参考
Android网络请求心路历程
Android Http接地气网络请求（HttpURLConnection）
一、对比
参考okhttp,retrofit,android-async-http,volley应该选择哪一个
HttpURLConnection
HttpURLConnection是一种多用途、轻量极的HTTP客户端，使用它来进行HTTP操作可以适用于大多数的应用程序。虽然HttpURLConnection的API提供的比较简单，但是同时这也使得我们可以更加容易地去使用和扩展它。从Android4.4开始HttpURLConnection的底层实现采用的是okHttp。HttpClient
Apache HttpClient早就不推荐httpclient，5.0之后干脆废弃，后续会删除。6.0删除了HttpClient。OkHttp
okhttp是高性能的http库，支持同步、异步，而且实现了spdy、http2、websocket协议，api很简洁易用，和volley一样实现了http协议的缓存。picasso就是利用okhttp的缓存机制实现其文件缓存，实现的很优雅，很正确，反例就是UIL（universal image loader），自己做的文件缓存，而且不遵守http缓存机制。volley
volley是一个简单的异步http库，仅此而已。缺点是不支持同步，这点会限制开发模式。自带缓存，支持自定义请求。不适合大文件上传和下载。
Volley在Android 2.3及以上版本，使用的是HttpURLConnection，而在Android 2.2及以下版本，使用的是HttpClient。
Volley自己的定位是轻量级网络交互，适合大量的，小数据传输。
不过再怎么封装Volley在功能拓展性上始终无法与OkHttp相比。Volley停止了更新，而OkHttp得到了官方的认可，并在不断优化。android-async-http。
与volley一样是异步网络库，但volley是封装的httpUrlConnection，它是封装的httpClient，而android平台不推荐用HttpClient了，所以这个库已经不适合android平台了。Retrofit
Retrofit 是一个 RESTful 的 HTTP 网络请求框架的封装。注意这里并没有说它是网络请求框架，主要原因在于网络请求的工作并不是 Retrofit 来完成的。Retrofit 2.0 开始内置 OkHttp，前者专注于接口的封装，后者专注于网络请求的高效，二者分工协作，宛如古人的『你耕地来我织布』，小日子别提多幸福了。参考深入浅出 Retrofit
retrofit与picasso一样都是在okhttp基础之上做的封装，项目中可以直接用了。Retrofit因为也是square出的，所以大家可能对它更崇拜些。Retrofit的跟Volley是一个套路，但解耦的更彻底:比方说通过注解来配置请求参数，通过工厂来生成CallAdapter，Converter，你可以使用不同的请求适配器(CallAdapter), 比方说RxJava，Java8, Guava。你可以使用不同的反序列化工具(Converter)，比方说json, protobuff, xml, moshi等等。炒鸡解耦，里面涉及到超多设计模式，个人觉得是很经典的学习案例。虽然支持Java8， Guava你可能也不需要用到。xml，protobuff等数据格式你也可能不需要解析。but，万一遇到鬼了呢。至于性能上，个人觉得这完全取决于请求client，也就是okhttp的性能，跟这些封装工具没太大关系。
二、HttpURLConnection
1.简单封装
public class NetUtils
{
public static String post(String url, String content) {
HttpURLConnection conn = null;
try {
// 创建一个URL对象
URL mURL = new URL(url);
// 调用URL的openConnection()方法,获取HttpURLConnection对象
conn = (HttpURLConnection) mURL.openConnection();
conn.setRequestMethod("POST");// 设置请求方法为post
conn.setReadTimeout(5000);// 设置读取超时为5秒
conn.setConnectTimeout(10000);// 设置连接网络超时为10秒
conn.setDoOutput(true);// 设置此方法,允许向服务器输出内容
// post请求的参数
String data = content;
// 获得一个输出流,向服务器写数据,默认情况下,系统不允许向服务器输出内容
OutputStream out = conn.getOutputStream();// 获得一个输出流,向服务器写数据
out.write(data.getBytes());
out.flush();
out.close();
int responseCode = conn.getResponseCode();// 调用此方法就不必再使用conn.connect()方法
if (responseCode == 200) {
InputStream is = conn.getInputStream();
String response = getStringFromInputStream(is);
return response;
} else {
throw new NetworkErrorException("response status is "+responseCode);
}
} catch (Exception e) {
e.printStackTrace();
} finally {
if (conn != null) {
conn.disconnect();// 关闭连接
}
}
return null;
}
public static String get(String url) {
HttpURLConnection conn = null;
try {
// 利用string url构建URL对象
URL mURL = new URL(url);
conn = (HttpURLConnection) mURL.openConnection();
conn.setRequestMethod("GET");
conn.setReadTimeout(5000);
conn.setConnectTimeout(10000);
int responseCode = conn.getResponseCode();
if (responseCode == 200) {
InputStream is = conn.getInputStream();
String response = getStringFromInputStream(is);
return response;
} else {
throw new NetworkErrorException("response status is "+responseCode);
}
} catch (Exception e) {
e.printStackTrace();
} finally {
if (conn != null) {
conn.disconnect();
}
}
return null;
}
private static String getStringFromInputStream(InputStream is) throws IOException {
ByteArrayOutputStream os = new ByteArrayOutputStream();
// 模板代码 必须熟练
byte[] buffer = new byte[1024];
int len = -1;
while ((len = is.read(buffer)) != -1) {
os.write(buffer, 0, len);
}
is.close();
String state = os.toString();// 把流中的数据转换成字符串,采用的编码是utf-8(模拟器默认编码)
os.close();
return state;
}
}
注意网络权限！被坑了多少次。
<uses-permission android:name="android.permission.INTERNET"/>
异步通常伴随者他的好基友回调。这是通过回调封装的Utils类。
public class AsynNetUtils {
public interface Callback{
void onResponse(String response);
}
public static void get(final String url, final Callback callback){
final Handler handler = new Handler();
new Thread(new Runnable() {
@Override
public void run() {
final String response = NetUtils.get(url);
handler.post(new Runnable() {
@Override
public void run() {
callback.onResponse(response);
}
});
}
}).start();
}
public static void post(final String url, final String content, final Callback callback){
final Handler handler = new Handler();
new Thread(new Runnable() {
@Override
public void run() {
final String response = NetUtils.post(url,content);
handler.post(new Runnable() {
@Override
public void run() {
callback.onResponse(response);
}
});
}
}).start();
}
}
使用方法
private TextView textView;
@Override
protected void onCreate(Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
setContentView(R.layout.activity_main);
textView = (TextView) findViewById(R.id.webview);
AsynNetUtils.get("http://www.baidu.com", new AsynNetUtils.Callback() {
@Override
public void onResponse(String response) {
textView.setText(response);
}
});
}
嗯，一个蠢到哭的网络请求方案成型了。愚蠢的地方有很多：
- 每次都new Thread，new Handler消耗过大
- 没有异常处理机制
- 没有缓存机制
- 没有完善的API(请求头,参数,编码,拦截器等)与调试模式
- 没有Https
2.HTTP缓存机制
参考HTTP缓存机制
缓存对于移动端是非常重要的存在。
- 减少请求次数，减小服务器压力.
- 本地数据读取速度更快，让页面不会空白几百毫秒。
- 在无网络的情况下提供数据。
三、OkHttp
参考
OkHttp使用介绍
Okhttp使用详解
OKHttp源码解析
先看一下四大核心类：OkHttpClient、Request、Call 和 Response。
1.OkHttpClient
OkHttpClient表示了HTTP请求的客户端类，在绝大多数的App中，我们只应该执行一次new OkHttpClient()，将其作为全局的实例进行保存，从而在App的各处都只使用这一个实例对象，这样所有的HTTP请求都可以共用Response缓存、共用线程池以及共用连接池。
默认情况下，直接执行OkHttpClient client = new OkHttpClient()就可以实例化一个OkHttpClient对象。
可以配置OkHttpClient的一些参数，比如超时时间、缓存目录、代理、Authenticator等，那么就需要用到内部类OkHttpClient.Builder，设置如下所示：
OkHttpClient client = new OkHttpClient.Builder().
readTimeout(30, TimeUnit.SECONDS).
cache(cache).
proxy(proxy).
authenticator(authenticator).
build();
OkHttpClient本身不能设置参数，需要借助于其内部类Builder设置参数，参数设置完成后，调用Builder的build方法得到一个配置好参数的OkHttpClient对象。这些配置的参数会对该OkHttpClient对象所生成的所有HTTP请求都有影响。
有时候我们想单独给某个网络请求设置特别的几个参数，比如只想让某个请求的超时时间设置为一分钟，但是还想保持OkHttpClient对象中的其他的参数设置，那么可以调用OkHttpClient对象的newBuilder()方法，代码如下所示：
OkHttpClient client = ...
OkHttpClient clientWith60sTimeout = client.newBuilder().
readTimeout(60, TimeUnit.SECONDS).
build();
clientWith60sTimeout中的参数来自于client中的配置参数，只不过它覆盖了读取超时时间这一个参数，其余参数与client中的一致。
2.Request
Request类封装了请求报文信息：请求的Url地址、请求的方法（如GET、POST等）、各种请求头（如Content-Type、Cookie）以及可选的请求体。一般通过内部类Request.Builder的链式调用生成Request对象。
3.Call
Call代表了一个实际的HTTP请求，它是连接Request和Response的桥梁，通过Request对象的newCall()方法可以得到一个Call对象。Call对象既支持同步获取数据，也可以异步获取数据。
执行Call对象的execute()方法，会阻塞当前线程去获取数据，该方法返回一个Response对象。
执行Call对象的enqueue()方法，不会阻塞当前线程，该方法接收一个Callback对象，当异步获取到数据之后，会回调执行Callback对象的相应方法。如果请求成功，则执行Callback对象的onResponse方法，并将Response对象传入该方法中；如果请求失败，则执行Callback对象的onFailure方法。
4.Response
Response类封装了响应报文信息：状态吗（200、404等）、响应头（Content-Type、Server等）以及可选的响应体。可以通过Call对象的execute()方法获得Response对象，异步回调执行Callback对象的onResponse方法时也可以获取Response对象。
5.同步GET
以下示例演示了如何同步发送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());
}
下面对以上代码进行简单说明：
client执行newCall方法会得到一个Call对象，表示一个新的网络请求。Call对象的execute方法是同步方法，会阻塞当前线程，其返回Response对象。
通过Response对象的isSuccessful()方法可以判断请求是否成功。通过Response的headers()方法可以得到响应头Headers对象，可以通过for循环索引遍历所有的响应头的名称和值。可以通过Headers.name(index)方法获取响应头的名称，通过Headers.value(index)方法获取响应头的值。
除了索引遍历，通过Headers.get(headerName)方法也可以获取某个响应头的值，比如通过headers.get(“Content-Type”)获得服务器返回给客户端的数据类型。但是服务器返回给客户端的响应头中有可能有多个重复名称的响应头，比如在某个请求中，服务器要向客户端设置多个Cookie，那么会写入多个Set-Cookie响应头，且这些Set-Cookie响应头的值是不同的，访问百度首页，可以看到有7个Set-Cookie的响应头，如下图所示：
为了解决同时获取多个name相同的响应头的值，Headers中提供了一个public List<String> values(String name)方法，该方法会返回一个List<String>对象，所以此处通过Headers对象的values(‘Set-Cookie’)可以获取全部的Cookie信息，如果调用Headers对象的get(‘Set-Cookie’)方法，那么只会获取最后一条Cookie信息。
通过Response对象的body()方法可以得到响应体ResponseBody对象，调用其string()方法可以很方便地将响应体中的数据转换为字符串，该方法会将所有的数据放入到内存之中，所以如果数据超过1M，最好不要调用string()方法以避免占用过多内存，这种情况下可以考虑将数据当做Stream流处理。
6.异步GET
以下示例演示了如何异步发送GET网络请求，代码如下所示：
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());
}
});
}
下面对以上代码进行一下说明：
要想异步执行网络请求，需要执行Call对象的enqueue方法，该方法接收一个okhttp3.Callback对象，enqueue方法不会阻塞当前线程，会新开一个工作线程，让实际的网络请求在工作线程中执行。一般情况下这个工作线程的名字以“Okhttp”开头，并包含连接的host信息，比如上面例子中的工作线程的name是Okhttp http://publicobject.com/...
当异步请求成功后，会回调Callback对象的onResponse方法，在该方法中可以获取Response对象。当异步请求失败或者调用了Call对象的cancel方法时，会回调Callback对象的onFailure方法。onResponse和onFailure这两个方法都是在工作线程中执行的。
7.请求头和响应头
典型的HTTP请求头、响应头都是类似于Map<String, String>，每个name对应一个value值。不过像我们之前提到的，也会存在多个name重复的情况，比如相应结果中就有可能存在多个Set-Cookie响应头，同样的，也可能同时存在多个名称一样的请求头。响应头的读取我们在上文已经说过了，在此不再赘述。一般情况下，我们只需要调用header(name, value)方法就可以设置请求头的name和value，调用该方法会确保整个请求头中不会存在多个名称一样的name。如果想添加多个name相同的请求头，应该调用addHeader(name, value)方法，这样可以添加重复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"));
}
上面的代码通过addHeader方法添加了两个Accept请求头，且二者的值不同，这样服务器收到客户端发来的请求后，就知道客户端既支持application/json类型的数据，也支持application/vnd.github.v3+json类型的数据。
8.用POST发送String
可以使用POST方法发送请求体。下面的示例演示了如何将markdown文本作为请求体发送到服务器，服务器会将其转换成html文档，并发送给客户端。
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());
}
下面对以上代码进行说明：
Request.Builder的post方法接收一个RequestBody对象。
RequestBody就是请求体，一般可通过调用该类的5个重载的static的create()方法得到RequestBody对象。create()方法第一个参数都是MediaType类型，create()方法的第二个参数可以是String、File、byte[]或okio.ByteString。除了调用create()方法，还可以调用RequestBody的writeTo()方法向其写入数据，writeTo()方法一般在用POST发送Stream流的时候使用。
MediaType指的是要传递的数据的MIME类型，MediaType对象包含了三种信息：type、subtype以及CharSet，一般将这些信息传入parse()方法中，这样就能解析出MediaType对象，比如在上例中text/x-markdown; charset=utf-8，type值是text，表示是文本这一大类；/后面的x-markdown是subtype，表示是文本这一大类下的markdown这一小类；charset=utf-8则表示采用UTF-8编码。如果不知道某种类型数据的MIME类型，可以参见连接Media Types和MIME 参考手册，较详细地列出了所有的数据的MIME类型。以下是几种常见数据的MIME类型值：
- json ：application/json
- xml：application/xml
- png：image/png
- jpg： image/jpeg
- gif：image/gif
在该例中，请求体会放置在内存中，所以应该避免用该API发送超过1M的数据。
9.用POST发送Stream流
下面的示例演示了如何使用POST发送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());
}
下面对以上代码进行说明：
以上代码在实例化RequestBody对象的时候重写了contentType()和writeTo()方法。
覆写contentType()方法，返回markdown类型的MediaType。
覆写writeTo()方法，该方法会传入一个Okia的BufferedSink类型的对象，可以通过BufferedSink的各种write方法向其写入各种类型的数据，此例中用其writeUtf8方法向其中写入UTF-8的文本数据。也可以通过它的outputStream()方法，得到输出流OutputStream，从而通过OutputSteram向BufferedSink写入数据。
10.用POST发送File
下面的代码演示了如何用POST发送文件。
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());
}
我们之前提到，RequestBody.create()静态方法可以接收File参数，将File转换成请求体，将其传递给post()方法。
11.用POST发送Form表单中的键值对
如果想用POST发送键值对字符串，可以使用在post()方法中传入FormBody对象，FormBody继承自RequestBody，类似于Web前端中的Form表单。可以通过FormBody.Builder构建FormBody。示例代码如下所示：
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());
}
需要注意的是，在发送数据之前，Android会对非ASCII码字符调用encodeURIComponent方法进行编码，例如”Jurassic Park”会编码成”Jurassic%20Park”，其中的空格符被编码成%20了，服务器端会其自动解码。
12.用POST发送multipart数据
我们可以通过Web前端的Form表单上传一个或多个文件，Okhttp也提供了对应的功能，如果我们想同时发送多个Form表单形式的文件，就可以使用在post()方法中传入MultipartBody对象。MultipartBody继承自RequestBody，也表示请求体。只不过MultipartBody的内部是由多个part组成的，每个part就单独包含了一个RequestBody请求体，所以可以把MultipartBody看成是一个RequestBody的数组，而且可以分别给每个RequestBody单独设置请求头。
示例代码如下所示：
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());
}
下面对以上代码进行说明：
MultipartBody要通过其内部类MultipartBody.Builder进行构建。
通过MultipartBody.Builder的setType()方法设置MultipartBody的MediaType类型，一般情况下，将该值设置为MultipartBody.FORM，即W3C定义的multipart/form-data类型，详见Forms in HTML documents。
通过MultipartBody.Builder的方法addFormDataPart(String name, String value)或addFormDataPart(String name, String filename, RequestBody body)添加数据，其中前者添加的是字符串键值对数据，后者可以添加文件。
MultipartBody.Builder还提供了三个重载的addPart方法，其中通过addPart(Headers headers, RequestBody body)方法可以在添加RequestBody的时候，同时为其单独设置请求头。
13.用Gson处理JSON响应
Gson是Google开源的一个用于进行JSON处理的Java库，通过Gson可以很方面地在JSON和Java对象之间进行转换。我们可以将Okhttp和Gson一起使用，用Gson解析返回的JSON结果。
下面的示例代码演示了如何使用Gson解析GitHub API的返回结果。
private final OkHttpClient client = new OkHttpClient();
private final Gson gson = new Gson();
public void run() throws Exception {
Request request = new Request.Builder()
.url("https://api.github.com/gists/c2a7c39532239ff261be")
.build();
Response response = client.newCall(request).execute();
if (!response.isSuccessful())
throw new IOException("Unexpected code " + response);
Gist gist = gson.fromJson(response.body().charStream(), Gist.class);
for (Map.Entry<String, GistFile> entry : gist.files.entrySet()) {
System.out.println(entry.getKey());
System.out.println(entry.getValue().content);
}
}
static class Gist {
Map<String, GistFile> files;
}
static class GistFile {
String content;
}
下面对以上代码进行说明：
访问GitHub的https://api.github.com/gists/c2a7c39532239ff261be的返回结果如下所示：
Gist类对应着整个JSON的返回结果，Gist中的Map<String, GistFile> files对应着JSON中的files。
files中的每一个元素都是一个key-value的键值对，key是String类型，value是GistFile类型，并且GistFile中必须包含一个String content。OkHttp.txt就对应着一个GistFile对象，其content值就是GistFile中的content。
通过代码Gist gist = gson.fromJson(response.body().charStream(), Gist.class)，将JSON字符串转换成了Java对象。将ResponseBody的charStream方法返回的Reader传给Gson的fromJson方法，然后传入要转换的Java类的class。
14.缓存响应结果
如果想缓存响应结果，我们就需要为Okhttp配置缓存目录，Okhttp可以写入和读取该缓存目录，并且我们需要限制该缓存目录的大小。Okhttp的缓存目录应该是私有的，不能被其他应用访问。
Okhttp中，多个缓存实例同时访问同一个缓存目录会出错，大部分的应用只应该调用一次new OkHttpClient()，然后为其配置缓存目录，然后在App的各个地方都使用这一个OkHttpClient实例对象，否则两个缓存实例会互相影响，导致App崩溃。
缓存示例代码如下所示：
private final OkHttpClient client;
public CacheResponse(File cacheDirectory) throws Exception {
int cacheSize = 10 * 1024 * 1024; // 10 MiB
String okhttpCachePath = getCacheDir().getPath() + File.separator + "okhttp";
File okhttpCache = new File(okhttpCachePath);
if(!okhttpCache.exists()){
okhttpCache.mkdirs();
}
Cache cache = new Cache(okhttpCache, cacheSize);
client = new OkHttpClient.Builder()
.cache(cache)
.build();
}
public void run() throws Exception {
Request request = new Request.Builder()
.url("http://publicobject.com/helloworld.txt")
.build();
Response response1 = client.newCall(request).execute();
if (!response1.isSuccessful())
throw new IOException("Unexpected code " + response1);
String response1Body = response1.body().string();
System.out.println("Response 1 response: " + response1);
System.out.println("Response 1 cache response: " + response1.cacheResponse());
System.out.println("Response 1 network response: " + response1.networkResponse());
Response response2 = client.newCall(request).execute();
if (!response2.isSuccessful()) throw new IOException("Unexpected code " + response2);
String response2Body = response2.body().string();
System.out.println("Response 2 response: " + response2);
System.out.println("Response 2 cache response: " + response2.cacheResponse());
System.out.println("Response 2 network response: " + response2.networkResponse());
System.out.println("Response 2 equals Response 1? " +
response1Body.equals(response2Body));
}
下面对以上代码进行说明：
我们在App的cache目录下创建了一个子目录okhttp，将其作为Okhttp专门用于缓存的目录，并设置其上限为10M，Okhttp需要能够读写该目录。
不要让多个缓存实例同时访问同一个缓存目录，因为多个缓存实例会相互影响，导致出错，甚至系统崩溃。在绝大多数的App中，我们只应该执行一次new OkHttpClient()，将其作为全局的实例进行保存，从而在App的各处都只使用这一个实例对象，这样所有的HTTP请求都可以共用Response缓存。
上面代码，我们对于同一个URL，我们先后发送了两个HTTP请求。第一次请求完成后，Okhttp将请求到的结果写入到了缓存目录中，进行了缓存。response1.networkResponse()返回了实际的数据，response1.cacheResponse()返回了null，这说明第一次HTTP请求的得到的响应是通过发送实际的网络请求，而不是来自于缓存。然后对同一个URL进行了第二次HTTP请求，response2.networkResponse()返回了null，response2.cacheResponse()返回了缓存数据，这说明第二次HTTP请求得到的响应来自于缓存，而不是网络请求。
如果想让某次请求禁用缓存，可以调用
request.cacheControl(CacheControl.FORCE_NETWORK)方法，这样即便缓存目录有对应的缓存，也会忽略缓存，强制发送网络请求，这对于获取最新的响应结果很有用。如果想强制某次请求使用缓存的结果，可以调用
request.cacheControl(CacheControl.FORCE_CACHE)，这样不会发送实际的网络请求，而是读取缓存，即便缓存数据过期了，也会强制使用该缓存作为响应数据，如果缓存不存在，那么就返回504 Unsatisfiable Request错误。也可以向请求中中加入类似于Cache-Control: max-stale=3600之类的请求头，Okhttp也会使用该配置对缓存进行处理。
15.取消请求
当请求不再需要的时候，我们应该中止请求，比如退出当前的Activity了，那么在Activity中发出的请求应该被中止。可以通过调用Call的cancel方法立即中止请求，如果线程正在写入Request或读取Response，那么会抛出IOException异常。同步请求和异步请求都可以被取消。
示例代码如下所示：
private final ScheduledExecutorService executor = Executors.newScheduledThreadPool(1);
private final OkHttpClient client = new OkHttpClient();
public void run() throws Exception {
// This URL is served with a 2 second delay.
Request request = new Request.Builder()
.url("http://httpbin.org/delay/2")
.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);
}
}
上述请求，服务器端会有两秒的延时，在客户端发出请求1秒之后，请求还未完成，这时候通过cancel方法中止了Call，请求中断，并触发IOException
异常。
16.设置超时
一次HTTP请求实际上可以分为三步：
- 客户端与服务器建立连接
- 客户端发送请求数据到服务器，即数据上传
- 服务器将响应数据发送给客户端，即数据下载
由于网络、服务器等各种原因，这三步中的每一步都有可能耗费很长时间，导致整个HTTP请求花费很长时间或不能完成。
为此，可以通过OkHttpClient.Builder的connectTimeout()方法设置客户端和服务器建立连接的超时时间，通过writeTimeout()方法设置客户端上传数据到服务器的超时时间，通过readTimeout()方法设置客户端从服务器下载响应数据的超时时间。
在2.5.0版本之前，Okhttp默认不设置任何的超时时间，从2.5.0版本开始，Okhttp将连接超时、写入超时（上传数据）、读取超时（下载数据）的超时时间都默认设置为10秒。如果HTTP请求需要更长时间，那么需要我们手动设置超时时间。
示例代码如下所示：
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 {
// This URL is served with a 2 second delay.
Request request = new Request.Builder()
.url("http://httpbin.org/delay/2")
.build();
Response response = client.newCall(request).execute();
System.out.println("Response completed: " + response);
}
如果HTTP请求的某一部分超时了，那么就会触发异常。
17.处理身份验证
有些网络请求是需要用户名密码登录的，如果没提供登录需要的信息，那么会得到401 Not Authorized未授权的错误，这时候Okhttp会自动查找是否配置了Authenticator，如果配置过Authenticator，会用Authenticator中包含的登录相关的信息构建一个新的Request，尝试再次发送HTTP请求。
示例代码如下所示：
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());
}
上面对以上代码进行说明：
OkHttpClient.Builder的authenticator()方法接收一个Authenticator对象，我们需要实现Authenticator对象的authenticate()方法，该方法需要返回一个新的Request对象，该新的Request对象基于原始的Request对象进行拷贝，而且要通过header("Authorization", credential)方法对其设置登录授权相关的请求头信息。
通过Response对象的challenges()方法可以得到第一次请求失败的授权相关的信息。如果响应码是401 unauthorized，那么会返回”WWW-Authenticate”相关信息，这种情况下，要执行OkHttpClient.Builder的authenticator()方法，在Authenticator对象的authenticate()中 对新的Request对象调用header("Authorization", credential)方法，设置其Authorization请求头；如果Response的响应码是407 proxy unauthorized，那么会返回”Proxy-Authenticate”相关信息，表示不是最终的服务器要求客户端登录授权信息，而是客户端和服务器之间的代理服务器要求客户端登录授权信息，这时候要执行OkHttpClient.Builder的proxyAuthenticator()方法，在Authenticator对象的authenticate()中 对新的Request对象调用header("Proxy-Authorization", credential)方法，设置其Proxy-Authorization请求头。
如果用户名密码有问题，那么Okhttp会一直用这个错误的登录信息尝试登录，我们应该判断如果之前已经用该用户名密码登录失败了，就不应该再次登录，这种情况下需要让Authenticator对象的authenticate()方法返回null，这就避免了没必要的重复尝试，代码片段如下所示：
if (credential.equals(response.request().header("Authorization"))) {
return null;
}
18.ResponseBody
通过Response的body()方法可以得到响应体ResponseBody，响应体必须最终要被关闭，否则会导致资源泄露、App运行变慢甚至崩溃。
ResponseBody和Response都实现了Closeable和AutoCloseable接口，它们都有close()方法，Response的close()方法内部直接调用了ResponseBody的close()方法，无论是同步调用execute()还是异步回调onResponse()，最终都需要关闭响应体，可以通过如下方法关闭响应体：
- Response.close()
- Response.body().close()
- Response.body().source().close()
- Response.body().charStream().close()
- Response.body().byteString().close()
- Response.body().bytes()
- Response.body().string()
对于同步调用，确保响应体被关闭的最简单的方式是使用try代码块，如下所示：
Call call = client.newCall(request);
try (Response response = call.execute()) {
... // Use the response.
}
将Response response = call.execute()放入到try()的括号之中，由于Response 实现了Closeable和AutoCloseable接口，这样对于编译器来说，会隐式地插入finally代码块，编译器会在该隐式的finally代码块中执行Response的close()方法。
也可以在异步回调方法onResponse()中，执行类似的try代码块，try()代码块括号中的ResponseBody也实现了Closeable和AutoCloseable接口，这样编译器也会在隐式的finally代码块中自动关闭响应体，代码如下所示：
Call call = client.newCall(request);
call.enqueue(new Callback() {
public void onResponse(Call call, Response response) throws IOException {
try (ResponseBody responseBody = response.body()) {
... // Use the response.
}
}
public void onFailure(Call call, IOException e) {
... // Handle the failure.
}
});
响应体中的数据有可能很大，应该只读取一次响应体的数据。调用ResponseBody的bytes()或string()方法会将整个响应体数据写入到内存中，可以通过source()、byteStream()或charStream()进行流式处理。
