责任链模式

责任链模式是一种对象的行为模式。在责任链模式里，很多对象由每一个对象对其下家的引用而连接起来形成一条链。

请求在这个链上传递，直到链上的某一个对象决定处理此请求。发出这个请求的客户端并不知道链上的哪一个对象最终处理这个请求，这使得系统可以在不影响客户端的情况下动态地重新组织和分配责任。

责任链模式的结构

下面使用了一个责任链模式的最简单的实现。



责任链模式涉及到的角色如下所示：

　　●抽象处理者(Handler)角色：定义出一个处理请求的接口。如果需要，接口可以定义 出一个方法以设定和返回对下家的引用。这个角色通常由一个Java抽象类或者Java接口实现。上图中Handler类的聚合关系给出了具体子类对下家的引用，抽象方法handleRequest()规范了子类处理请求的操作。

●具体处理者(ConcreteHandler)角色：具体处理者接到请求后，可以选择将请求处理掉，或者将请求传给下家。由于具体处理者持有对下家的引用，因此，如果需要，具体处理者可以访问下家。

具体例子：

抽象处理者角色类：

public abstract class Handler {
/**
* 持有后继的责任对象
*/
protected Handler successor;
/**
* 示意处理请求的方法，虽然这个示意方法是没有传入参数的
* 但实际是可以传入参数的，根据具体需要来选择是否传递参数
*/
public abstract void handleRequest();

/**
* get和set方法
*/
public Handler getSuccessor() {
return successor;
}
public void setSuccessor(Handler successor) {
this.successor = successor;
}
}具体处理者角色：
public class ConcreteHandler extends Handler {
/**
* 处理方法，调用此方法处理请求
*/
@Override
public void handleRequest() {
/**
* 判断是否有后继的责任对象
* 如果有，就转发请求给后继的责任对象
* 如果没有，则处理请求
*/
if(getSuccessor() != null)
{
System.out.println("放过请求");
getSuccessor().handleRequest();
}else
{
System.out.println("处理请求");
}

}
}
客户端：
public class Client {
public static void main(String[] args) {
//组装责任链
Handler handler1 = new ConcreteHandler();
Handler handler2 = new ConcreteHandler();
handler1.setSuccessor(handler2);
//提交请求
handler1.handleRequest();
}
}

可以看出，客户端创建了两个处理者对象，并指定第一个处理者对象的下家是第二个处理者对象，而第二个处理者对象没有下家。然后客户端将请求传递给第一个处理者对象。活动时序图：



在项目中的实际运用场景：

项目审核过程。项目需要指导教师,分俱乐部,学院管理员三级审核，只有通过了上一级的审核，才能进入下一级的审核，否则审核过程结束。

抽象审核角色类：

public abstract class Auditor {
/**
* 持有下一个处理请求的对象
*/
protected Auditor successor = null;
/**
* set,get方法
*/
public Auditor getSuccessor() {
return successor;
}
public void setSuccessor(Auditor successor) {
this.successor = successor;
}
/**
* 审核项目
* @param projectId 提交审核项目id
*/
public abstract void auditProjectRequest(String projectId);
}

具体审核角色对象：指导教师,分俱乐部,学院管理员。指导教师通过项目1,2,3，分俱乐部通过项目1，2，学院管理员通过项目1.

指导教师：

public class Teacher extends Auditor {

@Override
public void auditProjectRequest(String projectId) {
if(projectId.equals("1") || projectId.equals("2") || projectId.equals("3")){
System.out.println("指导教师审核通过");
/**
* 如果下一级不为空，则交给下一级审核
*/
if(getSuccessor() != null){
getSuccessor().auditProjectRequest(projectId);
}
}else{
System.out.println("指导教师审核不通过");
}
}

}
分俱乐部：
public class Club extends Auditor {

@Override
public void auditProjectRequest(String projectId) {
if(projectId.equals("1") || projectId.equals("2")){
System.out.println("分俱乐部审核通过");
/**
* 如果下一级不为空，则交给下一级审核
*/
if(getSuccessor() != null){
getSuccessor().auditProjectRequest(projectId);
}
}else{
System.out.println("分俱乐部审核不通过");
}
}

}
学院管理员：
public class Admin extends Auditor {
@Override
public void auditProjectRequest(String projectId) {
if(projectId.equals("1")){
System.out.println("学院管理员审核通过");
/**
* 如果下一级不为空，则交给下一级审核
*/
if(getSuccessor() != null){
getSuccessor().auditProjectRequest(projectId);
}
}else{
System.out.println("学院管理员审核不通过");
}
}
}

客户端：测试四个数据0,1,2,3

public class Client {
public static void main(String[] args) {
//先要组装责任链
Auditor a1 = new Teacher();
Auditor a2 = new Club();
Auditor a3 = new Admin();
a1.setSuccessor(a2);
a2.setSuccessor(a3);

//开始测试
System.out.println("项目0的审核记录：");
a1.auditProjectRequest("0");
System.out.println();

System.out.println("项目1的审核记录：");
a1.auditProjectRequest("1");
System.out.println();

System.out.println("项目2的审核记录：");
a1.auditProjectRequest("2");
System.out.println();

System.out.println("项目3的审核记录：");
a1.auditProjectRequest("3");
System.out.println();
}
}

运行结果：
项目0的审核记录：

指导教师审核不通过

项目1的审核记录：

指导教师审核通过

分俱乐部审核通过

学院管理员审核通过

项目2的审核记录：

指导教师审核通过

分俱乐部审核通过

学院管理员审核不通过

项目3的审核记录：

指导教师审核通过

分俱乐部审核不通过

采用责任链模式的好处：

1. 审核者之间松耦合，每一级审核者只需要知道下一级审核者就可以了，而无需知道上一级审核角色和审核结果。

2. 客户端可以重新组装责任链，因而审核者的审核顺序可以随意调换。

3. 可以在原有的责任链上任意位置随意新增审核角色，只需要修改客户端代码就可以了。