Java设计模式（九）之责任链模式（Chain）

目录

Request和Response

Filter

FilterChain

Main

---

        在tomcat的catalina.jar和servlet-api.jar源码中使用了责任链模式，本文以该源码的简化版为例介绍。模拟客户端请求过滤处理和响应原理。

Request和Response

        先定义请求Request和Response实体类，如下：

/**
 * Created by leboop on 2020/5/25.
 */
public class Request {
    String param;

    public Request() {
    }

    public Request(String param) {
        this.param = param;
    }

    public String getParam() {
        return param;
    }

    public void setParam(String param) {
        this.param = param;
    }

    @Override
    public String toString() {
        return "MyRequest{" +
                "param='" + param + '\'' +
                '}';
    }
}

Request只有一个属性param，表示请求的参数。 

/**
 * Created by leboop on 2020/5/25.
 */
public class Response {
    String data="";

    public Response() {
    }

    public Response(String data) {
        this.data = data;
    }

    public String getData() {
        return data;
    }

    public void setData(String data) {
        this.data = data;
    }

    @Override
    public String toString() {
        return "MyResponse{" +
                "data='" + data + '\'' +
                '}';
    }
}

Response类中也只有一个属性data，表示响应的数据。

 

Filter

        有个Request和Response实体类后，下面定义一个Filter接口，用于抽象对请求的过滤，如下：

/**
 * Created by leboop on 2020/5/25.
 */
public interface Filter {
    void doFilter(Request request, Response response, FilterChain filterChain);
}

Filter接口中只有一个过滤方法doFilter，Filter接口为各种不同的Filter类定义了一个框架。对于具体的Filter类实现该接口，并在doFilter方法中实现具体过滤逻辑。需要注意的是doFilter方法中除了需要处理的request和response对象外，还有filterChain对象，后面我们会看到，它的作用有两个：

（1）作为具体filter类之间的传递作用；

（2）保存多个顺序的filter，形成一条件filter链；

下面我们定义两个具体的Filter，一个是ParamFilter，用于模拟参数处理，另一个是LogFilter，用于模拟日志记录。如下：

/**
 * Created by leboop on 2020/5/25.
 */
public class ParamFilter implements Filter {

    @Override
    public void doFilter(Request request, Response response, FilterChain filterChain) {
        String param=request.getParam();
        if("prefix".equals(param)){
            response.setData("prefix"+response.getData());
        }

        filterChain.doFilter(request, response);
    }

}

ParamFilter处理的逻辑是：如果请求request的参数param是prefix，那么就在响应response的数据data前添加prefix字符串。 

/**
 * Created by leboop on 2020/5/25.
 */
public class LogFilter implements Filter {

    @Override
    public void doFilter(Request request, Response response, FilterChain filterChain) {
//        当前filter处理逻辑：在response后追加.log
        String data = response.getData();
        if (data.startsWith("prefix")) {
            response.setData(data + ".log");
        }

//        进入下一个filter处理
        filterChain.doFilter(request, response);
    }

}

LogFilter的处理逻辑是：如果响应的data以prefix开头，就在data的结尾添加.log字符串。注意filterChain.doFilter(request, response);在这里的作用就是从当前Filter转入到下一个Filter。

 

FilterChain

        有了Filter的后，我们需要FilterChain来管理这些Filter，FilterChain接口如下：

/**
 * Created by leboop on 2020/5/25.
 */
public interface FilterChain{
    void doFilter(Request request, Response response);
}

/**
 * Created by leboop on 2020/5/25.
 */
public final class AppFilterChain implements FilterChain {
//    filterchain中当前filter的索引
    private int pos = 0;
//    filterchain中filter数量
    private int n = 0;
//    AppFilterConfig是filter的简单封装，可以看成是filter数组
    private Filter[] filters = new Filter[0];

    @Override
    public void doFilter(Request request, Response response) {
        if(this.pos < this.n) {
            Filter filter = this.filters[this.pos++];
            System.out.println(
                    "start filter:"+filter.getClass().getSimpleName());
            filter.doFilter(request, response, this);
        }else {
            System.out.println("FilterChain is finished");
        }
    }

    public AppFilterChain addFilter(Filter filter) {
        Filter[] newFilters = this.filters;
        int len$ = newFilters.length;
//        检查filter是否已经存在，如果存在不添加，直接返回
        for(int i$ = 0; i$ < len$; ++i$) {
            Filter f = newFilters[i$];
            if(f == filter) {
                return this;
            }
        }
//      检查原有的filter数组是否可以存下新增的filter，如果不行，进行扩容，每次扩容增加10个
        if(this.n == this.filters.length) {
            newFilters = new Filter[this.n + 10];
            System.arraycopy(this.filters, 0, newFilters, 0, this.n);
            this.filters = newFilters;
        }

        this.filters[this.n++] = filter;

        return this;
    }
}

上面定义了FilterChain接口的具体实现类AppFilterChain。AppFilterChain具体管理Filter，可以向AppFilterChain中添加Filter。

 

Main

        有了前面的这些基础，下面就可以在客户端使用它们了，代码如下：

/**
 * Created by leboop on 2020/5/25.
 */
public class ChainResponsibilityMain {
    public static void main(String[] args) {
        Request request = new Request("prefix");
        Response response=new Response();
//        初始化两个filter
        Filter logFilter=new LogFilter();
        Filter paramFilter=new ParamFilter();
//        初始化filterchain
        AppFilterChain filterChain=new AppFilterChain();
        filterChain.addFilter(paramFilter).addFilter(logFilter);

        filterChain.doFilter(request,response);

        System.out.println(response.getData());
    }

}

代码中创建了request和response对象，然后创建了两个过滤器，分别是LogFilter和ParamFilter，最后创建一个FilterChain，将两个Filter添加进去，并调用doFilter方法。最终程序输出如下：

start filter:ParamFilter
start filter:LogFilter
FilterChain is finished
prefix.log