【MINA学习笔记】—— 1.体系结构分析[z] - 懒懒的呐喊

公告

前言

Apache的MINA框架是一个早年非常流行的NIO框架，它出自于Netty之父Trustin Lee大神之手。虽然目前市场份额已经逐渐被Netty取代了，但是其作为NIO初学者入门学习框架是非常合适的，因为MINA足够的简单，它的实现相对于Netty的难易程度，大概只有Netty的40%左右(个人在对比了MINA和Netty的底层实现得出的结论)；然而其在整体架构上的设计是非常类似的，因此在学习完MINA之后再去看Netty，也会相对简单一些。与此同时，一些老的系统在底层实现上也有很多使用了MINA来进行通信的，如果在接手后不懂其原理，也是很难去维护的。因此个人觉得还是有必要去花些时间去好好研究一下它！

MINA宏观架构

MINA宏观的体系结构

从宏观上面看，MINA作为应用程序与底层网络协议的中间桥梁，它所支持的底层协议包括TCP、UDP、in-VM、 RS-232C串口编程协议等。对于我们开发者而言，无论你是在编写客户端还是服务器端程序，我们都只需在MINA之上设计你的应用本身即可，而无需关注底层网络层协议的复杂处理。

MINA中的组件

上面我们从宏观的角度看完了MINA的整体结构，下面让我们MINA中的组件做一个剖析。

MINA中的组件

从上面的图中，我们可以看到，从广义的划分方式来说，一个基于MINA的应用，无论是服务端还是客户端，它都一共分为三个部分：

I/O Service：负责端口绑定、接受网络连接或者是主动发起网络连接、网络IO读写、生成对应的IOSession(IOSession是MINA对底层网络连接的一个封装)等功能。
I/O Filter Chain：数据过滤、数据报文的编解码、黑白名单过滤等等。
I/O Handler：执行真正的业务逻辑。

所以，如果我们想要创建一个基于MINA的网络应用程序，其实只需要3步：

创建I/O Service,通常直接使用MINA内置的IO Service即可。
创建一个Filter Chain,MINA也内置了大量Filter Chain的实现，在某些特殊情况下需要自定义IoFilter，比如实现自定义协议的编解码功能。
创建I/O Handler,编写我们真正的业务逻辑，处理不同的消息。

MINA服务器端架构

上面我们已经分析了MINA的整体架构，下面对其再细分一下，我们一起来看一下MINA服务器端的架构组成。

MINA服务器端架构

细心的同学会发现，上面的图与之前的整体架构图对比起来看，其实真正变化的内容就是从I/O Service变成了I/O Acceptor。

MINA对I/O Service做了一个整体的抽象，在服务器端，因为是接收连接，因此是I/O Acceptor;而在客户端，因为是主动发起连接，因此就是I/O Connnector。但是无论IOAcceptor还是IOConnector，它们都继承了IOService这个接口。

IOService的结构图

MINA服务器示例

好了，说了这么多，下面搞个MINA服务端的例子来感受一下，我们使用的MINA版本是2.0.16，JDK的版本为1.8。

1.添加maven的pom依赖

  <properties>
        <mina.version>2.0.16</mina.version>
        <logback.version>1.2.3</logback.version>
        <java.version>1.8</java.version>
    </properties>


    <dependencyManagement>
        <dependencies>
            <!-- https://mvnrepository.com/artifact/org.apache.mina/mina-core -->
            <dependency>
                <groupId>org.apache.mina</groupId>
                <artifactId>mina-core</artifactId>
                <version>${mina.version}</version>
              <!--Mina自带会引入SLF4J包-->
                <exclusions>
                    <exclusion>
                        <groupId>org.slf4j</groupId>
                        <artifactId>slf4j-api</artifactId>
                    </exclusion>
                </exclusions>
            </dependency>

            <!--使用Logback作为日志系统，自带会引入SLF4J-->
            <dependency>
                <groupId>ch.qos.logback</groupId>
                <artifactId>logback-classic</artifactId>
                <version>${logback.version}</version>
            </dependency>

        </dependencies>
    </dependencyManagement>

    <dependencies>

        <dependency>
            <groupId>org.apache.mina</groupId>
            <artifactId>mina-core</artifactId>
        </dependency>

        <dependency>
            <groupId>ch.qos.logback</groupId>
            <artifactId>logback-classic</artifactId>
        </dependency>

    </dependencies>


    <build>
        <plugins>
            <plugin>
                <groupId>org.apache.maven.plugins</groupId>
                <artifactId>maven-compiler-plugin</artifactId>
                <version>3.6.2</version>
                <configuration>
                    <source>${java.version}</source>
                    <target>${java.version}</target>
                </configuration>
            </plugin>
        </plugins>
    </build>

MINA自带就会使用SLF4J作为其日志框架，但是其引入的版本是1.7.21，而我们使用Logback也会自动引入SLF4J的包，其使用的版本是1.7.25。我们这里排除掉MINA自动引入的版本，使用1.7.25的SLF4J-API包。

2.编写Server端主程序

package com.panlingxiao.mina.quickstart;

import org.apache.mina.core.service.IoAcceptor;
import org.apache.mina.core.service.IoService;
import org.apache.mina.core.service.IoServiceListener;
import org.apache.mina.core.session.IdleStatus;
import org.apache.mina.core.session.IoSession;
import org.apache.mina.filter.codec.ProtocolCodecFilter;
import org.apache.mina.filter.codec.textline.TextLineCodecFactory;
import org.apache.mina.filter.logging.LoggingFilter;
import org.apache.mina.transport.socket.nio.NioSocketAcceptor;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;

import java.io.IOException;
import java.net.InetSocketAddress;
import java.net.SocketAddress;
import java.nio.charset.Charset;
import java.util.concurrent.TimeUnit;

/**
 * Created by panlingxiao on 2017/8/13.
 * 基于Mina的时间服务器
 */
public class MinaTimeServer {


    private static final int PORT = 9123;

    private static final Logger logger = LoggerFactory.getLogger(MinaTimeServer.class);


    public static void main(String[] args) throws Exception {

        IoAcceptor acceptor = new NioSocketAcceptor();  // 1
        //添加日志处理器 2.
        acceptor.getFilterChain().addLast("logger", new LoggingFilter());
        //添加编解码处理器,读取一行数据作为一个报文
        acceptor.getFilterChain().addLast("codec", new ProtocolCodecFilter(new TextLineCodecFactory(Charset.forName("UTF-8"))));
        //3.设置IoHandler
        acceptor.setHandler(new TimeServerHandler());
      
       //4.配置IoSession的属性
        acceptor.getSessionConfig().setReadBufferSize(2048);
        acceptor.getSessionConfig().setIdleTime(IdleStatus.BOTH_IDLE, 10);

        //5.在端口绑定前添加IOServiceListener,否则事件无法监听到
        acceptor.addListener(new IoServiceListener() {
            @Override
            public void serviceActivated(IoService service) throws Exception {
                logger.info("{} active", service);
            }

            @Override
            public void serviceIdle(IoService service, IdleStatus idleStatus) throws Exception {

            }

            @Override
            public void serviceDeactivated(IoService service) throws Exception {

            }

            @Override
            public void sessionCreated(IoSession session) throws Exception {
                logger.info("{} create session,session:{}", session);
            }

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

            }

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

            }
        });

        //6.如果不指定端口，则由OS随机分配一个可用端口
        //acceptor.bind();
        acceptor.bind(new InetSocketAddress(PORT));
    }
}

首选我们创建了一个IOAcceptor，它用于监听网络端口，等待进来的连接，以及客户端发送过来的报文。对于一个新的连接，一个新的Session会被创建。Session是MINA对客户端连接的一个封装实现，不让用户直接去处理JDK原生的SocketChannel。
设置了两个IoFilter，第一个是用于日志记录，每当有接受到连接或者读取到数据，都将日志输出。第二个是用于数据的编解码，以一行数据作为一个报文的形式，将读取的数据解码成一个字符串，同时也将输出的字符串转换成对应的ByteBuffer输出。
设置IoHandler，它的作用就是用于处理具体的业务逻辑的。这里的业务逻辑非常简单，就是将当前的日期向客户端输出。
通过IoSessionConfig设置IoSession的属性，setReadBufferSize(2048)表示每一次读取最大的字节数为2048个字节，setIdleTime(IdleStatus.BOTH_IDLE, 10)表示设置一个网络连接在10秒之内都没有读写，则认为是一次闲置。后面可以统计到一个连接出现了多少次闲置，业务上可以根据闲置的次数，当其达到最大值时，将连接断开，从而降低不必要的资源开销。
添加IoServiceListener去监听当前IoAcceptor所发生的事件。在Server端，如果当端口绑定成功之后，IoAcceptor就会处于active状态，此时IoServiceListener的serviceActivated就会得到通知。
最后，我们通过指定服务器端的端口，让IoAcceptor监听给定的端口。

3.编写IoHandler

package com.panlingxiao.mina.quickstart;

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

import java.util.Date;

/**
 * Created by panlingxiao on 2017/8/13.
 */
public class TimeServerHandler extends IoHandlerAdapter {

   private static final Logger logger = LoggerFactory.getLogger(TimeServerHandler.class);

    //1
    @Override
    public void exceptionCaught(IoSession session, Throwable cause) throws Exception {
        cause.printStackTrace();
    }
  
    //2
    @Override
    public void sessionIdle(IoSession session, IdleStatus status) throws Exception {
       logger.info("IDLE " + session.getIdleCount(status));
    }
  
    //3
    @Override
    public void messageReceived(IoSession session, Object message) throws Exception {
        String str = message.toString();
        if (str.trim().equalsIgnoreCase("quit")) {
            session.closeNow().addListener(future -> {
             logger.info("Session Close");
          });
            return;
        }

        Date date = new Date();
        //通过添加IOFutureListener,回调得到结果
        session.write(date.toString()).addListener((ioFuture) -> {
            if (ioFuture.isDone()) {
                logger.info("Message written...");
            }
        });

    }
}

在这里，我们并没有直接去实现IoHandler接口，而是去继承IoHandlerAdapter。这里使用了一个典型的适配器模式，通过在IoHandlerAdapter中去重写需要的方法。下面我们看一下这几个重写的方法：

exceptionCaught方法见名知意，当在执行处理过程中发生异常时会得到调用。这里的异常包括由网络引起的IOExcetpion，或者是由于IoHandler处理业务逻辑而引起的异常等，都会调用该方法来处理。这里我们只是简单地将异常输出而已，在实际的开发中，我们可以根据自己的业务，向另外一方影响一个错误处理的消息。
当连接在指定时间内没有发生网络读写时，IoService就将该连接的Idle次数加1。此时sessionIdle方法就会得到调用。该方法只针对面向连接的协议有效，如果我们使用UDP这种无连接的传输模式时，该方法就不会被执行。
最后我们完成当接受到消息的处理。由于前面已经经过IoFilter对数据的解码处理，因此我们接受到的数据就是一个String类型。如果我们接受到的数据是一个quit,那么服务器端则主动关闭连接；否则的话，我们将当前时间返回给客户端。需要注意的是，MINA与Netty一样，都是一个异步处理的框架，因此我们在处理一个操作的时候，建议通过添加IoFutureListener的方式来获取执行的返回结果。

4.演示结果

Server端日志

通过telnet连接

客户端架构

在分析完服务器的结构之后，我们再来看一下客户端的结构。仔细看我们会发现，客户端结构与服务器端结构唯一的不同就在于，IOAcceptor被换成了IOConnector。

客户端代码示例

package com.panlingxiao.mina.quickstart.client;

import org.apache.mina.core.service.IoConnector;
import org.apache.mina.core.service.IoService;
import org.apache.mina.core.service.IoServiceListener;
import org.apache.mina.core.session.IdleStatus;
import org.apache.mina.core.session.IoSession;
import org.apache.mina.filter.codec.ProtocolCodecFilter;
import org.apache.mina.filter.codec.textline.TextLineCodecFactory;
import org.apache.mina.filter.logging.LoggingFilter;
import org.apache.mina.transport.socket.nio.NioSocketConnector;

import java.net.InetSocketAddress;
import java.nio.charset.Charset;

/**
 * Created by panlingxiao on 2017/8/28.
 */
public class MinaTimeClient {

    public static void main(String[] args) throws Throwable {
        //创建IOConnector，用于完成与服务器建立连接
        IoConnector connector = new NioSocketConnector();
        //添加IoFilter
        connector.getFilterChain().addLast("logger", new LoggingFilter());
        connector.getFilterChain().addLast("codec", new ProtocolCodecFilter(new TextLineCodecFactory(Charset.forName("UTF-8"))));
        //设置IoHandler
        connector.setHandler(new TimeClientHandler());

        //添加监听器，获取IOConnector的事件通知
        connector.addListener(new IoServiceListener() {
            @Override
            public void serviceActivated(IoService service) throws Exception {

            }

            @Override
            public void serviceIdle(IoService service, IdleStatus idleStatus) throws Exception {

            }

            @Override
            public void serviceDeactivated(IoService service) throws Exception {

            }

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

            }

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

            }

            @Override
            public void sessionDestroyed(IoSession session) throws Exception {
                //当关闭完成session销毁之后，将IOConnector资源释放
                connector.dispose();
            }
        });

        //连接服务器
        connector.connect(new InetSocketAddress(9123));
    }
}

package com.panlingxiao.mina.quickstart.client;

import org.apache.mina.core.service.IoHandlerAdapter;
import org.apache.mina.core.session.IoSession;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;

/**
 * Created by panlingxiao on 2017/8/28.
 */
public class TimeClientHandler extends IoHandlerAdapter {
    private static final Logger logger = LoggerFactory.getLogger(TimeClientHandler.class);

    private int counter = 0;

    private int num = 100;

    @Override
    public void exceptionCaught(IoSession session, Throwable cause) throws Exception {
        super.exceptionCaught(session, cause);
    }

    @Override
    public void sessionOpened(IoSession session) throws Exception {
        //当连接建立之后，客户端主动向服务器发送100条消息
        for (int i = 0; i < num; i++) {
            session.write("hello:" + i);
        }
    }

    @Override
    public void messageReceived(IoSession session, Object message) throws Exception {
        counter++;
        logger.info("receive message:{},counter:{}", message, counter);
          //当客户端接受到100条消息后，主动断开连接
        if(num == counter){
            session.closeNow();
        }
    }
}

客户端运行结果

总结

至此，我们已经学习完了MINA的整体结构以及它的组成部分。在后面会开始分析NIOSocketAcceptor的实现，分析端口的绑定过程、网络数据的读写过程、Session的创建过程、以及一个网络事件是如果通过IoFilter一层层地传递到IoHandler等内容。

链接：https://www.jianshu.com/p/5d47e56f89de

posted on 2018-12-26 15:20 懒懒的呐喊阅读(283) 评论(0) 编辑收藏举报

刷新页面返回顶部