1.介绍
在现实生活中，常常会出现这样的事例：一个请求有多个对象可以处理，但每个对象的处理条件或权限不同。例如，公司员工请假，可批假的领导有部门负责人、副总经理、总经理等，但每个领导能批准的天数不同，员工必须根据自己要请假的天数去找不同的领导签名，也就是说员工必须记住每个领导的姓名、电话和地址等信息，这增加了难度。这样的例子还有很多，如找领导出差报销、生活中的“击鼓传花”游戏等。
定义
又名职责链模式，为了避免请求发送者与多个请求处理者耦合在一起，将所有请求的处理者通过前一对象记住其下一个对象的引用而连成一条链；当有请求发生时，可将请求沿着这条链传递，直到有对象处理它为止。
2.结构
职责链模式主要包含以下角色:
- 抽象处理者（Handler）角色：定义一个处理请求的接口，包含抽象处理方法和一个后继连接。
- 具体处理者（Concrete Handler）角色：实现抽象处理者的处理方法，判断能否处理本次请求，如果可以处理请求则处理，否则将该请求转给它的后继者。
- 客户类（Client）角色：创建处理链，并向链头的具体处理者对象提交请求，它不关心处理细节和请求的传递过程。
3.案例一
现需要开发一个请假流程控制系统。请假一天以下的假只需要小组长同意即可；请假1天到3天的假还需要部门经理同意；请求3天到7天还需要总经理同意才行。
类图如下：
代码实现
请假条类
/**
* 请假条类
* @author CharlieLiang
*
*/
public class LeaveRequest {
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public int getNum() {
return num;
}
public void setNum(int num) {
this.num = num;
}
public String getContent() {
return content;
}
public void setContent(String content) {
this.content = content;
}
public LeaveRequest() {
super();
}
public LeaveRequest(String name, int num, String content) {
super();
this.name = name;
this.num = num;
this.content = content;
}
//姓名
private String name;
//请假天数
private int num;
//请假内容
private String content;
}抽象处理者
/**
* 抽象处理者类
* @author CharlieLiang
*
*/
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) {
super();
this.numStart = numStart;
}
public Handler(int numStart, int numEnd) {
super();
this.numStart = numStart;
this.numEnd = numEnd;
}
public Handler getNextHandler() {
return nextHandler;
}
//设置上层领导
public void setNextHandler(Handler nextHandler) {
this.nextHandler = nextHandler;
}
//各级领导处理请求的方法
protected abstract void handleLeave(LeaveRequest leave) ;
//提交请假条
public final void submit(LeaveRequest leave) {
//如果请假天数达到该领导者的要求
if(leave.getNum()>=this.numStart) {
this.handleLeave(leave);
//如果还有上级，并且请假天数超过了当前领导的处理范围
if(null!=this.nextHandler && leave.getNum()>numEnd) {
this.nextHandler.submit(leave); //继续提交
}else {
System.out.println("流程结束");
}
}
}
}具体处理者：小组长
/**
* 具体处理者：小组长
* @author CharlieLiang
*
*/
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("小组长审批同意");
}
}具体处理者：部门经理类
/**
* 具体处理者：部门经理类
* @author CharlieLiang
*
*/
public class Manager extends Handler{
public Manager() {
super(0,Handler.NUM_THREE);
}
@Override
protected void handleLeave(LeaveRequest leave) {
System.out.println(leave.getName()+"请假"+leave.getNum()+"天，"
+leave.getContent()+". ");
System.out.println("部门经理审批同意");
}
}具体处理者：总经理类
/**
* 具体处理者：总经理类
* @author CharlieLiang
*
*/
public class GeneralManager extends Handler{
public GeneralManager() {
super(0,Handler.NUM_SEVEN);
}
@Override
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 lr1=new LeaveRequest("小明",1,"身体不适");
LeaveRequest lr2=new LeaveRequest("小红",3,"身体不适");
LeaveRequest lr3=new LeaveRequest("张三",7,"身体不适");
//创建各级领导对象
GroupLeader groupLeader=new GroupLeader();
Manager manager=new Manager();
GeneralManager generalManager=new GeneralManager();
//设置处理链
groupLeader.setNextHandler(manager);
manager.setNextHandler(generalManager);
//小明提交请假条
groupLeader.submit(lr1);
System.out.println("-----------------");
groupLeader.submit(lr2);
System.out.println("-----------------");
groupLeader.submit(lr3);
}
}运行结果
4.优缺点
(1) 优点
- 降低了对象之间的耦合度
该模式降低了请求发送者和接收者的耦合度。 - 增强了系统的可扩展性
可以根据需要增加新的请求处理类，满足开闭原则。 - 增强了给对象指派职责的灵活性
当工作流程发生变化，可以动态地改变链内的成员或者修改它们的次序，也可动态地新增或者删除责任。 - 责任链简化了对象之间的连接
一个对象只需保持一个指向其后继者的引用，不需保持其他所有处理者的引用，这避免了使用众多的 if 或者 if···else 语句。 - 责任分担
每个类只需要处理自己该处理的工作，不能处理的传递给下一个对象完成，明确各类的责任范围，符合类的单一职责原则。
(2) 缺点
- 不能保证每个请求一定被处理。由于一个请求没有明确的接收者，所以不能保证它一定会被处理，该请求可能一直传到链的末端都得不到处理。
- 对比较长的职责链，请求的处理可能涉及多个处理对象，系统性能将受到一定影响。
- 职责链建立的合理性要靠客户端来保证，增加了客户端的复杂性，可能会由于职责链的错误设置而导致系统出错，如可能会造成循环调用。
5. 案例二
案例出处：
类图表示:
代码实现
//抽象处理者角色
abstract class Handler {
private Handler next;
public void setNext(Handler next) {
this.next = next;
}
public Handler getNext() {
return next;
}
//处理请求的方法
public abstract void handleRequest(String request);
}//具体处理者角色1
class ConcreteHandler1 extends Handler {
public void handleRequest(String request) {
if (request.equals("one")) {
System.out.println("具体处理者1负责处理该请求！");
} else {
if (getNext() != null) {
getNext().handleRequest(request);
} else {
System.out.println("没有人处理该请求！");
}
}
}
}//具体处理者角色2
class ConcreteHandler2 extends Handler {
public void handleRequest(String request) {
if (request.equals("two")) {
System.out.println("具体处理者2负责处理该请求！");
} else {
if (getNext() != null) {
getNext().handleRequest(request);
} else {
System.out.println("没有人处理该请求！");
}
}
}
}运算结果：
6.源码解析
在javaWeb应用开发中，FilterChain是职责链（过滤器）模式的典型应用，以下是Filter的模拟 实现分析:
模拟web请求Request以及web响应Response
public interface Request {
}
public interface Response {
}模拟web过滤器Filter
public interface Filter {
public void doFilter(Request req,Response res,FilterChain c);
}模拟实现具体过滤器
public class FirstFilter implements Filter {
@Override
public void doFilter(Request request, Response response, FilterChain chain) {
System.out.println("过滤器1 前置处理");
// 先执行所有request再倒序执行所有response
chain.doFilter(request, response);
System.out.println("过滤器1 后置处理");
}
}public class SecondFilter implements Filter {
@Override
public void doFilter(Request request, Response response, FilterChain chain) {
System.out.println("过滤器2 前置处理");
// 先执行所有request再倒序执行所有response
chain.doFilter(request, response);
System.out.println("过滤器2 后置处理");
}
}模拟实现过滤器链FilterChain
import java.util.ArrayList;
import java.util.List;
public class FilterChain {
private List<Filter> filters = new ArrayList<Filter>();
private int index = 0;
// 链式调用
public FilterChain addFilter(Filter filter) {
this.filters.add(filter);
return this;
}
public void doFilter(Request request, Response response) {
if (index == filters.size()) {
return;
}
Filter filter = filters.get(index);
index++;
filter.doFilter(request, response, this);
}
}客户端
public class Client {
public static void main(String[] args) {
Request req = null;
Response res = null;
FilterChain filterChain = new FilterChain();
filterChain.addFilter(new FirstFilter()).addFilter(new SecondFilter());
filterChain.doFilter(req, res);
}
}运行结果：
本文章为转载内容，我们尊重原作者对文章享有的著作权。如有内容错误或侵权问题，欢迎原作者联系我们进行内容更正或删除文章。
