链式调用

不少文章都是先告诉你概念在举例，其实效果并很差。毕竟我连东西都每见过，你就开始告诉我，它有什么特色，有何做用等等。

因此我决定，先给大家看实例，让你先有一个大概认识，等讲到概念的时候，再对照着实例去作验证，这样印象应该深入一些

实例

节点

/**
 * 这是执行链的处理节点
 */
public abstract class Handler {

    /**
     * execute 与 执行链中的process 相互调用，不断循环，直到执行到最后一个节点
     *
     * @param chain 执行链
     */
    public void execute(Chain chain) {
        // 先执行当前节点的处理方法
        process();
        // 在执行 执行链 中的 process
        chain.process();
    }

    /**
     * process 是该节点的 处理方法
     * 执行链的每个节点都要重写 process 方法，并在里面写上本身的处理逻辑
     */
    abstract void process();
}
复制代码

执行链

/**
 * 执行链
 */
public class Chain {

    // 节点列表，里面是要执行的节点
    private List<Handler> list;

    // 游标，指向要执行的节点，默认从0开始
    private int index = 0;

    // 构造方法，传人一个 节点列表
    public Chain(List<Handler> list) {
        this.list = list;
    }

    /**
     * 按照顺序执行节点列表中的节点
     * process 与 节点的execute方法 相互调用，不断循环，直到执行到最后一个节点
     */
    public void process() {
        // 节点列表是否为null 或者 游标已经走完了最后一个节点
        if (list == null || index >= list.size()) {
            return;
        }
        //执行顺序 1获取游标指向的节点 2游标+1 3执行节点的execute方法，并将本身传递进去
        list.get(index++).execute(this);
    }
}
复制代码

测试类

public class Test {

    /**
     * 这是节点A，它重写了节点的process方法
     */
    static class HandlerA extends Handler {

        @Override
        protected void process() {
            System.out.println("执行HandlerA的命令");
        }
    }

    /**
     * 这是节点B，它重写了节点的process方法
     */
    static class HandlerB extends Handler {

        @Override
        protected void process() {
            System.out.println("执行HandlerB的命令");
        }
    }

    /**
     * 这是节点C，它重写了节点的process方法
     */
    static class HandlerC extends Handler {

        @Override
        protected void process() {
            System.out.println("执行HandlerC的命令");
        }
    }


    public static void main(String[] args) {
        /**
         * 建立一个节点列表，并按照执行顺序添加节点对象
         */
        List<Handler> list = Arrays.asList(
                new HandlerA(),
                new HandlerB(),
                new HandlerC()
        );
        // 根据 节点列表 初始化一个 执行链
        Chain chain = new Chain(list);
        //调用
        chain.process();
    }
}
复制代码

概念

上面的例子就是 Spring AOP 处理多个切面做用同一个目标方法的实现。 其实就是切面1调用切面2，切面2调用切面3...切面n调用目标方法。

组成

链式调用 主要有两个类

• 节点抽象类
• 执行链类

任何一个点节点类都必须继承节点抽象类并重写要执行的方法 执行链类须要一个节点列表来告诉它执行顺序 执行链 与 节点相互调用，不断循环，直到最后一个节点(注意，这个地方要处理好，否则容易死循环)

做用

按照 指定的前后顺序，批量执行自定义的方法。