优雅设计封装基于Okhttp3的网络框架（六）：HttpHeader接口设计实现 及 Response、Request封装实现

到目前为止，多线程下载功能设计、编写、优化工作已经完成，但是网络框架编写工作并没有完成，此篇将完成Http核心架构，编写的新功能还是围绕在http请求上，涉及到的知识点：

• httpHeader的接口定义和实现
• http请求头和响应头访问编写
• http状态码定义
• http中的 response封装、request接口封装和实现

（建议阅读此篇文章之前，需理解前两篇文章的讲解，此系列文章是环环相扣，不可缺一，链接如下：）
优雅设计封装基于Okhttp3的网络框架（一）：Http网络协议与Okhttp3解析
优雅设计封装基于Okhttp3的网络框架（二）：多线程下载功能原理设计 及 简单实现
优雅设计封装基于Okhttp3的网络框架（三）：多线程下载功能核心实现 及 线程池、队列机制解析
优雅设计封装基于Okhttp3的网络框架（四）：多线程下载添加数据库支持（greenDao）及 进度更新
优雅设计封装基于Okhttp3的网络框架（五）：多线程、单例模式优化 及 volatile、构建者模式使用解析

---

一. Http核心架构实现

下面将完成网络框架核心架构，考虑到程序的扩展性，首要编写的是接口，采用设计模式将相关的接口预留出来。

1. HttpHeader的接口定义和实现

（1）NameValueMap键值对接口

在定义接口之前，需要先定义一个键值对接口NameValueMap，继承Map接口，提供一些相关接口访问，实现比较简单，代码如下：

public interface NameValueMap<K, V> extends Map<K, V> {    String get(String name);    void set(String name, String value);    void setAll(Map<String, String> map);}

（2）HttpHeader实现NameValueMap

HttpHeader是实现了整个Http请求的接口，该类在定义时实现NameValueMap接口后，需要实现很多方法。既然HttpHeader实现了键值对接口，所以在其内部需要维护一个private Map<String, String> mMap，此时可以根据此HashMap来完善待实现方法。

/** * @function Http请求、响应头部字段访问封装 * @author lemon Guo */public class HttpHeader implements NameValueMap<String, String> {    private Map<String, String> mMap = new HashMap<>();    /*    *   以下都是实现Map接口后需要实现的方法    * */    @Override    public String get(String name) {        return mMap.get(name);    }    @Override    public void set(String name, String value) {        mMap.put(name, value);    }    @Override    public void setAll(Map<String, String> map) {        mMap.putAll(map);    }    @Override    public int size() {        return mMap.size();    }    @Override    public boolean isEmpty() {        return mMap.isEmpty();    }    @Override    public boolean containsKey(Object o) {        return mMap.containsKey(o);    }    @Override    public boolean containsValue(Object value) {        return mMap.containsValue(value);    }    @Override    public String get(Object o) {        return mMap.get(o);    }    @Override    public String put(String key, String value) {        return mMap.put(key, value);    }    @Override    public String remove(Object key) {        return mMap.remove(key);    }    @Override    public void putAll(Map<? extends String, ? extends String> map) {        mMap.putAll(map);    }    @Override    public void clear() {        mMap.clear();    }    ......}

---

2. Http请求头和响应头访问编写

下面就是对Http请求头接口上的访问和包装，首先需要知道Http请求头包含的内容，但是Http请求头、响应头所包含的内容是比较多的，这里只在此封装较为常见的字段：

/** * @function Http请求、响应头部字段访问封装 * @author lemon Guo */public class HttpHeader implements NameValueMap<String, String> {    //常用的 Http字段    public final static String ACCEPT = "Accept";    public final static String PRAGMA = "Pragma";    public final static String PROXY_CONNECTION = "Proxy-Connection";    public final static String USER_AGENT = "User-Agent";    public final static String ACCEPT_ENCODING = "accept-encoding";    public final static String CACHE_CONTROL = "Cache-Control";    public final static String CONTENT_ENCODING = "Content-Encoding";    public final static String CONNECTION = "Connection";    public final static String CONTENT_LENGTH = "Content-length";    public static final String CONTENT_TYPE = "Content-Type";    private Map<String, String> mMap = new HashMap<>();    /*    *   以上Http字段的get/set方法    * */    public String getAccept() {        return get(ACCEPT);    }    public void setAccept(String value) {        set(ACCEPT, value);    }    ......    /*    *   以下都是实现Map接口后需要实现的方法    * */    ......}

以上已经封装完成HttpHeader类——Http头部相关字段的访问。接下来还需要对Http请求方式进行一个简单的封装，除了常用的GET、POST方式还有其它5种，通过一个枚举进行封装即可。代码如下：

/** * @function Http请求方式封装 * @author lemon Guo */public enum HttpMethod {    GET, POST, TRACE, PUT, DELETE, CONNECTION, OPTIONS}

---

3. Http状态码定义

Http的状态码非常多，分布于100~600，根据状态码也分成了几种不同的类型，这里也是封装每种类型中较为常见的，同样采用枚举方式。

• 为HttpStatus类提供构造方法，参数为状态码和含义。
• 声明状态码枚举类型。
• 对外提供方法isSuccess，通过判断字节码返回代表请求是否成功的boolean值
• 对外提供方法getValue，通过传入的参数状态码数字，返回状态码枚举类型。

/** * @function Http状态码封装 * @author lemon Guo */public enum HttpStatus {    CONTINUE(100, "Continue"),    SWITCHING_PROTOCOLS(101, "Switching Protocols"),    OK(200, "OK"),    CREATED(201, "Created"),    Accepted(202, "Accepted "),    NON_AUTHORITATIVE_INFORMATION(203, "Non-Authoritative Information"),    NO_CONTENT(204, "No Content"),    RESET_CONTENT(205, "Reset Content"),    MULTIPLE_CHOICES(300, "Multiple Choices"),    MOVED_PERMANENTLY(301, "Moved Permanently"),    FOUND(302, "Found"),    SEE_OTHER(303, "See Other"),    USE_PROXY(305, "Use Proxy "),    UNUSED(306, "Unused"),    TEMPORARY_REDIRECT(307, "Temporary Redirect"),    BAD_REQUEST(400, "Bad Request"),    PAYMENT_REQUIRED(402, "Payment Required"),    FORBIDDEN(403, "Forbidden"),    NOT_FOUND(404, "Not_Found"),    METHOD_NOT_ALLOWED(405, "Method Not Allowed "),    NOT_ACCEPTABLE(406, "Not Acceptable"),    REQUEST_TIMEOUT(408, "Request Timeout"),    CONFLICT(409, "Conflict"),    GONE(410, "Gone"),    LENGTH_REQUIRED(411, "Length Required"),    PAYLOAD_TOO_LARGE(413, "Payload Too Large"),    URI_TOO_LONG(414, "URI Too Long"),    UNSUPPORTED_MEDIA_TYPE(415, "Unsupported Media Type  Server Error"),    FAILED(417, "Failed Server Error"),    UPGRADE_REQUIRED(426, "Upgrade Required"),    INTERNAL_SERVER_ERROR(500, "Internal Server Error"),    NOT_IMPLEMENTED(501, "Not Implemented"),    BAD_GATEWAY(502, "Bad_Gateway"),    SERVICE_UNAVAILABLE(503, "Service Unavailable"),    GATEWAY_TIMEOUT(504, "Gateway Timeout"),    HTTP_VERSION_NOT_SUPPORTED(505, "HTTP Version Not Supported ");    private int mCode;    private String mMessage;    private HttpStatus(int code, String message) {        this.mCode = code;        this.mMessage = message;    }    public boolean isSuccess() {        int value = mCode / 100;        if (value == 2) {            return true;        }        return false;    }    public static HttpStatus getValue(int value) {        for (HttpStatus httpStatus : values()) {            if (value == httpStatus.mCode) {                return httpStatus;            }        }        return null;    }}

---

---

---

二. Http中Response、Request封装实现

在第一大点编码中的类与接口实现比较基础，难度不大，更像是实现Http核心框架前做的准备，所以说前期接口设计封装直接决定整个程序的扩展性，需谨慎考虑全面。而接下来将对Http中的Response响应、Request请求进行封装。

1. Response接口封装

首先思考一下Response接口中需要封装的方法，状态码和body的获取必不可少，另外可以考虑状态码信息获取、字节长度获取方法。

（1）Header

在封装Response之前还需要先封装一个接口 —– Header，它是对所有响应头、请求头的封装，而接口中只有一个getHeaders 方法，意味着响应头、请求头都会对其实现。代码如下：

/** * @function 对所有响应头、请求头的封装 * @author lemonGuo */public interface Header {    HttpHeader getHeaders();}

（2）HttpResponse接口

该接口继承于Header、Closeable接口，组成为：

• 必须要有获取状态码getStatus()方法、获取Body输入流getBody()方法、关闭输入流close()方法。
• 其次为了考虑全面，新增了获取状态码代表信息getStatusMsg()方法、获取字节长度getContentLength()方法

/** * @funtion Http响应接口 * @author nate */public interface HttpResponse extends Header, Closeable {    HttpStatus getStatus();    String getStatusMsg();    InputStream getBody() throws IOException;    void close();    long getContentLength();}

（3）抽象类AbstractHttpResponse

以上HttpResponse 接口定义好之后，可以定义响应类实现，可是在此之前还需要定义一个抽象类AbstractHttpResponse，由它来实现HttpResponse 接口。

抽象类的好处

抽象类可以拥有自己的成员变量和已实现的方法，比接口的功能更加丰富。在封装框架过程中，可借由抽象类来实现一些内部的方法，更易扩展。

编码实现

在此抽象类中处理响应数据时，需要多判断一点：即是否为压缩数据，若是则对数据流进行处理后再作返回。该抽象类主要是对响应数据多做了一层判断，相当于一个过滤网。

为了处理压缩这种情况，该抽象类实现了HttpResponse 接口中的getBody()、close()，做了一些共性的预处理操作，同时为具体实现的子类留出了getBodyInternal()、closeInternal()抽象方法。

/** * @function AbstractHttpResponse 数据响应抽象类（继承HttpResponse接口） * @author lemon guo */public abstract class AbstractHttpResponse implements HttpResponse {    private static final String GZIP = "gzip";    private InputStream mGzipInputStream;    @Override    public void close()  {        if (mGzipInputStream != null) {            try {                mGzipInputStream.close();            } catch (IOException e) {                e.printStackTrace();            }        }        closeInternal();    }    @Override    public InputStream getBody() throws IOException {        InputStream body = getBodyInternal();        if (isGzip()) {            return getBodyGzip(body);        }        return body;    }    protected abstract InputStream getBodyInternal() throws IOException;    protected abstract void closeInternal();    private InputStream getBodyGzip(InputStream body) throws IOException {        if (this.mGzipInputStream == null) {            this.mGzipInputStream = new GZIPInputStream(body);        }        return mGzipInputStream;    }    private boolean isGzip() {        String contentEncoding = getHeaders().getContentEncoding();        if (GZIP.equals(contentEncoding)) {            return true;        }        return false;    }}

（4）实现类OkHttpResponse

回顾以上，已完成的接口、抽象类都是在为Http响应实现类做准备，最后定义实现类OkHttpResponse，继承抽象类AbstractHttpResponse，实现父类的方法：

• 实现类内部定义两个重要成员变量：响应类mResponse和Http字段访问类mHeaders 。
• 为实现类提供构造方法，参数为响应类Response。
• 实现类内部待实现的方法具体编码都依赖于以上两个成员变量。

代码量虽然不少，但是实现简单，查看即可理解，代码如下：

/** * @funtion: 实现类OkHttpResponse * @author lemon Guo */public class OkHttpResponse extends AbstractHttpResponse {    private Response mResponse;    private HttpHeader mHeaders;    public OkHttpResponse(Response response) {        this.mResponse = response;    }    @Override    protected InputStream getBodyInternal() {        return mResponse.body().byteStream();    }    @Override    protected void closeInternal() {        mResponse.body().close();    }    @Override    public HttpStatus getStatus() {        return HttpStatus.getValue(mResponse.code());    }    @Override    public String getStatusMsg() {        return mResponse.message();    }    @Override    public long getContentLength() {        return mResponse.body().contentLength();    }    @Override    public HttpHeader getHeaders() {        if (mHeaders == null) {            mHeaders = new HttpHeader();        }        for (String name : mResponse.headers().names()) {            mHeaders.set(name, mResponse.headers().get(name));        }        return mHeaders;    }}

---

---

2. HttpRequest接口封装和实现

接下来完成Http请求上的接口设计封装，其实在真正了解以上Response的系列接口、抽象类、实现类设计实现后，会发现两者的“套路”其实很相似。

（1）HttpRequest接口

首先来思考接口中的方法，一个请求很关键的是请求头，然后是请求方式，最后是请求中传递的参数信息。

前期考虑封装很重要，需设计全面，代码实现如下：

/** * @funtion HttpRequest接口设计 * @author nate */public interface HttpRequest extends Header {    HttpMethod getMethod();    URI getUri();    OutputStream getBody();    HttpResponse execute() throws IOException;}

（2）抽象类AbstractHttpRequest

如上，接口定义完之后，定义抽象类继承该接口，实现了HttpResponse 接口中的getBody()、getHeaders()、execute()做一些共性的处理操作，同时为具体实现的子类留出了executeInternal(HttpHeader mHeader)、getBodyOutputStream()抽象方法。

同样为了考虑压缩情况，在实现父类的方法中需要判断当前请求过程中是否支持Zip压缩，根据判断结果来决定是否需要进一步处理输出流。

请求、响应抽象类中的压缩判断代码相同，都是为了考虑压缩情况，在接口的基础上多做了一层封装。编码实现并不难，如下：

/** * @function AbstractHttpRequest 数据响应抽象类（继承HttpRequest接口） * @author lemon guo */public abstract class AbstractHttpRequest implements HttpRequest {    private static final String GZIP = "gzip";    private HttpHeader mHeader = new HttpHeader();    private ZipOutputStream mZip;    private boolean executed;    @Override    public HttpHeader getHeaders() {        return mHeader;    }    @Override    public OutputStream getBody() {        OutputStream body = getBodyOutputStream();        if (isGzip()) {            return getGzipOutStream(body);        }        return body;    }    private OutputStream getGzipOutStream(OutputStream body) {        if (this.mZip == null) {            this.mZip = new ZipOutputStream(body);        }        return mZip;    }    private boolean isGzip() {        String contentEncoding = getHeaders().getContentEncoding();        if (GZIP.equals(contentEncoding)) {            return true;        }        return false;    }    @Override    public HttpResponse execute() throws IOException {        if (mZip != null) {            mZip.close();        }        HttpResponse response = executeInternal(mHeader);        executed = true;        return response;    }    protected abstract HttpResponse executeInternal(HttpHeader mHeader) throws IOException;    protected abstract OutputStream getBodyOutputStream();}

（3）请求流抽象处理BufferHttpRequest

到这里你会发现接下来不是应该创建实现类么？请求的封装在此之前还需要再对抽象类进行一层封装—–BufferHttpRequest，继承于AbstractHttpRequest，在其中对请求流多做一步操作：

• 内部维护一个成员变量：输出字节流ByteArrayOutputStream 。
• 在实现于父类的getBodyOutputStream方法中将成员变量输出流返回出去。
• 在实现于父类的executeInternal(HttpHeader header)方法中将成员变量内存数据转换为字节数组类型，即请求时传递参数的信息，再定义抽象方法将HttpHeader、字节数组两个参数传出。相当于在原理基础上对输出流多做了一步处理：转换为字节数组类型。

代码实现如下：

/** * @funtion 请求流抽象处理BufferHttpRequest * @author lemon Guo */public abstract class BufferHttpRequest extends AbstractHttpRequest {    private ByteArrayOutputStream mByteArray = new ByteArrayOutputStream();    protected OutputStream getBodyOutputStream() {        return mByteArray;    }    protected HttpResponse executeInternal(HttpHeader header) throws IOException {        byte[] data = mByteArray.toByteArray();        return executeInternal(header, data);    }    protected abstract HttpResponse executeInternal(HttpHeader header, byte[] data) throws IOException;}

（4）实现类OkHttpRequest

由于请求不同于响应的特殊性，需要考虑到头部信息，在封装两次抽象类后，最后编写实现类OkHttpRequest。此类继承于BufferHttpRequest ，具体实现为：

• 定义成员变量OkHttpClient及参数HttpMethod、Url来实现Okhttp的请求过程。
• 提供构造方法初始化以上3个成员变量。
• 实现抽象方法getMethod()、getUri()。（这两个抽象方法实现简单，只需返回成员变量即可）
• 实现抽象方法executeInternal(HttpHeader header, byte[] data)：
  
  • 首先需要判断请求方式是否为POST，若是则意味着需要处理RequestBody，将客户端传递的data参数封装到RequestBody其中。
  • 创建请求Request.Builder，传入URL、请求方式、RequestBody参数。
  • 接着对header进行处理，循环该参数将所有请求头封装至Request.Builder
  • 最后封装完毕，调用成员变量OkHttpClient进行请求，获取到响应数据Response。
  • 创建上一点封装好的响应实现类HttpResponse，将响应数据传入其构造方法，最后将响应实现类HttpResponse返回出去即可。

此部分较为重要，一定要将逻辑整理清楚，代码实现如下：

/** * @function 实现类OkHttpRequest * @author lemon guo */public class OkHttpRequest extends BufferHttpRequest {    private OkHttpClient mClient;    private HttpMethod mMethod;    private String mUrl;    public OkHttpRequest(OkHttpClient client, HttpMethod method, String url) {        this.mClient = client;        this.mMethod = method;        this.mUrl = url;    }    @Override    protected HttpResponse executeInternal(HttpHeader header, byte[] data) throws IOException {        boolean isBody = mMethod == HttpMethod.POST;        RequestBody requestBody = null;        if (isBody) {            requestBody = RequestBody.create(MediaType.parse("application/x-www-form-urlencoded"), data);        }        Request.Builder builder = new Request.Builder().url(mUrl).method(mMethod.name(), requestBody);        for (Map.Entry<String, String> entry : header.entrySet()) {            builder.addHeader(entry.getKey(), entry.getValue());        }        Response response = mClient.newCall(builder.build()).execute();        System.out.println("fuck "+response.body().contentLength());        return new OkHttpResponse(response);    }    @Override    public HttpMethod getMethod() {        return mMethod;    }    @Override    public URI getUri() {        return URI.create(mUrl);    }}

---

---

3. 测试

在创建的module文件夹下会自动生成一个test文件夹，供开发人员测试所用，在这里可以编写一个简单的网络代码来测试以上编码工作是否正确，代码如下：

public class ExampleUnitTest {    @Test    public void addition_isCorrect() throws Exception {        assertEquals(4, 2 + 2);        OkHttpClient client = new OkHttpClient();        OkHttpRequest request = new OkHttpRequest(client, HttpMethod.GET, "http://www.baidu.com");        HttpResponse response = request.execute();        String content = null;        BufferedReader bufferedReader = new BufferedReader(new InputStreamReader(response.getBody()));        while ((content = bufferedReader.readLine()) != null){            System.out.println(content);        }        response.close();    }}

结果显示

以上代码逻辑为GET方式请求百度，打印出请求到的资源数据，成功显示，证明以上编码无误。

---

---

---

三. 工厂模式封装HttpReques创建

此部分将对HttpRequest对象进行封装，以上工作对于网络框架而言是底层实现，那具体的网络请求是调用OkhttpRequest来完成，但是此次封装的网络框架不仅支持Okhttp网络框架请求方式，还支持原生UrlConnection请求，所以考虑到扩展性，完成原生请求，只需继承HttpReques接口实现功能即可，但是对于上层业务调用，还是要对请求对象进行封装。

通过一种机制来封装HttpReques对象给上层调用，对于上层而言只需获取HttpReques对象即可，至于该对象是通过Okhttp还是UrlConnection获取并不关注。

1. 接口HttpRequestFactory

通过此接口的名字便知它内部采用的是工厂模式，而方法就是获取HttpReques对象：

/** * @function 接口HttpRequestFactory（获取HttpRequest对象） * @author lemon Guo */public interface HttpRequestFactory {    HttpRequest createHttpRequest(URI uri, HttpMethod method) throws IOException;}

工厂设计模式

工厂设计模式可以解决的问题：

• 不会向上层曝露对象创建的复杂过程，只提供结果。
• 工厂模式是典型的解耦式设计，使职责单一化。

类图

结合此类图至编写的接口：

• HttpRequestFactory就是工厂模式中的Creator
• 接口中返回的HttpRequest 对象就是工厂模式中的Product
• 下面就需要创建实现类继承接口来“生产”Product，此实现类相当于工厂模式中的ConcreteCreator

---

2. 实现类

通过以上结合工厂模式的分析后，得知此类就是“生产”HttpRequest 对象的具体实现类，它继承于HttpRequestFactory 接口，具体实现：

• 定义成员变量OkhttpClient
• 为此类提供构造方法初始化成员变量
• 实现接口中的createHttpRequest方法，即创建OkHttpRequest 对象并返回。
• 再提供一些基本方法setConnectionTimeOut设置请求超时时间，setReadTimeOut、setWriteTimeOut设置读写时间。（若有其他需求，此处可继续增加）

/** * @function 实现类OkHttpRequestFactory（返回HttpRequest对象） * @author lemon Guo */public class OkHttpRequestFactory implements HttpRequestFactory {    private OkHttpClient mClient;    public OkHttpRequestFactory() {        this.mClient = new OkHttpClient();    }    public OkHttpRequestFactory(OkHttpClient client) {        this.mClient = client;    }    public void setReadTimeOut(int readTimeOut) {        this.mClient = mClient.newBuilder().                readTimeout(readTimeOut, TimeUnit.MILLISECONDS).                build();    }    public void setWriteTimeOut(int writeTimeOut) {        this.mClient = mClient.newBuilder().                writeTimeout(writeTimeOut, TimeUnit.MILLISECONDS).                build();    }    public void setConnectionTimeOut(int connectionTimeOut) {        this.mClient = mClient.newBuilder().                connectTimeout(connectionTimeOut, TimeUnit.MILLISECONDS).                build();    }    @Override    public HttpRequest createHttpRequest(URI uri, HttpMethod method) {        return new OkHttpRequest(mClient, method, uri.toString());    }}

---

3. 供上层调用HttpRequestProvider

接下来需要将OkHttpRequestFactory 的具体实现再做一次封装供上层使用，创建一个类HttpRequestProvider ：

• 定义成员变量HttpRequestFactory，用于创建HttpRequest对象。
• 提供构造方法来初始化成员变量。注意这里会判断项目中是否使用Okhttp：
  
  • 若是，则创建OkHttpRequestFactory
  • 若不是，意味着请求需依赖原生UrlConnction，使用原生的Factory（后续会编写）。
• 提供方法getHttpRequest(URI uri, HttpMethod httpMethod)，底层会调用HttpRequestFactory来创建HttpRequest对象。

/** * @function 封装请求HttpRequestProvider，供上层调用 * @author lemon Guo */public class HttpRequestProvider {    private static boolean OKHTTP_REQUEST = Utills.isExist("okhttp3.OkHttpClient", HttpRequestProvider.class.getClassLoader());    private HttpRequestFactory mHttpRequestFactory;    public HttpRequestProvider() {        if (OKHTTP_REQUEST) {            mHttpRequestFactory = new OkHttpRequestFactory();        } else {            mHttpRequestFactory = new OriginHttpRequestFactory();        }    }    public HttpRequest getHttpRequest(URI uri, HttpMethod httpMethod) throws IOException {        return mHttpRequestFactory.createHttpRequest(uri, httpMethod);    }    public HttpRequestFactory getHttpRequestFactory() {        return mHttpRequestFactory;    }    public void setHttpRequestFactory(HttpRequestFactory httpRequestFactory) {        mHttpRequestFactory = httpRequestFactory;    }}

最后，供给上层调用的就是HttpRequestProvider 类，它可以根据不同的条件创建不同Http请求library，这样便实现多个library类库切换的条件判断使用。

---

---

---

四. 总结

1. 本篇总结

以上截图显示着此篇博文完成的编码内容，看起来编码量很多，但是实现起来逻辑并不复杂。其中含有大量的接口、抽象类，这些都是在为程序拓展性做准备，在下一篇博文中将添加新的类库请求支持，你会发现在此基础上只需增加3个类即可，充分体现出了程序的扩展性。

我们编写的顺序基本是 接口、枚举 –> 抽象类 –>实现类，

• 在第一点准备工作中完成了HttpHeader的设计实现、Http请求头和响应头访问编写、Http状态码封装，这些并不复杂，只是最基本的封装思想。
• 在第二点中主要对Http中的Request、Response进行设计封装，这里为了程序扩展性逻辑稍显复杂，先从接口开始定义，然后在此基础上定义抽象类实现接口，在其内部进行共性操作，再留出抽象方法。
• 第三点在现有的请求方式上再次封装，采用工厂模式，提供最简洁方法供上层调用。

此篇文章完成的部分还是有些多，需将逻辑捋清楚，但每个类实现并不难，重要的是它们之间的封装关系，可对应以下代码理解。

对应第六篇至以前所完成的源码

---

2. 下篇预告

在下一篇博文中将添加新功能——原生请求的类库支持，你会发现在此基础上只需增加3个类即可，充分体现出了程序的扩展性。新增功能如下：

• 原生HttpUrlConnction请求和响应
• 业务层多线程分发处理
• 移除请求
• 请求成功类型转换包装处理

---

---

若有错误，虚心指教~