Android：OkHttp的理解和使用

2023-05-16

OkHttp的理解和使用

OkHttp
1、什么是OkHttp
2、OkHttp的作用
3、Okhttp的基本使用
- 3.1、Http请求和响应的组成
- 3.2、OkHttp请求和响应的组成
- 3.3、GET请求同步方法
- 3.4、GET请求异步方法
- 3.5、post请求方法
- 3.6、POST请求传递参数的方法总结
- - 3.6.1、Post方式提交String
  - 3.6.2、Post方式提交 `流`
  - 3.6.3、Post方式提交文件
  - 3.6.4、Post方式提交表单
- 3.7、POST其他用法
- - 3.7.1、提取响应头
  - 3.7.2、使用Gson来解析JSON响应
  - 3.7.3、响应缓存
  - 3.7.4、响应cookie
- 3.8、综合实例
参考

OkHttp

在这里插入图片描述

1、什么是OkHttp

1、网络请求发展

历史上Http请求库优缺点

HttpURLConnection—>Apache HTTP Client—>Volley—->okHttp

2、项目开源地址

https://github.com/square/okhttp

3、OkHttp是什么

OKhttp是一个网络请求开源项目，Android网络请求轻量级框架,支持文件上传与下载，支持https。

2、OkHttp的作用

OkHttp是一个高效的HTTP库:

支持HTTP/2, HTTP/2通过使用多路复用技术在一个单独的TCP连接上支持并发, 通过在一个连接上一次性发送多个请求来发送或接收数据
如果HTTP/2不可用, 连接池复用技术也可以极大减少延时
支持GZIP, 可以压缩下载体积
响应缓存可以直接避免重复请求
会从很多常用的连接问题中自动恢复
如果您的服务器配置了多个IP地址, 当第一个IP连接失败的时候, OkHttp会自动尝试下一个IP OkHttp还处理了代理服务器问题和SSL握手失败问题

优势

使用 OkHttp无需重写您程序中的网络代码。OkHttp实现了几乎和java.net.HttpURLConnection一样的API。如果您用了 Apache HttpClient，则OkHttp也提供了一个对应的okhttp-apache 模块

3、Okhttp的基本使用

Okhttp的基本使用，从以下五方面讲解：

1.Get请求(同步和异步)
2.POST请求表单(key-value)
3.POST请求提交(JSON/String/文件等)
4.文件下载
5.请求超时设置

加入build.gradle

compile 'com.squareup.okhttp3:okhttp:3.6.0'

3.1、Http请求和响应的组成

http请求
在这里插入图片描述
所以一个类库要完成一个http请求, 需要包含请求方法, 请求地址, 请求协议, 请求头, 请求体这五部分. 这些都在okhttp3.Request的类中有体现, 这个类正是代表http请求的类. 看下图:

在这里插入图片描述
其中HttpUrl类代表请求地址, String method代表请求方法, Headers代表请求头, RequestBody代表请求体. Object tag这个是用来取消http请求的标志, 这个我们先不管.

http响应

响应组成图:
在这里插入图片描述
可以看到大体由应答首行, 应答头, 应答体构成. 但是应答首行表达的信息过多, HTTP/1.1表示访问协议, 200是响应码, OK是描述状态的消息.

根据单一职责, 我们不应该把这么多内容用一个应答首行来表示. 这样的话, 我们的响应就应该由访问协议, 响应码, 描述信息, 响应头, 响应体来组成.

3.2、OkHttp请求和响应的组成

OkHttp请求

构造一个http请求, 并查看请求具体内容:

final Request request = new Request.Builder().url("https://github.com/").build();

我们看下在内存中, 这个请求是什么样子的, 是否如我们上文所说和请求方法, 请求地址, 请求头, 请求体一一对应.
在这里插入图片描述
OkHttp响应

OkHttp库怎么表示一个响应:
在这里插入图片描述
可以看到Response类里面有Protocol代表请求协议, int code代表响应码, String message代表描述信息, Headers代表响应头, ResponseBody代表响应体. 当然除此之外, 还有Request代表持有的请求, Handshake代表SSL/TLS握手协议验证时的信息, 这些额外信息我们暂时不问.

有了刚才说的OkHttp响应的类组成, 我们看下OkHttp请求后响应在内存中的内容:

final Request request = new Request.Builder().url("https://github.com/").build();
Response response = client.newCall(request).execute();

在这里插入图片描述

3.3、GET请求同步方法

同步GET的意思是一直等待http请求, 直到返回了响应. 在这之间会阻塞进程, 所以通过get不能在Android的主线程中执行, 否则会报错.

对于同步请求在请求时需要开启子线程，请求成功后需要跳转到UI线程修改UI。

public void getDatasync(){
    new Thread(new Runnable() {
        @Override
        public void run() {
            try {
                OkHttpClient client = new OkHttpClient();//创建OkHttpClient对象
                Request request = new Request.Builder()
                        .url("http://www.baidu.com")//请求接口。如果需要传参拼接到接口后面。
                        .build();//创建Request 对象
                Response response = null;
                response = client.newCall(request).execute();//得到Response 对象
                if (response.isSuccessful()) {
                Log.d("kwwl","response.code()=="+response.code());
                Log.d("kwwl","response.message()=="+response.message());
                Log.d("kwwl","res=="+response.body().string());
                //此时的代码执行在子线程，修改UI的操作请使用handler跳转到UI线程。
                }
            } catch (Exception e) {
                e.printStackTrace();
            }
        }
    }).start();
}

此时打印结果如下：

response.code()==200；
response.message()OK；
res{“code”:200,“message”:success};

OkHttpClient实现了Call.Factory接口, 是Call的工厂类, Call负责发送执行请求和读取响应.
Request代表Http请求, 通过Request.Builder辅助类来构建.

client.newCall(request)通过传入一个http request, 返回一个Call调用. 然后执行execute()方法, 同步获得Response代表Http请求的响应. response.body()是ResponseBody类, 代表响应体

注意事项：

1，Response.code是http响应行中的code，如果访问成功则返回200.这个不是服务器设置的，而是http协议中自带的。res中的code才是服务器设置的。注意二者的区别。

2，response.body().string()本质是输入流的读操作，所以它还是网络请求的一部分，所以这行代码必须放在子线程。

3，response.body().string()只能调用一次，在第一次时有返回值，第二次再调用时将会返回null。原因是：response.body().string()的本质是输入流的读操作，必须有服务器的输出流的写操作时客户端的读操作才能得到数据。而服务器的写操作只执行一次，所以客户端的读操作也只能执行一次，第二次将返回null。

4、响应体的string()方法对于小文档来说十分方便高效. 但是如果响应体太大（超过1MB）, 应避免使用 string()方法, 因为它会将把整个文档加载到内存中.

5、对于超过1MB的响应body, 应使用流的方式来处理响应body. 这和我们处理xml文档的逻辑是一致的, 小文件可以载入内存树状解析, 大文件就必须流式解析.

注解：

responseBody.string()获得字符串的表达形式, 或responseBody.bytes()获得字节数组的表达形式, 这两种形式都会把文档加入到内存. 也可以通过responseBody.charStream()和responseBody.byteStream()返回流来处理.

3.4、GET请求异步方法

异步GET是指在另外的工作线程中执行http请求, 请求时不会阻塞当前的线程, 所以可以在Android主线程中使用.

这种方式不用再次开启子线程，但回调方法是执行在子线程中，所以在更新UI时还要跳转到UI线程中。

下面是在一个工作线程中下载文件, 当响应可读时回调Callback接口. 当响应头准备好后, 就会调用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(Request request, Throwable throwable) {
        throwable.printStackTrace();
      }
 
      @Override public void onResponse(Response response) throws IOException {
        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());
      }
    });
}

异步请求的打印结果与注意事项与同步请求时相同。最大的不同点就是异步请求不需要开启子线程，enqueue方法会自动将网络请求部分放入子线程中执行。

注意事项：

1，回调接口的onFailure方法和onResponse执行在子线程。
2，response.body().string()方法也必须放在子线程中。当执行这行代码得到结果后，再跳转到UI线程修改UI。

3.5、post请求方法

Post请求也分同步和异步两种方式，同步与异步的区别和get方法类似，所以此时只讲解post异步请求的使用方法。

private void postDataWithParame() {
    OkHttpClient client = new OkHttpClient();//创建OkHttpClient对象。
    FormBody.Builder formBody = new FormBody.Builder();//创建表单请求体
    formBody.add("username","zhangsan");//传递键值对参数
    Request request = new Request.Builder()//创建Request 对象。
            .url("http://www.baidu.com")
            .post(formBody.build())//传递请求体
            .build();
    client.newCall(request).enqueue(new Callback() {。。。});//回调方法的使用与get异步请求相同，此时略。
}

看完代码我们会发现：post请求中并没有设置请求方式为POST，回忆在get请求中也没有设置请求方式为GET，那么是怎么区分请求方式的呢？重点是Request.Builder类的post方法，在Request.Builder对象创建最初默认是get请求，所以在get请求中不需要设置请求方式，当调用post方法时把请求方式修改为POST。所以此时为POST请求。

3.6、POST请求传递参数的方法总结

3.6.1、Post方式提交String

下面是使用HTTP POST提交请求到服务. 这个例子提交了一个markdown文档到web服务, 以HTML方式渲染markdown. 因为整个请求体都在内存中, 因此避免使用此api提交大文档（大于1MB）.

public static final MediaType MEDIA_TYPE_MARKDOWN
  = MediaType.parse("text/x-markdown; charset=utf-8");
 
private final OkHttpClient client = new OkHttpClient();
 
public void run() throws Exception {
    String postBody = ""
        + "Releases\n"
        + "--------\n"
        + "\n"
        + " * _1.0_ May 6, 2013\n"
        + " * _1.1_ June 15, 2013\n"
        + " * _1.2_ August 11, 2013\n";
 
    Request request = new Request.Builder()
        .url("https://api.github.com/markdown/raw")
        .post(RequestBody.create(MEDIA_TYPE_MARKDOWN, postBody))
        .build();
 
    Response response = client.newCall(request).execute();
    if (!response.isSuccessful()) throw new IOException("Unexpected code " + response);
 
    System.out.println(response.body().string());
}

3.6.2、Post方式提交 `流`

以流的方式POST提交请求体. 请求体的内容由流写入产生. 这个例子是流直接写入Okio的BufferedSink. 你的程序可能会使用OutputStream, 你可以使用BufferedSink.outputStream()来获取. OkHttp的底层对流和字节的操作都是基于Okio库, Okio库也是Square开发的另一个IO库, 填补I/O和NIO的空缺, 目的是提供简单便于使用的接口来操作IO.

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

3.6.3、Post方式提交文件

public static final MediaType MEDIA_TYPE_MARKDOWN
  = MediaType.parse("text/x-markdown; charset=utf-8");
 
private final OkHttpClient client = new OkHttpClient();
 
public void run() throws Exception {
    File file = new File("README.md");
 
    Request request = new Request.Builder()
        .url("https://api.github.com/markdown/raw")
        .post(RequestBody.create(MEDIA_TYPE_MARKDOWN, file))
        .build();
 
    Response response = client.newCall(request).execute();
    if (!response.isSuccessful()) throw new IOException("Unexpected code " + response);
 
    System.out.println(response.body().string());
}

3.6.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());
  }

3.7、POST其他用法

3.7.1、提取响应头

典型的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 final OkHttpClient client = new OkHttpClient();
 
public void run() throws Exception {
    Request request = new Request.Builder()
        .url("https://api.github.com/repos/square/okhttp/issues")
        .header("User-Agent", "OkHttp Headers.java")
        .addHeader("Accept", "application/json; q=0.5")
        .addHeader("Accept", "application/vnd.github.v3+json")
        .build();
 
    Response response = client.newCall(request).execute();
    if (!response.isSuccessful()) throw new IOException("Unexpected code " + response);
 
    System.out.println("Server: " + response.header("Server"));
    System.out.println("Date: " + response.header("Date"));
    System.out.println("Vary: " + response.headers("Vary"));
}

3.7.2、使用Gson来解析JSON响应

Gson是一个在JSON和Java对象之间转换非常方便的api库. 这里我们用Gson来解析Github API的JSON响应.

注意: ResponseBody.charStream()使用响应头Content-Type指定的字符集来解析响应体. 默认是UTF-8.

private final OkHttpClient client = new OkHttpClient();
  private final Gson gson = new Gson();

  public void run() throws Exception {
    Request request = new Request.Builder()
        .url("https://api.github.com/gists/c2a7c39532239ff261be")
        .build();
    Response response = client.newCall(request).execute();
    if (!response.isSuccessful()) throw new IOException("Unexpected code " + response);

    Gist gist = gson.fromJson(response.body().charStream(), Gist.class);
    for (Map.Entry<String, GistFile> entry : gist.files.entrySet()) {
      System.out.println(entry.getKey());
      System.out.println(entry.getValue().content);
    }
  }

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

  static class GistFile {
    String content;
  }

3.7.3、响应缓存

为了缓存响应, 你需要一个你可以读写的缓存目录, 和缓存大小的限制. 这个缓存目录应该是私有的, 不信任的程序应不能读取缓存内容.

一个缓存目录同时拥有多个缓存访问是错误的. 大多数程序只需要调用一次new OkHttp(), 在第一次调用时配置好缓存, 然后其他地方只需要调用这个实例就可以了. 否则两个缓存示例互相干扰, 破坏响应缓存, 而且有可能会导致程序崩溃.

响应缓存使用HTTP头作为配置. 你可以在请求头中添加Cache-Control: max-stale=3600 , OkHttp缓存会支持. 你的服务通过响应头确定响应缓存多长时间, 例如使用Cache-Control: max-age=9600.

private final OkHttpClient client;
 
public CacheResponse(File cacheDirectory) throws Exception {
    int cacheSize = 10 * 1024 * 1024; // 10 MiB
    Cache cache = new Cache(cacheDirectory, cacheSize);
 
    client = new OkHttpClient();
    client.setCache(cache);
}
 
public void run() throws Exception {
    Request request = new Request.Builder()
        .url("http://publicobject.com/helloworld.txt")
        .build();
 
    Response response1 = client.newCall(request).execute();
    if (!response1.isSuccessful()) throw new IOException("Unexpected code " + response1);
 
    String response1Body = response1.body().string();
    System.out.println("Response 1 response:          " + response1);
    System.out.println("Response 1 cache response:    " + response1.cacheResponse());
    System.out.println("Response 1 network response:  " + response1.networkResponse());
 
    Response response2 = client.newCall(request).execute();
    if (!response2.isSuccessful()) throw new IOException("Unexpected code " + response2);
 
    String response2Body = response2.body().string();
    System.out.println("Response 2 response:          " + response2);
    System.out.println("Response 2 cache response:    " + response2.cacheResponse());
    System.out.println("Response 2 network response:  " + response2.networkResponse());
 
    System.out.println("Response 2 equals Response 1? " + response1Body.equals(response2Body));
}

如果需要阻值response使用缓存, 使用CacheControl.FORCE_NETWORK. 如果需要阻值response使用网络, 使用CacheControl.FORCE_CACHE.

警告
如果你使用FORCE_CACHE, 但是response要求使用网络, OkHttp将会返回一个504 Unsatisfiable Request响应.

实例2

package com.enjoy.networkdemo;

import android.util.Log;

import org.jetbrains.annotations.NotNull;
import org.junit.Test;

import java.io.File;
import java.io.IOException;

import okhttp3.Cache;
import okhttp3.Call;
import okhttp3.Interceptor;
import okhttp3.OkHttpClient;
import okhttp3.Request;
import okhttp3.Response;

public class InterceptorUnitTest {

    @Test
    public void interceptorTest() {
        OkHttpClient okHttpClient = new OkHttpClient.Builder()
                .cache(new Cache(new File("C:\\Users\\Administrator\\Desktop"),
                        1024 * 1024)).addNetworkInterceptor(new Interceptor() {
                    @NotNull
                    @Override
                    public Response intercept(@NotNull Chain chain) throws IOException {
                        System.out.println("version:" + chain.request().header("version"));
                        return chain.proceed(chain.request());
                    }
                }).addInterceptor(new Interceptor() {
                    @NotNull
                    @Override
                    public Response intercept(@NotNull Chain chain) throws IOException {
                        //前置处理
                        Request request = chain.request().newBuilder().addHeader("os", "android")
                                .addHeader("version", "1.0").build();
                        Response response = chain.proceed(request);
                        //后置处理
                        return response;
                    }
                }).build();

        Request request = new Request.Builder().url("https://www.httpbin.org/get?a=1&b=2").build();
        // 准备好请求的Call对象
        Call call = okHttpClient.newCall(request);
        try {
            Response response = call.execute();
            System.out.println(response.body().string());
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
}

3.7.4、响应cookie

package com.enjoy.networkdemo;

import org.jetbrains.annotations.NotNull;
import org.junit.Test;

import java.io.IOException;
import java.util.ArrayList;
import java.util.HashMap;
import java.util.List;
import java.util.Map;

import okhttp3.Cache;
import okhttp3.Call;
import okhttp3.Cookie;
import okhttp3.CookieJar;
import okhttp3.FormBody;
import okhttp3.HttpUrl;
import okhttp3.Interceptor;
import okhttp3.OkHttpClient;
import okhttp3.Request;
import okhttp3.Response;

public class CookieUnitTest {
    Map<String, List<Cookie>> cookies = new HashMap<>();

    @Test
    public void cookieTest() {
        OkHttpClient okHttpClient = new OkHttpClient.Builder()
                .cookieJar(new CookieJar() {
                    @Override
                    public void saveFromResponse(@NotNull HttpUrl httpUrl, @NotNull List<Cookie> list) {
                        cookies.put(httpUrl.host(), list);
                    }

                    @NotNull
                    @Override
                    public List<Cookie> loadForRequest(@NotNull HttpUrl httpUrl) {
                        List<Cookie> cookies = CookieUnitTest.this.cookies.get(httpUrl.host());
                        return cookies == null ? new ArrayList<>() : cookies;
                    }
                })
                .build();
        FormBody formBody = new FormBody.Builder().add("username", "lanceedu")
                .add("password", "123123").build();
        Request request = new Request.Builder().url("https://www.wanandroid.com/user/login")
                .post(formBody).build();
        // 准备好请求的Call对象
        Call call = okHttpClient.newCall(request);
        try {
            Response response = call.execute();
            System.out.println(response.body().string());
        } catch (IOException e) {
            e.printStackTrace();
        }


        request = new Request.Builder().url("https://www.wanandroid.com/lg/collect/list/0/json")
                .build();
        // 准备好请求的Call对象
        call = okHttpClient.newCall(request);
        try {
            Response response = call.execute();
            System.out.println(response.body().string());
        } catch (IOException e) {
            e.printStackTrace();
        }

    }
}

3.8、综合实例

参考链接
activity_main

<?xml version="1.0" encoding="utf-8"?>
<LinearLayout xmlns:android="http://schemas.android.com/apk/res/android"
              android:layout_width="match_parent"
              android:layout_height="match_parent"
              android:orientation="vertical">
 
    <LinearLayout
        android:layout_width="match_parent"
        android:layout_height="wrap_content"
        android:gravity="center_horizontal"
        android:orientation="horizontal">
 
        <Button
            android:id="@+id/syncGet"
            android:layout_width="wrap_content"
            android:layout_height="wrap_content"
            android:text="同步请求"/>
 
        <Button
            android:id="@+id/asyncget"
            android:layout_width="wrap_content"
            android:layout_height="wrap_content"
            android:text="异步请求"/>
		
		<Button
            android:id="@+id/post"
            android:layout_width="wrap_content"
            android:layout_height="wrap_content"
            android:text="表单提交"/>
 
        <Button
            android:id="@+id/fileDownload"
            android:layout_width="wrap_content"
            android:layout_height="wrap_content"
            android:text="文件下载"/>
 
    </LinearLayout>
 
    <TextView
        android:id="@+id/tv_text"
        android:layout_width="match_parent"
        android:layout_height="wrap_content"/>
</LinearLayout>

MainActivity

package com.example.okhttpdemo;

import android.os.Bundle;
import android.support.v7.app.AppCompatActivity;
import android.util.Log;
import android.view.View;
import android.widget.Button;
import android.widget.TextView;

import java.io.File;
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.InputStream;
import java.util.concurrent.TimeUnit;

import okhttp3.Call;
import okhttp3.Callback;
import okhttp3.FormBody;
import okhttp3.OkHttpClient;
import okhttp3.Request;
import okhttp3.Response;

public class MainActivity extends AppCompatActivity implements View.OnClickListener {

    private Button syncGet;
    private Button asyncget;
    private Button post;
    private Button fileDownload;
    private TextView tvtext;
    private String result;




    private static OkHttpClient client = new OkHttpClient();


    /**
     * 在这里直接设置连接超时，静态方法内，在构造方法被调用前就已经初始话了
     */
    static {
        client.newBuilder().connectTimeout(10, TimeUnit.SECONDS);
        client.newBuilder().readTimeout(10, TimeUnit.SECONDS);
        client.newBuilder().writeTimeout(10, TimeUnit.SECONDS);
    }

    private Request request;

    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_main);
        initialize();
        initListener();

    }

    /**
     * 事件监听
     */
    private void initListener() {
        syncGet.setOnClickListener(this);
        asyncget.setOnClickListener(this);
        post.setOnClickListener(this);
        fileDownload.setOnClickListener(this);
    }


    /**
     * 初始化布局控件
     */
    private void initialize() {

        syncGet = (Button) findViewById(R.id.syncGet);
        asyncget = (Button) findViewById(R.id.asyncget);
        post = (Button) findViewById(R.id.post);
        tvtext = (TextView) findViewById(R.id.tv_text);
        fileDownload = (Button) findViewById(R.id.fileDownload);
    }


    @Override
    public void onClick(View v) {
        switch (v.getId()) {
            case R.id.syncGet:
                initSyncData();
                break;
            case R.id.asyncget:
                initAsyncGet();
                break;
            case R.id.post:
                initPost();
                break;
            case R.id.fileDownload:
                downLoadFile();
                break;
            default：
                break;
        }
    }



    /**
     * get请求同步方法
     */
    private void initSyncData() {
        new Thread(new Runnable() {
            @Override
            public void run() {
                try {
                    request = new Request.Builder().url(Contants.SYNC_URL).build();
                    Response response = client.newCall(request).execute();
                    result = response.body().string();
                    runOnUiThread(new Runnable() {
                        @Override
                        public void run() {
                            tvtext.setText(result);
                            Log.d("MainActivity", "hello");
                        }
                    });
                } catch (Exception e) {
                    e.printStackTrace();
                }
            }
        }).start();

    }

    /**
     * 异步请求
     */
    private void initAsyncGet() {
        new Thread(new Runnable() {
            @Override
            public void run() {
                request = new Request.Builder().url(Contants.ASYNC_URL).build();
                client.newCall(request).enqueue(new Callback() {

                    /**
                     * @param call   是一个接口，  是一个准备好的可以执行的request
                     *               可以取消，对位一个请求对象，只能单个请求
                     * @param e
                     */
                    @Override
                    public void onFailure(Call call, IOException e) {
                        Log.d("MainActivity", "请求失败");
                    }

                    /**
                     *
                     * @param call
                     * @param response   是一个响应请求
                     * @throws IOException
                     */
                    @Override
                    public void onResponse(Call call, Response response) throws IOException {
                        /**
                         * 通过拿到response这个响应请求，然后通过body().string(),拿到请求到的数据
                         * 这里最好用string()  而不要用toString（）
                         * toString（）每个类都有的，是把对象转换为字符串
                         * string（）是把流转为字符串
                         */
                        result = response.body().string();
                        runOnUiThread(new Runnable() {
                            @Override
                            public void run() {
                                tvtext.setText(result);
                            }
                        });
                    }
                });
            }
        }).start();
    }

    /**
     * 表单提交
     */
    private void initPost() {

        String url = "http://112.124.22.238:8081/course_api/banner/query";


        FormBody formBody = new FormBody.Builder()
                .add("type", "1")
                .build();
        request = new Request.Builder().url(url)
                .post(formBody).build();
        new Thread(new Runnable() {
            @Override
            public void run() {
                client.newCall(request).enqueue(new Callback() {
                    @Override
                    public void onFailure(Call call, IOException e) {

                    }

                    @Override
                    public void onResponse(Call call, final Response response) throws IOException {
                        runOnUiThread(new Runnable() {
                            @Override
                            public void run() {
                                tvtext.setText("提交成功");
                            }
                        });
                    }
                });
            }
        }).start();

    }

    /**
     * 文件下载地址
     */
    private void downLoadFile() {
        String url = "http://www.0551fangchan.com/images/keupload/20120917171535_49309.jpg";
        request = new Request.Builder().url(url).build();
        OkHttpClient client = new OkHttpClient();
        client.newCall(request).enqueue(new Callback() {
            @Override
            public void onFailure(Call call, IOException e) {

            }

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

                //把请求成功的response转为字节流
                InputStream inputStream = response.body().byteStream();

                /**
                 * 在这里要加上权限   在mainfests文件中
                 * <uses-permission android:name="android.permission.INTERNET"/>
                 * <uses-permission android:name="android.permission.WRITE_EXTERNAL_STORAGE"/>
                 */

                //在这里用到了文件输出流
                FileOutputStream fileOutputStream = new FileOutputStream(new File("/sdcard/logo.jpg"));
               //定义一个字节数组
                byte[] buffer = new byte[2048];
                int len = 0;
                while ((len = inputStream.read(buffer)) != -1) {
                    //写出到文件
                    fileOutputStream.write(buffer, 0, len);
                }
                //关闭输出流
                fileOutputStream.flush();
                Log.d("wuyinlei", "文件下载成功...");
            }
        });
    }


}

在这里插入图片描述

参考

1、https://blog.csdn.net/fightingXia/article/details/70947701
2、https://blog.csdn.net/chenzujie/article/details/46994073
3、https://blog.csdn.net/weixin_30700099/article/details/95962192
4、https://www.jianshu.com/p/5a12ae6d741a
5、https://www.jianshu.com/p/ca8a982a116b
6、https://wuyinlei.blog.csdn.net/article/details/50579564

本文内容由网友自发贡献，版权归原作者所有，本站不承担相应法律责任。如您发现有涉嫌抄袭侵权的内容，请联系:hwhale#tublm.com(使用前将#替换为@)