责任链模式是一种经典的设计模式，属于行为型设计模式，他的核心思想是：将请求的发起者与接受者进行解耦，让多个对象都有机会处理请求，从而避免了请求发送者与接受者之间的耦合关系。这些对象连接形成一条链，请求沿着这条链传递，直到被某个对象处理为止。
你会简单的发现，在这种处理模式直线，实际上是有先后顺序的，你可以把它想象成为一个链表，从头到尾开始进行执行，在某一步执行完毕之后结束返回，下面我将举一个具体的业务场景来具体说明当前模式
业务场景
我们需要计算一下两个地点的运费，但是对于每个地点的运费的计算规则是不同的，也就是我们现在设计了多个模板，你需要进行判断然后返回需要的模板，下面给出逻辑示意图
解决
你会发现当我们给出逻辑示意图的时候，整个思路就比较明确了，你可以写许多的ifelse，但是这样的话你的代码会显得比较冗余并且拓展性极差，所以我们基于任务链设计模式来解决
首先，我们定义抽象类处理链对象，你可以认为实际上就是指向下一个的指针，也就是说，当你的是否同城判断完之后，如果成功就返回，不成功就执行下一个节点
package com.sl.ms.carriage.handler;
import com.sl.ms.carriage.domain.dto.WaybillDTO;
import com.sl.ms.carriage.entity.CarriageEntity;
/**
* 运费模板处理链的抽象定义
*/
public abstract class AbstractCarriageChainHandler {
private AbstractCarriageChainHandler nextHandler;
/**
* 执行过滤方法，通过输入参数查找运费模板
*
* @param waybillDTO 输入参数
* @return 运费模板
*/
public abstract CarriageEntity doHandler(WaybillDTO waybillDTO);
/**
* 执行下一个处理器
*
* @param waybillDTO 输入参数
* @param carriageEntity 上个handler处理得到的对象
* @return
*/
protected CarriageEntity doNextHandler(WaybillDTO waybillDTO, CarriageEntity carriageEntity) {
if (nextHandler == null || carriageEntity != null) {
//如果下游Handler为空 或 上个Handler已经找到运费模板就返回
return carriageEntity;
}
return nextHandler.doHandler(waybillDTO);
}
/**
* 设置下游Handler
*
* @param nextHandler 下游Handler
*/
public void setNextHandler(AbstractCarriageChainHandler nextHandler) {
this.nextHandler = nextHandler;
}
}然后，你这个时候就是去定义同城，同省，同经济区的既可
这边写一个同城的
package com.sl.ms.carriage.handler;
import com.sl.ms.carriage.domain.constant.CarriageConstant;
import com.sl.ms.carriage.domain.dto.WaybillDTO;
import com.sl.ms.carriage.entity.CarriageEntity;
import com.sl.ms.carriage.service.CarriageService;
import com.sl.transport.common.util.ObjectUtil;
import org.springframework.core.annotation.Order;
import org.springframework.stereotype.Component;
import javax.annotation.Resource;
/**
* 同城寄
*/
@Order(100) //定义顺序
@Component
public class SameCityChainHandler extends AbstractCarriageChainHandler {
@Resource
private CarriageService carriageService;
@Override
public CarriageEntity doHandler(WaybillDTO waybillDTO) {
CarriageEntity carriageEntity = null;
if (ObjectUtil.equals(waybillDTO.getReceiverCityId(), waybillDTO.getSenderCityId())) {
//同城
carriageEntity = this.carriageService.findByTemplateType(CarriageConstant.SAME_CITY);
}
return doNextHandler(waybillDTO, carriageEntity);
}
}你会发现，这里我们在最后在一次调用了doNextHandler，也就是传给了下一个节点，
这个时候开始组装处理链
package com.sl.ms.carriage.handler;
import cn.hutool.core.collection.CollUtil;
import com.sl.ms.carriage.domain.dto.WaybillDTO;
import com.sl.ms.carriage.entity.CarriageEntity;
import com.sl.transport.common.exception.SLException;
import org.springframework.stereotype.Component;
import javax.annotation.PostConstruct;
import javax.annotation.Resource;
import java.util.List;
/**
* 查找运费模板处理链 @Order注解指定handler顺序
*/
@Component
public class CarriageChainHandler {
/**
* 利用Spring注入特性，按照 @Order 从小到达排序注入到集合中
*/
@Resource
private List<AbstractCarriageChainHandler> chainHandlers;
private AbstractCarriageChainHandler firstHandler;
/**
* 组装处理链
*/
@PostConstruct
private void constructChain() {
if (CollUtil.isEmpty(chainHandlers)) {
throw new SLException("not found carriage chain handler!");
}
//处理链中第一个节点
firstHandler = chainHandlers.get(0);
for (int i = 0; i < chainHandlers.size(); i++) {
if (i == chainHandlers.size() - 1) {
//最后一个处理链节点
chainHandlers.get(i).setNextHandler(null);
} else {
//设置下游节点
chainHandlers.get(i).setNextHandler(chainHandlers.get(i + 1));
}
}
}
public CarriageEntity findCarriage(WaybillDTO waybillDTO) {
//从第一个节点开始处理
return firstHandler.doHandler(waybillDTO);
}
}我们对于最后一个节点的下一个节点设置为null，对于每个节点的下一个节点，我们实际上是由先后顺序的，我们可以基于spring对于每一个类写上order注解进行排序，spring的抽象类在进行注入的时候，会根据order的值从小到大注入，这样我们之后调用find方法就可以解决当前的业务问题了
总结
- 责任链模式是一种行为型设计模式，用于解耦请求发送者和接收者。
- 核心思想：将多个处理者连接成一条链，请求沿着链传递，直到被某个处理者处理。
- 适用场景：Web 过滤器、审批流程、异常处理、日志记录等。
- 优点：解耦、灵活、符合单一职责原则。
- 缺点：请求可能未被处理，调试较复杂。