Netty之数据编码

一、概况

　　我们在网络编程中会把各种数据转换为byte数组（即字节数组）以便能在网络上传输，最基本的如网络字节序（Little-Endian和Big-Endian），按位或多位数据编码与解码，IP地址的编码与解码，BCD编码与解码，ASCII编码与解码，16进制字符串的编码与解码，有符号数与无符号数的编码与解码等。本篇博文所贴代码并不是最简洁最优化的，只是起到抛砖引玉的效果，不用像博主一样刚入门网络编程时经历那么的曲折，少走些弯路，不过站在此刻回想正是经历了磨砺才会闪耀光泽。

二、代码实现

1. 编码工具类

package com.chansen.common.utils;


import com.chansen.common.enums.TypeEnum;
import io.netty.buffer.ByteBuf;
import io.netty.buffer.ByteBufAllocator;
import io.netty.buffer.ByteBufUtil;

import java.util.Arrays;
import java.util.Date;
import java.util.List;
import java.util.Map;
import java.util.stream.Collectors;
import java.util.stream.IntStream;

/**
 * 编码工具类
 *
 * @author 复姓江山
 * @date 
 */
public final class EncodeUtils {
    

    private EncodeUtils() {
    }


   

   


    /**
     * 组装配置文件所配置的ByteBuf
     *
     * @param type   枚举类型字符串
     * @param param  参数
     * @param buf    ByteBuf缓存域
     * @param endian 字节序
     */
    public static void encode(String type, Object param,
                              ByteBuf buf, boolean endian) {

        //类型枚举
        final TypeEnum typeEnum = TypeEnum.match(type);
        //根据不同的类型编码数据
        switch (typeEnum) {
            //有符号int
            case TYPE_INT:
                writeInt(param, buf, endian);
                break;
            //无符号int
            case TYPE_UINT:
                writeUnSignInt(param, buf, endian);
                break;
            //有符号short
            case TYPE_SHORT:
                writeShort(param, buf, endian);
                break;
            //无符号short
            case TYPE_USHORT:
                writeUnSignShort(param, buf, endian);
                break;
            //有符号byte
            case TYPE_BYTE:
                writeByte(param, buf);
                break;
            //无符号byte
            case TYPE_UBYTE:
                writeUnSignByte(param, buf);
                break;
            //字符串
            case TYPE_STRING:
                writeString(param, buf);
                break;
            //字符串时间
            case TYPE_DATE_STRING:
                writeDateString(param, buf);
                break;
            case TYPE_HEX_STRING:
                writeHexString(param, buf);
                break;
            case TYPE_BIT:
                writeBit(param, buf);
                break;
            case TYPE_MULTI_BIT:
                writeMultiBit(param, buf);
                break;
            case TYPE_BCD8421:
                writeBcd8421(param, buf);
                break;
        }
    }

    /**
     * 组装ByteBuff
     *
     * @param type      枚举类型字符串
     * @param param     参数
     * @param rangeList 枚举范围
     * @param buf       ByteBuf缓存域
     * @param endian    字节序
     */
    public static void encodeEnum(String type, Object param,
                                  List<Object> rangeList,
                                  ByteBuf buf, boolean endian) {
        //枚举数据类型
        final TypeEnum typeEnum = TypeEnum.match(type);

        switch (typeEnum) {
            case TYPE_ENUM_BYTE:
                writeEnumByte(param, rangeList, buf);
                break;
            case TYPE_ENUM_INT:
                writeEnumInt(param, rangeList, buf, endian);
                break;
            case TYPE_ENUM_STRING:
                writeEnumString(param, rangeList, buf);
                break;
            case TYPE_ENUM_HEX_STRING:
                writeEnumHexString(param, rangeList, buf);
                break;
        }

    }

    /**
     * 写枚举Hex字符串
     *
     * @param obj  数据
     * @param list 枚举范围
     * @param buff ByteBuf缓存区
     */
    public static void writeEnumHexString(Object obj, List<Object> list, ByteBuf buff) {
        for (Object object : list) {
            if (object.toString().equals(obj.toString())) {
                writeHexString(obj, buff);
            }
        }

    }

    /**
     * 写枚举字符串
     *
     * @param obj  数据
     * @param list 枚举范围
     * @param buff ByteBuf缓存区
     */
    public static void writeEnumString(Object obj, List<Object> list, ByteBuf buff) {
        for (Object object : list) {
            if (object.toString().equals(obj.toString())) {
                writeString(obj, buff);
            }
        }

    }

    /**
     * 写枚举int
     *
     * @param obj  数据
     * @param list 枚举范围
     * @param buff ByteBuf缓存区
     */
    public static void writeEnumInt(Object obj, List<Object> list, ByteBuf buff, boolean endian) {
        for (Object object : list) {
            if (object.toString().equals(obj.toString())) {
                writeInt(obj, buff, endian);
            }
        }

    }

    /**
     * 写枚举byte
     *
     * @param obj  数据
     * @param list 枚举范围
     * @param buff ByteBuf缓存区
     */
    public static void writeEnumByte(Object obj, List<Object> list, ByteBuf buff) {
        for (Object object : list) {
            if (object.toString().equals(obj.toString())) {
                writeByte(obj, buff);
            }
        }

    }

    /**
     * 写字符串数据
     *
     * @param obj 值
     * @param buf ByteBuf缓存区
     */
    public static void writeHexString(Object obj, ByteBuf buf) {
        String value = (String) obj;
        writeHexString(value, buf);
    }

    /**
     * 写字符串数据
     *
     * @param value 值
     * @param buf   ByteBuf缓存区
     */
    public static void writeHexString(String value, ByteBuf buf) {
        //value is hexDump
        final byte[] bytes = ByteBufUtil.decodeHexDump(value);
        buf.writeBytes(bytes);
    }

    /**
     * 写时间字符串数据
     *
     * @param obj 值
     * @param buf ByteBuf缓存区
     */
    public static void writeDateString(Object obj, ByteBuf buf) {
        Date value = (Date) obj;
        writeDateString(value, buf);
    }

    /**
     * 写时间字符串数据
     *
     * @param obj 值
     * @param buf ByteBuf缓存区
     */
    public static void writeDateString(Date obj, ByteBuf buf) {
        String value = DateTimeUtils.getFormatDateTime(obj);
        writeString(value, buf);
    }

    /**
     * 写字符串数据
     *
     * @param obj 值
     * @param buf ByteBuf缓存区
     */
    public static void writeString(Object obj, ByteBuf buf) {
        String value = (String) obj;
        writeString(value, buf);
    }


    /**
     * 写字符串数据
     *
     * @param value 值
     * @param buf   ByteBuf缓存区
     */
    public static void writeString(String value, ByteBuf buf) {
        final char[] valueChars = value.toCharArray();
        if (valueChars.length > 0) {
            for (char valueChar : valueChars) {
                buf.writeByte(valueChar);
            }
        }
    }

    /**
     * 写int数据
     *
     * @param obj    值
     * @param buf    ByteBuf缓存区
     * @param endian 字节序
     */
    public static void writeInt(Object obj, ByteBuf buf, boolean endian) {
        int m = (int) obj;
        //小字节序
        if (endian) {
            buf.writeIntLE(m);
        } else {
            buf.writeInt(m);
        }
    }

    /**
     * 写无符号byte数据
     *
     * @param obj 值
     * @param buf ByteBuf缓存区
     */
    public static void writeUnSignByte(Object obj, ByteBuf buf) {
        int m = (int) obj;
        writeUnSignByte(m, buf);
    }

    /**
     * 写无符号byte数据
     *
     * @param m   值
     * @param buf ByteBuf缓存区
     */
    public static void writeUnSignByte(int m, ByteBuf buf) {
        writeUnSignByteBase(m, buf);
    }

    /**
     * 写byte数据
     *
     * @param obj 值
     * @param buf ByteBuf缓存区
     */
    public static void writeByte(Object obj, ByteBuf buf) {
        int m = (int) obj;
        assert m <= 127 && m >= -128;
        buf.writeByte(m);
    }

    /**
     * 写无符号short数据
     *
     * @param obj    值
     * @param buf    ByteBuf缓存区
     * @param endian 字节序
     */
    public static void writeUnSignShort(Object obj, ByteBuf buf, boolean endian) {
        int m = (int) obj;
        assert m >= 0 && m <= 65535;
        m &= 0x0FFFF;
        writeShort(m, buf, endian);
    }

    /**
     * 写short数据
     *
     * @param obj    值
     * @param buf    ByteBuf缓存区
     * @param endian 字节序
     */
    public static void writeShort(Object obj, ByteBuf buf, boolean endian) {
        int m = (short) obj;
        //-32768~32767
        assert m >= -32768 && m <= 32767;
        writeShort(m, buf, endian);
    }

    /**
     * 写无符号int数据
     *
     * @param obj    值
     * @param buf    ByteBuf缓存区
     * @param endian 字节序
     */
    public static void writeUnSignInt(Object obj, ByteBuf buf, boolean endian) {
        long m = (long) obj;
        assert m >= 0 && m < 0x100000000L;
        String hexString = Long.toHexString(m);
        hexString = fullFillHexString(hexString);
        final byte[] bytes = hexEncodeBytes(hexString, 4);
        //小字节序
        if (endian) {
            final byte[] littleBytes = {bytes[3], bytes[2], bytes[1], bytes[0]};
            buf.writeBytes(littleBytes);
        } else {
            buf.writeBytes(bytes);
        }
    }

    /**
     * hex字符串转byte数组
     *
     * @param hexString hex字符串
     * @return byte数组
     */
    public static byte[] hexEncodeBytes(String hexString, int index) {
        final byte[] bytes = ByteBufUtil.decodeHexDump(hexString);
        int len = bytes.length;
        byte[] bytesTmp = new byte[index];
        if (len < index) {
            byte[] bt = ByteBufUtil.decodeHexDump("00");
            for (int i = 0; i < (index - len); i++) {
                bytesTmp[i] = bt[0];
            }
        }

        for (int j = bytes.length - 1; j >= 0; j--) {
            bytesTmp[--index] = bytes[j];
        }
        return bytesTmp;
    }

    /**
     * hex字符串补位处理
     *
     * @param hexString hex字符串
     * @return hex字符串
     */
    public static String fullFillHexString(String hexString) {
        int len = hexString.length();
        int mold = len % 2;
        return mold > 0 ? "0" + hexString : hexString;
    }

    /**
     * 写short数据
     *
     * @param m      数据
     * @param buf    ByteBuf
     * @param endian 字节序
     */
    public static void writeShort(int m, ByteBuf buf, boolean endian) {
        //小字节序
        if (endian) {
            buf.writeShortLE(m);
        } else {
            //大字节序
            buf.writeShort(m);
        }
    }

    /**
     * 写多bit位
     *
     * @param obj 参数
     * @param buf ByteBuf
     */
    public static void writeMultiBit(Object obj, ByteBuf buf) {
        int[] arr = (int[]) obj;
        writeMultiBit(arr, buf);
    }

    /**
     * 写多bit位
     *
     * @param arr  参数
     * @param buff ByteBuf
     */
    public static void writeMultiBit(int[] arr, ByteBuf buff) {
        int total = 0;
        for (int i : arr) {
            int j = 1 << i;
            total += j;
        }
        writeBitBase(total, buff);
    }

    /**
     * 写bit位
     *
     * @param obj  参数
     * @param buff ByteBuf
     */
    public static void writeBit(Object obj, ByteBuf buff) {
        int value = (int) obj;
        writeBit(value, buff);
    }

    /**
     * 位写bit
     *
     * @param buff     ByteBuf数据缓存区
     * @param bitIndex 置位索引
     */
    public static void writeBit(int bitIndex, ByteBuf buff) {
        int i = 1 << bitIndex;
        writeBitBase(i, buff);
    }

    /**
     * 写bit位基础
     *
     * @param i    数据
     * @param buff ByteBuf数据缓存区
     */
    private static void writeBitBase(int i, ByteBuf buff) {
        //buff容量
        final int capacity = buff.capacity();
        assert capacity >= 1;
        //255
        if (i <= 0xff) {
            int j = capacity;
            --j;
            fullFillBytes(buff, j);
            buff.writeByte(i);
        } else {
            writeBitBaseMore(i, buff);
        }
    }

    /**
     * 写bit位基础较大值
     *
     * @param i    数据
     * @param buff ByteBuf数据缓存区
     */
    private static void writeBitBaseMore(int i, ByteBuf buff) {
        final int capacity = buff.capacity();
        int j = capacity;
        String hexString = Integer.toHexString(i);
        hexString = fullFillHexString(hexString);
        final byte[] bytes = ByteBufUtil.decodeHexDump(hexString);
        assert bytes.length <= capacity;
        j -= bytes.length;
        fullFillBytes(buff, j);
        buff.writeBytes(bytes);
    }

    /**
     * 填充byte
     *
     * @param buff ByteBuf
     * @param m    循环次数
     */
    private static void fullFillBytes(ByteBuf buff, int m) {
        for (; m > 0; m--) {
            buff.writeByte(0x00);
        }
    }

    /**
     * 写BCD码
     * <p>
     * 4位二进制数表示1位十进制数
     * <p>
     * 20200905
     *
     * @param obj  数据
     * @param buff ByteBuf数据缓存区
     */
    public static void writeBcd8421(Object obj, ByteBuf buff) {
        String value = (String) obj;
        writeBcd8421(value, buff);
    }

    /**
     * 写BCD码
     * <p>
     * 4位二进制数表示1位十进制数
     * <p>
     * 20200905
     *
     * @param bcdString 数据
     * @param buff      ByteBuf数据缓存区
     */
    public static void writeBcd8421(String bcdString, ByteBuf buff) {
        assert bcdString.length() == buff.capacity() * 2;
        final char[] chars = bcdString.toCharArray();
        boolean flag = true;
        int j = 0;
        for (char ch : chars) {
            int i = Integer.parseInt(ch + "");
            if (flag) {
                j = i << 4;
                flag = false;
            } else {
                j += i;
                writeUnSignByteBase(j, buff);
                j = 0;
                flag = true;
            }
        }
    }

    /**
     * 写无符号数基础
     *
     * @param m    数据
     * @param buff ByteBuf数据缓存区
     */
    private static void writeUnSignByteBase(int m, ByteBuf buff) {
        assert m < 256 && m >= 0;
        buff.writeByte(m);
    }

}

2.数据类型枚举类

package com.chansen.common.enums;

/**
 * 数据枚举
 *
 * @author 复姓江山
 * @date 
 */
public enum TypeEnum {
    /**
     * 字符串
     */
    TYPE_STRING("string"),

    /**
     * Binary-Coded Decimal
     * bcd码 8421码
     * 4位二进制数表示1位十进制数
     */
    TYPE_BCD8421("bcd8421"),
    /**
     * 时间字符串
     */
    TYPE_DATE_STRING("date_string"),
    /**
     * 枚举byte
     */
    TYPE_ENUM_BYTE("enum|byte"),

    /**
     * 枚举int
     */
    TYPE_ENUM_INT("enum|int"),

    /**
     * 枚举字符串
     */
    TYPE_ENUM_STRING("enum|string"),

    /**
     * 枚举HEX字符串
     */
    TYPE_ENUM_HEX_STRING("enum|hex_string"),

    /**
     * HEX字符串
     */
    TYPE_HEX_STRING("hex_string"),

    /**
     * -2^31~2^31-1
     * -2,147,483,648~2,147,483,647
     */
    TYPE_INT("int"),
    /**
     * 0~2^32
     * 0~4294967296L
     */
    TYPE_UINT("uint"),
    /**
     * -2^15~2^15-1
     * -32768~32767
     */
    TYPE_SHORT("short"),
    /**
     * 0~65535
     */
    TYPE_USHORT("ushort"),
    /**
     * -2^7~2^7-1
     * -128~127
     */
    TYPE_BYTE("byte"),

    /**
     * 0~256
     */
    TYPE_UBYTE("ubyte"),

    /**
     * 多位同选
     */
    TYPE_MULTI_BIT("multi_bit"),
    /**
     * 位
     */
    TYPE_BIT("bit");

    private String val;

    TypeEnum(String val) {
        this.val = val;
    }


    /**
     * 字符串匹配枚举类型
     *
     * @param value 字符串
     * @return 对应枚举
     */
    public static TypeEnum match(String value) {
        String str = "TYPE_";
        if (value.indexOf("|") > 0) {
            value = value.replace("|", "_");
        }
        str += value.toUpperCase();
        return valueOf(str);
    }


}

三、后记

　　如果大家觉得不错，后期我会把数据解码的部分代码贴出来的。