责任链模式

一、责任链模式概述

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

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

二、责任链的实现方式

2.1 链表

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

将传入的第一个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();
}

而后实现这个父类。

/**
 * A处理器
 */
public class HandlerA extends Handler{

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

/**
 * B处理器
 */
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();
        }
    }
}

2.2 数组

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

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

/**
 * handler的接口
 */
public interface IHandler {

    /**
     * 执行处理
     */
    boolean doHandle();
}

而后实现接口。

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

/**
 * B处理器
 */
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<IHandler> 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的拦截器