Netty学习笔记_11(Netty群聊系统)

最新推荐文章于 2022-06-13 10:30:37 发布
最新推荐文章于 2022-06-13 10:30:37 发布
阅读量347 收藏
点赞数
分类专栏： Netty 笔记 文章标签： java netty
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/feiku_ysu/article/details/107800403
版权
Netty 同时被 2 个专栏收录
15 篇文章 0 订阅
订阅专栏
笔记
15 篇文章 0 订阅
订阅专栏

一、Netty群聊系统开发要求

  1. 编写一个Netty群聊系统，实现服务器端和客户端之间的数据简单通信（非阻塞）
  2. 实现多人群聊
  3. 服务器端：检测用户上线、离线、转发客户端消息
  4. 客户端：通过channel可以无阻塞发送消息给其他客户，同时可以接收其他客户端发送的消息（服务器转发得到）

二、设计与开发

2-1、服务器端

  1. 首先要设置监听端口，服务器将通过该端口与客户端交换信息，发送和接收数据；
  2. 初始化事件循环组EventLoopGroup，这里初始化两个事件循环组bossGroup和workerGroup。其中，bossGroup主要处理新来的客户端连接，workerGroup主要负责连接建立以后的IO事件；
  3. 初始化Netty的启动类ServerBootStrap，通过链式调用配置参数：【设置事件循环对象：bossGroup用于处理accept事件，workerGroup用于处理已建立连接的IO请求】——【构造serverSocketChannel的工厂类】——【设置serverSocketChannel允许的最大连接队列数】——【设置channel为保持活动状态】——【初始化SocketChannel的业务处理器管道pipeline>>考虑到群聊系统主要进行文字交流，故需要一个编码器，一个解码器和一个自定义转发消息的业务处理器】；
  4. 给服务器启动类绑定端口；
  5. 在main()方法中调用启动类对象的run()方法。 
    import io.netty.bootstrap.ServerBootstrap;
import io.netty.channel.*;
import io.netty.channel.nio.NioEventLoopGroup;
import io.netty.channel.socket.SocketChannel;
import io.netty.channel.socket.nio.NioServerSocketChannel;
import io.netty.handler.codec.string.StringDecoder;
import io.netty.handler.codec.string.StringEncoder;

public class groupChatServer {
    //相关属性
    private int port; //监听端口

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

    //编写run()方法，处理客户端请求
    public void run() throws InterruptedException {
        //创建两个eventLoopGroup
        EventLoopGroup bossGroup = new NioEventLoopGroup(1);
        EventLoopGroup workerGroup = new NioEventLoopGroup();

        try {
            //
            ServerBootstrap b = new ServerBootstrap();
            b.group(bossGroup, workerGroup)
                    .channel(NioServerSocketChannel.class)
                    .option(ChannelOption.SO_BACKLOG, 128)
                    .childOption(ChannelOption.SO_KEEPALIVE, true)
                    .childHandler(new ChannelInitializer<SocketChannel>() {
                        @Override
                        protected void initChannel(SocketChannel ch) throws Exception {
                            //获取到pipeline
                            ChannelPipeline pipeline = ch.pipeline();
                            //向pipeline里面加入解码器
                            pipeline.addLast("decoder", new StringDecoder());
                            pipeline.addLast("encoder", new StringEncoder());
                            //加入自己的业务处理 handler
                            pipeline.addLast(new groupChatServerHandler());

                        }
                    });

            System.out.println("Netty服务器已启动");
            ChannelFuture channelFuture = b.bind(port).sync();

            //监听关闭事件
            channelFuture.channel().closeFuture().sync();
        }finally {
            bossGroup.shutdownGracefully();
            workerGroup.shutdownGracefully();
        }
    }

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

        new groupChatServer(7000).run();
    }
}

     

 2-2、服务器自定义业务处理器handler

  1. 1为了方便管理，需要建立一个channel的集合，每当有新的客户端连接时，新建一个channel放入该集合，因此创建一个任务队列的单线程事件执行器GlobalEventExecutor并使用ChannelGroup来管理连接进来的channel。
  2. 自定义的handler需要重写某些方法，满足：
    在新的客户端建立连接时触发，提示客户加入聊天；
    在客户端断开连接时触发，提示客户下线；
    在客户端发送消息时触发，接收消息并将消息转发给其他客户端；
    在发生异常时触发，关闭通道ChannelHandler关联的channel和ChannelFuture(监听器)
    import io.netty.channel.Channel;
import io.netty.channel.ChannelHandlerContext;
import io.netty.channel.SimpleChannelInboundHandler;
import io.netty.channel.group.ChannelGroup;
import io.netty.channel.group.DefaultChannelGroup;
import io.netty.util.concurrent.GlobalEventExecutor;

import java.text.SimpleDateFormat;
import java.util.HashMap;
import java.util.Map;

public class groupChatServerHandler extends SimpleChannelInboundHandler<String> {

    //定义一个hashmap进行管理
    //public static Map<String,Channel> channels = new HashMap<String,Channel>();

    //定义一个channel组管理所有的channel
    /**
     * GlobalEventExecutor.INSTANCE是一个全局的事件执行器，是一个单例
     * */
    private static ChannelGroup channelGroup = new DefaultChannelGroup(GlobalEventExecutor.INSTANCE);
    SimpleDateFormat sdf = new SimpleDateFormat("yyyy-mm-DD HH:mm:ss");

    //handlerAdded：表示连接建立，一旦连接建立，第一个被执行
    //将当前channel加入到 channelGroup
    @Override
    public void handlerAdded(ChannelHandlerContext ctx) throws Exception {
        Channel channel = ctx.channel();
        //将该客户加入聊天的信息推送给其他在线的客户端
        //writeAndFlush:该方法会将 channelGroup 中的所有 channel 遍历，并发送消息，无需自己遍历
        channelGroup.writeAndFlush(sdf.format(new java.util.Date()) + " [客户端]"+channel.remoteAddress()+"加入聊天\n");
        channelGroup.add(channel);

        //channels.put("id100",channel);
    }
    //断开连接时触发,将xx客户离开的消息推送给当前在线的客户端，自动将当前channel从channelGroup中移除
    @Override
    public void handlerRemoved(ChannelHandlerContext ctx) throws Exception {
        Channel channel = ctx.channel();
        channelGroup.writeAndFlush(sdf.format(new java.util.Date()) + " [客户端]"+channel.remoteAddress()+"离开了\n");
        System.out.println("channelGroup size = "+channelGroup.size());
    }

    //表示 channel 处于活动状态，提示 xx 上线
    @Override
    public void channelActive(ChannelHandlerContext ctx) throws Exception {
        System.out.println(ctx.channel().remoteAddress() + "上线了");
    }

    //表示 channel 处于非活动状态，提示 xx 离线
    @Override
    public void channelInactive(ChannelHandlerContext ctx) throws Exception {
        System.out.println(ctx.channel().remoteAddress() + "离线了");
    }

    @Override
    protected void channelRead0(ChannelHandlerContext ctx, String msg) throws Exception {

        //获取到当前的channel
        Channel channel = ctx.channel();
        //遍历 channelGroup，根据不同的情况，回送不同的消息
        channelGroup.forEach(ch -> {
            if (channel != ch){  //表示遍历到的channel不是当前的channel，转发消息
                ch.writeAndFlush("[客户]"+channel.remoteAddress() + " 发送消息:"+ msg + "\n");
            }else {  //回显一下
                ch.writeAndFlush("自己发送了消息："+msg+"\n");
            }
        });
    }

    @Override
    public void exceptionCaught(ChannelHandlerContext ctx, Throwable cause) throws Exception {
        //关闭
        ctx.close();
    }
}

     

 2-3、客户端

  1. 客户端需要初始化主机和端口两个属性；
  2. 客户端同样需要初始化线程池（EventLoopGroup），但只需要初始化一个进行具体业处理的eventExecutors即可；
  3. 新建客户端的启动类BootStrap，并设置相关参数——【设置事件循环对象：eventExecutors用于处理已建立连接的IO请求】——【构造SocketChannel的工厂类】——【初始化SocketChannel的业务处理器管道pipeline>>考虑到群聊系统主要进行文字交流，故需要一个编码器，一个解码器和一个自定义的业务处理器】
  4. 客户端需要输入消息，故创建一个扫描器scanner用来通过键盘输入消息。 
    import io.netty.bootstrap.Bootstrap;
import io.netty.channel.*;
import io.netty.channel.nio.NioEventLoopGroup;
import io.netty.channel.socket.SocketChannel;
import io.netty.channel.socket.nio.NioSocketChannel;
import io.netty.handler.codec.string.StringDecoder;
import io.netty.handler.codec.string.StringEncoder;

import java.util.Scanner;

public class groupChatClient {
    //相关属性
    private final String host;
    private final int port;

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

    public void run() throws InterruptedException {
        EventLoopGroup eventExecutors = new NioEventLoopGroup();

        try {
            Bootstrap bootstrap = new Bootstrap();

            bootstrap.group(eventExecutors)
                    .channel(NioSocketChannel.class)
                    .handler(new ChannelInitializer<SocketChannel>() {

                        @Override
                        protected void initChannel(SocketChannel ch) throws Exception {

                            //得到pipeline
                            ChannelPipeline pipeline = ch.pipeline();
                            //加入相关的handler
                            pipeline.addLast("decoder", new StringDecoder());
                            pipeline.addLast("encoder", new StringEncoder());
                            //加入自定义的handler
                            pipeline.addLast(new groupChatClientHandler());

                        }
                    });
            ChannelFuture channelFuture = bootstrap.connect(host, port).sync();
            //得到channel
            Channel channel = channelFuture.channel();
            System.out.println("----------"+channel.remoteAddress() + "-----------");
            //客户端需要输入信息，创建一个扫描器
            Scanner scanner = new Scanner(System.in);
            while (scanner.hasNext()){
                String msg = scanner.nextLine();
                //通过channel发送到服务器端
                channel.writeAndFlush(msg+"\r\n");
            }
        }finally {
            eventExecutors.shutdownGracefully();
        }
    }

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

        new groupChatClient("127.0.0.1",7000).run();
    }
}

    import io.netty.channel.ChannelHandlerContext;
import io.netty.channel.SimpleChannelInboundHandler;

public class groupChatClientHandler extends SimpleChannelInboundHandler<String> {
    @Override
    protected void channelRead0(ChannelHandlerContext ctx, String msg) throws Exception {
        System.out.println(msg.trim());
    }
}

     

 三、点对点聊天功能扩展

  1. 要实现点对点的聊天，必须很快地找到每个客户端连接时创建的channel，因此不能再使用ChannelGroup来进行管理，改用hasmap进行管理，规定每个channel对应一个id，Map<String id,Channel channel>；
  2. 依然是通过hashmap进行管理，但可以创建一个User对象，在该该对象内部初始化用户ID，登录密码等属性，可以存入数据库，使每个user实体与channel唯一对应，Map<User user,Channel channel>;

feiku_ysu
关注
专栏目录
95-31-020-ChannelGroup-DefaultChannelGroup
九师兄
03-14 407
1.拓扑图
Netty学习笔记 - 1 (带源码分析部分)
小小一只可乐猪
02-11 608
netty学习笔记，哔哩哔哩尚硅谷课程 韩老师主讲，笔记有4篇，很全面包含源码分析部分，结尾有相关文件 阿里云盘 欢迎下载。
ChannelGroup—广播
JasonZi的博客
09-26 6963
1.channelGroup    广播     关键语句：ChannelGroup channelgroup = new DefaultChannelGroup(GlobalEventExecutor.INSTANCE);      MyChannelHandlerPool.channelgroup.add(ctx.channel());      MyChannelHandlerPool
Netty - 从启蒙到搬砖（完整应用篇）（后端篇）
陆氪和他的那些代码
09-25 1002
前端篇：https://lux-sun.blog.csdn.net/article/details/101354215 后端篇 本文思路是按顺序进行的，必要说明的地方会唠嗑几句。 0、辅助类 package com.wxgj.center.common; public class Const { public static final Byte OP_SUCCE...
Netty聊天系统（4）群聊功能实现
weixin_42105432的博客
08-01 4069
7 群聊功能的实现 7.1 群聊的创建 创建一个创建群聊请求的实体类，依然是继承Packet，因为要通过我们的协议进行编解码 服务器端创建一个处理创建群聊请求的Handler，并实现其中的逻辑 创建一个群聊创建响应的实体类，继承Packet 客户端创建一个Handler来处理响应 创建一个CreateGroupRequestPacket类， @Data public class CreateGroupRequestPacket extends Packet { private String
详谈ChannelGroup功能之一
weixin_33853827的博客
04-24 4951
2019独角兽企业重金招聘Python工程师标准>>> ...
netty系列之:channel和channelGroup
「 虚幻私塾」
02-18 1433
Python微信订餐小程序课程视频 https://edu.csdn.net/course/detail/36074 Python实战量化交易理财系统 https://edu.csdn.net/course/detail/35475 目录* 简介 神龙见首不见尾的channel channel和channelGroup channelGroup的基本使用 将关闭的channel自动移出 同时关闭serverChannel和acceptedChannel ChannelGroupFuture 总结
Netty学习笔记（二）java NIO Buffer、Channel、Selector学习及使用，搭建nio群聊系统
yangwen-bo的博客
09-15 235
缓冲区（Buffer） 缓冲区（Buffer）：缓冲区本质上是一个可以读写数据的内存块，可以理解成是一个容器对象(含数组)，该对象提供了一组方法，可以更轻松地使用内存块，，缓冲区对象内置了一些机制，能够跟踪和记录缓冲区的状态变化情况。 Channel 提供从文件、网络读取数据的渠道，但是读取或写入的数据都必须经由 Buffer。 在NIO中，Buffer是一个顶级父类，它是一个抽象类，类的层级关系如图：（每个buffer实现类中都有对应数据类型的数组用来存储数据（所以buffer实际上数据是存在该数组中的）
Netty学习笔记（四）：Netty应用（群聊、心跳机制、长连接）、Protobfuf、编解码器、TCP粘包和拆包
Miracle42的博客
06-13 1271
第 5 章 Netty 应用实例 一、Netty 应用实例-群聊系统 1、要求 编写一个 Netty 群聊系统，实现服务器端和客户端之间的数据简单通讯（非阻塞） ，实现多人群聊 。 服务器端：可以监测用户上线，离线，并实现消息转发功能 客户端：通过 channel 可以无阻塞发送消息给其它所有用户，同时可以接受其它用户发送的消息(有服务器转发 得到) 2、实现 服务器端 public class ChatGroupServer { private static final int PORT = 6
Netty学习笔记（四）Netty概述及传统阻塞 IO 、Reactor 模式线程模型
yangwen-bo的博客
09-27 570
原生NIO存在的问题 1.NIO 的类库和 API 繁杂，使用麻烦：需要熟练掌握 Selector、ServerSocketChannel、SocketChannel、ByteBuffer 等。 2.需要具备其他的额外技能：要熟悉 Java 多线程编程，因为 NIO 编程涉及到 Reactor 模式，你必须对多线程和网络编程非常熟悉，才能编写出高质量的 NIO 程序。 3.开发工作量和难度都非常大：例如客户端面临断连重连、网络闪断、半包读写、失败缓存、网络拥塞和异常流的处理等等。 4.JDK NIO 的 B
Netty笔记（三）
qq_36905908的博客
06-13 756
netty学习笔记
Netty+websocket实现消息推送和统计在线人数
热爱技术，享受生活
03-08 1485
Netty+websocket实现消息推送和统计玩家在线人数
netty学习的一些总结
yoyohunter的博客
11-16 2811
最近因为工作关系要完成tcp的长链接推送，公司原来选择的是netty框架，就学习一下，怕忘了就做些笔记，实用的是netty5的handleradapter，是对netty4的in和out的handler的升级，现在服务端和客户端都加入的有心跳，来保持连接和服务端消息消费，整合了protobuf协议，进行数据传输，听说protostuff用起来很方便，也跟着写了demo确实很方便， 不知道能不能和
Netty之ChannelPipeline（一）添加ChannelHandler
weixin_43257196 的博客
01-30 1001
在Netty中每个Channel都有且仅有一个ChannelPipeline与之对应，而每个ChannelPipeline中又维护了一个由ChannelHandlerContext组成的双向链表，链表头是HeadContext，链表尾是TailContext，并且每个ChannelHandlerContext中又关联着一个ChannelHandler，如图示： ...
【Netty】Netty+springboot实现IM即时通讯服务端
doomwatcher的博客
04-27 5978
📣 📣 📣 📢📢📢 ☀️☀️你好啊！小伙伴，我是小冷。是一个兴趣驱动自学练习两年半的的Java工程师。 📒 一位十分喜欢将知识分享出来的Java博主⭐️⭐️⭐️，擅长使用Java技术开发web项目和工具 📒 文章内容丰富：覆盖大部分java必学技术栈，前端，计算机基础，容器等方面的文章 📒 如果你也对Java感兴趣，关注小冷吧，一起探索Java技术的生态与进步，一起讨论Java技术的使用与学习 ✏️高质量技术专栏专栏链接: 微服务，数据结构，netty，单点登录，SSM ，SpringCloudAli.
三、Netty服务器与多客户连接利用广播方式完全理解netty的读写机制
学而不思则罔,思而不学则殆！
09-24 3361
         本篇采用的编解码是netty自带的字符串的格式的编解码，用户1可以控制台发消息（输入完消息要加换行符号，是一个消息结束的分隔符，后面我会在编解码中详细讲解）给服务器，服务器广播给其他所有的客户端，这个机制，我们游戏开发服务器中应用很普遍，游戏中的广播，游戏中你看到其他玩家在操作。。。都是利用这个广播机制。 案例如下： package com.zhurong.netty.te...
Netty下的消息群发
ttlee的博客
12-03 2425
本文使用netty4.1.16 JDK 1.8 实现简单的群发功能 代码来源于GitHub上的项目，本着学习态度对该代码进行了仔细学习。 客户端代码 package simplechat; import io.netty.bootstrap.Bootstrap; import io.netty.channel.Channel; import io.netty.channel.Event
netty：Failed to initialize a channel. Closing
热门推荐
有酒有故事
10-27 1万+
netty 加到jar包 混淆后 报错Failed to initialize a channel. Closing: [id: 0xf7195050] java.lang.AbstractMethodError: abstract method "void
java.lang.UnsatisfiedLinkError: no com_alibaba_nacos_shaded_io_grpc_netty_shaded_netty_transport_native_epoll_x86_64 in java.library.path
最新发布
07-27
1. 检查本机库是否存在：确保 `com_alibaba_nacos_shaded_io_grpc_netty_shaded_netty_transport_native_epoll_x86_64` 本机库文件存在于你的系统上。如果不存在，你可能需要下载或重新编译该库，并确保将其放在正确...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值