【MinaFile】【三】写自定义编码解码

一、添加常量类Constants

/**
 * 消息自身字节常量类
 * @author king_fu
 *
 */
public class Constants {
    public static final int TYPE_LEN = 2;

    public static final int SEQUENCE_LEN = 4;

    public static final int HEADER_LEN = TYPE_LEN + SEQUENCE_LEN;

    public static final int BODY_LEN = 12;

    public static final int RESULT = 0;

    public static final int ADD = 1;

    public static final int RESULT_CODE_LEN = 2;

    public static final int RESULT_VALUE_LEN = 4;

    public static final int ADD_BODY_LEN = 4;

    public static final int RESULT_OK = 0;

    public static final int RESULT_ERROR = 1;

    private Constants() {
    }
}

下面用了设计模式中的模版方法。

二、添加抽象父类解码器AbstractMessageDecoder

 

/**
 * 父类解码
 * @author king_fu
 *
 */
public abstract class AbstractMessageDecoder implements MessageDecoder {
    private final int type;

    private int sequence;

    private boolean readHeader;

    protected AbstractMessageDecoder(int type) {
        this.type = type;
    }

    public MessageDecoderResult decodable(IoSession session, IoBuffer in) {
    	// 判断是否符合最小的头长度。一个short+一个int类型。
    	/**
    	 *  // 编码头
         * 	   buf.putShort((short) type);
         *     buf.putInt(message.getSequence());
    	 */
        if (in.remaining() < Constants.HEADER_LEN) {
            return MessageDecoderResult.NEED_DATA;
        }
        if (type == in.getShort()) {
            return MessageDecoderResult.OK;
        }
        return MessageDecoderResult.NOT_OK;
    }

    public MessageDecoderResult decode(IoSession session, IoBuffer in,
            ProtocolDecoderOutput out) throws Exception {
         
        if (!readHeader) {
            in.getShort();  
            sequence = in.getInt(); 
            readHeader = true;
        }

        AbstractMessage m = decodeBody(session, in);
        if (m == null) {
            return MessageDecoderResult.NEED_DATA;
        } else {
            readHeader = false;  
        }
        m.setSequence(sequence);
        out.write(m);

        return MessageDecoderResult.OK;
    }

  
    /**
     * 模版方法
     * @param session 当前的session
     * @param in 输入流
     * @return	如果对象没有读完返回null
     */
    protected abstract AbstractMessage decodeBody(IoSession session,
            IoBuffer in);
}

三、添加抽象父类编码器AbstractMessageDecoder

 

/**
 * 父类编码
 * @author king_fu
 *
 * @param <T>
 */
public abstract class AbstractMessageEncoder<T extends AbstractMessage> implements MessageEncoder<T> {
    private final int type;

    protected AbstractMessageEncoder(int type) {
        this.type = type;
    }

    public void encode(IoSession session, T message, ProtocolEncoderOutput out) throws Exception {
        IoBuffer buf = IoBuffer.allocate(16);
        buf.setAutoExpand(true); 

        // 编码头
        buf.putShort((short) type);
        buf.putInt(message.getSequence());

        // 编码体
        encodeBody(session, message, buf);
        buf.flip();
        out.write(buf);
    }

    protected abstract void encodeBody(IoSession session, T message, IoBuffer out);
}

四、添加子类解码器MessageDecoder

/**
 * 消息解码
 * @author king_fu
 *
 */
public class MessageDecoder extends AbstractMessageDecoder {

    public MessageDecoder() {
        super(Constants.ADD);
    }

    @Override
    protected AbstractMessage decodeBody(IoSession session, IoBuffer in) {
        if (in.remaining() < Constants.ADD_BODY_LEN) {
            return null;
        }

        Message m = new Message();
        m.setValue(in.getInt());
        return m;
    }

    public void finishDecode(IoSession session, ProtocolDecoderOutput out)
            throws Exception {
    }
}

五、添加子类编码器MessageEncoder

/**
 * 消息编码
 * @author king_fu
 *
 * @param <T>
 */
public class MessageEncoder<T extends Message> extends AbstractMessageEncoder<T> {
    public MessageEncoder() {
        super(Constants.ADD);
    }

    @Override
    protected void encodeBody(IoSession session, T message, IoBuffer out) {
        out.putInt(message.getValue());
    }

    public void dispose() throws Exception {
    }
}

六、添加子类解码器ResultMessageDecoder

/**
 * 返回的消息解码
 * @author king_fu
 *
 */
public class ResultMessageDecoder extends AbstractMessageDecoder {
    private int code;

    private boolean readCode;

    public ResultMessageDecoder() {
        super(Constants.RESULT);
    }

    @Override
    protected AbstractMessage decodeBody(IoSession session, IoBuffer in) {
        if (!readCode) {
            if (in.remaining() < Constants.RESULT_CODE_LEN) {
                return null; 
            }

            code = in.getShort();
            readCode = true;
        }

        if (code == Constants.RESULT_OK) {
            if (in.remaining() < Constants.RESULT_VALUE_LEN) {
                return null;
            }

            ResultMessage m = new ResultMessage();
            m.setOk(true);
            m.setValue(in.getInt());
            readCode = false;
            return m;
        } else {
            ResultMessage m = new ResultMessage();
            m.setOk(false);
            readCode = false;
            return m;
        }
    }

    public void finishDecode(IoSession session, ProtocolDecoderOutput out)
            throws Exception {
    }
}

七、添加子类编码器ResultMessageEncoder

/**
 * 返回的消息编码
 * @author king_fu
 *
 * @param <T>
 */
public class ResultMessageEncoder<T extends ResultMessage> extends AbstractMessageEncoder<T> {
    public ResultMessageEncoder() {
        super(Constants.RESULT);
    }

    @Override
    protected void encodeBody(IoSession session, T message, IoBuffer out) {
        if (message.isOk()) {
            out.putShort((short) Constants.RESULT_OK);
            out.putInt(message.getValue());
        } else {
            out.putShort((short) Constants.RESULT_ERROR);
        }
    }

    public void dispose() throws Exception {
    }
}