责任链模式

责任链模式是一种对象的行为模式。在责任链模式里，很多对象由每一个对象对其下家的引用而连接起来形成一条链。请求在这个链上传递，直到链上的某一个对象决定处理此请求。发出这个请求的客户端并不知道链上的哪一个对象最终处理这个请求，这使得系统可以在不影响客户端的情况下动态地重新组织和分配责任。

从击鼓传花谈起

　　击鼓传花是一种热闹而又紧张的饮酒游戏。在酒宴上宾客依次坐定位置，由一人击鼓，击鼓的地方与传花的地方是分开的，以示公正。开始击鼓时，花束就开始依次传递，鼓声一落，如果花束在某人手中，则该人就得饮酒。

　　比如说，贾母、贾赦、贾政、贾宝玉和贾环是五个参加击鼓传花游戏的传花者，他们组成一个环链。击鼓者将花传给贾母，开始传花游戏。花由贾母传给贾赦，由贾赦传给贾政，由贾政传给贾宝玉，又贾宝玉传给贾环，由贾环传回给贾母，如此往复，如下图所示。当鼓声停止时，手中有花的人就得执行酒令。

　　击鼓传花便是责任链模式的应用。责任链可能是一条直线、一个环链或者一个树结构的一部分。

责任链模式的结构

　　责任链模式涉及到的角色如下所示：

　　●　　抽象处理者(Handler)角色：定义出一个处理请求的接口。如果需要，接口可以定义 出一个方法以设定和返回对下家的引用。这个角色通常由一个Java抽象类或者Java接口实现。上图中Handler类的聚合关系给出了具体子类对下家的引用，抽象方法handleRequest()规范了子类处理请求的操作。

　　●　　具体处理者(ConcreteHandler)角色：具体处理者接到请求后，可以选择将请求处理掉，或者将请求传给下家。由于具体处理者持有对下家的引用，因此，如果需要，具体处理者可以访问下家。

责任链实现方式一：组合方式

抽象处理者角色

/**
 * 抽象处理者角色
 * 使用组合方式实现责任链的递归调用，该方式需要维护上下游目标对象的关系
 *
 */
public abstract class Handler {
    private Handler successor;  

    public Handler getSuccessor() {
        return successor;
    }

    public void setSuccessor(Handler successor) { //设置后继的责任对象
        this.successor = successor;
    }
    
    public void execute(){
        handleProcess();    //处理单个目标对象的逻辑
        if(successor!=null){
            successor.execute();    //递归调用
        }
    }
    protected abstract void handleProcess();    //目标对象业务方法
}

调用客户端和具体处理者角色：

public class Client {
    //具体处理者角色
    static class HandlerA extends Handler{
        @Override
        protected void handleProcess() {
            System.out.println("handlerProcess by a");
        }
    }
    //具体处理者角色
    static class HandlerB extends Handler{
        @Override
        protected void handleProcess() {
            System.out.println("handlerProcess by b");
        }
    }
    //具体处理者角色
    static class HandlerC extends Handler{
        @Override
        protected void handleProcess() {
            System.out.println("handlerProcess by c");
        }
    }
    
    public static void main(String[] args) {
        Handler handlerA = new HandlerA();
        Handler handlerB = new HandlerB();
        Handler handlerC = new HandlerC();
        handlerA.setSuccessor(handlerB);    //设置后继的责任对象
        handlerB.setSuccessor(handlerC);    //设置后继的责任对象
        handlerA.execute(); //开始执行请求
    }
}

输出结果：

handlerProcess by a
handlerProcess by b
handlerProcess by c

责任链实现方式二：解耦方式(解耦上下游责任处理者关系，由chain统一管理)

责任链关系管理者

public class Chain {
    private List<ChainHandler> handlers;
    
    private int index = 0;  //游标，记录递归的次数
    
    public Chain(List<ChainHandler> handlers){
        this.handlers = handlers;
    }
    
    public void proceed(){
        if(index >= handlers.size()){
            return; //中断递归
        }
        handlers.get(index++).execute(this);//递归调用
    }
}

抽象处理者角色

public abstract class ChainHandler {
    public void execute(Chain chain){
        handleProcess();    //目标对象处理逻辑
        chain.proceed();    //责任链递归调用
    }
    
    protected abstract void handleProcess();    //目标对象业务方法
}

具体处理者角色和客户端

import java.util.Arrays;
import java.util.List;

/**
 * 责任链调用客户端
 * 该方式解耦多个上下游责任处理者对象，添加剔除更方便。spring-AOP使用该方式实现多个AOP的叠加
 */
public class ChainClient {
    具体处理者角色
    static class ChainHandlerA extends ChainHandler{
        @Override
        protected void handleProcess() {
            System.out.println("handlerProcess by a");
        }
    }
    具体处理者角色
    static class ChainHandlerB extends ChainHandler{
        @Override
        protected void handleProcess() {
            System.out.println("handlerProcess by b");
        }
    }
    具体处理者角色
    static class ChainHandlerC extends ChainHandler{
        @Override
        protected void handleProcess() {
            System.out.println("handlerProcess by c");
        }
    }
    
    public static void main(String[] args) {
        List<ChainHandler> handlers = Arrays.asList(
                new ChainHandlerA(),
                new ChainHandlerB(),
                new ChainHandlerC()
        );
        
        Chain chain = new Chain(handlers);  //初始化责任链目标对象
        chain.proceed();    //开始执行请求
    }
}

输出结果：

handlerProcess by a
handlerProcess by b
handlerProcess by c

总结：责任链模式在开源框架中有很好的使用，struts2的过滤器链filterChain和Spring-AOP的叠加等。