Mina2.0框架源码剖析（六）

上文的内容还有一些没有结尾，这篇补上。在ExpiringMap类中，使用了一个私有内部类ExpiringObject来表示待检查超时的对象，它包括三个域，键，值，上次访问时间，以及用于上次访问时间这个域的读写锁：

         private  K key;
         private  V value;
         private   long  lastAccessTime;
         private   final  ReadWriteLock lastAccessTimeLock  =   new  ReentrantReadWriteLock();

而ExpiringMap中包括了下述几个变量:

   private   final  ConcurrentHashMap < K, ExpiringObject >  delegate; // 超时代理集合，保存待检查对象
     private   final  CopyOnWriteArrayList < ExpirationListener < V >>  expirationListeners; // 超时监听者
     private   final  Expirer expirer; // 超时检查线程

现在再来看看IoSession的一个抽象实现类AbstractIoSession。这是它的几个重要的成员变量：

     private  IoSessionAttributeMap attributes; // 会话属性映射图
     private  WriteRequestQueue writeRequestQueue; // 写请求队列
     private  WriteRequest currentWriteRequest; // 当前写请求

     当要结束当前会话时，会发送一个一个写请求CLOSE_REQUEST。而closeFuture这个CloseFuture会在连接关闭时状态被设置为”closed”,它的监听器是SCHEDULED_COUNTER_RESETTER。

close和closeOnFlush都是异步的关闭操作，区别是前者立即关闭连接，而后者是在写请求队列中放入一个CLOSE_REQUEST，并将其即时刷新出去，若要真正等待关闭完成，需要调用方在返回的CloseFuture等待

public   final  CloseFuture close() {
         synchronized  (lock) {
             if  (isClosing()) {
                 return  closeFuture;
            }  else  {
                closing  =   true ;
            }
        }
        getFilterChain().fireFilterClose(); // fire出关闭事件
         return  closeFuture;
    }

     public   final  CloseFuture closeOnFlush() {
        getWriteRequestQueue().offer( this , CLOSE_REQUEST);
        getProcessor().flush( this );
         return  closeFuture;
    }

     下面来看看读数据的过程：

public   final  CloseFuture close() {
         synchronized  (lock) {
             if  (isClosing()) {
                 return  closeFuture;
            }  else  {
                closing  =   true ;
            }
        }
        getFilterChain().fireFilterClose(); // fire出关闭事件
         return  closeFuture;
    }

     public   final  CloseFuture closeOnFlush() {
        getWriteRequestQueue().offer( this , CLOSE_REQUEST);
        getProcessor().flush( this );
         return  closeFuture;
    }


     private  Queue < ReadFuture >  getReadyReadFutures() { // 返回可被读数据队列
        Queue < ReadFuture >  readyReadFutures  =
            (Queue < ReadFuture > ) getAttribute(READY_READ_FUTURES_KEY); // 从会话映射表中取出可被读数据队列
         if  (readyReadFutures  ==   null ) { // 第一次读数据
            readyReadFutures  =   new  CircularQueue < ReadFuture > (); // 构造一个新读数据队列
            Queue < ReadFuture >  oldReadyReadFutures  =
                (Queue < ReadFuture > ) setAttributeIfAbsent(
                        READY_READ_FUTURES_KEY, readyReadFutures);
             if  (oldReadyReadFutures  !=   null ) {
                readyReadFutures  =  oldReadyReadFutures;
            }
        }
         return  readyReadFutures;
    }

     public   final  ReadFuture read() { // 读数据
         if  ( ! getConfig().isUseReadOperation()) { // 会话配置不允许读数据(这是默认情况)
             throw   new  IllegalStateException( " useReadOperation is not enabled. " );
        }
        Queue < ReadFuture >  readyReadFutures  =  getReadyReadFutures(); // 获取已经可被读数据队列
        ReadFuture future;
         synchronized  (readyReadFutures) { // 锁住读数据队列
            future  =  readyReadFutures.poll(); // 取队头数据
             if  (future  !=   null ) {
                 if  (future.isClosed()) { // 关联的会话已经关闭了，让读者知道此情况
                    readyReadFutures.offer(future);
                }
            }  else  {
                future  =   new  DefaultReadFuture( this );
                getWaitingReadFutures().offer(future);  // 将此数据插入等待被读取数据的队列，这个代码和上面的getReadyReadFutures类似，只是键值不同而已

            }
        }
         return  future;
    }

     再来看写数据到指定远端地址的过程，可以写三种类型数据：IoBuffer，整个文件或文件的部分区域，这会通过传递写请求给过滤器链条来完成数据向目的远端的传输。

     public   final  WriteFuture write(Object message, SocketAddress remoteAddress) {
        FileChannel openedFileChannel  =   null ;
         try  
        {
             if  (message  instanceof  IoBuffer &&   ! ((IoBuffer) message).hasRemaining()) 
            { //  空消息
                 throw   new  IllegalArgumentException(
                 " message is empty. Forgot to call flip()? " );
            } 
             else   if  (message  instanceof  FileChannel) 
            { // 要发送的是文件的某一区域
                FileChannel fileChannel  =  (FileChannel) message;
                message  =   new  DefaultFileRegion(fileChannel,  0 , fileChannel.size());
            }
             else   if  (message  instanceof  File) 
            { // 要发送的是文件,打开文件通道
                File file  =  (File) message;
                openedFileChannel  =   new  FileInputStream(file).getChannel();
                message  =   new  DefaultFileRegion(openedFileChannel,  0 , openedFileChannel.size());
            }
        } 
         catch  (IOException e) 
        {
            ExceptionMonitor.getInstance().exceptionCaught(e);
             return  DefaultWriteFuture.newNotWrittenFuture( this , e);
        }
        WriteFuture future  =   new  DefaultWriteFuture( this ); 
        getFilterChain().fireFilterWrite(
                 new  DefaultWriteRequest(message, future, remoteAddress));  // 构造写请求,通过过滤器链发送出去，写请求中指明了要发送的消息，目的地址，以及返回的结果
 
// 如果打开了一个文件通道（发送的文件的部分区域或全部），就必须在写请求完成时关闭文件通道
         if  (openedFileChannel  !=   null ) {
             final  FileChannel finalChannel  =  openedFileChannel;
            future.addListener( new  IoFutureListener < WriteFuture > () {
                 public   void  operationComplete(WriteFuture future) {
                     try  {
                        finalChannel.close(); // 关闭文件通道
                    }  catch  (IOException e) {
                        ExceptionMonitor.getInstance().exceptionCaught(e);
                    }
                }
            });
        }
         return  future; // 写请求成功完成
    }

     最后，来看看一个WriteRequestQueue的实现，唯一加入的一个功能就是若在队头发现是请求关闭，则会去关闭会话。

  private   class  CloseRequestAwareWriteRequestQueue  implements  WriteRequestQueue {
         private   final  WriteRequestQueue q; // 内部实际的写请求队列
         public  CloseRequestAwareWriteRequestQueue(WriteRequestQueue q) {
             this .q  =  q;
        }
         public   synchronized  WriteRequest poll(IoSession session) {
            WriteRequest answer  =  q.poll(session);
             if  (answer  ==  CLOSE_REQUEST) {
                AbstractIoSession. this .close();
                dispose(session);
                answer  =   null ;
            }
             return  answer;
        }
         public   void  offer(IoSession session, WriteRequest e) {
            q.offer(session, e);
        }
         public   boolean  isEmpty(IoSession session) {
             return  q.isEmpty(session);
        }
         public   void  clear(IoSession session) {
            q.clear(session);
        }
         public   void  dispose(IoSession session) {
            q.dispose(session);
        }
    }

 

作者：phinecos(洞庭散人)
出处：http://phinecos.cnblogs.com/
本文版权归作者和博客园共有，欢迎转载，但请保留此段声明，并在文章页面明显位置给出原文连接。