【设计模式】责任链模式

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