Android你必须学会的okhttp3_百度文库
两大类热门资源免费畅读
续费一年阅读会员，立省24元！
Android你必须学会的okhttp3
||文档简介
中国移动互联网行业领军品牌|
总评分0.0|
&&Android你必须学会的okhttp3
阅读已结束，如果下载本文需要使用1下载券
想免费下载本文？
定制HR最喜欢的简历
下载文档到电脑，查找使用更方便
还剩1页未读，继续阅读
定制HR最喜欢的简历
你可能喜欢12463人阅读
Android进阶（46）
Android应用层（104）
讲完了Volley，我们接下来看看目前比较火的网络框架OkHttp， 它处理了很多网络疑难杂症：会从很多常用的连接问题中自动恢复。如果您的服务器配置了多个IP地址，当第一个IP连接失败的时候，OkHttp会自动尝试下一个IP，此外OkHttp还处理了代理服务器问题和SSL握手失败问题。
1.使用前准备
eclipse引入jar包地址：
Android Studio 配置gradle：
compile 'com.squareup.okhttp:okhttp:2.7.5'
compile 'com.squareup.okio:okio:1.7.0'
2.异步GET请求
最简单的get请求，老规矩请求百度：
private void getAsynHttp() {
OkHttpClient mOkHttpClient = new OkHttpClient();
final Request request = new Request.Builder()
Call call = mOkHttpClient.newCall(request);
call.enqueue(new Callback() {
public void onFailure(Request request, IOException e) {
public void onResponse(final Response response) throws IOException {
String str = response.body().string();
Log.i("wangshu", str);
runOnUiThread(new Runnable() {
public void run() {
Toast.makeText(getApplication(), "请求成功", Toast.LENGTH_SHORT).show();
运行程序log打印出来的是百度首页的html文件，基本的步骤很简单，就是创建OkHttpClient、Request和Call，最后调用Call的enqueue()方法。但是每次这么写肯定是很麻烦，肯定是要进行封装的。需要注意的是onResponse回调并不是在UI线程。
3.同步GET请求
private String getSyncHttp() throws IOException{
OkHttpClient mOkHttpClient = new OkHttpClient();
final Request request = new Request.Builder()
Call call = mOkHttpClient.newCall(request);
Response mResponse=call.execute();
if (mResponse.isSuccessful()) {
return mResponse.body().string();
throw new IOException("Unexpected code " + mResponse);
同步Get请求和异步调用区别就是调用了call的execute()方法。
4.异步POST请求
private void postAsynHttp() {
OkHttpClient mOkHttpClient = new OkHttpClient();
RequestBody formBody = new FormEncodingBuilder()
.add("size", "10")
Request request = new Request.Builder()
.url("http://api./biz/bizserver/article/list.do")
.post(formBody)
Call call = mOkHttpClient.newCall(request);
call.enqueue(new Callback() {
public void onFailure(Request request, IOException e) {
public void onResponse(Response response) throws IOException {
String str = response.body().string();
Log.i("wangshu", str);
runOnUiThread(new Runnable() {
public void run() {
Toast.makeText(getApplicationContext(), "请求成功", Toast.LENGTH_SHORT).show();
post与get不同的就是要要创建RequestBody并传进Request中，同样onResponse回调不是在UI线程。
5.请求缓存设置
首先我们设置缓存路径和大小并设置给OkHttpClient：
mOkHttpClient = new OkHttpClient();
File sdcache = getExternalCacheDir();
int cacheSize = 10 * 1024 * 1024;
mOkHttpClient.setCache(new Cache(sdcache.getAbsoluteFile(), cacheSize));
接下来异步GET请求baidu：
private void getAsynHttp() {
final Request request = new Request.Builder()
Call call = mOkHttpClient.newCall(request);
call.enqueue(new Callback() {
public void onFailure(Request request, IOException e) {
public void onResponse(final Response response) throws IOException {
if (null != response.cacheResponse()) {
String str = response.cacheResponse().toString();
Log.i("wangshu", "cache---" + str);
response.body().string();
String str=response.networkResponse().toString();
Log.i("wangshu", "network---" + str);
runOnUiThread(new Runnable() {
public void run() {
Toast.makeText(getApplicationContext(), "请求成功", Toast.LENGTH_SHORT).show();
第一次请求会请求网络得到数据，第二次以及后面的请求则会从缓存中取出数据：
当然也有种情况是有的请求每次都需要最新的数据，则在创建Request，来设置cacheControl为“CacheControl.FORCE_NETWORK”，用来表示请求会一直请求网络得到数据：
final Request request = new Request.Builder()
.cacheControl(CacheControl.FORCE_NETWORK)
运行程序结果为：
6.设置超时时间
另外我们也需要设置超时的时间用来处理各种网络超时的情况，超时的原因可能是网络问题也可能是服务器响应慢等问题，OkHttp当然不会忽略这一点，它支持连接、读取和写入超时的时间设置：
mOkHttpClient = new OkHttpClient()
mOkHttpClient.setConnectTimeout(15, TimeUnit.SECONDS)
mOkHttpClient.setWriteTimeout(20, TimeUnit.SECONDS)
mOkHttpClient.setReadTimeout(20, TimeUnit.SECONDS)
7.取消请求
使用call.cancel()可以立即停止掉一个正在执行的call。如果一个线程正在写请求或者读响应，将会引发IOException。当用户离开一个应用时或者跳到其他界面时，使用Call.cancel()可以节约网络资源，另外不管同步还是异步的call都可以取消。
也可以通过tags来同时取消多个请求。当你构建一请求时，使用RequestBuilder.tag(tag)来分配一个标签。之后你就可以用OkHttpClient.cancel(tag)来取消所有带有这个tag的call。
为了模拟这个场景我们首先创建一个定时的线程池：
private ScheduledExecutorService executor = Executors.newScheduledThreadPool(1);
接下来的代码为：
void cancel(){
final Request request = new Request.Builder()
.cacheControl(CacheControl.FORCE_NETWORK)
Call call=null;
call = mOkHttpClient.newCall(request);
final Call finalCall =
executor.schedule(new Runnable() {
@Override public void run() {
finalCall.cancel();
}, 100, TimeUnit.MILLISECONDS);
call.enqueue(new Callback() {
public void onFailure(Request request, IOException e) {
public void onResponse(final Response response) {
if (null != response.cacheResponse()) {
String str = response.cacheResponse().toString();
Log.i("wangshu", "cache---" + str);
response.body().string();
} catch (IOException e) {
Log.i("wangshu", "IOException");
e.printStackTrace();
String str = response.networkResponse().toString();
Log.i("wangshu", "network---" + str);
Log.i("wangshu", "是否取消成功"+call.isCanceled());
100毫秒后调用call.cancel()，为了能让请求耗时，我们设置每次请求都要请求网络，运行程序并且不断的快速点击发送请求按钮：
很明显每次cancel()都失败了，仍旧成功的访问了网络，在cancel()时已经有读写操作了所以会报IOException。每隔100毫秒来调用call.cancel()显然时间间隔太长，我们设置为1毫秒并不断的快速的点击发送请求按钮：
没有请求网络的log，几乎每次都取消成功了。
8.关于封装
如果每次请求网络都需要写重复的代码绝对是令人头疼的，网上也有很多对OkHttp封装的优秀开源项目，功能也非常强大，封装的意义就在于更加方便的使用，具有拓展性，但是对OkHttp封装最需要解决的是以下的两点：
避免重复代码调用
将请求结果回调改为UI线程
根据以上两点，我们也简单封装一下，在此只是举个例子，如果想要使用OkHttp封装的开源库，推荐使用。
首先呢我们写一个抽象类用于请求回调：
public abstract class ResultCallback&T&
public abstract void onError(Request request, Exception e);
public abstract void onResponse(Response response);
接下来封装OkHttp，并实现了异步GET请求：
public class OkHttpEngine {
private static OkHttpEngine mI
private OkHttpClient mOkHttpC
private Handler mH
public static OkHttpEngine getInstance() {
if (mInstance == null) {
synchronized (OkHttpEngine.class) {
if (mInstance == null) {
mInstance = new OkHttpEngine();
private OkHttpEngine() {
mOkHttpClient = new OkHttpClient();
mOkHttpClient.setConnectTimeout(15, TimeUnit.SECONDS);
mOkHttpClient.setWriteTimeout(20, TimeUnit.SECONDS);
mOkHttpClient.setReadTimeout(20, TimeUnit.SECONDS);
mHandler = new Handler();
public OkHttpEngine setCache(Context mContext) {
File sdcache = mContext.getExternalCacheDir();
int cacheSize = 10 * 1024 * 1024;
mOkHttpClient.setCache(new Cache(sdcache.getAbsoluteFile(), cacheSize));
* 异步get请求
* callback
public void getAsynHttp(String url, ResultCallback callback) {
final Request request = new Request.Builder()
Call call = mOkHttpClient.newCall(request);
dealResult(call, callback);
private void dealResult(Call call, final ResultCallback callback) {
call.enqueue(new Callback() {
public void onFailure(Request request, IOException e) {
sendFailedCallback(request, e, callback);
public void onResponse(final Response response) throws IOException {
sendSuccessCallback(response, callback);
private void sendSuccessCallback(final Response object, final ResultCallback callback) {
mHandler.post(new Runnable() {
public void run() {
if (callback != null) {
callback.onResponse(object);
private void sendFailedCallback(final Request request, final Exception e, final ResultCallback callback) {
mHandler.post(new Runnable() {
public void run() {
if (callback != null)
callback.onError(request, e);
原理很简单就是，写一个双重检查模式的单例，不了解双重检查模式的请查看这篇文章。在开始创建的时候配置好OkHttpClient，在请求网络的时候用Handler将请求的结果回调给UI线程。
最后调用这个OkHttpEngine的getAsynHttp()方法：
OkHttpEngine.getInstance().getAsynHttp("", new ResultCallback() {
public void onError(Request request, Exception e) {
public void onResponse(Response response) {
String str = response.networkResponse().toString();
Log.i("wangshu", str);
Toast.makeText(getApplicationContext(), "请求成功", Toast.LENGTH_SHORT).show();
使用起来简单多了，而且请求结果回调是在UI线程的。下一篇我们会讲到OkHttp3，来看看它与OkHttp2.x之间的使用方式上有什么区别。
参考知识库
* 以上用户言论只代表其个人观点，不代表CSDN网站的观点或立场
访问：1133518次
积分：11063
积分：11063
排名：第1099名
原创：130篇
转载：52篇
评论：622条
Android高级工程师、技术经理7年Android开发经验、1年J2EE经验曾工作于华为北研所、开心网等公司
第一时间获得博客更新提醒，以及更多成体系的Android相关技术干货。
<font color="#c8415
(1)(2)(2)(2)(1)(3)(8)(4)(1)(3)(6)(9)(10)(10)(8)(1)(1)(2)(2)(3)(1)(1)(1)(1)(1)(1)(1)(3)(3)(1)(3)(5)(2)(3)(3)(4)(5)(4)(1)(3)(4)(8)(6)(8)(3)(3)(14)(13)okhttp3使用_Android开发-织梦者
当前位置:&>&&>& > okhttp3使用
okhttp3使用
一、引入包
在项目module下的build.gradle添加okhttp3依赖
compile 'com.squareup.okhttp3:okhttp:3.3.1'
二、基本使用
1、okhttp3 Get 方法
1.1 、okhttp3 同步 Get方法
* 同步Get方法
private void okHttp_synchronousGet() {
new Thread(new Runnable() {
public void run() {
String url = "/";
OkHttpClient client = new OkHttpClient();
Request request = new Request.Builder().url(url).build();
okhttp3.Response response = client.newCall(request).execute();
if (response.isSuccessful()) {
Log.i(TAG, response.body().string());
Log.i(TAG, "okHttp is request error");
} catch (IOException e) {
e.printStackTrace();
}).start();
Request是okhttp3 的请求对象，Response是okhttp3中的响应。通过response.isSuccessful()判断请求是否成功。
@Contract(pure=true)
public boolean isSuccessful()
Returns true if the code is in [200..300), which means the request was successfully received, understood, and accepted.
获取返回的数据，可通过response.body().string()获取，默认返回的是utf-8格式；string()适用于获取小数据信息，如果返回的数据超过1M，建议使用stream()获取返回的数据，因为string() 方法会将整个文档加载到内存中。
public final java.lang.String string()
throws java.io.IOException
Returns the response as a string decoded with the charset of the Content-Type header. If that header is either absent or lacks a charset, this will attempt to decode the response body as UTF-8.
java.io.IOException
当然也可以获取流输出形式；
public final java.io.InputStream byteStream()
1.2 、okhttp3 异步 Get方法
有时候需要下载一份文件（比如网络图片），如果文件比较大，整个下载会比较耗时，通常我们会将耗时任务放到工作线程中，而使用okhttp3异步方法，不需要我们开启工作线程执行网络请求，返回的结果也在工作线程中；
* 异步 Get方法
private void okHttp_asynchronousGet(){
Log.i(TAG,"main thread id is "+Thread.currentThread().getId());
String url = "/";
OkHttpClient client = new OkHttpClient();
Request request = new Request.Builder().url(url).build();
client.newCall(request).enqueue(new okhttp3.Callback() {
public void onFailure(okhttp3.Call call, IOException e) {
public void onResponse(okhttp3.Call call, okhttp3.Response response) throws IOException {
// 注：该回调是子线程，非主线程
Log.i(TAG,"callback thread id is "+Thread.currentThread().getId());
Log.i(TAG,response.body().string());
} catch (Exception e) {
e.printStackTrace();
注： 4.0 之后，要求网络请求必须在工作线程中运行，不再允许在主线程中运行。因此，如果使用 okhttp3 的同步Get方法，需要新起工作线程调用。
1.3 、添加请求头
okhttp3添加请求头，需要在Request.Builder()使用.header(String key,String value)或者.addHeader(String key,String value);
使用.header(String key,String value)，如果key已经存在，将会移除该key对应的value，然后将新value添加进来，即替换掉原来的value；
使用.addHeader(String key,String value)，即使当前的可以已经存在值了，只会添加新value的值，并不会移除/替换原来的值。
private final OkHttpClient client = new OkHttpClient();
public void run() throws Exception {
Request request = new Request.Builder()
.url("/repos/square/okhttp/issues")
.header("User-Agent", "OkHttp Headers.java")
.addHeader("Accept", "application/ q=0.5")
.addHeader("Accept", "application/vnd.github.v3+json")
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"));
2、okhttp3 Post 方法
2.1 、Post 提交键值对
很多时候，我们需要通过Post方式把键值对数据传送到服务器，okhttp3使用FormBody.Builder创建请求的参数键值对；
private void okHttp_postFromParameters() {
new Thread(new Runnable() {
public void run() {
// 请求完整url：:88/?app=weather.future&weaid=1&&appkey=10003&sign=b59bc3efdd4e83c99f2a4&format=json
String url = ":88/";
OkHttpClient okHttpClient = new OkHttpClient();
String json = "{'app':'weather.future','weaid':'1','appkey':'10003'," +
"'sign':'b59bc3efdd4e83c99f2a4','format':'json'}";
RequestBody formBody = new FormBody.Builder().add("app", "weather.future")
.add("weaid", "1").add("appkey", "10003").add("sign",
"b59bc3efdd4e83c99f2a4").add("format", "json")
Request request = new Request.Builder().url(url).post(formBody).build();
okhttp3.Response response = okHttpClient.newCall(request).execute();
Log.i(TAG, response.body().string());
} catch (Exception e) {
e.printStackTrace();
}).start();
2.2 、Post a String
可以使用Post方法发送一串字符串，但不建议发送超过1M的文本信息，如下示例展示了，发送一个markdown文本
public static final MediaType MEDIA_TYPE_MARKDOWN
= MediaType.parse("text/x- charset=utf-8");
private final OkHttpClient client = new OkHttpClient();
public void run() throws Exception {
String postBody = ""
+ "Releases\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("/markdown/raw")
.post(RequestBody.create(MEDIA_TYPE_MARKDOWN, postBody))
Response response = client.newCall(request).execute();
if (!response.isSuccessful()) throw new IOException("Unexpected code " + response);
System.out.println(response.body().string());
2.3 、Post Streaming
post可以将stream对象作为请求体，依赖以Okio 将数据写成输出流形式；
public static final MediaType MEDIA_TYPE_MARKDOWN
= MediaType.parse("text/x- 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 & i++) {
int x = n /
if (x * i == n) return factor(x) + " × " +
return Integer.toString(n);
Request request = new Request.Builder()
.url("/markdown/raw")
.post(requestBody)
Response response = client.newCall(request).execute();
if (!response.isSuccessful()) throw new IOException("Unexpected code " + response);
System.out.println(response.body().string());
2.4 、Post file
public static final MediaType MEDIA_TYPE_MARKDOWN
= MediaType.parse("text/x- 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("/markdown/raw")
.post(RequestBody.create(MEDIA_TYPE_MARKDOWN, file))
Response response = client.newCall(request).execute();
if (!response.isSuccessful()) throw new IOException("Unexpected code " + response);
System.out.println(response.body().string());
3、其他配置
3.1 、Gson解析Response的Gson对象
如果Response对象的内容是个json字符串，可以使用Gson将字符串格式化为对象。ResponseBody.charStream()使用响应头中的Content-Type
作为Response返回数据的编码方式，默认是UTF-8。
private final OkHttpClient client = new OkHttpClient();
private final Gson gson = new Gson();
public void run() throws Exception {
Request request = new Request.Builder()
.url("/gists/c2a7c1be")
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&
static class GistFile {
3.2 、okhttp3 本地缓存
okhttp框架全局必须只有一个OkHttpClient实例（new OkHttpClient()），并在第一次创建实例的时候，配置好缓存路径和大小。只要设置的缓存，okhttp默认就会自动使用缓存功能。
package com.jackchan.test.
import android.os.B
import android.support.v7.app.ActionBarA
import android.util.L
import com.squareup.okhttp.C
import com.squareup.okhttp.CacheC
import com.squareup.okhttp.C
import com.squareup.okhttp.C
import com.squareup.okhttp.OkHttpC
import com.squareup.okhttp.R
import com.squareup.okhttp.R
import java.io.F
import java.io.IOE
public class TestActivity extends ActionBarActivity {
private final static String TAG = "TestActivity";
private final OkHttpClient client = new OkHttpClient();
protected void onCreate(Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
setContentView(R.layout.activity_test);
File sdcache = getExternalCacheDir();
int cacheSize = 10 * 1024 * 1024; // 10 MiB
client.setCache(new Cache(sdcache.getAbsoluteFile(), cacheSize));
new Thread(new Runnable() {
public void run() {
execute();
} catch (Exception e) {
e.printStackTrace();
}).start();
public void execute() throws Exception {
Request request = new Request.Builder()
.url("/helloworld.txt")
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));
okhttpclient有点像Application的概念，统筹着整个okhttp的大功能，通过它设置缓存目录，我们执行上面的代码，得到的结果如下
response1 的结果在networkresponse，代表是从网络请求加载过来的，而response2的networkresponse 就为null，而cacheresponse有数据，因为我设置了缓存因此第二次请求时发现缓存里有就不再去走网络请求了。
但有时候即使在有缓存的情况下我们依然需要去后台请求最新的资源（比如资源更新了）这个时候可以使用强制走网络来要求必须请求网络数据
public void execute() throws Exception {
Request request = new Request.Builder()
.url("/helloworld.txt")
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());
request = request.newBuilder().cacheControl(CacheControl.FORCE_NETWORK).build();
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));
上面的代码中
response2对应的request变成
request = request.newBuilder().cacheControl(CacheControl.FORCE_NETWORK).build();
我们看看运行结果
response2的cache response为null，network response依然有数据。
同样的我们可以使用 FORCE_CACHE 强制只要使用缓存的数据，但如果请求必须从网络获取才有数据，但又使用了FORCE_CACHE 策略就会返回504错误，代码如下，我们去okhttpclient的缓存，并设置request为FORCE_CACHE
protected void onCreate(Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
setContentView(R.layout.activity_test);
File sdcache = getExternalCacheDir();
int cacheSize = 10 * 1024 * 1024; // 10 MiB
//client.setCache(new Cache(sdcache.getAbsoluteFile(), cacheSize));
new Thread(new Runnable() {
public void run() {
execute();
} catch (Exception e) {
e.printStackTrace();
System.out.println(e.getMessage().toString());
}).start();
public void execute() throws Exception {
Request request = new Request.Builder()
.url("/helloworld.txt")
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());
request = request.newBuilder().cacheControl(CacheControl.FORCE_CACHE).build();
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));
3.3 、okhttp3 取消请求
如果一个okhttp3网络请求已经不再需要，可以使用Call.cancel()来终止正在准备的同步/异步请求。如果一个线程正在写一个请求或是读取返回的response，它将会接收到一个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.
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);
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);
3.4 、okhttp3 超时设置
okhttp3 支持设置连接超时，读写超时。
private final OkHttpC
public ConfigureTimeouts() throws Exception {
client = new OkHttpClient.Builder()
.connectTimeout(10, TimeUnit.SECONDS)
.writeTimeout(10, TimeUnit.SECONDS)
.readTimeout(30, TimeUnit.SECONDS)
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.
Response response = client.newCall(request).execute();
System.out.println("Response completed: " + response);
3.5 、okhttp3 复用okhttpclient配置
所有HTTP请求的代理设置，超时，缓存设置等都需要在OkHttpClient中设置。如果需要更改一个请求的配置，可以使用
OkHttpClient.newBuilder()获取一个builder对象，该builder对象与原来OkHttpClient共享相同的连接池，配置等。
如下示例，拷贝2个'OkHttpClient的配置，然后分别设置不同的超时时间；
private final OkHttpClient client = new OkHttpClient();
public void run() throws Exception {
Request request = new Request.Builder()
.url("http://httpbin.org/delay/1") // This URL is served with a 1 second delay.
// Copy to customize OkHttp for this request.
OkHttpClient copy = client.newBuilder()
.readTimeout(500, TimeUnit.MILLISECONDS)
Response response = copy.newCall(request).execute();
System.out.println("Response 1 succeeded: " + response);
} catch (IOException e) {
System.out.println("Response 1 failed: " + e);
// Copy to customize OkHttp for this request.
OkHttpClient copy = client.newBuilder()
.readTimeout(3000, TimeUnit.MILLISECONDS)
Response response = copy.newCall(request).execute();
System.out.println("Response 2 succeeded: " + response);
} catch (IOException e) {
System.out.println("Response 2 failed: " + e);
3.6 、okhttp3 处理验证
okhttp3 会自动重试未验证的请求。当一个请求返回401 Not Authorized时，需要提供Anthenticator。
private final OkHttpC
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)
public void run() throws Exception {
Request request = new Request.Builder()
.url("/secrets/hellosecret.txt")
Response response = client.newCall(request).execute();
if (!response.isSuccessful()) throw new IOException("Unexpected code " + response);
System.out.println(response.body().string());
三、参考文献：
/square/okhttp/wiki/Recipes
http://blog.csdn.net/chenzujie/article/details/
/a/anzhuokaifa/androidkaifa/75.html
以上就是okhttp3使用的全文介绍,希望对您学习Android应用开发有所帮助.
这些内容可能对你也有帮助
无相关信息
更多可查看Android开发列表页。
猜您也会喜欢这些文章}