3.Netty的粘包、拆包（二）

阿新 • • 發佈：2018-10-13

length coder 解碼器 generate trac main med con ++

Netty提供的TCP數據拆包、粘包解決方案

1.前言

關於TCP的數據拆包、粘包的介紹，我在上一篇文章裏面已經有過介紹。

想要了解一下的，請點擊這裏 Chick Here！

今天我們要講解的是Netty提供的兩種解決方案：

DelimiterBasedFrameDecoder
FixedLengthFrameDecoder

2.關於Decoder

先觀察下兩段代碼的不同

（1）使用StringDecoder之前

@Override
 public void channelRead(ChannelHandlerContext ctx, Object msg) throws Exception {


     try {

         ByteBuf in = (ByteBuf) msg;
         String str = in.toString(CharsetUtil.UTF_8);
         System.out.println("Client:"+str);

     } finally {
         ReferenceCountUtil.release(msg);
     }
 }

（2）使用StringDecoder之後

@Override
 public void channelRead(ChannelHandlerContext ctx, Object msg) throws Exception {


     try {
         String str = (String) msg;
         System.out.println("Client:"+str);

     } finally {
         ReferenceCountUtil.release(msg);
     }
 }

關於Decoder

decoder：n. 解碼器

在我看來，Netty數據的解析方式大概為：

發送過程：Buffer------>數據報------>比特流

接受過程：Buffer<------數據報<------比特流

所以我們接受到的msg是一個ButeBuf

使用了Decoder（這裏使用StringDecoder舉例）之後：

發送過程：Buffer------>數據報------>比特流

接受過程：String<------Buffer<------數據報<------比特流

相當於ByteBuf按照StringDecoder的解碼規則，把msg翻譯成為了一個字符串。

如何使用Decoder

（1）實際代碼演示：

package com.xm.netty.demo02;

import java.net.InetSocketAddress;

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

public class Server {

 private final int port;

 public Server(int port) {
     this.port = port;
 }



 public static void main(String[] args) {

     int port = 8989;
     try {
         new Server(port).start();
     } catch (InterruptedException e) {
         // TODO Auto-generated catch block
         e.printStackTrace();
     }

 }



 private void start() throws InterruptedException {
     EventLoopGroup g1 = new NioEventLoopGroup();
     EventLoopGroup g2 = new NioEventLoopGroup();
     try {
         ServerBootstrap bootstrap = new ServerBootstrap();
          bootstrap
                 .group(g1,g2)
                 .channel(NioServerSocketChannel.class)
                 .localAddress(new InetSocketAddress( port))
                 .childHandler(new ChannelInitializer() {
                     @Override
                     protected void initChannel(Channel ch) throws Exception {
                         ch.pipeline().addLast(new StringDecoder());
                         ch.pipeline().addLast(new ServerHandler());
                     }
                 });
          ChannelFuture future = bootstrap.bind().sync();
          future.channel().closeFuture().sync();
     } finally {
         g1.shutdownGracefully().sync();
         g2.shutdownGracefully().sync();
     }
 }

}

代碼改動：

ch.pipeline().addLast(new StringDecoder());
?

? ch.pipeline().addLast(new ServerHandler());

（2）多個Decoder的使用順序：

從前往後，依次解碼

假設我們有個通過字符串變化為時間的TimeDecoder：

ch.pipeline().addLast(new StringDecoder());

ch.pipeline().addLast(new TimeDecoder());

? ch.pipeline().addLast(new ServerHandler());

解析規則為：

技術分享圖片

3.DelimiterBasedFrameDecoder

關於DelimiterBasedFrameDecoder

其實很簡單，就是在一個緩沖區的末尾添加一個結束字符。

在規定了最大長度的緩沖區裏，遇到一個特殊字符，就截取一次。

原理類似於String的split（）方法。

代碼實現

（1）服務端Server

package com.xm.netty.demo03;

import java.net.InetSocketAddress;

import io.netty.bootstrap.ServerBootstrap;
import io.netty.buffer.ByteBuf;
import io.netty.buffer.Unpooled;
import io.netty.channel.Channel;
import io.netty.channel.ChannelFuture;
import io.netty.channel.ChannelInitializer;
import io.netty.channel.EventLoopGroup;
import io.netty.channel.nio.NioEventLoopGroup;
import io.netty.channel.socket.nio.NioServerSocketChannel;
import io.netty.handler.codec.DelimiterBasedFrameDecoder;
import io.netty.handler.codec.string.StringDecoder;

public class Server {

 private final int port;

 public Server(int port) {
     this.port = port;
 }



 public static void main(String[] args) {

     int port = 8989;
     try {
         new Server(port).start();
     } catch (InterruptedException e) {
         // TODO Auto-generated catch block
         e.printStackTrace();
     }

 }



 private void start() throws InterruptedException {
     EventLoopGroup g1 = new NioEventLoopGroup();
     EventLoopGroup g2 = new NioEventLoopGroup();
     try {
         ServerBootstrap bootstrap = new ServerBootstrap();
          bootstrap
                 .group(g1,g2)
                 .channel(NioServerSocketChannel.class)
                 .localAddress(new InetSocketAddress( port))
                 .childHandler(new ChannelInitializer() {
                     @Override
                     protected void initChannel(Channel ch) throws Exception {
                         ByteBuf buf = Unpooled.copiedBuffer("$".getBytes());
                         ch.pipeline().addLast(new DelimiterBasedFrameDecoder(1024,buf));
                         ch.pipeline().addLast(new StringDecoder());
                         ch.pipeline().addLast(new ServerHandler());
                     }
                 });
          ChannelFuture future = bootstrap.bind().sync();
          future.channel().closeFuture().sync();
     } finally {
         g1.shutdownGracefully().sync();
         g2.shutdownGracefully().sync();
     }
 }

}

（2）服務端ServerHandler

package com.xm.netty.demo03;

import java.time.LocalDateTime;
import java.time.format.DateTimeFormatter;

import io.netty.buffer.ByteBuf;
import io.netty.buffer.Unpooled;
import io.netty.channel.ChannelHandlerAdapter;
import io.netty.channel.ChannelHandlerContext;
import io.netty.util.CharsetUtil;

public class ServerHandler extends ChannelHandlerAdapter {

 @Override
 public void channelRead(ChannelHandlerContext ctx, Object msg) throws Exception {

     String str = (String) msg;
     System.out.println("Server:"+str);
     str = "服務器返回--->"+ str+"$";
     ctx.writeAndFlush(Unpooled.copiedBuffer(str.getBytes()));
 }

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

 @Override
 public void channelActive(ChannelHandlerContext ctx) throws Exception {
     System.out.println(DateTimeFormatter.ISO_LOCAL_DATE_TIME.format(LocalDateTime.now())+"一個客戶端連接上服務器！");
 }


}

（3）客戶端Client

package com.xm.netty.demo03;

import java.time.LocalDateTime;
import java.time.format.DateTimeFormatter;

import io.netty.bootstrap.Bootstrap;
import io.netty.buffer.ByteBuf;
import io.netty.buffer.Unpooled;
import io.netty.channel.ChannelFuture;
import io.netty.channel.ChannelInitializer;
import io.netty.channel.EventLoopGroup;
import io.netty.channel.nio.NioEventLoopGroup;
import io.netty.channel.socket.SocketChannel;
import io.netty.channel.socket.nio.NioSocketChannel;
import io.netty.handler.codec.DelimiterBasedFrameDecoder;
import io.netty.handler.codec.string.StringDecoder;

public class Client {

 private final int port;
 private final String host;



 public Client(int port, String host) {
     this.port = port;
     this.host = host;
 }

 public static void main(String[] args) {
     String host = "127.0.0.1";
     int port = 8989;
     try {
         new Client(port, host).start();
     } catch (InterruptedException e) {
         // TODO Auto-generated catch block
         e.printStackTrace();
     }
 }

 private void start() throws InterruptedException {

     EventLoopGroup group = new NioEventLoopGroup();
     try {
         Bootstrap bootstrap = new Bootstrap();
         bootstrap
                 .group(group)
                 .channel(NioSocketChannel.class)
                 .remoteAddress(host, port)
                 .handler(new ChannelInitializer<SocketChannel>() {

                     @Override
                     protected void initChannel(SocketChannel ch) throws Exception {
                         ByteBuf buf = Unpooled.copiedBuffer("$".getBytes());
                         ch.pipeline().addLast(new DelimiterBasedFrameDecoder(1024,buf));
                         ch.pipeline().addLast(new StringDecoder());
                         ch.pipeline().addLast(new ClientHandler());
                     }

                 });

         ChannelFuture future = bootstrap.connect().sync();

         for(int i=10;i<20;i++) {
             String str = DateTimeFormatter.ISO_LOCAL_DATE_TIME.format(LocalDateTime.now()) + "---- " +i+"<<<$";
             future.channel().write(Unpooled.copiedBuffer(str.getBytes()));
         }

         future.channel().flush();


         //future.channel().writeAndFlush(Unpooled.copiedBuffer("Hello Netty!".getBytes()));



         future.channel().closeFuture().sync();
     } finally {
         group.shutdownGracefully().sync();
     }

 }

}

（4）客戶端ClientHandler

package com.xm.netty.demo03;

import java.time.LocalDateTime;
import java.time.format.DateTimeFormatter;

import io.netty.buffer.ByteBuf;
import io.netty.buffer.Unpooled;
import io.netty.channel.ChannelHandlerAdapter;
import io.netty.channel.ChannelHandlerContext;
import io.netty.util.CharsetUtil;
import io.netty.util.ReferenceCountUtil;

public class ClientHandler extends ChannelHandlerAdapter {

 @Override
 public void channelRead(ChannelHandlerContext ctx, Object msg) throws Exception {


     try {
         String str = (String) msg;
         System.out.println("Client:"+str);

     } finally {
         ReferenceCountUtil.release(msg);
     }
 }

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

 @Override
 public void channelActive(ChannelHandlerContext ctx) throws Exception {
     System.out.println(DateTimeFormatter.ISO_LOCAL_DATE_TIME.format(LocalDateTime.now())+"已連接服務器！");
 }


}

運行結果截圖

（1）服務端運行結果：

（2）客戶端運行結果：

4.FixedLengthFrameDecoder

關於FixedLengthFrameDecoder

其實很簡單，就是對規定的發送的數據進行限制長度，

當符合這個長度的情況下，就可以解析。

假設你發送一個’123456‘，’654321‘

那麽解析的狀況為’12345‘，’66543‘

代碼實現

（1）服務端Server

package com.xm.netty.demo04;

import java.net.InetSocketAddress;

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

public class Server {

 private final int port;

 public Server(int port) {
     this.port = port;
 }



 public static void main(String[] args) {

     int port = 8989;
     try {
         new Server(port).start();
     } catch (InterruptedException e) {
         // TODO Auto-generated catch block
         e.printStackTrace();
     }

 }



 private void start() throws InterruptedException {
     EventLoopGroup g1 = new NioEventLoopGroup();
     EventLoopGroup g2 = new NioEventLoopGroup();
     try {
         ServerBootstrap bootstrap = new ServerBootstrap();
          bootstrap
                 .group(g1,g2)
                 .channel(NioServerSocketChannel.class)
                 .localAddress(new InetSocketAddress( port))
                 .childHandler(new ChannelInitializer() {
                     @Override
                     protected void initChannel(Channel ch) throws Exception {
                         ch.pipeline().addLast(new FixedLengthFrameDecoder(5));
                         ch.pipeline().addLast(new StringDecoder());
                         ch.pipeline().addLast(new ServerHandler());
                     }
                 });
          ChannelFuture future = bootstrap.bind().sync();
          future.channel().closeFuture().sync();
     } finally {
         g1.shutdownGracefully().sync();
         g2.shutdownGracefully().sync();
     }
 }

}

（2）服務端ServerHandler

package com.xm.netty.demo04;

import java.time.LocalDateTime;
import java.time.format.DateTimeFormatter;

import io.netty.buffer.ByteBuf;
import io.netty.buffer.Unpooled;
import io.netty.channel.ChannelHandlerAdapter;
import io.netty.channel.ChannelHandlerContext;
import io.netty.util.CharsetUtil;

public class ServerHandler extends ChannelHandlerAdapter {

 @Override
 public void channelRead(ChannelHandlerContext ctx, Object msg) throws Exception {

     String str = (String) msg;
     System.out.println("Server:"+str);
     ctx.writeAndFlush(Unpooled.copiedBuffer(str.getBytes()));
 }

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

 @Override
 public void channelActive(ChannelHandlerContext ctx) throws Exception {
     System.out.println(DateTimeFormatter.ISO_LOCAL_DATE_TIME.format(LocalDateTime.now())+"一個客戶端連接上服務器！");
 }


}

（3）客戶端Client

package com.xm.netty.demo04;

import java.time.LocalDateTime;
import java.time.format.DateTimeFormatter;

import io.netty.bootstrap.Bootstrap;
import io.netty.buffer.Unpooled;
import io.netty.channel.ChannelFuture;
import io.netty.channel.ChannelInitializer;
import io.netty.channel.EventLoopGroup;
import io.netty.channel.nio.NioEventLoopGroup;
import io.netty.channel.socket.SocketChannel;
import io.netty.channel.socket.nio.NioSocketChannel;
import io.netty.handler.codec.FixedLengthFrameDecoder;
import io.netty.handler.codec.string.StringDecoder;

public class Client {

 private final int port;
 private final String host;



 public Client(int port, String host) {
     this.port = port;
     this.host = host;
 }

 public static void main(String[] args) {
     String host = "127.0.0.1";
     int port = 8989;
     try {
         new Client(port, host).start();
     } catch (InterruptedException e) {
         // TODO Auto-generated catch block
         e.printStackTrace();
     }
 }

 private void start() throws InterruptedException {

     EventLoopGroup group = new NioEventLoopGroup();
     try {
         Bootstrap bootstrap = new Bootstrap();
         bootstrap
                 .group(group)
                 .channel(NioSocketChannel.class)
                 .remoteAddress(host, port)
                 .handler(new ChannelInitializer<SocketChannel>() {

                     @Override
                     protected void initChannel(SocketChannel ch) throws Exception {
                         ch.pipeline().addLast(new FixedLengthFrameDecoder(5));
                         ch.pipeline().addLast(new StringDecoder());
                         ch.pipeline().addLast(new ClientHandler());
                     }

                 });

         ChannelFuture future = bootstrap.connect().sync();

         for(int i=123450;i<123460;i++) {
             String str = ""+i;
             future.channel().write(Unpooled.copiedBuffer(str.getBytes()));
         }
         future.channel().flush();

         //future.channel().writeAndFlush(Unpooled.copiedBuffer("Hello Netty!".getBytes()));



         future.channel().closeFuture().sync();
     } finally {
         group.shutdownGracefully().sync();
     }

 }

}

（4）客戶端ClientHandler

package com.xm.netty.demo04;

import java.time.LocalDateTime;
import java.time.format.DateTimeFormatter;

import io.netty.buffer.ByteBuf;
import io.netty.buffer.Unpooled;
import io.netty.channel.ChannelHandlerAdapter;
import io.netty.channel.ChannelHandlerContext;
import io.netty.util.CharsetUtil;
import io.netty.util.ReferenceCountUtil;

public class ClientHandler extends ChannelHandlerAdapter {

 @Override
 public void channelRead(ChannelHandlerContext ctx, Object msg) throws Exception {


     try {
         String str = (String) msg;
         System.out.println("Client:"+str);

     } finally {
         ReferenceCountUtil.release(msg);
     }
 }

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

 @Override
 public void channelActive(ChannelHandlerContext ctx) throws Exception {
     System.out.println(DateTimeFormatter.ISO_LOCAL_DATE_TIME.format(LocalDateTime.now())+"已連接服務器！");
 }


}

運行結果截圖

（1）服務端運行結果：

（2）客戶端運行結果：

3.Netty的粘包、拆包（二）

3、netty粘包、拆包（二）

list ride int 簡化 iter getclass null message som 上篇博客留了個尾巴“而且LineBasedFrameDecoder據說還有一種不要求攜帶結束符的解碼方式”，今天就從源碼來看看是怎麽回事。一、基本原理如果沒有netty，

3.Netty的粘包、拆包（二）

length coder 解碼器 generate trac main med con ++ Netty提供的TCP數據拆包、粘包解決方案 1.前言關於TCP的數據拆包、粘包的介紹，我在上一篇文章裏面已經有過介紹。想要了解一下的，請點擊這裏 Chick Here！今天

2.Netty的粘包、拆包（一）

Netty粘包、拆包 1.什麼是拆包、粘包（1）拆包、粘包介紹 TCP是個“流”協議，所謂流，就是沒有界限的一串資料。大家可以想想河裡的流水，是連成一片的，其間並沒有分界線。TCP底層並不瞭解上層業務資料的具體含義，它會根據TCP緩衝區的實際情況進行包的劃分，所以在業務上認為，一個完整的包可能會被TCP拆

C#.網路程式設計 Tcp基礎（二） TCP組包、粘包、拆包的原理

一、TCP粘包，拆包及解決方法轉https://blog.csdn.net/scythe666/article/details/51996268 以下是轉發的部分內容我們都知道TCP屬於傳

netty自定義簡單解碼器處理粘包、拆包

.so ack 繼承記錄 line sync ann write 工程 tcp連接的粘包、拆包發生在長連接中，先了解一下長、短連接的概念短連接：請求/響應之後，關閉已經建立的tcp連接，下次請求再建立新的連接長連接：請求/響應之後，不關閉已經建立的tcp連接，多次請求

tcp粘包、拆包

傳輸 packet ima .cn bsp log src blog 一次粘包、拆包發生原因：發生TCP粘包或拆包有很多原因，現列出常見的幾點，可能不全面，歡迎補充，1、要發送的數據大於TCP發送緩沖區剩余空間大小，將會發生拆包。2、待發送數據大於MSS（最大報文長度），

TCP粘包、拆包與通訊協議

在TCP程式設計中，通常Sever端與Client通訊時的訊息都有著固定的訊息格式，稱之為協議(protocol)，例如FTP協議、Telnet協議等，有的公司也會自己開發協議。那麼協議到底是幹什麼的呢？說白了，協議了就是定義了資料通訊的格式。主要是為了解決

粘包、拆包發生原因滑動窗口、MSS/MTU限制、Nagle算法

情況下粘包多次設置無法以太網幀 fin tps targe 【TCP協議】(3)---TCP粘包黏包有關TCP協議之前寫過兩篇博客: 1、【TCP協議】（1）---TCP協議詳解 2、【TCP協議】(2)---TCP三次握手和四

tcp和upd粘包、拆包、ip分片問題

我們都知道TCP屬於傳輸層的協議，傳輸層除了有TCP協議外還有UDP協議。那麼UDP是否會發生粘包或拆包的現象呢？答案是不會。UDP是基於報文傳送的，從UDP的幀結構可以看出，在UDP首部採用了16bit來指示UDP資料報文的長度，因此在應用層能很好的將不同的資料報文區分開，

Mina 粘包、拆包的實現-網上常見的程式碼有bug。。

mina的粘包拆包其實是蠻簡單的，只是一開始沒搞清楚原理。我們要約定資料包的格式，我這裡的是(4個位元組長度+json的string字串） 1：寫一個 ProtocolCodecFactory類，用來攔截資料包處理內容如下 public class Messag

java基礎之Integer的封包、拆包和反射

先看一段程式碼例子： public static void main(String[] args) { Integer a1 = 1; Integer b1 = 2; Integer a2 = 1000; I

Android開發————3、簡易備忘錄（二）

實驗內容 1. android 開發環境搭建，開發工具可以是eclipse+adt 或android studio。 2. 按照實驗課要求製作對應的app小程式，實現按鈕新增備忘，並且包含日期時間。 3. 編寫並提交實驗報告。實驗步驟實驗程式碼如下： <

ros+科大迅飛語音包+圖靈機器人（二）在ros上使用科大迅飛

在工作空間catkin_ws下建立一個包$ cd catkin_ws/src/$ catkin_create_pkg voice_system std_msgs rospy roscpp把科大迅飛包裡的程式碼複製到你建立的包裡,並重命名為xf_tts.cpp$ cd Soft

android之解析包時出現錯誤（二）

這次的原因不同，再記錄下public class DownloadTask { /** * @param path下載地址 * @param filePath儲存路徑 * @param progressDialog進度條 * @return * @t

【Laravel5.3 筆記整理八】Laravel檢視（二）邏輯控制、模板佈局、檔案包含

1. 邏輯控制 1） if 語句將下面的程式碼寫入 shitu1.blade.php @if($qiangge > 100) <h2>胖美女</h2> @elseif($qiangge > 80)

Android實戰——第三方服務之Bmob後端雲的增刪改查、上傳文件、獲取文件、修改密碼（二）

tid blank 生成 src 上傳圖片放置第三方 b數 net 第三方服務之Bmob後端雲的增刪改查、上傳文件、獲取文件、修改密碼（二）事先說明：這裏的一切操作都是在集成了BmobSDK之後實現的，如果對Bmob還不了解的話，請關註我第一篇Bmob文章步

三、處理機管理（二）--程序的排程與管理

程序的排程與管理程序控制塊佇列（PCB），作業系統採用連結串列的方法將這些程序的PCB連結起來生成佇列。對於單CPU系統，生成的PCB佇列如下。（1）執行佇列。任何時刻系統中最多隻有一個程序處於執行狀態。（2）就緒佇列。就緒佇列中的PCB會根據某種

Python入門教程--介紹、基本語法（二）

在上一篇文章中，我們介紹了Python的一些基本語法，現在我們繼續介紹剩下的Python基本語法。檢視上一篇文章請點選：https://www.cnblogs.com/dustman/p/9871938.html 字元運算子字串連線就像對數字進行加減一樣，兩個字串也可以通過加號 + 進行連線產生新的字串

python 程序、執行緒（二）

一、多執行緒與多程序的對比在python 程序、執行緒 (一)中簡單的說過，CPython中的GIL使得同一時刻只能有一個執行緒執行，即併發執行。並且即使是多核CPU，GIL使得同一個程序中的多個執行緒也無法對映到多個CPU上執行，這麼做最初是為了安全著想，慢慢的也成為了限制CPython效能的問題。就

python 進程、線程（二）

調整文件處理 gil 什麽代碼說過效率釋放 complete 一、多線程與多進程的對比在python 進程、線程 (一)中簡單的說過，CPython中的GIL使得同一時刻只能有一個線程運行，即並發執行。並且即使是多核CPU，GIL使得同一個進程中的多個線程也無法

3.Netty的粘包、拆包（二）

Netty提供的TCP數據拆包、粘包解決方案

1.前言

2.關於Decoder

先觀察下兩段代碼的不同

3.DelimiterBasedFrameDecoder

4.FixedLengthFrameDecoder

相關推薦