【转】Android OkHttp3简介和使用详解

一 OKHttp简介

OKHttp是一个处理网络请求的开源项目，Android 当前最火热网络框架，由移动支付Square公司贡献，用于替代HttpUrlConnection和Apache HttpClient(android API23 6.0里已移除HttpClient）。 
OKHttpGitHub地址

OKHttp优势

1. 支持HTTP2/SPDY（SPDY是Google开发的基于TCP的传输层协议，用以最小化网络延迟，提高网络速度，优化用户的网络使用体验。）
2. socket自动选择最好路线，并支持自动重连，拥有自动维护的socket链接池，减小握手次数，减小了请求延迟，共享Socket,减小对服务器的请求次数。
3. 基于Headers的缓存策略减小重复的网络请求。
4. 拥有Interceptors轻松处理请求与响应（自动处理GZip压缩）。

OKHttp的功能

1. PUT，DELETE，POST，GET等请求
2. 文件的上传下载
3. 加载图片(内部会图片大小自动压缩)
4. 支持请求回调，直接返回对象、对象集合
5. 支持session的保持

二 OkHttp3使用

主要介绍 OkHttp3 的 Get 请求、 Post 请求、 上传下载文件 、 上传下载图片等功能 。

添加OkHttp3的依赖

1. compile  'com.squareup.okhttp3:okhttp:3.7.0'
2. compile  'com.squareup.okio:okio:1.12.0'

添加网络权限

<uses-permission android:name="android.permission.INTERNET"/>

添加请求头

    private Request.Builder addHeaders() {
        Request.Builder builder = new Request.Builder()
                //addHeader，可添加多个请求头  header，惟一，会覆盖
                .addHeader("Connection", "keep-alive")
                .addHeader("platform", "2")
                .addHeader("phoneModel", Build.MODEL)
                .addHeader("systemVersion", Build.VERSION.RELEASE)
                .addHeader("appVersion", "3.2.0")
                .header("sid", "eyJhZGRDaGFubmVsIjoiYXBwIiwiYWRkUHJvZHVjdCI6InFia3BsdXMiLCJhZGRUaW1lIjoxNTAzOTk1NDQxOTEzLCJyb2xlIjoiUk9MRV9VU0VSIiwidXBkYXRlVGltZSI6MTUwMzk5NTQ0MTkxMywidXNlcklkIjoxNjQxMTQ3fQ==.b0e5fd6266ab475919ee810a82028c0ddce3f5a0e1faf5b5e423fb2aaf05ffbf");
        return builder;
    }

 1.异步GET请求

        //1.建立OkHttpClient对象
        OkHttpClient okHttpClient = new OkHttpClient();
        //2.建立Request对象，设置一个url地址（百度地址）,设置请求方式。
        Request request = new Request.Builder().url("http://www.baidu.com").method("GET",null).build();
        //3.建立一个call对象,参数就是Request请求对象
        Call call = okHttpClient.newCall(request);
        //4.请求加入调度，重写回调方法
        call.enqueue(new Callback() {
            //请求失败执行的方法
            @Override
            public void onFailure(Call call, IOException e) {
            }
            //请求成功执行的方法
            @Override
            public void onResponse(Call call, Response response) throws IOException {
            }
        });

 

上面就是发送一个异步GET请求的4个步骤：

1. 建立OkHttpClient对象
2. 经过Builder模式建立Request对象，参数必须有个url参数，能够经过Request.Builder设置更多的参数好比：header、method等
3. 经过request的对象去构造获得一个Call对象，Call对象有execute()和cancel()等方法。
4. 以异步的方式去执行请求，调用的是call.enqueue，将call加入调度队列，任务执行完成会在Callback中获得结果。

注意事项：

1. 异步调用的回调函数是在子线程,咱们不能在子线程更新UI,须要借助于 runOnUiThread() 方法或者 Handler 来处理。
2. onResponse回调有一个参数是response，若是咱们想得到返回的是字符串，能够经过response.body().string()获取；若是但愿得到返回的二进制字节数组，则调用response.body().bytes()；若是你想拿到返回的inputStream，则调response.body().byteStream()，有inputStream咱们就能够经过IO的方式写文件（后面会有例子）。

2.同步GET请求

        //1.建立OkHttpClient对象
        OkHttpClient okHttpClient = new OkHttpClient();
        //2.建立Request对象，设置一个url地址（百度地址）,设置请求方式。
        Request request = new Request.Builder().url("http://www.baidu.com").method("GET",null).build();
        //3.建立一个call对象,参数就是Request请求对象
        Call call = okHttpClient.newCall(request);
        //4.同步调用会阻塞主线程,这边在子线程进行
        new Thread(new Runnable() {
                @Override
                public void run() {
                    try {
                        //同步调用,返回Response,会抛出IO异常
                        Response response = call.execute();
                    } catch (IOException e) {
                        e.printStackTrace();
                    }
                }
            }).start();

 

同步GET请求和异步GET请求基本同样，不一样地方是同步请求调用Call的execute()方法，而异步请求调用call.enqueue()方法（具体2个方法的不一样点我下一遍具体源码详解再说）。

3.POST请求提交键值对

        //1.建立OkHttpClient对象
        OkHttpClient  okHttpClient = new OkHttpClient();
        //2.经过new FormBody()调用build方法,建立一个RequestBody,能够用add添加键值对 
        RequestBody  requestBody = new FormBody.Builder().add("name","zhangqilu").add("age","25").build();
        //3.建立Request对象，设置URL地址，将RequestBody做为post方法的参数传入
        Request request = new Request.Builder().url("url").post(requestBody).build();
        //4.建立一个call对象,参数就是Request请求对象
        Call call = okHttpClient.newCall(request);
        //5.请求加入调度,重写回调方法
        call.enqueue(new Callback() {
            @Override
            public void onFailure(Call call, IOException e) {
            }
 
            @Override
            public void onResponse(Call call, Response response) throws IOException {
            }
        });

 

上面就是一个异步POST请求提交键值对的5个步骤：

1. 建立OkHttpClient对象。
2. 经过new FormBody()调用build方法,建立一个RequestBody,能够用add添加键值对 ，FormBody 是 RequestBody 的子类。
3. 建立Request对象，设置URL地址，将RequestBody做为post方法的参数传入。
4. 建立一个call对象,参数就是Request请求对象。
5. 请求加入调度,重写回调方法。

经过对比咱们发现异步的POST请求和GET请求步骤很类似。

4.异步POST请求提交字符串

POST请求提交字符串和POST请求提交键值对很是类似，不一样地方主要是RequestBody，下面咱们来具体看一下。 
在有些状况下客户端须要向服务端传送字符串，咱们该怎么作？ 
咱们须要用到另外一种方式来构造一个 RequestBody 以下所示:

        MediaType mediaType = MediaType.parse("application/json; charset=utf-8");//"类型,字节码"
        //字符串
        String value = "{username:admin;password:admin}"; 
        //1.建立OkHttpClient对象
        OkHttpClient  okHttpClient = new OkHttpClient();
        //2.经过RequestBody.create 建立requestBody对象
        RequestBody requestBody =RequestBody.create(mediaType, value);
        //3.建立Request对象，设置URL地址，将RequestBody做为post方法的参数传入
        Request request = new Request.Builder().url("url").post(requestBody).build();
        //4.建立一个call对象,参数就是Request请求对象
        Call call = okHttpClient.newCall(request);
        //5.请求加入调度,重写回调方法
        call.enqueue(new Callback() {
            @Override
            public void onFailure(Call call, IOException e) {
            }
 
            @Override
            public void onResponse(Call call, Response response) throws IOException {
            }
        });

 

5.异步POST请求上传文件

咱们这里举一个上传图片的例子，也能够是其余文件如，TXT文档等，不一样地方主要是RequestBody，首先咱们要添加存储卡读写权限,在 AndroidManifest.xml 文件中添加以下代码:

1. <uses-permission android:name="android.permission.READ_EXTERNAL_STORAGE"/>
2. <uses-permission android:name="android.permission.WRITE_EXTERNAL_STORAGE"/>

下面咱们具体看一下上传文件代码。

        //1.建立OkHttpClient对象
        OkHttpClient  okHttpClient = new OkHttpClient();
        //上传的图片
        File file = new File(Environment.getExternalStorageDirectory(), "zhuangqilu.png");
        //2.经过RequestBody.create 建立requestBody对象,application/octet-stream 表示文件是任意二进制数据流
        RequestBody requestBody =RequestBody.create(MediaType.parse("application/octet-stream"), file);
        //3.建立Request对象，设置URL地址，将RequestBody做为post方法的参数传入
        Request request = new Request.Builder().url("url").post(requestBody).build();
        //4.建立一个call对象,参数就是Request请求对象
        Call call = okHttpClient.newCall(request);
        //5.请求加入调度,重写回调方法
        call.enqueue(new Callback() {
            @Override
            public void onFailure(Call call, IOException e) {
            }
 
            @Override
            public void onResponse(Call call, Response response) throws IOException {
            }
        });

 

6.异步GET请求下载文件

下载文件也是咱们常常用到的功能，咱们就举个下载图片的例子吧

        //1.建立OkHttpClient对象
        OkHttpClient okHttpClient = new OkHttpClient();
        //2.建立Request对象，设置一个url地址（百度地址）,设置请求方式。
        Request request = new Request.Builder().url("https://www.baidu.com/img/bd_logo1.png").get().build();
        //3.建立一个call对象,参数就是Request请求对象
        Call call = okHttpClient.newCall(request);
        //4.请求加入调度,重写回调方法
        call.enqueue(new Callback() {
            @Override
            public void onFailure(Call call, IOException e) {
                Log.e(TAG, "onFailure: "+call.toString() );
            }
 
            @Override
            public void onResponse(Call call, Response response) throws IOException {
                //拿到字节流
                InputStream is = response.body().byteStream();
                int len = 0;
                //设置下载图片存储路径和名称
                File file = new File(Environment.getExternalStorageDirectory(),"baidu.png");
                FileOutputStream fos = new FileOutputStream(file);
                byte[] buf = new byte[128];
                while((len = is.read(buf))!= -1){
                    fos.write(buf,0,len);
                    Log.e(TAG, "onResponse: "+len );
                }
                fos.flush();
                fos.close();
                is.close();
            }
        });

 

Get请求下载文件仍是比较简单，设置下载地址，在回调函数中拿到了图片的字节流,而后保存为了本地的一张图片。

从网络下载一张图片并直接设置到ImageView中。

@Override
public void onResponse(Call call, Response response) throws IOException {
    InputStream is = response.body().byteStream();
    //使用 BitmapFactory 的 decodeStream 将图片的输入流直接转换为 Bitmap 
    final Bitmap bitmap = BitmapFactory.decodeStream(is);
    //在主线程中操做UI
    runOnUiThread(new Runnable() {
        @Override
        public void run() {
            //而后将Bitmap设置到 ImageView 中
            imageView.setImageBitmap(bitmap);
        }
    });
 
    is.close();

 

主要注释已在代码中了。

7.异步POST请求上传Multipart文件

咱们在有些状况下既要上传文件还要上传其余类型字段。好比在我的中心咱们能够修更名字，年龄，修改图像，这其实就是一个表单。这里咱们用到MuiltipartBody ,它 是RequestBody 的一个子类,咱们提交表单就是利用这个类来构建一个 RequestBody，咱们来看一下具体代码。

        //1.建立OkHttpClient对象
        OkHttpClient  okHttpClient = new OkHttpClient();
        //上传的图片
        File file = new File(Environment.getExternalStorageDirectory(), "zhuangqilu.png");
        //2.经过new MultipartBody build() 建立requestBody对象，
         RequestBody  requestBody = new MultipartBody.Builder()
                //设置类型是表单
                .setType(MultipartBody.FORM)
                //添加数据
                .addFormDataPart("username","zhangqilu")
                .addFormDataPart("age","25")
                .addFormDataPart("image","zhangqilu.png",
RequestBody.create(MediaType.parse("image/png"),file))
                .build();
        //3.建立Request对象，设置URL地址，将RequestBody做为post方法的参数传入
        Request request = new Request.Builder().url("url").post(requestBody).build();
        //4.建立一个call对象,参数就是Request请求对象
        Call call = okHttpClient.newCall(request);
        //5.请求加入调度,重写回调方法
        call.enqueue(new Callback() {
            @Override
            public void onFailure(Call call, IOException e) {
            }
 
            @Override
            public void onResponse(Call call, Response response) throws IOException {
            }
        });

 

Post 表单

public void postForm(View view) {
        OkHttpClient client = new OkHttpClient();
        RequestBody requestBody = new MultipartBody.Builder()
                .setType(MultipartBody.FORM)
                .addFormDataPart("username", "叶应是叶")
                .addFormDataPart("password", "叶应是叶")
                .build();
        final Request request = new Request.Builder()
                .url("http://www.jianshu.com/")
                .post(requestBody)
                .build();
        Call call = client.newCall(request);
        call.enqueue(new Callback() {
            @Override
            public void onFailure(Call call, IOException e) {
                ToastUtil.showToast(PostFormActivity.this, "Post Form 失败");
            }

            @Override
            public void onResponse(Call call, Response response) throws IOException {
                final String responseStr = response.body().string();
                ToastUtil.showToast(PostFormActivity.this, "Code：" + String.valueOf(response.code()));
                runOnUiThread(new Runnable() {
                    @Override
                    public void run() {
                        tv_result.setText(responseStr);
                    }
                });
            }
        });
    }

 

Post 流

public void postStreaming(View view) {
    final MediaType MEDIA_TYPE_MARKDOWN = MediaType.parse("text/x-markdown; charset=utf-8");
    File file = new File("README.md");
    final FileInputStream fileInputStream1=new FileInputStream(file);
    RequestBody requestBody1=new RequestBody() {
        @Nullable
        @Override
        public MediaType contentType() {
            return MEDIA_TYPE_MARKDOWN;
        }

        @Override
        public void writeTo(BufferedSink sink) throws IOException {
            OutputStream outputStream=sink.outputStream();
            int length;
            byte[] buffer = new byte[1024];
            while ((length = fileInputStream1.read(buffer)) != -1) {
                outputStream.write(buffer, 0, length);
            }
        }
    };

    RequestBody requestBody2=new RequestBody() {
        @Nullable
        @Override
        public MediaType contentType() {
            return MEDIA_TYPE_MARKDOWN;
        }

        @Override
        public void writeTo(BufferedSink sink) throws IOException {
            int length;
            byte[] buffer = new byte[1024];
            while ((length = fileInputStream1.read(buffer)) != -1) {
                sink.write(buffer, 0, length);
            }
        }
    };

    Request request = new Request.Builder()
            .url(url)
            .post(requestBody1)
            .build();

    Call call = client.newCall(request);
    call.enqueue(new Callback() {
        @Override
        public void onFailure(Call call, IOException e) {
            ToastUtil.showToast(PostStreamingActivity.this, "Post Streaming 失败");
        }

        @Override
        public void onResponse(Call call, Response response) throws IOException {
            final String responseStr = response.body().string();
            ToastUtil.showToast(PostStreamingActivity.this, "Code：" + String.valueOf(response.code()));
            runOnUiThread(new Runnable() {
                @Override
                public void run() {
                    tv_result.setText(responseStr);
                }
            });
        }
    });
}

 

 

解析Json

这里来经过Gson将response的内容解析为Java Bean
首先须要先去将Gson.jar文件导入工程

这里来经过OkHttp访问接口“http://news-at.zhihu.com/api/4/themes”，获取Json数据而后将之解析为JavaBean实体

 

Response response = okHttpClient.newCall(request).execute();
        if (response.isSuccessful()){
        User user = new Gson().fromJson(response.body().charStream(), User.class);
        }

 

设置超时时间和缓存

和OkHttp2.x有区别的是不能经过OkHttpClient直接设置超时时间和缓存了，而是经过OkHttpClient.Builder来设置，经过builder配置好OkHttpClient后用builder.build()来返回OkHttpClient，因此咱们一般不会调用new OkHttpClient()来获得OkHttpClient，而是经过builder.build()：

 File sdcache = getExternalCacheDir();
        int cacheSize = 10 * 1024 * 1024;
        OkHttpClient.Builder builder = new OkHttpClient.Builder()
                .connectTimeout(15, TimeUnit.SECONDS)
                .writeTimeout(20, TimeUnit.SECONDS)
                .readTimeout(20, TimeUnit.SECONDS)
                .cache(new Cache(sdcache.getAbsoluteFile(), cacheSize));
        OkHttpClient mOkHttpClient=builder.build();            

 

关于取消请求和封装

取消请求仍旧能够调用call.cancel()，这个没有变化，不明白的能够查看上一篇文章Android网络编程（五）OkHttp2.x用法全解析，这里就不赘述了，封装上一篇也讲过仍旧推荐OkHttpFinal，它目前是基于OkHttp3来进行封装的。

call.cancel();//取消请求，不能取消已经准备完成的请求 okHttpClient.dispatcher().cancelAll();//取消全部请求

有时候网络条件很差的状况下，用户会主动关闭页面，这时候须要取消正在请求的http request, OkHttp提供了cancel方法，可是实际在使用过程当中发现，若是调用cancel()方法，会回调到CallBack里面的 onFailure方法中，

/** * Called when the request could not be executed due to cancellation, a connectivity problem or * timeout. Because networks can fail during an exchange, it is possible that the remote server * accepted the request before the failure. */ void onFailure(Call call, IOException e); 

能够看到注释，当取消一个请求，网络链接错误，或者超时都会回调到这个方法中来，可是我想对取消请求作一下单独处理，这个时候就须要区分不一样的失败类型了

解决思路

测试发现不一样的失败类型返回的IOException e 不同，因此能够经过e.toString 中的关键字来区分不一样的错误类型

本身主动取消的错误的 java.net.SocketException: Socket closed 超时的错误是 java.net.SocketTimeoutException 网络出错的错误是java.net.ConnectException: Failed to connect to xxxxx 

代码

直贴了部分代码

call.enqueue(new Callback() { @Override public void onFailure(Call call, IOException e) { if(e.toString().contains("closed")) { //若是是主动取消的状况下 }else{ //其余状况下 }

拦截器

 添加Interceptor

// 配置一些信息进入OkHttpClient
mOkHttpClient = new OkHttpClient().newBuilder()
        .connectTimeout(REQUEST_TIME, TimeUnit.SECONDS)
        .readTimeout(REQUEST_TIME, TimeUnit.SECONDS)
        .writeTimeout(REQUEST_TIME, TimeUnit.SECONDS)
        .addInterceptor(new LoggerInterceptor())
        .build();

 

只要利用addInterceptor方法就能够添加拦截器，而自定义的拦截器只须要实现 Interceptor 接口就好了，可使用拦截器方便的打印网络请求时，须要查看的日志。以下所示：

public class LoggerInterceptor implements Interceptor {
 
  @Override
  public Response intercept(@NonNull Chain chain) throws IOException {
    // 拦截请求，获取到该次请求的request
    Request request = chain.request();
    // 执行本次网络请求操做，返回response信息
    Response response = chain.proceed(request);
    if (Configuration.DEBUG) {
      for (String key : request.headers().toMultimap().keySet()) {
        LogUtil.e("zp_test", "header: {" + key + " : " + request.headers().toMultimap().get(key) + "}");
      }
      LogUtil.e("zp_test", "url: " + request.url().uri().toString());
      ResponseBody responseBody = response.body();
 
      if (HttpHeaders.hasBody(response) && responseBody != null) {
        BufferedReader bufferedReader = new BufferedReader(new InputStreamReader(responseBody.byteStream(), "utf-8"));
        String result;
        while ((result = bufferedReader.readLine()) != null) {
          LogUtil.e("zp_test", "response: " + result);
        }
        // 测试代码
        responseBody.string();
      }
    }
    // 注意，这样写，等于从新建立Request，获取新的Response，避免在执行以上代码时，
    // 调用了responseBody.string()而不能在返回体中再次调用。
    return response.newBuilder().build();
  }
 
}

 

注意事项

1. 若是提交的是表单,必定要设置表单类型， setType(MultipartBody.FORM)
2. 提交文件 addFormDataPart() 方法的第一个参数就是相似于键值对的键,是供服务端使用的，第二个参数是文件的本地的名字，第三个参数是 RequestBody，里面包含了咱们要上传的文件的路径以及 MidiaType。

　　from：https://www.cnblogs.com/chenxibobo/p/9585760.html