Java責任鏈模式（ChainofResponsibility模式）

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,比如 請求幫助 請求列印 或請求格式化：

◆ 最先想到的解決方案是：在介面中增加多個請求：

1. public interface Handler{

2. public void handleHelp();

3. public void handlePrint();

4. public void handleFormat();

5. }

具體是一段實現介面Handler程式碼：

1. public class ConcreteHandler implements Handler{

2. private Handler successor;

3. public ConcreteHandler(Handler successor){

4. this.successor=successor;

5. }

6. public void handleHelp(){

7. //具體處理請求Help的程式碼

8. …

9. }

11. public void handlePrint(){

12. //如果是print 轉去處理Print

13. 　　　　successor.handlePrint();

14. }

15. public void handleFormat(){

16. //如果是Format 轉去處理format

17. 　　　　successor.handleFormat();

18. }

20. }

一共有三個這樣的具體實現類，上面是處理help,還有處理Print 處理Format這大概是我們最常用的程式設計思路。

雖然思路簡單明瞭，但是有一個擴充套件問題，如果我們需要再增加一個請求request種類,需要修改介面及其每一個實現。

◆ 第二方案：將每種request都變成一個介面，因此我們有以下程式碼 ：

1. public interface HelpHandler{

2. public void handleHelp();

3. }

4. public interface PrintHandler{

5. public void handlePrint();

6. }

8. public interface FormatHandler{

9. public void handleFormat();

10. }

12. public class ConcreteHandler

13. implements HelpHandler,PrintHandler,FormatHandlet{

14. private HelpHandler helpSuccessor;

15. private PrintHandler printSuccessor;

16. private FormatHandler formatSuccessor;

18. public ConcreteHandler(HelpHandler helpSuccessor,PrintHandler printSuccessor,FormatHandler 　　　　　　　　　　　　formatSuccessor)

19. {

20. this.helpSuccessor=helpSuccessor;

21. this.printSuccessor=printSuccessor;

22. this.formatSuccessor=formatSuccessor;

23. }

25. public void handleHelp(){

26. …….

27. }

29. public void handlePrint(){this.printSuccessor=printSuccessor;}

31. public void handleFormat(){this.formatSuccessor=formatSuccessor;}

33. }

這個辦法在增加新的請求request情況下，只是節省了介面的修改量，介面實現ConcreteHandler還需要修改。而且程式碼顯然不簡單美麗。

◆ 解決方案3：在Handler介面中只使用一個引數化方法：

1. public interface Handler{

2. public void handleRequest(String request);

3. }

那麼Handler實現程式碼如下：

1. public class ConcreteHandler implements Handler{

2. private Handler successor;

3. public ConcreteHandler(Handler successor){

4. this.successor=successor;

5. }

7. public void handleRequest(String request){

8. if (request.equals("Help")){

9. //這裡是處理Help的具體程式碼

10. }else

11. //傳遞到下一個

12. 　　　　　　successor.handle(request);

14. }

15. }

17. }

這裡先假設request是String型別，如果不是怎麼辦？當然我們可以建立一個專門類Request

◆ 最後解決方案：介面Handler的程式碼如下：

1. public interface Handler{

2. public void handleRequest(Request request);

3. }

Request類的定義：

1. public class Request{

2. private String type;

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

5. public String getType(){return type;}

7. public void execute(){

8. //request真正具體行為程式碼

9. }

10. }

那麼Handler實現程式碼如下：

1. public class ConcreteHandler implements Handler{

2. private Handler successor;

3. public ConcreteHandler(Handler successor){

4. this.successor=successor;

5. }

7. public void handleRequest(Request request){

8. if (request instanceof HelpRequest){

9. //這裡是處理Help的具體程式碼

10. }else if (request instanceof PrintRequst){

11. 　　　　　　request.execute();

12. }else

13. //傳遞到下一個

14. 　　　　　　successor.handle(request);

16. }

17. }

19. }

這個解決方案就是CoR，在一個鏈上，都有相應職責的類，因此叫Chain of Responsibility。

• CoR的優點：因為無法預知來自外界的請求是屬於哪種型別，每個類如果碰到它不能處理的請求只要放棄就可以。無疑這降低了類之間的耦合性。

• CoR的缺點是效率低，因為一個請求的完成可能要遍歷到最後才可能完成，當然也可以用樹的概念優化。 在Java AWT1.0中，對於滑鼠按鍵事情的處理就是使用CoR,到Java.1.1以後，就使用Observer代替CoR。 擴充套件性差，因為在CoR中，一定要有一個統一的介面Handler.侷限性就在這裡。

原文釋出時間為：2018-08-30

本文作者：HARRIES

本文來自雲棲社群合作伙伴“Java雜記”，瞭解相關資訊可以關注“Java雜記”。