Apache httpclient & okhttp（2）

学习链接

Apache httpclient & okhttp（1）
Apache httpclient & okhttp（2）
okhttp github
okhttp官方使用文档
okhttp官方示例代码
OkHttp使用介绍
OkHttp使用进阶 译自OkHttp Github官方教程
SpringBoot 整合okHttp okhttp3用法
Java中常用的HTTP客户端库：OkHttp和HttpClient（包含请求示例代码）
深入浅出 OkHttp 源码解析及应用实践

  
okhttp

okhttp概述

HTTP是当代应用程序的网络方式。这是我们互换数据和媒体的方式。高效地使用HTTP可以让您的东西加载更快并节省带宽。
OkHttp使用起来很方便。它的请求/响应API筹划具有流式构建和不可变性。它支持同步壅闭调用和带有回调的异步调用。
特点

OkHttp是一个高效的默认HTTP客户端

• HTTP/2支持答应对同一主机的全部请求共享一个套接字。
  
• 连接池淘汰了请求延时（假如HTTP/2不可用）。
  
• 透明GZIP缩小了下载巨细。
  
• 响应缓存完全避免了重复请求的网络。
  

OkHttp遵照当代HTTP规范，例如

• HTTP语义-RFC 9110
  
• HTTP缓存-RFC 9111
  
• HTTP/1.1-RFC 9112
  
• HTTP/2-RFC 9113
  
• Websocket-RFC 6455
  
• SSE-服务器发送的事件
  

快速入门

pom.xml

注意：okhttp的3.9.0版本用的是java，okhttp4.12.0用的是kotlin。

1. <?xml version="1.0" encoding="UTF-8"?>
2. <project xmlns="http://maven.apache.org/POM/4.0.0"
3.          xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
4.          xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
5.     <modelVersion>4.0.0</modelVersion>
7.     <groupId>com.zzhua</groupId>
8.     <artifactId>demo-okhttp</artifactId>
9.     <version>1.0-SNAPSHOT</version>
11.     <properties>
12.         <maven.compiler.source>8</maven.compiler.source>
13.         <maven.compiler.target>8</maven.compiler.target>
14.         <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
15.         <!--<okhttp.version>3.9.0</okhttp.version>-->
16.         <!--<okhttp.version>3.14.9</okhttp.version>-->
17.         <!-- OkHttp从4.x版本开始转向Kotlin, Kotlin 代码可以被编译成标准的 JVM 字节码运行，这与 Java 代码的最终执行形式完全兼容。 -->
18.         <okhttp.version>4.12.0</okhttp.version>
19.     </properties>
21.     <dependencies>
23.         <dependency>
24.             <groupId>com.squareup.okhttp3</groupId>
25.             <artifactId>okhttp</artifactId>
26.             <version>${okhttp.version}</version>
27.         </dependency>
29.     </dependencies>
31. </project>

复制代码

get请求

1. import okhttp3.OkHttpClient;
2. import okhttp3.Request;
3. import okhttp3.Response;
5. import java.io.IOException;
7. public class Test01 {
9.     public static void main(String[] args) {
10.         OkHttpClient client = new OkHttpClient();
12.         Request request = new Request.Builder()
13.                 .url("http://www.baidu.com")
14.                 .build();
16.         try (Response response = client.newCall(request).execute()) {
17.             System.out.println(response.body().string());
18.         } catch (IOException e) {
19.             throw new RuntimeException(e);
20.         }
21.     }
23. }

复制代码

Post请求

1. import okhttp3.*;
2. public class Test02 {
3.     public static void main(String[] args) {
4.    
5.         OkHttpClient client = new OkHttpClient();
7.         RequestBody body = RequestBody.create(MediaType.parse("application/json"),
8.                                                                                  "{"username":"zzhua"}");
9.         Request request = new Request.Builder()
10.                 .url("http://localhost:8080/ok01")
11.                 .post(body)
12.                 .build();
13.         try (Response response = client.newCall(request).execute()) {
14.             System.out.println(response.body().string());
15.         } catch (Exception e) {
16.             throw new RuntimeException(e);
17.         }
18.     }
20. }

复制代码

示例代码

这些示例代码来自：https://square.github.io/okhttp/recipes，
官方也有对应的代码：https://github.com/square/okhttp/blob/okhttp_3.14.x/samples

同步请求

下载文件，打印headers，并将其响应正文打印为字符串。

• 响应正文上的string()方法对于小文档来说既方便又高效。但是假如响应正文很大（大于1 MiB），避免string()，因为它会将整个文档加载到内存中。在这种情况下，更推荐将正文作为流处理惩罚。
  

1. import okhttp3.Headers;
2. import okhttp3.OkHttpClient;
3. import okhttp3.Request;
4. import okhttp3.Response;
6. import java.io.IOException;
8. public class TestSynchronous {
10.     private final static OkHttpClient client = new OkHttpClient();
12.     public static void main(String[] args) {
14.         Request request = new Request.Builder()
15.                 .url("https://publicobject.com/helloworld.txt")
16.                 .build();
18.         try (Response response = client.newCall(request).execute()) {
19.             if (!response.isSuccessful())
20.                 throw new IOException("Unexpected code " + response);
22.                         // 获取响应头
23.             Headers responseHeaders = response.headers();
24.             for (int i = 0; i < responseHeaders.size(); i++) {
25.                 System.out.println(responseHeaders.name(i) + ": " + responseHeaders.value(i));
26.             }
27.                        
28.                         // 获取响应体
29.             System.out.println(response.body().string());
30.         } catch (IOException e) {
31.             throw new RuntimeException(e);
32.         }
34.     }
36. }

复制代码

异步请求

在工作线程中下载文件，并在响应可读取时触发回调。该回调会在响应头准备停当后触发，但读取响应体仍大概壅闭线程。当前OkHttp未提供异步API以分块吸收响应体内容。

1. @Slf4j
2. public class Test02Async {
4.     public static void main(String[] args) {
6.         log.info("main start");
8.         OkHttpClient okHttpClient = new OkHttpClient();
11.         Request requeset = new Request.Builder()
12.                 .url("http://publicobject.com/helloworld.txt")
13.                 .build();
15.         Call call = okHttpClient.newCall(requeset);
17.         log.info("call.enqueue");
19.         // 执行回调的线程不是main线程
20.         call.enqueue(new Callback() {
21.             @Override
22.             public void onFailure(Call call, IOException e) {
23.                 log.info("=========请求失败=========: {}", e);
24.             }
26.             @Override
27.             public void onResponse(Call call, Response response) throws IOException {
28.                 log.info("=========获得响应=========");
29.                 try (ResponseBody responseBody = response.body()) {
30.                     if (!response.isSuccessful())
31.                         throw new IOException("Unexpected code " + response);
33.                     Headers responseHeaders = response.headers();
34.                     for (int i = 0, size = responseHeaders.size(); i < size; i++) {
35.                         System.out.println(responseHeaders.name(i) + ": " + responseHeaders.value(i));
36.                     }
38.                     System.out.println(responseBody.string());
39.                 }
40.             }
41.         });
43.         log.info("main end");
45.     }
47. }

复制代码

请求头&响应头

1. public class TestHeader {
3.     public static void main(String[] args) {
5.         OkHttpClient okHttpClient = new OkHttpClient();
7.         Request request = new Request.Builder()
8.                 .url("https://api.github.com/repos/square/okhttp/issues")
9.                 // 单个header值
10.                 .header("User-Agent", "OkHttp Headers.java")
11.                 // 多个header值
12.                 .addHeader("Accept", "application/json; q=0.5")
13.                 .addHeader("Accept", "application/vnd.github.v3+json")
14.                 .build();
16.         try (Response response = okHttpClient.newCall(request).execute()) {
18.             if (!response.isSuccessful())
19.                 throw new IOException("Unexpected code " + response);
21.             System.out.println("Server: " + response.header("Server"));
22.             System.out.println("Date: " + response.header("Date"));
23.             // 多个响应头使用headers()获取
24.             System.out.println("Vary: " + response.headers("Vary"));
27.         } catch (IOException e) {
28.             throw new RuntimeException(e);
29.         }
31.     }
33. }

复制代码

post + 请求体

使用HTTP POST向服务发送请求正文。此示例将markdown文档发布到将markdown渲染为html。由于整个请求正文同时在内存中，因此避免使用此API发布大型（大于1 MiB）文档。

1. public class TestRequestBody {
3.     public static void main(String[] args) {
5.         MediaType mediaType = MediaType.parse("text/x-markdown; charset=utf-8");
7.         OkHttpClient client = new OkHttpClient();
9.         String postBody = ""
10.                 + "Releases\n"
11.                 + "--------\n"
12.                 + "\n"
13.                 + " * _1.0_ May 6, 2013\n"
14.                 + " * _1.1_ June 15, 2013\n"
15.                 + " * _1.2_ August 11, 2013\n";
17.         Request request = new Request.Builder()
18.                 .url("https://api.github.com/markdown/raw")
19.                 .post(RequestBody.create(mediaType, postBody))
20.                 .build();
22.         try {
23.             Response response = client.newCall(request).execute();
24.             if (!response.isSuccessful())
25.                 throw new IOException("Unexpected code " + response);
26.             System.out.println(response.body().string());
27.         } catch (Exception e) {
28.             throw new RuntimeException(e);
29.         }
31.     }
33. }

复制代码

流式传输

我们在这里将请求体以流的情势举行POST提交。该请求体的内容在写入过程中动态生成。此示例直接将数据流式写入Okio的缓冲池(Buffered Sink)。您的程序大概更倾向于使用OutputStream，您可以通过BufferedSink.outputStream()方法获取它。

• 流式传输(Streaming)：区别于一次性加载完整数据到内存，流式传输答应边生成数据边发送，尤其得当：大文件传输（如视频上传）、及时生成数据（如传感器数据流）、内存敏感场景（避免OOM）
  

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

复制代码

流式传输扩展示例

通过观察客户端和服务端的日记，可以看到客户端发的同时，服务端也在收。
Test05StreamClient

1. @Slf4j
2. public class Test05StreamClient {
4.     public static void main(String[] args) {
5.         OkHttpClient client = new OkHttpClient.Builder()
6.                 .writeTimeout(30, TimeUnit.SECONDS) // 延长写入超时
7.                 .build();
9.         // 创建流式 RequestBody
10.         RequestBody requestBody = new RequestBody() {
11.             @Override
12.             public MediaType contentType() {
13.                 return MediaType.parse("application/octet-stream");
14.             }
16.             @Override
17.             public void writeTo(BufferedSink sink) throws IOException {
18.                 try (java.io.OutputStream os = sink.outputStream()) {
19.                     for (int i = 0; i < 50; i++) {
20.                         // 模拟生成数据块
21.                         String chunk = "Chunk-" + i + "\n";
22.                         log.info("发送数据块: {}", chunk);
23.                         os.write(chunk.getBytes());
24.                         os.flush(); // 立即刷新缓冲区
25.                         Thread.sleep(100); // 模拟延迟
26.                     }
27.                 } catch (InterruptedException e) {
28.                     Thread.currentThread().interrupt();
29.                 }
30.             }
31.         };
33.         Request request = new Request.Builder()
34.                 .url("http://localhost:8080/stream-upload-raw")
35.                 .post(requestBody)
36.                 .header("Content-Type", "application/octet-stream") // 强制覆盖
37.                 .build();
39.         // 异步执行
40.         client.newCall(request).enqueue(new Callback() {
41.             @Override
42.             public void onFailure(Call call, IOException e) {
43.                 log.info("[请求失败]");
44.             }
46.             @Override
47.             public void onResponse(Call call, Response response) throws IOException {
48.                 log.info("[请求成功]");
49.                 System.out.println("上传成功: " + response.code());
50.                 System.out.println("响应内容: " + response.body().string());
51.                 response.close();
52.             }
53.         });
54.     }
55. }

复制代码

StreamController

1. @Slf4j
2. @RestController
3. public class StreamController {
5.     // 通过 HttpServletRequest 获取原始流
6.     @PostMapping("/stream-upload-raw")
7.     public String handleRawStream(HttpServletRequest request) {
8.         try (InputStream rawStream = request.getInputStream()) {
9.             byte[] buffer = new byte[1024];
10.             int bytesRead;
11.             while ((bytesRead = rawStream.read(buffer)) != -1) { // 按字节读取
12.                 String chunk = new String(buffer, 0, bytesRead);
13.                 log.info("[字节流] {}, {}", chunk.trim(), bytesRead);
14.             }
15.             return "Raw stream processed";
16.         } catch (IOException e) {
17.             return "Error: " + e.getMessage();
18.         }
19.     }
20. }

复制代码

文件传输

将文件作为请求体。

1. public class Test06File {
3.     public static void main(String[] args) {
5.         OkHttpClient client = new OkHttpClient();
7.         Request request = new Request.Builder()
8.                 .url("http://localhost:8080/okFile")
9.                 .post(RequestBody.create(null, new File("C:\\Users\\zzhua195\\Desktop\\test.png")))
10.                 .build();
12.         try (Response response = client.newCall(request).execute()) {
13.             if (!response.isSuccessful()) throw new IOException("Unexpected code " + response);
15.             System.out.println(response.body().string());
16.         } catch (IOException e) {
17.             throw new RuntimeException(e);
18.         }
20.     }
22. }

复制代码

后端代码

1. @RequestMapping("okFile")
2. public Object okFile(HttpServletRequest request) throws Exception {
3.      ServletInputStream inputStream = request.getInputStream();
4.      org.springframework.util.FileCopyUtils.copy(request.getInputStream(), new FileOutputStream("D:\\Projects\\practice\\demo-boot\\src\\main\\resources\\test.png"));
5.      return "ok";
6. }

复制代码

表单提交

使用FormBody.Builder构建一个像超文本标记语言<form>标签一样工作的请求正文。名称和值将使用超文本标记语言兼容的表单URL编码举行编码。

1. public class Test07Form {
3.     public static void main(String[] args) {
5.         OkHttpClient client = new OkHttpClient();
7.         RequestBody formBody = new FormBody.Builder()
8.                 .add("username", "Jurassic Park")
9.                 .build();
11.         Request request = new Request.Builder()
12.                 .url("http://localhost:8080/okForm")
13.                 .post(formBody)
14.                 .build();
16.         try (Response response = client.newCall(request).execute()) {
17.             if (!response.isSuccessful())
18.                 throw new IOException("Unexpected code " + response);
20.             System.out.println(response.body().string());
21.         } catch (IOException e) {
22.             throw new RuntimeException(e);
23.         }
25.     }
27. }

复制代码

对应的后端代码

1. @RequestMapping("okForm")
2. public Object okForm(LoginForm loginForm) throws Exception {
3.      log.info("[okForm] {}", loginForm);
4.      return "ok";
5. }

复制代码

文件上传

MultipartBody.Builder可以构建与超文本标记语言文件上传表单兼容的复杂请求正文。多部门请求正文的每个部门自己就是一个请求正文，而且可以界说自己的标头。假如存在，这些标头应该形貌部门正文，例如它的Content-Disposition。假如可用，Content-Length和Content-Type标头会主动添加

1. public class Test08MultipartFile {
3.     public static void main(String[] args) {
5.         OkHttpClient client = new OkHttpClient();
7.         RequestBody requestBody = new MultipartBody.Builder()
8.                 .setType(MultipartBody.FORM)
9.                 .addFormDataPart("comment", "Square Logo")
10.                 .addFormDataPart("bin", "logo-square.png", RequestBody.create(null, new File("C:\\Users\\zzhua195\\Desktop\\test.png")))
11.                 .build();
13.         Request request = new Request.Builder()
14.                 .header("Authorization", "Client-ID")
15.                 .url("http://127.0.0.1:8080/multipart02")
16.                 .post(requestBody)
17.                 .build();
19.         try (Response response = client.newCall(request).execute()) {
20.             if (!response.isSuccessful()) throw new IOException("Unexpected code " + response);
22.             System.out.println(response.body().string());
23.         } catch (IOException e) {
24.             throw new RuntimeException(e);
25.         }
27.     }
29. }

复制代码

对应的后端代码

1. @RequestMapping("multipart01")
2. public Object multipart(
3.          @RequestPart("bin") MultipartFile file,
4.          @RequestPart("comment") String comment
5. ) throws InterruptedException, IOException {
6.      System.out.println(file.getBytes().length);
7.      System.out.println(comment);
8.      return "ojbk";
9. }
11. @RequestMapping("multipart02")
12. public Object multipart(MultipartDTO multipartDTO) throws InterruptedException, IOException {
13.      System.out.println(multipartDTO.getBin().getBytes().length);
14.      System.out.println(multipartDTO.getComment());
15.      return "ojbk";
16. }

复制代码

响应缓存

1、要缓存响应，您必要一个可以读取和写入的缓存目录，以及对缓存巨细的限定。缓存目录应该是私有的，不受信托的应用程序应该无法读取其内容！
2、让多个缓存同时访问同一个缓存目录是错误的。大多数应用程序应该只调用一次new OkHttpClient()，用它们的缓存配置它，并在任何地方使用相同的实例。否则两个缓存实例会相互踩踏，粉碎响应缓存，并大概使您的程序瓦解。
3、响应缓存对全部配置都使用HTTP标头。您可以添加请求标头，如Cache-Control: max-stale=3600，OkHttp的缓存将恭敬它们。您的网络服务器使用自己的响应标头配置缓存响应的时间，如Cache-Control: max-age=9600。有缓存标头可以强制缓存响应、强制网络响应或强制使用条件GET验证网络响应。
4、要防止响应使用缓存，请使用CacheControl.FORCE_NETWORK。要防止它使用网络，请使用CacheControl.FORCE_CACHE。请注意：假如您使用FORCE_CACHE而且响应必要网络，OkHttp将返回504 Unsatisfiable Request响应。

1. import okhttp3.Cache;
2. import okhttp3.OkHttpClient;
3. import okhttp3.Request;
4. import okhttp3.Response;
6. import java.io.File;
7. import java.io.IOException;
9. public class Test09CacheResponse {
11.     public static void main(String[] args) {
12.         try {
13.             Test09CacheResponse test = new Test09CacheResponse(new File("cache"));
14.             test.run();
15.         } catch (Exception e) {
16.             throw new RuntimeException(e);
17.         }
18.     }
20.     private final OkHttpClient client;
22.     public Test09CacheResponse(File cacheDirectory) throws Exception {
23.         int cacheSize = 10 * 1024 * 1024; // 10 MiB
24.         Cache cache = new Cache(cacheDirectory, cacheSize);
26.         client = new OkHttpClient.Builder()
27.                 .cache(cache)
28.                 .build();
29.     }
31.     public void run() throws Exception {
32.         Request request = new Request.Builder()
33.                 .url("http://publicobject.com/helloworld.txt")
34.                 .build();
36.         String response1Body;
37.         try (Response response1 = client.newCall(request).execute()) {
38.             if (!response1.isSuccessful()) throw new IOException("Unexpected code " + response1);
40.             response1Body = response1.body().string();
41.             System.out.println("Response 1 response:          " + response1);
42.             System.out.println("Response 1 cache response:    " + response1.cacheResponse());
43.             System.out.println("Response 1 network response:  " + response1.networkResponse());
44.         }
46.         String response2Body;
47.         try (Response response2 = client.newCall(request).execute()) {
48.             if (!response2.isSuccessful()) throw new IOException("Unexpected code " + response2);
50.             response2Body = response2.body().string();
51.             System.out.println("Response 2 response:          " + response2);
52.             System.out.println("Response 2 cache response:    " + response2.cacheResponse());
53.             System.out.println("Response 2 network response:  " + response2.networkResponse());
54.         }
56.         System.out.println("Response 2 equals Response 1? " + response1Body.equals(response2Body));
57.     }
59. }
60. /*
61. Response 1 response:          Response{protocol=http/1.1, code=200, message=OK, url=https://publicobject.com/helloworld.txt}
62. Response 1 cache response:    null
63. Response 1 network response:  Response{protocol=http/1.1, code=200, message=OK, url=https://publicobject.com/helloworld.txt}
64. Response 2 response:          Response{protocol=http/1.1, code=200, message=OK, url=https://publicobject.com/helloworld.txt}
65. Response 2 cache response:    Response{protocol=http/1.1, code=200, message=OK, url=https://publicobject.com/helloworld.txt}
66. Response 2 network response:  null
67. Response 2 equals Response 1? true
68. */

复制代码

取消调用

使用Call.cancel()立即制止正在举行的调用。假如线程当前正在写入请求或读取响应，它将收到IOException。当不再必要调用时，使用它来节省网络；例如，当您的用户导航脱离应用程序时。同步和异步调用都可以取消。

1. public class Test09CancelCall {
3.     public static void main(String[] args) throws Exception {
4.         new Test09CancelCall().run();
5.     }
7.     private final ScheduledExecutorService executor = Executors.newScheduledThreadPool(1);
8.     private final OkHttpClient client = new OkHttpClient();
10.     public void run() throws Exception {
11.         Request request = new Request.Builder()
12.                 .url("http://httpbin.org/delay/2") // This URL is served with a 2 second delay.
13.                 .build();
15.         final long startNanos = System.nanoTime();
16.         final Call call = client.newCall(request);
18.         // Schedule a job to cancel the call in 1 second.
19.         executor.schedule(new Runnable() {
20.             @Override public void run() {
21.                 System.out.printf("%.2f Canceling call.%n", (System.nanoTime() - startNanos) / 1e9f);
22.                 call.cancel();
23.                 System.out.printf("%.2f Canceled call.%n", (System.nanoTime() - startNanos) / 1e9f);
24.             }
25.         }, 1, TimeUnit.SECONDS);
27.         System.out.printf("%.2f Executing call.%n", (System.nanoTime() - startNanos) / 1e9f);
28.         try (Response response = call.execute()) {
29.             System.out.printf("%.2f Call was expected to fail, but completed: %s%n",  (System.nanoTime() - startNanos) / 1e9f, response);
30.         } catch (IOException e) {
31.             System.out.printf("%.2f Call failed as expected: %s%n", (System.nanoTime() - startNanos) / 1e9f, e);
32.         }
33.     }
35. }

复制代码

超时

1. private final OkHttpClient client;
3. public ConfigureTimeouts() throws Exception {
4.   client = new OkHttpClient.Builder()
5.       .connectTimeout(10, TimeUnit.SECONDS)
6.       .writeTimeout(10, TimeUnit.SECONDS)
7.       .readTimeout(30, TimeUnit.SECONDS)
8.       .build();
9. }
11. public void run() throws Exception {
12.   Request request = new Request.Builder()
13.       .url("http://httpbin.org/delay/2") // This URL is served with a 2 second delay.
14.       .build();
16.   try (Response response = client.newCall(request).execute()) {
17.     System.out.println("Response completed: " + response);
18.   }
19. }

复制代码

每次调用配置

全部HTTP客户端配置都存在OkHttpClient中，包括署理设置、超时和缓存。当您必要更改单个调用的配置时，调用OkHttpClient.newBuilder()。这将返回一个与原始客户端共享相同连接池、调度程序和配置的构建器。在下面的示例中，我们发出一个超时500毫秒的请求，另一个超时3000毫秒。

1. private final OkHttpClient client = new OkHttpClient();
3. public void run() throws Exception {
4.   Request request = new Request.Builder()
5.       .url("http://httpbin.org/delay/1") // This URL is served with a 1 second delay.
6.       .build();
8.   // 拷贝client的属性，并作出自定义修改
9.   OkHttpClient client1 = client.newBuilder()
10.       .readTimeout(500, TimeUnit.MILLISECONDS)
11.       .build();
12.   try (Response response = client1.newCall(request).execute()) {
13.     System.out.println("Response 1 succeeded: " + response);
14.   } catch (IOException e) {
15.     System.out.println("Response 1 failed: " + e);
16.   }
18.   // Copy to customize OkHttp for this request.
19.   OkHttpClient client2 = client.newBuilder()
20.       .readTimeout(3000, TimeUnit.MILLISECONDS)
21.       .build();
22.   try (Response response = client2.newCall(request).execute()) {
23.     System.out.println("Response 2 succeeded: " + response);
24.   } catch (IOException e) {
25.     System.out.println("Response 2 failed: " + e);
26.   }
27. }

复制代码

处理惩罚鉴权

OkHttp可以主动重试未经身份验证的请求。当响应为401 Not Authorized时，会要求Authenticator提供凭据。实现应该构建一个包含缺失凭据的新请求。假如没有可用的凭据，则返回null以跳过重试。

1. private final OkHttpClient client;
3. public Authenticate() {
4. client = new OkHttpClient.Builder()
5.      .authenticator(new Authenticator() {
6.        @Override public Request authenticate(Route route, Response response) throws IOException {
7.          if (response.request().header("Authorization") != null) {
8.            return null; // Give up, we've already attempted to authenticate.
9.          }
11.          System.out.println("Authenticating for response: " + response);
12.          System.out.println("Challenges: " + response.challenges());
13.          String credential = Credentials.basic("jesse", "password1");
14.          return response.request().newBuilder()
15.              .header("Authorization", credential)
16.              .build();
17.        }
18.      })
19.      .build();
20. }
22. public void run() throws Exception {
23. Request request = new Request.Builder()
24.      .url("http://publicobject.com/secrets/hellosecret.txt")
25.      .build();
27. try (Response response = client.newCall(request).execute()) {
28.    if (!response.isSuccessful()) throw new IOException("Unexpected code " + response);
30.    System.out.println(response.body().string());
31. }
32. }

复制代码

为避免在鉴权不起作用时举行多次重试，您可以返回null以放弃。例如，当已经实行了这些确切的凭据时，您大概希望跳过重试：

1. if (credential.equals(response.request().header("Authorization"))) {
2.         return null; // If we already failed with these credentials, don't retry.
3. }

复制代码

当您达到应用程序界说的实行限定时，您也可以跳过重试：

1. if (responseCount(response) >= 3) {
2. return null; // If we've failed 3 times, give up.
3. }

复制代码

拦截器

参考：https://square.github.io/okhttp/features/interceptors/

1. import okhttp3.Interceptor;
2. import okhttp3.OkHttpClient;
3. import okhttp3.Request;
4. import okhttp3.Response;
6. import java.io.IOException;
8. @Slf4j
9. public class TestInterceptor {
11.     public static void main(String[] args) throws IOException {
13.         OkHttpClient client = new OkHttpClient.Builder()
14.                 .addInterceptor(new LoggingInterceptor())
15.                 // .addNetworkInterceptor(new LoggingInterceptor())
16.                 .build();
18.         Request request = new Request.Builder()
19.                 .url("http://www.publicobject.com/helloworld.txt")
20.                 .header("User-Agent", "OkHttp Example")
21.                 .build();
23.         Response response = client.newCall(request).execute();
24.         response.body().close();
25.     }
27.     static class LoggingInterceptor implements Interceptor {
28.         @Override public Response intercept(Interceptor.Chain chain) throws IOException {
29.             Request request = chain.request();
31.             long t1 = System.nanoTime();
32.             log.info(String.format("Sending request %s on %s%n%s",
33.                     request.url(), chain.connection(), request.headers()));
35.             Response response = chain.proceed(request);
37.             long t2 = System.nanoTime();
38.             log.info(String.format("Received response for %s in %.1fms%n%s",
39.                     response.request().url(), (t2 - t1) / 1e6d, response.headers()));
41.             return response;
42.         }
43.     }
45. }

复制代码

事件监听

免责声明：如果侵犯了您的权益，请联系站长，我们会及时删除侵权内容，谢谢合作！更多信息从访问主页：qidao123.com:ToB企服之家，中国第一个企服评测及商务社交产业平台。