1、前言
当今软件开发中，设计模式是一种重要的方法论，它们帮助开发人员解决了各种常见的问题，并提高了代码的可维护性和可扩展性。本文将重点介绍责任链模式（Chain of Responsibility Pattern），并使用Java语言来解释它的概念、用途以及如何实现。
2、责任链模式简介
责任链模式是一种行为型设计模式，它允许你将请求沿着处理链传递，直到有一个对象处理它为止。这种模式非常适合处理请求的分发和处理，特别是当您不知道哪个对象能够处理请求时。
在责任链模式中，通常有多个处理对象（处理器），每个处理对象都有一个处理请求的方法。当一个请求进入责任链时，它从链的起始点开始传递，每个处理对象检查是否能够处理该请求。如果可以处理，则该请求被处理，否则它会被传递给链中的下一个处理对象，直到找到一个合适的处理器。
3、责任链模式的优点
责任链模式有以下几个优点：
- 解耦性: 责任链模式将请求发送者和接收者解耦，发送者无需知道请求最终由哪个接收者处理。
- 可扩展性: 可以轻松地添加新的处理对象或修改处理顺序，而不会影响其他部分的代码。
- 灵活性: 可以动态配置责任链，根据需要添加、删除或修改处理对象。
- 单一职责原则: 每个处理对象只需关心自己是否能够处理请求，符合单一职责原则。
4、责任链模式的实现
让我们使用Java语言来实现一个简单的责任链模式示例。假设我们有一个报销审批系统，根据报销金额不同，有三个处理对象：经理、财务部门和CEO。让我们一步一步实现这个示例。
首先，我们创建一个请求类表示报销请求：
public class ReimbursementRequest {
private double amount;
public ReimbursementRequest(double amount) {
this.amount = amount;
}
public double getAmount() {
return amount;
}
}
接下来，我们创建一个处理接口，表示处理请求的方法：
public interface ReimbursementHandler {
void handleRequest(ReimbursementRequest request);
void setNextHandler(ReimbursementHandler nextHandler);
}
然后，我们创建三个具体的处理对象：经理、财务部门和CEO，它们实现了ReimbursementHandler接口：
public class Manager implements ReimbursementHandler {
private ReimbursementHandler nextHandler;
@Override
public void handleRequest(ReimbursementRequest request) {
if (request.getAmount() <= 1000) {
System.out.println("经理审批通过，报销金额：" + request.getAmount());
} else {
if (nextHandler != null) {
nextHandler.handleRequest(request);
} else {
System.out.println("无法处理该报销申请");
}
}
}
@Override
public void setNextHandler(ReimbursementHandler nextHandler) {
this.nextHandler = nextHandler;
}
}
public class FinanceDepartment implements ReimbursementHandler {
private ReimbursementHandler nextHandler;
@Override
public void handleRequest(ReimbursementRequest request) {
if (request.getAmount() <= 5000) {
System.out.println("财务部门审批通过，报销金额：" + request.getAmount());
} else {
if (nextHandler != null) {
nextHandler.handleRequest(request);
} else {
System.out.println("无法处理该报销申请");
}
}
}
@Override
public void setNextHandler(ReimbursementHandler nextHandler) {
this.nextHandler = nextHandler;
}
}
public class CEO implements ReimbursementHandler {
@Override
public void handleRequest(ReimbursementRequest request) {
System.out.println("CEO审批通过，报销金额：" + request.getAmount());
}
@Override
public void setNextHandler(ReimbursementHandler nextHandler) {
// CEO是责任链中的最后一个处理对象，不需要设置下一个处理对象
}
}
最后，我们可以创建一个责任链并测试它：
public class Main {
public static void main(String[] args) {
ReimbursementHandler manager = new Manager();
ReimbursementHandler finance = new FinanceDepartment();
ReimbursementHandler ceo = new CEO();
// 构建责任链
manager.setNextHandler(finance);
finance.setNextHandler(ceo);
// 创建报销请求
ReimbursementRequest request1 = new ReimbursementRequest(800);
ReimbursementRequest request2 = new ReimbursementRequest(3500);
ReimbursementRequest request3 = new ReimbursementRequest(10000);
// 发送请求
manager.handleRequest(request1);
manager.handleRequest(request2);
manager.handleRequest(request3);
}
}
运行以上代码，你会看到不同金额的报销请求会被不同的处理对象处理。
5、责任链模式在检查系统中的运用
检查系统具有以下检查-申诉-整改-奖惩链路，在该链路中我们可以使用责任链模式，使代码变得更容易维护和扩展。
首先我们创建一个包含各个链路中需要用到的请求类对象。
/**
* @author: guojiangtao
* @description:
* @param:
**/
@Data
@Builder
@NoArgsConstructor
@AllArgsConstructor
public class CheckRewardPunishmentRequest implements Serializable {
private static final long serialVersionUID = 8676996408255323152L;
/**
* 检查结果ID
**/
private Long checkListResultId;
/**
* 检查基本事实
**/
CheckBaseBO checkBaseBO;
/**
* 检查整改事实
**/
CheckRectifyBO checkRectifyBO;
/**
* 检查申诉事实
**/
CheckAppealBO checkAppealBO;
}
我们创建一个处理接口，表示处理请求的方法。
/**
* @author: guojiangtao
* @description: 处理请求
* @param:
**/
public interface CheckRewardPunishmentPhaseActionInterface {
CheckRewardPunishmentPhaseResult proceed(PhaseChain chain);
/**
* @author: guojiangtao
* @description: 获取request以及转发请求
* @param:
**/
interface PhaseChain {
// 获取当前Request
CheckRewardPunishmentRequest request();
// 转发Request
CheckRewardPunishmentPhaseResult dispatch(CheckRewardPunishmentRequest request);
}
}
创建一个客户端类来维护处理的实现类。
/**
* @author guojiangtao
*/
@Data
public class PhaseChainClient {
public static final List<CheckRewardPunishmentPhaseActionInterface> phaseActionInterfaceList = Lists.newArrayList();
private static void addPhaseActionInterface(CheckRewardPunishmentPhaseActionInterface phaseActionInterface) {
phaseActionInterfaceList.add(phaseActionInterface);
}
public static PhaseChainClient getChainClient(CheckRewardPunishmentPhaseActionInterface ... interfaces) {
List<CheckRewardPunishmentPhaseActionInterface> interfaceList = Lists.newArrayList(interfaces);
if (CollectionUtil.isNullOrEmpty(interfaceList)) {
throw new BizException(BizErrorCodeEnum.ILLEGAL_OPERATION, "getChainClient exception");
}
interfaceList.forEach(PhaseChainClient::addPhaseActionInterface);
return new PhaseChainClient();
}
public CheckRewardPunishmentPhaseResult execute (CheckRewardPunishmentRequest request) {
RealPhaseChain realChain = new RealPhaseChain(request, phaseActionInterfaceList, 0);
return realChain.dispatch(request);
}
}
检查提交实现类。
/**
* @author: guojiangtao
* @description: 检查提交
* @param:
**/
@Service
@Slf4j
public class CheckSubmit implements CheckRewardPunishmentPhaseActionInterface {
@Autowired
private CheckAppeal checkAppeal;
@Autowired
private CheckRpProducer checkRpProducer;
@Override
public CheckRewardPunishmentPhaseResult proceed(PhaseChain chain) {
CheckRewardPunishmentRequest request = chain.request();
// 参数校验
if (null == request) {
log.warn("CheckSubmit proceed with null request");
return null;
}
CheckBaseBO checkBaseBO = request.getCheckBaseBO();
if (null == checkBaseBO) {
log.warn("CheckSubmit proceed with null checkBaseBO");
return null;
}
// 检查单配置
if (AppealTypeEnum.OPEN_APPEAL.getCode().equals(checkBaseBO.getAppealType())) {
// 构建检查申诉事实实例
CheckAppealBO appealBO = new CheckAppealBO(checkBaseBO.getCheckItemId(), checkBaseBO.getCheckItemResultId(), 1);
request.setCheckAppealBO(appealBO);
return PhaseChainClient.getChainClient(checkAppeal).execute(request);
}
checkRpProducer.sendMessage(request);
return new CheckRewardPunishmentPhaseResult(Boolean.TRUE, "");
}
}
检查申诉实现类：
/**
* @author: guojiangtao
* @description: 检查申诉
* @param:
**/
@Service
@Slf4j
public class CheckAppeal implements CheckRewardPunishmentPhaseActionInterface {
@Autowired
private CheckRpProducer checkRpProducer;
@Autowired
private CheckResultRectifyListRepository checkResultRectifyListRepository;
@Autowired
private CheckRectifyTemplateItemRelationRepository rectifyTemplateItemRelationRepository;
@Autowired
private CheckRectify checkRectify;
@Override
public CheckRewardPunishmentPhaseResult proceed (PhaseChain chain) {
CheckRewardPunishmentRequest request = chain.request();
// 参数校验
if (null == request) {
return new CheckRewardPunishmentPhaseResult(Boolean.FALSE, "");
}
CheckBaseBO checkBaseBO = request.getCheckBaseBO();
CheckAppealBO appealBO = request.getCheckAppealBO();
if (null == checkBaseBO || null == appealBO) {
return new CheckRewardPunishmentPhaseResult(Boolean.FALSE, "");
}
// 根据检查项ID查询 检查项与整改任务模板 1:1
CheckRectifyTemplateItemRelationDAO templateItemRelationDAO = rectifyTemplateItemRelationRepository.queryByItemId(checkBaseBO.getCheckItemId());
if (null != templateItemRelationDAO) {
// 整改单模板ID
Long rectifyTemplateId = templateItemRelationDAO.getRectifyTemplateId();
// 整改单
CheckResultRectifyListDAO rectifyListDAO = checkResultRectifyListRepository.getByCheckResultIdAndTemplateId(checkBaseBO.getCheckListResultId(), rectifyTemplateId);
if (null != rectifyListDAO && Objects.equals(RectifyResultListStatusEnum.FINISH.getCode(), rectifyListDAO.getStatus())) {
// 构建检查整改事实实例
CheckRectifyBO rectifyBO = new CheckRectifyBO(checkBaseBO.getCheckItemId(), rectifyListDAO.getStatus());
request.setCheckRectifyBO(rectifyBO);
return PhaseChainClient.getChainClient(checkRectify).execute(request);
}
}
checkRpProducer.sendMessage(request);
return new CheckRewardPunishmentPhaseResult(Boolean.TRUE, "");
}
}
检查整改实现类：
@Service
@Slf4j
public class CheckRectify implements CheckRewardPunishmentPhaseActionInterface {
@Autowired
private CheckRpProducer checkRpProducer;
@Override
public CheckRewardPunishmentPhaseResult proceed(PhaseChain chain) {
CheckRewardPunishmentRequest request = chain.request();
if (null == request) {
return null;
}
CheckRectifyBO rectifyBO = request.getCheckRectifyBO();
// 无整改事实 不处理
if (null == rectifyBO) {
return null;
}
checkRpProducer.sendMessage(request);
return new CheckRewardPunishmentPhaseResult(Boolean.TRUE, "");
}
6、责任链模式的适用场景
责任链模式在以下情况下特别有用：
- 当您希望将请求的发送者和接收者解耦时，可以使用责任链模式。发送者无需知道最终哪个对象会处理请求。
- 当您有多个对象可以处理请求，但您不确定哪个对象应该处理时，可以使用责任链模式。这种情况下，您可以将请求传递给责任链，直到有一个对象能够处理它。
- 当您希望动态配置处理对象的顺序或添加新的处理对象时，可以使用责任链模式。这使得系统更加灵活和可扩展。
- 在需要应用单一职责原则的情况下，责任链模式可以帮助将处理逻辑分散到不同的对象中，每个对象只负责一部分功能。
7、总结
责任链模式是一种有用的设计模式，可以帮助您构建灵活的、可扩展的系统。它通过将请求传递给一系列处理对象来解耦请求发送者和接收者，使得代码更容易维护和扩展。通过示例代码和解释，我们希望您现在更好地理解了责任链模式及其在Java中的实现方式。希望这篇分享文档有助于您在实际项目中应用责任链模式以解决类似的问题。