转：MINA 协议解码过滤器

为什么使用协议解码过滤器 ProtocolCodecFilter ？

1)  TCP保证所有的包以正确是顺序传递，但不保证发送方的一次写操作在接收方产生一次读操作。在 MINA 的术语中：没有 ProtocolCodecFilter ，发送方的一次 IoSession.write(Object message) 导致接收方多次 messageReceived(IoSession session, Object message) 事件，多次调用 IoSession.write(Object message) 可以导致单一的 messageReceived 事件。当服务器和客户端在同一台主机（或同一局域网）时，你可能不会遇到这种行为。但你的应用程序可能会遇到。

2)  大多数应用程序需要一种方法来找出当前消息的结束位置和下一个消息的开始位置。

你可以在IoHandler 里实现这些逻辑，但添加一个 ProtocolCodecFilter 可以使你的代码更加清晰和易于维护。它允许你分离协议逻辑和业务逻辑（ IoHandler ）。

 

 

应用程序基本上是接收一串字节，需要转换这些字节到消息（高层对象）。

有三种常用的技术来分割字节流到消息：
1、使用定长消息
2、使用固定长度的头来指示内容体长度
3、使用分隔符。

这里使用分割符（换行）来编写时间服务器的解码器。

时间服务器的请求对象为java.lang.String，对应的协议解码器为：

org.apache.mina.filter.codec.textline.TextLineEncoder和org.apache.mina.filter.codec.textline.TextLineDecoder。

 

响应对象定义如下：

public class TimeResponse {
    private String client;      // 客户端发送到字符串
    private Date date;

    public TimeResponse(String client, Date date) {
        this.client = client;
        this.date = date;
    }

    public String getClient() {
        return client;
    }

    public Date getDate() {
        return date;
    }
}

 

 

下面是响应的编码器：

public class TimeResponseEncoder extends ProtocolEncoderAdapter {

    @Override
    public void encode(IoSession session, Object message,
            ProtocolEncoderOutput out) throws Exception {
       
        TimeResponse res = (TimeResponse) message;
       
        IoBuffer buff = IoBuffer.allocate(32);
        buff.setAutoExpand(true);
        buff.setAutoShrink(true);
       
       
        CharsetEncoder encoder = Charset.forName("UTF-8").newEncoder();
        buff.putString(res.getClient() + " 您好！服务器时间是：", encoder);
       
        Date date = res.getDate();
        SimpleDateFormat sdf = new SimpleDateFormat("yyyy年MM月dd，HH时mm分ss秒");
       
        buff.putString(sdf.format(date), encoder);
        buff.put((byte)'\n');
       
        buff.flip();
       
        out.write(buff);
        out.flush();
       
        System.err.println("res encode end .... ");
    }
}

 

业务处理器通过IoSession.write()写出的都是响应对象，所以这里可以直接进行强类型转换 

TimeResponse res = (TimeResponse) message;

 

编码后的内容是写到  ProtocolEncoderOutput out，传给下一个过滤器。

 

 

然后是响应的解码器：

public class TimeResponseDecoder extends CumulativeProtocolDecoder {

    @Override
    protected boolean doDecode(IoSession session, IoBuffer in,
            ProtocolDecoderOutput out) throws Exception {
       
        CharsetDecoder decoder = Charset.forName("UTF-8").newDecoder();

        int start = in.position();

        int end = in.remaining() - 1;
       
        if (end >= 0 && in.get(end) == (byte) '\n') {
           
            String res = in.getString(decoder);
            out.write(res);
           
            return true;
           
        } else {
            in.position(start);
        }

        return false;
    }
}

 

解码器继承自CumulativeProtocolDecoder的好处是，当缓存的内容还不够解码为一个响应对象时，可以继续缓存响应内容，只要返回false即可。

 

 

有了请求和响应的编解码器后，定义一个解码器工厂：

public class TimeResponseCodecFactory implements ProtocolCodecFactory {
    private ProtocolDecoder decoder;
    private ProtocolEncoder encoder;
   
    public TimeResponseCodecFactory(boolean server) {
        if(server) {
            decoder = new TextLineDecoder(Charset.forName("UTF-8"));
            encoder = new TimeResponseEncoder();
        } else {
            decoder = new TimeResponseDecoder();
            encoder = new TextLineEncoder(Charset.forName("UTF-8"));
        }
    }

    @Override
    public ProtocolDecoder getDecoder(IoSession session) throws Exception {
        return decoder;
    }

    @Override
    public ProtocolEncoder getEncoder(IoSession session) throws Exception {
        return encoder;
    }

}

 

MINA会调用工厂的 getDecoder 和 getEncoder 方法。

注意：服务器端的解码器是请求解码器，编码器是响应编码器；客户端的解码器是响应解码器，编码器是请求编码器。

 

修改服务器和客户端的过滤器配置

connector.getFilterChain().addLast("codec", new ProtocolCodecFilter(new TimeResponseCodecFactory(true/false)));

 

 

服务器端的处理器现在可以直接写响应对象了：

public class TimeServerHandler extends IoHandlerAdapter {
    private Logger log = LoggerFactory.getLogger(TimeServerHandler.class);

    @Override
    public void messageReceived(IoSession session, Object message)
            throws Exception {
       
        String str = message.toString();
       
        log.info("server receive :" + str);
       
        if("quit".equalsIgnoreCase(str.trim())) {
            session.close(true);
            return;
        }
       
        Date date = new Date();
       
        TimeResponse res = new TimeResponse(str, date);
       
        session.write(res);
       
        log.info("message writter ...");
    }
}

 

而客户端的处理器也可以直接处理响应对象：

public class ClientHandler extends IoHandlerAdapter {

    @Override
    public void messageReceived(IoSession session, Object message)
            throws Exception {
       
        String msg = (String) message;
       
        System.out.println("response :" + msg);
    }
}

 

 

有了协议解码过滤器，处理器就不需要考虑底层的编解码的问题，只需要处理高层的业务对象，达到了分层的目的。

 

 

转自:http://wen866595.iteye.com/blog/1154137

 

评论

1 楼 rgbaflf 2011-10-18  

你好
你可以写一下 第二种情况的解码器吗？
2、使用固定长度的头来指示内容体长度



还有   
   public TimeResponseCodecFactory(boolean server) {
        if(server) {
            decoder = new TextLineDecoder(Charset.forName("UTF-8"));
            encoder = new TimeResponseEncoder();
        } else {
            decoder = new TimeResponseDecoder();
            encoder = new TextLineEncoder(Charset.forName("UTF-8"));
        }
    }

会不会写反了？
为server 的时候 解码器应该为自己写的吧！？！？ 在线求解