>> 欢迎您 客人: 登录 | 注册 | 在线 | 搜索 | 风格 | 帮助 | 统计 | 文章 返回首页
>>分享Java编程技术，对《Java面向对象编程》等书籍提供技术支持 书籍支持  卫琴直播  品书摘要  在线测试  资源下载  联系我们
Java技术网站 → 『 Java开发技术 』 → 『 Java编程技术专题 』 → java NIO示例以及流程详解
发表一个新主题 开启一个新投票 回复文章 您是本文章第 21451 个阅读者 刷新本主题
 * 贴子主题:  java NIO示例以及流程详解 回复文章 点赞(0)  收藏  
作者:flybird    发表时间：2020-02-06 16:36:31     消息  查看  搜索  好友  邮件  复制  引用
  
                                                                                                                                                                                                                                     服务端：        
  1.       package nio;
  3.       import org.springframework.util.StringUtils;
  5.       import java.io.IOException;
  6.       import java.net.InetSocketAddress;
  7.       import java.nio.ByteBuffer;
  8.       import java.nio.channels.SelectionKey;
  9.       import java.nio.channels.Selector;
  10.       import java.nio.channels.ServerSocketChannel;
  11.       import java.nio.channels.SocketChannel;
  12.       import java.util.Date;
  13.       import java.util.Iterator;
  14.       import java.util.Set;
  16.       public   class  ServerSocketChannels  implements  Runnable {
  18.           private  ServerSocketChannel serverSocketChannel;
  20.           private  Selector selector;
  22.           private  volatile  boolean stop;
  25.            public  ServerSocketChannels ( int port){
  27.               try {
  28.                   //创建多路复用器selector，工厂方法
  29.                  selector = Selector.open();
  30.                   //创建ServerSocketChannel，工厂方法
  31.                  serverSocketChannel = ServerSocketChannel.open();
  32.                   //绑定ip和端口号，默认的IP=127.0.0.1，对连接的请求最大队列长度设置为backlog=1024，如果队列满时收到连接请求，则拒绝连接
  33.                  serverSocketChannel.socket().bind( new InetSocketAddress(port),  1024);
  34.                   //设置非阻塞方式
  35.                  serverSocketChannel.configureBlocking( false);
  36.                   //注册serverSocketChannel到selector多路服用器上面，监听accrpt请求
  37.                  serverSocketChannel.register(selector, SelectionKey.OP_ACCEPT);
  38.                  System.out.println( "the time is start port = " + port);
  39.              }  catch (IOException e) {
  40.                  e.printStackTrace();
  41.                  System.exit( 1);
  42.              }
  43.          }
  45.            public  void  stop (){
  46.               this.stop =  true;
  47.          }
  49.           @Override
  50.            public  void  run () {
  51.               //如果server没有停止
  52.               while(!stop){
  53.                   try {
  54.                       //selector.select()会一直阻塞到有一个通道在你注册的事件上就绪了
  55.                       //selector.select(1000)会阻塞到1s后然后接着执行，相当于1s轮询检查
  56.                      selector.select( 1000);
  57.                       //找到所有准备接续的key
  58.                      Set<SelectionKey> selectionKeys = selector.selectedKeys();
  59.                      Iterator<SelectionKey> it = selectionKeys.iterator();
  60.                      SelectionKey key =  null;
  61.                      while(it.hasNext()){
  62.                         key = it.next();
  63.                         it.remove();
  64.                          try {
  65.                              //处理准备就绪的key
  66.                             handle(key);
  67.                         } catch (Exception e){
  68.                              if(key !=  null){
  69.                                  //请求取消此键的通道到其选择器的注册
  70.                                 key.cancel();
  71.                                  //关闭这个通道
  72.                                  if(key.channel() !=  null){
  73.                                     key.channel().close();
  74.                                 }
  75.                             }
  76.                         }
  77.                     }
  78.                  }  catch (Throwable e) {
  79.                      e.printStackTrace();
  80.                  }
  81.              }
  82.               if(selector !=  null){
  83.                   try {
  84.                      selector.close();
  85.                  }  catch (IOException e) {
  86.                      e.printStackTrace();
  87.                  }
  88.              }
  89.          }
  91.            public  void  handle (SelectionKey key)  throws IOException {
  92.                //如果key是有效的
  93.                 if(key.isValid()){
  94.                     //监听到有新客户端的接入请求
  95.                     //完成TCP的三次握手，建立物理链路层
  96.                     if(key.isAcceptable()){
  97.                        ServerSocketChannel ssc = (ServerSocketChannel) key.channel();
  98.                        SocketChannel sc = (SocketChannel) ssc.accept();
  99.                         //设置客户端链路为非阻塞模式
  100.                        sc.configureBlocking( false);
  101.                         //将新接入的客户端注册到多路复用器Selector上
  102.                        sc.register(selector, SelectionKey.OP_READ);
  103.                    }
  104.                     //监听到客户端的读请求
  105.                     if(key.isReadable()){
  106.                         //获得通道对象
  107.                        SocketChannel sc = (SocketChannel) key.channel();
  108.                        ByteBuffer readBuffer = ByteBuffer.allocate( 1024);
  109.                         //从channel读数据到缓冲区
  110.                        int readBytes = sc.read(readBuffer);
  111.                        if (readBytes >  0){
  112.                           //Flips this buffer.  The limit is set to the current position and then
  113.                            // the position is set to zero，就是表示要从起始位置开始读取数据
  114.                           readBuffer.flip();
  115.                            //eturns the number of elements between the current position and the  limit.
  116.                            // 要读取的字节长度
  117.                            byte[] bytes =  new  byte[readBuffer.remaining()];
  118.                            //将缓冲区的数据读到bytes数组
  119.                           readBuffer.get(bytes);
  120.                           String body =  new String(bytes,  "UTF-8");
  121.                           System.out.println( "the time server receive order: " + body);
  122.                           String currenttime =  "query time order".equals(body) ?  new Date(System.currentTimeMillis()).toString():  "bad order";
  123.                           doWrite(sc, currenttime);
  124.                       } else  if(readBytes <  0){
  125.                          key.channel();
  126.                          sc.close();
  127.                        }
  128.                    }
  129.                }
  130.          }
  132.            public  static  void  doWrite (SocketChannel channel, String response)  throws IOException {
  133.               if(!StringUtils.isEmpty(response)){
  134.                   byte []  bytes = response.getBytes();
  135.                   //分配一个bytes的length长度的ByteBuffer
  136.                  ByteBuffer  write = ByteBuffer.allocate(bytes.length);
  137.                   //将返回数据写入缓冲区
  138.                  write.put(bytes);
  139.                  write.flip();
  140.                   //将缓冲数据写入渠道，返回给客户端
  141.                  channel.write(write);
  142.              }
  143.          }
  144.      }

       服务端启动程序：        

  1.       package nio;
  3.        /**
  4.        * 服务端启动程序
  5.        */
  6.       public   class  ServerMain {
  8.            public  static  void  main (String[] args) {
  9.               int port =  8010;
  10.              ServerSocketChannels server =  new ServerSocketChannels(port);
  11.               new Thread(server, "timeserver-001").start();
  12.          }
  13.      }

       客户端程序：        

  1.       package nio;
  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.SocketChannel;
  9.       import java.util.Iterator;
  10.       import java.util.Set;
  12.       public   class  TimeClientHandler  implements  Runnable {
  14.           //服务器端的ip
  15.           private String host;
  16.          //服务器端的端口号
  17.           private  int port;
  18.          //多路服用选择器
  19.           private Selector selector;
  21.           private SocketChannel socketChannel;
  23.           private  volatile  boolean stop;
  26.            public  TimeClientHandler (String host,  int port){
  27.               this.host = host ==  null ?  "127.0.0.1": host;
  28.               this.port = port;
  29.               try {
  30.                   //初始化一个Selector，工厂方法
  31.                  selector = Selector.open();
  32.                   //初始化一个SocketChannel，工厂方法
  33.                  socketChannel = SocketChannel.open();
  34.                   //设置非阻塞模式
  35.                  socketChannel.configureBlocking( false);
  36.              }  catch (IOException e) {
  37.                  e.printStackTrace();
  38.                  System.exit( 1);
  39.              }
  41.          }
  44.            /**
  45.            * 首先尝试连接服务端
  46.            *  @throws IOException
  47.            */
  48.            public  void  doConnect ()  throws IOException {
  49.               //如果连接成功，像多路复用器selector监听读请求
  50.               if(socketChannel.connect( new InetSocketAddress( this.host,  this.port))){
  51.               socketChannel.register(selector, SelectionKey.OP_READ);
  52.                //执行写操作，像服务器端发送数据
  53.               doWrite(socketChannel);
  54.              } else {
  55.                   //监听连接请求
  56.                  socketChannel.register(selector, SelectionKey.OP_CONNECT);
  57.              }
  58.          }
  61.            public  static  void  doWrite (SocketChannel sc)  throws IOException {
  62.             //构造请求消息体
  63.              byte [] bytes =  "query time order".getBytes();
  64.             //构造ByteBuffer
  65.             ByteBuffer write = ByteBuffer.allocate(bytes.length);
  66.             //将消息体写入发送缓冲区
  67.              write.put(bytes);
  68.              write.flip();
  69.              //调用channel的发送方法异步发送
  70.              sc.write(write);
  71.              //通过hasRemaining方法对发送结果进行判断，如果消息全部发送成功，则返回true
  72.               if(!write.hasRemaining()){
  73.                  System.out.println( "send order 2 server successd");
  74.              }
  75.          }
  77.           @Override
  78.            public  void  run () {
  79.               try {
  80.                  doConnect();
  81.              }  catch (IOException e) {
  82.                  e.printStackTrace();
  83.                  System.exit( 1);
  84.              }
  85.               while (!stop){
  86.                   try {
  87.                      selector.select( 1000);
  88.                      Set<SelectionKey> keys =  selector.selectedKeys();
  89.                      Iterator<SelectionKey> its =keys.iterator();
  90.                      SelectionKey key =  null;
  91.                       while (its.hasNext()){
  92.                          key = its.next();
  93.                          its.remove();
  94.                           try {
  95.                              handle(key);
  96.                          } catch (Exception e){
  97.                               if(key !=  null){
  98.                                  key.cancel();
  99.                                   if(key.channel() !=  null){
  100.                                      key.channel().close();
  101.                                  }
  102.                              }
  103.                          }
  104.                      }
  105.                  }  catch (Exception e) {
  106.                      e.printStackTrace();
  107.                      System.exit( 1);
  108.                  }
  109.              }
  110.          }
  112.            public   void  handle (SelectionKey key)  throws IOException {
  113.               if(key.isValid()){
  114.                  SocketChannel sc = (SocketChannel) key.channel();
  115.                   if(key.isConnectable()){
  116.                       //如果连接成功，监听读请求
  117.                      if(sc.finishConnect()){
  118.                        sc.register( this.selector, SelectionKey.OP_READ);
  119.                         //像服务端发送数据
  120.                         doWrite(sc);
  121.                     } else{
  122.                         System.exit( 1);
  123.                     }
  124.                  }
  125.                   //监听到读请求，从服务器端接受数据
  126.                   if(key.isReadable()){
  127.                      ByteBuffer byteBuffer = ByteBuffer.allocate( 1024);
  128.                       int readBytes = sc.read(byteBuffer);
  129.                       if(readBytes >  0){
  130.                          byteBuffer.flip();
  131.                           byte []  bytes =  new  byte;
  132.                          byteBuffer.get(bytes);
  133.                          String body =  new String(bytes, "UTF-8");
  134.                          System.out.println( "now body is "+ body);
  135.                          stop =  true;
  137.                      } else  if(readBytes <  0){
  138.                          key.cancel();
  139.                          sc.close();
  140.                      }
  143.                  }
  144.              }
  145.          }
  146.         //释放所有与该多路复用器selector关联的资源
  147.            if(selector !=  null){
  148.               try {
  149.                  selector.close();
  150.              }  catch (IOException e) {
  151.                  e.printStackTrace();
  152.              }
  153.          }
  154.      }

       客户端启动程序：        

  1.       package nio;
  4.        /**
  5.        * 客户端启动程序
  6.        */
  7.       public   class  ClientMain {
  9.            public  static  void  main (String[] args) {
  10.             int port =  8010;
  11.            TimeClientHandler client =  new TimeClientHandler( "",port);
  12.             new Thread(client, "client-001").start();
  13.          }
  14.      }

           现在说一下nio的执行过程：

         第一步：启动server服务器，初始化多路复用器selector、ServerSocketChannel通道、设置通道的模式为非阻塞、注册channel到selector上，并监听accept请求；

         第二步：启动server服务器，循环selectionKeys，当有channel准备好时就处理，否则一直循环；

         第三步：启动client端，初始化多路复用器selector、SocketChannel通道，设置通道的模式为非阻塞；

         第四步：client首先尝试连接server，此时socketChannel.connect(new InetSocketAddress(this.host, this.port)返回false，表示server还没有返回信息，server收到连接请求后，监听到client的接入请求，会初始化一个新的client、并将新接入的client注册到多路复用器Selector上，并应答client；再回到client端，由于client没有及时收到server端的应答，所以client胡监听一个connect请求，socketChannel.register(selector, SelectionKey.OP_CONNECT)，当server返回应答信息时，client会收到一个connect请求，key.isConnectable()，如果此时sc.finishConnect()连接完成，client会监听一个read请求，并像server发送数据doWrite(sc)，然后server会收到一个read请求，key.isReadable()处理完后返回给client，client也会收到一个读请求，收到server的返回数据，此时，整个交互过程结束；

                           截取一下书上的步骤：来自netty权威指南：

         点击在新窗口中浏览原图 CTRL+鼠标滚轮放大或缩小

                                             nio的优点：

         1、客户端发起的连接操作connect是异步的，可以通过在多路复用器selector上监听connect事件等待后续结果，不需要像之前的客户端那样被同步阻塞；

         2、SocketChannel的读写操作都是异步的，如果没有可读写的数据它不会同步等待，直接返回，这样IO线程就可以处理其它的链路，不需要同步等待这个链路可用；

         3、线程模型的优化，由于jdk的selector在linux等主流操作系统上通过epoll实现，它没有连接句柄数的限制（只受限与操作系统的最大句柄数或者单个进程的句柄限制），这意味这一个selector可以连接成千上万个客户端连接，而性能不会随着客户端连接数的增长呈线性下降，因此，它适合做高性能、高负载的网络服务器；

                                                                                                                        
----------------------------
原文链接:https://blog.csdn.net/chengkui1990/article/details/81558522

程序猿的技术大观园：www.javathinker.net



[这个贴子最后由 flybird 在 2020-02-07 10:54:24 重新编辑]
Java精品书籍推荐
Java最新视频教程推荐
  Java面向对象编程-->Swing组件（下）
  JavaWeb开发-->JavaWeb应用入门（Ⅱ）
  JSP与Hibernate开发-->使用JPA和注解
  Java网络编程-->基于UDP的数据报和套接字
  精通Spring-->CSS过渡和动画
  Vue3开发-->Vue CLI脚手架工具
本站其他相关文章
  BIO、NIO和AIO的区别、三种IO的原理与用法
  面向对象的七大原则，你知道几个？
  Java设计模式中的工厂模式和策略模式范例
  64匹马，8个赛道，找出跑得最快的4匹马
  Java 冒泡排序算法
  Java设计模式：抽象工厂模式
  深入分析synchronized实现原理
  Eclipse使用指南：工作空间(Workspace)
  Java Scoket之java.io.EOFException解决方案
  Java虚拟机(JVM)的内存结构
  java比c++强大之处JVM垃圾收集算法
  Java入门实用代码：获取当前线程名称
  Java入门实用代码：将文件内容复制到另一个文件
  Java入门实用代码:打印九九乘法表
  Java程序代码优化技巧
  更多...
 IPIP: 已设置保密
楼主      
共1页 0条记录 当前第1页
发表一个新主题 开启一个新投票 回复文章

中文版权所有： JavaThinker技术网站 Copyright 2016-2026 沪ICP备16029593号-2
荟萃Java程序员智慧的结晶，分享交流Java前沿技术。  联系我们
如有技术文章涉及侵权，请与本站管理员联系。