最近在整理Android常用第三方框架相关的东西，说道Android的框架，无外乎就是Android开发中常见的网络、图片缓存、数据交互、优化、页面等框架，其中网络作为一个基础部分，我相信大家更多的是使用OkHttp，而在长连接中有Socket和webSocket等，今天给大家总结下OkHttp相关的内容，部分参考网络资源。

OkHttp简介

OkHttp作为时下Android最火的Http第三方库可以说被大多数的Android客户端程序所使用，Retrofit底层也是使用OkHttp，与Volley等网络请求框架相比，OkHttp具有如下的一些特点：

HTTP/2支持所有访问相同主机的请求共享一个套接字。也就是说支持Google的SPDY协议，如果 SPDY 不可用，则通过连接池来减少请求延时。
连接池减少了请求延迟(如果HTTP/2不可用)。
透明GZIP压缩减少了下载大小。
响应缓存完全避免了重复请求的网络使用。
当网络出现问题时，OkHttp 会自动重试一个主机的多个 IP 地址
…

OkHttp官网地址：http://square.github.io/okhttp/
OkHttp GitHub地址：https://github.com/square/okhttp

使用示例

OkHttp的使用也非常简单，支持Get、Post等多种请求方式，并且支持文件等的上传下载等多种功能，可以说现在你业务中能涉及到的情况，OkHttp都能解决。下面是一些简单的使用示例。

同步Get请求

private final OkHttpClient client = new OkHttpClient();  public void run() throws Exception {    Request request = new Request.Builder()        .url("http://publicobject.com/helloworld.txt")        .build();    Response response = client.newCall(request).execute();    if (!response.isSuccessful()) throw new IOException("Unexpected code " + response);    Headers responseHeaders = response.headers();    for (int i = 0; i < responseHeaders.size(); i++) {      System.out.println(responseHeaders.name(i) + ": " + responseHeaders.value(i));    }    System.out.println(response.body().string());  }

不过需要注意的是，作用在响应主体上的string()方法对于小文档来说是方便和高效的，但是如果响应主体比较大(大于1MB)，应避免使用string()，因为它会加载整个文档到内存中。

异步Get请求

异步使用enqueue进行请求，例如：

private final OkHttpClient client = new OkHttpClient();  public void run() throws Exception {    Request request = new Request.Builder()        .url("http://publicobject.com/helloworld.txt")        .build();    client.newCall(request).enqueue(new Callback() {      @Override public void onFailure(Call call, IOException e) {        e.printStackTrace();      }      @Override public void onResponse(Call call, Response response) throws IOException {        if (!response.isSuccessful()) throw new IOException("Unexpected code " + response);        Headers responseHeaders = response.headers();        for (int i = 0, size = responseHeaders.size(); i < size; i++) {          System.out.println(responseHeaders.name(i) + ": " + responseHeaders.value(i));        }        System.out.println(response.body().string());      }    });  }

典型的HTTP头工作起来像一个Map< String, String >，每一个字段有一个值或没有值。但是有一些头允许多个值，像Guava的Multimap。

使用Request进行请求头信息的设置时，有些信息再次设置是不会被覆盖的，例如addHeader(name, value)，使用addHeader(name, value)来添加一个头而不移除已经存在的头。

private final OkHttpClient client = new OkHttpClient();  public void run() throws Exception {    Request request = new Request.Builder()        .url("https://api.github.com/repos/square/okhttp/issues")        .header("User-Agent", "OkHttp Headers.java")        .addHeader("Accept", "application/json; q=0.5")        .addHeader("Accept", "application/vnd.github.v3+json")        .build();    Response response = client.newCall(request).execute();    if (!response.isSuccessful()) throw new IOException("Unexpected code " + response);    System.out.println("Server: " + response.header("Server"));    System.out.println("Date: " + response.header("Date"));    System.out.println("Vary: " + response.headers("Vary"));  }

上传字符串

使用HTTP POST来发送请求（比如文件）主体到服务器，因为整个请求主体同时存在内存中，应避免使用这个API上传大的文档大于1MB。如果是大文件，可以使用OKHttp的断点续传功能。

public static final MediaType MEDIA_TYPE_MARKDOWN      = MediaType.parse("text/x-markdown; charset=utf-8");  private final OkHttpClient client = new OkHttpClient();  public void run() throws Exception {    String postBody = ""        + "Releases\n"        + "--------\n"        + "\n"        + " * _1.0_ May 6, 2013\n"        + " * _1.1_ June 15, 2013\n"        + " * _1.2_ August 11, 2013\n";    Request request = new Request.Builder()        .url("https://api.github.com/markdown/raw")        .post(RequestBody.create(MEDIA_TYPE_MARKDOWN, postBody))        .build();    Response response = client.newCall(request).execute();    if (!response.isSuccessful()) throw new IOException("Unexpected code " + response);    System.out.println(response.body().string());  }

当然，OkHttp也支持以stream的形式来上传文件等请求主体。

public static final MediaType MEDIA_TYPE_MARKDOWN      = MediaType.parse("text/x-markdown; charset=utf-8");  private final OkHttpClient client = new OkHttpClient();  public void run() throws Exception {    RequestBody requestBody = new RequestBody() {      @Override public MediaType contentType() {        return MEDIA_TYPE_MARKDOWN;      }      @Override public void writeTo(BufferedSink sink) throws IOException {        sink.writeUtf8("Numbers\n");        sink.writeUtf8("-------\n");        for (int i = 2; i <= 997; i++) {          sink.writeUtf8(String.format(" * %s = %s\n", i, factor(i)));        }      }      private String factor(int n) {        for (int i = 2; i < n; i++) {          int x = n / i;          if (x * i == n) return factor(x) + " × " + i;        }        return Integer.toString(n);      }    };    Request request = new Request.Builder()        .url("https://api.github.com/markdown/raw")        .post(requestBody)        .build();    Response response = client.newCall(request).execute();    if (!response.isSuccessful()) throw new IOException("Unexpected code " + response);    System.out.println(response.body().string());  }

文件上传

文件的上传相对简单，直接提供File的路径即可。

public static final MediaType MEDIA_TYPE_MARKDOWN      = MediaType.parse("text/x-markdown; charset=utf-8");  private final OkHttpClient client = new OkHttpClient();  public void run() throws Exception {    File file = new File("README.md");    Request request = new Request.Builder()        .url("https://api.github.com/markdown/raw")        .post(RequestBody.create(MEDIA_TYPE_MARKDOWN, file))        .build();    Response response = client.newCall(request).execute();    if (!response.isSuccessful()) throw new IOException("Unexpected code " + response);    System.out.println(response.body().string());  }

上传表格参数

OkHtpp支持使用FormBody.Builder来构建一个工作起来像HTML< form >标签的请求主体。键值对会使用一个兼容HTML form的URL编码进行编码。

private final OkHttpClient client = new OkHttpClient();  public void run() throws Exception {    RequestBody formBody = new FormBody.Builder()        .add("search", "Jurassic Park")        .build();    Request request = new Request.Builder()        .url("https://en.wikipedia.org/w/index.php")        .post(formBody)        .build();    Response response = client.newCall(request).execute();    if (!response.isSuccessful()) throw new IOException("Unexpected code " + response);    System.out.println(response.body().string());  }

多部分请求

MultipartBody.Builder可以构造复杂的请求主体与HTML文件上传表单兼容。multipart请求主体的每部分本身就是一个请求主体，可以定义它自己的头。如果存在自己的头，那么这些头应该描述部分主体，例如它的Content-Disposition。Content-Length和Content-Type会在其可用时自动添加。

private static final String IMGUR_CLIENT_ID = "...";  private static final MediaType MEDIA_TYPE_PNG = MediaType.parse("image/png");  private final OkHttpClient client = new OkHttpClient();  public void run() throws Exception {    // Use the imgur image upload API as documented at https://api.imgur.com/endpoints/image    RequestBody requestBody = new MultipartBody.Builder()        .setType(MultipartBody.FORM)        .addFormDataPart("title", "Square Logo")        .addFormDataPart("image", "logo-square.png",            RequestBody.create(MEDIA_TYPE_PNG, new File("website/static/logo-square.png")))        .build();    Request request = new Request.Builder()        .header("Authorization", "Client-ID " + IMGUR_CLIENT_ID)        .url("https://api.imgur.com/3/image")        .post(requestBody)        .build();    Response response = client.newCall(request).execute();    if (!response.isSuccessful()) throw new IOException("Unexpected code " + response);    System.out.println(response.body().string());  }

缓存响应设置

要设置缓存响应，你需要一个进行读取和写入的缓存目录，以及一个缓存大小的限制。缓存目录应该是私有的，且不被信任的应用不能够读取它的内容。让多个缓存同时访问相同的混存目录是错误的。大多数应用应该只调用一次new OkHttpClient()，配置它们的缓存，并在所有地方使用相同的实例。否则两个缓存实例会相互进行干涉。

同时OkHttp还支持对缓存的时间和大小进行设置。如添加像Cache-Control:max-stale=3600设置请求头缓存大小，使用Cache-Control:max-age=9600来配置响应缓存时间。

网络超时配置

网络部分可能是由于连接问题，服务器可用性问题或者其他原因造成网络请求超时。所以在使用时，可以根据实际情况进行网络的超时设置。

private final OkHttpClient client;  public ConfigureTimeouts() throws Exception {    client = new OkHttpClient.Builder()        .connectTimeout(10, TimeUnit.SECONDS)        .writeTimeout(10, TimeUnit.SECONDS)        .readTimeout(30, TimeUnit.SECONDS)        .build();  }  public void run() throws Exception {    Request request = new Request.Builder()        .url("http://httpbin.org/delay/2") // This URL is served with a 2 second delay.        .build();    Response response = client.newCall(request).execute();    System.out.println("Response completed: " + response);  }

取消请求

OkHttp支持取消网络请求，使用Call.cancel()来立即停止一个正在进行的调用。如果一个线程正在写请求或读响应，它会接收到一个IOException，同步和异步调用都可以取消。

private final ScheduledExecutorService executor = Executors.newScheduledThreadPool(1);  private final OkHttpClient client = new OkHttpClient();  public void run() throws Exception {    Request request = new Request.Builder()        .url("http://httpbin.org/delay/2") // This URL is served with a 2 second delay.        .build();    final long startNanos = System.nanoTime();    final Call call = client.newCall(request);    // Schedule a job to cancel the call in 1 second.    executor.schedule(new Runnable() {      @Override public void run() {        System.out.printf("%.2f Canceling call.%n", (System.nanoTime() - startNanos) / 1e9f);        call.cancel();        System.out.printf("%.2f Canceled call.%n", (System.nanoTime() - startNanos) / 1e9f);      }    }, 1, TimeUnit.SECONDS);    try {      System.out.printf("%.2f Executing call.%n", (System.nanoTime() - startNanos) / 1e9f);      Response response = call.execute();      System.out.printf("%.2f Call was expected to fail, but completed: %s%n",          (System.nanoTime() - startNanos) / 1e9f, response);    } catch (IOException e) {      System.out.printf("%.2f Call failed as expected: %s%n",          (System.nanoTime() - startNanos) / 1e9f, e);    }  }

认证请求

如果网络请求涉及到认证机制，OkHttp也提供了Authenticator来进行应用证书认证，Authenticator的实现应该构建一个包含缺失证书的新请求，如果没有证书可用，返回null来跳过重试。

使用Response.challenges()来获取所有认证挑战的模式和领域。当完成一个Basic挑战时，使用Credentials.basic(username，password)来编码请求头。涉及的示例如下：

private final OkHttpClient client;  public Authenticate() {    client = new OkHttpClient.Builder()        .authenticator(new Authenticator() {          @Override public Request authenticate(Route route, Response response) throws IOException {            System.out.println("Authenticating for response: " + response);            System.out.println("Challenges: " + response.challenges());            String credential = Credentials.basic("jesse", "password1");            return response.request().newBuilder()                .header("Authorization", credential)                .build();          }        })        .build();  }  public void run() throws Exception {    Request request = new Request.Builder()        .url("http://publicobject.com/secrets/hellosecret.txt")        .build();    Response response = client.newCall(request).execute();    if (!response.isSuccessful()) throw new IOException("Unexpected code " + response);    System.out.println(response.body().string());  }

OkHttp的Call

OkHttp支持重写，重定向，跟进和重试，OkHttp会使用Call来模化满足请求的任务，然而中间的请求和响应是必要的。OkHttp提供了两种方式的Call：

Synchronous：线程会阻塞直到响应可读；
Asynchronous：在一个线程中入队请求，当你的响应可读时在另外一个线程获取回调。

请求可以从任何线程取消，如果请求还没有执行完成，会使请求失败，请求失败会出现IOException异常错误。

OkHttp支持同步和异步方式请求，对于同步调用，使用的是自己的线程并对管理你同时创建多少请求负责。对于异步调用，Dispatcher实现了最大并发请求的策略，你可以设置每个服务器最大值(默认是5)和所有最大值(默认是64)。

OkHttp网络链接

在使用OkHttp进行请求的时候，我们只需要提供请求的url地址即可实现网络的访问，其实OkHttp在规划连接服务器的连接时提供了三种类型：URL，Address和Route。
下面就分别来说一下这三种链接的关系即使用场合。

URL

URL是HTTP和网络的最基本的联系方式，成为统一资源定位符，URL是一个抽象的概念。

它们规定了调用可能是明文(http)或密文(https)，但是没有规定应该使用哪个加密算法。也没有规定如何验证对等的证书(HostnameVerifier)或者哪个证书可被信任(SSLSocketFactory)。
每一个URL确定一个特定路径，每个服务器包含很多的URL。

Addresses

在OkHttp中，Addresses规定了服务器和所有连接服务器需要的静态配置：端口号，HTTPS设置和优先网络协议(如HTTP/2或SPDY)。共享相同address的URLs也可能共享相同的下层TCP socket连接。
共享一个连接有巨大的性能好处：低延迟，高吞吐量(因为TCP启动慢)和节省电源。OkHttp使用ConnectionPool来自动复用HTTP/1.X连接和多路传输HTTP/2和SPDY连接。

在OkHttp中，address的一些字段来自URL(机制，主机名，端口)，剩下的来自OkHttpClient。

Routes

Routes提供了真正连接到服务器所需要的动态信息，它会Routes明确的要尝试的IP地址以及代理服务器，以及什么版本的TLS来协商(针对HTTPS连接)。

对于一个地址有可能有很多路由，一个存在多个数据中心的网络服务器可能在它的DNS响应中产生多个IP地址。

OkHttp网络连接流程

当你使用OkHttp请求一个URL时，下面是它执行的流程：
1. 它使用URL和配置的OkHttpClient来创建一个address，这个address规定了如何连接到服务器。
2. OkHttp尝试使用这个address从连接池中获取一个连接。
3. 如果它没有在池中找到一个连接，它会选择一个route来尝试。这通常意味着创建一个DNS请求来获取服务器的IP地址。
4. 如果这是一个新route，它会通过构建一个直接的socket连接或一个TLS隧道或一个直接的TLS连接来进行连接。如果需要它会执行TLS握手。
5. 然后发送HTTP请求然后读取响应。

当连接出现问题时，OkHttp会选择另外一个route进行尝试。一旦接收到服务端的响应，连接就会返回到池中，这样它可以在之后的请求复用，连接空闲一段时间会从池中移除。

拦截器

看过OkHttp源码分析的同学对于拦截器肯定不会陌生，在OkHttp中拦截器是所有的网络请求的必经之地，拦截器主要有以下一些作用。

1、拦截器可以一次性对所有的请求和返回值进行修改；
2、拦截器可以一次性对请求的参数和返回的结果进行编码，比如统一设置为UTF-8；
3、拦截器可以对所有的请求做统一的日志记录，不需要在每个请求开始或者结束的位置都添加一个日志操作；
4、其他需要对请求和返回进行统一处理的需求….

下面是一个最简单的拦截器使用，用来打印OkHttp的请求和收到的响应。

class LoggingInterceptor implements Interceptor {  @Override public Response intercept(Interceptor.Chain chain) throws IOException {    Request request = chain.request();    long t1 = System.nanoTime();    logger.info(String.format("Sending request %s on %s%n%s",        request.url(), chain.connection(), request.headers()));    Response response = chain.proceed(request);    long t2 = System.nanoTime();    logger.info(String.format("Received response for %s in %.1fms%n%s",        response.request().url(), (t2 - t1) / 1e6d, response.headers()));    return response;  }}

OkHttp使用列表来跟踪拦截器，并且拦截器按顺序被调用。栖拦截的模型如下：

OkHttp中的拦截器分为两类：APP层面的拦截器（Application Interception）、网络请求层面的拦截器(Network Interception)。在OkHttp中，首先从App Interceptor开始，然后执行Network Interceptor，最后又回到App Interceptor。

应用拦截器

下面我们使用OkHttpCleint.Builder上调用addInterceptor()来注册一个应用拦截器。代码如下：

OkHttpClient client = new OkHttpClient.Builder()    .addInterceptor(new LoggingInterceptor())    .build();Request request = new Request.Builder()    .url("http://www.publicobject.com/helloworld.txt")    .header("User-Agent", "OkHttp Example")    .build();Response response = client.newCall(request).execute();response.body().close();

如果我们需要将http://www.publicobject.com/helloworld.txt这个URL重定向到https://publicobject.com/helloworld.txt，那么OkHttp会自动跟进这个重定向。下面是重定向的相关的执行信息：

INFO: Sending request http://www.publicobject.com/helloworld.txt on nullUser-Agent: OkHttp ExampleINFO: Received response for https://publicobject.com/helloworld.txt in 1179.7msServer: nginx/1.4.6 (Ubuntu)Content-Type: text/plainContent-Length: 1759Connection: keep-alive

通过日志，我们可以看到OkHttp已经重定向了，可以通过引文reponse.request().url()与request.url()不同来区分。我们发现，应用拦截器只会被调用一次，并且从chain.proceed()返回的响应是重定向后的响应。

网络拦截器

注册一个网络拦截器很相似，调用addNetworkInterceptor()替代addInterceptor()。同样是上面的实例：

OkHttpClient client = new OkHttpClient.Builder()    .addNetworkInterceptor(new LoggingInterceptor())    .build();Request request = new Request.Builder()    .url("http://www.publicobject.com/helloworld.txt")    .header("User-Agent", "OkHttp Example")    .build();Response response = client.newCall(request).execute();response.body().close();

当我们运行这个代码，拦截器会执行两次：一次是访问http://www.publicobject.com/helloworld.txt的初始请求，另外一个是重定向到https://publicobject.com/helloworld.txt。

INFO: Sending request http://www.publicobject.com/helloworld.txt on Connection{www.publicobject.com:80, proxy=DIRECT hostAddress=54.187.32.157 cipherSuite=none protocol=http/1.1}User-Agent: OkHttp ExampleHost: www.publicobject.comConnection: Keep-AliveAccept-Encoding: gzipINFO: Received response for http://www.publicobject.com/helloworld.txt in 115.6msServer: nginx/1.4.6 (Ubuntu)Content-Type: text/htmlContent-Length: 193Connection: keep-aliveLocation: https://publicobject.com/helloworld.txtINFO: Sending request https://publicobject.com/helloworld.txt on Connection{publicobject.com:443, proxy=DIRECT hostAddress=54.187.32.157 cipherSuite=TLS_ECDHE_RSA_WITH_AES_256_CBC_SHA protocol=http/1.1}User-Agent: OkHttp ExampleHost: publicobject.comConnection: Keep-AliveAccept-Encoding: gzipINFO: Received response for https://publicobject.com/helloworld.txt in 80.9msServer: nginx/1.4.6 (Ubuntu)Content-Type: text/plainContent-Length: 1759Connection: keep-alive

网络请求也包含更多数据，例如通过OkHttp添加的Accept-Encoding:gzip头来通知支持响应压缩。网络拦截器的Chain有一个非空Connection，可以用来访问IP地址和用来连接网络服务器的TLS配置。

应用拦截器VS网络拦截器

选择哪种拦截器需要根据实际情况，每种拦截器chain都有自己相对的优势。

应用拦截器

不需要关心像重定向和重试这样的中间响应；
总是调用一次，即使HTTP响应从缓存中获取服务；
监视应用原始意图。不关心OkHttp注入的像If-None-Match头；
允许短路并不调用Chain.proceed()；
允许重试并执行多个Chain.proceed()调用。

网络拦截器

可以操作像重定向和重试这样的中间响应；
对于短路网络的缓存响应不会调用；
监视即将要通过网络传输的数据；
访问运输请求的Connection。

重写请求

拦截器支持添加，移除或替换请求头，如果有请求主体，它们也可以改变。例如，如果你连接一个已知支持请求主体压缩的网络服务器，你还可以使用一个应用拦截器来添加请求主体压缩。

final class GzipRequestInterceptor implements Interceptor {  @Override public Response intercept(Interceptor.Chain chain) throws IOException {    Request originalRequest = chain.request();    if (originalRequest.body() == null || originalRequest.header("Content-Encoding") != null) {      return chain.proceed(originalRequest);    }    Request compressedRequest = originalRequest.newBuilder()        .header("Content-Encoding", "gzip")        .method(originalRequest.method(), gzip(originalRequest.body()))        .build();    return chain.proceed(compressedRequest);  }  private RequestBody gzip(final RequestBody body) {    return new RequestBody() {      @Override public MediaType contentType() {        return body.contentType();      }      @Override public long contentLength() {        return -1; // We don't know the compressed length in advance!      }      @Override public void writeTo(BufferedSink sink) throws IOException {        BufferedSink gzipSink = Okio.buffer(new GzipSink(sink));        body.writeTo(gzipSink);        gzipSink.close();      }    };  }}

重写响应

当然，拦截器也可以重写响应头并且改变响应主体。如果你在一个棘手的环境下并准备处理结果，重写响应头是一个解决问题强大的方式。

private static final Interceptor REWRITE_CACHE_CONTROL_INTERCEPTOR = new Interceptor() {  @Override public Response intercept(Interceptor.Chain chain) throws IOException {    Response originalResponse = chain.proceed(chain.request());    return originalResponse.newBuilder()        .header("Cache-Control", "max-age=60")        .build();  }};

OkHttp使用Https

关于Https及其工作的流程本文不做任何的介绍，本文主要介绍在OkHttp中如何使用Https进行网络校验即请求。在使用OkHttpClient初始化OkHttpClient对象时，有两个关键的地方需要注意：hostnameVerifier和sslSocketFactory。

OkHttpClient okHttpClient = new OkHttpClient.Builder()                .connectTimeout(20000L, TimeUnit.MILLISECONDS)                .readTimeout(20000L, TimeUnit.MILLISECONDS)                .addInterceptor(new LoggerInterceptor("TAG"))                .hostnameVerifier(new HostnameVerifier() {                    @Override                    public boolean verify(String hostname, SSLSession session) {                        return true;                    }                })                .sslSocketFactory(sslParams.sSLSocketFactory,sslParams.trustManager)                .build();

其中sslSocketFactory传入两个参数，一个是SSLSocketFactory,另一个是TrustManager,通常都是写一个HttpsUtils，里面持有这两个对象，读取本地的一个证书，进行相关初始化赋值动作。 hostnameVerifier则是对服务端返回的一些信息进行相关校验的地方，用于客户端判断所连接的服务端是否可信，通常默认return true。

public boolean verify(String host, X509Certificate certificate) {    return verifyAsIpAddress(host)        ? verifyIpAddress(host, certificate)        : verifyHostname(host, certificate);  }

OkHttp的验证逻辑

对于一个android开发者来说，目前的网络请求框架大部分都是使用okhttp进行网络请求的，所以了解okhttp是如何具体工作的对于我们平时开发有很大的帮助的。当我们使用https进行网络请求的时候最终进行连接的类是RealConnection，该类的关键代码如下：

private void connectTls(int readTimeout, int writeTimeout,      ConnectionSpecSelector connectionSpecSelector) throws IOException {    Address address = route.address();    SSLSocketFactory sslSocketFactory = address.sslSocketFactory();    boolean success = false;    SSLSocket sslSocket = null;    try {      // Create the wrapper over the connected socket.    //创建Socket      sslSocket = (SSLSocket) sslSocketFactory.createSocket(          rawSocket, address.url().host(), address.url().port(), true /* autoClose */);      // Configure the socket's ciphers, TLS versions, and extensions.      ConnectionSpec connectionSpec = connectionSpecSelector.configureSecureSocket(sslSocket);      if (connectionSpec.supportsTlsExtensions()) {        Platform.get().configureTlsExtensions(            sslSocket, address.url().host(), address.protocols());      }      // Force handshake. This can throw!        //初次握手      sslSocket.startHandshake();      Handshake unverifiedHandshake = Handshake.get(sslSocket.getSession());      // Verify that the socket's certificates are acceptable for the target host.    //校验，回调hostnameVerifier.verify方法      if (!address.hostnameVerifier().verify(address.url().host(), sslSocket.getSession())) {        X509Certificate cert = (X509Certificate) unverifiedHandshake.peerCertificates().get(0);        throw new SSLPeerUnverifiedException("Hostname " + address.url().host() + " not verified:"            + "\n    certificate: " + CertificatePinner.pin(cert)            + "\n    DN: " + cert.getSubjectDN().getName()            + "\n    subjectAltNames: " + OkHostnameVerifier.allSubjectAltNames(cert));      }      // Check that the certificate pinner is satisfied by the certificates presented.      address.certificatePinner().check(address.url().host(),          unverifiedHandshake.peerCertificates());

在该类中，我们主要关心的地方也是在初次握手建立连接和本地校验的那，正常情况下，我们在调用https地址的时候会先连接，就是调到上面代码的位置，之后执行初次握手，回调验证服务端是否可信，然后在进行正常的网络请求。如果在这个过程中出现异常，就会报一个证书信任的问题，出现这种情况有两方面，一是客户端验证服务端，二是服务端验证客户端。

证书获取

下面介绍下证书获取的相关内容，证书校验主要用到了hostnameVerifier.verify()，该方法的源码如下：

@Override public boolean verify(String hostname, SSLSession session) {       Certificate[] localCertificates = new Certificate[0];       try {     //获取证书链中的所有证书           localCertificates = session.getPeerCertificates();         } catch (SSLPeerUnverifiedException e) {                e.printStackTrace();           }    //打印所有证书内容        for (Certificate c : localCertificates) {          Log.d(TAG, "verify: "+c.toString());        }     try {    //将证书链中的第一个写到文件           createFileWithByte(localCertificates[0].getEncoded());            } catch (CertificateEncodingException e) {              e.printStackTrace();            }       return true;       }    //写到文件    private void createFileWithByte(byte[] bytes) {        // TODO Auto-generated method stub        /**         * 创建File对象，其中包含文件所在的目录以及文件的命名         */        File file = new File(Environment.getExternalStorageDirectory(),                "ca.cer");        // 创建FileOutputStream对象        FileOutputStream outputStream = null;        // 创建BufferedOutputStream对象        BufferedOutputStream bufferedOutputStream = null;        try {            // 如果文件存在则删除            if (file.exists()) {                file.delete();            }            // 在文件系统中根据路径创建一个新的空文件            file.createNewFile();            // 获取FileOutputStream对象            outputStream = new FileOutputStream(file);            // 获取BufferedOutputStream对象            bufferedOutputStream = new BufferedOutputStream(outputStream);            // 往文件所在的缓冲输出流中写byte数据            bufferedOutputStream.write(bytes);            // 刷出缓冲输出流，该步很关键，要是不执行flush()方法，那么文件的内容是空的。            bufferedOutputStream.flush();        } catch (Exception e) {            // 打印异常信息            e.printStackTrace();        } finally {            // 关闭创建的流对象            if (outputStream != null) {                try {                    outputStream.close();                } catch (IOException e) {                    e.printStackTrace();                }            }            if (bufferedOutputStream != null) {                try {                    bufferedOutputStream.close();                } catch (Exception e2) {                    e2.printStackTrace();                }            }        }    }

hostnameVerifier主要有两个参数，一个是hostname就是你请求地址的host，session则包括了从服务端返回的证书链。
证书链通常有三个，第一个是我们自己的，然后也能在本地看到证书文件。包含一些相关信息，包括公钥，颁发机构等，最为严苛的方式就是可以从本地读取一个证书，取公钥与服务器返回的证书公钥进行对比。

但是证书也不是完全安全的，CertificatePinner就是一个用来限制哪些证书和证书颁发机构可以被信任。证书锁定提升安全性，但是限制你的服务器团队更新他们的TLS证书的能力。例如：

public CertificatePinning() {    client = new OkHttpClient.Builder()        .certificatePinner(new CertificatePinner.Builder()            .add("publicobject.com", "sha256/afwiKY3RxoMmLkuRW1l7QsPZTJPwDS2pdDROQjXw8ig=")            .build())        .build();  }  public void run() throws Exception {    Request request = new Request.Builder()        .url("https://publicobject.com/robots.txt")        .build();    Response response = client.newCall(request).execute();    if (!response.isSuccessful()) throw new IOException("Unexpected code " + response);    for (Certificate certificate : response.handshake().peerCertificates()) {      System.out.println(CertificatePinner.pin(certificate));    }  }

自定义可信任的证书

当然，也可以使用自定义的证书来替换主机的证书，然后使用sslSocketFactory函数进行设置。

private final OkHttpClient client;  public CustomTrust() {    SSLContext sslContext = sslContextForTrustedCertificates(trustedCertificatesInputStream());    client = new OkHttpClient.Builder()        .sslSocketFactory(sslContext.getSocketFactory())        .build();  }  public void run() throws Exception {    Request request = new Request.Builder()        .url("https://publicobject.com/helloworld.txt")        .build();    Response response = client.newCall(request).execute();    System.out.println(response.body().string());  }  private InputStream trustedCertificatesInputStream() {    ... // Full source omitted. See sample.  }  public SSLContext sslContextForTrustedCertificates(InputStream in) {    ... // Full source omitted. See sample.  }

SSLSocketFactory

安全套接层工厂，用于创建SSLSocket，默认的SSLSocket是信任手机内置信任的证书列表，我们可以通过OKHttpClient.Builder的sslSocketFactory方法定义自己的信任策略。下面是加载SSLSocketFactory的相关代码：

public static SSLSocketFactory getSSLSocketFactory(InputStream... certificates) {        try {//用我们的证书创建一个keystore            CertificateFactory certificateFactory = CertificateFactory.getInstance("X.509");            KeyStore keyStore = KeyStore.getInstance(KeyStore.getDefaultType());            keyStore.load(null);            int index = 0;            for (InputStream certificate : certificates) {                String certificateAlias = "server"+Integer.toString(index++);                keyStore.setCertificateEntry(certificateAlias, certificateFactory.generateCertificate(certificate));                try {                    if (certificate != null) {                        certificate.close();                    }                } catch (IOException e) {                    e.printStackTrace();                }            }//创建一个trustmanager，只信任我们创建的keystore            SSLContext sslContext = SSLContext.getInstance("TLS");            TrustManagerFactory trustManagerFactory =                    TrustManagerFactory.getInstance(TrustManagerFactory.getDefaultAlgorithm());            trustManagerFactory.init(keyStore);            sslContext.init(                    null,                    trustManagerFactory.getTrustManagers(),                    new SecureRandom()            );            return sslContext.getSocketFactory();        } catch (Exception e) {            e.printStackTrace();            return null;        }    }

X509TrustManager

public interface X509TrustManager extends TrustManager {    void checkClientTrusted(X509Certificate[] var1, String var2) throws CertificateException;    void checkServerTrusted(X509Certificate[] var1, String var2) throws CertificateException;    X509Certificate[] getAcceptedIssuers();}

HostnameVerifier

HostnameVerifier的接口定义如下：

public interface HostnameVerifier {    boolean verify(String var1, SSLSession var2);}

这个接口主要实现对于域名的校验，OKHTTP实现了一个OkHostnameVerifier，对于证书中的IP及Host做了各种正则匹配，默认情况下使用的是这个策略。相关代码如下：

OKHttpClient.Builder.hostnameVerifier(new HostnameVerifier() {                    @Override                    public boolean verify(String hostname, SSLSession session) {                        return true;                    }                })

在实际使用中可以将上面的东西封装起来，例如：

   public class SSLSocketClient{     //获取这个SSLSocketFactory      public static SSLSocketFactory getSSLSocketFactory(){         try{             SSLContext sslContext = SSLContext.getInstance("SSL");            sslContext.init(null, getTrustManager(), new SecureRandom());             return sslContext.getSocketFactory();        }         catch (Exception e){             throw new RuntimeException(e);        }     }   //获取TrustManager       private static TrustManager[] getTrustManager(){         TrustManager[] trustAllCerts = new TrustManager[]{new X509TrustManager(){            @Override            public void checkClientTrusted(X509Certificate[] chain, String authType){            }            @Override            public void checkServerTrusted(X509Certificate[] chain, String authType){            }            @Override            public X509Certificate[] getAcceptedIssuers(){                 return new X509Certificate[]{};             }        }};         return trustAllCerts;    }    //获取HostnameVerifier       public static HostnameVerifier getHostnameVerifier(){        HostnameVerifier hostnameVerifier = new HostnameVerifier(){            @Override            public boolean verify(String s, SSLSession sslSession){                return true;            }        };         return hostnameVerifier;     } }

然后在需要使用的使用的地方

OkHttpClient.Builder builder=new OkHttpClient.Builder();...builder.sslSocketFactory(SSLSocketClient.getSSLSocketFactory();builder.hostnameVerifier(SSLSocketClient.getHostnameVerifier();

OkHttp基础概念解释

OkHttp简介

使用示例

同步Get请求

异步Get请求

设置Header

上传字符串

文件上传

上传表格参数

多部分请求

缓存响应设置

网络超时配置

取消请求

认证请求

OkHttp的Call

OkHttp网络链接

URL

Addresses

Routes

OkHttp网络连接流程

拦截器

应用拦截器

网络拦截器

应用拦截器VS网络拦截器

应用拦截器

网络拦截器

重写请求

重写响应

OkHttp使用Https

OkHttp的验证逻辑

证书获取

自定义可信任的证书

SSLSocketFactory

X509TrustManager

HostnameVerifier

更多相关文章

随机推荐