乐趣区

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

jiezi

概念

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

应用形式

  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 多平台公布

退出移动版