2. 程式人生 > >Netty中處理TCP粘包和拆包

Netty中處理TCP粘包和拆包

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

什麼是粘包和拆包

TCP是個”流”協議，流其實就是沒有界限的一串資料。
TCP底層中並不瞭解上層業務資料的具體含義，它會根據TCP緩衝區的實際情況進行包劃分，所以在TCP中就有可能一個完整地包會被TCP拆分成多個包，也有可能吧多個小的包封裝成一個大的資料包傳送，這就是拆包和粘包的問題。

問題例項:假設客戶端分別傳送了兩個資料包D1和D2給服務端，由於服務端一次讀取到的位元組數是不確定的，所以存在幾種情況:
1.不存在粘包和分包的時候，服務端分兩次讀取到了兩個獨立的資料包。
2.存在粘包，一次讀取了D1和D2。
3.存在拆包，第一次讀取的是完整的D1包和部分D2包，第二次讀取到了D2包的剩餘內容。
4.第一次讀取到了D1包的部分內容，第二次讀取了D1剩下的內容和D2獨立的包。

為什麼會出現呢？

1.應用程式write寫入的位元組大小大於套介面傳送緩衝區大小(出現拆包).
2,進行MSS大小的TCP分段
3.大於MTU進行分片

這裡一般來說
MSS <=MTU-40(IPV4) MSS<= MTU -60 (IPV6)

解決策略

下面的策略都可以對應於我們Netty中的某個handler解決
1.訊息定長.
2.在包尾增加回車換行符進行分割，例如FTP協議;
3將訊息分為訊息頭和訊息體，訊息頭中包含表示訊息總長度。
4.複雜的應用協議。

粘包導致的問題

我們可以設計一個類似Echo伺服器的功能，客戶端發出一百條，echo回顯肯定也是一百條。這裡有:

服務端程式碼

package time2;

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 time2.TimeServerHandler;


/**
 * Created by lz on 2016/8/9.
 */
public class TimeServer {
    public void bind(int port) throws Exception{
        //配置服務端的NIO執行緒組,一個用於接收連線，一個用於處理連線
        EventLoopGroup bossGroup = new NioEventLoopGroup();
        EventLoopGroup workerGroup = new NioEventLoopGroup();
        try{
            ServerBootstrap b = new ServerBootstrap();
            b.group(bossGroup,workerGroup)
                    .channel(NioServerSocketChannel.class)
                    .option(ChannelOption.SO_BACKLOG,1024)
                    .childHandler(new ChildChannerHanler());
            //繫結埠，同步等待
            ChannelFuture f = b.bind(port).sync();
            //等待服務端監聽埠關閉
            f.channel().closeFuture().sync();
        }finally {
            //優雅退出,釋放執行緒資源
            bossGroup.shutdownGracefully();
            workerGroup.shutdownGracefully();
        }
    }

    private class ChildChannerHanler extends ChannelInitializer<SocketChannel> {
        @Override
        protected void initChannel(SocketChannel socketChannel) throws Exception {
            socketChannel.pipeline().addLast(new TimeServerHandler());
        }
    }

    public static void main(String[] args) throws Exception {
        int port = 8080;
        new TimeServer().bind(port);
    }
}

服務端handler

package time2;

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

import java.util.Date;

/**
 * Created by lz on 2016/8/10.
 */
public class TimeServerHandler extends ChannelHandlerAdapter{
    private int counter;

    @Override
    public void channelRead(ChannelHandlerContext ctx, Object msg) throws Exception {
        ByteBuf buf = (ByteBuf) msg;
        byte[] req = new byte[buf.readableBytes()];
        buf.readBytes(req);
        String body = new String(req,"UTF-8").substring(0,req.length-System.getProperty("line.separator").length());
        System.out.println("Time Server得到了資料:" + body+";counter是:"+ ++counter);
        String currentTime = "QUERY TIME ORDER".equalsIgnoreCase(body) ? new Date().toString():"BAD ORDER";
        currentTime = currentTime + System.getProperty("line.separator");
        ByteBuf  resp = Unpooled.copiedBuffer(currentTime.getBytes());
        ctx.writeAndFlush(resp);
    }

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

    public static void main(String[] args) {
        System.out.println("1"+System.getProperty("line.separator")+"1");
    }
}

客戶端程式碼

package time2;

import io.netty.bootstrap.Bootstrap;
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.NioSocketChannel;


/**
 * Created by lz on 2016/8/9.
 */
public class TimeClient {
    public void connect(int port,String host) throws Exception{
        //配置客戶端NIO執行緒組
        EventLoopGroup group =new NioEventLoopGroup();
        try{
            Bootstrap b = new Bootstrap();
            b.group(group).channel(NioSocketChannel.class).option(ChannelOption.TCP_NODELAY,true)
            .handler(new ChannelInitializer<SocketChannel>(){

                @Override
                protected void initChannel(SocketChannel socketChannel) throws Exception {
                    socketChannel.pipeline().addLast(new TimeClientHandler());
                }
            });
            //發起非同步連線操作
            ChannelFuture f = b.connect(host,port).sync();
            f.channel().closeFuture().sync();
        }finally {
            //優雅退出，釋放NIO執行緒組
            group.shutdownGracefully();
        }
    }

    public static void main(String[] args) throws Exception {
        int port = 8080;
        new TimeClient().connect(port,"127.0.0.1");
    }
}

客戶端Handler程式碼

package time2;

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

/**
 * Created by lz on 2016/8/10.
 */
public class TimeClientHandler extends ChannelHandlerAdapter {
    private int counter;
    private byte[] req;
    public TimeClientHandler(){
        req = ("QUERY TIME ORDER" + 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);
        }
    }

    @Override
    public void channelRead(ChannelHandlerContext ctx, Object msg) throws Exception {
        ByteBuf buf = (ByteBuf) msg;
        byte[] req = new byte[buf.readableBytes()];
        buf.readBytes(req);
        String body = new String( req,"UTF-8");
        System.out.println("Now is:"+body+";the counter is :" + ++counter);
    }

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

進行測試分別執行客戶端和伺服器端，發現出現了粘包現象，客戶端的counter只加了一次，這就出現了粘包問題，在我們初學的時候可以不考慮這個問題但是當壓力上來後，傳送大報文，就會出現粘包/拆包。
我們就需要我們的半包解碼器。如下：

LineBasedFrameDecoder

這是一個一換行符為界限的解碼器，如果有換行我們就把他標記為結束位置，這樣就組成一個獨立的包。我們可以設定最大長度。如果連續讀取到最大長度後沒有發現換行符，就會丟擲異常，同時忽略掉之前讀到的異常碼流。程式碼如下：

Server端程式碼:

package time3;

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;


/**
 * Created by lz on 2016/8/10.
 */
public class TimeServer {
    public void bind(int port) throws Exception{
        //配置服務端的NIO執行緒組,一個用於接收連線，一個用於處理連線
        EventLoopGroup bossGroup = new NioEventLoopGroup();
        EventLoopGroup workerGroup = new NioEventLoopGroup();
        try{
            ServerBootstrap b = new ServerBootstrap();
            b.group(bossGroup,workerGroup)
                    .channel(NioServerSocketChannel.class)
                    .option(ChannelOption.SO_BACKLOG,1024)
                    .childHandler(new ChildChannelHandler());
            //繫結埠，同步等待
            ChannelFuture f = b.bind(port).sync();
            //等待服務端監聽埠關閉
            f.channel().closeFuture().sync();
        }finally {
            //優雅退出,釋放執行緒資源
            bossGroup.shutdownGracefully();
            workerGroup.shutdownGracefully();
        }
    }
    private class ChildChannelHandler extends ChannelInitializer<SocketChannel>{

        @Override
        protected void initChannel(SocketChannel socketChannel) throws Exception {
            System.out.println("已經繫結");
            socketChannel.pipeline().addLast(new LineBasedFrameDecoder(1024));
            socketChannel.pipeline().addLast(new StringDecoder());
            socketChannel.pipeline().addLast(new TimeServerHandler());
        }
    }

    public static void main(String[] args) throws Exception {
        int port = 8080;
        new TimeServer().bind(port);
    }
}

ServerHandler端程式碼:

package time3;

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

import java.util.Date;

/**
 * Created by lz on 2016/8/10.
 */
public class TimeServerHandler extends ChannelHandlerAdapter{
    private int counter;

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

        String body = (String) msg;
        System.out.println("Time Server得到了資料:" + body+";counter是:"+ ++counter);
        String currentTime = "QUERY TIME ORDER".equalsIgnoreCase(body) ? new Date().toString():"BAD ORDER";
        currentTime = currentTime + System.getProperty("line.separator");
        ByteBuf  resp = Unpooled.copiedBuffer(currentTime.getBytes());
        ctx.writeAndFlush(resp);
    }

    @Override
    public void exceptionCaught(ChannelHandlerContext ctx, Throwable cause) throws Exception {
        System.out.println(cause.getMessage());
        ctx.close();
    }

    public static void main(String[] args) {
        System.out.println("1"+System.getProperty("line.separator")+"1");
    }
}

Client端程式碼:

package time3;

import io.netty.bootstrap.Bootstrap;
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.NioSocketChannel;
import io.netty.handler.codec.LineBasedFrameDecoder;
import io.netty.handler.codec.string.StringDecoder;


/**
 * Created by lz on 2016/8/10.
 */
public class TimeClient {
    public void connect(int port,String host) throws Exception{
        //配置客戶端NIO執行緒組
        EventLoopGroup group =new NioEventLoopGroup();
        try{
            Bootstrap b = new Bootstrap();
            b.group(group).channel(NioSocketChannel.class).option(ChannelOption.TCP_NODELAY,true)
                    .handler(new ChannelInitializer<SocketChannel>(){

                        @Override
                        protected void initChannel(SocketChannel socketChannel) throws Exception {
                            socketChannel.pipeline().addLast(new LineBasedFrameDecoder(1024));
                            socketChannel.pipeline().addLast(new StringDecoder());
                            socketChannel.pipeline().addLast(new TimeClientHandler());
                        }
                    });
            //發起非同步連線操作
            ChannelFuture f = b.connect(host,port).sync();
            f.channel().closeFuture().sync();
        }finally {
            //優雅退出，釋放NIO執行緒組
            group.shutdownGracefully();
        }
    }

    public static void main(String[] args) throws Exception {
        int port = 8080;
        new TimeClient().connect(port,"127.0.0.1");
    }
}

Client端Handler程式碼

package time3;

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

/**
 * Created by lz on 2016/8/10.
 */
public class TimeClientHandler extends ChannelHandlerAdapter {
    private int counter;
    private byte[] req;
    public TimeClientHandler(){
        System.out.println("初始化");
        req = ("QUERY TIME ORDER" + System.getProperty("line.separator")).getBytes();
    }

    @Override
    public void channelActive(ChannelHandlerContext ctx) throws Exception {
        System.out.println("傳送資料");
        ByteBuf message = null;
        for (int i = 0; i < 100; i++) {
            message = Unpooled.buffer(req.length);
            message.writeBytes(req);
            ctx.writeAndFlush(message);
        }
    }

    @Override
    public void channelRead(ChannelHandlerContext ctx, Object msg) throws Exception {
        String body = (String) msg;
        System.out.println("Now is:"+body+";the counter is :" + ++counter);
    }

    @Override
    public void exceptionCaught(ChannelHandlerContext ctx, Throwable cause) throws Exception {
        System.out.println(cause.getMessage());
        ctx.close();
    }
}

通過我們的解碼器我們的程式碼就簡單了很多，部分地方有註釋就不祥解了。

DelimiterBasedFrameDecoder

DelimiterBasedFrameDecoder允許我們設定特定的分隔符用來分隔，用法和上面類似，

 ByteBuf delimiter = Unpooled.copiedBuffer("$_".getBytes()); //使用$_為分隔符
            socketChannel.pipeline().addLast(new DelimiterBasedFrameDecoder(1024,delimiter));

上面就是以$_為分隔符，這裡我們用echo伺服器做測試:

EchoServer端程式碼

package echo1;

import io.netty.bootstrap.ServerBootstrap;
import io.netty.buffer.ByteBuf;
import io.netty.buffer.Unpooled;
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.DelimiterBasedFrameDecoder;
import io.netty.handler.codec.LineBasedFrameDecoder;
import io.netty.handler.codec.string.StringDecoder;
import io.netty.handler.logging.LogLevel;
import io.netty.handler.logging.LoggingHandler;
import time3.TimeServerHandler;

/**
 * Created by lz on 2016/8/10.
 */
public class EchoServer {
    public void bind(int port) throws Exception{
        //配置服務端的NIO執行緒組,一個用於接收連線，一個用於處理連線
        EventLoopGroup bossGroup = new NioEventLoopGroup();
        EventLoopGroup workerGroup = new NioEventLoopGroup();
        try{
            ServerBootstrap b = new ServerBootstrap();
            b.group(bossGroup,workerGroup)
                    .channel(NioServerSocketChannel.class)
                    .option(ChannelOption.SO_BACKLOG,1024) //設定accept的最大 也就是三次握手成功的佇列長度
                    .handler(new LoggingHandler(LogLevel.INFO))
                    .childHandler(new ChildChannelHandler());
            //繫結埠，同步等待
            ChannelFuture f = b.bind(port).sync();
            //等待服務端監聽埠關閉
            f.channel().closeFuture().sync();
        }finally {
            //優雅退出,釋放執行緒資源
            bossGroup.shutdownGracefully();
            workerGroup.shutdownGracefully();
        }
    }
    private class ChildChannelHandler extends ChannelInitializer<SocketChannel> {

        @Override
        protected void initChannel(SocketChannel socketChannel) throws Exception {
            System.out.println("已經繫結");
            ByteBuf delimiter = Unpooled.copiedBuffer("$_".getBytes()); //使用$_為分隔符
            socketChannel.pipeline().addLast(new DelimiterBasedFrameDecoder(1024,delimiter));
            socketChannel.pipeline().addLast(new StringDecoder());
            socketChannel.pipeline().addLast(new EchoServerHandler());
        }
    }

    public static void main(String[] args) throws Exception {
        int port = 8080;
        new EchoServer().bind(port);
    }
}

EchoServer Handler程式碼

package echo1;

import io.netty.buffer.ByteBuf;
import io.netty.buffer.Unpooled;
import io.netty.channel.ChannelHandler;
import io.netty.channel.ChannelHandlerAdapter;
import io.netty.channel.ChannelHandlerContext;

/**
 * Created by lz on 2016/8/10.
 */
public class EchoServerHandler extends ChannelHandlerAdapter {
    int counter = 0;

    @Override
    public void channelRead(ChannelHandlerContext ctx, Object msg) throws Exception {
        String body = (String) msg;
        System.out.println("第"+ ++counter +"次接收"+body);
        body +="$_";
        ByteBuf echo = Unpooled.copiedBuffer(body.getBytes());
        ctx.writeAndFlush(echo);
    }

    @Override
    public void exceptionCaught(ChannelHandlerContext ctx, Throwable cause) throws Exception {
        cause.printStackTrace();
        ctx.close();//發生異常，關閉鏈路
    }
}

Echo Client端程式碼

package echo1;

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.ChannelOption;
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.LineBasedFrameDecoder;
import io.netty.handler.codec.string.StringDecoder;
import time3.TimeClientHandler;

/**
 * Created by lz on 2016/8/10.
 */
public class EchoClient {
    public void connect(int port,String host) throws Exception{
        //配置客戶端NIO執行緒組
        EventLoopGroup group =new NioEventLoopGroup();
        try{
            Bootstrap b = new Bootstrap();
            b.group(group).channel(NioSocketChannel.class).option(ChannelOption.TCP_NODELAY,true)
                    .handler(new ChannelInitializer<SocketChannel>(){

                        @Override
                        protected void initChannel(SocketChannel socketChannel) throws Exception {
                            ByteBuf delimiter = Unpooled.copiedBuffer("$_".getBytes()); //使用$_為分隔符
                            socketChannel.pipeline().addLast(new DelimiterBasedFrameDecoder(1024,delimiter));
                            socketChannel.pipeline().addLast(new StringDecoder());
                            socketChannel.pipeline().addLast(new EchoClientHandler());
                        }
                    });
            //發起非同步連線操作
            ChannelFuture f = b.connect(host,port).sync();
            f.channel().closeFuture().sync();
        }finally {
            //優雅退出，釋放NIO執行緒組
            group.shutdownGracefully();
        }
    }

    public static void main(String[] args) throws Exception {
        int port = 8080;
        new EchoClient().connect(port,"127.0.0.1");
    }
}

EchoClient Handler程式碼

package echo1;

import io.netty.buffer.Unpooled;
import io.netty.channel.ChannelHandler;
import io.netty.channel.ChannelHandlerAdapter;
import io.netty.channel.ChannelHandlerContext;

/**
 * Created by lz on 2016/8/10.
 */
public class EchoClientHandler extends ChannelHandlerAdapter {
    private int counter;
    static final String ECHO_REQ = "Hi,lizhao$_";

    @Override
    public void channelActive(ChannelHandlerContext ctx) throws Exception {
        for (int i = 0; i < 10; i++) {
            ctx.writeAndFlush(Unpooled.copiedBuffer(ECHO_REQ.getBytes()));
        }
    }

    @Override
    public void channelRead(ChannelHandlerContext ctx, Object msg) throws Exception {
        System.out.println("這是第"+ ++counter + "次接收" + msg);
    }

    @Override
    public void channelReadComplete(ChannelHandlerContext ctx) throws Exception {
        ctx.flush();
    }

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

執行上面的程式碼可以展示出正確的結果，我們當然不止這幾個我們還有FixedLengthFrameDecoder固定長度的解碼器，以及其他解碼器，更多檢視官方手冊。

相關推薦

Netty中處理TCP粘包和拆包

什麼是粘包和拆包 TCP是個”流”協議，流其實就是沒有界限的一串資料。 TCP底層中並不瞭解上層業務資料的具體含義，它會根據TCP緩衝區的實際情況進行包劃分，所以在TCP中就有可能一個完整地包會被TCP拆分成多個包，也有可能吧多個小的包封裝成一個大的資料包傳

tcp粘包和拆包的處理方案

隨著智慧硬體越來越流行，很多後端開發人員都有可能接觸到socket程式設計。而很多情況下，伺服器與端上需要保證資料的有序，穩定到達，自然而然就會選擇基於tcp/ip協議的socekt開發。開發過程中，經常會遇到tcp粘包，拆包的問題，本文將從產生原因，和解決方案以及work

Netty中粘包和拆包的解決方案

粘包和拆包是TCP網路程式設計中不可避免的，無論是服務端還是客戶端，當我們讀取或者傳送訊息的時候，都需要考慮TCP底層的粘包/拆包

Netty學習10-粘包和拆包

1 粘包拆包基本概念 TPC是一個面向流的協議。所謂流就是沒有邊界的一串資料，如同河水般連成一片，其中並沒有分界線。TCP底層並不瞭解上層業務資料的具體含義，它會根據TCP緩衝區的具體情況進行包的劃分，所以在業務上認為，一個完整的包可能會被TCP拆成多個包傳送，也有可能

Tcp粘包和拆包的原因

最近研究Netty網路程式設計，以前專案中也遇到過資料接收過程中資料質量太差問題，很可能是TCP傳輸過程中問題，特此記錄。 問題產生 一個完整的業務可能會被TCP拆分成多個包進行傳送，也有可能把多個小的包封裝成一個大的資料包傳送，這個就是TCP的拆包和封包問

tcp粘包和拆包、斷包

    while (1) {       var packLen = _.unpack('packLen', tcpBuffer.slice(0, 2));       len = packLen.len;       // console.log('pack len------:' + len);    

CocoaAsyncSocket + Protobuf 處理粘包和拆包問題

 在上一篇文章《iOS之ProtocolBuffer搭建和示例demo》分享環境的搭建, 我們和伺服器進行IM通訊用了github有名的框架CocoaAsynSocket, 然後和伺服器之間的資料媒介是ProtoBuf。然後後面在開發的過程中也碰到了拆包和粘包問題，這方面

Unity Socket傳輸 TCP粘包和拆包原因以及解決策略

3. 乙太網的payload大於MTU進行IP分片。MTU指：一種通訊協議的某一層上面所能通過的最大資料包大小。如果IP層有一個數據包要傳，而且資料的長度比鏈路層的MTU大，那麼IP層就會進行分片，把資料包分成若干片，讓每一片都不超過MTU。注意，IP分片可以發生在原始傳送端主機上，也可以發生在中間路由器上

Netty解決粘包和拆包問題的四種方案

兩個 json反序列 obj 合並 間隔 分享圖片 發送數據 返回 想是 在RPC框架中，粘包和拆包問題是必須解決一個問題，因為RPC框架中，各個微服務相互之間都是維系了一個TCP長連接，比如dubbo就是一個全雙工的長連接。由於微服務往對方發送信息的時候，所有的請求都是使

Netty入門系列(2) --使用Netty解決粘包和拆包問題

前言 上一篇我們介紹瞭如果使用Netty來開發一個簡單的服務端和客戶端，接下來我們來討論如何使用解碼器來解決TCP的粘包和拆包問題 TCP為什麼會粘包/拆包 我們知道，TCP是以一種流的方式來進行網路轉播的，當tcp三次握手簡歷通訊後，客戶端服務端之間就建立了一種通訊管道，我們可以想象成自來水管道，流出來的水

SOCKET 封包和拆包

資源 isl 個數 遊戲服務器 指正 長度 num 部分 程序開發 對於基於TCP開發的通訊程序,有個很重要的問題需要解決,就是封包和拆包.自從我從事網絡通訊編程工作以來(大概有三年的時間了),我一直在思索和改進封包和拆包的方法.下面就針對這個問題談談我的想法,拋磚引玉.若

描述在IPSec傳輸模式下ESP報文裝包和拆包過程

        AH(Authentication Header)：提供資料完整性驗證，通過Hash實現；資料來源身份認證，在計算驗證碼時加入共享金鑰；防止重放攻擊，AH包頭的序列號可防止重放攻擊。ESP(Encapsulating Security Payload)：ESP的協議號是50，提供AH的三種服務

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

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

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

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

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

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

Netty精粹之TCP粘包拆包問題

粘包拆包問題是處於網路比較底層的問題，在資料鏈路層、網路層以及傳輸層都有可能發生。我們日常的網路應用開發大都在傳輸層進行，由於UDP有訊息保護邊界，不會發生這個問題，因此這篇文章只討論發生在傳輸層的TCP粘包拆包問題。 什麼是粘包、拆包？ 對於什麼是粘包、拆包問題，

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

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

關於TCP粘包和半包的處理

今日，在程式設計過程中需要在區域網內不同的電腦間傳輸檔案，遇到了TCP協議的粘包和半包現象。經過思考和借鑑，找到了一個比較好的解決方法。因為在傳輸檔案時要先傳輸檔名和檔案大小，然後再傳輸檔案，所以電腦間的應用程式實現了一個小的協議。這個協議需要解碼TCP傳輸的內容。在有粘包

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

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

3、netty粘包、拆包（二）

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