2. 程式人生 > >【Netty入門】解決TCP粘包/分包的例項

【Netty入門】解決TCP粘包/分包的例項

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

回顧TCP粘包/分包問題的解決方法

1.訊息定長

2.在包尾都增加特殊字元進行分割

3.將訊息分為訊息頭和訊息體

針對這三種方法，下面我會分別舉例驗證

FixedLengthFrameDecoder類

對應第一種解決方法：訊息定長

（1）例1：服務端程式碼：

public class Server4 {
    public static void main(String[] args) throws SigarException {

        //boss執行緒監聽埠，worker執行緒負責資料讀寫
        EventLoopGroup boss = new
 
 NioEventLoopGroup();
        EventLoopGroup worker = new NioEventLoopGroup();

        try{
            //輔助啟動類
            ServerBootstrap bootstrap = new ServerBootstrap();
            //設定執行緒池
            bootstrap.group(boss,worker);

            //設定socket工廠
            bootstrap.channel(NioServerSocketChannel.class);

            //設定管道工廠
 

            bootstrap.childHandler(new ChannelInitializer<SocketChannel>() {
                @Override
                protected void initChannel(SocketChannel socketChannel) throws Exception {
                    //獲取管道
                    ChannelPipeline pipeline = socketChannel.pipeline();
                    //定長解碼類
 

                    pipeline.addLast(new FixedLengthFrameDecoder(19));
                    //字串解碼類
                    pipeline.addLast(new StringDecoder());
                    //處理類
                    pipeline.addLast(new ServerHandler4());
                }
            });

            //繫結埠
            ChannelFuture future = bootstrap.bind(8866).sync();
            System.out.println("server start ...... ");

            //等待服務端監聽埠關閉
            future.channel().closeFuture().sync();

        } catch (InterruptedException e) {
            e.printStackTrace();
        }finally {
            //優雅退出，釋放執行緒池資源
            boss.shutdownGracefully();
            worker.shutdownGracefully();
        }
    }

}

class ServerHandler4 extends SimpleChannelInboundHandler <String>{

    //用於記錄次數
    private int count = 0;
    //讀取客戶端傳送的資料
    @Override
    protected void channelRead0(ChannelHandlerContext ctx, String msg) throws Exception {
        System.out.println("RESPONSE--------"+msg+";"+"   @ "+ ++count);

    }

    //新客戶端接入
    @Override
    public void channelActive(ChannelHandlerContext ctx) throws Exception {
        System.out.println("channelActive");
    }

    //客戶端斷開
    @Override
    public void channelInactive(ChannelHandlerContext ctx) throws Exception {
        System.out.println("channelInactive");
    }

    //異常
    @Override
    public void exceptionCaught(ChannelHandlerContext ctx, Throwable cause) throws Exception {
        //關閉通道
        ctx.channel().close();
        //列印異常
        cause.printStackTrace();
    }
}

（2）例1：客戶端程式碼：

public class Client4 {

    public static void main(String[] args) {

        //worker負責讀寫資料
        EventLoopGroup worker = new NioEventLoopGroup();

        try {
            //輔助啟動類
            Bootstrap bootstrap = new Bootstrap();

            //設定執行緒池
            bootstrap.group(worker);

            //設定socket工廠
            bootstrap.channel(NioSocketChannel.class);

            //設定管道
            bootstrap.handler(new ChannelInitializer<SocketChannel>() {
                @Override
                protected void initChannel(SocketChannel socketChannel) throws Exception {
                    //獲取管道
                    ChannelPipeline pipeline = socketChannel.pipeline();
                    //定長解碼類
                    pipeline.addLast(new FixedLengthFrameDecoder(19));
                    //字串編碼類
                    pipeline.addLast(new StringEncoder());
                    //處理類
                    pipeline.addLast(new ClientHandler4());
                }
            });

            //發起非同步連線操作
            ChannelFuture futrue = bootstrap.connect(new InetSocketAddress("127.0.0.1",8866)).sync();

            //等待客戶端鏈路關閉
            futrue.channel().closeFuture().sync();
        } catch (InterruptedException e) {
            e.printStackTrace();
        } finally {
            //優雅的退出，釋放NIO執行緒組
            worker.shutdownGracefully();
        }
    }

}

class ClientHandler4 extends SimpleChannelInboundHandler<String> {

    //接受服務端發來的訊息
    @Override
    protected void channelRead0(ChannelHandlerContext ctx, String msg) throws Exception {
        System.out.println("server response ： "+msg);
    }

    //與伺服器建立連線
    @Override
    public void channelActive(ChannelHandlerContext ctx) throws Exception {
        //給伺服器發訊息
        String s = System.getProperty("line.separator");
        //傳送50次訊息
        for (int i = 0; i < 50; i++) {
            ctx.channel().writeAndFlush("  I am client    "+s);
        }
    }

    //與伺服器斷開連線
    @Override
    public void channelInactive(ChannelHandlerContext ctx) throws Exception {
        System.out.println("channelInactive");
    }

    //異常
    @Override
    public void exceptionCaught(ChannelHandlerContext ctx, Throwable cause) throws Exception {
        //關閉管道
        ctx.channel().close();
        //列印異常資訊
        cause.printStackTrace();
    }

}

例1服務端執行結果：

這裡寫圖片描述

…………………….此處省略多行………………….
這裡寫圖片描述

分析：從執行結果可以看出，符合我們的預期，並沒有TCP粘包問題，這是因為使用的定長解碼器的原因，我在此解釋一下例1client/server程式碼中新增加了幾個“陌生”的類，若之後再次出現，則不作解釋！

  • FixedLengthFrameDecoder類：用於固定長度訊息的粘包分包處理，可以攜帶引數，我在程式碼中指定的引數為19，因為我要傳送的字元長度為19。
  • StringDecoder類 ：用於字串的解碼。
  • StringEncoder類 ：用於字串的編碼。

LineBasedFrameDecoder類

對應第二種解決方法：在包尾都增加特殊字元（行分隔符）進行分割

（1）例2：服務端程式碼：

public class Server4 {
    public static void main(String[] args) throws SigarException {

        //boss執行緒監聽埠，worker執行緒負責資料讀寫
        EventLoopGroup boss = new NioEventLoopGroup();
        EventLoopGroup worker = new NioEventLoopGroup();

        try{
            //輔助啟動類
            ServerBootstrap bootstrap = new ServerBootstrap();
            //設定執行緒池
            bootstrap.group(boss,worker);

            //設定socket工廠
            bootstrap.channel(NioServerSocketChannel.class);

            //設定管道工廠
            bootstrap.childHandler(new ChannelInitializer<SocketChannel>() {
                @Override
                protected void initChannel(SocketChannel socketChannel) throws Exception {
                    //獲取管道
                    ChannelPipeline pipeline = socketChannel.pipeline();
                    //行分隔符解碼類
                    pipeline.addLast(new LineBasedFrameDecoder(1024));
                    //字串解碼類
                    pipeline.addLast(new StringDecoder());
                    //處理類
                    pipeline.addLast(new ServerHandler4());
                }
            });

            //繫結埠
            ChannelFuture future = bootstrap.bind(8866).sync();
            System.out.println("server start ...... ");

            //等待服務端監聽埠關閉
            future.channel().closeFuture().sync();

        } catch (InterruptedException e) {
            e.printStackTrace();
        }finally {
            //優雅退出，釋放執行緒池資源
            boss.shutdownGracefully();
            worker.shutdownGracefully();
        }
    }

}

class ServerHandler4 extends SimpleChannelInboundHandler <String>{

    //用於記錄次數
    private int count = 0;
    //讀取客戶端傳送的資料
    @Override
    protected void channelRead0(ChannelHandlerContext ctx, String msg) throws Exception {
        System.out.println("RESPONSE--------"+msg+";"+"   @ "+ ++count);

    }

    //新客戶端接入
    @Override
    public void channelActive(ChannelHandlerContext ctx) throws Exception {
        System.out.println("channelActive");
    }

    //客戶端斷開
    @Override
    public void channelInactive(ChannelHandlerContext ctx) throws Exception {
        System.out.println("channelInactive");
    }

    //異常
    @Override
    public void exceptionCaught(ChannelHandlerContext ctx, Throwable cause) throws Exception {
        //關閉通道
        ctx.channel().close();
        //列印異常
        cause.printStackTrace();
    }
}

（2）例2：客戶端程式碼：

public class Client4 {

    public static void main(String[] args) {

        //worker負責讀寫資料
        EventLoopGroup worker = new NioEventLoopGroup();

        try {
            //輔助啟動類
            Bootstrap bootstrap = new Bootstrap();

            //設定執行緒池
            bootstrap.group(worker);

            //設定socket工廠
            bootstrap.channel(NioSocketChannel.class);

            //設定管道
            bootstrap.handler(new ChannelInitializer<SocketChannel>() {
                @Override
                protected void initChannel(SocketChannel socketChannel) throws Exception {
                    //獲取管道
                    ChannelPipeline pipeline = socketChannel.pipeline();
                    //行分隔符解碼類
                    pipeline.addLast(new LineBasedFrameDecoder(1024));
                    //字串編碼類
                    pipeline.addLast(new StringEncoder());
                    //處理類
                    pipeline.addLast(new ClientHandler4());
                }
            });

            //發起非同步連線操作
            ChannelFuture futrue = bootstrap.connect(new InetSocketAddress("127.0.0.1",8866)).sync();

            //等待客戶端鏈路關閉
            futrue.channel().closeFuture().sync();
        } catch (InterruptedException e) {
            e.printStackTrace();
        } finally {
            //優雅的退出，釋放NIO執行緒組
            worker.shutdownGracefully();
        }
    }

}

class ClientHandler4 extends SimpleChannelInboundHandler<String> {

    //接受服務端發來的訊息
    @Override
    protected void channelRead0(ChannelHandlerContext ctx, String msg) throws Exception {
        System.out.println("server response ： "+msg);
    }

    //與伺服器建立連線
    @Override
    public void channelActive(ChannelHandlerContext ctx) throws Exception {
        //給伺服器發訊息
        String s = System.getProperty("line.separator");
        //傳送50次訊息
        for (int i = 0; i < 50; i++) {
            ctx.channel().writeAndFlush("  I am client    "+s);
        }
    }

    //與伺服器斷開連線
    @Override
    public void channelInactive(ChannelHandlerContext ctx) throws Exception {
        System.out.println("channelInactive");
    }

    //異常
    @Override
    public void exceptionCaught(ChannelHandlerContext ctx, Throwable cause) throws Exception {
        //關閉管道
        ctx.channel().close();
        //列印異常資訊
        cause.printStackTrace();
    }

}

例2服務端執行結果：

這裡寫圖片描述

…………………….此處省略多行………………….
這裡寫圖片描述

分析：從執行結果可以看出沒有TCP粘包問題了，細心的你或許已經發現程式碼中新出現了一個LineBasedFrameDecoder類，它可以攜帶引數，我指定的引數為1024，含義為在每1024個位元組中尋找換行符，若有，就傳送訊息，否則繼續尋找。

DelimiterBasedFrameDecoder類

對應第二種解決方法：在包尾都增加特殊字元（#）進行分割

例3：服務端程式碼，和例2服務端程式碼類似，由於篇幅有限，我就僅僅指出它們不一樣的地方了！

將例2服務端 第23行 和第24行 程式碼修改為

//自定義分隔符解碼類
pipeline.addLast(newDelimiterBasedFrameDecoder(1024,Unpooled.copiedBuffer("#".getBytes())));

例3：客戶端程式碼：（和例2客戶端程式碼的不同之處）

將例2客戶端 第24行 和第25行 程式碼修改為

//自定義分隔符解碼類
pipeline.addLast(newDelimiterBasedFrameDecoder(1024,Unpooled.copiedBuffer("#".getBytes())));

再將例2客戶端 第63行 程式碼修改為

ctx.channel().writeAndFlush("  I am  client    "+"#");

例3服務端執行結果：

這裡寫圖片描述

…………………….此處省略多行………………….
這裡寫圖片描述

分析：從執行結果可以看出TCP粘包問題解決了！程式碼中新出現了一個DelimiterBasedFrameDecoder類，它可以攜帶引數，我指定的引數為(1024,Unpooled.copiedBuffer(“#”.getBytes())))，含義為在每1024個位元組中尋找#，若有，就傳送訊息，否則繼續尋找。

MyRequestDecoder自定義類

對應第三種方法：將訊息分為訊息頭和訊息體

對於訊息頭和訊息體，有三種情況分別如下：

  • 有頭部的拆包與粘包：

    lengthFieldOffset = 2 長度欄位偏移量 ( = 外部頭部Header 1的長度)
    lengthFieldLength = 3 長度欄位佔用位元組數
    lengthAdjustment = 0
    initialBytesToStrip = 0

這裡寫圖片描述

  • 長度欄位在前且有頭部的拆包與粘包：

    lengthFieldOffset = 0 長度欄位偏移量
    lengthFieldLength = 3 長度欄位佔用位元組數
    lengthAdjustment = 2 ( Header 1 的長度)
    initialBytesToStrip = 0

這裡寫圖片描述

  • 多擴充套件頭部的拆包與粘包：
    lengthFieldOffset = 1 長度欄位偏移量(=頭HDR1的長度)
    lengthFieldLength = 2 長度欄位佔用位元組數
    lengthAdjustment = 1 調整長度(= 頭HDR2的長度)
    initialBytesToStrip = 3 排除的偏移量(= the length of HDR1 + LEN)

這裡寫圖片描述

舉一個簡單的例子

例4：

import netty.EnDecode.Request;

/**
 * 請求解碼器
 * <pre>
 * 資料包格式
 * +——----——+——-----——+——----——+——----——+——-----——+
 * | 包頭   | 模組號    | 命令號 |  長度   |   資料   |
 * +——----——+——-----——+——----——+——----——+——-----——+
 * </pre>
 * 包頭4位元組
 * 模組號2位元組short
 * 命令號2位元組short
 * 長度4位元組(描述資料部分位元組長度)
 */


public class MyRequestDecoder extends FrameDecoder{

    //資料包基本長度
    public static final int BASE_LENTH = 4 + 2 + 2 + 4;

    @Override
    protected Object decode(ChannelHandlerContext arg0, Channel arg1, ChannelBuffer buffer) throws Exception {

        //可讀長度必須大於基本長度
        if(buffer.readableBytes() >= BASE_LENTH){
            //防止socket位元組流攻擊
            if(buffer.readableBytes() > 2048){
                buffer.skipBytes(buffer.readableBytes());
            }

            //記錄包頭開始的index
            int beginReader;

            while(true){
                beginReader = buffer.readerIndex();
                buffer.markReaderIndex();
                if(buffer.readInt() == -32523523){
                    break;
                }

                //未讀到包頭，略過一個位元組
                buffer.resetReaderIndex();
                buffer.readByte();

                //長度又變得不滿足
                if(buffer.readableBytes() < BASE_LENTH){
                    return null;
                }
            }

            //模組號
            short module = buffer.readShort();
            //命令號
            short cmd = buffer.readShort();
            //長度
            int length = buffer.readInt();

            //判斷請求資料包資料是否到齊
            if(buffer.readableBytes() < length){
                //還原讀指標
                buffer.readerIndex(beginReader);
                return null;
            }

            //讀取data資料
            byte[] data = new byte[length];
            buffer.readBytes(data);

            Request request = new Request();
            request.setModule(module);
            request.setCmd(cmd);
            request.setData(data);

            //繼續往下傳遞 
            return request;

        }
        //資料包不完整，需要等待後面的包來
        return null;
    }

}



本人才疏學淺，如有錯誤，請指出
謝謝！

相關推薦

【Netty入門】解決TCP粘包/分包的例項

回顧TCP粘包/分包問題的解決方法 1.訊息定長 2.在包尾都增加特殊字元進行分割 3.將訊息分為訊息頭和訊息體 針對這三種方法，下面我會分別舉例驗證 FixedLengthFrameDecoder類 對應第一種解決方法：訊息定長 （1）例1：

python全棧開發基礎【補充】解決tcp粘包

技術 服務端 消息 log 完成後 open unpack div pytho 一、什麽是粘包 須知：只有TCP有粘包現象，UDP永遠不會粘包 粘包不一定會發生 如果發生了：1.可能是在客戶端已經粘了 　　　　　　2.客戶端沒有粘，可能是在服務端粘了 首先需要掌握一個soc

【轉】Netty之解決TCP粘包拆包(自定義協議)

https://www.cnblogs.com/sidesky/p/6913109.html 1、什麼是粘包/拆包        一般所謂的TCP粘包是在一次接收資料不能完全地體現一個完整的訊息資料。TCP通訊為何存在粘包呢？主要原因是TCP是以流的方

Netty中LineBasedFrameDecoder解碼器使用與分析：解決TCP粘包問題

ring public xpl cep ctx new 綁定端口 註意 相關 [toc] Netty中LineBasedFrameDecoder解碼器使用與分析：解決TCP粘包問題 上一篇文章《Netty中TCP粘包問題代碼示例與分析》演示了使用了時間服務器的例子演示了T

結合RPC框架通訊談 netty如何解決TCP粘包問題

0.起因 因為自己造一個RPC框架的輪子時，需要解決TCP的粘包問題，特此記錄，希望方便他人。這是我寫的RPC框架的 GitHub地址 github.com/yangzhenkun… 歡迎star，fork。已經寫了多篇文章對這個框架的原理進行說明。對原理有興趣的歡迎交流。 1.什麼是粘包 1.1 什麼

Netty學習之分隔符解決TCP粘包

package com.phei.netty.s20160424; import io.netty.bootstrap.ServerBootstrap; import io.netty.buffer.ByteBuf; import io.netty.buffer.Unpooled; import io.ne

【TCP協議】(3)---TCP粘包黏包

發出 ati borde 能夠 技術 承載 src right 8bit 【TCP協議】(3)---TCP粘包黏包 有關TCP協議之前寫過兩篇博客: 1、【TCP協議】（1）---TCP協議詳解 2、【TCP協議】(2)---TCP三次握手和四

Netty之解決TCP粘包拆包(設定訊息邊界)

1、什麼是粘包/拆包        一般所謂的TCP粘包是在一次接收資料不能完全地體現一個完整的訊息資料。TCP通訊為何存在粘包呢？主要原因是TCP是以流的方式來處理資料，再加上網路上MTU的往往小於在應用處理的訊息資料，所以就會引發一次接收的資料無法滿足訊息的需要，

Netty之解決TCP粘包拆包(自定義協議)

1、什麼是粘包/拆包        一般所謂的TCP粘包是在一次接收資料不能完全地體現一個完整的訊息資料。TCP通訊為何存在粘包呢？主要原因是TCP是以流的方式來處理資料，再加上網路上MTU的往往小於在應用處理的訊息資料，所以就會引發一次接收的資料無法滿足訊息的需要，導

python套接字解決tcp粘包問題

python套接字解決tcp粘包問題 目錄 什麼是粘包演示粘包現象 解決粘包 實際應用       什麼是粘包 首先只有tcp有粘包現象，udp沒有粘包     socket收發訊息的原理    

【Netty入門】基於Netty的Server / Client

回顧NIO 我在之前介紹了NIO的server與client，雖然說程式設計相對於ＢＩＯ比較複雜，但是效能高啊，而且Netty的server/client也是基於NIO的。所以，在介紹Netty的server/client 之前，先回顧一下ＮＩＯ 的serve

【HTML5入門】解決eclipse中tomcat8080埠被佔用問題

       配置tomcat後eclipse可能會報8080端口占用問題，tomcat預設8080埠，所以不管報哪些端口占用其實解決掉8080端口占用即可。比如會遇到下面的報錯情況： Several

五、Netty5解決TCP粘包問題

我們在前面的Demo中並沒有考慮到讀半包問題，這在功能測試中往往沒有問題，但是一旦壓力上來，或者傳送大報文之後，就會存在粘包和拆包問題，如果程式碼沒有考慮，往往就會出現解碼錯位或者錯誤，導致程式不能正常執行。下面使用netty的半包解碼器來解決TCP粘包和拆包問

TCP粘包/拆包--利用DelimiterBasedFrameDecoder解決TCP粘包問題

前面我們介紹了利用LineBasedFrameDecoder解決TCP的粘包/拆包的問題， 現在我們繼續介紹Netty的另外一種解碼器--DelemiterBasedFrameDecoder。 1. DelimiterBasedFrameDecoder服務端開發 EchoS

【HTML5入門】解決The superclass javax.servlet.http.HttpServlet was not found on the Java Build Path問題

問題：編譯其他人的程式碼或者教材書程式碼的時候經常會出現The superclass javax.servlet.http.HttpServlet was not found on the Java

【Netty4.x】Netty TCP粘包/拆包問題的解決辦法(二)

一、什麼是TCP粘包/拆包  如圖所示，假如客戶端分別傳送兩個資料包D1和D2給服務端，由於服務端一次讀取到的位元組數是不確定的，故可能存在以下4中情況：第一種情況:Server端分別讀取到D1和D2，沒有產生粘包和拆包的情況。第二種情況:Server端一次接收到兩個資料包，

【轉載】TCP粘包問題分析和解決（全）

刪除 而且 實例 報文 底層 nagle 存在 ngxin 想想 TCP通信粘包問題分析和解決（全） 在socket網絡程序中，TCP和UDP分別是面向連接和非面向連接的。因此TCP的socket編程，收發兩端（客戶端和服務器端）都要有成對的socket，因此，發送端為了將

【轉】TCP粘包問題解決方法之\n\r

該方案，每次讀取時當讀到‘\n’換行符時，讀取該行 伺服器端： [cpp]  view plain  copy #include<uni

Netty中使用MessagePack時的TCP粘包問題與解決方案

private pri delay read complete bcd 資源 tina object [toc] Netty中使用MessagePack時的TCP粘包問題與解決方案 通過下面的實例代碼來演示在Netty中使用MessagPack時會出現的TCP粘包問題，為

netty權威指南學習筆記四——TCP粘包/拆包之粘包問題解決

方法 pan 對象 protect row 學習 ddl .get font 　　發生了粘包，我們需要將其清晰的進行拆包處理，這裏采用LineBasedFrameDecoder來解決 LineBasedFrameDecoder的工作原理是它依次遍歷ByteBuf中的可讀字節