MINA 源码分析

导读：不想细看就直接看红色部分，我最近会绘制图与仔细说哈自己的感受与MINA流程，欢迎探讨一起进步

 

刚刚读完MINA源码，解决了过去的困惑，但是多了一些新的困惑！

 

希望有研究的人指导探讨！

 

 SocketAcceptor acceptor = new NioSocketAcceptor();

        acceptor.setReuseAddress( true );
        acceptor.setHandler(new EchoProtocolHandler());
        acceptor.bind(new InetSocketAddress(PORT));

 

SocketAcceptor acceptor = new NioSocketAcceptor();

此行代码 通过NioSocketAcceptor构造器 构造了SimpleIoProcessorPool实例包含几个NioProcessor实例NioProcessor实例包含同一个Executor实例

 

 

acceptor.bind(new InetSocketAddress(PORT));

这样服务器接到请求，就从SimpleIoProcessorPool选择一个NioProcessor实例处理数据【当然是其包含的Executor实力构造内部类Runable接口执行】

 

是从AbstractPollingIoAcceptor类startupAcceptor（）方法

 private void startupAcceptor() {
        // If the acceptor is not ready, clear the queues
        // TODO : they should already be clean : do we have to do that ?
        if (!selectable) {
            registerQueue.clear();
            cancelQueue.clear();
        }

        // start the acceptor if not already started
        synchronized (lock) {
            if (acceptor == null) {
                acceptor = new Acceptor();
                executeWorker(acceptor);
            }
        }
    }

 

 private class Acceptor implements Runnable {
        public void run() {
            int nHandles = 0;

            while (selectable) {
                try {
                 
                    int selected = select();

                  
                    nHandles += registerHandles();

                    if (selected > 0) {
                     
                        processHandles(selectedHandles());
                    }

                  
                    nHandles -= unregisterHandles();

                    if (nHandles == 0) {
                        synchronized (lock) {
                            if (registerQueue.isEmpty()
                                    && cancelQueue.isEmpty()) {
                                acceptor = null;
                                break;
                            }
                        }
                    }
                } catch (Throwable e) {
                    ExceptionMonitor.getInstance().exceptionCaught(e);

                    try {
                        Thread.sleep(1000);
                    } catch (InterruptedException e1) {
                        ExceptionMonitor.getInstance().exceptionCaught(e1);
                    }
                }
            }

            // Cleanup all the processors, and shutdown the acceptor.
            if (selectable && isDisposing()) {
                selectable = false;
                try {
                    if (createdProcessor) {
                        processor.dispose();
                    }
                } finally {
                    try {
                        synchronized (disposalLock) {
                            if (isDisposing()) {
                                destroy();
                            }
                        }
                    } catch (Exception e) {
                        ExceptionMonitor.getInstance().exceptionCaught(e);
                    } finally {
                        disposalFuture.setDone();
                    }
                }
            }
        }
  processHandles(selectedHandles());

  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
                T session = accept(processor, handle);
               
                if (session == null) {
                    break;
                }

                initSession(session, null, null);
              System.out.print("bobo-->"+session.getProcessor().getClass());
                // add the session to the SocketIoProcessor
                session.getProcessor().add(session);
            }
        }
    }
 T session = accept(processor, handle);

session.getProcessor().add(session);
session.getProcessor()实例是

SimpleIoProcessorPool对象

 public final void add(T session) {
        getProcessor(session).add(session);
    }

 

getProcessor(session)实例是NioProcessor他的父类AbstractPollingIoProcessor

 public final void add(T session) {
        if (isDisposing()) {
            throw new IllegalStateException("Already disposed.");
        }

        // Adds the session to the newSession queue and starts the worker
        newSessions.add(session);
        startupProcessor();
    }

  private void startupProcessor() {
        synchronized (lock) {
            if (processor == null) {
                processor = new Processor();
                executor.execute(new NamePreservingRunnable(processor, threadName));
            }
        }
       
        // Just stop the select() and start it again, so that the processor
        // can be activated immediately.
        wakeup();
    }

就这样运行

评论

6 楼 rrsy23 2010-06-04  

没有具体研究

但是我认为MINA是主要工作是通信

上传路径，你可以自己在chain上写个自己的策略或者配置什么的啊；

原来那些开源的上传怎么做的？思考ha

5 楼 qyhdt 2010-05-29  

上传的文件设定服务器文件存放路径，可否有解？ 做了几次都失败了

4 楼 rrsy23 2009-07-23  

呵呵 可以 自己写个 mockMina

就4，5个类 实现个简单的

3 楼 hardPass 2009-07-20  

这部分代码看得我眼睛疼，跳来啊跳去。
我想，要是把mina这些代码精简一下，也不要搞太多继承，顺序搞得清楚一点。
那就好了。

对头，搞个mina的精简版，不知道大家喜欢啊？

2 楼 rrsy23 2009-07-20  

不知道你想了解什么，可以说清楚点！

工作他的example有代码

如果不清楚 你就信了解哈 java nio的scocket那部分

1 楼 granjoy 2009-07-20  

仔细讲一下哈。
最近拿red5做项目，不知道Mina怎么工作的。