责任链模式是一种很常见的模式,我们平常开发中都会用到它,比如我们常用的Filter,就是一种责任链模式。
依旧举例说明,先来看如下一个例子:假如我们想买车,需要问老婆是否同意,你老婆要是做不了主,就要去问你的妈妈,同样你妈妈也做不了主呢,那么就要去问你的爸爸。这样形成的链路就是责任链,有权处理就直接处理,无权处理则交由下一级处理。下面来看类图:
接下来来看实现:
首先是我们的请求BuyCarRequest
,其中包含level,即处理级别,每个人家里谁做主都是不一样的,这个我们构造时给他赋值:
public enum HandlerLevelEnum {
LEVEL_WIFE, LEVEL_MOM, LEVEL_DAD;
}
public class BuyCarRequest {
/** 处理级别 */
private HandlerLevelEnum level;
/** 想买车的人名 */
private String name;
public BuyCarRequest(HandlerLevelEnum level, String name) {
this.level = level;
this.name = name;
}
/**
* 获取当前申请买车人家里谁做主
*/
public HandlerLevelEnum getLevel() {
return level;
}
/**
* 我要买车
*/
public void request() {
System.out.println(MessageFormat.format("{0}要买车车!!!", this.name));
}
public String getName() {
return name;
}
}
接下来是我们抽象的处理类BaseCarHandler
,负责分配责任:
public abstract class BaseCarHandler {
/** 当前可处理等级 由子类实现 */
protected HandlerLevelEnum level;
/** 当前不能处理时,下一个处理类 由子类实现 */
protected BaseCarHandler nextHandler;
/**
* 处理链
*/
public void handle(BuyCarRequest request) {
if (level.equals(request.getLevel())) {
response(request);
return;
}
if (nextHandler != null) {
nextHandler.handle(request);
}else {
System.out.println("未找到对应处理器,处理失败!!!");
}
}
/**
* 设置下一级责任人
*/
public void setNextHandler(BaseCarHandler handler) {
nextHandler = handler;
}
/**
* 具体处理应答类,由各个具体的处理器实现
*/
abstract void response(BuyCarRequest request );
}
接下来是各个具体的处理器,负责具体处理业务:
public class DadHandler extends BaseCarHandler {
public DadHandler() {
this.level = HandlerLevelEnum.LEVEL_DAD;
}
@Override
void response(BuyCarRequest request) {
System.out.println(MessageFormat.format("{0}的爸爸同意了买车请求!!!", request.getName()));
}
}
public class MomHandler extends BaseCarHandler {
public MomHandler() {
this.level = HandlerLevelEnum.LEVEL_MOM;
}
@Override
void response(BuyCarRequest request) {
System.out.println(MessageFormat.format("{0}的妈妈同意了买车请求!!!", request.getName()));
}
}
public class WifeHandler extends BaseCarHandler {
public WifeHandler() {
this.level = HandlerLevelEnum.LEVEL_WIFE;
}
@Override
void response(BuyCarRequest request) {
System.out.println(MessageFormat.format("{0}的妻子同意了买车请求!!!", request.getName()));
}
}
接下来调用接口测试:
@Test
public void test() {
BaseCarHandler handler = initHandler();
//老王要买车
BuyCarRequest request = new BuyCarRequest(HandlerLevelEnum.LEVEL_DAD, "老王");
request.request();
handler.handle(request);
//老李要买车
request = new BuyCarRequest(HandlerLevelEnum.LEVEL_MOM, "老李");
request.request();
handler.handle(request);
//老陈要买车
request = new BuyCarRequest(HandlerLevelEnum.LEVEL_WIFE, "老陈");
request.request();
handler.handle(request);
}
/**
* 初始化责任链
*/
private BaseCarHandler initHandler() {
BaseCarHandler wifeHandler = new WifeHandler();
BaseCarHandler momHandler = new MomHandler();
BaseCarHandler dadHandler = new DadHandler();
wifeHandler.setNextHandler(momHandler);
momHandler.setNextHandler(dadHandler);
return wifeHandler;
}
运行看结果:
老王要买车车!!!
老王的爸爸同意了买车请求!!!
老李要买车车!!!
老李的妈妈同意了买车请求!!!
老陈要买车车!!!
老陈的妻子同意了买车请求!!!
总结:
- 优点:请求者不知道具体是哪个handler处理的请求,业务无感知,利于扩展
- 缺点:每个请求都会遍历责任链,直至找到对应的handler,效率低下
欢迎关注个人博客:blog.scarlettbai.com