设计模式09：责任链模式

一、定义

    责任链是一种行为模式。将处理请求的多个环节连在一起，形成一条链。当请求的对象进入链条时，流过某个模块，某个模块就处理自身的逻辑，处理完成之后，将处理后的对象在交由下一个环节处理。以此来实现各个业务模块之间的解耦。

二、优缺点

1、优点

• 降低耦合度，将请求的发送者与各个部分的处理逻辑进行解耦。
• 简化对象，兑现不需要知道链的结构，也不需要知道自己在链的那个环节，顺着链一直传递下去，一直到结尾就可形成目标对象或某种功能。
• 增强给对象添加或删除责任环节的灵活性，也可在系统运行过程中动态添加或删除某些责任环节。
• 系统易扩展，可任意在链上动态添加责任模块。

2、缺点

• 可能存在链上模块循环调用。
• 不能保证一定会被链上某个模块处理。

三、应用实例

1、tomcat中的Encoding处理，以及tomcat中的管道模式就是责任链模式的变种。

2、拦截器链和过滤器链。

四、应用场景

1、有多个对象可以处理同一个请求，具体哪个对象处理该请求由运行时刻自动确定。 

2、在不明确指定接收者的情况下，向多个对象中的一个提交一个请求。 

3、可动态指定一组对象处理请求。

五、Java实现

1、业务场景

    以参数校验为例。一个参数进入联调后，分别有长度验证、类型验证、字符串比对验证等联调到最终结果。

2、原型图

3、Java实现

3.1、创建上下文对象类，各个环节将要处理的对象。

/**
 * desc: 上下文需要处理的对象
 *
 * @author xuebin
 * @version 1.0
 * @date 2020/04/28 
 */
public class Param {
    private String param;

    public String getParam() {
        return param;
    }

    public void setParam(String param) {
        this.param = param;
    }
}

3.2、责任链中节点抽象类

/**
 * desc: 验证抽象类
 *
 * @author xuebin
 * @version 1.0
 * @date 2020/04/28 
 */
public abstract class AbstractParamsValidate {
    /**
     * 责任链中下一个处理者
     */
    private AbstractParamsValidate nextParamsValidate;

    public AbstractParamsValidate getNextParamsValidate() {
        return nextParamsValidate;
    }

    public void setNextParamsValidate(AbstractParamsValidate nextParamsValidate) {
        this.nextParamsValidate = nextParamsValidate;
    }

    /**
     * 业务处理
     * @param param 需要处理的对象
     * @return true 处理成功； false 处理失败
     */
    public abstract boolean validate(Param param);

    public boolean hasNext(){
        return nextParamsValidate != null;
    }
}

3.3、分别创建四种联调处理者

/**
 * desc: 长度处理者
 *
 * @author xuebin
 * @version 1.0
 * @date 2020/04/28 
 */
public class LengthValidate extends AbstractParamsValidate {

    @Override
    public boolean validate(Param param) {
        param.setParam(param.getParam() + " -> LengthValidate");
        System.out.println("LengthValidate");
        if (hasNext()){
            getNextParamsValidate().validate(param);
        }
        return true;
    }
}
/**
 * desc:
 *
 * @author xuebin
 * @version 1.0
 * @date 2020/04/28 
 */
public class SecurityValidate extends AbstractParamsValidate {
    @Override
    public boolean validate(Param param) {
        param.setParam(param.getParam() + " -> SecurityValidate");
        System.out.println("TypeValidate");
        if (hasNext()){
            getNextParamsValidate().validate(param);
        }
        return false;
    }
}
/**
 * desc:
 *
 * @author xuebin
 * @version 1.0
 * @date 2020/04/28 
 */
public class SecurityValidate extends AbstractParamsValidate {
    @Override
    public boolean validate(Param param) {
        param.setParam(param.getParam() + " -> SecurityValidate");
        System.out.println("TypeValidate");
        if (hasNext()){
            getNextParamsValidate().validate(param);
        }
        return false;
    }
}

3.4、特殊处理，在联调中动态添加责任链中的处理者

/**
 * desc: 长度处理者
 *
 * @author xuebin
 * @version 1.0
 * @date 2020/04/28 
 */
public class EquesValidate extends AbstractParamsValidate {

    @Override
    public boolean validate(Param param) {
        param.setParam(param.getParam() + " -> EquesValidate");

        // 在EquesValidate校验后添加SecurityValidate校验

        System.out.println("EquesValidate");
        if (hasNext()){



            // 安全校验
            AbstractParamsValidate securityValidate = new SecurityValidate();
            // 下一个校验连
            AbstractParamsValidate next = getNextParamsValidate();
            // 将下一个校验连设置到securityValidate后边
            securityValidate.setNextParamsValidate(next);
            // 将securityValidate设置成下一个校验链
            setNextParamsValidate(securityValidate);

            // 关键点：调用下一个调用链处理逻辑
            getNextParamsValidate().validate(param);
        }
        return true;
    }
}

3.5、测试

/**
 * desc: 责任链测试类
 *
 * @author xuebin
 * @version 1.0
 * @date 2020/04/28 
 */
public class ValidateTest {
    public static void main(String[] args) {
        Param param = new Param();
        param.setParam("validate start");

        AbstractParamsValidate lengthValidate = new LengthValidate();
        AbstractParamsValidate equesValidate = new EquesValidate();
        AbstractParamsValidate typeValidate = new TypeValidate();

        lengthValidate.setNextParamsValidate(equesValidate);
        equesValidate.setNextParamsValidate(typeValidate);

        lengthValidate.validate(param);

        System.out.println("param 最终结果： "+param.getParam());
    }
}

3.6、运行结​果

LengthValidate
EquesValidate
SecurityValidate
TypeValidate
param 最终结果： validate start -> LengthValidate -> EquesValidate -> SecurityValidate -> TypeValidate