设计模式-责任链模式

我不是女神ヾ 2024-04-01 13:37 84阅读 0赞

一、简单责任链模式实现

图示：

![d169e3c533f96173a17884379e9f5b45.png][]

接口：

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();
    }

优缺点：

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

二、迭代器形式的责任链

类结构图示：

![daf5fd5bb090febff9ebdf2ca14b2a5d.png][]

实现类（主要展示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);

结果输出：

![6648002e34cda99a196d779d3479bb0c.png][]

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

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

图示：

![75f44ed196d2f065cc70511399a9f866.png][]

接口：

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);

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

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

[d169e3c533f96173a17884379e9f5b45.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/01/5c1a67abcc7e4ace81e2214249b388ba.png
[daf5fd5bb090febff9ebdf2ca14b2a5d.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/01/f1f530f4a3a4458189ff734a8a3d90c4.png
[6648002e34cda99a196d779d3479bb0c.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/01/202c0daba7644cd398e688facaf8218a.png
[75f44ed196d2f065cc70511399a9f866.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/01/8703698d986240ad89ac180bbc4716c8.png