Netty之数据解码

一、概况

 　　作为Java世界使用最广泛的网络通信框架Netty，其性能和效率是有目共睹的，好多大公司都在使用如苹果、谷歌、Facebook、Twitter、阿里巴巴等，所以不仅仅是因为Netty有高效的性能与效率，更重要的是：屏蔽了底层的复杂度，简单易懂的编程模型，适应更广泛的应用场景，以及活跃的开发者社区。
　　本篇博客是作为Netty之数据编码的续篇，上一篇以抛砖引玉的方式讲解了怎么使用Netty的核心缓冲区ByteBuf怎么编码存储各种基本数据，本篇就是与之对应的怎么从Netty的数据容器ByteBuf中的编码数据解码出来，因为网络通信数据的基本单位总是字节，而我们在Java代码中处理数据一般不是按照字节流来处理，所以需要解码恢复出数据然后再进行处理。

二、代码实现

1. 解码工具类

package com.ethan.cws.common.utils;

import com.ethan.cws.common.enums.TypeEnum;
import io.netty.buffer.ByteBuf;
import io.netty.buffer.ByteBufUtil;
import io.netty.util.CharsetUtil;

import java.util.ArrayList;
import java.util.Arrays;
import java.util.List;

/**
 * 解码工具类
 *
 * @author ethancws
 * @date 
 */
public final class DecodeUtils {
    
    /**
     * FEP data数据文件后缀名
     */
    public final static String FILE_SUFFIX_EXTEND = ".xml";
    
    /**
     * 文件名
     */
    public final static String FILE_NAME = "Filename";

    private DecodeUtils() {

    }

    /**
     * 解码
     *
     * @param symbol  符号
     * @param byteNum 字节数
     * @param buff    数据
     * @param type    枚举类型字符串
     * @param endian  编码
     * @return 解码数据
     */
    public static Object decode(String symbol, int byteNum, ByteBuf buff,
                                String type, boolean endian) {
        Object value = null;
        //类型枚举
        final TypeEnum typeEnum = TypeEnum.match(type);
        switch (typeEnum) {
            case TYPE_STRING:
            case TYPE_ENUM_STRING:
            case TYPE_DATE_STRING:
                value = readString(byteNum, buff, symbol);
                break;
            case TYPE_HEX_STRING:
            case TYPE_ENUM_HEX_STRING:
                value = readHexString(byteNum, buff);
                break;
            case TYPE_USHORT:
                value = readUnSignShort(buff, endian);
                break;
            case TYPE_SHORT:
                value = readShort(buff, endian);
                break;
            case TYPE_INT:
            case TYPE_ENUM_INT:
                value = readInt(buff, endian);
                break;
            case TYPE_UINT:
                value = readUnSignInt(buff, endian);
                break;
            case TYPE_BYTE:
            case TYPE_ENUM_BYTE:
                value = readByte(buff);
                break;
            case TYPE_UBYTE:
                value = readUnSignByte(buff);
                break;
            case TYPE_BIT:
                value = readBit(byteNum, buff);
                break;
            case TYPE_MULTI_BIT:
                value = readMultiBit(byteNum, buff);
                break;
            case TYPE_BCD8421:
                value = readBcd8421(byteNum, buff);
                break;

        }

        return value;
    }

    /**
     * 读无符号byte
     *
     * @param buff 编码数据
     * @return 解码数据
     */
    public static short readUnSignByte(ByteBuf buff) {
        byte by = buff.readByte();
        return (short) (by & 0x0FF);
    }

    /**
     * 读byte
     *
     * @param buff 编码数据
     * @return 解码数据
     */
    public static byte readByte(ByteBuf buff) {
        return buff.readByte();
    }

    /**
     * 读无符号int
     *
     * @param buff   编码数据
     * @param endian 字节序
     * @return 解码数据
     */
    public static long readUnSignInt(ByteBuf buff, boolean endian) {
        int intValue = endian ? buff.readIntLE() : buff.readInt();
        return intValue & 0x0FFFFFFFFL;
    }

    /**
     * 读int
     *
     * @param buff   编码数据
     * @param endian 字节序
     * @return 解码数据
     */
    public static int readInt(ByteBuf buff, boolean endian) {
        return endian ? buff.readIntLE() : buff.readInt();
    }

    /**
     * 读short
     *
     * @param buff   编码数据
     * @param endian 字节序
     * @return 解码数据
     */
    public static short readShort(ByteBuf buff, boolean endian) {
        return endian ? buff.readShortLE() : buff.readShort();
    }

    /**
     * 读无符号short
     *
     * @param buff   编码数据
     * @param endian 字节序
     * @return 解码数据
     */
    public static int readUnSignShort(ByteBuf buff, boolean endian) {
        short shortValue = endian ? buff.readShortLE() : buff.readShort();
        return shortValue & 0x0FFFF;
    }

    /**
     * 读Hex字符串
     *
     * @param num  字节长度
     * @param buff 编码数据
     * @return 字符串
     */
    public static String readHexString(int num, ByteBuf buff) {
        String value = ByteBufUtil.hexDump(buff, 0, num);
        readByteBuf(num, buff);
        return value;
    }

    /**
     * 读Hex字符串没有数据缓冲区偏移
     *
     * @param num  字节长度
     * @param buff 编码数据
     * @return 字符串
     */
    public static String readHexStringWithoutOffset(int num, ByteBuf buff) {
        return ByteBufUtil.hexDump(buff, 0, num);
    }

    /**
     * 获取文件名称
     *
     * @param fileName 字符
     * @return 文件名称
     */
    private static String acquireFileName(String fileName) {
        String fileSuffixExtend = FILE_SUFFIX_EXTEND;
        int index = fileName.lastIndexOf(fileSuffixExtend);
        index += fileSuffixExtend.length();
        fileName = fileName.substring(1, index);
        return fileName;
    }

    /**
     * 读字符串
     *
     * @param num    字节长度
     * @param buff   编码数据
     * @param symbol 编码标识
     * @return 字符串
     */
    public static String readString(int num, ByteBuf buff, String symbol) {
        final CharSequence charSequence = buff.getCharSequence(0, num, CharsetUtil.UTF_8);
        String value = charSequence.toString();
        if (FILE_NAME.equals(symbol)) {
            value = acquireFileName(value);
        }
        //移动读指针
        readByteBuf(num, buff);
        return value;
    }


    /**
     * 移动读指针
     *
     * @param num  移动字节数
     * @param buff 数据缓冲区ByteBuf
     */
    private static void readByteBuf(int num, ByteBuf buff) {
        assert num >= 1;
        if (num == 1) {
            buff.readByte();
        } else {
            buff.readBytes(num);
        }
    }

    /**
     * 读bit
     *
     * @param num  字节长度
     * @param buff 数据缓冲区ByteBuf
     * @return bit位索引
     */
    public static int readBit(int num, ByteBuf buff) {
        ByteBuf buffCopy = buff.copy(0, num);
        int index = 0;
        for (; num > 0; num--) {
            byte b = buffCopy.readByte();
            if (b != 0) {
                index += b / 2;
                --num;
                break;
            }
        }
        index += num * 8;
        //移动读指针
        readByteBuf(num, buff);
        return index;
    }

    /**
     * 读多位bit
     *
     * @param num  字节长度
     * @param buff 数据缓冲区ByteBuf
     * @return 二进制数据为1的索引数组
     */
    public static int[] readMultiBit(int num, ByteBuf buff) {
        ByteBuf buffCopy = buff.copy(0, num);
        List list = new ArrayList<>();
        int size = num;
        final int fixedNum = num;
        for (; num > 0; num--) {
            size--;
            int b = readUnSignByte(buffCopy);
            if (b != 0) {
                String str = Integer.toBinaryString(b);
                str = fullFillByteString(str);
                gatherIndexes(str, size, list);
            }
        }
        //移动读指针
        readByteBuf(fixedNum, buff);
        return Arrays.stream(list.toArray(new Integer[0])).mapToInt(Integer::valueOf).toArray();
    }

    /**
     * 补全byte二进制8位字符串
     *
     * @param str 字符串
     * @return 补全8位后的字符串
     */
    private static String fullFillByteString(String str) {
        int len = 8;
        int length = str.length();
        if (length < 8) {
            StringBuilder strBuilder = new StringBuilder(str);
            for (int i = 0; i < len - length; i++) {
                strBuilder.insert(0, "0");
            }
            str = strBuilder.toString();
        }
        return str;
    }

    /**
     * 收集索引存入List
     *
     * @param str  byte二进制字符串
     * @param size 剩余byte长度
     * @param list 集合List
     */
    private static void gatherIndexes(String str, int size, List list) {
        int len = 8, lenFixed = 8;
        for (char ch : str.toCharArray()) {
            int totalIndex = 0;
            len--;
            if (ch == 48) {
                continue;
            }
            totalIndex = len + size * lenFixed;
            list.add(totalIndex);
        }
    }

    /**
     * 读Bcd码
     *
     * @param num  字节长度
     * @param buff 数据缓冲区ByteBuf
     * @return Bcd码解码数据
     */
    public static String readBcd8421(int num, ByteBuf buff) {
        return readHexString(num, buff);
    }
}

 

2. 数据类型枚举类

package com.ethan.cws.common.enums;

/**
 * 数据枚举
 *
 * @author ethancws
 * @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);
    }


}

三、后记

　　随着对于Netty的理解和使用的深入，越来越对于Netty框架的痴迷，所以后面会不定期的更新Netty相关的使用与心得。欢迎与大家一起探讨一起学习。