原文：http://blog.csdn.net/yoara/article/details/37597141

总有那么一群人，他们默默无闻的工作在自己的岗位上，你永远都接触不到他们，可是离了他们完整的做好一件事。譬如只注意在荧光屏上的明星，却不知道谁给他们打得灯光、谁给他们踩得位、谁给他们化妆端茶送水等等。IoFilter也是这群人中的一员，每个session的请求和事件离不了他们，IoFilter在IoService和IoHandler之间提供了各个层面的切面支持，让其他两个组件安心做自己的事而不用关注其他细节。软件工程的魅力也在于此——解耦。

1.IoFilter的一家子

IoFilter家族的类图结构非常简单明快，mina非常贴心的为广大使用者提供了丰富的Filter实现子类，很多标准服务我们都不需要自己实现。

还有两个FIlter是mina自带并且不为用户管理的，当生成过滤器链自动注入：

HeadFilter（当发生write操作时，将写buffer加入到session.scheduledWriteMessages队列，并执行发送调用IoProcessor执行write()操作），位于过滤器链头。
TailFilter（当所有过滤器都处理完后，他将调用IoHandler的对应方法）。位于过滤器链尾。

2.IoFilter执行顺序

搞清楚了

图5.2 过滤器调用顺序图

在事件端，我们以messageSent事件被执行的代码来详解下过程；在操作端我们的例子是session.write。

2.1 messageSent顺序调用过滤器链

当IoProcessor的remove(session)方法被调用时，该session将被添加进Processor内部的removingSessions的ConcurrentLinkedQueue等待被移除。

public final void remove(S session) {  
    scheduleRemove(session);  
    startupProcessor();  
}  
  
private void scheduleRemove(S session) {  
    removingSessions.add(session);  
}

当IoProcessor工作线程执行一个循环，调用removeSessions()方法，状态为SessionState.OPENED的session将被移除，移除的代码中就包括刷新消息队列，其中代码如下，从而引发一次过滤器链的调用。

if (message instanceof IoBuffer) {  
    IoBuffer buf = (IoBuffer) message;  
    if (buf.hasRemaining()) {  
        buf.reset();  
        failedRequests.add(req);  
    } else {  
        IoFilterChain filterChain = session.getFilterChain();  
        filterChain.fireMessageSent(req);  
    }  
} else {  
    failedRequests.add(req);  
}

最终调用的是TailFilter，他的代码如下：

private static class TailFilter extends IoFilterAdapter {  
  
        public void sessionCreated(NextFilter nextFilter, IoSession session) throws Exception {  
            session.getHandler().sessionCreated(session);  
        }  
  
        public void sessionOpened(NextFilter nextFilter, IoSession session) throws Exception {  
            session.getHandler().sessionOpened(session);  
        }  
  
        public void sessionClosed(NextFilter nextFilter, IoSession session) throws Exception {  
            AbstractIoSession s = (AbstractIoSession) session;  
            try {  
                s.getHandler().sessionClosed(session);  
            } finally {  
                try {  
                    s.getWriteRequestQueue().dispose(session);  
                } finally {  
                    try {  
                        s.getAttributeMap().dispose(session);  
                    } finally {  
                        try {  
                            // Remove all filters.  
                            session.getFilterChain().clear();  
                        } finally {  
                            if (s.getConfig().isUseReadOperation()) {  
                                s.offerClosedReadFuture();  
                            }  
                        }  
                    }  
                }  
            }  
        }  
  
        public void sessionIdle(NextFilter nextFilter, IoSession session, IdleStatus status) throws Exception {  
            session.getHandler().sessionIdle(session, status);  
        }  
  
        public void exceptionCaught(NextFilter nextFilter, IoSession session, Throwable cause) throws Exception {  
            AbstractIoSession s = (AbstractIoSession) session;  
            try {  
                s.getHandler().exceptionCaught(s, cause);  
            } finally {  
                if (s.getConfig().isUseReadOperation()) {  
                    s.offerFailedReadFuture(cause);  
                }  
            }  
        }  
  
        public void messageReceived(NextFilter nextFilter, IoSession session, Object message) throws Exception {  
            session.getHandler().messageReceived(s, message);  
        }  
  
        public void messageSent(NextFilter nextFilter, IoSession session, WriteRequest writeRequest) throws Exception {  
            session.getHandler().messageSent(session, writeRequest.getMessage());  
        }  
  
        public void filterWrite(NextFilter nextFilter, IoSession session, WriteRequest writeRequest) throws Exception {  
            nextFilter.filterWrite(session, writeRequest);  
        }  
  
        public void filterClose(NextFilter nextFilter, IoSession session) throws Exception {  
            nextFilter.filterClose(session);  
        }  
    }

2.2 session.write逆序调用过滤器链

在Handler中持有session的对象，调用session.write(date.toString());，session会调用具体方法：

AbstractIoSession.write(Object message) {  
    ...  
        IoFilterChain filterChain = getFilterChain();  
        filterChain.fireFilterWrite(writeRequest);  
    ...  
    }

DefaultIoFilterChain.fireFilterWrite(WriteRequest writeRequest) {  
        Entry tail = this.tail;  
        callPreviousFilterWrite(tail, session, writeRequest);  
    }

触发逆序的过滤器链，最终到HeadFilter中：

...其他Filter  
HeadFilter.filterWrite(NextFilter nextFilter, IoSession session, WriteRequest writeRequest) throws Exception {  
        AbstractIoSession s = (AbstractIoSession) session;  
        ...  
            WriteRequestQueue writeRequestQueue = s.getWriteRequestQueue();  
  
            if (!s.isWriteSuspended()) {  
                if (writeRequestQueue.size() == 0) {  
                    // We can write directly the message  
                    s.getProcessor().write(s, writeRequest);  
                } else {  
                    s.getWriteRequestQueue().offer(s, writeRequest);  
                    s.getProcessor().flush(s);  
                }  
            } else {  
                s.getWriteRequestQueue().offer(s, writeRequest);  
            }  
        }

3.IoHandler API

Handler虽然是直面用户的对象，但由上述可知，他其实只是整个操作链上最后的一环，也是最简单的一环，给出IoHander的API清单

sessionCreated(IoSession)：session创建时调用
sessionOpened(IoSession)：session打开时调用，实际上是在sessionCreated后立即执行
sessionClosed(IoSession)：session关闭时调用
sessionIdle(IoSession, IdleStatus)：session空闲时调用
exceptionCaught(IoSession, Throwable)：异常时调用
messageReceived(IoSession, Object)：接收到新的request时调用
messageSent(IoSession, Object)：发送在消息队列中未完成的消息时调用

4. IoFilter API

和Handler有一部分一致：

init() filter初始化方法，在下面4个on方法调用之前必须先被调用。
destroy() 该方法被ReferenceCountingFilter引用到，如果不继承ReferenceCountingFilter，不需实现该方法。
onPreAdd(IoFilterChain, String, NextFilter) 过滤器被添加之前调用。
onPostAdd(IoFilterChain, String, NextFilter) 过滤器被添加之后调用。
onPreRemove(IoFilterChain, String, NextFilter) 过滤器被移除之前调用。
onPostRemove(IoFilterChain, String, NextFilter) 过滤器被移除之后调用。
sessionCreated(NextFilter, IoSession)
sessionOpened(NextFilter, IoSession)
sessionClosed(NextFilter, IoSession)
sessionIdle(NextFilter, IoSession, IdleStatus)
exceptionCaught(NextFilter, IoSession, Throwable)
messageReceived(NextFilter, IoSession, Object)
messageSent(NextFilter, IoSession, WriteRequest)
filterClose(NextFilter, IoSession) session.close(）方法中调用。
filterWrite(NextFilter, IoSession, WriteRequest) session.write(）方法中调用。

5. IoListener

上面用了比较多的篇幅介绍了IoFilter，现在我们也该讲讲二号后台人物——IoListerner。在mina中主要有两类，一个是IoServiceListener，另一个就是IoFutureListener。

5.1 IoServiceListener

IoServiceListener负责Service的各个生命周期节点事件通知。我们曾在学习笔记三中提到过IoServiceListenerSupport，此类对象是该service所有IoServiceListener对象的持有类并管理着监听器的回调入口，同时还管理着当前Service的所有session。当时没有详细的介绍，现在我们重点说说这个类在做嫁衣方面的独到之处。     IoServiceListenerSupport是在AbstractIoService的构造函数中被生成的，也就是说，恭喜，无论你是Acceptor还是Connector，你都拥有这个强大的助手了。为了支持监听器的功能，可爱的祖父AbstractIoService还贴心的为我们实现好了addListener(IoServiceListener listener)和removeListener(IoServiceListener listener)方法。     我们先看看的API吧：

serviceActivated(IoService) 当service生效时被调用。当新的service被bind时或第一个session生成时，IoServiceListenerSupport.fireServiceActivated被调用同时调用此方法。
serviceIdle(IoService, IdleStatus) 当service空闲时被调用，不过此方法没有在mina中真正使用。
serviceDeactivated(IoService) 当service失效时被调用。当service被unbind或最后个session注销时，IoServiceListenerSupport.fireServiceDeactivated被调用同时调用此方法。
sessionCreated(IoSession) 当新的session生成时被调用。IoServiceListenerSupport.fireSessionCreated
sessionDestroyed(IoSession) 当session被注销时调用。IoServiceListenerSupport.fireSessionDestroyed

如此一看，还是很简单清晰的，监听器可以在任意时刻被添加或移除。我们的使用方法也很简单：

IoServiceListener listener = new IoServiceListener() {  
    public void sessionDestroyed(IoSession session) throws Exception {  
    }  
    public void sessionCreated(IoSession session) throws Exception {  
    }  
    public void serviceIdle(IoService service, IdleStatus idleStatus)  
            throws Exception {  
    }  
    public void serviceDeactivated(IoService service) throws Exception {  
    }  
    public void serviceActivated(IoService service) throws Exception {  
    }  
};  
acceptor.addListener(listener);  
acceptor.removeListener(listener);

5.1 IoFutureListener

还有一种Listener就是IoFutureListener，他在学习笔记四种也出现过，确实也比较简单，能在IoFuture任务完成后被调用，唯一的API：

1
2
3

public interface IoFutureListener<F extends IoFuture> extends EventListener {    
    void operationComplete(F future);    
}

因为大部分的future都被mina集成在框架里，所以future的listener支持一项特性：若任务已经执行完后添加的listener将被立刻执行。我们先看看future是怎么实现该功能的。

public IoFuture addListener(IoFutureListener<?> listener) {  
    if (listener == null) {  
        throw new IllegalArgumentException("listener");  
    }  
  
    boolean notifyNow = false;  
    synchronized (lock) {  
        if (ready) {  
            notifyNow = true;  
        } else {  
            if (firstListener == null) {  
                firstListener = listener;  
            } else {  
                if (otherListeners == null) {  
                    otherListeners = new ArrayList<IoFutureListener<?>>(1);  
                }  
                otherListeners.add(listener);  
            }  
        }  
    }  
是这里了！如果ready完成了，则马上执行  
    if (notifyNow) {  
        notifyListener(listener);  
    }  
    return this;  
}

那不用说就知道啦，在notiffyListener中将会回调监听器的方法。

6. 结语

mina框架核心部件基本上都讲的差不多了，看看如果有需要补余的，留在下一章节。

mina学习笔记五：做嫁衣的IoFilter和IoListener

2016-09-08
mina