一,mina的架构
mina 架构可以大致分为三部分，ioService ,ioFilterChain , IoHandler
ioService:用于接受服务或者连接服务，例如socket 接收器，连接器。
ioFilterChain:对接受的数据或发送的数据进行处理，例如接收到的字节数组转化成字符串，打日志等。
ioHandler:业务处理类，我们自己写的业务逻辑，例如对接受到的数据进行怎么样的数据，需要返回什么数据。
二,聊天室代码。
下面看下mina-2.0.9中聊天室例子。聊天室服务器的代码：
public static void main(String[] args) throws Exception {
NioSocketAcceptor acceptor = new NioSocketAcceptor();//创建接收器，用于接受socket连接。
DefaultIoFilterChainBuilder chain = acceptor.getFilterChain();//获取filterChain
MdcInjectionFilter mdcInjectionFilter = new MdcInjectionFilter();//获取mdc inject filter
chain.addLast("mdc", mdcInjectionFilter);//设置filterChain 链中最好一个过滤器为mdcInjectionFilter
// Add SSL filter if SSL is enabled.
if (USE_SSL) {
addSSLSupport(chain);
}
chain.addLast("codec", new ProtocolCodecFilter(
new TextLineCodecFactory()));//字节组和字符串转换 filter
addLogger(chain); //日志 filter
// Bind
acceptor.setHandler(new ChatProtocolHandler()); //设置接受的信息的业务处理类
acceptor.bind(new InetSocketAddress(PORT));//绑定端口
System.out.println("Listening on port " + PORT);
} 然后看下ChatProtocolHandler ，该类是继承了IoHandlerAdapter类，看下具体实现逻辑的方法，简化了大部分代码。
@Override
public void messageReceived(IoSession session, Object message) {
String theMessage = (String) message;//接受得来的字符串
session.write("LOGIN OK");//返回登录成功，
} 上面代码出现了一个session的概念，这个session的概念在mina中是比较重要的，下面来看下，mina在底层帮我们做了哪些事情。
主要是看下
NioSocketAcceptor acceptor = new NioSocketAcceptor();//创建接收器，用于接受socket连接。
acceptor.bind(new InetSocketAddress(PORT));//绑定端口 这两行代码背后mina都做了哪些事情。
先看下下面这行代码初始化的时候，都初始化了哪些属性，下图的属性是初始化中比较关键的。
三，接受新连接
NioSocketAcceptor acceptor = new NioSocketAcceptor();//创建接收器，用于接受socket连接。 NioSocketAcceptor的继承图如下，属性只列出了相对重要的属性。
1.初始化sessionConfig的实现是 DefaultSocketSessionConfig()，里面配置了一些参数用于后续创建session.
2.初始化executor,
executor = Executors.newCachedThreadPool();
newCachedThreadPool线程池的用法如下：
“创建一个可根据需要创建新线程的线程池，但是在以前构造的线程可用时将重用它们。对于执行很多短期异步任务的程序而言，这些线程池通常可提高程序性能。调用 execute 将重用以前构造的线程（如果线程可用）。如果现有线程没有可用的，则创建一个新线程并添加到池中。终止并从缓存中移除那些已有 60 秒钟未被使用的线程。因此，长时间保持空闲的线程池不会使用任何资源。注意，可以使用 ThreadPoolExecutor 构造方法创建具有类似属性但细节不同（例如超时参数）的线程池。 ”
3.初始化processor,创建了下面这个对象。
new SimpleIoProcessorPool<S>( NioProcessor.class)，该对象有两个比较关键的属性，分别是executor和pool。executor和上面一样是一个Executors.newCachedThreadPool（），pool为一个NioProcessor的数组。NioProcessor如下，也有两个关键属性，selector选择器和executor线程池（newCachedThreadPool）。
看下这行代码背后都做了哪些东西。
acceptor.bind(new InetSocketAddress(PORT));//绑定端口
1.这块代码主要做的事情就是启动了一个线程，用户监听连接。
主要的runnable为AbstractPollingIoAcceptor.Acceptor
Acceptor中会调用NioSocketAcceptor.open方法，在open方法中，我们能看到熟悉的创建接收器的代码。简化代码如下：
protected ServerSocketChannel open(SocketAddress localAddress) throws Exception {
// Creates the listening ServerSocket
ServerSocketChannel channel = null;
if (selectorProvider != null) {
channel = selectorProvider.openServerSocketChannel();
} else {
channel = ServerSocketChannel.open();//创建一个ServerSocketChannel对象
}
// This is a non blocking socket channel
channel.configureBlocking(false);//设定管道为非阻塞
// Configure the server socket,
ServerSocket socket = channel.socket();//获取管道中关联的ServerSocket
// Set the reuseAddress flag accordingly with the setting
socket.setReuseAddress(isReuseAddress());
// and bind.
socket.bind(localAddress, getBacklog());//绑定地址
...
// Register the channel within the selector for ACCEPT event
channel.register(selector, SelectionKey.OP_ACCEPT);//管道注册到选择器，监听socket的接受事件，该selector为NioSocketAcceptor的属性
....
return channel;
} 看下Acceptor的run方法,同样可以看到熟悉的selector代码:
private class Acceptor implements Runnable {
public void run() {
assert (acceptorRef.get() == this);
int nHandles = 0;
// Release the lock
lock.release();
while (selectable) {
try {
// Detect if we have some keys ready to be processed
// The select() will be woke up if some new connection
// have occurred, or if the selector has been explicitly
// woke up
int selected = select();//第一次访问到这个地方的时候，会在AbstractPollingIoAcceptor. bindInternal()中的wakeUp()方法中会被打断，直接执行下面registerHandles的初始化。
// this actually sets the selector to OP_ACCEPT,
// and binds to the port on which this class will
// listen on
nHandles += registerHandles();//主要是执行上面的open方法。
// Now, if the number of registred handles is 0, we can
// quit the loop: we don't have any socket listening
// for incoming connection.
if (nHandles == 0) {
.....
}
if (selected > 0) {//如果有新连接进来
// We have some connection request, let's process
// them here.
processHandles(selectedHandles());
}
// check to see if any cancellation request has been made.
nHandles -= unregisterHandles();
} .....
// Cleanup all the processors, and shutdown the acceptor.
if (selectable && isDisposing()) {
selectable = false;
......
}}} 然后看下下面这段代码背后都做了哪些事情。
if (selected > 0) {//如果有新连接进来
// We have some connection request, let's process
// them here.
processHandles(selectedHandles());
} selectedHandles()方法中主要是获取当前selector中已经就绪的selectedKey 的集合，具体的方法如下：
@Override
protected Iterator<ServerSocketChannel> selectedHandles() {
return new ServerSocketChannelIterator(selector.selectedKeys());
} processHandles的的方法如下：
private void processHandles(Iterator<H> handles) throws Exception {
while (handles.hasNext()) {
H handle = handles.next();
handles.remove();
// Associates a new created connection to a processor,
// and get back a session
S session = accept(processor, handle);//生成一个NioSocketSession
if (session == null) {
continue;
}
initSession(session, null, null);//对session中的部分attribute和writeRequestQueue等进行默认的初始化。
// add the session to the SocketIoProcessor
session.getProcessor().add(session);
}
} 看一下accept方法
@Override
protected NioSession accept(IoProcessor<NioSession> processor, ServerSocketChannel handle) throws Exception {
SelectionKey key = null;
if (handle != null) {
key = handle.keyFor(selector);//
}
if ((key == null) || (!key.isValid()) || (!key.isAcceptable())) {
return null;
}
// accept the connection from the client
SocketChannel ch = handle.accept();//接受一个新连接
if (ch == null) {
return null;
}
return new NioSocketSession(this, processor, ch);
} new NioSocketSession(this, processor, ch)中有几个主要的操作：
this.service = service;//设置当前当前session关联的IoService在这里是NioSocketAcceptor
this.handler = service.getHandler();//设置当前session关联的handler，在这里对应的是new ChatProtocolHandler()
sessionId = idGenerator.incrementAndGet();//获取唯一的sessionId
this.channel = channel;//设置当前的Channel，这里为新进来的socket连接对应的SocketChannel
this.processor = processor;//设置当前IoProcessor<NioSession> processor ，这里设为AbstractPollingIoAcceptor.processor 也就是上面初始化的SimpleIoProcessorPool（..）
filterChain = new DefaultIoFilterChain(this);//初始化默认的filterChain
this.config.setAll(service.getSessionConfig());//设置SessionCofig 为NioSocketAcceptor.getSessionConfig(); NioSocketSession的继承图如下：属性只列出了关键的属性。
再看下
initSession(session, null, null);//对session中的部分attribute和writeRequestQueue等进行默认的初始化。
最后是：
session.getProcessor().add(session);
session.getProcessor()获取刚才初始化processor，SimpleIoProcessorPool 的一个对象
在看下SimpleIoProcessorPool的add(Session session)方法：
public final void add(S session) {
getProcessor(session).add(session);//toread
} getProcessor(session) 中首先会在SimpleIoProcessorPool.pool中去取一个IoProcessor<S> 的实例，这里是NioProcessor实例，然后session和这个NioProcessor的实例关联起来。简化代码如下：
IoProcessor<S> processor = pool[Math.abs((int) session.getId()) % pool.length];
session.setAttributeIfAbsent(PROCESSOR, processor); 然后再看下NioProcessor.add(Session session)方法，其实是执行了NioProcessor的父类AbstractPollingIoProcessor的add方法。
该add方法，首先是在Queue<S> newSessions这个队列中增加了上面传进来的session,然后启动了一个新的线程AbstractPollingIoProcessor的内部类 Processor。简化的run方法如下：
private class Processor implements Runnable {
public void run() {
int selected = select(SELECT_TIMEOUT);//获取当前是否有新的请求进来。
nSessions += handleNewSessions();
if (selected > 0) {
//LOG.debug("Processing ..."); // This log hurts one of the MDCFilter test...
process();
}
flush(currentTime);//如果有session有写请求在这里面处理
｝
｝ hanldeNewSession()中对刚才在
Queue<S> newSessions
增加的新session进行初始化操作，首先是：NioProcessor中的初始化方法：
@Override
protected void init(NioSession session) throws Exception {
SelectableChannel ch = (SelectableChannel) session.getChannel();//获取session关联的SocketChannel
ch.configureBlocking(false);//设置为非阻塞
session.setSelectionKey(ch.register(selector, SelectionKey.OP_READ, session));//把socketChannel注册到NioProcessor的selector中，并且监听的时间为OP_READ,可读事件。
} 然后是初始session的filterChain,初始化为session关联的IoService的FilterChainBuilder，这里就是我们一开始初始化NioSocketAcceptor的filterChain
代码如下：
// Build the filter chain of this session.
IoFilterChainBuilder chainBuilder = session.getService().getFilterChainBuilder();
chainBuilder.buildFilterChain(session.getFilterChain()); 四，处理请求
然后执行下面的代码，如果当前NioProcessor.selector有可读的channel的话，执行process()方法
if (selected > 0) {
//LOG.debug("Processing ..."); // This log hurts one of the MDCFilter test...
process();
} process()方法就是真正处理数据和执行业务逻辑的地方了。首先会调用filterChain然后执行设定的handler.
process(）方法中主要是read()方法，该方法主要是读取socket中的数据，并且执行filterChain和handler 简化的代码如下：
private void read(S session) {
IoSessionConfig config = session.getConfig();
int bufferSize = config.getReadBufferSize();
IoBuffer buf = IoBuffer.allocate(bufferSize);
final boolean hasFragmentation = session.getTransportMetadata().hasFragmentation();
try {
int readBytes = 0;
int ret;
try {
if (hasFragmentation) {
while ((ret = read(session, buf)) > 0) {//读取数据
readBytes += ret;
if (!buf.hasRemaining()) {
break;
}
}
} else {
ret = read(session, buf);
if (ret > 0) {
readBytes = ret;
}
}
} finally {
buf.flip();
}
if (readBytes > 0) {
IoFilterChain filterChain = session.getFilterChain();//获取filterChain
filterChain.fireMessageReceived(buf);//执行filterChain中的messageReceived事件。
buf = null;
IoFilterChain filterChain = session.getFilterChain();
filterChain.fireExceptionCaught(e);
}
} session如有写的请求的话，先把请求封装成WriteRequest，最后把结果存在session.writeRequestQueue中，待执行flush方法的时候，才真正的把数据写进去。
写操作具体的代码在AbstractPollingIoProcessor的flushNow里，最终写操作是在NioProcessor的write方法中完成的
NioProcessor. write如下代码 , 就是主要就是Channnel的write方法了：
@Override
protected int write(NioSession session, IoBuffer buf, int length) throws Exception {
if (buf.remaining() <= length) {
return session.getChannel().write(buf.buf());
}
int oldLimit = buf.limit();
buf.limit(buf.position() + length);
try {
return session.getChannel().write(buf.buf());
} finally {
buf.limit(oldLimit);
}
} 五，概括
最后来看下mina中IoService,IoSession,IoProcessor,IoFilterChain,Handler之间的关系。还是以上面聊天室的为例,从服务器开始监听端口，到有第一个请求进来，流程如下。
1.NioSocketAcceptor 会启动一个线程用于接受socket连接,另外还会创建一个NioProcessor池.在新建NioSocketAcceptor之后需要设置IoFilterChain和Handler,Handler就是具体的业务处理逻辑。
2.当有一个新的连接进来的时候，会创建一个NioSocketSession，这个session会和新创建的socketChannel关联起来.
3.在NioProcessor池中取出一个NioProcessor来处理该session.
4.session关联IoFilterChain,当有Channel有读写事件的时候都需要经过FilterChain,FilterChain中根据不同的事件，例如接受消息，写事件，发送事件都有特定的方法。
5.NioProcessor中会启动一个线程用于监听该socketChannel是否有新消息进来，sochetChannel在selector中注册了OP_READ这个事件。NioProcessor中主要就是处理socketChannel中发生的各种事件，包括读写操作。
end~