TCP 粘包 和 拆包

最新推荐文章于 2024-08-18 23:52:08 发布
最新推荐文章于 2024-08-18 23:52:08 发布
阅读量2.3k 收藏 1
点赞数
分类专栏： Java NIO编程(Netty框架) 文章标签： netty tcp 粘包 拆包

本文来源：《Netty权威指南》

TCP 粘包/拆包
TCP 是一个“流”协议，没有分界线。
TCP底层并不了解上层业务数据的具体含义，它会根据TCP缓冲区的实际情况进行包的划分。

粘包/拆包现象：
如下图，客户端发送两个数据包D1和D2到服务器，会出现以下4种情况：

（1）服务端分两次读取，获得两个独立的数据包，分别D1和D2，这种情况下没有粘包/拆包问题。
（2）服务端一共就读到了一个数据包，这个数据包是D1和D2的完整信息，这样D1和D2粘合在一起，因为服务端不知道第一条消息从哪儿结束和第二条消息从哪儿开始，所以发生了TCP粘包。
（3）服务端分两次读取到了两个数据包，第一次读取到了完整的D1包和D2包的前半部分D2_1，第二次读取到了D2包的剩余部分D2_2，这被称为TCP拆包。
（4）服务端分两次读取到了两个数据包，第一次读取到了D1包的前半部分D1_1，第二次读取到了D1包的剩余部分D1_2和D2包的整包，这也被称为TCP拆包。

粘包/拆包会导致半包读写问题！！

发生粘包/拆包的主要原因：
（1）应用程序写入的数据大于套接字缓冲区大小，这将会发生拆包。
（2）应用程序写入数据小于套接字缓冲区大小，网卡将应用多次写入的数据发送到网络上，这将会发生粘包。
（3）进行MSS（最大报文长度）大小的TCP分段，当TCP报文长度-TCP头部长度>MSS的时候将发生拆包。
（4）接收方不及时读取套接字缓冲区数据，这将发生粘包。
（5）……

粘包/拆包问题的解决策略
通过上层的应用协议栈来解决。
（1）消息定长。例如每个报文的大小为固定长度200字节，如果不够，空位补空格。
（2）在包尾增加回车换行符进行分割，例如FTP协议。
（3）设置消息边界，服务端从网络流中按消息边界分离出消息内容。
（3）将消息分为消息头和消息体，消息头中包含表示消息总长度（或者消息体长度）的字段。
（4）更复杂的应用层协议。

下面看看，如何利用Netty提供的半包解码器来解决TCP粘包/拆包问题。

一、未考虑TCP粘包问题的程序
未进行粘包/拆包处理的代码： 
package com.tao.netty.netty.ch4;

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;

public class TimeServer {
	
	public void bind(int port) throws Exception {
		//配置服务器端的NIO线程组
		//bossGroup用于服务端接收客户端的连接
		//workerGroup用于网络读写
		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 {
					// TODO Auto-generated method stub
					ch.pipeline().addLast(new TimeServerHandler());
				}		 
			});
			
			//绑定端口，同步等待成功
			ChannelFuture f = b.bind(port).sync();
			
			//等待服务端监听端口关闭
			f.channel().closeFuture().sync();
			
		} catch (Exception e) {
			e.printStackTrace();
		} finally {
			//优雅退出，释放线程池资源
			bossGroup.shutdownGracefully();
			workerGroup.shutdownGracefully();
		}
	}
		
	public static void main(String[] args) throws Exception {
		int port = 8080;	
		new TimeServer().bind(port);
	}	
}

package com.tao.netty.netty.ch4;

import java.util.Date;

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

public class TimeServerHandler extends ChannelInboundHandlerAdapter {
	
	private int counter;
	
	@Override
	public void channelRead(ChannelHandlerContext ctx, Object msg) throws Exception {
		// TODO Auto-generated method stub
		ByteBuf buf = (ByteBuf) msg;
		byte[] req = new byte[buf.readableBytes()];
		buf.readBytes(req);//读数据到req中
		String body = new String(req, "UTF-8").substring(0, req.length
				- System.getProperty("line.separator").length());
		System.out.println("服务器收到客户端发送的命令：" + body
				+ ", 计数器counter：" + (++counter));
		String currentTime = "QUERY TIME ORDER".equalsIgnoreCase(body) ? 
				new Date(System.currentTimeMillis()).toString() : "无效的命令";
				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 {
		// TODO Auto-generated method stub
		ctx.close();	
	}
}

package com.tao.netty.netty.ch4;

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;

public class TimeClient {
	
	public void connect(String host, int port) 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
					protected void initChannel(SocketChannel ch) throws Exception {
						ch.pipeline().addLast(new TimeClientHandler());
						
					}
				});
			
			//发起异步连接请求
			ChannelFuture f = b.connect(host, port).sync();
			
			f.channel().closeFuture().sync();
			
		} catch (Exception e) {
			e.printStackTrace();
		} finally {
			group.shutdownGracefully();
		}
	}
	
	
	public static void main(String[] args) {
		int port = 8080;
		
		try {
			new TimeClient().connect("127.0.0.1", port);
		} catch (Exception e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		}
	}	
}

package com.tao.netty.netty.ch4;

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

public class TimeClientHandler extends ChannelInboundHandlerAdapter {
	
	private int counter;
	private byte[] req;
	
	public TimeClientHandler() {
		req = ("QUERY TIME ORDER" + System.getProperty("line.separator")).getBytes();
	}

	@Override
	public void channelActive(ChannelHandlerContext ctx) throws Exception {
		// TODO Auto-generated method stub
		ByteBuf message = null;
		//发送100次请求
		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 {
		// TODO Auto-generated method stub
		ByteBuf buf = (ByteBuf) msg;
		byte[] req = new byte[buf.readableBytes()];
		buf.readBytes(req);
		String body = new String(req, "UTF-8");
		System.out.println("当前服务器时间：" + body
				 + ", 计数器counter：" + counter);
	}

	@Override
	public void exceptionCaught(ChannelHandlerContext ctx, Throwable cause) throws Exception {
		System.out.println(cause.getMessage());
		ctx.close();
	}	
}
       本意是让客户端发送100条请求消息，服务器发回100条应答消息。但由于发生了TCP粘包，客户端发送的消息数不足100条，并且服务器无法解析粘包中的命令。
---------------------------------------------------------------------------------------------------------------------------------
Netty中有两个抽象类：
1、ByteToMessageDecoder
2、MessageToMessageDecoder
        这两个组件都实现了ChannelInboundHandler接口，这说明这两个组件都是用来解码网络上过来的数据的。而他们的顺序一般是ByteToMessageDecoder位于head channel handler的后面，MessageToMessageDecoder位于ByteToMessageDecoder的后面。Netty中，涉及到粘包、拆包的逻辑主要在ByteToMessageDecoder及其实现中。
       当然，使用 ByteToMessageDecoder，用户需要自己去实现处理粘包、拆包的逻辑，这还是有一定难度的。

Netty已经提供了一些基于不同处理粘包、拆包规则的实现：
DelimiterBasedFrameDecoder       是基于消息边界方式进行粘包拆包处理的。
FixedLengthFrameDecoder            是基于固定长度消息进行粘包拆包处理的。
LengthFieldBasedFrameDecoder   是基于消息头指定消息长度进行粘包拆包处理的。
LineBasedFrameDecoder                是基于换行符来进行消息粘包拆包处理的。
用户可以自行选择规则然后使用Netty提供的对应的Decoder来进行具有粘包、拆包处理功能的网络应用开发。
---------------------------------------------------------------------------------------------------------------------------------
下面展示使用LineBasedFrameDecoder 解码器 + StringDecoder解码器 来解决粘包拆包问题。
LineBasedFrameDecoder 工作原理：

StringDecoder 工作原理：


二、考虑TCP粘包问题的程序
支持TCP粘包/拆包的程序：
需要在原来的TimeServerHandler之前添加两个解码器：LineBasedFrameDecoder 和 StringDecoder 

package com.tao.netty.netty.ch4.code2;

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;

public class TimeServer {
	
	public void bind(int port) throws Exception {
		//配置服务器端的NIO线程组
		//bossGroup用于服务端接收客户端的连接
		//workerGroup用于网络读写
		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 LineBasedFrameDecoder(1024));	//添加LineBasedFrameDecoder解码器
					ch.pipeline().addLast(new StringDecoder());	//添加StringDecoder解码器
					ch.pipeline().addLast(new TimeServerHandler());
				}	 
			});
			
			//绑定端口，同步等待成功
			ChannelFuture f = b.bind(port).sync();
			
			//等待服务端监听端口关闭
			f.channel().closeFuture().sync();
			
		} catch (Exception e) {
			e.printStackTrace();
		} finally {
			//优雅退出，释放线程池资源
			bossGroup.shutdownGracefully();
			workerGroup.shutdownGracefully();
		}
	}
	
	
	public static void main(String[] args) throws Exception {
		int port = 8080;
		
		new TimeServer().bind(port);
	}	
}

package com.tao.netty.netty.ch4.code2;

import java.util.Date;

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

public class TimeServerHandler extends ChannelInboundHandlerAdapter {
	
	private int counter;
	
	@Override
	public void channelRead(ChannelHandlerContext ctx, Object msg) throws Exception {
		
		//这里的msg就是删除了回车换行符之后的请求消息
		String body = (String) msg;
		System.out.println("服务器收到客户端发送的命令：" + body
				+ ", 计数器counter：" + (++counter));
		String currentTime = "QUERY TIME ORDER".equalsIgnoreCase(body) ? 
				new Date(System.currentTimeMillis()).toString() : "无效的命令";
				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 {
		// TODO Auto-generated method stub
		ctx.close();
	}
}

package com.tao.netty.netty.ch4.code2;

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;

public class TimeClient {
	
	public void connect(String host, int port) 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
					protected void initChannel(SocketChannel ch) throws Exception {
						ch.pipeline().addLast(new LineBasedFrameDecoder(1024));
						ch.pipeline().addLast(new StringDecoder());
						ch.pipeline().addLast(new TimeClientHandler());
						
					}
				});
			
			//发起异步连接请求
			ChannelFuture f = b.connect(host, port).sync();
			
			f.channel().closeFuture().sync();
			
		} catch (Exception e) {
			e.printStackTrace();
		} finally {
			group.shutdownGracefully();
		}
	}
	
	
	public static void main(String[] args) {
		int port = 8080;
		
		try {
			new TimeClient().connect("127.0.0.1", port);
		} catch (Exception e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		}
	}		
}

package com.tao.netty.netty.ch4.code2;

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

public class TimeClientHandler extends ChannelInboundHandlerAdapter {
	
	private int counter;
	private byte[] req;
	
	public TimeClientHandler() {
		req = ("QUERY TIME ORDER" + System.getProperty("line.separator")).getBytes();
	}
	
	//连接建立时触发
	@Override
	public void channelActive(ChannelHandlerContext ctx) throws Exception {
		// TODO Auto-generated method stub
		ByteBuf message = null;
		//发送100次请求
		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 {
		// TODO Auto-generated method stub
		String body = (String) msg;
		System.out.println("当前服务器时间：" + body
				 + ", 计数器counter：" + (++counter));
	}

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

System.getProperty("line.separator")的作用是获得换行符，与平台无关。





西瓜游侠
关注
专栏目录
TCP粘包和拆包
weixin_44277476的博客
06-30 2656
Socket为TCP长连接，TCP为了保证可靠传输并减少额外的开销（每次发包都要验证），采用了基于流的传输，基于流的传输不认为消息是一条一条的，是无保护消息边界的（保护消息边界：指传输协议把数据当做一条独立的消息在网上传输，接收端一次只能接受一条独立的消息）。会存在粘包拆包问题。UDP则是面向消息传输的，是有保护消息边界的，接收方一次只接受一条独立的信息，所以不存在粘包拆包问题。TCP是个流协议，就是没有界限的一串数据。TCP底层并不了解上层业务数据的具体含义，它会根据TCP缓冲区的实际情况进行包的划分，所
netty解决tcp粘包和拆包问题
远方的少年
01-20 2893
tcp为了提高效率会将多个数据包批量发送过来，所以就会存在粘包和拆包的问题。使用Netty,可以通过自定义协议+编解码器来解决粘包和拆包的问题。 1.定义协议 public class MessageProtocol { private int len; private byte[] content; public int getLen() { return len; } public void setLen(int len) {
什么是拆包、粘包？
最新发布
xycxycooo的博客
08-18 1101
拆包和粘包是网络通信中常见的问题，通常需要在应用层进行一些额外的处理来解决。通过使用消息定界、消息确认和重传、应用层协议或数据包重组等方法，可以有效地解决拆包和粘包问题，确保数据的可靠传输。
什么是TCP的粘包和拆包
wrysunny_bc的博客
02-05 1658
TCP的粘包是指TCP协议可能将数个小的包封装成一个大的包来进行传输. 而分包就是指TCP协议在进行传输时将一个大的包拆分称为数个小的包来进行数据传输.
tcp粘包
alin的博客
08-26 192
tcp粘包 tcp是是流式的传输协议, 基于这特点就会导致数据传输的时候造成粘包的现象。 什么是粘包 tcp传输时，因为网络环境的原因不会每一次发送的数据都是既定的大小，若每一个数据块是1k，那么发送过去就可能是很多个1k的包同时发送到对端，如果再加上其中每一个包的大小不同的时候，那么将无法进行数据包的划分，也就无法进行数据的解析。 粘包产生的原因 发送的数据的量 发送端和接收端对数据的处理速度 网络原因 粘包的解决方案 在发送一个数据块的头部先发送一个固定大小的整型数据，这个整型数据存的是数据块的
使用Netty解决TCP粘包和拆包问题过程详解
08-25
使用Netty解决TCP粘包和拆包问题过程详解 Netty是一个流行的Java网络编程框架，提供了简洁、灵活的API来处理网络编程的各种问题。其中，解决TCP粘包和拆包问题是Netty的一个重要应用场景。本文将详细介绍使用Netty...
【QT】自定义协议解决TCP粘包和拆包问题
08-11
在某些需要精确控制数据传输的应用中，如游戏、实时通信等，解决TCP粘包和拆包问题是至关重要的。QT是一个跨平台的C++图形用户界面应用程序开发框架，它提供了丰富的网络编程接口，可以用来处理这个问题。 本文将...
tcp 粘包 拆包解决思路以代码
04-25
这个DEMO可以帮助理解TCP粘包拆包的解决思路，并提供了实践代码实现，有助于深入理解网络编程中遇到的这类问题。 总的来说，TCP粘包和拆包是网络编程中常见的挑战，但通过合理的设计和编程技巧，我们可以有效地避免...
TCP粘包
awangdea99的博客
05-10 245
再次之前要说一下TCP和UDP的区别 TCP是可靠传输，UDP是不可靠传输； 但是TCP有一个缺点就是会粘包，因为TCP是基于数据流的协议，而UDP是基于数据报的协议 一、什么是粘包 发送端可以是一K一K地发送数据，而接收端的应用程序可以两K两K地提走数据，当然也有可能一次提走3K或6K数据，或者一次只提走几个字节的数据，也就是说，应用程序所看到的数据是一个整体，或说是一个流（stream），一条消息有多少字节对应用程序是不可见的，因此TCP协议是面向流的协议，这也是容易出现粘包问题的原因。而UDP
【计算机网络】TCP粘包
每天进步一点点
07-31 330
转载自：https://blog.csdn.net/weixin_41047704/article/details/85340311 在socket网络编程中，都是端到端通信，由客户端端口+服务端端口+客户端IP+服务端IP+传输协议组成的五元组可以明确的标识一条连接。在TCP的socket编程中，发送端和接收端都有成对的socket。发送端为了将多个发往接收端的包，更加高效的的发给接收端，于是采用了优化算法（Nagle算法），将多次间隔较小、数据量较小的数据，合并成一个数据量大的数据块，然后进行封包。那
TCP拆包和粘包问题
weixin_38172229的博客
07-08 293
粘包拆包问题是处于网络比较底层的问题，在数据链路层、网络层以及传输层都有可能发生。我们日常的网络应用开发大都在传输层进行，由于UDP有消息保护边界，不会发生粘包拆包问题，因此粘包拆包问题只发生在TCP协议中。 1. 什么是粘包、拆包？ 假设客户端向服务端连续发送了两个数据包，用packet1和packet2来表示，那么服务端收到的数据可以分为三种，现列举如下： 第一种情况，接收端正常收到两个数据包，即没有发生拆包和粘包的现象，此种情况不在本文的讨论范围内。 第二种情况，接收端只收到一个数据包，由于TCP是
TCP的粘包与拆包
goat的博客
12-05 542
一文带你搞懂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、付费专栏及课程。

余额充值