定义
又名职责链模式,简单来说就是将请求一级一级下发,直到请求被处理。
结构
抽象处理者(Handler):定义一个处理请求的接口,包含抽象处理方法和一个后继链接
具体处理者(Concrete Handler):实现抽象处理者的方法,判断能否处理本次请求,如果可以则处理,否则将请求转给它的后继者。
客户类(Client):创建处理链,并向链头的具体处理者对象提交请求,它不关心处理细节和请求的传递过程。
案例
需要一个请假流程控制系统。请假一天以内只需要小组长同意即可;请假1到3天还需要部门经理同意;请假3到7天还需要总经理同意
请假条
package com.hupp.responsibility;
/**
* 请假条
*/
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;
}
}
抽象处理者
package com.hupp.responsibility;
/**
* 抽象处理者
*/
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 handlerLeave(LeaveRequest leave);
//提交请假条
public final void submit(LeaveRequest leave){
this.handlerLeave(leave);
if(this.nextHandler!=null && leave.getNum()>this.numEnd){
//提交给上级领导审批
this.nextHandler.submit(leave);
}
else
{
System.out.println("处理完毕");
}
}
}
小组长
package com.hupp.responsibility;
/**
* 小组长
*/
public class GroupLeader extends Handler {
public GroupLeader() {
super(0, NUM_ONE);
}
@Override
protected void handlerLeave(LeaveRequest leave) {
System.out.println(leave.getName()+"请假"+leave.getNum()+"天,"+leave.getContent());
System.out.println("小组长:同意");
}
}
部门经理
package com.hupp.responsibility;
/**
* 部门经理
*/
public class Manager extends Handler{
public Manager() {
super(NUM_ONE, NUM_THREE);
}
@Override
protected void handlerLeave(LeaveRequest leave) {
System.out.println(leave.getName()+"请假"+leave.getNum()+"天,"+leave.getContent());
System.out.println("部门经理:同意");
}
}
总经理
package com.hupp.responsibility;
public class GeneralManager extends Handler {
public GeneralManager() {
super(NUM_THREE, NUM_SEVEN);
}
@Override
protected void handlerLeave(LeaveRequest leave) {
System.out.println(leave.getName()+"请假"+leave.getNum()+"天,"+leave.getContent());
System.out.println("总经理:同意");
}
}
客户端
package com.hupp.responsibility;
public class Client {
public static void main(String[] args) {
//创建请假条
LeaveRequest leave = new LeaveRequest("小明", 7, "结婚去了");
//创建各级领导对象
GroupLeader groupLeader = new GroupLeader();
Manager manager = new Manager();
GeneralManager generalManager = new GeneralManager();
//设置上级领导
groupLeader.setNextHandler(manager);
manager.setNextHandler(generalManager);
//提交请假条
groupLeader.submit(leave);
}
}
优缺点
- 优点
- 降低了系统的耦合度,降低请求发送者和接收者的耦合度
- 增强系统的可扩展性,满足开闭原则。
- 责任分组处理
- 缺点
- 不能保证每个请求一定被处理。请求可能传到最后一个接收者也没被处理。
- 对比较长的职责链,请求的处理可能涉及多个处理对象,系统性能可能会受一定的影响
- 增加了客户端的复杂性。可能会导致职责链的错误设置而导致系统出错,如可能会导致循环调用。