Design Patterns 入門 - 職責鏈（Chain of Responsibility） [精華]

未明确核心内容，暂无法精准拟题

最新推荐文章于 2025-06-25 17:43:19 发布

原创最新推荐文章于 2025-06-25 17:43:19 发布 · 982 阅读

0 ·

CC 4.0 BY-SA版权

文章标签：

#input #class #character #string #exception #import

java 专栏收录该内容

14 篇文章

订阅专栏

Design Patterns 入門 - 職責鏈（Chain of Responsibility） [精華]

其實職責鏈（Chain of Responsibility）的概念，即使是一個剛學程式設計的新手也會用到，一個簡單的 if...else if ... else 流程控制就有職責鏈的概念：

if(/* 符合請求條件一 */)
    // 執行請求一
else if(/* 符合請求條件二 */)
    // 執行請求二
else
    // 執行預設請求或顯示訊息

這是從結構化程式設計的觀點來看職責鏈的概念，若使用物件的觀點來看職責鏈的話，有一個較佳的例子就是Java的例外處理機制，當程式中發生例外時，也比會catch所捕捉的例外是否符合，如果符合就執行所設定的處理，如果都沒有比對到適當的例外物件，就會將例外丟出try...catch區塊之外。

在Gof的書中給定職責鏈的目的為：使多個物件都有機會處理請求，以避免請求的發送者與接收者之間的耦合關係，將這些物件組合為一個鏈，並沿著這個鏈傳遞該請求，直到有物件處理它為止。

我們先用一個例子來說明使用if...else的方式來處理請求：

public interface Handler {
    public void handle();
}

public class HandleSymbol implements Handler {
    public void handle() {
       System.out.println("Symbol has been handled");
    }
}

public class HandleCharacter implements Handler {
    public void handle() {
       System.out.println("Character has been handled");
    }
}

public class HandleNumber implements Handler {
    public void handle() {
       System.out.println("Number has been handled");
    }
}

import java.io.*;
public class Main {
   public void chains() throws Exception {
       System.out.print("Press any key then return: ");
       char input = (char)System.in.read();

       Handler request = null;
       if (Character.isLetter(input))
         request= new HandleCharacter();
       else if (Character.isDigit(input))
          request= new HandleNumber();
       else
          request= new HandleSymbol();
       request.handle();
   }

   public static void main(String[] args) throws IOException {
          new Test().chains();
   }
}

執行結果：

Press any key then return: x
Character has been handled

這是一個很簡單的程式，可以判定您所輸入的是數字、字元或是符號，如果我們將之以物件的方式來組織物件之間的職責，我們可以將程式改寫如下：

public class Handler {
    private Handler successor;
                                                                                
    public void setSuccessor(Handler successor) {
        this.successor = successor;
    }
                                                                                
    public Handler getSuccessor() {
        return successor;
    }
                                                                                
    public void handleRequest(char input) {
        if(successor != null)
            successor.handleRequest(input);
    }
}

public class HandleNumber extends Handler {
    public void handleRequest(char input) {
        if(Character.isDigit(input)) {
            System.out.println("Number has been handled");
        }
        else
            getSuccessor().handleRequest(input);
    }
}

public class HandleCharacter extends Handler {
    public void handleRequest(char input) {
        if(Character.isLetter(input)) {
            System.out.println("Character has been handled");
        }
        else
            getSuccessor().handleRequest(input);
    }
}

public class HandleSymbol extends Handler {
    public void handleRequest(char input) {
        System.out.println("Symbol has been handled");
    }
}

import java.io.*;
                                                                                
public class Main {
    public static void main(String[] args) throws IOException {
        Handler numberHandler = new HandleNumber();
        Handler characterHandler = new HandleCharacter();
        Handler symbolHandler = new HandleSymbol();
                                                                                
        numberHandler.setSuccessor(characterHandler);
        characterHandler.setSuccessor(symbolHandler);
                                                                                
        System.out.print("Press any key then return: ");
        char input = (char)System.in.read();
        numberHandler.handleRequest(input);
    }
}

在組織物件之間的職責時，通常是從細粒度至粗粒度的方式來組織，從特殊到抽象化，就像程式中將數字視為字元的特殊化，字元又為符號的特殊化。

職責鏈的UML結構圖如下所示：

從物件執行請求的時間來看，其運作是很簡單的職責傳遞而已，如下：

我們所舉的例子在請求上是很簡單的，只是比對輸入的型態，在更一般的情況下，可以將請求包裝為一個物件，並提供getType()之間的方法，以讓職責鏈中的物件進行比對，例如：

public class Request{
　　private String type;

　　public Request(String type){this.type=type;}

　　public String getType(){return type;}

　　public void execute(){
            // 執行請求
　　}
}

在Gof的書中所舉的例子為輔助說明系統，在一個介面中希望使用者一定可以得到相關的說明主題，如果子元件有說明的話，就顯示相關說明，否則的話就轉發給包括它的容器元件或父元件，以保證使用者的輔助說明請求一定可以得到回應。

Where would you want to go?
http://www.javaworld.com.tw/confluence/homepage.action
http://www.caterpillar.onlyfun.net/phpBB2/