设计模式(三) 责任链模式

 

定义

责任链模式是一种设计模式。在责任链模式里，很多对象由每一个对象对其下家的引用而连接起来形成一条链。请求在这个链上传递，直到链上的某一个对象决定处理此请求。

发出这个请求的客户端并不知道链上的哪一个对象最终处理这个请求，这使得系统可以在不影响客户端的情况下动态地重新组织和分配责任。

简而言之，就是将多个对象以链条的形式进行连接。每一个对象都会引用下一个对象。
请求在链条上进行传递，直到某个对象处理了请求，传递终止。

责任链类图

责任链模式涉及到的角色如下所示

● 抽象处理者(BaseHandler)角色：定义出一个处理请求的接口。如果需要，接口可以定义出一个方法以设定和返回对下家的引用。

这个角色通常由一个Java抽象类或者Java接口实现。上图中Handler类的聚合关系给出了具体子类对下家的引用，

抽象方法handleRequest()规范了子类处理请求的操作。

● 具体处理者(ConcreteHandler)角色：具体处理者接到请求后，可以选择将请求处理掉，或者将请求传给下家。

由于具体处理者持有对下家的引用，因此，如果需要，具体处理者可以访问下家。

源代码

抽象处理者(Handler)角色

定义了一个对象，四个方法：

successor：持有当前责任的对象。
getSuccessor()：获取下家责任对象的方法。
setSuccessor()：设置下家责任对象的方法。
handlerRequest()：处理当前请求的方法。如果当前对象可以处理请求，处理请求。如果当前对象不可以处理请求，传递给下家。

public abstract class BaseHandler {

    /**持有后续的责任对象*/
    protected BaseHandler successor;

    /**
     * 示意处理请求的方法，虽然这个示意方法并没有传入参数
     * 但是实际是可以传入参数的，根据实际情况进行选择
     */
    public abstract void handleRequest();

    /**
     * 获取后续的责任对象
     */
    public BaseHandler getSuccessor() {
        return successor;
    }

    /**
     * 设置后续的责任对象
     */
    public void setSuccessor(BaseHandler successor) {
        this.successor = successor;
    }
}

具体处理者(ConcreteHandler)角色

继承BaseHandler类，重写了handleRequest()方法。
如果当前的处理对象有下家就传递给下家，没有下家就自行处理请求。
通过getSuccessor().handleRequest()可以引用下家。

public class ConcreteHandler extends BaseHandler {


    /**处理器名称*/
    private String handlerName;
    public ConcreteHandler(String handlerName) {
        this.handlerName = handlerName;
    }

    /**
     * 处理请求的方法
     * 如果当前对象有下家，就传递给下家
     * 如果当前对象没有下家，就自行处理
     */
    @Override
    public void handleRequest() {

        if(getSuccessor() !=null){
            System.out.println("已经有对象处理此请求！"+this.handlerName);
            getSuccessor().handleRequest();
        }else {
            System.out.println("正在处理请求......."+this.handlerName);
        }

        System.out.println(" ======= 请求处理结束 ======= "+new Date().toLocaleString());
    }
}

测试用例

    public static void main(String[] args) {

        BaseHandler baseHandler1=new ConcreteHandler("baseHandler1");
        BaseHandler baseHandler2=new ConcreteHandler("baseHandler2");
        BaseHandler baseHandler3=new ConcreteHandler("baseHandler3");
        BaseHandler baseHandler4=new ConcreteHandler("baseHandler4");
        baseHandler1.setSuccessor(baseHandler2);
        baseHandler2.setSuccessor(baseHandler3);
        baseHandler3.setSuccessor(baseHandler4);

        //提交请求
        baseHandler1.handleRequest();

    }

场景一聚餐费用 

一般申请聚餐费用的流程为：申请人填写申请表->提交给领导审批
->如果领导批准->去财务领钱
->如果领导不批准->就没有然后了

不同的级别领导的审批额度不一样
比如：项目经理审批最大额度为2000，部门经理审批最大额度为5000，总经理审批最大额度为50000。
也就是说如果审批的费用在2000以内，项目经理、部门经理、总经理都可以审批。如果审批的费用在2000以上，只有部门经理、总经理可以审批。如果审批的费用在5000以上，只有总经理可以审批。

但是最终那个领导进行审批，请求人是不清楚的。这个流程就可以使用责任链模式来实现。

用户提交申请，请求会在(项目经理审批-部门经理审批-总经理审批)这样一条责任处理链上传递。直到某个领导处理了这个请求，这个传递才会结束。

思路：因为每个领导的审批额度是不一样的，所以每个领导应该分别建一个单独的对象，处理各自的业务。而每个领导都继承了同一个抽象的父类，拥有共同的行为和方法。方便根据不同的功能选择对应的审批流程。

源代码

审批处理抽象父类(BaseApprovalHandler)

定义了一个对象，四个方法。
baseApprovalHandler：持有当前责任的对象
transferRequest():负责将请求传递给下家
getBaseApprovalHandler()：获取当前的责任对象
setBaseApprovalHandler()：设置当前的责任对象
handlerRequest()：处理当前请求的方法。如果当前对象可以处理请求，处理请求。如果当前对象不可以处理请求，传递给下家。

public abstract class BaseApprovalHandler {


    /**
     * 审批当前请求的责任对象
     */
    protected BaseApprovalHandler baseApprovalHandler;

    /**
     * 处理当前请求的方法
     * 如果当前对象可以处理请求->处理请求
     * 如果当前对象不可以处理请求->传递给下家
     *
     * @param money 审批金额
     */
    public abstract void handlerRequest(int money);

    /**
     * 将请求传递给下家
     */
    protected void transferRequest(int money){

        //将请求传递给下家
        BaseApprovalHandler baseApprovalHandler = getBaseApprovalHandler();
        if (baseApprovalHandler != null) {
            baseApprovalHandler.handlerRequest(money);
        }
    }

    /**
     * 获取当前的责任对象
     */
    public BaseApprovalHandler getBaseApprovalHandler() {
        return baseApprovalHandler;
    }

    /**
     * 设置当前的责任对象
     */
    public void setBaseApprovalHandler(BaseApprovalHandler baseApprovalHandler) {
        this.baseApprovalHandler = baseApprovalHandler;
    }
}

项目经理(ProjectManager)

职能：只能审批N元以下的申请，超出职能传递给BranchManager

public class ProjectManager extends BaseApprovalHandler {


    public ProjectManager(BaseApprovalHandler baseApprovalHandler) {
        this.baseApprovalHandler=baseApprovalHandler;
    }

    @Override
    public void handlerRequest(int money) {

        //最大审批额度
        int maxMoney=2000;

        if(money <=maxMoney){
            System.out.println("我是"+this.getClass().getSimpleName()+"，正在审批金额 money="+money);
        }else {
            System.out.println("我是"+this.getClass().getSimpleName()+"，金额超出我的审批范围 money="+money);

            //传递请求
            transferRequest(money);

        }

    }
}

部门经理(BranchManager)

职能：只能审批N元以下的申请，超出职能传递给GeneralManager

public class BranchManager extends BaseApprovalHandler {


    public BranchManager(BaseApprovalHandler baseApprovalHandler) {
        this.baseApprovalHandler = baseApprovalHandler;
    }

    @Override
    public void handlerRequest(int money) {

        //最大审批额度
        int maxMoney=5000;

        if(money <=maxMoney){
            System.out.println("我是"+this.getClass().getSimpleName()+"，正在审批金额 money="+money);
        }else {
            System.out.println("我是"+this.getClass().getSimpleName()+"，金额超出我的审批范围 money="+money);

            //传递请求
            transferRequest(money);
        }

    }
}

总经理(GeneralManager)

职能：只能审批N元以下的申请，超出职能直接拒绝

public class GeneralManager extends BaseApprovalHandler {


    public GeneralManager(BaseApprovalHandler baseApprovalHandler) {
        this.baseApprovalHandler = baseApprovalHandler;
    }

    @Override
    public void handlerRequest(int money) {

        //最大审批额度
        int maxMoney=50000;

        if(money <=maxMoney){
            System.out.println("我是"+this.getClass().getSimpleName()+"，正在审批金额 money="+money);
        }else {
            System.out.println("我是"+this.getClass().getSimpleName()+"，金额过大无法审批 money="+money);

            //传递请求
            transferRequest(money);
        }

    }
}

处理工厂(HandlerFactory)

作用：规范审批流程。当前情景的审批需要先经过项目经理，项目经理能审批就处理，不能审批传递给部门经理。
部门经理能审批就处理不能审批就传递给总经理。以此类推

public class HandlerFactory {

    /**
     * 审批处理流程
     * 项目经理->部门经理->总经理
     */
 8     public static BaseApprovalHandler getProjectManagerHandler() {
        return new ProjectManager(new BranchManager(new GeneralManager(null)));
    }
    
}

测试用例

    public static void main(String[] args) {

        //申请金额
        int money = 8000;

        System.out.println("

项目经理开始审批");
        HandlerFactory.getProjectManagerHandler().handlerRequest(money);
    }

扩展性

如果此时审批流程没有项目经理这个角色了。新增了两个审批流程：(部门经理审批->总经理审批)、(总经理审批)。应该怎么办？
这个时候工厂的作用就出现了。我们可以新增两个方法getBranchManagerHandler()、getGeneralManagerHandler()。然后将以前的getProjectManagerHandler()方法暂时废弃掉即可。

public class HandlerFactory {

    /**
     * 审批处理流程
     * 项目经理->部门经理->总经理
     */
    @Deprecated
    public static BaseApprovalHandler getProjectManagerHandler() {
        return new ProjectManager(new BranchManager(new GeneralManager(null)));
    }

    /**
     * 审批处理流程
     * 部门经理->总经理
     */
    public static BaseApprovalHandler getBranchManagerHandler() {
        return new BranchManager(new GeneralManager(null));
    }

    /**
     * 审批处理流程
     * 总经理
     */
    public static BaseApprovalHandler getGeneralManagerHandler() {
        return new GeneralManager(null);
    }

}

场景二拦截器应用

假设我需要对外提供API服务。考虑到接口安全性需要做token校验，日志收集需要做日志记录。这个时候怎么做呢？
一般的时候我们都会选择加一个拦截器。先做一个token校验，然后再做一个日志收集。
或者增加一个日志拦截器、token拦截器。
那么我们分析一下这样做好不好。第一种情况将所有的业务冗余一个方法一个类，如果以后增加接口限流，增加其他的功能会继续冗余。第二种情况增加多个拦截器，以后增加功能拦截器会越来越多。能不能做到有效的管理？

思路：我们知道责任链的功能是把多个业务功能进行串联。当请求到达token校验类的时候校验token，检验完token传递给下家。当请求到达日志类的时候做日志记录，做完日志记录传递给下家。那么，如果获取这个请求呢？我们可以增加一个拦截器，拦截器接收到请求之后，将请求传递到责任链。
这样一来，只需要一个拦截器我们就完成了token校验、日志收集。如果后期增加功能只需要增加一个类即可。

查看以下类图

 

首先客户端接收到请求会进入拦截器(BaseFilter)，在doFilter()方法中进行接收。doFilter()获取request参数、response参数。并调用BaseFilterFactory工厂将request参数、response参数传到责任链。
此时责任链接接收到request参数、response参数。会进行token校验、日志采集，执行完会调用下家继续执行，如果没有下家则停止传递。

源代码

审批处理抽象父类(BaseFilterHandler)

定义了一个对象，四个方法
successor：持有当前责任的对象
transferRequest():负责将请求传递给下家
getBaseApprovalHandler()：获取当前的责任对象
setBaseApprovalHandler()：设置当前的责任对象
handlerRequest()：处理当前请求的方法。如果当前对象可以处理请求，处理请求。如果当前对象不可以处理请求，传递给下家。

　　

public abstract class BaseFilterHandler {

    /** 处理当前请求的责任对象 */
    protected BaseFilterHandler successor;

    /**
     * 处理请求
     *
     * @param request
     *         请求对象
     * @param response
     *         请求对象
     * @param chain
     *         决定拦截器是否执行
     *
     * @throws IOException
     *         io异常
     * @throws ServletException
     *         servlet异常
     */
    public abstract void handlerRequest(ServletRequest request, ServletResponse response, FilterChain chain) throws IOException, ServletException;

    /**
     * 将请求传递给下家
     *
     * @param request
     *         请求对象
     * @param response
     *         请求对象
     * @param chain
     *         决定拦截器是否执行
     *
     * @throws IOException
     *         io异常
     * @throws ServletException
     *         servlet异常
     */
    protected void transferRequest(ServletRequest request, ServletResponse response, FilterChain chain) throws IOException, ServletException {

        //将请求传递给下家
        BaseFilterHandler baseFilter = getSuccessor();
        if (baseFilter != null) {
            baseFilter.handlerRequest(request, response, chain);
        }
    }


    public BaseFilterHandler getSuccessor() {
        return successor;
    }

    public void setSuccessor(BaseFilterHandler successor) {
        this.successor = successor;
    }
}

日志记录(LogRecord)

职能：负责获取接口请求与参数，进行统一日志记录管理

public class LogRecord extends BaseFilterHandler {

    public LogRecord(BaseFilterHandler baseFilterHandler) {
        this.successor = baseFilterHandler;
    }

    @Override
    public void handlerRequest(ServletRequest request, ServletResponse response,FilterChain chain) throws IOException, ServletException {


        System.out.println("
 日志记录拦截器..................");

        //日志记录->记录完日志调用下家
        HttpServletRequest httpServletRequest = (HttpServletRequest) request;


        //获取请求URL
        StringBuffer requestURL = httpServletRequest.getRequestURL();
        System.out.println("请求URL: requestURL=" + requestURL);

        //获取请求参数
        Map<String, String[]> parameterMap = request.getParameterMap();
        if (parameterMap.size() > 0) {

            Map<String, String> parameterMap2 = new HashMap<>(parameterMap.size());
            parameterMap.forEach((key, value) -> parameterMap2.put(key, Arrays.toString(value)));

            System.out.println("请求参数：parameterMap=" + parameterMap2);
        }


        //请求传递给下家
        transferRequest(request, response ,chain);

        chain.doFilter(request, response);
    }
}

token鉴权(TokenAuth)

职能：负责校验接口token是否合法

public class TokenAuth extends BaseFilterHandler {

    private final String ckToken = "123";

    public TokenAuth(BaseFilterHandler baseFilterHandler) {
        this.successor = baseFilterHandler;
    }

    @Override
    public void handlerRequest(ServletRequest request, ServletResponse response, FilterChain chain) throws IOException, ServletException {

        //token校验->校验完token调用下家

        HttpServletResponse httpServletResponse = (HttpServletResponse) response;
        System.out.println("
 token校验拦截器..................");

        //获取请求参数
        boolean isNext = false;
        Map<String, String[]> parameterMap = request.getParameterMap();
        if (parameterMap.size() > 0) {

            String[] tokens = parameterMap.get("token");
            if (tokens.length > 0) {
                for (String token : tokens) {
                    if (StringUtils.isNotEmpty(token) && ckToken.equals(token)) {
                        isNext = true;
                    }
                }
            }
        }


        if (isNext) {

            //请求传递给下家
            transferRequest(request, response, chain);

            chain.doFilter(request, response);

        } else {
            //这句话的意思，是让浏览器用utf8来解析返回的数据
            httpServletResponse.setHeader("Content-type", "text/html;charset=UTF-8");
            //这句话的意思，是告诉servlet用UTF-8转码，而不是用默认的ISO8859
            httpServletResponse.setCharacterEncoding("UTF-8");

            String printStr="无效的token";
            httpServletResponse.getWriter().print(printStr);
            System.out.println(printStr);
        }

    }
}

处理工厂(BaseFilterFactory)

作用：规范审批流程。当前的执行流程为：token鉴权(TokenAuth)->日志记录(LogRecord)。
当然执行顺序可以按照业务场景，自行调整。

public class BaseFilterFactory {

    public static BaseFilterHandler getBaseFilterHandler(){
        return new TokenAuth(new LogRecord(null));
    }

}

过滤器(BaseFilter)
作用：负责拦截请求，调用处理工厂，并将请求参数传递给责任链

@WebFilter(filterName = "baseFilter", urlPatterns = "/*")
public class BaseFilter implements Filter {

    private final List<String> passUrlList =new ArrayList<>(50);

    @Override
    public void init(FilterConfig filterConfig) throws ServletException {
        passUrlList.clear();
        passUrlList.add(".");
        passUrlList.add("/login");
        passUrlList.add("/jiankong");
    }

    @Override
    public void doFilter(ServletRequest request, ServletResponse response, FilterChain chain) throws IOException, ServletException {

        System.out.println("

 ========================= 执行自定义责任链拦截器 ========================= ");

        //获取请求URL
        HttpServletRequest httpServletRequest = (HttpServletRequest) request;
        String requestURI = httpServletRequest.getRequestURI();
        if(passUrlList.size() >0){
            for (String url : passUrlList) {
                if (requestURI.contains(url)) {

                    System.out.println("url ="+requestURI +"放行！");

                    chain.doFilter(request, response);
                    return;
                }
            }
        }

        //执行自定义责任链拦截器
        BaseFilterHandler baseFilterHandler = BaseFilterFactory.getBaseFilterHandler();
        baseFilterHandler.handlerRequest(request,response,chain);

    }
}

配置(BaseFilterConfig)

@Configuration
public class BaseFilterConfig {
    @Bean
    public FilterRegistrationBean filterRegistrationBean(){
        FilterRegistrationBean bean = new FilterRegistrationBean();
        bean.setFilter(new BaseFilter());
        bean.addUrlPatterns("/*");
        return bean;
    }
}

总结

纯与不纯的责任链模式

我们知道责任链中有两个行为：一个是承担责任，一个是把责任推给下家。

纯的责任链模式：要求两个行为中只执行一个，要么承担责任，要么把责任推给下家。不能存在既承担部分责任，又把责任推给下家的情况。

不纯的责任链模式：就是即承担部分责任，又把责任推给下家。当然也有可能出现没有对象承担责任的情况。

在抽象处理者(Handler)角色中，我们采用的是纯的责任链模式，但是这种情况在现实生活中很难找到。
像场景一聚餐费用 与场景二拦截器应用现实生活中均是不纯的责任链模式。

责任链模式的应用场景

网关：接口鉴权、日志记录、接口限流等等
多条件(if else 、switch)流程判断、权限控制
ERP系统 流程审批 总经理、人事经理、项目经理
Java过滤器的底层实现Filter