责任链模式——递归实现

前言

我们知道责任链模式可以通过构造数组或者链表方式实现，本文介绍一种更富有技巧性的实现方式，通过构造函数递归实现，这样做的好处是什么呢？容我先卖个关子，后面会给出答案。

以实现一串过滤器为例子，话不多说，撸代码！

定义过滤器

首先定义过滤器接口

public interface IFilter {
    /**
     *
     * @param exchange 需要贯穿过滤全程的对象，这里采用字符串
     * @param chain 过滤连
     */
    void doFilter(StringBuffer exchange, FilterChain chain);
}

实现过滤器

public class FilterA implements IFilter {
    @Override
    public void doFilter(StringBuffer exchange, FilterChain chain) {
        exchange.append("\n").append("唱");
        chain.filter(exchange);
    }
}

public class FilterB implements IFilter {
    @Override
    public void doFilter(StringBuffer exchange, FilterChain chain) {
        exchange.append("\n").append("跳");
        chain.filter(exchange);
    }
}

public class FilterC implements IFilter{
    @Override
    public void doFilter(StringBuffer exchange, FilterChain chain) {
        exchange.append("\n").append("rap");
        chain.filter(exchange);
    }
}

public class FilterD implements IFilter {
    @Override
    public void doFilter(StringBuffer exchange, FilterChain chain) {
        exchange.append("\n").append("篮球");
        chain.filter(exchange);
    }
}

构造过滤链

public class FilterChain {
    private final List<IFilter> filters;
    private final int index;

    public FilterChain(FilterChain parent, int index) {
        this.index = index;
        this.filters = parent.getFilters();
    }

    public FilterChain(List<IFilter> filters) {
        this.filters = filters;
        this.index = 0;
    }

    public void filter(StringBuffer exchange) {
        if (this.index < this.filters.size()) {
            IFilter filter = this.filters.get(index);
            // index + 1, 构造新的过滤链
            FilterChain filterChain = new FilterChain(this, index + 1);
            // 执行过滤，这里其实是一个递归
            filter.doFilter(exchange, filterChain);
        } else {
            exchange.append("\n").append("--------所有前置过滤执行完毕--------");
        }
    }

    public List<IFilter> getFilters() {
        return this.filters;
    }

}

写一个Demo跑一下

public class DemoApplication {
    public static void main(String[] args) {
        List<IFilter> filters = new ArrayList<>();
        filters.add(new FilterA());
        filters.add(new FilterB());
        filters.add(new FilterC());
        filters.add(new FilterD());
        FilterChain filterChain = new FilterChain(filters);
        StringBuffer exchange = new StringBuffer("坤坤");
        filterChain.filter(exchange);
        System.out.println(exchange);
    }
}

先来看运行结果

坤坤
唱
跳
rap
篮球
--------所有前置过滤执行完毕--------

很好， 所有过滤器都以期望的方式执行了。

接下来我们看filter.doFilter(exchange, filterChain)这行代码，不知道大家有没有发现，这里其实是一个隐藏的递归，如果这里不太理解，可以把这行代码换成filterChain .filter(exchange)，效果是一样的。

那么有同学要问了，为什么不直接使用filterChain .filter(exchange)呢？

其实解决了这个问题，也就解决了我们开头提出的为什么要采用递归来实现责任链模式。我们随便找个过滤器，以FilterA为例：

public class FilterA implements IFilter {
    @Override
    public void doFilter(StringBuffer exchange, FilterChain chain) {
    	// 前置过滤
        exchange.append("\n").append("唱");
        chain.filter(exchange);
        // 后置过滤
        exchange.append("\n").append("sing");
    }
}

细心的同学会发现，比起刚才的代码，这里添加了一些后置处理，这就是递归实现的精妙之处！比起普通以数组或链表实现的责任链模式，这里可以对具体业务逻辑进行前置和后置处理。事实上，SpringWeb中的一些过滤器就是这么实现的。

我们为每个Filter添加一些后置处理，再次运行DemoApplication
得到结果：

坤坤
唱
跳
rap
篮球
--------所有前置过滤执行完毕--------
basketball
rap
dance
sing