美文网首页程序员
学好设计模式防被祭天:责任链模式

学好设计模式防被祭天:责任链模式

作者: 阿菜的博客 | 来源:发表于2017-09-05 22:08 被阅读116次
    责任链模式

    为了防止被“杀”了祭天,学点设计模式,并总结下还是有必要的。

    一:理解

    1. 在责任链模式中,对象通过对另一个对象的引用而连接形成一条链。调用方的请求可以在链上传递,直到找到满足要求的处理对象,或者走完整个链。
    2. 责任链将调用方和服务方进行解耦,调用方无需知道服务方内部的逻辑。
    3. Tomcat的过滤器链FilterChain中使用了责任链模式。

    二:例子

    你是个富二代。

    你爸给了你5个亿让你玩投资。

    虽然你贵为富二代,不过一下子给你5个亿,你还是略略有点触不及防的。

    于是,你开始满世界的招管理人员辅助你投资,准备大干一番。

    准备大干一番

    你还叫来了程序员小菜帮你抽象一下投资工资的员工管理问题。

    小菜上来就是一顿敲。

    为了对员工的行为进行约束,他首先新建了一个抽象经理类Manager。

    Manager类中只有一个方法handleInvestment,即处理投资。

    @Data
    public abstract class Manager {
        public abstract void handleInvestment(long amount);
    }
    

    接着,小菜新建了不同级别的经理,有一级,二级,三级管理人员,当然你是最高级别的经理。

    他们都继承自Manager抽象类。他们处理投资的方法各不一样,为了方便举例,只输出一句话。

    // 一级经理
    public class AManager extends Manager {
        @Override
        public void handleInvestment(long amount) {
            System.out.println("一级已经处理");
        }
    }
    
    // 二级经理
    public class BManager extends Manager {
        @Override
        public void handleInvestment(long amount) {
            System.out.println("二级经理已经处理");
        }
    }
    
    // 三级经理
    public class CManager extends Manager {
        @Override
        public void handleInvestment(long amount) {
            System.out.println("三级经理已经处理");
        }
    }
    
    // 你,最高级经理
    public class You extends Manager {
        @Override
        public void handleInvestment(long amount) {
            System.out.println("厂长亲自处理");
        }
    }
    

    作为一个大公司,你不希望所有的投资都直接找你谈,你只谈大项目,于是你规定:

    1. 投资金额小于等于一万元,一级经理直接处理。
    2. 投资金额在一万元到十万元之间,二级经理直接处理。
    3. 投资金额在十万元到一百万元之间,三级经理直接处理。
    4. 投资金额超过一百万元,你亲自处理。

    于是,小菜写了以下的测试代码:

    public class Client {
        public static void main(String[] args) {
            Manager aManager = new AManager();
            Manager bManager = new BManager();
            Manager cManager = new CManager();
            Manager you = new You();
            int amount = 99999;
            if (amount <= 10000) {
                aManager.handleInvestment(amount);
            } else if (amount <= 100000) {
                bManager.handleInvestment(amount);
            } else if (amount <= 1000000) {
                cManager.handleInvestment(amount);
            } else {
                you.handleInvestment(amount);
            }
        }
    }
    

    输入/输出:

    二级经理已经处理

    投资公司顺利地开起来了,你也很开心。

    一段时间之后,创业者们纷纷反映很难可以找到对接的经理。

    因为创业者需要根据自己项目所需的金额,找到对应的投资人。

    创业者在发起请求之前,需要在一堆if else中找到符合要求的经理。

    作为高富帅,你觉得让投资者自己了解整个游戏规则,并且徜徉在if else的海洋里,翻过山和大海才能得到投资,很符合你高贵的身份。

    然而,毕竟是第一次开公司,你还是决定让创业者们更方便一些。

    你决定对公司做出调整,有以下两个方案:

    1. 专门设立一个咨询类接受投资者的请求,咨询类根据投资金额,将投资请求提交到对应的经理。
    2. 所有投资直接找一级经理。如果一级经理无权处理,往上申请,直到向你申请为止。

    小菜惊讶于你竟然会产生这样的想法,表示book思议。

    book思议

    然而在你的淫威下,小菜开始重构代码。

    小菜认为,方案一需要多招至少一名员工,你那么大方,是肯定不会同意的。

    于是,他决定尝试使用责任链模式来重构这个程序。

    因为不同等级的经理有关联关系,并且调用呈链式关系,即一级到二级,二级到更上级,直到最上级。

    小菜首先抽象出Manager类,Manager中有一个superior属性,该属性表示的是当前对象的上级。

    superior也属于Manager类,因为经理的上级仍旧是一个经理。

    @Data
    public abstract class Manager {
        private Manager superior;
    
        public abstract void handleInvestment(long amount);
    }
    

    接着,小菜新建了一级经理,二级经理,三级经理和你对应的类。

    // 一级经理
    public class AManager extends Manager {
        @Override
        public void handleInvestment(long amount) {
            if (amount <= 10000) {
                System.out.println("一级经理已经处理");
                return;
            }
            getSuperior().handleInvestment(amount);
        }
    }
    
    // 二级经理
    public class BManager extends Manager {
        @Override
        public void handleInvestment(long amount) {
            if (amount <= 100000) {
                System.out.println("二级经理已经处理");
                return;
            }
            getSuperior().handleInvestment(amount);
        }
    }
    
    // 三级经理
    public class CManager extends Manager {
        @Override
        public void handleInvestment(long amount) {
            if (amount <= 1000000) {
                System.out.println("三级经理已经处理");
                return;
            }
            getSuperior().handleInvestment(amount);
        }
    }
    
    // 你,最高级经理
    public class You extends Manager {
        @Override
        public void handleInvestment(long amount) {
            System.out.println("厂长亲自处理");
        }
    }
    

    和之前不同的是,当经理受到投资请求时,如果投资金额处于自己可处理范围内,则直接处理,return。

    如果无权处理,则提交上级进行处理。

    小菜写了一段测试代码:

    public class Client {
        public static void main(String[] args) {
            Manager aManager = new AManager();
            Manager bManager = new BManager();
            Manager cManager = new CManager();
            Manager you = new You();
            aManager.setSuperior(bManager);
            bManager.setSuperior(cManager);
            cManager.setSuperior(you);
            aManager.handleInvestment(9999);
            aManager.handleInvestment(99999);
            aManager.handleInvestment(999999);
            aManager.handleInvestment(9999999);
        }
    }
    

    输入/输出:

    一级经理已经处理
    二级经理已经处理
    三级经理已经处理
    厂长亲自处理

    在经过责任链模式重构之后,整个投资过程变得很清晰,创业者无需再了解你司内部的逻辑,专心创业即可。

    在例子中,责任链是单向的,即从下往上。

    也可以构建双向责任链模式,请求者可以把请求发到链上的任意对象,再根据是否满足条件开始在链上传递。

    小菜将重构后的代码给你看,你很开心。

    当你得知这个模式叫责任链模式之后,你顿时觉得自己的投资公司非常有责任。

    小菜也体验了一把有bear来的感觉。


    有bear来

    三:再理解

    1. 例子中通过在类中加入对上级的引用来构建调用链,其实也可以用额外的数据结构来保存这条链。事实上,Tomcat的FilterChain就用额外的数组来保存的。
    2. 责任链模式简化了很多if else逻辑,在需要扩展的时候,只需在链上加入新对象即可。

    相关文章

      网友评论

        本文标题:学好设计模式防被祭天:责任链模式

        本文链接:https://www.haomeiwen.com/subject/qqipjxtx.html