Netty TCP 粘包和拆包

最新推荐文章于 2023-11-09 10:43:00 发布
最新推荐文章于 2023-11-09 10:43:00 发布
阅读量174 收藏
点赞数
分类专栏： Java Netty 文章标签： tcp/ip 网络 服务器
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/hn_lzh2014/article/details/129820499
版权
Java 同时被 2 个专栏收录
46 篇文章 0 订阅
订阅专栏
Netty
23 篇文章 2 订阅
订阅专栏

基本介绍：

TCP 是面向连接的，面向流的，提供高可靠性服务。 收发两端 （客户端 和 服务器端）都要有一一成对的 socket。因此，发送端为了将多个发给接收端的包，更有效的发送给对方，使用了优化方法（Nagle 算法）, 将多次间隔较小且数据量小的数据，合并成一个大的数据块，然后进行封包。这样做虽然提高了效率，但是接收端就难于分辨出完整的数据包了，因为面向流通信是无消息保护边界的，需要接收端处理消息边界问题。

存在四种情况:  由于服务端一次读取到字节数是不确定的

  • 服务端分两次读取到了两个 独立的数据包,分别是D1 和 D2,  没有粘包和拆包
  • 服务端一次接受到了两个数据包，D1 和 D2 粘合在一起，称之为 TCP 粘包
  • 服务端分两次读取到了数据包, 第一次读取到完整的 D1 包和 D2 包的部分内容，第二次读取到了 D2 包的剩余内容，这称为 TCP 拆包
  • 服务端分两次读取到了数据包，第一次读取到了 D1 包的部分内容 D1_1, 第二次读取到了 D1包的剩余部分内容 D1_2 和 完整的D2包

粘包和拆包示例:

NettyServerHandler:

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

import java.nio.charset.StandardCharsets;
import java.util.UUID;


public class NettyServerHandler extends SimpleChannelInboundHandler<ByteBuf> {
    private int count;
    @Override
    protected void channelRead0(ChannelHandlerContext channelHandlerContext, ByteBuf byteBuf) throws Exception {
        byte[] buffer = new byte[byteBuf.readableBytes()];
        byteBuf.readBytes(buffer);

        // 将 buffer 转成字符串
        String message = new String(buffer, StandardCharsets.UTF_8);
        System.out.println("服务器端接收到数据 " + message);
        System.out.println("服务器接收到消息量=" + (count++));

        // 服务器回送数据给客户端, 回送一个随机 id
        ByteBuf responseByteBuf = Unpooled.copiedBuffer(UUID.randomUUID().toString() + " ", StandardCharsets.UTF_8);
        channelHandlerContext.writeAndFlush(responseByteBuf);
    }

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

NettyServerInitializer:
import io.netty.channel.ChannelInitializer;
import io.netty.channel.ChannelPipeline;
import io.netty.channel.socket.SocketChannel;

public class NettyServerInitializer extends ChannelInitializer<SocketChannel> {
    @Override
    protected void initChannel(SocketChannel socketChannel) throws Exception {
        ChannelPipeline pipeline = socketChannel.pipeline();
        pipeline.addLast(new NettyServerHandler());
    }
}

NettyServerHandler:
import io.netty.buffer.ByteBuf;
import io.netty.buffer.Unpooled;
import io.netty.channel.ChannelHandlerContext;
import io.netty.channel.SimpleChannelInboundHandler;

import java.nio.charset.StandardCharsets;
import java.util.UUID;


public class NettyServerHandler extends SimpleChannelInboundHandler<ByteBuf> {
    private int count;
    @Override
    protected void channelRead0(ChannelHandlerContext channelHandlerContext, ByteBuf byteBuf) throws Exception {
        byte[] buffer = new byte[byteBuf.readableBytes()];
        byteBuf.readBytes(buffer);

        // 将 buffer 转成字符串
        String message = new String(buffer, StandardCharsets.UTF_8);
        System.out.println("服务器端接收到数据 " + message);
        System.out.println("服务器接收到消息量=" + (count++));

        // 服务器回送数据给客户端, 回送一个随机 id
        ByteBuf responseByteBuf = Unpooled.copiedBuffer(UUID.randomUUID().toString() + " ", StandardCharsets.UTF_8);
        channelHandlerContext.writeAndFlush(responseByteBuf);
    }

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

NettyClientHandler:
import io.netty.buffer.ByteBuf;
import io.netty.buffer.Unpooled;
import io.netty.channel.ChannelHandlerContext;
import io.netty.channel.SimpleChannelInboundHandler;

import java.nio.charset.StandardCharsets;

public class NettyClientHandler extends SimpleChannelInboundHandler<ByteBuf> {
    private int count;

    @Override
    protected void channelRead0(ChannelHandlerContext channelHandlerContext, ByteBuf byteBuf) throws Exception {
        byte[] buffer = new byte[byteBuf.readableBytes()];
        byteBuf.readBytes(buffer);

        // 将 buffer 转成字符串
        String message = new String(buffer, StandardCharsets.UTF_8);
        System.out.println("客户端端接收到数据 " + message);
        System.out.println("客户端接收到消息量=" + (count++));
    }

    @Override
    public void channelActive(ChannelHandlerContext ctx) throws Exception {
        // 使用客户端发送 10条数据, hello,doubily
        for (int i = 0; i< 10; i++) {
            ByteBuf buffer = Unpooled.copiedBuffer("hello,doubily" + i + " ", StandardCharsets.UTF_8);
            ctx.writeAndFlush(buffer);
        }
    }

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

NettyClientInitializer:
import io.netty.channel.ChannelInitializer;
import io.netty.channel.ChannelPipeline;
import io.netty.channel.socket.SocketChannel;

public class NettyClientInitializer extends ChannelInitializer<SocketChannel> {
    @Override
    protected void initChannel(SocketChannel socketChannel) throws Exception {
        ChannelPipeline pipeline = socketChannel.pipeline();
        pipeline.addLast(new NettyClientHandler());
    }
}

NettyClient:
import io.netty.bootstrap.Bootstrap;
import io.netty.channel.ChannelFuture;
import io.netty.channel.EventLoopGroup;
import io.netty.channel.nio.NioEventLoopGroup;
import io.netty.channel.socket.nio.NioSocketChannel;

public class NettyClient {

    public static void main(String[] args) throws InterruptedException {
        EventLoopGroup group = new NioEventLoopGroup();
        try {
            Bootstrap bootstrap = new Bootstrap();
            bootstrap.group(group).channel(NioSocketChannel.class).handler(new NettyClientInitializer());

            ChannelFuture channelFuture = bootstrap.connect("localhost", 9527).sync();
            channelFuture.channel().closeFuture().sync();
        }finally {
            group.shutdownGracefully();
        }

    }
}

启动多客户端后服务器效果图：

 TCP 粘包和拆包解决：

增加POJO，根据长度去获取数据信息

MessageProtocol：
public class MessageProtocol {
    private int len;
    private byte[] content;

    public int getLen() {
        return len;
    }

    public void setLen(int len) {
        this.len = len;
    }

    public byte[] getContent() {
        return content;
    }

    public void setContent(byte[] content) {
        this.content = content;
    }
}

MessageDecoder：
import io.netty.buffer.ByteBuf;
import io.netty.channel.ChannelHandlerContext;
import io.netty.handler.codec.ReplayingDecoder;

import java.util.List;

public class MessageDecoder extends ReplayingDecoder<Void> {
    @Override
    protected void decode(ChannelHandlerContext channelHandlerContext, ByteBuf byteBuf, List<Object> list) throws Exception {
        System.out.println("MessageDecoder decode 被调用");

        // 需要将得到的二进制字节码 转成 messageProtocol 数据包
        int length = byteBuf.readInt();
        byte[] content = new byte[length];
        byteBuf.readBytes(content);

        // 封装成 MessageProtocol 对象，放入 list， 传递到下一个 handler 进行处理
        MessageProtocol messageProtocol = new MessageProtocol();
        messageProtocol.setLen(length);
        messageProtocol.setContent(content);

        list.add(messageProtocol);

    }
}

MessageEncoder：
import io.netty.buffer.ByteBuf;
import io.netty.channel.ChannelHandlerContext;
import io.netty.handler.codec.MessageToByteEncoder;

public class MessageEncoder extends MessageToByteEncoder<MessageProtocol> {
    @Override
    protected void encode(ChannelHandlerContext channelHandlerContext, MessageProtocol messageProtocol, ByteBuf byteBuf) throws Exception {
        System.out.println("MessageEncoder encode 方法被调用");
        byteBuf.writeInt(messageProtocol.getLen());
        byteBuf.writeBytes(messageProtocol.getContent());
    }
}

NettyServerHandler：
import io.netty.channel.ChannelHandlerContext;
import io.netty.channel.SimpleChannelInboundHandler;

import java.nio.charset.StandardCharsets;
import java.util.UUID;

public class NettyServerHandler extends SimpleChannelInboundHandler<MessageProtocol> {
    private int count;
    @Override
    public void exceptionCaught(ChannelHandlerContext ctx, Throwable cause) throws Exception {
        cause.printStackTrace();
        ctx.close();
    }

    @Override
    protected void channelRead0(ChannelHandlerContext channelHandlerContext, MessageProtocol messageProtocol) throws Exception {
        // 接收到数据并处理
        int len = messageProtocol.getLen();
        byte[] content = messageProtocol.getContent();

        System.out.println("服务器接收到信息如下");
        System.out.println("长度 = " + len);
        System.out.println("内容 = " + new String(content, StandardCharsets.UTF_8));
        System.out.println("服务器接收到消息包数量 = " + (++count));

        // 回复消息
        String responseMsg = UUID.randomUUID().toString();
        byte[] responseContent = responseMsg.getBytes(StandardCharsets.UTF_8);
        int responseLen = responseContent.length;
        // 构建协议包
        MessageProtocol responseProtocol = new MessageProtocol();
        responseProtocol.setLen(responseLen);
        responseProtocol.setContent(responseContent);
        channelHandlerContext.writeAndFlush(responseProtocol);
    }
}

NettyServerInitializer：
import io.netty.channel.ChannelInitializer;
import io.netty.channel.ChannelPipeline;
import io.netty.channel.socket.SocketChannel;

public class NettyServerInitializer extends ChannelInitializer<SocketChannel> {
    @Override
    protected void initChannel(SocketChannel socketChannel) throws Exception {
        ChannelPipeline pipeline = socketChannel.pipeline();
        pipeline.addLast(new MessageDecoder()); // 解码器
        pipeline.addLast(new MessageEncoder()); // 编码器
        pipeline.addLast(new NettyServerHandler());
    }
}
NettyServer：
import io.netty.bootstrap.ServerBootstrap;
import io.netty.channel.ChannelFuture;
import io.netty.channel.nio.NioEventLoopGroup;
import io.netty.channel.socket.nio.NioServerSocketChannel;

public class NettyServer {
    public static void main(String[] args) throws InterruptedException {
        NioEventLoopGroup bossGroup = new NioEventLoopGroup(1);
        NioEventLoopGroup workerGroup = new NioEventLoopGroup();

        try {
            ServerBootstrap serverBootstrap = new ServerBootstrap();
            serverBootstrap.group(bossGroup, workerGroup)
                    .channel(NioServerSocketChannel.class)
                    .childHandler(new NettyServerInitializer());

            ChannelFuture channelFuture = serverBootstrap.bind(9527).sync();
            channelFuture.channel().closeFuture().sync();
        } finally {
            bossGroup.shutdownGracefully();
            workerGroup.shutdownGracefully();
        }

    }
}

NettyClientHandler：
import io.netty.channel.ChannelHandlerContext;
import io.netty.channel.SimpleChannelInboundHandler;

import java.nio.charset.StandardCharsets;

public class NettyClientHandler extends SimpleChannelInboundHandler<MessageProtocol> {
    private int count;


    @Override
    public void channelActive(ChannelHandlerContext ctx) throws Exception {
        // 使用客户端发送 10条数据, hello,doubily
        for (int i = 0; i< 5; i++) {
            String msg = "hello,doubily" + i + " ";
            byte[] content = msg.getBytes(StandardCharsets.UTF_8);
            int length = content.length;

            // 创建协议包对象
            MessageProtocol messageProtocol = new MessageProtocol();
            messageProtocol.setLen(length);
            messageProtocol.setContent(content);
            ctx.writeAndFlush(messageProtocol);
        }
    }

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

    @Override
    protected void channelRead0(ChannelHandlerContext channelHandlerContext, MessageProtocol messageProtocol) throws Exception {
        int len = messageProtocol.getLen();
        byte[] content = messageProtocol.getContent();

        System.out.println("客户端接收到信息如下");
        System.out.println("长度 = " + len);
        System.out.println("内容 = " + new String(content, StandardCharsets.UTF_8));
        System.out.println("客户端接收到消息包数量 = " + (++count));
    }
}

NettyClientInitializer：
import io.netty.channel.ChannelInitializer;
import io.netty.channel.ChannelPipeline;
import io.netty.channel.socket.SocketChannel;

public class NettyClientInitializer extends ChannelInitializer<SocketChannel> {
    @Override
    protected void initChannel(SocketChannel socketChannel) throws Exception {
        ChannelPipeline pipeline = socketChannel.pipeline();
        pipeline.addLast(new MessageEncoder()); // 编码器
        pipeline.addLast(new MessageDecoder()); // 解码器
        pipeline.addLast(new NettyClientHandler());

    }
}

NettyClient：
import io.netty.bootstrap.Bootstrap;
import io.netty.channel.ChannelFuture;
import io.netty.channel.EventLoopGroup;
import io.netty.channel.nio.NioEventLoopGroup;
import io.netty.channel.socket.nio.NioSocketChannel;

public class NettyClient {

    public static void main(String[] args) throws InterruptedException {
        EventLoopGroup group = new NioEventLoopGroup();
        try {
            Bootstrap bootstrap = new Bootstrap();
            bootstrap.group(group).channel(NioSocketChannel.class).handler(new NettyClientInitializer());

            ChannelFuture channelFuture = bootstrap.connect("localhost", 9527).sync();
            channelFuture.channel().closeFuture().sync();
        }finally {
            group.shutdownGracefully();
        }

    }
}

逆流丶石头
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
使用Netty解决TCP粘包和拆包问题过程详解
08-25
使用Netty解决TCP粘包和拆包问题过程详解 Netty是一个流行的Java网络编程框架，提供了简洁、灵活的API来处理网络编程的各种问题。其中，解决TCP粘包和拆包问题是Netty的一个重要应用场景。本文将详细介绍使用Netty...
Netty粘包拆包问题解决方案
08-18
Netty 粘包拆包问题解决方案 Netty 是一个基于 Java 的网络编程框架，它提供了一个便捷的方式来处理网络数据的读写操作。然而，在使用 Netty 进行网络编程时，经常会遇到粘包和拆包的问题。所谓粘包和拆包，就是指...
Netty如何解决TCP中的粘包和拆包问题
lengyingzhang的博客
07-29 3071
粘包和拆包是TCP网络编程中不可避免的，无论是服务端还是客户端，当我们读取或者发送消息的时候，都需要考虑TCP底层的粘包/拆包机制。TCP是个“流”协议，所谓流，就是没有界限的一串数据。TCP底层并不了解上层业务数据的具体含义，它会根据TCP缓冲区的实际情况进行包的划分，所以在业务上认为，一个完整的包可能会被TCP拆分成多个包进行发送，也有可能把多个小的包封装成一个大的数据包发送，这就是所谓的TCP粘包和拆包问题。...
【三】Netty 解决粘包和拆包问题
echohuangshihuxue的博客
01-06 2558
一:介绍了下 TCP的粘包和拆包的原理以及主流的解决方案。 二:详细的用代码展示了粘包例子和 如何解决。 三:简单介绍了下 编码解码原理以及自己遇到的坑
基于 Netty 的通信组件如何解决粘包拆包问题
m0_71777195的博客
06-06 983
这节课给大家介绍了粘包拆包的解决方案。首先给大家介绍了粘包拆包的场景。然后，给大家介绍了通过设定一个完整语义的字节流长度来避免粘包拆包的问题。在生产环境上我还是建议大家用设定字节流长度方法来解决拆包粘包的问题，因为这个方案会更加的通用，而且 4 个字节长度的字节流长度也不会浪费太多流量。
SpringBoot+Netty实现TCP客户端实现接收数据按照16进制解析并存储到Mysql以及Netty断线重连检测与自动重连
BADAO_LIUMANG_QIZHI的博客
03-30 8821
在SpringBoot项目中需要对接三方系统，对接协议是TCP，需实现一个TCP客户端接收服务端发送的数据并按照16进制进行解析数据，然后对数据进行过滤，将指定类型的数据通过mybatis存储进mysql数据库中。并且当tcp服务端断连时，tcp客户端能定时检测并发起重连。
Netty解决粘包和拆包问题的四种方案，简单易懂
lt_xiaodou的博客
08-06 1万+
对于粘包与拆包问题，其实前面三种基本上已经能够满足大多数情形了，但是对于一些更加复杂的协议，可能有一些定制化的需求。对于这些场景，其实本质上，我们也不需要手动从头开始写一份粘包与拆包处理器，而是通过继承LengthFieldBasedFrameDecoder和LengthFieldPrepender来实现粘包和拆包的处理。如果用户确实需要不通过继承的方式实现自己的粘包和拆包处理器，这里可以通过实现MessageToByteEncoder和ByteToMessageDecoder来实现。...
Netty中粘包和拆包的解决方案.docx
10-26
在TCP网络编程中，粘包和拆包是常见的问题，...总的来说，Netty通过提供一系列的解码器，使得处理TCP粘包和拆包问题变得更加便捷，开发者可以根据实际业务需求灵活选择或自定义解码策略，保证数据的正确传输和解析。
Netty粘包-拆包应用案例及解决方案分析.docx
10-26
Netty 作为一个高性能的网络通信框架，提供了多种解决 TCP 粘包/拆包问题的方法。 一、TCP 粘包/拆包的基础知识 TCP 是一个“流”协议，没有界限的一串数据。TCP 底层并不知道上层业务逻辑，它会根据 TCP 缓冲区...
Netty精粹之TCP粘包拆包问题
09-27
什么是粘包拆包，为什么发生拆包粘包问题，如何处理拆包粘包问题
【Java】Netty创建网络服务端客户端（TCP/UDP）
最新发布
DevFrank的博客
11-09 4030
Netty创建网络服务端客户端示例
Netty实现TCP通信
做兴趣使然的Hero
10-03 2640
Netty实现TCP通信 1 基本步骤 2 具体代码 2.1 服务端代码 /** * @desc: Server端 * @author: YanMingXin * @create: 2021/9/27-15:30 **/ public class NettyTcpServer { public static void main(String[] args) { //boosGroup处理连接请求 NioEventLoopGroup boosGroup =
Java netty发送接收（TCP、UDP）
weixin_50272584的博客
05-12 2892
Java netty发送接收（TCP、UDP）含项目地址
tcp粘包，拆包
qq_21277357的博客
12-21 233
例如：客户端发送了2个数据包，一个a,一个b给到服务端，由于服务端一次读取到字节数是不确定的，可能有以下4种情况；4.服务端第一次读取到了a的一部分，第二次读取到了a的剩余部分和b的完整数据，这也叫拆包；3.服务第一次读取到了a和b的一部分数据，第二次读取到了b的剩余部分，这就叫拆包；tcp 在发消息的时候，把多个数据量小的数据，合并成一个大的数据块，这个叫封包；可以看到，12粘包，345粘包，67粘包，89粘包。1、服务端分别读取到了a和b，这样是正常的情况；我们在启动一个客户端。
用netty实现tcp简单通信
mistt的博客
02-16 1万+
一般我们想要使用tcp通信，最原始的方法就是使用socket套接字，但是每次都要创建新的socket对象，并且在finally中关闭，好浪费资源，很麻烦。所以就是用netty工具，可以轻松地实现tcp通信，当然也可以实现http通信，因为我们需要用tcp通信，所以这里只研究tcp。 最好先了解一下netty是干嘛的，以及NIO是什么。 netty： https://blog.csdn.net/qq_34730511/article/details/98472924?ops_request_misc=&
Netty 之 TCP粘包拆包基本解决方案
z69183787的专栏
09-20 3831
上个小节我们浅析了在Netty的使用的时候TCP的粘包和拆包的现象，Netty对此问题提供了相对比较丰富的解决方案 Netty提供了几个常用的解码器，帮助我们解决这些问题，其实上述的粘包和拆包的问题，归根结底的解决方案就是发送端给远程端一个标记，告诉远程端，每个信息的结束标志是什么，这样，远程端获取到数据后，根据跟发送端约束的标志，将接收的信息分切或者合并成我们需要的信息，这样我
解决Netty中TCP拆包、粘包问题
刘信坚的博客
08-21 8062
一 概述 在基于流的传输里比如TCP/IP，接收到的数据会先被存储到一个socket接收缓冲里。不幸的是，基于流的传输并不是一个数据包队列，而是一个字节队列。即使你发送了2个独立的数据包，操作系统也不会作为2个消息处理而仅仅是作为一连串的字节而言。因此这是不能保证你远程写入的数据就会准确地读取。举个例子，让我们假设操作系统的TCP/TP协议栈已经接收了3个数据包： 由于基于流传输的协议的这...
一起学Netty（七）之 TCP粘包拆包基本解决方案
BazingaLyncc
05-07 2万+
可以看到被分了20次读取，我们可以这样理解，客户端发送了2次req字节，每个req中有10个“$$__”，这样就是第11次切割的时候其实发送了粘包，第一个req中末尾部分和第二次的头部粘在了一起，作为第11部分的内容 而最后一部分的内容因为没有"$$__"切割，所以没有打印在控制台上~ 其实这类的Handler还是相对比较简单的，真实的生产环境这些decoder只是作为比较基本的切分类，但是这些decoder还是很好用的~
netty解析自定义长度的tcp报文--java处理tcp接口数据
热门推荐
老专家的博客
07-20 2万+
1.理解netty的decode处理过程，2.netty的Bytebuf在decode时的处理过程，两个指针 netty是tcp包–&amp;amp;amp;amp;gt;decode整理报文–&amp;amp;amp;amp;gt;业务handler的过程。decode【必须】读取报文，否则报DecoderException说你decode但是没有读取任何报文，这是netty为了防止自己开发decode出现bug，所有decode需要Bytebuf msg...
netty tcp粘包和拆包
07-30
Netty中的TCP粘包和拆包问题是由于底层的TCP协议无法理解上层的业务数据而导致的。为了解决这个问题，Netty提供了几种解决方案。其中，常用的解决方案有四种[1]： 1. 固定长度的拆包器（FixedLengthFrameDecoder）...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值