[转]java nio解决半包 粘包问题
java nio解决半包 粘包问题
NIO socket是非阻塞的通讯模式，与IO阻塞式的通讯不同点在于NIO的数据要通过channel放到一个缓存池ByteBuffer中，然后再从这个缓存池中读出数据，由于服务端缓存池大小限制以及网速不均匀等原因，会造成服务端读取到缓冲池中的数据不完整，就形成了断包问题，当缓存池大小够大的情况下又会发生一次读取到缓存池中的数据多于一个完整的数据包，这种情况因为无法分清数据包之间的界限，就形成了粘包问题。对于NIO的SocketChannel每次触发OP_READ事件时，发送端不一定仅仅写入了一次，同理，发送端如果一次发送数据包过大，那么发送端的一次写入也可能会被拆分成两次OP_READ事件，所以OP_READ事件和发送端的OP_WRITE事件并不是一一对应的。
一、断包、粘包问题的重现
package org.weir.socket.socketPackage; import java.io.IOException;
import java.net.InetSocketAddress;
import java.nio.ByteBuffer;
import java.nio.channels.ClosedChannelException;
import java.nio.channels.SelectionKey;
import java.nio.channels.Selector;
import java.nio.channels.SocketChannel;
import java.util.Iterator;
import java.util.Set; public class NioSocketClient extends Thread {
private SocketChannel socketChannel;
private Selector selector = null;
private int clientId; public static void main(String args[]) throws IOException {
NioSocketClient client = new NioSocketClient();
client.initClient();
client.start();
} public NioSocketClient() {
} public NioSocketClient(int clientId) {
this.clientId = clientId;
} public void initClient() throws IOException {
InetSocketAddress inetSocketAddress = new InetSocketAddress(8888);
selector = Selector.open();
socketChannel = SocketChannel.open();
socketChannel.configureBlocking(false);
socketChannel.connect(inetSocketAddress);
synchronized (selector) {
socketChannel.register(selector, SelectionKey.OP_CONNECT);
}
} public void run() {
while (true) {
try {
int key = selector.select();
if (key > 0) {
Set<SelectionKey> keySet = selector.selectedKeys();
Iterator<SelectionKey> iter = keySet.iterator();
while (iter.hasNext()) {
SelectionKey selectionKey = null;
synchronized (iter) {
selectionKey = iter.next();
iter.remove();
} if (selectionKey.isConnectable()) {
finishConnect(selectionKey);
}
if (selectionKey.isWritable()) {
send(selectionKey);
}
if (selectionKey.isReadable()) {
read(selectionKey);
}
}
}
} catch (IOException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
}
} public void finishConnect(SelectionKey key) {
System.out.println("client finish connect!");
SocketChannel socketChannel = (SocketChannel) key.channel();
try {
socketChannel.finishConnect();
synchronized (selector) {
socketChannel.register(selector, SelectionKey.OP_WRITE);
key.interestOps(SelectionKey.OP_WRITE); }
} catch (IOException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
} public void read(SelectionKey key) throws IOException {
SocketChannel channel = (SocketChannel) key.channel();
ByteBuffer byteBuffer = ByteBuffer.allocate(1024);
int len = channel.read(byteBuffer);
if (len > 0) {
byteBuffer.flip();
byte[] byteArray = new byte[byteBuffer.limit()];
byteBuffer.get(byteArray);
System.out.println("client[" + clientId + "]" + "receive from server:");
System.out.println(new String(byteArray));
len = channel.read(byteBuffer);
byteBuffer.clear(); }
key.interestOps(SelectionKey.OP_READ);
} public void send(SelectionKey key) {
SocketChannel channel = (SocketChannel) key.channel(); // byteBuffer.put(ss.getBytes());
for (int i = 0; i < 10; i++) {
String ss = i + "Server ,how are you? this is package message from NioSocketClient!";
ByteBuffer byteBuffer = ByteBuffer.wrap(ss.getBytes()); System.out.println("[client] send:{" + i + "}-- " + ss);
while (byteBuffer.hasRemaining()) {
try { channel.write(byteBuffer);
} catch (IOException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
}
} // key.interestOps(SelectionKey.OP_READ);
try {
synchronized (selector) { channel.register(selector, SelectionKey.OP_READ);
}
} catch (ClosedChannelException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
} /**
* int到byte[]
*
* @param i
* @return
*/
public static byte[] intToBytes(int value) {
byte[] result = new byte[4];
// 由高位到低位
result[0] = (byte) ((value >> 24) & 0xFF);
result[1] = (byte) ((value >> 16) & 0xFF);
result[2] = (byte) ((value >> 8) & 0xFF);
result[3] = (byte) (value & 0xFF);
return result;
}
}
package org.weir.socket.socketPackage; import java.io.IOException;
import java.net.InetSocketAddress;
import java.nio.ByteBuffer;
import java.nio.channels.SelectionKey;
import java.nio.channels.Selector;
import java.nio.channels.ServerSocketChannel;
import java.nio.channels.SocketChannel;
import java.util.Iterator;
import java.util.Set; public class NioSocketServer extends Thread {
ServerSocketChannel serverSocketChannel = null;
Selector selector = null;
SelectionKey selectionKey = null; public void initServer() throws IOException {
selector = Selector.open();
serverSocketChannel = ServerSocketChannel.open();
serverSocketChannel.configureBlocking(false);
serverSocketChannel.socket().bind(new InetSocketAddress(8888));
selectionKey = serverSocketChannel.register(selector, SelectionKey.OP_ACCEPT); } public void run() {
while (true) {
try {
int selectKey = selector.select();
if (selectKey > 0) {
Set<SelectionKey> keySet = selector.selectedKeys();
Iterator<SelectionKey> iter = keySet.iterator();
while (iter.hasNext()) {
SelectionKey selectionKey = iter.next();
iter.remove();
if (selectionKey.isAcceptable()) {
accept(selectionKey);
}
if (selectionKey.isReadable()) {
read(selectionKey);
}
if (selectionKey.isWritable()) {
// write(selectionKey);
System.out.println();
}
}
}
} catch (IOException e) {
// TODO Auto-generated catch block
e.printStackTrace();
try {
serverSocketChannel.close();
} catch (IOException e1) {
// TODO Auto-generated catch block
e1.printStackTrace();
}
} }
} public void accept(SelectionKey key) {
try {
ServerSocketChannel serverSocketChannel = (ServerSocketChannel) key.channel();
SocketChannel socketChannel = serverSocketChannel.accept();
System.out.println("is acceptable");
socketChannel.configureBlocking(false);
socketChannel.register(selector, SelectionKey.OP_READ); } catch (IOException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
} public void read(SelectionKey selectionKey) {
System.out.println("read事件"); try {
SocketChannel channel = (SocketChannel) selectionKey.channel();
ByteBuffer byteBuffer = ByteBuffer.allocate(100);
int len = channel.read(byteBuffer);
if (len > 0) { byteBuffer.flip();
byte[] byteArray = new byte[byteBuffer.limit()];
byteBuffer.get(byteArray);
System.out.println("NioSocketServer receive from client:" + new String(byteArray)); }
selectionKey.interestOps(SelectionKey.OP_READ);
selectionKey.interestOps(SelectionKey.OP_READ);
} catch (IOException e) {
// TODO Auto-generated catch block
try {
serverSocketChannel.close();
selectionKey.cancel();
} catch (IOException e1) {
// TODO Auto-generated catch block
e1.printStackTrace();
}
e.printStackTrace();
} } public void write(SelectionKey selectionKey) {
SocketChannel socketChannel = (SocketChannel) selectionKey.channel();
String httpResponse = "HTTP/1.1 200 OK\r\n" + "Content-Length: 38\r\n" + "Content-Type: text/html\r\n" + "\r\n"
+ "<html><body>Hello World!</body></html>";
System.out.println("response from server to client");
try {
ByteBuffer byteBuffer = ByteBuffer.wrap(httpResponse.getBytes());
while (byteBuffer.hasRemaining()) {
socketChannel.write(byteBuffer);
}
selectionKey.cancel();
} catch (IOException e) {
try {
selectionKey.cancel();
serverSocketChannel.close();
} catch (IOException e1) {
// TODO Auto-generated catch block
e1.printStackTrace();
}
// TODO Auto-generated catch block
e.printStackTrace();
}
} /**
* byte[]转int
*
* @param bytes
* @return
*/
public static int byteArrayToInt(byte[] bytes) {
int value = 0;
// 由高位到低位
for (int i = 0; i < 4; i++) {
int shift = (4 - 1 - i) * 8;
value += (bytes[i] & 0x000000FF) << shift;// 往高位游
}
return value;
} public static void main(String args[]) throws IOException {
NioSocketServer server = new NioSocketServer();
server.initServer();
server.start(); }
}
运行这两个类，结果如下： 
由于server端的ByteBuffer大小为100，所以会发生粘包问题，当把server端的ByteBuffer大小改为50的情况下，运行结果如下
这种情况下就形成了断包问题，接收到的数据都是不完整的数据
二、断包、粘包问题的解决
解决思路是在封装自己的包协议：包=包内容长度(4byte)+包内容
对于粘包问题先读出包头即包体长度n，然后再读取长度为n的包内容，这样数据包之间的边界就清楚了。
对于断包问题先读出包头即包体长度n，由于此次读取的缓存池长度小于n，这时候就需要先缓存这部分的内容，等待下次read事件来时拼接起来形成完整的数据包。
由于读取channel数据到ByteBuffer缓存池时ByteBuffer的大小限制，client的一次write事件不一定一一对应server的read事件，所以需要一个全局变量来缓存这部分不完整的数据包。
代码如下：
package org.weir.socket.socketPackage; import java.io.IOException;
import java.net.InetSocketAddress;
import java.nio.ByteBuffer;
import java.nio.channels.SelectionKey;
import java.nio.channels.Selector;
import java.nio.channels.ServerSocketChannel;
import java.nio.channels.SocketChannel;
import java.util.Iterator;
import java.util.Set; public class NioSocketServer extends Thread {
ServerSocketChannel serverSocketChannel = null;
Selector selector = null;
SelectionKey selectionKey = null;
// 缓存一个read事件中一个不完整的包，以待下次read事件到来时拼接成完整的包
ByteBuffer cacheBuffer = ByteBuffer.allocate(100);
boolean cache = false; public void initServer() throws IOException {
selector = Selector.open();
serverSocketChannel = ServerSocketChannel.open();
serverSocketChannel.configureBlocking(false);
serverSocketChannel.socket().bind(new InetSocketAddress(8888));
selectionKey = serverSocketChannel.register(selector, SelectionKey.OP_ACCEPT); } public void run() {
while (true) {
try {
int selectKey = selector.select();
if (selectKey > 0) {
Set<SelectionKey> keySet = selector.selectedKeys();
Iterator<SelectionKey> iter = keySet.iterator();
while (iter.hasNext()) {
SelectionKey selectionKey = iter.next();
iter.remove();
if (selectionKey.isAcceptable()) {
accept(selectionKey);
}
if (selectionKey.isReadable()) {
read(selectionKey);
}
if (selectionKey.isWritable()) {
// write(selectionKey);
System.out.println();
}
}
}
} catch (IOException e) {
// TODO Auto-generated catch block
e.printStackTrace();
try {
serverSocketChannel.close();
} catch (IOException e1) {
// TODO Auto-generated catch block
e1.printStackTrace();
}
} }
} public void accept(SelectionKey key) {
try {
ServerSocketChannel serverSocketChannel = (ServerSocketChannel) key.channel();
SocketChannel socketChannel = serverSocketChannel.accept();
System.out.println("is acceptable");
socketChannel.configureBlocking(false);
socketChannel.register(selector, SelectionKey.OP_READ); } catch (IOException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
} // 一个client的write事件不一定唯一对应server的read事件，所以需要缓存不完整的包，以便拼接成完整的包
//包协议：包=包头(4byte)+包体，包头内容为包体的数据长度
public void read(SelectionKey selectionKey) {
System.out.println("read事件");
int head_length = 4;//数据包长度
byte[] headByte = new byte[4]; try {
SocketChannel channel = (SocketChannel) selectionKey.channel();
ByteBuffer byteBuffer = ByteBuffer.allocate(100);
int bodyLen = -1;
if (cache) {
cacheBuffer.flip();
byteBuffer.put(cacheBuffer);
}
channel.read(byteBuffer);// 当前read事件
byteBuffer.flip();// write mode to read mode
while (byteBuffer.remaining() > 0) {
if (bodyLen == -1) {// 还没有读出包头，先读出包头
if (byteBuffer.remaining() >= head_length) {// 可以读出包头，否则缓存
byteBuffer.mark();
byteBuffer.get(headByte);
bodyLen = byteArrayToInt(headByte);
} else {
byteBuffer.reset();
cache = true;
cacheBuffer.clear();
cacheBuffer.put(byteBuffer);
break;
}
} else {// 已经读出包头
if (byteBuffer.remaining() >= bodyLen) {// 大于等于一个包，否则缓存
byte[] bodyByte = new byte[bodyLen];
byteBuffer.get(bodyByte, 0, bodyLen);
bodyLen = -1; System.out.println("receive from clien content is:" + new String(bodyByte));
} else {
byteBuffer.reset();
cacheBuffer.clear();
cacheBuffer.put(byteBuffer);
cache = true;
break;
}
}
} selectionKey.interestOps(SelectionKey.OP_READ);
} catch (IOException e) {
// TODO Auto-generated catch block
try {
serverSocketChannel.close();
selectionKey.cancel();
} catch (IOException e1) {
// TODO Auto-generated catch block
e1.printStackTrace();
}
e.printStackTrace();
} } public void write(SelectionKey selectionKey) {
SocketChannel socketChannel = (SocketChannel) selectionKey.channel();
String httpResponse = "HTTP/1.1 200 OK\r\n" + "Content-Length: 38\r\n" + "Content-Type: text/html\r\n" + "\r\n"
+ "<html><body>Hello World!</body></html>";
System.out.println("response from server to client");
try {
ByteBuffer byteBuffer = ByteBuffer.wrap(httpResponse.getBytes());
while (byteBuffer.hasRemaining()) {
socketChannel.write(byteBuffer);
}
selectionKey.cancel();
} catch (IOException e) {
try {
selectionKey.cancel();
serverSocketChannel.close();
} catch (IOException e1) {
// TODO Auto-generated catch block
e1.printStackTrace();
}
// TODO Auto-generated catch block
e.printStackTrace();
}
} /**
* byte[]转int
*
* @param bytes
* @return
*/
public static int byteArrayToInt(byte[] bytes) {
int value = 0;
// 由高位到低位
for (int i = 0; i < 4; i++) {
int shift = (4 - 1 - i) * 8;
value += (bytes[i] & 0x000000FF) << shift;// 往高位游
}
return value;
} public static void main(String args[]) throws IOException {
NioSocketServer server = new NioSocketServer();
server.initServer();
server.start(); }
}
package org.weir.socket.socketPackage; import java.io.IOException;
import java.net.InetSocketAddress;
import java.nio.ByteBuffer;
import java.nio.channels.ClosedChannelException;
import java.nio.channels.SelectionKey;
import java.nio.channels.Selector;
import java.nio.channels.SocketChannel;
import java.util.Iterator;
import java.util.Set; public class NioSocketClient extends Thread {
private SocketChannel socketChannel;
private Selector selector = null;
private int clientId; public static void main(String args[]) throws IOException {
NioSocketClient client = new NioSocketClient();
client.initClient();
client.start();
} public NioSocketClient() {
} public NioSocketClient(int clientId) {
this.clientId = clientId;
} public void initClient() throws IOException {
InetSocketAddress inetSocketAddress = new InetSocketAddress(8888);
selector = Selector.open();
socketChannel = SocketChannel.open();
socketChannel.configureBlocking(false);
socketChannel.connect(inetSocketAddress);
synchronized (selector) {
socketChannel.register(selector, SelectionKey.OP_CONNECT);
}
} public void run() {
while (true) {
try {
int key = selector.select();
if (key > 0) {
Set<SelectionKey> keySet = selector.selectedKeys();
Iterator<SelectionKey> iter = keySet.iterator();
while (iter.hasNext()) {
SelectionKey selectionKey = null;
synchronized (iter) {
selectionKey = iter.next();
iter.remove();
} if (selectionKey.isConnectable()) {
finishConnect(selectionKey);
}
if (selectionKey.isWritable()) {
send(selectionKey);
}
if (selectionKey.isReadable()) {
read(selectionKey);
}
}
}
} catch (IOException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
}
} public void finishConnect(SelectionKey key) {
System.out.println("client finish connect!");
SocketChannel socketChannel = (SocketChannel) key.channel();
try {
socketChannel.finishConnect();
synchronized (selector) {
socketChannel.register(selector, SelectionKey.OP_WRITE);
key.interestOps(SelectionKey.OP_WRITE); }
} catch (IOException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
} public void read(SelectionKey key) throws IOException {
SocketChannel channel = (SocketChannel) key.channel();
ByteBuffer byteBuffer = ByteBuffer.allocate(1024);
int len = channel.read(byteBuffer);
if (len > 0) {
byteBuffer.flip();
byte[] byteArray = new byte[byteBuffer.limit()];
byteBuffer.get(byteArray);
System.out.println("client[" + clientId + "]" + "receive from server:");
System.out.println(new String(byteArray));
len = channel.read(byteBuffer);
byteBuffer.clear(); }
key.interestOps(SelectionKey.OP_READ);
} public void send(SelectionKey key) {
SocketChannel channel = (SocketChannel) key.channel(); for (int i = 0; i < 10; i++) {
String ss = i + "Server ,how are you? this is package message from NioSocketClient!";
int head = (ss).getBytes().length;
ByteBuffer byteBuffer = ByteBuffer.allocate(4 + head);
byteBuffer.put(intToBytes(head));
byteBuffer.put(ss.getBytes());
byteBuffer.flip();
System.out.println("[client] send:" + i + "-- " + head + ss);
while (byteBuffer.hasRemaining()) {
try { channel.write(byteBuffer);
} catch (IOException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
}
} // key.interestOps(SelectionKey.OP_READ);
try {
synchronized (selector) { channel.register(selector, SelectionKey.OP_READ);
}
} catch (ClosedChannelException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
} /**
* int到byte[]
*
* @param i
* @return
*/
public static byte[] intToBytes(int value) {
byte[] result = new byte[4];
// 由高位到低位
result[0] = (byte) ((value >> 24) & 0xFF);
result[1] = (byte) ((value >> 16) & 0xFF);
result[2] = (byte) ((value >> 8) & 0xFF);
result[3] = (byte) (value & 0xFF);
return result;
}
}
运行结果如下： 
断包、粘包问题解决了，接下来写下关于ByteBuffer这个类的使用。
[转]java nio解决半包 粘包问题的更多相关文章
- tomcat Http11NioProtocol如何解析http请求及如何解决TCP拆包粘包
前言 tomcat是常用的Web 应用服务器,目前国内有很多文章讲解了tomcat架构,请求流程等,但是没有如何解析http请求及如何解决TCP粘包拆包,所以这篇文章的目的就是介绍这块内容,一下内容完 ...
- java nio消息半包、粘包解决方案
问题背景 NIO是面向缓冲区进行通信的,不是面向流的.我们都知道,既然是缓冲区,那它一定存在一个固定大小.这样一来通常会遇到两个问题: 消息粘包:当缓冲区足够大,由于网络不稳定种种原因,可能会有多条消 ...
- 6行代码解决golang TCP粘包
转自:https://studygolang.com/articles/12483 什么是TCP粘包问题以及为什么会产生TCP粘包,本文不加讨论.本文使用golang的bufio.Scanner来实现 ...
- 用struct模块解决tcp的粘包问题
服务器端程序 import struct import socket sk = socket.socket() sk.bind(('127.0.0.1',9000)) sk.listen() conn ...
- netty10---分包粘包
客户端:根据 长度+数据 方式发送 package com.server; import java.net.Socket; import java.nio.ByteBuffer; public cla ...
- 网络编程3 网络编程之缓冲区&subprocess&粘包&粘包解决方案
1.sub简单使用 2.粘包现象(1) 3.粘包现象(2) 4.粘包现象解决方案 5.struct学习 6.粘包现象升级版解决方案 7.打印进度条
- mina框架tcpt通讯接收数据断包粘包处理
用mina做基于tcp,udp有通讯有段时间了,一直对编码解码不是很熟悉,这次做项目的时候碰到了断包情况,贴一下解决过程, 我接受数据格式如下图所示: unit32为c++中数据类型,代表4个字节,由 ...
- goim socket丢包粘包问题解决。
-(NSInteger)bytesToInt:(unsigned char*) data { return (data[3]&255)|(data[2]&255)<<8|( ...
- Netty解决TCP粘包/拆包问题 - 按行分隔字符串解码器
服务端 package org.zln.netty.five.timer; import io.netty.bootstrap.ServerBootstrap; import io.netty.cha ...
随机推荐
- Hibernate的查询功能
1.Query对象 1.使用Query对象,不需要写sql语句,但是写hql语句 (1)hql:hibernate query language,提供查询语言,这个hql语言和普通sql语句相似 (2 ...
- qt.network.ssl: QSslSocket: cannot call unresolved function SSLv23_client_method
使用Qt编写程序访问知乎官网,程序报错 qt.network.ssl: QSslSocket: cannot call unresolved function SSLv23_client_method ...
- 动态规划-填格子问题 Domino and Tromino Tiling
2018-09-01 22:38:19 问题描述: 问题求解: 本题如果是第一看到,应该还是非常棘手的,基本没有什么思路. 不妨先从一种简化的版本来考虑.如果仅有一种砖块,那么,填充的方式如下.
- Mongodb 分享（一）
Mongodb使用基础知识: 一.简介 1.mongodb是什么? 1)MongoDB 是一个基于分布式文件存储的数据库.由 )mongodb 客户端:NoSQL Manager for MongoD ...
- 7.2内存管理-ARC
@0-简介 1编译器会自动在适当的地方插入适当的retain.release.autorelease语句 @1-ARC的判断原则 1只要还有一个强指针变量指向对象,对象就会保持在内存中 2强指针 ...
- GWAS | 全基因组关联分析 | Linkage disequilibrium (LD)连锁不平衡 | 曼哈顿图 Manhattan_plot | QQ_plot | haplotype phasing
现在GWAS已经属于比较古老的技术了,主要是碰到严重的瓶颈了,单纯的snp与表现的关联已经不够,需要具体的生物学解释,这些snp是如何具体导致疾病的发生的. 而且,大多数病找到的都不是个别显著的snp ...
- English trip Spoken English & Word List（updating...）
Word List 词汇 Square 英 [skweə] 美 [skwɛr] adj. 平方的:正方形的:直角的:正直的. 使成方形:与…一致 vi. 一致:成方形 n. 平方:广场:正方形 ...
- 20170907wdVBA_ImportPicturesBaseOnExcel
Public Sub ImportPicturesBaseOnExcel() Dim shp As Object Dim xlApp As Object Dim Wb As Object Dim Rn ...
- canvas学习之树叶动画
项目地址:http://pan.baidu.com/s/1geJgqen 今天用canvas做了一个树叶发芽到凋落的动画,当然还有很多不完善的地方,不过也让我体会到了,做动画技术占2分,算法占8分.这 ...
- Spring Batch 使用场景
一个标准的批处理程序通常会从数据库,文件或者队列中读取大量的数据和记录,然后对获取的数据进行处理,然后将修改后的格式写回到数据库中. 通常 Spring Batch 在离线模式下进行工作,不需要用户干 ...