一、責任鏈模式的本來面目

Mina 中有一個重要的設計模式-責任鏈模式，它將此模式成功的應用在了它的過濾器鏈（IoFilterChain）中。開發過J2EE的童鞋們應該對這個模式比較清楚，在Servlet中我們就可以加入Filter的實現，還有Hibernate中也實現了FilterChain。學習怎麼實現責任鏈模式對於我們對開源軟體的學習和以後的工作都會有莫大的幫助。

我們知道計算機系統就是接收資訊，進行資訊處理，資訊輸出的過程，那麼在這個過程中我們加入過濾器有很多好處，訊息經過特定功能的多個過濾器進行逐步處理得到所需要的最終資訊，讓處理過程透明，責任明晰，方便擴充套件。

責任鏈模式的定義我也就不說了，網上一大堆，我的理解是可以把它理解成一個有向連結串列，訊息在這個連結串列中的某個過濾器進行處理然後再傳向下個過濾器，在每個過濾器中都可以處理這些訊息，也可以不處理。如圖：

責任鏈模式的類圖如下：

其實這裡面最核心的就是Handler了，它可是是一個介面或者是一個抽象類，它有對自己的一個引用successor，然後有個處理方法HandleRequest()。因為有了對自己的引用successor所以當本物件不能處理的時候可以轉向successor.HandleRequest()方法，這樣一個“鏈”就形成了。

你應該挺羨慕富士.康裡面生產蘋果手機的工人吧，你平時最喜歡的蘋果手機就是他們生產出來的，他們一個人就能把蘋果手機生產出來嗎？不是的，他們是流水線做業的，OK，流水線就可以看做是責任鏈模式的體現，工人就是鏈條上的一員，有的工人組裝螢幕，有的工人檢查手機，有的工人進行手機的包裝等，下面我們就以程式碼的方式實現：

蘋果手機類：

package com.lifanghu.chain;

/**
 * @author lifh
 * @mail [email protected]
 * @since 2012-6-12 下午11:20:18
 * @name com.lifanghu.chain.Iphone.java
 * @version 1.0
 */

public class Iphone {

    private String state = "我是一臺蘋果機器；";

    public String getState() {
        return state;
    }

    public void setState(String state) {
        this.state = state;
    }

}
 

抽象處理介面類：

package com.lifanghu.chain;



/**
 * @author  lifh
 * @mail    [email protected]
 * @since   2012-6-12 下午11:23:36
 * @name    com.lifanghu.chain.IWorker.java
 * @version 1.0
 */

public interface IWorker {

    /**
     * 處理方法
     * @param iphone
     * @author lifh
     */
    void handleIphone(Iphone iphone);
    /**
     * 設定下一個處理者
     * @param worker
     * @author lifh
     */
    void setNext(IWorker worker);
}

具體處理者：

package com.lifanghu.chain;

/**
 * @author lifh
 * @mail [email protected]
 * @since 2012-6-12 下午11:29:46
 * @name com.lifanghu.chain.Worker1.java
 * @version 1.0
 */

public class Worker1 implements IWorker {

    private IWorker next;

    public void handleIphone(Iphone iphone) {
        iphone.setState(iphone.getState() + "我被裝了一個黑色的後蓋；");
        if (next != null)
            next.handleIphone(iphone);
    }

    public void setNext(IWorker worker) {
        this.next = worker;

    }

}
package com.lifanghu.chain;

/**
 * @author lifh
 * @mail [email protected]
 * @since 2012-6-12 下午11:34:32
 * @name com.lifanghu.chain.Worker2.java
 * @version 1.0
 */

public class Worker2 implements IWorker {

    private IWorker next;

    public void handleIphone(Iphone iphone) {
        iphone.setState(iphone.getState() + "我被裝了一塊電池；");
        if (next != null)
            next.handleIphone(iphone);
    }

    public void setNext(IWorker worker) {
        this.next = worker;
    }
}
package com.lifanghu.chain;

/**
 * @author lifh
 * @mail [email protected]
 * @since 2012-6-12 下午11:34:32
 * @name com.lifanghu.chain.Worker3.java
 * @version 1.0
 */

public class Worker3 implements IWorker {

    private IWorker next;

    public void handleIphone(Iphone iphone) {
        iphone.setState(iphone.getState() + "我現在是一臺完整的Iphone了。");
        if (next != null)
            next.handleIphone(iphone);
    }

    public void setNext(IWorker worker) {
        this.next = worker;
    }
}

客戶端呼叫者：

package com.lifanghu.chain;

/**
 * @author lifh
 * @mail [email protected]
 * @since 2012-6-12 下午11:37:27
 * @name com.lifanghu.chain.Client.java
 * @version 1.0
 */

public class Client {

    public static void main(String[] args) {
        IWorker worker1 = new Worker1();
        IWorker worker2 = new Worker2();
        IWorker worker3 = new Worker3();

        worker1.setNext(worker2);
        worker2.setNext(worker3);
        Iphone iphone = new Iphone();
        worker1.handleIphone(iphone);

        System.out.println(iphone.getState());
    }
}

輸出結果：

好了，現在一臺蘋果就組裝完成了，發現了沒有，我們的程式碼比較整潔清新，沒有大量的if/else語句，責任清晰明瞭，呼叫簡單，想要擴充套件的話只需要再實現IWorker介面即可，這就是使用責任鏈模式的好處。

二、Mina是怎麼實現責任鏈模式的

上面介紹了純淨的責任鏈模式，但是在真實的專案中寫程式碼不可能完全照搬，所以多看看開源專案的程式碼寫作方式也許才能真正提高我們的程式設計能力。就以Mina的過濾器鏈來看，對這種模式進行了自己的實現，但是道理是相通的，帶著責任鏈模式的理解去看看Mina的實現是怎樣的。

先看一下Mina過濾器的類圖結構：

從圖中我們可以看出Mina對於此模式的實現是相對比較複雜的，其實從它的程式碼上也可以看出來，當時也是花了好大力氣才把它這塊看明白，其實主要在於理清思路，抓住核心類，最主要的一個介面IoFilterChain和它的一個內部介面Entry，其中IoFilterChain代表了過濾器的容器，它本身就是一個物件引用形成的連結串列結構,預設的實現DefaultIoFilterChain其實有對連結串列頭（head）的引用，找到頭後就可以順著頭向下找，一直找到尾(tail),Entry是對IoFilter和NextFilter的封裝整合介面，它屬於連結串列IoFilterChain中的元素。指向當前和下一個過濾器。

EntryImpl 類中包含兩個介面，filter和nextFilter，他們所用的介面是不一樣的，至於為什麼不用同一個介面，我想可能是因為介面職責單一的原則吧。

雖然有IoFilter和NextFilter兩個介面，介面方法都差不多，但最後真正業務的執行者還是IoFilter的實現，IoFilterAdapter做為它的預設實現，完成了介面卡的功能，以後的類可以直接繼承它而不用實現IoFilter介面，想實現哪個方法只需要覆蓋IoFilterAdapter的類的方法即可。NextFilter只起到轉發的作用，如訊息接收處理方法（messageReceived）：

NextFilter的實現：

//訊息接收到以後NextFilter的實現會把訊息傳遞給nextEntry去處理。
public void messageReceived(IoSession session, Object message) {
    Entry nextEntry = EntryImpl.this.nextEntry;
    callNextMessageReceived(nextEntry, session, message);
}

DefaultIoFilterChain再將訊息傳遞給本Filter的messageReceived方法進行實際的訊息接收處理工作：

private void callNextMessageReceived(Entry entry, IoSession session,
        Object message) {
    try {
        IoFilter filter = entry.getFilter();
        NextFilter nextFilter = entry.getNextFilter();
        //本過濾器進行資料處理，完成後再把訊息傳向下個過濾器
        filter.messageReceived(nextFilter, session,
                message);
    } catch (Throwable e) {
        fireExceptionCaught(e);
    }
}

當訊息處理完成以後，訊息就要進入到業務處理IoHandler的實現類中去完成業務的相關操作了。這可以在鏈尾看到相關業務傳遞：

@Override
public void messageReceived(NextFilter nextFilter, IoSession session, Object message) throws Exception {
    AbstractIoSession s = (AbstractIoSession) session;
    if (!(message instanceof IoBuffer)) {
        s.increaseReadMessages(System.currentTimeMillis());
    } else if (!((IoBuffer) message).hasRemaining()) {
        s.increaseReadMessages(System.currentTimeMillis());
    }

    try {
        // 最後一個filter會進入到handler進行訊息處理。
        session.getHandler().messageReceived(s, message);
    } finally {
        if (s.getConfig().isUseReadOperation()) {
            s.offerReadFuture(message);
        }
    }
}

至此，Mina的連結串列結構就基本講完了，其實仔細看看它的程式碼還是比較容易理解的，可能裡面有些細節還需要我們去琢磨。

連結串列建立了以後，外界是怎樣呼叫的呢？

在org.apache.mina.core.filterchain包下我們可以看到類IoFilterEvent，可以看到它實現了基於事件的處理模型，當一個事件（比如接收到訊息）發生後會觸發相應的事件，進而呼叫過濾器鏈的訊息處理功能進行訊息的處理和轉發，這塊其實會有執行緒池的參與完成，會在以後的文章中說明這塊。

public void fire() {
    IoSession session = getSession();
    NextFilter nextFilter = getNextFilter();
    IoEventType type = getType();

    if (DEBUG) {
        LOGGER.debug( "Firing a {} event for session {}",type, session.getId() );
    }

    switch (type) {
    case MESSAGE_RECEIVED:
        //觸發訊息接收
        Object parameter = getParameter();
        nextFilter.messageReceived(session, parameter);
        break;

當然也可以直接呼叫：

//觸發過濾器的接收訊息處理
session.getFilterChain().fireMessageReceived(newBuf);

 還有一個類DefaultIoFilterChainBuilder，它以使用者更易用的角度完成了對過濾器鏈的封裝操作，這裡就不細講了。

總結：本文章主要講了責任鏈模式在Mina中的實現，做為一個優秀的框架我們沒理由不好好去學習。

每天進步一點點，不做無為的碼農。。。。。

2012年6月13日星期三

碼農虎虎

[email protected]