多路分离的解码器

(6-3.)多路分离的解码器：
假设一段数据发送过来之后，需要根据某种条件决定使用哪个解码器，而不是像上面的例子，固定使用一个解码器，那么该如何做呢？幸好Mina 提供了org.apache.mina.filter.codec.demux 包来完成这种多路分离（Demultiplexes）的解码工作，也就是同时注册多个解码器，然后运行时依据传入的数据决定到底使用哪个解码器来工作。所谓多路分离就是依据条件分发到指定的解码器，譬如：上面的短信协议进行扩展，可以依据状态行来判断使用1.0 版本的短信协议解码器还是2.0版本的短信协议解码器。
下面我们使用一个简单的例子，说明这个多路分离的解码器是如何使用的，需求如下所示：
(1.) 客户端传入两个int 类型的数字，还有一个char 类型的符号。
(2.) 如果符号是+，服务端就是用1 号解码器，对两个数字相加，然后把结果返回给客户端。
(3.) 如果符号是-，服务端就使用2 号解码器，将两个数字变为相反数，然后相加，把结果返回给客户端。
Demux 开发编解码器主要有如下几个步骤：
A. 定义Client 端、Server 端发送、接收的数据对象。
B. 使用Demux 编写编码器是实现MessageEncoder接口，T 是你要编码的数据对象，这个MessageEncoder 会在DemuxingProtocolEncoder 中调用。
C. 使用Demux 编写编码器是实现MessageDecoder 接口，这个MessageDecoder 会在DemuxingProtocolDecoder 中调用。

D. 在 DemuxingProtocolCodecFactory 中调用addMessageEncoder()、addMessageDecoder()方法组装编解码器。
MessageEncoder的接口如下所示：

 public interface MessageEncoder {
 void encode(IoSession session, T message, ProtocolEncoderOutput out)
 throws Exception;
 }

你注意到消息编码器接口与在ProtocolEncoder 中没什么不同，区别就是Object message被泛型具体化了类型，你不需要手动的类型转换了。
MessageDecoder的接口如下所示：

 public interface MessageDecoder {
 static MessageDecoderResult OK = MessageDecoderResult.OK;
 static MessageDecoderResult NEED_DATA =
 MessageDecoderResult.NEED_DATA;
 static MessageDecoderResult NOT_OK = MessageDecoderResult.NOT_OK;
 MessageDecoderResult decodable(IoSession session, IoBuffer in);
 MessageDecoderResult decode(IoSession session, IoBuffer in,
 ProtocolDecoderOutput out) throws Exception;
 void finishDecode(IoSession session, ProtocolDecoderOutput out)
 throws Exception;
 }

(1.)decodable()方法有三个返回值，分别表示如下的含义：
A. MessageDecoderResult.NOT_OK：表示这个解码器不适合解码数据，然后检查其它解码器，如果都不满足会抛异常；
B. MessageDecoderResult.NEED_DATA：表示当前的读入的数据不够判断是否能够使用这个解码器解码，然后再次调用decodable()方法检查其它解码器，如果都是NEED_DATA,则等待下次输入；
C. MessageDecoderResult.OK： 表示这个解码器可以解码读入的数据， 然后则调用MessageDecoder 的decode()方法。这里注意decodable()方法对参数IoBuffer in 的任何操作在方法结束之后，都会复原，也就是你不必担心在调用decode()方法时，position 已经不在缓冲区的起始位置。这个方法相当于是预读取，用于判断是否是可用的解码器。
(2.)decode()方法有三个返回值，分别表示如下的含义：
A. MessageDecoderResult.NOT_OK：表示解码失败，会抛异常；

B. MessageDecoderResult.NEED_DATA：表示数据不够，需要读到新的数据后，再次调用decode()方法。
C. MessageDecoderResult.OK：表示解码成功。
代码演示：
(1.)客户端发送的数据对象：

 public class SendMessage {
 private int i = 0;
 private int j = 0;
 private char symbol = '+';
 public char getSymbol() {
 return symbol;
 }
 public void setSymbol(char symbol) {
 this.symbol = symbol;
 }
 public int getI() {
 return i;
 }
 public void setI(int i) {
 this.i = i;
 }
 public int getJ() {
 return j;
 }
 public void setJ(int j) {
 this.j = j;
 }
 }

(2.)服务端发送的返回结果对象：

 public class ResultMessage {
 private int result = 0;
 public int getResult() {
 return result;
 }
 public void setResult(int result) {
 this.result = result;
 }
 }

(3.)客户端使用的SendMessage的编码器：

 public class SendMessageEncoder implements MessageEncoder
 {
 @Override
 public void encode(IoSession session, SendMessage message,
 ProtocolEncoderOutput out) throws Exception {
 IoBuffer buffer = IoBuffer.allocate(10);
 buffer.putChar(message.getSymbol());
 buffer.putInt(message.getI());
 buffer.putInt(message.getJ());
 buffer.flip();
 out.write(buffer);
 }
 }

这里我们的SendMessage、ResultMessage 中的字段都是用长度固定的基本数据类型，这样IoBuffer 就不需要自动扩展了，提高性能。按照一个char、两个int 计算，这里的IoBuffer只需要10 个字节的长度就可以了。
(4.)服务端使用的SendMessage的1号解码器：

 public class SendMessageDecoderPositive implements MessageDecoder {
 @Override
 public MessageDecoderResult decodable(IoSession session, IoBuffer in)
 {
 if (in.remaining() < 2)
 return MessageDecoderResult.NEED_DATA;
 else {
 char symbol = in.getChar();
 if (symbol == '+') {
 return MessageDecoderResult.OK;
 } else {
 return MessageDecoderResult.NOT_OK;
 }
 }
 }
 @Override
 public MessageDecoderResult decode(IoSession session, IoBuffer in,
 ProtocolDecoderOutput out) throws Exception {
 SendMessage sm = new SendMessage();
 sm.setSymbol(in.getChar());
 sm.setI(in.getInt());
 sm.setJ(in.getInt());
 out.write(sm);
 return MessageDecoderResult.OK;
 }
 @Override
 public void finishDecode(IoSession session, ProtocolDecoderOutput
 out)
 throws Exception {
 // undo
 }
 }

因为客户端发送的SendMessage 的前两个字节（char）就是符号位，所以我们在decodable()方法中对此条件进行了判断，之后读到两个字节，并且这两个字节表示的字符是+时，才认为这个解码器可用。
(5.)服务端使用的SendMessage的2号解码器：

 public class SendMessageDecoderNegative implements MessageDecoder {
 @Override
 public MessageDecoderResult decodable(IoSession session, IoBuffer in)
 {
 if (in.remaining() < 2)
 return MessageDecoderResult.NEED_DATA;
 else {
 char symbol = in.getChar();
 if (symbol == '-') {
 return MessageDecoderResult.OK;
 } else {
 return MessageDecoderResult.NOT_OK;
 }
 }
 }
 @Override
 public MessageDecoderResult decode(IoSession session, IoBuffer in,
 ProtocolDecoderOutput out) throws Exception {
 SendMessage sm = new SendMessage();
 sm.setSymbol(in.getChar());
 sm.setI(-in.getInt());
 sm.setJ(-in.getInt());
 out.write(sm);
 return MessageDecoderResult.OK;
 }
 @Override
 public void finishDecode(IoSession session, ProtocolDecoderOutput
 out)
 throws Exception {
 // undo
 }
 }

(6.)服务端使用的ResultMessage的编码器：

 public class ResultMessageEncoder implements
 MessageEncoder {
 @Override
 public void encode(IoSession session, ResultMessage message,
 ProtocolEncoderOutput out) throws Exception {
 IoBuffer buffer = IoBuffer.allocate(4);
 buffer.putInt(message.getResult());
 buffer.flip();
 out.write(buffer);
 }
 }

(7.)客户端使用的ResultMessage的解码器：

 public class ResultMessageDecoder implements MessageDecoder {
 @Override
 public MessageDecoderResult decodable(IoSession session, IoBuffer in)
 {
 if (in.remaining() < 4)
 return MessageDecoderResult.NEED_DATA;
 else if (in.remaining() == 4)
 return MessageDecoderResult.OK;
 else
 return MessageDecoderResult.NOT_OK;
 }
 @Override
 public MessageDecoderResult decode(IoSession session, IoBuffer in,
 ProtocolDecoderOutput out) throws Exception {
 ResultMessage rm = new ResultMessage();
 rm.setResult(in.getInt());
 out.write(rm);
 return MessageDecoderResult.OK;
 }
 @Override
 public void finishDecode(IoSession session, ProtocolDecoderOutput
 out)
 throws Exception {
 // undo
 }
 }

(8.)组装这些编解码器的工厂：

 public class MathProtocolCodecFactory extends
 DemuxingProtocolCodecFactory {
 public MathProtocolCodecFactory(boolean server) {
 if (server) {
 super.addMessageEncoder(ResultMessage.class,
 ResultMessageEncoder.class);
 super.addMessageDecoder(SendMessageDecoderPositive.class);
 super.addMessageDecoder(SendMessageDecoderNegative.class);
 } else {
 super
 .addMessageEncoder(SendMessage.class,
 SendMessageEncoder.class);
 super.addMessageDecoder(ResultMessageDecoder.class);
 }
 }
 }

这个工厂类我们使用了构造方法的一个布尔类型的参数，以便其可以在Server 端、Client端同时使用。我们以Server 端为例，你可以看到调用两次addMessageDecoder()方法添加了1 号、2 号解码器，其实DemuxingProtocolDecoder 内部在维护了一个MessageDecoder数组，用于保存添加的所有的消息解码器，每次decode()的时候就调用每个MessageDecoder的decodable()方法逐个检查，只要发现一个MessageDecoder 不是对应的解码器，就从数组中移除，直到找到合适的MessageDecoder，如果最后发现数组为空，就表示没找到对应的MessageDecoder，最后抛出异常。
(9.)Server端：

 public class Server {
 public static void main(String[] args) throws Exception {
 IoAcceptor acceptor = new NioSocketAcceptor();
 LoggingFilter lf = new LoggingFilter();
 acceptor.getSessionConfig().setIdleTime(IdleStatus.BOTH_IDLE,
 5);
 acceptor.getFilterChain().addLast("logger", lf);
 acceptor.getFilterChain().addLast("codec",
 new ProtocolCodecFilter(new
 MathProtocolCodecFactory(true)));
 acceptor.setHandler(new ServerHandler());
 acceptor.bind(new InetSocketAddress(9123));
 }
 }

(10.)Server端使用的IoHandler：

 public class ServerHandler extends IoHandlerAdapter {
 private final static Logger log = LoggerFactory
 .getLogger(ServerHandler.class);
 @Override
 public void sessionIdle(IoSession session, IdleStatus status)
 throws Exception {
 session.close(true);
 }
 @Override
 public void messageReceived(IoSession session, Object message)
 throws Exception {
 SendMessage sm = (SendMessage) message;
 log.info("The message received is [ " + sm.getI() + " "
 + sm.getSymbol() + " " + sm.getJ() + " ]");
 ResultMessage rm = new ResultMessage();
 rm.setResult(sm.getI() + sm.getJ());
 session.write(rm);
 }
 }

(11.)Client端：

 public class Client {
 public static void main(String[] args) throws Throwable {
 IoConnector connector = new NioSocketConnector();
 connector.setConnectTimeoutMillis(30000);
 connector.getFilterChain().addLast("logger", new
 LoggingFilter());
 connector.getFilterChain().addLast("codec",
 new ProtocolCodecFilter(new
 MathProtocolCodecFactory(false)));
 connector.setHandler(new ClientHandler());
 connector.connect(new InetSocketAddress("localhost", 9123));
 }
 }

(12.)Client端的IoHandler：

 public class ClientHandler extends IoHandlerAdapter {
 private final static Logger LOGGER = LoggerFactory
 .getLogger(ClientHandler.class);
 @Override
 public void sessionOpened(IoSession session) throws Exception {
 SendMessage sm = new SendMessage();
 sm.setI(100);
 sm.setJ(99);
 sm.setSymbol('+');
 session.write(sm);
 }
 @Override
 public void messageReceived(IoSession session, Object message) {
 ResultMessage rs = (ResultMessage) message;
 LOGGER.info(String.valueOf(rs.getResult()));
 }
 }

你尝试改变(12.)中的红色代码中的正负号，会看到服务端使用了两个不同的解码器对其进行处理。