拦截器链

封装网络框架时，会有这样的业务场景：

1.url在发起请求前可能需要根据不同的域名拼接不同的参数。

此时需要在网络请求上层封装一层参数处理层，以处理不同域名的特殊需求。

2.请求成功之后，有的业务方只想拿到需要的数据类型，不想参与数据的解析；有的业务方则想要返回的json去掉某些不相关参数（如{"code":"200","data":{"name":"xz"}}，业务方只需要data而不关心code）。

此时需要在封装的网络框架返回结果前加一层数据解析或结果处理层。

...

随着类似的需求逐渐增多，封装的难度和复杂度会逐渐增加，且杂乱难以维护。

如：
一般情况下，业务方调用封装好的网络框架访问网络；
为了不耦合网络层的代码，我们在网络框架上层封装了参数处理层。此时业务方需要网络请求，将不能直接调用网络框架，而需要调用参数处理层。
导致的结果就是：增加新的层次，业务方也需要跟着修改代码，一旦原调用量巨大，将带来巨大的修改量。

是否可以对诸多层进行一次封装，使层与层之间可以根据需求轻易插入，也可以轻易摘除，同时对业务方无感知呢？

拦截器链可以解决这个问题。

拦截器链

这里以拦截器链封装网络框架调用为例。以下代码仅是简单范例：

拦截器链可以简单看作是一端输入参数、一端输出结果的单向管道，故先简单定义一个请求参数：Request，及一个返回结果：Response。

Request

public class Request {

    private String url;
    private String method;
    private String data;

    public String getUrl() {
        return url;
    }

    public void setUrl(String url) {
        this.url = url;
    }

    public String getMethod() {
        return method;
    }

    public void setMethod(String method) {
        this.method = method;
    }

    public String getData() {
        return data;
    }

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

    private Request() {
    }

    public static class Builder {

        private String url;
        private String method;
        private String data;

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

        public Builder setUrl(String url) {
            this.url = url;
            return this;
        }

        public Builder setMethod(String method) {
            this.method = method;
            return this;
        }

        public Request build() {

            Request request = new Request();

            if (!TextUtils.isEmpty(url)) {
                request.setUrl(url);
            } else {
                throw new NullPointerException("url is empty!");
            }

            if (!TextUtils.isEmpty(method)) {
                request.setMethod(method);
            } else {
                request.setMethod("get");
            }

            if (!TextUtils.isEmpty(data)) {
                request.setData(data);
            }

            return request;
        }
    }
}

Response

public class Response<T> {

    private T data;

    public T getData() {
        return data;
    }

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

下面正式开始拦截器链的代码。

首先定义拦截器及链条的接口：

Interceptor & Chain

//拦截器
public interface Interceptor {

    Response intercept(Chain chain); //拦截器需要链条启动新拦截器以及链条携带的参数

    //链条（拦截器启动器）
    interface Chain {

        Response proceed(Request request);//request用于init新链条需要的参数
        
        Request request();
    }
}

实现链条：

RealChain

public class RealChain implements Interceptor.Chain {

    public List<Interceptor> list;
    public int index;
    public Request request; //旧链条携带的参数

    public RealChain(List<Interceptor> list, int index, Request request) {

        this.list = list;
        this.index = index;
        this.request = request;
    }

    public Response proceed(Request request) { //新链条携带的参数

        if (index >= list.size()) {
            //exception
            throw new IllegalArgumentException("The chain exceeds the maximum number");
        }
        Interceptor.Chain next = new RealChain(list, index + 1, request);//这个新链条用于intercept执行任务完毕后启动
        Interceptor interceptor = list.get(index);//index即依次累加后的值
        //执行当前拦截器
        return interceptor.intercept(next);
    }
    
    @Override
    public Request request() {
        return request;
    }
}

现在定义一个网络请求的拦截器，模拟一下拦截器链。这里网络请求使用Volley JsonRequest同步请求，Volley如何封装不做展示：

JsonConnectInterceptor

public class JsonConnectInterceptor implements Interceptor {

    @Override
    public Response intercept(Chain chain) {

        Request request = chain.request();
        JSONObject jsonObject = connect(request);
        Response<JSONObject> response = new Response<>();
        response.setData(jsonObject);
        return response;
    }

    private JSONObject connect(Request request) {

        //示例代码 这里仅以get为例

        if (request == null) {
            throw new NullPointerException("the request is null!");
        }

        JSONObject jsonResponse = null;

        switch (request.getMethod().toLowerCase()) {
            case "get":
                RequestFuture<JSONObject> future = RequestFuture.newFuture();
                JsonObjectRequest jsonRequest = new JsonObjectRequest(request.getUrl(), future, future);
                VolleyManager.getInstance().addQueue(jsonRequest);

                try {
                    jsonResponse = future.get(); // this will block
                } catch (InterruptedException | ExecutionException e) {
                    // exception handling
                }
                break;

            case "post":

                break;
        }

        return jsonResponse;
    }
}

拦截器和链条都定义好了，可以启动拦截器链了。这里为了方便测试，直接new Thread，没有做其余额外封装：

new Thread(new Runnable() {
    @Override
    public void run() {

        Request request = new Request.Builder().setUrl("xxx").build();

        List<Interceptor> list = new ArrayList<>();
        list.add(new JsonConnectInterceptor());

        //启动链条
        RealChain startChain = new RealChain(list, 0, null);//interceptor使用的是下一个链条的request 故启动链条可以传null
        Response response = startChain.proceed(request);

        Log.e(TAG, response.getData().toString());
    }
}).start();

这样，一个简单的拦截器链框架已经搭好，并可以进行网络请求了。
现在，只需根据需要，增删拦截器即可实现增删层次。

回到开头，假如此时需要根据域名拼接参数，只需要增加一个新的拦截器：

HostInterceptor

public class HostInterceptor implements Interceptor {

    private static final String HOST_STORMSEND = "xxx";

    @Override
    public Response intercept(Chain chain) {

        //修改url
        Request request = chain.request();
        request.setUrl(parseUrl(request.getUrl()));

        //执行下一拦截器
        return chain.proceed(request);
    }

    //根据域名拼接不同参数
    private String parseUrl(String url) {

        //以下仅为示例代码
        StringBuilder builder = new StringBuilder(url);

        try {
            URL u = new URL(url);
            String host = u.getHost();
            switch (host) {

                case HOST_STORMSEND:

                    if (!url.contains("?")) {

                        builder.append("?");
                    }
                    builder.append("&country=cn&language=zh-CN");
                    break;
            }
        } catch (MalformedURLException e) {
            e.printStackTrace();
        }
        return builder.toString();
    }
}

然后如下调用：

List<Interceptor> list = new ArrayList<>();
list.add(new HostInterceptor());
list.add(new JsonConnectInterceptor());

域名拦截器仅仅通过list.add，就实现了层次的增删，而且和其它功能代码完全没有耦合，最后这种链式的代码结构，也容易梳理。

继续，假如目前后端返回的是数据格式如：{"code":"200","data":{"name":"xz"}}，而业务方只想拿到"data":{"name":"xz"}。只需要增加一个结果处理拦截器。

JsonParseInterceptor

public class JsonParseInterceptor implements Interceptor {
    @Override
    public Response intercept(Chain chain) {

        //先执行下一链条 拿到返回结果
        Response response = chain.proceed(chain.request());

        //对返回结果进行处理
        JSONObject newData = parseJson(response.getData().toString());

        //返回处理后的结果
        Response<JSONObject> result = new Response<>();
        result.setData(newData);
        return result;
    }

    private JSONObject parseJson(String json) {

        //TODO 在这里处理Json 这里不做演示
        return null;
    }
}

如下调用：

List<Interceptor> list = new ArrayList<>();
list.add(new HostInterceptor());
list.add(new JsonParseInterceptor());
list.add(new JsonConnectInterceptor());

之后有类似的需求，也可以添加拦截器实现。

总结

拦截器链的优点有哪些？

通过拦截器链，实现了诸多数据处理层之间的封装。

1. 层次之间没有耦合。各层之间独立开发互不影响。
2. 层与层之间可以根据需要随时增删层，增删仅通过数组或集合即可实现，扩展性强。
3. 对业务方完全无感知。层次的叠加或减少对业务方不可见，封装性好。
4. 链式处理数据，代码易梳理易读。

拦截器链的执行步骤？

简单步骤如下，具体应以实际情况为准。

1. 链条A（启动链条）生成链条B，启动拦截器1，拦截器1获取链条B携带的参数，执行完毕后调用链条B。
2. 链条B生成链条C，启动拦截器2，拦截器2获取链条C携带的参数，执行完毕后调用链条C。
3. ...

上述表达比较抽象，可以这样理解：

一个简单的链式模型应该是：
A用于启动1，B用于启动2，C用于启动3
为了实现链条效果：
A用于启动1，1在相关代码执行完后调用B，B用于启动2，2在相关代码执行完后调用C...

同理，chain.proceed()可以看作拦截器启动器，为了实现链式效果，它会在启动当前拦截器的同时，生成启动下一个拦截器的链条，并传给拦截器。
interceptor.intercept()则执行拦截器功能，根据情况返回结果，或是继续执行传给它的链条（也就是拦截器启动器）。

拦截器链模型如下：

B9DC0499-02A6-45C9-B317-ED8CD001E469.png

好吧，还真像个链条...