設計模式精講 Day 13：責任鏈模式（Chain of Responsibility Pattern）

【設計模式精講 Day 13】責任鏈模式（Chain of Responsibility Pattern）

文章內容

在“設計模式精講”系列的第13天，我們將深入講解責任鏈模式（Chain of Responsibility Pattern）。這是一種行為型設計模式，它通過將請求的發送者和接收者解耦，使得多個對象都有機會處理請求，從而避免了請求的發送者與接收者之間的緊耦合。

責任鏈模式的核心思想是：將請求的處理過程組織成一個鏈式結構，每個處理節點可以決定是否處理該請求或將其傳遞給下一個節點。這種模式非常適合處理需要多個條件判斷、權限校驗、審批流程等場景，能夠有效提升系統的靈活性和可擴展性。

本篇文章將從理論到實踐全面解析責任鏈模式，包括其定義、結構、適用場景、實現方式、工作原理、優缺點分析，并結合真實項目案例進行深入探討。同時，我們還將展示如何在Java中實現責任鏈模式，并討論其在Java標準庫及主流框架中的應用實例。

模式定義

責任鏈模式（Chain of Responsibility Pattern） 是一種行為型設計模式，它允許你將請求的發送者與接收者解耦。請求通過一系列處理對象進行傳遞，直到某個對象決定處理它為止。每個處理對象都包含對下一個處理對象的引用，形成一條鏈。

該模式的核心思想是：

解耦請求的發送者與接收者
允許多個對象有機會處理請求
動態構建處理鏈

模式結構

責任鏈模式由以下幾個關鍵角色組成：

角色	說明
抽象處理者（Handler）	定義處理請求的接口，通常包含一個指向下一個處理者的引用。
具體處理者（Concrete Handler）	實現具體的處理邏輯，決定是否處理請求或將其傳遞給下一個處理者。
客戶端（Client）	創建處理鏈并發起請求。

類圖結構描述：

+----------------+
|   Handler      |
+----------------+
| - next: Handler|
+----------------+
| + setNext()    |
| + handleRequest()|
+----------------+▲│
+----------------+
| ConcreteHandlerA|
+----------------+
| + handleRequest()|
+----------------+▲│
+----------------+
| ConcreteHandlerB|
+----------------+
| + handleRequest()|
+----------------+

每個具體處理者繼承自抽象處理者，維護一個對下一個處理者的引用。當當前處理者無法處理請求時，它會將請求傳遞給下一個處理者。

適用場景

責任鏈模式適用于以下典型場景：

場景	說明
多級審批流程	如請假審批、報銷申請、合同簽署等，不同層級的審批人按順序處理請求
權限驗證	在系統中對用戶權限進行逐級驗證，如登錄、訪問控制、操作權限等
日志記錄	不同級別的日志信息被不同處理器處理，如調試日志、錯誤日志、審計日志
過濾器鏈	Web開發中的過濾器（Filter）、攔截器（Interceptor）等
事件處理	GUI事件、消息隊列中的消息處理等

這些場景中，請求的處理可能涉及多個步驟，且處理邏輯具有一定的優先級或順序性，此時使用責任鏈模式能有效提高系統的可維護性和可擴展性。

實現方式

下面是一個完整的 Java 示例，演示責任鏈模式的基本實現。

抽象處理者（Handler）

// 抽象處理者
public abstract class Handler {protected Handler next;public void setNext(Handler next) {this.next = next;}// 處理請求的方法public void handleRequest(Request request) {if (canHandle(request)) {doHandle(request);} else if (next != null) {next.handleRequest(request);} else {System.out.println("No handler can process the request.");}}// 判斷是否可以處理該請求protected abstract boolean canHandle(Request request);// 具體處理邏輯protected abstract void doHandle(Request request);
}

具體處理者（Concrete Handler）

// 具體處理者1：處理普通請求
public class ConcreteHandlerA extends Handler {@Overrideprotected boolean canHandle(Request request) {return request.getType() == RequestType.NORMAL;}@Overrideprotected void doHandle(Request request) {System.out.println("ConcreteHandlerA handled the request: " + request.getMessage());}
}// 具體處理者2：處理緊急請求
public class ConcreteHandlerB extends Handler {@Overrideprotected boolean canHandle(Request request) {return request.getType() == RequestType.EMERGENCY;}@Overrideprotected void doHandle(Request request) {System.out.println("ConcreteHandlerB handled the request: " + request.getMessage());}
}

請求類（Request）

// 請求類
public class Request {private RequestType type;private String message;public Request(RequestType type, String message) {this.type = type;this.message = message;}public RequestType getType() {return type;}public String getMessage() {return message;}
}

枚舉類型（RequestType）

// 請求類型枚舉
public enum RequestType {NORMAL,EMERGENCY
}

客戶端調用示例

public class Client {public static void main(String[] args) {// 創建處理鏈Handler handlerA = new ConcreteHandlerA();Handler handlerB = new ConcreteHandlerB();handlerA.setNext(handlerB);// 發起請求Request request1 = new Request(RequestType.NORMAL, "This is a normal request.");Request request2 = new Request(RequestType.EMERGENCY, "This is an emergency request.");handlerA.handleRequest(request1); // 會被ConcreteHandlerA處理handlerA.handleRequest(request2); // 會被ConcreteHandlerB處理}
}

單元測試代碼（JUnit 5）

import org.junit.jupiter.api.Test;
import static org.junit.jupiter.api.Assertions.*;public class ChainOfResponsibilityTest {@Testpublic void testChainOfResponsibility() {Handler handlerA = new ConcreteHandlerA();Handler handlerB = new ConcreteHandlerB();handlerA.setNext(handlerB);Request request1 = new Request(RequestType.NORMAL, "Normal request");Request request2 = new Request(RequestType.EMERGENCY, "Emergency request");handlerA.handleRequest(request1);handlerA.handleRequest(request2);}
}

工作原理

責任鏈模式通過鏈式結構來傳遞請求，每個處理者都擁有對下一個處理者的引用。當請求到達鏈頭時，第一個處理者嘗試處理，如果不能處理，則將請求傳遞給下一個處理者，依此類推。

這種方式的優點在于：

請求的發送者不需要知道具體由哪個處理者處理，只需將請求發送到鏈頭即可。
處理鏈可以動態構建和修改，無需修改請求發送者的代碼。
提高了系統的可擴展性，新增處理者只需加入鏈中，不影響現有邏輯。

優缺點分析

優點	缺點
解耦請求的發送者與接收者	鏈式結構可能導致調試困難
提高系統的靈活性和可擴展性	請求可能未被任何處理者處理，需注意邊界情況
支持動態配置處理鏈	若鏈過長，可能影響性能
易于添加新的處理者	需要合理設計處理順序，否則可能造成邏輯混亂

案例分析：企業審批系統

假設我們正在開發一個企業內部的審批系統，用于處理員工的請假申請。根據請假天數的不同，審批流程也不同：

1天以內：部門經理審批
2~5天：部門經理 + 人事部審批
5天以上：部門經理 + 人事部 + 總經理審批

在這種情況下，使用責任鏈模式可以很好地組織審批流程，而無需在請求發送者中硬編碼審批路徑。

代碼實現

// 抽象處理者
public abstract class ApprovalHandler {protected ApprovalHandler next;public void setNext(ApprovalHandler next) {this.next = next;}public void approve(LeaveRequest request) {if (canApprove(request)) {doApprove(request);} else if (next != null) {next.approve(request);} else {System.out.println("No approver can process the request.");}}protected abstract boolean canApprove(LeaveRequest request);protected abstract void doApprove(LeaveRequest request);
}// 具體處理者：部門經理
public class ManagerApprover extends ApprovalHandler {@Overrideprotected boolean canApprove(LeaveRequest request) {return request.getDays() <= 1;}@Overrideprotected void doApprove(LeaveRequest request) {System.out.println("Manager approved: " + request.getEmployeeName() + " for " + request.getDays() + " days.");}
}// 具體處理者：人事部
public class HRApprover extends ApprovalHandler {@Overrideprotected boolean canApprove(LeaveRequest request) {return request.getDays() > 1 && request.getDays() <= 5;}@Overrideprotected void doApprove(LeaveRequest request) {System.out.println("HR approved: " + request.getEmployeeName() + " for " + request.getDays() + " days.");}
}// 具體處理者：總經理
public class CEOApprover extends ApprovalHandler {@Overrideprotected boolean canApprove(LeaveRequest request) {return request.getDays() > 5;}@Overrideprotected void doApprove(LeaveRequest request) {System.out.println("CEO approved: " + request.getEmployeeName() + " for " + request.getDays() + " days.");}
}// 請求類
public class LeaveRequest {private String employeeName;private int days;public LeaveRequest(String employeeName, int days) {this.employeeName = employeeName;this.days = days;}public String getEmployeeName() {return employeeName;}public int getDays() {return days;}
}// 客戶端
public class LeaveApprovalSystem {public static void main(String[] args) {ApprovalHandler manager = new ManagerApprover();ApprovalHandler hr = new HRApprover();ApprovalHandler ceo = new CEOApprover();manager.setNext(hr);hr.setNext(ceo);LeaveRequest request1 = new LeaveRequest("Alice", 1);LeaveRequest request2 = new LeaveRequest("Bob", 3);LeaveRequest request3 = new LeaveRequest("Charlie", 7);manager.approve(request1); // 被部門經理處理manager.approve(request2); // 被人事部處理manager.approve(request3); // 被總經理處理}
}

在這個案例中，責任鏈模式清晰地表達了審批流程的層次結構，使系統更易于維護和擴展。例如，若以后需要增加新的審批級別，只需添加一個新的處理者并將其鏈接到鏈中即可。

與其他模式的關系

責任鏈模式常常與其他設計模式結合使用，以增強其功能或解決更復雜的問題：

模式	關系說明
命令模式（Command Pattern）	命令模式封裝請求為對象，責任鏈模式則處理請求鏈，二者可以結合使用，實現靈活的請求處理機制
觀察者模式（Observer Pattern）	責任鏈模式關注請求的傳遞，而觀察者模式關注事件的通知，二者可以協同工作，實現事件驅動的系統
策略模式（Strategy Pattern）	責任鏈模式強調處理鏈的順序，而策略模式強調算法的替換，兩者可以配合使用，實現不同的處理策略
裝飾器模式（Decorator Pattern）	責任鏈模式和裝飾器模式都采用組合方式擴展對象功能，但責任鏈模式更關注請求的處理流程，而裝飾器模式更關注對象的行為增強

總結

今天我們學習了責任鏈模式的核心思想、結構、適用場景、實現方式、工作原理、優缺點分析，并通過實際項目案例進行了深入講解。責任鏈模式通過解耦請求的發送者與接收者，使得多個對象有機會處理請求，提升了系統的靈活性和可擴展性。

在Java中，責任鏈模式可以通過抽象類和鏈式引用實現，適用于審批流程、權限驗證、日志處理等多種場景。此外，責任鏈模式還可以與其他設計模式（如命令模式、觀察者模式）結合使用，進一步增強系統的功能和可維護性。

下一天我們將進入“設計模式精講”的第14天，講解命令模式（Command Pattern），敬請期待！

文章標簽

design-patterns, java, software-architecture, oop, chain-of-responsibility

文章簡述

本文詳細介紹了設計模式中的責任鏈模式（Chain of Responsibility Pattern），通過理論與實踐結合的方式，幫助Java開發工程師理解其核心思想、實現方式以及應用場景。文章提供了完整的Java代碼示例，展示了如何構建責任鏈結構，并通過企業審批系統的真實案例說明其實際價值。責任鏈模式通過解耦請求的發送者與接收者，提高了系統的靈活性和可擴展性，特別適合多級審批、權限驗證、日志處理等場景。本文不僅涵蓋了模式的基本概念，還深入分析了其與其它設計模式的關系，并提供了單元測試代碼，確保讀者能夠直接應用到實際項目中。