设计模式--责任链模式

Posted 2021-06-29 我爱看明朝

设计模式–责任链模式

当我们需要连续链式的进行处理数据时：你可以理解为接力赛，接力棒就是我们处理的数据，队员就是就是不同的处理器(mybaitis就是自定义插件)

责任链中的角色

责任链模式中有两个角色: 处理者、调度者

调度者：负责责任在处理这之间的传播
处理者：只负责处理自己的逻辑，保持单一原则

要点： 各个处理器要符合单一原则，关注自己的逻辑就行，任务的传播交给调度这就Ok了

应用

mybaits的插件机制
servlet中filter机制

工作流、管道流、各种类型的审批

责任链实现

/**
 * 任务抽象方法
 * @author
 * @description
 **/
public abstract class Task {

    public abstract Object hanlderTask(Object o);
}

/**
 * 调度者
 * @author xuelongjiang109
 * @description
 **/
public class Chain {

    private List<Task> taskList = new ArrayList<Task>();

    public void handler() {
        Object object = new Object();

        for (Task task : taskList) {
            object = task.hanlderTask(object);
        }
    }

    // 加入
    public void addTask(Task task) {
        taskList.add(task);
    }

}

// 具体任务
public class TaskOne extends  Task {

    @Override
    public Object hanlderTask(Object o) {
        // 处理逻辑返回object
        System.out.println("处理任务1");
        return o;
    }
}

public class TaskTwo extends  Task {

    public Object hanlderTask(Object o) {
        System.out.println("处理任务2");
        return o;
    }
}

//具体任务
public class Client {

    public static void main(String[] args) {

        Chain chain = new Chain();
        chain.addTask(new TaskOne());
        chain.addTask(new TaskTwo());
        chain.handler();

    }

}

实践：部署审批

我们写一个示例，需求如下：部署不同环境需要不同角色审批
ci: 只需要开发者通过就可以部署
stg:需要开发者、测试人员通过就可以部署
prd:需要开发者、测试人员、团队leader同意才可以部署

// 调度者
public class DeployChain {

    private List<AbstractDeployHandler> handlers = new ArrayList<AbstractDeployHandler>();

    public void handler(DeployInfo deployInfo) {
        System.out.println("当前需部署环境:" + deployInfo.getEnv());
        for (AbstractDeployHandler deployHandler : handlers) {
            deployHandler.handlerDeploy(deployInfo);
            if (!deployInfo.isResult()) {
                break;
            }
        }
    }

    public void addHandler(AbstractDeployHandler handler) {
        handlers.add(handler);
    }

}

// 部署信息
public class DeployInfo {

    private String env;
    //是否同意部署
    private boolean result = false;

    public String getEnv() {
        return env;
    }

    public void setEnv(String env) {
        this.env = env;
    }

    public boolean isResult() {
        return result;
    }

    public void setResult(boolean result) {
        this.result = result;
    }
}

// 抽象的处理者
public abstract class AbstractDeployHandler {

    public abstract DeployInfo handlerDeploy(DeployInfo deployInfo);

}

//角色为开发者的处理者
public class DevRoleDeployHanlder extends  AbstractDeployHandler {

    public DeployInfo handlerDeploy(DeployInfo deployInfo) {
        if ("ci".equals(deployInfo.getEnv())
        || "stg".equals(deployInfo.getEnv())
                || "prd".equals(deployInfo.getEnv())) {
            deployInfo.setResult(true);
            System.out.println("我是开发者，允许部署");
        }
        return deployInfo;
    }
}

//角色为测试者的处理者
public class TestRoleDeployHanlder extends  AbstractDeployHandler{

    public DeployInfo handlerDeploy(DeployInfo deployInfo) {
        if ("stg".equals(deployInfo.getEnv())
                || "prd".equals(deployInfo.getEnv())) {
            deployInfo.setResult(true);
            System.out.println("我是测试人员，允许部署");
        } else {
            deployInfo.setResult(false);
        }
        return deployInfo;
    }
}

//角色为团队leader的处理者
public class LeaderDeployHanlder extends  AbstractDeployHandler {

    public DeployInfo handlerDeploy(DeployInfo deployInfo) {
        if ("prd".equals(deployInfo.getEnv())) {
            deployInfo.setResult(true);
            System.out.println("我是项目leader，允许部署");
        } else {
            deployInfo.setResult(false);
        }
        return deployInfo;
    }
}

public class Client {

    public static void main(String[] args) {

        DeployInfo info = new DeployInfo();
        info.setEnv("ci");

        AbstractDeployHandler dever = new DevRoleDeployHanlder();
        AbstractDeployHandler tester = new TestRoleDeployHanlder();
        AbstractDeployHandler leader = new LeaderDeployHanlder();

        DeployChain chain = new DeployChain();
        chain.addHandler(dever);
        chain.addHandler(tester);
        chain.addHandler(leader);

        chain.handler(info);
    }

}