apache mina 自定义编码解码

774530750

mina允许自定义数据传输的编码和解码方式
需要
实现ProtocolCodecFactory接口的工厂类
实现ProtocolDecoder接口的解码类
实现ProtocolEncoder接口的编码类
本例以client和server端都是java实现
首先定义传输的数据格式：
编码和解码都是针对数据字节。
数据格式：A+B+C+D
A:固定长度 6个字节，用来简单表示时间戳，
  月日年，时分秒每个一字节，年取后两位
B：内容（C+D）的length,固定长度，4个字节
C：请求指令：固定长度，4个字节
D：传递内容：不固定，json格式
这样针对上面的数据结构定义一个bean
public class MyMessage implements Serializable {
/****/
private static final long serialVersionUID = 5570201892267872279L;
private Date date;//时间
private int command;//指令
private byte[] contents;//内容
public int getCommand() {
return command;
}
public void setCommand(int command) {
this.command = command;
}
public byte[] getContents() {
return contents;
}
public void setContents(byte[] contents) {
this.contents = contents;
}
public int length(){
return contents.length;
}
public Date getDate() {
return date;
}
public void setDate(Date date) {
this.date = date;
}
}

编码类，继承org.apache.mina.filter.codec.CumulativeProtocolDecoder
重新encode方法即可
public class MyEncoder implements ProtocolEncoder {
@Override
public void encode(IoSession session, Object message,
ProtocolEncoderOutput out) throws Exception {
MyMessage msg = (MyMessage) message;
IoBuffer buffer = IoBuffer.allocate(1024);
buffer.setAutoExpand(true);
//编码数据结构的A，时间戳
buffer.put(getTimeTag(msg.getDate()));
//数据结构的B
buffer.putInt(msg.length()+4);
//数据结构的C
buffer.putInt(msg.getCommand());
//数据结构的D
buffer.put(msg.getContents());
buffer.flip();
out.write(buffer);
}
@Override
public void dispose(IoSession session) throws Exception {
}
public static byte[] getTimeTag(Date date){
if(date == null){
date = new Date();
}
Calendar c = Calendar.getInstance();
c.get(Calendar.YEAR);
String dateStr = sdf.format(date);
String[] dates = dateStr.split("-");
byte[] bt = new byte[dates.length];
for(int a=0;a<dates.length;a++){
bt[a] = Byte.parseByte(dates[a]);
}
return bt;
}
}

解码类，继承自org.apache.mina.filter.codec.CumulativeProtocolDecoder
重新decode方法
public class MyDecoder extends CumulativeProtocolDecoder {
@Override
protected boolean doDecode(IoSession session, IoBuffer in,
ProtocolDecoderOutput out) throws Exception {
//读取数据结构A
byte[] dateTag = new byte[6];
in.get(dateTag);
//读取数据结构B
int length =in.getInt();
//读取数据结构C
int command = in.getInt();
//读取数据结构D
byte[] bytes = new byte[length-4];
in.get(bytes);
//提取出数据结构对象
MyMessage msg = new MyMessage();
msg.setCommand(command);
msg.setContents(bytes);
out.write(msg);
return true;
}
}

工厂类，很简单。主要是给server端和client端提供使用
public class MyCodeFactory implements ProtocolCodecFactory{
private ProtocolDecoder decoder;
private ProtocolEncoder encoder;
public MyCodeFactory() {
decoder = new MyDecoder();
encoder = new MyEncoder();
}
@Override
public ProtocolEncoder getEncoder(IoSession session) throws Exception {
return encoder;
}
@Override
public ProtocolDecoder getDecoder(IoSession session) throws Exception {
return decoder;
}
}

写到这里基本上自定义编码解码部分就完成了，下面使用就和其他已有mina提供的
编码解码filter一样使用了
首先还是要定义两个handler
server端handler：
public class MyServerHandler extends IoHandlerAdapter {
@Override
public void exceptionCaught( IoSession session, Throwable cause ) throws Exception
{
cause.printStackTrace();
session.close(true);
}
@Override
public void messageReceived( IoSession session, Object message ) throws Exception
{
//收到了上面解码后的消息
MyMessage msg = (MyMessage) message;
if(message == null){
//TODO
}
int cmd = msg.getCommand();
String body = new String(msg.getContents());
String result = "";
//TODO
/**
根据请求指令的不同，调用后续的业务，
然后响应内容到client
*/
System.out.println(msg.getCommand()+"-----"+new String(msg.getContents()));
session.write(msg);
}
}

client端handler
public class MyClientHandler extends IoHandlerAdapter {
@Override
public void sessionOpened(IoSession session) throws Exception {
//session.write(obj);
}
@Override
public void messageReceived(IoSession session, Object message)
throws Exception {
//收到消息，。。。
MyMessage gm = (MyMessage) message;
System.out.println(gm.getCommand()+":"+new String(gm.getContents()));
}
@Override
public void exceptionCaught(IoSession session, Throwable cause)
throws Exception {
session.close(true);
}
}

server端配置：
IoAcceptor accepter = new NioSocketAcceptor();
ProtocolCodecFilter coderFilter =
//使用自定义的编码解码filter
new ProtocolCodecFilter(new MyCodeFactory());
accepter.getFilterChain().addLast("a", new LoggingFilter());
accepter.getFilterChain().addLast("b",coderFilter);
//绑定handler
accepter.setHandler(new MyServerHandler());
accepter.getSessionConfig().setReadBufferSize(2048);
accepter.getSessionConfig().setIdleTime(IdleStatus.BOTH_IDLE, 10);
accepter.bind(new InetSocketAddress(8484));

client端配置：
NioSocketConnector connector = new NioSocketConnector();
connector.setConnectTimeoutMillis(20000);
connector.getFilterChain().addLast("codes", new ProtocolCodecFilter(
new MyCodeFactory()));
connector.setHandler(new MyClientHandler());
ConnectFuture future = connector.connect(new InetSocketAddress("localhost", 8484));
future.awaitUninterruptibly();
IoSession session = null;
session = future.getSession();
MyMessage gm = new MyMessage();
Map<String, String> map = new HashMap<String, String>();
gm.setCommand(101);
map.put("name", "bird");
map.put("age", "7");
//JsonUtil json工具类，map转json，随便找个就行
gm.setContents(JsonUtil.objectToStr(map).getBytes());
session.write(gm);
connector.dispose();


运行后server端会打印：1001-----{"name":"c","age":"7"}
client：1001:{"name":"c","age":"7"}
都能正确获取到传递的内容。