Apache Mina的学习应用（一）

        在一般的项目中使用Mina要求在发送消息前加密数据，在接收数据时解析数据。在加密和解析需要自己定义相应的解析协议。如果采用Mina是就可以简单省事的定义自己的解析和加密协议。 只需实现Mina自己的类库即可。实现相应的方法即可。

   如在客户端发送消息先加密，在服务端进行解密，服务端把执行的结果封装成对象之后，先加密之后发送到客户端，客户端，接收到信息后在解密的过程，也是多数mina应用的过程。

   首先定义自己的协议基类：

自定义消息体必须是实现MINA的消息的加密类MessageEncoder类 和消息的解密类：MessageDecoder 类针对客户端消息Message 和ResultMessage 的不同解析过程主要为消息体的解析。在消息的加密和解密基类中定义一些公共 的方法。

消息的加密类的基类：
 package cn.com.unutrip.java.opensource.mina.sumup.codec;
import org.apache.mina.core.buffer.IoBuffer;
import org.apache.mina.core.session.IoSession;
import org.apache.mina.filter.codec.ProtocolEncoderOutput;
import org.apache.mina.filter.codec.demux.MessageEncoder;
import cn.com.unutrip.java.opensource.mina.sumup.message.AbstractMessage;
/**
 * 加密消息头和消息的体的信息
 * @author longgangbai
 *
 * @param <T>
 */
public abstract class AbstractMessageEncoder<T extends AbstractMessage> implements MessageEncoder<T> {
      private final int type;
      protected AbstractMessageEncoder(int type){
    this.type=type;
      }
      
      /**
       * 加密的整个过程的
       */
      @Override
      public void encode(IoSession session ,T message ,ProtocolEncoderOutput out)throws Exception
      {
   IoBuffer buf=IoBuffer.allocate(6);
          //Enable auto-expand for easier encoding
   buf.setAutoExpand(true);
   //加密 消息头
   buf.putShort((short)type);
   buf.putInt(message.getSequence());
   //加密消息体
   encodeBody(session, message, buf);
          buf.flip();
          out.write(buf);
      }
      /**
       * 解析消息的体的方法的
       * @param session
       * @param message
       * @param out
       */
      protected abstract void encodeBody(IoSession session ,T message ,IoBuffer out);
}
 
消息的解密类的基类：
package cn.com.unutrip.java.opensource.mina.sumup.codec;
import org.apache.mina.core.buffer.IoBuffer;
import org.apache.mina.core.session.IoSession;
import org.apache.mina.filter.codec.ProtocolDecoderOutput;
import org.apache.mina.filter.codec.demux.MessageDecoder;
import org.apache.mina.filter.codec.demux.MessageDecoderResult;
import cn.com.unutrip.java.opensource.mina.sumup.message.AbstractMessage;
/**
 * 
 * @author longgangbai
 *
 */
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)
     { 
  //当信息头（header）中没有读取时返回需要读取 NEED_DATA
         if(in.remaining()<Constants.HEADER_LEN){
              return MessageDecoderResult.NEED_DATA;
         }
         //如果类型和长度匹配返回 OK
         if(type==in.getShort())
         {
            return  MessageDecoderResult.OK;
         }
         //如果不匹配返回NOT OK
        return MessageDecoderResult.NOT_OK;  
     }
     
     
     public MessageDecoderResult decode(IoSession session ,IoBuffer in,ProtocolDecoderOutput out)throws Exception
     { 
  //当信息头（header）中没有读取时返回需要读取 NEED_DATA
         if(!readHeader){
             //忽略此种类型
             in.getShort();
             sequence=in.getInt();
             readHeader=true;
         }
         // 获取消息的解析内容
         AbstractMessage m=decodeBody(session, in);
         //如果
         if(m==null)
         {
            return  MessageDecoderResult.NEED_DATA;
         }else{
             //重新设置readerHeader 为下一次解析作准备
             readHeader=false;
         }
         m.setSequence(sequence);
         out.write(m);
        return MessageDecoderResult.OK;  
     }
     /**
      * 解析消息的body体的信息
      * @param session
      * @param in
      * @return
      */
     protected abstract AbstractMessage decodeBody(IoSession session ,IoBuffer in);
}
 
Message消息体的加密和解密过程：
package cn.com.unutrip.java.opensource.mina.sumup.codec;
import org.apache.mina.core.buffer.IoBuffer;
import org.apache.mina.core.session.IoSession;
import org.apache.mina.filter.codec.ProtocolDecoderOutput;
import cn.com.unutrip.java.opensource.mina.sumup.message.AbstractMessage;
import cn.com.unutrip.java.opensource.mina.sumup.message.AddMessage;
/**
 * 添加消息的解密解析器
 * @author longgangbai
 *
 */
public class AddMessageDecoder extends AbstractMessageDecoder {
    public AddMessageDecoder(){
  super(Constants.ADD);
    }
    /**
     * 解析消息体的过程
     */
    @Override
    protected AbstractMessage decodeBody(IoSession session, IoBuffer in) {
         if(in.remaining()<Constants.ADD_BODY_LEN)
         {
             return null;
         }
         AddMessage message=new AddMessage();
         message.setValue(in.getInt());
 return message;
    }
    /**
     * 解析完毕的操作
     */
    @Override
    public void finishDecode(IoSession session, ProtocolDecoderOutput output)
     throws Exception {
    }
}
 
 
package cn.com.unutrip.java.opensource.mina.sumup.codec;
import org.apache.mina.core.buffer.IoBuffer;
import org.apache.mina.core.session.IoSession;
import cn.com.unutrip.java.opensource.mina.sumup.message.AddMessage;
/**
 *  添加消息的加密解析器
 * @author longgangbai
 *
 * @param <T>
 */
public  class AddMessageEncoder<T extends AddMessage> extends AbstractMessageEncoder<T> {
         public AddMessageEncoder() {
             super(Constants.ADD);
        }
 @Override
 protected void encodeBody(IoSession session, T message, IoBuffer out) {
     out.putInt(message.getValue());
 }
 public  void dispose()throws Exception{
             
        }
}

 

文章尚未写完，请关注下文。