Java设计模式--责任链模式

责任链模式的理解：

　　生产一个产品，需要依次执行多个步骤，才能完成，那么是使用责任链模式则是极好的。

　　小学生请假条审批流程。

代码如下：

/**
 * 类功能说明:  告警规则
 * @author 尘世间迷茫的小书童
 *
 */
public class AlarmRule {
    
    private String name;
    
    private String type;
    
    /**
     * 阈值
     */
    private String threshold;
    
    public String getName() {
        return name;
    }
    public void setName(String name) {
        this.name = name;
    }
    public String getType() {
        return type;
    }
    public void setType(String type) {
        this.type = type;
    }
    public String getThreshold() {
        return threshold;
    }
    public void setThreshold(String threshold) {
        this.threshold = threshold;
    }
    
}

/**
 * 类功能说明: 告警规则责任链处理节点抽象类
 * @author 尘世间迷茫的小书童
 *
 */
public abstract class AbstractRuleHandler {
    
    // 上一个处理器
    private AbstractRuleHandler preHandler;
    
    // 下一个处理器
    private AbstractRuleHandler nextHandler;
    
    /**
     * 业务执行
     * 
     * @author 尘世间迷茫的小书童
     * @param rule
     */
    public void doHandle(AlarmRule rule){
        try {
            doHandleReal(rule);
        } catch(Exception e) {
            // 业务代码执行失败主动回滚
            rollBack(rule);
            return;
        }
        
        // 业务代码执行成功主动调用下一个处理器处理
        if(null != nextHandler)
        {
            nextHandler.doHandle(rule);
        }
    }
    
    
    /**
     * 事务回滚
     * 
     * @param rule
     */
    public void rollBack(AlarmRule rule)
    {
        rollBackReal(rule);
        // 本处理器业务回滚完成，主动调用前一个处理器业务回滚
        if(null != preHandler)
        {
            preHandler.rollBack(rule);
        }
    }
    
    
    /**
     * 每个处理器特有的业务处理方法
     * 
     * @param rule
     * @throws Exception
     */
    public abstract void doHandleReal(AlarmRule rule) throws Exception;
    
    /**
     * 每个处理器特有的业务回滚方法
     * 
     * @param rule
     */
    public abstract void rollBackReal(AlarmRule rule);
    
    /**
     * 设置上一个业务处理器
     * @param preHandler
     * @return
     */
    private AbstractRuleHandler setPreHandler(AbstractRuleHandler preHandler) 
    {
        this.preHandler = preHandler;
        return preHandler;
    }

    /**
     * 设置下一个业务处理器
     * @param nextHandler
     * @return
     */
    public AbstractRuleHandler setNextHandler(AbstractRuleHandler nextHandler) 
    {
        this.nextHandler = nextHandler;
        nextHandler.setPreHandler(this);
        return nextHandler;
    }
}

/**
 * 规则入库处理器
 * 类功能说明:   告警规则持久化
 * @author 尘世间迷茫的小书童
 *
 */
public class RulePesistHandler extends AbstractRuleHandler {

    @Override
    public void doHandleReal(AlarmRule rule) throws Exception {
        if(null == rule.getName() || "".equals(rule.getName())){
            throw new Exception("Rule name is empty.");
        }
        System.out.println("规则入库处理器: " + "Persist rule success. Rule name is " + rule.getName());
    }

    @Override
    public void rollBackReal(AlarmRule rule) {
        System.out.println("规则入库处理器: " + "Roll persist rule. Rule name is " + rule.getName());
    }

}

/**
 * 流任务生成处理器
 * 类功能说明:   告警流规则生成
 * @author 尘世间迷茫的小书童
 *
 */
public class StreamGenerateHandler extends AbstractRuleHandler {

    @Override
    public void doHandleReal(AlarmRule rule) throws Exception {
        System.out.println("流任务生成处理器: " + "Generate stream success.");
    }

    @Override
    public void rollBackReal(AlarmRule rule) {
        System.out.println("流任务生成处理器: " + "Roll Generate stream.");
    }

}

/**
 * 阈值解析处理器
 * 类功能说明:   阈值解析
 * @author 尘世间迷茫的小书童
 *
 */
public class ThresholdParseHandler extends AbstractRuleHandler {

    @Override
    public void doHandleReal(AlarmRule rule) throws Exception {
        if(null == rule.getThreshold() || "".equals(rule.getThreshold())){
            throw new Exception("Threshold is empty.");
        }
        System.out.println("阈值解析处理器: " + "Parse threshold success. Threshold is " + rule.getThreshold());
    }

    @Override
    public void rollBackReal(AlarmRule rule) {
        System.out.println("阈值解析处理器: " + "Roll parse threshold. Threshold is " + rule.getThreshold());
    }

}

/**
 * 规则创建责任链
 * 类功能说明:   告警规则创建
 * @author 尘世间迷茫的小书童
 *
 */
public class AlarmRuleCreator {
    
    private AbstractRuleHandler alarmRuleHandler;
    
    public AlarmRuleCreator(){
        alarmRuleHandler = new ThresholdParseHandler();
        alarmRuleHandler.setNextHandler(new StreamGenerateHandler())
                .setNextHandler(new RulePesistHandler());
    }
    
    public void create(AlarmRule rule){
        alarmRuleHandler.doHandle(rule);
    }
    
    public static void main(String[] args){
        AlarmRule rule = new AlarmRule();
        rule.setThreshold("cpuRate < 10");
        rule.setName("Cpu Alarm");
        
        AlarmRuleCreator ruleCreator = new AlarmRuleCreator();
        ruleCreator.create(rule);
        System.out.println();
        
        rule.setName("");
        ruleCreator.create(rule);
    }

    
}

　　

　　代码虽然写了很多但意思很简单，你生成一条规则，按照一定流程处理该规则，一个流程处理完下一个流程处理，直到所有流程走完；中间但凡有一条不符合，回滚该流程，再回滚上一个处理流程，回滚全部操作。责任链的应用相当于工作流。

 

推荐阅读： https://www.cnblogs.com/coshaho/p/6815490.html　　http://c.biancheng.net/view/1383.html