设计模式-责任链模式

概念

• 责任链模式是一种行为设计模式
• 
  • 就是将一个东西（入参）按步骤顺序处理
  • 每一个步骤（一个个实际处理入参的对象：可以抽出公共的接口或抽象类）对应相应的处理方式
  • 东西通过这条加工链（步骤的对象数组）进行一步步的处理。
  • 输出最终的产品（出参）。

使用方式

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、规则拦截对象