chain of responsibility模式

场景：

（1）现在在某一个地方的业务流程，要执行功能1、功能2、功能3 （2）现在在另外一个地方的业务流程，是要先执行功能3，然后执行功能1和功能2

1.常规

  1. package com.example.demo.pattern.chain;
  2. /**
  3.  * @author chenchao
  4.  * @date 2021/11/9
  5.  */
  6. public class WithoutChainPatternDemo {
  8.     public static void main(String[] args) {
  9.         // 业务流程1
  10.         System.out.println("执行功能1");  
  11.         System.out.println("执行功能2");  
  12.         System.out.println("执行功能3");
  14.         // 业务流程2
  15.         System.out.println("执行功能3");
  16.         System.out.println("执行功能1"); 
  17.         System.out.println("执行功能2");
  19.         // 有什么问题？
  20.         // 第一个，大量的重复代码出现了，功能123的代码，都出现在了两个地方，有复制粘贴的现象
  21.         // 如果说，现在要对某个功能的代码进行修改，那么就会很麻烦，要在多个地方去修改这个功能的代码
  22.         // 另外一个问题是说，如果现在要对某个业务流程的顺序进行调整或者改造，很麻烦，要去修改大量的代码
  23.     }
  25. }

2.责任链模式

  1. package com.example.demo.pattern.chain;
  2. /**
  3.  * @author chenchao
  4.  * @date 2021/11/9
  5.  */
  6. public class ChainPatternDemo {
  8.     public static void main(String[] args) {
  9.         // 业务流程1
  10.         Handler thirdHandler = new Handler3(null);
  11.         Handler secondHandler = new Handler2(thirdHandler);
  12.         Handler firstHandler = new Handler1(secondHandler);
  13.         firstHandler.execute();
  15.         // 业务流程2
  16.         thirdHandler = new Handler3(null);
  17.         secondHandler = new Handler1(thirdHandler);
  18.         firstHandler = new Handler2(secondHandler);
  19.         firstHandler.execute();
  21.         // 责任链的思想
  22.         // 1：将一个业务流程中的多个步骤拆分开来，每个步骤封装到一个handler处理器中去
  23.         // 2：支持业务流程基于handler动态组装，不同的业务流程 -> handler代表的代码组件可以复用
  25.         // 好处1：将这个代码封装到一个handler中，后面如果要对某个步骤的代码逻辑调整，修改一个handler即可
  26.         // 好处2：如果业务流程要修改，那么不需要拷贝大量的代码，只要基于handler动态组装业务流程即可
  28.         // 面向的场景
  29.         // 就是有多个业务流程，这些业务流程之间有相同的代码逻辑和步骤
  30.         // 可以用责任链模式来实现
  31.     }
  33.     public static abstract class Handler {
  35.         protected Handler successor;
  37.         public Handler(Handler successor) {
  38.             this.successor = successor;
  39.         }
  41.         public abstract void execute();
  43.     }
  45.     public static class Handler1 extends Handler {
  47.         public Handler1(Handler successor) {
  48.             super(successor);
  49.         }
  50.         @Override
  51.         public void execute() {
  52.             System.out.println("执行功能1");  
  53.             if(successor != null) {
  54.                 successor.execute();
  55.             }
  56.         }
  58.     }
  60.     public static class Handler2 extends Handler {
  62.         public Handler2(Handler successor) {
  63.             super(successor);
  64.         }
  65.         @Override
  66.         public void execute() {
  67.             System.out.println("执行功能2");  
  68.             if(successor != null) {
  69.                 successor.execute();
  70.             }
  71.         }
  73.     }
  75.     public static class Handler3 extends Handler {
  77.         public Handler3(Handler successor) {
  78.             super(successor);
  79.         }
  80.         @Override
  81.         public void execute() {
  82.             System.out.println("执行功能3");  
  83.             if(successor != null) {
  84.                 successor.execute();
  85.             }
  86.         }
  88.     }
  90. }

3.说明

责任链模式，那也是经常会使用到的，对于那种复杂的业务流程，一种方案是采取面向对象的设计，将不同的业务逻辑封装到不同的类里去，然后通通过方法中的调用来控制业务流向；另外一种就是采用责任链模式，将业务逻辑封装到不同的handler里面去，形成链条式调用。

什么时候用责任链模式呢？很简单，就是如果你需要动态组装一个业务流程出来，流程中的每个handler业务逻辑需要复用，那就用责任链模式。