介绍

  1. 职责链模式（Chain of Responsibility Pattern）, 又叫责任链模式，为请求创建了一个接收者对象的链(简单示意图)。这种模式对请求的发送者和接收者进行解耦。
  2. 职责链模式通常每个接收者都包含对另一个接收者的引用。如果一个对象不能处理该请求， 那么它会把相同的请求传给下一个接收者，依此类推。

原理

image-20201018131652462.png
对原理类图的说明-即(职责链模式的角色及职责)

  1. Handler : 抽象的处理者, 定义了一个处理请求的接口, 同时含义另外Handler
  2. ConcreteHandlerA , B 是具体的处理者, 处理它自己负责的请求， 可以访问它的后继者(即下一个处理者), 如果可以处理当前请求，则处理，否则就将该请求交个 后继者去处理，从而形成一个职责链
  3. Request ， 含义很多属性，表示一个请求

案例

学校OA系统的采购审批项目：需求是

  1. 采购员采购教学器材
  2. 如果金额小于等于5000, 由教学主任审批（0<=x<=5000）
  3. 如果金额 小于等于10000, 由院长审批 (5000<x<=10000)
  4. 如果金额小于等于30000, 由副校长审批 (10000<x<=30000)
  5. 如果金额超过30000以上，有校长审批( 30000<x) 
  1. //采购请求
  2. public class PurchaseRequest {
  3.     private String id;
  4.     private double money;
  7.     public PurchaseRequest(String id, double money) {
  8.         this.id = id;
  9.         this.money = money;
  10.     }
  12.     public String getId() {
  13.         return id;
  14.     }
  16.     public void setId(String id) {
  17.         this.id = id;
  18.     }
  20.     public double getMoney() {
  21.         return money;
  22.     }
  24.     public void setMoney(double money) {
  25.         this.money = money;
  26.     }
  28. }
  1. //抽象处理类
  2. public abstract class Approver {
  3.     private String name;
  4.     private Approver approver;        //包含下一个处理对象
  6.     public Approver(String name) {
  7.         this.name = name;
  8.     }
  11.     public String getName() {
  12.         return name;
  13.     }
  15.     public void setName(String name) {
  16.         this.name = name;
  17.     }
  19.     public Approver getApprover() {
  20.         return approver;
  21.     }
  23.     public void setApprover(Approver approver) {
  24.         this.approver = approver;
  25.     }
  28.     public abstract void handleRequest(PurchaseRequest purchaseRequest); //具体处理类实现的处理请求的方法
  29. }
  1. //4个具体处理类
  2. public class DepartmentApprover extends Approver{
  3.     public DepartmentApprover(String name) {
  4.         super(name);
  5.     }
  7.     @Override
  8.     public void handleRequest(PurchaseRequest purchaseRequest) {
  9.         if (purchaseRequest.getMoney()<5000){
  10.             System.out.println("编号为"+purchaseRequest.getId()+"的购买请求"+this.getName()+"已处理");
  11.         }else{
  12.             this.getApprover().handleRequest(purchaseRequest);
  13.         }
  14.     }
  15. }
  17. public class ColleageApprover extends Approver{
  18.     public ColleageApprover(String name) {
  19.         super(name);
  20.     }
  22.     @Override
  23.     public void handleRequest(PurchaseRequest purchaseRequest) {
  24.         if (purchaseRequest.getMoney()>5000&&purchaseRequest.getMoney()<10000){
  25.             System.out.println("编号为"+purchaseRequest.getId()+"的购买请求"+this.getName()+"已处理");
  26.         }else{
  27.             this.getApprover().handleRequest(purchaseRequest);
  28.         }
  29.     }
  30. }
  32. public class ViceSchoolMasterApprover extends Approver{
  33.     public ViceSchoolMasterApprover(String name) {
  34.         super(name);
  35.     }
  37.     @Override
  38.     public void handleRequest(PurchaseRequest purchaseRequest) {
  39.         if (purchaseRequest.getMoney()>10000&&purchaseRequest.getMoney()<30000){
  40.             System.out.println("编号为"+purchaseRequest.getId()+"的购买请求"+this.getName()+"已处理");
  41.         }else{
  42.             this.getApprover().handleRequest(purchaseRequest);
  43.         }
  44.     }
  45. }
  47. public class SchoolMasterApprover extends Approver{
  48.     public SchoolMasterApprover(String name) {
  49.         super(name);
  50.     }
  52.     @Override
  53.     public void handleRequest(PurchaseRequest purchaseRequest) {
  54.         if (purchaseRequest.getMoney()>30000){
  55.             System.out.println("编号为"+purchaseRequest.getId()+"的购买请求"+this.getName()+"已处理");
  56.         }else{
  57.             this.getApprover().handleRequest(purchaseRequest);
  58.         }
  59.     }
  60. }
  1. //测试类
  2. public class Client {
  3.     public static void main(String[] args) {
  4.         //创建采购请求
  5.         PurchaseRequest Request = new PurchaseRequest("1", 50000);
  7.         //创建处理对象
  8.         DepartmentApprover departmentApprover = new DepartmentApprover("成主任");
  9.         ColleageApprover colleageApprover = new ColleageApprover("李院长");
  10.         ViceSchoolMasterApprover viceSchoolMasterApprover = new ViceSchoolMasterApprover("阮副校长");
  11.         SchoolMasterApprover schoolMasterApprover = new SchoolMasterApprover("张校长");
  13.         //把处理对象连成一个环链
  14.         departmentApprover.setApprover(colleageApprover);
  15.         colleageApprover.setApprover(viceSchoolMasterApprover);
  16.         viceSchoolMasterApprover.setApprover(schoolMasterApprover);
  17.         schoolMasterApprover.setApprover(departmentApprover);
  19.         departmentApprover.handleRequest(Request);
  20.     }
  21. }

image-20201018132233886.png

职责链模式的注意事项和细节

  1. 将请求和处理分开，实现解耦，提高系统的灵活性
  2. 简化了对象，使对象不需要知道链的结构
  3. 性能会受到影响，特别是在链比较长的时候，因此需控制链中最大节点数量，一般通过在Handler中设置一个最大节点数量，在setNext()方法中判断是否已经超过阀值， 超过则不允许该链建立，避免出现超长链无意识地破坏系统性能
  4. 调试不方便。采用了类似递归的方式，调试时逻辑可能比较复杂
  5. 最佳应用场景：有多个对象可以处理同一个请求时，比如：多级请求、请假/加薪等审批流程、Java Web中Tomcat对Encoding的处理、拦截器

个人总结
此模式关键是需要使得所有处理者成为一个链表，即自身的下一个节点是另外一个处理者，这样自身处理不了的请求，抛给下一个节点处理即可。