okhttp3_okhttp3封装 - CSDN
精华内容
参与话题
  • OkHttp3详细使用教程

    千次阅读 2017-10-24 22:40:58
    OkHttp现在应该算是最火的OkHttp,Retrofit底层也是使用OkHttp,网上很多教程都写的不错,但是有些我认为重要的知识,大多一笔带过,所以我决定写一篇入门文章 OkHttp官网地址:http://square.github.io/okhttp/...

    概述

    OkHttp现在应该算是最火的OkHttp,Retrofit底层也是使用OkHttp,网上很多教程都写的不错,但是有些我认为重要的知识,大多一笔带过,所以我决定写一篇入门文章

    OkHttp官网地址:http://square.github.io/okhttp/ 
    OkHttp GitHub地址:https://github.com/square/okhttp

    出现背景

    网络访问的高效性要求,可以说是为高效而生

    解决思路

    1. 提供了对 HTTP/2 和 SPDY 的支持,这使得对同一个主机发出的所有请求都可以共享相同的套接字连接
    2. 如果 HTTP/2 和 SPDY 不可用,OkHttp 会使用连接池来复用连接以提高效率
    3. 提供了对 GZIP 的默认支持来降低传输内容的大小
    4. 提供了对 HTTP 响应的缓存机制,可以避免不必要的网络请求
    5. 当网络出现问题时,OkHttp 会自动重试一个主机的多个 IP 地址

    OkHttp3设计思路

    这里写图片描述

    Requests(请求)

    每一个HTTP请求中都应该包含一个URL,一个GET或POST方法以及Header或其他参数,当然还可以含特定内容类型的数据流。

    Responses(响应)

    响应则包含一个回复代码(200代表成功,404代表未找到),Header和定制可选的body。

    二、使用教程

    2.1、GRADLE引入包

    compile 'com.squareup.okhttp3:okhttp:3.2.0'
    • 1

    2.2、创建OkHttpClient实例

    简单来说,通过OkHttpClient可以发送一个Http请求,并读取该Http请求的响应,它是一个生产Call的工厂。 
    此外,受益于一个共享的响应缓存/线程池/复用的连接等因素,绝大多数应用使用一个OkHttpClient实例,便可以满足整个应用的Http请求。

    三种创建实例的方法:

    • 创建一个默认配置OkHttpClient,可以使用默认的构造函数。
    • 通过new OkHttpClient.Builder()方法来一步一步配置一个OkHttpClient实例。
    • 如果要求使用现有的实例,可以通过newBuilder()方法来进行构造。
    OkHttpClient client = new OkHttpClient();
    OkHttpClient clientWith30sTimeout = client.Builder()
        .readTimeout(30, TimeUnit.SECONDS)
        .build();
    OkHttpClient client  = client.newBuilder().build();
    • 1
    • 2
    • 3
    • 4
    • 5

    看一下OkHttpClient的源码,会发现缓存/代理等等需求,一应俱全的按照类封装到了Builder中。

    Dispatcher dispatcher;          // 分发
    Proxy proxy;                    // 代理
    List<Protocol> protocols;
    List<ConnectionSpec> connectionSpecs;
    final List<Interceptor> interceptors = new ArrayList<>(); // 拦截器
    final List<Interceptor> networkInterceptors = new ArrayList<>(); // 网络拦截器
    ProxySelector proxySelector;
    CookieJar cookieJar;
    Cache cache;    // 缓存
    InternalCache internalCache;
    SocketFactory socketFactory;
    SSLSocketFactory sslSocketFactory;
    HostnameVerifier hostnameVerifier;
    CertificatePinner certificatePinner;
    Authenticator proxyAuthenticator;   // 代理证书
    Authenticator authenticator;        // 证书
    ConnectionPool connectionPool;
    Dns dns;        // DNS
    boolean followSslRedirects;
    boolean followRedirects;
    boolean retryOnConnectionFailure;
    int connectTimeout;
    int readTimeout;
    int writeTimeout;
    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    • 15
    • 16
    • 17
    • 18
    • 19
    • 20
    • 21
    • 22
    • 23
    • 24

    2.3、GET

    OkHttpClient client = new OkHttpClient();
    
    String run(String url) throws IOException {
      Request request = new Request.Builder()
          .url(url)
          .build();
    
      Response response = client.newCall(request).execute();
      return response.body().string();
    }
    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10

    Request

    简单看一下Request类,可以发现它代表一个Http请求,需要注意的是Request一旦build()之后,便不可修改。

    主要通过new Request.Builder()来一步一步构造的。看一下Builder的代码。

    public Builder() {
      this.method = "GET";
      this.headers = new Headers.Builder();
    }
    • 1
    • 2
    • 3
    • 4

    默认是Get方法, 
    此外还创建了头信息。Headers类中是通过List<String> namesAndValues = new ArrayList<>(20),来存放头信息的,一开始我也很纳闷,头信息都是一对一对的为什么要用List,看一下源码发现,在存取的时候都是将索引+2或者-2。并且头信息可以存在多个相同的Key信息。

    发起请求

    跟到newCall()方法中发现,又使用OkHttpClient实例和Request的实例,一起构造了一个RealCall的实例。

    RealCall类简单做了一个托管并通过Dispather类对请求进行分发和执行,实际开启线程发起请求的方法就在这个类中。

    随后又调用execute()方法,拿到了一个响应。这个execute()方法,实际上执行的就是RealCall中的execute()方法,最后调用了Dispatcher的execute()方法。

    Response

    Response代表一个Http的响应,这个类的实例不可修改。

    一个简单的Get请求和说明就结束了

    2.4、POST

    2.4.1、POST提交字符串

    public static final MediaType JSON
        = MediaType.parse("application/json; charset=utf-8");
    
    OkHttpClient client = new OkHttpClient();
    
    String post(String url, String json) throws IOException {
      RequestBody body = RequestBody.create(JSON, json);
      Request request = new Request.Builder()
          .url(url)
          .post(body)
          .build();
      Response response = client.newCall(request).execute();
      return response.body().string();
    }
    
    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    • 15

    MediaType用于描述Http请求和响应体的内容类型,也就是Content-Type

    一次请求就是向目标服务器发送一串文本。什么样的文本?有下面结构的文本。 
    HTTP请求包结构(图片来自Android网络请求心路历程

    这里写图片描述

    例子:

    POST /meme.php/home/user/login HTTP/1.1
    Host: 114.215.86.90
    Cache-Control: no-cache
    Postman-Token: bd243d6b-da03-902f-0a2c-8e9377f6f6ed
    Content-Type: application/x-www-form-urlencoded
    
    tel=13637829200&password=123456
    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7

    例如,MediaType.parse(“application/json; charset=utf-8”);这个就带表请求体的类型为JSON格式的。

    定义好数据类型,还要将其变为请求体,最后通过post()方法,随请求一并发出。

    2.4.2、POST提交键值对

    OkHttp也可以通过POST方式把键值对数据传送到服务器

    OkHttpClient client = new OkHttpClient();
    String post(String url, String json) throws IOException {
        RequestBody formBody = new FormEncodingBuilder()
        .add("platform", "android")
        .add("name", "bug")
        .add("subject", "XXXXXXXXXXXXXXX")
        .build();
    
        Request request = new Request.Builder()
          .url(url)
          .post(body)
          .build();
    
        Response response = client.newCall(request).execute();
        if (response.isSuccessful()) {
            return response.body().string();
        } else {
            throw new IOException("Unexpected code " + response);
        }
    }
    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    • 15
    • 16
    • 17
    • 18
    • 19
    • 20

    2.4.3、Post方式提交流

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

    public static final MediaType MEDIA_TYPE_MARKDOWN
          = MediaType.parse("text/x-markdown; charset=utf-8");
    
      private final OkHttpClient client = new OkHttpClient();
    
      public void run() throws Exception {
        RequestBody requestBody = new RequestBody() {
          @Override public MediaType contentType() {
            return MEDIA_TYPE_MARKDOWN;
          }
    
          @Override public void writeTo(BufferedSink sink) throws IOException {
            sink.writeUtf8("Numbers\n");
            sink.writeUtf8("-------\n");
            for (int i = 2; i <= 997; i++) {
              sink.writeUtf8(String.format(" * %s = %s\n", i, factor(i)));
            }
          }
    
          private String factor(int n) {
            for (int i = 2; i < n; i++) {
              int x = n / i;
              if (x * i == n) return factor(x) + " × " + i;
            }
            return Integer.toString(n);
          }
        };
    
        Request request = new Request.Builder()
            .url("https://api.github.com/markdown/raw")
            .post(requestBody)
            .build();
    
        Response response = client.newCall(request).execute();
        if (!response.isSuccessful()) throw new IOException("Unexpected code " + response);
    
        System.out.println(response.body().string());
      }
    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    • 15
    • 16
    • 17
    • 18
    • 19
    • 20
    • 21
    • 22
    • 23
    • 24
    • 25
    • 26
    • 27
    • 28
    • 29
    • 30
    • 31
    • 32
    • 33
    • 34
    • 35
    • 36
    • 37
    • 38

    重写RequestBody中的几个方法,将本地数据放入到Http协议的请求体中,然后发送到服务端。

    2.4.4、Post方式提交表单

    使用FormEncodingBuilder来构建和HTML标签相同效果的请求体。键值对将使用一种HTML兼容形式的URL编码来进行编码。

    private final OkHttpClient client = new OkHttpClient();
    
      public void run() throws Exception {
        RequestBody formBody = new FormBody.Builder()
            .add("search", "Jurassic Park")
            .build();
        Request request = new Request.Builder()
            .url("https://en.wikipedia.org/w/index.php")
            .post(formBody)
            .build();
    
        Response response = client.newCall(request).execute();
        if (!response.isSuccessful()) throw new IOException("Unexpected code " + response);
    
        System.out.println(response.body().string());
      }
    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    • 15
    • 16

    2.4.5、Post方式提交分块请求,可以上传文件

    MultipartBuilder可以构建复杂的请求体,与HTML文件上传形式兼容。

    多块请求体中每块请求都是一个请求体,可以定义自己的请求头。这些请求头可以用来描述这块请求,例如他的Content-Disposition。如果Content-Length和Content-Type可用的话,他们会被自动添加到请求头中。

    private static final String IMGUR_CLIENT_ID = "...";
      private static final MediaType MEDIA_TYPE_PNG = MediaType.parse("image/png");
    
      private final OkHttpClient client = new OkHttpClient();
    
      public void run() throws Exception {
        // Use the imgur image upload API as documented at https://api.imgur.com/endpoints/image
        RequestBody requestBody = new MultipartBody.Builder()
            .setType(MultipartBody.FORM)
            .addFormDataPart("title", "Square Logo")
            .addFormDataPart("image", "logo-square.png",
                RequestBody.create(MEDIA_TYPE_PNG, new File("website/static/logo-square.png")))
            .build();
    
        Request request = new Request.Builder()
            .header("Authorization", "Client-ID " + IMGUR_CLIENT_ID)
            .url("https://api.imgur.com/3/image")
            .post(requestBody)
            .build();
    
        Response response = client.newCall(request).execute();
        if (!response.isSuccessful()) throw new IOException("Unexpected code " + response);
    
        System.out.println(response.body().string());
      }
    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    • 15
    • 16
    • 17
    • 18
    • 19
    • 20
    • 21
    • 22
    • 23
    • 24
    • 25

    2.5、HTTP头部的设置和读取

    HTTP 头的数据结构是 Map<String, List<String>>类型。也就是说,对于每个 HTTP 头,可能有多个值。但是大部分 HTTP 头都只有一个值,只有少部分 HTTP 头允许多个值。至于name的取值说明,可以查看这个请求头大全

    OkHttp的处理方式是:

    • 使用header(name,value)来设置HTTP头的唯一值,如果请求中已经存在响应的信息那么直接替换掉。
    • 使用addHeader(name,value)来补充新值,如果请求头中已经存在name的name-value,那么还会继续添加,请求头中便会存在多个name相同而value不同的“键值对”。
    • 使用header(name)读取唯一值或多个值的最后一个值
    • 使用headers(name)获取所有值
    OkHttpClient client = new OkHttpClient();
    
    Request request = new Request.Builder()
            .url("https://github.com")
            .header("User-Agent", "My super agent")
            .addHeader("Accept", "text/html")
            .build();
    
    Response response = client.newCall(request).execute();
    if (!response.isSuccessful()) {
        throw new IOException("服务器端错误: " + response);
    }
    
    System.out.println(response.header("Server"));
    System.out.println(response.headers("Set-Cookie"));
    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    • 15

    2.6、同步和异步

    Synchronous Get(同步Get)

    下载一个文件,打印他的响应头,以string形式打印响应体。

    响应体的 string() 方法对于小文档来说十分方便、高效。但是如果响应体太大(超过1MB),应避免适应 string()方法 ,因为他会将把整个文档加载到内存中。对于超过1MB的响应body,应使用流的方式来处理body。

    private final OkHttpClient client = new OkHttpClient();
    
      public void run() throws Exception {
        Request request = new Request.Builder()
            .url("http://publicobject.com/helloworld.txt")
            .build();
    
        Response response = client.newCall(request).execute();//同步
        if (!response.isSuccessful()) throw new IOException("Unexpected code " + response);
    
        Headers responseHeaders = response.headers();
        for (int i = 0; i < responseHeaders.size(); i++) {
          System.out.println(responseHeaders.name(i) + ": " + responseHeaders.value(i));
        }
    
        System.out.println(response.body().string());
      }
    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    • 15
    • 16
    • 17

    Asynchronous Get(异步Get)

    在一个工作线程中下载文件,当响应可读时回调Callback接口。读取响应时会阻塞当前线程。OkHttp现阶段不提供异步api来接收响应体。

    private final OkHttpClient client = new OkHttpClient();
    
      public void run() throws Exception {
        Request request = new Request.Builder()
            .url("http://publicobject.com/helloworld.txt")
            .build();
    
        //异步,需要设置一个回调接口
        client.newCall(request).enqueue(new Callback() {
          @Override public void onFailure(Call call, IOException e) {
            e.printStackTrace();
          }
    
          @Override public void onResponse(Call call, Response response) throws IOException {
            if (!response.isSuccessful()) throw new IOException("Unexpected code " + response);
    
            Headers responseHeaders = response.headers();
            for (int i = 0, size = responseHeaders.size(); i < size; i++) {
              System.out.println(responseHeaders.name(i) + ": " + responseHeaders.value(i));
            }
    
            System.out.println(response.body().string());
          }
        });
      }
    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    • 15
    • 16
    • 17
    • 18
    • 19
    • 20
    • 21
    • 22
    • 23
    • 24
    • 25

    参考:

    OkHttp官方教程解析-彻底入门OkHttp使用 
    Android OkHttp完全解析 是时候来了解OkHttp了 
    OKHttp3.0的日常及入门 
    #Android#OkHttp3使用指南

    展开全文
  • Android OkHttp3简介和使用详解

    万次阅读 2019-03-10 14:11:41
    OKHttp简介 OKHttp是一个处理网络请求的开源项目,Android 当前最火热网络框架,由移动支付Square公司贡献,用于替代HttpUrlConnection和Apache HttpClient(android API23 6.0里已移除HttpClient)。...

    一 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的依赖

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

    添加网络权限

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

    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 文件中添加如下代码:

     <uses-permission android:name="android.permission.READ_EXTERNAL_STORAGE"/>
       <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 {
                }
            });

    注意事项

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

    三 结束

    Android OkHttp3简介和使用详解就到这里了,下一篇我们分析 OkHttp3源码。

    版权声明:

    本文为原作者原创文章,此处转载仅学习研究。

    原文地址:https://blog.csdn.net/zhangqiluGrubby/article/details/71480546

    展开全文
  • Android网络编程(六)OkHttp3用法全解析

    万次阅读 多人点赞 2017-12-31 05:39:07
    上一篇介绍了OkHttp2.x的用法,这一篇文章我们来对照OkHttp2.x版本来看看,OkHttp3使用起来有那些变化。当然,看这篇文章前建议看一下前一篇文章Android网络编程(五)OkHttp2.x用法全解析。

    相关文章
    Android网络编程(一)HTTP协议原理
    Android网络编程(二)HttpClient与HttpURLConnection
    Android网络编程(三)Volley用法全解析
    Android网络编程(四)从源码解析volley
    Android网络编程(五)OkHttp2.x用法全解析
    Android网络编程(六)OkHttp3用法全解析
    Android网络编程(七)源码解析OkHttp前篇[请求网络]
    Android网络编程(八)源码解析OkHttp后篇[复用连接池]
    Android网络编程(九)Retrofit2前篇[基本使用]
    Android网络编程(十)Retrofit2后篇[注解]
    Android网络编程(十一)源码解析Retrofit

    前言

    上一篇介绍了OkHttp2.x的用法,这一篇文章我们来对照OkHttp2.x版本来看看,OkHttp3使用起来有那些变化。当然,看这篇文章前建议看一下前一篇文章Android网络编程(五)OkHttp2.x用法全解析

    1.使用前准备

    Android Studio 配置gradle:

      compile 'com.squareup.okhttp3:okhttp:3.2.0'
      compile 'com.squareup.okio:okio:1.7.0'

    添加网络权限:

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

    2.异步GET请求

    惯例,请求百度:

            private void getAsynHttp() {
            mOkHttpClient=new OkHttpClient();
            Request.Builder requestBuilder = new Request.Builder().url("http://www.baidu.com");
            //可以省略,默认是GET请求
            requestBuilder.method("GET",null);
            Request request = requestBuilder.build();
            Call mcall= mOkHttpClient.newCall(request);
            mcall.enqueue(new Callback() {
                @Override
                public void onFailure(Call call, IOException e) {
    
                }
    
                @Override
                public void onResponse(Call call, Response response) throws IOException {
                    if (null != response.cacheResponse()) {
                        String str = response.cacheResponse().toString();
                        Log.i("wangshu", "cache---" + str);
                    } else {
                        response.body().string();
                        String str = response.networkResponse().toString();
                        Log.i("wangshu", "network---" + str);
                    }
                    runOnUiThread(new Runnable() {
                        @Override
                        public void run() {
                            Toast.makeText(getApplicationContext(), "请求成功", Toast.LENGTH_SHORT).show();
                        }
                    });
                }
            });
        }

    与2.x版本并没有什么不同,比较郁闷的是回调仍然不在UI线程。

    2.异步POST请求

    OkHttp3异步POST请求和OkHttp2.x有一些差别就是没有FormEncodingBuilder这个类,替代它的是功能更加强大的FormBody:

       private void postAsynHttp() {
            mOkHttpClient=new OkHttpClient();
            RequestBody formBody = new FormBody.Builder()
                    .add("size", "10")
                    .build();
            Request request = new Request.Builder()
                    .url("http://api.1-blog.com/biz/bizserver/article/list.do")
                    .post(formBody)
                    .build();
            Call call = mOkHttpClient.newCall(request);
            call.enqueue(new Callback() {
                @Override
                public void onFailure(Call call, IOException e) {
    
                }
    
                @Override
                public void onResponse(Call call, Response response) throws IOException {
                    String str = response.body().string();
                    Log.i("wangshu", str);
    
                    runOnUiThread(new Runnable() {
                        @Override
                        public void run() {
                            Toast.makeText(getApplicationContext(), "请求成功", Toast.LENGTH_SHORT).show();
                        }
                    });
                }
    
            });
        }

    3.异步上传文件

    上传文件本身也是一个POST请求,上一篇没有讲,这里我们补上。首先定义上传文件类型:

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

    将sdcard根目录的wangshu.txt文件上传到服务器上:

        private void postAsynFile() {
            mOkHttpClient=new OkHttpClient();
            File file = new File("/sdcard/wangshu.txt");
            Request request = new Request.Builder()
                    .url("https://api.github.com/markdown/raw")
                    .post(RequestBody.create(MEDIA_TYPE_MARKDOWN, file))
                    .build();
    
                mOkHttpClient.newCall(request).enqueue(new Callback() {
                    @Override
                    public void onFailure(Call call, IOException e) {
    
                    }
    
                    @Override
                    public void onResponse(Call call, Response response) throws IOException {
                        Log.i("wangshu",response.body().string());
                    }
                });
            }
    

    当然如果想要改为同步的上传文件只要调用 mOkHttpClient.newCall(request).execute()就可以了。
    在wangshu.txt文件中有一行字“Android网络编程(六)OkHttp3用法全解析”我们运行程序点击发送文件按钮,最终请求网络返回的结果就是我们txt文件中的内容 :

    这里写图片描述

    当然不要忘了添加如下权限:

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

    4.异步下载文件

    下载文件同样在上一篇没有讲到,实现起来比较简单,在这里下载一张图片,我们得到Response后将流写进我们指定的图片文件中就可以了。

        private void downAsynFile() {
            mOkHttpClient = new OkHttpClient();
            String url = "https://img-my.csdn.net/uploads/201603/26/1458988468_5804.jpg";
            Request request = new Request.Builder().url(url).build();
            mOkHttpClient.newCall(request).enqueue(new Callback() {
                @Override
                public void onFailure(Call call, IOException e) {
    
                }
    
                @Override
                public void onResponse(Call call, Response response) {
                    InputStream inputStream = response.body().byteStream();
                    FileOutputStream fileOutputStream = null;
                    try {
                        fileOutputStream = new FileOutputStream(new File("/sdcard/wangshu.jpg"));
                        byte[] buffer = new byte[2048];
                        int len = 0;
                        while ((len = inputStream.read(buffer)) != -1) {
                            fileOutputStream.write(buffer, 0, len);
                        }
                        fileOutputStream.flush();
                    } catch (IOException e) {
                        Log.i("wangshu", "IOException");
                        e.printStackTrace();
                   }
    
                   Log.d("wangshu", "文件下载成功");
               }
           });
       }

    5.异步上传Multipart文件

    这种场景很常用,我们有时会上传文件同时还需要传其他类型的字段,OkHttp3实现起来很简单,需要注意的是没有服务器接收我这个Multipart文件,所以这里只是举个例子,具体的应用还要结合实际工作中对应的服务器。
    首先定义上传文件类型:

    private static final MediaType MEDIA_TYPE_PNG = MediaType.parse("image/png");
    private void sendMultipart(){
        mOkHttpClient = new OkHttpClient();
        RequestBody requestBody = new MultipartBody.Builder()
                .setType(MultipartBody.FORM)
                .addFormDataPart("title", "wangshu")
                .addFormDataPart("image", "wangshu.jpg",
                        RequestBody.create(MEDIA_TYPE_PNG, new File("/sdcard/wangshu.jpg")))
                .build();
    
        Request request = new Request.Builder()
                .header("Authorization", "Client-ID " + "...")
                .url("https://api.imgur.com/3/image")
                .post(requestBody)
                .build();
    
       mOkHttpClient.newCall(request).enqueue(new Callback() {
           @Override
           public void onFailure(Call call, IOException e) {
    
           }
    
           @Override
           public void onResponse(Call call, Response response) throws IOException {
               Log.i("wangshu", response.body().string());
           }
       });
    }

    6.设置超时时间和缓存

    和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();            

    7.关于取消请求和封装

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

    8.关于源码Demo

    源码Demo很简单就四个按钮用来测试上面讲到的内容:

    这里写图片描述

    github源码下载


    公众号末尾1.1.jpg

    展开全文
  • OkHttp3简介和使用详解

    千次阅读 2019-05-07 10:00:42
    OKHttp是一个当前主流的网络请求的开源框架 Square公司开发,用于替代HttpUrlConnection和Apache HttpClient Android4.4开始,google已经开始将源码中的HttpURLConnection替换为OkHttp Android6.0里已移除...

    1 简介

    • OKHttp是一个当前主流的网络请求的开源框架
    • Square公司开发,用于替代HttpUrlConnection和Apache HttpClient
    • Android4.4开始,google已经开始将源码中的HttpURLConnection替换为OkHttp
      Android6.0里已移除HttpClient

    优点 (版本一)

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

    优点 (版本二)

    1)支持http2,对一台机器的所有请求共享同一个socket
    2)内置连接池,支持连接复用,减少延迟
    3)支持透明的gzip压缩响应体
    4)通过缓存避免重复的请求
    5)请求失败时自动重试主机的其他ip,自动重定向
    6)好用的API

    功能

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

    2 基本使用

    首先记得在build.gradle 和 配置文件分别加上依赖 和 网络权限

        compile 'com.squareup.okhttp3:okhttp:3.8.0'
        compile 'com.squareup.okio:okio:1.12.0'
    

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

    2-1 异步Get请求

    异步GET请求的4个步骤:

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

    注意事项:

    • 异步调用的回调函数是在子线程,我们不能在子线程更新UI
      需要借助于 runOnUiThread() 方法或者 Handler 来处理。
    • onResponse回调有一个参数是response
      如果想获得返回的是字符串,可以通过response.body().string()
      如果获得返回的二进制字节数组,则调用response.body().bytes()
      如果想拿到返回的inputStream,则调response.body().byteStream()
      有inputStream我们就可以通过IO的方式写文件

    实例:

    我新建了一个活动,并在布局里放入一个按钮,点击就会开始执行网络请求

        private void getRequest() {
            //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 {
                    String data = response.body().string();
                    Log.d("response",data);
                    runOnUiThread(new Runnable() {
                        @Override
                        public void run() {
                            //更新UI
                        }
                    });
                }
            });
        }
    
    
    • 打个断点可以看到请求成功,返回了一串html的文字

       

    2-2 同步Get请求 (较少用)

    • 同步GET请求和异步GET请求基本一样,不同地方是同步请求调用Call的execute()方法,而异步请求调用call.enqueue()方法
            //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();
    

    2-3 异步POST——键值对

    • 通过FormBody
      添加多个String键值对
      最后为Request添加post方法并传入formBody
    • 经过对比我们发现异步的POST请求和GET请求步骤很相似
      这里就不赘述了
    private void postAsynHttp() {
         mOkHttpClient=new OkHttpClient();
         RequestBody formBody = new FormBody.Builder()
                 .add("size", "10")
                 .build();
         Request request = new Request.Builder()
                 .url("http://api.1-blog.com/biz/bizserver/article/list.do")
                 .post(formBody)
                 .build();
         Call call = mOkHttpClient.newCall(request);
         call.enqueue(new Callback() {
             @Override
             public void onFailure(Call call, IOException e) {
             }
             @Override
             public void onResponse(Call call, Response response) throws IOException {
                 String str = response.body().string();
                 runOnUiThread(new Runnable() {
                     @Override
                     public void run() {
                         Toast.makeText(getApplicationContext(), "请求成功", Toast.LENGTH_SHORT).show();
                     }
                 });
             }
         });
     }
    

    2-4 异步POST——上传文件

    • 我们需要设置上传类型MIME,我们打算上传一个纯文本
      因此需要用到 MediaType.parse("text/plain; charset=utf-8")
      常见的类型有: 更多参考这里

       

    • 再来看例子

           // step 1: 创建 OkHttpClient 对象
            OkHttpClient okHttpClient = new OkHttpClient();
    
            //step 2:创建 RequestBody 以及所需的参数
            //2.1 获取文件
            File file = new File(Environment.getExternalStorageDirectory() + "test.txt");
            //2.2 创建 MediaType 设置上传文件类型
            MediaType MEDIATYPE = MediaType.parse("text/plain; charset=utf-8");
            //2.3 获取请求体
            RequestBody requestBody = RequestBody.create(MEDIATYPE, file);
    
            //step 3:创建请求
            Request request = new Request.Builder().url("http://www.baidu.com")
                    .post(requestBody)
                    .build();
    
            //step 4 建立联系
            okHttpClient.newCall(request).enqueue(new Callback() {
                @Override
                public void onFailure(Call call, IOException e) {
                    // 请求失败
                }
    
                @Override
                public void onResponse(Call call, Response response) throws IOException {
                    // 请求成功
                }
            });
    
    • 最后别忘了加文件权限
    <uses-permission android:name="android.permission.READ_EXTERNAL_STORAGE"/> 
    <uses-permission android:name="android.permission.WRITE_EXTERNAL_STORAGE"/>
    

    2-5 异步Get请求——下载文件

    • 比如下载一张图片,我们得到Response后将流写进我们指定的图片文件中就可以了
     private void downAsynFile() {
         mOkHttpClient = new OkHttpClient();
         String url = "https://img-my.csdn.net/uploads/201603/26/1458988468_5804.jpg";
         Request request = new Request.Builder().url(url).build();
         mOkHttpClient.newCall(request).enqueue(new Callback() {
             @Override
             public void onFailure(Call call, IOException e) {
             }
             @Override
             public void onResponse(Call call, Response response) {
                 InputStream inputStream = response.body().byteStream();
                 FileOutputStream fileOutputStream = null;
                 try {
                     fileOutputStream = new FileOutputStream(new File("/sdcard/123.jpg"));
                     byte[] buffer = new byte[2048];
                     int len = 0;
                     while ((len = inputStream.read(buffer)) != -1) {
                         fileOutputStream.write(buffer, 0, len);
                     }
                     fileOutputStream.flush();
                 } catch (IOException e) {
                     e.printStackTrace();
                }
                Log.d("123", "文件下载成功");
            }
        });
    }
    
    

    2-6 异步上传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 {
                }
            });
    

    3 其他配置

    3-1 设置超时时间和缓存

    • 和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();
    

    3-2 添加请求头

    • 将请求头以键值对形式添加,可添加多个请求头
                Request.Builder builder = new Request.Builder().url(url);
                builder.addHeader("X-UA","android");  
    

    3-3 取消请求

    • 有时候网络条件不好的情况下,用户会主动关闭页面,这时候需要取消正在请求的http request, OkHttp提供了cancel方法,但是实际在使用过程中发现,如果调用cancel()方法,会回调到CallBack里面的 onFailure方法中,
    • 测试发现不同的失败类型返回的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{
                      //其他情况下
                }
              }
    
    • 在okhttp3.Callback的回调方法里面有个参数是Call
      这个call可以单独取消相应的请求,随便在onFailure或者onResponse方法内部执行call.cancel()都可以
      如果想取消所有的请求,则可以okhttpclient.dispatcher().cancelAll();

    来源:https://www.jianshu.com/p/16ab28d40737

    展开全文
  • Okhttp3 总结研究 (面试)

    万次阅读 多人点赞 2018-04-07 14:41:10
    OKhttp3 是最近比较主流的网络请求框架。面试中,常会问道你对okhttp3是否有深入的了解。在这篇文章我总结了下okhttp3的原理(非用法,用法自己百度就行),以及大神们根据源码分析OKhttp3比较好的文章。1.首先是...
  • OkHttp3最佳入门使用

    千次阅读 2018-05-16 16:26:20
    OkHttp以前大家普遍使用Volley、asyncHttpClient、HttpURLConnection来作为我们应用的网络框架。但是相比于他们OkHttp有什么优点呢?我们看官方给出的介绍: ...Connection pooling reduces ...
  • 深入解析OkHttp3

    万次阅读 多人点赞 2020-09-24 14:24:18
    OkHttp是一个精巧的网络请求库,有如下特性: 1)支持http2,对一台机器的所有请求共享同一个socket 2)内置连接池,支持连接复用,减少延迟 3)支持透明的gzip压缩响应体 4)通过缓存避免重复的请求 5)请求失败时...
  • Okhttp3基本使用

    2020-08-13 15:25:16
    I.简介 ...OkHttp是一个高效的HTTP客户端,它有以下默认特性...当网络出现问题的时候OkHttp依然坚守自己的职责,它会自动恢复一般的连接问题,如果你的服务有多个IP地址,当第一个IP请求失败时,OkHttp会交替尝试你配置的
  • okhttp3的基本使用

    万次阅读 多人点赞 2019-02-22 14:18:05
    okhttp3的基本使用
  • okhttp3

    2020-05-19 16:50:04
    使用流程 异步同步请求核心方法 getReponseWithInterceptorChain() 执行流程 核心拦截器: RetryAndFollowUpInterceptor 职责:重试和对response进行下一步的处理 BridgeInterceptor 职责:对request加上各种...
  • OkHttp execute方法和enqueue方法的区别

    万次阅读 2016-03-25 23:56:17
    OkHttp的execute的方法是同步方法, OkHttp的enqueue的方法是异步方法, 具体请参考: OKHttp使用简介
  • OKhttp3 系列(修改最大并发数)

    万次阅读 2017-03-17 15:57:00
    本文可能比较短,后续补充一、修改okhttp3 最大并发数方法 源码中okhttp3.Dispatcher这个类里面提供了maxRequests = 64: 最大并发请求数为64 maxRequestsPerHost = 5: 每个主机最大请求数为5并且对外提供了相应的...
  • OKhttp FormBody和RequestBody的不同

    万次阅读 2019-01-12 14:29:00
    原文地址:https://www.jianshu.com/p/1133389c1f75
  • 在gradle里面加上这句 allprojects { repositories { mavenCentral() google() jcenter() maven { url 'https://maven.google.com' } maven { url 'https://oss...
  • "containedParcels"=>[ {"parcelNum": "aaa"}, {"parcelNum": "bbb"}, {"parcelNum": "ddd"} ] 像这种数据我要怎样使用post发送请求
  • Failed to resolve: com.squareup.okhttp3:okhttp:3.2.0
  • android okhttp3 3.10.0 开启混淆报错

    千次阅读 2019-04-02 15:24:00
    网上添加的混淆过滤规则试了好多中都不能用,后来升级okhttp的版本至 implementation '...#-------------- okhttp3 start------------- # OkHttp3 # https://github.com/square/okhttp # okhttp -kee...
  • Okhttp获取中文网页乱码的解决方式

    千次阅读 2017-02-26 22:26:26
    OkHttp post请求编码问题 解决放法 在回调方法onResponse方法中 byte[] b = response.body().bytes(); //获取数据的bytes String info = new String(b, "GB2312"); //然后将其转为gb2312
  • 求大神告知okhttp的post请求怎么携带cookie 求大神告知okhttp的post请求怎么携带cookie 谢谢!!!!!!
  • 添加okhttp依赖大家都知道哈,非常容易... implementation 'com.squareup.okhttp3:okhttp:3.13.1' } 报错: Could not resolve com.sqaureup.okhttp3:okhttp:3.x.x 解决方法:取消代理设置!!! 首先:File-Settin...
1 2 3 4 5 ... 20
收藏数 44,351
精华内容 17,740
关键字:

okhttp3