设计模式07-责任链模式
责任链模式属于行为设计模式，常见的过滤器链就是使用责任链模式设计的。
文章目录
- 1、真实开发场景的问题引入
- 2、责任链模式讲解
-
- 2.1 核心类及类图
- 2.2 基本代码
- 3、利用构建者模式解决问题
- 4、责任链模式的应用实例
- 5、总结
-
- 5.1 解决的问题
- 5.2 使用场景
- 5.3 优缺点
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
* @return
*/
public static <R> ProcessResult resumeData(R data){
return new ProcessResult(true,data);
}
/**
* 继续处理不返回数据
* @param
* @return
*/
public static <R> ProcessResult resumeNoData(){
return new ProcessResult(true,null);
}
/**
* 不继续处理+返回数据
* @param
* @return
*/
public static <R> ProcessResult stopData(R data){
return new ProcessResult(false,data);
}
/**
* 不继续处理+不返回数据
* @param
* @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
@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] 责任链模式-菜鸟教程