模式小故事
相信大家出差的都有过报销的经历吧！
小明负责一个异地的项目，去出差花费五万元，回来报销需要审批。
组长审批最大：500 元
主管审批最大：1000元
经理审批最大：5000元
老板审批最大：xxxx元
由于花费太高，所以要一层一层的向上报请求，就像链条一样，环环相扣，有首有尾，所以这就是责任链模式基本场景。
模式小案例UML：
模式小案例实现：
//领导
public abstract class Leader {
Leader nextHandler;// 上级领导
// 处理报账
public final void handlerReq(int money) {
if (money <= limit()) {
handler(money);
} else if (nextHandler != null) {
nextHandler.handlerReq(money);
} else {
System.out.println("无法报销");
}
}
abstract void handler(int money) ;
abstract int limit();
}
//组长
public class GroupLeader extends Leader {
@Override
int limit() {
return 500;
}
@Override
void handler(int money) {
System.out.println("组长报销了： " + money + " 元");
}
}
//主管
public class Director extends Leader {
@Override
int limit() {
return 1000;
}
@Override
void handler(int money) {
System.out.println("主管报销了： " + money + " 元");
}
}
//经理
public class Manager extends Leader {
@Override
int limit() {
return 5000;
}
@Override
void handler(int money) {
System.out.println("经理报销了： " + money + " 元");
}
}
//老板
public class Boss extends Leader {
@Override
int limit() {
return Integer.MAX_VALUE;
}
@Override
void handler(int money) {
System.out.println("老板报销了： " + money + " 元");
}
}
//小明报销：
public class Client {
public static void main(String[] args) {
GroupLeader groupLeader = new GroupLeader();
Director director = new Director();
Manager manager = new Manager();
Boss boss = new Boss();
groupLeader.nextHandler = director;
director.nextHandler = manager;
manager.nextHandler = boss;
groupLeader.handlerReq(Integer.MAX_VALUE);
}
}
模式最精简案例UML
模式最精简案例
public abstract class Handler {
Handler successor;// 下一个节点处理者
public abstract void handler(String req);
}
public class ConcreteAHandler extends Handler {
@Override
public void handler(String req) {
if (req.equals("req1")) {
System.out.println("命令：req1 执行完成");
return;
} else {
this.successor.handler(req);
}
}
}
public class ConcreteBHandler extends Handler {
@Override
public void handler(String req) {
if (req.equals("req2")) {
System.out.println("命令：req2 执行完成");
return;
} else {
if (this.successor == null) {
System.out.println("无法处理请求！");
return;
}
this.successor.handler(req);
}
}
}
public class Client {
public static void main(String[] args) {
// 构造节点
ConcreteAHandler aReq = new ConcreteAHandler();
ConcreteBHandler bReq = new ConcreteBHandler();
// 设置节点
aReq.successor = bReq;
// 处理请求;
aReq.handler("req1");
}
}
模式优缺点
优点：
1、降低耦合度。它将请求的发送者和接收者解耦。
2、简化了对象。使得对象不需要知道链的结构。
3、增强给对象指派职责的灵活性。通过改变链内的成员或者调动它们的次序，允许动态地新增或者删除责任。
4、增加新的请求处理类很方便。
缺点：
1、不能保证请求一定被接收。
2、系统性能将受到一定影响，而且在进行代码调试时不太方便，可能会造成循环调用。
3、可能不容易观察运行时的特征，有碍于除错。
