netty学习二（解决tcp/udp 粘包，拆包问题）

最新推荐文章于 2024-08-20 11:07:51 发布
最新推荐文章于 2024-08-20 11:07:51 发布
阅读量1.7k 收藏 3
点赞数
分类专栏： netty 文章标签： netty解决tcp粘、拆包问题 LineBasedFrameDecoder StringDecoder FixedLengthFrameDecoder DelimiterBasedFrameDecoder
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/bird_tp/article/details/102525328
版权

在通讯协议中，粘包，拆包是常发生的事情，而netty则很好的给出了三种解决方式，下面分别介绍：

一;利用LineBasedFrameDecoder解决TCP粘包问题

直接上代码，

Client类：
package stickorApartPackageResolveOne.one;

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;

/**
 * @ProjectName: nettyTes
 * @Package: stickorApartPackageResolveOne.one
 * @ClassName: Client
 * @Author: Administrator
 * @Description: ${description}
 * @Date: 2019/10/12 16:48
 * @Version: 1.0
 *  *LineBasedFrameDecoder以换行符为结束标志的解码器，支持携带结束符或者不携带结束符两种解码方式，
 *  * 同时支持配置单行的最大长度。如果连续读取到最大长度后仍然没有发现换行符，
 *  * 就会抛出异常，同时忽略掉之前读到的异常码流。
 *  * StringDecoder的功能非常简单，就是将接收到的对象转换成字符串，
 *  * 然后继续调用后面的handler。LineBasedFrameDecoder+StringDecoder组合就是按行切换的文本解码器，
 *  * 它被设计用来支持TCP的粘包和拆包。
 */
public class Client {

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

    private void connect(int port, String host) {


        EventLoopGroup eventLoopGroup = new NioEventLoopGroup();
        try {
            Bootstrap bst = new Bootstrap();
            bst.group(eventLoopGroup);
            bst.channel(NioSocketChannel.class);
            bst.option(ChannelOption.TCP_NODELAY, true);
            bst.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 ClientHandler());
                }
            });
            ChannelFuture f = bst.connect(host, port).sync();
            f.channel().closeFuture().sync();
        } catch (InterruptedException e) {
            e.printStackTrace();
        } finally {
            eventLoopGroup.shutdownGracefully();
        }
    }
}

ClientHandler类
package stickorApartPackageResolveOne.one;

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

import java.util.logging.Logger;

/**
 * @ProjectName: nettyTes
 * @Package: stickorApartPackageResolveOne.one
 * @ClassName: ClientHandler
 * @Author: Administrator
 * @Description: ${description}
 * @Date: 2019/10/12 17:03
 * @Version: 1.0
 */
public class ClientHandler extends ChannelHandlerAdapter {

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

    private int counter;
    String req = ("QUERY TIME ORDER" + System.getProperty("line.separator")); 

   

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

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

 

package stickorApartPackageResolveOne.one;

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;

/**
 * @ProjectName: nettyTes
 * @Package: stickorApartPackageResolveOne
 * @ClassName: Timeserver
 * @Author: Administrator
 * @Description: ${description}
 * @Date: 2019/10/12 16:03
 * @Version: 1.0
 */
public class Server {

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

    private void bind(int port) {

        EventLoopGroup eventLoopGroup = new NioEventLoopGroup();
        EventLoopGroup eventLoopGroup1 = new NioEventLoopGroup();

        try {
            ServerBootstrap sbt = new ServerBootstrap();
            sbt.group(eventLoopGroup, eventLoopGroup1);
            sbt.channel(NioServerSocketChannel.class);
            sbt.option(ChannelOption.SO_BACKLOG, 1024);
            sbt.childHandler(new ChannelInitializer<SocketChannel>() {
                @Override
                protected void initChannel(SocketChannel socketChannel) throws Exception {
                    //利用LineBasedFrameDecoder解决TCP粘包问题
                    socketChannel.pipeline().addLast(new LineBasedFrameDecoder(1024));
                    socketChannel.pipeline().addLast(new StringDecoder());
                    socketChannel.pipeline().addLast(new ServerHandler());
                }
            });
            ChannelFuture cf = sbt.bind(port).sync();
            cf.channel().closeFuture().sync();
        } catch (InterruptedException e) {
            e.printStackTrace();
        } finally {
            eventLoopGroup.shutdownGracefully();
            eventLoopGroup1.shutdownGracefully();
        }

    }
}

ServerHandler类
package stickorApartPackageResolveOne.one;

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

/**
 * @ProjectName: nettyTes
 * @Package: stickorApartPackageResolveOne
 * @ClassName: ServerHandler
 * @Author: Administrator
 * @Description: ${description}
 * @Date: 2019/10/12 16:20
 * @Version: 1.0
 */
public class ServerHandler extends ChannelHandlerAdapter {

    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 = "QUERY TIME ORDER".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) throws Exception {
        ctx.close();
    }


}

 

先直接上结果：

客户端：

服务端：

 

 LineBasedFrameDecoder和StringDecoder的原理分析


LineBasedFrameDecoder的工作原理是它依次遍历ByteBuf中的可读字节，判断看是否有＼n或者以\r\n气如果有，就以此位置为结束位置，从可读索引到结束位置区间的字节就组成了一行。它是以换行符为结束标志的解码器，支持携带结束符或者不携带结束符两种解码方式，同时支持配置单行的最大长度。如果连续读取到最大长度后仍然没有发现换行符，就会抛出异常，同时忽略掉之前读到的异常码流。
StringDecoder的功能非常简单，就是将接收到的对象转换成字符串，然后继续调用后面的handler。LineBasedFrameDecoder+StringDecoder组合就是按行切换的文本解码器，它被设计用来支持TCP的粘包和拆包。

 

二、利用DelimiterBasedFrameDecoder

Client1类：
package stickorApartPackageResolve.two;

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.string.StringDecoder;

/**
 * @ProjectName: nettyTes
 * @Package: stickorApartPackageResolve.two
 * @ClassName: Client1
 * @Author: Administrator
 * @Description: ${description}
 * @Date: 2019/10/14 9:18
 * @Version: 1.0
 */
public class Client1 {

    public static void main(String[] args) {

        int port = 8080;
        String host = "127.0.0.1";
        new Client1().connect(host,port);

    }

    private void connect(String host, int port) {

        EventLoopGroup eventLoopGroup = new NioEventLoopGroup();

        try {
            Bootstrap bs = new Bootstrap();
            bs.group(eventLoopGroup);
            bs.channel(NioSocketChannel.class);
            bs.option(ChannelOption.TCP_NODELAY, true);
            bs.handler(new ChannelInitializer<SocketChannel>() {
                @Override
                protected void initChannel(SocketChannel socketChannel) throws Exception {
                    ByteBuf buffer = Unpooled.copiedBuffer("$_".getBytes());
                    socketChannel.pipeline().addLast(new DelimiterBasedFrameDecoder(1024,buffer));
                    socketChannel.pipeline().addLast(new StringDecoder());
                    socketChannel.pipeline().addLast(new Client1Handler());
                }
            });
            ChannelFuture f = bs.connect(host,port).sync();
            f.channel().closeFuture().sync();
        } catch (InterruptedException e) {
            e.printStackTrace();
        } finally {
            eventLoopGroup.shutdownGracefully();
        }
    }
}

Client1Handler类

package stickorApartPackageResolve.two;

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

/**
 * @ProjectName: nettyTes
 * @Package: stickorApartPackageResolve.two
 * @ClassName: Client1Handler
 * @Author: Administrator
 * @Description: ${description}
 * @Date: 2019/10/14 14:35
 * @Version: 1.0
 */
public class Client1Handler extends ChannelHandlerAdapter {

    private int counter;
    private String req = "Hi,XXX! Welcome to netty.$_";

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

    @Override
    public void channelRead(ChannelHandlerContext ctx, Object msg){
        String body = (String) msg;
        System.out.println("this is : " + ++counter + "time recive " + body);
    }

    @Override
    public void exceptionCaught(ChannelHandlerContext ctx, Throwable cause) {
        // 释放资源
        ctx.close();
    }
}

Server1类
package stickorApartPackageResolve.two;

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.string.StringDecoder;

/**
 * @ProjectName: nettyTes
 * @Package: stickorApartPackageResolve.two
 * @ClassName: Server1
 * @Author: Administrator
 * @Description: ${description}
 * @Date: 2019/10/14 8:54
 * @Version: 1.0
 */
public class Server1 {
    public static void main(String[] args) {
        int port = 8080;
        new Server1().bind(port);
    }

    private void bind(int port) {
        EventLoopGroup eventLoopGroup = new NioEventLoopGroup();
        EventLoopGroup eventLoopGroup1 = new NioEventLoopGroup();

        try {
            ServerBootstrap sbt = new ServerBootstrap();
            sbt.group(eventLoopGroup,eventLoopGroup1);
            sbt.channel(NioServerSocketChannel.class);
            sbt.option(ChannelOption.SO_BACKLOG, 1024);
            sbt.childHandler(new ChannelInitializer<SocketChannel>() {
                @Override
                protected void initChannel(SocketChannel socketChannel) throws Exception {
                    ByteBuf buffer = Unpooled.copiedBuffer("$_".getBytes());
                    socketChannel.pipeline().addLast(new DelimiterBasedFrameDecoder(1024,buffer));
                    socketChannel.pipeline().addLast(new StringDecoder());
                    socketChannel.pipeline().addLast(new Server1Handler());
                }
            });
            ChannelFuture f = sbt.bind(port).sync();
            f.channel().closeFuture().sync();
        } catch (InterruptedException e) {
            e.printStackTrace();
        }finally {
            eventLoopGroup.shutdownGracefully();
            eventLoopGroup1.shutdownGracefully();
        }
    }
}

 

Server1Handler类
package stickorApartPackageResolve.two;

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

/**
 * @ProjectName: nettyTes
 * @Package: stickorApartPackageResolve.two
 * @ClassName: Server1Handler
 * @Author: Administrator
 * @Description: ${description}
 * @Date: 2019/10/14 9:10
 * @Version: 1.0
 */
public class Server1Handler extends ChannelHandlerAdapter {

    int  counter;

    @Override
    public void channelRead(ChannelHandlerContext ctx, Object msg){
        String body =  (String)msg;
        System.out.println("The time server receive order : "  + body + " ; the counter is : " + ++counter);
        body = body + "$_";
        ByteBuf bf = Unpooled.copiedBuffer(body.getBytes());
        ctx.writeAndFlush(bf);
    }

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

结果：

服务端

客户端

通过对DelimiterBasedFrameDecoder的使用，我们可以自动完成以分隔符作为码流结束标识的消息的解码，

 

三、 FixedLengthFrameDecoder

FixedLengtl1FrameDecoder是固定长度解码器，它能够按照指定的长度对消息进行自动解码，开发者不需要考虑TCP的粘包／拆包问题，非常实用。下面我们通过一个应用实例对其用法进行讲解。

Server1类：
package stickorApartPackageResolve.two;

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.FixedLengthFrameDecoder;
import io.netty.handler.codec.string.StringDecoder;

/**
 * @ProjectName: nettyTes
 * @Package: stickorApartPackageResolve.two
 * @ClassName: Server1
 * @Author: Administrator
 * @Description: ${description}
 * @Date: 2019/10/14 8:54
 * @Version: 1.0
 */
public class Server1 {
    public static void main(String[] args) {
        int port = 8080;
        new Server1().bind(port);
    }

    private void bind(int port) {
        EventLoopGroup eventLoopGroup = new NioEventLoopGroup();
        EventLoopGroup eventLoopGroup1 = new NioEventLoopGroup();

        try {
            ServerBootstrap sbt = new ServerBootstrap();
            sbt.group(eventLoopGroup,eventLoopGroup1);
            sbt.channel(NioServerSocketChannel.class);
            sbt.option(ChannelOption.SO_BACKLOG, 1024);
            sbt.childHandler(new ChannelInitializer<SocketChannel>() {
                @Override
                protected void initChannel(SocketChannel socketChannel) throws Exception {
                    //会按照这里给定的长度对消息进行截取
                    socketChannel.pipeline().addLast(new FixedLengthFrameDecoder(12));
                    socketChannel.pipeline().addLast(new StringDecoder());
                    socketChannel.pipeline().addLast(new Server1Handler());
                }
            });
            ChannelFuture f = sbt.bind(port).sync();
            f.channel().closeFuture().sync();
        } catch (InterruptedException e) {
            e.printStackTrace();
        }finally {
            eventLoopGroup.shutdownGracefully();
            eventLoopGroup1.shutdownGracefully();
        }
    }
}

Server1Handler类：
package stickorApartPackageResolve.two;

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

/**
 * @ProjectName: nettyTes
 * @Package: stickorApartPackageResolve.two
 * @ClassName: Server1Handler
 * @Author: Administrator
 * @Description: ${description}
 * @Date: 2019/10/14 9:10
 * @Version: 1.0
 */
public class Server1Handler extends ChannelHandlerAdapter {

    int  counter;

    @Override
    public void channelRead(ChannelHandlerContext ctx, Object msg){
        String body =  (String)msg;
        System.out.println("The time server receive order : "  + body + " ; the counter is : " + ++counter);
        ByteBuf bf = Unpooled.copiedBuffer(body.getBytes());
        ctx.writeAndFlush(bf);
    }

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

Client1类：
package stickorApartPackageResolve.two;

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.FixedLengthFrameDecoder;
import io.netty.handler.codec.string.StringDecoder;

/**
 * @ProjectName: nettyTes
 * @Package: stickorApartPackageResolve.two
 * @ClassName: Client1
 * @Author: Administrator
 * @Description: ${description}
 * @Date: 2019/10/14 9:18
 * @Version: 1.0
 */
public class Client1 {

    public static void main(String[] args) {

        int port = 8080;
        String host = "127.0.0.1";
        new Client1().connect(host,port);

    }

    private void connect(String host, int port) {

        EventLoopGroup eventLoopGroup = new NioEventLoopGroup();

        try {
            Bootstrap bs = new Bootstrap();
            bs.group(eventLoopGroup);
            bs.channel(NioSocketChannel.class);
            bs.option(ChannelOption.TCP_NODELAY, true);
            bs.handler(new ChannelInitializer<SocketChannel>() {
                @Override
                protected void initChannel(SocketChannel socketChannel) throws Exception {
                    socketChannel.pipeline().addLast(new FixedLengthFrameDecoder(12));
                    socketChannel.pipeline().addLast(new StringDecoder());
                    socketChannel.pipeline().addLast(new Client1Handler());
                }
            });
            ChannelFuture f = bs.connect(host,port).sync();
            f.channel().closeFuture().sync();
        } catch (InterruptedException e) {
            e.printStackTrace();
        } finally {
            eventLoopGroup.shutdownGracefully();
        }
    }
}

Client1Handler类：
package stickorApartPackageResolve.two;

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

/**
 * @ProjectName: nettyTes
 * @Package: stickorApartPackageResolve.two
 * @ClassName: Client1Handler
 * @Author: Administrator
 * @Description: ${description}
 * @Date: 2019/10/14 14:35
 * @Version: 1.0
 */
public class Client1Handler extends ChannelHandlerAdapter {

    private int counter;
    private String req = "Hi!xiaoming!";

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

    @Override
    public void channelRead(ChannelHandlerContext ctx, Object msg){
        String body = (String) msg;
        System.out.println("this is : " + ++counter + "time recive " + body);
    }

    @Override
    public void exceptionCaught(ChannelHandlerContext ctx, Throwable cause) {
        // 释放资源
        ctx.close();
    }
}

结果：

服务端

客户端：

利用FixedLengthFrameDecoder解码器，无论一次接收到多少数据报，它都会按照构造函数中设置的固定长度进行解码，如果是半包消息，FixedLengthFrameDecoder会缓存半包消息并等待下个包到达后进行拼包，直到读取到一个完整的包。

 

 

bird_tp
关注
专栏目录
Netty 教程 – Netty粘包/拆包解决之道
二师兄撒欢之地
03-16 891
通过以上分析，我们清楚了粘包或拆包发生的原因，那么如何解决这个问题呢？数据报文的长度，因此在应用层能很好的将不同的数据报文区分开，从而避免粘包和拆包的问题。需要实现的逻辑主要对应于处理第一个数据包的时候，第一次调用。，用户自己去实现处理粘包、拆包的逻辑还是有一定难度的，的首部没有表示数据长度的字段，基于上面两点，在使用。，这里有不断的数据流入，而我们要做的就是从这个。的都知道，它是属于传输层的协议，传输层除了有。传输层之间的数据交互是大小不等的数据块，但是。内置的解决方案解决粘包/拆包的问题。
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的UDP通信心得
08-30
Netty的UDP通信心得
Netty入门(十)netty粘包拆包原理
weixin_42412601的博客
06-26 944
目录TCP 粘包和拆包基本介绍TCP 粘包和拆包现象实例服务端客户端测试TCP 粘包和拆包解决方案一个具体的实例自定义协议编解码器服务端客户端测试练习自定义协议编解码器服务端修改客户端修改测试 TCP 粘包和拆包基本介绍 由于UDP有消息保护边界，不会发生粘包拆包问题，因此粘包拆包问题只发生在TCP协议中。 TCP是面向连接的，面向流的，提供高可靠性服务。收发两端（客户端和服务器端）都要有一一成对的socket，因此，发送端为了将多个数据包发给接收端，更有效的发给对方，使用了优化方法（Nagle算法）
SpringBoot 集成 Netty 作为服务端常用 TCP/UDP 通讯协议示例
最新发布
Mrqiang9001
08-20 539
文章目录1 摘要2 通讯协议3 核心代码3.1 Netty 服务器3.2 Netty 服务端工具类3.3 Netty 服务处理器3.4 协议请求头封装类4 测试4.1 测试工具4.2 测试数据4.2 测试数据 1 摘要 在 IoT 物联网设备通讯领域，服务端和设备端的通讯通常基于 TCP/UDP 协议，在这些协议的基础上定义自己的私有通讯协议。本文将介绍 SpringBoot 集成 Netty 在服务端常用的TCP、UDP通讯协议示例。 SpringBoot 集成 Netty 作为服务端: SpringBo
Netty5入门学习笔记002-TCP粘包/拆包问题的解决之道（上）
weixin_33693070的博客
12-17 122
2019独角兽企业重金招聘Python工程师标准>>> ...
Netty解决粘包和拆包问题的四种方案
勇往直前的专栏
07-10 273
在RPC框架中，粘包和拆包问题是必须解决一个问题，因为RPC框架中，各个微服务相互之间都是维系了一个TCP长连接，比如dubbo就是一个全双工的长连接。由于微服务往对方发送信息的时候，所有的请求都是使用的同一个连接，这样就会产生粘包和拆包的问题。本文首先会对粘包和拆包问题进行描述，然后介绍其常用的解决方案，最后会对Netty提供的几种解决方案进行讲解。这里说明一下，由于oschina将“jie ma qi”认定为敏感文字，因而本文统一使用“解码一器”表示该含义 1. 粘包和拆包 产生粘包和拆包问题的..
Netty笔记——粘包和拆包
qq_41157876的博客
12-17 140
粘包和拆包 发送原因 业界解决策略 Netty提供的策略 LineBasedFrameDecoder DelimiterBasedFrameDecoder FixLengthFrameDecoder 问题说明 假设客户端分别发送了两个数据包D1和D2给服务端，由于服务端一次读取到字节数是不确定的，故可能存在以下四种情况： 1. 服务端分两次读取到了两个独立的数据包，分别是D1和D2，没有粘包和拆包 2. 服务端一次接受到了两个数据包，D1.
Netty 解决粘包和拆包问题的四种方案
weixin_44749255的博客
02-29 3725
Netty 解决粘包和拆包问题的四种方案
netty解析报文，解决粘包拆包
03-25
注：下载前请查看本人博客文章，看是否...里面包含模拟TCP客户端发送报文工具，硬件厂商提供的协议，服务端（springboot+netty）解析报文源码，源码里整合了redis，不需要可自行删除，如有需要客户端代码，可联系我。
Netty学习（二）- TCP粘包/拆包
noaman_wgs的博客
07-27 643
一、TCP 粘包/拆包介绍 1、什么是粘包、拆包 首先只有TCP数据传输才会存在是粘包、拆包现象。 假设客户端分别发送两个数据包D1和D2给服务器，由于TCP是面向流的协议，TCP把客户端传过来的数据看成是一连串的无结构的字节流，且服务端一次读取到的数据是不确定的，所以可能会出现下面几种情况。 （1）服务端分两次接收到D1和D2数据包，没有发生粘包/拆包。 （2）服务端一次接收了两个数据包，D1...
unity实现Socket通讯（内含tcp粘包/拆包解决）
12-25
本教程将深入探讨如何在Unity中实现Socket通信，包括TCP连接、粘包/拆包问题的解决方案。 一、TCP连接基础 TCP（Transmission Control Protocol）是一种面向连接的、可靠的、基于字节流的传输层通信协议。在Unity中...
通过大量实战案例分解Netty中是如何解决拆包黏包问题的?
跟着Mic学架构
11-14 666
TCP传输协议是基于数据流传输的，而基于流化的数据是没有界限的，当客户端向服务端发送数据时，可能会把一个完整的数据报文拆分成多个小报文进行发送，也可能将多个报文合并成一个大报文进行发送。 在这样的情况下，有可能会出现图3-1所示的情况。 服务端恰巧读到了两个完整的数据包 A 和 B，没有出现拆包/粘包问题； 服务端接收到 A 和 B 粘在一起的数据包，服务端需要解析出 A 和 B； 服务端收到完整的 A 和 B 的一部分数据包 B-1，服务端需要解析出完整的 A，并等待读取完整的 B 数据包； 服务端接.
Netty之UDP丢包解决
weixin_30375247的博客
01-05 1660
程序背景 程序是Java编写，基于Netty框架写的客户端及服务端。 现象 客户端大数据量持续发UDP数据，作为UDP服务器出现了部分数据频繁丢失触发程序自身重传逻辑。 通过GC日志对比发现丢包的时间点偶有处于Full GC，说明Java程序接收间歇性stop world的不是根因。 观察Udp的dump 通过watch -n 1 -d 'cat /proc/net/udp >> /u...
使用netty4.x 编写UDP服务器遇到的狗血问题
weixin_33681778的博客
07-16 772
2019独角兽企业重金招聘Python工程师标准>>> ...
Netty 学习笔记（3） ------ ChannelPipeline 和 ChannelHandler
05-20 336
ChannelPipeline通过责任链设计模式组织逻辑代码（ChannelHandler）,ChannelHander就如同Servlet的Filter一样一层层处理Channel的读写数据。 ChannelPipeline和ChannelHander的构成 Channel Netty框架中，一个连接对应一个Channel ChannelPipeline 一个Channel绑定一条...
网络编程Netty入门（二）
狐言
04-23 314
111
Java 使用 Netty DefaultFullHttpRequest 实现Post发送数据包的功能
xbt312的专栏
08-20 7307
// 向SQLMAPAPI传送开始测试的指令 NioEventLoopGroup workerGroup = new NioEventLoopGroup(); try { Bootstrap bootstrap = new Bootstrap(); bootstrap.group(workerGroup).channel(NioSocketChannel.class).o...
基于netty实现redis服务（解析redis协议密码验证）
weixin_43241706的博客
02-26 2703
最近使用redis缓存，但是不允许客户端直接连接redis服务器，需要模拟redis的服务器，实现redis的get\set\del\auth基础功能。 网上该场景的解决方案不多，文章如有问题，请指正以备完善。 使用netty来实现，Netty提供异步的、事件驱动的网络应用程序框架和工具，用以快速开发高性能、高可靠性的网络服务器和客户端程序，Netty 是一个基于NIO的客户、服务器端的编程框架，使用Netty 可以确保你快速和简单的开发出一个网络应用，例如实现了某种协议（redis协议）的客户、服务端应用
TCP粘包问题解析：Python Socket网络编程
"Python socket网络编程中的粘包问题详解，主要涉及TCP协议的特性与UDP协议的区别，以及粘包产生的原因和解决方案。" 在计算机网络编程中，粘包问题主要出现在使用TCP协议进行数据传输时。TCP（传输控制协议）是一...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值