手写一个NIO群聊系统

已于 2023-02-06 15:20:04 修改
阅读量1k 收藏
点赞数
分类专栏： netty 文章标签： java 服务器 网络
于 2022-02-07 21:57:24 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/F15217283411/article/details/122815395
版权

一、浅谈NIO

1. 什么是NIO?

​​Java NIO​​：同步非阻塞，服务器实现模式为一个线程处理多个请求（连接)，即客户端发送的连接请求都会注册到多路复用器上，多路复用器轮询到连接有 ​​I/O​​ 请求就进行处理。【简单示意图】

手写的服务端，是利用多路复用的技术处理多个客户端的，类似于redis的单线程多路复用处理，有什么好处？比传统的BIO（Blocking I/O）处理速度更快，传统的BIO处理一个客户端，服务端得启动一个线程去处理，这个线程没法关心处理其他客户端，是1对1模式。
 
NIO（non-Blocking I/O）是一个线程处理多个客户端，相比BIO减少了对线程的开销，使用NIO开发群聊系统使用的主要Java类

SelectionKey

  1. SelectionKey，表示Selector和网络通道的注册关系，共四种：
  • int OP_ACCEPT：有新的网络连接可以 accept，值为 16
  • int OP_CONNECT：代表连接已经建立，值为 8
  • int OP_READ：代表读操作，值为 1
  • int OP_WRITE​​​：代表写操作，值为 ​​​4​​
  1. SelectionKey 相关方法

image.png

ServerSocketChannel

  1. ServerSocketChannel 在服务器端监听新的客户端 Socket 连接，负责监听，不负责实际的读写操作
  2. 相关方法如下
    image.png

SocketChannel

  1. SocketChannel，网络 IO 通道，具体负责进行读写操作。NIO 把缓冲区的数据写入通道，或者把通道里的数据读到缓冲区。
  2. 相关方法如下
    image.png

二、群聊系统开发

1. 原理理解模型

服务端：

package com.fyp.nio;

import java.io.IOException;
import java.net.InetSocketAddress;
import java.nio.ByteBuffer;
import java.nio.channels.*;
import java.util.Iterator;
import java.util.Set;

/**
 * @Auther: fyp
 * @Date: 2022/2/5
 * @Description: NIO服务器
 * @Package: com.fyp.nio
 * @Version: 1.0
 */
public class NIOServer {
    public static void main(String[] args) throws IOException {
        //创建ServerSocketChannel -> ServerSocket
        ServerSocketChannel serverSocketChannel = ServerSocketChannel.open();

        //得到一个Selector对象
        Selector selector = Selector.open();

        //绑定一个端口6666，在服务端监听
        serverSocketChannel.socket().bind(new InetSocketAddress(6666));

        //设置为非阻塞
        serverSocketChannel.configureBlocking(false);

        //把 serverSocketChannel 注册到 selector, 关注事件 为 OP_ACCEPT
        serverSocketChannel.register(selector, SelectionKey.OP_ACCEPT);

        //循环等待客户端连接
        while (true) {
            //这里我们等待1秒，如果没有事件发生（连接事件）
            if (selector.select(1000) == 0) {//没有事件发生
                System.out.println("服务器等待了1秒，无连接");
                continue;
            }

            //如果返回的 > 0, 就获取到相关的 selectionKey集合
            //1. 如果返回的 > 0, 表示已经获取到关注的事件
            //2. selector.selectedKeys() 返回关注事件的集合
            //通过 selectionKeys 反向获取通道
            Set<SelectionKey> selectionKeys = selector.selectedKeys();

            //遍历 Set<SelectionKey>, 使用迭代器
            Iterator<SelectionKey> keyIterator = selectionKeys.iterator();

            while (keyIterator.hasNext()) {
                //获取到selectionKey
                SelectionKey key = keyIterator.next();
                //根据key 对应的通道发生的事件做相应处理
                if (key.isAcceptable()) { //如果是OP_ACCEPT, 表示新的客户端连接
                    //给该客户端生成一个 SocketChannel
                    SocketChannel socketChannel = serverSocketChannel.accept();
                    System.out.println("客户端连接成功！生成了一个socketChannel " + socketChannel.hashCode());
                    //将 SocketChannel 设置为非阻塞
                    socketChannel.configureBlocking(false);
                    //将socketChannel注册到 selector上, 关注事件为OP_READ, 同时给socketChannel
                    //关联一个Buffer
                    socketChannel.register(selector, SelectionKey.OP_READ, ByteBuffer.allocate(1024));
                    System.out.println("客户端连接后 ，注册的selectionkey 数量=" + selector.keys().size());
                }
                if (key.isReadable()) { //发生OP_READ
                    // 通过key 反向获取对应的channel
                    SocketChannel channel = (SocketChannel) key.channel();
                    //获取该channel关联的 buffer,在与客户端连接就已经创建好了
                    ByteBuffer buffer = (ByteBuffer) key.attachment();
                    channel.read(buffer);
                    System.out.println("from 客户端： " + new String(buffer.array()));
                }
                //手动从集合中移动当前的selectionKey, 防止重复操作
                keyIterator.remove();
            }

        }
    }
}

客户端：

package com.fyp.nio;

import java.io.IOException;
import java.net.InetSocketAddress;
import java.nio.ByteBuffer;
import java.nio.channels.SocketChannel;

/**
 * @Auther: fyp
 * @Date: 2022/2/6
 * @Description: 客户端
 * @Package: com.fyp.nio
 * @Version: 1.0
 */
public class NIOClient {
    public static void main(String[] args) throws IOException {
        //得到一个网络通道
        SocketChannel socketChannel = SocketChannel.open();
        //设置非阻塞
        socketChannel.configureBlocking(false);
        //提供服务端的 ip 和 端口
        InetSocketAddress inetSocketAddress = new InetSocketAddress("127.0.0.1", 6666);
        /*
            连接服务器
            1. 为非阻塞模式时，即不会等到方法执行完毕再返回，会立即返回，如果返回前已经连接成功，则返回true
            返回false 时，说明未连接成功，所以需要再通过while循环地finishConnect()完成最终的连接
            2. 为阻塞模式时，直到连接建立或抛出异常
            不会返回false，连接不上就抛异常，不需要借助finishConnect()
         */
        if (!socketChannel.connect(inetSocketAddress)) {
            while (!socketChannel.finishConnect()) {
                System.out.println("因为连接需要时间，客户端不会阻塞，可以做其他工作");
            }
        }
        //如果连接成功，就发送数据
        String str = "hello, 尚硅谷";
        ByteBuffer buffer = ByteBuffer.wrap(str.getBytes());
        //发送数据，将buffer 写入 channel
        socketChannel.write(buffer);
        System.in.read();


    }
}

2. 开发模型

实现要求：

  1. 服务器端：可以监测用户上线，离线，并实现消息转发功能
  2. 客户端：通过 Channel 可以无阻塞发送消息给其它所有用户，同时可以接受其它用户发送的消息（由服务器转发得到）

服务端：

package com.fyp.nio.groupchat;

import java.io.IOException;
import java.net.InetSocketAddress;
import java.net.Socket;
import java.nio.ByteBuffer;
import java.nio.channels.*;
import java.util.Iterator;

/**
 * @Auther: fyp
 * @Date: 2022/2/6
 * @Description: 群聊系统服务端
 * @Package: com.fyp.nio.groupchat
 * @Version: 1.0
 */
public class GroupChatServer {

    private Selector selector;
    private ServerSocketChannel listenChannel;
    private static final int PORT = 6667;

    public GroupChatServer() {

        try {
            selector = Selector.open();
            listenChannel = ServerSocketChannel.open();
            listenChannel.socket().bind(new InetSocketAddress(PORT));
            listenChannel.configureBlocking(false);
            listenChannel.register(selector, SelectionKey.OP_ACCEPT);



        } catch (IOException e) {
            e.printStackTrace();
        }

    }

    public void listen() {
        try {
            while (true) {
                // count 获取的是 在阻塞过程中 同时发生的 事件 数，直到有事件 发生，才会执行，否则一直阻塞
                /*
                    select 方法在 没有 客户端发起连接时， 会一直阻塞，至少有一个客户端连接，其他 客户端再 发起连接 不再阻塞，会立即返回
                 */
                int count = selector.select();
                System.out.println(count);
                if(count > 0) {// 有事件 处理
                    // 遍历得到 SelectionKey 集合
                    Iterator<SelectionKey> iterator = selector.selectedKeys().iterator();
                    while (iterator.hasNext()) {
                        //取出SelectionKey
                        SelectionKey key = iterator.next();
                        //监听到accept
                        if (key.isAcceptable()) {
                            SocketChannel sc = listenChannel.accept();
                            // 监听到 客户端 的 SocketChannel 总是默认为阻塞方式，需要重新设置
                            sc.configureBlocking(false);
                            //将该 sc 注册到 selector
                            sc.register(selector, SelectionKey.OP_READ);

                            System.out.println(sc.getRemoteAddress() + " 上线 ");
                        }

                        if (key.isReadable()) { // 通道发送 read 事件， 即通道是可读状态
                            //处理读
                            readData(key);
                        }
                        /*
                            每次  监听到 客户端后， selector会将 连接上的 客户端 选中， 并添加到 selectionKeys 中
                            要注册到 selector 上，使用该方法，selector 将 不再选中
                            如果没有移除，selector 不能选中 其他的 客户端连接
                            iterator.remove() 移除后，将释放 selector 中的 selectionKeys
                         */
                        iterator.remove();
                    }
                } else {
                    //System.out.println("等待....");
                }
            }
        } catch (IOException e) {
            e.printStackTrace();
        } finally {
            // 发送异常处理
        }
    }

    public void readData(SelectionKey key) {
        // 取到关联的 channel
        SocketChannel channel = null;
        try {
            // 得到 channel
             channel = (SocketChannel) key.channel();

             // 创建buffer
             ByteBuffer buffer = ByteBuffer.allocate(1024);

             int count = channel.read(buffer);

             // 根据 count 的值 做 处理
            if (count > 0) {
                // 把 缓冲区 的 数据 转成 字符串
                String msg = new String(buffer.array());
                // 输出该消息
                System.out.println("from 客户端： " + msg);
                //想其他客户端转发消息，专门写一个方法来处理
                sendInfoToOtherClients(msg, channel);
            }

        } catch (IOException e) {
            //e.printStackTrace();
            try {
                System.out.println(channel.getRemoteAddress() + "离线了");
                // 取消 注册
                key.cancel();
                // 关闭通道
                channel.close();
            } catch (IOException ioException) {
                ioException.printStackTrace();
            }
        }
    }

    // 转发消息给其他客户端（通道）
    private void sendInfoToOtherClients(String msg, SocketChannel self) throws IOException {
        System.out.println("服务器转发消息中....");
        // 遍历所有 注册到 selector 上 的 SockChannel, 并排除 self
        for (SelectionKey key : selector.keys()) {
            // 通过 key 取出 对应的 SocketChannel
            Channel targetChannel = key.channel();

            // 排除自己
            if (targetChannel instanceof SocketChannel && targetChannel != self) {
                // 转型
                SocketChannel dest = (SocketChannel) targetChannel;
                // 将 msg 存储到 buffer
                ByteBuffer buffer = ByteBuffer.wrap(msg.getBytes());
                // 将 buffer 的数据 写入 通道
                dest.write(buffer);
            }

        }
    }


    public static void main(String[] args) {
        // 创建 服务器 对象
        GroupChatServer groupChatServer = new GroupChatServer();
        groupChatServer.listen();
    }
}

客户端：

package com.fyp.nio.groupchat;


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.util.Iterator;
import java.util.Scanner;

/**
 * @Auther: fyp
 * @Date: 2022/2/7
 * @Description: 群聊系统客户端
 * @Package: com.fyp.nio.groupchat
 * @Version: 1.0
 */
public class GroupChatClient {

    //定义 相关 属性
    private final String HOST = "127.0.0.1";
    private final int PORT = 6667;
    private Selector selector;
    private SocketChannel socketChannel;
    private String username;

    // 构造器，完成初始化工作
    public GroupChatClient() throws IOException {

        selector = Selector.open();
        // 连接 服务器
        socketChannel = socketChannel.open(new InetSocketAddress("127.0.0.1", PORT));
        // 设置 非阻塞
        socketChannel.configureBlocking(false);
        // 将 channel 注册到 selector
        socketChannel.register(selector, SelectionKey.OP_READ);
        // 得到 username
        username = socketChannel.getLocalAddress().toString().substring(1);
        System.out.println(username + " is ok....");

    }

    // 向 服务器 发送 消息
    public void sendInfo(String info) {

        info = username + " 说：" + info;

        try {
            socketChannel.write(ByteBuffer.wrap(info.getBytes()));

        } catch (Exception e) {

        }
    }

    // 读取从 服务器 端 回复的 消息
    public void readInfo() {
        try {
            int readChannels = selector.select();
            if (readChannels > 0) {// 有可以用的 通道

                Iterator<SelectionKey> iterator = selector.selectedKeys().iterator();
                while (iterator.hasNext()) {

                    SelectionKey key = iterator.next();
                    if (key.isReadable()) {
                        // 得到 相关的 通道
                        SocketChannel sc = (SocketChannel) key.channel();
                        // 得到一个 Buffer
                        ByteBuffer buffer = ByteBuffer.allocate(1024);
                        // 读取
                        sc.read(buffer);
                        // 把缓存区的数据 转成 字符串
                        String msg = new String(buffer.array());
                        System.out.println(msg.trim());
                    }
                }
                iterator.remove();// 删除当前的selectionKey, 防止重复操作
            } else {
                //System.out.println("没有可以用的通道....");
            }
        } catch (IOException e) {
            e.printStackTrace();
        }
    }

    public static void main(String[] args) throws IOException {
        // 启动 客户端
        GroupChatClient chatClient = new GroupChatClient();
        // 启动一个线程，每隔3秒， 读取从 服务器 发送过来的数据
        new Thread() {
            @Override
            public void run() {
                while (true) {
                    chatClient.readInfo();

                    try {
                        Thread.currentThread().sleep(3000);
                    } catch (Exception e) {
                        e.printStackTrace();
                    }
                }
            }
        }.start();

        // 发送数据给 服务端
        Scanner scanner = new Scanner(System.in);

        while (scanner.hasNextLine()) {
            String s = scanner.nextLine();
            chatClient.sendInfo(s);
        }

    }

}

三、结束语

评论区可留言，可私信，可互相交流学习，共同进步，欢迎各位给出意见或评价，本人致力于做到优质文章，希望能有幸拜读各位的建议！

专注品质，热爱生活。
交流技术，奢求同志。

嗝屁小孩纸
关注
专栏目录
手写一个简化版的Tomcat（NIO版本）
撸起袖子加油干
02-08 298
一、摘要： 序号 实现方式 功能链接 1 BIO 手写一个简化版的Tomcat(BIO版本） 2 BIO-Plus 手写一个简化版的Tomcat（BIO升级版本） 3 NIO 手写一个简化版的Tomcat（NIO版本） 4 Netty 手写一个简化版的Tomcat（Netty版本） 二、demo编码 package com.jason.http.server.nio; import java.io.IOException
手写 tomcat nio
01-22
手写 tomcat nio http://knight-black-bob.iteye.com/blog/2408450
Java IO模型(BIO/NIO/IOM)原生代码手写
田宝宝的博客
10-24 569
Java IO模型(BIO/NIO/IOM)原生代码手写 原生BIO模型 package com.tcf.io.model.server.bio; import java.net.ServerSocket; import java.net.Socket; /*** * TODO TCF 阻塞IO-服务器 * @author Hasee *...
手写一个NIO传输实例
龙仞的博客
10-30 409
java socket编程大体有三个技术阶段，大致区别在于： bio（java1） 阻塞同步 流式传输 nio（java 1.4） 非阻塞同步块传输 适应于轻量级连接 如聊天 项目上基本用框架：Netty、Mina aio（java1.7） 异步非阻塞 适用于重量级 如相册服务 这里重点说一下NIO，实现它主要是由三个组件：1.selector（能够进行多路复用，一个线程可处理多个chan...
手写BIO、NIO、AIO服务器
wanger61的博客
03-19 203
1.BIO import java.io.BufferedReader; import java.io.IOException; import java.io.InputStream; import java.io.InputStreamReader; import java.net.ServerSocket; import java.net.Socket; import java.util.co...
NIO群聊系统（java）
05-31
NIO群聊系统（java）
Nio简单群聊.zip
08-18
在这个“Nio简单群聊.zip”压缩包中，我们可以预见到一个使用Java NIO实现的简单群聊系统。这个系统利用TCP协议进行网络通信，使多个用户能够通过连接到同一服务器进行实时聊天。 TCP（Transmission Control ...
自己手写nio和netty，不建议下载
04-01
在传统的Java I/O模型中，I/O操作是基于流（Stream）的，数据从一个流到另一个流，且通常都是阻塞的，即一个线程在等待数据读取或写入完成时会被挂起，直到I/O操作完成。这种方式在处理少量连接时效率尚可，但当面对...
基于NIO的群聊.zip
01-10
Java NIO（New IO）是Java 1.4版本引入的一个新特性，它为Java应用程序提供了非阻塞I/O操作的能力，与传统的IO（Blocking IO）模型相比，NIO具有更高的并发性能。在这个"基于NIO的群聊.zip"项目中，开发者利用NIO...
NIO 学习之 手写简易聊天室
LuoQiangQiang2017的博客
11-02 257
最近在学NIO，感觉目前对NIO的了解有了进一步的认识，不再像第一次接触它，面对,Buffer,Channel，Selector等新概念一头雾水。话不多少，开始记录下。 下面的概念性的东西，我参考了一下别人的博客。（说的挺好）真正理解NIO 简单说一下什么是NIO IO是面向缓冲区的。数据读取到一个它稍后处理的缓冲区，需要时可在缓冲区中前后移动，这就增加了处理过程中的灵活性。Java ...
手写简易tomcat
05-15
想学习web服务器的可以来看看，写的很基础，内容很详细，有源码和相关说明
手写JAVA NIO实现Socket通信及其过程中注意的问题
ccityzh的博客
07-26 2022
当然现在不需要自己手写NIO实现socket，都是在需要建立TCP/IP连接的程序中直接使用mina框架，或者netty框架， 后者使用的更多。本文仅仅是手写NIO，找一找学习NIO中遇到的问题，以及在调试的过程中学习对某些API的理解，文中只写了服务端，客户端用SocketTools这个工具充当，测试。
Java NIO手写简易版tomcat
weixin_44371237的博客
01-03 277
采用NIO，只用Channel和ByteBuffer两大组件 //采用NIO，只用Channel和ByteBuffer两大组件 public class tomcat { public static final String SEPARATOR = "\r\n"; //源码注释：requested maximum length of the queue of incoming connections. //BACK_LOG影响的accept队列大小 public static
NIO中的Selector 使用理解(手写版)
或左的博客
04-06 176
用于自我快速理解,字迹丑陋,之后有时间我会专门重新写博客来讲解
Java NIO基础：手写服务器逻辑解析
最新发布
m0_74022176的博客
06-29 334
以此为基础，将核心概念掌握再拓展，比如跨域问题，如何让服务器更加稳定等等。在Java中，NIO（New I/O）提供了一种基于通道（Channel）和选择器（Selector）的非阻塞I/O处理方式。今天，我们将基于Java NIO的基本概念，来解析一个简单的手写服务器逻辑。来监听传入的连接，并绑定到一个特定的IP地址和端口上。接着，我们将这个通道设置为非阻塞模式，以便在没有可用连接时，线程不会被阻塞。上有新的连接请求时，我们接受这个连接，并将新的。上，并指定我们关心的事件是新的连接请求（
基于jdk1.8 NIO手写http server，并且部署到阿里云服务器，浏览器可访问
JinglongSource的博客
10-19 821
如果没有tomcat，你的java程序是不是单机版？ 首先明确一个知识点（大前提），网络中的进程是通过socket来通信的 最近在学习socket（俗称 套接字），然后顺便了解一下http协议，手写一个http服务端出来玩一下，如果想实现其实也不是很复杂，需要了解一下http协议，了解一下如果使用socket编程，那就一切变得很简单了 ~~ # 1.0 简要了解 发送 一个http请求包含的信...
手写一个基于NIO的迷你版Tomcat
beifengtz
05-17 355
笔者也建立的自己的公众号啦，平时会分享一些编程知识，欢迎各位大佬支持~ 扫码或微信搜索北风IT之路关注 本文公众号地址：手写一个基于NIO的迷你版Tomcat 在很久之前看到了一篇文章写一个迷你版的Tomcat，觉得还是很有意思的，于是也跟着手敲了一遍，果不其然得出了想要的hello world，但是他这个是基于BIO的，正好最近看了并发编程的书，于是尝试将这位大佬的代码改一改，于是就有了这个基...
手写一个简单的RPC
yinbucheng的博客
04-21 2138
public class MyRPC { private static ExecutorService threadTool = Executors.newFixedThreadPool(5); // 客户端 public static Object getProxy(Class clazz, String ip, int port) throws Exception { //
mysql唯一索引死锁
m0_56255097的博客
07-29 231
一、网络编程基础回顾 1. Socket Socket本身有“插座”的意思，不是Java中特有的概念，而是一个语言无关的标准，任何可以实现网络编程的编程语言都有Socket。在Linux环境下，用于表示进程间网络通信的特殊文件类型，其本质为内核借助缓冲区形成的伪文件。既然是文件，那么理所当然的，我们可以使用文件描述符引用套接字。 与管道类似的，Linux系统将其封装成文件的目的是为了统一接口，使得读写套接字和读写文件的操作一致。区别是管道主要应用于本地进程间通信，而套接字多应用于网络进程间数据的传递。 可以
使用NIO写一个服务端
05-26
好的，以下是一个简单的使用NIO写的服务端示例代码： ```java import java.io.IOException; import java.net.InetSocketAddress; import java.nio.ByteBuffer; import java.nio.channels.SelectionKey; import java...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

嗝屁小孩纸

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值