简介

责任链模式是一种行为型设计模式，它允许你将请求沿着处理者链进行发送。每个处理者都可以对请求进行处理，或者将其传递给链上的下一个处理者。责任链模式主要应用于面向对象编程中，特别是当系统中的对象需要根据其属性来决定如何处理请求时。

在责任链模式中，通常会有多个对象（处理者）连接在一起形成一个链。当一个请求发送到链的开始时，它将沿着链传递，直到找到一个处理者来处理这个请求。如果没有处理者能够处理该请求，那么请求将沿着链继续传递，直到找到一个可以处理它的处理者。

结构

职责链模式主要包含以下角色:

• 抽象处理者（Handler）角色：定义一个处理请求的接口，包含抽象处理方法和一个后继连接。
• 具体处理者（Concrete Handler）角色：实现抽象处理者的处理方法，判断能否处理本次请求，如果可以处理请求则处理，否则将该请求转给它的后继者。
• 客户类（Client）角色：创建处理链，并向链头的具体处理者对象提交请求，它不关心处理细节和请求的传递过程。

案例实现

现需要开发一个请假流程控制系统。请假一天以下的假只需要小组长同意即可；请假1天到3天的假还需要部门经理同意；请求3天到7天还需要总经理同意才行。

类图如下：

代码如下：

//请假条
public class LeaveRequest {
    private String name;//姓名
    private int num;//请假天数
    private String content;//请假内容

    public LeaveRequest(String name, int num, String content) {
        this.name = name;
        this.num = num;
        this.content = content;
    }

    public String getName() {
        return name;
    }

    public int getNum() {
        return num;
    }

    public String getContent() {
        return content;
    }
}

//处理者抽象类
public abstract class Handler {
    protected final static int NUM_ONE = 1;
    protected final static int NUM_THREE = 3;
    protected final static int NUM_SEVEN = 7;

    //该领导处理的请假天数区间
    private int numStart;
    private int numEnd;

    //领导上面还有领导
    private Handler nextHandler;

    //设置请假天数范围 上不封顶
    public Handler(int numStart) {
        this.numStart = numStart;
    }

    //设置请假天数范围
    public Handler(int numStart, int numEnd) {
        this.numStart = numStart;
        this.numEnd = numEnd;
    }

    //设置上级领导
    public void setNextHandler(Handler nextHandler){
        this.nextHandler = nextHandler;
    }

    //提交请假条
    public final void submit(LeaveRequest leave){
        if(0 == this.numStart){
            return;
        }

        //如果请假天数达到该领导者的处理要求
        if(leave.getNum() >= this.numStart){
            this.handleLeave(leave);

            //如果还有上级 并且请假天数超过了当前领导的处理范围
            if(null != this.nextHandler && leave.getNum() > numEnd){
                this.nextHandler.submit(leave);//继续提交
            } else {
                System.out.println("流程结束");
            }
        }
    }

    //各级领导处理请假条方法
    protected abstract void handleLeave(LeaveRequest leave);
}

//小组长
public class GroupLeader extends Handler {
    public GroupLeader() {
        //小组长处理1-3天的请假
        super(Handler.NUM_ONE, Handler.NUM_THREE);
    }

    @Override
    protected void handleLeave(LeaveRequest leave) {
        System.out.println(leave.getName() + "请假" + leave.getNum() + "天," + leave.getContent() + "。");
        System.out.println("小组长审批：同意。");
    }
}

//部门经理
public class Manager extends Handler {
    public Manager() {
        //部门经理处理3-7天的请假
        super(Handler.NUM_THREE, Handler.NUM_SEVEN);
    }

    @Override
    protected void handleLeave(LeaveRequest leave) {
        System.out.println(leave.getName() + "请假" + leave.getNum() + "天," + leave.getContent() + "。");
        System.out.println("部门经理审批：同意。");
    }
}

//总经理
public class GeneralManager extends Handler {
    public GeneralManager() {
        //部门经理处理7天以上的请假
        super(Handler.NUM_SEVEN);
    }

    @Override
    protected void handleLeave(LeaveRequest leave) {
        System.out.println(leave.getName() + "请假" + leave.getNum() + "天," + leave.getContent() + "。");
        System.out.println("总经理审批：同意。");
    }
}

//测试类
public class Client {
    public static void main(String[] args) {
        //请假条来一张
        LeaveRequest leave = new LeaveRequest("小花",5,"身体不适");

        //各位领导
        GroupLeader groupLeader = new GroupLeader();
        Manager manager = new Manager();
        GeneralManager generalManager = new GeneralManager();

        groupLeader.setNextHandler(manager);//小组长的领导是部门经理
        manager.setNextHandler(generalManager);//部门经理的领导是总经理
        //之所以在这里设置上级领导，是因为可以根据实际需求来更改设置，如果实战中上级领导人都是固定的，则可以移到领导实现类中。

        //提交申请
        groupLeader.submit(leave);
    }
}

优缺点

1，优点：

• 降低了对象之间的耦合度

  该模式降低了请求发送者和接收者的耦合度。

• 增强了系统的可扩展性

  可以根据需要增加新的请求处理类，满足开闭原则。

• 增强了给对象指派职责的灵活性

  当工作流程发生变化，可以动态地改变链内的成员或者修改它们的次序，也可动态地新增或者删除责任。

• 责任链简化了对象之间的连接

  一个对象只需保持一个指向其后继者的引用，不需保持其他所有处理者的引用，这避免了使用众多的 if 或者 if···else 语句。

• 责任分担

  每个类只需要处理自己该处理的工作，不能处理的传递给下一个对象完成，明确各类的责任范围，符合类的单一职责原则。

2，缺点：

• 不能保证每个请求一定被处理。由于一个请求没有明确的接收者，所以不能保证它一定会被处理，该请求可能一直传到链的末端都得不到处理。
• 对比较长的职责链，请求的处理可能涉及多个处理对象，系统性能将受到一定影响。
• 职责链建立的合理性要靠客户端来保证，增加了客户端的复杂性，可能会由于职责链的错误设置而导致系统出错，如可能会造成循环调用。

源码中的应用

JDK

javax.servlet.Filter 接口

在Java Web开发中，Servlet Filter 是责任链模式的一个典型应用。Servlet容器在接收到HTTP请求之后，将请求逐一传递给一系列Filter，每个Filter可以选择继续处理请求、修改请求、拒绝请求或者直接响应请求。

public class AuthenticationFilter implements Filter {
    @Override
    public void doFilter(ServletRequest request, ServletResponse response, FilterChain chain) throws IOException, ServletException {
        // 认证逻辑
        chain.doFilter(request, response); // 传递请求给下一个Filter
    }
}

public class LoggingFilter implements Filter {
    @Override
    public void doFilter(ServletRequest request, ServletResponse response, FilterChain chain) throws IOException, ServletException {
        // 日志记录逻辑
        chain.doFilter(request, response); // 传递请求给下一个Filter
    }
}

// 其他Filter类...

java.util.logging.Logger 日志记录器

java标准库中的日志记录器也是一种责任链模式的应用。日志记录器可以配置多个处理器（Handler），每个处理器可以根据日志记录的级别、格式等属性选择是否处理该条日志。

Logger logger = Logger.getLogger("example.logger");
logger.addHandler(new ConsoleHandler()); // 控制台处理器
logger.addHandler(new FileHandler()); // 文件处理器

java.util.concurrent.ThreadPoolExecutor 中的拒绝策略

ThreadPoolExecutor 是Java标准库中用于管理线程池的类之一。当线程池无法接受新的任务时，它可以使用预定义的拒绝策略（如AbortPolicy、CallerRunsPolicy等），也可以自定义拒绝策略。这些拒绝策略形成了一条责任链，用于决定如何处理被拒绝的任务。

ThreadPoolExecutor executor = new ThreadPoolExecutor(
    corePoolSize,
    maximumPoolSize,
    keepAliveTime,
    unit,
    workQueue,
    new CustomRejectedExecutionHandler() // 自定义的拒绝策略
);

异常处理机制

Java 中的异常处理机制就是一个典型的责任链模式的应用。当一个方法抛出异常时，调用栈会逐层向上回溯，直到找到能够处理该异常的异常处理器为止。如果当前方法没有捕获该异常，那么它就会传递给调用它的方法，依此类推，直到找到合适的异常处理器或者抛出到顶层方法。

try {
    // 可能会抛出异常的代码
} catch (IOException e) {
    // 处理 IOException 异常
} catch (SQLException e) {
    // 处理 SQLException 异常
} catch (Exception e) {
    // 处理其他类型的异常
}

在这个例子中，不同类型的异常处理器构成了一个责任链，每个处理器根据异常的类型来判断是否能够处理，如果不能处理则将异常传递给下一个处理器。

Spring

Spring AOP（面向切面编程）

Spring AOP 允许在方法调用之前、之后或者周围执行额外的操作。这些操作可以在一条责任链中依次执行，以实现对方法调用的拦截和增强。

@Aspect
@Component
public class LoggingAspect {
    @Before("execution(* com.example.service.*.*(..))")
    public void logBefore(JoinPoint joinPoint) {
        // 在方法调用之前记录日志
    }

    // 其他切面逻辑...
}

在这个例子中，LoggingAspect 类充当了责任链中的一个处理器，它在被通知的方法调用之前记录了日志。

Spring Security 拦截器链

Spring Security 提供了一套基于过滤器的安全框架，其中的过滤器形成了一条责任链，依次对请求进行安全验证、授权、会话管理等操作。

@Configuration
@EnableWebSecurity
public class WebSecurityConfig extends WebSecurityConfigurerAdapter {
    @Override
    protected void configure(HttpSecurity http) throws Exception {
        http
            .authorizeRequests()
                .antMatchers("/admin/**").hasRole("ADMIN")
                .antMatchers("/user/**").hasRole("USER")
                .anyRequest().authenticated()
                .and()
            .formLogin()
                .loginPage("/login")
                .permitAll()
                .and()
            .logout()
                .permitAll();
    }
}

在这个例子中，WebSecurityConfig 类配置了一个拦截器链，用于对请求进行安全控制和权限验证。

Spring Boot Web 中的过滤器链

在Spring Boot Web应用中，可以通过配置 FilterRegistrationBean 来定义一条过滤器链，对请求进行预处理、修改或者验证。

@Configuration
public class WebConfig {
    @Bean
    public FilterRegistrationBean<MyFilter> myFilter() {
        FilterRegistrationBean<MyFilter> registrationBean = new FilterRegistrationBean<>();
        registrationBean.setFilter(new MyFilter());
        registrationBean.addUrlPatterns("/api/*");
        return registrationBean;
    }
}

在这个例子中，WebConfig 类配置了一个自定义过滤器的过滤器链，它将拦截 /api/* 下的所有请求。

Spring MVC 中的拦截器链

Spring MVC 框架中的拦截器允许开发人员在请求到达控制器之前或之后执行额外的处理逻辑。拦截器链由一系列的拦截器组成，它们依次执行，每个拦截器可以选择是否处理请求或者将请求传递给下一个拦截器。

@Configuration
public class WebMvcConfig implements WebMvcConfigurer {
    @Override
    public void addInterceptors(InterceptorRegistry registry) {
        registry.addInterceptor(new LoggingInterceptor());
        registry.addInterceptor(new AuthenticationInterceptor());
        // 添加其他拦截器...
    }
}

在这个例子中，LoggingInterceptor、AuthenticationInterceptor 等都是拦截器，它们构成了一条责任链，每个拦截器可以选择处理请求、修改请求、终止请求或者将请求传递给下一个拦截器。

BeanPostProcessor 接口

Spring 框架中的 BeanPostProcessor 接口允许开发人员在 Spring 容器实例化 bean 之前和之后执行自定义的处理逻辑。多个 BeanPostProcessor 实现类形成了一个责任链，每个 BeanPostProcessor 都可以选择处理特定类型的 bean 或者将处理交给下一个 BeanPostProcessor。

public class CustomBeanPostProcessor implements BeanPostProcessor {
    @Override
    public Object postProcessBeforeInitialization(Object bean, String beanName) throws BeansException {
        // 在初始化之前处理 bean
        return bean;
    }

    @Override
    public Object postProcessAfterInitialization(Object bean, String beanName) throws BeansException {
        // 在初始化之后处理 bean
        return bean;
    }
}

在这个例子中，CustomBeanPostProcessor 实现了 BeanPostProcessor 接口，它可以在 bean 初始化之前和之后执行自定义的处理逻辑。

事件处理

Spring 框架中的事件处理机制允许 bean 之间通过事件进行通信。事件由事件发布者发布，由事件监听器监听。多个事件监听器形成了一个责任链，每个监听器可以选择处理特定类型的事件或者将事件传递给下一个监听器。

@Component
public class MyEventListener implements ApplicationListener<MyEvent> {
    @Override
    public void onApplicationEvent(MyEvent event) {
        // 处理事件
    }
}

在这个例子中，MyEventListener 是一个事件监听器，它监听 MyEvent 类型的事件，并在事件发生时执行自定义的处理逻辑。

.Net Core

ASP.NET Core 中间件

ASP.NET Core 中的中间件是一种处理 HTTP 请求和响应的方式，它们形成了一个责任链，每个中间件可以在请求到达处理终点之前对请求进行操作。

public class Startup {
    public void Configure(IApplicationBuilder app) {
        app.UseMiddleware<LoggingMiddleware>();
        app.UseMiddleware<AuthenticationMiddleware>();
        app.UseMiddleware<RoutingMiddleware>();
        // 其他中间件...
    }
}

在这个例子中，LoggingMiddleware、AuthenticationMiddleware、RoutingMiddleware 等都是中间件，它们构成了一条责任链，每个中间件可以选择处理请求、修改请求、终止请求或者将请求传递给下一个中间件。

MediatR 库

MediatR 是一个 .NET 中的中介者模式（Mediator Pattern）库，它也可以用于实现责任链模式。在 MediatR 中，请求和处理程序之间的关系形成了一个责任链，每个处理程序可以选择处理请求、修改请求、终止请求或者将请求传递给下一个处理程序。

public class MyHandler : IRequestHandler<MyRequest, MyResponse> {
    public Task<MyResponse> Handle(MyRequest request, CancellationToken cancellationToken) {
        // 处理请求的逻辑
    }
}

在这个例子中，MyHandler 是一个处理程序，它实现了处理请求的逻辑。通过 MediatR，可以将多个处理程序组成一个处理程序链，实现责任链模式的效果。

Entity Framework Core 中的查询过滤器

在 Entity Framework Core 中，查询过滤器允许你定义全局的查询筛选逻辑，这些过滤器可以被应用到每一个查询中，形成了一条责任链。

public class MyDbContext : DbContext {
    protected override void OnModelCreating(ModelBuilder modelBuilder) {
        modelBuilder.Entity<MyEntity>().HasQueryFilter(e => !e.IsDeleted);
    }
}

在这个例子中，HasQueryFilter 方法定义了一个查询过滤器，它将在每次查询中过滤掉已删除的实体。