责任链模式

一、责任链模式概述二、责任链的实现方式

2.1 链表2.2 数组 三、责任链的适用范围

职责链模式的英文翻译是 Chain Of Responsibility Design Pattern。在 GoF 的《设计模式》中，它是这么定义的：将请求的发送和接收解耦，让多个接收对象都有机会处理这个请求。将这些接收对象串成一条链，并沿着这条链传递这个请求，直到链上的某个接收对象能够处理它为止。

其本质就是将多个处理器作为一个链条，统一处理一个请求。

链表的实现方式比较复杂。如图：

将传入的第一个HandlerA作为头，然后内部的set方法为下一个的HandlerB，尾指向HandlerB，当继续有处理器add的时候，将其添加到HandlerB的set方法中，然后尾指向HandlerC，以此类推。

我们设计的责任链HandlerChain的执行方法，将会先执行A，如果执行失败，则会调用里面的B，如果B再失败，调用C，如链条一样传动调用。

首先定义一个抽象处理器类，并使用模板设计模式进行重构。

public abstract class Handler {

    
    private boolean isSuccess = false;

    
    private Handler handler = null;
    public void setHandler(Handler handler) {
        this.handler = handler;
    }

    
    public void handle() {
        isSuccess = doHandle(); //执行的是本Handler方法
        if (!isSuccess && null != handler) {
            handler.handle(); //如果执行失败，则执行通过set方法存入的下一个Handler的handle方法
        }
    }

    
    abstract boolean doHandle();
}

而后实现这个父类。

public class HandlerA extends Handler{

    @Override
    boolean doHandle() {
        System.out.println("执行A处理器业务逻辑===");
        System.out.println("执行A处理器业务逻辑失败！");
        return false;
    }
}


public class HandlerB extends Handler{
    @Override
    boolean doHandle() {
        System.out.println("执行B处理器业务逻辑===");
        System.out.println("执行B处理器业务逻辑成功！");
        return true;
    }
}

最后实现一个链表类型的责任链。

public class HandlerChain {
    private Handler head = null; //头
    private Handler tail = null; //尾

    public void addHandler(Handler handler) {
        handler.setHandler(null);
        if (null == head) {
            head = handler;
            tail = handler;
            return;
        }
        tail.setHandler(handler); //这一步操作，将尾部的Handler内的成员handler变量赋值为下一个Handler
        tail = handler;
    }

    public void handle() {
        if (null != head) {
            head.handle();
        }
    }
}

数组的实现方式很简单，而且使用普遍。

首先定义一个处理器接口。

public interface IHandler {

    
    boolean doHandle();
}

而后实现接口。

public class IHandlerA implements IHandler {
    @Override
    public boolean doHandle() {
        System.out.println("执行A处理器=====");
        System.out.println("A处理失败！");
        return false;
    }
}


public class IHandlerB implements IHandler {
    @Override
    public boolean doHandle() {
        System.out.println("执行B处理器=====");
        System.out.println("B处理成功！");
        return true;
    }
}

最后实现一个处理器链，不同于链表形式，它是将所有处理器存到一个数组或者list，循环处理。

public class IHandlerChain {

    
    private List iHandlers = Lists.newArrayList();

    
    public void addHandler(IHandler iHandler){
        iHandlers.add(iHandler);
    }

    
    public void handled() {
        for (IHandler iHandler : iHandlers) {
            if(iHandler.doHandle()) {
                break;
            }
        }
    }
}

Servlet的Filter、Spring的拦截器