Mina框架定义

Mina框架是 Apache 开源的一款网络通信应用框架，是一款Java NIO通信框架。

Mina框架作用

Mina框架是对Java NIO包的一个封装，简化了NIO程序开发的难度，封装了很多底层的细节。

主要屏蔽了网络通信的一些细节，比如：对Socket进行封装，并且是NIO的一个实现架构，可以帮助我们快速的开发网络通信。

Mina框架架构

1.通讯层框架

MINA是应用程序（服务端和客户端）和网络层间（TCP UDP 内存通信）的桥梁，Mina位于用户应用程序和底层Java网络API（和in-VM通讯）之间，咱们开发基于Mina的网络应用程序，就无需关心复杂的通讯细节。

Mina框架详解(定义作用及功能架构)-mikechen

2.应用总体架构

Mina的底层依赖的主要是Java NIO库，上层提供的是基于事件的异步接口，Mina应用框架被分成了主要的3个组件部分，远程客户端通过IoService建立连接得到session，session将数据传送到IoFilterChain进行过滤，最后客户端在IoHandle中进行数据操作。IoFilter作为IoService 和IoHandler 之间的桥梁。

I/O Service，具体提供服务的组件。
I/O Filter Chain，过滤器链，负责编码处理，字节到数据结构或数据结构到字节的转换等，即非业务逻辑的操作；
I/O Handler，用于处理用户的业务逻辑。

Mina框架详解(定义作用及功能架构)-mikechen

Server/Client架构

服务端的作用就是开启监听端口，等待请求的到来、处理他们、以及将发送对请求的响应。同时，服务端会为每个连接创建session，在session周期内提供各种精度的服务，比如连接创建时(sessionCreated(IoSession session))、连接等待时(sessionIdle(IoSession session, IdleStatus status))、连接销毁时(sessionClosed(IoSession session))等。mina的api为TCP/UDP提供的一致性Server端操作。

IOAcceptor 监听来自网络的请求。
当新的连接建立时，一个新的session会被创建，该session用作对同一IP/端口组合的客户端提供服务。
数据包需经过一系列的过滤器，这些过滤器可用来修改数据包的内容（如转换对象、添加或修改信息等），其中将原始字节流转换成POJO对象是非常有用的。当然这需要解编码器提供支持。
最后这些数据包或转化后的对象将交由IOHandler处理，我们将实现IOHandler用于处理具体的业务逻辑。

客户端执行流程，客户端通过 IoHandler 从服务器端接收所有响应请求和消息之后，通过开发者在 IoConnector 连接服务器时，遍历加入过滤链的过滤器，接着通过 IoConnector 发送数据到服务器端。

客户端首先创建一个IOConnector，并启动与Server的绑定
创建Connection后，将创建一个Session，并与Connection关联
应用程序/客户端写会话，导致数据被发送到服务器，在遍历过滤链
从Server接收到的所有响应/消息都将遍历过滤器链并落在IOHandler上进行处理

Mina框架详解(定义作用及功能架构)-mikechen

Mina框架使用场景

服务端异步通信场景：mina是个异步通信框架,一般使用场景是服务端开发,长连接、异步通信使用；

游戏行业：如果要使用Java语言来开发游戏服务器，那么Mina框架可以作为选择；

MINA框架的应用比较广泛，应用的开源项目有Apache Directory、AsyncWeb、ApacheQpid、QuickFIX/J、Openfire、SubEthaSTMP、red5等。

Mina网络通信框架

由于传统的 Socket 网络编程基于一个线程对应一个客户端的实现方式，大量的线程创建和销毁导致性能下降，无法应对高并发量的访问，所以基于服务器端的网络通信开发，我们常用 Mina 网络通信框架，即常说的 Java NIO ( java non-blocking IO ) 开发。

首先，我们来看看 Mina 的几个重要接口：

IoServiece ：这个接口在一个线程上负责套接字的建立，拥有自己的 Selector，监听是否有连接被建立。
IoProcessor ：这个接口在另一个线程上负责检查是否有数据在通道上读写，也就是说它也拥有自己的
 Selector，这是与我们使用 JAVA NIO 编码时的一个不同之处，通常在 JAVA NIO 编码中，我们都
 是使用一个 Selector，也就是不区分 IoService与 IoProcessor 两个功能接口。另外，IoProcessor 负责调用注册在 IoService 上的过滤器，并在过滤器链之后调用 IoHandler。  
IoAccepter ：相当于网络应用程序中的服务器端
IoConnector ：相当于客户端
IoSession ：当前客户端到服务器端的一个连接实例
IoHandler ：这个接口负责编写业务逻辑，也就是接收、发送数据的地方。这也是实际开发过程中需要用户自己编写的部分代码。
IoFilter ：过滤器用于悬接通讯层接口与业务层接口，这个接口定义一组拦截器，这些拦截器可以包括日
志输出、黑名单过滤、数据的编码（write 方向）与解码（read 方向）等功能，其中数据的 encode与 
decode是最为重要的、也是你在使用 Mina时最主要关注的地方。

接着，我们来看看 Mina 的一个重要的类 IoHandlerAdapter，此类仅仅是实现了 IoHandler 接口，但并不做任何处理。
一个 IoHandler 接口中具有如下一些方法（摘自 MINA 的 API 文档）：

void exceptionCaught(IoSession session, Throwable cause)
当接口中其他方法抛出异常未被捕获时触发此方法
void messageReceived(IoSession session, Object message)
当接收到客户端的请求信息后触发此方法
void messageSent(IoSession session, Object message)
当信息已经传送给客户端后触发此方法
void sessionClosed(IoSession session)
当连接被关闭时触发，例如客户端程序意外退出等等
void sessionCreated(IoSession session)
当一个新客户端连接后触发此方法
void sessionIdle(IoSession session, IdleStatus status)
当连接空闲时触发此方法
void sessionOpened(IoSession session)
当连接后打开时触发此方法，一般此方法与 sessionCreated 会被同时触发

下面我们来看看 Mina 服务器网络通信框架开发流程：

1、引入依赖: mina-core-2.0.13

2、创建acceptor，绑定Handler，设置Filter，绑定端口

            NioSocketAcceptor acceptor = new NioSocketAcceptor();
            acceptor.setHandler(new MyServerHandler());
            // 获取拦截器，拦截器作用：把字节转成对象
            // TextLineCodecFactory 把数据进行加解码
            acceptor.getFilterChain().addLast("codec",
                    new ProtocolCodecFilter(new TextLineCodecFactory()));
            // 5秒钟服务器和客户端没有进行读写，则进入空闲状态Idle
            acceptor.getSessionConfig().setIdleTime(IdleStatus.BOTH_IDLE, 5);
            //绑定9898端口
            acceptor.bind(new InetSocketAddress(9898));

3、创建自定义的Handler

package com.example.server;

import org.apache.mina.core.service.IoHandlerAdapter;
import org.apache.mina.core.session.IdleStatus;
import org.apache.mina.core.session.IoSession;

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);
        session.write("server replay: " + 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");
    }

}

4、由于默认的 Filter: TextLineCodeFactory 只能接收以换行符为结束的消息，有时为满足特定需求，需要自定义一个 Factory

package com.example.server;

import org.apache.mina.core.session.IoSession;
import org.apache.mina.filter.codec.ProtocolCodecFactory;
import org.apache.mina.filter.codec.ProtocolDecoder;
import org.apache.mina.filter.codec.ProtocolEncoder;

public class MyTextLineFactory implements ProtocolCodecFactory {
    
    

    private MyTextLineDecoder mDecoder;
    private MyTextLineEncoder mEncoder;
    private MyTextLineCumulativeDecoder mCumulativeDecoder;

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

    // 加密
    @Override
    public ProtocolDecoder getDecoder(IoSession arg0) throws Exception {
    
    
        // return mDecoder;
        // 解决没检测到\n时的数据丢失问题
        return mCumulativeDecoder;
    }

    // 解密
    @Override
    public ProtocolEncoder getEncoder(IoSession arg0) throws Exception {
    
    
        return mEncoder;
    }

}
package com.example.server;

import java.nio.charset.Charset;
import java.nio.charset.CharsetEncoder;

import org.apache.mina.core.buffer.IoBuffer;
import org.apache.mina.core.session.IoSession;
import org.apache.mina.filter.codec.ProtocolEncoder;
import org.apache.mina.filter.codec.ProtocolEncoderOutput;

public class MyTextLineEncoder implements ProtocolEncoder {
    
    

    @Override
    public void dispose(IoSession session) throws Exception {
    
    

    }

    @Override
    public void encode(IoSession session, Object message,
            ProtocolEncoderOutput output) throws Exception {
    
    
        String s = null;
        if (message instanceof String) {
    
    
            s = (String) message;
        }
        if (s != null) {
    
    
            // 系统默认的Encoder
            CharsetEncoder charsetEncoder = (CharsetEncoder) session
                    .getAttribute("encoder");
            if (charsetEncoder == null) {
    
    
                charsetEncoder = Charset.defaultCharset().newEncoder();
                session.setAttribute("encoder", charsetEncoder);
            }
            IoBuffer ioBuffer = IoBuffer.allocate(s.length());
            ioBuffer.setAutoExpand(true);// 自动扩展
            ioBuffer.putString(s, charsetEncoder);
            ioBuffer.flip();
            output.write(ioBuffer);
        }
    }
}
package com.example.server;

import org.apache.mina.core.buffer.IoBuffer;
import org.apache.mina.core.session.IoSession;
import org.apache.mina.filter.codec.ProtocolDecoder;
import org.apache.mina.filter.codec.ProtocolDecoderOutput;

public class MyTextLineDecoder implements ProtocolDecoder {
    
    

    @Override
    public void decode(IoSession session, IoBuffer ioBuffer,
            ProtocolDecoderOutput output) throws Exception {
    
    
        // 起始位置
        int startPosition = ioBuffer.position();
        // 是否还有数据
        while (ioBuffer.hasRemaining()) {
    
    
            byte b = ioBuffer.get();
            // 读取到\n
            if (b == '\n') {
    
    
                // 当前位置
                int currentPosition = ioBuffer.position();
                // 当前总长度,指向末尾
                int limit = ioBuffer.limit();
                // 截取行
                ioBuffer.position(startPosition);
                ioBuffer.limit(currentPosition);
                IoBuffer buf = ioBuffer.slice();
                // 把buf中的数据写入到dest
                byte[] dest = new byte[buf.limit()];
                buf.get(dest);
                String str = new String(dest);
                output.write(str);
                // 还原位置
                ioBuffer.position(currentPosition);
                ioBuffer.limit(limit);
            }
        }

    }

    @Override
    public void dispose(IoSession arg0) throws Exception {
    
    

    }

    @Override
    public void finishDecode(IoSession arg0, ProtocolDecoderOutput arg1)
            throws Exception {
    
    

    }
}

5、为了解决数据丢失问题，我们常使用 CumulativeProtocolDecoder

package com.example.server;

import org.apache.mina.core.buffer.IoBuffer;
import org.apache.mina.core.session.IoSession;
import org.apache.mina.filter.codec.CumulativeProtocolDecoder;
import org.apache.mina.filter.codec.ProtocolDecoderOutput;

/**
 * 处理数据丢失
 */
public class MyTextLineCumulativeDecoder extends CumulativeProtocolDecoder {
    
    

    @Override
    protected boolean doDecode(IoSession ioSession, IoBuffer ioBuffer,
            ProtocolDecoderOutput output) throws Exception {
    
    
        // 起始位置
        int startPosition = ioBuffer.position();
        // 是否还有数据
        while (ioBuffer.hasRemaining()) {
    
    
            byte b = ioBuffer.get();
            // 读取到\n
            if (b == '\n') {
    
    
                // 当前位置
                int currentPosition = ioBuffer.position();
                // 当前总长度,指向末尾
                int limit = ioBuffer.limit();
                // 截取行
                ioBuffer.position(startPosition);
                ioBuffer.limit(currentPosition);
                IoBuffer buf = ioBuffer.slice();
                // 把buf中的数据写入到dest
                byte[] dest = new byte[buf.limit()];
                buf.get(dest);
                String str = new String(dest);
                output.write(str);
                // 还原位置
                ioBuffer.position(currentPosition);
                ioBuffer.limit(limit);
                return true;// 读取完成
            }
        }

        ioBuffer.position(startPosition);
        return false;// 读取未完成
    }
}

至此，整个服务器搭建框架就完了，是否比 Socket 开发要简洁呢？下节笔者将为大家带来一个完整案例，并给出相应的 jar 包和源码。