Netty-TCP拆包/粘包

最新推荐文章于 2024-04-10 10:00:00 发布
最新推荐文章于 2024-04-10 10:00:00 发布
阅读量234 收藏
点赞数
分类专栏： Netty 文章标签： 字符串 网络通信 wap
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/coder_py/article/details/105587131
版权

Netty-TCP拆包/粘包

TCP拆包/粘包

TCP 是一个面向字节流的协议，它是性质是流式的，所以它并没有分段。就像水流一样，你没法知道什么时候开始，什么时候结束。所以它会根据当前的套接字缓冲区的情况进行拆包或是粘包

粘包问题图示:

图1.png

客户端发送两个数据包D1&D2给服务端，因为服务端一次读取的字节数是不确定的，所以可能出现:

  • 正常情况，服务端分两次读取到了两个独立的数据包

  • 服务端一次收到两个数据包，两个粘合在了一起，出现粘包现象

  • 服务端分两次读取到了两个数据包，第一次读取到完整的D1包&部分D2包的内容，第二次读取到了D2剩余内容，出现拆包现象

  • 服务端分两次读取到了两个数据包，第一次读取D1的部分，第二次读取了D1剩余内容以及完整D2

TCP拆包/粘包发送原因

图示:

图2.png

三个原因:

  • 应用程序write写入的字节大小大于套接口发送缓冲区的大小

  • 进行MSS大小的TCP分段

  • 以太网帧的payload大于MTU进行IP分片

例子

未考虑TCP粘包的情况


public class Client {

    public void connect(String host, int port) throws InterruptedException {

        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 ch) throws Exception {

                            ChannelPipeline p = ch.pipeline();
//                            p.addLast(new LineBasedFrameDecoder(1024));
//                            p.addLast(new StringDecoder());
//                            p.addLast(new StringEncoder());

                            p.addLast(new ClientHandler());
                        }
                    });

            ChannelFuture future = b.connect(host, port).sync();

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

    public static void main(String[] args) throws Exception {

        new Client().connect("localhost",9988);
    }


}


public class ClientHandler extends ChannelInboundHandlerAdapter {

//    private Logger logger = LoggerFactory.getLogger(getClass());

    private int count =0;

    @Override
    public void channelActive(ChannelHandlerContext ctx) throws Exception {
        // Send the message to Server
        ByteBuf buf = null;
        for(int i=0; i<100; i++){

            String msg = "hello from client "+i + "\n";
            byte[] r = msg.getBytes();
            buf = Unpooled.buffer(r.length);
            buf.writeBytes(r);
           ctx.writeAndFlush(buf);
//            System.out.println("client send message:{}   " + msg);


//            ctx.writeAndFlush(msg+System.getProperty("line.separator"));
        }

        System.out.println("out");
    }

    @Override
    public void channelRead(ChannelHandlerContext ctx, Object msg)
            throws Exception {
        String body = (String) msg;
        count++;
        System.out.println("client read msg:{}, count:{}   " + body + "    " + count);
    }

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


public class Server {

//    private Logger logger = LoggerFactory.getLogger(getClass());

    public void bind(int port) throws Exception {

        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 ChannelInitializer<SocketChannel>() {
                        @Override
                        public void initChannel(SocketChannel ch) throws Exception {

                            ChannelPipeline p = ch.pipeline();
//                            p.addLast(new LineBasedFrameDecoder(1024));
//                            p.addLast(new StringDecoder());
//                            p.addLast(new StringEncoder());

                            p.addLast(new ServerHandler());
                        }
                    });

            // Bind and start to accept incoming connections.
            ChannelFuture f = b.bind(port).sync(); // (7)

            System.out.println("server bind port:{}    "+ + port);

            // Wait until the server socket is closed.
            f.channel().closeFuture().sync();

        } finally {
            bossGroup.shutdownGracefully();
            workerGroup.shutdownGracefully();
        }
    }

    public static void main(String[] args) throws Exception {

        new Server().bind(9988);
    }
}


public class ServerHandler extends ChannelInboundHandlerAdapter {
//    private Logger logger = LoggerFactory.getLogger(getClass());

    private int count = 0;

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

        System.out.println("============package=====================");
        System.out.println(body);
        System.out.println("============package=====================");
    }

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

}

运行输出:


============package=====================
hello from client 0
hello from client 1
hello from client 2
hello from client 3
hello from client 4
hello from client 5
hello from client 6
hello from client 7
hello from client 8
hello from client 9
hello from client 10
hello from client 11
hello from client 12
hello from client 13
hello from client 14
hello from client 15
hello from client 16
hello from client 17
hello from client 18
hello from client 19
hello from client 20
hello from client 21
hello from client 22
hello from client 23
hello from client 24
hello from client 25
hello from client 26
hello from client 27
hello from client 28
hello from client 29
hello from client 30
hello from client 31
hello from client 32
hello from client 33
hello from client 34
hello from client 35
hello from client 36
hello from client 37
hello from client 38
hello from client 39
hello from client 40
hello from client 41
hello from client 42
hello from client 43
hello from client 44
hello from client 45
hello from client 46
hello from client 47
hello from client 48
hello
============package=====================
============package=====================
 from client 49
hello from client 50
hello from client 51
hello from client 52
hello from client 53
hello from client 54
hello from client 55
hello from client 56
hello from client 57
hello from client 58
hello from client 59
hello from client 60
hello from client 61
hello from client 62
hello from client 63
hello from client 64
hello from client 65
hello from client 66
hello from client 67
hello from client 68
hello from client 69
hello from client 70
hello from client 71
hello from client 72
hello from client 73
hello from client 74
hello from client 75
hello from client 76
hello from client 77
hello from client 78
hello from client 79
hello from client 80
hello from client 81
hello from client 82
hello from client 83
hello from client 84
hello from client 85
hello from client 86
hello from client 87
hello from client 88
hello from client 89
hello from client 90
hello from client 91
hello from client 92
hello from client 93
hello from client 94
hello from client 95
hello from client 96
hello from client 97
hello from client 98
hello from client 99

============package=====================

客户端发送的100条消息被当成了两个数据包进行处理，说明发送了粘包现象

使用LineBasedFrameDecoder + StringDecoder 解决问题

LineBasedFrameDecoder

文档:

public class LineBasedFrameDecoder
extends ByteToMessageDecoder

在行尾拆分接收到的ByteBuf的解码器，“ \ n”和“ \ r \ n”都被处理，字节流应采用UTF-8字符编码或ASCII。 当前实现使用直接字节进行字符转换，然后将该字符与一些低范围的ASCII字符（例如’\ n’或’\ r’）进行比较。 UTF-8没有将低范围[0…0x7F]字节值用于多字节代码点表示，因此此实现完全支持。

LineBasedFrameDecoder 的工作原理是它依次遍历 ByteBuf 中的可读字节，判断看是否有 "\n” 或者 "\r\n”，如果有，就以此位置为结束位置，从可读索引到结束位置区间的字节就组成了一行。它是以回车换行符为结束标记的解码器，支持配置单行的最大长度，如果连续读取到最大长度后仍然没有发现换行符，会抛出异常，同时忽略掉之前读取到的异常码流。

StringDecoder
public class StringDecoder
extends MessageToMessageDecoder<ByteBuf>

将收到的ByteBuf解码为字符串。 请注意，如果使用的是基于流的传输方式（例如TCP / IP），则此解码器必须与适当的ByteToMessageDecoder（例如DelimiterBasedFrameDecoder或LineBasedFrameDecoder）一起使用。 TCP / IP套接字中基于文本的线路协议的典型设置为：

 ChannelPipeline pipeline = ...;

 // Decoders
 pipeline.addLast("frameDecoder", new LineBasedFrameDecoder(80));
 pipeline.addLast("stringDecoder", new StringDecoder(CharsetUtil.UTF_8));

 // Encoder
 pipeline.addLast("stringEncoder", new StringEncoder(CharsetUtil.UTF_8));
 
and then you can use a String instead of a ByteBuf as a message:
 void channelRead(ChannelHandlerContext ctx, String msg) {
     ch.write("Did you say '" + msg + "'?\n");
 }
StringEncoder
public class StringEncoder
extends MessageToMessageEncoder<java.lang.CharSequence>

将请求的字符串编码为ByteBuf。 TCP / IP套接字中基于文本的线路协议的典型设置为：

 ChannelPipeline pipeline = ...;

 // Decoders
 pipeline.addLast("frameDecoder", new LineBasedFrameDecoder(80));
 pipeline.addLast("stringDecoder", new StringDecoder(CharsetUtil.UTF_8));

 // Encoder
 pipeline.addLast("stringEncoder", new StringEncoder(CharsetUtil.UTF_8));
 
and then you can use a String instead of a ByteBuf as a message:
 void channelRead(ChannelHandlerContext ctx, String msg) {
     ch.write("Did you say '" + msg + "'?\n");
 }

应用:

public class Server {

//    private Logger logger = LoggerFactory.getLogger(getClass());

    public void bind(int port) throws Exception {

        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 ChannelInitializer<SocketChannel>() {
                        @Override
                        public void initChannel(SocketChannel ch) throws Exception {

                            ChannelPipeline p = ch.pipeline();
                            p.addLast(new LineBasedFrameDecoder(1024));
                            p.addLast(new StringDecoder());
//                            p.addLast(new StringEncoder());

                            p.addLast(new ServerHandler());
                        }
                    });

            // Bind and start to accept incoming connections.
            ChannelFuture f = b.bind(port).sync(); // (7)

            System.out.println("server bind port:{}    "+ + port);

            // Wait until the server socket is closed.
            f.channel().closeFuture().sync();

        } finally {
            bossGroup.shutdownGracefully();
            workerGroup.shutdownGracefully();
        }
    }

    public static void main(String[] args) throws Exception {

        new Server().bind(9988);
    }
}

public class ServerHandler extends ChannelInboundHandlerAdapter {
//    private Logger logger = LoggerFactory.getLogger(getClass());

    private int count = 0;

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

        String body = (String) msg;
        System.out.println("");
        System.out.println("============package=====================");
        System.out.println(body);
        System.out.println("============package=====================");
        System.out.println("");
    }

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

}


public class ClientHandler extends ChannelInboundHandlerAdapter {

    private int count =0;

    @Override
    public void channelActive(ChannelHandlerContext ctx) throws Exception {
        // Send the message to Server
        ByteBuf buf = null;
        for(int i=0; i<100; i++){

            String msg = "hello from client "+i + "\n";
            byte[] r = msg.getBytes();
            buf = Unpooled.buffer(r.length);
            buf.writeBytes(r);
           ctx.writeAndFlush(buf);
        }

    }

    @Override
    public void channelRead(ChannelHandlerContext ctx, Object msg)
            throws Exception {
        String body = (String) msg;
        count++;
        System.out.println("client read msg:{}, count:{}   " + body + "    " + count);
    }

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



public class Client {

    public void connect(String host, int port) throws InterruptedException {

        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 ch) throws Exception {

                            ChannelPipeline p = ch.pipeline();
                            p.addLast(new LineBasedFrameDecoder(1024));
                            p.addLast(new StringDecoder());
//                            p.addLast(new StringEncoder());

                            p.addLast(new ClientHandler());
                        }
                    });

            ChannelFuture future = b.connect(host, port).sync();

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

    public static void main(String[] args) throws Exception {

        new Client().connect("localhost",9988);
    }


}
Coder_py
关注
专栏目录
netty基于TCP的拆包与粘包
weixin_42743317的博客
04-14 864
TCP的拆包与粘包netty基于TCP的拆包与粘包2.1 拆包粘包简介2.2 发送方拆包2.2.1 需求2.2.2 创建工程 03-unpacking2.2.3 定义客户端2.2.4 定义服务端2.3 发送方粘包2.3.1 需求2.3.2 创建工程 03-stickybag2.3.3 定义客户端2.3.4 定义服务端2.4 接收方的粘包拆包2.5 LineBasedFrameDecoder2.5....
Netty-TCP粘包/拆包和编解码
qq_45126604的博客
07-06 500
TCP是”流“协议，无消息保护边界，所以一个完整的包可能会被TCP划分成多个包进行发送，也可能把多个包封装成一个大的数据包发送。所以我们需要在接收端处理消息边界问题。 当服务端一次收到两个数据包，D1和D2粘合在一起，就是TCP粘包 当服务端分两次读取到了两个数据包，第一次读取完整的D1包和D2的部分内容，第二次读取了D2的剩余内容，就是TCP拆包。 TCP粘包/拆包的原因 应用程序写入的字节大小大于套接口发送缓冲区的大小，会导致拆包。 进行MSS大小的TCP分段，会导致拆包。 以太网帧的pay
Netty框架之编解码机制一（ByteBuf以及Tcp粘包拆包）
a1032722788的博客
07-31 793
前言 继上次文章后小编很久都没有发布文章了，已经一个多月了，小编还是要努力更新的，最近确实比较忙，并且台风烟花也过来了，愿各地灾情早点过去吧！好了话不多说，今天继续我们的netty的编解码机制。在编解码之前，我们先说一下netty的ByteBuf，以及tcp的粘包和拆包。 netty核心组件之ByteBuf 上篇文章中Netty框架之核心组件，主要讲了Netty Channel，ChannelPipeline等重要组件，但是小编忘记了一个、那就是ByteBuf。那小编首先带大家了解一下netty的ByteB
12.netty中tcp粘包拆包问题及解决方法
PacosonSWJTU的博客
09-10 1734
接收者接收到2个冗余或不完整的数据包（服务器只接收到一个数据包（存在。服务器接收到2个数据包，没有拆包，也没有粘包问题。
Netty核心原理详解第三篇 编解码和数据传输
fegus的博客
07-15 1402
本节课我们详细讨论了TCP中的拆包/粘包问题，以及如何通过应用层的通信协议来解决拆包/粘包问题。其中基于消息长度+消息内容的变长协议是项目开发中最常用的一种方法，需要我们重点掌握，例如开源中间件Dubbo、RocketMQ等都基于该方法自定义了自己的通信协议，下节课我们将一起学习如何设计高效、可扩展、易维护的自定义网络通信协议。既然是网络编程，自然离不开通信协议，应用层之间通信需要实现各种各样的网络协议。在项目开发的过程中，我们就需要去构建满足自己业务场景的应用层协议。一次解码器和二次解码器。...
netty系列之:netty中的frame解码器
程序那些事
04-28 1094
文章目录简介LineBasedFrameDecoderDelimiterBasedFrameDecoderFixedLengthFrameDecoderLengthFieldBasedFrameDecoder总结 简介 netty中的数据是通过ByteBuf来进行传输的，一个ByteBuf中可能包含多个有意义的数据，这些数据可以被称作frame，也就是说一个ByteBuf中可以包含多个Frame。 对于消息的接收方来说，接收到了ByteBuf，还需要从ByteBuf中解析出有用而数据，那就需要将ByteBu
Netty——解码器的作用及实现
共勉
02-23 1387
主要介绍沾包和拆包以及掌握Netty内置的LengthFieldBasedFrameDecoder、LineBasedFrameDecoder、DelimiterBasedFrameDecoder、FixedLengthFrameDecoder几种解码器的使用
使用Netty解决TCP粘包和拆包问题过程详解
08-25
使用Netty解决TCP粘包和拆包问题过程详解 Netty是一个流行的Java网络编程框架，提供了简洁、灵活的API来处理网络编程的各种问题。其中，解决TCP粘包和拆包问题是Netty的一个重要应用场景。本文将详细介绍使用Netty...
Netty 教程 – Netty粘包/拆包解决之道
二师兄撒欢之地
03-16 889
通过以上分析，我们清楚了粘包或拆包发生的原因，那么如何解决这个问题呢？数据报文的长度，因此在应用层能很好的将不同的数据报文区分开，从而避免粘包和拆包的问题。需要实现的逻辑主要对应于处理第一个数据包的时候，第一次调用。，用户自己去实现处理粘包、拆包的逻辑还是有一定难度的，的首部没有表示数据长度的字段，基于上面两点，在使用。，这里有不断的数据流入，而我们要做的就是从这个。的都知道，它是属于传输层的协议，传输层除了有。传输层之间的数据交互是大小不等的数据块，但是。内置的解决方案解决粘包/拆包的问题。
Netty粘包-拆包应用案例及解决方案分析.docx
10-26
Netty 作为一个高性能的网络通信框架，提供了多种解决 TCP 粘包/拆包问题的方法。 一、TCP 粘包/拆包的基础知识 TCP 是一个“流”协议，没有界限的一串数据。TCP 底层并不知道上层业务逻辑，它会根据 TCP 缓冲区...
LengthFieldBasedFrameDecoder 实例代码
12-02
netty中，大多数的协议在协议头中都会携带长度字段，用于标识消息体或则整包消息的长度。LengthFieldBasedFrameDecoder通过指定长度来标识整包消息，这样就可以自动的处理黏包和半包消息，只要传入正确的参数，就可以轻松解决“读半包”的问题。
nettty3.0之探究FrameDecoder 带你了解解码器的原理
qq_32459653的博客
08-11 1464
使用过netty的人都知道，在使用netty的时候都或多或少碰到粘包或分包问题，这里就需要使用使用解码器了，那解码器如何工作的呢？现在就带大家探究一下，首次请看下面我画的一张frameDecoder流程图，因为源码就是按照这个思路写的。   带着这个思路，我们就开始我们源码分析之旅吧！！，首先你应该明白，FrameDecoder是一个handler，应为netty中数据交个管道中的hand...
Netty笔记：FrameDecoder
tianshilang的专栏
09-29 447
     FrameDecoder是Netty Protocol Decode最关键的Decoder，几乎所有和协议解码相关的Decoder都继承自它，那到底解决了什么问题？为什么需要这样的一个部件呢？TCP的传输是基于流的，每个数据包都有可能被分片和然后重组，这时候我们就需要协议去界定一个数据包，通常来说用来方式来确定数据包的边界，一个是基于长度，简单一点就是规定数据包的长度，例如规定每个数据包...
FrameDecoder介绍
SAN_YUN的专栏
11-05 262
FrameDecoder 负责 decodes the received ChannelBuffer s into a meaningful frame object. In a stream-based transport such as TCP/IP, packets can be fragmented and reassembled during transmi...
LengthFieldBasedFrameDecoder 详解
架构师尼恩
01-20 9329
LengthFieldBasedFrameDecoder 详解 疯狂创客圈 Java 分布式聊天室【 亿级流量】实战系列之 -31【 博客园 总入口 】 文章目录LengthFieldBasedFrameDecoder 详解写在前面1.1.1. 解码器：FrameDecoder1.1.1. 难点：自定义长度帧解码器写在最后疯狂创客圈 亿级流量 高并发IM 学习实战 ...
netty源码分析之FrameDecoder
勤奋的asialee的博客
01-27 331
         我们接下来就看和业务息息相关的解码器，首先我们来看FrameDecoder，这个东西应该是所有的解码器都会实现这个，所以我们来重点看一下。         FrameDecoder产生的根源就是TCP/IP数据包的传输方式决定的，包在传输的过程中会分片和重组， 正如javadoc里面所说的：     客户端在发送的时候的序列如下： +-----+-----+-----...
Netty学习——高级篇2 Netty解码技术
最新发布
geminigoth的博客
04-10 1076
本章继续介绍Netty的其他解码器。
decoder_decode_frame解码函数分析
u012117034的博客
01-05 1790
decoder_decode_frame() 其实是一个通用的解码函数，可以解码 音频，视频，字幕的 AVPacket。不过本文主要侧重于分析音频流的解码，但其他的流也是类似的逻辑。
Netty学习-02（粘包 解包 FrameDecoder）
写博客只为学习
04-11 1366
1、简介 Java1.4提供了NIO使开发者可以使用Java编写高性能的服务端程序，但使用原生的NIO API就像Linux C中网络编程一样，还是需要做IO处理、协议处理等低层次工作。所以，就像C服务端程序大量使用libevent作为网络应用框架一样，Java社区也不断涌现出基于NIO的网络应用框架。在这其中，Jboss出品的Netty就是个中翘楚。Netty是个异步的事件驱动网络应用框架，具有
Netty深度解析：TCP粘包拆包问题及解决方案
TCP粘包拆包问题是在网络编程，尤其是使用像Netty这样的TCP通信框架时，开发者经常会遇到的一个挑战。粘包指的是在网络通信中，接收方收到的数据包可能会超出预期的界限，使得原本应该分隔开的消息被合并成一个，而...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值