回归java，学习下mina，后续慢慢完善哈。

 

 一、怎么看mina的开源代码

1、首先要明白，一个代码、程序、或者框架，是用来解决用户实在的问题。而mina是一个能够帮助用户开发高性能和高伸缩性网络应用程序的框架 。

2、所有，针对mina，关键就是高性能、高伸缩、网络应用。所有，看mina源码就带着几个问题去看：

        a、什么是网络编程，这个就需要了解socket、io、nio的知识。

        b、高性能，在高并发的情况下高吞吐量，针对这种并发编程，mina用到了并发编程框架，所有要了解concurrent相关知识。

        c、高伸缩性，就是框架在设计上，在架构上，在模式的运用上设计合理，这里就是要学习怎么样才能架构出高伸缩性的架构。

 

二、mina 入门《mina，hello world》和整体通信过程

这里默认你已经准备好了Eclipse和java等必要的开发环境。

新建一个project工程，导入mina必要包：mina-core等。

http://apache.fayea.com/mina/mina/2.0.13/apache-mina-2.0.13-bin.zip

，最懒的方式就是讲lib包和dist包下的jar全部依赖在工程中。

代码参考：http://www.cnblogs.com/xuekyo/archive/2013/03/06/2945826.html

创建服务端 MinaTimeServer ：

1. import java.io.IOException;
2. import java.net.InetSocketAddress;
3. import java.nio.charset.Charset;
4. import org.apache.mina.core.service.IoAcceptor;
5. import org.apache.mina.core.session.IdleStatus;
6. import org.apache.mina.filter.codec.ProtocolCodecFilter;
7. import org.apache.mina.filter.codec.textline.TextLineCodecFactory;
8. import org.apache.mina.filter.logging.LoggingFilter;
9. import org.apache.mina.transport.socket.nio.NioSocketAcceptor;
11. publicclassMinaTimeServer{
12. // 定义监听端口
13. privatestaticfinalint PORT =6488;
15. publicstaticvoid main(String[] args)throwsIOException{
16. // 创建服务端监控线程
17. IoAcceptor acceptor =newNioSocketAcceptor();
18. acceptor.getSessionConfig().setReadBufferSize(2048);
19. acceptor.getSessionConfig().setIdleTime(IdleStatus.BOTH_IDLE,10);
20. // 设置日志记录器
21. acceptor.getFilterChain().addLast("logger",newLoggingFilter());
22. // 设置编码过滤器
23. acceptor.getFilterChain().addLast(
24. "codec",
25. newProtocolCodecFilter(newTextLineCodecFactory(Charset.forName("UTF-8"))));
26. // 指定业务逻辑处理器
27. acceptor.setHandler(newTimeServerHandler());
28. // 设置端口号
29. acceptor.bind(newInetSocketAddress(PORT));
30. // 启动监听线程
31. acceptor.bind();
32. }
33. }

编写服务端handler

1. import org.apache.mina.core.service.IoHandlerAdapter;
2. import org.apache.mina.core.session.IdleStatus;
3. import org.apache.mina.core.session.IoSession;
5. /**
6. * 服务器端业务逻辑
7. */
8. publicclassTimeServerHandlerextendsIoHandlerAdapter{
10. /**
11. * 连接创建事件
12. */
13. @Override
14. publicvoid sessionCreated(IoSession session){
15. // 显示客户端的ip和端口
16. System.out.println(session.getRemoteAddress().toString());
17. }
19. @Override
20. publicvoid exceptionCaught(IoSession session,Throwable cause)throwsException{
21. cause.printStackTrace();
22. }
24. /**
25. * 消息接收事件
26. */
27. @Override
28. publicvoid messageReceived(IoSession session,Object message)throwsException{
29. String strMsg = message.toString();
30. if(strMsg.trim().equalsIgnoreCase("quit")){
31. session.close(true);
32. return;
33. }
34. // 返回消息字符串
35. session.write("Hi Client!");
36. // 打印客户端传来的消息内容
37. System.out.println("Message written : "+ strMsg);
38. }
40. @Override
41. publicvoid sessionIdle(IoSession session,IdleStatus status)throwsException{
42. System.out.println("IDLE"+ session.getIdleCount(status));
43. }
45. }

构建客户端

1. import java.net.InetSocketAddress;
2. import java.nio.charset.Charset;
3. import org.apache.mina.core.future.ConnectFuture;
4. import org.apache.mina.filter.codec.ProtocolCodecFilter;
5. import org.apache.mina.filter.codec.textline.TextLineCodecFactory;
6. import org.apache.mina.filter.logging.LoggingFilter;
7. import org.apache.mina.transport.socket.nio.NioSocketConnector;
9. publicclassMinaTimeClient{
11. publicstaticvoid main(String[] args){
12. // 创建客户端连接器.
13. NioSocketConnector connector =newNioSocketConnector();
14. connector.getFilterChain().addLast("logger",newLoggingFilter());
15. connector.getFilterChain().addLast("codec",
16. newProtocolCodecFilter(newTextLineCodecFactory(Charset.forName("UTF-8"))));
18. // 设置连接超时检查时间
19. connector.setConnectTimeoutCheckInterval(30);
20. connector.setHandler(newTimeClientHandler());
22. // 建立连接
23. ConnectFuture cf = connector.connect(newInetSocketAddress("192.168.2.109",6488));
24. // 等待连接创建完成
25. cf.awaitUninterruptibly();
27. cf.getSession().write("Hi Server!");
28. cf.getSession().write("quit");
30. // 等待连接断开
31. cf.getSession().getCloseFuture().awaitUninterruptibly();
32. // 释放连接
33. connector.dispose();
34. }
35. }

 

编写客户端handler

1. import org.apache.mina.core.service.IoHandlerAdapter;
2. import org.apache.mina.core.session.IoSession;
4. publicclassTimeClientHandlerextendsIoHandlerAdapter{
6. publicvoid messageReceived(IoSession session,Object message)throwsException{
7. String content = message.toString();
8. System.out.println("client receive a message is : "+ content);
9. }
11. publicvoid messageSent(IoSession session,Object message)throwsException{
12. System.out.println("messageSent -> ："+ message);
13. }
15. }

 

主要接口体现

 

 

先说明下主要接口和包结构

Mina包的简介：

org.apache.mina.core.buffer	用于缓冲区的IoBuffer
org.apache.mina.core.service org.apache.mina.transport.*	用于提供连接的service
org.apache.mina.core.session	用于提供两端状态的session
org.apache.mina.core.filterchain org.apache.mina.filter.*	用于拦截所有IO事件和请求的filter chain和各类拦截器（在IoService和IoHandler之间）
org.apache.mina.handler.*	用于处理IO事件的handler
org.apache.mina.core.future	用于实现异步IO操作的 future
org.apache.mina.core.polling	用于实现IO轮询的的polling
org.apache.mina.proxy.*	用于实现代理的proxy

先介绍Mina几个重要接口：

• IoServiece ：这个接口在一个线程上负责套接字的建立，拥有自己的 Selector，监听是否有连接被建立。
• IoProcessor ：这个接口在另一个线程上负责检查是否有数据在通道上读写，也就是说它也拥有自己的 Selector，这是与我们使用 JAVA NIO 编码时的一个不同之处，通常在 JAVA NIO 编码中，我们都是使用一个 Selector，也就是不区分 IoService与 IoProcessor 两个功能接口。另外，IoProcessor 负责调用注册在 IoService 上的过滤器，并在过滤器链之后调用 IoHandler。  
• IoAccepter ：相当于网络应用程序中的服务器端
• IoConnector ：相当于客户端
• IoSession ：当前客户端到服务器端的一个连接实例
• IoHandler ：这个接口负责编写业务逻辑，也就是接收、发送数据的地方。这也是实际开发过程中需要用户自己编写的部分代码。
• IoFilter ：过滤器用于悬接通讯层接口与业务层接口，这个接口定义一组拦截器，这些拦截器可以包括日志输出、黑名单过滤、数据的编码（write 方向）与解码（read 方向）等功能，其中数据的 encode与 decode是最为重要的、也是你在使用 Mina时最主要关注的地方。

 

 

这里需要了解的就是mina如何建立客户端连接请求和与客户端的数据交互 来了解各个接口的作用。

1、建立客户端请求：

我们看到，我们的MinaTimeServer中，new 了一个NioSocketAcceptor，我们来看看，这里发生了什么，先抛出，NioSocketAcceptor的相关继承关系如下：

 所有，我们来先看看，new NioSocketAcceptor都做了什么事情

1、调用NioSocketAcceptor的构造函数，其实是调用了AbstractPollingIoAcceptor

1. publicNioSocketAcceptor(){
2. super(newDefaultSocketSessionConfig(),NioProcessor.class);
3. ((DefaultSocketSessionConfig) getSessionConfig()).init(this);
4. }

2、那我看下，AbstractPollingIoAcceptor又调用了super（），就是AbstartIoAcceptor，其中这个sessionConfig是默认实现，executor是null

1. privateAbstractPollingIoAcceptor(IoSessionConfig sessionConfig,Executor executor,IoProcessor<S> processor,
2. boolean createdProcessor,SelectorProvider selectorProvider){
3. super(sessionConfig, executor);
5. if(processor ==null){
6. thrownewIllegalArgumentException("processor");
7. }
9. this.processor = processor;
10. this.createdProcessor = createdProcessor;
12. try{
13. // Initialize the selector
14. init(selectorProvider);//初始化selector，也就是selector.open();
16. // The selector is now ready, we can switch the
17. // flag to true so that incoming connection can be accepted
18. selectable =true;
19. }catch(RuntimeException e){
20. throw e;
21. }catch(Exception e){
22. thrownewRuntimeIoException("Failed to initialize.", e);
23. }finally{
24. if(!selectable){
25. try{
26. destroy();
27. }catch(Exception e){
28. ExceptionMonitor.getInstance().exceptionCaught(e);
29. }
30. }
31. }
32. }

2.1、这里new的时候，生产了一个SimpleProcessor的实例，并告知已经创建了processor了。

3、我们在继续看，这个 AbstartIoAcceptor继续调用了AbstactIoService（）,主要的工作就是初始化下listener，生成excutor为newCachedThreadPool模式，此对象还包括了filterChainBuilder和sessionDataStructureFactory

1. protectedAbstractIoService(IoSessionConfig sessionConfig,Executor executor){
2. if(sessionConfig ==null){
3. thrownewIllegalArgumentException("sessionConfig");
4. }
6. if(getTransportMetadata()==null){
7. thrownewIllegalArgumentException("TransportMetadata");
8. }
10. if(!getTransportMetadata().getSessionConfigType().isAssignableFrom(sessionConfig.getClass())){
11. thrownewIllegalArgumentException("sessionConfig type: "+ sessionConfig.getClass()+" (expected: "
12. + getTransportMetadata().getSessionConfigType()+")");
13. }
15. // Create the listeners, and add a first listener : a activation listener
16. // for this service, which will give information on the service state.
17. listeners =newIoServiceListenerSupport(this);
18. listeners.add(serviceActivationListener);
20. // Stores the given session configuration
21. this.sessionConfig = sessionConfig;
23. // Make JVM load the exception monitor before some transports
24. // change the thread context class loader.
25. ExceptionMonitor.getInstance();
27. if(executor ==null){
28. this.executor =Executors.newCachedThreadPool();
29. createdExecutor =true;
30. }else{
31. this.executor = executor;
32. createdExecutor =false;
33. }
35. threadName = getClass().getSimpleName()+'-'+ id.incrementAndGet();
36. }

至此，new NioSocketAcceptor实例过程完成，看起来只是初始化了下如下必要元素

selector，processor，listenList,IofilterChainBuilder,和线程相关的线程池execute

那我们继续看，我们的MinaTimeServer 设置了iofilter和业务处理handler。接下来调用了bind方法。其实是调用了AbstractIoAcceptor的bind，方法里面调用了AbstactPollingIoAcceptor中的bindInternal.

1. publicfinalvoid bind(Iterable<?extendsSocketAddress> localAddresses)throwsIOException{
2. if(isDisposing()){
3. thrownewIllegalStateException("The Accpetor disposed is being disposed.");
4. }
6. if(localAddresses ==null){
7. thrownewIllegalArgumentException("localAddresses");
8. }
10. List<SocketAddress> localAddressesCopy =newArrayList<SocketAddress>();
12. for(SocketAddress a : localAddresses){
13. checkAddressType(a);
14. localAddressesCopy.add(a);
15. }
17. if(localAddressesCopy.isEmpty()){
18. thrownewIllegalArgumentException("localAddresses is empty.");
19. }
21. boolean activate =false;
22. synchronized(bindLock){
23. synchronized(boundAddresses){
24. if(boundAddresses.isEmpty()){
25. activate =true;
26. }
27. }
29. if(getHandler()==null){
30. thrownewIllegalStateException("handler is not set.");
31. }
33. try{
34. Set<SocketAddress> addresses = bindInternal(localAddressesCopy);//
36. synchronized(boundAddresses){
37. boundAddresses.addAll(addresses);
38. }
39. }catch(IOException e){
40. throw e;
41. }catch(RuntimeException e){
42. throw e;
43. }catch(Exception e){
44. thrownewRuntimeIoException("Failed to bind to: "+ getLocalAddresses(), e);
45. }
46. }
48. if(activate){
49. getListeners().fireServiceActivated();
50. }
51. }

bindInternal，这里研究下future，这个current包中的模式。。

1. @Override
2. protectedfinalSet<SocketAddress> bindInternal(List<?extendsSocketAddress> localAddresses)throwsException{
3. //创建一个future并放在注册队列中，当selector处理完后，将通知这个future做其他事情
4. AcceptorOperationFuture request =newAcceptorOperationFuture(localAddresses);
5. registerQueue.add(request);
7. // 创建一个Acceptor（内部类），并放在execute中启动监听线程。
8. startupAcceptor();
10. // 为了处理刚才这个绑定请求，我们暂且不阻塞selector方法
11. //As we just started the acceptor, we have to unblock the select()
12. // in order to process the bind request we just have added to the
13. // registerQueue.
14. try{
15. lock.acquire();
17. // Wait a bit to give a chance to the Acceptor thread to do the select()
18. Thread.sleep(10);
19. wakeup();
20. }finally{
21. lock.release();
22. }
24. // Now, we wait until this request is completed.
25. request.awaitUninterruptibly();
27. if(request.getException()!=null){
28. throw request.getException();
29. }
31. // Update the local addresses.
32. // setLocalAddresses() shouldn't be called from the worker thread
33. // because of deadlock.
34. Set<SocketAddress> newLocalAddresses =newHashSet<SocketAddress>();
36. for(H handle : boundHandles.values()){
37. newLocalAddresses.add(localAddress(handle));
38. }
40. return newLocalAddresses;
41. }

startupAcceptor

1. privatevoid startupAcceptor()throwsInterruptedException{
2. // If the acceptor is not ready, clear the queues
3. // TODO : they should already be clean : do we have to do that ?
4. if(!selectable){
5. registerQueue.clear();
6. cancelQueue.clear();
7. }
9. // start the acceptor if not already started
10. Acceptor acceptor = acceptorRef.get();//获取线程中是否有Acceptor了。
12. if(acceptor ==null){//没有，则实例化一个，并在exeutrWorker中启动，调用他的run方法
13. lock.acquire();
14. acceptor =newAcceptor();
16. if(acceptorRef.compareAndSet(null, acceptor)){
17. executeWorker(acceptor);
18. }else{
19. lock.release();
20. }
21. }
22. }

我们继续看看Acceptor的run方法，其实就是开始执行select（）阻塞方法了。

1. publicvoid run(){
2. assert(acceptorRef.get()==this);
4. int nHandles =0;
6. // Release the lock
7. lock.release();
9. while(selectable){
10. try{
11. // Detect if we have some keys ready to be processed
12. // The select() will be woke up if some new connection
13. // have occurred, or if the selector has been explicitly
14. // woke up
15. int selected = select();
17. // this actually sets the selector to OP_ACCEPT,
18. // and binds to the port on which this class will
19. // listen on
20. nHandles += registerHandles();
22. // Now, if the number of registred handles is 0, we can
23. // quit the loop: we don't have any socket listening
24. // for incoming connection.
25. if(nHandles ==0){
26. acceptorRef.set(null);
28. if(registerQueue.isEmpty()&& cancelQueue.isEmpty()){
29. assert(acceptorRef.get()!=this);
30. break;
31. }
33. if(!acceptorRef.compareAndSet(null,this)){
34. assert(acceptorRef.get()!=this);
35. break;
36. }
38. assert(acceptorRef.get()==this);
39. }
41. if(selected >0){
42. // We have some connection request, let's process
43. // them here.
44. processHandles(selectedHandles());
45. }
47. // check to see if any cancellation request has been made.
48. nHandles -= unregisterHandles();
49. }catch(ClosedSelectorException cse){
50. // If the selector has been closed, we can exit the loop
51. ExceptionMonitor.getInstance().exceptionCaught(cse);
52. break;
53. }catch(Exception e){
54. ExceptionMonitor.getInstance().exceptionCaught(e);
56. try{
57. Thread.sleep(1000);
58. }catch(InterruptedException e1){
59. ExceptionMonitor.getInstance().exceptionCaught(e1);
60. }
61. }
62. }
64. // Cleanup all the processors, and shutdown the acceptor.
65. if(selectable && isDisposing()){
66. selectable =false;
67. try{
68. if(createdProcessor){
69. processor.dispose();
70. }
71. }finally{
72. try{
73. synchronized(disposalLock){
74. if(isDisposing()){
75. destroy();
76. }
77. }
78. }catch(Exception e){
79. ExceptionMonitor.getInstance().exceptionCaught(e);
80. }finally{
81. disposalFuture.setDone();
82. }
83. }
84. }
85. }

其中registerHandler就是实力ServerSocket的端口监听，能看到我们熟悉的NIO代码端口bind和 channel.register(selector, SelectionKey.OP_ACCEPT);

，在 registerHandler调用了NioSocketAcceptor中的open

1. @Override
2. protectedServerSocketChannel open(SocketAddress localAddress)throwsException{
3. // Creates the listening ServerSocket
5. ServerSocketChannel channel =null;
7. if(selectorProvider !=null){
8. channel = selectorProvider.openServerSocketChannel();
9. }else{
10. channel =ServerSocketChannel.open();
11. }
13. boolean success =false;
15. try{
16. // This is a non blocking socket channel
17. channel.configureBlocking(false);
19. // Configure the server socket,
20. ServerSocket socket = channel.socket();
22. // Set the reuseAddress flag accordingly with the setting
23. socket.setReuseAddress(isReuseAddress());
25. // and bind.
26. try{
27. socket.bind(localAddress, getBacklog());
28. }catch(IOException ioe){
29. // Add some info regarding the address we try to bind to the
30. // message
31. String newMessage ="Error while binding on "+ localAddress +"\n"+"original message : "
32. + ioe.getMessage();
33. Exception e =newIOException(newMessage);
34. e.initCause(ioe.getCause());
36. // And close the channel
37. channel.close();
39. throw e;
40. }
42. // Register the channel within the selector for ACCEPT event
43. channel.register(selector,SelectionKey.OP_ACCEPT);
44. success =true;
45. }finally{
46. if(!success){
47. close(channel);
48. }
49. }
50. return channel;
51. }

注册后，那我们就等待客户端的连接吧，如果客户端执行了socket.connect(iPaddr),那我们这里的selector.select()会>0.此时会处理这个客户端的请求Acceptor.processHandles(new ServerSocketChannelIterator(selector.selectedKeys()));是不是感觉这个代码在自己编写的NIO代码中很类似？这里，accept（）方法，将processor和这个ServerSocketChannel作处理， 其实是生产一个session，并将socketChannel，processor等做关联 。并初始化和准备一个客户端和服务端连接和交互过程整个生命周期的session了。最后session.getProcessor.add（session）很隐晦的开始了processor的流程。。

1. privatevoid processHandles(Iterator<H> handles)throwsException{
2. while(handles.hasNext()){
3. H handle = handles.next();
4. handles.remove();
6. // Associates a new created connection to a processor,
7. // and get back a session
8. S session = accept(processor, handle);
10. if(session ==null){
11. continue;
12. }
14. initSession(session,null,null);
16. // add the session to the SocketIoProcessor
17. session.getProcessor().add(session);
18. }
19. }

我们来看看NioSocketAcceptor.accept()

1. protectedNioSession accept(IoProcessor<NioSession> processor,ServerSocketChannel handle)throwsException{
3. SelectionKey key =null;
5. if(handle !=null){
6. key = handle.keyFor(selector);
7. }
9. if((key ==null)||(!key.isValid())||(!key.isAcceptable())){
10. returnnull;
11. }
13. // accept the connection from the client
14. SocketChannel ch = handle.accept();
16. if(ch ==null){
17. returnnull;
18. }
20. returnnewNioSocketSession(this, processor, ch);
21. }

刚我们说到很隐晦的 session.getProcessor.add（session）。为什么说很隐晦，应该这里正是开始了processor处理这个session后续请求的。 上面在实例化的时候，实例的是SimpleProcessor首先看看SimpleProcessor.add(){getProcessor.add()}//整个就是多个processor的体现

1. @SuppressWarnings("unchecked")
2. privateIoProcessor<S> getProcessor(S session){
3. IoProcessor<S> processor =(IoProcessor<S>) session.getAttribute(PROCESSOR);
5. if(processor ==null){
6. if(disposed || disposing){
7. thrownewIllegalStateException("A disposed processor cannot be accessed.");
8. }
10. processor = pool[Math.abs((int) session.getId())% pool.length];
12. if(processor ==null){
13. thrownewIllegalStateException("A disposed processor cannot be accessed.");
14. }
16. session.setAttributeIfAbsent(PROCESSOR, processor);
17. }
19. return processor;
20. }

 

 

 

AbstractPollingIoProcessor.add()

1. publicfinalvoid add(S session){
2. if(disposed || disposing){
3. thrownewIllegalStateException("Already disposed.");
4. }
6. // Adds the session to the newSession queue and starts the worker
7. newSessions.add(session);
8. startupProcessor();
9. }

1. privatevoid startupProcessor(){
2. Processor processor = processorRef.get();
4. if(processor ==null){
5. processor =newProcessor();
7. if(processorRef.compareAndSet(null, processor)){
8. executor.execute(newNamePreservingRunnable(processor, threadName));
9. }
10. }
12. // 注意这个wakeup。
13. wakeup();
14. }

1. publicvoid run(){
2. assert(processorRef.get()==this);
4. int nSessions =0;
5. lastIdleCheckTime =System.currentTimeMillis();
7. for(;;){
8. try{
9. // This select has a timeout so that we can manage
10. // idle session when we get out of the select every
11. // second. (note : this is a hack to avoid creating
12. // a dedicated thread).
13. long t0 =System.currentTimeMillis();
14. int selected = select(SELECT_TIMEOUT);
15. long t1 =System.currentTimeMillis();
16. long delta =(t1 - t0);
18. if(!wakeupCalled.getAndSet(false)&&(selected ==0)&&(delta <100)){
19. // Last chance : the select() may have been
20. // interrupted because we have had an closed channel.
21. if(isBrokenConnection()){
22. LOG.warn("Broken connection");
23. }else{
24. LOG.warn("Create a new selector. Selected is 0, delta = "+(t1 - t0));
25. // 这里搞不太懂为什么要注册过新的。
26. registerNewSelector();
27. }
28. }
30. // 先处理这个心的sessoin。其实就是做了socket在processor线程上的selector的注册
31. nSessions += handleNewSessions();
33. updateTrafficMask();
35. // Now, if we have had some incoming or outgoing events,
36. // deal with them
37. if(selected >0){
38. // LOG.debug("Processing ..."); // This log hurts one of
39. // the MDCFilter test...
40. process();
41. }
43. // Write the pending requests
44. long currentTime =System.currentTimeMillis();
45. flush(currentTime);
47. // And manage removed sessions
48. nSessions -= removeSessions();
50. // Last, not least, send Idle events to the idle sessions
51. notifyIdleSessions(currentTime);
53. // Get a chance to exit the infinite loop if there are no
54. // more sessions on this Processor
55. if(nSessions ==0){
56. processorRef.set(null);
58. if(newSessions.isEmpty()&& isSelectorEmpty()){
59. // newSessions.add() precedes startupProcessor
60. assert(processorRef.get()!=this);
61. break;
62. }
64. assert(processorRef.get()!=this);
66. if(!processorRef.compareAndSet(null,this)){
67. // startupProcessor won race, so must exit processor
68. assert(processorRef.get()!=this);
69. break;
70. }
72. assert(processorRef.get()==this);
73. }
75. // Disconnect all sessions immediately if disposal has been
76. // requested so that we exit this loop eventually.
77. if(isDisposing()){
78. boolean hasKeys =false;
80. for(Iterator<S> i = allSessions(); i.hasNext();){
81. IoSession session = i.next();
83. if(session.isActive()){
84. scheduleRemove((S)session);
85. hasKeys =true;
86. }
87. }
89. if(hasKeys){
90. wakeup();
91. }
92. }
93. }catch(ClosedSelectorException cse){
94. // If the selector has been closed, we can exit the loop
95. // But first, dump a stack trace
96. ExceptionMonitor.getInstance().exceptionCaught(cse);
97. break;
98. }catch(Exception e){
99. ExceptionMonitor.getInstance().exceptionCaught(e);
101. try{
102. Thread.sleep(1000);
103. }catch(InterruptedException e1){
104. ExceptionMonitor.getInstance().exceptionCaught(e1);
105. }
106. }
107. }
109. try{
110. synchronized(disposalLock){
111. if(disposing){
112. doDispose();
113. }
114. }
115. }catch(Exception e){
116. ExceptionMonitor.getInstance().exceptionCaught(e);
117. }finally{
118. disposalFuture.setValue(true);
119. }
120. }

handlerNewSession做了几件事情，

1、将这个socketChannel注册在processor线程上的selector上，具体看NioProcessor的init().

2、构建iofilter的chain，并发出session被创建的事件。

 

很快，我们就能看到，一个请求过来后，如何读写的了。这里就是靠processor的中的process（），很熟悉。哈哈

1. privatevoid process(S session){
2. // Process Reads
3. if(isReadable(session)&&!session.isReadSuspended()){
4. read(session);
5. }
7. // Process writes
8. if(isWritable(session)&&!session.isWriteSuspended()){
9. // add the session to the queue, if it's not already there
10. if(session.setScheduledForFlush(true)){
11. flushingSessions.add(session);
12. }
13. }
14. }

那我们最后看看read（）

1. privatevoid read(S session){
2. IoSessionConfig config = session.getConfig();
3. int bufferSize = config.getReadBufferSize();
4. IoBuffer buf =IoBuffer.allocate(bufferSize);
6. finalboolean hasFragmentation = session.getTransportMetadata().hasFragmentation();
8. try{
9. int readBytes =0;
10. int ret;
12. try{
13. if(hasFragmentation){
15. while((ret = read(session, buf))>0){
16. readBytes += ret;
18. if(!buf.hasRemaining()){
19. break;
20. }
21. }
22. }else{
23. ret = read(session, buf);
25. if(ret >0){
26. readBytes = ret;
27. }
28. }
29. }finally{
30. buf.flip();
31. }
33. if(readBytes >0){
34. IoFilterChain filterChain = session.getFilterChain();
35. filterChain.fireMessageReceived(buf);
36. buf =null;
38. if(hasFragmentation){
39. if(readBytes <<1< config.getReadBufferSize()){
40. session.decreaseReadBufferSize();
41. }elseif(readBytes == config.getReadBufferSize()){
42. session.increaseReadBufferSize();
43. }
44. }
45. }
47. if(ret <0){
48. // scheduleRemove(session);
49. IoFilterChain filterChain = session.getFilterChain();
50. filterChain.fireInputClosed();
51. }
52. }catch(Exception e){
53. if(e instanceofIOException){
54. if(!(e instanceofPortUnreachableException)
55. ||!AbstractDatagramSessionConfig.class.isAssignableFrom(config.getClass())
56. ||((AbstractDatagramSessionConfig) config).isCloseOnPortUnreachable()){
57. scheduleRemove(session);
58. }
59. }
61. IoFilterChain filterChain = session.getFilterChain();
62. filterChain.fireExceptionCaught(e);
63. }
64. }

除了读写Iobuffer外，filterChain.fireMessageReceived(buf);这里就到了我们一序列的iofitler，并在这个chain中，有一个tailFilter，这个TailFilter就是调用了我们的自己编写的Handler了。

整个流程的代码就这么。很多细节后续再补充，如：IoBuffer读写；穿插在整个系统中的事件。

 

 

 

二、mina 如何使用nio

    1、nio要素：selector，buffer，channel，这里推荐一个文章，链接为：

http://www.iteye.com/magazines/132-Java-NIO

 

三、mina 如何使用concurrent

    这个也是我们学习mina中能对concurrent中的一些应用做 个了解的。

四、mina 主要UML图和

 

五、mina 总结

  主要接口：IoService，包括了IoAcceptor，IoProcessor和在客户端使用的Ioconnector

                    IoFilter，很好第体现了面向对象中的开闭原则（软件实体应当对扩展开放，对修改关闭），对于整个处理流程的修改是关闭，在对于个性化的处理流程中用户需要关心的业务相关的拓展进行了开放。

                    IOSession,讲一个连接封装成session，后续用到的请求数据，处理器，相关配置等关联到这里。理解了session的整个生命周期，就明白了Acceptor，processor的是怎么分别处理客户端连接请求和数据处理过程了。

                    IoHandler，业务处理的中心，用户根据自己的业务需求，在这里编写业务代码

                    IO