chain of responsibility模式

    场景：

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

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

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

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