设计模式概述
- 模式类型：行为型
- 模式定义：责任链模式通过将请求沿着处理者链传递，使多个处理者有机会处理该请求，从而实现请求发送者与接收者之间的解耦。可在运行时灵活组合、插拔和调整处理顺序。
- 适用场景：
- 需要对一个请求执行一系列的校验或处理，且步骤可插拔、可调整顺序
- 各处理步骤彼此独立，职责清晰
- 希望统一异常处理和日志输出，简化横切关注点
核心角色
| 角色 |
职责说明 |
| Handler（抽象处理者） |
定义处理请求的接口与链路转发逻辑，内置统一日志与异常包装 |
| ConcreteHandler（具体处理者） |
实现具体的处理逻辑（库存校验、黑名单过滤、风控评分、限购规则） |
| HandlerChain（处理链） |
负责组装和执行处理者链，支持插拔与顺序调整 |
| Context（上下文） |
封装请求数据及处理过程中的中间状态（如风险分） |
| Request（请求对象） |
订单提交请求的基本字段（用户、商品、数量） |
| BizException / ErrorCode |
统一业务异常与错误码定义 |
| Service（领域服务） |
抽象外部依赖（库存、黑名单、风控、限购）并提供简化实现 |
Java代码实现
import java.util.*;
import java.util.logging.Level;
import java.util.logging.Logger;
/**
* 责任链模式 - 订单提交校验示例（简化版）
* 校验步骤：库存校验 -> 黑名单过滤 -> 风控评分 -> 限购规则
* 特点：可插拔、可调整顺序、统一异常与日志
*/
public class OrderSubmitChainDemo {
// ===================== 统一异常与错误码 =====================
enum ErrorCode {
OUT_OF_STOCK,
BLACKLISTED,
HIGH_RISK,
PURCHASE_LIMIT_EXCEEDED,
SYSTEM_ERROR
}
static class BizException extends RuntimeException {
private final ErrorCode errorCode;
public BizException(ErrorCode code, String message) {
super(message);
this.errorCode = code;
}
public BizException(ErrorCode code, String message, Throwable cause) {
super(message, cause);
this.errorCode = code;
}
public ErrorCode getErrorCode() {
return errorCode;
}
}
// ===================== 请求、上下文与结果 =====================
static class OrderSubmitRequest {
private final String userId;
private final String productId;
private final int quantity;
public OrderSubmitRequest(String userId, String productId, int quantity) {
this.userId = userId;
this.productId = productId;
this.quantity = quantity;
}
public String getUserId() { return userId; }
public String getProductId() { return productId; }
public int getQuantity() { return quantity; }
}
static class OrderContext {
private final OrderSubmitRequest request;
// 中间产物：例如风控评分
private int riskScore;
public OrderContext(OrderSubmitRequest request) {
this.request = request;
}
public OrderSubmitRequest getRequest() { return request; }
public int getRiskScore() { return riskScore; }
public void setRiskScore(int riskScore) { this.riskScore = riskScore; }
}
static class Result {
private boolean success;
private String message;
private ErrorCode errorCode;
public static Result ok() {
Result r = new Result();
r.success = true;
r.message = "OK";
return r;
}
public static Result fail(ErrorCode code, String message) {
Result r = new Result();
r.success = false;
r.errorCode = code;
r.message = message;
return r;
}
@Override
public String toString() {
return "Result{" +
"success=" + success +
", message='" + message + '\'' +
", errorCode=" + errorCode +
'}';
}
}
// ===================== 抽象处理者与处理链 =====================
interface Handler {
String name();
void setNext(Handler next);
void handle(OrderContext ctx);
}
static abstract class AbstractHandler implements Handler {
protected final Logger log = Logger.getLogger(getClass().getName());
private Handler next;
@Override
public void setNext(Handler next) {
this.next = next;
}
@Override
public String name() {
return getClass().getSimpleName();
}
/**
* 统一模板方法：日志 + 异常包装 + 链路透传
*/
@Override
public final void handle(OrderContext ctx) {
long start = System.currentTimeMillis();
log.info(() -> "[START] " + name() + ", req=" + brief(ctx.getRequest()));
try {
doHandle(ctx); // 具体处理
log.info(() -> "[PASS] " + name() + ", cost=" + (System.currentTimeMillis() - start) + "ms");
if (next != null) {
next.handle(ctx);
}
} catch (BizException be) {
log.log(Level.WARNING, "[BIZ-ERROR] " + name() + " -> " + be.getErrorCode() + ": " + be.getMessage());
throw be;
} catch (Exception e) {
log.log(Level.SEVERE, "[SYS-ERROR] " + name() + " -> " + e.getMessage(), e);
throw new BizException(ErrorCode.SYSTEM_ERROR, "System error in " + name(), e);
}
}
protected abstract void doHandle(OrderContext ctx);
private static String brief(OrderSubmitRequest r) {
return "{user=" + r.getUserId() + ", product=" + r.getProductId() + ", qty=" + r.getQuantity() + "}";
}
}
static class HandlerChain {
private final Handler head;
private HandlerChain(Handler head) {
this.head = head;
}
public void execute(OrderContext ctx) {
if (head != null) {
head.handle(ctx);
}
}
public static class Builder {
private final List<Handler> list = new ArrayList<>();
public Builder add(Handler handler) {
list.add(handler);
return this;
}
public HandlerChain build() {
if (list.isEmpty()) return new HandlerChain(null);
for (int i = 0; i < list.size() - 1; i++) {
list.get(i).setNext(list.get(i + 1));
}
return new HandlerChain(list.get(0));
}
}
}
// ===================== 领域服务（示例实现） =====================
interface InventoryService {
int getAvailableStock(String productId);
}
interface BlacklistService {
boolean isBlacklisted(String userId);
}
interface RiskService {
int calcRiskScore(String userId);
}
interface PurchaseLimitService {
boolean exceedsLimit(String userId, String productId, int quantity);
}
// 简化的内存实现
static class InMemoryInventoryService implements InventoryService {
private final Map<String, Integer> stockMap;
public InMemoryInventoryService(Map<String, Integer> stockMap) {
this.stockMap = stockMap;
}
@Override
public int getAvailableStock(String productId) {
return stockMap.getOrDefault(productId, 0);
}
}
static class InMemoryBlacklistService implements BlacklistService {
private final Set<String> blackSet;
public InMemoryBlacklistService(Set<String> blackSet) {
this.blackSet = blackSet;
}
@Override
public boolean isBlacklisted(String userId) {
return blackSet.contains(userId);
}
}
static class InMemoryRiskService implements RiskService {
private final Map<String, Integer> riskScoreMap;
public InMemoryRiskService(Map<String, Integer> riskScoreMap) {
this.riskScoreMap = riskScoreMap;
}
@Override
public int calcRiskScore(String userId) {
return riskScoreMap.getOrDefault(userId, 0);
}
}
static class SimplePurchaseLimitService implements PurchaseLimitService {
private final Map<String, Integer> perUserProductLimit; // key: userId#productId
public SimplePurchaseLimitService(Map<String, Integer> perUserProductLimit) {
this.perUserProductLimit = perUserProductLimit;
}
@Override
public boolean exceedsLimit(String userId, String productId, int quantity) {
String key = userId + "#" + productId;
int limit = perUserProductLimit.getOrDefault(key, Integer.MAX_VALUE);
return quantity > limit;
}
}
// ===================== 具体处理者实现 =====================
static class InventoryCheckHandler extends AbstractHandler {
private final InventoryService inventoryService;
public InventoryCheckHandler(InventoryService inventoryService) {
this.inventoryService = inventoryService;
}
@Override
protected void doHandle(OrderContext ctx) {
OrderSubmitRequest req = ctx.getRequest();
int stock = inventoryService.getAvailableStock(req.getProductId());
if (stock < req.getQuantity()) {
throw new BizException(
ErrorCode.OUT_OF_STOCK,
"Insufficient stock. required=" + req.getQuantity() + ", available=" + stock
);
}
}
}
static class BlacklistCheckHandler extends AbstractHandler {
private final BlacklistService blacklistService;
public BlacklistCheckHandler(BlacklistService blacklistService) {
this.blacklistService = blacklistService;
}
@Override
protected void doHandle(OrderContext ctx) {
String userId = ctx.getRequest().getUserId();
if (blacklistService.isBlacklisted(userId)) {
throw new BizException(
ErrorCode.BLACKLISTED,
"User " + userId + " is in blacklist"
);
}
}
}
static class RiskScoreHandler extends AbstractHandler {
private final RiskService riskService;
private final int threshold; // 风控阈值
public RiskScoreHandler(RiskService riskService, int threshold) {
this.riskService = riskService;
this.threshold = threshold;
}
@Override
protected void doHandle(OrderContext ctx) {
String userId = ctx.getRequest().getUserId();
int score = riskService.calcRiskScore(userId);
ctx.setRiskScore(score);
if (score >= threshold) {
throw new BizException(
ErrorCode.HIGH_RISK,
"Risk score too high: " + score + ", threshold=" + threshold
);
}
}
}
static class PurchaseLimitHandler extends AbstractHandler {
private final PurchaseLimitService purchaseLimitService;
public PurchaseLimitHandler(PurchaseLimitService purchaseLimitService) {
this.purchaseLimitService = purchaseLimitService;
}
@Override
protected void doHandle(OrderContext ctx) {
OrderSubmitRequest req = ctx.getRequest();
if (purchaseLimitService.exceedsLimit(req.getUserId(), req.getProductId(), req.getQuantity())) {
throw new BizException(
ErrorCode.PURCHASE_LIMIT_EXCEEDED,
"Purchase limit exceeded for user=" + req.getUserId() + ", product=" + req.getProductId()
);
}
}
}
// ===================== 示例运行 =====================
public static void main(String[] args) {
// 初始化日志级别（可选）
Logger root = Logger.getLogger("");
root.setLevel(Level.INFO);
// 构造示例服务数据
InventoryService inventoryService = new InMemoryInventoryService(new HashMap<String, Integer>() {{
put("P1001", 5);
put("P1002", 0);
}});
BlacklistService blacklistService = new InMemoryBlacklistService(new HashSet<>(Arrays.asList("U999")));
RiskService riskService = new InMemoryRiskService(new HashMap<String, Integer>() {{
put("U100", 30);
put("U200", 85);
}});
PurchaseLimitService limitService = new SimplePurchaseLimitService(new HashMap<String, Integer>() {{
put("U100#P1001", 3); // 用户U100对商品P1001限购3件
}});
// 构造处理器（可插拔）
Handler inventory = new InventoryCheckHandler(inventoryService);
Handler blacklist = new BlacklistCheckHandler(blacklistService);
Handler risk = new RiskScoreHandler(riskService, 60);
Handler limit = new PurchaseLimitHandler(limitService);
// 组装处理链（可调整顺序）
HandlerChain chain = new HandlerChain.Builder()
.add(inventory) // 先校验库存
.add(blacklist) // 再检查黑名单
.add(risk) // 再风控
.add(limit) // 再限购
.build();
// 示例请求（成功案例）
OrderSubmitRequest reqOk = new OrderSubmitRequest("U100", "P1001", 2);
Result resultOk;
try {
chain.execute(new OrderContext(reqOk));
resultOk = Result.ok();
} catch (BizException e) {
resultOk = Result.fail(e.getErrorCode(), e.getMessage());
}
System.out.println("Submit result 1: " + resultOk);
// 示例请求（失败案例：库存不足或高风险等）
OrderSubmitRequest reqFail = new OrderSubmitRequest("U200", "P1001", 2); // 高风险用户
Result resultFail;
try {
chain.execute(new OrderContext(reqFail));
resultFail = Result.ok();
} catch (BizException e) {
resultFail = Result.fail(e.getErrorCode(), e.getMessage());
}
System.out.println("Submit result 2: " + resultFail);
// 如需调整顺序或插拔某个步骤，只需更改构建器顺序或不添加即可
// 例如：先做风控，再做库存
HandlerChain altChain = new HandlerChain.Builder()
.add(risk)
.add(blacklist)
.add(inventory)
.add(limit)
.build();
try {
altChain.execute(new OrderContext(reqOk));
System.out.println("Alt chain: OK");
} catch (BizException e) {
System.out.println("Alt chain: FAIL -> " + e.getErrorCode() + ", " + e.getMessage());
}
}
}
实现要点
- 抽象处理者模板方法
- 在 AbstractHandler.handle 中统一做日志、异常包装与链路透传；具体逻辑在 doHandle 中实现，简化横切关注点的处理。
- 可插拔与可调整顺序
- HandlerChain.Builder 以列表顺序串联处理器；通过修改 add 的顺序或省略某个处理器实现插拔与重排。
- 统一异常与错误码
- 通过 BizException 和 ErrorCode 进行业务错误统一管理，上层只需捕获 BizException 生成统一返回。
- 上下文共享中间结果
- OrderContext 存储中间值（如风险分）以便后续处理器复用，避免重复计算或耦合。
- 简化服务依赖
- 使用内存 Map/Set 模拟外部服务，实际项目中替换为真实服务实现即可，处理器无需变更。
优缺点分析
- 优点：
- 解耦：请求发起方与各处理步骤解耦，新增/删除处理器对其他模块影响较小。
- 可扩展：可在运行时按需组装链路，支持步骤的插拔与顺序调整。
- 职责单一：每个处理器只关心自身逻辑，代码清晰、可测试性强。
- 横切统一：通过模板方法统一日志与异常处理，降低重复代码。
- 缺点：
- 调试复杂：链路过长时定位问题需要依赖完善的日志与追踪。
- 性能风险：不当的链路顺序可能造成不必要的开销（例如把昂贵步骤放在前面）。
- 不保证处理：若所有处理器都通过但业务仍需其他保障，需确保链尾有默认处理或最终落地逻辑。
使用建议：在订单提交流程中，将副作用大、耗时长的步骤后置，将快速失败的步骤前置；通过配置或装配（如Spring配置）管理链路，便于动态调整和灰度。
