• 极客专栏正式上线!欢迎访问 https://www.jikewenku.com/topic.html
  • 极客专栏正式上线!欢迎访问 https://www.jikewenku.com/topic.html

设计模式是什么鬼(责任链)

技术杂谈 勤劳的小蚂蚁 3个月前 (01-29) 80次浏览 已收录 0个评论 扫描二维码

曾经有这么一些零散的功能节点,他们各自承担各自的义务,分工明确,各司其职。为了更高效,更完整地解决客户的问题,他们发扬团队精神,互相串联起来形成一个有序的责任传递链表,于是责任链模式诞生了。当然,它的结构也不一定非得是链表,甚至可以是树型分叉结构,这要根据业务场景看怎样去灵活运用,但其核心意义是为了处理某种连续的流程,并确保业务一定能走到相应的责任节点上并得到相应的处理。


说到这里想必大家已经想到了工作流吧?对,企事业单位中通常为了完成某项日常任务,通常要制定一些工作流程,按步骤拆分,并组织好各个环节中的逻辑关系及走向,这样才能更高效、更规范地完成任务。


根据以上流程图,我们来做一个最简单的例子。假设某公司针对出差报销业务制定审批流程,有三个审批角色分别是员工(1000元权限)、经理(5000元权限)、以及CEO(10000元权限),各审批人代码如下。

1public class Staff {
2
3    private String name;
4
5    public Staff(String name{
6        this.name = name;
7    }
8
9    public boolean approve(int amount{
10        if (amount <= 1000) {
11            System.out.println(“审批通过。【员工:” + name + “】”);
12            return true;
13        } else {
14            System.out.println(“无权审批,请找上级。【员工:” + name + “】”);
15            return false;
16        }
17    }
18
19}
1public class Manager {
2
3    private String name;
4
5    public Manager(String name{
6        this.name = name;
7    }
8
9    public boolean approve(int amount{
10        if (amount <= 5000) {
11            System.out.println(“审批通过。【经理:” + name + “】”);
12            return true;
13        } else {
14            System.out.println(“无权审批,请找上级。【经理:” + name + “】”);
15            return false;
16        }
17    }
18
19}
1public class CEO {
2
3    private String name;
4
5    public CEO(String name{
6        this.name = name;
7    }
8
9    public boolean approve(int amount{
10        if (amount <= 10000) {
11            System.out.println(“审批通过。【CEO:” + name + “】”);
12            return true;
13        } else {
14            System.out.println(“驳回申请。【CEO:” + name + “】”);
15            return false;
16        }
17    }
18
19}

好了,审批人们定义完毕,逻辑非常简单缜密,如果超过审批金额最大权限则打回去,开始写申请人客户端类。

1public class Client {
2    public static void main(String[] args) {
3        int amount = 10000;//出差花费10000元
4        // 先找员工张飞审批
5        Staff staff = new Staff(“张飞”);
6        if (!staff.approve(amount)) {
7            //被拒,找关二爷问问。
8            Manager manager = new Manager(“关羽”);
9            if (!manager.approve(amount)) {
10                //还是被拒,只能找老大了。
11                CEO ceo = new CEO(“刘备”);
12                ceo.approve(amount);
13            }
14        }
15        /***********************
16        无权审批,请找上级。【员工:张飞】
17        无权审批,请找上级。【经理:关羽】
18        审批通过。【CEO:刘备】
19        ***********************/
20    }
21}

功夫不负有心人,跑了三个地方找了三个人,一万元的大额报销单终于被大老板审批了。然而,大家有没有发现问题?我们走的审批流程好像有点过于复杂了,找这个不行那个不同意,跑来跑去的好像自己有点像是被踢皮球的感觉。此外,如果我们后期要优化完善此工作流程,或是添加新的审批角色进来,那就得不停地修改此处的逻辑,最终的修改结果会是?


乱了,全乱套了,我们终将被淹没在一堆复杂的审批流程中,跑断腿也找不到门路。这显然是违反设计模式原则的,我们必须进行重构。我们观察此类中的审批逻辑,这显然就是一个链式结构,审批人之间环环相扣,对于自己无法处理的申请,会像被踢皮球似的传给上级,直到某人解决此申请,对员工张飞来说,他只知道自己传球给关羽了,仅此而已。

进一步分析,审批人肯定是不同的角色,并且每个角色的审批逻辑会有区别,所以我们得把这些角色的审批逻辑分开来写,对每个角色的责任范围我们进行定义,我只懂自己怎么审批(责任),我处理不了的我递交给上层(链条),开始重构,先抽象出一个审批人类。

1public abstract class Approver {// 审批人抽象类
2
3    protected String name;// 抽象出审批人的姓名。
4    protected Approver nextApprover;// 下一个审批人,更高级别领导。
5
6    public Approver(String name{
7        this.name = name;
8    }
9
10    protected Approver setNextApprover(Approver nextApprover{
11        this.nextApprover = nextApprover;
12        return this.nextApprover;// 返回下个审批人,链式编程。
13    }
14
15    public abstract void approve(int amount);// 抽象审批方法由具体审批人子类实现
16}

注意第4行,审批人只认识自己的领导,所以会持有下一级领导的引用,同时第10行的代码用于把领导注入进来。第15行是我们的审批方法了,但每个角色审批逻辑会有区别,所以这里进行抽象,并由具体的审批角色子类去实现,先从员工看起。

1public class Staff extends Approver {
2
3    public Staff(String name) {
4        super(name);
5    }
6
7    @Override
8    public void approve(int amount) {
9        if (amount <= 1000) {
10            System.out.println(“审批通过。【员工:” + name + “】”);
11        } else {
12            System.out.println(“无权审批,升级处理。【员工:” + name + “】”);
13            this.nextApprover.approve(amount);
14        }
15    }
16
17}

很简单,员工类继承了审批角色类,第9行申明审批权限为1000元,重点在于第13行这里调用了自己上级领导的审批方法,显然这里是自己处理不了的申请单了。大同小异,再重构经理及CEO审批角色类。

1public class Manager extends Approver {
2
3    public Manager(String name) {
4        super(name);
5    }
6
7    @Override
8    public void approve(int amount) {
9        if (amount <= 5000) {
10            System.out.println(“审批通过。【经理:” + name + “】”);
11        } else {
12            System.out.println(“无权审批,升级处理。【经理:” + name + “】”);
13            this.nextApprover.approve(amount);
14        }
15    }
16
17}
1public class CEO extends Approver {
2
3    public CEO(String name) {
4        super(name);
5    }
6
7    @Override
8    public void approve(int amount) {
9        if (amount <= 10000) {
10            System.out.println(“审批通过。【CEO:” + name + “】”);
11        } else {
12            System.out.println(“驳回申请。【CEO:” + name + “】”);
13        }
14    }
15
16}

CEO类作为链条的尾巴,也就是最高级别,第12行的越权逻辑会最终拒绝申请单。很简单吧?我们生成一下这个链条,并从员工开始传递申请单。

1public class Client {
2    public static void main(String[] args) {
3        Approver flightJohn = new Staff(“张飞”);
4        flightJohn.setNextApprover(new Manager(“关羽”)).setNextApprover(new CEO(“刘备”));
5
6        //高层接触不到也没必要接触,直接找员工张飞审批。
7        flightJohn.approve(1000);
8        /***********************
9        审批通过。【员工:张飞】
10        ***********************/
11
12        flightJohn.approve(4000);
13        /***********************
14        无权审批,升级处理。【员工:张飞】
15        审批通过。【经理:关羽】
16        ***********************/
17
18        flightJohn.approve(9000);
19        /***********************
20        无权审批,升级处理。【员工:张飞】
21        无权审批,升级处理。【经理:关羽】
22        审批通过。【CEO:刘备】
23        ***********************/
24
25        flightJohn.approve(88000);
26        /***********************
27        无权审批,升级处理。【员工:张飞】
28        无权审批,升级处理。【经理:关羽】
29        驳回申请。【CEO:刘备】
30        ***********************/
31    }
32}

这里注意第4行的代码对责任链进行构造(其实这里我们还可以交由工作流工厂去构造完成,读者可以自己实践练习),从员工开始一直到CEO结束。之后的业务就非常简单了,直接递单给员工张飞,审批流程便魔法般地启动了,审批单在这个责任链条上层层递交,最终给出结果。

至此,申请人与审批人实现了解耦,我们只需递单送给责任链即可,申请人不必再关心每个处理细节,只需交给接口人张飞处理就妥了。使用了责任链模式后的代码看起来非常简洁,各个角色的责任划分非常明确并且被分开定义到了每个角色类中,再把他们串起来去调用,一气呵成。后期如果再继续添加新的角色只需要添加新角色类并加入链条即可,链条的随意伸缩,灵活的可伸缩性,完美的扩展性。挂上这条钛合金项链,维护世界和平的责任就交给你了!


在实际应用中,我们切勿生搬硬套,还需根据实际需求场景进行灵活运用,就拿工业现代化生产线举例,这个其实也类似责任链模式,但不同之处在于其组装工作是必须经过每个组装节点处理的,从头到尾的全链处理而不能中途退出,读者朋友可以自己写代码练习,实践与思考要相结合并循环往复,二者都非常重要。

丨极客文库, 版权所有丨如未注明 , 均为原创丨
本网站采用知识共享署名-非商业性使用-相同方式共享 3.0 中国大陆许可协议进行授权
转载请注明原文链接:设计模式是什么鬼(责任链)
喜欢 (0)
[247507792@qq.com]
分享 (0)
勤劳的小蚂蚁
关于作者:
温馨提示:本文来源于网络,转载文章皆标明了出处,如果您发现侵权文章,请及时向站长反馈删除。

您必须 登录 才能发表评论!

  • 精品技术教程
  • 编程资源分享
  • 问答交流社区
  • 极客文库知识库

客服QQ


QQ:2248886839


工作时间:09:00-23:00