一、概况
作为Java世界使用最广泛的网络通信框架Netty，其性能和效率是有目共睹的，好多大公司都在使用如苹果、谷歌、Facebook、Twitter、阿里巴巴等，所以不仅仅是因为Netty有高效的性能与效率，更重要的是：屏蔽了底层的复杂度，简单易懂的编程模型，适应更广泛的应用场景，以及活跃的开发者社区。
本篇博客是作为Netty之数据编码的续篇，上一篇以抛砖引玉的方式讲解了怎么使用Netty的核心缓冲区ByteBuf怎么编码存储各种基本数据，本篇就是与之对应的怎么从缓冲区ByteBuf中的编码数据解码出来，因为我们的Java代码中处理数据一般不是按照字节流来处理，所以需要解码恢复出数据然后再进行处理。
二、代码实现
1. 解码工具类
1 package com.ethan.cws.common.utils; 2 3 import com.ethan.cws.common.enums.TypeEnum; 4 import io.netty.buffer.ByteBuf; 5 import io.netty.buffer.ByteBufUtil; 6 import io.netty.util.CharsetUtil; 7 8 import java.util.ArrayList; 9 import java.util.Arrays; 10 import java.util.List; 11 12 /** 13 * 解码工具类 14 * 15 * @author ethancws 16 * @date 17 */ 18 public final class DecodeUtils { 19 20 /** 21 * FEP data数据文件后缀名 22 */ 23 public final static String FILE_SUFFIX_EXTEND = ".xml"; 24 25 /** 26 * 文件名 27 */ 28 public final static String FILE_NAME = "Filename"; 29 30 private DecodeUtils() { 31 32 } 33 34 /** 35 * 解码 36 * 37 * @param symbol 符号 38 * @param byteNum 字节数 39 * @param buff 数据 40 * @param type 枚举类型字符串 41 * @param endian 编码 42 * @return 解码数据 43 */ 44 public static Object decode(String symbol, int byteNum, ByteBuf buff, 45 String type, boolean endian) { 46 Object value = null; 47 //类型枚举 48 final TypeEnum typeEnum = TypeEnum.match(type); 49 switch (typeEnum) { 50 case TYPE_STRING: 51 case TYPE_ENUM_STRING: 52 case TYPE_DATE_STRING: 53 value = readString(byteNum, buff, symbol); 54 break; 55 case TYPE_HEX_STRING: 56 case TYPE_ENUM_HEX_STRING: 57 value = readHexString(byteNum, buff); 58 break; 59 case TYPE_USHORT: 60 value = readUnSignShort(buff, endian); 61 break; 62 case TYPE_SHORT: 63 value = readShort(buff, endian); 64 break; 65 case TYPE_INT: 66 case TYPE_ENUM_INT: 67 value = readInt(buff, endian); 68 break; 69 case TYPE_UINT: 70 value = readUnSignInt(buff, endian); 71 break; 72 case TYPE_BYTE: 73 case TYPE_ENUM_BYTE: 74 value = readByte(buff); 75 break; 76 case TYPE_UBYTE: 77 value = readUnSignByte(buff); 78 break; 79 case TYPE_BIT: 80 value = readBit(byteNum, buff); 81 break; 82 case TYPE_MULTI_BIT: 83 value = readMultiBit(byteNum, buff); 84 break; 85 case TYPE_BCD8421: 86 value = readBcd8421(byteNum, buff); 87 break; 88 89 } 90 91 return value; 92 } 93 94 /** 95 * 读无符号byte 96 * 97 * @param buff 编码数据 98 * @return 解码数据 99 */ 100 public static short readUnSignByte(ByteBuf buff) { 101 byte by = buff.readByte(); 102 return (short) (by & 0x0FF); 103 } 104 105 /** 106 * 读byte 107 * 108 * @param buff 编码数据 109 * @return 解码数据 110 */ 111 public static byte readByte(ByteBuf buff) { 112 return buff.readByte(); 113 } 114 115 /** 116 * 读无符号int 117 * 118 * @param buff 编码数据 119 * @param endian 字节序 120 * @return 解码数据 121 */ 122 public static long readUnSignInt(ByteBuf buff, boolean endian) { 123 int intValue = endian ? buff.readIntLE() : buff.readInt(); 124 return intValue & 0x0FFFFFFFFL; 125 } 126 127 /** 128 * 读int 129 * 130 * @param buff 编码数据 131 * @param endian 字节序 132 * @return 解码数据 133 */ 134 public static int readInt(ByteBuf buff, boolean endian) { 135 return endian ? buff.readIntLE() : buff.readInt(); 136 } 137 138 /** 139 * 读short 140 * 141 * @param buff 编码数据 142 * @param endian 字节序 143 * @return 解码数据 144 */ 145 public static short readShort(ByteBuf buff, boolean endian) { 146 return endian ? buff.readShortLE() : buff.readShort(); 147 } 148 149 /** 150 * 读无符号short 151 * 152 * @param buff 编码数据 153 * @param endian 字节序 154 * @return 解码数据 155 */ 156 public static int readUnSignShort(ByteBuf buff, boolean endian) { 157 short shortValue = endian ? buff.readShortLE() : buff.readShort(); 158 return shortValue & 0x0FFFF; 159 } 160 161 /** 162 * 读Hex字符串 163 * 164 * @param num 字节长度 165 * @param buff 编码数据 166 * @return 字符串 167 */ 168 public static String readHexString(int num, ByteBuf buff) { 169 String value = ByteBufUtil.hexDump(buff, 0, num); 170 readByteBuf(num, buff); 171 return value; 172 } 173 174 /** 175 * 读Hex字符串没有数据缓冲区偏移 176 * 177 * @param num 字节长度 178 * @param buff 编码数据 179 * @return 字符串 180 */ 181 public static String readHexStringWithoutOffset(int num, ByteBuf buff) { 182 return ByteBufUtil.hexDump(buff, 0, num); 183 } 184 185 /** 186 * 获取文件名称 187 * 188 * @param fileName 字符 189 * @return 文件名称 190 */ 191 private static String acquireFileName(String fileName) { 192 String fileSuffixExtend = FILE_SUFFIX_EXTEND; 193 int index = fileName.lastIndexOf(fileSuffixExtend); 194 index += fileSuffixExtend.length(); 195 fileName = fileName.substring(1, index); 196 return fileName; 197 } 198 199 /** 200 * 读字符串 201 * 202 * @param num 字节长度 203 * @param buff 编码数据 204 * @param symbol 编码标识 205 * @return 字符串 206 */ 207 public static String readString(int num, ByteBuf buff, String symbol) { 208 final CharSequence charSequence = buff.getCharSequence(0, num, CharsetUtil.UTF_8); 209 String value = charSequence.toString(); 210 if (FILE_NAME.equals(symbol)) { 211 value = acquireFileName(value); 212 } 213 //移动读指针 214 readByteBuf(num, buff); 215 return value; 216 } 217 218 219 /** 220 * 移动读指针 221 * 222 * @param num 移动字节数 223 * @param buff 数据缓冲区ByteBuf 224 */ 225 private static void readByteBuf(int num, ByteBuf buff) { 226 assert num >= 1; 227 if (num == 1) { 228 buff.readByte(); 229 } else { 230 buff.readBytes(num); 231 } 232 } 233 234 /** 235 * 读bit 236 * 237 * @param num 字节长度 238 * @param buff 数据缓冲区ByteBuf 239 * @return bit位索引 240 */ 241 public static int readBit(int num, ByteBuf buff) { 242 ByteBuf buffCopy = buff.copy(0, num); 243 int index = 0; 244 for (; num > 0; num--) { 245 byte b = buffCopy.readByte(); 246 if (b != 0) { 247 index += b / 2; 248 --num; 249 break; 250 } 251 } 252 index += num * 8; 253 //移动读指针 254 readByteBuf(num, buff); 255 return index; 256 } 257 258 /** 259 * 读多位bit 260 * 261 * @param num 字节长度 262 * @param buff 数据缓冲区ByteBuf 263 * @return 二进制数据为1的索引数组 264 */ 265 public static int[] readMultiBit(int num, ByteBuf buff) { 266 ByteBuf buffCopy = buff.copy(0, num); 267 List<Integer> list = new ArrayList<>(); 268 int size = num; 269 final int fixedNum = num; 270 for (; num > 0; num--) { 271 size--; 272 int b = readUnSignByte(buffCopy); 273 if (b != 0) { 274 String str = Integer.toBinaryString(b); 275 str = fullFillByteString(str); 276 gatherIndexes(str, size, list); 277 } 278 } 279 //移动读指针 280 readByteBuf(fixedNum, buff); 281 return Arrays.stream(list.toArray(new Integer[0])).mapToInt(Integer::valueOf).toArray(); 282 } 283 284 /** 285 * 补全byte二进制8位字符串 286 * 287 * @param str 字符串 288 * @return 补全8位后的字符串 289 */ 290 private static String fullFillByteString(String str) { 291 int len = 8; 292 int length = str.length(); 293 if (length < 8) { 294 StringBuilder strBuilder = new StringBuilder(str); 295 for (int i = 0; i < len - length; i++) { 296 strBuilder.insert(0, "0"); 297 } 298 str = strBuilder.toString(); 299 } 300 return str; 301 } 302 303 /** 304 * 收集索引存入List 305 * 306 * @param str byte二进制字符串 307 * @param size 剩余byte长度 308 * @param list 集合List 309 */ 310 private static void gatherIndexes(String str, int size, List<Integer> list) { 311 int len = 8, lenFixed = 8; 312 for (char ch : str.toCharArray()) { 313 int totalIndex = 0; 314 len--; 315 if (ch == 48) { 316 continue; 317 } 318 totalIndex = len + size * lenFixed; 319 list.add(totalIndex); 320 } 321 } 322 323 /** 324 * 读Bcd码 325 * 326 * @param num 字节长度 327 * @param buff 数据缓冲区ByteBuf 328 * @return Bcd码解码数据 329 */ 330 public static String readBcd8421(int num, ByteBuf buff) { 331 return readHexString(num, buff); 332 } 333 }
2. 数据类型枚举类
1 package com.ethan.cws.common.enums; 2 3 /** 4 * 数据枚举 5 * 6 * @author ethancws 7 * @date 8 */ 9 public enum TypeEnum { 10 /** 11 * 字符串 12 */ 13 TYPE_STRING("string"), 14 15 /** 16 * Binary-Coded Decimal 17 * bcd码 8421码 18 * 4位二进制数表示1位十进制数 19 */ 20 TYPE_BCD8421("bcd8421"), 21 /** 22 * 时间字符串 23 */ 24 TYPE_DATE_STRING("date_string"), 25 /** 26 * 枚举byte 27 */ 28 TYPE_ENUM_BYTE("enum|byte"), 29 30 /** 31 * 枚举int 32 */ 33 TYPE_ENUM_INT("enum|int"), 34 35 /** 36 * 枚举字符串 37 */ 38 TYPE_ENUM_STRING("enum|string"), 39 40 /** 41 * 枚举HEX字符串 42 */ 43 TYPE_ENUM_HEX_STRING("enum|hex_string"), 44 45 /** 46 * HEX字符串 47 */ 48 TYPE_HEX_STRING("hex_string"), 49 50 /** 51 * -2^31~2^31-1 52 * -2,147,483,648~2,147,483,647 53 */ 54 TYPE_INT("int"), 55 /** 56 * 0~2^32 57 * 0~4294967296L 58 */ 59 TYPE_UINT("uint"), 60 /** 61 * -2^15~2^15-1 62 * -32768~32767 63 */ 64 TYPE_SHORT("short"), 65 /** 66 * 0~65535 67 */ 68 TYPE_USHORT("ushort"), 69 /** 70 * -2^7~2^7-1 71 * -128~127 72 */ 73 TYPE_BYTE("byte"), 74 75 /** 76 * 0~256 77 */ 78 TYPE_UBYTE("ubyte"), 79 80 /** 81 * 多位同选 82 */ 83 TYPE_MULTI_BIT("multi_bit"), 84 /** 85 * 位 86 */ 87 TYPE_BIT("bit"); 88 89 private String val; 90 91 TypeEnum(String val) { 92 this.val = val; 93 } 94 95 96 /** 97 * 字符串匹配枚举类型 98 * 99 * @param value 字符串 100 * @return 对应枚举 101 */ 102 public static TypeEnum match(String value) { 103 String str = "TYPE_"; 104 if (value.indexOf("|") > 0) { 105 value = value.replace("|", "_"); 106 } 107 str += value.toUpperCase(); 108 return valueOf(str); 109 } 110 111 112 }
三、后记
随着对于Netty的理解和使用的深入，越来越对于Netty框架的痴迷，所以后面会不定期的更新Netty相关的使用与心得。欢迎与大家一起探讨一起学习。
原文链接：https://www.cnblogs.com/inverseEntropy/p/17365544.html
本站文章如无特殊说明，均为本站原创，如若转载，请注明出处：Netty之数据解码 - Python技术站
微信扫一扫 
支付宝扫一扫 