责任链模式属于行为设计模式,常见的过滤器链就是使用责任链模式设计的。
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] 责任链模式-菜鸟教程