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

最新推荐文章于 2024-05-15 22:05:04 发布
最新推荐文章于 2024-05-15 22:05:04 发布
阅读量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
关注
  • 0
    点赞
  • 踩
  • 3
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
Netty的UDP通信心得
08-30
Netty的UDP通信心得
netty解析报文，解决粘包拆包
03-25
注：下载前请查看本人博客文章，看是否...里面包含模拟TCP客户端发送报文工具，硬件厂商提供的协议，服务端（springboot+netty）解析报文源码，源码里整合了redis，不需要可自行删除，如有需要客户端代码，可联系我。
Netty入门(十)netty粘包拆包原理
weixin_42412601的博客
06-26 544
目录TCP 粘包和拆包基本介绍TCP 粘包和拆包现象实例服务端客户端测试TCP 粘包和拆包解决方案一个具体的实例自定义协议编解码器服务端客户端测试练习自定义协议编解码器服务端修改客户端修改测试 TCP 粘包和拆包基本介绍 由于UDP有消息保护边界，不会发生粘包拆包问题，因此粘包拆包问题只发生在TCP协议中。 TCP是面向连接的，面向流的，提供高可靠性服务。收发两端（客户端和服务器端）都要有一一成对的socket，因此，发送端为了将多个数据包发给接收端，更有效的发给对方，使用了优化方法（Nagle算法）
TCP、UDP模型与粘包问题
最新发布
g1446992400的博客
05-15 1888
粘包问题只会发生在TCP协议 ---> 流式协议 ---> 不断的传输数据比如有一个大缸：先放红颜色的颜料放了一缸但是还有一勺没有放进去没有放进去的这一勺红颜色颜料和下一缸的绿颜色颜料混到了一起不会发生在UDP协议 ---> 报式协议 ---> 一次性传输数据比如有一个大缸：先放红颜色的颜料放了一缸但是还有一勺没有放进去那么直接将这勺颜料扔了# 【一】模块介绍# ● struct.pack()是Python内置模块struct中的一个函数# ● 它的作用是将指定的数据按照指定的格式进行打包。
Netty解决粘包和拆包问题的四种方案
勇往直前的专栏
07-10 268
在RPC框架中，粘包和拆包问题是必须解决一个问题，因为RPC框架中，各个微服务相互之间都是维系了一个TCP长连接，比如dubbo就是一个全双工的长连接。由于微服务往对方发送信息的时候，所有的请求都是使用的同一个连接，这样就会产生粘包和拆包的问题。本文首先会对粘包和拆包问题进行描述，然后介绍其常用的解决方案，最后会对Netty提供的几种解决方案进行讲解。这里说明一下，由于oschina将“jie ma qi”认定为敏感文字，因而本文统一使用“解码一器”表示该含义 1. 粘包和拆包 产生粘包和拆包问题的..
Netty5入门学习笔记002-TCP粘包/拆包问题的解决之道（上）
weixin_33693070的博客
12-17 119
2019独角兽企业重金招聘Python工程师标准>>> ...
Netty 教程 – Netty粘包/拆包解决之道
二师兄撒欢之地
03-16 832
通过以上分析，我们清楚了粘包或拆包发生的原因，那么如何解决这个问题呢？数据报文的长度，因此在应用层能很好的将不同的数据报文区分开，从而避免粘包和拆包的问题。需要实现的逻辑主要对应于处理第一个数据包的时候，第一次调用。，用户自己去实现处理粘包、拆包的逻辑还是有一定难度的，的首部没有表示数据长度的字段，基于上面两点，在使用。，这里有不断的数据流入，而我们要做的就是从这个。的都知道，它是属于传输层的协议，传输层除了有。传输层之间的数据交互是大小不等的数据块，但是。内置的解决方案解决粘包/拆包的问题。
Netty笔记——粘包和拆包
qq_41157876的博客
12-17 128
粘包和拆包 发送原因 业界解决策略 Netty提供的策略 LineBasedFrameDecoder DelimiterBasedFrameDecoder FixLengthFrameDecoder 问题说明 假设客户端分别发送了两个数据包D1和D2给服务端，由于服务端一次读取到字节数是不确定的，故可能存在以下四种情况： 1. 服务端分两次读取到了两个独立的数据包，分别是D1和D2，没有粘包和拆包 2. 服务端一次接受到了两个数据包，D1.
unity实现Socket通讯（内含tcp粘包/拆包解决）
12-25
本教程将深入探讨如何在Unity中实现Socket通信，包括TCP连接、粘包/拆包问题的解决方案。 一、TCP连接基础 TCP（Transmission Control Protocol）是一种面向连接的、可靠的、基于字节流的传输层通信协议。在Unity中...
面试题：聊聊TCP的粘包、拆包以及解决方案.docx
10-26
TCP的粘包和拆包是网络编程中遇到的常见问题，尤其在基于TCP协议的通讯中，如RPC框架和Netty等。TCP是一种面向字节流的协议，它没有明确的数据包边界，这可能导致发送的数据在接收端看起来像是被粘在一起或是被拆...
Netty的技术的总结（Marshalling编解码，tcp的拆包粘包，webservice），包括新手入门源码，注释清楚，绝对物超所值
09-28
**TCP的拆包粘包问题**：TCP是面向字节流的协议，不区分消息边界，可能导致数据接收方无法准确解析消息。Netty通过提供一系列的编解码器，如LengthFieldBasedFrameDecoder，解决了这个问题。它可以根据前导长度字段...
c++服务器 拆包粘包 过程
08-18
在计算机网络编程中，"拆包"和"粘包"是TCP协议中常见的问题，尤其在C++服务器开发中，理解并处理好这两个概念对于构建高效稳定的网络服务至关重要。TCP是一种面向连接的、可靠的传输层协议，它通过流式传输确保数据...
Netty 解决粘包和拆包问题的四种方案
weixin_44749255的博客
02-29 3268
Netty 解决粘包和拆包问题的四种方案
通过大量实战案例分解Netty中是如何解决拆包黏包问题的?
跟着Mic学架构
11-14 653
TCP传输协议是基于数据流传输的，而基于流化的数据是没有界限的，当客户端向服务端发送数据时，可能会把一个完整的数据报文拆分成多个小报文进行发送，也可能将多个报文合并成一个大报文进行发送。 在这样的情况下，有可能会出现图3-1所示的情况。 服务端恰巧读到了两个完整的数据包 A 和 B，没有出现拆包/粘包问题； 服务端接收到 A 和 B 粘在一起的数据包，服务端需要解析出 A 和 B； 服务端收到完整的 A 和 B 的一部分数据包 B-1，服务端需要解析出完整的 A，并等待读取完整的 B 数据包； 服务端接.
Netty之UDP丢包解决
weixin_30375247的博客
01-05 1649
程序背景 程序是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 762
2019独角兽企业重金招聘Python工程师标准>>> ...
Netty 学习笔记（3） ------ ChannelPipeline 和 ChannelHandler
05-20 331
ChannelPipeline通过责任链设计模式组织逻辑代码（ChannelHandler）,ChannelHander就如同Servlet的Filter一样一层层处理Channel的读写数据。 ChannelPipeline和ChannelHander的构成 Channel Netty框架中，一个连接对应一个Channel ChannelPipeline 一个Channel绑定一条...
Java 使用 Netty DefaultFullHttpRequest 实现Post发送数据包的功能
xbt312的专栏
08-20 7249
// 向SQLMAPAPI传送开始测试的指令 NioEventLoopGroup workerGroup = new NioEventLoopGroup(); try { Bootstrap bootstrap = new Bootstrap(); bootstrap.group(workerGroup).channel(NioSocketChannel.class).o...
网络编程Netty入门（二）
狐言
04-23 282
111
netty udp tcp
07-15
### 回答1： Netty是一种基于Java的网络通信框架，它提供了高度灵活和可扩展的功能，可以用于开发各种类型的网络应用程序。其中，Netty支持TCP和UDP两种传输协议。 TCP（Transmission Control Protocol）是一种面向连接的协议，它能够提供可靠的数据传输。TCP通过三次握手建立连接，并通过流量控制和拥塞控制机制来保证数据的可靠性。在使用TCP协议时，数据的传输是一对一的，即每个数据包从发送方到接收方都会经过一个确定的路径。 UDP（User Datagram Protocol）是一种面向无连接的协议，它不保证数据的可靠传输。UDP在数据的发送方和接收方之间建立一个简单的交互，数据包通过广播方式发送，不保证数据包的顺序和完整性。UDP适用于实时性要求较高的应用场景，如音频、视频、游戏等。 在Netty中，无论是TCP还是UDP，都可以通过使用Channel来进行创建和管理。对于UDP来说，Netty提供了DatagramChannel来处理UDP数据包的发送和接收。而对于TCP来说，Netty提供了SocketChannel来处理TCP连接的建立和数据的传输。 Netty使用NIO（Non-blocking I/O）实现网络通信，通过事件驱动机制和高效的线程池来处理网络I/O操作。无论是TCP还是UDP，都可以通过设置相应的ChannelHandler来处理数据的编码、解码、读取和写入操作。 总之，Netty是一种强大的网络通信框架，支持TCP和UDP两种传输协议。它提供了丰富的功能和简化的API，可以大大简化网络应用程序的开发和管理。无论是开发高性能服务器还是实时应用程序，Netty都是一个非常好的选择。 ### 回答2： Netty是一个开源的高性能网络应用框架，它支持多种协议，包括UDP和TCP。UDP（User Datagram Protocol）是一种无连接的传输协议，它在应用层和传输层之间提供了一种简单的、不可靠的传输服务。UDP主要用于传输实时数据，如音频和视频流等，因为它具有较低的延迟和较小的数据包头开销。UDP不保证数据的可靠传输，因此在使用UDP时需要自己处理丢包、乱序等问题。 而TCP（Transmission Control Protocol）是一种面向连接的传输协议，它提供了可靠的、有序的数据传输服务。TCP在应用层和传输层之间建立了一个可靠的、全双工的、面向字节流的连接。TCP通过序号、确认和重传机制等保证了数据的可靠性和有序性。TCP适用于传输对数据完整性要求较高的应用，如网页浏览、文件传输等。 Netty在UDP和TCP协议之上提供了统一的编程模型和高度可配置的网络应用框架。它能够有效地处理网络传输中的各种问题，如拆包、粘包、流量控制等。通过使用Netty，开发者可以方便地实现各种基于UDP和TCP的网络应用，而无需关注底层网络细节。 总结来说，Netty是一个强大的网络应用框架，它支持UDP和TCP等多种协议，并提供了统一的编程模型，使开发者能够更便捷地开发高性能的网络应用。无论是实时的UDP应用还是可靠的TCP应用，Netty都能提供高效、稳定的网络传输服务。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值