【设计模式】责任链模式

【一】责任链模式

顾名思义，责任链模式（Chain of Responsibility Pattern）为请求创建了一个接收者对象的链。这种模式给予请求的类型，对请求的发送者和接收者进行解耦。这种类型的设计模式属于行为型模式。

在这种模式中，通常每个接收者都包含对另一个接收者的引用。如果一个对象不能处理该请求，那么它会把相同的请求传给下一个接收者，依此类推。

【二】介绍

（1）意图

避免请求发送者与接收者耦合在一起，让多个对象都有可能接收请求，将这些对象连接成一条链，并且沿着这条链传递请求，直到有对象处理它为止。

（2）主要解决

职责链上的处理者负责处理请求，客户只需要将请求发送到职责链上即可，无须关心请求的处理细节和请求的传递，所以职责链将请求的发送者和请求的处理者解耦了。

（3）何时使用

在处理消息的时候以过滤很多道。

（4）如何解决

拦截的类都实现统一接口。

（5）关键代码

Handler 里面聚合它自己，在 HandlerRequest 里判断是否合适，如果没达到条件则向下传递，向谁传递之前 set 进去。

（6）应用实例

1、红楼梦中的"击鼓传花"。 2、JS 中的事件冒泡。 3、JAVA WEB 中 Apache Tomcat 对 Encoding 的处理，Struts2 的拦截器，jsp servlet 的 Filter。

（7）优点

1、降低耦合度。它将请求的发送者和接收者解耦。 2、简化了对象。使得对象不需要知道链的结构。 3、增强给对象指派职责的灵活性。通过改变链内的成员或者调动它们的次序，允许动态地新增或者删除责任。 4、增加新的请求处理类很方便。

（8）缺点

1、不能保证请求一定被接收。 2、系统性能将受到一定影响，而且在进行代码调试时不太方便，可能会造成循环调用。 3、可能不容易观察运行时的特征，有碍于除错。

（9）使用场景

1、有多个对象可以处理同一个请求，具体哪个对象处理该请求由运行时刻自动确定。 2、在不明确指定接收者的情况下，向多个对象中的一个提交一个请求。 3、可动态指定一组对象处理请求。

（10）注意事项

在 JAVA WEB 中遇到很多应用。

【三】实现案例

（1）介绍

我们创建抽象类 AbstractLogger，带有详细的日志记录级别。然后我们创建三种类型的记录器，都扩展了 AbstractLogger。每个记录器消息的级别是否属于自己的级别，如果是则相应地打印出来，否则将不打印并把消息传给下一个记录器。

（2）创建抽象的记录器类

public abstract class AbstractLogger {
   public static int INFO = 1;
   public static int DEBUG = 2;
   public static int ERROR = 3;
 
   protected int level;
 
   //责任链中的下一个元素
   protected AbstractLogger nextLogger;
 
   public void setNextLogger(AbstractLogger nextLogger){
      this.nextLogger = nextLogger;
   }
 
   public void logMessage(int level, String message){
      // 如果传的参数level大于等于已有的level，则写日志
      if(this.level <= level){
         write(message);
      }
      // 如果下一个记录器不为null
      if(nextLogger !=null){
         nextLogger.logMessage(level, message);
      }
   }
 
   abstract protected void write(String message);
   
}

（3）创建扩展了该记录器类的实体类

public class ConsoleLogger extends AbstractLogger {
 
   public ConsoleLogger(int level){
      this.level = level;
   }
 
   @Override
   protected void write(String message) {    
      System.out.println("Standard Console::Logger: " + message);
   }
}


public class ErrorLogger extends AbstractLogger {
 
   public ErrorLogger(int level){
      this.level = level;
   }
 
   @Override
   protected void write(String message) {    
      System.out.println("Error Console::Logger: " + message);
   }
}


public class FileLogger extends AbstractLogger {
 
   public FileLogger(int level){
      this.level = level;
   }
 
   @Override
   protected void write(String message) {    
      System.out.println("File::Logger: " + message);
   }
}

（4）创建不同类型的记录器

创建不同类型的记录器。赋予它们不同的错误级别，并在每个记录器中设置下一个记录器。每个记录器中的下一个记录器代表的是链的一部分。

public class ChainPatternDemo {
   
   private static AbstractLogger getChainOfLoggers(){
 
      AbstractLogger errorLogger = new ErrorLogger(AbstractLogger.ERROR);
      AbstractLogger fileLogger = new FileLogger(AbstractLogger.DEBUG);
      AbstractLogger consoleLogger = new ConsoleLogger(AbstractLogger.INFO);
 
      errorLogger.setNextLogger(fileLogger);
      fileLogger.setNextLogger(consoleLogger);
 
      return errorLogger;  
   }
 
   public static void main(String[] args) {
      AbstractLogger loggerChain = getChainOfLoggers();
 
      loggerChain.logMessage(AbstractLogger.INFO, "This is an information.");
 
      loggerChain.logMessage(AbstractLogger.DEBUG, 
         "This is a debug level information.");
 
      loggerChain.logMessage(AbstractLogger.ERROR, 
         "This is an error information.");
   }
}

输出结果

Standard Console::Logger: This is an information.
File::Logger: This is a debug level information.
Standard Console::Logger: This is a debug level information.
Error Console::Logger: This is an error information.
File::Logger: This is an error information.
Standard Console::Logger: This is an error information.

【四】更多案例介绍

【1】责任链模式解决采购审批问题

1-创建采购请求的实体类

/**
 * @ClassName: PurchaseRequest
 * @Author: AllenSun
 * @Date: 2020/3/9 22:36
 */
public class PurchaseRequest {

    private int type=0;
    private float price=0.0f;
    private int id=0;

    public PurchaseRequest(int type, float price, int id) {
        this.type = type;
        this.price = price;
        this.id = id;
    }

    public int getType() {
        return type;
    }

    public float getPrice() {
        return price;
    }

    public int getId() {
        return id;
    }
}

2-创建抽象的采购审批类

/**
 * @ClassName: Approver
 * @Author: AllenSun
 * @Date: 2020/3/9 22:31
 */
public abstract class Approver {
    //下一个处理者
    Approver approver;
    //名字
    String name;

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

    //下一个处理者
    public void setApprover(Approver approver) {
        this.approver = approver;
    }

    //处理审批请求的方法，得到一个请求，处理是子类完成，因此该方法做成抽象
    public abstract void processRequest(PurchaseRequest purchaseRequest);
}

3-创建扩展了该审批类的实体类

/**
 * @ClassName: CollegeApprover
 * @Author: AllenSun
 * @Date: 2020/3/9 22:34
 */
public class DepartmentApprover extends Approver {
    public DepartmentApprover(String name) {
        super(name);
    }

    @Override
    public void processRequest(PurchaseRequest purchaseRequest) {
        if(purchaseRequest.getPrice()<=5000){
            System.out.println("请求编号id="+purchaseRequest.getId()+"被"+this.name+"处理");

        } else {
            approver.processRequest(purchaseRequest);
        }
    }
}

/**
 * @ClassName: CollegeApprover
 * @Author: AllenSun
 * @Date: 2020/3/9 22:34
 */
public class CollegeApprover extends Approver {
    public CollegeApprover(String name) {
        super(name);
    }

    @Override
    public void processRequest(PurchaseRequest purchaseRequest) {
        if(purchaseRequest.getPrice()>5000&&purchaseRequest.getPrice()<=10000){
            System.out.println("请求编号id="+purchaseRequest.getId()+"被"+this.name+"处理");

        } else {
            approver.processRequest(purchaseRequest);
        }

    }
}

/**
 * @ClassName: CollegeApprover
 * @Author: AllenSun
 * @Date: 2020/3/9 22:34
 */
public class ViceSchoolMasterApprover extends Approver {
    public ViceSchoolMasterApprover(String name) {
        super(name);
    }

    @Override
    public void processRequest(PurchaseRequest purchaseRequest) {
        if(purchaseRequest.getPrice()>10000&&purchaseRequest.getPrice()<=30000){
            System.out.println("请求编号id="+purchaseRequest.getId()+"被"+this.name+"处理");

        } else {
            approver.processRequest(purchaseRequest);
        }
    }
}

/**
 * @ClassName: CollegeApprover
 * @Author: AllenSun
 * @Date: 2020/3/9 22:34
 */
public class SchoolMasterApprover extends Approver {
    public SchoolMasterApprover(String name) {
        super(name);
    }

    @Override
    public void processRequest(PurchaseRequest purchaseRequest) {
        if(purchaseRequest.getPrice()>30000){
            System.out.println("请求编号id="+purchaseRequest.getId()+"被"+this.name+"处理");

        } else {
            approver.processRequest(purchaseRequest);
        }
    }
}

4-设置责任链，测试类

/**
 * @ClassName: Client
 * @Author: AllenSun
 * @Date: 2020/3/9 22:50
 */
public class Client {
    public static void main(String[] args) {
        //创建一个请求
        PurchaseRequest purchaseRequest=new PurchaseRequest(1,31000,1);

        //创建相关的审批人
        DepartmentApprover departmentApprover=new DepartmentApprover("张主任");
        CollegeApprover collegeApprover=new CollegeApprover("李院长");
        ViceSchoolMasterApprover viceSchoolMasterApprover=new ViceSchoolMasterApprover("王副校长");
        SchoolMasterApprover schoolMasterApprover=new SchoolMasterApprover("孙校长");

        //需要把各个审批级别的下一个设置好（处理人构成环形）
        departmentApprover.setApprover(collegeApprover);
        collegeApprover.setApprover(viceSchoolMasterApprover);
        viceSchoolMasterApprover.setApprover(schoolMasterApprover);
        schoolMasterApprover.setApprover(departmentApprover);

        departmentApprover.processRequest(purchaseRequest);
        viceSchoolMasterApprover.processRequest(purchaseRequest);
    }
}

【2】责任链模式解决登录过程的数据校验问题

在日常生活中责任链模式还是比较常见的，我们平时工作处理一些事务，往往是各部门协同合作的完成—个任务。而每个部门都有各自的职责，因此，很多时候事谓完成—半，便会转交给下—个部门，直到所有部门都过一渔之后事谓才能完成。

1-创建一个实体类Member

@Data
public class Member {
    private String loginName;
    private String loginPass;
    private String roleName;

    public Member(String loginName, String loginPass) {
        this.loginName = loginName;
        this.loginPass = loginPass;
    }
}

2-传统方式的登录校验代码

public class MemberService {
    public static void main(String[] args) {
        MemberService service = new MemberService();
        service.login("tom", "666");
    }

    public void login(String loginName, String loginPass) {
        if (StringUtils.isEmpty(loginName) ||
                StringUtils.isEmpty(loginPass)) {
            System.out.println("用户名和密码为空");
            return;
        }
        System.out.println("用户名和密码不为空，可以往下执行");
        Member member = checkExists(loginName, loginPass);
        if (null == member) {
            System.out.println("用户不存在");
            return;
        }
        System.out.println("登录成功！");
        if (!"管理员".equals(member.getRoleName())) {
            System.out.println("您不是管理员，没有操作权限");
            return;
        }
        System.out.println("允许操作");
    }

    private Member checkExists(String loginName, String loginPass) {
        Member member = new Member(loginName, loginPass);
        member.setRoleName("管理员");
        return member;
    }
}

3-开始使用责任链模式优化，创建抽象的处理类Handler

public abstract class Handler {
    protected Handler next;
    public void next(Handler next){ this.next = next;}
    public abstract void doHandler(Member member);
}

4-创建扩展了处理类的实体类

我们分别创建非空校验ValidateHandler类、登录校验LoginHandler类和权限校验AuthHandler类

public class ValidateHandler extends Handler {
    public void doHandler(Member member) {
        if (StringUtils.isEmpty(member.getLoginName()) ||
                StringUtils.isEmpty(member.getLoginPass())) {
            System.out.println("用户名和密码为空");
            return;
        }
        System.out.println("用户名和密码不为空，可以往下执行");
        next.doHandler(member);
    }
}

public class LoginHandler extends Handler {
    public void doHandler(Member member) {
        System.out.println("登录成功！");
        member.setRoleName("管理员");
        next.doHandler(member);
    }
}

public class AuthHandler extends Handler {
    public void doHandler(Member member) {
        if (!"管理员".equals(member.getRoleName())) {
            System.out.println("您不是管理员，没有操作权限");
            return;
        }
        System.out.println("允许操作");
    }
}

5-在服务层设置链

public class MemberService {

    public void login(String loginName, String loginPass) {
        Handler validateHandler = new ValidateHandler();
        Handler loginHandler = new LoginHandler();
        Handler authHandler = new AuthHandler();
        validateHandler.next(loginHandler);
        loginHandler.next(authHandler);
        validateHandler.doHandler(new Member(loginName, loginPass));
    }
}

6-测试代码

public class Test {
    public static void main(String[] args) {
        MemberService memberService = new MemberService();
        memberService.login("tom","666");
    }
}

测试结果

用户名和密码校验成功，可以往下执行
登录成功!
您是管理员，允许操作

7-责任链模式+建造者模式结合使用优化

因为责任链模式具备链式结构，而上面代码中，我们看到，负责组装链式结构的角色是
MemberService ,当链式结构较长时,MemberService的工作会非常繁琐,并且MemberService代码相对臃肿，且后续更改处理者或消息类型时，都必须在MemberService中进行修改,不符合开闭原则。产生这些问题的原因就是因为链式结构的组装过于复杂,而对于复杂结构的创建，很自然我们就会想到建造者模式,使用建造者模式，我们完全可以MemberService指定的处理节点对象进行自动链式组装，客户只需指定处理节点对象，其他任何事情都无需关心，并且客户指定的处理节点对象顺序不同 ，构造出来的链式结构也随之不同。我们来改造一下，修改Handler的代码：

public abstract class Handler<T> {
    protected Handler next;
    //public void next(Handler next){ this.next = next;}
    private void next(Handler next){ this.next = next;}

    public abstract void doHandler(Member member);

    public static class Builder<T>{
        private Handler<T> head;
        private Handler<T> tail;

        public Builder<T> addHandler(Handler handler){
           // do {
                if (this.head == null) {
                    this.head = this.tail = handler;
                    return this;
                }
                this.tail.next(handler);
                this.tail = handler;
           // }while (false);//真正框架中，如果是双向链表，会判断是否已经到了尾部
            return this;
        }

        public Handler<T> build(){
            return this.head;
        }
    }
}

然后 ，修改MemberService的代码：

public class MemberService {
    public void login(String loginName,String loginPass){
        Handler.Builder builder = new Handler.Builder();
        builder.addHandler(new ValidateHandler())
               .addHandler(new LoginHandler())
               .addHandler(new AuthHandler());
        builder.build().doHandler(new Member(loginName,loginPass));
        //用过Netty的人，肯定见过
    }
}

【3】责任链模式实现请假审批流程

（1）介绍

责任链模式是将多个处理对象连成一条链，请求沿着链传递，直到有一个对象处理它为止。这样可以解耦发送者和接收者，增加灵活性。

通常，公司的请假流程会有不同级别的审批人，比如组长、经理、HR等等，请假天数不同，审批人不同。比如1天内组长批，3天内项目经理批，超过3天需要HR批，最终都由部门主管批。这种情况下，责任链模式就很适合，每个处理者处理自己能处理的请求，否则传递给下一个。

（2）代码实现

（1）请假请求类（包含审批记录）

import java.util.ArrayList;
import java.util.List;

public class LeaveRequest {
    private String employeeId;
    private String startTime;
    private String endTime;
    private int days;
    private String reason;
    private List<ApprovalResult> approvalResults = new ArrayList<>();

    // 构造方法、Getter、审批记录操作
    public LeaveRequest(String employeeId, String startTime, String endTime, int days, String reason) {
        this.employeeId = employeeId;
        this.startTime = startTime;
        this.endTime = endTime;
        this.days = days;
        this.reason = reason;
    }

    public void addApprovalResult(String approverName, boolean approved, String reason) {
        approvalResults.add(new ApprovalResult(approverName, approved, reason));
    }

    public static class ApprovalResult {
        private String approver;
        private boolean approved;
        private String reason;

        public ApprovalResult(String approver, boolean approved, String reason) {
            this.approver = approver;
            this.approved = approved;
            this.reason = reason;
        }

        // Getter
    }
}

（2）抽象审批者

public abstract class Approver {
    protected Approver next;

    public void setNext(Approver next) {
        this.next = next;
    }

    public abstract void handleRequest(LeaveRequest request);
}

（3）具体审批者（组长、项目经理、HR、部门主管）

public class GroupLeader extends Approver {
    @Override
    public void handleRequest(LeaveRequest request) {
        if (request.getDays() <= 1) {
            boolean approved = true; // 实际业务中根据规则判断
            String reason = "同意，短期请假无影响";
            request.addApprovalResult("组长", approved, reason);
            System.out.println("【组长】审批结果：" + approved + "，理由：" + reason);
        }
        if (next != null) next.handleRequest(request); // 传递给下一节点
    }
}

public class ProjectManager extends Approver {
    @Override
    public void handleRequest(LeaveRequest request) {
        if (request.getDays() > 1 && request.getDays() <= 3) {
            boolean approved = true;
            String reason = "项目进度允许，批准请假";
            request.addApprovalResult("项目经理", approved, reason);
            System.out.println("【项目经理】审批结果：" + approved + "，理由：" + reason);
        }
        if (next != null) next.handleRequest(request);
    }
}

public class HR extends Approver {
    @Override
    public void handleRequest(LeaveRequest request) {
        if (request.getDays() > 3) {
            boolean approved = true;
            String reason = "符合长假政策";
            request.addApprovalResult("HR", approved, reason);
            System.out.println("【HR】审批结果：" + approved + "，理由：" + reason);
        }
        if (next != null) next.handleRequest(request);
    }
}

public class DepartmentManager extends Approver {
    @Override
    public void handleRequest(LeaveRequest request) {
        boolean approved = true; // 部门主管最终决策
        String reason = "部门最终批准";
        request.addApprovalResult("部门主管", approved, reason);
        System.out.println("【部门主管】审批结果：" + approved + "，理由：" + reason);
    }
}

（4）构建责任链并测试

public class Main {
    public static void main(String[] args) {
        // 构建责任链
        Approver groupLeader = new GroupLeader();
        Approver projectManager = new ProjectManager();
        Approver hr = new HR();
        Approver deptManager = new DepartmentManager();

        groupLeader.setNext(projectManager);
        projectManager.setNext(hr);
        hr.setNext(deptManager);

        // 测试不同天数的请假
        LeaveRequest request1 = new LeaveRequest("1001", "2023-10-01", "2023-10-01", 1, "事假");
        groupLeader.handleRequest(request1);

        LeaveRequest request2 = new LeaveRequest("1002", "2023-10-02", "2023-10-04", 3, "病假");
        groupLeader.handleRequest(request2);

        LeaveRequest request3 = new LeaveRequest("1003", "2023-10-05", "2023-10-09", 5, "旅游");
        groupLeader.handleRequest(request3);
    }
}

（5）执行结果

【组长】审批结果：true，理由：同意，短期请假无影响
【部门主管】审批结果：true，理由：部门最终批准

【项目经理】审批结果：true，理由：项目进度允许，批准请假
【部门主管】审批结果：true，理由：部门最终批准

【HR】审批结果：true，理由：符合长假政策
【部门主管】审批结果：true，理由：部门最终批准