回复
设计模式-责任链模式
大家好我是佩奇
发布于 2022-8-5 17:42
浏览
0收藏
定义
责任链模式(Chain of Responsibility Pattern)：避免请求发送者与接收者耦合在一起，让多个对象都有可能接收请求，将这些对象连接成一条链，并且沿着这条链传递请求，直到有对象处理它为止。职责链模式是一种对象行为型模式。
用通俗的话就是推卸责任某件事，我们去解决，找到A，结果A踢皮球，说这不关我的事，去找B解决，然后我们就去找B，结果B也说，这跟我没关系，快去找C，就这样，我们就被踢来踢去，这就是责任链模式的思想。
角色
Handler（抽象处理者）：它定义了处理请求的接口、一般设计成抽象类，持有一个处理器的引用，如果自己无法处理请求，则转给下一个处理器。因此在抽象处理者中定义了一个抽象处理者类型的对象，作为其对下家的引用。通过该引用，处理者可以连成一条链。
ConcreteHandler（具体处理者）：它是抽象处理者的子类，可以处理用户请求，在具体处理者类中实现了抽象处理者中定义的抽象请求处理方法，在处理请求之前需要进行判断，看是否有相应的处理权限，如果可以处理请求就处理它，否则将请求转发给后继者；在具体处理者中可以访问链中下一个对象，以便请求的转发。
纯责任链模式
● 一个具体处理对象只能选择选择其中一个处理器：要么承担全部责任，要么把处理责任推给下家，不允许出现某个处理器处理了部分又继续向下传递。
● 一个请求必须被某一个处理者对象所接收，不能出现某个请求未被任何一个处理者对象处理的情况
不纯的责任链模式
● 允许某个请求被一个具体处理器处理后再向下传递
● 一个具体处理器处理完某请求后还可以继续处理该请求。
● 一个请求最终可以不被任何处理器所处理。
代码示例
纯责任链模式
现在模拟一个场景请求，当数字符合奇数、指定数字、某个下限等可处理，否则就处理失败。
首先我们定义抽象处理器，以及处理方法模板,定义了当前请求哪些可以处理，不能处理就转给next。
package com.zero.headfirst.chain.support;
import java.util.Objects;
/**
* 抽象处理器：定义了抽象请求处理方法，持有一个抽象处理器的引用，用于生成一条处理链
*/
publicabstractclass AbstractSupport {
private String name;
private AbstractSupport next;
/**
* 定义处理请求的算法模板
*/
public final void process(NumberData numberData) {
if (resolve(numberData)) {
done(numberData);
} elseif (Objects.nonNull(next)) {
next.process(numberData);
} else {
fail(numberData);
}
}
/**
* 无法处理
* @param numberData
*/
protected void fail(NumberData numberData) {
System.out.println(numberData + " cannot be resolved.");
}
/**
* 成功处理
* @param numberData
*/
protected void done(NumberData numberData) {
System.out.println(numberData + " is resolved by " + this + ".");
}
/**
* 判断是否能处理，子类重写
* @param numberData
* @return
*/
protected abstract boolean resolve(NumberData numberData);
public AbstractSupport setNext(AbstractSupport next) {
this.next = next;
return next;
}
public AbstractSupport(String name) {
this.name = name;
}
@Override
public String toString() {
return"AbstractSupport{" +
"name='" + name + '\'' +
'}';
}
}
然后定义我们的具体处理器，NoSupport 是一个永远不解决，只管推卸责任的类。
package com.zero.headfirst.chain.support;
/**
* 永远不解决,返回false
*/
publicclass NoSupport extends AbstractSupport {
public NoSupport(String name) {
super(name);
}
@Override
protected boolean resolve(NumberData numberData) {
returnfalse;
}
}LimitSupport 解决指定范围的请求
package com.zero.headfirst.chain.support;
/**
* 解决指定区间
*/
publicclass LimitSupport extends AbstractSupport {
private Integer limit;
public LimitSupport(String name, Integer limit) {
super(name);
this.limit = limit;
}
@Override
protected boolean resolve(NumberData numberData) {
return numberData.getNumber() < limit;
}
}
OddSupport 类,解决奇数的问题
package com.zero.headfirst.chain.support;
/**
* 奇数处理
*/
publicclass OddSupport extends AbstractSupport {
public OddSupport(String name) {
super(name);
}
@Override
protected boolean resolve(NumberData numberData) {
return numberData.getNumber() % 2 == 1;
}
}SpecialSupport 指定数字处理器
package com.zero.headfirst.chain.support;
/**
* 指定数字特殊处理
*/
publicclass SpecialSupport extends AbstractSupport {
private Integer number;
public SpecialSupport(String name, Integer number) {
super(name);
this.number = number;
}
@Override
protected boolean resolve(NumberData numberData) {
return numberData.getNumber().equals(number);
}
}
最后我们定义一个客户端去组装我们的责任链，将所有的处理器连在一起，并且模拟请求
package com.zero.headfirst.chain.support;
publicclass ChainTest {
public static void main(String[] args) {
AbstractSupport alice = new NoSupport("Alice");
AbstractSupport jams = new OddSupport("jams");
AbstractSupport bob = new LimitSupport("Bob", 100);
AbstractSupport charlie = new SpecialSupport("Charlie", 429);
//定义责任链
alice.setNext(jams).setNext(bob).setNext(charlie);
for (int i = 0; i < 500; i += 33) {
alice.process(new NumberData(i));
}
}
}我们的打印结果：除了我们定义处理器能处理的数字可以处理完成，其他数字无法处理。
NumberData{number=0} is resolved by AbstractSupport{name='Bob'}.
NumberData{number=33} is resolved by AbstractSupport{name='jams'}.
NumberData{number=66} is resolved by AbstractSupport{name='Bob'}.
NumberData{number=99} is resolved by AbstractSupport{name='jams'}.
NumberData{number=132} cannot be resolved.
NumberData{number=165} is resolved by AbstractSupport{name='jams'}.
NumberData{number=198} cannot be resolved.
NumberData{number=231} is resolved by AbstractSupport{name='jams'}.
NumberData{number=264} cannot be resolved.
NumberData{number=297} is resolved by AbstractSupport{name='jams'}.
NumberData{number=330} cannot be resolved.
NumberData{number=363} is resolved by AbstractSupport{name='jams'}.
NumberData{number=396} cannot be resolved.
NumberData{number=429} is resolved by AbstractSupport{name='jams'}.
NumberData{number=462} cannot be resolved.
NumberData{number=495} is resolved by AbstractSupport{name='jams'}.不纯的责任链模式
比如说公司请假需要审批，举个不恰当的例子，如果请假小于3天，主管审批；4-10天的， 经理审批；11-30天的，总经理审批；超过30天的，不批准等等。这就得一步步去判断， 如果撇开设计模式不看的话，那么我们可以使用if…else…把它解决了，但是问题可想而知， 实际中的复杂程度远远超过这个例子的。
现在我们用责任链设计模式解决，将每种角色连接起来处理请假数据流。
抽象处理器
package com.zero.design.actions.dutychain;
/**
* 责任链抽象类，包含核心处理方法，以及后继责任处理器设置.由不同的处理器继承
*/
publicabstractclass AbstractLeaderHandler {
protected String handlerName;
/**
* 责任链上的后继对象，即这个对象无法处理，就转移给下一个Leader
*/
protected AbstractLeaderHandler nextLeaderHandler;
public AbstractLeaderHandler(String handlerName) {
this.handlerName = handlerName;
}
/**
* 处理请求的核心的业务方法
* 需要不同继承该类的处理器自己实现
* @param request
*/
public abstract void handleRequest(LeaveRequest request);
/**
* 设定责任链上的后继对象
* @param nextLeaderHandler
*/
public AbstractLeaderHandler setNextLeaderHandler(AbstractLeaderHandler nextLeaderHandler) {
this.nextLeaderHandler = nextLeaderHandler;
return nextLeaderHandler;
}
}
具体处理器-主任处理器
负责处理 3 天以下的假期，大于三天的递交给主管
package com.zero.design.actions.dutychain;
/**
* 主任处理器，继承抽象处理器接口,处理相应业务或设置下一个处理器
*/
publicclass DirectorHandler extends AbstractLeaderHandler {
public DirectorHandler(String handlerName) {
super(handlerName);
}
@Override
public void handleRequest(LeaveRequest request) {
int days = request.getLeaveDays(); //获取请假天数
String name = request.getName(); //获取请假人姓名
String reason = request.getReason(); // 获取请假理由
if (days <= 3) {
//如果满足3天内的要求，主任直接审批
System.out.println("员工" + name + "请假" + days + "天，理由：" + reason);
System.out.println("主任" + this.handlerName + "审批通过");
} else {
System.out.println("请假天数过多，主任" + this.handlerName + "处理结束，还要交给经理处理");
if(this.nextLeaderHandler != null) {
//否则，如果链上存在下一个Leader，就让他处理
this.nextLeaderHandler.handleRequest(request);
}
}
}
}
经理处理器
处理小于10天的假期，大于10则递交给总办
package com.zero.design.actions.dutychain;
/**
* 经理处理器
*/
publicclass ManagerHandler extends AbstractLeaderHandler {
public ManagerHandler(String handlerName) {
super(handlerName);
}
@Override
public void handleRequest(LeaveRequest request) {
int days = request.getLeaveDays(); //获取请假天数
String name = request.getName(); //获取请假人姓名
String reason = request.getReason(); // 获取请假理由
if(days <= 10) { //如果满足10天内的要求，经理直接审批
System.out.println("员工" + name + "请假" + days + "天，理由：" + reason);
System.out.println("经理" + this.handlerName + "审批通过");
} else {
System.out.println("请假天数过多，经理" + this.handlerName + "处理结束，交给总办处理");
if(this.nextLeaderHandler != null) { //否则，如果链上存在下一个Leader，就让他处理
this.nextLeaderHandler.handleRequest(request);
}
}
}
}
总办处理器
处理大于 10 天假期的请求
package com.zero.design.actions.dutychain;
/**
* 总办处理器
*/
publicclass GeneralManagerHandler extends AbstractLeaderHandler {
public GeneralManagerHandler(String handlerName) {
super(handlerName);
}
@Override
public void handleRequest(LeaveRequest request) {
int days = request.getLeaveDays(); //获取请假天数
String name = request.getName(); //获取请假人姓名
String reason = request.getReason(); // 获取请假理由
if(days <= 30) { //如果满足10天内的要求，经理直接审批
System.out.println("员工" + name + "请假" + days + "天，理由：" + reason);
System.out.println("总办" + this.handlerName + "审批通过");
} else {
System.out.println("请假天数过多，总办" + this.handlerName + "没法处理");
if(this.nextLeaderHandler != null) { //否则，如果链上存在下一个Leader，就让他处理
this.nextLeaderHandler.handleRequest(request);
} else {
System.out.println("请假不成功");
}
}
}
}
客户端角色
声明一条处理链，模拟请假数据流
package com.zero.design.actions.dutychain;
/**
* 模拟请求：
* 他们处理请求的条件是不同的，而且只要不是自己处理范围之内的，就会将请求传给链上的下一位来处理
*/
publicclass Client {
public static void main(String[] args) {
//初始化责任链，应该使用单例
AbstractLeaderHandler directorHandler = new DirectorHandler("张胜男");
AbstractLeaderHandler managerHandler = new ManagerHandler("李四");
AbstractLeaderHandler generalManagerHndler = new GeneralManagerHandler("赵王");
//组织好责任对象关系
directorHandler.setNextLeaderHandler(managerHandler).setNextLeaderHandler(generalManagerHndler);
//开始请假操作
LeaveRequest request = new LeaveRequest("倪升武", 15, "在家睡觉");
directorHandler.handleRequest(request);
}
}
最后我们看打印结果
请假天数过多，主任张胜男处理结束，还要交给经理处理
请假天数过多，经理李四处理结束，交给总办处理
员工倪升武请假15天，理由：在家睡觉
总办赵王审批通过总结
责任链模式的优点
● 对象仅需知道该请求会被处理即可，且链中的对象不需要知道链的结构，由客户端负责链的创建，降低了系统的耦合度
● 请求处理对象仅需维持一个指向其后继者的引用，而不需要维持它对所有的候选处理者的引用，可简化对象的相互连接
● 在给对象分派职责时，职责链可以给我们更多的灵活性，可以在运行时对该链进行动态的增删改，改变处理一个请求的职责
● 新增一个新的具体请求处理者时无须修改原有代码，只需要在客户端重新建链即可，符合 "开闭原则"
缺点
● 一个请求可能因职责链没有被正确配置而得不到处理
● 对于比较长的职责链，请求的处理可能涉及到多个处理对象，系统性能将受到一定影响，且不方便调试
● 可能因为职责链创建不当，造成循环调用，导致系统陷入死循环
使用场景
- Netty 中的 Pipeline 和 ChannelHandler 通过责任链设计模式来组织代码逻辑
- Tomcat 过滤器中的责任链模式。
- Mybatis 中的 Plugin 机制使用了责任链模式，配置各种官方或者自定义的 Plugin，与 Filter 类似，可以在执行 Sql 语句的时候做一些操作
● 有多个对象可以处理同一个请求，具体哪个对象处理该请求待运行时刻再确定，客户端只需将请求提交到链上，而无须关心请求的处理对象是谁以及它是如何处理的
● 在不明确指定接收者的情况下，向多个对象中的一个提交一个请求
● 可动态指定一组对象处理请求，客户端可以动态创建职责链来处理请求，还可以改变链中处理者之间的先后次序
文章转载自公众号：码哥字节
已于2022-8-5 17:42:56修改
赞
收藏
回复
相关推荐
