2. 程式人生 > >一起學Netty（七）之 TCP粘包拆包基本解決方案

一起學Netty（七）之 TCP粘包拆包基本解決方案

阿新 • • 發佈：2019-02-17

上個小節我們淺析了在Netty的使用的時候TCP的粘包和拆包的現象，Netty對此問題提供了相對比較豐富的解決方案

Netty提供了幾個常用的解碼器，幫助我們解決這些問題，其實上述的粘包和拆包的問題，歸根結底的解決方案就是傳送端給遠端端一個標記，告訴遠端端，每個資訊的結束標誌是什麼，這樣，遠端端獲取到資料後，根據跟傳送端約束的標誌，將接收的資訊分切或者合併成我們需要的資訊，這樣我們就可以獲取到正確的資訊了

例如，我們剛才的例子中，我們可以在傳送的資訊中，加一個結束標誌，例如兩個遠端端規定以行來切分資料，那麼傳送端，就需要在每個資訊體的末尾加上行結束的標誌，部分程式碼如下：

修改BaseClientHandler的req的構造：

public BaseClientHandler() {
//        req = ("BazingaLyncc is learner").getBytes();
        req = ("In this chapter you general, we recommend Java Concurrency in Practice by Brian Goetz. His book w"
                + "ill give We’ve reached an exciting point—in the next chapter we’ll discuss bootstrapping, the process "
                + "of configuring and connecting all of Netty’s components to bring your learned about threading models in ge"
                + "neral and Netty’s threading model in particular, whose performance and consistency advantages we discuss"
                + "ed in detail In this chapter you general, we recommend Java Concurrency in Practice by Brian Goetz. Hi"
                + "s book will give We’ve reached an exciting point—in the next chapter we’ll discuss bootstrapping, the"
                + " process of configuring and connecting all of Netty’s components to bring your learned about threading "
                + "models in general and Netty’s threading model in particular, whose performance and consistency advantag"
                + "es we discussed in detailIn this chapter you general, we recommend Java Concurrency in Practice by Bri"
                + "an Goetz. His book will give We’ve reached an exciting point—in the next chapter;the counter is: 1 2222"
                + "sdsa ddasd asdsadas dsadasdas" + System.getProperty("line.separator")).getBytes();
    }
我們在我們巨長的req中末尾加了System.getProperty("line.separator")，這樣相當於給req打了一個標記

打完標記，其實我們這個示例中的server中還不知道是以行為結尾的，所以我們需要修改server的handler鏈，在inbound鏈中加一個額外的處理鏈，判斷一下，獲取的資訊按照行來切分，我們很慶幸，這樣枯燥的程式碼Netty已經幫我們完美地完成了，Netty提供了一個LineBasedFrameDecoder這個類，顧名思義，這個類名字中有decoder，說明是一個解碼器，我們再看看它的詳細宣告：

/**
 * A decoder that splits the received {@link ByteBuf}s on line endings.
 * <p>
 * Both {@code "\n"} and {@code "\r\n"} are handled.
 * For a more general delimiter-based decoder, see {@link DelimiterBasedFrameDecoder}.
 */
public class LineBasedFrameDecoder extends ByteToMessageDecoder {

    /** Maximum length of a frame we're willing to decode.  */
    private final int maxLength;
    /** Whether or not to throw an exception as soon as we exceed maxLength. */
    private final boolean failFast;
    private final boolean stripDelimiter;

    /** True if we're discarding input because we're already over maxLength.  */
    private boolean discarding;
    private int discardedBytes;
它是繼承ByteToMessageDecoder的，是將byte型別轉化成Message的，所以我們應該將這個解碼器放在inbound處理器鏈的第一個，所以我們修改一下Server端的啟動程式碼： 
package com.lyncc.netty.stickpackage.myself;

import io.netty.bootstrap.ServerBootstrap;
import io.netty.channel.ChannelFuture;
import io.netty.channel.ChannelInitializer;
import io.netty.channel.ChannelOption;
import io.netty.channel.EventLoopGroup;
import io.netty.channel.nio.NioEventLoopGroup;
import io.netty.channel.socket.SocketChannel;
import io.netty.channel.socket.nio.NioServerSocketChannel;
import io.netty.handler.codec.LineBasedFrameDecoder;
import io.netty.handler.codec.string.StringDecoder;

import java.net.InetSocketAddress;

public class BaseServer {

    private int port;
    
    public BaseServer(int port) {
        this.port = port;
    }
    
    public void start(){
        EventLoopGroup bossGroup = new NioEventLoopGroup(1);
        EventLoopGroup workerGroup = new NioEventLoopGroup();
        try {
            ServerBootstrap sbs = new ServerBootstrap().group(bossGroup,workerGroup).channel(NioServerSocketChannel.class).localAddress(new InetSocketAddress(port))
                    .childHandler(new ChannelInitializer<SocketChannel>() {
                        
                        protected void initChannel(SocketChannel ch) throws Exception {
                            ch.pipeline().addLast(new LineBasedFrameDecoder(2048));
                            ch.pipeline().addLast(new StringDecoder());
                            ch.pipeline().addLast(new BaseServerHandler());
                        };
                        
                    }).option(ChannelOption.SO_BACKLOG, 128)   
                    .childOption(ChannelOption.SO_KEEPALIVE, true);
             // 繫結埠，開始接收進來的連線
             ChannelFuture future = sbs.bind(port).sync();  
             
             System.out.println("Server start listen at " + port );
             future.channel().closeFuture().sync();
        } catch (Exception e) {
            bossGroup.shutdownGracefully();
            workerGroup.shutdownGracefully();
        }
    }
    
    public static void main(String[] args) throws Exception {
        int port;
        if (args.length > 0) {
            port = Integer.parseInt(args[0]);
        } else {
            port = 8080;
        }
        new BaseServer(port).start();
    }
}
這樣，我們只是在initChannel方法中增加了一個LineBasedFrameDecoder這個類，其中2048是規定一行資料最大的位元組數

我們再次執行，我們再看看效果：

可以看到客戶端傳送的兩次msg，被伺服器端成功地兩次接收了，我們要的效果達到了

我們將LineBasedFrameDecoder中的2048引數，縮小一半，變成1024，我們再看看效果：

出現了異常，這個異常時TooLongFrameException,這個異常在Netty in Action中介紹過，幀的大小太大，在我們這個場景中，就是我們傳送的一行資訊大小是1076，大於了我們規定的1024所以報錯了

我們再解決另一個粘包的問題，我們可以看到上節中介紹的那個粘包案例中，我們傳送了100次的資訊“BazingaLyncc is learner”，這個案例很特殊，這個資訊是一個特長的資料，位元組長度是23，所以我們可以使用Netty為我們提供的FixedLengthFrameDecoder這個解碼器，看到這個名字就明白了大半，定長資料幀的解碼器，所以我們修改一下程式碼：

BaseClientHandler：

package com.lyncc.netty.stickpackage.myself;

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

public class BaseClientHandler extends ChannelInboundHandlerAdapter{
    
    private byte[] req;
    
    public BaseClientHandler() {
        req = ("BazingaLyncc is learner").getBytes();
//        req = ("In this chapter you general, we recommend Java Concurrency in Practice by Brian Goetz. His book w"
//                + "ill give We’ve reached an exciting point—in the next chapter we’ll discuss bootstrapping, the process "
//                + "of configuring and connecting all of Netty’s components to bring your learned about threading models in ge"
//                + "neral and Netty’s threading model in particular, whose performance and consistency advantages we discuss"
//                + "ed in detail In this chapter you general, we recommend Java Concurrency in Practice by Brian Goetz. Hi"
//                + "s book will give We’ve reached an exciting point—in the next chapter we’ll discuss bootstrapping, the"
//                + " process of configuring and connecting all of Netty’s components to bring your learned about threading "
//                + "models in general and Netty’s threading model in particular, whose performance and consistency advantag"
//                + "es we discussed in detailIn this chapter you general, we recommend Java Concurrency in Practice by Bri"
//                + "an Goetz. His book will give We’ve reached an exciting point—in the next chapter;the counter is: 1 2222"
//                + "sdsa ddasd asdsadas dsadasdas" + System.getProperty("line.separator")).getBytes();
    }
    
    
    @Override
    public void channelActive(ChannelHandlerContext ctx) throws Exception {
        ByteBuf message = null;
        for (int i = 0; i < 100; i++) {
            message = Unpooled.buffer(req.length);
            message.writeBytes(req);
            ctx.writeAndFlush(message);
        }
//        message = Unpooled.buffer(req.length);
//        message.writeBytes(req);
//        ctx.writeAndFlush(message);
//        message = Unpooled.buffer(req.length);
//        message.writeBytes(req);
//        ctx.writeAndFlush(message);
    }

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

}
BaseServer： 
package com.lyncc.netty.stickpackage.myself;

import io.netty.bootstrap.ServerBootstrap;
import io.netty.channel.ChannelFuture;
import io.netty.channel.ChannelInitializer;
import io.netty.channel.ChannelOption;
import io.netty.channel.EventLoopGroup;
import io.netty.channel.nio.NioEventLoopGroup;
import io.netty.channel.socket.SocketChannel;
import io.netty.channel.socket.nio.NioServerSocketChannel;
import io.netty.handler.codec.FixedLengthFrameDecoder;
import io.netty.handler.codec.string.StringDecoder;

import java.net.InetSocketAddress;

public class BaseServer {

    private int port;
    
    public BaseServer(int port) {
        this.port = port;
    }
    
    public void start(){
        EventLoopGroup bossGroup = new NioEventLoopGroup(1);
        EventLoopGroup workerGroup = new NioEventLoopGroup();
        try {
            ServerBootstrap sbs = new ServerBootstrap().group(bossGroup,workerGroup).channel(NioServerSocketChannel.class).localAddress(new InetSocketAddress(port))
                    .childHandler(new ChannelInitializer<SocketChannel>() {
                        
                        protected void initChannel(SocketChannel ch) throws Exception {
                            ch.pipeline().addLast(new FixedLengthFrameDecoder(23));
                            ch.pipeline().addLast(new StringDecoder());
                            ch.pipeline().addLast(new BaseServerHandler());
                        };
                        
                    }).option(ChannelOption.SO_BACKLOG, 128)   
                    .childOption(ChannelOption.SO_KEEPALIVE, true);
             // 繫結埠，開始接收進來的連線
             ChannelFuture future = sbs.bind(port).sync();  
             
             System.out.println("Server start listen at " + port );
             future.channel().closeFuture().sync();
        } catch (Exception e) {
            bossGroup.shutdownGracefully();
            workerGroup.shutdownGracefully();
        }
    }
    
    public static void main(String[] args) throws Exception {
        int port;
        if (args.length > 0) {
            port = Integer.parseInt(args[0]);
        } else {
            port = 8080;
        }
        new BaseServer(port).start();
    }
}
我們就是在channelhandler鏈中，加入了FixedLengthFrameDecoder，且引數是23，告訴Netty，獲取的幀資料有23個位元組就切分一次

執行結果：

可以看見，我們獲取到了我們想要的效果

當然Netty還提供了一些其他的解碼器，有他們自己的使用場景，例如有按照某個固定字元切分的DelimiterBasedFrameDecoder的解碼器

我們再次修改程式碼：

BaseClientHandler.java

package com.lyncc.netty.stickpackage.myself;

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

public class BaseClientHandler extends ChannelInboundHandlerAdapter{
    
    private byte[] req;
    
    public BaseClientHandler() {
//        req = ("BazingaLyncc is learner").getBytes();
        req = ("In this chapter you general, we recommend Java Concurrency in Practice by Brian Goetz. $$__ His book w"
                + "ill give We’ve reached an exciting point—in the next chapter we’ll $$__ discuss bootstrapping, the process "
                + "of configuring and connecting all of Netty’s components to bring $$__ your learned about threading models in ge"
                + "neral and Netty’s threading model in particular, whose performance $$__ and consistency advantages we discuss"
                + "ed in detail In this chapter you general, we recommend Java  $$__Concurrency in Practice by Brian Goetz. Hi"
                + "s book will give We’ve reached an exciting point—in the next $$__ chapter we’ll discuss bootstrapping, the"
                + " process of configuring and connecting all of Netty’s components $$__ to bring your learned about threading "
                + "models in general and Netty’s threading model in particular, $$__ whose performance and consistency advantag"
                + "es we discussed in detailIn this chapter you general, $$__ we recommend Java Concurrency in Practice by Bri"
                + "an Goetz. His book will give We’ve reached an exciting $$__ point—in the next chapter;the counter is: 1 2222"
                + "sdsa ddasd asdsadas dsadasdas" + System.getProperty("line.separator")).getBytes();
    }
    
    
    @Override
    public void channelActive(ChannelHandlerContext ctx) throws Exception {
        ByteBuf message = null;
//        for (int i = 0; i < 100; i++) {
//            message = Unpooled.buffer(req.length);
//            message.writeBytes(req);
//            ctx.writeAndFlush(message);
//        }
        message = Unpooled.buffer(req.length);
        message.writeBytes(req);
        ctx.writeAndFlush(message);
        message = Unpooled.buffer(req.length);
        message.writeBytes(req);
        ctx.writeAndFlush(message);
    }

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

}
我們在req的字串中增加了“$$__”這樣的切割符，然後再Server中照例增加一個DelimiterBasedFrameDecoder，來切割字串： 
ServerBootstrap sbs = new ServerBootstrap().group(bossGroup,workerGroup).channel(NioServerSocketChannel.class).localAddress(new InetSocketAddress(port))
                    .childHandler(new ChannelInitializer<SocketChannel>() {
                        
                        protected void initChannel(SocketChannel ch) throws Exception {
                            ch.pipeline().addLast(new DelimiterBasedFrameDecoder(1024,Unpooled.copiedBuffer("$$__".getBytes())));
                            ch.pipeline().addLast(new StringDecoder());
                            ch.pipeline().addLast(new BaseServerHandler());
                        };
                        
                    }).option(ChannelOption.SO_BACKLOG, 128)   
                    .childOption(ChannelOption.SO_KEEPALIVE, true);
我們在initChannel中第一個inbound中增加了DelimiterBasedFrameDecoder，且規定切割符就是“$$__”，這樣就能正常切割了，我們看看執行效果：


可以看到被分了20次讀取，我們可以這樣理解，客戶端傳送了2次req位元組，每個req中有10個“$$__”，這樣就是第11次切割的時候其實發送了粘包，第一個req中末尾部分和第二次的頭部粘在了一起，作為第11部分的內容

而最後一部分的內容因為沒有"$$__"切割，所以沒有列印在控制檯上~

其實這類的Handler還是相對比較簡單的，真實的生產環境這些decoder只是作為比較基本的切分類，但是這些decoder還是很好用的~

希望講的對您有所幫助~END~

相關推薦

一起學Netty（七）之 TCP粘包拆包基本解決方案

上個小節我們淺析了在Netty的使用的時候TCP的粘包和拆包的現象，Netty對此問題提供了相對比較豐富的解決方案 Netty提供了幾個常用的解碼器，幫助我們解決這些問題，其實上述的粘包和拆包的問題，歸根結底的解決方案就是傳送端給遠端端一個標記，告訴遠端端，每個資訊的結束

一起學Netty（六）之 TCP粘包拆包場景

TCP程式設計底層都有粘包和拆包機制，因為我們在C/S這種傳輸模型下，以TCP協議傳輸的時候，在網路中的byte其實就像是河水，TCP就像一個搬運工,將這流水從一端轉送到另一端，這時又分兩種情況： 1）如果客戶端的每次製造的水比較多，也就是我們常說的客戶端給的包比較大，TC

一起學Netty（十）之 Netty使用Google的ProtoBuf

protobuf是由Google開發的一套對資料結構進行序列化的方法，可用做通訊協議，資料儲存格式，等等。其特點是不限語言、不限平臺、擴充套件性強 Netty也提供了對Protobuf的天然支援，我們今天就寫一個簡單的示例，簡單地瞭解一下Netty對Google的prot

一起學Netty（三）之 SimpleChannelInboundHandler

 其實Netty的知識點還是很零碎的，比如這個SimpleChannelInboundHandler這個類，在《Netty in Action》該書中的原版的Hello world的demo的客戶端就是使用的SimpleChannelInboundHandler來作為處理

一起學Netty（二）之 Hello Netty的原型圖解

上一個小節，寫的一個入門的Hello Netty的案例，它的模型其實很簡單，我們畫個簡單的圖理解一下 package com.lyncc.netty.concept; /** * * @author Bazingalyncc * 描述： * 時間 2016年

一起學Netty（四）之 ChannelHandler,ChannelHandlerContext,ChannelPipeline

本小節一起學習一下ChannelHandler,ChannelHandlerContext,ChannelPipeline這三個Netty常用的元件，不探究它們的底層原始碼，我們就簡單的分析一下用法 首先先分析一下ChannelHandler，ChannelHandler

一起學Netty（五）之 初識ByteBuf和ByteBuf的常用API

  網路傳輸的載體是byte，這是任何框架誰也逃脫不了的一種規定，JAVA的NIO提供了ByteBuffer，用來完成這項任務，當然ByteBuffer也很好的完成了這個任務，Netty也提供了一個名字很相似的載體叫做ByteBuf，相比於ByteBuf而言，它有著更加更多

一起學Netty（八）之 淺析ByteToMessageDecoder

上一節一起學習了幾個解碼器，用於解決TCP協議網路傳輸過程中粘包和拆包的問題，用過Netty的人總會說一句話“用Netty一定要了解一下它的底層原理，這樣才敢用”，其實很有感悟，Netty in action 這本書中也有一個章節分析了codec，也定義了幾個自定義的譯碼

一起學Netty（十七）netty原始碼學習之大話java NIO

沉澱了一個月安安心心地學習了家純大神的Jupiter(https://github.com/fengjiachun/Jupiter），感覺受益良多，感覺自己學習了這裡面的精華的50%,不是謙虛，而是無知，因為我不知道著裡面還有多少是我沒有理解的，也許我看懂了他的程式碼，但我

一起學Netty（十八）netty原始碼學習之netty server端原始碼初讀（上）

server端是使用了Reactor模式對nio進行了一些封裝，Reactor模式網上有很多資料，不贅述，瞭解了這個模式開始看原始碼 netty的版本是4.0.21.Final <dependency> <groupId>io.netty<

一起學Netty（十二）之 Netty心跳簡單Demo

前面簡單地瞭解了一下IdleStateHandler，我們現在寫一個簡單的心跳demo： 1）伺服器端每隔5秒檢測伺服器端的讀超時，如果5秒沒有接受到客戶端的寫請求，也就說伺服器端5秒沒有收到讀事件，則視為一次超時 2）如果超時二次則說明連線處於不活躍的狀態，關閉Serve

一起學Netty（十四）之 Netty生產級的心跳和重連機制

sigh，寫這篇部落格的時候老臉還是紅了一下，心裡還是有些唏噓的，應該算是剽竊吧，每個人的程式碼功力的確是有差距的，好在文章的標題是“一起學”，而不是開濤大神的“跟我學”系列的文章，我們還是多花點時間學習吧，感嘆無用~ 最近工作比較忙，但閒暇之餘還是看了阿里的馮家春（fe

軟件測試基本方法（七）之驗收測試

用戶界面 基本 設計 意見 改錯 用戶需求 target 行業 alt 驗收測試是在功能測試和系統測試之後進行的，所以驗收測試的前提條件是系統或軟件產品已通過了內部測試。然後和用戶一起驗收軟件，在真實環境下執行軟件，看是否存在與用戶需求不一致的問題或違背產品規

數據庫（七）之連接

font eat 模式 pwd color 聯合 空值 sele ont select A.班級名, A.班級人數, B.姓名, B.聯系方式 from 班級信息 A, 輔導員信息 B where A.輔導員 = B.輔導員編號 for xml raw 基本連接 　

C++標準庫（七）之iterator

控制 ins opera access 指向 begin 任務 multiset fse iterator iterator模式：提供一種方法，使之能依次訪問容器內的各個元素，而又不暴露該聚合物內部的表述方式。 STL的中心思想是將算法與數據結構分離，彼此獨立設計，最後在用

PHP常見概念混淆（七）之self、static、parent的區別

sta parent tst 執行 pub call 例子 turn function 前言 首先，這個 static 符號跟 static（靜態）關鍵字不是一個東西。這三個符號在PHP對象中共有兩種用法: 在類內部，可以使用 new self、 new static、

Python基礎（七）之Dict字典

全部測試程式碼 ##dict dictionnary 字典，相當於java中的map，一鍵值對的方式儲存，查詢速度快 #定義一個字典 d={'tom':95,'bob':88,'nacy':66} tomsore=d['tom'] print('time 的成績--',tom

小白帶你認識netty（三）之NioEventLoop的執行緒（或者reactor執行緒）啟動（三）

在上一章中，我們看了處理IO事件的過程，今天，我們瞅瞅處理非同步任務佇列。 3、處理非同步任務佇列 在執行完processSelectedKeys方法後，netty會繼續執行runAllTasks方法，在觀摩這個方法之前，我們瞭解下netty的task。 在初始化NioEventLoop的時候，會例

Java框架（七）之Mybatis（簡介、mybatis開發dao的方式）

一、Mybatis簡介 1.定義 MyBatis 是支援普通 SQL 查詢,儲存過程和高階對映的優秀持久層(dao)框架。MyBatis 消除 了幾乎所有的 JDBC程式碼和 引數的手工設定 以及對 結果集的檢索。MyBatis 可以使用簡單的 XML 或註解

前端（七）之動畫與陰影

動畫及陰影 一.拼接網頁 將區域整體劃分起名 => 對其他區域佈局不產生影響 提出公共css => reset操作 當有區域傳送顯示重疊(脫離文件流導致的), 需要通過z-index調整層級 一定需要最外層,且最外層做自身佈局時,不要做過多佈局操作 二.過渡 transition屬性 t