NIO 网络编程 群聊案例

最新推荐文章于 2024-04-27 08:51:11 发布
最新推荐文章于 2024-04-27 08:51:11 发布
阅读量156 收藏
点赞数 1
分类专栏： java学习
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_42962779/article/details/116298942
版权

前言

最近在学习B站尚硅谷的netty的网络编程课程，非常感谢硅谷，硅谷威武！感兴趣的朋友，也可以去看一下。
学习netty之前，学习了BIO ,NIO，给后续netty课程打下扎实基础，现分享一下NIO 的群聊的一个案例 ，案例仅作为自己笔记
需要对NIO 的 三大组件有些了解哦，通道，选择器，buffer（缓冲区）

服务端代码流程：
客户端发起连接，服务端进行监听，当有事件发生时，服务器根据不同事件做不同处理
连接事件：服务端会为每个连接的客户端创建对应的通道，并注册到选择器，
读取事件：服务端会将通道中的数据读到buffer中，然后再进行转发，转发排除自己
客户端代码流程：

客户端发起连接，并开启一个线程循环去读取服务端转发过来的数据，主线程则阻塞，等待用户输入数据，然后发送，将数据写入通道，服务器端再从通道内获取数据

下面我贴上代码

服务端

package com.bio.demo;

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

/**
 * @author yanjun.liu
 * @date 2021/4/29--10:42
 * <p>
 * GroupChatServer 服务端的职责：
 * 1.初始化  selector ，serverSocketChannel 并且进行绑定ip 端口，并且将自己注册到selector上，指定监听的事件（连接事件）
 * 2.开启监听，并且处理selector 上，发送的事件（根据不同事件做不同处理）
 * 如果是客户端连接事件  需要通过连接获取客户端socketChannel，然后设置非阻塞，并且将这个客户端socketChannel注册在selector，并指定监听的事件
 * 如果发送事件的户端是发送数据，那么就是读事件，serverSocketChannel需要读取客户端的数据
 */
public class GroupChatServer {

    private Selector selector;

    private ServerSocketChannel serverSocketChannel;

    private static final int PORT = 8888;

    /**
     * 构造器初始化工作
     *
     * @throws Exception
     */
    public GroupChatServer() throws Exception {
        //创建初始化selector
        selector = Selector.open();
        //创建初始化serverSocketChannel
        serverSocketChannel = ServerSocketChannel.open();
        //设置非阻塞
        serverSocketChannel.configureBlocking(false);
        //绑定ip端口
        serverSocketChannel.bind(new InetSocketAddress(PORT));
        //将serverSocketChannel 注册到 selector上，SelectionKey.OP_ACCEPT 客户端连接事件
        serverSocketChannel.register(selector, SelectionKey.OP_ACCEPT);
    }


    /**
     * 服务端需要监听selector 上发送的事件，根据不同事件，做出不同处理
     */
    public void listen() throws Exception {

        while (true) {
            //Selector 进行监听 select 方法，返回有事件发生的通道的个数,不传毫秒值会阻塞，直到拿到至少一个通道返回
            // 重载方法，此方法还可以传入一个毫秒值，表示等待多少毫秒之后返回
            int select = selector.select();
            //说明有事件发送，进行处理
            if (select > 0) {
                //获取selector 上发送事件的SelectionKey，这里注意！SelectionKey 和通道是有绑定关系的，
                //也可以说 获取selector 上发送事件的通道 socketChannel
                Set<SelectionKey> selectionKeys = selector.selectedKeys();

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

                while (iterator.hasNext()) {
                    //取出每个有事件发送的  SelectionKey
                    SelectionKey key = iterator.next();
                    //如果是客户端连接事件，监听建立连接，并且拿到对应的socketChannel，
                    // 设置非阻塞，并且将此 socketChannel注册在selector 上并设置监听事件
                    if (key.isAcceptable()) {
                        //serverSocketChannel.accept(); 此方法本身是阻塞的，但是代码进入if，就说明有客户端连接，因此这个方法必定会往下执行，不阻塞
                        SocketChannel socketChannel = serverSocketChannel.accept();
                        System.out.println("获取到客户端的socketChannel：" + socketChannel.hashCode());
                        socketChannel.configureBlocking(false);
                        //设置读事件，
                        socketChannel.register(selector, SelectionKey.OP_READ);

                        System.out.println(socketChannel.getRemoteAddress() + "：上线了");
                    }
                    //读事件，将数据从通道读取到buffer中
                    if (key.isReadable()) {
                        redDate(key);
                    }
                    //进入while，处理完这个事件之后，需要将这个事件从selectedKeys 数组中，将当前selectedKey 删除
                    iterator.remove();
                }

            } else {
                System.out.println("客户端没有事件发生，继续循环等待");
            }

        }

    }


    public void redDate(SelectionKey key) throws IOException {
        //通过SelectionKey 反向获取 SocketChannel
        SocketChannel socketChannel = (SocketChannel) key.channel();
        //创建buffer
        ByteBuffer buffer = ByteBuffer.allocate(1024);
        int count = 0;
        try {
            //读取 从通道读取到buffer，返回读取到的长度
            count = socketChannel.read(buffer);
            if (count > 0) {
                String msg = new String(buffer.array());
                System.out.println("服务器收到客户端->" + socketChannel.getRemoteAddress() + "-发送的消息msg：" + msg);
                System.out.println("服务器开始转发消息===============================");
                //重点！服务端接收到消息了，还需要将消息转发给其客户端，当然要排除发消息的这个客户端哦
                //获取所有注册在此selector 上通道 对应的SelectionKey
                Set<SelectionKey> keys = selector.keys();
                Iterator<SelectionKey> it = keys.iterator();
                while (it.hasNext()) {
                    SelectionKey next = it.next();
                    Channel channel = (Channel) next.channel();
                    //不是他自己，服务端就转发消息给客户端  socketChannel 为发消息的客户端
                    if (channel instanceof SocketChannel && channel != socketChannel) {
                        ByteBuffer wrap = ByteBuffer.wrap(msg.getBytes());
                        ((SocketChannel) channel).write(wrap);
                    }
                }
            }
        } catch (IOException e) {
            System.out.println(socketChannel.getRemoteAddress() + ": 离线了===============================");
            //取消注册关闭通道
            key.cancel();
            socketChannel.close();
        }
    }

    public static void main(String[] args) throws Exception {
        GroupChatServer groupChatServer = new GroupChatServer();

        groupChatServer.listen();
    }

}

客户端

package com.bio.demo;

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;
import java.util.Set;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;

/**
 * @author yanjun.liu
 * @date 2021/4/29--17:10
 */
public class GroupChatClient {

    private SocketChannel socketChannel;
    private Selector selector;
    private String userName;

    /**
     * 客户端类 初始化
     *
     * @throws IOException
     */
    public GroupChatClient() throws IOException {
        //客户端进行连接服务端
        socketChannel = SocketChannel.open(new InetSocketAddress("127.0.0.1", 8888));
        //创建selector
        selector = Selector.open();
        //设置为非阻塞
        socketChannel.configureBlocking(false);
        //将客户端此通道 注册在 selector上，并指定监听的事件为读 read
        socketChannel.register(selector, SelectionKey.OP_READ);
        //初始化客户端名称
        userName = socketChannel.getRemoteAddress().toString().substring(1);
        System.out.println("客户端 is  ok");
    }

    /**
     * 客户端发送消息
     *
     * @param massage
     * @throws Exception
     */
    public void sendMessage(String massage) throws Exception {
        String msg = userName + "说： " + massage;
        ByteBuffer wrap = ByteBuffer.wrap(msg.getBytes());
        //通过buff 中的数据 ，写入客户端通道，（服务端会监听，得到此通道，并读取此通道内的数据）
        socketChannel.write(wrap);
    }

    /**
     * 客户端也要读取服务端 转发  过来的数据，并显示
     *
     * @throws IOException
     */
    public void readMassage() throws IOException {
        //获取此 selector 有事件发生的 通道个数，如果不删除执行过的key，这里不会阻塞，而是返回0
        int select = selector.select();

        if (select > 0) {
            //获取此selector 发生事件的  SelectionKey
            Set<SelectionKey> selectionKeys = selector.selectedKeys();
            Iterator<SelectionKey> iterator = selectionKeys.iterator();
            while (iterator.hasNext()) {
                SelectionKey key = iterator.next();
                //处理读事件
                if (key.isReadable()) {
                    //通过SelectionKey 反现获取对应的通道
                    SocketChannel channel = (SocketChannel) key.channel();
                    System.out.println("客户端的通道对象为：" + channel);
                    ByteBuffer buff = ByteBuffer.allocate(1024);
                    //将通道里面的数据读取到buff中
                    channel.read(buff);
                    String msg = new String(buff.array());
                    System.out.println(msg);
                    //删除当前事件
                    iterator.remove();
                }
            }
        } else {
            System.out.println("没有可用的通道");
        }
    }


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

        GroupChatClient groupChatClient = new GroupChatClient();

        //启动一个线程去读取数据
        ExecutorService executorService = Executors.newFixedThreadPool(1);
        executorService.execute(new Runnable() {
            @Override
            public void run() {
                //一直尝试读取服务端发送过来的数据,每割两秒
                while (true) {
                    try {
                        groupChatClient.readMassage();
                        Thread.currentThread().sleep(2000);
                    } catch (Exception e) {
                        e.getStackTrace();
                    }
                }
            }
        });

        //主线程等待用户输入（scanner 阻塞）
        Scanner scanner = new Scanner(System.in);
        while (scanner.hasNextLine()) {
            String s = scanner.nextLine();
            groupChatClient.sendMessage(s);
        }

    }
}

运行

依次启动服务端，然后启动客户端即可，进行测试

Sir_小三
关注
专栏目录
基于NIO的群聊.zip
01-10
Java NIO（New IO）是Java 1.4版本引入的一个新特性，它为Java应用程序提供了非阻塞I/O操作的能力，与传统的IO（Blocking IO）模型相比，NIO具有更...对于想要提升Java网络编程能力的人来说，这是一个很好的学习案例。
netty学习：bio，nio到netty各种使用案例，包括基础使用案例，各api使用方法，零拷贝，websocket，群聊，私聊，编码，解码，自定义协议，protobuf等使用案例，rpc服务器，客户端等等学习
02-05
jdk原生的nio网络编程 jdk原生的React器编程模型（使用选择器）聊天室 零拷贝使用案例文件上传 netty的演进模型（3中React器使用案例线程池的添加时机）。 NioEventLoopGroup中的成员变量分析（线程池） ...
NIO网络编程
dingmb的博客
11-14 101
负责配合缓冲区进行数据的传递channel通道与流的区别通道可以同时进行读写，而流只能读或只能写通道可以实现异步读写数据通道可以从缓冲区读数据，也可以向缓冲区写数据Channel是一个接口，主要实现类有：FileChannel，SocketChannel，ServerSocketChannelNIO是非阻塞的IO方式，可以用一个线程处理多个客户端的连接，这里就会使用到选择器Selector（也叫多路复用器）。
Netty: NIO网络编程
玉汝于成
04-27 517
NIO介绍Java NIO的Buffer类是一个用于特定基本数据类型的容器。它是一个对象，包含一些要写入或者要读出的数据。在NIO中，所有的数据都是用Buffer处理的。在数据读写之前，需要先放入Buffer，或者从Buffer中取出。Buffer对象中提供了一组方法，可以轻松的使用内存块，此外缓冲区对象那中内置了一些机制，能够追踪和记录缓冲区的状态变化情况。分配Buffer。
网络编程之NIO
Strange_boy的博客
05-09 530
原文链接 基本介绍 1、NIO（non-blocking IO）是JDK提供的新API，从JDK1.4开始，Java提供了一系列改进的输入/输出新特性，被统称为NIO（即 New IO）, 是同步非阻塞的 2、NIO 有三大核心部分：Channel(通道)、Buffer(缓冲区)、Selector(选择器) 3、 NIO 是面向缓冲区，或者面向块编程的。数据读取到一个它稍后处理的缓冲区，需要时可在缓冲区中前后移动，这就增加了处理过程中的灵活性，使用它可以提供非阻塞式的高伸缩性网络 4、NIO的非阻塞模式，
第三章 第二节NIO网络编程应用实例-群聊系统
qq_44850917的博客
12-17 460
NIO群聊系统案例实现
NIO群聊系统案例---网络编程NIO
Gopuwe的博客
01-29 272
一、从BIO到NIO 前面写过BIO的相关代码，BIO的问题很突出： 一个请求要对应一个线程，当并发数比较大时，需要大量的线程，造成系统资源占用比较大 当连接建立时，读写操作是阻塞的，所以当一个请求暂时不进行读写操作时，就会造成资源的浪费 为了解决上述的问题，jdk1.4引入了NIO NIO全称为 java non-blocking IO看这个名字就可以知道是java的非阻塞IO，NIO是可以通过一个线程来处理多个请求的操作的，而不是像BIO一样必须要一请求 —一线程这种模型，NIO有以下特点： NI
Java NIO 应用案例：实现一个简单的群聊系统
正在努力工作的搬砖人
04-23 2213
本文基于NIO实现了一个简单的群聊系统来巩固NIO所学的知识。该案例实现了服务器端和客户端之间的数据简单通讯。 服务器端功能：监测用户上线，离线；实现客户端消息的转发功能（将该客户端的消息转发给其它客户端）。 客户端功能：通过 channel 无阻塞地发送消息给其它所有用户，同时可以接受其它用户发送的消息（由服务器转发得到）。
三、JAVA NIO 编程
donkeyboy001的博客
08-04 305
JAVA NIO 编程
Netty专题-（3）NIO网络编程
weixin_43525722的博客
01-28 264
之前在上一章中介绍了NIO的三大核心类Selector 、 Channel 和 Buffer，这一章我们将利用这些核心进行编程实现相关的一些功能。在正式进入编程之前我们还需要介绍一些概念。 1 NIO网络编程关系图 （1）当客户端连接时，会通过 ServerSocketChannel 得到 SocketChannel （2）Selector 进行监听 select 方法, 返回有事件发生的通道的个数 （3）将 socketChannel 注册到 Selector 上, register(Selector
网络编程-NIO案例 与 AIO 案例
qq_43259860的博客
02-24 613
案例说明：一个简单的群聊实现，支持重复上下线。
基于NIO非阻塞的java聊天demo（支持单聊和群聊）
11-25
它不仅涉及到网络编程的基础知识，如套接字通信，还涵盖了多线程、并发控制以及高效数据传输的技巧，是学习和理解Java NIO体系结构的一个很好的实践案例。通过深入研究和分析这个项目，开发者能够更好地掌握NIO在...
nio、bio、netty的一些案例
01-19
本资源主要涵盖了三种不同的I/O模型：BIO（ Blocking I/O）、NIO（Non-blocking I/O）和Netty，这些都是Java平台上的重要网络编程技术。下面将详细介绍这些概念及其在实际应用中的案例。 首先，BIO（阻塞I/O）是最...
基于java aio研发的网络编程框架，从收集到的案例来看，用t-io做物联网、IM、客服的比较多，堪称殿堂级网络开发框架
最新发布
05-27
Java AIO，全称为Asynchronous Input/Output，是Java NIO的一个扩展，它提供了一种非阻塞的I/O操作方式，使得开发者可以更高效地处理网络通信。T-io就是一个基于Java AIO实现的高性能、易用且稳定的网络编程框架。它...
LocalDateTime 日期格式化
热门推荐
qq_42962779的博客
06-22 5万+
获取当前时间 LocalDateTime dateTime = LocalDateTime.now(); 对当前日期进行格式化 String date=DateTimeFormatter.ofPattern("yyyy-MM-dd 00:00:00").format(dateTime);
SpringBoot上传文件 MultipartFile.getBytes 导致内存溢出
qq_42962779的博客
04-07 1万+
记录一下生产环境上传大文件 发生的一次内存溢出问题 管理平台在上传 大文件时抛出错误 OOM异常（jvm 内存溢出，就是内存不够用了），除了上传文件以外，其它操作没有什么问题 经过排查发现，后端controller接口 使用了 MultipartFile.getBytes() 去拿到文件的字节数组，试想下如果上传2个g的视频，那么这个bytes数组得多大？需要占用多少内存？经常网上查找，找到了一个方法，通过拷贝流的方式来做 错误的上传方式 FileUtils.uploadFile(file.get
java 多线程第一章 理论概念笔记 总结
qq_42962779的博客
03-29 3220
线程的创建 1.继承Thread，重写run方法， 创建 Thread 对象 调用 Thread 对象的start方法，让线程进入就绪状态 这种方式没什么好说的，继承Thread类，重写run方法就行 2.实现 Runnable 接口，实现接口中run方法，并且创建 Thread对象，将Runnable任务对象传递进Thread的构造方法，然后在调用 Thread 对象的start方法，源码调用流程：当线程被调度，执行Thread类的run方法，线程对象的run方法判断传进来的Runnable任务对象不为n
mybatis xml 日期格式化
qq_42962779的博客
06-17 3016
<select id="count" resultType="java.lang.Integer"> select count(*) from ai_appointment_visitor where 1=1 <if test="entity.opStatus != null and entity.opStatus != ''"> op_status = #{entity.opStatus} &.
NIO网络编程之Selector选择器详解
NIO完成网络编程 NIO（New I/O）是一种Java API，用于实现高性能的网络编程。NIO的核心组件是Selector、SelectionKey和Channel，这些组件一起工作，实现了高效的网络编程。 Selector是NIO的核心组件之一，负责监听...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值