关于后端:设计模式责任链模式

概念

• 责任链模式是一种行为设计模式
• • 就是将一个货色（入参）按步骤程序解决
  • 每一个步骤（一个个理论解决入参的对象：能够抽出公共的接口或抽象类）对应相应的解决形式
  • 货色通过这条加工链（步骤的对象数组）进行一步步的解决。
  • 输入最终的产品（出参）。

应用形式

1. 定义一个公共接口或者抽象类
2. 创立每一步的对象去实现该接口或者抽象类
3. 创立一个初始化类，将每一步串联起来

业务场景

• 咱们在我的项目解决申请的时候，一个申请过去，咱们可能进行

  1. 非空参数查看
  2. 平安调用校验
  3. 校验黑名单
  4. 规定拦挡对象

代码实现

1. 定义一个公共接口或者抽象类

   /**
     * @Description: 定义一个接口或者抽象类
     */
   public abstract class AbstractHandler {
   
       /**
        * 责任链中的下一个对象
        */
       private AbstractHandler nextHandler;
       
       // 串连所有操作
       public void filter(HttpServletRequest request, HttpServletResponse response) {
           // 执行以后链
           doFilter(request, response);
           // 如果还有下个链，执行下个链
           if (getNextHandler() != null) {getNextHandler().filter(request, response);
           }
       }
   
       // 获取下一个链对象
       public AbstractHandler getNextHandler() {return nextHandler;}
       
       // 插入责任链的下一个对象
       public void setNextHandler(AbstractHandler nextHandler){this.nextHandler = nextHandler;}
   
       abstract void doFilter(HttpServletRequest request, HttpServletResponse response);
   }

2. 创立每一步的对象去实现该接口或者抽象类

   • 非空参数查看

     /**
      * 1、非空参数查看对象
      **/
     @Component
     @Order(1) // 程序排第 1，最先校验
     public class CheckParamFilterObject extends AbstractHandler {
     
         @Override
         public void doFilter(HttpServletRequest request, HttpServletResponse response) {System.out.println("1、非空参数查看");
         }
     }

   • 平安调用校验

     /**
      *  2、平安校验对象
      */
     @Component
     @Order(2) // 校验程序排第 2
     public class CheckSecurityFilterObject extends AbstractHandler {
     
         @Override
         public void doFilter(HttpServletRequest request, HttpServletResponse response) {
             //invoke Security check
             System.out.println("2、平安调用校验");
         }
     }

   • 校验黑名单

     /**
      *  3、黑名单校验对象
      */
     @Component
     @Order(3) // 校验程序排第 3
     public class CheckBlackFilterObject extends AbstractHandler {
     
         @Override
         public void doFilter(HttpServletRequest request, HttpServletResponse response) {
             //invoke black list check
             System.out.println("3、校验黑名单");
         }
     }

   • 规定拦挡对象

     /**
      *  4、规定拦挡对象
      */
     @Component
     @Order(4) // 校验程序排第 4
     public class CheckRuleFilterObject extends AbstractHandler {
     
         @Override
         public void doFilter(HttpServletRequest request, HttpServletResponse response) {
             //check rule
             System.out.println("4、规定拦挡对象");
         }
     }

3. 创立一个初始化类，将每一步串联起来

   /**
     * @Description: 对象链连起来（初始化）对象
     */
   @Component("ChainPatternDemo")
   public class ChainPatternDemo {
   
       // 主动注入各个责任链的对象
       @Autowired
       private List<AbstractHandler> abstractHandleList;
   
       private AbstractHandler abstractHandler;
   
       //spring 注入后主动执行，责任链的对象连接起来
       @PostConstruct
       public void initializeChainFilter(){for(int i = 0;i<abstractHandleList.size();i++){if(i == 0){abstractHandler = abstractHandleList.get(0);
               }else{AbstractHandler currentHander = abstractHandleList.get(i - 1);
                   AbstractHandler nextHander = abstractHandleList.get(i);
                   currentHander.setNextHandler(nextHander);
               }
           }
       }
   
       // 间接调用这个办法应用, 返回最初解决好的 response
       public HttpServletResponse exec(HttpServletRequest request, HttpServletResponse response) {
           // 这里 abstractHandler 就是第一个 接下来就会一个一个向下
           abstractHandler.filter(request, response);
           return response;
       }
   }

4. 调用

   @RestController
   public class PayController {
   
       @Autowired
       private ChainPatternDemo chainPatternDemo;
   
       @RequestMapping("/testHandler")
       public  void testHandler(HttpServletRequest req, HttpServletResponse resp){
           // 调用责任链
           chainPatternDemo.exec(req,resp);
       }
   }

5. 后果

   1、非空参数查看
   2、平安调用校验
   3、校验黑名单
   4、规定拦挡对象 

本文由 mdnice 多平台公布