NIO通信架构图
1.Client
NioClient
package nio;
import constant.Constant;
import java.io.IOException;
import java.util.Scanner;
public class NioClient {
private static NioClientHandle nioClientHandle;
public static void start() {
nioClientHandle = new NioClientHandle(Constant.DEFAULT_SERVER_IP, Constant.DEFAULT_PORT);
new Thread(nioClientHandle, "Client").start();
}
// 向服务器发送消息
public static boolean sendMsg(String msg) throws IOException {
nioClientHandle.sendMsg(msg);
return true;
}
public static void main(String[] args) throws IOException {
start();
Scanner scanner = new Scanner(System.in);
while (NioClient.sendMsg(scanner.next()));
}
}
NioClientHandle
package nio;
import java.io.IOException;
import java.net.InetSocketAddress;
import java.nio.ByteBuffer;
import java.nio.channels.SelectionKey;
import java.nio.channels.Selector;
import java.nio.channels.SocketChannel;
import java.util.Iterator;
import java.util.Set;
public class NioClientHandle implements Runnable {
private String host;
private int port;
private volatile boolean started;
private Selector selector;
private SocketChannel socketChannel;
public NioClientHandle(String ip, int port) {
this.host = ip;
this.port = port;
try {
// 创建选择器的实例
selector = Selector.open();
// 创建ServerSocketChannel的实例
socketChannel = SocketChannel.open();
// 设置通道为非阻塞模式
socketChannel.configureBlocking(false);
started = true;
} catch (Exception e) {
e.printStackTrace();
}
}
public void stop() {
started = false;
}
@Override
public void run() {
try {
doConnect();
} catch (Exception e) {
e.printStackTrace();
System.exit(1);
}
// 循环遍历selector
while (started) {
try {
// 无论是否有读写事件发生，selector每隔1s被唤醒一次
selector.select(1000);
// 获取当前有哪些事件可以使用
Set<SelectionKey> keys = selector.selectedKeys();
// 转换为迭代器
Iterator<SelectionKey> it = keys.iterator();
SelectionKey key = null;
while (it.hasNext()) {
key = it.next();
// 我们必须受限将处理过的SelectionKey从选定的集合中删除
// 如果我们没有删除处理过的键，那么它仍然会在主集合中以一个激活的键
// 出现，这会导致我们尝试再次处理它
it.remove();
try {
handleInput(key);
} catch (Exception e) {
if (key != null) {
key.cancel();
if (key.channel() != null) {
key.channel().close();
}
}
}
}
} catch (Exception e) {
e.printStackTrace();
System.exit(1);
}
}
// selector关闭后会自动释放里面管理的资源
if (selector != null) {
try {
selector.close();
} catch (Exception e) {
e.printStackTrace();
}
}
}
/**
* 具体的事件处理方法
* @param key
*/
private void handleInput(SelectionKey key) throws IOException {
if (key.isValid()) {
// 获得关心当前事件的channel
SocketChannel sc = (SocketChannel)key.channel();
// 连接事件
if (key.isConnectable()) {
if (sc.finishConnect()) {
socketChannel.register(selector, SelectionKey.OP_READ);
} else {
System.exit(1);
}
}
// 有数据可读事件
if (key.isReadable()) {
// 创建ByteBuffer,并开启一个1M的缓冲区
ByteBuffer buffer = ByteBuffer.allocate(1024);
// 读取数据码流 返回读取到的字节数
int readBytes = sc.read(buffer);
// 读取到字节 对字节进行编解码
if (readBytes > 0) {
//将缓冲区当前的limit设置为position, position = 0;
// 用于后续对缓冲区的读取操作
buffer.flip();
// 根据缓冲区可读字节数创建字节数组
byte[] bytes = new byte[buffer.remaining()];
// 将缓冲区可读字节数组复制到新建的数组中
buffer.get(bytes);
String result = new String(bytes, "UTF-8");
System.out.println("客户端收到消息:" + result);
} else if (readBytes < 0) {
key.cancel();
sc.close();
}
}
}
}
public void sendMsg(String msg) throws IOException {
doWrite(socketChannel, msg);
}
private void doWrite(SocketChannel socketChannel, String request) throws IOException {
// 将消息编码为字节数组
byte[] bytes = request.getBytes();
// 根据数组容量创建ByteBuffer
ByteBuffer writeBuffer = ByteBuffer.allocate(bytes.length);
// 将字节数组复制到缓冲区
writeBuffer.put(bytes);
// flip操作
writeBuffer.flip();
// 发送缓冲区的字节数组
// 关心事件和读写网络不冲突
socketChannel.write(writeBuffer);
}
private void doConnect() throws IOException {
// 非阻塞的连接
if (socketChannel.connect(new InetSocketAddress(host, port))) {
socketChannel.register(selector, SelectionKey.OP_READ);
} else {
socketChannel.register(selector, SelectionKey.OP_CONNECT);
}
}
}
2.Server
NioServer
package nio;
import constant.Constant;
public class NioServer {
private static NioServerHandle nioServerHandle;
public static void main(String[] args) {
nioServerHandle = new NioServerHandle(Constant.DEFAULT_PORT);
new Thread(nioServerHandle, "Server").start();
}
}
NioServerHandle
package nio;
import constant.Constant;
import java.io.IOException;
import java.net.InetSocketAddress;
import java.nio.ByteBuffer;
import java.nio.channels.SelectionKey;
import java.nio.channels.Selector;
import java.nio.channels.ServerSocketChannel;
import java.nio.channels.SocketChannel;
import java.util.Iterator;
import java.util.Set;
public class NioServerHandle implements Runnable {
private volatile boolean started;
private ServerSocketChannel serverSocketChannel;
private Selector selector;
public NioServerHandle(int port) {
try {
// 创建选择器实例
selector = Selector.open();
// 创建ServerSocketChannel的实例
serverSocketChannel = ServerSocketChannel.open();
// 设置通道为非阻塞模式
serverSocketChannel.configureBlocking(false);
// 绑定端口
serverSocketChannel.socket().bind(new InetSocketAddress(port));
// 注册事件，表示关心客户端连接
serverSocketChannel.register(selector, SelectionKey.OP_ACCEPT);
//
started = true;
System.out.println("服务器已启动, 端口号为:" + port);
} catch (Exception e) {
e.printStackTrace();
}
}
@Override
public void run() {
while (started) {
try {
// 获取当前有哪些事件
selector.select(1000);
// 获取事件的集合
Set<SelectionKey> selectionKeys = selector.selectedKeys();
Iterator<SelectionKey> iterator = selectionKeys.iterator();
while (iterator.hasNext()) {
SelectionKey key = iterator.next();
// 我们必须首先将处理过的SelectionKey 从选定的键集合中删除
// 如果我们没有删除处理过的键，那么它仍然会在主集合中以
// 一个激活的键出现，这回导致我们尝试再次处理它
iterator.remove();
handleInput(key);
}
} catch (Exception e) {
}
}
}
/**
* 处理事件的发生
* @param key
*/
private void handleInput(SelectionKey key) throws IOException {
if (key.isValid()) {
// 处理新接入的客户端的请求
if (key.isAcceptable()) {
// 获取关心当前事件的Channel
ServerSocketChannel ssc = (ServerSocketChannel)key.channel();
// 接受连接
SocketChannel sc = ssc.accept();
System.out.println("=========建立连接=========");
sc.configureBlocking(false);
// 关注读事件
sc.register(selector, SelectionKey.OP_READ);
}
// 处理对端的发送的数据
if (key.isReadable()) {
SocketChannel sc = (SocketChannel) key.channel();
// 创建ByteBuffer, 开辟一个缓冲区
ByteBuffer buffer = ByteBuffer.allocate(1024);
// 从通道里读取数据，然后写入buffer
int readBytes = sc.read(buffer);
if (readBytes > 0) {
// 将缓冲区当前的limit设置为position, position = 0
// 用于后续对缓冲区的读取操作
buffer.flip();
// 根据缓冲区可读字节数创建字节数组
byte[] bytes = new byte[buffer.remaining()];
// 将缓冲区可读字节数组复制到新建的数组中
buffer.get(bytes);
String message = new String(bytes, "UTF-8");
System.out.println("服务器收到消息:" + message);
// 处理数据
String result = Constant.response(message);
// 发送应答消息
doWrite(sc, result);
}
}
}
}
private void doWrite(SocketChannel sc, String response) throws IOException {
byte[] bytes = response.getBytes();
ByteBuffer buffer = ByteBuffer.allocate(bytes.length);
buffer.put(bytes);
buffer.flip();
sc.write(buffer);
}
}
3.代码运行实例
先启动server再启动client
![LeetCode[105] 从前序与中序遍历序列构造二叉树](https://img-blog.csdnimg.cn/img_convert/7734f2d365035a4069006c67e7c1efb9.jpeg)