CharsetProtocolEncoderAdapter() {
        this.charset = Charset.forName("UTF8");;
    }

    public void encode(IoSession session, Object message, ProtocolEncoderOutput output) {
        ByteBuffer data = this.charset.encode((String) message);
        output.write(IoBuffer.wrap(data));
    }

public boolean doDecode(IoSession session, IoBuffer buffer, ProtocolDecoderOutput output) {
        if (this.decodeReady) {
            if (buffer.remaining() < this.frameInfoData.getCapLength()) {
                return false;
            } else {
                try {
                    byte[] data = new byte[this.frameInfoData.getCapLength()];
                    buffer.get(data);
                    output.write(Pair.of(this.frameInfoData, ByteBuffer.wrap(data)));
                } finally {
                    this.decodeReady = false;
                }
                return true;
            }
        } else if (buffer.remaining() < 16) {
            return false;
        } else {
            this.decodeReady = true;
            this.frameInfoData = new FrameInfoData();
            byte byteOrder = buffer.get(buffer.position() + 11);
            buffer.order(byteOrder == 1 ? ByteOrder.LITTLE_ENDIAN : ByteOrder.BIG_ENDIAN);
            long seconds = UnsignedValue.toUint(buffer.getInt());
            long microsnd = UnsignedValue.toUint(buffer.getInt());
            int len = buffer.getInt();
            int capLength = len & 16777215;
            int packetLength = buffer.getInt();
            this.frameInfoData.timestamp(TimeUnit.SECONDS.toNanos(seconds) + TimeUnit.MICROSECONDS.toNanos(microsnd));
            this.frameInfoData.capLength(capLength);
            this.frameInfoData.packetLength(packetLength);
            return true;
        }
    }

Encoder() {
        this.charset = Charset.forName("UTF8");
    }
    @Override
    public void encode(IoSession session, Object msg, ProtocolEncoderOutput out) throws IOException {
        ByteBuffer msgByte = this.charset.encode((String) msg);
        out.write(IoBuffer.wrap(msgByte));
    }

public void encode(IoSession session, Object msg, ProtocolEncoderOutput out) throws IOException {      
        byte[] fileBytes=(byte[])msg;
        //The cap_len of a pcap packet does not include the pcap header, big-endian
        int capLen= fileBytes.length;
        //packet_len
        int packetSize = fileBytes.length +16;
        //second && microsecond
        Timestamp timeStamp = new Timestamp(System.currentTimeMillis());         
        long seconds = TimeUnit.NANOSECONDS.toSeconds(timeStamp.getTime());
        long micros = TimeUnit.NANOSECONDS.toMicros(timeStamp.getTime() - TimeUnit.SECONDS.toNanos(seconds));
        int capacity = fileBytes.length + 16;
        IoBuffer buffer = IoBuffer.allocate(capacity, false);
        buffer.order(ByteOrder.LITTLE_ENDIAN);
        buffer.setAutoExpand(true);
        buffer.putInt((int)seconds);
        buffer.putInt((int)micros);
        buffer.putInt(capLen);
        buffer.putInt(packetSize);
        buffer.put(fileBytes);
        buffer.flip();
        out.write(buffer);
        buffer.clear();
    }

public boolean doDecode(IoSession var1, IoBuffer in, ProtocolDecoderOutput out) throws CharacterCodingException {
         CharsetDecoder cd = Charset.forName("UTF8").newDecoder();  
         IoBuffer buf = IoBuffer.allocate(100).setAutoExpand(true);  
         while(in.hasRemaining()){  
             buf.put(in.get());  
         }  
         buf.flip();  
         out.write(buf.getString(cd));   
         return false;  
    }

public void sessionOpened(IoSession session) throws Exception {
           System.out.println(session.getLocalAddress() + "   " + "sessionOpened");
            //客户端发送文件   
           byte[] fileBytes =toByteArray("/path/to/file/test.pcap");
           session.write(IoBuffer.wrap(fileBytes));
}
public static byte[] toByteArray(String filename) throws IOException {  
       FileChannel fc = null;  
       try {  
           fc = new RandomAccessFile(filename, "r").getChannel();  
           MappedByteBuffer byteBuffer = fc.map(MapMode.READ_ONLY, 0, fc.size()).load();  
           System.out.println(byteBuffer.isLoaded());  
           byte[] result = new byte[(int) fc.size()];  
           if (byteBuffer.remaining() > 0) {
               byteBuffer.get(result, 0, byteBuffer.remaining());  
           }  
           return result;  
       } catch (IOException e) {  
           e.printStackTrace();  
           throw e;  
       } finally {  
           try {  
               fc.close();  
           } catch (IOException e) {  
               e.printStackTrace();  
           }  
       }  
   }