package com.zy.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;
|
|
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;
|
}
|
|
@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);
|
}
|
|
/**
|
* 解码： 字节数组 ====>> 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 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 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;//结束符
|
}
|
|
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();
|
}
|
|
}
|
