职责链模式： 使多个对象都有机会处理请求，从而避免请求的发送者和接收者之间的耦合关系，将这些对象连成一条链，并沿着这条链传递该请求，直到有一个对象处理它为止。
模式动机(Motivation)
- 在软件构建过程中，一个请求可能被多个对象处理，但是每个请求在运行时只能有一个接受者，如果显式指定，将必不可少地带来请求发送者与接受者的紧耦合。
- 如何使请求的发送者不需要指定具体的接受者?让请求的接受者自己在运行时决定来处理请求，从而使两者解耦。 模式定义使多个对象都有机会处理请求，从而避免请求的发送者和.接收者之间的耦合关系。将这些对象连成一条链，并沿着这条链传递请求，直到有一个对象处理它为止。
问题引入
公司员工的加薪申请需求的上报与审批：申请人提交给项目经理申请经费，项目经理如果权限够的话就审批，不够的话就提交到上级领导，依次类推，直到能够处理请求为止。
初始代码
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(); // 小菜请求加薪1000
request.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再说吧
问题抽象
- 客户端发出一个请求，会有很多对象都可以来处理这个请求，而且不同对象的处理逻辑是不一样的。
- 对于客户端而言，无所谓谁来处理，反正有对象处理就可以了。而且在上述处理中，还希望处理流程是可以灵活变动的，处理请求的对象霄要能方便地修改或者是被替换掉，以适应新的业务功能的需要。
这就是职责链模式
职责链模式结构图
- 抽象处理者（Handler）角色：定义一个处理请求的接口，包含抽象处理方法和一个后继连接。
- 具体处理者（Concrete Handler）角色：实现抽象处理者的处理方法，判断能否处理本次请求，如果可以处理请求则处理，否则将该请求转给它的后继者。
- 客户类（Client）角色：创建处理链，并向链头的具体处理者对象提交请求，它不关心处理细节和请求的传递过程。
职责链模式基本代码
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的下一个审批人为h22
h2.SetSuccessor(h3); // h2的下一个审批人为h3
int[] requests = { 2, 5, 14, 22, 18, 3, 27, 20 };
for (int i = 0; i < requests.length; i++) {
h1.HandleRequest(requests[i]);
}
}
}
优点：
- 职责链模式的最主要功能就是：动态组合，请求者和接受者解耦。
- 请求者和接受者松散耦合：请求者不需要知道接受者，也不需要知道如何处理。每个职责对象只负责自己的职责范围，其他的交给后继者。各个组件间完全解耦。
- 动态组合职责：职责链模式会把功能分散到单独的职责对象中，然后在使用时动态的组合形成链，从而可以灵活的分配职责对象，也可以灵活的添加改变对象职责。
缺点：
- 产生很多细粒度的对象：因为功能处理都分散到了单独的职责对象中，每个对象功能单一，要把整个流程处理完，需要很多的职责对象，会产生大量的细粒度职责对象。
- 不一定能处理：每个职责对象都只负责自己的部分，这样就可以出现某个请求，即使把整个链走完，都没有职责对象处理它。这就需要提供默认处理，并且注意构造链的有效性。
部分文字转载于http://www.cnblogs.com/xuwendong/
扫一扫
1389
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
