职责链( Chain of Responsibility)模式

职责链模式动机(Motivation)
➢在软件构建过程中，一个请求可能被多个对象处理，但是每个请求在运行时只能有一个接受者，如果显式指定，将必不可少地带来请求发送者与接受者的紧耦合。
➢如何使请求的发送者不需要指定具体的接受者?让请求的接受者自己在运行时决定来处理请求，从而使两者解耦。
模式定义
使多个对象都有机会处理请求，从而避免请求的发送者和.接收者之间的耦合关系。将这些对象连成一条链，并沿着这条链传递请求，直到有一个对象处理它为止。

问题的引入一加薪申请、上报与审批

员工向经理发起加薪申请，经理无权决定，需要向总.监汇报，如果加薪额度超过总监权力范围，需耍向总经理汇报。
员工还可以提交请假申请，经理可以决定2天以下的假，总监可以决定5天以下的假，其余都耍上报总经理。
这些例子就是职责链。

加薪代码初步
无论加薪还是请假，都是一种申请。申请就应该有申请类别、申请内容和申请数量，

class Request {private String requestType;// 申请类别private String requestContent;// 申请内容private int number;// 数量public String getRequestType() {return requestType;}public void setRequestType(String requestType) {this.requestType = requestType;}public int getNumber() {return number;}public void setNumber(int number) {this.number = number;}public String getRequestContent() {return requestContent;}public void setRequestContent(String requestContent) {this.requestContent = requestContent;}
}//管理者
class Manager {protected String name;public Manager(String name) {this.name = name;}public void GetResult(String managerLevel, Request request) {System.out.println(request.getRequestType() + ":" + request.getNumber());if (managerLevel == "经理") {if (request.getRequestType() == "请假" && request.getNumber() <= 2) {System.out.println("数量<=2， 被批准");} else {System.out.println("数量>2，无权批准");}} else if (managerLevel == "总监") {if (request.getRequestType() == "请假" && request.getNumber() <= 5) {System.out.println("数量<=5， 被批准");} else {System.out.println("数量>5，无权批准");}} else if (managerLevel == "总经理") {if (request.getRequestType() == "请假") {System.out.println("请假， 被批准");} else if (request.getRequestType() == "加薪" && request.getNumber() <= 500) {System.out.println("加薪<=500，被批准");} else if (request.getRequestType() == "加薪" && request.getNumber() > 500) {System.out.println("加薪>500，无权批准");}}}
}public class Main {public static void main(String[] args) {Manager jinli = new Manager("金利");// 三个管理者Manager zongjian = new Manager("宗剑");Manager zhongjingli = new Manager("仲精励");Request request = new Request(); // 小菜请求加薪1000request.setRequestType("加薪");request.setRequestContent("小菜请求加蕲");request.setNumber(1000);jinli.GetResult("经理", request); // 不同的级别对比请求做判断和处理zongjian.GetResult("总监", request);zhongjingli.GetResult("总经理", request);System.out.println("======");Request request2 = new Request(); // 小菜请假3天request2.setRequestType("请假");request2.setRequestContent("小菜请假");request2.setNumber(3);jinli.GetResult("经理", request2);zongjian.GetResult("总监", request2);zhongjingli.GetResult("总经理", request2);}
}

加薪代码分析:

Manager类的GetResult方法比较长，且有太多的分支判断，这是非常不好的设计。因为可能还会增加其他的管理类别，比如项目经理、部门经理、人力总监、副总经理等等。那就意味等都需要去更改这个Manager类，这个类承担了太多的责任，违背了单一职责原则，增加新的管理类别，需要修改这个类，违背了开放-封闭原则。
如何重构?
可能会增加管理类别，那就意味着这里容易变化，应该把公司管理者的类别做成管理者的子类，就可以利用多态性来化解分支带来的僵化。
如何解决经理无权，则上报总些，总监无权，则上报总经理这样的功能呢?
它们之间有一定的关联，传递用户的请求，直到可以解决这个请求为止

重构加薪代码

class Request {private String requestType;// 申请类别private String requestContent;// 申请内容private int number;// 数量public String getRequestType() {return requestType;}public void setRequestType(String requestType) {this.requestType = requestType;}public int getNumber() {return number;}public void setNumber(int number) {this.number = number;}public String getRequestContent() {return requestContent;}public void setRequestContent(String requestContent) {this.requestContent = requestContent;}
}//管理者类
abstract class Manager {protected String name;
//管理者的，上级protected Manager superior;public Manager(String name) {this.name = name;}//设置管理者的上级public void SetSuperior(Manager superior) {this.superior = superior;}abstract public void RequestApplications(Request request);
}//"经理类"继承"管理者"类，需要重写"申请请求”
class CommonManager extends Manager {public CommonManager(String name) {super(name);}public void RequestApplications(Request request) {if (request.getRequestType() == "请假" && request.getNumber() <= 2) {System.out.println(name + ": " + request.getRequestContent() + "数量" + request.getNumber() + "被批准");} else { // 其余的申请都需转到上级if (superior != null) {superior.RequestApplications(request);}}}
}//"总监类"同样继承"管理者"类
class Majordomo extends Manager {public Majordomo(String name) {super(name);}public void RequestApplications(Request request) {if (request.getRequestType() == "请假" && request.getNumber() <= 5) {System.out.println((name) + ":" + request.getRequestContent() + "数量" + request.getNumber() + "被批准");} else { // 其余的申请都需转到上级if (superior != null) {superior.RequestApplications(request);}}}
}//"总经理类"同样继承"管理者"类，权限是全部处理
class GeneralManager extends Manager {public GeneralManager(String name) {super(name);}public void RequestApplications(Request request) { // 总经理的权限可批准下属任意天数的请假if (request.getRequestType() == "请假")System.out.println((name) + ":" + request.getRequestContent() + "数量" + request.getNumber() + "被批准");else if (request.getRequestType() == "加薪" && request.getNumber() <= 500)System.out.println(name + ":" + request.getRequestContent() + "数量" + request.getNumber() + "被批准");else {System.out.println(name + ": " + request.getRequestContent() + "数量" + request.getNumber() + "再说吧");}}
}public class Main {public static void main(String[] args) {CommonManager jinli = new CommonManager("金立");Majordomo zongjian = new Majordomo("宗剑");GeneralManager zhongjingli = new GeneralManager("钟精励");
//根据实际需求设置上级jinli.SetSuperior(zongjian);zongjian.SetSuperior(zhongjingli);
//客户端的申请都是由"经理"发起，但实际上谁来决策由具体的管理，客户端不知道。Request request = new Request();request.setRequestType("请假");request.setRequestContent("小菜请假");request.setNumber(1);jinli.RequestApplications(request);Request request2 = new Request();request2.setRequestType("请假");request2.setRequestContent("小菜请假");request2.setNumber(4);jinli.RequestApplications(request2);Request request3 = new Request();request3.setRequestType("加薪");request3.setRequestContent("小菜加薪");request3.setNumber(1000);jinli.RequestApplications(request3);}
}

输出结果：
金立: 小菜请假数量1被批准
宗剑:小菜请假数量4被批准
钟精励: 小菜加薪数量1000再说吧
问题抽象

客户端发出一个请求，会有很多对象都可以来处理这个请求，而且不同对象的处理逻辑是不一样的。
对于客户端而言，无所谓谁来处理，反正有对象处理就可以了。而且在上述处理中，还希望处理流程是可以灵活变动的，处理请求的对象霄要能方便地修改或者是被替换掉，以适应新的业务功能的需要。

职责链模式( Chain of Responsibillity )

职责链模式( Chain of Responsibility ) :使多个对象都有机会处理请求，从而避免请求的发送者和接收者之间的耦合关系。将这个对象连成一条链，并沿着这条链传递该请求，直到有一个对象处理它为止。
这里发出这个请求的客户端并不知道这当中的哪一个对象最终处理这个请求，这样系统的更改可以在不影响客户端.的情况下动态地重新组织和分配责任。

Handler类，定义一个处理请示的接口。
ConcreteHandler类，具体处理者类，处理它所负责的请求，可访问它的后继者，如果可处理该请求，就处理之，否这就将该请求转发给它的后继者。
ConcreteHandler1类:当请求数在0到10之间则有权处理,否则转到下一位。
ConcreteHandler2类:当请求数在10到20之间则有权处理,否则转到下一位。
ConcreteHandler3类:当请求数在20到30之间则有权处理,否则转到下一位。

abstract class Handler {protected String name;protected Handler successor; // 设置继任者public void SetSuccessor(Handler successor) {this.successor = successor;}public abstract void HandleRequest(int request);//处理请求的抽象方法public String getName() {return name;}public void setName(String name) {this.name = name;}
}//具体处理者类，处理它所负责的请求，可访问它的后继者，如果可处理请求就处理它，
//否则，将该请求转发给它的后继者。
class ConcreteHandler1 extends Handler {public void HandleRequest(int request) {if (request >= 0 && request < 10) {System.out.println(this.getName() + " 处理请求" + request);} else if (successor != null) // 转移到下一位去处理{successor.HandleRequest(request);}}
}class ConcreteHandler2 extends Handler {public void HandleRequest(int request) {if (request >= 10 && request < 20) {System.out.println(this.getName() + " 处理请求" + request);} else if (successor != null) // 转移到下一位去处理{successor.HandleRequest(request);}}
}class ConcreteHandler3 extends Handler {public void HandleRequest(int request) {if (request >= 20 && request < 30) {System.out.println(this.getName() + " 处理请求" + request);} else if (successor != null) // 转移到下一位去处理{successor.HandleRequest(request);}}
}public class Main {public static void main(String[] args) {Handler h1 = new ConcreteHandler1();h1.setName("审批人1");Handler h2 = new ConcreteHandler2();h2.setName("审批人2");Handler h3 = new ConcreteHandler3();h3.setName("审批人3");
//设置职责链上的关系h1.SetSuccessor(h2);// h1的下一个审批人为h22h2.SetSuccessor(h3); // h2的下一个审批人为h3int[] requests = { 2, 5, 14, 22, 18, 3, 27, 20 };for (int i = 0; i < requests.length; i++) {h1.HandleRequest(requests[i]);}}
}

处理过程
Chain of Responsibility模式中ConcreteHandler将自己的后继对象(向下传递消息的对象)记录在自己的后继表中，当一个请求到来时，ConcreteHandler会先检查看自己有没有匹配的处理方法，如昊有就自己处理，否则传递给它的后继。

责任链模式降低了请求的发送端和接收端之间的耦合，使多个对象都有机会处理这个请求。一个链可以是一条线，一个树，也可以是一个环。如下图所示，责任链是一个树结构的一部分。

优点:

请求者和接收者松散耦合
动态组合职责

缺点:

产生很多细粒度对象
不一定能被处理
- 需要提供默认处理

本质：
分离职责，动态组合

职责链( Chain of Responsibility)模式相关推荐

java使命召唤_Java设计模式之从[使命召唤等游戏的任务提示]分析职责链(Chain Of Responsibility)模式...
我们在使命召唤.暗黑破坏神等游戏时,总会接到各种各样的游戏任务,如到某某地方解救某人,或者消灭某某地方的敌人等.当玩家进入到某一个地图(以下称之为游戏场景)时,我们就可以查看它的任务提示.在这个机制下 ...
设计模式学习笔记——责任链(Chain of Responsibility)模式
设计模式学习笔记--责任链(Chain of Responsibility)模式 @(设计模式)[设计模式, 责任链模式, chain of responsibility] 设计模式学习笔记责任链Ch ...
推卸责任的 Chain of Responsibility模式
文章目录 Chain of Responsibility模式应用场景本质优点缺点角色 Chain of Responsibility模式的类图示例程序示例程序的类图示例代码拓展思路 ...
Chain of Responsibility 模式-----推卸责任模式
>> ----- 当外部请求程序进行某个处理,但程序暂时无法直接决定由哪个对象负责处理时,就需要推卸责任. 在这种情况下,我们可以考虑将多个对象组成一条职责链,然后按照它们的职责链上的顺序 ...
源码解析——FilterChain是职责链（过滤器）模式的典型应用
源码解析在javaWeb应用开发中,FilterChain是职责链(过滤器)模式的典型应用,以下是Filter的模拟实现分析: Request.java package com.itheima.pa ...
责任链模式（Chain of Responsibility模式）
在现实生活中,一个事件需要经过多个对象处理是很常见的场景.例如,采购审批流程.请假流程等.公司员工请假,可批假的领导有部门负责人.副总经理.总经理等,但每个领导能批准的天数不同,员工必须根据需要请假的 ...
行为模式之Chain of Responsibility模式
1.意图使多个对象都有机会处理请求,从而避免请求的发送者和接收者之间的耦合关系.将这些对象连成一条链,并沿着这条链传递该请求,直到有一个对象处理它为止. 2.适用性在以下条件下使用Responsi ...
Chain of Responsibility模式——读书笔记
继承如下抽象类的一系列类 abstract class Handler { protected Handler next; Handler(Handler next) { this.next = ne ...
设计模式之职责链模式(Chain of Responsibility)摘录
23种GOF设计模式一般分为三大类:创建型模式.结构型模式.行为模式. 创建型模式抽象了实例化过程,它们帮助一个系统独立于如何创建.组合和表示它的那些对象.一个类创建型模式使用继承改变被实例化的类,而 ...

职责链( Chain of Responsibility)模式

职责链( Chain of Responsibility)模式

职责链( Chain of Responsibility)模式相关推荐

最新文章

热门文章