1 定义
又名职责链模式,为了避免请求发送者与多个请求处理者耦合在一起,将所有请求的处理者通过前一对象记住其下一个对象的引用而连成一条链;当有请求发生时,可将请求沿着这条链传递,直到有对象处理它为止。
2 结构
职责链模式主要包含以下角色:
- **抽象处理者(Handler)角色:**定义一个处理请求的接口,包含抽象处理方法和一个后继连接。
- **具体处理者(Concrete Handler)角色:**实现抽象处理者的处理方法,判断能否处理本次请求,如果可以处理请求则处理,否则将该请求转给它的后继者。
- **客户类(Client)角色:**创建处理链,并向链头的具体处理者对象提交请求,它不关心处理细节和请求的传递过程。
3 案例
现需要开发一个请假流程控制系统。请假一天以下的假只需要小组长同意即可;请假1天到3天的假还需要部门经理同意;请求3天到7天还需要总经理同意才行。
/**
* @ClassName: LeaveRequest
* @Description: 请假条类
* @Author: Sevenyear
*/
public class LeaveRequest {
//姓名
private String name;
//请假天数
private int num;
//请假内容
private String content;
public LeaveRequest(String name, int num, String content) {
this.name = name;
this.num = num;
this.content = content;
}
public String getName() {
return name;
}
public int getNum() {
return num;
}
public String getContent() {
return content;
}
}
/**
* @ClassName: Handler
* @Description: 抽象处理者类
* @Author: Sevenyear
*/
public abstract class Handler {
protected final static int NUM_ONE = 1;
protected final static int NUM_THREE = 3;
protected final static int NUM_SEVEN = 7;
//该领导处理的请求天数区间
private int numStart;
private int numEnd;
//声明后续者(声明上级领导)
private Handler nextHandler;
public Handler(int numStart) {
this.numStart = numStart;
}
public Handler(int numStart, int numEnd) {
this.numStart = numStart;
this.numEnd = numEnd;
}
//设置上级领导对象
public void setNextHandler(Handler nextHandler) {
this.nextHandler = nextHandler;
}
//各级领导处理请求条的方法
protected abstract void handleLeave(LeaveRequest leave);
//提交请求条
public final void submit(LeaveRequest leave) {
//该领导进行审批
this.handleLeave(leave);
if(this.nextHandler != null && leave.getNum() > this.numEnd) {
//提交给上级领导进行审批
this.nextHandler.submit(leave);
} else {
System.out.println("流程结束!");
}
}
}
/**
* @ClassName: GroupLeader
* @Description: 小组长类(具体的处理者)
* @Author: Sevenyear
*/
public class GroupLeader extends Handler {
public GroupLeader() {
super(0,Handler.NUM_ONE);
}
@Override
protected void handleLeave(LeaveRequest leave) {
System.out.println(leave.getName() + "请假" + leave.getNum() + "天," + leave.getContent() + "。");
System.out.println("小组长审批:同意");
}
}
/**
* @ClassName: GroupLeader
* @Description: 部门经理类(具体的处理者)
* @Author: Sevenyear
*/
public class Manager extends Handler {
public Manager() {
super(Handler.NUM_ONE,Handler.NUM_THREE);
}
protected void handleLeave(LeaveRequest leave) {
System.out.println(leave.getName() + "请假" + leave.getNum() + "天," + leave.getContent() + "。");
System.out.println("部门经理审批:同意");
}
}
/**
* @ClassName: GroupLeader
* @Description: 总经理类(具体的处理者)
* @Author: Sevenyear
*/
public class GeneralManager extends Handler {
public GeneralManager() {
super(Handler.NUM_THREE,Handler.NUM_SEVEN);
}
protected void handleLeave(LeaveRequest leave) {
System.out.println(leave.getName() + "请假" + leave.getNum() + "天," + leave.getContent() + "。");
System.out.println("总经理审批:同意");
}
}
public class Client {
public static void main(String[] args) {
//创建请假条对象
LeaveRequest leave1 = new LeaveRequest("小明",1,"身体不适");
LeaveRequest leave2 = new LeaveRequest("小红", 6, "家有喜事");
//创建各级领导对象
GroupLeader groupLeader = new GroupLeader();
Manager manager = new Manager();
GeneralManager generalManager = new GeneralManager();
//设置处理者链
groupLeader.setNextHandler(manager);
manager.setNextHandler(generalManager);
//小明提交请假申请
groupLeader.submit(leave1);
System.out.println("=================================");
//小红提交请假申请
groupLeader.submit(leave2);
}
}
4 优缺点
1,优点:
-
降低了对象之间的耦合度
该模式降低了请求发送者和接收者的耦合度。
-
增强了系统的可扩展性
可以根据需要增加新的请求处理类,满足开闭原则。
-
增强了给对象指派职责的灵活性
当工作流程发生变化,可以动态地改变链内的成员或者修改它们的次序,也可动态地新增或者删除责任。
-
责任链简化了对象之间的连接
一个对象只需保持一个指向其后继者的引用,不需保持其他所有处理者的引用,这避免了使用众多的 if 或者 if···else 语句。
-
责任分担
每个类只需要处理自己该处理的工作,不能处理的传递给下一个对象完成,明确各类的责任范围,符合类的单一职责原则。
2,缺点:
- 不能保证每个请求一定被处理。由于一个请求没有明确的接收者,所以不能保证它一定会被处理,该请求可能一直传到链的末端都得不到处理。
- 对比较长的职责链,请求的处理可能涉及多个处理对象,系统性能将受到一定影响。
- 职责链建立的合理性要靠客户端来保证,增加了客户端的复杂性,可能会由于职责链的错误设置而导致系统出错,如可能会造成循环调用。
5 源码解析
原文链接
https://blog.csdn.net/qq_42191980/article/details/115184634