Java IO编程由浅入深 - 8 (bio实现C/S聊天室 3 )

朴灿烈づ我的快乐病毒、 2022-11-10 06:00 99阅读 0赞

### 开发服务端分发消息功能，实现群聊 ###

*  目录
 *  对Message对象进行细分，拆分成以下对象
 *  编写CsServerMessageHandler，管理客户端与分发消息
 *  编写客户端代码
 *  测试一个客户端连接到服务端的效果
 *  这个时候我们加一个客户端,测试两个客户端的效果
 *  测试客户端1和2分别发送消息
 *  关闭客户端2

# 目录 #

1.  [Java IO编程由浅入深 - 1 (bio c/s架构实现)][Java IO_ - 1 _bio c_s]
2.  [Java IO编程由浅入深 - 2(bio 基于字符串的消息编解码器)][Java IO_ - 2_bio]
3.  [Java IO编程由浅入深 - 3 (bio 基于消息长度的解编码器)][Java IO_ - 3 _bio]
4.  [Java IO编程由浅入深 - 4 (bio http协议解编码器，实现http服务器)][Java IO_ - 4 _bio http_http]
5.  [Java IO编程由浅入深 - 5 (项目架构重构)][Java IO_ - 5]
6.  [Java IO编程由浅入深 - 6 (bio实现C/S聊天室 1 )][Java IO_ - 6 _bio_C_S_ 1]
7.  [Java IO编程由浅入深 - 7 (bio实现C/S聊天室 2 )][Java IO_ - 7 _bio_C_S_ 2]
8.  [Java IO编程由浅入深 - 8 (bio实现C/S聊天室 3 )][Java IO_ - 8 _bio_C_S_ 3]
9.  [Java IO编程由浅入深 - 9 (bio实现http升级到websocket )][Java IO_ - 9 _bio_http_websocket]
10. [Java IO编程由浅入深 - 10 (bio 基于websocket的心跳检测实现 )][Java IO_ - 10 _bio _websocket_]

# 对Message对象进行细分，拆分成以下对象 #

TextMessage (数据为文本内容)  
BinaryMessage(数据为二进制)  
StreamMessage(数据为流数据)  
PingMessage(ping消息，对应必须响应pong)  
PongMessage(pong消息)

# 编写CsServerMessageHandler，管理客户端与分发消息 #

package com.lhstack.example.handler;
    
    import com.lhstack.bio.channel.Channel;
    import com.lhstack.bio.channel.ChannelHandlerContext;
    import com.lhstack.bio.channel.SimpleChannelAdapterHandler;
    import com.lhstack.bio.codec.bs.TextMessage;
    
    import java.time.LocalDateTime;
    import java.time.format.DateTimeFormatter;
    import java.util.concurrent.ConcurrentHashMap;
    
    /** * @author lhstack * 服务端 */
    public class CsServerMessageHandler extends SimpleChannelAdapterHandler<TextMessage> { 
    
        private static final ConcurrentHashMap<String, Channel> MESSAGE_GROUP = new ConcurrentHashMap<>();
    
        @Override
        public void channelActive(ChannelHandlerContext ctx) throws Exception { 
            MESSAGE_GROUP.forEach((k,v) ->{ 
                try { 
                    v.writeAndFlush(new TextMessage(String.format("%s: 欢迎客户端[%s],加入消息组",getCurrentFormatTime(),ctx.channel().id())));
                } catch (Exception e) { 
                    e.printStackTrace();
                }
            });
            ctx.writeAndFlush(new TextMessage(String.format("%s: 你好，欢迎加入消息组",getCurrentFormatTime())));
            MESSAGE_GROUP.put(ctx.channel().id(),ctx.channel());
        }
    
        private String getCurrentFormatTime() { 
            return LocalDateTime.now().format(DateTimeFormatter.ofPattern("yyyy-MM-dd HH:mm:ss"));
        }
    
        @Override
        public void channelRead0(ChannelHandlerContext ctx, TextMessage msg) throws Exception { 
            MESSAGE_GROUP.forEach((k,v) ->{ 
                try { 
                    if(k.equals(ctx.channel().id())){ 
                        v.writeAndFlush(new TextMessage(String.format("%s: 你说: %s",getCurrentFormatTime(),msg.text())));
                    }else{ 
                        v.writeAndFlush(new TextMessage(String.format("%s: 客户端[%s]说: %s",getCurrentFormatTime(),ctx.channel().id(),msg.text())));
                    }
                } catch (Exception e) { 
                    e.printStackTrace();
                }
            });
        }
    
        @Override
        public void exceptionCatch(ChannelHandlerContext ctx, Throwable throwable) throws Exception { 
            MESSAGE_GROUP.forEach((k,v) ->{ 
                try { 
                    if(!k.equals(ctx.channel().id())){ 
                        v.writeAndFlush(new TextMessage(String.format("%s: 客户端[%s]离开了消息组",getCurrentFormatTime(),ctx.channel().id())));
                    }
                } catch (Exception e) { 
                    e.printStackTrace();
                }
            });
            MESSAGE_GROUP.remove(ctx.channel().id());
        }
    }

# 编写客户端代码 #

public static void csMessageClient() throws Exception { 
            BootStrap bootStrap = new BootStrap();
            Channel channel = bootStrap
                    .group(new DefaultEventLoopGroup())
                    .handler(new ChannelInitializeHandler() { 
                @Override
                public void initializer(Channel ch) throws Exception { 
                    ch.pipeline()
                            .addLast(new CsMessageCodec())
                            .addLast(new CsClientMessageIdleStateHandler())
                            .addLast(new SimpleChannelAdapterHandler<TextMessage>() { 
                                @Override
                                public void channelRead0(ChannelHandlerContext ctx, TextMessage msg) throws Exception { 
                                    System.out.println(new String(msg.getBody()));
                                }
                            });
                }
            }).connect(new InetSocketAddress("localhost", 8080));
            Scanner scanner = new Scanner(System.in);
            System.out.println("请发送消息");
            while(scanner.hasNext()){ 
                String msg = scanner.nextLine();
                channel.writeAndFlush(new TextMessage(msg,true));
            }
        }

# 测试一个客户端连接到服务端的效果 #

可以看到，客户端接收到了服务端响应的消息  
![在这里插入图片描述][20210316193837548.png]

# 这个时候我们加一个客户端,测试两个客户端的效果 #

客户端1收到了客户端2的上线消息，同时客户端2也收到了服务端响应的消息  
客户端1  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQyNDEzMDEx_size_16_color_FFFFFF_t_70]

客户端2  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQyNDEzMDEx_size_16_color_FFFFFF_t_70 1]

# 测试客户端1和2分别发送消息 #

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQyNDEzMDEx_size_16_color_FFFFFF_t_70 2]  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQyNDEzMDEx_size_16_color_FFFFFF_t_70 3]  
客户端1和2分别收到了消息

# 关闭客户端2 #

客户端1也收到了客户端2的离线通知  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQyNDEzMDEx_size_16_color_FFFFFF_t_70 4]

由此，我们实现了一个简单的群聊功能，同时附带了心跳检测功能

[Java IO_ - 1 _bio c_s]: https://blog.csdn.net/qq_42413011/article/details/114553235
[Java IO_ - 2_bio]: https://blog.csdn.net/qq_42413011/article/details/114579502
[Java IO_ - 3 _bio]: https://blog.csdn.net/qq_42413011/article/details/114636827
[Java IO_ - 4 _bio http_http]: https://blog.csdn.net/qq_42413011/article/details/114646159
[Java IO_ - 5]: https://blog.csdn.net/qq_42413011/article/details/114802496
[Java IO_ - 6 _bio_C_S_ 1]: https://blog.csdn.net/qq_42413011/article/details/114852932
[Java IO_ - 7 _bio_C_S_ 2]: https://blog.csdn.net/qq_42413011/article/details/114878895
[Java IO_ - 8 _bio_C_S_ 3]: https://blog.csdn.net/qq_42413011/article/details/114896029
[Java IO_ - 9 _bio_http_websocket]: https://blog.csdn.net/qq_42413011/article/details/114925184
[Java IO_ - 10 _bio _websocket_]: https://blog.csdn.net/qq_42413011/article/details/114947311
[20210316193837548.png]: /images/20221023/28f995825ba146268868fcd725d81e57.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQyNDEzMDEx_size_16_color_FFFFFF_t_70]: /images/20221023/18e7ca7da6cc44f381d2295d75e92432.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQyNDEzMDEx_size_16_color_FFFFFF_t_70 1]: /images/20221023/26a1308589284b4497f707a435d70b93.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQyNDEzMDEx_size_16_color_FFFFFF_t_70 2]: /images/20221023/555c3122d9c649cfa782e4f705017658.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQyNDEzMDEx_size_16_color_FFFFFF_t_70 3]: /images/20221023/da7ca9e6030e48c7aa589e57d4aa4ac6.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQyNDEzMDEx_size_16_color_FFFFFF_t_70 4]: /images/20221023/b6732523e7ef4758a9323c1adf5692e9.png