>> 欢迎您 客人: 登录 | 注册 | 在线 | 搜索 | 风格 | 帮助 | 统计 | 文章 返回首页
>>分享Java编程技术，对《Java面向对象编程》等书籍提供技术支持 书籍支持  卫琴直播  品书摘要  在线测试  资源下载  联系我们
Java技术网站 → 『 Java开发技术 』 → 『 Java编程技术专题 』 → 使用javaNIO实现C/S模式的通信
发表一个新主题 开启一个新投票 回复文章 您是本文章第 21822 个阅读者 刷新本主题
 * 贴子主题:  使用javaNIO实现C/S模式的通信 回复文章 点赞(0)  收藏  
作者:flybird    发表时间：2020-02-06 23:41:23     消息  查看  搜索  好友  邮件  复制  引用

      NIO使用非阻塞IO的方式实现，服务器与客户端的交流，适用于大量连接，而数据量少的情况。通过一个线程轮询所有的通道，处理注册的事件，而主线程可以继续干其他的事情。这样所有的I/O都交给一个线程处理，减少了线程IO的切换。如果具体学习NIO的架构和原理请点击下面的连接

       点击打开链接 http://ifeve.com/selectors/

          以下为一个使用NIO实现的C/S通信模式，对应简单例子学习，可以更容易入手。

      服务端代码如下：

      主线程类：MainChannel              
  1.        import java.io.IOException;
  2.       import java.net.InetSocketAddress;
  3.       import java.nio.channels.SelectionKey;
  4.       import java.nio.channels.Selector;
  5.       import java.nio.channels.ServerSocketChannel;
  7.       public   class  MainChannel {
  9.        public  static  void  main (String[] args) {
  10.      // TODO Auto-generated method stub
  11.      // 声明服务器监听通道 和select选择器
  12.      ServerSocketChannel serverChannel =  null;
  13.      Selector selector =  null;
  15.      try {
  16.      // 实例化selector 此种实例化模式说明 selector 是单例的
  17.      selector = Selector.open();
  18.      // 实例化服务器监听端口
  19.      serverChannel = ServerSocketChannel.open();
  20.      // 绑定监听地址。
  21.      serverChannel.socket().bind( new InetSocketAddress( 8881));
  22.      // 设置channel为非阻塞模式,一定要非阻塞模式才能注册到selector中
  23.      serverChannel.configureBlocking( false);
  25.      // 把监听通道注册到选择器中， 监听此通道的连接事件。SelectionKey.OP_ACCEPT 指定为连接事件。
  26.      serverChannel.register(selector, SelectionKey.OP_ACCEPT);
  27.      //所有通道，交给通道管理器，统一管理
  28.      ChannelManager.addChannel(serverChannel);
  29.      // 开启一个线程负责管理selector,并轮询是否有注册监听的事件就绪。
  30.      Thread thread =  new Thread( new ServerNIO(selector));
  31.      thread.start();
  33.      // 然后主线程 就可以干其他的事情了。不管客户端连接 还是I/O
  34.      // 都不会阻塞此线程，只会阻塞selector管理线程，且只在等待事件发生时阻塞。
  35.      }  catch (IOException e) {
  36.      // TODO Auto-generated catch block
  37.      System.out.println( "服务器监听发生异常");
  38.      }
  39.      }
  40.      }

   管理selector的线程类:          

  1.        import java.io.IOException;
  2.       import java.nio.ByteBuffer;
  3.       import java.nio.channels.SelectionKey;
  4.       import java.nio.channels.Selector;
  5.       import java.nio.channels.ServerSocketChannel;
  6.       import java.nio.channels.SocketChannel;
  7.       import java.util.Iterator;
  8.       import java.util.Set;
  10.       public   class  ServerNIO  implements  Runnable {
  11.      // 客户端通道，用于给某个客户端收发数据
  12.      private SocketChannel socketChannel;
  14.      // 缓冲区，用户收发数据，面向通道。
  15.      private ByteBuffer buf = ByteBuffer.allocate( 1024);
  17.      // 选择器，从主线程注入
  18.      private Selector selector;
  20.      // 指定线程是否轮询
  21.      private  boolean flag =  true;
  23.      // 构造器中注入selector
  24.        public  ServerNIO (Selector selector) {
  25.      // TODO Auto-generated constructor stub
  26.      this.selector = selector;
  27.      }
  29.      // 开启线程等待事件的发生，轮询通道。
  30.      @Override
  31.        public  void  run () {
  32.      // TODO Auto-generated method stub
  33.      try {
  34.      while (flag) {
  36.        /**
  37.        * 获取等待的事件就绪的通道，如果没有通道有事件就绪有三种情况
  38.        * 1. 直接返回:selectNow();
  39.        * 2. 超时返回:select(int timeout);
  40.        * 3. 阻 塞: select();
  41.        */
  42.      int nums = selector.select();  // 阻塞模式
  43.      if (nums >  0) {  // 阻塞模式下 此次判定多余
  44.      // 当事件发生了，获取发生事件通道的key集合;
  45.      Set<SelectionKey> selectKeys = selector.selectedKeys();
  47.      // 迭代遍历这个keys集合
  48.      Iterator<SelectionKey> iter = selectKeys.iterator();
  50.      while (iter.hasNext()) {
  51.      // 获取单个通道的key
  52.      SelectionKey key = iter.next();
  53.      // 如果是读取事件就绪。说明有客户端向服务器发送数据了。
  54.      if (key.isReadable()) {
  55.      // 先获取到客户端channel
  56.      socketChannel = (SocketChannel) key.channel();
  57.      buf.clear();
  58.      // 利用buffer读取数据。
  59.      int len = socketChannel.read(buf);
  60.      if (len >  0) {
  61.      byte[] str =  new  byte[len];
  62.      buf.rewind();
  63.      buf.get(str,  0, len);
  64.      buf.clear();
  65.      System.out.println( "获取客户端数据：" +  new String(str));
  67.      // 给客户端回复数据
  68.      String temp =  "服务器回复: 已经收到您发送的数据，祝您一路平安!";
  69.      buf.clear();
  70.      buf.put(temp.getBytes());
  71.      buf.flip();
  72.      socketChannel.write(buf);
  73.      System.out.println( "已经向客户端回复");
  74.      //此处可以利用ChannelManager向其他所有通道广播数据。只要在ChannelManager中写一个广播方法即可
  75.      }
  76.      }  else  if (key.isAcceptable()) {  // 如果是接受客户端连接就绪
  77.      // 从key中获取对应的通道
  78.      ServerSocketChannel serverChannel = (ServerSocketChannel) key.channel();
  79.      // 接受这个连接。
  80.      SocketChannel socketChannel = serverChannel.accept();
  81.      // 如果连接不为空，则控制台打印 连接的客户端地址。
  82.      if (socketChannel !=  null) {
  83.      // 由于关闭selector的时候，并不会关闭通道，最好使用一个容器，将通道都保存起来
  84.      //然后开启心跳连接，如果通道出现异常则关闭此通道，当应用程序关闭的时候，关闭所有的通道。
  85.      ChannelManager.addChannel(socketChannel);
  87.      System.out.println(String.format( "接收到客户端的连接:IP[%s]-端口[%s]",
  88.      socketChannel.socket().getPort(), socketChannel.socket().getInetAddress()));
  89.      // 把这个通道设置为非阻塞模式，然后又注册到selector中，等待事件发生
  90.      socketChannel.configureBlocking( false);
  91.      socketChannel.register(selector, SelectionKey.OP_READ);
  92.      }
  93.      }  //写事件在缓冲区直接达到阈值时候出发，一般不注册写事件。
  94.      // 通道处理完毕后 将此通道删除。如果下次又有此时间，会有一个新的key，所以记得删除处理过的key。
  95.      iter.remove();
  96.      }
  98.      }
  99.      }
  100.      }  catch (IOException e) {
  101.      System.out.println( "服务器断开连接");
  102.      }
  104.      try {
  105.      // 注意此处只会关闭，selector使注册到琪上面的selectionKeys无效，通道本身不会关闭。
  106.      selector.close();
  107.      ChannelManager.closeChannles();
  108.      }  catch (IOException e1) {
  109.      // TODO Auto-generated catch block
  110.      e1.printStackTrace();
  111.      }
  112.      }
  113.      }

   通道管理类：          

  1.        import java.io.IOException;
  2.       import java.nio.channels.Channel;
  3.       import java.util.LinkedList;
  5.       public   class  ChannelManager {
  6.      private  static LinkedList<Channel> list =  new LinkedList<>();
  8.      private  static Thread thread;  //用于开启心跳测试通道连接,实现省略
  10.        public  static  void  addChannel (Channel channel) {
  11.      list.add(channel);
  12.      }
  14.      //关闭所有的通道连接
  15.        public  static  void  closeChannles () {
  16.      for (Channel channel : list) {
  17.      try {
  18.      channel.close();
  19.      }  catch (IOException e) {
  20.      // TODO Auto-generated catch block
  21.      e.printStackTrace();
  22.      System.out.println( "关闭通道失败");
  23.      }
  24.      list.remove();
  25.      }
  26.      }
  27.      }

   一个简单的客户端类： 这个脚本可以直接通过cmd 编译运行。          

  1.        import java.io.IOException;
  2.       import java.net.InetSocketAddress;
  3.       import java.nio.ByteBuffer;
  4.       import java.nio.channels.SocketChannel;
  5.       import java.util.Scanner;
  7.       public   class  MainChannel {
  9.        public  static  void  main (String[] args) {
  10.      // TODO Auto-generated method stub
  11.      SocketChannel socketChannel =  null;
  12.      boolean flag =  true;
  13.      Scanner in =  new Scanner(System.in);
  14.      ByteBuffer buffer = ByteBuffer.allocate( 1024);
  15.      try {
  16.      socketChannel = SocketChannel.open();
  18.      // 设置连接为非阻塞模式，可能未连接完成就返回
  19.      // socketChannel.configureBlocking(false);
  20.      socketChannel.socket().connect( new InetSocketAddress( "192.168.1.100",  8881));
  22.      // 判断是否连接成功，等待连接成功
  23.      while (!socketChannel.finishConnect()) {
  24.      }
  26.      while (flag) {
  28.      String temp = in.nextLine();
  30.      buffer.clear();
  32.      buffer.put(temp.getBytes());
  34.      // limit指针 移动到 position位置
  35.      buffer.flip();
  37.      // 当buffer中有足够空间，则写到buffer中
  38.      while (buffer.hasRemaining())
  39.      socketChannel.write(buffer);
  41.      if ( "exit".equals(temp))
  42.      flag =  false;
  43.      }
  45.      }  catch (IOException e) {
  46.      // TODO Auto-generated catch block
  47.      System.out.println( "与服务断开连接");
  48.      }
  50.      if (socketChannel !=  null) {
  51.      try {
  52.      socketChannel.close();
  53.      }  catch (IOException e) {
  54.      // TODO Auto-generated catch block
  55.      e.printStackTrace();
  56.      }
  57.      }
  58.      }
  60.      }

   上述代码，可以实现客户端向服务器发送消息，然后服务器接受到消息，在自己的控制台打印输出。

                                                                                            
----------------------------
原文链接:https://blog.csdn.net/qq_32250495/article/details/76796084

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



[这个贴子最后由 flybird 在 2020-02-06 23:41:23 重新编辑]
Java精品书籍推荐
Java最新视频教程推荐
  Java面向对象编程-->面向对象开发方法概述之开发思想(上)
  JavaWeb开发-->访问数据库(Ⅱ)
  JSP与Hibernate开发-->立即检索和延迟检索策略
  Java网络编程-->通过JDBC API访问数据库
  精通Spring-->绑定表单
  Vue3开发-->Vue CLI脚手架工具
本站其他相关文章
  解密Java类文件的数据结构
   JAVA进阶之IO模型深入解析
  快速理解 函数式编程,响应式编程,链式编程
  TCP、UDP及Socket代码示例
  [讨论]书中多线程章节的语言表述有误？
  如何优雅地打印一个Java对象？
  面试必考-static、final和单例模式
  邀请您一起来祝福和祈祷，祈愿疫情早日消除，平安吉祥
  java NIO示例以及流程详解
  Java设计模式：解释器模式
  Java设计模式：享元模式
  Java入门实用代码：线程状态监测
  Java入门实用代码：获取链表（LinkedList）的第一个和最后一...
  Java 入门实用代码： 数组差集
  Java Pattern和Matcher字符匹配详解
  更多...
 IPIP: 已设置保密
树形列表:   
共1页 0条记录 当前第1页
发表一个新主题 开启一个新投票 回复文章

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