1、什么是责任链设计模式：
    当客户端发起一个请求，需要多个对象对请求做处理，同时这个处理对象对请求的处理顺序也是有要求的，而客户端不需要知道具体的处理对象；这样就实现了请求者与实现者的解耦，并且在客户端可以实现动态的组合职责链，使编程更具灵活性。

    2、责任链设计模式类结构图
    抽象处理者角色(Handler):
    定义一个处理请求的抽象类，里边一般设置有三个部分，一个是处理请求，另一个是获取下个处理器，调用下一个处理器处理请求的方法(因为每个处理器都要调用，所以将其放到抽象类中)；

    具体处理者角色(ConcreteHandler)：
    具体处理者接到请求后，做两件事，一是处理请求，而是调用下个处理器处理请求。

    3、优缺点：
    优点：动态组合，请求者与接受者解耦；
    动态组合：责任链模式会将功能分散到多个单独的责任对象当中，然后在使用时动态组合形成链，从而可以灵活地分配职责对象，也可以灵活地添加或改变对象职责。

    请求者与接收者解耦：请求者不需要知道接受者，也不需要知道如何处理，每个职责对象只负责自己的职责范围，其他的交给后继者，各个组件完全解耦。

    缺点：这样在处理某个功能请求的过程中就会产生大量的细粒度职责对象，但是这样的缺点也是优点，提高了代码的复用性。

    4、应用场景

    在网关作为微服务程序的入口，拦截客户端所有的请求实现权限控制 ，比如先判断Api接口限流、黑名单、用户会话、参数过滤。
    Api接口限流→黑名单拦截→用户会话→参数过滤

    抽象角色：

    1. public abstract class GatewayHandler {
    2.     protected GatewayHandler nextGatewayHandler;
    4.     /**
    5.      * 处理业务逻辑
    6.      *
    7.      * @return true 表示继续执行 false表示不继续执行..
    8.      */
    9.     public abstract void service();
    11.     public void setHandler(GatewayHandler gatewayHandler) {
    12.         this.nextGatewayHandler = gatewayHandler;
    13.     }
    14.     protected void nextService(){
    15.          if(nextGatewayHandler!=null){
    16.              nextGatewayHandler.service();;
    17.          }
    18.     }
    19. }

    具体实现者：

    1. @Component
    2. public class CurrentLimitHandler extends GatewayHandler {
    3.     @Override
    4.     public void service() {
    5.         System.out.println("第一关网关限流判断....");
    6.         nextService();
    7.     }
    8. }
    11. @Component
    12. public class BlacklistHandler extends GatewayHandler {
    13.     @Override
    14.     public void service() {
    15.         System.out.println("第二关黑名单拦截判断....");
    16.         nextService();
    17.     }
    18. }
    20. @Component
    21. public class ConversationHandler extends GatewayHandler {
    22.     @Override
    23.     public void service() {
    24.         System.out.println("第三关用户会话拦截判断....");
    25.         nextService();
    26.     }
    27. }
    31. @Component
    32. public class ConversationHandler extends GatewayHandler {
    33.     @Override
    34.     public void service() {
    35.         System.out.println("第三关用户会话拦截判断....");
    36.         nextService();
    37.     }
    38. }

    GatewayHandlerService:

    1. @Component
    2. public class GatewayHandlerService {
    3.     @Autowired
    4.     private GatewayHandlerMapper gatewayHandlerMapper;
    5.     private GatewayHandler firstGatewayHandler;
    7.     public GatewayHandler getDbGatewayHandler() {
    8.         if (firstGatewayHandler != null) {
    9.             return firstGatewayHandler;
    10.         }
    11.         // 1.获取第一个GatewayHandler信息
    12.         GatewayHandlerEntity firstGatewayHandlerEntity = gatewayHandlerMapper.getFirstGatewayHandler();
    13.         if (firstGatewayHandlerEntity == null) {
    14.             return null;
    15.         }
    16.         // 2.获取第一个firstGatewayHandler spring容器中的id
    17.         String handlerBeanId = firstGatewayHandlerEntity.getHandlerId();
    18.         // 3.从spring容器中获取对应的对象 firstGatewayHandler
    19.         GatewayHandler firstGatewayHandler = SpringUtils.getBean(handlerBeanId, GatewayHandler.class);
    20.         // 4.使用white循环 设置下一个节点 同时定义循环遍历临时对象
    21.         GatewayHandler tempGatewayHandler = firstGatewayHandler;
    22.         // 5.获取下一个节点
    23.         String nextHandlerBeanId = firstGatewayHandlerEntity.getNextHandlerId();
    24.         while (!StringUtils.isEmpty(nextHandlerBeanId)) {
    25.             GatewayHandlerEntity nextGatewayHandlerEntity = gatewayHandlerMapper.getByHandler(nextHandlerBeanId);
    26.             if (nextGatewayHandlerEntity == null) {
    27.                 break;
    28.             }
    29.             // 6.从springboot容器获取下一个handler 对象
    30.             String tempNextHandlerBeanId = nextGatewayHandlerEntity.getHandlerId();
    31.             GatewayHandler nextGatewayHandler = SpringUtils.getBean(tempNextHandlerBeanId, GatewayHandler.class);
    32.             // 7.设置当前handler下一个handler对象
    33.             tempGatewayHandler.setHandler(nextGatewayHandler);
    34.             tempGatewayHandler = nextGatewayHandler;
    35.             // 8.循环遍历下一个节点
    36.             nextHandlerBeanId = nextGatewayHandlerEntity.getNextHandlerId();
    37.         }
    38.         this.firstGatewayHandler = firstGatewayHandler;
    39.         return firstGatewayHandler;
    40.     }
    41. }

    如何调用:

    1. @RestController
    2. public class HandlerController {
    3.     @Autowired
    4.     private GatewayHandlerService gatewayHandlerService;
    6.     @RequestMapping("/client")
    7.     public String client() {
    8.         GatewayHandler firstGatewayHandler = gatewayHandlerService.getFirstGatewayHandler();
    9.         firstGatewayHandler.service();
    10.         return "success";
    11.     }
    12. }

    总结：
    1.什么是责任链模式
    2.责任链模式应用场景
    3.责任链与链表数据结构关系
    4.基于工厂模式实现责任链
    5.基于数据库实现动态责任链
    6.Java过滤器责任链模式源码分析