首页 > 代码库 > mina socket底层主流程源码实现

mina socket底层主流程源码实现

一,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~

mina socket底层主流程源码实现