深度剖析责任链模式

一、责任链模式的本质：灵活可扩展的流水线处理

责任链模式（Chain of Responsibility Pattern）是行为型设计模式的代表，其核心思想是将请求的发送者与接收者解耦，允许多个对象都有机会处理请求。这种模式完美解决了以下场景痛点：

1. 动态流程编排：审批流程、风控流程等需要灵活调整顺序

2. 请求分发机制：日志处理、权限校验等需要多层级过滤

3. 未知处理者：异常捕获链、HTTP中间件等场景

UML类图：

二、责任链模式的三种经典实现

1. 基础链表实现（传统方式）

// 处理器接口
public interface OrderHandler {
    void handle(Order order);
    void setNext(OrderHandler next);
}

// 抽象基类
public abstract class AbstractOrderHandler implements OrderHandler {
    private OrderHandler next;

    @Override
    public void setNext(OrderHandler next) {
        this.next = next;
    }

    protected void handleNext(Order order) {
        if (next != null) {
            next.handle(order);
        }
    }
}

// 具体处理器
public class InventoryCheckHandler extends AbstractOrderHandler {
    @Override
    public void handle(Order order) {
        if (!checkInventory(order)) {
            throw new RuntimeException("库存不足");
        }
        System.out.println("库存校验通过");
        handleNext(order);
    }

    private boolean checkInventory(Order order) {
        // 库存检查逻辑
        return true;
    }
}

public class PaymentHandler extends AbstractOrderHandler {
    @Override
    public void handle(Order order) {
        processPayment(order);
        System.out.println("支付处理完成");
        handleNext(order);
    }

    private void processPayment(Order order) {
        // 支付处理逻辑
    }
}

2. 集合迭代实现（Spring风格）

// 处理器接口
public interface Filter {
    void doFilter(Request request, Response response, FilterChain chain);
}

// 链式调用容器
public class FilterChain {
    private List<Filter> filters = new ArrayList<>();
    private int index = 0;

    public FilterChain addFilter(Filter filter) {
        filters.add(filter);
        return this;
    }

    public void doFilter(Request request, Response response) {
        if (index < filters.size()) {
            Filter filter = filters.get(index++);
            filter.doFilter(request, response, this);
        }
    }
}

// 使用示例
FilterChain chain = new FilterChain()
    .addFilter(new AuthFilter())
    .addFilter(new LogFilter())
    .addFilter(new EncodingFilter());
chain.doFilter(request, response);

3. 注解驱动实现（企业级方案）

// 自定义注解
@Retention(RetentionPolicy.RUNTIME)
@Target(ElementType.TYPE)
public @interface OrderProcessor {
    int order() default 0;
    String[] supportType();
}

// 处理器基类
public abstract class BaseOrderProcessor {
    @Autowired
    private ProcessorChain chain;

    public void process(OrderContext context) {
        if (canProcess(context)) {
            doProcess(context);
        }
        chain.process(context);
    }

    protected abstract boolean canProcess(OrderContext context);
    protected abstract void doProcess(OrderContext context);
}

// 具体处理器
@OrderProcessor(order = 1, supportType = "NORMAL")
public class NormalOrderProcessor extends BaseOrderProcessor {
    @Override
    protected boolean canProcess(OrderContext context) {
        return "NORMAL".equals(context.getOrderType());
    }

    @Override
    protected void doProcess(OrderContext context) {
        // 普通订单处理逻辑
    }
}

三、责任链模式的五大应用场景

场景1：审批流程系统

• 请假审批链（组长 → 经理 → 总监）

• 采购审批链（金额分级审批）

• 合同审批链（法务 → 财务 → CEO）

场景2：Web请求处理

• Servlet Filter链

• Spring Interceptor链

• 网关过滤器链（限流 → 鉴权 → 日志）

场景3：订单处理系统

• 订单校验链（库存 → 优惠券 → 地址）

• 订单履约链（拆单 → 分配仓库 → 物流）

场景4：异常处理系统

• 异常捕获链（业务异常 → 系统异常 → 全局异常）

• 错误恢复链（重试 → 降级 → 告警）

场景5：游戏事件处理

• 技能释放链（蓝量检查 → CD检查 → 效果触发）

• 伤害计算链（防御计算 → 暴击计算 → 元素反应）

四、责任链模式与相关模式对比

五、企业级实战：Spring风格审批系统

架构设计

[审批请求] → [审批链构建器] → [审批处理器1] → [审批处理器2] → [...] → [审批完成]
                   ↑
           [审批规则配置中心]
                   ↑
           [数据库/配置中心]

完整代码实现

// 审批处理器接口
public interface ApprovalHandler {
    ApprovalResult handle(ApprovalContext context);
    void setNext(ApprovalHandler next);
    boolean support(ApprovalType type);
}

// 链式处理器基类
public abstract class AbstractApprovalHandler implements ApprovalHandler {
    private ApprovalHandler next;
    private ApprovalType supportType;

    protected AbstractApprovalHandler(ApprovalType supportType) {
        this.supportType = supportType;
    }

    @Override
    public void setNext(ApprovalHandler next) {
        this.next = next;
    }

    @Override
    public ApprovalResult handle(ApprovalContext context) {
        if (!support(context.getType())) {
            return next.handle(context);
        }

        ApprovalResult result = doHandle(context);
        if (result.isApproved() && next != null) {
            return next.handle(context);
        }
        return result;
    }

    @Override
    public boolean support(ApprovalType type) {
        return this.supportType == type;
    }

    protected abstract ApprovalResult doHandle(ApprovalContext context);
}

// 具体审批处理器
public class DepartmentManagerHandler extends AbstractApprovalHandler {
    public DepartmentManagerHandler() {
        super(ApprovalType.DEPARTMENT_MANAGER);
    }

    @Override
    protected ApprovalResult doHandle(ApprovalContext context) {
        // 部门经理审批逻辑
        return new ApprovalResult(true, "部门经理审批通过");
    }
}

// 审批链构建工厂
@Service
public class ApprovalChainFactory {
    @Autowired
    private List<ApprovalHandler> handlers;

    public ApprovalHandler createChain(ApprovalType type) {
        List<ApprovalHandler> sortedHandlers = handlers.stream()
                .filter(h -> h.support(type))
                .sorted(Comparator.comparingInt(h -> h.getOrder()))
                .collect(Collectors.toList());

        ApprovalHandler head = null;
        ApprovalHandler current = null;
        for (ApprovalHandler handler : sortedHandlers) {
            if (head == null) {
                head = handler;
                current = handler;
            } else {
                current.setNext(handler);
                current = handler;
            }
        }
        return head;
    }
}

六、责任链模式的五大优化技巧

1. 动态配置链顺序

// 基于配置文件的链定义
@Configuration
public class ChainConfig {
    @Bean
    public FilterChain securityFilterChain() {
        return new FilterChain()
            .addFilter(new CorsFilter())
            .addFilter(new AuthFilter())
            .addFilter(new RateLimitFilter());
    }
}

2. 中断机制优化

public interface Handler {
    enum Result {
        CONTINUE, BREAK
    }
    Result handle(Request request);
}

public class Chain {
    public void process(Request request) {
        for (Handler handler : handlers) {
            if (handler.handle(request) == Result.BREAK) {
                return;
            }
        }
    }
}

3. 性能监控埋点

public class MonitoredHandler implements Handler {
    private final Handler delegate;
    private final MeterRegistry registry;

    public MonitoredHandler(Handler delegate, MeterRegistry registry) {
        this.delegate = delegate;
        this.registry = registry;
    }

    @Override
    public Result handle(Request request) {
        Timer.Sample sample = Timer.start(registry);
        try {
            return delegate.handle(request);
        } finally {
            sample.stop(registry.timer("handler.time", 
                "handler", delegate.getClass().getSimpleName()));
        }
    }
}

七、常见陷阱与解决方案