故名思义责任链模式中存在一个链式结构,链式结构：多外节点首尾相连，每个节点都可以被拆分再连接。具体什么是责任链模式呢。它使多个对象都有机会处理请求，从而避免请求的发送者和接受者之间的耦合关系，将这个对象连成一条链，并沿着这个条链传递该请求，直到有一个对象处理它为止。将每一个节点看作是一个对象，每一个对象拥有不同的处理逻辑，将一个请求从链式的首段发出，沿着链的路径传递给每一个节点对象，直到有对象处理这个请求为止。
责任链模式看起来可能比较陌生，可是我们在日常开发却经常碰到这种形式。
public void handleSomething(int eventNum){
switch (eventNum){
case 1:
//do something
break;
case 2:
//do something
break;
case 3:
//do something
break;
default:
//do something
}
}
switch或者if-else这种就是责任链的裸体样式，是最简单的实现格式。当然这是个不恰当的例子，if-else嵌套太多，很可能你都看不懂你的代码。
举个粟子
下面给一个简单的例子：
这个例子很简单，一个抽象的Handler（处理者角色）和一个继承Handler的具体实现者ConcreteHandler。
类图
类图
代码
Handler类:
public abstract class Handler {
/**
* 持有下一个处理节点
*/
protected Handler successor;
/**
* 这个方法是具体的请求处理方法，在这里为了简化而没有传入参数
*/
public abstract void handleRequest();
/**
* 取出下一个节点的方法
*/
public Handler getSuccessor() {
return successor;
}
/**
* 赋值下一个节点的方法
*/
public void setSuccessor(Handler successor) {
this.successor = successor;
}
}
ConcreteHandler 类：
public class ConcreteHandler extends Handler {
@Override
public void handleRequest() {
/**
* 判断是否有下个节点的责任处理对象
* 如果有，就转发请求给下一个责任处理对象
* 如果没有，则处理请求
*/
if (getSuccessor() != null) {
System.out.println("放过请求");
getSuccessor().handleRequest();
} else {
System.out.println("处理请求");
}
}
}
Cilent类:
public class Client {
public static void main(String[] args) {
Handler handler1 = new ConcreteHandler();
Handler handler2 = new ConcreteHandler();
handler1.setSuccessor(handler2);
handler1.handleRequest();
}
}
Android/java 中应用责任链模式的场景
- 在android比较明显的就是事件分发过程中对事件的投递。严格说来，事件投递并不是严格的责任链模式，是责任链模式的变种实现。子 View 的 onTouchEvent 返回 true 代码消费该事件并不再传递，false 代表不消费并且传递到父 ViewGroup 去处理，这些树形结构的子 View 就是责任链上一个个处理对象；
- OrderedBroadcast，广播的每一个接收者按照优先级依次接受消息，如果处理完成之后可以调用 abortBroadcast 终止广播，不是自己处理的就可以传递给下一个处理者；
- try-catch语句，每一个 catch 根据 Exception 类型进行匹配，形成一个责任链，如果有一个 catch 语句与该 Exception 符合，这个 Exception 就交由给它进行处理，之后所有 catch 语句都不会再次执行。
再来看看具体的粟子
如果一个程序员一个月连续加班，这个月算下来可以调休5天。然后这个coder写了调休申请给项目经理，可项目经理有点方了，他只能审批调休一天的，然后项目经理把你的申请交给部门经理，部门经理一看也没法，公司规则多，他只能审批多超过三天的，只能让总经理过目了。
那看看具体代码。
//这个是leader的抽象类
public abstract class Leader {
private Leader successor;
private int hoildayNum;
private String position;
public void setPosition(String position) {
this.position = position;
}
public String getPosition() {
return position;
}
public Leader(int hoildayNum) {
this.hoildayNum = hoildayNum;
}
public abstract void reply(Worker worker);
public void handleRequest(Worker worker) {
if (worker.getHolidayNum() <= hoildayNum) {
reply(worker);
} else {
if (null != successor) {
successor.handleRequest(worker);
} else {
System.out.println(position + "拒绝了你的请求");
}
}
}
public void setSuccessor(Leader successor) {
this.successor = successor;
}
}
/**
* 项目经理处理类
*/
public class ProjectDirector extends Leader {
public ProjectDirector(int hoildayNum) {
super(hoildayNum);
setPosition("项目经理");
}
@Override
public void reply(Worker worker) {
System.out.println(getPosition() + "已通过你的请求");
}
}
/**
* 部门经理处理类
*/
public class DepartmentManager extends Leader {
public DepartmentManager(int hoildayNum) {
super(hoildayNum);
setPosition("部门经理");
}
@Override
public void reply(Worker worker) {
System.out.println(getPosition() + "已通过你的请求");
}}
/**
* 总经理处理类
*/
public class GeneralManager extends Leader {
public GeneralManager(int hoildayNum) {
super(hoildayNum);
setPosition("总经理");
}
@Override
public void reply(Worker worker) {
System.out.println(getPosition() + "已通过请求");
}
}
public class Cilent {
public static void main(String[] args) {
Worker worker = new Worker(6);
Leader projectDir = new ProjectDirector(1);
Leader departmentMan = new DepartmentManager(3);
Leader generalMan = new GeneralManager(10);
projectDir.setSuccessor(departmentMan);
departmentMan.setSuccessor(generalMan);
projectDir.handleRequest(worker);
}
}
这样我们就把请求者与处理者优雅的解耦。
纯与不纯的责任链模式
很多资料中会介绍纯和不纯的责任链模式，在标准的责任链模式中，责任链上的一个节点只允许有两个行为：处理或者推给下个节点处理，而不允许处理完之后又推给下个节点，前者被很多资料称为纯的责任链模式，而后者被称为不纯的责任链模式。其实在实际的系统里，纯的责任链很难找到。如果坚持责任链不纯便不是责任链模式，那么责任链模式便不会有太大意义了。
