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

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

@Slf4j
public class FirstLevel {@Autowiredprivate SecondLevel secondLevel;public void play(){log.info("进入第一关");//游戏操作,获得分数int res = 80;if(res >= 80){secondLevel.play();}else {return;}}
}
@Component
@Slf4j
public class SecondLevel {@Autowiredprivate 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 {@Autowiredprivate FirstLevel firstLevel;@Testpublic 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>{@Overridepublic ProcessResult<String> process(String s) {//通过参数判断是不是处理请求log.info("ConcreteProcessor01处理");//处理return ProcessResult.resumeData(s);}
}
@Component
@Order(2)
@Slf4j
public class ConcreteProcessor02 implements Processor<String,String>{@Overridepublic ProcessResult<String> process(String s) {//通过参数判断是不是处理请求log.info("ConcreteProcessor02处理");//处理return ProcessResult.stopData(s);}
}
@Component
@Order(3)
@Slf4j
public class ConcreteProcessor03 implements Processor<String,String>{@Overridepublic 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;@Autowiredpublic 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 {@Autowiredprivate BaseChain baseChain;@Testpublic 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 {...//在数组中存放所有的过滤器@Nullableprivate 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;}
}