【Netty入门】解决TCP粘包/分包的实例

最新推荐文章于 2021-04-20 10:00:49 发布
最新推荐文章于 2021-04-20 10:00:49 发布
阅读量408 收藏
点赞数 1
分类专栏： 通信协议 文章标签： Netty 拆包粘包

本文转自//blog.csdn.net/baiye_xing/article/details/73189191

回顾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())));
  • 1
  • 2

例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;
    }

}
Alex_81D
关注
专栏目录
Netty 教程 – Netty粘包/拆包解决之道
二师兄撒欢之地
03-16 896
通过以上分析，我们清楚了粘包或拆包发生的原因，那么如何解决这个问题呢？数据报文的长度，因此在应用层能很好的将不同的数据报文区分开，从而避免粘包和拆包的问题。需要实现的逻辑主要对应于处理第一个数据包的时候，第一次调用。，用户自己去实现处理粘包、拆包的逻辑还是有一定难度的，的首部没有表示数据长度的字段，基于上面两点，在使用。，这里有不断的数据流入，而我们要做的就是从这个。的都知道，它是属于传输层的协议，传输层除了有。传输层之间的数据交互是大小不等的数据块，但是。内置的解决方案解决粘包/拆包的问题。
Netty实战：深度解析分包处理与LengthFieldBasedFrameDecoder的运用
最新发布
kiingking的博客
07-19 433
在Netty中，分包（splitting packets）和粘包（sticking packets）问题是网络编程中常见的挑战，特别是在处理基于字节流的协议，如TCP，其中数据可能不会恰好按照消息边界进行传输。Netty通过其强大的编解码器来解决这些问题，特别是针对分包和粘包的处理。
netty 数据分包、组包、粘包处理机制（二）
网络
09-18 3733
(5)  LengthFieldBasedFrameDecoder常用的处理大数据分包传输问题的解决类，先对构造方法LengthFieldBasedFrameDecoder中的参数做以下解释说明“maxFrameLength：解码的帧的最大长度lengthFieldOffset ：长度属性的起始位（偏移位），包中存放有整个大数据包长度的字节，这段字节的其实位置lengthFieldLength：长
实例：Netty 处理 TCP协议数据分包问题
Heaven Wang 的专栏
06-25 1万+
我们知道通过TCP协议发送接收数据时，如果数据过大，接受到的数据会是分包的，比如：                                   +-----+-----+-----+          发送数据是： | ABC | DEF | GHI |                             +-----+-----+-----+          而我们想接受到
示例：Netty 处理 TCP数据分包协议
weixin_34159110的博客
08-24 293
一个、Netty解决TCP协议的数据分包的想法 我们知道通过TCP协议发送接收数据时，假设数据过大。接收到的数据会是分包的。比方：                                     +-----+-----+-----+          发送数据是： | ABC | DEF | GHI |                           ...
Netty解决TCP的粘包和分包（一）
weixin_34034261的博客
07-29 1012
2019独角兽企业重金招聘Python工程师标准>>> ...
Netty--TCP--实例
IT利刃出鞘的博客
04-20 736
其他网址 Netty实现简单的Socket通讯_Touch-CSDN博客_netty socket通信JAVA 网络编程(6) Netty TCP 示例_kkgbn的博客-CSDN博客_java netty tcpNetty简单示例----客户端与服务器通信_wangshuang1631的博客-CSDN博客_netty客户端和服务器端功能Netty 实现TCP群聊系统_mister_Wei的博客-CSDN博客 ...
[netty]--最通用TCP黏包解决方案：LengthFieldBasedFrameDecoder和LengthFieldPrepender
热门推荐
惜暮
02-19 3万+
前面已经说过： TCP以流的方式进行数据传输，上层应用协议为了对消息进行区分，往往采用如下4种方式。 （1）消息长度固定：累计读取到固定长度为LENGTH之后就认为读取到了一个完整的消息。然后将计数器复位，重新开始读下一个数据报文。 （2）回车换行符作为消息结束符：在文本协议中应用比较广泛。 （3）将特殊的分隔符作为消息的结束标志，回车换行符就是一种特殊的结...
TCP粘包和拆包、编码解码器
JinXYan的博客
04-30 2097
在进行Netty学习时，发现，如果客户端连续不断的向服务端发送数据包时，服务端接收的数据会出现两个数据包粘在一起的情况，这就是TCP协议中经常会遇到的粘包以及拆包的问题。 我们都知道TCP属于传输层的协议，传输层除了有TCP协议外还有UDP协议。那么UDP是否会发生粘包或拆包的现象呢？答案是不会。UDP是基于报文发送的，从UDP的帧结构可以看出，在UDP首部采用了...
netty搭建tcp服务，粘拆包解决
05-10
netty搭建tcp服务，并以相应的编码解决粘包，拆包问题
netty 数据分包、组包、粘包处理机制(部分)1
08-04
netty 数据分包、组包、粘包处理机制(部分)1
netty-server中采用的分包拆包源码，java开发用于实战项目
02-27
@Component public class RabbitmqConfig { private final static String message = "web.socket.message"; private final static String messages = "send.socket.message"; @Bean public Queue queueMessage() { return new Queue(RabbitmqConfig.message); } @Bean public Queue queueMessages() { return new Queue(RabbitmqConfig.messages); } @Bean TopicExchange exchange() { return new TopicExchange("exchange"); } @Bean Binding bindingExchangeMessage(Queue queueMessage, TopicExchange exchange) { return BindingBuilder.bind(queueMessage).to(exchange).with("web.#"); } @Bean Binding bindingExchangeMessages(Queue queueMessages, TopicExchange exchange) { return BindingBuilder.bind(queueMessages).to(exchange).with("send.#"); } } ServerBootstrap bootstrap = new ServerBootstrap() .group(bossGroup, workGroup) .channel(NioServerSocketChannel.class) .childHandler(new ServerChannelInitializer()) .localAddress(socketAddress) //设置队列大小 .option(ChannelOption.SO_BACKLOG, 1024) // 两小时内没有数据的通信时,TCP会自动发送一个活动探测数据报文 .childOption(ChannelOption.SO_KEEPALIVE, true); //绑定端口,开始接收进来的连接 完整代码，下载有详细说明，使用于长报文通讯，将报文长度截取一定字节发送，便于网速传输中丢包
netty快速入门教程12集 共12集
07-16
解决粘包和分包的问题通常有以下策略： 1. **定义固定长度的报文头**：每个数据包都以固定长度的头部信息开始，头部包含数据的长度，这样接收端可以根据头部信息得知数据的边界。 2. **消息分隔符**：在数据中插入...
实例：Netty 处理TCP协议数据分包问题
wjxbj的博客
11-24 455
一.Netty解决TCP协议数据分包问题思路         我们知道通过TCP协议发送接收数据时，如果数据过大，接收到的数据会是分包的，比如：                             +-----+-----+-----+          发送数据是： | ABC | DEF | GHI |                             +-----+---...
Netty粘包分包分析
蹊源的奇思妙想的博客
07-07 1898
粘包分包分析 消息如何在管道中流通？ 一个管道中存在多个Handler(事件处理器)，消息在通道中通过Handler以事件的形式进行传递。 handler往下传递对象的方法是:sendUpstream(event) 粘包现象：两个数据包连在一起，导致无法区分。 分包现象：一个数据包中的数据被间隔。 粘包和分包出现的原因是：没有一个稳定数据结构。 FraneDecoder Netty借助继承f...
Netty学习7TCP实例解析
DXH9701的博客
12-22 1554
说明 上一章将自己学习 netty 的Demo放了上去. 这里我们对照着代码分析一下 Netty 背后的东西 服务端 EventNioLoopGroup 时服务端和客户端的本质. 用来使用在客户端和服务端通信 用在服务端,接收客户端的消息.进行事件的处理. NioEventLoopGroup BossGroup 和 WorkerGroup:是俩个线程组. 都含有子线程(NioEventLoo...
Netty学习6之TCP实例
DXH9701的博客
12-22 1467
实践 创建项目 使用了Springboot来创建.毕竟好多开箱即用的东东.用着很舒服. 创建界面必选一个框架.只选了基础的Lombok. 不写getter和setter方法真的爽很多 导入jar包 Netty是在B站学习的.而那个老师的jar 是 下载下来手动导入的.emmm. 编写服务端程序 编写客户端程序 分析Netty程序 ...
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值