【流程流转解耦设计模式】责任链模式

责任链模式保姆级教程：基于Spring Boot的代码示例

1. 什么是责任链模式？

责任链模式（Chain of Responsibility Pattern）是一种行为设计模式，它允许多个对象有机会处理请求，从而避免请求的发送者与接收者之间的耦合。责任链模式将这些对象连成一条链，并沿着这条链传递请求，直到有对象处理它为止。
1.1 责任链模式的核心思想

• 解耦：将请求的发送者和处理者解耦，使得多个对象都有机会处理请求。
  
• 灵活性：可以动态地调整链中的处理者，增加或删除处理者。
  
• 责任分离：每个处理者只关心自己能否处理请求，如果不能处理，则将请求传递给下一个处理者。
  

1.2 责任链模式的应用场景

• 多级审批流程：例如请假审批、报销审批等。
  
• 过滤器链：例如Web应用中的过滤器链、拦截器等。
  
• 日志处理：不同级别的日志由不同的处理器处理。
  

2. 责任链模式的实现

2.1 责任链模式的结构

责任链模式通常包含以下几个角色：

• Handler（抽象处理者）：定义一个处理请求的接口，通常包含一个指向下一个处理者的引用。
  
• ConcreteHandler（具体处理者）：实现处理请求的具体逻辑，如果自己不能处理，则将请求传递给下一个处理者。
  
• Client（客户端）：创建责任链，并向链中的第一个处理者发送请求。
  

2.2 基于Spring Boot的责任链模式实现

下面我们通过一个简单的例子来演示如何在Spring Boot中实现责任链模式。假设我们有一个请假审批系统，请假请求需要经过多个层级的审批：组长、经理、总监。
2.2.1 创建抽象处理者

首先，我们定义一个抽象处理者 LeaveHandler，它包含一个指向下一个处理者的引用。

1. public abstract class LeaveHandler {
3.     protected LeaveHandler nextHandler;
5.     public void setNextHandler(LeaveHandler nextHandler) {
6.         this.nextHandler = nextHandler;
7.     }
9.     public abstract void handleRequest(LeaveRequest request);
10. }

复制代码

2.2.2 创建具体处理者

接下来，我们创建三个具体处理者：GroupLeaderHandler、ManagerHandler 和 DirectorHandler。

1. @Component
2. public class GroupLeaderHandler extends LeaveHandler {
4.     @Override
5.     public void handleRequest(LeaveRequest request) {
6.         if (request.getDays() <= 1) {
7.             System.out.println("组长批准了 " + request.getDays() + " 天的请假申请。");
8.         } else if (nextHandler != null) {
9.             nextHandler.handleRequest(request);
10.         }
11.     }
12. }
14. @Component
15. public class ManagerHandler extends LeaveHandler {
17.     @Override
18.     public void handleRequest(LeaveRequest request) {
19.         if (request.getDays() > 1 && request.getDays() <= 3) {
20.             System.out.println("经理批准了 " + request.getDays() + " 天的请假申请。");
21.         } else if (nextHandler != null) {
22.             nextHandler.handleRequest(request);
23.         }
24.     }
25. }
27. @Component
28. public class DirectorHandler extends LeaveHandler {
30.     @Override
31.     public void handleRequest(LeaveRequest request) {
32.         if (request.getDays() > 3) {
33.             System.out.println("总监批准了 " + request.getDays() + " 天的请假申请。");
34.         } else if (nextHandler != null) {
35.             nextHandler.handleRequest(request);
36.         }
37.     }
38. }

复制代码

2.2.3 创建请假请求类

我们还需要一个 LeaveRequest 类来表示请假请求。

1. public class LeaveRequest {
3.     private int days;
5.     public LeaveRequest(int days) {
6.         this.days = days;
7.     }
9.     public int getDays() {
10.         return days;
11.     }
12. }

复制代码

2.2.4 配置责任链

在Spring Boot中，我们可以通过配置类来组装责任链。

1. @Configuration
2. public class LeaveHandlerConfig {
4.     @Autowired
5.     private GroupLeaderHandler groupLeaderHandler;
7.     @Autowired
8.     private ManagerHandler managerHandler;
10.     @Autowired
11.     private DirectorHandler directorHandler;
13.     @Bean
14.     public LeaveHandler leaveHandlerChain() {
15.         groupLeaderHandler.setNextHandler(managerHandler);
16.         managerHandler.setNextHandler(directorHandler);
17.         return groupLeaderHandler;
18.     }
19. }

复制代码

2.2.5 使用责任链处理请求

最后，我们可以在服务类中使用责任链来处理请假请求。

1. @Service
2. public class LeaveService {
4.     @Autowired
5.     private LeaveHandler leaveHandlerChain;
7.     public void submitLeaveRequest(LeaveRequest request) {
8.         leaveHandlerChain.handleRequest(request);
9.     }
10. }

复制代码

2.2.6 测试责任链

我们可以编写一个简单的测试类来测试责任链的工作情况。

1. @SpringBootApplication
2. public class ChainOfResponsibilityApplication implements CommandLineRunner {
4.     @Autowired
5.     private LeaveService leaveService;
7.     public static void main(String[] args) {
8.         SpringApplication.run(ChainOfResponsibilityApplication.class, args);
9.     }
11.     @Override
12.     public void run(String... args) throws Exception {
13.         LeaveRequest request1 = new LeaveRequest(1);
14.         LeaveRequest request2 = new LeaveRequest(2);
15.         LeaveRequest request3 = new LeaveRequest(4);
17.         leaveService.submitLeaveRequest(request1);
18.         leaveService.submitLeaveRequest(request2);
19.         leaveService.submitLeaveRequest(request3);
20.     }
21. }

复制代码

运行程序后，输出结果如下：

1. 组长批准了 1 天的请假申请。
2. 经理批准了 2 天的请假申请。
3. 总监批准了 4 天的请假申请。

复制代码

3. 责任链模式的优缺点

3.1 优点

• 解耦：请求的发送者和处理者之间没有直接的依赖关系，降低了系统的耦合度。
  
• 灵活性：可以动态地增加或修改处理链，符合开闭原则。
  
• 责任分离：每个处理者只负责处理自己能处理的请求，职责清晰。
  

3.2 缺点

• 性能问题：如果责任链过长，可能会导致请求处理速度变慢。
  
• 调试困难：由于请求在链中传递，调试时可能难以跟踪请求的处理过程。
  

4. 总结

责任链模式是一种非常实用的设计模式，特别适用于需要多级处理的场景。通过责任链模式，我们可以将复杂的处理逻辑分解到多个处理者中，使得系统更加灵活和可扩展。在Spring Boot中，我们可以通过依赖注入和配置类来轻松实现责任链模式。
希望这篇博客能帮助你更好地理解责任链模式，并在实际项目中灵活运用。如果你有任何问题或建议，欢迎在评论区留言！

来源：程序园用户自行投稿发布，如果侵权，请联系站长删除
免责声明：如果侵犯了您的权益，请联系站长，我们会及时删除侵权内容，谢谢合作！