Chain of Responsibility定義
Chain of Responsibility(CoR) 是用一系列類(classes)試圖處理一個請求request,這些類之間是一個鬆散的耦合,唯一共同點是在他們之間傳遞request. 也就是說，來了一個請求，A類先處理，如果沒有處理，就傳遞到B類處理，如果沒有處理，就傳遞到C類處理，就這樣象一個鏈條(chain)一樣傳遞下去。過濾器就用到了。
如何使用?
雖然這一段是如何使用CoR,但是也是演示什麼是CoR.
有一個Handler介面:
public interface Handler{
public void handleRequest();
}
這是一個處理request的事例， 如果有多種request,比如 請求幫助 請求列印 或請求格式化：
最先想到的解決方案是：在介面中增加多個請求：
public interface Handler{
public void handleHelp();
public void handlePrint();
public void handleFormat();
}
具體是一段實現介面Handler程式碼：
public class ConcreteHandler implements Handler{
private Handler successor;
public ConcreteHandler(Handler successor){
this.successor=successor;
}
public void handleHelp(){
//具體處理請求Help的程式碼
...
}
public void handlePrint(){
//如果是print 轉去處理Print
successor.handlePrint();
}
public void handleFormat(){
//如果是Format 轉去處理format
successor.handleFormat();
}
}
一共有三個這樣的具體實現類，上面是處理help,還有處理Print 處理Format這大概是我們最常用的程式設計思路。
雖然思路簡單明瞭，但是有一個擴充套件問題，如果我們需要再增加一個請求request種類,需要修改介面及其每一個實現。
原文連結：http://www.jdon.com/designpatterns/cor.htm
第二方案:將每種request都變成一個介面，因此我們有以下程式碼 ：
public interface HelpHandler{
public void handleHelp();
}
public interface PrintHandler{
public void handlePrint();
}
public interface FormatHandler{
public void handleFormat();
}
public class ConcreteHandler
implements
HelpHandler,PrintHandler,FormatHandlet{
private HelpHandler helpSuccessor;
private PrintHandler printSuccessor;
private FormatHandler formatSuccessor;
public ConcreteHandler(HelpHandler helpSuccessor,PrintHandler printSuccessor,FormatHandler formatSuccessor)
{
this.helpSuccessor=helpSuccessor;
this.printSuccessor=printSuccessor;
this.formatSuccessor=formatSuccessor;
}
public void handleHelp(){
.......
}
public void handlePrint(){this.printSuccessor=printSuccessor;}
public void handleFormat(){this.formatSuccessor=formatSuccessor;}
}
這個辦法在增加新的請求request情況下，只是節省了介面的修改量，介面實現ConcreteHandler還需要修改。而且程式碼顯然不簡單美麗。
解決方案3: 在Handler介面中只使用一個引數化方法：
public interface Handler{
public void handleRequest(String request);
}
那麼Handler實現程式碼如下：
public class ConcreteHandler implements Handler{
private Handler successor;
public ConcreteHandler(Handler successor){
this.successor=successor;
}
public void handleRequest(String request){
if (request.equals("Help")){
//這裡是處理Help的具體程式碼
}else
//傳遞到下一個
successor.handle(request);
}
}
}
這裡先假設request是String型別，如果不是怎麼辦？當然我們可以建立一個專門類Request
最後解決方案:介面Handler的程式碼如下：
public interface Handler{
public void handleRequest(Request request);
}
Request類的定義:
public class Request{
private String type;
public Request(String type){this.type=type;}
public String getType(){return type;}
public void execute(){
//request真正具體行為程式碼
}
}
那麼Handler實現程式碼如下：
public class ConcreteHandler implements Handler{
private Handler successor;
public ConcreteHandler(Handler successor){
this.successor=successor;
}
public void handleRequest(Request request){
if (request instanceof HelpRequest){
//這裡是處理Help的具體程式碼
}else if (request instanceof PrintRequst){
request.execute();
}else
//傳遞到下一個
successor.handle(request);
}
}
}
這個解決方案就是CoR, 在一個鏈上,都有相應職責的類,因此叫Chain of Responsibility.
CoR的優點：
因為無法預知來自外界（客戶端）的請求是屬於哪種型別，每個類如果碰到它不能處理的請求只要放棄就可以。
缺點是效率低，因為一個請求的完成可能要遍歷到最後才可能完成，當然也可以用樹的概念優化。 在Java AWT1.0中，對於滑鼠按鍵事情的處理就是使用CoR,到Java.1.1以後，就使用Observer代替CoR
擴充套件性差，因為在CoR中，一定要有一個統一的介面Handler.侷限性就在這裡。
與Command模式區別：
Command 模式需要事先協商客戶端和伺服器端的呼叫關係，比如 1 代表 start 2 代表 move 等，這些 都是封裝在 request 中，到達伺服器端再分解。
CoR 模式就無需這種事先約定，伺服器端可以使用 CoR 模式進行客戶端請求的猜測，一個個猜測 試驗。
一段程式碼：
該程式碼實現了依次呼叫所有過濾器類的過濾方法的前半部分然後呼叫Action最後再倒過來呼叫所有過濾器的過濾方法的後半部分。
過濾器介面：
public interface Interceptor {
public void intercept(ActionInvocation invocation) ;
}
入口：
public class Main {
public static void main(String[] args) {
new ActionInvocation().invoke();
}
}
過濾器呼叫控制器：
import java.util.ArrayList;
import java.util.List;
public class ActionInvocation {
List<Interceptor> interceptors = new ArrayList<Interceptor>();
int index = -1;
Action a = new Action();
public ActionInvocation() {
this.interceptors.add(new FirstInterceptor());
this.interceptors.add(new SecondInterceptor());
}
public void invoke() {
index ++;
if(index >= this.interceptors.size()) {
a.execute();
}else {
this.interceptors.get(index).intercept(this);
}
}
}
兩個過濾器：
public class FirstInterceptor implements Interceptor {
public void intercept(ActionInvocation invocation) { System.out.println(1); invocation.invoke(); System.out.println(-1); }
}
public class SecondInterceptor implements Interceptor {
public void intercept(ActionInvocation invocation) { System.out.println(2); invocation.invoke(); System.out.println(-2); }
}
要過濾的Action：
public class Action {
public void execute() {
System.out.println("execute!");
}
}