设计模式--责任链模式

Dear 丶 2022-10-07 14:58 202阅读 0赞

# 设计模式–责任链模式 #

> 当我们需要连续链式的进行处理数据时：你可以理解为接力赛，接力棒就是我们处理的数据，队员就是就是不同的处理器(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);
        }
    
    }