package com.zy.common.utils;
|
|
import com.zy.common.model.annotations.*;
|
import org.springframework.expression.EvaluationContext;
|
import org.springframework.expression.Expression;
|
import org.springframework.expression.ExpressionParser;
|
import org.springframework.expression.spel.standard.SpelExpressionParser;
|
import org.springframework.expression.spel.support.StandardEvaluationContext;
|
|
import java.io.ByteArrayInputStream;
|
import java.io.ByteArrayOutputStream;
|
import java.io.DataInputStream;
|
import java.io.DataOutputStream;
|
import java.lang.reflect.Array;
|
import java.lang.reflect.Field;
|
import java.nio.charset.StandardCharsets;
|
import java.util.*;
|
|
/**
|
* Tcp协议报文基类
|
* @author vincent
|
*/
|
public class Struct implements java.io.Serializable {
|
|
private transient Map<String, byte[]> decodeByteMapping = new HashMap<>();
|
private transient Map<String, byte[]> encodeByteMapping = new HashMap<>();
|
// 解码前的原生字节数组
|
private transient byte[] dataBytes = null;
|
private transient byte[] decodeBytes = null;
|
private transient byte[] encodeBytes = null;
|
private transient byte[] unusedBytes = null;
|
|
@SuppressWarnings({"unchecked", "rawtypes"})
|
public static <T extends Struct> T decode(Class<? extends Struct> cls, byte[] bytes) throws Exception {
|
Struct instance = cls.newInstance();
|
return instance.decode(bytes);
|
}
|
|
// 字节数组 ===>> 转为十六进制字符串
|
public static String toHex(byte[] bytes) {
|
StringBuilder buf = new StringBuilder(bytes.length * 2);
|
for (byte b : bytes) { // 使用String的format方法进行转换
|
buf.append(String.format("%02x", b & 0xff));
|
}
|
return buf.toString().toUpperCase();
|
}
|
|
public static byte[] toBytes(String str) {
|
if (str == null || str.trim().equals("")) return new byte[0];
|
byte[] bytes = new byte[str.length() / 2];
|
for (int i = 0; i < str.length() / 2; i++) {
|
String subStr = str.substring(i * 2, i * 2 + 2);
|
bytes[i] = (byte) Integer.parseInt(subStr, 16);
|
}
|
return bytes;
|
}
|
|
/**
|
* @功能: BCD码转为10进制串(阿拉伯数据)
|
* @参数: BCD码
|
* @结果: 10进制串
|
*/
|
public static String bcd2Str(byte[] bytes) {
|
StringBuffer temp = new StringBuffer(bytes.length * 2);
|
for (int i = 0; i < bytes.length; i++) {
|
temp.append((byte) ((bytes[i] & 0xf0) >>> 4));
|
temp.append((byte) (bytes[i] & 0x0f));
|
}
|
return temp.toString().substring(0, 1).equalsIgnoreCase("0") ? temp
|
.toString().substring(1) : temp.toString();
|
}
|
|
/**
|
* @功能: 10进制串转为BCD码
|
* @参数: 10进制串
|
* @结果: BCD码
|
*/
|
public static byte[] str2Bcd(String asc) {
|
int len = asc.length();
|
int mod = len % 2;
|
if (mod != 0) {
|
asc = "0" + asc;
|
len = asc.length();
|
}
|
byte abt[] = new byte[len];
|
if (len >= 2) {
|
len = len / 2;
|
}
|
byte bbt[] = new byte[len];
|
abt = asc.getBytes();
|
int j, k;
|
for (int p = 0; p < asc.length() / 2; p++) {
|
if ((abt[2 * p] >= '0') && (abt[2 * p] <= '9')) {
|
j = abt[2 * p] - '0';
|
} else if ((abt[2 * p] >= 'a') && (abt[2 * p] <= 'z')) {
|
j = abt[2 * p] - 'a' + 0x0a;
|
} else {
|
j = abt[2 * p] - 'A' + 0x0a;
|
}
|
if ((abt[2 * p + 1] >= '0') && (abt[2 * p + 1] <= '9')) {
|
k = abt[2 * p + 1] - '0';
|
} else if ((abt[2 * p + 1] >= 'a') && (abt[2 * p + 1] <= 'z')) {
|
k = abt[2 * p + 1] - 'a' + 0x0a;
|
} else {
|
k = abt[2 * p + 1] - 'A' + 0x0a;
|
}
|
int a = (j << 4) + k;
|
byte b = (byte) a;
|
bbt[p] = b;
|
}
|
return bbt;
|
}
|
|
public static byte getXor(byte[] datas, int start, int end) {
|
byte temp = datas[start];
|
for (int i = start + 1; i < end; i++) {
|
temp ^= datas[i];
|
}
|
return temp;
|
}
|
|
/**
|
* 求校验和的算法
|
* @param b 需要求校验和的字节数组
|
* @return 校验和
|
*/
|
public static byte sumCheck(byte[] b, int start, int end) {
|
int sum = 0;
|
for (int i = start; i < end; i++) {
|
sum = sum + b[i];
|
}
|
return (byte) (sum & 0xff);
|
}
|
|
//字符串转换为ascii
|
public static byte[] StrToAsc(String content) {
|
try {
|
return content.getBytes(StandardCharsets.US_ASCII);
|
} catch (Exception e) {
|
e.printStackTrace();
|
return null;
|
}
|
}
|
|
//ascii转换为string
|
public static String AscToStr(byte[] bytes) {
|
StringBuffer sbu = new StringBuffer();
|
for (byte aByte : bytes) {
|
sbu.append(Character.toString((char) aByte));
|
}
|
return sbu.toString();
|
}
|
|
public Class getClassType(String name) {
|
return null;
|
}
|
|
/**
|
* 判断大小端
|
* @return true: 小端 / false: 大端
|
*/
|
public boolean isReverse() {
|
return this.getClass().getAnnotation(little.class) != null;
|
}
|
|
/**
|
* 获取字节数组
|
*/
|
public byte[] toBytes() throws Exception {
|
return encode(this);
|
}
|
|
public Map<String, String> toDecodeHexMapping() throws Exception {
|
if (this.decodeByteMapping == null) this.decodeByteMapping = new HashMap<>();
|
Map<String, String> mapping = getHex(this.decodeByteMapping);
|
if (this.decodeBytes != null) {
|
mapping.put("byte[]", Struct.toHex(this.decodeBytes));
|
}
|
return mapping;
|
}
|
|
public Map<String, String> toEncodeHexMapping() throws Exception {
|
if (this.encodeBytes == null) this.encode(this);
|
if (this.encodeByteMapping == null) this.encodeByteMapping = new HashMap<>();
|
Map<String, String> mapping = getHex(this.encodeByteMapping);
|
mapping.put("byte[]", Struct.toHex(this.encodeBytes));
|
return mapping;
|
}
|
|
public Map<String, String> getHex(Map<String, byte[]> bytemapping) throws Exception {
|
Map<String, String> map = new LinkedHashMap<>();
|
Field[] fields = this.getClass().getFields();
|
for (Field field : fields) {
|
byte[] bytes = bytemapping.get(field.getName());
|
if (bytes != null) {
|
map.put(field.getName(), Struct.toHex(bytes));
|
}
|
}
|
return map;
|
}
|
|
// 转java对象到数组
|
public byte[] encode(Struct entity) throws Exception {
|
ByteArrayOutputStream baOs = new ByteArrayOutputStream();
|
write(new DataOutputStream(baOs), entity);
|
entity.encodeBytes = baOs.toByteArray();
|
return entity.encodeBytes;
|
}
|
|
/**
|
* 写数据到输出流
|
*
|
* @param dos
|
* @param entity
|
*/
|
public void write(DataOutputStream dos, Struct entity) throws Exception {
|
if (entity == null) return;
|
if (entity.encodeByteMapping == null) entity.encodeByteMapping = new HashMap<>();
|
Field[] fields = entity.getClass().getFields();
|
EvaluationContext context = new StandardEvaluationContext();
|
for (Field field : Objects.requireNonNull(ReflectUtils.removeStaticField(fields))) {
|
field.setAccessible(true);
|
|
String name = field.getName();
|
Class<?> type = field.getType();
|
String typeName = type.getSimpleName();
|
if (typeName.equals("Struct")) {
|
if (entity.getClassType(name) != null) {
|
type = entity.getClassType(name);
|
typeName = type.getSimpleName();
|
} else if (field.get(entity) != null) {
|
type = field.get(entity).getClass();
|
typeName = type.getSimpleName();
|
}
|
}
|
|
size size = field.getAnnotation(size.class);
|
bit bit = field.getAnnotation(bit.class);
|
expr expr = field.getAnnotation(expr.class);
|
flag flag = field.getAnnotation(flag.class);
|
if (size == null && bit == null && expr == null) {
|
continue;
|
}
|
|
int bited = 0;//已写位数
|
int length = 0;//定义的长度
|
if (size != null) {
|
length = size.value();
|
bited += size.value() * 8;
|
} else if (bit != null) {
|
//按位写方式未实现处理
|
throw new RuntimeException("按位写方式未实现处理");
|
} else if (expr != null) {
|
ExpressionParser parser = new SpelExpressionParser();
|
Expression exp = parser.parseExpression(expr.value());
|
Integer len = null;
|
try {
|
len = CommonUtils.parseInt(exp.getValue(context, entity));
|
} catch (Exception e) {
|
len = 0;
|
}
|
if (len != null) {
|
if (len == -1) continue;
|
length = len;
|
bited += len * 8;
|
}
|
}
|
context.setVariable(name, field.get(entity));
|
|
byte[] bytes = new byte[length];
|
|
if (typeName.equals("int") || typeName.equals("Integer")) {
|
dos.write(bytes = convert(length, field.getInt(entity)));
|
} else if (typeName.equals("long") || typeName.equals("Long")) {
|
dos.write(bytes = convert(length, field.getLong(entity)));
|
} else if (typeName.equals("short") || typeName.equals("Short")) {
|
dos.write(bytes = convert(length, field.getShort(entity)));
|
} else if (typeName.equals("byte") || typeName.equals("Byte")) {
|
dos.write(bytes = convert(length, field.getByte(entity)));
|
} else if (typeName.equals("String")) {
|
String str = (String) field.get(entity);
|
if (str == null)
|
str = "";
|
str = str.replaceAll(" ", " ");
|
|
byte[] bts = null;
|
if (flag != null && flag.value().equals("ASCII")) {
|
bts = Struct.StrToAsc(str);
|
} else if (flag != null && flag.value().equals("BCD")) {
|
bts = Struct.str2Bcd(str);
|
} else {
|
bts = str.getBytes();
|
}
|
|
if (length == 0) {//如果长度未设置，以当前实际的字节为准
|
bytes = new byte[bts.length];
|
}
|
System.arraycopy(bts, 0, bytes, 0, bts.length);
|
dos.write(bytes);
|
} else if (typeName.equals("byte[]")) {
|
byte[] bts = (byte[]) field.get(entity);
|
if (bts != null) {
|
if (length == 0) {//如果长度未设置，以当前实际的字节为准
|
bytes = new byte[bts.length];
|
}
|
System.arraycopy(bts, 0, bytes, 0, bts.length);
|
dos.write(bytes);
|
}
|
} else if (type.isArray()) {
|
ByteArrayOutputStream baOs1 = new ByteArrayOutputStream();
|
DataOutputStream dos1 = new DataOutputStream(baOs1);
|
for (Object object : (Object[]) field.get(entity)) {
|
write(dos1, (Struct) object);
|
}
|
byte[] bts = baOs1.toByteArray();
|
if (length == 0) {//如果长度未设置，以当前实际的字节为准
|
bytes = new byte[bts.length];
|
}
|
System.arraycopy(bts, 0, bytes, 0, bts.length);
|
dos.write(bytes);
|
} else {
|
byte[] bts = encode((Struct) field.get(entity));
|
if (length == 0) {//如果长度未设置，以当前实际的字节为准
|
bytes = new byte[bts.length];
|
}
|
System.arraycopy(bts, 0, bytes, 0, bts.length);
|
dos.write(bytes);
|
}
|
entity.encodeByteMapping.put(name, bytes);
|
}
|
}
|
|
public byte[] convert(int size, long value) throws Exception {
|
ByteArrayOutputStream baOs = new ByteArrayOutputStream();
|
DataOutputStream dos = new DataOutputStream(baOs);
|
switch (size) {
|
case 1://byte
|
dos.write((byte) value);
|
break;
|
case 2://short
|
dos.writeShort(this.isReverse() ? Short.reverseBytes((short) value) : (short) value);
|
break;
|
case 4://int
|
dos.writeInt(this.isReverse() ? Integer.reverseBytes((int) value) : (int) value);
|
break;
|
case 8://long
|
dos.writeLong(this.isReverse() ? Long.reverseBytes((long) value) : (long) value);
|
break;
|
}
|
return baOs.toByteArray();
|
}
|
|
public long convertEx(long value, int size) throws Exception {
|
switch (size) {
|
case 1://byte
|
return value;
|
case 2://short
|
return (this.isReverse() ? Short.reverseBytes((short) value) : (short) value);
|
case 4://int
|
return (this.isReverse() ? Integer.reverseBytes((int) value) : (int) value);
|
case 8://long
|
return (this.isReverse() ? Long.reverseBytes((long) value) : (long) value);
|
}
|
return 0;
|
}
|
|
/**
|
* 解码： 字节数组 ====>> java对象
|
*/
|
@SuppressWarnings({"unchecked", "rawtypes"})
|
public <T extends Struct> T decode(byte[] bytes) throws Exception {
|
this.dataBytes = bytes;
|
Struct instance = this;
|
Class<? extends Struct> cls = this.getClass();
|
Field[] fields = cls.getFields();
|
if (this.decodeByteMapping == null) instance.decodeByteMapping = new HashMap();
|
// spring el表达式
|
EvaluationContext context = new StandardEvaluationContext();
|
context.setVariable("_", bytes.length);
|
int bited = 0;//已读位数
|
for (Field field : Objects.requireNonNull(ReflectUtils.removeStaticField(fields))) {
|
size size = field.getAnnotation(size.class);
|
bit bit = field.getAnnotation(bit.class);
|
expr expr = field.getAnnotation(expr.class);
|
flag flag = field.getAnnotation(flag.class);
|
// 没有size、bit、expr注解的变量不进行解析
|
if (size == null && bit == null && expr == null) {
|
continue;
|
}
|
String name = field.getName();
|
Class<?> type = field.getType();
|
String typeName = type.getSimpleName();
|
if (typeName.equals("Struct")) {
|
if (instance.getClassType(name) != null) {
|
type = instance.getClassType(name);
|
typeName = type.getSimpleName();
|
}
|
}
|
context.setVariable("__", bytes.length - bited / 8);
|
byte[] bts = null;
|
if (size != null) {
|
bts = new byte[size.value()];
|
System.arraycopy(bytes, bited / 8, bts, 0, size.value());
|
bited += size.value() * 8;
|
} else if (bit != null) {
|
int val = 0;
|
String strBin = "";
|
for (int i = bited; i < bited + bit.value(); i++) {//逐位扫描
|
if ((bytes[i / 8] & (1 << (i % 8))) != 0) {//如果位为1
|
strBin += "1";
|
} else {
|
strBin += "0";
|
}
|
val = Integer.parseInt(strBin, 2);
|
}
|
byte[] result = new byte[4];
|
result[3] = (byte) (val);
|
result[2] = (byte) (val >> 8);
|
result[1] = (byte) (val >> 16);
|
result[0] = (byte) (val >> 24);
|
bts = new byte[(int) Math.ceil((double) bit.value() / 8.0)];
|
System.arraycopy(result, result.length - bts.length, bts, 0, bts.length);
|
bited += bit.value();
|
} else if (expr != null) {
|
ExpressionParser parser = new SpelExpressionParser();
|
Expression exp = parser.parseExpression(expr.value());
|
Integer len = CommonUtils.parseInt(exp.getValue(context, instance));
|
if (len != null) {
|
if (len == -1) continue;
|
bts = new byte[len];
|
System.arraycopy(bytes, bited / 8, bts, 0, len);
|
bited += len * 8;
|
}
|
}
|
if (bts.length == 0) continue;
|
DataInputStream dis = new DataInputStream(new ByteArrayInputStream(bts));
|
if (typeName.equals("int") || typeName.equals("Integer")) {
|
field.setInt(instance, (int) convertEx(dis.readInt(), 4));
|
} else if (typeName.equals("long") || typeName.equals("Long")) {
|
field.setLong(instance, convertEx(dis.readLong(), 8));
|
} else if (typeName.equals("short") || typeName.equals("Short")) {
|
field.setShort(instance, (short) convertEx(dis.readShort(), 2));
|
} else if (typeName.equals("byte") || typeName.equals("Byte")) {
|
field.setByte(instance, (byte) convertEx(dis.readByte(), 1));
|
} else if (typeName.equals("byte[]")) {
|
field.set(instance, bts);
|
} else if (typeName.equals("String")) {
|
String strStr = new String(bts, StandardCharsets.UTF_8);
|
if (flag != null && flag.value().equals("BCD")) {
|
strStr = bcd2Str(bts);
|
} else if (flag != null && flag.value().equals("ASCII")) {
|
strStr = Struct.AscToStr(bts);
|
}
|
strStr = strStr.replaceAll("[\u0000]", "");
|
field.set(instance, strStr);
|
} else if (type.isArray()) {
|
byte[] arrayBytes = bts;
|
List list = new ArrayList();
|
while (arrayBytes.length > 0 && list.size() < 256) {
|
Struct item = decode((Class<? extends Struct>) type.getComponentType(), arrayBytes);
|
list.add(item);
|
arrayBytes = item.unusedBytes;
|
}
|
Object array = Array.newInstance(type.getComponentType(), list.size());
|
for (int i = 0; i < list.size(); i++) {
|
Array.set(array, i, list.get(i));
|
}
|
field.set(instance, array);
|
} else if (type == Struct.class || Struct.class.isAssignableFrom(type)) {
|
byte[] arrayBytes = bts;
|
Struct item = decode((Class<? extends Struct>) type, arrayBytes);
|
field.set(instance, item);
|
} else {
|
throw new RuntimeException(cls.getSimpleName() + "字段" + field.getName() + "类型未知");
|
}
|
instance.decodeByteMapping.put(name, bts);
|
context.setVariable(name, field.get(instance));
|
}
|
byte[] useBytes = new byte[bited / 8];
|
System.arraycopy(bytes, 0, useBytes, 0, bited / 8);
|
instance.decodeBytes = useBytes;
|
byte[] unusedBytes = new byte[bytes.length - (bited / 8)];
|
if (unusedBytes.length > 0) {
|
System.arraycopy(bytes, useBytes.length, unusedBytes, 0, unusedBytes.length);
|
}
|
instance.unusedBytes = unusedBytes;
|
return (T) instance;
|
}
|
|
public static class TestMessage {
|
public @size(1) byte begin = 0x7e;//起始符
|
public @size(2) short type = 0;//消息ID
|
public @bit(2) byte retain;//消息体属性>保留
|
public @bit(1) byte subpkg;//消息体属性>是否分包,0表示不分包
|
public @bit(3) byte encrypt;//消息体属性>加密方式,0表示不加密
|
public @bit(10) short length;//消息体长度
|
public @size(6)
|
@flag("BCD") String number;//手机号码
|
public @size(2) short serial;//消息流水号
|
public @expr("#subpkg==1?2:0") short pkgs;//分包数
|
public @expr("#subpkg==1?2:0") short index;//包序号
|
public @expr("#length") byte[] data;//数据部分
|
public @size(1) byte verify;//校验码
|
public @size(1) byte end = 0x7e;//结束符
|
}
|
|
}
|
