Nettyの网络聊天室扩展序列化算法

1、网络聊天室综合案例

客户端初始代码：

@Slf4j
public class ChatClient {public static void main(String[] args) {NioEventLoopGroup group = new NioEventLoopGroup();LoggingHandler LOGGING_HANDLER = new LoggingHandler(LogLevel.DEBUG);MessageCodecSharable MESSAGE_CODEC = new MessageCodecSharable();try {Bootstrap bootstrap = new Bootstrap();bootstrap.channel(NioSocketChannel.class);bootstrap.group(group);bootstrap.handler(new ChannelInitializer<SocketChannel>() {@Overrideprotected void initChannel(SocketChannel ch) throws Exception {ch.pipeline().addLast(new ProcotolFrameDecoder());ch.pipeline().addLast(LOGGING_HANDLER);ch.pipeline().addLast(MESSAGE_CODEC);}});Channel channel = bootstrap.connect("localhost", 8080).sync().channel();channel.closeFuture().sync();} catch (Exception e) {log.error("client error", e);} finally {group.shutdownGracefully();}}
}

服务器初始代码：

@Slf4j
public class ChatServer {public static void main(String[] args) {NioEventLoopGroup boss = new NioEventLoopGroup();NioEventLoopGroup worker = new NioEventLoopGroup();LoggingHandler LOGGING_HANDLER = new LoggingHandler(LogLevel.DEBUG);MessageCodecSharable MESSAGE_CODEC = new MessageCodecSharable();try {ServerBootstrap serverBootstrap = new ServerBootstrap();serverBootstrap.channel(NioServerSocketChannel.class);serverBootstrap.group(boss, worker);serverBootstrap.childHandler(new ChannelInitializer<SocketChannel>() {@Overrideprotected void initChannel(SocketChannel ch) throws Exception {ch.pipeline().addLast(new ProcotolFrameDecoder());ch.pipeline().addLast(LOGGING_HANDLER);ch.pipeline().addLast(MESSAGE_CODEC);}});Channel channel = serverBootstrap.bind(8080).sync().channel();channel.closeFuture().sync();} catch (InterruptedException e) {log.error("server error", e);} finally {boss.shutdownGracefully();worker.shutdownGracefully();}}
}

1.1、登录业务

业务流程：

客户端流水线上新增一个入站处理器，处理登录逻辑，有连接建立时触发的channelActive事件（处理登录逻辑）和channelRead事件（获取服务器返回登录的结果）。
入站处理器中异步操作，封装LoginRequestMessage消息请求对象，通过ctx.writeAndFlush发送给服务器，并且触发该入站处理器之前的所有出站处理器（消息编解码器，日志打印），然后陷入阻塞等待服务器返回结果
服务器创建一个自定义的Handle，专门监听客户端的LoginRequestMessage消息请求对象。
服务器对登录信息进行校验，如果登录信息正确则临时保存（将用户的channel和用户名绑定）。
服务器封装LoginResponseMessage消息响应对象，通过channelHandlerContext.writeAndFlush方法将消息发送给客户端，并且触发该入站处理器前的所有出站处理器（消息编解码器，日志打印）。
将自定义的Handle注册到服务器的流水线上。
客户端channelRead接收到服务器返回的结果，将结果记录，并且结束阻塞（无论是否登录成功）
客户端根据结果执行不同的业务逻辑，成功则让用户选择菜单，失败则断开连接。

客户端，在流水线上新增一个入站处理器，专门处理登录相关逻辑：

注意点：

使用channelActive，确保该入站处理器是在连接建立时触发。
并非在Netty的主线程中处理登录相关逻辑，而是新开启一个线程异步地处理，相应地，线程间的通信使用countDownLatch （判断是否拿到服务器端的返回结果）和 AtomicBoolean （判断服务器端返回的结果，是否登录成功）。

成员位置：

CountDownLatch countDownLatch = new CountDownLatch(1);
AtomicBoolean loginResult = new AtomicBoolean(false);

 //编写登录逻辑ch.pipeline().addLast(new ChannelInboundHandlerAdapter() {/*** 连接建立时触发，输入用户名和密码，传给后端校验* @param ctx* @throws Exception*/@Overridepublic void channelActive(ChannelHandlerContext ctx) throws Exception {new Thread(() -> {Scanner sc = new Scanner(System.in);System.out.println("请输入用户名");String username = sc.nextLine();System.out.println("请输入密码");String password = sc.nextLine();LoginRequestMessage requestMessage = new LoginRequestMessage(username, password, null);//发送给后端 后端有一个专门的处理器去处理请求信息并且返回结果ctx.writeAndFlush(requestMessage);try {countDownLatch.await();} catch (InterruptedException e) {e.printStackTrace();}boolean result = loginResult.get();//登录成功if (result) {while (true) {System.out.println("==================================");System.out.println("send [username] [content]");System.out.println("gsend [group name] [content]");System.out.println("gcreate [group name] [m1,m2,m3...]");System.out.println("gmembers [group name]");System.out.println("gjoin [group name]");System.out.println("gquit [group name]");System.out.println("quit");System.out.println("==================================");String command = sc.nextLine();String[] s = command.split(" ");switch (s[0]) {case "send":ctx.writeAndFlush(new ChatRequestMessage(username, s[1], s[2]));break;case "gsend":ctx.writeAndFlush(new GroupChatRequestMessage(username, s[1], s[2]));break;case "gcreate":Set<String> set = new HashSet<>(Arrays.asList(s[2].split(",")));set.add(username); // 加入自己ctx.writeAndFlush(new GroupCreateRequestMessage(s[1], set));break;case "gmembers":ctx.writeAndFlush(new GroupMembersRequestMessage(s[1]));break;case "gjoin":ctx.writeAndFlush(new GroupJoinRequestMessage(username, s[1]));break;case "gquit":ctx.writeAndFlush(new GroupQuitRequestMessage(username, s[1]));break;case "quit":ctx.channel().close();return;}}} else {//密码错误就关闭连接，触发 channel.closeFuture().sync();ctx.channel().close();}}, "login").start();}/*** 接受后端返回的登录校验结果* @param ctx* @param msg* @throws Exception*/@Overridepublic void channelRead(ChannelHandlerContext ctx, Object msg) throws Exception {log.debug("登录结果:{}", msg);//记录状态if (msg instanceof LoginResponseMessage) {LoginResponseMessage responseMessage = (LoginResponseMessage) msg;if (responseMessage.isSuccess()) {loginResult.compareAndSet(false, true);}countDownLatch.countDown();}}});

服务器端：

注意点：

自定义一个Handler，继承SimpleChannelInboundHandler，只关注客户端发送的登录请求。
登录成功后，将当前会话信息临时进行保存。

@ChannelHandler.Sharable
@Slf4j
public class LoginRequesHandler extends SimpleChannelInboundHandler<LoginRequestMessage> {@Overrideprotected void channelRead0(ChannelHandlerContext channelHandlerContext, LoginRequestMessage loginRequestMessage) throws Exception {String username = loginRequestMessage.getUsername();String password = loginRequestMessage.getPassword();boolean loginSuccess = UserServiceFactory.getUserService().login(username, password);LoginResponseMessage responseMessage = null;if (loginSuccess) {//保存会话信息 key channel value 当前登录人 zhangsan lisiChannel channel = channelHandlerContext.channel();SessionFactory.getSession().bind(channel, loginRequestMessage.getUsername());responseMessage = new LoginResponseMessage(true, "登录成功！");log.info("账号：{}登录成功,绑定的交换机:{}",username,channel);} else {responseMessage = new LoginResponseMessage(false, "登录失败！");}//将结果返回给前端channelHandlerContext.writeAndFlush(responseMessage);}
}

将自定义Handler注册到流水线上：

//接受前端传递的用户名和密码并校验，然后返回给前端登录结果
//指定关注的消息类型为LoginRequestMessage
ch.pipeline().addLast(new LoginRequesHandler());

1.2、发送消息（单聊）

客户端：

如果用户在菜单中选择send，则触发单聊功能。

通过ctx.writeAndFlush发送封装好的单聊消息请求，并且触发在这之前的所有出站消息。

 ctx.writeAndFlush(new ChatRequestMessage(username, s[1], s[2]));

服务器端：

注册一个ChatRequestHandler处理器，继承SimpleChannelInboundHandler，专门处理客户端传递的单聊请求。

注意点：

发送消息之前需要检查收件人是否在线，通过用户名去查询对应的channel是否存在（如果该用户已登录，必定会将自己的用户名和channel绑定）
拿到收件人的channel后，利用收件人的channel向收件人的客户端发送消息。

1.3、创建聊天群组

客户端：

如果用户在菜单中选择gcreate，则触发创建聊天群组功能：

封装GroupCreateRequestMessage创建聊天群组请求对象，并且调用ctx.writeAndFlush触发之前所有的出站处理器。

ctx.writeAndFlush(new GroupCreateRequestMessage(s[1], set));

服务器端：

创建一个自定义的Handler，继承SimpleChannelInboundHandler，专门监听客户端的GroupCreateRequestMessage。

注意点：

首先需要判断群聊是否存在，如果存在就不能重复创建。
创建成功后拿到所有群组成员的channel，向各自的客户端发送GroupChatResponseMessage消息响应对象。

1.4、发送消息（群聊）

客户端：

如果用户在菜单中选择gsend，则触发创建聊天群组功能：

封装GroupChatRequestMessage创建群聊请求对象，并且调用ctx.writeAndFlush触发之前所有的出站处理器。

 ctx.writeAndFlush(new GroupChatRequestMessage(username, s[1], s[2]));

服务器端：

创建一个Handler继承SimpleChannelInboundHandler专门监听GroupChatRequestMessage群聊消息请求。

1.5、心跳消息监测

有时服务器长时间没有接收到客户端发出的消息，可能是因为网络设备出现故障，网络不稳定，应用程序发生阻塞等原因，称之为连接假死。

这时我们应该及时地去释放资源，那么如何去判定是否发生连接假死？如果通过常规的超时机制难以判定，因为连接本身并没有断开，但数据无法正常传输。

可以通过心跳监测机制去实现。客户端和服务器之间定期互相发送心跳消息，对方在一定时间内收到心跳消息后，会发送一个确认消息，表示连接仍然正常。如果一方在指定时间内未收到对方的心跳消息，就认为连接可能已经中断或假死。

心跳机制通常运用于分布式系统和实时通信中，eureka运用的便是心跳检测机制。

如果需要在Netty框架中使用心跳消息监测，需要在服务器端的流水线上加入：

IdleStateHandler：是 Netty 提供的一个处理器，用于检测连接的空闲状态，可以分为读空闲，写空闲和读写空闲。
ChannelDuplexHandler：是一个入站/出站双向的处理器，在其中加入userEventTriggered，它是一个自定义的处理器，当IdleStateHandler检测到空闲事件后，会触发IdleStateEvent，被userEventTriggered捕获。

服务器端关注的是读空闲。

                    //空闲检测ch.pipeline().addLast(new IdleStateHandler(5, 0, 0));
//                    //双向监测 入站和出站ch.pipeline().addLast(new ChannelDuplexHandler() {/*** 用户自定义事件* @param ctx* @param evt* @throws Exception*/@Overridepublic void userEventTriggered(ChannelHandlerContext ctx, Object evt) throws Exception {if (evt instanceof IdleStateEvent) {IdleStateEvent event = (IdleStateEvent) evt;if (event.state().equals(IdleState.READER_IDLE)) {log.debug("已经5s未读取到数据了");ctx.channel().close();}}}});

同时在客户端中加入，客户端关注的是写空闲，如果一定时间内没有向客户端发送消息，就发送默认的心跳消息确认双方都是存活的。

//如果三秒内没有向服务器写出数据，就发送心跳消息ch.pipeline().addLast(new IdleStateHandler(0, 3, 0));
//                    双向监测 入站和出站ch.pipeline().addLast(new ChannelDuplexHandler() {/*** 用户自定义事件* @param ctx* @param evt* @throws Exception*/@Overridepublic void userEventTriggered(ChannelHandlerContext ctx, Object evt) throws Exception {if (evt instanceof IdleStateEvent) {IdleStateEvent event = (IdleStateEvent) evt;if (event.state().equals(IdleState.WRITER_IDLE)) {log.debug("已经3s未写入数据了，发送默认消息");ctx.writeAndFlush(new PingMessage());}}}});

如果超过一定的时间，客户端没有向服务器发送消息或心跳，则服务器默认客户端已经假死，就会断开连接释放资源。

1.6、退出

退出分为在客户端选择quit正常退出，以及异常退出的情况，服务器端为了处理这两种情况，需要在流水线上加入一个自定义的QuitHandler：

创建一个自定义的QuitHandler，继承ChannelInboundHandlerAdapter接口，重写其中的

channelInactive和exceptionCaught方法

  // 当连接断开时触发 inactive 事件@Overridepublic void channelInactive(ChannelHandlerContext ctx) throws Exception {SessionFactory.getSession().unbind(ctx.channel());log.debug("{} 已经断开", ctx.channel());}// 当出现异常时触发@Overridepublic void exceptionCaught(ChannelHandlerContext ctx, Throwable cause) throws Exception {SessionFactory.getSession().unbind(ctx.channel());log.debug("{} 已经异常断开 异常是{}", ctx.channel(), cause.getMessage());}

2、扩展序列化算法

在自定义通讯协议时，消息的传输使用到了序列化算法，当时使用的是JDK默认的序列化算法：

序列化：

// 6. 获取内容的字节数组
ByteArrayOutputStream bos = new ByteArrayOutputStream();
ObjectOutputStream oos = new ObjectOutputStream(bos);
oos.writeObject(msg);
byte[] bytes = bos.toByteArray();

反序列化：

int length = in.readInt();
byte[] bytes = new byte[length];
in.readBytes(bytes, 0, length);
ObjectInputStream ois = new ObjectInputStream(new ByteArrayInputStream(bytes));
Message message = (Message) ois.readObject();

这里介绍一种不需要修改代码，只需要修改配置文件达成序列化方式切换的思路：

application.properties

serializer.algorithm=JSON

创建一个接口，定义序列化和反序列化方法的模版：

public interface Serialized {/*** 序列化** @param object 将要序列化的对象* @param <T>* @return 序列化后的byte数组*/<T> byte[] serialized(T object);/*** 反序列化** @param clazz 将要反序列化成的对象的类型* @param bytes 序列化的byte数组* @param <T>* @return 反序列化后的对象*/<T> T deSerialized(Class<T> clazz, byte[] bytes);}

定义一个枚举类，实现接口，分别编写使用JDK自带的方式序列化以及使用JSON序列化的逻辑：

enum Algorithm implements Serialized {JAVA {@Overridepublic <T> byte[] serialized(T object) {try {ByteArrayOutputStream bos = new ByteArrayOutputStream();ObjectOutputStream oos = new ObjectOutputStream(bos);oos.writeObject(object);return bos.toByteArray();} catch (IOException e) {e.printStackTrace();throw new RuntimeException("序列化失败！");}}@Overridepublic <T> T deSerialized(Class<T> clazz, byte[] bytes) {try {ObjectInputStream ois = new ObjectInputStream(new ByteArrayInputStream(bytes));return (T) ois.readObject();} catch (IOException | ClassNotFoundException e) {e.printStackTrace();throw new RuntimeException("反序列化失败！");}}},JSON {@Overridepublic <T> byte[] serialized(T object) {Gson gson = new Gson();String str = gson.toJson(object);return str.getBytes(StandardCharsets.UTF_8);}@Overridepublic <T> T deSerialized(Class<T> clazz, byte[] bytes) {Gson gson = new Gson();return gson.fromJson(new String(bytes, StandardCharsets.UTF_8), clazz);}}}

再定义一个读取 application.properties 文件的配置类，如果配置文件中未配置，就按照默认的JDK序列化方式实现：

/*** 序列化配置类*/
public class SerializedConfig {static Properties properties;static {//从application.properties配置文件中读取try (InputStream is = SerializedConfig.class.getResourceAsStream("/application.properties")) {properties = new Properties();properties.load(is);} catch (IOException e) {throw new ExceptionInInitializerError(e);}}public static int getServerPort() {//从配置文件中读取键为server.port的值String value = properties.getProperty("server.port");if (value == null) {return 8080;} else {return Integer.parseInt(value);}}public static Serialized.Algorithm getSerializedAlgorithm() {//从配置文件中读取键为serializer.algorithm的值String value = properties.getProperty("serializer.algorithm");if (value == null) {return Serialized.Algorithm.JAVA;} else {return Serialized.Algorithm.valueOf(value);}}}

改造自定义协议类：

编码主要有两处需要修改，一处是设定字节的序列化方式（获取的是序列化方式 java json 在枚举类中的位置 0,1）：

out.writeByte(SerializedConfig.getSerializedAlgorithm().ordinal());

另一处是将消息序列化的逻辑：

byte[] bytes = SerializedConfig.getSerializedAlgorithm().serialized(msg);

解码也有两处需要修改：

第一处是确定反序列化的算法：

Serialized.Algorithm[] values = Serialized.Algorithm.values();
//确定反序列化算法
Serialized.Algorithm algorithm = values[serializerType];

第二处是确定消息类型，并且解码：

//确定消息类型
Class<? extends Message> messageClass = Message.getMessageClass(messageType);
Object message = algorithm.deSerialized(messageClass, bytes)