本文实例为大家分享了Java NIO实现群聊系统的具体代码，供大家参考，具体内容如下
实例要求：
1）编写一个 NIO 群聊系统，实现服务器端和客户端之间的数据简单通讯（非阻塞）
2）实现多人群聊
3）服务器端：可以监测用户上线，离线，并实现消息转发功能
4）客户端：通过channel 可以无阻塞发送消息给其它所有用户，同时可以接受其它用户发送的消息(有服务器转发得到)
5）目的：进一步理解NIO非阻塞网络编程机制

服务端代码：

  1. import java.io.IOException;
  2. import java.net.InetSocketAddress;
  3. import java.nio.ByteBuffer;
  4. import java.nio.channels.*;
  5. import java.util.Iterator;
  7. public class GroupChatServer {
  8.     //定义属性
  9.     private Selector selector;
  10.     private ServerSocketChannel listenChannel;
  11.     private static final int PORT = 6667;
  13.     //构造器
  14.     //初始化工作
  15.     public GroupChatServer() {
  17.         try {
  18.             //得到选择器
  19.             selector = Selector.open();
  20.             //ServerSocketChannel
  21.             listenChannel =  ServerSocketChannel.open();
  22.             //绑定端口
  23.             listenChannel.socket().bind(new InetSocketAddress(PORT));
  24.             //设置非阻塞模式
  25.             listenChannel.configureBlocking(false);
  26.             //将该listenChannel 注册到selector
  27.             listenChannel.register(selector, SelectionKey.OP_ACCEPT);
  29.         }catch (IOException e) {
  30.             e.printStackTrace();
  31.         }
  32.     }
  34.     //监听
  35.     public void listen() {
  37.         System.out.println("监听线程: " + Thread.currentThread().getName());
  38.         try {
  40.             //循环处理
  41.             while (true) {
  43.                 int count = selector.select();
  44.                 if(count > 0) {//有事件处理
  46.                     //遍历得到selectionKey 集合
  47.                     Iterator<SelectionKey> iterator = selector.selectedKeys().iterator();
  48.                     while (iterator.hasNext()) {
  49.                         //取出selectionkey
  50.                         SelectionKey key = iterator.next();
  52.                         //监听到accept
  53.                         if(key.isAcceptable()) {
  54.                             SocketChannel sc = listenChannel.accept();
  55.                             sc.configureBlocking(false);
  56.                             //将该 sc 注册到seletor
  57.                             sc.register(selector, SelectionKey.OP_READ);
  58.                             //提示
  59.                             System.out.println(sc.getRemoteAddress() + " 上线 ");
  60.                         }
  61.                         if(key.isReadable()) { //通道发送read事件，即通道是可读的状态
  62.                             //处理读 (专门写方法..)
  63.                             readData(key);
  64.                         }
  65.                         //当前的key 删除，防止重复处理
  66.                         iterator.remove();
  67.                     }
  69.                 } else {
  70.                     System.out.println("等待....");
  71.                 }
  72.             }
  74.         }catch (Exception e) {
  75.             e.printStackTrace();
  77.         }finally {
  78.             //发生异常处理....
  79.         }
  80.     }
  82.     //读取客户端消息
  83.     private void readData(SelectionKey key) {
  85.         //取到关联的channle
  86.         SocketChannel channel = null;
  88.         try {
  89.            //得到channel
  90.             channel = (SocketChannel) key.channel();
  91.             //创建buffer
  92.             ByteBuffer buffer = ByteBuffer.allocate(1024);
  94.             int count = channel.read(buffer);
  95.             //根据count的值做处理
  96.             if(count > 0) {
  97.                 //把缓存区的数据转成字符串
  98.                 String msg = new String(buffer.array());
  99.                 //输出该消息
  100.                 System.out.println("form 客户端: " + msg);
  101.                 //向其它的客户端转发消息(去掉自己), 专门写一个方法来处理
  102.                 sendInfoToOtherClients(msg, channel);
  103.             }
  105.         }catch (IOException e) {
  106.             try {
  107.                 System.out.println(channel.getRemoteAddress() + " 离线了..");
  108.                 //取消注册
  109.                 key.cancel();
  110.                 //关闭通道
  111.                 channel.close();
  112.             }catch (IOException e2) {
  113.                 e2.printStackTrace();;
  114.             }
  115.         }
  116.     }
  118.     //转发消息给其它客户(通道)
  119.     private void sendInfoToOtherClients(String msg, SocketChannel self ) throws  IOException{
  121.         System.out.println("服务器转发消息中...");
  122.         System.out.println("服务器转发数据给客户端线程: " + Thread.currentThread().getName());
  123.         //遍历 所有注册到selector 上的 SocketChannel,并排除 self
  124.         for(SelectionKey key: selector.keys()) {
  126.             //通过 key  取出对应的 SocketChannel
  127.             Channel targetChannel = key.channel();
  129.             //排除自己
  130.             if(targetChannel instanceof  SocketChannel && targetChannel != self) {
  131.                 //转型
  132.                 SocketChannel dest = (SocketChannel)targetChannel;
  133.                 //将msg 存储到buffer
  134.                 ByteBuffer buffer = ByteBuffer.wrap(msg.getBytes());
  135.                 //将buffer 的数据写入 通道
  136.                 dest.write(buffer);
  137.             }
  138.         }
  139.     }
  141.     public static void main(String[] args) {
  142.         //创建服务器对象
  143.         GroupChatServer groupChatServer = new GroupChatServer();
  144.         groupChatServer.listen();
  145.     }
  146. }
  148. //可以写一个Handler
  149. class MyHandler {
  150.     public void readData() {
  151.     }
  152.     public void sendInfoToOtherClients(){
  153.     }
  154. }
  1. import java.io.IOException;
  2. import java.net.InetSocketAddress;
  3. import java.nio.ByteBuffer;
  4. import java.nio.channels.SelectionKey;
  5. import java.nio.channels.Selector;
  6. import java.nio.channels.SocketChannel;
  7. import java.util.Iterator;
  8. import java.util.Scanner;
  9. import java.util.Set;
  11. public class GroupChatClient {
  13.     //定义相关的属性
  14.     private final String HOST = "127.0.0.1"; // 服务器的ip
  15.     private final int PORT = 6667; //服务器端口
  16.     private Selector selector;
  17.     private SocketChannel socketChannel;
  18.     private String username;
  20.     //构造器, 完成初始化工作
  21.     public GroupChatClient() throws IOException {
  23.         selector = Selector.open();
  24.         //连接服务器
  25.         socketChannel = socketChannel.open(new InetSocketAddress("127.0.0.1", PORT));
  26.         //设置非阻塞
  27.         socketChannel.configureBlocking(false);
  28.         //将channel 注册到selector
  29.         socketChannel.register(selector, SelectionKey.OP_READ);
  30.         //得到username
  31.         username = socketChannel.getLocalAddress().toString().substring(1);
  32.         System.out.println(username + " is ok...");
  34.     }
  36.     //向服务器发送消息
  37.     public void sendInfo(String info) {
  39.         info = username + " 说：" + info;
  40.         try {
  41.             socketChannel.write(ByteBuffer.wrap(info.getBytes()));
  42.         }catch (IOException e) {
  43.             e.printStackTrace();
  44.         }
  45.     }
  47.     //读取从服务器端回复的消息
  48.     public void readInfo() {
  50.         try {
  52.             int readChannels = selector.select();
  53.             if(readChannels > 0) {//有可以用的通道
  55.                 Iterator<SelectionKey> iterator = selector.selectedKeys().iterator();
  56.                 while (iterator.hasNext()) {
  58.                     SelectionKey key = iterator.next();
  59.                     if(key.isReadable()) {
  60.                         //得到相关的通道
  61.                        SocketChannel sc = (SocketChannel) key.channel();
  62.                        //得到一个Buffer
  63.                         ByteBuffer buffer = ByteBuffer.allocate(1024);
  64.                         //读取
  65.                         sc.read(buffer);
  66.                         //把读到的缓冲区的数据转成字符串
  67.                         String msg = new String(buffer.array());
  68.                         System.out.println(msg.trim());
  69.                     }
  70.                 }
  71.                 iterator.remove(); //删除当前的selectionKey, 防止重复操作
  72.             } else {
  73.                 //System.out.println("没有可以用的通道...");
  74.             }
  76.         }catch (Exception e) {
  77.             e.printStackTrace();
  78.         }
  79.     }
  81.     public static void main(String[] args) throws Exception {
  83.         //启动我们客户端
  84.         GroupChatClient chatClient = new GroupChatClient();
  86.         //启动一个线程, 每隔3秒，读取从服务器发送数据
  87.         new Thread() {
  88.             public void run() {
  90.                 while (true) {
  91.                     chatClient.readInfo();
  92.                     try {
  93.                         Thread.currentThread().sleep(3000);
  94.                     }catch (InterruptedException e) {
  95.                         e.printStackTrace();
  96.                     }
  97.                 }
  98.             }
  99.         }.start();
  101.         //发送数据给服务器端
  102.         Scanner scanner = new Scanner(System.in);
  104.         while (scanner.hasNextLine()) {
  105.             String s = scanner.nextLine();
  106.             chatClient.sendInfo(s);
  107.         }
  108.     }
  109. }

注意：必须设置通道为非阻塞，才能向Selector注册，否则报 java.nio.channels.IllegalBlockingModeException 错
注意：在客户端上要想获取得到服务端的数据，也需要注册在register上(监听读事件)

更多相关文章

  1. 如何远程登录云服务器？登录失败是什么原因？
  2. 部署小程序的云服务器要注意什么？配置过程是怎么样的？
  3. 程序员有必要拥有一台自己的云服务器吗？为什么？
  4. 小鸟云服务器FTP上传中断是什么原因？解决方法总结
  5. 小鸟云虚拟主机和云服务器和裸金属服务器有何不一样？
  6. 物理机、虚拟机、云主机、物理服务器、裸金属都是什么？
  7. Linux服务器遇到攻击怎么办？用这些方法封禁IP
  8. 记录对云服务器的初体验
  9. 云服务器如何通过本地安全策略阻止特定IP访问服务器？

随机推荐

  1. 官方示例（十）：网页开发3D粒子系统实现降雨效
  2. Spring Boot 揭秘与实战 内嵌的服务器 To
  3. Linux性能优化（二）——sysbench压力测试工
  4. Spring Boot 开箱即用，内藏玄机
  5. 第二日学习
  6. Spring Boot 揭秘与实战 工作原理剖析
  7. Linux性能优化（一）——stress压力测试工具
  8. 安全要素与 STRIDE 威胁
  9. 在51CTO学院学习PMP,终于get证书
  10. 安全的软件开发生命周期