服务器端

编写NIO服务端：
1、创建 SeverSockerChannel 对象
2、将 ServerSocketChannel 绑定到本机端口
3、将 ServerSocketChannel 设置为非阻塞模式
4、创建 Selector 选择器
5、将 ServerSocketChannel 注册到 Selector 选择器上并监听 SelectionKey.OP_ACCEPT 连接事件
6、轮询 selector 选择器，直到有事件准备就绪
7、对准备就绪的事件进行处理

  1. public class NioServer {
  3.     public void start() throws IOException {
  4.         // 1.创建Selector
  5.         Selector selector = Selector.open();
  7.         // 2.创建ServerSocketChannel
  8.         ServerSocketChannel serverSocketChannel = ServerSocketChannel.open();
  9.         // 3.绑定本地端口
  10.         serverSocketChannel.socket().bind(new InetSocketAddress(10000));
  11.         // 4.设置非阻塞模式
  12.         serverSocketChannel.configureBlocking(false);
  14.         // 5.将serverSocketChannel注册到Selector，并监听连接事件
  15.         serverSocketChannel.register(selector, SelectionKey.OP_ACCEPT);
  17.         // 6.循环监听并处理事件
  18.         while (true) {
  19.             // 阻塞方法：获取已经就绪的事件
  20.             int readyChannels = selector.select();
  22.             // 没有准备就绪的事件，跳过本轮循环
  23.             if (readyChannels == 0) {
  24.                 continue;
  25.             }
  27.             // 已经就绪的channel集合
  28.             Set<SelectionKey> selectionKeys = selector.selectedKeys();
  29.             // 获取迭代器
  30.             Iterator<SelectionKey> iterator = selectionKeys.iterator();
  31.             while (iterator.hasNext()) {
  32.                 // 获取一个selectKey实例
  33.                 SelectionKey selectionKey = iterator.next();
  35.                 // 移除selectKey实例，避免多次处理
  36.                 iterator.remove();
  38.                 // 7.根据就绪状态调用相应的处理逻辑
  39.                 // 连接事件就绪
  40.                 if (selectionKey.isAcceptable()) {
  41.                     acceptHandler(serverSocketChannel, selector);
  42.                 }
  44.                 // 可读事件就绪
  45.                 if (selectionKey.isReadable()) {
  46.                     readHandler(selectionKey, selector);
  47.                 }
  48.             }
  49.         }
  50.     }
  52.     private void acceptHandler(ServerSocketChannel serverSocketChannel, Selector selector) throws IOException {
  53.         // 获取相应客户端的SocketChannel
  54.         SocketChannel socketChannel = serverSocketChannel.accept();
  55.         // 将socketChannel设置为非阻塞模式
  56.         socketChannel.configureBlocking(false);
  57.         // 将socketChannel注册到selector上，监听可读事件
  58.         socketChannel.register(selector, SelectionKey.OP_READ);
  60.         // 回送客户端消息
  61.         socketChannel.write(StandardCharsets.UTF_8.encode("你与聊天室其他人都不是朋友关系，请注意隐私安全！"));
  62.     }
  64.     private void readHandler(SelectionKey selectionKey, Selector selector) throws IOException {
  65.         // 从SelectionKey中获取到已经就绪的channel
  66.         SocketChannel socketChannel = (SocketChannel) selectionKey.channel();
  68.         // 创建Buffer
  69.         ByteBuffer byteBuffer = ByteBuffer.allocate(1024);
  71.         // 循环读取客户端信息
  72.         StringBuilder read = new StringBuilder();
  73.         while (socketChannel.read(byteBuffer) > 0) {
  74.             // 切换为读模式
  75.             byteBuffer.flip();
  77.             // 进行读取
  78.             read.append(StandardCharsets.UTF_8.decode(byteBuffer));
  80.             // 清空缓冲区
  81.             byteBuffer.clear();
  82.         }
  84.         System.out.println(read);
  86.         // 将客户端发送的请求信息，广播给其他客户端
  87.         // Selector.keys()：获取所有注册的SelectionKey
  88.         for (SelectionKey key : selector.keys()) {
  89.             // 获取注册在select中的通道
  90.             SelectableChannel channel = key.channel();
  91.             // 如果为socketChannel
  92.             if (channel instanceof SocketChannel && channel != socketChannel) {
  93.                 // 向其他客户端发送此客户端发送的消息
  94.                 ((SocketChannel) channel).write(StandardCharsets.UTF_8.encode(read.toString()));
  95.             }
  96.         }
  97.     }
  99.     public static void main(String[] args) throws IOException {
  100.         NioServer nioServer = new NioServer();
  101.         nioServer.start();
  102.     }
  103. }

客户端

编写NIO客户端：
1、创建 SocketChannel 对象
2、设置当前客户端为非阻塞
3、连接远程服务器
4、创建 Selector 对象
5、将 SocketChannel 注册到 Selector 对象，并监听 SelectionKey.OP_READ 事件
6、轮询

  1. public class NioClient {
  2.     private SocketChannel socketChannel;
  4.     public NioClient(String host, Integer port) {
  5.         try {
  6.             // 1.创建SocketChannel
  7.             socketChannel = SocketChannel.open();
  8.             // 2.连接到服务端
  9.             socketChannel.socket().connect(new InetSocketAddress(host, port));
  10.             // 3.设置到非阻塞模式
  11.             socketChannel.configureBlocking(false);
  12.         } catch (IOException e) {
  13.             e.printStackTrace();
  14.         }
  15.     }
  17.     public void send(String msg) throws IOException {
  18.         socketChannel.write(StandardCharsets.UTF_8.encode(msg));
  19.     }
  21.     public void receive() {
  22.         new Thread(() -> {
  23.             try {
  24.                 Selector selector = Selector.open();
  25.                 socketChannel.register(selector, SelectionKey.OP_READ);
  27.                 while (true) {
  28.                     int counts = selector.select();
  29.                     if (counts == 0) {
  30.                         continue;
  31.                     }
  32.                     Iterator<SelectionKey> iterator = selector.selectedKeys().iterator();
  33.                     while (iterator.hasNext()) {
  34.                         // 获取SelectionKey
  35.                         SelectionKey selectionKey = iterator.next();
  36.                         // 删除已经处理的SelectionKey，避免重复处理
  37.                         iterator.remove();
  38.                         // 由于只绑定了一个SocketChannel且只监听OP_READ事件
  39.                         if (selectionKey.isReadable()) {
  40.                             ByteBuffer byteBuffer = ByteBuffer.allocate(1024);
  41.                             while (socketChannel.read(byteBuffer) > 0) {
  42.                                 // 将byteBuffer切换为读模式
  43.                                 byteBuffer.flip();
  45.                                 // 控制台打印服务端消息
  46.                                 System.out.println(StandardCharsets.UTF_8.decode(byteBuffer));
  48.                                 // 清空byteBuffer
  49.                                 byteBuffer.clear();
  50.                             }
  51.                         }
  52.                     }
  53.                 }
  54.             } catch (IOException e) {
  55.                 e.printStackTrace();
  56.             }
  57.         }).start();
  58.     }
  60.     public static void main(String[] args) {
  61.         NioClient nioClient = new NioClient("127.0.0.1", 10000);
  62.         // 客户端接受消息
  63.         nioClient.receive();
  65.         Scanner scanner = new Scanner(System.in);
  66.         while (true) {
  67.             System.out.println("请输入要发送的信息：");
  68.             String msg = scanner.nextLine();
  69.             if ("close".equalsIgnoreCase(msg)) break;
  71.             try {
  72.                 nioClient.send(msg);
  73.             } catch (IOException e) {
  74.                 e.printStackTrace();
  75.             }
  76.         }
  77.     }
  78. }