mina架构

本文以mina 2.0.7为基础，记录mina nio网络接口的内部结构及消息流。

Java代码  

1. public static void main(String[] args) {    
2.       SocketAcceptor acceptor = new NioSocketAcceptor();    
3.       acceptor.getFilterChain().addLast(    
4.               "text",  new Business0Filter();    
5.       acceptor.setHandler(new ServerHandler());    
6.       try {    
7.           acceptor.bind(new InetSocketAddress(PORT));    
8.       } catch (IOException e) {    
9.          acceptor.dispose();    
10.       }    
11.   }    

这是一个典型的基于mina的服务端程序。Mina的大体结构还是很清晰的，绑定一个端口接收消息，经过一个Filter链(上行)预处理request，最后在Handler完成业务逻辑，然后反向经过Filter链(下行)封装response，直至返回客户端。Mina支持TCP/UDP，本文只记录TCP(面向连接)的消息流。 
看一下NioSocketAcceptor的内部结构概念图； 
 
可以看出，整体上还是采用多Selector的架构。 

Acceptor线程 
在NioSocketAcceptor中有个Acceptor线程，它负责将一个ServerSocketChannel注册到主Selector中，注册事件为OP_ACCEPT，当有OP_ACCEPT响应时，取出相应的socket，封装在NioSocketSession中，并给这个NioSocketSession对象分配一个NioProcessor； 

SimpleIoProcessorPool 
NioSocketAcceptor维护的一个NioProcessor的对象池，这个对象池缺省状态下维护了Runtime.getRuntime().availableProcessors() + 1个NioProcessor对象，每个运行时建立的NioSocketSession对象都会分配一个NioProcessor对象，这个NioProcessor对象与NioSocketSession对象是一对多的关系； 

NioProcessor 
每个NioProcessor对象内部维护了一个Selector对象及Processor线程，除此还有一些数据结构，用于数据处理，主要的有； 

• Queue<S> newSessions = new ConcurrentLinkedQueue<S>()
• Queue<S> flushingSessions = new ConcurrentLinkedQueue<S>()

其中，newSessions就是当给NioSocketSession对象分配NioProcessor时，将此NioSocketSession对象添加到此newSessions queue中，同时将对应的channel以OP_READ注册到这个NioProcessor对象的Selector，给session分配NioProcessor的逻辑是； 

Java代码  

1. private IoProcessor<S> getProcessor(S session) {  
2.         IoProcessor<S> processor = (IoProcessor<S>) session.getAttribute(PROCESSOR);  
3.         if (processor == null) {  
4.             if (disposed || disposing) {  
5.                 throw new IllegalStateException("A disposed processor cannot be accessed.");  
6.             }  
7.             processor = pool[Math.abs((int) session.getId()) % pool.length];  
8.             if (processor == null) {  
9.                 throw new IllegalStateException("A disposed processor cannot be accessed.");  
10.             }  
11.             session.setAttributeIfAbsent(PROCESSOR, processor);  
12.         }  
13.         return processor;  
14. }  

这个session id是生成session时产生的。 

NioProcessor对象的Processor线程就是从这个newSessions queue里取出新加进来的session对象，以OP_READ注册到自己Selector中，然后针对自己的Selector进行select()操作，当有可读的socket事件响应时就取出socket数据，然后走Filter链直至业务逻辑。当有了response需要返回给客户端时，会将response对象封装并添加到session对象的一个写出缓冲里，然后session对象被添加到NioProcessor对象的flushingSessions中，Processor线程会从flushingSessions中取出session，然后从session的写出缓冲中取出response，写socket。需要注意的是，在处理写的时候还是比较细腻的，进入flushingSessions queue有两种方式， 

• 一个是经过业务逻辑处理，产生response，直接将session压入flushingSessions queue；
• 另一个是当执行上述写socket动作时，因为网络闪断或其他什么原因，写socket不能正常完成，这时，会将session对应的channel在Selector中注册OP_WRITE事件，当Processor线程发现这个session对应的channel有OP_WRITE事件时，会重新将这个session压入flushingSessions queue，然后就是走正常逻辑了，看下代码感受一下；

 

Java代码  

1. private boolean flushNow(S session, long currentTime) {  
2.         final WriteRequestQueue writeRequestQueue = session.getWriteRequestQueue();  
3.         WriteRequest req = null;  
4.         try {  
5.             ......  
6.             do {  
7.                 req = session.getCurrentWriteRequest();  
8.                 if (req == null) {  
9.                     // session的写出缓冲中取response  
10.                     req = writeRequestQueue.poll(session);  
11.                     if (req == null) {  
12.                         break;  
13.                     }  
14.                     session.setCurrentWriteRequest(req);  
15.                 }  
16.   
17.                 int localWrittenBytes = 0;  
18.                 Object message = req.getMessage();  
19.                 if (message instanceof IoBuffer) {  
20.                     //写socket  
21.                     localWrittenBytes = writeBuffer(session, req, hasFragmentation, maxWrittenBytes - writtenBytes, currentTime);  
22.   
23.                     if ((localWrittenBytes > 0) && ((IoBuffer) message).hasRemaining()) {  
24.                         //写socket成功，但是buffer中还有需要写的数据  
25.                         writtenBytes += localWrittenBytes;  
26.                         setInterestedInWrite(session, true);  
27.                         return false;  
28.                     }  
29.                 }  
30.                   
31.                 ......  
32.                 //写socket出错，重置channel事件  
33.                 if (localWrittenBytes == 0) {  
34.                     setInterestedInWrite(session, true);  
35.                     return false;  
36.                 }  
37.                 ......  
38.                   
39.             } while (writtenBytes < maxWrittenBytes);  
40.         } catch (Exception e) {  
41.             ......  
42.         }  
43.         return true;  
44.     }  
45.   
46.     protected void setInterestedInWrite(NioSession session, boolean isInterested) throws Exception {  
47.         SelectionKey key = session.getSelectionKey();  
48.         if (key == null) {  
49.             return;  
50.         }  
51.         int newInterestOps = key.interestOps();  
52.         //注册OP_WRITE事件  
53.         if (isInterested) {  
54.             newInterestOps |= SelectionKey.OP_WRITE;  
55.         } else {  
56.             newInterestOps &= ~SelectionKey.OP_WRITE;  
57.         }  
58.         key.interestOps(newInterestOps);  
59.     }  

在各个Selector的维护及session的超时控制等方面，mina在实现的细节上还有很多特别的设计，