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