责任链模式属于行为设计模式，常见的过滤器链就是使用责任链模式设计的。

1、真实开发场景的问题引入

Q：假设有一个闯关游戏，共三关，每一关达到通过条件后才能进入下一关，使用java实现。
A：针对这个问题，按照朴素的想法，我们可以定义三个类，分别是第一关、第二关、第三关，客户端启动游戏首先进入第一关，然后第一关通过后进入第二关，依次类推。我们可以得到这样的代码如下：

@Slf4j
public class FirstLevel {
    @Autowired
    private SecondLevel secondLevel;
    public void play(){
        log.info("进入第一关");
        //游戏操作,获得分数
        int res = 80;
        if(res >= 80){
            secondLevel.play();
        }else {
            return;
        }
    }
}
@Component
@Slf4j
public class SecondLevel {
    @Autowired
    private ThirdLevel thirdLevel;
    public void play(){
        log.info("进入第二关");
        //游戏操作,获得分数
        int res = 90;
        if(res >= 90){
            thirdLevel.play();
        }else {
            return;
        }
    }
}
@Component
@Slf4j
public class ThirdLevel {
    public void play(){
        log.info("进入第三关");
        //游戏操作,获得分数
        int res = 95;
        if(res >= 95){
            log.info("游戏通关");
        }else {
            return;
        }
    }
}

@SpringBootTest
@RunWith(SpringRunner.class)
@Slf4j
class DpApplicationTests {
    @Autowired
    private FirstLevel firstLevel;

    @Test
    public void client(){
        firstLevel.play();
    }
}

上述代码有什么问题呢？

• 耦合性太强，每个类中包含其他类
• 如果想改变关卡的顺序需要改类内部代码

2、责任链模式讲解

责任链模式应用的场景是：一个请求，有很多处理者可以处理，这些处理者构成一个链，请求只需要发送到链上，不用管最终是谁处理了请求，也不用管请求在链上是怎么传递的。这样就实现了请求者与被请求者的解耦，同时也只需定义一条链，把处理者放到链上同时定义好处理者的顺序，处理者之间也不用相互持有。

2.1 核心类及类图

一个抽象处理器接口和三个具体的处理器，在处理器链类中有一个List，其中放的是三个具体处理器，在客户端中使用处理器链对象与请求交互。

2.2 基本代码

• 1 定义一个处理器返回结果类型，其中包括处理结果数据(范型)、是否继续在链上传播

@Data
public class ProcessResult<R> {
    private boolean next;
    private R data;

    public ProcessResult(boolean next, R data) {
        this.next = next;
        this.data = data;
    }

    /**
     * 继续处理并返回数据
     * @param data
     * @param <R>
     * @return
     */
    public static <R> ProcessResult resumeData(R data){
        return new ProcessResult(true,data);
    }

    /**
     * 继续处理不返回数据
     * @param <R>
     * @return
     */
    public static <R> ProcessResult resumeNoData(){
        return new ProcessResult(true,null);
    }

    /**
     * 不继续处理+返回数据
     * @param <R>
     * @return
     */
    public static <R> ProcessResult stopData(R data){
        return new ProcessResult(false,data);
    }

    /**
     * 不继续处理+不返回数据
     * @param <R>
     * @return
     */
    public static <R> ProcessResult stopNoData(){
        return new ProcessResult(false,null);
    }
}

• 2 定义抽象的处理器，返回值为上面定义的类型；有两个范型，一个是处理器接收的参数，另一个是处理器返回具体数据的类型（包裹在ProcessResult中）

public interface Processor<Result,Param> {
    /**
     * 使用范型的方法、类，需要指定范型
     * @param param 处理器参数
     * @return Res 返回结果
     */
    ProcessResult<Result> process(Param param );


    /**
     * 接口的默认方法，表示该处理器是否已经处理过请求
     * @return
     */
    default boolean isProcessed(){
        return false;
    }
}

• 3 定义三个具体的处理器，用来处理请求，使用order注解规定了JavaBean扫描的顺序，实现Processor注意指明范型参数

@Component
@Order(1)
@Slf4j
public class ConcreteProcessor01 implements Processor<String,String>{
    @Override
    public ProcessResult<String> process(String s) {
        //通过参数判断是不是处理请求
        log.info("ConcreteProcessor01处理");
        //处理
        return ProcessResult.resumeData(s);
    }
}
@Component
@Order(2)
@Slf4j
public class ConcreteProcessor02 implements Processor<String,String>{
    @Override
    public ProcessResult<String> process(String s) {
        //通过参数判断是不是处理请求
        log.info("ConcreteProcessor02处理");
        //处理
        return ProcessResult.stopData(s);
    }
}
@Component
@Order(3)
@Slf4j
public class ConcreteProcessor03 implements Processor<String,String>{
    @Override
    public ProcessResult<String> process(String s) {
        //通过参数判断是不是处理请求
        log.info("ConcreteProcessor03处理");
        //处理
        return ProcessResult.resumeData(s);
    }
}

• 4 定义处理器链，构造函数注入List

  类型参数，spring容器会扫描所有的P类型的Bean，放到List中。Processor<Result,Param> 前面定义的ConcreteProcessor01、02、03一致（即Processor<String,String>），但是这里为了保证BaseChain的通用性，即可以定义多个聚合不同类型处理器的处理器链，该处使用范型。

@Component
@Slf4j
public class BaseChain<Result,Param> {
    private List<Processor<Result,Param>> processors;

    @Autowired
    public BaseChain(List<Processor<Result,Param>> processors) {
        this.processors = processors;
    }

    public void doProcess(Param param) {
        for (Processor processor : processors) {
            ProcessResult process = processor.process(param);
            if (process.getData() != null) {
                log.info(process.getData().toString());
            }
            if (!process.isNext()) {
                return;
            }
        }
    }
}

• 5 客户端

@SpringBootTest
@RunWith(SpringRunner.class)
@Slf4j
class DpApplicationTests {
    @Autowired
    private BaseChain baseChain;

    @Test
    public void chainTest(){
        baseChain.doProcess("123");
    }
}

输出：

3、利用构建者模式解决问题

针对1中的问题可以套用2中的代码解决

4、责任链模式的应用实例

Spring Web 中的 HandlerInterceptor

HandlerInterceptor接口在web开发中非常常用，里面有preHandle()、postHandle()、afterCompletion()三个方法，preHandle()方法在请求处理之前被调用、postHandle()方法在请求处理完成后，但在视图渲染之前被调用、afterCompletion()方法在视图渲染完成后被调用

public interface HandlerInterceptor {
	default boolean preHandle(HttpServletRequest request, HttpServletResponse response, Object handler)
			throws Exception {

		return true;
	}

	default void postHandle(HttpServletRequest request, HttpServletResponse response, Object handler,
			@Nullable ModelAndView modelAndView) throws Exception {
	}

	default void afterCompletion(HttpServletRequest request, HttpServletResponse response, Object handler,
			@Nullable Exception ex) throws Exception {
	}
}

这样的过滤器会有很多个，使用责任链模式，将这些过滤器放在一个链中，即HandlerExecutionChain中，由HandlerExecutionChain对所有的HandlerInterceptor进行调用。

public class HandlerExecutionChain {

	...

    //在数组中存放所有的过滤器
	@Nullable
	private HandlerInterceptor[] interceptors;
	//数组的下标
	private int interceptorIndex = -1;
	//pre的调度
	boolean applyPreHandle(HttpServletRequest request, HttpServletResponse response) throws Exception {
		HandlerInterceptor[] interceptors = getInterceptors();
		if (!ObjectUtils.isEmpty(interceptors)) {
			for (int i = 0; i < interceptors.length; i++) {
			//遍历过滤器
				HandlerInterceptor interceptor = interceptors[i];
        //preHandle返回false，进入该if，结束处理流程，
				if (!interceptor.preHandle(request, response, this.handler)) {
          //执行渲染完成后的逻辑
					triggerAfterCompletion(request, response, null);
					return false;
				}
        //修改当前指向的过滤器下标，记录最后一个成功执行preHandle()方法的拦截器的索引。
        //如果某个拦截器的preHandle()方法返回false，则遍历将停止，并且请求处理也将停止。
        //在这种情况下，HandlerExecutionChain需要调用所有已成功执行preHandle()方法的拦截器的afterCompletion()方法。
        //这时候就需要使用interceptorIndex得到最后一个成功执行的preHandle方法所在的拦截器在拦截链的位置。
				this.interceptorIndex = i;
			}
		}
		return true;
	}
}

5、总结

5.1 解决的问题

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

5.2 使用场景

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

5.3 优缺点

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

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

---

参考：
[1] 实战：设计模式之责任链设计模式深度解析
[2] 责任链模式在 Spring 中的应用
[3] 责任链模式-菜鸟教程