Starter

有时我们的业务需要大量的if else if。看着是不是很难受。下面我们来优化它

• 我们先定义一个接口

public interface ChainHandler {
    public void doHandler();//具体需要的执行的方法
    public void setNextHandler(AbstractChainHandler nextHandler);
    public AbstractChainHandler getNextHandler();
}

• ChainHandler接口的实现

public abstract class AbstractChainHandler implements ChainHandler{
    private AbstractChainHandler nextHandler;//当前结点的下一个需要执行的结点
    public AbstractChainHandler(){};

    public AbstractChainHandler(AbstractChainHandler nextHandler) {
        this.nextHandler = nextHandler;
    }

    public abstract boolean preHandler();//模版方法模式，具体的留给子类实现

    @Override
    public void doHandler(){//定义通用的规则，这里主要参考AQS的代码
        if (preHandler() && nextHandler != null) {
            nextHandler.doHandler();
        }
    }

    @Override
    public AbstractChainHandler getNextHandler() {
        return nextHandler;
    }

    @Override
    public void setNextHandler(AbstractChainHandler nextHandler) {
        this.nextHandler = nextHandler;
    }
}

• 接下来我们定义三个具体的类，也就是if else 中需要真正执行方法的类

public class InterceptorA extends AbstractChainHandler {
    @Override
    public boolean preHandler() {
        System.out.println("InterceptorA is invoked");
        return true;
    }
}

public class InterceptorB extends AbstractChainHandler {
    @Override
    public boolean preHandler() {
        System.out.println("InterceptorB is invoked");
        return true;
    }
}

public class InterceptorC extends AbstractChainHandler {
    @Override
    public boolean preHandler() {
        System.out.println("InterceptorC is invoked");
        return true;
    }
}

是不是特别像我们的拦截器。接下来看他们如何组合在一起形成一个链。

• 责任链的组装

public class HandlerContext {
    private List<ChainHandler> chainHandlers;
    private ChainHandler front;//维护了当前加入结点的前驱结点
    private ChainHandler head;//维护了责任链的头结点
    public HandlerContext(){
        chainHandlers = new ArrayList<>();
    }
    //这里将具体需要执行的加入
    public void register(ChainHandler chainHandler) {
        if (front != null) {
            front.setNextHandler((AbstractChainHandler) chainHandler);
        }else {
            head = chainHandler;
        }
        front = chainHandler;
        chainHandlers.add(chainHandler);
    }
    
    public void doHandler() {
        head.doHandler();
    }

}

• 测试

public class InterceptorTest {
    public static void main(String[] args) {
        InterceptorA interceptorA = new InterceptorA();
        InterceptorB interceptorB = new InterceptorB();
        InterceptorC interceptorC = new InterceptorC();
        
        HandlerContext handlerContext = new HandlerContext();
        
        //这里执行的顺序和注册的顺序一致
        handlerContext.register(interceptorA);
        handlerContext.register(interceptorB);
        handlerContext.register(interceptorC);
        //执行责任链
        handlerContext.doHandler();
    }
}

具体输出
InterceptorA is invoked
InterceptorB is invoked
InterceptorC is invoked