【设计模式】责任链模式

责任链模式是一种很常见的模式，我们平常开发中都会用到它，比如我们常用的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