netty笔记---粘包、拆包问题解决方案

最新推荐文章于 2023-01-06 11:24:13 发布
最新推荐文章于 2023-01-06 11:24:13 发布
阅读量285 收藏
点赞数
分类专栏： java ee 文章标签： netty Java web
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/coffee_fighter/article/details/89521305
版权

目录

何为粘包、拆包

粘包：客户端原本是发了10条数据给服务器端的，但是tcp是基于数据流传输数据，导致服务器端收到的数据条数可能少于10条，这就是粘包现象。
拆包：客户端原本是发了1条数据给服务器端的，但是tcp是基于数据流传输数据，导致服务器端收到的数据条数可能大于1条，这就是拆包现象。

粘包例子

服务端代码

package com.coffee.tcpnbcb;

import io.netty.bootstrap.Bootstrap;
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 TcpServer {
    public static void main(String[]args){
        NioEventLoopGroup bossGroup = new NioEventLoopGroup();
        NioEventLoopGroup workerGroup = new NioEventLoopGroup();
        ServerBootstrap serverBootstrap =new ServerBootstrap();
        serverBootstrap.group(bossGroup,workerGroup).channel(NioServerSocketChannel.class).childHandler(new TcpServerInitializer());
        ChannelFuture channelFuture = null;
        try {
            channelFuture = serverBootstrap .bind(8899).sync();
            channelFuture.channel().closeFuture().sync();
        } catch (InterruptedException e) {
            e.printStackTrace();
        }finally {
            bossGroup.shutdownGracefully();
            workerGroup.shutdownGracefully();
        }
    }
}


package com.coffee.tcpnbcb;

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

public class TcpServerInitializer extends ChannelInitializer<SocketChannel> {
    @Override
    protected void initChannel(SocketChannel ch) {
        ChannelPipeline channelPipeline = ch.pipeline();
        channelPipeline.addLast(new MyTcpServerHandler());
    }
}

package com.coffee.tcpnbcb;

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

import java.nio.Buffer;
import java.nio.charset.Charset;
import java.util.UUID;

public class MyTcpServerHandler extends SimpleChannelInboundHandler<ByteBuf> {
    int count = 0;
    @Override
    protected void channelRead0(ChannelHandlerContext ctx, ByteBuf msg) throws Exception {
        byte[] bytes = new byte[msg.readableBytes()];
        msg.readBytes(bytes);
        String content = new String(bytes, Charset.forName("utf-8"));
        System.out.println("收到来自客户端的消息："+content);
        System.out.println("收到来自客户端的消息条数："+(++this.count));
        ByteBuf responseByteBuf = Unpooled.copiedBuffer(UUID.randomUUID().toString(),Charset.forName("utf-8"));
        ctx.writeAndFlush(responseByteBuf);
    }

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

客户端代码

package com.coffee.tcpnbcb;

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.NioServerSocketChannel;
import io.netty.channel.socket.nio.NioSocketChannel;

public class MyClient {
    public static void main(String[]args){
        EventLoopGroup eventLoopGroup = new NioEventLoopGroup();
        Bootstrap bootstrap = new Bootstrap();
        bootstrap.group(eventLoopGroup).channel(NioSocketChannel.class).handler(new MyClientInitializer());
        try {
            ChannelFuture channelFuture =bootstrap .connect("localhost",8899).sync();
            channelFuture.channel().closeFuture().sync();
        } catch (InterruptedException e) {
            e.printStackTrace();
        }finally {
            eventLoopGroup.shutdownGracefully();
        }
    }
}

package com.coffee.tcpnbcb;

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

import java.nio.charset.Charset;

public class MyClientHandler extends SimpleChannelInboundHandler<ByteBuf> {
    int count=0;
    @Override
    protected void channelRead0(ChannelHandlerContext ctx, ByteBuf msg) throws Exception {
        byte[] bytes = new byte[msg.readableBytes()];
        msg.readBytes(bytes);
        String content = new String(bytes, Charset.forName("utf-8"));
        System.out.println("收到服务器端消息："+content);
        System.out.println("收到服务器消息条数："+(++this.count));
    }

    @Override
    public void channelActive(ChannelHandlerContext ctx) throws Exception {
        super.channelActive(ctx);
        for(int i=0;i<10;i++){
            ctx.writeAndFlush(Unpooled.copiedBuffer("send from client",Charset.forName("utf-8")));
        }
    }

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

package com.coffee.tcpnbcb;

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

public class MyClientInitializer extends ChannelInitializer<SocketChannel> {
    @Override
    protected void initChannel(SocketChannel ch) throws Exception {
        ChannelPipeline channelPipeline=ch.pipeline();
        channelPipeline.addLast(new MyClientHandler());
    }
}

运行结果

客户端截图

客户端只收到来自服务端的一条代码

服务端截图

客户端发送了10条数据，服务器却只收到了一条数据

粘、拆包解决方案

使用自定义协议、Netty自带编解码器

package com.coffee.handler;

import com.coffee.fifth.NioServer;
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 MyClient {
    public static void main(String[]args){
        EventLoopGroup eventLoopGroup = new NioEventLoopGroup();
        Bootstrap bootstrap = new Bootstrap();
        bootstrap.group(eventLoopGroup).channel(NioSocketChannel.class).handler(new MyClientInitializer());
        ChannelFuture channelFuture = null;
        try {
            channelFuture = bootstrap.connect("localhost",8899).sync();
            channelFuture.channel().closeFuture().sync();
        } catch (InterruptedException e) {
            e.printStackTrace();
        }finally {
            eventLoopGroup.shutdownGracefully();
        }

    }
}


package com.coffee.handler;

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

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

public class MyClientHandler extends SimpleChannelInboundHandler<MyProtocol> {
    private int count = 0;
    @Override
    protected void channelRead0(ChannelHandlerContext ctx, MyProtocol msg) {
        int length = msg.getLength();
        String content = new String(msg.getContent(), Charset.forName("utf-8"));
        System.out.println("收到来自服务器的消息："+content);
        System.out.println("收到来自服务器的消息个数："+(++this.count));
    }

    @Override
    public void channelActive(ChannelHandlerContext ctx) throws Exception {
        for(int i=0;i<10;i++) {
            String s = "send from client";
            MyProtocol myProtocol = new MyProtocol();
            myProtocol.setLength(s.getBytes(Charset.forName("utf-8")).length);
            myProtocol.setContent(s.getBytes(Charset.forName("utf-8")));
            ctx.writeAndFlush(myProtocol);
        }
    }
    @Override
    public void exceptionCaught(ChannelHandlerContext ctx, Throwable cause) {
        cause.printStackTrace();
        ctx.close();
    }
}


package com.coffee.handler;

import io.netty.channel.ChannelHandlerContext;
import io.netty.channel.ChannelInitializer;
import io.netty.channel.ChannelPipeline;
import io.netty.channel.socket.SocketChannel;

public class MyClientInitializer extends ChannelInitializer<SocketChannel> {
    @Override
    protected void initChannel(SocketChannel ch) throws Exception {
        ChannelPipeline channelPipeline = ch.pipeline();
        channelPipeline.addLast(new MyProtocolDecoder());
        channelPipeline.addLast(new MyProtocolEncoder());
        channelPipeline.addLast(new MyClientHandler());
    }

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


package com.coffee.handler;

public class MyProtocol {
    private int length;
    private byte[] content;

    public int getLength() {
        return length;
    }

    public void setLength(int length) {
        this.length = length;
    }

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

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


package com.coffee.handler;

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

import java.util.List;

public class MyProtocolDecoder extends ReplayingDecoder<Void> {

    @Override
    protected void decode(ChannelHandlerContext ctx, ByteBuf in, List<Object> out) throws Exception {
        int length = in.readInt();
        byte[] content = new byte[length];
        in.readBytes(content);
        MyProtocol myProtocol = new MyProtocol();
        myProtocol.setLength(length);
        myProtocol.setContent(content);
        out.add(myProtocol);
    }

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


package com.coffee.handler;

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

import java.util.List;

public class MyProtocolEncoder extends MessageToByteEncoder<MyProtocol> {

    @Override
    protected void encode(ChannelHandlerContext ctx, MyProtocol msg, ByteBuf out) throws Exception {
        out.writeInt(msg.getLength());
        out.writeBytes(msg.getContent());
    }

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

package com.coffee.handler;

import io.netty.bootstrap.ServerBootstrap;
import io.netty.channel.ChannelFuture;
import io.netty.channel.EventLoopGroup;
import io.netty.channel.nio.NioEventLoopGroup;
import io.netty.channel.socket.nio.NioServerSocketChannel;

public class MyServer {
    public static void main(String[]args){
        EventLoopGroup bossGroup = new NioEventLoopGroup();
        EventLoopGroup workerGroup = new NioEventLoopGroup();
        ServerBootstrap serverBootstrap = new ServerBootstrap();
        serverBootstrap.group(bossGroup,workerGroup).channel(NioServerSocketChannel.class).
                childHandler(new MyServerInitializer());
        ChannelFuture channelFuture = null;
        try {
            channelFuture = serverBootstrap.bind(8899).sync();
            channelFuture.channel().closeFuture().sync();
        } catch (InterruptedException e) {
            e.printStackTrace();
        }finally {
            bossGroup.shutdownGracefully();
        }
    }
}


package com.coffee.handler;

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

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

public class MyServerHandler extends SimpleChannelInboundHandler<MyProtocol> {
    int count = 0;
    @Override
    protected void channelRead0(ChannelHandlerContext ctx, MyProtocol msg) {
        String content = new String(msg.getContent(), Charset.forName("utf-8"));
        System.out.println("收到客户端的消息："+content);
        System.out.println("收到客户端的消息条数："+(++this.count));

        String uuid = UUID.randomUUID().toString();
        MyProtocol myProtocol = new MyProtocol();
        myProtocol.setLength(uuid.getBytes().length);
        myProtocol.setContent(uuid.getBytes());
        ctx.writeAndFlush(myProtocol);
    }

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


package com.coffee.handler;

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

public class MyServerInitializer extends ChannelInitializer<SocketChannel> {
    @Override
    protected void initChannel(SocketChannel ch) throws Exception {
        ChannelPipeline channelPipeline = ch.pipeline();
        channelPipeline.addLast(new MyProtocolDecoder());
        channelPipeline.addLast(new MyProtocolEncoder());
        channelPipeline.addLast(new MyServerHandler());
    }
}

客户端运行图

在这里插入图片描述

服务端运行图

在这里插入图片描述

高飞小童鞋
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
in unnamed module of loader ‘app‘
公众号 Java4ye
10-24 4万+
额 1024的这天 居然出现这么难搞定的bug in unnamed module of loader 'app' java.lang.ClassCastException: class java.util.LinkedHashMap cannot be cast to
Netty教程(八)——事件和异常的传播
yygr的博客
04-20 1712
https://juejin.cn/post/6889263643456700423 ChannelRead事件的传播 在自定义handler的时候，通常要重写channelRead函数，如果想要将该事件向后传播（注意，传播顺序与handler添加顺序相同），需要调用fireChannelRead函数，ChannelRead事件便在这里中断 通常在重写的channelRead函数里，有两种传播ChannelRead事件的方式 public void channelRead(ChannelHan
使用NETTY实现TCP的服务端
平头哥的博客
09-28 3169
Netty是一个异步事件驱动的网络应用框架，可快速开发可维护的高性能协议服务器和客户端。基于NIO实现的高性能网络IO框架，极大简化基于常用网络协议的编程（TCP、UDP等）。
Netty源码阅读(2)之——服务端源码梗概
运气不好努力来凑
11-15 568
对比客户端源码，了解服务端与客户端源码差异，知晓服务端源码梗概。
tcp粘包，拆包
qq_21277357的博客
12-21 236
例如：客户端发送了2个数据包，一个a,一个b给到服务端，由于服务端一次读取到字节数是不确定的，可能有以下4种情况；4.服务端第一次读取到了a的一部分，第二次读取到了a的剩余部分和b的完整数据，这也叫拆包；3.服务第一次读取到了a和b的一部分数据，第二次读取到了b的剩余部分，这就叫拆包；tcp 在发消息的时候，把多个数据量小的数据，合并成一个大的数据块，这个叫封包；可以看到，12粘包，345粘包，67粘包，89粘包。1、服务端分别读取到了a和b，这样是正常的情况；我们在启动一个客户端。
Netty粘包拆包问题解决方案
08-18
Netty 粘包拆包问题解决方案 Netty 是一个基于 Java 的网络编程框架，它提供了一个便捷的方式来处理网络数据的读写操作。然而，在使用 Netty 进行网络编程时，经常会遇到粘包和拆包的问题。所谓粘包和拆包，就是指...
使用Netty解决TCP粘包和拆包问题过程详解
08-25
使用Netty解决TCP粘包和拆包问题过程详解 Netty是一个流行的Java网络编程框架，提供了简洁、灵活的API来处理网络编程的各种问题。其中，解决TCP粘包和拆包问题是Netty的一个重要应用场景。本文将详细介绍使用Netty...
netty拆包粘包解决方案示例
07-28
本文将深入探讨Netty中解决拆包粘包问题的策略，以及客户端断线重连的实现方式。 首先，我们需要理解什么是“拆包”和“粘包”。在TCP/IP通信中，由于TCP协议的流式传输特性，数据可能会被分片或者合并，这就可能...
Netty粘包-拆包应用案例及解决方案分析.docx
10-26
Netty 提供了多种解决 TCP 粘包/拆包问题的方法，例如使用 LineBasedFrameDecoder、StringDecoder 等编解码器来解决半包读写问题。在使用 Netty 时，可以通过添加编解码器来解决 TCP 粘包/拆包问题，以确保数据传输...
Netty粘包拆包解决方案.docx
10-26
总的来说，Netty提供的解码器机制使得开发者无需深入理解TCP底层细节，也能有效地解决粘包和拆包问题，提高了网络通信的可靠性和效率。通过选择合适的解码器并合理配置，我们可以构建出健壮的网络应用。
自己写的基于netty的服务器端通讯框架
12-08
本人写的基于netty的服务器端通讯框架，报文格式为【int的长度+json格式的字符串】，json格式类似于{cmd:1,data:{}},通过cmd的表示识别controller，仅需在spring配置中配置controller即可，线程池大小和编码格式可在constants静态变量里配置。目前线程池为固定大小，以后的版本中可能会增加其他形式
netty框架最简单的客户端服务端代码
08-29
详细的netty框架的简单案例,包括客户端服务端
Netty(二)——粘包、拆包解决之道
学会改变自己——才能突破
10-23 859
       上一篇博客我们说了Java基础中BIO、NIO、AIO，其中用NIO和AIO开发中需要处理的东西比较多，Netty是IO这方面优秀的框架，我们来看个Netty的入门，以及其解决IO传输中的比较恶心的粘包和拆包问题。        首先我们到http://netty.io/ 去下载netty的jar包，我是通过Maven下载了5.0.0.Alpha2版本，然后我们看下入门实例。注意其...
Netty 创建服务端代码记录
小g的博客
05-06 446
Netty 创建服务端代码记录
Netty入门，开发一个简单的服务器端和客户端，不玩虚的直接上代码！（已完善客户端代码！粘贴启动即可！）
mltaozi的博客
08-13 1076
现在，用netty开发一个简单的服务器端和客户端，实现客户端发送消息给服务端，服务端收到之后反馈给客户端。Netty 是一个异步的、基于事件驱动的网络应用框架，用于快速开发可维护、高性能的网络服务器和客户端。项目，名字自己随便取就行，构建好了之后再。先看看官网这段“英格力士”创建自定义handler类。......
netty https 客户端 + 服务端 代码案例实现
qq_22185423的博客
08-11 1281
netty HTTPS 客户端+服务端 代码案例实现
netty实现tcp通信服务端代码
weixin_35757531的博客
01-06 169
下面是 Netty 实现 TCP 通信服务端的代码示例： import io.netty.bootstrap.ServerBootstrap; import io.netty.channel.Channel; import io.netty.channel.ChannelOption; import io.netty.channel.EventLoopGroup; import io.netty....
Netty exceptionCaught 异常机制
热门推荐
静__嘘的博客
08-08 3万+
Netty handler的exceptionCaught 只会catchinbound handler的exception,outbound exceptions 需要在writeAndFlush方法里加上listener来监听消息是否发送成功， 最好在每个outboundhandler的处理类里加上try catch，只是处理由于程序异常导致的发包失败，由于网络原因没有发送成功，最终会被...
Netty解决粘包问题(1) 自定义分隔符
自由の力
08-30 1966
见如下代码Client.javaimport io.netty.bootstrap.Bootstrap; import io.netty.buffer.ByteBuf; import io.netty.buffer.Unpooled; import io.netty.channel.ChannelFuture; import io.netty.channel.ChannelInitializer;
Netty 解决粘包拆包
最新发布
07-25
Netty 是一个高性能的网络编程框架，它提供了许多解决粘包拆包问题的机制。 一种常见的解决粘包拆包问题的方法是使用定长消息或者定界符消息。对于定长消息，发送方在发送数据时固定每个消息的长度，接收方根据固定...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值