《精通併發與Netty》學習筆記（13 - 解決TCP粘包拆包（一）概念及實例演示）

時間 2019-12-12

原文原文鏈接

1、粘包/拆包概念java

TCP是一個「流」協議，所謂流，就是沒有界限的一長串二進制數據。TCP做爲傳輸層協議並不不瞭解上層業務數據的具體含義，它會根據TCP緩衝區的實際狀況進行數據包的劃分，因此在業務上認爲是一個完整的包，可能會被TCP拆分紅多個包進行發送，也有可能把多個小的包封裝成一個大的數據包發送，這就是所謂的TCP粘包和拆包問題。spring

通常所謂的TCP粘包是在一次接收數據不能徹底地體現一個完整的消息數據。TCP通信爲什麼存在粘包呢？主要緣由是TCP是以流的方式來處理數據，再加上網絡上MTU的每每小於在應用處理的消息數據，因此就會引起一次接收的數據沒法知足消息的須要，致使粘包的存在。處理粘包的惟一方法就是制定應用層的數據通信協議，經過協議來規範現有接收的數據是否知足消息數據的須要。編程

如今假設客戶端向服務端連續發送了兩個數據包，用packet1和packet2來表示，那麼服務端收到的數據能夠分爲三種，現列舉以下： bootstrap

第一種狀況：網絡

接收端正常收到兩個數據包，即沒有發生拆包和粘包的現象，此種狀況不在本文的討論範圍內。dom

第二種狀況：socket

接收端只收到一個數據包，因爲TCP是不會出現丟包的，因此這一個數據包中包含了發送端發送的兩個數據包的信息，這種現象即爲粘包。這種狀況因爲接收端不知道這兩個數據包的界限，因此對於接收端來講很難處理。ide

第三種狀況：oop

這種狀況有兩種表現形式，以下圖。接收端收到了兩個數據包，可是這兩個數據包要麼是不完整的，要麼就是多出來一塊，這種狀況即發生了拆包和粘包。這兩種狀況若是不加特殊處理，對於接收端一樣是很差處理的。this

2、粘包問題的解決策略

消息定長，報文大小固定長度，不夠空格補全，發送和接收方遵循相同的約定，這樣即便粘包了經過接收方編程實現獲取定長報文也能區分。
包尾添加特殊分隔符，例如每條報文結束都添加回車換行符（例如FTP協議）或者指定特殊字符做爲報文分隔符，接收方經過特殊分隔符切分報文區分。
將消息分爲消息頭和消息體，消息頭中包含表示信息的總長度（或者消息體長度）的字段

3、Netty粘包和拆包解決方案

Netty提供了多個解碼器，能夠進行分包的操做，分別是：
LineBasedFrameDecoder
DelimiterBasedFrameDecoder（添加特殊分隔符報文來分包）
FixedLengthFrameDecoder（使用定長的報文來分包）
LengthFieldBasedFrameDecoder

4、TCP粘包和拆包實例演示

首先編寫服務端

package com.spring.netty.handler;

import io.netty.bootstrap.ServerBootstrap;
import io.netty.channel.ChannelFuture;
import io.netty.channel.EventLoopGroup;
import io.netty.channel.nio.NioEventLoopGroup;
import io.netty.channel.socket.nio.NioServerSocketChannel;

public class MyServer {
    public static void main(String[] args) throws Exception {
        EventLoopGroup bossGroup = new NioEventLoopGroup(1);
        EventLoopGroup workerGroup = new NioEventLoopGroup();

        try {
            ServerBootstrap serverBootstrap = new ServerBootstrap();
            serverBootstrap.group(bossGroup,workerGroup).channel(NioServerSocketChannel.class).
                    childHandler(new MyServerInitializer());

            ChannelFuture channelFuture = serverBootstrap.bind(8899).sync();
            channelFuture.channel().closeFuture().sync();
        }finally {
            bossGroup.shutdownGracefully();
            workerGroup.shutdownGracefully();
        }
    }
}

package com.spring.netty.handler;

import io.netty.channel.ChannelInitializer;
import io.netty.channel.ChannelPipeline;
import io.netty.channel.socket.SocketChannel;

public class MyServerInitializer extends ChannelInitializer<SocketChannel> {
    @Override
    protected void initChannel(SocketChannel ch) throws Exception {
        ChannelPipeline pipeline = ch.pipeline();
        pipeline.addLast(new MyServerHandler());
    }
}

package com.spring.netty.handler;

import io.netty.buffer.ByteBuf;
import io.netty.buffer.Unpooled;
import io.netty.channel.ChannelHandlerContext;
import io.netty.channel.SimpleChannelInboundHandler;

import java.nio.charset.Charset;
import java.util.UUID;

public class MyServerHandler extends SimpleChannelInboundHandler<ByteBuf> {

    private int count;

    @Override
    protected void channelRead0(ChannelHandlerContext ctx, ByteBuf msg) throws Exception {
        byte[] buffer = new byte[msg.readableBytes()];
        msg.readBytes(buffer);

        String message = new String(buffer, Charset.forName("utf-8"));
        System.out.println("服務端接收到的消息內容:"+message);
        System.out.println("服務端接收的消息數量:"+(++this.count));

        ByteBuf responseByteBuf = Unpooled.copiedBuffer(UUID.randomUUID().toString(),Charset.forName("utf-8"));
        ctx.writeAndFlush(responseByteBuf);
    }

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

而後編寫客戶端

package com.spring.netty.handler;

import io.netty.bootstrap.Bootstrap;
import io.netty.channel.ChannelFuture;
import io.netty.channel.EventLoopGroup;
import io.netty.channel.nio.NioEventLoopGroup;
import io.netty.channel.socket.nio.NioSocketChannel;

public class MyClient {
    public static void main(String[] args) throws Exception {
        EventLoopGroup eventLoopGroup = new NioEventLoopGroup();
        try {
            Bootstrap bootstrap = new Bootstrap();
            bootstrap.group(eventLoopGroup).channel(NioSocketChannel.class)
                    .handler(new MyClientInitializer());
            ChannelFuture channelFuture = bootstrap.connect("localhost",8899).sync();
            channelFuture.channel().closeFuture().sync();
        }finally {
            eventLoopGroup.shutdownGracefully();
        }
    }
}

package com.spring.netty.handler;

import io.netty.channel.ChannelInitializer;
import io.netty.channel.ChannelPipeline;
import io.netty.channel.socket.SocketChannel;

public class MyClientInitializer extends ChannelInitializer<SocketChannel> {
    @Override
    protected void initChannel(SocketChannel ch) throws Exception {
        ChannelPipeline pipeline = ch.pipeline();
        pipeline.addLast(new MyClientHandler());
    }
}

package com.spring.netty.handler;

import io.netty.buffer.ByteBuf;
import io.netty.buffer.Unpooled;
import io.netty.channel.ChannelHandler;
import io.netty.channel.ChannelHandlerContext;
import io.netty.channel.SimpleChannelInboundHandler;
import io.netty.util.concurrent.EventExecutorGroup;

import java.nio.charset.Charset;

public class MyClientHandler extends SimpleChannelInboundHandler<ByteBuf> {
    private int count;
    @Override
    public void channelActive(ChannelHandlerContext ctx) throws Exception {
        for(int i=0;i<10;i++){
            ByteBuf buffer = Unpooled.copiedBuffer("send from client ", Charset.forName("utf-8"));
            ctx.writeAndFlush(buffer);
        }
    }

    @Override
    protected void channelRead0(ChannelHandlerContext ctx, ByteBuf msg) throws Exception {
        byte[] buffer = new byte[msg.readableBytes()];
        msg.readBytes(buffer);

        String message = new String(buffer,Charset.forName("utf-8"));
        System.out.println("客戶端接收到的消息內容："+message);
        System.out.println("客戶端接收到的消息數量:"+(++this.count));
    }

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