Netty 粘包、拆包解决示例

最新推荐文章于 2024-07-14 02:22:03 发布
最新推荐文章于 2024-07-14 02:22:03 发布
阅读量699 收藏
点赞数
分类专栏： 网络编程 文章标签： 网络编程
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/hq0556/article/details/70820202
版权

Netty是一个高性能、异步事件驱动的NIO框架，它提供了对TCP、UDP和文件传输的支持，作为一个异步NIO框架，Netty的所有IO操作都是异步非阻塞的，通过Future-Listener机制，用户可以方便的主动获取或者通过通知机制获得IO操作结果。

作为当前最流行的NIO框架，Netty在互联网领域、大数据分布式计算领域、游戏行业、通信行业等获得了广泛的应用，一些业界著名的开源组件也基于Netty的NIO框架构建。

Netty示例

public class NettyServer {

    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 ChannelInitializer<SocketChannel>() {
                        @Override
                        protected void initChannel(SocketChannel ch) throws Exception {
                            ch.pipeline().addLast(new NettyServerHandler());
                        }
                    });
            // 绑定端口，同步等待成功
            ChannelFuture f = b.bind(port).sync();

            // 等待服务端监听端口关闭
            f.channel().closeFuture().sync();
        } finally {
            // 优雅退出，释放线程池资源
            bossGroup.shutdownGracefully();
            workerGroup.shutdownGracefully();
        }
    }

    /**
     * @param args
     * @throws Exception
     */
    public static void main(String[] args) throws Exception {
        int port = 8080;
        new NettyServer().bind(port);
    }
}
public class NettyServerHandler extends ChannelHandlerAdapter {

    @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("The time server receive order : " + body);
        String currentTime = "heqing".equalsIgnoreCase(body) ? new java.util.Date(
                System.currentTimeMillis()).toString() : "BAD ORDER";
        ByteBuf resp = Unpooled.copiedBuffer(currentTime.getBytes());
        ctx.write(resp);
    }

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

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

    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
                        public void initChannel(SocketChannel ch) throws Exception {
                            ch.pipeline().addLast(new NettyClientHandler());
                        }
                    });

            // 发起异步连接操作
            ChannelFuture f = b.connect(host, port).sync();

            // 当代客户端链路关闭
            f.channel().closeFuture().sync();
        } finally {
            // 优雅退出，释放NIO线程组
            group.shutdownGracefully();
        }
    }

    /**
     * @param args
     * @throws Exception
     */
    public static void main(String[] args) throws Exception {
        int port = 8080;
        new NettyClient().connect(port, "127.0.0.1");
    }
}
public class NettyClientHandler extends ChannelHandlerAdapter {

    private static final Logger logger = Logger.getLogger(NettyClientHandler.class.getName());

    private final ByteBuf firstMessage;

    /**
     * Creates a client-side handler.
     */
    public NettyClientHandler() {
        byte[] req = "heqing".getBytes();
        firstMessage = Unpooled.buffer(req.length);
        firstMessage.writeBytes(req);
    }

    @Override
    public void channelActive(ChannelHandlerContext ctx) {
        ctx.writeAndFlush(firstMessage);
    }

    @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);
    }

    @Override
    public void exceptionCaught(ChannelHandlerContext ctx, Throwable cause) {
        // 释放资源
        logger.warning("Unexpected exception from downstream : "+ cause.getMessage());
        ctx.close();
    }
}

粘包、拆包

public class PacketServer {

    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 ChannelInitializer<SocketChannel>() {
                        protected void initChannel(SocketChannel ch) throws Exception {
                            ch.pipeline().addLast(new LineBasedFrameDecoder(1024)); //解决粘包拆包
                            ch.pipeline().addLast(new StringDecoder());
                            ch.pipeline().addLast(new PacketServerHandler());
                        }
                    });
            // 绑定端口，同步等待成功
            ChannelFuture f = b.bind(port).sync();

            // 等待服务端监听端口关闭
            f.channel().closeFuture().sync();
        } finally {
            // 优雅退出，释放线程池资源
            bossGroup.shutdownGracefully();
            workerGroup.shutdownGracefully();
        }
    }

    /**
     * @param args
     * @throws Exception
     */
    public static void main(String[] args) throws Exception {
        int port = 8080;
        new PacketServer().bind(port);
    }
}
public class PacketServerHandler extends ChannelHandlerAdapter {

    private int counter;

    @Override
    public void channelRead(ChannelHandlerContext ctx, Object msg)
            throws Exception {
        String body = (String) msg;
        System.out.println("The time server receive order : " + body
                + " ; the counter is : " + ++counter);
        String currentTime = "heqing".equalsIgnoreCase(body) ? new java.util.Date(
                System.currentTimeMillis()).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) {
        ctx.close();
    }
}
public class PacketClient {

    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
                        public void initChannel(SocketChannel ch) throws Exception {
                            ch.pipeline().addLast(new LineBasedFrameDecoder(1024)); //解决粘包拆包
                            ch.pipeline().addLast(new StringDecoder());
                            ch.pipeline().addLast(new PacketClientHandler());
                        }
                    });

            // 发起异步连接操作
            ChannelFuture f = b.connect(host, port).sync();

            // 当代客户端链路关闭
            f.channel().closeFuture().sync();
        } finally {
            // 优雅退出，释放NIO线程组
            group.shutdownGracefully();
        }
    }

    /**
     * @param args
     * @throws Exception
     */
    public static void main(String[] args) throws Exception {
        int port = 8080;
        new PacketClient().connect(port, "127.0.0.1");
    }
}
public class PacketClientHandler extends ChannelHandlerAdapter {

    private static final Logger logger = Logger.getLogger(PacketClientHandler.class.getName());
    private int counter;
    private byte[] req;

    public PacketClientHandler() {
        req = ("heqing" + System.getProperty("line.separator")).getBytes();
    }

    @Override
    public void channelActive(ChannelHandlerContext ctx) {
        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) {
        // 释放资源
        logger.warning("Unexpected exception from downstream : "+ cause.getMessage());
        ctx.close();
    }
}

分隔符（DelimiterBasedFrameDecoder）

public class DelimiterServer {

    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, 100)
                .handler(new LoggingHandler(LogLevel.INFO))
                .childHandler(new ChannelInitializer<SocketChannel>() {
                    @Override
                    public void initChannel(SocketChannel ch) throws Exception {
                        ByteBuf delimiter = Unpooled.copiedBuffer("$_".getBytes());
                        ch.pipeline().addLast(new DelimiterBasedFrameDecoder(1024,delimiter));
                        ch.pipeline().addLast(new StringDecoder());
                        ch.pipeline().addLast(new DelimiterServerHandler());
                    }
                });

            // 绑定端口，同步等待成功
            ChannelFuture f = b.bind(port).sync();

            // 等待服务端监听端口关闭
            f.channel().closeFuture().sync();
        } finally {
            // 优雅退出，释放线程池资源
            bossGroup.shutdownGracefully();
            workerGroup.shutdownGracefully();
        }
    }

    public static void main(String[] args) throws Exception {
        int port = 8080;
        new DelimiterServer().bind(port);
    }
}
@Sharable
public class DelimiterServerHandler extends ChannelHandlerAdapter {

    int counter = 0;

    @Override
    public void channelRead(ChannelHandlerContext ctx, Object msg) throws Exception {
        String body = (String) msg;
        System.out.println("This is " + (++counter) + " times receive client : ["+ body + "]");
        body += "#_";
        ByteBuf echo = Unpooled.copiedBuffer(body.getBytes());
        ctx.writeAndFlush(echo);
    }

    @Override
    public void exceptionCaught(ChannelHandlerContext ctx, Throwable cause) {
        cause.printStackTrace();
        ctx.close();// 发生异常，关闭链路
    }
}
public class DelimiterClient {

    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
                        public void initChannel(SocketChannel ch) throws Exception {
                            ByteBuf delimiter = Unpooled.copiedBuffer("#_".getBytes());
                            ch.pipeline().addLast(new DelimiterBasedFrameDecoder(1024,delimiter));
                            ch.pipeline().addLast(new StringDecoder());
                            ch.pipeline().addLast(new DelimiterClientHandler());
                        }
                    });

            // 发起异步连接操作
            ChannelFuture f = b.connect(host, port).sync();

            // 当代客户端链路关闭
            f.channel().closeFuture().sync();
        } finally {
            // 优雅退出，释放NIO线程组
            group.shutdownGracefully();
        }
    }

    /**
     * @param args
     * @throws Exception
     */
    public static void main(String[] args) throws Exception {
        int port = 8080;
        new DelimiterClient().connect(port, "127.0.0.1");
    }
}
public class DelimiterClientHandler extends ChannelHandlerAdapter {

    private int counter;

    static final String ECHO_REQ = "heqing.$_";

    @Override
    public void channelActive(ChannelHandlerContext ctx) {
        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("This is " + (++counter) + " times receive server : ["+ msg + "]");
    }

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

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

定长解码器(FixedLengthFrameDecoder)

public class FixedLenServer {
    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, 100)
                    .handler(new LoggingHandler(LogLevel.INFO))
                    .childHandler(new ChannelInitializer<SocketChannel>() {
                        @Override
                        public void initChannel(SocketChannel ch) throws Exception {
                            ch.pipeline().addLast(new FixedLengthFrameDecoder(7));
                            ch.pipeline().addLast(new StringDecoder());
                            ch.pipeline().addLast(new FixedLenServerHandler());
                        }
                    });

            // 绑定端口，同步等待成功
            ChannelFuture f = b.bind(port).sync();

            // 等待服务端监听端口关闭
            f.channel().closeFuture().sync();
        } finally {
            // 优雅退出，释放线程池资源
            bossGroup.shutdownGracefully();
            workerGroup.shutdownGracefully();
        }
    }

    public static void main(String[] args) throws Exception {
        int port = 8080;
        if (args != null && args.length > 0) {
            try {
                port = Integer.valueOf(args[0]);
            } catch (NumberFormatException e) {
                // 采用默认值
            }
        }
        new FixedLenServer().bind(port);
    }
}
@Sharable
public class FixedLenServerHandler extends ChannelHandlerAdapter {

    @Override
    public void channelRead(ChannelHandlerContext ctx, Object msg) throws Exception {
        System.out.println("Receive client : [" + msg + "]");
        String body = "shanghai";
        ByteBuf echo = Unpooled.copiedBuffer(body.getBytes());
        ctx.writeAndFlush(echo);
    }

    @Override
    public void exceptionCaught(ChannelHandlerContext ctx, Throwable cause) {
        cause.printStackTrace();
        ctx.close();// 发生异常，关闭链路
    }
}
public class FixedLenClient {

    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
                        public void initChannel(SocketChannel ch) throws Exception {
                            ch.pipeline().addLast(new FixedLengthFrameDecoder(8));
                            ch.pipeline().addLast(new StringDecoder());
                            ch.pipeline().addLast(new FixedLenClientHandler());
                        }
                    });

            // 发起异步连接操作
            ChannelFuture f = b.connect(host, port).sync();

            // 当代客户端链路关闭
            f.channel().closeFuture().sync();
        } finally {
            // 优雅退出，释放NIO线程组
            group.shutdownGracefully();
        }
    }

    /**
     * @param args
     * @throws Exception
     */
    public static void main(String[] args) throws Exception {
        int port = 8080;
        new FixedLenClient().connect(port, "127.0.0.1");
    }
}
public class FixedLenClientHandler extends ChannelHandlerAdapter {

    private int counter;

    static final String ECHO_REQ = "heqing.";

    @Override
    public void channelActive(ChannelHandlerContext ctx) {
        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("This is " + (++counter) + " times receive server : ["+ msg + "]");
    }

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

    @Override
    public void exceptionCaught(ChannelHandlerContext ctx, Throwable cause) {
        cause.printStackTrace();
        ctx.close();
    }
}
贺家小白
关注
专栏目录
Netty精粹之TCP粘包拆包问题
09-27
什么是粘包拆包，为什么发生拆包粘包问题，如何处理拆包粘包问题
Netty 拆包粘包和服务启动流程分析
weixin_33949359的博客
01-29 95
Netty 拆包粘包和服务启动流程分析 通过本章学习，笔者希望你能掌握EventLoopGroup的工作流程，ServerBootstrap的启动流程，ChannelPipeline是如何操作管理Channel。只有清楚这些，才能更好的了解和使用Netty。还在等什么，快来学习吧！ 知识结构图： 技术：Netty，拆包粘包，服务启动流程...
Netty_03_ByteBuf和网络中拆包粘包问题及其解决
最新发布
weixin_34829480的博客
07-14 34
文章目录一、前言二、ByteBuf（Netty API中定义的数据类型）2.1 ByteBuf2.1.1 ByteBuf创建的方法有两种2.1.2 ByteBuf的存储结构2.1.3 ByteBuf中常用的方法APIReader相关方法Write相关方法Write可能导致扩容2.2 ByteBuf代码(演示读写指针移动和...
Netty 解决粘包和拆包问题的四种方案
weixin_44749255的博客
02-29 3777
Netty 解决粘包和拆包问题的四种方案
Netty中粘包和拆包的解决方案
一个无限死循环的博客
10-10 716
粘包和拆包是TCP网络编程中不可避免的，无论是服务端还是客户端，当我们读取或者发送消息的时候，都需要考虑TCP底层的粘包/拆包机制。 TCP粘包和拆包 TCP是个“流”协议，所谓流，就是没有界限的一串数据。TCP底层并不了解上层业务数据的具体含义，它会根据TCP缓冲区的实际情况进行包的划分，所以在业务上认为，一个完整的包可能会被TCP拆分成多个包进行发送，也有可能把多个小的包封装成一个大的数据包发...
Netty--原理--TCP--粘包与拆包
IT利刃出鞘的博客
06-01 1403
本文介绍Netty是如何解决TCP的粘包与拆包问题的。
Netty粘包拆包问题解决方案
08-18
Netty 粘包拆包问题解决方案 Netty 是一个基于 Java 的网络编程框架，它提供了一个便捷的方式来处理网络数据的读写操作。然而，在使用 Netty 进行网络编程时，经常会遇到粘包和拆包的问题。所谓粘包和拆包，就是指...
netty拆包粘包解决方案示例
07-28
本文将深入探讨Netty中解决拆包粘包问题的策略，以及客户端断线重连的实现方式。 首先，我们需要理解什么是“拆包”和“粘包”。在TCP/IP通信中，由于TCP协议的流式传输特性，数据可能会被分片或者合并，这就可能...
使用Netty解决TCP粘包和拆包问题过程详解
08-25
下面是一个使用Netty解决TCP粘包和拆包问题的示例代码： ```java public class PrintServer { public void bind(int port) throws Exception { // 配置服务端的NIO线程组 EventLoopGroup bossGroup = new ...
基于 Netty 的通信组件如何解决粘包拆包问题
m0_71777195的博客
06-06 1010
这节课给大家介绍了粘包拆包的解决方案。首先给大家介绍了粘包拆包的场景。然后，给大家介绍了通过设定一个完整语义的字节流长度来避免粘包拆包的问题。在生产环境上我还是建议大家用设定字节流长度方法来解决拆包粘包的问题，因为这个方案会更加的通用，而且 4 个字节长度的字节流长度也不会浪费太多流量。
Netty的入门-拆包和粘包的处理
Eric_LanOu的博客
07-08 402
由于是流，拆包和粘包是不可避免的，产生的原因有：1、应用程序write的字节大小大于套接字缓冲区大小；2、进行MMS大小的tcp分段；3、以太网帧的playload大于MTU进行IP分片 解决策略有：1、消息定长；2、包尾添加回车符进行分割；3、将消息分为消息头和消息尾，消息头包含表示消息总长度的字段。 LineBaseFrameDecoder
Netty粘包拆包
qq_41931364的博客
01-03 442
Netty粘包拆包1、什么是粘包拆包？2、解决方案3、代码示例3.1、MyClient3.2、MyClientHandler3.3、MyServer3.4、MyServerHandler3.5、MyMessageDecoder3.6、MyMessageEncoder3.7、MyMessageProtocol 1、什么是粘包拆包？ 粘包拆包一般是发生在TCP协议层的，TCP作为传输层一般不知道上层（这里指的是我们的代码业务层）数据的具体含义，它会根据TCP缓冲区 的实际情况进行数据包的划分，所以在业务上认为
Netty中的粘包拆包
CAUC_lin的博客
09-02 481
粘包和拆包是TCP网络编程中不可避免的，无论是服务端还是客户端，当我们读取或者发送消息 的时候，都需要考虑TCP底层的粘包/拆包机制。TCP传输会根据TCP缓冲区的实际情况进行包的划分，所以在业务上认为，一个完整的包可能会被TCP拆分 成多个包进行发送，也有可能把多个小的包封装成一个大的数据包发送，这就是所谓的TCP粘包和拆包 问题。服务端分两次读取到了两个独立的数据包，分别是P1和P2，没有粘包和拆包；服务端一次接收到了两个数据包，P1和P2粘合在一起，被称为TCP粘包；
Netty中的粘包问题处理
全栈工程师，热爱编程，喜欢探索各种技术栈。分享前端、后端、数据库等技术学习心得，以及在项目开发中的实践经验。
05-24 417
根据应用场景和需求设计自定义协议，可以更加灵活和高效地解决粘包问题。例如，在消息头部添加标识字段、校验字段等信息。粘包问题是网络编程中常见的问题，尤其是在使用TCP协议时。Netty提供了多种解决粘包和拆包问题的方案，包括定长消息、使用分隔符、使用长度字段和自定义协议。每种方案都有其适用的场景和优缺点，开发者需要根据实际需求选择合适的方案。通过示例代码，我们展示了如何在Netty中实现这些方案，并对每种方案的原理和实现进行了详细介绍。希望本文能帮助读者更好地理解和解决Netty中的粘包问题。
Netty粘包/拆包解决方案
凌霄的专栏
07-09 318
TCP粘包/拆包问题  TCP粘包和拆包示意图如下： TCP粘包/拆包 假设客户端分别发送了两个数据包D1和D2给服务端，由于服务端一次读到的字节数是不确定的，故可能存在以下4中情况.  1. 服务端分两次读取到了两个独立的数据包，分别是D1和D2,没有粘包和拆包  2. 服务端一次收到了连个数据包，D1和D2粘合在一起，被称为TCP粘包  3. 服务端分别两次读取到了两...
netty中的粘包和拆包问题处理
zxh87的专栏
06-12 1143
1、tcp粘包和拆包问题说明 2、tcp粘包和拆包发生的原因 3、粘包问题的解决策略
Netty粘包与拆包解决方案（一）
木子陈的博客
03-07 3890
在RPC框架中，粘包与拆包问题是必须解决的一个问题，因为RPC框架中，各个微服务相互之间都是维护一个TCP长连接，比如dubbo就是一个全双工的长连接。由于微服务往对方发送消息的时候，所有的请求都是使用的同一个连接，这样就会产生粘包和拆包的问题，就会出现丢包的情况，Netty提供了更好的解决方案。 1、粘包和拆包 产生粘包和拆包的主要原因是：操作系统在发送TCP数据包的时候，底层会有一个缓冲区，例如1024字节大小，如果一次请求发送的数据量比较小，没达到缓存区大小，TCP则会将多个请求合并为同一个请求进
Netty工作笔记0082---TCP粘包拆包实例演示
添柴程序猿的专栏
09-25 320
技术交流QQ群【JAVA,C++,Python,.NET,BigData,AI】：170933152 还是用一起的client和server.然后自己写一个 initializer 这里发送10个hello,server 给服务器端 然后服务器收到数据,以后,打印出来,然后统计一下,当前是接收的第几次,也就是说,咱们要看一下 这个服务器收到,客户端的10次发送的消息,服务器这边是不是也是10次?收到的,还是怎么样. 服务器收到消息打印,然后发送一个随机的id,给客户端
Netty中的粘包、拆包与丢包问题及其解决方案详解
微笑听雨
06-19 5077
在Netty中，通过使用合适的解码器（如定长解码器、换行符解码器、分隔符解码器和长度字段解码器）可以有效解决粘包和拆包问题。同时，结合TCP的重传机制和应用层的重传策略，可以有效地减少丢包现象，确保数据传输的可靠性。选择合适的方案需要根据具体的应用场景和协议要求来定。
Netty 解决粘包拆包
07-25
Netty 是一个高性能的网络编程框架，它提供了许多解决粘包拆包问题的机制。 一种常见的解决粘包拆包问题的方法是使用定长消息或者定界符消息。对于定长消息，发送方在发送数据时固定每个消息的长度，接收方根据固定长度进行拆包。对于定界符消息，发送方在每个消息的结尾添加一个特定的字符或者字符序列作为消息的结束标志，接收方根据结束标志进行拆包。 Netty 提供了多种编解码器，可以方便地实现定长消息和定界符消息的处理。其中，FixedLengthFrameDecoder 是一个定长消息的解码器，它可以根据指定的固定长度对接收到的数据进行拆包。DelimiterBasedFrameDecoder 是一个定界符消息的解码器，它可以根据指定的结束标志对接收到的数据进行拆包。 此外，Netty 还提供了 LengthFieldBasedFrameDecoder 编解码器，它支持消息头部包含长度字段的情况。通过指定长度字段的起始位置、长度以及长度字段的偏移量等参数，可以实现对可变长度消息的拆包。 总之，Netty 提供了多种解决粘包拆包问题的机制和编解码器，开发者可以根据实际需求选择合适的方法来解决粘包拆包问题。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值