image.png

NioServer.java

  1. package io.torey.niotest;
  3. import java.io.IOException;
  4. import java.net.InetSocketAddress;
  5. import java.nio.ByteBuffer;
  6. import java.nio.channels.*;
  7. import java.nio.charset.Charset;
  8. import java.util.Iterator;
  9. import java.util.Set;
  11. /**
  12.  * NIO服务器端
  13.  */
  14. public class NioServer {
  15.     public static void main(String[] args){
  16.         NioServer nioServer = new NioServer();
  17.         try {
  18.             nioServer.start();
  19.         } catch (IOException e) {
  20.             e.printStackTrace();
  21.         }
  22.     }
  24.     /**
  25.      * 启动
  26.      */
  27.     public void start() throws IOException{
  28.         //1 创建Selector
  29.         //2 通过ServerSocketChannel创建channel通道
  30.         //3 为channel通道绑定监听端口
  31.         //4 重点：设置channel为非阻塞模式
  32.         //5 将channel注册到selector上，监听连接事件
  33.         //6 循环等待新接入的连接
  34.         //7 根据就绪状态，调用对应方法处理业务逻辑
  37.         //1 创建Selector
  38.         Selector selector = Selector.open();
  39.         //2 通过ServerSocketChannel创建channel通道
  40.         ServerSocketChannel serverSocketChannel= ServerSocketChannel.open();
  41.         //3 为channel通道绑定监听端口
  42.         serverSocketChannel.bind(new InetSocketAddress(8000));
  43.         //4 重点：设置channel为非阻塞模式
  44.         serverSocketChannel.configureBlocking(false);
  45.         //5 将channel注册到selector上，监听连接事件
  46.         serverSocketChannel.register(selector,SelectionKey.OP_ACCEPT);
  47.         System.out.println("服务器启动成功!!");
  48.         //6 循环等待新接入的连接
  49.         while (true) {
  50.             //这个方法是阻塞方法，获取可用的channel数量
  51.             int readyChannels= selector.select();
  52.             if (readyChannels==0) {
  53.                 continue;
  54.             }
  55.             //获取可用channel的集合
  56.             Set<SelectionKey> selectionKeys = selector.selectedKeys();
  57.             Iterator<SelectionKey> iterator = selectionKeys.iterator();
  58.             while (iterator.hasNext()) {
  59.                 //selectionKey的实例
  60.                 SelectionKey selectionKey = iterator.next();
  61.                 //移除Set中当前的selectionKey，重点
  62.                 iterator.remove();
  63.                 //7 根据就绪状态，调用对应方法处理业务逻辑
  64.                 //如果是 接入事件
  65.                 if (selectionKey.isAcceptable()) {
  66.                     acceptHandler(serverSocketChannel,selector);
  67.                 }
  68.                 //如果是 可读事件
  69.                 if (selectionKey.isReadable()) {
  70.                     readHandler(selectionKey,selector);
  71.                 }
  72.             }
  73.         }
  74.     }
  76.     /**
  77.      * 接入事件处理器
  78.      * @param serverSocketChannel
  79.      * @param selector
  80.      * @throws IOException
  81.      */
  82.     private void acceptHandler(ServerSocketChannel serverSocketChannel,Selector selector) throws IOException{
  83.         //如果要是接入事件，创建socketChannel
  84.         //将socketChannel设置为非阻塞工作模式
  85.         //将channel注册到selector上，监听 可读事件
  86.         //回复客户端提示信息
  88.         System.out.println("有一个客户端进来了...");
  89.         //如果要是接入事件，创建socketChannel
  90.         SocketChannel socketChannel = serverSocketChannel.accept();
  91.         //将socketChannel设置为非阻塞工作模式
  92.         socketChannel.configureBlocking(false);
  93.         //将channel注册到selector上，监听 可读事件
  94.         socketChannel.register(selector,SelectionKey.OP_READ);
  95.         //回复客户端提示信息
  96.         socketChannel.write(Charset.forName("UTF-8")
  97.                 .encode("你与聊天室里其他人都不是朋友关系，请注意隐私安全!!"));
  98.     }
  100.     /**
  101.      * 可读事件处理器
  102.      */
  103.     private void readHandler(SelectionKey selectionKey,Selector selector) throws IOException{
  104.         //要从selectionKey中获取到已经就绪的channel
  105.         //创建buffer
  106.         //循环读取客户端请求信息
  107.         //将channel再次注册到selector上，监听他的可读事件
  108.         //将客户端发送的请求信息，广播给其他客户端
  110.         //要从selectionKey中获取到已经就绪的channel
  111.         SocketChannel socketChannel= (SocketChannel)selectionKey.channel();
  112.         //创建buffer
  113.         ByteBuffer byteBuffer = ByteBuffer.allocate(1024);
  114.         //循环读取客户端请求信息
  115.         StringBuilder reques=new StringBuilder();
  116.         while (socketChannel.read(byteBuffer) > 0) {
  117.             //切换buffer为读模式
  118.             byteBuffer.flip();
  119.             //读取buffer中的内容
  120.             reques.append(Charset.forName("UTF-8").decode(byteBuffer));
  121.         }
  122.         //将channel再次注册到selector上，监听他的可读事件
  123.         socketChannel.register(selector,SelectionKey.OP_READ);
  124.         //将客户端发送的请求信息，广播给其他客户端
  125.         if (reques.length()>0) {
  126.             System.out.println("收到客户端消息:"+reques.toString());
  127.         }
  128.     }
  129. }
  130. package io.torey.niotest;
  132. import java.io.IOException;
  133. import java.net.InetSocketAddress;
  134. import java.nio.ByteBuffer;
  135. import java.nio.channels.*;
  136. import java.nio.charset.Charset;
  137. import java.util.Iterator;
  138. import java.util.Set;
  140. /**
  141.  * NIO服务器端
  142.  */
  143. public class NioServer {
  144.     public static void main(String[] args){
  145.         NioServer nioServer = new NioServer();
  146.         try {
  147.             nioServer.start();
  148.         } catch (IOException e) {
  149.             e.printStackTrace();
  150.         }
  151.     }
  153.     /**
  154.      * 启动
  155.      */
  156.     public void start() throws IOException{
  157.         //1 创建Selector
  158.         //2 通过ServerSocketChannel创建channel通道
  159.         //3 为channel通道绑定监听端口
  160.         //4 重点：设置channel为非阻塞模式
  161.         //5 将channel注册到selector上，监听连接事件
  162.         //6 循环等待新接入的连接
  163.         //7 根据就绪状态，调用对应方法处理业务逻辑
  166.         //1 创建Selector
  167.         Selector selector = Selector.open();
  168.         //2 通过ServerSocketChannel创建channel通道
  169.         ServerSocketChannel serverSocketChannel= ServerSocketChannel.open();
  170.         //3 为channel通道绑定监听端口
  171.         serverSocketChannel.bind(new InetSocketAddress(8000));
  172.         //4 重点：设置channel为非阻塞模式
  173.         serverSocketChannel.configureBlocking(false);
  174.         //5 将channel注册到selector上，监听连接事件
  175.         serverSocketChannel.register(selector,SelectionKey.OP_ACCEPT);
  176.         System.out.println("服务器启动成功!!");
  177.         //6 循环等待新接入的连接
  178.         while (true) {
  179.             //这个方法是阻塞方法，获取可用的channel数量
  180.             int readyChannels= selector.select();
  181.             if (readyChannels==0) {
  182.                 continue;
  183.             }
  184.             //获取可用channel的集合
  185.             Set<SelectionKey> selectionKeys = selector.selectedKeys();
  186.             Iterator<SelectionKey> iterator = selectionKeys.iterator();
  187.             while (iterator.hasNext()) {
  188.                 //selectionKey的实例
  189.                 SelectionKey selectionKey = iterator.next();
  190.                 //移除Set中当前的selectionKey，重点
  191.                 iterator.remove();
  192.                 //7 根据就绪状态，调用对应方法处理业务逻辑
  193.                 //如果是 接入事件
  194.                 if (selectionKey.isAcceptable()) {
  195.                     acceptHandler(serverSocketChannel,selector);
  196.                 }
  197.                 //如果是 可读事件
  198.                 if (selectionKey.isReadable()) {
  199.                     readHandler(selectionKey,selector);
  200.                 }
  201.             }
  202.         }
  203.     }
  205.     /**
  206.      * 接入事件处理器
  207.      * @param serverSocketChannel
  208.      * @param selector
  209.      * @throws IOException
  210.      */
  211.     private void acceptHandler(ServerSocketChannel serverSocketChannel,Selector selector) throws IOException{
  212.         //如果要是接入事件，创建socketChannel
  213.         //将socketChannel设置为非阻塞工作模式
  214.         //将channel注册到selector上，监听 可读事件
  215.         //回复客户端提示信息
  217.         System.out.println("有一个客户端进来了...");
  218.         //如果要是接入事件，创建socketChannel
  219.         SocketChannel socketChannel = serverSocketChannel.accept();
  220.         //将socketChannel设置为非阻塞工作模式
  221.         socketChannel.configureBlocking(false);
  222.         //将channel注册到selector上，监听 可读事件
  223.         socketChannel.register(selector,SelectionKey.OP_READ);
  224.         //回复客户端提示信息
  225.         socketChannel.write(Charset.forName("UTF-8")
  226.                 .encode("你与聊天室里其他人都不是朋友关系，请注意隐私安全!!"));
  227.     }
  229.     /**
  230.      * 可读事件处理器
  231.      */
  232.     private void readHandler(SelectionKey selectionKey,Selector selector) throws IOException{
  233.         //要从selectionKey中获取到已经就绪的channel
  234.         //创建buffer
  235.         //循环读取客户端请求信息
  236.         //将channel再次注册到selector上，监听他的可读事件
  237.         //将客户端发送的请求信息，广播给其他客户端
  239.         //要从selectionKey中获取到已经就绪的channel
  240.         SocketChannel socketChannel= (SocketChannel)selectionKey.channel();
  241.         //创建buffer
  242.         ByteBuffer byteBuffer = ByteBuffer.allocate(1024);
  243.         //循环读取客户端请求信息
  244.         StringBuilder reques=new StringBuilder();
  245.         while (socketChannel.read(byteBuffer) > 0) {
  246.             //切换buffer为读模式
  247.             byteBuffer.flip();
  248.             //读取buffer中的内容
  249.             reques.append(Charset.forName("UTF-8").decode(byteBuffer));
  250.         }
  251.         //将channel再次注册到selector上，监听他的可读事件
  252.         socketChannel.register(selector,SelectionKey.OP_READ);
  253.         //将客户端发送的请求信息，广播给其他客户端
  254.         if (reques.length()>0) {
  255.             System.out.println("收到客户端消息:"+reques.toString());
  256.         }
  257.     }
  258. }

NioClientHandler.java

  1. package io.torey.niotest;
  3. import java.io.IOException;
  4. import java.net.InetSocketAddress;
  5. import java.nio.ByteBuffer;
  6. import java.nio.channels.SelectionKey;
  7. import java.nio.channels.Selector;
  8. import java.nio.channels.ServerSocketChannel;
  9. import java.nio.channels.SocketChannel;
  10. import java.nio.charset.Charset;
  11. import java.util.Iterator;
  12. import java.util.Set;
  14. /**
  15.  * 服务器端线程类，专门接收服务器端响应
  16.  */
  17. public class NioClientHandler implements Runnable {
  18.     private Selector selector;
  20.     public NioClientHandler(Selector selector) {
  21.         this.selector = selector;
  22.     }
  24.     @Override
  25.     public void run() {
  26.         try{
  27.         while (true) {
  28.             //这个方法是阻塞方法，获取可用的channel数量
  29.             int readyChannels= selector.select();
  30.             if (readyChannels==0) {
  31.                 continue;
  32.             }
  33.             //获取可用channel的集合
  34.             Set<SelectionKey> selectionKeys = selector.selectedKeys();
  35.             Iterator<SelectionKey> iterator = selectionKeys.iterator();
  36.             while (iterator.hasNext()) {
  37.                 //selectionKey的实例
  38.                 SelectionKey selectionKey = iterator.next();
  39.                 //移除Set中当前的selectionKey，重点
  40.                 iterator.remove();
  41.                 //7 根据就绪状态，调用对应方法处理业务逻辑
  42.                 //如果是 可读事件
  43.                 if (selectionKey.isReadable()) {
  44.                     readHandler(selectionKey,selector);
  45.                 }
  46.             }
  47.         }}catch (Exception ex){
  48.             ex.printStackTrace();
  49.         }
  50.     }
  51.     /**
  52.      * 可读事件处理器
  53.      */
  54.     private void readHandler(SelectionKey selectionKey,Selector selector) throws IOException {
  55.         //要从selectionKey中获取到已经就绪的channel
  56.         //创建buffer
  57.         //循环读取服务器端请求信息
  58.         //将channel再次注册到selector上，监听他的可读事件
  59.         //将服务器端发送的请求信息，广播给其他服务器端
  61.         //要从selectionKey中获取到已经就绪的channel
  62.         SocketChannel socketChannel= (SocketChannel)selectionKey.channel();
  63.         //创建buffer
  64.         ByteBuffer byteBuffer = ByteBuffer.allocate(1024);
  65.         //循环读取服务器端请求信息
  66.         StringBuilder response=new StringBuilder();
  67.         while (socketChannel.read(byteBuffer) > 0) {
  68.             //切换buffer为读模式
  69.             byteBuffer.flip();
  70.             //读取buffer中的内容
  71.             response.append(Charset.forName("UTF-8").decode(byteBuffer));
  72.         }
  73.         //将channel再次注册到selector上，监听他的可读事件
  74.         socketChannel.register(selector,SelectionKey.OP_READ);
  75.         //将服务器端发送的请求信息，打印到本地
  76.         if (response.length()>0) {
  77.             System.out.println("收到服务器端消息:"+response.toString());
  78.         }
  79.     }
  80. }

NioServer.java

  1. package io.torey.niotest;
  3. import java.io.IOException;
  4. import java.net.InetSocketAddress;
  5. import java.nio.ByteBuffer;
  6. import java.nio.channels.*;
  7. import java.nio.charset.Charset;
  8. import java.util.Iterator;
  9. import java.util.Set;
  11. /**
  12.  * NIO服务器端
  13.  */
  14. public class NioServer {
  15.     public static void main(String[] args){
  16.         NioServer nioServer = new NioServer();
  17.         try {
  18.             nioServer.start();
  19.         } catch (IOException e) {
  20.             e.printStackTrace();
  21.         }
  22.     }
  24.     /**
  25.      * 启动
  26.      */
  27.     public void start() throws IOException{
  28.         //1 创建Selector
  29.         //2 通过ServerSocketChannel创建channel通道
  30.         //3 为channel通道绑定监听端口
  31.         //4 重点：设置channel为非阻塞模式
  32.         //5 将channel注册到selector上，监听连接事件
  33.         //6 循环等待新接入的连接
  34.         //7 根据就绪状态，调用对应方法处理业务逻辑
  37.         //1 创建Selector
  38.         Selector selector = Selector.open();
  39.         //2 通过ServerSocketChannel创建channel通道
  40.         ServerSocketChannel serverSocketChannel= ServerSocketChannel.open();
  41.         //3 为channel通道绑定监听端口
  42.         serverSocketChannel.bind(new InetSocketAddress(8000));
  43.         //4 重点：设置channel为非阻塞模式
  44.         serverSocketChannel.configureBlocking(false);
  45.         //5 将channel注册到selector上，监听连接事件
  46.         serverSocketChannel.register(selector,SelectionKey.OP_ACCEPT);
  47.         System.out.println("服务器启动成功!!");
  48.         //6 循环等待新接入的连接
  49.         while (true) {
  50.             //这个方法是阻塞方法，获取可用的channel数量
  51.             int readyChannels= selector.select();
  52.             if (readyChannels==0) {
  53.                 continue;
  54.             }
  55.             //获取可用channel的集合
  56.             Set<SelectionKey> selectionKeys = selector.selectedKeys();
  57.             Iterator<SelectionKey> iterator = selectionKeys.iterator();
  58.             while (iterator.hasNext()) {
  59.                 //selectionKey的实例
  60.                 SelectionKey selectionKey = iterator.next();
  61.                 //移除Set中当前的selectionKey，重点
  62.                 iterator.remove();
  63.                 //7 根据就绪状态，调用对应方法处理业务逻辑
  64.                 //如果是 接入事件
  65.                 if (selectionKey.isAcceptable()) {
  66.                     acceptHandler(serverSocketChannel,selector);
  67.                 }
  68.                 //如果是 可读事件
  69.                 if (selectionKey.isReadable()) {
  70.                     readHandler(selectionKey,selector);
  71.                 }
  72.             }
  73.         }
  74.     }
  76.     /**
  77.      * 接入事件处理器
  78.      * @param serverSocketChannel
  79.      * @param selector
  80.      * @throws IOException
  81.      */
  82.     private void acceptHandler(ServerSocketChannel serverSocketChannel,Selector selector) throws IOException{
  83.         //如果要是接入事件，创建socketChannel
  84.         //将socketChannel设置为非阻塞工作模式
  85.         //将channel注册到selector上，监听 可读事件
  86.         //回复客户端提示信息
  88.         System.out.println("有一个客户端进来了...");
  89.         //如果要是接入事件，创建socketChannel
  90.         SocketChannel socketChannel = serverSocketChannel.accept();
  91.         //将socketChannel设置为非阻塞工作模式
  92.         socketChannel.configureBlocking(false);
  93.         //将channel注册到selector上，监听 可读事件
  94.         socketChannel.register(selector,SelectionKey.OP_READ);
  95.         //回复客户端提示信息
  96.         socketChannel.write(Charset.forName("UTF-8")
  97.                 .encode("你与聊天室里其他人都不是朋友关系，请注意隐私安全!!"));
  98.     }
  100.     /**
  101.      * 可读事件处理器
  102.      */
  103.     private void readHandler(SelectionKey selectionKey,Selector selector) throws IOException{
  104.         //要从selectionKey中获取到已经就绪的channel
  105.         //创建buffer
  106.         //循环读取客户端请求信息
  107.         //将channel再次注册到selector上，监听他的可读事件
  108.         //将客户端发送的请求信息，广播给其他客户端
  110.         //要从selectionKey中获取到已经就绪的channel
  111.         SocketChannel socketChannel= (SocketChannel)selectionKey.channel();
  112.         //创建buffer
  113.         ByteBuffer byteBuffer = ByteBuffer.allocate(1024);
  114.         //循环读取客户端请求信息
  115.         StringBuilder reques=new StringBuilder();
  116.         while (socketChannel.read(byteBuffer) > 0) {
  117.             //切换buffer为读模式
  118.             byteBuffer.flip();
  119.             //读取buffer中的内容
  120.             reques.append(Charset.forName("UTF-8").decode(byteBuffer));
  121.         }
  122.         //将channel再次注册到selector上，监听他的可读事件
  123.         socketChannel.register(selector,SelectionKey.OP_READ);
  124.         //将客户端发送的请求信息，广播给其他客户端
  125.         if (reques.length()>0) {
  126.             System.out.println("收到客户端消息:"+reques.toString());
  127.         }
  128.     }
  129. }

测试截图

  1. 先开启 服务器端
  2. 在开启 客户端

image.png
image.png