7E.....7E
public static List<byte[]> msgUnPkg(final byte[] msg){
List<byte[]> msgBytes=new LinkedList<byte[]>();
int i=0;
int k=0,index=0;
while(i<msg.length){
if(msg[i]==0x7E){
if(index%2!=0){
byte[] msgB3=new byte[i-k+1];
System.arraycopy(msg, k, msgB3, 0, msgB3.length);
msgBytes.add(msgB3);
}else{
k=i;
}
index++;
}
i++;
}
return msgBytes;
}
5B......5D
package com.zhonghong.platforms.dexchang.util;
import java.nio.charset.Charset;
import java.util.Arrays;
import java.util.LinkedList;
import java.util.List;
import org.apache.commons.codec.net.URLCodec;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
public class MsgConverUtil {
private static final Logger LOGGER = LoggerFactory.getLogger(MsgConverUtil.class);
public static MessageBuilder mainMb=null;
public static MessageBuilder subMb=null;
/**
* 消息转译
* @param msg
* @return
*/
public static byte[] translation(byte[] rsdata){
byte[] trans5b = new byte[2];
trans5b[0] = 0x5a;
trans5b[1] = 0x01;
byte[] trans5a = new byte[2];
trans5a[0] = 0x5a;
trans5a[1] = 0x02;
byte[] trans5d = new byte[2];
trans5d[0] = 0x5e;
trans5d[1] = 0x01;
byte[] trans5e = new byte[2];
trans5e[0] = 0x5e;
trans5e[1] = 0x02;
for(int i=1; i<rsdata.length-1; i++){
if(rsdata[i]==0x5b){
byte[] middleByte = new byte[rsdata.length+1];
System.arraycopy(rsdata, 0, middleByte, 0, i);
System.out.println("1."+ByteUtils.bytesToHexStringSpace(middleByte));
System.arraycopy(trans5b, 0, middleByte, i, 2);
System.out.println("2."+ByteUtils.bytesToHexStringSpace(middleByte));
System.arraycopy(rsdata, i+1, middleByte, 2+i, rsdata.length-i-1);
System.out.println("3."+ByteUtils.bytesToHexStringSpace(middleByte));
rsdata = Arrays.copyOf(middleByte, middleByte.length);
System.out.println("4."+ByteUtils.bytesToHexStringSpace(rsdata));
continue;
}
if(rsdata[i]==0x5a){
byte[] middleByte = new byte[rsdata.length+1];
System.arraycopy(rsdata, 0, middleByte, 0, i);
System.arraycopy(trans5a, 0, middleByte, i, 2);
System.arraycopy(rsdata, i+1, middleByte, 2+i, rsdata.length-i-1);
rsdata = Arrays.copyOf(middleByte, middleByte.length);
continue;
}
if(rsdata[i]==0x5d){
byte[] middleByte = new byte[rsdata.length+1];
System.arraycopy(rsdata, 0, middleByte, 0, i);
System.arraycopy(trans5d, 0, middleByte, i, 2);
System.arraycopy(rsdata, i+1, middleByte, 2+i, rsdata.length-i-1);
rsdata = Arrays.copyOf(middleByte, middleByte.length);
continue;
}
if(rsdata[i]==0x5e){
byte[] middleByte = new byte[rsdata.length+1];
System.arraycopy(rsdata, 0, middleByte, 0, i);
System.arraycopy(trans5e, 0, middleByte, i, 2);
System.arraycopy(rsdata, i+1, middleByte, 2+i, rsdata.length-i-1);
rsdata = Arrays.copyOf(middleByte, middleByte.length);
continue;
}
}
return rsdata;
}
/**
* 消息反转译
* @param msg
* @return
*/
public static byte[] unTranslation(byte[] data){
byte[] rsdata = data.clone();
for(int i=1; i<rsdata.length-1; i++){
if(rsdata[i]==0x5a&&rsdata[i+1]==0x01){
byte[] middleByte = new byte[rsdata.length-1];
System.arraycopy(rsdata, 0, middleByte, 0, i);
middleByte[i]=0x5b;
System.arraycopy(rsdata, i+2, middleByte, i+1, rsdata.length-i-2);
rsdata = Arrays.copyOf(middleByte, middleByte.length);
continue;
}
if(rsdata[i]==0x5a&&rsdata[i+1]==0x02){
byte[] middleByte = new byte[rsdata.length-1];
System.arraycopy(rsdata, 0, middleByte, 0, i);
middleByte[i]=0x5a;
System.arraycopy(rsdata, i+2, middleByte, i+1, rsdata.length-i-2);
rsdata = Arrays.copyOf(middleByte, middleByte.length);
continue;
}
if(rsdata[i]==0x5e&&rsdata[i+1]==0x01){
byte[] middleByte = new byte[rsdata.length-1];
System.arraycopy(rsdata, 0, middleByte, 0, i);
middleByte[i]=0x5d;
System.arraycopy(rsdata, i+2, middleByte, i+1, rsdata.length-i-2);
rsdata = Arrays.copyOf(middleByte, middleByte.length);
continue;
}
if(rsdata[i]==0x5e&&rsdata[i+1]==0x02){
byte[] middleByte = new byte[rsdata.length-1];
System.arraycopy(rsdata, 0, middleByte, 0, i);
middleByte[i]=0x5e;
System.arraycopy(rsdata, i+2, middleByte, i+1, rsdata.length-i-2);
rsdata = Arrays.copyOf(middleByte, middleByte.length);
continue;
}
}
return rsdata;
}
/**
* 生成CRC16-CCITT校验位
* @param 二进制消息
*/
public static byte[] genCrcCode(byte[] bytes)
{
if (bytes.length < 1)
{
return null;
}
int crc = 0xFFFF; // initial value
int polynomial = 0x1021; // 0001 0000 0010 0001 (0, 5, 12)
for (byte b : bytes) {
for (int i = 0; i < 8; i++) {
boolean bit = ((b >> (7 - i) & 1) == 1);
boolean c15 = ((crc >> 15 & 1) == 1);
crc <<= 1;
if (c15 ^ bit)
crc ^= polynomial;
}
}
crc &= 0xffff;
return TypeChangeUtil.intToWORD(crc);
}
public static boolean valiMsgCRC(byte[] msg){
byte[] msgCRCBody=new byte[msg.length-4];
System.arraycopy(msg, 1,msgCRCBody,0, msgCRCBody.length);
System.out.println(ByteUtils.bytesToHexStringSpace(msgCRCBody));
byte[] CRCCode=MsgConverUtil.genCrcCode(msgCRCBody);
String c1=ByteUtils.bytesToHexString(CRCCode);
byte[] msgCRC=new byte[2];
System.arraycopy(msg, msg.length-3,msgCRC,0, msgCRC.length);
String c2=ByteUtils.bytesToHexString(msgCRC);
if(c1.equals(c2)){
return true;
}
LOGGER.warn("消息效验码不匹配(src="+c2+",desc="+c1+").");
return false;
}
public static synchronized byte[] composeMainLinkPack(final byte[] msg){
if(msg[0]==0x5B&&msg.length>10&&msg[msg.length-1]!=0x5D){//开始
mainMb=new MessageBuilder();
mainMb.append(msg);
//LOGGER.warn("(main)消息开始组包(1)："+ByteUtils.bytesToHexStringSpace(mainMb.getBytes()));
}else if(msg[0]!=0x5B&&msg[msg.length-1]==0x5D){//结尾
mainMb.append(msg);
byte[] msg2=mainMb.getBytes();
//LOGGER.warn("(main)消息组包完成(2)："+ByteUtils.bytesToHexStringSpace(msg2));
mainMb=null;
return msg2;
}else if(msg[0]!=0x5B&&msg[msg.length-1]!=0x5D){//中间部分
mainMb.append(msg);
//LOGGER.warn("(main)消息组包中(3)："+ByteUtils.bytesToHexStringSpace(mainMb.getBytes()));
}else if(msg[0]==0x5B&&msg[msg.length-1]==0x5D){//完整消息，可能出现粘包情况
//LOGGER.warn("(main)完整消息包(4)："+ByteUtils.bytesToHexStringSpace(msg));
return msg;
}
return null;
}
public static byte[] composeSubLinkPack(final byte[] msg){
if(msg[0]==0x5B&&msg.length>10&&msg[msg.length-1]!=0x5D){//开始
subMb=new MessageBuilder();
subMb.append(msg);
//LOGGER.warn("(sub)消息开始组包(1)："+ByteUtils.bytesToHexStringSpace(subMb.getBytes()));
}else if(msg[0]!=0x5B&&msg[msg.length-1]==0x5D){//结尾
subMb.append(msg);
byte[] msg2=subMb.getBytes();
//LOGGER.warn("(sub)消息组包完成(2)："+ByteUtils.bytesToHexStringSpace(msg2));
subMb=null;
return msg2;
}else if(msg[0]!=0x5B&&msg[msg.length-1]!=0x5D){//中间部分
subMb.append(msg);
//LOGGER.warn("(sub)消息组包中(3)："+ByteUtils.bytesToHexStringSpace(subMb.getBytes()));
}else if(msg[0]==0x5B&&msg[msg.length-1]==0x5D){//完整消息，可能出现粘包情况
//LOGGER.warn("(sub)完整消息包(4)："+ByteUtils.bytesToHexStringSpace(msg));
return msg;
}
return null;
}
public static List<byte[]> msgUnPkg(byte[] msg){
List<byte[]> msgBytes=new LinkedList<byte[]>();
int i=0;
int s=0,e=0;
while(i<msg.length){
if(msg[i]==0x5B){
s=i;
}
if(msg[i]==0x5D){
e=i;
byte[] msgB2=new byte[(e-s)+1];
System.arraycopy(msg, s, msgB2, 0, msgB2.length);
msgBytes.add(msgB2);
}
i++;
}
//LOGGER.warn("数据包个数："+msgBytes.size());
return msgBytes;
}
public static byte[] encryptData1(int key,byte[] msg){
int idx = 0;
if (0==key)
{
key = 1;
}
int mk=MsgConfig.M1;
if(mk==0){
mk=1;
}
while ( idx < msg.length)
{
key = MsgConfig.IA1 * (key % mk) + MsgConfig.IC1;
msg[idx++] ^= (byte)((key >> 20) & 0xFF);
}
return msg;
}
public static byte[] decryptData1(long key,byte[] msg)
{
int idx = 0;
if (0==key)
{
key = 1;
}
int mk=MsgConfig.M1;
if(mk==0){
mk=1;
}
while ( idx < msg.length)
{
key = MsgConfig.IA1 * (key % mk) + MsgConfig.IC1;
msg[idx++] ^= (byte)((key >> 20) & 0xFF);
}
return msg;
}
public static byte[] encryptNDataNO(long _key, byte[] msg) {
long key = _key;
int size = msg.length;
if (key == 0)
key = 1;
int i = 0;
while(i < size) {
int x = (int)(MsgConfig.IA1 * (key % MsgConfig.M1));
String tx = ByteUtils.ToHexString(x&0x0FFFFFFFF);
long t = Long.valueOf(tx, 16);
key = (t + MsgConfig.IC1);
//short te = (short)(b[i] ^ (short) (key >> 20) & 0xFF);
msg[i++] ^= ((byte) (key >> 20) & 0xFF);
}
return msg;
}
public static byte[] encryptDataDll(int _key, byte[] msg){
EncryptUtil helloWorld=new EncryptUtil();
helloWorld.size=msg.length;
helloWorld.bytes=msg;
helloWorld.key=_key;
helloWorld.encrypt1=MsgConfig.M1;
helloWorld.encrypt2=MsgConfig.IA1;
helloWorld.encrypt3=MsgConfig.IC1;
helloWorld.encryptDLL();
return helloWorld.bytes;
}
/*public static byte[] encryptDLL(int _key, byte[] msg){
try {
//byte[] bb=TypeChangeUtil.hexStringToByte("EF1051B72F82569A424F40F1CCD3D5DEA2C7A75E2F858D73E94AA9037444C0B7DE5C72FB9D9C59898ED0510849590CB3DC36C433AE12859DDA64228B666623D4459E0C108D9005A5D33F7983C6C5DBE5CE5C76FC1C417E02842A8024D7F27E8A88951435C37747BF4F1B06242E1DAAE834F03B57F2D7495AF6619F97E3AEFC748F9D3E324C2C20EE06E45CAC1401038E28CAF0D6398AD6D83F5E07C5CFFFD459F81919E31443BB6EC5D66B8164");
JNative jnative=new JNative("dllEncrypt","encrypt");
jnative.setRetVal(Type.INT);
Pointer pointer = new Pointer(MemoryBlockFactory.createMemoryBlock(msg.length));
pointer.setMemory(msg);
jnative.setParameter(0, Type.INT,_key+"");
jnative.setParameter(1,pointer);
jnative.setParameter(2, Type.INT,msg.length+"");
jnative.invoke();
LOGGER.debug("加解密结果："+jnative.getRetValAsInt());
jnative.dispose();
return pointer.getMemory();
} catch (NativeException e) {
LOGGER.error(e.getMessage());
} catch (IllegalAccessException e) {
LOGGER.error(e.getMessage());
}
return msg;
}*/
public static void main(String[] args) {;
String a=new String("我加解密结果a".getBytes(), Charset.forName("ISO8859-1"));
char[] s=a.toCharArray();
byte[] b=new byte[s.length];
for(int i=0;i<s.length;i++){
b[i]=(byte)s[i];
}
System.out.println(new String(b));
System.out.println(new String(b)+""+ new String(b, Charset.forName("UTF-8")));
}
}
相关推荐
以上就是关于Netty消息拆包粘包编解码的基本介绍，通过合理的编码和解码策略，我们可以有效地处理TCP通信中的粘包和拆包问题，确保数据的正确传输。在实际应用中，还可以结合其他编码解码器，如`...
接下来是消息拆包，即接收端将接收到的字节流还原为原来的变量或数据结构。在描述中提到了使用Find和Mid方法来实现这一过程。Find方法用于在字符串中查找特定子串，而Mid方法则用于提取字符串的一部分。例如，假设...
简单的WebSocket 握手 消息拆包 消息封包 方法
### Golang TCP粘包拆包问题的解决方法 #### 一、引言 在使用Go语言进行网络编程时，特别是TCP编程过程中，经常会遇到所谓的“粘包”与“拆包”问题。这些问题的发生通常会影响到数据的正确性以及系统的稳定性。...
使用Netty解决TCP粘包和拆包问题过程详解 Netty是一个流行的Java网络编程框架，提供了简洁、灵活的API来处理网络编程的各种问题。其中，解决TCP粘包和拆包问题是Netty的一个重要应用场景。本文将详细介绍使用Netty...
本篇文章将深入探讨“socket连接”、“消息收发”以及“拆包”这三个关键知识点。 首先，我们来理解“socket连接”。在TCP/IP协议栈中，Socket是用来建立和维护端到端连接的工具。当两个设备想要通过网络通信时，...
前言：因为写网络游戏服务端，很多人都没办法处理，无法自定义自己的封包规格，一直问我，用什么方法 一般我就说自己用ETCP，或者Hp...客户端的收消息拆包思路 一样，自己加吧。 学会后，自己可能也很有成就感的。哈哈~
3. **消息协议**：设计一套消息协议，如Netty中的ByteBuf或protobuf，每个数据包由头部和主体组成，头部包含主体的长度，接收端先读取头部，然后根据头部信息读取对应长度的主体。 4. **缓冲区管理**：使用缓冲区...
在计算机网络编程中，"拆包"（Unpacking）与"粘包"（Packing）是两个关键概念，尤其在TCP协议中尤为重要。这两个术语主要涉及到数据传输时的数据包处理方式。 TCP是一种面向连接的、可靠的传输层协议，它通过序列号...
在探讨C++服务器开发中的拆包与粘包问题前，我们先来理解这两个概念的基本含义。拆包（Packet Splitting）是指数据在网络传输过程中被分割成多个数据包发送的现象；而粘包（Packet Sticking）则是指两个或多个数据包...
### Netty精粹之TCP粘包拆包问题详解 #### 一、引言 在网络通信领域，尤其是在基于TCP协议的应用程序开发中，经常会遇到“粘包”和“拆包”的问题。这些问题虽然属于较为底层的技术细节，但对于保障数据传输的准确...
"拆包"指的是接收到的数据中包含多个完整消息，而"粘包"则是指一个完整的消息被分割成了多个部分与其他消息一起发送。这两个问题在处理自定义协议时尤为常见。 Netty提供了多种解决拆包粘包问题的方法： 1. ...
在TCP协议中，由于其流式传输的特性，可能会出现“粘包”和“拆包”的问题。这两个术语是网络编程中的常见概念，主要涉及到数据在网络传输过程中的封装与解析。 **TCP粘包**：当发送方连续发送多个数据包时，接收方...
例如，假设我们定义了一个自定义消息结构`MyMessage`，包含了消息类型和消息体： ```cpp struct MyMessage { quint8 messageType; QByteArray messageBody; }; ``` 我们可以通过`QDataStream`进行序列化： ```...
首先，TCP本身并不区分消息边界，它只是一个字节流的传输层协议，这意味着连续发送的多个数据包可能会被合并成一个大的数据包发送，或者一个数据包会被拆分成多个小的数据包发送，这就是所谓的“粘包”和“拆包”...
虽然题目提供的示例代码不完整，但从给出的部分可以看出，该代码示例主要通过定义一个带有消息头的消息格式来解决粘包和拆包问题。这种方式在实际开发中非常常见，也是较为推荐的做法之一。通过这种方式，可以在接收...
在Socket通信中，结合Protobuff，可以有效地处理粘包、拆包问题，因为每个Protobuff消息都有明确的边界，方便解析。 最后，我们谈谈断线重连机制。在实际应用中，网络连接可能会因各种原因中断，如网络波动、服务器...
TCP（传输控制协议）作为互联网上广泛使用的面向连接的、可靠的传输层协议，虽然在数据传输的可靠性方面表现出色，但同时也带来了“粘包”和“拆包”这两个让开发者头疼的问题。本文将深入探讨这两个概念，并提供...
在TCP/IP协议中，由于数据的传输是以字节流的方式进行，如果不对数据进行适当的处理，就可能出现“粘包”和“拆包”的问题。本文将深入探讨Netty中如何处理这两个问题，并通过源码分析来理解其内部机制。 “粘包”...
TCP协议是基于字节流的，没有消息边界，可能会出现粘包或拆包的问题。为了解决这个问题，我们通常采用以下策略： - 固定长度消息：每个数据包都设定固定长度，便于解析。 - 包头+包体：每个数据包前加上包头，包含...