设计模式-责任链模式

一、简单责任链模式实现

图示：

 接口：

public interface Handler {
    Object handle(Object param);
    void addNext(Handler processor);
    Handler next();
}

实现类：

public class FirstHandler implements Handler {
    private Handler next=null;
    @Override
    public Object handle(Object param) {
        System.out.println(this.getClass().getName() + param);
        return param;
    }
    @Override
    public void addNext(Handler handler) {
        this.next = handler;
    }
    @Override
    public Handler next() {
        return next;
    }
}

使用方式：

Handler firstHandler = new FirstHandler();
Handler secondHandler = new SecondHandler();
Handler thirdHandler = new ThirdHandler();
firstHandler.addNext(secondHandler);
secondHandler.addNext(thirdHandler);

Handler tmpHandler=firstHandler;
while(tmpHandler!=null){
    tmpHandler.handle("");
    tmpHandler=tmpHandler.next();
}

优缺点：

实现了链式调用，严格保证了调用顺序和安全性，但无法进行链中断。

二、迭代器形式的责任链

类结构图示：

实现类（主要展示HandlerChain，其他类和接口比较简单自行实现）：

private List<Handler> handlerChain = new ArrayList<>();
private volatile int index = 0;
public Boolean addHandler(Handler handler) {
    return handlerChain.add(handler);
}
public Handler currentHandler() {return handlerChain.get(index);}
public Object doHandlerChain(Object param) {
    Object result= param;
    Iterator<Handler> it = handlerChain.iterator();
    while (it.hasNext()){
        index++;
        Handler handler = it.next();
        result=handler.handle(result);
    }
    index = 0;
    return result;
}

使用：

HandlerChain chain = new HandlerChain();
Handler firstHandler = new FirstHandler();
Handler secondHandler = new SecondHandler();
Handler thirdHandler = new ThirdHandler();
chain.addHandler(firstHandler);
chain.addHandler(secondHandler);
chain.addHandler(thirdHandler);
Object result=chain.doHandlerChain("chain");
System.out.println(result);

结果输出：

优缺点：通过数组列表保存执行节点，可以比较容易的实现链式调用的中断，并且将节点和链式的执行进行了解耦。缺点是各个节点的执行不保证严格的顺序和安全性。

 三、类似拦截器形式的责任链，根据情况跳过某个节点执行。

图示：

 接口：

public interface Intercepter {
    Boolean beforeHandle(Object param);
    Object handle(Object param);
    Object afterhandle(Object param);
}

实现类：

public class FirstIntercepter implements Intercepter {

    @Override
    public Boolean beforeHandle(Object param) {
        System.out.println(this.getClass().getSimpleName() +"_beforeHandle");
        return true;
    }

    @Override
    public Object handle(Object param) {
        System.out.println(this.getClass().getName());
        return param + "_" + this.getClass().getSimpleName();
    }

    @Override
    public Object afterhandle(Object param) {
        System.out.println(this.getClass().getSimpleName() +"_afterhandle");
        return param;
    }
}

拦截器链实现（IntercepterChain）：

public class IntercepterChain {

    private List<Intercepter> intercepterChain = new ArrayList<>();

    private volatile AtomicInteger index = new AtomicInteger();

    public Boolean addIntercepter(Intercepter intercepter) {
        return intercepterChain.add(intercepter);
    }

    public Intercepter currentIntercepter() {return intercepterChain.get(index.get());}

    public synchronized Object doIntercepterChain(Object param) {

        Iterator<Intercepter> it = intercepterChain.iterator();
        while (it.hasNext()){
            index.incrementAndGet();
            Intercepter intercepter = it.next();
            if (intercepter.beforeHandle(param)) {
                param=intercepter.handle(param);
                param=intercepter.afterhandle(param);
            }
        }
        index.set(0);
        return param;
    }
}

使用实例：

IntercepterChain chain = new IntercepterChain();
Intercepter firstIntercepter = new FirstIntercepter();
Intercepter secondIntercepter = new SecondIntercepter();
Intercepter thirdIntercepter = new ThirdIntercepter();
chain.addIntercepter(firstIntercepter);
chain.addIntercepter(secondIntercepter);
chain.addIntercepter(thirdIntercepter);
Object result=chain.doIntercepterChain("chain");
System.out.println(result);

优缺点：实现了链式调用，执行节点和链路管理进行了解耦，并且增加了拦截器前置和后置处理方法，同时可以任意跨过某个拦截器节点的执行；缺点是编写稍微复杂，安全性没有保证，没有严格的顺序要求。

原创文章，引用指明出处！