面试题答案
一键面试Java NIO相比于传统IO在微服务间网络通信的优势
- 非阻塞I/O：
- 传统IO是阻塞式的，在进行读写操作时，线程会被阻塞，直到操作完成。例如，在读取网络数据时，如果数据未到达，线程会一直等待，这会造成线程资源的浪费。
- NIO是非阻塞的，线程可以在I/O操作进行时去做其他事情，提高了线程的利用率。比如在一个微服务中有多个网络连接需要处理时，使用NIO可以让一个线程处理多个连接，而传统IO每个连接可能都需要一个线程来处理。
- 基于缓冲区：
- 传统IO是面向流的，数据是按顺序一个字节一个字节地处理。
- NIO使用缓冲区（Buffer）来处理数据，数据可以批量地读入或写出缓冲区，提高了数据处理效率。例如在网络通信中，可以一次性从缓冲区读取大量数据，而不是一个字节一个字节地读取。
- 选择器（Selector）：
- 传统IO没有选择器的概念，无法高效地管理多个连接。
- NIO的选择器可以管理多个通道（Channel），通过它可以监听多个通道的事件（如连接就绪、数据可读等）。在微服务中，一个线程通过选择器可以同时处理多个微服务间的连接，大大减少了线程数量，降低了系统开销。
利用Java NIO的Channel和Buffer构建简单微服务通信模块
1. 处理连接建立
以服务端为例，使用ServerSocketChannel来监听连接：
import java.io.IOException;
import java.net.InetSocketAddress;
import java.nio.channels.ServerSocketChannel;
import java.nio.channels.SocketChannel;
public class NioServer {
public static void main(String[] args) {
try (ServerSocketChannel serverSocketChannel = ServerSocketChannel.open()) {
serverSocketChannel.bind(new InetSocketAddress(8888));
serverSocketChannel.configureBlocking(false);
while (true) {
SocketChannel socketChannel = serverSocketChannel.accept();
if (socketChannel != null) {
System.out.println("新连接: " + socketChannel.getRemoteAddress());
socketChannel.configureBlocking(false);
// 可以将新连接的socketChannel注册到Selector进行后续处理
}
}
} catch (IOException e) {
e.printStackTrace();
}
}
}
在客户端，使用SocketChannel来发起连接：
import java.io.IOException;
import java.net.InetSocketAddress;
import java.nio.channels.SocketChannel;
public class NioClient {
public static void main(String[] args) {
try (SocketChannel socketChannel = SocketChannel.open()) {
socketChannel.connect(new InetSocketAddress("localhost", 8888));
socketChannel.configureBlocking(false);
System.out.println("连接到服务端");
} catch (IOException e) {
e.printStackTrace();
}
}
}
2. 数据读写操作
服务端数据读取和写入示例：
import java.io.IOException;
import java.nio.ByteBuffer;
import java.nio.channels.SocketChannel;
public class NioServerHandler {
public static void handle(SocketChannel socketChannel) {
ByteBuffer buffer = ByteBuffer.allocate(1024);
try {
int readBytes = socketChannel.read(buffer);
if (readBytes > 0) {
buffer.flip();
byte[] data = new byte[readBytes];
buffer.get(data);
String message = new String(data);
System.out.println("收到消息: " + message);
buffer.clear();
String response = "Message received: " + message;
buffer.put(response.getBytes());
buffer.flip();
socketChannel.write(buffer);
}
} catch (IOException e) {
e.printStackTrace();
}
}
}
客户端数据写入和读取示例：
import java.io.IOException;
import java.nio.ByteBuffer;
import java.nio.channels.SocketChannel;
public class NioClientHandler {
public static void handle(SocketChannel socketChannel) {
ByteBuffer buffer = ByteBuffer.wrap("Hello, Server!".getBytes());
try {
socketChannel.write(buffer);
buffer.clear();
int readBytes = socketChannel.read(buffer);
if (readBytes > 0) {
buffer.flip();
byte[] data = new byte[readBytes];
buffer.get(data);
String message = new String(data);
System.out.println("收到服务端响应: " + message);
}
} catch (IOException e) {
e.printStackTrace();
}
}
}
在实际应用中，通常会结合选择器（Selector）来管理多个通道，实现更高效的网络通信处理。例如：
import java.io.IOException;
import java.nio.ByteBuffer;
import java.nio.channels.*;
import java.util.Iterator;
import java.util.Set;
public class NioSelectorServer {
public static void main(String[] args) {
try (ServerSocketChannel serverSocketChannel = ServerSocketChannel.open();
Selector selector = Selector.open()) {
serverSocketChannel.bind(new InetSocketAddress(8888));
serverSocketChannel.configureBlocking(false);
serverSocketChannel.register(selector, SelectionKey.OP_ACCEPT);
while (true) {
selector.select();
Set<SelectionKey> selectedKeys = selector.selectedKeys();
Iterator<SelectionKey> keyIterator = selectedKeys.iterator();
while (keyIterator.hasNext()) {
SelectionKey key = keyIterator.next();
if (key.isAcceptable()) {
ServerSocketChannel server = (ServerSocketChannel) key.channel();
SocketChannel client = server.accept();
client.configureBlocking(false);
client.register(selector, SelectionKey.OP_READ);
} else if (key.isReadable()) {
SocketChannel client = (SocketChannel) key.channel();
ByteBuffer buffer = ByteBuffer.allocate(1024);
int readBytes = client.read(buffer);
if (readBytes > 0) {
buffer.flip();
byte[] data = new byte[readBytes];
buffer.get(data);
String message = new String(data);
System.out.println("收到消息: " + message);
buffer.clear();
String response = "Message received: " + message;
buffer.put(response.getBytes());
buffer.flip();
client.write(buffer);
}
}
keyIterator.remove();
}
}
} catch (IOException e) {
e.printStackTrace();
}
}
}
这样就利用Java NIO的Channel和Buffer构建了一个简单的微服务通信模块，涵盖了连接建立和数据读写操作。