【Java网络编程】基于BIO/NIO/AIO的多人聊天室（四）：NIO聊天室

最新推荐文章于 2021-04-17 21:14:56 发布
最新推荐文章于 2021-04-17 21:14:56 发布
阅读量1k 收藏
点赞数 1
分类专栏： 网络编程 文章标签： 网络 java nio socket
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/NoxUni/article/details/109408094
版权

课程《一站式学习Java网络编程 全面理解BIO/NIO/AIO》的学习笔记（四）：
NIO编程模型 & 基于NIO的多人聊天室实现

源码地址：https://github.com/NoxWang/web-program

【Java网络编程】基于BIO/NIO/AIO的多人聊天室（一）：java IO与内核IO
【Java网络编程】基于BIO/NIO/AIO的多人聊天室（二）：BIO聊天室
【Java网络编程】基于BIO/NIO/AIO的多人聊天室（三）：NIO概述与实践
【Java网络编程】基于BIO/NIO/AIO的多人聊天室（五）：AIO聊天室
【Java网络编程】基于BIO/NIO/AIO的多人聊天室（六）：思维导图

一、NIO编程模型

  1. 在Selector上注册服务器Channel，监听ACCEPT事件；
  2. 当Client1连接进服务器，ACCEPT事件触发，调用handles对该事件进行处理：向Selector上注册Client1的Channel的READ事件；
  3. 当Client1向服务器发送数据，READ事件触发，调用handles对该事件进行处理：转发消息；
  4. 当Client2连接进服务器，再次触发ACCEPT事件，同样调用handles进行相同处理，以此类推。

几个需要注意的点：

  • 与BIO不同，NIO编程模型中，accept操作与读写处理操作是在同一个线程中进行的。
  • 虽然使用Selector可实现非阻塞式调用，但Selector的select()方法是阻塞式的：如果当前没有Selector监听事件出现，则该方法阻塞（返回值为出现事件的数量）。
  • 同时可有多个事件被触发，调用Selector的selectedKeys()方法可以获得可操作Channel的SelectionKey集合。
    NIO编程模型

二、基于NIO的多人聊天室实现

2.1 服务端

仅需要一个线程。Selector需要监听两种事件：服务端Channel的ACCEPT事件，客户端Channel的READ事件。两种事件的具体处理在handles()方法中实现。具体实现见代码注释。

package server;

import java.io.Closeable;
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.ServerSocketChannel;
import java.nio.channels.SocketChannel;
import java.nio.charset.Charset;
import java.nio.charset.StandardCharsets;
import java.util.Set;

public class ChatServer {

    /** 默认监听端口 */
    private static final int DEFAULT_PORT = 8888;
    /** 用户自定义的监听端口 */
    private int port;

    /** 处理服务器端 IO 的通道 */
    private ServerSocketChannel server;
    /** 监听 channel 上发生的事件和 channel 状态的变化 */
    private Selector selector;

    /** 缓冲区大小 */
    private static final int BUFFER_SIZE = 1024;
    /** 用于从通道读取数据的 Buffer */
    private ByteBuffer rBuffer = ByteBuffer.allocate(BUFFER_SIZE);
    /** 用于向通道写数据的 Buffer */
    private ByteBuffer wBuffer = ByteBuffer.allocate(BUFFER_SIZE);

    /** 客户端退出命令 */
    private static final String QUIT = "\\quit";
    /** 指定编解码方式 */
    private Charset charset = StandardCharsets.UTF_8;

    public ChatServer() {
        this(DEFAULT_PORT);
    }

    public ChatServer(int port) {
        this.port = port;
    }

    /**
     * 服务端主逻辑
     */
    private void start() {
        try {
            // 创建一个新的通道，并设置为非阻塞式调用（open()方法产生的通道默认为阻塞式调用）
            server = ServerSocketChannel.open();
            server.configureBlocking(false);
            // 绑定监听端口
            server.socket().bind(new InetSocketAddress(port));

            // 创建Selector
            selector = Selector.open();
            // 在selector上注册serverChannel的accept事件
            server.register(selector, SelectionKey.OP_ACCEPT);
            System.out.println("启动服务器，监听端口：" + port + "...");

            while (true) {
                // select()方法为阻塞式调用，如果当前没有selector监听事件出现，则该方法阻塞（返回值为出现事件的数量）
                selector.select();
                // 获取所有被触发Channel的SelectionKey集合
                Set<SelectionKey> selectionKeys = selector.selectedKeys();
                for (SelectionKey key : selectionKeys) {
                    // 处理被触发的事件
                    handles(key);
                }
                selectionKeys.clear();
            }

        } catch (IOException e) {
            e.printStackTrace();
        } finally {
            // 关闭selector：解除注册，同时关闭对应的通道
            close(selector);
        }
    }

    /**
     * 需要处理两个事件：ACCEPT & READ
     */
    private void handles(SelectionKey key) throws IOException {
        // ACCEPT事件 --- 和客户端建立了连接
        if (key.isAcceptable()) {
            ServerSocketChannel serverChannel = (ServerSocketChannel) key.channel();
            // 获得连接进来的客户端的channel
            SocketChannel clientChannel = serverChannel.accept();
            // 转换为非阻塞式调用
            clientChannel.configureBlocking(false);

            // 注册该客户端channel的READ事件
            clientChannel.register(selector, SelectionKey.OP_READ);
            System.out.println(getClientName(clientChannel) + "已连接");
        }

        // READ事件 --- 客户端发送了消息
        else if (key.isReadable()) {
            SocketChannel clientChannel = (SocketChannel) key.channel();
            String fwdMsg = receive(clientChannel);
            if (fwdMsg.isEmpty() || readyToQuit(fwdMsg)) { // 客户端异常 or 客户端准备退出
                // 取消注册该通道上的该事件
                key.cancel();
                // 更改状态后，强制返回selector，令其重新检测
                selector.wakeup();
                System.out.println(getClientName(clientChannel) + "已断开");
            } else {
                System.out.println(getClientName(clientChannel) + ":" + fwdMsg);
                forwardMessage(clientChannel, fwdMsg);
            }
        }
    }

    /**
     * 读取客户端发来的消息
     * @param clientChannel 客户端 channel
     * @return 发来的消息
     * @throws IOException
     */
    private String receive(SocketChannel clientChannel) throws IOException {
        // 将rBuffer转为写模式（起到清空的作用）
        rBuffer.clear();
        // 从clientChannel中读取数据，写入rBuffer，直至channel中没有数据可读
        while ((clientChannel.read(rBuffer)) > 0);
        // 将rBuffer从写模式转换为读模式
        rBuffer.flip();
        // 使用utf8编码解码rBuffer，并转为字符串类型
        return String.valueOf(charset.decode(rBuffer));
    }

    /**
     * 转发消息给其他客户端
     * @param clientChannel 发来消息的客户端 channel
     * @param fwdMsg 需要转发的消息
     * @throws IOException
     */
    private void forwardMessage(SocketChannel clientChannel, String fwdMsg) throws IOException {
    	// keys()返回所有注册过的SelectionKey
        for (SelectionKey key : selector.keys()) {
            // key有效并且是客户端socket
            if (key.isValid() && key.channel() instanceof SocketChannel) {
                SocketChannel connectedClient = (SocketChannel) key.channel();
                if (!connectedClient.equals(clientChannel)) {
                    wBuffer.clear();
                    // 将需要转发的消息写进wBuffer，注意使用utf8编码
                    wBuffer.put(charset.encode(getClientName(clientChannel) + ":" + fwdMsg));
                    // 将wBuffer从写入模式转换为读取模式
                    wBuffer.flip();
                    while (wBuffer.hasRemaining()) {
                        connectedClient.write(wBuffer);
                    }
                }
            }
        }
    }

    private String getClientName(SocketChannel client) {
        return "客户端[" + client.socket().getPort() + "]";
    }

    private boolean readyToQuit(String msg) {
        return QUIT.equals(msg);
    }

    private void close (Closeable closeable) {
        if (closeable != null) {
            try {
                closeable.close();
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
    }

    public static void main(String[] args) {
        ChatServer chatServer = new ChatServer();
        chatServer.start();
    }
}

2.2 客户端

ChatClient.java：客户端主线程，Selector监听客户端的CONNECT事件和READ事件

package client;

import java.io.Closeable;
import java.io.IOException;
import java.net.InetSocketAddress;
import java.nio.ByteBuffer;
import java.nio.channels.ClosedSelectorException;
import java.nio.channels.SelectionKey;
import java.nio.channels.Selector;
import java.nio.channels.SocketChannel;
import java.nio.charset.Charset;
import java.nio.charset.StandardCharsets;
import java.util.Set;

public class ChatClient {

    /** 服务器地址 */
    private String host;
    private static final String DEFAULT_SERVER_HOST = "127.0.0.1";

    /** 服务器端口 */
    private int port;
    private static final int DEFAULT_SERVER_PORT = 8888;

    /** 客户端 Channel */
    private SocketChannel client;
    /** 监听Channel的Selector */
    private Selector selector;

    /** 缓冲区大小 */
    private static final int BUFFER_SIZE = 1024;
    /** 用于从通道读取数据的 Buffer */
    private ByteBuffer rBuffer = ByteBuffer.allocate(BUFFER_SIZE);
    /** 用于向通道写数据的 Buffer */
    private ByteBuffer wBuffer = ByteBuffer.allocate(BUFFER_SIZE);

    /** 客户端退出命令 */
    private static final String QUIT = "\\quit";
    /** 指定编解码方式 */
    private Charset charset = StandardCharsets.UTF_8;

    public ChatClient() {
        this(DEFAULT_SERVER_HOST, DEFAULT_SERVER_PORT);
    }

    public ChatClient(String host, int port) {
        this.host = host;
        this.port = port;
    }

    public boolean readyToQuit(String msg) {
        return QUIT.equals(msg);
    }

    private void close(Closeable closeable) {
        if (closeable != null) {
            try {
                closeable.close();
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
    }

    /**
     * 客户端主要逻辑
     */
    private void start() {
        try {
            // 创建Channel，并设置为非阻塞式调用
            client = SocketChannel.open();
            client.configureBlocking(false);

            // 创建Selector
            selector = Selector.open();
            // 注册 连接就绪CONNECT 事件
            client.register(selector, SelectionKey.OP_CONNECT);
            // 向服务器发送连接请求
            client.connect(new InetSocketAddress(host, port));

            while (true) {
                selector.select();
                Set<SelectionKey> selectionKeys = selector.selectedKeys();
                for (SelectionKey key : selectionKeys) {
                    handles(key);
                }
                selectionKeys.clear();
            }

        } catch (IOException e) {
            e.printStackTrace();
        } catch (ClosedSelectorException e) {
            // 用户正常退出
        } finally {
            close(selector);
        }
    }

    /**
     * 处理 CONNECT (连接就绪)和 READ （服务器转发消息）事件
     */
    private void handles(SelectionKey key) throws IOException {
        if (key.isConnectable()) {  // 处理 CONNECT
            SocketChannel clientChannel = (SocketChannel) key.channel();
            if (clientChannel.isConnectionPending()) {  // 返回true：连接已就绪
                // 结束连接状态，完成连接
                clientChannel.finishConnect();
                new Thread(new UserInputHandler(this)).start();
            }
            // 注册READ事件，以接收服务端转发的消息
            clientChannel.register(selector, SelectionKey.OP_READ);

        } else if (key.isReadable()) {  // 处理READ
            SocketChannel clientChannel = (SocketChannel) key.channel();
            String msg = receive(clientChannel);
            if (msg.isEmpty()) {
                // 服务器异常
                close(selector);
            } else {
                System.out.println(msg);
            }
        }
    }

    /**
     * 向服务端发送信息
     * @param msg 用户输入的信息
     * @throws IOException
     */
    public void send(String msg) throws IOException {
        if (msg.isEmpty()) {
            return;
        }

        wBuffer.clear();
        wBuffer.put(charset.encode(msg));
        wBuffer.flip();
        while (wBuffer.hasRemaining()) {
            client.write(wBuffer);
        }

        if (readyToQuit(msg)) {
            close(selector);
        }
    }

    /**
     * 读取服务端转发来的消息
     * @param clientChannel 客户端channel
     * @return 收到的消息
     * @throws IOException
     */
    private String receive(SocketChannel clientChannel) throws IOException {
        rBuffer.clear();
        while (clientChannel.read(rBuffer) > 0);
        rBuffer.flip();
        return String.valueOf(charset.decode(rBuffer));
    }

    public static void main(String[] args) {
        ChatClient chatClient = new ChatClient();
        chatClient.start();
    }
}

UserInputHandler.java：处理用户输入

package client;

import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;

public class UserInputHandler implements Runnable {
    ChatClient client;

    public UserInputHandler(ChatClient client) {
        this.client = client;
    }
    @Override
    public void run() {
        BufferedReader consoleReader = new BufferedReader(
                new InputStreamReader(System.in)
        );
        while (true) {
            try {
                String input = consoleReader.readLine();
                client.send(input);

                if (client.readyToQuit(input)) {
                    break;
                }
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
    }
}
流心芝士挞
关注
专栏目录
基于BIO模型实现多人聊天室
鹿谷門実的博客
03-07 241
服务端 在server包下创建ChatServer.java，该类用监听有没有任何的客户端发起建立连接的要求,如果有的话接收连接的要求并接收任意用户发来的消息转发给在线的所有用户 public class ChatServer { //端口号 private int DEFAULT_PORT = 8888; //用户输入quit时退出聊天 private f...
一站式学习Java网络编程 全面理解BIO_NIO_AIO，学习手记（六）
好想去看海
09-30 649
文章目录1. NIO模型分析2.聊天室项目代码重点知识2.1 服务器端2.1.1 字段2.1.2 主方法2.1.3 处理方法2.1.4 转发消息方法2.1.5 接收消息方法2.2 客户端2.2.1 字段2.2.2 主方法2.2.3 处理方法2.2.4 接收方法2.2.5 发送方法3. 测试结果4. 完整代码4.1 服务器端4.2 客户端4.3 客户端监听用户输入进程 1. NIO模型分析 在服务器端创建一个Selector，将ServerSocketChannel注册到Selector上，被Selec
基于BIO的的多人聊天室，
06-16
基于BIO的多人聊天室，使用了多线程技术，比如 CountDownLatch 和线程池等技术， 以udp为辅，tcp为主, 对于tcp服务器端：客户端的消息读写是双通道的，互不影响
java BIO/NIO/AIO 学习
weixin_34088598的博客
05-08 425
一、了解Unix网络编程5种I/O模型 1.1、阻塞式I/O模型 阻塞I/O(blocking I/O）模型，进程调用recvfrom，其系统调用直到数据报到达且被拷贝到应用进程的缓冲区中或者发生错误才返回。进程从调用recvfrom开始到它返回的整段时间内是被阻塞的。 1.2、非阻塞式I/O模型 当一个应用进程像这样对一个非阻塞描述字循环调用recvfrom时，我们称之为轮询（polling...
【Java网络编程】基于BIO/NIO/AIO的多人聊天室（二）：BIO聊天室
NoxUni的博客
10-30 492
课程《一站式学习Java网络编程 全面理解BIO/NIO/AIO》的学习笔记（二）： BIO编程模型 & 基于BIO的多人聊天室实现 一、BIO编程模型二、基于BIO的多人聊天室设计2.1 需求分析2.2 聊天室设计2.2.1 服务器端2.2.2 客户端三、基于BIO的多人聊天室实现3.1 服务端3.1.1 ChatServer.java3.2 客户端 一、BIO编程模型 BIO：阻塞式IO 线程 Acceptor 负责接收客户端发起的连接请求 每当有新客户端连接，服务器都为其创建一个新线程H.
多人在线聊天系统：BIO与NIO实现
阿七
03-20 255
服务端代码： public class ChatServer { private int port=8888; private final String quit="quit"; private ServerSocket serverSocket; private Map<Integer,Writer> connectedClients; //客户端的端口，和写入流。 ...
java网络编程源码-java-IO:java网络编程BIO，NIO,AIO源码示例
05-20
在Java中，有三种主要的I/O模型：BIO（Blocking I/O），NIO（Non-blocking I/O）和AIO（Asynchronous I/O）。这些模型各有特点，适用于不同的场景。 1. **BIO（阻塞I/O）** - BIO是最基础的I/O模型，它在Java早期...
"Java网络编程一站式学习:全面理解BIO:NIO:AIO1
一站式学习Java网络编程 全面理解BIO:NIO:AIO 本课程提供了一站式学习Java网络编程的全面指导。在这门课程中，学员将深入理解BIO（同步阻塞IO）、NIO（同步非阻塞IO）和AIO（异步非阻塞IO）这三个重要的网络编程...
手动搭建I/O网络通信框架3：NIO编程模型，升级改造聊天室
耶low的博客
04-14 172
第一章：手动搭建I/O网络通信框架1：Socket和ServerSocket入门实战，实现单聊 第二章：手动搭建I/O网络通信框架2：BIO编程模型实现群聊 第四章：手动搭建I/O网络通信框架4：AIO编程模型，聊天室终极改造 　　在第二章中用BIO编程模型，简单的实现了一个聊天室。但是其最大的问题在解释BIO时就已经说了：ServerSocket接收请求时（accept()方法）、...
使用Netty NIO重构Java聊天室
"java基于netty NIO的简单聊天室的实现" 本文将深入探讨如何使用Java的Netty框架实现一个基于NIO的简单聊天室。Netty是一个高性能、异步事件驱动的网络应用程序框架，用于快速开发可维护的网络服务。在本文中，我们...
一站式学习Java网络编程 全面理解BIO/NIO/AIO——学习笔记（1）
imahui的博客
04-17 271
目录前言模型发展1. URL解析与构造2. 域名DNS的解析过程3. 域名DNS查询的两种方式4. 网络分层及其协议 前言 模型发展 BIO Java 1.4以前 NIO Java 1.4 AIO Java 1.7 1. URL解析与构造 2. 域名DNS的解析过程 3. 域名DNS查询的两种方式 4. 网络分层及其协议 ...
一站式学习Java网络编程 全面理解BIO_NIO_AIO，学习手记（七）
方圆 Blog
07-23 976
AIO通信模型及实战
一站式学习Java网络编程 全面理解BIO_NIO_AIO，学习手记（八）
方圆 Blog
07-24 1169
AIO聊天室
一站式学习Java网络编程 全面理解BIO_NIO_AIO，学习手记（九）
方圆 Blog
07-25 755
完结总结
一站式学习Java网络编程 全面理解BIO_NIO_AIO，学习手记（四）
方圆 Blog
07-21 858
BIO聊天室实战
一站式学习Java网络编程 全面理解BIO_NIO_AIO，学习手记（一）
方圆 Blog
07-19 1207
网络相关的基础知识
一站式学习Java网络编程 全面理解BIO_NIO_AIO，学习手记（三）
方圆 Blog
07-20 527
BIO阻塞模型
Java NIO Selector深度解析与多人聊天室应用
"Java NIO Selector 是Java...通过学习和实践使用Java NIO Selector，开发者可以创建高性能、低延迟的网络应用程序，如服务器、并发客户端连接处理等。理解Selector的工作原理和用法，对于构建高效的并发系统至关重要。
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值