【185】okHttp 3.0 基本使用整理

0.okHttp点滴

【1】网络请求属于耗时请求，不能放在ui线程（主线程）执行，需要放在子线程中执行。

1.GET请求--默认请求

    /**
     * [1]GET请求
     */
    private void okHttpGet(String url) throws IOException {
        //1,创建okHttpClient对象
        OkHttpClient client = new OkHttpClient();


        //2,创建一个Request
        //可以通过Request.Builder设置更多的参数比如： header、 method等
        Request request = new Request.Builder()
                .get()  //get请求；
                .url(url)
                .build();

        //3,新建一个call对象
        Call call = client.newCall(request);
        //[4-1]同步请求-会阻塞，使用很少；
        call.execute();
        //[4-2]异步请求-请求是在线程，更新数据需要使用handler等；
        //请求加入调度，这里是异步Get请求回调
        call.enqueue(new Callback() {
            @Override
            public void onFailure(Call call, IOException e) {

            }

            @Override
            public void onResponse(Call call, Response response) throws IOException {
                //可以判断response返回的状态：
                if (response.isSuccessful()) {
                    //response.body返回数据；
                    //[1]
                    String string = response.body().string();
                    //                [2]
                    byte[] bytes = response.body().bytes();
                    //                [3]
                    InputStream inputStream = response.body().byteStream();
                    //                [4]
                    Reader reader = response.body().charStream();
                    //                [5]
                    BufferedSource source = response.body().source();
                }

            }
        });

    }

【说明】

【1】发送一个GET请求的步骤，首先构造一个Request对象，参数至少具备URL，当然也可以通过Request.Builder设置更多的参数比如：header、method等。 

//URL带的参数
HashMap<String,String> params = new HashMap<>();
//GET 请求带的Header
HashMap<String,String> headers= new HashMap<>();
//HttpUrl.Builder构造带参数url
 HttpUrl.Builder urlBuilder = HttpUrl.parse(url).newBuilder();
        if (params != null) {

            for (String key : params.keySet()) {
                urlBuilder.setQueryParameter(key, params.get(key));
            }
        }
        Request request = new Request.Builder()
                .url(urlBuilder.build())
                .headers(headers == null ? new Headers.Builder().build() : Headers.of(headers))
                .get()
                .build();

【2】通过Request的对象去构造得到一个Call对象，类似于将你的请求封装成了任务，既然是任务，就会有execute(),enqueue()和cancel()等方法。
execute():同步GET请求

 //同步
Response response = call.execute()
     if(response.isSuccessful()){
      //响应成功
}

enqueue():异步GET请求，将call加入调度队列，然后等待任务执行完成，在Callback中即可得到结果。

call.enqueue(new Callback() {
            @Override
            public void onFailure(Call call, IOException e) {

            }

            @Override
            public void onResponse(Call call, Response response) throws IOException {
                //可以判断response返回的状态：
                if (response.isSuccessful()) {
                    //response.body返回数据；
                }

            }
        });

cancel():Call请求的取消，okHttp支持请求取消功能，当调用请求的cancel()时，请求就会被取消，抛出异常。

又是需要监控许多Http请求的执行情况，可以把这些请求的Call搜集起来，

执行完毕自动剔除，如果在请求执行过程中(如下载)，想取消执行，可使用call.cancel()取消。

【3】请求的响应Response
对于同步GET请求，Response对象是直接返回的。

异步GET请求，通过onResponse回调方法传参数，需要注意的是这个onResponse回调方法不是在主线程回调，可以使用runInUIThread(new Runnable(){})。
获得，可以通过 response.body().string() 获取；

//[4-2]异步请求-请求是在线程，更新数据需要使用handler等；
        //请求加入调度，这里是异步Get请求回调
        call.enqueue(new Callback() {
            @Override
            public void onFailure(Call call, IOException e) {

            }

            @Override
            public void onResponse(Call call, Response response) throws IOException {
                //可以判断response返回的状态：
                if (response.isSuccessful()) {
                    //response.body返回数据；
                    //[1]返回的字符串
                    String string = response.body().string();
                    //[2]返回的二进制字节数组 
                    byte[] bytes = response.body().bytes();
                    //[3]返回的inputStream 
                    InputStream inputStream = response.body().byteStream();
                    //[4]
                    Reader reader = response.body().charStream();
                    //[5]
                    BufferedSource source = response.body().source();
                }
            }
        });

2.post 提交键值对

【post创建的说明】

post请求创建request和get是一样的，只是post请求需要提交一个表单，就是RequestBody。表单的格式有好多种。

【提交键值对】

/**
     * [2]post 提交键值对
     */
    private void okHttpPostWithParam(String url) {
        OkHttpClient okHttpClient = new OkHttpClient();

        /*okhttp2 的写法；
        FormEncodingBuilder builder = new FormEncodingBuilder();
        builder.add("username", "CodingMankk");*/

        //okhttp3的写法
        FormBody formBody = new FormBody.Builder()
                .add("username", "admin")
                .add("password", "admin")
                .build();

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

        Call call = okHttpClient.newCall(request);

        //[1]同步请求
        /*try {
            call.execute();
        } catch (IOException e) {
            e.printStackTrace();
        }*/

        //[2]异步请求
        call.enqueue(new Callback() {
            @Override
            public void onFailure(Call call, IOException e) {
                //请求失败的回调
            }

            @Override
            public void onResponse(Call call, Response response) throws IOException {
                //请求成功的回调；
                //                response 是请求到的数据；
            }
        });
    }

3.post 提交表单

使用 FormEncodingBuilder（2.0）FormBody（3.0） 来构建和HTML <form> 标签相同效果的请求体。

用户注册的情况,需要你输入用户名,密码,还有上传头像,这其实就是一个表单,
主要的区别就在于构造不同的RequestBody传递给post方法即可

表单数据的提交需要：compile 'com.squareup.okio:okio:1.11.0'

MuiltipartBody,是RequestBody的一个子类,提交表单利用MuiltipartBody来构建一个RequestBody,
下面的代码是发送一个包含用户民、密码、头像的表单到服务端

【注意】
【1】如果提交的是表单,一定要设置setType(MultipartBody.FORM)这一句
【2】 addFormDataPart("avatar","avatar.png",requestBodyFile)
 参数1：类似于键值对的键,是供服务端使用的,就类似于网页表单里面的name属性，<input type="file" name="myfile">
 参数2：本地文件的名字
 参数3：第三个参数是RequestBody,里面包含了我们要上传的文件的路径以及MidiaType
【3】本地sd卡的读写权限的添加：<uses-permission android:name="android.permission.WRITE_EXTERNAL_STORAGE"/>

private void okHttpPostFormData(String url) {
        //构造图片文件;
        File file = new File(Environment.getExternalStorageDirectory(), "avatar.png");
        if (!file.exists()) {
            Log.d("okHttpPostFormData", "文件不存在");
            return;
        }

        RequestBody requestBodyFile =
                RequestBody.create(MediaType.parse("application/octet-stream"), file);

        MultipartBody multipartBody = new MultipartBody.Builder()
                //一定要设置这句
                .setType(MultipartBody.FORM)
                .addFormDataPart("username", "admin")
                .addFormDataPart("password", "admin")
                .addFormDataPart("avatar", "avatar.png", requestBodyFile)
                .build();

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

        OkHttpClient okHttpClient = new OkHttpClient();
        Call call = okHttpClient.newCall(request);
        //[1]同步请求；
       /* try {
            call.execute();
        } catch (IOException e) {
            e.printStackTrace();
        }*/

        //[2]异步请求
        call.enqueue(new Callback() {
            @Override
            public void onFailure(Call call, IOException e) {

            }

            @Override
            public void onResponse(Call call, Response response) throws IOException {

            }
        });

    }

【多种类型的multipartBody的构造】

【1】图片文件+字符串；

       //构造图片文件;
        File file = new File(Environment.getExternalStorageDirectory(), "avatar.png");
        if (!file.exists()) {
            Log.d("okHttpPostFormData", "文件不存在");
            return;
        }

        RequestBody requestBodyFile =
                RequestBody.create(MediaType.parse("application/octet-stream"), file);

        MultipartBody multipartBody = new MultipartBody.Builder()
                //一定要设置这句
                .setType(MultipartBody.FORM)
                .addFormDataPart("username", "admin")
                .addFormDataPart("password", "admin")
                .addFormDataPart("avatar", "avatar.png", requestBodyFile)
                .build();
        
        Request request = new Request.Builder()
                .url(url)
                .post(multipartBody)
                .build();

【2】多个string字符串

 Post的时候，参数是包含在请求体中的，通过MultipartBody.Builder 添加多个String键值对，然后去构造RequestBody，最后完成Request的构造

        //POST参数构造MultipartBody.Builder，表单提交
        HashMap<String, String> params = new HashMap<>();
        MultipartBody.Builder MultipartBodyBuilder  = new MultipartBody.Builder()
                                              .setType(MultipartBody.FORM);
        if (params != null) {
            for (String key : params.keySet()) {
                if (params.get(key) != null) {
                    MultipartBodyBuilder.addFormDataPart(key, params.get(key));
                }
            }
        }

        // 构造Request->call->执行
        Request request = new Request.Builder()
                .url(url)
                .post(MultipartBodyBuilder.build())//参数放在body体里
                .build();

3.post 文件上传

3.1 RequestBody的构造

上传文件本身也是一个POST请求。在上面的POST请求中可以知道，POST请求的所有参数都是在BODY体中的，

请求体的源码RequestBody:请求体=contentType +BufferedSink

【RequestBody源码】

【简析】源码中看出，该类是一个抽象类，需要实现；其中具有三个抽象方法；下面是5个Request的create方法。

//抽象类请求体，**请求体=contentType + BufferedSink**
public abstract class RequestBody {
  /** Returns the Content-Type header for this body. */
 //【抽象方法1】返回Body体的内容类型
  public abstract @Nullable MediaType contentType();
  /**
   * Returns the number of bytes that will be written to {@code sink} in a call to {@link #writeTo},
   * or -1 if that count is unknown.
   */
  //【抽象方法2】返回写入sink的字节长度
  public long contentLength() throws IOException {
    return -1;
  }

  /** Writes the content of this request to {@code sink}. */
  //【抽象方法3】写入缓存sink
  public abstract void writeTo(BufferedSink sink) throws IOException;

  /**
   * Returns a new request body that transmits {@code content}. If {@code contentType} is non-null
   * and lacks a charset, this will use UTF-8.
   */
   //【创建的请求体1】创建一个请求体，如果contentType不等于null且缺少字符集，将使用UTF-8
  public static RequestBody create(@Nullable MediaType contentType, String content) {
    Charset charset = Util.UTF_8;
    if (contentType != null) {
      //contentType里面的字符集
      charset = contentType.charset();
      if (charset == null) {
        charset = Util.UTF_8;
        //contentType 里面加入字符集
        contentType = MediaType.parse(contentType + "; charset=utf-8");
      }
    }
    //按字符集变成字节
    byte[] bytes = content.getBytes(charset);
    return create(contentType, bytes);
  }

  /** Returns a new request body that transmits {@code content}. */
 //【创建的请求体2】创建新的请求体，传输字节
  public static RequestBody create(
      final @Nullable MediaType contentType, final ByteString content) {
    return new RequestBody() {
      @Override public @Nullable MediaType contentType() {
        //请求体需要的内容类型
        return contentType;
      }

      @Override public long contentLength() throws IOException {
       //写入BufferedSink 的长度
        return content.size();
      }

      @Override public void writeTo(BufferedSink sink) throws IOException {
       //将需要传输的字节，写入缓存BufferedSink 中
        sink.write(content);
      }
    };
  }

  /** 【创建的请求体3】Returns a new request body that transmits {@code content}. */
  public static RequestBody create(final @Nullable MediaType contentType, final byte[] content) {
    return create(contentType, content, 0, content.length);
  }

  /**【创建的请求体4】 Returns a new request body that transmits {@code content}. */
  public static RequestBody create(final @Nullable MediaType contentType, final byte[] content,
      final int offset, final int byteCount) {
    if (content == null) throw new NullPointerException("content == null");
    Util.checkOffsetAndCount(content.length, offset, byteCount);
    return new RequestBody() {
      @Override public @Nullable MediaType contentType() {
        return contentType;
      }

      @Override public long contentLength() {
        return byteCount;
      }

      @Override public void writeTo(BufferedSink sink) throws IOException {
        sink.write(content, offset, byteCount);
      }
    };
  }

  /** Returns a new request body that transmits the content of {@code file}. */
  //【创建的请求体5】创建一个请求体，传输文件file内容，其实就是file写入bufferedSink
  public static RequestBody create(final @Nullable MediaType contentType, final File file) {
    if (file == null) throw new NullPointerException("content == null");

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

      @Override public long contentLength() {
        return file.length();
      }

      @Override public void writeTo(BufferedSink sink) throws IOException {
        Source source = null;
        try {
         //文件写入BufferedSink 
          source = Okio.source(file);
          sink.writeAll(source);
        } finally {
          Util.closeQuietly(source);
        }
      }
    };
  }
}

 

【MultipartBody】
1. MultipartBody本质一个是一个RequestBody，具有自己的contentType+BufferedSink，是POST请求的最外层封装，需要添加多个Part；

 

2. Part对象组成：Headers+RequestBody。是MultipartBody的成员变量，需要写入MultipartBody的BufferedSink中。

Http请求中Content-Type

客户端在进行http请求服务器的时候，需要告诉服务器请求的类型，服务器在返回给客户端的数据的时候，也需要告诉客户端返回数据的类型默认的ContentType为text/html 也就是网页格式.
 
常用的内容类型
text/plain ：纯文本格式 .txt
text/xml ： XML格式 .xml
image/gif ：gif图片格式 .gif
image/jpeg ：jpg图片格式 .jpg
image/png：png图片格式 .png
audio/mp3 : 音频mp3格式 .mp3
audio/rn-mpeg :音频mpga格式 .mpga
video/mpeg4 : 视频mp4格式 .mp4
video/x-mpg : 视频mpa格式 .mpg
video/x-mpeg :视频mpeg格式 .mpeg
video/mpg : 视频mpg格式 .mpg

以application开头的媒体格式类型：
application/xhtml+xml ：XHTML格式
application/xml ： XML数据格式
application/atom+xml ：Atom XML聚合格式
application/json ： JSON数据格式
application/pdf ：pdf格式
application/msword ： Word文档格式
application/octet-stream ： 二进制流数据（如常见的文件下载）

RequestBody的数据格式都要指定Content-Type，常见的有三种

application/x-www-form-urlencoded 数据是个普通表单 
multipart/form-data 数据里有文件
application/json 数据是个json

普通表单并没有指定Content-Type，这是因为FormBody继承了RequestBody，它已经指定了数据类型为application/x-www-form-urlencoded。 

[普通表单]

RequestBody body = new FormBody.Builder()
.add("键", "值")
.add("键", "值")
...
.build();

[json表单 ]

MediaType JSON = MediaType.parse("application/json; charset=utf-8");
RequestBody body = RequestBody.create(JSON, "你的json");

[数据包含文件 ]

RequestBody requestBody = new MultipartBody.Builder()
                                           .setType(MultipartBody.FORM)
                                           .addFormDataPart("file", file.getName(), RequestBody.create(MediaType.parse("image/png")
                                           .build()

MultipartBody也是继承了RequestBody，看下源码可知它适用于这五种ContentType: 

public static final MediaType MIXED = MediaType.parse("multipart/mixed");
public static final MediaType ALTERNATIVE = MediaType.parse("multipart/alternative");
public static final MediaType DIGEST = MediaType.parse("multipart/digest");
public static final MediaType PARALLEL = MediaType.parse("multipart/parallel");
public static final MediaType FORM = MediaType.parse("multipart/form-data");

 

其他的媒体类型支持参考下面网址中列出的MIME类型：http://www.w3school.com.cn/media/media_mimeref.asp

3.2 单个文件上传

【简单示例】将sd卡的文件读取，然后构造fileBody，使用post请求上传。 

/**
     * [3]post http文件上传
     * 最主要的还是创建合适的RequestBody
     */
    private void okHttpPostFile(String url) {

        OkHttpClient okHttpClient = new OkHttpClient();

        //读取外部的sd卡的文件上传；
        File file = new File(Environment.getExternalStorageDirectory(), "mimi.mp4");
        RequestBody fileBody = RequestBody.create(MediaType.parse("application/octet-stream"),
                file);

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

        Call call = okHttpClient.newCall(request);

        //[1]同步请求；
       /* try {
            call.execute();
        } catch (IOException e) {
            e.printStackTrace();
        }*/

        //[2]异步请求
        call.enqueue(new Callback() {
            @Override
            public void onFailure(Call call, IOException e) {

            }

            @Override
            public void onResponse(Call call, Response response) throws IOException {

            }
        });
    }

3.3 多个文件的上传

【重点】RequestBody create(MediaType contentType, final File file)构造文件请求体RequestBody ,并且添加到MultiPartBody中  

/**
     * [多个文件的上传]
     */

    private void postMultiFile(String url){

        HashMap<String, String> urlHeaders = new HashMap<>();
        
        OkHttpClient client = new OkHttpClient();

        // form 表单形式上传,MultipartBody的内容类型是表单格式，multipart/form-data
        MultipartBody.Builder multiPartBodyBuilder= new MultipartBody
                .Builder()
                .setType(MultipartBody.FORM);

        //参数
        HashMap<String,String> params = new HashMap<>();
        if (params != null) {
            for (String key : params.keySet()) {
                if (params.get(key)!=null){
                    //增加一系列的参数；
                    multiPartBodyBuilder.addFormDataPart(key, params.get(key));
                }
            }
        }
        
        //需要上传的文件，需要携带上传的文件（小型文件 不建议超过500K）
        HashMap<String,String> files= new HashMap<>();
        if (files != null) {
            for (String key : files.keySet()) {
                //重点：RequestBody create(MediaType contentType, final File file)构造文件请求体RequestBody
                RequestBody requestBody = RequestBody.create(MediaType.parse("multipart/form-data"), files.get(key));
                multiPartBodyBuilder.addFormDataPart(key, files.get(key).getClass().getName(),requestBody);
            }
        }
        
        //构造请求request
        Request request = new Request.Builder()
                .headers(urlHeaders == null ? new Headers.Builder().build() : Headers.of(urlHeaders))
                .url(url)
                .post(multiPartBodyBuilder.build())
                .build();
        
        //异步执行请求
        client.newCall(request).enqueue(new Callback() {
            @Override
            public void onFailure(Call call, IOException e) {
                
            }

            @Override
            public void onResponse(Call call, Response response) throws IOException {
                //非主线程
                if (response.isSuccessful()) {
                    String str = response.body().string();
                    Log.i("tk", response.message() + " , body " + str);

                } else {
                    Log.i("tk" ,response.message() + " error : body " + response.body().string());
                }
            }
        });
    }

 

 

6.post json 请求

/**
     * [5]post json 请求；
     */
    private void okHttpPostJSon(String url, String json) throws IOException {

        OkHttpClient okHttpClient = new OkHttpClient();

        MediaType JSON = MediaType.parse("application/json; charset=utf-8");
        RequestBody requestBody = RequestBody.create(JSON, json);

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

        Call call = okHttpClient.newCall(request);
        //[1]同步请求;
        call.execute();
        //[2]异步请求;
        call.enqueue(new Callback() {
            @Override
            public void onFailure(Call call, IOException e) {

            }

            @Override
            public void onResponse(Call call, Response response) throws IOException {

            }
        });

    }

7.使用Gson来解析JSON响应

/**
     * [6]使用Gson来解析JSON响应
     * <p>
     * Gson是一个在JSON和Java对象之间转换非常方便的api。这里我们用Gson来解析Github API的JSON响应。
     * 注意： ResponseBody.charStream() 使用响应头 Content-Type 指定的字符集来解析响应体。默认是UTF-8。
　　　　　* 添加依赖： compile 'com.google.code.gson:gson:2.6.2'
     */
    private void ParseGson(String url) {
        OkHttpClient okHttpClient = new OkHttpClient();
        
        final Gson gson = new Gson();
        
        //默认是get请求；
        final Request request = new Request.Builder()
                .url("https://api.github.com/gists/c2a7c39532239ff261be")
                .build();
        
        Call call = okHttpClient.newCall(request);
        
        call.enqueue(new Callback() {
            @Override
            public void onFailure(Call call, IOException e) {

            }

            @Override
            public void onResponse(Call call, Response response) throws IOException {
                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);
                }
            }
        });
    }

    private static class Gist {
        Map<String, GistFile> files;
    }

    private static class GistFile {
        String content;
    }

8.get请求文件下载

/**
     * [6] get请求文件下载
     * 此处的实例是下载图片
     */
    private void okHttpGetDownLoadFile(String url) {
        OkHttpClient okHttpClient = new OkHttpClient();
        final Request request = new Request.Builder()
                .get()
                .url(url)
                .build();

        Call call = okHttpClient.newCall(request);
        call.enqueue(new Callback() {
            @Override
            public void onFailure(Call call, IOException e) {

            }

            @Override
            public void onResponse(Call call, Response response) throws IOException {
                //拿到图片的字节流,然后保存为了本地的一张图片
                if (response.isSuccessful()) {
                    //获取数据流；
                    InputStream is = response.body().byteStream();

                    //读到文件中;
                    int len = 0;
                    File file = new File(Environment.getExternalStorageDirectory(), "downLoadFile" +
                            ".png");
                    FileOutputStream fos = new FileOutputStream(file);

                    byte[] buf = new byte[1024];
                    while ((len = is.read(buf)) != -1) {
                        fos.write(buf, 0, len);
                    }
                    fos.flush();
                    fos.close();
                    is.close();
                }


           /*   直接将图片设置给了ImagView；
                final Bitmap bitmap = BitmapFactory.decodeStream(is);
                runOnUiThread(new Runnable() {
                    @Override
                    public void run() {
                        imageView.setImageBitmap(bitmap);
                    }
                });
                is.close();*/
            }
        });


    }

9.给文件的下载加上进度条

/**
     * [7] 给文件的下载加上进度条
     * 进度的获取是在回调函数onResponse()中去获取
     * (1)使用response.body().contentLength()拿到文件总大小
     * (2)在while循环中每次递增我们读取的buf的长度
     */

    private void okHttpDownLoadWithProgress(String url) {
        OkHttpClient okHttpClient = new OkHttpClient();
        final Request request = new Request.Builder()
                .get()
                .url(url)
                .build();

        Call call = okHttpClient.newCall(request);
        call.enqueue(new Callback() {
            @Override
            public void onFailure(Call call, IOException e) {

            }

            @Override
            public void onResponse(Call call, Response response) throws IOException {
                //拿到图片的字节流,然后保存为了本地的一张图片
                if (response.isSuccessful()) {
                    //获取数据流；
                    InputStream is = response.body().byteStream();

                    //每次下载的实时更新的进度；
                    long sum = 0;
                    //下载的文件总长度；
                    final long total = response.body().contentLength();

                    //读到文件中;
                    int len = 0;
                    File file = new File(Environment.getExternalStorageDirectory(), "downLoadFile" +
                            ".png");
                    FileOutputStream fos = new FileOutputStream(file);

                    byte[] buf = new byte[1024];
                    while ((len = is.read(buf)) != -1) {
                        fos.write(buf, 0, len);

                        sum += len;
                        final long finalSum = sum;
                        Log.d("okHttp", "下载进度：" + finalSum + "/" + total);

                        //将进度设置到主线程显示
                       /* runOnUiThread(new Runnable() {
                            @Override
                            public void run() {
                                //将进度设置到TextView中
                                contentTv.setText(finalSum + "/" + total);
                            }
                        });*/

                    }
                    fos.flush();
                    fos.close();
                    is.close();
                }
            }

        });

    }

【另外一种写法】

 /**
     * @param url 下载连接
     * @param saveDir 储存下载文件的SDCard目录
     * @param params url携带参数
     * @param extraHeaders 请求携带其他的要求的headers
     * @param listener 下载监听
     */
    public void download(final String url, final String saveDir, 
                         HashMap<String,String> params, HashMap<String,String> extraHeaders,
                                 final OnDownloadListener listener) {

        OkHttpClient okHttpClient = new OkHttpClient();
        //构造请求Url
        HttpUrl.Builder urlBuilder = HttpUrl.parse(url).newBuilder();
        if (params != null) {
            for (String key : params.keySet()) {
                if (params.get(key)!=null){
                    urlBuilder.setQueryParameter(key, params.get(key));//非必须
                }
            }
        }
        //构造请求request
        Request request = new Request.Builder()
                .url(urlBuilder.build())
                .headers(extraHeaders == null ? new Headers.Builder().build() : Headers.of(extraHeaders))//headers非必须
                .get()
                .build();
        
        //异步执行请求
        okHttpClient.newCall(request).enqueue(new Callback() {
            @Override
            public void onFailure(Call call, IOException e) {
                // 下载失败
                listener.onDownloadFailed();
            }
            @Override
            public void onResponse(Call call, Response response) throws IOException {
                //非主线程
                InputStream is = null;
                byte[] buf = new byte[2048];
                int len = 0;
                FileOutputStream fos = null;
                // 储存下载文件的目录
                String savePath = isExistDir(saveDir);
                try {
                    //获取响应的字节流
                    is = response.body().byteStream();
                    //文件的总大小
                    long total = response.body().contentLength();
                    File file = new File(savePath);
                    fos = new FileOutputStream(file);
                    long sum = 0;
                    //循环读取输入流
                    while ((len = is.read(buf)) != -1) {
                        fos.write(buf, 0, len);
                        sum += len;
                        int progress = (int) (sum * 1.0f / total * 100);
                        // 下载中
                        if(listener != null){
                            listener.onDownloading(progress);
                        }

                    }
                    fos.flush();
                    // 下载完成
                    if(listener != null){
                        listener.onDownloadSuccess();
                    }

                } catch (Exception e) {
                    if(listener != null){
                        listener.onDownloadFailed();
                    }

                } finally {
                    try {
                        if (is != null)
                            is.close();
                    } catch (IOException e) {
                    }
                    try {
                        if (fos != null)
                            fos.close();
                    } catch (IOException e) {
                    }
                }
            }
        });
    }

10.文件的上传增加进度

/**
     * [8]文件的上传增加进度
     * 对于上传的进度的处理会比较麻烦,因为具体的上传过程是在RequestBody中由OkHttp帮我们处理上传,
     * 而且OkHttp并没有给我们提供上传进度的接口,这里做法是自定义类继承RequestBody,
     * 然后重写其中的方法,将其中的上传进度通过接口回调暴露出来供使用
     * 详见：包下的progressRequestBody类；
     * 在原有的RequestBody上包装了一层,最后在我们的使用中在post()方法中传入我们的CountingRequestBody对象即可
     * <p>
     * 最主要的还是创建合适的RequestBody
     */
    private void okHttpPostFileWithProgress(String url) {

        OkHttpClient okHttpClient = new OkHttpClient();

        //读取外部的sd卡的文件上传；
        File file = new File(Environment.getExternalStorageDirectory(), "mimi.mp4");
        //        RequestBody fileBody = RequestBody.create(MediaType.parse
        // ("application/octet-stream"),file);

        //*****此处使用的RequestBody是经过修改；
        RequestBody fileBody = progressRequestBody.create(MediaType.parse
                ("application/octet-stream"), file);

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

        Call call = okHttpClient.newCall(request);

        //[1]同步请求；
       /* try {
            call.execute();
        } catch (IOException e) {
            e.printStackTrace();
        }*/

        //[2]异步请求
        call.enqueue(new Callback() {
            @Override
            public void onFailure(Call call, IOException e) {

            }

            @Override
            public void onResponse(Call call, Response response) throws IOException {

            }
        });
    }

【progressRequestBody类的实现】

package com.oztaking.www.a02_okhttp.okHttpUtils;

import java.io.IOException;

import okhttp3.MediaType;
import okhttp3.RequestBody;
import okhttp3.ResponseBody;
import okio.Buffer;
import okio.BufferedSink;
import okio.ForwardingSink;
import okio.Okio;
import okio.Sink;


/**
 * [8]文件的上传增加进度
 * 对于上传的进度的处理会比较麻烦,因为具体的上传过程是在RequestBody中由OkHttp帮我们处理上传,
 * 而且OkHttp并没有给我们提供上传进度的接口,这里做法是自定义类继承RequestBody,
 * 然后重写其中的方法,将其中的上传进度通过接口回调暴露出来供使用
 * 实质：在原有的RequestBody上包装了一层,最后在我们的使用中在post()方法中传入我们的CountingRequestBody对象即可
 */

public class progressRequestBody extends RequestBody {

    //实际要使用的requestBody
    private ResponseBody mDelegate;
    //回调监听
    private okHttpUpLoadProgressListener mListener;
    private CountingSink countingSink;

    public progressRequestBody(ResponseBody mDelegate, okHttpUpLoadProgressListener mListener) {
        this.mDelegate = mDelegate;
        this.mListener = mListener;
    }

    @Override
    public MediaType contentType() {
        return mDelegate.contentType();
    }

    /* 返回文件总的字节大小
     * 如果文件大小获取失败则返回-1*/
    @Override
    public long contentLength() {
        return mDelegate.contentLength();
    }

    @Override
    public void writeTo(BufferedSink sink) throws IOException {
        countingSink = new CountingSink(sink);
        //将CountingSink转化为BufferedSink供writeTo()使用
        BufferedSink bufferedSink = Okio.buffer(countingSink);
        bufferedSink.flush();
    }


    protected final class CountingSink extends ForwardingSink {

        private long byteWritten;

        public CountingSink(Sink delegate) {
            super(delegate);
        }

        /**
         * **
         * 上传时调用该方法,在其中调用回调函数将上传进度暴露出去,
         * 该方法提供了缓冲区的自己大小
         * @param source
         * @param byteCount
         * @throws IOException
         */

        @Override
        public void write(Buffer source, long byteCount) throws IOException {
            super.write(source, byteCount);
            byteWritten += byteCount;
            mListener.onRequestProgress(byteWritten,contentLength());
        }
    }


    public static interface okHttpUpLoadProgressListener {
        /**
         * 暴露出上传进度
         *
         * @param byteWritten   已经上传的字节大小
         * @param contentLength 文件的总字节大小
         */
        void onRequestProgress(long byteWritten, long contentLength);
    }
}

11.同步get

/**
     * [9] 同步get
     * 下载一个文件，打印他的响应头，以string形式打印响应体。
     * 响应体的 string() 方法对于小文档来说十分方便、高效。但是如果响应体太大（超过1MB），应避免适应
     * string() 方法 ，因为他会将把整个文档加载到内存中。
     * 对于超过1MB的响应body，应使用流的方式来处理body。
     */
    private void okHttpGetSyncHeader(String url) throws IOException {

        OkHttpClient okHttpClient = new OkHttpClient();
        Request request = new Request.Builder()
                .url(url)
                .build();

        Call call = okHttpClient.newCall(request);
        //同步请求；
        Response response = call.execute();
        if (!response.isSuccessful()) {
            throw new IOException("response error" + response);
        }
        //获取到response的头部；
        Headers responseHeaders = response.headers();
        int len = responseHeaders.size();
        for (int i = 0; i < len; i++) {
            //response的头部的每个信息
            System.out.println(responseHeaders.name(i) + ":" + responseHeaders.value(i));
        }
        //打印头部的所有信息；
        System.out.println(response.body().string());
    }

12.异步get

 /**
     * [10]异步get
     *
     * @param url
     */
    private void okHttpGetASyncHeader(String url) {
        OkHttpClient okHttpClient = new OkHttpClient();
        Request request = new Request.Builder()
                .url(url)
                .get()
                .build();
        Call call = okHttpClient.newCall(request);
        call.enqueue(new Callback() {
            @Override
            public void onFailure(Call call, IOException e) {

            }

            @Override
            public void onResponse(Call call, Response response) throws IOException {
                if (!response.isSuccessful()) {
                    throw new IOException("Unexpected code " + response);
                }
                //获取到response的头部；
                Headers headers = response.headers();
                int len = headers.size();
                for (int i = 0; i < len; i++) {
                    //response的头部的每个信息
                    System.out.println("responseHeaders:" + headers.name(i) + ":" + headers.value
                            (i));
                }
                //打印头部的所有信息；
                System.out.println(response.body().string());
            }
        });
    }

13.提取响应头

/**
     * [11] 提取响应头
     * 典型的HTTP头 像是一个 Map<String, String> :每个字段都有一个或没有值。
     * 但是一些头允许多个值，像Guava的Multimap。
     * 例如：HTTP响应里面提供的 Vary 响应头，就是多值的。OkHttp的api试图让这些情况都适用。
     * 【header(name, value)】 可以设置唯一的name、value。
     * 如果已经有值，旧的将被移除，然后添加新的。
     * 【addHeader(name, value)】 可以添加多值（添加，不移除已有的）。
     * 当读取响应头时，使用 header(name) 返回最后出现的name、value。
     * 通常情况这也是唯一的name、value。
     * 如果没有值，那么 header(name) 将返回null。
     * 如果想读取字段对应的所有值，使用 headers(name) 会返回一个list（如上例）。
     * 为了获取所有的Header，Headers类支持按index访问。
     */

    private void addHeaders(String url) {
        OkHttpClient okHttpClient = new OkHttpClient();

        Request request = new Request.Builder()
                .url(url)
                .header("User-Agent", "OkHttp Headers.java")
                .addHeader("Accept", "application/json:q=0.5")
                .addHeader("Accept", "application/vnd.github.v3+json")
                .build();

        Call call = okHttpClient.newCall(request);
        call.enqueue(new Callback() {
            @Override
            public void onFailure(Call call, IOException e) {

            }

            @Override
            public void onResponse(Call call, Response response) throws IOException {
                System.out.println(response.header("Server"));
                System.out.println(response.header("Date"));
                System.out.println(response.headers("Vary"));
            }
        });
    }

14.post 提交String

/**
     * [11]post 提交String
     * 提交了一个markdown文档到web服务，以HTML方式渲染markdown。
     * 因为整个请求体都在内存中，因此避免使用此api提交大文档（大于1MB）。
     */

    private void okHttpPostString(String url) {
        MediaType mediaType = MediaType.parse("text/x-markdown; charset=utf-8");
        OkHttpClient okHttpClient = new OkHttpClient();
        String postBody = ""
                + "Releases\n"
                + "--------\n"
                + "\n"
                + " * _1.0_ May 6, 2013\n"
                + " * _1.1_ June 15, 2013\n"
                + " * _1.2_ August 11, 2013\n";

        //创建请求体
        RequestBody requestBody = RequestBody.create(mediaType, postBody);

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

        Call call = okHttpClient.newCall(request);
        call.enqueue(new Callback() {
            @Override
            public void onFailure(Call call, IOException e) {

            }

            @Override
            public void onResponse(Call call, Response response) throws IOException {
                if (!response.isSuccessful())
                    throw new IOException("Unexpected code " + response);
                System.out.println(response.body().string());
            }
        });

    }

15.post 方式提交流

/**
     * [12]post 方式提交流
     * <p>
     * 以流的方式POST提交请求体。请求体的内容由流写入产生。
     * 这个例子是流直接写入Okio的BufferedSink。
     * 你的程序可能会使用 OutputStream ，你可以使用 BufferedSink.outputStream()来获取
     */

    private void okHttpPostStream(String url) {

        final MediaType mediaType = MediaType.parse("text/x-markdown; charset=utf-8");

        OkHttpClient okHttpClient = new OkHttpClient();

        RequestBody requestBody = new RequestBody() {
            @Override
            public MediaType contentType() {
                return mediaType;
            }

            @Override
            public void writeTo(BufferedSink sink) throws IOException {
                /**
                 * 关键的方法：sink.writeUtf8
                 */
                sink.writeUtf8("Numbers\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(url)
                .post(requestBody)
                .build();
        Call call = okHttpClient.newCall(request);
        call.enqueue(new Callback() {
            @Override
            public void onFailure(Call call, IOException e) {

            }

            @Override
            public void onResponse(Call call, Response response) throws IOException {
                if (!response.isSuccessful()) throw new IOException("Unexpected code " + response);
                System.out.println(response.body().string());
            }
        });
    }

16.响应缓存

/**
     * [13]响应缓存----没有弄明白；
     * 【注意】Okhttp仅支持get请求缓存，其他请求方式需要自己实现 
     *
     * 缓存响应：需要建立可以读写的缓存目录和限定缓存大小。
     * 建立的缓存目录应该是私有的，不信任的程序应不能读取缓存内容。
     * 一个缓存目录不能同时拥有多个缓存访问。
     * 大多数程序只需要调用一次 new OkHttp() ，在第一次调用时配置好缓存，然后其他使用到的地方只需要调用这个实例。
     * 否则两个缓存示例互相干扰，破坏响应缓存，而且有可能会导致程序崩溃。
     * 响应缓存使用HTTP头作为配置。
     * 你可以在请求头中添加 Cache-Control: max-stale=3600 ,OkHttp缓存会支持。
     * 你的服务通过响应头确定响应缓存多长时间，例如使用 Cache-Control: max-age=9600
     */

    private void okHttCacheResponse(File cacheDirector) {

        //使用OkHttp的Cache，首先需要指定缓存的路径和大小
        int cacheSize = 10 * 1024 * 1024;
        Cache cache = new Cache(cacheDirector, cacheSize);

        OkHttpClient okHttpClient
                = new OkHttpClient()
                .newBuilder()
                .cache(cache)
                .build();

        Request request = new Request.Builder()
                .url("http://publicobject.com/helloworld.txt")
                .build();

        Call call1 = okHttpClient.newCall(request);
        call1.enqueue(new Callback() {
            @Override
            public void onFailure(Call call, IOException e) {

            }

            @Override
            public void onResponse(Call call, Response response1) throws IOException {
                if (!response1.isSuccessful())
                    throw new IOException("Unexpected code " + response1);

                String s = response1.body().string();
                Logger.d("response1:"+s);
                Logger.d("response1 Cache response:"+response1.cacheResponse());
                Logger.d("response1 network response:"+response1.networkResponse());
            }
        });

        Call call2 = okHttpClient.newCall(request);
        call2.enqueue(new Callback() {
            @Override
            public void onFailure(Call call, IOException e) {

            }

            @Override
            public void onResponse(Call call, Response response2) throws IOException {
                if (!response2.isSuccessful())
                    throw new IOException("Unexpected code " + response2);

                String s = response2.body().string();
                Logger.d("response2:"+s);
                Logger.d("response2 Cache response:"+response2.cacheResponse());
                Logger.d("response2 network response:"+response2.networkResponse());
            }
        });

//        System.out.println("Response 2 equals Response 1? " +
//                response2.equals(response1));
    }

17.取消一个Call

/**
     * [14]取消一个Call--没有弄明白；
     *
     * 使用 Call.cancel() 可以立即停止掉一个正在执行的call。
     * 如果一个线程正在写请求或者读响应，将会引发IOException 。
     * 当call没有必要的时候，使用这个api可以节约网络资源。
     * 例如当用户离开一个应用时。不管同步还是异步的call都可以取消。
     * 你可以通过tags来同时取消多个请求。
     * 当你构建一请求时，使用 RequestBuilder.tag(tag) 来分配一个标签。
     * 之后你就可以用 OkHttpClient.cancel(tag) 来取消所有带有这个tag的call
     */
    private void okHttpCancelCall(){

        ScheduledExecutorService executor = Executors.newScheduledThreadPool(1);
        OkHttpClient okHttpClient = new OkHttpClient();

        Request request = new Request.Builder()
                .url("http://httpbin.org/delay/2")// This URL is served with a 2 second delay.
                .tag(1)
                .build();

        final long nanoTime = System.nanoTime();
        final Call call = okHttpClient.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() - nanoTime) / 1e9f);
                call.cancel();
                System.out.printf("%.2f Canceled ------call.%n", (System.nanoTime() - nanoTime) / 1e9f);
            }
        },1, TimeUnit.SECONDS);

        System.out.printf("%.2f Canceling #### call.%n",(System.nanoTime() - nanoTime) / 1e9f);
        call.enqueue(new Callback() {
            @Override
            public void onFailure(Call call, IOException e) {

            }

            @Override
            public void onResponse(Call call, Response response) throws IOException {
                System.out.printf("%.2f Call was  $$$$$ bexpected to fail, but completed: %s%n",
                        (System.nanoTime() - nanoTime) / 1e9f, response);
            }
        });


    }

18.设置超时时间

/**
     * [15]超时
     * 没有响应时使用超时结束call。
     * 没有响应的原因可能是客户点链接问题、服务器可用性问题或者这之间的其他东西。
     * OkHttp支持连接，读取和写入超时。
     */

    private void okHttpTimeout(){
        OkHttpClient okHttpClient = new OkHttpClient().newBuilder()
                .connectTimeout(1,TimeUnit.SECONDS)
                .readTimeout(1,TimeUnit.SECONDS)
                .writeTimeout(1,TimeUnit.SECONDS)
                .pingInterval(10,TimeUnit.SECONDS) //websocket 轮训间隔
                .build();

        Request request = new Request.Builder()
                .url("http://httpbin.org/delay/2") // This URL is served with a 2 second delay.
                .build();

        Call call = okHttpClient.newCall(request);
        call.enqueue(new Callback() {
            @Override
            public void onFailure(Call call, IOException e) {

            }

            @Override
            public void onResponse(Call call, Response response) throws IOException {
                System.out.println("Response completed: " + response.body().string());
            }
        });
    }

19.配置call

/**
     * [16]每个call的配置--clone
     * 使用 OkHttpClient ，所有的HTTP Client配置包括代理设置、超时设置、缓存设置。当你需要为单个call改变
     * 配置的时候，clone 一个 OkHttpClient 。这个api将会返回一个浅拷贝（shallow copy），你可以用来单独自
     * 定义。下面的例子中，我们让一个请求是500ms的超时、另一个是3000ms的超时。
     */


  /*  public void run() throws Exception {
        final OkHttpClient client = new OkHttpClient();
        Request request = new Request.Builder()
                .url("http://httpbin.org/delay/1") // This URL is served with a 1 second delay.
                .build();
        try {
            Response response = client.clone() // Clone to make a customized OkHttp for this
            request..setReadTimeout(500, TimeUnit.MILLISECONDS)
                    .newCall(request)
                    .execute();
            System.out.println("Response 1 succeeded: " + response);
        } catch (IOException e) {
            System.out.println("Response 1 failed: " + e);
        }
        try {
            Response response = client.clone() // Clone to make a customized OkHttp for this
            request..setReadTimeout(3000, TimeUnit.MILLISECONDS)
                    .newCall(request)
                    .execute();
            System.out.println("Response 2 succeeded: " + response);
        } catch (IOException e) {
            System.out.println("Response 2 failed: " + e);
        }
    }*/


    private void OkHttpCallConfigure(){
        OkHttpClient okHttpClient = new OkHttpClient();
        Request request = new Request.Builder()
                .url("http://httpbin.org/delay/1") // This URL is served with a 1 second delay
                .build();

        Call call = okHttpClient.newCall(request);
        Call clone = call.clone();

    }

20.Cookie 保存

/**
     * [17]Cookie 保存
     * Request经常都要携带Cookie，上面说过request创建时可以通过header设置参数，Cookie也是参数之一
     * 然后可以从返回的response里得到新的Cookie，可能得想办法把Cookie保存起来。
     * 但是OkHttp可以不用我们管理Cookie，自动携带，保存和更新Cookie。
     * 方法是在创建OkHttpClient设置管理Cookie的CookieJar
     *
     */
    private void OkHttpCookieSave(String url){

        final HashMap<String, List<Cookie>> cookieStore = new HashMap<>();

        OkHttpClient okHttpClient = new OkHttpClient().newBuilder()
                .cookieJar(new CookieJar() {
                    @Override
                    public void saveFromResponse(HttpUrl url, List<Cookie> cookies) {
                        // 保存cookie通常使用SharedPreferences
                        cookieStore.put(url.host(), cookies);
                    }

                    @Override
                    public List<Cookie> loadForRequest(HttpUrl url) {
                        // 从保存位置读取，注意此处不能为空，否则会导致空指针
                        List<Cookie> cookies = cookieStore.get(url.host());
                        return cookies != null ? cookies : new ArrayList<Cookie>();

                    }
                })
                .build();

        Request request = new Request.Builder()
                .url(url)
                .header("Cookie", "xxx") //添加cookie；
              .build();
    }

21.添加拦截器

/**
     * [21]添加拦截器
     * okHttp3的实现使用的是链式的拦截器，同时也开放了自定义拦截器接口
     */
    private void okHttpAddInterceptor(){
        new OkHttpClient.Builder()
                // 此种拦截器将会在请求开始的时候调用
                .addInterceptor(new Interceptor() {
                    @Override
                    public Response intercept(Chain chain) throws IOException {
                        return null;
                    }
                })
                // 连接成功，读写数据前调用
                .addNetworkInterceptor(new Interceptor() {
                    @Override
                    public Response intercept(Chain chain) throws IOException {
                        return null;
                    }
                }).build();
    }

22.https的支持

 /**
     *  [22]https的支持添加
     *  okhttp3完全支持https，设置证书即可
     *  未完成，报错；
     */
    private void okHttpHttps(){
        OkHttpClient okHttpClient = new OkHttpClient.Builder()
                .sslSocketFactory(SSLSocketFactory(), X509TrustManager)
                .build();
    }

23.Websocket支持

    /**
     * [23]Websocket支持
     * okhttp3支持websocket,简易推送，轮训都可以使用
     * websocket协议首先会发起http请求，握手成功后，转换协议保持长连接，类似心跳
     *
     * 【说明】创建一个OkHttpClient，通常是单例，
     *  如果要自定义一些属性那就要用内部的Builder来构造
     *
     *  [参考文章]https://blog.csdn.net/xlh1191860939/article/details/75452342/
     */

    private void okHttpWebSocket(String url){
        OkHttpClient okHttpClient = new OkHttpClient.Builder().build();
        Request request = new Request.Builder()
                .url(url)
                .build();
        okHttpClient.newWebSocket(request, new WebSocketListener() {
            @Override
            public void onOpen(WebSocket webSocket, Response response) {
                super.onOpen(webSocket, response);
                // 连接成功
            }

            @Override
            public void onMessage(WebSocket webSocket, String text) {
                super.onMessage(webSocket, text);
                // 当收到文本消息
            }

            @Override
            public void onMessage(WebSocket webSocket, ByteString bytes) {
                super.onMessage(webSocket, bytes);
                // 收到字节消息，可转换为文本
            }

            @Override
            public void onClosing(WebSocket webSocket, int code, String reason) {
                super.onClosing(webSocket, code, reason);

            }

            @Override
            public void onClosed(WebSocket webSocket, int code, String reason) {
                super.onClosed(webSocket, code, reason);
                // 连接被关闭
            }

            @Override
            public void onFailure(WebSocket webSocket, Throwable t, Response response) {
                super.onFailure(webSocket, t, response);
                // 连接失败
            }
        });
    }

24.混淆

在混淆文件（proguard-rules.pro）中添加如下语句：
-dontwarn okhttp3.**

 【参考文章】

【1】https://www.jianshu.com/p/9aa969dd1b4d

【2】http://www.cnblogs.com/ct2011/p/3997368.html
【3】https://www.jianshu.com/p/1873287eed87

 

 

 

/**
     * [3]post http文件上传
     * 最主要的还是创建合适的RequestBody
     */
    private void okHttpPostFile(String url) {

        OkHttpClient okHttpClient = new OkHttpClient();

        //读取外部的sd卡的文件上传；
        File file = new File(Environment.getExternalStorageDirectory(), "mimi.mp4");
　　　　　　　//关键是requestBody的构造
        RequestBody fileBody = RequestBody.create(MediaType.parse("application/octet-stream"),file);

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

        Call call = okHttpClient.newCall(request);

        //[1]同步请求；
       /* try {
            call.execute();
        } catch (IOException e) {
            e.printStackTrace();
        }*/

        //[2]异步请求
        call.enqueue(new Callback() {
            @Override
            public void onFailure(Call call, IOException e) {

            }

            @Override
            public void onResponse(Call call, Response response) throws IOException {

            }
        });
    }

 

 

 

 

 

 

 

 

5.Post方式提交分块请求

/**
     * [4-2] Post方式提交分块请求
     * MultipartBuilder 可以构建复杂的请求体，与HTML文件上传形式兼容。
     * 多块请求体中每块请求都是一个请求体，可以定义自己的请求头。
     * 这些请求头可以用来描述这块请求，例如他的 Content-Disposition 。
     * 如果 Content-Length 和 Content-Type 可用的话，他们会被自动添加到请求头中
     *
     * @param url
     * @throws Exception 【注意】上面的描述是基于okhttp2.0;代码是基于okhttp3.0；
     */
    private void okHttpPostBlockData(String url) throws Exception {

        final String IMGUR_CLIENT_ID = "...";
        final MediaType MEDIA_TYPE_PNG = MediaType.parse("image/png");
        OkHttpClient client = new OkHttpClient();

        MultipartBody multipartBody = new MultipartBody.Builder()
                .setType((MultipartBody.FORM))
                .addPart(Headers.of("Content-Disposition", "form-data; name=\"title\""),
                        RequestBody.create(null, "Square Logo"))
                .addPart(Headers.of("Content-Disposition", "form-data; name=\"image\""),
                        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("")
                .post(multipartBody)
                .build();

        Response response = client.newCall(request).execute();
        if (!response.isSuccessful()) throw new IOException("Unexpected code " + response);
        System.out.println(response.body().string());
    }