MINA框架中的编码解码以及对粘包断包的处理

        我们都知道MINA中是使用责任链的方式来实现将二进制字节流数据转换为java对象，或者将java对象转换为二进制字节流数据的，那么这个转换过程到底是怎么进行的呢？这就涉及到MINA中的编码与解码问题了；
        我们先来看看解码过程：

        当服务端读取客户端发送过来的消息时，会执行AbstractPollingIoProcessor里面的read方法，因为之前在我们对MINA的源码分析中就已经知道了对于每个Session的请求来说，实际上的执行者是IoProcessor对象，在read方法中会获取到当前IoSession所对应的IoFilter责任链，接着就会调用责任链的fireMessageReceived方法，而在fireMessageReceived里面又会调用callNextMessageReceived方法，在callNextMessageReceived方法里面就会执行IoFilter的messageReceived方法了，这个方法的真正实现是在ProtocolCodecFilter里面的，我们来看看他的具体实现：

        ProtocolCodecFilter$messageReceived()

public void messageReceived(NextFilter nextFilter, IoSession session, Object message) throws Exception {
        LOGGER.debug("Processing a MESSAGE_RECEIVED for session {}", session.getId());

        if (!(message instanceof IoBuffer)) {
            nextFilter.messageReceived(session, message);
            return;
        }

        IoBuffer in = (IoBuffer) message;
        ProtocolDecoder decoder = factory.getDecoder(session);
        ProtocolDecoderOutput decoderOut = getDecoderOut(session, nextFilter);

        // Loop until we don't have anymore byte in the buffer,
        // or until the decoder throws an unrecoverable exception or
        // can't decoder a message, because there are not enough
        // data in the buffer
        while (in.hasRemaining()) {
            int oldPos = in.position();
            try {
                synchronized (session) {
                    // Call the decoder with the read bytes
                    decoder.decode(session, in, decoderOut);
                }
                // Finish decoding if no exception was thrown.
                decoderOut.flush(nextFilter, session);
            } catch (Exception e) {
                ProtocolDecoderException pde;
                if (e instanceof ProtocolDecoderException) {
                    pde = (ProtocolDecoderException) e;
                } else {
                    pde = new ProtocolDecoderException(e);
                }
                if (pde.getHexdump() == null) {
                    // Generate a message hex dump
                    int curPos = in.position();
                    in.position(oldPos);
                    pde.setHexdump(in.getHexDump());
                    in.position(curPos);
                }
                // Fire the exceptionCaught event.
                decoderOut.flush(nextFilter, session);
                nextFilter.exceptionCaught(session, pde);
                // Retry only if the type of the caught exception is
                // recoverable and the buffer position has changed.
                // We check buffer position additionally to prevent an
                // infinite loop.
                if (!(e instanceof RecoverableProtocolDecoderException) || (in.position() == oldPos)) {
                    break;
                }
            }
        }
    }

        这个方法第4行首先判断当前的message是不是IoBuffer，如果不是的话，则会调用nextFilter的messageReceived，由下一个IoFilter进行处理，同时结束当前IoFilter处理，这里的nextFilter是EntryImpl里面的一个对象，他是DefaultIoFilterChain里面的一个内部类，我们来看看他里面的messageReceived方法：

        DefaultIoFilterChain#EntryImpl

public void messageReceived(IoSession session, Object message) {
                    Entry nextEntry = EntryImpl.this.nextEntry;
                    callNextMessageReceived(nextEntry, session, message);
                }

        可以看到它实际上调用的是 callNextMessageReceived方法，而 callNextMessageReceived方法又会调用 IoFilter的messageReceived方法，继续判断当前的message对象是不是IoBuffer，直到是为止，相当于是一个间接的递归操作了；

        如果当前message是IoBuffer的话，则在第10行通过编解码器工厂获取到我们的解码器ProtocolDecoder，我们可以通过实现ProtocolDecoder接口来实现自己的解码器，第17行判断当前IoBuffer中是否存在需要被解码的内容，存在的话执行第22行解码器的decode方法，如果解码器是我们自己实现的话，那么这个方法将是我们自己实现的，并且在我们自己实现的decode方法将该消息解码出来之后，会调用ProtocolDecoderOutput的write方法，将解码出来的信息添加到队列中去：

        AbstractProtocolDecoderOutput$write()

public void write(Object message) {
        if (message == null) {
            throw new IllegalArgumentException("message");
        }

        messageQueue.add(message);
    }

        在执行完write方法之后 ProtocolCodecFilter$messageReceived()的25行执行了flush方法，这个方法会将当前已经解析好的消息传递下去，由下面的IoFilter来进行处理，flush方法的具体实现是在ProtocolCodecFilter的静态内部类ProtocolDecoderOutputImpl里面的：

        ProtocolDecoderOutputImpl$flush

public void flush(NextFilter nextFilter, IoSession session) {
            Queue