NIO之路3---MINA框架详细解析

前言：

上一文分析了Java NIO的实现逻辑， 可以发现NIO相比于BIO来说性能提升了不止一个档次，但是Java的NIO使用还有一个弊端，比如Buffer的API设计太过复杂，想要用好NIO就需要对于NIO的各个组件的所以API使用非常熟练才行，对于新手来说入门门槛比较高。

所以如果有一个框架能够将NIO的API进行封装，让开发者只需要关心具体的IO数据而不需要关心IO数据的发送和接收过程，那么就会大大降低开发NIO程序的入门门槛。而MINA框架就是基于Java NIO实现的一款基于异步事件的NIO框架。

一、MINA简介

MINA是基于Java NIO技术的网络应用程序框架，通过Java NIO通过TCP/UDP等网络协议提供了一套抽象的实践驱动的异步API。MINA提供了网络通信的服务端和客户端，无论是哪段在Min通信框架中的工作流程基本上一致，所以Mina的优点就是将网络通信的操作与业务系统隔离开，业务系统只需要关系数据的发送、接收和具体的业务处理即可。衡量一个开源框架是否成熟，框架对于业务系统代码的侵入性高低是很大一个衡量标准。

二、MINA的组件

NIO的三大核心组件为channel（通道）、Buffer（缓冲区）以及Selector（多路复用选择器），而MINA在NIO的三大核心基础之上又衍生出了很多的组件，分别如下：

2.1、IoBuffer

IO数据缓冲区，相当于NIO的Buffer，而MINA的IoBuffer实际上也就是NIO的Buffer的封装，因为NIO的Buffer只能对基本数据类型进行操作，而不可以对于字符串或自定义对象类型的操作，而IoBuffer可以对于任何对象类型进行操作。另外Buffer的使用是定长的，而IoBuffer的长度是可变的，使用起来伸缩性更好。

2.2、IoSession

客户端和服务端的IO会话，相当于NIO的channel，在MINA中整个IO操作流程中都是建立在IoSession之上，所以IoSession会贯穿整个IO操作流程。IO数据的读写也分别是调用IoSession的write和read方法来进行操作的

2.3、IoService

最底层的IO服务，负责具体的IO操作，分别包括服务端的IoSocketAcceptor和IoSocketChannel，类似于NIO中的Selecotr，分别用于IoSession的创建，以及IO数据具体的发送和接收工作。IOService最大的作用是将底层IO数据的操作进行封装，再通过异步的方式将IO事件上报给上层业务层处理，所以相当于将NIO的同步IO改成了异步IO操作

2.4、IoFilter

IO过滤器，IoService将IO数据封装成IoBuffer上报给上层，但是上层可需要对数据进行统一的编解码解析操作，而这些统一的编解码操作就可以交给IO过滤器来处理，过滤器将IoService提供的IO数据进行编解码、解析、日志打印等功能处理之后再交给业务层。

2.5、IoFilterChain

一组IoFilter链，将多个IoFilter组合成一个IO过滤器链，接收数据就从尾部依次过滤到尾部，发送数据从头部依次过滤到尾部

2.6、IoProcessor

为IO数据处理提供多线程环境，IoProcessor通常会有多个，IoService有IO数据交互时会交给IoProcessor，IoProcessor再来异步处理。每一个IoProcessor内部都有一个Selector，相当于将Java NIO的单个Selector改成了多个Selector

2.7、IoHandler

IO数据的业务处理器，通过IoFilter过滤之后，会将IO数据封装成业务层需要的个数，比如字符串格式，JSON格式，此时将业务层需要的格式的数据交给业务层处理器IoHandler再进行真正的业务逻辑处理，也就是IO数据流的终点

总结MINA的整体IO交互架构如下图示：

三、MINA的工作流程

服务端核心步骤如下：

1、创建IoService的实例IoAcceptor对象，负责监听客户端的连接请求

2、初始化IoAcceptor对象，主要是绑定IoFilter和IoHandler，依次添加多个IoFilter到IoAccetpor上，并且设置IoAcceptor的业务处理器IoHandler对象，最好绑定IoAcceptor的监听端口

3、IoAcceptor接收客户端的连接请求之后，将IO操作分配给IoProcessor，IoProcessor通常是多线程的，之后的IO处理都是由IoProcessor执行

4、IoProcessor依次调用IoFilterChain上的所有IO过滤器的过滤方法

5、IO数据经过所有的IO过滤器处理之后交给业务处理器IoHandler对象进行最终的业务处理

 

总结MINA的整体工作如下图示：

 

四、MINA的使用案例

服务端代码案例如下：

1、自定义IoFilter的实现类TimeFilter，由于IoFilter定义的方法较多，而不是每一个IoFilter实现类都需要实现所有的方法，比如消息发送和消息接收方法，正常情况下需要对于接收数据进行解码处理，而需要丢发送数据进行编码处理，所以可以定义不同的过滤器实现不同的IoFilter定义的方法，此时就可以不直接实现IoFilter，而是可以通过继承IoFilter的适配器IoFilterAdater，IoFilterAdater实现了所有的IoFilter接口定义的方法，并且都作了默认的处理，所以如果需要自定义IoFilter实现类，就可以直接继承之IoFilterAdapter，并且再重写需要实现的方法即可，如案例中的TimeFilter仅仅只重写了messageReceived和messageSent两个方法

/**
 * @Auther: Lucky
 * @Date: 2020/8/13 下午10:31
 * @Desc: 自定义过滤器实现IoFilter接口
 */
public class TimeFilter extends IoFilterAdapter {

    @Override
    public void messageReceived(NextFilter nextFilter, IoSession session, Object message) throws Exception {
        System.out.println("接收消息时过滤,打印当前时间:" + System.currentTimeMillis());
    }

    @Override
    public void messageSent(NextFilter nextFilter, IoSession session, WriteRequest writeRequest) throws Exception {
        System.out.println("发送消息时过滤,打印当前时间:" + System.currentTimeMillis());
    }
}

2、自定义业务处理器IoHandler实现类，同样的IoHandler接口也定义了很多的方法，但是并不是所有的业务处理器都需要实现的，同样有一个IoHandler的适配器IoHandlerAdapter类，自定义IoHandler实现类只需要继承之IoHandlerAdapter，重写感兴趣的方法即可

public class GameServerHandler extends IoHandlerAdapter {

    public static GameServer gameServer = new GameServer();


    @Override
    public void messageReceived(IoSession session, Object message) throws Exception {
        System.out.println("服务器接收到消息:" + message.toString());
        GameEvent event = JSON.parseObject(message.toString(), GameEvent.class);
        if(event.getCmd() == 0){//进入房间
            gameServer.enter(event.getName(), session);
        }else if(event.getCmd() == 1){//准备游戏
            gameServer.ready(event.getName(), session);
        }
    }
}

3、创建服务器端并开启服务器

public class MinaServer {

    public static void main(String[] args) throws IOException {
        System.out.println("开始启动服务器...");
        startServer(8000);
    }

    public static void startServer(int port) throws IOException {
        /** 1.创建IoService对象,服务端是IoAcceptor用于接收客户端连接 */
        IoAcceptor acceptor = new NioSocketAcceptor();

        /** 2.给IoService添加过滤器链 */
        acceptor.getFilterChain().addLast("codec", new ProtocolCodecFilter(new TextLineCodecFactory(Charset.forName("UTF-8"))));
        acceptor.getFilterChain().addLast("log", new LoggingFilter());
        acceptor.getFilterChain().addLast("time", new TimeFilter());

        /** 3.添加业务处理器 */
        acceptor.setHandler(new GameServerHandler());

        /** 绑定监听端口号 */
        acceptor.bind(new InetSocketAddress(port));
    }
}

过程比较清晰，首先是创建IoService的实现类IoAcceptor对象，然后给IoAcceptor添加过滤器，如编解码过滤器，打印日志过滤器以及自定义的过滤器等，然后再给IoAccetor添加业务处理器，最后绑定需要监听的端口即可。

4、客户端代码如下：

public class PlayerClient {

    private String name;

    public void load(){
        /** 创建 IoService实例 */
        NioSocketConnector connector = new NioSocketConnector();

        /** 添加编解码过滤器*/
        connector.getFilterChain().addLast("codec", new ProtocolCodecFilter(new TextLineCodecFactory(Charset.forName("utf-8"))));

        /** 设置业务处理器*/
        connector.setHandler(new PlayerHandler(name));

        /** 连接服务器*/
        connector.connect(new InetSocketAddress("localhost", 8000));
    }

    public PlayerClient(String name){
        this.name = name;
    }
}

public class PlayerHandler extends IoHandlerAdapter {
    private String name;
    public PlayerHandler(String name){
        this.name = name;
    }

    @Override
    public void sessionOpened(IoSession session) throws Exception {
        /** 当连接创建成功之后向服务器发送消息*/
        GameEvent event = new GameEvent();
        event.setCmd(0);
        event.setName(name);
        session.write(JSON.toJSON(event).toString());
    }

    @Override
    public void messageReceived(IoSession session, Object message) throws Exception {
        System.out.println("玩家:" + name + "接收到消息:" + message.toString());
        if(message.toString().equals("进入房间成功")){
            GameEvent event = new GameEvent();
            event.setName(name);
            event.setCmd(1);
            session.write(JSON.toJSON(event));
        }
    }
}

自定义客户端的IoHandler，重写了sessionOpend方法，作用是和服务器连接成功之后执行该方法，messageReceived方法是接收到服务器发送过来的数据之后执行该方法

5、其他对象

public class GameEvent {

    private String name;

    private int cmd;

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public int getCmd() {
        return cmd;
    }

    public void setCmd(int cmd) {
        this.cmd = cmd;
    }
}

public class GameServer {

    public static List<PlayerSession> playerList = new ArrayList<>();
    public static AtomicInteger readyCount = new AtomicInteger(0);

    public void enter(String name, IoSession session){
        System.out.println("玩家:" + name + "进入房间");
        if(playerList.size() >=5){
            session.write("房间已满,您进入房间失败");
        }else {
            System.out.println("玩家:" + name + "进入房间成功");
            PlayerSession player = new PlayerSession(name, session);
            playerList.add(player);
            session.write("进入房间成功");
        }
    }

    public void ready(String name, IoSession session){
        System.out.println("玩家:" + name + "已准备");
        if(readyCount.incrementAndGet() ==5){
            for (PlayerSession player: playerList) {
                player.session.write("游戏开始,欢迎进入王者荣耀");
            }
        }
    }

    static class PlayerSession{
        public PlayerSession(String name,IoSession session){
            this.name = name;
            this.session = session;
        }
        private String name;
        private IoSession session;

        public String getName() {
            return name;
        }

        public void setName(String name) {
            this.name = name;
        }

        public IoSession getSession() {
            return session;
        }

        public void setSession(IoSession session) {
            this.session = session;
        }
    }

}

这里定义了一个PlayerSession对象，用于封装IoSession对象，给IoSession对象添加一个用户名称

6、模拟多个客户端连接服务器的测试代码如下：

public class MinaTest {

    public static void main(String[] args) throws InterruptedException {
        PlayerClient client1 = new PlayerClient("赵一");
        PlayerClient client2 = new PlayerClient("王二");
        PlayerClient client3 = new PlayerClient("张三");
        PlayerClient client4 = new PlayerClient("李四");
        PlayerClient client5 = new PlayerClient("孙五");
        PlayerClient client6 = new PlayerClient("小六");

        client1.load();
        Thread.sleep(3000L);

        client2.load();
        Thread.sleep(3000L);

        client3.load();
        Thread.sleep(3000L);

        client4.load();
        Thread.sleep(3000L);

        client5.load();
        Thread.sleep(3000L);

        client6.load();
    }
}

执行服务器和客户端main方法，执行结果如下：

服务端打印结果：

开始启动服务器...
17:16:39.263 [NioProcessor-2] DEBUG org.apache.mina.filter.codec.ProtocolCodecFilter - Processing a MESSAGE_RECEIVED for session 1
服务器接收到消息:{"name":"赵一","cmd":0}
玩家:赵一进入房间
玩家:赵一进入房间成功
17:16:39.362 [NioProcessor-2] DEBUG org.apache.mina.filter.codec.ProtocolCodecFilter - Processing a MESSAGE_RECEIVED for session 1
服务器接收到消息:{"name":"赵一","cmd":1}
玩家:赵一已准备
17:16:42.064 [NioProcessor-3] DEBUG org.apache.mina.filter.codec.ProtocolCodecFilter - Processing a MESSAGE_RECEIVED for session 2
服务器接收到消息:{"name":"王二","cmd":0}
玩家:王二进入房间
玩家:王二进入房间成功
17:16:42.065 [NioProcessor-3] DEBUG org.apache.mina.filter.codec.ProtocolCodecFilter - Processing a MESSAGE_RECEIVED for session 2
服务器接收到消息:{"name":"王二","cmd":1}
玩家:王二已准备
17:16:45.066 [NioProcessor-4] DEBUG org.apache.mina.filter.codec.ProtocolCodecFilter - Processing a MESSAGE_RECEIVED for session 3
服务器接收到消息:{"name":"张三","cmd":0}
玩家:张三进入房间
玩家:张三进入房间成功
17:16:45.067 [NioProcessor-4] DEBUG org.apache.mina.filter.codec.ProtocolCodecFilter - Processing a MESSAGE_RECEIVED for session 3
服务器接收到消息:{"name":"张三","cmd":1}
玩家:张三已准备
17:16:48.071 [NioProcessor-5] DEBUG org.apache.mina.filter.codec.ProtocolCodecFilter - Processing a MESSAGE_RECEIVED for session 4
服务器接收到消息:{"name":"李四","cmd":0}
玩家:李四进入房间
玩家:李四进入房间成功
17:16:48.073 [NioProcessor-5] DEBUG org.apache.mina.filter.codec.ProtocolCodecFilter - Processing a MESSAGE_RECEIVED for session 4
服务器接收到消息:{"name":"李四","cmd":1}
玩家:李四已准备
17:16:51.074 [NioProcessor-6] DEBUG org.apache.mina.filter.codec.ProtocolCodecFilter - Processing a MESSAGE_RECEIVED for session 5
服务器接收到消息:{"name":"孙五","cmd":0}
玩家:孙五进入房间
玩家:孙五进入房间成功
17:16:51.076 [NioProcessor-6] DEBUG org.apache.mina.filter.codec.ProtocolCodecFilter - Processing a MESSAGE_RECEIVED for session 5
服务器接收到消息:{"name":"孙五","cmd":1}
玩家:孙五已准备
17:16:54.078 [NioProcessor-7] DEBUG org.apache.mina.filter.codec.ProtocolCodecFilter - Processing a MESSAGE_RECEIVED for session 6
服务器接收到消息:{"name":"小六","cmd":0}
玩家:小六进入房间

客户端打印结果：

17:16:39.357 [NioProcessor-2] DEBUG org.apache.mina.filter.codec.ProtocolCodecFilter - Processing a MESSAGE_RECEIVED for session 1
玩家:赵一接收到消息:进入房间成功
17:16:42.064 [NioProcessor-16] DEBUG org.apache.mina.filter.codec.ProtocolCodecFilter - Processing a MESSAGE_RECEIVED for session 2
玩家:王二接收到消息:进入房间成功
17:16:45.067 [NioProcessor-30] DEBUG org.apache.mina.filter.codec.ProtocolCodecFilter - Processing a MESSAGE_RECEIVED for session 3
玩家:张三接收到消息:进入房间成功
17:16:48.072 [NioProcessor-44] DEBUG org.apache.mina.filter.codec.ProtocolCodecFilter - Processing a MESSAGE_RECEIVED for session 4
玩家:李四接收到消息:进入房间成功
17:16:51.075 [NioProcessor-58] DEBUG org.apache.mina.filter.codec.ProtocolCodecFilter - Processing a MESSAGE_RECEIVED for session 5
玩家:孙五接收到消息:进入房间成功
17:16:51.076 [NioProcessor-2] DEBUG org.apache.mina.filter.codec.ProtocolCodecFilter - Processing a MESSAGE_RECEIVED for session 1
17:16:51.076 [NioProcessor-16] DEBUG org.apache.mina.filter.codec.ProtocolCodecFilter - Processing a MESSAGE_RECEIVED for session 2
玩家:赵一接收到消息:游戏开始,欢迎进入王者荣耀
17:16:51.077 [NioProcessor-30] DEBUG org.apache.mina.filter.codec.ProtocolCodecFilter - Processing a MESSAGE_RECEIVED for session 3
玩家:王二接收到消息:游戏开始,欢迎进入王者荣耀
17:16:51.077 [NioProcessor-44] DEBUG org.apache.mina.filter.codec.ProtocolCodecFilter - Processing a MESSAGE_RECEIVED for session 4
玩家:张三接收到消息:游戏开始,欢迎进入王者荣耀
17:16:51.077 [NioProcessor-58] DEBUG org.apache.mina.filter.codec.ProtocolCodecFilter - Processing a MESSAGE_RECEIVED for session 5
玩家:李四接收到消息:游戏开始,欢迎进入王者荣耀
玩家:孙五接收到消息:游戏开始,欢迎进入王者荣耀
17:16:54.079 [NioProcessor-72] DEBUG org.apache.mina.filter.codec.ProtocolCodecFilter - Processing a MESSAGE_RECEIVED for session 6
玩家:小六接收到消息:房间已满,您进入房间失败

本案例主要模拟了王者荣耀开始游戏的场景，六个客户端分别和游戏服务器进行连接，连接成功就表示进入房间成功，连接成功之后服务器回复客户端进入房间成功，然后客户端再开始准备，准备完成之后服务器就回复正式进入游戏，而本案例模拟了6个客户端，当5个客户端准备了之后就进入了游戏，第六个房间提升进入房间失败。

五、MINA的线程模型

Java NIO的服务端一般线程模型为开启一个线程通过Selecotor监听客户端的连接请求和IO操作，只有有事件发生（连接请求和IO操作）就会立即去处理，这样的线程模型有一个弊端Selector对于客户端连接请求的channel和客户端IO操作的channel是用同一个Selector来监控的，如下图示

这样就会有一个问题，但IO操作比较耗时时就会导致连接请求的channel也会被阻塞，因为Selector是单线程同步处理所有IO事件的，如上图假设客户端A连接成功之后发送IO数据，Selector接收到IO数据之后开始处理，假设处理时间需要10秒，而在10秒之内客户端B通过ServerSocketChannel请求连接服务器，此时Selector还是处于处理IO事件的状态，只要客户端A的IO事件处理完成，才会继续执行select方法处理下一轮的IO事件。整个流程就好比Selector处理IO事件是一批一批的处理，处理完了第一批之后才会处理第二批的IO事件，如果第一批处理比较慢，就会影响到第二批，而第二批中很可能都是耗时比较短的OP_ACCEPT事件。所以为了让服务器在处理OP_READ事件时不会影响OP_ACCEPT事件，MINA在NIO的线程模型之上进行了优化，单独开启一个线程用于处理客户端的连接请求，而对于IO事件再由于IoProcessor线程去处理，而IoProcessor又可以创建多个，这就形成了一个Selector用于负责监听客户的连接请求，然后有多个Selector分别监听多个Channel的IO事件的线程模型，如下图示：

总结：

1、服务端创建IoAcceptor，开启单线程通过Selector用来监听所有客户端请求连接的OP_ACCEPT事件，连接成功之后将客户端封装成IoSession，将IoSession交给IoProcessor线程组

2、IoSession通过取模算法被分配给一个IoProcessor，IoProcessor通过Selector监听注册到此Selecotr上的所有IoSession的IO状态，当有IO事件发生时，进行IO数据的读写并将IO数据先通过IoFilterChain进行过滤，最后交给业务层IoHandler进行业务处理

  

后结：本文主要介绍来MINA的基本理论和实验案例，下一文将分析MINA的源码实现：NIO之路--MINA框架源码解析