什么是责任链模式

责任链模式是一种行为型设计模式，它允许多个对象都有机会处理请求，从而避免请求的发送者和接受者之间的耦合关系。将这些对象连城一条链，并沿着这种链传递请求，直到有对象处理它为止。

简单来说，就是多个处理器排成一条链，一个请求依次经过这些处理器，哪个处理器能处理就处理，不能处理就传给下一个，直到请求被处理或者链结束。

责任链模式的结构

抽象处理器

定义一个处理请求的接口，通常包含一个处理方法和设置下一个处理器的方法；

具体处理器

实现抽象处理器接口，处理它负责的请求；如果它能处理就处理，否则将请求传递给链中的下一个处理器；

客户端

创建处理器链，并向链上的第一个处理器递交请求

责任链模式UML图

简单的责任链例子

通过一个简单的例子来说明：请假审批流程，整体设计如下：

假设公司员工请假，由不同的审批层级审批。例如 团队主管 ==> 开发经理 ==> 部门总监 ，一共需要经过三个步骤的审批。

1️⃣定义一个请求的实体类

// 请假请求
public class LeaveRequest {
    private String employeeName;
    private int leaveDays;

    public LeaveRequest(String employeeName, int leaveDays) {
        this.employeeName = employeeName;
        this.leaveDays = leaveDays;
    }

    public String getEmployeeName() {
        return employeeName;
    }

    public int getLeaveDays() {
        return leaveDays;
    }
}

2️⃣定义一个的抽象的Handler

// 抽象审批者
public interface Approver {

    public void approve(LeaveRequest leaveRequest);

    public void setNext(Approver approver);

}

3️⃣定义具体的实现handler

// 基础的Handler要求
public abstract class BaseApprover implements Approver {


    private Approver nextApprover;

    @Override
    public void setNext(Approver nextApprover) {
        this.nextApprover = nextApprover;
    }

    @Override
    public void approve(LeaveRequest leaveRequest) {
        this.handleApprove(leaveRequest);
        if (nextApprover != null) {
            nextApprover.approve(leaveRequest);
        }
    }

    /**
     * 处理审批
     * @param leaveRequest 请假请求
     */
    protected abstract void handleApprove(LeaveRequest leaveRequest);
}

public class TeamLeaderApprover extends BaseApprover {

    @Override
    protected void handleApprove(LeaveRequest leaveRequest) {
        System.out.println("团队领导审批");
    }
}

public class ManagerApprover extends BaseApprover{

    @Override
    protected void handleApprove(LeaveRequest leaveRequest) {
        System.out.println("经理审批");
    }
}

public class DirectorApprover extends BaseApprover {

    @Override
    protected void handleApprove(LeaveRequest leaveRequest) {
        System.out.println("总监审批");
    }
}

4️⃣组装责任链

public class LeaveApproverChain {

    private static volatile Approver approver;

    private LeaveApproverChain() {
    }

    public static Approver getApprover() {
        if (LeaveApproverChain.approver == null) {
            synchronized (LeaveApproverChain.class) {
                if (LeaveApproverChain.approver == null) {
                    TeamLeaderApprover teamLeaderApprover = new TeamLeaderApprover();
                    ManagerApprover managerApprover = new ManagerApprover();
                    DirectorApprover directorApprover = new DirectorApprover();

                    teamLeaderApprover.setNext(managerApprover);
                    managerApprover.setNext(directorApprover);

                    LeaveApproverChain.approver = teamLeaderApprover;
                }
            }
        }
        return LeaveApproverChain.approver;
    }

}

5️⃣测试审批流程

    public static void main(String[] args) {
        Approver approver = LeaveApproverChain.getApprover();
        // 张三请求2天
        approver.approve(new LeaveRequest("张三", 2));
    }

输出结果：

团队领导审批
经理审批
总监审批

@startuml SpringMVC执行流程

actor 用户 as User
participant DispatcherServlet as DS
participant HandlerMapping as HM
participant HandlerAdapter as HA
participant Controller as C
participant ModelAndView as MV
participant ViewResolver as VR
participant View as V
participant 响应 as Response

User -> DS : 1. 发送HTTP请求
DS -> HM : 2. 查找Handler
HM --> DS : 3. 返回Handler
DS -> HA : 4. 获取HandlerAdapter
HA -> C : 5. 调用Controller方法
C --> MV : 6. 返回ModelAndView
MV --> HA
HA --> DS
DS -> VR : 7. 解析视图
VR --> DS : 8. 返回View
DS -> V : 9. 渲染视图
V --> Response : 10. 生成响应
Response --> User : 11. 返回给用户

note top of DS: DispatcherServlet 是核心控制器
note right of HM: 根据URL找到对应Handler
note left of HA: 适配并调用Controller
note bottom of VR: 解析逻辑视图名为真实视图
@enduml