最近在整理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());
}
});
}
设置Header
典型的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 null
User-Agent: OkHttp Example
INFO: Received response for https://publicobject.com/helloworld.txt in 1179.7ms
Server: nginx/1.4.6 (Ubuntu)
Content-Type: text/plain
Content-Length: 1759
Connection: 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 Example
Host: www.publicobject.com
Connection: Keep-Alive
Accept-Encoding: gzip
INFO: Received response for http://www.publicobject.com/helloworld.txt in 115.6ms
Server: nginx/1.4.6 (Ubuntu)
Content-Type: text/html
Content-Length: 193
Connection: keep-alive
Location: https://publicobject.com/helloworld.txt
INFO: 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 Example
Host: publicobject.com
Connection: Keep-Alive
Accept-Encoding: gzip
INFO: Received response for https://publicobject.com/helloworld.txt in 80.9ms
Server: nginx/1.4.6 (Ubuntu)
Content-Type: text/plain
Content-Length: 1759
Connection: 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();
原创文章,作者:奋斗,如若转载,请注明出处:https://blog.ytso.com/tech/app/5960.html