4.NIO 基础知识
Java NIO(new IO)是JDK1.4引入的非阻塞IO机制，具体它如何的好，我就不说啦，百度一下看看就了解啦。
Java NIO引入了两个新的概念：通道Channel和选择器Selector。
通道是服务端和客户端进行通信的接口-----原来是直接的IO操作，客户端发信息给服务端，服务端从OutputStream中读取，然后向InputStream中写数据；现在则直接从Channel中读取或写入数据。
选择器是一个多路复用器：所有的通道向它注册事件，因此它管理了所有的通道信息，并轮询各个通道的状态，一旦某个通道某事件发生（比如有数据读或可以写入数据），则通知该管道对应事件的处理器去处理它。
如下图所示：
客户端连接上服务端后，首先每个客户端都要与服务端建立一个通道（SocketChannel）；然后每个通道向选择器(Selector)注册事件，注册器就会轮询查看每个通道是否有事件发生，一旦某通道有事件发生，比如Client1的SocketChannel有数据了，就触发了读就绪事件，可以进行读取的操作。
选择器(Selector)是个典型的反应器模式（Reactor Pattern），它的实现原理可以参考该文章：http://bijian1013.iteye.com/blog/2277792
先介绍下NIO的几个常用类：
（1）.Buffer 缓冲区
Java NIO的缓冲区Buffer基本和Mina的IoBuffer一样，但是准确的说，Mina的IoBuffer就是对Java NIO buffer的二次封装，使得它的功能更加强大。
数据输入和输出往往是比较耗时的操作。缓冲区从两个方面提高I/O操作的效率：
1).减少实际的物理读写次数
这一点比较容易理解，我们经常使用的缓冲数组就是这个道理：
public void ioRead(String filePath) throws IOException {
FileInputStream in = new FileInputStream(filePath);
byte[] b = new byte[1024];
int i = 0;
while ((i = in.read(b)) != -1) {
logger.info(new String(b, 0, i));
}
}
2).缓冲区在创建时被分配内存，这块内存区域一直被重用，这可以减少动态分配和回收内存区域的次数。
这一点是Buffer的优势，也是buffer性能较高的一个原因。
java.nio.Buffer类是一个抽象类，不能被实例化。共有8个具体的缓冲区类，其中最基本的缓冲区是ByteBuffer，它存放的数据单元是字节。ByteBuffer类并没有提供公开的构造方法，但是提供了两个获得ByteBuffer实例的静态工厂方法：
a.allocate(int capacity)：返回一个ByteBuffer对象，参数capacity指定缓冲区的容量。
b.directAllocate(int capacity): 返回一个ByteBuffer对象，参数capacity指定缓冲区的容量。该方法返回的缓冲区称为直接缓冲区，它与当前操作系统能够更好的耦合，因此能进一步提高I/O操作的速度。但是分配直接缓冲区的系统开销很大，因此只有在缓冲区较大并且长期存在，或者需要经常重用时，才使用这种缓冲区。
同样常用的是CharBuffer，使用基本和上面一样，所有不多说啦！其他实现类我也基本不怎么用。
常用的方法也不多做解释了，翻看API文档吧。
（2）.Charset 字符编码
Charset就是根据指定的编码个数进行编解码的一个接口，不多作解释。
a.Charset类的静态forName(String encode)方法返回一个Charset对象，它代表参数encode指定的编码类型。
b.ByteBuffer encode(String str)：对参数str指定的字符串进行编码，把得到的字节序列存放在一个ByteBuffer对象中，并将其返回。
c.ByteBuffer encode(CharBuffer cb)：对参数cb指定的字符缓冲区中的字符进行编码，把得到的字节序列存放在一个ByteBuffer对象中，并将其返回。
d.CharBuffer decode(ByteBuffer bb)：把参数bb指定的ByteBuffer中的字节序列进行解码，把得到的字符序列存放在一个CharBuffer对象中，并将其返回。
（3）.Channel 通道
通道在Java NIO的开始就做个解释，它是服务端和客户端进行通信的接口；通道Channel用来连接缓冲区与数据源或数据汇（即数据目的地）。如下图所示，数据源的数据经过通道到达缓冲区，缓冲区的数据经过通道到达数据汇。
但是在实际的开发中，我们基本都是使用Channel的实现类：ServerSocketChannel和SocketChannel，类图如下：
ServerSocketChannel从SelectableChannel中继承了configureBlocking()和register()方法。ServerSocketChannel是ServerSocket的替代类，也具有负责接收客户连接的accept()方法。
ServerSocketChannel并没有public类型的构造方法，必须通过它的静态方法open()来创建ServerSocketChannel对象。
每个ServerSocketChannel对象都与一个ServerSocket对象关联。ServerSocketChannel的socket()方法返回与它关联的ServerSocket对象。
private Selector selector; private int PORT = 3015; private ServerSocketChannel serverSocketChannel = null; // 创建一个Selector对象 selector = Selector.open(); // 创建一个ServerSocketChannel对象 serverSocketChannel = ServerSocketChannel.open(); // 使得在同一个主机上关闭了服务器程序，紧接着再启动该服务器程序时， // 可以顺利绑定到相同的端口 serverSocketChannel.socket().setReuseAddress(true); // 使ServerSocketChannel工作于非阻塞模式 serverSocketChannel.configureBlocking(false); serverSocketChannel.socket().bind(new InetSocketAddress(PORT));
SocketChannel可看作是Socket的替代类，但它比Socket具有更多的功能；SocketChannel不仅从SelectableChannel父类中继承了configureBlocking()和register()方法，而且实现了ByteChannel接口，因此具有用于读写数据的read(ByteBuffer dst)和write(ByteBuffer src)方法。
SocketChannel没有public类型的构造方法，必须通过它的静态方法open()来创建SocketChannel对象。
private String HOST = "127.0.0.1";
private int PORT = 3015;
private SocketChannel socketChannel = null;
// 创建一个SocketChannel对象
socketChannel = SocketChannel.open();
// 使SocketChannel工作于非阻塞模式
socketChannel.configureBlocking(false);
// InetAddress ia = InetAddress.getLocalHost();
// InetSocketAddress isa = new InetSocketAddress(ia, 3015);
InetSocketAddress isa = new InetSocketAddress(HOST, PORT);
socketChannel.connect(isa);
logger.info("与服务器建立连接成功....");
// 创建一个Selector对象
selector = Selector.open();
其他不多做解释了，请参看NIO的API。
（4）.Selector 选择器
选择器在Java NIO的开始就做个解释，它是一个多路复用器，所有的通道向它注册事件；只要ServerSocketChannel以及SocketChannel向Selector注册了特定的事件，Selector就会监控这些事件是否发生。
ServerSocketChannel以及SelectableChannel的register()方法负责注册事件，该方法返回一个SelectionKey对象，该对象是用于跟踪这些被注册事件的句柄。
在SelectionKey对象的有效期间，Selector会一直监控与SelectionKey对象相关的事件，如果事件发生，就会把SelectionKey对象加入到selected-keys集合中。
在以下情况，SelectionKey对象会失效，这意味着Selector再也不会监控与它相关的事件。
a.程序调用SelectionKey的cancel()方法；
b.关闭与SelectionKey关联的Channel；
c.与SelectionKey关联的Selector被关闭；
在SelectionKey中定义了四种事件，分别用4个int类型的常量来表示：
a.SelectionKey.OP_ACCEPT：接收连接就绪事件，表示服务器监听到了客户连接，服务器可以接收这个连接了，常量值为16。
b.SelectionKey.OP_CONNECT：连接就绪事件，表示客户与服务器的连接已经建立成功，常量值为8。
c.SelectionKey.OP_READ：读就绪事件，表示通道中已经有了可读数据，可以执行读操作了，常量值为1。
d.SelectionKey.OP_WRITE：写就绪事件，表示已经可以向通道写数据了，常量值为4。
最常用的就是后三种事件：连接就绪事件和读写就绪事件；下面就是它们的具体应用啦，请结合实例理解NIO的用法。
5.基于NIO的阻塞服务器
ServerSocketChannel与SocketChannel采用默认的阻塞模式，因此我们用NIO提供的API做一个阻塞服务器，和以前的阻塞服务器做个对比，以加深它们的区别；
服务端代码：
package com.bijian.study.mina.server;
import java.io.IOException;
import java.net.InetSocketAddress;
import java.nio.channels.ServerSocketChannel;
import java.nio.channels.SocketChannel;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import org.apache.log4j.Logger;
import com.bijian.study.mina.handler.Server05Handler;
/*
* 使用NIO的ServerSocketChannel创建阻塞的Socket服务端
* 使用JDK自带的线程池ExecutorService，多线程处理客户端请求
*/
public class EchoServer05 {
private Logger logger = Logger.getLogger(EchoServer05.class);
private int PORT = 3015;
private ServerSocketChannel serverSocketChannel = null;
private ExecutorService executorService; // 线程池
private static final int POOL_MULTIPLE = 4; // 单个CPU时线程池中的工作线程个数
public EchoServer05() throws IOException {
// 创建线程池
// Runtime的availableProcessors()方法返回当前系统的CPU格式
// 系统的CPU越多，线程池中工作线程的数目也越多
executorService = Executors.newFixedThreadPool(Runtime.getRuntime()
.availableProcessors()
* POOL_MULTIPLE);
// ServerSocketChannel并没有public类型的构造方法，
// 必须通过它的静态方法open()来创建ServerSocketChannel对象
// 默认是阻塞模式的，通过configureBlocking(false)设置为非阻塞模式
serverSocketChannel = ServerSocketChannel.open();
// 使得在同一个主机上关闭了服务器程序，紧接着再启动该服务器程序时，
// 可以顺利绑定到相同的端口
serverSocketChannel.socket().setReuseAddress(true);
// 每个ServerSocketChannel对象都与一个ServerSocket对象关联
// ServerSocketChannel的socket()方法返回与它关联的ServerSocket对象
serverSocketChannel.socket().bind(new InetSocketAddress(PORT));
logger.info("服务端启动.... 端口号：" + PORT);
}
public void service() {
while (true) { // 阻塞
SocketChannel socketChannel = null;
try {
socketChannel = serverSocketChannel.accept(); // 等待连接
// 多线程处理
executorService.execute(new Server05Handler(socketChannel));
} catch (IOException e) {
e.printStackTrace();
}
}
}
public static void main(String args[]) throws IOException {
new EchoServer05().service();
}
}
服务器端的业务处理代码：
package com.bijian.study.mina.handler;
import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStream;
import java.io.InputStreamReader;
import java.io.OutputStream;
import java.io.PrintWriter;
import java.net.Socket;
import java.nio.channels.SocketChannel;
import java.util.Date;
import org.apache.log4j.Logger;
public class Server05Handler implements Runnable {
private Logger logger = Logger.getLogger(Server05Handler.class);
private SocketChannel socketChannel;
public Server05Handler(SocketChannel socketChannel) {
this.socketChannel = socketChannel;
}
public void run() {
try {
Socket socket = socketChannel.socket();
logger.info("一个新的请求达到并创建 " + socket.getInetAddress() + ":" + socket.getPort());
InputStream socketIn = socket.getInputStream();
BufferedReader br = new BufferedReader(new InputStreamReader(socketIn));
OutputStream socketOut = socket.getOutputStream();
PrintWriter pw = new PrintWriter(socketOut, true);
String msg = null;
while ((msg = br.readLine()) != null) {
logger.info("服务端受到的信息为：" + msg);
pw.println(new Date()); // 给客户端响应日期字符串
if (msg.equals("bye"))
break;
}
} catch (IOException e) {
e.printStackTrace();
} finally {
try {
if (socketChannel != null)
socketChannel.close();
} catch (IOException e) {
e.printStackTrace();
}
}
}
}
客户端代码：
package com.bijian.study.mina.client;
import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStream;
import java.io.InputStreamReader;
import java.io.OutputStream;
import java.io.PrintWriter;
import java.net.InetSocketAddress;
import java.nio.channels.SocketChannel;
import org.apache.log4j.Logger;
/*
* 使用NIO的SocketChannel创建阻塞的客户端
*/
public class EchoClient05 {
private Logger logger = Logger.getLogger(EchoClient05.class);
private String HOST = "localhost";
private int PORT = 3015;
private SocketChannel socketChannel;
public EchoClient05() throws IOException {
socketChannel = SocketChannel.open();
// InetAddress ia = InetAddress.getLocalHost();
InetSocketAddress isa = new InetSocketAddress(HOST, PORT);
// socketChannel.connect()与远程主机建立连接
// 默认采用阻塞模式
socketChannel.connect(isa);
}
public void talk() throws IOException {
try {
// 通过socketChannel.socket()方法获得与SocketChannel关联的Socket对象，
// 然后从这个Socket中获得输出流与输入流，再一行行的发送和接受数据。
// 获得服务端响应信息的输入流
InputStream socketIn = socketChannel.socket().getInputStream();
BufferedReader br = new BufferedReader(new InputStreamReader(
socketIn));
// 给服务端发送信息的输出流
OutputStream socketOut = socketChannel.socket().getOutputStream();
PrintWriter pw = new PrintWriter(socketOut, true);
BufferedReader localReader = new BufferedReader(
new InputStreamReader(System.in));
String msg = null;
while ((msg = localReader.readLine()) != null) {
pw.println(msg);
logger.info(br.readLine());
if (msg.equals("bye"))
break;
}
} catch (IOException e) {
e.printStackTrace();
} finally {
try {
socketChannel.close();
} catch (IOException e) {
e.printStackTrace();
}
}
}
public static void main(String[] args) throws IOException {
new EchoClient05().talk();
}
}
启动服务端和客户端，测试，无疑是成功的！
是不是感觉很别扭呀，明明两个ServerSocket和Socket解决的问题，却创建了一大堆的对象。NIO编程刚开始的却是感觉不爽呀，不过慢慢就适应啦。但如果使用Mina框架，你会发现，根本不需要关心什么NIO，它已经给你封装好啦。
6.基于NIO的非阻塞服务器
待完善……
7.多线程的基于NIO的非阻塞服务器
NIO有效解决了多线程服务器存在的线程开销问题，但在使用上略显得复杂一些。许多基于 NIO 的多线程服务器程序往往直接基于选择器（Selector）的 Reactor 模式实现。这种简单的事件机制对于较复杂的服务器应用，显然缺乏扩展性和可维护性， 而且缺乏直观清晰的结构层次。
二.异步操作分析
待完善……
三.Mina内部实现分析
待完善……
四.Mina的线程模型配置
先看官方文档的描述：(这里我就纯粹翻译一下吧，注意Mina的线程模型配置是针对Mina2.0以前的版本而言的，使用2.0以后版本的可以跳过)
1.禁止缺省的ThreadModel设置
MINA2.0及以后版本已经没有ThreadModel了，如果使用这些版本的话，可以跳过本节。
ThreadModel设置是在MINA1.0以后引入的，但是使用ThreadModel增加了配置的复杂性，推荐禁止掉缺省的TheadModel配置。
IoAcceptor acceptor = new SocketAcceptor(); SocketAcceptorConfig cfg = new SocketAcceptorConfig(); cfg.setThreadModel(ThreadModel.MANUAL);// 禁止掉ThreadModel的缺省配置
2.配置I/O工作线程的数量
这节只是NIO实现相关的，NIO数据包以及虚拟机管道等的实现没有这个配置。
在MINA的NIO实现中，有三种I/O工作线程：
a.Acceptor线程：接受进入连接，并且转给I/O处理器线程来进行读写操作。每一个SocketAcceptor产生一个Acceptor线程，线程的数目不能配置。
b.Connector线程：尝试连接远程对等机，并且将成功的连接转给I/O处理器线程来进行读写操作。每一个SocketConnector产生一个Connector线程，这个的数目也不可以配置。
c.I/O处理器线程：执行实际上的读写操作直到连接关闭。每一个SocketAcceptor或SocketConnector都产生它们自己的I/O处理线程。这个数目可以配置，缺省是1。
因此，对于每个IoService，可以配置的就是I/O处理线程的数目。下面的代码产生一个有四个I/O处理线程的SocketAcceptor：
IoAcceptor acceptor = new SocketAcceptor(4,Executors.newCachedThreadPool());
没有单凭经验来决定I/O处理线程数目的方法，一般设置为当前服务器CPU个数+1:
IoAcceptor acceptor = new SocketAcceptor(Runtime.getRuntime().availableProcessors() + 1, Executors.newCachedThreadPool());
3.增加一个ExecutorFilter到IoFilterChain中
ExecutorFilter是一个IoFilter，用于将进入的I/O事件转到一个 java.util.concurrent.Executor实现。事件会从这个Executor转到下一个IoFilter，通常是一个线程池。可以在 IoFilterChain的任何地方增加任意数目的ExecutorFilter，实现任何类型的线程模型，从简单的线程池到复杂的SEDA。
到现在为止我们还没有增加ExecutorFilter，如果没有增加ExecutorFilter，事件会通过方法调用转到一个 IoHandler，这意味着在IoHandler实现中的业务逻辑会在I/O处理线程里运行。我们叫这种线程模型为"单线程模型"。单线程模型可以用来就会低反应网络应用程序，受CPU限制的业务逻辑（如，游戏服务器）。
典型的网络应用需要一个ExecutorFilter插入到IoFilterChain中，因为业务逻辑和I/O处理线程有不同的资源使用模式。如果你用IoHandler的实现来执行数据库操作，而没有增加一个ExecutorFilter的话，那么，你整个服务器会在执行数据库操作的时候锁定，特别是数据库性能低的时候。下面的例子配置一个IoService在一个新的IoSession建立时增加一个ExecutorFilter。
cfg.getFilterChain().addLast("threadPool",new ExecutorFilter(Executors.newCachedThreadPool()));
如果server关闭，则execute也需要关闭。
使用一个ExecutorFilter通常不意味着要用一个线程池，对于Executor的实现没有任何限制。
4.应该把ExecutorFilter放在IoFilterChain的什么地方
这个要根据于具体应用的情况来定。如果一个应用有一个ProtocolCodecFilter实现和一个常用的有数据库操作的IoHandler实现的话，那么就建议在ProtocolCodecFilter实现的后面增加一个ExecutorFilter，这是因为大部分的协议解码实现的性能特性是受CPU限制的，和I/O处理线程是一样的。
// Add CPU-bound job first
cfg.getFilterChain().addLast(
"codec",
new ProtocolCodecFilter(new VamsCodecFactory(Charset.forName("utf-8"), true)));
// and then a thread pool
cfg.getFilterChain().addLast("threadPool",new ExecutorFilter(Executors.newCachedThreadPool()));
5.选择IoService的线程池类型时要小心
Executors.newCachedThreadPool()经常是IoService首选的。因为如果使用其它类型的话，可能会对 IoService产生不可预知的性能方面的影响。一旦池中的所有线程都在使用中，IoService会在向池尝试请求一个线程时开始锁定，然后会出现一个奇怪的性能下降，这有时是很难跟踪的。
6.不推荐IoServices和ExecutorFilters共享一个线程池
你可以想让IoServices和ExecutorFilters共享一个线程池，而不是一家一个。这个是不禁止的，但是会出现很多问题，在这种情况下，除非你为IoServices建立一个缓冲线程池。
PS：Socket编程俗称Java网络编程，是Java Web开发的精髓！做J2EE的人可能很少关心多线程，NIO等等这些东西，但是不可否认它却实时与我们打交道，比如常用的web容器Tomcat。
Mina解析完整代码见附件MinaDemo05.rar。
相关推荐
Mina 2.0快速入门与源码解析 很适合初学者使用!!!
Mina源码解析 ,有兴趣的下载看一下，很不错的。
写这篇文档主要是想对刚接触Mina的人讲解一些Mina的基本知识，由浅入深，一步一步的学习Mina思想的精髓。这里只是简单的涉及一点，不会对其做很深入的探讨。但是Mina的服务器和客户端在很大的程度上都是一样，所以...
详细介绍mina框架的各个组成部分、服务器端的开发、客户端开发。并根据本人在工程项目中使用的代码，详细讲解了服务器端是客户端实现。实现了json格式的通信、以及文件的上传于下载等功能。图文并茂，以开发者的角度...
解决中文乱码问题，保持Socket稳定可靠连接,Android Studio工程
ftpserver mina框架，适合初学。
NULL 博文链接：https://sziitjiang.iteye.com/blog/1646625
望大家不吝批评指教，本人常年从事JAVA软件开发，有丰富的MINA通信软件开发经验，现在已经有成熟的底层框架（结合了反射、DynaBean、Spring等多种技术），可以实现程序自动对上位机和下位机之间的通信协议进行解析，...
LocationServiceLocationService Spring+hibernate+mina 解析设备数据并存放到数据库
MINA使用详解，MINA的工作流程，及搭建一个实例！
mina学习文档,包括入门、基础、解析、实例
Android中的JSON详细总结
这个框架协议自己定义（即：底层已有字符串传输或Object传输，自己可以定义字符串会对象进行解析来制定自己的协议） 语音、图片等其实也是上传文件服务器再连个即时通信字符串通信而已； 注意：SSH-lib里有注意...
基于mina架构的JTT808协议演示版本程序，网关采用mina+spring+MQ/redis架构,简单配置application.properties中的 MQ:jms.brokerurl=tcp://127.0.0.1:61616； 终端连接对应的端口：3005， 点击bin/目录下面的bin/...
交通部809协议源码（java开发，基于apache-mina框架）。未全部实现功能，仅实现server端主链路，从链路未做，默认链路不加密，可满足常规接入实时车辆GPS定位等功能，需实现更多业务逻辑请自行丰富MsgCallBack类。 ...
我在工作中是这么学过来的，下了很多demo，一个个自己解析搞定， 所以集合了下，有兴趣的可以参考下
dhcp4j 是一款纯 Java 的 DHCP 解析器，协议管理器和服务器，用来处理 PXE 选项，供应商扩展和完成 IANA 数据库的移植硬件类型。它还拥有网络驱动，是用 Mina 和 Netty 构建的。 标签：dhcp4j
场景: 在一些nio的网络框架, 比如netty, mina等, 读取数据时异步的, 也就是不能通过InputStream.read来以阻塞的方式读取数据. 而大多数json的库, 如FastJSON, jackson等都只能解析一个阻塞式的InputStream. 在nio...
1、网关应用采用mina+spring+ehcache框架，主要功能是接受终端的tcp/udp链接，解析终端的上行消息以及封装平台下发的下行消息，本网关应用已历经并通过多次交通部部标部标的检测，性能稳定；同时网关采用json消息与...