NIO 网络编程——群聊系统实现

最新推荐文章于 2023-05-10 15:53:58 发布
最新推荐文章于 2023-05-10 15:53:58 发布
阅读量362 收藏
点赞数
分类专栏： Netty Java 文章标签： java
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/KIMTOU/article/details/124518260
版权

在使用 NIO 之前，我们先来看一下传统 BIO 阻塞 IO 的实现。

Java BIO 工作机制

Java BIO 就是传统的 Java I/O 编程，其相关的类和接口在 java.io。

BIO(BlockingI/O)：同步阻塞，服务器实现模式为一个连接一个线程，即客户端有连接请求时服务器端就需要启动一个线程进行处理，如果这个连接不做任何事情会造成不必要的线程开销，可以通过线程池机制改善（实现多个客户连接服务器）。Java BIO 工作流程：

  1. 服务器端启动一个 ServerSocket。
  2. 客户端启动 Socket 对服务器进行通信，默认情况下服务器端需要对每个客户建立一个线程与之通讯。
  3. 客户端发出请求后，先咨询服务器是否有线程响应，如果没有则会等待，或者被拒绝。
  4. 如果有响应，客户端线程会等待请求结束后，再继续执行。

Java BIO 应用实例

  1. 使用 BIO 模型编写一个服务器端，监听 6666 端口，当有客户端连接时，就启动一个线程与之通讯。
  2. 要求使用线程池机制改善，可以连接多个客户端。
  3. 服务器端可以接收客户端发送的数据（telnet 方式即可）。
public class BIOServer {
    public static void main(String[] args) throws Exception{
        //如果有客户端连接，就创建一个线程与之通信
        ExecutorService executorService = Executors.newCachedThreadPool();
        ServerSocket serverSocket = new ServerSocket(6666);
        System.out.println("服务器启动了");
        while (true) {
            //监听，等待客户端连接
            Socket socket = serverSocket.accept(); //阻塞
            System.out.println("连接到一个客户端");
            executorService.execute(new Runnable() {
                @Override
                public void run() {
                    try {
                        byte[] bytes = new byte[1024];
                        InputStream inputStream = socket.getInputStream();
                        while (true) {
                            int read = inputStream.read(bytes); //阻塞
                            if (read == -1) break;
                            System.out.println(new String(bytes, 0, read));
                        }
                    } catch (IOException e) {
                        e.printStackTrace();
                    } finally {
                        System.out.println("关闭客户端连接");
                        try {
                            socket.close();
                        } catch (IOException e) {
                            e.printStackTrace();
                        }
                    }
                }
            });
        }
    }
}

为什么使用 NIO

传统 Socket 的 accept() 方法阻塞（等待客户端连接），输入流的 read() 方法阻塞（等待 OS 将数据从内核拷贝到用户空间）。也就是说 BIO 会让主线程进入阻塞状态，性能不高。就算使用多线程来解决，但在高并发的情况下，会创建很多线程，线程会占用内存，线程之间的切换也会浪费资源开销。

而 NIO 只有在连接/通道真正有读写事件发生时(事件驱动)，才会进行读写，就大大地减少了系统的开销。不必为每一个连接都创建一个线程，也不必去维护多个线程。避免了多个线程之间的上下文切换，导致资源的浪费。

NIO 和 BIO 的比较

  1. BIO 以流的方式处理数据，而 NIO 以块的方式处理数据，块 I/O 的效率比流 I/O 高很多。
  2. BIO 是阻塞的，NIO 则是非阻塞的。
  3. BIO 基于字节流和字符流进行操作，而 NIO 基于 Channel（通道）和 Buffer（缓冲区）进行操作，数据总是从通道读取到缓冲区中，或者从缓冲区写入到通道中。Selector（选择器）用于监听多个通道的事件（比如：连接请求，数据到达等），因此使用单个线程就可以监听多个客户端通道。
  4. Buffer 和 Channel 之间的数据流向是双向的。

NIO 实现群聊系统

服务端实现
public class NIOServer {
    private Selector selector;
    private ServerSocketChannel listenChannel;
    private static final int PORT = 6667;

    public NIOServer() throws IOException{
        // 初始化Selector选择器
        this.selector = Selector.open();
        // 初始化Channel通道
        this.listenChannel = getServerSocketChannel(selector);
    }

    /**
     * 初始化 ServerSocketChannel
     */
    private ServerSocketChannel getServerSocketChannel(Selector selector) throws IOException {
        // 开辟一个Channel通道
        ServerSocketChannel serverSocketChannel = ServerSocketChannel.open();
        // 通道设置为非阻塞模式
        serverSocketChannel.configureBlocking(false);
        // 通道绑定端口，开始监听
        serverSocketChannel.socket().bind(new InetSocketAddress(PORT));
        // 为了将Channel跟Selector绑定在一起，我们需要将Channel注册到Selector上，调用Channel的register()方法
        // 通道中数据的事件类型为OP_ACCEPT（通道与选择器之间的桥梁SelectionKey）
        serverSocketChannel.register(selector, SelectionKey.OP_ACCEPT);
        return serverSocketChannel;
    }

    /**
     * 监听
     */
    public void listen() {
        System.out.println("服务器开始监听......");
        try {
            while (true) {
                if (selector.select() == 0) {
                    continue;
                }
                //若select()返回大于0，则获取发生事件的SelectionKey
                Set<SelectionKey> selectionKeys = selector.selectedKeys();
                Iterator<SelectionKey> it = selectionKeys.iterator();
                while (it.hasNext()) {
                    SelectionKey key = it.next();
                    //手动从集合中移除当前SelectionKey，防止重复操作
                    it.remove();
                    if (key.isAcceptable()) { //判断是否为连接事件（表示有客户端连接）
                        //accept()为阻塞方法，但此时已经有事件发生，所以实际并不会阻塞
                        SocketChannel channel = listenChannel.accept();
                        channel.configureBlocking(false);
                        //将socketChannel注册到selector，关注事件为OP_READ
                        channel.register(selector, SelectionKey.OP_READ);
                        System.out.println("客户端连接: " + channel.getRemoteAddress());
                    } else if (key.isReadable()) {
                        //通过SelectionKey反向获取到关联的Channel与Buffer
                        SocketChannel channel = null;
                        try {
                            channel = (SocketChannel) key.channel();
                            ByteBuffer byteBuffer = ByteBuffer.allocate(1024);
                            int read = channel.read(byteBuffer);
                            if (read > 0) {
                                String msg = new String(byteBuffer.array());
                                System.out.println(msg);
                                notifyAllClient(msg, channel); //转发消息
                            }
                        } catch (IOException e) {
                            System.out.println("客户端 " + channel.getRemoteAddress() + ": 离线了...");
                            key.cancel(); //取消注册
                            channel.close();
                        }
                    }
                }
            }
        } catch (Exception e) {
            e.printStackTrace();
        } finally {
            try {
                //调用close()方法将会关闭Selector，同时也会将关联的SelectionKey失效，但不会关闭Channel
                selector.close();
                listenChannel.close();
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
    }

    /**
     * 转发消息到其他客户端
     */
    private void notifyAllClient(String msg, SocketChannel self) throws IOException {
        for (SelectionKey selectionKey : selector.keys()) {
            Channel channel = selectionKey.channel();
            if (channel instanceof SocketChannel && channel != self) {
                SocketChannel socketChannel = (SocketChannel) channel;
                ByteBuffer byteBuffer = ByteBuffer.wrap(msg.getBytes());
                socketChannel.write(byteBuffer);
            }
        }
    }

    public static void main(String[] args) throws IOException {
        new NIOServer().listen();
    }
}
客户端线程类
public class ClientThread extends Thread{

    private Selector selector;
    private SocketChannel socketChannel;
    private static final String HOST = "127.0.0.1";
    private static final int PORT = 6667;
    private String userName;

    public ClientThread(String userName) throws Exception{
        this.selector = Selector.open();
        this.socketChannel = getSocketChannel();
        this.userName = userName;
    }

    public SocketChannel getSocketChannel() throws Exception{
        SocketChannel socketChannel = SocketChannel.open();
        socketChannel.socket().connect(new InetSocketAddress(HOST, PORT)); //连接到远程地址
        socketChannel.configureBlocking(false);
        socketChannel.register(selector, SelectionKey.OP_READ);
        return socketChannel;
    }

    @Override
    public void run() {
        try {
            while (true) {
                readInfo();
            }
        } catch (Exception e) {
            e.printStackTrace();
        } finally {
            try {
                selector.close();
                socketChannel.close();
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
    }

    /**
     * 从服务器读取消息
     */
    public void readInfo() {
        try {
            int read = selector.select();
            if (read > 0) {
                Set<SelectionKey> selectionKeys = selector.selectedKeys();
                Iterator<SelectionKey> it = selectionKeys.iterator();
                while (it.hasNext()) {
                    SelectionKey key = it.next();
                    it.remove();
                    if (key.isReadable()) {
                        SocketChannel channel = (SocketChannel) key.channel();
                        ByteBuffer byteBuffer = ByteBuffer.allocate(1024);
                        channel.read(byteBuffer);
                        System.out.println(new String(byteBuffer.array()));
                    }
                }
            }
        } catch (IOException e) {
            e.printStackTrace();
        }
    }

    /**
     * 向服务器发送消息
     */
    public void sendInfo(String msg) {
        msg = userName + ": " + msg;
        ByteBuffer buffer = ByteBuffer.wrap(msg.getBytes());
        try {
            socketChannel.write(buffer);
        } catch (IOException e) {
            e.printStackTrace();
        }
    }

    public void close() {
        try {
            selector.close();
            socketChannel.close();
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
}
客户端实现
public class NIOClient {

    public static void main(String[] args) throws Exception{
        String userName = "小明";
        ClientThread client = new ClientThread(userName);
        client.start();
        BufferedReader reader = new BufferedReader(new InputStreamReader(System.in));
        String readLine;
        while ((readLine = reader.readLine()) != null) {
            if (readLine.equals("bye")) {
                client.close();
                System.exit(0);
            }
            client.sendInfo(readLine);
        }
    }
}
Kim_smile
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
Java NIO 网络编程初探
12-22
Java NIO 网络编程初探 1. Java NIO Java 1.4 版本添加了一个新的IO API，称为NIO（New IO）。NIO拥有所有IO的功能，但是操作方法却完全不一样。NIO支持面向缓冲区的、基于通道的IO操作。能够更加高效的进行IO操作。...
NIO网络编程
12-22
NIO网络编程 Selector选择器 进行监听，是新连接或已经连接，读写数据 常用方法 public static Selector Open(); 得到一个选择器对象 public int select(long timeout); 监听所有注册通道，存在IO流操作，将对应...
Linux-Socket实现模拟群聊（多人聊天室）
tua__的博客
04-04 2747
在linux系统上使用c语言开发简单多人聊天服务器
如何利用即时通讯app开发实现群聊功能？
zyk2905的博客
05-10 94
你还需要考虑如何向你的用户提供一个安全的聊天环境，以保护他们的隐私和安全。一旦你设计了你的群聊功能，你就可以开始实现它。即时通讯app开发是一项复杂的任务，但如果你能够设计和实现一个能够实现群聊功能的应用程序，那么你将为人们提供一种方便、实用和有趣的交流方式。希望本文能够帮助你了解如何开发即时通讯应用程序并实现群聊功能，以及如何选择适当的开发工具和增加其他功能。当你了解了这些基础知识后，你就可以开始设计你的应用程序的群聊功能。一旦你成功地实现了群聊功能，你可能想要增加其他功能来提高应用程序的价值。
基于WebSocket实现一个简易的群聊功能
weixin_45630885的博客
04-18 1717
本文主要来讲解如何使用WebSocket来实现一个简易的群聊功能 引入maven依赖 <dependency> <groupId>org.springframework.boot</groupId> <artifactId>spring-boot-starter-web</artifactId> <version>2.2.5.RELEASE</version> </dependency&g
Java NIO 应用案例：实现一个简单的群聊系统
正在努力工作的搬砖人
04-23 2128
本文基于NIO实现了一个简单的群聊系统来巩固NIO所学的知识。该案例实现了服务器端和客户端之间的数据简单通讯。 服务器端功能：监测用户上线，离线；实现客户端消息的转发功能（将该客户端的消息转发给其它客户端）。 客户端功能：通过 channel 无阻塞地发送消息给其它所有用户，同时可以接受其它用户发送的消息（由服务器转发得到）。
Netty基础，Netty实现群聊系统
ALiangXLogic的博客
03-28 653
NIO群聊系统 这里面的知识比较全面，用到了我们之前学习的三大组件，首先我先来给大家介绍本系统的功能 服务端功能 最基本的当然是注册功能，也就是将serverSocketChannel注册进Selector，Selector负责调度事件 监听、读取客户端发来的消息 收到客户端的信息后将其转发到其它客户端，完成群聊功能 客户端功能 连接服务端，注册进Selector 读写消息 以上就是群聊系统最基本的功能，我们直接上代码，每句话的含义我都标在它的顶上了 服务端源码 package com.hecl.desig
NIO群聊系统（java）
05-31
NIO群聊系统（java）
NIO网络编程原理与实战.xmind
05-26
https://blog.csdn.net/ykmeory/article/details/115603895
NIO网络编程-简易聊天室
08-07
内含详细注释，可以帮助小白理解熟悉NIO网络编程的具体步骤。其中NioServer是服务器端，NioClient是客户端，AClient、BClient、CClient是具体的客户。通过服务端和客户端的Channel通道，客户可以进行读写操作。在...
NIO系列：5.NIO群聊系统
天高任鸟飞，海阔凭鱼跃
03-13 3568
前面的文章介绍了NIO的三大核心组件并编写了BIO的一个demo实例，本文使用NIO写一个小应用实例，巩固并加深对NIO的理解。 实例要求： 1）编写一个 NIO 群聊系统，实现服务器端和客户端之间的数据简单通讯（非阻塞） 2）实现多人群聊 3）服务器端：可以监测用户上线，离线，并实现消息转发功能 4）客户端：通过channel 可以无阻塞发送消息给其它所有用户，同时可以接受其它用户发送的消息(有...
NIO原理，及实现群聊功能
z_z_k的博客
12-27 427
文章目录什么是NIONIO和原生IO有什么不同NIO的三大组件核心三大组件的关系buffer（缓冲区）Buffer的简单使用Buffer的注意事项channel（通道）FileChannel的简单使用selector（选择器）使用 selector 实现简单的读写通讯NIO实现简单的群聊功能 什么是NIO NIO是一种非阻塞，基于事件响应的IO NIO和原生IO有什么不同 IO有三种，BIO,NIO和AIO BIO： 就是jdk原生的IO，是一个同步阻塞的io（等待客户端链接的时候，等待读写请求的时候都
使用websocket实现群聊（多个群）
qq_38089964的博客
08-09 1万+
最近一个项目中需要用到一个用户实时聊天需求：需要很多用户（在不同的房间）进行实时聊天，也就是一个简单的聊天室，这里用的是websocket实现。 这里需要对每一个连接都指定两个参数：用户的userId和所加入的房间id（roomId）； @ServerEndpoint("/community/{ro_user}")使用｛ro_user｝来绑定请求参数，不同的用户连接的时候就把参数加入到连接的后...
java网络socket编程（七）之java中NIO实现聊天系统的群聊功能
zzjstudent的专栏
08-22 3484
1.服务器端代码 import java.io.IOException; import java.net.InetSocketAddress; import java.net.ServerSocket; import java.nio.ByteBuffer; import java.nio.channels.Channel; import java.nio.channels.Selectio
网络I/o编程模型7 Nio实现聊天室
健康平安的活着的专栏
05-15 421
一 nio实现聊天室 1.1 功能描述 服务器端：可以检测用户上线、离线，并实现消息的转发功能。 客户端：通过channel可以五阻塞发送消息给其它所有用户，同时可以接受其它用户发送的消息（有服务器转发得到） 使用NIO聊天系统，实现服务器端和客户端之间的数据非阻塞的简单通讯。 1.2 代码 1.服务端 package com.ljf.netty.nio.chat; import org.omg.Messaging.SyncScopeHelper; import java.io.IOExce
聊天室群聊以及私聊功能的实现
qq_43108252的博客
02-27 2757
之前的代码框架：part1 1 私聊功能的实现 1.1 客户端相关代码； 为客户端添加私聊功能，用户可以选择一名目标用户名，然后开始和目标进行私聊，指定目标后先发送目标名到服务器进行绑定，而后每条消息都发送到服务器，服务器再转发到目标用户。 客户端有两个线程，一个线程用于发送信息给对方，另外一个线程接收信息。 为服务器添加处理私聊业务的代码，服务器接收客户端发来的绑定信息和私聊，绑定目标用户并将每条私聊信息都转发到目标用户的客户端处。 当用户输入 exit 时，能够离开私聊，返回到主界面。 要面向对象编程
Netty剖析之NIO群聊系统
皓晨的架构笔记
02-01 241
前言 在前面我们详细讲解了BIO、NIO，本次我们将使用NIO来完成一个群聊系统，实现服务器端和客户端之间的数据简单通讯（非阻塞）; 群聊系统基本要求： 服务器端可监测客户端上线、离线、并转发客户端消息； 客户端可群发消息给其它用户，也可接收其它客户发送的消息； 代码示例 服务端： public class GroupChatServer { private Selector sel...
Netty实现一个简单的群聊系统
ITMANLZY的技术空间
08-02 218
Netty实现一个群聊系统。
IO（BIO），NIO，AIO的深度解析和区别
热门推荐
小马哥的博客
02-11 2万+
IO（BIO），NIO，AIO的深度解析和区别    IO    概念： Socket又称“套接字”，应用程序通常通过“套接字”向网络发出请求或者应答网络请求。   Socket和ServerSocket类库位于java.net包中，serverSocket用于服务器端，Socket是建立网络连接时使用的。在连接成功时，应用程序两端都会产生一个Socket实例，操作这个实例，完成所需
java nio网络编程示例
最新发布
07-11
以下是一个使用 Java NIO（New I/O）进行网络编程的简单示例： ```java import java.io.IOException; import java.net.InetSocketAddress; import java.nio.ByteBuffer; import java.nio.channels....

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值