003 Netty_处理TCP拆包粘包基础工具类

最新推荐文章于 2024-05-17 16:11:15 发布
最新推荐文章于 2024-05-17 16:11:15 发布
阅读量323 收藏 1
点赞数
分类专栏： netty
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/zxylwj/article/details/103385093
版权

1.TCP拆包、粘包问题

        tcp编程，无论是服务器端还是客户端，当我们读取或者发送数据的时候，都需要考虑TCP底层的粘包/拆包机制。TCP是一个“流”协议，所谓流就是没有界限的遗传数据。可以想象下河里的水就好比数据，他们是连成一片的，没有分界线，TCP底层并不了解上层的业务数据具体的含义，它会根据TCP缓冲区的实际情况进行包的划分，也就是说，在业务上，我们一个完整的包可能会被TCP分成多个包进行发送，也可能把多个小包封装成一个大的数据包发送出去，这就是所谓的TCP粘包、拆包问题。
分析TCP粘包、拆包问题的产生原因：
-1 应用程序write写入的字节大小大于套接口发送缓冲区的大小
-2 进行MSS大小的TCP分段
-3 以太网帧的payload大于MTU进行IP分片

2.TCP拆包、粘包解决方案

粘包拆包问题的解决方案，根据业界主流协议，的有三种方案：
-1 消息定长，例如每个报文的大小固定为200个字节，如果不够，空位补空格；
-2 在包尾部增加特殊字符进行分割，例如加回车等
-3 消息分为消息头和消息体，在消息头中包含表示消息总长度的字段，然后进行业务处理（自定义常用）

3.NETTY解决TCP拆包粘包问题（给定了前两种解决方案）

-1 分隔符类 DelimiterBasedFrameDecoder（自定义分隔符）
-2 FixedLengthFrameDecoder（定长）

4.NETTY解决TCP拆包粘包实现

step1:DelimiterBasedFrameDecoder（自定义分隔符）

package com.cc.netty.decoder1;

import java.nio.ByteBuffer;

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

public class Server {

	public static void main(String[] args) throws Exception{
		//1 创建2个线程，一个是负责接收客户端的连接。一个是负责进行数据传输的
		EventLoopGroup pGroup = new NioEventLoopGroup();
		EventLoopGroup cGroup = new NioEventLoopGroup();
		
		//2 创建服务器辅助类
		ServerBootstrap b = new ServerBootstrap();
		b.group(pGroup, cGroup)
		 .channel(NioServerSocketChannel.class)
		 .option(ChannelOption.SO_BACKLOG, 1024)
		 /**发送1000条消息，其中990都是1024 * 32大小，有10条数据为1024 * 64大小，
		  * ChannelOption.SO_SNDBUF与ChannelOption.SO_RCVBUF都可以设置为 32*1024，
		  * 超出部分，服务器端等待就可以；
		  * 但是在Client端要做两次(多次)writeAndFlush；
		  */
		 .childOption(ChannelOption.SO_SNDBUF, 32*1024)
		 .childOption(ChannelOption.SO_RCVBUF, 32*1024)
		 .childHandler(new ChannelInitializer<SocketChannel>() {
			@Override
			protected void initChannel(SocketChannel sc) throws Exception {
				//	设置特殊分隔符
				ByteBuf buf = Unpooled.copiedBuffer("$_".getBytes());
				sc.pipeline().addLast(new DelimiterBasedFrameDecoder(32 * 1024, buf));//一次处理大小要与ChannelOption.SO_RCVBUF设置一致
				//	设置字符串形式的解码
				sc.pipeline().addLast(new StringDecoder()); //使用StringDecoder转String
				sc.pipeline().addLast(new ServerHandler());
			}
		});
		
		//4 绑定连接
		ChannelFuture cf = b.bind(8765).sync();
		
		//	等待服务器监听端口关闭
		cf.channel().closeFuture().sync();
		pGroup.shutdownGracefully();
		cGroup.shutdownGracefully();
		
	}
	
}

package com.cc.netty.decoder1;

import java.util.Random;

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

public class ServerHandler extends ChannelInboundHandlerAdapter {


	@Override
	public void channelActive(ChannelHandlerContext ctx) throws Exception {
		System.out.println(" server channel active... ");
	}

	@Override
	public void channelRead(ChannelHandlerContext ctx, Object msg) throws Exception {
		String request = (String)msg;
//		Thread.sleep(5000);
//		Random r = new Random();
//		Thread.sleep(100 * r.nextInt(5));
		System.out.println("Server :" + msg);
		String response = "服务器响应：" + msg + "$_";
		ctx.writeAndFlush(Unpooled.copiedBuffer(response.getBytes()));
	}

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

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




}

package com.cc.netty.decoder1;

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;

public class Client {

	public static void main(String[] args) throws Exception {
		
		EventLoopGroup group = new NioEventLoopGroup();
		
		Bootstrap b = new Bootstrap();
		b.group(group)
		 .channel(NioSocketChannel.class)
		 .option(ChannelOption.SO_SNDBUF, 32*1024)
		 .option(ChannelOption.SO_RCVBUF, 32*1024)		 
		 .handler(new ChannelInitializer<SocketChannel>() {
			@Override
			protected void initChannel(SocketChannel sc) throws Exception {
				//
				ByteBuf buf = Unpooled.copiedBuffer("$_".getBytes());
				sc.pipeline().addLast(new DelimiterBasedFrameDecoder(32 * 1024, buf)); //一次处理大小要与ChannelOption.SO_RCVBUF设置一致
				sc.pipeline().addLast(new StringDecoder());
				sc.pipeline().addLast(new ClientHandler());
			}
		});
		
		ChannelFuture cf = b.connect("127.0.0.1", 8765).sync();
		
		for(int i = 1 ; i <=10 ; i ++){			// 4 + 10 + $_ = 8
			cf.channel().writeAndFlush(Unpooled.wrappedBuffer(("消息" + i + "$_").getBytes()));
		}
		
		//	等待客户端端口关闭
		cf.channel().closeFuture().sync();
		group.shutdownGracefully();
		
	}
}

package com.cc.netty.decoder1;

import io.netty.channel.ChannelHandlerContext;
import io.netty.channel.ChannelInboundHandlerAdapter;
import io.netty.util.ReferenceCountUtil;

public class ClientHandler extends ChannelInboundHandlerAdapter{

	@Override
	public void channelActive(ChannelHandlerContext ctx) throws Exception {
		System.out.println("client channel active... ");
	}

	@Override
	public void channelRead(ChannelHandlerContext ctx, Object msg) throws Exception {
		try {
			String response = (String)msg;
			System.out.println("Client: " + response);
		} finally {
			ReferenceCountUtil.release(msg);
		}
	}

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

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

}

 

DelimiterBasedFrameDecoder(32 * 1024, buf) :一次接收处理数据的大小设置要和childOption(ChannelOption.SO_SNDBUF, 32*1024)与childOption(ChannelOption.SO_RCVBUF, 32*1024)一致；

StringDecoder ：将buffer转换为String；

step2：FixedLengthFrameDecoder（定长）

package com.cc.netty.decoder2;

import java.nio.ByteBuffer;

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

public class Server {

	public static void main(String[] args) throws Exception{
		//1 创建2个线程，一个是负责接收客户端的连接。一个是负责进行数据传输的
		EventLoopGroup pGroup = new NioEventLoopGroup();
		EventLoopGroup cGroup = new NioEventLoopGroup();
		
		//2 创建服务器辅助类
		ServerBootstrap b = new ServerBootstrap();
		b.group(pGroup, cGroup)
		 .channel(NioServerSocketChannel.class)
		 .option(ChannelOption.SO_BACKLOG, 1024)
		 .option(ChannelOption.SO_SNDBUF, 32*1024)
		 .option(ChannelOption.SO_RCVBUF, 32*1024)
		 .childHandler(new ChannelInitializer<SocketChannel>() {
			@Override
			protected void initChannel(SocketChannel sc) throws Exception {
				//	设置定长字符串接收
				sc.pipeline().addLast(new FixedLengthFrameDecoder(5));
				//	设置字符串形式的解码
				sc.pipeline().addLast(new StringDecoder());
				sc.pipeline().addLast(new ServerHandler());
			}
		});
		
		//4 绑定连接
		ChannelFuture cf = b.bind(8765).sync();
		
		//	等待服务器监听端口关闭
		cf.channel().closeFuture().sync();
		pGroup.shutdownGracefully();
		cGroup.shutdownGracefully();
		
	}
	
}

package com.cc.netty.decoder2;

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

public class Client {

	public static void main(String[] args) throws Exception {
		
		EventLoopGroup group = new NioEventLoopGroup();
		
		Bootstrap b = new Bootstrap();
		b.group(group)
		 .channel(NioSocketChannel.class)
		 .handler(new ChannelInitializer<SocketChannel>() {
			@Override
			protected void initChannel(SocketChannel sc) throws Exception {
				sc.pipeline().addLast(new FixedLengthFrameDecoder(5));
				sc.pipeline().addLast(new StringDecoder());
				sc.pipeline().addLast(new ClientHandler());
			}
		});
		
		ChannelFuture cf = b.connect("127.0.0.1", 8765).sync();
		
		cf.channel().writeAndFlush(Unpooled.wrappedBuffer("aaaaabbbbb".getBytes()));
		cf.channel().writeAndFlush(Unpooled.copiedBuffer("ccccccc  ".getBytes()));
		cf.channel().writeAndFlush(Unpooled.copiedBuffer("c   cc".getBytes()));
        cf.channel().writeAndFlush(Unpooled.copiedBuffer("123456789".getBytes()));
		//	等待客户端端口关闭
		cf.channel().closeFuture().sync();
		group.shutdownGracefully();
		
	}
}

package com.cc.netty.decoder2;

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

public class ServerHandler extends ChannelInboundHandlerAdapter {


	@Override
	public void channelActive(ChannelHandlerContext ctx) throws Exception {
		System.out.println(" server channel active... ");
	}

	@Override
	public void channelRead(ChannelHandlerContext ctx, Object msg) throws Exception {
		String request = (String)msg;
		System.out.println("Server :" + msg);
		String response =  request ;
		ctx.writeAndFlush(Unpooled.copiedBuffer(response.getBytes()));
	}

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

	@Override
	public void exceptionCaught(ChannelHandlerContext ctx, Throwable t) throws Exception {

	}




}

 

package com.cc.netty.decoder2;

import io.netty.channel.ChannelHandlerContext;
import io.netty.channel.ChannelInboundHandlerAdapter;

public class ClientHandler extends ChannelInboundHandlerAdapter{

	@Override
	public void channelActive(ChannelHandlerContext ctx) throws Exception {
		System.out.println("client channel active... ");
	}

	@Override
	public void channelRead(ChannelHandlerContext ctx, Object msg) throws Exception {
		String response = (String)msg;
		System.out.println("Client: " + response);
	}

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

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

}

FixedLengthFrameDecoder(5)：按照5个识别一次传输，如果出现不足5个的数据将不传输；

 

 

诸般世界
关注
  • 0
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
Netty粘包分包现象及解决方案实战，防socket攻击
11-09
Netty粘包分包现象及解决方案实战，防socket攻击水。
关于netty对于客户端不同定长包分包处理
Lmianhuatang的博客
05-03 1438
业务需求为一固定客户端发送固定包长为25的数据包，且只能注册发送一包，其他还有不同长度的包需要接收，且都来源于同一客户端方案一 （不可行）：使用netty的定长解码器进行粘包/分包处理，但如果长度定为25，那大于25的包必定会被分包。如果超过25，那注册第一包且只能发送一包的数据将会丢失。因为客户端协议已经定好，不好修改，所以采用最大定长，不够补0的方法也不方便。方案2（可行）：只能自己根据包的类...
亲测！超详细的使用netty进行tcp数据通信的流程
最新发布
小红的成长日记
05-17 1897
超详细
Netty：解决粘包、半包问题，实现ByteToMessageDecoder解码器分包
Oxye
03-20 1062
开发时使用netty的解码器解析协议报文时，出现StringIndexOutOfBoundsException报错，debug发现是协议头总长度和当次读取的数据总长度不一致，看来是遇到半包问题了，所以通过下面的代码解决，供参考。核心手段是使用ByteBuf 的markReaderIndex、resetReaderIndex来控制对ByteBuf对象的读取，长度不够就攒着，够了就读走想要的部分。我们约定协议的byte数组结构为 3位长度+1位id+对应长度的数据。
netty 数据分包、组包、粘包处理机制(部分)1
08-04
netty 数据分包、组包、粘包处理机制(部分)1
netty 解决粘包 和 分包的问题
架构师的成长之路的博客
06-20 5167
netty 解决粘包 和 分包的问题概述粘包现象客户端在一个for循环内连续发送1000个hello给Netty服务器端 Socket socket = new Socket("127.0.0.1", 10101); for(int i = 0; i &lt; 1000; i++){ socket.getOutputStream().write(“hell...
netty拆包粘包解决方案示例
07-28
在分布式系统和网络通信中，Netty是一个非常流行的高性能、异步事件驱动的网络应用程序框架，用于快速开发可...通过阅读和理解这些代码，开发者可以更好地掌握Netty在处理拆包粘包问题以及客户端断线重连方面的技巧。
netty搭建tcp服务，粘拆包解决
05-10
总的来说，Netty通过提供一系列的工具和组件，使得在TCP服务中处理粘包和拆包变得简单且高效。只要正确地配置和使用解码器，就可以确保数据的完整性和一致性，从而保证网络通信的可靠性。在实际项目中，还需要根据...
netty 断线重连+心跳
10-25
netty使用自带工具类实现断线重连和心跳包
Netty 17道面试题和答案.docx
06-15
3. 自带编解码器解决 TCP 粘包/拆包问题。 4. 自带各种协议栈。 5. 真正的无连接数据包套接字支持。 6. 比直接使用 JDK 自带的 NIO 相关的 API 来说更加易用。 7. 安全性不错，有完整的 SSL/TLS 以及 StartTLS 支持...
Netty入门与实战：仿写微信IM即时通讯系统
01-12
2. **数据载体ByteBuf的使用**：掌握ByteBuf的用法，它是Netty中用于处理二进制数据的核心类。 3. **自定义协议设计**：设计一套适合即时通讯系统的二进制协议，以提高通信效率。 4. **粘包与拆包问题**：解决在网络...
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的解决思路
zhuzj12345的博客
09-06 1732
一般直接接触RPC框架的时候内部都做了对于粘包分包的解决方案，咱们来一起了解下这方便的含义，包括编码解码这块。 （一）粘包分包概念 粘包 TCP 由于TCP协议本身的机制（面向连接的可靠地协议-三次握手机制）客户端与服务器会维持一个连接（Channel），数据在连接不断开的情况下，可以持续不断地将多个数据包发往服务器，但是如果发送的网络数据包太小，那么他本身会启用Nag...
【转载格式化】Netty解决粘包和拆包问题的四种方案，简单易懂
a375816465的博客
05-25 1092
对于粘包与拆包问题，其实前面三种基本上已经能够满足大多数情形了，但是对于一些更加复杂的协议，可能有一些定制化的需求。对于这些场景，其实本质上，我们也不需要手动从头开始写一份粘包与拆包处理器，而是通过继承LengthFieldBasedFrameDecoder和LengthFieldPrepender来实现粘包和拆包的处理。如果用户确实需要不通过继承的方式实现自己的粘包和拆包处理器，这里可以通过实现MessageToByteEncoder和ByteToMessageDecoder来实现。
【Netty入门】解决TCP粘包/分包的实例
白夜行
06-13 4147
回顾TCP粘包/分包问题的解决方法1.消息定长2.在包尾都增加特殊字符进行分割3.将消息分为消息头和消息体针对这三种方法，下面我会分别举例验证FixedLengthFrameDecoder类对应第一种解决方法：消息定长（1）例1：服务端代码：public class Server4 { public static void main(String[] args) throws SigarEx
Netty--原理--TCP--粘包与拆包
IT利刃出鞘的博客
06-01 1253
本文介绍Netty是如何解决TCP的粘包与拆包问题的。
Netty解决粘包和分包问题
blwinner的专栏
02-27 2300
Netty提供的解码器 Netty提供的解码器的基类是ByteToMessageDecoder, netty默认提供的几个非常有用的解码器都是它的子类 FixedLengthFrameDecoder: 适用于业务包长度固定的情况, 比如TS流, 构造器传入每个业务包的固定长度值, 解码器接收到数据后, 会按照定长来划分业务包并包业务交给后续的处理器(如自定义的handler), 如果当前接收的数...
netty分包的问题
wangbingqi的专栏
09-23 1452
使用netty做硬件设备通讯的服务端，有时候会出现一条数据被分成几个片段 解决办法：继承解码器ByteToMessageDecoder，覆盖decode方法，在decode方法中进行数据的验证和解析，验证通过后，decode方法参数List<Object> out，使用这个参数把解析的数据放进去，如何验证不通过，不做任何处理（也就是不放进out参数，netty会把下次接收的数据和这次的数据拼接，放进参数out中就会传递到Handler的ChannelInboundHandlerAdapter类
Netty对于粘包和拆包问题的解决方案
qq_44613591的博客
03-15 844
前言 什么是粘包拆包？ 拆包和粘包是在socket编程中经常出现的情况，在socket通讯过程中，如果通讯的一端一次性连续发送多条数据包，tcp协议会将多个数据包打包成一个tcp报文发送出去，这就是所谓的粘包。而如果通讯的一端发送的数据包超过一次tcp报文所能传输的最大值时，就会将一个数据包拆成多个最大tcp长度的tcp报文分开传输，这就叫做拆包。 我们看一下下面这张图就知道了： 粘包拆包产生的原因 数据流在TCP协议下传播，因为协议本身对于流有一些规则的限制，这些规则会导致当前对端接收到的数据包不
netty tcp粘包和拆包
07-30
Netty中的TCP粘包和拆包问题是由于底层的TCP协议无法理解上层的业务数据而导致的。为了解决这个问题，Netty提供了几种解决方案。其中，常用的解决方案有四种[1]： 1. 固定长度的拆包器（FixedLengthFrameDecoder）...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值