前言
Apache的MINA框架是一个早年非常流行的NIO框架，它出自于Netty之父Trustin Lee大神之手。虽然目前市场份额已经逐渐被Netty取代了，但是其作为NIO初学者入门学习框架是非常合适的，因为MINA足够的简单，它的实现相对于Netty的难易程度，大概只有Netty的40%左右(个人在对比了MINA和Netty的底层实现得出的结论)；然而其在整体架构上的设计是非常类似的，因此在学习完MINA之后再去看Netty，也会相对简单一些。与此同时，一些老的系统在底层实现上也有很多使用了MINA来进行通信的，如果在接手后不懂其原理，也是很难去维护的。因此个人觉得还是有必要去花些时间去好好研究一下它！
MINA宏观架构
从宏观上面看，MINA作为应用程序与底层网络协议的中间桥梁，它所支持的底层协议包括TCP、UDP、in-VM、 RS-232C串口编程协议等。对于我们开发者而言，无论你是在编写客户端还是服务器端程序，我们都只需在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服务器端的架构组成。
细心的同学会发现，上面的图与之前的整体架构图对比起来看，其实真正变化的内容就是从I/O Service变成了I/O Acceptor。
MINA对I/O Service做了一个整体的抽象，在服务器端，因为是接收连接，因此是I/O Acceptor;而在客户端，因为是主动发起连接，因此就是I/O Connnector。但是无论IOAcceptor还是IOConnector，它们都继承了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.演示结果
客户端架构
在分析完服务器的结构之后，我们再来看一下客户端的结构。仔细看我们会发现，客户端结构与服务器端结构唯一的不同就在于，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等内容。
参考
http://mina.apache.org/mina-project/userguide/ch2-basics/ch2-basics.html
