NIO 多人聊天室

一前言

在家休息没事，敲敲代码，用NIO写个简易的仿真聊天室。下面直接讲聊天室设计和编码。对NIO不了解的朋友，推荐一个博客，里面写的很棒：

https://javadoop.com/ 里面有NIO的部分

二设计

1.进入的时候，提示输入聊天昵称，重复的话，重新输入，成功后进到聊天室。

2.成功进到聊天室，广播通知，XXX进到了聊天室；离开聊天室，XXX离开了聊天室。

3.@XXX 给XXX发消息，只有双方可以看到。

4.服务端收到的内容会转发给其他客户端。

三代码

目前版本（设计工程3，4有待改进）

服务端：

 package com.lee.demo.nio;

 import java.io.IOException;

 import java.net.InetSocketAddress;

 import java.nio.ByteBuffer;

 import java.nio.channels.Channel;

 import java.nio.channels.SelectionKey;

 import java.nio.channels.Selector;

 import java.nio.channels.ServerSocketChannel;

 import java.nio.channels.SocketChannel;

 import java.nio.charset.Charset;

 import java.util.HashSet;

 import java.util.Iterator;

 import java.util.Set;

 public class ChatServer {

     private Selector  selector = null;

     private Charset charset = Charset.forName("UTF-8");

     public static final int PORT = 8765;

     private static String USER_CONTENT_SPILIT = "#";

     private static HashSet<String> users = new HashSet<String>();

     public void init() throws IOException {

         selector = Selector.open();

         ServerSocketChannel server = ServerSocketChannel.open();

         server.socket().bind(new InetSocketAddress(PORT));

         // 将其注册到 Selector 中，监听 OP_ACCEPT 事件

         server.configureBlocking(false);

         server.register(selector, SelectionKey.OP_ACCEPT);

         while (true) {

             int readyChannels = selector.select();

             if (readyChannels == 0) {

                 continue;

             }

             Set<SelectionKey> readyKeys = selector.selectedKeys();

             // 遍历

             Iterator<SelectionKey> iterator = readyKeys.iterator();

             while (iterator.hasNext()) {

                 SelectionKey key = iterator.next();

                 iterator.remove();

                 dealWithKey(server, key);

             }

         }

     }

     private void dealWithKey(ServerSocketChannel server, SelectionKey key) throws IOException {

         String content = null;

         if (key.isAcceptable()) {

             // 有已经接受的新的到服务端的连接

             SocketChannel socketChannel = server.accept();

             // 有新的连接并不代表这个通道就有数据，

             // 这里将这个新的 SocketChannel 注册到 Selector，监听 OP_READ 事件，等待数据

             socketChannel.configureBlocking(false);

             socketChannel.register(selector, SelectionKey.OP_READ);

             //将此对应的channel设置为准备接受其他客户端请求

             key.interestOps(SelectionKey.OP_ACCEPT);

             System.out.println("Server is listening from client " + socketChannel.getRemoteAddress());

             socketChannel.write(charset.encode("Please input your name: "));

         } else if (key.isReadable()) {

             // 有数据可读

             // 上面一个 if 分支中注册了监听 OP_READ 事件的 SocketChannel

             SocketChannel socketChannel = (SocketChannel) key.channel();

             ByteBuffer readBuffer = ByteBuffer.allocate(1024);

             int num = socketChannel.read(readBuffer);

             if (num > 0) {

                 content = new String(readBuffer.array()).trim();

                 // 处理进来的数据...

                 System.out.println("Server is listening from client " +

                                     socketChannel.getRemoteAddress() +

                                     " data received is: " +

                                     content);

 /*                ByteBuffer buffer = ByteBuffer.wrap("返回给客户端的数据...".getBytes());

                 socketChannel.write(buffer);*/

                 //将此对应的channel设置为准备下一次接受数据

                 key.interestOps(SelectionKey.OP_READ);

                 String[] arrayContent = content.split(USER_CONTENT_SPILIT);

                 //注册用户

                 if(arrayContent != null && arrayContent.length ==1) {

                     String name = arrayContent[0];

                     if(users.contains(name)) {

                         socketChannel.write(charset.encode("system message: user exist, please change a name"));

                     } else {

                         users.add(name);

                         int number = OnlineNum(selector);

                         String message = "welcome " + name + " to chat room! Online numbers:" + number;

                         broadCast(selector, null, message);

                     }

                 }

                 //注册完了，发送消息

                 else if(arrayContent != null && arrayContent.length >1){

                     String name = arrayContent[0];

                     String message = content.substring(name.length() + USER_CONTENT_SPILIT.length());

                     message = name + " say " + message;

                     if(users.contains(name)) {

                         //不回发给发送此内容的客户端

                         broadCast(selector, socketChannel, message);

                     }

                 }

             } else if (num == -1) {

                 // -1 代表连接已经关闭

                 socketChannel.close();

             }

         }

     }

     private void broadCast(Selector selector, SocketChannel except, String content) throws IOException {

         //广播数据到所有的SocketChannel中

         for(SelectionKey key : selector.keys())

         {

             Channel targetchannel = key.channel();

             //如果except不为空，不回发给发送此内容的客户端

             if(targetchannel instanceof SocketChannel && targetchannel!=except)

             {

                 SocketChannel dest = (SocketChannel)targetchannel;

                 dest.write(charset.encode(content));

             }

         }

     }

     public static int OnlineNum(Selector selector) {

         int res = 0;

         for(SelectionKey key : selector.keys())

         {

             Channel targetchannel = key.channel();

             if(targetchannel instanceof SocketChannel)

                 res++;

         }

         return res;

     }

     public static void main(String[] args) throws IOException {

         new ChatServer().init();

     }

 }

客户端：

 package com.lee.demo.nio;

 import java.io.IOException;

 import java.net.InetSocketAddress;

 import java.nio.ByteBuffer;

 import java.nio.channels.SelectionKey;

 import java.nio.channels.Selector;

 import java.nio.channels.SocketChannel;

 import java.nio.charset.Charset;

 import java.util.Iterator;

 import java.util.Scanner;

 import java.util.Set;

 public abstract class ChatClient {

     private Selector selector = null;

     public static final int port = 8765;

     private Charset charset = Charset.forName("UTF-8");

     private SocketChannel sc = null;

     private String name = "";

     private static String USER_EXIST = "system message: user exist, please change a name";

     private static String USER_CONTENT_SPILIT = "#";

     public void init() throws IOException

     {

         selector = Selector.open();

         //连接远程主机的IP和端口

         sc = SocketChannel.open(new InetSocketAddress("127.0.0.1", port));

         sc.configureBlocking(false);

         sc.register(selector, SelectionKey.OP_READ);

         //开辟一个新线程来读取服务器端的数据

         new Thread(new ClientThread()).start();

         //在主线程中 从键盘读取数据输入到服务器端

         Scanner scan = new Scanner(System.in);

         try {

             while (scan.hasNextLine()) {

                 String line = scan.nextLine();

                 if ("".equals(line))

                     continue; // 不允许发空消息

                 if ("".equals(name)) {

                     name = line;

                     line = name + USER_CONTENT_SPILIT;

                 } else {

                     line = name + USER_CONTENT_SPILIT + line;

                 }

                 sc.write(charset.encode(line));// sc既能写也能读，这边是写

             }

         } finally {

             scan.close();

         }

     }

     private class ClientThread implements Runnable

     {

         public void run()

         {

             try

             {

                 while(true) {

                     int readyChannels = selector.select();

                     if(readyChannels == 0) continue;

                     //可以通过这个方法，知道可用通道的集合

                     Set<SelectionKey> selectedKeys = selector.selectedKeys();

                     Iterator<SelectionKey> keyIterator = selectedKeys.iterator();

                     while(keyIterator.hasNext()) {

                          SelectionKey sk = (SelectionKey) keyIterator.next();

                          keyIterator.remove();

                          dealWithSelectionKey(sk);

                     }

                 }

             }

             catch (IOException io)

             {}

         }

         private void dealWithSelectionKey(SelectionKey sk) throws IOException {

             if(sk.isReadable())

             {

                 //使用 NIO 读取 Channel中的数据，这个和全局变量sc是一样的，因为只注册了一个SocketChannel

                 //sc既能写也能读，这边是读

                 SocketChannel sc = (SocketChannel)sk.channel();

                 ByteBuffer buff = ByteBuffer.allocate(1024);

                 String content = "";

                 while(sc.read(buff) > 0)

                 {

                     buff.flip();

                     content += charset.decode(buff);

                 }

                 //若系统发送通知名字已经存在，则需要换个昵称

                 if(USER_EXIST.equals(content)) {

                     name = "";

                 }

                 System.out.println(content);

                 sk.interestOps(SelectionKey.OP_READ);

             }

         }

     }

 }

自己生成一个类，将Client这个抽象类继承，执行就可以了。观看结果的时候，会有个小地方需要注意，就是Eclipse中，console的结果，需要开启多个控制台，要不会发生混乱。

方法：

第一步：

第二步：

左侧红框，pin console ，作用是锁定console，固定显示选择的线程的输出；
右侧红框，作用是线程选择显示哪个线程的输出。

巴特西

NIO 多人聊天室

最新文章

热门文章