初识mina

    最近在看郭霖大神的慕课网视频学习mina框架，把学习的情况记录下来，方便以后查阅。

    网上关于mina详细介绍很多，我就不班门弄斧了。一边看视频一边慢慢更新。

    这次把注释放到代码里面，更加细致。

    官网下载mina的jar包，先只导入mina-core-x.x.x.jar和slf4j-api-x.x.x.jar(mina日志打印包，不导入会报错)。

    使用mina最基本的功能只需要四步。

主函数类

public class MinaServer {

    public static void main(String[] args) {
        try {

            NioSocketAcceptor acceptor = new NioSocketAcceptor();

            /*
             * 自己定义Handler对象来处理消息
             */
            acceptor.setHandler(new MyServerHandler());

            /*
             * 获取拦截器来过滤信息
             * 添加新的拦截器
             * MyTextLineFactory()是自己定义的拦截器
             */
            acceptor.getFilterChain().addLast("codec", new ProtocolCodecFilter(new MyTextLineFactory()));

            /*
             * 定义idle，即设置连接多久无消息收发为进入空闲状态
             * 第一个参数IdleStatus.BOTH_IDLE为多久没有读取且没有收到向客户端发送消息
             * 第二个参数是设置时间，单位是秒。每隔60秒再次输出表示你又进入空闲状态
             */
            acceptor.getSessionConfig().setIdleTime(IdleStatus.BOTH_IDLE, 60);

            /*
             * 绑定一个端口
             */
            acceptor.bind(new InetSocketAddress(9090));
        } catch (Exception e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        }
    }
}

自定义MyserverHandler类

public class MyServerHandler extends IoHandlerAdapter {

    /**
     * 网络异常的时候调用方法
     */
    @Override
    public void exceptionCaught(IoSession session, Throwable cause)
            throws Exception {
        System.out.println("exceptionCaught");
    }

    /**
     * 接收到消息的时候调用方法
     */
    @Override
    public void messageReceived(IoSession session, Object message)
            throws Exception {
        String s = (String)message;
        System.out.println("messageReceived : " + s);
    }

    /**
     * 发出消息的时候调用方法
     */
    @Override
    public void messageSent(IoSession session, Object message) throws Exception {
        System.out.println("messageSent");
    }

    /**
     * 客户端会话关闭时调用的方法
     */
    @Override
    public void sessionClosed(IoSession session) throws Exception {
        System.out.println("sessionClosed");
    }

    /**
     * 客户端会话开启的时候调用的方法
     */
    @Override
    public void sessionCreated(IoSession session) throws Exception {
        System.out.println("sessionCreated");
    }

    /**
     * 客户端进入空闲状态的时候调用的方法
     */
    @Override
    public void sessionIdle(IoSession session, IdleStatus status)
            throws Exception {
        System.out.println("sessionIdle");
    }

    /**
     * 会话打开的时候调用的方法
     */
    @Override
    public void sessionOpened(IoSession session) throws Exception {
        System.out.println("sessionOpened");
    }
}

继承于IoHandlerAdapter类，实现里面的几个方法，将log打印出来、

自定义拦截器来拦截收发消息

public class MyTextLineFactory implements ProtocolCodecFactory {

    //自定义加码类
    private MyTextLineEncoder mEncoder;
    //自定义解码类
    private MyTextLineDecoder mDecoder;
    //自定义防止数据丢失解码类
    private MyTextLineCumulativeDecoder mCumulativeDecoder;

    public MyTextLineFactory() {
        mEncoder = new MyTextLineEncoder();
        mDecoder = new MyTextLineDecoder();
        mCumulativeDecoder = new MyTextLineCumulativeDecoder();
    }

    public ProtocolDecoder getDecoder(IoSession arg0) throws Exception {
        //返回的是防丢失的Decoder
        return mCumulativeDecoder;
    }

    public ProtocolEncoder getEncoder(IoSession arg0) throws Exception {
        return mEncoder;
    }
}

    你可以用mina中定义的，不过为了适应自己的需要，还是自己定义比较好。

    新建一个MyTextLineFactory继承于ProtocolCodecFactory。

    在MyTextLineFactory中，使用了自定义的加解码器来实现收发数据的加解码。

自定义编码类来给数据加码

public class MyTextLineEncoder implements ProtocolEncoder {

    public void dispose(IoSession arg0) throws Exception {

    }

    public void encode(IoSession session, Object message, ProtocolEncoderOutput out)
            throws Exception {

        String s = null;
        if(message instanceof String) {
            s = (String)message;
        }
        //开始转码操作
        if(s != null) {
            /*
             * 将字符串进行编码，采取系统默认的编码方式
             * 为了提高效率（因为每一次都要获取系统默认的编码方式），这里采取一个判断
             * 
             * 类似于ListView的ViewHoder
             * 如果session中没有获取到属性 encoder，那么就创建一个为系统默认编码的加密方式
             * 如果有的话就使用之前就有的，这样的方法可以提高运行效率
             */
            CharsetEncoder charsetEncoder = (CharsetEncoder)session.getAttribute("encoder");
            if(charsetEncoder == null) {
                charsetEncoder = Charset.defaultCharset().newEncoder();
                session.setAttribute("encoder", charsetEncoder);
            }
            //mina框架中开辟内存
            IoBuffer ioBuffer = IoBuffer.allocate(s.length());
            //设置内存可以自动开辟内存
            ioBuffer.setAutoExpand(true);
            //设置put数据类型为系统本身的格式
            ioBuffer.putString(s,charsetEncoder);
            ioBuffer.flip();
            //写出数据
            out.write(ioBuffer);
        }
    }
}

最后定义解码器，将收到的字节码转化为字符串

public class MyTextLineCumulativeDecoder extends CumulativeProtocolDecoder{

    /**
     * 当且仅当数据读取完的时候返回true
     * 如果没有读取完想要下次再进行读取的时候就返回false
     */
    @Override
    protected boolean doDecode(IoSession session, IoBuffer ioBuffer,
            ProtocolDecoderOutput out) throws Exception {
        //开始读取的位置
        int startPosition = ioBuffer.position();
        //判断ioBuffer里面是否还有字节可以读取
        while(ioBuffer.hasRemaining()) {
            byte b = ioBuffer.get();
            if(b == '\n') {
                //读取到 '\n'的时候的位置记录下来
                int currentPosition = ioBuffer.position();

                //当前的总长度
                int limit = ioBuffer.limit();

                //把初始位置定在字符串开始的第一个字节上
                ioBuffer.position(startPosition);

                //limit是终点的的位置，这里就是读到currentPosition的地方
                //从startPosition到currentPosition位置，就是读取到'\n'的总长度
                ioBuffer.limit(currentPosition);

                //截取从startPosition位置到currentPosition位置的所有字节，返回的是一个IoBuffer
                IoBuffer sliceIoBuffer = ioBuffer.slice();

                //把字节码转换成字符串
                byte [] dest = new byte[sliceIoBuffer.limit()];
                sliceIoBuffer.get(dest);
                String str = new String(dest);

                //写出数据
                out.write(str);

                /*
                 * 因为在之间重定位在startPosition的位置，如果我们不重新定位到当前位置的话，
                 * 就会一直从 startPosition -> currentPosition不停的循环导致死循环
                 * 这里要把开始位置定义到currentPosition
                 */
                ioBuffer.position(currentPosition);
                ioBuffer.limit(limit);
                return true;
            }
        }
        //如果没有读取完就要把position重新读取到开始的位置
        ioBuffer.position(startPosition);
        return false;
    }
}

    这里选择继承的是CumulativeProtocalDecoder类，这个类和ProtocalDecoder的区别在于decode方法有一个返回值，这个返回值是在循环读取的时候判断是否读取完成整个字节。如果是完全读取就返回一个true。否则就返回一个false，并且将position定位在开始的位置重新读取。

    以上是服务器端的代码，下面是客户端的代码。

    写一些简简单单测试的代码测试是否能联通。

public class MinaClient {

    public static void main(String[] args) throws Exception{
        NioSocketConnector connector = new NioSocketConnector();
        connector.setHandler(new MyClientHandler());
        connector.getFilterChain().addLast("codec", new ProtocolCodecFilter(new TextLineCodecFactory()));
        ConnectFuture future = connector.connect(new InetSocketAddress("127.0.0.1",9090));
        //阻塞连接，直到连接上服务器
        future.awaitUninterruptibly();
        //当连接上后会返回一个IoSession对象，有这个对象可以完成许多事情
        IoSession ioSession = future.getSession();
        //获取从控制台输入的流
        BufferedReader readIn = new BufferedReader(new InputStreamReader(System.in));
        String inputContent;
        //当不输入bye的时候就发送输出的内容
        while(!(inputContent = readIn.readLine()).equals("bye")) {
            ioSession.write(inputContent);
        }
    }
}

首先还是导入那两个包

客户端的代码和服务端的代码差不多。从控制台输出数据，服务器能够接受到数据。

其中new MyClientHandler()中的代码与服务器中的MyServerHandler是一样的，只是改了名字而已。

这样就完成了一个简单的客户端和服务器连接的例子