设计模式之责任链模式

责任链模式是面向对象的23种设计模式中的一种，属于行为模式范围。
责任链模式（Chain of Responsibility），
见名知意：就是每一个处理请求的处理器组合成一个链表，链表中的每个节点（执行器）都有机会处理发送的请求。
大致的结构是这个样子：

 

举一个简单的例子：
某公司有一名新员工要入职，则入职过程大致分为三步：
1、签订劳动合同
2、员工信息入库
3、下发工卡
我们按照责任链模式的思路来设计这块业务：
类图如下：

代码如下：
处理器接口

1. 1 package com.example.demo.learn.pattern.behavior.responsibilitychain;
2. 2
3. 3 public interface IHandler {
4. 4     boolean handle(Employee employee);
5. 5 }

复制代码

合同处理器

1. 1 package com.example.demo.learn.pattern.behavior.responsibilitychain;
2. 2
3. 3 /**
4. 4  * @discription
5. 5  */
6. 6 public class CardHandler implements IHandler{
7. 7     @Override
8. 8     public boolean handle(Employee employee) {
9. 9         System.out.println("制作工牌：工号"+employee.getId()+" 姓名:"+employee.getName());
10. 10         return true;
11. 11     }
12. 12 }

复制代码

协议处理器

1. 1 package com.example.demo.learn.pattern.behavior.responsibilitychain;
2. 2
3. 3 /**
4. 4  * @discription
5. 5  */
6. 6 public class ContractHandler implements IHandler {
7. 7     @Override
8. 8     public boolean handle(Employee employee) {
9. 9         System.out.println("签订合同：" + employee);
10. 10         return true;
11. 11     }
12. 12 }

复制代码

系统流程处理器

1. 1 package com.example.demo.learn.pattern.behavior.responsibilitychain;
2. 2
3. 3 import java.util.Date;
4. 4
5. 5 /**
6. 6  * @discription
7. 7  */
8. 8 public class SystemHandler implements IHandler {
9. 9     @Override
10. 10     public boolean handle(Employee employee) {
11. 11         long id = new Date().getTime();
12. 12         employee.setId(id);
13. 13         System.out.println("员工信息登入到系统中: " + employee);
14. 14         return true;
15. 15     }
16. 16 }

复制代码

员工类：业务实体

1. 1 package com.example.demo.learn.pattern.behavior.responsibilitychain;
2. 2
3. 3 import lombok.Data;
4. 4
5. 5 /**
6. 6  * @discription
7. 7  */
8. 8 @Data
9. 9 public class Employee {
10. 10     private Long id;
11. 11     private String name;
12. 12 }

复制代码

主类：责任链的编排和请求调用

1. 1 package com.example.demo.learn.pattern.behavior.responsibilitychain;
2. 2
3. 3 /**
4. 4  * @discription
5. 5  */
6. 6 public class PatternMain {
7. 7     public static void main(String[] args) {
8. 8         ContractHandler contractHandler = new ContractHandler();
9. 9         SystemHandler systemHandler = new SystemHandler();
10. 10         CardHandler cardHandler = new CardHandler();
11. 11
12. 12
13. 13         EntryChain entry = new EntryChain(contractHandler, systemHandler, cardHandler);
14. 14         String name = "小z";
15. 15         boolean result = entry.process(name);
16. 16         if (result) {
17. 17             System.out.println(name + "的入职流程已经处理完");
18. 18         }
19. 19     }
20. 20 }

复制代码

执行效果如下：

1. Connected to the target VM, address: '127.0.0.1:63269', transport: 'socket'
2. 签订合同：Employee(id=null, name=小z)
3. 员工信息入库: Employee(id=1724316937102, name=小z)
4. 制作工牌：工号1724316937102 姓名:小z
5. 小z的入职流程已经全部处理完
6. Disconnected from the target VM, address: '127.0.0.1:63269', transport: 'socket'

复制代码

来具体说下设计的核心思路：
首先我们需要定义好一个接口，这个接口规范每一个执行器（责任链节点）的执行方法。在本例中就是IHandler接口。
接着我们定义3个实现类（也就是所谓的执行器，即责任链的节点），(防盗连接：本文首发自http://www.cnblogs.com/jilodream/ )每个执行器中实现接口的方法，编写当前执行器要做的事。
最后我们需要一个链表来编排当前各个执行器的执行顺序。
当我们将请求下发，系统就可以按照责任链编排的顺序，依次执行了。
有些文章也这样定义：
抽象接口---->抽象处理器(Handler)角色
具体执行器实现---->具体处理者(ConcreteHandler)角色
责任链模式一般应用在：
1、流程编排（如电子流工单处理）
2、资源的使用（依次申请资源--->使用资源--->释放资源）
3、日志记录、权限过滤、请求预处理 （如在aop切面编程执行顺序的编排）
那么为啥要搞责任链模式呢？
我们直接从头到尾写一套流程不就行了么，这样还比较直接，易懂。
如果是简单的使用，那么肯定是可以的，但是如果要是业务流程复杂，又经常变动，以满足开闭原则为初衷，则从头到尾写一套流程就很难维护了。
所以我们可以将各个执行节点（执行器）为对象，按照具体场景，随意的调整顺序，随意的增加新的场景。从这个角度看，是不是逐渐就有了一点面向对象的意思。
设计模式除了举得这个简单的例子外，还有很多的变形：
1、有些场景将责任链的节点，保存在每一个责任链节点的next引用处，(防盗连接：本文首发自http://www.cnblogs.com/jilodream/ )从而形成一个逻辑上的单链表结构，而不是依赖某一个list来保存。
2、责任链模式既可以从中途结束返回，也可以依次的每个节点都执行，这个没有强制的约束。
3、责任链模式是一个整体的设计思路，并不是某几个固定方法，比如我们的OA流程，就是一个大的流程，可能跨多个服务，并不是某几个方法简单编排一下就可以的。
那么我们应该怎么掌握呢？个人觉得设计模式本来就是一个设计思路，没必要条条框框，按部就班的来。要根据核心思路，以实际情况为场景，来灵活的实现和使用。

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