设计模式——责任链模式

什么是责任链模式

责任链，顾名思义，首先责任就是对于需要被处理的请求对象进行处理的责任对象，而在责任链模式中，一个请求处理的对象通常对应一个处理者的链。而每个处理者通常都包含下一个处理者的引用。

责任链模式UML

首先，一个请求会对应一个Handler处理链。在处理对象中有一个successor后继处理者和处理方法，在处理方法中会将请求作为入参，然后判断请求的类型或者数值等等，如果符合那么做一些处理，如果不符合过滤请求那么就调用下一个successor后继处理对象的处理方法

代码

处理者的抽象类

public abstract class AbstractApprover {

  private AbstractApprover abstractApprover;

  private String name;

  public String getName() {
    return name;
  }

  public AbstractApprover getAbstractApprover() {
    return abstractApprover;
  }

  public void setApprover(AbstractApprover abstractApprover) {
    this.abstractApprover = abstractApprover;
  }

  public abstract void process(PurchaseRequest purchaseRequest);

  public AbstractApprover(String name) {
    this.name = name;
  }
}

具体处理者

public class DepartmentApprover extends AbstractApprover{
  public DepartmentApprover(String name) {
    super(name);
  }

  @Override
  public void process(PurchaseRequest purchaseRequest) {
    if (purchaseRequest.getPrice() <= 5000) {
      System.out.println("这个请求被" + this.getName() + "处理了");
    } else {
      this.getAbstractApprover().process(purchaseRequest);
    }
  }
}


public class CollegeApprover extends AbstractApprover{
  public CollegeApprover(String name) {
    super(name);
  }

  @Override
  public void process(PurchaseRequest purchaseRequest) {
    if (purchaseRequest.getPrice() <= 10000) {
      System.out.println("这个请求被" + this.getName() + "处理了");
    } else {
      this.getAbstractApprover().process(purchaseRequest);
    }
  }
}

public class ViceSchoolMasterApprover extends AbstractApprover{
  public ViceSchoolMasterApprover(String name) {
    super(name);
  }

  @Override
  public void process(PurchaseRequest purchaseRequest) {
    if (purchaseRequest.getPrice() <= 30000) {
      System.out.println("这个请求被" + this.getName() + "处理了");
    } else {
      this.getAbstractApprover().process(purchaseRequest);
    }
  }
}


public class SchoolMasterApprover extends AbstractApprover{
  public SchoolMasterApprover(String name) {
    super(name);
  }

  @Override
  public void process(PurchaseRequest purchaseRequest) {
    if (purchaseRequest.getPrice() <= 50000) {
      System.out.println("这个请求被" + this.getName() + "处理了");
    } else {
      this.getAbstractApprover().process(purchaseRequest);
    }
  }
}

需要被处理的请求(当然我们可以面向接口，但是这里直接就是实体类了)

public class PurchaseRequest {
  private int type;
  private float price;
  private int id;
  public PurchaseRequest(int type, float price, int id) {
    this.type = type;
    this.price = price;
    this.id = id;
  }
  public int getType() {
    return type;
  }
  public void setType(int type) {
    this.type = type;
  }
  public float getPrice() {
    return price;
  }
  public void setPrice(float price) {
    this.price = price;
  }
  public int getId() {
    return id;
  }
  public void setId(int id) {
    this.id = id;
  }

}

客户端

public class Client {

  public static void main(String[] args) {

    PurchaseRequest purchaseRequest = new PurchaseRequest(1, 40000, 1);

    AbstractApprover departmentApprover = new DepartmentApprover("主任");
    AbstractApprover collegeApprover = new CollegeApprover("院长");
    AbstractApprover viceSchoolMasterApprover = new ViceSchoolMasterApprover("副校长");
    AbstractApprover schoolMasterApprover = new SchoolMasterApprover("校长");

    departmentApprover.setApprover(collegeApprover);
    collegeApprover.setApprover(viceSchoolMasterApprover);
    viceSchoolMasterApprover.setApprover(schoolMasterApprover);

    departmentApprover.process(purchaseRequest);
  }

}

总结

责任链模式的好处

1. 将处理对象和被处理者分开，如果不使用责任链的话，被处理对象要知道什么时候去调用处理方法，逻辑混合在一起，代码耦合严重。

2. 简化了被处理对象，被处理对象不需要知道处理者的结构和链式结构。

   责任链模式的缺点

3. 当链比较长的时候 性能会受到影响，因此要控制链的总长度