public interface Codec2 {
    @Adaptive({Constants.CODEC_KEY})
    void encode(Channel channel, ChannelBuffer buffer, Object message) throws IOException;

    /* 省略 */
}

public class ExchangeCodec extends TelnetCodec {
  public void encode(Channel channel, ChannelBuffer buffer, Object msg) throws IOException {
      if (msg instanceof Request) {
          encodeRequest(channel, buffer, (Request) msg);
      } else if (msg instanceof Response) {
          encodeResponse(channel, buffer, (Response) msg);
      } else {
          super.encode(channel, buffer, msg);
      }
  }
}

public class Request {
    public static final String HEARTBEAT_EVENT = null;
    public static final String READONLY_EVENT = "R";
    private static final AtomicLong INVOKE_ID = new AtomicLong(0);
    private final long mId;
    private String mVersion;
    private boolean mTwoWay = true;
    private boolean mEvent = false;
    private boolean mBroken = false;
    private Object mData;
    
    /* 省略 setter 和 getter 方法 */
}

protected void encodeRequest(Channel channel, ChannelBuffer buffer, Request req) throws IOException {
    Serialization serialization = getSerialization(channel); // 1
    // header.
    byte[] header = new byte[HEADER_LENGTH]; // 2
    // set magic number.
    Bytes.short2bytes(MAGIC, header); // 3

    // set request and serialization flag.
    header[2] = (byte) (FLAG_REQUEST | serialization.getContentTypeId()); // 4

    if (req.isTwoWay()) { // 5
        header[2] |= FLAG_TWOWAY;
    }
    if (req.isEvent()) { // 6
        header[2] |= FLAG_EVENT;
    }

    // set request id.
    Bytes.long2bytes(req.getId(), header, 4); // 7

    // encode request data.
    int savedWriteIndex = buffer.writerIndex();
    buffer.writerIndex(savedWriteIndex + HEADER_LENGTH);
    ChannelBufferOutputStream bos = new ChannelBufferOutputStream(buffer);
    ObjectOutput out = serialization.serialize(channel.getUrl(), bos); // 8
    if (req.isEvent()) {
        encodeEventData(channel, out, req.getData()); // 9
    } else {
        encodeRequestData(channel, out, req.getData(), req.getVersion()); // 10
    }
    out.flushBuffer();
    if (out instanceof Cleanable) {
        ((Cleanable) out).cleanup();
    }
    bos.flush();
    bos.close();
    int len = bos.writtenBytes();
    checkPayload(channel, len);
    Bytes.int2bytes(len, header, 12);

    // write
    buffer.writerIndex(savedWriteIndex); // 11
    buffer.writeBytes(header); // write header. // 11
    buffer.writerIndex(savedWriteIndex + HEADER_LENGTH + len); // 11
}

public class DubboCodec extends ExchangeCodec {
  protected void encodeRequestData(Channel channel, ObjectOutput out, Object data, String version) throws IOException {
      RpcInvocation inv = (RpcInvocation) data; // 1

      out.writeUTF(version); // 2
      out.writeUTF(inv.getAttachment(PATH_KEY)); // 3
      out.writeUTF(inv.getAttachment(VERSION_KEY)); // 4

      out.writeUTF(inv.getMethodName()); // 5
      out.writeUTF(ReflectUtils.getDesc(inv.getParameterTypes())); // 6
      Object[] args = inv.getArguments();
      if (args != null) {
          for (int i = 0; i < args.length; i++) {
              out.writeObject(encodeInvocationArgument(channel, inv, i)); // 7
          }
      }
      out.writeObject(inv.getAttachments()); // 8
  }
}

protected void encodeResponse(Channel channel, ChannelBuffer buffer, Response res) throws IOException {
    int savedWriteIndex = buffer.writerIndex();
    try {
        Serialization serialization = getSerialization(channel); // 1
        // header.
        byte[] header = new byte[HEADER_LENGTH]; // 2
        // set magic number.
        Bytes.short2bytes(MAGIC, header); // 3
        // set request and serialization flag.
        header[2] = serialization.getContentTypeId(); // 4
        if (res.isHeartbeat()) { // 5
            header[2] |= FLAG_EVENT;
        }
        // set response status.
        byte status = res.getStatus();
        header[3] = status; // 6
        // set request id.
        Bytes.long2bytes(res.getId(), header, 4); // 7

        buffer.writerIndex(savedWriteIndex + HEADER_LENGTH);
        ChannelBufferOutputStream bos = new ChannelBufferOutputStream(buffer);
        ObjectOutput out = serialization.serialize(channel.getUrl(), bos);
        // encode response data or error message.
        if (status == Response.OK) { // 8
            if (res.isHeartbeat()) {
                encodeHeartbeatData(channel, out, res.getResult());
            } else {
                encodeResponseData(channel, out, res.getResult(), res.getVersion());
            }
        } else {
            out.writeUTF(res.getErrorMessage());
        }
        out.flushBuffer();
        if (out instanceof Cleanable) {
            ((Cleanable) out).cleanup();
        }
        bos.flush();
        bos.close();

        int len = bos.writtenBytes();
        checkPayload(channel, len);
        Bytes.int2bytes(len, header, 12);
        // write
        buffer.writerIndex(savedWriteIndex); // 9
        buffer.writeBytes(header); // write header.
        buffer.writerIndex(savedWriteIndex + HEADER_LENGTH + len);
    } catch (Throwable t) {
      /* 省略 */
    }
}

public class DubboCodec extends ExchangeCodec {
    protected void encodeResponseData(Channel channel, ObjectOutput out, Object data, String version) throws IOException {
        Result result = (Result) data;
        // currently, the version value in Response records the version of Request
        boolean attach = Version.isSupportResponseAttachment(version);
        Throwable th = result.getException();
        if (th == null) { // 1
            Object ret = result.getValue();
            if (ret == null) { // 2
                out.writeByte(attach ? RESPONSE_NULL_VALUE_WITH_ATTACHMENTS : RESPONSE_NULL_VALUE);
            } else { // 2
                out.writeByte(attach ? RESPONSE_VALUE_WITH_ATTACHMENTS : RESPONSE_VALUE);
                out.writeObject(ret);
            }
        } else {
            out.writeByte(attach ? RESPONSE_WITH_EXCEPTION_WITH_ATTACHMENTS : RESPONSE_WITH_EXCEPTION); // 1
            out.writeObject(th);
        }

        if (attach) { // 3
            // returns current version of Response to consumer side.
            result.getAttachments().put(DUBBO_VERSION_KEY, Version.getProtocolVersion());
            out.writeObject(result.getAttachments());
        }
    }
}

public interface Codec2 {
    @Adaptive({Constants.CODEC_KEY})
    Object decode(Channel channel, ChannelBuffer buffer) throws IOException;

    enum DecodeResult {
        NEED_MORE_INPUT, SKIP_SOME_INPUT
    }
}

public class ExchangeCodec extends TelnetCodec {
  @Override
  public Object decode(Channel channel, ChannelBuffer buffer) throws IOException {
    int readable = buffer.readableBytes();
    byte[] header = new byte[Math.min(readable, HEADER_LENGTH)];
    buffer.readBytes(header);
    return decode(channel, buffer, readable, header);
  }
}

@Override
protected Object decode(Channel channel, ChannelBuffer buffer, int readable, byte[] header) throws IOException {
    // check magic number.
    if (readable > 0 && header[0] != MAGIC_HIGH
            || readable > 1 && header[1] != MAGIC_LOW) { // 1
        int length = header.length;
        if (header.length < readable) {
            header = Bytes.copyOf(header, readable);
            buffer.readBytes(header, length, readable - length);
        }
        for (int i = 1; i < header.length - 1; i++) {
            if (header[i] == MAGIC_HIGH && header[i + 1] == MAGIC_LOW) {
                buffer.readerIndex(buffer.readerIndex() - header.length + i);
                header = Bytes.copyOf(header, i);
                break;
            }
        }
        return super.decode(channel, buffer, readable, header);
    }
    // check length.
    if (readable < HEADER_LENGTH) {
        return DecodeResult.NEED_MORE_INPUT; // 2
    }

    // get data length.
    int len = Bytes.bytes2int(header, 12); // 3
    checkPayload(channel, len); // 3

    int tt = len + HEADER_LENGTH;
    if (readable < tt) {
        return DecodeResult.NEED_MORE_INPUT; // 4
    }

    // limit input stream.
    ChannelBufferInputStream is = new ChannelBufferInputStream(buffer, len);

    try {
        return decodeBody(channel, is, header); // 5
    } finally {
        if (is.available() > 0) {
            try {
                if (logger.isWarnEnabled()) {
                    logger.warn("Skip input stream " + is.available());
                }
                StreamUtils.skipUnusedStream(is);
            } catch (IOException e) {
                logger.warn(e.getMessage(), e);
            }
        }
    }
}

protected Object decodeBody(Channel channel, InputStream is, byte[] header) throws IOException {
    byte flag = header[2], proto = (byte) (flag & SERIALIZATION_MASK); // 1
    // get request id.
    long id = Bytes.bytes2long(header, 4); // 2
    if ((flag & FLAG_REQUEST) == 0) {
      /* 省略 */
    } else {
        // decode request.
        Request req = new Request(id); // 3
        req.setVersion(Version.getProtocolVersion()); // 4
        req.setTwoWay((flag & FLAG_TWOWAY) != 0); // 4
        if ((flag & FLAG_EVENT) != 0) {
            req.setEvent(true); // 5
        }
        try {
            Object data;
            ObjectInput in = CodecSupport.deserialize(channel.getUrl(), is, proto); // 6
            if (req.isHeartbeat()) {
                data = decodeHeartbeatData(channel, in); // 7
            } else if (req.isEvent()) {
                data = decodeEventData(channel, in); // 7
            } else {
                DecodeableRpcInvocation inv;
                if (channel.getUrl().getParameter(DECODE_IN_IO_THREAD_KEY, DEFAULT_DECODE_IN_IO_THREAD)) { // 8
                    inv = new DecodeableRpcInvocation(channel, req, is, proto);
                    inv.decode();
                } else {
                    inv = new DecodeableRpcInvocation(channel, req,
                            new UnsafeByteArrayInputStream(readMessageData(is)), proto); // 8
                }
                data = inv; // 9
            }
            req.setData(data);
        } catch (Throwable t) {
            if (log.isWarnEnabled()) {
                log.warn("Decode request failed: " + t.getMessage(), t);
            }
            // bad request
            req.setBroken(true);
            req.setData(t);
        }
        return req;
    }
}

public class DecodeableRpcInvocation extends RpcInvocation implements Codec, Decodeable {
  @Override
  public void decode() throws Exception {
      if (!hasDecoded && channel != null && inputStream != null) { // 1
          try {
              decode(channel, inputStream);
          } catch (Throwable e) {
              if (log.isWarnEnabled()) {
                  log.warn("Decode rpc invocation failed: " + e.getMessage(), e);
              }
              request.setBroken(true);
              request.setData(e);
          } finally {
              hasDecoded = true;
          }
      }
  }
  
  @Override
  public Object decode(Channel channel, InputStream input) throws IOException {
      ObjectInput in = CodecSupport.getSerialization(channel.getUrl(), serializationType)
              .deserialize(channel.getUrl(), input); // 2

      String dubboVersion = in.readUTF(); // 3
      request.setVersion(dubboVersion); // 3
      setAttachment(DUBBO_VERSION_KEY, dubboVersion); // 4

      setAttachment(PATH_KEY, in.readUTF()); // 4
      setAttachment(VERSION_KEY, in.readUTF()); // 4

      setMethodName(in.readUTF()); // 4
      try {
          Object[] args;
          Class<?>[] pts;
          String desc = in.readUTF(); // 5
          if (desc.length() == 0) {
              pts = DubboCodec.EMPTY_CLASS_ARRAY; // 5
              args = DubboCodec.EMPTY_OBJECT_ARRAY; // 5
          } else {
              pts = ReflectUtils.desc2classArray(desc); // 5
              args = new Object[pts.length]; // 5
              for (int i = 0; i < args.length; i++) {
                  try {
                      args[i] = in.readObject(pts[i]); // 5
                  } catch (Exception e) {
                      if (log.isWarnEnabled()) {
                          log.warn("Decode argument failed: " + e.getMessage(), e);
                      }
                  }
              }
          }
          setParameterTypes(pts); // 5

          Map<String, String> map = (Map<String, String>) in.readObject(Map.class); // 6
          if (map != null && map.size() > 0) {
              Map<String, String> attachment = getAttachments(); // 6
              if (attachment == null) {
                  attachment = new HashMap<String, String>();
              }
              attachment.putAll(map);
              setAttachments(attachment); // 6
          }
          //decode argument ,may be callback
          for (int i = 0; i < args.length; i++) {
              args[i] = decodeInvocationArgument(channel, this, pts, i, args[i]); // 7
          }

          setArguments(args);

      } catch (ClassNotFoundException e) {
          throw new IOException(StringUtils.toString("Read invocation data failed.", e));
      } finally {
          if (in instanceof Cleanable) {
              ((Cleanable) in).cleanup();
          }
      }
      return this;
  }
}

protected Object decodeBody(Channel channel, InputStream is, byte[] header) throws IOException {
    byte flag = header[2], proto = (byte) (flag & SERIALIZATION_MASK); // 1
    // get request id.
    long id = Bytes.bytes2long(header, 4); // 2
    if ((flag & FLAG_REQUEST) == 0) {
        // decode response.
        Response res = new Response(id); // 2
        if ((flag & FLAG_EVENT) != 0) { // 3
            res.setEvent(true);
        }
        // get status.
        byte status = header[3]; // 4
        res.setStatus(status);
        try {
            if (status == Response.OK) { // 5
                Object data;
                if (res.isHeartbeat()) {
                    ObjectInput in = CodecSupport.deserialize(channel.getUrl(), is, proto); // 5
                    data = decodeHeartbeatData(channel, in);
                } else if (res.isEvent()) {
                    ObjectInput in = CodecSupport.deserialize(channel.getUrl(), is, proto); // 5
                    data = decodeEventData(channel, in);
                } else {
                    DecodeableRpcResult result; // 6
                    if (channel.getUrl().getParameter(DECODE_IN_IO_THREAD_KEY, DEFAULT_DECODE_IN_IO_THREAD)) { // 6
                        result = new DecodeableRpcResult(channel, res, is,
                                (Invocation) getRequestData(id), proto); // 6
                        result.decode(); // 6
                    } else {
                        result = new DecodeableRpcResult(channel, res,
                                new UnsafeByteArrayInputStream(readMessageData(is)),
                                (Invocation) getRequestData(id), proto); // 6
                    }
                    data = result;
                }
                res.setResult(data);
            } else {
                ObjectInput in = CodecSupport.deserialize(channel.getUrl(), is, proto); // 7
                res.setErrorMessage(in.readUTF());
            }
        } catch (Throwable t) {
            if (log.isWarnEnabled()) {
                log.warn("Decode response failed: " + t.getMessage(), t);
            }
            res.setStatus(Response.CLIENT_ERROR);
            res.setErrorMessage(StringUtils.toString(t));
        }
        return res;
    } else {
        /* 省略 */
    }
}

public class DecodeableRpcResult extends AppResponse implements Codec, Decodeable {
    @Override
    public void decode() throws Exception {
        if (!hasDecoded && channel != null && inputStream != null) { // 1
            try {
                decode(channel, inputStream);
            } catch (Throwable e) {
                if (log.isWarnEnabled()) {
                    log.warn("Decode rpc result failed: " + e.getMessage(), e);
                }
                response.setStatus(Response.CLIENT_ERROR);
                response.setErrorMessage(StringUtils.toString(e));
            } finally {
                hasDecoded = true;
            }
        }
    }

    @Override
    public Object decode(Channel channel, InputStream input) throws IOException {
        ObjectInput in = CodecSupport.getSerialization(channel.getUrl(), serializationType)
                .deserialize(channel.getUrl(), input); // 2

        byte flag = in.readByte(); // 3
        switch (flag) {
            case DubboCodec.RESPONSE_NULL_VALUE:
                break;
            case DubboCodec.RESPONSE_VALUE:
                handleValue(in);
                break;
            case DubboCodec.RESPONSE_WITH_EXCEPTION:
                handleException(in);
                break;
            case DubboCodec.RESPONSE_NULL_VALUE_WITH_ATTACHMENTS:
                handleAttachment(in);
                break;
            case DubboCodec.RESPONSE_VALUE_WITH_ATTACHMENTS:
                handleValue(in);
                handleAttachment(in);
                break;
            case DubboCodec.RESPONSE_WITH_EXCEPTION_WITH_ATTACHMENTS:
                handleException(in);
                handleAttachment(in);
                break;
            default:
                throw new IOException("Unknown result flag, expect '0' '1' '2' '3' '4' '5', but received: " + flag);
        }
        if (in instanceof Cleanable) {
            ((Cleanable) in).cleanup();
        }
        return this;
    }
}

public class HeaderExchanger implements Exchanger {
    public static final String NAME = "header";
    @Override
    public ExchangeClient connect(URL url, ExchangeHandler handler) throws RemotingException {
        return new HeaderExchangeClient(Transporters.connect(url, new DecodeHandler(new HeaderExchangeHandler(handler))), true);
    }

    @Override
    public ExchangeServer bind(URL url, ExchangeHandler handler) throws RemotingException {
        return new HeaderExchangeServer(Transporters.bind(url, new DecodeHandler(new HeaderExchangeHandler(handler))));
    }
}

final public class NettyCodecAdapter {
    private final ChannelHandler encoder = new InternalEncoder();
    private final ChannelHandler decoder = new InternalDecoder();
    private final Codec2 codec; // 1
    private final URL url;
    private final org.apache.dubbo.remoting.ChannelHandler handler;

    public NettyCodecAdapter(Codec2 codec, URL url, org.apache.dubbo.remoting.ChannelHandler handler) {
        this.codec = codec;
        this.url = url;
        this.handler = handler;
    }

    public ChannelHandler getEncoder() {
        return encoder;
    }

    private class InternalEncoder extends MessageToByteEncoder {
        @Override
        protected void encode(ChannelHandlerContext ctx, Object msg, ByteBuf out) throws Exception {
            org.apache.dubbo.remoting.buffer.ChannelBuffer buffer = new NettyBackedChannelBuffer(out);
            Channel ch = ctx.channel();
            NettyChannel channel = NettyChannel.getOrAddChannel(ch, url, handler);
            try {
                codec.encode(channel, buffer, msg); // 2
            } finally {
                NettyChannel.removeChannelIfDisconnected(ch);
            }
        }
    }
    
    /* 省略 */
}

private class InternalDecoder extends ByteToMessageDecoder {
    @Override
    protected void decode(ChannelHandlerContext ctx, ByteBuf input, List<Object> out) throws Exception {
        ChannelBuffer message = new NettyBackedChannelBuffer(input);
        NettyChannel channel = NettyChannel.getOrAddChannel(ctx.channel(), url, handler);

        try {
            // decode object.
            do {
                int saveReaderIndex = message.readerIndex();
                Object msg = codec.decode(channel, message);
                if (msg == Codec2.DecodeResult.NEED_MORE_INPUT) { // 1
                    message.readerIndex(saveReaderIndex);
                    break;
                } else {
                    //is it possible to go here ?
                    if (saveReaderIndex == message.readerIndex()) {
                        throw new IOException("Decode without read data.");
                    }
                    if (msg != null) {
                        out.add(msg);
                    }
                }
            } while (message.readable());
        } finally {
            NettyChannel.removeChannelIfDisconnected(ctx.channel());
        }
    }
}