設計模式之不一樣的責任鏈模式
責任鏈模式（Chain of Responsibility Pattern）是一種行為型設計模式，它通過將請求的發送者和接收者解耦，使多個對象都有機會處理請求。在這個模式中，請求沿著一個處理鏈依次傳遞，直到有一個對象能夠處理它為止。
本文將詳細介紹責任鏈模式的概述、應用場景以及代碼示例，來幫助讀者更好地理解和應用這個模式。
1. 簡介
模式概述
責任鏈模式的核心思想是將請求的發送者和接收者解耦，使得多個對象都有機會處理請求。在責任鏈模式中，請求會沿著一個處理鏈依次傳遞，每個處理者都有機會處理請求，如果一個處理者不能處理請求，則將請求傳遞給下一個處理者，直到有一個處理者能夠處理它。
責任鏈模式包含以下幾個角色：
責任鏈模式類結構
- 抽象處理者（Handler）：定義了處理請求的接口，通常包含一個指向下一個處理者的引用，用于將請求傳遞給下一個處理者。
- 具體處理者（ConcreteHandler）：實現了處理請求的接口，具體處理者可以決定是否處理請求，如果不能處理，則將請求傳遞給下一個處理者。
- 客戶端（Client）：創建處理者對象并組成責任鏈的結構，負責將請求發送給第一個處理者。
優點與缺點
優點：
- 責任鏈模式可以實現請求的發送者和接收者之間的解耦。發送者只需要將請求發送給第一個處理者，無需關心具體是哪個處理者來處理。這樣，系統的靈活性大大增強，可以隨時增加或修改處理者的順序。
- 責任鏈模式能夠避免請求的發送者和接收者之間的緊耦合。每個處理者只需要關心自己負責的請求類型，無需關心其他請求。這樣，系統的可維護性也得到了提升。
- 責任鏈模式可以靈活地動態添加或刪除處理者。我們可以根據實際情況來調整責任鏈的結構，以滿足不同的業務需求。
缺點：
- 復雜度會明顯提升，如果責任鏈過長或者處理者之間的關系復雜，可能還會導致性能下降和調試困難。
應用場景
責任鏈模式在許多不同的應用場景中都有廣泛的應用。下面列舉了一些常見的應用場景：
- 請求處理鏈：當一個請求需要經過多個處理步驟或處理者進行處理時，可以使用責任鏈模式。每個處理者負責一部分邏輯，處理完后可以選擇將請求傳遞給下一個處理者，從而形成一個處理鏈。
- 日志記錄：在日志系統中，可以使用責任鏈模式來記錄日志。不同的處理者可以負責不同級別的日志記錄，例如，一個處理者負責記錄錯誤日志，另一個處理者負責記錄調試日志，然后按照鏈式結構傳遞日志。
- 身份驗證和權限檢查：在身份驗證和權限檢查系統中，可以使用責任鏈模式來驗證用戶的身份和權限。每個處理者可以檢查特定的條件，例如用戶名和密碼的正確性、賬戶是否鎖定等。如果一個處理者無法通過驗證，可以將請求傳遞給下一個處理者。
- 數據過濾和轉換：在數據處理過程中，可以使用責任鏈模式來進行數據過濾和轉換。每個處理者可以根據特定的條件過濾數據或對數據進行轉換，然后將處理后的數據傳遞給下一個處理者。
- 錯誤處理和異常處理：在錯誤處理和異常處理系統中，可以使用責任鏈模式來處理錯誤和異常。不同的處理者可以處理不同類型的錯誤或異常，并根據需要將錯誤或異常傳遞給下一個處理者進行進一步處理或記錄。
2. Java 代碼示例
在 Java 中實現責任鏈模式有多種方式，包括基于接口、基于抽象類、基于注解等。下面將詳細介紹基于接口的常見實現方式。
基于接口的實現方式是通過定義一個處理請求的接口，每個處理者實現這個接口，并在自己的實現中決定是否處理請求和傳遞請求給下一個處理者。
首先，我們定義一個處理請求的接口 Handler 以及請求入參 Request：
public interface Handler {
void handleRequest(Request request);
}
public class Request {
private String type;
// 省略getter、setter
}然后，我們創建3個具體的處理者類實現這個接口，在具體處理者類的實現中，首先判斷自己是否能夠處理請求，如果能夠處理，則進行處理；否則將請求傳遞給下一個處理者。代碼如下：
public class ConcreteHandlerA implements Handler {
private Handler successor;
public void setSuccessor(Handler successor) {
this.successor = successor;
}
public void handleRequest(Request request) {
if (request.getType().equals("A")) {
// 處理請求的邏輯
} else if (successor != null) {
successor.handleRequest(request);
}
}
}
public class ConcreteHandlerB implements Handler {
private Handler successor;
public void setSuccessor(Handler successor) {
this.successor = successor;
}
public void handleRequest(Request request) {
if (request.getType().equals("B")) {
// 處理請求的邏輯
} else if (successor != null) {
successor.handleRequest(request);
}
}
}
public class ConcreteHandlerC implements Handler {
private Handler successor;
public void setSuccessor(Handler successor) {
this.successor = successor;
}
public void handleRequest(Request request) {
if (request.getType().equals("C")) {
// 處理請求的邏輯
} else if (successor != null) {
successor.handleRequest(request);
}
}
}接下來，我們創建一個客戶端類 Client，用于創建處理者對象并組成責任鏈的結構：
public class Client {
public static void main(String[] args) {
Handler handlerA = new ConcreteHandlerA();
Handler handlerB = new ConcreteHandlerB();
Handler handlerC = new ConcreteHandlerC();
handlerA.setSuccessor(handlerB);
handlerB.setSuccessor(handlerC);
// 創建請求并發送給第一個處理者
Request request = new Request("A");
handlerA.handleRequest(request);
}
}在客戶端類中，我們創建了具體的處理者對象，并通過 setSuccessor() 方法將它們組成一個責任鏈的結構。然后，創建一個請求對象，并將請求發送給第一個處理者。
基于接口的實現方式簡單直觀，每個處理者只需要實現一個接口即可。但是它的缺點是如果責任鏈較長，需要創建多個處理者對象，增加了系統的復雜性和資源消耗。下面基于 Spring 框架實現一個高級版的責任鏈模式。
3. Spring 代碼示例
在實際開發中，一個請求會在多個處理器之間流轉，每個處理器都可以處理請求。
假設我們有一個 Spring 框架開發的訂單處理系統，訂單需要依次經過訂單檢查、庫存處理、支付處理。如果某個處理環節無法處理訂單，將會終止處理并返回錯誤信息，只有每個處理器都完成了請求處理，這個訂單才算法下單成功。
首先，我們定義一個訂單類 Order：
@Data
@AllArgsConstructor
public class orderNo {
private String orderNumber;
private String paymentMethod;
private boolean stockAvailability;
private String shippingAddress;
}然后，我們定義一個抽象訂單處理者類 OrderHandler：
public abstract class OrderHandler {
public abstract void handleOrder(Order order);
}接下來，我們創建具體的訂單處理者類繼承自抽象訂單處理者類，實現相應的方法，并注冊到 Spring 中，
@Component
public class CheckOrderHandler extends OrderHandler {
public void handleOrder(Order order) {
if (StringUtils.isBlank(order.getOrderNo())) {
throw new RuntimeException("訂單編號不能為空");
}
if (order.getPrice().compareTo(BigDecimal.ONE) <= 0) {
throw new RuntimeException("訂單金額不能小于等于0");
}
if (StringUtils.isBlank(order.getShippingAddress())) {
throw new RuntimeException("收貨地址不能為空");
}
System.out.println("訂單參數檢驗通過");
}
}
@Component
public class StockHandler extends OrderHandler {
public void handleOrder(Order order) {
if (!order.isStockAvailability()) {
throw new RuntimeException("訂單庫存不足");
}
System.out.println("庫存扣減成功");
}
}
@Component
public class AliPaymentHandler extends OrderHandler {
public void handleOrder(Order order) {
if (!order.getPaymentMethod().equals("支付寶")) {
throw new RuntimeException("不支持支付寶以外的支付方式");
}
System.out.println("支付寶預下單成功");
}
}在具體訂單處理者類的實現中，CheckOrderHandler 負責做訂單參數檢查、StockHandler 負責做庫存扣減、AliPaymentHandler 負責做預下單，每個處理者的邏輯都是相互獨立各不不干擾。
最后，我們創建一個訂單生產鏈條 BuildOrderChain ，用于組成責任鏈的鏈條處理結構：
@Component
public class BuildOrderChain {
@Autowired
private AliPaymentHandler aliPaymentHandler;
@Autowired
private CheckOrderHandler checkOrderHandler;
@Autowired
private StockHandler stockHandler;
List<OrderHandler> list = new ArrayList<>();
@PostConstruct
public void init() {
// 1. 檢查訂單參數
list.add(checkOrderHandler);
// 2. 扣減庫存
list.add(stockHandler);
// 3. 支付寶預下單
list.add(aliPaymentHandler);
}
public void doFilter(Order order) {
for (OrderHandler orderHandler : this.list) {
orderHandler.handleOrder(order);
}
}
}訂單生產鏈條 BuildOrderChain 類中，我們通過 @PostConstruct 注解下的 init() 初始化方法，將具體的訂單處理者按代碼順序組成一個責任鏈的結構。然后通過 doFilter(order) 方法遍歷處理者集合依次處理。
運行代碼，
@Slf4j
@SpringBootTest
@RunWith(SpringRunner.class)
public class OrderChainTest {
@Autowired
private BuildOrderChain buildOrderChain;
@Test
public void test() {
Order order = new Order("123456", "支付寶",
true, "長沙", new BigDecimal("100"));
buildOrderChain.doFilter(order);
}
}
-------------------------------
訂單參數檢驗通過
庫存扣減成功
支付寶預下單成功可以看到訂單依次經過校驗處理器、庫存處理器和支付處理器進行處理，直到最后完成整個訂單的處理。
在舉個例子，假如我們的訂單針對的是虛擬不限庫存商品，我們不需要進行庫存扣減，那我們可以直接新建 VirtualGoodsOrderChain 虛擬商品訂單生產鏈條類，代碼如下，
@Component
public class VirtualGoodsOrderChain {
@Autowired
private AliPaymentHandler aliPaymentHandler;
@Autowired
private CheckOrderHandler checkOrderHandler;
List<OrderHandler> list = new ArrayList<>();
@PostConstruct
public void init() {
// 1. 檢查訂單參數
list.add(checkOrderHandler);
// 2 支付寶預下單
list.add(aliPaymentHandler);
}
public void doFilter(Order order) {
for (OrderHandler orderHandler : this.list) {
orderHandler.handleOrder(order);
}
}
}運行代碼：
@Test
public void virtualOrderTest() {
Order order = new Order("123456", "支付寶", true, "長沙", new BigDecimal("100"));
virtualGoodsOrderChain.doFilter(order);
}
-------------------------------------------
訂單參數檢驗通過
支付寶預下單成功4. 總結
總的來說，責任鏈模式適用于存在多個處理步驟、每個處理步驟具有獨立邏輯或條件、需要靈活組合和擴展的場景。通過責任鏈模式，可以將復雜的處理邏輯拆分為多個獨立的處理步驟，并且可以動態地組合和調整處理步驟的順序，從而提高系統的靈活性和可維護性。希望本文能夠幫助讀者理解和應用責任鏈模式，提升軟件設計和開發的能力。
