perf: 移除tcp.util里面的ByteBufUtils

-package org.thingsboard.server.transport.tcp.util;
-
-import io.netty.buffer.ByteBuf;
-import org.apache.commons.lang3.ArrayUtils;
-
-import java.io.*;
-import java.nio.charset.Charset;
-import java.util.regex.Pattern;
-
-/**
- * @Description :数据类型转换工具类
- * 二进制的最高位是符号位，0表示正，1表示负。
- * 负数采用二进制的补码表示，10进制转为二进制得到的是源码，将源码按位取反得到的是反码，反码加1得到补码
- *
- *
- * *￥￥￥【基本数据类型】￥￥￥￥￥￥￥￥￥￥￥￥
-        1/8：boolean【1 位】
-        3/8：byte   【1个字节，8 位】
-        3/8：short  【2个字节，16位】
-        4/8：int    【4个字节，32位】
-        5/8：long   【8个字节，64位】
-        6/8：float  【4个字节，32位】
-        7/8：double 【8个字节，64位】
-        8/8：chart  【2个字节，16位】
- *
- *
- *
- * *￥￥￥【位运算】￥￥￥￥￥￥￥￥￥￥￥￥
-    左移【<< n】：向左移动，左边高位舍弃，右边的低位补0，例如：2左移3位，结果为16
-    右移【>>n】：向右移动，右边的舍弃掉，左边补的值取决于原来最高位，原来是1就补1，原来是0就补0
-    无符号右移【>>>n】向右移动，右边的舍弃掉，左边补0。
- *
- *
- *
- * 1.其它地方抛出异常，交由控制层统一处理
- * 2.服务层注意持久化的事务管理
- * @Author: junlianglee
- * @Date Created in 2019/12/11.
- * @Modified by Administrator on 2019/12/11.
- */
-public class ByteUtils {
-    public static final char[] ascii = "0123456789ABCDEF".toCharArray();
-    private static char[] HEX_VOCABLE = {'0', '1', '2', '3', '4', '5', '6', '7',
-            '8', '9', 'A', 'B', 'C', 'D', 'E', 'F'};
-
-    public static final String UTF_8 = "UTF-8";
-
-    private static String hexString="0123456789ABCDEF";
-    /**
-     * 将short整型数值转换为字节数组
-     *
-     * @param data
-     * @return
-     */
-    public static byte[] getBytes(short data) {
-        byte[] bytes = new byte[2];
-        bytes[0] = (byte) ((data & 0xff00) >> 8);//1个十六进制位匹配4个二进制位
-        bytes[1] = (byte) (data & 0xff);
-        return bytes;
-    }
-
-    /**
-     * 将字符转换为字节数组
-     *
-     * @param data
-     * @return
-     */
-    public static byte[] getBytes(char data) {
-        byte[] bytes = new byte[2];
-        bytes[0] = (byte) (data >> 8);
-        bytes[1] = (byte) (data);
-        return bytes;
-    }
-
-    /**
-     * 将布尔值转换为字节数组
-     *
-     * @param data
-     * @return
-     */
-    public static byte[] getBytes(boolean data) {
-        byte[] bytes = new byte[1];
-        bytes[0] = (byte) (data ? 1 : 0);
-        return bytes;
-    }
-
-    /**
-     * 将整型数值转换为字节数组
-     *
-     * @param data
-     * @return
-     */
-    public static byte[] getBytes(int data) {
-        byte[] bytes = new byte[4];
-        bytes[0] = (byte) ((data & 0xff000000) >> 24);
-        bytes[1] = (byte) ((data & 0xff0000) >> 16);
-        bytes[2] = (byte) ((data & 0xff00) >> 8);
-        bytes[3] = (byte) (data & 0xff);
-        return bytes;
-    }
-
-    /**
-     * 将long整型数值转换为字节数组
-     *
-     * @param data
-     * @return
-     */
-    public static byte[] getBytes(long data) {
-        byte[] bytes = new byte[8];
-        bytes[0] = (byte) ((data >> 56) & 0xff);
-        bytes[1] = (byte) ((data >> 48) & 0xff);
-        bytes[2] = (byte) ((data >> 40) & 0xff);
-        bytes[3] = (byte) ((data >> 32) & 0xff);
-        bytes[4] = (byte) ((data >> 24) & 0xff);
-        bytes[5] = (byte) ((data >> 16) & 0xff);
-        bytes[6] = (byte) ((data >> 8) & 0xff);
-        bytes[7] = (byte) (data & 0xff);
-        return bytes;
-    }
-
-    /**
-     * 将float型数值转换为字节数组
-     *
-     * @param data
-     * @return
-     */
-    public static byte[] getBytes(float data) {
-        int intBits = Float.floatToIntBits(data);
-        return getBytes(intBits);
-    }
-
-    /**
-     * 将double型数值转换为字节数组
-     *
-     * @param data
-     * @return
-     */
-    public static byte[] getBytes(double data) {
-        long intBits = Double.doubleToLongBits(data);
-        return getBytes(intBits);
-    }
-
-    /**
-     * 将字符串按照charsetName编码格式的字节数组
-     *
-     * @param data
-     *            字符串
-     * @param charsetName
-     *            编码格式
-     * @return
-     */
-    public static byte[] getBytes(String data, String charsetName) {
-        Charset charset = Charset.forName(charsetName);
-        return data.getBytes(charset);
-    }
-
-
-
-
-
-    /**
-     * 将字节数组前8字节转换为long整型数值
-     *
-     * @param bytes
-     * @return
-     */
-    public static long getLong(byte[] bytes) {
-        return (0xff00000000000000L & ((long) bytes[0] << 56)
-                | (0xff000000000000L & ((long) bytes[1] << 48))
-                | (0xff0000000000L & ((long) bytes[2] << 40))
-                | (0xff00000000L & ((long) bytes[3] << 32))
-                | (0xff000000L & ((long) bytes[4] << 24))
-                | (0xff0000L & ((long) bytes[5] << 16))
-                | (0xff00L & ((long) bytes[6] << 8))
-                | (0xffL & (long) bytes[7]));
-    }
-
-
-
-    /**
-     * 将charsetName编码格式的字节数组转换为字符串
-     *
-     * @param bytes
-     * @param charsetName
-     * @return
-     */
-    public static String getString(byte[] bytes, String charsetName) {
-        return new String(bytes, Charset.forName(charsetName));
-    }
-
-
-    public static byte[] hexStr2Bytes(String hexString) {
-        if (hexString == null || hexString.equals("")) {
-            return null;
-        }
-        // toUpperCase将字符串中的所有字符转换为大写
-        hexString = hexString.toUpperCase();
-        int length = hexString.length() / 2;// 2个16进制字符表示一个字节，所以字节数组长度是字符串长度除以2
-        // toCharArray将此字符串转换为一个新的字符数组。
-        char[] hexChars = hexString.toCharArray();
-        byte[] d = new byte[length];
-        for (int i = 0; i < length; i++) {
-            int pos = i * 2;
-            d[i] = (byte) (charToByte(hexChars[pos]) << 4
-                    | charToByte(hexChars[pos + 1]));
-        }
-        return d;
-    }
-
-    // charToByte返回在指定字符的第一个发生的字符串中的索引，即返回匹配字符
-    private static byte charToByte(char c) {
-        return (byte) "0123456789ABCDEF".indexOf(c);
-    }
-    /**
-     * 将16进制字符串转换为字节数组
-     *
-     * @param hex
-     * @return
-     */
-    public static byte[] hexToBytes(String hex) {
-        if (hex.length() % 2 != 0)
-            throw new IllegalArgumentException(
-                    "input string should be any multiple of 2!");
-        hex.toUpperCase();
-
-        byte[] byteBuffer = new byte[hex.length() / 2];
-
-        byte padding = 0x00;
-        boolean paddingTurning = false;
-        for (int i = 0; i < hex.length(); i++) {
-            if (paddingTurning) {
-                char c = hex.charAt(i);
-                int index = indexOf(hex, c);
-                padding = (byte) ((padding << 4) | index);
-                byteBuffer[i / 2] = padding;
-                padding = 0x00;
-                paddingTurning = false;
-            } else {
-                char c = hex.charAt(i);
-                int index = indexOf(hex, c);
-                padding = (byte) (padding | index);
-                paddingTurning = true;
-            }
-
-        }
-        return byteBuffer;
-    }
-
-    private static int indexOf(String input, char c) {
-        int index = ArrayUtils.indexOf(HEX_VOCABLE, c);
-
-        if (index < 0) {
-            throw new IllegalArgumentException("err input:" + input);
-        }
-        return index;
-
-    }
-    /**
-     * 字节数组转16进制字符串
-     *
-     * @param bs
-     * @return
-     */
-    public static String bytesToHex(byte[] bs) {
-        StringBuilder sb = new StringBuilder();
-        for (byte b : bs) {
-            int high = (b >> 4) & 0x0f;
-            int low = b & 0x0f;
-            sb.append(HEX_VOCABLE[high]);
-            sb.append(HEX_VOCABLE[low]);
-        }
-        return sb.toString();
-    }
-
-    private static final String messageRegular = "^[A-Za-z0-9!@#$%^&*()]+$";
-    public static String bytesToStr(byte[] bs){
-        String result = getString(bs, ByteUtils.UTF_8);
-        if(!Pattern.compile(messageRegular).matcher(result).matches()){
-            result = bytesToHex(bs);
-        }
-        return result;
-    }
-
-    public static byte[] strToBytes(String str){
-        if(Pattern.compile(messageRegular).matcher(str).matches()){
-            return hexStr2Bytes(str);
-        }
-        return getBytes(str,ByteUtils.UTF_8);
-    }
-
-    /**
-     * 字节数组取前len个字节转16进制字符串
-     *
-     * @param bs
-     * @param len
-     * @return
-     */
-    public static String bytesToHex(byte[] bs, int len) {
-        StringBuilder sb = new StringBuilder();
-        for (int i = 0; i < len; i++) {
-            byte b = bs[i];
-            int high = (b >> 4) & 0x0f;
-            int low = b & 0x0f;
-            sb.append(HEX_VOCABLE[high]);
-            sb.append(HEX_VOCABLE[low]);
-        }
-        return sb.toString();
-    }
-    /**
-     * 字节数组偏移offset长度之后的取len个字节转16进制字符串
-     *
-     * @param bs
-     * @param offset
-     * @param len
-     * @return
-     */
-    public static String bytesToHex(byte[] bs, int offset, int len) {
-        StringBuilder sb = new StringBuilder();
-        for (int i = 0; i < len; i++) {
-            byte b = bs[offset + i];
-            int high = (b >> 4) & 0x0f;
-            int low = b & 0x0f;
-            sb.append(HEX_VOCABLE[high]);
-            sb.append(HEX_VOCABLE[low]);
-        }
-        return sb.toString();
-    }
-    /**
-     * 字节数组转16进制字符串
-     *
-     * @param bs
-     * @return
-     */
-    public static String byteToHex(byte bs) {
-        StringBuilder sb = new StringBuilder();
-        int high = (bs >> 4) & 0x0f;
-        int low = bs & 0x0f;
-        sb.append(HEX_VOCABLE[high]);
-        sb.append(HEX_VOCABLE[low]);
-        return sb.toString();
-    }
-    /**
-     * 将字节数组取反
-     *
-     * @param src
-     * @return
-     */
-    public static String negate(byte[] src) {
-        if (src == null || src.length == 0) {
-            return null;
-        }
-        byte[] temp = new byte[2 * src.length];
-        for (int i = 0; i < src.length; i++) {
-            byte tmp = (byte) (0xFF ^ src[i]);
-            temp[i * 2] = (byte) ((tmp >> 4) & 0x0f);
-            temp[i * 2 + 1] = (byte) (tmp & 0x0f);
-        }
-        StringBuffer res = new StringBuffer();
-        for (int i = 0; i < temp.length; i++) {
-            res.append(ascii[temp[i]]);
-        }
-        return res.toString();
-    }
-
-
-
-    /**
-     * 数组合并
-     * @param before
-     * @param end
-     * @return
-     */
-    public static  byte[] merge(byte[]before,byte[]end){
-        byte[] result= new byte[before.length+end.length];
-        System.arraycopy(before,0,result,0,before.length);
-        System.arraycopy(end,0,result,before.length,end.length);
-        return result;
-    }
-
-    public static  byte[] subBytes(byte[]before,Integer start,Integer length){
-        byte[] result= new byte[length];
-        System.arraycopy(before,start,result,0,length);
-        return result;
-    }
-
-    /**
-     * 比较字节数组是否相同
-     *
-     * @param a
-     * @param b
-     * @return
-     */
-    public static boolean compareBytes(byte[] a, byte[] b) {
-        if (a == null || a.length == 0 || b == null || b.length == 0
-                || a.length != b.length) {
-            return false;
-        }
-        if (a.length == b.length) {
-            for (int i = 0; i < a.length; i++) {
-                if (a[i] != b[i]) {
-                    return false;
-                }
-            }
-        } else {
-            return false;
-        }
-        return true;
-    }
-    /**
-     * 只比对指定长度byte
-     *
-     * @param a
-     * @param b
-     * @param len
-     * @return
-     */
-    public static boolean compareBytes(byte[] a, byte[] b, int len) {
-        if (a == null || a.length == 0 || b == null || b.length == 0
-                || a.length < len || b.length < len) {
-            return false;
-        }
-        for (int i = 0; i < len; i++) {
-            if (a[i] != b[i]) {
-                return false;
-            }
-        }
-        return true;
-    }
-
-    /**
-     * 将字节数组转换为二进制字符串
-     *
-     * @param items
-     * @return
-     */
-    public static String bytesToBinaryString(byte[] items) {
-        if (items == null || items.length == 0) {
-            return null;
-        }
-        StringBuffer buf = new StringBuffer();
-        for (byte item : items) {
-            buf.append(byteToBinaryString(item));
-        }
-        return buf.toString();
-    }
-
-    /**
-     * 将字节转换为二进制字符串
-     *
-     * @param item
-     * @return
-     */
-    public static String byteToBinaryString(byte item) {
-        byte a = item;
-        StringBuffer buf = new StringBuffer();
-        for (int i = 0; i < 8; i++) {
-            buf.insert(0, a % 2);
-            a = (byte) (a >> 1);
-        }
-        return buf.toString();
-    }
-
-    /**
-     * 对数组a，b进行异或运算
-     *
-     * @param a
-     * @param b
-     * @return
-     */
-    public static byte[] xor(byte[] a, byte[] b) {
-        if (a == null || a.length == 0 || b == null || b.length == 0
-                || a.length != b.length) {
-            return null;
-        }
-        byte[] result = new byte[a.length];
-        for (int i = 0; i < a.length; i++) {
-            result[i] = (byte) (a[i] ^ b[i]);
-        }
-        return result;
-    }
-
-    /**
-     * 对数组a，b进行异或运算 运算长度len
-     *
-     * @param a
-     * @param b
-     * @param len
-     * @return
-     */
-    public static byte[] xor(byte[] a, byte[] b, int len) {
-        if (a == null || a.length == 0 || b == null || b.length == 0) {
-            return null;
-        }
-        if (a.length < len || b.length < len) {
-            return null;
-        }
-        byte[] result = new byte[len];
-        for (int i = 0; i < len; i++) {
-            result[i] = (byte) (a[i] ^ b[i]);
-        }
-        return result;
-    }
-    /**
-     * 将short整型数值转换为字节数组
-     *
-     * @param num
-     * @return
-     */
-    public static byte[] shortToBytes(int num) {
-        byte[] temp = new byte[2];
-        for (int i = 0; i < 2; i++) {
-            temp[i] = (byte) ((num >>> (8 - i * 8)) & 0xFF);
-        }
-        return temp;
-    }
-
-    /**
-     * 将字节数组转为整型
-     *
-     * @param arr
-     * @return
-     */
-    public static int bytesToShort(byte[] arr) {
-        int mask = 0xFF;
-        int temp = 0;
-        int result = 0;
-        for (int i = 0; i < 2; i++) {
-            result <<= 8;
-            temp = arr[i] & mask;
-            result |= temp;
-        }
-        return result;
-    }
-
-    /**
-     * 将整型数值转换为指定长度的字节数组
-     *
-     * @param num
-     * @return
-     */
-    public static byte[] intToBytes(int num) {
-        byte[] temp = new byte[4];
-        for (int i = 0; i < 4; i++) {
-            temp[i] = (byte) ((num >>> (24 - i * 8)) & 0xFF);
-        }
-        return temp;
-    }
-
-    /**
-     * 将整型数值转换为指定长度的字节数组
-     *
-     * @param src
-     * @param len
-     * @return
-     */
-    public static byte[] intToBytes(int src, int len) {
-        if (len < 1 || len > 4) {
-            return null;
-        }
-        byte[] temp = new byte[len];
-        for (int i = 0; i < len; i++) {
-            temp[len - 1 - i] = (byte) ((src >>> (8 * i)) & 0xFF);
-        }
-        return temp;
-    }
-
-    /**
-     * 将字节数组转换为整型数值
-     *
-     * @param arr
-     * @return
-     */
-    public static int bytesToInt(byte[] arr) {
-        int mask = 0xFF;
-        int temp = 0;
-        int result = 0;
-        for (int i = 0; i < 4; i++) {
-            result <<= 8;
-            temp = arr[i] & mask;
-            result |= temp;
-        }
-        return result;
-    }
-
-    /**
-     * 将long整型数值转换为字节数组
-     *
-     * @param num
-     * @return
-     */
-    public static byte[] longToBytes(long num) {
-        byte[] temp = new byte[8];
-        for (int i = 0; i < 8; i++) {
-            temp[i] = (byte) ((num >>> (56 - i * 8)) & 0xFF);
-        }
-        return temp;
-    }
-
-    /**
-     * 将字节数组转换为long整型数值
-     *
-     * @param arr
-     * @return
-     */
-    public static long bytesToLong(byte[] arr) {
-        int mask = 0xFF;
-        int temp = 0;
-        long result = 0;
-        int len = Math.min(8, arr.length);
-        for (int i = 0; i < len; i++) {
-            result <<= 8;
-            temp = arr[i] & mask;
-            result |= temp;
-        }
-        return result;
-    }
-
-    /**
-     * 将16进制字符转换为字节
-     *
-     * @param c
-     * @return
-     */
-    public static byte toByte(char c) {
-        byte b = (byte) "0123456789ABCDEF".indexOf(c);
-        return b;
-    }
-
-    /**
-     * 功能描述：把两个字节的字节数组转化为整型数据，高位补零，例如：<br/>
-     * 有字节数组byte[] data = new byte[]{1,2};转换后int数据的字节分布如下：<br/>
-     * 00000000 00000000 00000001 00000010,函数返回258
-     *
-     * @param lenData
-     *            需要进行转换的字节数组
-     * @return 字节数组所表示整型值的大小
-     */
-    public static int bytesToIntWhereByteLengthEquals2(byte lenData[]) {
-        if (lenData.length != 2) {
-            return -1;
-        }
-        byte fill[] = new byte[]{0, 0};
-        byte real[] = new byte[4];
-        System.arraycopy(fill, 0, real, 0, 2);
-        System.arraycopy(lenData, 0, real, 2, 2);
-        int len = byteToInt(real);
-        return len;
-
-    }
-
-    /**
-     * 功能描述：将byte数组转化为int类型的数据
-     *
-     * @param byteVal
-     *            需要转化的字节数组
-     * @return 字节数组所表示的整型数据
-     */
-    public static int byteToInt(byte[] byteVal) {
-        int result = 0;
-        for (int i = 0; i < byteVal.length; i++) {
-            int tmpVal = (byteVal[i] << (8 * (3 - i)));
-            switch (i) {
-                case 0 :
-                    tmpVal = tmpVal & 0xFF000000;
-                    break;
-                case 1 :
-                    tmpVal = tmpVal & 0x00FF0000;
-                    break;
-                case 2 :
-                    tmpVal = tmpVal & 0x0000FF00;
-                    break;
-                case 3 :
-                    tmpVal = tmpVal & 0x000000FF;
-                    break;
-            }
-
-            result = result | tmpVal;
-        }
-        return result;
-    }
-    public static byte CheckXORSum(byte[] bData) {
-        byte sum = 0x00;
-        for (int i = 0; i < bData.length; i++) {
-            sum ^= bData[i];
-        }
-        return sum;
-    }
-    /**
-     * 从offset开始 将后续长度为len的byte字节转为int
-     *
-     * @param data
-     * @param offset
-     * @param len
-     * @return
-     */
-    public static int bytesToInt(byte[] data, int offset, int len) {
-        int mask = 0xFF;
-        int temp = 0;
-        int result = 0;
-        len = Math.min(len, 4);
-        for (int i = 0; i < len; i++) {
-            result <<= 8;
-            temp = data[offset + i] & mask;
-            result |= temp;
-        }
-        return result;
-    }
-
-    /**
-     * byte字节数组中的字符串的长度
-     *
-     * @param data
-     * @return
-     */
-    public static int getBytesStringLen(byte[] data) {
-        int count = 0;
-        for (byte b : data) {
-            if (b == 0x00)
-                break;
-            count++;
-        }
-        return count;
-    }
-
-    /**
-     * 校验和
-     *
-     * @param msg
-     *            需要计算校验和的byte数组
-     * @param length
-     *            校验和位数
-     * @return 计算出的校验和数组
-     */
-    public static byte[] SumCheck(byte[] msg, int length) {
-        long mSum = 0;
-        byte[] mByte = new byte[length];
-
-        /** 逐Byte添加位数和 */
-        for (byte byteMsg : msg) {
-            long mNum = ((long) byteMsg >= 0)
-                    ? (long) byteMsg
-                    : ((long) byteMsg + 256);
-            mSum += mNum;
-        } /** end of for (byte byteMsg : msg) */
-
-        /** 位数和转化为Byte数组 */
-        for (int liv_Count = 0; liv_Count < length; liv_Count++) {
-            mByte[length - liv_Count
-                    - 1] = (byte) (mSum >> (liv_Count * 8) & 0xff);
-        } /** end of for (int liv_Count = 0; liv_Count < length; liv_Count++) */
-
-        return mByte;
-    }
-
-    /**
-     * 字节数据转十进制字符(补码-无符号)
-     *
-     * @param data
-     * @return
-     */
-    public static String getByteToStr(byte[] data) {
-        StringBuffer str = new StringBuffer();
-        for (int i = 0; i < data.length; i++) {
-            if (data[i] < 0) {
-                int tem = data[i] + 256;
-                str.append(tem + " ");
-            } else {
-                str.append(data[i] + " ");
-            }
-        }
-        return str.toString();
-    }
-
-    public static byte[]  buf2Bytes(ByteBuf in) {
-        return buf2Bytes( in, in.readableBytes()) ;
-    }
-    public static byte[]  buf2Bytes(ByteBuf in,int readable) {
-        byte[] dst = new byte[readable];
-        in.getBytes(0, dst);
-        return dst;
-    }
-
-    public static byte[] fileBytes(String pathname) throws IOException {
-        File filename = new File(pathname);
-        BufferedInputStream in = new BufferedInputStream(new FileInputStream(filename));
-        ByteArrayOutputStream out = new ByteArrayOutputStream(1024);
-        byte[] temp = new byte[1024];
-        int size = 0;
-        while((size = in.read(temp)) != -1){
-            out.write(temp, 0, size);
-        }
-        in.close();
-        out.close();
-        byte[] content = out.toByteArray();
-        return content;
-    }
-    /**
-     * 单字节高低位互换
-     * @param src
-     * @return
-     */
-    public static int revert(int src) {
-        int lowByte = (src & 0xFF00) >> 8;
-        int highByte = (src & 0x00FF) << 8;
-        return lowByte | highByte;
-    }
-
-  /**
-   * 将字符串编码成16进制数字,适用于所有字符(包括中文)
-   * @param str 字符串
-   * @return
-   */
-  public static String stringEncodeToHex(String str) {
-        //根据默认编码获取字节数组
-        byte[] bytes=str.getBytes();
-        StringBuilder sb=new StringBuilder(bytes.length*2);
-        //将字节数组中每个字节拆解成2位16进制整数
-        for(int i=0;i<bytes.length;i++)
-        {
-            sb.append(hexString.charAt((bytes[i]&0xf0)>>4));
-            sb.append(hexString.charAt((bytes[i]&0x0f)>>0));
-        }
-        return sb.toString();
-
-    }
-
-  /**
-   * 将16进制数字解码成字符串,适用于所有字符(包括中文)
-   * @param hex 16进制
-   * @return
-   */
-  public static String hexDecodeToString(String hex) {
-        try{
-            byte[] baKeyword = new byte[hex.length()/2];
-            for(int i = 0; i < baKeyword.length; i++) {
-                baKeyword[i] = (byte)(0xff & Integer.parseInt(hex.substring(i*2, i*2+2),16));
-            }
-            return new String(baKeyword,"UTF-8");
-        }catch (UnsupportedEncodingException e){
-            return null;
-        }
-    }
-
-    public static byte[] hexToByteArray(String inHex){
-        inHex.replace(" ","");
-        int hexlen = inHex.length();
-        byte[] result;
-        if (hexlen % 2 == 1){
-            //奇数
-            hexlen++;
-            result = new byte[(hexlen/2)];
-            inHex="0"+inHex;
-        }else {
-            //偶数
-            result = new byte[(hexlen/2)];
-        }
-        int j=0;
-        for (int i = 0; i < hexlen; i+=2){
-            result[j]=hexToByte(inHex.substring(i,i+2));
-            j++;
-        }
-        return result;
-    }
-    public static byte hexToByte(String inHex){
-        return (byte)Integer.parseInt(inHex,16);
-    }
-}