职责链( Chain of Responsibility)模式

职责链( 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(); // 小菜请求加薪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再说吧
问题抽象

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

职责链模式( 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的下一个审批人为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]);
		}
	}
}

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

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

优点:

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

缺点:

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

本质:
分离职责,动态组合

  • 0
    点赞
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论

“相关推荐”对你有帮助么?

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

当前余额3.43前往充值 >
需支付:10.00
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、付费专栏及课程。

余额充值