「DUBBO系列」责任链模式源码分析

系统管理员 2021-09-24 09:14 401阅读 0赞

欢迎大家关注公众号「JAVA前线」查看更多精彩分享文章，主要包括源码分析、实际应用、架构思维、职场分享、产品思考等等，同时欢迎大家加我微信「java_front」一起交流学习

1 文章概述

责任链模式将请求发送和接收解耦，让多个接收对象都有机会处理这个请求。这些接收对象串成一条链路并沿着这条链路传递这个请求，直到链路上某个接收对象能够处理它。本文我们介绍责任链模式两种应用场景和四种代码实现方式，最后介绍了DUBBO如何应用责任链构建过滤器链路。

2 应用场景

2.1 命中立即中断

我们实现一个关键词过滤功能。系统设置三个关键词过滤器，输入内容命中任何一个过滤器规则就返回校验不通过，链路立即中断无需继续进行。

(1) 实现方式一

  1. public interface ContentFilter {
  2.     public boolean filter(String content);
  3. }
  5. public class AaaContentFilter implements ContentFilter {
  6.     private final static String KEY_CONTENT = "aaa";
  8.     @Override
  9.     public boolean filter(String content) {
  10.         boolean isValid = Boolean.FALSE;
  11.         if (StringUtils.isEmpty(content)) {
  12.             return isValid;
  13.         }
  14.         isValid = !content.contains(KEY_CONTENT);
  15.         return isValid;
  16.     }
  17. }
  19. public class BbbContentFilter implements ContentFilter {
  20.     private final static String KEY_CONTENT = "bbb";
  22.     @Override
  23.     public boolean filter(String content) {
  24.         boolean isValid = Boolean.FALSE;
  25.         if (StringUtils.isEmpty(content)) {
  26.             return isValid;
  27.         }
  28.         isValid = !content.contains(KEY_CONTENT);
  29.         return isValid;
  30.     }
  31. }
  33. public class CccContentFilter implements ContentFilter {
  34.     private final static String KEY_CONTENT = "ccc";
  36.     @Override
  37.     public boolean filter(String content) {
  38.         boolean isValid = Boolean.FALSE;
  39.         if (StringUtils.isEmpty(content)) {
  40.             return isValid;
  41.         }
  42.         isValid = !content.contains(KEY_CONTENT);
  43.         return isValid;
  44.     }
  45. }

具体过滤器已经编写完成，接下来构造过滤器责任链路

  1. @Service
  2. public class FilterHandlerChain {
  3.     private FilterHandler head = null;
  4.     private FilterHandler tail = null;
  6.     @PostConstruct
  7.     public void init() {
  8.         FilterHandler aaaHandler = new AaaContentFilterHandler();
  9.         FilterHandler bbbHandler = new BbbContentFilterHandler();
  10.         FilterHandler cccHandler = new CccContentFilterHandler();
  11.         addHandler(aaaHandler);
  12.         addHandler(bbbHandler);
  13.         addHandler(cccHandler);
  14.     }
  16.     public void addHandler(FilterHandler handler) {
  17.         if (head == null) {
  18.             head = tail = handler;
  19.         }
  20.         /** 设置当前tail继任者 **/
  21.         tail.setSuccessor(handler);
  23.         /** 指针重新指向tail **/
  24.         tail = handler;
  25.     }
  27.     public boolean filter(String content) {
  28.         if (null == head) {
  29.             throw new RuntimeException("FilterHandlerChain is empty");
  30.         }
  31.         /** head发起调用 **/
  32.         return head.filter(content);
  33.     }
  34. }
  36. public class Test {
  37.     public static void main(String[] args) throws Exception {
  38.         ClassPathXmlApplicationContext context = new ClassPathXmlApplicationContext(new String[] { "classpath*:META-INF/chain/spring-core.xml" });
  39.         FilterHandlerChain chain = (FilterHandlerChain) context.getBean("filterHandlerChain");
  40.         System.out.println(context);
  41.         boolean result1 = chain.filter("ccc");
  42.         boolean result2 = chain.filter("ddd");
  43.         System.out.println("校验结果1=" + result1);
  44.         System.out.println("校验结果2=" + result2);
  45.     }
  46. }

(2) 实现方式二

  1. public abstract class FilterHandler {
  3.     /** 下一个节点 **/
  4.     protected FilterHandler successor = null;
  6.     public void setSuccessor(FilterHandler successor) {
  7.         this.successor = successor;
  8.     }
  10.     public final boolean filter(String content) {
  11.         /** 执行自身方法 **/
  12.         boolean isValid = doFilter(content);
  13.         if (!isValid) {
  14.             System.out.println("校验不通过");
  15.             return isValid;
  16.         }
  17.         /** 执行下一个节点链路 **/
  18.         if (successor != null && this != successor) {
  19.             isValid = successor.filter(content);
  20.         }
  21.         return isValid;
  22.     }
  23.     /** 每个节点过滤方法 **/
  24.     protected abstract boolean doFilter(String content);
  25. }
  27. public class AaaContentFilterHandler extends FilterHandler {
  28.     private final static String KEY_CONTENT = "aaa";
  30.     @Override
  31.     protected boolean doFilter(String content) {
  32.         boolean isValid = Boolean.FALSE;
  33.         if (StringUtils.isEmpty(content)) {
  34.             return isValid;
  35.         }
  36.         isValid = !content.contains(KEY_CONTENT);
  37.         return isValid;
  38.     }
  39. }
  41. // 省略其它过滤器代码

具体过滤器已经编写完成，接下来构造过滤器责任链路

  1. @Service
  2. public class FilterHandlerChain {
  3.     private FilterHandler head = null;
  4.     private FilterHandler tail = null;
  6.     @PostConstruct
  7.     public void init() {
  8.         FilterHandler aaaHandler = new AaaContentFilterHandler();
  9.         FilterHandler bbbHandler = new BbbContentFilterHandler();
  10.         FilterHandler cccHandler = new CccContentFilterHandler();
  11.         addHandler(aaaHandler);
  12.         addHandler(bbbHandler);
  13.         addHandler(cccHandler);
  14.     }
  16.     public void addHandler(FilterHandler handler) {
  17.         if (head == null) {
  18.             head = tail = handler;
  19.         }
  20.         /** 设置当前tail继任者 **/
  21.         tail.setSuccessor(handler);
  23.         /** 指针重新指向tail **/
  24.         tail = handler;
  25.     }
  27.     public boolean filter(String content) {
  28.         if (null == head) {
  29.             throw new RuntimeException("FilterHandlerChain is empty");
  30.         }
  31.         /** head发起调用 **/
  32.         return head.filter(content);
  33.     }
  34. }
  36. public class Test {
  37.     public static void main(String[] args) throws Exception {
  38.         ClassPathXmlApplicationContext context = new ClassPathXmlApplicationContext(new String[] { "classpath*:META-INF/chain/spring-core.xml" });
  39.         FilterHandlerChain chain = (FilterHandlerChain) context.getBean("filterHandlerChain");
  40.         System.out.println(context);
  41.         boolean result1 = chain.filter("ccc");
  42.         boolean result2 = chain.filter("ddd");
  43.         System.out.println("校验结果1=" + result1);
  44.         System.out.println("校验结果2=" + result2);
  45.     }
  46. }

2.2 全链路执行

我们实现一个考题生成功能。在线考试系统根据不同年级生成不同考题。系统设置三个考题生成器，每个生成器都会执行，根据学生年级决定是否生成考题，无需生成则执行下一个生成器。

(1) 实现方式一

  1. public interface QuestionGenerator {
  2.     public Question generateQuestion(String gradeInfo);
  3. }
  5. public class AaaQuestionGenerator implements QuestionGenerator {
  7.     @Override
  8.     public Question generateQuestion(String gradeInfo) {
  9.         if (!gradeInfo.equals("一年级")) {
  10.             return null;
  11.         }
  12.         Question question = new Question();
  13.         question.setId("aaa");
  14.         question.setScore(10);
  15.         return question;
  16.     }
  17. }
  19. // 省略其它生成器代码

具体生成器已经编写完成，接下来构造生成器责任链路

  1. @Service
  2. public class QuestionChain {
  3.     private List<QuestionGenerator> generators = new ArrayList<QuestionGenerator>();
  5.     @PostConstruct
  6.     public void init() {
  7.         QuestionGenerator aaaQuestionGenerator = new AaaQuestionGenerator();
  8.         QuestionGenerator bbbQuestionGenerator = new BbbQuestionGenerator();
  9.         QuestionGenerator cccQuestionGenerator = new CccQuestionGenerator();
  10.         generators.add(aaaQuestionGenerator);
  11.         generators.add(bbbQuestionGenerator);
  12.         generators.add(cccQuestionGenerator);
  13.     }
  15.     public List<Question> generate(String gradeInfo) {
  16.         if (CollectionUtils.isEmpty(generators)) {
  17.             throw new RuntimeException("QuestionChain is empty");
  18.         }
  19.         List<Question> questions = new ArrayList<Question>();
  20.         for (QuestionGenerator generator : generators) {
  21.             Question question = generator.generateQuestion(gradeInfo);
  22.             if (null == question) {
  23.                 continue;
  24.             }
  25.             questions.add(question);
  26.         }
  27.         return questions;
  28.     }
  29. }
  31. public class Test {
  32.     public static void main(String[] args) {
  33.         ClassPathXmlApplicationContext context = new ClassPathXmlApplicationContext(new String[] { "classpath*:META-INF/chain/spring-core.xml" });
  34.         System.out.println(context);
  35.         QuestionChain chain = (QuestionChain) context.getBean("questionChain");
  36.         List<Question> questions = chain.generate("一年级");
  37.         System.out.println(questions);
  38.     }
  39. }

(2) 实现方式二

  1. public abstract class GenerateHandler {
  3.     /** 下一个节点 **/
  4.     protected GenerateHandler successor = null;
  6.     public void setSuccessor(GenerateHandler successor) {
  7.         this.successor = successor;
  8.     }
  10.     public final List<Question> generate(String gradeInfo) {
  11.         List<Question> result = new ArrayList<Question>();
  13.         /** 执行自身方法 **/
  14.         Question question = doGenerate(gradeInfo);
  15.         if (null != question) {
  16.             result.add(question);
  17.         }
  19.         /** 执行下一个节点链路 **/
  20.         if (successor != null && this != successor) {
  21.             List<Question> successorQuestions = successor.generate(gradeInfo);
  22.             if (null != successorQuestions) {
  23.                 result.addAll(successorQuestions);
  24.             }
  25.         }
  26.         return result;
  27.     }
  28.     /** 每个节点生成方法 **/
  29.     protected abstract Question doGenerate(String gradeInfo);
  30. }
  32. public class AaaGenerateHandler extends GenerateHandler {
  34.     @Override
  35.     protected Question doGenerate(String gradeInfo) {
  36.         if (!gradeInfo.equals("一年级")) {
  37.             return null;
  38.         }
  39.         Question question = new Question();
  40.         question.setId("aaa");
  41.         question.setScore(10);
  42.         return question;
  43.     }
  44. }
  46. // 省略其它生成器代码

具体生成器已经编写完成，接下来构造生成器责任链路

  1. @Service
  2. public class GenerateChain {
  3.     private GenerateHandler head = null;
  4.     private GenerateHandler tail = null;
  6.     @PostConstruct
  7.     public void init() {
  8.         GenerateHandler aaaHandler = new AaaGenerateHandler();
  9.         GenerateHandler bbbHandler = new BbbGenerateHandler();
  10.         GenerateHandler cccHandler = new CccGenerateHandler();
  11.         addHandler(aaaHandler);
  12.         addHandler(bbbHandler);
  13.         addHandler(cccHandler);
  14.     }
  16.     public void addHandler(GenerateHandler handler) {
  17.         if (head == null) {
  18.             head = tail = handler;
  19.         }
  20.         /** 设置当前tail继任者 **/
  21.         tail.setSuccessor(handler);
  23.         /** 指针重新指向tail **/
  24.         tail = handler;
  25.     }
  27.     public List<Question> generate(String gradeInfo) {
  28.         if (null == head) {
  29.             throw new RuntimeException("GenerateChain is empty");
  30.         }
  31.         /** head发起调用 **/
  32.         return head.generate(gradeInfo);
  33.     }
  34. }
  36. public class Test {
  37.     public static void main(String[] args) {
  38.         ClassPathXmlApplicationContext context = new ClassPathXmlApplicationContext(new String[] { "classpath*:META-INF/chain/spring-core.xml" });
  39.         GenerateChain chain = (GenerateChain) context.getBean("generateChain");
  40.         System.out.println(context);
  41.         List<Question> result = chain.generate("一年级");
  42.         System.out.println(result);
  43.     }
  44. }

3 DUBBO构建过滤器链

生产者和消费者最终执行对象都是过滤器链路最后一个节点，整个链路包含多个过滤器进行业务处理。我们看看生产者和消费者默认过滤器链路。

  1. # 生产者过滤器链路
  2. EchoFilter > ClassloaderFilter > GenericFilter > ContextFilter > 
  3. TraceFilter > TimeoutFilter > MonitorFilter > ExceptionFilter > AbstractProxyInvoker
  5. # 消费者过滤器链路
  6. ConsumerContextFilter > FutureFilter > MonitorFilter > DubboInvoker

ProtocolFilterWrapper作为链路生成核心通过匿名类方式构建过滤器链路，我们以消费者构建过滤器链路为例

  1. public class ProtocolFilterWrapper implements Protocol {
  2.     private static <T> Invoker<T> buildInvokerChain(final Invoker<T> invoker, String key, String group) {
  4.         // invoker = DubboInvoker
  5.         Invoker<T> last = invoker;
  7.         // 查询符合条件过滤器列表
  8.         List<Filter> filters = ExtensionLoader.getExtensionLoader(Filter.class).getActivateExtension(invoker.getUrl(), key, group);
  9.         if (!filters.isEmpty()) {
  10.             for (int i = filters.size() - 1; i >= 0; i--) {
  11.                 final Filter filter = filters.get(i);
  12.                 final Invoker<T> next = last;
  14.                 // 构造一个简化Invoker
  15.                 last = new Invoker<T>() {
  16.                     @Override
  17.                     public Class<T> getInterface() {
  18.                         return invoker.getInterface();
  19.                     }
  21.                     @Override
  22.                     public URL getUrl() {
  23.                         return invoker.getUrl();
  24.                     }
  26.                     @Override
  27.                     public boolean isAvailable() {
  28.                         return invoker.isAvailable();
  29.                     }
  31.                     @Override
  32.                     public Result invoke(Invocation invocation) throws RpcException {
  33.                         // 构造过滤器链路
  34.                         Result result = filter.invoke(next, invocation);
  35.                         if (result instanceof AsyncRpcResult) {
  36.                             AsyncRpcResult asyncResult = (AsyncRpcResult) result;
  37.                             asyncResult.thenApplyWithContext(r -> filter.onResponse(r, invoker, invocation));
  38.                             return asyncResult;
  39.                         } else {
  40.                             return filter.onResponse(result, invoker, invocation);
  41.                         }
  42.                     }
  44.                     @Override
  45.                     public void destroy() {
  46.                         invoker.destroy();
  47.                     }
  49.                     @Override
  50.                     public String toString() {
  51.                         return invoker.toString();
  52.                     }
  53.                 };
  54.             }
  55.         }
  56.         return last;
  57.     }
  59.     @Override
  60.     public <T> Invoker<T> refer(Class<T> type, URL url) throws RpcException {
  61.         // RegistryProtocol不构造过滤器链路
  62.         if (Constants.REGISTRY_PROTOCOL.equals(url.getProtocol())) {
  63.             return protocol.refer(type, url);
  64.         }
  65.         Invoker<T> invoker = protocol.refer(type, url);
  66.         return buildInvokerChain(invoker, Constants.REFERENCE_FILTER_KEY, Constants.CONSUMER);
  67.     }
  68. }

4 文章总结

面向对象设计有一个重要原则：对扩展开放对修改关闭，我认为这是最重要的面向对象设计原则，责任链模式非常好得体现了这个原则，有助于代码维护和处理复杂场景。

本文我们分析了责任链模式两种场景和四种代码实现方式，最后介绍了DUBBO如何应用责任链构建过滤器链路。后续文章继续分析DUBBO设计模式实例请继续关注。

欢迎大家关注公众号「JAVA前线」查看更多精彩分享文章，主要包括源码分析、实际应用、架构思维、职场分享、产品思考等等，同时欢迎大家加我微信「java_front」一起交流学习

watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dvc2hpeHV5ZQ_size_16_color_FFFFFF_t_70

发表评论

表情：
评论列表 （有 0 条评论，401人围观）

还没有评论，来说两句吧...

相关阅读

    相关 责任链模式

    > 责任链模式是一种对象的行为模式。在责任链模式里，很多对象由每一个对象对其下家的引用而连接起来形成一条链。请求在这个链上传递，直到链上的某一个对象决定处理此请求。发出这个请求

    电玩女神电玩女神/ 0 赞/ 341 阅读

    相关 责任链模式

    在公众号的前面我们说策略模式的时候，我们说各种策略的对象和一个行为随着策略对象改变而改变的。换句话说，针对客户端传来不同的参数进行实例不同策略的对象，也就是说保证了客户端和服务

    客官°小女子只卖身不卖艺客官°小女子只卖身不卖艺/ 0 赞/ 316 阅读