Mina的IoBuffer改造成Netty的ByteBuff

　　背景：部标GPS通讯底层全部改造成基于Netty服务器实现的，现将Mina的依赖移除，修改过程中有用到缓冲区的读写。现做了如下修改：

原有基于Mina的IoBuffer对字节读写封装代码如下：

 package com.hns.gps.gw.jt808.protocol;

 import com.hns.gps.gw.jt808.utils.Tools;
 import org.apache.log4j.Logger;
 import org.apache.mina.core.buffer.IoBuffer;

 import java.nio.charset.CharacterCodingException;
 import java.nio.charset.Charset;

 public class MyBuffer {
     private Logger logger = Logger.getLogger(MyBuffer.class);
     IoBuffer buff;

     public MyBuffer() {
         buff.setUseDirectBuffer(false);
         buff = IoBuffer.allocate(1536);
         buff.mark();
     }

     public MyBuffer(int len) {
         buff.setUseDirectBuffer(false);
         buff = IoBuffer.allocate(len);
         buff.mark();
     }

     public MyBuffer(byte[] bytes) {
         if (bytes.length > 1024)
             buff = IoBuffer.allocate(bytes.length + 100);
         else
             buff = IoBuffer.allocate(1024);
         buff.mark();
         buff.put(bytes);
         buff.limit(bytes.length);
         buff.reset();
     }
     public MyBuffer(byte[] bytes, int start, int length) {
         buff = IoBuffer.allocate(length);
         buff.mark();
         buff.put(bytes, start, length);
         buff.limit(length);
         buff.reset();
     }

     public void clear() {
         buff.clear();
         buff.mark();
     }

     public void put(byte a) {
         buff.put(a);
     }

     public void put(long a)
     {
         buff.putLong(a);
     }

     public void put(short a) {
         buff.putShort(a);
     }

     public void put(byte[] a) {
         buff.put(a);
     }

     public boolean hasRemain() {
         return buff.remaining() > 0;
     }

     public void put(int a) {
         buff.putInt(a);
     }

     public void putShort(int a) {
         buff.putShort((short) a);
     }

     public void put(String str) {
         // US-ASCII

         try {
             byte[] b = str.getBytes("gbk");
             buff.put(b);

         } catch (Exception e) {
         //    logger.error(e.getMessage(), e);
         }
     }

     public void putBcd(String str, int length)
     {
         byte[] b = BcDToBytes(str,length);
         buff.put(b);
     }

     public static String BytesToBcd(byte[] bytes, int start, int len) {
         StringBuilder bcd = new StringBuilder();
         for (int m = 0; m < len; m++) {
             bcd.append(String.format("%02X", bytes[start + m]));
         }
         return bcd.toString();
     }

     public static byte[] BcDToBytes(String bcd, int len) {
         bcd = bcd == null ? "" : bcd;
         while (bcd.length() < len) {
             bcd = "0" + bcd;
         }
         return Tools.HexString2Bytes(bcd);
     }

     public void put(String str, int len) {
         byte[] result = new byte[len];
         try {
             byte[] b = str.getBytes("gbk");

             System.arraycopy(b, 0, result, 0, b.length);

             for (int m = b.length; m < len; m++) {
                 result[m] = 0;
             }
             buff.put(result);

         } catch (Exception e) {
             //logger.error(e.getMessage(), e);
         }
     }

     public byte get() {
         return buff.get();
     }

     public byte[] gets(int len) {
         byte[] data = new byte[len];
         buff.get(data);
         return data;
     }

     public int getInt() {
         return buff.getInt();
     }

     public short getShort() {
         return buff.getShort();
     }

     public long getLong() {
         return buff.getLong();
     }

     // 将data字节型数据转换为0~65535 (0xFFFF 即 WORD)。
     public int getUnsignedShort() {
         short t = buff.getShort();
         return t & 0xffff;
     }

     // 将data字节型数据转换为0~255 (0xFF 即BYTE)。
     public int getUnsignedByte() {
         return buff.get() & 0x0FF;
     }

     public long getUnsignedInt() {
         return buff.getInt() & 0x0FFFFFFFF;
     }

     public String getString() {
         try {
             String strTemp = buff
                     .getString(Charset.forName("GBK").newDecoder());
             return strTemp;
         } catch (CharacterCodingException e) {
             e.printStackTrace();
         }
         return "";
     }

     public String getString(int len) {
         try {
             String strTemp = buff.getString(len, Charset.forName("GBK")
                     .newDecoder());
             return strTemp;
         } catch (CharacterCodingException e) {
             e.printStackTrace();
             gets(len);
         }
         return "";
     }

     public String getBcdString(int len) {
         byte[] bytes = this.gets(len);
         StringBuilder bcd = new StringBuilder();
         for (int m = 0; m < len; m++) {
             bcd.append(String.format("%02X", bytes[m]));
         }
         return bcd.toString();
     }

     public byte[] array() {
         int pos = buff.position();
         byte[] data = new byte[pos];
         buff.reset();
         buff.get(data);
         return data;
     }

     public static void main(String[] args) {

         IoBuffer ib = IoBuffer.allocate(1024);
         ib.mark();
         ib.put((byte) 128);
         ib.reset();
         // byte b = ib.get();
         // int x = b& 0xff;
         short x = ib.getUnsigned();

         short y = ib.getUnsigned(0);

         System.out.println("" + x + "," + y);
     }

 }

后修改成Netty版的ByteBuffer操作实现如下：

 package com.hns.gps.gw.jt808.protocol;

 import com.hns.gps.gw.jt808.utils.Tools;
 import io.netty.buffer.ByteBuf;
 import io.netty.buffer.ByteBufAllocator;
 import io.netty.util.ReferenceCountUtil;
 import io.netty.util.ResourceLeakDetector;
 import org.apache.log4j.Logger;

 import java.io.UnsupportedEncodingException;
 import java.nio.charset.Charset;

 /**
  *  ByteBuffer缓冲区，用Netty实现
  *
  * @author linys
  * @create 2018-06-12
  * @since 1.0.0
  */
 public class ByteBuffer {
     private Logger logger = Logger.getLogger(ByteBuffer.class);
     protected ByteBuf buff;

     public ByteBuffer() {
         buff = ByteBufAllocator.DEFAULT.ioBuffer(1536);
         //为了找到ByteBuff没有被释放的原因 (上线关闭)
         ResourceLeakDetector.setLevel(ResourceLeakDetector.Level.ADVANCED);
     }

     public ByteBuffer(byte[] bytes) {
         buff = ByteBufAllocator.DEFAULT.ioBuffer(bytes.length);
         buff.writeBytes(bytes);
         //为了找到ByteBuff没有被释放的原因 (上线关闭)
         ResourceLeakDetector.setLevel(ResourceLeakDetector.Level.ADVANCED);
     }

     public ByteBuffer(byte[] bytes, int start, int length) {
         buff = ByteBufAllocator.DEFAULT.ioBuffer(length);
         buff.writeBytes(bytes, start, length);
         //为了找到ByteBuff没有被释放的原因 (上线关闭)
         ResourceLeakDetector.setLevel(ResourceLeakDetector.Level.ADVANCED);
     }

     public void clear() {
         buff.clear();
         buff.markWriterIndex();
         buff.markReaderIndex();
     }

     public void put(byte a) {
         buff.writeByte(a);
     }

     public void put(long a) {
         buff.writeLong(a);
     }

     public void put(short a) {
         buff.writeShort(a);
     }

     public void put(byte[] a) {
         buff.writeBytes(a);
     }

     public boolean hasRemain() {
         return buff.isReadable();
     }

     public void put(int a) {
         buff.writeInt(a);
     }

     public void put(String str) {
         // US-ASCII
         try {
             byte[] b = str.getBytes("gbk");
             buff.writeBytes(b);
         } catch (UnsupportedEncodingException e) {
             logger.error(e.getMessage(), e);
         }
     }

     public String getBcdString(int len) {
         byte[] bytes = this.gets(len);
         StringBuilder bcd = new StringBuilder();
         for (int m = 0; m < len; m++) {
             bcd.append(String.format("%02X", bytes[m]));
         }
         return bcd.toString();
     }

     public void putBcd(String str, int length) {
         byte[] b = BcDToBytes(str, length);
         buff.writeBytes(b);
     }

     public static byte[] BcDToBytes(String bcd, int len) {
         bcd = bcd == null ? "" : bcd;
         while (bcd.length() < len) {
             bcd = "0" + bcd;
         }
         return Tools.HexString2Bytes(bcd);
     }

     public static String BytesToBcd(byte[] bytes, int start, int len) {
         StringBuilder bcd = new StringBuilder();
         for (int m = 0; m < len; m++) {
             bcd.append(String.format("%02X", bytes[start + m]));
         }
         return bcd.toString();
     }

     public void put(String str, int len) {
         byte[] result = new byte[len];
         try {
             byte[] b = str.getBytes("gbk");
             System.arraycopy(b,0, result,0, b.length);
             for (int m = b.length; m < len; m++) {
                 result[m] = 0; //不够位补0
             }
             buff.writeBytes(result);
         } catch (UnsupportedEncodingException e) {
             logger.error(e.getMessage(), e);
         }
     }

     public byte get() {
         return buff.readByte();
     }

     public short getShort() {
         return buff.readShort();
     }

     public int getInt() {
         return buff.readInt();
     }

     public long getLong() {
         return buff.readLong();
     }

     public double getDouble() {
         return buff.readDouble();
     }

     public byte[] gets(int len) {
         byte[] data = new byte[len];
         buff.readBytes(data);
         return data;
     }

     // 将data字节型数据转换为0~255 (0xFF 即BYTE)。
     public short getUnsignedByte() {
         return buff.readUnsignedByte();
     }

     // 将data字节型数据转换为0~65535 (0xFFFF 即 WORD)。
     public int getUnsignedShort() {
         return buff.readUnsignedShort();
     }

     public long getUnsignedInt() {
         return buff.readUnsignedInt();
     }

     public String getString() {
         return buff.toString(Charset.forName("GBK"));
     }

     public String getString(int len) {
         return buff.toString(0, len, Charset.forName("GBK"));
     }

     /**
      * 转换成byte数组
      * @return
      */
     public byte[] toByteArray() {
         int pos = buff.writerIndex();
         byte[] data = new byte[pos];
         buff.readBytes(data);
         //再次调用重新从头读
         buff.resetReaderIndex();
         return data;
     }

     /**
      * 清空释放buff，在buff使用结束后调用
      * @return
      */
     public void release() {
         this.clear();
         //释放缓冲区内存
         ReferenceCountUtil.release(buff);
     }

     /**
      * 转换成byte数组并清空释放buff，在buff使用结束后调用
      * @return
      */
     public byte[] toByteArrayAndRelease() {
         int pos = buff.writerIndex();
         byte[] data = new byte[pos];
         buff.readBytes(data);
         this.clear();
         //释放缓冲区内存
         ReferenceCountUtil.release(buff);
         return data;
     }

 }

总结：处理网络数据的项目中经常需要处理字节数据，Java的ByteBuffer很强大，对于NIO的ByteBuffer字节读写缓冲区操作，Mina和Netty都有封装，IoBuffer基于Java原生ByteBuffer封装而成，ByteBuff则是Netty自己独有的字节数据Buffer，Netty提供了更强大的封装并能实现零拷贝，更加方便我们操作字节缓冲区，推荐使用netty的ByteBuff！代码供大家对ByteBuff的封装参考。

文章封装的代码基于连接：

https://blog.csdn.net/alex_bean/article/details/51251015

https://blog.csdn.net/u010853261/article/details/53690780

https://www.cnblogs.com/zzt-lovelinlin/p/5292608.html