TCP粘包／拆包

TCP是个”流”协议，所谓流，就是没有界限的一串数据。TCP底层并不了解上层业务数据的具体含义，它会根据TCP缓冲区的实际情况进行包的划分，所以在业务上认为，一个完整的包可能会被TCP拆分成多个包进行发送，也有可能把多个小的包封装成一个大的数据包发送，这就是所谓的TCP粘包和拆包问题

TCP粘包/拆包发生的原因

1. 应用程序write写入的字节大小大于套接口发送缓冲区大小
2. 进行MSS大小的TCP分段
3. 以太网帧的payload大于MTU进行IP分片

粘包问题的解决策略

由于底层的TCP无法理解上层的业务数据，所以在底层是无法保证数据包不被拆分和重组的，这个问题只能通过上层的应用协议栈设计来解决，根据业界的主流协议的解决方案，可以归纳如下

先来看一个粘包的例子

新建maven工程，添加依赖包

  1. <!-- https://mvnrepository.com/artifact/io.netty/netty-all -->
  2.     <dependency>
  3.         <groupId>io.netty</groupId>
  4.         <artifactId>netty-all</artifactId>
  5.         <version>5.0..Alpha1</version>
  6.     </dependency>

TimeServer

  1. package com.zhen.netty1129_TCP_HALF_PACKAGE;
  2.  
  3. import java.awt.Event;
  4. import java.net.Socket;
  5.  
  6. import io.netty.bootstrap.ServerBootstrap;
  7. import io.netty.channel.ChannelFuture;
  8. import io.netty.channel.ChannelInitializer;
  9. import io.netty.channel.ChannelOption;
  10. import io.netty.channel.EventLoop;
  11. import io.netty.channel.EventLoopGroup;
  12. import io.netty.channel.nio.NioEventLoopGroup;
  13. import io.netty.channel.socket.SocketChannel;
  14. import io.netty.channel.socket.nio.NioServerSocketChannel;
  15.  
  16. public class TimeServer {
  17.  
  18.     public void bind(int port) throws Exception{
  19.         //配置服务端的NIO线程组
  20.         //NioEventLoopGroup是个线程组，它包含了一组NIO线程，专门用于网络事件的处理，实际上它们就是Reactor线程组
  21.         //bossGroup用于服务端接受客户端的连接
  22.         EventLoopGroup bossGroup = new NioEventLoopGroup();
  23.         //workerGroup进行SocketChannel的网络读写
  24.         EventLoopGroup workerGroup = new NioEventLoopGroup();
  25.         try {
  26.             //Netty用于启动NIO服务端的辅助启动类，目的是降低服务端的开发复杂度
  27.             ServerBootstrap bootstrap = new ServerBootstrap();
  28.             //将两个NIO线程组当作入参传递到ServerBootstrap
  29.             bootstrap.group(bossGroup, workerGroup)
  30.                 //设置创建的Channel为NioServerSocketChannel,它的功能对应于JDK NIO类库中的ServerSocketChannel类。
  31.                 .channel(NioServerSocketChannel.class)
  32.                 //配置NioServerSocketChannel的TCP参数，此处将它的backlog设置为1024
  33.                 .option(ChannelOption.SO_BACKLOG, )
  34.                 //绑定I/O事件的处理类ChildChannelHandler，它的作用类似于Reactor模式中的Handler类，主要用于处理网络I/O事件，例如记录日志、对消息进行编解码等
  35.                 .childHandler(new ChildChannelHandler());
  36.             //调用bind方法绑定监听端口，随后，调用它的同步阻塞方法sync等待绑定操作完成。
  37.             //完成之后Netty会返回一个ChannelFuture，它的功能类似于JDK的java.util.concurrent.Future，主要用于异步操作的通知回调
  38.             ChannelFuture future = bootstrap.bind(port).sync();
  39.             //等待服务端监听端口关闭，等待服务端链路关闭之后main函数才退出
  40.             future.channel().closeFuture().sync();
  41.         } finally {
  42.             //优雅退出，释放线程池资源
  43.             bossGroup.shutdownGracefully();
  44.             workerGroup.shutdownGracefully();
  45.         }
  46.     }
  47.  
  48.     private class ChildChannelHandler extends ChannelInitializer<SocketChannel>{
  49.         @Override
  50.         protected void initChannel(SocketChannel ch) throws Exception {
  51.             ch.pipeline().addLast(new TimeServerHandler());
  52.         }
  53.     }
  54.  
  55.     public static void main(String[] args) throws Exception {
  56.         int port = ;
  57.         if (args != null && args.length > ) {
  58.             try {
  59.                 port = Integer.valueOf(args[]);
  60.             } catch (Exception e) {
  61.                 e.printStackTrace();
  62.             }
  63.         }
  64.         new TimeServer().bind(port);
  65.     }
  66. }

TimeServerHandler

  1. package com.zhen.netty1129_TCP_HALF_PACKAGE;
  2.  
  3. import java.util.Date;
  4.  
  5. import io.netty.buffer.ByteBuf;
  6. import io.netty.buffer.Unpooled;
  7. import io.netty.channel.ChannelHandlerAdapter;
  8. import io.netty.channel.ChannelHandlerContext;
  9.  
  10. //TimeServerHandler 继承自ChannelHandlerAdapter，它用于对网络事件进行读写操作
  11. public class TimeServerHandler extends ChannelHandlerAdapter{
  12.  
  13.     private int counter;
  14.  
  15.     @Override
  16.     public void channelRead(ChannelHandlerContext ctx, Object msg) throws Exception {
  17.         //将msg转换成Netty的ByteBuf对象。ByteBuf类似于jdk中的java.nio.ByteBuffer对象，不过它提供了更加强大和灵活的功能
  18.         ByteBuf buf = (ByteBuf) msg;
  19.         //通过ByteBuf的readableBytes方法可以获取缓冲区可读的字节数，根据可读的字节数创建byte数组
  20.         byte[] req = new byte[buf.readableBytes()];
  21.         //通过ByteBuf的readBytes方法将缓冲区中的字节数据复制到新建的byte数组中
  22.         buf.readBytes(req);
  23.         //通过new String构造函数获取请求消息
  24.         String body = new String(req, "UTF-8").substring(, req.length
  25.                 - System.getProperty("line.separator").length());
  26.         System.out.println("The time server receive order : " + body
  27.                 + "; the counter is : "+ ++counter);
  28.         //对请求消息进行判断，如果是QUERY TIME ORDER则创建应答消息
  29.         String currentTime = "QUERY TIME ORDER".equalsIgnoreCase(body) ?
  30.                 new Date(System.currentTimeMillis()).toString() : "BAD ORDER";
  31.         currentTime = currentTime + System.getProperty("line.separator");
  32.         ByteBuf resp = Unpooled.copiedBuffer(currentTime.getBytes());
  33.         //通过ChannelHandlerContext的write方法异步发送应答消息给客户端
  34.         ctx.writeAndFlush(resp);
  35.     }
  36.  
  37.     @Override
  38.     public void exceptionCaught(ChannelHandlerContext ctx, Throwable cause) throws Exception {
  39.         //当发生异常时，关闭ChannelHandlerContext，释放和ChannelHandlerContext相关联的句柄等资源
  40.         ctx.close();
  41.     }
  42. }

TimeClient

  1. package com.zhen.netty1129_TCP_HALF_PACKAGE;
  2.  
  3. import io.netty.bootstrap.Bootstrap;
  4. import io.netty.channel.Channel;
  5. import io.netty.channel.ChannelFuture;
  6. import io.netty.channel.ChannelInitializer;
  7. import io.netty.channel.ChannelOption;
  8. import io.netty.channel.EventLoopGroup;
  9. import io.netty.channel.nio.NioEventLoopGroup;
  10. import io.netty.channel.socket.nio.NioSocketChannel;
  11.  
  12. public class TimeClient {
  13.  
  14.     public void connect(int port,String host) throws Exception{
  15.         //配置客户端NIO线程组,客户端处理I/O读写的NioEventLoopGroup线程组
  16.         EventLoopGroup group = new NioEventLoopGroup();
  17.         try {
  18.             //客户端辅助启动类Bootstrap
  19.             Bootstrap bootstrap = new Bootstrap();
  20.             //设置线程组
  21.             bootstrap.group(group)
  22.                 //与服务端不同的是，它的channel需要设置为NioSocketChannel
  23.                 .channel(NioSocketChannel.class)
  24.                 .option(ChannelOption.TCP_NODELAY, true)
  25.                 //然后为其添加Handler,此处为了简单直接创建匿名内部类，实现initChannel方法
  26.                 //作用是当创建NioSocketChannel成功之后，在进行初始化时，将它的ChannelHandler设置到ChannelPipeline中，用于处理网络I/O事件
  27.                 .handler(new ChannelInitializer<Channel>() {
  28.                     @Override
  29.                     protected void initChannel(Channel ch) throws Exception {
  30.                         ch.pipeline().addLast(new TimeClientHandler());
  31.                     }
  32.                 });
  33.             //调用connect发起异步连接操作，然后调用sync同步方法等待连接成功。
  34.             ChannelFuture future = bootstrap.connect(host, port).sync();
  35.             //等待客户端链路关闭，当客户端连接关闭之后，客户端主函数退出，退出之前释放NIO线程组的资源
  36.             future.channel().closeFuture().sync();
  37.         } finally {
  38.             //优雅退出，释放NIO线程组
  39.             group.shutdownGracefully();
  40.         }
  41.     }
  42.  
  43.     public static void main(String[] args) throws Exception{
  44.         int port = ;
  45.         String host = "127.0.0.1";
  46.         if (args != null && args.length > ) {
  47.             try {
  48.                 port = Integer.valueOf(args[]);
  49.             } catch (Exception e) {
  50.                 e.printStackTrace();
  51.             }
  52.         }
  53.         new TimeClient().connect(port, host);
  54.     }
  55.  
  56. }

TimeClientHandler

  1. package com.zhen.netty1129_TCP_HALF_PACKAGE;
  2.  
  3. import java.util.logging.Logger;
  4.  
  5. import io.netty.buffer.ByteBuf;
  6. import io.netty.buffer.Unpooled;
  7. import io.netty.channel.ChannelHandlerAdapter;
  8. import io.netty.channel.ChannelHandlerContext;
  9.  
  10. public class TimeClientHandler extends ChannelHandlerAdapter{
  11.  
  12.     private static final Logger logger = Logger.getLogger(TimeClientHandler.class.getName());
  13.  
  14.     private int counter;
  15.  
  16.     private byte[] req;
  17.  
  18.     public TimeClientHandler(){
  19.         req = ("QUERY TIME ORDER"+System.getProperty("line.separator")).getBytes();
  20.  
  21.     }
  22.  
  23.     //当客户端和服务端TCP链路建立成功之后，Netty的NIO线程会调用channelActive方法，发送查询时间的指令给服务端
  24.     //调用ChannelHandlerContext的writeAndFlush方法将请求消息发送给客户端
  25.     @Override
  26.     public void channelActive(ChannelHandlerContext ctx) throws Exception {
  27.         ByteBuf message = null;
  28.         for (int i = ; i < ; i++) {
  29.             message = Unpooled.buffer(req.length);
  30.             message.writeBytes(req);
  31.             ctx.writeAndFlush(message);
  32.         }
  33.     }
  34.  
  35.     //当客户端返回应答消息，channelRead方法被调用
  36.     @Override
  37.     public void channelRead(ChannelHandlerContext ctx, Object msg) throws Exception {
  38.         ByteBuf buf = (ByteBuf) msg;
  39.         byte[] req = new byte[buf.readableBytes()];
  40.         buf.readBytes(req);
  41.         String body = new String(req, "UTF-8");
  42.         System.out.println("Now is :" + body + " ; the counter is : " + ++counter);
  43.     }
  44.  
  45.     //发生异常时，释放客户端资源
  46.     @Override
  47.     public void exceptionCaught(ChannelHandlerContext ctx, Throwable cause) throws Exception {
  48.         logger.warning("Unexpected exception from downstream : " + cause.getMessage());
  49.         ctx.close();
  50.     }
  51.  
  52. }

此时启动server，再启动client，可看到以下结果

server端

client端

可以发现，server只受到了两条消息，说明发生了粘包，但是我们期望的是收到100条消息，每条包含一条”QUERY TIME ORDER”指令，这说明发生了TCP粘包
客户端应该收到100条当前系统时间，但实际上只收到了一条，因为服务端只收到了2条请求消息，所以实际服务端只发送了2条应答，由于请求消息不满足查询条件，所以返回了2条”BAD ORDER”应答消息。但是实际上客户端只收到了一条包含两条”BAD ORDER”指令的消息，说明服务端返回的应答消息也发生了粘包

解决TCP粘包问题

利用LineBasedFrameDecoder解决TCP粘包问题

为了解决TCP粘包／拆包导致的半包读写问题，Netty默认提供了多种编解码器用于处理半包，只要能熟练掌握这些类库的使用，TCP粘包问题从此会变得非常容易

来看代码

TimeServer

  1. package com.zhen.netty1129_TCP_HALF_PACKAGE_SOLVE;
  2.  
  3. import java.awt.Event;
  4. import java.net.Socket;
  5.  
  6. import io.netty.bootstrap.ServerBootstrap;
  7. import io.netty.channel.ChannelFuture;
  8. import io.netty.channel.ChannelInitializer;
  9. import io.netty.channel.ChannelOption;
  10. import io.netty.channel.EventLoop;
  11. import io.netty.channel.EventLoopGroup;
  12. import io.netty.channel.nio.NioEventLoopGroup;
  13. import io.netty.channel.socket.SocketChannel;
  14. import io.netty.channel.socket.nio.NioServerSocketChannel;
  15. import io.netty.handler.codec.LineBasedFrameDecoder;
  16. import io.netty.handler.codec.string.StringDecoder;
  17.  
  18. public class TimeServer {
  19.  
  20.     public void bind(int port) throws Exception{
  21.         //配置服务端的NIO线程组
  22.         //NioEventLoopGroup是个线程组，它包含了一组NIO线程，专门用于网络事件的处理，实际上它们就是Reactor线程组
  23.         //bossGroup用于服务端接受客户端的连接
  24.         EventLoopGroup bossGroup = new NioEventLoopGroup();
  25.         //workerGroup进行SocketChannel的网络读写
  26.         EventLoopGroup workerGroup = new NioEventLoopGroup();
  27.         try {
  28.             //Netty用于启动NIO服务端的辅助启动类，目的是降低服务端的开发复杂度
  29.             ServerBootstrap bootstrap = new ServerBootstrap();
  30.             //将两个NIO线程组当作入参传递到ServerBootstrap
  31.             bootstrap.group(bossGroup, workerGroup)
  32.                 //设置创建的Channel为NioServerSocketChannel,它的功能对应于JDK NIO类库中的ServerSocketChannel类。
  33.                 .channel(NioServerSocketChannel.class)
  34.                 //配置NioServerSocketChannel的TCP参数，此处将它的backlog设置为1024
  35.                 .option(ChannelOption.SO_BACKLOG, )
  36.                 //绑定I/O事件的处理类ChildChannelHandler，它的作用类似于Reactor模式中的Handler类，主要用于处理网络I/O事件，例如记录日志、对消息进行编解码等
  37.                 .childHandler(new ChildChannelHandler());
  38.             //调用bind方法绑定监听端口，随后，调用它的同步阻塞方法sync等待绑定操作完成。
  39.             //完成之后Netty会返回一个ChannelFuture，它的功能类似于JDK的java.util.concurrent.Future，主要用于异步操作的通知回调
  40.             ChannelFuture future = bootstrap.bind(port).sync();
  41.             //等待服务端监听端口关闭，等待服务端链路关闭之后main函数才退出
  42.             future.channel().closeFuture().sync();
  43.         } finally {
  44.             //优雅退出，释放线程池资源
  45.             bossGroup.shutdownGracefully();
  46.             workerGroup.shutdownGracefully();
  47.         }
  48.     }
  49.  
  50.     private class ChildChannelHandler extends ChannelInitializer<SocketChannel>{
  51.         @Override
  52.         protected void initChannel(SocketChannel ch) throws Exception {
  53.             //在原来的TimeServerHandler之前新增了两个解码器LineBasedFrameDecoder、StringDecoder
  54.             ch.pipeline().addLast(new LineBasedFrameDecoder(1024));
  55.             ch.pipeline().addLast(new StringDecoder());
  56.             ch.pipeline().addLast(new TimeServerHandler());
  57.         }
  58.     }
  59.  
  60.     public static void main(String[] args) throws Exception {
  61.         int port = ;
  62.         if (args != null && args.length > ) {
  63.             try {
  64.                 port = Integer.valueOf(args[]);
  65.             } catch (Exception e) {
  66.                 e.printStackTrace();
  67.             }
  68.         }
  69.         new TimeServer().bind(port);
  70.     }
  71. }

TimeServerHandler

  1. package com.zhen.netty1129_TCP_HALF_PACKAGE_SOLVE;
  2.  
  3. import java.util.Date;
  4.  
  5. import io.netty.buffer.ByteBuf;
  6. import io.netty.buffer.Unpooled;
  7. import io.netty.channel.ChannelHandlerAdapter;
  8. import io.netty.channel.ChannelHandlerContext;
  9.  
  10. //TimeServerHandler 继承自ChannelHandlerAdapter，它用于对网络事件进行读写操作
  11. public class TimeServerHandler extends ChannelHandlerAdapter{
  12.  
  13.     private int counter;
  14.  
  15.     @Override
  16.     public void channelRead(ChannelHandlerContext ctx, Object msg) throws Exception {
  17.         String body = (String)msg;
  18.         System.out.println("The time server receive order : " + body
  19.                 + "; the counter is : "+ ++counter);
  20.         //对请求消息进行判断，如果是QUERY TIME ORDER则创建应答消息
  21.         String currentTime = "QUERY TIME ORDER".equalsIgnoreCase(body) ?
  22.                 new Date(System.currentTimeMillis()).toString() : "BAD ORDER";
  23.         currentTime = currentTime + System.getProperty("line.separator");
  24.         ByteBuf resp = Unpooled.copiedBuffer(currentTime.getBytes());
  25.         //通过ChannelHandlerContext的write方法异步发送应答消息给客户端
  26.         ctx.writeAndFlush(resp);
  27.     }
  28.  
  29.     @Override
  30.     public void exceptionCaught(ChannelHandlerContext ctx, Throwable cause) throws Exception {
  31.         //当发生异常时，关闭ChannelHandlerContext，释放和ChannelHandlerContext相关联的句柄等资源
  32.         ctx.close();
  33.     }
  34. }

TimeClient

  1. package com.zhen.netty1129_TCP_HALF_PACKAGE_SOLVE;
  2.  
  3. import io.netty.bootstrap.Bootstrap;
  4. import io.netty.channel.Channel;
  5. import io.netty.channel.ChannelFuture;
  6. import io.netty.channel.ChannelInitializer;
  7. import io.netty.channel.ChannelOption;
  8. import io.netty.channel.EventLoopGroup;
  9. import io.netty.channel.nio.NioEventLoopGroup;
  10. import io.netty.channel.socket.nio.NioSocketChannel;
  11. import io.netty.handler.codec.LineBasedFrameDecoder;
  12. import io.netty.handler.codec.string.StringDecoder;
  13.  
  14. public class TimeClient {
  15.  
  16.     public void connect(int port,String host) throws Exception{
  17.         //配置客户端NIO线程组,客户端处理I/O读写的NioEventLoopGroup线程组
  18.         EventLoopGroup group = new NioEventLoopGroup();
  19.         try {
  20.             //客户端辅助启动类Bootstrap
  21.             Bootstrap bootstrap = new Bootstrap();
  22.             //设置线程组
  23.             bootstrap.group(group)
  24.                 //与服务端不同的是，它的channel需要设置为NioSocketChannel
  25.                 .channel(NioSocketChannel.class)
  26.                 .option(ChannelOption.TCP_NODELAY, true)
  27.                 //然后为其添加Handler,此处为了简单直接创建匿名内部类，实现initChannel方法
  28.                 //作用是当创建NioSocketChannel成功之后，在进行初始化时，将它的ChannelHandler设置到ChannelPipeline中，用于处理网络I/O事件
  29.                 .handler(new ChannelInitializer<Channel>() {
  30.                     @Override
  31.                     protected void initChannel(Channel ch) throws Exception {
  32.                         //在原来的TimeClientHandler之前新增了两个解码器LineBasedFrameDecoder、StringDecoder
  33.                         ch.pipeline().addLast(new LineBasedFrameDecoder(1024));
  34.                         ch.pipeline().addLast(new StringDecoder());
  35.                         ch.pipeline().addLast(new TimeClientHandler());
  36.                     }
  37.                 });
  38.             //调用connect发起异步连接操作，然后调用sync同步方法等待连接成功。
  39.             ChannelFuture future = bootstrap.connect(host, port).sync();
  40.             //等待客户端链路关闭，当客户端连接关闭之后，客户端主函数退出，退出之前释放NIO线程组的资源
  41.             future.channel().closeFuture().sync();
  42.         } finally {
  43.             //优雅退出，释放NIO线程组
  44.             group.shutdownGracefully();
  45.         }
  46.     }
  47.  
  48.     public static void main(String[] args) throws Exception{
  49.         int port = ;
  50.         String host = "127.0.0.1";
  51.         if (args != null && args.length > ) {
  52.             try {
  53.                 port = Integer.valueOf(args[]);
  54.             } catch (Exception e) {
  55.                 e.printStackTrace();
  56.             }
  57.         }
  58.         new TimeClient().connect(port, host);
  59.     }
  60.  
  61. }

TimeClientHandler

  1. package com.zhen.netty1129_TCP_HALF_PACKAGE_SOLVE;
  2.  
  3. import java.util.logging.Logger;
  4.  
  5. import io.netty.buffer.ByteBuf;
  6. import io.netty.buffer.Unpooled;
  7. import io.netty.channel.ChannelHandlerAdapter;
  8. import io.netty.channel.ChannelHandlerContext;
  9.  
  10. public class TimeClientHandler extends ChannelHandlerAdapter{
  11.  
  12.     private static final Logger logger = Logger.getLogger(TimeClientHandler.class.getName());
  13.  
  14.     private int counter;
  15.  
  16.     private byte[] req;
  17.  
  18.     public TimeClientHandler(){
  19.         req = ("QUERY TIME ORDER"+System.getProperty("line.separator")).getBytes();
  20.  
  21.     }
  22.  
  23.     //当客户端和服务端TCP链路建立成功之后，Netty的NIO线程会调用channelActive方法，发送查询时间的指令给服务端
  24.     //调用ChannelHandlerContext的writeAndFlush方法将请求消息发送给客户端
  25.     @Override
  26.     public void channelActive(ChannelHandlerContext ctx) throws Exception {
  27.         ByteBuf message = null;
  28.         for (int i = ; i < ; i++) {
  29.             message = Unpooled.buffer(req.length);
  30.             message.writeBytes(req);
  31.             ctx.writeAndFlush(message);
  32.         }
  33.     }
  34.  
  35.     //当客户端返回应答消息，channelRead方法被调用
  36.     @Override
  37.     public void channelRead(ChannelHandlerContext ctx, Object msg) throws Exception {
  38.         //拿到的msg已经是解码成字符串之后的应答消息了。
  39.         String body = (String)msg;
  40.         System.out.println("Now is :" + body + " ; the counter is : " + ++counter);
  41.     }
  42.  
  43.     //发生异常时，释放客户端资源
  44.     @Override
  45.     public void exceptionCaught(ChannelHandlerContext ctx, Throwable cause) throws Exception {
  46.         logger.warning("Unexpected exception from downstream : " + cause.getMessage());
  47.         ctx.close();
  48.     }
  49.  
  50. }

此时再次运行，查看结果

Server端

client端

此时TCP粘包问题已经解决

LineBasedFrameDecoder和StringDecoder的原理分析
LineBasedFrameDecoder的工作原理是依次便利ByteBuf中的刻度子节，判断看是否有”\n” 或者“\r”，如果有，就以此为止为结束位置，从可读索引到结束位置区间的字节久组成了一行。它是以换行符为结束标志的解码器，支持携带结束符或者不携带结束符两种编码方式，同时支持配置单行的最大长度后仍然没有发现换行符，就会抛出异常，同时忽略掉之前读到的异常码流。
StringDecoder的功能非常简单，就是将接收到的对象转换成字符串，然后继续调用后面的handler。LineBasedFrameDecoder+StringDecoder组合就是按行切换的文本解码器，它被设计用来支持TCP的粘包和拆包.

Netty使用LineBasedFrameDecoder解决TCP粘包/拆包的更多相关文章

  1. 深入学习Netty（5）——Netty是如何解决TCP粘包/拆包问题的？

    前言 学习Netty避免不了要去了解TCP粘包/拆包问题,熟悉各个编解码器是如何解决TCP粘包/拆包问题的,同时需要知道TCP粘包/拆包问题是怎么产生的. 在此博文前,可以先学习了解前几篇博文: 深入 ...

  2. Netty（三）TCP粘包拆包处理

    tcp是一个“流”的协议,一个完整的包可能会被TCP拆分成多个包进行发送,也可能把小的封装成一个大的数据包发送,这就是所谓的TCP粘包和拆包问题. 粘包.拆包问题说明 假设客户端分别发送数据包D1和D ...

  3. Netty（二）——TCP粘包/拆包

    转载请注明出处:http://www.cnblogs.com/Joanna-Yan/p/7814644.html 前面讲到:Netty(一)--Netty入门程序 主要内容: TCP粘包/拆包的基础知 ...

  4. 《精通并发与Netty》学习笔记（13 - 解决TCP粘包拆包（一）概念及实例演示）

    一.粘包/拆包概念 TCP是一个“流”协议,所谓流,就是没有界限的一长串二进制数据.TCP作为传输层协议并不不了解上层业务数据的具体含义,它会根据TCP缓冲区的实际情况进行数据包的划分,所以在业务上认 ...

  5. 1. Netty解决Tcp粘包拆包

    一. TCP粘包问题 实际发送的消息, 可能会被TCP拆分成很多数据包发送, 也可能把很多消息组合成一个数据包发送 粘包拆包发生的原因 (1) 应用程序一次写的字节大小超过socket发送缓冲区大小 ...

  6. 【转】Netty之解决TCP粘包拆包(自定义协议)

    1.什么是粘包/拆包 一般所谓的TCP粘包是在一次接收数据不能完全地体现一个完整的消息数据.TCP通讯为何存在粘包呢?主要原因是TCP是以流的方式来处理数据,再加上网络上MTU的往往小于在应用处理的消 ...

  7. Netty之解决TCP粘包拆包(自定义协议)

    1.什么是粘包/拆包 一般所谓的TCP粘包是在一次接收数据不能完全地体现一个完整的消息数据.TCP通讯为何存在粘包呢?主要原因是TCP是以流的方式来处理数据,再加上网络上MTU的往往小于在应用处理的消 ...

  8. 《精通并发与Netty》学习笔记（14 - 解决TCP粘包拆包（二）Netty自定义协议解决粘包拆包）

    一.Netty粘包和拆包解决方案 Netty提供了多个解码器,可以进行分包的操作,分别是: * LineBasedFrameDecoder (换行)   LineBasedFrameDecoder是回 ...

  9. Netty解决TCP粘包/拆包问题 - 按行分隔字符串解码器

    服务端 package org.zln.netty.five.timer; import io.netty.bootstrap.ServerBootstrap; import io.netty.cha ...

随机推荐

  1. baksmali反编译出现:UNEXPECTED TOP-LEVEL ERROR:....Too many open files

    解包大型apk文件,可能会出现例如以下错误, UNEXPECTED TOP-LEVEL ERROR: java.util.concurrent.ExecutionException: java.io. ...

  2. Oracle 技术支持之现场优化的思维路径

    性能调优是每个DBA职业生涯中都能遇到的任务     大到世界五百强的核心系统,小到乡镇企业的进销存,几乎都会有要调优的时候     面对形形色色的系统,林林总总的需求,调优的手段也是丰富多彩 定位问 ...

  3. 刷脸支付真的来啦！华为nova3带你玩转酷时代~

    无论是不愿脱离手套的怕冷手. 或是沾满泥土芬芳的勤劳手. 还是挂着水滴的清洁手…… 每当这些时刻,打开支付宝认证支付, 指纹解锁的能力总是光彩尽失. 不过,就在华为nova 3的发布会上, 一项传说已 ...

  4. linux .vimrc的设置!

    0.记得在配之前先下载vim.不同的版本下载vim使用不同命令 ubuntu使用sudo apt-get install vim 1.vi ~/.vimrc  打开当前用户下的vim的配置文件(修改完 ...

  5. saltstack之nginx部署

    1./srv/salt/nginx目录树 . conf.sls file |--- nginx |--- nginx-1.5.1.tar.gz |--- nginx.conf |--- nginx_l ...

  6. PHP-Manual的学习----【语言参考】----【类型】-----【Resource 资源类型】

    2017年8月24日11:29:361.资源 resource 是一种特殊变量,保存了到外部资源的一个引用.资源是通过专门的函数来建立和使用的.2.由于资源类型变量保存有为打开文件.数据库连接.图形画 ...

  7. Java是否存在内存泄露

    会的. 原因:长生命周期的对象持有短生命周期对象的引用,导致短生命周期对象不能被回收,由此可能发生内存泄露. 举例参考:http://blog.csdn.net/yakihappy/article/d ...

  8. 也谈在 .NET 平台上使用 Scala 语言(续)

    而我是在 Ubuntu 操作系统中使用 Scala.NET 的,应该没有这个问题. 那么,就让我们来測试一下吧. 如今,我们添加一个 DotNet.cs 文件,例如以下所看到的: 1 2 3 4 5 ...

  9. 关于function的一种常用用法

    关于function的一种常用用法 void Share::InitAcrossManager() { GsMgrEvent gsMgrEvents;//保存function的结构体 gsMgrEve ...

  10. Fiddler 抓取 ios 端数据包

    前提条件: 1. Fiddler 工具安装完成,并授权成功,可以完成网页的http 协议拦截. 2. iphone X 一部 ☺ 3. 360wifi 一个[同一局域网内,任何wifi都可以设置,其他 ...