简述
责任链模式:一个发送者发送请求,多个接收者链在一起接收请求,每个接收者持有下个接收者的引用。
例如:
多个接收者:接收者A持有接收者B的引用,接收着B持有接收者C的引用,A->B->C形成了一条责任链。
一个发送者:发送请求给接收者A,接收者A先判断能不能处理,A不能处理丢给B处理,B不能处理丢给C处理。
当A可以处理,请求就不再往后传递了。
为什么要这样设计
看以下代码:
public void recieve(String param) {
if(StringUtils.equals(param, "A")){
//处理A业务逻辑
}else if (StringUtils.equals(param, "B")){
//处理B业务逻辑
}else if (StringUtils.equals(param, "C")) {
//处理C业务逻辑
}
}
A,B,C的业务逻辑直接耦合在一起,并且发送者不需要关注recieve方法的具体的实现细节
用责任链模式则很好的解决这个问题,使得A,B,C业务分离,一个方法里代码的减少,代码也看起来清爽多了,增强可读性,并且对于发送者隐藏实现的细节
责任链模式实现例子
1.定义一个抽象类,A,B,C子类继承实现具体的业务逻辑,处理各自的业务逻辑前判断是否可以处理
2.A,B,C各自持有一个下一个业务处理环节的引用,A->B->C传递处理
代码
import org.apache.commons.lang3.StringUtils;
/**
*A,B,C的超类
*
/
public abstract class Super {
//标记是哪个环节
public String label;
//持有的下一个业务逻辑的引用
protected Super next;
/**
* 设置下一个环节的引用
* @param
*/
protected void setNext(Super next){
this.next = next;
}
/**
* 处理之前判断是否可以执行
* @param param
*/
protected void canHandler(String param){
if(StringUtils.equals(param, label)){
this.handler();
return;
}
if (null != next){
next.canHandler(param);
}
}
/**
* 业务逻辑
*/
public abstract void handler();
}
public class ChainDemo {
public static void main(String[] args) {
Super chain = getChain();
chain.canHandler("A");
chain.canHandler("B");
chain.canHandler("C");
}
/**
* 得到多个环节的一条业务链
* @return
*/
public static Super getChain() {
Super a = new A("A");
Super b = new B("B");
Super c = new C("C");
a.setNext(b);
b.setNext(c);
return a;
}
/**
* A业务环节
*/
static class A extends Super {
public A(String label){
this.label = label;
}
@Override
public void handler() {
//A的业务逻辑
System.out.println("A");
}
}
/**
* B业务环节
*/
static class B extends Super {
public B(String label){
this.label = label;
}
@Override
public void handler() {
//B的业务逻辑
System.out.println("B");
}
}
/**
* C业务环节
*/
static class C extends Super {
public C(String label){
this.label = label;
}
@Override
public void handler() {
//C的业务逻辑
System.out.println("C");
}
}
}