1.解决思路

在上文中我们提出了多种解决拆包粘包的问题思路，其中就包括通过包尾添加分隔符来解决。本章将通过回车换行分隔符介结合Netty来进行拆包粘包问题的解决

2.服务端代码改造

  1. package demo1;
  3. import io.netty.bootstrap.ServerBootstrap;
  4. import io.netty.buffer.ByteBuf;
  5. import io.netty.buffer.Unpooled;
  6. import io.netty.channel.*;
  7. import io.netty.channel.nio.NioEventLoopGroup;
  8. import io.netty.channel.socket.SocketChannel;
  9. import io.netty.channel.socket.nio.NioServerSocketChannel;
  10. import io.netty.handler.codec.LineBasedFrameDecoder;
  11. import io.netty.handler.codec.string.StringDecoder;
  13. /**
  14.  * @author 冯铁城 [17615007230@163.com]
  15.  * @date 2022-05-09 19:11:57
  16.  * @describe: 时间服务器服务端
  17.  */
  18. public class TimeServer {
  20.     /**
  21.      * 开启socket链接
  22.      *
  23.      * @param port 端口号
  24.      */
  25.     public void bind(int port) {
  27.         //1.创建线程组用于接受服务端链接
  28.         NioEventLoopGroup bossGroup = new NioEventLoopGroup();
  30.         //2.创建线程组用户socketChannel读写
  31.         NioEventLoopGroup workGroup = new NioEventLoopGroup();
  32.         try {
  34.             //3.创建服务端
  35.             ServerBootstrap server = new ServerBootstrap();
  36.             server.group(bossGroup, workGroup)
  37.                     .channel(NioServerSocketChannel.class)
  38.                     .option(ChannelOption.SO_BACKLOG, 1024)
  39.                     .childHandler(new ChildChannelHandler());
  41.             //3.绑定端口,开启同步等待
  42.             ChannelFuture sync = server.bind(port).sync();
  43.             System.out.println("服务端已启动!");
  45.             //4.等待服务端监听端口关闭
  46.             sync.channel().closeFuture().sync();
  47.         } catch (InterruptedException e) {
  48.             e.printStackTrace();
  49.         } finally {
  50.             bossGroup.shutdownGracefully();
  51.             workGroup.shutdownGracefully();
  52.         }
  53.     }
  55.     private class ChildChannelHandler extends ChannelInitializer<SocketChannel> {
  56.         @Override
  57.         protected void initChannel(SocketChannel socketChannel) throws Exception {
  58.             socketChannel.pipeline().addLast(new LineBasedFrameDecoder(1024));
  59.             socketChannel.pipeline().addLast(new StringDecoder());
  60.             socketChannel.pipeline().addLast(new TimeServerHandler());
  61.         }
  62.     }
  64.     private class TimeServerHandler extends ChannelHandlerAdapter {
  66.         @Override
  67.         public void channelActive(ChannelHandlerContext ctx) throws Exception {
  68.             System.out.println("服务端已与" + ctx.channel().id() + "建立链接");
  69.         }
  71.         @Override
  72.         public void channelRead(ChannelHandlerContext ctx, Object msg) throws Exception {
  74.             //1.字符串判定
  75.             System.out.println("收到" + ctx.channel().id() + "渠道的请求:" + msg);
  77.             //2.定义返回结果
  78.             String responseMessage = "响应信息\r\n";
  80.             //3.相应数据
  81.             ByteBuf response = Unpooled.copiedBuffer(responseMessage.getBytes());
  82.             ctx.write(response);
  83.         }
  85.         @Override
  86.         public void channelReadComplete(ChannelHandlerContext ctx) throws Exception {
  87.             ctx.flush();
  88.         }
  90.         @Override
  91.         public void exceptionCaught(ChannelHandlerContext ctx, Throwable cause) throws Exception {
  92.             ctx.close();
  93.         }
  94.     }
  95. }

在ChildChannelHandler.initChannel()方法中添加了如下两行代码

  1. socketChannel.pipeline().addLast(new LineBasedFrameDecoder(1024));
  2. socketChannel.pipeline().addLast(new StringDecoder());

同时channelRead()方法中不再将msg转为ButeBuf。而是直接视作字符串处理
同时回复消息时在包尾写入/r/n分隔符

3.客户端代码改造

  1. package demo1;
  3. import io.netty.bootstrap.Bootstrap;
  4. import io.netty.buffer.ByteBuf;
  5. import io.netty.buffer.Unpooled;
  6. import io.netty.channel.*;
  7. import io.netty.channel.nio.NioEventLoopGroup;
  8. import io.netty.channel.socket.SocketChannel;
  9. import io.netty.channel.socket.nio.NioSocketChannel;
  10. import io.netty.handler.codec.LineBasedFrameDecoder;
  11. import io.netty.handler.codec.string.StringDecoder;
  13. /**
  14.  * @author 冯铁城 [17615007230@163.com]
  15.  * @date 2022-05-09 21:09:16
  16.  * @describe: 时间服务器客户端
  17.  */
  18. public class TimeClient {
  20.     /**
  21.      * 创建客户端链接
  22.      *
  23.      * @param host 主机
  24.      * @param port 端口号
  25.      */
  26.     public void connect(String host, int port) {
  28.         //1. 创建用于IO读写的线程组
  29.         EventLoopGroup group = new NioEventLoopGroup();
  30.         try {
  32.             //2.创建客户端启动类
  33.             Bootstrap bootstrap = new Bootstrap();
  35.             //3.启动类初始化
  36.             bootstrap.group(group)
  37.                     .channel(NioSocketChannel.class)
  38.                     .option(ChannelOption.TCP_NODELAY, true)
  39.                     .handler(new ChannelInitializer<SocketChannel>() {
  41.                         @Override
  42.                         protected void initChannel(SocketChannel socketChannel) throws Exception {
  43.                             socketChannel.pipeline().addLast(new LineBasedFrameDecoder(1024));
  44.                             socketChannel.pipeline().addLast(new StringDecoder());
  45.                             socketChannel.pipeline().addLast(new TimeClientHandler());
  46.                         }
  47.                     });
  49.             //4.发起异步链接操作
  50.             ChannelFuture sync = bootstrap.connect(host, port).sync();
  52.             //5.等待客户端链路链接关闭
  53.             sync.channel().closeFuture().sync();
  54.         } catch (InterruptedException e) {
  55.             e.printStackTrace();
  56.         } finally {
  57.             group.shutdownGracefully();
  58.         }
  59.     }
  61.     /**
  62.      * @author 冯铁城 [17615007230@163.com]
  63.      * @date 2022-05-09 21:01:23
  64.      * @describe: 时间服务器客户端
  65.      */
  66.     public class TimeClientHandler extends ChannelHandlerAdapter {
  68.         @Override
  69.         public void channelActive(ChannelHandlerContext ctx) throws Exception {
  70.             for (int i = 0; i < 20; i++) {
  71.                 String requestMessage = "发送消息\r\n";
  72.                 ByteBuf message = Unpooled.buffer(requestMessage.getBytes().length);
  73.                 message.writeBytes(requestMessage.getBytes());
  74.                 ctx.writeAndFlush(message);
  75.             }
  76.         }
  78.         @Override
  79.         public void channelRead(ChannelHandlerContext ctx, Object msg) throws Exception {
  80.             System.out.println("收到服务端答复:" + msg);
  81.         }
  83.         @Override
  84.         public void exceptionCaught(ChannelHandlerContext ctx, Throwable cause) throws Exception {
  85.             System.out.println("链接出现异常,异常信息:" + cause.getMessage());
  86.             ctx.close();
  87.         }
  88.     }
  89. }

在ChildChannelHandler.initChannel()方法中添加了如下两行代码

  1. socketChannel.pipeline().addLast(new LineBasedFrameDecoder(1024));
  2. socketChannel.pipeline().addLast(new StringDecoder());

同时channelRead()方法中不再将msg转为ButeBuf。而是直接视作字符串处理
同时发送消息时在包尾写入/r/n分隔符

4.调试结果

服务端收到了20条请求
image.png
客户端收到了20条响应
image.png

5.原理

  1. LineBasedFrameDecoder解码器：遍历ByteBuf中的字节，通过findEndOfLine寻找ascii码=10（换行键）或13（回车键）的位置标记为包体结束位，因此可读索引到结束位的数据就形成了一行，也就是一个包。支持配置最大长度，如果在最大长度读取完后还没有读取到换行回车分隔符，会抛出异常，同时忽略掉之前读取的异常码流

image.png

  1. StringDecoder解码器：将接受到的对象通过Charset.defaultCharset()转为字符串，交给后续的handler处理因此其实上述解决拆包粘包的问题可以不用添加StringDecoder解码器，只不过在获取消息时需要进行byte数组转字符串的操作。加入StringDecode解码器后不需要在消息接受时进行byte数组转字符串的操作了，直接将消息视作字符串操作即可