From 248d71e3b3fa0bf8f1da1fb08cd0aef30a0d654d Mon Sep 17 00:00:00 2001 From: ejlchina Date: Tue, 31 Mar 2020 09:43:45 +0800 Subject: [PATCH 001/924] Initial commit --- .gitee/ISSUE_TEMPLATE.zh-CN.md | 13 ++ .gitee/PULL_REQUEST_TEMPLATE.zh-CN.md | 15 ++ LICENSE | 201 ++++++++++++++++++++++++++ README.en.md | 36 +++++ README.md | 37 +++++ 5 files changed, 302 insertions(+) create mode 100644 .gitee/ISSUE_TEMPLATE.zh-CN.md create mode 100644 .gitee/PULL_REQUEST_TEMPLATE.zh-CN.md create mode 100644 LICENSE create mode 100644 README.en.md create mode 100644 README.md diff --git a/.gitee/ISSUE_TEMPLATE.zh-CN.md b/.gitee/ISSUE_TEMPLATE.zh-CN.md new file mode 100644 index 00000000..f09d98dd --- /dev/null +++ b/.gitee/ISSUE_TEMPLATE.zh-CN.md @@ -0,0 +1,13 @@ +### 该问题是怎么引起的？ + + + +### 重现步骤 + + + +### 报错信息 + + + + diff --git a/.gitee/PULL_REQUEST_TEMPLATE.zh-CN.md b/.gitee/PULL_REQUEST_TEMPLATE.zh-CN.md new file mode 100644 index 00000000..1e5b8d33 --- /dev/null +++ b/.gitee/PULL_REQUEST_TEMPLATE.zh-CN.md @@ -0,0 +1,15 @@ +### 相关的Issue + + +### 原因（目的、解决的问题等） + + +### 描述（做了什么，变更了什么） + + +### 测试用例 + + + + + diff --git a/LICENSE b/LICENSE new file mode 100644 index 00000000..261eeb9e --- /dev/null +++ b/LICENSE @@ -0,0 +1,201 @@ + Apache License + Version 2.0, January 2004 + http://www.apache.org/licenses/ + + TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION + + 1. Definitions. + + "License" shall mean the terms and conditions for use, reproduction, + and distribution as defined by Sections 1 through 9 of this document. + + "Licensor" shall mean the copyright owner or entity authorized by + the copyright owner that is granting the License. + + "Legal Entity" shall mean the union of the acting entity and all + other entities that control, are controlled by, or are under common + control with that entity. For the purposes of this definition, + "control" means (i) the power, direct or indirect, to cause the + direction or management of such entity, whether by contract or + otherwise, or (ii) ownership of fifty percent (50%) or more of the + outstanding shares, or (iii) beneficial ownership of such entity. + + "You" (or "Your") shall mean an individual or Legal Entity + exercising permissions granted by this License. + + "Source" form shall mean the preferred form for making modifications, + including but not limited to software source code, documentation + source, and configuration files. + + "Object" form shall mean any form resulting from mechanical + transformation or translation of a Source form, including but + not limited to compiled object code, generated documentation, + and conversions to other media types. + + "Work" shall mean the work of authorship, whether in Source or + Object form, made available under the License, as indicated by a + copyright notice that is included in or attached to the work + (an example is provided in the Appendix below). + + "Derivative Works" shall mean any work, whether in Source or Object + form, that is based on (or derived from) the Work and for which the + editorial revisions, annotations, elaborations, or other modifications + represent, as a whole, an original work of authorship. For the purposes + of this License, Derivative Works shall not include works that remain + separable from, or merely link (or bind by name) to the interfaces of, + the Work and Derivative Works thereof. + + "Contribution" shall mean any work of authorship, including + the original version of the Work and any modifications or additions + to that Work or Derivative Works thereof, that is intentionally + submitted to Licensor for inclusion in the Work by the copyright owner + or by an individual or Legal Entity authorized to submit on behalf of + the copyright owner. For the purposes of this definition, "submitted" + means any form of electronic, verbal, or written communication sent + to the Licensor or its representatives, including but not limited to + communication on electronic mailing lists, source code control systems, + and issue tracking systems that are managed by, or on behalf of, the + Licensor for the purpose of discussing and improving the Work, but + excluding communication that is conspicuously marked or otherwise + designated in writing by the copyright owner as "Not a Contribution." + + "Contributor" shall mean Licensor and any individual or Legal Entity + on behalf of whom a Contribution has been received by Licensor and + subsequently incorporated within the Work. + + 2. Grant of Copyright License. Subject to the terms and conditions of + this License, each Contributor hereby grants to You a perpetual, + worldwide, non-exclusive, no-charge, royalty-free, irrevocable + copyright license to reproduce, prepare Derivative Works of, + publicly display, publicly perform, sublicense, and distribute the + Work and such Derivative Works in Source or Object form. + + 3. Grant of Patent License. Subject to the terms and conditions of + this License, each Contributor hereby grants to You a perpetual, + worldwide, non-exclusive, no-charge, royalty-free, irrevocable + (except as stated in this section) patent license to make, have made, + use, offer to sell, sell, import, and otherwise transfer the Work, + where such license applies only to those patent claims licensable + by such Contributor that are necessarily infringed by their + Contribution(s) alone or by combination of their Contribution(s) + with the Work to which such Contribution(s) was submitted. If You + institute patent litigation against any entity (including a + cross-claim or counterclaim in a lawsuit) alleging that the Work + or a Contribution incorporated within the Work constitutes direct + or contributory patent infringement, then any patent licenses + granted to You under this License for that Work shall terminate + as of the date such litigation is filed. + + 4. Redistribution. You may reproduce and distribute copies of the + Work or Derivative Works thereof in any medium, with or without + modifications, and in Source or Object form, provided that You + meet the following conditions: + + (a) You must give any other recipients of the Work or + Derivative Works a copy of this License; and + + (b) You must cause any modified files to carry prominent notices + stating that You changed the files; and + + (c) You must retain, in the Source form of any Derivative Works + that You distribute, all copyright, patent, trademark, and + attribution notices from the Source form of the Work, + excluding those notices that do not pertain to any part of + the Derivative Works; and + + (d) If the Work includes a "NOTICE" text file as part of its + distribution, then any Derivative Works that You distribute must + include a readable copy of the attribution notices contained + within such NOTICE file, excluding those notices that do not + pertain to any part of the Derivative Works, in at least one + of the following places: within a NOTICE text file distributed + as part of the Derivative Works; within the Source form or + documentation, if provided along with the Derivative Works; or, + within a display generated by the Derivative Works, if and + wherever such third-party notices normally appear. The contents + of the NOTICE file are for informational purposes only and + do not modify the License. You may add Your own attribution + notices within Derivative Works that You distribute, alongside + or as an addendum to the NOTICE text from the Work, provided + that such additional attribution notices cannot be construed + as modifying the License. + + You may add Your own copyright statement to Your modifications and + may provide additional or different license terms and conditions + for use, reproduction, or distribution of Your modifications, or + for any such Derivative Works as a whole, provided Your use, + reproduction, and distribution of the Work otherwise complies with + the conditions stated in this License. + + 5. Submission of Contributions. Unless You explicitly state otherwise, + any Contribution intentionally submitted for inclusion in the Work + by You to the Licensor shall be under the terms and conditions of + this License, without any additional terms or conditions. + Notwithstanding the above, nothing herein shall supersede or modify + the terms of any separate license agreement you may have executed + with Licensor regarding such Contributions. + + 6. Trademarks. This License does not grant permission to use the trade + names, trademarks, service marks, or product names of the Licensor, + except as required for reasonable and customary use in describing the + origin of the Work and reproducing the content of the NOTICE file. + + 7. Disclaimer of Warranty. Unless required by applicable law or + agreed to in writing, Licensor provides the Work (and each + Contributor provides its Contributions) on an "AS IS" BASIS, + WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or + implied, including, without limitation, any warranties or conditions + of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A + PARTICULAR PURPOSE. You are solely responsible for determining the + appropriateness of using or redistributing the Work and assume any + risks associated with Your exercise of permissions under this License. + + 8. Limitation of Liability. In no event and under no legal theory, + whether in tort (including negligence), contract, or otherwise, + unless required by applicable law (such as deliberate and grossly + negligent acts) or agreed to in writing, shall any Contributor be + liable to You for damages, including any direct, indirect, special, + incidental, or consequential damages of any character arising as a + result of this License or out of the use or inability to use the + Work (including but not limited to damages for loss of goodwill, + work stoppage, computer failure or malfunction, or any and all + other commercial damages or losses), even if such Contributor + has been advised of the possibility of such damages. + + 9. Accepting Warranty or Additional Liability. While redistributing + the Work or Derivative Works thereof, You may choose to offer, + and charge a fee for, acceptance of support, warranty, indemnity, + or other liability obligations and/or rights consistent with this + License. However, in accepting such obligations, You may act only + on Your own behalf and on Your sole responsibility, not on behalf + of any other Contributor, and only if You agree to indemnify, + defend, and hold each Contributor harmless for any liability + incurred by, or claims asserted against, such Contributor by reason + of your accepting any such warranty or additional liability. + + END OF TERMS AND CONDITIONS + + APPENDIX: How to apply the Apache License to your work. + + To apply the Apache License to your work, attach the following + boilerplate notice, with the fields enclosed by brackets "[]" + replaced with your own identifying information. (Don't include + the brackets!) The text should be enclosed in the appropriate + comment syntax for the file format. We also recommend that a + file or class name and description of purpose be included on the + same "printed page" as the copyright notice for easier + identification within third-party archives. + + Copyright [yyyy] [name of copyright owner] + + Licensed under the Apache License, Version 2.0 (the "License"); + you may not use this file except in compliance with the License. + You may obtain a copy of the License at + + http://www.apache.org/licenses/LICENSE-2.0 + + Unless required by applicable law or agreed to in writing, software + distributed under the License is distributed on an "AS IS" BASIS, + WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + See the License for the specific language governing permissions and + limitations under the License. diff --git a/README.en.md b/README.en.md new file mode 100644 index 00000000..724a4724 --- /dev/null +++ b/README.en.md @@ -0,0 +1,36 @@ +# okhttps + +#### Description +OkHttp3 轻量封装 ，功能力求开箱即用、设计力求优雅与纯粹，Java领域前后端处Http问题的新选择。 + +#### Software Architecture +Software architecture description + +#### Installation + +1. xxxx +2. xxxx +3. xxxx + +#### Instructions + +1. xxxx +2. xxxx +3. xxxx + +#### Contribution + +1. Fork the repository +2. Create Feat_xxx branch +3. Commit your code +4. Create Pull Request + + +#### Gitee Feature + +1. You can use Readme\_XXX.md to support different languages, such as Readme\_en.md, Readme\_zh.md +2. Gitee blog [blog.gitee.com](https://blog.gitee.com) +3. Explore open source project [https://gitee.com/explore](https://gitee.com/explore) +4. The most valuable open source project [GVP](https://gitee.com/gvp) +5. The manual of Gitee [https://gitee.com/help](https://gitee.com/help) +6. The most popular members [https://gitee.com/gitee-stars/](https://gitee.com/gitee-stars/) diff --git a/README.md b/README.md new file mode 100644 index 00000000..72dc1707 --- /dev/null +++ b/README.md @@ -0,0 +1,37 @@ +# okhttps + +#### 介绍 +OkHttp3 轻量封装 ，功能力求开箱即用、设计力求优雅与纯粹，Java领域前后端处Http问题的新选择。 + +#### 软件架构 +软件架构说明 + + +#### 安装教程 + +1. xxxx +2. xxxx +3. xxxx + +#### 使用说明 + +1. xxxx +2. xxxx +3. xxxx + +#### 参与贡献 + +1. Fork 本仓库 +2. 新建 Feat_xxx 分支 +3. 提交代码 +4. 新建 Pull Request + + +#### 码云特技 + +1. 使用 Readme\_XXX.md 来支持不同的语言，例如 Readme\_en.md, Readme\_zh.md +2. 码云官方博客 [blog.gitee.com](https://blog.gitee.com) +3. 你可以 [https://gitee.com/explore](https://gitee.com/explore) 这个地址来了解码云上的优秀开源项目 +4. [GVP](https://gitee.com/gvp) 全称是码云最有价值开源项目，是码云综合评定出的优秀开源项目 +5. 码云官方提供的使用手册 [https://gitee.com/help](https://gitee.com/help) +6. 码云封面人物是一档用来展示码云会员风采的栏目 [https://gitee.com/gitee-stars/](https://gitee.com/gitee-stars/) From 712eefa2e5723f40dae1b4cb32b55162fe84efef Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?=E5=91=A8=E6=97=AD?= Date: Tue, 31 Mar 2020 14:18:33 +0800 Subject: [PATCH 002/924] clone from httputils --- .gitee/ISSUE_TEMPLATE.zh-CN.md | 13 - .gitee/PULL_REQUEST_TEMPLATE.zh-CN.md | 15 - .gitignore | 7 + README.en.md | 36 - README.md | 789 +++++++++++++++++- pom.xml | 169 ++++ .../java/com/ejlchina/http/Configurator.java | 17 + .../java/com/ejlchina/http/DownListener.java | 19 + src/main/java/com/ejlchina/http/Download.java | 307 +++++++ src/main/java/com/ejlchina/http/HTTP.java | 70 ++ src/main/java/com/ejlchina/http/HttpCall.java | 28 + .../java/com/ejlchina/http/HttpResult.java | 282 +++++++ src/main/java/com/ejlchina/http/HttpTask.java | 710 ++++++++++++++++ .../java/com/ejlchina/http/HttpUtils.java | 105 +++ .../java/com/ejlchina/http/OnCallback.java | 11 + .../java/com/ejlchina/http/Preprocessor.java | 36 + src/main/java/com/ejlchina/http/Process.java | 31 + .../java/com/ejlchina/http/TaskListener.java | 20 + .../ejlchina/http/internal/AsyncHttpTask.java | 269 ++++++ .../ejlchina/http/internal/HttpClient.java | 445 ++++++++++ .../ejlchina/http/internal/HttpException.java | 21 + .../http/internal/ProcessInputStream.java | 53 ++ .../http/internal/ProcessRequestBody.java | 91 ++ .../http/internal/RealHttpResult.java | 134 +++ .../ejlchina/http/internal/RealProcess.java | 50 ++ .../ejlchina/http/internal/ResultBody.java | 323 +++++++ .../ejlchina/http/internal/SyncHttpTask.java | 92 ++ .../ejlchina/http/internal/TaskExecutor.java | 98 +++ src/test/java/com/ejlchina/test/HttpTest.java | 611 ++++++++++++++ src/test/java/com/ejlchina/test/User.java | 27 + 30 files changed, 4791 insertions(+), 88 deletions(-) delete mode 100644 .gitee/ISSUE_TEMPLATE.zh-CN.md delete mode 100644 .gitee/PULL_REQUEST_TEMPLATE.zh-CN.md create mode 100644 .gitignore delete mode 100644 README.en.md create mode 100644 pom.xml create mode 100644 src/main/java/com/ejlchina/http/Configurator.java create mode 100644 src/main/java/com/ejlchina/http/DownListener.java create mode 100644 src/main/java/com/ejlchina/http/Download.java create mode 100644 src/main/java/com/ejlchina/http/HTTP.java create mode 100644 src/main/java/com/ejlchina/http/HttpCall.java create mode 100644 src/main/java/com/ejlchina/http/HttpResult.java create mode 100644 src/main/java/com/ejlchina/http/HttpTask.java create mode 100644 src/main/java/com/ejlchina/http/HttpUtils.java create mode 100644 src/main/java/com/ejlchina/http/OnCallback.java create mode 100644 src/main/java/com/ejlchina/http/Preprocessor.java create mode 100644 src/main/java/com/ejlchina/http/Process.java create mode 100644 src/main/java/com/ejlchina/http/TaskListener.java create mode 100644 src/main/java/com/ejlchina/http/internal/AsyncHttpTask.java create mode 100644 src/main/java/com/ejlchina/http/internal/HttpClient.java create mode 100644 src/main/java/com/ejlchina/http/internal/HttpException.java create mode 100644 src/main/java/com/ejlchina/http/internal/ProcessInputStream.java create mode 100644 src/main/java/com/ejlchina/http/internal/ProcessRequestBody.java create mode 100644 src/main/java/com/ejlchina/http/internal/RealHttpResult.java create mode 100644 src/main/java/com/ejlchina/http/internal/RealProcess.java create mode 100644 src/main/java/com/ejlchina/http/internal/ResultBody.java create mode 100644 src/main/java/com/ejlchina/http/internal/SyncHttpTask.java create mode 100644 src/main/java/com/ejlchina/http/internal/TaskExecutor.java create mode 100644 src/test/java/com/ejlchina/test/HttpTest.java create mode 100644 src/test/java/com/ejlchina/test/User.java diff --git a/.gitee/ISSUE_TEMPLATE.zh-CN.md b/.gitee/ISSUE_TEMPLATE.zh-CN.md deleted file mode 100644 index f09d98dd..00000000 --- a/.gitee/ISSUE_TEMPLATE.zh-CN.md +++ /dev/null @@ -1,13 +0,0 @@ -### 该问题是怎么引起的？ - - - -### 重现步骤 - - - -### 报错信息 - - - - diff --git a/.gitee/PULL_REQUEST_TEMPLATE.zh-CN.md b/.gitee/PULL_REQUEST_TEMPLATE.zh-CN.md deleted file mode 100644 index 1e5b8d33..00000000 --- a/.gitee/PULL_REQUEST_TEMPLATE.zh-CN.md +++ /dev/null @@ -1,15 +0,0 @@ -### 相关的Issue - - -### 原因（目的、解决的问题等） - - -### 描述（做了什么，变更了什么） - - -### 测试用例 - - - - - diff --git a/.gitignore b/.gitignore new file mode 100644 index 00000000..d848a362 --- /dev/null +++ b/.gitignore @@ -0,0 +1,7 @@ +/target/ +/bin/ +/.settings/ +/.classpath +/.project +/.idea/** +*.iml \ No newline at end of file diff --git a/README.en.md b/README.en.md deleted file mode 100644 index 724a4724..00000000 --- a/README.en.md +++ /dev/null @@ -1,36 +0,0 @@ -# okhttps - -#### Description -OkHttp3 轻量封装 ，功能力求开箱即用、设计力求优雅与纯粹，Java领域前后端处Http问题的新选择。 - -#### Software Architecture -Software architecture description - -#### Installation - -1. xxxx -2. xxxx -3. xxxx - -#### Instructions - -1. xxxx -2. xxxx -3. xxxx - -#### Contribution - -1. Fork the repository -2. Create Feat_xxx branch -3. Commit your code -4. Create Pull Request - - -#### Gitee Feature - -1. You can use Readme\_XXX.md to support different languages, such as Readme\_en.md, Readme\_zh.md -2. Gitee blog [blog.gitee.com](https://blog.gitee.com) -3. Explore open source project [https://gitee.com/explore](https://gitee.com/explore) -4. The most valuable open source project [GVP](https://gitee.com/gvp) -5. The manual of Gitee [https://gitee.com/help](https://gitee.com/help) -6. The most popular members [https://gitee.com/gitee-stars/](https://gitee.com/gitee-stars/) diff --git a/README.md b/README.md index 72dc1707..b83e8387 100644 --- a/README.md +++ b/README.md @@ -1,37 +1,778 @@ -# okhttps +# HttpUtils -#### 介绍 -OkHttp3 轻量封装 ，功能力求开箱即用、设计力求优雅与纯粹，Java领域前后端处Http问题的新选择。 +[![Maven Central](https://maven-badges.herokuapp.com/maven-central/com.ejlchina/httputils/badge.svg)](https://maven-badges.herokuapp.com/maven-central/com.ejlchina/httputils/) +[![License](https://img.shields.io/hexpm/l/plug.svg)](https://gitee.com/ejlchina-zhxu/httputils/blob/master/LICENSE) +[![Troy.Zhou](https://img.shields.io/badge/%E4%BD%9C%E8%80%85-ejlchina-orange.svg)](https://github.com/ejlchina) -#### 软件架构 -软件架构说明 +## 介绍 +　　HttpUtils 是近期开源的对 OkHttp 轻量封装的框架，它独创的异步预处理器，特色的标签，灵活的上传下载进度监听与过程控制功能，在轻松解决很多原本另人头疼问题的同时，设计上也力求纯粹与优雅。 -#### 安装教程 + * 链式调用，一点到底 + * BaseURL、URL占位符、JSON自动封装与解析 + * 同步拦截器、异步预处理器、回调执行器 + * 文件上传下载（过程控制、进度监听） + * TCP连接池、Http2 -1. xxxx -2. xxxx -3. xxxx +### 当前文档版本[2.3.0]（近期发布到中央仓库） +#### [查阅[2.1.x]点我](https://gitee.com/ejlchina-zhxu/httputils/blob/master/README-2.1.2.md) | [查阅[2.0.x]点我](https://gitee.com/ejlchina-zhxu/httputils/blob/master/README-2.0.0.md) | [查阅[1.0.x]点我](https://gitee.com/ejlchina-zhxu/httputils/blob/1.x/README.md) -#### 使用说明 +## 目录 -1. xxxx -2. xxxx -3. xxxx ++ [安装教程](#安装教程) + + [Maven](#maven) + + [Gradle](#gradle) ++ [使用说明](#使用说明) + + [1 简单示例](#1-简单示例) + - [1.1 构建HTTP](#11-构建-http) + - [1.2 同步请求](#12-同步请求) + - [1.3 异步请求](#13-异步请求) + + [2 请求方法（GET|POST|PUT|DELETE）](#2-请求方法getpostputdelete) + + [3 解析请求结果](#3-解析请求结果) + - [3.1 回调函数](#31-回调函数) + - [3.2 HttpResult](#32-HttpResult) + - [3.3 HttpCall](#33-HttpCall) + + [4 构建HTTP任务](#4-构建HTTP任务) + + [5 使用标签](#5-使用标签) + + [6 配置 HTTP](#65-配置-http) + - [6.1 设置 BaseUrl](#61-设置-baseurl) + - [6.2 回调执行器](#62-回调执行器) + - [6.3 配置 OkHttpClient](#63-配置-okhttpclient) + - [6.4 并行预处理器](#64-并行预处理器) + - [6.5 串行预处理器](#65-串行预处理器) + - [6.6 全局回调处理](#66-全局回调处理) + - [6.7 全局下载监听](#67-全局下载监听) + + [7 使用 HttpUtils 类](#7-使用-httputils-类) + + [8 文件下载](#8-文件下载) + - [8.1 下载进度监听](#81-下载进度监听) + - [8.2 下载过程控制](#82-下载过程控制) + - [8.3 实现断点续传](#83-实现断点续传) + - [8.4 实现分块下载](#84-实现分块下载) + + [9 文件上传](#9-文件上传) + - [9.1 上传进度监听](#91-上传进度监听) + - [9.2 上传过程控制](#92-上传过程控制) + + [10 执行线程自由切换（for Android）](#10-执行线程自由切换for-android) ++ [参考文档](#参考文档) ++ [联系方式](#联系方式) -#### 参与贡献 +## 安装教程 + +### Maven + +``` + + com.ejlchina + httputils + 2.3.0 + +``` +### Gradle + +`compile 'com.ejlchina:httputils:2.3.0'` + +## 使用说明 + +### 1 简单示例 + +#### 1.1 构建 HTTP + +```java +HTTP http = HTTP.builder().build(); +``` +　　以上代码构建了一个最简单的`HTTP`实例，它拥有以下三个方法： + +* `async(String url)` 开始一个异步HTTP任务 +* `sync(String url)` 开始一个同步HTTP任务 +* `cancel(String tag)` 根据标签批量取消HTTP任务 + +　　为了使用方便，在构建的时候，我们更愿意指定一个`BaseUrl`（请参见[5.1 设置 BaseUrl](#51-设置-baseurl)）: + +```java +HTTP http = HTTP.builder() + .baseUrl("http://api.demo.com") + .build(); +``` +　　为了简化文档，下文中出现的`http`均是在构建时设置了`BaseUrl`的`HTTP`实例。 + +#### 1.2 同步请求 + +　　使用方法`sync(String url)`开始一个同步请求： + +```java +List users = http.sync("/users") // http://api.demo.com/users + .get() // GET请求 + .getBody() // 获取响应报文体 + .toList(User.class); // 得到目标数据 +``` +　　方法`sync`返回一个同步`HttpTask`，可链式使用。 + +#### 1.3 异步请求 + +　　使用方法`async(String url)`开始一个异步请求： + +```java +http.async("/users/1") // http://api.demo.com/users/1 + .setOnResponse((HttpResult result) -> { + // 得到目标数据 + User user = result.getBody().toBean(User.class); + }) + .get(); // GET请求 +``` +　　方法`async`返回一个异步`HttpTask`，可链式使用。 + +### 2 请求方法（GET|POST|PUT|DELETE） + +　　同步与异步的`HttpTask`都拥有`get`、`post`、`put`与`delete`方法。不同的是：同步`HttpTask`的这些方法返回一个`HttpResult`，而异步`HttpTask`的这些方法返回一个`HttpCall`。 + +```java +HttpResult res1 = http.sync("/users").get(); // 同步 GET +HttpResult res2 = http.sync("/users")post(); // 同步 POST +HttpResult res3 = http.sync("/users/1").put(); // 同步 PUT +HttpResult res4 = http.sync("/users/1").delete();// 同步 DELETE +HttpCall call1 = http.async("/users").get(); // 异步 GET +HttpCall call2 = http.async("/users").post(); // 异步 POST +HttpCall call3 = http.async("/users/1").put(); // 异步 PUT +HttpCall call4 = http.async("/users/1").delete();// 异步 DELETE +``` +### 3 解析请求结果 + +#### 3.1 回调函数 + +　　只有异步请求才可以设置回调函数： + +```java +http.async("/users/{id}") // http://api.demo.com/users/1 + .addPathParam("id", 1) + .setOnResponse((HttpResult result) -> { + // 响应回调 + }) + .setOnException((IOException e) -> { + // 异常回调 + }) + .setOnComplete((State state) -> { + // 完成回调，无论成功失败都会执行 + }) + .get(); +``` + +#### 3.2 HttpResult + +　　`HttpResult`是HTTP请求执行完后的结果，它是同步请求方法（ `get`、`post`、`put`、`delete`）的返回值，也是异步请求响应回调（`OnResponse`）的参数，它定义了如下方法： + +* `getState()` 得到请求执行状态枚举，它有以下取值： + * `State.CANCELED` 请求被取消 + * `State.RESPONSED` 已收到响应 + * `State.TIMEOUT` 请求超时 + * `State.NETWORK_ERROR` 网络错误 + * `State.EXCEPTION` 其它请求异常 +* `getStatus()` 得到HTTP状态码 +* `isSuccessful()` 是否响应成功，状态码在 [200..300) 之间 +* `getHeaders()` 得到HTTP响应头 +* `getHeaders(String name)` 得到HTTP响应头 +* `getHeader(String name)` 得到HTTP响应头 +* `getBody()` 得到响应报文体`Body`实例，它定义了如下方法（对同一个`Body`实例，以下的`toXXX()`类方法只能使用一个且仅能调用一次）： + * `toBytes()` 返回字节数组 + * `toByteStream()` 返回字节输入流 + * `toCharStream()` 返回字符输入流 + * `toString()` 返回字符串 + * `toJsonObject()` 返回Json对象 + * `toJsonArray()` 返回Json数组 + * `toBean(Class type)` 返回根据type自动json解析后的JavaBean + * `toList(Class type)` 返回根据type自动json解析后的JavaBean列表 + * `toFile(String filePath)` 下载到指定路径 + * `toFile(File file)` 下载到指定文件 + * `toFolder(String dirPath)` 下载到指定目录 + * `toFolder(File dir)` 下载到指定目录 + * `getContentType()` 返回报文体的媒体类型 + * `getContentLength()` 返回报文体的字节长度 + * `cache()` 缓存报文体，开启缓存后可重复使用`toXXX()`类方法 + * `close()` 关闭报文体，未对报文体做任何消费时使用，比如只读取报文头 +* `getError()` 执行中发生的异常，自动捕获执行请求是发生的 网络超时、网络错误 和 其它请求异常 +* `close()` 关闭报文，未对报文体做任何消费时使用，比如只读取长度 + +　　示例，请求结果自动转Bean和List： + +```java +// 自动转Bean +Order order = http.sync("/orders/1") + .get().getBody().toBean(Order.class); + +// 自动转List +List orders = http.sync("/orders") + .get().getBody().toList(Order.class); +``` + +　　示例，下载文件到指定目录： + +```java +String path = "D:/reports/2020-03-01.xlsx"; // 文件保存目录 + +// 同步下载 +http.sync("/reports/2020-03-01.xlsx") + .get().getBody().toFile(path); + +// 异步下载 +http.async("/reports/2020-03-01.xlsx") + .setOnResponse((HttpResult result) -> { + result.getBody().toFile(path); + }) + .get(); +``` + +#### 3.3 HttpCall + +　　`HttpCall`对象是异步请求方法（`get`、`post`、`put`、`delete`）的返回值，与`java`的`Future`接口很像，它有如下方法： + +* `cancel()` 取消本次请求，返回取消结果 +* `isCanceled()` 返回请求是否被取消 +* `isDone()` 返回是否执行完成，包含取消和失败 +* `getResult()` 返回执行结果`HttpResult`对象，若请求未执行完，则挂起当前线程直到执行完成再返回 + +　　取消一个异步请求示例： + +```java +HttpCall call = http.async("/users/1").get(); + +System.out.println(call.isCanceled()); // false + +boolean success = call.cancel(); // 取消请求 + +System.out.println(success); // true +System.out.println(call.isCanceled()); // true +``` + +### 4 构建HTTP任务 + +　　`HTTP`对象的`sync`与`async`方法返回一个`HttpTask`对象，该对象提供了可链式调用的`addXXX`与`setXXX`系列方法用于构建任务本身。 + +* `addHeader(String name, String value)` 添加请求头 +* `addHeader(Map headers)` 添加请求头 + +* `addPathParam(String name, Object value)` 添加路径参数：替换URL里的{name}占位符 +* `addPathParam(Map params)` 添加路径参数：替换URL里的{name}占位符 + +* `addUrlParam(String name, Object value)` 添加URL参数：拼接在URL的?之后（查询参数） +* `addUrlParam(Map params)` 添加URL参数：拼接在URL的?之后（查询参数） + +* `addBodyParam(String name, Object value)` 添加Body参数：以表单key=value&的形式放在报文体内（表单参数） +* `addBodyParam(Map params)` 添加Body参数：以表单key=value&的形式放在报文体内（表单参数） + +* `addJsonParam(String name, Object value)` 添加Json参数：请求体为Json（支持多层结构） +* `addJsonParam(Map params)` 添加Json参数：请求体为Json（支持多层结构） + +* `setRequestJson(Object json)` 设置请求体的Json字符串 或待转换为 Json的 JavaBean +* `setRequestJson(Object bean, String dateFormat)` 设置请求体的Json字符串 或待转换为 Json的 JavaBean + +* `addFileParam(String name, String filePath)` 上传文件 +* `addFileParam(String name, File file)` 上传文件 +* `addFileParam(String name, String type, InputStream inputStream)` 上传文件 +* `addFileParam(String name, String type, String fileName, InputStream input)` 上传文件 +* `addFileParam(String name, String type, byte[] content)` 上传文件 +* `addFileParam(String name, String type, String fileName, byte[] content)` 上传文件 + +* `setTag(String tag)` 为HTTP任务添加标签 +* `setRange(long rangeStart)` 设置Range头信息，用于断点续传 +* `setRange(long rangeStart, long rangeEnd)` 设置Range头信息，用于分块下载 +* `setRange(long rangeStart, long rangeEnd)` 设置Range头信息，用于分块下载 + +* `bind(Object object)` 绑定一个对象，可用于实现Android里的生命周期绑定 + +### 5 使用标签 + +　　有时候我们想对HTTP任务加以分类，这时候可以使用标签功能： + +```java +http.async("/users") //（1） + .setTag("A").get(); + +http.async("/users") //（2） + .setTag("A.B").get(); + +http.async("/users") //（3） + .setTag("B").get(); + +http.async("/users") //（4） + .setTag("B.C").get(); + +http.async("/users") //（5） + .setTag("C").get(); +``` +　　当使用标签后，就可以按标签批量的对HTTP任务进行取消： + +```java +int count = http.cancel("B"); //（2）（3）（4）被取消（取消标签包含"B"的任务） +System.out.println(count); // 输出 3 +``` +　　同样的，只有异步HTTP任务才可以被取消。标签除了可以用来取消任务，在预处理器中它也可以发挥作用，请参见[并行预处理器](#54-并行预处理器)与[串行预处理器](#55-串行预处理器)。 + +### 6 配置 HTTP + +#### 6.1 设置 BaseUrl + +```java +HTTP http = HTTP.builder() + .baseUrl("http://api.demo.com") // 设置 BaseUrl + .build(); +``` +　　该配置全局生效，在配置了`BaseUrl`之后，具体的请求便可以省略`BaseUrl`部分，使得代码更加简洁，例如： + +```java +http.sync("/users").get() // http://api.demo.com/users + +http.sync("/auth/signin") // http://api.demo.com/auth/signin + .addBodyParam("username", "Jackson") + .addBodyParam("password", "xxxxxx") + .post() // POST请求 +``` +　　在配置了`BaseUrl`之后，如有特殊请求任务，仍然可以使用全路径的方式，一点都不妨碍： + +```java +http.sync("https://www.baidu.com").get() +``` + +#### 6.2 回调执行器 + +　　如何想改变执行回调函数的线程时，可以配置回调执行器。例如在Android里，让所有的回调函数都在UI线程执行，则可以在构建`HTTP`时配置如下： + +```java +HTTP http = HTTP.builder() + .callbackExecutor((Runnable run) -> { + runOnUiThread(run); // 在UI线程执行 + }) + .build(); +``` +　　该配置影响所有回调。 + +#### 6.3 配置 OkHttpClient + +　　与其他封装 OkHttp 的框架不同，HttpUtils 并不会遮蔽 OkHttp 本身就很好用的功能，如下： + +```java +HTTP http = HTTP.builder() + .config((Builder builder) -> { + // 配置连接池 最小10个连接（不配置默认为 5） + builder.connectionPool(new ConnectionPool(10, 5, TimeUnit.MINUTES)); + // 配置连接超时时间（默认10秒） + builder.connectTimeout(20, TimeUnit.SECONDS); + // 配置拦截器 + builder.addInterceptor((Chain chain) -> { + Request request = chain.request(); + // 必须同步返回，拦截器内无法执行异步操作 + return chain.proceed(request); + }); + // 其它配置: SSL、缓存、代理、事件监听... + }) + .build(); +``` + +#### 6.4 并行预处理器 + +　　预处理器（`Preprocessor`）可以让我们在请求发出之前对请求本身做一些改变，但与`OkHttp`的拦截器（`Interceptor`）不同：预处理器可以让我们**异步**处理这些问题。 + +　　例如，当我们想为请求任务自动添加`Token`头信息，而`Token`只能通过异步方法`requestToken`获取时，这时使用`Interceptor`就很难处理了，但可以使用预处理器轻松解决： + +```java +HTTP http = HTTP.builder() + .addPreprocessor((PreChain chain) -> { + HttpTask task = chain.getTask();// 获得当前的HTTP任务 + if (!task.isTagged("Auth")) { // 根据标签判断该任务是否需要Token + return; + } + requestToken((String token) -> { // 异步获取 Token + task.addHeader("Token", token);// 为任务添加头信息 + chain.proceed(); // 继续当前的任务 + }); + }) + .build(); +``` +　　和`Interceptor`一样，`Preprocessor`也可以添加多个。 + +#### 6.5 串行预处理器 + +　　普通预处理器都是可并行处理的，然而有时我们希望某个预处理器同时只处理一个任务。比如 当`Token`过期时我们需要去刷新获取新`Token`，而刷新`Token`这个操作只能有一个任务去执行，因为如果`n`个任务同时执行的话，那么必有`n-1`个任务刚刷新得到的`Token`可能就立马失效了，而这是我们所不希望的。 + +　　为了解决这个问题，HttpUtils 提供了串行预处理器，它可以让 HTTP 任务排好队，一个一个地进入预处理器： + +```java +HTTP http = HTTP.builder() + .addSerialPreprocessor((PreChain chain) -> { + HttpTask task = chain.getTask(); + if (!task.isTagged("Auth")) { + return; + } + // 检查过期，若需要则刷新Token + requestTokenAndRefreshIfExpired((String token) -> { + task.addHeader("Token", token); + chain.proceed(); // 调用此方法前，不会有其它任务进入该处理器 + }); + }) + .build(); +``` +　　串行预处理器实现了让HTTP任务排队串行处理的功能，但值得一提的是：它并没有因此而阻塞任何线程！ + +#### 6.6 全局回调处理 + +```java +HTTP http = HTTP.builder() + .responseListener((HttpTask task, HttpResult result) -> { + // 所有请求响应后都会走这里 + + return true; // 返回 true 表示继续执行 task 的 OnResponse 回调，false 表示不再执行 + }) + .completeListener((HttpTask task, State state) -> { + // 所有请求执行完都会走这里 + + return true; // 返回 true 表示继续执行 task 的 OnComplete 回调，false 表示不再执行 + }) + .exceptionListener((HttpTask task, IOException error) -> { + // 所有请求发生异常都会走这里 + + return true; // 返回 true 表示继续执行 task 的 OnException 回调，false 表示不再执行 + }) + .build(); +``` + +#### 6.7 全局下载监听 + +```java +HTTP http = HTTP.builder() + .downloadListener((HttpTask task, Download download) -> { + // 所有下载在开始之前都会先走这里 + Ctrl ctrl = download.getCtrl(); // 下载控制器 + + }) + .build(); +``` + +### 7 使用 HttpUtils 类 + +　　类`HttpUtils`本是 1.x 版本里的最重要的核心类，由于在 2.x 版本里抽象出了`HTTP`接口，使得它的重要性已不如往昔。但合理的使用它，仍然可以带来不少便利，特别是在没有IOC容器的环境里，比如在Android开发和一些工具项目的开发中。 + +　　类`HttpUtils`共定义了四个静态方法： + +* `async(String url)` 开始一个异步请求 （内容通过一个`HTTP`单例实现） +* `sync(String url)` 开始一个同步请求 （内容通过一个`HTTP`单例实现） +* `cancel(String tag)` 按标签取消请求（内容通过一个`HTTP`单例实现） +* `of(HTTP http)` 配置`HttpUtils`持有的`HTTP`实例（不调用此方法前默认使用一个没有没有经过任何配置的`HTTP`懒实例） + +　　也就是说，能使用`http`实例的地方，都可以使用`HttpUtils`类，例如： + +```java +// 在配置HTTP实例之前，只能使用全路径方式 +List roles = HttpUtils.sync("http://api.demo.com/roles") + .get().getBody().toList(Role.class); + +// 配置HTTP实例,全局生效 +HttpUtils.of(HTTP.builder() + .baseUrl("http://api.demo.com") + .build()); + +// 内部使用新的HTTP实例 +List users = HttpUtils.sync("/users") + .get().getBody().toList(User.class); +``` + +### 8 文件下载 + +　　HttpUtils 并没有把文件的下载排除在常规的请求之外，同一套API，它优雅的设计使得下载与常规请求融合的毫无违和感，一个最简单的示例： + +```java +http.sync("/download/test.zip") + .get() // 使用 GET 方法（其它方法也可以，看服务器支持） + .getBody() // 得到报文体 + .toFile("D:/download/test.zip") // 指定下载的目录，文件名将根据下载信息自动生成 + .start(); // 启动下载 +``` +　　或使用异步连接方式： + +```java +http.async("/download/test.zip") + .setOnResponse((HttpResult result) -> { + result.getBody().toFile("D:/download/test.zip").start(); + }) + .get(); +``` +　　这里要说明一下：`sync`与`async`的区别在于连接服务器并得到响应这个过程的同步与异步（这个过程的耗时在大文件下载中占比极小），而`start`方法启动的下载过程则都是异步的。 + +#### 8.1 下载进度监听 + +　　就直接上代码啦，诸君一看便懂： + +```java +http.sync("/download/test.zip") + .get() + .getBody() + .setStepBytes(1024) // 设置每接收 1024 个字节执行一次进度回调（不设置默认为 8192） + // .setStepRate(0.01) // 设置每接收 1% 执行一次进度回调（不设置以 StepBytes 为准） + .setOnProcess((Process process) -> { // 下载进度回调 + long doneBytes = process.getDoneBytes(); // 已下载字节数 + long totalBytes = process.getTotalBytes(); // 总共的字节数 + double rate = process.getRate(); // 已下载的比例 + boolean isDone = process.isDone(); // 是否下载完成 + }) + .toFolder("D:/download/") // 指定下载的目录，文件名将根据下载信息自动生成 + // .toFile("D:/download/test.zip") // 指定下载的路径，若文件已存在则覆盖 + .setOnSuccess((File file) -> { // 下载成功回调 + + }) + .start(); +``` +　　值得一提的是：由于 HttpUtils 并没有把下载做的很特别，这里设置的进度回调不只对下载文件起用作，即使对响应JSON的常规请求，只要设置了进度回调，它也会告诉你报文接收的进度（提前是服务器响应的报文有`Content-Length`头），例如： + +```java +List users = http.sync("/users") + .get() + .getBody() + .setStepBytes(2) + .setOnProcess((Process process) -> { + System.out.println(process.getRate()); + }) + .toList(User.class); +``` + +#### 8.2 下载过程控制 + +　　过于简单：还是直接上代码： + +```java +Ctrl ctrl = http.sync("/download/test.zip") + .get() + .getBody() + .setOnProcess((Process process) -> { + System.out.println(process.getRate()); + }) + .toFolder("D:/download/") + .start(); // 该方法返回一个下载过程控制器 + +ctrl.status(); // 下载状态 +ctrl.pause(); // 暂停下载 +ctrl.resume(); // 恢复下载 +ctrl.cancel(); // 取消下载（同时会删除文件，不可恢复） +``` +　　无论是同步还是异步发起的下载请求，都可以做以上的控制： + +```java +http.async("/download/test.zip") + .setOnResponse((HttpResult result) -> { + // 拿到下载控制器 + Ctrl ctrl = result.getBody().toFolder("D:/download/").start(); + }) + .get(); +``` + +#### 8.3 实现断点续传 + +　　HttpUtils 对断点续传并没有再做更高层次的封装，因为这是app该去做的事情，它在设计上使各种网络问题的处理变简单的同时力求纯粹。下面的例子可以看到，HttpUtils 通过一个失败回调拿到**断点**，便将复杂的问题变得简单： + +```java +http.sync("/download/test.zip") + .get() + .getBody() + .toFolder("D:/download/") + .setOnFailure((Failure failure) -> { // 下载失败回调，以便接收诸如网络错误等失败信息 + IOException e = failure.getException(); // 具体的异常信息 + long doneBytes = failure.getDoneBytes(); // 已下载的字节数（断点），需要保存，用于断点续传 + File file = failure.getFile(); // 下载生成的文件，需要保存 ，用于断点续传（只保存路径也可以） + }) + .start(); +``` +　　下面代码实现续传： + +```java +long doneBytes = ... // 拿到保存的断点 +File file = ... // 待续传的文件 + +http.sync("/download/test.zip") + .setRange(doneBytes) // 设置断点（已下载的字节数） + .get() + .getBody() + .toFile(file) // 下载到同一个文件里 + .setAppended() // 开启文件追加模式 + .setOnSuccess((File file) -> { + + }) + .setOnFailure((Failure failure) -> { + + }) + .start(); +``` + +#### 8.4 实现分块下载 + +　　当文件很大时，有时候我们会考虑分块下载，与断点续传的思路是一样的，示例代码： + +```java +static String url = "http://api.demo.com/download/test.zip" + +public static void main(String[] args) { + long totalSize = HttpUtils.sync(url).get().getBody() + .close() // 因为这次请求只是为了获得文件大小，不消费报文体，所以直接关闭 + .getContentLength(); // 获得待下载文件的大小（由于未消费报文体，所以该请求不会消耗下载报文体的时间和网络流量） + download(totalSize, 0); // 从第 0 块开始下载 + sleep(50000); // 等待下载完成（不然本例的主线程就结束啦） +} + +static void download(long totalSize, int index) { + long size = 3 * 1024 * 1024; // 每块下载 3M + long start = index * size; + long end = Math.min(start + size, totalSize); + HttpUtils.sync(url) + .setRange(start, end) // 设置本次下载的范围 + .get().getBody() + .toFile("D:/download/test.zip") // 下载到同一个文件里 + .setAppended() // 开启文件追加模式 + .setOnSuccess((File file) -> { + if (end < totalSize) { // 若未下载完，则继续下载下一块 + download(totalSize, index + 1); + } else { + System.out.println("下载完成"); + } + }) + .start(); +} +``` + +### 9 文件上传 + +　　一个简单文件上传的示例： + +```java +http.sync("/upload") + .addFileParam("test", "D:/download/test.zip") + .post() // 上传发法一般使用 POST 或 PUT，看服务器支持 +``` +　　异步上传也是完全一样： + +```java +http.async("/upload") + .addFileParam("test", "D:/download/test.zip") + .post() +``` + +#### 9.1 上传进度监听 + +　　HttpUtils 的上传进度监听，监听的是所有请求报文体的发送进度，示例代码： + +```java +http.sync("/upload") + .addBodyParam("name", "Jack") + .addBodyParam("age", 20) + .addFileParam("avatar", "D:/image/avatar.jpg") + .setStepBytes(1024) // 设置每发送 1024 个字节执行一次进度回调（不设置默认为 8192） + // .setStepRate(0.01) // 设置每发送 1% 执行一次进度回调（不设置以 StepBytes 为准） + .setOnProcess((Process process) -> { // 上传进度回调 + long doneBytes = process.getDoneBytes(); // 已发送字节数 + long totalBytes = process.getTotalBytes(); // 总共的字节数 + double rate = process.getRate(); // 已发送的比例 + boolean isDone = process.isDone(); // 是否发送完成 + }) + .post() +``` +　　咦！怎么感觉和下载的进度回调的一样？没错！HttpUtils 还是使用同一套API处理上传和下载的进度回调，区别只在于上传是在`get/post`方法之前使用这些API，下载是在`getBody`方法之后使用。很好理解：`get/post`之前是准备发送请求时段，有上传的含义，而`getBody`之后，已是报文响应的时段，当然是下载。 + +#### 9.2 上传过程控制 + +　　上传文件的过程控制就很简单，和常规请求一样，只有异步发起的上传可以取消： + +```java +HttpCall call = http.async("/upload") + .addFileParam("test", "D:/download/test.zip") + .setOnProcess((Process process) -> { + System.out.println(process.getRate()); + }) + .post() + +call.cancel(); // 取消上传 +``` +　　上传就没有暂停和继续这个功能啦，应该没人有这个需求吧? + +### 10 执行线程自由切换（for Android） + +　　在 Android 开发中，经常会把某些代码放到特点的线程去执行，比如网络请求响应后的页面更新在主线程（UI线程）执行，而保存文件则在IO线程操作。HttpUtils 为这类问题提供了良好的方案。 + +　　在 **默认** 情况下，**所有回调** 函数都会 **在 IO 线程** 执行。为什么会设计如此呢？这是因为 HttpUtils 只是纯粹的 Java 领域 Http工具包，本身对 Android 不会有任何依赖，因此也不知 Android 的 UI 线程为何物。这么设计也让它在 Android 之外有更多的可能性。 + +　　但是在 Android 里使用 HttpUtils 的话，UI线程的问题能否优雅的解决呢？当然可以！简单粗暴的方法就是配置一个 回调执行器： + + ```java +HTTP http = HTTP.builder() + .callbackExecutor((Runnable run) -> { + // 实际编码中可以吧 Handler 提出来，不需要每次执行回调都重新创建 + new Handler(Looper.getMainLooper()).post(run); // 在主线程执行 + }) + .build(); +``` +　　上述代码便实现了让 **所有** 的 **回调函数** 都在 **主线程** 执行的目的，如： + +```java +http.async("/users") + .addBodyParam("name", "Jack") + .setOnProcess((Process process) -> { + // 在主线程执行 + }) + .setOnResponse((HttpResult result) -> { + // 在主线程执行 + }) + .setOnException((Exception e) -> { + // 在主线程执行 + }) + .setOnComplete((State state) -> { + // 在主线程执行 + }) + .post(); +``` +　　但是，如果同时还想让某些回调放在IO线程，实现 **自由切换**，怎么办呢?HttpUtils 给出了非常灵活的方法，如下： + +```java +http.async("/users") + .addBodyParam("name", "Jack") + .setOnProcess((Process process) -> { + // 在主线程执行 + }) + .nextOnIO() // 指定下一个回调在 IO 线程执行 + .setOnResponse((HttpResult result) -> { + // 在 IO 线程执行 + }) + .setOnException((Exception e) -> { + // 在主线程执行（没有指明 nextOnIO 则在回调执行器里执行） + }) + .nextOnIO() // 指定下一个回调在 IO 线程执行 + .setOnComplete((State state) -> { + // 在 IO 线程执行 + }) + .post(); +``` +　　无论是哪一个回调，都可以使用`nextOnIO()`方法自由切换。同样，对于文件下载也是一样： + +```java +http.sync("/download/test.zip") + .get() + .getBody() + .setOnProcess((Process process) -> { + // 在主线程执行 + }) + .toFolder("D:/download/") + .nextOnIO() // 指定下一个回调在 IO 线程执行 + .setOnSuccess((File file) -> { + // 在 IO 线程执行 + }) + .setOnFailure((Failure failure) -> { + // 在主线程执行 + }) + .start(); +``` + +## 参考文档 + + + +## 联系方式 + +* 邮箱：zhou.xu@ejlchina.com + +## 参与贡献 1. Fork 本仓库 2. 新建 Feat_xxx 分支 3. 提交代码 4. 新建 Pull Request - - -#### 码云特技 - -1. 使用 Readme\_XXX.md 来支持不同的语言，例如 Readme\_en.md, Readme\_zh.md -2. 码云官方博客 [blog.gitee.com](https://blog.gitee.com) -3. 你可以 [https://gitee.com/explore](https://gitee.com/explore) 这个地址来了解码云上的优秀开源项目 -4. [GVP](https://gitee.com/gvp) 全称是码云最有价值开源项目，是码云综合评定出的优秀开源项目 -5. 码云官方提供的使用手册 [https://gitee.com/help](https://gitee.com/help) -6. 码云封面人物是一档用来展示码云会员风采的栏目 [https://gitee.com/gitee-stars/](https://gitee.com/gitee-stars/) diff --git a/pom.xml b/pom.xml new file mode 100644 index 00000000..f434d4c5 --- /dev/null +++ b/pom.xml @@ -0,0 +1,169 @@ + + 4.0.0 + + com.ejlchina + httputils + 2.3.0 + HttpUtils + + + 1.8 + UTF-8 + https://oss.sonatype.org/content/repositories/snapshots/ + + + + + The Apache License, Version 2.0 + http://www.apache.org/licenses/LICENSE-2.0.txt + + + + + + Troy + zhou.xu@ejlchina.com + ejlchina + http://www.ejlchina.com + + + + + scm:git://gitee.com/ejlchina-zhxu/httputils.git + scm:http://gitee.com/ejlchina-zhxu/httputils + https://gitee.com/ejlchina-zhxu/httputils + v2.2.0 + + + + + + junit + junit + 4.12 + test + + + + com.alibaba + fastjson + 1.2.67 + + + + com.squareup.okhttp3 + okhttp + 3.14.7 + + + + + + + sonatype-nexus-snapshots + Sonatype Nexus Snapshots + https://oss.sonatype.org/content/repositories/snapshots + + false + + + true + + + + + + + sonatype-nexus-snapshots + Sonatype Nexus Snapshots + ${sonatypeOssDistMgmtSnapshotsUrl} + + + sonatype-nexus-staging + Nexus Release Repository + https://oss.sonatype.org/service/local/staging/deploy/maven2/ + + + + + httputils + + + + org.apache.maven.plugins + maven-release-plugin + 2.1 + + forked-path + false + -Psonatype-oss-release + + + + + org.apache.maven.plugins + maven-compiler-plugin + + ${java-version} + ${java-version} + ${project.build.sourceEncoding} + true + + + + + org.apache.maven.plugins + maven-source-plugin + 2.1.2 + + + attach-sources + + jar-no-fork + + + + + + + org.apache.maven.plugins + maven-javadoc-plugin + 2.7 + + + attach-javadocs + + jar + + + + + + + org.apache.maven.plugins + maven-gpg-plugin + 1.1 + + + sign-artifacts + verify + + sign + + + + + + + + + https://gitee.com/ejlchina-zhxu/httputils + Http工具包，封装 OkHttp，链式用法、支持异步同步、响应JSON自动解析，回调线程切换、配置灵活、支持URL占位符、支持BaseUrl、外部依赖少、适用 JavaWeb 和 Android，教程全面、简单易用 + + 江苏一键联信息科技有限公司 + http://www.ejlchina.com/ + + + https://gitee.com/ejlchina-zhxu/httputils/issues + + \ No newline at end of file diff --git a/src/main/java/com/ejlchina/http/Configurator.java b/src/main/java/com/ejlchina/http/Configurator.java new file mode 100644 index 00000000..c76a5a85 --- /dev/null +++ b/src/main/java/com/ejlchina/http/Configurator.java @@ -0,0 +1,17 @@ +package com.ejlchina.http; + +import okhttp3.OkHttpClient.Builder; + +/** + * Http 配置器 + * + */ +public interface Configurator { + + /** + * 使用 builder 配置 HttpClient + * @param builder OkHttpClient 构建器 + */ + void config(Builder builder); + +} diff --git a/src/main/java/com/ejlchina/http/DownListener.java b/src/main/java/com/ejlchina/http/DownListener.java new file mode 100644 index 00000000..7802013a --- /dev/null +++ b/src/main/java/com/ejlchina/http/DownListener.java @@ -0,0 +1,19 @@ +package com.ejlchina.http; + +/** + * 下载监听接口 + * @author 15735 + * @since 2.3.0 + */ +public interface DownListener { + + + /** + * 全局下载监听 + * @param task 所属的 HttpTask + * @param download 下载事件 + */ + void listen(HttpTask task, Download download); + + +} diff --git a/src/main/java/com/ejlchina/http/Download.java b/src/main/java/com/ejlchina/http/Download.java new file mode 100644 index 00000000..c7ef89bd --- /dev/null +++ b/src/main/java/com/ejlchina/http/Download.java @@ -0,0 +1,307 @@ +package com.ejlchina.http; + +import java.io.File; +import java.io.FileNotFoundException; +import java.io.IOException; +import java.io.InputStream; +import java.io.RandomAccessFile; + +import com.ejlchina.http.internal.HttpException; +import com.ejlchina.http.internal.TaskExecutor; + +import okhttp3.internal.Util; + +/** + * 文件下载 + * @author Troy.Zhou + * @since 2.2.0 + */ +public class Download { + + private File file; + private InputStream input; + private OnCallback onSuccess; + private OnCallback onFailure; + private TaskExecutor taskExecutor; + private long doneBytes; + private int buffSize = 0; + private long seekBytes = 0; + private boolean appended; + private volatile int status; + private Object lock = new Object(); + + protected boolean nextOnIO = false; + private boolean sOnIO; + private boolean fOnIO; + + private Ctrl ctrl; + + public Download(File file, InputStream input, TaskExecutor taskExecutor, long skipBytes) { + this.file = file; + this.input = input; + this.taskExecutor = taskExecutor; + this.seekBytes = skipBytes; + this.ctrl = new Ctrl(); + } + + /** + * 设置缓冲区大小，默认 2K（2048） + * @param buffSize 缓冲区大小（单位：字节） + * @return Download + */ + public Download setBuffSize(int buffSize) { + if (buffSize > 0) { + this.buffSize = buffSize; + } + return this; + } + + /** + * 设置文件追加模式 + * 用预断点续传和分块下载 + * @return Download + */ + public Download setAppended() { + this.appended = true; + return this; + } + + /** + * 设置文件指针，从文件的 seekBytes 位置追加内容 + * @param seekBytes 跨越的字节数 + * @return Download + */ + public Download setFilePointer(long seekBytes) { + this.seekBytes = seekBytes; + return this; + } + + /** + * 在IO线程执行 + * @return Download + */ + public Download nextOnIO() { + nextOnIO = true; + return this; + } + + /** + * 设置下载成功回调 + * @param onSuccess 成功回调函数 + * @return Download + */ + public Download setOnSuccess(OnCallback onSuccess) { + this.onSuccess = onSuccess; + sOnIO = nextOnIO; + nextOnIO = false; + return this; + } + + /** + * 设置下载失败回调 + * @param onFailure 失败回调函数 + * @return Download + */ + public Download setOnFailure(OnCallback onFailure) { + this.onFailure = onFailure; + fOnIO = nextOnIO; + nextOnIO = false; + return this; + } + + /** + * 开始下载 + * @return 下载控制器 + */ + public Ctrl start() { + if (buffSize == 0) { + buffSize = Process.DEFAULT_STEP_BYTES; + } + RandomAccessFile raFile = randomAccessFile(); + status = Ctrl.STATUS__DOWNLOADING; + taskExecutor.execute(() -> { + doDownload(raFile); + }, true); + return ctrl; + } + + /** + * 获取下载控制器 + * @return Ctrl + */ + public Ctrl getCtrl() { + return ctrl; + } + + public class Ctrl { + + /** + * 已取消 + */ + public static final int STATUS__CANCELED = -1; + + /** + * 下载中 + */ + public static final int STATUS__DOWNLOADING = 1; + + /** + * 已暂停 + */ + public static final int STATUS__PAUSED = 2; + + /** + * 已完成 + */ + public static final int STATUS__DONE = 3; + + /** + * 错误 + */ + public static final int STATUS__ERROR = 4; + + /** + * @see #STATUS__CANCELED + * @see #STATUS__DOWNLOADING + * @see #STATUS__PAUSED + * @see #STATUS__DONE + * @return 下载状态 + */ + public int status() { + return status; + } + + /** + * 暂停下载任务 + */ + public void pause() { + synchronized (lock) { + if (status == STATUS__DOWNLOADING) { + status = STATUS__PAUSED; + } + } + } + + /** + * 继续下载任务 + */ + public void resume() { + synchronized (lock) { + if (status == STATUS__PAUSED) { + status = STATUS__DOWNLOADING; + } + } + } + + /** + * 取消下载任务 + */ + public void cancel() { + synchronized (lock) { + if (status == STATUS__PAUSED || status == STATUS__DOWNLOADING) { + status = STATUS__CANCELED; + } + } + } + + } + + public class Failure { + + private IOException exception; + + Failure(IOException exception) { + this.exception = exception; + } + + /** + * @return 下载文件 + */ + public File getFile() { + return file; + } + + /** + * @return 已下载字节数 + */ + public long getDoneBytes() { + return doneBytes; + } + + /** + * @return 异常信息 + */ + public IOException getException() { + return exception; + } + + } + + private RandomAccessFile randomAccessFile() { + try { + return new RandomAccessFile(file, "rw"); + } catch (FileNotFoundException e) { + status = Ctrl.STATUS__ERROR; + Util.closeQuietly(input); + throw new HttpException("无法获取文件[" + file.getAbsolutePath() + "]的输入流", e); + } + } + + private void doDownload(RandomAccessFile raFile) { + try { + if (appended && seekBytes > 0) { + long length = raFile.length(); + if (seekBytes <= length) { + raFile.seek(seekBytes); + doneBytes = seekBytes; + } else { + raFile.seek(length); + doneBytes = length; + } + } + while (status != Ctrl.STATUS__CANCELED && status != Ctrl.STATUS__DONE) { + if (status == Ctrl.STATUS__DOWNLOADING) { + byte[] buff = new byte[buffSize]; + int len = -1; + while ((len = input.read(buff)) != -1) { + raFile.write(buff, 0, len); + doneBytes += len; + if (status == Ctrl.STATUS__CANCELED + || status == Ctrl.STATUS__PAUSED) { + break; + } + } + if (len == -1) { + synchronized (lock) { + status = Ctrl.STATUS__DONE; + } + } + } + } + } catch (IOException e) { + synchronized (lock) { + status = Ctrl.STATUS__ERROR; + } + if (onFailure != null) { + taskExecutor.execute(() -> { + onFailure.on(new Failure(e)); + }, fOnIO); + } else { + throw new HttpException("流传输失败", e); + } + } finally { + Util.closeQuietly(raFile); + Util.closeQuietly(input); + if (status == Ctrl.STATUS__CANCELED) { + file.delete(); + } + } + if (status == Ctrl.STATUS__DONE + && onSuccess != null) { + taskExecutor.execute(() -> { + onSuccess.on(file); + }, sOnIO); + } + } + +} diff --git a/src/main/java/com/ejlchina/http/HTTP.java b/src/main/java/com/ejlchina/http/HTTP.java new file mode 100644 index 00000000..b8fc7c4b --- /dev/null +++ b/src/main/java/com/ejlchina/http/HTTP.java @@ -0,0 +1,70 @@ +package com.ejlchina.http; + +import com.ejlchina.http.internal.AsyncHttpTask; +import com.ejlchina.http.internal.SyncHttpTask; +import com.ejlchina.http.internal.TaskExecutor; +import com.ejlchina.http.internal.HttpClient.Builder; + +import okhttp3.Call; +import okhttp3.Request; +import okhttp3.WebSocket; +import okhttp3.WebSocketListener; + +/** + * HTTP 客户端接口 + * @author 15735 + * + */ +public interface HTTP { + + /** + * 异步请求 + * @param url 请求地址 + * @return 异步HTTP任务 + */ + AsyncHttpTask async(String url); + + /** + * 同步请求 + * @param url 请求地址 + * @return 同步HTTP任务 + */ + SyncHttpTask sync(String url); + + /** + * 根据标签取消HTTP任务，只要任务的标签包含指定的Tag就会被取消 + * @param tag 标签 + * @return 被取消的任务数量 + */ + int cancel(String tag); + + /** + * OkHttp 原生请求 （该请求不经过 预处理器） + * @param request 请求 + * @return Call + */ + Call request(Request request); + + /** + * Websocket（该请求不经过 预处理器） + * @param request 请求 + * @param listener 监听器 + * @return + */ + WebSocket webSocket(Request request, WebSocketListener listener); + + /** + * 获取任务执行器 + * @return TaskExecutor + */ + TaskExecutor getExecutor(); + + /** + * HTTP 构建器 + * @return HTTP 构建器 + */ + static Builder builder() { + return new Builder(); + } + +} diff --git a/src/main/java/com/ejlchina/http/HttpCall.java b/src/main/java/com/ejlchina/http/HttpCall.java new file mode 100644 index 00000000..940d5749 --- /dev/null +++ b/src/main/java/com/ejlchina/http/HttpCall.java @@ -0,0 +1,28 @@ +package com.ejlchina.http; + +public interface HttpCall { + + /** + * 取消 Http 请求 + * @return 是否取消成功 + */ + boolean cancel(); + + /** + * @return 请求是否被取消 + */ + boolean isCanceled(); + + /** + * @return 请求是否执行完成，包含取消和失败 + */ + boolean isDone(); + + /** + * Waits if necessary for the computation to complete, and then + * retrieves its result + * @return 请求执行结果，若请求未执行完，则阻塞当前线程直到请求执行完成 + */ + HttpResult getResult(); + +} diff --git a/src/main/java/com/ejlchina/http/HttpResult.java b/src/main/java/com/ejlchina/http/HttpResult.java new file mode 100644 index 00000000..f1d67b8a --- /dev/null +++ b/src/main/java/com/ejlchina/http/HttpResult.java @@ -0,0 +1,282 @@ +package com.ejlchina.http; + +import java.io.File; +import java.io.InputStream; +import java.io.Reader; +import java.util.List; + +import com.alibaba.fastjson.JSONArray; +import com.alibaba.fastjson.JSONObject; +import com.ejlchina.http.internal.RealHttpResult; +import com.ejlchina.http.internal.TaskExecutor; + +import okhttp3.Headers; +import okhttp3.MediaType; +import okhttp3.Response; + + +/** + * Http 执行结果 + */ +public interface HttpResult { + + /** + * 构造一个 HttpResult + * 此方法构造的 HttpResult 不可设置进度回调，不可进行下载操作！ + * 若需要，请使用方法： {@link #of(Response, TaskExecutor)} + * @param response Response + * @return HttpResult + */ + static HttpResult of(Response response) { + return of(response, null); + } + + /** + * 构造一个 HttpResult + * @param response Response + * @param taskExecutor 任务执行器, 可通过方法 {@link HTTP#getExecutor()} 获得 + * @return HttpResult + */ + static HttpResult of(Response response, TaskExecutor taskExecutor) { + if (response != null) { + return new RealHttpResult(null, response, taskExecutor); + } + throw new IllegalArgumentException("response 不能为空"); + } + + /** + * 获取所属的 Http请求任务 + * @return HttpTask + */ + HttpTask getTask(); + + + public enum State { + + /** + * 执行异常 + */ + EXCEPTION, + + /** + * 请求被取消 + */ + CANCELED, + + /** + * 请求已响应 + */ + RESPONSED, + + /** + * 网络超时 + */ + TIMEOUT, + + /** + * 网络出错 + */ + NETWORK_ERROR + + } + + /** + * HTTP响应报文体 + */ + public interface Body { + + /** + * @return 媒体类型 + */ + MediaType getContentType(); + + /** + * @return 报文体字节长度 + */ + long getContentLength(); + + /** + * 在IO线程执行 + * @return Body + */ + Body nextOnIO(); + + /** + * 设置报文体接收进度回调 + * @param onProcess 进度回调函数 + * @return Body + */ + Body setOnProcess(OnCallback onProcess); + + /** + * 设置进度回调的步进字节，默认 8K（8192） + * 表示每接收 stepBytes 个字节，执行一次进度回调 + * @param stepBytes 步进字节 + * @return Body + */ + Body setStepBytes(long stepBytes); + + /** + * 设置进度回调的步进比例 + * 表示每接收 stepRate 比例，执行一次进度回调 + * @param stepRate 步进比例 + * @return Body + */ + Body setStepRate(double stepRate); + + /** + * 设置进度回调忽略响应的Range头信息，即进度回调会从0开始 + * @return Body + */ + Body setRangeIgnored(); + + /** + * 同一个 Body 对象的 toXXX 类方法只可使用一个并且只能调用一次 + * @return 报文体转字节流 + */ + InputStream toByteStream(); + + /** + * 同一个 Body 对象的 toXXX 类方法只可使用一个并且只能调用一次 + * @return 报文体转字节数组 + */ + byte[] toBytes(); + + /** + * 同一个 Body 对象的 toXXX 类方法只可使用一个并且只能调用一次 + * @return 报文体转字符流 + */ + Reader toCharStream(); + + /** + * 同一个 Body 对象的 toXXX 类方法只可使用一个并且只能调用一次 + * @return 报文体转字符串 + */ + String toString(); + + /** + * 同一个 Body 对象的 toXXX 类方法只可使用一个并且只能调用一次 + * @return 报文体转Json对象 + */ + JSONObject toJsonObject(); + + /** + * 同一个 Body 对象的 toXXX 类方法只可使用一个并且只能调用一次 + * @return 报文体转Json数组 + */ + JSONArray toJsonArray(); + + /** + * 同一个 Body 对象的 toXXX 类方法只可使用一个并且只能调用一次 + * @param 目标泛型 + * @param type 目标类型 + * @return 报文体Json文本转JavaBean + */ + T toBean(Class type); + + /** + * 同一个 Body 对象的 toXXX 类方法只可使用一个并且只能调用一次 + * @param 目标泛型 + * @param type 目标类型 + * @return 报文体Json文本转JavaBean列表 + */ + List toList(Class type); + + /** + * 下载到指定路径 + * 同一个 Body 对象的 toXXX 类方法只可使用一个并且只能调用一次 + * @param filePath 目标路径 + * @return 下载过程 #Download + */ + Download toFile(String filePath); + + /** + * 下载到指定文件 + * 同一个 Body 对象的 toXXX 类方法只可使用一个并且只能调用一次 + * @param file 目标文件 + * @return 下载过程 #Download + */ + Download toFile(File file); + + /** + * 下载到指定文件夹 + * 同一个 Body 对象的 toXXX 类方法只可使用一个并且只能调用一次 + * @param dirPath 目标目录 + * @return 下载过程 #Download + */ + Download toFolder(String dirPath); + + /** + * 下载到指定文件夹 + * 同一个 Body 对象的 toXXX 类方法只可使用一个并且只能调用一次 + * @param dir 目标目录 + * @return 下载过程 #Download + */ + Download toFolder(File dir); + + /** + * 缓存自己，缓存后可 重复使用 toXXX 类方法 + * @return Body + */ + Body cache(); + + /** + * 关闭报文体 + * 未对报文体做任何消费时使用，比如只读取长度 + * @return Body + */ + Body close(); + + } + + + /** + * @return 执行状态 + */ + State getState(); + + /** + * @return HTTP状态码 + */ + int getStatus(); + + /** + * @return 是否响应成功，状态码在 [200..300) 之间 + */ + boolean isSuccessful(); + + /** + * @return 响应头 + */ + Headers getHeaders(); + + /** + * @param name 头名称 + * @return 响应头 + */ + List getHeaders(String name); + + /** + * @param name 头名称 + * @return 响应头 + */ + String getHeader(String name); + + /** + * @return 响应报文体 + */ + Body getBody(); + + /** + * @return 执行中发生的异常 + */ + Exception getError(); + + /** + * 关闭报文 + * 未对报文体做任何消费时使用，比如只读取报文头 + * @return HttpResult + */ + HttpResult close(); + +} diff --git a/src/main/java/com/ejlchina/http/HttpTask.java b/src/main/java/com/ejlchina/http/HttpTask.java new file mode 100644 index 00000000..04ccf72c --- /dev/null +++ b/src/main/java/com/ejlchina/http/HttpTask.java @@ -0,0 +1,710 @@ +package com.ejlchina.http; + +import java.io.File; +import java.io.IOException; +import java.io.InputStream; +import java.net.ConnectException; +import java.net.SocketTimeoutException; +import java.net.UnknownHostException; +import java.util.HashMap; +import java.util.Map; + +import com.alibaba.fastjson.JSON; +import com.ejlchina.http.HttpResult.State; +import com.ejlchina.http.internal.HttpClient; +import com.ejlchina.http.internal.HttpException; +import com.ejlchina.http.internal.ProcessRequestBody; + +import okhttp3.Call; +import okhttp3.FormBody; +import okhttp3.MediaType; +import okhttp3.MultipartBody; +import okhttp3.Request; +import okhttp3.RequestBody; +import okhttp3.Response; +import okhttp3.ResponseBody; +import okhttp3.internal.Util; +import okio.Buffer; + + +/** + * Created by 周旭（Troy.Zhou） on 2020/3/11. + */ +@SuppressWarnings("unchecked") +public abstract class HttpTask> { + + private static final MediaType TYPE_JSON = MediaType.parse("application/json; charset=utf-8"); + private static String PATH_PARAM_REGEX = "[A-Za-z0-9_\\-/]*\\{[A-Za-z0-9_\\-]+\\}[A-Za-z0-9_\\-/]*"; + + protected HttpClient httpClient; + protected boolean nothrow; + protected String tag; + protected boolean nextOnIO = false; + + private String urlPath; + private Map headers; + private Map pathParams; + private Map urlParams; + private Map bodyParams; + private Map jsonParams; + private Map files; + private String requestJson; + private OnCallback onProcess; + private boolean pOnIO; + private long stepBytes = 0; + private double stepRate = -1; + + private Object object; + + + public HttpTask(HttpClient httpClient, String url) { + this.httpClient = httpClient; + this.urlPath = url; + } + + /** + * 获取请求任务的URL地址 + * @return URL地址 + */ + public String getUrl() { + return urlPath; + } + + /** + * 获取请求任务的标签 + * @return 标签 + */ + public String getTag() { + return tag; + } + + /** + * 标签匹配 + * 判断任务标签与指定的标签是否匹配（包含指定的标签） + * @param tag 标签 + * @return 是否匹配 + */ + public boolean isTagged(String tag) { + if (this.tag != null && tag != null) { + return this.tag.contains(tag); + } + return false; + } + + /** + * 获取请求任务的头信息 + * @return 头信息 + */ + public Map getHeaders() { + return headers; + } + + /** + * 获得被绑定的对象 + * @return Object + */ + public Object getBound() { + return object; + } + + /** + * 设置在发生异常时不向上抛出，设置后： + * 异步请求可以在异常回调内捕获异常，同步请求在返回结果中找到该异常 + * @return HttpTask 实例 + */ + public C nothrow() { + this.nothrow = true; + return (C) this; + } + + /** + * 为请求任务添加标签 + * @param tag 标签 + * @return HttpTask 实例 + */ + public C setTag(String tag) { + this.tag = tag; + return (C) this; + } + + /** + * 下一个回调在IO线程执行 + * @return HttpTask 实例 + */ + public C nextOnIO() { + nextOnIO = true; + return (C) this; + } + + /** + * 绑定一个对象 + * @return HttpTask 实例 + */ + public C bind(Object object) { + this.object = object; + return (C) this; + } + + /** + * 添加请求头 + * @param name 请求头名 + * @param value 请求头值 + * @return HttpTask 实例 + */ + public C addHeader(String name, String value) { + if (name != null && value != null) { + if (headers == null) { + headers = new HashMap<>(); + } + headers.put(name, value); + } + return (C) this; + } + + /** + * 添加请求头 + * @param headers 请求头集合 + * @return HttpTask 实例 + */ + public C addHeader(Map headers) { + if (headers != null) { + if (this.headers == null) { + this.headers = new HashMap<>(); + } + this.headers.putAll(headers); + } + return (C) this; + } + + /** + * 设置Range头信息 + * 表示接收报文体时跳过的字节数，用于断点续传 + * @param rangeStart 表示从 rangeStart 个字节处开始接收，通常是已经下载的字节数，即上次的断点） + * @return HttpTask 实例 + */ + public C setRange(long rangeStart) { + return addHeader("Range", "bytes=" + rangeStart + "-"); + } + + /** + * 设置Range头信息 + * 设置接收报文体时接收的范围，用于分块下载 + * @param rangeStart 表示从 rangeStart 个字节处开始接收 + * @param rangeEnd 表示接收到 rangeEnd 个字节处 + * @return HttpTask 实例 + */ + public C setRange(long rangeStart, long rangeEnd) { + return addHeader("Range", "bytes=" + rangeStart + "-" + rangeEnd); + } + + /** + * 设置报文体发送进度回调 + * @param onProcess 进度回调函数 + * @return HttpTask 实例 + */ + public C setOnProcess(OnCallback onProcess) { + this.onProcess = onProcess; + pOnIO = nextOnIO; + nextOnIO = false; + return (C) this; + } + + /** + * 设置进度回调的步进字节，默认 8K（8192） + * 表示每接收 stepBytes 个字节，执行一次进度回调 + * @param stepBytes 步进字节 + * @return HttpTask 实例 + */ + public C setStepBytes(long stepBytes) { + this.stepBytes = stepBytes; + return (C) this; + } + + /** + * 设置进度回调的步进比例 + * 表示每接收 stepRate 比例，执行一次进度回调 + * @param stepRate 步进比例 + * @return HttpTask 实例 + */ + public C setStepRate(double stepRate) { + this.stepRate = stepRate; + return (C) this; + } + + /** + * 路径参数：替换URL里的{name} + * @param name 参数名 + * @param value 参数值 + * @return HttpTask 实例 + **/ + public C addPathParam(String name, Object value) { + if (name != null && value != null) { + if (pathParams == null) { + pathParams = new HashMap<>(); + } + pathParams.put(name, value.toString()); + } + return (C) this; + } + + /** + * 路径参数：替换URL里的{name} + * @param params 参数集合 + * @return HttpTask 实例 + **/ + public C addPathParam(Map params) { + if (params != null) { + if (pathParams == null) { + pathParams = new HashMap<>(); + } + params.forEach((String name, Object value) -> { + if (name != null && value != null) { + pathParams.put(name, value.toString()); + } + }); + } + return (C) this; + } + + /** + * URL参数：拼接在URL后的参数 + * @param name 参数名 + * @param value 参数值 + * @return HttpTask 实例 + **/ + public C addUrlParam(String name, Object value) { + if (name != null && value != null) { + if (urlParams == null) { + urlParams = new HashMap<>(); + } + urlParams.put(name, value.toString()); + } + return (C) this; + } + + /** + * URL参数：拼接在URL后的参数 + * @param params 参数集合 + * @return HttpTask 实例 + **/ + public C addUrlParam(Map params) { + if (params != null) { + if (urlParams == null) { + urlParams = new HashMap<>(); + } + params.forEach((String name, Object value) -> { + if (name != null && value != null) { + urlParams.put(name, value.toString()); + } + }); + } + return (C) this; + } + + /** + * Body参数：放在Body里的参数 + * @param name 参数名 + * @param value 参数值 + * @return HttpTask 实例 + **/ + public C addBodyParam(String name, Object value) { + if (name != null && value != null) { + if (bodyParams == null) { + bodyParams = new HashMap<>(); + } + bodyParams.put(name, value.toString()); + } + return (C) this; + } + + /** + * Body参数：放在Body里的参数 + * @param params 参数集合 + * @return HttpTask 实例 + **/ + public C addBodyParam(Map params) { + if (params != null) { + if (bodyParams == null) { + bodyParams = new HashMap<>(); + } + params.forEach((String name, Object value) -> { + if (name != null && value != null) { + bodyParams.put(name, value.toString()); + } + }); + } + return (C) this; + } + + /** + * Json参数：请求体为Json，支持多层结构 + * @param name JSON键名 + * @param value JSON键值 + * @return HttpTask 实例 + */ + public C addJsonParam(String name, Object value) { + if (name != null && value != null) { + if (jsonParams == null) { + jsonParams = new HashMap<>(); + } + jsonParams.put(name, value); + } + return (C) this; + } + + /** + * Json参数：请求体为Json，只支持单层Json + * 若请求json为多层结构，请使用setRequestJson方法 + * @param params JSON键值集合 + * @return HttpTask 实例 + */ + public C addJsonParam(Map params) { + if (params != null) { + if (jsonParams == null) { + jsonParams = new HashMap<>(); + } + jsonParams.putAll(params); + } + return (C) this; + } + + /** + * 设置 json 请求体 + * @param json JSON字符串 或 Java对象（将依据 对象的get方法序列化为 json 字符串） + * @return HttpTask 实例 + **/ + public C setRequestJson(Object json) { + return setRequestJson(json, null); + } + + /** + * 请求体为json + * @param json JSON字符串 或 Java对象，将跟换 bean的get方法序列化程 json 字符串 + * @param dateFormat 序列化json时对日期类型字段的处理格式 + * @return HttpTask 实例 + **/ + public C setRequestJson(Object json, String dateFormat) { + if (json != null) { + if (json instanceof String) { + requestJson = json.toString(); + } else if (dateFormat != null) { + requestJson = JSON.toJSONStringWithDateFormat(json, dateFormat); + } else { + requestJson = JSON.toJSONString(json); + } + } + return (C) this; + } + + /** + * 添加文件参数 + * @param name 参数名 + * @param filePath 文件路径 + * @return HttpTask 实例 + */ + public C addFileParam(String name, String filePath) { + return addFileParam(name, new File(filePath)); + } + + /** + * 添加文件参数 + * @param name 参数名 + * @param file 文件 + * @return HttpTask 实例 + */ + public C addFileParam(String name, File file) { + if (name != null && file != null && file.exists()) { + String fileName = file.getName(); + String type = fileName.substring(fileName.lastIndexOf(".") + 1); + if (files == null) { + files = new HashMap<>(); + } + files.put(name, new FilePara(type, fileName, file)); + } + return (C) this; + } + + /** + * 添加文件参数 + * @param name 参数名 + * @param type 文件类型: 如 png、jpg、jpeg 等 + * @param inputStream 文件输入流 + * @return HttpTask 实例 + */ + public C addFileParam(String name, String type, InputStream inputStream) { + return addFileParam(name, type, null, inputStream); + } + + /** + * 添加文件参数 + * @param name 参数名 + * @param type 文件类型: 如 png、jpg、jpeg 等 + * @param fileName 文件名 + * @param input 文件输入流 + * @return HttpTask 实例 + */ + public C addFileParam(String name, String type, String fileName, InputStream input) { + if (name != null && input != null) { + byte[] content = null; + try { + Buffer buffer = new Buffer(); + content = buffer.readFrom(input).readByteArray(); + buffer.close(); + } catch (IOException e) { + throw new HttpException("读取文件输入流出错：", e); + } finally { + Util.closeQuietly(input); + } + addFileParam(name, type, fileName, content); + } + return (C) this; + } + + /** + * 添加文件参数 + * @param name 参数名 + * @param type 文件类型: 如 png、jpg、jpeg 等 + * @param content 文件内容 + * @return HttpTask 实例 + */ + public C addFileParam(String name, String type, byte[] content) { + return addFileParam(name, type, null, content); + } + + /** + * 添加文件参数 + * @param name 参数名 + * @param type 文件类型: 如 png、jpg、jpeg 等 + * @param fileName 文件名 + * @param content 文件内容 + * @return HttpTask 实例 + */ + public C addFileParam(String name, String type, String fileName, byte[] content) { + if (name != null && content != null) { + if (files == null) { + files = new HashMap<>(); + } + files.put(name, new FilePara(type, fileName, content)); + } + return (C) this; + } + + class FilePara { + + String type; + String fileName; + byte[] content; + File file; + + FilePara(String type, String fileName, byte[] content) { + this.type = type; + this.fileName = fileName; + this.content = content; + } + + FilePara(String type, String fileName, File file) { + this.type = type; + this.fileName = fileName; + this.file = file; + } + + } + + protected Call prepareCall(String method) { + assertNotConflict("GET".equals(method)); + Request.Builder builder = new Request.Builder() + .url(buildUrlPath()); + buildHeaders(builder); + RequestBody reqBody = null; + if (!"GET".equals(method)) { + reqBody = buildRequestBody(); + if (onProcess != null) { + long contentLength = contentLength(reqBody); + if (stepRate > 0 && stepRate <= 1) { + stepBytes = (long) (contentLength * stepRate); + } + if (stepBytes <= 0) { + stepBytes = Process.DEFAULT_STEP_BYTES; + } + reqBody = new ProcessRequestBody(reqBody, onProcess, + httpClient.getExecutor().getExecutor(pOnIO), + contentLength, stepBytes); + } + } + switch (method) { + case "GET": + builder.get(); + break; + case "POST": + builder.post(reqBody); + break; + case "PUT": + builder.put(reqBody); + break; + case "DELETE": + builder.delete(reqBody); + break; + } + return httpClient.request(builder.build()); + } + + private long contentLength(RequestBody reqBody) { + try { + return reqBody.contentLength(); + } catch (IOException e) { + throw new HttpException("无法获取请求体长度", e); + } + } + + + private void buildHeaders(Request.Builder builder) { + if (headers != null) { + for (String name : headers.keySet()) { + String value = headers.get(name); + if (value != null) { + builder.addHeader(name, value); + } + } + } + } + + + protected String toString(Response response) throws IOException { + String body = null; + ResponseBody rbody = response.body(); + if (rbody != null) { + body = rbody.string(); + } + return body; + } + + protected State toState(IOException e) { + if (e instanceof SocketTimeoutException) { + return State.TIMEOUT; + } else if (e instanceof UnknownHostException || e instanceof ConnectException) { + return State.NETWORK_ERROR; + } else if ("Canceled".equals(e.getMessage())) { + return State.CANCELED; + } + return State.EXCEPTION; + } + + + private RequestBody buildRequestBody() { + if (jsonParams != null) { + requestJson = JSON.toJSONString(jsonParams); + } + if (files != null) { + MultipartBody.Builder builder = new MultipartBody.Builder().setType(MultipartBody.FORM); + if (bodyParams != null) { + for (String name : bodyParams.keySet()) { + String value = bodyParams.get(name); + builder.addFormDataPart(name, value); + } + } + for (String name : files.keySet()) { + FilePara file = files.get(name); + MediaType type = httpClient.getMediaType(file.type); + RequestBody bodyPart; + if (file.file != null) { + bodyPart = RequestBody.create(type, file.file); + } else { + bodyPart = RequestBody.create(type, file.content); + } + builder.addFormDataPart(name, file.fileName, bodyPart); + } + return builder.build(); + } else if (requestJson != null) { + return RequestBody.create(TYPE_JSON, requestJson); + } else { + FormBody.Builder builder = new FormBody.Builder(); + if (bodyParams != null) { + for (String name : bodyParams.keySet()) { + String value = bodyParams.get(name); + builder.add(name, value); + } + } + return builder.build(); + } + } + + + + private String buildUrlPath() { + String url = urlPath; + if (url == null || url.trim().isEmpty()) { + throw new HttpException("url 不能为空！"); + } + if (pathParams != null) { + for (String name : pathParams.keySet()) { + String target = "{" + name + "}"; + if (url.contains(target)) { + url = url.replace(target, pathParams.get(name)); + } else { + throw new HttpException("pathParameter [ " + name + " ] 不存在于 url [ " + urlPath + " ]"); + } + } + } + if (url.matches(PATH_PARAM_REGEX)) { + throw new HttpException("url 里有 pathParameter 没有设置，你必须先调用 addPathParam 为其设置！"); + } + if (urlParams != null) { + if (url.contains("?")) { + if (!url.endsWith("?")) { + url = url.trim(); + if (url.lastIndexOf("=") < url.lastIndexOf("?") + 2) { + throw new HttpException("url 格式错误，'？' 后没有发现 '='"); + } + if (!url.endsWith("&")) { + url += "&"; + } + } + } else { + url += "?"; + } + for (String name : urlParams.keySet()) { + url += name + "=" + urlParams.get(name) + "&"; + } + url = url.substring(0, url.length() - 1); + } + return url; + } + + + protected void assertNotConflict(boolean isGetRequest) { + if (isGetRequest) { + if (requestJson != null) { + throw new HttpException("GET 请求 不能调用 setRequestJson 方法！"); + } + if (jsonParams != null) { + throw new HttpException("GET 请求 不能调用 addJsonParam 方法！"); + } + if (bodyParams != null) { + throw new HttpException("GET 请求 不能调用 addBodyParam 方法！"); + } + if (files != null) { + throw new HttpException("GET 请求 不能调用 addFileParam 方法！"); + } + } + if (requestJson != null) { + if (jsonParams != null) { + throw new HttpException("方法 addJsonParam 与 setRequestJson 不能同时调用！"); + } + if (bodyParams != null) { + throw new HttpException("方法 addBodyParam 与 setRequestJson 不能同时调用！"); + } + if (files != null) { + throw new HttpException("方法 addFileParam 与 setRequestJson 不能同时调用！"); + } + } + if (jsonParams != null) { + if (bodyParams != null) { + throw new HttpException("方法 addBodyParam 与 addJsonParam 不能同时调用！"); + } + if (files != null) { + throw new HttpException("方法 addFileParam 与 addJsonParam 不能同时调用！"); + } + } + } + +} diff --git a/src/main/java/com/ejlchina/http/HttpUtils.java b/src/main/java/com/ejlchina/http/HttpUtils.java new file mode 100644 index 00000000..f7b7ccb5 --- /dev/null +++ b/src/main/java/com/ejlchina/http/HttpUtils.java @@ -0,0 +1,105 @@ +package com.ejlchina.http; + +import com.ejlchina.http.internal.AsyncHttpTask; +import com.ejlchina.http.internal.SyncHttpTask; +import com.ejlchina.http.internal.TaskExecutor; + +import okhttp3.Call; +import okhttp3.Request; +import okhttp3.WebSocket; +import okhttp3.WebSocketListener; + +/** + * Http 工具类，封装 OkHttp + + * 特性： + * 同步请求 + * 异步请求 + * Restfull路径 + * 文件上传 + * JSON自动解析 + * TCP连接池 + * Http2 + * + * @author Troy.Zhou + */ +public class HttpUtils { + + + private static HTTP http; + + + /** + * 配置HttpUtils持有的HTTP实例（不调用此方法前默认使用一个没有没有经过任何配置的HTTP懒实例） + * @param http HTTP实例 + */ + public static void of(HTTP http) { + if (http != null) { + HttpUtils.http = http; + } + } + + + static synchronized HTTP getHttp() { + if (http != null) { + return http; + } + http = HTTP.builder().build(); + return http; + } + + /** + * 异步请求 + * @param url 请求地址 + * @return 异步 HttpTask + */ + public static AsyncHttpTask async(String url) { + return getHttp().async(url); + } + + /** + * 同步请求 + * @param url 请求地址 + * @return 同步 HttpTask + */ + public static SyncHttpTask sync(String url) { + return getHttp().sync(url); + } + + /** + * 根据标签取消HTTP任务，只要任务的标签包含指定的Tag就会被取消 + * @param tag 标签 + * @return 被取消的任务数量 + */ + public static int cancel(String tag) { + return getHttp().cancel(tag); + } + + /** + * OkHttp 原生请求 （该请求不经过 预处理器） + * @param request 请求 + * @return Call + */ + public static Call request(Request request) { + return getHttp().request(request); + } + + /** + * Websocket（该请求不经过 预处理器） + * @param request 请求 + * @param listener 监听器 + * @return + */ + public static WebSocket webSocket(Request request, WebSocketListener listener) { + return getHttp().webSocket(request, listener); + } + + /** + * 获取任务执行器 + * @return TaskExecutor + */ + public static TaskExecutor getExecutor() { + return getHttp().getExecutor(); + } + +} diff --git a/src/main/java/com/ejlchina/http/OnCallback.java b/src/main/java/com/ejlchina/http/OnCallback.java new file mode 100644 index 00000000..32dd81e8 --- /dev/null +++ b/src/main/java/com/ejlchina/http/OnCallback.java @@ -0,0 +1,11 @@ +package com.ejlchina.http; + +/** + * 数据回调接口 + * Created by 15735 on 2017/1/3. + */ +public interface OnCallback { + + void on(T data); + +} diff --git a/src/main/java/com/ejlchina/http/Preprocessor.java b/src/main/java/com/ejlchina/http/Preprocessor.java new file mode 100644 index 00000000..ee2f757c --- /dev/null +++ b/src/main/java/com/ejlchina/http/Preprocessor.java @@ -0,0 +1,36 @@ +package com.ejlchina.http; + +/** + * 预处理器，支持异步 + * 在HTTP请求任务正式开始之前执行 + * @author Troy.Zhou + */ +public interface Preprocessor { + + /** + * 在HTTP请求开始之前执行 + * @param chain 预处理器链 + */ + void doProcess(PreChain chain); + + + interface PreChain { + + /** + * @return 当前的请求任务 + */ + HttpTask getTask(); + + /** + * @return HTTP + */ + HTTP getHttp(); + + /** + * 继续HTTP请求任务 + */ + void proceed(); + + } + +} diff --git a/src/main/java/com/ejlchina/http/Process.java b/src/main/java/com/ejlchina/http/Process.java new file mode 100644 index 00000000..aff09bd3 --- /dev/null +++ b/src/main/java/com/ejlchina/http/Process.java @@ -0,0 +1,31 @@ +package com.ejlchina.http; + +/** + * 进度（上传或下载） + * @since 2.2.0 + */ +public interface Process { + + static final int DEFAULT_STEP_BYTES = 8192; + + /** + * @return 完成比例 + */ + double getRate(); + + /** + * @return 总 + */ + long getTotalBytes(); + + /** + * @return 已完成任务量 + */ + long getDoneBytes(); + + /** + * @return 任务是否完成 + */ + boolean isDone(); + +} diff --git a/src/main/java/com/ejlchina/http/TaskListener.java b/src/main/java/com/ejlchina/http/TaskListener.java new file mode 100644 index 00000000..90c2ada2 --- /dev/null +++ b/src/main/java/com/ejlchina/http/TaskListener.java @@ -0,0 +1,20 @@ +package com.ejlchina.http; + +/** + * 任务监听接口 + * @author 15735 + * @since 2.3.0 + */ +public interface TaskListener { + + + /** + * 全局任务监听 + * @param task 所属的 HttpTask + * @param data 监听内容 + * @return 是否继续执行 task 对应的回调函数 + */ + boolean listen(HttpTask task, T data); + + +} diff --git a/src/main/java/com/ejlchina/http/internal/AsyncHttpTask.java b/src/main/java/com/ejlchina/http/internal/AsyncHttpTask.java new file mode 100644 index 00000000..c55985a8 --- /dev/null +++ b/src/main/java/com/ejlchina/http/internal/AsyncHttpTask.java @@ -0,0 +1,269 @@ +package com.ejlchina.http.internal; + +import java.io.IOException; + +import com.ejlchina.http.HttpCall; +import com.ejlchina.http.HttpResult; +import com.ejlchina.http.HttpResult.State; +import com.ejlchina.http.HttpTask; +import com.ejlchina.http.OnCallback; + +import okhttp3.Call; +import okhttp3.Callback; +import okhttp3.Response; + + +/** + * 异步 Http 请求任务 + * + * @author Troy.Zhou + * + */ +public class AsyncHttpTask extends HttpTask { + + + private OnCallback onResponse; + private OnCallback onException; + private OnCallback onComplete; + private boolean rOnIO; + private boolean eOnIO; + private boolean cOnIO; + + + public AsyncHttpTask(HttpClient client, String url) { + super(client, url); + } + + + /** + * 设置请求执行异常后的回调函数，设置后，相关异常将不再向上抛出 + * @param onException 请求异常回调 + * @return HttpTask 实例 + */ + public AsyncHttpTask setOnException(OnCallback onException) { + this.onException = onException; + eOnIO = nextOnIO; + nextOnIO = false; + return this; + } + + /** + * 设置请求执行完成后的回调函数，无论成功|失败|异常 都会被执行 + * @param onComplete 请求完成回调 + * @return HttpTask 实例 + */ + public AsyncHttpTask setOnComplete(OnCallback onComplete) { + this.onComplete = onComplete; + cOnIO = nextOnIO; + nextOnIO = false; + return this; + } + + /** + * 设置请求得到响应后的回调函数 + * @param onResponse 请求响应回调 + * @return HttpTask 实例 + */ + public AsyncHttpTask setOnResponse(OnCallback onResponse) { + this.onResponse = onResponse; + rOnIO = nextOnIO; + nextOnIO = false; + return this; + } + + /** + * 发起 GET 请求 + * @return HttpCall + */ + public HttpCall get() { + return request("GET"); + } + + /** + * 发起 POST 请求 + * @return HttpCall + */ + public HttpCall post() { + return request("POST"); + } + + /** + * 发起 PUT 请求 + * @return HttpCall + */ + public HttpCall put() { + return request("PUT"); + } + + /** + * 发起 DELETE 请求 + * @return HttpCall + */ + public HttpCall delete() { + return request("DELETE"); + } + + private HttpCall request(String method) { + PreHttpCall call = new PreHttpCall(); + httpClient.preprocess(this, () -> { + synchronized (call) { + if (!call.isCanceled()) { + call.setCall(executeCall(prepareCall(method))); + } + } + }); + if (tag != null) { + httpClient.addTagCall(tag, call, this); + } + return call; + } + + + class PreHttpCall implements HttpCall { + + private boolean canceled = false; + private HttpCall call; + + @Override + public boolean cancel() { + boolean res = true; + synchronized (this) { + if (call != null) { + res = call.cancel(); + } else { + canceled = true; + } + notify(); + } + if (tag != null && call == null) { + httpClient.removeTagCall(AsyncHttpTask.this); + } + return res; + } + + @Override + public boolean isDone() { + if (call != null) { + return call.isDone(); + } + return canceled; + } + + @Override + public boolean isCanceled() { + if (call != null) { + return call.isCanceled(); + } + return canceled; + } + + public void setCall(HttpCall call) { + this.call = call; + notify(); + } + + @Override + public synchronized HttpResult getResult() { + if (canceled) { + return new RealHttpResult(AsyncHttpTask.this, State.CANCELED); + } + if (call == null) { + try { + wait(); + } catch (InterruptedException e) { + throw new HttpException(e.getMessage(), e); + } + } + if (call != null) { + return call.getResult(); + } + return new RealHttpResult(AsyncHttpTask.this, State.CANCELED); + } + + } + + class OkHttpCall implements HttpCall { + + private Call call; + private HttpResult result; + + public OkHttpCall(Call call) { + this.call = call; + } + + @Override + public boolean cancel() { + if (result == null) { + call.cancel(); + return true; + } + return false; + } + + @Override + public boolean isDone() { + return result != null; + } + + @Override + public boolean isCanceled() { + return call.isCanceled(); + } + + @Override + public synchronized HttpResult getResult() { + if (result == null) { + try { + wait(); + } catch (InterruptedException e) { + throw new HttpException(e.getMessage(), e); + } + } + return result; + } + + public void setResult(HttpResult result) { + synchronized (this) { + this.result = result; + notify(); + } + if (tag != null) { + httpClient.removeTagCall(AsyncHttpTask.this); + } + } + + } + + private HttpCall executeCall(Call call) { + OkHttpCall httpCall = new OkHttpCall(call); + call.enqueue(new Callback() { + @Override + public void onFailure(Call call, IOException error) { + State state = toState(error); + if (state == State.CANCELED) { + httpCall.setResult(new RealHttpResult(AsyncHttpTask.this, state)); + } else { + TaskExecutor executor = httpClient.getExecutor(); + executor.executeOnComplete(AsyncHttpTask.this, onComplete, state, cOnIO); + if (!executor.executeOnException(AsyncHttpTask.this, onException, error, eOnIO) + && !nothrow) { + throw new HttpException(error.getMessage(), error); + } + httpCall.setResult(new RealHttpResult(AsyncHttpTask.this, state, error)); + } + } + + @Override + public void onResponse(Call call, Response response) throws IOException { + TaskExecutor executor = httpClient.getExecutor(); + HttpResult result = new RealHttpResult(AsyncHttpTask.this, response, executor); + executor.executeOnComplete(AsyncHttpTask.this, onComplete, State.RESPONSED, cOnIO); + executor.executeOnResponse(AsyncHttpTask.this, onResponse, result, rOnIO); + httpCall.setResult(result); + } + + }); + return httpCall; + } + +} diff --git a/src/main/java/com/ejlchina/http/internal/HttpClient.java b/src/main/java/com/ejlchina/http/internal/HttpClient.java new file mode 100644 index 00000000..6d224c45 --- /dev/null +++ b/src/main/java/com/ejlchina/http/internal/HttpClient.java @@ -0,0 +1,445 @@ +package com.ejlchina.http.internal; + +import java.io.IOException; +import java.util.ArrayList; +import java.util.Collections; +import java.util.HashMap; +import java.util.Iterator; +import java.util.LinkedList; +import java.util.List; +import java.util.Map; +import java.util.Queue; +import java.util.concurrent.Executor; + +import com.ejlchina.http.Configurator; +import com.ejlchina.http.DownListener; +import com.ejlchina.http.HTTP; +import com.ejlchina.http.HttpCall; +import com.ejlchina.http.HttpResult; +import com.ejlchina.http.HttpResult.State; +import com.ejlchina.http.HttpTask; +import com.ejlchina.http.Preprocessor; +import com.ejlchina.http.TaskListener; + +import okhttp3.Call; +import okhttp3.MediaType; +import okhttp3.OkHttpClient; +import okhttp3.Request; +import okhttp3.WebSocket; +import okhttp3.WebSocketListener; + +public class HttpClient implements HTTP { + + + private OkHttpClient client; + + private String baseUrl; + // 媒体类型 + private Map mediaTypes; + // 执行器 + private TaskExecutor executor; + // 预处理器 + private Preprocessor[] preprocessors; + + private List tagCalls; + + + private HttpClient(Builder builder) { + this.client = builder.client; + this.baseUrl = builder.baseUrl; + this.mediaTypes = builder.mediaTypes; + this.executor = new TaskExecutor(client.dispatcher().executorService(), + builder.mainExecutor, builder.downloadListener, + builder.responseListener, builder.exceptionListener, + builder.completeListener); + this.preprocessors = builder.preprocessors.toArray(new Preprocessor[builder.preprocessors.size()]); + this.tagCalls = Collections.synchronizedList(new LinkedList<>()); + } + + @Override + public AsyncHttpTask async(String url) { + return new AsyncHttpTask(this, urlPath(url)); + } + + @Override + public SyncHttpTask sync(String url) { + return new SyncHttpTask(this, urlPath(url)); + } + + @Override + public int cancel(String tag) { + if (tag == null) { + return 0; + } + int count = 0; + Iterator it = tagCalls.iterator(); + while (it.hasNext()) { + TagCall tagCall = it.next(); + // 只要任务的标签包含指定的Tag就会被取消 + if (tagCall.tag.contains(tag)) { + if (tagCall.call.cancel()) { + count++; + } + it.remove(); + } + } + return count; + } + + @Override + public Call request(Request request) { + return client.newCall(request); + } + + @Override + public WebSocket webSocket(Request request, WebSocketListener listener) { + return client.newWebSocket(request, listener); + } + + public OkHttpClient getOkClient() { + return client; + } + + public int getTagCallCount() { + return tagCalls.size(); + } + + public void addTagCall(String tag, HttpCall call, HttpTask task) { + tagCalls.add(new TagCall(tag, call, task)); + } + + public void removeTagCall(HttpTask task) { + Iterator it = tagCalls.iterator(); + while (it.hasNext()) { + TagCall tagCall = it.next(); + if (tagCall.task == task) { + it.remove(); + break; + } + } + } + + class TagCall { + + String tag; + HttpCall call; + HttpTask task; + + public TagCall(String tag, HttpCall call, HttpTask task) { + this.tag = tag; + this.call = call; + this.task = task; + } + + } + + public MediaType getMediaType(String type) { + String mediaType = mediaTypes.get(type); + if (mediaType != null) { + return MediaType.parse(mediaType); + } + return MediaType.parse("application/octet-stream"); + } + + public TaskExecutor getExecutor() { + return executor; + } + + public void preprocess(HttpTask> httpTask, Runnable request) { + if (preprocessors.length > 0) { + RealPreChain process = new RealPreChain(preprocessors, + httpTask, request); + preprocessors[0].doProcess(process); + } else { + request.run(); + } + } + + /** + * 串行预处理器 + * @author Troy.Zhou + */ + static class SerialPreprocessor implements Preprocessor { + + // 预处理器 + private Preprocessor preprocessor; + // 待处理的任务队列 + private Queue pendings; + // 是否有任务正在执行 + private boolean running = false; + + SerialPreprocessor(Preprocessor preprocessor) { + this.preprocessor = preprocessor; + this.pendings = new LinkedList<>(); + } + + @Override + public void doProcess(PreChain process) { + boolean should = true; + synchronized (this) { + if (running) { + pendings.add(process); + should = false; + } else { + running = true; + } + } + if (should) { + preprocessor.doProcess(process); + } + } + + public void afterProcess() { + PreChain process = null; + synchronized (this) { + if (pendings.size() > 0) { + process = pendings.poll(); + } else { + running = false; + } + } + if (process != null) { + preprocessor.doProcess(process); + } + } + + } + + + class RealPreChain implements Preprocessor.PreChain { + + private int index; + + private Preprocessor[] preprocessors; + + private HttpTask httpTask; + + private Runnable request; + + public RealPreChain(Preprocessor[] preprocessors, + HttpTask httpTask, + Runnable request) { + this.index = 1; + this.preprocessors = preprocessors; + this.httpTask = httpTask; + this.request = request; + } + + @Override + public HttpTask getTask() { + return httpTask; + } + + @Override + public HTTP getHttp() { + return HttpClient.this; + } + + @Override + public void proceed() { + if (index > 0) { + Preprocessor last = preprocessors[index - 1]; + if (last instanceof SerialPreprocessor) { + ((SerialPreprocessor) last).afterProcess(); + } + } + if (index < preprocessors.length) { + preprocessors[index++].doProcess(this); + } else { + request.run(); + } + } + + } + + public Builder newBuilder() { + return new Builder(this); + } + + private String urlPath(String urlPath) { + boolean isFullPath = urlPath.startsWith("https://") + || urlPath.startsWith("http://"); + if (isFullPath) { + return urlPath; + } + if (baseUrl != null) { + return baseUrl + urlPath; + } + throw new HttpException("在设置 BaseUrl 之前，您必须使用全路径URL发起请求，当前URL为：" + urlPath); + } + + + public static class Builder { + + private OkHttpClient client; + + private String baseUrl; + + private Map mediaTypes; + + private Configurator configurator; + + private Executor mainExecutor; + + private List preprocessors; + + private DownListener downloadListener; + + private TaskListener responseListener; + + private TaskListener exceptionListener; + + private TaskListener completeListener; + + public Builder() { + mediaTypes = new HashMap<>(); + mediaTypes.put("*", "application/octet-stream"); + mediaTypes.put("png", "image/png"); + mediaTypes.put("jpg", "image/jpeg"); + mediaTypes.put("jpeg", "image/jpeg"); + mediaTypes.put("wav", "audio/wav"); + mediaTypes.put("mp3", "audio/mp3"); + mediaTypes.put("mp4", "video/mpeg4"); + mediaTypes.put("txt", "text/plain"); + mediaTypes.put("xls", "application/x-xls"); + mediaTypes.put("xml", "text/xml"); + mediaTypes.put("apk", "application/vnd.android.package-archive"); + mediaTypes.put("doc", "application/msword"); + mediaTypes.put("pdf", "application/pdf"); + mediaTypes.put("html", "text/html"); + preprocessors = new ArrayList<>(); + } + + private Builder(HttpClient hc) { + this.client = hc.client; + this.baseUrl = hc.baseUrl; + this.mediaTypes = hc.mediaTypes; + this.preprocessors = new ArrayList<>(); + Collections.addAll(this.preprocessors, hc.preprocessors); + } + + /** + * 配置 OkHttpClient + * @param configurator 配置器 + * @return Builder + */ + public Builder config(Configurator configurator) { + this.configurator = configurator; + return this; + } + + /** + * 设置 baseUrl + * @param baseUrl 全局URL前缀 + * @return Builder + */ + public Builder baseUrl(String baseUrl) { + this.baseUrl = baseUrl; + return this; + } + + /** + * 配置媒体类型 + * @param mediaTypes 媒体类型 + * @return Builder + */ + public Builder mediaTypes(Map mediaTypes) { + this.mediaTypes.putAll(mediaTypes); + return this; + } + + /** + * 配置媒体类型 + * @param key 媒体类型KEY + * @param value 媒体类型VALUE + * @return Builder + */ + public Builder mediaTypes(String key, String value) { + this.mediaTypes.put(key, value); + return this; + } + + /** + * 设置回调执行器，例如实现切换线程功能，只对异步请求有效 + * @param executor 回调执行器 + * @return Builder + */ + public Builder callbackExecutor(Executor executor) { + this.mainExecutor = executor; + return this; + } + + /** + * 添加可并行处理请求任务的预处理器 + * @param preprocessor 预处理器 + * @return Builder + */ + public Builder addPreprocessor(Preprocessor preprocessor) { + preprocessors.add(preprocessor); + return this; + } + + /** + * 添加预处理器 + * @param preprocessor 预处理器 + * @return Builder + */ + public Builder addSerialPreprocessor(Preprocessor preprocessor) { + preprocessors.add(new SerialPreprocessor(preprocessor)); + return this; + } + + /** + * 设置全局响应监听 + * @param listener 监听器 + * @return Builder + */ + public Builder responseListener(TaskListener listener) { + this.responseListener = listener; + return this; + } + + /** + * 设置全局异常监听 + * @param listener 监听器 + * @return Builder + */ + public Builder exceptionListener(TaskListener listener) { + this.exceptionListener = listener; + return this; + } + + /** + * 设置全局完成监听 + * @param listener 监听器 + * @return Builder + */ + public Builder completeListener(TaskListener listener) { + this.completeListener = listener; + return this; + } + + /** + * 设置下载监听器 + * @param listener 监听器 + * @return Builder + */ + public Builder downloadListener(DownListener listener) { + this.downloadListener = listener; + return this; + } + + public HTTP build() { + if (configurator != null || client == null) { + OkHttpClient.Builder builder = new OkHttpClient.Builder(); + if (configurator != null) { + configurator.config(builder); + } + client = builder.build(); + } + return new HttpClient(this); + } + + } + +} diff --git a/src/main/java/com/ejlchina/http/internal/HttpException.java b/src/main/java/com/ejlchina/http/internal/HttpException.java new file mode 100644 index 00000000..f78606cf --- /dev/null +++ b/src/main/java/com/ejlchina/http/internal/HttpException.java @@ -0,0 +1,21 @@ +package com.ejlchina.http.internal; + +/** + * Created by 周旭（Troy.Zhou） on 2016/8/30. + */ +public class HttpException extends RuntimeException { + + /** + * + */ + private static final long serialVersionUID = 8223484833265657324L; + + public HttpException(String detailMessage) { + super(detailMessage); + } + + public HttpException(String detailMessage, Throwable throwable) { + super(detailMessage, throwable); + } + +} diff --git a/src/main/java/com/ejlchina/http/internal/ProcessInputStream.java b/src/main/java/com/ejlchina/http/internal/ProcessInputStream.java new file mode 100644 index 00000000..779ddc30 --- /dev/null +++ b/src/main/java/com/ejlchina/http/internal/ProcessInputStream.java @@ -0,0 +1,53 @@ +package com.ejlchina.http.internal; + +import java.io.IOException; +import java.io.InputStream; +import java.util.concurrent.Executor; + +import com.ejlchina.http.OnCallback; +import com.ejlchina.http.Process; + +public class ProcessInputStream extends InputStream { + + private InputStream input; + private OnCallback onProcess; + private Executor callbackExecutor; + private long stepBytes; + private long step = 0; + private RealProcess process; + private boolean doneCalled = false; + + public ProcessInputStream(InputStream input, OnCallback onProcess, long totalBytes, long stepBytes, + long doneBytes, Executor callbackExecutor) { + this.input = input; + this.onProcess = onProcess; + this.stepBytes = stepBytes; + this.callbackExecutor = callbackExecutor; + this.process = new RealProcess(totalBytes, doneBytes); + this.step = doneBytes / stepBytes; + } + + + @Override + public int read() throws IOException { + int data = input.read(); + if (data > -1) { + process.increaseDoneBytes(); + } + if (process.notDoneOrReached(step * stepBytes)) { + return data; + } + if (process.isDone()) { + if (doneCalled) { + return data; + } + doneCalled = true; + } + step++; + callbackExecutor.execute(() -> { + onProcess.on(process); + }); + return data; + } + +} diff --git a/src/main/java/com/ejlchina/http/internal/ProcessRequestBody.java b/src/main/java/com/ejlchina/http/internal/ProcessRequestBody.java new file mode 100644 index 00000000..6f406b54 --- /dev/null +++ b/src/main/java/com/ejlchina/http/internal/ProcessRequestBody.java @@ -0,0 +1,91 @@ +package com.ejlchina.http.internal; + +import java.io.IOException; +import java.util.concurrent.Executor; + +import com.ejlchina.http.OnCallback; +import com.ejlchina.http.Process; + +import okhttp3.MediaType; +import okhttp3.RequestBody; +import okio.Buffer; +import okio.BufferedSink; +import okio.ForwardingSink; +import okio.Okio; + +public class ProcessRequestBody extends RequestBody { + + private RequestBody requestBody; + private OnCallback onProcess; + private Executor callbackExecutor; + private long stepBytes; + private long step = 0; + private RealProcess process; + private boolean doneCalled = false; + + public ProcessRequestBody(RequestBody requestBody, OnCallback onProcess, Executor callbackExecutor, + long contentLength, long stepBytes) { + this.requestBody = requestBody; + this.onProcess = onProcess; + this.callbackExecutor = callbackExecutor; + this.stepBytes = stepBytes; + this.process = new RealProcess(contentLength, 0); + } + + @Override + public long contentLength() throws IOException { + return process.getTotalBytes(); + } + + @Override + public boolean isDuplex() { + return requestBody.isDuplex(); + } + + @Override + public boolean isOneShot() { + return requestBody.isOneShot(); + } + + @Override + public MediaType contentType() { + return requestBody.contentType(); + } + + private BufferedSink bufferedSink; + + @Override + public void writeTo(BufferedSink sink) throws IOException { + if (bufferedSink == null) { + bufferedSink = Okio.buffer(new ForwardingSink(sink) { + + @Override + public void write(Buffer source, long byteCount) throws IOException { + //这个方法会循环调用，byteCount 是每次调用上传的字节数。 + super.write(source, byteCount); + process.addDoneBytes(byteCount); + if (process.notDoneOrReached(step * stepBytes)) { + return; + } + if (process.isDone()) { + if (doneCalled) { + return; + } + doneCalled = true; + } + step++; + callbackExecutor.execute(() -> { + onProcess.on(process); + }); + } + + }); + } + requestBody.writeTo(bufferedSink); + bufferedSink.flush(); + } + + + +} + diff --git a/src/main/java/com/ejlchina/http/internal/RealHttpResult.java b/src/main/java/com/ejlchina/http/internal/RealHttpResult.java new file mode 100644 index 00000000..697fd4a6 --- /dev/null +++ b/src/main/java/com/ejlchina/http/internal/RealHttpResult.java @@ -0,0 +1,134 @@ +package com.ejlchina.http.internal; + +import java.util.List; + +import com.ejlchina.http.HttpResult; +import com.ejlchina.http.HttpTask; + +import okhttp3.Headers; +import okhttp3.Response; + + +public class RealHttpResult implements HttpResult { + + private State state; + private Response response; + private Exception error; + private TaskExecutor taskExecutor; + private HttpTask httpTask; + + + public RealHttpResult(HttpTask httpTask, State state) { + this.httpTask = httpTask; + this.state = state; + } + + public RealHttpResult(HttpTask httpTask, Response response, TaskExecutor taskExecutor) { + this(httpTask, taskExecutor); + response(response); + } + + public RealHttpResult(HttpTask httpTask, TaskExecutor taskExecutor) { + this.httpTask = httpTask; + this.taskExecutor = taskExecutor; + } + + public RealHttpResult(HttpTask httpTask, State state, Exception error) { + this.httpTask = httpTask; + exception(state, error); + } + + + public void exception(State state, Exception error) { + this.state = state; + this.error = error; + } + + public void response(Response response) { + this.state = State.RESPONSED; + this.response = response; + } + + @Override + public HttpTask getTask() { + return httpTask; + } + + @Override + public State getState() { + return state; + } + + @Override + public int getStatus() { + if (response != null) { + return response.code(); + } + return 0; + } + + @Override + public boolean isSuccessful() { + if (response != null) { + return response.isSuccessful(); + } + return false; + } + + @Override + public Headers getHeaders() { + if (response != null) { + return response.headers(); + } + return null; + } + + @Override + public List getHeaders(String name) { + return response.headers(name); + } + + @Override + public String getHeader(String name) { + return response.header(name); + } + + @Override + public Body getBody() { + if (response != null) { + return new ResultBody(httpTask, response, taskExecutor); + } + return null; + } + + @Override + public Exception getError() { + return error; + } + + public Response getResponse() { + return response; + } + + + @Override + public String toString() { + Body body = getBody(); + String str = "HttpResult [\n state: " + state + ",\n status: " + getStatus() + + ",\n headers: " + getHeaders(); + if (body != null) { + str += ",\n contentType: " + body.getContentType() + + ",\n body: " + body.toString(); + } + return str + ",\n error: " + error + "\n]"; + } + + @Override + public HttpResult close() { + if (response != null) { + response.close(); + } + return this; + } + +} diff --git a/src/main/java/com/ejlchina/http/internal/RealProcess.java b/src/main/java/com/ejlchina/http/internal/RealProcess.java new file mode 100644 index 00000000..700d2895 --- /dev/null +++ b/src/main/java/com/ejlchina/http/internal/RealProcess.java @@ -0,0 +1,50 @@ +package com.ejlchina.http.internal; + +import com.ejlchina.http.Process; + +public class RealProcess implements Process { + + // 总字节数 + private long totalBytes; + // 已经完成字节数 + private long doneBytes; + + + public RealProcess(long totalBytes, long doneBytes) { + this.totalBytes = totalBytes; + this.doneBytes = doneBytes; + } + + @Override + public double getRate() { + return (double) doneBytes / totalBytes; + } + + @Override + public long getTotalBytes() { + return totalBytes; + } + + @Override + public long getDoneBytes() { + return doneBytes; + } + + @Override + public boolean isDone() { + return doneBytes >= totalBytes; + } + + public void addDoneBytes(long delt) { + doneBytes += delt; + } + + public void increaseDoneBytes() { + doneBytes++; + } + + public boolean notDoneOrReached(long bytes) { + return doneBytes < bytes && doneBytes < totalBytes; + } + +} diff --git a/src/main/java/com/ejlchina/http/internal/ResultBody.java b/src/main/java/com/ejlchina/http/internal/ResultBody.java new file mode 100644 index 00000000..aa827e75 --- /dev/null +++ b/src/main/java/com/ejlchina/http/internal/ResultBody.java @@ -0,0 +1,323 @@ +package com.ejlchina.http.internal; + +import static java.nio.charset.StandardCharsets.UTF_8; + +import java.io.ByteArrayInputStream; +import java.io.File; +import java.io.IOException; +import java.io.InputStream; +import java.io.InputStreamReader; +import java.io.Reader; +import java.io.UnsupportedEncodingException; +import java.net.HttpURLConnection; +import java.net.URLDecoder; +import java.nio.charset.Charset; +import java.util.List; + +import com.alibaba.fastjson.JSON; +import com.alibaba.fastjson.JSONArray; +import com.alibaba.fastjson.JSONObject; +import com.ejlchina.http.Download; +import com.ejlchina.http.HttpTask; +import com.ejlchina.http.HttpResult.Body; +import com.ejlchina.http.OnCallback; +import com.ejlchina.http.Process; + +import okhttp3.MediaType; +import okhttp3.Response; +import okio.Buffer; + +public class ResultBody implements Body { + + private Response response; + private TaskExecutor taskExecutor; + private boolean onIO = false; + private OnCallback onProcess; + private long stepBytes = 0; + private double stepRate = -1; + private boolean rangeIgnored = false; + private HttpTask httpTask; + private boolean cached = false; + private byte[] data; + + ResultBody(HttpTask httpTask, Response response, TaskExecutor taskExecutor) { + this.httpTask = httpTask; + this.response = response; + this.taskExecutor = taskExecutor; + } + + @Override + public MediaType getContentType() { + return response.body().contentType(); + } + + @Override + public long getContentLength() { + return response.body().contentLength(); + } + + @Override + public Body nextOnIO() { + onIO = true; + return this; + } + + @Override + public Body setOnProcess(OnCallback onProcess) { + if (taskExecutor == null) { + throw new IllegalStateException("没有 taskExecutor， 不可设置下载进度回调！"); + } + if (cached) { + throw new IllegalStateException("开启缓存后，不可设置下载进度回调！"); + } + this.onProcess = onProcess; + return this; + } + + @Override + public Body setStepBytes(long stepBytes) { + this.stepBytes = stepBytes; + return this; + } + + @Override + public Body setStepRate(double stepRate) { + this.stepRate = stepRate; + return this; + } + + @Override + public Body setRangeIgnored() { + this.rangeIgnored =true; + return this; + } + + @Override + public InputStream toByteStream() { + InputStream input; + if (cached) { + input = new ByteArrayInputStream(cacheBytes()); + } else { + input = response.body().byteStream(); + } + if (onProcess != null) { + long rangeStart = getRangeStart(); + long totalBytes = getContentLength(); + if (!rangeIgnored) { + totalBytes += rangeStart; + } + if (stepRate > 0 && stepRate <= 1) { + stepBytes = (long) (totalBytes * stepRate); + } + if (stepBytes <= 0) { + stepBytes = Process.DEFAULT_STEP_BYTES; + } + return new ProcessInputStream(input, onProcess, totalBytes, stepBytes, + rangeIgnored ? 0 : rangeStart, taskExecutor.getExecutor(onIO)); + } + return input; + } + + @Override + public byte[] toBytes() { + if (cached) { + return cacheBytes(); + } + return bodyToBytes(); + } + + @Override + public Reader toCharStream() { + if (cached || onProcess != null) { + return new InputStreamReader(toByteStream()); + } + return response.body().charStream(); + } + + @Override + public String toString() { + if (cached || onProcess != null) { + MediaType contentType = getContentType(); + Charset charset = contentType != null ? contentType.charset(UTF_8) : UTF_8; + return new String(toBytes(), charset); + } + try { + return response.body().string(); + } catch (IOException e) { + throw new HttpException("报文体转化字符串出错", e); + } + } + + @Override + public JSONObject toJsonObject() { + return JSON.parseObject(toString()); + } + + @Override + public JSONArray toJsonArray() { + return JSON.parseArray(toString()); + } + + @Override + public T toBean(Class type) { + return JSON.parseObject(toString(), type); + } + + @Override + public List toList(Class type) { + return JSON.parseArray(toString(), type); + } + + @Override + public Download toFile(String filePath) { + return toFile(new File(filePath)); + } + + @Override + public Download toFile(File file) { + if (taskExecutor == null) { + throw new IllegalStateException("没有 taskExecutor， 不可进行下载操作！"); + } + if (!file.exists()) { + try { + File parent = file.getParentFile(); + if (!parent.exists()) { + parent.mkdirs(); + } + file.createNewFile(); + } catch (IOException e) { + response.close(); + throw new HttpException( + "Cannot create file [" + file.getAbsolutePath() + "]", e); + } + } + return taskExecutor.download(httpTask, file, toByteStream(), + getRangeStart()); + } + + @Override + public Download toFolder(String dirPath) { + String fileName = resolveFileName(); + String filePath = resolveFilePath(dirPath, fileName); + int index = 0; + File file = new File(filePath); + while (file.exists()) { + String indexFileName = indexFileName(fileName, index++); + filePath = resolveFilePath(dirPath, indexFileName); + file = new File(filePath); + } + return toFile(file); + } + + @Override + public Download toFolder(File dir) { + if (dir.exists() && !dir.isDirectory()) { + response.close(); + throw new HttpException("文件下载失败：文件[" + dir.getAbsolutePath() + "]已存在，并且不是一个目录！"); + } + if (!dir.exists()) { + dir.mkdirs(); + } + return toFolder(dir.getAbsolutePath()); + } + + @Override + public Body cache() { + if (onProcess != null) { + throw new IllegalStateException("设置了下载进度回调，不可再开启缓存！"); + } + cached = true; + return this; + } + + @Override + public Body close() { + response.close(); + data = null; + return this; + } + + private byte[] cacheBytes() { + if (data == null) { + data = bodyToBytes(); + } + return data; + } + + private byte[] bodyToBytes() { + if (onProcess != null) { + Buffer buffer = new Buffer(); + try { + return buffer.readFrom(toByteStream()).readByteArray(); + } catch (IOException e) { + throw new HttpException("报文体转化字节数组出错", e); + } finally { + response.close(); + buffer.close(); + } + } + try { + return response.body().bytes(); + } catch (IOException e) { + throw new HttpException("报文体转化字节数组出错", e); + } + } + + private long getRangeStart() { + long rangeStart = 0; + if (response.code() != HttpURLConnection.HTTP_PARTIAL) { + return rangeStart; + } + String range = response.header("Content-Range"); + if (range != null && range.startsWith("bytes")) { + int index = range.indexOf('-'); + if (index > 5) { + String start = range.substring(5, index).trim(); + try { + rangeStart = Long.parseLong(start); + } catch (Exception ignore) {} + } + } + return rangeStart; + } + + private String resolveFilePath(String dirPath, String fileName) { + if (dirPath.endsWith("\\") || dirPath.endsWith("/")) { + return dirPath + fileName; + } + return dirPath + "\\" + fileName; + } + + private String indexFileName(String fileName, int index) { + int i = fileName.lastIndexOf('.'); + if (i < 0) { + return fileName + "(" + index + ")"; + } + String ext = fileName.substring(i); + if (i > 0) { + String name = fileName.substring(0, i); + return name + "(" + index + ")" + ext; + } + return "(" + index + ")" + ext; + } + + private String resolveFileName() { + String fileName = response.header("Content-Disposition"); + // 通过Content-Disposition获取文件名，这点跟服务器有关，需要灵活变通 + if (fileName == null || fileName.length() < 1) { + fileName = response.request().url().encodedPath(); + fileName = fileName.substring(fileName.lastIndexOf("/") + 1); + } else { + try { + fileName = URLDecoder.decode(fileName.substring( + fileName.indexOf("filename=") + 9), "UTF-8"); + } catch (UnsupportedEncodingException e) { + throw new HttpException("解码文件名失败", e); + } + // 有些文件名会被包含在""里面，所以要去掉，不然无法读取文件后缀 + fileName = fileName.replaceAll("\"", ""); + } + return fileName; + } + +} diff --git a/src/main/java/com/ejlchina/http/internal/SyncHttpTask.java b/src/main/java/com/ejlchina/http/internal/SyncHttpTask.java new file mode 100644 index 00000000..8ff98b5b --- /dev/null +++ b/src/main/java/com/ejlchina/http/internal/SyncHttpTask.java @@ -0,0 +1,92 @@ +package com.ejlchina.http.internal; + +import java.io.IOException; + +import com.ejlchina.http.HttpResult; +import com.ejlchina.http.HttpResult.State; +import com.ejlchina.http.HttpTask; + +import okhttp3.Call; +import okhttp3.Response; + + +/** + * 同步 Http 请求任务 + * + * @author Troy.Zhou + * + */ +public class SyncHttpTask extends HttpTask { + + public SyncHttpTask(HttpClient client, String url) { + super(client, url); + } + + /** + * 发起 GET 请求 + * @return 请求结果 + */ + public HttpResult get() { + return request("GET"); + } + + /** + * 发起 POST 请求 + * @return 请求结果 + */ + public HttpResult post() { + return request("POST"); + } + + /** + * 发起 PUT 请求 + * @return 请求结果 + */ + public HttpResult put() { + return request("PUT"); + } + + /** + * 发起 DELETE 请求 + * @return 请求结果 + */ + public HttpResult delete() { + return request("DELETE"); + } + + private HttpResult request(String method) { + RealHttpResult result = new RealHttpResult(this, httpClient.getExecutor()); + httpClient.preprocess(this, () -> { + Call call = prepareCall(method); + try { + Response response = call.execute(); + synchronized (SyncHttpTask.this) { + result.response(response); + SyncHttpTask.this.notify(); + } + } catch (IOException e) { + State state = toState(e); + synchronized (SyncHttpTask.this) { + result.exception(state, e); + SyncHttpTask.this.notify(); + } + } + }); + synchronized (this) { + if (result.getState() == null) { + try { + SyncHttpTask.this.wait(); + } catch (InterruptedException e) { + throw new HttpException("等待异常", e); + } + } + } + Exception e = result.getError(); + if (e != null && result.getState() != State.CANCELED + && !nothrow) { + throw new HttpException("请求执行异常", e); + } + return result; + } + +} diff --git a/src/main/java/com/ejlchina/http/internal/TaskExecutor.java b/src/main/java/com/ejlchina/http/internal/TaskExecutor.java new file mode 100644 index 00000000..419bc56c --- /dev/null +++ b/src/main/java/com/ejlchina/http/internal/TaskExecutor.java @@ -0,0 +1,98 @@ +package com.ejlchina.http.internal; + +import java.io.File; +import java.io.IOException; +import java.io.InputStream; +import java.util.concurrent.Executor; + +import com.ejlchina.http.DownListener; +import com.ejlchina.http.Download; +import com.ejlchina.http.HttpResult; +import com.ejlchina.http.HttpResult.State; +import com.ejlchina.http.HttpTask; +import com.ejlchina.http.OnCallback; +import com.ejlchina.http.TaskListener; + +public class TaskExecutor { + + private Executor ioExecutor; + private Executor mainExecutor; + private DownListener downloadListener; + private TaskListener responseListener; + private TaskListener exceptionListener; + private TaskListener completeListener; + + public TaskExecutor(Executor ioExecutor, Executor mainExecutor, DownListener downloadListener, + TaskListener responseListener, TaskListener exceptionListener, + TaskListener completeListener) { + this.ioExecutor = ioExecutor; + this.mainExecutor = mainExecutor; + this.downloadListener = downloadListener; + this.responseListener = responseListener; + this.exceptionListener = exceptionListener; + this.completeListener = completeListener; + } + + public Executor getExecutor(boolean onIoThread) { + if (onIoThread || mainExecutor == null) { + return ioExecutor; + } + return mainExecutor; + } + + public Download download(HttpTask httpTask, File file, InputStream input, long skipBytes) { + Download download = new Download(file, input, this, skipBytes); + if (downloadListener != null) { + downloadListener.listen(httpTask, download); + } + return download; + } + + public void execute(Runnable command, boolean onIoThread) { + Executor executor = ioExecutor; + if (mainExecutor != null && !onIoThread) { + executor = mainExecutor; + } + executor.execute(command); + } + + public void executeOnResponse(HttpTask task, OnCallback onResponse, HttpResult result, boolean onIoThread) { + if (responseListener != null) { + execute(() -> { + if (responseListener.listen(task, result) && onResponse != null) { + onResponse.on(result); + } + }, onIoThread); + } else if (onResponse != null) { + execute(() -> { onResponse.on(result); }, onIoThread); + } + } + + public boolean executeOnException(HttpTask task, OnCallback onException, IOException error, boolean onIoThread) { + if (exceptionListener != null) { + execute(() -> { + if (exceptionListener.listen(task, error) && onException != null) { + onException.on(error); + } + }, onIoThread); + return true; + } else if (onException != null) { + execute(() -> { onException.on(error); }, onIoThread); + return true; + } + return false; + } + + public void executeOnComplete(HttpTask task, OnCallback onComplete, State state, boolean onIoThread) { + if (completeListener != null) { + execute(() -> { + if (completeListener.listen(task, state) && onComplete != null) { + onComplete.on(state); + } + }, onIoThread); + } else if (onComplete != null) { + execute(() -> { onComplete.on(state); }, onIoThread); + } + } + +} diff --git a/src/test/java/com/ejlchina/test/HttpTest.java b/src/test/java/com/ejlchina/test/HttpTest.java new file mode 100644 index 00000000..6573da97 --- /dev/null +++ b/src/test/java/com/ejlchina/test/HttpTest.java @@ -0,0 +1,611 @@ +package com.ejlchina.test; + + +import java.io.File; +import java.io.IOException; +import java.util.List; +import java.util.concurrent.TimeUnit; + +import org.junit.Test; + +import com.ejlchina.http.Download; +import com.ejlchina.http.Download.Ctrl; +import com.ejlchina.http.Download.Failure; +import com.ejlchina.http.HTTP; +import com.ejlchina.http.HttpCall; +import com.ejlchina.http.HttpResult; +import com.ejlchina.http.HttpResult.Body; +import com.ejlchina.http.HttpResult.State; +import com.ejlchina.http.HttpTask; +import com.ejlchina.http.HttpUtils; +import com.ejlchina.http.Preprocessor.PreChain; +import com.ejlchina.http.Process; +import com.ejlchina.http.internal.HttpClient; + +import okhttp3.ConnectionPool; +import okhttp3.Interceptor.Chain; +import okhttp3.OkHttpClient.Builder; +import okhttp3.Request; + + +public class HttpTest { + + + @Test + public void testCache() { + HTTP http = HTTP.builder().build(); + + Body body = http.sync("http://xxx.cdyun.vip/comm/provinces") + .get() + .getBody() + .cache() + ; + + + System.out.println("result = " + body.toString()); + System.out.println("result = " + body.toJsonArray()); + System.out.println("result = " + body.toBytes()); + + body.close(); + + System.out.println("result = " + body.toString()); + System.out.println("result = " + body.toJsonArray()); + System.out.println("result = " + body.toBytes()); + } + + + @Test + public void testGlobalCallback() { + HTTP http = HTTP.builder() + .responseListener((HttpTask task, HttpResult result) -> { + System.out.println("全局 onResponse: " + result.getStatus()); + return true; + }) + .completeListener((HttpTask task, State state) -> { + System.out.println("全局 onComplete: " + state); + return true; + }) + .exceptionListener((HttpTask task, IOException error) -> { + System.out.println("全局 onException: " + error.getMessage()); + return false; + }) + .build(); + + http.async("http://www.baidu.com") + .setOnResponse((HttpResult result) -> { + System.out.println("单例 onResponse: " + result.getStatus()); + }) + .setOnComplete((State state) -> { + System.out.println("单例 onComplete: " + state); + }) + .setOnException((IOException error) -> { + System.out.println("单例 onException: " + error.getMessage()); + }) + .get(); + + sleep(2000); + } + + @Test + public void testDownloadListener() { + HTTP http = HTTP.builder() + .downloadListener((HttpTask task, Download download) -> { + System.out.println("URL = " + task.getUrl()); + System.out.println("TAG = " + task.getTag()); + Ctrl ctrl = download.getCtrl(); + + new Thread(() -> { + sleep(3000); + ctrl.pause(); + sleep(3000); + ctrl.resume(); + sleep(3000); + ctrl.cancel(); + }).start(); + }) + .build(); + + String url = "https://download.cocos.com/CocosDashboard/v1.0.1/CocosDashboard-v1.0.1-win32-031816.exe"; + + long t0 = System.currentTimeMillis(); + + + http.sync(url) + .setTag("ASD") + .get() + .getBody() + .setOnProcess((Process process) -> { + print(t0, process.getDoneBytes() + "/" + process.getTotalBytes() + "\t" + process.getRate(), false); + }) + .setStepRate(0.01) + .toFolder("D:/download/") + .nextOnIO() + .setOnSuccess((File file) -> { + print(t0, "下载成功：" + file.getAbsolutePath(), true); + }) + .setOnFailure((Failure failure) -> { + print(t0, "下载失败：" + failure.getDoneBytes() + ", path = " + failure.getFile().getAbsolutePath(), true); + }) + .start(); + + sleep(20000); + } + + @Test + public void testExecutor() { + HTTP http = HTTP.builder() + .callbackExecutor((Runnable command) -> { + System.out.println("主线程执行"); + command.run(); + }).build(); + + http.async("http://47.100.7.202/ejl-test.zip") + .addBodyParam("name", "Jack") +// .nextOnIO() + .setOnProcess((Process process) -> { + System.out.println("process： " + process.getRate()); + }) +// .nextOnIO() + .setOnResponse((HttpResult result) -> { + System.out.println("status： " + result.close().getStatus()); + }) + .nextOnIO() + .setOnComplete((State state) -> { + System.out.println("state： " + state); + }) + .post(); + + sleep(3000); + } + + + public static void main(String[] args) { + long totalSize = HttpUtils.sync("/download/test.zip").get().getBody() + .close() // 因为这次请求只是为了获得文件大小，不消费报文体，所以直接关闭 + .getContentLength(); + download(totalSize, 0); // 从第 0 块开始下载 + sleep(50000); // 等待下载完成 + } + + static void download(long totalSize, int index) { + long size = 3 * 1024 * 1024; // 每块下载 3M + long start = index * size; + long end = Math.min(start + size, totalSize); + HttpUtils.sync("/download/test.zip") + .setRange(start, end) // 设置本次下载的范围 + .get().getBody() + .toFile("D:/download/test.zip") // 下载到同一个文件里 + .setAppended() // 开启文件追加模式 + .setOnSuccess((File file) -> { + if (end < totalSize) { // 若未下载完，则继续下载下一块 + download(totalSize, index + 1); + } else { + System.out.println("下载完成"); + } + }) + .start(); + } + + + @Test + public void testD() { + System.out.println(Long.parseLong("12")); + } + + + @Test + public void testUpload() { + String data = "0123456789abcdefghijklmnopqrstuvwsyz0123456789abcdefghijklmnopqrstuvwsyz0123456789abcdefghijklmnopqrstuvwsyz0123456789abcdefghijklmnopqrstuvwsyz0123456789abcdefghijklmnopqrstuvwsyz"; + + HTTP http = HTTP.builder().build(); + + long t0 = System.currentTimeMillis(); + + String res = http.sync("http://localhost:8080/test/index") + .addBodyParam("data", data) + .addFileParam("file", "D:\\WorkSpace\\download\\CocosDashboard-v1.0.1-win32-031816.exe") + .setStepRate(0.01) + .setOnProcess((Process process) -> { + print(t0, "上传：" + process.getDoneBytes() + "/" + process.getTotalBytes() + "\t" + process.getRate(), false); + }) + .post() + .getBody() + .setStepBytes(5) + .setOnProcess((Process process) -> { + print(t0, "下载：" + process.getDoneBytes() + "/" + process.getTotalBytes() + "\t" + process.getRate(), false); + }) + .toString(); + + System.out.println("响应：" + res); + } + + @Test + public void testDownload() { + HTTP http = HTTP.builder() + .config((Builder builder) -> { + builder.readTimeout(300, TimeUnit.MILLISECONDS); + }) + .build(); + + String url = "https://download.cocos.com/CocosDashboard/v1.0.1/CocosDashboard-v1.0.1-win32-031816.exe"; +// String url = "http://47.100.7.202/ejl-test.zip"; + + long t0 = System.currentTimeMillis(); + +// Ctrl ctrl = + http.sync(url) +// .setRange(24771214) + .bind(this) + .get() + .getBody() + .setOnProcess((Process process) -> { + print(t0, process.getDoneBytes() + "/" + process.getTotalBytes() + "\t" + process.getRate(), false); + }) + .setStepRate(0.1) + .toFolder("D:/WorkSpace/download/") +// .toFile("D:\\WorkSpace\\download\\CocosDashboard-v1.0.1-win32-031816(9).exe") +// .setAppended() // 启用 断点续传 + .nextOnIO() + .setOnSuccess((File file) -> { + print(t0, "下载成功：" + file.getAbsolutePath(), true); + }) + .setOnFailure((Failure failure) -> { + print(t0, "下载失败：" + failure.getDoneBytes() + ", path = " + failure.getFile().getAbsolutePath(), true); + }) + .start(); + + sleep(10000); + +// ctrl.status(); +// ctrl.pause(); +// System.out.println("暂停"); +// sleep(5000); +// +// ctrl.resume(); +// System.out.println("继续"); +// sleep(5000); +// +// ctrl.cancel(); +// System.out.println("取消"); + + +// + +// +// ctrl.pause(); +// System.out.println("暂停"); +// sleep(5000); +// +// ctrl.resume(); +// System.out.println("继续"); + sleep(5000); + + } + + void print(long t0, String str, boolean ln) { + long now = System.currentTimeMillis() - t0; + System.out.println((now) + "\t" + str); + if (ln) { + System.out.println(); + } + } + + long now(long t0) { + return System.currentTimeMillis() - t0; + } + + + @Test + public void testToList() { + long t0 = System.currentTimeMillis(); + + HTTP http = HTTP.builder() + .baseUrl("http://xxx.cdyun.vip/ejlchina") + .build(); + + HttpResult result = http.sync("/comm/provinces") + .setRange(0) + .get(); + + print(t0, "status: " + result.getStatus(), true); + print(t0, "headers: " + result.getHeaders(), true); + + Body body = result.getBody(); + + print(t0, "total: " + body.getContentLength(), true); + + List list = body.setStepRate(0.1) + .setOnProcess((Process process) -> { + print(t0, process.getDoneBytes() + "/" + process.getTotalBytes() + "\t" + process.getRate(), false); + }) + .toList(User.class); + + print(t0, list.toString(), false); + } + + + @Test + public void testPreprocessor() { + + HTTP http = HTTP.builder() + .baseUrl("http://localhost:8080") + .addPreprocessor((PreChain chain) -> { + System.out.println("并行预处理-开始"); +// new Thread(() -> { + sleep(2000); + System.out.println("并行预处理-结束"); + chain.proceed(); +// }).start(); + }) + .addSerialPreprocessor((PreChain chain) -> { + System.out.println("串行预处理-开始"); + new Thread(() -> { + sleep(3000); + System.out.println("串行预处理-结束"); + chain.proceed(); + }).start(); + }) + .build(); + + new Thread(() -> { + System.out.println(http.sync("/user/show/1").get()); + }).start(); + + new Thread(() -> { + System.out.println(http.sync("/user/show/2").get()); + }).start(); + +// new Thread(() -> { +// http.async("/user/show/1") +// .setOnResponse((HttpResult result) -> { +// System.out.println(result); +// }) +// .get(); +// }).start(); +// +// new Thread(() -> { +// http.async("/user/show/2") +// .setOnResponse((HttpResult result) -> { +// System.out.println(result); +// }) +// .get(); +// }).start(); + + sleep(10000); + } + + + + @Test + public void testCancel() { + + HTTP http = HTTP.builder() + .baseUrl("http://localhost:8080") + .build(); + + http.async("/user/show/1") + .setOnResponse((HttpResult result) -> { + System.out.println(result); + }) + .setOnException((IOException e) -> { + System.out.println("异常捕获：" + e.getMessage()); + }) + .setOnComplete((State state) -> { + System.out.println(state); + }) + .setTag("A") + .get(); + + System.out.println(((HttpClient) http).getTagCallCount()); + + http.async("/user/show/2") + .setOnResponse((HttpResult result) -> { + System.out.println(result); + }) + .setTag("A.B") + .get(); + + System.out.println(((HttpClient) http).getTagCallCount()); + + http.async("/user/show/3") + .setOnResponse((HttpResult result) -> { + System.out.println(result); + }) + .setTag("B.C") + .get(); + + System.out.println(((HttpClient) http).getTagCallCount()); + + http.async("/user/show/4") + .setOnResponse((HttpResult result) -> { + System.out.println(result); + }) + .setTag("C") + .get(); + + System.out.println(((HttpClient) http).getTagCallCount()); + + + System.out.println("标签取消：" + http.cancel("B")); + + System.out.println(((HttpClient) http).getTagCallCount()); + + sleep(5000); + + System.out.println(((HttpClient) http).getTagCallCount()); + + sleep(5000); + + System.out.println(((HttpClient) http).getTagCallCount()); + + sleep(5000); + + System.out.println(((HttpClient) http).getTagCallCount()); + +// System.out.println("isDone = " + call.isDone()); +// System.out.println("isCanceled = " + call.isCanceled()); +// +// System.out.println("取消结果 = " + call.cancel()); +// +// System.out.println("isDone = " + call.isDone()); +// System.out.println("isCanceled = " + call.isCanceled()); +// +// sleep(100); +// System.out.println("++++++++"); +// +// System.out.println("isDone = " + call.isDone()); +// System.out.println("isCanceled = " + call.isCanceled()); + } + + + + + private HTTP buildHttp() { + + return HTTP.builder() + .config((Builder builder) -> { + + // 配置连接池 最小10个连接（不配置默认为 5） + builder.connectionPool(new ConnectionPool(10, 5, TimeUnit.MINUTES)); + + // 配置连接超时时间 + builder.connectTimeout(20, TimeUnit.SECONDS); + + builder.addInterceptor((Chain chain) -> { + + Request request = chain.request(); + + return chain.proceed(request); + }); + }) + .baseUrl("http://localhost:8080") + .callbackExecutor((Runnable run) -> { + runOnUiThread(run); + }) + .addPreprocessor((PreChain chain) -> { + new Thread(() -> { + try { + Thread.sleep(100); + } catch (InterruptedException e) { + e.printStackTrace(); + } + chain.getTask().addHeader("Token", "yyyyy"); + + chain.proceed(); + + }).start(); + }) + .addPreprocessor((PreChain chain) -> { + new Thread(() -> { + + chain.getTask().addUrlParam("actor", "Alice"); + + chain.proceed(); + + }).start(); + }) + .build(); + + } + + + @Test + public void syncHttpExample() { + + HTTP http = buildHttp(); + // 同步请求 + HttpResult result = http.sync("https://timgsa.baidu.com/timg?image&quality=80&size=b9999_10000&sec=1584365400942&di=d9e7890f13b7bc4b76080fdd490ed5d5&imgtype=0&src=http%3A%2F%2Ft8.baidu.com%2Fit%2Fu%3D1484500186%2C1503043093%26fm%3D79%26app%3D86%26f%3DJPEG%3Fw%3D1280%26h%3D853") + .get(); + + result.getBody().toFile("E:/3.jpg"); +// // 得到状态码 +// int status = result.getStatus(); +// +// // 得到返回头 +// Headers headers = result.getHeaders(); +// +// User user = result.getBody().toBean(User.class); +// // 得到目标数据 +// +// +// System.out.println("status = " + status); +// System.out.println("headers = " + headers); +// System.out.println("user = " + user); + + System.out.println("status = " + result.getStatus()); + + } + + + @Test + public void syncJsonExample() { + HTTP http = buildHttp(); + // 同步请求 + HttpResult result = http.sync("/user/save") + .addJsonParam("name", "Tom") + .addJsonParam("age", 23) + .post(); + + System.out.println("result = " + result); + + result = http.sync("/user/show/1").get(); + + System.out.println("result = " + result); + + System.out.println("isSuccessful = " + result.isSuccessful()); + } + + @Test + public void asyncHttpExample() throws InterruptedException { + HTTP http = buildHttp(); + // 异步请求 + // 最终路径 http://api.demo.com/users/2 + HttpCall call = http.async("/user/show/{id}") + // 设置路径参数 + .addPathParam("id", 2) + // 设置回调函数 + .setOnResponse((HttpResult result) -> { + System.out.println("000"); +// User user = result.getBody().toBean(User.class); +// System.out.println("user = " + user); + }) + .setOnException((IOException e) -> { + e.printStackTrace(); + }) + // 发起 GET 请求 + .get(); + + Thread.sleep(150); + + System.out.println("是否完成: " + call.isDone()); + System.out.println("是否取消: " + call.isCanceled()); + + call.cancel(); // 取消请求 + + System.out.println("是否取消: " + call.isCanceled()); + System.out.println("执行结果: " + call.getResult()); + System.out.println("是否完成: " + call.isDone()); +// + Thread.sleep(100); +// +// System.out.println("是否完成: " + call.isDone()); +// System.out.println("是否取消: " + call.isCanceled()); +// System.out.println("执行状态: " + call.getResult()); + + } + + + private static void sleep(int millis) { + try { + Thread.sleep(millis); + } catch (InterruptedException e) { + e.printStackTrace(); + } + } + + + static void runOnUiThread(Runnable run) { + run.run(); + } + +} diff --git a/src/test/java/com/ejlchina/test/User.java b/src/test/java/com/ejlchina/test/User.java new file mode 100644 index 00000000..bdf75c9d --- /dev/null +++ b/src/test/java/com/ejlchina/test/User.java @@ -0,0 +1,27 @@ +package com.ejlchina.test; + +public class User { + + int id; + String name; + + public void setId(int id) { + this.id = id; + } + public void setName(String name) { + this.name = name; + } + + public int getId() { + return id; + } + public String getName() { + return name; + } + + @Override + public String toString() { + return "User [id=" + id + ", name=" + name + "]"; + } + +} From b77323a58c6dfe593a0203ac2dc15018a220c6df Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?=E5=91=A8=E6=97=AD?= Date: Tue, 31 Mar 2020 14:27:16 +0800 Subject: [PATCH 003/924] =?UTF-8?q?=E6=8A=A5=E5=90=8D=E9=87=8D=E6=9E=84?= =?UTF-8?q?=EF=BC=9Acom.ejlchina.http=20->=20com.ejlchina.okhttps?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- .../{http => okhttps}/Configurator.java | 2 +- .../{http => okhttps}/DownListener.java | 2 +- .../ejlchina/{http => okhttps}/Download.java | 6 ++--- .../com/ejlchina/{http => okhttps}/HTTP.java | 10 +++---- .../ejlchina/{http => okhttps}/HttpCall.java | 2 +- .../{http => okhttps}/HttpResult.java | 6 ++--- .../ejlchina/{http => okhttps}/HttpTask.java | 10 +++---- .../ejlchina/{http => okhttps}/HttpUtils.java | 8 +++--- .../{http => okhttps}/OnCallback.java | 2 +- .../{http => okhttps}/Preprocessor.java | 2 +- .../ejlchina/{http => okhttps}/Process.java | 2 +- .../{http => okhttps}/TaskListener.java | 2 +- .../internal/AsyncHttpTask.java | 12 ++++----- .../internal/HttpClient.java | 20 +++++++------- .../internal/HttpException.java | 2 +- .../internal/ProcessInputStream.java | 6 ++--- .../internal/ProcessRequestBody.java | 6 ++--- .../internal/RealHttpResult.java | 6 ++--- .../internal/RealProcess.java | 4 +-- .../internal/ResultBody.java | 12 ++++----- .../internal/SyncHttpTask.java | 8 +++--- .../internal/TaskExecutor.java | 16 ++++++------ src/test/java/com/ejlchina/test/HttpTest.java | 26 +++++++++---------- 23 files changed, 86 insertions(+), 86 deletions(-) rename src/main/java/com/ejlchina/{http => okhttps}/Configurator.java (88%) rename src/main/java/com/ejlchina/{http => okhttps}/DownListener.java (89%) rename src/main/java/com/ejlchina/{http => okhttps}/Download.java (97%) rename src/main/java/com/ejlchina/{http => okhttps}/HTTP.java (84%) rename src/main/java/com/ejlchina/{http => okhttps}/HttpCall.java (94%) rename src/main/java/com/ejlchina/{http => okhttps}/HttpResult.java (97%) rename src/main/java/com/ejlchina/{http => okhttps}/HttpTask.java (98%) rename src/main/java/com/ejlchina/{http => okhttps}/HttpUtils.java (92%) rename src/main/java/com/ejlchina/{http => okhttps}/OnCallback.java (80%) rename src/main/java/com/ejlchina/{http => okhttps}/Preprocessor.java (94%) rename src/main/java/com/ejlchina/{http => okhttps}/Process.java (92%) rename src/main/java/com/ejlchina/{http => okhttps}/TaskListener.java (91%) rename src/main/java/com/ejlchina/{http => okhttps}/internal/AsyncHttpTask.java (96%) rename src/main/java/com/ejlchina/{http => okhttps}/internal/HttpClient.java (96%) rename src/main/java/com/ejlchina/{http => okhttps}/internal/HttpException.java (91%) rename src/main/java/com/ejlchina/{http => okhttps}/internal/ProcessInputStream.java (90%) rename src/main/java/com/ejlchina/{http => okhttps}/internal/ProcessRequestBody.java (95%) rename src/main/java/com/ejlchina/{http => okhttps}/internal/RealHttpResult.java (95%) rename src/main/java/com/ejlchina/{http => okhttps}/internal/RealProcess.java (91%) rename src/main/java/com/ejlchina/{http => okhttps}/internal/ResultBody.java (97%) rename src/main/java/com/ejlchina/{http => okhttps}/internal/SyncHttpTask.java (92%) rename src/main/java/com/ejlchina/{http => okhttps}/internal/TaskExecutor.java (89%) diff --git a/src/main/java/com/ejlchina/http/Configurator.java b/src/main/java/com/ejlchina/okhttps/Configurator.java similarity index 88% rename from src/main/java/com/ejlchina/http/Configurator.java rename to src/main/java/com/ejlchina/okhttps/Configurator.java index c76a5a85..54f954ad 100644 --- a/src/main/java/com/ejlchina/http/Configurator.java +++ b/src/main/java/com/ejlchina/okhttps/Configurator.java @@ -1,4 +1,4 @@ -package com.ejlchina.http; +package com.ejlchina.okhttps; import okhttp3.OkHttpClient.Builder; diff --git a/src/main/java/com/ejlchina/http/DownListener.java b/src/main/java/com/ejlchina/okhttps/DownListener.java similarity index 89% rename from src/main/java/com/ejlchina/http/DownListener.java rename to src/main/java/com/ejlchina/okhttps/DownListener.java index 7802013a..53cbebed 100644 --- a/src/main/java/com/ejlchina/http/DownListener.java +++ b/src/main/java/com/ejlchina/okhttps/DownListener.java @@ -1,4 +1,4 @@ -package com.ejlchina.http; +package com.ejlchina.okhttps; /** * 下载监听接口 diff --git a/src/main/java/com/ejlchina/http/Download.java b/src/main/java/com/ejlchina/okhttps/Download.java similarity index 97% rename from src/main/java/com/ejlchina/http/Download.java rename to src/main/java/com/ejlchina/okhttps/Download.java index c7ef89bd..87764862 100644 --- a/src/main/java/com/ejlchina/http/Download.java +++ b/src/main/java/com/ejlchina/okhttps/Download.java @@ -1,4 +1,4 @@ -package com.ejlchina.http; +package com.ejlchina.okhttps; import java.io.File; import java.io.FileNotFoundException; @@ -6,8 +6,8 @@ import java.io.InputStream; import java.io.RandomAccessFile; -import com.ejlchina.http.internal.HttpException; -import com.ejlchina.http.internal.TaskExecutor; +import com.ejlchina.okhttps.internal.HttpException; +import com.ejlchina.okhttps.internal.TaskExecutor; import okhttp3.internal.Util; diff --git a/src/main/java/com/ejlchina/http/HTTP.java b/src/main/java/com/ejlchina/okhttps/HTTP.java similarity index 84% rename from src/main/java/com/ejlchina/http/HTTP.java rename to src/main/java/com/ejlchina/okhttps/HTTP.java index b8fc7c4b..2f6a54df 100644 --- a/src/main/java/com/ejlchina/http/HTTP.java +++ b/src/main/java/com/ejlchina/okhttps/HTTP.java @@ -1,9 +1,9 @@ -package com.ejlchina.http; +package com.ejlchina.okhttps; -import com.ejlchina.http.internal.AsyncHttpTask; -import com.ejlchina.http.internal.SyncHttpTask; -import com.ejlchina.http.internal.TaskExecutor; -import com.ejlchina.http.internal.HttpClient.Builder; +import com.ejlchina.okhttps.internal.AsyncHttpTask; +import com.ejlchina.okhttps.internal.SyncHttpTask; +import com.ejlchina.okhttps.internal.TaskExecutor; +import com.ejlchina.okhttps.internal.HttpClient.Builder; import okhttp3.Call; import okhttp3.Request; diff --git a/src/main/java/com/ejlchina/http/HttpCall.java b/src/main/java/com/ejlchina/okhttps/HttpCall.java similarity index 94% rename from src/main/java/com/ejlchina/http/HttpCall.java rename to src/main/java/com/ejlchina/okhttps/HttpCall.java index 940d5749..8a59cd14 100644 --- a/src/main/java/com/ejlchina/http/HttpCall.java +++ b/src/main/java/com/ejlchina/okhttps/HttpCall.java @@ -1,4 +1,4 @@ -package com.ejlchina.http; +package com.ejlchina.okhttps; public interface HttpCall { diff --git a/src/main/java/com/ejlchina/http/HttpResult.java b/src/main/java/com/ejlchina/okhttps/HttpResult.java similarity index 97% rename from src/main/java/com/ejlchina/http/HttpResult.java rename to src/main/java/com/ejlchina/okhttps/HttpResult.java index f1d67b8a..c3d51d96 100644 --- a/src/main/java/com/ejlchina/http/HttpResult.java +++ b/src/main/java/com/ejlchina/okhttps/HttpResult.java @@ -1,4 +1,4 @@ -package com.ejlchina.http; +package com.ejlchina.okhttps; import java.io.File; import java.io.InputStream; @@ -7,8 +7,8 @@ import com.alibaba.fastjson.JSONArray; import com.alibaba.fastjson.JSONObject; -import com.ejlchina.http.internal.RealHttpResult; -import com.ejlchina.http.internal.TaskExecutor; +import com.ejlchina.okhttps.internal.RealHttpResult; +import com.ejlchina.okhttps.internal.TaskExecutor; import okhttp3.Headers; import okhttp3.MediaType; diff --git a/src/main/java/com/ejlchina/http/HttpTask.java b/src/main/java/com/ejlchina/okhttps/HttpTask.java similarity index 98% rename from src/main/java/com/ejlchina/http/HttpTask.java rename to src/main/java/com/ejlchina/okhttps/HttpTask.java index 04ccf72c..ae6067be 100644 --- a/src/main/java/com/ejlchina/http/HttpTask.java +++ b/src/main/java/com/ejlchina/okhttps/HttpTask.java @@ -1,4 +1,4 @@ -package com.ejlchina.http; +package com.ejlchina.okhttps; import java.io.File; import java.io.IOException; @@ -10,10 +10,10 @@ import java.util.Map; import com.alibaba.fastjson.JSON; -import com.ejlchina.http.HttpResult.State; -import com.ejlchina.http.internal.HttpClient; -import com.ejlchina.http.internal.HttpException; -import com.ejlchina.http.internal.ProcessRequestBody; +import com.ejlchina.okhttps.HttpResult.State; +import com.ejlchina.okhttps.internal.HttpClient; +import com.ejlchina.okhttps.internal.HttpException; +import com.ejlchina.okhttps.internal.ProcessRequestBody; import okhttp3.Call; import okhttp3.FormBody; diff --git a/src/main/java/com/ejlchina/http/HttpUtils.java b/src/main/java/com/ejlchina/okhttps/HttpUtils.java similarity index 92% rename from src/main/java/com/ejlchina/http/HttpUtils.java rename to src/main/java/com/ejlchina/okhttps/HttpUtils.java index f7b7ccb5..96dca13d 100644 --- a/src/main/java/com/ejlchina/http/HttpUtils.java +++ b/src/main/java/com/ejlchina/okhttps/HttpUtils.java @@ -1,8 +1,8 @@ -package com.ejlchina.http; +package com.ejlchina.okhttps; -import com.ejlchina.http.internal.AsyncHttpTask; -import com.ejlchina.http.internal.SyncHttpTask; -import com.ejlchina.http.internal.TaskExecutor; +import com.ejlchina.okhttps.internal.AsyncHttpTask; +import com.ejlchina.okhttps.internal.SyncHttpTask; +import com.ejlchina.okhttps.internal.TaskExecutor; import okhttp3.Call; import okhttp3.Request; diff --git a/src/main/java/com/ejlchina/http/OnCallback.java b/src/main/java/com/ejlchina/okhttps/OnCallback.java similarity index 80% rename from src/main/java/com/ejlchina/http/OnCallback.java rename to src/main/java/com/ejlchina/okhttps/OnCallback.java index 32dd81e8..bfeeaa3e 100644 --- a/src/main/java/com/ejlchina/http/OnCallback.java +++ b/src/main/java/com/ejlchina/okhttps/OnCallback.java @@ -1,4 +1,4 @@ -package com.ejlchina.http; +package com.ejlchina.okhttps; /** * 数据回调接口 diff --git a/src/main/java/com/ejlchina/http/Preprocessor.java b/src/main/java/com/ejlchina/okhttps/Preprocessor.java similarity index 94% rename from src/main/java/com/ejlchina/http/Preprocessor.java rename to src/main/java/com/ejlchina/okhttps/Preprocessor.java index ee2f757c..d0f6f96c 100644 --- a/src/main/java/com/ejlchina/http/Preprocessor.java +++ b/src/main/java/com/ejlchina/okhttps/Preprocessor.java @@ -1,4 +1,4 @@ -package com.ejlchina.http; +package com.ejlchina.okhttps; /** * 预处理器，支持异步 diff --git a/src/main/java/com/ejlchina/http/Process.java b/src/main/java/com/ejlchina/okhttps/Process.java similarity index 92% rename from src/main/java/com/ejlchina/http/Process.java rename to src/main/java/com/ejlchina/okhttps/Process.java index aff09bd3..6f36f827 100644 --- a/src/main/java/com/ejlchina/http/Process.java +++ b/src/main/java/com/ejlchina/okhttps/Process.java @@ -1,4 +1,4 @@ -package com.ejlchina.http; +package com.ejlchina.okhttps; /** * 进度（上传或下载） diff --git a/src/main/java/com/ejlchina/http/TaskListener.java b/src/main/java/com/ejlchina/okhttps/TaskListener.java similarity index 91% rename from src/main/java/com/ejlchina/http/TaskListener.java rename to src/main/java/com/ejlchina/okhttps/TaskListener.java index 90c2ada2..54f734d1 100644 --- a/src/main/java/com/ejlchina/http/TaskListener.java +++ b/src/main/java/com/ejlchina/okhttps/TaskListener.java @@ -1,4 +1,4 @@ -package com.ejlchina.http; +package com.ejlchina.okhttps; /** * 任务监听接口 diff --git a/src/main/java/com/ejlchina/http/internal/AsyncHttpTask.java b/src/main/java/com/ejlchina/okhttps/internal/AsyncHttpTask.java similarity index 96% rename from src/main/java/com/ejlchina/http/internal/AsyncHttpTask.java rename to src/main/java/com/ejlchina/okhttps/internal/AsyncHttpTask.java index c55985a8..cadc760c 100644 --- a/src/main/java/com/ejlchina/http/internal/AsyncHttpTask.java +++ b/src/main/java/com/ejlchina/okhttps/internal/AsyncHttpTask.java @@ -1,12 +1,12 @@ -package com.ejlchina.http.internal; +package com.ejlchina.okhttps.internal; import java.io.IOException; -import com.ejlchina.http.HttpCall; -import com.ejlchina.http.HttpResult; -import com.ejlchina.http.HttpResult.State; -import com.ejlchina.http.HttpTask; -import com.ejlchina.http.OnCallback; +import com.ejlchina.okhttps.HttpCall; +import com.ejlchina.okhttps.HttpResult; +import com.ejlchina.okhttps.HttpTask; +import com.ejlchina.okhttps.OnCallback; +import com.ejlchina.okhttps.HttpResult.State; import okhttp3.Call; import okhttp3.Callback; diff --git a/src/main/java/com/ejlchina/http/internal/HttpClient.java b/src/main/java/com/ejlchina/okhttps/internal/HttpClient.java similarity index 96% rename from src/main/java/com/ejlchina/http/internal/HttpClient.java rename to src/main/java/com/ejlchina/okhttps/internal/HttpClient.java index 6d224c45..cdc0c85e 100644 --- a/src/main/java/com/ejlchina/http/internal/HttpClient.java +++ b/src/main/java/com/ejlchina/okhttps/internal/HttpClient.java @@ -1,4 +1,4 @@ -package com.ejlchina.http.internal; +package com.ejlchina.okhttps.internal; import java.io.IOException; import java.util.ArrayList; @@ -11,15 +11,15 @@ import java.util.Queue; import java.util.concurrent.Executor; -import com.ejlchina.http.Configurator; -import com.ejlchina.http.DownListener; -import com.ejlchina.http.HTTP; -import com.ejlchina.http.HttpCall; -import com.ejlchina.http.HttpResult; -import com.ejlchina.http.HttpResult.State; -import com.ejlchina.http.HttpTask; -import com.ejlchina.http.Preprocessor; -import com.ejlchina.http.TaskListener; +import com.ejlchina.okhttps.Configurator; +import com.ejlchina.okhttps.DownListener; +import com.ejlchina.okhttps.HTTP; +import com.ejlchina.okhttps.HttpCall; +import com.ejlchina.okhttps.HttpResult; +import com.ejlchina.okhttps.HttpTask; +import com.ejlchina.okhttps.Preprocessor; +import com.ejlchina.okhttps.TaskListener; +import com.ejlchina.okhttps.HttpResult.State; import okhttp3.Call; import okhttp3.MediaType; diff --git a/src/main/java/com/ejlchina/http/internal/HttpException.java b/src/main/java/com/ejlchina/okhttps/internal/HttpException.java similarity index 91% rename from src/main/java/com/ejlchina/http/internal/HttpException.java rename to src/main/java/com/ejlchina/okhttps/internal/HttpException.java index f78606cf..c2bf3f37 100644 --- a/src/main/java/com/ejlchina/http/internal/HttpException.java +++ b/src/main/java/com/ejlchina/okhttps/internal/HttpException.java @@ -1,4 +1,4 @@ -package com.ejlchina.http.internal; +package com.ejlchina.okhttps.internal; /** * Created by 周旭（Troy.Zhou） on 2016/8/30. diff --git a/src/main/java/com/ejlchina/http/internal/ProcessInputStream.java b/src/main/java/com/ejlchina/okhttps/internal/ProcessInputStream.java similarity index 90% rename from src/main/java/com/ejlchina/http/internal/ProcessInputStream.java rename to src/main/java/com/ejlchina/okhttps/internal/ProcessInputStream.java index 779ddc30..77cf2e91 100644 --- a/src/main/java/com/ejlchina/http/internal/ProcessInputStream.java +++ b/src/main/java/com/ejlchina/okhttps/internal/ProcessInputStream.java @@ -1,11 +1,11 @@ -package com.ejlchina.http.internal; +package com.ejlchina.okhttps.internal; import java.io.IOException; import java.io.InputStream; import java.util.concurrent.Executor; -import com.ejlchina.http.OnCallback; -import com.ejlchina.http.Process; +import com.ejlchina.okhttps.OnCallback; +import com.ejlchina.okhttps.Process; public class ProcessInputStream extends InputStream { diff --git a/src/main/java/com/ejlchina/http/internal/ProcessRequestBody.java b/src/main/java/com/ejlchina/okhttps/internal/ProcessRequestBody.java similarity index 95% rename from src/main/java/com/ejlchina/http/internal/ProcessRequestBody.java rename to src/main/java/com/ejlchina/okhttps/internal/ProcessRequestBody.java index 6f406b54..c1f50f55 100644 --- a/src/main/java/com/ejlchina/http/internal/ProcessRequestBody.java +++ b/src/main/java/com/ejlchina/okhttps/internal/ProcessRequestBody.java @@ -1,10 +1,10 @@ -package com.ejlchina.http.internal; +package com.ejlchina.okhttps.internal; import java.io.IOException; import java.util.concurrent.Executor; -import com.ejlchina.http.OnCallback; -import com.ejlchina.http.Process; +import com.ejlchina.okhttps.OnCallback; +import com.ejlchina.okhttps.Process; import okhttp3.MediaType; import okhttp3.RequestBody; diff --git a/src/main/java/com/ejlchina/http/internal/RealHttpResult.java b/src/main/java/com/ejlchina/okhttps/internal/RealHttpResult.java similarity index 95% rename from src/main/java/com/ejlchina/http/internal/RealHttpResult.java rename to src/main/java/com/ejlchina/okhttps/internal/RealHttpResult.java index 697fd4a6..1218e4a0 100644 --- a/src/main/java/com/ejlchina/http/internal/RealHttpResult.java +++ b/src/main/java/com/ejlchina/okhttps/internal/RealHttpResult.java @@ -1,9 +1,9 @@ -package com.ejlchina.http.internal; +package com.ejlchina.okhttps.internal; import java.util.List; -import com.ejlchina.http.HttpResult; -import com.ejlchina.http.HttpTask; +import com.ejlchina.okhttps.HttpResult; +import com.ejlchina.okhttps.HttpTask; import okhttp3.Headers; import okhttp3.Response; diff --git a/src/main/java/com/ejlchina/http/internal/RealProcess.java b/src/main/java/com/ejlchina/okhttps/internal/RealProcess.java similarity index 91% rename from src/main/java/com/ejlchina/http/internal/RealProcess.java rename to src/main/java/com/ejlchina/okhttps/internal/RealProcess.java index 700d2895..895583e3 100644 --- a/src/main/java/com/ejlchina/http/internal/RealProcess.java +++ b/src/main/java/com/ejlchina/okhttps/internal/RealProcess.java @@ -1,6 +1,6 @@ -package com.ejlchina.http.internal; +package com.ejlchina.okhttps.internal; -import com.ejlchina.http.Process; +import com.ejlchina.okhttps.Process; public class RealProcess implements Process { diff --git a/src/main/java/com/ejlchina/http/internal/ResultBody.java b/src/main/java/com/ejlchina/okhttps/internal/ResultBody.java similarity index 97% rename from src/main/java/com/ejlchina/http/internal/ResultBody.java rename to src/main/java/com/ejlchina/okhttps/internal/ResultBody.java index aa827e75..1123668e 100644 --- a/src/main/java/com/ejlchina/http/internal/ResultBody.java +++ b/src/main/java/com/ejlchina/okhttps/internal/ResultBody.java @@ -1,4 +1,4 @@ -package com.ejlchina.http.internal; +package com.ejlchina.okhttps.internal; import static java.nio.charset.StandardCharsets.UTF_8; @@ -17,11 +17,11 @@ import com.alibaba.fastjson.JSON; import com.alibaba.fastjson.JSONArray; import com.alibaba.fastjson.JSONObject; -import com.ejlchina.http.Download; -import com.ejlchina.http.HttpTask; -import com.ejlchina.http.HttpResult.Body; -import com.ejlchina.http.OnCallback; -import com.ejlchina.http.Process; +import com.ejlchina.okhttps.Download; +import com.ejlchina.okhttps.HttpTask; +import com.ejlchina.okhttps.OnCallback; +import com.ejlchina.okhttps.Process; +import com.ejlchina.okhttps.HttpResult.Body; import okhttp3.MediaType; import okhttp3.Response; diff --git a/src/main/java/com/ejlchina/http/internal/SyncHttpTask.java b/src/main/java/com/ejlchina/okhttps/internal/SyncHttpTask.java similarity index 92% rename from src/main/java/com/ejlchina/http/internal/SyncHttpTask.java rename to src/main/java/com/ejlchina/okhttps/internal/SyncHttpTask.java index 8ff98b5b..648c8357 100644 --- a/src/main/java/com/ejlchina/http/internal/SyncHttpTask.java +++ b/src/main/java/com/ejlchina/okhttps/internal/SyncHttpTask.java @@ -1,10 +1,10 @@ -package com.ejlchina.http.internal; +package com.ejlchina.okhttps.internal; import java.io.IOException; -import com.ejlchina.http.HttpResult; -import com.ejlchina.http.HttpResult.State; -import com.ejlchina.http.HttpTask; +import com.ejlchina.okhttps.HttpResult; +import com.ejlchina.okhttps.HttpTask; +import com.ejlchina.okhttps.HttpResult.State; import okhttp3.Call; import okhttp3.Response; diff --git a/src/main/java/com/ejlchina/http/internal/TaskExecutor.java b/src/main/java/com/ejlchina/okhttps/internal/TaskExecutor.java similarity index 89% rename from src/main/java/com/ejlchina/http/internal/TaskExecutor.java rename to src/main/java/com/ejlchina/okhttps/internal/TaskExecutor.java index 419bc56c..fbb164b1 100644 --- a/src/main/java/com/ejlchina/http/internal/TaskExecutor.java +++ b/src/main/java/com/ejlchina/okhttps/internal/TaskExecutor.java @@ -1,17 +1,17 @@ -package com.ejlchina.http.internal; +package com.ejlchina.okhttps.internal; import java.io.File; import java.io.IOException; import java.io.InputStream; import java.util.concurrent.Executor; -import com.ejlchina.http.DownListener; -import com.ejlchina.http.Download; -import com.ejlchina.http.HttpResult; -import com.ejlchina.http.HttpResult.State; -import com.ejlchina.http.HttpTask; -import com.ejlchina.http.OnCallback; -import com.ejlchina.http.TaskListener; +import com.ejlchina.okhttps.DownListener; +import com.ejlchina.okhttps.Download; +import com.ejlchina.okhttps.HttpResult; +import com.ejlchina.okhttps.HttpTask; +import com.ejlchina.okhttps.OnCallback; +import com.ejlchina.okhttps.TaskListener; +import com.ejlchina.okhttps.HttpResult.State; public class TaskExecutor { diff --git a/src/test/java/com/ejlchina/test/HttpTest.java b/src/test/java/com/ejlchina/test/HttpTest.java index 6573da97..e8951dab 100644 --- a/src/test/java/com/ejlchina/test/HttpTest.java +++ b/src/test/java/com/ejlchina/test/HttpTest.java @@ -8,19 +8,19 @@ import org.junit.Test; -import com.ejlchina.http.Download; -import com.ejlchina.http.Download.Ctrl; -import com.ejlchina.http.Download.Failure; -import com.ejlchina.http.HTTP; -import com.ejlchina.http.HttpCall; -import com.ejlchina.http.HttpResult; -import com.ejlchina.http.HttpResult.Body; -import com.ejlchina.http.HttpResult.State; -import com.ejlchina.http.HttpTask; -import com.ejlchina.http.HttpUtils; -import com.ejlchina.http.Preprocessor.PreChain; -import com.ejlchina.http.Process; -import com.ejlchina.http.internal.HttpClient; +import com.ejlchina.okhttps.Download; +import com.ejlchina.okhttps.HTTP; +import com.ejlchina.okhttps.HttpCall; +import com.ejlchina.okhttps.HttpResult; +import com.ejlchina.okhttps.HttpTask; +import com.ejlchina.okhttps.HttpUtils; +import com.ejlchina.okhttps.Process; +import com.ejlchina.okhttps.Download.Ctrl; +import com.ejlchina.okhttps.Download.Failure; +import com.ejlchina.okhttps.HttpResult.Body; +import com.ejlchina.okhttps.HttpResult.State; +import com.ejlchina.okhttps.Preprocessor.PreChain; +import com.ejlchina.okhttps.internal.HttpClient; import okhttp3.ConnectionPool; import okhttp3.Interceptor.Chain; From 09b68905fe90b686572c5f7ed268062439663d00 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?=E5=91=A8=E6=97=AD?= Date: Tue, 31 Mar 2020 14:28:05 +0800 Subject: [PATCH 004/924] name: HttpUtils -> OkHttps, version: 1.0.0 --- pom.xml | 18 +++++++++--------- 1 file changed, 9 insertions(+), 9 deletions(-) diff --git a/pom.xml b/pom.xml index f434d4c5..c322c04d 100644 --- a/pom.xml +++ b/pom.xml @@ -2,9 +2,9 @@ 4.0.0 com.ejlchina - httputils - 2.3.0 - HttpUtils + okhttps + 1.0.0 + OkHttps 1.8 @@ -29,9 +29,9 @@ - scm:git://gitee.com/ejlchina-zhxu/httputils.git - scm:http://gitee.com/ejlchina-zhxu/httputils - https://gitee.com/ejlchina-zhxu/httputils + scm:git://gitee.com/ejlchina-zhxu/okhttps.git + scm:http://gitee.com/ejlchina-zhxu/okhttps + https://gitee.com/ejlchina-zhxu/okhttps v2.2.0 @@ -86,7 +86,7 @@ - httputils + okhttps @@ -157,13 +157,13 @@ - https://gitee.com/ejlchina-zhxu/httputils + https://gitee.com/ejlchina-zhxu/okhttps Http工具包，封装 OkHttp，链式用法、支持异步同步、响应JSON自动解析，回调线程切换、配置灵活、支持URL占位符、支持BaseUrl、外部依赖少、适用 JavaWeb 和 Android，教程全面、简单易用 江苏一键联信息科技有限公司 http://www.ejlchina.com/ - https://gitee.com/ejlchina-zhxu/httputils/issues + https://gitee.com/ejlchina-zhxu/okhttps/issues \ No newline at end of file From 5e2a49147a4924b39fdcc842d35bdac00d6d7eb5 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?=E5=91=A8=E6=97=AD?= Date: Tue, 31 Mar 2020 14:32:38 +0800 Subject: [PATCH 005/924] =?UTF-8?q?HttpUtils=20of=20=E6=96=B9=E6=B3=95?= =?UTF-8?q?=E4=B8=BA=E5=BC=82=E5=B8=B8=E6=A0=A1=E9=AA=8C?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- src/main/java/com/ejlchina/okhttps/HttpUtils.java | 2 ++ 1 file changed, 2 insertions(+) diff --git a/src/main/java/com/ejlchina/okhttps/HttpUtils.java b/src/main/java/com/ejlchina/okhttps/HttpUtils.java index 96dca13d..a03e365f 100644 --- a/src/main/java/com/ejlchina/okhttps/HttpUtils.java +++ b/src/main/java/com/ejlchina/okhttps/HttpUtils.java @@ -36,6 +36,8 @@ public class HttpUtils { public static void of(HTTP http) { if (http != null) { HttpUtils.http = http; + } else { + throw new IllegalArgumentException("Parameter http can not be null!"); } } From 2940751fa88647554f9a5775409ad67266008e51 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?=E5=91=A8=E6=97=AD?= Date: Tue, 31 Mar 2020 15:13:42 +0800 Subject: [PATCH 006/924] =?UTF-8?q?=E4=BF=AE=E6=94=B9=20README.md?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- README.md | 39 +++++++++++++++++++-------------------- 1 file changed, 19 insertions(+), 20 deletions(-) diff --git a/README.md b/README.md index b83e8387..fb708986 100644 --- a/README.md +++ b/README.md @@ -1,12 +1,12 @@ -# HttpUtils +# OkHttps -[![Maven Central](https://maven-badges.herokuapp.com/maven-central/com.ejlchina/httputils/badge.svg)](https://maven-badges.herokuapp.com/maven-central/com.ejlchina/httputils/) -[![License](https://img.shields.io/hexpm/l/plug.svg)](https://gitee.com/ejlchina-zhxu/httputils/blob/master/LICENSE) +[![Maven Central](https://maven-badges.herokuapp.com/maven-central/com.ejlchina/okhttps/badge.svg)](https://maven-badges.herokuapp.com/maven-central/com.ejlchina/okhttps/) +[![License](https://img.shields.io/hexpm/l/plug.svg)](https://gitee.com/ejlchina-zhxu/okhttps/blob/master/LICENSE) [![Troy.Zhou](https://img.shields.io/badge/%E4%BD%9C%E8%80%85-ejlchina-orange.svg)](https://github.com/ejlchina) ## 介绍 -　　HttpUtils 是近期开源的对 OkHttp 轻量封装的框架，它独创的异步预处理器，特色的标签，灵活的上传下载进度监听与过程控制功能，在轻松解决很多原本另人头疼问题的同时，设计上也力求纯粹与优雅。 +　　OkHttps 是近期开源的对 OkHttp3 轻量封装的框架，它独创的异步预处理器，特色的标签，灵活的上传下载进度监听与过程控制功能，在轻松解决很多原本另人头疼问题的同时，设计上也力求纯粹与优雅。 * 链式调用，一点到底 * BaseURL、URL占位符、JSON自动封装与解析 @@ -14,8 +14,7 @@ * 文件上传下载（过程控制、进度监听） * TCP连接池、Http2 -### 当前文档版本[2.3.0]（近期发布到中央仓库） -#### [查阅[2.1.x]点我](https://gitee.com/ejlchina-zhxu/httputils/blob/master/README-2.1.2.md) | [查阅[2.0.x]点我](https://gitee.com/ejlchina-zhxu/httputils/blob/master/README-2.0.0.md) | [查阅[1.0.x]点我](https://gitee.com/ejlchina-zhxu/httputils/blob/1.x/README.md) +### 当前文档版本[1.0.0]（近期发布到中央仓库） ## 目录 @@ -62,13 +61,13 @@ ``` com.ejlchina - httputils - 2.3.0 + okhttps + 1.0.0 ``` ### Gradle -`compile 'com.ejlchina:httputils:2.3.0'` +`compile 'com.ejlchina:okhttps:1.0.0'` ## 使用说明 @@ -345,7 +344,7 @@ HTTP http = HTTP.builder() #### 6.3 配置 OkHttpClient -　　与其他封装 OkHttp 的框架不同，HttpUtils 并不会遮蔽 OkHttp 本身就很好用的功能，如下： +　　与其他封装 OkHttp3 的框架不同，OkHttps 并不会遮蔽 OkHttp3 本身就很好用的功能，如下： ```java HTTP http = HTTP.builder() @@ -391,7 +390,7 @@ HTTP http = HTTP.builder() 　　普通预处理器都是可并行处理的，然而有时我们希望某个预处理器同时只处理一个任务。比如 当`Token`过期时我们需要去刷新获取新`Token`，而刷新`Token`这个操作只能有一个任务去执行，因为如果`n`个任务同时执行的话，那么必有`n-1`个任务刚刷新得到的`Token`可能就立马失效了，而这是我们所不希望的。 -　　为了解决这个问题，HttpUtils 提供了串行预处理器，它可以让 HTTP 任务排好队，一个一个地进入预处理器： +　　为了解决这个问题，OkHttps 提供了串行预处理器，它可以让 HTTP 任务排好队，一个一个地进入预处理器： ```java HTTP http = HTTP.builder() @@ -474,7 +473,7 @@ List users = HttpUtils.sync("/users") ### 8 文件下载 -　　HttpUtils 并没有把文件的下载排除在常规的请求之外，同一套API，它优雅的设计使得下载与常规请求融合的毫无违和感，一个最简单的示例： +　　OkHttps 并没有把文件的下载排除在常规的请求之外，同一套API，它优雅的设计使得下载与常规请求融合的毫无违和感，一个最简单的示例： ```java http.sync("/download/test.zip") @@ -517,7 +516,7 @@ http.sync("/download/test.zip") }) .start(); ``` -　　值得一提的是：由于 HttpUtils 并没有把下载做的很特别，这里设置的进度回调不只对下载文件起用作，即使对响应JSON的常规请求，只要设置了进度回调，它也会告诉你报文接收的进度（提前是服务器响应的报文有`Content-Length`头），例如： +　　值得一提的是：由于 OkHttps 并没有把下载做的很特别，这里设置的进度回调不只对下载文件起用作，即使对响应JSON的常规请求，只要设置了进度回调，它也会告诉你报文接收的进度（提前是服务器响应的报文有`Content-Length`头），例如： ```java List users = http.sync("/users") @@ -562,7 +561,7 @@ http.async("/download/test.zip") #### 8.3 实现断点续传 -　　HttpUtils 对断点续传并没有再做更高层次的封装，因为这是app该去做的事情，它在设计上使各种网络问题的处理变简单的同时力求纯粹。下面的例子可以看到，HttpUtils 通过一个失败回调拿到**断点**，便将复杂的问题变得简单： +　　OkHttps 对断点续传并没有再做更高层次的封装，因为这是app该去做的事情，它在设计上使各种网络问题的处理变简单的同时力求纯粹。下面的例子可以看到，OkHttps 通过一个失败回调拿到**断点**，便将复杂的问题变得简单： ```java http.sync("/download/test.zip") @@ -651,7 +650,7 @@ http.async("/upload") #### 9.1 上传进度监听 -　　HttpUtils 的上传进度监听，监听的是所有请求报文体的发送进度，示例代码： +　　OkHttps 的上传进度监听，监听的是所有请求报文体的发送进度，示例代码： ```java http.sync("/upload") @@ -668,7 +667,7 @@ http.sync("/upload") }) .post() ``` -　　咦！怎么感觉和下载的进度回调的一样？没错！HttpUtils 还是使用同一套API处理上传和下载的进度回调，区别只在于上传是在`get/post`方法之前使用这些API，下载是在`getBody`方法之后使用。很好理解：`get/post`之前是准备发送请求时段，有上传的含义，而`getBody`之后，已是报文响应的时段，当然是下载。 +　　咦！怎么感觉和下载的进度回调的一样？没错！OkHttps 还是使用同一套API处理上传和下载的进度回调，区别只在于上传是在`get/post`方法之前使用这些API，下载是在`getBody`方法之后使用。很好理解：`get/post`之前是准备发送请求时段，有上传的含义，而`getBody`之后，已是报文响应的时段，当然是下载。 #### 9.2 上传过程控制 @@ -688,11 +687,11 @@ call.cancel(); // 取消上传 ### 10 执行线程自由切换（for Android） -　　在 Android 开发中，经常会把某些代码放到特点的线程去执行，比如网络请求响应后的页面更新在主线程（UI线程）执行，而保存文件则在IO线程操作。HttpUtils 为这类问题提供了良好的方案。 +　　在 Android 开发中，经常会把某些代码放到特点的线程去执行，比如网络请求响应后的页面更新在主线程（UI线程）执行，而保存文件则在IO线程操作。OkHttps 为这类问题提供了良好的方案。 -　　在 **默认** 情况下，**所有回调** 函数都会 **在 IO 线程** 执行。为什么会设计如此呢？这是因为 HttpUtils 只是纯粹的 Java 领域 Http工具包，本身对 Android 不会有任何依赖，因此也不知 Android 的 UI 线程为何物。这么设计也让它在 Android 之外有更多的可能性。 +　　在 **默认** 情况下，**所有回调** 函数都会 **在 IO 线程** 执行。为什么会设计如此呢？这是因为 OkHttps 只是纯粹的 Java 领域 Http工具包，本身对 Android 不会有任何依赖，因此也不知 Android 的 UI 线程为何物。这么设计也让它在 Android 之外有更多的可能性。 -　　但是在 Android 里使用 HttpUtils 的话，UI线程的问题能否优雅的解决呢？当然可以！简单粗暴的方法就是配置一个 回调执行器： +　　但是在 Android 里使用 OkHttps 的话，UI线程的问题能否优雅的解决呢？当然可以！简单粗暴的方法就是配置一个 回调执行器： ```java HTTP http = HTTP.builder() @@ -721,7 +720,7 @@ http.async("/users") }) .post(); ``` -　　但是，如果同时还想让某些回调放在IO线程，实现 **自由切换**，怎么办呢?HttpUtils 给出了非常灵活的方法，如下： +　　但是，如果同时还想让某些回调放在IO线程，实现 **自由切换**，怎么办呢？OkHttps 给出了非常灵活的方法，如下： ```java http.async("/users") From 869c2917f8366a61b996a09dc2f4aba18816201f Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?=E5=91=A8=E6=97=AD?= Date: Tue, 31 Mar 2020 16:13:15 +0800 Subject: [PATCH 007/924] readme --- README.md | 1 + 1 file changed, 1 insertion(+) diff --git a/README.md b/README.md index fb708986..975d597d 100644 --- a/README.md +++ b/README.md @@ -14,6 +14,7 @@ * 文件上传下载（过程控制、进度监听） * TCP连接池、Http2 +### 前身：[HttpUtils, V2.3.0 之后重命名为 OkHttps](https://gitee.com/ejlchina-zhxu/httputils) ### 当前文档版本[1.0.0]（近期发布到中央仓库） ## 目录 From c37f31fa75868fb4ca5424a08431ffb0cfe6cc39 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?=E5=91=A8=E6=97=AD?= Date: Tue, 31 Mar 2020 16:14:57 +0800 Subject: [PATCH 008/924] readme --- README.md | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/README.md b/README.md index 975d597d..6a00fcec 100644 --- a/README.md +++ b/README.md @@ -14,7 +14,7 @@ * 文件上传下载（过程控制、进度监听） * TCP连接池、Http2 -### 前身：[HttpUtils, V2.3.0 之后重命名为 OkHttps](https://gitee.com/ejlchina-zhxu/httputils) +### 前世：[HttpUtils, V2.3.0 之后重命名为 OkHttps](https://gitee.com/ejlchina-zhxu/httputils) ### 当前文档版本[1.0.0]（近期发布到中央仓库） ## 目录 From e53ca139c42b4252ab6232c9dfe1f6656b833bdf Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?=E5=91=A8=E6=97=AD?= Date: Tue, 31 Mar 2020 16:19:23 +0800 Subject: [PATCH 009/924] . --- README.md | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/README.md b/README.md index 6a00fcec..bb89e92d 100644 --- a/README.md +++ b/README.md @@ -15,7 +15,7 @@ * TCP连接池、Http2 ### 前世：[HttpUtils, V2.3.0 之后重命名为 OkHttps](https://gitee.com/ejlchina-zhxu/httputils) -### 当前文档版本[1.0.0]（近期发布到中央仓库） +### 当前文档版本[1.0.0] ## 目录 From 3f0cfca90433208ae0deed9f3670533e0f64b4e3 Mon Sep 17 00:00:00 2001 From: ejlchina Date: Tue, 7 Apr 2020 16:36:43 +0800 Subject: [PATCH 010/924] update README.md. --- README.md | 20 +++++++------------- 1 file changed, 7 insertions(+), 13 deletions(-) diff --git a/README.md b/README.md index bb89e92d..a8531e9d 100644 --- a/README.md +++ b/README.md @@ -126,7 +126,7 @@ http.async("/users/1") // http://api.demo.com/users/1 ```java HttpResult res1 = http.sync("/users").get(); // 同步 GET -HttpResult res2 = http.sync("/users")post(); // 同步 POST +HttpResult res2 = http.sync("/users").post(); // 同步 POST HttpResult res3 = http.sync("/users/1").put(); // 同步 PUT HttpResult res4 = http.sync("/users/1").delete();// 同步 DELETE HttpCall call1 = http.async("/users").get(); // 异步 GET @@ -202,21 +202,15 @@ List orders = http.sync("/orders") .get().getBody().toList(Order.class); ``` -　　示例，下载文件到指定目录： +　　示例，使用 cache 方法： ```java -String path = "D:/reports/2020-03-01.xlsx"; // 文件保存目录 +Body body = http.sync("/orders").get().getBody().cache(); -// 同步下载 -http.sync("/reports/2020-03-01.xlsx") - .get().getBody().toFile(path); - -// 异步下载 -http.async("/reports/2020-03-01.xlsx") - .setOnResponse((HttpResult result) -> { - result.getBody().toFile(path); - }) - .get(); +// 使用 cache 后，可以多次使用 toXXX() 方法 +System.out.println(body.toString()); +System.out.println(body.toJsonArray()); +System.out.println(body.toList(Order.class)); ``` #### 3.3 HttpCall From f56b83679bca4fbb4e9153e13c21a4da7d47784e Mon Sep 17 00:00:00 2001 From: ejlchina Date: Tue, 7 Apr 2020 16:45:34 +0800 Subject: [PATCH 011/924] update README.md. --- README.md | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/README.md b/README.md index a8531e9d..80223ac7 100644 --- a/README.md +++ b/README.md @@ -170,7 +170,7 @@ http.async("/users/{id}") // http://api.demo.com/users/1 * `getHeaders()` 得到HTTP响应头 * `getHeaders(String name)` 得到HTTP响应头 * `getHeader(String name)` 得到HTTP响应头 -* `getBody()` 得到响应报文体`Body`实例，它定义了如下方法（对同一个`Body`实例，以下的`toXXX()`类方法只能使用一个且仅能调用一次）： +* `getBody()` 得到响应报文体`Body`实例，它定义了如下方法（对同一个`Body`实例，以下的`toXXX()`类方法只能使用一个且仅能调用一次，除非先使用 cache 方法）： * `toBytes()` 返回字节数组 * `toByteStream()` 返回字节输入流 * `toCharStream()` 返回字符输入流 From 7c75812ad7aa0853e7e08f84bc8fd3280d96071b Mon Sep 17 00:00:00 2001 From: ejlchina Date: Tue, 7 Apr 2020 16:53:36 +0800 Subject: [PATCH 012/924] update README.md. --- README.md | 14 ++++++++++++++ 1 file changed, 14 insertions(+) diff --git a/README.md b/README.md index 80223ac7..57e94c78 100644 --- a/README.md +++ b/README.md @@ -213,6 +213,20 @@ System.out.println(body.toJsonArray()); System.out.println(body.toList(Order.class)); ``` +　　示例，获取下载文件的大小： + +```java +long size = http.sync("http://api.demo.com/download/test.zip") + .get().getBody() + .close() // 只是想获得文件大小，不消费报文体，所以直接关闭 + .getContentLength(); // 获得待下载文件的大小 + +// 由于未消费报文体，所以本次请求不会消耗下载报文体的时间和网络流量） + +System.out.println("size = " + size); +``` + + #### 3.3 HttpCall 　　`HttpCall`对象是异步请求方法（`get`、`post`、`put`、`delete`）的返回值，与`java`的`Future`接口很像，它有如下方法： From 1a7b8db91141e3273a10ee1ed4779a1daefdbb36 Mon Sep 17 00:00:00 2001 From: ejlchina Date: Tue, 7 Apr 2020 17:02:41 +0800 Subject: [PATCH 013/924] update README.md. --- README.md | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/README.md b/README.md index 57e94c78..7a9c954b 100644 --- a/README.md +++ b/README.md @@ -39,7 +39,7 @@ - [6.2 回调执行器](#62-回调执行器) - [6.3 配置 OkHttpClient](#63-配置-okhttpclient) - [6.4 并行预处理器](#64-并行预处理器) - - [6.5 串行预处理器](#65-串行预处理器) + - [6.5 串行预处理器（Token问题最优雅的解决方案）](#65-串行预处理器) - [6.6 全局回调处理](#66-全局回调处理) - [6.7 全局下载监听](#67-全局下载监听) + [7 使用 HttpUtils 类](#7-使用-httputils-类) From 0e2b9cd443d8c26de48a424a12fb54c5a07161f5 Mon Sep 17 00:00:00 2001 From: ejlchina Date: Tue, 7 Apr 2020 22:37:21 +0800 Subject: [PATCH 014/924] update README.md. --- README.md | 1 + 1 file changed, 1 insertion(+) diff --git a/README.md b/README.md index 7a9c954b..0b86c262 100644 --- a/README.md +++ b/README.md @@ -16,6 +16,7 @@ ### 前世：[HttpUtils, V2.3.0 之后重命名为 OkHttps](https://gitee.com/ejlchina-zhxu/httputils) ### 当前文档版本[1.0.0] +### API文档：[https://apidoc.gitee.com/ejlchina-zhxu/okhttps](https://apidoc.gitee.com/ejlchina-zhxu/okhttps) ## 目录 From 0c14c2dfba96883de1069a27107e4e6e25469ce0 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?=E5=91=A8=E6=97=AD?= <15735559897@qq.com> Date: Tue, 7 Apr 2020 23:32:23 +0800 Subject: [PATCH 015/924] =?UTF-8?q?=E4=BC=98=E5=8C=96=20HttpResult=20?= =?UTF-8?q?=E7=9A=84=E5=AE=9E=E7=8E=B0=EF=BC=8C=201=E3=80=81=E5=BD=93?= =?UTF-8?q?=E6=89=A7=E8=A1=8C=E7=8A=B6=E6=80=81=20!=3D=20State.RESPONSED?= =?UTF-8?q?=20=E6=97=B6=EF=BC=8C=E8=B0=83=E7=94=A8=20getHeaders=20?= =?UTF-8?q?=E7=AD=89=E6=96=B9=E6=B3=95=E6=97=B6=E4=B8=8D=E5=86=8D=E6=8A=9B?= =?UTF-8?q?=E5=BC=82=E5=B8=B8=202=E3=80=81HttpResult.toString=20=E6=96=B9?= =?UTF-8?q?=E6=B3=95=E7=A7=BB=E9=99=A4=E5=AF=B9=20Body.toString=20?= =?UTF-8?q?=E7=9A=84=E8=B0=83=E7=94=A8?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- .../okhttps/internal/RealHttpResult.java | 274 +++++++++--------- 1 file changed, 140 insertions(+), 134 deletions(-) diff --git a/src/main/java/com/ejlchina/okhttps/internal/RealHttpResult.java b/src/main/java/com/ejlchina/okhttps/internal/RealHttpResult.java index 1218e4a0..c9326d36 100644 --- a/src/main/java/com/ejlchina/okhttps/internal/RealHttpResult.java +++ b/src/main/java/com/ejlchina/okhttps/internal/RealHttpResult.java @@ -1,134 +1,140 @@ -package com.ejlchina.okhttps.internal; - -import java.util.List; - -import com.ejlchina.okhttps.HttpResult; -import com.ejlchina.okhttps.HttpTask; - -import okhttp3.Headers; -import okhttp3.Response; - - -public class RealHttpResult implements HttpResult { - - private State state; - private Response response; - private Exception error; - private TaskExecutor taskExecutor; - private HttpTask httpTask; - - - public RealHttpResult(HttpTask httpTask, State state) { - this.httpTask = httpTask; - this.state = state; - } - - public RealHttpResult(HttpTask httpTask, Response response, TaskExecutor taskExecutor) { - this(httpTask, taskExecutor); - response(response); - } - - public RealHttpResult(HttpTask httpTask, TaskExecutor taskExecutor) { - this.httpTask = httpTask; - this.taskExecutor = taskExecutor; - } - - public RealHttpResult(HttpTask httpTask, State state, Exception error) { - this.httpTask = httpTask; - exception(state, error); - } - - - public void exception(State state, Exception error) { - this.state = state; - this.error = error; - } - - public void response(Response response) { - this.state = State.RESPONSED; - this.response = response; - } - - @Override - public HttpTask getTask() { - return httpTask; - } - - @Override - public State getState() { - return state; - } - - @Override - public int getStatus() { - if (response != null) { - return response.code(); - } - return 0; - } - - @Override - public boolean isSuccessful() { - if (response != null) { - return response.isSuccessful(); - } - return false; - } - - @Override - public Headers getHeaders() { - if (response != null) { - return response.headers(); - } - return null; - } - - @Override - public List getHeaders(String name) { - return response.headers(name); - } - - @Override - public String getHeader(String name) { - return response.header(name); - } - - @Override - public Body getBody() { - if (response != null) { - return new ResultBody(httpTask, response, taskExecutor); - } - return null; - } - - @Override - public Exception getError() { - return error; - } - - public Response getResponse() { - return response; - } - - - @Override - public String toString() { - Body body = getBody(); - String str = "HttpResult [\n state: " + state + ",\n status: " + getStatus() - + ",\n headers: " + getHeaders(); - if (body != null) { - str += ",\n contentType: " + body.getContentType() - + ",\n body: " + body.toString(); - } - return str + ",\n error: " + error + "\n]"; - } - - @Override - public HttpResult close() { - if (response != null) { - response.close(); - } - return this; - } - -} +package com.ejlchina.okhttps.internal; + +import java.util.Collections; +import java.util.List; + +import com.ejlchina.okhttps.HttpResult; +import com.ejlchina.okhttps.HttpTask; + +import okhttp3.Headers; +import okhttp3.Response; + + +public class RealHttpResult implements HttpResult { + + private State state; + private Response response; + private Exception error; + private TaskExecutor taskExecutor; + private HttpTask httpTask; + private Body body; + + public RealHttpResult(HttpTask httpTask, State state) { + this.httpTask = httpTask; + this.state = state; + } + + public RealHttpResult(HttpTask httpTask, Response response, TaskExecutor taskExecutor) { + this(httpTask, taskExecutor); + response(response); + } + + public RealHttpResult(HttpTask httpTask, TaskExecutor taskExecutor) { + this.httpTask = httpTask; + this.taskExecutor = taskExecutor; + } + + public RealHttpResult(HttpTask httpTask, State state, Exception error) { + this.httpTask = httpTask; + exception(state, error); + } + + + public void exception(State state, Exception error) { + this.state = state; + this.error = error; + } + + public void response(Response response) { + this.state = State.RESPONSED; + this.response = response; + } + + @Override + public HttpTask getTask() { + return httpTask; + } + + @Override + public State getState() { + return state; + } + + @Override + public int getStatus() { + if (response != null) { + return response.code(); + } + return 0; + } + + @Override + public boolean isSuccessful() { + if (response != null) { + return response.isSuccessful(); + } + return false; + } + + @Override + public Headers getHeaders() { + if (response != null) { + return response.headers(); + } + return null; + } + + @Override + public List getHeaders(String name) { + if (response != null) { + return response.headers(name); + } + return Collections.emptyList(); + } + + @Override + public String getHeader(String name) { + if (response != null) { + return response.header(name); + } + return null; + } + + @Override + public Body getBody() { + if (body == null && response != null) { + body = new ResultBody(httpTask, response, taskExecutor); + } + return body; + } + + @Override + public Exception getError() { + return error; + } + + public Response getResponse() { + return response; + } + + + @Override + public String toString() { + Body body = getBody(); + String str = "HttpResult [\n state: " + state + ",\n status: " + getStatus() + + ",\n headers: " + getHeaders(); + if (body != null) { + str += ",\n contentType: " + body.getContentType(); + } + return str + ",\n error: " + error + "\n]"; + } + + @Override + public HttpResult close() { + if (response != null) { + response.close(); + } + return this; + } + +} From ed80e855c4a4c82ce4e289d23d6fc037910ac3cb Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?=E5=91=A8=E6=97=AD?= <15735559897@qq.com> Date: Tue, 7 Apr 2020 23:45:30 +0800 Subject: [PATCH 016/924] =?UTF-8?q?=E7=A7=BB=E9=99=A4=20HttpResult.getTask?= =?UTF-8?q?()=20=E6=96=B9=E6=B3=95?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- .../java/com/ejlchina/okhttps/HttpResult.java | 558 +++++++++--------- .../okhttps/internal/RealHttpResult.java | 5 - 2 files changed, 276 insertions(+), 287 deletions(-) diff --git a/src/main/java/com/ejlchina/okhttps/HttpResult.java b/src/main/java/com/ejlchina/okhttps/HttpResult.java index c3d51d96..63424db2 100644 --- a/src/main/java/com/ejlchina/okhttps/HttpResult.java +++ b/src/main/java/com/ejlchina/okhttps/HttpResult.java @@ -1,282 +1,276 @@ -package com.ejlchina.okhttps; - -import java.io.File; -import java.io.InputStream; -import java.io.Reader; -import java.util.List; - -import com.alibaba.fastjson.JSONArray; -import com.alibaba.fastjson.JSONObject; -import com.ejlchina.okhttps.internal.RealHttpResult; -import com.ejlchina.okhttps.internal.TaskExecutor; - -import okhttp3.Headers; -import okhttp3.MediaType; -import okhttp3.Response; - - -/** - * Http 执行结果 - */ -public interface HttpResult { - - /** - * 构造一个 HttpResult - * 此方法构造的 HttpResult 不可设置进度回调，不可进行下载操作！ - * 若需要，请使用方法： {@link #of(Response, TaskExecutor)} - * @param response Response - * @return HttpResult - */ - static HttpResult of(Response response) { - return of(response, null); - } - - /** - * 构造一个 HttpResult - * @param response Response - * @param taskExecutor 任务执行器, 可通过方法 {@link HTTP#getExecutor()} 获得 - * @return HttpResult - */ - static HttpResult of(Response response, TaskExecutor taskExecutor) { - if (response != null) { - return new RealHttpResult(null, response, taskExecutor); - } - throw new IllegalArgumentException("response 不能为空"); - } - - /** - * 获取所属的 Http请求任务 - * @return HttpTask - */ - HttpTask getTask(); - - - public enum State { - - /** - * 执行异常 - */ - EXCEPTION, - - /** - * 请求被取消 - */ - CANCELED, - - /** - * 请求已响应 - */ - RESPONSED, - - /** - * 网络超时 - */ - TIMEOUT, - - /** - * 网络出错 - */ - NETWORK_ERROR - - } - - /** - * HTTP响应报文体 - */ - public interface Body { - - /** - * @return 媒体类型 - */ - MediaType getContentType(); - - /** - * @return 报文体字节长度 - */ - long getContentLength(); - - /** - * 在IO线程执行 - * @return Body - */ - Body nextOnIO(); - - /** - * 设置报文体接收进度回调 - * @param onProcess 进度回调函数 - * @return Body - */ - Body setOnProcess(OnCallback onProcess); - - /** - * 设置进度回调的步进字节，默认 8K（8192） - * 表示每接收 stepBytes 个字节，执行一次进度回调 - * @param stepBytes 步进字节 - * @return Body - */ - Body setStepBytes(long stepBytes); - - /** - * 设置进度回调的步进比例 - * 表示每接收 stepRate 比例，执行一次进度回调 - * @param stepRate 步进比例 - * @return Body - */ - Body setStepRate(double stepRate); - - /** - * 设置进度回调忽略响应的Range头信息，即进度回调会从0开始 - * @return Body - */ - Body setRangeIgnored(); - - /** - * 同一个 Body 对象的 toXXX 类方法只可使用一个并且只能调用一次 - * @return 报文体转字节流 - */ - InputStream toByteStream(); - - /** - * 同一个 Body 对象的 toXXX 类方法只可使用一个并且只能调用一次 - * @return 报文体转字节数组 - */ - byte[] toBytes(); - - /** - * 同一个 Body 对象的 toXXX 类方法只可使用一个并且只能调用一次 - * @return 报文体转字符流 - */ - Reader toCharStream(); - - /** - * 同一个 Body 对象的 toXXX 类方法只可使用一个并且只能调用一次 - * @return 报文体转字符串 - */ - String toString(); - - /** - * 同一个 Body 对象的 toXXX 类方法只可使用一个并且只能调用一次 - * @return 报文体转Json对象 - */ - JSONObject toJsonObject(); - - /** - * 同一个 Body 对象的 toXXX 类方法只可使用一个并且只能调用一次 - * @return 报文体转Json数组 - */ - JSONArray toJsonArray(); - - /** - * 同一个 Body 对象的 toXXX 类方法只可使用一个并且只能调用一次 - * @param 目标泛型 - * @param type 目标类型 - * @return 报文体Json文本转JavaBean - */ - T toBean(Class type); - - /** - * 同一个 Body 对象的 toXXX 类方法只可使用一个并且只能调用一次 - * @param 目标泛型 - * @param type 目标类型 - * @return 报文体Json文本转JavaBean列表 - */ - List toList(Class type); - - /** - * 下载到指定路径 - * 同一个 Body 对象的 toXXX 类方法只可使用一个并且只能调用一次 - * @param filePath 目标路径 - * @return 下载过程 #Download - */ - Download toFile(String filePath); - - /** - * 下载到指定文件 - * 同一个 Body 对象的 toXXX 类方法只可使用一个并且只能调用一次 - * @param file 目标文件 - * @return 下载过程 #Download - */ - Download toFile(File file); - - /** - * 下载到指定文件夹 - * 同一个 Body 对象的 toXXX 类方法只可使用一个并且只能调用一次 - * @param dirPath 目标目录 - * @return 下载过程 #Download - */ - Download toFolder(String dirPath); - - /** - * 下载到指定文件夹 - * 同一个 Body 对象的 toXXX 类方法只可使用一个并且只能调用一次 - * @param dir 目标目录 - * @return 下载过程 #Download - */ - Download toFolder(File dir); - - /** - * 缓存自己，缓存后可 重复使用 toXXX 类方法 - * @return Body - */ - Body cache(); - - /** - * 关闭报文体 - * 未对报文体做任何消费时使用，比如只读取长度 - * @return Body - */ - Body close(); - - } - - - /** - * @return 执行状态 - */ - State getState(); - - /** - * @return HTTP状态码 - */ - int getStatus(); - - /** - * @return 是否响应成功，状态码在 [200..300) 之间 - */ - boolean isSuccessful(); - - /** - * @return 响应头 - */ - Headers getHeaders(); - - /** - * @param name 头名称 - * @return 响应头 - */ - List getHeaders(String name); - - /** - * @param name 头名称 - * @return 响应头 - */ - String getHeader(String name); - - /** - * @return 响应报文体 - */ - Body getBody(); - - /** - * @return 执行中发生的异常 - */ - Exception getError(); - - /** - * 关闭报文 - * 未对报文体做任何消费时使用，比如只读取报文头 - * @return HttpResult - */ - HttpResult close(); - -} +package com.ejlchina.okhttps; + +import java.io.File; +import java.io.InputStream; +import java.io.Reader; +import java.util.List; + +import com.alibaba.fastjson.JSONArray; +import com.alibaba.fastjson.JSONObject; +import com.ejlchina.okhttps.internal.RealHttpResult; +import com.ejlchina.okhttps.internal.TaskExecutor; + +import okhttp3.Headers; +import okhttp3.MediaType; +import okhttp3.Response; + + +/** + * Http 执行结果 + */ +public interface HttpResult { + + /** + * 构造一个 HttpResult + * 此方法构造的 HttpResult 不可设置进度回调，不可进行下载操作！ + * 若需要，请使用方法： {@link #of(Response, TaskExecutor)} + * @param response Response + * @return HttpResult + */ + static HttpResult of(Response response) { + return of(response, null); + } + + /** + * 构造一个 HttpResult + * @param response Response + * @param taskExecutor 任务执行器, 可通过方法 {@link HTTP#getExecutor()} 获得 + * @return HttpResult + */ + static HttpResult of(Response response, TaskExecutor taskExecutor) { + if (response != null) { + return new RealHttpResult(null, response, taskExecutor); + } + throw new IllegalArgumentException("response 不能为空"); + } + + + public enum State { + + /** + * 执行异常 + */ + EXCEPTION, + + /** + * 请求被取消 + */ + CANCELED, + + /** + * 请求已响应 + */ + RESPONSED, + + /** + * 网络超时 + */ + TIMEOUT, + + /** + * 网络出错 + */ + NETWORK_ERROR + + } + + /** + * HTTP响应报文体 + */ + public interface Body { + + /** + * @return 媒体类型 + */ + MediaType getContentType(); + + /** + * @return 报文体字节长度 + */ + long getContentLength(); + + /** + * 在IO线程执行 + * @return Body + */ + Body nextOnIO(); + + /** + * 设置报文体接收进度回调 + * @param onProcess 进度回调函数 + * @return Body + */ + Body setOnProcess(OnCallback onProcess); + + /** + * 设置进度回调的步进字节，默认 8K（8192） + * 表示每接收 stepBytes 个字节，执行一次进度回调 + * @param stepBytes 步进字节 + * @return Body + */ + Body setStepBytes(long stepBytes); + + /** + * 设置进度回调的步进比例 + * 表示每接收 stepRate 比例，执行一次进度回调 + * @param stepRate 步进比例 + * @return Body + */ + Body setStepRate(double stepRate); + + /** + * 设置进度回调忽略响应的Range头信息，即进度回调会从0开始 + * @return Body + */ + Body setRangeIgnored(); + + /** + * 同一个 Body 对象的 toXXX 类方法只可使用一个并且只能调用一次 + * @return 报文体转字节流 + */ + InputStream toByteStream(); + + /** + * 同一个 Body 对象的 toXXX 类方法只可使用一个并且只能调用一次 + * @return 报文体转字节数组 + */ + byte[] toBytes(); + + /** + * 同一个 Body 对象的 toXXX 类方法只可使用一个并且只能调用一次 + * @return 报文体转字符流 + */ + Reader toCharStream(); + + /** + * 同一个 Body 对象的 toXXX 类方法只可使用一个并且只能调用一次 + * @return 报文体转字符串 + */ + String toString(); + + /** + * 同一个 Body 对象的 toXXX 类方法只可使用一个并且只能调用一次 + * @return 报文体转Json对象 + */ + JSONObject toJsonObject(); + + /** + * 同一个 Body 对象的 toXXX 类方法只可使用一个并且只能调用一次 + * @return 报文体转Json数组 + */ + JSONArray toJsonArray(); + + /** + * 同一个 Body 对象的 toXXX 类方法只可使用一个并且只能调用一次 + * @param 目标泛型 + * @param type 目标类型 + * @return 报文体Json文本转JavaBean + */ + T toBean(Class type); + + /** + * 同一个 Body 对象的 toXXX 类方法只可使用一个并且只能调用一次 + * @param 目标泛型 + * @param type 目标类型 + * @return 报文体Json文本转JavaBean列表 + */ + List toList(Class type); + + /** + * 下载到指定路径 + * 同一个 Body 对象的 toXXX 类方法只可使用一个并且只能调用一次 + * @param filePath 目标路径 + * @return 下载过程 #Download + */ + Download toFile(String filePath); + + /** + * 下载到指定文件 + * 同一个 Body 对象的 toXXX 类方法只可使用一个并且只能调用一次 + * @param file 目标文件 + * @return 下载过程 #Download + */ + Download toFile(File file); + + /** + * 下载到指定文件夹 + * 同一个 Body 对象的 toXXX 类方法只可使用一个并且只能调用一次 + * @param dirPath 目标目录 + * @return 下载过程 #Download + */ + Download toFolder(String dirPath); + + /** + * 下载到指定文件夹 + * 同一个 Body 对象的 toXXX 类方法只可使用一个并且只能调用一次 + * @param dir 目标目录 + * @return 下载过程 #Download + */ + Download toFolder(File dir); + + /** + * 缓存自己，缓存后可 重复使用 toXXX 类方法 + * @return Body + */ + Body cache(); + + /** + * 关闭报文体 + * 未对报文体做任何消费时使用，比如只读取长度 + * @return Body + */ + Body close(); + + } + + + /** + * @return 执行状态 + */ + State getState(); + + /** + * @return HTTP状态码 + */ + int getStatus(); + + /** + * @return 是否响应成功，状态码在 [200..300) 之间 + */ + boolean isSuccessful(); + + /** + * @return 响应头 + */ + Headers getHeaders(); + + /** + * @param name 头名称 + * @return 响应头 + */ + List getHeaders(String name); + + /** + * @param name 头名称 + * @return 响应头 + */ + String getHeader(String name); + + /** + * @return 响应报文体 + */ + Body getBody(); + + /** + * @return 执行中发生的异常 + */ + Exception getError(); + + /** + * 关闭报文 + * 未对报文体做任何消费时使用，比如只读取报文头 + * @return HttpResult + */ + HttpResult close(); + +} diff --git a/src/main/java/com/ejlchina/okhttps/internal/RealHttpResult.java b/src/main/java/com/ejlchina/okhttps/internal/RealHttpResult.java index c9326d36..4de88afd 100644 --- a/src/main/java/com/ejlchina/okhttps/internal/RealHttpResult.java +++ b/src/main/java/com/ejlchina/okhttps/internal/RealHttpResult.java @@ -50,11 +50,6 @@ public void response(Response response) { this.response = response; } - @Override - public HttpTask getTask() { - return httpTask; - } - @Override public State getState() { return state; From 7d0eba0676addbe57849a81063123126506e2354 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?=E5=91=A8=E6=97=AD?= <15735559897@qq.com> Date: Tue, 7 Apr 2020 23:58:22 +0800 Subject: [PATCH 017/924] =?UTF-8?q?=E4=BC=98=E5=8C=96=20HttpCall.getResult?= =?UTF-8?q?()=20=E7=9A=84=E5=AE=9E=E7=8E=B0?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- .../java/com/ejlchina/okhttps/internal/AsyncHttpTask.java | 4 ++-- src/main/java/com/ejlchina/okhttps/internal/HttpClient.java | 6 +++++- 2 files changed, 7 insertions(+), 3 deletions(-) diff --git a/src/main/java/com/ejlchina/okhttps/internal/AsyncHttpTask.java b/src/main/java/com/ejlchina/okhttps/internal/AsyncHttpTask.java index cadc760c..44389f03 100644 --- a/src/main/java/com/ejlchina/okhttps/internal/AsyncHttpTask.java +++ b/src/main/java/com/ejlchina/okhttps/internal/AsyncHttpTask.java @@ -169,7 +169,7 @@ public synchronized HttpResult getResult() { } if (call == null) { try { - wait(); + wait(httpClient.totalTimeoutMillis()); } catch (InterruptedException e) { throw new HttpException(e.getMessage(), e); } @@ -214,7 +214,7 @@ public boolean isCanceled() { public synchronized HttpResult getResult() { if (result == null) { try { - wait(); + wait(httpClient.totalTimeoutMillis()); } catch (InterruptedException e) { throw new HttpException(e.getMessage(), e); } diff --git a/src/main/java/com/ejlchina/okhttps/internal/HttpClient.java b/src/main/java/com/ejlchina/okhttps/internal/HttpClient.java index cdc0c85e..15ab2fae 100644 --- a/src/main/java/com/ejlchina/okhttps/internal/HttpClient.java +++ b/src/main/java/com/ejlchina/okhttps/internal/HttpClient.java @@ -99,7 +99,11 @@ public WebSocket webSocket(Request request, WebSocketListener listener) { public OkHttpClient getOkClient() { return client; } - + + public int totalTimeoutMillis() { + return client.connectTimeoutMillis() + client.writeTimeoutMillis() + client.readTimeoutMillis(); + } + public int getTagCallCount() { return tagCalls.size(); } From 3c9c6bdbf48c1c6239fd70b662983bda2c985e54 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?=E5=91=A8=E6=97=AD?= Date: Wed, 8 Apr 2020 09:10:37 +0800 Subject: [PATCH 018/924] README --- README.md | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/README.md b/README.md index 0b86c262..d9644e66 100644 --- a/README.md +++ b/README.md @@ -40,7 +40,7 @@ - [6.2 回调执行器](#62-回调执行器) - [6.3 配置 OkHttpClient](#63-配置-okhttpclient) - [6.4 并行预处理器](#64-并行预处理器) - - [6.5 串行预处理器（Token问题最优雅的解决方案）](#65-串行预处理器) + - [6.5 串行预处理器（TOKEN问题最佳解决方案）](#65-串行预处理器) - [6.6 全局回调处理](#66-全局回调处理) - [6.7 全局下载监听](#67-全局下载监听) + [7 使用 HttpUtils 类](#7-使用-httputils-类) @@ -396,7 +396,7 @@ HTTP http = HTTP.builder() ``` 　　和`Interceptor`一样，`Preprocessor`也可以添加多个。 -#### 6.5 串行预处理器 +#### 6.5 串行预处理器（TOKEN问题最佳解决方案） 　　普通预处理器都是可并行处理的，然而有时我们希望某个预处理器同时只处理一个任务。比如 当`Token`过期时我们需要去刷新获取新`Token`，而刷新`Token`这个操作只能有一个任务去执行，因为如果`n`个任务同时执行的话，那么必有`n-1`个任务刚刷新得到的`Token`可能就立马失效了，而这是我们所不希望的。 From b15d21f266751f9b191e475b1e3d74ee732415b1 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?=E5=91=A8=E6=97=AD?= Date: Wed, 8 Apr 2020 09:11:47 +0800 Subject: [PATCH 019/924] README --- README.md | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/README.md b/README.md index d9644e66..2fd5790a 100644 --- a/README.md +++ b/README.md @@ -40,7 +40,7 @@ - [6.2 回调执行器](#62-回调执行器) - [6.3 配置 OkHttpClient](#63-配置-okhttpclient) - [6.4 并行预处理器](#64-并行预处理器) - - [6.5 串行预处理器（TOKEN问题最佳解决方案）](#65-串行预处理器) + - [6.5 串行预处理器（TOKEN问题最佳解决方案）](#65-串行预处理器token问题最佳解决方案) - [6.6 全局回调处理](#66-全局回调处理) - [6.7 全局下载监听](#67-全局下载监听) + [7 使用 HttpUtils 类](#7-使用-httputils-类) From c530520a77ceab6e39a6f021f73f21773cee0d20 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?=E5=91=A8=E6=97=AD?= Date: Wed, 8 Apr 2020 09:26:46 +0800 Subject: [PATCH 020/924] README --- README.md | 5 +++++ 1 file changed, 5 insertions(+) diff --git a/README.md b/README.md index 2fd5790a..8f51efab 100644 --- a/README.md +++ b/README.md @@ -396,6 +396,11 @@ HTTP http = HTTP.builder() ``` 　　和`Interceptor`一样，`Preprocessor`也可以添加多个。 +> 预处理器（Preprocessor）与拦截器（Interceptor）的区别： +> * 拦截器只能处理同步操作，预处理器支持处理异步操作 +> * 拦截器都是并行处理请求，预处理支持串行处理（详见6.5章节） +> * 拦截器处理时机在请求前和响应后，预处理器只在请求前，并且预处理器先于拦截器执行 + #### 6.5 串行预处理器（TOKEN问题最佳解决方案） 　　普通预处理器都是可并行处理的，然而有时我们希望某个预处理器同时只处理一个任务。比如 当`Token`过期时我们需要去刷新获取新`Token`，而刷新`Token`这个操作只能有一个任务去执行，因为如果`n`个任务同时执行的话，那么必有`n-1`个任务刚刷新得到的`Token`可能就立马失效了，而这是我们所不希望的。 From 321db867f4c770b67433096a6ed133a07273ae7b Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?=E5=91=A8=E6=97=AD?= Date: Wed, 8 Apr 2020 09:29:16 +0800 Subject: [PATCH 021/924] readme --- README.md | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/README.md b/README.md index 8f51efab..23016116 100644 --- a/README.md +++ b/README.md @@ -398,7 +398,7 @@ HTTP http = HTTP.builder() > 预处理器（Preprocessor）与拦截器（Interceptor）的区别： > * 拦截器只能处理同步操作，预处理器支持处理异步操作 -> * 拦截器都是并行处理请求，预处理支持串行处理（详见6.5章节） +> * 拦截器都是并行处理请求，预处理器支持串行处理（详见6.5章节） > * 拦截器处理时机在请求前和响应后，预处理器只在请求前，并且预处理器先于拦截器执行 #### 6.5 串行预处理器（TOKEN问题最佳解决方案） From 084ce950ceac8ee5ff49ee545f65cab944b9cfc3 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?=E5=91=A8=E6=97=AD?= Date: Wed, 8 Apr 2020 09:31:43 +0800 Subject: [PATCH 022/924] readme --- README.md | 3 +-- 1 file changed, 1 insertion(+), 2 deletions(-) diff --git a/README.md b/README.md index 23016116..e676ff36 100644 --- a/README.md +++ b/README.md @@ -394,9 +394,8 @@ HTTP http = HTTP.builder() }) .build(); ``` -　　和`Interceptor`一样，`Preprocessor`也可以添加多个。 +　　和`Interceptor`一样，`Preprocessor`也可以添加多个。他们之前的区别如下: -> 预处理器（Preprocessor）与拦截器（Interceptor）的区别： > * 拦截器只能处理同步操作，预处理器支持处理异步操作 > * 拦截器都是并行处理请求，预处理器支持串行处理（详见6.5章节） > * 拦截器处理时机在请求前和响应后，预处理器只在请求前，并且预处理器先于拦截器执行 From 018bca1154087d99dd568b7760498e42bb6b46ae Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?=E5=91=A8=E6=97=AD?= Date: Wed, 8 Apr 2020 09:43:54 +0800 Subject: [PATCH 023/924] readme --- README.md | 13 +++++++++---- 1 file changed, 9 insertions(+), 4 deletions(-) diff --git a/README.md b/README.md index e676ff36..d20d2cb2 100644 --- a/README.md +++ b/README.md @@ -398,7 +398,7 @@ HTTP http = HTTP.builder() > * 拦截器只能处理同步操作，预处理器支持处理异步操作 > * 拦截器都是并行处理请求，预处理器支持串行处理（详见6.5章节） -> * 拦截器处理时机在请求前和响应后，预处理器只在请求前，并且预处理器先于拦截器执行 +> * 拦截器处理时机在请求前和响应后，预处理器只在请求前，并且预处理器先于拦截器执行。关于响应后，OkHttps还提供了全局回调机制（详见6.6章节） #### 6.5 串行预处理器（TOKEN问题最佳解决方案） @@ -429,22 +429,27 @@ HTTP http = HTTP.builder() HTTP http = HTTP.builder() .responseListener((HttpTask task, HttpResult result) -> { // 所有请求响应后都会走这里 - + return true; // 返回 true 表示继续执行 task 的 OnResponse 回调，false 表示不再执行 }) .completeListener((HttpTask task, State state) -> { // 所有请求执行完都会走这里 - + return true; // 返回 true 表示继续执行 task 的 OnComplete 回调，false 表示不再执行 }) .exceptionListener((HttpTask task, IOException error) -> { // 所有请求发生异常都会走这里 - + return true; // 返回 true 表示继续执行 task 的 OnException 回调，false 表示不再执行 }) .build(); ``` +　　全局回调与拦截器的异同: +> * 处理时机都在请求的响应后 +> * 拦截器可以添加多个，全局回调分三种，每种最多添加一个 +> * 全局回调可以阻断某个请求的具体回调（在全局回调里返回 false），而拦截器不能 + #### 6.7 全局下载监听 ```java From 64d3097464d766b1c1875e59e5e52001ebffbf75 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?=E5=91=A8=E6=97=AD?= Date: Wed, 8 Apr 2020 09:48:15 +0800 Subject: [PATCH 024/924] readme --- README.md | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/README.md b/README.md index d20d2cb2..f4f3b5e3 100644 --- a/README.md +++ b/README.md @@ -446,7 +446,7 @@ HTTP http = HTTP.builder() ``` 　　全局回调与拦截器的异同: -> * 处理时机都在请求的响应后 +> * 拦截器处理时机在请求前和响应后，全局回调只在响应后 > * 拦截器可以添加多个，全局回调分三种，每种最多添加一个 > * 全局回调可以阻断某个请求的具体回调（在全局回调里返回 false），而拦截器不能 From 0c7ff3b73c796aaf7d40f8c4385e6fbe8ebee578 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?=E5=91=A8=E6=97=AD?= Date: Wed, 8 Apr 2020 09:53:33 +0800 Subject: [PATCH 025/924] readme --- README.md | 6 +++--- 1 file changed, 3 insertions(+), 3 deletions(-) diff --git a/README.md b/README.md index f4f3b5e3..40740da6 100644 --- a/README.md +++ b/README.md @@ -398,7 +398,7 @@ HTTP http = HTTP.builder() > * 拦截器只能处理同步操作，预处理器支持处理异步操作 > * 拦截器都是并行处理请求，预处理器支持串行处理（详见6.5章节） -> * 拦截器处理时机在请求前和响应后，预处理器只在请求前，并且预处理器先于拦截器执行。关于响应后，OkHttps还提供了全局回调机制（详见6.6章节） +> * 拦截器处理时机在请求前和响应后，预处理器只在请求前，并且先于拦截器执行。关于响应后，OkHttps还提供了全局回调机制（详见6.6章节） #### 6.5 串行预处理器（TOKEN问题最佳解决方案） @@ -446,9 +446,9 @@ HTTP http = HTTP.builder() ``` 　　全局回调与拦截器的异同: -> * 拦截器处理时机在请求前和响应后，全局回调只在响应后 > * 拦截器可以添加多个，全局回调分三种，每种最多添加一个 -> * 全局回调可以阻断某个请求的具体回调（在全局回调里返回 false），而拦截器不能 +> * 拦截器处的理时机在请求前和响应后，全局回调只在响应后，并且晚于拦截器 +> * 全局回调可以阻断（return false）某个请求的具体回调，而拦截器不能 #### 6.7 全局下载监听 From c38c79ad2c9bb0dfa48d9313cbace733ab3b6337 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?=E5=91=A8=E6=97=AD?= Date: Wed, 8 Apr 2020 10:55:57 +0800 Subject: [PATCH 026/924] =?UTF-8?q?=E4=BC=98=E5=8C=96?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- .../java/com/ejlchina/okhttps/internal/AsyncHttpTask.java | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/src/main/java/com/ejlchina/okhttps/internal/AsyncHttpTask.java b/src/main/java/com/ejlchina/okhttps/internal/AsyncHttpTask.java index 44389f03..a0d798dc 100644 --- a/src/main/java/com/ejlchina/okhttps/internal/AsyncHttpTask.java +++ b/src/main/java/com/ejlchina/okhttps/internal/AsyncHttpTask.java @@ -169,7 +169,7 @@ public synchronized HttpResult getResult() { } if (call == null) { try { - wait(httpClient.totalTimeoutMillis()); + wait(httpClient.totalTimeoutMillis() * 10); } catch (InterruptedException e) { throw new HttpException(e.getMessage(), e); } @@ -214,7 +214,7 @@ public boolean isCanceled() { public synchronized HttpResult getResult() { if (result == null) { try { - wait(httpClient.totalTimeoutMillis()); + wait(httpClient.totalTimeoutMillis() * 10); } catch (InterruptedException e) { throw new HttpException(e.getMessage(), e); } From 9c2674392741d5bfef2c1e728f74e6500a0da20c Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?=E5=91=A8=E6=97=AD?= Date: Wed, 8 Apr 2020 11:22:05 +0800 Subject: [PATCH 027/924] V1.0.1 --- pom.xml | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/pom.xml b/pom.xml index c322c04d..1678b893 100644 --- a/pom.xml +++ b/pom.xml @@ -3,7 +3,7 @@ com.ejlchina okhttps - 1.0.0 + 1.0.1 OkHttps @@ -32,7 +32,7 @@ scm:git://gitee.com/ejlchina-zhxu/okhttps.git scm:http://gitee.com/ejlchina-zhxu/okhttps https://gitee.com/ejlchina-zhxu/okhttps - v2.2.0 + v1.0.1 From 1355d8e4aa8ac24600f5dbbb16999d6a0a9db749 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?=E5=91=A8=E6=97=AD?= Date: Wed, 8 Apr 2020 11:40:49 +0800 Subject: [PATCH 028/924] readme --- README.md | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/README.md b/README.md index 40740da6..79d44f92 100644 --- a/README.md +++ b/README.md @@ -369,7 +369,7 @@ HTTP http = HTTP.builder() // 必须同步返回，拦截器内无法执行异步操作 return chain.proceed(request); }); - // 其它配置: SSL、缓存、代理、事件监听... + // 其它配置: CookieJar、SSL、缓存、代理、事件监听... }) .build(); ``` From 8b2de164bd9d4867949f5142fe372d4c65fd1d4c Mon Sep 17 00:00:00 2001 From: ejlchina Date: Wed, 8 Apr 2020 12:13:18 +0800 Subject: [PATCH 029/924] update README.md. --- README.md | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/README.md b/README.md index 79d44f92..0067f8db 100644 --- a/README.md +++ b/README.md @@ -69,7 +69,7 @@ ``` ### Gradle -`compile 'com.ejlchina:okhttps:1.0.0'` +`implementation 'com.ejlchina:okhttps:1.0.0'` ## 使用说明 From fd60a1c2f6bbbcd7b8d2a228259ad67e1bdafc45 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?=E5=91=A8=E6=97=AD?= Date: Wed, 8 Apr 2020 12:14:23 +0800 Subject: [PATCH 030/924] readme --- README.md | 6 +++--- 1 file changed, 3 insertions(+), 3 deletions(-) diff --git a/README.md b/README.md index 0067f8db..27578d65 100644 --- a/README.md +++ b/README.md @@ -15,7 +15,7 @@ * TCP连接池、Http2 ### 前世：[HttpUtils, V2.3.0 之后重命名为 OkHttps](https://gitee.com/ejlchina-zhxu/httputils) -### 当前文档版本[1.0.0] +### 当前文档版本[1.0.1] ### API文档：[https://apidoc.gitee.com/ejlchina-zhxu/okhttps](https://apidoc.gitee.com/ejlchina-zhxu/okhttps) ## 目录 @@ -64,12 +64,12 @@ com.ejlchina okhttps - 1.0.0 + 1.0.1 ``` ### Gradle -`implementation 'com.ejlchina:okhttps:1.0.0'` +`implementation 'com.ejlchina:okhttps:1.0.1'` ## 使用说明 From e4f40b286e194f8e016959f9511a5367f07aef6b Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?=E5=91=A8=E6=97=AD?= Date: Wed, 8 Apr 2020 12:36:02 +0800 Subject: [PATCH 031/924] readme --- README.md | 1 + 1 file changed, 1 insertion(+) diff --git a/README.md b/README.md index 27578d65..b2d77eea 100644 --- a/README.md +++ b/README.md @@ -12,6 +12,7 @@ * BaseURL、URL占位符、JSON自动封装与解析 * 同步拦截器、异步预处理器、回调执行器 * 文件上传下载（过程控制、进度监听） + * 单方法回调，充分利用 Lambda 表达式 * TCP连接池、Http2 ### 前世：[HttpUtils, V2.3.0 之后重命名为 OkHttps](https://gitee.com/ejlchina-zhxu/httputils) From 99200f3ccc04c49c54fffe8e476b1caf616e17e9 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?=E5=91=A8=E6=97=AD?= Date: Wed, 8 Apr 2020 12:56:32 +0800 Subject: [PATCH 032/924] readme --- README.md | 5 ++++- 1 file changed, 4 insertions(+), 1 deletion(-) diff --git a/README.md b/README.md index b2d77eea..f818d06e 100644 --- a/README.md +++ b/README.md @@ -140,7 +140,7 @@ HttpCall call4 = http.async("/users/1").delete();// 异步 DELETE #### 3.1 回调函数 -　　只有异步请求才可以设置回调函数： +　　OkHttps 的回调函数全部使用单方法模式，这样可以充分利用 Java8 或 Kotlin 中的 Lambda 表达式，使你的代码更加简洁优雅： ```java http.async("/users/{id}") // http://api.demo.com/users/1 @@ -157,6 +157,9 @@ http.async("/users/{id}") // http://api.demo.com/users/1 .get(); ``` +>* 只有异步请求才可以设置这三种（响应|异常|完成）回调函数 +>* 同步请求直接返回结果，无需使用回调 + #### 3.2 HttpResult 　　`HttpResult`是HTTP请求执行完后的结果，它是同步请求方法（ `get`、`post`、`put`、`delete`）的返回值，也是异步请求响应回调（`OnResponse`）的参数，它定义了如下方法： From 0cec85b7a41021ade6e24393b1214e1e2dce7149 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?=E5=91=A8=E6=97=AD?= Date: Wed, 8 Apr 2020 12:57:31 +0800 Subject: [PATCH 033/924] readme --- README.md | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/README.md b/README.md index f818d06e..43b52cb3 100644 --- a/README.md +++ b/README.md @@ -157,7 +157,7 @@ http.async("/users/{id}") // http://api.demo.com/users/1 .get(); ``` ->* 只有异步请求才可以设置这三种（响应|异常|完成）回调函数 +>* 只有异步请求才可以设置这三种（响应|异常|完成）回调 >* 同步请求直接返回结果，无需使用回调 #### 3.2 HttpResult From b75664ed261a83c6292141b97952e3c204fa041a Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?=E5=91=A8=E6=97=AD?= Date: Wed, 8 Apr 2020 12:59:24 +0800 Subject: [PATCH 034/924] readme --- README.md | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/README.md b/README.md index 43b52cb3..9362b94d 100644 --- a/README.md +++ b/README.md @@ -221,7 +221,7 @@ System.out.println(body.toList(Order.class)); 　　示例，获取下载文件的大小： ```java -long size = http.sync("http://api.demo.com/download/test.zip") +long size = http.sync("/download/test.zip") .get().getBody() .close() // 只是想获得文件大小，不消费报文体，所以直接关闭 .getContentLength(); // 获得待下载文件的大小 From 05620fd8f94062039d289b0f4bcbee667cef466b Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?=E5=91=A8=E6=97=AD?= Date: Wed, 8 Apr 2020 13:11:21 +0800 Subject: [PATCH 035/924] readme --- README.md | 15 ++++++++------- 1 file changed, 8 insertions(+), 7 deletions(-) diff --git a/README.md b/README.md index 9362b94d..35c76a5e 100644 --- a/README.md +++ b/README.md @@ -13,6 +13,7 @@ * 同步拦截器、异步预处理器、回调执行器 * 文件上传下载（过程控制、进度监听） * 单方法回调，充分利用 Lambda 表达式 + * 全局监听、回调阻断 * TCP连接池、Http2 ### 前世：[HttpUtils, V2.3.0 之后重命名为 OkHttps](https://gitee.com/ejlchina-zhxu/httputils) @@ -42,7 +43,7 @@ - [6.3 配置 OkHttpClient](#63-配置-okhttpclient) - [6.4 并行预处理器](#64-并行预处理器) - [6.5 串行预处理器（TOKEN问题最佳解决方案）](#65-串行预处理器token问题最佳解决方案) - - [6.6 全局回调处理](#66-全局回调处理) + - [6.6 全局回调监听](#66-全局回调监听) - [6.7 全局下载监听](#67-全局下载监听) + [7 使用 HttpUtils 类](#7-使用-httputils-类) + [8 文件下载](#8-文件下载) @@ -402,7 +403,7 @@ HTTP http = HTTP.builder() > * 拦截器只能处理同步操作，预处理器支持处理异步操作 > * 拦截器都是并行处理请求，预处理器支持串行处理（详见6.5章节） -> * 拦截器处理时机在请求前和响应后，预处理器只在请求前，并且先于拦截器执行。关于响应后，OkHttps还提供了全局回调机制（详见6.6章节） +> * 拦截器处理时机在请求前和响应后，预处理器只在请求前，并且先于拦截器执行。关于响应后，OkHttps还提供了全局回调监听（详见6.6章节） #### 6.5 串行预处理器（TOKEN问题最佳解决方案） @@ -427,7 +428,7 @@ HTTP http = HTTP.builder() ``` 　　串行预处理器实现了让HTTP任务排队串行处理的功能，但值得一提的是：它并没有因此而阻塞任何线程！ -#### 6.6 全局回调处理 +#### 6.6 全局回调监听 ```java HTTP http = HTTP.builder() @@ -449,10 +450,10 @@ HTTP http = HTTP.builder() .build(); ``` -　　全局回调与拦截器的异同: -> * 拦截器可以添加多个，全局回调分三种，每种最多添加一个 -> * 拦截器处的理时机在请求前和响应后，全局回调只在响应后，并且晚于拦截器 -> * 全局回调可以阻断（return false）某个请求的具体回调，而拦截器不能 +　　全局回调监听与拦截器的异同: +> * 拦截器可以添加多个，全局回调监听分三种，每种最多添加一个 +> * 拦截器处的理时机在请求前和响应后，全局回调监听只在响应后，并且晚于拦截器 +> * 全局回调监听可以阻断（return false）某个请求的具体回调，而拦截器不能 #### 6.7 全局下载监听 From adf76e83aa4b6ae1feb726a75af81c75632c3597 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?=E5=91=A8=E6=97=AD?= Date: Wed, 8 Apr 2020 13:20:08 +0800 Subject: [PATCH 036/924] readme --- README.md | 3 +-- 1 file changed, 1 insertion(+), 2 deletions(-) diff --git a/README.md b/README.md index 35c76a5e..e2b9d6f7 100644 --- a/README.md +++ b/README.md @@ -10,10 +10,9 @@ * 链式调用，一点到底 * BaseURL、URL占位符、JSON自动封装与解析 - * 同步拦截器、异步预处理器、回调执行器 + * 同步拦截器、异步预处理器、回调执行器、全局监听、回调阻断 * 文件上传下载（过程控制、进度监听） * 单方法回调，充分利用 Lambda 表达式 - * 全局监听、回调阻断 * TCP连接池、Http2 ### 前世：[HttpUtils, V2.3.0 之后重命名为 OkHttps](https://gitee.com/ejlchina-zhxu/httputils) From f6db912aad78d9576aa633f9f5578eeca5632721 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?=E5=91=A8=E6=97=AD?= Date: Wed, 8 Apr 2020 13:50:42 +0800 Subject: [PATCH 037/924] =?UTF-8?q?TaskExecutor=20=E6=96=B0=E5=A2=9E=20shu?= =?UTF-8?q?tdown=20=E6=96=B9=E6=B3=95?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- .../com/ejlchina/okhttps/internal/TaskExecutor.java | 10 ++++++++++ 1 file changed, 10 insertions(+) diff --git a/src/main/java/com/ejlchina/okhttps/internal/TaskExecutor.java b/src/main/java/com/ejlchina/okhttps/internal/TaskExecutor.java index fbb164b1..3abcc054 100644 --- a/src/main/java/com/ejlchina/okhttps/internal/TaskExecutor.java +++ b/src/main/java/com/ejlchina/okhttps/internal/TaskExecutor.java @@ -4,6 +4,7 @@ import java.io.IOException; import java.io.InputStream; import java.util.concurrent.Executor; +import java.util.concurrent.ExecutorService; import com.ejlchina.okhttps.DownListener; import com.ejlchina.okhttps.Download; @@ -95,4 +96,13 @@ public void executeOnComplete(HttpTask task, OnCallback onComplete, St } } + public void shutdown() { + if (ioExecutor != null && ioExecutor instanceof ExecutorService) { + ((ExecutorService) ioExecutor).shutdown(); + } + if (mainExecutor != null && mainExecutor instanceof ExecutorService) { + ((ExecutorService) mainExecutor).shutdown(); + } + } + } From e8f8c21f95f4dce4dd70e2fd472c266edff1271d Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?=E5=91=A8=E6=97=AD?= Date: Wed, 8 Apr 2020 13:54:21 +0800 Subject: [PATCH 038/924] =?UTF-8?q?=E6=B3=A8=E9=87=8A?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- src/main/java/com/ejlchina/okhttps/internal/TaskExecutor.java | 4 ++++ 1 file changed, 4 insertions(+) diff --git a/src/main/java/com/ejlchina/okhttps/internal/TaskExecutor.java b/src/main/java/com/ejlchina/okhttps/internal/TaskExecutor.java index 3abcc054..66ed7a85 100644 --- a/src/main/java/com/ejlchina/okhttps/internal/TaskExecutor.java +++ b/src/main/java/com/ejlchina/okhttps/internal/TaskExecutor.java @@ -96,6 +96,10 @@ public void executeOnComplete(HttpTask task, OnCallback onComplete, St } } + /** + * 关闭线程池 + * @since OkHttps V1.0.2 + */ public void shutdown() { if (ioExecutor != null && ioExecutor instanceof ExecutorService) { ((ExecutorService) ioExecutor).shutdown(); From f027d65d0b97b7b01a635e0ca76b5cb754b677d4 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?=E5=91=A8=E6=97=AD?= Date: Wed, 8 Apr 2020 16:53:37 +0800 Subject: [PATCH 039/924] readme --- README.md | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/README.md b/README.md index e2b9d6f7..3563ed0a 100644 --- a/README.md +++ b/README.md @@ -502,7 +502,7 @@ List users = HttpUtils.sync("/users") http.sync("/download/test.zip") .get() // 使用 GET 方法（其它方法也可以，看服务器支持） .getBody() // 得到报文体 - .toFile("D:/download/test.zip") // 指定下载的目录，文件名将根据下载信息自动生成 + .toFile("D:/download/test.zip") // 下载到指定的路径 .start(); // 启动下载 ``` 　　或使用异步连接方式： From 9ba2d77b3710d6bcac171dec5db06f16a9212604 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?=E5=91=A8=E6=97=AD?= Date: Wed, 8 Apr 2020 16:55:37 +0800 Subject: [PATCH 040/924] readme --- README.md | 4 ++++ 1 file changed, 4 insertions(+) diff --git a/README.md b/README.md index 3563ed0a..869edb2c 100644 --- a/README.md +++ b/README.md @@ -504,6 +504,10 @@ http.sync("/download/test.zip") .getBody() // 得到报文体 .toFile("D:/download/test.zip") // 下载到指定的路径 .start(); // 启动下载 + +http.sync("/download/test.zip").get().getBody() + .toFolder("D:/download/") // 下载到指定的目录，文件名将根据下载信息自动生成 + .start(); ``` 　　或使用异步连接方式： From 3e08e59de5457d1930d9b014386c13282f766ae0 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?=E5=91=A8=E6=97=AD?= Date: Wed, 8 Apr 2020 16:56:58 +0800 Subject: [PATCH 041/924] readme --- README.md | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/README.md b/README.md index 869edb2c..354a69d2 100644 --- a/README.md +++ b/README.md @@ -506,7 +506,7 @@ http.sync("/download/test.zip") .start(); // 启动下载 http.sync("/download/test.zip").get().getBody() - .toFolder("D:/download/") // 下载到指定的目录，文件名将根据下载信息自动生成 + .toFolder("D:/download") // 下载到指定的目录，文件名将根据下载信息自动生成 .start(); ``` 　　或使用异步连接方式： @@ -514,7 +514,7 @@ http.sync("/download/test.zip").get().getBody() ```java http.async("/download/test.zip") .setOnResponse((HttpResult result) -> { - result.getBody().toFile("D:/download/test.zip").start(); + result.getBody().toFolder("D:/download").start(); }) .get(); ``` From e3e3e54b30c8508ddff40f00f2d717f0344200f6 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?=E5=91=A8=E6=97=AD?= Date: Wed, 8 Apr 2020 16:57:37 +0800 Subject: [PATCH 042/924] readme --- README.md | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/README.md b/README.md index 354a69d2..f844d1dc 100644 --- a/README.md +++ b/README.md @@ -506,7 +506,7 @@ http.sync("/download/test.zip") .start(); // 启动下载 http.sync("/download/test.zip").get().getBody() - .toFolder("D:/download") // 下载到指定的目录，文件名将根据下载信息自动生成 + .toFolder("D:/download") // 下载到指定的目录，文件名将根据下载信息自动生成 .start(); ``` 　　或使用异步连接方式： From 8794048f15cdbee2f7900b342096b2e524d64b17 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?=E5=91=A8=E6=97=AD?= <15735559897@qq.com> Date: Wed, 8 Apr 2020 23:36:12 +0800 Subject: [PATCH 043/924] SimpleTests --- .../java/com/ejlchina/test/SimpleTests.java | 73 +++++++++++++++++++ src/test/java/com/ejlchina/test/User.java | 27 ------- 2 files changed, 73 insertions(+), 27 deletions(-) create mode 100644 src/test/java/com/ejlchina/test/SimpleTests.java delete mode 100644 src/test/java/com/ejlchina/test/User.java diff --git a/src/test/java/com/ejlchina/test/SimpleTests.java b/src/test/java/com/ejlchina/test/SimpleTests.java new file mode 100644 index 00000000..f1e92e7e --- /dev/null +++ b/src/test/java/com/ejlchina/test/SimpleTests.java @@ -0,0 +1,73 @@ +package com.ejlchina.test; + +import com.ejlchina.okhttps.HTTP; +import com.ejlchina.okhttps.HttpResult; +import org.junit.Test; + +import java.util.List; + +public class SimpleTests { + + + HTTP http = HTTP.builder() + .baseUrl("http://localhost:8080") + .build(); + + /** + * 同步请求示例 + */ + @Test + public void testSync() { + List users = http.sync("/users") // http://localhost:8080/users + .get() // GET请求 + .getBody() // 获取响应报文体 + .toList(User.class); // 得到目标数据 + System.out.println("users = " + users); + } + + /** + * 异步请求示例 + */ + @Test + public void testAsync() { + http.async("/users/1") // http://api.demo.com/users/1 + .setOnResponse((HttpResult result) -> { + // 得到目标数据 + User user = result.getBody().toBean(User.class); + System.out.println("user = " + user); + }) + .get(); + sleep(5000); + } + + + void sleep(int millis) { + try { + Thread.sleep(millis); + } catch (InterruptedException e) { + e.printStackTrace(); + } + } + +} + + +class User { + + private int id; + private String name; + + public void setId(int id) { + this.id = id; + } + + public void setName(String name) { + this.name = name; + } + + @Override + public String toString() { + return "User [id=" + id + ", name=" + name + "]"; + } + +} \ No newline at end of file diff --git a/src/test/java/com/ejlchina/test/User.java b/src/test/java/com/ejlchina/test/User.java deleted file mode 100644 index bdf75c9d..00000000 --- a/src/test/java/com/ejlchina/test/User.java +++ /dev/null @@ -1,27 +0,0 @@ -package com.ejlchina.test; - -public class User { - - int id; - String name; - - public void setId(int id) { - this.id = id; - } - public void setName(String name) { - this.name = name; - } - - public int getId() { - return id; - } - public String getName() { - return name; - } - - @Override - public String toString() { - return "User [id=" + id + ", name=" + name + "]"; - } - -} From d912448b9151afbe9690f6dc6abc87bf22850c61 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?=E5=91=A8=E6=97=AD?= <15735559897@qq.com> Date: Wed, 8 Apr 2020 23:57:35 +0800 Subject: [PATCH 044/924] SimpleTests --- .../java/com/ejlchina/test/SimpleTests.java | 37 +++++++++++++++++++ 1 file changed, 37 insertions(+) diff --git a/src/test/java/com/ejlchina/test/SimpleTests.java b/src/test/java/com/ejlchina/test/SimpleTests.java index f1e92e7e..78f41c29 100644 --- a/src/test/java/com/ejlchina/test/SimpleTests.java +++ b/src/test/java/com/ejlchina/test/SimpleTests.java @@ -2,6 +2,7 @@ import com.ejlchina.okhttps.HTTP; import com.ejlchina.okhttps.HttpResult; +import com.ejlchina.okhttps.HttpResult.Body; import org.junit.Test; import java.util.List; @@ -15,6 +16,7 @@ public class SimpleTests { /** * 同步请求示例 + * 同步请求直接得到结果，无需设置回调 */ @Test public void testSync() { @@ -27,6 +29,7 @@ public void testSync() { /** * 异步请求示例 + * 异步请求在OnResponse里接收请求结果 */ @Test public void testAsync() { @@ -41,6 +44,40 @@ public void testAsync() { } + /** + * 启用 cache 示例 + */ + @Test + public void testCache() { + Body body = http.sync("/users").get().getBody() + .cache(); // 启用 cache + // 使用 cache 后，可以多次使用 toXXX() 方法 + System.out.println(body.toString()); + System.out.println(body.toJsonArray()); + System.out.println(body.toList(User.class)); + } + + + /** + * 获取文件大小示例 + */ + @Test + public void testContentLength() { + long t = System.currentTimeMillis(); + + long size = http.sync("https://download.cocos.com/CocosDashboard/v1.0.1/CocosDashboard-v1.0.1-win32-031816.exe") + .get().getBody() + .close() // 只是想获得文件大小，不消费报文体，所以直接关闭 + .getContentLength(); // 获得待下载文件的大小 + + t = System.currentTimeMillis() - t; + + // 由于未消费报文体，所以本次请求不会消耗下载报文体的时间和网络流量） + System.out.println("耗时：" + t + " 毫秒"); + System.out.println("size = " + (size / 1024) + " KB"); + } + + void sleep(int millis) { try { Thread.sleep(millis); From 062853b773871763317a195f1bcedaa368ae5cf7 Mon Sep 17 00:00:00 2001 From: ejlchina Date: Thu, 9 Apr 2020 09:59:55 +0800 Subject: [PATCH 045/924] update README.md. --- README.md | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/README.md b/README.md index f844d1dc..82ebb80f 100644 --- a/README.md +++ b/README.md @@ -728,7 +728,7 @@ HTTP http = HTTP.builder() }) .build(); ``` -　　上述代码便实现了让 **所有** 的 **回调函数** 都在 **主线程** 执行的目的，如： +　　上述代码便实现了让 **所有** 的 **回调函数** 都在 **主线程（UI线程）** 执行的目的，如： ```java http.async("/users") From a8ea604e618aef7008ceee2a90ed7a76581c49ea Mon Sep 17 00:00:00 2001 From: ejlchina Date: Thu, 9 Apr 2020 10:00:52 +0800 Subject: [PATCH 046/924] update README.md. --- README.md | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/README.md b/README.md index 82ebb80f..8ad48ef1 100644 --- a/README.md +++ b/README.md @@ -53,7 +53,7 @@ + [9 文件上传](#9-文件上传) - [9.1 上传进度监听](#91-上传进度监听) - [9.2 上传过程控制](#92-上传过程控制) - + [10 执行线程自由切换（for Android）](#10-执行线程自由切换for-android) + + [10 回调线程自由切换（for Android）](#10-回调线程自由切换for-android) + [参考文档](#参考文档) + [联系方式](#联系方式) @@ -712,7 +712,7 @@ call.cancel(); // 取消上传 ``` 　　上传就没有暂停和继续这个功能啦，应该没人有这个需求吧? -### 10 执行线程自由切换（for Android） +### 10 回调线程自由切换（for Android） 　　在 Android 开发中，经常会把某些代码放到特点的线程去执行，比如网络请求响应后的页面更新在主线程（UI线程）执行，而保存文件则在IO线程操作。OkHttps 为这类问题提供了良好的方案。 From 884a4d252ce90ef8704373380eacab2f5241569b Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?=E5=91=A8=E6=97=AD?= Date: Thu, 9 Apr 2020 10:12:40 +0800 Subject: [PATCH 047/924] readme --- README.md | 19 ++++++++++++++++--- 1 file changed, 16 insertions(+), 3 deletions(-) diff --git a/README.md b/README.md index 8ad48ef1..8459860a 100644 --- a/README.md +++ b/README.md @@ -53,7 +53,10 @@ + [9 文件上传](#9-文件上传) - [9.1 上传进度监听](#91-上传进度监听) - [9.2 上传过程控制](#92-上传过程控制) - + [10 回调线程自由切换（for Android）](#10-回调线程自由切换for-android) + + [10 异常处理](#10-异常处理) + - [10.1 同步方式](#101-同步方式) + - [10.2 异步方式](#102-异步方式) + + [11 回调线程自由切换（for Android）](#11-回调线程自由切换for-android) + [参考文档](#参考文档) + [联系方式](#联系方式) @@ -192,7 +195,7 @@ http.async("/users/{id}") // http://api.demo.com/users/1 * `getContentLength()` 返回报文体的字节长度 * `cache()` 缓存报文体，开启缓存后可重复使用`toXXX()`类方法 * `close()` 关闭报文体，未对报文体做任何消费时使用，比如只读取报文头 -* `getError()` 执行中发生的异常，自动捕获执行请求是发生的 网络超时、网络错误 和 其它请求异常 +* `getError()` 执行中发生的异常，自动捕获执行请求时发生的 网络超时、网络错误 和 其它IO异常 * `close()` 关闭报文，未对报文体做任何消费时使用，比如只读取长度 　　示例，请求结果自动转Bean和List： @@ -712,7 +715,17 @@ call.cancel(); // 取消上传 ``` 　　上传就没有暂停和继续这个功能啦，应该没人有这个需求吧? -### 10 回调线程自由切换（for Android） +### 10 异常处理 + +#### 10.1 同步方式 + +文档完善中... + +#### 10.2 异步方式 + +文档完善中... + +### 11 回调线程自由切换（for Android） 　　在 Android 开发中，经常会把某些代码放到特点的线程去执行，比如网络请求响应后的页面更新在主线程（UI线程）执行，而保存文件则在IO线程操作。OkHttps 为这类问题提供了良好的方案。 From b74e2fe706b4d5e63c38e0243e7f99910c5c05bf Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?=E5=91=A8=E6=97=AD?= Date: Thu, 9 Apr 2020 10:16:36 +0800 Subject: [PATCH 048/924] readme --- README.md | 2 ++ 1 file changed, 2 insertions(+) diff --git a/README.md b/README.md index 8459860a..a2214606 100644 --- a/README.md +++ b/README.md @@ -717,6 +717,8 @@ call.cancel(); // 取消上传 ### 10 异常处理 +　　相比其它的 HTTP 开发包，OkHttps 提供了更多的异常处理方式，以满足不同的异常处理需求。 + #### 10.1 同步方式 文档完善中... From 73ae5e3cc282b01cc67f1541e0ff0b1be36b12ad Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?=E5=91=A8=E6=97=AD?= Date: Thu, 9 Apr 2020 10:17:46 +0800 Subject: [PATCH 049/924] readme --- README.md | 6 +++--- 1 file changed, 3 insertions(+), 3 deletions(-) diff --git a/README.md b/README.md index a2214606..ff0d0045 100644 --- a/README.md +++ b/README.md @@ -717,13 +717,13 @@ call.cancel(); // 取消上传 ### 10 异常处理 -　　相比其它的 HTTP 开发包，OkHttps 提供了更多的异常处理方式，以满足不同的异常处理需求。 +　　相比其它的 HTTP 开发包，OkHttps 提供了更多的异常处理方法，以满足不同的异常处理需求。 -#### 10.1 同步方式 +#### 10.1 同步请求的异常 文档完善中... -#### 10.2 异步方式 +#### 10.2 异步请求的异常 文档完善中... From 90ed6c0e352ed02824393daee79260c4e705e545 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?=E5=91=A8=E6=97=AD?= Date: Thu, 9 Apr 2020 11:22:37 +0800 Subject: [PATCH 050/924] =?UTF-8?q?=E4=BC=98=E5=8C=96=20HttpResult.getErro?= =?UTF-8?q?r()=20=E6=96=B9=E6=B3=95=E7=9A=84=E8=BF=94=E5=9B=9E=E7=B1=BB?= =?UTF-8?q?=E5=9E=8B=20Exception=20=E5=85=B7=E4=BD=93=E5=88=B0=20IOExcepti?= =?UTF-8?q?on?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- src/main/java/com/ejlchina/okhttps/HttpResult.java | 3 ++- .../com/ejlchina/okhttps/internal/RealHttpResult.java | 9 +++++---- 2 files changed, 7 insertions(+), 5 deletions(-) diff --git a/src/main/java/com/ejlchina/okhttps/HttpResult.java b/src/main/java/com/ejlchina/okhttps/HttpResult.java index 63424db2..88984b72 100644 --- a/src/main/java/com/ejlchina/okhttps/HttpResult.java +++ b/src/main/java/com/ejlchina/okhttps/HttpResult.java @@ -1,6 +1,7 @@ package com.ejlchina.okhttps; import java.io.File; +import java.io.IOException; import java.io.InputStream; import java.io.Reader; import java.util.List; @@ -264,7 +265,7 @@ public interface Body { /** * @return 执行中发生的异常 */ - Exception getError(); + IOException getError(); /** * 关闭报文 diff --git a/src/main/java/com/ejlchina/okhttps/internal/RealHttpResult.java b/src/main/java/com/ejlchina/okhttps/internal/RealHttpResult.java index 4de88afd..f6eab345 100644 --- a/src/main/java/com/ejlchina/okhttps/internal/RealHttpResult.java +++ b/src/main/java/com/ejlchina/okhttps/internal/RealHttpResult.java @@ -1,5 +1,6 @@ package com.ejlchina.okhttps.internal; +import java.io.IOException; import java.util.Collections; import java.util.List; @@ -14,7 +15,7 @@ public class RealHttpResult implements HttpResult { private State state; private Response response; - private Exception error; + private IOException error; private TaskExecutor taskExecutor; private HttpTask httpTask; private Body body; @@ -34,13 +35,13 @@ public RealHttpResult(HttpTask httpTask, TaskExecutor taskExecutor) { this.taskExecutor = taskExecutor; } - public RealHttpResult(HttpTask httpTask, State state, Exception error) { + public RealHttpResult(HttpTask httpTask, State state, IOException error) { this.httpTask = httpTask; exception(state, error); } - public void exception(State state, Exception error) { + public void exception(State state, IOException error) { this.state = state; this.error = error; } @@ -104,7 +105,7 @@ public Body getBody() { } @Override - public Exception getError() { + public IOException getError() { return error; } From e898b069d25c608ca6ccd3077e3c292df9b283b7 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?=E5=91=A8=E6=97=AD?= Date: Thu, 9 Apr 2020 11:23:41 +0800 Subject: [PATCH 051/924] =?UTF-8?q?readme:=20=E5=90=8C=E6=AD=A5=E8=AF=B7?= =?UTF-8?q?=E6=B1=82=E7=9A=84=E5=BC=82=E5=B8=B8=E5=A4=84=E7=90=86?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- README.md | 45 ++++++++++++++++++++++++++++++++++++++++++++- 1 file changed, 44 insertions(+), 1 deletion(-) diff --git a/README.md b/README.md index ff0d0045..1ff3d618 100644 --- a/README.md +++ b/README.md @@ -721,7 +721,50 @@ call.cancel(); // 取消上传 #### 10.1 同步请求的异常 -文档完善中... +　　默认情况下，当请求执行异常时，会直接向外抛出，我们可以用 `try catch` 来捕获，例如： + +```java +try { + HttpResult result = http.sync("/users/1").get(); +} catch (HttpException e) { + Throwable cause = e.getCause(); // 得到异常原因 + if (cause instanceof ConnectException) { + // 当没网络时，会抛出连接异常 + } + if (cause instanceof SocketTimeoutException) { + // 当接口长时间未响应，会抛出超时异常 + } + if (cause instanceof UnknownHostException) { + // 当把域名或IP写错，会抛出 UnknownHost 异常 + } + // ... +} +``` +　　这种传统的异常处理方式，当然可以解决问题，但是 OkHttps 提供了更优雅的方案： + +``` +HttpResult result = http.sync("/users/1") + .nothrow() // 告诉 OkHttps 发生异常时不要直接向外抛出 + .get(); +State state = result.getState(); // 得到请求执行状态 +if (state == State.RESPONSED) { + // 请求已正常响应 +} +if (state == State.CANCELED) { + // 请求已被取消 +} +if (state == State.NETWORK_ERROR) { + // 网络错误，说明用户没网了 +} +if (state == State.TIMEOUT) { + // 请求超时 +} +if (state == State.EXCEPTION) { + // 其它请求异常 +} +// 还可以获得具体的异常信息 +Exception err = result.getError(); +``` #### 10.2 异步请求的异常 From c16276c1373c72794e2bd29042d24d6ba5c63c5d Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?=E5=91=A8=E6=97=AD?= Date: Thu, 9 Apr 2020 11:26:37 +0800 Subject: [PATCH 052/924] =?UTF-8?q?readme:=20=E5=90=8C=E6=AD=A5=E8=AF=B7?= =?UTF-8?q?=E6=B1=82=E7=9A=84=E5=BC=82=E5=B8=B8=E5=A4=84=E7=90=86?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- README.md | 6 +++--- 1 file changed, 3 insertions(+), 3 deletions(-) diff --git a/README.md b/README.md index 1ff3d618..18be0c65 100644 --- a/README.md +++ b/README.md @@ -54,8 +54,8 @@ - [9.1 上传进度监听](#91-上传进度监听) - [9.2 上传过程控制](#92-上传过程控制) + [10 异常处理](#10-异常处理) - - [10.1 同步方式](#101-同步方式) - - [10.2 异步方式](#102-异步方式) + - [10.1 同步请求的异常](#101-同步请求的异常) + - [10.2 异步请求的异常](#102-异步请求的异常) + [11 回调线程自由切换（for Android）](#11-回调线程自由切换for-android) + [参考文档](#参考文档) + [联系方式](#联系方式) @@ -742,7 +742,7 @@ try { ``` 　　这种传统的异常处理方式，当然可以解决问题，但是 OkHttps 提供了更优雅的方案： -``` +```java HttpResult result = http.sync("/users/1") .nothrow() // 告诉 OkHttps 发生异常时不要直接向外抛出 .get(); From 999b12f137007aa985738fef8a45b716fff50d4c Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?=E5=91=A8=E6=97=AD?= Date: Thu, 9 Apr 2020 11:35:37 +0800 Subject: [PATCH 053/924] =?UTF-8?q?readme:=20=E5=90=8C=E6=AD=A5=E8=AF=B7?= =?UTF-8?q?=E6=B1=82=E7=9A=84=E5=BC=82=E5=B8=B8=E5=A4=84=E7=90=86?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- README.md | 29 +++++++++---------- .../java/com/ejlchina/test/SimpleTests.java | 1 - 2 files changed, 13 insertions(+), 17 deletions(-) diff --git a/README.md b/README.md index 18be0c65..17d7a247 100644 --- a/README.md +++ b/README.md @@ -746,24 +746,21 @@ try { HttpResult result = http.sync("/users/1") .nothrow() // 告诉 OkHttps 发生异常时不要直接向外抛出 .get(); -State state = result.getState(); // 得到请求执行状态 -if (state == State.RESPONSED) { - // 请求已正常响应 -} -if (state == State.CANCELED) { - // 请求已被取消 -} -if (state == State.NETWORK_ERROR) { - // 网络错误，说明用户没网了 -} -if (state == State.TIMEOUT) { - // 请求超时 -} -if (state == State.EXCEPTION) { - // 其它请求异常 +// 判断执行状态 +switch (result.getState()) { + case RESPONSED: // 请求已正常响应 + break; + case CANCELED: // 请求已被取消 + break; + case NETWORK_ERROR: // 网络错误，说明用户没网了 + break; + case TIMEOUT: // 请求超时 + break; + case EXCEPTION: // 其它异常 + break; } // 还可以获得具体的异常信息 -Exception err = result.getError(); +Exception error = result.getError(); ``` #### 10.2 异步请求的异常 diff --git a/src/test/java/com/ejlchina/test/SimpleTests.java b/src/test/java/com/ejlchina/test/SimpleTests.java index 78f41c29..da3b3472 100644 --- a/src/test/java/com/ejlchina/test/SimpleTests.java +++ b/src/test/java/com/ejlchina/test/SimpleTests.java @@ -77,7 +77,6 @@ public void testContentLength() { System.out.println("size = " + (size / 1024) + " KB"); } - void sleep(int millis) { try { Thread.sleep(millis); From b14c3cbdbd628521e97e760ffb44b634de2ea25f Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?=E5=91=A8=E6=97=AD?= Date: Thu, 9 Apr 2020 11:38:53 +0800 Subject: [PATCH 054/924] readme --- README.md | 5 +- .../com/ejlchina/test/ExceptionTests.java | 72 +++++++++++++++++++ 2 files changed, 74 insertions(+), 3 deletions(-) create mode 100644 src/test/java/com/ejlchina/test/ExceptionTests.java diff --git a/README.md b/README.md index 17d7a247..7cdb00aa 100644 --- a/README.md +++ b/README.md @@ -743,9 +743,8 @@ try { 　　这种传统的异常处理方式，当然可以解决问题，但是 OkHttps 提供了更优雅的方案： ```java -HttpResult result = http.sync("/users/1") - .nothrow() // 告诉 OkHttps 发生异常时不要直接向外抛出 - .get(); +// 使用 nothrow 方法告诉 OkHttps 发生异常时不要直接向外抛出 +HttpResult result = http.sync("/users/1").nothrow().get(); // 判断执行状态 switch (result.getState()) { case RESPONSED: // 请求已正常响应 diff --git a/src/test/java/com/ejlchina/test/ExceptionTests.java b/src/test/java/com/ejlchina/test/ExceptionTests.java new file mode 100644 index 00000000..aeb31d5c --- /dev/null +++ b/src/test/java/com/ejlchina/test/ExceptionTests.java @@ -0,0 +1,72 @@ +package com.ejlchina.test; + +import com.ejlchina.okhttps.HTTP; +import com.ejlchina.okhttps.HttpResult; +import com.ejlchina.okhttps.internal.HttpException; +import org.junit.Test; + +import java.net.ConnectException; +import java.net.SocketTimeoutException; +import java.net.UnknownHostException; + +public class ExceptionTests { + + HTTP http = HTTP.builder() + .baseUrl("http://localhost:8080") + .build(); + + @Test + public void testSync0() { + try { + HttpResult result = http.sync("/users/1").get(); + System.out.println("请求结果：" + result); + } catch (HttpException e) { + Throwable cause = e.getCause(); // 得到异常原因 + if (cause instanceof ConnectException) { + // 当没网络时，会抛出连接异常 + } + if (cause instanceof SocketTimeoutException) { + // 当接口长时间未响应，会抛出超时异常 + } + if (cause instanceof UnknownHostException) { + // 当把域名或IP写错，会抛出 UnknownHost 异常 + } + // ... + } + } + + @Test + public void testSync1() { + HttpResult result = http.sync("/users/1") + .nothrow() // 告诉 OkHttps 发生异常时不要直接向外抛出 + .get(); + // 判断执行状态 + switch (result.getState()) { + case RESPONSED: // 请求已正常响应 + + break; + case CANCELED: // 请求已被取消 + + break; + case NETWORK_ERROR: // 网络错误，说明用户没网了 + + break; + case TIMEOUT: // 请求超时 + + break; + case EXCEPTION: // 其它异常 + + break; + } + // 还可以获得具体的异常信息 + Exception error = result.getError(); + + + } + + @Test + public void testASync() { + + } + +} From 03fea6905fa627d2edebb7a102f2f3b7ca49bb28 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?=E5=91=A8=E6=97=AD?= Date: Thu, 9 Apr 2020 12:37:35 +0800 Subject: [PATCH 055/924] =?UTF-8?q?readme:=20=E5=BC=82=E6=AD=A5=E8=AF=B7?= =?UTF-8?q?=E6=B1=82=E7=9A=84=E5=BC=82=E5=B8=B8=E5=A4=84=E7=90=86?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- README.md | 50 ++++++++++++++++++- .../com/ejlchina/test/ExceptionTests.java | 32 +++++++++++- 2 files changed, 79 insertions(+), 3 deletions(-) diff --git a/README.md b/README.md index 7cdb00aa..6cccea99 100644 --- a/README.md +++ b/README.md @@ -717,7 +717,7 @@ call.cancel(); // 取消上传 ### 10 异常处理 -　　相比其它的 HTTP 开发包，OkHttps 提供了更多的异常处理方法，以满足不同的异常处理需求。 +　　相比其它的 HTTP 开发包，OkHttps 额外提供了一个特别的异常处理方发（`nothrow()`），以满足不同的异常处理需求。 #### 10.1 同步请求的异常 @@ -764,7 +764,53 @@ Exception error = result.getError(); #### 10.2 异步请求的异常 -文档完善中... +　　异步请求的使用最多的异常处理方式是设置一个异常回调： + +```java +http.async("/users/1") + .setOnResponse((HttpResult result) -> { + // 当发生异常时就不会走这里 + }) + .setOnException((IOException e) -> { + // 这里处理请求异常 + }) + .get(); +``` +　　如果不设置`OnException`回调，发生异常时会在 **IO线程池** 中向上抛出，外层无法捕获： + +```java +try { + http.async("/users/1") + .setOnResponse((HttpResult result) -> { + // 当发生异常时就不会走这里 + }) + .get(); +} catch (HttpException e) { + // 这种方式是捕获不到异常的！！！！ +} +``` +　　但即使不设置`OnException`回调，发生异常时，依然会走`OnComplete`回调： + +```java +http.async("/users/1") + .setOnResponse((HttpResult result) -> { + // 当发生异常时就不会走这里 + }) + .setOnComplete((State state) -> { + // 发生异常，会先执行这里，但执行完后依然会在IO线程中向上抛出 + }) + .get(); +``` +　　如果就是想 **不处理异常，也不向上抛出**，可以做到吗？可以！使用`nothrow()`方法： + +```java +http.async("/users/1") + .nothrow() // 告诉 OkHttps 发生异常时不向外抛出 + .setOnResponse((HttpResult result) -> { + // 当发生异常时就不会走这里 + }) + .get(); +``` ### 11 回调线程自由切换（for Android） diff --git a/src/test/java/com/ejlchina/test/ExceptionTests.java b/src/test/java/com/ejlchina/test/ExceptionTests.java index aeb31d5c..aafeedf1 100644 --- a/src/test/java/com/ejlchina/test/ExceptionTests.java +++ b/src/test/java/com/ejlchina/test/ExceptionTests.java @@ -3,16 +3,24 @@ import com.ejlchina.okhttps.HTTP; import com.ejlchina.okhttps.HttpResult; import com.ejlchina.okhttps.internal.HttpException; +import okhttp3.OkHttpClient; import org.junit.Test; +import java.io.IOException; import java.net.ConnectException; import java.net.SocketTimeoutException; import java.net.UnknownHostException; +import java.util.concurrent.TimeUnit; public class ExceptionTests { HTTP http = HTTP.builder() - .baseUrl("http://localhost:8080") + .config((OkHttpClient.Builder builder) -> { + builder.connectTimeout(2, TimeUnit.SECONDS); + builder.writeTimeout(2, TimeUnit.SECONDS); + builder.readTimeout(2, TimeUnit.SECONDS); + }) + .baseUrl("http://localhost:8081") .build(); @Test @@ -67,6 +75,28 @@ public void testSync1() { @Test public void testASync() { + http.async("/users/1") + .setOnResponse((HttpResult result) -> { + // 当发生异常时就不会走这里 + System.out.println(result); + }) + .setOnException((IOException e) -> { + // 这里处理请求异常 + System.out.println(e); + }) + .get(); + + sleep(10000); + } + + + + void sleep(int millis) { + try { + Thread.sleep(millis); + } catch (InterruptedException e) { + e.printStackTrace(); + } } } From 889968a04470c19d3dba64c272ab70a0be7db172 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?=E5=91=A8=E6=97=AD?= Date: Thu, 9 Apr 2020 12:44:13 +0800 Subject: [PATCH 056/924] =?UTF-8?q?=E3=80=82=E3=80=82?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- README.md | 7 ++++--- 1 file changed, 4 insertions(+), 3 deletions(-) diff --git a/README.md b/README.md index 6cccea99..602688e2 100644 --- a/README.md +++ b/README.md @@ -717,7 +717,7 @@ call.cancel(); // 取消上传 ### 10 异常处理 -　　相比其它的 HTTP 开发包，OkHttps 额外提供了一个特别的异常处理方发（`nothrow()`），以满足不同的异常处理需求。 +　　使用 OkHttps 时，**异常处理不是必须的**，但相比其它的 HTTP 开发包，它还是额外提供了一个特别的处理方发（`nothrow()`），以满足不同的异常处理需求。 #### 10.1 同步请求的异常 @@ -789,7 +789,7 @@ try { // 这种方式是捕获不到异常的！！！！ } ``` -　　但即使不设置`OnException`回调，发生异常时，依然会走`OnComplete`回调： +　　即使不设置`OnException`回调，发生异常时，依然会走`OnComplete`回调： ```java http.async("/users/1") @@ -797,7 +797,8 @@ http.async("/users/1") // 当发生异常时就不会走这里 }) .setOnComplete((State state) -> { - // 发生异常，会先执行这里，但执行完后依然会在IO线程中向上抛出 + // 发生异常，会先执行这里，可以更加 state 判断发生了什么 + // 但执行完后依然会在IO线程中向上抛出 }) .get(); ``` From 5cad02590cc06cf3cb3f8f41695217e2c5dad4c4 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?=E5=91=A8=E6=97=AD?= Date: Thu, 9 Apr 2020 12:46:36 +0800 Subject: [PATCH 057/924] readme --- README.md | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/README.md b/README.md index 602688e2..ce385097 100644 --- a/README.md +++ b/README.md @@ -721,7 +721,7 @@ call.cancel(); // 取消上传 #### 10.1 同步请求的异常 -　　默认情况下，当请求执行异常时，会直接向外抛出，我们可以用 `try catch` 来捕获，例如： +　　默认情况下，当同步请求执行异常时，会直接向外抛出，我们可以用 `try catch` 来捕获，例如： ```java try { From ec54f5e680ccbebcd5e29376abbe2da6a215c27c Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?=E5=91=A8=E6=97=AD?= Date: Thu, 9 Apr 2020 13:15:21 +0800 Subject: [PATCH 058/924] readme --- README.md | 8 ++++++-- 1 file changed, 6 insertions(+), 2 deletions(-) diff --git a/README.md b/README.md index ce385097..9519bb9f 100644 --- a/README.md +++ b/README.md @@ -57,6 +57,7 @@ - [10.1 同步请求的异常](#101-同步请求的异常) - [10.2 异步请求的异常](#102-异步请求的异常) + [11 回调线程自由切换（for Android）](#11-回调线程自由切换for-android) + + [12 实现生命周期绑定（for Android）](#12-实现生命周期绑定for-android) + [参考文档](#参考文档) + [联系方式](#联系方式) @@ -357,7 +358,7 @@ HTTP http = HTTP.builder() }) .build(); ``` -　　该配置影响所有回调。 +　　该配置**影响所有回调**。 #### 6.3 配置 OkHttpClient @@ -888,9 +889,12 @@ http.sync("/download/test.zip") }) .start(); ``` +### 12 实现生命周期绑定（for Android） + +文档完善中，敬请期待... -## 参考文档 +## 参考文档 ## 联系方式 From f5a8569a3b66ceaaf475d37a596645961deb9154 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?=E5=91=A8=E6=97=AD?= Date: Thu, 9 Apr 2020 13:20:53 +0800 Subject: [PATCH 059/924] readme --- README.md | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/README.md b/README.md index 9519bb9f..fd69be14 100644 --- a/README.md +++ b/README.md @@ -358,7 +358,7 @@ HTTP http = HTTP.builder() }) .build(); ``` -　　该配置**影响所有回调**。 +　　该配置默认 **影响所有回调**。 #### 6.3 配置 OkHttpClient From 31eae6de662479b19ca12614bd896cb8eee1ef88 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?=E5=91=A8=E6=97=AD?= Date: Thu, 9 Apr 2020 13:23:32 +0800 Subject: [PATCH 060/924] readme --- README.md | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/README.md b/README.md index fd69be14..d18d156f 100644 --- a/README.md +++ b/README.md @@ -349,7 +349,7 @@ http.sync("https://www.baidu.com").get() #### 6.2 回调执行器 -　　如何想改变执行回调函数的线程时，可以配置回调执行器。例如在Android里，让所有的回调函数都在UI线程执行，则可以在构建`HTTP`时配置如下： +　　OkHttps 默认所有回调都在 **IO线程** 执行，如何想改变执行回调的线程时，可以配置回调执行器。例如在Android里，让所有的回调函数都在UI线程执行，则可以在构建`HTTP`时配置如下： ```java HTTP http = HTTP.builder() From 462bb08338ec57446fc96af40b2fa36290bf2a93 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?=E5=91=A8=E6=97=AD?= Date: Thu, 9 Apr 2020 13:32:51 +0800 Subject: [PATCH 061/924] readme --- README.md | 16 ++++++++-------- 1 file changed, 8 insertions(+), 8 deletions(-) diff --git a/README.md b/README.md index d18d156f..78a25dbc 100644 --- a/README.md +++ b/README.md @@ -260,7 +260,7 @@ System.out.println(call.isCanceled()); // true ### 4 构建HTTP任务 -　　`HTTP`对象的`sync`与`async`方法返回一个`HttpTask`对象，该对象提供了可链式调用的`addXXX`与`setXXX`系列方法用于构建任务本身。 +　　`HTTP`对象的`sync`与`async`方法返回一个`HttpTask`对象，该对象提供了可链式调用的`addXXX`与`setXXX`等系列方法用于构建任务本身。 * `addHeader(String name, String value)` 添加请求头 * `addHeader(Map headers)` 添加请求头 @@ -384,7 +384,7 @@ HTTP http = HTTP.builder() #### 6.4 并行预处理器 -　　预处理器（`Preprocessor`）可以让我们在请求发出之前对请求本身做一些改变，但与`OkHttp`的拦截器（`Interceptor`）不同：预处理器可以让我们**异步**处理这些问题。 +　　预处理器（`Preprocessor`）可以让我们在请求发出之前对请求本身做一些改变，但与`OkHttp`的拦截器（`Interceptor`）不同：预处理器可以让我们 **异步** 处理这些问题。 　　例如，当我们想为请求任务自动添加`Token`头信息，而`Token`只能通过异步方法`requestToken`获取时，这时使用`Interceptor`就很难处理了，但可以使用预处理器轻松解决： @@ -592,7 +592,7 @@ http.async("/download/test.zip") #### 8.3 实现断点续传 -　　OkHttps 对断点续传并没有再做更高层次的封装，因为这是app该去做的事情，它在设计上使各种网络问题的处理变简单的同时力求纯粹。下面的例子可以看到，OkHttps 通过一个失败回调拿到**断点**，便将复杂的问题变得简单： +　　OkHttps 对断点续传并没有再做更高层次的封装，因为这是app该去做的事情，它在设计上使各种网络问题的处理变简单的同时力求纯粹。下面的例子可以看到，OkHttps 通过一个失败回调拿到 **断点**，便将复杂的问题变得简单： ```java http.sync("/download/test.zip") @@ -718,7 +718,7 @@ call.cancel(); // 取消上传 ### 10 异常处理 -　　使用 OkHttps 时，**异常处理不是必须的**，但相比其它的 HTTP 开发包，它还是额外提供了一个特别的处理方发（`nothrow()`），以满足不同的异常处理需求。 +　　使用 OkHttps 时，**异常处理不是必须的**，但相比其它的 HTTP 开发包，它还是额外提供了一个特别的处理方法（`nothrow()`），以满足不同的异常处理需求。 #### 10.1 同步请求的异常 @@ -777,7 +777,7 @@ http.async("/users/1") }) .get(); ``` -　　如果不设置`OnException`回调，发生异常时会在 **IO线程池** 中向上抛出，外层无法捕获： +　　如果不设置`OnException`回调，发生异常时会在 **IO 线程** 中向上抛出，外层无法捕获： ```java try { @@ -787,7 +787,7 @@ try { }) .get(); } catch (HttpException e) { - // 这种方式是捕获不到异常的！！！！ + // 这种方式是捕获不到异常的！！！！！！ } ``` 　　即使不设置`OnException`回调，发生异常时，依然会走`OnComplete`回调： @@ -798,12 +798,12 @@ http.async("/users/1") // 当发生异常时就不会走这里 }) .setOnComplete((State state) -> { - // 发生异常，会先执行这里，可以更加 state 判断发生了什么 + // 发生异常，会先执行这里，可以根据 state 判断发生了什么 // 但执行完后依然会在IO线程中向上抛出 }) .get(); ``` -　　如果就是想 **不处理异常，也不向上抛出**，可以做到吗？可以！使用`nothrow()`方法： +　　如果就是想 **不处理异常，也不向上抛出**，可以做到吗？可以！还是使用`nothrow()`方法： ```java http.async("/users/1") From f6bee7c6017d80df398357ad8bdef0283207a90a Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?=E5=91=A8=E6=97=AD?= Date: Thu, 9 Apr 2020 13:34:29 +0800 Subject: [PATCH 062/924] readme --- README.md | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/README.md b/README.md index 78a25dbc..0d31e747 100644 --- a/README.md +++ b/README.md @@ -718,7 +718,7 @@ call.cancel(); // 取消上传 ### 10 异常处理 -　　使用 OkHttps 时，**异常处理不是必须的**，但相比其它的 HTTP 开发包，它还是额外提供了一个特别的处理方法（`nothrow()`），以满足不同的异常处理需求。 +　　使用 OkHttps 时，**异常处理不是必须的**，但相比其它的 HTTP 开发包，它还是提供了一个特别的处理方法：`nothrow()`，以满足不同的异常处理需求。 #### 10.1 同步请求的异常 From b34d4fdd43b315511ad26404294c72a92e5061c1 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?=E5=91=A8=E6=97=AD?= Date: Thu, 9 Apr 2020 13:34:52 +0800 Subject: [PATCH 063/924] readme --- README.md | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/README.md b/README.md index 0d31e747..83676cca 100644 --- a/README.md +++ b/README.md @@ -718,7 +718,7 @@ call.cancel(); // 取消上传 ### 10 异常处理 -　　使用 OkHttps 时，**异常处理不是必须的**，但相比其它的 HTTP 开发包，它还是提供了一个特别的处理方法：`nothrow()`，以满足不同的异常处理需求。 +　　使用 OkHttps 时，**异常处理不是必须的**，但相比其它的 HTTP 开发包，它还提供了一个特别的处理方法：`nothrow()`，以满足不同的异常处理需求。 #### 10.1 同步请求的异常 From 29f7472d2c351f7be021943c0433bf537ac7c2cd Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?=E5=91=A8=E6=97=AD?= Date: Thu, 9 Apr 2020 13:36:11 +0800 Subject: [PATCH 064/924] readme --- README.md | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/README.md b/README.md index 83676cca..4453bbb4 100644 --- a/README.md +++ b/README.md @@ -741,7 +741,7 @@ try { // ... } ``` -　　这种传统的异常处理方式，当然可以解决问题，但是 OkHttps 提供了更优雅的方案： +　　这种传统的异常处理方式，当然可以解决问题，但是 OkHttps 有更佳的方案： ```java // 使用 nothrow 方法告诉 OkHttps 发生异常时不要直接向外抛出 From 77d4c3b58dc32c86bf4bea11ae093cd4b7bd73d4 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?=E5=91=A8=E6=97=AD?= Date: Thu, 9 Apr 2020 13:39:02 +0800 Subject: [PATCH 065/924] readme --- README.md | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/README.md b/README.md index 4453bbb4..b27a2624 100644 --- a/README.md +++ b/README.md @@ -765,7 +765,7 @@ Exception error = result.getError(); #### 10.2 异步请求的异常 -　　异步请求的使用最多的异常处理方式是设置一个异常回调： +　　异步请求最常用的异常处理方式就是设置一个异常回调： ```java http.async("/users/1") @@ -803,7 +803,7 @@ http.async("/users/1") }) .get(); ``` -　　如果就是想 **不处理异常，也不向上抛出**，可以做到吗？可以！还是使用`nothrow()`方法： +　　如果就是想 **不处理异常，也不向上抛出**，发生错误完全无视，可以做到吗？可以！还是使用`nothrow()`方法： ```java http.async("/users/1") From c5303b41e6a97145f266bc837106a0f4be3c1f56 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?=E5=91=A8=E6=97=AD?= Date: Thu, 9 Apr 2020 13:48:12 +0800 Subject: [PATCH 066/924] readme --- README.md | 15 +++++++++++++-- 1 file changed, 13 insertions(+), 2 deletions(-) diff --git a/README.md b/README.md index b27a2624..50c17a75 100644 --- a/README.md +++ b/README.md @@ -777,7 +777,18 @@ http.async("/users/1") }) .get(); ``` -　　如果不设置`OnException`回调，发生异常时会在 **IO 线程** 中向上抛出，外层无法捕获： +　　当然，还有一个全局异常监听（`ExceptionListener`）： + +```java +HTTP http = HTTP.builder() + .exceptionListener((HttpTask task, IOException error) -> { + // 所有请求发生异常都会走这里 + + return true; // 返回 true 表示继续执行 task 的 OnException 回调，false 表示不再执行 + }) + .build(); +``` +　　如果不设置`OnException`回调，也没有`ExceptionListener`，发生异常时会在 **IO 线程** 中向上抛出，外层无法捕获： ```java try { @@ -790,7 +801,7 @@ try { // 这种方式是捕获不到异常的！！！！！！ } ``` -　　即使不设置`OnException`回调，发生异常时，依然会走`OnComplete`回调： +　　即使没有`OnException`回调，发生异常时，依然会走`OnComplete`回调，如果设置了的话： ```java http.async("/users/1") From 89d64a6adc5c9a367997591af86c053e9431d7c2 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?=E5=91=A8=E6=97=AD?= Date: Thu, 9 Apr 2020 13:53:25 +0800 Subject: [PATCH 067/924] readme --- README.md | 1 + 1 file changed, 1 insertion(+) diff --git a/README.md b/README.md index 50c17a75..11da4a26 100644 --- a/README.md +++ b/README.md @@ -157,6 +157,7 @@ http.async("/users/{id}") // http://api.demo.com/users/1 }) .setOnComplete((State state) -> { // 完成回调，无论成功失败都会执行 + // 并且在 响应|异常回调 之前执行 }) .get(); ``` From d4b6c4e5e9d577480983cbd1610e63fa0a8cd122 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?=E5=91=A8=E6=97=AD?= Date: Thu, 9 Apr 2020 14:02:17 +0800 Subject: [PATCH 068/924] .. --- README.md | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/README.md b/README.md index 11da4a26..54e390fc 100644 --- a/README.md +++ b/README.md @@ -719,7 +719,7 @@ call.cancel(); // 取消上传 ### 10 异常处理 -　　使用 OkHttps 时，**异常处理不是必须的**，但相比其它的 HTTP 开发包，它还提供了一个特别的处理方法：`nothrow()`，以满足不同的异常处理需求。 +　　使用 OkHttps 时，**异常处理不是必须的**，但相比其它的 HTTP 开发包，它还提供一个特别的处理方法：`nothrow()`，以满足不同的异常处理需求。 #### 10.1 同步请求的异常 From c27b3ecb1b875eb4b01d2ee58ddbc20157d75000 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?=E5=91=A8=E6=97=AD?= Date: Thu, 9 Apr 2020 14:19:03 +0800 Subject: [PATCH 069/924] readme --- README.md | 7 ++++--- 1 file changed, 4 insertions(+), 3 deletions(-) diff --git a/README.md b/README.md index 54e390fc..621db2f4 100644 --- a/README.md +++ b/README.md @@ -15,6 +15,9 @@ * 单方法回调，充分利用 Lambda 表达式 * TCP连接池、Http2 +> 1. OkHttps 非常轻量，自身代码在 2000 行左右 +> 2. OkHttps 有较高的编码质量，sonarqube 结果为 3A，[查看报告](https://gitee.com/ejlchina-zhxu/okhttps/quality_analyses?platform=sonar_qube) + ### 前世：[HttpUtils, V2.3.0 之后重命名为 OkHttps](https://gitee.com/ejlchina-zhxu/httputils) ### 当前文档版本[1.0.1] ### API文档：[https://apidoc.gitee.com/ejlchina-zhxu/okhttps](https://apidoc.gitee.com/ejlchina-zhxu/okhttps) @@ -58,8 +61,8 @@ - [10.2 异步请求的异常](#102-异步请求的异常) + [11 回调线程自由切换（for Android）](#11-回调线程自由切换for-android) + [12 实现生命周期绑定（for Android）](#12-实现生命周期绑定for-android) -+ [参考文档](#参考文档) + [联系方式](#联系方式) ++ [参与贡献](#参与贡献) ## 安装教程 @@ -906,8 +909,6 @@ http.sync("/download/test.zip") 文档完善中，敬请期待... -## 参考文档 - ## 联系方式 From ea7f08ac05a38cef32bc3b99b1a089a827a2887d Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?=E5=91=A8=E6=97=AD?= Date: Thu, 9 Apr 2020 14:19:43 +0800 Subject: [PATCH 070/924] readme --- README.md | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/README.md b/README.md index 621db2f4..a33f49ea 100644 --- a/README.md +++ b/README.md @@ -16,7 +16,7 @@ * TCP连接池、Http2 > 1. OkHttps 非常轻量，自身代码在 2000 行左右 -> 2. OkHttps 有较高的编码质量，sonarqube 结果为 3A，[查看报告](https://gitee.com/ejlchina-zhxu/okhttps/quality_analyses?platform=sonar_qube) +> 2. OkHttps 有较高的编码质量，sonarqube 分析结果为 3A，[查看报告](https://gitee.com/ejlchina-zhxu/okhttps/quality_analyses?platform=sonar_qube) ### 前世：[HttpUtils, V2.3.0 之后重命名为 OkHttps](https://gitee.com/ejlchina-zhxu/httputils) ### 当前文档版本[1.0.1] From 1229d3a61e61c2a87076a1688e94e471355e7860 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?=E5=91=A8=E6=97=AD?= Date: Thu, 9 Apr 2020 14:21:49 +0800 Subject: [PATCH 071/924] readme --- README.md | 3 +-- 1 file changed, 1 insertion(+), 2 deletions(-) diff --git a/README.md b/README.md index a33f49ea..98ca90d1 100644 --- a/README.md +++ b/README.md @@ -15,8 +15,7 @@ * 单方法回调，充分利用 Lambda 表达式 * TCP连接池、Http2 -> 1. OkHttps 非常轻量，自身代码在 2000 行左右 -> 2. OkHttps 有较高的编码质量，sonarqube 分析结果为 3A，[查看报告](https://gitee.com/ejlchina-zhxu/okhttps/quality_analyses?platform=sonar_qube) +> OkHttps 非常轻量，自身代码在 2000 行左右，且有较高的编码质量，sonarqube 分析结果为 3A，[查看报告](https://gitee.com/ejlchina-zhxu/okhttps/quality_analyses?platform=sonar_qube) ### 前世：[HttpUtils, V2.3.0 之后重命名为 OkHttps](https://gitee.com/ejlchina-zhxu/httputils) ### 当前文档版本[1.0.1] From cf3cf94d230936aeef2ffe0e1249244264a1e960 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?=E5=91=A8=E6=97=AD?= Date: Thu, 9 Apr 2020 14:30:07 +0800 Subject: [PATCH 072/924] readme --- README.md | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/README.md b/README.md index 98ca90d1..bdc34adf 100644 --- a/README.md +++ b/README.md @@ -15,7 +15,7 @@ * 单方法回调，充分利用 Lambda 表达式 * TCP连接池、Http2 -> OkHttps 非常轻量，自身代码在 2000 行左右，且有较高的编码质量，sonarqube 分析结果为 3A，[查看报告](https://gitee.com/ejlchina-zhxu/okhttps/quality_analyses?platform=sonar_qube) +> OkHttps 非常轻量，自身代码在 2000 行左右，且有较高的编码质量，sonarqube 分析结果为 3A ### 前世：[HttpUtils, V2.3.0 之后重命名为 OkHttps](https://gitee.com/ejlchina-zhxu/httputils) ### 当前文档版本[1.0.1] From 311f24197307a5a877be9dd370d6d5bce5ec1d02 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?=E5=91=A8=E6=97=AD?= Date: Thu, 9 Apr 2020 14:40:05 +0800 Subject: [PATCH 073/924] =?UTF-8?q?=E9=85=8D=E7=BD=AE=20sonar?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- pom.xml | 3 +++ 1 file changed, 3 insertions(+) diff --git a/pom.xml b/pom.xml index 1678b893..95b384e4 100644 --- a/pom.xml +++ b/pom.xml @@ -10,6 +10,9 @@ 1.8 UTF-8 https://oss.sonatype.org/content/repositories/snapshots/ + + src/main/java/com/ejlchina/okhttps/Preprocessor + From 377a0e3ba4739a089f68605b3c1efa33e24d84ab Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?=E5=91=A8=E6=97=AD?= Date: Thu, 9 Apr 2020 14:41:45 +0800 Subject: [PATCH 074/924] =?UTF-8?q?=E9=85=8D=E7=BD=AE=20sonar?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- pom.xml | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/pom.xml b/pom.xml index 95b384e4..c9d4cbcc 100644 --- a/pom.xml +++ b/pom.xml @@ -11,7 +11,7 @@ UTF-8 https://oss.sonatype.org/content/repositories/snapshots/ - src/main/java/com/ejlchina/okhttps/Preprocessor + src/main/java/com/ejlchina/okhttps/Preprocessor.java From 269f587dd8bbe349f75643afc495602401492b58 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?=E5=91=A8=E6=97=AD?= Date: Thu, 9 Apr 2020 14:47:00 +0800 Subject: [PATCH 075/924] .. --- pom.xml | 3 --- 1 file changed, 3 deletions(-) diff --git a/pom.xml b/pom.xml index c9d4cbcc..1678b893 100644 --- a/pom.xml +++ b/pom.xml @@ -10,9 +10,6 @@ 1.8 UTF-8 https://oss.sonatype.org/content/repositories/snapshots/ - - src/main/java/com/ejlchina/okhttps/Preprocessor.java - From dbff8b6d9dad9ad9cd9bca048170e019f55adedc Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?=E5=91=A8=E6=97=AD?= Date: Thu, 9 Apr 2020 14:55:53 +0800 Subject: [PATCH 076/924] =?UTF-8?q?=E5=88=A0=E9=99=A4=E6=97=A0=E7=94=A8?= =?UTF-8?q?=E4=BB=A3=E7=A0=81:=20HttpTask.toString(Response=20response)?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- src/main/java/com/ejlchina/okhttps/HttpTask.java | 10 ---------- 1 file changed, 10 deletions(-) diff --git a/src/main/java/com/ejlchina/okhttps/HttpTask.java b/src/main/java/com/ejlchina/okhttps/HttpTask.java index ae6067be..7469ef9b 100644 --- a/src/main/java/com/ejlchina/okhttps/HttpTask.java +++ b/src/main/java/com/ejlchina/okhttps/HttpTask.java @@ -568,16 +568,6 @@ private void buildHeaders(Request.Builder builder) { } } - - protected String toString(Response response) throws IOException { - String body = null; - ResponseBody rbody = response.body(); - if (rbody != null) { - body = rbody.string(); - } - return body; - } - protected State toState(IOException e) { if (e instanceof SocketTimeoutException) { return State.TIMEOUT; From 0e0f57b0f7bd977c20036d4e38ef4f930a7da5b8 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?=E5=91=A8=E6=97=AD?= Date: Thu, 9 Apr 2020 14:57:58 +0800 Subject: [PATCH 077/924] remove unused imports --- .../java/com/ejlchina/okhttps/HttpTask.java | 32 ++++++------------- 1 file changed, 10 insertions(+), 22 deletions(-) diff --git a/src/main/java/com/ejlchina/okhttps/HttpTask.java b/src/main/java/com/ejlchina/okhttps/HttpTask.java index 7469ef9b..392484d5 100644 --- a/src/main/java/com/ejlchina/okhttps/HttpTask.java +++ b/src/main/java/com/ejlchina/okhttps/HttpTask.java @@ -1,5 +1,14 @@ package com.ejlchina.okhttps; +import com.alibaba.fastjson.JSON; +import com.ejlchina.okhttps.HttpResult.State; +import com.ejlchina.okhttps.internal.HttpClient; +import com.ejlchina.okhttps.internal.HttpException; +import com.ejlchina.okhttps.internal.ProcessRequestBody; +import okhttp3.*; +import okhttp3.internal.Util; +import okio.Buffer; + import java.io.File; import java.io.IOException; import java.io.InputStream; @@ -9,23 +18,6 @@ import java.util.HashMap; import java.util.Map; -import com.alibaba.fastjson.JSON; -import com.ejlchina.okhttps.HttpResult.State; -import com.ejlchina.okhttps.internal.HttpClient; -import com.ejlchina.okhttps.internal.HttpException; -import com.ejlchina.okhttps.internal.ProcessRequestBody; - -import okhttp3.Call; -import okhttp3.FormBody; -import okhttp3.MediaType; -import okhttp3.MultipartBody; -import okhttp3.Request; -import okhttp3.RequestBody; -import okhttp3.Response; -import okhttp3.ResponseBody; -import okhttp3.internal.Util; -import okio.Buffer; - /** * Created by 周旭（Troy.Zhou） on 2020/3/11. @@ -555,8 +547,7 @@ private long contentLength(RequestBody reqBody) { throw new HttpException("无法获取请求体长度", e); } } - - + private void buildHeaders(Request.Builder builder) { if (headers != null) { for (String name : headers.keySet()) { @@ -579,7 +570,6 @@ protected State toState(IOException e) { return State.EXCEPTION; } - private RequestBody buildRequestBody() { if (jsonParams != null) { requestJson = JSON.toJSONString(jsonParams); @@ -618,8 +608,6 @@ private RequestBody buildRequestBody() { } } - - private String buildUrlPath() { String url = urlPath; if (url == null || url.trim().isEmpty()) { From e8436350146cf095fdf05b51fd96948155af899b Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?=E5=91=A8=E6=97=AD?= Date: Thu, 9 Apr 2020 15:13:13 +0800 Subject: [PATCH 078/924] =?UTF-8?q?HTTP=20=E6=8E=A5=E5=8F=A3=E6=96=B0?= =?UTF-8?q?=E5=A2=9E=E6=96=B9=E6=B3=95=EF=BC=9AcancelAll()=20=E5=8F=96?= =?UTF-8?q?=E6=B6=88=E6=89=80=E6=9C=89=E8=AF=B7=E6=B1=82?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- src/main/java/com/ejlchina/okhttps/HTTP.java | 7 ++++++- .../ejlchina/okhttps/internal/HttpClient.java | 21 ++++++++++++------- 2 files changed, 19 insertions(+), 9 deletions(-) diff --git a/src/main/java/com/ejlchina/okhttps/HTTP.java b/src/main/java/com/ejlchina/okhttps/HTTP.java index 2f6a54df..3ac7124b 100644 --- a/src/main/java/com/ejlchina/okhttps/HTTP.java +++ b/src/main/java/com/ejlchina/okhttps/HTTP.java @@ -37,7 +37,12 @@ public interface HTTP { * @return 被取消的任务数量 */ int cancel(String tag); - + + /** + * 取消所有HTTP任务，包括同步和异步 + */ + void cancelAll(); + /** * OkHttp 原生请求 （该请求不经过 预处理器） * @param request 请求 diff --git a/src/main/java/com/ejlchina/okhttps/internal/HttpClient.java b/src/main/java/com/ejlchina/okhttps/internal/HttpClient.java index 15ab2fae..99660120 100644 --- a/src/main/java/com/ejlchina/okhttps/internal/HttpClient.java +++ b/src/main/java/com/ejlchina/okhttps/internal/HttpClient.java @@ -30,18 +30,18 @@ public class HttpClient implements HTTP { + + final OkHttpClient client; - private OkHttpClient client; - - private String baseUrl; + final String baseUrl; // 媒体类型 - private Map mediaTypes; + final Map mediaTypes; // 执行器 - private TaskExecutor executor; + final TaskExecutor executor; // 预处理器 - private Preprocessor[] preprocessors; + final Preprocessor[] preprocessors; - private List tagCalls; + final List tagCalls; private HttpClient(Builder builder) { @@ -85,7 +85,12 @@ public int cancel(String tag) { } return count; } - + + @Override + public void cancelAll() { + client.dispatcher().cancelAll(); + } + @Override public Call request(Request request) { return client.newCall(request); From f2f5cf13d2d585f935b98a5da383545217b9b503 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?=E5=91=A8=E6=97=AD?= Date: Thu, 9 Apr 2020 15:48:24 +0800 Subject: [PATCH 079/924] =?UTF-8?q?=E6=8A=BD=E8=B1=A1=20Cancelable=20?= =?UTF-8?q?=E6=8E=A5=E5=8F=A3=EF=BC=8C=E4=BD=BF=E5=BE=97=E5=90=8C=E6=AD=A5?= =?UTF-8?q?=E8=AF=B7=E6=B1=82=E4=BB=BB=E5=8A=A1=20=E4=B9=9F=E5=8F=AF?= =?UTF-8?q?=E4=BB=A5=E6=8C=89=20=E6=A0=87=E7=AD=BE=E5=8F=96=E6=B6=88?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- .../java/com/ejlchina/okhttps/Cancelable.java | 11 ++++ src/main/java/com/ejlchina/okhttps/HTTP.java | 2 + .../java/com/ejlchina/okhttps/HttpCall.java | 2 +- .../okhttps/internal/AsyncHttpTask.java | 6 +-- .../ejlchina/okhttps/internal/HttpClient.java | 53 ++++++++----------- .../okhttps/internal/SyncHttpTask.java | 35 +++++++++++- src/test/java/com/ejlchina/test/HttpTest.java | 16 +++--- 7 files changed, 82 insertions(+), 43 deletions(-) create mode 100644 src/main/java/com/ejlchina/okhttps/Cancelable.java diff --git a/src/main/java/com/ejlchina/okhttps/Cancelable.java b/src/main/java/com/ejlchina/okhttps/Cancelable.java new file mode 100644 index 00000000..0c81a7ac --- /dev/null +++ b/src/main/java/com/ejlchina/okhttps/Cancelable.java @@ -0,0 +1,11 @@ +package com.ejlchina.okhttps; + +public interface Cancelable { + + /** + * 取消 + * @return 取消是否成功 + */ + boolean cancel(); + +} diff --git a/src/main/java/com/ejlchina/okhttps/HTTP.java b/src/main/java/com/ejlchina/okhttps/HTTP.java index 3ac7124b..5252ff53 100644 --- a/src/main/java/com/ejlchina/okhttps/HTTP.java +++ b/src/main/java/com/ejlchina/okhttps/HTTP.java @@ -33,12 +33,14 @@ public interface HTTP { /** * 根据标签取消HTTP任务，只要任务的标签包含指定的Tag就会被取消 + * 从 v1.0.2 开始支持取消同步请求 * @param tag 标签 * @return 被取消的任务数量 */ int cancel(String tag); /** + * @since 1.0.2 * 取消所有HTTP任务，包括同步和异步 */ void cancelAll(); diff --git a/src/main/java/com/ejlchina/okhttps/HttpCall.java b/src/main/java/com/ejlchina/okhttps/HttpCall.java index 8a59cd14..a7543a7b 100644 --- a/src/main/java/com/ejlchina/okhttps/HttpCall.java +++ b/src/main/java/com/ejlchina/okhttps/HttpCall.java @@ -1,6 +1,6 @@ package com.ejlchina.okhttps; -public interface HttpCall { +public interface HttpCall extends Cancelable { /** * 取消 Http 请求 diff --git a/src/main/java/com/ejlchina/okhttps/internal/AsyncHttpTask.java b/src/main/java/com/ejlchina/okhttps/internal/AsyncHttpTask.java index a0d798dc..7969fc11 100644 --- a/src/main/java/com/ejlchina/okhttps/internal/AsyncHttpTask.java +++ b/src/main/java/com/ejlchina/okhttps/internal/AsyncHttpTask.java @@ -113,7 +113,7 @@ private HttpCall request(String method) { } }); if (tag != null) { - httpClient.addTagCall(tag, call, this); + httpClient.addTagTask(tag, call, this); } return call; } @@ -136,7 +136,7 @@ public boolean cancel() { notify(); } if (tag != null && call == null) { - httpClient.removeTagCall(AsyncHttpTask.this); + httpClient.removeTagTask(AsyncHttpTask.this); } return res; } @@ -228,7 +228,7 @@ public void setResult(HttpResult result) { notify(); } if (tag != null) { - httpClient.removeTagCall(AsyncHttpTask.this); + httpClient.removeTagTask(AsyncHttpTask.this); } } diff --git a/src/main/java/com/ejlchina/okhttps/internal/HttpClient.java b/src/main/java/com/ejlchina/okhttps/internal/HttpClient.java index 99660120..15e69497 100644 --- a/src/main/java/com/ejlchina/okhttps/internal/HttpClient.java +++ b/src/main/java/com/ejlchina/okhttps/internal/HttpClient.java @@ -11,14 +11,7 @@ import java.util.Queue; import java.util.concurrent.Executor; -import com.ejlchina.okhttps.Configurator; -import com.ejlchina.okhttps.DownListener; -import com.ejlchina.okhttps.HTTP; -import com.ejlchina.okhttps.HttpCall; -import com.ejlchina.okhttps.HttpResult; -import com.ejlchina.okhttps.HttpTask; -import com.ejlchina.okhttps.Preprocessor; -import com.ejlchina.okhttps.TaskListener; +import com.ejlchina.okhttps.*; import com.ejlchina.okhttps.HttpResult.State; import okhttp3.Call; @@ -30,9 +23,9 @@ public class HttpClient implements HTTP { - + // OkHttpClient final OkHttpClient client; - + // 根URL final String baseUrl; // 媒体类型 final Map mediaTypes; @@ -40,8 +33,8 @@ public class HttpClient implements HTTP { final TaskExecutor executor; // 预处理器 final Preprocessor[] preprocessors; - - final List tagCalls; + // 持有标签的任务 + final List tagTasks; private HttpClient(Builder builder) { @@ -52,8 +45,8 @@ private HttpClient(Builder builder) { builder.mainExecutor, builder.downloadListener, builder.responseListener, builder.exceptionListener, builder.completeListener); - this.preprocessors = builder.preprocessors.toArray(new Preprocessor[builder.preprocessors.size()]); - this.tagCalls = Collections.synchronizedList(new LinkedList<>()); + this.preprocessors = builder.preprocessors.toArray(new Preprocessor[0]); + this.tagTasks = Collections.synchronizedList(new LinkedList<>()); } @Override @@ -72,12 +65,12 @@ public int cancel(String tag) { return 0; } int count = 0; - Iterator it = tagCalls.iterator(); + Iterator it = tagTasks.iterator(); while (it.hasNext()) { - TagCall tagCall = it.next(); + TagTask tagCall = it.next(); // 只要任务的标签包含指定的Tag就会被取消 if (tagCall.tag.contains(tag)) { - if (tagCall.call.cancel()) { + if (tagCall.canceler.cancel()) { count++; } it.remove(); @@ -109,18 +102,18 @@ public int totalTimeoutMillis() { return client.connectTimeoutMillis() + client.writeTimeoutMillis() + client.readTimeoutMillis(); } - public int getTagCallCount() { - return tagCalls.size(); + public int getTagTaskCount() { + return tagTasks.size(); } - public void addTagCall(String tag, HttpCall call, HttpTask task) { - tagCalls.add(new TagCall(tag, call, task)); + public void addTagTask(String tag, Cancelable canceler, HttpTask task) { + tagTasks.add(new TagTask(tag, canceler, task)); } - public void removeTagCall(HttpTask task) { - Iterator it = tagCalls.iterator(); + public void removeTagTask(HttpTask task) { + Iterator it = tagTasks.iterator(); while (it.hasNext()) { - TagCall tagCall = it.next(); + TagTask tagCall = it.next(); if (tagCall.task == task) { it.remove(); break; @@ -128,15 +121,15 @@ public void removeTagCall(HttpTask task) { } } - class TagCall { - + static class TagTask { + String tag; - HttpCall call; + Cancelable canceler; HttpTask task; - - public TagCall(String tag, HttpCall call, HttpTask task) { + + public TagTask(String tag, Cancelable canceler, HttpTask task) { this.tag = tag; - this.call = call; + this.canceler = canceler; this.task = task; } diff --git a/src/main/java/com/ejlchina/okhttps/internal/SyncHttpTask.java b/src/main/java/com/ejlchina/okhttps/internal/SyncHttpTask.java index 648c8357..cbb9cdd4 100644 --- a/src/main/java/com/ejlchina/okhttps/internal/SyncHttpTask.java +++ b/src/main/java/com/ejlchina/okhttps/internal/SyncHttpTask.java @@ -2,6 +2,7 @@ import java.io.IOException; +import com.ejlchina.okhttps.Cancelable; import com.ejlchina.okhttps.HttpResult; import com.ejlchina.okhttps.HttpTask; import com.ejlchina.okhttps.HttpResult.State; @@ -53,13 +54,45 @@ public HttpResult put() { public HttpResult delete() { return request("DELETE"); } - + + static class SyncCall implements Cancelable { + + final Call call; + boolean done = false; + + public SyncCall(Call call) { + this.call = call; + } + + @Override + public boolean cancel() { + if (done) { + return false; + } + call.cancel(); + return true; + } + + public void setDone(boolean done) { + this.done = done; + } + + } + private HttpResult request(String method) { RealHttpResult result = new RealHttpResult(this, httpClient.getExecutor()); httpClient.preprocess(this, () -> { Call call = prepareCall(method); + SyncCall syncCall = null; + if (tag != null) { + syncCall = new SyncCall(call); + httpClient.addTagTask(tag, syncCall, this); + } try { Response response = call.execute(); + if (syncCall != null) { + syncCall.setDone(true); + } synchronized (SyncHttpTask.this) { result.response(response); SyncHttpTask.this.notify(); diff --git a/src/test/java/com/ejlchina/test/HttpTest.java b/src/test/java/com/ejlchina/test/HttpTest.java index e8951dab..c638d69d 100644 --- a/src/test/java/com/ejlchina/test/HttpTest.java +++ b/src/test/java/com/ejlchina/test/HttpTest.java @@ -396,7 +396,7 @@ public void testCancel() { .setTag("A") .get(); - System.out.println(((HttpClient) http).getTagCallCount()); + System.out.println(((HttpClient) http).getTagTaskCount()); http.async("/user/show/2") .setOnResponse((HttpResult result) -> { @@ -405,7 +405,7 @@ public void testCancel() { .setTag("A.B") .get(); - System.out.println(((HttpClient) http).getTagCallCount()); + System.out.println(((HttpClient) http).getTagTaskCount()); http.async("/user/show/3") .setOnResponse((HttpResult result) -> { @@ -414,7 +414,7 @@ public void testCancel() { .setTag("B.C") .get(); - System.out.println(((HttpClient) http).getTagCallCount()); + System.out.println(((HttpClient) http).getTagTaskCount()); http.async("/user/show/4") .setOnResponse((HttpResult result) -> { @@ -423,24 +423,24 @@ public void testCancel() { .setTag("C") .get(); - System.out.println(((HttpClient) http).getTagCallCount()); + System.out.println(((HttpClient) http).getTagTaskCount()); System.out.println("标签取消：" + http.cancel("B")); - System.out.println(((HttpClient) http).getTagCallCount()); + System.out.println(((HttpClient) http).getTagTaskCount()); sleep(5000); - System.out.println(((HttpClient) http).getTagCallCount()); + System.out.println(((HttpClient) http).getTagTaskCount()); sleep(5000); - System.out.println(((HttpClient) http).getTagCallCount()); + System.out.println(((HttpClient) http).getTagTaskCount()); sleep(5000); - System.out.println(((HttpClient) http).getTagCallCount()); + System.out.println(((HttpClient) http).getTagTaskCount()); // System.out.println("isDone = " + call.isDone()); // System.out.println("isCanceled = " + call.isCanceled()); From 52f628cbe023cbbaef4d2b3cd3631a264fec7548 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?=E5=91=A8=E6=97=AD?= Date: Thu, 9 Apr 2020 16:01:01 +0800 Subject: [PATCH 080/924] . --- src/main/java/com/ejlchina/okhttps/Preprocessor.java | 3 ++- 1 file changed, 2 insertions(+), 1 deletion(-) diff --git a/src/main/java/com/ejlchina/okhttps/Preprocessor.java b/src/main/java/com/ejlchina/okhttps/Preprocessor.java index d0f6f96c..a1fdd173 100644 --- a/src/main/java/com/ejlchina/okhttps/Preprocessor.java +++ b/src/main/java/com/ejlchina/okhttps/Preprocessor.java @@ -19,8 +19,9 @@ interface PreChain { /** * @return 当前的请求任务 */ + @SuppressWarnings("") HttpTask getTask(); - + /** * @return HTTP */ From 7dfe92f4607b76ff2b4ef33635ea64cb4e7acc86 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?=E5=91=A8=E6=97=AD?= Date: Thu, 9 Apr 2020 16:04:38 +0800 Subject: [PATCH 081/924] . --- src/main/java/com/ejlchina/okhttps/Preprocessor.java | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/src/main/java/com/ejlchina/okhttps/Preprocessor.java b/src/main/java/com/ejlchina/okhttps/Preprocessor.java index a1fdd173..c090c56e 100644 --- a/src/main/java/com/ejlchina/okhttps/Preprocessor.java +++ b/src/main/java/com/ejlchina/okhttps/Preprocessor.java @@ -19,7 +19,7 @@ interface PreChain { /** * @return 当前的请求任务 */ - @SuppressWarnings("") + @SuppressWarnings("all") HttpTask getTask(); /** From 5d2429baab904735ea320c3409b21fa2096940d0 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?=E5=91=A8=E6=97=AD?= Date: Thu, 9 Apr 2020 16:10:01 +0800 Subject: [PATCH 082/924] . --- src/main/java/com/ejlchina/okhttps/Preprocessor.java | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/src/main/java/com/ejlchina/okhttps/Preprocessor.java b/src/main/java/com/ejlchina/okhttps/Preprocessor.java index c090c56e..12454e6e 100644 --- a/src/main/java/com/ejlchina/okhttps/Preprocessor.java +++ b/src/main/java/com/ejlchina/okhttps/Preprocessor.java @@ -19,7 +19,7 @@ interface PreChain { /** * @return 当前的请求任务 */ - @SuppressWarnings("all") + @SuppressWarnings("rawtypes") HttpTask getTask(); /** From 38d09fe668ed359dcd4fd2c0aeff1f29ad3e3c97 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?=E5=91=A8=E6=97=AD?= Date: Thu, 9 Apr 2020 16:13:42 +0800 Subject: [PATCH 083/924] . --- README.md | 2 +- src/main/java/com/ejlchina/okhttps/Preprocessor.java | 2 +- 2 files changed, 2 insertions(+), 2 deletions(-) diff --git a/README.md b/README.md index bdc34adf..98ca90d1 100644 --- a/README.md +++ b/README.md @@ -15,7 +15,7 @@ * 单方法回调，充分利用 Lambda 表达式 * TCP连接池、Http2 -> OkHttps 非常轻量，自身代码在 2000 行左右，且有较高的编码质量，sonarqube 分析结果为 3A +> OkHttps 非常轻量，自身代码在 2000 行左右，且有较高的编码质量，sonarqube 分析结果为 3A，[查看报告](https://gitee.com/ejlchina-zhxu/okhttps/quality_analyses?platform=sonar_qube) ### 前世：[HttpUtils, V2.3.0 之后重命名为 OkHttps](https://gitee.com/ejlchina-zhxu/httputils) ### 当前文档版本[1.0.1] diff --git a/src/main/java/com/ejlchina/okhttps/Preprocessor.java b/src/main/java/com/ejlchina/okhttps/Preprocessor.java index 12454e6e..c090c56e 100644 --- a/src/main/java/com/ejlchina/okhttps/Preprocessor.java +++ b/src/main/java/com/ejlchina/okhttps/Preprocessor.java @@ -19,7 +19,7 @@ interface PreChain { /** * @return 当前的请求任务 */ - @SuppressWarnings("rawtypes") + @SuppressWarnings("all") HttpTask getTask(); /** From a399222d077f3a5d0d10b3a143716011be2c7638 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?=E5=91=A8=E6=97=AD?= Date: Thu, 9 Apr 2020 16:51:52 +0800 Subject: [PATCH 084/924] V1.0.2 ^_^ --- pom.xml | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/pom.xml b/pom.xml index 1678b893..b8e2b970 100644 --- a/pom.xml +++ b/pom.xml @@ -3,7 +3,7 @@ com.ejlchina okhttps - 1.0.1 + 1.0.2 OkHttps @@ -32,7 +32,7 @@ scm:git://gitee.com/ejlchina-zhxu/okhttps.git scm:http://gitee.com/ejlchina-zhxu/okhttps https://gitee.com/ejlchina-zhxu/okhttps - v1.0.1 + v1.0.2 From 15c74c7b1f14d77ad6c4d47465faf9e470ccc350 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?=E5=91=A8=E6=97=AD?= Date: Thu, 9 Apr 2020 17:21:04 +0800 Subject: [PATCH 085/924] Tests --- src/test/java/com/ejlchina/test/BaseTest.java | 49 ++ .../java/com/ejlchina/test/CacheTests.java | 27 + .../java/com/ejlchina/test/CancelTests.java | 97 +++ .../java/com/ejlchina/test/DownloadTests.java | 140 ++++ .../com/ejlchina/test/ExceptionTests.java | 18 +- .../java/com/ejlchina/test/ExecutorTests.java | 39 ++ src/test/java/com/ejlchina/test/HttpTest.java | 611 ------------------ .../java/com/ejlchina/test/JsonTests.java | 61 ++ .../java/com/ejlchina/test/ListenerTests.java | 94 +++ .../com/ejlchina/test/PreprocessorTests.java | 60 ++ .../java/com/ejlchina/test/SimpleTests.java | 28 +- .../java/com/ejlchina/test/UploadTests.java | 36 ++ 12 files changed, 610 insertions(+), 650 deletions(-) create mode 100644 src/test/java/com/ejlchina/test/BaseTest.java create mode 100644 src/test/java/com/ejlchina/test/CacheTests.java create mode 100644 src/test/java/com/ejlchina/test/CancelTests.java create mode 100644 src/test/java/com/ejlchina/test/DownloadTests.java create mode 100644 src/test/java/com/ejlchina/test/ExecutorTests.java delete mode 100644 src/test/java/com/ejlchina/test/HttpTest.java create mode 100644 src/test/java/com/ejlchina/test/JsonTests.java create mode 100644 src/test/java/com/ejlchina/test/ListenerTests.java create mode 100644 src/test/java/com/ejlchina/test/PreprocessorTests.java create mode 100644 src/test/java/com/ejlchina/test/UploadTests.java diff --git a/src/test/java/com/ejlchina/test/BaseTest.java b/src/test/java/com/ejlchina/test/BaseTest.java new file mode 100644 index 00000000..bd96497b --- /dev/null +++ b/src/test/java/com/ejlchina/test/BaseTest.java @@ -0,0 +1,49 @@ +package com.ejlchina.test; + +public class BaseTest { + + public static void sleep(int millis) { + try { + Thread.sleep(millis); + } catch (InterruptedException e) { + e.printStackTrace(); + } + } + + public static void println() { + System.out.println(); + } + + public static void println(Object x) { + System.out.println(x); + } + + public static void println(long t0, String str) { + System.out.println(now() - t0 + "\t" + str); + } + + public static long now() { + return System.currentTimeMillis(); + } + + public static class User { + + private int id; + private String name; + + public void setId(int id) { + this.id = id; + } + + public void setName(String name) { + this.name = name; + } + + @Override + public String toString() { + return "User [id=" + id + ", name=" + name + "]"; + } + + } + +} diff --git a/src/test/java/com/ejlchina/test/CacheTests.java b/src/test/java/com/ejlchina/test/CacheTests.java new file mode 100644 index 00000000..baa95483 --- /dev/null +++ b/src/test/java/com/ejlchina/test/CacheTests.java @@ -0,0 +1,27 @@ +package com.ejlchina.test; + +import com.ejlchina.okhttps.HTTP; +import com.ejlchina.okhttps.HttpResult; +import org.junit.Test; + +public class CacheTests extends BaseTest { + + @Test + public void testCache() { + HTTP http = HTTP.builder().build(); + + HttpResult.Body body = http.sync("http://xxx.cdyun.vip/comm/provinces") + .get() + .getBody() + .cache(); + + println("result = " + body.toString()); + println("result = " + body.toJsonArray()); + + body.close(); + + println("result = " + body.toString()); + println("result = " + body.toJsonArray()); + } + +} diff --git a/src/test/java/com/ejlchina/test/CancelTests.java b/src/test/java/com/ejlchina/test/CancelTests.java new file mode 100644 index 00000000..ebd5aaa0 --- /dev/null +++ b/src/test/java/com/ejlchina/test/CancelTests.java @@ -0,0 +1,97 @@ +package com.ejlchina.test; + +import com.ejlchina.okhttps.HTTP; +import com.ejlchina.okhttps.HttpResult; +import com.ejlchina.okhttps.internal.HttpClient; +import org.junit.Test; + +import java.io.IOException; + +/** + * 测试取消 + */ +public class CancelTests extends BaseTest { + + + @Test + public void testCancel() { + + HTTP http = HTTP.builder() + .baseUrl("http://localhost:8080") + .build(); + + http.async("/user/show/1") + .setOnResponse((HttpResult result) -> { + println(result); + }) + .setOnException((IOException e) -> { + println("异常捕获：" + e.getMessage()); + }) + .setOnComplete((HttpResult.State state) -> { + println(state); + }) + .setTag("A") + .get(); + + println(((HttpClient) http).getTagTaskCount()); + + http.async("/user/show/2") + .setOnResponse((HttpResult result) -> { + println(result); + }) + .setTag("A.B") + .get(); + + println(((HttpClient) http).getTagTaskCount()); + + http.async("/user/show/3") + .setOnResponse((HttpResult result) -> { + println(result); + }) + .setTag("B.C") + .get(); + + println(((HttpClient) http).getTagTaskCount()); + + http.async("/user/show/4") + .setOnResponse((HttpResult result) -> { + println(result); + }) + .setTag("C") + .get(); + + println(((HttpClient) http).getTagTaskCount()); + + + println("标签取消：" + http.cancel("B")); + + println(((HttpClient) http).getTagTaskCount()); + + sleep(5000); + + println(((HttpClient) http).getTagTaskCount()); + + sleep(5000); + + println(((HttpClient) http).getTagTaskCount()); + + sleep(5000); + + println(((HttpClient) http).getTagTaskCount()); + +// println("isDone = " + call.isDone()); +// println("isCanceled = " + call.isCanceled()); +// +// println("取消结果 = " + call.cancel()); +// +// println("isDone = " + call.isDone()); +// println("isCanceled = " + call.isCanceled()); +// +// sleep(100); +// println("++++++++"); +// +// println("isDone = " + call.isDone()); +// println("isCanceled = " + call.isCanceled()); + } + +} diff --git a/src/test/java/com/ejlchina/test/DownloadTests.java b/src/test/java/com/ejlchina/test/DownloadTests.java new file mode 100644 index 00000000..12113de8 --- /dev/null +++ b/src/test/java/com/ejlchina/test/DownloadTests.java @@ -0,0 +1,140 @@ +package com.ejlchina.test; + +import com.ejlchina.okhttps.*; +import com.ejlchina.okhttps.Process; +import okhttp3.OkHttpClient; +import org.junit.Test; + +import java.io.File; +import java.util.concurrent.TimeUnit; + +public class DownloadTests extends BaseTest { + + + /** + * 分块下载测试 + * @param args + */ + public static void main(String[] args) { + long totalSize = HttpUtils.sync("/download/test.zip").get().getBody() + .close() // 因为这次请求只是为了获得文件大小，不消费报文体，所以直接关闭 + .getContentLength(); + download(totalSize, 0); // 从第 0 块开始下载 + sleep(50000); // 等待下载完成 + } + + static void download(long totalSize, int index) { + long size = 3 * 1024 * 1024; // 每块下载 3M + long start = index * size; + long end = Math.min(start + size, totalSize); + HttpUtils.sync("/download/test.zip") + .setRange(start, end) // 设置本次下载的范围 + .get().getBody() + .toFile("D:/download/test.zip") // 下载到同一个文件里 + .setAppended() // 开启文件追加模式 + .setOnSuccess((File file) -> { + if (end < totalSize) { // 若未下载完，则继续下载下一块 + download(totalSize, index + 1); + } else { + println("下载完成"); + } + }) + .start(); + } + + + + @Test + public void testDownload() { + HTTP http = HTTP.builder() + .config((OkHttpClient.Builder builder) -> { + builder.readTimeout(300, TimeUnit.MILLISECONDS); + }) + .build(); + + String url = "https://download.cocos.com/CocosDashboard/v1.0.1/CocosDashboard-v1.0.1-win32-031816.exe"; +// String url = "http://47.100.7.202/ejl-test.zip"; + + long t0 = now(); + +// Ctrl ctrl = + http.sync(url) +// .setRange(24771214) + .bind(this) + .get() + .getBody() + .setOnProcess((Process process) -> { + println(t0, process.getDoneBytes() + "/" + process.getTotalBytes() + "\t" + process.getRate()); + }) + .setStepRate(0.1) + .toFolder("D:/WorkSpace/download/") +// .toFile("D:\\WorkSpace\\download\\CocosDashboard-v1.0.1-win32-031816(9).exe") +// .setAppended() // 启用 断点续传 + .nextOnIO() + .setOnSuccess((File file) -> { + println(t0, "下载成功：" + file.getAbsolutePath()); + println(); + }) + .setOnFailure((Download.Failure failure) -> { + println(t0, "下载失败：" + failure.getDoneBytes() + ", path = " + failure.getFile().getAbsolutePath()); + println(); + }) + .start(); + + sleep(10000); + +// ctrl.status(); +// ctrl.pause(); +// println("暂停"); +// sleep(5000); +// +// ctrl.resume(); +// println("继续"); +// sleep(5000); +// +// ctrl.cancel(); +// println("取消"); + + +// + +// +// ctrl.pause(); +// println("暂停"); +// sleep(5000); +// +// ctrl.resume(); +// println("继续"); + sleep(5000); + + } + + + @Test + public void syncHttpExample() { + + HTTP http = HTTP.builder().build(); + // 同步请求 + HttpResult result = http.sync("https://timgsa.baidu.com/timg?image&quality=80&size=b9999_10000&sec=1584365400942&di=d9e7890f13b7bc4b76080fdd490ed5d5&imgtype=0&src=http%3A%2F%2Ft8.baidu.com%2Fit%2Fu%3D1484500186%2C1503043093%26fm%3D79%26app%3D86%26f%3DJPEG%3Fw%3D1280%26h%3D853") + .get(); + + result.getBody().toFile("E:/3.jpg"); +// // 得到状态码 +// int status = result.getStatus(); +// +// // 得到返回头 +// Headers headers = result.getHeaders(); +// +// User user = result.getBody().toBean(User.class); +// // 得到目标数据 +// +// +// println("status = " + status); +// println("headers = " + headers); +// println("user = " + user); + + println("status = " + result.getStatus()); + + } + +} diff --git a/src/test/java/com/ejlchina/test/ExceptionTests.java b/src/test/java/com/ejlchina/test/ExceptionTests.java index aafeedf1..7cee825b 100644 --- a/src/test/java/com/ejlchina/test/ExceptionTests.java +++ b/src/test/java/com/ejlchina/test/ExceptionTests.java @@ -12,7 +12,10 @@ import java.net.UnknownHostException; import java.util.concurrent.TimeUnit; -public class ExceptionTests { +/** + * 测试异常处理 + */ +public class ExceptionTests extends BaseTest { HTTP http = HTTP.builder() .config((OkHttpClient.Builder builder) -> { @@ -78,11 +81,11 @@ public void testASync() { http.async("/users/1") .setOnResponse((HttpResult result) -> { // 当发生异常时就不会走这里 - System.out.println(result); + println(result); }) .setOnException((IOException e) -> { // 这里处理请求异常 - System.out.println(e); + println(e); }) .get(); @@ -90,13 +93,4 @@ public void testASync() { } - - void sleep(int millis) { - try { - Thread.sleep(millis); - } catch (InterruptedException e) { - e.printStackTrace(); - } - } - } diff --git a/src/test/java/com/ejlchina/test/ExecutorTests.java b/src/test/java/com/ejlchina/test/ExecutorTests.java new file mode 100644 index 00000000..8f82422b --- /dev/null +++ b/src/test/java/com/ejlchina/test/ExecutorTests.java @@ -0,0 +1,39 @@ +package com.ejlchina.test; + +import com.ejlchina.okhttps.HTTP; +import com.ejlchina.okhttps.HttpResult; +import com.ejlchina.okhttps.Process; +import org.junit.Test; + +public class ExecutorTests extends BaseTest { + + + @Test + public void testExecutor() { + HTTP http = HTTP.builder() + .callbackExecutor((Runnable command) -> { + println("主线程执行"); + command.run(); + }).build(); + + http.async("http://47.100.7.202/ejl-test.zip") + .addBodyParam("name", "Jack") +// .nextOnIO() + .setOnProcess((Process process) -> { + println("process： " + process.getRate()); + }) +// .nextOnIO() + .setOnResponse((HttpResult result) -> { + println("status： " + result.close().getStatus()); + }) + .nextOnIO() + .setOnComplete((HttpResult.State state) -> { + println("state： " + state); + }) + .post(); + + sleep(3000); + } + + +} diff --git a/src/test/java/com/ejlchina/test/HttpTest.java b/src/test/java/com/ejlchina/test/HttpTest.java deleted file mode 100644 index c638d69d..00000000 --- a/src/test/java/com/ejlchina/test/HttpTest.java +++ /dev/null @@ -1,611 +0,0 @@ -package com.ejlchina.test; - - -import java.io.File; -import java.io.IOException; -import java.util.List; -import java.util.concurrent.TimeUnit; - -import org.junit.Test; - -import com.ejlchina.okhttps.Download; -import com.ejlchina.okhttps.HTTP; -import com.ejlchina.okhttps.HttpCall; -import com.ejlchina.okhttps.HttpResult; -import com.ejlchina.okhttps.HttpTask; -import com.ejlchina.okhttps.HttpUtils; -import com.ejlchina.okhttps.Process; -import com.ejlchina.okhttps.Download.Ctrl; -import com.ejlchina.okhttps.Download.Failure; -import com.ejlchina.okhttps.HttpResult.Body; -import com.ejlchina.okhttps.HttpResult.State; -import com.ejlchina.okhttps.Preprocessor.PreChain; -import com.ejlchina.okhttps.internal.HttpClient; - -import okhttp3.ConnectionPool; -import okhttp3.Interceptor.Chain; -import okhttp3.OkHttpClient.Builder; -import okhttp3.Request; - - -public class HttpTest { - - - @Test - public void testCache() { - HTTP http = HTTP.builder().build(); - - Body body = http.sync("http://xxx.cdyun.vip/comm/provinces") - .get() - .getBody() - .cache() - ; - - - System.out.println("result = " + body.toString()); - System.out.println("result = " + body.toJsonArray()); - System.out.println("result = " + body.toBytes()); - - body.close(); - - System.out.println("result = " + body.toString()); - System.out.println("result = " + body.toJsonArray()); - System.out.println("result = " + body.toBytes()); - } - - - @Test - public void testGlobalCallback() { - HTTP http = HTTP.builder() - .responseListener((HttpTask task, HttpResult result) -> { - System.out.println("全局 onResponse: " + result.getStatus()); - return true; - }) - .completeListener((HttpTask task, State state) -> { - System.out.println("全局 onComplete: " + state); - return true; - }) - .exceptionListener((HttpTask task, IOException error) -> { - System.out.println("全局 onException: " + error.getMessage()); - return false; - }) - .build(); - - http.async("http://www.baidu.com") - .setOnResponse((HttpResult result) -> { - System.out.println("单例 onResponse: " + result.getStatus()); - }) - .setOnComplete((State state) -> { - System.out.println("单例 onComplete: " + state); - }) - .setOnException((IOException error) -> { - System.out.println("单例 onException: " + error.getMessage()); - }) - .get(); - - sleep(2000); - } - - @Test - public void testDownloadListener() { - HTTP http = HTTP.builder() - .downloadListener((HttpTask task, Download download) -> { - System.out.println("URL = " + task.getUrl()); - System.out.println("TAG = " + task.getTag()); - Ctrl ctrl = download.getCtrl(); - - new Thread(() -> { - sleep(3000); - ctrl.pause(); - sleep(3000); - ctrl.resume(); - sleep(3000); - ctrl.cancel(); - }).start(); - }) - .build(); - - String url = "https://download.cocos.com/CocosDashboard/v1.0.1/CocosDashboard-v1.0.1-win32-031816.exe"; - - long t0 = System.currentTimeMillis(); - - - http.sync(url) - .setTag("ASD") - .get() - .getBody() - .setOnProcess((Process process) -> { - print(t0, process.getDoneBytes() + "/" + process.getTotalBytes() + "\t" + process.getRate(), false); - }) - .setStepRate(0.01) - .toFolder("D:/download/") - .nextOnIO() - .setOnSuccess((File file) -> { - print(t0, "下载成功：" + file.getAbsolutePath(), true); - }) - .setOnFailure((Failure failure) -> { - print(t0, "下载失败：" + failure.getDoneBytes() + ", path = " + failure.getFile().getAbsolutePath(), true); - }) - .start(); - - sleep(20000); - } - - @Test - public void testExecutor() { - HTTP http = HTTP.builder() - .callbackExecutor((Runnable command) -> { - System.out.println("主线程执行"); - command.run(); - }).build(); - - http.async("http://47.100.7.202/ejl-test.zip") - .addBodyParam("name", "Jack") -// .nextOnIO() - .setOnProcess((Process process) -> { - System.out.println("process： " + process.getRate()); - }) -// .nextOnIO() - .setOnResponse((HttpResult result) -> { - System.out.println("status： " + result.close().getStatus()); - }) - .nextOnIO() - .setOnComplete((State state) -> { - System.out.println("state： " + state); - }) - .post(); - - sleep(3000); - } - - - public static void main(String[] args) { - long totalSize = HttpUtils.sync("/download/test.zip").get().getBody() - .close() // 因为这次请求只是为了获得文件大小，不消费报文体，所以直接关闭 - .getContentLength(); - download(totalSize, 0); // 从第 0 块开始下载 - sleep(50000); // 等待下载完成 - } - - static void download(long totalSize, int index) { - long size = 3 * 1024 * 1024; // 每块下载 3M - long start = index * size; - long end = Math.min(start + size, totalSize); - HttpUtils.sync("/download/test.zip") - .setRange(start, end) // 设置本次下载的范围 - .get().getBody() - .toFile("D:/download/test.zip") // 下载到同一个文件里 - .setAppended() // 开启文件追加模式 - .setOnSuccess((File file) -> { - if (end < totalSize) { // 若未下载完，则继续下载下一块 - download(totalSize, index + 1); - } else { - System.out.println("下载完成"); - } - }) - .start(); - } - - - @Test - public void testD() { - System.out.println(Long.parseLong("12")); - } - - - @Test - public void testUpload() { - String data = "0123456789abcdefghijklmnopqrstuvwsyz0123456789abcdefghijklmnopqrstuvwsyz0123456789abcdefghijklmnopqrstuvwsyz0123456789abcdefghijklmnopqrstuvwsyz0123456789abcdefghijklmnopqrstuvwsyz"; - - HTTP http = HTTP.builder().build(); - - long t0 = System.currentTimeMillis(); - - String res = http.sync("http://localhost:8080/test/index") - .addBodyParam("data", data) - .addFileParam("file", "D:\\WorkSpace\\download\\CocosDashboard-v1.0.1-win32-031816.exe") - .setStepRate(0.01) - .setOnProcess((Process process) -> { - print(t0, "上传：" + process.getDoneBytes() + "/" + process.getTotalBytes() + "\t" + process.getRate(), false); - }) - .post() - .getBody() - .setStepBytes(5) - .setOnProcess((Process process) -> { - print(t0, "下载：" + process.getDoneBytes() + "/" + process.getTotalBytes() + "\t" + process.getRate(), false); - }) - .toString(); - - System.out.println("响应：" + res); - } - - @Test - public void testDownload() { - HTTP http = HTTP.builder() - .config((Builder builder) -> { - builder.readTimeout(300, TimeUnit.MILLISECONDS); - }) - .build(); - - String url = "https://download.cocos.com/CocosDashboard/v1.0.1/CocosDashboard-v1.0.1-win32-031816.exe"; -// String url = "http://47.100.7.202/ejl-test.zip"; - - long t0 = System.currentTimeMillis(); - -// Ctrl ctrl = - http.sync(url) -// .setRange(24771214) - .bind(this) - .get() - .getBody() - .setOnProcess((Process process) -> { - print(t0, process.getDoneBytes() + "/" + process.getTotalBytes() + "\t" + process.getRate(), false); - }) - .setStepRate(0.1) - .toFolder("D:/WorkSpace/download/") -// .toFile("D:\\WorkSpace\\download\\CocosDashboard-v1.0.1-win32-031816(9).exe") -// .setAppended() // 启用 断点续传 - .nextOnIO() - .setOnSuccess((File file) -> { - print(t0, "下载成功：" + file.getAbsolutePath(), true); - }) - .setOnFailure((Failure failure) -> { - print(t0, "下载失败：" + failure.getDoneBytes() + ", path = " + failure.getFile().getAbsolutePath(), true); - }) - .start(); - - sleep(10000); - -// ctrl.status(); -// ctrl.pause(); -// System.out.println("暂停"); -// sleep(5000); -// -// ctrl.resume(); -// System.out.println("继续"); -// sleep(5000); -// -// ctrl.cancel(); -// System.out.println("取消"); - - -// - -// -// ctrl.pause(); -// System.out.println("暂停"); -// sleep(5000); -// -// ctrl.resume(); -// System.out.println("继续"); - sleep(5000); - - } - - void print(long t0, String str, boolean ln) { - long now = System.currentTimeMillis() - t0; - System.out.println((now) + "\t" + str); - if (ln) { - System.out.println(); - } - } - - long now(long t0) { - return System.currentTimeMillis() - t0; - } - - - @Test - public void testToList() { - long t0 = System.currentTimeMillis(); - - HTTP http = HTTP.builder() - .baseUrl("http://xxx.cdyun.vip/ejlchina") - .build(); - - HttpResult result = http.sync("/comm/provinces") - .setRange(0) - .get(); - - print(t0, "status: " + result.getStatus(), true); - print(t0, "headers: " + result.getHeaders(), true); - - Body body = result.getBody(); - - print(t0, "total: " + body.getContentLength(), true); - - List list = body.setStepRate(0.1) - .setOnProcess((Process process) -> { - print(t0, process.getDoneBytes() + "/" + process.getTotalBytes() + "\t" + process.getRate(), false); - }) - .toList(User.class); - - print(t0, list.toString(), false); - } - - - @Test - public void testPreprocessor() { - - HTTP http = HTTP.builder() - .baseUrl("http://localhost:8080") - .addPreprocessor((PreChain chain) -> { - System.out.println("并行预处理-开始"); -// new Thread(() -> { - sleep(2000); - System.out.println("并行预处理-结束"); - chain.proceed(); -// }).start(); - }) - .addSerialPreprocessor((PreChain chain) -> { - System.out.println("串行预处理-开始"); - new Thread(() -> { - sleep(3000); - System.out.println("串行预处理-结束"); - chain.proceed(); - }).start(); - }) - .build(); - - new Thread(() -> { - System.out.println(http.sync("/user/show/1").get()); - }).start(); - - new Thread(() -> { - System.out.println(http.sync("/user/show/2").get()); - }).start(); - -// new Thread(() -> { -// http.async("/user/show/1") -// .setOnResponse((HttpResult result) -> { -// System.out.println(result); -// }) -// .get(); -// }).start(); -// -// new Thread(() -> { -// http.async("/user/show/2") -// .setOnResponse((HttpResult result) -> { -// System.out.println(result); -// }) -// .get(); -// }).start(); - - sleep(10000); - } - - - - @Test - public void testCancel() { - - HTTP http = HTTP.builder() - .baseUrl("http://localhost:8080") - .build(); - - http.async("/user/show/1") - .setOnResponse((HttpResult result) -> { - System.out.println(result); - }) - .setOnException((IOException e) -> { - System.out.println("异常捕获：" + e.getMessage()); - }) - .setOnComplete((State state) -> { - System.out.println(state); - }) - .setTag("A") - .get(); - - System.out.println(((HttpClient) http).getTagTaskCount()); - - http.async("/user/show/2") - .setOnResponse((HttpResult result) -> { - System.out.println(result); - }) - .setTag("A.B") - .get(); - - System.out.println(((HttpClient) http).getTagTaskCount()); - - http.async("/user/show/3") - .setOnResponse((HttpResult result) -> { - System.out.println(result); - }) - .setTag("B.C") - .get(); - - System.out.println(((HttpClient) http).getTagTaskCount()); - - http.async("/user/show/4") - .setOnResponse((HttpResult result) -> { - System.out.println(result); - }) - .setTag("C") - .get(); - - System.out.println(((HttpClient) http).getTagTaskCount()); - - - System.out.println("标签取消：" + http.cancel("B")); - - System.out.println(((HttpClient) http).getTagTaskCount()); - - sleep(5000); - - System.out.println(((HttpClient) http).getTagTaskCount()); - - sleep(5000); - - System.out.println(((HttpClient) http).getTagTaskCount()); - - sleep(5000); - - System.out.println(((HttpClient) http).getTagTaskCount()); - -// System.out.println("isDone = " + call.isDone()); -// System.out.println("isCanceled = " + call.isCanceled()); -// -// System.out.println("取消结果 = " + call.cancel()); -// -// System.out.println("isDone = " + call.isDone()); -// System.out.println("isCanceled = " + call.isCanceled()); -// -// sleep(100); -// System.out.println("++++++++"); -// -// System.out.println("isDone = " + call.isDone()); -// System.out.println("isCanceled = " + call.isCanceled()); - } - - - - - private HTTP buildHttp() { - - return HTTP.builder() - .config((Builder builder) -> { - - // 配置连接池 最小10个连接（不配置默认为 5） - builder.connectionPool(new ConnectionPool(10, 5, TimeUnit.MINUTES)); - - // 配置连接超时时间 - builder.connectTimeout(20, TimeUnit.SECONDS); - - builder.addInterceptor((Chain chain) -> { - - Request request = chain.request(); - - return chain.proceed(request); - }); - }) - .baseUrl("http://localhost:8080") - .callbackExecutor((Runnable run) -> { - runOnUiThread(run); - }) - .addPreprocessor((PreChain chain) -> { - new Thread(() -> { - try { - Thread.sleep(100); - } catch (InterruptedException e) { - e.printStackTrace(); - } - chain.getTask().addHeader("Token", "yyyyy"); - - chain.proceed(); - - }).start(); - }) - .addPreprocessor((PreChain chain) -> { - new Thread(() -> { - - chain.getTask().addUrlParam("actor", "Alice"); - - chain.proceed(); - - }).start(); - }) - .build(); - - } - - - @Test - public void syncHttpExample() { - - HTTP http = buildHttp(); - // 同步请求 - HttpResult result = http.sync("https://timgsa.baidu.com/timg?image&quality=80&size=b9999_10000&sec=1584365400942&di=d9e7890f13b7bc4b76080fdd490ed5d5&imgtype=0&src=http%3A%2F%2Ft8.baidu.com%2Fit%2Fu%3D1484500186%2C1503043093%26fm%3D79%26app%3D86%26f%3DJPEG%3Fw%3D1280%26h%3D853") - .get(); - - result.getBody().toFile("E:/3.jpg"); -// // 得到状态码 -// int status = result.getStatus(); -// -// // 得到返回头 -// Headers headers = result.getHeaders(); -// -// User user = result.getBody().toBean(User.class); -// // 得到目标数据 -// -// -// System.out.println("status = " + status); -// System.out.println("headers = " + headers); -// System.out.println("user = " + user); - - System.out.println("status = " + result.getStatus()); - - } - - - @Test - public void syncJsonExample() { - HTTP http = buildHttp(); - // 同步请求 - HttpResult result = http.sync("/user/save") - .addJsonParam("name", "Tom") - .addJsonParam("age", 23) - .post(); - - System.out.println("result = " + result); - - result = http.sync("/user/show/1").get(); - - System.out.println("result = " + result); - - System.out.println("isSuccessful = " + result.isSuccessful()); - } - - @Test - public void asyncHttpExample() throws InterruptedException { - HTTP http = buildHttp(); - // 异步请求 - // 最终路径 http://api.demo.com/users/2 - HttpCall call = http.async("/user/show/{id}") - // 设置路径参数 - .addPathParam("id", 2) - // 设置回调函数 - .setOnResponse((HttpResult result) -> { - System.out.println("000"); -// User user = result.getBody().toBean(User.class); -// System.out.println("user = " + user); - }) - .setOnException((IOException e) -> { - e.printStackTrace(); - }) - // 发起 GET 请求 - .get(); - - Thread.sleep(150); - - System.out.println("是否完成: " + call.isDone()); - System.out.println("是否取消: " + call.isCanceled()); - - call.cancel(); // 取消请求 - - System.out.println("是否取消: " + call.isCanceled()); - System.out.println("执行结果: " + call.getResult()); - System.out.println("是否完成: " + call.isDone()); -// - Thread.sleep(100); -// -// System.out.println("是否完成: " + call.isDone()); -// System.out.println("是否取消: " + call.isCanceled()); -// System.out.println("执行状态: " + call.getResult()); - - } - - - private static void sleep(int millis) { - try { - Thread.sleep(millis); - } catch (InterruptedException e) { - e.printStackTrace(); - } - } - - - static void runOnUiThread(Runnable run) { - run.run(); - } - -} diff --git a/src/test/java/com/ejlchina/test/JsonTests.java b/src/test/java/com/ejlchina/test/JsonTests.java new file mode 100644 index 00000000..4e936e02 --- /dev/null +++ b/src/test/java/com/ejlchina/test/JsonTests.java @@ -0,0 +1,61 @@ +package com.ejlchina.test; + +import com.ejlchina.okhttps.HTTP; +import com.ejlchina.okhttps.HttpResult; +import com.ejlchina.okhttps.Process; +import org.junit.Test; + +import java.util.List; + +public class JsonTests extends BaseTest { + + @Test + public void syncJsonExample() { + HTTP http = HTTP.builder().build(); + // 同步请求 + HttpResult result = http.sync("/user/save") + .addJsonParam("name", "Tom") + .addJsonParam("age", 23) + .post(); + + println("result = " + result); + + result = http.sync("/user/show/1").get(); + + println("result = " + result); + + println("isSuccessful = " + result.isSuccessful()); + } + + + @Test + public void testToList() { + long t0 = System.currentTimeMillis(); + + HTTP http = HTTP.builder() + .baseUrl("http://xxx.cdyun.vip/ejlchina") + .build(); + + HttpResult result = http.sync("/comm/provinces") + .setRange(0) + .get(); + + println(t0, "status: " + result.getStatus()); + println(); + println(t0, "headers: " + result.getHeaders()); + println(); + HttpResult.Body body = result.getBody(); + + println(t0, "total: " + body.getContentLength()); + println(); + List list = body.setStepRate(0.1) + .setOnProcess((Process process) -> { + println(t0, process.getDoneBytes() + "/" + process.getTotalBytes() + "\t" + process.getRate()); + }) + .toList(User.class); + + println(t0, list.toString()); + } + + +} diff --git a/src/test/java/com/ejlchina/test/ListenerTests.java b/src/test/java/com/ejlchina/test/ListenerTests.java new file mode 100644 index 00000000..5a0ad8ac --- /dev/null +++ b/src/test/java/com/ejlchina/test/ListenerTests.java @@ -0,0 +1,94 @@ +package com.ejlchina.test; + +import com.ejlchina.okhttps.Download; +import com.ejlchina.okhttps.HTTP; +import com.ejlchina.okhttps.HttpResult; +import com.ejlchina.okhttps.HttpTask; +import com.ejlchina.okhttps.Process; +import org.junit.Test; + +import java.io.File; +import java.io.IOException; + +public class ListenerTests extends BaseTest { + + @Test + public void testGlobalCallback() { + HTTP http = HTTP.builder() + .responseListener((HttpTask task, HttpResult result) -> { + println("全局 onResponse: " + result.getStatus()); + return true; + }) + .completeListener((HttpTask task, HttpResult.State state) -> { + println("全局 onComplete: " + state); + return true; + }) + .exceptionListener((HttpTask task, IOException error) -> { + println("全局 onException: " + error.getMessage()); + return false; + }) + .build(); + + http.async("http://www.baidu.com") + .setOnResponse((HttpResult result) -> { + println("单例 onResponse: " + result.getStatus()); + }) + .setOnComplete((HttpResult.State state) -> { + println("单例 onComplete: " + state); + }) + .setOnException((IOException error) -> { + println("单例 onException: " + error.getMessage()); + }) + .get(); + + sleep(2000); + } + + @Test + public void testDownloadListener() { + HTTP http = HTTP.builder() + .downloadListener((HttpTask task, Download download) -> { + println("URL = " + task.getUrl()); + println("TAG = " + task.getTag()); + Download.Ctrl ctrl = download.getCtrl(); + + new Thread(() -> { + sleep(3000); + ctrl.pause(); + sleep(3000); + ctrl.resume(); + sleep(3000); + ctrl.cancel(); + }).start(); + }) + .build(); + + String url = "https://download.cocos.com/CocosDashboard/v1.0.1/CocosDashboard-v1.0.1-win32-031816.exe"; + + long t0 = now(); + + + http.sync(url) + .setTag("ASD") + .get() + .getBody() + .setOnProcess((Process process) -> { + println(t0, process.getDoneBytes() + "/" + process.getTotalBytes() + "\t" + process.getRate()); + }) + .setStepRate(0.01) + .toFolder("D:/download/") + .nextOnIO() + .setOnSuccess((File file) -> { + println(t0, "下载成功：" + file.getAbsolutePath()); + println(); + }) + .setOnFailure((Download.Failure failure) -> { + println(t0, "下载失败：" + failure.getDoneBytes() + ", path = " + failure.getFile().getAbsolutePath()); + println(); + }) + .start(); + + sleep(20000); + } + +} diff --git a/src/test/java/com/ejlchina/test/PreprocessorTests.java b/src/test/java/com/ejlchina/test/PreprocessorTests.java new file mode 100644 index 00000000..f20fe559 --- /dev/null +++ b/src/test/java/com/ejlchina/test/PreprocessorTests.java @@ -0,0 +1,60 @@ +package com.ejlchina.test; + +import com.ejlchina.okhttps.HTTP; +import com.ejlchina.okhttps.Preprocessor; +import org.junit.Test; + +public class PreprocessorTests extends BaseTest { + + + @Test + public void testPreprocessor() { + + HTTP http = HTTP.builder() + .baseUrl("http://localhost:8080") + .addPreprocessor((Preprocessor.PreChain chain) -> { + println("并行预处理-开始"); +// new Thread(() -> { + sleep(2000); + println("并行预处理-结束"); + chain.proceed(); +// }).start(); + }) + .addSerialPreprocessor((Preprocessor.PreChain chain) -> { + println("串行预处理-开始"); + new Thread(() -> { + sleep(3000); + println("串行预处理-结束"); + chain.proceed(); + }).start(); + }) + .build(); + + new Thread(() -> { + println(http.sync("/user/show/1").get()); + }).start(); + + new Thread(() -> { + println(http.sync("/user/show/2").get()); + }).start(); + +// new Thread(() -> { +// http.async("/user/show/1") +// .setOnResponse((HttpResult result) -> { +// println(result); +// }) +// .get(); +// }).start(); +// +// new Thread(() -> { +// http.async("/user/show/2") +// .setOnResponse((HttpResult result) -> { +// println(result); +// }) +// .get(); +// }).start(); + + sleep(10000); + } + +} diff --git a/src/test/java/com/ejlchina/test/SimpleTests.java b/src/test/java/com/ejlchina/test/SimpleTests.java index da3b3472..4a6d8a34 100644 --- a/src/test/java/com/ejlchina/test/SimpleTests.java +++ b/src/test/java/com/ejlchina/test/SimpleTests.java @@ -7,7 +7,7 @@ import java.util.List; -public class SimpleTests { +public class SimpleTests extends BaseTest { HTTP http = HTTP.builder() @@ -77,33 +77,7 @@ public void testContentLength() { System.out.println("size = " + (size / 1024) + " KB"); } - void sleep(int millis) { - try { - Thread.sleep(millis); - } catch (InterruptedException e) { - e.printStackTrace(); - } - } } -class User { - - private int id; - private String name; - - public void setId(int id) { - this.id = id; - } - - public void setName(String name) { - this.name = name; - } - - @Override - public String toString() { - return "User [id=" + id + ", name=" + name + "]"; - } - -} \ No newline at end of file diff --git a/src/test/java/com/ejlchina/test/UploadTests.java b/src/test/java/com/ejlchina/test/UploadTests.java new file mode 100644 index 00000000..dc1728f5 --- /dev/null +++ b/src/test/java/com/ejlchina/test/UploadTests.java @@ -0,0 +1,36 @@ +package com.ejlchina.test; + +import com.ejlchina.okhttps.HTTP; +import com.ejlchina.okhttps.Process; +import org.junit.Test; + +public class UploadTests extends BaseTest { + + @Test + public void testUpload() { + String data = "0123456789abcdefghijklmnopqrstuvwsyz0123456789abcdefghijklmnopqrstuvwsyz0123456789abcdefghijklmnopqrstuvwsyz0123456789abcdefghijklmnopqrstuvwsyz0123456789abcdefghijklmnopqrstuvwsyz"; + + HTTP http = HTTP.builder().build(); + + long t0 = System.currentTimeMillis(); + + String res = http.sync("http://localhost:8080/test/index") + .addBodyParam("data", data) + .addFileParam("file", "D:\\WorkSpace\\download\\CocosDashboard-v1.0.1-win32-031816.exe") + .setStepRate(0.01) + .setOnProcess((Process process) -> { + println(t0, "上传：" + process.getDoneBytes() + "/" + process.getTotalBytes() + "\t" + process.getRate()); + }) + .post() + .getBody() + .setStepBytes(5) + .setOnProcess((Process process) -> { + println(t0, "下载：" + process.getDoneBytes() + "/" + process.getTotalBytes() + "\t" + process.getRate()); + }) + .toString(); + + println("响应：" + res); + } + + +} From 90696dcf6a7b412ecfacaedab1187339e22ff6f7 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?=E5=91=A8=E6=97=AD?= Date: Thu, 9 Apr 2020 18:26:16 +0800 Subject: [PATCH 086/924] Tests --- src/test/java/com/ejlchina/test/CancelTests.java | 10 ++++++++++ 1 file changed, 10 insertions(+) diff --git a/src/test/java/com/ejlchina/test/CancelTests.java b/src/test/java/com/ejlchina/test/CancelTests.java index ebd5aaa0..45ec2707 100644 --- a/src/test/java/com/ejlchina/test/CancelTests.java +++ b/src/test/java/com/ejlchina/test/CancelTests.java @@ -13,6 +13,16 @@ public class CancelTests extends BaseTest { + public void testCancelAll() { + HTTP http = HTTP.builder() + .baseUrl("http://localhost:8080") + .build(); + + + + + } + @Test public void testCancel() { From ee6d276c6b3a601e2c2797306b633caefbd8efc2 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?=E5=91=A8=E6=97=AD?= Date: Thu, 9 Apr 2020 20:37:19 +0800 Subject: [PATCH 087/924] =?UTF-8?q?=E8=A7=A3=E5=86=B3=E5=AF=B9=E5=90=8C?= =?UTF-8?q?=E6=AD=A5=E8=AF=B7=E6=B1=82=E8=BF=9B=E8=A1=8C=E5=8F=96=E6=B6=88?= =?UTF-8?q?=E6=97=B6=EF=BC=8COkHttp=20=E5=BA=95=E5=B1=82=E6=8A=9B=E5=87=BA?= =?UTF-8?q?=20SocketException=20=E9=97=AE=E9=A2=98?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- src/main/java/com/ejlchina/okhttps/HttpTask.java | 8 ++++++-- .../java/com/ejlchina/okhttps/internal/AsyncHttpTask.java | 2 +- .../java/com/ejlchina/okhttps/internal/SyncHttpTask.java | 4 ++-- 3 files changed, 9 insertions(+), 5 deletions(-) diff --git a/src/main/java/com/ejlchina/okhttps/HttpTask.java b/src/main/java/com/ejlchina/okhttps/HttpTask.java index 392484d5..ae8f96fd 100644 --- a/src/main/java/com/ejlchina/okhttps/HttpTask.java +++ b/src/main/java/com/ejlchina/okhttps/HttpTask.java @@ -13,6 +13,7 @@ import java.io.IOException; import java.io.InputStream; import java.net.ConnectException; +import java.net.SocketException; import java.net.SocketTimeoutException; import java.net.UnknownHostException; import java.util.HashMap; @@ -559,12 +560,15 @@ private void buildHeaders(Request.Builder builder) { } } - protected State toState(IOException e) { + protected State toState(IOException e, boolean sync) { if (e instanceof SocketTimeoutException) { return State.TIMEOUT; } else if (e instanceof UnknownHostException || e instanceof ConnectException) { return State.NETWORK_ERROR; - } else if ("Canceled".equals(e.getMessage())) { + } + String msg = e.getMessage(); + if (msg != null && ("Canceled".equals(msg) || e instanceof SocketException + && msg.startsWith("Socket operation on nonsocket"))) { return State.CANCELED; } return State.EXCEPTION; diff --git a/src/main/java/com/ejlchina/okhttps/internal/AsyncHttpTask.java b/src/main/java/com/ejlchina/okhttps/internal/AsyncHttpTask.java index 7969fc11..49be51ff 100644 --- a/src/main/java/com/ejlchina/okhttps/internal/AsyncHttpTask.java +++ b/src/main/java/com/ejlchina/okhttps/internal/AsyncHttpTask.java @@ -239,7 +239,7 @@ private HttpCall executeCall(Call call) { call.enqueue(new Callback() { @Override public void onFailure(Call call, IOException error) { - State state = toState(error); + State state = toState(error, false); if (state == State.CANCELED) { httpCall.setResult(new RealHttpResult(AsyncHttpTask.this, state)); } else { diff --git a/src/main/java/com/ejlchina/okhttps/internal/SyncHttpTask.java b/src/main/java/com/ejlchina/okhttps/internal/SyncHttpTask.java index cbb9cdd4..4c3696dc 100644 --- a/src/main/java/com/ejlchina/okhttps/internal/SyncHttpTask.java +++ b/src/main/java/com/ejlchina/okhttps/internal/SyncHttpTask.java @@ -98,7 +98,7 @@ private HttpResult request(String method) { SyncHttpTask.this.notify(); } } catch (IOException e) { - State state = toState(e); + State state = toState(e, true); synchronized (SyncHttpTask.this) { result.exception(state, e); SyncHttpTask.this.notify(); @@ -114,7 +114,7 @@ private HttpResult request(String method) { } } } - Exception e = result.getError(); + IOException e = result.getError(); if (e != null && result.getState() != State.CANCELED && !nothrow) { throw new HttpException("请求执行异常", e); From 94043a090bd88fb33e42ab71944f541be1653231 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?=E5=91=A8=E6=97=AD?= Date: Thu, 9 Apr 2020 20:51:35 +0800 Subject: [PATCH 088/924] V1.0.2 ^_^ --- .../java/com/ejlchina/test/CancelTests.java | 36 ++++++++++++++++--- 1 file changed, 31 insertions(+), 5 deletions(-) diff --git a/src/test/java/com/ejlchina/test/CancelTests.java b/src/test/java/com/ejlchina/test/CancelTests.java index 45ec2707..e69dfa2b 100644 --- a/src/test/java/com/ejlchina/test/CancelTests.java +++ b/src/test/java/com/ejlchina/test/CancelTests.java @@ -2,6 +2,7 @@ import com.ejlchina.okhttps.HTTP; import com.ejlchina.okhttps.HttpResult; +import com.ejlchina.okhttps.HttpResult.State; import com.ejlchina.okhttps.internal.HttpClient; import org.junit.Test; @@ -13,14 +14,39 @@ public class CancelTests extends BaseTest { - public void testCancelAll() { + @Test + public void testCancelByTag() { HTTP http = HTTP.builder() - .baseUrl("http://localhost:8080") + .baseUrl("http://tst-api-mini.cdyun.vip") .build(); - - - + new Thread(() -> { + sleep(50); +// http.cancelAll(); +// int count = http.cancel("A"); +// println("count = " + count); + }).start(); + + http.async("/ejlchina/comm/provinces") + .setTag("A") + .setOnResponse((HttpResult result) -> { + println("异步：result = " + result); + }) + .setOnComplete((State state) -> { + println("异步：state = " + state); + }) + .get(); + + try { + HttpResult result = http.sync("/ejlchina/comm/provinces") + .setTag("A") + .get(); + + println("同步：result = " + result); + } catch (Exception e) { + e.printStackTrace(); + } + sleep(5000); } @Test From aa10838a97df402636a0845cc866e007872ec2ad Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?=E5=91=A8=E6=97=AD?= Date: Thu, 9 Apr 2020 21:04:48 +0800 Subject: [PATCH 089/924] V1.0.2 ^_^ --- README.md | 5 +++-- 1 file changed, 3 insertions(+), 2 deletions(-) diff --git a/README.md b/README.md index 98ca90d1..31067378 100644 --- a/README.md +++ b/README.md @@ -87,11 +87,12 @@ ```java HTTP http = HTTP.builder().build(); ``` -　　以上代码构建了一个最简单的`HTTP`实例，它拥有以下三个方法： +　　以上代码构建了一个最简单的`HTTP`实例，它拥有以下方法： * `async(String url)` 开始一个异步HTTP任务 * `sync(String url)` 开始一个同步HTTP任务 * `cancel(String tag)` 根据标签批量取消HTTP任务 +* `cancelAll()` 取消所有任务（since v1.0.2） 　　为了使用方便，在构建的时候，我们更愿意指定一个`BaseUrl`（请参见[5.1 设置 BaseUrl](#51-设置-baseurl)）: @@ -323,7 +324,7 @@ http.async("/users") //（5） int count = http.cancel("B"); //（2）（3）（4）被取消（取消标签包含"B"的任务） System.out.println(count); // 输出 3 ``` -　　同样的，只有异步HTTP任务才可以被取消。标签除了可以用来取消任务，在预处理器中它也可以发挥作用，请参见[并行预处理器](#54-并行预处理器)与[串行预处理器](#55-串行预处理器)。 +　　标签除了可以用来取消任务，在预处理器中它也可以发挥作用，请参见[并行预处理器](#54-并行预处理器)与[串行预处理器](#55-串行预处理器)。 ### 6 配置 HTTP From 261c2e8c3585e5934b2c192a0dd8bf413545fdee Mon Sep 17 00:00:00 2001 From: ejlchina Date: Fri, 10 Apr 2020 00:21:48 +0800 Subject: [PATCH 090/924] V1.0.2 ^_^ --- README.md | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/README.md b/README.md index 31067378..d4e29534 100644 --- a/README.md +++ b/README.md @@ -15,7 +15,7 @@ * 单方法回调，充分利用 Lambda 表达式 * TCP连接池、Http2 -> OkHttps 非常轻量，自身代码在 2000 行左右，且有较高的编码质量，sonarqube 分析结果为 3A，[查看报告](https://gitee.com/ejlchina-zhxu/okhttps/quality_analyses?platform=sonar_qube) +> OkHttps 非常轻量，自身代码仅 2000 行左右，且有较高的编码质量，sonarqube 分析结果为 3A，[查看报告](https://gitee.com/ejlchina-zhxu/okhttps/quality_analyses?platform=sonar_qube) ### 前世：[HttpUtils, V2.3.0 之后重命名为 OkHttps](https://gitee.com/ejlchina-zhxu/httputils) ### 当前文档版本[1.0.1] From 0956cec8e7ee74f69c1643f7cedf38d5c522b745 Mon Sep 17 00:00:00 2001 From: richenli <719583022@qq.com> Date: Fri, 10 Apr 2020 10:47:32 +0800 Subject: [PATCH 091/924] =?UTF-8?q?1.=E5=85=81=E8=AE=B8sync()=E5=92=8Casyn?= =?UTF-8?q?c()=E7=A9=BA=E5=8F=82=E4=BC=A0=E5=85=A5=20=E5=8E=9F=E5=9B=A0:?= =?UTF-8?q?=E9=83=A8=E5=88=86=E9=A1=B9=E7=9B=AE=E7=9A=84=E8=AF=B7=E6=B1=82?= =?UTF-8?q?=E8=B7=AF=E5=BE=84=E6=94=BE=E5=9C=A8json=E5=BD=93=E4=B8=AD?= =?UTF-8?q?=EF=BC=8C=E4=B8=8D=E4=BB=A5url=E4=B8=BA=E4=B8=BB=202.=E5=8A=A0?= =?UTF-8?q?=E5=85=A5=E8=B6=85=E6=97=B6=E6=97=B6=E9=97=B4=E8=AE=BE=E7=BD=AE?= =?UTF-8?q?=20HTTP=20http=20=3D=20HTTP.builder().builderTimeOut(3,3,=20Tim?= =?UTF-8?q?eUnit.SECONDS).build();=203.=E4=BC=98=E5=8C=96HttpTask=E9=83=A8?= =?UTF-8?q?=E5=88=86=E5=86=97=E4=BD=99=E4=BB=A3=E7=A0=81?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- src/main/java/com/ejlchina/okhttps/HTTP.java | 13 ++++ .../java/com/ejlchina/okhttps/HttpTask.java | 59 ++++++++----------- .../java/com/ejlchina/okhttps/HttpUtils.java | 16 +++++ .../ejlchina/okhttps/internal/HttpClient.java | 38 +++++++++++- 4 files changed, 91 insertions(+), 35 deletions(-) diff --git a/src/main/java/com/ejlchina/okhttps/HTTP.java b/src/main/java/com/ejlchina/okhttps/HTTP.java index 5252ff53..22232f1e 100644 --- a/src/main/java/com/ejlchina/okhttps/HTTP.java +++ b/src/main/java/com/ejlchina/okhttps/HTTP.java @@ -24,12 +24,25 @@ public interface HTTP { */ AsyncHttpTask async(String url); + /** + * 异步请求 + * @param url 请求地址 + * @return 异步HTTP任务 + */ + AsyncHttpTask async(); + /** * 同步请求 * @param url 请求地址 * @return 同步HTTP任务 */ SyncHttpTask sync(String url); + + /** + * 同步请求 + * @return 同步HTTP任务 + */ + SyncHttpTask sync(); /** * 根据标签取消HTTP任务，只要任务的标签包含指定的Tag就会被取消 diff --git a/src/main/java/com/ejlchina/okhttps/HttpTask.java b/src/main/java/com/ejlchina/okhttps/HttpTask.java index ae8f96fd..4d6038d7 100644 --- a/src/main/java/com/ejlchina/okhttps/HttpTask.java +++ b/src/main/java/com/ejlchina/okhttps/HttpTask.java @@ -18,6 +18,7 @@ import java.net.UnknownHostException; import java.util.HashMap; import java.util.Map; +import java.util.concurrent.TimeUnit; /** @@ -33,7 +34,6 @@ public abstract class HttpTask> { protected boolean nothrow; protected String tag; protected boolean nextOnIO = false; - private String urlPath; private Map headers; private Map pathParams; @@ -246,19 +246,10 @@ public C addPathParam(String name, Object value) { * @return HttpTask 实例 **/ public C addPathParam(Map params) { - if (params != null) { - if (pathParams == null) { - pathParams = new HashMap<>(); - } - params.forEach((String name, Object value) -> { - if (name != null && value != null) { - pathParams.put(name, value.toString()); - } - }); - } + addParams(params,this.pathParams); return (C) this; } - + /** * URL参数：拼接在URL后的参数 * @param name 参数名 @@ -281,16 +272,7 @@ public C addUrlParam(String name, Object value) { * @return HttpTask 实例 **/ public C addUrlParam(Map params) { - if (params != null) { - if (urlParams == null) { - urlParams = new HashMap<>(); - } - params.forEach((String name, Object value) -> { - if (name != null && value != null) { - urlParams.put(name, value.toString()); - } - }); - } + addParams(params,this.urlParams); return (C) this; } @@ -316,19 +298,26 @@ public C addBodyParam(String name, Object value) { * @return HttpTask 实例 **/ public C addBodyParam(Map params) { - if (params != null) { - if (bodyParams == null) { - bodyParams = new HashMap<>(); + addParams(params,this.bodyParams); + return (C) this; + } + private void addParams(Map params,Map addParam){ + if (params != null) { + if (addParam == null) { + addParam = new HashMap<>(); + } +// params.forEach((String name, Object value) -> { +// if (name != null && value != null) { +// addParam.put(name, value.toString()); +// } +// }); + for (Map.Entry stringEntry : params.entrySet()) { + if (stringEntry.getKey() != null && stringEntry.getValue() != null) { + addParam.put(stringEntry.getKey(), stringEntry.getValue().toString()); + } } - params.forEach((String name, Object value) -> { - if (name != null && value != null) { - bodyParams.put(name, value.toString()); - } - }); } - return (C) this; } - /** * Json参数：请求体为Json，支持多层结构 * @param name JSON键名 @@ -504,6 +493,10 @@ class FilePara { } protected Call prepareCall(String method) { +// OkHttpClient client = new OkHttpClient.Builder() +// .connectTimeout(connectTimeout,timeUnit) // 设置连接超时时间 +// .readTimeout(readTimeout,timeUnit) // 设置读取超时时间 +// .build(); assertNotConflict("GET".equals(method)); Request.Builder builder = new Request.Builder() .url(buildUrlPath()); @@ -526,7 +519,7 @@ protected Call prepareCall(String method) { } switch (method) { case "GET": - builder.get(); + builder.get().build(); break; case "POST": builder.post(reqBody); diff --git a/src/main/java/com/ejlchina/okhttps/HttpUtils.java b/src/main/java/com/ejlchina/okhttps/HttpUtils.java index a03e365f..e2a8e0af 100644 --- a/src/main/java/com/ejlchina/okhttps/HttpUtils.java +++ b/src/main/java/com/ejlchina/okhttps/HttpUtils.java @@ -59,6 +59,14 @@ public static AsyncHttpTask async(String url) { return getHttp().async(url); } + /** + * 异步请求 + * @return 异步 HttpTask + */ + public static AsyncHttpTask async() { + return getHttp().async(); + } + /** * 同步请求 * @param url 请求地址 @@ -68,6 +76,14 @@ public static SyncHttpTask sync(String url) { return getHttp().sync(url); } + /** + * 同步请求 + * @return 同步 HttpTask + */ + public static SyncHttpTask sync() { + return getHttp().sync(); + } + /** * 根据标签取消HTTP任务，只要任务的标签包含指定的Tag就会被取消 * @param tag 标签 diff --git a/src/main/java/com/ejlchina/okhttps/internal/HttpClient.java b/src/main/java/com/ejlchina/okhttps/internal/HttpClient.java index 15e69497..5a1ad119 100644 --- a/src/main/java/com/ejlchina/okhttps/internal/HttpClient.java +++ b/src/main/java/com/ejlchina/okhttps/internal/HttpClient.java @@ -10,6 +10,7 @@ import java.util.Map; import java.util.Queue; import java.util.concurrent.Executor; +import java.util.concurrent.TimeUnit; import com.ejlchina.okhttps.*; import com.ejlchina.okhttps.HttpResult.State; @@ -58,7 +59,17 @@ public AsyncHttpTask async(String url) { public SyncHttpTask sync(String url) { return new SyncHttpTask(this, urlPath(url)); } - + + @Override + public AsyncHttpTask async() { + return new AsyncHttpTask(this, urlPath()); + } + + @Override + public SyncHttpTask sync() { + return new SyncHttpTask(this, urlPath()); + } + @Override public int cancel(String tag) { if (tag == null) { @@ -86,6 +97,7 @@ public void cancelAll() { @Override public Call request(Request request) { + return client.newCall(request); } @@ -269,6 +281,13 @@ private String urlPath(String urlPath) { } throw new HttpException("在设置 BaseUrl 之前，您必须使用全路径URL发起请求，当前URL为：" + urlPath); } + + private String urlPath() { + if (baseUrl != null) { + return baseUrl; + } + throw new HttpException("在设置 BaseUrl 之前，您必须使用全路径URL发起请求，当前URL为：" + baseUrl); + } public static class Builder { @@ -430,7 +449,22 @@ public Builder downloadListener(DownListener listener) { this.downloadListener = listener; return this; } - + + /** + * 设置超时时间 + * @param connectTimeout 连接时间 + * @param readTimeout 读取时间 + * @param timeUnit + * @return + */ + public Builder builderTimeOut(long connectTimeout, long readTimeout, TimeUnit timeUnit) { + this.client= new OkHttpClient.Builder() + .connectTimeout(connectTimeout,timeUnit) // 设置连接超时时间 + .readTimeout(readTimeout,timeUnit) // 设置读取超时时间 + .build(); + return this; + } + public HTTP build() { if (configurator != null || client == null) { OkHttpClient.Builder builder = new OkHttpClient.Builder(); From 82eb2ea1c97f1033916a7b5b10bb57c9d4207018 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?=E5=91=A8=E6=97=AD?= Date: Fri, 10 Apr 2020 11:42:47 +0800 Subject: [PATCH 092/924] =?UTF-8?q?=E4=BC=98=E5=8C=96=E5=88=A4=E6=96=AD=20?= =?UTF-8?q?Cancel=20=E9=80=BB=E8=BE=91?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- src/main/java/com/ejlchina/okhttps/HttpTask.java | 3 ++- 1 file changed, 2 insertions(+), 1 deletion(-) diff --git a/src/main/java/com/ejlchina/okhttps/HttpTask.java b/src/main/java/com/ejlchina/okhttps/HttpTask.java index ae8f96fd..51d69a98 100644 --- a/src/main/java/com/ejlchina/okhttps/HttpTask.java +++ b/src/main/java/com/ejlchina/okhttps/HttpTask.java @@ -567,7 +567,8 @@ protected State toState(IOException e, boolean sync) { return State.NETWORK_ERROR; } String msg = e.getMessage(); - if (msg != null && ("Canceled".equals(msg) || e instanceof SocketException + if (msg != null && ("Canceled".equals(msg) + || sync && e instanceof SocketException && msg.startsWith("Socket operation on nonsocket"))) { return State.CANCELED; } From f63c0ac50db00a665703a9852594701dd3e813a5 Mon Sep 17 00:00:00 2001 From: richenli <719583022@qq.com> Date: Fri, 10 Apr 2020 12:20:25 +0800 Subject: [PATCH 093/924] =?UTF-8?q?1.=E4=BF=AE=E6=94=B9=E4=BB=A3=E7=A0=81?= =?UTF-8?q?=E6=A0=BC=E5=BC=8F=E9=97=AE=E9=A2=98=E4=BB=A5=E5=8F=8A=E6=B3=A8?= =?UTF-8?q?=E9=87=8A?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- src/main/java/com/ejlchina/okhttps/HTTP.java | 82 +- .../java/com/ejlchina/okhttps/HttpTask.java | 511 ++++++----- .../ejlchina/okhttps/internal/HttpClient.java | 852 +++++++++--------- 3 files changed, 743 insertions(+), 702 deletions(-) diff --git a/src/main/java/com/ejlchina/okhttps/HTTP.java b/src/main/java/com/ejlchina/okhttps/HTTP.java index 22232f1e..acb1fbd2 100644 --- a/src/main/java/com/ejlchina/okhttps/HTTP.java +++ b/src/main/java/com/ejlchina/okhttps/HTTP.java @@ -12,79 +12,87 @@ /** * HTTP 客户端接口 - * @author 15735 * + * @author 15735 */ public interface HTTP { - /** - * 异步请求 - * @param url 请求地址 - * @return 异步HTTP任务 - */ + /** + * 异步请求 + * + * @param url 请求地址 + * @return 异步HTTP任务 + */ AsyncHttpTask async(String url); - /** - * 异步请求 - * @param url 请求地址 - * @return 异步HTTP任务 - */ - AsyncHttpTask async(); + /** + * 异步请求 + * + * @return 异步HTTP任务 + */ + AsyncHttpTask async(); - /** - * 同步请求 - * @param url 请求地址 - * @return 同步HTTP任务 - */ + /** + * 同步请求 + * + * @param url 请求地址 + * @return 同步HTTP任务 + */ SyncHttpTask sync(String url); - /** - * 同步请求 - * @return 同步HTTP任务 - */ - SyncHttpTask sync(); - + /** + * 同步请求 + * + * @return 同步HTTP任务 + */ + SyncHttpTask sync(); + /** * 根据标签取消HTTP任务，只要任务的标签包含指定的Tag就会被取消 - * 从 v1.0.2 开始支持取消同步请求 + * 从 v1.0.2 开始支持取消同步请求 + * * @param tag 标签 * @return 被取消的任务数量 */ int cancel(String tag); - /** - * @since 1.0.2 - * 取消所有HTTP任务，包括同步和异步 - */ - void cancelAll(); + /** + * @since 1.0.2 + * 取消所有HTTP任务，包括同步和异步 + */ + void cancelAll(); /** * OkHttp 原生请求 （该请求不经过 预处理器） + * * @param request 请求 * @return Call */ Call request(Request request); - + /** * Websocket（该请求不经过 预处理器） - * @param request 请求 + * + * @param request 请求 * @param listener 监听器 * @return */ WebSocket webSocket(Request request, WebSocketListener listener); - + /** * 获取任务执行器 + * * @return TaskExecutor */ TaskExecutor getExecutor(); - + /** * HTTP 构建器 + * * @return HTTP 构建器 */ - static Builder builder() { - return new Builder(); - } - + static Builder builder() { + return new Builder(); + } + } diff --git a/src/main/java/com/ejlchina/okhttps/HttpTask.java b/src/main/java/com/ejlchina/okhttps/HttpTask.java index 4d6038d7..002fe663 100644 --- a/src/main/java/com/ejlchina/okhttps/HttpTask.java +++ b/src/main/java/com/ejlchina/okhttps/HttpTask.java @@ -44,273 +44,297 @@ public abstract class HttpTask> { private String requestJson; private OnCallback onProcess; private boolean pOnIO; - private long stepBytes = 0; - private double stepRate = -1; - - private Object object; - - + private long stepBytes = 0; + private double stepRate = -1; + + private Object object; + + public HttpTask(HttpClient httpClient, String url) { - this.httpClient = httpClient; - this.urlPath = url; + this.httpClient = httpClient; + this.urlPath = url; } /** * 获取请求任务的URL地址 + * * @return URL地址 */ public String getUrl() { - return urlPath; + return urlPath; } - + /** * 获取请求任务的标签 + * * @return 标签 */ public String getTag() { - return tag; - } - + return tag; + } + /** * 标签匹配 * 判断任务标签与指定的标签是否匹配（包含指定的标签） + * * @param tag 标签 * @return 是否匹配 */ public boolean isTagged(String tag) { - if (this.tag != null && tag != null) { - return this.tag.contains(tag); - } - return false; + if (this.tag != null && tag != null) { + return this.tag.contains(tag); + } + return false; } - + /** * 获取请求任务的头信息 + * * @return 头信息 */ public Map getHeaders() { - return headers; - } - + return headers; + } + /** * 获得被绑定的对象 + * * @return Object */ public Object getBound() { - return object; + return object; } - /** + /** * 设置在发生异常时不向上抛出，设置后： * 异步请求可以在异常回调内捕获异常，同步请求在返回结果中找到该异常 + * * @return HttpTask 实例 */ public C nothrow() { - this.nothrow = true; - return (C) this; + this.nothrow = true; + return (C) this; } - + /** * 为请求任务添加标签 + * * @param tag 标签 * @return HttpTask 实例 */ public C setTag(String tag) { - this.tag = tag; - return (C) this; + this.tag = tag; + return (C) this; } /** * 下一个回调在IO线程执行 + * * @return HttpTask 实例 */ public C nextOnIO() { - nextOnIO = true; - return (C) this; + nextOnIO = true; + return (C) this; } - + /** * 绑定一个对象 + * * @return HttpTask 实例 */ public C bind(Object object) { - this.object = object; - return (C) this; + this.object = object; + return (C) this; } - - /** + + /** * 添加请求头 - * @param name 请求头名 + * + * @param name 请求头名 * @param value 请求头值 * @return HttpTask 实例 */ - public C addHeader(String name, String value) { - if (name != null && value != null) { - if (headers == null) { + public C addHeader(String name, String value) { + if (name != null && value != null) { + if (headers == null) { headers = new HashMap<>(); } headers.put(name, value); - } + } return (C) this; } /** * 添加请求头 + * * @param headers 请求头集合 * @return HttpTask 实例 */ public C addHeader(Map headers) { - if (headers != null) { - if (this.headers == null) { - this.headers = new HashMap<>(); + if (headers != null) { + if (this.headers == null) { + this.headers = new HashMap<>(); } this.headers.putAll(headers); - } + } return (C) this; } - + /** * 设置Range头信息 * 表示接收报文体时跳过的字节数，用于断点续传 + * * @param rangeStart 表示从 rangeStart 个字节处开始接收，通常是已经下载的字节数，即上次的断点） * @return HttpTask 实例 */ public C setRange(long rangeStart) { - return addHeader("Range", "bytes=" + rangeStart + "-"); + return addHeader("Range", "bytes=" + rangeStart + "-"); } - + /** * 设置Range头信息 * 设置接收报文体时接收的范围，用于分块下载 + * * @param rangeStart 表示从 rangeStart 个字节处开始接收 - * @param rangeEnd 表示接收到 rangeEnd 个字节处 + * @param rangeEnd 表示接收到 rangeEnd 个字节处 * @return HttpTask 实例 */ public C setRange(long rangeStart, long rangeEnd) { - return addHeader("Range", "bytes=" + rangeStart + "-" + rangeEnd); - } - - /** - * 设置报文体发送进度回调 - * @param onProcess 进度回调函数 - * @return HttpTask 实例 - */ - public C setOnProcess(OnCallback onProcess) { - this.onProcess = onProcess; - pOnIO = nextOnIO; - nextOnIO = false; - return (C) this; - } - - /** - * 设置进度回调的步进字节，默认 8K（8192） - * 表示每接收 stepBytes 个字节，执行一次进度回调 - * @param stepBytes 步进字节 - * @return HttpTask 实例 - */ - public C setStepBytes(long stepBytes) { - this.stepBytes = stepBytes; - return (C) this; - } - - /** - * 设置进度回调的步进比例 - * 表示每接收 stepRate 比例，执行一次进度回调 - * @param stepRate 步进比例 - * @return HttpTask 实例 - */ - public C setStepRate(double stepRate) { - this.stepRate = stepRate; - return (C) this; - } - + return addHeader("Range", "bytes=" + rangeStart + "-" + rangeEnd); + } + + /** + * 设置报文体发送进度回调 + * + * @param onProcess 进度回调函数 + * @return HttpTask 实例 + */ + public C setOnProcess(OnCallback onProcess) { + this.onProcess = onProcess; + pOnIO = nextOnIO; + nextOnIO = false; + return (C) this; + } + + /** + * 设置进度回调的步进字节，默认 8K（8192） + * 表示每接收 stepBytes 个字节，执行一次进度回调 + * + * @param stepBytes 步进字节 + * @return HttpTask 实例 + */ + public C setStepBytes(long stepBytes) { + this.stepBytes = stepBytes; + return (C) this; + } + + /** + * 设置进度回调的步进比例 + * 表示每接收 stepRate 比例，执行一次进度回调 + * + * @param stepRate 步进比例 + * @return HttpTask 实例 + */ + public C setStepRate(double stepRate) { + this.stepRate = stepRate; + return (C) this; + } + /** * 路径参数：替换URL里的{name} - * @param name 参数名 + * + * @param name 参数名 * @param value 参数值 * @return HttpTask 实例 **/ public C addPathParam(String name, Object value) { - if (name != null && value != null) { - if (pathParams == null) { - pathParams = new HashMap<>(); - } - pathParams.put(name, value.toString()); - } + if (name != null && value != null) { + if (pathParams == null) { + pathParams = new HashMap<>(); + } + pathParams.put(name, value.toString()); + } return (C) this; } /** * 路径参数：替换URL里的{name} + * * @param params 参数集合 * @return HttpTask 实例 **/ public C addPathParam(Map params) { - addParams(params,this.pathParams); + addParams(params, this.pathParams); return (C) this; } /** * URL参数：拼接在URL后的参数 - * @param name 参数名 + * + * @param name 参数名 * @param value 参数值 * @return HttpTask 实例 **/ public C addUrlParam(String name, Object value) { - if (name != null && value != null) { - if (urlParams == null) { - urlParams = new HashMap<>(); - } - urlParams.put(name, value.toString()); - } + if (name != null && value != null) { + if (urlParams == null) { + urlParams = new HashMap<>(); + } + urlParams.put(name, value.toString()); + } return (C) this; } /** * URL参数：拼接在URL后的参数 + * * @param params 参数集合 * @return HttpTask 实例 **/ public C addUrlParam(Map params) { - addParams(params,this.urlParams); + addParams(params, this.urlParams); return (C) this; } /** * Body参数：放在Body里的参数 - * @param name 参数名 + * + * @param name 参数名 * @param value 参数值 * @return HttpTask 实例 **/ public C addBodyParam(String name, Object value) { - if (name != null && value != null) { - if (bodyParams == null) { - bodyParams = new HashMap<>(); - } - bodyParams.put(name, value.toString()); - } + if (name != null && value != null) { + if (bodyParams == null) { + bodyParams = new HashMap<>(); + } + bodyParams.put(name, value.toString()); + } return (C) this; } /** * Body参数：放在Body里的参数 + * * @param params 参数集合 * @return HttpTask 实例 **/ public C addBodyParam(Map params) { - addParams(params,this.bodyParams); + addParams(params, this.bodyParams); return (C) this; } - private void addParams(Map params,Map addParam){ + + /** + * 批量添加参数 + * + * @param params + * @param addParam + */ + private void addParams(Map params, Map addParam) { if (params != null) { if (addParam == null) { addParam = new HashMap<>(); } -// params.forEach((String name, Object value) -> { -// if (name != null && value != null) { -// addParam.put(name, value.toString()); -// } -// }); for (Map.Entry stringEntry : params.entrySet()) { if (stringEntry.getKey() != null && stringEntry.getValue() != null) { addParam.put(stringEntry.getKey(), stringEntry.getValue().toString()); @@ -318,32 +342,35 @@ private void addParams(Map params,Map addParam){ } } } + /** * Json参数：请求体为Json，支持多层结构 - * @param name JSON键名 + * + * @param name JSON键名 * @param value JSON键值 * @return HttpTask 实例 */ public C addJsonParam(String name, Object value) { - if (name != null && value != null) { - if (jsonParams == null) { - jsonParams = new HashMap<>(); - } - jsonParams.put(name, value); - } + if (name != null && value != null) { + if (jsonParams == null) { + jsonParams = new HashMap<>(); + } + jsonParams.put(name, value); + } return (C) this; } /** * Json参数：请求体为Json，只支持单层Json * 若请求json为多层结构，请使用setRequestJson方法 + * * @param params JSON键值集合 * @return HttpTask 实例 */ public C addJsonParam(Map params) { - if (params != null) { + if (params != null) { if (jsonParams == null) { - jsonParams = new HashMap<>(); + jsonParams = new HashMap<>(); } jsonParams.putAll(params); } @@ -352,6 +379,7 @@ public C addJsonParam(Map params) { /** * 设置 json 请求体 + * * @param json JSON字符串 或 Java对象（将依据 对象的get方法序列化为 json 字符串） * @return HttpTask 实例 **/ @@ -361,26 +389,28 @@ public C setRequestJson(Object json) { /** * 请求体为json - * @param json JSON字符串 或 Java对象，将跟换 bean的get方法序列化程 json 字符串 + * + * @param json JSON字符串 或 Java对象，将跟换 bean的get方法序列化程 json 字符串 * @param dateFormat 序列化json时对日期类型字段的处理格式 * @return HttpTask 实例 **/ public C setRequestJson(Object json, String dateFormat) { if (json != null) { - if (json instanceof String) { - requestJson = json.toString(); - } else if (dateFormat != null) { - requestJson = JSON.toJSONStringWithDateFormat(json, dateFormat); - } else { - requestJson = JSON.toJSONString(json); - } + if (json instanceof String) { + requestJson = json.toString(); + } else if (dateFormat != null) { + requestJson = JSON.toJSONStringWithDateFormat(json, dateFormat); + } else { + requestJson = JSON.toJSONString(json); + } } return (C) this; } - + /** * 添加文件参数 - * @param name 参数名 + * + * @param name 参数名 * @param filePath 文件路径 * @return HttpTask 实例 */ @@ -390,6 +420,7 @@ public C addFileParam(String name, String filePath) { /** * 添加文件参数 + * * @param name 参数名 * @param file 文件 * @return HttpTask 实例 @@ -408,57 +439,61 @@ public C addFileParam(String name, File file) { /** * 添加文件参数 - * @param name 参数名 - * @param type 文件类型: 如 png、jpg、jpeg 等 + * + * @param name 参数名 + * @param type 文件类型: 如 png、jpg、jpeg 等 * @param inputStream 文件输入流 * @return HttpTask 实例 */ public C addFileParam(String name, String type, InputStream inputStream) { - return addFileParam(name, type, null, inputStream); + return addFileParam(name, type, null, inputStream); } - + /** * 添加文件参数 - * @param name 参数名 - * @param type 文件类型: 如 png、jpg、jpeg 等 + * + * @param name 参数名 + * @param type 文件类型: 如 png、jpg、jpeg 等 * @param fileName 文件名 - * @param input 文件输入流 + * @param input 文件输入流 * @return HttpTask 实例 */ public C addFileParam(String name, String type, String fileName, InputStream input) { if (name != null && input != null) { byte[] content = null; - try { - Buffer buffer = new Buffer(); - content = buffer.readFrom(input).readByteArray(); - buffer.close(); - } catch (IOException e) { - throw new HttpException("读取文件输入流出错：", e); - } finally { - Util.closeQuietly(input); - } + try { + Buffer buffer = new Buffer(); + content = buffer.readFrom(input).readByteArray(); + buffer.close(); + } catch (IOException e) { + throw new HttpException("读取文件输入流出错：", e); + } finally { + Util.closeQuietly(input); + } addFileParam(name, type, fileName, content); } return (C) this; } - + /** * 添加文件参数 - * @param name 参数名 - * @param type 文件类型: 如 png、jpg、jpeg 等 + * + * @param name 参数名 + * @param type 文件类型: 如 png、jpg、jpeg 等 * @param content 文件内容 * @return HttpTask 实例 */ public C addFileParam(String name, String type, byte[] content) { - return addFileParam(name, type, null, content); + return addFileParam(name, type, null, content); } - + /** * 添加文件参数 - * @param name 参数名 - * @param type 文件类型: 如 png、jpg、jpeg 等 + * + * @param name 参数名 + * @param type 文件类型: 如 png、jpg、jpeg 等 * @param fileName 文件名 - * @param content 文件内容 + * @param content 文件内容 * @return HttpTask 实例 */ public C addFileParam(String name, String type, String fileName, byte[] content) { @@ -472,75 +507,75 @@ public C addFileParam(String name, String type, String fileName, byte[] content) } class FilePara { - - String type; - String fileName; - byte[] content; - File file; - - FilePara(String type, String fileName, byte[] content) { - this.type = type; - this.fileName = fileName; - this.content = content; - } - - FilePara(String type, String fileName, File file) { - this.type = type; - this.fileName = fileName; - this.file = file; - } - - } - + + String type; + String fileName; + byte[] content; + File file; + + FilePara(String type, String fileName, byte[] content) { + this.type = type; + this.fileName = fileName; + this.content = content; + } + + FilePara(String type, String fileName, File file) { + this.type = type; + this.fileName = fileName; + this.file = file; + } + + } + protected Call prepareCall(String method) { // OkHttpClient client = new OkHttpClient.Builder() // .connectTimeout(connectTimeout,timeUnit) // 设置连接超时时间 // .readTimeout(readTimeout,timeUnit) // 设置读取超时时间 // .build(); - assertNotConflict("GET".equals(method)); + assertNotConflict("GET".equals(method)); Request.Builder builder = new Request.Builder() - .url(buildUrlPath()); + .url(buildUrlPath()); buildHeaders(builder); - RequestBody reqBody = null; - if (!"GET".equals(method)) { - reqBody = buildRequestBody(); - if (onProcess != null) { - long contentLength = contentLength(reqBody); - if (stepRate > 0 && stepRate <= 1) { - stepBytes = (long) (contentLength * stepRate); - } - if (stepBytes <= 0) { - stepBytes = Process.DEFAULT_STEP_BYTES; - } - reqBody = new ProcessRequestBody(reqBody, onProcess, - httpClient.getExecutor().getExecutor(pOnIO), - contentLength, stepBytes); - } - } - switch (method) { - case "GET": - builder.get().build(); - break; - case "POST": - builder.post(reqBody); - break; - case "PUT": - builder.put(reqBody); - break; - case "DELETE": - builder.delete(reqBody); - break; + RequestBody reqBody = null; + if (!"GET".equals(method)) { + reqBody = buildRequestBody(); + if (onProcess != null) { + long contentLength = contentLength(reqBody); + if (stepRate > 0 && stepRate <= 1) { + stepBytes = (long) (contentLength * stepRate); + } + if (stepBytes <= 0) { + stepBytes = Process.DEFAULT_STEP_BYTES; + } + reqBody = new ProcessRequestBody(reqBody, onProcess, + httpClient.getExecutor().getExecutor(pOnIO), + contentLength, stepBytes); + } + } + switch (method) { + case "GET": + builder.get().build(); + break; + case "POST": + builder.post(reqBody); + break; + case "PUT": + builder.put(reqBody); + break; + case "DELETE": + builder.delete(reqBody); + break; } - return httpClient.request(builder.build()); - } + return httpClient.request(builder.build()); + } - private long contentLength(RequestBody reqBody) { - try { - return reqBody.contentLength(); - } catch (IOException e) { - throw new HttpException("无法获取请求体长度", e); - } - } + private long contentLength(RequestBody reqBody) { + try { + return reqBody.contentLength(); + } catch (IOException e) { + throw new HttpException("无法获取请求体长度", e); + } + } private void buildHeaders(Request.Builder builder) { if (headers != null) { @@ -553,19 +588,19 @@ private void buildHeaders(Request.Builder builder) { } } - protected State toState(IOException e, boolean sync) { - if (e instanceof SocketTimeoutException) { - return State.TIMEOUT; - } else if (e instanceof UnknownHostException || e instanceof ConnectException) { - return State.NETWORK_ERROR; - } - String msg = e.getMessage(); - if (msg != null && ("Canceled".equals(msg) || e instanceof SocketException + protected State toState(IOException e, boolean sync) { + if (e instanceof SocketTimeoutException) { + return State.TIMEOUT; + } else if (e instanceof UnknownHostException || e instanceof ConnectException) { + return State.NETWORK_ERROR; + } + String msg = e.getMessage(); + if (msg != null && ("Canceled".equals(msg) || e instanceof SocketException && msg.startsWith("Socket operation on nonsocket"))) { - return State.CANCELED; - } - return State.EXCEPTION; - } + return State.CANCELED; + } + return State.EXCEPTION; + } private RequestBody buildRequestBody() { if (jsonParams != null) { @@ -584,11 +619,11 @@ private RequestBody buildRequestBody() { MediaType type = httpClient.getMediaType(file.type); RequestBody bodyPart; if (file.file != null) { - bodyPart = RequestBody.create(type, file.file); + bodyPart = RequestBody.create(type, file.file); } else { - bodyPart = RequestBody.create(type, file.content); + bodyPart = RequestBody.create(type, file.content); } - builder.addFormDataPart(name, file.fileName, bodyPart); + builder.addFormDataPart(name, file.fileName, bodyPart); } return builder.build(); } else if (requestJson != null) { @@ -596,17 +631,17 @@ private RequestBody buildRequestBody() { } else { FormBody.Builder builder = new FormBody.Builder(); if (bodyParams != null) { - for (String name : bodyParams.keySet()) { - String value = bodyParams.get(name); - builder.add(name, value); - } + for (String name : bodyParams.keySet()) { + String value = bodyParams.get(name); + builder.add(name, value); + } } return builder.build(); } } private String buildUrlPath() { - String url = urlPath; + String url = urlPath; if (url == null || url.trim().isEmpty()) { throw new HttpException("url 不能为空！"); } diff --git a/src/main/java/com/ejlchina/okhttps/internal/HttpClient.java b/src/main/java/com/ejlchina/okhttps/internal/HttpClient.java index 5a1ad119..62d48d69 100644 --- a/src/main/java/com/ejlchina/okhttps/internal/HttpClient.java +++ b/src/main/java/com/ejlchina/okhttps/internal/HttpClient.java @@ -24,130 +24,130 @@ public class HttpClient implements HTTP { - // OkHttpClient - final OkHttpClient client; - // 根URL - final String baseUrl; - // 媒体类型 - final Map mediaTypes; - // 执行器 - final TaskExecutor executor; - // 预处理器 - final Preprocessor[] preprocessors; - // 持有标签的任务 - final List tagTasks; - - - private HttpClient(Builder builder) { - this.client = builder.client; - this.baseUrl = builder.baseUrl; - this.mediaTypes = builder.mediaTypes; - this.executor = new TaskExecutor(client.dispatcher().executorService(), - builder.mainExecutor, builder.downloadListener, - builder.responseListener, builder.exceptionListener, - builder.completeListener); - this.preprocessors = builder.preprocessors.toArray(new Preprocessor[0]); - this.tagTasks = Collections.synchronizedList(new LinkedList<>()); - } - - @Override + // OkHttpClient + final OkHttpClient client; + // 根URL + final String baseUrl; + // 媒体类型 + final Map mediaTypes; + // 执行器 + final TaskExecutor executor; + // 预处理器 + final Preprocessor[] preprocessors; + // 持有标签的任务 + final List tagTasks; + + + private HttpClient(Builder builder) { + this.client = builder.client; + this.baseUrl = builder.baseUrl; + this.mediaTypes = builder.mediaTypes; + this.executor = new TaskExecutor(client.dispatcher().executorService(), + builder.mainExecutor, builder.downloadListener, + builder.responseListener, builder.exceptionListener, + builder.completeListener); + this.preprocessors = builder.preprocessors.toArray(new Preprocessor[0]); + this.tagTasks = Collections.synchronizedList(new LinkedList<>()); + } + + @Override public AsyncHttpTask async(String url) { return new AsyncHttpTask(this, urlPath(url)); } - @Override + @Override public SyncHttpTask sync(String url) { return new SyncHttpTask(this, urlPath(url)); } - @Override - public AsyncHttpTask async() { - return new AsyncHttpTask(this, urlPath()); - } - - @Override - public SyncHttpTask sync() { - return new SyncHttpTask(this, urlPath()); - } - - @Override - public int cancel(String tag) { - if (tag == null) { - return 0; - } - int count = 0; - Iterator it = tagTasks.iterator(); - while (it.hasNext()) { - TagTask tagCall = it.next(); - // 只要任务的标签包含指定的Tag就会被取消 - if (tagCall.tag.contains(tag)) { - if (tagCall.canceler.cancel()) { - count++; - } - it.remove(); - } - } - return count; - } - - @Override - public void cancelAll() { - client.dispatcher().cancelAll(); - } - - @Override - public Call request(Request request) { - - return client.newCall(request); + @Override + public AsyncHttpTask async() { + return new AsyncHttpTask(this, urlPath()); + } + + @Override + public SyncHttpTask sync() { + return new SyncHttpTask(this, urlPath()); + } + + @Override + public int cancel(String tag) { + if (tag == null) { + return 0; + } + int count = 0; + Iterator it = tagTasks.iterator(); + while (it.hasNext()) { + TagTask tagCall = it.next(); + // 只要任务的标签包含指定的Tag就会被取消 + if (tagCall.tag.contains(tag)) { + if (tagCall.canceler.cancel()) { + count++; + } + it.remove(); + } + } + return count; + } + + @Override + public void cancelAll() { + client.dispatcher().cancelAll(); + } + + @Override + public Call request(Request request) { + + return client.newCall(request); } - - @Override - public WebSocket webSocket(Request request, WebSocketListener listener) { - return client.newWebSocket(request, listener); - } - - public OkHttpClient getOkClient() { - return client; - } - - public int totalTimeoutMillis() { - return client.connectTimeoutMillis() + client.writeTimeoutMillis() + client.readTimeoutMillis(); - } - - public int getTagTaskCount() { - return tagTasks.size(); - } - - public void addTagTask(String tag, Cancelable canceler, HttpTask task) { - tagTasks.add(new TagTask(tag, canceler, task)); - } - - public void removeTagTask(HttpTask task) { - Iterator it = tagTasks.iterator(); - while (it.hasNext()) { - TagTask tagCall = it.next(); - if (tagCall.task == task) { - it.remove(); - break; - } - } - } - - static class TagTask { - - String tag; - Cancelable canceler; - HttpTask task; - - public TagTask(String tag, Cancelable canceler, HttpTask task) { - this.tag = tag; - this.canceler = canceler; - this.task = task; - } - - } - - public MediaType getMediaType(String type) { + + @Override + public WebSocket webSocket(Request request, WebSocketListener listener) { + return client.newWebSocket(request, listener); + } + + public OkHttpClient getOkClient() { + return client; + } + + public int totalTimeoutMillis() { + return client.connectTimeoutMillis() + client.writeTimeoutMillis() + client.readTimeoutMillis(); + } + + public int getTagTaskCount() { + return tagTasks.size(); + } + + public void addTagTask(String tag, Cancelable canceler, HttpTask task) { + tagTasks.add(new TagTask(tag, canceler, task)); + } + + public void removeTagTask(HttpTask task) { + Iterator it = tagTasks.iterator(); + while (it.hasNext()) { + TagTask tagCall = it.next(); + if (tagCall.task == task) { + it.remove(); + break; + } + } + } + + static class TagTask { + + String tag; + Cancelable canceler; + HttpTask task; + + public TagTask(String tag, Cancelable canceler, HttpTask task) { + this.tag = tag; + this.canceler = canceler; + this.task = task; + } + + } + + public MediaType getMediaType(String type) { String mediaType = mediaTypes.get(type); if (mediaType != null) { return MediaType.parse(mediaType); @@ -155,327 +155,325 @@ public MediaType getMediaType(String type) { return MediaType.parse("application/octet-stream"); } - public TaskExecutor getExecutor() { - return executor; - } - - public void preprocess(HttpTask> httpTask, Runnable request) { - if (preprocessors.length > 0) { - RealPreChain process = new RealPreChain(preprocessors, - httpTask, request); - preprocessors[0].doProcess(process); - } else { - request.run(); - } + public TaskExecutor getExecutor() { + return executor; + } + + public void preprocess(HttpTask> httpTask, Runnable request) { + if (preprocessors.length > 0) { + RealPreChain process = new RealPreChain(preprocessors, + httpTask, request); + preprocessors[0].doProcess(process); + } else { + request.run(); + } } - + /** * 串行预处理器 + * * @author Troy.Zhou */ static class SerialPreprocessor implements Preprocessor { - - // 预处理器 - private Preprocessor preprocessor; - // 待处理的任务队列 - private Queue pendings; - // 是否有任务正在执行 - private boolean running = false; - - SerialPreprocessor(Preprocessor preprocessor) { - this.preprocessor = preprocessor; - this.pendings = new LinkedList<>(); - } - - @Override - public void doProcess(PreChain process) { - boolean should = true; - synchronized (this) { - if (running) { - pendings.add(process); - should = false; - } else { - running = true; - } - } - if (should) { - preprocessor.doProcess(process); - } - } - - public void afterProcess() { - PreChain process = null; - synchronized (this) { - if (pendings.size() > 0) { - process = pendings.poll(); - } else { - running = false; - } - } - if (process != null) { - preprocessor.doProcess(process); - } - } - + + // 预处理器 + private Preprocessor preprocessor; + // 待处理的任务队列 + private Queue pendings; + // 是否有任务正在执行 + private boolean running = false; + + SerialPreprocessor(Preprocessor preprocessor) { + this.preprocessor = preprocessor; + this.pendings = new LinkedList<>(); + } + + @Override + public void doProcess(PreChain process) { + boolean should = true; + synchronized (this) { + if (running) { + pendings.add(process); + should = false; + } else { + running = true; + } + } + if (should) { + preprocessor.doProcess(process); + } + } + + public void afterProcess() { + PreChain process = null; + synchronized (this) { + if (pendings.size() > 0) { + process = pendings.poll(); + } else { + running = false; + } + } + if (process != null) { + preprocessor.doProcess(process); + } + } + } - - + + class RealPreChain implements Preprocessor.PreChain { - private int index; - - private Preprocessor[] preprocessors; - - private HttpTask httpTask; - - private Runnable request; - - public RealPreChain(Preprocessor[] preprocessors, - HttpTask httpTask, - Runnable request) { - this.index = 1; - this.preprocessors = preprocessors; - this.httpTask = httpTask; - this.request = request; - } - - @Override - public HttpTask getTask() { - return httpTask; - } - - @Override - public HTTP getHttp() { - return HttpClient.this; - } - - @Override - public void proceed() { - if (index > 0) { - Preprocessor last = preprocessors[index - 1]; - if (last instanceof SerialPreprocessor) { - ((SerialPreprocessor) last).afterProcess(); - } - } - if (index < preprocessors.length) { - preprocessors[index++].doProcess(this); - } else { - request.run(); - } - } + private int index; + + private Preprocessor[] preprocessors; + + private HttpTask httpTask; + + private Runnable request; + + public RealPreChain(Preprocessor[] preprocessors, + HttpTask httpTask, + Runnable request) { + this.index = 1; + this.preprocessors = preprocessors; + this.httpTask = httpTask; + this.request = request; + } + + @Override + public HttpTask getTask() { + return httpTask; + } + + @Override + public HTTP getHttp() { + return HttpClient.this; + } + + @Override + public void proceed() { + if (index > 0) { + Preprocessor last = preprocessors[index - 1]; + if (last instanceof SerialPreprocessor) { + ((SerialPreprocessor) last).afterProcess(); + } + } + if (index < preprocessors.length) { + preprocessors[index++].doProcess(this); + } else { + request.run(); + } + } + + } + + public Builder newBuilder() { + return new Builder(this); + } + + private String urlPath(String urlPath) { + boolean isFullPath = urlPath.startsWith("https://") + || urlPath.startsWith("http://"); + if (isFullPath) { + return urlPath; + } + if (baseUrl != null) { + return baseUrl + urlPath; + } + throw new HttpException("在设置 BaseUrl 之前，您必须使用全路径URL发起请求，当前URL为：" + urlPath); + } + + private String urlPath() { + if (baseUrl != null) { + return baseUrl; + } + throw new HttpException("在设置 BaseUrl 之前，您必须使用全路径URL发起请求，当前URL为：" + baseUrl); + } + + + public static class Builder { + + private OkHttpClient client; + + private String baseUrl; + + private Map mediaTypes; + + private Configurator configurator; + + private Executor mainExecutor; + + private List preprocessors; + + private DownListener downloadListener; + + private TaskListener responseListener; + + private TaskListener exceptionListener; + + private TaskListener completeListener; + + public Builder() { + mediaTypes = new HashMap<>(); + mediaTypes.put("*", "application/octet-stream"); + mediaTypes.put("png", "image/png"); + mediaTypes.put("jpg", "image/jpeg"); + mediaTypes.put("jpeg", "image/jpeg"); + mediaTypes.put("wav", "audio/wav"); + mediaTypes.put("mp3", "audio/mp3"); + mediaTypes.put("mp4", "video/mpeg4"); + mediaTypes.put("txt", "text/plain"); + mediaTypes.put("xls", "application/x-xls"); + mediaTypes.put("xml", "text/xml"); + mediaTypes.put("apk", "application/vnd.android.package-archive"); + mediaTypes.put("doc", "application/msword"); + mediaTypes.put("pdf", "application/pdf"); + mediaTypes.put("html", "text/html"); + preprocessors = new ArrayList<>(); + } + + private Builder(HttpClient hc) { + this.client = hc.client; + this.baseUrl = hc.baseUrl; + this.mediaTypes = hc.mediaTypes; + this.preprocessors = new ArrayList<>(); + Collections.addAll(this.preprocessors, hc.preprocessors); + } + + /** + * 配置 OkHttpClient + * + * @param configurator 配置器 + * @return Builder + */ + public Builder config(Configurator configurator) { + this.configurator = configurator; + return this; + } + + /** + * 设置 baseUrl + * + * @param baseUrl 全局URL前缀 + * @return Builder + */ + public Builder baseUrl(String baseUrl) { + this.baseUrl = baseUrl; + return this; + } + + /** + * 配置媒体类型 + * + * @param mediaTypes 媒体类型 + * @return Builder + */ + public Builder mediaTypes(Map mediaTypes) { + this.mediaTypes.putAll(mediaTypes); + return this; + } + + /** + * 配置媒体类型 + * + * @param key 媒体类型KEY + * @param value 媒体类型VALUE + * @return Builder + */ + public Builder mediaTypes(String key, String value) { + this.mediaTypes.put(key, value); + return this; + } + + /** + * 设置回调执行器，例如实现切换线程功能，只对异步请求有效 + * + * @param executor 回调执行器 + * @return Builder + */ + public Builder callbackExecutor(Executor executor) { + this.mainExecutor = executor; + return this; + } + + /** + * 添加可并行处理请求任务的预处理器 + * + * @param preprocessor 预处理器 + * @return Builder + */ + public Builder addPreprocessor(Preprocessor preprocessor) { + preprocessors.add(preprocessor); + return this; + } + + /** + * 添加预处理器 + * + * @param preprocessor 预处理器 + * @return Builder + */ + public Builder addSerialPreprocessor(Preprocessor preprocessor) { + preprocessors.add(new SerialPreprocessor(preprocessor)); + return this; + } + + /** + * 设置全局响应监听 + * + * @param listener 监听器 + * @return Builder + */ + public Builder responseListener(TaskListener listener) { + this.responseListener = listener; + return this; + } + + /** + * 设置全局异常监听 + * + * @param listener 监听器 + * @return Builder + */ + public Builder exceptionListener(TaskListener listener) { + this.exceptionListener = listener; + return this; + } + + /** + * 设置全局完成监听 + * + * @param listener 监听器 + * @return Builder + */ + public Builder completeListener(TaskListener listener) { + this.completeListener = listener; + return this; + } + + /** + * 设置下载监听器 + * + * @param listener 监听器 + * @return Builder + */ + public Builder downloadListener(DownListener listener) { + this.downloadListener = listener; + return this; + } + + + public HTTP build() { + if (configurator != null || client == null) { + OkHttpClient.Builder builder = new OkHttpClient.Builder(); + if (configurator != null) { + configurator.config(builder); + } + client = builder.build(); + } + return new HttpClient(this); + } } - - public Builder newBuilder() { - return new Builder(this); - } - - private String urlPath(String urlPath) { - boolean isFullPath = urlPath.startsWith("https://") - || urlPath.startsWith("http://"); - if (isFullPath) { - return urlPath; - } - if (baseUrl != null) { - return baseUrl + urlPath; - } - throw new HttpException("在设置 BaseUrl 之前，您必须使用全路径URL发起请求，当前URL为：" + urlPath); - } - - private String urlPath() { - if (baseUrl != null) { - return baseUrl; - } - throw new HttpException("在设置 BaseUrl 之前，您必须使用全路径URL发起请求，当前URL为：" + baseUrl); - } - - - public static class Builder { - - private OkHttpClient client; - - private String baseUrl; - - private Map mediaTypes; - - private Configurator configurator; - - private Executor mainExecutor; - - private List preprocessors; - - private DownListener downloadListener; - - private TaskListener responseListener; - - private TaskListener exceptionListener; - - private TaskListener completeListener; - - public Builder() { - mediaTypes = new HashMap<>(); - mediaTypes.put("*", "application/octet-stream"); - mediaTypes.put("png", "image/png"); - mediaTypes.put("jpg", "image/jpeg"); - mediaTypes.put("jpeg", "image/jpeg"); - mediaTypes.put("wav", "audio/wav"); - mediaTypes.put("mp3", "audio/mp3"); - mediaTypes.put("mp4", "video/mpeg4"); - mediaTypes.put("txt", "text/plain"); - mediaTypes.put("xls", "application/x-xls"); - mediaTypes.put("xml", "text/xml"); - mediaTypes.put("apk", "application/vnd.android.package-archive"); - mediaTypes.put("doc", "application/msword"); - mediaTypes.put("pdf", "application/pdf"); - mediaTypes.put("html", "text/html"); - preprocessors = new ArrayList<>(); - } - - private Builder(HttpClient hc) { - this.client = hc.client; - this.baseUrl = hc.baseUrl; - this.mediaTypes = hc.mediaTypes; - this.preprocessors = new ArrayList<>(); - Collections.addAll(this.preprocessors, hc.preprocessors); - } - - /** - * 配置 OkHttpClient - * @param configurator 配置器 - * @return Builder - */ - public Builder config(Configurator configurator) { - this.configurator = configurator; - return this; - } - - /** - * 设置 baseUrl - * @param baseUrl 全局URL前缀 - * @return Builder - */ - public Builder baseUrl(String baseUrl) { - this.baseUrl = baseUrl; - return this; - } - - /** - * 配置媒体类型 - * @param mediaTypes 媒体类型 - * @return Builder - */ - public Builder mediaTypes(Map mediaTypes) { - this.mediaTypes.putAll(mediaTypes); - return this; - } - - /** - * 配置媒体类型 - * @param key 媒体类型KEY - * @param value 媒体类型VALUE - * @return Builder - */ - public Builder mediaTypes(String key, String value) { - this.mediaTypes.put(key, value); - return this; - } - - /** - * 设置回调执行器，例如实现切换线程功能，只对异步请求有效 - * @param executor 回调执行器 - * @return Builder - */ - public Builder callbackExecutor(Executor executor) { - this.mainExecutor = executor; - return this; - } - - /** - * 添加可并行处理请求任务的预处理器 - * @param preprocessor 预处理器 - * @return Builder - */ - public Builder addPreprocessor(Preprocessor preprocessor) { - preprocessors.add(preprocessor); - return this; - } - - /** - * 添加预处理器 - * @param preprocessor 预处理器 - * @return Builder - */ - public Builder addSerialPreprocessor(Preprocessor preprocessor) { - preprocessors.add(new SerialPreprocessor(preprocessor)); - return this; - } - - /** - * 设置全局响应监听 - * @param listener 监听器 - * @return Builder - */ - public Builder responseListener(TaskListener listener) { - this.responseListener = listener; - return this; - } - - /** - * 设置全局异常监听 - * @param listener 监听器 - * @return Builder - */ - public Builder exceptionListener(TaskListener listener) { - this.exceptionListener = listener; - return this; - } - - /** - * 设置全局完成监听 - * @param listener 监听器 - * @return Builder - */ - public Builder completeListener(TaskListener listener) { - this.completeListener = listener; - return this; - } - - /** - * 设置下载监听器 - * @param listener 监听器 - * @return Builder - */ - public Builder downloadListener(DownListener listener) { - this.downloadListener = listener; - return this; - } - - /** - * 设置超时时间 - * @param connectTimeout 连接时间 - * @param readTimeout 读取时间 - * @param timeUnit - * @return - */ - public Builder builderTimeOut(long connectTimeout, long readTimeout, TimeUnit timeUnit) { - this.client= new OkHttpClient.Builder() - .connectTimeout(connectTimeout,timeUnit) // 设置连接超时时间 - .readTimeout(readTimeout,timeUnit) // 设置读取超时时间 - .build(); - return this; - } - - public HTTP build() { - if (configurator != null || client == null) { - OkHttpClient.Builder builder = new OkHttpClient.Builder(); - if (configurator != null) { - configurator.config(builder); - } - client = builder.build(); - } - return new HttpClient(this); - } - - } - + } From dbef39a0ad6d3dec0a98e1c74e64ea897b34d7fa Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?=E5=91=A8=E6=97=AD?= Date: Fri, 10 Apr 2020 14:14:51 +0800 Subject: [PATCH 094/924] =?UTF-8?q?=E4=BC=98=E5=8C=96=20build=20url=20path?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- .../java/com/ejlchina/okhttps/HttpTask.java | 40 ++++++++++--------- 1 file changed, 22 insertions(+), 18 deletions(-) diff --git a/src/main/java/com/ejlchina/okhttps/HttpTask.java b/src/main/java/com/ejlchina/okhttps/HttpTask.java index 7e251013..59b57d93 100644 --- a/src/main/java/com/ejlchina/okhttps/HttpTask.java +++ b/src/main/java/com/ejlchina/okhttps/HttpTask.java @@ -474,7 +474,7 @@ public C addFileParam(String name, String type, String fileName, byte[] content) return (C) this; } - class FilePara { + static class FilePara { String type; String fileName; @@ -624,27 +624,31 @@ private String buildUrlPath() { throw new HttpException("url 里有 pathParameter 没有设置，你必须先调用 addPathParam 为其设置！"); } if (urlParams != null) { - if (url.contains("?")) { - if (!url.endsWith("?")) { - url = url.trim(); - if (url.lastIndexOf("=") < url.lastIndexOf("?") + 2) { - throw new HttpException("url 格式错误，'？' 后没有发现 '='"); - } - if (!url.endsWith("&")) { - url += "&"; - } - } - } else { - url += "?"; - } - for (String name : urlParams.keySet()) { - url += name + "=" + urlParams.get(name) + "&"; - } - url = url.substring(0, url.length() - 1); + url = buildUrl(url.trim()); } return url; } + private String buildUrl(String url) { + StringBuilder sb = new StringBuilder(url); + if (url.contains("?")) { + if (!url.endsWith("?")) { + if (url.lastIndexOf("=") < url.lastIndexOf("?") + 2) { + throw new HttpException("url 格式错误，'？' 后没有发现 '='"); + } + if (!url.endsWith("&")) { + sb.append('&'); + } + } + } else { + sb.append('?'); + } + for (String name : urlParams.keySet()) { + sb.append(name).append('=').append(urlParams.get(name)).append('&'); + } + sb.delete(sb.length() - 1, sb.length()); + return sb.toString(); + } protected void assertNotConflict(boolean isGetRequest) { if (isGetRequest) { From 76ff2e19f24e0fce9c93551879141d8193a985c8 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?=E5=91=A8=E6=97=AD?= Date: Fri, 10 Apr 2020 15:52:25 +0800 Subject: [PATCH 095/924] V1.0.2 ^_^ --- README.md | 10 ++++++---- 1 file changed, 6 insertions(+), 4 deletions(-) diff --git a/README.md b/README.md index d4e29534..1270a5f8 100644 --- a/README.md +++ b/README.md @@ -18,7 +18,7 @@ > OkHttps 非常轻量，自身代码仅 2000 行左右，且有较高的编码质量，sonarqube 分析结果为 3A，[查看报告](https://gitee.com/ejlchina-zhxu/okhttps/quality_analyses?platform=sonar_qube) ### 前世：[HttpUtils, V2.3.0 之后重命名为 OkHttps](https://gitee.com/ejlchina-zhxu/httputils) -### 当前文档版本[1.0.1] +### 当前文档版本[1.0.2] ### API文档：[https://apidoc.gitee.com/ejlchina-zhxu/okhttps](https://apidoc.gitee.com/ejlchina-zhxu/okhttps) ## 目录 @@ -71,12 +71,12 @@ com.ejlchina okhttps - 1.0.1 + 1.0.2 ``` ### Gradle -`implementation 'com.ejlchina:okhttps:1.0.1'` +`implementation 'com.ejlchina:okhttps:1.0.2'` ## 使用说明 @@ -91,8 +91,10 @@ HTTP http = HTTP.builder().build(); * `async(String url)` 开始一个异步HTTP任务 * `sync(String url)` 开始一个同步HTTP任务 +* `async()` 开始一个异步HTTP任务，使用该方法必须在构建时设置 BaseUrl +* `sync()` 开始一个同步HTTP任务，使用该方法必须在构建时设置 BaseUrl * `cancel(String tag)` 根据标签批量取消HTTP任务 -* `cancelAll()` 取消所有任务（since v1.0.2） +* `cancelAll()` 取消所有任务 　　为了使用方便，在构建的时候，我们更愿意指定一个`BaseUrl`（请参见[5.1 设置 BaseUrl](#51-设置-baseurl)）: From cc6127c2aeb8a174f961ebcec42c1cd411839a3e Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?=E5=91=A8=E6=97=AD?= Date: Fri, 10 Apr 2020 16:14:46 +0800 Subject: [PATCH 096/924] V1.0.2 ^_^ --- README.md | 6 +++--- 1 file changed, 3 insertions(+), 3 deletions(-) diff --git a/README.md b/README.md index 1270a5f8..2d99971c 100644 --- a/README.md +++ b/README.md @@ -462,7 +462,7 @@ HTTP http = HTTP.builder() 　　全局回调监听与拦截器的异同: > * 拦截器可以添加多个，全局回调监听分三种，每种最多添加一个 > * 拦截器处的理时机在请求前和响应后，全局回调监听只在响应后，并且晚于拦截器 -> * 全局回调监听可以阻断（return false）某个请求的具体回调，而拦截器不能 +> * 全局回调监听可以 **阻断**（return false）某个请求的具体回调，而拦截器不能 #### 6.7 全局下载监听 @@ -750,7 +750,7 @@ try { 　　这种传统的异常处理方式，当然可以解决问题，但是 OkHttps 有更佳的方案： ```java -// 使用 nothrow 方法告诉 OkHttps 发生异常时不要直接向外抛出 +// 方法 nothrow() 让异常不直接抛出 HttpResult result = http.sync("/users/1").nothrow().get(); // 判断执行状态 switch (result.getState()) { @@ -766,7 +766,7 @@ switch (result.getState()) { break; } // 还可以获得具体的异常信息 -Exception error = result.getError(); +IOException error = result.getError(); ``` #### 10.2 异步请求的异常 From 741d214c654d93d2bd186df7d7d4f83d21ecbec9 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?=E5=91=A8=E6=97=AD?= <15735559897@qq.com> Date: Fri, 10 Apr 2020 23:35:08 +0800 Subject: [PATCH 097/924] =?UTF-8?q?=E6=B2=A1=E6=9C=89=E5=85=B3=E8=81=94=20?= =?UTF-8?q?httpTask=20=E7=9A=84=20HttpResult=20=E6=89=A7=E8=A1=8C=20Downlo?= =?UTF-8?q?ad=20=E7=9A=84=E6=97=B6=E5=80=99=20=E4=B8=8D=E8=B5=B0=20?= =?UTF-8?q?=E5=85=A8=E5=B1=80=E4=B8=8B=E8=BD=BD=E7=9B=91=E5=90=AC?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- .../okhttps/internal/TaskExecutor.java | 224 +++++++++--------- 1 file changed, 112 insertions(+), 112 deletions(-) diff --git a/src/main/java/com/ejlchina/okhttps/internal/TaskExecutor.java b/src/main/java/com/ejlchina/okhttps/internal/TaskExecutor.java index 66ed7a85..cb8c5d1c 100644 --- a/src/main/java/com/ejlchina/okhttps/internal/TaskExecutor.java +++ b/src/main/java/com/ejlchina/okhttps/internal/TaskExecutor.java @@ -1,112 +1,112 @@ -package com.ejlchina.okhttps.internal; - -import java.io.File; -import java.io.IOException; -import java.io.InputStream; -import java.util.concurrent.Executor; -import java.util.concurrent.ExecutorService; - -import com.ejlchina.okhttps.DownListener; -import com.ejlchina.okhttps.Download; -import com.ejlchina.okhttps.HttpResult; -import com.ejlchina.okhttps.HttpTask; -import com.ejlchina.okhttps.OnCallback; -import com.ejlchina.okhttps.TaskListener; -import com.ejlchina.okhttps.HttpResult.State; - -public class TaskExecutor { - - private Executor ioExecutor; - private Executor mainExecutor; - private DownListener downloadListener; - private TaskListener responseListener; - private TaskListener exceptionListener; - private TaskListener completeListener; - - public TaskExecutor(Executor ioExecutor, Executor mainExecutor, DownListener downloadListener, - TaskListener responseListener, TaskListener exceptionListener, - TaskListener completeListener) { - this.ioExecutor = ioExecutor; - this.mainExecutor = mainExecutor; - this.downloadListener = downloadListener; - this.responseListener = responseListener; - this.exceptionListener = exceptionListener; - this.completeListener = completeListener; - } - - public Executor getExecutor(boolean onIoThread) { - if (onIoThread || mainExecutor == null) { - return ioExecutor; - } - return mainExecutor; - } - - public Download download(HttpTask httpTask, File file, InputStream input, long skipBytes) { - Download download = new Download(file, input, this, skipBytes); - if (downloadListener != null) { - downloadListener.listen(httpTask, download); - } - return download; - } - - public void execute(Runnable command, boolean onIoThread) { - Executor executor = ioExecutor; - if (mainExecutor != null && !onIoThread) { - executor = mainExecutor; - } - executor.execute(command); - } - - public void executeOnResponse(HttpTask task, OnCallback onResponse, HttpResult result, boolean onIoThread) { - if (responseListener != null) { - execute(() -> { - if (responseListener.listen(task, result) && onResponse != null) { - onResponse.on(result); - } - }, onIoThread); - } else if (onResponse != null) { - execute(() -> { onResponse.on(result); }, onIoThread); - } - } - - public boolean executeOnException(HttpTask task, OnCallback onException, IOException error, boolean onIoThread) { - if (exceptionListener != null) { - execute(() -> { - if (exceptionListener.listen(task, error) && onException != null) { - onException.on(error); - } - }, onIoThread); - return true; - } else if (onException != null) { - execute(() -> { onException.on(error); }, onIoThread); - return true; - } - return false; - } - - public void executeOnComplete(HttpTask task, OnCallback onComplete, State state, boolean onIoThread) { - if (completeListener != null) { - execute(() -> { - if (completeListener.listen(task, state) && onComplete != null) { - onComplete.on(state); - } - }, onIoThread); - } else if (onComplete != null) { - execute(() -> { onComplete.on(state); }, onIoThread); - } - } - - /** - * 关闭线程池 - * @since OkHttps V1.0.2 - */ - public void shutdown() { - if (ioExecutor != null && ioExecutor instanceof ExecutorService) { - ((ExecutorService) ioExecutor).shutdown(); - } - if (mainExecutor != null && mainExecutor instanceof ExecutorService) { - ((ExecutorService) mainExecutor).shutdown(); - } - } - -} +package com.ejlchina.okhttps.internal; + +import java.io.File; +import java.io.IOException; +import java.io.InputStream; +import java.util.concurrent.Executor; +import java.util.concurrent.ExecutorService; + +import com.ejlchina.okhttps.DownListener; +import com.ejlchina.okhttps.Download; +import com.ejlchina.okhttps.HttpResult; +import com.ejlchina.okhttps.HttpTask; +import com.ejlchina.okhttps.OnCallback; +import com.ejlchina.okhttps.TaskListener; +import com.ejlchina.okhttps.HttpResult.State; + +public class TaskExecutor { + + private Executor ioExecutor; + private Executor mainExecutor; + private DownListener downloadListener; + private TaskListener responseListener; + private TaskListener exceptionListener; + private TaskListener completeListener; + + public TaskExecutor(Executor ioExecutor, Executor mainExecutor, DownListener downloadListener, + TaskListener responseListener, TaskListener exceptionListener, + TaskListener completeListener) { + this.ioExecutor = ioExecutor; + this.mainExecutor = mainExecutor; + this.downloadListener = downloadListener; + this.responseListener = responseListener; + this.exceptionListener = exceptionListener; + this.completeListener = completeListener; + } + + public Executor getExecutor(boolean onIoThread) { + if (onIoThread || mainExecutor == null) { + return ioExecutor; + } + return mainExecutor; + } + + public Download download(HttpTask httpTask, File file, InputStream input, long skipBytes) { + Download download = new Download(file, input, this, skipBytes); + if (httpTask != null && downloadListener != null) { + downloadListener.listen(httpTask, download); + } + return download; + } + + public void execute(Runnable command, boolean onIoThread) { + Executor executor = ioExecutor; + if (mainExecutor != null && !onIoThread) { + executor = mainExecutor; + } + executor.execute(command); + } + + public void executeOnResponse(HttpTask task, OnCallback onResponse, HttpResult result, boolean onIoThread) { + if (responseListener != null) { + execute(() -> { + if (responseListener.listen(task, result) && onResponse != null) { + onResponse.on(result); + } + }, onIoThread); + } else if (onResponse != null) { + execute(() -> { onResponse.on(result); }, onIoThread); + } + } + + public boolean executeOnException(HttpTask task, OnCallback onException, IOException error, boolean onIoThread) { + if (exceptionListener != null) { + execute(() -> { + if (exceptionListener.listen(task, error) && onException != null) { + onException.on(error); + } + }, onIoThread); + return true; + } else if (onException != null) { + execute(() -> { onException.on(error); }, onIoThread); + return true; + } + return false; + } + + public void executeOnComplete(HttpTask task, OnCallback onComplete, State state, boolean onIoThread) { + if (completeListener != null) { + execute(() -> { + if (completeListener.listen(task, state) && onComplete != null) { + onComplete.on(state); + } + }, onIoThread); + } else if (onComplete != null) { + execute(() -> { onComplete.on(state); }, onIoThread); + } + } + + /** + * 关闭线程池 + * @since OkHttps V1.0.2 + */ + public void shutdown() { + if (ioExecutor != null && ioExecutor instanceof ExecutorService) { + ((ExecutorService) ioExecutor).shutdown(); + } + if (mainExecutor != null && mainExecutor instanceof ExecutorService) { + ((ExecutorService) mainExecutor).shutdown(); + } + } + +} From d906c6d1bea9bf2052663dd80b68f6d7536ca5e4 Mon Sep 17 00:00:00 2001 From: zhxu_china <1573555987@qq.com> Date: Sat, 11 Apr 2020 12:01:39 +0800 Subject: [PATCH 098/924] =?UTF-8?q?!3=20=E6=9B=B4=E6=96=B0=E6=96=87?= =?UTF-8?q?=E6=A1=A3=20*=20Merge=20branch=20'master'=20of=20https://gitee.?= =?UTF-8?q?com/zhxu/okhttps.git=20*=20readme?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- README.md | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/README.md b/README.md index 2d99971c..21ae7bb1 100644 --- a/README.md +++ b/README.md @@ -747,7 +747,7 @@ try { // ... } ``` -　　这种传统的异常处理方式，当然可以解决问题，但是 OkHttps 有更佳的方案： +　　这种传统的异常处理方式，当然可以解决问题，但 OkHttps 有更佳的方案： ```java // 方法 nothrow() 让异常不直接抛出 From c0ca210c0714145236ba63bef7d853e00623b1af Mon Sep 17 00:00:00 2001 From: yejunxiang Date: Sat, 11 Apr 2020 16:22:57 +0800 Subject: [PATCH 099/924] =?UTF-8?q?!4=20=E4=BC=98=E5=8C=96HttpUtils?= =?UTF-8?q?=E5=B9=B6=E5=AE=8C=E5=96=84README=E6=96=87=E6=A1=A3=20*=20?= =?UTF-8?q?=E5=AE=8C=E5=96=84README=20*=20HttpUtils=E5=A2=9E=E5=8A=A0cance?= =?UTF-8?q?lAll()?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- README.md | 26 ++++++++++++------- .../java/com/ejlchina/okhttps/HttpUtils.java | 8 ++++++ 2 files changed, 24 insertions(+), 10 deletions(-) diff --git a/README.md b/README.md index 21ae7bb1..15d42ce6 100644 --- a/README.md +++ b/README.md @@ -89,12 +89,14 @@ HTTP http = HTTP.builder().build(); ``` 　　以上代码构建了一个最简单的`HTTP`实例，它拥有以下方法： -* `async(String url)` 开始一个异步HTTP任务 -* `sync(String url)` 开始一个同步HTTP任务 -* `async()` 开始一个异步HTTP任务，使用该方法必须在构建时设置 BaseUrl -* `sync()` 开始一个同步HTTP任务，使用该方法必须在构建时设置 BaseUrl -* `cancel(String tag)` 根据标签批量取消HTTP任务 -* `cancelAll()` 取消所有任务 +* `async(String url)` 开始一个异步请求 （内部通过一个`HTTP`单例实现） +* `async()` 开始一个异步HTTP任务，使用该方法必须在构建时设置 BaseUrl +* `sync(String url)` 开始一个同步请求 （内部通过一个`HTTP`单例实现） +* `sync()` 开始一个同步HTTP任务，使用该方法必须在构建时设置 BaseUrl +* `cancel(String tag)` 按标签取消请求（内部通过一个`HTTP`单例实现） +* `cancelAll()` 取消所有HTTP任务，包括同步和异步（内部通过一个`HTTP`单例实现） +* `request(Request request)` OkHttp 原生请求 （该请求不经过 预处理器） +* `webSocket(Request request, WebSocketListener listener)` WebSocket通讯 　　为了使用方便，在构建的时候，我们更愿意指定一个`BaseUrl`（请参见[5.1 设置 BaseUrl](#51-设置-baseurl)）: @@ -482,11 +484,15 @@ HTTP http = HTTP.builder() 　　类`HttpUtils`共定义了四个静态方法： -* `async(String url)` 开始一个异步请求 （内容通过一个`HTTP`单例实现） -* `sync(String url)` 开始一个同步请求 （内容通过一个`HTTP`单例实现） -* `cancel(String tag)` 按标签取消请求（内容通过一个`HTTP`单例实现） * `of(HTTP http)` 配置`HttpUtils`持有的`HTTP`实例（不调用此方法前默认使用一个没有没有经过任何配置的`HTTP`懒实例） - +* `async(String url)` 开始一个异步请求 （内部通过一个`HTTP`单例实现） +* `async()` 开始一个异步HTTP任务，使用该方法必须在构建时设置 BaseUrl +* `sync(String url)` 开始一个同步请求 （内部通过一个`HTTP`单例实现） +* `sync()` 开始一个同步HTTP任务，使用该方法必须在构建时设置 BaseUrl +* `cancel(String tag)` 按标签取消请求（内部通过一个`HTTP`单例实现） +* `cancelAll()` 取消所有HTTP任务，包括同步和异步（内部通过一个`HTTP`单例实现） +* `request(Request request)` OkHttp 原生请求 （该请求不经过 预处理器） +* `webSocket(Request request, WebSocketListener listener)` WebSocket通讯 　　也就是说，能使用`http`实例的地方，都可以使用`HttpUtils`类，例如： ```java diff --git a/src/main/java/com/ejlchina/okhttps/HttpUtils.java b/src/main/java/com/ejlchina/okhttps/HttpUtils.java index e2a8e0af..965ac96f 100644 --- a/src/main/java/com/ejlchina/okhttps/HttpUtils.java +++ b/src/main/java/com/ejlchina/okhttps/HttpUtils.java @@ -93,6 +93,14 @@ public static int cancel(String tag) { return getHttp().cancel(tag); } + /** + * @since 1.0.3 + * 取消所有HTTP任务，包括同步和异步 + */ + public void cancelAll() { + getHttp().cancelAll(); + } + /** * OkHttp 原生请求 （该请求不经过 预处理器） * @param request 请求 From 7d647757b795a8fc265866ed07be8d3cffd632ac Mon Sep 17 00:00:00 2001 From: Funny Date: Sat, 11 Apr 2020 16:39:31 +0800 Subject: [PATCH 100/924] =?UTF-8?q?!5=20=E6=9B=B4=E6=96=B0=20README:=20?= =?UTF-8?q?=E5=90=8E=E6=9C=9F=E5=BC=80=E5=8F=91=E8=AE=A1=E5=88=92=20*=20up?= =?UTF-8?q?date=20README.md.=20*=20update=20README.md.?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- README.md | 5 +++++ 1 file changed, 5 insertions(+) diff --git a/README.md b/README.md index 15d42ce6..1964fd0a 100644 --- a/README.md +++ b/README.md @@ -60,6 +60,7 @@ - [10.2 异步请求的异常](#102-异步请求的异常) + [11 回调线程自由切换（for Android）](#11-回调线程自由切换for-android) + [12 实现生命周期绑定（for Android）](#12-实现生命周期绑定for-android) ++ [后期计划（v1.1.0）](#后期计划v110) + [联系方式](#联系方式) + [参与贡献](#参与贡献) @@ -916,7 +917,11 @@ http.sync("/download/test.zip") 文档完善中，敬请期待... +## 后期计划（v1.1.0） +* 简化 WebSocket 编程：可直接发送 JavaBean 对象消息 +* 简化 WebSocket 编程：可直接接收 JavaBean 对象消息 +* 简化 WebSocket 编程：可使用 Lambda 表达式进行 WebSocket 编程 ## 联系方式 From b3cf9fb759c005d92e05b1bf40dfa840ec365fef Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?=E5=91=A8=E6=97=AD?= Date: Sat, 11 Apr 2020 19:01:53 +0800 Subject: [PATCH 101/924] =?UTF-8?q?=E7=BA=A6=E6=9D=9F=20HttpTask.setTag=20?= =?UTF-8?q?=E5=8F=AA=E8=83=BD=E8=B0=83=E7=94=A8=E4=B8=80=E6=AC=A1?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- src/main/java/com/ejlchina/okhttps/HttpTask.java | 4 ++++ 1 file changed, 4 insertions(+) diff --git a/src/main/java/com/ejlchina/okhttps/HttpTask.java b/src/main/java/com/ejlchina/okhttps/HttpTask.java index 59b57d93..ac7cadca 100644 --- a/src/main/java/com/ejlchina/okhttps/HttpTask.java +++ b/src/main/java/com/ejlchina/okhttps/HttpTask.java @@ -116,6 +116,10 @@ public C nothrow() { * @return HttpTask 实例 */ public C setTag(String tag) { + if (this.tag != null) { + // 标签可动态修改会带来许多不可控的问题 + throw new IllegalStateException("该任务的标签已经存在，不可以在更改！"); + } this.tag = tag; return (C) this; } From bdbfa126e33099ae1599b57eff48c7a6991108dc Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?=E5=91=A8=E6=97=AD?= Date: Sat, 11 Apr 2020 19:05:28 +0800 Subject: [PATCH 102/924] =?UTF-8?q?fix=20bug:=20=E5=BC=82=E6=AD=A5?= =?UTF-8?q?=E8=AF=B7=E6=B1=82=E6=97=B6=EF=BC=8C=E5=A6=82=E6=9E=9C=E5=8F=91?= =?UTF-8?q?=E7=94=9F=E5=BC=82=E5=B8=B8=E4=B8=8D=E6=8D=95=E8=8E=B7=E5=A4=84?= =?UTF-8?q?=E7=90=86=EF=BC=8C=E5=88=99=E6=A0=87=E7=AD=BE=E4=BB=BB=E5=8A=A1?= =?UTF-8?q?=E4=B8=80=E7=9B=B4=E4=B8=8D=E4=BC=9A=E5=89=94=E9=99=A4=E9=97=AE?= =?UTF-8?q?=E9=A2=98?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- .../java/com/ejlchina/okhttps/internal/AsyncHttpTask.java | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/src/main/java/com/ejlchina/okhttps/internal/AsyncHttpTask.java b/src/main/java/com/ejlchina/okhttps/internal/AsyncHttpTask.java index 49be51ff..d574bac1 100644 --- a/src/main/java/com/ejlchina/okhttps/internal/AsyncHttpTask.java +++ b/src/main/java/com/ejlchina/okhttps/internal/AsyncHttpTask.java @@ -243,13 +243,13 @@ public void onFailure(Call call, IOException error) { if (state == State.CANCELED) { httpCall.setResult(new RealHttpResult(AsyncHttpTask.this, state)); } else { + httpCall.setResult(new RealHttpResult(AsyncHttpTask.this, state, error)); TaskExecutor executor = httpClient.getExecutor(); executor.executeOnComplete(AsyncHttpTask.this, onComplete, state, cOnIO); if (!executor.executeOnException(AsyncHttpTask.this, onException, error, eOnIO) && !nothrow) { throw new HttpException(error.getMessage(), error); } - httpCall.setResult(new RealHttpResult(AsyncHttpTask.this, state, error)); } } @@ -257,9 +257,9 @@ public void onFailure(Call call, IOException error) { public void onResponse(Call call, Response response) throws IOException { TaskExecutor executor = httpClient.getExecutor(); HttpResult result = new RealHttpResult(AsyncHttpTask.this, response, executor); + httpCall.setResult(result); executor.executeOnComplete(AsyncHttpTask.this, onComplete, State.RESPONSED, cOnIO); executor.executeOnResponse(AsyncHttpTask.this, onResponse, result, rOnIO); - httpCall.setResult(result); } }); From 2f37c7dbc80b179399a0ba86ca1d799685264235 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?=E5=91=A8=E6=97=AD?= Date: Sat, 11 Apr 2020 19:18:42 +0800 Subject: [PATCH 103/924] exception message --- src/main/java/com/ejlchina/okhttps/HttpTask.java | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/src/main/java/com/ejlchina/okhttps/HttpTask.java b/src/main/java/com/ejlchina/okhttps/HttpTask.java index ac7cadca..944540f8 100644 --- a/src/main/java/com/ejlchina/okhttps/HttpTask.java +++ b/src/main/java/com/ejlchina/okhttps/HttpTask.java @@ -118,7 +118,7 @@ public C nothrow() { public C setTag(String tag) { if (this.tag != null) { // 标签可动态修改会带来许多不可控的问题 - throw new IllegalStateException("该任务的标签已经存在，不可以在更改！"); + throw new IllegalStateException("the task's tag already exists, canot modify again!"); } this.tag = tag; return (C) this; From d434e0d912bdd0ca1e8eb2191a0703376a09c953 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?=E5=91=A8=E6=97=AD?= Date: Sat, 11 Apr 2020 19:21:33 +0800 Subject: [PATCH 104/924] exception message --- src/main/java/com/ejlchina/okhttps/HttpTask.java | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/src/main/java/com/ejlchina/okhttps/HttpTask.java b/src/main/java/com/ejlchina/okhttps/HttpTask.java index 944540f8..447913ec 100644 --- a/src/main/java/com/ejlchina/okhttps/HttpTask.java +++ b/src/main/java/com/ejlchina/okhttps/HttpTask.java @@ -118,7 +118,7 @@ public C nothrow() { public C setTag(String tag) { if (this.tag != null) { // 标签可动态修改会带来许多不可控的问题 - throw new IllegalStateException("the task's tag already exists, canot modify again!"); + throw new IllegalStateException("the tag[" + this.tag + "] of task[" + urlPath + "] already exists, canot modify again!"); } this.tag = tag; return (C) this; From ef622d77a218fc376574d90e86ea7c8322ba1745 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?=E5=91=A8=E6=97=AD?= Date: Sat, 11 Apr 2020 19:38:02 +0800 Subject: [PATCH 105/924] V_1.0.3 ^_^ --- src/test/java/com/ejlchina/test/TagTests.java | 41 +++++++++++++++++++ 1 file changed, 41 insertions(+) create mode 100644 src/test/java/com/ejlchina/test/TagTests.java diff --git a/src/test/java/com/ejlchina/test/TagTests.java b/src/test/java/com/ejlchina/test/TagTests.java new file mode 100644 index 00000000..f2c9f8f3 --- /dev/null +++ b/src/test/java/com/ejlchina/test/TagTests.java @@ -0,0 +1,41 @@ +package com.ejlchina.test; + +import com.ejlchina.okhttps.HTTP; +import com.ejlchina.okhttps.HttpResult; +import com.ejlchina.okhttps.internal.HttpClient; +import okhttp3.OkHttpClient; +import org.junit.Test; + +import java.util.concurrent.TimeUnit; + +public class TagTests extends BaseTest { + + @Test + public void testTag() { + HttpClient http = (HttpClient) HTTP.builder() + .config((OkHttpClient.Builder builder) -> { + builder.connectTimeout(1, TimeUnit.SECONDS); + builder.writeTimeout(1, TimeUnit.SECONDS); + builder.readTimeout(1, TimeUnit.SECONDS); + }) + .build(); + + http.async("http://www.baidu.com") + .setTag("AA") + .setOnResponse((HttpResult result) -> { + throw new RuntimeException("我是一个异常"); + }) + .get(); + + println("taskCount = " + http.getTagTaskCount()); + sleep(1000); + println("taskCount = " + http.getTagTaskCount()); + sleep(1000); + println("taskCount = " + http.getTagTaskCount()); + sleep(5000); + println("taskCount = " + http.getTagTaskCount()); + + } + + +} From f2b497629c87d978683ed0f17770ab6849511d34 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?=E5=91=A8=E6=97=AD?= Date: Sat, 11 Apr 2020 20:06:44 +0800 Subject: [PATCH 106/924] =?UTF-8?q?Tag=20=E5=8F=AF=E4=BB=A5=E5=8A=A8?= =?UTF-8?q?=E6=80=81=E4=BF=AE=E6=94=B9=EF=BC=8C=E5=8F=AA=E6=98=AF=E4=B8=8D?= =?UTF-8?q?=E5=8F=AF=E4=BB=A5=E4=BF=AE=E6=94=B9=E4=B8=BA=20null?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- src/main/java/com/ejlchina/okhttps/HttpTask.java | 6 ++---- 1 file changed, 2 insertions(+), 4 deletions(-) diff --git a/src/main/java/com/ejlchina/okhttps/HttpTask.java b/src/main/java/com/ejlchina/okhttps/HttpTask.java index 447913ec..82e44717 100644 --- a/src/main/java/com/ejlchina/okhttps/HttpTask.java +++ b/src/main/java/com/ejlchina/okhttps/HttpTask.java @@ -116,11 +116,9 @@ public C nothrow() { * @return HttpTask 实例 */ public C setTag(String tag) { - if (this.tag != null) { - // 标签可动态修改会带来许多不可控的问题 - throw new IllegalStateException("the tag[" + this.tag + "] of task[" + urlPath + "] already exists, canot modify again!"); + if (tag != null) { + this.tag = tag; } - this.tag = tag; return (C) this; } From 10c4bab9e5b11d5fee75be72c6b34ec8096d5275 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?=E5=91=A8=E6=97=AD?= Date: Sat, 11 Apr 2020 20:47:58 +0800 Subject: [PATCH 107/924] =?UTF-8?q?=E4=BF=AE=E5=A4=8D=E5=90=8C=E6=AD=A5?= =?UTF-8?q?=E8=AF=B7=E6=B1=82=E6=B7=BB=E5=8A=A0=E6=A0=87=E7=AD=BE=E6=97=B6?= =?UTF-8?q?=20tagTask=20=E6=B2=A1=E6=9C=89=E7=A7=BB=E9=99=A4=E9=97=AE?= =?UTF-8?q?=E9=A2=98?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- .../okhttps/internal/SyncHttpTask.java | 69 ++++++++++--------- 1 file changed, 37 insertions(+), 32 deletions(-) diff --git a/src/main/java/com/ejlchina/okhttps/internal/SyncHttpTask.java b/src/main/java/com/ejlchina/okhttps/internal/SyncHttpTask.java index 4c3696dc..bc80b721 100644 --- a/src/main/java/com/ejlchina/okhttps/internal/SyncHttpTask.java +++ b/src/main/java/com/ejlchina/okhttps/internal/SyncHttpTask.java @@ -1,6 +1,7 @@ package com.ejlchina.okhttps.internal; import java.io.IOException; +import java.util.concurrent.CountDownLatch; import com.ejlchina.okhttps.Cancelable; import com.ejlchina.okhttps.HttpResult; @@ -57,19 +58,23 @@ public HttpResult delete() { static class SyncCall implements Cancelable { - final Call call; + private Call call; boolean done = false; + boolean canceled = false; - public SyncCall(Call call) { + public void setCall(Call call) { this.call = call; } @Override - public boolean cancel() { + public synchronized boolean cancel() { if (done) { return false; } - call.cancel(); + if (call != null) { + call.cancel(); + } + canceled = true; return true; } @@ -81,39 +86,39 @@ public void setDone(boolean done) { private HttpResult request(String method) { RealHttpResult result = new RealHttpResult(this, httpClient.getExecutor()); + SyncCall syncCall = new SyncCall(); + if (tag != null) { + httpClient.addTagTask(tag, syncCall, this); + } + CountDownLatch latch = new CountDownLatch(1); httpClient.preprocess(this, () -> { - Call call = prepareCall(method); - SyncCall syncCall = null; - if (tag != null) { - syncCall = new SyncCall(call); - httpClient.addTagTask(tag, syncCall, this); + synchronized (syncCall) { + if (syncCall.canceled) { + result.exception(State.CANCELED, null); + latch.countDown(); + return; + } + syncCall.setCall(prepareCall(method)); } try { - Response response = call.execute(); - if (syncCall != null) { - syncCall.setDone(true); - } - synchronized (SyncHttpTask.this) { - result.response(response); - SyncHttpTask.this.notify(); - } + result.response(syncCall.call.execute()); + syncCall.setDone(true); } catch (IOException e) { - State state = toState(e, true); - synchronized (SyncHttpTask.this) { - result.exception(state, e); - SyncHttpTask.this.notify(); - } - } + result.exception(toState(e, true), e); + } finally { + latch.countDown(); + } }); - synchronized (this) { - if (result.getState() == null) { - try { - SyncHttpTask.this.wait(); - } catch (InterruptedException e) { - throw new HttpException("等待异常", e); - } - } - } + if (result.getState() == null) { + try { + latch.await(); + } catch (InterruptedException e) { + throw new HttpException("等待异常", e); + } + } + if (tag != null) { + httpClient.removeTagTask(this); + } IOException e = result.getError(); if (e != null && result.getState() != State.CANCELED && !nothrow) { From e6de40da124083e370bed615afe5b6bc44a8399b Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?=E5=91=A8=E6=97=AD?= Date: Sat, 11 Apr 2020 20:49:09 +0800 Subject: [PATCH 108/924] =?UTF-8?q?=E4=BC=98=E5=8C=96=EF=BC=9A=E5=BD=93?= =?UTF-8?q?=E8=AF=B7=E6=B1=82=E4=BB=BB=E5=8A=A1=E5=A4=84=E4=BA=8E=E9=A2=84?= =?UTF-8?q?=E5=A4=84=E7=90=86=E6=9C=9F=E9=97=B4=EF=BC=8C=E4=B9=9F=E5=8F=AF?= =?UTF-8?q?=E4=BB=A5=E8=A2=AB=E6=8C=89=E6=A0=87=E7=AD=BE=E5=8F=96=E6=B6=88?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- .../java/com/ejlchina/okhttps/internal/AsyncHttpTask.java | 6 +++--- .../java/com/ejlchina/okhttps/internal/RealHttpResult.java | 3 +-- 2 files changed, 4 insertions(+), 5 deletions(-) diff --git a/src/main/java/com/ejlchina/okhttps/internal/AsyncHttpTask.java b/src/main/java/com/ejlchina/okhttps/internal/AsyncHttpTask.java index d574bac1..7d8fe373 100644 --- a/src/main/java/com/ejlchina/okhttps/internal/AsyncHttpTask.java +++ b/src/main/java/com/ejlchina/okhttps/internal/AsyncHttpTask.java @@ -105,6 +105,9 @@ public HttpCall delete() { private HttpCall request(String method) { PreHttpCall call = new PreHttpCall(); + if (tag != null) { + httpClient.addTagTask(tag, call, this); + } httpClient.preprocess(this, () -> { synchronized (call) { if (!call.isCanceled()) { @@ -112,9 +115,6 @@ private HttpCall request(String method) { } } }); - if (tag != null) { - httpClient.addTagTask(tag, call, this); - } return call; } diff --git a/src/main/java/com/ejlchina/okhttps/internal/RealHttpResult.java b/src/main/java/com/ejlchina/okhttps/internal/RealHttpResult.java index f6eab345..15c27ab2 100644 --- a/src/main/java/com/ejlchina/okhttps/internal/RealHttpResult.java +++ b/src/main/java/com/ejlchina/okhttps/internal/RealHttpResult.java @@ -39,8 +39,7 @@ public RealHttpResult(HttpTask httpTask, State state, IOException error) { this.httpTask = httpTask; exception(state, error); } - - + public void exception(State state, IOException error) { this.state = state; this.error = error; From 4d2b8d5453e9f0700dea7fe3dba5c5f70af059df Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?=E5=91=A8=E6=97=AD?= Date: Sat, 11 Apr 2020 21:10:29 +0800 Subject: [PATCH 109/924] =?UTF-8?q?=E4=BC=98=E5=8C=96=EF=BC=9A=E5=BC=82?= =?UTF-8?q?=E6=AD=A5=E8=AF=B7=E6=B1=82=E6=A0=87=E7=AD=BE=E4=BB=BB=E5=8A=A1?= =?UTF-8?q?=E9=80=BB=E8=BE=91?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- .../okhttps/internal/AsyncHttpTask.java | 37 ++++++------------- 1 file changed, 11 insertions(+), 26 deletions(-) diff --git a/src/main/java/com/ejlchina/okhttps/internal/AsyncHttpTask.java b/src/main/java/com/ejlchina/okhttps/internal/AsyncHttpTask.java index 7d8fe373..a65cc445 100644 --- a/src/main/java/com/ejlchina/okhttps/internal/AsyncHttpTask.java +++ b/src/main/java/com/ejlchina/okhttps/internal/AsyncHttpTask.java @@ -105,14 +105,14 @@ public HttpCall delete() { private HttpCall request(String method) { PreHttpCall call = new PreHttpCall(); - if (tag != null) { - httpClient.addTagTask(tag, call, this); - } + registeTagTask(call); httpClient.preprocess(this, () -> { synchronized (call) { - if (!call.isCanceled()) { - call.setCall(executeCall(prepareCall(method))); - } + if (call.isCanceled()) { + removeTagTask(); + } else { + call.setCall(executeCall(prepareCall(method))); + } } }); return call; @@ -125,20 +125,10 @@ class PreHttpCall implements HttpCall { private HttpCall call; @Override - public boolean cancel() { - boolean res = true; - synchronized (this) { - if (call != null) { - res = call.cancel(); - } else { - canceled = true; - } - notify(); - } - if (tag != null && call == null) { - httpClient.removeTagTask(AsyncHttpTask.this); - } - return res; + public synchronized boolean cancel() { + canceled = call == null || call.cancel(); + notify(); + return canceled; } @Override @@ -151,9 +141,6 @@ public boolean isDone() { @Override public boolean isCanceled() { - if (call != null) { - return call.isCanceled(); - } return canceled; } @@ -227,9 +214,7 @@ public void setResult(HttpResult result) { this.result = result; notify(); } - if (tag != null) { - httpClient.removeTagTask(AsyncHttpTask.this); - } + removeTagTask(); } } From 022d3126fa50bd76d9a528f4ed2645d2baa8c3af Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?=E5=91=A8=E6=97=AD?= Date: Sat, 11 Apr 2020 21:11:38 +0800 Subject: [PATCH 110/924] =?UTF-8?q?=E4=BC=98=E5=8C=96=EF=BC=9A=E5=BC=82?= =?UTF-8?q?=E6=AD=A5=E8=AF=B7=E6=B1=82=E6=A0=87=E7=AD=BE=E4=BB=BB=E5=8A=A1?= =?UTF-8?q?=E9=80=BB=E8=BE=91?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- src/main/java/com/ejlchina/okhttps/HttpTask.java | 12 ++++++++++++ 1 file changed, 12 insertions(+) diff --git a/src/main/java/com/ejlchina/okhttps/HttpTask.java b/src/main/java/com/ejlchina/okhttps/HttpTask.java index 82e44717..51443ac8 100644 --- a/src/main/java/com/ejlchina/okhttps/HttpTask.java +++ b/src/main/java/com/ejlchina/okhttps/HttpTask.java @@ -497,6 +497,18 @@ static class FilePara { } + protected void registeTagTask(Cancelable canceler) { + if (tag != null) { + httpClient.addTagTask(tag, canceler, this); + } + } + + protected void removeTagTask() { + if (tag != null) { + httpClient.removeTagTask(this); + } + } + protected Call prepareCall(String method) { assertNotConflict("GET".equals(method)); Request.Builder builder = new Request.Builder() From 4001ce5af28c0e8d834e12886748e0e3ce520ed7 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?=E5=91=A8=E6=97=AD?= Date: Sat, 11 Apr 2020 21:52:00 +0800 Subject: [PATCH 111/924] =?UTF-8?q?=E4=BD=BF=E7=94=A8=20CountDownLatch=20?= =?UTF-8?q?=E7=AE=80=E5=8C=96=E5=90=8C=E6=AD=A5=E4=BB=A3=E7=A0=81?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- .../java/com/ejlchina/okhttps/HttpTask.java | 13 +++++- .../okhttps/internal/AsyncHttpTask.java | 44 +++++++------------ .../okhttps/internal/SyncHttpTask.java | 19 +++----- 3 files changed, 34 insertions(+), 42 deletions(-) diff --git a/src/main/java/com/ejlchina/okhttps/HttpTask.java b/src/main/java/com/ejlchina/okhttps/HttpTask.java index 51443ac8..24b926a5 100644 --- a/src/main/java/com/ejlchina/okhttps/HttpTask.java +++ b/src/main/java/com/ejlchina/okhttps/HttpTask.java @@ -18,6 +18,8 @@ import java.net.UnknownHostException; import java.util.HashMap; import java.util.Map; +import java.util.concurrent.CountDownLatch; +import java.util.concurrent.TimeUnit; /** @@ -31,10 +33,10 @@ public abstract class HttpTask> { protected HttpClient httpClient; protected boolean nothrow; - protected String tag; protected boolean nextOnIO = false; private String urlPath; + private String tag; private Map headers; private Map pathParams; private Map urlParams; @@ -700,4 +702,13 @@ protected void assertNotConflict(boolean isGetRequest) { } } + protected void timeoutAwait(CountDownLatch latch) { + try { + latch.await(httpClient.totalTimeoutMillis() * 10, + TimeUnit.MILLISECONDS); + } catch (InterruptedException e) { + throw new HttpException("超时", e); + } + } + } diff --git a/src/main/java/com/ejlchina/okhttps/internal/AsyncHttpTask.java b/src/main/java/com/ejlchina/okhttps/internal/AsyncHttpTask.java index a65cc445..9fa9a686 100644 --- a/src/main/java/com/ejlchina/okhttps/internal/AsyncHttpTask.java +++ b/src/main/java/com/ejlchina/okhttps/internal/AsyncHttpTask.java @@ -1,6 +1,7 @@ package com.ejlchina.okhttps.internal; import java.io.IOException; +import java.util.concurrent.CountDownLatch; import com.ejlchina.okhttps.HttpCall; import com.ejlchina.okhttps.HttpResult; @@ -108,7 +109,7 @@ private HttpCall request(String method) { registeTagTask(call); httpClient.preprocess(this, () -> { synchronized (call) { - if (call.isCanceled()) { + if (call.canceled) { removeTagTask(); } else { call.setCall(executeCall(prepareCall(method))); @@ -123,11 +124,12 @@ class PreHttpCall implements HttpCall { private boolean canceled = false; private HttpCall call; - + final CountDownLatch latch = new CountDownLatch(1); + @Override public synchronized boolean cancel() { canceled = call == null || call.cancel(); - notify(); + latch.countDown(); return canceled; } @@ -146,33 +148,25 @@ public boolean isCanceled() { public void setCall(HttpCall call) { this.call = call; - notify(); + latch.countDown(); } @Override - public synchronized HttpResult getResult() { - if (canceled) { + public HttpResult getResult() { + timeoutAwait(latch); + if (canceled || call == null) { return new RealHttpResult(AsyncHttpTask.this, State.CANCELED); } - if (call == null) { - try { - wait(httpClient.totalTimeoutMillis() * 10); - } catch (InterruptedException e) { - throw new HttpException(e.getMessage(), e); - } - } - if (call != null) { - return call.getResult(); - } - return new RealHttpResult(AsyncHttpTask.this, State.CANCELED); + return call.getResult(); } } - + class OkHttpCall implements HttpCall { private Call call; private HttpResult result; + final CountDownLatch latch = new CountDownLatch(1); public OkHttpCall(Call call) { this.call = call; @@ -198,22 +192,16 @@ public boolean isCanceled() { } @Override - public synchronized HttpResult getResult() { + public HttpResult getResult() { if (result == null) { - try { - wait(httpClient.totalTimeoutMillis() * 10); - } catch (InterruptedException e) { - throw new HttpException(e.getMessage(), e); - } + timeoutAwait(latch); } return result; } public void setResult(HttpResult result) { - synchronized (this) { - this.result = result; - notify(); - } + this.result = result; + latch.countDown(); removeTagTask(); } diff --git a/src/main/java/com/ejlchina/okhttps/internal/SyncHttpTask.java b/src/main/java/com/ejlchina/okhttps/internal/SyncHttpTask.java index bc80b721..69de2342 100644 --- a/src/main/java/com/ejlchina/okhttps/internal/SyncHttpTask.java +++ b/src/main/java/com/ejlchina/okhttps/internal/SyncHttpTask.java @@ -9,7 +9,6 @@ import com.ejlchina.okhttps.HttpResult.State; import okhttp3.Call; -import okhttp3.Response; /** @@ -87,9 +86,8 @@ public void setDone(boolean done) { private HttpResult request(String method) { RealHttpResult result = new RealHttpResult(this, httpClient.getExecutor()); SyncCall syncCall = new SyncCall(); - if (tag != null) { - httpClient.addTagTask(tag, syncCall, this); - } + // 注册标签任务 + registeTagTask(syncCall); CountDownLatch latch = new CountDownLatch(1); httpClient.preprocess(this, () -> { synchronized (syncCall) { @@ -110,19 +108,14 @@ private HttpResult request(String method) { } }); if (result.getState() == null) { - try { - latch.await(); - } catch (InterruptedException e) { - throw new HttpException("等待异常", e); - } - } - if (tag != null) { - httpClient.removeTagTask(this); + timeoutAwait(latch); } + // 移除标签任务 + removeTagTask(); IOException e = result.getError(); if (e != null && result.getState() != State.CANCELED && !nothrow) { - throw new HttpException("请求执行异常", e); + throw new HttpException("执行异常", e); } return result; } From 2122183f5d7e9ed5a88e73ab4172874f8e5f23b4 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?=E5=91=A8=E6=97=AD?= Date: Sat, 11 Apr 2020 22:59:57 +0800 Subject: [PATCH 112/924] =?UTF-8?q?=E4=BC=98=E5=8C=96=E4=BB=A3=E7=A0=81?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- .../java/com/ejlchina/okhttps/HttpCall.java | 10 +--- .../okhttps/internal/AsyncHttpTask.java | 58 +++++++++++-------- .../okhttps/internal/HttpException.java | 13 +++++ .../okhttps/internal/SyncHttpTask.java | 5 +- 4 files changed, 51 insertions(+), 35 deletions(-) diff --git a/src/main/java/com/ejlchina/okhttps/HttpCall.java b/src/main/java/com/ejlchina/okhttps/HttpCall.java index a7543a7b..11df025a 100644 --- a/src/main/java/com/ejlchina/okhttps/HttpCall.java +++ b/src/main/java/com/ejlchina/okhttps/HttpCall.java @@ -3,16 +3,10 @@ public interface HttpCall extends Cancelable { /** - * 取消 Http 请求 - * @return 是否取消成功 - */ - boolean cancel(); - - /** - * @return 请求是否被取消 + * @return 是否被取消 */ boolean isCanceled(); - + /** * @return 请求是否执行完成，包含取消和失败 */ diff --git a/src/main/java/com/ejlchina/okhttps/internal/AsyncHttpTask.java b/src/main/java/com/ejlchina/okhttps/internal/AsyncHttpTask.java index 9fa9a686..7801409b 100644 --- a/src/main/java/com/ejlchina/okhttps/internal/AsyncHttpTask.java +++ b/src/main/java/com/ejlchina/okhttps/internal/AsyncHttpTask.java @@ -3,10 +3,7 @@ import java.io.IOException; import java.util.concurrent.CountDownLatch; -import com.ejlchina.okhttps.HttpCall; -import com.ejlchina.okhttps.HttpResult; -import com.ejlchina.okhttps.HttpTask; -import com.ejlchina.okhttps.OnCallback; +import com.ejlchina.okhttps.*; import com.ejlchina.okhttps.HttpResult.State; import okhttp3.Call; @@ -164,16 +161,16 @@ public HttpResult getResult() { class OkHttpCall implements HttpCall { - private Call call; - private HttpResult result; + final Call call; final CountDownLatch latch = new CountDownLatch(1); + private HttpResult result; public OkHttpCall(Call call) { this.call = call; } @Override - public boolean cancel() { + public synchronized boolean cancel() { if (result == null) { call.cancel(); return true; @@ -202,7 +199,6 @@ public HttpResult getResult() { public void setResult(HttpResult result) { this.result = result; latch.countDown(); - removeTagTask(); } } @@ -212,31 +208,43 @@ private HttpCall executeCall(Call call) { call.enqueue(new Callback() { @Override public void onFailure(Call call, IOException error) { - State state = toState(error, false); - if (state == State.CANCELED) { - httpCall.setResult(new RealHttpResult(AsyncHttpTask.this, state)); - } else { - httpCall.setResult(new RealHttpResult(AsyncHttpTask.this, state, error)); - TaskExecutor executor = httpClient.getExecutor(); - executor.executeOnComplete(AsyncHttpTask.this, onComplete, state, cOnIO); - if (!executor.executeOnException(AsyncHttpTask.this, onException, error, eOnIO) - && !nothrow) { - throw new HttpException(error.getMessage(), error); - } - } + State state = toState(error, false); + HttpResult result = new RealHttpResult(AsyncHttpTask.this, state, error); + doCallback(httpCall, result, () -> { + TaskExecutor executor = httpClient.getExecutor(); + executor.executeOnComplete(AsyncHttpTask.this, onComplete, state, cOnIO); + if (!executor.executeOnException(AsyncHttpTask.this, onException, error, eOnIO) + && !nothrow) { + throw new HttpException(state, error.getMessage(), error); + } + }); } @Override public void onResponse(Call call, Response response) throws IOException { TaskExecutor executor = httpClient.getExecutor(); - HttpResult result = new RealHttpResult(AsyncHttpTask.this, response, executor); - httpCall.setResult(result); - executor.executeOnComplete(AsyncHttpTask.this, onComplete, State.RESPONSED, cOnIO); - executor.executeOnResponse(AsyncHttpTask.this, onResponse, result, rOnIO); + HttpResult result = new RealHttpResult(AsyncHttpTask.this, response, executor); + doCallback(httpCall, result, () -> { + executor.executeOnComplete(AsyncHttpTask.this, onComplete, State.RESPONSED, cOnIO); + executor.executeOnResponse(AsyncHttpTask.this, onResponse, result, rOnIO); + }); } - + }); return httpCall; } + private void doCallback(OkHttpCall httpCall, HttpResult result, Runnable runnable) { + //noinspection SynchronizationOnLocalVariableOrMethodParameter + synchronized (httpCall) { + removeTagTask(); + if (httpCall.isCanceled() || result.getState() == State.CANCELED) { + httpCall.setResult(new RealHttpResult(AsyncHttpTask.this, State.CANCELED)); + return; + } + httpCall.setResult(result); + runnable.run(); + } + } + } diff --git a/src/main/java/com/ejlchina/okhttps/internal/HttpException.java b/src/main/java/com/ejlchina/okhttps/internal/HttpException.java index c2bf3f37..f7a8a0d6 100644 --- a/src/main/java/com/ejlchina/okhttps/internal/HttpException.java +++ b/src/main/java/com/ejlchina/okhttps/internal/HttpException.java @@ -1,5 +1,7 @@ package com.ejlchina.okhttps.internal; +import com.ejlchina.okhttps.HttpResult; + /** * Created by 周旭（Troy.Zhou） on 2016/8/30. */ @@ -10,6 +12,8 @@ public class HttpException extends RuntimeException { */ private static final long serialVersionUID = 8223484833265657324L; + private HttpResult.State state; + public HttpException(String detailMessage) { super(detailMessage); } @@ -18,4 +22,13 @@ public HttpException(String detailMessage, Throwable throwable) { super(detailMessage, throwable); } + public HttpException(HttpResult.State state, String detailMessage, Throwable throwable) { + super(detailMessage, throwable); + this.state = state; + } + + public HttpResult.State getState() { + return state; + } + } diff --git a/src/main/java/com/ejlchina/okhttps/internal/SyncHttpTask.java b/src/main/java/com/ejlchina/okhttps/internal/SyncHttpTask.java index 69de2342..8e5b5053 100644 --- a/src/main/java/com/ejlchina/okhttps/internal/SyncHttpTask.java +++ b/src/main/java/com/ejlchina/okhttps/internal/SyncHttpTask.java @@ -113,9 +113,10 @@ private HttpResult request(String method) { // 移除标签任务 removeTagTask(); IOException e = result.getError(); - if (e != null && result.getState() != State.CANCELED + State state = result.getState(); + if (e != null && state != State.CANCELED && !nothrow) { - throw new HttpException("执行异常", e); + throw new HttpException(state, "执行异常", e); } return result; } From ee9b36c5500288d1e1adc5be40a717b931b53054 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?=E5=91=A8=E6=97=AD?= Date: Sat, 11 Apr 2020 23:15:29 +0800 Subject: [PATCH 113/924] =?UTF-8?q?=E6=A0=87=E7=AD=BE=E4=BB=BB=E5=8A=A1?= =?UTF-8?q?=E9=98=9F=E5=88=97=E6=96=B0=E5=A2=9E=E8=BF=87=E6=9C=9F=E6=B8=85?= =?UTF-8?q?=E7=90=86=E6=9C=BA=E5=88=B6?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- .../ejlchina/okhttps/internal/HttpClient.java | 16 ++++++++++++++-- 1 file changed, 14 insertions(+), 2 deletions(-) diff --git a/src/main/java/com/ejlchina/okhttps/internal/HttpClient.java b/src/main/java/com/ejlchina/okhttps/internal/HttpClient.java index 6de2ac77..4f0998dd 100644 --- a/src/main/java/com/ejlchina/okhttps/internal/HttpClient.java +++ b/src/main/java/com/ejlchina/okhttps/internal/HttpClient.java @@ -72,6 +72,8 @@ public int cancel(String tag) { count++; } it.remove(); + } else if (tagCall.isExpired()) { + it.remove(); } } return count; @@ -116,19 +118,29 @@ public void removeTagTask(HttpTask task) { it.remove(); break; } + if (tagCall.isExpired()) { + it.remove(); + } } } - static class TagTask { + class TagTask { String tag; Cancelable canceler; HttpTask task; + long createAt; - public TagTask(String tag, Cancelable canceler, HttpTask task) { + TagTask(String tag, Cancelable canceler, HttpTask task) { this.tag = tag; this.canceler = canceler; this.task = task; + this.createAt = System.nanoTime(); + } + + boolean isExpired() { + // 生存时间大于10倍的总超时限值 + return System.nanoTime() - createAt > 10_000_000 * totalTimeoutMillis(); } } From 3873c418e34c24e0ff76b9b1e441f455586c6609 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?=E5=91=A8=E6=97=AD?= Date: Sat, 11 Apr 2020 23:24:08 +0800 Subject: [PATCH 114/924] =?UTF-8?q?=E4=BC=98=E5=8C=96=E4=BB=A3=E7=A0=81?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- .../okhttps/internal/AsyncHttpTask.java | 26 +++++++++---------- .../okhttps/internal/SyncHttpTask.java | 14 +++------- 2 files changed, 16 insertions(+), 24 deletions(-) diff --git a/src/main/java/com/ejlchina/okhttps/internal/AsyncHttpTask.java b/src/main/java/com/ejlchina/okhttps/internal/AsyncHttpTask.java index 7801409b..3688a9ae 100644 --- a/src/main/java/com/ejlchina/okhttps/internal/AsyncHttpTask.java +++ b/src/main/java/com/ejlchina/okhttps/internal/AsyncHttpTask.java @@ -119,9 +119,9 @@ private HttpCall request(String method) { class PreHttpCall implements HttpCall { - private boolean canceled = false; - private HttpCall call; - final CountDownLatch latch = new CountDownLatch(1); + HttpCall call; + boolean canceled = false; + CountDownLatch latch = new CountDownLatch(1); @Override public synchronized boolean cancel() { @@ -143,7 +143,7 @@ public boolean isCanceled() { return canceled; } - public void setCall(HttpCall call) { + void setCall(HttpCall call) { this.call = call; latch.countDown(); } @@ -161,11 +161,11 @@ public HttpResult getResult() { class OkHttpCall implements HttpCall { - final Call call; - final CountDownLatch latch = new CountDownLatch(1); - private HttpResult result; - - public OkHttpCall(Call call) { + Call call; + HttpResult result; + CountDownLatch latch = new CountDownLatch(1); + + OkHttpCall(Call call) { this.call = call; } @@ -196,7 +196,7 @@ public HttpResult getResult() { return result; } - public void setResult(HttpResult result) { + void setResult(HttpResult result) { this.result = result; latch.countDown(); } @@ -210,7 +210,7 @@ private HttpCall executeCall(Call call) { public void onFailure(Call call, IOException error) { State state = toState(error, false); HttpResult result = new RealHttpResult(AsyncHttpTask.this, state, error); - doCallback(httpCall, result, () -> { + onCallback(httpCall, result, () -> { TaskExecutor executor = httpClient.getExecutor(); executor.executeOnComplete(AsyncHttpTask.this, onComplete, state, cOnIO); if (!executor.executeOnException(AsyncHttpTask.this, onException, error, eOnIO) @@ -224,7 +224,7 @@ public void onFailure(Call call, IOException error) { public void onResponse(Call call, Response response) throws IOException { TaskExecutor executor = httpClient.getExecutor(); HttpResult result = new RealHttpResult(AsyncHttpTask.this, response, executor); - doCallback(httpCall, result, () -> { + onCallback(httpCall, result, () -> { executor.executeOnComplete(AsyncHttpTask.this, onComplete, State.RESPONSED, cOnIO); executor.executeOnResponse(AsyncHttpTask.this, onResponse, result, rOnIO); }); @@ -234,7 +234,7 @@ public void onResponse(Call call, Response response) throws IOException { return httpCall; } - private void doCallback(OkHttpCall httpCall, HttpResult result, Runnable runnable) { + private void onCallback(OkHttpCall httpCall, HttpResult result, Runnable runnable) { //noinspection SynchronizationOnLocalVariableOrMethodParameter synchronized (httpCall) { removeTagTask(); diff --git a/src/main/java/com/ejlchina/okhttps/internal/SyncHttpTask.java b/src/main/java/com/ejlchina/okhttps/internal/SyncHttpTask.java index 8e5b5053..d40a7855 100644 --- a/src/main/java/com/ejlchina/okhttps/internal/SyncHttpTask.java +++ b/src/main/java/com/ejlchina/okhttps/internal/SyncHttpTask.java @@ -57,14 +57,10 @@ public HttpResult delete() { static class SyncCall implements Cancelable { - private Call call; + Call call; boolean done = false; boolean canceled = false; - public void setCall(Call call) { - this.call = call; - } - @Override public synchronized boolean cancel() { if (done) { @@ -77,10 +73,6 @@ public synchronized boolean cancel() { return true; } - public void setDone(boolean done) { - this.done = done; - } - } private HttpResult request(String method) { @@ -96,11 +88,11 @@ private HttpResult request(String method) { latch.countDown(); return; } - syncCall.setCall(prepareCall(method)); + syncCall.call = prepareCall(method); } try { result.response(syncCall.call.execute()); - syncCall.setDone(true); + syncCall.done = true; } catch (IOException e) { result.exception(toState(e, true), e); } finally { From 176eaa4f1287d05091db24efb905cce06070f023 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?=E5=91=A8=E6=97=AD?= Date: Sat, 11 Apr 2020 23:34:17 +0800 Subject: [PATCH 115/924] V1.0.3 ^_^ --- src/main/java/com/ejlchina/okhttps/internal/AsyncHttpTask.java | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/src/main/java/com/ejlchina/okhttps/internal/AsyncHttpTask.java b/src/main/java/com/ejlchina/okhttps/internal/AsyncHttpTask.java index 3688a9ae..c0d28ca7 100644 --- a/src/main/java/com/ejlchina/okhttps/internal/AsyncHttpTask.java +++ b/src/main/java/com/ejlchina/okhttps/internal/AsyncHttpTask.java @@ -234,8 +234,8 @@ public void onResponse(Call call, Response response) throws IOException { return httpCall; } + @SuppressWarnings("all") private void onCallback(OkHttpCall httpCall, HttpResult result, Runnable runnable) { - //noinspection SynchronizationOnLocalVariableOrMethodParameter synchronized (httpCall) { removeTagTask(); if (httpCall.isCanceled() || result.getState() == State.CANCELED) { From bb03c83b1dd611b46252e0cab5c1ad0fc01206f2 Mon Sep 17 00:00:00 2001 From: hake <15735559897@qq.com> Date: Sun, 12 Apr 2020 09:09:51 +0800 Subject: [PATCH 116/924] =?UTF-8?q?=E5=8F=96=E6=B6=88=E6=89=80=E6=9C=89?= =?UTF-8?q?=E8=AF=B7=E6=B1=82=E4=BB=BB=E5=8A=A1=E6=97=B6=EF=BC=8C=E6=B8=85?= =?UTF-8?q?=E7=A9=BA=20tagTasks=20=E9=98=9F=E5=88=97?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- src/main/java/com/ejlchina/okhttps/internal/HttpClient.java | 1 + 1 file changed, 1 insertion(+) diff --git a/src/main/java/com/ejlchina/okhttps/internal/HttpClient.java b/src/main/java/com/ejlchina/okhttps/internal/HttpClient.java index 4f0998dd..ff6645ef 100644 --- a/src/main/java/com/ejlchina/okhttps/internal/HttpClient.java +++ b/src/main/java/com/ejlchina/okhttps/internal/HttpClient.java @@ -82,6 +82,7 @@ public int cancel(String tag) { @Override public void cancelAll() { client.dispatcher().cancelAll(); + tagTasks.clear(); } @Override From cc6745cf6c6ee1b0d70d6e3aceba0bf14d13a306 Mon Sep 17 00:00:00 2001 From: hake <15735559897@qq.com> Date: Sun, 12 Apr 2020 09:12:11 +0800 Subject: [PATCH 117/924] =?UTF-8?q?=E4=BC=98=E5=8C=96=E5=8F=98=E9=87=8F?= =?UTF-8?q?=E5=91=BD=E5=90=8D?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- .../ejlchina/okhttps/internal/HttpClient.java | 18 +++++++++--------- 1 file changed, 9 insertions(+), 9 deletions(-) diff --git a/src/main/java/com/ejlchina/okhttps/internal/HttpClient.java b/src/main/java/com/ejlchina/okhttps/internal/HttpClient.java index ff6645ef..e935d604 100644 --- a/src/main/java/com/ejlchina/okhttps/internal/HttpClient.java +++ b/src/main/java/com/ejlchina/okhttps/internal/HttpClient.java @@ -160,9 +160,9 @@ public TaskExecutor getExecutor() { public void preprocess(HttpTask> httpTask, Runnable request) { if (preprocessors.length > 0) { - RealPreChain process = new RealPreChain(preprocessors, + RealPreChain chain = new RealPreChain(preprocessors, httpTask, request); - preprocessors[0].doProcess(process); + preprocessors[0].doProcess(chain); } else { request.run(); } @@ -187,32 +187,32 @@ static class SerialPreprocessor implements Preprocessor { } @Override - public void doProcess(PreChain process) { + public void doProcess(PreChain chain) { boolean should = true; synchronized (this) { if (running) { - pendings.add(process); + pendings.add(chain); should = false; } else { running = true; } } if (should) { - preprocessor.doProcess(process); + preprocessor.doProcess(chain); } } public void afterProcess() { - PreChain process = null; + PreChain chain = null; synchronized (this) { if (pendings.size() > 0) { - process = pendings.poll(); + chain = pendings.poll(); } else { running = false; } } - if (process != null) { - preprocessor.doProcess(process); + if (chain != null) { + preprocessor.doProcess(chain); } } From 54eb8fa82a8e6297d75ca2b2cdd02637d74ef4e9 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?=E5=91=A8=E6=97=AD?= <15735559897@qq.com> Date: Sun, 12 Apr 2020 09:38:43 +0800 Subject: [PATCH 118/924] =?UTF-8?q?=E4=BC=98=E5=8C=96=20tagTasks=20?= =?UTF-8?q?=E9=98=9F=E5=88=97=E6=80=A7=E8=83=BD?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- .../java/com/ejlchina/okhttps/internal/HttpClient.java | 10 +++++----- 1 file changed, 5 insertions(+), 5 deletions(-) diff --git a/src/main/java/com/ejlchina/okhttps/internal/HttpClient.java b/src/main/java/com/ejlchina/okhttps/internal/HttpClient.java index e935d604..32553f1c 100644 --- a/src/main/java/com/ejlchina/okhttps/internal/HttpClient.java +++ b/src/main/java/com/ejlchina/okhttps/internal/HttpClient.java @@ -34,7 +34,7 @@ private HttpClient(Builder builder) { builder.responseListener, builder.exceptionListener, builder.completeListener); this.preprocessors = builder.preprocessors.toArray(new Preprocessor[0]); - this.tagTasks = Collections.synchronizedList(new LinkedList<>()); + this.tagTasks = new LinkedList<>(); } @Override @@ -58,7 +58,7 @@ public SyncHttpTask sync(String url) { } @Override - public int cancel(String tag) { + public synchronized int cancel(String tag) { if (tag == null) { return 0; } @@ -80,7 +80,7 @@ public int cancel(String tag) { } @Override - public void cancelAll() { + public synchronized void cancelAll() { client.dispatcher().cancelAll(); tagTasks.clear(); } @@ -107,11 +107,11 @@ public int getTagTaskCount() { return tagTasks.size(); } - public void addTagTask(String tag, Cancelable canceler, HttpTask task) { + public synchronized void addTagTask(String tag, Cancelable canceler, HttpTask task) { tagTasks.add(new TagTask(tag, canceler, task)); } - public void removeTagTask(HttpTask task) { + public synchronized void removeTagTask(HttpTask task) { Iterator it = tagTasks.iterator(); while (it.hasNext()) { TagTask tagCall = it.next(); From 32e491e2390b4638cae2511b357f74efa8f534b2 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?=E5=91=A8=E6=97=AD?= <15735559897@qq.com> Date: Sun, 12 Apr 2020 09:39:29 +0800 Subject: [PATCH 119/924] V1.0.3 ^_^ --- pom.xml | 336 ++++++++++++++++++++++++++++---------------------------- 1 file changed, 168 insertions(+), 168 deletions(-) diff --git a/pom.xml b/pom.xml index b8e2b970..1c69b7d4 100644 --- a/pom.xml +++ b/pom.xml @@ -1,169 +1,169 @@ - - 4.0.0 - - com.ejlchina - okhttps - 1.0.2 - OkHttps - - - 1.8 - UTF-8 - https://oss.sonatype.org/content/repositories/snapshots/ - - - - - The Apache License, Version 2.0 - http://www.apache.org/licenses/LICENSE-2.0.txt - - - - - - Troy - zhou.xu@ejlchina.com - ejlchina - http://www.ejlchina.com - - - - - scm:git://gitee.com/ejlchina-zhxu/okhttps.git - scm:http://gitee.com/ejlchina-zhxu/okhttps - https://gitee.com/ejlchina-zhxu/okhttps - v1.0.2 - - - - - - junit - junit - 4.12 - test - - - - com.alibaba - fastjson - 1.2.67 - - - - com.squareup.okhttp3 - okhttp - 3.14.7 - - - - - - - sonatype-nexus-snapshots - Sonatype Nexus Snapshots - https://oss.sonatype.org/content/repositories/snapshots - - false - - - true - - - - - - - sonatype-nexus-snapshots - Sonatype Nexus Snapshots - ${sonatypeOssDistMgmtSnapshotsUrl} - - - sonatype-nexus-staging - Nexus Release Repository - https://oss.sonatype.org/service/local/staging/deploy/maven2/ - - - - - okhttps - - - - org.apache.maven.plugins - maven-release-plugin - 2.1 - - forked-path - false - -Psonatype-oss-release - - - - - org.apache.maven.plugins - maven-compiler-plugin - - ${java-version} - ${java-version} - ${project.build.sourceEncoding} - true - - - - - org.apache.maven.plugins - maven-source-plugin - 2.1.2 - - - attach-sources - - jar-no-fork - - - - - - - org.apache.maven.plugins - maven-javadoc-plugin - 2.7 - - - attach-javadocs - - jar - - - - - - - org.apache.maven.plugins - maven-gpg-plugin - 1.1 - - - sign-artifacts - verify - - sign - - - - - - - - - https://gitee.com/ejlchina-zhxu/okhttps - Http工具包，封装 OkHttp，链式用法、支持异步同步、响应JSON自动解析，回调线程切换、配置灵活、支持URL占位符、支持BaseUrl、外部依赖少、适用 JavaWeb 和 Android，教程全面、简单易用 - - 江苏一键联信息科技有限公司 - http://www.ejlchina.com/ - - - https://gitee.com/ejlchina-zhxu/okhttps/issues - + + 4.0.0 + + com.ejlchina + okhttps + 1.0.3 + OkHttps + + + 1.8 + UTF-8 + https://oss.sonatype.org/content/repositories/snapshots/ + + + + + The Apache License, Version 2.0 + http://www.apache.org/licenses/LICENSE-2.0.txt + + + + + + Troy + zhou.xu@ejlchina.com + ejlchina + http://www.ejlchina.com + + + + + scm:git://gitee.com/ejlchina-zhxu/okhttps.git + scm:http://gitee.com/ejlchina-zhxu/okhttps + https://gitee.com/ejlchina-zhxu/okhttps + v1.0.3 + + + + + + junit + junit + 4.12 + test + + + + com.alibaba + fastjson + 1.2.67 + + + + com.squareup.okhttp3 + okhttp + 3.14.7 + + + + + + + sonatype-nexus-snapshots + Sonatype Nexus Snapshots + https://oss.sonatype.org/content/repositories/snapshots + + false + + + true + + + + + + + sonatype-nexus-snapshots + Sonatype Nexus Snapshots + ${sonatypeOssDistMgmtSnapshotsUrl} + + + sonatype-nexus-staging + Nexus Release Repository + https://oss.sonatype.org/service/local/staging/deploy/maven2/ + + + + + okhttps + + + + org.apache.maven.plugins + maven-release-plugin + 2.1 + + forked-path + false + -Psonatype-oss-release + + + + + org.apache.maven.plugins + maven-compiler-plugin + + ${java-version} + ${java-version} + ${project.build.sourceEncoding} + true + + + + + org.apache.maven.plugins + maven-source-plugin + 2.1.2 + + + attach-sources + + jar-no-fork + + + + + + + org.apache.maven.plugins + maven-javadoc-plugin + 2.7 + + + attach-javadocs + + jar + + + + + + + org.apache.maven.plugins + maven-gpg-plugin + 1.1 + + + sign-artifacts + verify + + sign + + + + + + + + + https://gitee.com/ejlchina-zhxu/okhttps + Http工具包，封装 OkHttp，链式用法、支持异步同步、响应JSON自动解析，回调线程切换、配置灵活、支持URL占位符、支持BaseUrl、外部依赖少、适用 JavaWeb 和 Android，教程全面、简单易用 + + 江苏一键联信息科技有限公司 + http://www.ejlchina.com/ + + + https://gitee.com/ejlchina-zhxu/okhttps/issues + \ No newline at end of file From 910b19b6c83443a6004c77a10fe6371971fbad2c Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?=E5=91=A8=E6=97=AD?= <15735559897@qq.com> Date: Sun, 12 Apr 2020 21:21:08 +0800 Subject: [PATCH 120/924] V1.0.3 ^_^ --- README.md | 6 +++--- 1 file changed, 3 insertions(+), 3 deletions(-) diff --git a/README.md b/README.md index 1964fd0a..01bf4e9a 100644 --- a/README.md +++ b/README.md @@ -18,7 +18,7 @@ > OkHttps 非常轻量，自身代码仅 2000 行左右，且有较高的编码质量，sonarqube 分析结果为 3A，[查看报告](https://gitee.com/ejlchina-zhxu/okhttps/quality_analyses?platform=sonar_qube) ### 前世：[HttpUtils, V2.3.0 之后重命名为 OkHttps](https://gitee.com/ejlchina-zhxu/httputils) -### 当前文档版本[1.0.2] +### 当前文档版本[1.0.3] ### API文档：[https://apidoc.gitee.com/ejlchina-zhxu/okhttps](https://apidoc.gitee.com/ejlchina-zhxu/okhttps) ## 目录 @@ -72,12 +72,12 @@ com.ejlchina okhttps - 1.0.2 + 1.0.3 ``` ### Gradle -`implementation 'com.ejlchina:okhttps:1.0.2'` +`implementation 'com.ejlchina:okhttps:1.0.3'` ## 使用说明 From eabf562b90bdcdc58668fee5c3e63f9cff96c9ec Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?=E5=91=A8=E6=97=AD?= Date: Mon, 13 Apr 2020 11:53:53 +0800 Subject: [PATCH 121/924] =?UTF-8?q?=E6=B7=BB=E5=8A=A0=20mockserver=20?= =?UTF-8?q?=E8=87=AA=E5=8A=A8=E5=8C=96=E6=B5=8B=E8=AF=95?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- pom.xml | 36 +++++++++++++++++++++++------------- 1 file changed, 23 insertions(+), 13 deletions(-) diff --git a/pom.xml b/pom.xml index b8e2b970..59a5257c 100644 --- a/pom.xml +++ b/pom.xml @@ -8,6 +8,9 @@ 1.8 + 3.14.7 + 1.2.67 + 4.12 UTF-8 https://oss.sonatype.org/content/repositories/snapshots/ @@ -36,24 +39,31 @@ - - - junit - junit - 4.12 - test + + + com.squareup.okhttp3 + okhttp + ${okhttp.version} - - - com.alibaba + + + com.alibaba fastjson - 1.2.67 + ${fastjson.version} - + com.squareup.okhttp3 - okhttp - 3.14.7 + mockwebserver + ${okhttp.version} + test + + + + junit + junit + ${junit.version} + test From 62c8027fede491a1054fb656aa8d5332aa1b1d2b Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?=E5=91=A8=E6=97=AD?= Date: Mon, 13 Apr 2020 14:25:17 +0800 Subject: [PATCH 122/924] =?UTF-8?q?HttpTask=20=E6=96=B0=E5=A2=9E=20appendT?= =?UTF-8?q?ag=20=E6=96=B9=E6=B3=95?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- .../java/com/ejlchina/okhttps/HttpTask.java | 18 +++++++++++++++++- 1 file changed, 17 insertions(+), 1 deletion(-) diff --git a/src/main/java/com/ejlchina/okhttps/HttpTask.java b/src/main/java/com/ejlchina/okhttps/HttpTask.java index 24b926a5..eb858d0c 100644 --- a/src/main/java/com/ejlchina/okhttps/HttpTask.java +++ b/src/main/java/com/ejlchina/okhttps/HttpTask.java @@ -124,6 +124,22 @@ public C setTag(String tag) { return (C) this; } + /** + * 为请求任务追加标签 + * @param tag 标签 + * @return HttpTask 实例 + */ + public C appendTag(String tag) { + if (tag != null) { + if (this.tag != null) { + this.tag = this.tag + "." + tag; + } else { + this.tag = tag; + } + } + return (C) this; + } + /** * 下一个回调在IO线程执行 * @return HttpTask 实例 @@ -576,7 +592,7 @@ protected State toState(IOException e, boolean sync) { } String msg = e.getMessage(); if (msg != null && ("Canceled".equals(msg) - || sync && e instanceof SocketException + || sync && e instanceof SocketException && msg.startsWith("Socket operation on nonsocket"))) { return State.CANCELED; } From cac4d90250b5d4768e5e56e643c937767c3912e2 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?=E5=91=A8=E6=97=AD?= Date: Mon, 13 Apr 2020 14:33:51 +0800 Subject: [PATCH 123/924] =?UTF-8?q?=E4=BC=98=E5=8C=96=20TagTask=20?= =?UTF-8?q?=E9=98=9F=E5=88=97?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- .../ejlchina/okhttps/internal/HttpClient.java | 62 +++++++++++-------- 1 file changed, 36 insertions(+), 26 deletions(-) diff --git a/src/main/java/com/ejlchina/okhttps/internal/HttpClient.java b/src/main/java/com/ejlchina/okhttps/internal/HttpClient.java index 32553f1c..e43affd4 100644 --- a/src/main/java/com/ejlchina/okhttps/internal/HttpClient.java +++ b/src/main/java/com/ejlchina/okhttps/internal/HttpClient.java @@ -58,31 +58,35 @@ public SyncHttpTask sync(String url) { } @Override - public synchronized int cancel(String tag) { + public int cancel(String tag) { if (tag == null) { return 0; } int count = 0; - Iterator it = tagTasks.iterator(); - while (it.hasNext()) { - TagTask tagCall = it.next(); - // 只要任务的标签包含指定的Tag就会被取消 - if (tagCall.tag.contains(tag)) { - if (tagCall.canceler.cancel()) { - count++; + synchronized (tagTasks) { + Iterator it = tagTasks.iterator(); + while (it.hasNext()) { + TagTask tagCall = it.next(); + // 只要任务的标签包含指定的Tag就会被取消 + if (tagCall.tag.contains(tag)) { + if (tagCall.canceler.cancel()) { + count++; + } + it.remove(); + } else if (tagCall.isExpired()) { + it.remove(); } - it.remove(); - } else if (tagCall.isExpired()) { - it.remove(); } } return count; } @Override - public synchronized void cancelAll() { + public void cancelAll() { client.dispatcher().cancelAll(); - tagTasks.clear(); + synchronized (tagTasks) { + tagTasks.clear(); + } } @Override @@ -107,22 +111,28 @@ public int getTagTaskCount() { return tagTasks.size(); } - public synchronized void addTagTask(String tag, Cancelable canceler, HttpTask task) { - tagTasks.add(new TagTask(tag, canceler, task)); + public TagTask addTagTask(String tag, Cancelable canceler, HttpTask task) { + TagTask tagTask = new TagTask(tag, canceler, task); + synchronized (tagTasks) { + tagTasks.add(tagTask); + } + return tagTask; } - public synchronized void removeTagTask(HttpTask task) { - Iterator it = tagTasks.iterator(); - while (it.hasNext()) { - TagTask tagCall = it.next(); - if (tagCall.task == task) { - it.remove(); - break; - } - if (tagCall.isExpired()) { - it.remove(); + public void removeTagTask(HttpTask task) { + synchronized (tagTasks) { + Iterator it = tagTasks.iterator(); + while (it.hasNext()) { + TagTask tagCall = it.next(); + if (tagCall.task == task) { + it.remove(); + break; + } + if (tagCall.isExpired()) { + it.remove(); + } } - } + } } class TagTask { From 90b848b278a1512e8dd7b6061bc52f6946411d22 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?=E5=91=A8=E6=97=AD?= Date: Mon, 13 Apr 2020 20:31:46 +0800 Subject: [PATCH 124/924] =?UTF-8?q?=E4=BC=98=E5=8C=96=20HttpTask=EF=BC=9A?= =?UTF-8?q?=201=E3=80=81=E8=8B=A5=E8=B0=83=E7=94=A8=E5=A4=9A=E6=AC=A1=20se?= =?UTF-8?q?tTag=EF=BC=8C=E4=BB=BB=E5=8A=A1=E5=B0=86=E8=A2=AB=E6=B7=BB?= =?UTF-8?q?=E5=8A=A0=E5=A4=9A=E4=B8=AA=E6=A0=87=E7=AD=BE=202=E3=80=81?= =?UTF-8?q?=E8=8B=A5=E6=A0=87=E7=AD=BE=E4=BB=BB=E5=8A=A1=E5=B7=B2=E6=B7=BB?= =?UTF-8?q?=E5=8A=A0=EF=BC=8C=E5=88=99=E4=BF=AE=E6=94=B9=E6=A0=87=E7=AD=BE?= =?UTF-8?q?=E6=97=B6=EF=BC=8C=E5=B0=86=E6=9B=B4=E6=96=B0=E6=A0=87=E7=AD=BE?= =?UTF-8?q?=E4=BB=BB=E5=8A=A1=203=E3=80=81=E4=BC=98=E5=8C=96=E6=96=B9?= =?UTF-8?q?=E6=B3=95=EF=BC=9AaddJsonParam(Map=20params)?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- .../java/com/ejlchina/okhttps/HttpTask.java | 45 ++++++++++--------- .../ejlchina/okhttps/internal/HttpClient.java | 6 ++- 2 files changed, 30 insertions(+), 21 deletions(-) diff --git a/src/main/java/com/ejlchina/okhttps/HttpTask.java b/src/main/java/com/ejlchina/okhttps/HttpTask.java index eb858d0c..8f4c2453 100644 --- a/src/main/java/com/ejlchina/okhttps/HttpTask.java +++ b/src/main/java/com/ejlchina/okhttps/HttpTask.java @@ -3,6 +3,7 @@ import com.alibaba.fastjson.JSON; import com.ejlchina.okhttps.HttpResult.State; import com.ejlchina.okhttps.internal.HttpClient; +import com.ejlchina.okhttps.internal.HttpClient.TagTask; import com.ejlchina.okhttps.internal.HttpException; import com.ejlchina.okhttps.internal.ProcessRequestBody; import okhttp3.*; @@ -50,6 +51,9 @@ public abstract class HttpTask> { private double stepRate = -1; private Object object; + + private TagTask tagTask; + private Cancelable canceler; public HttpTask(HttpClient httpClient, String url) { @@ -114,28 +118,18 @@ public C nothrow() { /** * 为请求任务添加标签 + * v1.0.4 之后，若 set 多次，标签将连接在一起 * @param tag 标签 * @return HttpTask 实例 */ public C setTag(String tag) { if (tag != null) { - this.tag = tag; - } - return (C) this; - } - - /** - * 为请求任务追加标签 - * @param tag 标签 - * @return HttpTask 实例 - */ - public C appendTag(String tag) { - if (tag != null) { - if (this.tag != null) { - this.tag = this.tag + "." + tag; - } else { - this.tag = tag; - } + if (this.tag != null) { + this.tag = this.tag + "." + tag; + } else { + this.tag = tag; + } + updateTagTask(); } return (C) this; } @@ -363,7 +357,7 @@ public C addJsonParam(String name, Object value) { * @param params JSON键值集合 * @return HttpTask 实例 */ - public C addJsonParam(Map params) { + public C addJsonParam(Map params) { if (params != null) { if (jsonParams == null) { jsonParams = new HashMap<>(); @@ -514,13 +508,23 @@ static class FilePara { } } - + protected void registeTagTask(Cancelable canceler) { if (tag != null) { - httpClient.addTagTask(tag, canceler, this); + tagTask = httpClient.addTagTask(tag, canceler, this); } + this.canceler = canceler; } + private void updateTagTask() { + if (tagTask != null) { + tagTask.setTag(tag); + } else + if (canceler != null) { + registeTagTask(canceler); + } + } + protected void removeTagTask() { if (tag != null) { httpClient.removeTagTask(this); @@ -719,6 +723,7 @@ protected void assertNotConflict(boolean isGetRequest) { } protected void timeoutAwait(CountDownLatch latch) { + // TODO: 超时不会异常！ try { latch.await(httpClient.totalTimeoutMillis() * 10, TimeUnit.MILLISECONDS); diff --git a/src/main/java/com/ejlchina/okhttps/internal/HttpClient.java b/src/main/java/com/ejlchina/okhttps/internal/HttpClient.java index e43affd4..c6902eb6 100644 --- a/src/main/java/com/ejlchina/okhttps/internal/HttpClient.java +++ b/src/main/java/com/ejlchina/okhttps/internal/HttpClient.java @@ -135,7 +135,7 @@ public void removeTagTask(HttpTask task) { } } - class TagTask { + public class TagTask { String tag; Cancelable canceler; @@ -154,6 +154,10 @@ boolean isExpired() { return System.nanoTime() - createAt > 10_000_000 * totalTimeoutMillis(); } + public void setTag(String tag) { + this.tag = tag; + } + } public MediaType getMediaType(String type) { From a2f8522cab00d86d3e7279ab1f36c58d7933719a Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?=E5=91=A8=E6=97=AD?= Date: Mon, 13 Apr 2020 21:29:44 +0800 Subject: [PATCH 125/924] Test --- src/test/java/com/ejlchina/test/BaseTest.java | 49 +++++- .../java/com/ejlchina/test/SimpleTests.java | 142 +++++++++++------- 2 files changed, 134 insertions(+), 57 deletions(-) diff --git a/src/test/java/com/ejlchina/test/BaseTest.java b/src/test/java/com/ejlchina/test/BaseTest.java index bd96497b..e920abda 100644 --- a/src/test/java/com/ejlchina/test/BaseTest.java +++ b/src/test/java/com/ejlchina/test/BaseTest.java @@ -31,19 +31,64 @@ public static class User { private int id; private String name; - public void setId(int id) { + + public User() { + } + + public User(int id, String name) { + this.id = id; + this.name = name; + } + + public void setId(int id) { this.id = id; } public void setName(String name) { this.name = name; } + + public int getId() { + return id; + } + + public String getName() { + return name; + } - @Override + @Override public String toString() { return "User [id=" + id + ", name=" + name + "]"; } + @Override + public int hashCode() { + final int prime = 31; + int result = 1; + result = prime * result + id; + result = prime * result + ((name == null) ? 0 : name.hashCode()); + return result; + } + + @Override + public boolean equals(Object obj) { + if (this == obj) + return true; + if (obj == null) + return false; + if (getClass() != obj.getClass()) + return false; + User other = (User) obj; + if (id != other.id) + return false; + if (name == null) { + if (other.name != null) + return false; + } else if (!name.equals(other.name)) + return false; + return true; + } + } } diff --git a/src/test/java/com/ejlchina/test/SimpleTests.java b/src/test/java/com/ejlchina/test/SimpleTests.java index 4a6d8a34..4b0ef9ef 100644 --- a/src/test/java/com/ejlchina/test/SimpleTests.java +++ b/src/test/java/com/ejlchina/test/SimpleTests.java @@ -1,17 +1,25 @@ package com.ejlchina.test; -import com.ejlchina.okhttps.HTTP; -import com.ejlchina.okhttps.HttpResult; -import com.ejlchina.okhttps.HttpResult.Body; -import org.junit.Test; +import static org.junit.Assert.assertEquals; +import java.util.Arrays; import java.util.List; +import org.junit.Test; + +import com.alibaba.fastjson.JSON; +import com.ejlchina.okhttps.HTTP; + +import okhttp3.mockwebserver.MockResponse; +import okhttp3.mockwebserver.MockWebServer; + public class SimpleTests extends BaseTest { + MockWebServer server = new MockWebServer(); + HTTP http = HTTP.builder() - .baseUrl("http://localhost:8080") + .baseUrl("http://" + server.getHostName() + ":" + server.getPort()) .build(); /** @@ -19,63 +27,87 @@ public class SimpleTests extends BaseTest { * 同步请求直接得到结果，无需设置回调 */ @Test - public void testSync() { - List users = http.sync("/users") // http://localhost:8080/users + public void testSyncToBean() { + User u1 = new User(1, "Jack"); + server.enqueue(new MockResponse().setBody(JSON.toJSONString(u1))); + + User user = http.sync("/users") // http://localhost:8080/users .get() // GET请求 .getBody() // 获取响应报文体 - .toList(User.class); // 得到目标数据 - System.out.println("users = " + users); - } - - /** - * 异步请求示例 - * 异步请求在OnResponse里接收请求结果 - */ - @Test - public void testAsync() { - http.async("/users/1") // http://api.demo.com/users/1 - .setOnResponse((HttpResult result) -> { - // 得到目标数据 - User user = result.getBody().toBean(User.class); - System.out.println("user = " + user); - }) - .get(); - sleep(5000); + .toBean(User.class); // 得到目标数据 + + assertEquals(u1, user); } - - + /** - * 启用 cache 示例 - */ - @Test - public void testCache() { - Body body = http.sync("/users").get().getBody() - .cache(); // 启用 cache - // 使用 cache 后，可以多次使用 toXXX() 方法 - System.out.println(body.toString()); - System.out.println(body.toJsonArray()); - System.out.println(body.toList(User.class)); - } - - - /** - * 获取文件大小示例 + * 同步请求示例 + * 同步请求直接得到结果，无需设置回调 */ @Test - public void testContentLength() { - long t = System.currentTimeMillis(); - - long size = http.sync("https://download.cocos.com/CocosDashboard/v1.0.1/CocosDashboard-v1.0.1-win32-031816.exe") - .get().getBody() - .close() // 只是想获得文件大小，不消费报文体，所以直接关闭 - .getContentLength(); // 获得待下载文件的大小 - - t = System.currentTimeMillis() - t; - - // 由于未消费报文体，所以本次请求不会消耗下载报文体的时间和网络流量） - System.out.println("耗时：" + t + " 毫秒"); - System.out.println("size = " + (size / 1024) + " KB"); + public void testSyncToList() { + User u1 = new User(1, "Jack"); + User u2 = new User(2, "Tom"); + List list = Arrays.asList(u1, u2); + server.enqueue(new MockResponse().setBody(JSON.toJSONString(list))); + + List users = http.sync("/users") // http://localhost:8080/users + .get() // GET请求 + .getBody() // 获取响应报文体 + .toList(User.class); // 得到目标数据 + + assertEquals(u1, users.get(0)); + assertEquals(u2, users.get(1)); } +// +// /** +// * 异步请求示例 +// * 异步请求在OnResponse里接收请求结果 +// */ +// @Test +// public void testAsync() { +// http.async("/users/1") // http://api.demo.com/users/1 +// .setOnResponse((HttpResult result) -> { +// // 得到目标数据 +// User user = result.getBody().toBean(User.class); +// System.out.println("user = " + user); +// }) +// .get(); +// sleep(5000); +// } +// +// +// /** +// * 启用 cache 示例 +// */ +// @Test +// public void testCache() { +// Body body = http.sync("/users").get().getBody() +// .cache(); // 启用 cache +// // 使用 cache 后，可以多次使用 toXXX() 方法 +// System.out.println(body.toString()); +// System.out.println(body.toJsonArray()); +// System.out.println(body.toList(User.class)); +// } +// +// +// /** +// * 获取文件大小示例 +// */ +// @Test +// public void testContentLength() { +// long t = System.currentTimeMillis(); +// +// long size = http.sync("https://download.cocos.com/CocosDashboard/v1.0.1/CocosDashboard-v1.0.1-win32-031816.exe") +// .get().getBody() +// .close() // 只是想获得文件大小，不消费报文体，所以直接关闭 +// .getContentLength(); // 获得待下载文件的大小 +// +// t = System.currentTimeMillis() - t; +// +// // 由于未消费报文体，所以本次请求不会消耗下载报文体的时间和网络流量） +// System.out.println("耗时：" + t + " 毫秒"); +// System.out.println("size = " + (size / 1024) + " KB"); +// } } From fd69399a57a074d22f0e69ac929429f25342018f Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?=E5=91=A8=E6=97=AD?= <15735559897@qq.com> Date: Mon, 13 Apr 2020 23:19:36 +0800 Subject: [PATCH 126/924] =?UTF-8?q?HttpTask=20=E5=AE=9E=E7=8E=B0=20Cancela?= =?UTF-8?q?ble=20=E6=8E=A5=E5=8F=A3?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- src/main/java/com/ejlchina/okhttps/HttpTask.java | 10 +++++++++- 1 file changed, 9 insertions(+), 1 deletion(-) diff --git a/src/main/java/com/ejlchina/okhttps/HttpTask.java b/src/main/java/com/ejlchina/okhttps/HttpTask.java index 8f4c2453..2b8d6289 100644 --- a/src/main/java/com/ejlchina/okhttps/HttpTask.java +++ b/src/main/java/com/ejlchina/okhttps/HttpTask.java @@ -27,7 +27,7 @@ * Created by 周旭（Troy.Zhou） on 2020/3/11. */ @SuppressWarnings("unchecked") -public abstract class HttpTask> { +public abstract class HttpTask> implements Cancelable { private static final MediaType TYPE_JSON = MediaType.parse("application/json; charset=utf-8"); private static String PATH_PARAM_REGEX = "[A-Za-z0-9_\\-/]*\\{[A-Za-z0-9_\\-]+\\}[A-Za-z0-9_\\-/]*"; @@ -488,6 +488,14 @@ public C addFileParam(String name, String type, String fileName, byte[] content) return (C) this; } + @Override + public boolean cancel() { + if (canceler != null) { + return canceler.cancel(); + } + return false; + } + static class FilePara { String type; From dbcc2006623efd08ad2519fc762fcfc046b44da3 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?=E5=91=A8=E6=97=AD?= <15735559897@qq.com> Date: Mon, 13 Apr 2020 23:21:01 +0800 Subject: [PATCH 127/924] v1.0.4 --- pom.xml | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/pom.xml b/pom.xml index 553da5e8..1cf524f8 100644 --- a/pom.xml +++ b/pom.xml @@ -3,7 +3,7 @@ com.ejlchina okhttps - 1.0.3 + 1.0.4 OkHttps @@ -35,7 +35,7 @@ scm:git://gitee.com/ejlchina-zhxu/okhttps.git scm:http://gitee.com/ejlchina-zhxu/okhttps https://gitee.com/ejlchina-zhxu/okhttps - v1.0.3 + v1.0.4 From 8cf9fe917d59b06d0b335807284836cec153d844 Mon Sep 17 00:00:00 2001 From: ejlchina Date: Tue, 14 Apr 2020 00:14:59 +0800 Subject: [PATCH 128/924] update README.md. --- README.md | 2 ++ 1 file changed, 2 insertions(+) diff --git a/README.md b/README.md index 01bf4e9a..f59bdeda 100644 --- a/README.md +++ b/README.md @@ -926,6 +926,8 @@ http.sync("/download/test.zip") ## 联系方式 * 邮箱：zhou.xu@ejlchina.com +* 微信： + ## 参与贡献 From 8653bac3f828621083cb3384737ddcaa18b268e1 Mon Sep 17 00:00:00 2001 From: ejlchina Date: Tue, 14 Apr 2020 00:15:50 +0800 Subject: [PATCH 129/924] update README.md. --- README.md | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/README.md b/README.md index f59bdeda..97190bb9 100644 --- a/README.md +++ b/README.md @@ -927,7 +927,7 @@ http.sync("/download/test.zip") * 邮箱：zhou.xu@ejlchina.com * 微信： - + ## 参与贡献 From 78280d980b1a07229b9685d29eba5e8e51337cc5 Mon Sep 17 00:00:00 2001 From: ejlchina Date: Tue, 14 Apr 2020 00:20:47 +0800 Subject: [PATCH 130/924] =?UTF-8?q?=E5=BE=AE=E4=BF=A1=E4=BA=A4=E6=B5=81?= =?UTF-8?q?=E7=BE=A4?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- README.md | 4 +++- 1 file changed, 3 insertions(+), 1 deletion(-) diff --git a/README.md b/README.md index 97190bb9..c17e12cb 100644 --- a/README.md +++ b/README.md @@ -927,7 +927,9 @@ http.sync("/download/test.zip") * 邮箱：zhou.xu@ejlchina.com * 微信： - +
+ +
## 参与贡献 From ecc3df352a3347d11d9e06475f38a85cc0f01b22 Mon Sep 17 00:00:00 2001 From: ejlchina Date: Tue, 14 Apr 2020 00:21:51 +0800 Subject: [PATCH 131/924] update README.md. --- README.md | 5 +---- 1 file changed, 1 insertion(+), 4 deletions(-) diff --git a/README.md b/README.md index c17e12cb..936c1532 100644 --- a/README.md +++ b/README.md @@ -926,10 +926,7 @@ http.sync("/download/test.zip") ## 联系方式 * 邮箱：zhou.xu@ejlchina.com -* 微信： -
- -
+* 微信： ## 参与贡献 From 7b9cfa98fb8fd97d001214e204827b5cce3fe1cb Mon Sep 17 00:00:00 2001 From: ejlchina Date: Tue, 14 Apr 2020 00:25:34 +0800 Subject: [PATCH 132/924] update README.md. --- README.md | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/README.md b/README.md index 936c1532..21f09e94 100644 --- a/README.md +++ b/README.md @@ -926,7 +926,7 @@ http.sync("/download/test.zip") ## 联系方式 * 邮箱：zhou.xu@ejlchina.com -* 微信： +* 微信： ## 参与贡献 From 5fc7163580796f1cb4cbecb67f8f89d443f2686f Mon Sep 17 00:00:00 2001 From: ejlchina Date: Tue, 14 Apr 2020 00:30:38 +0800 Subject: [PATCH 133/924] update README.md. --- README.md | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/README.md b/README.md index 21f09e94..ff35cc34 100644 --- a/README.md +++ b/README.md @@ -925,8 +925,8 @@ http.sync("/download/test.zip") ## 联系方式 +* 微信： * 邮箱：zhou.xu@ejlchina.com -* 微信： ## 参与贡献 From c0b95e5dcbfe23b95c43ec57e4ffd72b5b238c37 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?=E5=91=A8=E6=97=AD?= Date: Tue, 14 Apr 2020 14:04:45 +0800 Subject: [PATCH 134/924] =?UTF-8?q?=E9=A2=84=E5=A4=84=E7=90=86=E5=99=A8?= =?UTF-8?q?=E8=B6=85=E6=97=B6=E5=A4=84=E7=90=86?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- .../java/com/ejlchina/okhttps/HttpTask.java | 43 +++++++++++++------ .../okhttps/internal/AsyncHttpTask.java | 11 ++++- .../okhttps/internal/HttpException.java | 5 +++ .../okhttps/internal/SyncHttpTask.java | 23 ++++++---- 4 files changed, 58 insertions(+), 24 deletions(-) diff --git a/src/main/java/com/ejlchina/okhttps/HttpTask.java b/src/main/java/com/ejlchina/okhttps/HttpTask.java index 2b8d6289..0d8c3ecb 100644 --- a/src/main/java/com/ejlchina/okhttps/HttpTask.java +++ b/src/main/java/com/ejlchina/okhttps/HttpTask.java @@ -1,15 +1,5 @@ package com.ejlchina.okhttps; -import com.alibaba.fastjson.JSON; -import com.ejlchina.okhttps.HttpResult.State; -import com.ejlchina.okhttps.internal.HttpClient; -import com.ejlchina.okhttps.internal.HttpClient.TagTask; -import com.ejlchina.okhttps.internal.HttpException; -import com.ejlchina.okhttps.internal.ProcessRequestBody; -import okhttp3.*; -import okhttp3.internal.Util; -import okio.Buffer; - import java.io.File; import java.io.IOException; import java.io.InputStream; @@ -22,6 +12,23 @@ import java.util.concurrent.CountDownLatch; import java.util.concurrent.TimeUnit; +import com.alibaba.fastjson.JSON; +import com.ejlchina.okhttps.HttpResult.State; +import com.ejlchina.okhttps.internal.HttpClient; +import com.ejlchina.okhttps.internal.HttpClient.TagTask; +import com.ejlchina.okhttps.internal.HttpException; +import com.ejlchina.okhttps.internal.ProcessRequestBody; +import com.ejlchina.okhttps.internal.RealHttpResult; + +import okhttp3.Call; +import okhttp3.FormBody; +import okhttp3.MediaType; +import okhttp3.MultipartBody; +import okhttp3.Request; +import okhttp3.RequestBody; +import okhttp3.internal.Util; +import okio.Buffer; + /** * Created by 周旭（Troy.Zhou） on 2020/3/11. @@ -730,14 +737,24 @@ protected void assertNotConflict(boolean isGetRequest) { } } - protected void timeoutAwait(CountDownLatch latch) { - // TODO: 超时不会异常！ + /** + * @param latch CountDownLatch + * @return 是否未超时：false 表示已超时 + */ + protected boolean timeoutAwait(CountDownLatch latch) { try { - latch.await(httpClient.totalTimeoutMillis() * 10, + return latch.await(httpClient.totalTimeoutMillis() * 10, TimeUnit.MILLISECONDS); } catch (InterruptedException e) { throw new HttpException("超时", e); } } + protected HttpResult timeoutResult() { + if (nothrow) { + return new RealHttpResult(this, State.TIMEOUT); + } + throw new HttpException(State.TIMEOUT, "执行超时"); + } + } diff --git a/src/main/java/com/ejlchina/okhttps/internal/AsyncHttpTask.java b/src/main/java/com/ejlchina/okhttps/internal/AsyncHttpTask.java index c0d28ca7..d22f433b 100644 --- a/src/main/java/com/ejlchina/okhttps/internal/AsyncHttpTask.java +++ b/src/main/java/com/ejlchina/okhttps/internal/AsyncHttpTask.java @@ -150,7 +150,10 @@ void setCall(HttpCall call) { @Override public HttpResult getResult() { - timeoutAwait(latch); + if (!timeoutAwait(latch)) { + cancel(); + return timeoutResult(); + } if (canceled || call == null) { return new RealHttpResult(AsyncHttpTask.this, State.CANCELED); } @@ -191,7 +194,10 @@ public boolean isCanceled() { @Override public HttpResult getResult() { if (result == null) { - timeoutAwait(latch); + if (!timeoutAwait(latch)) { + cancel(); + return timeoutResult(); + } } return result; } @@ -202,6 +208,7 @@ void setResult(HttpResult result) { } } + private HttpCall executeCall(Call call) { OkHttpCall httpCall = new OkHttpCall(call); diff --git a/src/main/java/com/ejlchina/okhttps/internal/HttpException.java b/src/main/java/com/ejlchina/okhttps/internal/HttpException.java index f7a8a0d6..60dc6539 100644 --- a/src/main/java/com/ejlchina/okhttps/internal/HttpException.java +++ b/src/main/java/com/ejlchina/okhttps/internal/HttpException.java @@ -27,6 +27,11 @@ public HttpException(HttpResult.State state, String detailMessage, Throwable thr this.state = state; } + public HttpException(HttpResult.State state, String detailMessage) { + super(detailMessage); + this.state = state; + } + public HttpResult.State getState() { return state; } diff --git a/src/main/java/com/ejlchina/okhttps/internal/SyncHttpTask.java b/src/main/java/com/ejlchina/okhttps/internal/SyncHttpTask.java index d40a7855..ef3d16a6 100644 --- a/src/main/java/com/ejlchina/okhttps/internal/SyncHttpTask.java +++ b/src/main/java/com/ejlchina/okhttps/internal/SyncHttpTask.java @@ -55,7 +55,7 @@ public HttpResult delete() { return request("DELETE"); } - static class SyncCall implements Cancelable { + static class SyncHttpCall implements Cancelable { Call call; boolean done = false; @@ -77,33 +77,38 @@ public synchronized boolean cancel() { private HttpResult request(String method) { RealHttpResult result = new RealHttpResult(this, httpClient.getExecutor()); - SyncCall syncCall = new SyncCall(); + SyncHttpCall httpCall = new SyncHttpCall(); // 注册标签任务 - registeTagTask(syncCall); + registeTagTask(httpCall); CountDownLatch latch = new CountDownLatch(1); httpClient.preprocess(this, () -> { - synchronized (syncCall) { - if (syncCall.canceled) { + synchronized (httpCall) { + if (httpCall.canceled) { result.exception(State.CANCELED, null); latch.countDown(); return; } - syncCall.call = prepareCall(method); + httpCall.call = prepareCall(method); } try { - result.response(syncCall.call.execute()); - syncCall.done = true; + result.response(httpCall.call.execute()); + httpCall.done = true; } catch (IOException e) { result.exception(toState(e, true), e); } finally { latch.countDown(); } }); + boolean timeout = false; if (result.getState() == null) { - timeoutAwait(latch); + timeout = !timeoutAwait(latch); } // 移除标签任务 removeTagTask(); + if (timeout) { + httpCall.cancel(); + return timeoutResult(); + } IOException e = result.getError(); State state = result.getState(); if (e != null && state != State.CANCELED From dd3e672d0e32d5116a54128dfeb7ea2f1c19599f Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?=E5=91=A8=E6=97=AD?= Date: Tue, 14 Apr 2020 20:33:57 +0800 Subject: [PATCH 135/924] =?UTF-8?q?=E6=96=87=E6=A1=A3=E6=B3=A8=E9=87=8A?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- src/main/java/com/ejlchina/okhttps/HTTP.java | 2 +- src/main/java/com/ejlchina/okhttps/HttpTask.java | 1 + src/main/java/com/ejlchina/okhttps/HttpUtils.java | 2 +- 3 files changed, 3 insertions(+), 2 deletions(-) diff --git a/src/main/java/com/ejlchina/okhttps/HTTP.java b/src/main/java/com/ejlchina/okhttps/HTTP.java index 7b768f6f..f5c67a8e 100644 --- a/src/main/java/com/ejlchina/okhttps/HTTP.java +++ b/src/main/java/com/ejlchina/okhttps/HTTP.java @@ -69,7 +69,7 @@ public interface HTTP { * * @param request 请求 * @param listener 监听器 - * @return + * @return Websocket */ WebSocket webSocket(Request request, WebSocketListener listener); diff --git a/src/main/java/com/ejlchina/okhttps/HttpTask.java b/src/main/java/com/ejlchina/okhttps/HttpTask.java index 0d8c3ecb..3eb3932a 100644 --- a/src/main/java/com/ejlchina/okhttps/HttpTask.java +++ b/src/main/java/com/ejlchina/okhttps/HttpTask.java @@ -152,6 +152,7 @@ public C nextOnIO() { /** * 绑定一个对象 + * @param object 对象 * @return HttpTask 实例 */ public C bind(Object object) { diff --git a/src/main/java/com/ejlchina/okhttps/HttpUtils.java b/src/main/java/com/ejlchina/okhttps/HttpUtils.java index 965ac96f..ae36b8f2 100644 --- a/src/main/java/com/ejlchina/okhttps/HttpUtils.java +++ b/src/main/java/com/ejlchina/okhttps/HttpUtils.java @@ -114,7 +114,7 @@ public static Call request(Request request) { * Websocket（该请求不经过 预处理器） * @param request 请求 * @param listener 监听器 - * @return + * @return WebSocket */ public static WebSocket webSocket(Request request, WebSocketListener listener) { return getHttp().webSocket(request, listener); From e5da47c0e3740f5671e6b2e8b5b2a4418fb16289 Mon Sep 17 00:00:00 2001 From: ejlchina Date: Wed, 15 Apr 2020 14:55:54 +0800 Subject: [PATCH 136/924] update README.md. --- README.md | 14 ++++++++------ 1 file changed, 8 insertions(+), 6 deletions(-) diff --git a/README.md b/README.md index ff35cc34..4089aa46 100644 --- a/README.md +++ b/README.md @@ -58,8 +58,9 @@ + [10 异常处理](#10-异常处理) - [10.1 同步请求的异常](#101-同步请求的异常) - [10.2 异步请求的异常](#102-异步请求的异常) - + [11 回调线程自由切换（for Android）](#11-回调线程自由切换for-android) - + [12 实现生命周期绑定（for Android）](#12-实现生命周期绑定for-android) + + [11 请求的取消](#11-请求的取消) + + [12 回调线程自由切换（for Android）](#12-回调线程自由切换for-android) + + [13 实现生命周期绑定（for Android）](#13-实现生命周期绑定for-android) + [后期计划（v1.1.0）](#后期计划v110) + [联系方式](#联系方式) + [参与贡献](#参与贡献) @@ -72,12 +73,12 @@ com.ejlchina okhttps - 1.0.3 + 1.0.4 ``` ### Gradle -`implementation 'com.ejlchina:okhttps:1.0.3'` +`implementation 'com.ejlchina:okhttps:1.0.4'` ## 使用说明 @@ -837,8 +838,9 @@ http.async("/users/1") }) .get(); ``` +### 11 请求的取消 -### 11 回调线程自由切换（for Android） +### 12 回调线程自由切换（for Android） 　　在 Android 开发中，经常会把某些代码放到特点的线程去执行，比如网络请求响应后的页面更新在主线程（UI线程）执行，而保存文件则在IO线程操作。OkHttps 为这类问题提供了良好的方案。 @@ -913,7 +915,7 @@ http.sync("/download/test.zip") }) .start(); ``` -### 12 实现生命周期绑定（for Android） +### 13 实现生命周期绑定（for Android） 文档完善中，敬请期待... From ff72a2db7f12699562a297ea7f74105196b83bfb Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?=E5=91=A8=E6=97=AD?= Date: Wed, 15 Apr 2020 15:13:55 +0800 Subject: [PATCH 137/924] =?UTF-8?q?read=20me:=20=E8=AF=B7=E6=B1=82?= =?UTF-8?q?=E7=9A=84=E5=8F=96=E6=B6=88?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- README.md | 7 +++++++ 1 file changed, 7 insertions(+) diff --git a/README.md b/README.md index 4089aa46..40890e12 100644 --- a/README.md +++ b/README.md @@ -840,6 +840,13 @@ http.async("/users/1") ``` ### 11 请求的取消 +　　在 OkHttps 里取消某个请求有多种方式： + +* 使用`HttpCall#cancel()`取消请求（适用于异步请求） +* 使用`HttpTask#cancel()`取消请求（适用于所有请求）（since v1.0.4） +* 使用`HTTP.cancel(String tag)`批量取消请求（适用于所有请求） +* 使用`HTTP.cancelAll()`取消所有请求（适用于所有请求）（since v1.0.2） + ### 12 回调线程自由切换（for Android） 　　在 Android 开发中，经常会把某些代码放到特点的线程去执行，比如网络请求响应后的页面更新在主线程（UI线程）执行，而保存文件则在IO线程操作。OkHttps 为这类问题提供了良好的方案。 From 9f092750ea0b91ed47a9d872f58d448e4d48be2d Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?=E5=91=A8=E6=97=AD?= Date: Wed, 15 Apr 2020 15:15:13 +0800 Subject: [PATCH 138/924] readme --- README.md | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/README.md b/README.md index 40890e12..25b6b71d 100644 --- a/README.md +++ b/README.md @@ -842,8 +842,8 @@ http.async("/users/1") 　　在 OkHttps 里取消某个请求有多种方式： -* 使用`HttpCall#cancel()`取消请求（适用于异步请求） -* 使用`HttpTask#cancel()`取消请求（适用于所有请求）（since v1.0.4） +* 使用`HttpCall#cancel()`取消单个请求（适用于异步请求） +* 使用`HttpTask#cancel()`取消单个请求（适用于所有请求）（since v1.0.4） * 使用`HTTP.cancel(String tag)`批量取消请求（适用于所有请求） * 使用`HTTP.cancelAll()`取消所有请求（适用于所有请求）（since v1.0.2） From 5b02073b581037af2ed9e1aeb2afd33ea3c17c02 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?=E5=91=A8=E6=97=AD?= Date: Wed, 15 Apr 2020 15:18:21 +0800 Subject: [PATCH 139/924] readme --- README.md | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/README.md b/README.md index 25b6b71d..a0bfae18 100644 --- a/README.md +++ b/README.md @@ -844,8 +844,8 @@ http.async("/users/1") * 使用`HttpCall#cancel()`取消单个请求（适用于异步请求） * 使用`HttpTask#cancel()`取消单个请求（适用于所有请求）（since v1.0.4） -* 使用`HTTP.cancel(String tag)`批量取消请求（适用于所有请求） -* 使用`HTTP.cancelAll()`取消所有请求（适用于所有请求）（since v1.0.2） +* 使用`HTTP#cancel(String tag)`批量取消请求（适用于所有请求） +* 使用`HTTP#cancelAll()`取消所有请求（适用于所有请求）（since v1.0.2） ### 12 回调线程自由切换（for Android） From 0577b4c14ea9d5770e5cf15bc6e84dd8d689b1b9 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?=E5=91=A8=E6=97=AD?= Date: Wed, 15 Apr 2020 15:29:50 +0800 Subject: [PATCH 140/924] readme --- README.md | 28 ++++++++++++++++++++++++++-- 1 file changed, 26 insertions(+), 2 deletions(-) diff --git a/README.md b/README.md index a0bfae18..4bfb6422 100644 --- a/README.md +++ b/README.md @@ -842,11 +842,35 @@ http.async("/users/1") 　　在 OkHttps 里取消某个请求有多种方式： -* 使用`HttpCall#cancel()`取消单个请求（适用于异步请求） +* 使用`HttpCall#cancel()`取消单个请求（适用于异步请求，[详见 3.3 章节](#33-httpcall)） * 使用`HttpTask#cancel()`取消单个请求（适用于所有请求）（since v1.0.4） -* 使用`HTTP#cancel(String tag)`批量取消请求（适用于所有请求） + +```java +HttpTask task = http.async("/users") + .setOnResponse((HttpResult result) -> { + // 响应回调 + }); + +task.get(); // 发起 GET 请求 + +// 取消请求，并返回是否取消成功 +boolean canceled = task.cancel(); +``` + +* 使用`HTTP#cancel(String tag)`批量取消请求（适用于所有请求，[详见第 5 章节](#5-使用标签)） * 使用`HTTP#cancelAll()`取消所有请求（适用于所有请求）（since v1.0.2） +```java +http.async("/users") + .setOnResponse((HttpResult result) -> { + + }) + .get(); + +// 取消所有请求 +http.cancelAll(); +``` + ### 12 回调线程自由切换（for Android） 　　在 Android 开发中，经常会把某些代码放到特点的线程去执行，比如网络请求响应后的页面更新在主线程（UI线程）执行，而保存文件则在IO线程操作。OkHttps 为这类问题提供了良好的方案。 From db9e1c03f064bcd7eb0e6c89b95b30ef279cdd3e Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?=E5=91=A8=E6=97=AD?= Date: Wed, 15 Apr 2020 15:31:45 +0800 Subject: [PATCH 141/924] readme --- README.md | 11 ++--------- 1 file changed, 2 insertions(+), 9 deletions(-) diff --git a/README.md b/README.md index 4bfb6422..b2234441 100644 --- a/README.md +++ b/README.md @@ -857,18 +857,11 @@ task.get(); // 发起 GET 请求 boolean canceled = task.cancel(); ``` -* 使用`HTTP#cancel(String tag)`批量取消请求（适用于所有请求，[详见第 5 章节](#5-使用标签)） +* 使用`HTTP#cancel(String tag)`按标签批量取消请求（适用于所有请求，[详见第 5 章节](#5-使用标签)） * 使用`HTTP#cancelAll()`取消所有请求（适用于所有请求）（since v1.0.2） ```java -http.async("/users") - .setOnResponse((HttpResult result) -> { - - }) - .get(); - -// 取消所有请求 -http.cancelAll(); +http.cancelAll(); // 取消所有请求 ``` ### 12 回调线程自由切换（for Android） From 5156ddaccc817dddfc5fcffa2335b4021ed80139 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?=E5=91=A8=E6=97=AD?= Date: Wed, 15 Apr 2020 15:37:15 +0800 Subject: [PATCH 142/924] readme --- README.md | 6 +++--- 1 file changed, 3 insertions(+), 3 deletions(-) diff --git a/README.md b/README.md index b2234441..439d6bc5 100644 --- a/README.md +++ b/README.md @@ -58,7 +58,7 @@ + [10 异常处理](#10-异常处理) - [10.1 同步请求的异常](#101-同步请求的异常) - [10.2 异步请求的异常](#102-异步请求的异常) - + [11 请求的取消](#11-请求的取消) + + [11 取消请求的4种方式](#11-取消请求的4种方式) + [12 回调线程自由切换（for Android）](#12-回调线程自由切换for-android) + [13 实现生命周期绑定（for Android）](#13-实现生命周期绑定for-android) + [后期计划（v1.1.0）](#后期计划v110) @@ -838,9 +838,9 @@ http.async("/users/1") }) .get(); ``` -### 11 请求的取消 +### 11 取消请求的4种方式 -　　在 OkHttps 里取消某个请求有多种方式： +　　在 OkHttps 里取消请求共有 4 种方式： * 使用`HttpCall#cancel()`取消单个请求（适用于异步请求，[详见 3.3 章节](#33-httpcall)） * 使用`HttpTask#cancel()`取消单个请求（适用于所有请求）（since v1.0.4） From 7853a5019a484b0d7b2d31fa398f3f8858dc6228 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?=E5=91=A8=E6=97=AD?= Date: Wed, 15 Apr 2020 15:38:09 +0800 Subject: [PATCH 143/924] readme --- README.md | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/README.md b/README.md index 439d6bc5..796bb0a4 100644 --- a/README.md +++ b/README.md @@ -840,7 +840,7 @@ http.async("/users/1") ``` ### 11 取消请求的4种方式 -　　在 OkHttps 里取消请求共有 4 种方式： +　　在 OkHttps 里取消请求共有 **4 种** 方式： * 使用`HttpCall#cancel()`取消单个请求（适用于异步请求，[详见 3.3 章节](#33-httpcall)） * 使用`HttpTask#cancel()`取消单个请求（适用于所有请求）（since v1.0.4） From 99c4d099feaa79fae503c5a80a77592dc45117aa Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?=E5=91=A8=E6=97=AD?= Date: Wed, 15 Apr 2020 15:45:20 +0800 Subject: [PATCH 144/924] =?UTF-8?q?readme=EF=BC=9A=E7=94=9F=E5=91=BD?= =?UTF-8?q?=E5=91=A8=E6=9C=9F=E7=BB=91=E5=AE=9A?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- README.md | 7 ++++++- 1 file changed, 6 insertions(+), 1 deletion(-) diff --git a/README.md b/README.md index 796bb0a4..6d28a19b 100644 --- a/README.md +++ b/README.md @@ -840,7 +840,7 @@ http.async("/users/1") ``` ### 11 取消请求的4种方式 -　　在 OkHttps 里取消请求共有 **4 种** 方式： +　　在 OkHttps 里取消请求共有 **4 种** 方式可选： * 使用`HttpCall#cancel()`取消单个请求（适用于异步请求，[详见 3.3 章节](#33-httpcall)） * 使用`HttpTask#cancel()`取消单个请求（适用于所有请求）（since v1.0.4） @@ -941,6 +941,11 @@ http.sync("/download/test.zip") ``` ### 13 实现生命周期绑定（for Android） +　　由于 OkHttps 并不依赖于 Android，所以它并没有直接提供关于生命周期绑定的实现，但它的一些扩展机制让我们很容易就可以实现这个功能。 + + + + 文档完善中，敬请期待... ## 后期计划（v1.1.0） From 56d120e654fe1401d35d4a43f0efcfa5876d80eb Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?=E5=91=A8=E6=97=AD?= Date: Wed, 15 Apr 2020 15:55:26 +0800 Subject: [PATCH 145/924] readme --- README.md | 3 ++- 1 file changed, 2 insertions(+), 1 deletion(-) diff --git a/README.md b/README.md index 6d28a19b..367e03c0 100644 --- a/README.md +++ b/README.md @@ -941,8 +941,9 @@ http.sync("/download/test.zip") ``` ### 13 实现生命周期绑定（for Android） -　　由于 OkHttps 并不依赖于 Android，所以它并没有直接提供关于生命周期绑定的实现，但它的一些扩展机制让我们很容易就可以实现这个功能。 +　　由于 OkHttps 并不依赖于 Android，所以它并没有直接提供关于生命周期绑定的实现，但它的一些扩展机制让我们很容易就可以实现这个功能。在开始之前，我们首先要理解何为生命周期绑定： +> 所谓的生命周期绑定：即是让 HTTP 任务感知其所属的 Activity 或 Fragment 的生命周期，当 Activity 或 Fragment 将被销毁时，框架应自动的把由它们发起的但尚未完成的 HTTP 任务全部取消，以免导致程序出错！ From 7d9dacd8962324d277b844c7fd1686c68b17759d Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?=E5=91=A8=E6=97=AD?= Date: Wed, 15 Apr 2020 16:08:26 +0800 Subject: [PATCH 146/924] =?UTF-8?q?readme:=20=E7=94=9F=E5=91=BD=E5=91=A8?= =?UTF-8?q?=E6=9C=9F=E7=BB=91=E5=AE=9A=EF=BC=88for=20Android=EF=BC=89?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- README.md | 14 +++++++++++++- 1 file changed, 13 insertions(+), 1 deletion(-) diff --git a/README.md b/README.md index 367e03c0..0aa61aed 100644 --- a/README.md +++ b/README.md @@ -941,10 +941,22 @@ http.sync("/download/test.zip") ``` ### 13 实现生命周期绑定（for Android） -　　由于 OkHttps 并不依赖于 Android，所以它并没有直接提供关于生命周期绑定的实现，但它的一些扩展机制让我们很容易就可以实现这个功能。在开始之前，我们首先要理解何为生命周期绑定： +　　由于 OkHttps 并不依赖于 Android，所以它并没有提供关于生命周期绑定的直接实现，但它的一些扩展机制让我们很容易就可以实现这个需求。在开始之前，我们首先要理解何为生命周期绑定： > 所谓的生命周期绑定：即是让 HTTP 任务感知其所属的 Activity 或 Fragment 的生命周期，当 Activity 或 Fragment 将被销毁时，框架应自动的把由它们发起的但尚未完成的 HTTP 任务全部取消，以免导致程序出错！ +　　现在我们需要手写一个工具类，这个工具类具有生命周期绑定的功能，假设我们把它取名叫`OkHttps`，在 androidx 的开发环境里，它的使用效果如下： + +```java +// 在 Activity 或 Fragment 内发起请求 +OkHttps.async("http://www.baidu.com") + .bind(getLifecycle()) // 绑定Activity 或 Fragment 的生命周期，getLifecycle()是Activity 或 Fragment 自带的方法 + .setOnResponse((HttpResult result) -> { + Log.i("FirstFragment", "收到请求：" + result.toString()); + }) + .get(); +``` + 文档完善中，敬请期待... From 8b02d424d5310c10a4ba5d3c67d1d78e28f1c120 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?=E5=91=A8=E6=97=AD?= Date: Wed, 15 Apr 2020 16:09:20 +0800 Subject: [PATCH 147/924] =?UTF-8?q?=E3=80=82?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- README.md | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/README.md b/README.md index 0aa61aed..6c2887e6 100644 --- a/README.md +++ b/README.md @@ -948,9 +948,9 @@ http.sync("/download/test.zip") 　　现在我们需要手写一个工具类，这个工具类具有生命周期绑定的功能，假设我们把它取名叫`OkHttps`，在 androidx 的开发环境里，它的使用效果如下： ```java -// 在 Activity 或 Fragment 内发起请求 +// 在 Activity 或 Fragment 内发起请，getLifecycle()是Activity 或 Fragment 自带的方法 OkHttps.async("http://www.baidu.com") - .bind(getLifecycle()) // 绑定Activity 或 Fragment 的生命周期，getLifecycle()是Activity 或 Fragment 自带的方法 + .bind(getLifecycle()) // 绑定Activity 或 Fragment 的生命周期 .setOnResponse((HttpResult result) -> { Log.i("FirstFragment", "收到请求：" + result.toString()); }) From c806ebb8c044a776878d7e864a3bc97be543db2a Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?=E5=91=A8=E6=97=AD?= Date: Wed, 15 Apr 2020 18:11:45 +0800 Subject: [PATCH 148/924] readme --- README.md | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/README.md b/README.md index 6c2887e6..a5a70c21 100644 --- a/README.md +++ b/README.md @@ -945,11 +945,11 @@ http.sync("/download/test.zip") > 所谓的生命周期绑定：即是让 HTTP 任务感知其所属的 Activity 或 Fragment 的生命周期，当 Activity 或 Fragment 将被销毁时，框架应自动的把由它们发起的但尚未完成的 HTTP 任务全部取消，以免导致程序出错！ -　　现在我们需要手写一个工具类，这个工具类具有生命周期绑定的功能，假设我们把它取名叫`OkHttps`，在 androidx 的开发环境里，它的使用效果如下： +　　现在我们需要对`HTTP`实例进行配置，配置后的`HTTP`实例具有生命周期绑定的功能，在 androidx 的开发环境里，它的使用效果如下： ```java // 在 Activity 或 Fragment 内发起请，getLifecycle()是Activity 或 Fragment 自带的方法 -OkHttps.async("http://www.baidu.com") +http.async("http://www.baidu.com") .bind(getLifecycle()) // 绑定Activity 或 Fragment 的生命周期 .setOnResponse((HttpResult result) -> { Log.i("FirstFragment", "收到请求：" + result.toString()); From 16cb05f778c24bbdc5a498d426d78ac71d1245e7 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?=E5=91=A8=E6=97=AD?= Date: Wed, 15 Apr 2020 19:11:36 +0800 Subject: [PATCH 149/924] readme --- README.md | 8 +++++--- 1 file changed, 5 insertions(+), 3 deletions(-) diff --git a/README.md b/README.md index a5a70c21..6bf6b4ab 100644 --- a/README.md +++ b/README.md @@ -945,17 +945,19 @@ http.sync("/download/test.zip") > 所谓的生命周期绑定：即是让 HTTP 任务感知其所属的 Activity 或 Fragment 的生命周期，当 Activity 或 Fragment 将被销毁时，框架应自动的把由它们发起的但尚未完成的 HTTP 任务全部取消，以免导致程序出错！ -　　现在我们需要对`HTTP`实例进行配置，配置后的`HTTP`实例具有生命周期绑定的功能，在 androidx 的开发环境里，它的使用效果如下： +　　现在我们需要对`HTTP`实例进行配置，配置后的`HTTP`实例具有生命周期绑定的功能，在`androidx`的开发环境里，它的使用效果如下： ```java -// 在 Activity 或 Fragment 内发起请，getLifecycle()是Activity 或 Fragment 自带的方法 +// 在 Activity 或 Fragment 内发起请，getLifecycle() 是 Activity 或 Fragment 自带的方法 http.async("http://www.baidu.com") - .bind(getLifecycle()) // 绑定Activity 或 Fragment 的生命周期 + .bind(getLifecycle()) // 绑定生命周期 .setOnResponse((HttpResult result) -> { Log.i("FirstFragment", "收到请求：" + result.toString()); }) .get(); ``` +　　上述代码中的`getLifecycle()`是`androidx`中`Activity`或`Fragment`自带的方法，而`bind()`是`HttpTask`的现有方法。在配置好`HTTP`实例后，上述代码发起的请求便可以感知`Activity`或`Fragment`的生命周期。 +　　那`HTTP`实例到底该如何配置呢？ From 8d109beb477b40753aa7f3ca610aebe8b7825e95 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?=E5=91=A8=E6=97=AD?= Date: Wed, 15 Apr 2020 19:12:00 +0800 Subject: [PATCH 150/924] radme --- README.md | 1 + 1 file changed, 1 insertion(+) diff --git a/README.md b/README.md index 6bf6b4ab..e77a4135 100644 --- a/README.md +++ b/README.md @@ -957,6 +957,7 @@ http.async("http://www.baidu.com") .get(); ``` 　　上述代码中的`getLifecycle()`是`androidx`中`Activity`或`Fragment`自带的方法，而`bind()`是`HttpTask`的现有方法。在配置好`HTTP`实例后，上述代码发起的请求便可以感知`Activity`或`Fragment`的生命周期。 + 　　那`HTTP`实例到底该如何配置呢？ From 29bfd74523c6685ba406f2a92387335ca0bbcf9e Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?=E5=91=A8=E6=97=AD?= Date: Wed, 15 Apr 2020 19:23:16 +0800 Subject: [PATCH 151/924] =?UTF-8?q?=E3=80=82?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- README.md | 63 +++++++++++++++++++++++++++++++++++++++++++++++++++++++ 1 file changed, 63 insertions(+) diff --git a/README.md b/README.md index e77a4135..5482ae61 100644 --- a/README.md +++ b/README.md @@ -960,6 +960,69 @@ http.async("http://www.baidu.com") 　　那`HTTP`实例到底该如何配置呢？ +#### 第一步：配置预处理器 + +```java +HTTP http = HTTP.builder() + ... // 省略其它配置项 + .addPreprocessor((Preprocessor.PreChain chain) -> { + HttpTask task = chain.getTask(); + Object bound = task.getBound(); + // 判断 task 是否绑定了 Lifecycle 对象 + if (bound instanceof Lifecycle) { + // 重新绑定一个 生命周期监视器（LCObserver），它的定义见下一步 + task.bind(new LCObserver(task, (Lifecycle) bound)); + } + chain.proceed(); + }) + ... // 省略其它配置项 + .build(); +``` + +#### 第二步：定义生命周期监视器 + +```java +public class LCObserver implements LifecycleObserver { + + HttpTask task; + Lifecycle lifecycle; + + LCObserver(HttpTask task, Lifecycle lifecycle) { + this.task = task; + this.lifecycle = lifecycle; + lifecycle.addObserver(this); + } + + @OnLifecycleEvent(Lifecycle.Event.ON_STOP) + public void onStop() { + task.cancel(); // 在 ON_STOP 事件中，取消对应的 HTTP 任务 + } + + void unbind() { + lifecycle.removeObserver(this); + } + +} +``` + +#### 第三步：配置全局回调监听 + +```java +HTTP http = HTTP.builder() + ... // 省略其它配置项 + .completeListener((HttpTask task, HttpResult.State state) -> { + Object bound = task.getBound(); + // 判断 task 是否绑定了生命周期监视器（LCObserver）对象 + if (bound instanceof LCObserver) { + // 解绑监视器 + ((LCObserver) bound).unbind(); + } + return true; + }) + ... // 省略其它配置项 + .build(); +``` + 文档完善中，敬请期待... From fdaf567d221518b1a741c37fa197175b5d35c8e1 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?=E5=91=A8=E6=97=AD?= Date: Wed, 15 Apr 2020 19:40:16 +0800 Subject: [PATCH 152/924] =?UTF-8?q?README=EF=BC=9AAndroid=E4=B8=AD?= =?UTF-8?q?=E5=AE=9E=E7=8E=B0=E4=BA=86=E7=94=9F=E5=91=BD=E5=91=A8=E6=9C=9F?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- README.md | 7 ++++++- 1 file changed, 6 insertions(+), 1 deletion(-) diff --git a/README.md b/README.md index 5482ae61..a7390596 100644 --- a/README.md +++ b/README.md @@ -1007,6 +1007,8 @@ public class LCObserver implements LifecycleObserver { #### 第三步：配置全局回调监听 +　　以上两步其实已经实现了生命周期绑定的功能，但是在请求完成之后，我们需要移除生命周期监视器（LCObserver）对象： + ```java HTTP http = HTTP.builder() ... // 省略其它配置项 @@ -1023,9 +1025,12 @@ HTTP http = HTTP.builder() .build(); ``` +####　以上三步便在Android中实现了生命周期与HTTP请求绑定的功能 + +　　非常简单，懒得敲代码的同学还可以 [点这里 OkHttps.java](https://gitee.com/ejlchina-zhxu/okhttps-android-demo/blob/master/app/src/main/java/com/flower/myapplication/http/OkHttps.java) 直接下载封装好的源码，其中不仅编写了生命周期绑定的配置，还有在UI线程执行回调的配置。 +　　有需要的同学，可以直接下载下来使用，还可以再其上再次扩展，比如实现自动添加 TOKEN 的功能，具体可以参考[6.5 串行预处理器（TOKEN问题最佳解决方案）](#65-串行预处理器token问题最佳解决方案)。 -文档完善中，敬请期待... ## 后期计划（v1.1.0） From 2122c5cb2875be70562c3e8b4de69d50f86b2e10 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?=E5=91=A8=E6=97=AD?= Date: Wed, 15 Apr 2020 20:01:56 +0800 Subject: [PATCH 153/924] readme --- README.md | 6 +++--- 1 file changed, 3 insertions(+), 3 deletions(-) diff --git a/README.md b/README.md index a7390596..0dca2155 100644 --- a/README.md +++ b/README.md @@ -970,7 +970,7 @@ HTTP http = HTTP.builder() Object bound = task.getBound(); // 判断 task 是否绑定了 Lifecycle 对象 if (bound instanceof Lifecycle) { - // 重新绑定一个 生命周期监视器（LCObserver），它的定义见下一步 + // 重新绑定一个 生命周期监视器（LCObserver）对象，它的定义见下一步 task.bind(new LCObserver(task, (Lifecycle) bound)); } chain.proceed(); @@ -1007,7 +1007,7 @@ public class LCObserver implements LifecycleObserver { #### 第三步：配置全局回调监听 -　　以上两步其实已经实现了生命周期绑定的功能，但是在请求完成之后，我们需要移除生命周期监视器（LCObserver）对象： +　　以上两步其实已经实现了生命周期绑定的功能，但是在请求完成之后，我们需要在`lifecycle`中移除`LCObserver`对象： ```java HTTP http = HTTP.builder() @@ -1029,7 +1029,7 @@ HTTP http = HTTP.builder() 　　非常简单，懒得敲代码的同学还可以 [点这里 OkHttps.java](https://gitee.com/ejlchina-zhxu/okhttps-android-demo/blob/master/app/src/main/java/com/flower/myapplication/http/OkHttps.java) 直接下载封装好的源码，其中不仅编写了生命周期绑定的配置，还有在UI线程执行回调的配置。 -　　有需要的同学，可以直接下载下来使用，还可以再其上再次扩展，比如实现自动添加 TOKEN 的功能，具体可以参考[6.5 串行预处理器（TOKEN问题最佳解决方案）](#65-串行预处理器token问题最佳解决方案)。 +　　有需要的同学，可以直接下载下来使用，还可以基于它再次扩展，比如实现自动添加 TOKEN 的功能，具体可以参考[6.5 串行预处理器（TOKEN问题最佳解决方案）](#65-串行预处理器token问题最佳解决方案)。 ## 后期计划（v1.1.0） From aea6951c85cfc2f2dc4d1ef4972a100ff8a76421 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?=E5=91=A8=E6=97=AD?= Date: Wed, 15 Apr 2020 20:05:35 +0800 Subject: [PATCH 154/924] readme --- README.md | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/README.md b/README.md index 0dca2155..4713d05c 100644 --- a/README.md +++ b/README.md @@ -240,7 +240,7 @@ long size = http.sync("/download/test.zip") .close() // 只是想获得文件大小，不消费报文体，所以直接关闭 .getContentLength(); // 获得待下载文件的大小 -// 由于未消费报文体，所以本次请求不会消耗下载报文体的时间和网络流量） +// 由于未消费报文体，所以本次请求不会消耗下载报文体的时间和网络流量 System.out.println("size = " + size); ``` From 07293f4e2d4e3793d615c8020132bfc5f80c516a Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?=E5=91=A8=E6=97=AD?= Date: Thu, 16 Apr 2020 09:12:05 +0800 Subject: [PATCH 155/924] readme --- README.md | 16 +++++++++++----- 1 file changed, 11 insertions(+), 5 deletions(-) diff --git a/README.md b/README.md index 4713d05c..2ae9958f 100644 --- a/README.md +++ b/README.md @@ -310,19 +310,25 @@ System.out.println(call.isCanceled()); // true ```java http.async("/users") //（1） - .setTag("A").get(); + .setTag("A") + .get(); http.async("/users") //（2） - .setTag("A.B").get(); + .setTag("A.B") + .get(); http.async("/users") //（3） - .setTag("B").get(); + .setTag("B") + .get(); http.async("/users") //（4） - .setTag("B.C").get(); + .setTag("B") + .setTag("C") // since v1.0.4, 标签将以追加模式添加 + .get(); http.async("/users") //（5） - .setTag("C").get(); + .setTag("C") + .get(); ``` 　　当使用标签后，就可以按标签批量的对HTTP任务进行取消： From 54f13169289ac8f9e3798b68af8574f66366188a Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?=E5=91=A8=E6=97=AD?= Date: Thu, 16 Apr 2020 09:19:14 +0800 Subject: [PATCH 156/924] readme --- README.md | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/README.md b/README.md index 2ae9958f..a0660d7a 100644 --- a/README.md +++ b/README.md @@ -954,7 +954,7 @@ http.sync("/download/test.zip") 　　现在我们需要对`HTTP`实例进行配置，配置后的`HTTP`实例具有生命周期绑定的功能，在`androidx`的开发环境里，它的使用效果如下： ```java -// 在 Activity 或 Fragment 内发起请，getLifecycle() 是 Activity 或 Fragment 自带的方法 +// 在 Activity 或 Fragment 内发起请求 http.async("http://www.baidu.com") .bind(getLifecycle()) // 绑定生命周期 .setOnResponse((HttpResult result) -> { From 3b136584c6b2f4d97293a6ebdbdfcdc36f7ea9d7 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?=E5=91=A8=E6=97=AD?= Date: Thu, 16 Apr 2020 09:22:14 +0800 Subject: [PATCH 157/924] readme --- README.md | 3 ++- 1 file changed, 2 insertions(+), 1 deletion(-) diff --git a/README.md b/README.md index a0660d7a..96b5bc53 100644 --- a/README.md +++ b/README.md @@ -1004,7 +1004,8 @@ public class LCObserver implements LifecycleObserver { task.cancel(); // 在 ON_STOP 事件中，取消对应的 HTTP 任务 } - void unbind() { + public void unbind() { + // 在请求完成之后移除监视器 lifecycle.removeObserver(this); } From 9b86ebedd8fda8015267c73bec66cb2143120c51 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?=E5=91=A8=E6=97=AD?= Date: Thu, 16 Apr 2020 09:23:42 +0800 Subject: [PATCH 158/924] readme --- README.md | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/README.md b/README.md index 96b5bc53..9c8de12e 100644 --- a/README.md +++ b/README.md @@ -1032,7 +1032,7 @@ HTTP http = HTTP.builder() .build(); ``` -####　以上三步便在Android中实现了生命周期与HTTP请求绑定的功能 +**以上三步便在Android中实现了生命周期与HTTP请求绑定的功能** 　　非常简单，懒得敲代码的同学还可以 [点这里 OkHttps.java](https://gitee.com/ejlchina-zhxu/okhttps-android-demo/blob/master/app/src/main/java/com/flower/myapplication/http/OkHttps.java) 直接下载封装好的源码，其中不仅编写了生命周期绑定的配置，还有在UI线程执行回调的配置。 From 6d46a28665923b813936d55feea880ad641d4871 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?=E5=91=A8=E6=97=AD?= Date: Thu, 16 Apr 2020 09:26:35 +0800 Subject: [PATCH 159/924] readme --- README.md | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/README.md b/README.md index 9c8de12e..55245b38 100644 --- a/README.md +++ b/README.md @@ -1036,7 +1036,7 @@ HTTP http = HTTP.builder() 　　非常简单，懒得敲代码的同学还可以 [点这里 OkHttps.java](https://gitee.com/ejlchina-zhxu/okhttps-android-demo/blob/master/app/src/main/java/com/flower/myapplication/http/OkHttps.java) 直接下载封装好的源码，其中不仅编写了生命周期绑定的配置，还有在UI线程执行回调的配置。 -　　有需要的同学，可以直接下载下来使用，还可以基于它再次扩展，比如实现自动添加 TOKEN 的功能，具体可以参考[6.5 串行预处理器（TOKEN问题最佳解决方案）](#65-串行预处理器token问题最佳解决方案)。 +　　有需要的同学，可以直接下载下来使用，还可以基于它再次扩展，比如实现自动添加 TOKEN 的功能，具体可以参考[6.5 串行预处理器（TOKEN问题最佳解决方案）](#65-串行预处理器token问题最佳解决方案)，再比如扩展实现生命周期与下载事件绑定的功能，都非常简单。 ## 后期计划（v1.1.0） From 0acd3a35cda92308e52904b79e5221469f6a1340 Mon Sep 17 00:00:00 2001 From: ejlchina Date: Thu, 16 Apr 2020 10:14:45 +0800 Subject: [PATCH 160/924] update README.md. --- README.md | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/README.md b/README.md index 55245b38..f47cc19e 100644 --- a/README.md +++ b/README.md @@ -1047,7 +1047,7 @@ HTTP http = HTTP.builder() ## 联系方式 -* 微信： +* 微信： * 邮箱：zhou.xu@ejlchina.com ## 参与贡献 From bf1c874683189899ad8b490656e83bfefbac0dc9 Mon Sep 17 00:00:00 2001 From: ejlchina Date: Thu, 16 Apr 2020 10:15:32 +0800 Subject: [PATCH 161/924] update README.md. --- README.md | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/README.md b/README.md index f47cc19e..9f6d4060 100644 --- a/README.md +++ b/README.md @@ -1047,7 +1047,7 @@ HTTP http = HTTP.builder() ## 联系方式 -* 微信： +* 微信： * 邮箱：zhou.xu@ejlchina.com ## 参与贡献 From 46bd05ed0269493bc2ddcd0361ccb9d1b1831d71 Mon Sep 17 00:00:00 2001 From: ejlchina Date: Thu, 16 Apr 2020 10:18:52 +0800 Subject: [PATCH 162/924] update README.md. --- README.md | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/README.md b/README.md index 9f6d4060..f41cd94b 100644 --- a/README.md +++ b/README.md @@ -1047,7 +1047,7 @@ HTTP http = HTTP.builder() ## 联系方式 -* 微信： +* 微信： * 邮箱：zhou.xu@ejlchina.com ## 参与贡献 From ce8b3a671acfdf3b41b33790db1170b14429385b Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?=E5=91=A8=E6=97=AD?= Date: Thu, 16 Apr 2020 10:23:44 +0800 Subject: [PATCH 163/924] readme --- README.md | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/README.md b/README.md index f41cd94b..c142298f 100644 --- a/README.md +++ b/README.md @@ -1047,7 +1047,7 @@ HTTP http = HTTP.builder() ## 联系方式 -* 微信： +* 微信： * 邮箱：zhou.xu@ejlchina.com ## 参与贡献 From cf58ca8b4a964d0dd987af3851b53f1440a112ec Mon Sep 17 00:00:00 2001 From: ejlchina Date: Thu, 16 Apr 2020 12:19:31 +0800 Subject: [PATCH 164/924] update README.md. --- README.md | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/README.md b/README.md index c142298f..6675dd0c 100644 --- a/README.md +++ b/README.md @@ -1047,7 +1047,7 @@ HTTP http = HTTP.builder() ## 联系方式 -* 微信： +* 微信： * 邮箱：zhou.xu@ejlchina.com ## 参与贡献 From efe5a5b6199dac0f88ce1e7eba56cf30e901caf9 Mon Sep 17 00:00:00 2001 From: ejlchina Date: Sat, 18 Apr 2020 10:56:34 +0800 Subject: [PATCH 165/924] update README.md. --- README.md | 14 +++++++++++++- 1 file changed, 13 insertions(+), 1 deletion(-) diff --git a/README.md b/README.md index 6675dd0c..ddaee286 100644 --- a/README.md +++ b/README.md @@ -69,7 +69,7 @@ ### Maven -``` +```xml com.ejlchina okhttps @@ -80,6 +80,18 @@ `implementation 'com.ejlchina:okhttps:1.0.4'` +安卓中使用需要把 JDK 版本调成 1.8，在 app 模块的 build.gradle 中加入以下配置即可： + +```groovy +android { + // 省略其它配置.. + compileOptions { + sourceCompatibility = 1.8 + targetCompatibility = 1.8 + } +} +``` + ## 使用说明 ### 1 简单示例 From a8c95ae3c2305419b56d6b2085e1e9b3ba27bf90 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?=E5=91=A8=E6=97=AD?= Date: Mon, 20 Apr 2020 09:11:37 +0800 Subject: [PATCH 166/924] update readme --- README.md | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/README.md b/README.md index c142298f..ce55f903 100644 --- a/README.md +++ b/README.md @@ -951,7 +951,7 @@ http.sync("/download/test.zip") > 所谓的生命周期绑定：即是让 HTTP 任务感知其所属的 Activity 或 Fragment 的生命周期，当 Activity 或 Fragment 将被销毁时，框架应自动的把由它们发起的但尚未完成的 HTTP 任务全部取消，以免导致程序出错！ -　　现在我们需要对`HTTP`实例进行配置，配置后的`HTTP`实例具有生命周期绑定的功能，在`androidx`的开发环境里，它的使用效果如下： +　　现在我们需要对`HTTP`实例进行配置，配置后的`HTTP`实例具有生命周期绑定的功能，在`Activity`或`Fragment`里，它的使用效果如下： ```java // 在 Activity 或 Fragment 内发起请求 @@ -962,7 +962,7 @@ http.async("http://www.baidu.com") }) .get(); ``` -　　上述代码中的`getLifecycle()`是`androidx`中`Activity`或`Fragment`自带的方法，而`bind()`是`HttpTask`的现有方法。在配置好`HTTP`实例后，上述代码发起的请求便可以感知`Activity`或`Fragment`的生命周期。 +　　上述代码中的`getLifecycle()`是`Activity`或`Fragment`自带的方法，而`bind()`是`HttpTask`的现有方法。在配置好`HTTP`实例后，上述代码发起的请求便可以感知`Activity`或`Fragment`的生命周期。 　　那`HTTP`实例到底该如何配置呢？ From 2995122cd81187d8980d22d37e569ef81b8f8640 Mon Sep 17 00:00:00 2001 From: ejlchina Date: Tue, 21 Apr 2020 20:30:00 +0800 Subject: [PATCH 167/924] update README.md. --- README.md | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/README.md b/README.md index dcb3ddc1..bc4f67ef 100644 --- a/README.md +++ b/README.md @@ -18,7 +18,7 @@ > OkHttps 非常轻量，自身代码仅 2000 行左右，且有较高的编码质量，sonarqube 分析结果为 3A，[查看报告](https://gitee.com/ejlchina-zhxu/okhttps/quality_analyses?platform=sonar_qube) ### 前世：[HttpUtils, V2.3.0 之后重命名为 OkHttps](https://gitee.com/ejlchina-zhxu/httputils) -### 当前文档版本[1.0.3] +### 当前文档版本[1.0.4] ### API文档：[https://apidoc.gitee.com/ejlchina-zhxu/okhttps](https://apidoc.gitee.com/ejlchina-zhxu/okhttps) ## 目录 From 34ea363e3a4d7e4d625c971a079f7b1b0cb916da Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?=E5=91=A8=E6=97=AD?= Date: Wed, 22 Apr 2020 13:02:53 +0800 Subject: [PATCH 168/924] update readme --- README.md | 5 ++--- 1 file changed, 2 insertions(+), 3 deletions(-) diff --git a/README.md b/README.md index bc4f67ef..3a35714f 100644 --- a/README.md +++ b/README.md @@ -311,8 +311,7 @@ System.out.println(call.isCanceled()); // true * `setTag(String tag)` 为HTTP任务添加标签 * `setRange(long rangeStart)` 设置Range头信息，用于断点续传 -* `setRange(long rangeStart, long rangeEnd)` 设置Range头信息，用于分块下载 -* `setRange(long rangeStart, long rangeEnd)` 设置Range头信息，用于分块下载 +* `setRange(long rangeStart, long rangeEnd)` 设置Range头信息，可用于分块下载 * `bind(Object object)` 绑定一个对象，可用于实现Android里的生命周期绑定 @@ -430,7 +429,7 @@ HTTP http = HTTP.builder() }) .build(); ``` -　　和`Interceptor`一样，`Preprocessor`也可以添加多个。他们之前的区别如下: +　　和`Interceptor`一样，`Preprocessor`也可以添加多个。他们之间的区别如下: > * 拦截器只能处理同步操作，预处理器支持处理异步操作 > * 拦截器都是并行处理请求，预处理器支持串行处理（详见6.5章节） From b3a69a80fe817ce639734aa37d6fc633885f13bb Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?=E5=91=A8=E6=97=AD?= Date: Wed, 22 Apr 2020 20:37:42 +0800 Subject: [PATCH 169/924] update readme --- README.md | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/README.md b/README.md index 3a35714f..7004426a 100644 --- a/README.md +++ b/README.md @@ -334,7 +334,7 @@ http.async("/users") //（3） http.async("/users") //（4） .setTag("B") - .setTag("C") // since v1.0.4, 标签将以追加模式添加 + .setTag("C") // 从 v1.0.4 标签将以追加模式添加，等效于 setTag("B.C") .get(); http.async("/users") //（5） @@ -499,7 +499,7 @@ HTTP http = HTTP.builder() ### 7 使用 HttpUtils 类 -　　类`HttpUtils`本是 1.x 版本里的最重要的核心类，由于在 2.x 版本里抽象出了`HTTP`接口，使得它的重要性已不如往昔。但合理的使用它，仍然可以带来不少便利，特别是在没有IOC容器的环境里，比如在Android开发和一些工具项目的开发中。 +　　类`HttpUtils`本是 [前身 HttpUtils](https://gitee.com/ejlchina-zhxu/httputils) 的 1.x 版本里的最重要的核心类，由于在后来的版本里抽象出了`HTTP`接口，使得它的重要性已不如往昔。但合理的使用它，仍然可以带来不少便利，特别是在没有IOC容器的环境里，比如在Android开发和一些工具项目的开发中。 　　类`HttpUtils`共定义了四个静态方法： From 6b8981cd1d346a1ee26b3a7ec04711902b98ef7c Mon Sep 17 00:00:00 2001 From: ejlchina Date: Thu, 23 Apr 2020 11:35:19 +0800 Subject: [PATCH 170/924] update README.md. --- README.md | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/README.md b/README.md index 7004426a..f8606ccd 100644 --- a/README.md +++ b/README.md @@ -17,7 +17,7 @@ > OkHttps 非常轻量，自身代码仅 2000 行左右，且有较高的编码质量，sonarqube 分析结果为 3A，[查看报告](https://gitee.com/ejlchina-zhxu/okhttps/quality_analyses?platform=sonar_qube) -### 前世：[HttpUtils, V2.3.0 之后重命名为 OkHttps](https://gitee.com/ejlchina-zhxu/httputils) +### 前身：[HttpUtils, V2.3.0 之后重命名为 OkHttps](https://gitee.com/ejlchina-zhxu/httputils) ### 当前文档版本[1.0.4] ### API文档：[https://apidoc.gitee.com/ejlchina-zhxu/okhttps](https://apidoc.gitee.com/ejlchina-zhxu/okhttps) From 09269cb9fefeeccc56707f8ba8b895d680c1a398 Mon Sep 17 00:00:00 2001 From: ejlchina Date: Thu, 23 Apr 2020 17:05:00 +0800 Subject: [PATCH 171/924] =?UTF-8?q?update=20README.md.=20=E6=9B=B4?= =?UTF-8?q?=E6=96=B0=E5=BE=AE=E4=BF=A1=E7=BE=A4=E4=BA=8C=E7=BB=B4=E7=A0=81?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- README.md | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/README.md b/README.md index f8606ccd..d9df88ee 100644 --- a/README.md +++ b/README.md @@ -1058,7 +1058,7 @@ HTTP http = HTTP.builder() ## 联系方式 -* 微信： +* 微信： * 邮箱：zhou.xu@ejlchina.com ## 参与贡献 From 188214d94f1f32e896142e981146fda9098a99c4 Mon Sep 17 00:00:00 2001 From: ejlchina Date: Fri, 24 Apr 2020 12:17:47 +0800 Subject: [PATCH 172/924] update README.md. --- README.md | 5 ++++- 1 file changed, 4 insertions(+), 1 deletion(-) diff --git a/README.md b/README.md index d9df88ee..84f77c0c 100644 --- a/README.md +++ b/README.md @@ -15,7 +15,10 @@ * 单方法回调，充分利用 Lambda 表达式 * TCP连接池、Http2 -> OkHttps 非常轻量，自身代码仅 2000 行左右，且有较高的编码质量，sonarqube 分析结果为 3A，[查看报告](https://gitee.com/ejlchina-zhxu/okhttps/quality_analyses?platform=sonar_qube) +> 1. OkHttps 非常轻量（59Kb），是 Retrofit（124Kb）的一半，并且更加的开箱即用，API 也更加自然和语义化。 +> 2. OkHttps 是一个纯粹的 Java 网络开发包，并不依赖 Android，这一点和 Retrofit 不同 +> 3. OkHttps 用起来很优美，可以像 RxJava 那样链式用，却比 RxJava 更简单。 + ### 前身：[HttpUtils, V2.3.0 之后重命名为 OkHttps](https://gitee.com/ejlchina-zhxu/httputils) ### 当前文档版本[1.0.4] From c8dc1284def6c8cceb3d95ebdb75735da44c6154 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?=E5=91=A8=E6=97=AD?= Date: Sun, 26 Apr 2020 17:25:18 +0800 Subject: [PATCH 173/924] =?UTF-8?q?=E4=BC=98=E5=8C=96=E6=80=A7=E8=83=BD?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- src/main/java/com/ejlchina/okhttps/HttpTask.java | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/src/main/java/com/ejlchina/okhttps/HttpTask.java b/src/main/java/com/ejlchina/okhttps/HttpTask.java index 3eb3932a..848df563 100644 --- a/src/main/java/com/ejlchina/okhttps/HttpTask.java +++ b/src/main/java/com/ejlchina/okhttps/HttpTask.java @@ -526,7 +526,7 @@ static class FilePara { } protected void registeTagTask(Cancelable canceler) { - if (tag != null) { + if (tag != null && tagTask == null) { tagTask = httpClient.addTagTask(tag, canceler, this); } this.canceler = canceler; From d1497bf3b886e7d20ada45d3c87778ed423b0de9 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?=E5=91=A8=E6=97=AD?= Date: Mon, 27 Apr 2020 11:27:57 +0800 Subject: [PATCH 174/924] =?UTF-8?q?=E4=BC=98=E5=8C=96=E5=85=BC=E5=AE=B9?= =?UTF-8?q?=EF=BC=9AHttpTask#doAddParams=20=E5=85=BC=E5=AE=B9=E4=BD=8E?= =?UTF-8?q?=E7=89=88=E6=9C=ACAndroid=EF=BC=8823=E5=8F=8A=E4=BB=A5=E4=B8=8B?= =?UTF-8?q?=EF=BC=89=E7=B3=BB=E7=BB=9F?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- .../java/com/ejlchina/okhttps/HttpTask.java | 38 ++++++++++--------- 1 file changed, 21 insertions(+), 17 deletions(-) diff --git a/src/main/java/com/ejlchina/okhttps/HttpTask.java b/src/main/java/com/ejlchina/okhttps/HttpTask.java index 848df563..369ecc38 100644 --- a/src/main/java/com/ejlchina/okhttps/HttpTask.java +++ b/src/main/java/com/ejlchina/okhttps/HttpTask.java @@ -8,6 +8,7 @@ import java.net.SocketTimeoutException; import java.net.UnknownHostException; import java.util.HashMap; +import java.util.Iterator; import java.util.Map; import java.util.concurrent.CountDownLatch; import java.util.concurrent.TimeUnit; @@ -131,12 +132,12 @@ public C nothrow() { */ public C setTag(String tag) { if (tag != null) { - if (this.tag != null) { - this.tag = this.tag + "." + tag; - } else { - this.tag = tag; - } - updateTagTask(); + if (this.tag != null) { + this.tag = this.tag + "." + tag; + } else { + this.tag = tag; + } + updateTagTask(); } return (C) this; } @@ -335,11 +336,14 @@ public C addBodyParam(Map params) { private void doAddParams(Map taskParams, Map params) { if (params != null) { - params.forEach((String name, Object value) -> { + Iterator it = params.keySet().iterator(); + while (it.hasNext()) { + String name = it.next(); + Object value = params.get(name); if (name != null && value != null) { taskParams.put(name, value.toString()); } - }); + } } } @@ -527,17 +531,17 @@ static class FilePara { protected void registeTagTask(Cancelable canceler) { if (tag != null && tagTask == null) { - tagTask = httpClient.addTagTask(tag, canceler, this); + tagTask = httpClient.addTagTask(tag, canceler, this); } this.canceler = canceler; } private void updateTagTask() { if (tagTask != null) { - tagTask.setTag(tag); + tagTask.setTag(tag); } else if (canceler != null) { - registeTagTask(canceler); + registeTagTask(canceler); } } @@ -751,11 +755,11 @@ protected boolean timeoutAwait(CountDownLatch latch) { } } - protected HttpResult timeoutResult() { - if (nothrow) { - return new RealHttpResult(this, State.TIMEOUT); - } - throw new HttpException(State.TIMEOUT, "执行超时"); - } + protected HttpResult timeoutResult() { + if (nothrow) { + return new RealHttpResult(this, State.TIMEOUT); + } + throw new HttpException(State.TIMEOUT, "执行超时"); + } } From bb6953d9c77b1048b6259a26fb20eda24f7d29f3 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?=E5=91=A8=E6=97=AD?= Date: Mon, 27 Apr 2020 11:37:00 +0800 Subject: [PATCH 175/924] . --- pom.xml | 6 +++--- 1 file changed, 3 insertions(+), 3 deletions(-) diff --git a/pom.xml b/pom.xml index 1cf524f8..ea76c2a4 100644 --- a/pom.xml +++ b/pom.xml @@ -3,7 +3,7 @@ com.ejlchina okhttps - 1.0.4 + 1.0.5 OkHttps @@ -35,7 +35,7 @@ scm:git://gitee.com/ejlchina-zhxu/okhttps.git scm:http://gitee.com/ejlchina-zhxu/okhttps https://gitee.com/ejlchina-zhxu/okhttps - v1.0.4 + v1.0.5 @@ -168,7 +168,7 @@ https://gitee.com/ejlchina-zhxu/okhttps - Http工具包，封装 OkHttp，链式用法、支持异步同步、响应JSON自动解析，回调线程切换、配置灵活、支持URL占位符、支持BaseUrl、外部依赖少、适用 JavaWeb 和 Android，教程全面、简单易用 + 比 Retrofit 更好用的网络框架！ OkHttp3 轻量封装 ，开箱即用、Java领域前后端处理 Http问题的新选择。 江苏一键联信息科技有限公司 http://www.ejlchina.com/ From de0191fbd0b175f571cb4570ec01689043d83115 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?=E5=91=A8=E6=97=AD?= Date: Mon, 27 Apr 2020 12:22:18 +0800 Subject: [PATCH 176/924] V1.0.5 ^_^ --- README.md | 6 +++--- 1 file changed, 3 insertions(+), 3 deletions(-) diff --git a/README.md b/README.md index 84f77c0c..bbbd68dc 100644 --- a/README.md +++ b/README.md @@ -21,7 +21,7 @@ ### 前身：[HttpUtils, V2.3.0 之后重命名为 OkHttps](https://gitee.com/ejlchina-zhxu/httputils) -### 当前文档版本[1.0.4] +### 当前文档版本[1.0.5] ### API文档：[https://apidoc.gitee.com/ejlchina-zhxu/okhttps](https://apidoc.gitee.com/ejlchina-zhxu/okhttps) ## 目录 @@ -76,12 +76,12 @@ com.ejlchina okhttps - 1.0.4 + 1.0.5 ``` ### Gradle -`implementation 'com.ejlchina:okhttps:1.0.4'` +`implementation 'com.ejlchina:okhttps:1.0.5'` 安卓中使用需要把 JDK 版本调成 1.8，在 app 模块的 build.gradle 中加入以下配置即可： From 252d7aa32a78ae5ec5105da22ed7c7b2f14a343e Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?=E5=91=A8=E6=97=AD?= Date: Mon, 27 Apr 2020 21:10:06 +0800 Subject: [PATCH 177/924] =?UTF-8?q?=E7=BD=91=E7=AB=99=E6=96=87=E6=A1=A3?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- docs/.vuepress/config.js | 7 ++++++ docs/.vuepress/public/favicon.png | Bin 0 -> 3471 bytes docs/README.md | 38 ++++++++++++++++++++++++++++++ package.json | 6 +++++ 4 files changed, 51 insertions(+) create mode 100644 docs/.vuepress/config.js create mode 100644 docs/.vuepress/public/favicon.png create mode 100644 docs/README.md create mode 100644 package.json diff --git a/docs/.vuepress/config.js b/docs/.vuepress/config.js new file mode 100644 index 00000000..d9a899ba --- /dev/null +++ b/docs/.vuepress/config.js @@ -0,0 +1,7 @@ +module.exports = { + title: 'OkHttps', + description: 'OkHttps 官网', + head: [ + ['link', { rel: 'icon', href: '/favicon.png' }] + ] +} \ No newline at end of file diff --git a/docs/.vuepress/public/favicon.png b/docs/.vuepress/public/favicon.png new file mode 100644 index 0000000000000000000000000000000000000000..74f9ae7340d0f02d65ab922cfc31f7f80d9c8b36 GIT binary patch literal 3471 zcmV;A4RG>_P)004R>004l5008;`004mK004C`008P>0026e000+ooVrmw00006 zVoOIv00000008+zyMF)x010qNS#tmY3labT3lag+-G2N401Wd z$A26Ss2rn>P!&*wq=^+PGGf89wXxWWRAwlCGEx^;j zGQii`|Ex%R6b3{oZ#-}nFdvvuq!C)Q8F(02qP4%Jhz8^iL@7@J3xLaj;YHkZ1nmc& z0PfM+e=W}o=LW=pSPXnW&l^lZD}Y~IKx==07Iw=7h*I8UU@0&y=BfLD=aEs*>a6}7mGZ^`=KzqK;wf|PyZA%r1QrX)BSD%s)mqa|}Entq;{yUvsyJH|qdD9UCA046i8^Cp1`+x8Bx_L+` z?_0nFz|;uEw*nVv?XU0TnxzgKJPUY{a2R`mMZmPd0s}y6|0U$TvJluEQv7J(MPrl1 zO58(~@-9T?e+~&L`a19vt^MxQEtaE{^1cfE5l|sT_X3w{?XOI7okTsv{1-%l@q1v# zV21&qwZ9QK19&i`=pn$eq&+2e4>9kI7lFeZ#XbdornUcYF4oFfN_q2;Nyrh7V!MH} z;=WU20WqVgS8=~HJ_at<+JB)KbLAuR!e0S=$x&=8a7LWbS7adOJ7YcWq3w3yT&?{L zg<2~oDdn94tOdq6ioFd?kNTYw=^bLez?TpXW7bfC0id=22C}lb-BIi$;1OfPP(^*I zUyJ(-{A1ue)4(Am^Rk}>eB>xL7qMZeLaCXr)(zO_ralF}r?tPPXyX(q^G;cV{YAeA z`3`eVNIH9nnL=NRd!q2#p$-FjKO*NliW~|oH8!;>?2&aH?kV(#wDun=+86^xTKh|Z z-#Us+L)M6_vH~$HeYZQ#?E-#Yv=IiN76AWr9KX%jHc+k}awqnczP-qF$ljvwexONf ze;;r;_PMW7h;0KE_&hTk5`O2n?#){Je=7Rs2da8{-rX^F?1VkYYGja39Xocy%ATHg zd)g1!ddOnO^}2z3^SZf8wJ}h)3WezbWF^$5KpTHy*sGK`HKd}mwf5I$eK(bAV-|2f za0>7ta7VpX{%yj#eu_;09}m0++)%HTGrtF=yl)~~R&6@1eUUDxhb(kduqr1Q7Xr^A zFhI8Q)GF1+T?y*C3wit=Z+@BzJZG+vsm#*!Q;s4F+JEQ=L@Dn$WJjS*H)nkl#!$-% z{=m914ir=N#(+a3faQ5WL2PE*1aVpWh^xJaT#0>q=QCNafrr3oDiRb2jHYsdV!q6m zTMiFL_BZ#c7l_$~?)uWq^hF*KMpI5G5nwcxS5LXmacsV^JzU9jynI4RbvyvXsRES1TdP)qo=r5PkU|OJM2}; zdyimenFer-*8a}4Ti79tR^4s>CV|naPl37hS~<}M1(%fajzEU*K@+uGwDyk!(?g6K znQeaMg#ux0M>ZCOZ5_Iia2V@>(-Ds;n=b3GZU=HC>Tv`vDQ?Hdb0B2DU6u>pzG#mPWoardII?Wcvgz*MIy;j~uawtt0|21{} zo8q86=QwsI^Z}V^DfBO`{mp5$CJBtD5<=+*qouAwplI!X2)t=IJQJW~{J?Fl$9`Ik z=>$eoF`@Jj0HdX@qI$|JmfuG!uEM4_=|EY)Xlf8c+2}Ynsf5H13DOQTc21-$ zVKg-up=j;z0zR-Do>)QxxdbWk=qe8wO$|mUz<(^ik1HWQ-9g%#-5y1e7N# z)rMseBk*Mq0Dg=hzO+wJW{DPj*Vk0 zWG{4(MwSwsWYc$m!yU)tyfZGg{63xZpoDtZMuaj7_gr8sb>#F}kkW)Q;N${wM9jL@ z04}GLF~HhNwQ)*>y23W$r2!>$7Q0eydp zS0TZ{*K6flU6sawF|S@LFN@ILSO4x_DQ6e)0 z8DJ&pLAi+(pqRQg)@$Xz)obMsT;*cIcr1yHkXT+p+F3$EsRk)=9K?YNB}_TN064+& z`}-v%I$MxNn}zvA8f;MVf}xam7%VxilHzB5TlX+Wt| z8>4_#^tl$e^`b8aV6P5B(i#pv2lolA@j&aFAC`G|g$~y-8 zd-)aUn>ulM`J^^+2Fai#gwa$#C(0(LRU$6QB(b|6x$t+{jZCN%RLZL*0(NdQU zN?tt!#Add^#1riqAcEG^UGC3wI*r^MMFz^b^v$#N0M$4!TI#w939r{&_vr@C%L9f9 zt>OBPyQlq!VU~*ij6F3`H=wlkI~l4T@KVYvBMw8h$NUPd{U5adXxnw-T5~>`j9>5v zh_1sOmORkL)(<76yrtOlM(qVo*V^yMUEx5LQr?M3L?v7F??<)v=LH>b?aNw(>^Tb3 zA;4owd10~Nhn$r1Mj}D`Z7_D>@a(bzF>ilY^q(oX13nH_-3y%NIR0x_ZmqDbr1v8+ zdu_T#Des!1Eih1Ig7murgKj_~%~^FYka9}OC6F@o#(Q!_nHvE-rIdGi(MBmsCMf?3 z+{*|Hqomo3y8Hb>>_NCd_NxBXG;B!8WZqeeJ8i|2geQUl4yLQC^O- zRk$;@H5+*gaNl5?B{s9R*CXp1VfVQkNx_;p*!02FtL}TtJ@x9rIT=YNHZA6<`;gcsPXnu6)6^Zd zZye&0dx`lwGG-MUfO%2ors66SAm*lrBg>e#V^5tFrj5uZvUSMtxjXKoK`E~SOh!DH zrX&6tljGFUqFu-u(fwNc`xDmTRAxY03^E?cxpYORbs23#996d=F5REd7yMuZGE;CA z;(B}n3EjH`^eC_>t6tkw=0KV`9G-Z;Rcu2~Ii*S24WuYy|sBRhH zw{CncLWKiqm&p<^8;ONJ6MG24q}qWvSiX!5t-Cs`FI5dVAnh`t(5E0fCMO|bZO0)a xsnLA#8)6?~^qt6l-c3lfif*9GxPcE?{U0r~qwQ(G{XhT!002ovPDHLkV1n9jU1$IR literal 0 HcmV?d00001 diff --git a/docs/README.md b/docs/README.md new file mode 100644 index 00000000..92e32024 --- /dev/null +++ b/docs/README.md @@ -0,0 +1,38 @@ +--- +home: true +heroText: OkHttps +tagline: 安卓和Java领域开箱即用的 HTTP 客户端 +actionText: 快速上手 → +actionLink: /zh/guide/ +features: +- title: 轻量纯粹优雅 + details: OkHttps 非常轻量，体积仅是 Retrofit 的一半不到，并且不依赖于特定平台，API 语义简洁舒适。 +- title: 开箱即用的功能 + details: 异步预处理器、回调执行器、全局监听器、回调阻断机制、文件上传下载、过程控制、进度监听。 +- title: 更多实用特性 + details: URL 占位符、Lambda 回调、JSON自动封装解析、OkHttp 的特性：拦截器、连接池、CookieJar 等。 + +footer: Apache Licensed | Copyright © 2020-present Troy Zhou +--- + + +```java +// 构建 HTTP +HTTP http = HTTP.builder() + .baseUrl("http://api.demo.com") + .build(); + +// 同步请求 +List users = http.sync("/users") // http://api.demo.com/users + .get() // GET请求 + .getBody() // 获取响应报文体 + .toList(User.class); // 得到目标数据 + +// 异步请求 +http.async("/users/jack") // http://api.demo.com/users/jack + .setOnResponse((HttpResult result) -> { + // 得到目标数据 + User jack = result.getBody().toBean(User.class); + }) + .get(); // GET请求 +``` diff --git a/package.json b/package.json new file mode 100644 index 00000000..2a6dea1b --- /dev/null +++ b/package.json @@ -0,0 +1,6 @@ +{ + "scripts": { + "dev": "vuepress dev docs", + "build": "vuepress build docs" + } +} \ No newline at end of file From e6ffe1f09fd4dcbf2428cbb94cda83cc2cb0e440 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?=E5=91=A8=E6=97=AD?= <15735559897@qq.com> Date: Tue, 28 Apr 2020 00:10:23 +0800 Subject: [PATCH 178/924] docs --- docs/.vuepress/config.js | 16 +- docs/README.md | 7 +- docs/guide/README.md | 93 ++++ docs/guide/getting-start.md | 920 ++++++++++++++++++++++++++++++++++++ 4 files changed, 1031 insertions(+), 5 deletions(-) create mode 100644 docs/guide/README.md create mode 100644 docs/guide/getting-start.md diff --git a/docs/.vuepress/config.js b/docs/.vuepress/config.js index d9a899ba..78f5aa65 100644 --- a/docs/.vuepress/config.js +++ b/docs/.vuepress/config.js @@ -2,6 +2,18 @@ module.exports = { title: 'OkHttps', description: 'OkHttps 官网', head: [ - ['link', { rel: 'icon', href: '/favicon.png' }] - ] + // ['link', { rel: 'icon', href: '/favicon.png' }] + ], + themeConfig: { + // logo: '/favicon.png', + nav: [ + { text: '教程', link: '/guide/' }, + { text: 'Gitee', link: 'https://gitee.com/ejlchina-zhxu/okhttps' }, + { text: 'GitHub', link: 'https://github.com/ejlchina/okhttps' } + ], + sidebar: [ + ['/guide/', '起步'], + '/guide/getting-start' + ] + } } \ No newline at end of file diff --git a/docs/README.md b/docs/README.md index 92e32024..3cd3c901 100644 --- a/docs/README.md +++ b/docs/README.md @@ -1,9 +1,10 @@ --- home: true + heroText: OkHttps -tagline: 安卓和Java领域开箱即用的 HTTP 客户端 +tagline: JAVA 中超级好用的 HTTP 客户端 actionText: 快速上手 → -actionLink: /zh/guide/ +actionLink: /guide/ features: - title: 轻量纯粹优雅 details: OkHttps 非常轻量，体积仅是 Retrofit 的一半不到，并且不依赖于特定平台，API 语义简洁舒适。 @@ -19,7 +20,7 @@ footer: Apache Licensed | Copyright © 2020-present Troy Zhou ```java // 构建 HTTP HTTP http = HTTP.builder() - .baseUrl("http://api.demo.com") + .baseUrl("https://api.demo.com") .build(); // 同步请求 diff --git a/docs/guide/README.md b/docs/guide/README.md new file mode 100644 index 00000000..e05d40b8 --- /dev/null +++ b/docs/guide/README.md @@ -0,0 +1,93 @@ +## 介绍 + +　　OkHttps 是近期开源的对 OkHttp3 轻量封装的框架，它独创的异步预处理器，特色的标签，灵活的上传下载进度监听与过程控制功能，在轻松解决很多原本另人头疼问题的同时，设计上也力求纯粹与优雅。 + + * 链式调用，一点到底 + * BaseURL、URL占位符、JSON自动封装与解析 + * 同步拦截器、异步预处理器、回调执行器、全局监听、回调阻断 + * 文件上传下载（过程控制、进度监听） + * 单方法回调，充分利用 Lambda 表达式 + * TCP连接池、Http2 + +> 1. OkHttps 非常轻量（59Kb），是 Retrofit（124Kb）的一半，并且更加的开箱即用，API 也更加自然和语义化。 +> 2. OkHttps 是一个纯粹的 Java 网络开发包，并不依赖 Android，这一点和 Retrofit 不同 +> 3. OkHttps 用起来很优美，可以像 RxJava 那样链式用，却比 RxJava 更简单。 + + +## 安装 + +### Maven + +```xml + + com.ejlchina + okhttps + 1.0.5 + +``` +### Gradle + +`implementation 'com.ejlchina:okhttps:1.0.5'` + +安卓中使用需要把 JDK 版本调成 1.8，在 app 模块的 build.gradle 中加入以下配置即可： + +```groovy +android { + // 省略其它配置.. + compileOptions { + sourceCompatibility = 1.8 + targetCompatibility = 1.8 + } +} +``` + +## 使用 + +### 构建 HTTP + +```java +HTTP http = HTTP.builder().build(); +``` +　　以上代码构建了一个最简单的`HTTP`实例，它拥有以下方法： + +* `async(String url)` 开始一个异步请求 （内部通过一个`HTTP`单例实现） +* `sync(String url)` 开始一个同步请求 （内部通过一个`HTTP`单例实现） +* `cancel(String tag)` 按标签取消请求（内部通过一个`HTTP`单例实现） +* `cancelAll()` 取消所有HTTP任务，包括同步和异步（内部通过一个`HTTP`单例实现） +* `request(Request request)` OkHttp 原生请求 （该请求不经过 预处理器） +* `webSocket(Request request, WebSocketListener listener)` WebSocket通讯 + +　　为了使用方便，在构建的时候，我们更愿意指定一个`BaseUrl`（请参见[5.1 设置 BaseUrl](#51-设置-baseurl)）: + +```java +HTTP http = HTTP.builder() + .baseUrl("http://api.demo.com") + .build(); +``` +　　为了简化文档，下文中出现的`http`均是在构建时设置了`BaseUrl`的`HTTP`实例。 + +#### 同步请求 + +　　使用方法`sync(String url)`开始一个同步请求： + +```java +List users = http.sync("/users") // http://api.demo.com/users + .get() // GET请求 + .getBody() // 获取响应报文体 + .toList(User.class); // 得到目标数据 +``` +　　方法`sync`返回一个同步`HttpTask`，可链式使用。 + +#### 异步请求 + +　　使用方法`async(String url)`开始一个异步请求： + +```java +http.async("/users/1") // http://api.demo.com/users/1 + .setOnResponse((HttpResult result) -> { + // 得到目标数据 + User user = result.getBody().toBean(User.class); + }) + .get(); // GET请求 +``` +　　方法`async`返回一个异步`HttpTask`，可链式使用。 diff --git a/docs/guide/getting-start.md b/docs/guide/getting-start.md new file mode 100644 index 00000000..fda88cae --- /dev/null +++ b/docs/guide/getting-start.md @@ -0,0 +1,920 @@ +### 2 请求方法（GET|POST|PUT|DELETE） + +　　同步与异步的`HttpTask`都拥有`get`、`post`、`put`与`delete`方法。不同的是：同步`HttpTask`的这些方法返回一个`HttpResult`，而异步`HttpTask`的这些方法返回一个`HttpCall`。 + +```java +HttpResult res1 = http.sync("/users").get(); // 同步 GET +HttpResult res2 = http.sync("/users").post(); // 同步 POST +HttpResult res3 = http.sync("/users/1").put(); // 同步 PUT +HttpResult res4 = http.sync("/users/1").delete();// 同步 DELETE +HttpCall call1 = http.async("/users").get(); // 异步 GET +HttpCall call2 = http.async("/users").post(); // 异步 POST +HttpCall call3 = http.async("/users/1").put(); // 异步 PUT +HttpCall call4 = http.async("/users/1").delete();// 异步 DELETE +``` +### 3 解析请求结果 + +#### 3.1 回调函数 + +　　OkHttps 的回调函数全部使用单方法模式，这样可以充分利用 Java8 或 Kotlin 中的 Lambda 表达式，使你的代码更加简洁优雅： + +```java +http.async("/users/{id}") // http://api.demo.com/users/1 + .addPathParam("id", 1) + .setOnResponse((HttpResult result) -> { + // 响应回调 + }) + .setOnException((IOException e) -> { + // 异常回调 + }) + .setOnComplete((State state) -> { + // 完成回调，无论成功失败都会执行 + // 并且在 响应|异常回调 之前执行 + }) + .get(); +``` + +>* 只有异步请求才可以设置这三种（响应|异常|完成）回调 +>* 同步请求直接返回结果，无需使用回调 + +#### 3.2 HttpResult + +　　`HttpResult`是HTTP请求执行完后的结果，它是同步请求方法（ `get`、`post`、`put`、`delete`）的返回值，也是异步请求响应回调（`OnResponse`）的参数，它定义了如下方法： + +* `getState()` 得到请求执行状态枚举，它有以下取值： + * `State.CANCELED` 请求被取消 + * `State.RESPONSED` 已收到响应 + * `State.TIMEOUT` 请求超时 + * `State.NETWORK_ERROR` 网络错误 + * `State.EXCEPTION` 其它请求异常 +* `getStatus()` 得到HTTP状态码 +* `isSuccessful()` 是否响应成功，状态码在 [200..300) 之间 +* `getHeaders()` 得到HTTP响应头 +* `getHeaders(String name)` 得到HTTP响应头 +* `getHeader(String name)` 得到HTTP响应头 +* `getBody()` 得到响应报文体`Body`实例，它定义了如下方法（对同一个`Body`实例，以下的`toXXX()`类方法只能使用一个且仅能调用一次，除非先使用 cache 方法）： + * `toBytes()` 返回字节数组 + * `toByteStream()` 返回字节输入流 + * `toCharStream()` 返回字符输入流 + * `toString()` 返回字符串 + * `toJsonObject()` 返回Json对象 + * `toJsonArray()` 返回Json数组 + * `toBean(Class type)` 返回根据type自动json解析后的JavaBean + * `toList(Class type)` 返回根据type自动json解析后的JavaBean列表 + * `toFile(String filePath)` 下载到指定路径 + * `toFile(File file)` 下载到指定文件 + * `toFolder(String dirPath)` 下载到指定目录 + * `toFolder(File dir)` 下载到指定目录 + * `getContentType()` 返回报文体的媒体类型 + * `getContentLength()` 返回报文体的字节长度 + * `cache()` 缓存报文体，开启缓存后可重复使用`toXXX()`类方法 + * `close()` 关闭报文体，未对报文体做任何消费时使用，比如只读取报文头 +* `getError()` 执行中发生的异常，自动捕获执行请求时发生的 网络超时、网络错误 和 其它IO异常 +* `close()` 关闭报文，未对报文体做任何消费时使用，比如只读取长度 + +　　示例，请求结果自动转Bean和List： + +```java +// 自动转Bean +Order order = http.sync("/orders/1") + .get().getBody().toBean(Order.class); + +// 自动转List +List orders = http.sync("/orders") + .get().getBody().toList(Order.class); +``` + +　　示例，使用 cache 方法： + +```java +Body body = http.sync("/orders").get().getBody().cache(); + +// 使用 cache 后，可以多次使用 toXXX() 方法 +System.out.println(body.toString()); +System.out.println(body.toJsonArray()); +System.out.println(body.toList(Order.class)); +``` + +　　示例，获取下载文件的大小： + +```java +long size = http.sync("/download/test.zip") + .get().getBody() + .close() // 只是想获得文件大小，不消费报文体，所以直接关闭 + .getContentLength(); // 获得待下载文件的大小 + +// 由于未消费报文体，所以本次请求不会消耗下载报文体的时间和网络流量 + +System.out.println("size = " + size); +``` + + +#### 3.3 HttpCall + +　　`HttpCall`对象是异步请求方法（`get`、`post`、`put`、`delete`）的返回值，与`java`的`Future`接口很像，它有如下方法： + +* `cancel()` 取消本次请求，返回取消结果 +* `isCanceled()` 返回请求是否被取消 +* `isDone()` 返回是否执行完成，包含取消和失败 +* `getResult()` 返回执行结果`HttpResult`对象，若请求未执行完，则挂起当前线程直到执行完成再返回 + +　　取消一个异步请求示例： + +```java +HttpCall call = http.async("/users/1").get(); + +System.out.println(call.isCanceled()); // false + +boolean success = call.cancel(); // 取消请求 + +System.out.println(success); // true +System.out.println(call.isCanceled()); // true +``` + +### 4 构建HTTP任务 + +　　`HTTP`对象的`sync`与`async`方法返回一个`HttpTask`对象，该对象提供了可链式调用的`addXXX`与`setXXX`等系列方法用于构建任务本身。 + +* `addHeader(String name, String value)` 添加请求头 +* `addHeader(Map headers)` 添加请求头 + +* `addPathParam(String name, Object value)` 添加路径参数：替换URL里的{name}占位符 +* `addPathParam(Map params)` 添加路径参数：替换URL里的{name}占位符 + +* `addUrlParam(String name, Object value)` 添加URL参数：拼接在URL的?之后（查询参数） +* `addUrlParam(Map params)` 添加URL参数：拼接在URL的?之后（查询参数） + +* `addBodyParam(String name, Object value)` 添加Body参数：以表单key=value&的形式放在报文体内（表单参数） +* `addBodyParam(Map params)` 添加Body参数：以表单key=value&的形式放在报文体内（表单参数） + +* `addJsonParam(String name, Object value)` 添加Json参数：请求体为Json（支持多层结构） +* `addJsonParam(Map params)` 添加Json参数：请求体为Json（支持多层结构） + +* `setRequestJson(Object json)` 设置请求体的Json字符串 或待转换为 Json的 JavaBean +* `setRequestJson(Object bean, String dateFormat)` 设置请求体的Json字符串 或待转换为 Json的 JavaBean + +* `addFileParam(String name, String filePath)` 上传文件 +* `addFileParam(String name, File file)` 上传文件 +* `addFileParam(String name, String type, InputStream inputStream)` 上传文件 +* `addFileParam(String name, String type, String fileName, InputStream input)` 上传文件 +* `addFileParam(String name, String type, byte[] content)` 上传文件 +* `addFileParam(String name, String type, String fileName, byte[] content)` 上传文件 + +* `setTag(String tag)` 为HTTP任务添加标签 +* `setRange(long rangeStart)` 设置Range头信息，用于断点续传 +* `setRange(long rangeStart, long rangeEnd)` 设置Range头信息，可用于分块下载 + +* `bind(Object object)` 绑定一个对象，可用于实现Android里的生命周期绑定 + +### 5 使用标签 + +　　有时候我们想对HTTP任务加以分类，这时候可以使用标签功能： + +```java +http.async("/users") //（1） + .setTag("A") + .get(); + +http.async("/users") //（2） + .setTag("A.B") + .get(); + +http.async("/users") //（3） + .setTag("B") + .get(); + +http.async("/users") //（4） + .setTag("B") + .setTag("C") // 从 v1.0.4 标签将以追加模式添加，等效于 setTag("B.C") + .get(); + +http.async("/users") //（5） + .setTag("C") + .get(); +``` +　　当使用标签后，就可以按标签批量的对HTTP任务进行取消： + +```java +int count = http.cancel("B"); //（2）（3）（4）被取消（取消标签包含"B"的任务） +System.out.println(count); // 输出 3 +``` +　　标签除了可以用来取消任务，在预处理器中它也可以发挥作用，请参见[并行预处理器](#54-并行预处理器)与[串行预处理器](#55-串行预处理器)。 + +### 6 配置 HTTP + +#### 6.1 设置 BaseUrl + +```java +HTTP http = HTTP.builder() + .baseUrl("http://api.demo.com") // 设置 BaseUrl + .build(); +``` +　　该配置全局生效，在配置了`BaseUrl`之后，具体的请求便可以省略`BaseUrl`部分，使得代码更加简洁，例如： + +```java +http.sync("/users").get() // http://api.demo.com/users + +http.sync("/auth/signin") // http://api.demo.com/auth/signin + .addBodyParam("username", "Jackson") + .addBodyParam("password", "xxxxxx") + .post() // POST请求 +``` +　　在配置了`BaseUrl`之后，如有特殊请求任务，仍然可以使用全路径的方式，一点都不妨碍： + +```java +http.sync("https://www.baidu.com").get() +``` + +#### 6.2 回调执行器 + +　　OkHttps 默认所有回调都在 **IO线程** 执行，如何想改变执行回调的线程时，可以配置回调执行器。例如在Android里，让所有的回调函数都在UI线程执行，则可以在构建`HTTP`时配置如下： + +```java +HTTP http = HTTP.builder() + .callbackExecutor((Runnable run) -> { + runOnUiThread(run); // 在UI线程执行 + }) + .build(); +``` +　　该配置默认 **影响所有回调**。 + +#### 6.3 配置 OkHttpClient + +　　与其他封装 OkHttp3 的框架不同，OkHttps 并不会遮蔽 OkHttp3 本身就很好用的功能，如下： + +```java +HTTP http = HTTP.builder() + .config((Builder builder) -> { + // 配置连接池 最小10个连接（不配置默认为 5） + builder.connectionPool(new ConnectionPool(10, 5, TimeUnit.MINUTES)); + // 配置连接超时时间（默认10秒） + builder.connectTimeout(20, TimeUnit.SECONDS); + // 配置拦截器 + builder.addInterceptor((Chain chain) -> { + Request request = chain.request(); + // 必须同步返回，拦截器内无法执行异步操作 + return chain.proceed(request); + }); + // 其它配置: CookieJar、SSL、缓存、代理、事件监听... + }) + .build(); +``` + +#### 6.4 并行预处理器 + +　　预处理器（`Preprocessor`）可以让我们在请求发出之前对请求本身做一些改变，但与`OkHttp`的拦截器（`Interceptor`）不同：预处理器可以让我们 **异步** 处理这些问题。 + +　　例如，当我们想为请求任务自动添加`Token`头信息，而`Token`只能通过异步方法`requestToken`获取时，这时使用`Interceptor`就很难处理了，但可以使用预处理器轻松解决： + +```java +HTTP http = HTTP.builder() + .addPreprocessor((PreChain chain) -> { + HttpTask task = chain.getTask();// 获得当前的HTTP任务 + if (!task.isTagged("Auth")) { // 根据标签判断该任务是否需要Token + return; + } + requestToken((String token) -> { // 异步获取 Token + task.addHeader("Token", token);// 为任务添加头信息 + chain.proceed(); // 继续当前的任务 + }); + }) + .build(); +``` +　　和`Interceptor`一样，`Preprocessor`也可以添加多个。他们之间的区别如下: + +> * 拦截器只能处理同步操作，预处理器支持处理异步操作 +> * 拦截器都是并行处理请求，预处理器支持串行处理（详见6.5章节） +> * 拦截器处理时机在请求前和响应后，预处理器只在请求前，并且先于拦截器执行。关于响应后，OkHttps还提供了全局回调监听（详见6.6章节） + +#### 6.5 串行预处理器（TOKEN问题最佳解决方案） + +　　普通预处理器都是可并行处理的，然而有时我们希望某个预处理器同时只处理一个任务。比如 当`Token`过期时我们需要去刷新获取新`Token`，而刷新`Token`这个操作只能有一个任务去执行，因为如果`n`个任务同时执行的话，那么必有`n-1`个任务刚刷新得到的`Token`可能就立马失效了，而这是我们所不希望的。 + +　　为了解决这个问题，OkHttps 提供了串行预处理器，它可以让 HTTP 任务排好队，一个一个地进入预处理器： + +```java +HTTP http = HTTP.builder() + .addSerialPreprocessor((PreChain chain) -> { + HttpTask task = chain.getTask(); + if (!task.isTagged("Auth")) { + return; + } + // 检查过期，若需要则刷新Token + requestTokenAndRefreshIfExpired((String token) -> { + task.addHeader("Token", token); + chain.proceed(); // 调用此方法前，不会有其它任务进入该处理器 + }); + }) + .build(); +``` +　　串行预处理器实现了让HTTP任务排队串行处理的功能，但值得一提的是：它并没有因此而阻塞任何线程！ + +#### 6.6 全局回调监听 + +```java +HTTP http = HTTP.builder() + .responseListener((HttpTask task, HttpResult result) -> { + // 所有请求响应后都会走这里 + + return true; // 返回 true 表示继续执行 task 的 OnResponse 回调，false 表示不再执行 + }) + .completeListener((HttpTask task, State state) -> { + // 所有请求执行完都会走这里 + + return true; // 返回 true 表示继续执行 task 的 OnComplete 回调，false 表示不再执行 + }) + .exceptionListener((HttpTask task, IOException error) -> { + // 所有请求发生异常都会走这里 + + return true; // 返回 true 表示继续执行 task 的 OnException 回调，false 表示不再执行 + }) + .build(); +``` + +　　全局回调监听与拦截器的异同: +> * 拦截器可以添加多个，全局回调监听分三种，每种最多添加一个 +> * 拦截器处的理时机在请求前和响应后，全局回调监听只在响应后，并且晚于拦截器 +> * 全局回调监听可以 **阻断**（return false）某个请求的具体回调，而拦截器不能 + +#### 6.7 全局下载监听 + +```java +HTTP http = HTTP.builder() + .downloadListener((HttpTask task, Download download) -> { + // 所有下载在开始之前都会先走这里 + Ctrl ctrl = download.getCtrl(); // 下载控制器 + + }) + .build(); +``` + +### 7 使用 HttpUtils 类 + +　　类`HttpUtils`本是 [前身 HttpUtils](https://gitee.com/ejlchina-zhxu/httputils) 的 1.x 版本里的最重要的核心类，由于在后来的版本里抽象出了`HTTP`接口，使得它的重要性已不如往昔。但合理的使用它，仍然可以带来不少便利，特别是在没有IOC容器的环境里，比如在Android开发和一些工具项目的开发中。 + +　　类`HttpUtils`共定义了四个静态方法： + +* `of(HTTP http)` 配置`HttpUtils`持有的`HTTP`实例（不调用此方法前默认使用一个没有没有经过任何配置的`HTTP`懒实例） +* `async(String url)` 开始一个异步请求 （内部通过一个`HTTP`单例实现） +* `async()` 开始一个异步HTTP任务，使用该方法必须在构建时设置 BaseUrl +* `sync(String url)` 开始一个同步请求 （内部通过一个`HTTP`单例实现） +* `sync()` 开始一个同步HTTP任务，使用该方法必须在构建时设置 BaseUrl +* `cancel(String tag)` 按标签取消请求（内部通过一个`HTTP`单例实现） +* `cancelAll()` 取消所有HTTP任务，包括同步和异步（内部通过一个`HTTP`单例实现） +* `request(Request request)` OkHttp 原生请求 （该请求不经过 预处理器） +* `webSocket(Request request, WebSocketListener listener)` WebSocket通讯 +　　也就是说，能使用`http`实例的地方，都可以使用`HttpUtils`类，例如： + +```java +// 在配置HTTP实例之前，只能使用全路径方式 +List roles = HttpUtils.sync("http://api.demo.com/roles") + .get().getBody().toList(Role.class); + +// 配置HTTP实例,全局生效 +HttpUtils.of(HTTP.builder() + .baseUrl("http://api.demo.com") + .build()); + +// 内部使用新的HTTP实例 +List users = HttpUtils.sync("/users") + .get().getBody().toList(User.class); +``` + +### 8 文件下载 + +　　OkHttps 并没有把文件的下载排除在常规的请求之外，同一套API，它优雅的设计使得下载与常规请求融合的毫无违和感，一个最简单的示例： + +```java +http.sync("/download/test.zip") + .get() // 使用 GET 方法（其它方法也可以，看服务器支持） + .getBody() // 得到报文体 + .toFile("D:/download/test.zip") // 下载到指定的路径 + .start(); // 启动下载 + +http.sync("/download/test.zip").get().getBody() + .toFolder("D:/download") // 下载到指定的目录，文件名将根据下载信息自动生成 + .start(); +``` +　　或使用异步连接方式： + +```java +http.async("/download/test.zip") + .setOnResponse((HttpResult result) -> { + result.getBody().toFolder("D:/download").start(); + }) + .get(); +``` +　　这里要说明一下：`sync`与`async`的区别在于连接服务器并得到响应这个过程的同步与异步（这个过程的耗时在大文件下载中占比极小），而`start`方法启动的下载过程则都是异步的。 + +#### 8.1 下载进度监听 + +　　就直接上代码啦，诸君一看便懂： + +```java +http.sync("/download/test.zip") + .get() + .getBody() + .setStepBytes(1024) // 设置每接收 1024 个字节执行一次进度回调（不设置默认为 8192） + // .setStepRate(0.01) // 设置每接收 1% 执行一次进度回调（不设置以 StepBytes 为准） + .setOnProcess((Process process) -> { // 下载进度回调 + long doneBytes = process.getDoneBytes(); // 已下载字节数 + long totalBytes = process.getTotalBytes(); // 总共的字节数 + double rate = process.getRate(); // 已下载的比例 + boolean isDone = process.isDone(); // 是否下载完成 + }) + .toFolder("D:/download/") // 指定下载的目录，文件名将根据下载信息自动生成 + // .toFile("D:/download/test.zip") // 指定下载的路径，若文件已存在则覆盖 + .setOnSuccess((File file) -> { // 下载成功回调 + + }) + .start(); +``` +　　值得一提的是：由于 OkHttps 并没有把下载做的很特别，这里设置的进度回调不只对下载文件起用作，即使对响应JSON的常规请求，只要设置了进度回调，它也会告诉你报文接收的进度（提前是服务器响应的报文有`Content-Length`头），例如： + +```java +List users = http.sync("/users") + .get() + .getBody() + .setStepBytes(2) + .setOnProcess((Process process) -> { + System.out.println(process.getRate()); + }) + .toList(User.class); +``` + +#### 8.2 下载过程控制 + +　　过于简单：还是直接上代码： + +```java +Ctrl ctrl = http.sync("/download/test.zip") + .get() + .getBody() + .setOnProcess((Process process) -> { + System.out.println(process.getRate()); + }) + .toFolder("D:/download/") + .start(); // 该方法返回一个下载过程控制器 + +ctrl.status(); // 下载状态 +ctrl.pause(); // 暂停下载 +ctrl.resume(); // 恢复下载 +ctrl.cancel(); // 取消下载（同时会删除文件，不可恢复） +``` +　　无论是同步还是异步发起的下载请求，都可以做以上的控制： + +```java +http.async("/download/test.zip") + .setOnResponse((HttpResult result) -> { + // 拿到下载控制器 + Ctrl ctrl = result.getBody().toFolder("D:/download/").start(); + }) + .get(); +``` + +#### 8.3 实现断点续传 + +　　OkHttps 对断点续传并没有再做更高层次的封装，因为这是app该去做的事情，它在设计上使各种网络问题的处理变简单的同时力求纯粹。下面的例子可以看到，OkHttps 通过一个失败回调拿到 **断点**，便将复杂的问题变得简单： + +```java +http.sync("/download/test.zip") + .get() + .getBody() + .toFolder("D:/download/") + .setOnFailure((Failure failure) -> { // 下载失败回调，以便接收诸如网络错误等失败信息 + IOException e = failure.getException(); // 具体的异常信息 + long doneBytes = failure.getDoneBytes(); // 已下载的字节数（断点），需要保存，用于断点续传 + File file = failure.getFile(); // 下载生成的文件，需要保存 ，用于断点续传（只保存路径也可以） + }) + .start(); +``` +　　下面代码实现续传： + +```java +long doneBytes = ... // 拿到保存的断点 +File file = ... // 待续传的文件 + +http.sync("/download/test.zip") + .setRange(doneBytes) // 设置断点（已下载的字节数） + .get() + .getBody() + .toFile(file) // 下载到同一个文件里 + .setAppended() // 开启文件追加模式 + .setOnSuccess((File file) -> { + + }) + .setOnFailure((Failure failure) -> { + + }) + .start(); +``` + +#### 8.4 实现分块下载 + +　　当文件很大时，有时候我们会考虑分块下载，与断点续传的思路是一样的，示例代码： + +```java +static String url = "http://api.demo.com/download/test.zip" + +public static void main(String[] args) { + long totalSize = HttpUtils.sync(url).get().getBody() + .close() // 因为这次请求只是为了获得文件大小，不消费报文体，所以直接关闭 + .getContentLength(); // 获得待下载文件的大小（由于未消费报文体，所以该请求不会消耗下载报文体的时间和网络流量） + download(totalSize, 0); // 从第 0 块开始下载 + sleep(50000); // 等待下载完成（不然本例的主线程就结束啦） +} + +static void download(long totalSize, int index) { + long size = 3 * 1024 * 1024; // 每块下载 3M + long start = index * size; + long end = Math.min(start + size, totalSize); + HttpUtils.sync(url) + .setRange(start, end) // 设置本次下载的范围 + .get().getBody() + .toFile("D:/download/test.zip") // 下载到同一个文件里 + .setAppended() // 开启文件追加模式 + .setOnSuccess((File file) -> { + if (end < totalSize) { // 若未下载完，则继续下载下一块 + download(totalSize, index + 1); + } else { + System.out.println("下载完成"); + } + }) + .start(); +} +``` + +### 9 文件上传 + +　　一个简单文件上传的示例： + +```java +http.sync("/upload") + .addFileParam("test", "D:/download/test.zip") + .post() // 上传发法一般使用 POST 或 PUT，看服务器支持 +``` +　　异步上传也是完全一样： + +```java +http.async("/upload") + .addFileParam("test", "D:/download/test.zip") + .post() +``` + +#### 9.1 上传进度监听 + +　　OkHttps 的上传进度监听，监听的是所有请求报文体的发送进度，示例代码： + +```java +http.sync("/upload") + .addBodyParam("name", "Jack") + .addBodyParam("age", 20) + .addFileParam("avatar", "D:/image/avatar.jpg") + .setStepBytes(1024) // 设置每发送 1024 个字节执行一次进度回调（不设置默认为 8192） + // .setStepRate(0.01) // 设置每发送 1% 执行一次进度回调（不设置以 StepBytes 为准） + .setOnProcess((Process process) -> { // 上传进度回调 + long doneBytes = process.getDoneBytes(); // 已发送字节数 + long totalBytes = process.getTotalBytes(); // 总共的字节数 + double rate = process.getRate(); // 已发送的比例 + boolean isDone = process.isDone(); // 是否发送完成 + }) + .post() +``` +　　咦！怎么感觉和下载的进度回调的一样？没错！OkHttps 还是使用同一套API处理上传和下载的进度回调，区别只在于上传是在`get/post`方法之前使用这些API，下载是在`getBody`方法之后使用。很好理解：`get/post`之前是准备发送请求时段，有上传的含义，而`getBody`之后，已是报文响应的时段，当然是下载。 + +#### 9.2 上传过程控制 + +　　上传文件的过程控制就很简单，和常规请求一样，只有异步发起的上传可以取消： + +```java +HttpCall call = http.async("/upload") + .addFileParam("test", "D:/download/test.zip") + .setOnProcess((Process process) -> { + System.out.println(process.getRate()); + }) + .post() + +call.cancel(); // 取消上传 +``` +　　上传就没有暂停和继续这个功能啦，应该没人有这个需求吧? + +### 10 异常处理 + +　　使用 OkHttps 时，**异常处理不是必须的**，但相比其它的 HTTP 开发包，它还提供一个特别的处理方法：`nothrow()`，以满足不同的异常处理需求。 + +#### 10.1 同步请求的异常 + +　　默认情况下，当同步请求执行异常时，会直接向外抛出，我们可以用 `try catch` 来捕获，例如： + +```java +try { + HttpResult result = http.sync("/users/1").get(); +} catch (HttpException e) { + Throwable cause = e.getCause(); // 得到异常原因 + if (cause instanceof ConnectException) { + // 当没网络时，会抛出连接异常 + } + if (cause instanceof SocketTimeoutException) { + // 当接口长时间未响应，会抛出超时异常 + } + if (cause instanceof UnknownHostException) { + // 当把域名或IP写错，会抛出 UnknownHost 异常 + } + // ... +} +``` +　　这种传统的异常处理方式，当然可以解决问题，但 OkHttps 有更佳的方案： + +```java +// 方法 nothrow() 让异常不直接抛出 +HttpResult result = http.sync("/users/1").nothrow().get(); +// 判断执行状态 +switch (result.getState()) { + case RESPONSED: // 请求已正常响应 + break; + case CANCELED: // 请求已被取消 + break; + case NETWORK_ERROR: // 网络错误，说明用户没网了 + break; + case TIMEOUT: // 请求超时 + break; + case EXCEPTION: // 其它异常 + break; +} +// 还可以获得具体的异常信息 +IOException error = result.getError(); +``` + +#### 10.2 异步请求的异常 + +　　异步请求最常用的异常处理方式就是设置一个异常回调： + +```java +http.async("/users/1") + .setOnResponse((HttpResult result) -> { + // 当发生异常时就不会走这里 + }) + .setOnException((IOException e) -> { + // 这里处理请求异常 + }) + .get(); +``` +　　当然，还有一个全局异常监听（`ExceptionListener`）： + +```java +HTTP http = HTTP.builder() + .exceptionListener((HttpTask task, IOException error) -> { + // 所有请求发生异常都会走这里 + + return true; // 返回 true 表示继续执行 task 的 OnException 回调，false 表示不再执行 + }) + .build(); +``` +　　如果不设置`OnException`回调，也没有`ExceptionListener`，发生异常时会在 **IO 线程** 中向上抛出，外层无法捕获： + +```java +try { + http.async("/users/1") + .setOnResponse((HttpResult result) -> { + // 当发生异常时就不会走这里 + }) + .get(); +} catch (HttpException e) { + // 这种方式是捕获不到异常的！！！！！！ +} +``` +　　即使没有`OnException`回调，发生异常时，依然会走`OnComplete`回调，如果设置了的话： + +```java +http.async("/users/1") + .setOnResponse((HttpResult result) -> { + // 当发生异常时就不会走这里 + }) + .setOnComplete((State state) -> { + // 发生异常，会先执行这里，可以根据 state 判断发生了什么 + // 但执行完后依然会在IO线程中向上抛出 + }) + .get(); +``` +　　如果就是想 **不处理异常，也不向上抛出**，发生错误完全无视，可以做到吗？可以！还是使用`nothrow()`方法： + +```java +http.async("/users/1") + .nothrow() // 告诉 OkHttps 发生异常时不向外抛出 + .setOnResponse((HttpResult result) -> { + // 当发生异常时就不会走这里 + }) + .get(); +``` +### 11 取消请求的4种方式 + +　　在 OkHttps 里取消请求共有 **4 种** 方式可选： + +* 使用`HttpCall#cancel()`取消单个请求（适用于异步请求，[详见 3.3 章节](#33-httpcall)） +* 使用`HttpTask#cancel()`取消单个请求（适用于所有请求）（since v1.0.4） + +```java +HttpTask task = http.async("/users") + .setOnResponse((HttpResult result) -> { + // 响应回调 + }); + +task.get(); // 发起 GET 请求 + +// 取消请求，并返回是否取消成功 +boolean canceled = task.cancel(); +``` + +* 使用`HTTP#cancel(String tag)`按标签批量取消请求（适用于所有请求，[详见第 5 章节](#5-使用标签)） +* 使用`HTTP#cancelAll()`取消所有请求（适用于所有请求）（since v1.0.2） + +```java +http.cancelAll(); // 取消所有请求 +``` + +### 12 回调线程自由切换（for Android） + +　　在 Android 开发中，经常会把某些代码放到特点的线程去执行，比如网络请求响应后的页面更新在主线程（UI线程）执行，而保存文件则在IO线程操作。OkHttps 为这类问题提供了良好的方案。 + +　　在 **默认** 情况下，**所有回调** 函数都会 **在 IO 线程** 执行。为什么会设计如此呢？这是因为 OkHttps 只是纯粹的 Java 领域 Http工具包，本身对 Android 不会有任何依赖，因此也不知 Android 的 UI 线程为何物。这么设计也让它在 Android 之外有更多的可能性。 + +　　但是在 Android 里使用 OkHttps 的话，UI线程的问题能否优雅的解决呢？当然可以！简单粗暴的方法就是配置一个 回调执行器： + + ```java +HTTP http = HTTP.builder() + .callbackExecutor((Runnable run) -> { + // 实际编码中可以吧 Handler 提出来，不需要每次执行回调都重新创建 + new Handler(Looper.getMainLooper()).post(run); // 在主线程执行 + }) + .build(); +``` +　　上述代码便实现了让 **所有** 的 **回调函数** 都在 **主线程（UI线程）** 执行的目的，如： + +```java +http.async("/users") + .addBodyParam("name", "Jack") + .setOnProcess((Process process) -> { + // 在主线程执行 + }) + .setOnResponse((HttpResult result) -> { + // 在主线程执行 + }) + .setOnException((Exception e) -> { + // 在主线程执行 + }) + .setOnComplete((State state) -> { + // 在主线程执行 + }) + .post(); +``` +　　但是，如果同时还想让某些回调放在IO线程，实现 **自由切换**，怎么办呢？OkHttps 给出了非常灵活的方法，如下： + +```java +http.async("/users") + .addBodyParam("name", "Jack") + .setOnProcess((Process process) -> { + // 在主线程执行 + }) + .nextOnIO() // 指定下一个回调在 IO 线程执行 + .setOnResponse((HttpResult result) -> { + // 在 IO 线程执行 + }) + .setOnException((Exception e) -> { + // 在主线程执行（没有指明 nextOnIO 则在回调执行器里执行） + }) + .nextOnIO() // 指定下一个回调在 IO 线程执行 + .setOnComplete((State state) -> { + // 在 IO 线程执行 + }) + .post(); +``` +　　无论是哪一个回调，都可以使用`nextOnIO()`方法自由切换。同样，对于文件下载也是一样： + +```java +http.sync("/download/test.zip") + .get() + .getBody() + .setOnProcess((Process process) -> { + // 在主线程执行 + }) + .toFolder("D:/download/") + .nextOnIO() // 指定下一个回调在 IO 线程执行 + .setOnSuccess((File file) -> { + // 在 IO 线程执行 + }) + .setOnFailure((Failure failure) -> { + // 在主线程执行 + }) + .start(); +``` +### 13 实现生命周期绑定（for Android） + +　　由于 OkHttps 并不依赖于 Android，所以它并没有提供关于生命周期绑定的直接实现，但它的一些扩展机制让我们很容易就可以实现这个需求。在开始之前，我们首先要理解何为生命周期绑定： + +> 所谓的生命周期绑定：即是让 HTTP 任务感知其所属的 Activity 或 Fragment 的生命周期，当 Activity 或 Fragment 将被销毁时，框架应自动的把由它们发起的但尚未完成的 HTTP 任务全部取消，以免导致程序出错！ + +　　现在我们需要对`HTTP`实例进行配置，配置后的`HTTP`实例具有生命周期绑定的功能，在`Activity`或`Fragment`里，它的使用效果如下： + +```java +// 在 Activity 或 Fragment 内发起请求 +http.async("http://www.baidu.com") + .bind(getLifecycle()) // 绑定生命周期 + .setOnResponse((HttpResult result) -> { + Log.i("FirstFragment", "收到请求：" + result.toString()); + }) + .get(); +``` +　　上述代码中的`getLifecycle()`是`Activity`或`Fragment`自带的方法，而`bind()`是`HttpTask`的现有方法。在配置好`HTTP`实例后，上述代码发起的请求便可以感知`Activity`或`Fragment`的生命周期。 + +　　那`HTTP`实例到底该如何配置呢？ + +#### 第一步：配置预处理器 + +```java +HTTP http = HTTP.builder() + ... // 省略其它配置项 + .addPreprocessor((Preprocessor.PreChain chain) -> { + HttpTask task = chain.getTask(); + Object bound = task.getBound(); + // 判断 task 是否绑定了 Lifecycle 对象 + if (bound instanceof Lifecycle) { + // 重新绑定一个 生命周期监视器（LCObserver）对象，它的定义见下一步 + task.bind(new LCObserver(task, (Lifecycle) bound)); + } + chain.proceed(); + }) + ... // 省略其它配置项 + .build(); +``` + +#### 第二步：定义生命周期监视器 + +```java +public class LCObserver implements LifecycleObserver { + + HttpTask task; + Lifecycle lifecycle; + + LCObserver(HttpTask task, Lifecycle lifecycle) { + this.task = task; + this.lifecycle = lifecycle; + lifecycle.addObserver(this); + } + + @OnLifecycleEvent(Lifecycle.Event.ON_STOP) + public void onStop() { + task.cancel(); // 在 ON_STOP 事件中，取消对应的 HTTP 任务 + } + + public void unbind() { + // 在请求完成之后移除监视器 + lifecycle.removeObserver(this); + } + +} +``` + +#### 第三步：配置全局回调监听 + +　　以上两步其实已经实现了生命周期绑定的功能，但是在请求完成之后，我们需要在`lifecycle`中移除`LCObserver`对象： + +```java +HTTP http = HTTP.builder() + ... // 省略其它配置项 + .completeListener((HttpTask task, HttpResult.State state) -> { + Object bound = task.getBound(); + // 判断 task 是否绑定了生命周期监视器（LCObserver）对象 + if (bound instanceof LCObserver) { + // 解绑监视器 + ((LCObserver) bound).unbind(); + } + return true; + }) + ... // 省略其它配置项 + .build(); +``` + +**以上三步便在Android中实现了生命周期与HTTP请求绑定的功能** + +　　非常简单，懒得敲代码的同学还可以 [点这里 OkHttps.java](https://gitee.com/ejlchina-zhxu/okhttps-android-demo/blob/master/app/src/main/java/com/flower/myapplication/http/OkHttps.java) 直接下载封装好的源码，其中不仅编写了生命周期绑定的配置，还有在UI线程执行回调的配置。 + +　　有需要的同学，可以直接下载下来使用，还可以基于它再次扩展，比如实现自动添加 TOKEN 的功能，具体可以参考[6.5 串行预处理器（TOKEN问题最佳解决方案）](#65-串行预处理器token问题最佳解决方案)，再比如扩展实现生命周期与下载事件绑定的功能，都非常简单。 + + +## 后期计划（v1.1.0） + +* 简化 WebSocket 编程：可直接发送 JavaBean 对象消息 +* 简化 WebSocket 编程：可直接接收 JavaBean 对象消息 +* 简化 WebSocket 编程：可使用 Lambda 表达式进行 WebSocket 编程 + +## 联系方式 + +* 微信： +* 邮箱：zhou.xu@ejlchina.com + +## 参与贡献 + +1. Fork 本仓库 +2. 新建 Feat_xxx 分支 +3. 提交代码 +4. 新建 Pull Request From 02b6e548e37a5946dc0516c8bff227cb765d0d5b Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?=E5=91=A8=E6=97=AD?= Date: Tue, 28 Apr 2020 11:23:24 +0800 Subject: [PATCH 179/924] docs --- docs/.vuepress/config.js | 10 +- docs/.vuepress/public/logo.png | Bin 0 -> 5800 bytes docs/.vuepress/styles/index.styl | 3 + docs/README.md | 6 +- docs/guide/README.md | 34 ++- docs/guide/android.md | 168 ++++++++++++ docs/guide/getting-start.md | 455 ++----------------------------- docs/guide/updown.md | 218 +++++++++++++++ 8 files changed, 444 insertions(+), 450 deletions(-) create mode 100644 docs/.vuepress/public/logo.png create mode 100644 docs/.vuepress/styles/index.styl create mode 100644 docs/guide/android.md create mode 100644 docs/guide/updown.md diff --git a/docs/.vuepress/config.js b/docs/.vuepress/config.js index 78f5aa65..7f15ba16 100644 --- a/docs/.vuepress/config.js +++ b/docs/.vuepress/config.js @@ -2,10 +2,10 @@ module.exports = { title: 'OkHttps', description: 'OkHttps 官网', head: [ - // ['link', { rel: 'icon', href: '/favicon.png' }] + ['link', { rel: 'icon', href: '/logo.png' }] ], themeConfig: { - // logo: '/favicon.png', + logo: '/logo.png', nav: [ { text: '教程', link: '/guide/' }, { text: 'Gitee', link: 'https://gitee.com/ejlchina-zhxu/okhttps' }, @@ -13,7 +13,9 @@ module.exports = { ], sidebar: [ ['/guide/', '起步'], - '/guide/getting-start' - ] + ['/guide/getting-start', '一探究竟'], + ['/guide/android', '安卓'], + ], + sidebarDepth: 2 } } \ No newline at end of file diff --git a/docs/.vuepress/public/logo.png b/docs/.vuepress/public/logo.png new file mode 100644 index 0000000000000000000000000000000000000000..3b3b2845420b470e4b091e3862ff98653c4b1cb0 GIT binary patch literal 5800 zcmX9?c|2768$RclVT^4s*_RpXRMuoG%P?dtA*m#L(n8lZmMhEHm&71ZWGfe4Wi5Ng zo~ww;5;4j}cES*5ese#+KhEcUKi~Izp69He_j%rATWd2Oq!=R5sxYDrp^2IMU_Bh0y>E*~O>!|ph0Kd1zw>qt@EFdT#`V|KkDr5H~Vx$ zx)qN}Ap!Ni=LJ%~4KJ^GhuGQh?bUZ0gP6bYt%j3+HhGK!?l=fvsUG{UYoE##$O+3L zcXJaDBgO*^4X}+3<@1HV`X40nk{wF!_t4kKDi{!MFP%L1P(CCI|9baxI_?ea=Cg%nKp+fbIeFs4TS`T<+@j9@WN^=z+q2S+UuVX zJ08S5nc@z=+e|L71(Fns;bfH}MHahx5{!0&1nRSZk5wOCfttxuth$gLL|cTK2_TWX zJy=EO-aO=tH^Tv(ESk4IyZSS_H|=cFbqDUos}!-J$@LBeU)J`r0{1d~(0R95-6|8PJ$uBxn)R!h`R!oGVeOt8Zk_3mb8P&Qx~Rsl$qY?5ZAR znd`p}FIl_Y?L7>yjD{#egzxhQ3HK8`fNlA7fprdau?sC9x7N+c=0Kh5hbjX-cSBk5zHwMB>BZEb<@Y z#2oE^)g|o!thYh_Z;NtWb_uo_kjDYZHRbcd(KoHQObKGM#7!0I1t3$N^xf+9EksGM zz?0D8jd%BiBi@wHzh0B1_YHj>Y?_S8X^cUb zTq`U5d{K4O=DM?QvY|!LDG|$HEbx7t?<{v@;!>kx#Y(ZOkz;*$>fvdxVN|z5unN_^ z7MEEG1A3I{iHB8-FNL@29d9r3-{^=)az0HG`5CAjSoYZouLY5F>IW*@lf8N^Wi(RH z{B|h5FO9jW?j%szc+R+*C`>Ws1-!>?Aclo6flubmOR+fP_uX!ZROPR~3 z>&xdOdw%#Y&a|+q|54hu?xvMe08=F)FO{0>0~y8X^3X&JSpr7wv^LPdf?nq5FZhgS z1Q7X6G53V=AR@7pg4rFJP!LN*w>lgzL3pl00TWzm;*DIkDT(**ymB-uZ)}JZlrbfM zTG2t+NqtCn6`pieaHjVxF|K05tP@;AnNIgZuXCSTVIvKyUVtiYTlKhpnuhs>ESA`%fNPm-I6&ic%!=cur zrJu^WpyGwoakaA%#V_8iIN{gscF?P>Zrz=~S6x0o?5faZP378&T(l-2G^Tm>&jzwE za-bhZt7erF%l||?uO^@^2^t($@Vz$^*f zO!9d7+0I9N0Tuo6&uD!s==x;pjaeu~kj&nNHQMlW5Ql_x(H`;kMAYCpJ*JWqz6PTC z3`No@)D-046&)>w6zin}1SY({gvc>mi1Yomph7dPCZi7H%pSkLSr8~mfJW({t+$c|! zwfYLT1unZ0tEFO%{e;EICSCD-`_S54$mr^ioaZY6tsYi<7McJh%w@_`fy6ez4qs+iXK0=H;rm!}>Ft77(PG9d`cPmaL6)z%?%Es&N zYmVB55_lBv-*LGe@#bL>kV^F<7JW?)<@Q64VYvVJIh3dWcER)d*0?Qj&ZBWP_xG%v zol>$%*HYBj@kR`nEdX^`cgvZE>V;xbLu9=4tVWGN1mgQzo?d?3bBF+7MFc45A^_o0 z-<9U5=;6Va0K{PAs)J>00<~O67pAlR_z0SipC%<=!U6oVvvS>H+@MSh&slEHB+*3x z?MB2`;z8TE#4OZZ5eQd{7Kqbp3s!PTohEQ8W$Kaub~iYm8fV-1I?v8=nM4n-dPTlPzo<##cHv9x+IN=y@JUN$W1QHR!G781TfE+uY zA{NVv2m&O4MB+WD;AxKA_6dW_zHXB>aYcX#2ix2I8m%9`GC#Y_Em)Y`;|CVAw&yu( z_4DO~alkq1DD5A&of!ua0g(i#2$6Oy&z)AL_o<|i(xJ^Xz*yK=^j ze&#qwJMKeqX{7`@4*DqAO0hXr^{t`1B`fS7Yl5*FY!P%Z={-2JG3No|0LfXJHc01( zC1CL!I(r{zfhuJV5m>MYsHb-L@}}VNB9IUESw~dzmS>_@iSCMprw&U;QP~B=4;RW! zTB%#lmzyKgB=7ScanLuiEKFrh-Q>_@O{=Afs$%#o=bndotMZ?3|bMG$hPhg%6nwsV*iVcjh-QaCd;cW>uUxQTywg9 zpL?QlGH7#rCzLF0*%a5J_oUJg4UmNo-V@_zj%kTXUQP4md2^iBf8$Au5{vxhC;{n3D+ zf7IoLWm)&Viwje(tWuk)rlDPHJAwD-#aGZ0FWmt?*xSfPF@0;A z7Q-w^fCg`*KIL)xDlC*iV^0YHa*qsCL(O>^JUAWD;J)U=dB9^37C!r?dJg7cBwU@~ z0R!ryD%qveb@wKt5mOIHP0p1j6nTpPpvH>~r~ehgVZ5(4^6w&a8D|X03^K0VdSVpD zYAK23X%D?ZD&UTrjWH7V${(enem#CKh$q=dpyfjuKwW8{@Jf@9<4c%2`vNSjI@F01 zB6p{6+kKM1`DnA~55wMhtdtJY!VggQVwPyp5rY5zSrKVW@Kgq>!$$PigzFizc-#hl z@6_4FE4F$~XUQUbkL%1s(`4je_l1EgWPr#w*f(`YOe*f;NXuS|FpyIRP#KmX`!~MZ z@ZJ`-4Hu!E3IRso()ma5Vy>jF1`USK2;W%vGfw-qedmznw2|H90gWGj3!6FAW;ymM zzdfNgxk}9n``tvlANaO>UOPUL?#5m)JC?5->T`ixCV#|OIkNShotY8!{l&6DkaI|1N`ax|&rZ7l z?z&&4G?ri$mD#tosdTvUP}h)WiuU>bJ3$BElSJgJCR-JSCM0=|ps9Xvoopb`+AT?t z!Tc%R!roPI%To~u&COJ9|1uECzuvd#>t+m-i359@$r6&}xh}mimjknKsb3GDo<&LA zm5Xl}*8|{1(l6=^r_NW2?oZDAel)p1O?TPbj2g>2U_bMd7)kHh<#<?7jM!H4`$P+ zY#7^p;vDS@E$v6m2U%_UAE(dUFpKe)_+0OhbPL;r)OS(bI{=pp8nc`y< z9)=!JU3<7XJ}i%Y3vrEV8!#MOdoC+a6*KG3!aYZCBbQ3b-~VW6!1}Jx(Z( zK3@Be+DY);;lt_CXu1t^YiNigz?HF}-R^JL-WbZb$;I_A%x#!QPrit4F)i3Ee{_`^ z3A8giIEG$^UupH;n>b*OYi5*xldc}0e`+^}1MIHe`LZXdvHs&t)PgC^HENTK&KNTE zD-8erv-j#ZMc$+KO+!hq$ixZPYe2V&P9VK8L*iP@e%yo!jcySvw)PM9&5t*uKMo$Z z^>gmEK?8a5?DNR_yl5Q-uq*2s8){Oml`qE|?p>50I|KCdzV%8Q3`Vt@YPNG~tIZ$kt;NT+`hR=gEYMzO6ZD|2Hyu^ewRy6Dkv$++c^3 zFseFe(-b91|8kMr5^X(VT5SmM34NLBoGm*sw*)+QU5Q1X>Z^WpGufAxVQnJx?T+4n z1W;M&>2DVQIQgBd*dN)B&=lpD7p9-1<+?f_MclzZL#e~y_^-U9gnT&u>#n1t?9j2F z9~n{S zIU&?_t)>S{gj3M=QTl~!vkvwNF5sa-Z`iszA$nNCOegYCpxB+&KANFEKad-KPOYM> z4v}owcXM0D6an0Uo@Yh#76Vt{VKJ4=BScPf%4tzKg82f}{dIFkC3rT27vqz1qd%R; z_s`44A|N$#Uqpo(_)o0TWCzXg0gA5ex9eJ5pB3%V1Tc-qtdMU4B;5O}X4P{TE`Q;` zq!s87DyJ=Ml*P)pI+aFhI(gaWRati(c>NDrF`^QTWwJbxl=`l#jXy*_7M&YG!$Fof zZiZzqBk%YQi8ekND$b7!4x)0=o);9DN*xx6-ei729|wr+`bpsv=V0&iPolUGGq=0r zTw~(}ADqAVg3YfwzD6L1Co+h3+q}nkT(($!uWI~t#Z#rpm=Ji~=Ec&1gCkCkrmq+0 z^bTv6&ssG24ZSP=>#yUEz|@%PQpR`7FgX9aJAuf!9f!u^1+CT{Rh7?T#;+EjZTEzW zB#&$Mi4_jb?ym=N|tg2236iIFNRu<^P(9?`q#FJX_mht! z3WEcbZDH>_I;2rZJO>U^Xf)22=7_@QvMqv_IhITWy^eR48ekWJFme$6=$&$p#e#&X zfy5#75#;W6nDBe$`Awq(LX-L3WZ(1WaGJUi(h)3|)Y*#n3&&nG9gyZgvJ|huSS4z`Y`R zf2Y_2aYl(#k2@4(9Y3y#$3Q4fWXG>)!|TVZlyN}Daa+XT@EC<{27?CVt3CW~HGUa& zuvXhJ3py@SYYRLynrTCNP=0T@2ckos{>Cbn;z2doW!@9{K3ORuP9*|cxuQqgEN27v z_(+=jrY)qP^yrLW;73JP@8YLujJqy<6(7JlX*nmV(?mbrguyZH800-v++ST);? +heroImage: /logo.png heroText: OkHttps -tagline: JAVA 中超级好用的 HTTP 客户端 +tagline: 基于 OkHttp 的 Java HTTP 客户端 actionText: 快速上手 → actionLink: /guide/ features: @@ -37,3 +37,5 @@ http.async("/users/jack") // http://api.demo.com/users/jack }) .get(); // GET请求 ``` + +**
就这么简单，你已学会 OkHttps 90% 的用法！
** \ No newline at end of file diff --git a/docs/guide/README.md b/docs/guide/README.md index e05d40b8..f2cda81c 100644 --- a/docs/guide/README.md +++ b/docs/guide/README.md @@ -43,18 +43,18 @@ android { ## 使用 -### 构建 HTTP +### 构建实例 ```java HTTP http = HTTP.builder().build(); ``` 　　以上代码构建了一个最简单的`HTTP`实例，它拥有以下方法： -* `async(String url)` 开始一个异步请求 （内部通过一个`HTTP`单例实现） -* `sync(String url)` 开始一个同步请求 （内部通过一个`HTTP`单例实现） -* `cancel(String tag)` 按标签取消请求（内部通过一个`HTTP`单例实现） -* `cancelAll()` 取消所有HTTP任务，包括同步和异步（内部通过一个`HTTP`单例实现） -* `request(Request request)` OkHttp 原生请求 （该请求不经过 预处理器） +* `async(String url)` 开始一个异步请求 +* `sync(String url)` 开始一个同步请求 +* `cancel(String tag)` 按标签取消请求 +* `cancelAll()` 取消所有HTTP任务，包括同步和异步 +* `request(Request request)` OkHttp 原生请求 * `webSocket(Request request, WebSocketListener listener)` WebSocket通讯 　　为了使用方便，在构建的时候，我们更愿意指定一个`BaseUrl`（请参见[5.1 设置 BaseUrl](#51-设置-baseurl)）: @@ -66,7 +66,7 @@ HTTP http = HTTP.builder() ``` 　　为了简化文档，下文中出现的`http`均是在构建时设置了`BaseUrl`的`HTTP`实例。 -#### 同步请求 +### 同步请求 　　使用方法`sync(String url)`开始一个同步请求： @@ -78,7 +78,7 @@ List users = http.sync("/users") // http://api.demo.com/users ``` 　　方法`sync`返回一个同步`HttpTask`，可链式使用。 -#### 异步请求 +### 异步请求 　　使用方法`async(String url)`开始一个异步请求： @@ -91,3 +91,21 @@ http.async("/users/1") // http://api.demo.com/users/1 .get(); // GET请求 ``` 　　方法`async`返回一个异步`HttpTask`，可链式使用。 + + +### 请求方法 + +　　同步与异步的`HttpTask`都拥有`get`、`post`、`put`与`delete`方法。不同的是：同步`HttpTask`的这些方法返回一个`HttpResult`，而异步`HttpTask`的这些方法返回一个`HttpCall`。 + +```java +HttpResult res1 = http.sync("/users").get(); // 同步 GET +HttpResult res2 = http.sync("/users").post(); // 同步 POST +HttpResult res3 = http.sync("/users/1").put(); // 同步 PUT +HttpResult res4 = http.sync("/users/1").delete();// 同步 DELETE +HttpCall call1 = http.async("/users").get(); // 异步 GET +HttpCall call2 = http.async("/users").post(); // 异步 POST +HttpCall call3 = http.async("/users/1").put(); // 异步 PUT +HttpCall call4 = http.async("/users/1").delete();// 异步 DELETE +``` + +**至此，你已轻松学会了 OkHttps 95% 的常规用法！但别急，后面还有更精彩的。** \ No newline at end of file diff --git a/docs/guide/android.md b/docs/guide/android.md new file mode 100644 index 00000000..0ec1dbbf --- /dev/null +++ b/docs/guide/android.md @@ -0,0 +1,168 @@ +## 回调线程切换 + +　　在 Android 开发中，经常会把某些代码放到特点的线程去执行，比如网络请求响应后的页面更新在主线程（UI线程）执行，而保存文件则在IO线程操作。OkHttps 为这类问题提供了良好的方案。 + +　　在 **默认** 情况下，**所有回调** 函数都会 **在 IO 线程** 执行。为什么会设计如此呢？这是因为 OkHttps 只是纯粹的 Java 领域 Http工具包，本身对 Android 不会有任何依赖，因此也不知 Android 的 UI 线程为何物。这么设计也让它在 Android 之外有更多的可能性。 + +　　但是在 Android 里使用 OkHttps 的话，UI线程的问题能否优雅的解决呢？当然可以！简单粗暴的方法就是配置一个 回调执行器： + + ```java +HTTP http = HTTP.builder() + .callbackExecutor((Runnable run) -> { + // 实际编码中可以吧 Handler 提出来，不需要每次执行回调都重新创建 + new Handler(Looper.getMainLooper()).post(run); // 在主线程执行 + }) + .build(); +``` +　　上述代码便实现了让 **所有** 的 **回调函数** 都在 **主线程（UI线程）** 执行的目的，如： + +```java +http.async("/users") + .addBodyParam("name", "Jack") + .setOnProcess((Process process) -> { + // 在主线程执行 + }) + .setOnResponse((HttpResult result) -> { + // 在主线程执行 + }) + .setOnException((Exception e) -> { + // 在主线程执行 + }) + .setOnComplete((State state) -> { + // 在主线程执行 + }) + .post(); +``` +　　但是，如果同时还想让某些回调放在IO线程，实现 **自由切换**，怎么办呢？OkHttps 给出了非常灵活的方法，如下： + +```java +http.async("/users") + .addBodyParam("name", "Jack") + .setOnProcess((Process process) -> { + // 在主线程执行 + }) + .nextOnIO() // 指定下一个回调在 IO 线程执行 + .setOnResponse((HttpResult result) -> { + // 在 IO 线程执行 + }) + .setOnException((Exception e) -> { + // 在主线程执行（没有指明 nextOnIO 则在回调执行器里执行） + }) + .nextOnIO() // 指定下一个回调在 IO 线程执行 + .setOnComplete((State state) -> { + // 在 IO 线程执行 + }) + .post(); +``` +　　无论是哪一个回调，都可以使用`nextOnIO()`方法自由切换。同样，对于文件下载也是一样： + +```java +http.sync("/download/test.zip") + .get() + .getBody() + .setOnProcess((Process process) -> { + // 在主线程执行 + }) + .toFolder("D:/download/") + .nextOnIO() // 指定下一个回调在 IO 线程执行 + .setOnSuccess((File file) -> { + // 在 IO 线程执行 + }) + .setOnFailure((Failure failure) -> { + // 在主线程执行 + }) + .start(); +``` + +## 生命周期绑定 + +　　由于 OkHttps 并不依赖于 Android，所以它并没有提供关于生命周期绑定的直接实现，但它的一些扩展机制让我们很容易就可以实现这个需求。在开始之前，我们首先要理解何为生命周期绑定： + +> 所谓的生命周期绑定：即是让 HTTP 任务感知其所属的 Activity 或 Fragment 的生命周期，当 Activity 或 Fragment 将被销毁时，框架应自动的把由它们发起的但尚未完成的 HTTP 任务全部取消，以免导致程序出错！ + +　　现在我们需要对`HTTP`实例进行配置，配置后的`HTTP`实例具有生命周期绑定的功能，在`Activity`或`Fragment`里，它的使用效果如下： + +```java +// 在 Activity 或 Fragment 内发起请求 +http.async("http://www.baidu.com") + .bind(getLifecycle()) // 绑定生命周期 + .setOnResponse((HttpResult result) -> { + Log.i("FirstFragment", "收到请求：" + result.toString()); + }) + .get(); +``` +　　上述代码中的`getLifecycle()`是`Activity`或`Fragment`自带的方法，而`bind()`是`HttpTask`的现有方法。在配置好`HTTP`实例后，上述代码发起的请求便可以感知`Activity`或`Fragment`的生命周期。 + +　　那`HTTP`实例到底该如何配置呢？ + +### 第一步：配置预处理器 + +```java +HTTP http = HTTP.builder() + ... // 省略其它配置项 + .addPreprocessor((Preprocessor.PreChain chain) -> { + HttpTask task = chain.getTask(); + Object bound = task.getBound(); + // 判断 task 是否绑定了 Lifecycle 对象 + if (bound instanceof Lifecycle) { + // 重新绑定一个 生命周期监视器（LCObserver）对象，它的定义见下一步 + task.bind(new LCObserver(task, (Lifecycle) bound)); + } + chain.proceed(); + }) + ... // 省略其它配置项 + .build(); +``` + +### 第二步：定义生命周期监视器 + +```java +public class LCObserver implements LifecycleObserver { + + HttpTask task; + Lifecycle lifecycle; + + LCObserver(HttpTask task, Lifecycle lifecycle) { + this.task = task; + this.lifecycle = lifecycle; + lifecycle.addObserver(this); + } + + @OnLifecycleEvent(Lifecycle.Event.ON_STOP) + public void onStop() { + task.cancel(); // 在 ON_STOP 事件中，取消对应的 HTTP 任务 + } + + public void unbind() { + // 在请求完成之后移除监视器 + lifecycle.removeObserver(this); + } + +} +``` + +### 第三步：配置全局回调监听 + +　　以上两步其实已经实现了生命周期绑定的功能，但是在请求完成之后，我们需要在`lifecycle`中移除`LCObserver`对象： + +```java +HTTP http = HTTP.builder() + ... // 省略其它配置项 + .completeListener((HttpTask task, HttpResult.State state) -> { + Object bound = task.getBound(); + // 判断 task 是否绑定了生命周期监视器（LCObserver）对象 + if (bound instanceof LCObserver) { + // 解绑监视器 + ((LCObserver) bound).unbind(); + } + return true; + }) + ... // 省略其它配置项 + .build(); +``` + +**以上三步便在Android中实现了生命周期与HTTP请求绑定的功能** + +　　非常简单，懒得敲代码的同学还可以 [点这里 OkHttps.java](https://gitee.com/ejlchina-zhxu/okhttps-android-demo/blob/master/app/src/main/java/com/flower/myapplication/http/OkHttps.java) 直接下载封装好的源码，其中不仅编写了生命周期绑定的配置，还有在UI线程执行回调的配置。 + +　　有需要的同学，可以直接下载下来使用，还可以基于它再次扩展，比如实现自动添加 TOKEN 的功能，具体可以参考[6.5 串行预处理器（TOKEN问题最佳解决方案）](#65-串行预处理器token问题最佳解决方案)，再比如扩展实现生命周期与下载事件绑定的功能，都非常简单。 diff --git a/docs/guide/getting-start.md b/docs/guide/getting-start.md index fda88cae..9d9bb495 100644 --- a/docs/guide/getting-start.md +++ b/docs/guide/getting-start.md @@ -1,20 +1,7 @@ -### 2 请求方法（GET|POST|PUT|DELETE） -　　同步与异步的`HttpTask`都拥有`get`、`post`、`put`与`delete`方法。不同的是：同步`HttpTask`的这些方法返回一个`HttpResult`，而异步`HttpTask`的这些方法返回一个`HttpCall`。 +## 解析请求结果 -```java -HttpResult res1 = http.sync("/users").get(); // 同步 GET -HttpResult res2 = http.sync("/users").post(); // 同步 POST -HttpResult res3 = http.sync("/users/1").put(); // 同步 PUT -HttpResult res4 = http.sync("/users/1").delete();// 同步 DELETE -HttpCall call1 = http.async("/users").get(); // 异步 GET -HttpCall call2 = http.async("/users").post(); // 异步 POST -HttpCall call3 = http.async("/users/1").put(); // 异步 PUT -HttpCall call4 = http.async("/users/1").delete();// 异步 DELETE -``` -### 3 解析请求结果 - -#### 3.1 回调函数 +### 回调函数 　　OkHttps 的回调函数全部使用单方法模式，这样可以充分利用 Java8 或 Kotlin 中的 Lambda 表达式，使你的代码更加简洁优雅： @@ -37,7 +24,7 @@ http.async("/users/{id}") // http://api.demo.com/users/1 >* 只有异步请求才可以设置这三种（响应|异常|完成）回调 >* 同步请求直接返回结果，无需使用回调 -#### 3.2 HttpResult +### HttpResult 　　`HttpResult`是HTTP请求执行完后的结果，它是同步请求方法（ `get`、`post`、`put`、`delete`）的返回值，也是异步请求响应回调（`OnResponse`）的参数，它定义了如下方法： @@ -109,7 +96,7 @@ System.out.println("size = " + size); ``` -#### 3.3 HttpCall +### HttpCall 　　`HttpCall`对象是异步请求方法（`get`、`post`、`put`、`delete`）的返回值，与`java`的`Future`接口很像，它有如下方法： @@ -131,7 +118,7 @@ System.out.println(success); // true System.out.println(call.isCanceled()); // true ``` -### 4 构建HTTP任务 +## 构建HTTP任务 　　`HTTP`对象的`sync`与`async`方法返回一个`HttpTask`对象，该对象提供了可链式调用的`addXXX`与`setXXX`等系列方法用于构建任务本身。 @@ -166,7 +153,7 @@ System.out.println(call.isCanceled()); // true * `bind(Object object)` 绑定一个对象，可用于实现Android里的生命周期绑定 -### 5 使用标签 +## 使用标签 　　有时候我们想对HTTP任务加以分类，这时候可以使用标签功能： @@ -200,9 +187,9 @@ System.out.println(count); // 输出 3 ``` 　　标签除了可以用来取消任务，在预处理器中它也可以发挥作用，请参见[并行预处理器](#54-并行预处理器)与[串行预处理器](#55-串行预处理器)。 -### 6 配置 HTTP +## 配置 HTTP -#### 6.1 设置 BaseUrl +### 设置 BaseUrl ```java HTTP http = HTTP.builder() @@ -225,7 +212,7 @@ http.sync("/auth/signin") // http://api.demo.com/auth/signin http.sync("https://www.baidu.com").get() ``` -#### 6.2 回调执行器 +### 回调执行器 　　OkHttps 默认所有回调都在 **IO线程** 执行，如何想改变执行回调的线程时，可以配置回调执行器。例如在Android里，让所有的回调函数都在UI线程执行，则可以在构建`HTTP`时配置如下： @@ -238,7 +225,7 @@ HTTP http = HTTP.builder() ``` 　　该配置默认 **影响所有回调**。 -#### 6.3 配置 OkHttpClient +### 配置 OkHttpClient 　　与其他封装 OkHttp3 的框架不同，OkHttps 并不会遮蔽 OkHttp3 本身就很好用的功能，如下： @@ -260,7 +247,7 @@ HTTP http = HTTP.builder() .build(); ``` -#### 6.4 并行预处理器 +### 并行预处理器 　　预处理器（`Preprocessor`）可以让我们在请求发出之前对请求本身做一些改变，但与`OkHttp`的拦截器（`Interceptor`）不同：预处理器可以让我们 **异步** 处理这些问题。 @@ -286,7 +273,7 @@ HTTP http = HTTP.builder() > * 拦截器都是并行处理请求，预处理器支持串行处理（详见6.5章节） > * 拦截器处理时机在请求前和响应后，预处理器只在请求前，并且先于拦截器执行。关于响应后，OkHttps还提供了全局回调监听（详见6.6章节） -#### 6.5 串行预处理器（TOKEN问题最佳解决方案） +### 串行预处理器（TOKEN问题最佳解决方案） 　　普通预处理器都是可并行处理的，然而有时我们希望某个预处理器同时只处理一个任务。比如 当`Token`过期时我们需要去刷新获取新`Token`，而刷新`Token`这个操作只能有一个任务去执行，因为如果`n`个任务同时执行的话，那么必有`n-1`个任务刚刷新得到的`Token`可能就立马失效了，而这是我们所不希望的。 @@ -309,7 +296,7 @@ HTTP http = HTTP.builder() ``` 　　串行预处理器实现了让HTTP任务排队串行处理的功能，但值得一提的是：它并没有因此而阻塞任何线程！ -#### 6.6 全局回调监听 +### 全局回调监听 ```java HTTP http = HTTP.builder() @@ -336,7 +323,7 @@ HTTP http = HTTP.builder() > * 拦截器处的理时机在请求前和响应后，全局回调监听只在响应后，并且晚于拦截器 > * 全局回调监听可以 **阻断**（return false）某个请求的具体回调，而拦截器不能 -#### 6.7 全局下载监听 +### 全局下载监听 ```java HTTP http = HTTP.builder() @@ -348,7 +335,7 @@ HTTP http = HTTP.builder() .build(); ``` -### 7 使用 HttpUtils 类 +## 使用 HttpUtils 类 　　类`HttpUtils`本是 [前身 HttpUtils](https://gitee.com/ejlchina-zhxu/httputils) 的 1.x 版本里的最重要的核心类，由于在后来的版本里抽象出了`HTTP`接口，使得它的重要性已不如往昔。但合理的使用它，仍然可以带来不少便利，特别是在没有IOC容器的环境里，比如在Android开发和一些工具项目的开发中。 @@ -380,229 +367,12 @@ List users = HttpUtils.sync("/users") .get().getBody().toList(User.class); ``` -### 8 文件下载 - -　　OkHttps 并没有把文件的下载排除在常规的请求之外，同一套API，它优雅的设计使得下载与常规请求融合的毫无违和感，一个最简单的示例： - -```java -http.sync("/download/test.zip") - .get() // 使用 GET 方法（其它方法也可以，看服务器支持） - .getBody() // 得到报文体 - .toFile("D:/download/test.zip") // 下载到指定的路径 - .start(); // 启动下载 - -http.sync("/download/test.zip").get().getBody() - .toFolder("D:/download") // 下载到指定的目录，文件名将根据下载信息自动生成 - .start(); -``` -　　或使用异步连接方式： - -```java -http.async("/download/test.zip") - .setOnResponse((HttpResult result) -> { - result.getBody().toFolder("D:/download").start(); - }) - .get(); -``` -　　这里要说明一下：`sync`与`async`的区别在于连接服务器并得到响应这个过程的同步与异步（这个过程的耗时在大文件下载中占比极小），而`start`方法启动的下载过程则都是异步的。 - -#### 8.1 下载进度监听 - -　　就直接上代码啦，诸君一看便懂： - -```java -http.sync("/download/test.zip") - .get() - .getBody() - .setStepBytes(1024) // 设置每接收 1024 个字节执行一次进度回调（不设置默认为 8192） - // .setStepRate(0.01) // 设置每接收 1% 执行一次进度回调（不设置以 StepBytes 为准） - .setOnProcess((Process process) -> { // 下载进度回调 - long doneBytes = process.getDoneBytes(); // 已下载字节数 - long totalBytes = process.getTotalBytes(); // 总共的字节数 - double rate = process.getRate(); // 已下载的比例 - boolean isDone = process.isDone(); // 是否下载完成 - }) - .toFolder("D:/download/") // 指定下载的目录，文件名将根据下载信息自动生成 - // .toFile("D:/download/test.zip") // 指定下载的路径，若文件已存在则覆盖 - .setOnSuccess((File file) -> { // 下载成功回调 - - }) - .start(); -``` -　　值得一提的是：由于 OkHttps 并没有把下载做的很特别，这里设置的进度回调不只对下载文件起用作，即使对响应JSON的常规请求，只要设置了进度回调，它也会告诉你报文接收的进度（提前是服务器响应的报文有`Content-Length`头），例如： - -```java -List users = http.sync("/users") - .get() - .getBody() - .setStepBytes(2) - .setOnProcess((Process process) -> { - System.out.println(process.getRate()); - }) - .toList(User.class); -``` - -#### 8.2 下载过程控制 - -　　过于简单：还是直接上代码： - -```java -Ctrl ctrl = http.sync("/download/test.zip") - .get() - .getBody() - .setOnProcess((Process process) -> { - System.out.println(process.getRate()); - }) - .toFolder("D:/download/") - .start(); // 该方法返回一个下载过程控制器 - -ctrl.status(); // 下载状态 -ctrl.pause(); // 暂停下载 -ctrl.resume(); // 恢复下载 -ctrl.cancel(); // 取消下载（同时会删除文件，不可恢复） -``` -　　无论是同步还是异步发起的下载请求，都可以做以上的控制： - -```java -http.async("/download/test.zip") - .setOnResponse((HttpResult result) -> { - // 拿到下载控制器 - Ctrl ctrl = result.getBody().toFolder("D:/download/").start(); - }) - .get(); -``` - -#### 8.3 实现断点续传 - -　　OkHttps 对断点续传并没有再做更高层次的封装，因为这是app该去做的事情，它在设计上使各种网络问题的处理变简单的同时力求纯粹。下面的例子可以看到，OkHttps 通过一个失败回调拿到 **断点**，便将复杂的问题变得简单： - -```java -http.sync("/download/test.zip") - .get() - .getBody() - .toFolder("D:/download/") - .setOnFailure((Failure failure) -> { // 下载失败回调，以便接收诸如网络错误等失败信息 - IOException e = failure.getException(); // 具体的异常信息 - long doneBytes = failure.getDoneBytes(); // 已下载的字节数（断点），需要保存，用于断点续传 - File file = failure.getFile(); // 下载生成的文件，需要保存 ，用于断点续传（只保存路径也可以） - }) - .start(); -``` -　　下面代码实现续传： - -```java -long doneBytes = ... // 拿到保存的断点 -File file = ... // 待续传的文件 - -http.sync("/download/test.zip") - .setRange(doneBytes) // 设置断点（已下载的字节数） - .get() - .getBody() - .toFile(file) // 下载到同一个文件里 - .setAppended() // 开启文件追加模式 - .setOnSuccess((File file) -> { - - }) - .setOnFailure((Failure failure) -> { - - }) - .start(); -``` - -#### 8.4 实现分块下载 - -　　当文件很大时，有时候我们会考虑分块下载，与断点续传的思路是一样的，示例代码： - -```java -static String url = "http://api.demo.com/download/test.zip" - -public static void main(String[] args) { - long totalSize = HttpUtils.sync(url).get().getBody() - .close() // 因为这次请求只是为了获得文件大小，不消费报文体，所以直接关闭 - .getContentLength(); // 获得待下载文件的大小（由于未消费报文体，所以该请求不会消耗下载报文体的时间和网络流量） - download(totalSize, 0); // 从第 0 块开始下载 - sleep(50000); // 等待下载完成（不然本例的主线程就结束啦） -} - -static void download(long totalSize, int index) { - long size = 3 * 1024 * 1024; // 每块下载 3M - long start = index * size; - long end = Math.min(start + size, totalSize); - HttpUtils.sync(url) - .setRange(start, end) // 设置本次下载的范围 - .get().getBody() - .toFile("D:/download/test.zip") // 下载到同一个文件里 - .setAppended() // 开启文件追加模式 - .setOnSuccess((File file) -> { - if (end < totalSize) { // 若未下载完，则继续下载下一块 - download(totalSize, index + 1); - } else { - System.out.println("下载完成"); - } - }) - .start(); -} -``` - -### 9 文件上传 -　　一个简单文件上传的示例： - -```java -http.sync("/upload") - .addFileParam("test", "D:/download/test.zip") - .post() // 上传发法一般使用 POST 或 PUT，看服务器支持 -``` -　　异步上传也是完全一样： - -```java -http.async("/upload") - .addFileParam("test", "D:/download/test.zip") - .post() -``` - -#### 9.1 上传进度监听 - -　　OkHttps 的上传进度监听，监听的是所有请求报文体的发送进度，示例代码： - -```java -http.sync("/upload") - .addBodyParam("name", "Jack") - .addBodyParam("age", 20) - .addFileParam("avatar", "D:/image/avatar.jpg") - .setStepBytes(1024) // 设置每发送 1024 个字节执行一次进度回调（不设置默认为 8192） - // .setStepRate(0.01) // 设置每发送 1% 执行一次进度回调（不设置以 StepBytes 为准） - .setOnProcess((Process process) -> { // 上传进度回调 - long doneBytes = process.getDoneBytes(); // 已发送字节数 - long totalBytes = process.getTotalBytes(); // 总共的字节数 - double rate = process.getRate(); // 已发送的比例 - boolean isDone = process.isDone(); // 是否发送完成 - }) - .post() -``` -　　咦！怎么感觉和下载的进度回调的一样？没错！OkHttps 还是使用同一套API处理上传和下载的进度回调，区别只在于上传是在`get/post`方法之前使用这些API，下载是在`getBody`方法之后使用。很好理解：`get/post`之前是准备发送请求时段，有上传的含义，而`getBody`之后，已是报文响应的时段，当然是下载。 - -#### 9.2 上传过程控制 - -　　上传文件的过程控制就很简单，和常规请求一样，只有异步发起的上传可以取消： - -```java -HttpCall call = http.async("/upload") - .addFileParam("test", "D:/download/test.zip") - .setOnProcess((Process process) -> { - System.out.println(process.getRate()); - }) - .post() - -call.cancel(); // 取消上传 -``` -　　上传就没有暂停和继续这个功能啦，应该没人有这个需求吧? - -### 10 异常处理 +## 异常处理 　　使用 OkHttps 时，**异常处理不是必须的**，但相比其它的 HTTP 开发包，它还提供一个特别的处理方法：`nothrow()`，以满足不同的异常处理需求。 -#### 10.1 同步请求的异常 +### 同步请求的异常 　　默认情况下，当同步请求执行异常时，会直接向外抛出，我们可以用 `try catch` 来捕获，例如： @@ -645,7 +415,7 @@ switch (result.getState()) { IOException error = result.getError(); ``` -#### 10.2 异步请求的异常 +### 异步请求的异常 　　异步请求最常用的异常处理方式就是设置一个异常回调： @@ -706,7 +476,7 @@ http.async("/users/1") }) .get(); ``` -### 11 取消请求的4种方式 +## 取消请求的4种方式 　　在 OkHttps 里取消请求共有 **4 种** 方式可选： @@ -731,190 +501,3 @@ boolean canceled = task.cancel(); ```java http.cancelAll(); // 取消所有请求 ``` - -### 12 回调线程自由切换（for Android） - -　　在 Android 开发中，经常会把某些代码放到特点的线程去执行，比如网络请求响应后的页面更新在主线程（UI线程）执行，而保存文件则在IO线程操作。OkHttps 为这类问题提供了良好的方案。 - -　　在 **默认** 情况下，**所有回调** 函数都会 **在 IO 线程** 执行。为什么会设计如此呢？这是因为 OkHttps 只是纯粹的 Java 领域 Http工具包，本身对 Android 不会有任何依赖，因此也不知 Android 的 UI 线程为何物。这么设计也让它在 Android 之外有更多的可能性。 - -　　但是在 Android 里使用 OkHttps 的话，UI线程的问题能否优雅的解决呢？当然可以！简单粗暴的方法就是配置一个 回调执行器： - - ```java -HTTP http = HTTP.builder() - .callbackExecutor((Runnable run) -> { - // 实际编码中可以吧 Handler 提出来，不需要每次执行回调都重新创建 - new Handler(Looper.getMainLooper()).post(run); // 在主线程执行 - }) - .build(); -``` -　　上述代码便实现了让 **所有** 的 **回调函数** 都在 **主线程（UI线程）** 执行的目的，如： - -```java -http.async("/users") - .addBodyParam("name", "Jack") - .setOnProcess((Process process) -> { - // 在主线程执行 - }) - .setOnResponse((HttpResult result) -> { - // 在主线程执行 - }) - .setOnException((Exception e) -> { - // 在主线程执行 - }) - .setOnComplete((State state) -> { - // 在主线程执行 - }) - .post(); -``` -　　但是，如果同时还想让某些回调放在IO线程，实现 **自由切换**，怎么办呢？OkHttps 给出了非常灵活的方法，如下： - -```java -http.async("/users") - .addBodyParam("name", "Jack") - .setOnProcess((Process process) -> { - // 在主线程执行 - }) - .nextOnIO() // 指定下一个回调在 IO 线程执行 - .setOnResponse((HttpResult result) -> { - // 在 IO 线程执行 - }) - .setOnException((Exception e) -> { - // 在主线程执行（没有指明 nextOnIO 则在回调执行器里执行） - }) - .nextOnIO() // 指定下一个回调在 IO 线程执行 - .setOnComplete((State state) -> { - // 在 IO 线程执行 - }) - .post(); -``` -　　无论是哪一个回调，都可以使用`nextOnIO()`方法自由切换。同样，对于文件下载也是一样： - -```java -http.sync("/download/test.zip") - .get() - .getBody() - .setOnProcess((Process process) -> { - // 在主线程执行 - }) - .toFolder("D:/download/") - .nextOnIO() // 指定下一个回调在 IO 线程执行 - .setOnSuccess((File file) -> { - // 在 IO 线程执行 - }) - .setOnFailure((Failure failure) -> { - // 在主线程执行 - }) - .start(); -``` -### 13 实现生命周期绑定（for Android） - -　　由于 OkHttps 并不依赖于 Android，所以它并没有提供关于生命周期绑定的直接实现，但它的一些扩展机制让我们很容易就可以实现这个需求。在开始之前，我们首先要理解何为生命周期绑定： - -> 所谓的生命周期绑定：即是让 HTTP 任务感知其所属的 Activity 或 Fragment 的生命周期，当 Activity 或 Fragment 将被销毁时，框架应自动的把由它们发起的但尚未完成的 HTTP 任务全部取消，以免导致程序出错！ - -　　现在我们需要对`HTTP`实例进行配置，配置后的`HTTP`实例具有生命周期绑定的功能，在`Activity`或`Fragment`里，它的使用效果如下： - -```java -// 在 Activity 或 Fragment 内发起请求 -http.async("http://www.baidu.com") - .bind(getLifecycle()) // 绑定生命周期 - .setOnResponse((HttpResult result) -> { - Log.i("FirstFragment", "收到请求：" + result.toString()); - }) - .get(); -``` -　　上述代码中的`getLifecycle()`是`Activity`或`Fragment`自带的方法，而`bind()`是`HttpTask`的现有方法。在配置好`HTTP`实例后，上述代码发起的请求便可以感知`Activity`或`Fragment`的生命周期。 - -　　那`HTTP`实例到底该如何配置呢？ - -#### 第一步：配置预处理器 - -```java -HTTP http = HTTP.builder() - ... // 省略其它配置项 - .addPreprocessor((Preprocessor.PreChain chain) -> { - HttpTask task = chain.getTask(); - Object bound = task.getBound(); - // 判断 task 是否绑定了 Lifecycle 对象 - if (bound instanceof Lifecycle) { - // 重新绑定一个 生命周期监视器（LCObserver）对象，它的定义见下一步 - task.bind(new LCObserver(task, (Lifecycle) bound)); - } - chain.proceed(); - }) - ... // 省略其它配置项 - .build(); -``` - -#### 第二步：定义生命周期监视器 - -```java -public class LCObserver implements LifecycleObserver { - - HttpTask task; - Lifecycle lifecycle; - - LCObserver(HttpTask task, Lifecycle lifecycle) { - this.task = task; - this.lifecycle = lifecycle; - lifecycle.addObserver(this); - } - - @OnLifecycleEvent(Lifecycle.Event.ON_STOP) - public void onStop() { - task.cancel(); // 在 ON_STOP 事件中，取消对应的 HTTP 任务 - } - - public void unbind() { - // 在请求完成之后移除监视器 - lifecycle.removeObserver(this); - } - -} -``` - -#### 第三步：配置全局回调监听 - -　　以上两步其实已经实现了生命周期绑定的功能，但是在请求完成之后，我们需要在`lifecycle`中移除`LCObserver`对象： - -```java -HTTP http = HTTP.builder() - ... // 省略其它配置项 - .completeListener((HttpTask task, HttpResult.State state) -> { - Object bound = task.getBound(); - // 判断 task 是否绑定了生命周期监视器（LCObserver）对象 - if (bound instanceof LCObserver) { - // 解绑监视器 - ((LCObserver) bound).unbind(); - } - return true; - }) - ... // 省略其它配置项 - .build(); -``` - -**以上三步便在Android中实现了生命周期与HTTP请求绑定的功能** - -　　非常简单，懒得敲代码的同学还可以 [点这里 OkHttps.java](https://gitee.com/ejlchina-zhxu/okhttps-android-demo/blob/master/app/src/main/java/com/flower/myapplication/http/OkHttps.java) 直接下载封装好的源码，其中不仅编写了生命周期绑定的配置，还有在UI线程执行回调的配置。 - -　　有需要的同学，可以直接下载下来使用，还可以基于它再次扩展，比如实现自动添加 TOKEN 的功能，具体可以参考[6.5 串行预处理器（TOKEN问题最佳解决方案）](#65-串行预处理器token问题最佳解决方案)，再比如扩展实现生命周期与下载事件绑定的功能，都非常简单。 - - -## 后期计划（v1.1.0） - -* 简化 WebSocket 编程：可直接发送 JavaBean 对象消息 -* 简化 WebSocket 编程：可直接接收 JavaBean 对象消息 -* 简化 WebSocket 编程：可使用 Lambda 表达式进行 WebSocket 编程 - -## 联系方式 - -* 微信： -* 邮箱：zhou.xu@ejlchina.com - -## 参与贡献 - -1. Fork 本仓库 -2. 新建 Feat_xxx 分支 -3. 提交代码 -4. 新建 Pull Request diff --git a/docs/guide/updown.md b/docs/guide/updown.md new file mode 100644 index 00000000..c1fffee4 --- /dev/null +++ b/docs/guide/updown.md @@ -0,0 +1,218 @@ + +## 文件下载 + +　　OkHttps 并没有把文件的下载排除在常规的请求之外，同一套API，它优雅的设计使得下载与常规请求融合的毫无违和感，一个最简单的示例： + +```java +http.sync("/download/test.zip") + .get() // 使用 GET 方法（其它方法也可以，看服务器支持） + .getBody() // 得到报文体 + .toFile("D:/download/test.zip") // 下载到指定的路径 + .start(); // 启动下载 + +http.sync("/download/test.zip").get().getBody() + .toFolder("D:/download") // 下载到指定的目录，文件名将根据下载信息自动生成 + .start(); +``` +　　或使用异步连接方式： + +```java +http.async("/download/test.zip") + .setOnResponse((HttpResult result) -> { + result.getBody().toFolder("D:/download").start(); + }) + .get(); +``` +　　这里要说明一下：`sync`与`async`的区别在于连接服务器并得到响应这个过程的同步与异步（这个过程的耗时在大文件下载中占比极小），而`start`方法启动的下载过程则都是异步的。 + +### 下载进度监听 + +　　就直接上代码啦，诸君一看便懂： + +```java +http.sync("/download/test.zip") + .get() + .getBody() + .setStepBytes(1024) // 设置每接收 1024 个字节执行一次进度回调（不设置默认为 8192） + // .setStepRate(0.01) // 设置每接收 1% 执行一次进度回调（不设置以 StepBytes 为准） + .setOnProcess((Process process) -> { // 下载进度回调 + long doneBytes = process.getDoneBytes(); // 已下载字节数 + long totalBytes = process.getTotalBytes(); // 总共的字节数 + double rate = process.getRate(); // 已下载的比例 + boolean isDone = process.isDone(); // 是否下载完成 + }) + .toFolder("D:/download/") // 指定下载的目录，文件名将根据下载信息自动生成 + // .toFile("D:/download/test.zip") // 指定下载的路径，若文件已存在则覆盖 + .setOnSuccess((File file) -> { // 下载成功回调 + + }) + .start(); +``` +　　值得一提的是：由于 OkHttps 并没有把下载做的很特别，这里设置的进度回调不只对下载文件起用作，即使对响应JSON的常规请求，只要设置了进度回调，它也会告诉你报文接收的进度（提前是服务器响应的报文有`Content-Length`头），例如： + +```java +List users = http.sync("/users") + .get() + .getBody() + .setStepBytes(2) + .setOnProcess((Process process) -> { + System.out.println(process.getRate()); + }) + .toList(User.class); +``` + +### 下载过程控制 + +　　过于简单：还是直接上代码： + +```java +Ctrl ctrl = http.sync("/download/test.zip") + .get() + .getBody() + .setOnProcess((Process process) -> { + System.out.println(process.getRate()); + }) + .toFolder("D:/download/") + .start(); // 该方法返回一个下载过程控制器 + +ctrl.status(); // 下载状态 +ctrl.pause(); // 暂停下载 +ctrl.resume(); // 恢复下载 +ctrl.cancel(); // 取消下载（同时会删除文件，不可恢复） +``` +　　无论是同步还是异步发起的下载请求，都可以做以上的控制： + +```java +http.async("/download/test.zip") + .setOnResponse((HttpResult result) -> { + // 拿到下载控制器 + Ctrl ctrl = result.getBody().toFolder("D:/download/").start(); + }) + .get(); +``` + +### 实现断点续传 + +　　OkHttps 对断点续传并没有再做更高层次的封装，因为这是app该去做的事情，它在设计上使各种网络问题的处理变简单的同时力求纯粹。下面的例子可以看到，OkHttps 通过一个失败回调拿到 **断点**，便将复杂的问题变得简单： + +```java +http.sync("/download/test.zip") + .get() + .getBody() + .toFolder("D:/download/") + .setOnFailure((Failure failure) -> { // 下载失败回调，以便接收诸如网络错误等失败信息 + IOException e = failure.getException(); // 具体的异常信息 + long doneBytes = failure.getDoneBytes(); // 已下载的字节数（断点），需要保存，用于断点续传 + File file = failure.getFile(); // 下载生成的文件，需要保存 ，用于断点续传（只保存路径也可以） + }) + .start(); +``` +　　下面代码实现续传： + +```java +long doneBytes = ... // 拿到保存的断点 +File file = ... // 待续传的文件 + +http.sync("/download/test.zip") + .setRange(doneBytes) // 设置断点（已下载的字节数） + .get() + .getBody() + .toFile(file) // 下载到同一个文件里 + .setAppended() // 开启文件追加模式 + .setOnSuccess((File file) -> { + + }) + .setOnFailure((Failure failure) -> { + + }) + .start(); +``` + +### 实现分块下载 + +　　当文件很大时，有时候我们会考虑分块下载，与断点续传的思路是一样的，示例代码： + +```java +static String url = "http://api.demo.com/download/test.zip" + +public static void main(String[] args) { + long totalSize = HttpUtils.sync(url).get().getBody() + .close() // 因为这次请求只是为了获得文件大小，不消费报文体，所以直接关闭 + .getContentLength(); // 获得待下载文件的大小（由于未消费报文体，所以该请求不会消耗下载报文体的时间和网络流量） + download(totalSize, 0); // 从第 0 块开始下载 + sleep(50000); // 等待下载完成（不然本例的主线程就结束啦） +} + +static void download(long totalSize, int index) { + long size = 3 * 1024 * 1024; // 每块下载 3M + long start = index * size; + long end = Math.min(start + size, totalSize); + HttpUtils.sync(url) + .setRange(start, end) // 设置本次下载的范围 + .get().getBody() + .toFile("D:/download/test.zip") // 下载到同一个文件里 + .setAppended() // 开启文件追加模式 + .setOnSuccess((File file) -> { + if (end < totalSize) { // 若未下载完，则继续下载下一块 + download(totalSize, index + 1); + } else { + System.out.println("下载完成"); + } + }) + .start(); +} +``` + +## 文件上传 + +　　一个简单文件上传的示例： + +```java +http.sync("/upload") + .addFileParam("test", "D:/download/test.zip") + .post() // 上传发法一般使用 POST 或 PUT，看服务器支持 +``` +　　异步上传也是完全一样： + +```java +http.async("/upload") + .addFileParam("test", "D:/download/test.zip") + .post() +``` + +### 上传进度监听 + +　　OkHttps 的上传进度监听，监听的是所有请求报文体的发送进度，示例代码： + +```java +http.sync("/upload") + .addBodyParam("name", "Jack") + .addBodyParam("age", 20) + .addFileParam("avatar", "D:/image/avatar.jpg") + .setStepBytes(1024) // 设置每发送 1024 个字节执行一次进度回调（不设置默认为 8192） + // .setStepRate(0.01) // 设置每发送 1% 执行一次进度回调（不设置以 StepBytes 为准） + .setOnProcess((Process process) -> { // 上传进度回调 + long doneBytes = process.getDoneBytes(); // 已发送字节数 + long totalBytes = process.getTotalBytes(); // 总共的字节数 + double rate = process.getRate(); // 已发送的比例 + boolean isDone = process.isDone(); // 是否发送完成 + }) + .post() +``` +　　咦！怎么感觉和下载的进度回调的一样？没错！OkHttps 还是使用同一套API处理上传和下载的进度回调，区别只在于上传是在`get/post`方法之前使用这些API，下载是在`getBody`方法之后使用。很好理解：`get/post`之前是准备发送请求时段，有上传的含义，而`getBody`之后，已是报文响应的时段，当然是下载。 + +### 上传过程控制 + +　　上传文件的过程控制就很简单，和常规请求一样，只有异步发起的上传可以取消： + +```java +HttpCall call = http.async("/upload") + .addFileParam("test", "D:/download/test.zip") + .setOnProcess((Process process) -> { + System.out.println(process.getRate()); + }) + .post() + +call.cancel(); // 取消上传 +``` +　　上传就没有暂停和继续这个功能啦，应该没人有这个需求吧? \ No newline at end of file From 636cd57228cc689fe8b40fbcec211e8dd202db62 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?=E5=91=A8=E6=97=AD?= Date: Tue, 28 Apr 2020 14:08:29 +0800 Subject: [PATCH 180/924] docs --- docs/.vuepress/config.js | 8 +- docs/README.md | 4 +- docs/guide/README.md | 32 +-- docs/guide/android.md | 9 +- docs/guide/configuration.md | 150 +++++++++++ docs/guide/features.md | 164 ++++++++++++ docs/guide/foundation.md | 203 +++++++++++++++ docs/guide/getting-start.md | 503 ------------------------------------ 8 files changed, 544 insertions(+), 529 deletions(-) create mode 100644 docs/guide/configuration.md create mode 100644 docs/guide/features.md create mode 100644 docs/guide/foundation.md delete mode 100644 docs/guide/getting-start.md diff --git a/docs/.vuepress/config.js b/docs/.vuepress/config.js index 7f15ba16..cb8d6db8 100644 --- a/docs/.vuepress/config.js +++ b/docs/.vuepress/config.js @@ -13,9 +13,15 @@ module.exports = { ], sidebar: [ ['/guide/', '起步'], - ['/guide/getting-start', '一探究竟'], + ['/guide/foundation', '基础'], + ['/guide/configuration', '配置'], + ['/guide/features', '特色'], + ['/guide/updown', '上传下载'], ['/guide/android', '安卓'], ], sidebarDepth: 2 + }, + markdown: { + lineNumbers: true } } \ No newline at end of file diff --git a/docs/README.md b/docs/README.md index 09bbef40..fcb54b8f 100644 --- a/docs/README.md +++ b/docs/README.md @@ -13,7 +13,7 @@ features: - title: 更多实用特性 details: URL 占位符、Lambda 回调、JSON自动封装解析、OkHttp 的特性：拦截器、连接池、CookieJar 等。 -footer: Apache Licensed | Copyright © 2020-present Troy Zhou +footer: Apache Licensed | Copyright © 2020-present ejlchina --- @@ -38,4 +38,4 @@ http.async("/users/jack") // http://api.demo.com/users/jack .get(); // GET请求 ``` -**
就这么简单，你已学会 OkHttps 90% 的用法！
** \ No newline at end of file +**
就这么简单，你已学会了 90% 的用法！
** \ No newline at end of file diff --git a/docs/guide/README.md b/docs/guide/README.md index f2cda81c..0725a00d 100644 --- a/docs/guide/README.md +++ b/docs/guide/README.md @@ -9,10 +9,11 @@ * 单方法回调，充分利用 Lambda 表达式 * TCP连接池、Http2 -> 1. OkHttps 非常轻量（59Kb），是 Retrofit（124Kb）的一半，并且更加的开箱即用，API 也更加自然和语义化。 -> 2. OkHttps 是一个纯粹的 Java 网络开发包，并不依赖 Android，这一点和 Retrofit 不同 -> 3. OkHttps 用起来很优美，可以像 RxJava 那样链式用，却比 RxJava 更简单。 - +::: tip +* OkHttps 非常轻量（59Kb），仅是 Retrofit（124Kb）的一半，并且更加的开箱即用，API 也更加自然和语义化。 +* OkHttps 是一个纯粹的 Java 网络开发包，并不依赖 Android，这一点和 Retrofit 不同 +* OkHttps 用起来很优美，可以像 RxJava 那样链式用，却比 RxJava 更简单。 +::: ## 安装 @@ -27,7 +28,9 @@ ``` ### Gradle -`implementation 'com.ejlchina:okhttps:1.0.5'` +```groovy +implementation 'com.ejlchina:okhttps:1.0.5' +``` 安卓中使用需要把 JDK 版本调成 1.8，在 app 模块的 build.gradle 中加入以下配置即可： @@ -50,14 +53,14 @@ HTTP http = HTTP.builder().build(); ``` 　　以上代码构建了一个最简单的`HTTP`实例，它拥有以下方法： -* `async(String url)` 开始一个异步请求 * `sync(String url)` 开始一个同步请求 +* `async(String url)` 开始一个异步请求 * `cancel(String tag)` 按标签取消请求 * `cancelAll()` 取消所有HTTP任务，包括同步和异步 * `request(Request request)` OkHttp 原生请求 * `webSocket(Request request, WebSocketListener listener)` WebSocket通讯 -　　为了使用方便，在构建的时候，我们更愿意指定一个`BaseUrl`（请参见[5.1 设置 BaseUrl](#51-设置-baseurl)）: +　　为了使用方便，在构建的时候，我们更愿意指定一个`BaseUrl`（详见 [设置 BaseUrl](/guide/configuration.html#设置-baseurl)）: ```java HTTP http = HTTP.builder() @@ -93,19 +96,4 @@ http.async("/users/1") // http://api.demo.com/users/1 　　方法`async`返回一个异步`HttpTask`，可链式使用。 -### 请求方法 - -　　同步与异步的`HttpTask`都拥有`get`、`post`、`put`与`delete`方法。不同的是：同步`HttpTask`的这些方法返回一个`HttpResult`，而异步`HttpTask`的这些方法返回一个`HttpCall`。 - -```java -HttpResult res1 = http.sync("/users").get(); // 同步 GET -HttpResult res2 = http.sync("/users").post(); // 同步 POST -HttpResult res3 = http.sync("/users/1").put(); // 同步 PUT -HttpResult res4 = http.sync("/users/1").delete();// 同步 DELETE -HttpCall call1 = http.async("/users").get(); // 异步 GET -HttpCall call2 = http.async("/users").post(); // 异步 POST -HttpCall call3 = http.async("/users/1").put(); // 异步 PUT -HttpCall call4 = http.async("/users/1").delete();// 异步 DELETE -``` - **至此，你已轻松学会了 OkHttps 95% 的常规用法！但别急，后面还有更精彩的。** \ No newline at end of file diff --git a/docs/guide/android.md b/docs/guide/android.md index 0ec1dbbf..534edb64 100644 --- a/docs/guide/android.md +++ b/docs/guide/android.md @@ -4,6 +4,8 @@ 　　在 **默认** 情况下，**所有回调** 函数都会 **在 IO 线程** 执行。为什么会设计如此呢？这是因为 OkHttps 只是纯粹的 Java 领域 Http工具包，本身对 Android 不会有任何依赖，因此也不知 Android 的 UI 线程为何物。这么设计也让它在 Android 之外有更多的可能性。 +### 配置 + 　　但是在 Android 里使用 OkHttps 的话，UI线程的问题能否优雅的解决呢？当然可以！简单粗暴的方法就是配置一个 回调执行器： ```java @@ -14,6 +16,9 @@ HTTP http = HTTP.builder() }) .build(); ``` + +### 用例 + 　　上述代码便实现了让 **所有** 的 **回调函数** 都在 **主线程（UI线程）** 执行的目的，如： ```java @@ -78,7 +83,9 @@ http.sync("/download/test.zip") 　　由于 OkHttps 并不依赖于 Android，所以它并没有提供关于生命周期绑定的直接实现，但它的一些扩展机制让我们很容易就可以实现这个需求。在开始之前，我们首先要理解何为生命周期绑定： -> 所谓的生命周期绑定：即是让 HTTP 任务感知其所属的 Activity 或 Fragment 的生命周期，当 Activity 或 Fragment 将被销毁时，框架应自动的把由它们发起的但尚未完成的 HTTP 任务全部取消，以免导致程序出错！ +::: tip HTTP 请求的生命周期绑定 +所谓的生命周期绑定：即是让 HTTP 任务感知其所属的 Activity 或 Fragment 的生命周期，当 Activity 或 Fragment 将被销毁时，框架应自动的把由它们发起的但尚未完成的 HTTP 任务全部取消，以免导致程序出错！ +::: 　　现在我们需要对`HTTP`实例进行配置，配置后的`HTTP`实例具有生命周期绑定的功能，在`Activity`或`Fragment`里，它的使用效果如下： diff --git a/docs/guide/configuration.md b/docs/guide/configuration.md new file mode 100644 index 00000000..8d8fbba8 --- /dev/null +++ b/docs/guide/configuration.md @@ -0,0 +1,150 @@ +## 设置 BaseUrl + +```java +HTTP http = HTTP.builder() + .baseUrl("http://api.demo.com") // 设置 BaseUrl + .build(); +``` +　　该配置全局生效，在配置了`BaseUrl`之后，具体的请求便可以省略`BaseUrl`部分，使得代码更加简洁，例如： + +```java +http.sync("/users").get() // http://api.demo.com/users + +http.sync("/auth/signin") // http://api.demo.com/auth/signin + .addBodyParam("username", "Jackson") + .addBodyParam("password", "xxxxxx") + .post() // POST请求 +``` +　　在配置了`BaseUrl`之后，如有特殊请求任务，仍然可以使用全路径的方式，一点都不妨碍： + +```java +http.sync("https://www.baidu.com").get() +``` + +## 回调执行器 + +　　OkHttps 默认所有回调都在 **IO线程** 执行，如何想改变执行回调的线程时，可以配置回调执行器。例如在Android里，让所有的回调函数都在UI线程执行，则可以在构建`HTTP`时配置如下： + +```java +HTTP http = HTTP.builder() + .callbackExecutor((Runnable run) -> { + runOnUiThread(run); // 在UI线程执行 + }) + .build(); +``` +　　该配置默认 **影响所有回调**。 + +## 配置 OkHttpClient + +　　与其他封装 OkHttp3 的框架不同，OkHttps 并不会遮蔽 OkHttp3 本身就很好用的功能，如下： + +```java +HTTP http = HTTP.builder() + .config((Builder builder) -> { + // 配置连接池 最小10个连接（不配置默认为 5） + builder.connectionPool(new ConnectionPool(10, 5, TimeUnit.MINUTES)); + // 配置连接超时时间（默认10秒） + builder.connectTimeout(20, TimeUnit.SECONDS); + // 配置拦截器 + builder.addInterceptor((Chain chain) -> { + Request request = chain.request(); + // 必须同步返回，拦截器内无法执行异步操作 + return chain.proceed(request); + }); + // 其它配置: CookieJar、SSL、缓存、代理、事件监听... + }) + .build(); +``` + +## 并行预处理器 + +　　预处理器（`Preprocessor`）可以让我们在请求发出之前对请求本身做一些改变，但与`OkHttp`的拦截器（`Interceptor`）不同：预处理器可以让我们 **异步** 处理这些问题。 + +　　例如，当我们想为请求任务自动添加`Token`头信息，而`Token`只能通过异步方法`requestToken`获取时，这时使用`Interceptor`就很难处理了，但可以使用预处理器轻松解决： + +```java +HTTP http = HTTP.builder() + .addPreprocessor((PreChain chain) -> { + HttpTask task = chain.getTask();// 获得当前的HTTP任务 + if (!task.isTagged("Auth")) { // 根据标签判断该任务是否需要Token + return; + } + requestToken((String token) -> { // 异步获取 Token + task.addHeader("Token", token);// 为任务添加头信息 + chain.proceed(); // 继续当前的任务 + }); + }) + .build(); +``` +　　和`Interceptor`一样，`Preprocessor`也可以添加多个。他们之间的区别如下: + +::: tip 拦截器与预处理器的区别 +* 拦截器只能处理同步操作，预处理器支持处理异步操作 +* 拦截器都是并行处理请求，预处理器支持串行处理（详见6.5章节） +* 拦截器处理时机在请求前和响应后，预处理器只在请求前，并且先于拦截器执行。关于响应后，OkHttps还提供了全局回调监听（详见6.6章节） +::: + +## 串行预处理器（TOKEN问题最佳解决方案） + +　　普通预处理器都是可并行处理的，然而有时我们希望某个预处理器同时只处理一个任务。比如 当`Token`过期时我们需要去刷新获取新`Token`，而刷新`Token`这个操作只能有一个任务去执行，因为如果`n`个任务同时执行的话，那么必有`n-1`个任务刚刷新得到的`Token`可能就立马失效了，而这是我们所不希望的。 + +　　为了解决这个问题，OkHttps 提供了串行预处理器，它可以让 HTTP 任务排好队，一个一个地进入预处理器： + +```java +HTTP http = HTTP.builder() + .addSerialPreprocessor((PreChain chain) -> { + HttpTask task = chain.getTask(); + if (!task.isTagged("Auth")) { + return; + } + // 检查过期，若需要则刷新Token + requestTokenAndRefreshIfExpired((String token) -> { + task.addHeader("Token", token); + chain.proceed(); // 调用此方法前，不会有其它任务进入该处理器 + }); + }) + .build(); +``` +　　串行预处理器实现了让HTTP任务排队串行处理的功能，但值得一提的是：它并没有因此而阻塞任何线程！ + +## 全局回调监听 + +　　全局回调是实际开发中经常需要的功能，比如对服务器响应的状态码进行统一处理等，同时 OkHttps 的全局回调还具有 **回调阻断** 的功能： + +```java +HTTP http = HTTP.builder() + .responseListener((HttpTask task, HttpResult result) -> { + // 所有请求响应后都会走这里 + + return true; // 返回 true 表示继续执行 task 的 OnResponse 回调，false 表示不再执行 + }) + .completeListener((HttpTask task, State state) -> { + // 所有请求执行完都会走这里 + + return true; // 返回 true 表示继续执行 task 的 OnComplete 回调，false 表示不再执行 + }) + .exceptionListener((HttpTask task, IOException error) -> { + // 所有请求发生异常都会走这里 + + return true; // 返回 true 表示继续执行 task 的 OnException 回调，false 表示不再执行 + }) + .build(); +``` + +::: tip 全局回调监听与拦截器的异同： +* 拦截器可以添加多个，全局回调监听分三种，每种最多添加一个 +* 拦截器处的理时机在请求前和响应后，全局回调监听只在响应后，并且晚于拦截器 +* 全局回调监听可以 **阻断**（return false）某个请求的具体回调，而拦截器不能 +::: + +## 全局下载监听 + +```java +HTTP http = HTTP.builder() + .downloadListener((HttpTask task, Download download) -> { + // 所有下载在开始之前都会先走这里 + Ctrl ctrl = download.getCtrl(); // 下载控制器 + + }) + .build(); +``` \ No newline at end of file diff --git a/docs/guide/features.md b/docs/guide/features.md new file mode 100644 index 00000000..fedc980f --- /dev/null +++ b/docs/guide/features.md @@ -0,0 +1,164 @@ +## 使用 HttpUtils 类 + +　　类`HttpUtils`本是 [前身 HttpUtils](https://gitee.com/ejlchina-zhxu/httputils) 的 1.x 版本里的最重要的核心类，由于在后来的版本里抽象出了`HTTP`接口，使得它的重要性已不如往昔。但合理的使用它，仍然可以带来不少便利，特别是在没有IOC容器的环境里，比如在Android开发和一些工具项目的开发中。 + +　　类`HttpUtils`共定义了四个静态方法： + +* `of(HTTP http)` 配置`HttpUtils`持有的`HTTP`实例（不调用此方法前默认使用一个没有没有经过任何配置的`HTTP`懒实例） +* `sync(String url)` 开始一个同步请求 （内部通过一个`HTTP`单例实现） +* `async(String url)` 开始一个异步请求 （内部通过一个`HTTP`单例实现） +* `cancel(String tag)` 按标签取消请求（内部通过一个`HTTP`单例实现） +* `cancelAll()` 取消所有HTTP任务，包括同步和异步（内部通过一个`HTTP`单例实现） +* `request(Request request)` OkHttp 原生请求 （该请求不经过 预处理器） +* `webSocket(Request request, WebSocketListener listener)` WebSocket通讯 +　　也就是说，能使用`http`实例的地方，都可以使用`HttpUtils`类，例如： + +```java +// 在配置HTTP实例之前，只能使用全路径方式 +List roles = HttpUtils.sync("http://api.demo.com/roles") + .get().getBody().toList(Role.class); + +// 配置HTTP实例,全局生效 +HttpUtils.of(HTTP.builder() + .baseUrl("http://api.demo.com") + .build()); + +// 内部使用新的HTTP实例 +List users = HttpUtils.sync("/users") + .get().getBody().toList(User.class); +``` + +## 异常处理 + +　　使用 OkHttps 时，**异常处理不是必须的**，但相比其它的 HTTP 开发包，它还提供一个特别的处理方法：`nothrow()`，以满足不同的异常处理需求。 + +### 同步请求的异常 + +　　默认情况下，当同步请求执行异常时，会直接向外抛出，我们可以用 `try catch` 来捕获，例如： + +```java +try { + HttpResult result = http.sync("/users/1").get(); +} catch (HttpException e) { + Throwable cause = e.getCause(); // 得到异常原因 + if (cause instanceof ConnectException) { + // 当没网络时，会抛出连接异常 + } + if (cause instanceof SocketTimeoutException) { + // 当接口长时间未响应，会抛出超时异常 + } + if (cause instanceof UnknownHostException) { + // 当把域名或IP写错，会抛出 UnknownHost 异常 + } + // ... +} +``` +　　这种传统的异常处理方式，当然可以解决问题，但 OkHttps 有更佳的方案： + +```java +// 方法 nothrow() 让异常不直接抛出 +HttpResult result = http.sync("/users/1").nothrow().get(); +// 判断执行状态 +switch (result.getState()) { + case RESPONSED: // 请求已正常响应 + break; + case CANCELED: // 请求已被取消 + break; + case NETWORK_ERROR: // 网络错误，说明用户没网了 + break; + case TIMEOUT: // 请求超时 + break; + case EXCEPTION: // 其它异常 + break; +} +// 还可以获得具体的异常信息 +IOException error = result.getError(); +``` + +### 异步请求的异常 + +　　异步请求最常用的异常处理方式就是设置一个异常回调： + +```java +http.async("/users/1") + .setOnResponse((HttpResult result) -> { + // 当发生异常时就不会走这里 + }) + .setOnException((IOException e) -> { + // 这里处理请求异常 + }) + .get(); +``` +　　当然，还有一个全局异常监听（`ExceptionListener`）： + +```java +HTTP http = HTTP.builder() + .exceptionListener((HttpTask task, IOException error) -> { + // 所有请求发生异常都会走这里 + + return true; // 返回 true 表示继续执行 task 的 OnException 回调，false 表示不再执行 + }) + .build(); +``` +　　如果不设置`OnException`回调，也没有`ExceptionListener`，发生异常时会在 **IO 线程** 中向上抛出，外层无法捕获： + +```java +try { + http.async("/users/1") + .setOnResponse((HttpResult result) -> { + // 当发生异常时就不会走这里 + }) + .get(); +} catch (HttpException e) { + // 这种方式是捕获不到异常的！！！！！！ +} +``` +　　即使没有`OnException`回调，发生异常时，依然会走`OnComplete`回调，如果设置了的话： + +```java +http.async("/users/1") + .setOnResponse((HttpResult result) -> { + // 当发生异常时就不会走这里 + }) + .setOnComplete((State state) -> { + // 发生异常，会先执行这里，可以根据 state 判断发生了什么 + // 但执行完后依然会在IO线程中向上抛出 + }) + .get(); +``` +　　如果就是想 **不处理异常，也不向上抛出**，发生错误完全无视，可以做到吗？可以！还是使用`nothrow()`方法： + +```java +http.async("/users/1") + .nothrow() // 告诉 OkHttps 发生异常时不向外抛出 + .setOnResponse((HttpResult result) -> { + // 当发生异常时就不会走这里 + }) + .get(); +``` + +## 取消请求 + +　　在 OkHttps 里取消请求共有 **4 种** 方式可选： + +* 使用`HttpCall#cancel()`取消单个请求（适用于异步请求，[详见 3.3 章节](#33-httpcall)） +* 使用`HttpTask#cancel()`取消单个请求（适用于所有请求）（since v1.0.4） + +```java +HttpTask task = http.async("/users") + .setOnResponse((HttpResult result) -> { + // 响应回调 + }); + +task.get(); // 发起 GET 请求 + +// 取消请求，并返回是否取消成功 +boolean canceled = task.cancel(); +``` + +* 使用`HTTP#cancel(String tag)`按标签批量取消请求（适用于所有请求，[详见第 5 章节](#5-使用标签)） +* 使用`HTTP#cancelAll()`取消所有请求（适用于所有请求）（since v1.0.2） + +```java +http.cancelAll(); // 取消所有请求 +``` \ No newline at end of file diff --git a/docs/guide/foundation.md b/docs/guide/foundation.md new file mode 100644 index 00000000..b0a3b173 --- /dev/null +++ b/docs/guide/foundation.md @@ -0,0 +1,203 @@ +## 请求方法 + +　　同步与异步的`HttpTask`都拥有`get`、`post`、`put`与`delete`方法。不同的是：同步`HttpTask`的这些方法返回一个`HttpResult`，而异步`HttpTask`的这些方法返回一个`HttpCall`。 + +```java +HttpResult res1 = http.sync("/users").get(); // 同步 GET +HttpResult res2 = http.sync("/users").post(); // 同步 POST +HttpResult res3 = http.sync("/users/1").put(); // 同步 PUT +HttpResult res4 = http.sync("/users/1").delete();// 同步 DELETE +HttpCall call1 = http.async("/users").get(); // 异步 GET +HttpCall call2 = http.async("/users").post(); // 异步 POST +HttpCall call3 = http.async("/users/1").put(); // 异步 PUT +HttpCall call4 = http.async("/users/1").delete();// 异步 DELETE +``` + +## 回调函数 + +　　OkHttps 的回调函数全部使用单方法模式，这样可以充分利用 Java8 或 Kotlin 中的 Lambda 表达式，使你的代码更加简洁优雅： + +```java +http.async("/users/{id}") // http://api.demo.com/users/1 + .addPathParam("id", 1) + .setOnResponse((HttpResult result) -> { + // 响应回调 + }) + .setOnException((IOException e) -> { + // 异常回调 + }) + .setOnComplete((State state) -> { + // 完成回调，无论成功失败都会执行 + // 并且在 响应|异常回调 之前执行 + }) + .get(); +``` + +　　OkHttps 同时还支持 **全局回调** 和 **回调阻断** 机制，详见 [全局回调监听](/guide/configuration.html#全局回调监听)。 + +::: tip +* 只有异步请求才可以设置这三种（响应|异常|完成）回调 +* 同步请求直接返回结果，无需使用回调 +::: + +## HttpResult + +　　`HttpResult`是HTTP请求执行完后的结果，它是同步请求方法（ `get`、`post`、`put`、`delete`）的返回值，也是异步请求响应回调（`OnResponse`）的参数，它定义了如下方法： + +* `getState()` 得到请求执行状态枚举，它有以下取值： + * `State.CANCELED` 请求被取消 + * `State.RESPONSED` 已收到响应 + * `State.TIMEOUT` 请求超时 + * `State.NETWORK_ERROR` 网络错误 + * `State.EXCEPTION` 其它请求异常 +* `getStatus()` 得到HTTP状态码 +* `isSuccessful()` 是否响应成功，状态码在 [200..300) 之间 +* `getHeaders()` 得到HTTP响应头 +* `getHeaders(String name)` 得到HTTP响应头 +* `getHeader(String name)` 得到HTTP响应头 +* `getBody()` 得到响应报文体`Body`实例，它定义了如下方法（对同一个`Body`实例，以下的`toXXX()`类方法只能使用一个且仅能调用一次，除非先使用 cache 方法）： + * `toBytes()` 返回字节数组 + * `toByteStream()` 返回字节输入流 + * `toCharStream()` 返回字符输入流 + * `toString()` 返回字符串 + * `toJsonObject()` 返回Json对象 + * `toJsonArray()` 返回Json数组 + * `toBean(Class type)` 返回根据type自动json解析后的JavaBean + * `toList(Class type)` 返回根据type自动json解析后的JavaBean列表 + * `toFile(String filePath)` 下载到指定路径 + * `toFile(File file)` 下载到指定文件 + * `toFolder(String dirPath)` 下载到指定目录 + * `toFolder(File dir)` 下载到指定目录 + * `getContentType()` 返回报文体的媒体类型 + * `getContentLength()` 返回报文体的字节长度 + * `cache()` 缓存报文体，开启缓存后可重复使用`toXXX()`类方法 + * `close()` 关闭报文体，未对报文体做任何消费时使用，比如只读取报文头 +* `getError()` 执行中发生的异常，自动捕获执行请求时发生的 网络超时、网络错误 和 其它IO异常 +* `close()` 关闭报文，未对报文体做任何消费时使用，比如只读取长度 + +　　示例，请求结果自动转Bean和List： + +```java +// 自动转Bean +Order order = http.sync("/orders/1") + .get().getBody().toBean(Order.class); + +// 自动转List +List orders = http.sync("/orders") + .get().getBody().toList(Order.class); +``` + +　　示例，使用 cache 方法： + +```java +Body body = http.sync("/orders").get().getBody().cache(); + +// 使用 cache 后，可以多次使用 toXXX() 方法 +System.out.println(body.toString()); +System.out.println(body.toJsonArray()); +System.out.println(body.toList(Order.class)); +``` + +　　示例，获取下载文件的大小： + +```java +long size = http.sync("/download/test.zip") + .get().getBody() + .close() // 只是想获得文件大小，不消费报文体，所以直接关闭 + .getContentLength(); // 获得待下载文件的大小 + +// 由于未消费报文体，所以本次请求不会消耗下载报文体的时间和网络流量 + +System.out.println("size = " + size); +``` + +## HttpCall + +　　`HttpCall`对象是异步请求方法（`get`、`post`、`put`、`delete`）的返回值，与`java`的`Future`接口很像，它有如下方法： + +* `cancel()` 取消本次请求，返回取消结果 +* `isCanceled()` 返回请求是否被取消 +* `isDone()` 返回是否执行完成，包含取消和失败 +* `getResult()` 返回执行结果`HttpResult`对象，若请求未执行完，则挂起当前线程直到执行完成再返回 + +　　取消一个异步请求示例： + +```java +HttpCall call = http.async("/users/1").get(); + +System.out.println(call.isCanceled()); // false + +boolean success = call.cancel(); // 取消请求 + +System.out.println(success); // true +System.out.println(call.isCanceled()); // true +``` + +## 构建HTTP任务 + +　　`HTTP`对象的`sync`与`async`方法返回一个`HttpTask`对象，该对象提供了可链式调用的`addXXX`与`setXXX`等系列方法用于构建任务本身。 + +* `addHeader(String name, String value)` 添加请求头 +* `addHeader(Map headers)` 添加请求头 + +* `addPathParam(String name, Object value)` 添加路径参数：替换URL里的{name}占位符 +* `addPathParam(Map params)` 添加路径参数：替换URL里的{name}占位符 + +* `addUrlParam(String name, Object value)` 添加URL参数：拼接在URL的?之后（查询参数） +* `addUrlParam(Map params)` 添加URL参数：拼接在URL的?之后（查询参数） + +* `addBodyParam(String name, Object value)` 添加Body参数：以表单key=value&的形式放在报文体内（表单参数） +* `addBodyParam(Map params)` 添加Body参数：以表单key=value&的形式放在报文体内（表单参数） + +* `addJsonParam(String name, Object value)` 添加Json参数：请求体为Json（支持多层结构） +* `addJsonParam(Map params)` 添加Json参数：请求体为Json（支持多层结构） + +* `setRequestJson(Object json)` 设置请求体的Json字符串 或待转换为 Json的 JavaBean +* `setRequestJson(Object bean, String dateFormat)` 设置请求体的Json字符串 或待转换为 Json的 JavaBean + +* `addFileParam(String name, String filePath)` 上传文件 +* `addFileParam(String name, File file)` 上传文件 +* `addFileParam(String name, String type, InputStream inputStream)` 上传文件 +* `addFileParam(String name, String type, String fileName, InputStream input)` 上传文件 +* `addFileParam(String name, String type, byte[] content)` 上传文件 +* `addFileParam(String name, String type, String fileName, byte[] content)` 上传文件 + +* `setTag(String tag)` 为HTTP任务添加标签 +* `setRange(long rangeStart)` 设置Range头信息，用于[断点续传](/guide/updown.html#实现断点续传) +* `setRange(long rangeStart, long rangeEnd)` 设置Range头信息，可用于[分块下载](/guide/updown.html#实现分块下载) + +* `bind(Object object)` 绑定一个对象，可用于实现Android里的[生命周期绑定](/guide/android.html#生命周期绑定) + +## 使用标签 + +　　有时候我们想对HTTP任务加以分类，这时候可以使用标签功能： + +```java +http.async("/users") //（1） + .setTag("A") + .get(); + +http.async("/users") //（2） + .setTag("A.B") + .get(); + +http.async("/users") //（3） + .setTag("B") + .get(); + +http.async("/users") //（4） + .setTag("B") + .setTag("C") // 从 v1.0.4 标签将以追加模式添加，等效于 setTag("B.C") + .get(); + +http.async("/users") //（5） + .setTag("C") + .get(); +``` +　　当使用标签后，就可以按标签批量的对HTTP任务进行取消： + +```java +int count = http.cancel("B"); //（2）（3）（4）被取消（取消标签包含"B"的任务） +System.out.println(count); // 输出 3 +``` +　　标签除了可以用来取消任务，在预处理器中它也可以发挥作用，请参见 [并行预处理器](/guide/configuration.html#并行预处理器) 与 [串行预处理器（token问题最佳解决方案）](/guide/configuration.html#串行预处理器（token问题最佳解决方案）)。 diff --git a/docs/guide/getting-start.md b/docs/guide/getting-start.md deleted file mode 100644 index 9d9bb495..00000000 --- a/docs/guide/getting-start.md +++ /dev/null @@ -1,503 +0,0 @@ - -## 解析请求结果 - -### 回调函数 - -　　OkHttps 的回调函数全部使用单方法模式，这样可以充分利用 Java8 或 Kotlin 中的 Lambda 表达式，使你的代码更加简洁优雅： - -```java -http.async("/users/{id}") // http://api.demo.com/users/1 - .addPathParam("id", 1) - .setOnResponse((HttpResult result) -> { - // 响应回调 - }) - .setOnException((IOException e) -> { - // 异常回调 - }) - .setOnComplete((State state) -> { - // 完成回调，无论成功失败都会执行 - // 并且在 响应|异常回调 之前执行 - }) - .get(); -``` - ->* 只有异步请求才可以设置这三种（响应|异常|完成）回调 ->* 同步请求直接返回结果，无需使用回调 - -### HttpResult - -　　`HttpResult`是HTTP请求执行完后的结果，它是同步请求方法（ `get`、`post`、`put`、`delete`）的返回值，也是异步请求响应回调（`OnResponse`）的参数，它定义了如下方法： - -* `getState()` 得到请求执行状态枚举，它有以下取值： - * `State.CANCELED` 请求被取消 - * `State.RESPONSED` 已收到响应 - * `State.TIMEOUT` 请求超时 - * `State.NETWORK_ERROR` 网络错误 - * `State.EXCEPTION` 其它请求异常 -* `getStatus()` 得到HTTP状态码 -* `isSuccessful()` 是否响应成功，状态码在 [200..300) 之间 -* `getHeaders()` 得到HTTP响应头 -* `getHeaders(String name)` 得到HTTP响应头 -* `getHeader(String name)` 得到HTTP响应头 -* `getBody()` 得到响应报文体`Body`实例，它定义了如下方法（对同一个`Body`实例，以下的`toXXX()`类方法只能使用一个且仅能调用一次，除非先使用 cache 方法）： - * `toBytes()` 返回字节数组 - * `toByteStream()` 返回字节输入流 - * `toCharStream()` 返回字符输入流 - * `toString()` 返回字符串 - * `toJsonObject()` 返回Json对象 - * `toJsonArray()` 返回Json数组 - * `toBean(Class type)` 返回根据type自动json解析后的JavaBean - * `toList(Class type)` 返回根据type自动json解析后的JavaBean列表 - * `toFile(String filePath)` 下载到指定路径 - * `toFile(File file)` 下载到指定文件 - * `toFolder(String dirPath)` 下载到指定目录 - * `toFolder(File dir)` 下载到指定目录 - * `getContentType()` 返回报文体的媒体类型 - * `getContentLength()` 返回报文体的字节长度 - * `cache()` 缓存报文体，开启缓存后可重复使用`toXXX()`类方法 - * `close()` 关闭报文体，未对报文体做任何消费时使用，比如只读取报文头 -* `getError()` 执行中发生的异常，自动捕获执行请求时发生的 网络超时、网络错误 和 其它IO异常 -* `close()` 关闭报文，未对报文体做任何消费时使用，比如只读取长度 - -　　示例，请求结果自动转Bean和List： - -```java -// 自动转Bean -Order order = http.sync("/orders/1") - .get().getBody().toBean(Order.class); - -// 自动转List -List orders = http.sync("/orders") - .get().getBody().toList(Order.class); -``` - -　　示例，使用 cache 方法： - -```java -Body body = http.sync("/orders").get().getBody().cache(); - -// 使用 cache 后，可以多次使用 toXXX() 方法 -System.out.println(body.toString()); -System.out.println(body.toJsonArray()); -System.out.println(body.toList(Order.class)); -``` - -　　示例，获取下载文件的大小： - -```java -long size = http.sync("/download/test.zip") - .get().getBody() - .close() // 只是想获得文件大小，不消费报文体，所以直接关闭 - .getContentLength(); // 获得待下载文件的大小 - -// 由于未消费报文体，所以本次请求不会消耗下载报文体的时间和网络流量 - -System.out.println("size = " + size); -``` - - -### HttpCall - -　　`HttpCall`对象是异步请求方法（`get`、`post`、`put`、`delete`）的返回值，与`java`的`Future`接口很像，它有如下方法： - -* `cancel()` 取消本次请求，返回取消结果 -* `isCanceled()` 返回请求是否被取消 -* `isDone()` 返回是否执行完成，包含取消和失败 -* `getResult()` 返回执行结果`HttpResult`对象，若请求未执行完，则挂起当前线程直到执行完成再返回 - -　　取消一个异步请求示例： - -```java -HttpCall call = http.async("/users/1").get(); - -System.out.println(call.isCanceled()); // false - -boolean success = call.cancel(); // 取消请求 - -System.out.println(success); // true -System.out.println(call.isCanceled()); // true -``` - -## 构建HTTP任务 - -　　`HTTP`对象的`sync`与`async`方法返回一个`HttpTask`对象，该对象提供了可链式调用的`addXXX`与`setXXX`等系列方法用于构建任务本身。 - -* `addHeader(String name, String value)` 添加请求头 -* `addHeader(Map headers)` 添加请求头 - -* `addPathParam(String name, Object value)` 添加路径参数：替换URL里的{name}占位符 -* `addPathParam(Map params)` 添加路径参数：替换URL里的{name}占位符 - -* `addUrlParam(String name, Object value)` 添加URL参数：拼接在URL的?之后（查询参数） -* `addUrlParam(Map params)` 添加URL参数：拼接在URL的?之后（查询参数） - -* `addBodyParam(String name, Object value)` 添加Body参数：以表单key=value&的形式放在报文体内（表单参数） -* `addBodyParam(Map params)` 添加Body参数：以表单key=value&的形式放在报文体内（表单参数） - -* `addJsonParam(String name, Object value)` 添加Json参数：请求体为Json（支持多层结构） -* `addJsonParam(Map params)` 添加Json参数：请求体为Json（支持多层结构） - -* `setRequestJson(Object json)` 设置请求体的Json字符串 或待转换为 Json的 JavaBean -* `setRequestJson(Object bean, String dateFormat)` 设置请求体的Json字符串 或待转换为 Json的 JavaBean - -* `addFileParam(String name, String filePath)` 上传文件 -* `addFileParam(String name, File file)` 上传文件 -* `addFileParam(String name, String type, InputStream inputStream)` 上传文件 -* `addFileParam(String name, String type, String fileName, InputStream input)` 上传文件 -* `addFileParam(String name, String type, byte[] content)` 上传文件 -* `addFileParam(String name, String type, String fileName, byte[] content)` 上传文件 - -* `setTag(String tag)` 为HTTP任务添加标签 -* `setRange(long rangeStart)` 设置Range头信息，用于断点续传 -* `setRange(long rangeStart, long rangeEnd)` 设置Range头信息，可用于分块下载 - -* `bind(Object object)` 绑定一个对象，可用于实现Android里的生命周期绑定 - -## 使用标签 - -　　有时候我们想对HTTP任务加以分类，这时候可以使用标签功能： - -```java -http.async("/users") //（1） - .setTag("A") - .get(); - -http.async("/users") //（2） - .setTag("A.B") - .get(); - -http.async("/users") //（3） - .setTag("B") - .get(); - -http.async("/users") //（4） - .setTag("B") - .setTag("C") // 从 v1.0.4 标签将以追加模式添加，等效于 setTag("B.C") - .get(); - -http.async("/users") //（5） - .setTag("C") - .get(); -``` -　　当使用标签后，就可以按标签批量的对HTTP任务进行取消： - -```java -int count = http.cancel("B"); //（2）（3）（4）被取消（取消标签包含"B"的任务） -System.out.println(count); // 输出 3 -``` -　　标签除了可以用来取消任务，在预处理器中它也可以发挥作用，请参见[并行预处理器](#54-并行预处理器)与[串行预处理器](#55-串行预处理器)。 - -## 配置 HTTP - -### 设置 BaseUrl - -```java -HTTP http = HTTP.builder() - .baseUrl("http://api.demo.com") // 设置 BaseUrl - .build(); -``` -　　该配置全局生效，在配置了`BaseUrl`之后，具体的请求便可以省略`BaseUrl`部分，使得代码更加简洁，例如： - -```java -http.sync("/users").get() // http://api.demo.com/users - -http.sync("/auth/signin") // http://api.demo.com/auth/signin - .addBodyParam("username", "Jackson") - .addBodyParam("password", "xxxxxx") - .post() // POST请求 -``` -　　在配置了`BaseUrl`之后，如有特殊请求任务，仍然可以使用全路径的方式，一点都不妨碍： - -```java -http.sync("https://www.baidu.com").get() -``` - -### 回调执行器 - -　　OkHttps 默认所有回调都在 **IO线程** 执行，如何想改变执行回调的线程时，可以配置回调执行器。例如在Android里，让所有的回调函数都在UI线程执行，则可以在构建`HTTP`时配置如下： - -```java -HTTP http = HTTP.builder() - .callbackExecutor((Runnable run) -> { - runOnUiThread(run); // 在UI线程执行 - }) - .build(); -``` -　　该配置默认 **影响所有回调**。 - -### 配置 OkHttpClient - -　　与其他封装 OkHttp3 的框架不同，OkHttps 并不会遮蔽 OkHttp3 本身就很好用的功能，如下： - -```java -HTTP http = HTTP.builder() - .config((Builder builder) -> { - // 配置连接池 最小10个连接（不配置默认为 5） - builder.connectionPool(new ConnectionPool(10, 5, TimeUnit.MINUTES)); - // 配置连接超时时间（默认10秒） - builder.connectTimeout(20, TimeUnit.SECONDS); - // 配置拦截器 - builder.addInterceptor((Chain chain) -> { - Request request = chain.request(); - // 必须同步返回，拦截器内无法执行异步操作 - return chain.proceed(request); - }); - // 其它配置: CookieJar、SSL、缓存、代理、事件监听... - }) - .build(); -``` - -### 并行预处理器 - -　　预处理器（`Preprocessor`）可以让我们在请求发出之前对请求本身做一些改变，但与`OkHttp`的拦截器（`Interceptor`）不同：预处理器可以让我们 **异步** 处理这些问题。 - -　　例如，当我们想为请求任务自动添加`Token`头信息，而`Token`只能通过异步方法`requestToken`获取时，这时使用`Interceptor`就很难处理了，但可以使用预处理器轻松解决： - -```java -HTTP http = HTTP.builder() - .addPreprocessor((PreChain chain) -> { - HttpTask task = chain.getTask();// 获得当前的HTTP任务 - if (!task.isTagged("Auth")) { // 根据标签判断该任务是否需要Token - return; - } - requestToken((String token) -> { // 异步获取 Token - task.addHeader("Token", token);// 为任务添加头信息 - chain.proceed(); // 继续当前的任务 - }); - }) - .build(); -``` -　　和`Interceptor`一样，`Preprocessor`也可以添加多个。他们之间的区别如下: - -> * 拦截器只能处理同步操作，预处理器支持处理异步操作 -> * 拦截器都是并行处理请求，预处理器支持串行处理（详见6.5章节） -> * 拦截器处理时机在请求前和响应后，预处理器只在请求前，并且先于拦截器执行。关于响应后，OkHttps还提供了全局回调监听（详见6.6章节） - -### 串行预处理器（TOKEN问题最佳解决方案） - -　　普通预处理器都是可并行处理的，然而有时我们希望某个预处理器同时只处理一个任务。比如 当`Token`过期时我们需要去刷新获取新`Token`，而刷新`Token`这个操作只能有一个任务去执行，因为如果`n`个任务同时执行的话，那么必有`n-1`个任务刚刷新得到的`Token`可能就立马失效了，而这是我们所不希望的。 - -　　为了解决这个问题，OkHttps 提供了串行预处理器，它可以让 HTTP 任务排好队，一个一个地进入预处理器： - -```java -HTTP http = HTTP.builder() - .addSerialPreprocessor((PreChain chain) -> { - HttpTask task = chain.getTask(); - if (!task.isTagged("Auth")) { - return; - } - // 检查过期，若需要则刷新Token - requestTokenAndRefreshIfExpired((String token) -> { - task.addHeader("Token", token); - chain.proceed(); // 调用此方法前，不会有其它任务进入该处理器 - }); - }) - .build(); -``` -　　串行预处理器实现了让HTTP任务排队串行处理的功能，但值得一提的是：它并没有因此而阻塞任何线程！ - -### 全局回调监听 - -```java -HTTP http = HTTP.builder() - .responseListener((HttpTask task, HttpResult result) -> { - // 所有请求响应后都会走这里 - - return true; // 返回 true 表示继续执行 task 的 OnResponse 回调，false 表示不再执行 - }) - .completeListener((HttpTask task, State state) -> { - // 所有请求执行完都会走这里 - - return true; // 返回 true 表示继续执行 task 的 OnComplete 回调，false 表示不再执行 - }) - .exceptionListener((HttpTask task, IOException error) -> { - // 所有请求发生异常都会走这里 - - return true; // 返回 true 表示继续执行 task 的 OnException 回调，false 表示不再执行 - }) - .build(); -``` - -　　全局回调监听与拦截器的异同: -> * 拦截器可以添加多个，全局回调监听分三种，每种最多添加一个 -> * 拦截器处的理时机在请求前和响应后，全局回调监听只在响应后，并且晚于拦截器 -> * 全局回调监听可以 **阻断**（return false）某个请求的具体回调，而拦截器不能 - -### 全局下载监听 - -```java -HTTP http = HTTP.builder() - .downloadListener((HttpTask task, Download download) -> { - // 所有下载在开始之前都会先走这里 - Ctrl ctrl = download.getCtrl(); // 下载控制器 - - }) - .build(); -``` - -## 使用 HttpUtils 类 - -　　类`HttpUtils`本是 [前身 HttpUtils](https://gitee.com/ejlchina-zhxu/httputils) 的 1.x 版本里的最重要的核心类，由于在后来的版本里抽象出了`HTTP`接口，使得它的重要性已不如往昔。但合理的使用它，仍然可以带来不少便利，特别是在没有IOC容器的环境里，比如在Android开发和一些工具项目的开发中。 - -　　类`HttpUtils`共定义了四个静态方法： - -* `of(HTTP http)` 配置`HttpUtils`持有的`HTTP`实例（不调用此方法前默认使用一个没有没有经过任何配置的`HTTP`懒实例） -* `async(String url)` 开始一个异步请求 （内部通过一个`HTTP`单例实现） -* `async()` 开始一个异步HTTP任务，使用该方法必须在构建时设置 BaseUrl -* `sync(String url)` 开始一个同步请求 （内部通过一个`HTTP`单例实现） -* `sync()` 开始一个同步HTTP任务，使用该方法必须在构建时设置 BaseUrl -* `cancel(String tag)` 按标签取消请求（内部通过一个`HTTP`单例实现） -* `cancelAll()` 取消所有HTTP任务，包括同步和异步（内部通过一个`HTTP`单例实现） -* `request(Request request)` OkHttp 原生请求 （该请求不经过 预处理器） -* `webSocket(Request request, WebSocketListener listener)` WebSocket通讯 -　　也就是说，能使用`http`实例的地方，都可以使用`HttpUtils`类，例如： - -```java -// 在配置HTTP实例之前，只能使用全路径方式 -List roles = HttpUtils.sync("http://api.demo.com/roles") - .get().getBody().toList(Role.class); - -// 配置HTTP实例,全局生效 -HttpUtils.of(HTTP.builder() - .baseUrl("http://api.demo.com") - .build()); - -// 内部使用新的HTTP实例 -List users = HttpUtils.sync("/users") - .get().getBody().toList(User.class); -``` - - -## 异常处理 - -　　使用 OkHttps 时，**异常处理不是必须的**，但相比其它的 HTTP 开发包，它还提供一个特别的处理方法：`nothrow()`，以满足不同的异常处理需求。 - -### 同步请求的异常 - -　　默认情况下，当同步请求执行异常时，会直接向外抛出，我们可以用 `try catch` 来捕获，例如： - -```java -try { - HttpResult result = http.sync("/users/1").get(); -} catch (HttpException e) { - Throwable cause = e.getCause(); // 得到异常原因 - if (cause instanceof ConnectException) { - // 当没网络时，会抛出连接异常 - } - if (cause instanceof SocketTimeoutException) { - // 当接口长时间未响应，会抛出超时异常 - } - if (cause instanceof UnknownHostException) { - // 当把域名或IP写错，会抛出 UnknownHost 异常 - } - // ... -} -``` -　　这种传统的异常处理方式，当然可以解决问题，但 OkHttps 有更佳的方案： - -```java -// 方法 nothrow() 让异常不直接抛出 -HttpResult result = http.sync("/users/1").nothrow().get(); -// 判断执行状态 -switch (result.getState()) { - case RESPONSED: // 请求已正常响应 - break; - case CANCELED: // 请求已被取消 - break; - case NETWORK_ERROR: // 网络错误，说明用户没网了 - break; - case TIMEOUT: // 请求超时 - break; - case EXCEPTION: // 其它异常 - break; -} -// 还可以获得具体的异常信息 -IOException error = result.getError(); -``` - -### 异步请求的异常 - -　　异步请求最常用的异常处理方式就是设置一个异常回调： - -```java -http.async("/users/1") - .setOnResponse((HttpResult result) -> { - // 当发生异常时就不会走这里 - }) - .setOnException((IOException e) -> { - // 这里处理请求异常 - }) - .get(); -``` -　　当然，还有一个全局异常监听（`ExceptionListener`）： - -```java -HTTP http = HTTP.builder() - .exceptionListener((HttpTask task, IOException error) -> { - // 所有请求发生异常都会走这里 - - return true; // 返回 true 表示继续执行 task 的 OnException 回调，false 表示不再执行 - }) - .build(); -``` -　　如果不设置`OnException`回调，也没有`ExceptionListener`，发生异常时会在 **IO 线程** 中向上抛出，外层无法捕获： - -```java -try { - http.async("/users/1") - .setOnResponse((HttpResult result) -> { - // 当发生异常时就不会走这里 - }) - .get(); -} catch (HttpException e) { - // 这种方式是捕获不到异常的！！！！！！ -} -``` -　　即使没有`OnException`回调，发生异常时，依然会走`OnComplete`回调，如果设置了的话： - -```java -http.async("/users/1") - .setOnResponse((HttpResult result) -> { - // 当发生异常时就不会走这里 - }) - .setOnComplete((State state) -> { - // 发生异常，会先执行这里，可以根据 state 判断发生了什么 - // 但执行完后依然会在IO线程中向上抛出 - }) - .get(); -``` -　　如果就是想 **不处理异常，也不向上抛出**，发生错误完全无视，可以做到吗？可以！还是使用`nothrow()`方法： - -```java -http.async("/users/1") - .nothrow() // 告诉 OkHttps 发生异常时不向外抛出 - .setOnResponse((HttpResult result) -> { - // 当发生异常时就不会走这里 - }) - .get(); -``` -## 取消请求的4种方式 - -　　在 OkHttps 里取消请求共有 **4 种** 方式可选： - -* 使用`HttpCall#cancel()`取消单个请求（适用于异步请求，[详见 3.3 章节](#33-httpcall)） -* 使用`HttpTask#cancel()`取消单个请求（适用于所有请求）（since v1.0.4） - -```java -HttpTask task = http.async("/users") - .setOnResponse((HttpResult result) -> { - // 响应回调 - }); - -task.get(); // 发起 GET 请求 - -// 取消请求，并返回是否取消成功 -boolean canceled = task.cancel(); -``` - -* 使用`HTTP#cancel(String tag)`按标签批量取消请求（适用于所有请求，[详见第 5 章节](#5-使用标签)） -* 使用`HTTP#cancelAll()`取消所有请求（适用于所有请求）（since v1.0.2） - -```java -http.cancelAll(); // 取消所有请求 -``` From 872cda2fe0e5a3b990d84ba7629dd74288484bbe Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?=E5=91=A8=E6=97=AD?= Date: Tue, 28 Apr 2020 14:46:50 +0800 Subject: [PATCH 181/924] docs --- docs/.vuepress/config.js | 9 ++++++++- 1 file changed, 8 insertions(+), 1 deletion(-) diff --git a/docs/.vuepress/config.js b/docs/.vuepress/config.js index cb8d6db8..782afe3f 100644 --- a/docs/.vuepress/config.js +++ b/docs/.vuepress/config.js @@ -8,6 +8,7 @@ module.exports = { logo: '/logo.png', nav: [ { text: '教程', link: '/guide/' }, + { text: '历史版本', link: 'https://gitee.com/ejlchina-zhxu/okhttps/releases' }, { text: 'Gitee', link: 'https://gitee.com/ejlchina-zhxu/okhttps' }, { text: 'GitHub', link: 'https://github.com/ejlchina/okhttps' } ], @@ -19,7 +20,13 @@ module.exports = { ['/guide/updown', '上传下载'], ['/guide/android', '安卓'], ], - sidebarDepth: 2 + sidebarDepth: 2, + smoothScroll: true, + lastUpdated: '上次更新', + repo: 'https://gitee.com/ejlchina-zhxu/okhttps', + repoLabel: '查看源码', + docsBranch: 'dev', + editLinks: true, }, markdown: { lineNumbers: true From ef09094bda963b55fb038a9dcde92ddb70dad194 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?=E5=91=A8=E6=97=AD?= Date: Tue, 28 Apr 2020 18:48:08 +0800 Subject: [PATCH 182/924] docs --- .gitignore | 4 +++- docs/.vuepress/config.js | 17 ++++++++++++----- docs/README.md | 29 +++++++++++++++++++++++++++++ docs/guide/README.md | 2 +- docs/guide/android.md | 2 ++ docs/guide/configuration.md | 2 ++ docs/guide/features.md | 2 ++ docs/guide/foundation.md | 2 ++ docs/guide/updown.md | 1 + package.json | 13 +++++++++++-- 10 files changed, 65 insertions(+), 9 deletions(-) diff --git a/.gitignore b/.gitignore index d848a362..535469d5 100644 --- a/.gitignore +++ b/.gitignore @@ -4,4 +4,6 @@ /.classpath /.project /.idea/** -*.iml \ No newline at end of file +*.iml +/package-lock.json +/node_modules/ \ No newline at end of file diff --git a/docs/.vuepress/config.js b/docs/.vuepress/config.js index 782afe3f..e004f65c 100644 --- a/docs/.vuepress/config.js +++ b/docs/.vuepress/config.js @@ -9,8 +9,7 @@ module.exports = { nav: [ { text: '教程', link: '/guide/' }, { text: '历史版本', link: 'https://gitee.com/ejlchina-zhxu/okhttps/releases' }, - { text: 'Gitee', link: 'https://gitee.com/ejlchina-zhxu/okhttps' }, - { text: 'GitHub', link: 'https://github.com/ejlchina/okhttps' } + { text: '码云', link: 'https://gitee.com/ejlchina-zhxu/okhttps' } ], sidebar: [ ['/guide/', '起步'], @@ -23,12 +22,20 @@ module.exports = { sidebarDepth: 2, smoothScroll: true, lastUpdated: '上次更新', - repo: 'https://gitee.com/ejlchina-zhxu/okhttps', - repoLabel: '查看源码', + repo: 'ejlchina/okhttps', + repoLabel: 'Github', docsBranch: 'dev', + docsDir: 'docs', editLinks: true, + editLinkText: '在 GitHub 上编辑此页' }, + // 若全局使用 vuepress，back-to-top 就会失效 + plugins: [ + '@vuepress/back-to-top', 'code-switcher', + ['smartlook', {id: "309988eea09b54d04d69edf5864d0414949892f4"}], + ['seo', { /* options */ }] + ], markdown: { lineNumbers: true } -} \ No newline at end of file +} diff --git a/docs/README.md b/docs/README.md index fcb54b8f..4ca82a7b 100644 --- a/docs/README.md +++ b/docs/README.md @@ -16,6 +16,8 @@ features: footer: Apache Licensed | Copyright © 2020-present ejlchina --- + ```java // 构建 HTTP @@ -38,4 +40,31 @@ http.async("/users/jack") // http://api.demo.com/users/jack .get(); // GET请求 ``` + + **
就这么简单，你已学会了 90% 的用法！
** \ No newline at end of file diff --git a/docs/guide/README.md b/docs/guide/README.md index 0725a00d..3a847547 100644 --- a/docs/guide/README.md +++ b/docs/guide/README.md @@ -1,4 +1,4 @@ -## 介绍 +# 起步 　　OkHttps 是近期开源的对 OkHttp3 轻量封装的框架，它独创的异步预处理器，特色的标签，灵活的上传下载进度监听与过程控制功能，在轻松解决很多原本另人头疼问题的同时，设计上也力求纯粹与优雅。 diff --git a/docs/guide/android.md b/docs/guide/android.md index 534edb64..e9b163b5 100644 --- a/docs/guide/android.md +++ b/docs/guide/android.md @@ -1,3 +1,5 @@ +# 安卓 + ## 回调线程切换 　　在 Android 开发中，经常会把某些代码放到特点的线程去执行，比如网络请求响应后的页面更新在主线程（UI线程）执行，而保存文件则在IO线程操作。OkHttps 为这类问题提供了良好的方案。 diff --git a/docs/guide/configuration.md b/docs/guide/configuration.md index 8d8fbba8..6f4983f7 100644 --- a/docs/guide/configuration.md +++ b/docs/guide/configuration.md @@ -1,3 +1,5 @@ +# 配置 + ## 设置 BaseUrl ```java diff --git a/docs/guide/features.md b/docs/guide/features.md index fedc980f..637059be 100644 --- a/docs/guide/features.md +++ b/docs/guide/features.md @@ -1,3 +1,5 @@ +# 特色 + ## 使用 HttpUtils 类 　　类`HttpUtils`本是 [前身 HttpUtils](https://gitee.com/ejlchina-zhxu/httputils) 的 1.x 版本里的最重要的核心类，由于在后来的版本里抽象出了`HTTP`接口，使得它的重要性已不如往昔。但合理的使用它，仍然可以带来不少便利，特别是在没有IOC容器的环境里，比如在Android开发和一些工具项目的开发中。 diff --git a/docs/guide/foundation.md b/docs/guide/foundation.md index b0a3b173..4ec4ecdc 100644 --- a/docs/guide/foundation.md +++ b/docs/guide/foundation.md @@ -1,3 +1,5 @@ +# 基础 + ## 请求方法 　　同步与异步的`HttpTask`都拥有`get`、`post`、`put`与`delete`方法。不同的是：同步`HttpTask`的这些方法返回一个`HttpResult`，而异步`HttpTask`的这些方法返回一个`HttpCall`。 diff --git a/docs/guide/updown.md b/docs/guide/updown.md index c1fffee4..df02d78b 100644 --- a/docs/guide/updown.md +++ b/docs/guide/updown.md @@ -1,3 +1,4 @@ +# 上传下载 ## 文件下载 diff --git a/package.json b/package.json index 2a6dea1b..b60f3866 100644 --- a/package.json +++ b/package.json @@ -1,6 +1,15 @@ { "scripts": { - "dev": "vuepress dev docs", + "dev": "vuepress dev docs --no-cache", "build": "vuepress build docs" + }, + "devDependencies": { + "@vuepress/plugin-back-to-top": "^1.4.1", + "vuepress": "^1.4.1", + "vuepress-plugin-seo": "^0.1.2" + }, + "dependencies": { + "vuepress-plugin-code-switcher": "^1.0.3", + "vuepress-plugin-smartlook": "0.0.6" } -} \ No newline at end of file +} From 0e188be7882ab6ccc901c8553e52833174c09c93 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?=E5=91=A8=E6=97=AD?= Date: Tue, 28 Apr 2020 19:52:32 +0800 Subject: [PATCH 183/924] docs --- .gitignore | 7 ++++--- docs/.vuepress/config.js | 10 +++++++--- docs/.vuepress/public/favicon.png | Bin 3471 -> 0 bytes docs/guide/README.md | 4 ++++ docs/guide/android.md | 4 ++++ docs/guide/configuration.md | 4 ++++ docs/guide/features.md | 4 ++++ docs/guide/foundation.md | 4 ++++ docs/guide/updown.md | 4 ++++ 9 files changed, 35 insertions(+), 6 deletions(-) delete mode 100644 docs/.vuepress/public/favicon.png diff --git a/.gitignore b/.gitignore index 535469d5..bc295ba2 100644 --- a/.gitignore +++ b/.gitignore @@ -3,7 +3,8 @@ /.settings/ /.classpath /.project -/.idea/** -*.iml +/.idea/ /package-lock.json -/node_modules/ \ No newline at end of file +/node_modules/ +/docs/.vuepress/dist/ +*.iml \ No newline at end of file diff --git a/docs/.vuepress/config.js b/docs/.vuepress/config.js index e004f65c..9bb0dd2f 100644 --- a/docs/.vuepress/config.js +++ b/docs/.vuepress/config.js @@ -1,6 +1,6 @@ module.exports = { title: 'OkHttps', - description: 'OkHttps 官网', + description: 'OkHttps 官网 比 Retrofit 更好用的网络框架！ OkHttp3 轻量封装 ，开箱即用、Java领域前后端处理 Http问题的新选择。', head: [ ['link', { rel: 'icon', href: '/logo.png' }] ], @@ -27,13 +27,17 @@ module.exports = { docsBranch: 'dev', docsDir: 'docs', editLinks: true, - editLinkText: '在 GitHub 上编辑此页' + editLinkText: '在 GitHub 上编辑此页', + author: 'Troy Zhou' }, // 若全局使用 vuepress，back-to-top 就会失效 plugins: [ '@vuepress/back-to-top', 'code-switcher', ['smartlook', {id: "309988eea09b54d04d69edf5864d0414949892f4"}], - ['seo', { /* options */ }] + ['seo', { + description: $page => $page.frontmatter.description, + tags: $page => $page.frontmatter.tags + }] ], markdown: { lineNumbers: true diff --git a/docs/.vuepress/public/favicon.png b/docs/.vuepress/public/favicon.png deleted file mode 100644 index 74f9ae7340d0f02d65ab922cfc31f7f80d9c8b36..0000000000000000000000000000000000000000 GIT binary patch literal 0 HcmV?d00001 literal 3471 zcmV;A4RG>_P)004R>004l5008;`004mK004C`008P>0026e000+ooVrmw00006 zVoOIv00000008+zyMF)x010qNS#tmY3labT3lag+-G2N401Wd z$A26Ss2rn>P!&*wq=^+PGGf89wXxWWRAwlCGEx^;j zGQii`|Ex%R6b3{oZ#-}nFdvvuq!C)Q8F(02qP4%Jhz8^iL@7@J3xLaj;YHkZ1nmc& z0PfM+e=W}o=LW=pSPXnW&l^lZD}Y~IKx==07Iw=7h*I8UU@0&y=BfLD=aEs*>a6}7mGZ^`=KzqK;wf|PyZA%r1QrX)BSD%s)mqa|}Entq;{yUvsyJH|qdD9UCA046i8^Cp1`+x8Bx_L+` z?_0nFz|;uEw*nVv?XU0TnxzgKJPUY{a2R`mMZmPd0s}y6|0U$TvJluEQv7J(MPrl1 zO58(~@-9T?e+~&L`a19vt^MxQEtaE{^1cfE5l|sT_X3w{?XOI7okTsv{1-%l@q1v# zV21&qwZ9QK19&i`=pn$eq&+2e4>9kI7lFeZ#XbdornUcYF4oFfN_q2;Nyrh7V!MH} z;=WU20WqVgS8=~HJ_at<+JB)KbLAuR!e0S=$x&=8a7LWbS7adOJ7YcWq3w3yT&?{L zg<2~oDdn94tOdq6ioFd?kNTYw=^bLez?TpXW7bfC0id=22C}lb-BIi$;1OfPP(^*I zUyJ(-{A1ue)4(Am^Rk}>eB>xL7qMZeLaCXr)(zO_ralF}r?tPPXyX(q^G;cV{YAeA z`3`eVNIH9nnL=NRd!q2#p$-FjKO*NliW~|oH8!;>?2&aH?kV(#wDun=+86^xTKh|Z z-#Us+L)M6_vH~$HeYZQ#?E-#Yv=IiN76AWr9KX%jHc+k}awqnczP-qF$ljvwexONf ze;;r;_PMW7h;0KE_&hTk5`O2n?#){Je=7Rs2da8{-rX^F?1VkYYGja39Xocy%ATHg zd)g1!ddOnO^}2z3^SZf8wJ}h)3WezbWF^$5KpTHy*sGK`HKd}mwf5I$eK(bAV-|2f za0>7ta7VpX{%yj#eu_;09}m0++)%HTGrtF=yl)~~R&6@1eUUDxhb(kduqr1Q7Xr^A zFhI8Q)GF1+T?y*C3wit=Z+@BzJZG+vsm#*!Q;s4F+JEQ=L@Dn$WJjS*H)nkl#!$-% z{=m914ir=N#(+a3faQ5WL2PE*1aVpWh^xJaT#0>q=QCNafrr3oDiRb2jHYsdV!q6m zTMiFL_BZ#c7l_$~?)uWq^hF*KMpI5G5nwcxS5LXmacsV^JzU9jynI4RbvyvXsRES1TdP)qo=r5PkU|OJM2}; zdyimenFer-*8a}4Ti79tR^4s>CV|naPl37hS~<}M1(%fajzEU*K@+uGwDyk!(?g6K znQeaMg#ux0M>ZCOZ5_Iia2V@>(-Ds;n=b3GZU=HC>Tv`vDQ?Hdb0B2DU6u>pzG#mPWoardII?Wcvgz*MIy;j~uawtt0|21{} zo8q86=QwsI^Z}V^DfBO`{mp5$CJBtD5<=+*qouAwplI!X2)t=IJQJW~{J?Fl$9`Ik z=>$eoF`@Jj0HdX@qI$|JmfuG!uEM4_=|EY)Xlf8c+2}Ynsf5H13DOQTc21-$ zVKg-up=j;z0zR-Do>)QxxdbWk=qe8wO$|mUz<(^ik1HWQ-9g%#-5y1e7N# z)rMseBk*Mq0Dg=hzO+wJW{DPj*Vk0 zWG{4(MwSwsWYc$m!yU)tyfZGg{63xZpoDtZMuaj7_gr8sb>#F}kkW)Q;N${wM9jL@ z04}GLF~HhNwQ)*>y23W$r2!>$7Q0eydp zS0TZ{*K6flU6sawF|S@LFN@ILSO4x_DQ6e)0 z8DJ&pLAi+(pqRQg)@$Xz)obMsT;*cIcr1yHkXT+p+F3$EsRk)=9K?YNB}_TN064+& z`}-v%I$MxNn}zvA8f;MVf}xam7%VxilHzB5TlX+Wt| z8>4_#^tl$e^`b8aV6P5B(i#pv2lolA@j&aFAC`G|g$~y-8 zd-)aUn>ulM`J^^+2Fai#gwa$#C(0(LRU$6QB(b|6x$t+{jZCN%RLZL*0(NdQU zN?tt!#Add^#1riqAcEG^UGC3wI*r^MMFz^b^v$#N0M$4!TI#w939r{&_vr@C%L9f9 zt>OBPyQlq!VU~*ij6F3`H=wlkI~l4T@KVYvBMw8h$NUPd{U5adXxnw-T5~>`j9>5v zh_1sOmORkL)(<76yrtOlM(qVo*V^yMUEx5LQr?M3L?v7F??<)v=LH>b?aNw(>^Tb3 zA;4owd10~Nhn$r1Mj}D`Z7_D>@a(bzF>ilY^q(oX13nH_-3y%NIR0x_ZmqDbr1v8+ zdu_T#Des!1Eih1Ig7murgKj_~%~^FYka9}OC6F@o#(Q!_nHvE-rIdGi(MBmsCMf?3 z+{*|Hqomo3y8Hb>>_NCd_NxBXG;B!8WZqeeJ8i|2geQUl4yLQC^O- zRk$;@H5+*gaNl5?B{s9R*CXp1VfVQkNx_;p*!02FtL}TtJ@x9rIT=YNHZA6<`;gcsPXnu6)6^Zd zZye&0dx`lwGG-MUfO%2ors66SAm*lrBg>e#V^5tFrj5uZvUSMtxjXKoK`E~SOh!DH zrX&6tljGFUqFu-u(fwNc`xDmTRAxY03^E?cxpYORbs23#996d=F5REd7yMuZGE;CA z;(B}n3EjH`^eC_>t6tkw=0KV`9G-Z;Rcu2~Ii*S24WuYy|sBRhH zw{CncLWKiqm&p<^8;ONJ6MG24q}qWvSiX!5t-Cs`FI5dVAnh`t(5E0fCMO|bZO0)a xsnLA#8)6?~^qt6l-c3lfif*9GxPcE?{U0r~qwQ(G{XhT!002ovPDHLkV1n9jU1$IR diff --git a/docs/guide/README.md b/docs/guide/README.md index 3a847547..ea0465f7 100644 --- a/docs/guide/README.md +++ b/docs/guide/README.md @@ -1,3 +1,7 @@ +--- +description: OkHttps 安装 构建实例 HTTP build 同步请求 异步请求 sync async BaseUrl request webSocket gradle maven ejlchina +--- + # 起步 　　OkHttps 是近期开源的对 OkHttp3 轻量封装的框架，它独创的异步预处理器，特色的标签，灵活的上传下载进度监听与过程控制功能，在轻松解决很多原本另人头疼问题的同时，设计上也力求纯粹与优雅。 diff --git a/docs/guide/android.md b/docs/guide/android.md index e9b163b5..73c7fde5 100644 --- a/docs/guide/android.md +++ b/docs/guide/android.md @@ -1,3 +1,7 @@ +--- +description: OkHttps 安卓 生命周期 UI线程 主线程 IO线程 自由 灵活 切换 生命周期绑定 配置预处理器 定义生命周期监视器 配置全局回调监听 +--- + # 安卓 ## 回调线程切换 diff --git a/docs/guide/configuration.md b/docs/guide/configuration.md index 6f4983f7..f828e5a1 100644 --- a/docs/guide/configuration.md +++ b/docs/guide/configuration.md @@ -1,3 +1,7 @@ +--- +description: OkHttps 配置 BaseUrl 回调执行器 主线程 UI线程 OkHttpClient 预处理器 TOKEN问题最佳解决方案 刷新TOKEN 全局 回调监听 下载监听 回调阻断 拦截器 CookieJar、SSL、缓存、代理、事件监听 +--- + # 配置 ## 设置 BaseUrl diff --git a/docs/guide/features.md b/docs/guide/features.md index 637059be..56771574 100644 --- a/docs/guide/features.md +++ b/docs/guide/features.md @@ -1,3 +1,7 @@ +--- +description: OkHttps 使用 HttpUtils 类 WebSocket 异常处理 nothrow 异常回调 多种方式 取消请求 标签 批量取消 cancelAll +--- + # 特色 ## 使用 HttpUtils 类 diff --git a/docs/guide/foundation.md b/docs/guide/foundation.md index 4ec4ecdc..4cccf799 100644 --- a/docs/guide/foundation.md +++ b/docs/guide/foundation.md @@ -1,3 +1,7 @@ +--- +description: OkHttps 请求方法 回调函数 HttpResult cache 多次 消费报文体 HttpCall 构建HTTP任务 请求参数 JSON 使用标签 发起请求 取消请求 +--- + # 基础 ## 请求方法 diff --git a/docs/guide/updown.md b/docs/guide/updown.md index df02d78b..14290b57 100644 --- a/docs/guide/updown.md +++ b/docs/guide/updown.md @@ -1,3 +1,7 @@ +--- +description: OkHttps 文件 上传 下载 进度监听 过程控制 断点续传 分块下载 +--- + # 上传下载 ## 文件下载 From 332644fe7be3f61b8650736036eaccf34594e205 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?=E5=91=A8=E6=97=AD?= Date: Tue, 28 Apr 2020 20:51:59 +0800 Subject: [PATCH 184/924] update README --- README.md | 9 +++++++-- 1 file changed, 7 insertions(+), 2 deletions(-) diff --git a/README.md b/README.md index bbbd68dc..4fba4996 100644 --- a/README.md +++ b/README.md @@ -1,8 +1,13 @@ -# OkHttps - +

+ + logo + +

+

[![Maven Central](https://maven-badges.herokuapp.com/maven-central/com.ejlchina/okhttps/badge.svg)](https://maven-badges.herokuapp.com/maven-central/com.ejlchina/okhttps/) [![License](https://img.shields.io/hexpm/l/plug.svg)](https://gitee.com/ejlchina-zhxu/okhttps/blob/master/LICENSE) [![Troy.Zhou](https://img.shields.io/badge/%E4%BD%9C%E8%80%85-ejlchina-orange.svg)](https://github.com/ejlchina) +

## 介绍 From 3b9e9a7bf8d7b5d2af01064e80badbd46bcde36f Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?=E5=91=A8=E6=97=AD?= Date: Tue, 28 Apr 2020 20:54:34 +0800 Subject: [PATCH 185/924] update README.md --- README.md | 6 +++--- 1 file changed, 3 insertions(+), 3 deletions(-) diff --git a/README.md b/README.md index 4fba4996..3e3969ac 100644 --- a/README.md +++ b/README.md @@ -4,9 +4,9 @@

-[![Maven Central](https://maven-badges.herokuapp.com/maven-central/com.ejlchina/okhttps/badge.svg)](https://maven-badges.herokuapp.com/maven-central/com.ejlchina/okhttps/) -[![License](https://img.shields.io/hexpm/l/plug.svg)](https://gitee.com/ejlchina-zhxu/okhttps/blob/master/LICENSE) -[![Troy.Zhou](https://img.shields.io/badge/%E4%BD%9C%E8%80%85-ejlchina-orange.svg)](https://github.com/ejlchina) + + +

## 介绍 From 50c767b6c4e5e28d76644500b9382845d2fce3ce Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?=E5=91=A8=E6=97=AD?= Date: Tue, 28 Apr 2020 20:56:47 +0800 Subject: [PATCH 186/924] update README.md --- README.md | 6 +++--- 1 file changed, 3 insertions(+), 3 deletions(-) diff --git a/README.md b/README.md index 3e3969ac..d11d76e5 100644 --- a/README.md +++ b/README.md @@ -4,9 +4,9 @@

- - - + Maven Central + License + Troy.Zhou

## 介绍 From 897d0876866aff5b42546aeeda386cd036765352 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?=E5=91=A8=E6=97=AD?= Date: Tue, 28 Apr 2020 21:00:09 +0800 Subject: [PATCH 187/924] update README.md --- README.md | 4 ++++ 1 file changed, 4 insertions(+) diff --git a/README.md b/README.md index d11d76e5..a8d14c73 100644 --- a/README.md +++ b/README.md @@ -9,6 +9,10 @@ Troy.Zhou

+## Documentation + +Check out our docs at http://okhttps.ejlchina.com/. + ## 介绍 　　OkHttps 是近期开源的对 OkHttp3 轻量封装的框架，它独创的异步预处理器，特色的标签，灵活的上传下载进度监听与过程控制功能，在轻松解决很多原本另人头疼问题的同时，设计上也力求纯粹与优雅。 From 3bdec153c3706bc5ca2a48c3fa03e1c92e73eaf4 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?=E5=91=A8=E6=97=AD?= Date: Tue, 28 Apr 2020 21:03:23 +0800 Subject: [PATCH 188/924] update README.md --- README.md | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/README.md b/README.md index a8d14c73..a8369c32 100644 --- a/README.md +++ b/README.md @@ -1,6 +1,6 @@

- logo + logo

From 9638a33e6e3e2397600e8e1920dea45818a63643 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?=E5=91=A8=E6=97=AD?= Date: Tue, 28 Apr 2020 21:05:06 +0800 Subject: [PATCH 189/924] update README.md --- README.md | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/README.md b/README.md index a8369c32..edb85cd9 100644 --- a/README.md +++ b/README.md @@ -11,7 +11,7 @@ ## Documentation -Check out our docs at http://okhttps.ejlchina.com/. +官网 http://okhttps.ejlchina.com/ ## 介绍 From 15613c6f80a894831305af59b5b61336e42da8b4 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?=E5=91=A8=E6=97=AD?= Date: Tue, 28 Apr 2020 21:27:15 +0800 Subject: [PATCH 190/924] docs --- docs/.vuepress/config.js | 6 +----- package.json | 1 + 2 files changed, 2 insertions(+), 5 deletions(-) diff --git a/docs/.vuepress/config.js b/docs/.vuepress/config.js index 9bb0dd2f..e45e3dda 100644 --- a/docs/.vuepress/config.js +++ b/docs/.vuepress/config.js @@ -32,12 +32,8 @@ module.exports = { }, // 若全局使用 vuepress，back-to-top 就会失效 plugins: [ - '@vuepress/back-to-top', 'code-switcher', + '@vuepress/back-to-top', 'code-switcher', 'baidu-autopush', 'seo', ['smartlook', {id: "309988eea09b54d04d69edf5864d0414949892f4"}], - ['seo', { - description: $page => $page.frontmatter.description, - tags: $page => $page.frontmatter.tags - }] ], markdown: { lineNumbers: true diff --git a/package.json b/package.json index b60f3866..cfbe1cec 100644 --- a/package.json +++ b/package.json @@ -6,6 +6,7 @@ "devDependencies": { "@vuepress/plugin-back-to-top": "^1.4.1", "vuepress": "^1.4.1", + "vuepress-plugin-baidu-autopush": "^1.0.1", "vuepress-plugin-seo": "^0.1.2" }, "dependencies": { From 9614aa145669ead94036a1a9ea579ae7c3594ab0 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?=E5=91=A8=E6=97=AD?= Date: Wed, 29 Apr 2020 15:40:19 +0800 Subject: [PATCH 191/924] docs --- docs/README.md | 7 ++++--- docs/guide/configuration.md | 4 ++-- docs/guide/updown.md | 6 +++--- 3 files changed, 9 insertions(+), 8 deletions(-) diff --git a/docs/README.md b/docs/README.md index 4ca82a7b..e7ab259a 100644 --- a/docs/README.md +++ b/docs/README.md @@ -2,8 +2,8 @@ home: true heroImage: /logo.png heroText: OkHttps -tagline: 基于 OkHttp 的 Java HTTP 客户端 -actionText: 快速上手 → +tagline: 基于 OkHttp 增强版 HTTP 客户端 +actionText: 极速上手 → actionLink: /guide/ features: - title: 轻量纯粹优雅 @@ -67,4 +67,5 @@ http.async("/users/jack") // http://api.demo.com/users/jack --> -**

就这么简单，你已学会了 90% 的用法！
** \ No newline at end of file +**
竟然不到 15 秒，你已学会 90% 的精髓！
** +
[**了解更多**](/guide/)
\ No newline at end of file diff --git a/docs/guide/configuration.md b/docs/guide/configuration.md index f828e5a1..ad0bb551 100644 --- a/docs/guide/configuration.md +++ b/docs/guide/configuration.md @@ -19,12 +19,12 @@ http.sync("/users").get() // http://api.demo.com/users http.sync("/auth/signin") // http://api.demo.com/auth/signin .addBodyParam("username", "Jackson") .addBodyParam("password", "xxxxxx") - .post() // POST请求 + .post(); // POST请求 ``` 　　在配置了`BaseUrl`之后，如有特殊请求任务，仍然可以使用全路径的方式，一点都不妨碍： ```java -http.sync("https://www.baidu.com").get() +http.sync("https://www.baidu.com").get(); ``` ## 回调执行器 diff --git a/docs/guide/updown.md b/docs/guide/updown.md index 14290b57..7f29e5c1 100644 --- a/docs/guide/updown.md +++ b/docs/guide/updown.md @@ -182,7 +182,7 @@ http.sync("/upload") ```java http.async("/upload") .addFileParam("test", "D:/download/test.zip") - .post() + .post(); ``` ### 上传进度监听 @@ -202,7 +202,7 @@ http.sync("/upload") double rate = process.getRate(); // 已发送的比例 boolean isDone = process.isDone(); // 是否发送完成 }) - .post() + .post(); ``` 　　咦！怎么感觉和下载的进度回调的一样？没错！OkHttps 还是使用同一套API处理上传和下载的进度回调，区别只在于上传是在`get/post`方法之前使用这些API，下载是在`getBody`方法之后使用。很好理解：`get/post`之前是准备发送请求时段，有上传的含义，而`getBody`之后，已是报文响应的时段，当然是下载。 @@ -216,7 +216,7 @@ HttpCall call = http.async("/upload") .setOnProcess((Process process) -> { System.out.println(process.getRate()); }) - .post() + .post(); call.cancel(); // 取消上传 ``` From bb08f8dcbc4353d44f8373360290087607870df8 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?=E5=91=A8=E6=97=AD?= Date: Wed, 29 Apr 2020 15:43:06 +0800 Subject: [PATCH 192/924] docs --- docs/guide/updown.md | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/docs/guide/updown.md b/docs/guide/updown.md index 7f29e5c1..73486bac 100644 --- a/docs/guide/updown.md +++ b/docs/guide/updown.md @@ -175,7 +175,7 @@ static void download(long totalSize, int index) { ```java http.sync("/upload") .addFileParam("test", "D:/download/test.zip") - .post() // 上传发法一般使用 POST 或 PUT，看服务器支持 + .post(); // 上传发法一般使用 POST 或 PUT，看服务器支持 ``` 　　异步上传也是完全一样： From fd6ab20bfd7986c539372d093b747565accebac8 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?=E5=91=A8=E6=97=AD?= Date: Wed, 29 Apr 2020 16:33:13 +0800 Subject: [PATCH 193/924] =?UTF-8?q?HttpTask=20=E6=9A=B4=E9=9C=B2=20=20requ?= =?UTF-8?q?est(String=20method)=20=E6=96=B9=E6=B3=95=EF=BC=8C=E5=BD=93?= =?UTF-8?q?=E9=A2=84=E5=AE=9A=E4=B9=89=E7=9A=84=20GET|POST|PUT|DELETE?= =?UTF-8?q?=E6=96=B9=E6=B3=95=E4=B8=8D=E5=A4=9F=E7=94=A8=E6=98=AF=EF=BC=8C?= =?UTF-8?q?=E7=94=A8=E6=88=B7=E5=8F=AF=E4=BB=A5=E8=87=AA=E5=AE=9A=E4=B9=89?= =?UTF-8?q?=E5=85=B6=E5=AE=83=E8=AF=B7=E6=B1=82=E6=96=B9=E6=B3=95?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- .../java/com/ejlchina/okhttps/HttpTask.java | 2 + .../okhttps/internal/AsyncHttpTask.java | 10 +++- .../okhttps/internal/SyncHttpTask.java | 51 +++++++++++-------- 3 files changed, 41 insertions(+), 22 deletions(-) diff --git a/src/main/java/com/ejlchina/okhttps/HttpTask.java b/src/main/java/com/ejlchina/okhttps/HttpTask.java index 369ecc38..3e48bc02 100644 --- a/src/main/java/com/ejlchina/okhttps/HttpTask.java +++ b/src/main/java/com/ejlchina/okhttps/HttpTask.java @@ -585,6 +585,8 @@ protected Call prepareCall(String method) { case "DELETE": builder.delete(reqBody); break; + default: + builder.method(method, reqBody); } return httpClient.request(builder.build()); } diff --git a/src/main/java/com/ejlchina/okhttps/internal/AsyncHttpTask.java b/src/main/java/com/ejlchina/okhttps/internal/AsyncHttpTask.java index d22f433b..7f894429 100644 --- a/src/main/java/com/ejlchina/okhttps/internal/AsyncHttpTask.java +++ b/src/main/java/com/ejlchina/okhttps/internal/AsyncHttpTask.java @@ -101,7 +101,15 @@ public HttpCall delete() { return request("DELETE"); } - private HttpCall request(String method) { + /** + * 发起 HTTP 请求 + * @param method 请求方法 + * @return HttpCall + */ + public HttpCall request(String method) { + if (method == null || method.isEmpty()) { + throw new IllegalArgumentException("HTTP 请求方法 method 不可为空！"); + } PreHttpCall call = new PreHttpCall(); registeTagTask(call); httpClient.preprocess(this, () -> { diff --git a/src/main/java/com/ejlchina/okhttps/internal/SyncHttpTask.java b/src/main/java/com/ejlchina/okhttps/internal/SyncHttpTask.java index ef3d16a6..666c0a90 100644 --- a/src/main/java/com/ejlchina/okhttps/internal/SyncHttpTask.java +++ b/src/main/java/com/ejlchina/okhttps/internal/SyncHttpTask.java @@ -55,27 +55,15 @@ public HttpResult delete() { return request("DELETE"); } - static class SyncHttpCall implements Cancelable { - - Call call; - boolean done = false; - boolean canceled = false; - - @Override - public synchronized boolean cancel() { - if (done) { - return false; - } - if (call != null) { - call.cancel(); - } - canceled = true; - return true; - } - - } - - private HttpResult request(String method) { + /** + * 发起 HTTP 请求 + * @param method + * @return 请求结果 + */ + public HttpResult request(String method) { + if (method == null || method.isEmpty()) { + throw new IllegalArgumentException("HTTP 请求方法 method 不可为空！"); + } RealHttpResult result = new RealHttpResult(this, httpClient.getExecutor()); SyncHttpCall httpCall = new SyncHttpCall(); // 注册标签任务 @@ -117,5 +105,26 @@ private HttpResult request(String method) { } return result; } + + + static class SyncHttpCall implements Cancelable { + + Call call; + boolean done = false; + boolean canceled = false; + + @Override + public synchronized boolean cancel() { + if (done) { + return false; + } + if (call != null) { + call.cancel(); + } + canceled = true; + return true; + } + + } } From 1dd855998e569aaeabaed774b5fe50d6ea0254e5 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?=E5=91=A8=E6=97=AD?= Date: Wed, 29 Apr 2020 21:10:21 +0800 Subject: [PATCH 194/924] websocket --- src/main/java/com/ejlchina/okhttps/HTTP.java | 8 + .../java/com/ejlchina/okhttps/HttpTask.java | 11 +- .../java/com/ejlchina/okhttps/WebSocket.java | 49 +++++ .../ejlchina/okhttps/internal/HttpClient.java | 6 + .../okhttps/internal/WebSocketTask.java | 208 ++++++++++++++++++ 5 files changed, 279 insertions(+), 3 deletions(-) create mode 100644 src/main/java/com/ejlchina/okhttps/WebSocket.java create mode 100644 src/main/java/com/ejlchina/okhttps/internal/WebSocketTask.java diff --git a/src/main/java/com/ejlchina/okhttps/HTTP.java b/src/main/java/com/ejlchina/okhttps/HTTP.java index f5c67a8e..5e534549 100644 --- a/src/main/java/com/ejlchina/okhttps/HTTP.java +++ b/src/main/java/com/ejlchina/okhttps/HTTP.java @@ -3,6 +3,7 @@ import com.ejlchina.okhttps.internal.AsyncHttpTask; import com.ejlchina.okhttps.internal.SyncHttpTask; import com.ejlchina.okhttps.internal.TaskExecutor; +import com.ejlchina.okhttps.internal.WebSocketTask; import com.ejlchina.okhttps.internal.HttpClient.Builder; import okhttp3.Call; @@ -43,6 +44,13 @@ public interface HTTP { */ SyncHttpTask sync(); + /** + * Websocket 连接 + * @param url 连接地址 + * @return WebSocket 任务 + */ + WebSocketTask webSocket(String url); + /** * 根据标签取消HTTP任务，只要任务的标签包含指定的Tag就会被取消 * 从 v1.0.2 开始支持取消同步请求 diff --git a/src/main/java/com/ejlchina/okhttps/HttpTask.java b/src/main/java/com/ejlchina/okhttps/HttpTask.java index 3e48bc02..04824ed9 100644 --- a/src/main/java/com/ejlchina/okhttps/HttpTask.java +++ b/src/main/java/com/ejlchina/okhttps/HttpTask.java @@ -553,7 +553,12 @@ protected void removeTagTask() { protected Call prepareCall(String method) { assertNotConflict("GET".equals(method)); - Request.Builder builder = new Request.Builder() + Request request = prepareRequest(method); + return httpClient.request(request); + } + + protected Request prepareRequest(String method) { + Request.Builder builder = new Request.Builder() .url(buildUrlPath()); buildHeaders(builder); RequestBody reqBody = null; @@ -588,8 +593,8 @@ protected Call prepareCall(String method) { default: builder.method(method, reqBody); } - return httpClient.request(builder.build()); - } + return builder.build(); + } private long contentLength(RequestBody reqBody) { try { diff --git a/src/main/java/com/ejlchina/okhttps/WebSocket.java b/src/main/java/com/ejlchina/okhttps/WebSocket.java new file mode 100644 index 00000000..015d46cb --- /dev/null +++ b/src/main/java/com/ejlchina/okhttps/WebSocket.java @@ -0,0 +1,49 @@ +package com.ejlchina.okhttps; + +import okio.ByteString; + +public interface WebSocket extends Cancelable { + + + public interface Listener { + + void on(WebSocket ws, T data); + + } + + + /** + * 同 {@link okhttp3.WebSocket#queueSize()} + */ + long queueSize(); + + /** + * 同 {@link okhttp3.WebSocket#send(String)} + */ + boolean send(String text); + + /** + * 同 {@link okhttp3.WebSocket#send(ByteString)} + */ + boolean send(ByteString bytes); + + /** + * 以JSON文本格式发送对象消息 + * @param bean 待发送的对象 + * @return 如果连接已断开 返回 false + */ + public boolean send(Object bean); + + /** + * 发送字节流 + * @param data 待发送的数据 + * @return 如果连接已断开 返回 false + */ + public boolean send(byte[] data); + + /** + * 同 {@link okhttp3.WebSocket#close(int, String)} + */ + boolean close(int code, String reason); + +} diff --git a/src/main/java/com/ejlchina/okhttps/internal/HttpClient.java b/src/main/java/com/ejlchina/okhttps/internal/HttpClient.java index c6902eb6..160d795a 100644 --- a/src/main/java/com/ejlchina/okhttps/internal/HttpClient.java +++ b/src/main/java/com/ejlchina/okhttps/internal/HttpClient.java @@ -3,6 +3,7 @@ import com.ejlchina.okhttps.*; import com.ejlchina.okhttps.HttpResult.State; import okhttp3.*; +import okhttp3.WebSocket; import java.io.IOException; import java.util.*; @@ -57,6 +58,11 @@ public SyncHttpTask sync(String url) { return new SyncHttpTask(this, urlPath(url)); } + @Override + public WebSocketTask webSocket(String url) { + return new WebSocketTask(this, urlPath(url)); + } + @Override public int cancel(String tag) { if (tag == null) { diff --git a/src/main/java/com/ejlchina/okhttps/internal/WebSocketTask.java b/src/main/java/com/ejlchina/okhttps/internal/WebSocketTask.java new file mode 100644 index 00000000..c0897e38 --- /dev/null +++ b/src/main/java/com/ejlchina/okhttps/internal/WebSocketTask.java @@ -0,0 +1,208 @@ +package com.ejlchina.okhttps.internal; + +import java.io.IOException; +import java.util.ArrayList; +import java.util.List; + +import com.alibaba.fastjson.JSON; +import com.ejlchina.okhttps.HttpResult; +import com.ejlchina.okhttps.HttpTask; +import com.ejlchina.okhttps.WebSocket; +import com.ejlchina.okhttps.WebSocket.Listener; + +import okhttp3.Request; +import okhttp3.Response; +import okhttp3.WebSocketListener; +import okio.ByteString; + + +public class WebSocketTask extends HttpTask { + + + private Listener onOnen; + private Listener onException; + + + public WebSocketTask(HttpClient httpClient, String url) { + super(httpClient, url); + } + + + public WebSocket listen() { + WebSocketImpl socket = new WebSocketImpl(); + registeTagTask(socket); + httpClient.preprocess(this, () -> { + synchronized (socket) { + if (socket.cancelOrClosed) { + removeTagTask(); + } else { + Request request = prepareRequest("GET"); + MessageListener listener = new MessageListener(socket); + socket.setWebSocket(httpClient.webSocket(request, listener)); + } + } + }); + return socket; + } + + + class MessageListener extends WebSocketListener { + + WebSocket webSocket; + + public MessageListener(WebSocket webSocket) { + this.webSocket = webSocket; + } + + @Override + public void onOpen(okhttp3.WebSocket webSocket, Response response) { + if (onOnen != null) { + HttpResult result = new RealHttpResult(WebSocketTask.this, response, httpClient.executor); + onOnen.on(this.webSocket, result); + } + } + + @Override + public void onMessage(okhttp3.WebSocket webSocket, String text) { + // TODO Auto-generated method stub + } + + @Override + public void onMessage(okhttp3.WebSocket webSocket, ByteString bytes) { + // TODO Auto-generated method stub + } + + @Override + public void onClosing(okhttp3.WebSocket webSocket, int code, String reason) { + // TODO Auto-generated method stub + } + + @Override + public void onClosed(okhttp3.WebSocket webSocket, int code, String reason) { + // TODO Auto-generated method stub + } + + @Override + public void onFailure(okhttp3.WebSocket webSocket, Throwable t, Response response) { + if (onException != null) { +// onException.on(this.webSocket, t); + } + } + + } + + + static class WebSocketImpl implements WebSocket { + + boolean cancelOrClosed; + + okhttp3.WebSocket webSocket; + + List queues = new ArrayList<>(); + + @Override + public synchronized boolean cancel() { + if (webSocket != null) { + webSocket.cancel(); + } + cancelOrClosed = true; + return true; + } + + @Override + public synchronized boolean close(int code, String reason) { + if (webSocket != null) { + webSocket.close(code, reason); + } + cancelOrClosed = true; + return true; + } + + @Override + public long queueSize() { + if (webSocket != null) { + return webSocket.queueSize(); + } + return 0; + } + + @Override + public boolean send(String text) { + if (webSocket != null) { + return webSocket.send(text); + } + queueMsgToSend(text); + return true; + } + + @Override + public boolean send(ByteString bytes) { + if (webSocket != null) { + return webSocket.send(bytes); + } + queueMsgToSend(bytes); + return true; + } + + @Override + public boolean send(Object bean) { + if (webSocket != null) { + return send(webSocket, bean); + } + queueMsgToSend(bean); + return true; + } + + @Override + public boolean send(byte[] data) { + if (webSocket != null) { + return send(webSocket, data); + } + queueMsgToSend(data); + return true; + } + + void queueMsgToSend(Object msg) { + if (msg == null) { + return; + } + synchronized (queues) { + if (queues != null) { + queues.add(msg); + } else if (webSocket != null) { + send(webSocket, msg); + } else { + throw new IllegalStateException(); + } + } + } + + void setWebSocket(okhttp3.WebSocket webSocket) { + synchronized (queues) { + for (Object msg: queues) { + send(webSocket, msg); + } + this.webSocket = webSocket; + queues = null; + } + } + + boolean send(okhttp3.WebSocket webSocket, Object msg) { + if (msg == null) { + return false; + } + if (msg instanceof String) { + return webSocket.send((String) msg); + } + if (msg instanceof ByteString) { + return webSocket.send((ByteString) msg); + } + if (msg instanceof byte[]) { + return webSocket.send(ByteString.of((byte[]) msg)); + } + return webSocket.send(JSON.toJSONString(msg)); + } + + } + +} From 71c6465d88a81a88bc7e0ce767e9dccc194c6778 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?=E5=91=A8=E6=97=AD?= <15735559897@qq.com> Date: Sat, 2 May 2020 01:03:08 +0800 Subject: [PATCH 195/924] docs --- docs/.vuepress/config.js | 1 + 1 file changed, 1 insertion(+) diff --git a/docs/.vuepress/config.js b/docs/.vuepress/config.js index e45e3dda..573c7d19 100644 --- a/docs/.vuepress/config.js +++ b/docs/.vuepress/config.js @@ -9,6 +9,7 @@ module.exports = { nav: [ { text: '教程', link: '/guide/' }, { text: '历史版本', link: 'https://gitee.com/ejlchina-zhxu/okhttps/releases' }, + { text: 'Grails 中文', link: 'http://grails.ejlchina.com' }, { text: '码云', link: 'https://gitee.com/ejlchina-zhxu/okhttps' } ], sidebar: [ From 5fb309ac5b376f0a728c75a8d7d7d226b9839996 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?=E5=91=A8=E6=97=AD?= <15735559897@qq.com> Date: Sun, 3 May 2020 20:26:28 +0800 Subject: [PATCH 196/924] add-vuepress-plugin-baidu-tongji --- docs/.vuepress/config.js | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/docs/.vuepress/config.js b/docs/.vuepress/config.js index 573c7d19..3e22cadd 100644 --- a/docs/.vuepress/config.js +++ b/docs/.vuepress/config.js @@ -34,7 +34,7 @@ module.exports = { // 若全局使用 vuepress，back-to-top 就会失效 plugins: [ '@vuepress/back-to-top', 'code-switcher', 'baidu-autopush', 'seo', - ['smartlook', {id: "309988eea09b54d04d69edf5864d0414949892f4"}], + ['baidu-tongji', {hm: '6eb41c0ab450d5a4ae8769682ecb0ab2'}], ], markdown: { lineNumbers: true From 4de968fe00b554791e7006e50db89eeb4c6c42bc Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?=E5=91=A8=E6=97=AD?= Date: Fri, 8 May 2020 13:17:34 +0800 Subject: [PATCH 197/924] doc --- docs/guide/configuration.md | 2 ++ 1 file changed, 2 insertions(+) diff --git a/docs/guide/configuration.md b/docs/guide/configuration.md index ad0bb551..30bf60e9 100644 --- a/docs/guide/configuration.md +++ b/docs/guide/configuration.md @@ -73,6 +73,7 @@ HTTP http = HTTP.builder() .addPreprocessor((PreChain chain) -> { HttpTask task = chain.getTask();// 获得当前的HTTP任务 if (!task.isTagged("Auth")) { // 根据标签判断该任务是否需要Token + chain.proceed(); return; } requestToken((String token) -> { // 异步获取 Token @@ -101,6 +102,7 @@ HTTP http = HTTP.builder() .addSerialPreprocessor((PreChain chain) -> { HttpTask task = chain.getTask(); if (!task.isTagged("Auth")) { + chain.proceed(); return; } // 检查过期，若需要则刷新Token From 23d78efa629e63cc3d6cd1231ad0a95e2f80a14a Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?=E5=91=A8=E6=97=AD?= Date: Fri, 8 May 2020 13:26:48 +0800 Subject: [PATCH 198/924] =?UTF-8?q?=E9=A1=B9=E7=9B=AE=E7=BB=93=E6=9E=84?= =?UTF-8?q?=E8=B0=83=E6=95=B4?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- .gitignore | 6 +- okhttps/.gitignore | 1 + pom.xml => okhttps/pom.xml | 0 .../java/com/ejlchina/okhttps/Cancelable.java | 0 .../com/ejlchina/okhttps/Configurator.java | 0 .../com/ejlchina/okhttps/DownListener.java | 0 .../java/com/ejlchina/okhttps/Download.java | 0 .../main/java/com/ejlchina/okhttps/HTTP.java | 0 .../java/com/ejlchina/okhttps/HttpCall.java | 0 .../java/com/ejlchina/okhttps/HttpResult.java | 554 +++++++++--------- .../java/com/ejlchina/okhttps/HttpTask.java | 0 .../java/com/ejlchina/okhttps/HttpUtils.java | 0 .../java/com/ejlchina/okhttps/OnCallback.java | 0 .../com/ejlchina/okhttps/Preprocessor.java | 0 .../java/com/ejlchina/okhttps/Process.java | 0 .../com/ejlchina/okhttps/TaskListener.java | 0 .../java/com/ejlchina/okhttps/WebSocket.java | 0 .../okhttps/internal/AsyncHttpTask.java | 0 .../ejlchina/okhttps/internal/HttpClient.java | 0 .../okhttps/internal/HttpException.java | 0 .../okhttps/internal/ProcessInputStream.java | 0 .../okhttps/internal/ProcessRequestBody.java | 0 .../okhttps/internal/RealHttpResult.java | 270 ++++----- .../okhttps/internal/RealProcess.java | 0 .../ejlchina/okhttps/internal/ResultBody.java | 0 .../okhttps/internal/SyncHttpTask.java | 0 .../okhttps/internal/TaskExecutor.java | 224 +++---- .../okhttps/internal/WebSocketTask.java | 0 .../test/java/com/ejlchina/test/BaseTest.java | 0 .../java/com/ejlchina/test/CacheTests.java | 0 .../java/com/ejlchina/test/CancelTests.java | 0 .../java/com/ejlchina/test/DownloadTests.java | 0 .../com/ejlchina/test/ExceptionTests.java | 2 +- .../java/com/ejlchina/test/ExecutorTests.java | 0 .../java/com/ejlchina/test/JsonTests.java | 0 .../java/com/ejlchina/test/ListenerTests.java | 0 .../com/ejlchina/test/PreprocessorTests.java | 0 .../java/com/ejlchina/test/SimpleTests.java | 0 .../test/java/com/ejlchina/test/TagTests.java | 0 .../java/com/ejlchina/test/UploadTests.java | 0 40 files changed, 529 insertions(+), 528 deletions(-) create mode 100644 okhttps/.gitignore rename pom.xml => okhttps/pom.xml (100%) rename {src => okhttps/src}/main/java/com/ejlchina/okhttps/Cancelable.java (100%) rename {src => okhttps/src}/main/java/com/ejlchina/okhttps/Configurator.java (100%) rename {src => okhttps/src}/main/java/com/ejlchina/okhttps/DownListener.java (100%) rename {src => okhttps/src}/main/java/com/ejlchina/okhttps/Download.java (100%) rename {src => okhttps/src}/main/java/com/ejlchina/okhttps/HTTP.java (100%) rename {src => okhttps/src}/main/java/com/ejlchina/okhttps/HttpCall.java (100%) rename {src => okhttps/src}/main/java/com/ejlchina/okhttps/HttpResult.java (95%) rename {src => okhttps/src}/main/java/com/ejlchina/okhttps/HttpTask.java (100%) rename {src => okhttps/src}/main/java/com/ejlchina/okhttps/HttpUtils.java (100%) rename {src => okhttps/src}/main/java/com/ejlchina/okhttps/OnCallback.java (100%) rename {src => okhttps/src}/main/java/com/ejlchina/okhttps/Preprocessor.java (100%) rename {src => okhttps/src}/main/java/com/ejlchina/okhttps/Process.java (100%) rename {src => okhttps/src}/main/java/com/ejlchina/okhttps/TaskListener.java (100%) rename {src => okhttps/src}/main/java/com/ejlchina/okhttps/WebSocket.java (100%) rename {src => okhttps/src}/main/java/com/ejlchina/okhttps/internal/AsyncHttpTask.java (100%) rename {src => okhttps/src}/main/java/com/ejlchina/okhttps/internal/HttpClient.java (100%) rename {src => okhttps/src}/main/java/com/ejlchina/okhttps/internal/HttpException.java (100%) rename {src => okhttps/src}/main/java/com/ejlchina/okhttps/internal/ProcessInputStream.java (100%) rename {src => okhttps/src}/main/java/com/ejlchina/okhttps/internal/ProcessRequestBody.java (100%) rename {src => okhttps/src}/main/java/com/ejlchina/okhttps/internal/RealHttpResult.java (95%) rename {src => okhttps/src}/main/java/com/ejlchina/okhttps/internal/RealProcess.java (100%) rename {src => okhttps/src}/main/java/com/ejlchina/okhttps/internal/ResultBody.java (100%) rename {src => okhttps/src}/main/java/com/ejlchina/okhttps/internal/SyncHttpTask.java (100%) rename {src => okhttps/src}/main/java/com/ejlchina/okhttps/internal/TaskExecutor.java (97%) rename {src => okhttps/src}/main/java/com/ejlchina/okhttps/internal/WebSocketTask.java (100%) rename {src => okhttps/src}/test/java/com/ejlchina/test/BaseTest.java (100%) rename {src => okhttps/src}/test/java/com/ejlchina/test/CacheTests.java (100%) rename {src => okhttps/src}/test/java/com/ejlchina/test/CancelTests.java (100%) rename {src => okhttps/src}/test/java/com/ejlchina/test/DownloadTests.java (100%) rename {src => okhttps/src}/test/java/com/ejlchina/test/ExceptionTests.java (98%) rename {src => okhttps/src}/test/java/com/ejlchina/test/ExecutorTests.java (100%) rename {src => okhttps/src}/test/java/com/ejlchina/test/JsonTests.java (100%) rename {src => okhttps/src}/test/java/com/ejlchina/test/ListenerTests.java (100%) rename {src => okhttps/src}/test/java/com/ejlchina/test/PreprocessorTests.java (100%) rename {src => okhttps/src}/test/java/com/ejlchina/test/SimpleTests.java (100%) rename {src => okhttps/src}/test/java/com/ejlchina/test/TagTests.java (100%) rename {src => okhttps/src}/test/java/com/ejlchina/test/UploadTests.java (100%) diff --git a/.gitignore b/.gitignore index bc295ba2..5a255776 100644 --- a/.gitignore +++ b/.gitignore @@ -1,8 +1,8 @@ /target/ /bin/ -/.settings/ -/.classpath -/.project +/*/.settings/ +/*/.classpath +/*/.project /.idea/ /package-lock.json /node_modules/ diff --git a/okhttps/.gitignore b/okhttps/.gitignore new file mode 100644 index 00000000..b83d2226 --- /dev/null +++ b/okhttps/.gitignore @@ -0,0 +1 @@ +/target/ diff --git a/pom.xml b/okhttps/pom.xml similarity index 100% rename from pom.xml rename to okhttps/pom.xml diff --git a/src/main/java/com/ejlchina/okhttps/Cancelable.java b/okhttps/src/main/java/com/ejlchina/okhttps/Cancelable.java similarity index 100% rename from src/main/java/com/ejlchina/okhttps/Cancelable.java rename to okhttps/src/main/java/com/ejlchina/okhttps/Cancelable.java diff --git a/src/main/java/com/ejlchina/okhttps/Configurator.java b/okhttps/src/main/java/com/ejlchina/okhttps/Configurator.java similarity index 100% rename from src/main/java/com/ejlchina/okhttps/Configurator.java rename to okhttps/src/main/java/com/ejlchina/okhttps/Configurator.java diff --git a/src/main/java/com/ejlchina/okhttps/DownListener.java b/okhttps/src/main/java/com/ejlchina/okhttps/DownListener.java similarity index 100% rename from src/main/java/com/ejlchina/okhttps/DownListener.java rename to okhttps/src/main/java/com/ejlchina/okhttps/DownListener.java diff --git a/src/main/java/com/ejlchina/okhttps/Download.java b/okhttps/src/main/java/com/ejlchina/okhttps/Download.java similarity index 100% rename from src/main/java/com/ejlchina/okhttps/Download.java rename to okhttps/src/main/java/com/ejlchina/okhttps/Download.java diff --git a/src/main/java/com/ejlchina/okhttps/HTTP.java b/okhttps/src/main/java/com/ejlchina/okhttps/HTTP.java similarity index 100% rename from src/main/java/com/ejlchina/okhttps/HTTP.java rename to okhttps/src/main/java/com/ejlchina/okhttps/HTTP.java diff --git a/src/main/java/com/ejlchina/okhttps/HttpCall.java b/okhttps/src/main/java/com/ejlchina/okhttps/HttpCall.java similarity index 100% rename from src/main/java/com/ejlchina/okhttps/HttpCall.java rename to okhttps/src/main/java/com/ejlchina/okhttps/HttpCall.java diff --git a/src/main/java/com/ejlchina/okhttps/HttpResult.java b/okhttps/src/main/java/com/ejlchina/okhttps/HttpResult.java similarity index 95% rename from src/main/java/com/ejlchina/okhttps/HttpResult.java rename to okhttps/src/main/java/com/ejlchina/okhttps/HttpResult.java index 88984b72..c3d31928 100644 --- a/src/main/java/com/ejlchina/okhttps/HttpResult.java +++ b/okhttps/src/main/java/com/ejlchina/okhttps/HttpResult.java @@ -1,277 +1,277 @@ -package com.ejlchina.okhttps; - -import java.io.File; -import java.io.IOException; -import java.io.InputStream; -import java.io.Reader; -import java.util.List; - -import com.alibaba.fastjson.JSONArray; -import com.alibaba.fastjson.JSONObject; -import com.ejlchina.okhttps.internal.RealHttpResult; -import com.ejlchina.okhttps.internal.TaskExecutor; - -import okhttp3.Headers; -import okhttp3.MediaType; -import okhttp3.Response; - - -/** - * Http 执行结果 - */ -public interface HttpResult { - - /** - * 构造一个 HttpResult - * 此方法构造的 HttpResult 不可设置进度回调，不可进行下载操作！ - * 若需要，请使用方法： {@link #of(Response, TaskExecutor)} - * @param response Response - * @return HttpResult - */ - static HttpResult of(Response response) { - return of(response, null); - } - - /** - * 构造一个 HttpResult - * @param response Response - * @param taskExecutor 任务执行器, 可通过方法 {@link HTTP#getExecutor()} 获得 - * @return HttpResult - */ - static HttpResult of(Response response, TaskExecutor taskExecutor) { - if (response != null) { - return new RealHttpResult(null, response, taskExecutor); - } - throw new IllegalArgumentException("response 不能为空"); - } - - - public enum State { - - /** - * 执行异常 - */ - EXCEPTION, - - /** - * 请求被取消 - */ - CANCELED, - - /** - * 请求已响应 - */ - RESPONSED, - - /** - * 网络超时 - */ - TIMEOUT, - - /** - * 网络出错 - */ - NETWORK_ERROR - - } - - /** - * HTTP响应报文体 - */ - public interface Body { - - /** - * @return 媒体类型 - */ - MediaType getContentType(); - - /** - * @return 报文体字节长度 - */ - long getContentLength(); - - /** - * 在IO线程执行 - * @return Body - */ - Body nextOnIO(); - - /** - * 设置报文体接收进度回调 - * @param onProcess 进度回调函数 - * @return Body - */ - Body setOnProcess(OnCallback onProcess); - - /** - * 设置进度回调的步进字节，默认 8K（8192） - * 表示每接收 stepBytes 个字节，执行一次进度回调 - * @param stepBytes 步进字节 - * @return Body - */ - Body setStepBytes(long stepBytes); - - /** - * 设置进度回调的步进比例 - * 表示每接收 stepRate 比例，执行一次进度回调 - * @param stepRate 步进比例 - * @return Body - */ - Body setStepRate(double stepRate); - - /** - * 设置进度回调忽略响应的Range头信息，即进度回调会从0开始 - * @return Body - */ - Body setRangeIgnored(); - - /** - * 同一个 Body 对象的 toXXX 类方法只可使用一个并且只能调用一次 - * @return 报文体转字节流 - */ - InputStream toByteStream(); - - /** - * 同一个 Body 对象的 toXXX 类方法只可使用一个并且只能调用一次 - * @return 报文体转字节数组 - */ - byte[] toBytes(); - - /** - * 同一个 Body 对象的 toXXX 类方法只可使用一个并且只能调用一次 - * @return 报文体转字符流 - */ - Reader toCharStream(); - - /** - * 同一个 Body 对象的 toXXX 类方法只可使用一个并且只能调用一次 - * @return 报文体转字符串 - */ - String toString(); - - /** - * 同一个 Body 对象的 toXXX 类方法只可使用一个并且只能调用一次 - * @return 报文体转Json对象 - */ - JSONObject toJsonObject(); - - /** - * 同一个 Body 对象的 toXXX 类方法只可使用一个并且只能调用一次 - * @return 报文体转Json数组 - */ - JSONArray toJsonArray(); - - /** - * 同一个 Body 对象的 toXXX 类方法只可使用一个并且只能调用一次 - * @param 目标泛型 - * @param type 目标类型 - * @return 报文体Json文本转JavaBean - */ - T toBean(Class type); - - /** - * 同一个 Body 对象的 toXXX 类方法只可使用一个并且只能调用一次 - * @param 目标泛型 - * @param type 目标类型 - * @return 报文体Json文本转JavaBean列表 - */ - List toList(Class type); - - /** - * 下载到指定路径 - * 同一个 Body 对象的 toXXX 类方法只可使用一个并且只能调用一次 - * @param filePath 目标路径 - * @return 下载过程 #Download - */ - Download toFile(String filePath); - - /** - * 下载到指定文件 - * 同一个 Body 对象的 toXXX 类方法只可使用一个并且只能调用一次 - * @param file 目标文件 - * @return 下载过程 #Download - */ - Download toFile(File file); - - /** - * 下载到指定文件夹 - * 同一个 Body 对象的 toXXX 类方法只可使用一个并且只能调用一次 - * @param dirPath 目标目录 - * @return 下载过程 #Download - */ - Download toFolder(String dirPath); - - /** - * 下载到指定文件夹 - * 同一个 Body 对象的 toXXX 类方法只可使用一个并且只能调用一次 - * @param dir 目标目录 - * @return 下载过程 #Download - */ - Download toFolder(File dir); - - /** - * 缓存自己，缓存后可 重复使用 toXXX 类方法 - * @return Body - */ - Body cache(); - - /** - * 关闭报文体 - * 未对报文体做任何消费时使用，比如只读取长度 - * @return Body - */ - Body close(); - - } - - - /** - * @return 执行状态 - */ - State getState(); - - /** - * @return HTTP状态码 - */ - int getStatus(); - - /** - * @return 是否响应成功，状态码在 [200..300) 之间 - */ - boolean isSuccessful(); - - /** - * @return 响应头 - */ - Headers getHeaders(); - - /** - * @param name 头名称 - * @return 响应头 - */ - List getHeaders(String name); - - /** - * @param name 头名称 - * @return 响应头 - */ - String getHeader(String name); - - /** - * @return 响应报文体 - */ - Body getBody(); - - /** - * @return 执行中发生的异常 - */ - IOException getError(); - - /** - * 关闭报文 - * 未对报文体做任何消费时使用，比如只读取报文头 - * @return HttpResult - */ - HttpResult close(); - -} +package com.ejlchina.okhttps; + +import java.io.File; +import java.io.IOException; +import java.io.InputStream; +import java.io.Reader; +import java.util.List; + +import com.alibaba.fastjson.JSONArray; +import com.alibaba.fastjson.JSONObject; +import com.ejlchina.okhttps.internal.RealHttpResult; +import com.ejlchina.okhttps.internal.TaskExecutor; + +import okhttp3.Headers; +import okhttp3.MediaType; +import okhttp3.Response; + + +/** + * Http 执行结果 + */ +public interface HttpResult { + + /** + * 构造一个 HttpResult + * 此方法构造的 HttpResult 不可设置进度回调，不可进行下载操作！ + * 若需要，请使用方法： {@link #of(Response, TaskExecutor)} + * @param response Response + * @return HttpResult + */ + static HttpResult of(Response response) { + return of(response, null); + } + + /** + * 构造一个 HttpResult + * @param response Response + * @param taskExecutor 任务执行器, 可通过方法 {@link HTTP#getExecutor()} 获得 + * @return HttpResult + */ + static HttpResult of(Response response, TaskExecutor taskExecutor) { + if (response != null) { + return new RealHttpResult(null, response, taskExecutor); + } + throw new IllegalArgumentException("response 不能为空"); + } + + + public enum State { + + /** + * 执行异常 + */ + EXCEPTION, + + /** + * 请求被取消 + */ + CANCELED, + + /** + * 请求已响应 + */ + RESPONSED, + + /** + * 网络超时 + */ + TIMEOUT, + + /** + * 网络出错 + */ + NETWORK_ERROR + + } + + /** + * HTTP响应报文体 + */ + public interface Body { + + /** + * @return 媒体类型 + */ + MediaType getContentType(); + + /** + * @return 报文体字节长度 + */ + long getContentLength(); + + /** + * 在IO线程执行 + * @return Body + */ + Body nextOnIO(); + + /** + * 设置报文体接收进度回调 + * @param onProcess 进度回调函数 + * @return Body + */ + Body setOnProcess(OnCallback onProcess); + + /** + * 设置进度回调的步进字节，默认 8K（8192） + * 表示每接收 stepBytes 个字节，执行一次进度回调 + * @param stepBytes 步进字节 + * @return Body + */ + Body setStepBytes(long stepBytes); + + /** + * 设置进度回调的步进比例 + * 表示每接收 stepRate 比例，执行一次进度回调 + * @param stepRate 步进比例 + * @return Body + */ + Body setStepRate(double stepRate); + + /** + * 设置进度回调忽略响应的Range头信息，即进度回调会从0开始 + * @return Body + */ + Body setRangeIgnored(); + + /** + * 同一个 Body 对象的 toXXX 类方法只可使用一个并且只能调用一次 + * @return 报文体转字节流 + */ + InputStream toByteStream(); + + /** + * 同一个 Body 对象的 toXXX 类方法只可使用一个并且只能调用一次 + * @return 报文体转字节数组 + */ + byte[] toBytes(); + + /** + * 同一个 Body 对象的 toXXX 类方法只可使用一个并且只能调用一次 + * @return 报文体转字符流 + */ + Reader toCharStream(); + + /** + * 同一个 Body 对象的 toXXX 类方法只可使用一个并且只能调用一次 + * @return 报文体转字符串 + */ + String toString(); + + /** + * 同一个 Body 对象的 toXXX 类方法只可使用一个并且只能调用一次 + * @return 报文体转Json对象 + */ + JSONObject toJsonObject(); + + /** + * 同一个 Body 对象的 toXXX 类方法只可使用一个并且只能调用一次 + * @return 报文体转Json数组 + */ + JSONArray toJsonArray(); + + /** + * 同一个 Body 对象的 toXXX 类方法只可使用一个并且只能调用一次 + * @param 目标泛型 + * @param type 目标类型 + * @return 报文体Json文本转JavaBean + */ + T toBean(Class type); + + /** + * 同一个 Body 对象的 toXXX 类方法只可使用一个并且只能调用一次 + * @param 目标泛型 + * @param type 目标类型 + * @return 报文体Json文本转JavaBean列表 + */ + List toList(Class type); + + /** + * 下载到指定路径 + * 同一个 Body 对象的 toXXX 类方法只可使用一个并且只能调用一次 + * @param filePath 目标路径 + * @return 下载过程 #Download + */ + Download toFile(String filePath); + + /** + * 下载到指定文件 + * 同一个 Body 对象的 toXXX 类方法只可使用一个并且只能调用一次 + * @param file 目标文件 + * @return 下载过程 #Download + */ + Download toFile(File file); + + /** + * 下载到指定文件夹 + * 同一个 Body 对象的 toXXX 类方法只可使用一个并且只能调用一次 + * @param dirPath 目标目录 + * @return 下载过程 #Download + */ + Download toFolder(String dirPath); + + /** + * 下载到指定文件夹 + * 同一个 Body 对象的 toXXX 类方法只可使用一个并且只能调用一次 + * @param dir 目标目录 + * @return 下载过程 #Download + */ + Download toFolder(File dir); + + /** + * 缓存自己，缓存后可 重复使用 toXXX 类方法 + * @return Body + */ + Body cache(); + + /** + * 关闭报文体 + * 未对报文体做任何消费时使用，比如只读取长度 + * @return Body + */ + Body close(); + + } + + + /** + * @return 执行状态 + */ + State getState(); + + /** + * @return HTTP状态码 + */ + int getStatus(); + + /** + * @return 是否响应成功，状态码在 [200..300) 之间 + */ + boolean isSuccessful(); + + /** + * @return 响应头 + */ + Headers getHeaders(); + + /** + * @param name 头名称 + * @return 响应头 + */ + List getHeaders(String name); + + /** + * @param name 头名称 + * @return 响应头 + */ + String getHeader(String name); + + /** + * @return 响应报文体 + */ + Body getBody(); + + /** + * @return 执行中发生的异常 + */ + IOException getError(); + + /** + * 关闭报文 + * 未对报文体做任何消费时使用，比如只读取报文头 + * @return HttpResult + */ + HttpResult close(); + +} diff --git a/src/main/java/com/ejlchina/okhttps/HttpTask.java b/okhttps/src/main/java/com/ejlchina/okhttps/HttpTask.java similarity index 100% rename from src/main/java/com/ejlchina/okhttps/HttpTask.java rename to okhttps/src/main/java/com/ejlchina/okhttps/HttpTask.java diff --git a/src/main/java/com/ejlchina/okhttps/HttpUtils.java b/okhttps/src/main/java/com/ejlchina/okhttps/HttpUtils.java similarity index 100% rename from src/main/java/com/ejlchina/okhttps/HttpUtils.java rename to okhttps/src/main/java/com/ejlchina/okhttps/HttpUtils.java diff --git a/src/main/java/com/ejlchina/okhttps/OnCallback.java b/okhttps/src/main/java/com/ejlchina/okhttps/OnCallback.java similarity index 100% rename from src/main/java/com/ejlchina/okhttps/OnCallback.java rename to okhttps/src/main/java/com/ejlchina/okhttps/OnCallback.java diff --git a/src/main/java/com/ejlchina/okhttps/Preprocessor.java b/okhttps/src/main/java/com/ejlchina/okhttps/Preprocessor.java similarity index 100% rename from src/main/java/com/ejlchina/okhttps/Preprocessor.java rename to okhttps/src/main/java/com/ejlchina/okhttps/Preprocessor.java diff --git a/src/main/java/com/ejlchina/okhttps/Process.java b/okhttps/src/main/java/com/ejlchina/okhttps/Process.java similarity index 100% rename from src/main/java/com/ejlchina/okhttps/Process.java rename to okhttps/src/main/java/com/ejlchina/okhttps/Process.java diff --git a/src/main/java/com/ejlchina/okhttps/TaskListener.java b/okhttps/src/main/java/com/ejlchina/okhttps/TaskListener.java similarity index 100% rename from src/main/java/com/ejlchina/okhttps/TaskListener.java rename to okhttps/src/main/java/com/ejlchina/okhttps/TaskListener.java diff --git a/src/main/java/com/ejlchina/okhttps/WebSocket.java b/okhttps/src/main/java/com/ejlchina/okhttps/WebSocket.java similarity index 100% rename from src/main/java/com/ejlchina/okhttps/WebSocket.java rename to okhttps/src/main/java/com/ejlchina/okhttps/WebSocket.java diff --git a/src/main/java/com/ejlchina/okhttps/internal/AsyncHttpTask.java b/okhttps/src/main/java/com/ejlchina/okhttps/internal/AsyncHttpTask.java similarity index 100% rename from src/main/java/com/ejlchina/okhttps/internal/AsyncHttpTask.java rename to okhttps/src/main/java/com/ejlchina/okhttps/internal/AsyncHttpTask.java diff --git a/src/main/java/com/ejlchina/okhttps/internal/HttpClient.java b/okhttps/src/main/java/com/ejlchina/okhttps/internal/HttpClient.java similarity index 100% rename from src/main/java/com/ejlchina/okhttps/internal/HttpClient.java rename to okhttps/src/main/java/com/ejlchina/okhttps/internal/HttpClient.java diff --git a/src/main/java/com/ejlchina/okhttps/internal/HttpException.java b/okhttps/src/main/java/com/ejlchina/okhttps/internal/HttpException.java similarity index 100% rename from src/main/java/com/ejlchina/okhttps/internal/HttpException.java rename to okhttps/src/main/java/com/ejlchina/okhttps/internal/HttpException.java diff --git a/src/main/java/com/ejlchina/okhttps/internal/ProcessInputStream.java b/okhttps/src/main/java/com/ejlchina/okhttps/internal/ProcessInputStream.java similarity index 100% rename from src/main/java/com/ejlchina/okhttps/internal/ProcessInputStream.java rename to okhttps/src/main/java/com/ejlchina/okhttps/internal/ProcessInputStream.java diff --git a/src/main/java/com/ejlchina/okhttps/internal/ProcessRequestBody.java b/okhttps/src/main/java/com/ejlchina/okhttps/internal/ProcessRequestBody.java similarity index 100% rename from src/main/java/com/ejlchina/okhttps/internal/ProcessRequestBody.java rename to okhttps/src/main/java/com/ejlchina/okhttps/internal/ProcessRequestBody.java diff --git a/src/main/java/com/ejlchina/okhttps/internal/RealHttpResult.java b/okhttps/src/main/java/com/ejlchina/okhttps/internal/RealHttpResult.java similarity index 95% rename from src/main/java/com/ejlchina/okhttps/internal/RealHttpResult.java rename to okhttps/src/main/java/com/ejlchina/okhttps/internal/RealHttpResult.java index 15c27ab2..aa4974fc 100644 --- a/src/main/java/com/ejlchina/okhttps/internal/RealHttpResult.java +++ b/okhttps/src/main/java/com/ejlchina/okhttps/internal/RealHttpResult.java @@ -1,135 +1,135 @@ -package com.ejlchina.okhttps.internal; - -import java.io.IOException; -import java.util.Collections; -import java.util.List; - -import com.ejlchina.okhttps.HttpResult; -import com.ejlchina.okhttps.HttpTask; - -import okhttp3.Headers; -import okhttp3.Response; - - -public class RealHttpResult implements HttpResult { - - private State state; - private Response response; - private IOException error; - private TaskExecutor taskExecutor; - private HttpTask httpTask; - private Body body; - - public RealHttpResult(HttpTask httpTask, State state) { - this.httpTask = httpTask; - this.state = state; - } - - public RealHttpResult(HttpTask httpTask, Response response, TaskExecutor taskExecutor) { - this(httpTask, taskExecutor); - response(response); - } - - public RealHttpResult(HttpTask httpTask, TaskExecutor taskExecutor) { - this.httpTask = httpTask; - this.taskExecutor = taskExecutor; - } - - public RealHttpResult(HttpTask httpTask, State state, IOException error) { - this.httpTask = httpTask; - exception(state, error); - } - - public void exception(State state, IOException error) { - this.state = state; - this.error = error; - } - - public void response(Response response) { - this.state = State.RESPONSED; - this.response = response; - } - - @Override - public State getState() { - return state; - } - - @Override - public int getStatus() { - if (response != null) { - return response.code(); - } - return 0; - } - - @Override - public boolean isSuccessful() { - if (response != null) { - return response.isSuccessful(); - } - return false; - } - - @Override - public Headers getHeaders() { - if (response != null) { - return response.headers(); - } - return null; - } - - @Override - public List getHeaders(String name) { - if (response != null) { - return response.headers(name); - } - return Collections.emptyList(); - } - - @Override - public String getHeader(String name) { - if (response != null) { - return response.header(name); - } - return null; - } - - @Override - public Body getBody() { - if (body == null && response != null) { - body = new ResultBody(httpTask, response, taskExecutor); - } - return body; - } - - @Override - public IOException getError() { - return error; - } - - public Response getResponse() { - return response; - } - - - @Override - public String toString() { - Body body = getBody(); - String str = "HttpResult [\n state: " + state + ",\n status: " + getStatus() - + ",\n headers: " + getHeaders(); - if (body != null) { - str += ",\n contentType: " + body.getContentType(); - } - return str + ",\n error: " + error + "\n]"; - } - - @Override - public HttpResult close() { - if (response != null) { - response.close(); - } - return this; - } - -} +package com.ejlchina.okhttps.internal; + +import java.io.IOException; +import java.util.Collections; +import java.util.List; + +import com.ejlchina.okhttps.HttpResult; +import com.ejlchina.okhttps.HttpTask; + +import okhttp3.Headers; +import okhttp3.Response; + + +public class RealHttpResult implements HttpResult { + + private State state; + private Response response; + private IOException error; + private TaskExecutor taskExecutor; + private HttpTask httpTask; + private Body body; + + public RealHttpResult(HttpTask httpTask, State state) { + this.httpTask = httpTask; + this.state = state; + } + + public RealHttpResult(HttpTask httpTask, Response response, TaskExecutor taskExecutor) { + this(httpTask, taskExecutor); + response(response); + } + + public RealHttpResult(HttpTask httpTask, TaskExecutor taskExecutor) { + this.httpTask = httpTask; + this.taskExecutor = taskExecutor; + } + + public RealHttpResult(HttpTask httpTask, State state, IOException error) { + this.httpTask = httpTask; + exception(state, error); + } + + public void exception(State state, IOException error) { + this.state = state; + this.error = error; + } + + public void response(Response response) { + this.state = State.RESPONSED; + this.response = response; + } + + @Override + public State getState() { + return state; + } + + @Override + public int getStatus() { + if (response != null) { + return response.code(); + } + return 0; + } + + @Override + public boolean isSuccessful() { + if (response != null) { + return response.isSuccessful(); + } + return false; + } + + @Override + public Headers getHeaders() { + if (response != null) { + return response.headers(); + } + return null; + } + + @Override + public List getHeaders(String name) { + if (response != null) { + return response.headers(name); + } + return Collections.emptyList(); + } + + @Override + public String getHeader(String name) { + if (response != null) { + return response.header(name); + } + return null; + } + + @Override + public Body getBody() { + if (body == null && response != null) { + body = new ResultBody(httpTask, response, taskExecutor); + } + return body; + } + + @Override + public IOException getError() { + return error; + } + + public Response getResponse() { + return response; + } + + + @Override + public String toString() { + Body body = getBody(); + String str = "HttpResult [\n state: " + state + ",\n status: " + getStatus() + + ",\n headers: " + getHeaders(); + if (body != null) { + str += ",\n contentType: " + body.getContentType(); + } + return str + ",\n error: " + error + "\n]"; + } + + @Override + public HttpResult close() { + if (response != null) { + response.close(); + } + return this; + } + +} diff --git a/src/main/java/com/ejlchina/okhttps/internal/RealProcess.java b/okhttps/src/main/java/com/ejlchina/okhttps/internal/RealProcess.java similarity index 100% rename from src/main/java/com/ejlchina/okhttps/internal/RealProcess.java rename to okhttps/src/main/java/com/ejlchina/okhttps/internal/RealProcess.java diff --git a/src/main/java/com/ejlchina/okhttps/internal/ResultBody.java b/okhttps/src/main/java/com/ejlchina/okhttps/internal/ResultBody.java similarity index 100% rename from src/main/java/com/ejlchina/okhttps/internal/ResultBody.java rename to okhttps/src/main/java/com/ejlchina/okhttps/internal/ResultBody.java diff --git a/src/main/java/com/ejlchina/okhttps/internal/SyncHttpTask.java b/okhttps/src/main/java/com/ejlchina/okhttps/internal/SyncHttpTask.java similarity index 100% rename from src/main/java/com/ejlchina/okhttps/internal/SyncHttpTask.java rename to okhttps/src/main/java/com/ejlchina/okhttps/internal/SyncHttpTask.java diff --git a/src/main/java/com/ejlchina/okhttps/internal/TaskExecutor.java b/okhttps/src/main/java/com/ejlchina/okhttps/internal/TaskExecutor.java similarity index 97% rename from src/main/java/com/ejlchina/okhttps/internal/TaskExecutor.java rename to okhttps/src/main/java/com/ejlchina/okhttps/internal/TaskExecutor.java index cb8c5d1c..42d2e19e 100644 --- a/src/main/java/com/ejlchina/okhttps/internal/TaskExecutor.java +++ b/okhttps/src/main/java/com/ejlchina/okhttps/internal/TaskExecutor.java @@ -1,112 +1,112 @@ -package com.ejlchina.okhttps.internal; - -import java.io.File; -import java.io.IOException; -import java.io.InputStream; -import java.util.concurrent.Executor; -import java.util.concurrent.ExecutorService; - -import com.ejlchina.okhttps.DownListener; -import com.ejlchina.okhttps.Download; -import com.ejlchina.okhttps.HttpResult; -import com.ejlchina.okhttps.HttpTask; -import com.ejlchina.okhttps.OnCallback; -import com.ejlchina.okhttps.TaskListener; -import com.ejlchina.okhttps.HttpResult.State; - -public class TaskExecutor { - - private Executor ioExecutor; - private Executor mainExecutor; - private DownListener downloadListener; - private TaskListener responseListener; - private TaskListener exceptionListener; - private TaskListener completeListener; - - public TaskExecutor(Executor ioExecutor, Executor mainExecutor, DownListener downloadListener, - TaskListener responseListener, TaskListener exceptionListener, - TaskListener completeListener) { - this.ioExecutor = ioExecutor; - this.mainExecutor = mainExecutor; - this.downloadListener = downloadListener; - this.responseListener = responseListener; - this.exceptionListener = exceptionListener; - this.completeListener = completeListener; - } - - public Executor getExecutor(boolean onIoThread) { - if (onIoThread || mainExecutor == null) { - return ioExecutor; - } - return mainExecutor; - } - - public Download download(HttpTask httpTask, File file, InputStream input, long skipBytes) { - Download download = new Download(file, input, this, skipBytes); - if (httpTask != null && downloadListener != null) { - downloadListener.listen(httpTask, download); - } - return download; - } - - public void execute(Runnable command, boolean onIoThread) { - Executor executor = ioExecutor; - if (mainExecutor != null && !onIoThread) { - executor = mainExecutor; - } - executor.execute(command); - } - - public void executeOnResponse(HttpTask task, OnCallback onResponse, HttpResult result, boolean onIoThread) { - if (responseListener != null) { - execute(() -> { - if (responseListener.listen(task, result) && onResponse != null) { - onResponse.on(result); - } - }, onIoThread); - } else if (onResponse != null) { - execute(() -> { onResponse.on(result); }, onIoThread); - } - } - - public boolean executeOnException(HttpTask task, OnCallback onException, IOException error, boolean onIoThread) { - if (exceptionListener != null) { - execute(() -> { - if (exceptionListener.listen(task, error) && onException != null) { - onException.on(error); - } - }, onIoThread); - return true; - } else if (onException != null) { - execute(() -> { onException.on(error); }, onIoThread); - return true; - } - return false; - } - - public void executeOnComplete(HttpTask task, OnCallback onComplete, State state, boolean onIoThread) { - if (completeListener != null) { - execute(() -> { - if (completeListener.listen(task, state) && onComplete != null) { - onComplete.on(state); - } - }, onIoThread); - } else if (onComplete != null) { - execute(() -> { onComplete.on(state); }, onIoThread); - } - } - - /** - * 关闭线程池 - * @since OkHttps V1.0.2 - */ - public void shutdown() { - if (ioExecutor != null && ioExecutor instanceof ExecutorService) { - ((ExecutorService) ioExecutor).shutdown(); - } - if (mainExecutor != null && mainExecutor instanceof ExecutorService) { - ((ExecutorService) mainExecutor).shutdown(); - } - } - -} +package com.ejlchina.okhttps.internal; + +import java.io.File; +import java.io.IOException; +import java.io.InputStream; +import java.util.concurrent.Executor; +import java.util.concurrent.ExecutorService; + +import com.ejlchina.okhttps.DownListener; +import com.ejlchina.okhttps.Download; +import com.ejlchina.okhttps.HttpResult; +import com.ejlchina.okhttps.HttpTask; +import com.ejlchina.okhttps.OnCallback; +import com.ejlchina.okhttps.TaskListener; +import com.ejlchina.okhttps.HttpResult.State; + +public class TaskExecutor { + + private Executor ioExecutor; + private Executor mainExecutor; + private DownListener downloadListener; + private TaskListener responseListener; + private TaskListener exceptionListener; + private TaskListener completeListener; + + public TaskExecutor(Executor ioExecutor, Executor mainExecutor, DownListener downloadListener, + TaskListener responseListener, TaskListener exceptionListener, + TaskListener completeListener) { + this.ioExecutor = ioExecutor; + this.mainExecutor = mainExecutor; + this.downloadListener = downloadListener; + this.responseListener = responseListener; + this.exceptionListener = exceptionListener; + this.completeListener = completeListener; + } + + public Executor getExecutor(boolean onIoThread) { + if (onIoThread || mainExecutor == null) { + return ioExecutor; + } + return mainExecutor; + } + + public Download download(HttpTask httpTask, File file, InputStream input, long skipBytes) { + Download download = new Download(file, input, this, skipBytes); + if (httpTask != null && downloadListener != null) { + downloadListener.listen(httpTask, download); + } + return download; + } + + public void execute(Runnable command, boolean onIoThread) { + Executor executor = ioExecutor; + if (mainExecutor != null && !onIoThread) { + executor = mainExecutor; + } + executor.execute(command); + } + + public void executeOnResponse(HttpTask task, OnCallback onResponse, HttpResult result, boolean onIoThread) { + if (responseListener != null) { + execute(() -> { + if (responseListener.listen(task, result) && onResponse != null) { + onResponse.on(result); + } + }, onIoThread); + } else if (onResponse != null) { + execute(() -> { onResponse.on(result); }, onIoThread); + } + } + + public boolean executeOnException(HttpTask task, OnCallback onException, IOException error, boolean onIoThread) { + if (exceptionListener != null) { + execute(() -> { + if (exceptionListener.listen(task, error) && onException != null) { + onException.on(error); + } + }, onIoThread); + return true; + } else if (onException != null) { + execute(() -> { onException.on(error); }, onIoThread); + return true; + } + return false; + } + + public void executeOnComplete(HttpTask task, OnCallback onComplete, State state, boolean onIoThread) { + if (completeListener != null) { + execute(() -> { + if (completeListener.listen(task, state) && onComplete != null) { + onComplete.on(state); + } + }, onIoThread); + } else if (onComplete != null) { + execute(() -> { onComplete.on(state); }, onIoThread); + } + } + + /** + * 关闭线程池 + * @since OkHttps V1.0.2 + */ + public void shutdown() { + if (ioExecutor != null && ioExecutor instanceof ExecutorService) { + ((ExecutorService) ioExecutor).shutdown(); + } + if (mainExecutor != null && mainExecutor instanceof ExecutorService) { + ((ExecutorService) mainExecutor).shutdown(); + } + } + +} diff --git a/src/main/java/com/ejlchina/okhttps/internal/WebSocketTask.java b/okhttps/src/main/java/com/ejlchina/okhttps/internal/WebSocketTask.java similarity index 100% rename from src/main/java/com/ejlchina/okhttps/internal/WebSocketTask.java rename to okhttps/src/main/java/com/ejlchina/okhttps/internal/WebSocketTask.java diff --git a/src/test/java/com/ejlchina/test/BaseTest.java b/okhttps/src/test/java/com/ejlchina/test/BaseTest.java similarity index 100% rename from src/test/java/com/ejlchina/test/BaseTest.java rename to okhttps/src/test/java/com/ejlchina/test/BaseTest.java diff --git a/src/test/java/com/ejlchina/test/CacheTests.java b/okhttps/src/test/java/com/ejlchina/test/CacheTests.java similarity index 100% rename from src/test/java/com/ejlchina/test/CacheTests.java rename to okhttps/src/test/java/com/ejlchina/test/CacheTests.java diff --git a/src/test/java/com/ejlchina/test/CancelTests.java b/okhttps/src/test/java/com/ejlchina/test/CancelTests.java similarity index 100% rename from src/test/java/com/ejlchina/test/CancelTests.java rename to okhttps/src/test/java/com/ejlchina/test/CancelTests.java diff --git a/src/test/java/com/ejlchina/test/DownloadTests.java b/okhttps/src/test/java/com/ejlchina/test/DownloadTests.java similarity index 100% rename from src/test/java/com/ejlchina/test/DownloadTests.java rename to okhttps/src/test/java/com/ejlchina/test/DownloadTests.java diff --git a/src/test/java/com/ejlchina/test/ExceptionTests.java b/okhttps/src/test/java/com/ejlchina/test/ExceptionTests.java similarity index 98% rename from src/test/java/com/ejlchina/test/ExceptionTests.java rename to okhttps/src/test/java/com/ejlchina/test/ExceptionTests.java index 7cee825b..7fd25505 100644 --- a/src/test/java/com/ejlchina/test/ExceptionTests.java +++ b/okhttps/src/test/java/com/ejlchina/test/ExceptionTests.java @@ -71,7 +71,7 @@ public void testSync1() { } // 还可以获得具体的异常信息 Exception error = result.getError(); - + System.out.println(error); } diff --git a/src/test/java/com/ejlchina/test/ExecutorTests.java b/okhttps/src/test/java/com/ejlchina/test/ExecutorTests.java similarity index 100% rename from src/test/java/com/ejlchina/test/ExecutorTests.java rename to okhttps/src/test/java/com/ejlchina/test/ExecutorTests.java diff --git a/src/test/java/com/ejlchina/test/JsonTests.java b/okhttps/src/test/java/com/ejlchina/test/JsonTests.java similarity index 100% rename from src/test/java/com/ejlchina/test/JsonTests.java rename to okhttps/src/test/java/com/ejlchina/test/JsonTests.java diff --git a/src/test/java/com/ejlchina/test/ListenerTests.java b/okhttps/src/test/java/com/ejlchina/test/ListenerTests.java similarity index 100% rename from src/test/java/com/ejlchina/test/ListenerTests.java rename to okhttps/src/test/java/com/ejlchina/test/ListenerTests.java diff --git a/src/test/java/com/ejlchina/test/PreprocessorTests.java b/okhttps/src/test/java/com/ejlchina/test/PreprocessorTests.java similarity index 100% rename from src/test/java/com/ejlchina/test/PreprocessorTests.java rename to okhttps/src/test/java/com/ejlchina/test/PreprocessorTests.java diff --git a/src/test/java/com/ejlchina/test/SimpleTests.java b/okhttps/src/test/java/com/ejlchina/test/SimpleTests.java similarity index 100% rename from src/test/java/com/ejlchina/test/SimpleTests.java rename to okhttps/src/test/java/com/ejlchina/test/SimpleTests.java diff --git a/src/test/java/com/ejlchina/test/TagTests.java b/okhttps/src/test/java/com/ejlchina/test/TagTests.java similarity index 100% rename from src/test/java/com/ejlchina/test/TagTests.java rename to okhttps/src/test/java/com/ejlchina/test/TagTests.java diff --git a/src/test/java/com/ejlchina/test/UploadTests.java b/okhttps/src/test/java/com/ejlchina/test/UploadTests.java similarity index 100% rename from src/test/java/com/ejlchina/test/UploadTests.java rename to okhttps/src/test/java/com/ejlchina/test/UploadTests.java From f780ad7885b408652aba3542ca66d61766c8e462 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?=E5=91=A8=E6=97=AD?= Date: Fri, 8 May 2020 13:31:53 +0800 Subject: [PATCH 199/924] =?UTF-8?q?=E7=9B=AE=E5=BD=95=E7=BB=93=E6=9E=84?= =?UTF-8?q?=E8=B0=83=E6=95=B4?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- .gitignore | 16 +- .../docs}/.vuepress/config.js | 0 okhttps-doc/docs/.vuepress/dist/404.html | 19 ++ .../dist/assets/css/0.styles.86d9e6f9.css | 1 + .../dist/assets/img/search.83621669.svg | 1 + .../.vuepress/dist/assets/js/10.bc5e580e.js | 1 + .../.vuepress/dist/assets/js/11.152d132f.js | 1 + .../.vuepress/dist/assets/js/12.92e24a16.js | 1 + .../.vuepress/dist/assets/js/13.d857e269.js | 1 + .../.vuepress/dist/assets/js/2.16cbe9f2.js | 1 + .../.vuepress/dist/assets/js/3.972ca2ed.js | 1 + .../.vuepress/dist/assets/js/4.fe3bf0b0.js | 1 + .../.vuepress/dist/assets/js/5.93d38f11.js | 1 + .../.vuepress/dist/assets/js/6.fd474f39.js | 1 + .../.vuepress/dist/assets/js/7.51e5642d.js | 1 + .../.vuepress/dist/assets/js/8.d296d289.js | 1 + .../.vuepress/dist/assets/js/9.bff804f8.js | 1 + .../.vuepress/dist/assets/js/app.1e2fa6f5.js | 13 ++ .../docs/.vuepress/dist/guide/android.html | 161 +++++++++++++++ .../.vuepress/dist/guide/configuration.html | 137 ++++++++++++ .../docs/.vuepress/dist/guide/features.html | 150 ++++++++++++++ .../docs/.vuepress/dist/guide/foundation.html | 130 ++++++++++++ .../docs/.vuepress/dist/guide/index.html | 79 +++++++ .../docs/.vuepress/dist/guide/updown.html | 195 ++++++++++++++++++ okhttps-doc/docs/.vuepress/dist/index.html | 72 +++++++ .../docs/.vuepress/dist}/logo.png | Bin okhttps-doc/docs/.vuepress/public/logo.png | Bin 0 -> 5800 bytes .../docs}/.vuepress/styles/index.styl | 0 {docs => okhttps-doc/docs}/README.md | 0 {docs => okhttps-doc/docs}/guide/README.md | 0 {docs => okhttps-doc/docs}/guide/android.md | 0 .../docs}/guide/configuration.md | 0 {docs => okhttps-doc/docs}/guide/features.md | 0 .../docs}/guide/foundation.md | 0 {docs => okhttps-doc/docs}/guide/updown.md | 0 package.json => okhttps-doc/package.json | 0 36 files changed, 979 insertions(+), 7 deletions(-) rename {docs => okhttps-doc/docs}/.vuepress/config.js (100%) create mode 100644 okhttps-doc/docs/.vuepress/dist/404.html create mode 100644 okhttps-doc/docs/.vuepress/dist/assets/css/0.styles.86d9e6f9.css create mode 100644 okhttps-doc/docs/.vuepress/dist/assets/img/search.83621669.svg create mode 100644 okhttps-doc/docs/.vuepress/dist/assets/js/10.bc5e580e.js create mode 100644 okhttps-doc/docs/.vuepress/dist/assets/js/11.152d132f.js create mode 100644 okhttps-doc/docs/.vuepress/dist/assets/js/12.92e24a16.js create mode 100644 okhttps-doc/docs/.vuepress/dist/assets/js/13.d857e269.js create mode 100644 okhttps-doc/docs/.vuepress/dist/assets/js/2.16cbe9f2.js create mode 100644 okhttps-doc/docs/.vuepress/dist/assets/js/3.972ca2ed.js create mode 100644 okhttps-doc/docs/.vuepress/dist/assets/js/4.fe3bf0b0.js create mode 100644 okhttps-doc/docs/.vuepress/dist/assets/js/5.93d38f11.js create mode 100644 okhttps-doc/docs/.vuepress/dist/assets/js/6.fd474f39.js create mode 100644 okhttps-doc/docs/.vuepress/dist/assets/js/7.51e5642d.js create mode 100644 okhttps-doc/docs/.vuepress/dist/assets/js/8.d296d289.js create mode 100644 okhttps-doc/docs/.vuepress/dist/assets/js/9.bff804f8.js create mode 100644 okhttps-doc/docs/.vuepress/dist/assets/js/app.1e2fa6f5.js create mode 100644 okhttps-doc/docs/.vuepress/dist/guide/android.html create mode 100644 okhttps-doc/docs/.vuepress/dist/guide/configuration.html create mode 100644 okhttps-doc/docs/.vuepress/dist/guide/features.html create mode 100644 okhttps-doc/docs/.vuepress/dist/guide/foundation.html create mode 100644 okhttps-doc/docs/.vuepress/dist/guide/index.html create mode 100644 okhttps-doc/docs/.vuepress/dist/guide/updown.html create mode 100644 okhttps-doc/docs/.vuepress/dist/index.html rename {docs/.vuepress/public => okhttps-doc/docs/.vuepress/dist}/logo.png (100%) create mode 100644 okhttps-doc/docs/.vuepress/public/logo.png rename {docs => okhttps-doc/docs}/.vuepress/styles/index.styl (100%) rename {docs => okhttps-doc/docs}/README.md (100%) rename {docs => okhttps-doc/docs}/guide/README.md (100%) rename {docs => okhttps-doc/docs}/guide/android.md (100%) rename {docs => okhttps-doc/docs}/guide/configuration.md (100%) rename {docs => okhttps-doc/docs}/guide/features.md (100%) rename {docs => okhttps-doc/docs}/guide/foundation.md (100%) rename {docs => okhttps-doc/docs}/guide/updown.md (100%) rename package.json => okhttps-doc/package.json (100%) diff --git a/.gitignore b/.gitignore index 5a255776..d39f4879 100644 --- a/.gitignore +++ b/.gitignore @@ -1,10 +1,12 @@ -/target/ -/bin/ +/*/target/ +/*/bin/ /*/.settings/ /*/.classpath /*/.project -/.idea/ -/package-lock.json -/node_modules/ -/docs/.vuepress/dist/ -*.iml \ No newline at end of file +/*/.idea/ +/*/package-lock.json +/*/node_modules/ +/*/.vuepress/dist/* +/*/*.iml +*.iml +/.idea/ \ No newline at end of file diff --git a/docs/.vuepress/config.js b/okhttps-doc/docs/.vuepress/config.js similarity index 100% rename from docs/.vuepress/config.js rename to okhttps-doc/docs/.vuepress/config.js diff --git a/okhttps-doc/docs/.vuepress/dist/404.html b/okhttps-doc/docs/.vuepress/dist/404.html new file mode 100644 index 00000000..8d2b3afc --- /dev/null +++ b/okhttps-doc/docs/.vuepress/dist/404.html @@ -0,0 +1,19 @@ + + + + + + OkHttps + + + + + + + +

404

That's a Four-Oh-Four.
+ Take me home. +
+ + + diff --git a/okhttps-doc/docs/.vuepress/dist/assets/css/0.styles.86d9e6f9.css b/okhttps-doc/docs/.vuepress/dist/assets/css/0.styles.86d9e6f9.css new file mode 100644 index 00000000..355d531c --- /dev/null +++ b/okhttps-doc/docs/.vuepress/dist/assets/css/0.styles.86d9e6f9.css @@ -0,0 +1 @@ +#nprogress{pointer-events:none}#nprogress .bar{background:#3eaf7c;position:fixed;z-index:1031;top:0;left:0;width:100%;height:2px}#nprogress .peg{display:block;position:absolute;right:0;width:100px;height:100%;box-shadow:0 0 10px #3eaf7c,0 0 5px #3eaf7c;opacity:1;transform:rotate(3deg) translateY(-4px)}#nprogress .spinner{display:block;position:fixed;z-index:1031;top:15px;right:15px}#nprogress .spinner-icon{width:18px;height:18px;box-sizing:border-box;border-color:#3eaf7c transparent transparent #3eaf7c;border-style:solid;border-width:2px;border-radius:50%;-webkit-animation:nprogress-spinner .4s linear infinite;animation:nprogress-spinner .4s linear infinite}.nprogress-custom-parent{overflow:hidden;position:relative}.nprogress-custom-parent #nprogress .bar,.nprogress-custom-parent #nprogress .spinner{position:absolute}@-webkit-keyframes nprogress-spinner{0%{transform:rotate(0deg)}to{transform:rotate(1turn)}}@keyframes nprogress-spinner{0%{transform:rotate(0deg)}to{transform:rotate(1turn)}}html{scroll-behavior:smooth}.go-to-top[data-v-5fd4ef0c]{cursor:pointer;position:fixed;bottom:2rem;right:2.5rem;width:2rem;color:#3eaf7c;z-index:1}.go-to-top[data-v-5fd4ef0c]:hover{color:#72cda4}@media (max-width:959px){.go-to-top[data-v-5fd4ef0c]{display:none}}.fade-enter-active[data-v-5fd4ef0c],.fade-leave-active[data-v-5fd4ef0c]{transition:opacity .3s}.fade-enter[data-v-5fd4ef0c],.fade-leave-to[data-v-5fd4ef0c]{opacity:0}.code-switcher div[class*=language-]:before{content:""}.code-switcher .tab-header ul{padding:0;text-align:right;margin-bottom:-5px;margin-top:20px}.code-switcher .tab-header li{display:inline-block;padding:0 10px;cursor:pointer;border-radius:4px;border:2px solid #eaecef;margin-left:5px;font-size:80%}.code-switcher .tab-header li.active{border-color:#3eaf7c}.icon.outbound{color:#aaa;display:inline-block;vertical-align:middle;position:relative;top:-1px}.home{padding:3.6rem 2rem 0;max-width:960px;margin:0 auto;display:block}.home .hero{text-align:center}.home .hero img{max-width:100%;max-height:280px;display:block;margin:3rem auto 1.5rem}.home .hero h1{font-size:3rem}.home .hero .action,.home .hero .description,.home .hero h1{margin:1.8rem auto}.home .hero .description{max-width:35rem;font-size:1.6rem;line-height:1.3;color:#6a8bad}.home .hero .action-button{display:inline-block;font-size:1.2rem;color:#fff;background-color:#3eaf7c;padding:.8rem 1.6rem;border-radius:4px;transition:background-color .1s ease;box-sizing:border-box;border-bottom:1px solid #389d70}.home .hero .action-button:hover{background-color:#4abf8a}.home .features{border-top:1px solid #eaecef;padding:1.2rem 0;margin-top:2.5rem;display:flex;flex-wrap:wrap;align-items:flex-start;align-content:stretch;justify-content:space-between}.home .feature{flex-grow:1;flex-basis:30%;max-width:30%}.home .feature h2{font-size:1.4rem;font-weight:500;border-bottom:none;padding-bottom:0;color:#3a5169}.home .feature p{color:#4e6e8e}.home .footer{padding:2.5rem;border-top:1px solid #eaecef;text-align:center;color:#4e6e8e}@media (max-width:719px){.home .features{flex-direction:column}.home .feature{max-width:100%;padding:0 2.5rem}}@media (max-width:419px){.home{padding-left:1.5rem;padding-right:1.5rem}.home .hero img{max-height:210px;margin:2rem auto 1.2rem}.home .hero h1{font-size:2rem}.home .hero .action,.home .hero .description,.home .hero h1{margin:1.2rem auto}.home .hero .description{font-size:1.2rem}.home .hero .action-button{font-size:1rem;padding:.6rem 1.2rem}.home .feature h2{font-size:1.25rem}}.search-box{display:inline-block;position:relative;margin-right:1rem}.search-box input{cursor:text;width:10rem;height:2rem;color:#4e6e8e;display:inline-block;border:1px solid #cfd4db;border-radius:2rem;font-size:.9rem;line-height:2rem;padding:0 .5rem 0 2rem;outline:none;transition:all .2s ease;background:#fff url(/assets/img/search.83621669.svg) .6rem .5rem no-repeat;background-size:1rem}.search-box input:focus{cursor:auto;border-color:#3eaf7c}.search-box .suggestions{background:#fff;width:20rem;position:absolute;top:2rem;border:1px solid #cfd4db;border-radius:6px;padding:.4rem;list-style-type:none}.search-box .suggestions.align-right{right:0}.search-box .suggestion{line-height:1.4;padding:.4rem .6rem;border-radius:4px;cursor:pointer}.search-box .suggestion a{white-space:normal;color:#5d82a6}.search-box .suggestion a .page-title{font-weight:600}.search-box .suggestion a .header{font-size:.9em;margin-left:.25em}.search-box .suggestion.focused{background-color:#f3f4f5}.search-box .suggestion.focused a{color:#3eaf7c}@media (max-width:959px){.search-box input{cursor:pointer;width:0;border-color:transparent;position:relative}.search-box input:focus{cursor:text;left:0;width:10rem}}@media (-ms-high-contrast:none){.search-box input{height:2rem}}@media (max-width:959px) and (min-width:719px){.search-box .suggestions{left:0}}@media (max-width:719px){.search-box{margin-right:0}.search-box input{left:1rem}.search-box .suggestions{right:0}}@media (max-width:419px){.search-box .suggestions{width:calc(100vw - 4rem)}.search-box input:focus{width:8rem}}.sidebar-button{cursor:pointer;display:none;width:1.25rem;height:1.25rem;position:absolute;padding:.6rem;top:.6rem;left:1rem}.sidebar-button .icon{display:block;width:1.25rem;height:1.25rem}@media (max-width:719px){.sidebar-button{display:block}}.dropdown-enter,.dropdown-leave-to{height:0!important}.dropdown-wrapper{cursor:pointer}.dropdown-wrapper .dropdown-title{display:block;font-size:.9rem;font-family:inherit;cursor:inherit;padding:inherit;line-height:1.4rem;background:transparent;border:none;font-weight:500;color:#2c3e50;pointer-events:none}.dropdown-wrapper .dropdown-title:hover{border-color:transparent}.dropdown-wrapper .dropdown-title .arrow{vertical-align:middle;margin-top:-1px;margin-left:.4rem}.dropdown-wrapper .nav-dropdown .dropdown-item{color:inherit;line-height:1.7rem}.dropdown-wrapper .nav-dropdown .dropdown-item h4{margin:.45rem 0 0;border-top:1px solid #eee;padding:.45rem 1.5rem 0 1.25rem}.dropdown-wrapper .nav-dropdown .dropdown-item .dropdown-subitem-wrapper{padding:0;list-style:none}.dropdown-wrapper .nav-dropdown .dropdown-item .dropdown-subitem-wrapper .dropdown-subitem{font-size:.9em}.dropdown-wrapper .nav-dropdown .dropdown-item a{display:block;line-height:1.7rem;position:relative;border-bottom:none;font-weight:400;margin-bottom:0;padding:0 1.5rem 0 1.25rem}.dropdown-wrapper .nav-dropdown .dropdown-item a.router-link-active,.dropdown-wrapper .nav-dropdown .dropdown-item a:hover{color:#3eaf7c}.dropdown-wrapper .nav-dropdown .dropdown-item a.router-link-active:after{content:"";width:0;height:0;border-left:5px solid #3eaf7c;border-top:3px solid transparent;border-bottom:3px solid transparent;position:absolute;top:calc(50% - 2px);left:9px}.dropdown-wrapper .nav-dropdown .dropdown-item:first-child h4{margin-top:0;padding-top:0;border-top:0}@media (max-width:719px){.dropdown-wrapper.open .dropdown-title{margin-bottom:.5rem}.dropdown-wrapper .dropdown-title{font-weight:600;font-size:inherit}.dropdown-wrapper .dropdown-title:hover{color:#3eaf7c}.dropdown-wrapper .nav-dropdown{transition:height .1s ease-out;overflow:hidden}.dropdown-wrapper .nav-dropdown .dropdown-item h4{border-top:0;margin-top:0;padding-top:0}.dropdown-wrapper .nav-dropdown .dropdown-item>a,.dropdown-wrapper .nav-dropdown .dropdown-item h4{font-size:15px;line-height:2rem}.dropdown-wrapper .nav-dropdown .dropdown-item .dropdown-subitem{font-size:14px;padding-left:1rem}}@media (min-width:719px){.dropdown-wrapper{height:1.8rem}.dropdown-wrapper.open .nav-dropdown,.dropdown-wrapper:hover .nav-dropdown{display:block!important}.dropdown-wrapper.open:blur{display:none}.dropdown-wrapper .dropdown-title .arrow{border-left:4px solid transparent;border-right:4px solid transparent;border-top:6px solid #ccc;border-bottom:0}.dropdown-wrapper .nav-dropdown{display:none;height:auto!important;box-sizing:border-box;max-height:calc(100vh - 2.7rem);overflow-y:auto;position:absolute;top:100%;right:0;background-color:#fff;padding:.6rem 0;border:1px solid;border-color:#ddd #ddd #ccc;text-align:left;border-radius:.25rem;white-space:nowrap;margin:0}}.nav-links{display:inline-block}.nav-links a{line-height:1.4rem;color:inherit}.nav-links a.router-link-active,.nav-links a:hover{color:#3eaf7c}.nav-links .nav-item{position:relative;display:inline-block;margin-left:1.5rem;line-height:2rem}.nav-links .nav-item:first-child{margin-left:0}.nav-links .repo-link{margin-left:1.5rem}@media (max-width:719px){.nav-links .nav-item,.nav-links .repo-link{margin-left:0}}@media (min-width:719px){.nav-links a.router-link-active,.nav-links a:hover{color:#2c3e50}.nav-item>a:not(.external).router-link-active,.nav-item>a:not(.external):hover{margin-bottom:-2px;border-bottom:2px solid #46bd87}}.navbar{padding:.7rem 1.5rem;line-height:2.2rem}.navbar a,.navbar img,.navbar span{display:inline-block}.navbar .logo{height:2.2rem;min-width:2.2rem;margin-right:.8rem;vertical-align:top}.navbar .site-name{font-size:1.3rem;font-weight:600;color:#2c3e50;position:relative}.navbar .links{padding-left:1.5rem;box-sizing:border-box;background-color:#fff;white-space:nowrap;font-size:.9rem;position:absolute;right:1.5rem;top:.7rem;display:flex}.navbar .links .search-box{flex:0 0 auto;vertical-align:top}@media (max-width:719px){.navbar{padding-left:4rem}.navbar .can-hide{display:none}.navbar .links{padding-left:1.5rem}.navbar .site-name{width:calc(100vw - 9.4rem);overflow:hidden;white-space:nowrap;text-overflow:ellipsis}}.page-edit{max-width:740px;margin:0 auto;padding:2rem 2.5rem}@media (max-width:959px){.page-edit{padding:2rem}}@media (max-width:419px){.page-edit{padding:1.5rem}}.page-edit{padding-top:1rem;padding-bottom:1rem;overflow:auto}.page-edit .edit-link{display:inline-block}.page-edit .edit-link a{color:#4e6e8e;margin-right:.25rem}.page-edit .last-updated{float:right;font-size:.9em}.page-edit .last-updated .prefix{font-weight:500;color:#4e6e8e}.page-edit .last-updated .time{font-weight:400;color:#aaa}@media (max-width:719px){.page-edit .edit-link{margin-bottom:.5rem}.page-edit .last-updated{font-size:.8em;float:none;text-align:left}}.page-nav{max-width:740px;margin:0 auto;padding:2rem 2.5rem}@media (max-width:959px){.page-nav{padding:2rem}}@media (max-width:419px){.page-nav{padding:1.5rem}}.page-nav{padding-top:1rem;padding-bottom:0}.page-nav .inner{min-height:2rem;margin-top:0;border-top:1px solid #eaecef;padding-top:1rem;overflow:auto}.page-nav .next{float:right}.page{padding-bottom:2rem;display:block}.sidebar-group .sidebar-group{padding-left:.5em}.sidebar-group:not(.collapsable) .sidebar-heading:not(.clickable){cursor:auto;color:inherit}.sidebar-group.is-sub-group{padding-left:0}.sidebar-group.is-sub-group>.sidebar-heading{font-size:.95em;line-height:1.4;font-weight:400;padding-left:2rem}.sidebar-group.is-sub-group>.sidebar-heading:not(.clickable){opacity:.5}.sidebar-group.is-sub-group>.sidebar-group-items{padding-left:1rem}.sidebar-group.is-sub-group>.sidebar-group-items>li>.sidebar-link{font-size:.95em;border-left:none}.sidebar-group.depth-2>.sidebar-heading{border-left:none}.sidebar-heading{color:#2c3e50;transition:color .15s ease;cursor:pointer;font-size:1.1em;font-weight:700;padding:.35rem 1.5rem .35rem 1.25rem;width:100%;box-sizing:border-box;margin:0;border-left:.25rem solid transparent}.sidebar-heading.open,.sidebar-heading:hover{color:inherit}.sidebar-heading .arrow{position:relative;top:-.12em;left:.5em}.sidebar-heading.clickable.active{font-weight:600;color:#3eaf7c;border-left-color:#3eaf7c}.sidebar-heading.clickable:hover{color:#3eaf7c}.sidebar-group-items{transition:height .1s ease-out;font-size:.95em;overflow:hidden}.sidebar .sidebar-sub-headers{padding-left:1rem;font-size:.95em}a.sidebar-link{font-size:1em;font-weight:400;display:inline-block;color:#2c3e50;border-left:.25rem solid transparent;padding:.35rem 1rem .35rem 1.25rem;line-height:1.4;width:100%;box-sizing:border-box}a.sidebar-link:hover{color:#3eaf7c}a.sidebar-link.active{font-weight:600;color:#3eaf7c;border-left-color:#3eaf7c}.sidebar-group a.sidebar-link{padding-left:2rem}.sidebar-sub-headers a.sidebar-link{padding-top:.25rem;padding-bottom:.25rem;border-left:none}.sidebar-sub-headers a.sidebar-link.active{font-weight:500}.sidebar ul{padding:0;margin:0;list-style-type:none}.sidebar a{display:inline-block}.sidebar .nav-links{display:none;border-bottom:1px solid #eaecef;padding:.5rem 0 .75rem}.sidebar .nav-links a{font-weight:600}.sidebar .nav-links .nav-item,.sidebar .nav-links .repo-link{display:block;line-height:1.25rem;font-size:1.1em;padding:.5rem 0 .5rem 1.5rem}.sidebar>.sidebar-links{padding:1.5rem 0}.sidebar>.sidebar-links>li>a.sidebar-link{font-size:1.1em;line-height:1.7;font-weight:700}.sidebar>.sidebar-links>li:not(:first-child){margin-top:.75rem}@media (max-width:719px){.sidebar .nav-links{display:block}.sidebar .nav-links .dropdown-wrapper .nav-dropdown .dropdown-item a.router-link-active:after{top:calc(1rem - 2px)}.sidebar>.sidebar-links{padding:1rem 0}}code[class*=language-],pre[class*=language-]{color:#ccc;background:none;font-family:Consolas,Monaco,Andale Mono,Ubuntu Mono,monospace;font-size:1em;text-align:left;white-space:pre;word-spacing:normal;word-break:normal;word-wrap:normal;line-height:1.5;-moz-tab-size:4;-o-tab-size:4;tab-size:4;-webkit-hyphens:none;-ms-hyphens:none;hyphens:none}pre[class*=language-]{padding:1em;margin:.5em 0;overflow:auto}:not(pre)>code[class*=language-],pre[class*=language-]{background:#2d2d2d}:not(pre)>code[class*=language-]{padding:.1em;border-radius:.3em;white-space:normal}.token.block-comment,.token.cdata,.token.comment,.token.doctype,.token.prolog{color:#999}.token.punctuation{color:#ccc}.token.attr-name,.token.deleted,.token.namespace,.token.tag{color:#e2777a}.token.function-name{color:#6196cc}.token.boolean,.token.function,.token.number{color:#f08d49}.token.class-name,.token.constant,.token.property,.token.symbol{color:#f8c555}.token.atrule,.token.builtin,.token.important,.token.keyword,.token.selector{color:#cc99cd}.token.attr-value,.token.char,.token.regex,.token.string,.token.variable{color:#7ec699}.token.entity,.token.operator,.token.url{color:#67cdcc}.token.bold,.token.important{font-weight:700}.token.italic{font-style:italic}.token.entity{cursor:help}.token.inserted{color:green}.theme-default-content code{color:#476582;padding:.25rem .5rem;margin:0;font-size:.85em;background-color:rgba(27,31,35,.05);border-radius:3px}.theme-default-content code .token.deleted{color:#ec5975}.theme-default-content code .token.inserted{color:#3eaf7c}.theme-default-content pre,.theme-default-content pre[class*=language-]{line-height:1.4;padding:1.25rem 1.5rem;margin:.85rem 0;background-color:#282c34;border-radius:6px;overflow:auto}.theme-default-content pre[class*=language-] code,.theme-default-content pre code{color:#fff;padding:0;background-color:transparent;border-radius:0}div[class*=language-]{position:relative;background-color:#282c34;border-radius:6px}div[class*=language-] .highlight-lines{-webkit-user-select:none;-ms-user-select:none;user-select:none;padding-top:1.3rem;position:absolute;top:0;left:0;width:100%;line-height:1.4}div[class*=language-] .highlight-lines .highlighted{background-color:rgba(0,0,0,.66)}div[class*=language-] pre,div[class*=language-] pre[class*=language-]{background:transparent;position:relative;z-index:1}div[class*=language-]:before{position:absolute;z-index:3;top:.8em;right:1em;font-size:.75rem;color:hsla(0,0%,100%,.4)}div[class*=language-]:not(.line-numbers-mode) .line-numbers-wrapper{display:none}div[class*=language-].line-numbers-mode .highlight-lines .highlighted{position:relative}div[class*=language-].line-numbers-mode .highlight-lines .highlighted:before{content:" ";position:absolute;z-index:3;left:0;top:0;display:block;width:3.5rem;height:100%;background-color:rgba(0,0,0,.66)}div[class*=language-].line-numbers-mode pre{padding-left:4.5rem;vertical-align:middle}div[class*=language-].line-numbers-mode .line-numbers-wrapper{position:absolute;top:0;width:3.5rem;text-align:center;color:hsla(0,0%,100%,.3);padding:1.25rem 0;line-height:1.4}div[class*=language-].line-numbers-mode .line-numbers-wrapper br{-webkit-user-select:none;-ms-user-select:none;user-select:none}div[class*=language-].line-numbers-mode .line-numbers-wrapper .line-number{position:relative;z-index:4;-webkit-user-select:none;-ms-user-select:none;user-select:none;font-size:.85em}div[class*=language-].line-numbers-mode:after{content:"";position:absolute;z-index:2;top:0;left:0;width:3.5rem;height:100%;border-radius:6px 0 0 6px;border-right:1px solid rgba(0,0,0,.66);background-color:#282c34}div[class~=language-js]:before{content:"js"}div[class~=language-ts]:before{content:"ts"}div[class~=language-html]:before{content:"html"}div[class~=language-md]:before{content:"md"}div[class~=language-vue]:before{content:"vue"}div[class~=language-css]:before{content:"css"}div[class~=language-sass]:before{content:"sass"}div[class~=language-scss]:before{content:"scss"}div[class~=language-less]:before{content:"less"}div[class~=language-stylus]:before{content:"stylus"}div[class~=language-go]:before{content:"go"}div[class~=language-java]:before{content:"java"}div[class~=language-c]:before{content:"c"}div[class~=language-sh]:before{content:"sh"}div[class~=language-yaml]:before{content:"yaml"}div[class~=language-py]:before{content:"py"}div[class~=language-docker]:before{content:"docker"}div[class~=language-dockerfile]:before{content:"dockerfile"}div[class~=language-makefile]:before{content:"makefile"}div[class~=language-javascript]:before{content:"js"}div[class~=language-typescript]:before{content:"ts"}div[class~=language-markup]:before{content:"html"}div[class~=language-markdown]:before{content:"md"}div[class~=language-json]:before{content:"json"}div[class~=language-ruby]:before{content:"rb"}div[class~=language-python]:before{content:"py"}div[class~=language-bash]:before{content:"sh"}div[class~=language-php]:before{content:"php"}.custom-block .custom-block-title{font-weight:600;margin-bottom:-.4rem}.custom-block.danger,.custom-block.tip,.custom-block.warning{padding:.1rem 1.5rem;border-left-width:.5rem;border-left-style:solid;margin:1rem 0}.custom-block.tip{background-color:#f3f5f7;border-color:#42b983}.custom-block.warning{background-color:rgba(255,229,100,.3);border-color:#e7c000;color:#6b5900}.custom-block.warning .custom-block-title{color:#b29400}.custom-block.warning a{color:#2c3e50}.custom-block.danger{background-color:#ffe6e6;border-color:#c00;color:#4d0000}.custom-block.danger .custom-block-title{color:#900}.custom-block.danger a{color:#2c3e50}.custom-block.details{display:block;position:relative;border-radius:2px;margin:1.6em 0;padding:1.6em;background-color:#eee}.custom-block.details h4{margin-top:0}.custom-block.details figure:last-child,.custom-block.details p:last-child{margin-bottom:0;padding-bottom:0}.custom-block.details summary{outline:none;cursor:pointer}.arrow{display:inline-block;width:0;height:0}.arrow.up{border-bottom:6px solid #ccc}.arrow.down,.arrow.up{border-left:4px solid transparent;border-right:4px solid transparent}.arrow.down{border-top:6px solid #ccc}.arrow.right{border-left:6px solid #ccc}.arrow.left,.arrow.right{border-top:4px solid transparent;border-bottom:4px solid transparent}.arrow.left{border-right:6px solid #ccc}.theme-default-content:not(.custom){max-width:740px;margin:0 auto;padding:2rem 2.5rem}@media (max-width:959px){.theme-default-content:not(.custom){padding:2rem}}@media (max-width:419px){.theme-default-content:not(.custom){padding:1.5rem}}.table-of-contents .badge{vertical-align:middle}body,html{padding:0;margin:0;background-color:#fff}body{font-family:-apple-system,BlinkMacSystemFont,Segoe UI,Roboto,Oxygen,Ubuntu,Cantarell,Fira Sans,Droid Sans,Helvetica Neue,sans-serif;-webkit-font-smoothing:antialiased;-moz-osx-font-smoothing:grayscale;font-size:16px;color:#2c3e50}.page{padding-left:20rem}.navbar{z-index:20;right:0;height:3.6rem;background-color:#fff;box-sizing:border-box;border-bottom:1px solid #eaecef}.navbar,.sidebar-mask{position:fixed;top:0;left:0}.sidebar-mask{z-index:9;width:100vw;height:100vh;display:none}.sidebar{font-size:16px;background-color:#fff;width:20rem;position:fixed;z-index:10;margin:0;top:3.6rem;left:0;bottom:0;box-sizing:border-box;border-right:1px solid #eaecef;overflow-y:auto}.theme-default-content:not(.custom)>:first-child{margin-top:3.6rem}.theme-default-content:not(.custom) a:hover{text-decoration:underline}.theme-default-content:not(.custom) p.demo{padding:1rem 1.5rem;border:1px solid #ddd;border-radius:4px}.theme-default-content:not(.custom) img{max-width:100%}.theme-default-content.custom{padding:0;margin:0}.theme-default-content.custom img{max-width:100%}a{font-weight:500;text-decoration:none}a,p a code{color:#3eaf7c}p a code{font-weight:400}kbd{background:#eee;border:.15rem solid #ddd;border-bottom:.25rem solid #ddd;border-radius:.15rem;padding:0 .15em}blockquote{font-size:1rem;color:#999;border-left:.2rem solid #dfe2e5;margin:1rem 0;padding:.25rem 0 .25rem 1rem}blockquote>p{margin:0}ol,ul{padding-left:1.2em}strong{font-weight:600}h1,h2,h3,h4,h5,h6{font-weight:600;line-height:1.25}.theme-default-content:not(.custom)>h1,.theme-default-content:not(.custom)>h2,.theme-default-content:not(.custom)>h3,.theme-default-content:not(.custom)>h4,.theme-default-content:not(.custom)>h5,.theme-default-content:not(.custom)>h6{margin-top:-3.1rem;padding-top:4.6rem;margin-bottom:0}.theme-default-content:not(.custom)>h1:first-child,.theme-default-content:not(.custom)>h2:first-child,.theme-default-content:not(.custom)>h3:first-child,.theme-default-content:not(.custom)>h4:first-child,.theme-default-content:not(.custom)>h5:first-child,.theme-default-content:not(.custom)>h6:first-child{margin-top:-1.5rem;margin-bottom:1rem}.theme-default-content:not(.custom)>h1:first-child+.custom-block,.theme-default-content:not(.custom)>h1:first-child+p,.theme-default-content:not(.custom)>h1:first-child+pre,.theme-default-content:not(.custom)>h2:first-child+.custom-block,.theme-default-content:not(.custom)>h2:first-child+p,.theme-default-content:not(.custom)>h2:first-child+pre,.theme-default-content:not(.custom)>h3:first-child+.custom-block,.theme-default-content:not(.custom)>h3:first-child+p,.theme-default-content:not(.custom)>h3:first-child+pre,.theme-default-content:not(.custom)>h4:first-child+.custom-block,.theme-default-content:not(.custom)>h4:first-child+p,.theme-default-content:not(.custom)>h4:first-child+pre,.theme-default-content:not(.custom)>h5:first-child+.custom-block,.theme-default-content:not(.custom)>h5:first-child+p,.theme-default-content:not(.custom)>h5:first-child+pre,.theme-default-content:not(.custom)>h6:first-child+.custom-block,.theme-default-content:not(.custom)>h6:first-child+p,.theme-default-content:not(.custom)>h6:first-child+pre{margin-top:2rem}h1:hover .header-anchor,h2:hover .header-anchor,h3:hover .header-anchor,h4:hover .header-anchor,h5:hover .header-anchor,h6:hover .header-anchor{opacity:1}h1{font-size:2.2rem}h2{font-size:1.65rem;padding-bottom:.3rem;border-bottom:1px solid #eaecef}h3{font-size:1.35rem}a.header-anchor{font-size:.85em;float:left;margin-left:-.87em;padding-right:.23em;margin-top:.125em;opacity:0}a.header-anchor:hover{text-decoration:none}.line-number,code,kbd{font-family:source-code-pro,Menlo,Monaco,Consolas,Courier New,monospace}ol,p,ul{line-height:1.7}hr{border:0;border-top:1px solid #eaecef}table{border-collapse:collapse;margin:1rem 0;display:block;overflow-x:auto}tr{border-top:1px solid #dfe2e5}tr:nth-child(2n){background-color:#f6f8fa}td,th{border:1px solid #dfe2e5;padding:.6em 1em}.theme-container.sidebar-open .sidebar-mask{display:block}.theme-container.no-navbar .theme-default-content:not(.custom)>h1,.theme-container.no-navbar h2,.theme-container.no-navbar h3,.theme-container.no-navbar h4,.theme-container.no-navbar h5,.theme-container.no-navbar h6{margin-top:1.5rem;padding-top:0}.theme-container.no-navbar .sidebar{top:0}@media (min-width:720px){.theme-container.no-sidebar .sidebar{display:none}.theme-container.no-sidebar .page{padding-left:0}}@media (max-width:959px){.sidebar{font-size:15px;width:16.4rem}.page{padding-left:16.4rem}}@media (max-width:719px){.sidebar{top:0;padding-top:3.6rem;transform:translateX(-100%);transition:transform .2s ease}.page{padding-left:0}.theme-container.sidebar-open .sidebar{transform:translateX(0)}.theme-container.no-navbar .sidebar{padding-top:0}}@media (max-width:419px){h1{font-size:1.9rem}.theme-default-content div[class*=language-]{margin:.85rem -1.5rem;border-radius:0}}.home .hero img{height:200px}.badge[data-v-15b7b770]{display:inline-block;font-size:14px;height:18px;line-height:18px;border-radius:3px;padding:0 6px;color:#fff}.badge.green[data-v-15b7b770],.badge.tip[data-v-15b7b770],.badge[data-v-15b7b770]{background-color:#42b983}.badge.error[data-v-15b7b770]{background-color:#da5961}.badge.warn[data-v-15b7b770],.badge.warning[data-v-15b7b770],.badge.yellow[data-v-15b7b770]{background-color:#e7c000}.badge+.badge[data-v-15b7b770]{margin-left:5px} \ No newline at end of file diff --git a/okhttps-doc/docs/.vuepress/dist/assets/img/search.83621669.svg b/okhttps-doc/docs/.vuepress/dist/assets/img/search.83621669.svg new file mode 100644 index 00000000..03d83913 --- /dev/null +++ b/okhttps-doc/docs/.vuepress/dist/assets/img/search.83621669.svg @@ -0,0 +1 @@ + diff --git a/okhttps-doc/docs/.vuepress/dist/assets/js/10.bc5e580e.js b/okhttps-doc/docs/.vuepress/dist/assets/js/10.bc5e580e.js new file mode 100644 index 00000000..8f8cfd50 --- /dev/null +++ b/okhttps-doc/docs/.vuepress/dist/assets/js/10.bc5e580e.js @@ -0,0 +1 @@ +(window.webpackJsonp=window.webpackJsonp||[]).push([[10],{333:function(s,t,a){"use strict";a.r(t);var n=a(19),e=Object(n.a)({},(function(){var s=this,t=s.$createElement,a=s._self._c||t;return a("ContentSlotsDistributor",{attrs:{"slot-key":s.$parent.slotKey}},[a("h1",{attrs:{id:"特色"}},[a("a",{staticClass:"header-anchor",attrs:{href:"#特色"}},[s._v("#")]),s._v(" 特色")]),s._v(" "),a("h2",{attrs:{id:"使用-httputils-类"}},[a("a",{staticClass:"header-anchor",attrs:{href:"#使用-httputils-类"}},[s._v("#")]),s._v(" 使用 HttpUtils 类")]),s._v(" "),a("p",[s._v("类"),a("code",[s._v("HttpUtils")]),s._v("本是 "),a("a",{attrs:{href:"https://gitee.com/ejlchina-zhxu/httputils",target:"_blank",rel:"noopener noreferrer"}},[s._v("前身 HttpUtils"),a("OutboundLink")],1),s._v(" 的 1.x 版本里的最重要的核心类，由于在后来的版本里抽象出了"),a("code",[s._v("HTTP")]),s._v("接口，使得它的重要性已不如往昔。但合理的使用它，仍然可以带来不少便利，特别是在没有IOC容器的环境里，比如在Android开发和一些工具项目的开发中。")]),s._v(" "),a("p",[s._v("类"),a("code",[s._v("HttpUtils")]),s._v("共定义了四个静态方法：")]),s._v(" "),a("ul",[a("li",[a("code",[s._v("of(HTTP http)")]),s._v(" 配置"),a("code",[s._v("HttpUtils")]),s._v("持有的"),a("code",[s._v("HTTP")]),s._v("实例（不调用此方法前默认使用一个没有没有经过任何配置的"),a("code",[s._v("HTTP")]),s._v("懒实例）")]),s._v(" "),a("li",[a("code",[s._v("sync(String url)")]),s._v(" 开始一个同步请求 （内部通过一个"),a("code",[s._v("HTTP")]),s._v("单例实现）")]),s._v(" "),a("li",[a("code",[s._v("async(String url)")]),s._v(" 开始一个异步请求 （内部通过一个"),a("code",[s._v("HTTP")]),s._v("单例实现）")]),s._v(" "),a("li",[a("code",[s._v("cancel(String tag)")]),s._v(" 按标签取消请求（内部通过一个"),a("code",[s._v("HTTP")]),s._v("单例实现）")]),s._v(" "),a("li",[a("code",[s._v("cancelAll()")]),s._v(" 取消所有HTTP任务，包括同步和异步（内部通过一个"),a("code",[s._v("HTTP")]),s._v("单例实现）")]),s._v(" "),a("li",[a("code",[s._v("request(Request request)")]),s._v(" OkHttp 原生请求 （该请求不经过 预处理器）")]),s._v(" "),a("li",[a("code",[s._v("webSocket(Request request, WebSocketListener listener)")]),s._v(" WebSocket通讯\n　　也就是说，能使用"),a("code",[s._v("http")]),s._v("实例的地方，都可以使用"),a("code",[s._v("HttpUtils")]),s._v("类，例如：")])]),s._v(" "),a("div",{staticClass:"language-java line-numbers-mode"},[a("pre",{pre:!0,attrs:{class:"language-java"}},[a("code",[a("span",{pre:!0,attrs:{class:"token comment"}},[s._v("// 在配置HTTP实例之前，只能使用全路径方式")]),s._v("\n"),a("span",{pre:!0,attrs:{class:"token class-name"}},[s._v("List")]),a("span",{pre:!0,attrs:{class:"token generics"}},[a("span",{pre:!0,attrs:{class:"token punctuation"}},[s._v("<")]),a("span",{pre:!0,attrs:{class:"token class-name"}},[s._v("Role")]),a("span",{pre:!0,attrs:{class:"token punctuation"}},[s._v(">")])]),s._v(" roles "),a("span",{pre:!0,attrs:{class:"token operator"}},[s._v("=")]),s._v(" "),a("span",{pre:!0,attrs:{class:"token class-name"}},[s._v("HttpUtils")]),a("span",{pre:!0,attrs:{class:"token punctuation"}},[s._v(".")]),a("span",{pre:!0,attrs:{class:"token function"}},[s._v("sync")]),a("span",{pre:!0,attrs:{class:"token punctuation"}},[s._v("(")]),a("span",{pre:!0,attrs:{class:"token string"}},[s._v('"http://api.demo.com/roles"')]),a("span",{pre:!0,attrs:{class:"token punctuation"}},[s._v(")")]),s._v("\n "),a("span",{pre:!0,attrs:{class:"token punctuation"}},[s._v(".")]),a("span",{pre:!0,attrs:{class:"token function"}},[s._v("get")]),a("span",{pre:!0,attrs:{class:"token punctuation"}},[s._v("(")]),a("span",{pre:!0,attrs:{class:"token punctuation"}},[s._v(")")]),a("span",{pre:!0,attrs:{class:"token punctuation"}},[s._v(".")]),a("span",{pre:!0,attrs:{class:"token function"}},[s._v("getBody")]),a("span",{pre:!0,attrs:{class:"token punctuation"}},[s._v("(")]),a("span",{pre:!0,attrs:{class:"token punctuation"}},[s._v(")")]),a("span",{pre:!0,attrs:{class:"token punctuation"}},[s._v(".")]),a("span",{pre:!0,attrs:{class:"token function"}},[s._v("toList")]),a("span",{pre:!0,attrs:{class:"token punctuation"}},[s._v("(")]),a("span",{pre:!0,attrs:{class:"token class-name"}},[s._v("Role")]),a("span",{pre:!0,attrs:{class:"token punctuation"}},[s._v(".")]),a("span",{pre:!0,attrs:{class:"token keyword"}},[s._v("class")]),a("span",{pre:!0,attrs:{class:"token punctuation"}},[s._v(")")]),a("span",{pre:!0,attrs:{class:"token punctuation"}},[s._v(";")]),s._v("\n\n"),a("span",{pre:!0,attrs:{class:"token comment"}},[s._v("// 配置HTTP实例,全局生效")]),s._v("\n"),a("span",{pre:!0,attrs:{class:"token class-name"}},[s._v("HttpUtils")]),a("span",{pre:!0,attrs:{class:"token punctuation"}},[s._v(".")]),a("span",{pre:!0,attrs:{class:"token function"}},[s._v("of")]),a("span",{pre:!0,attrs:{class:"token punctuation"}},[s._v("(")]),s._v("HTTP"),a("span",{pre:!0,attrs:{class:"token punctuation"}},[s._v(".")]),a("span",{pre:!0,attrs:{class:"token function"}},[s._v("builder")]),a("span",{pre:!0,attrs:{class:"token punctuation"}},[s._v("(")]),a("span",{pre:!0,attrs:{class:"token punctuation"}},[s._v(")")]),s._v("\n "),a("span",{pre:!0,attrs:{class:"token punctuation"}},[s._v(".")]),a("span",{pre:!0,attrs:{class:"token function"}},[s._v("baseUrl")]),a("span",{pre:!0,attrs:{class:"token punctuation"}},[s._v("(")]),a("span",{pre:!0,attrs:{class:"token string"}},[s._v('"http://api.demo.com"')]),a("span",{pre:!0,attrs:{class:"token punctuation"}},[s._v(")")]),s._v("\n "),a("span",{pre:!0,attrs:{class:"token punctuation"}},[s._v(".")]),a("span",{pre:!0,attrs:{class:"token function"}},[s._v("build")]),a("span",{pre:!0,attrs:{class:"token punctuation"}},[s._v("(")]),a("span",{pre:!0,attrs:{class:"token punctuation"}},[s._v(")")]),a("span",{pre:!0,attrs:{class:"token punctuation"}},[s._v(")")]),a("span",{pre:!0,attrs:{class:"token punctuation"}},[s._v(";")]),s._v("\n\n"),a("span",{pre:!0,attrs:{class:"token comment"}},[s._v("// 内部使用新的HTTP实例")]),s._v("\n"),a("span",{pre:!0,attrs:{class:"token class-name"}},[s._v("List")]),a("span",{pre:!0,attrs:{class:"token generics"}},[a("span",{pre:!0,attrs:{class:"token punctuation"}},[s._v("<")]),a("span",{pre:!0,attrs:{class:"token class-name"}},[s._v("User")]),a("span",{pre:!0,attrs:{class:"token punctuation"}},[s._v(">")])]),s._v(" users "),a("span",{pre:!0,attrs:{class:"token operator"}},[s._v("=")]),s._v(" "),a("span",{pre:!0,attrs:{class:"token class-name"}},[s._v("HttpUtils")]),a("span",{pre:!0,attrs:{class:"token punctuation"}},[s._v(".")]),a("span",{pre:!0,attrs:{class:"token function"}},[s._v("sync")]),a("span",{pre:!0,attrs:{class:"token punctuation"}},[s._v("(")]),a("span",{pre:!0,attrs:{class:"token string"}},[s._v('"/users"')]),a("span",{pre:!0,attrs:{class:"token punctuation"}},[s._v(")")]),s._v("\n "),a("span",{pre:!0,attrs:{class:"token punctuation"}},[s._v(".")]),a("span",{pre:!0,attrs:{class:"token function"}},[s._v("get")]),a("span",{pre:!0,attrs:{class:"token punctuation"}},[s._v("(")]),a("span",{pre:!0,attrs:{class:"token punctuation"}},[s._v(")")]),a("span",{pre:!0,attrs:{class:"token punctuation"}},[s._v(".")]),a("span",{pre:!0,attrs:{class:"token function"}},[s._v("getBody")]),a("span",{pre:!0,attrs:{class:"token punctuation"}},[s._v("(")]),a("span",{pre:!0,attrs:{class:"token punctuation"}},[s._v(")")]),a("span",{pre:!0,attrs:{class:"token punctuation"}},[s._v(".")]),a("span",{pre:!0,attrs:{class:"token function"}},[s._v("toList")]),a("span",{pre:!0,attrs:{class:"token punctuation"}},[s._v("(")]),a("span",{pre:!0,attrs:{class:"token class-name"}},[s._v("User")]),a("span",{pre:!0,attrs:{class:"token punctuation"}},[s._v(".")]),a("span",{pre:!0,attrs:{class:"token keyword"}},[s._v("class")]),a("span",{pre:!0,attrs:{class:"token punctuation"}},[s._v(")")]),a("span",{pre:!0,attrs:{class:"token punctuation"}},[s._v(";")]),s._v("\n")])]),s._v(" "),a("div",{staticClass:"line-numbers-wrapper"},[a("span",{staticClass:"line-number"},[s._v("1")]),a("br"),a("span",{staticClass:"line-number"},[s._v("2")]),a("br"),a("span",{staticClass:"line-number"},[s._v("3")]),a("br"),a("span",{staticClass:"line-number"},[s._v("4")]),a("br"),a("span",{staticClass:"line-number"},[s._v("5")]),a("br"),a("span",{staticClass:"line-number"},[s._v("6")]),a("br"),a("span",{staticClass:"line-number"},[s._v("7")]),a("br"),a("span",{staticClass:"line-number"},[s._v("8")]),a("br"),a("span",{staticClass:"line-number"},[s._v("9")]),a("br"),a("span",{staticClass:"line-number"},[s._v("10")]),a("br"),a("span",{staticClass:"line-number"},[s._v("11")]),a("br"),a("span",{staticClass:"line-number"},[s._v("12")]),a("br")])]),a("h2",{attrs:{id:"异常处理"}},[a("a",{staticClass:"header-anchor",attrs:{href:"#异常处理"}},[s._v("#")]),s._v(" 异常处理")]),s._v(" "),a("p",[s._v("使用 OkHttps 时，"),a("strong",[s._v("异常处理不是必须的")]),s._v("，但相比其它的 HTTP 开发包，它还提供一个特别的处理方法："),a("code",[s._v("nothrow()")]),s._v("，以满足不同的异常处理需求。")]),s._v(" "),a("h3",{attrs:{id:"同步请求的异常"}},[a("a",{staticClass:"header-anchor",attrs:{href:"#同步请求的异常"}},[s._v("#")]),s._v(" 同步请求的异常")]),s._v(" "),a("p",[s._v("默认情况下，当同步请求执行异常时，会直接向外抛出，我们可以用 "),a("code",[s._v("try catch")]),s._v(" 来捕获，例如：")]),s._v(" "),a("div",{staticClass:"language-java line-numbers-mode"},[a("pre",{pre:!0,attrs:{class:"language-java"}},[a("code",[a("span",{pre:!0,attrs:{class:"token keyword"}},[s._v("try")]),s._v(" "),a("span",{pre:!0,attrs:{class:"token punctuation"}},[s._v("{")]),s._v("\n "),a("span",{pre:!0,attrs:{class:"token class-name"}},[s._v("HttpResult")]),s._v(" result "),a("span",{pre:!0,attrs:{class:"token operator"}},[s._v("=")]),s._v(" http"),a("span",{pre:!0,attrs:{class:"token punctuation"}},[s._v(".")]),a("span",{pre:!0,attrs:{class:"token function"}},[s._v("sync")]),a("span",{pre:!0,attrs:{class:"token punctuation"}},[s._v("(")]),a("span",{pre:!0,attrs:{class:"token string"}},[s._v('"/users/1"')]),a("span",{pre:!0,attrs:{class:"token punctuation"}},[s._v(")")]),a("span",{pre:!0,attrs:{class:"token punctuation"}},[s._v(".")]),a("span",{pre:!0,attrs:{class:"token function"}},[s._v("get")]),a("span",{pre:!0,attrs:{class:"token punctuation"}},[s._v("(")]),a("span",{pre:!0,attrs:{class:"token punctuation"}},[s._v(")")]),a("span",{pre:!0,attrs:{class:"token punctuation"}},[s._v(";")]),s._v("\n"),a("span",{pre:!0,attrs:{class:"token punctuation"}},[s._v("}")]),s._v(" "),a("span",{pre:!0,attrs:{class:"token keyword"}},[s._v("catch")]),s._v(" "),a("span",{pre:!0,attrs:{class:"token punctuation"}},[s._v("(")]),a("span",{pre:!0,attrs:{class:"token class-name"}},[s._v("HttpException")]),s._v(" e"),a("span",{pre:!0,attrs:{class:"token punctuation"}},[s._v(")")]),s._v(" "),a("span",{pre:!0,attrs:{class:"token punctuation"}},[s._v("{")]),s._v("\n "),a("span",{pre:!0,attrs:{class:"token class-name"}},[s._v("Throwable")]),s._v(" cause "),a("span",{pre:!0,attrs:{class:"token operator"}},[s._v("=")]),s._v(" e"),a("span",{pre:!0,attrs:{class:"token punctuation"}},[s._v(".")]),a("span",{pre:!0,attrs:{class:"token function"}},[s._v("getCause")]),a("span",{pre:!0,attrs:{class:"token punctuation"}},[s._v("(")]),a("span",{pre:!0,attrs:{class:"token punctuation"}},[s._v(")")]),a("span",{pre:!0,attrs:{class:"token punctuation"}},[s._v(";")]),s._v(" "),a("span",{pre:!0,attrs:{class:"token comment"}},[s._v("// 得到异常原因")]),s._v("\n "),a("span",{pre:!0,attrs:{class:"token keyword"}},[s._v("if")]),s._v(" "),a("span",{pre:!0,attrs:{class:"token punctuation"}},[s._v("(")]),s._v("cause "),a("span",{pre:!0,attrs:{class:"token keyword"}},[s._v("instanceof")]),s._v(" "),a("span",{pre:!0,attrs:{class:"token class-name"}},[s._v("ConnectException")]),a("span",{pre:!0,attrs:{class:"token punctuation"}},[s._v(")")]),s._v(" "),a("span",{pre:!0,attrs:{class:"token punctuation"}},[s._v("{")]),s._v("\n "),a("span",{pre:!0,attrs:{class:"token comment"}},[s._v("// 当没网络时，会抛出连接异常")]),s._v("\n "),a("span",{pre:!0,attrs:{class:"token punctuation"}},[s._v("}")]),s._v("\n "),a("span",{pre:!0,attrs:{class:"token keyword"}},[s._v("if")]),s._v(" "),a("span",{pre:!0,attrs:{class:"token punctuation"}},[s._v("(")]),s._v("cause "),a("span",{pre:!0,attrs:{class:"token keyword"}},[s._v("instanceof")]),s._v(" "),a("span",{pre:!0,attrs:{class:"token class-name"}},[s._v("SocketTimeoutException")]),a("span",{pre:!0,attrs:{class:"token punctuation"}},[s._v(")")]),s._v(" "),a("span",{pre:!0,attrs:{class:"token punctuation"}},[s._v("{")]),s._v("\n "),a("span",{pre:!0,attrs:{class:"token comment"}},[s._v("// 当接口长时间未响应，会抛出超时异常")]),s._v("\n "),a("span",{pre:!0,attrs:{class:"token punctuation"}},[s._v("}")]),s._v("\n "),a("span",{pre:!0,attrs:{class:"token keyword"}},[s._v("if")]),s._v(" "),a("span",{pre:!0,attrs:{class:"token punctuation"}},[s._v("(")]),s._v("cause "),a("span",{pre:!0,attrs:{class:"token keyword"}},[s._v("instanceof")]),s._v(" "),a("span",{pre:!0,attrs:{class:"token class-name"}},[s._v("UnknownHostException")]),a("span",{pre:!0,attrs:{class:"token punctuation"}},[s._v(")")]),s._v(" "),a("span",{pre:!0,attrs:{class:"token punctuation"}},[s._v("{")]),s._v("\n "),a("span",{pre:!0,attrs:{class:"token comment"}},[s._v("// 当把域名或IP写错，会抛出 UnknownHost 异常")]),s._v("\n "),a("span",{pre:!0,attrs:{class:"token punctuation"}},[s._v("}")]),s._v("\n "),a("span",{pre:!0,attrs:{class:"token comment"}},[s._v("// ...")]),s._v("\n"),a("span",{pre:!0,attrs:{class:"token punctuation"}},[s._v("}")]),s._v("\n")])]),s._v(" "),a("div",{staticClass:"line-numbers-wrapper"},[a("span",{staticClass:"line-number"},[s._v("1")]),a("br"),a("span",{staticClass:"line-number"},[s._v("2")]),a("br"),a("span",{staticClass:"line-number"},[s._v("3")]),a("br"),a("span",{staticClass:"line-number"},[s._v("4")]),a("br"),a("span",{staticClass:"line-number"},[s._v("5")]),a("br"),a("span",{staticClass:"line-number"},[s._v("6")]),a("br"),a("span",{staticClass:"line-number"},[s._v("7")]),a("br"),a("span",{staticClass:"line-number"},[s._v("8")]),a("br"),a("span",{staticClass:"line-number"},[s._v("9")]),a("br"),a("span",{staticClass:"line-number"},[s._v("10")]),a("br"),a("span",{staticClass:"line-number"},[s._v("11")]),a("br"),a("span",{staticClass:"line-number"},[s._v("12")]),a("br"),a("span",{staticClass:"line-number"},[s._v("13")]),a("br"),a("span",{staticClass:"line-number"},[s._v("14")]),a("br"),a("span",{staticClass:"line-number"},[s._v("15")]),a("br")])]),a("p",[s._v("这种传统的异常处理方式，当然可以解决问题，但 OkHttps 有更佳的方案：")]),s._v(" "),a("div",{staticClass:"language-java line-numbers-mode"},[a("pre",{pre:!0,attrs:{class:"language-java"}},[a("code",[a("span",{pre:!0,attrs:{class:"token comment"}},[s._v("// 方法 nothrow() 让异常不直接抛出")]),s._v("\n"),a("span",{pre:!0,attrs:{class:"token class-name"}},[s._v("HttpResult")]),s._v(" result "),a("span",{pre:!0,attrs:{class:"token operator"}},[s._v("=")]),s._v(" http"),a("span",{pre:!0,attrs:{class:"token punctuation"}},[s._v(".")]),a("span",{pre:!0,attrs:{class:"token function"}},[s._v("sync")]),a("span",{pre:!0,attrs:{class:"token punctuation"}},[s._v("(")]),a("span",{pre:!0,attrs:{class:"token string"}},[s._v('"/users/1"')]),a("span",{pre:!0,attrs:{class:"token punctuation"}},[s._v(")")]),a("span",{pre:!0,attrs:{class:"token punctuation"}},[s._v(".")]),a("span",{pre:!0,attrs:{class:"token function"}},[s._v("nothrow")]),a("span",{pre:!0,attrs:{class:"token punctuation"}},[s._v("(")]),a("span",{pre:!0,attrs:{class:"token punctuation"}},[s._v(")")]),a("span",{pre:!0,attrs:{class:"token punctuation"}},[s._v(".")]),a("span",{pre:!0,attrs:{class:"token function"}},[s._v("get")]),a("span",{pre:!0,attrs:{class:"token punctuation"}},[s._v("(")]),a("span",{pre:!0,attrs:{class:"token punctuation"}},[s._v(")")]),a("span",{pre:!0,attrs:{class:"token punctuation"}},[s._v(";")]),s._v("\n"),a("span",{pre:!0,attrs:{class:"token comment"}},[s._v("// 判断执行状态")]),s._v("\n"),a("span",{pre:!0,attrs:{class:"token keyword"}},[s._v("switch")]),s._v(" "),a("span",{pre:!0,attrs:{class:"token punctuation"}},[s._v("(")]),s._v("result"),a("span",{pre:!0,attrs:{class:"token punctuation"}},[s._v(".")]),a("span",{pre:!0,attrs:{class:"token function"}},[s._v("getState")]),a("span",{pre:!0,attrs:{class:"token punctuation"}},[s._v("(")]),a("span",{pre:!0,attrs:{class:"token punctuation"}},[s._v(")")]),a("span",{pre:!0,attrs:{class:"token punctuation"}},[s._v(")")]),s._v(" "),a("span",{pre:!0,attrs:{class:"token punctuation"}},[s._v("{")]),s._v("\n "),a("span",{pre:!0,attrs:{class:"token keyword"}},[s._v("case")]),s._v(" RESPONSED"),a("span",{pre:!0,attrs:{class:"token operator"}},[s._v(":")]),s._v(" "),a("span",{pre:!0,attrs:{class:"token comment"}},[s._v("// 请求已正常响应")]),s._v("\n "),a("span",{pre:!0,attrs:{class:"token keyword"}},[s._v("break")]),a("span",{pre:!0,attrs:{class:"token punctuation"}},[s._v(";")]),s._v("\n "),a("span",{pre:!0,attrs:{class:"token keyword"}},[s._v("case")]),s._v(" CANCELED"),a("span",{pre:!0,attrs:{class:"token operator"}},[s._v(":")]),s._v(" "),a("span",{pre:!0,attrs:{class:"token comment"}},[s._v("// 请求已被取消")]),s._v("\n "),a("span",{pre:!0,attrs:{class:"token keyword"}},[s._v("break")]),a("span",{pre:!0,attrs:{class:"token punctuation"}},[s._v(";")]),s._v("\n "),a("span",{pre:!0,attrs:{class:"token keyword"}},[s._v("case")]),s._v(" NETWORK_ERROR"),a("span",{pre:!0,attrs:{class:"token operator"}},[s._v(":")]),s._v(" "),a("span",{pre:!0,attrs:{class:"token comment"}},[s._v("// 网络错误，说明用户没网了")]),s._v("\n "),a("span",{pre:!0,attrs:{class:"token keyword"}},[s._v("break")]),a("span",{pre:!0,attrs:{class:"token punctuation"}},[s._v(";")]),s._v("\n "),a("span",{pre:!0,attrs:{class:"token keyword"}},[s._v("case")]),s._v(" TIMEOUT"),a("span",{pre:!0,attrs:{class:"token operator"}},[s._v(":")]),s._v(" "),a("span",{pre:!0,attrs:{class:"token comment"}},[s._v("// 请求超时")]),s._v("\n "),a("span",{pre:!0,attrs:{class:"token keyword"}},[s._v("break")]),a("span",{pre:!0,attrs:{class:"token punctuation"}},[s._v(";")]),s._v("\n "),a("span",{pre:!0,attrs:{class:"token keyword"}},[s._v("case")]),s._v(" EXCEPTION"),a("span",{pre:!0,attrs:{class:"token operator"}},[s._v(":")]),s._v(" "),a("span",{pre:!0,attrs:{class:"token comment"}},[s._v("// 其它异常")]),s._v("\n "),a("span",{pre:!0,attrs:{class:"token keyword"}},[s._v("break")]),a("span",{pre:!0,attrs:{class:"token punctuation"}},[s._v(";")]),s._v("\n"),a("span",{pre:!0,attrs:{class:"token punctuation"}},[s._v("}")]),s._v("\n"),a("span",{pre:!0,attrs:{class:"token comment"}},[s._v("// 还可以获得具体的异常信息")]),s._v("\n"),a("span",{pre:!0,attrs:{class:"token class-name"}},[s._v("IOException")]),s._v(" error "),a("span",{pre:!0,attrs:{class:"token operator"}},[s._v("=")]),s._v(" result"),a("span",{pre:!0,attrs:{class:"token punctuation"}},[s._v(".")]),a("span",{pre:!0,attrs:{class:"token function"}},[s._v("getError")]),a("span",{pre:!0,attrs:{class:"token punctuation"}},[s._v("(")]),a("span",{pre:!0,attrs:{class:"token punctuation"}},[s._v(")")]),a("span",{pre:!0,attrs:{class:"token punctuation"}},[s._v(";")]),s._v("\n")])]),s._v(" "),a("div",{staticClass:"line-numbers-wrapper"},[a("span",{staticClass:"line-number"},[s._v("1")]),a("br"),a("span",{staticClass:"line-number"},[s._v("2")]),a("br"),a("span",{staticClass:"line-number"},[s._v("3")]),a("br"),a("span",{staticClass:"line-number"},[s._v("4")]),a("br"),a("span",{staticClass:"line-number"},[s._v("5")]),a("br"),a("span",{staticClass:"line-number"},[s._v("6")]),a("br"),a("span",{staticClass:"line-number"},[s._v("7")]),a("br"),a("span",{staticClass:"line-number"},[s._v("8")]),a("br"),a("span",{staticClass:"line-number"},[s._v("9")]),a("br"),a("span",{staticClass:"line-number"},[s._v("10")]),a("br"),a("span",{staticClass:"line-number"},[s._v("11")]),a("br"),a("span",{staticClass:"line-number"},[s._v("12")]),a("br"),a("span",{staticClass:"line-number"},[s._v("13")]),a("br"),a("span",{staticClass:"line-number"},[s._v("14")]),a("br"),a("span",{staticClass:"line-number"},[s._v("15")]),a("br"),a("span",{staticClass:"line-number"},[s._v("16")]),a("br"),a("span",{staticClass:"line-number"},[s._v("17")]),a("br")])]),a("h3",{attrs:{id:"异步请求的异常"}},[a("a",{staticClass:"header-anchor",attrs:{href:"#异步请求的异常"}},[s._v("#")]),s._v(" 异步请求的异常")]),s._v(" "),a("p",[s._v("异步请求最常用的异常处理方式就是设置一个异常回调：")]),s._v(" "),a("div",{staticClass:"language-java line-numbers-mode"},[a("pre",{pre:!0,attrs:{class:"language-java"}},[a("code",[s._v("http"),a("span",{pre:!0,attrs:{class:"token punctuation"}},[s._v(".")]),a("span",{pre:!0,attrs:{class:"token function"}},[s._v("async")]),a("span",{pre:!0,attrs:{class:"token punctuation"}},[s._v("(")]),a("span",{pre:!0,attrs:{class:"token string"}},[s._v('"/users/1"')]),a("span",{pre:!0,attrs:{class:"token punctuation"}},[s._v(")")]),s._v("\n "),a("span",{pre:!0,attrs:{class:"token punctuation"}},[s._v(".")]),a("span",{pre:!0,attrs:{class:"token function"}},[s._v("setOnResponse")]),a("span",{pre:!0,attrs:{class:"token punctuation"}},[s._v("(")]),a("span",{pre:!0,attrs:{class:"token punctuation"}},[s._v("(")]),a("span",{pre:!0,attrs:{class:"token class-name"}},[s._v("HttpResult")]),s._v(" result"),a("span",{pre:!0,attrs:{class:"token punctuation"}},[s._v(")")]),s._v(" "),a("span",{pre:!0,attrs:{class:"token operator"}},[s._v("->")]),s._v(" "),a("span",{pre:!0,attrs:{class:"token punctuation"}},[s._v("{")]),s._v("\n "),a("span",{pre:!0,attrs:{class:"token comment"}},[s._v("// 当发生异常时就不会走这里")]),s._v("\n "),a("span",{pre:!0,attrs:{class:"token punctuation"}},[s._v("}")]),a("span",{pre:!0,attrs:{class:"token punctuation"}},[s._v(")")]),s._v("\n "),a("span",{pre:!0,attrs:{class:"token punctuation"}},[s._v(".")]),a("span",{pre:!0,attrs:{class:"token function"}},[s._v("setOnException")]),a("span",{pre:!0,attrs:{class:"token punctuation"}},[s._v("(")]),a("span",{pre:!0,attrs:{class:"token punctuation"}},[s._v("(")]),a("span",{pre:!0,attrs:{class:"token class-name"}},[s._v("IOException")]),s._v(" e"),a("span",{pre:!0,attrs:{class:"token punctuation"}},[s._v(")")]),s._v(" "),a("span",{pre:!0,attrs:{class:"token operator"}},[s._v("->")]),s._v(" "),a("span",{pre:!0,attrs:{class:"token punctuation"}},[s._v("{")]),s._v("\n "),a("span",{pre:!0,attrs:{class:"token comment"}},[s._v("// 这里处理请求异常")]),s._v("\n "),a("span",{pre:!0,attrs:{class:"token punctuation"}},[s._v("}")]),a("span",{pre:!0,attrs:{class:"token punctuation"}},[s._v(")")]),s._v("\n "),a("span",{pre:!0,attrs:{class:"token punctuation"}},[s._v(".")]),a("span",{pre:!0,attrs:{class:"token function"}},[s._v("get")]),a("span",{pre:!0,attrs:{class:"token punctuation"}},[s._v("(")]),a("span",{pre:!0,attrs:{class:"token punctuation"}},[s._v(")")]),a("span",{pre:!0,attrs:{class:"token punctuation"}},[s._v(";")]),s._v("\n")])]),s._v(" "),a("div",{staticClass:"line-numbers-wrapper"},[a("span",{staticClass:"line-number"},[s._v("1")]),a("br"),a("span",{staticClass:"line-number"},[s._v("2")]),a("br"),a("span",{staticClass:"line-number"},[s._v("3")]),a("br"),a("span",{staticClass:"line-number"},[s._v("4")]),a("br"),a("span",{staticClass:"line-number"},[s._v("5")]),a("br"),a("span",{staticClass:"line-number"},[s._v("6")]),a("br"),a("span",{staticClass:"line-number"},[s._v("7")]),a("br"),a("span",{staticClass:"line-number"},[s._v("8")]),a("br")])]),a("p",[s._v("当然，还有一个全局异常监听（"),a("code",[s._v("ExceptionListener")]),s._v("）：")]),s._v(" "),a("div",{staticClass:"language-java line-numbers-mode"},[a("pre",{pre:!0,attrs:{class:"language-java"}},[a("code",[a("span",{pre:!0,attrs:{class:"token class-name"}},[s._v("HTTP")]),s._v(" http "),a("span",{pre:!0,attrs:{class:"token operator"}},[s._v("=")]),s._v(" HTTP"),a("span",{pre:!0,attrs:{class:"token punctuation"}},[s._v(".")]),a("span",{pre:!0,attrs:{class:"token function"}},[s._v("builder")]),a("span",{pre:!0,attrs:{class:"token punctuation"}},[s._v("(")]),a("span",{pre:!0,attrs:{class:"token punctuation"}},[s._v(")")]),s._v("\n "),a("span",{pre:!0,attrs:{class:"token punctuation"}},[s._v(".")]),a("span",{pre:!0,attrs:{class:"token function"}},[s._v("exceptionListener")]),a("span",{pre:!0,attrs:{class:"token punctuation"}},[s._v("(")]),a("span",{pre:!0,attrs:{class:"token punctuation"}},[s._v("(")]),a("span",{pre:!0,attrs:{class:"token class-name"}},[s._v("HttpTask")]),a("span",{pre:!0,attrs:{class:"token generics"}},[a("span",{pre:!0,attrs:{class:"token punctuation"}},[s._v("<")]),a("span",{pre:!0,attrs:{class:"token operator"}},[s._v("?")]),a("span",{pre:!0,attrs:{class:"token punctuation"}},[s._v(">")])]),s._v(" task"),a("span",{pre:!0,attrs:{class:"token punctuation"}},[s._v(",")]),s._v(" "),a("span",{pre:!0,attrs:{class:"token class-name"}},[s._v("IOException")]),s._v(" error"),a("span",{pre:!0,attrs:{class:"token punctuation"}},[s._v(")")]),s._v(" "),a("span",{pre:!0,attrs:{class:"token operator"}},[s._v("->")]),s._v(" "),a("span",{pre:!0,attrs:{class:"token punctuation"}},[s._v("{")]),s._v("\n "),a("span",{pre:!0,attrs:{class:"token comment"}},[s._v("// 所有请求发生异常都会走这里")]),s._v("\n\n "),a("span",{pre:!0,attrs:{class:"token keyword"}},[s._v("return")]),s._v(" "),a("span",{pre:!0,attrs:{class:"token boolean"}},[s._v("true")]),a("span",{pre:!0,attrs:{class:"token punctuation"}},[s._v(";")]),s._v(" "),a("span",{pre:!0,attrs:{class:"token comment"}},[s._v("// 返回 true 表示继续执行 task 的 OnException 回调，false 表示不再执行")]),s._v("\n "),a("span",{pre:!0,attrs:{class:"token punctuation"}},[s._v("}")]),a("span",{pre:!0,attrs:{class:"token punctuation"}},[s._v(")")]),s._v("\n "),a("span",{pre:!0,attrs:{class:"token punctuation"}},[s._v(".")]),a("span",{pre:!0,attrs:{class:"token function"}},[s._v("build")]),a("span",{pre:!0,attrs:{class:"token punctuation"}},[s._v("(")]),a("span",{pre:!0,attrs:{class:"token punctuation"}},[s._v(")")]),a("span",{pre:!0,attrs:{class:"token punctuation"}},[s._v(";")]),s._v("\n")])]),s._v(" "),a("div",{staticClass:"line-numbers-wrapper"},[a("span",{staticClass:"line-number"},[s._v("1")]),a("br"),a("span",{staticClass:"line-number"},[s._v("2")]),a("br"),a("span",{staticClass:"line-number"},[s._v("3")]),a("br"),a("span",{staticClass:"line-number"},[s._v("4")]),a("br"),a("span",{staticClass:"line-number"},[s._v("5")]),a("br"),a("span",{staticClass:"line-number"},[s._v("6")]),a("br"),a("span",{staticClass:"line-number"},[s._v("7")]),a("br")])]),a("p",[s._v("如果不设置"),a("code",[s._v("OnException")]),s._v("回调，也没有"),a("code",[s._v("ExceptionListener")]),s._v("，发生异常时会在 "),a("strong",[s._v("IO 线程")]),s._v(" 中向上抛出，外层无法捕获：")]),s._v(" "),a("div",{staticClass:"language-java line-numbers-mode"},[a("pre",{pre:!0,attrs:{class:"language-java"}},[a("code",[a("span",{pre:!0,attrs:{class:"token keyword"}},[s._v("try")]),s._v(" "),a("span",{pre:!0,attrs:{class:"token punctuation"}},[s._v("{")]),s._v("\n http"),a("span",{pre:!0,attrs:{class:"token punctuation"}},[s._v(".")]),a("span",{pre:!0,attrs:{class:"token function"}},[s._v("async")]),a("span",{pre:!0,attrs:{class:"token punctuation"}},[s._v("(")]),a("span",{pre:!0,attrs:{class:"token string"}},[s._v('"/users/1"')]),a("span",{pre:!0,attrs:{class:"token punctuation"}},[s._v(")")]),s._v("\n "),a("span",{pre:!0,attrs:{class:"token punctuation"}},[s._v(".")]),a("span",{pre:!0,attrs:{class:"token function"}},[s._v("setOnResponse")]),a("span",{pre:!0,attrs:{class:"token punctuation"}},[s._v("(")]),a("span",{pre:!0,attrs:{class:"token punctuation"}},[s._v("(")]),a("span",{pre:!0,attrs:{class:"token class-name"}},[s._v("HttpResult")]),s._v(" result"),a("span",{pre:!0,attrs:{class:"token punctuation"}},[s._v(")")]),s._v(" "),a("span",{pre:!0,attrs:{class:"token operator"}},[s._v("->")]),s._v(" "),a("span",{pre:!0,attrs:{class:"token punctuation"}},[s._v("{")]),s._v("\n "),a("span",{pre:!0,attrs:{class:"token comment"}},[s._v("// 当发生异常时就不会走这里")]),s._v("\n "),a("span",{pre:!0,attrs:{class:"token punctuation"}},[s._v("}")]),a("span",{pre:!0,attrs:{class:"token punctuation"}},[s._v(")")]),s._v("\n "),a("span",{pre:!0,attrs:{class:"token punctuation"}},[s._v(".")]),a("span",{pre:!0,attrs:{class:"token function"}},[s._v("get")]),a("span",{pre:!0,attrs:{class:"token punctuation"}},[s._v("(")]),a("span",{pre:!0,attrs:{class:"token punctuation"}},[s._v(")")]),a("span",{pre:!0,attrs:{class:"token punctuation"}},[s._v(";")]),s._v("\n"),a("span",{pre:!0,attrs:{class:"token punctuation"}},[s._v("}")]),s._v(" "),a("span",{pre:!0,attrs:{class:"token keyword"}},[s._v("catch")]),s._v(" "),a("span",{pre:!0,attrs:{class:"token punctuation"}},[s._v("(")]),a("span",{pre:!0,attrs:{class:"token class-name"}},[s._v("HttpException")]),s._v(" e"),a("span",{pre:!0,attrs:{class:"token punctuation"}},[s._v(")")]),s._v(" "),a("span",{pre:!0,attrs:{class:"token punctuation"}},[s._v("{")]),s._v("\n "),a("span",{pre:!0,attrs:{class:"token comment"}},[s._v("// 这种方式是捕获不到异常的！！！！！！")]),s._v("\n"),a("span",{pre:!0,attrs:{class:"token punctuation"}},[s._v("}")]),s._v("\n")])]),s._v(" "),a("div",{staticClass:"line-numbers-wrapper"},[a("span",{staticClass:"line-number"},[s._v("1")]),a("br"),a("span",{staticClass:"line-number"},[s._v("2")]),a("br"),a("span",{staticClass:"line-number"},[s._v("3")]),a("br"),a("span",{staticClass:"line-number"},[s._v("4")]),a("br"),a("span",{staticClass:"line-number"},[s._v("5")]),a("br"),a("span",{staticClass:"line-number"},[s._v("6")]),a("br"),a("span",{staticClass:"line-number"},[s._v("7")]),a("br"),a("span",{staticClass:"line-number"},[s._v("8")]),a("br"),a("span",{staticClass:"line-number"},[s._v("9")]),a("br")])]),a("p",[s._v("即使没有"),a("code",[s._v("OnException")]),s._v("回调，发生异常时，依然会走"),a("code",[s._v("OnComplete")]),s._v("回调，如果设置了的话：")]),s._v(" "),a("div",{staticClass:"language-java line-numbers-mode"},[a("pre",{pre:!0,attrs:{class:"language-java"}},[a("code",[s._v("http"),a("span",{pre:!0,attrs:{class:"token punctuation"}},[s._v(".")]),a("span",{pre:!0,attrs:{class:"token function"}},[s._v("async")]),a("span",{pre:!0,attrs:{class:"token punctuation"}},[s._v("(")]),a("span",{pre:!0,attrs:{class:"token string"}},[s._v('"/users/1"')]),a("span",{pre:!0,attrs:{class:"token punctuation"}},[s._v(")")]),s._v("\n "),a("span",{pre:!0,attrs:{class:"token punctuation"}},[s._v(".")]),a("span",{pre:!0,attrs:{class:"token function"}},[s._v("setOnResponse")]),a("span",{pre:!0,attrs:{class:"token punctuation"}},[s._v("(")]),a("span",{pre:!0,attrs:{class:"token punctuation"}},[s._v("(")]),a("span",{pre:!0,attrs:{class:"token class-name"}},[s._v("HttpResult")]),s._v(" result"),a("span",{pre:!0,attrs:{class:"token punctuation"}},[s._v(")")]),s._v(" "),a("span",{pre:!0,attrs:{class:"token operator"}},[s._v("->")]),s._v(" "),a("span",{pre:!0,attrs:{class:"token punctuation"}},[s._v("{")]),s._v("\n "),a("span",{pre:!0,attrs:{class:"token comment"}},[s._v("// 当发生异常时就不会走这里")]),s._v("\n "),a("span",{pre:!0,attrs:{class:"token punctuation"}},[s._v("}")]),a("span",{pre:!0,attrs:{class:"token punctuation"}},[s._v(")")]),s._v("\n "),a("span",{pre:!0,attrs:{class:"token punctuation"}},[s._v(".")]),a("span",{pre:!0,attrs:{class:"token function"}},[s._v("setOnComplete")]),a("span",{pre:!0,attrs:{class:"token punctuation"}},[s._v("(")]),a("span",{pre:!0,attrs:{class:"token punctuation"}},[s._v("(")]),a("span",{pre:!0,attrs:{class:"token class-name"}},[s._v("State")]),s._v(" state"),a("span",{pre:!0,attrs:{class:"token punctuation"}},[s._v(")")]),s._v(" "),a("span",{pre:!0,attrs:{class:"token operator"}},[s._v("->")]),s._v(" "),a("span",{pre:!0,attrs:{class:"token punctuation"}},[s._v("{")]),s._v("\n "),a("span",{pre:!0,attrs:{class:"token comment"}},[s._v("// 发生异常，会先执行这里，可以根据 state 判断发生了什么")]),s._v("\n "),a("span",{pre:!0,attrs:{class:"token comment"}},[s._v("// 但执行完后依然会在IO线程中向上抛出")]),s._v("\n "),a("span",{pre:!0,attrs:{class:"token punctuation"}},[s._v("}")]),a("span",{pre:!0,attrs:{class:"token punctuation"}},[s._v(")")]),s._v("\n "),a("span",{pre:!0,attrs:{class:"token punctuation"}},[s._v(".")]),a("span",{pre:!0,attrs:{class:"token function"}},[s._v("get")]),a("span",{pre:!0,attrs:{class:"token punctuation"}},[s._v("(")]),a("span",{pre:!0,attrs:{class:"token punctuation"}},[s._v(")")]),a("span",{pre:!0,attrs:{class:"token punctuation"}},[s._v(";")]),s._v("\n")])]),s._v(" "),a("div",{staticClass:"line-numbers-wrapper"},[a("span",{staticClass:"line-number"},[s._v("1")]),a("br"),a("span",{staticClass:"line-number"},[s._v("2")]),a("br"),a("span",{staticClass:"line-number"},[s._v("3")]),a("br"),a("span",{staticClass:"line-number"},[s._v("4")]),a("br"),a("span",{staticClass:"line-number"},[s._v("5")]),a("br"),a("span",{staticClass:"line-number"},[s._v("6")]),a("br"),a("span",{staticClass:"line-number"},[s._v("7")]),a("br"),a("span",{staticClass:"line-number"},[s._v("8")]),a("br"),a("span",{staticClass:"line-number"},[s._v("9")]),a("br")])]),a("p",[s._v("如果就是想 "),a("strong",[s._v("不处理异常，也不向上抛出")]),s._v("，发生错误完全无视，可以做到吗？可以！还是使用"),a("code",[s._v("nothrow()")]),s._v("方法：")]),s._v(" "),a("div",{staticClass:"language-java line-numbers-mode"},[a("pre",{pre:!0,attrs:{class:"language-java"}},[a("code",[s._v("http"),a("span",{pre:!0,attrs:{class:"token punctuation"}},[s._v(".")]),a("span",{pre:!0,attrs:{class:"token function"}},[s._v("async")]),a("span",{pre:!0,attrs:{class:"token punctuation"}},[s._v("(")]),a("span",{pre:!0,attrs:{class:"token string"}},[s._v('"/users/1"')]),a("span",{pre:!0,attrs:{class:"token punctuation"}},[s._v(")")]),s._v("\n "),a("span",{pre:!0,attrs:{class:"token punctuation"}},[s._v(".")]),a("span",{pre:!0,attrs:{class:"token function"}},[s._v("nothrow")]),a("span",{pre:!0,attrs:{class:"token punctuation"}},[s._v("(")]),a("span",{pre:!0,attrs:{class:"token punctuation"}},[s._v(")")]),s._v(" "),a("span",{pre:!0,attrs:{class:"token comment"}},[s._v("// 告诉 OkHttps 发生异常时不向外抛出")]),s._v("\n "),a("span",{pre:!0,attrs:{class:"token punctuation"}},[s._v(".")]),a("span",{pre:!0,attrs:{class:"token function"}},[s._v("setOnResponse")]),a("span",{pre:!0,attrs:{class:"token punctuation"}},[s._v("(")]),a("span",{pre:!0,attrs:{class:"token punctuation"}},[s._v("(")]),a("span",{pre:!0,attrs:{class:"token class-name"}},[s._v("HttpResult")]),s._v(" result"),a("span",{pre:!0,attrs:{class:"token punctuation"}},[s._v(")")]),s._v(" "),a("span",{pre:!0,attrs:{class:"token operator"}},[s._v("->")]),s._v(" "),a("span",{pre:!0,attrs:{class:"token punctuation"}},[s._v("{")]),s._v("\n "),a("span",{pre:!0,attrs:{class:"token comment"}},[s._v("// 当发生异常时就不会走这里")]),s._v("\n "),a("span",{pre:!0,attrs:{class:"token punctuation"}},[s._v("}")]),a("span",{pre:!0,attrs:{class:"token punctuation"}},[s._v(")")]),s._v("\n "),a("span",{pre:!0,attrs:{class:"token punctuation"}},[s._v(".")]),a("span",{pre:!0,attrs:{class:"token function"}},[s._v("get")]),a("span",{pre:!0,attrs:{class:"token punctuation"}},[s._v("(")]),a("span",{pre:!0,attrs:{class:"token punctuation"}},[s._v(")")]),a("span",{pre:!0,attrs:{class:"token punctuation"}},[s._v(";")]),s._v("\n")])]),s._v(" "),a("div",{staticClass:"line-numbers-wrapper"},[a("span",{staticClass:"line-number"},[s._v("1")]),a("br"),a("span",{staticClass:"line-number"},[s._v("2")]),a("br"),a("span",{staticClass:"line-number"},[s._v("3")]),a("br"),a("span",{staticClass:"line-number"},[s._v("4")]),a("br"),a("span",{staticClass:"line-number"},[s._v("5")]),a("br"),a("span",{staticClass:"line-number"},[s._v("6")]),a("br")])]),a("h2",{attrs:{id:"取消请求"}},[a("a",{staticClass:"header-anchor",attrs:{href:"#取消请求"}},[s._v("#")]),s._v(" 取消请求")]),s._v(" "),a("p",[s._v("在 OkHttps 里取消请求共有 "),a("strong",[s._v("4 种")]),s._v(" 方式可选：")]),s._v(" "),a("ul",[a("li",[s._v("使用"),a("code",[s._v("HttpCall#cancel()")]),s._v("取消单个请求（适用于异步请求，"),a("a",{attrs:{href:"#33-httpcall"}},[s._v("详见 3.3 章节")]),s._v("）")]),s._v(" "),a("li",[s._v("使用"),a("code",[s._v("HttpTask#cancel()")]),s._v("取消单个请求（适用于所有请求）（since v1.0.4）")])]),s._v(" "),a("div",{staticClass:"language-java line-numbers-mode"},[a("pre",{pre:!0,attrs:{class:"language-java"}},[a("code",[a("span",{pre:!0,attrs:{class:"token class-name"}},[s._v("HttpTask")]),a("span",{pre:!0,attrs:{class:"token generics"}},[a("span",{pre:!0,attrs:{class:"token punctuation"}},[s._v("<")]),a("span",{pre:!0,attrs:{class:"token operator"}},[s._v("?")]),a("span",{pre:!0,attrs:{class:"token punctuation"}},[s._v(">")])]),s._v(" task "),a("span",{pre:!0,attrs:{class:"token operator"}},[s._v("=")]),s._v(" http"),a("span",{pre:!0,attrs:{class:"token punctuation"}},[s._v(".")]),a("span",{pre:!0,attrs:{class:"token function"}},[s._v("async")]),a("span",{pre:!0,attrs:{class:"token punctuation"}},[s._v("(")]),a("span",{pre:!0,attrs:{class:"token string"}},[s._v('"/users"')]),a("span",{pre:!0,attrs:{class:"token punctuation"}},[s._v(")")]),s._v("\n "),a("span",{pre:!0,attrs:{class:"token punctuation"}},[s._v(".")]),a("span",{pre:!0,attrs:{class:"token function"}},[s._v("setOnResponse")]),a("span",{pre:!0,attrs:{class:"token punctuation"}},[s._v("(")]),a("span",{pre:!0,attrs:{class:"token punctuation"}},[s._v("(")]),a("span",{pre:!0,attrs:{class:"token class-name"}},[s._v("HttpResult")]),s._v(" result"),a("span",{pre:!0,attrs:{class:"token punctuation"}},[s._v(")")]),s._v(" "),a("span",{pre:!0,attrs:{class:"token operator"}},[s._v("->")]),s._v(" "),a("span",{pre:!0,attrs:{class:"token punctuation"}},[s._v("{")]),s._v("\n "),a("span",{pre:!0,attrs:{class:"token comment"}},[s._v("// 响应回调")]),s._v("\n "),a("span",{pre:!0,attrs:{class:"token punctuation"}},[s._v("}")]),a("span",{pre:!0,attrs:{class:"token punctuation"}},[s._v(")")]),a("span",{pre:!0,attrs:{class:"token punctuation"}},[s._v(";")]),s._v("\n\ntask"),a("span",{pre:!0,attrs:{class:"token punctuation"}},[s._v(".")]),a("span",{pre:!0,attrs:{class:"token function"}},[s._v("get")]),a("span",{pre:!0,attrs:{class:"token punctuation"}},[s._v("(")]),a("span",{pre:!0,attrs:{class:"token punctuation"}},[s._v(")")]),a("span",{pre:!0,attrs:{class:"token punctuation"}},[s._v(";")]),s._v(" "),a("span",{pre:!0,attrs:{class:"token comment"}},[s._v("// 发起 GET 请求")]),s._v("\n\n"),a("span",{pre:!0,attrs:{class:"token comment"}},[s._v("// 取消请求，并返回是否取消成功")]),s._v("\n"),a("span",{pre:!0,attrs:{class:"token keyword"}},[s._v("boolean")]),s._v(" canceled "),a("span",{pre:!0,attrs:{class:"token operator"}},[s._v("=")]),s._v(" task"),a("span",{pre:!0,attrs:{class:"token punctuation"}},[s._v(".")]),a("span",{pre:!0,attrs:{class:"token function"}},[s._v("cancel")]),a("span",{pre:!0,attrs:{class:"token punctuation"}},[s._v("(")]),a("span",{pre:!0,attrs:{class:"token punctuation"}},[s._v(")")]),a("span",{pre:!0,attrs:{class:"token punctuation"}},[s._v(";")]),s._v(" \n")])]),s._v(" "),a("div",{staticClass:"line-numbers-wrapper"},[a("span",{staticClass:"line-number"},[s._v("1")]),a("br"),a("span",{staticClass:"line-number"},[s._v("2")]),a("br"),a("span",{staticClass:"line-number"},[s._v("3")]),a("br"),a("span",{staticClass:"line-number"},[s._v("4")]),a("br"),a("span",{staticClass:"line-number"},[s._v("5")]),a("br"),a("span",{staticClass:"line-number"},[s._v("6")]),a("br"),a("span",{staticClass:"line-number"},[s._v("7")]),a("br"),a("span",{staticClass:"line-number"},[s._v("8")]),a("br"),a("span",{staticClass:"line-number"},[s._v("9")]),a("br")])]),a("ul",[a("li",[s._v("使用"),a("code",[s._v("HTTP#cancel(String tag)")]),s._v("按标签批量取消请求（适用于所有请求，"),a("a",{attrs:{href:"#5-%E4%BD%BF%E7%94%A8%E6%A0%87%E7%AD%BE"}},[s._v("详见第 5 章节")]),s._v("）")]),s._v(" "),a("li",[s._v("使用"),a("code",[s._v("HTTP#cancelAll()")]),s._v("取消所有请求（适用于所有请求）（since v1.0.2）")])]),s._v(" "),a("div",{staticClass:"language-java line-numbers-mode"},[a("pre",{pre:!0,attrs:{class:"language-java"}},[a("code",[s._v("http"),a("span",{pre:!0,attrs:{class:"token punctuation"}},[s._v(".")]),a("span",{pre:!0,attrs:{class:"token function"}},[s._v("cancelAll")]),a("span",{pre:!0,attrs:{class:"token punctuation"}},[s._v("(")]),a("span",{pre:!0,attrs:{class:"token punctuation"}},[s._v(")")]),a("span",{pre:!0,attrs:{class:"token punctuation"}},[s._v(";")]),s._v(" "),a("span",{pre:!0,attrs:{class:"token comment"}},[s._v("// 取消所有请求")]),s._v("\n")])]),s._v(" "),a("div",{staticClass:"line-numbers-wrapper"},[a("span",{staticClass:"line-number"},[s._v("1")]),a("br")])])])}),[],!1,null,null,null);t.default=e.exports}}]); \ No newline at end of file diff --git a/okhttps-doc/docs/.vuepress/dist/assets/js/11.152d132f.js b/okhttps-doc/docs/.vuepress/dist/assets/js/11.152d132f.js new file mode 100644 index 00000000..4ce64ac2 --- /dev/null +++ b/okhttps-doc/docs/.vuepress/dist/assets/js/11.152d132f.js @@ -0,0 +1 @@ +(window.webpackJsonp=window.webpackJsonp||[]).push([[11],{335:function(t,s,a){"use strict";a.r(s);var n=a(19),e=Object(n.a)({},(function(){var t=this,s=t.$createElement,a=t._self._c||s;return a("ContentSlotsDistributor",{attrs:{"slot-key":t.$parent.slotKey}},[a("h1",{attrs:{id:"基础"}},[a("a",{staticClass:"header-anchor",attrs:{href:"#基础"}},[t._v("#")]),t._v(" 基础")]),t._v(" "),a("h2",{attrs:{id:"请求方法"}},[a("a",{staticClass:"header-anchor",attrs:{href:"#请求方法"}},[t._v("#")]),t._v(" 请求方法")]),t._v(" "),a("p",[t._v("同步与异步的"),a("code",[t._v("HttpTask")]),t._v("都拥有"),a("code",[t._v("get")]),t._v("、"),a("code",[t._v("post")]),t._v("、"),a("code",[t._v("put")]),t._v("与"),a("code",[t._v("delete")]),t._v("方法。不同的是：同步"),a("code",[t._v("HttpTask")]),t._v("的这些方法返回一个"),a("code",[t._v("HttpResult")]),t._v("，而异步"),a("code",[t._v("HttpTask")]),t._v("的这些方法返回一个"),a("code",[t._v("HttpCall")]),t._v("。")]),t._v(" "),a("div",{staticClass:"language-java line-numbers-mode"},[a("pre",{pre:!0,attrs:{class:"language-java"}},[a("code",[a("span",{pre:!0,attrs:{class:"token class-name"}},[t._v("HttpResult")]),t._v(" res1 "),a("span",{pre:!0,attrs:{class:"token operator"}},[t._v("=")]),t._v(" http"),a("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v(".")]),a("span",{pre:!0,attrs:{class:"token function"}},[t._v("sync")]),a("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v("(")]),a("span",{pre:!0,attrs:{class:"token string"}},[t._v('"/users"')]),a("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v(")")]),a("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v(".")]),a("span",{pre:!0,attrs:{class:"token function"}},[t._v("get")]),a("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v("(")]),a("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v(")")]),a("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v(";")]),t._v(" "),a("span",{pre:!0,attrs:{class:"token comment"}},[t._v("// 同步 GET")]),t._v("\n"),a("span",{pre:!0,attrs:{class:"token class-name"}},[t._v("HttpResult")]),t._v(" res2 "),a("span",{pre:!0,attrs:{class:"token operator"}},[t._v("=")]),t._v(" http"),a("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v(".")]),a("span",{pre:!0,attrs:{class:"token function"}},[t._v("sync")]),a("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v("(")]),a("span",{pre:!0,attrs:{class:"token string"}},[t._v('"/users"')]),a("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v(")")]),a("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v(".")]),a("span",{pre:!0,attrs:{class:"token function"}},[t._v("post")]),a("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v("(")]),a("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v(")")]),a("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v(";")]),t._v(" "),a("span",{pre:!0,attrs:{class:"token comment"}},[t._v("// 同步 POST")]),t._v("\n"),a("span",{pre:!0,attrs:{class:"token class-name"}},[t._v("HttpResult")]),t._v(" res3 "),a("span",{pre:!0,attrs:{class:"token operator"}},[t._v("=")]),t._v(" http"),a("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v(".")]),a("span",{pre:!0,attrs:{class:"token function"}},[t._v("sync")]),a("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v("(")]),a("span",{pre:!0,attrs:{class:"token string"}},[t._v('"/users/1"')]),a("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v(")")]),a("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v(".")]),a("span",{pre:!0,attrs:{class:"token function"}},[t._v("put")]),a("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v("(")]),a("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v(")")]),a("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v(";")]),t._v(" "),a("span",{pre:!0,attrs:{class:"token comment"}},[t._v("// 同步 PUT")]),t._v("\n"),a("span",{pre:!0,attrs:{class:"token class-name"}},[t._v("HttpResult")]),t._v(" res4 "),a("span",{pre:!0,attrs:{class:"token operator"}},[t._v("=")]),t._v(" http"),a("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v(".")]),a("span",{pre:!0,attrs:{class:"token function"}},[t._v("sync")]),a("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v("(")]),a("span",{pre:!0,attrs:{class:"token string"}},[t._v('"/users/1"')]),a("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v(")")]),a("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v(".")]),a("span",{pre:!0,attrs:{class:"token function"}},[t._v("delete")]),a("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v("(")]),a("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v(")")]),a("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v(";")]),a("span",{pre:!0,attrs:{class:"token comment"}},[t._v("// 同步 DELETE")]),t._v("\n"),a("span",{pre:!0,attrs:{class:"token class-name"}},[t._v("HttpCall")]),t._v(" call1 "),a("span",{pre:!0,attrs:{class:"token operator"}},[t._v("=")]),t._v(" http"),a("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v(".")]),a("span",{pre:!0,attrs:{class:"token function"}},[t._v("async")]),a("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v("(")]),a("span",{pre:!0,attrs:{class:"token string"}},[t._v('"/users"')]),a("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v(")")]),a("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v(".")]),a("span",{pre:!0,attrs:{class:"token function"}},[t._v("get")]),a("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v("(")]),a("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v(")")]),a("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v(";")]),t._v(" "),a("span",{pre:!0,attrs:{class:"token comment"}},[t._v("// 异步 GET")]),t._v("\n"),a("span",{pre:!0,attrs:{class:"token class-name"}},[t._v("HttpCall")]),t._v(" call2 "),a("span",{pre:!0,attrs:{class:"token operator"}},[t._v("=")]),t._v(" http"),a("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v(".")]),a("span",{pre:!0,attrs:{class:"token function"}},[t._v("async")]),a("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v("(")]),a("span",{pre:!0,attrs:{class:"token string"}},[t._v('"/users"')]),a("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v(")")]),a("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v(".")]),a("span",{pre:!0,attrs:{class:"token function"}},[t._v("post")]),a("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v("(")]),a("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v(")")]),a("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v(";")]),t._v(" "),a("span",{pre:!0,attrs:{class:"token comment"}},[t._v("// 异步 POST")]),t._v("\n"),a("span",{pre:!0,attrs:{class:"token class-name"}},[t._v("HttpCall")]),t._v(" call3 "),a("span",{pre:!0,attrs:{class:"token operator"}},[t._v("=")]),t._v(" http"),a("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v(".")]),a("span",{pre:!0,attrs:{class:"token function"}},[t._v("async")]),a("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v("(")]),a("span",{pre:!0,attrs:{class:"token string"}},[t._v('"/users/1"')]),a("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v(")")]),a("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v(".")]),a("span",{pre:!0,attrs:{class:"token function"}},[t._v("put")]),a("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v("(")]),a("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v(")")]),a("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v(";")]),t._v(" "),a("span",{pre:!0,attrs:{class:"token comment"}},[t._v("// 异步 PUT")]),t._v("\n"),a("span",{pre:!0,attrs:{class:"token class-name"}},[t._v("HttpCall")]),t._v(" call4 "),a("span",{pre:!0,attrs:{class:"token operator"}},[t._v("=")]),t._v(" http"),a("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v(".")]),a("span",{pre:!0,attrs:{class:"token function"}},[t._v("async")]),a("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v("(")]),a("span",{pre:!0,attrs:{class:"token string"}},[t._v('"/users/1"')]),a("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v(")")]),a("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v(".")]),a("span",{pre:!0,attrs:{class:"token function"}},[t._v("delete")]),a("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v("(")]),a("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v(")")]),a("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v(";")]),a("span",{pre:!0,attrs:{class:"token comment"}},[t._v("// 异步 DELETE")]),t._v("\n")])]),t._v(" "),a("div",{staticClass:"line-numbers-wrapper"},[a("span",{staticClass:"line-number"},[t._v("1")]),a("br"),a("span",{staticClass:"line-number"},[t._v("2")]),a("br"),a("span",{staticClass:"line-number"},[t._v("3")]),a("br"),a("span",{staticClass:"line-number"},[t._v("4")]),a("br"),a("span",{staticClass:"line-number"},[t._v("5")]),a("br"),a("span",{staticClass:"line-number"},[t._v("6")]),a("br"),a("span",{staticClass:"line-number"},[t._v("7")]),a("br"),a("span",{staticClass:"line-number"},[t._v("8")]),a("br")])]),a("h2",{attrs:{id:"回调函数"}},[a("a",{staticClass:"header-anchor",attrs:{href:"#回调函数"}},[t._v("#")]),t._v(" 回调函数")]),t._v(" "),a("p",[t._v("OkHttps 的回调函数全部使用单方法模式，这样可以充分利用 Java8 或 Kotlin 中的 Lambda 表达式，使你的代码更加简洁优雅：")]),t._v(" "),a("div",{staticClass:"language-java line-numbers-mode"},[a("pre",{pre:!0,attrs:{class:"language-java"}},[a("code",[t._v("http"),a("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v(".")]),a("span",{pre:!0,attrs:{class:"token function"}},[t._v("async")]),a("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v("(")]),a("span",{pre:!0,attrs:{class:"token string"}},[t._v('"/users/{id}"')]),a("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v(")")]),t._v(" "),a("span",{pre:!0,attrs:{class:"token comment"}},[t._v("// http://api.demo.com/users/1")]),t._v("\n "),a("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v(".")]),a("span",{pre:!0,attrs:{class:"token function"}},[t._v("addPathParam")]),a("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v("(")]),a("span",{pre:!0,attrs:{class:"token string"}},[t._v('"id"')]),a("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v(",")]),t._v(" "),a("span",{pre:!0,attrs:{class:"token number"}},[t._v("1")]),a("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v(")")]),t._v("\n "),a("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v(".")]),a("span",{pre:!0,attrs:{class:"token function"}},[t._v("setOnResponse")]),a("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v("(")]),a("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v("(")]),a("span",{pre:!0,attrs:{class:"token class-name"}},[t._v("HttpResult")]),t._v(" result"),a("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v(")")]),t._v(" "),a("span",{pre:!0,attrs:{class:"token operator"}},[t._v("->")]),t._v(" "),a("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v("{")]),t._v("\n "),a("span",{pre:!0,attrs:{class:"token comment"}},[t._v("// 响应回调")]),t._v("\n "),a("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v("}")]),a("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v(")")]),t._v("\n "),a("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v(".")]),a("span",{pre:!0,attrs:{class:"token function"}},[t._v("setOnException")]),a("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v("(")]),a("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v("(")]),a("span",{pre:!0,attrs:{class:"token class-name"}},[t._v("IOException")]),t._v(" e"),a("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v(")")]),t._v(" "),a("span",{pre:!0,attrs:{class:"token operator"}},[t._v("->")]),t._v(" "),a("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v("{")]),t._v("\n "),a("span",{pre:!0,attrs:{class:"token comment"}},[t._v("// 异常回调")]),t._v("\n "),a("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v("}")]),a("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v(")")]),t._v("\n "),a("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v(".")]),a("span",{pre:!0,attrs:{class:"token function"}},[t._v("setOnComplete")]),a("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v("(")]),a("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v("(")]),a("span",{pre:!0,attrs:{class:"token class-name"}},[t._v("State")]),t._v(" state"),a("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v(")")]),t._v(" "),a("span",{pre:!0,attrs:{class:"token operator"}},[t._v("->")]),t._v(" "),a("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v("{")]),t._v("\n "),a("span",{pre:!0,attrs:{class:"token comment"}},[t._v("// 完成回调，无论成功失败都会执行")]),t._v("\n "),a("span",{pre:!0,attrs:{class:"token comment"}},[t._v("// 并且在 响应|异常回调 之前执行")]),t._v("\n "),a("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v("}")]),a("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v(")")]),t._v("\n "),a("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v(".")]),a("span",{pre:!0,attrs:{class:"token function"}},[t._v("get")]),a("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v("(")]),a("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v(")")]),a("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v(";")]),t._v("\n")])]),t._v(" "),a("div",{staticClass:"line-numbers-wrapper"},[a("span",{staticClass:"line-number"},[t._v("1")]),a("br"),a("span",{staticClass:"line-number"},[t._v("2")]),a("br"),a("span",{staticClass:"line-number"},[t._v("3")]),a("br"),a("span",{staticClass:"line-number"},[t._v("4")]),a("br"),a("span",{staticClass:"line-number"},[t._v("5")]),a("br"),a("span",{staticClass:"line-number"},[t._v("6")]),a("br"),a("span",{staticClass:"line-number"},[t._v("7")]),a("br"),a("span",{staticClass:"line-number"},[t._v("8")]),a("br"),a("span",{staticClass:"line-number"},[t._v("9")]),a("br"),a("span",{staticClass:"line-number"},[t._v("10")]),a("br"),a("span",{staticClass:"line-number"},[t._v("11")]),a("br"),a("span",{staticClass:"line-number"},[t._v("12")]),a("br"),a("span",{staticClass:"line-number"},[t._v("13")]),a("br")])]),a("p",[t._v("OkHttps 同时还支持 "),a("strong",[t._v("全局回调")]),t._v(" 和 "),a("strong",[t._v("回调阻断")]),t._v(" 机制，详见 "),a("RouterLink",{attrs:{to:"/guide/configuration.html#全局回调监听"}},[t._v("全局回调监听")]),t._v("。")],1),t._v(" "),a("div",{staticClass:"custom-block tip"},[a("p",{staticClass:"custom-block-title"},[t._v("TIP")]),t._v(" "),a("ul",[a("li",[t._v("只有异步请求才可以设置这三种（响应|异常|完成）回调")]),t._v(" "),a("li",[t._v("同步请求直接返回结果，无需使用回调")])])]),t._v(" "),a("h2",{attrs:{id:"httpresult"}},[a("a",{staticClass:"header-anchor",attrs:{href:"#httpresult"}},[t._v("#")]),t._v(" HttpResult")]),t._v(" "),a("p",[a("code",[t._v("HttpResult")]),t._v("是HTTP请求执行完后的结果，它是同步请求方法（ "),a("code",[t._v("get")]),t._v("、"),a("code",[t._v("post")]),t._v("、"),a("code",[t._v("put")]),t._v("、"),a("code",[t._v("delete")]),t._v("）的返回值，也是异步请求响应回调（"),a("code",[t._v("OnResponse")]),t._v("）的参数，它定义了如下方法：")]),t._v(" "),a("ul",[a("li",[a("code",[t._v("getState()")]),t._v(" 得到请求执行状态枚举，它有以下取值：\n"),a("ul",[a("li",[a("code",[t._v("State.CANCELED")]),t._v(" 请求被取消")]),t._v(" "),a("li",[a("code",[t._v("State.RESPONSED")]),t._v(" 已收到响应")]),t._v(" "),a("li",[a("code",[t._v("State.TIMEOUT")]),t._v(" 请求超时")]),t._v(" "),a("li",[a("code",[t._v("State.NETWORK_ERROR")]),t._v(" 网络错误")]),t._v(" "),a("li",[a("code",[t._v("State.EXCEPTION")]),t._v(" 其它请求异常")])])]),t._v(" "),a("li",[a("code",[t._v("getStatus()")]),t._v(" 得到HTTP状态码")]),t._v(" "),a("li",[a("code",[t._v("isSuccessful()")]),t._v(" 是否响应成功，状态码在 [200..300) 之间")]),t._v(" "),a("li",[a("code",[t._v("getHeaders()")]),t._v(" 得到HTTP响应头")]),t._v(" "),a("li",[a("code",[t._v("getHeaders(String name)")]),t._v(" 得到HTTP响应头")]),t._v(" "),a("li",[a("code",[t._v("getHeader(String name)")]),t._v(" 得到HTTP响应头")]),t._v(" "),a("li",[a("code",[t._v("getBody()")]),t._v(" 得到响应报文体"),a("code",[t._v("Body")]),t._v("实例，它定义了如下方法（对同一个"),a("code",[t._v("Body")]),t._v("实例，以下的"),a("code",[t._v("toXXX()")]),t._v("类方法只能使用一个且仅能调用一次，除非先使用 cache 方法）：\n"),a("ul",[a("li",[a("code",[t._v("toBytes()")]),t._v(" 返回字节数组")]),t._v(" "),a("li",[a("code",[t._v("toByteStream()")]),t._v(" 返回字节输入流")]),t._v(" "),a("li",[a("code",[t._v("toCharStream()")]),t._v(" 返回字符输入流")]),t._v(" "),a("li",[a("code",[t._v("toString()")]),t._v(" 返回字符串")]),t._v(" "),a("li",[a("code",[t._v("toJsonObject()")]),t._v(" 返回Json对象")]),t._v(" "),a("li",[a("code",[t._v("toJsonArray()")]),t._v(" 返回Json数组")]),t._v(" "),a("li",[a("code",[t._v("toBean(Class type)")]),t._v(" 返回根据type自动json解析后的JavaBean")]),t._v(" "),a("li",[a("code",[t._v("toList(Class type)")]),t._v(" 返回根据type自动json解析后的JavaBean列表")]),t._v(" "),a("li",[a("code",[t._v("toFile(String filePath)")]),t._v(" 下载到指定路径")]),t._v(" "),a("li",[a("code",[t._v("toFile(File file)")]),t._v(" 下载到指定文件")]),t._v(" "),a("li",[a("code",[t._v("toFolder(String dirPath)")]),t._v(" 下载到指定目录")]),t._v(" "),a("li",[a("code",[t._v("toFolder(File dir)")]),t._v(" 下载到指定目录")]),t._v(" "),a("li",[a("code",[t._v("getContentType()")]),t._v(" 返回报文体的媒体类型")]),t._v(" "),a("li",[a("code",[t._v("getContentLength()")]),t._v(" 返回报文体的字节长度")]),t._v(" "),a("li",[a("code",[t._v("cache()")]),t._v(" 缓存报文体，开启缓存后可重复使用"),a("code",[t._v("toXXX()")]),t._v("类方法")]),t._v(" "),a("li",[a("code",[t._v("close()")]),t._v(" 关闭报文体，未对报文体做任何消费时使用，比如只读取报文头")])])]),t._v(" "),a("li",[a("code",[t._v("getError()")]),t._v(" 执行中发生的异常，自动捕获执行请求时发生的 网络超时、网络错误 和 其它IO异常")]),t._v(" "),a("li",[a("code",[t._v("close()")]),t._v(" 关闭报文，未对报文体做任何消费时使用，比如只读取长度")])]),t._v(" "),a("p",[t._v("示例，请求结果自动转Bean和List：")]),t._v(" "),a("div",{staticClass:"language-java line-numbers-mode"},[a("pre",{pre:!0,attrs:{class:"language-java"}},[a("code",[a("span",{pre:!0,attrs:{class:"token comment"}},[t._v("// 自动转Bean")]),t._v("\n"),a("span",{pre:!0,attrs:{class:"token class-name"}},[t._v("Order")]),t._v(" order "),a("span",{pre:!0,attrs:{class:"token operator"}},[t._v("=")]),t._v(" http"),a("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v(".")]),a("span",{pre:!0,attrs:{class:"token function"}},[t._v("sync")]),a("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v("(")]),a("span",{pre:!0,attrs:{class:"token string"}},[t._v('"/orders/1"')]),a("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v(")")]),t._v("\n "),a("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v(".")]),a("span",{pre:!0,attrs:{class:"token function"}},[t._v("get")]),a("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v("(")]),a("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v(")")]),a("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v(".")]),a("span",{pre:!0,attrs:{class:"token function"}},[t._v("getBody")]),a("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v("(")]),a("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v(")")]),a("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v(".")]),a("span",{pre:!0,attrs:{class:"token function"}},[t._v("toBean")]),a("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v("(")]),a("span",{pre:!0,attrs:{class:"token class-name"}},[t._v("Order")]),a("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v(".")]),a("span",{pre:!0,attrs:{class:"token keyword"}},[t._v("class")]),a("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v(")")]),a("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v(";")]),t._v("\n \n"),a("span",{pre:!0,attrs:{class:"token comment"}},[t._v("// 自动转List")]),t._v("\n"),a("span",{pre:!0,attrs:{class:"token class-name"}},[t._v("List")]),a("span",{pre:!0,attrs:{class:"token generics"}},[a("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v("<")]),a("span",{pre:!0,attrs:{class:"token class-name"}},[t._v("Order")]),a("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v(">")])]),t._v(" orders "),a("span",{pre:!0,attrs:{class:"token operator"}},[t._v("=")]),t._v(" http"),a("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v(".")]),a("span",{pre:!0,attrs:{class:"token function"}},[t._v("sync")]),a("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v("(")]),a("span",{pre:!0,attrs:{class:"token string"}},[t._v('"/orders"')]),a("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v(")")]),t._v("\n "),a("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v(".")]),a("span",{pre:!0,attrs:{class:"token function"}},[t._v("get")]),a("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v("(")]),a("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v(")")]),a("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v(".")]),a("span",{pre:!0,attrs:{class:"token function"}},[t._v("getBody")]),a("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v("(")]),a("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v(")")]),a("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v(".")]),a("span",{pre:!0,attrs:{class:"token function"}},[t._v("toList")]),a("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v("(")]),a("span",{pre:!0,attrs:{class:"token class-name"}},[t._v("Order")]),a("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v(".")]),a("span",{pre:!0,attrs:{class:"token keyword"}},[t._v("class")]),a("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v(")")]),a("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v(";")]),t._v("\n")])]),t._v(" "),a("div",{staticClass:"line-numbers-wrapper"},[a("span",{staticClass:"line-number"},[t._v("1")]),a("br"),a("span",{staticClass:"line-number"},[t._v("2")]),a("br"),a("span",{staticClass:"line-number"},[t._v("3")]),a("br"),a("span",{staticClass:"line-number"},[t._v("4")]),a("br"),a("span",{staticClass:"line-number"},[t._v("5")]),a("br"),a("span",{staticClass:"line-number"},[t._v("6")]),a("br"),a("span",{staticClass:"line-number"},[t._v("7")]),a("br")])]),a("p",[t._v("示例，使用 cache 方法：")]),t._v(" "),a("div",{staticClass:"language-java line-numbers-mode"},[a("pre",{pre:!0,attrs:{class:"language-java"}},[a("code",[a("span",{pre:!0,attrs:{class:"token class-name"}},[t._v("Body")]),t._v(" body "),a("span",{pre:!0,attrs:{class:"token operator"}},[t._v("=")]),t._v(" http"),a("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v(".")]),a("span",{pre:!0,attrs:{class:"token function"}},[t._v("sync")]),a("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v("(")]),a("span",{pre:!0,attrs:{class:"token string"}},[t._v('"/orders"')]),a("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v(")")]),a("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v(".")]),a("span",{pre:!0,attrs:{class:"token function"}},[t._v("get")]),a("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v("(")]),a("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v(")")]),a("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v(".")]),a("span",{pre:!0,attrs:{class:"token function"}},[t._v("getBody")]),a("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v("(")]),a("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v(")")]),a("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v(".")]),a("span",{pre:!0,attrs:{class:"token function"}},[t._v("cache")]),a("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v("(")]),a("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v(")")]),a("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v(";")]),t._v("\n\n"),a("span",{pre:!0,attrs:{class:"token comment"}},[t._v("// 使用 cache 后，可以多次使用 toXXX() 方法")]),t._v("\n"),a("span",{pre:!0,attrs:{class:"token class-name"}},[t._v("System")]),a("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v(".")]),t._v("out"),a("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v(".")]),a("span",{pre:!0,attrs:{class:"token function"}},[t._v("println")]),a("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v("(")]),t._v("body"),a("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v(".")]),a("span",{pre:!0,attrs:{class:"token function"}},[t._v("toString")]),a("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v("(")]),a("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v(")")]),a("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v(")")]),a("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v(";")]),t._v("\n"),a("span",{pre:!0,attrs:{class:"token class-name"}},[t._v("System")]),a("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v(".")]),t._v("out"),a("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v(".")]),a("span",{pre:!0,attrs:{class:"token function"}},[t._v("println")]),a("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v("(")]),t._v("body"),a("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v(".")]),a("span",{pre:!0,attrs:{class:"token function"}},[t._v("toJsonArray")]),a("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v("(")]),a("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v(")")]),a("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v(")")]),a("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v(";")]),t._v("\n"),a("span",{pre:!0,attrs:{class:"token class-name"}},[t._v("System")]),a("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v(".")]),t._v("out"),a("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v(".")]),a("span",{pre:!0,attrs:{class:"token function"}},[t._v("println")]),a("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v("(")]),t._v("body"),a("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v(".")]),a("span",{pre:!0,attrs:{class:"token function"}},[t._v("toList")]),a("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v("(")]),a("span",{pre:!0,attrs:{class:"token class-name"}},[t._v("Order")]),a("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v(".")]),a("span",{pre:!0,attrs:{class:"token keyword"}},[t._v("class")]),a("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v(")")]),a("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v(")")]),a("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v(";")]),t._v("\n")])]),t._v(" "),a("div",{staticClass:"line-numbers-wrapper"},[a("span",{staticClass:"line-number"},[t._v("1")]),a("br"),a("span",{staticClass:"line-number"},[t._v("2")]),a("br"),a("span",{staticClass:"line-number"},[t._v("3")]),a("br"),a("span",{staticClass:"line-number"},[t._v("4")]),a("br"),a("span",{staticClass:"line-number"},[t._v("5")]),a("br"),a("span",{staticClass:"line-number"},[t._v("6")]),a("br")])]),a("p",[t._v("示例，获取下载文件的大小：")]),t._v(" "),a("div",{staticClass:"language-java line-numbers-mode"},[a("pre",{pre:!0,attrs:{class:"language-java"}},[a("code",[a("span",{pre:!0,attrs:{class:"token keyword"}},[t._v("long")]),t._v(" size "),a("span",{pre:!0,attrs:{class:"token operator"}},[t._v("=")]),t._v(" http"),a("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v(".")]),a("span",{pre:!0,attrs:{class:"token function"}},[t._v("sync")]),a("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v("(")]),a("span",{pre:!0,attrs:{class:"token string"}},[t._v('"/download/test.zip"')]),a("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v(")")]),t._v("\n "),a("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v(".")]),a("span",{pre:!0,attrs:{class:"token function"}},[t._v("get")]),a("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v("(")]),a("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v(")")]),a("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v(".")]),a("span",{pre:!0,attrs:{class:"token function"}},[t._v("getBody")]),a("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v("(")]),a("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v(")")]),t._v("\n "),a("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v(".")]),a("span",{pre:!0,attrs:{class:"token function"}},[t._v("close")]),a("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v("(")]),a("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v(")")]),t._v(" "),a("span",{pre:!0,attrs:{class:"token comment"}},[t._v("// 只是想获得文件大小，不消费报文体，所以直接关闭")]),t._v("\n "),a("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v(".")]),a("span",{pre:!0,attrs:{class:"token function"}},[t._v("getContentLength")]),a("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v("(")]),a("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v(")")]),a("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v(";")]),t._v(" "),a("span",{pre:!0,attrs:{class:"token comment"}},[t._v("// 获得待下载文件的大小")]),t._v("\n\n"),a("span",{pre:!0,attrs:{class:"token comment"}},[t._v("// 由于未消费报文体，所以本次请求不会消耗下载报文体的时间和网络流量")]),t._v("\n\n"),a("span",{pre:!0,attrs:{class:"token class-name"}},[t._v("System")]),a("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v(".")]),t._v("out"),a("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v(".")]),a("span",{pre:!0,attrs:{class:"token function"}},[t._v("println")]),a("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v("(")]),a("span",{pre:!0,attrs:{class:"token string"}},[t._v('"size = "')]),t._v(" "),a("span",{pre:!0,attrs:{class:"token operator"}},[t._v("+")]),t._v(" size"),a("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v(")")]),a("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v(";")]),t._v("\n")])]),t._v(" "),a("div",{staticClass:"line-numbers-wrapper"},[a("span",{staticClass:"line-number"},[t._v("1")]),a("br"),a("span",{staticClass:"line-number"},[t._v("2")]),a("br"),a("span",{staticClass:"line-number"},[t._v("3")]),a("br"),a("span",{staticClass:"line-number"},[t._v("4")]),a("br"),a("span",{staticClass:"line-number"},[t._v("5")]),a("br"),a("span",{staticClass:"line-number"},[t._v("6")]),a("br"),a("span",{staticClass:"line-number"},[t._v("7")]),a("br"),a("span",{staticClass:"line-number"},[t._v("8")]),a("br")])]),a("h2",{attrs:{id:"httpcall"}},[a("a",{staticClass:"header-anchor",attrs:{href:"#httpcall"}},[t._v("#")]),t._v(" HttpCall")]),t._v(" "),a("p",[a("code",[t._v("HttpCall")]),t._v("对象是异步请求方法（"),a("code",[t._v("get")]),t._v("、"),a("code",[t._v("post")]),t._v("、"),a("code",[t._v("put")]),t._v("、"),a("code",[t._v("delete")]),t._v("）的返回值，与"),a("code",[t._v("java")]),t._v("的"),a("code",[t._v("Future")]),t._v("接口很像，它有如下方法：")]),t._v(" "),a("ul",[a("li",[a("code",[t._v("cancel()")]),t._v(" 取消本次请求，返回取消结果")]),t._v(" "),a("li",[a("code",[t._v("isCanceled()")]),t._v(" 返回请求是否被取消")]),t._v(" "),a("li",[a("code",[t._v("isDone()")]),t._v(" 返回是否执行完成，包含取消和失败")]),t._v(" "),a("li",[a("code",[t._v("getResult()")]),t._v(" 返回执行结果"),a("code",[t._v("HttpResult")]),t._v("对象，若请求未执行完，则挂起当前线程直到执行完成再返回")])]),t._v(" "),a("p",[t._v("取消一个异步请求示例：")]),t._v(" "),a("div",{staticClass:"language-java line-numbers-mode"},[a("pre",{pre:!0,attrs:{class:"language-java"}},[a("code",[a("span",{pre:!0,attrs:{class:"token class-name"}},[t._v("HttpCall")]),t._v(" call "),a("span",{pre:!0,attrs:{class:"token operator"}},[t._v("=")]),t._v(" http"),a("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v(".")]),a("span",{pre:!0,attrs:{class:"token function"}},[t._v("async")]),a("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v("(")]),a("span",{pre:!0,attrs:{class:"token string"}},[t._v('"/users/1"')]),a("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v(")")]),a("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v(".")]),a("span",{pre:!0,attrs:{class:"token function"}},[t._v("get")]),a("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v("(")]),a("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v(")")]),a("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v(";")]),t._v("\n\n"),a("span",{pre:!0,attrs:{class:"token class-name"}},[t._v("System")]),a("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v(".")]),t._v("out"),a("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v(".")]),a("span",{pre:!0,attrs:{class:"token function"}},[t._v("println")]),a("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v("(")]),t._v("call"),a("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v(".")]),a("span",{pre:!0,attrs:{class:"token function"}},[t._v("isCanceled")]),a("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v("(")]),a("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v(")")]),a("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v(")")]),a("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v(";")]),t._v(" "),a("span",{pre:!0,attrs:{class:"token comment"}},[t._v("// false")]),t._v("\n\n"),a("span",{pre:!0,attrs:{class:"token keyword"}},[t._v("boolean")]),t._v(" success "),a("span",{pre:!0,attrs:{class:"token operator"}},[t._v("=")]),t._v(" call"),a("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v(".")]),a("span",{pre:!0,attrs:{class:"token function"}},[t._v("cancel")]),a("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v("(")]),a("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v(")")]),a("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v(";")]),t._v(" "),a("span",{pre:!0,attrs:{class:"token comment"}},[t._v("// 取消请求")]),t._v("\n\n"),a("span",{pre:!0,attrs:{class:"token class-name"}},[t._v("System")]),a("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v(".")]),t._v("out"),a("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v(".")]),a("span",{pre:!0,attrs:{class:"token function"}},[t._v("println")]),a("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v("(")]),t._v("success"),a("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v(")")]),a("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v(";")]),t._v(" "),a("span",{pre:!0,attrs:{class:"token comment"}},[t._v("// true")]),t._v("\n"),a("span",{pre:!0,attrs:{class:"token class-name"}},[t._v("System")]),a("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v(".")]),t._v("out"),a("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v(".")]),a("span",{pre:!0,attrs:{class:"token function"}},[t._v("println")]),a("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v("(")]),t._v("call"),a("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v(".")]),a("span",{pre:!0,attrs:{class:"token function"}},[t._v("isCanceled")]),a("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v("(")]),a("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v(")")]),a("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v(")")]),a("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v(";")]),t._v(" "),a("span",{pre:!0,attrs:{class:"token comment"}},[t._v("// true")]),t._v("\n")])]),t._v(" "),a("div",{staticClass:"line-numbers-wrapper"},[a("span",{staticClass:"line-number"},[t._v("1")]),a("br"),a("span",{staticClass:"line-number"},[t._v("2")]),a("br"),a("span",{staticClass:"line-number"},[t._v("3")]),a("br"),a("span",{staticClass:"line-number"},[t._v("4")]),a("br"),a("span",{staticClass:"line-number"},[t._v("5")]),a("br"),a("span",{staticClass:"line-number"},[t._v("6")]),a("br"),a("span",{staticClass:"line-number"},[t._v("7")]),a("br"),a("span",{staticClass:"line-number"},[t._v("8")]),a("br")])]),a("h2",{attrs:{id:"构建http任务"}},[a("a",{staticClass:"header-anchor",attrs:{href:"#构建http任务"}},[t._v("#")]),t._v(" 构建HTTP任务")]),t._v(" "),a("p",[a("code",[t._v("HTTP")]),t._v("对象的"),a("code",[t._v("sync")]),t._v("与"),a("code",[t._v("async")]),t._v("方法返回一个"),a("code",[t._v("HttpTask")]),t._v("对象，该对象提供了可链式调用的"),a("code",[t._v("addXXX")]),t._v("与"),a("code",[t._v("setXXX")]),t._v("等系列方法用于构建任务本身。")]),t._v(" "),a("ul",[a("li",[a("p",[a("code",[t._v("addHeader(String name, String value)")]),t._v(" 添加请求头")])]),t._v(" "),a("li",[a("p",[a("code",[t._v("addHeader(Map headers)")]),t._v(" 添加请求头")])]),t._v(" "),a("li",[a("p",[a("code",[t._v("addPathParam(String name, Object value)")]),t._v(" 添加路径参数：替换URL里的{name}占位符")])]),t._v(" "),a("li",[a("p",[a("code",[t._v("addPathParam(Map params)")]),t._v(" 添加路径参数：替换URL里的{name}占位符")])]),t._v(" "),a("li",[a("p",[a("code",[t._v("addUrlParam(String name, Object value)")]),t._v(" 添加URL参数：拼接在URL的?之后（查询参数）")])]),t._v(" "),a("li",[a("p",[a("code",[t._v("addUrlParam(Map params)")]),t._v(" 添加URL参数：拼接在URL的?之后（查询参数）")])]),t._v(" "),a("li",[a("p",[a("code",[t._v("addBodyParam(String name, Object value)")]),t._v(" 添加Body参数：以表单key=value&的形式放在报文体内（表单参数）")])]),t._v(" "),a("li",[a("p",[a("code",[t._v("addBodyParam(Map params)")]),t._v(" 添加Body参数：以表单key=value&的形式放在报文体内（表单参数）")])]),t._v(" "),a("li",[a("p",[a("code",[t._v("addJsonParam(String name, Object value)")]),t._v(" 添加Json参数：请求体为Json（支持多层结构）")])]),t._v(" "),a("li",[a("p",[a("code",[t._v("addJsonParam(Map params)")]),t._v(" 添加Json参数：请求体为Json（支持多层结构）")])]),t._v(" "),a("li",[a("p",[a("code",[t._v("setRequestJson(Object json)")]),t._v(" 设置请求体的Json字符串 或待转换为 Json的 JavaBean")])]),t._v(" "),a("li",[a("p",[a("code",[t._v("setRequestJson(Object bean, String dateFormat)")]),t._v(" 设置请求体的Json字符串 或待转换为 Json的 JavaBean")])]),t._v(" "),a("li",[a("p",[a("code",[t._v("addFileParam(String name, String filePath)")]),t._v(" 上传文件")])]),t._v(" "),a("li",[a("p",[a("code",[t._v("addFileParam(String name, File file)")]),t._v(" 上传文件")])]),t._v(" "),a("li",[a("p",[a("code",[t._v("addFileParam(String name, String type, InputStream inputStream)")]),t._v(" 上传文件")])]),t._v(" "),a("li",[a("p",[a("code",[t._v("addFileParam(String name, String type, String fileName, InputStream input)")]),t._v(" 上传文件")])]),t._v(" "),a("li",[a("p",[a("code",[t._v("addFileParam(String name, String type, byte[] content)")]),t._v(" 上传文件")])]),t._v(" "),a("li",[a("p",[a("code",[t._v("addFileParam(String name, String type, String fileName, byte[] content)")]),t._v(" 上传文件")])]),t._v(" "),a("li",[a("p",[a("code",[t._v("setTag(String tag)")]),t._v(" 为HTTP任务添加标签")])]),t._v(" "),a("li",[a("p",[a("code",[t._v("setRange(long rangeStart)")]),t._v(" 设置Range头信息，用于"),a("RouterLink",{attrs:{to:"/guide/updown.html#实现断点续传"}},[t._v("断点续传")])],1)]),t._v(" "),a("li",[a("p",[a("code",[t._v("setRange(long rangeStart, long rangeEnd)")]),t._v(" 设置Range头信息，可用于"),a("RouterLink",{attrs:{to:"/guide/updown.html#实现分块下载"}},[t._v("分块下载")])],1)]),t._v(" "),a("li",[a("p",[a("code",[t._v("bind(Object object)")]),t._v(" 绑定一个对象，可用于实现Android里的"),a("RouterLink",{attrs:{to:"/guide/android.html#生命周期绑定"}},[t._v("生命周期绑定")])],1)])]),t._v(" "),a("h2",{attrs:{id:"使用标签"}},[a("a",{staticClass:"header-anchor",attrs:{href:"#使用标签"}},[t._v("#")]),t._v(" 使用标签")]),t._v(" "),a("p",[t._v("有时候我们想对HTTP任务加以分类，这时候可以使用标签功能：")]),t._v(" "),a("div",{staticClass:"language-java line-numbers-mode"},[a("pre",{pre:!0,attrs:{class:"language-java"}},[a("code",[t._v("http"),a("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v(".")]),a("span",{pre:!0,attrs:{class:"token function"}},[t._v("async")]),a("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v("(")]),a("span",{pre:!0,attrs:{class:"token string"}},[t._v('"/users"')]),a("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v(")")]),t._v(" "),a("span",{pre:!0,attrs:{class:"token comment"}},[t._v("//（1）")]),t._v("\n "),a("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v(".")]),a("span",{pre:!0,attrs:{class:"token function"}},[t._v("setTag")]),a("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v("(")]),a("span",{pre:!0,attrs:{class:"token string"}},[t._v('"A"')]),a("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v(")")]),t._v("\n "),a("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v(".")]),a("span",{pre:!0,attrs:{class:"token function"}},[t._v("get")]),a("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v("(")]),a("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v(")")]),a("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v(";")]),t._v("\n \nhttp"),a("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v(".")]),a("span",{pre:!0,attrs:{class:"token function"}},[t._v("async")]),a("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v("(")]),a("span",{pre:!0,attrs:{class:"token string"}},[t._v('"/users"')]),a("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v(")")]),t._v(" "),a("span",{pre:!0,attrs:{class:"token comment"}},[t._v("//（2）")]),t._v("\n "),a("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v(".")]),a("span",{pre:!0,attrs:{class:"token function"}},[t._v("setTag")]),a("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v("(")]),a("span",{pre:!0,attrs:{class:"token string"}},[t._v('"A.B"')]),a("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v(")")]),t._v("\n "),a("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v(".")]),a("span",{pre:!0,attrs:{class:"token function"}},[t._v("get")]),a("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v("(")]),a("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v(")")]),a("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v(";")]),t._v("\n \nhttp"),a("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v(".")]),a("span",{pre:!0,attrs:{class:"token function"}},[t._v("async")]),a("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v("(")]),a("span",{pre:!0,attrs:{class:"token string"}},[t._v('"/users"')]),a("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v(")")]),t._v(" "),a("span",{pre:!0,attrs:{class:"token comment"}},[t._v("//（3）")]),t._v("\n "),a("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v(".")]),a("span",{pre:!0,attrs:{class:"token function"}},[t._v("setTag")]),a("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v("(")]),a("span",{pre:!0,attrs:{class:"token string"}},[t._v('"B"')]),a("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v(")")]),t._v("\n "),a("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v(".")]),a("span",{pre:!0,attrs:{class:"token function"}},[t._v("get")]),a("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v("(")]),a("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v(")")]),a("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v(";")]),t._v("\n \nhttp"),a("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v(".")]),a("span",{pre:!0,attrs:{class:"token function"}},[t._v("async")]),a("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v("(")]),a("span",{pre:!0,attrs:{class:"token string"}},[t._v('"/users"')]),a("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v(")")]),t._v(" "),a("span",{pre:!0,attrs:{class:"token comment"}},[t._v("//（4）")]),t._v("\n "),a("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v(".")]),a("span",{pre:!0,attrs:{class:"token function"}},[t._v("setTag")]),a("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v("(")]),a("span",{pre:!0,attrs:{class:"token string"}},[t._v('"B"')]),a("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v(")")]),t._v("\n "),a("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v(".")]),a("span",{pre:!0,attrs:{class:"token function"}},[t._v("setTag")]),a("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v("(")]),a("span",{pre:!0,attrs:{class:"token string"}},[t._v('"C"')]),a("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v(")")]),t._v(" "),a("span",{pre:!0,attrs:{class:"token comment"}},[t._v('// 从 v1.0.4 标签将以追加模式添加，等效于 setTag("B.C")')]),t._v("\n "),a("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v(".")]),a("span",{pre:!0,attrs:{class:"token function"}},[t._v("get")]),a("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v("(")]),a("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v(")")]),a("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v(";")]),t._v("\n \nhttp"),a("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v(".")]),a("span",{pre:!0,attrs:{class:"token function"}},[t._v("async")]),a("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v("(")]),a("span",{pre:!0,attrs:{class:"token string"}},[t._v('"/users"')]),a("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v(")")]),t._v(" "),a("span",{pre:!0,attrs:{class:"token comment"}},[t._v("//（5）")]),t._v("\n "),a("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v(".")]),a("span",{pre:!0,attrs:{class:"token function"}},[t._v("setTag")]),a("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v("(")]),a("span",{pre:!0,attrs:{class:"token string"}},[t._v('"C"')]),a("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v(")")]),t._v("\n "),a("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v(".")]),a("span",{pre:!0,attrs:{class:"token function"}},[t._v("get")]),a("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v("(")]),a("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v(")")]),a("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v(";")]),t._v("\n")])]),t._v(" "),a("div",{staticClass:"line-numbers-wrapper"},[a("span",{staticClass:"line-number"},[t._v("1")]),a("br"),a("span",{staticClass:"line-number"},[t._v("2")]),a("br"),a("span",{staticClass:"line-number"},[t._v("3")]),a("br"),a("span",{staticClass:"line-number"},[t._v("4")]),a("br"),a("span",{staticClass:"line-number"},[t._v("5")]),a("br"),a("span",{staticClass:"line-number"},[t._v("6")]),a("br"),a("span",{staticClass:"line-number"},[t._v("7")]),a("br"),a("span",{staticClass:"line-number"},[t._v("8")]),a("br"),a("span",{staticClass:"line-number"},[t._v("9")]),a("br"),a("span",{staticClass:"line-number"},[t._v("10")]),a("br"),a("span",{staticClass:"line-number"},[t._v("11")]),a("br"),a("span",{staticClass:"line-number"},[t._v("12")]),a("br"),a("span",{staticClass:"line-number"},[t._v("13")]),a("br"),a("span",{staticClass:"line-number"},[t._v("14")]),a("br"),a("span",{staticClass:"line-number"},[t._v("15")]),a("br"),a("span",{staticClass:"line-number"},[t._v("16")]),a("br"),a("span",{staticClass:"line-number"},[t._v("17")]),a("br"),a("span",{staticClass:"line-number"},[t._v("18")]),a("br"),a("span",{staticClass:"line-number"},[t._v("19")]),a("br"),a("span",{staticClass:"line-number"},[t._v("20")]),a("br")])]),a("p",[t._v("当使用标签后，就可以按标签批量的对HTTP任务进行取消：")]),t._v(" "),a("div",{staticClass:"language-java line-numbers-mode"},[a("pre",{pre:!0,attrs:{class:"language-java"}},[a("code",[a("span",{pre:!0,attrs:{class:"token keyword"}},[t._v("int")]),t._v(" count "),a("span",{pre:!0,attrs:{class:"token operator"}},[t._v("=")]),t._v(" http"),a("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v(".")]),a("span",{pre:!0,attrs:{class:"token function"}},[t._v("cancel")]),a("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v("(")]),a("span",{pre:!0,attrs:{class:"token string"}},[t._v('"B"')]),a("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v(")")]),a("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v(";")]),t._v(" "),a("span",{pre:!0,attrs:{class:"token comment"}},[t._v('//（2）（3）（4）被取消（取消标签包含"B"的任务）')]),t._v("\n"),a("span",{pre:!0,attrs:{class:"token class-name"}},[t._v("System")]),a("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v(".")]),t._v("out"),a("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v(".")]),a("span",{pre:!0,attrs:{class:"token function"}},[t._v("println")]),a("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v("(")]),t._v("count"),a("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v(")")]),a("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v(";")]),t._v(" "),a("span",{pre:!0,attrs:{class:"token comment"}},[t._v("// 输出 3")]),t._v("\n")])]),t._v(" "),a("div",{staticClass:"line-numbers-wrapper"},[a("span",{staticClass:"line-number"},[t._v("1")]),a("br"),a("span",{staticClass:"line-number"},[t._v("2")]),a("br")])]),a("p",[t._v("标签除了可以用来取消任务，在预处理器中它也可以发挥作用，请参见 "),a("RouterLink",{attrs:{to:"/guide/configuration.html#并行预处理器"}},[t._v("并行预处理器")]),t._v(" 与 "),a("RouterLink",{attrs:{to:"/guide/configuration.html#串行预处理器（token问题最佳解决方案）"}},[t._v("串行预处理器（token问题最佳解决方案）")]),t._v("。")],1)])}),[],!1,null,null,null);s.default=e.exports}}]); \ No newline at end of file diff --git a/okhttps-doc/docs/.vuepress/dist/assets/js/12.92e24a16.js b/okhttps-doc/docs/.vuepress/dist/assets/js/12.92e24a16.js new file mode 100644 index 00000000..e954337f --- /dev/null +++ b/okhttps-doc/docs/.vuepress/dist/assets/js/12.92e24a16.js @@ -0,0 +1 @@ +(window.webpackJsonp=window.webpackJsonp||[]).push([[12],{332:function(t,s,a){"use strict";a.r(s);var n=a(19),e=Object(n.a)({},(function(){var t=this,s=t.$createElement,a=t._self._c||s;return a("ContentSlotsDistributor",{attrs:{"slot-key":t.$parent.slotKey}},[a("h1",{attrs:{id:"上传下载"}},[a("a",{staticClass:"header-anchor",attrs:{href:"#上传下载"}},[t._v("#")]),t._v(" 上传下载")]),t._v(" "),a("h2",{attrs:{id:"文件下载"}},[a("a",{staticClass:"header-anchor",attrs:{href:"#文件下载"}},[t._v("#")]),t._v(" 文件下载")]),t._v(" "),a("p",[t._v("OkHttps 并没有把文件的下载排除在常规的请求之外，同一套API，它优雅的设计使得下载与常规请求融合的毫无违和感，一个最简单的示例：")]),t._v(" "),a("div",{staticClass:"language-java line-numbers-mode"},[a("pre",{pre:!0,attrs:{class:"language-java"}},[a("code",[t._v("http"),a("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v(".")]),a("span",{pre:!0,attrs:{class:"token function"}},[t._v("sync")]),a("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v("(")]),a("span",{pre:!0,attrs:{class:"token string"}},[t._v('"/download/test.zip"')]),a("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v(")")]),t._v("\n "),a("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v(".")]),a("span",{pre:!0,attrs:{class:"token function"}},[t._v("get")]),a("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v("(")]),a("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v(")")]),t._v(" "),a("span",{pre:!0,attrs:{class:"token comment"}},[t._v("// 使用 GET 方法（其它方法也可以，看服务器支持）")]),t._v("\n "),a("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v(".")]),a("span",{pre:!0,attrs:{class:"token function"}},[t._v("getBody")]),a("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v("(")]),a("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v(")")]),t._v(" "),a("span",{pre:!0,attrs:{class:"token comment"}},[t._v("// 得到报文体")]),t._v("\n "),a("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v(".")]),a("span",{pre:!0,attrs:{class:"token function"}},[t._v("toFile")]),a("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v("(")]),a("span",{pre:!0,attrs:{class:"token string"}},[t._v('"D:/download/test.zip"')]),a("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v(")")]),t._v(" "),a("span",{pre:!0,attrs:{class:"token comment"}},[t._v("// 下载到指定的路径")]),t._v("\n "),a("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v(".")]),a("span",{pre:!0,attrs:{class:"token function"}},[t._v("start")]),a("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v("(")]),a("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v(")")]),a("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v(";")]),t._v(" "),a("span",{pre:!0,attrs:{class:"token comment"}},[t._v("// 启动下载")]),t._v("\n\nhttp"),a("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v(".")]),a("span",{pre:!0,attrs:{class:"token function"}},[t._v("sync")]),a("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v("(")]),a("span",{pre:!0,attrs:{class:"token string"}},[t._v('"/download/test.zip"')]),a("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v(")")]),a("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v(".")]),a("span",{pre:!0,attrs:{class:"token function"}},[t._v("get")]),a("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v("(")]),a("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v(")")]),a("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v(".")]),a("span",{pre:!0,attrs:{class:"token function"}},[t._v("getBody")]),a("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v("(")]),a("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v(")")]),t._v(" \n "),a("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v(".")]),a("span",{pre:!0,attrs:{class:"token function"}},[t._v("toFolder")]),a("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v("(")]),a("span",{pre:!0,attrs:{class:"token string"}},[t._v('"D:/download"')]),a("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v(")")]),t._v(" "),a("span",{pre:!0,attrs:{class:"token comment"}},[t._v("// 下载到指定的目录，文件名将根据下载信息自动生成")]),t._v("\n "),a("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v(".")]),a("span",{pre:!0,attrs:{class:"token function"}},[t._v("start")]),a("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v("(")]),a("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v(")")]),a("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v(";")]),t._v("\n")])]),t._v(" "),a("div",{staticClass:"line-numbers-wrapper"},[a("span",{staticClass:"line-number"},[t._v("1")]),a("br"),a("span",{staticClass:"line-number"},[t._v("2")]),a("br"),a("span",{staticClass:"line-number"},[t._v("3")]),a("br"),a("span",{staticClass:"line-number"},[t._v("4")]),a("br"),a("span",{staticClass:"line-number"},[t._v("5")]),a("br"),a("span",{staticClass:"line-number"},[t._v("6")]),a("br"),a("span",{staticClass:"line-number"},[t._v("7")]),a("br"),a("span",{staticClass:"line-number"},[t._v("8")]),a("br"),a("span",{staticClass:"line-number"},[t._v("9")]),a("br")])]),a("p",[t._v("或使用异步连接方式：")]),t._v(" "),a("div",{staticClass:"language-java line-numbers-mode"},[a("pre",{pre:!0,attrs:{class:"language-java"}},[a("code",[t._v("http"),a("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v(".")]),a("span",{pre:!0,attrs:{class:"token function"}},[t._v("async")]),a("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v("(")]),a("span",{pre:!0,attrs:{class:"token string"}},[t._v('"/download/test.zip"')]),a("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v(")")]),t._v("\n "),a("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v(".")]),a("span",{pre:!0,attrs:{class:"token function"}},[t._v("setOnResponse")]),a("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v("(")]),a("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v("(")]),a("span",{pre:!0,attrs:{class:"token class-name"}},[t._v("HttpResult")]),t._v(" result"),a("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v(")")]),t._v(" "),a("span",{pre:!0,attrs:{class:"token operator"}},[t._v("->")]),t._v(" "),a("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v("{")]),t._v("\n result"),a("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v(".")]),a("span",{pre:!0,attrs:{class:"token function"}},[t._v("getBody")]),a("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v("(")]),a("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v(")")]),a("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v(".")]),a("span",{pre:!0,attrs:{class:"token function"}},[t._v("toFolder")]),a("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v("(")]),a("span",{pre:!0,attrs:{class:"token string"}},[t._v('"D:/download"')]),a("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v(")")]),a("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v(".")]),a("span",{pre:!0,attrs:{class:"token function"}},[t._v("start")]),a("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v("(")]),a("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v(")")]),a("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v(";")]),t._v("\n "),a("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v("}")]),a("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v(")")]),t._v("\n "),a("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v(".")]),a("span",{pre:!0,attrs:{class:"token function"}},[t._v("get")]),a("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v("(")]),a("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v(")")]),a("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v(";")]),t._v("\n")])]),t._v(" "),a("div",{staticClass:"line-numbers-wrapper"},[a("span",{staticClass:"line-number"},[t._v("1")]),a("br"),a("span",{staticClass:"line-number"},[t._v("2")]),a("br"),a("span",{staticClass:"line-number"},[t._v("3")]),a("br"),a("span",{staticClass:"line-number"},[t._v("4")]),a("br"),a("span",{staticClass:"line-number"},[t._v("5")]),a("br")])]),a("p",[t._v("这里要说明一下："),a("code",[t._v("sync")]),t._v("与"),a("code",[t._v("async")]),t._v("的区别在于连接服务器并得到响应这个过程的同步与异步（这个过程的耗时在大文件下载中占比极小），而"),a("code",[t._v("start")]),t._v("方法启动的下载过程则都是异步的。")]),t._v(" "),a("h3",{attrs:{id:"下载进度监听"}},[a("a",{staticClass:"header-anchor",attrs:{href:"#下载进度监听"}},[t._v("#")]),t._v(" 下载进度监听")]),t._v(" "),a("p",[t._v("就直接上代码啦，诸君一看便懂：")]),t._v(" "),a("div",{staticClass:"language-java line-numbers-mode"},[a("pre",{pre:!0,attrs:{class:"language-java"}},[a("code",[t._v("http"),a("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v(".")]),a("span",{pre:!0,attrs:{class:"token function"}},[t._v("sync")]),a("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v("(")]),a("span",{pre:!0,attrs:{class:"token string"}},[t._v('"/download/test.zip"')]),a("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v(")")]),t._v("\n "),a("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v(".")]),a("span",{pre:!0,attrs:{class:"token function"}},[t._v("get")]),a("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v("(")]),a("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v(")")]),t._v("\n "),a("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v(".")]),a("span",{pre:!0,attrs:{class:"token function"}},[t._v("getBody")]),a("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v("(")]),a("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v(")")]),t._v("\n "),a("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v(".")]),a("span",{pre:!0,attrs:{class:"token function"}},[t._v("setStepBytes")]),a("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v("(")]),a("span",{pre:!0,attrs:{class:"token number"}},[t._v("1024")]),a("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v(")")]),t._v(" "),a("span",{pre:!0,attrs:{class:"token comment"}},[t._v("// 设置每接收 1024 个字节执行一次进度回调（不设置默认为 8192） ")]),t._v("\n "),a("span",{pre:!0,attrs:{class:"token comment"}},[t._v("// .setStepRate(0.01) // 设置每接收 1% 执行一次进度回调（不设置以 StepBytes 为准） ")]),t._v("\n "),a("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v(".")]),a("span",{pre:!0,attrs:{class:"token function"}},[t._v("setOnProcess")]),a("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v("(")]),a("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v("(")]),a("span",{pre:!0,attrs:{class:"token class-name"}},[t._v("Process")]),t._v(" process"),a("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v(")")]),t._v(" "),a("span",{pre:!0,attrs:{class:"token operator"}},[t._v("->")]),t._v(" "),a("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v("{")]),t._v(" "),a("span",{pre:!0,attrs:{class:"token comment"}},[t._v("// 下载进度回调")]),t._v("\n "),a("span",{pre:!0,attrs:{class:"token keyword"}},[t._v("long")]),t._v(" doneBytes "),a("span",{pre:!0,attrs:{class:"token operator"}},[t._v("=")]),t._v(" process"),a("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v(".")]),a("span",{pre:!0,attrs:{class:"token function"}},[t._v("getDoneBytes")]),a("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v("(")]),a("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v(")")]),a("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v(";")]),t._v(" "),a("span",{pre:!0,attrs:{class:"token comment"}},[t._v("// 已下载字节数")]),t._v("\n "),a("span",{pre:!0,attrs:{class:"token keyword"}},[t._v("long")]),t._v(" totalBytes "),a("span",{pre:!0,attrs:{class:"token operator"}},[t._v("=")]),t._v(" process"),a("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v(".")]),a("span",{pre:!0,attrs:{class:"token function"}},[t._v("getTotalBytes")]),a("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v("(")]),a("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v(")")]),a("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v(";")]),t._v(" "),a("span",{pre:!0,attrs:{class:"token comment"}},[t._v("// 总共的字节数")]),t._v("\n "),a("span",{pre:!0,attrs:{class:"token keyword"}},[t._v("double")]),t._v(" rate "),a("span",{pre:!0,attrs:{class:"token operator"}},[t._v("=")]),t._v(" process"),a("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v(".")]),a("span",{pre:!0,attrs:{class:"token function"}},[t._v("getRate")]),a("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v("(")]),a("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v(")")]),a("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v(";")]),t._v(" "),a("span",{pre:!0,attrs:{class:"token comment"}},[t._v("// 已下载的比例")]),t._v("\n "),a("span",{pre:!0,attrs:{class:"token keyword"}},[t._v("boolean")]),t._v(" isDone "),a("span",{pre:!0,attrs:{class:"token operator"}},[t._v("=")]),t._v(" process"),a("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v(".")]),a("span",{pre:!0,attrs:{class:"token function"}},[t._v("isDone")]),a("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v("(")]),a("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v(")")]),a("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v(";")]),t._v(" "),a("span",{pre:!0,attrs:{class:"token comment"}},[t._v("// 是否下载完成")]),t._v("\n "),a("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v("}")]),a("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v(")")]),t._v("\n "),a("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v(".")]),a("span",{pre:!0,attrs:{class:"token function"}},[t._v("toFolder")]),a("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v("(")]),a("span",{pre:!0,attrs:{class:"token string"}},[t._v('"D:/download/"')]),a("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v(")")]),t._v(" "),a("span",{pre:!0,attrs:{class:"token comment"}},[t._v("// 指定下载的目录，文件名将根据下载信息自动生成")]),t._v("\n "),a("span",{pre:!0,attrs:{class:"token comment"}},[t._v('// .toFile("D:/download/test.zip") // 指定下载的路径，若文件已存在则覆盖')]),t._v("\n "),a("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v(".")]),a("span",{pre:!0,attrs:{class:"token function"}},[t._v("setOnSuccess")]),a("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v("(")]),a("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v("(")]),a("span",{pre:!0,attrs:{class:"token class-name"}},[t._v("File")]),t._v(" file"),a("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v(")")]),t._v(" "),a("span",{pre:!0,attrs:{class:"token operator"}},[t._v("->")]),t._v(" "),a("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v("{")]),t._v(" "),a("span",{pre:!0,attrs:{class:"token comment"}},[t._v("// 下载成功回调")]),t._v("\n \n "),a("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v("}")]),a("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v(")")]),t._v("\n "),a("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v(".")]),a("span",{pre:!0,attrs:{class:"token function"}},[t._v("start")]),a("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v("(")]),a("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v(")")]),a("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v(";")]),t._v("\n")])]),t._v(" "),a("div",{staticClass:"line-numbers-wrapper"},[a("span",{staticClass:"line-number"},[t._v("1")]),a("br"),a("span",{staticClass:"line-number"},[t._v("2")]),a("br"),a("span",{staticClass:"line-number"},[t._v("3")]),a("br"),a("span",{staticClass:"line-number"},[t._v("4")]),a("br"),a("span",{staticClass:"line-number"},[t._v("5")]),a("br"),a("span",{staticClass:"line-number"},[t._v("6")]),a("br"),a("span",{staticClass:"line-number"},[t._v("7")]),a("br"),a("span",{staticClass:"line-number"},[t._v("8")]),a("br"),a("span",{staticClass:"line-number"},[t._v("9")]),a("br"),a("span",{staticClass:"line-number"},[t._v("10")]),a("br"),a("span",{staticClass:"line-number"},[t._v("11")]),a("br"),a("span",{staticClass:"line-number"},[t._v("12")]),a("br"),a("span",{staticClass:"line-number"},[t._v("13")]),a("br"),a("span",{staticClass:"line-number"},[t._v("14")]),a("br"),a("span",{staticClass:"line-number"},[t._v("15")]),a("br"),a("span",{staticClass:"line-number"},[t._v("16")]),a("br"),a("span",{staticClass:"line-number"},[t._v("17")]),a("br")])]),a("p",[t._v("值得一提的是：由于 OkHttps 并没有把下载做的很特别，这里设置的进度回调不只对下载文件起用作，即使对响应JSON的常规请求，只要设置了进度回调，它也会告诉你报文接收的进度（提前是服务器响应的报文有"),a("code",[t._v("Content-Length")]),t._v("头），例如：")]),t._v(" "),a("div",{staticClass:"language-java line-numbers-mode"},[a("pre",{pre:!0,attrs:{class:"language-java"}},[a("code",[a("span",{pre:!0,attrs:{class:"token class-name"}},[t._v("List")]),a("span",{pre:!0,attrs:{class:"token generics"}},[a("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v("<")]),a("span",{pre:!0,attrs:{class:"token class-name"}},[t._v("User")]),a("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v(">")])]),t._v(" users "),a("span",{pre:!0,attrs:{class:"token operator"}},[t._v("=")]),t._v(" http"),a("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v(".")]),a("span",{pre:!0,attrs:{class:"token function"}},[t._v("sync")]),a("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v("(")]),a("span",{pre:!0,attrs:{class:"token string"}},[t._v('"/users"')]),a("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v(")")]),t._v("\n "),a("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v(".")]),a("span",{pre:!0,attrs:{class:"token function"}},[t._v("get")]),a("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v("(")]),a("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v(")")]),t._v("\n "),a("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v(".")]),a("span",{pre:!0,attrs:{class:"token function"}},[t._v("getBody")]),a("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v("(")]),a("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v(")")]),t._v("\n "),a("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v(".")]),a("span",{pre:!0,attrs:{class:"token function"}},[t._v("setStepBytes")]),a("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v("(")]),a("span",{pre:!0,attrs:{class:"token number"}},[t._v("2")]),a("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v(")")]),t._v("\n "),a("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v(".")]),a("span",{pre:!0,attrs:{class:"token function"}},[t._v("setOnProcess")]),a("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v("(")]),a("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v("(")]),a("span",{pre:!0,attrs:{class:"token class-name"}},[t._v("Process")]),t._v(" process"),a("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v(")")]),t._v(" "),a("span",{pre:!0,attrs:{class:"token operator"}},[t._v("->")]),t._v(" "),a("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v("{")]),t._v("\n "),a("span",{pre:!0,attrs:{class:"token class-name"}},[t._v("System")]),a("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v(".")]),t._v("out"),a("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v(".")]),a("span",{pre:!0,attrs:{class:"token function"}},[t._v("println")]),a("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v("(")]),t._v("process"),a("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v(".")]),a("span",{pre:!0,attrs:{class:"token function"}},[t._v("getRate")]),a("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v("(")]),a("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v(")")]),a("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v(")")]),a("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v(";")]),t._v("\n "),a("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v("}")]),a("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v(")")]),t._v("\n "),a("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v(".")]),a("span",{pre:!0,attrs:{class:"token function"}},[t._v("toList")]),a("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v("(")]),a("span",{pre:!0,attrs:{class:"token class-name"}},[t._v("User")]),a("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v(".")]),a("span",{pre:!0,attrs:{class:"token keyword"}},[t._v("class")]),a("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v(")")]),a("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v(";")]),t._v("\n")])]),t._v(" "),a("div",{staticClass:"line-numbers-wrapper"},[a("span",{staticClass:"line-number"},[t._v("1")]),a("br"),a("span",{staticClass:"line-number"},[t._v("2")]),a("br"),a("span",{staticClass:"line-number"},[t._v("3")]),a("br"),a("span",{staticClass:"line-number"},[t._v("4")]),a("br"),a("span",{staticClass:"line-number"},[t._v("5")]),a("br"),a("span",{staticClass:"line-number"},[t._v("6")]),a("br"),a("span",{staticClass:"line-number"},[t._v("7")]),a("br"),a("span",{staticClass:"line-number"},[t._v("8")]),a("br")])]),a("h3",{attrs:{id:"下载过程控制"}},[a("a",{staticClass:"header-anchor",attrs:{href:"#下载过程控制"}},[t._v("#")]),t._v(" 下载过程控制")]),t._v(" "),a("p",[t._v("过于简单：还是直接上代码：")]),t._v(" "),a("div",{staticClass:"language-java line-numbers-mode"},[a("pre",{pre:!0,attrs:{class:"language-java"}},[a("code",[a("span",{pre:!0,attrs:{class:"token class-name"}},[t._v("Ctrl")]),t._v(" ctrl "),a("span",{pre:!0,attrs:{class:"token operator"}},[t._v("=")]),t._v(" http"),a("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v(".")]),a("span",{pre:!0,attrs:{class:"token function"}},[t._v("sync")]),a("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v("(")]),a("span",{pre:!0,attrs:{class:"token string"}},[t._v('"/download/test.zip"')]),a("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v(")")]),t._v("\n "),a("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v(".")]),a("span",{pre:!0,attrs:{class:"token function"}},[t._v("get")]),a("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v("(")]),a("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v(")")]),t._v("\n "),a("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v(".")]),a("span",{pre:!0,attrs:{class:"token function"}},[t._v("getBody")]),a("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v("(")]),a("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v(")")]),t._v("\n "),a("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v(".")]),a("span",{pre:!0,attrs:{class:"token function"}},[t._v("setOnProcess")]),a("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v("(")]),a("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v("(")]),a("span",{pre:!0,attrs:{class:"token class-name"}},[t._v("Process")]),t._v(" process"),a("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v(")")]),t._v(" "),a("span",{pre:!0,attrs:{class:"token operator"}},[t._v("->")]),t._v(" "),a("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v("{")]),t._v("\n "),a("span",{pre:!0,attrs:{class:"token class-name"}},[t._v("System")]),a("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v(".")]),t._v("out"),a("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v(".")]),a("span",{pre:!0,attrs:{class:"token function"}},[t._v("println")]),a("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v("(")]),t._v("process"),a("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v(".")]),a("span",{pre:!0,attrs:{class:"token function"}},[t._v("getRate")]),a("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v("(")]),a("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v(")")]),a("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v(")")]),a("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v(";")]),t._v("\n "),a("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v("}")]),a("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v(")")]),t._v("\n "),a("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v(".")]),a("span",{pre:!0,attrs:{class:"token function"}},[t._v("toFolder")]),a("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v("(")]),a("span",{pre:!0,attrs:{class:"token string"}},[t._v('"D:/download/"')]),a("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v(")")]),t._v("\n "),a("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v(".")]),a("span",{pre:!0,attrs:{class:"token function"}},[t._v("start")]),a("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v("(")]),a("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v(")")]),a("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v(";")]),t._v(" "),a("span",{pre:!0,attrs:{class:"token comment"}},[t._v("// 该方法返回一个下载过程控制器")]),t._v("\n \nctrl"),a("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v(".")]),a("span",{pre:!0,attrs:{class:"token function"}},[t._v("status")]),a("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v("(")]),a("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v(")")]),a("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v(";")]),t._v(" "),a("span",{pre:!0,attrs:{class:"token comment"}},[t._v("// 下载状态")]),t._v("\nctrl"),a("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v(".")]),a("span",{pre:!0,attrs:{class:"token function"}},[t._v("pause")]),a("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v("(")]),a("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v(")")]),a("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v(";")]),t._v(" "),a("span",{pre:!0,attrs:{class:"token comment"}},[t._v("// 暂停下载")]),t._v("\nctrl"),a("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v(".")]),a("span",{pre:!0,attrs:{class:"token function"}},[t._v("resume")]),a("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v("(")]),a("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v(")")]),a("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v(";")]),t._v(" "),a("span",{pre:!0,attrs:{class:"token comment"}},[t._v("// 恢复下载")]),t._v("\nctrl"),a("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v(".")]),a("span",{pre:!0,attrs:{class:"token function"}},[t._v("cancel")]),a("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v("(")]),a("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v(")")]),a("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v(";")]),t._v(" "),a("span",{pre:!0,attrs:{class:"token comment"}},[t._v("// 取消下载（同时会删除文件，不可恢复）")]),t._v("\n")])]),t._v(" "),a("div",{staticClass:"line-numbers-wrapper"},[a("span",{staticClass:"line-number"},[t._v("1")]),a("br"),a("span",{staticClass:"line-number"},[t._v("2")]),a("br"),a("span",{staticClass:"line-number"},[t._v("3")]),a("br"),a("span",{staticClass:"line-number"},[t._v("4")]),a("br"),a("span",{staticClass:"line-number"},[t._v("5")]),a("br"),a("span",{staticClass:"line-number"},[t._v("6")]),a("br"),a("span",{staticClass:"line-number"},[t._v("7")]),a("br"),a("span",{staticClass:"line-number"},[t._v("8")]),a("br"),a("span",{staticClass:"line-number"},[t._v("9")]),a("br"),a("span",{staticClass:"line-number"},[t._v("10")]),a("br"),a("span",{staticClass:"line-number"},[t._v("11")]),a("br"),a("span",{staticClass:"line-number"},[t._v("12")]),a("br"),a("span",{staticClass:"line-number"},[t._v("13")]),a("br")])]),a("p",[t._v("无论是同步还是异步发起的下载请求，都可以做以上的控制：")]),t._v(" "),a("div",{staticClass:"language-java line-numbers-mode"},[a("pre",{pre:!0,attrs:{class:"language-java"}},[a("code",[t._v("http"),a("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v(".")]),a("span",{pre:!0,attrs:{class:"token function"}},[t._v("async")]),a("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v("(")]),a("span",{pre:!0,attrs:{class:"token string"}},[t._v('"/download/test.zip"')]),a("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v(")")]),t._v("\n "),a("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v(".")]),a("span",{pre:!0,attrs:{class:"token function"}},[t._v("setOnResponse")]),a("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v("(")]),a("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v("(")]),a("span",{pre:!0,attrs:{class:"token class-name"}},[t._v("HttpResult")]),t._v(" result"),a("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v(")")]),t._v(" "),a("span",{pre:!0,attrs:{class:"token operator"}},[t._v("->")]),t._v(" "),a("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v("{")]),t._v("\n "),a("span",{pre:!0,attrs:{class:"token comment"}},[t._v("// 拿到下载控制器")]),t._v("\n "),a("span",{pre:!0,attrs:{class:"token class-name"}},[t._v("Ctrl")]),t._v(" ctrl "),a("span",{pre:!0,attrs:{class:"token operator"}},[t._v("=")]),t._v(" result"),a("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v(".")]),a("span",{pre:!0,attrs:{class:"token function"}},[t._v("getBody")]),a("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v("(")]),a("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v(")")]),a("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v(".")]),a("span",{pre:!0,attrs:{class:"token function"}},[t._v("toFolder")]),a("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v("(")]),a("span",{pre:!0,attrs:{class:"token string"}},[t._v('"D:/download/"')]),a("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v(")")]),a("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v(".")]),a("span",{pre:!0,attrs:{class:"token function"}},[t._v("start")]),a("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v("(")]),a("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v(")")]),a("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v(";")]),t._v("\n "),a("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v("}")]),a("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v(")")]),t._v("\n "),a("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v(".")]),a("span",{pre:!0,attrs:{class:"token function"}},[t._v("get")]),a("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v("(")]),a("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v(")")]),a("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v(";")]),t._v("\n")])]),t._v(" "),a("div",{staticClass:"line-numbers-wrapper"},[a("span",{staticClass:"line-number"},[t._v("1")]),a("br"),a("span",{staticClass:"line-number"},[t._v("2")]),a("br"),a("span",{staticClass:"line-number"},[t._v("3")]),a("br"),a("span",{staticClass:"line-number"},[t._v("4")]),a("br"),a("span",{staticClass:"line-number"},[t._v("5")]),a("br"),a("span",{staticClass:"line-number"},[t._v("6")]),a("br")])]),a("h3",{attrs:{id:"实现断点续传"}},[a("a",{staticClass:"header-anchor",attrs:{href:"#实现断点续传"}},[t._v("#")]),t._v(" 实现断点续传")]),t._v(" "),a("p",[t._v("OkHttps 对断点续传并没有再做更高层次的封装，因为这是app该去做的事情，它在设计上使各种网络问题的处理变简单的同时力求纯粹。下面的例子可以看到，OkHttps 通过一个失败回调拿到 "),a("strong",[t._v("断点")]),t._v("，便将复杂的问题变得简单：")]),t._v(" "),a("div",{staticClass:"language-java line-numbers-mode"},[a("pre",{pre:!0,attrs:{class:"language-java"}},[a("code",[t._v("http"),a("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v(".")]),a("span",{pre:!0,attrs:{class:"token function"}},[t._v("sync")]),a("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v("(")]),a("span",{pre:!0,attrs:{class:"token string"}},[t._v('"/download/test.zip"')]),a("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v(")")]),t._v("\n "),a("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v(".")]),a("span",{pre:!0,attrs:{class:"token function"}},[t._v("get")]),a("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v("(")]),a("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v(")")]),t._v("\n "),a("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v(".")]),a("span",{pre:!0,attrs:{class:"token function"}},[t._v("getBody")]),a("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v("(")]),a("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v(")")]),t._v("\n "),a("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v(".")]),a("span",{pre:!0,attrs:{class:"token function"}},[t._v("toFolder")]),a("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v("(")]),a("span",{pre:!0,attrs:{class:"token string"}},[t._v('"D:/download/"')]),a("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v(")")]),t._v("\n "),a("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v(".")]),a("span",{pre:!0,attrs:{class:"token function"}},[t._v("setOnFailure")]),a("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v("(")]),a("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v("(")]),a("span",{pre:!0,attrs:{class:"token class-name"}},[t._v("Failure")]),t._v(" failure"),a("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v(")")]),t._v(" "),a("span",{pre:!0,attrs:{class:"token operator"}},[t._v("->")]),t._v(" "),a("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v("{")]),t._v(" "),a("span",{pre:!0,attrs:{class:"token comment"}},[t._v("// 下载失败回调，以便接收诸如网络错误等失败信息")]),t._v("\n "),a("span",{pre:!0,attrs:{class:"token class-name"}},[t._v("IOException")]),t._v(" e "),a("span",{pre:!0,attrs:{class:"token operator"}},[t._v("=")]),t._v(" failure"),a("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v(".")]),a("span",{pre:!0,attrs:{class:"token function"}},[t._v("getException")]),a("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v("(")]),a("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v(")")]),a("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v(";")]),t._v(" "),a("span",{pre:!0,attrs:{class:"token comment"}},[t._v("// 具体的异常信息")]),t._v("\n "),a("span",{pre:!0,attrs:{class:"token keyword"}},[t._v("long")]),t._v(" doneBytes "),a("span",{pre:!0,attrs:{class:"token operator"}},[t._v("=")]),t._v(" failure"),a("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v(".")]),a("span",{pre:!0,attrs:{class:"token function"}},[t._v("getDoneBytes")]),a("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v("(")]),a("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v(")")]),a("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v(";")]),t._v(" "),a("span",{pre:!0,attrs:{class:"token comment"}},[t._v("// 已下载的字节数（断点），需要保存，用于断点续传")]),t._v("\n "),a("span",{pre:!0,attrs:{class:"token class-name"}},[t._v("File")]),t._v(" file "),a("span",{pre:!0,attrs:{class:"token operator"}},[t._v("=")]),t._v(" failure"),a("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v(".")]),a("span",{pre:!0,attrs:{class:"token function"}},[t._v("getFile")]),a("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v("(")]),a("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v(")")]),a("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v(";")]),t._v(" "),a("span",{pre:!0,attrs:{class:"token comment"}},[t._v("// 下载生成的文件，需要保存 ，用于断点续传（只保存路径也可以）")]),t._v("\n "),a("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v("}")]),a("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v(")")]),t._v("\n "),a("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v(".")]),a("span",{pre:!0,attrs:{class:"token function"}},[t._v("start")]),a("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v("(")]),a("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v(")")]),a("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v(";")]),t._v("\n")])]),t._v(" "),a("div",{staticClass:"line-numbers-wrapper"},[a("span",{staticClass:"line-number"},[t._v("1")]),a("br"),a("span",{staticClass:"line-number"},[t._v("2")]),a("br"),a("span",{staticClass:"line-number"},[t._v("3")]),a("br"),a("span",{staticClass:"line-number"},[t._v("4")]),a("br"),a("span",{staticClass:"line-number"},[t._v("5")]),a("br"),a("span",{staticClass:"line-number"},[t._v("6")]),a("br"),a("span",{staticClass:"line-number"},[t._v("7")]),a("br"),a("span",{staticClass:"line-number"},[t._v("8")]),a("br"),a("span",{staticClass:"line-number"},[t._v("9")]),a("br"),a("span",{staticClass:"line-number"},[t._v("10")]),a("br")])]),a("p",[t._v("下面代码实现续传：")]),t._v(" "),a("div",{staticClass:"language-java line-numbers-mode"},[a("pre",{pre:!0,attrs:{class:"language-java"}},[a("code",[a("span",{pre:!0,attrs:{class:"token keyword"}},[t._v("long")]),t._v(" doneBytes "),a("span",{pre:!0,attrs:{class:"token operator"}},[t._v("=")]),t._v(" "),a("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v(".")]),a("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v(".")]),a("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v(".")]),t._v(" "),a("span",{pre:!0,attrs:{class:"token comment"}},[t._v("// 拿到保存的断点")]),t._v("\n"),a("span",{pre:!0,attrs:{class:"token class-name"}},[t._v("File")]),t._v(" file "),a("span",{pre:!0,attrs:{class:"token operator"}},[t._v("=")]),t._v(" "),a("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v(".")]),a("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v(".")]),a("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v(".")]),t._v(" "),a("span",{pre:!0,attrs:{class:"token comment"}},[t._v("// 待续传的文件")]),t._v("\n\nhttp"),a("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v(".")]),a("span",{pre:!0,attrs:{class:"token function"}},[t._v("sync")]),a("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v("(")]),a("span",{pre:!0,attrs:{class:"token string"}},[t._v('"/download/test.zip"')]),a("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v(")")]),t._v("\n "),a("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v(".")]),a("span",{pre:!0,attrs:{class:"token function"}},[t._v("setRange")]),a("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v("(")]),t._v("doneBytes"),a("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v(")")]),t._v(" "),a("span",{pre:!0,attrs:{class:"token comment"}},[t._v("// 设置断点（已下载的字节数）")]),t._v("\n "),a("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v(".")]),a("span",{pre:!0,attrs:{class:"token function"}},[t._v("get")]),a("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v("(")]),a("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v(")")]),t._v("\n "),a("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v(".")]),a("span",{pre:!0,attrs:{class:"token function"}},[t._v("getBody")]),a("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v("(")]),a("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v(")")]),t._v("\n "),a("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v(".")]),a("span",{pre:!0,attrs:{class:"token function"}},[t._v("toFile")]),a("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v("(")]),t._v("file"),a("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v(")")]),t._v(" "),a("span",{pre:!0,attrs:{class:"token comment"}},[t._v("// 下载到同一个文件里")]),t._v("\n "),a("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v(".")]),a("span",{pre:!0,attrs:{class:"token function"}},[t._v("setAppended")]),a("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v("(")]),a("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v(")")]),t._v(" "),a("span",{pre:!0,attrs:{class:"token comment"}},[t._v("// 开启文件追加模式")]),t._v("\n "),a("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v(".")]),a("span",{pre:!0,attrs:{class:"token function"}},[t._v("setOnSuccess")]),a("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v("(")]),a("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v("(")]),a("span",{pre:!0,attrs:{class:"token class-name"}},[t._v("File")]),t._v(" file"),a("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v(")")]),t._v(" "),a("span",{pre:!0,attrs:{class:"token operator"}},[t._v("->")]),t._v(" "),a("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v("{")]),t._v("\n\n "),a("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v("}")]),a("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v(")")]),t._v("\n "),a("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v(".")]),a("span",{pre:!0,attrs:{class:"token function"}},[t._v("setOnFailure")]),a("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v("(")]),a("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v("(")]),a("span",{pre:!0,attrs:{class:"token class-name"}},[t._v("Failure")]),t._v(" failure"),a("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v(")")]),t._v(" "),a("span",{pre:!0,attrs:{class:"token operator"}},[t._v("->")]),t._v(" "),a("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v("{")]),t._v("\n \n "),a("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v("}")]),a("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v(")")]),t._v("\n "),a("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v(".")]),a("span",{pre:!0,attrs:{class:"token function"}},[t._v("start")]),a("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v("(")]),a("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v(")")]),a("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v(";")]),t._v("\n")])]),t._v(" "),a("div",{staticClass:"line-numbers-wrapper"},[a("span",{staticClass:"line-number"},[t._v("1")]),a("br"),a("span",{staticClass:"line-number"},[t._v("2")]),a("br"),a("span",{staticClass:"line-number"},[t._v("3")]),a("br"),a("span",{staticClass:"line-number"},[t._v("4")]),a("br"),a("span",{staticClass:"line-number"},[t._v("5")]),a("br"),a("span",{staticClass:"line-number"},[t._v("6")]),a("br"),a("span",{staticClass:"line-number"},[t._v("7")]),a("br"),a("span",{staticClass:"line-number"},[t._v("8")]),a("br"),a("span",{staticClass:"line-number"},[t._v("9")]),a("br"),a("span",{staticClass:"line-number"},[t._v("10")]),a("br"),a("span",{staticClass:"line-number"},[t._v("11")]),a("br"),a("span",{staticClass:"line-number"},[t._v("12")]),a("br"),a("span",{staticClass:"line-number"},[t._v("13")]),a("br"),a("span",{staticClass:"line-number"},[t._v("14")]),a("br"),a("span",{staticClass:"line-number"},[t._v("15")]),a("br"),a("span",{staticClass:"line-number"},[t._v("16")]),a("br")])]),a("h3",{attrs:{id:"实现分块下载"}},[a("a",{staticClass:"header-anchor",attrs:{href:"#实现分块下载"}},[t._v("#")]),t._v(" 实现分块下载")]),t._v(" "),a("p",[t._v("当文件很大时，有时候我们会考虑分块下载，与断点续传的思路是一样的，示例代码：")]),t._v(" "),a("div",{staticClass:"language-java line-numbers-mode"},[a("pre",{pre:!0,attrs:{class:"language-java"}},[a("code",[a("span",{pre:!0,attrs:{class:"token keyword"}},[t._v("static")]),t._v(" "),a("span",{pre:!0,attrs:{class:"token class-name"}},[t._v("String")]),t._v(" url "),a("span",{pre:!0,attrs:{class:"token operator"}},[t._v("=")]),t._v(" "),a("span",{pre:!0,attrs:{class:"token string"}},[t._v('"http://api.demo.com/download/test.zip"')]),t._v("\n\n"),a("span",{pre:!0,attrs:{class:"token keyword"}},[t._v("public")]),t._v(" "),a("span",{pre:!0,attrs:{class:"token keyword"}},[t._v("static")]),t._v(" "),a("span",{pre:!0,attrs:{class:"token keyword"}},[t._v("void")]),t._v(" "),a("span",{pre:!0,attrs:{class:"token function"}},[t._v("main")]),a("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v("(")]),a("span",{pre:!0,attrs:{class:"token class-name"}},[t._v("String")]),a("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v("[")]),a("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v("]")]),t._v(" args"),a("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v(")")]),t._v(" "),a("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v("{")]),t._v("\n "),a("span",{pre:!0,attrs:{class:"token keyword"}},[t._v("long")]),t._v(" totalSize "),a("span",{pre:!0,attrs:{class:"token operator"}},[t._v("=")]),t._v(" "),a("span",{pre:!0,attrs:{class:"token class-name"}},[t._v("HttpUtils")]),a("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v(".")]),a("span",{pre:!0,attrs:{class:"token function"}},[t._v("sync")]),a("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v("(")]),t._v("url"),a("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v(")")]),a("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v(".")]),a("span",{pre:!0,attrs:{class:"token function"}},[t._v("get")]),a("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v("(")]),a("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v(")")]),a("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v(".")]),a("span",{pre:!0,attrs:{class:"token function"}},[t._v("getBody")]),a("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v("(")]),a("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v(")")]),t._v("\n "),a("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v(".")]),a("span",{pre:!0,attrs:{class:"token function"}},[t._v("close")]),a("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v("(")]),a("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v(")")]),t._v(" "),a("span",{pre:!0,attrs:{class:"token comment"}},[t._v("// 因为这次请求只是为了获得文件大小，不消费报文体，所以直接关闭")]),t._v("\n "),a("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v(".")]),a("span",{pre:!0,attrs:{class:"token function"}},[t._v("getContentLength")]),a("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v("(")]),a("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v(")")]),a("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v(";")]),t._v(" "),a("span",{pre:!0,attrs:{class:"token comment"}},[t._v("// 获得待下载文件的大小（由于未消费报文体，所以该请求不会消耗下载报文体的时间和网络流量）")]),t._v("\n "),a("span",{pre:!0,attrs:{class:"token function"}},[t._v("download")]),a("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v("(")]),t._v("totalSize"),a("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v(",")]),t._v(" "),a("span",{pre:!0,attrs:{class:"token number"}},[t._v("0")]),a("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v(")")]),a("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v(";")]),t._v(" "),a("span",{pre:!0,attrs:{class:"token comment"}},[t._v("// 从第 0 块开始下载")]),t._v("\n "),a("span",{pre:!0,attrs:{class:"token function"}},[t._v("sleep")]),a("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v("(")]),a("span",{pre:!0,attrs:{class:"token number"}},[t._v("50000")]),a("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v(")")]),a("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v(";")]),t._v(" "),a("span",{pre:!0,attrs:{class:"token comment"}},[t._v("// 等待下载完成（不然本例的主线程就结束啦）")]),t._v("\n"),a("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v("}")]),t._v("\n\n"),a("span",{pre:!0,attrs:{class:"token keyword"}},[t._v("static")]),t._v(" "),a("span",{pre:!0,attrs:{class:"token keyword"}},[t._v("void")]),t._v(" "),a("span",{pre:!0,attrs:{class:"token function"}},[t._v("download")]),a("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v("(")]),a("span",{pre:!0,attrs:{class:"token keyword"}},[t._v("long")]),t._v(" totalSize"),a("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v(",")]),t._v(" "),a("span",{pre:!0,attrs:{class:"token keyword"}},[t._v("int")]),t._v(" index"),a("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v(")")]),t._v(" "),a("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v("{")]),t._v("\n "),a("span",{pre:!0,attrs:{class:"token keyword"}},[t._v("long")]),t._v(" size "),a("span",{pre:!0,attrs:{class:"token operator"}},[t._v("=")]),t._v(" "),a("span",{pre:!0,attrs:{class:"token number"}},[t._v("3")]),t._v(" "),a("span",{pre:!0,attrs:{class:"token operator"}},[t._v("*")]),t._v(" "),a("span",{pre:!0,attrs:{class:"token number"}},[t._v("1024")]),t._v(" "),a("span",{pre:!0,attrs:{class:"token operator"}},[t._v("*")]),t._v(" "),a("span",{pre:!0,attrs:{class:"token number"}},[t._v("1024")]),a("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v(";")]),t._v(" "),a("span",{pre:!0,attrs:{class:"token comment"}},[t._v("// 每块下载 3M ")]),t._v("\n "),a("span",{pre:!0,attrs:{class:"token keyword"}},[t._v("long")]),t._v(" start "),a("span",{pre:!0,attrs:{class:"token operator"}},[t._v("=")]),t._v(" index "),a("span",{pre:!0,attrs:{class:"token operator"}},[t._v("*")]),t._v(" size"),a("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v(";")]),t._v("\n "),a("span",{pre:!0,attrs:{class:"token keyword"}},[t._v("long")]),t._v(" end "),a("span",{pre:!0,attrs:{class:"token operator"}},[t._v("=")]),t._v(" "),a("span",{pre:!0,attrs:{class:"token class-name"}},[t._v("Math")]),a("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v(".")]),a("span",{pre:!0,attrs:{class:"token function"}},[t._v("min")]),a("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v("(")]),t._v("start "),a("span",{pre:!0,attrs:{class:"token operator"}},[t._v("+")]),t._v(" size"),a("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v(",")]),t._v(" totalSize"),a("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v(")")]),a("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v(";")]),t._v("\n "),a("span",{pre:!0,attrs:{class:"token class-name"}},[t._v("HttpUtils")]),a("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v(".")]),a("span",{pre:!0,attrs:{class:"token function"}},[t._v("sync")]),a("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v("(")]),t._v("url"),a("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v(")")]),t._v("\n "),a("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v(".")]),a("span",{pre:!0,attrs:{class:"token function"}},[t._v("setRange")]),a("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v("(")]),t._v("start"),a("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v(",")]),t._v(" end"),a("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v(")")]),t._v(" "),a("span",{pre:!0,attrs:{class:"token comment"}},[t._v("// 设置本次下载的范围")]),t._v("\n "),a("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v(".")]),a("span",{pre:!0,attrs:{class:"token function"}},[t._v("get")]),a("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v("(")]),a("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v(")")]),a("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v(".")]),a("span",{pre:!0,attrs:{class:"token function"}},[t._v("getBody")]),a("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v("(")]),a("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v(")")]),t._v("\n "),a("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v(".")]),a("span",{pre:!0,attrs:{class:"token function"}},[t._v("toFile")]),a("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v("(")]),a("span",{pre:!0,attrs:{class:"token string"}},[t._v('"D:/download/test.zip"')]),a("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v(")")]),t._v(" "),a("span",{pre:!0,attrs:{class:"token comment"}},[t._v("// 下载到同一个文件里")]),t._v("\n "),a("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v(".")]),a("span",{pre:!0,attrs:{class:"token function"}},[t._v("setAppended")]),a("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v("(")]),a("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v(")")]),t._v(" "),a("span",{pre:!0,attrs:{class:"token comment"}},[t._v("// 开启文件追加模式")]),t._v("\n "),a("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v(".")]),a("span",{pre:!0,attrs:{class:"token function"}},[t._v("setOnSuccess")]),a("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v("(")]),a("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v("(")]),a("span",{pre:!0,attrs:{class:"token class-name"}},[t._v("File")]),t._v(" file"),a("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v(")")]),t._v(" "),a("span",{pre:!0,attrs:{class:"token operator"}},[t._v("->")]),t._v(" "),a("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v("{")]),t._v("\n "),a("span",{pre:!0,attrs:{class:"token keyword"}},[t._v("if")]),t._v(" "),a("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v("(")]),t._v("end "),a("span",{pre:!0,attrs:{class:"token operator"}},[t._v("<")]),t._v(" totalSize"),a("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v(")")]),t._v(" "),a("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v("{")]),t._v(" "),a("span",{pre:!0,attrs:{class:"token comment"}},[t._v("// 若未下载完，则继续下载下一块")]),t._v("\n "),a("span",{pre:!0,attrs:{class:"token function"}},[t._v("download")]),a("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v("(")]),t._v("totalSize"),a("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v(",")]),t._v(" index "),a("span",{pre:!0,attrs:{class:"token operator"}},[t._v("+")]),t._v(" "),a("span",{pre:!0,attrs:{class:"token number"}},[t._v("1")]),a("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v(")")]),a("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v(";")]),t._v(" \n "),a("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v("}")]),t._v(" "),a("span",{pre:!0,attrs:{class:"token keyword"}},[t._v("else")]),t._v(" "),a("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v("{")]),t._v("\n "),a("span",{pre:!0,attrs:{class:"token class-name"}},[t._v("System")]),a("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v(".")]),t._v("out"),a("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v(".")]),a("span",{pre:!0,attrs:{class:"token function"}},[t._v("println")]),a("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v("(")]),a("span",{pre:!0,attrs:{class:"token string"}},[t._v('"下载完成"')]),a("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v(")")]),a("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v(";")]),t._v("\n "),a("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v("}")]),t._v("\n "),a("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v("}")]),a("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v(")")]),t._v("\n "),a("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v(".")]),a("span",{pre:!0,attrs:{class:"token function"}},[t._v("start")]),a("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v("(")]),a("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v(")")]),a("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v(";")]),t._v("\n"),a("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v("}")]),t._v("\n")])]),t._v(" "),a("div",{staticClass:"line-numbers-wrapper"},[a("span",{staticClass:"line-number"},[t._v("1")]),a("br"),a("span",{staticClass:"line-number"},[t._v("2")]),a("br"),a("span",{staticClass:"line-number"},[t._v("3")]),a("br"),a("span",{staticClass:"line-number"},[t._v("4")]),a("br"),a("span",{staticClass:"line-number"},[t._v("5")]),a("br"),a("span",{staticClass:"line-number"},[t._v("6")]),a("br"),a("span",{staticClass:"line-number"},[t._v("7")]),a("br"),a("span",{staticClass:"line-number"},[t._v("8")]),a("br"),a("span",{staticClass:"line-number"},[t._v("9")]),a("br"),a("span",{staticClass:"line-number"},[t._v("10")]),a("br"),a("span",{staticClass:"line-number"},[t._v("11")]),a("br"),a("span",{staticClass:"line-number"},[t._v("12")]),a("br"),a("span",{staticClass:"line-number"},[t._v("13")]),a("br"),a("span",{staticClass:"line-number"},[t._v("14")]),a("br"),a("span",{staticClass:"line-number"},[t._v("15")]),a("br"),a("span",{staticClass:"line-number"},[t._v("16")]),a("br"),a("span",{staticClass:"line-number"},[t._v("17")]),a("br"),a("span",{staticClass:"line-number"},[t._v("18")]),a("br"),a("span",{staticClass:"line-number"},[t._v("19")]),a("br"),a("span",{staticClass:"line-number"},[t._v("20")]),a("br"),a("span",{staticClass:"line-number"},[t._v("21")]),a("br"),a("span",{staticClass:"line-number"},[t._v("22")]),a("br"),a("span",{staticClass:"line-number"},[t._v("23")]),a("br"),a("span",{staticClass:"line-number"},[t._v("24")]),a("br"),a("span",{staticClass:"line-number"},[t._v("25")]),a("br"),a("span",{staticClass:"line-number"},[t._v("26")]),a("br"),a("span",{staticClass:"line-number"},[t._v("27")]),a("br"),a("span",{staticClass:"line-number"},[t._v("28")]),a("br")])]),a("h2",{attrs:{id:"文件上传"}},[a("a",{staticClass:"header-anchor",attrs:{href:"#文件上传"}},[t._v("#")]),t._v(" 文件上传")]),t._v(" "),a("p",[t._v("一个简单文件上传的示例：")]),t._v(" "),a("div",{staticClass:"language-java line-numbers-mode"},[a("pre",{pre:!0,attrs:{class:"language-java"}},[a("code",[t._v("http"),a("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v(".")]),a("span",{pre:!0,attrs:{class:"token function"}},[t._v("sync")]),a("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v("(")]),a("span",{pre:!0,attrs:{class:"token string"}},[t._v('"/upload"')]),a("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v(")")]),t._v("\n "),a("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v(".")]),a("span",{pre:!0,attrs:{class:"token function"}},[t._v("addFileParam")]),a("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v("(")]),a("span",{pre:!0,attrs:{class:"token string"}},[t._v('"test"')]),a("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v(",")]),t._v(" "),a("span",{pre:!0,attrs:{class:"token string"}},[t._v('"D:/download/test.zip"')]),a("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v(")")]),t._v("\n "),a("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v(".")]),a("span",{pre:!0,attrs:{class:"token function"}},[t._v("post")]),a("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v("(")]),a("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v(")")]),a("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v(";")]),t._v(" "),a("span",{pre:!0,attrs:{class:"token comment"}},[t._v("// 上传发法一般使用 POST 或 PUT，看服务器支持")]),t._v("\n")])]),t._v(" "),a("div",{staticClass:"line-numbers-wrapper"},[a("span",{staticClass:"line-number"},[t._v("1")]),a("br"),a("span",{staticClass:"line-number"},[t._v("2")]),a("br"),a("span",{staticClass:"line-number"},[t._v("3")]),a("br")])]),a("p",[t._v("异步上传也是完全一样：")]),t._v(" "),a("div",{staticClass:"language-java line-numbers-mode"},[a("pre",{pre:!0,attrs:{class:"language-java"}},[a("code",[t._v("http"),a("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v(".")]),a("span",{pre:!0,attrs:{class:"token function"}},[t._v("async")]),a("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v("(")]),a("span",{pre:!0,attrs:{class:"token string"}},[t._v('"/upload"')]),a("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v(")")]),t._v("\n "),a("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v(".")]),a("span",{pre:!0,attrs:{class:"token function"}},[t._v("addFileParam")]),a("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v("(")]),a("span",{pre:!0,attrs:{class:"token string"}},[t._v('"test"')]),a("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v(",")]),t._v(" "),a("span",{pre:!0,attrs:{class:"token string"}},[t._v('"D:/download/test.zip"')]),a("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v(")")]),t._v("\n "),a("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v(".")]),a("span",{pre:!0,attrs:{class:"token function"}},[t._v("post")]),a("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v("(")]),a("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v(")")]),a("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v(";")]),t._v("\n")])]),t._v(" "),a("div",{staticClass:"line-numbers-wrapper"},[a("span",{staticClass:"line-number"},[t._v("1")]),a("br"),a("span",{staticClass:"line-number"},[t._v("2")]),a("br"),a("span",{staticClass:"line-number"},[t._v("3")]),a("br")])]),a("h3",{attrs:{id:"上传进度监听"}},[a("a",{staticClass:"header-anchor",attrs:{href:"#上传进度监听"}},[t._v("#")]),t._v(" 上传进度监听")]),t._v(" "),a("p",[t._v("OkHttps 的上传进度监听，监听的是所有请求报文体的发送进度，示例代码：")]),t._v(" "),a("div",{staticClass:"language-java line-numbers-mode"},[a("pre",{pre:!0,attrs:{class:"language-java"}},[a("code",[t._v("http"),a("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v(".")]),a("span",{pre:!0,attrs:{class:"token function"}},[t._v("sync")]),a("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v("(")]),a("span",{pre:!0,attrs:{class:"token string"}},[t._v('"/upload"')]),a("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v(")")]),t._v("\n "),a("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v(".")]),a("span",{pre:!0,attrs:{class:"token function"}},[t._v("addBodyParam")]),a("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v("(")]),a("span",{pre:!0,attrs:{class:"token string"}},[t._v('"name"')]),a("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v(",")]),t._v(" "),a("span",{pre:!0,attrs:{class:"token string"}},[t._v('"Jack"')]),a("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v(")")]),t._v("\n "),a("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v(".")]),a("span",{pre:!0,attrs:{class:"token function"}},[t._v("addBodyParam")]),a("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v("(")]),a("span",{pre:!0,attrs:{class:"token string"}},[t._v('"age"')]),a("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v(",")]),t._v(" "),a("span",{pre:!0,attrs:{class:"token number"}},[t._v("20")]),a("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v(")")]),t._v("\n "),a("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v(".")]),a("span",{pre:!0,attrs:{class:"token function"}},[t._v("addFileParam")]),a("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v("(")]),a("span",{pre:!0,attrs:{class:"token string"}},[t._v('"avatar"')]),a("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v(",")]),t._v(" "),a("span",{pre:!0,attrs:{class:"token string"}},[t._v('"D:/image/avatar.jpg"')]),a("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v(")")]),t._v("\n "),a("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v(".")]),a("span",{pre:!0,attrs:{class:"token function"}},[t._v("setStepBytes")]),a("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v("(")]),a("span",{pre:!0,attrs:{class:"token number"}},[t._v("1024")]),a("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v(")")]),t._v(" "),a("span",{pre:!0,attrs:{class:"token comment"}},[t._v("// 设置每发送 1024 个字节执行一次进度回调（不设置默认为 8192） ")]),t._v("\n "),a("span",{pre:!0,attrs:{class:"token comment"}},[t._v("// .setStepRate(0.01) // 设置每发送 1% 执行一次进度回调（不设置以 StepBytes 为准） ")]),t._v("\n "),a("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v(".")]),a("span",{pre:!0,attrs:{class:"token function"}},[t._v("setOnProcess")]),a("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v("(")]),a("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v("(")]),a("span",{pre:!0,attrs:{class:"token class-name"}},[t._v("Process")]),t._v(" process"),a("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v(")")]),t._v(" "),a("span",{pre:!0,attrs:{class:"token operator"}},[t._v("->")]),t._v(" "),a("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v("{")]),t._v(" "),a("span",{pre:!0,attrs:{class:"token comment"}},[t._v("// 上传进度回调")]),t._v("\n "),a("span",{pre:!0,attrs:{class:"token keyword"}},[t._v("long")]),t._v(" doneBytes "),a("span",{pre:!0,attrs:{class:"token operator"}},[t._v("=")]),t._v(" process"),a("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v(".")]),a("span",{pre:!0,attrs:{class:"token function"}},[t._v("getDoneBytes")]),a("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v("(")]),a("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v(")")]),a("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v(";")]),t._v(" "),a("span",{pre:!0,attrs:{class:"token comment"}},[t._v("// 已发送字节数")]),t._v("\n "),a("span",{pre:!0,attrs:{class:"token keyword"}},[t._v("long")]),t._v(" totalBytes "),a("span",{pre:!0,attrs:{class:"token operator"}},[t._v("=")]),t._v(" process"),a("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v(".")]),a("span",{pre:!0,attrs:{class:"token function"}},[t._v("getTotalBytes")]),a("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v("(")]),a("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v(")")]),a("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v(";")]),t._v(" "),a("span",{pre:!0,attrs:{class:"token comment"}},[t._v("// 总共的字节数")]),t._v("\n "),a("span",{pre:!0,attrs:{class:"token keyword"}},[t._v("double")]),t._v(" rate "),a("span",{pre:!0,attrs:{class:"token operator"}},[t._v("=")]),t._v(" process"),a("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v(".")]),a("span",{pre:!0,attrs:{class:"token function"}},[t._v("getRate")]),a("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v("(")]),a("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v(")")]),a("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v(";")]),t._v(" "),a("span",{pre:!0,attrs:{class:"token comment"}},[t._v("// 已发送的比例")]),t._v("\n "),a("span",{pre:!0,attrs:{class:"token keyword"}},[t._v("boolean")]),t._v(" isDone "),a("span",{pre:!0,attrs:{class:"token operator"}},[t._v("=")]),t._v(" process"),a("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v(".")]),a("span",{pre:!0,attrs:{class:"token function"}},[t._v("isDone")]),a("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v("(")]),a("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v(")")]),a("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v(";")]),t._v(" "),a("span",{pre:!0,attrs:{class:"token comment"}},[t._v("// 是否发送完成")]),t._v("\n "),a("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v("}")]),a("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v(")")]),t._v("\n "),a("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v(".")]),a("span",{pre:!0,attrs:{class:"token function"}},[t._v("post")]),a("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v("(")]),a("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v(")")]),a("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v(";")]),t._v("\n")])]),t._v(" "),a("div",{staticClass:"line-numbers-wrapper"},[a("span",{staticClass:"line-number"},[t._v("1")]),a("br"),a("span",{staticClass:"line-number"},[t._v("2")]),a("br"),a("span",{staticClass:"line-number"},[t._v("3")]),a("br"),a("span",{staticClass:"line-number"},[t._v("4")]),a("br"),a("span",{staticClass:"line-number"},[t._v("5")]),a("br"),a("span",{staticClass:"line-number"},[t._v("6")]),a("br"),a("span",{staticClass:"line-number"},[t._v("7")]),a("br"),a("span",{staticClass:"line-number"},[t._v("8")]),a("br"),a("span",{staticClass:"line-number"},[t._v("9")]),a("br"),a("span",{staticClass:"line-number"},[t._v("10")]),a("br"),a("span",{staticClass:"line-number"},[t._v("11")]),a("br"),a("span",{staticClass:"line-number"},[t._v("12")]),a("br"),a("span",{staticClass:"line-number"},[t._v("13")]),a("br")])]),a("p",[t._v("咦！怎么感觉和下载的进度回调的一样？没错！OkHttps 还是使用同一套API处理上传和下载的进度回调，区别只在于上传是在"),a("code",[t._v("get/post")]),t._v("方法之前使用这些API，下载是在"),a("code",[t._v("getBody")]),t._v("方法之后使用。很好理解："),a("code",[t._v("get/post")]),t._v("之前是准备发送请求时段，有上传的含义，而"),a("code",[t._v("getBody")]),t._v("之后，已是报文响应的时段，当然是下载。")]),t._v(" "),a("h3",{attrs:{id:"上传过程控制"}},[a("a",{staticClass:"header-anchor",attrs:{href:"#上传过程控制"}},[t._v("#")]),t._v(" 上传过程控制")]),t._v(" "),a("p",[t._v("上传文件的过程控制就很简单，和常规请求一样，只有异步发起的上传可以取消：")]),t._v(" "),a("div",{staticClass:"language-java line-numbers-mode"},[a("pre",{pre:!0,attrs:{class:"language-java"}},[a("code",[a("span",{pre:!0,attrs:{class:"token class-name"}},[t._v("HttpCall")]),t._v(" call "),a("span",{pre:!0,attrs:{class:"token operator"}},[t._v("=")]),t._v(" http"),a("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v(".")]),a("span",{pre:!0,attrs:{class:"token function"}},[t._v("async")]),a("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v("(")]),a("span",{pre:!0,attrs:{class:"token string"}},[t._v('"/upload"')]),a("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v(")")]),t._v("\n "),a("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v(".")]),a("span",{pre:!0,attrs:{class:"token function"}},[t._v("addFileParam")]),a("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v("(")]),a("span",{pre:!0,attrs:{class:"token string"}},[t._v('"test"')]),a("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v(",")]),t._v(" "),a("span",{pre:!0,attrs:{class:"token string"}},[t._v('"D:/download/test.zip"')]),a("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v(")")]),t._v("\n "),a("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v(".")]),a("span",{pre:!0,attrs:{class:"token function"}},[t._v("setOnProcess")]),a("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v("(")]),a("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v("(")]),a("span",{pre:!0,attrs:{class:"token class-name"}},[t._v("Process")]),t._v(" process"),a("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v(")")]),t._v(" "),a("span",{pre:!0,attrs:{class:"token operator"}},[t._v("->")]),t._v(" "),a("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v("{")]),t._v("\n "),a("span",{pre:!0,attrs:{class:"token class-name"}},[t._v("System")]),a("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v(".")]),t._v("out"),a("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v(".")]),a("span",{pre:!0,attrs:{class:"token function"}},[t._v("println")]),a("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v("(")]),t._v("process"),a("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v(".")]),a("span",{pre:!0,attrs:{class:"token function"}},[t._v("getRate")]),a("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v("(")]),a("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v(")")]),a("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v(")")]),a("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v(";")]),t._v("\n "),a("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v("}")]),a("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v(")")]),t._v("\n "),a("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v(".")]),a("span",{pre:!0,attrs:{class:"token function"}},[t._v("post")]),a("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v("(")]),a("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v(")")]),a("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v(";")]),t._v("\n\ncall"),a("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v(".")]),a("span",{pre:!0,attrs:{class:"token function"}},[t._v("cancel")]),a("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v("(")]),a("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v(")")]),a("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v(";")]),t._v(" "),a("span",{pre:!0,attrs:{class:"token comment"}},[t._v("// 取消上传")]),t._v("\n")])]),t._v(" "),a("div",{staticClass:"line-numbers-wrapper"},[a("span",{staticClass:"line-number"},[t._v("1")]),a("br"),a("span",{staticClass:"line-number"},[t._v("2")]),a("br"),a("span",{staticClass:"line-number"},[t._v("3")]),a("br"),a("span",{staticClass:"line-number"},[t._v("4")]),a("br"),a("span",{staticClass:"line-number"},[t._v("5")]),a("br"),a("span",{staticClass:"line-number"},[t._v("6")]),a("br"),a("span",{staticClass:"line-number"},[t._v("7")]),a("br"),a("span",{staticClass:"line-number"},[t._v("8")]),a("br")])]),a("p",[t._v("上传就没有暂停和继续这个功能啦，应该没人有这个需求吧?")])])}),[],!1,null,null,null);s.default=e.exports}}]); \ No newline at end of file diff --git a/okhttps-doc/docs/.vuepress/dist/assets/js/13.d857e269.js b/okhttps-doc/docs/.vuepress/dist/assets/js/13.d857e269.js new file mode 100644 index 00000000..126a94c9 --- /dev/null +++ b/okhttps-doc/docs/.vuepress/dist/assets/js/13.d857e269.js @@ -0,0 +1 @@ +(window.webpackJsonp=window.webpackJsonp||[]).push([[13],{281:function(n,w,o){}}]); \ No newline at end of file diff --git a/okhttps-doc/docs/.vuepress/dist/assets/js/2.16cbe9f2.js b/okhttps-doc/docs/.vuepress/dist/assets/js/2.16cbe9f2.js new file mode 100644 index 00000000..7e02b99a --- /dev/null +++ b/okhttps-doc/docs/.vuepress/dist/assets/js/2.16cbe9f2.js @@ -0,0 +1 @@ +(window.webpackJsonp=window.webpackJsonp||[]).push([[2],{282:function(t,e,n){"use strict";n.d(e,"d",(function(){return i})),n.d(e,"a",(function(){return a})),n.d(e,"i",(function(){return s})),n.d(e,"f",(function(){return u})),n.d(e,"g",(function(){return c})),n.d(e,"h",(function(){return l})),n.d(e,"b",(function(){return h})),n.d(e,"e",(function(){return f})),n.d(e,"k",(function(){return p})),n.d(e,"l",(function(){return d})),n.d(e,"c",(function(){return g})),n.d(e,"j",(function(){return v}));n(20),n(84),n(143),n(298),n(145),n(57),n(25),n(283),n(58),n(148),n(88);var i=/#.*$/,r=/\.(md|html)$/,a=/\/$/,s=/^[a-z]+:/i;function o(t){return decodeURI(t).replace(i,"").replace(r,"")}function u(t){return s.test(t)}function c(t){return/^mailto:/.test(t)}function l(t){return/^tel:/.test(t)}function h(t){if(u(t))return t;var e=t.match(i),n=e?e[0]:"",r=o(t);return a.test(r)?t:r+".html"+n}function f(t,e){var n=decodeURIComponent(t.hash),r=function(t){var e=t.match(i);if(e)return e[0]}(e);return(!r||n===r)&&o(t.path)===o(e)}function p(t,e,n){if(u(e))return{type:"external",path:e};n&&(e=function(t,e,n){var i=t.charAt(0);if("/"===i)return t;if("?"===i||"#"===i)return e+t;var r=e.split("/");n&&r[r.length-1]||r.pop();for(var a=t.replace(/^\//,"").split("/"),s=0;s3&&void 0!==arguments[3]?arguments[3]:1;if("string"==typeof e)return p(n,e,i);if(Array.isArray(e))return Object.assign(p(n,e[0],i),{title:e[1]});var a=e.children||[];return 0===a.length&&e.path?Object.assign(p(n,e.path,i),{title:e.title}):{type:"group",path:e.path,title:e.title,sidebarDepth:e.sidebarDepth,children:a.map((function(e){return t(e,n,i,r+1)})),collapsable:!1!==e.collapsable}}(t,r,c)})):[]}return[]}function g(t){var e;return(t=t.map((function(t){return Object.assign({},t)}))).forEach((function(t){2===t.level?e=t:e&&(e.children||(e.children=[])).push(t)})),t.filter((function(t){return 2===t.level}))}function v(t){return Object.assign(t,{type:t.items&&t.items.length?"links":"link"})}},283:function(t,e,n){"use strict";var i=n(89),r=n(8),a=n(14),s=n(13),o=n(90),u=n(91);i("match",1,(function(t,e,n){return[function(e){var n=s(this),i=null==e?void 0:e[t];return void 0!==i?i.call(e,n):new RegExp(e)[t](String(n))},function(t){var i=n(e,t,this);if(i.done)return i.value;var s=r(t),c=String(this);if(!s.global)return u(s,c);var l=s.unicode;s.lastIndex=0;for(var h,f=[],p=0;null!==(h=u(s,c));){var d=String(h[0]);f[p]=d,""===d&&(s.lastIndex=o(c,a(s.lastIndex),l)),p++}return 0===p?null:f}]}))},284:function(t,e,n){},285:function(t,e,n){},286:function(t,e,n){},287:function(t,e,n){},288:function(t,e,n){},289:function(t,e,n){},290:function(t,e,n){},291:function(t,e,n){},292:function(t,e,n){},293:function(t,e,n){},294:function(t,e,n){},295:function(t,e,n){},296:function(t,e,n){},298:function(t,e,n){n(0)({target:"Array",stat:!0},{isArray:n(40)})},299:function(t,e,n){"use strict";var i=n(0),r=n(146).trim;i({target:"String",proto:!0,forced:n(311)("trim")},{trim:function(){return r(this)}})},300:function(t,e,n){var i=n(6),r=n(3),a=n(82),s=n(155),o=n(7).f,u=n(39).f,c=n(86),l=n(144),h=n(150),f=n(21),p=n(1),d=n(37).set,g=n(312),v=n(2)("match"),m=r.RegExp,b=m.prototype,k=/a/g,_=/a/g,x=new m(k)!==k,C=h.UNSUPPORTED_Y;if(i&&a("RegExp",!x||C||p((function(){return _[v]=!1,m(k)!=k||m(_)==_||"/a/i"!=m(k,"i")})))){for(var $=function(t,e){var n,i=this instanceof $,r=c(t),a=void 0===e;if(!i&&r&&t.constructor===$&&a)return t;x?r&&!a&&(t=t.source):t instanceof $&&(a&&(e=l.call(t)),t=t.source),C&&(n=!!e&&e.indexOf("y")>-1)&&(e=e.replace(/y/g,""));var o=s(x?new m(t,e):m(t,e),i?this:b,$);return C&&n&&d(o,{sticky:n}),o},L=function(t){t in $||o($,t,{configurable:!0,get:function(){return m[t]},set:function(e){m[t]=e}})},y=u(m),w=0;y.length>w;)L(y[w++]);b.constructor=$,$.prototype=b,f(r,"RegExp",$)}g("RegExp")},301:function(t,e,n){"use strict";var i=n(21),r=n(8),a=n(1),s=n(144),o=RegExp.prototype,u=o.toString,c=a((function(){return"/a/b"!=u.call({source:"a",flags:"b"})})),l="toString"!=u.name;(c||l)&&i(RegExp.prototype,"toString",(function(){var t=r(this),e=String(t.source),n=t.flags;return"/"+e+"/"+String(void 0===n&&t instanceof RegExp&&!("flags"in o)?s.call(t):n)}),{unsafe:!0})},302:function(t,e){t.exports=function(t){return null==t}},303:function(t,e,n){"use strict";n.r(e);n(142);var i=n(282),r={name:"SidebarGroup",components:{DropdownTransition:n(304).a},props:["item","open","collapsable","depth"],beforeCreate:function(){this.$options.components.SidebarLinks=n(303).default},methods:{isActive:i.e}},a=(n(324),n(19)),s=Object(a.a)(r,(function(){var t=this,e=t.$createElement,n=t._self._c||e;return n("section",{staticClass:"sidebar-group",class:[{collapsable:t.collapsable,"is-sub-group":0!==t.depth},"depth-"+t.depth]},[t.item.path?n("RouterLink",{staticClass:"sidebar-heading clickable",class:{open:t.open,active:t.isActive(t.$route,t.item.path)},attrs:{to:t.item.path},nativeOn:{click:function(e){return t.$emit("toggle")}}},[n("span",[t._v(t._s(t.item.title))]),t._v(" "),t.collapsable?n("span",{staticClass:"arrow",class:t.open?"down":"right"}):t._e()]):n("p",{staticClass:"sidebar-heading",class:{open:t.open},on:{click:function(e){return t.$emit("toggle")}}},[n("span",[t._v(t._s(t.item.title))]),t._v(" "),t.collapsable?n("span",{staticClass:"arrow",class:t.open?"down":"right"}):t._e()]),t._v(" "),n("DropdownTransition",[t.open||!t.collapsable?n("SidebarLinks",{staticClass:"sidebar-group-items",attrs:{items:t.item.children,"sidebar-depth":t.item.sidebarDepth,depth:t.depth+1}}):t._e()],1)],1)}),[],!1,null,null,null).exports;n(325),n(57);function o(t,e,n,i,r){var a={props:{to:e,activeClass:"",exactActiveClass:""},class:{active:i,"sidebar-link":!0}};return r>2&&(a.style={"padding-left":r+"rem"}),t("RouterLink",a,n)}function u(t,e,n,r,a){var s=arguments.length>5&&void 0!==arguments[5]?arguments[5]:1;return!e||s>a?null:t("ul",{class:"sidebar-sub-headers"},e.map((function(e){var c=Object(i.e)(r,n+"#"+e.slug);return t("li",{class:"sidebar-sub-header"},[o(t,n+"#"+e.slug,e.title,c,e.level-1),u(t,e.children,n,r,a,s+1)])})))}var c={functional:!0,props:["item","sidebarDepth"],render:function(t,e){var n=e.parent,r=n.$page,a=(n.$site,n.$route),s=n.$themeConfig,c=n.$themeLocaleConfig,l=e.props,h=l.item,f=l.sidebarDepth,p=Object(i.e)(a,h.path),d="auto"===h.type?p||h.children.some((function(t){return Object(i.e)(a,h.basePath+"#"+t.slug)})):p,g="external"===h.type?function(t,e,n){return t("a",{attrs:{href:e,target:"_blank",rel:"noopener noreferrer"},class:{"sidebar-link":!0}},[n,t("OutboundLink")])}(t,h.path,h.title||h.path):o(t,h.path,h.title||h.path,d),v=[r.frontmatter.sidebarDepth,f,c.sidebarDepth,s.sidebarDepth,1].find((function(t){return void 0!==t})),m=c.displayAllHeaders||s.displayAllHeaders;return"auto"===h.type?[g,u(t,h.children,h.basePath,a,v)]:(d||m)&&h.headers&&!i.d.test(h.path)?[g,u(t,Object(i.c)(h.headers),h.path,a,v)]:g}};n(326);function l(t,e){return"group"===e.type&&e.children.some((function(e){return"group"===e.type?l(t,e):"page"===e.type&&Object(i.e)(t,e.path)}))}var h={name:"SidebarLinks",components:{SidebarGroup:s,SidebarLink:Object(a.a)(c,void 0,void 0,!1,null,null,null).exports},props:["items","depth","sidebarDepth"],data:function(){return{openGroupIndex:0}},watch:{$route:function(){this.refreshIndex()}},created:function(){this.refreshIndex()},methods:{refreshIndex:function(){var t=function(t,e){for(var n=0;n-1&&(this.openGroupIndex=t)},toggleGroup:function(t){this.openGroupIndex=t===this.openGroupIndex?-1:t},isActive:function(t){return Object(i.e)(this.$route,t.regularPath)}}},f=Object(a.a)(h,(function(){var t=this,e=t.$createElement,n=t._self._c||e;return t.items.length?n("ul",{staticClass:"sidebar-links"},t._l(t.items,(function(e,i){return n("li",{key:i},["group"===e.type?n("SidebarGroup",{attrs:{item:e,open:i===t.openGroupIndex,collapsable:e.collapsable||e.collapsible,depth:t.depth},on:{toggle:function(e){return t.toggleGroup(i)}}}):n("SidebarLink",{attrs:{"sidebar-depth":t.sidebarDepth,item:e}})],1)})),0):t._e()}),[],!1,null,null,null);e.default=f.exports},304:function(t,e,n){"use strict";var i={name:"DropdownTransition",methods:{setHeight:function(t){t.style.height=t.scrollHeight+"px"},unsetHeight:function(t){t.style.height=""}}},r=(n(316),n(19)),a=Object(r.a)(i,(function(){var t=this.$createElement;return(this._self._c||t)("transition",{attrs:{name:"dropdown"},on:{enter:this.setHeight,"after-enter":this.unsetHeight,"before-leave":this.setHeight}},[this._t("default")],2)}),[],!1,null,null,null);e.a=a.exports},305:function(t,e,n){"use strict";var i=n(0),r=n(306);i({target:"String",proto:!0,forced:n(307)("link")},{link:function(t){return r(this,"a","href",t)}})},306:function(t,e,n){var i=n(13),r=/"/g;t.exports=function(t,e,n,a){var s=String(i(t)),o="<"+e;return""!==n&&(o+=" "+n+'="'+String(a).replace(r,""")+'"'),o+">"+s+""}},307:function(t,e,n){var i=n(1);t.exports=function(t){return i((function(){var e=""[t]('"');return e!==e.toLowerCase()||e.split('"').length>3}))}},308:function(t,e,n){"use strict";var i=n(284);n.n(i).a},309:function(t,e,n){var i=n(0),r=n(310);i({global:!0,forced:parseInt!=r},{parseInt:r})},310:function(t,e,n){var i=n(3),r=n(146).trim,a=n(147),s=i.parseInt,o=/^[+-]?0[Xx]/,u=8!==s(a+"08")||22!==s(a+"0x16");t.exports=u?function(t,e){var n=r(String(t));return s(n,e>>>0||(o.test(n)?16:10))}:s},311:function(t,e,n){var i=n(1),r=n(147);t.exports=function(t){return i((function(){return!!r[t]()||"​…᠎"!="​…᠎"[t]()||r[t].name!==t}))}},312:function(t,e,n){"use strict";var i=n(38),r=n(7),a=n(2),s=n(6),o=a("species");t.exports=function(t){var e=i(t),n=r.f;s&&e&&!e[o]&&n(e,o,{configurable:!0,get:function(){return this}})}},313:function(t,e,n){"use strict";var i,r=n(0),a=n(22).f,s=n(14),o=n(85),u=n(13),c=n(87),l=n(26),h="".endsWith,f=Math.min,p=c("endsWith");r({target:"String",proto:!0,forced:!!(l||p||(i=a(String.prototype,"endsWith"),!i||i.writable))&&!p},{endsWith:function(t){var e=String(u(this));o(t);var n=arguments.length>1?arguments[1]:void 0,i=s(e.length),r=void 0===n?i:f(s(n),i),a=String(t);return h?h.call(e,a,r):e.slice(r-a.length,r)===a}})},314:function(t,e,n){"use strict";var i=n(285);n.n(i).a},315:function(t,e,n){"use strict";var i=n(286);n.n(i).a},316:function(t,e,n){"use strict";var i=n(287);n.n(i).a},317:function(t,e,n){"use strict";var i=n(288);n.n(i).a},318:function(t,e,n){"use strict";var i=n(289);n.n(i).a},319:function(t,e,n){"use strict";var i=n(290);n.n(i).a},320:function(t,e,n){"use strict";var i=n(291);n.n(i).a},321:function(t,e,n){var i=n(28),r=n(10),a=n(23);t.exports=function(t){return"string"==typeof t||!r(t)&&a(t)&&"[object String]"==i(t)}},322:function(t,e,n){"use strict";var i=n(292);n.n(i).a},323:function(t,e,n){"use strict";var i=n(293);n.n(i).a},324:function(t,e,n){"use strict";var i=n(294);n.n(i).a},325:function(t,e,n){"use strict";var i=n(0),r=n(27).find,a=n(83),s=n(15),o=!0,u=s("find");"find"in[]&&Array(1).find((function(){o=!1})),i({target:"Array",proto:!0,forced:o||!u},{find:function(t){return r(this,t,arguments.length>1?arguments[1]:void 0)}}),a("find")},326:function(t,e,n){"use strict";var i=n(295);n.n(i).a},327:function(t,e,n){"use strict";var i=n(296);n.n(i).a},329:function(t,e,n){"use strict";n.r(e);n(142),n(81),n(305);var i=n(282),r={name:"NavLink",props:{item:{required:!0}},computed:{link:function(){return Object(i.b)(this.item.link)},exact:function(){var t=this;return this.$site.locales?Object.keys(this.$site.locales).some((function(e){return e===t.link})):"/"===this.link},isNonHttpURI:function(){return Object(i.g)(this.link)||Object(i.h)(this.link)},isBlankTarget:function(){return"_blank"===this.target},isInternal:function(){return!Object(i.f)(this.link)&&!this.isBlankTarget},target:function(){return this.isNonHttpURI?null:this.item.target?this.item.target:Object(i.f)(this.link)?"_blank":""},rel:function(){return this.isNonHttpURI?null:this.item.rel?this.item.rel:this.isBlankTarget?"noopener noreferrer":""}},methods:{focusoutAction:function(){this.$emit("focusout")}}},a=n(19),s=Object(a.a)(r,(function(){var t=this,e=t.$createElement,n=t._self._c||e;return t.isInternal?n("RouterLink",{staticClass:"nav-link",attrs:{to:t.link,exact:t.exact},nativeOn:{focusout:function(e){return t.focusoutAction(e)}}},[t._v("\n "+t._s(t.item.text)+"\n")]):n("a",{staticClass:"nav-link external",attrs:{href:t.link,target:t.target,rel:t.rel},on:{focusout:t.focusoutAction}},[t._v("\n "+t._s(t.item.text)+"\n "),t.isBlankTarget?n("OutboundLink"):t._e()],1)}),[],!1,null,null,null).exports,o={name:"Home",components:{NavLink:s},computed:{data:function(){return this.$page.frontmatter},actionLink:function(){return{link:this.data.actionLink,text:this.data.actionText}}}},u=(n(308),Object(a.a)(o,(function(){var t=this,e=t.$createElement,n=t._self._c||e;return n("main",{staticClass:"home",attrs:{"aria-labelledby":"main-title"}},[n("header",{staticClass:"hero"},[t.data.heroImage?n("img",{attrs:{src:t.$withBase(t.data.heroImage),alt:t.data.heroAlt||"hero"}}):t._e(),t._v(" "),null!==t.data.heroText?n("h1",{attrs:{id:"main-title"}},[t._v("\n "+t._s(t.data.heroText||t.$title||"Hello")+"\n ")]):t._e(),t._v(" "),null!==t.data.tagline?n("p",{staticClass:"description"},[t._v("\n "+t._s(t.data.tagline||t.$description||"Welcome to your VuePress site")+"\n ")]):t._e(),t._v(" "),t.data.actionText&&t.data.actionLink?n("p",{staticClass:"action"},[n("NavLink",{staticClass:"action-button",attrs:{item:t.actionLink}})],1):t._e()]),t._v(" "),t.data.features&&t.data.features.length?n("div",{staticClass:"features"},t._l(t.data.features,(function(e,i){return n("div",{key:i,staticClass:"feature"},[n("h2",[t._v(t._s(e.title))]),t._v(" "),n("p",[t._v(t._s(e.details))])])})),0):t._e(),t._v(" "),n("Content",{staticClass:"theme-default-content custom"}),t._v(" "),t.data.footer?n("div",{staticClass:"footer"},[t._v("\n "+t._s(t.data.footer)+"\n ")]):t._e()],1)}),[],!1,null,null,null).exports),c=(n(309),n(20),n(149),n(143),n(298),n(25),n(151),n(283),n(299),n(145),n(57),n(300),n(301),n(313),n(58),n(148),n(153)),l=n.n(c),h=function(t,e){var n=arguments.length>2&&void 0!==arguments[2]?arguments[2]:null,i=l()(e,"title","");return l()(e,"frontmatter.tags")&&(i+=" ".concat(e.frontmatter.tags.join(" "))),n&&(i+=" ".concat(n)),f(t,i)},f=function(t,e){var n=function(t){return t.replace(/[-/\\^$*+?.()|[\]{}]/g,"\\$&")},i=new RegExp("[^\0-]"),r=t.split(/\s+/g).map((function(t){return t.trim()})).filter((function(t){return!!t}));if(i.test(t))return r.some((function(t){return e.toLowerCase().indexOf(t)>-1}));var a=t.endsWith(" ");return new RegExp(r.map((function(t,e){return r.length!==e+1||a?"(?=.*\\b".concat(n(t),"\\b)"):"(?=.*\\b".concat(n(t),")")})).join("")+".+","gi").test(e)},p={name:"SearchBox",data:function(){return{query:"",focused:!1,focusIndex:0,placeholder:void 0}},computed:{showSuggestions:function(){return this.focused&&this.suggestions&&this.suggestions.length},suggestions:function(){var t=this.query.trim().toLowerCase();if(t){for(var e=this.$site.pages,n=this.$site.themeConfig.searchMaxSuggestions||5,i=this.$localePath,r=[],a=0;a=n);a++){var s=e[a];if(this.getPageLocalePath(s)===i&&this.isSearchable(s))if(h(t,s))r.push(s);else if(s.headers)for(var o=0;o=n);o++){var u=s.headers[o];u.title&&h(t,s,u.title)&&r.push(Object.assign({},s,{path:s.path+"#"+u.slug,header:u}))}}return r}},alignRight:function(){return(this.$site.themeConfig.nav||[]).length+(this.$site.repo?1:0)<=2}},mounted:function(){this.placeholder=this.$site.themeConfig.searchPlaceholder||"",document.addEventListener("keydown",this.onHotkey)},beforeDestroy:function(){document.removeEventListener("keydown",this.onHotkey)},methods:{getPageLocalePath:function(t){for(var e in this.$site.locales||{})if("/"!==e&&0===t.path.indexOf(e))return e;return"/"},isSearchable:function(t){var e=null;return null===e||(e=Array.isArray(e)?e:new Array(e)).filter((function(e){return t.path.match(e)})).length>0},onHotkey:function(t){t.srcElement===document.body&&["s","/"].includes(t.key)&&(this.$refs.input.focus(),t.preventDefault())},onUp:function(){this.showSuggestions&&(this.focusIndex>0?this.focusIndex--:this.focusIndex=this.suggestions.length-1)},onDown:function(){this.showSuggestions&&(this.focusIndex "+t._s(e.header.title))]):t._e()])])})),0):t._e()])}),[],!1,null,null,null).exports),g=(n(315),Object(a.a)({},(function(){var t=this,e=t.$createElement,n=t._self._c||e;return n("div",{staticClass:"sidebar-button",on:{click:function(e){return t.$emit("toggle-sidebar")}}},[n("svg",{staticClass:"icon",attrs:{xmlns:"http://www.w3.org/2000/svg","aria-hidden":"true",role:"img",viewBox:"0 0 448 512"}},[n("path",{attrs:{fill:"currentColor",d:"M436 124H12c-6.627 0-12-5.373-12-12V80c0-6.627 5.373-12 12-12h424c6.627 0 12 5.373 12 12v32c0 6.627-5.373 12-12 12zm0 160H12c-6.627 0-12-5.373-12-12v-32c0-6.627 5.373-12 12-12h424c6.627 0 12 5.373 12 12v32c0 6.627-5.373 12-12 12zm0 160H12c-6.627 0-12-5.373-12-12v-32c0-6.627 5.373-12 12-12h424c6.627 0 12 5.373 12 12v32c0 6.627-5.373 12-12 12z"}})])])}),[],!1,null,null,null).exports),v=(n(152),n(35)),m=n(304),b=n(154),k=n.n(b),_={name:"DropdownLink",components:{NavLink:s,DropdownTransition:m.a},props:{item:{required:!0}},data:function(){return{open:!1}},computed:{dropdownAriaLabel:function(){return this.item.ariaLabel||this.item.text}},watch:{$route:function(){this.open=!1}},methods:{setOpen:function(t){this.open=t},isLastItemOfArray:function(t,e){return k()(e)===t}}},x=(n(317),{name:"NavLinks",components:{NavLink:s,DropdownLink:Object(a.a)(_,(function(){var t=this,e=t.$createElement,n=t._self._c||e;return n("div",{staticClass:"dropdown-wrapper",class:{open:t.open}},[n("button",{staticClass:"dropdown-title",attrs:{type:"button","aria-label":t.dropdownAriaLabel},on:{click:function(e){return t.setOpen(!t.open)}}},[n("span",{staticClass:"title"},[t._v(t._s(t.item.text))]),t._v(" "),n("span",{staticClass:"arrow",class:t.open?"down":"right"})]),t._v(" "),n("DropdownTransition",[n("ul",{directives:[{name:"show",rawName:"v-show",value:t.open,expression:"open"}],staticClass:"nav-dropdown"},t._l(t.item.items,(function(e,i){return n("li",{key:e.link||i,staticClass:"dropdown-item"},["links"===e.type?n("h4",[t._v("\n "+t._s(e.text)+"\n ")]):t._e(),t._v(" "),"links"===e.type?n("ul",{staticClass:"dropdown-subitem-wrapper"},t._l(e.items,(function(i){return n("li",{key:i.link,staticClass:"dropdown-subitem"},[n("NavLink",{attrs:{item:i},on:{focusout:function(n){t.isLastItemOfArray(i,e.items)&&t.isLastItemOfArray(e,t.item.items)&&t.setOpen(!1)}}})],1)})),0):n("NavLink",{attrs:{item:e},on:{focusout:function(n){t.isLastItemOfArray(e,t.item.items)&&t.setOpen(!1)}}})],1)})),0)])],1)}),[],!1,null,null,null).exports},computed:{userNav:function(){return this.$themeLocaleConfig.nav||this.$site.themeConfig.nav||[]},nav:function(){var t=this,e=this.$site.locales;if(e&&Object.keys(e).length>1){var n=this.$page.path,i=this.$router.options.routes,r=this.$site.themeConfig.locales||{},a={text:this.$themeLocaleConfig.selectText||"Languages",ariaLabel:this.$themeLocaleConfig.ariaLabel||"Select language",items:Object.keys(e).map((function(a){var s,o=e[a],u=r[a]&&r[a].label||o.lang;return o.lang===t.$lang?s=n:(s=n.replace(t.$localeConfig.path,a),i.some((function(t){return t.path===s}))||(s=a)),{text:u,link:s}}))};return[].concat(Object(v.a)(this.userNav),[a])}return this.userNav},userLinks:function(){return(this.nav||[]).map((function(t){return Object.assign(Object(i.j)(t),{items:(t.items||[]).map(i.j)})}))},repoLink:function(){var t=this.$site.themeConfig.repo;return t?/^https?:/.test(t)?t:"https://github.com/".concat(t):null},repoLabel:function(){if(this.repoLink){if(this.$site.themeConfig.repoLabel)return this.$site.themeConfig.repoLabel;for(var t=this.repoLink.match(/^https?:\/\/[^/]+/)[0],e=["GitHub","GitLab","Bitbucket"],n=0;nMath.abs(n)&&Math.abs(e)>40&&(e>0&&this.touchStart.x<=80?this.toggleSidebar(!0):this.toggleSidebar(!1))}}}),B=Object(a.a)(W,(function(){var t=this,e=t.$createElement,n=t._self._c||e;return n("div",{staticClass:"theme-container",class:t.pageClasses,on:{touchstart:t.onTouchStart,touchend:t.onTouchEnd}},[t.shouldShowNavbar?n("Navbar",{on:{"toggle-sidebar":t.toggleSidebar}}):t._e(),t._v(" "),n("div",{staticClass:"sidebar-mask",on:{click:function(e){return t.toggleSidebar(!1)}}}),t._v(" "),n("Sidebar",{attrs:{items:t.sidebarItems},on:{"toggle-sidebar":t.toggleSidebar},scopedSlots:t._u([{key:"top",fn:function(){return[t._t("sidebar-top")]},proxy:!0},{key:"bottom",fn:function(){return[t._t("sidebar-bottom")]},proxy:!0}],null,!0)}),t._v(" "),t.$page.frontmatter.home?n("Home"):n("Page",{attrs:{"sidebar-items":t.sidebarItems},scopedSlots:t._u([{key:"top",fn:function(){return[t._t("page-top")]},proxy:!0},{key:"bottom",fn:function(){return[t._t("page-bottom")]},proxy:!0}],null,!0)})],1)}),[],!1,null,null,null);e.default=B.exports}}]); \ No newline at end of file diff --git a/okhttps-doc/docs/.vuepress/dist/assets/js/3.972ca2ed.js b/okhttps-doc/docs/.vuepress/dist/assets/js/3.972ca2ed.js new file mode 100644 index 00000000..1f8e660f --- /dev/null +++ b/okhttps-doc/docs/.vuepress/dist/assets/js/3.972ca2ed.js @@ -0,0 +1 @@ +(window.webpackJsonp=window.webpackJsonp||[]).push([[3],{297:function(t,e,n){},328:function(t,e,n){"use strict";var i=n(297);n.n(i).a},334:function(t,e,n){"use strict";n.r(e);var i={functional:!0,props:{type:{type:String,default:"tip"},text:String,vertical:{type:String,default:"top"}},render:function(t,e){var n=e.props,i=e.slots;return t("span",{class:["badge",n.type],style:{verticalAlign:n.vertical}},n.text||i().default)}},r=(n(328),n(19)),a=Object(r.a)(i,void 0,void 0,!1,null,"15b7b770",null);e.default=a.exports}}]); \ No newline at end of file diff --git a/okhttps-doc/docs/.vuepress/dist/assets/js/4.fe3bf0b0.js b/okhttps-doc/docs/.vuepress/dist/assets/js/4.fe3bf0b0.js new file mode 100644 index 00000000..6c638411 --- /dev/null +++ b/okhttps-doc/docs/.vuepress/dist/assets/js/4.fe3bf0b0.js @@ -0,0 +1 @@ +(window.webpackJsonp=window.webpackJsonp||[]).push([[4],{331:function(t,e,s){"use strict";s.r(e);var n=["There's nothing here.","How did we get here?","That's a Four-Oh-Four.","Looks like we've got some broken links."],o={methods:{getMsg:function(){return n[Math.floor(Math.random()*n.length)]}}},i=s(19),h=Object(i.a)(o,(function(){var t=this.$createElement,e=this._self._c||t;return e("div",{staticClass:"theme-container"},[e("div",{staticClass:"theme-default-content"},[e("h1",[this._v("404")]),this._v(" "),e("blockquote",[this._v(this._s(this.getMsg()))]),this._v(" "),e("RouterLink",{attrs:{to:"/"}},[this._v("\n Take me home.\n ")])],1)])}),[],!1,null,null,null);e.default=h.exports}}]); \ No newline at end of file diff --git a/okhttps-doc/docs/.vuepress/dist/assets/js/5.93d38f11.js b/okhttps-doc/docs/.vuepress/dist/assets/js/5.93d38f11.js new file mode 100644 index 00000000..8b93dda2 --- /dev/null +++ b/okhttps-doc/docs/.vuepress/dist/assets/js/5.93d38f11.js @@ -0,0 +1 @@ +(window.webpackJsonp=window.webpackJsonp||[]).push([[5],{330:function(e,t,a){"use strict";a.r(t);a(143),a(92),a(81);var n={props:{name:{type:String,default:"default"},isolated:{type:Boolean,default:!1},languages:Object},data:function(){return{selectedLanguage:Object.keys(this.languages)[0]}},computed:{root:function(){for(var e,t=this;e=t.$parent;)t=e;return t},localStorageKey:function(){return"vuepress-plugin-code-switcher@".concat(this.name)}},methods:{switchLanguage:function(e){if(this.isolated)return this.selectedLanguage=e;"undefined"!=typeof localStorage&&localStorage.setItem(this.localStorageKey,e),this.root.$emit("change",{name:this.name,value:e})}},created:function(){var e=this;if(!this.isolated){if("undefined"!=typeof localStorage){var t=localStorage.getItem(this.localStorageKey);t&&-1!==Object.keys(this.languages).indexOf(t)&&(this.selectedLanguage=t)}this.root.$on("change",(function(t){var a=t.name,n=t.value;a===e.name&&(e.selectedLanguage=n)}))}}},s=a(19),i=Object(s.a)(n,(function(){var e=this,t=e.$createElement,a=e._self._c||t;return a("div",{staticClass:"code-switcher"},[a("div",{staticClass:"tab-header"},[a("ul",e._l(e.languages,(function(t,n){return a("li",{key:n,class:{active:e.selectedLanguage===n},on:{click:function(t){return e.switchLanguage(n)}}},[e._v(" "+e._s(t)+"\n ")])})),0)]),e._v(" "),e._l(e.languages,(function(t,n){return a("div",{directives:[{name:"show",rawName:"v-show",value:n===e.selectedLanguage,expression:"shorthand === selectedLanguage"}],key:n,staticClass:"tab-content"},[e._t(n)],2)}))],2)}),[],!1,null,null,null);t.default=i.exports}}]); \ No newline at end of file diff --git a/okhttps-doc/docs/.vuepress/dist/assets/js/6.fd474f39.js b/okhttps-doc/docs/.vuepress/dist/assets/js/6.fd474f39.js new file mode 100644 index 00000000..66342655 --- /dev/null +++ b/okhttps-doc/docs/.vuepress/dist/assets/js/6.fd474f39.js @@ -0,0 +1 @@ +(window.webpackJsonp=window.webpackJsonp||[]).push([[6],{337:function(s,t,n){"use strict";n.r(t);var a=n(19),e=Object(a.a)({},(function(){var s=this,t=s.$createElement,n=s._self._c||t;return n("ContentSlotsDistributor",{attrs:{"slot-key":s.$parent.slotKey}},[n("div",{staticClass:"language-java line-numbers-mode"},[n("pre",{pre:!0,attrs:{class:"language-java"}},[n("code",[n("span",{pre:!0,attrs:{class:"token comment"}},[s._v("// 构建 HTTP")]),s._v("\n"),n("span",{pre:!0,attrs:{class:"token class-name"}},[s._v("HTTP")]),s._v(" http "),n("span",{pre:!0,attrs:{class:"token operator"}},[s._v("=")]),s._v(" HTTP"),n("span",{pre:!0,attrs:{class:"token punctuation"}},[s._v(".")]),n("span",{pre:!0,attrs:{class:"token function"}},[s._v("builder")]),n("span",{pre:!0,attrs:{class:"token punctuation"}},[s._v("(")]),n("span",{pre:!0,attrs:{class:"token punctuation"}},[s._v(")")]),s._v("\n "),n("span",{pre:!0,attrs:{class:"token punctuation"}},[s._v(".")]),n("span",{pre:!0,attrs:{class:"token function"}},[s._v("baseUrl")]),n("span",{pre:!0,attrs:{class:"token punctuation"}},[s._v("(")]),n("span",{pre:!0,attrs:{class:"token string"}},[s._v('"https://api.demo.com"')]),n("span",{pre:!0,attrs:{class:"token punctuation"}},[s._v(")")]),s._v("\n "),n("span",{pre:!0,attrs:{class:"token punctuation"}},[s._v(".")]),n("span",{pre:!0,attrs:{class:"token function"}},[s._v("build")]),n("span",{pre:!0,attrs:{class:"token punctuation"}},[s._v("(")]),n("span",{pre:!0,attrs:{class:"token punctuation"}},[s._v(")")]),n("span",{pre:!0,attrs:{class:"token punctuation"}},[s._v(";")]),s._v("\n\n"),n("span",{pre:!0,attrs:{class:"token comment"}},[s._v("// 同步请求")]),s._v("\n"),n("span",{pre:!0,attrs:{class:"token class-name"}},[s._v("List")]),n("span",{pre:!0,attrs:{class:"token generics"}},[n("span",{pre:!0,attrs:{class:"token punctuation"}},[s._v("<")]),n("span",{pre:!0,attrs:{class:"token class-name"}},[s._v("User")]),n("span",{pre:!0,attrs:{class:"token punctuation"}},[s._v(">")])]),s._v(" users "),n("span",{pre:!0,attrs:{class:"token operator"}},[s._v("=")]),s._v(" http"),n("span",{pre:!0,attrs:{class:"token punctuation"}},[s._v(".")]),n("span",{pre:!0,attrs:{class:"token function"}},[s._v("sync")]),n("span",{pre:!0,attrs:{class:"token punctuation"}},[s._v("(")]),n("span",{pre:!0,attrs:{class:"token string"}},[s._v('"/users"')]),n("span",{pre:!0,attrs:{class:"token punctuation"}},[s._v(")")]),s._v(" "),n("span",{pre:!0,attrs:{class:"token comment"}},[s._v("// http://api.demo.com/users")]),s._v("\n "),n("span",{pre:!0,attrs:{class:"token punctuation"}},[s._v(".")]),n("span",{pre:!0,attrs:{class:"token function"}},[s._v("get")]),n("span",{pre:!0,attrs:{class:"token punctuation"}},[s._v("(")]),n("span",{pre:!0,attrs:{class:"token punctuation"}},[s._v(")")]),s._v(" "),n("span",{pre:!0,attrs:{class:"token comment"}},[s._v("// GET请求")]),s._v("\n "),n("span",{pre:!0,attrs:{class:"token punctuation"}},[s._v(".")]),n("span",{pre:!0,attrs:{class:"token function"}},[s._v("getBody")]),n("span",{pre:!0,attrs:{class:"token punctuation"}},[s._v("(")]),n("span",{pre:!0,attrs:{class:"token punctuation"}},[s._v(")")]),s._v(" "),n("span",{pre:!0,attrs:{class:"token comment"}},[s._v("// 获取响应报文体")]),s._v("\n "),n("span",{pre:!0,attrs:{class:"token punctuation"}},[s._v(".")]),n("span",{pre:!0,attrs:{class:"token function"}},[s._v("toList")]),n("span",{pre:!0,attrs:{class:"token punctuation"}},[s._v("(")]),n("span",{pre:!0,attrs:{class:"token class-name"}},[s._v("User")]),n("span",{pre:!0,attrs:{class:"token punctuation"}},[s._v(".")]),n("span",{pre:!0,attrs:{class:"token keyword"}},[s._v("class")]),n("span",{pre:!0,attrs:{class:"token punctuation"}},[s._v(")")]),n("span",{pre:!0,attrs:{class:"token punctuation"}},[s._v(";")]),s._v(" "),n("span",{pre:!0,attrs:{class:"token comment"}},[s._v("// 得到目标数据")]),s._v("\n\n"),n("span",{pre:!0,attrs:{class:"token comment"}},[s._v("// 异步请求")]),s._v("\nhttp"),n("span",{pre:!0,attrs:{class:"token punctuation"}},[s._v(".")]),n("span",{pre:!0,attrs:{class:"token function"}},[s._v("async")]),n("span",{pre:!0,attrs:{class:"token punctuation"}},[s._v("(")]),n("span",{pre:!0,attrs:{class:"token string"}},[s._v('"/users/jack"')]),n("span",{pre:!0,attrs:{class:"token punctuation"}},[s._v(")")]),s._v(" "),n("span",{pre:!0,attrs:{class:"token comment"}},[s._v("// http://api.demo.com/users/jack")]),s._v("\n "),n("span",{pre:!0,attrs:{class:"token punctuation"}},[s._v(".")]),n("span",{pre:!0,attrs:{class:"token function"}},[s._v("setOnResponse")]),n("span",{pre:!0,attrs:{class:"token punctuation"}},[s._v("(")]),n("span",{pre:!0,attrs:{class:"token punctuation"}},[s._v("(")]),n("span",{pre:!0,attrs:{class:"token class-name"}},[s._v("HttpResult")]),s._v(" result"),n("span",{pre:!0,attrs:{class:"token punctuation"}},[s._v(")")]),s._v(" "),n("span",{pre:!0,attrs:{class:"token operator"}},[s._v("->")]),s._v(" "),n("span",{pre:!0,attrs:{class:"token punctuation"}},[s._v("{")]),s._v("\n "),n("span",{pre:!0,attrs:{class:"token comment"}},[s._v("// 得到目标数据")]),s._v("\n "),n("span",{pre:!0,attrs:{class:"token class-name"}},[s._v("User")]),s._v(" jack "),n("span",{pre:!0,attrs:{class:"token operator"}},[s._v("=")]),s._v(" result"),n("span",{pre:!0,attrs:{class:"token punctuation"}},[s._v(".")]),n("span",{pre:!0,attrs:{class:"token function"}},[s._v("getBody")]),n("span",{pre:!0,attrs:{class:"token punctuation"}},[s._v("(")]),n("span",{pre:!0,attrs:{class:"token punctuation"}},[s._v(")")]),n("span",{pre:!0,attrs:{class:"token punctuation"}},[s._v(".")]),n("span",{pre:!0,attrs:{class:"token function"}},[s._v("toBean")]),n("span",{pre:!0,attrs:{class:"token punctuation"}},[s._v("(")]),n("span",{pre:!0,attrs:{class:"token class-name"}},[s._v("User")]),n("span",{pre:!0,attrs:{class:"token punctuation"}},[s._v(".")]),n("span",{pre:!0,attrs:{class:"token keyword"}},[s._v("class")]),n("span",{pre:!0,attrs:{class:"token punctuation"}},[s._v(")")]),n("span",{pre:!0,attrs:{class:"token punctuation"}},[s._v(";")]),s._v("\n "),n("span",{pre:!0,attrs:{class:"token punctuation"}},[s._v("}")]),n("span",{pre:!0,attrs:{class:"token punctuation"}},[s._v(")")]),s._v("\n "),n("span",{pre:!0,attrs:{class:"token punctuation"}},[s._v(".")]),n("span",{pre:!0,attrs:{class:"token function"}},[s._v("get")]),n("span",{pre:!0,attrs:{class:"token punctuation"}},[s._v("(")]),n("span",{pre:!0,attrs:{class:"token punctuation"}},[s._v(")")]),n("span",{pre:!0,attrs:{class:"token punctuation"}},[s._v(";")]),s._v(" "),n("span",{pre:!0,attrs:{class:"token comment"}},[s._v("// GET请求")]),s._v("\n")])]),s._v(" "),n("div",{staticClass:"line-numbers-wrapper"},[n("span",{staticClass:"line-number"},[s._v("1")]),n("br"),n("span",{staticClass:"line-number"},[s._v("2")]),n("br"),n("span",{staticClass:"line-number"},[s._v("3")]),n("br"),n("span",{staticClass:"line-number"},[s._v("4")]),n("br"),n("span",{staticClass:"line-number"},[s._v("5")]),n("br"),n("span",{staticClass:"line-number"},[s._v("6")]),n("br"),n("span",{staticClass:"line-number"},[s._v("7")]),n("br"),n("span",{staticClass:"line-number"},[s._v("8")]),n("br"),n("span",{staticClass:"line-number"},[s._v("9")]),n("br"),n("span",{staticClass:"line-number"},[s._v("10")]),n("br"),n("span",{staticClass:"line-number"},[s._v("11")]),n("br"),n("span",{staticClass:"line-number"},[s._v("12")]),n("br"),n("span",{staticClass:"line-number"},[s._v("13")]),n("br"),n("span",{staticClass:"line-number"},[s._v("14")]),n("br"),n("span",{staticClass:"line-number"},[s._v("15")]),n("br"),n("span",{staticClass:"line-number"},[s._v("16")]),n("br"),n("span",{staticClass:"line-number"},[s._v("17")]),n("br"),n("span",{staticClass:"line-number"},[s._v("18")]),n("br")])]),s._v(" "),n("p",[n("strong",[n("center",[s._v("竟然不到 "),n("font",{attrs:{size:"5"}},[s._v("15")]),s._v(" 秒，你已学会 "),n("font",{attrs:{size:"6"}},[s._v("90")]),s._v("% 的精髓！")],1)],1),s._v(" "),n("center",[n("RouterLink",{attrs:{to:"/guide/"}},[n("strong",[s._v("了解更多")])])],1)],1)])}),[],!1,null,null,null);t.default=e.exports}}]); \ No newline at end of file diff --git a/okhttps-doc/docs/.vuepress/dist/assets/js/7.51e5642d.js b/okhttps-doc/docs/.vuepress/dist/assets/js/7.51e5642d.js new file mode 100644 index 00000000..c76c8a33 --- /dev/null +++ b/okhttps-doc/docs/.vuepress/dist/assets/js/7.51e5642d.js @@ -0,0 +1 @@ +(window.webpackJsonp=window.webpackJsonp||[]).push([[7],{338:function(s,t,a){"use strict";a.r(t);var n=a(19),e=Object(n.a)({},(function(){var s=this,t=s.$createElement,a=s._self._c||t;return a("ContentSlotsDistributor",{attrs:{"slot-key":s.$parent.slotKey}},[a("h1",{attrs:{id:"起步"}},[a("a",{staticClass:"header-anchor",attrs:{href:"#起步"}},[s._v("#")]),s._v(" 起步")]),s._v(" "),a("p",[s._v("OkHttps 是近期开源的对 OkHttp3 轻量封装的框架，它独创的异步预处理器，特色的标签，灵活的上传下载进度监听与过程控制功能，在轻松解决很多原本另人头疼问题的同时，设计上也力求纯粹与优雅。")]),s._v(" "),a("ul",[a("li",[s._v("链式调用，一点到底")]),s._v(" "),a("li",[s._v("BaseURL、URL占位符、JSON自动封装与解析")]),s._v(" "),a("li",[s._v("同步拦截器、异步预处理器、回调执行器、全局监听、回调阻断")]),s._v(" "),a("li",[s._v("文件上传下载（过程控制、进度监听）")]),s._v(" "),a("li",[s._v("单方法回调，充分利用 Lambda 表达式")]),s._v(" "),a("li",[s._v("TCP连接池、Http2")])]),s._v(" "),a("div",{staticClass:"custom-block tip"},[a("p",{staticClass:"custom-block-title"},[s._v("TIP")]),s._v(" "),a("ul",[a("li",[s._v("OkHttps 非常轻量（59Kb），仅是 Retrofit（124Kb）的一半，并且更加的开箱即用，API 也更加自然和语义化。")]),s._v(" "),a("li",[s._v("OkHttps 是一个纯粹的 Java 网络开发包，并不依赖 Android，这一点和 Retrofit 不同")]),s._v(" "),a("li",[s._v("OkHttps 用起来很优美，可以像 RxJava 那样链式用，却比 RxJava 更简单。")])])]),s._v(" "),a("h2",{attrs:{id:"安装"}},[a("a",{staticClass:"header-anchor",attrs:{href:"#安装"}},[s._v("#")]),s._v(" 安装")]),s._v(" "),a("h3",{attrs:{id:"maven"}},[a("a",{staticClass:"header-anchor",attrs:{href:"#maven"}},[s._v("#")]),s._v(" Maven")]),s._v(" "),a("div",{staticClass:"language-xml line-numbers-mode"},[a("pre",{pre:!0,attrs:{class:"language-xml"}},[a("code",[a("span",{pre:!0,attrs:{class:"token tag"}},[a("span",{pre:!0,attrs:{class:"token tag"}},[a("span",{pre:!0,attrs:{class:"token punctuation"}},[s._v("<")]),s._v("dependency")]),a("span",{pre:!0,attrs:{class:"token punctuation"}},[s._v(">")])]),s._v("\n "),a("span",{pre:!0,attrs:{class:"token tag"}},[a("span",{pre:!0,attrs:{class:"token tag"}},[a("span",{pre:!0,attrs:{class:"token punctuation"}},[s._v("<")]),s._v("groupId")]),a("span",{pre:!0,attrs:{class:"token punctuation"}},[s._v(">")])]),s._v("com.ejlchina"),a("span",{pre:!0,attrs:{class:"token tag"}},[a("span",{pre:!0,attrs:{class:"token tag"}},[a("span",{pre:!0,attrs:{class:"token punctuation"}},[s._v("")])]),s._v("\n "),a("span",{pre:!0,attrs:{class:"token tag"}},[a("span",{pre:!0,attrs:{class:"token tag"}},[a("span",{pre:!0,attrs:{class:"token punctuation"}},[s._v("<")]),s._v("artifactId")]),a("span",{pre:!0,attrs:{class:"token punctuation"}},[s._v(">")])]),s._v("okhttps"),a("span",{pre:!0,attrs:{class:"token tag"}},[a("span",{pre:!0,attrs:{class:"token tag"}},[a("span",{pre:!0,attrs:{class:"token punctuation"}},[s._v("")])]),s._v("\n "),a("span",{pre:!0,attrs:{class:"token tag"}},[a("span",{pre:!0,attrs:{class:"token tag"}},[a("span",{pre:!0,attrs:{class:"token punctuation"}},[s._v("<")]),s._v("version")]),a("span",{pre:!0,attrs:{class:"token punctuation"}},[s._v(">")])]),s._v("1.0.5"),a("span",{pre:!0,attrs:{class:"token tag"}},[a("span",{pre:!0,attrs:{class:"token tag"}},[a("span",{pre:!0,attrs:{class:"token punctuation"}},[s._v("")])]),s._v("\n"),a("span",{pre:!0,attrs:{class:"token tag"}},[a("span",{pre:!0,attrs:{class:"token tag"}},[a("span",{pre:!0,attrs:{class:"token punctuation"}},[s._v("")])]),s._v("\n")])]),s._v(" "),a("div",{staticClass:"line-numbers-wrapper"},[a("span",{staticClass:"line-number"},[s._v("1")]),a("br"),a("span",{staticClass:"line-number"},[s._v("2")]),a("br"),a("span",{staticClass:"line-number"},[s._v("3")]),a("br"),a("span",{staticClass:"line-number"},[s._v("4")]),a("br"),a("span",{staticClass:"line-number"},[s._v("5")]),a("br")])]),a("h3",{attrs:{id:"gradle"}},[a("a",{staticClass:"header-anchor",attrs:{href:"#gradle"}},[s._v("#")]),s._v(" Gradle")]),s._v(" "),a("div",{staticClass:"language-groovy line-numbers-mode"},[a("pre",{pre:!0,attrs:{class:"language-groovy"}},[a("code",[s._v("implementation "),a("span",{pre:!0,attrs:{class:"token string"}},[s._v("'com.ejlchina:okhttps:1.0.5'")]),s._v("\n")])]),s._v(" "),a("div",{staticClass:"line-numbers-wrapper"},[a("span",{staticClass:"line-number"},[s._v("1")]),a("br")])]),a("p",[s._v("安卓中使用需要把 JDK 版本调成 1.8，在 app 模块的 build.gradle 中加入以下配置即可：")]),s._v(" "),a("div",{staticClass:"language-groovy line-numbers-mode"},[a("pre",{pre:!0,attrs:{class:"language-groovy"}},[a("code",[s._v("android "),a("span",{pre:!0,attrs:{class:"token punctuation"}},[s._v("{")]),s._v("\n "),a("span",{pre:!0,attrs:{class:"token comment"}},[s._v("// 省略其它配置..")]),s._v("\n compileOptions "),a("span",{pre:!0,attrs:{class:"token punctuation"}},[s._v("{")]),s._v("\n sourceCompatibility "),a("span",{pre:!0,attrs:{class:"token operator"}},[s._v("=")]),s._v(" "),a("span",{pre:!0,attrs:{class:"token number"}},[s._v("1.8")]),s._v("\n targetCompatibility "),a("span",{pre:!0,attrs:{class:"token operator"}},[s._v("=")]),s._v(" "),a("span",{pre:!0,attrs:{class:"token number"}},[s._v("1.8")]),s._v("\n "),a("span",{pre:!0,attrs:{class:"token punctuation"}},[s._v("}")]),s._v("\n"),a("span",{pre:!0,attrs:{class:"token punctuation"}},[s._v("}")]),s._v("\n")])]),s._v(" "),a("div",{staticClass:"line-numbers-wrapper"},[a("span",{staticClass:"line-number"},[s._v("1")]),a("br"),a("span",{staticClass:"line-number"},[s._v("2")]),a("br"),a("span",{staticClass:"line-number"},[s._v("3")]),a("br"),a("span",{staticClass:"line-number"},[s._v("4")]),a("br"),a("span",{staticClass:"line-number"},[s._v("5")]),a("br"),a("span",{staticClass:"line-number"},[s._v("6")]),a("br"),a("span",{staticClass:"line-number"},[s._v("7")]),a("br")])]),a("h2",{attrs:{id:"使用"}},[a("a",{staticClass:"header-anchor",attrs:{href:"#使用"}},[s._v("#")]),s._v(" 使用")]),s._v(" "),a("h3",{attrs:{id:"构建实例"}},[a("a",{staticClass:"header-anchor",attrs:{href:"#构建实例"}},[s._v("#")]),s._v(" 构建实例")]),s._v(" "),a("div",{staticClass:"language-java line-numbers-mode"},[a("pre",{pre:!0,attrs:{class:"language-java"}},[a("code",[a("span",{pre:!0,attrs:{class:"token class-name"}},[s._v("HTTP")]),s._v(" http "),a("span",{pre:!0,attrs:{class:"token operator"}},[s._v("=")]),s._v(" HTTP"),a("span",{pre:!0,attrs:{class:"token punctuation"}},[s._v(".")]),a("span",{pre:!0,attrs:{class:"token function"}},[s._v("builder")]),a("span",{pre:!0,attrs:{class:"token punctuation"}},[s._v("(")]),a("span",{pre:!0,attrs:{class:"token punctuation"}},[s._v(")")]),a("span",{pre:!0,attrs:{class:"token punctuation"}},[s._v(".")]),a("span",{pre:!0,attrs:{class:"token function"}},[s._v("build")]),a("span",{pre:!0,attrs:{class:"token punctuation"}},[s._v("(")]),a("span",{pre:!0,attrs:{class:"token punctuation"}},[s._v(")")]),a("span",{pre:!0,attrs:{class:"token punctuation"}},[s._v(";")]),s._v("\n")])]),s._v(" "),a("div",{staticClass:"line-numbers-wrapper"},[a("span",{staticClass:"line-number"},[s._v("1")]),a("br")])]),a("p",[s._v("以上代码构建了一个最简单的"),a("code",[s._v("HTTP")]),s._v("实例，它拥有以下方法：")]),s._v(" "),a("ul",[a("li",[a("code",[s._v("sync(String url)")]),s._v(" 开始一个同步请求")]),s._v(" "),a("li",[a("code",[s._v("async(String url)")]),s._v(" 开始一个异步请求")]),s._v(" "),a("li",[a("code",[s._v("cancel(String tag)")]),s._v(" 按标签取消请求")]),s._v(" "),a("li",[a("code",[s._v("cancelAll()")]),s._v(" 取消所有HTTP任务，包括同步和异步")]),s._v(" "),a("li",[a("code",[s._v("request(Request request)")]),s._v(" OkHttp 原生请求")]),s._v(" "),a("li",[a("code",[s._v("webSocket(Request request, WebSocketListener listener)")]),s._v(" WebSocket通讯")])]),s._v(" "),a("p",[s._v("为了使用方便，在构建的时候，我们更愿意指定一个"),a("code",[s._v("BaseUrl")]),s._v("（详见 "),a("RouterLink",{attrs:{to:"/guide/configuration.html#设置-baseurl"}},[s._v("设置 BaseUrl")]),s._v("）:")],1),s._v(" "),a("div",{staticClass:"language-java line-numbers-mode"},[a("pre",{pre:!0,attrs:{class:"language-java"}},[a("code",[a("span",{pre:!0,attrs:{class:"token class-name"}},[s._v("HTTP")]),s._v(" http "),a("span",{pre:!0,attrs:{class:"token operator"}},[s._v("=")]),s._v(" HTTP"),a("span",{pre:!0,attrs:{class:"token punctuation"}},[s._v(".")]),a("span",{pre:!0,attrs:{class:"token function"}},[s._v("builder")]),a("span",{pre:!0,attrs:{class:"token punctuation"}},[s._v("(")]),a("span",{pre:!0,attrs:{class:"token punctuation"}},[s._v(")")]),s._v("\n "),a("span",{pre:!0,attrs:{class:"token punctuation"}},[s._v(".")]),a("span",{pre:!0,attrs:{class:"token function"}},[s._v("baseUrl")]),a("span",{pre:!0,attrs:{class:"token punctuation"}},[s._v("(")]),a("span",{pre:!0,attrs:{class:"token string"}},[s._v('"http://api.demo.com"')]),a("span",{pre:!0,attrs:{class:"token punctuation"}},[s._v(")")]),s._v("\n "),a("span",{pre:!0,attrs:{class:"token punctuation"}},[s._v(".")]),a("span",{pre:!0,attrs:{class:"token function"}},[s._v("build")]),a("span",{pre:!0,attrs:{class:"token punctuation"}},[s._v("(")]),a("span",{pre:!0,attrs:{class:"token punctuation"}},[s._v(")")]),a("span",{pre:!0,attrs:{class:"token punctuation"}},[s._v(";")]),s._v("\n")])]),s._v(" "),a("div",{staticClass:"line-numbers-wrapper"},[a("span",{staticClass:"line-number"},[s._v("1")]),a("br"),a("span",{staticClass:"line-number"},[s._v("2")]),a("br"),a("span",{staticClass:"line-number"},[s._v("3")]),a("br")])]),a("p",[s._v("为了简化文档，下文中出现的"),a("code",[s._v("http")]),s._v("均是在构建时设置了"),a("code",[s._v("BaseUrl")]),s._v("的"),a("code",[s._v("HTTP")]),s._v("实例。")]),s._v(" "),a("h3",{attrs:{id:"同步请求"}},[a("a",{staticClass:"header-anchor",attrs:{href:"#同步请求"}},[s._v("#")]),s._v(" 同步请求")]),s._v(" "),a("p",[s._v("使用方法"),a("code",[s._v("sync(String url)")]),s._v("开始一个同步请求：")]),s._v(" "),a("div",{staticClass:"language-java line-numbers-mode"},[a("pre",{pre:!0,attrs:{class:"language-java"}},[a("code",[a("span",{pre:!0,attrs:{class:"token class-name"}},[s._v("List")]),a("span",{pre:!0,attrs:{class:"token generics"}},[a("span",{pre:!0,attrs:{class:"token punctuation"}},[s._v("<")]),a("span",{pre:!0,attrs:{class:"token class-name"}},[s._v("User")]),a("span",{pre:!0,attrs:{class:"token punctuation"}},[s._v(">")])]),s._v(" users "),a("span",{pre:!0,attrs:{class:"token operator"}},[s._v("=")]),s._v(" http"),a("span",{pre:!0,attrs:{class:"token punctuation"}},[s._v(".")]),a("span",{pre:!0,attrs:{class:"token function"}},[s._v("sync")]),a("span",{pre:!0,attrs:{class:"token punctuation"}},[s._v("(")]),a("span",{pre:!0,attrs:{class:"token string"}},[s._v('"/users"')]),a("span",{pre:!0,attrs:{class:"token punctuation"}},[s._v(")")]),s._v(" "),a("span",{pre:!0,attrs:{class:"token comment"}},[s._v("// http://api.demo.com/users")]),s._v("\n "),a("span",{pre:!0,attrs:{class:"token punctuation"}},[s._v(".")]),a("span",{pre:!0,attrs:{class:"token function"}},[s._v("get")]),a("span",{pre:!0,attrs:{class:"token punctuation"}},[s._v("(")]),a("span",{pre:!0,attrs:{class:"token punctuation"}},[s._v(")")]),s._v(" "),a("span",{pre:!0,attrs:{class:"token comment"}},[s._v("// GET请求")]),s._v("\n "),a("span",{pre:!0,attrs:{class:"token punctuation"}},[s._v(".")]),a("span",{pre:!0,attrs:{class:"token function"}},[s._v("getBody")]),a("span",{pre:!0,attrs:{class:"token punctuation"}},[s._v("(")]),a("span",{pre:!0,attrs:{class:"token punctuation"}},[s._v(")")]),s._v(" "),a("span",{pre:!0,attrs:{class:"token comment"}},[s._v("// 获取响应报文体")]),s._v("\n "),a("span",{pre:!0,attrs:{class:"token punctuation"}},[s._v(".")]),a("span",{pre:!0,attrs:{class:"token function"}},[s._v("toList")]),a("span",{pre:!0,attrs:{class:"token punctuation"}},[s._v("(")]),a("span",{pre:!0,attrs:{class:"token class-name"}},[s._v("User")]),a("span",{pre:!0,attrs:{class:"token punctuation"}},[s._v(".")]),a("span",{pre:!0,attrs:{class:"token keyword"}},[s._v("class")]),a("span",{pre:!0,attrs:{class:"token punctuation"}},[s._v(")")]),a("span",{pre:!0,attrs:{class:"token punctuation"}},[s._v(";")]),s._v(" "),a("span",{pre:!0,attrs:{class:"token comment"}},[s._v("// 得到目标数据")]),s._v("\n")])]),s._v(" "),a("div",{staticClass:"line-numbers-wrapper"},[a("span",{staticClass:"line-number"},[s._v("1")]),a("br"),a("span",{staticClass:"line-number"},[s._v("2")]),a("br"),a("span",{staticClass:"line-number"},[s._v("3")]),a("br"),a("span",{staticClass:"line-number"},[s._v("4")]),a("br")])]),a("p",[s._v("方法"),a("code",[s._v("sync")]),s._v("返回一个同步"),a("code",[s._v("HttpTask")]),s._v("，可链式使用。")]),s._v(" "),a("h3",{attrs:{id:"异步请求"}},[a("a",{staticClass:"header-anchor",attrs:{href:"#异步请求"}},[s._v("#")]),s._v(" 异步请求")]),s._v(" "),a("p",[s._v("使用方法"),a("code",[s._v("async(String url)")]),s._v("开始一个异步请求：")]),s._v(" "),a("div",{staticClass:"language-java line-numbers-mode"},[a("pre",{pre:!0,attrs:{class:"language-java"}},[a("code",[s._v("http"),a("span",{pre:!0,attrs:{class:"token punctuation"}},[s._v(".")]),a("span",{pre:!0,attrs:{class:"token function"}},[s._v("async")]),a("span",{pre:!0,attrs:{class:"token punctuation"}},[s._v("(")]),a("span",{pre:!0,attrs:{class:"token string"}},[s._v('"/users/1"')]),a("span",{pre:!0,attrs:{class:"token punctuation"}},[s._v(")")]),s._v(" "),a("span",{pre:!0,attrs:{class:"token comment"}},[s._v("// http://api.demo.com/users/1")]),s._v("\n "),a("span",{pre:!0,attrs:{class:"token punctuation"}},[s._v(".")]),a("span",{pre:!0,attrs:{class:"token function"}},[s._v("setOnResponse")]),a("span",{pre:!0,attrs:{class:"token punctuation"}},[s._v("(")]),a("span",{pre:!0,attrs:{class:"token punctuation"}},[s._v("(")]),a("span",{pre:!0,attrs:{class:"token class-name"}},[s._v("HttpResult")]),s._v(" result"),a("span",{pre:!0,attrs:{class:"token punctuation"}},[s._v(")")]),s._v(" "),a("span",{pre:!0,attrs:{class:"token operator"}},[s._v("->")]),s._v(" "),a("span",{pre:!0,attrs:{class:"token punctuation"}},[s._v("{")]),s._v("\n "),a("span",{pre:!0,attrs:{class:"token comment"}},[s._v("// 得到目标数据")]),s._v("\n "),a("span",{pre:!0,attrs:{class:"token class-name"}},[s._v("User")]),s._v(" user "),a("span",{pre:!0,attrs:{class:"token operator"}},[s._v("=")]),s._v(" result"),a("span",{pre:!0,attrs:{class:"token punctuation"}},[s._v(".")]),a("span",{pre:!0,attrs:{class:"token function"}},[s._v("getBody")]),a("span",{pre:!0,attrs:{class:"token punctuation"}},[s._v("(")]),a("span",{pre:!0,attrs:{class:"token punctuation"}},[s._v(")")]),a("span",{pre:!0,attrs:{class:"token punctuation"}},[s._v(".")]),a("span",{pre:!0,attrs:{class:"token function"}},[s._v("toBean")]),a("span",{pre:!0,attrs:{class:"token punctuation"}},[s._v("(")]),a("span",{pre:!0,attrs:{class:"token class-name"}},[s._v("User")]),a("span",{pre:!0,attrs:{class:"token punctuation"}},[s._v(".")]),a("span",{pre:!0,attrs:{class:"token keyword"}},[s._v("class")]),a("span",{pre:!0,attrs:{class:"token punctuation"}},[s._v(")")]),a("span",{pre:!0,attrs:{class:"token punctuation"}},[s._v(";")]),s._v("\n "),a("span",{pre:!0,attrs:{class:"token punctuation"}},[s._v("}")]),a("span",{pre:!0,attrs:{class:"token punctuation"}},[s._v(")")]),s._v("\n "),a("span",{pre:!0,attrs:{class:"token punctuation"}},[s._v(".")]),a("span",{pre:!0,attrs:{class:"token function"}},[s._v("get")]),a("span",{pre:!0,attrs:{class:"token punctuation"}},[s._v("(")]),a("span",{pre:!0,attrs:{class:"token punctuation"}},[s._v(")")]),a("span",{pre:!0,attrs:{class:"token punctuation"}},[s._v(";")]),s._v(" "),a("span",{pre:!0,attrs:{class:"token comment"}},[s._v("// GET请求")]),s._v("\n")])]),s._v(" "),a("div",{staticClass:"line-numbers-wrapper"},[a("span",{staticClass:"line-number"},[s._v("1")]),a("br"),a("span",{staticClass:"line-number"},[s._v("2")]),a("br"),a("span",{staticClass:"line-number"},[s._v("3")]),a("br"),a("span",{staticClass:"line-number"},[s._v("4")]),a("br"),a("span",{staticClass:"line-number"},[s._v("5")]),a("br"),a("span",{staticClass:"line-number"},[s._v("6")]),a("br")])]),a("p",[s._v("方法"),a("code",[s._v("async")]),s._v("返回一个异步"),a("code",[s._v("HttpTask")]),s._v("，可链式使用。")]),s._v(" "),a("p",[a("strong",[s._v("至此，你已轻松学会了 OkHttps 95% 的常规用法！但别急，后面还有更精彩的。")])])])}),[],!1,null,null,null);t.default=e.exports}}]); \ No newline at end of file diff --git a/okhttps-doc/docs/.vuepress/dist/assets/js/8.d296d289.js b/okhttps-doc/docs/.vuepress/dist/assets/js/8.d296d289.js new file mode 100644 index 00000000..791bf3d0 --- /dev/null +++ b/okhttps-doc/docs/.vuepress/dist/assets/js/8.d296d289.js @@ -0,0 +1 @@ +(window.webpackJsonp=window.webpackJsonp||[]).push([[8],{336:function(s,t,a){"use strict";a.r(t);var n=a(19),e=Object(n.a)({},(function(){var s=this,t=s.$createElement,a=s._self._c||t;return a("ContentSlotsDistributor",{attrs:{"slot-key":s.$parent.slotKey}},[a("h1",{attrs:{id:"安卓"}},[a("a",{staticClass:"header-anchor",attrs:{href:"#安卓"}},[s._v("#")]),s._v(" 安卓")]),s._v(" "),a("h2",{attrs:{id:"回调线程切换"}},[a("a",{staticClass:"header-anchor",attrs:{href:"#回调线程切换"}},[s._v("#")]),s._v(" 回调线程切换")]),s._v(" "),a("p",[s._v("在 Android 开发中，经常会把某些代码放到特点的线程去执行，比如网络请求响应后的页面更新在主线程（UI线程）执行，而保存文件则在IO线程操作。OkHttps 为这类问题提供了良好的方案。")]),s._v(" "),a("p",[s._v("在 "),a("strong",[s._v("默认")]),s._v(" 情况下，"),a("strong",[s._v("所有回调")]),s._v(" 函数都会 "),a("strong",[s._v("在 IO 线程")]),s._v(" 执行。为什么会设计如此呢？这是因为 OkHttps 只是纯粹的 Java 领域 Http工具包，本身对 Android 不会有任何依赖，因此也不知 Android 的 UI 线程为何物。这么设计也让它在 Android 之外有更多的可能性。")]),s._v(" "),a("h3",{attrs:{id:"配置"}},[a("a",{staticClass:"header-anchor",attrs:{href:"#配置"}},[s._v("#")]),s._v(" 配置")]),s._v(" "),a("p",[s._v("但是在 Android 里使用 OkHttps 的话，UI线程的问题能否优雅的解决呢？当然可以！简单粗暴的方法就是配置一个 回调执行器：")]),s._v(" "),a("div",{staticClass:"language-java line-numbers-mode"},[a("pre",{pre:!0,attrs:{class:"language-java"}},[a("code",[a("span",{pre:!0,attrs:{class:"token class-name"}},[s._v("HTTP")]),s._v(" http "),a("span",{pre:!0,attrs:{class:"token operator"}},[s._v("=")]),s._v(" HTTP"),a("span",{pre:!0,attrs:{class:"token punctuation"}},[s._v(".")]),a("span",{pre:!0,attrs:{class:"token function"}},[s._v("builder")]),a("span",{pre:!0,attrs:{class:"token punctuation"}},[s._v("(")]),a("span",{pre:!0,attrs:{class:"token punctuation"}},[s._v(")")]),s._v("\n "),a("span",{pre:!0,attrs:{class:"token punctuation"}},[s._v(".")]),a("span",{pre:!0,attrs:{class:"token function"}},[s._v("callbackExecutor")]),a("span",{pre:!0,attrs:{class:"token punctuation"}},[s._v("(")]),a("span",{pre:!0,attrs:{class:"token punctuation"}},[s._v("(")]),a("span",{pre:!0,attrs:{class:"token class-name"}},[s._v("Runnable")]),s._v(" run"),a("span",{pre:!0,attrs:{class:"token punctuation"}},[s._v(")")]),s._v(" "),a("span",{pre:!0,attrs:{class:"token operator"}},[s._v("->")]),s._v(" "),a("span",{pre:!0,attrs:{class:"token punctuation"}},[s._v("{")]),s._v("\n "),a("span",{pre:!0,attrs:{class:"token comment"}},[s._v("// 实际编码中可以吧 Handler 提出来，不需要每次执行回调都重新创建")]),s._v("\n "),a("span",{pre:!0,attrs:{class:"token keyword"}},[s._v("new")]),s._v(" "),a("span",{pre:!0,attrs:{class:"token class-name"}},[s._v("Handler")]),a("span",{pre:!0,attrs:{class:"token punctuation"}},[s._v("(")]),a("span",{pre:!0,attrs:{class:"token class-name"}},[s._v("Looper")]),a("span",{pre:!0,attrs:{class:"token punctuation"}},[s._v(".")]),a("span",{pre:!0,attrs:{class:"token function"}},[s._v("getMainLooper")]),a("span",{pre:!0,attrs:{class:"token punctuation"}},[s._v("(")]),a("span",{pre:!0,attrs:{class:"token punctuation"}},[s._v(")")]),a("span",{pre:!0,attrs:{class:"token punctuation"}},[s._v(")")]),a("span",{pre:!0,attrs:{class:"token punctuation"}},[s._v(".")]),a("span",{pre:!0,attrs:{class:"token function"}},[s._v("post")]),a("span",{pre:!0,attrs:{class:"token punctuation"}},[s._v("(")]),s._v("run"),a("span",{pre:!0,attrs:{class:"token punctuation"}},[s._v(")")]),a("span",{pre:!0,attrs:{class:"token punctuation"}},[s._v(";")]),s._v(" "),a("span",{pre:!0,attrs:{class:"token comment"}},[s._v("// 在主线程执行")]),s._v("\n "),a("span",{pre:!0,attrs:{class:"token punctuation"}},[s._v("}")]),a("span",{pre:!0,attrs:{class:"token punctuation"}},[s._v(")")]),s._v("\n "),a("span",{pre:!0,attrs:{class:"token punctuation"}},[s._v(".")]),a("span",{pre:!0,attrs:{class:"token function"}},[s._v("build")]),a("span",{pre:!0,attrs:{class:"token punctuation"}},[s._v("(")]),a("span",{pre:!0,attrs:{class:"token punctuation"}},[s._v(")")]),a("span",{pre:!0,attrs:{class:"token punctuation"}},[s._v(";")]),s._v("\n")])]),s._v(" "),a("div",{staticClass:"line-numbers-wrapper"},[a("span",{staticClass:"line-number"},[s._v("1")]),a("br"),a("span",{staticClass:"line-number"},[s._v("2")]),a("br"),a("span",{staticClass:"line-number"},[s._v("3")]),a("br"),a("span",{staticClass:"line-number"},[s._v("4")]),a("br"),a("span",{staticClass:"line-number"},[s._v("5")]),a("br"),a("span",{staticClass:"line-number"},[s._v("6")]),a("br")])]),a("h3",{attrs:{id:"用例"}},[a("a",{staticClass:"header-anchor",attrs:{href:"#用例"}},[s._v("#")]),s._v(" 用例")]),s._v(" "),a("p",[s._v("上述代码便实现了让 "),a("strong",[s._v("所有")]),s._v(" 的 "),a("strong",[s._v("回调函数")]),s._v(" 都在 "),a("strong",[s._v("主线程（UI线程）")]),s._v(" 执行的目的，如：")]),s._v(" "),a("div",{staticClass:"language-java line-numbers-mode"},[a("pre",{pre:!0,attrs:{class:"language-java"}},[a("code",[s._v("http"),a("span",{pre:!0,attrs:{class:"token punctuation"}},[s._v(".")]),a("span",{pre:!0,attrs:{class:"token function"}},[s._v("async")]),a("span",{pre:!0,attrs:{class:"token punctuation"}},[s._v("(")]),a("span",{pre:!0,attrs:{class:"token string"}},[s._v('"/users"')]),a("span",{pre:!0,attrs:{class:"token punctuation"}},[s._v(")")]),s._v("\n "),a("span",{pre:!0,attrs:{class:"token punctuation"}},[s._v(".")]),a("span",{pre:!0,attrs:{class:"token function"}},[s._v("addBodyParam")]),a("span",{pre:!0,attrs:{class:"token punctuation"}},[s._v("(")]),a("span",{pre:!0,attrs:{class:"token string"}},[s._v('"name"')]),a("span",{pre:!0,attrs:{class:"token punctuation"}},[s._v(",")]),s._v(" "),a("span",{pre:!0,attrs:{class:"token string"}},[s._v('"Jack"')]),a("span",{pre:!0,attrs:{class:"token punctuation"}},[s._v(")")]),s._v("\n "),a("span",{pre:!0,attrs:{class:"token punctuation"}},[s._v(".")]),a("span",{pre:!0,attrs:{class:"token function"}},[s._v("setOnProcess")]),a("span",{pre:!0,attrs:{class:"token punctuation"}},[s._v("(")]),a("span",{pre:!0,attrs:{class:"token punctuation"}},[s._v("(")]),a("span",{pre:!0,attrs:{class:"token class-name"}},[s._v("Process")]),s._v(" process"),a("span",{pre:!0,attrs:{class:"token punctuation"}},[s._v(")")]),s._v(" "),a("span",{pre:!0,attrs:{class:"token operator"}},[s._v("->")]),s._v(" "),a("span",{pre:!0,attrs:{class:"token punctuation"}},[s._v("{")]),s._v("\n "),a("span",{pre:!0,attrs:{class:"token comment"}},[s._v("// 在主线程执行")]),s._v("\n "),a("span",{pre:!0,attrs:{class:"token punctuation"}},[s._v("}")]),a("span",{pre:!0,attrs:{class:"token punctuation"}},[s._v(")")]),s._v("\n "),a("span",{pre:!0,attrs:{class:"token punctuation"}},[s._v(".")]),a("span",{pre:!0,attrs:{class:"token function"}},[s._v("setOnResponse")]),a("span",{pre:!0,attrs:{class:"token punctuation"}},[s._v("(")]),a("span",{pre:!0,attrs:{class:"token punctuation"}},[s._v("(")]),a("span",{pre:!0,attrs:{class:"token class-name"}},[s._v("HttpResult")]),s._v(" result"),a("span",{pre:!0,attrs:{class:"token punctuation"}},[s._v(")")]),s._v(" "),a("span",{pre:!0,attrs:{class:"token operator"}},[s._v("->")]),s._v(" "),a("span",{pre:!0,attrs:{class:"token punctuation"}},[s._v("{")]),s._v("\n "),a("span",{pre:!0,attrs:{class:"token comment"}},[s._v("// 在主线程执行")]),s._v("\n "),a("span",{pre:!0,attrs:{class:"token punctuation"}},[s._v("}")]),a("span",{pre:!0,attrs:{class:"token punctuation"}},[s._v(")")]),s._v("\n "),a("span",{pre:!0,attrs:{class:"token punctuation"}},[s._v(".")]),a("span",{pre:!0,attrs:{class:"token function"}},[s._v("setOnException")]),a("span",{pre:!0,attrs:{class:"token punctuation"}},[s._v("(")]),a("span",{pre:!0,attrs:{class:"token punctuation"}},[s._v("(")]),a("span",{pre:!0,attrs:{class:"token class-name"}},[s._v("Exception")]),s._v(" e"),a("span",{pre:!0,attrs:{class:"token punctuation"}},[s._v(")")]),s._v(" "),a("span",{pre:!0,attrs:{class:"token operator"}},[s._v("->")]),s._v(" "),a("span",{pre:!0,attrs:{class:"token punctuation"}},[s._v("{")]),s._v("\n "),a("span",{pre:!0,attrs:{class:"token comment"}},[s._v("// 在主线程执行")]),s._v("\n "),a("span",{pre:!0,attrs:{class:"token punctuation"}},[s._v("}")]),a("span",{pre:!0,attrs:{class:"token punctuation"}},[s._v(")")]),s._v("\n "),a("span",{pre:!0,attrs:{class:"token punctuation"}},[s._v(".")]),a("span",{pre:!0,attrs:{class:"token function"}},[s._v("setOnComplete")]),a("span",{pre:!0,attrs:{class:"token punctuation"}},[s._v("(")]),a("span",{pre:!0,attrs:{class:"token punctuation"}},[s._v("(")]),a("span",{pre:!0,attrs:{class:"token class-name"}},[s._v("State")]),s._v(" state"),a("span",{pre:!0,attrs:{class:"token punctuation"}},[s._v(")")]),s._v(" "),a("span",{pre:!0,attrs:{class:"token operator"}},[s._v("->")]),s._v(" "),a("span",{pre:!0,attrs:{class:"token punctuation"}},[s._v("{")]),s._v("\n "),a("span",{pre:!0,attrs:{class:"token comment"}},[s._v("// 在主线程执行")]),s._v("\n "),a("span",{pre:!0,attrs:{class:"token punctuation"}},[s._v("}")]),a("span",{pre:!0,attrs:{class:"token punctuation"}},[s._v(")")]),s._v("\n "),a("span",{pre:!0,attrs:{class:"token punctuation"}},[s._v(".")]),a("span",{pre:!0,attrs:{class:"token function"}},[s._v("post")]),a("span",{pre:!0,attrs:{class:"token punctuation"}},[s._v("(")]),a("span",{pre:!0,attrs:{class:"token punctuation"}},[s._v(")")]),a("span",{pre:!0,attrs:{class:"token punctuation"}},[s._v(";")]),s._v("\n")])]),s._v(" "),a("div",{staticClass:"line-numbers-wrapper"},[a("span",{staticClass:"line-number"},[s._v("1")]),a("br"),a("span",{staticClass:"line-number"},[s._v("2")]),a("br"),a("span",{staticClass:"line-number"},[s._v("3")]),a("br"),a("span",{staticClass:"line-number"},[s._v("4")]),a("br"),a("span",{staticClass:"line-number"},[s._v("5")]),a("br"),a("span",{staticClass:"line-number"},[s._v("6")]),a("br"),a("span",{staticClass:"line-number"},[s._v("7")]),a("br"),a("span",{staticClass:"line-number"},[s._v("8")]),a("br"),a("span",{staticClass:"line-number"},[s._v("9")]),a("br"),a("span",{staticClass:"line-number"},[s._v("10")]),a("br"),a("span",{staticClass:"line-number"},[s._v("11")]),a("br"),a("span",{staticClass:"line-number"},[s._v("12")]),a("br"),a("span",{staticClass:"line-number"},[s._v("13")]),a("br"),a("span",{staticClass:"line-number"},[s._v("14")]),a("br"),a("span",{staticClass:"line-number"},[s._v("15")]),a("br")])]),a("p",[s._v("但是，如果同时还想让某些回调放在IO线程，实现 "),a("strong",[s._v("自由切换")]),s._v("，怎么办呢？OkHttps 给出了非常灵活的方法，如下：")]),s._v(" "),a("div",{staticClass:"language-java line-numbers-mode"},[a("pre",{pre:!0,attrs:{class:"language-java"}},[a("code",[s._v("http"),a("span",{pre:!0,attrs:{class:"token punctuation"}},[s._v(".")]),a("span",{pre:!0,attrs:{class:"token function"}},[s._v("async")]),a("span",{pre:!0,attrs:{class:"token punctuation"}},[s._v("(")]),a("span",{pre:!0,attrs:{class:"token string"}},[s._v('"/users"')]),a("span",{pre:!0,attrs:{class:"token punctuation"}},[s._v(")")]),s._v("\n "),a("span",{pre:!0,attrs:{class:"token punctuation"}},[s._v(".")]),a("span",{pre:!0,attrs:{class:"token function"}},[s._v("addBodyParam")]),a("span",{pre:!0,attrs:{class:"token punctuation"}},[s._v("(")]),a("span",{pre:!0,attrs:{class:"token string"}},[s._v('"name"')]),a("span",{pre:!0,attrs:{class:"token punctuation"}},[s._v(",")]),s._v(" "),a("span",{pre:!0,attrs:{class:"token string"}},[s._v('"Jack"')]),a("span",{pre:!0,attrs:{class:"token punctuation"}},[s._v(")")]),s._v("\n "),a("span",{pre:!0,attrs:{class:"token punctuation"}},[s._v(".")]),a("span",{pre:!0,attrs:{class:"token function"}},[s._v("setOnProcess")]),a("span",{pre:!0,attrs:{class:"token punctuation"}},[s._v("(")]),a("span",{pre:!0,attrs:{class:"token punctuation"}},[s._v("(")]),a("span",{pre:!0,attrs:{class:"token class-name"}},[s._v("Process")]),s._v(" process"),a("span",{pre:!0,attrs:{class:"token punctuation"}},[s._v(")")]),s._v(" "),a("span",{pre:!0,attrs:{class:"token operator"}},[s._v("->")]),s._v(" "),a("span",{pre:!0,attrs:{class:"token punctuation"}},[s._v("{")]),s._v("\n "),a("span",{pre:!0,attrs:{class:"token comment"}},[s._v("// 在主线程执行")]),s._v("\n "),a("span",{pre:!0,attrs:{class:"token punctuation"}},[s._v("}")]),a("span",{pre:!0,attrs:{class:"token punctuation"}},[s._v(")")]),s._v("\n "),a("span",{pre:!0,attrs:{class:"token punctuation"}},[s._v(".")]),a("span",{pre:!0,attrs:{class:"token function"}},[s._v("nextOnIO")]),a("span",{pre:!0,attrs:{class:"token punctuation"}},[s._v("(")]),a("span",{pre:!0,attrs:{class:"token punctuation"}},[s._v(")")]),s._v(" "),a("span",{pre:!0,attrs:{class:"token comment"}},[s._v("// 指定下一个回调在 IO 线程执行")]),s._v("\n "),a("span",{pre:!0,attrs:{class:"token punctuation"}},[s._v(".")]),a("span",{pre:!0,attrs:{class:"token function"}},[s._v("setOnResponse")]),a("span",{pre:!0,attrs:{class:"token punctuation"}},[s._v("(")]),a("span",{pre:!0,attrs:{class:"token punctuation"}},[s._v("(")]),a("span",{pre:!0,attrs:{class:"token class-name"}},[s._v("HttpResult")]),s._v(" result"),a("span",{pre:!0,attrs:{class:"token punctuation"}},[s._v(")")]),s._v(" "),a("span",{pre:!0,attrs:{class:"token operator"}},[s._v("->")]),s._v(" "),a("span",{pre:!0,attrs:{class:"token punctuation"}},[s._v("{")]),s._v("\n "),a("span",{pre:!0,attrs:{class:"token comment"}},[s._v("// 在 IO 线程执行")]),s._v("\n "),a("span",{pre:!0,attrs:{class:"token punctuation"}},[s._v("}")]),a("span",{pre:!0,attrs:{class:"token punctuation"}},[s._v(")")]),s._v("\n "),a("span",{pre:!0,attrs:{class:"token punctuation"}},[s._v(".")]),a("span",{pre:!0,attrs:{class:"token function"}},[s._v("setOnException")]),a("span",{pre:!0,attrs:{class:"token punctuation"}},[s._v("(")]),a("span",{pre:!0,attrs:{class:"token punctuation"}},[s._v("(")]),a("span",{pre:!0,attrs:{class:"token class-name"}},[s._v("Exception")]),s._v(" e"),a("span",{pre:!0,attrs:{class:"token punctuation"}},[s._v(")")]),s._v(" "),a("span",{pre:!0,attrs:{class:"token operator"}},[s._v("->")]),s._v(" "),a("span",{pre:!0,attrs:{class:"token punctuation"}},[s._v("{")]),s._v("\n "),a("span",{pre:!0,attrs:{class:"token comment"}},[s._v("// 在主线程执行（没有指明 nextOnIO 则在回调执行器里执行）")]),s._v("\n "),a("span",{pre:!0,attrs:{class:"token punctuation"}},[s._v("}")]),a("span",{pre:!0,attrs:{class:"token punctuation"}},[s._v(")")]),s._v("\n "),a("span",{pre:!0,attrs:{class:"token punctuation"}},[s._v(".")]),a("span",{pre:!0,attrs:{class:"token function"}},[s._v("nextOnIO")]),a("span",{pre:!0,attrs:{class:"token punctuation"}},[s._v("(")]),a("span",{pre:!0,attrs:{class:"token punctuation"}},[s._v(")")]),s._v(" "),a("span",{pre:!0,attrs:{class:"token comment"}},[s._v("// 指定下一个回调在 IO 线程执行")]),s._v("\n "),a("span",{pre:!0,attrs:{class:"token punctuation"}},[s._v(".")]),a("span",{pre:!0,attrs:{class:"token function"}},[s._v("setOnComplete")]),a("span",{pre:!0,attrs:{class:"token punctuation"}},[s._v("(")]),a("span",{pre:!0,attrs:{class:"token punctuation"}},[s._v("(")]),a("span",{pre:!0,attrs:{class:"token class-name"}},[s._v("State")]),s._v(" state"),a("span",{pre:!0,attrs:{class:"token punctuation"}},[s._v(")")]),s._v(" "),a("span",{pre:!0,attrs:{class:"token operator"}},[s._v("->")]),s._v(" "),a("span",{pre:!0,attrs:{class:"token punctuation"}},[s._v("{")]),s._v("\n "),a("span",{pre:!0,attrs:{class:"token comment"}},[s._v("// 在 IO 线程执行")]),s._v("\n "),a("span",{pre:!0,attrs:{class:"token punctuation"}},[s._v("}")]),a("span",{pre:!0,attrs:{class:"token punctuation"}},[s._v(")")]),s._v("\n "),a("span",{pre:!0,attrs:{class:"token punctuation"}},[s._v(".")]),a("span",{pre:!0,attrs:{class:"token function"}},[s._v("post")]),a("span",{pre:!0,attrs:{class:"token punctuation"}},[s._v("(")]),a("span",{pre:!0,attrs:{class:"token punctuation"}},[s._v(")")]),a("span",{pre:!0,attrs:{class:"token punctuation"}},[s._v(";")]),s._v("\n")])]),s._v(" "),a("div",{staticClass:"line-numbers-wrapper"},[a("span",{staticClass:"line-number"},[s._v("1")]),a("br"),a("span",{staticClass:"line-number"},[s._v("2")]),a("br"),a("span",{staticClass:"line-number"},[s._v("3")]),a("br"),a("span",{staticClass:"line-number"},[s._v("4")]),a("br"),a("span",{staticClass:"line-number"},[s._v("5")]),a("br"),a("span",{staticClass:"line-number"},[s._v("6")]),a("br"),a("span",{staticClass:"line-number"},[s._v("7")]),a("br"),a("span",{staticClass:"line-number"},[s._v("8")]),a("br"),a("span",{staticClass:"line-number"},[s._v("9")]),a("br"),a("span",{staticClass:"line-number"},[s._v("10")]),a("br"),a("span",{staticClass:"line-number"},[s._v("11")]),a("br"),a("span",{staticClass:"line-number"},[s._v("12")]),a("br"),a("span",{staticClass:"line-number"},[s._v("13")]),a("br"),a("span",{staticClass:"line-number"},[s._v("14")]),a("br"),a("span",{staticClass:"line-number"},[s._v("15")]),a("br"),a("span",{staticClass:"line-number"},[s._v("16")]),a("br"),a("span",{staticClass:"line-number"},[s._v("17")]),a("br")])]),a("p",[s._v("无论是哪一个回调，都可以使用"),a("code",[s._v("nextOnIO()")]),s._v("方法自由切换。同样，对于文件下载也是一样：")]),s._v(" "),a("div",{staticClass:"language-java line-numbers-mode"},[a("pre",{pre:!0,attrs:{class:"language-java"}},[a("code",[s._v("http"),a("span",{pre:!0,attrs:{class:"token punctuation"}},[s._v(".")]),a("span",{pre:!0,attrs:{class:"token function"}},[s._v("sync")]),a("span",{pre:!0,attrs:{class:"token punctuation"}},[s._v("(")]),a("span",{pre:!0,attrs:{class:"token string"}},[s._v('"/download/test.zip"')]),a("span",{pre:!0,attrs:{class:"token punctuation"}},[s._v(")")]),s._v("\n "),a("span",{pre:!0,attrs:{class:"token punctuation"}},[s._v(".")]),a("span",{pre:!0,attrs:{class:"token function"}},[s._v("get")]),a("span",{pre:!0,attrs:{class:"token punctuation"}},[s._v("(")]),a("span",{pre:!0,attrs:{class:"token punctuation"}},[s._v(")")]),s._v("\n "),a("span",{pre:!0,attrs:{class:"token punctuation"}},[s._v(".")]),a("span",{pre:!0,attrs:{class:"token function"}},[s._v("getBody")]),a("span",{pre:!0,attrs:{class:"token punctuation"}},[s._v("(")]),a("span",{pre:!0,attrs:{class:"token punctuation"}},[s._v(")")]),s._v("\n "),a("span",{pre:!0,attrs:{class:"token punctuation"}},[s._v(".")]),a("span",{pre:!0,attrs:{class:"token function"}},[s._v("setOnProcess")]),a("span",{pre:!0,attrs:{class:"token punctuation"}},[s._v("(")]),a("span",{pre:!0,attrs:{class:"token punctuation"}},[s._v("(")]),a("span",{pre:!0,attrs:{class:"token class-name"}},[s._v("Process")]),s._v(" process"),a("span",{pre:!0,attrs:{class:"token punctuation"}},[s._v(")")]),s._v(" "),a("span",{pre:!0,attrs:{class:"token operator"}},[s._v("->")]),s._v(" "),a("span",{pre:!0,attrs:{class:"token punctuation"}},[s._v("{")]),s._v("\n "),a("span",{pre:!0,attrs:{class:"token comment"}},[s._v("// 在主线程执行")]),s._v("\n "),a("span",{pre:!0,attrs:{class:"token punctuation"}},[s._v("}")]),a("span",{pre:!0,attrs:{class:"token punctuation"}},[s._v(")")]),s._v("\n "),a("span",{pre:!0,attrs:{class:"token punctuation"}},[s._v(".")]),a("span",{pre:!0,attrs:{class:"token function"}},[s._v("toFolder")]),a("span",{pre:!0,attrs:{class:"token punctuation"}},[s._v("(")]),a("span",{pre:!0,attrs:{class:"token string"}},[s._v('"D:/download/"')]),a("span",{pre:!0,attrs:{class:"token punctuation"}},[s._v(")")]),s._v("\n "),a("span",{pre:!0,attrs:{class:"token punctuation"}},[s._v(".")]),a("span",{pre:!0,attrs:{class:"token function"}},[s._v("nextOnIO")]),a("span",{pre:!0,attrs:{class:"token punctuation"}},[s._v("(")]),a("span",{pre:!0,attrs:{class:"token punctuation"}},[s._v(")")]),s._v(" "),a("span",{pre:!0,attrs:{class:"token comment"}},[s._v("// 指定下一个回调在 IO 线程执行")]),s._v("\n "),a("span",{pre:!0,attrs:{class:"token punctuation"}},[s._v(".")]),a("span",{pre:!0,attrs:{class:"token function"}},[s._v("setOnSuccess")]),a("span",{pre:!0,attrs:{class:"token punctuation"}},[s._v("(")]),a("span",{pre:!0,attrs:{class:"token punctuation"}},[s._v("(")]),a("span",{pre:!0,attrs:{class:"token class-name"}},[s._v("File")]),s._v(" file"),a("span",{pre:!0,attrs:{class:"token punctuation"}},[s._v(")")]),s._v(" "),a("span",{pre:!0,attrs:{class:"token operator"}},[s._v("->")]),s._v(" "),a("span",{pre:!0,attrs:{class:"token punctuation"}},[s._v("{")]),s._v("\n "),a("span",{pre:!0,attrs:{class:"token comment"}},[s._v("// 在 IO 线程执行")]),s._v("\n "),a("span",{pre:!0,attrs:{class:"token punctuation"}},[s._v("}")]),a("span",{pre:!0,attrs:{class:"token punctuation"}},[s._v(")")]),s._v("\n "),a("span",{pre:!0,attrs:{class:"token punctuation"}},[s._v(".")]),a("span",{pre:!0,attrs:{class:"token function"}},[s._v("setOnFailure")]),a("span",{pre:!0,attrs:{class:"token punctuation"}},[s._v("(")]),a("span",{pre:!0,attrs:{class:"token punctuation"}},[s._v("(")]),a("span",{pre:!0,attrs:{class:"token class-name"}},[s._v("Failure")]),s._v(" failure"),a("span",{pre:!0,attrs:{class:"token punctuation"}},[s._v(")")]),s._v(" "),a("span",{pre:!0,attrs:{class:"token operator"}},[s._v("->")]),s._v(" "),a("span",{pre:!0,attrs:{class:"token punctuation"}},[s._v("{")]),s._v("\n "),a("span",{pre:!0,attrs:{class:"token comment"}},[s._v("// 在主线程执行")]),s._v("\n "),a("span",{pre:!0,attrs:{class:"token punctuation"}},[s._v("}")]),a("span",{pre:!0,attrs:{class:"token punctuation"}},[s._v(")")]),s._v("\n "),a("span",{pre:!0,attrs:{class:"token punctuation"}},[s._v(".")]),a("span",{pre:!0,attrs:{class:"token function"}},[s._v("start")]),a("span",{pre:!0,attrs:{class:"token punctuation"}},[s._v("(")]),a("span",{pre:!0,attrs:{class:"token punctuation"}},[s._v(")")]),a("span",{pre:!0,attrs:{class:"token punctuation"}},[s._v(";")]),s._v("\n")])]),s._v(" "),a("div",{staticClass:"line-numbers-wrapper"},[a("span",{staticClass:"line-number"},[s._v("1")]),a("br"),a("span",{staticClass:"line-number"},[s._v("2")]),a("br"),a("span",{staticClass:"line-number"},[s._v("3")]),a("br"),a("span",{staticClass:"line-number"},[s._v("4")]),a("br"),a("span",{staticClass:"line-number"},[s._v("5")]),a("br"),a("span",{staticClass:"line-number"},[s._v("6")]),a("br"),a("span",{staticClass:"line-number"},[s._v("7")]),a("br"),a("span",{staticClass:"line-number"},[s._v("8")]),a("br"),a("span",{staticClass:"line-number"},[s._v("9")]),a("br"),a("span",{staticClass:"line-number"},[s._v("10")]),a("br"),a("span",{staticClass:"line-number"},[s._v("11")]),a("br"),a("span",{staticClass:"line-number"},[s._v("12")]),a("br"),a("span",{staticClass:"line-number"},[s._v("13")]),a("br"),a("span",{staticClass:"line-number"},[s._v("14")]),a("br"),a("span",{staticClass:"line-number"},[s._v("15")]),a("br")])]),a("h2",{attrs:{id:"生命周期绑定"}},[a("a",{staticClass:"header-anchor",attrs:{href:"#生命周期绑定"}},[s._v("#")]),s._v(" 生命周期绑定")]),s._v(" "),a("p",[s._v("由于 OkHttps 并不依赖于 Android，所以它并没有提供关于生命周期绑定的直接实现，但它的一些扩展机制让我们很容易就可以实现这个需求。在开始之前，我们首先要理解何为生命周期绑定：")]),s._v(" "),a("div",{staticClass:"custom-block tip"},[a("p",{staticClass:"custom-block-title"},[s._v("HTTP 请求的生命周期绑定")]),s._v(" "),a("p",[s._v("所谓的生命周期绑定：即是让 HTTP 任务感知其所属的 Activity 或 Fragment 的生命周期，当 Activity 或 Fragment 将被销毁时，框架应自动的把由它们发起的但尚未完成的 HTTP 任务全部取消，以免导致程序出错！")])]),s._v(" "),a("p",[s._v("现在我们需要对"),a("code",[s._v("HTTP")]),s._v("实例进行配置，配置后的"),a("code",[s._v("HTTP")]),s._v("实例具有生命周期绑定的功能，在"),a("code",[s._v("Activity")]),s._v("或"),a("code",[s._v("Fragment")]),s._v("里，它的使用效果如下：")]),s._v(" "),a("div",{staticClass:"language-java line-numbers-mode"},[a("pre",{pre:!0,attrs:{class:"language-java"}},[a("code",[a("span",{pre:!0,attrs:{class:"token comment"}},[s._v("// 在 Activity 或 Fragment 内发起请求")]),s._v("\nhttp"),a("span",{pre:!0,attrs:{class:"token punctuation"}},[s._v(".")]),a("span",{pre:!0,attrs:{class:"token function"}},[s._v("async")]),a("span",{pre:!0,attrs:{class:"token punctuation"}},[s._v("(")]),a("span",{pre:!0,attrs:{class:"token string"}},[s._v('"http://www.baidu.com"')]),a("span",{pre:!0,attrs:{class:"token punctuation"}},[s._v(")")]),s._v("\n "),a("span",{pre:!0,attrs:{class:"token punctuation"}},[s._v(".")]),a("span",{pre:!0,attrs:{class:"token function"}},[s._v("bind")]),a("span",{pre:!0,attrs:{class:"token punctuation"}},[s._v("(")]),a("span",{pre:!0,attrs:{class:"token function"}},[s._v("getLifecycle")]),a("span",{pre:!0,attrs:{class:"token punctuation"}},[s._v("(")]),a("span",{pre:!0,attrs:{class:"token punctuation"}},[s._v(")")]),a("span",{pre:!0,attrs:{class:"token punctuation"}},[s._v(")")]),s._v(" "),a("span",{pre:!0,attrs:{class:"token comment"}},[s._v("// 绑定生命周期")]),s._v("\n "),a("span",{pre:!0,attrs:{class:"token punctuation"}},[s._v(".")]),a("span",{pre:!0,attrs:{class:"token function"}},[s._v("setOnResponse")]),a("span",{pre:!0,attrs:{class:"token punctuation"}},[s._v("(")]),a("span",{pre:!0,attrs:{class:"token punctuation"}},[s._v("(")]),a("span",{pre:!0,attrs:{class:"token class-name"}},[s._v("HttpResult")]),s._v(" result"),a("span",{pre:!0,attrs:{class:"token punctuation"}},[s._v(")")]),s._v(" "),a("span",{pre:!0,attrs:{class:"token operator"}},[s._v("->")]),s._v(" "),a("span",{pre:!0,attrs:{class:"token punctuation"}},[s._v("{")]),s._v("\n "),a("span",{pre:!0,attrs:{class:"token class-name"}},[s._v("Log")]),a("span",{pre:!0,attrs:{class:"token punctuation"}},[s._v(".")]),a("span",{pre:!0,attrs:{class:"token function"}},[s._v("i")]),a("span",{pre:!0,attrs:{class:"token punctuation"}},[s._v("(")]),a("span",{pre:!0,attrs:{class:"token string"}},[s._v('"FirstFragment"')]),a("span",{pre:!0,attrs:{class:"token punctuation"}},[s._v(",")]),s._v(" "),a("span",{pre:!0,attrs:{class:"token string"}},[s._v('"收到请求："')]),s._v(" "),a("span",{pre:!0,attrs:{class:"token operator"}},[s._v("+")]),s._v(" result"),a("span",{pre:!0,attrs:{class:"token punctuation"}},[s._v(".")]),a("span",{pre:!0,attrs:{class:"token function"}},[s._v("toString")]),a("span",{pre:!0,attrs:{class:"token punctuation"}},[s._v("(")]),a("span",{pre:!0,attrs:{class:"token punctuation"}},[s._v(")")]),a("span",{pre:!0,attrs:{class:"token punctuation"}},[s._v(")")]),a("span",{pre:!0,attrs:{class:"token punctuation"}},[s._v(";")]),s._v("\n "),a("span",{pre:!0,attrs:{class:"token punctuation"}},[s._v("}")]),a("span",{pre:!0,attrs:{class:"token punctuation"}},[s._v(")")]),s._v("\n "),a("span",{pre:!0,attrs:{class:"token punctuation"}},[s._v(".")]),a("span",{pre:!0,attrs:{class:"token function"}},[s._v("get")]),a("span",{pre:!0,attrs:{class:"token punctuation"}},[s._v("(")]),a("span",{pre:!0,attrs:{class:"token punctuation"}},[s._v(")")]),a("span",{pre:!0,attrs:{class:"token punctuation"}},[s._v(";")]),s._v("\n")])]),s._v(" "),a("div",{staticClass:"line-numbers-wrapper"},[a("span",{staticClass:"line-number"},[s._v("1")]),a("br"),a("span",{staticClass:"line-number"},[s._v("2")]),a("br"),a("span",{staticClass:"line-number"},[s._v("3")]),a("br"),a("span",{staticClass:"line-number"},[s._v("4")]),a("br"),a("span",{staticClass:"line-number"},[s._v("5")]),a("br"),a("span",{staticClass:"line-number"},[s._v("6")]),a("br"),a("span",{staticClass:"line-number"},[s._v("7")]),a("br")])]),a("p",[s._v("上述代码中的"),a("code",[s._v("getLifecycle()")]),s._v("是"),a("code",[s._v("Activity")]),s._v("或"),a("code",[s._v("Fragment")]),s._v("自带的方法，而"),a("code",[s._v("bind()")]),s._v("是"),a("code",[s._v("HttpTask")]),s._v("的现有方法。在配置好"),a("code",[s._v("HTTP")]),s._v("实例后，上述代码发起的请求便可以感知"),a("code",[s._v("Activity")]),s._v("或"),a("code",[s._v("Fragment")]),s._v("的生命周期。")]),s._v(" "),a("p",[s._v("那"),a("code",[s._v("HTTP")]),s._v("实例到底该如何配置呢？")]),s._v(" "),a("h3",{attrs:{id:"第一步：配置预处理器"}},[a("a",{staticClass:"header-anchor",attrs:{href:"#第一步：配置预处理器"}},[s._v("#")]),s._v(" 第一步：配置预处理器")]),s._v(" "),a("div",{staticClass:"language-java line-numbers-mode"},[a("pre",{pre:!0,attrs:{class:"language-java"}},[a("code",[a("span",{pre:!0,attrs:{class:"token class-name"}},[s._v("HTTP")]),s._v(" http "),a("span",{pre:!0,attrs:{class:"token operator"}},[s._v("=")]),s._v(" HTTP"),a("span",{pre:!0,attrs:{class:"token punctuation"}},[s._v(".")]),a("span",{pre:!0,attrs:{class:"token function"}},[s._v("builder")]),a("span",{pre:!0,attrs:{class:"token punctuation"}},[s._v("(")]),a("span",{pre:!0,attrs:{class:"token punctuation"}},[s._v(")")]),s._v("\n "),a("span",{pre:!0,attrs:{class:"token punctuation"}},[s._v(".")]),a("span",{pre:!0,attrs:{class:"token punctuation"}},[s._v(".")]),a("span",{pre:!0,attrs:{class:"token punctuation"}},[s._v(".")]),s._v(" "),a("span",{pre:!0,attrs:{class:"token comment"}},[s._v("// 省略其它配置项")]),s._v("\n "),a("span",{pre:!0,attrs:{class:"token punctuation"}},[s._v(".")]),a("span",{pre:!0,attrs:{class:"token function"}},[s._v("addPreprocessor")]),a("span",{pre:!0,attrs:{class:"token punctuation"}},[s._v("(")]),a("span",{pre:!0,attrs:{class:"token punctuation"}},[s._v("(")]),a("span",{pre:!0,attrs:{class:"token class-name"}},[s._v("Preprocessor")]),a("span",{pre:!0,attrs:{class:"token punctuation"}},[s._v(".")]),a("span",{pre:!0,attrs:{class:"token class-name"}},[s._v("PreChain")]),s._v(" chain"),a("span",{pre:!0,attrs:{class:"token punctuation"}},[s._v(")")]),s._v(" "),a("span",{pre:!0,attrs:{class:"token operator"}},[s._v("->")]),s._v(" "),a("span",{pre:!0,attrs:{class:"token punctuation"}},[s._v("{")]),s._v("\n "),a("span",{pre:!0,attrs:{class:"token class-name"}},[s._v("HttpTask")]),a("span",{pre:!0,attrs:{class:"token generics"}},[a("span",{pre:!0,attrs:{class:"token punctuation"}},[s._v("<")]),a("span",{pre:!0,attrs:{class:"token operator"}},[s._v("?")]),a("span",{pre:!0,attrs:{class:"token punctuation"}},[s._v(">")])]),s._v(" task "),a("span",{pre:!0,attrs:{class:"token operator"}},[s._v("=")]),s._v(" chain"),a("span",{pre:!0,attrs:{class:"token punctuation"}},[s._v(".")]),a("span",{pre:!0,attrs:{class:"token function"}},[s._v("getTask")]),a("span",{pre:!0,attrs:{class:"token punctuation"}},[s._v("(")]),a("span",{pre:!0,attrs:{class:"token punctuation"}},[s._v(")")]),a("span",{pre:!0,attrs:{class:"token punctuation"}},[s._v(";")]),s._v("\n "),a("span",{pre:!0,attrs:{class:"token class-name"}},[s._v("Object")]),s._v(" bound "),a("span",{pre:!0,attrs:{class:"token operator"}},[s._v("=")]),s._v(" task"),a("span",{pre:!0,attrs:{class:"token punctuation"}},[s._v(".")]),a("span",{pre:!0,attrs:{class:"token function"}},[s._v("getBound")]),a("span",{pre:!0,attrs:{class:"token punctuation"}},[s._v("(")]),a("span",{pre:!0,attrs:{class:"token punctuation"}},[s._v(")")]),a("span",{pre:!0,attrs:{class:"token punctuation"}},[s._v(";")]),s._v("\n "),a("span",{pre:!0,attrs:{class:"token comment"}},[s._v("// 判断 task 是否绑定了 Lifecycle 对象")]),s._v("\n "),a("span",{pre:!0,attrs:{class:"token keyword"}},[s._v("if")]),s._v(" "),a("span",{pre:!0,attrs:{class:"token punctuation"}},[s._v("(")]),s._v("bound "),a("span",{pre:!0,attrs:{class:"token keyword"}},[s._v("instanceof")]),s._v(" "),a("span",{pre:!0,attrs:{class:"token class-name"}},[s._v("Lifecycle")]),a("span",{pre:!0,attrs:{class:"token punctuation"}},[s._v(")")]),s._v(" "),a("span",{pre:!0,attrs:{class:"token punctuation"}},[s._v("{")]),s._v("\n "),a("span",{pre:!0,attrs:{class:"token comment"}},[s._v("// 重新绑定一个 生命周期监视器（LCObserver）对象，它的定义见下一步")]),s._v("\n task"),a("span",{pre:!0,attrs:{class:"token punctuation"}},[s._v(".")]),a("span",{pre:!0,attrs:{class:"token function"}},[s._v("bind")]),a("span",{pre:!0,attrs:{class:"token punctuation"}},[s._v("(")]),a("span",{pre:!0,attrs:{class:"token keyword"}},[s._v("new")]),s._v(" "),a("span",{pre:!0,attrs:{class:"token class-name"}},[s._v("LCObserver")]),a("span",{pre:!0,attrs:{class:"token punctuation"}},[s._v("(")]),s._v("task"),a("span",{pre:!0,attrs:{class:"token punctuation"}},[s._v(",")]),s._v(" "),a("span",{pre:!0,attrs:{class:"token punctuation"}},[s._v("(")]),a("span",{pre:!0,attrs:{class:"token class-name"}},[s._v("Lifecycle")]),a("span",{pre:!0,attrs:{class:"token punctuation"}},[s._v(")")]),s._v(" bound"),a("span",{pre:!0,attrs:{class:"token punctuation"}},[s._v(")")]),a("span",{pre:!0,attrs:{class:"token punctuation"}},[s._v(")")]),a("span",{pre:!0,attrs:{class:"token punctuation"}},[s._v(";")]),s._v("\n "),a("span",{pre:!0,attrs:{class:"token punctuation"}},[s._v("}")]),s._v("\n chain"),a("span",{pre:!0,attrs:{class:"token punctuation"}},[s._v(".")]),a("span",{pre:!0,attrs:{class:"token function"}},[s._v("proceed")]),a("span",{pre:!0,attrs:{class:"token punctuation"}},[s._v("(")]),a("span",{pre:!0,attrs:{class:"token punctuation"}},[s._v(")")]),a("span",{pre:!0,attrs:{class:"token punctuation"}},[s._v(";")]),s._v("\n "),a("span",{pre:!0,attrs:{class:"token punctuation"}},[s._v("}")]),a("span",{pre:!0,attrs:{class:"token punctuation"}},[s._v(")")]),s._v("\n "),a("span",{pre:!0,attrs:{class:"token punctuation"}},[s._v(".")]),a("span",{pre:!0,attrs:{class:"token punctuation"}},[s._v(".")]),a("span",{pre:!0,attrs:{class:"token punctuation"}},[s._v(".")]),s._v(" "),a("span",{pre:!0,attrs:{class:"token comment"}},[s._v("// 省略其它配置项")]),s._v("\n "),a("span",{pre:!0,attrs:{class:"token punctuation"}},[s._v(".")]),a("span",{pre:!0,attrs:{class:"token function"}},[s._v("build")]),a("span",{pre:!0,attrs:{class:"token punctuation"}},[s._v("(")]),a("span",{pre:!0,attrs:{class:"token punctuation"}},[s._v(")")]),a("span",{pre:!0,attrs:{class:"token punctuation"}},[s._v(";")]),s._v("\n")])]),s._v(" "),a("div",{staticClass:"line-numbers-wrapper"},[a("span",{staticClass:"line-number"},[s._v("1")]),a("br"),a("span",{staticClass:"line-number"},[s._v("2")]),a("br"),a("span",{staticClass:"line-number"},[s._v("3")]),a("br"),a("span",{staticClass:"line-number"},[s._v("4")]),a("br"),a("span",{staticClass:"line-number"},[s._v("5")]),a("br"),a("span",{staticClass:"line-number"},[s._v("6")]),a("br"),a("span",{staticClass:"line-number"},[s._v("7")]),a("br"),a("span",{staticClass:"line-number"},[s._v("8")]),a("br"),a("span",{staticClass:"line-number"},[s._v("9")]),a("br"),a("span",{staticClass:"line-number"},[s._v("10")]),a("br"),a("span",{staticClass:"line-number"},[s._v("11")]),a("br"),a("span",{staticClass:"line-number"},[s._v("12")]),a("br"),a("span",{staticClass:"line-number"},[s._v("13")]),a("br"),a("span",{staticClass:"line-number"},[s._v("14")]),a("br")])]),a("h3",{attrs:{id:"第二步：定义生命周期监视器"}},[a("a",{staticClass:"header-anchor",attrs:{href:"#第二步：定义生命周期监视器"}},[s._v("#")]),s._v(" 第二步：定义生命周期监视器")]),s._v(" "),a("div",{staticClass:"language-java line-numbers-mode"},[a("pre",{pre:!0,attrs:{class:"language-java"}},[a("code",[a("span",{pre:!0,attrs:{class:"token keyword"}},[s._v("public")]),s._v(" "),a("span",{pre:!0,attrs:{class:"token keyword"}},[s._v("class")]),s._v(" "),a("span",{pre:!0,attrs:{class:"token class-name"}},[s._v("LCObserver")]),s._v(" "),a("span",{pre:!0,attrs:{class:"token keyword"}},[s._v("implements")]),s._v(" "),a("span",{pre:!0,attrs:{class:"token class-name"}},[s._v("LifecycleObserver")]),s._v(" "),a("span",{pre:!0,attrs:{class:"token punctuation"}},[s._v("{")]),s._v("\n\n "),a("span",{pre:!0,attrs:{class:"token class-name"}},[s._v("HttpTask")]),a("span",{pre:!0,attrs:{class:"token generics"}},[a("span",{pre:!0,attrs:{class:"token punctuation"}},[s._v("<")]),a("span",{pre:!0,attrs:{class:"token operator"}},[s._v("?")]),a("span",{pre:!0,attrs:{class:"token punctuation"}},[s._v(">")])]),s._v(" task"),a("span",{pre:!0,attrs:{class:"token punctuation"}},[s._v(";")]),s._v("\n "),a("span",{pre:!0,attrs:{class:"token class-name"}},[s._v("Lifecycle")]),s._v(" lifecycle"),a("span",{pre:!0,attrs:{class:"token punctuation"}},[s._v(";")]),s._v("\n\n "),a("span",{pre:!0,attrs:{class:"token class-name"}},[s._v("LCObserver")]),a("span",{pre:!0,attrs:{class:"token punctuation"}},[s._v("(")]),a("span",{pre:!0,attrs:{class:"token class-name"}},[s._v("HttpTask")]),a("span",{pre:!0,attrs:{class:"token generics"}},[a("span",{pre:!0,attrs:{class:"token punctuation"}},[s._v("<")]),a("span",{pre:!0,attrs:{class:"token operator"}},[s._v("?")]),a("span",{pre:!0,attrs:{class:"token punctuation"}},[s._v(">")])]),s._v(" task"),a("span",{pre:!0,attrs:{class:"token punctuation"}},[s._v(",")]),s._v(" "),a("span",{pre:!0,attrs:{class:"token class-name"}},[s._v("Lifecycle")]),s._v(" lifecycle"),a("span",{pre:!0,attrs:{class:"token punctuation"}},[s._v(")")]),s._v(" "),a("span",{pre:!0,attrs:{class:"token punctuation"}},[s._v("{")]),s._v("\n "),a("span",{pre:!0,attrs:{class:"token keyword"}},[s._v("this")]),a("span",{pre:!0,attrs:{class:"token punctuation"}},[s._v(".")]),s._v("task "),a("span",{pre:!0,attrs:{class:"token operator"}},[s._v("=")]),s._v(" task"),a("span",{pre:!0,attrs:{class:"token punctuation"}},[s._v(";")]),s._v("\n "),a("span",{pre:!0,attrs:{class:"token keyword"}},[s._v("this")]),a("span",{pre:!0,attrs:{class:"token punctuation"}},[s._v(".")]),s._v("lifecycle "),a("span",{pre:!0,attrs:{class:"token operator"}},[s._v("=")]),s._v(" lifecycle"),a("span",{pre:!0,attrs:{class:"token punctuation"}},[s._v(";")]),s._v("\n lifecycle"),a("span",{pre:!0,attrs:{class:"token punctuation"}},[s._v(".")]),a("span",{pre:!0,attrs:{class:"token function"}},[s._v("addObserver")]),a("span",{pre:!0,attrs:{class:"token punctuation"}},[s._v("(")]),a("span",{pre:!0,attrs:{class:"token keyword"}},[s._v("this")]),a("span",{pre:!0,attrs:{class:"token punctuation"}},[s._v(")")]),a("span",{pre:!0,attrs:{class:"token punctuation"}},[s._v(";")]),s._v("\n "),a("span",{pre:!0,attrs:{class:"token punctuation"}},[s._v("}")]),s._v("\n\n "),a("span",{pre:!0,attrs:{class:"token annotation punctuation"}},[s._v("@OnLifecycleEvent")]),a("span",{pre:!0,attrs:{class:"token punctuation"}},[s._v("(")]),a("span",{pre:!0,attrs:{class:"token class-name"}},[s._v("Lifecycle")]),a("span",{pre:!0,attrs:{class:"token punctuation"}},[s._v(".")]),a("span",{pre:!0,attrs:{class:"token class-name"}},[s._v("Event")]),a("span",{pre:!0,attrs:{class:"token punctuation"}},[s._v(".")]),s._v("ON_STOP"),a("span",{pre:!0,attrs:{class:"token punctuation"}},[s._v(")")]),s._v("\n "),a("span",{pre:!0,attrs:{class:"token keyword"}},[s._v("public")]),s._v(" "),a("span",{pre:!0,attrs:{class:"token keyword"}},[s._v("void")]),s._v(" "),a("span",{pre:!0,attrs:{class:"token function"}},[s._v("onStop")]),a("span",{pre:!0,attrs:{class:"token punctuation"}},[s._v("(")]),a("span",{pre:!0,attrs:{class:"token punctuation"}},[s._v(")")]),s._v(" "),a("span",{pre:!0,attrs:{class:"token punctuation"}},[s._v("{")]),s._v("\n task"),a("span",{pre:!0,attrs:{class:"token punctuation"}},[s._v(".")]),a("span",{pre:!0,attrs:{class:"token function"}},[s._v("cancel")]),a("span",{pre:!0,attrs:{class:"token punctuation"}},[s._v("(")]),a("span",{pre:!0,attrs:{class:"token punctuation"}},[s._v(")")]),a("span",{pre:!0,attrs:{class:"token punctuation"}},[s._v(";")]),s._v(" "),a("span",{pre:!0,attrs:{class:"token comment"}},[s._v("// 在 ON_STOP 事件中，取消对应的 HTTP 任务")]),s._v("\n "),a("span",{pre:!0,attrs:{class:"token punctuation"}},[s._v("}")]),s._v("\n\n "),a("span",{pre:!0,attrs:{class:"token keyword"}},[s._v("public")]),s._v(" "),a("span",{pre:!0,attrs:{class:"token keyword"}},[s._v("void")]),s._v(" "),a("span",{pre:!0,attrs:{class:"token function"}},[s._v("unbind")]),a("span",{pre:!0,attrs:{class:"token punctuation"}},[s._v("(")]),a("span",{pre:!0,attrs:{class:"token punctuation"}},[s._v(")")]),s._v(" "),a("span",{pre:!0,attrs:{class:"token punctuation"}},[s._v("{")]),s._v("\n "),a("span",{pre:!0,attrs:{class:"token comment"}},[s._v("// 在请求完成之后移除监视器")]),s._v("\n lifecycle"),a("span",{pre:!0,attrs:{class:"token punctuation"}},[s._v(".")]),a("span",{pre:!0,attrs:{class:"token function"}},[s._v("removeObserver")]),a("span",{pre:!0,attrs:{class:"token punctuation"}},[s._v("(")]),a("span",{pre:!0,attrs:{class:"token keyword"}},[s._v("this")]),a("span",{pre:!0,attrs:{class:"token punctuation"}},[s._v(")")]),a("span",{pre:!0,attrs:{class:"token punctuation"}},[s._v(";")]),s._v("\n "),a("span",{pre:!0,attrs:{class:"token punctuation"}},[s._v("}")]),s._v("\n\n"),a("span",{pre:!0,attrs:{class:"token punctuation"}},[s._v("}")]),s._v("\n")])]),s._v(" "),a("div",{staticClass:"line-numbers-wrapper"},[a("span",{staticClass:"line-number"},[s._v("1")]),a("br"),a("span",{staticClass:"line-number"},[s._v("2")]),a("br"),a("span",{staticClass:"line-number"},[s._v("3")]),a("br"),a("span",{staticClass:"line-number"},[s._v("4")]),a("br"),a("span",{staticClass:"line-number"},[s._v("5")]),a("br"),a("span",{staticClass:"line-number"},[s._v("6")]),a("br"),a("span",{staticClass:"line-number"},[s._v("7")]),a("br"),a("span",{staticClass:"line-number"},[s._v("8")]),a("br"),a("span",{staticClass:"line-number"},[s._v("9")]),a("br"),a("span",{staticClass:"line-number"},[s._v("10")]),a("br"),a("span",{staticClass:"line-number"},[s._v("11")]),a("br"),a("span",{staticClass:"line-number"},[s._v("12")]),a("br"),a("span",{staticClass:"line-number"},[s._v("13")]),a("br"),a("span",{staticClass:"line-number"},[s._v("14")]),a("br"),a("span",{staticClass:"line-number"},[s._v("15")]),a("br"),a("span",{staticClass:"line-number"},[s._v("16")]),a("br"),a("span",{staticClass:"line-number"},[s._v("17")]),a("br"),a("span",{staticClass:"line-number"},[s._v("18")]),a("br"),a("span",{staticClass:"line-number"},[s._v("19")]),a("br"),a("span",{staticClass:"line-number"},[s._v("20")]),a("br"),a("span",{staticClass:"line-number"},[s._v("21")]),a("br"),a("span",{staticClass:"line-number"},[s._v("22")]),a("br")])]),a("h3",{attrs:{id:"第三步：配置全局回调监听"}},[a("a",{staticClass:"header-anchor",attrs:{href:"#第三步：配置全局回调监听"}},[s._v("#")]),s._v(" 第三步：配置全局回调监听")]),s._v(" "),a("p",[s._v("以上两步其实已经实现了生命周期绑定的功能，但是在请求完成之后，我们需要在"),a("code",[s._v("lifecycle")]),s._v("中移除"),a("code",[s._v("LCObserver")]),s._v("对象：")]),s._v(" "),a("div",{staticClass:"language-java line-numbers-mode"},[a("pre",{pre:!0,attrs:{class:"language-java"}},[a("code",[a("span",{pre:!0,attrs:{class:"token class-name"}},[s._v("HTTP")]),s._v(" http "),a("span",{pre:!0,attrs:{class:"token operator"}},[s._v("=")]),s._v(" HTTP"),a("span",{pre:!0,attrs:{class:"token punctuation"}},[s._v(".")]),a("span",{pre:!0,attrs:{class:"token function"}},[s._v("builder")]),a("span",{pre:!0,attrs:{class:"token punctuation"}},[s._v("(")]),a("span",{pre:!0,attrs:{class:"token punctuation"}},[s._v(")")]),s._v("\n "),a("span",{pre:!0,attrs:{class:"token punctuation"}},[s._v(".")]),a("span",{pre:!0,attrs:{class:"token punctuation"}},[s._v(".")]),a("span",{pre:!0,attrs:{class:"token punctuation"}},[s._v(".")]),s._v(" "),a("span",{pre:!0,attrs:{class:"token comment"}},[s._v("// 省略其它配置项")]),s._v("\n "),a("span",{pre:!0,attrs:{class:"token punctuation"}},[s._v(".")]),a("span",{pre:!0,attrs:{class:"token function"}},[s._v("completeListener")]),a("span",{pre:!0,attrs:{class:"token punctuation"}},[s._v("(")]),a("span",{pre:!0,attrs:{class:"token punctuation"}},[s._v("(")]),a("span",{pre:!0,attrs:{class:"token class-name"}},[s._v("HttpTask")]),a("span",{pre:!0,attrs:{class:"token generics"}},[a("span",{pre:!0,attrs:{class:"token punctuation"}},[s._v("<")]),a("span",{pre:!0,attrs:{class:"token operator"}},[s._v("?")]),a("span",{pre:!0,attrs:{class:"token punctuation"}},[s._v(">")])]),s._v(" task"),a("span",{pre:!0,attrs:{class:"token punctuation"}},[s._v(",")]),s._v(" "),a("span",{pre:!0,attrs:{class:"token class-name"}},[s._v("HttpResult")]),a("span",{pre:!0,attrs:{class:"token punctuation"}},[s._v(".")]),a("span",{pre:!0,attrs:{class:"token class-name"}},[s._v("State")]),s._v(" state"),a("span",{pre:!0,attrs:{class:"token punctuation"}},[s._v(")")]),s._v(" "),a("span",{pre:!0,attrs:{class:"token operator"}},[s._v("->")]),s._v(" "),a("span",{pre:!0,attrs:{class:"token punctuation"}},[s._v("{")]),s._v("\n "),a("span",{pre:!0,attrs:{class:"token class-name"}},[s._v("Object")]),s._v(" bound "),a("span",{pre:!0,attrs:{class:"token operator"}},[s._v("=")]),s._v(" task"),a("span",{pre:!0,attrs:{class:"token punctuation"}},[s._v(".")]),a("span",{pre:!0,attrs:{class:"token function"}},[s._v("getBound")]),a("span",{pre:!0,attrs:{class:"token punctuation"}},[s._v("(")]),a("span",{pre:!0,attrs:{class:"token punctuation"}},[s._v(")")]),a("span",{pre:!0,attrs:{class:"token punctuation"}},[s._v(";")]),s._v("\n "),a("span",{pre:!0,attrs:{class:"token comment"}},[s._v("// 判断 task 是否绑定了生命周期监视器（LCObserver）对象")]),s._v("\n "),a("span",{pre:!0,attrs:{class:"token keyword"}},[s._v("if")]),s._v(" "),a("span",{pre:!0,attrs:{class:"token punctuation"}},[s._v("(")]),s._v("bound "),a("span",{pre:!0,attrs:{class:"token keyword"}},[s._v("instanceof")]),s._v(" "),a("span",{pre:!0,attrs:{class:"token class-name"}},[s._v("LCObserver")]),a("span",{pre:!0,attrs:{class:"token punctuation"}},[s._v(")")]),s._v(" "),a("span",{pre:!0,attrs:{class:"token punctuation"}},[s._v("{")]),s._v("\n "),a("span",{pre:!0,attrs:{class:"token comment"}},[s._v("// 解绑监视器")]),s._v("\n "),a("span",{pre:!0,attrs:{class:"token punctuation"}},[s._v("(")]),a("span",{pre:!0,attrs:{class:"token punctuation"}},[s._v("(")]),a("span",{pre:!0,attrs:{class:"token class-name"}},[s._v("LCObserver")]),a("span",{pre:!0,attrs:{class:"token punctuation"}},[s._v(")")]),s._v(" bound"),a("span",{pre:!0,attrs:{class:"token punctuation"}},[s._v(")")]),a("span",{pre:!0,attrs:{class:"token punctuation"}},[s._v(".")]),a("span",{pre:!0,attrs:{class:"token function"}},[s._v("unbind")]),a("span",{pre:!0,attrs:{class:"token punctuation"}},[s._v("(")]),a("span",{pre:!0,attrs:{class:"token punctuation"}},[s._v(")")]),a("span",{pre:!0,attrs:{class:"token punctuation"}},[s._v(";")]),s._v("\n "),a("span",{pre:!0,attrs:{class:"token punctuation"}},[s._v("}")]),s._v("\n "),a("span",{pre:!0,attrs:{class:"token keyword"}},[s._v("return")]),s._v(" "),a("span",{pre:!0,attrs:{class:"token boolean"}},[s._v("true")]),a("span",{pre:!0,attrs:{class:"token punctuation"}},[s._v(";")]),s._v("\n "),a("span",{pre:!0,attrs:{class:"token punctuation"}},[s._v("}")]),a("span",{pre:!0,attrs:{class:"token punctuation"}},[s._v(")")]),s._v("\n "),a("span",{pre:!0,attrs:{class:"token punctuation"}},[s._v(".")]),a("span",{pre:!0,attrs:{class:"token punctuation"}},[s._v(".")]),a("span",{pre:!0,attrs:{class:"token punctuation"}},[s._v(".")]),s._v(" "),a("span",{pre:!0,attrs:{class:"token comment"}},[s._v("// 省略其它配置项")]),s._v("\n "),a("span",{pre:!0,attrs:{class:"token punctuation"}},[s._v(".")]),a("span",{pre:!0,attrs:{class:"token function"}},[s._v("build")]),a("span",{pre:!0,attrs:{class:"token punctuation"}},[s._v("(")]),a("span",{pre:!0,attrs:{class:"token punctuation"}},[s._v(")")]),a("span",{pre:!0,attrs:{class:"token punctuation"}},[s._v(";")]),s._v("\n")])]),s._v(" "),a("div",{staticClass:"line-numbers-wrapper"},[a("span",{staticClass:"line-number"},[s._v("1")]),a("br"),a("span",{staticClass:"line-number"},[s._v("2")]),a("br"),a("span",{staticClass:"line-number"},[s._v("3")]),a("br"),a("span",{staticClass:"line-number"},[s._v("4")]),a("br"),a("span",{staticClass:"line-number"},[s._v("5")]),a("br"),a("span",{staticClass:"line-number"},[s._v("6")]),a("br"),a("span",{staticClass:"line-number"},[s._v("7")]),a("br"),a("span",{staticClass:"line-number"},[s._v("8")]),a("br"),a("span",{staticClass:"line-number"},[s._v("9")]),a("br"),a("span",{staticClass:"line-number"},[s._v("10")]),a("br"),a("span",{staticClass:"line-number"},[s._v("11")]),a("br"),a("span",{staticClass:"line-number"},[s._v("12")]),a("br"),a("span",{staticClass:"line-number"},[s._v("13")]),a("br")])]),a("p",[a("strong",[s._v("以上三步便在Android中实现了生命周期与HTTP请求绑定的功能")])]),s._v(" "),a("p",[s._v("非常简单，懒得敲代码的同学还可以 "),a("a",{attrs:{href:"https://gitee.com/ejlchina-zhxu/okhttps-android-demo/blob/master/app/src/main/java/com/flower/myapplication/http/OkHttps.java",target:"_blank",rel:"noopener noreferrer"}},[s._v("点这里 OkHttps.java"),a("OutboundLink")],1),s._v(" 直接下载封装好的源码，其中不仅编写了生命周期绑定的配置，还有在UI线程执行回调的配置。")]),s._v(" "),a("p",[s._v("有需要的同学，可以直接下载下来使用，还可以基于它再次扩展，比如实现自动添加 TOKEN 的功能，具体可以参考"),a("a",{attrs:{href:"#65-%E4%B8%B2%E8%A1%8C%E9%A2%84%E5%A4%84%E7%90%86%E5%99%A8token%E9%97%AE%E9%A2%98%E6%9C%80%E4%BD%B3%E8%A7%A3%E5%86%B3%E6%96%B9%E6%A1%88"}},[s._v("6.5 串行预处理器（TOKEN问题最佳解决方案）")]),s._v("，再比如扩展实现生命周期与下载事件绑定的功能，都非常简单。")])])}),[],!1,null,null,null);t.default=e.exports}}]); \ No newline at end of file diff --git a/okhttps-doc/docs/.vuepress/dist/assets/js/9.bff804f8.js b/okhttps-doc/docs/.vuepress/dist/assets/js/9.bff804f8.js new file mode 100644 index 00000000..2dae5b30 --- /dev/null +++ b/okhttps-doc/docs/.vuepress/dist/assets/js/9.bff804f8.js @@ -0,0 +1 @@ +(window.webpackJsonp=window.webpackJsonp||[]).push([[9],{339:function(t,s,a){"use strict";a.r(s);var n=a(19),e=Object(n.a)({},(function(){var t=this,s=t.$createElement,a=t._self._c||s;return a("ContentSlotsDistributor",{attrs:{"slot-key":t.$parent.slotKey}},[a("h1",{attrs:{id:"配置"}},[a("a",{staticClass:"header-anchor",attrs:{href:"#配置"}},[t._v("#")]),t._v(" 配置")]),t._v(" "),a("h2",{attrs:{id:"设置-baseurl"}},[a("a",{staticClass:"header-anchor",attrs:{href:"#设置-baseurl"}},[t._v("#")]),t._v(" 设置 BaseUrl")]),t._v(" "),a("div",{staticClass:"language-java line-numbers-mode"},[a("pre",{pre:!0,attrs:{class:"language-java"}},[a("code",[a("span",{pre:!0,attrs:{class:"token class-name"}},[t._v("HTTP")]),t._v(" http "),a("span",{pre:!0,attrs:{class:"token operator"}},[t._v("=")]),t._v(" HTTP"),a("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v(".")]),a("span",{pre:!0,attrs:{class:"token function"}},[t._v("builder")]),a("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v("(")]),a("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v(")")]),t._v("\n "),a("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v(".")]),a("span",{pre:!0,attrs:{class:"token function"}},[t._v("baseUrl")]),a("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v("(")]),a("span",{pre:!0,attrs:{class:"token string"}},[t._v('"http://api.demo.com"')]),a("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v(")")]),t._v(" "),a("span",{pre:!0,attrs:{class:"token comment"}},[t._v("// 设置 BaseUrl")]),t._v("\n "),a("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v(".")]),a("span",{pre:!0,attrs:{class:"token function"}},[t._v("build")]),a("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v("(")]),a("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v(")")]),a("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v(";")]),t._v("\n")])]),t._v(" "),a("div",{staticClass:"line-numbers-wrapper"},[a("span",{staticClass:"line-number"},[t._v("1")]),a("br"),a("span",{staticClass:"line-number"},[t._v("2")]),a("br"),a("span",{staticClass:"line-number"},[t._v("3")]),a("br")])]),a("p",[t._v("该配置全局生效，在配置了"),a("code",[t._v("BaseUrl")]),t._v("之后，具体的请求便可以省略"),a("code",[t._v("BaseUrl")]),t._v("部分，使得代码更加简洁，例如：")]),t._v(" "),a("div",{staticClass:"language-java line-numbers-mode"},[a("pre",{pre:!0,attrs:{class:"language-java"}},[a("code",[t._v("http"),a("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v(".")]),a("span",{pre:!0,attrs:{class:"token function"}},[t._v("sync")]),a("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v("(")]),a("span",{pre:!0,attrs:{class:"token string"}},[t._v('"/users"')]),a("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v(")")]),a("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v(".")]),a("span",{pre:!0,attrs:{class:"token function"}},[t._v("get")]),a("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v("(")]),a("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v(")")]),t._v(" "),a("span",{pre:!0,attrs:{class:"token comment"}},[t._v("// http://api.demo.com/users")]),t._v("\n\nhttp"),a("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v(".")]),a("span",{pre:!0,attrs:{class:"token function"}},[t._v("sync")]),a("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v("(")]),a("span",{pre:!0,attrs:{class:"token string"}},[t._v('"/auth/signin"')]),a("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v(")")]),t._v(" "),a("span",{pre:!0,attrs:{class:"token comment"}},[t._v("// http://api.demo.com/auth/signin")]),t._v("\n "),a("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v(".")]),a("span",{pre:!0,attrs:{class:"token function"}},[t._v("addBodyParam")]),a("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v("(")]),a("span",{pre:!0,attrs:{class:"token string"}},[t._v('"username"')]),a("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v(",")]),t._v(" "),a("span",{pre:!0,attrs:{class:"token string"}},[t._v('"Jackson"')]),a("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v(")")]),t._v("\n "),a("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v(".")]),a("span",{pre:!0,attrs:{class:"token function"}},[t._v("addBodyParam")]),a("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v("(")]),a("span",{pre:!0,attrs:{class:"token string"}},[t._v('"password"')]),a("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v(",")]),t._v(" "),a("span",{pre:!0,attrs:{class:"token string"}},[t._v('"xxxxxx"')]),a("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v(")")]),t._v("\n "),a("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v(".")]),a("span",{pre:!0,attrs:{class:"token function"}},[t._v("post")]),a("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v("(")]),a("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v(")")]),a("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v(";")]),t._v(" "),a("span",{pre:!0,attrs:{class:"token comment"}},[t._v("// POST请求")]),t._v("\n")])]),t._v(" "),a("div",{staticClass:"line-numbers-wrapper"},[a("span",{staticClass:"line-number"},[t._v("1")]),a("br"),a("span",{staticClass:"line-number"},[t._v("2")]),a("br"),a("span",{staticClass:"line-number"},[t._v("3")]),a("br"),a("span",{staticClass:"line-number"},[t._v("4")]),a("br"),a("span",{staticClass:"line-number"},[t._v("5")]),a("br"),a("span",{staticClass:"line-number"},[t._v("6")]),a("br")])]),a("p",[t._v("在配置了"),a("code",[t._v("BaseUrl")]),t._v("之后，如有特殊请求任务，仍然可以使用全路径的方式，一点都不妨碍：")]),t._v(" "),a("div",{staticClass:"language-java line-numbers-mode"},[a("pre",{pre:!0,attrs:{class:"language-java"}},[a("code",[t._v("http"),a("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v(".")]),a("span",{pre:!0,attrs:{class:"token function"}},[t._v("sync")]),a("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v("(")]),a("span",{pre:!0,attrs:{class:"token string"}},[t._v('"https://www.baidu.com"')]),a("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v(")")]),a("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v(".")]),a("span",{pre:!0,attrs:{class:"token function"}},[t._v("get")]),a("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v("(")]),a("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v(")")]),a("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v(";")]),t._v("\n")])]),t._v(" "),a("div",{staticClass:"line-numbers-wrapper"},[a("span",{staticClass:"line-number"},[t._v("1")]),a("br")])]),a("h2",{attrs:{id:"回调执行器"}},[a("a",{staticClass:"header-anchor",attrs:{href:"#回调执行器"}},[t._v("#")]),t._v(" 回调执行器")]),t._v(" "),a("p",[t._v("OkHttps 默认所有回调都在 "),a("strong",[t._v("IO线程")]),t._v(" 执行，如何想改变执行回调的线程时，可以配置回调执行器。例如在Android里，让所有的回调函数都在UI线程执行，则可以在构建"),a("code",[t._v("HTTP")]),t._v("时配置如下：")]),t._v(" "),a("div",{staticClass:"language-java line-numbers-mode"},[a("pre",{pre:!0,attrs:{class:"language-java"}},[a("code",[a("span",{pre:!0,attrs:{class:"token class-name"}},[t._v("HTTP")]),t._v(" http "),a("span",{pre:!0,attrs:{class:"token operator"}},[t._v("=")]),t._v(" HTTP"),a("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v(".")]),a("span",{pre:!0,attrs:{class:"token function"}},[t._v("builder")]),a("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v("(")]),a("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v(")")]),t._v("\n "),a("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v(".")]),a("span",{pre:!0,attrs:{class:"token function"}},[t._v("callbackExecutor")]),a("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v("(")]),a("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v("(")]),a("span",{pre:!0,attrs:{class:"token class-name"}},[t._v("Runnable")]),t._v(" run"),a("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v(")")]),t._v(" "),a("span",{pre:!0,attrs:{class:"token operator"}},[t._v("->")]),t._v(" "),a("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v("{")]),t._v("\n "),a("span",{pre:!0,attrs:{class:"token function"}},[t._v("runOnUiThread")]),a("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v("(")]),t._v("run"),a("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v(")")]),a("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v(";")]),t._v(" "),a("span",{pre:!0,attrs:{class:"token comment"}},[t._v("// 在UI线程执行")]),t._v("\n "),a("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v("}")]),a("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v(")")]),t._v("\n "),a("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v(".")]),a("span",{pre:!0,attrs:{class:"token function"}},[t._v("build")]),a("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v("(")]),a("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v(")")]),a("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v(";")]),t._v("\n")])]),t._v(" "),a("div",{staticClass:"line-numbers-wrapper"},[a("span",{staticClass:"line-number"},[t._v("1")]),a("br"),a("span",{staticClass:"line-number"},[t._v("2")]),a("br"),a("span",{staticClass:"line-number"},[t._v("3")]),a("br"),a("span",{staticClass:"line-number"},[t._v("4")]),a("br"),a("span",{staticClass:"line-number"},[t._v("5")]),a("br")])]),a("p",[t._v("该配置默认 "),a("strong",[t._v("影响所有回调")]),t._v("。")]),t._v(" "),a("h2",{attrs:{id:"配置-okhttpclient"}},[a("a",{staticClass:"header-anchor",attrs:{href:"#配置-okhttpclient"}},[t._v("#")]),t._v(" 配置 OkHttpClient")]),t._v(" "),a("p",[t._v("与其他封装 OkHttp3 的框架不同，OkHttps 并不会遮蔽 OkHttp3 本身就很好用的功能，如下：")]),t._v(" "),a("div",{staticClass:"language-java line-numbers-mode"},[a("pre",{pre:!0,attrs:{class:"language-java"}},[a("code",[a("span",{pre:!0,attrs:{class:"token class-name"}},[t._v("HTTP")]),t._v(" http "),a("span",{pre:!0,attrs:{class:"token operator"}},[t._v("=")]),t._v(" HTTP"),a("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v(".")]),a("span",{pre:!0,attrs:{class:"token function"}},[t._v("builder")]),a("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v("(")]),a("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v(")")]),t._v("\n "),a("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v(".")]),a("span",{pre:!0,attrs:{class:"token function"}},[t._v("config")]),a("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v("(")]),a("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v("(")]),a("span",{pre:!0,attrs:{class:"token class-name"}},[t._v("Builder")]),t._v(" builder"),a("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v(")")]),t._v(" "),a("span",{pre:!0,attrs:{class:"token operator"}},[t._v("->")]),t._v(" "),a("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v("{")]),t._v("\n "),a("span",{pre:!0,attrs:{class:"token comment"}},[t._v("// 配置连接池 最小10个连接（不配置默认为 5）")]),t._v("\n builder"),a("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v(".")]),a("span",{pre:!0,attrs:{class:"token function"}},[t._v("connectionPool")]),a("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v("(")]),a("span",{pre:!0,attrs:{class:"token keyword"}},[t._v("new")]),t._v(" "),a("span",{pre:!0,attrs:{class:"token class-name"}},[t._v("ConnectionPool")]),a("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v("(")]),a("span",{pre:!0,attrs:{class:"token number"}},[t._v("10")]),a("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v(",")]),t._v(" "),a("span",{pre:!0,attrs:{class:"token number"}},[t._v("5")]),a("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v(",")]),t._v(" "),a("span",{pre:!0,attrs:{class:"token class-name"}},[t._v("TimeUnit")]),a("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v(".")]),t._v("MINUTES"),a("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v(")")]),a("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v(")")]),a("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v(";")]),t._v("\n "),a("span",{pre:!0,attrs:{class:"token comment"}},[t._v("// 配置连接超时时间（默认10秒）")]),t._v("\n builder"),a("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v(".")]),a("span",{pre:!0,attrs:{class:"token function"}},[t._v("connectTimeout")]),a("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v("(")]),a("span",{pre:!0,attrs:{class:"token number"}},[t._v("20")]),a("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v(",")]),t._v(" "),a("span",{pre:!0,attrs:{class:"token class-name"}},[t._v("TimeUnit")]),a("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v(".")]),t._v("SECONDS"),a("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v(")")]),a("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v(";")]),t._v("\n "),a("span",{pre:!0,attrs:{class:"token comment"}},[t._v("// 配置拦截器")]),t._v("\n builder"),a("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v(".")]),a("span",{pre:!0,attrs:{class:"token function"}},[t._v("addInterceptor")]),a("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v("(")]),a("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v("(")]),a("span",{pre:!0,attrs:{class:"token class-name"}},[t._v("Chain")]),t._v(" chain"),a("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v(")")]),t._v(" "),a("span",{pre:!0,attrs:{class:"token operator"}},[t._v("->")]),t._v(" "),a("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v("{")]),t._v("\n "),a("span",{pre:!0,attrs:{class:"token class-name"}},[t._v("Request")]),t._v(" request "),a("span",{pre:!0,attrs:{class:"token operator"}},[t._v("=")]),t._v(" chain"),a("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v(".")]),a("span",{pre:!0,attrs:{class:"token function"}},[t._v("request")]),a("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v("(")]),a("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v(")")]),a("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v(";")]),t._v("\n "),a("span",{pre:!0,attrs:{class:"token comment"}},[t._v("// 必须同步返回，拦截器内无法执行异步操作")]),t._v("\n "),a("span",{pre:!0,attrs:{class:"token keyword"}},[t._v("return")]),t._v(" chain"),a("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v(".")]),a("span",{pre:!0,attrs:{class:"token function"}},[t._v("proceed")]),a("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v("(")]),t._v("request"),a("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v(")")]),a("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v(";")]),t._v("\n "),a("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v("}")]),a("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v(")")]),a("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v(";")]),t._v("\n "),a("span",{pre:!0,attrs:{class:"token comment"}},[t._v("// 其它配置: CookieJar、SSL、缓存、代理、事件监听...")]),t._v("\n "),a("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v("}")]),a("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v(")")]),t._v("\n "),a("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v(".")]),a("span",{pre:!0,attrs:{class:"token function"}},[t._v("build")]),a("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v("(")]),a("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v(")")]),a("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v(";")]),t._v("\n")])]),t._v(" "),a("div",{staticClass:"line-numbers-wrapper"},[a("span",{staticClass:"line-number"},[t._v("1")]),a("br"),a("span",{staticClass:"line-number"},[t._v("2")]),a("br"),a("span",{staticClass:"line-number"},[t._v("3")]),a("br"),a("span",{staticClass:"line-number"},[t._v("4")]),a("br"),a("span",{staticClass:"line-number"},[t._v("5")]),a("br"),a("span",{staticClass:"line-number"},[t._v("6")]),a("br"),a("span",{staticClass:"line-number"},[t._v("7")]),a("br"),a("span",{staticClass:"line-number"},[t._v("8")]),a("br"),a("span",{staticClass:"line-number"},[t._v("9")]),a("br"),a("span",{staticClass:"line-number"},[t._v("10")]),a("br"),a("span",{staticClass:"line-number"},[t._v("11")]),a("br"),a("span",{staticClass:"line-number"},[t._v("12")]),a("br"),a("span",{staticClass:"line-number"},[t._v("13")]),a("br"),a("span",{staticClass:"line-number"},[t._v("14")]),a("br"),a("span",{staticClass:"line-number"},[t._v("15")]),a("br")])]),a("h2",{attrs:{id:"并行预处理器"}},[a("a",{staticClass:"header-anchor",attrs:{href:"#并行预处理器"}},[t._v("#")]),t._v(" 并行预处理器")]),t._v(" "),a("p",[t._v("预处理器（"),a("code",[t._v("Preprocessor")]),t._v("）可以让我们在请求发出之前对请求本身做一些改变，但与"),a("code",[t._v("OkHttp")]),t._v("的拦截器（"),a("code",[t._v("Interceptor")]),t._v("）不同：预处理器可以让我们 "),a("strong",[t._v("异步")]),t._v(" 处理这些问题。")]),t._v(" "),a("p",[t._v("例如，当我们想为请求任务自动添加"),a("code",[t._v("Token")]),t._v("头信息，而"),a("code",[t._v("Token")]),t._v("只能通过异步方法"),a("code",[t._v("requestToken")]),t._v("获取时，这时使用"),a("code",[t._v("Interceptor")]),t._v("就很难处理了，但可以使用预处理器轻松解决：")]),t._v(" "),a("div",{staticClass:"language-java line-numbers-mode"},[a("pre",{pre:!0,attrs:{class:"language-java"}},[a("code",[a("span",{pre:!0,attrs:{class:"token class-name"}},[t._v("HTTP")]),t._v(" http "),a("span",{pre:!0,attrs:{class:"token operator"}},[t._v("=")]),t._v(" HTTP"),a("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v(".")]),a("span",{pre:!0,attrs:{class:"token function"}},[t._v("builder")]),a("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v("(")]),a("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v(")")]),t._v("\n "),a("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v(".")]),a("span",{pre:!0,attrs:{class:"token function"}},[t._v("addPreprocessor")]),a("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v("(")]),a("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v("(")]),a("span",{pre:!0,attrs:{class:"token class-name"}},[t._v("PreChain")]),t._v(" chain"),a("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v(")")]),t._v(" "),a("span",{pre:!0,attrs:{class:"token operator"}},[t._v("->")]),t._v(" "),a("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v("{")]),t._v("\n "),a("span",{pre:!0,attrs:{class:"token class-name"}},[t._v("HttpTask")]),a("span",{pre:!0,attrs:{class:"token generics"}},[a("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v("<")]),a("span",{pre:!0,attrs:{class:"token operator"}},[t._v("?")]),a("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v(">")])]),t._v(" task "),a("span",{pre:!0,attrs:{class:"token operator"}},[t._v("=")]),t._v(" chain"),a("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v(".")]),a("span",{pre:!0,attrs:{class:"token function"}},[t._v("getTask")]),a("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v("(")]),a("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v(")")]),a("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v(";")]),a("span",{pre:!0,attrs:{class:"token comment"}},[t._v("// 获得当前的HTTP任务")]),t._v("\n "),a("span",{pre:!0,attrs:{class:"token keyword"}},[t._v("if")]),t._v(" "),a("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v("(")]),a("span",{pre:!0,attrs:{class:"token operator"}},[t._v("!")]),t._v("task"),a("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v(".")]),a("span",{pre:!0,attrs:{class:"token function"}},[t._v("isTagged")]),a("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v("(")]),a("span",{pre:!0,attrs:{class:"token string"}},[t._v('"Auth"')]),a("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v(")")]),a("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v(")")]),t._v(" "),a("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v("{")]),t._v(" "),a("span",{pre:!0,attrs:{class:"token comment"}},[t._v("// 根据标签判断该任务是否需要Token")]),t._v("\n chain"),a("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v(".")]),a("span",{pre:!0,attrs:{class:"token function"}},[t._v("proceed")]),a("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v("(")]),a("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v(")")]),a("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v(";")]),t._v("\n "),a("span",{pre:!0,attrs:{class:"token keyword"}},[t._v("return")]),a("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v(";")]),t._v("\n "),a("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v("}")]),t._v("\n "),a("span",{pre:!0,attrs:{class:"token function"}},[t._v("requestToken")]),a("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v("(")]),a("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v("(")]),a("span",{pre:!0,attrs:{class:"token class-name"}},[t._v("String")]),t._v(" token"),a("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v(")")]),t._v(" "),a("span",{pre:!0,attrs:{class:"token operator"}},[t._v("->")]),t._v(" "),a("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v("{")]),t._v(" "),a("span",{pre:!0,attrs:{class:"token comment"}},[t._v("// 异步获取 Token")]),t._v("\n task"),a("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v(".")]),a("span",{pre:!0,attrs:{class:"token function"}},[t._v("addHeader")]),a("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v("(")]),a("span",{pre:!0,attrs:{class:"token string"}},[t._v('"Token"')]),a("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v(",")]),t._v(" token"),a("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v(")")]),a("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v(";")]),a("span",{pre:!0,attrs:{class:"token comment"}},[t._v("// 为任务添加头信息")]),t._v("\n chain"),a("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v(".")]),a("span",{pre:!0,attrs:{class:"token function"}},[t._v("proceed")]),a("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v("(")]),a("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v(")")]),a("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v(";")]),t._v(" "),a("span",{pre:!0,attrs:{class:"token comment"}},[t._v("// 继续当前的任务")]),t._v("\n "),a("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v("}")]),a("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v(")")]),a("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v(";")]),t._v("\n "),a("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v("}")]),a("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v(")")]),t._v("\n "),a("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v(".")]),a("span",{pre:!0,attrs:{class:"token function"}},[t._v("build")]),a("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v("(")]),a("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v(")")]),a("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v(";")]),t._v("\n")])]),t._v(" "),a("div",{staticClass:"line-numbers-wrapper"},[a("span",{staticClass:"line-number"},[t._v("1")]),a("br"),a("span",{staticClass:"line-number"},[t._v("2")]),a("br"),a("span",{staticClass:"line-number"},[t._v("3")]),a("br"),a("span",{staticClass:"line-number"},[t._v("4")]),a("br"),a("span",{staticClass:"line-number"},[t._v("5")]),a("br"),a("span",{staticClass:"line-number"},[t._v("6")]),a("br"),a("span",{staticClass:"line-number"},[t._v("7")]),a("br"),a("span",{staticClass:"line-number"},[t._v("8")]),a("br"),a("span",{staticClass:"line-number"},[t._v("9")]),a("br"),a("span",{staticClass:"line-number"},[t._v("10")]),a("br"),a("span",{staticClass:"line-number"},[t._v("11")]),a("br"),a("span",{staticClass:"line-number"},[t._v("12")]),a("br"),a("span",{staticClass:"line-number"},[t._v("13")]),a("br")])]),a("p",[t._v("和"),a("code",[t._v("Interceptor")]),t._v("一样，"),a("code",[t._v("Preprocessor")]),t._v("也可以添加多个。他们之间的区别如下:")]),t._v(" "),a("div",{staticClass:"custom-block tip"},[a("p",{staticClass:"custom-block-title"},[t._v("拦截器与预处理器的区别")]),t._v(" "),a("ul",[a("li",[t._v("拦截器只能处理同步操作，预处理器支持处理异步操作")]),t._v(" "),a("li",[t._v("拦截器都是并行处理请求，预处理器支持串行处理（详见6.5章节）")]),t._v(" "),a("li",[t._v("拦截器处理时机在请求前和响应后，预处理器只在请求前，并且先于拦截器执行。关于响应后，OkHttps还提供了全局回调监听（详见6.6章节）")])])]),t._v(" "),a("h2",{attrs:{id:"串行预处理器（token问题最佳解决方案）"}},[a("a",{staticClass:"header-anchor",attrs:{href:"#串行预处理器（token问题最佳解决方案）"}},[t._v("#")]),t._v(" 串行预处理器（TOKEN问题最佳解决方案）")]),t._v(" "),a("p",[t._v("普通预处理器都是可并行处理的，然而有时我们希望某个预处理器同时只处理一个任务。比如 当"),a("code",[t._v("Token")]),t._v("过期时我们需要去刷新获取新"),a("code",[t._v("Token")]),t._v("，而刷新"),a("code",[t._v("Token")]),t._v("这个操作只能有一个任务去执行，因为如果"),a("code",[t._v("n")]),t._v("个任务同时执行的话，那么必有"),a("code",[t._v("n-1")]),t._v("个任务刚刷新得到的"),a("code",[t._v("Token")]),t._v("可能就立马失效了，而这是我们所不希望的。")]),t._v(" "),a("p",[t._v("为了解决这个问题，OkHttps 提供了串行预处理器，它可以让 HTTP 任务排好队，一个一个地进入预处理器：")]),t._v(" "),a("div",{staticClass:"language-java line-numbers-mode"},[a("pre",{pre:!0,attrs:{class:"language-java"}},[a("code",[a("span",{pre:!0,attrs:{class:"token class-name"}},[t._v("HTTP")]),t._v(" http "),a("span",{pre:!0,attrs:{class:"token operator"}},[t._v("=")]),t._v(" HTTP"),a("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v(".")]),a("span",{pre:!0,attrs:{class:"token function"}},[t._v("builder")]),a("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v("(")]),a("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v(")")]),t._v("\n "),a("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v(".")]),a("span",{pre:!0,attrs:{class:"token function"}},[t._v("addSerialPreprocessor")]),a("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v("(")]),a("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v("(")]),a("span",{pre:!0,attrs:{class:"token class-name"}},[t._v("PreChain")]),t._v(" chain"),a("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v(")")]),t._v(" "),a("span",{pre:!0,attrs:{class:"token operator"}},[t._v("->")]),t._v(" "),a("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v("{")]),t._v("\n "),a("span",{pre:!0,attrs:{class:"token class-name"}},[t._v("HttpTask")]),a("span",{pre:!0,attrs:{class:"token generics"}},[a("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v("<")]),a("span",{pre:!0,attrs:{class:"token operator"}},[t._v("?")]),a("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v(">")])]),t._v(" task "),a("span",{pre:!0,attrs:{class:"token operator"}},[t._v("=")]),t._v(" chain"),a("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v(".")]),a("span",{pre:!0,attrs:{class:"token function"}},[t._v("getTask")]),a("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v("(")]),a("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v(")")]),a("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v(";")]),t._v("\n "),a("span",{pre:!0,attrs:{class:"token keyword"}},[t._v("if")]),t._v(" "),a("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v("(")]),a("span",{pre:!0,attrs:{class:"token operator"}},[t._v("!")]),t._v("task"),a("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v(".")]),a("span",{pre:!0,attrs:{class:"token function"}},[t._v("isTagged")]),a("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v("(")]),a("span",{pre:!0,attrs:{class:"token string"}},[t._v('"Auth"')]),a("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v(")")]),a("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v(")")]),t._v(" "),a("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v("{")]),t._v("\n chain"),a("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v(".")]),a("span",{pre:!0,attrs:{class:"token function"}},[t._v("proceed")]),a("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v("(")]),a("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v(")")]),a("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v(";")]),t._v("\n "),a("span",{pre:!0,attrs:{class:"token keyword"}},[t._v("return")]),a("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v(";")]),t._v("\n "),a("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v("}")]),t._v("\n "),a("span",{pre:!0,attrs:{class:"token comment"}},[t._v("// 检查过期，若需要则刷新Token")]),t._v("\n "),a("span",{pre:!0,attrs:{class:"token function"}},[t._v("requestTokenAndRefreshIfExpired")]),a("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v("(")]),a("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v("(")]),a("span",{pre:!0,attrs:{class:"token class-name"}},[t._v("String")]),t._v(" token"),a("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v(")")]),t._v(" "),a("span",{pre:!0,attrs:{class:"token operator"}},[t._v("->")]),t._v(" "),a("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v("{")]),t._v("\n task"),a("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v(".")]),a("span",{pre:!0,attrs:{class:"token function"}},[t._v("addHeader")]),a("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v("(")]),a("span",{pre:!0,attrs:{class:"token string"}},[t._v('"Token"')]),a("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v(",")]),t._v(" token"),a("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v(")")]),a("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v(";")]),t._v(" \n chain"),a("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v(".")]),a("span",{pre:!0,attrs:{class:"token function"}},[t._v("proceed")]),a("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v("(")]),a("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v(")")]),a("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v(";")]),t._v(" "),a("span",{pre:!0,attrs:{class:"token comment"}},[t._v("// 调用此方法前，不会有其它任务进入该处理器")]),t._v("\n "),a("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v("}")]),a("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v(")")]),a("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v(";")]),t._v("\n "),a("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v("}")]),a("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v(")")]),t._v("\n "),a("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v(".")]),a("span",{pre:!0,attrs:{class:"token function"}},[t._v("build")]),a("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v("(")]),a("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v(")")]),a("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v(";")]),t._v("\n")])]),t._v(" "),a("div",{staticClass:"line-numbers-wrapper"},[a("span",{staticClass:"line-number"},[t._v("1")]),a("br"),a("span",{staticClass:"line-number"},[t._v("2")]),a("br"),a("span",{staticClass:"line-number"},[t._v("3")]),a("br"),a("span",{staticClass:"line-number"},[t._v("4")]),a("br"),a("span",{staticClass:"line-number"},[t._v("5")]),a("br"),a("span",{staticClass:"line-number"},[t._v("6")]),a("br"),a("span",{staticClass:"line-number"},[t._v("7")]),a("br"),a("span",{staticClass:"line-number"},[t._v("8")]),a("br"),a("span",{staticClass:"line-number"},[t._v("9")]),a("br"),a("span",{staticClass:"line-number"},[t._v("10")]),a("br"),a("span",{staticClass:"line-number"},[t._v("11")]),a("br"),a("span",{staticClass:"line-number"},[t._v("12")]),a("br"),a("span",{staticClass:"line-number"},[t._v("13")]),a("br"),a("span",{staticClass:"line-number"},[t._v("14")]),a("br")])]),a("p",[t._v("串行预处理器实现了让HTTP任务排队串行处理的功能，但值得一提的是：它并没有因此而阻塞任何线程！")]),t._v(" "),a("h2",{attrs:{id:"全局回调监听"}},[a("a",{staticClass:"header-anchor",attrs:{href:"#全局回调监听"}},[t._v("#")]),t._v(" 全局回调监听")]),t._v(" "),a("p",[t._v("全局回调是实际开发中经常需要的功能，比如对服务器响应的状态码进行统一处理等，同时 OkHttps 的全局回调还具有 "),a("strong",[t._v("回调阻断")]),t._v(" 的功能：")]),t._v(" "),a("div",{staticClass:"language-java line-numbers-mode"},[a("pre",{pre:!0,attrs:{class:"language-java"}},[a("code",[a("span",{pre:!0,attrs:{class:"token class-name"}},[t._v("HTTP")]),t._v(" http "),a("span",{pre:!0,attrs:{class:"token operator"}},[t._v("=")]),t._v(" HTTP"),a("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v(".")]),a("span",{pre:!0,attrs:{class:"token function"}},[t._v("builder")]),a("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v("(")]),a("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v(")")]),t._v("\n "),a("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v(".")]),a("span",{pre:!0,attrs:{class:"token function"}},[t._v("responseListener")]),a("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v("(")]),a("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v("(")]),a("span",{pre:!0,attrs:{class:"token class-name"}},[t._v("HttpTask")]),a("span",{pre:!0,attrs:{class:"token generics"}},[a("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v("<")]),a("span",{pre:!0,attrs:{class:"token operator"}},[t._v("?")]),a("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v(">")])]),t._v(" task"),a("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v(",")]),t._v(" "),a("span",{pre:!0,attrs:{class:"token class-name"}},[t._v("HttpResult")]),t._v(" result"),a("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v(")")]),t._v(" "),a("span",{pre:!0,attrs:{class:"token operator"}},[t._v("->")]),t._v(" "),a("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v("{")]),t._v("\n "),a("span",{pre:!0,attrs:{class:"token comment"}},[t._v("// 所有请求响应后都会走这里")]),t._v("\n\n "),a("span",{pre:!0,attrs:{class:"token keyword"}},[t._v("return")]),t._v(" "),a("span",{pre:!0,attrs:{class:"token boolean"}},[t._v("true")]),a("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v(";")]),t._v(" "),a("span",{pre:!0,attrs:{class:"token comment"}},[t._v("// 返回 true 表示继续执行 task 的 OnResponse 回调，false 表示不再执行")]),t._v("\n "),a("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v("}")]),a("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v(")")]),t._v("\n "),a("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v(".")]),a("span",{pre:!0,attrs:{class:"token function"}},[t._v("completeListener")]),a("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v("(")]),a("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v("(")]),a("span",{pre:!0,attrs:{class:"token class-name"}},[t._v("HttpTask")]),a("span",{pre:!0,attrs:{class:"token generics"}},[a("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v("<")]),a("span",{pre:!0,attrs:{class:"token operator"}},[t._v("?")]),a("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v(">")])]),t._v(" task"),a("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v(",")]),t._v(" "),a("span",{pre:!0,attrs:{class:"token class-name"}},[t._v("State")]),t._v(" state"),a("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v(")")]),t._v(" "),a("span",{pre:!0,attrs:{class:"token operator"}},[t._v("->")]),t._v(" "),a("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v("{")]),t._v("\n "),a("span",{pre:!0,attrs:{class:"token comment"}},[t._v("// 所有请求执行完都会走这里")]),t._v("\n\n "),a("span",{pre:!0,attrs:{class:"token keyword"}},[t._v("return")]),t._v(" "),a("span",{pre:!0,attrs:{class:"token boolean"}},[t._v("true")]),a("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v(";")]),t._v(" "),a("span",{pre:!0,attrs:{class:"token comment"}},[t._v("// 返回 true 表示继续执行 task 的 OnComplete 回调，false 表示不再执行")]),t._v("\n "),a("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v("}")]),a("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v(")")]),t._v("\n "),a("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v(".")]),a("span",{pre:!0,attrs:{class:"token function"}},[t._v("exceptionListener")]),a("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v("(")]),a("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v("(")]),a("span",{pre:!0,attrs:{class:"token class-name"}},[t._v("HttpTask")]),a("span",{pre:!0,attrs:{class:"token generics"}},[a("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v("<")]),a("span",{pre:!0,attrs:{class:"token operator"}},[t._v("?")]),a("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v(">")])]),t._v(" task"),a("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v(",")]),t._v(" "),a("span",{pre:!0,attrs:{class:"token class-name"}},[t._v("IOException")]),t._v(" error"),a("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v(")")]),t._v(" "),a("span",{pre:!0,attrs:{class:"token operator"}},[t._v("->")]),t._v(" "),a("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v("{")]),t._v("\n "),a("span",{pre:!0,attrs:{class:"token comment"}},[t._v("// 所有请求发生异常都会走这里")]),t._v("\n\n "),a("span",{pre:!0,attrs:{class:"token keyword"}},[t._v("return")]),t._v(" "),a("span",{pre:!0,attrs:{class:"token boolean"}},[t._v("true")]),a("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v(";")]),t._v(" "),a("span",{pre:!0,attrs:{class:"token comment"}},[t._v("// 返回 true 表示继续执行 task 的 OnException 回调，false 表示不再执行")]),t._v("\n "),a("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v("}")]),a("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v(")")]),t._v("\n "),a("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v(".")]),a("span",{pre:!0,attrs:{class:"token function"}},[t._v("build")]),a("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v("(")]),a("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v(")")]),a("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v(";")]),t._v("\n")])]),t._v(" "),a("div",{staticClass:"line-numbers-wrapper"},[a("span",{staticClass:"line-number"},[t._v("1")]),a("br"),a("span",{staticClass:"line-number"},[t._v("2")]),a("br"),a("span",{staticClass:"line-number"},[t._v("3")]),a("br"),a("span",{staticClass:"line-number"},[t._v("4")]),a("br"),a("span",{staticClass:"line-number"},[t._v("5")]),a("br"),a("span",{staticClass:"line-number"},[t._v("6")]),a("br"),a("span",{staticClass:"line-number"},[t._v("7")]),a("br"),a("span",{staticClass:"line-number"},[t._v("8")]),a("br"),a("span",{staticClass:"line-number"},[t._v("9")]),a("br"),a("span",{staticClass:"line-number"},[t._v("10")]),a("br"),a("span",{staticClass:"line-number"},[t._v("11")]),a("br"),a("span",{staticClass:"line-number"},[t._v("12")]),a("br"),a("span",{staticClass:"line-number"},[t._v("13")]),a("br"),a("span",{staticClass:"line-number"},[t._v("14")]),a("br"),a("span",{staticClass:"line-number"},[t._v("15")]),a("br"),a("span",{staticClass:"line-number"},[t._v("16")]),a("br"),a("span",{staticClass:"line-number"},[t._v("17")]),a("br")])]),a("div",{staticClass:"custom-block tip"},[a("p",{staticClass:"custom-block-title"},[t._v("全局回调监听与拦截器的异同：")]),t._v(" "),a("ul",[a("li",[t._v("拦截器可以添加多个，全局回调监听分三种，每种最多添加一个")]),t._v(" "),a("li",[t._v("拦截器处的理时机在请求前和响应后，全局回调监听只在响应后，并且晚于拦截器")]),t._v(" "),a("li",[t._v("全局回调监听可以 "),a("strong",[t._v("阻断")]),t._v("（return false）某个请求的具体回调，而拦截器不能")])])]),t._v(" "),a("h2",{attrs:{id:"全局下载监听"}},[a("a",{staticClass:"header-anchor",attrs:{href:"#全局下载监听"}},[t._v("#")]),t._v(" 全局下载监听")]),t._v(" "),a("div",{staticClass:"language-java line-numbers-mode"},[a("pre",{pre:!0,attrs:{class:"language-java"}},[a("code",[a("span",{pre:!0,attrs:{class:"token class-name"}},[t._v("HTTP")]),t._v(" http "),a("span",{pre:!0,attrs:{class:"token operator"}},[t._v("=")]),t._v(" HTTP"),a("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v(".")]),a("span",{pre:!0,attrs:{class:"token function"}},[t._v("builder")]),a("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v("(")]),a("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v(")")]),t._v("\n "),a("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v(".")]),a("span",{pre:!0,attrs:{class:"token function"}},[t._v("downloadListener")]),a("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v("(")]),a("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v("(")]),a("span",{pre:!0,attrs:{class:"token class-name"}},[t._v("HttpTask")]),a("span",{pre:!0,attrs:{class:"token generics"}},[a("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v("<")]),a("span",{pre:!0,attrs:{class:"token operator"}},[t._v("?")]),a("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v(">")])]),t._v(" task"),a("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v(",")]),t._v(" "),a("span",{pre:!0,attrs:{class:"token class-name"}},[t._v("Download")]),t._v(" download"),a("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v(")")]),t._v(" "),a("span",{pre:!0,attrs:{class:"token operator"}},[t._v("->")]),t._v(" "),a("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v("{")]),t._v("\n "),a("span",{pre:!0,attrs:{class:"token comment"}},[t._v("// 所有下载在开始之前都会先走这里")]),t._v("\n "),a("span",{pre:!0,attrs:{class:"token class-name"}},[t._v("Ctrl")]),t._v(" ctrl "),a("span",{pre:!0,attrs:{class:"token operator"}},[t._v("=")]),t._v(" download"),a("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v(".")]),a("span",{pre:!0,attrs:{class:"token function"}},[t._v("getCtrl")]),a("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v("(")]),a("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v(")")]),a("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v(";")]),t._v(" "),a("span",{pre:!0,attrs:{class:"token comment"}},[t._v("// 下载控制器")]),t._v("\n \n "),a("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v("}")]),a("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v(")")]),t._v("\n "),a("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v(".")]),a("span",{pre:!0,attrs:{class:"token function"}},[t._v("build")]),a("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v("(")]),a("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v(")")]),a("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v(";")]),t._v("\n")])]),t._v(" "),a("div",{staticClass:"line-numbers-wrapper"},[a("span",{staticClass:"line-number"},[t._v("1")]),a("br"),a("span",{staticClass:"line-number"},[t._v("2")]),a("br"),a("span",{staticClass:"line-number"},[t._v("3")]),a("br"),a("span",{staticClass:"line-number"},[t._v("4")]),a("br"),a("span",{staticClass:"line-number"},[t._v("5")]),a("br"),a("span",{staticClass:"line-number"},[t._v("6")]),a("br"),a("span",{staticClass:"line-number"},[t._v("7")]),a("br")])])])}),[],!1,null,null,null);s.default=e.exports}}]); \ No newline at end of file diff --git a/okhttps-doc/docs/.vuepress/dist/assets/js/app.1e2fa6f5.js b/okhttps-doc/docs/.vuepress/dist/assets/js/app.1e2fa6f5.js new file mode 100644 index 00000000..4a930851 --- /dev/null +++ b/okhttps-doc/docs/.vuepress/dist/assets/js/app.1e2fa6f5.js @@ -0,0 +1,13 @@ +(window.webpackJsonp=window.webpackJsonp||[]).push([[0],[]]);!function(t){function e(e){for(var r,a,c=e[0],u=e[1],s=e[2],l=0,p=[];l0?o(r(t),9007199254740991):0}},function(t,e,n){var r=n(6),o=n(1),i=n(4),a=Object.defineProperty,c={},u=function(t){throw t};t.exports=function(t,e){if(i(c,t))return c[t];e||(e={});var n=[][t],s=!!i(e,"ACCESSORS")&&e.ACCESSORS,f=i(e,0)?e[0]:u,l=i(e,1)?e[1]:void 0;return c[t]=!!n&&!o((function(){if(s&&!r)return!0;var t={length:-1};s?a(t,1,{enumerable:!0,get:u}):t[1]=1,n.call(t,f,l)}))}},function(t,e,n){var r=n(13);t.exports=function(t){return Object(r(t))}},function(t,e,n){var r=n(67),o=n(21),i=n(160);r||o(Object.prototype,"toString",i,{unsafe:!0})},function(t,e,n){var r=n(193),o=n(196);t.exports=function(t,e){var n=o(t,e);return r(n)?n:void 0}},function(t,e,n){"use strict";function r(t,e,n,r,o,i,a,c){var u,s="function"==typeof t?t.options:t;if(e&&(s.render=e,s.staticRenderFns=n,s._compiled=!0),r&&(s.functional=!0),i&&(s._scopeId="data-v-"+i),a?(u=function(t){(t=t||this.$vnode&&this.$vnode.ssrContext||this.parent&&this.parent.$vnode&&this.parent.$vnode.ssrContext)||"undefined"==typeof __VUE_SSR_CONTEXT__||(t=__VUE_SSR_CONTEXT__),o&&o.call(this,t),t&&t._registeredComponents&&t._registeredComponents.add(a)},s._ssrRegister=u):o&&(u=c?function(){o.call(this,this.$root.$options.shadowRoot)}:o),u)if(s.functional){s._injectStyles=u;var f=s.render;s.render=function(t,e){return u.call(e),f(t,e)}}else{var l=s.beforeCreate;s.beforeCreate=l?[].concat(l,u):[u]}return{exports:t,options:s}}n.d(e,"a",(function(){return r}))},function(t,e,n){"use strict";var r=n(0),o=n(27).filter,i=n(45),a=n(15),c=i("filter"),u=a("filter");r({target:"Array",proto:!0,forced:!c||!u},{filter:function(t){return o(this,t,arguments.length>1?arguments[1]:void 0)}})},function(t,e,n){var r=n(3),o=n(9),i=n(4),a=n(59),c=n(96),u=n(37),s=u.get,f=u.enforce,l=String(String).split("String");(t.exports=function(t,e,n,c){var u=!!c&&!!c.unsafe,s=!!c&&!!c.enumerable,p=!!c&&!!c.noTargetGet;"function"==typeof n&&("string"!=typeof e||i(n,"name")||o(n,"name",e),f(n).source=l.join("string"==typeof e?e:"")),t!==r?(u?!p&&t[e]&&(s=!0):delete t[e],s?t[e]=n:o(t,e,n)):s?t[e]=n:a(e,n)})(Function.prototype,"toString",(function(){return"function"==typeof this&&s(this).source||c(this)}))},function(t,e,n){var r=n(6),o=n(93),i=n(29),a=n(11),c=n(30),u=n(4),s=n(94),f=Object.getOwnPropertyDescriptor;e.f=r?f:function(t,e){if(t=a(t),e=c(e,!0),s)try{return f(t,e)}catch(t){}if(u(t,e))return i(!o.f.call(t,e),t[e])}},function(t,e){t.exports=function(t){return null!=t&&"object"==typeof t}},function(t,e){var n={}.toString;t.exports=function(t){return n.call(t).slice(8,-1)}},function(t,e,n){"use strict";var r=n(0),o=n(46);r({target:"RegExp",proto:!0,forced:/./.exec!==o},{exec:o})},function(t,e){t.exports=!1},function(t,e,n){var r=n(158),o=n(41),i=n(16),a=n(14),c=n(104),u=[].push,s=function(t){var e=1==t,n=2==t,s=3==t,f=4==t,l=6==t,p=5==t||l;return function(d,h,v,y){for(var m,g,b=i(d),_=o(b),x=r(h,v,3),w=a(_.length),O=0,S=y||c,j=e?S(d,w):n?S(d,0):void 0;w>O;O++)if((p||O in _)&&(g=x(m=_[O],O,b),t))if(e)j[O]=g;else if(g)switch(t){case 3:return!0;case 5:return m;case 6:return O;case 2:u.call(j,m)}else if(f)return!1;return l?-1:s||f?f:j}};t.exports={forEach:s(0),map:s(1),filter:s(2),some:s(3),every:s(4),find:s(5),findIndex:s(6)}},function(t,e,n){var r=n(34),o=n(178),i=n(179),a=r?r.toStringTag:void 0;t.exports=function(t){return null==t?void 0===t?"[object Undefined]":"[object Null]":a&&a in Object(t)?o(t):i(t)}},function(t,e){t.exports=function(t,e){return{enumerable:!(1&t),configurable:!(2&t),writable:!(4&t),value:e}}},function(t,e,n){var r=n(5);t.exports=function(t,e){if(!r(t))return t;var n,o;if(e&&"function"==typeof(n=t.toString)&&!r(o=n.call(t)))return o;if("function"==typeof(n=t.valueOf)&&!r(o=n.call(t)))return o;if(!e&&"function"==typeof(n=t.toString)&&!r(o=n.call(t)))return o;throw TypeError("Can't convert object to primitive value")}},function(t,e){t.exports={}},function(t,e,n){var r,o=n(8),i=n(163),a=n(62),c=n(31),u=n(164),s=n(95),f=n(42),l=f("IE_PROTO"),p=function(){},d=function(t){return" + + diff --git a/okhttps-doc/docs/.vuepress/dist/guide/configuration.html b/okhttps-doc/docs/.vuepress/dist/guide/configuration.html new file mode 100644 index 00000000..0564067a --- /dev/null +++ b/okhttps-doc/docs/.vuepress/dist/guide/configuration.html @@ -0,0 +1,137 @@ + + + + + + 配置 | OkHttps + + + + + + + + + + + + + + + + + + +
OkHttps

# 配置

# 设置 BaseUrl

HTTP http = HTTP.builder()
+        .baseUrl("http://api.demo.com")    // 设置 BaseUrl
+        .build();
+
1
2
3

该配置全局生效，在配置了BaseUrl之后，具体的请求便可以省略BaseUrl部分，使得代码更加简洁，例如：

http.sync("/users").get()                  // http://api.demo.com/users
+
+http.sync("/auth/signin")                  // http://api.demo.com/auth/signin
+        .addBodyParam("username", "Jackson")
+        .addBodyParam("password", "xxxxxx")
+        .post();                           // POST请求
+
1
2
3
4
5
6

在配置了BaseUrl之后，如有特殊请求任务，仍然可以使用全路径的方式，一点都不妨碍：

http.sync("https://www.baidu.com").get();
+
1

# 回调执行器

OkHttps 默认所有回调都在 IO线程 执行，如何想改变执行回调的线程时，可以配置回调执行器。例如在Android里，让所有的回调函数都在UI线程执行，则可以在构建HTTP时配置如下：

HTTP http = HTTP.builder()
+        .callbackExecutor((Runnable run) -> {
+            runOnUiThread(run);            // 在UI线程执行
+        })
+        .build();
+
1
2
3
4
5

该配置默认 影响所有回调。

# 配置 OkHttpClient

与其他封装 OkHttp3 的框架不同，OkHttps 并不会遮蔽 OkHttp3 本身就很好用的功能，如下：

HTTP http = HTTP.builder()
+    .config((Builder builder) -> {
+        // 配置连接池 最小10个连接（不配置默认为 5）
+        builder.connectionPool(new ConnectionPool(10, 5, TimeUnit.MINUTES));
+        // 配置连接超时时间（默认10秒）
+        builder.connectTimeout(20, TimeUnit.SECONDS);
+        // 配置拦截器
+        builder.addInterceptor((Chain chain) -> {
+            Request request = chain.request();
+            // 必须同步返回，拦截器内无法执行异步操作
+            return chain.proceed(request);
+        });
+        // 其它配置: CookieJar、SSL、缓存、代理、事件监听...
+    })
+    .build();
+
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15

# 并行预处理器

预处理器（Preprocessor）可以让我们在请求发出之前对请求本身做一些改变，但与OkHttp的拦截器（Interceptor）不同：预处理器可以让我们 异步 处理这些问题。

例如，当我们想为请求任务自动添加Token头信息，而Token只能通过异步方法requestToken获取时，这时使用Interceptor就很难处理了，但可以使用预处理器轻松解决：

HTTP http = HTTP.builder()
+        .addPreprocessor((PreChain chain) -> {
+            HttpTask<?> task = chain.getTask();// 获得当前的HTTP任务
+            if (!task.isTagged("Auth")) {      // 根据标签判断该任务是否需要Token
+                chain.proceed();
+                return;
+            }
+            requestToken((String token) -> {   // 异步获取 Token
+                task.addHeader("Token", token);// 为任务添加头信息
+                chain.proceed();               // 继续当前的任务
+            });
+        })
+        .build();
+
1
2
3
4
5
6
7
8
9
10
11
12
13

和Interceptor一样，Preprocessor也可以添加多个。他们之间的区别如下:

拦截器与预处理器的区别

  • 拦截器只能处理同步操作，预处理器支持处理异步操作
  • 拦截器都是并行处理请求，预处理器支持串行处理（详见6.5章节）
  • 拦截器处理时机在请求前和响应后，预处理器只在请求前，并且先于拦截器执行。关于响应后，OkHttps还提供了全局回调监听（详见6.6章节）

# 串行预处理器（TOKEN问题最佳解决方案）

普通预处理器都是可并行处理的，然而有时我们希望某个预处理器同时只处理一个任务。比如 当Token过期时我们需要去刷新获取新Token，而刷新Token这个操作只能有一个任务去执行，因为如果n个任务同时执行的话，那么必有n-1个任务刚刷新得到的Token可能就立马失效了，而这是我们所不希望的。

为了解决这个问题，OkHttps 提供了串行预处理器，它可以让 HTTP 任务排好队，一个一个地进入预处理器：

HTTP http = HTTP.builder()
+        .addSerialPreprocessor((PreChain chain) -> {
+            HttpTask<?> task = chain.getTask();
+            if (!task.isTagged("Auth")) {
+                chain.proceed();
+                return;
+            }
+            // 检查过期，若需要则刷新Token
+            requestTokenAndRefreshIfExpired((String token) -> {
+                task.addHeader("Token", token);            
+                chain.proceed();               // 调用此方法前，不会有其它任务进入该处理器
+            });
+        })
+        .build();
+
1
2
3
4
5
6
7
8
9
10
11
12
13
14

串行预处理器实现了让HTTP任务排队串行处理的功能，但值得一提的是：它并没有因此而阻塞任何线程！

# 全局回调监听

全局回调是实际开发中经常需要的功能，比如对服务器响应的状态码进行统一处理等，同时 OkHttps 的全局回调还具有 回调阻断 的功能：

HTTP http = HTTP.builder()
+        .responseListener((HttpTask<?> task, HttpResult result) -> {
+            // 所有请求响应后都会走这里
+
+            return true; // 返回 true 表示继续执行 task 的 OnResponse 回调，false 表示不再执行
+        })
+        .completeListener((HttpTask<?> task, State state) -> {
+            // 所有请求执行完都会走这里
+
+            return true; // 返回 true 表示继续执行 task 的 OnComplete 回调，false 表示不再执行
+        })
+        .exceptionListener((HttpTask<?> task, IOException error) -> {
+            // 所有请求发生异常都会走这里
+
+            return true; // 返回 true 表示继续执行 task 的 OnException 回调，false 表示不再执行
+        })
+        .build();
+
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17

全局回调监听与拦截器的异同：

  • 拦截器可以添加多个，全局回调监听分三种，每种最多添加一个
  • 拦截器处的理时机在请求前和响应后，全局回调监听只在响应后，并且晚于拦截器
  • 全局回调监听可以 阻断（return false）某个请求的具体回调，而拦截器不能

# 全局下载监听

HTTP http = HTTP.builder()
+        .downloadListener((HttpTask<?> task, Download download) -> {
+            // 所有下载在开始之前都会先走这里
+            Ctrl ctrl = download.getCtrl();         // 下载控制器
+            
+        })
+        .build();
+
1
2
3
4
5
6
7

+ ← + + 特色 + + → +

+ + + diff --git a/okhttps-doc/docs/.vuepress/dist/guide/features.html b/okhttps-doc/docs/.vuepress/dist/guide/features.html new file mode 100644 index 00000000..23771675 --- /dev/null +++ b/okhttps-doc/docs/.vuepress/dist/guide/features.html @@ -0,0 +1,150 @@ + + + + + + 特色 | OkHttps + + + + + + + + + + + + + + + + + + +
OkHttps

# 特色

# 使用 HttpUtils 类

类HttpUtils本是 前身 HttpUtils 的 1.x 版本里的最重要的核心类，由于在后来的版本里抽象出了HTTP接口，使得它的重要性已不如往昔。但合理的使用它，仍然可以带来不少便利，特别是在没有IOC容器的环境里，比如在Android开发和一些工具项目的开发中。

类HttpUtils共定义了四个静态方法：

  • of(HTTP http) 配置HttpUtils持有的HTTP实例（不调用此方法前默认使用一个没有没有经过任何配置的HTTP懒实例）
  • sync(String url) 开始一个同步请求 （内部通过一个HTTP单例实现）
  • async(String url) 开始一个异步请求 （内部通过一个HTTP单例实现）
  • cancel(String tag) 按标签取消请求（内部通过一个HTTP单例实现）
  • cancelAll() 取消所有HTTP任务，包括同步和异步（内部通过一个HTTP单例实现）
  • request(Request request) OkHttp 原生请求 （该请求不经过 预处理器）
  • webSocket(Request request, WebSocketListener listener) WebSocket通讯 +　　也就是说，能使用http实例的地方，都可以使用HttpUtils类，例如：
// 在配置HTTP实例之前，只能使用全路径方式
+List<Role> roles = HttpUtils.sync("http://api.demo.com/roles")
+        .get().getBody().toList(Role.class);
+
+// 配置HTTP实例,全局生效
+HttpUtils.of(HTTP.builder()
+        .baseUrl("http://api.demo.com")
+        .build());
+
+// 内部使用新的HTTP实例
+List<User> users = HttpUtils.sync("/users")
+        .get().getBody().toList(User.class);
+
1
2
3
4
5
6
7
8
9
10
11
12

# 异常处理

使用 OkHttps 时，异常处理不是必须的，但相比其它的 HTTP 开发包，它还提供一个特别的处理方法：nothrow()，以满足不同的异常处理需求。

# 同步请求的异常

默认情况下，当同步请求执行异常时，会直接向外抛出，我们可以用 try catch 来捕获，例如：

try {
+    HttpResult result = http.sync("/users/1").get();
+} catch (HttpException e) {
+    Throwable cause = e.getCause(); // 得到异常原因
+    if (cause instanceof ConnectException) {
+        // 当没网络时，会抛出连接异常
+    }
+    if (cause instanceof SocketTimeoutException) {
+        // 当接口长时间未响应，会抛出超时异常
+    }
+    if (cause instanceof UnknownHostException) {
+        // 当把域名或IP写错，会抛出 UnknownHost 异常
+    }
+    // ...
+}
+
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15

这种传统的异常处理方式，当然可以解决问题，但 OkHttps 有更佳的方案：

// 方法  nothrow() 让异常不直接抛出
+HttpResult result = http.sync("/users/1").nothrow().get();
+// 判断执行状态
+switch (result.getState()) {
+    case RESPONSED:     // 请求已正常响应
+        break;
+    case CANCELED:      // 请求已被取消
+        break;
+    case NETWORK_ERROR: // 网络错误，说明用户没网了
+        break;
+    case TIMEOUT:       // 请求超时
+        break;
+    case EXCEPTION:     // 其它异常
+        break;
+}
+// 还可以获得具体的异常信息
+IOException error = result.getError();
+
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17

# 异步请求的异常

异步请求最常用的异常处理方式就是设置一个异常回调：

http.async("/users/1")
+        .setOnResponse((HttpResult result) -> {
+            // 当发生异常时就不会走这里
+        })
+        .setOnException((IOException e) -> {
+            // 这里处理请求异常
+        })
+        .get();
+
1
2
3
4
5
6
7
8

当然，还有一个全局异常监听（ExceptionListener）：

HTTP http = HTTP.builder()
+        .exceptionListener((HttpTask<?> task, IOException error) -> {
+            // 所有请求发生异常都会走这里
+
+            return true; // 返回 true 表示继续执行 task 的 OnException 回调，false 表示不再执行
+        })
+        .build();
+
1
2
3
4
5
6
7

如果不设置OnException回调，也没有ExceptionListener，发生异常时会在 IO 线程 中向上抛出，外层无法捕获：

try {
+    http.async("/users/1")
+            .setOnResponse((HttpResult result) -> {
+                // 当发生异常时就不会走这里
+            })
+            .get();
+} catch (HttpException e) {
+    // 这种方式是捕获不到异常的！！！！！！
+}
+
1
2
3
4
5
6
7
8
9

即使没有OnException回调，发生异常时，依然会走OnComplete回调，如果设置了的话：

http.async("/users/1")
+        .setOnResponse((HttpResult result) -> {
+            // 当发生异常时就不会走这里
+        })
+        .setOnComplete((State state) -> {
+            // 发生异常，会先执行这里，可以根据 state 判断发生了什么
+            // 但执行完后依然会在IO线程中向上抛出
+        })
+        .get();
+
1
2
3
4
5
6
7
8
9

如果就是想 不处理异常，也不向上抛出，发生错误完全无视，可以做到吗？可以！还是使用nothrow()方法：

http.async("/users/1")
+        .nothrow()  // 告诉 OkHttps 发生异常时不向外抛出
+        .setOnResponse((HttpResult result) -> {
+            // 当发生异常时就不会走这里
+        })
+        .get();
+
1
2
3
4
5
6

# 取消请求

在 OkHttps 里取消请求共有 4 种 方式可选：

  • 使用HttpCall#cancel()取消单个请求（适用于异步请求，详见 3.3 章节）
  • 使用HttpTask#cancel()取消单个请求（适用于所有请求）（since v1.0.4）
HttpTask<?> task = http.async("/users")
+        .setOnResponse((HttpResult result) -> {
+            // 响应回调
+        });
+
+task.get(); // 发起 GET 请求
+
+// 取消请求，并返回是否取消成功
+boolean canceled = task.cancel();   
+
1
2
3
4
5
6
7
8
9
  • 使用HTTP#cancel(String tag)按标签批量取消请求（适用于所有请求，详见第 5 章节）
  • 使用HTTP#cancelAll()取消所有请求（适用于所有请求）（since v1.0.2）
http.cancelAll();   // 取消所有请求
+
1

+ ← + + 上传下载 + + → +

+ + + diff --git a/okhttps-doc/docs/.vuepress/dist/guide/foundation.html b/okhttps-doc/docs/.vuepress/dist/guide/foundation.html new file mode 100644 index 00000000..54bfdf7b --- /dev/null +++ b/okhttps-doc/docs/.vuepress/dist/guide/foundation.html @@ -0,0 +1,130 @@ + + + + + + 基础 | OkHttps + + + + + + + + + + + + + + + + + + +
OkHttps

# 基础

# 请求方法

同步与异步的HttpTask都拥有get、post、put与delete方法。不同的是：同步HttpTask的这些方法返回一个HttpResult，而异步HttpTask的这些方法返回一个HttpCall。

HttpResult res1 = http.sync("/users").get();     // 同步 GET
+HttpResult res2 = http.sync("/users").post();    // 同步 POST
+HttpResult res3 = http.sync("/users/1").put();   // 同步 PUT
+HttpResult res4 = http.sync("/users/1").delete();// 同步 DELETE
+HttpCall call1 = http.async("/users").get();     // 异步 GET
+HttpCall call2 = http.async("/users").post();    // 异步 POST
+HttpCall call3 = http.async("/users/1").put();   // 异步 PUT
+HttpCall call4 = http.async("/users/1").delete();// 异步 DELETE
+
1
2
3
4
5
6
7
8

# 回调函数

OkHttps 的回调函数全部使用单方法模式，这样可以充分利用 Java8 或 Kotlin 中的 Lambda 表达式，使你的代码更加简洁优雅：

http.async("/users/{id}")             // http://api.demo.com/users/1
+        .addPathParam("id", 1)
+        .setOnResponse((HttpResult result) -> {
+            // 响应回调
+        })
+        .setOnException((IOException e) -> {
+            // 异常回调
+        })
+        .setOnComplete((State state) -> {
+            // 完成回调，无论成功失败都会执行
+            // 并且在 响应|异常回调 之前执行
+        })
+        .get();
+
1
2
3
4
5
6
7
8
9
10
11
12
13

OkHttps 同时还支持 全局回调 和 回调阻断 机制，详见 全局回调监听。

TIP

  • 只有异步请求才可以设置这三种（响应|异常|完成）回调
  • 同步请求直接返回结果，无需使用回调

# HttpResult

HttpResult是HTTP请求执行完后的结果，它是同步请求方法（ get、post、put、delete）的返回值，也是异步请求响应回调（OnResponse）的参数，它定义了如下方法：

  • getState() 得到请求执行状态枚举，它有以下取值： +
    • State.CANCELED 请求被取消
    • State.RESPONSED 已收到响应
    • State.TIMEOUT 请求超时
    • State.NETWORK_ERROR 网络错误
    • State.EXCEPTION 其它请求异常
  • getStatus() 得到HTTP状态码
  • isSuccessful() 是否响应成功，状态码在 [200..300) 之间
  • getHeaders() 得到HTTP响应头
  • getHeaders(String name) 得到HTTP响应头
  • getHeader(String name) 得到HTTP响应头
  • getBody() 得到响应报文体Body实例，它定义了如下方法（对同一个Body实例，以下的toXXX()类方法只能使用一个且仅能调用一次，除非先使用 cache 方法）： +
    • toBytes() 返回字节数组
    • toByteStream() 返回字节输入流
    • toCharStream() 返回字符输入流
    • toString() 返回字符串
    • toJsonObject() 返回Json对象
    • toJsonArray() 返回Json数组
    • toBean(Class<T> type) 返回根据type自动json解析后的JavaBean
    • toList(Class<T> type) 返回根据type自动json解析后的JavaBean列表
    • toFile(String filePath) 下载到指定路径
    • toFile(File file) 下载到指定文件
    • toFolder(String dirPath) 下载到指定目录
    • toFolder(File dir) 下载到指定目录
    • getContentType() 返回报文体的媒体类型
    • getContentLength() 返回报文体的字节长度
    • cache() 缓存报文体，开启缓存后可重复使用toXXX()类方法
    • close() 关闭报文体，未对报文体做任何消费时使用，比如只读取报文头
  • getError() 执行中发生的异常，自动捕获执行请求时发生的 网络超时、网络错误 和 其它IO异常
  • close() 关闭报文，未对报文体做任何消费时使用，比如只读取长度

示例，请求结果自动转Bean和List：

// 自动转Bean
+Order order = http.sync("/orders/1")
+        .get().getBody().toBean(Order.class);
+        
+// 自动转List
+List<Order> orders = http.sync("/orders")
+        .get().getBody().toList(Order.class);
+
1
2
3
4
5
6
7

示例，使用 cache 方法：

Body body = http.sync("/orders").get().getBody().cache();
+
+// 使用 cache 后，可以多次使用 toXXX() 方法
+System.out.println(body.toString());
+System.out.println(body.toJsonArray());
+System.out.println(body.toList(Order.class));
+
1
2
3
4
5
6

示例，获取下载文件的大小：

long size = http.sync("/download/test.zip")
+            .get().getBody()
+            .close()             // 只是想获得文件大小，不消费报文体，所以直接关闭
+            .getContentLength(); // 获得待下载文件的大小
+
+// 由于未消费报文体，所以本次请求不会消耗下载报文体的时间和网络流量
+
+System.out.println("size = " + size);
+
1
2
3
4
5
6
7
8

# HttpCall

HttpCall对象是异步请求方法（get、post、put、delete）的返回值，与java的Future接口很像，它有如下方法：

  • cancel() 取消本次请求，返回取消结果
  • isCanceled() 返回请求是否被取消
  • isDone() 返回是否执行完成，包含取消和失败
  • getResult() 返回执行结果HttpResult对象，若请求未执行完，则挂起当前线程直到执行完成再返回

取消一个异步请求示例：

HttpCall call = http.async("/users/1").get();
+
+System.out.println(call.isCanceled());     // false
+
+boolean success = call.cancel();           // 取消请求
+
+System.out.println(success);               // true
+System.out.println(call.isCanceled());     // true
+
1
2
3
4
5
6
7
8

# 构建HTTP任务

HTTP对象的sync与async方法返回一个HttpTask对象，该对象提供了可链式调用的addXXX与setXXX等系列方法用于构建任务本身。

  • addHeader(String name, String value) 添加请求头

  • addHeader(Map<String, String> headers) 添加请求头

  • addPathParam(String name, Object value) 添加路径参数：替换URL里的{name}占位符

  • addPathParam(Map<String, ?> params) 添加路径参数：替换URL里的{name}占位符

  • addUrlParam(String name, Object value) 添加URL参数：拼接在URL的?之后（查询参数）

  • addUrlParam(Map<String, ?> params) 添加URL参数：拼接在URL的?之后（查询参数）

  • addBodyParam(String name, Object value) 添加Body参数：以表单key=value&的形式放在报文体内（表单参数）

  • addBodyParam(Map<String, ?> params) 添加Body参数：以表单key=value&的形式放在报文体内（表单参数）

  • addJsonParam(String name, Object value) 添加Json参数：请求体为Json（支持多层结构）

  • addJsonParam(Map<String, ?> params) 添加Json参数：请求体为Json（支持多层结构）

  • setRequestJson(Object json) 设置请求体的Json字符串 或待转换为 Json的 JavaBean

  • setRequestJson(Object bean, String dateFormat) 设置请求体的Json字符串 或待转换为 Json的 JavaBean

  • addFileParam(String name, String filePath) 上传文件

  • addFileParam(String name, File file) 上传文件

  • addFileParam(String name, String type, InputStream inputStream) 上传文件

  • addFileParam(String name, String type, String fileName, InputStream input) 上传文件

  • addFileParam(String name, String type, byte[] content) 上传文件

  • addFileParam(String name, String type, String fileName, byte[] content) 上传文件

  • setTag(String tag) 为HTTP任务添加标签

  • setRange(long rangeStart) 设置Range头信息，用于断点续传

  • setRange(long rangeStart, long rangeEnd) 设置Range头信息，可用于分块下载

  • bind(Object object) 绑定一个对象，可用于实现Android里的生命周期绑定

# 使用标签

有时候我们想对HTTP任务加以分类，这时候可以使用标签功能：

http.async("/users")    //（1）
+        .setTag("A")
+        .get();
+        
+http.async("/users")    //（2）
+        .setTag("A.B")
+        .get();
+        
+http.async("/users")    //（3）
+        .setTag("B")
+        .get();
+        
+http.async("/users")    //（4）
+        .setTag("B")
+        .setTag("C")    // 从 v1.0.4 标签将以追加模式添加，等效于 setTag("B.C")
+        .get();
+        
+http.async("/users")    //（5）
+        .setTag("C")
+        .get();
+
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20

当使用标签后，就可以按标签批量的对HTTP任务进行取消：

int count = http.cancel("B");              //（2）（3）（4）被取消（取消标签包含"B"的任务）
+System.out.println(count);                 // 输出 3
+
1
2

标签除了可以用来取消任务，在预处理器中它也可以发挥作用，请参见 并行预处理器 与 串行预处理器（token问题最佳解决方案）。

+ ← + + 配置 + + → +

+ + + diff --git a/okhttps-doc/docs/.vuepress/dist/guide/index.html b/okhttps-doc/docs/.vuepress/dist/guide/index.html new file mode 100644 index 00000000..9b6c66b0 --- /dev/null +++ b/okhttps-doc/docs/.vuepress/dist/guide/index.html @@ -0,0 +1,79 @@ + + + + + + 起步 | OkHttps + + + + + + + + + + + + + + + + + + +
OkHttps

# 起步

OkHttps 是近期开源的对 OkHttp3 轻量封装的框架，它独创的异步预处理器，特色的标签，灵活的上传下载进度监听与过程控制功能，在轻松解决很多原本另人头疼问题的同时，设计上也力求纯粹与优雅。

  • 链式调用，一点到底
  • BaseURL、URL占位符、JSON自动封装与解析
  • 同步拦截器、异步预处理器、回调执行器、全局监听、回调阻断
  • 文件上传下载（过程控制、进度监听）
  • 单方法回调，充分利用 Lambda 表达式
  • TCP连接池、Http2

TIP

  • OkHttps 非常轻量（59Kb），仅是 Retrofit（124Kb）的一半，并且更加的开箱即用，API 也更加自然和语义化。
  • OkHttps 是一个纯粹的 Java 网络开发包，并不依赖 Android，这一点和 Retrofit 不同
  • OkHttps 用起来很优美，可以像 RxJava 那样链式用，却比 RxJava 更简单。

# 安装

# Maven

<dependency>
+     <groupId>com.ejlchina</groupId>
+     <artifactId>okhttps</artifactId>
+     <version>1.0.5</version>
+</dependency>
+
1
2
3
4
5

# Gradle

implementation 'com.ejlchina:okhttps:1.0.5'
+
1

安卓中使用需要把 JDK 版本调成 1.8，在 app 模块的 build.gradle 中加入以下配置即可：

android {
+    // 省略其它配置..
+    compileOptions {
+        sourceCompatibility = 1.8
+        targetCompatibility = 1.8
+    }
+}
+
1
2
3
4
5
6
7

# 使用

# 构建实例

HTTP http = HTTP.builder().build();
+
1

以上代码构建了一个最简单的HTTP实例，它拥有以下方法：

  • sync(String url) 开始一个同步请求
  • async(String url) 开始一个异步请求
  • cancel(String tag) 按标签取消请求
  • cancelAll() 取消所有HTTP任务，包括同步和异步
  • request(Request request) OkHttp 原生请求
  • webSocket(Request request, WebSocketListener listener) WebSocket通讯

为了使用方便，在构建的时候，我们更愿意指定一个BaseUrl（详见 设置 BaseUrl）:

HTTP http = HTTP.builder()
+        .baseUrl("http://api.demo.com")
+        .build();
+
1
2
3

为了简化文档，下文中出现的http均是在构建时设置了BaseUrl的HTTP实例。

# 同步请求

使用方法sync(String url)开始一个同步请求：

List<User> users = http.sync("/users") // http://api.demo.com/users
+        .get()                         // GET请求
+        .getBody()                     // 获取响应报文体
+        .toList(User.class);           // 得到目标数据
+
1
2
3
4

方法sync返回一个同步HttpTask，可链式使用。

# 异步请求

使用方法async(String url)开始一个异步请求：

http.async("/users/1")                //  http://api.demo.com/users/1
+        .setOnResponse((HttpResult result) -> {
+            // 得到目标数据
+            User user = result.getBody().toBean(User.class);
+        })
+        .get();                       // GET请求
+
1
2
3
4
5
6

方法async返回一个异步HttpTask，可链式使用。

至此，你已轻松学会了 OkHttps 95% 的常规用法！但别急，后面还有更精彩的。

+ 基础 + + → +

+ + + diff --git a/okhttps-doc/docs/.vuepress/dist/guide/updown.html b/okhttps-doc/docs/.vuepress/dist/guide/updown.html new file mode 100644 index 00000000..32ad8f39 --- /dev/null +++ b/okhttps-doc/docs/.vuepress/dist/guide/updown.html @@ -0,0 +1,195 @@ + + + + + + 上传下载 | OkHttps + + + + + + + + + + + + + + + + + + +
OkHttps

# 上传下载

# 文件下载

OkHttps 并没有把文件的下载排除在常规的请求之外，同一套API，它优雅的设计使得下载与常规请求融合的毫无违和感，一个最简单的示例：

http.sync("/download/test.zip")
+        .get()                           // 使用 GET 方法（其它方法也可以，看服务器支持）
+        .getBody()                       // 得到报文体
+        .toFile("D:/download/test.zip")  // 下载到指定的路径
+        .start();                        // 启动下载
+
+http.sync("/download/test.zip").get().getBody()                  
+        .toFolder("D:/download")         // 下载到指定的目录，文件名将根据下载信息自动生成
+        .start();
+
1
2
3
4
5
6
7
8
9

或使用异步连接方式：

http.async("/download/test.zip")
+        .setOnResponse((HttpResult result) -> {
+            result.getBody().toFolder("D:/download").start();
+        })
+        .get();
+
1
2
3
4
5

这里要说明一下：sync与async的区别在于连接服务器并得到响应这个过程的同步与异步（这个过程的耗时在大文件下载中占比极小），而start方法启动的下载过程则都是异步的。

# 下载进度监听

就直接上代码啦，诸君一看便懂：

http.sync("/download/test.zip")
+        .get()
+        .getBody()
+        .setStepBytes(1024)   // 设置每接收 1024 个字节执行一次进度回调（不设置默认为 8192）  
+ //     .setStepRate(0.01)    // 设置每接收 1% 执行一次进度回调（不设置以 StepBytes 为准）  
+        .setOnProcess((Process process) -> {           // 下载进度回调
+            long doneBytes = process.getDoneBytes();   // 已下载字节数
+            long totalBytes = process.getTotalBytes(); // 总共的字节数
+            double rate = process.getRate();           // 已下载的比例
+            boolean isDone = process.isDone();         // 是否下载完成
+        })
+        .toFolder("D:/download/")        // 指定下载的目录，文件名将根据下载信息自动生成
+ //     .toFile("D:/download/test.zip")  // 指定下载的路径，若文件已存在则覆盖
+        .setOnSuccess((File file) -> {   // 下载成功回调
+            
+        })
+        .start();
+
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17

值得一提的是：由于 OkHttps 并没有把下载做的很特别，这里设置的进度回调不只对下载文件起用作，即使对响应JSON的常规请求，只要设置了进度回调，它也会告诉你报文接收的进度（提前是服务器响应的报文有Content-Length头），例如：

List<User> users = http.sync("/users")
+        .get()
+        .getBody()
+        .setStepBytes(2)
+        .setOnProcess((Process process) -> {
+            System.out.println(process.getRate());
+        })
+        .toList(User.class);
+
1
2
3
4
5
6
7
8

# 下载过程控制

过于简单：还是直接上代码：

Ctrl ctrl = http.sync("/download/test.zip")
+        .get()
+        .getBody()
+        .setOnProcess((Process process) -> {
+            System.out.println(process.getRate());
+        })
+        .toFolder("D:/download/")
+        .start();   // 该方法返回一个下载过程控制器
+ 
+ctrl.status();      // 下载状态
+ctrl.pause();       // 暂停下载
+ctrl.resume();      // 恢复下载
+ctrl.cancel();      // 取消下载（同时会删除文件，不可恢复）
+
1
2
3
4
5
6
7
8
9
10
11
12
13

无论是同步还是异步发起的下载请求，都可以做以上的控制：

http.async("/download/test.zip")
+        .setOnResponse((HttpResult result) -> {
+            // 拿到下载控制器
+            Ctrl ctrl = result.getBody().toFolder("D:/download/").start();
+        })
+        .get();
+
1
2
3
4
5
6

# 实现断点续传

OkHttps 对断点续传并没有再做更高层次的封装，因为这是app该去做的事情，它在设计上使各种网络问题的处理变简单的同时力求纯粹。下面的例子可以看到，OkHttps 通过一个失败回调拿到 断点，便将复杂的问题变得简单：

http.sync("/download/test.zip")
+        .get()
+        .getBody()
+        .toFolder("D:/download/")
+        .setOnFailure((Failure failure) -> {         // 下载失败回调，以便接收诸如网络错误等失败信息
+            IOException e = failure.getException();  // 具体的异常信息
+            long doneBytes = failure.getDoneBytes(); // 已下载的字节数（断点），需要保存，用于断点续传
+            File file = failure.getFile();           // 下载生成的文件，需要保存 ，用于断点续传（只保存路径也可以）
+        })
+        .start();
+
1
2
3
4
5
6
7
8
9
10

下面代码实现续传：

long doneBytes = ...    // 拿到保存的断点
+File file =  ...        // 待续传的文件
+
+http.sync("/download/test.zip")
+        .setRange(doneBytes)                         // 设置断点（已下载的字节数）
+        .get()
+        .getBody()
+        .toFile(file)                                // 下载到同一个文件里
+        .setAppended()                               // 开启文件追加模式
+        .setOnSuccess((File file) -> {
+
+        })
+        .setOnFailure((Failure failure) -> {
+        
+        })
+        .start();
+
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16

# 实现分块下载

当文件很大时，有时候我们会考虑分块下载，与断点续传的思路是一样的，示例代码：

static String url = "http://api.demo.com/download/test.zip"
+
+public static void main(String[] args) {
+    long totalSize = HttpUtils.sync(url).get().getBody()
+            .close()             // 因为这次请求只是为了获得文件大小，不消费报文体，所以直接关闭
+            .getContentLength(); // 获得待下载文件的大小（由于未消费报文体，所以该请求不会消耗下载报文体的时间和网络流量）
+    download(totalSize, 0);      // 从第 0 块开始下载
+    sleep(50000);                // 等待下载完成（不然本例的主线程就结束啦）
+}
+
+static void download(long totalSize, int index) {
+    long size = 3 * 1024 * 1024;                 // 每块下载 3M  
+    long start = index * size;
+    long end = Math.min(start + size, totalSize);
+    HttpUtils.sync(url)
+            .setRange(start, end)                // 设置本次下载的范围
+            .get().getBody()
+            .toFile("D:/download/test.zip")      // 下载到同一个文件里
+            .setAppended()                       // 开启文件追加模式
+            .setOnSuccess((File file) -> {
+                if (end < totalSize) {           // 若未下载完，则继续下载下一块
+                    download(totalSize, index + 1); 
+                } else {
+                    System.out.println("下载完成");
+                }
+            })
+            .start();
+}
+
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

# 文件上传

一个简单文件上传的示例：

http.sync("/upload")
+        .addFileParam("test", "D:/download/test.zip")
+        .post();     // 上传发法一般使用 POST 或 PUT，看服务器支持
+
1
2
3

异步上传也是完全一样：

http.async("/upload")
+        .addFileParam("test", "D:/download/test.zip")
+        .post();
+
1
2
3

# 上传进度监听

OkHttps 的上传进度监听，监听的是所有请求报文体的发送进度，示例代码：

http.sync("/upload")
+        .addBodyParam("name", "Jack")
+        .addBodyParam("age", 20)
+        .addFileParam("avatar", "D:/image/avatar.jpg")
+        .setStepBytes(1024)   // 设置每发送 1024 个字节执行一次进度回调（不设置默认为 8192）  
+ //     .setStepRate(0.01)    // 设置每发送 1% 执行一次进度回调（不设置以 StepBytes 为准）  
+        .setOnProcess((Process process) -> {           // 上传进度回调
+            long doneBytes = process.getDoneBytes();   // 已发送字节数
+            long totalBytes = process.getTotalBytes(); // 总共的字节数
+            double rate = process.getRate();           // 已发送的比例
+            boolean isDone = process.isDone();         // 是否发送完成
+        })
+        .post();
+
1
2
3
4
5
6
7
8
9
10
11
12
13

咦！怎么感觉和下载的进度回调的一样？没错！OkHttps 还是使用同一套API处理上传和下载的进度回调，区别只在于上传是在get/post方法之前使用这些API，下载是在getBody方法之后使用。很好理解：get/post之前是准备发送请求时段，有上传的含义，而getBody之后，已是报文响应的时段，当然是下载。

# 上传过程控制

上传文件的过程控制就很简单，和常规请求一样，只有异步发起的上传可以取消：

HttpCall call = http.async("/upload")
+        .addFileParam("test", "D:/download/test.zip")
+        .setOnProcess((Process process) -> {
+            System.out.println(process.getRate());
+        })
+        .post();
+
+call.cancel();  // 取消上传
+
1
2
3
4
5
6
7
8

上传就没有暂停和继续这个功能啦，应该没人有这个需求吧?

+ ← + + 安卓 + + → +

+ + + diff --git a/okhttps-doc/docs/.vuepress/dist/index.html b/okhttps-doc/docs/.vuepress/dist/index.html new file mode 100644 index 00000000..3d0605ad --- /dev/null +++ b/okhttps-doc/docs/.vuepress/dist/index.html @@ -0,0 +1,72 @@ + + + + + + OkHttps + + + + + + + + + + + + + + + + +
OkHttps
hero

+ OkHttps +

+ 基于 OkHttp 增强版 HTTP 客户端 +

+ 极速上手 → +

轻量纯粹优雅

OkHttps 非常轻量，体积仅是 Retrofit 的一半不到，并且不依赖于特定平台，API 语义简洁舒适。

开箱即用的功能

异步预处理器、回调执行器、全局监听器、回调阻断机制、文件上传下载、过程控制、进度监听。

更多实用特性

URL 占位符、Lambda 回调、JSON自动封装解析、OkHttp 的特性：拦截器、连接池、CookieJar 等。

// 构建 HTTP
+HTTP http = HTTP.builder()
+        .baseUrl("https://api.demo.com")
+        .build();
+
+// 同步请求
+List<User> users = http.sync("/users")  // http://api.demo.com/users
+        .get()                          // GET请求
+        .getBody()                      // 获取响应报文体
+        .toList(User.class);            // 得到目标数据
+
+// 异步请求
+http.async("/users/jack")               //  http://api.demo.com/users/jack
+        .setOnResponse((HttpResult result) -> {
+            // 得到目标数据
+            User jack = result.getBody().toBean(User.class);
+        })
+        .get();                         // GET请求
+
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18

竟然不到 15 秒，你已学会 90% 的精髓！
了解更多

+ Apache Licensed | Copyright © 2020-present ejlchina +
+ + + diff --git a/docs/.vuepress/public/logo.png b/okhttps-doc/docs/.vuepress/dist/logo.png similarity index 100% rename from docs/.vuepress/public/logo.png rename to okhttps-doc/docs/.vuepress/dist/logo.png diff --git a/okhttps-doc/docs/.vuepress/public/logo.png b/okhttps-doc/docs/.vuepress/public/logo.png new file mode 100644 index 0000000000000000000000000000000000000000..3b3b2845420b470e4b091e3862ff98653c4b1cb0 GIT binary patch literal 5800 zcmX9?c|2768$RclVT^4s*_RpXRMuoG%P?dtA*m#L(n8lZmMhEHm&71ZWGfe4Wi5Ng zo~ww;5;4j}cES*5ese#+KhEcUKi~Izp69He_j%rATWd2Oq!=R5sxYDrp^2IMU_Bh0y>E*~O>!|ph0Kd1zw>qt@EFdT#`V|KkDr5H~Vx$ zx)qN}Ap!Ni=LJ%~4KJ^GhuGQh?bUZ0gP6bYt%j3+HhGK!?l=fvsUG{UYoE##$O+3L zcXJaDBgO*^4X}+3<@1HV`X40nk{wF!_t4kKDi{!MFP%L1P(CCI|9baxI_?ea=Cg%nKp+fbIeFs4TS`T<+@j9@WN^=z+q2S+UuVX zJ08S5nc@z=+e|L71(Fns;bfH}MHahx5{!0&1nRSZk5wOCfttxuth$gLL|cTK2_TWX zJy=EO-aO=tH^Tv(ESk4IyZSS_H|=cFbqDUos}!-J$@LBeU)J`r0{1d~(0R95-6|8PJ$uBxn)R!h`R!oGVeOt8Zk_3mb8P&Qx~Rsl$qY?5ZAR znd`p}FIl_Y?L7>yjD{#egzxhQ3HK8`fNlA7fprdau?sC9x7N+c=0Kh5hbjX-cSBk5zHwMB>BZEb<@Y z#2oE^)g|o!thYh_Z;NtWb_uo_kjDYZHRbcd(KoHQObKGM#7!0I1t3$N^xf+9EksGM zz?0D8jd%BiBi@wHzh0B1_YHj>Y?_S8X^cUb zTq`U5d{K4O=DM?QvY|!LDG|$HEbx7t?<{v@;!>kx#Y(ZOkz;*$>fvdxVN|z5unN_^ z7MEEG1A3I{iHB8-FNL@29d9r3-{^=)az0HG`5CAjSoYZouLY5F>IW*@lf8N^Wi(RH z{B|h5FO9jW?j%szc+R+*C`>Ws1-!>?Aclo6flubmOR+fP_uX!ZROPR~3 z>&xdOdw%#Y&a|+q|54hu?xvMe08=F)FO{0>0~y8X^3X&JSpr7wv^LPdf?nq5FZhgS z1Q7X6G53V=AR@7pg4rFJP!LN*w>lgzL3pl00TWzm;*DIkDT(**ymB-uZ)}JZlrbfM zTG2t+NqtCn6`pieaHjVxF|K05tP@;AnNIgZuXCSTVIvKyUVtiYTlKhpnuhs>ESA`%fNPm-I6&ic%!=cur zrJu^WpyGwoakaA%#V_8iIN{gscF?P>Zrz=~S6x0o?5faZP378&T(l-2G^Tm>&jzwE za-bhZt7erF%l||?uO^@^2^t($@Vz$^*f zO!9d7+0I9N0Tuo6&uD!s==x;pjaeu~kj&nNHQMlW5Ql_x(H`;kMAYCpJ*JWqz6PTC z3`No@)D-046&)>w6zin}1SY({gvc>mi1Yomph7dPCZi7H%pSkLSr8~mfJW({t+$c|! zwfYLT1unZ0tEFO%{e;EICSCD-`_S54$mr^ioaZY6tsYi<7McJh%w@_`fy6ez4qs+iXK0=H;rm!}>Ft77(PG9d`cPmaL6)z%?%Es&N zYmVB55_lBv-*LGe@#bL>kV^F<7JW?)<@Q64VYvVJIh3dWcER)d*0?Qj&ZBWP_xG%v zol>$%*HYBj@kR`nEdX^`cgvZE>V;xbLu9=4tVWGN1mgQzo?d?3bBF+7MFc45A^_o0 z-<9U5=;6Va0K{PAs)J>00<~O67pAlR_z0SipC%<=!U6oVvvS>H+@MSh&slEHB+*3x z?MB2`;z8TE#4OZZ5eQd{7Kqbp3s!PTohEQ8W$Kaub~iYm8fV-1I?v8=nM4n-dPTlPzo<##cHv9x+IN=y@JUN$W1QHR!G781TfE+uY zA{NVv2m&O4MB+WD;AxKA_6dW_zHXB>aYcX#2ix2I8m%9`GC#Y_Em)Y`;|CVAw&yu( z_4DO~alkq1DD5A&of!ua0g(i#2$6Oy&z)AL_o<|i(xJ^Xz*yK=^j ze&#qwJMKeqX{7`@4*DqAO0hXr^{t`1B`fS7Yl5*FY!P%Z={-2JG3No|0LfXJHc01( zC1CL!I(r{zfhuJV5m>MYsHb-L@}}VNB9IUESw~dzmS>_@iSCMprw&U;QP~B=4;RW! zTB%#lmzyKgB=7ScanLuiEKFrh-Q>_@O{=Afs$%#o=bndotMZ?3|bMG$hPhg%6nwsV*iVcjh-QaCd;cW>uUxQTywg9 zpL?QlGH7#rCzLF0*%a5J_oUJg4UmNo-V@_zj%kTXUQP4md2^iBf8$Au5{vxhC;{n3D+ zf7IoLWm)&Viwje(tWuk)rlDPHJAwD-#aGZ0FWmt?*xSfPF@0;A z7Q-w^fCg`*KIL)xDlC*iV^0YHa*qsCL(O>^JUAWD;J)U=dB9^37C!r?dJg7cBwU@~ z0R!ryD%qveb@wKt5mOIHP0p1j6nTpPpvH>~r~ehgVZ5(4^6w&a8D|X03^K0VdSVpD zYAK23X%D?ZD&UTrjWH7V${(enem#CKh$q=dpyfjuKwW8{@Jf@9<4c%2`vNSjI@F01 zB6p{6+kKM1`DnA~55wMhtdtJY!VggQVwPyp5rY5zSrKVW@Kgq>!$$PigzFizc-#hl z@6_4FE4F$~XUQUbkL%1s(`4je_l1EgWPr#w*f(`YOe*f;NXuS|FpyIRP#KmX`!~MZ z@ZJ`-4Hu!E3IRso()ma5Vy>jF1`USK2;W%vGfw-qedmznw2|H90gWGj3!6FAW;ymM zzdfNgxk}9n``tvlANaO>UOPUL?#5m)JC?5->T`ixCV#|OIkNShotY8!{l&6DkaI|1N`ax|&rZ7l z?z&&4G?ri$mD#tosdTvUP}h)WiuU>bJ3$BElSJgJCR-JSCM0=|ps9Xvoopb`+AT?t z!Tc%R!roPI%To~u&COJ9|1uECzuvd#>t+m-i359@$r6&}xh}mimjknKsb3GDo<&LA zm5Xl}*8|{1(l6=^r_NW2?oZDAel)p1O?TPbj2g>2U_bMd7)kHh<#<?7jM!H4`$P+ zY#7^p;vDS@E$v6m2U%_UAE(dUFpKe)_+0OhbPL;r)OS(bI{=pp8nc`y< z9)=!JU3<7XJ}i%Y3vrEV8!#MOdoC+a6*KG3!aYZCBbQ3b-~VW6!1}Jx(Z( zK3@Be+DY);;lt_CXu1t^YiNigz?HF}-R^JL-WbZb$;I_A%x#!QPrit4F)i3Ee{_`^ z3A8giIEG$^UupH;n>b*OYi5*xldc}0e`+^}1MIHe`LZXdvHs&t)PgC^HENTK&KNTE zD-8erv-j#ZMc$+KO+!hq$ixZPYe2V&P9VK8L*iP@e%yo!jcySvw)PM9&5t*uKMo$Z z^>gmEK?8a5?DNR_yl5Q-uq*2s8){Oml`qE|?p>50I|KCdzV%8Q3`Vt@YPNG~tIZ$kt;NT+`hR=gEYMzO6ZD|2Hyu^ewRy6Dkv$++c^3 zFseFe(-b91|8kMr5^X(VT5SmM34NLBoGm*sw*)+QU5Q1X>Z^WpGufAxVQnJx?T+4n z1W;M&>2DVQIQgBd*dN)B&=lpD7p9-1<+?f_MclzZL#e~y_^-U9gnT&u>#n1t?9j2F z9~n{S zIU&?_t)>S{gj3M=QTl~!vkvwNF5sa-Z`iszA$nNCOegYCpxB+&KANFEKad-KPOYM> z4v}owcXM0D6an0Uo@Yh#76Vt{VKJ4=BScPf%4tzKg82f}{dIFkC3rT27vqz1qd%R; z_s`44A|N$#Uqpo(_)o0TWCzXg0gA5ex9eJ5pB3%V1Tc-qtdMU4B;5O}X4P{TE`Q;` zq!s87DyJ=Ml*P)pI+aFhI(gaWRati(c>NDrF`^QTWwJbxl=`l#jXy*_7M&YG!$Fof zZiZzqBk%YQi8ekND$b7!4x)0=o);9DN*xx6-ei729|wr+`bpsv=V0&iPolUGGq=0r zTw~(}ADqAVg3YfwzD6L1Co+h3+q}nkT(($!uWI~t#Z#rpm=Ji~=Ec&1gCkCkrmq+0 z^bTv6&ssG24ZSP=>#yUEz|@%PQpR`7FgX9aJAuf!9f!u^1+CT{Rh7?T#;+EjZTEzW zB#&$Mi4_jb?ym=N|tg2236iIFNRu<^P(9?`q#FJX_mht! z3WEcbZDH>_I;2rZJO>U^Xf)22=7_@QvMqv_IhITWy^eR48ekWJFme$6=$&$p#e#&X zfy5#75#;W6nDBe$`Awq(LX-L3WZ(1WaGJUi(h)3|)Y*#n3&&nG9gyZgvJ|huSS4z`Y`R zf2Y_2aYl(#k2@4(9Y3y#$3Q4fWXG>)!|TVZlyN}Daa+XT@EC<{27?CVt3CW~HGUa& zuvXhJ3py@SYYRLynrTCNP=0T@2ckos{>Cbn;z2doW!@9{K3ORuP9*|cxuQqgEN27v z_(+=jrY)qP^yrLW;73JP@8YLujJqy<6(7JlX*nmV(?mbrguyZH800-v++ST);? Date: Fri, 8 May 2020 13:34:11 +0800 Subject: [PATCH 200/924] update_README --- README.md | 2 ++ 1 file changed, 2 insertions(+) diff --git a/README.md b/README.md index edb85cd9..ed3a8f1c 100644 --- a/README.md +++ b/README.md @@ -432,6 +432,7 @@ HTTP http = HTTP.builder() .addPreprocessor((PreChain chain) -> { HttpTask task = chain.getTask();// 获得当前的HTTP任务 if (!task.isTagged("Auth")) { // 根据标签判断该任务是否需要Token + chain.proceed(); return; } requestToken((String token) -> { // 异步获取 Token @@ -458,6 +459,7 @@ HTTP http = HTTP.builder() .addSerialPreprocessor((PreChain chain) -> { HttpTask task = chain.getTask(); if (!task.isTagged("Auth")) { + chain.proceed(); return; } // 检查过期，若需要则刷新Token From b74c1e5292c5f9b8e052d1be5c0bde2d951299df Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?=E5=91=A8=E6=97=AD?= Date: Fri, 8 May 2020 14:27:48 +0800 Subject: [PATCH 201/924] =?UTF-8?q?=E5=AD=90=E6=A8=A1=E5=9D=97?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- okhttps-fastjson/pom.xml | 17 +++++ okhttps-gson/pom.xml | 17 +++++ okhttps-jackson/pom.xml | 17 +++++ okhttps-kotlin/pom.xml | 17 +++++ okhttps/pom.xml | 158 ++------------------------------------- 5 files changed, 75 insertions(+), 151 deletions(-) create mode 100644 okhttps-fastjson/pom.xml create mode 100644 okhttps-gson/pom.xml create mode 100644 okhttps-jackson/pom.xml create mode 100644 okhttps-kotlin/pom.xml diff --git a/okhttps-fastjson/pom.xml b/okhttps-fastjson/pom.xml new file mode 100644 index 00000000..bdf2ab35 --- /dev/null +++ b/okhttps-fastjson/pom.xml @@ -0,0 +1,17 @@ + + 4.0.0 + + okhttps-fastjson + OkHttps Fastjson + jar + + + com.ejlchina + okhttps-parent + 1.0.5 + + + + okhttps-fastjson + + \ No newline at end of file diff --git a/okhttps-gson/pom.xml b/okhttps-gson/pom.xml new file mode 100644 index 00000000..c595205b --- /dev/null +++ b/okhttps-gson/pom.xml @@ -0,0 +1,17 @@ + + 4.0.0 + + okhttps-gson + OkHttps Gson + jar + + + com.ejlchina + okhttps-parent + 1.0.5 + + + + okhttps-gson + + \ No newline at end of file diff --git a/okhttps-jackson/pom.xml b/okhttps-jackson/pom.xml new file mode 100644 index 00000000..ad226219 --- /dev/null +++ b/okhttps-jackson/pom.xml @@ -0,0 +1,17 @@ + + 4.0.0 + + okhttps-jackson + OkHttps Jackson + jar + + + com.ejlchina + okhttps-parent + 1.0.5 + + + + okhttps-jackson + + \ No newline at end of file diff --git a/okhttps-kotlin/pom.xml b/okhttps-kotlin/pom.xml new file mode 100644 index 00000000..acbaf2e6 --- /dev/null +++ b/okhttps-kotlin/pom.xml @@ -0,0 +1,17 @@ + + 4.0.0 + + okhttps-kotlin + OkHttps Kotlin + jar + + + com.ejlchina + okhttps-parent + 1.0.5 + + + + okhttps-kotlin + + \ No newline at end of file diff --git a/okhttps/pom.xml b/okhttps/pom.xml index ea76c2a4..c2cd72c2 100644 --- a/okhttps/pom.xml +++ b/okhttps/pom.xml @@ -1,51 +1,18 @@ 4.0.0 - com.ejlchina okhttps - 1.0.5 OkHttps - - - 1.8 - 3.14.7 - 1.2.67 - 4.12 - UTF-8 - https://oss.sonatype.org/content/repositories/snapshots/ - - - - - The Apache License, Version 2.0 - http://www.apache.org/licenses/LICENSE-2.0.txt - - - - - - Troy - zhou.xu@ejlchina.com - ejlchina - http://www.ejlchina.com - - - - - scm:git://gitee.com/ejlchina-zhxu/okhttps.git - scm:http://gitee.com/ejlchina-zhxu/okhttps - https://gitee.com/ejlchina-zhxu/okhttps - v1.0.5 - + jar + + + com.ejlchina + okhttps-parent + 1.0.5 + - - com.squareup.okhttp3 - okhttp - ${okhttp.version} - - com.alibaba fastjson @@ -59,121 +26,10 @@ test - - junit - junit - ${junit.version} - test - - - - - sonatype-nexus-snapshots - Sonatype Nexus Snapshots - https://oss.sonatype.org/content/repositories/snapshots - - false - - - true - - - - - - - sonatype-nexus-snapshots - Sonatype Nexus Snapshots - ${sonatypeOssDistMgmtSnapshotsUrl} - - - sonatype-nexus-staging - Nexus Release Repository - https://oss.sonatype.org/service/local/staging/deploy/maven2/ - - - okhttps - - - - org.apache.maven.plugins - maven-release-plugin - 2.1 - - forked-path - false - -Psonatype-oss-release - - - - - org.apache.maven.plugins - maven-compiler-plugin - - ${java-version} - ${java-version} - ${project.build.sourceEncoding} - true - - - - - org.apache.maven.plugins - maven-source-plugin - 2.1.2 - - - attach-sources - - jar-no-fork - - - - - - - org.apache.maven.plugins - maven-javadoc-plugin - 2.7 - - - attach-javadocs - - jar - - - - - - - org.apache.maven.plugins - maven-gpg-plugin - 1.1 - - - sign-artifacts - verify - - sign - - - - - - - https://gitee.com/ejlchina-zhxu/okhttps - 比 Retrofit 更好用的网络框架！ OkHttp3 轻量封装 ，开箱即用、Java领域前后端处理 Http问题的新选择。 - - 江苏一键联信息科技有限公司 - http://www.ejlchina.com/ - - - https://gitee.com/ejlchina-zhxu/okhttps/issues - \ No newline at end of file From defe4ce5f4edd6435f2b0720afc5b480936432d1 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?=E5=91=A8=E6=97=AD?= Date: Fri, 8 May 2020 14:28:58 +0800 Subject: [PATCH 202/924] gitignore --- .gitignore | 5 +- pom.xml | 176 +++++++++++++++++++++++++++++++++++++++++++++++++++++ 2 files changed, 180 insertions(+), 1 deletion(-) create mode 100644 pom.xml diff --git a/.gitignore b/.gitignore index d39f4879..5a66362c 100644 --- a/.gitignore +++ b/.gitignore @@ -9,4 +9,7 @@ /*/.vuepress/dist/* /*/*.iml *.iml -/.idea/ \ No newline at end of file +/.idea/ +.settings/ +.classpath +.project \ No newline at end of file diff --git a/pom.xml b/pom.xml new file mode 100644 index 00000000..d342656e --- /dev/null +++ b/pom.xml @@ -0,0 +1,176 @@ + + 4.0.0 + + com.ejlchina + okhttps-parent + 1.0.5 + OkHttps + + pom + + + okhttps + okhttps-fastjson + okhttps-gson + okhttps-jackson + okhttps-kotlin + + + + 1.8 + 3.14.7 + 1.2.67 + 4.12 + UTF-8 + https://oss.sonatype.org/content/repositories/snapshots/ + + + + + The Apache License, Version 2.0 + http://www.apache.org/licenses/LICENSE-2.0.txt + + + + + + Troy + zhou.xu@ejlchina.com + ejlchina + http://www.ejlchina.com + + + + + scm:git://gitee.com/ejlchina-zhxu/okhttps.git + scm:http://gitee.com/ejlchina-zhxu/okhttps + https://gitee.com/ejlchina-zhxu/okhttps + v1.0.5 + + + + + + com.squareup.okhttp3 + okhttp + ${okhttp.version} + + + + junit + junit + ${junit.version} + test + + + + + + + sonatype-nexus-snapshots + Sonatype Nexus Snapshots + https://oss.sonatype.org/content/repositories/snapshots + + false + + + true + + + + + + + sonatype-nexus-snapshots + Sonatype Nexus Snapshots + ${sonatypeOssDistMgmtSnapshotsUrl} + + + sonatype-nexus-staging + Nexus Release Repository + https://oss.sonatype.org/service/local/staging/deploy/maven2/ + + + + + okhttps + + + + org.apache.maven.plugins + maven-release-plugin + 2.1 + + forked-path + false + -Psonatype-oss-release + + + + + org.apache.maven.plugins + maven-compiler-plugin + + ${java-version} + ${java-version} + ${project.build.sourceEncoding} + true + + + + + org.apache.maven.plugins + maven-source-plugin + 2.1.2 + + + attach-sources + + jar-no-fork + + + + + + + org.apache.maven.plugins + maven-javadoc-plugin + 2.7 + + + attach-javadocs + + jar + + + + + + + org.apache.maven.plugins + maven-gpg-plugin + 1.1 + + + sign-artifacts + verify + + sign + + + + + + + + + https://gitee.com/ejlchina-zhxu/okhttps + 比 Retrofit 更好用的网络框架！ OkHttp3 轻量封装 ，开箱即用、Java领域前后端处理 Http问题的新选择。 + + 江苏一键联信息科技有限公司 + http://www.ejlchina.com/ + + + https://gitee.com/ejlchina-zhxu/okhttps/issues + + \ No newline at end of file From 011d970987394585f1dfc1e6409bdaadf914f3ed Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?=E5=91=A8=E6=97=AD?= Date: Fri, 8 May 2020 16:41:27 +0800 Subject: [PATCH 203/924] =?UTF-8?q?HttpTask=20=E6=96=B0=E5=A2=9E=20=20noPr?= =?UTF-8?q?eprocess()=20=E5=92=8C=20noSerialPreprocess()=20=E6=96=B9?= =?UTF-8?q?=E6=B3=95=EF=BC=8C=E7=94=A8=E4=BA=8E=E8=B7=B3=E8=BF=87=20?= =?UTF-8?q?=E9=A2=84=E5=A4=84=E7=90=86=E5=99=A8=20=E5=92=8C=20=E4=B8=B2?= =?UTF-8?q?=E8=A1=8C=E9=A2=84=E5=A4=84=E7=90=86=E5=99=A8?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- .../java/com/ejlchina/okhttps/HttpTask.java | 25 +++++++++- .../okhttps/internal/AsyncHttpTask.java | 2 +- .../ejlchina/okhttps/internal/HttpClient.java | 50 +++++++++++++------ .../okhttps/internal/SyncHttpTask.java | 2 +- .../okhttps/internal/WebSocketTask.java | 9 ++-- 5 files changed, 65 insertions(+), 23 deletions(-) diff --git a/okhttps/src/main/java/com/ejlchina/okhttps/HttpTask.java b/okhttps/src/main/java/com/ejlchina/okhttps/HttpTask.java index 04824ed9..2d7b8b17 100644 --- a/okhttps/src/main/java/com/ejlchina/okhttps/HttpTask.java +++ b/okhttps/src/main/java/com/ejlchina/okhttps/HttpTask.java @@ -63,7 +63,10 @@ public abstract class HttpTask> implements Cancelable { private TagTask tagTask; private Cancelable canceler; - + protected boolean noPreprocess = false; + protected boolean noSerialPreprocess = false; + + public HttpTask(HttpClient httpClient, String url) { this.httpClient = httpClient; this.urlPath = url; @@ -124,6 +127,24 @@ public C nothrow() { return (C) this; } + /** + * 指定该请求不经过任何预处理器 + * @return HttpTask 实例 + */ + public C noPreprocess() { + this.noPreprocess = true; + return (C) this; + } + + /** + * 指定该请求不经过并行预处理器 + * @return HttpTask 实例 + */ + public C noSerialPreprocess() { + this.noSerialPreprocess = true; + return (C) this; + } + /** * 为请求任务添加标签 * v1.0.4 之后，若 set 多次，标签将连接在一起 @@ -161,7 +182,7 @@ public C bind(Object object) { return (C) this; } - /** + /** * 添加请求头 * @param name 请求头名 * @param value 请求头值 diff --git a/okhttps/src/main/java/com/ejlchina/okhttps/internal/AsyncHttpTask.java b/okhttps/src/main/java/com/ejlchina/okhttps/internal/AsyncHttpTask.java index 7f894429..2fb42b88 100644 --- a/okhttps/src/main/java/com/ejlchina/okhttps/internal/AsyncHttpTask.java +++ b/okhttps/src/main/java/com/ejlchina/okhttps/internal/AsyncHttpTask.java @@ -120,7 +120,7 @@ public HttpCall request(String method) { call.setCall(executeCall(prepareCall(method))); } } - }); + }, noPreprocess, noSerialPreprocess); return call; } diff --git a/okhttps/src/main/java/com/ejlchina/okhttps/internal/HttpClient.java b/okhttps/src/main/java/com/ejlchina/okhttps/internal/HttpClient.java index 160d795a..511bca79 100644 --- a/okhttps/src/main/java/com/ejlchina/okhttps/internal/HttpClient.java +++ b/okhttps/src/main/java/com/ejlchina/okhttps/internal/HttpClient.java @@ -178,14 +178,27 @@ public TaskExecutor getExecutor() { return executor; } - public void preprocess(HttpTask> httpTask, Runnable request) { - if (preprocessors.length > 0) { - RealPreChain chain = new RealPreChain(preprocessors, - httpTask, request); - preprocessors[0].doProcess(chain); - } else { - request.run(); - } + public void preprocess(HttpTask> httpTask, Runnable request, + boolean noPreprocess, boolean noSerialPreprocess) { + if (preprocessors.length == 0 || noPreprocess) { + request.run(); + return; + } + int index = 0; + if (noSerialPreprocess) { + while (index < preprocessors.length + && preprocessors[index] instanceof SerialPreprocessor) { + index++; + } + } + if (index < preprocessors.length) { + RealPreChain chain = new RealPreChain(preprocessors, + httpTask, request, index + 1, + noSerialPreprocess); + preprocessors[index].doProcess(chain); + } else { + request.run(); + } } /** @@ -249,13 +262,15 @@ class RealPreChain implements Preprocessor.PreChain { private Runnable request; - public RealPreChain(Preprocessor[] preprocessors, - HttpTask httpTask, - Runnable request) { - this.index = 1; + private boolean noSerialPreprocess; + + public RealPreChain(Preprocessor[] preprocessors, HttpTask httpTask, Runnable request, + int index, boolean noSerialPreprocess) { + this.index = index; // index 大于等于 1 this.preprocessors = preprocessors; this.httpTask = httpTask; this.request = request; + this.noSerialPreprocess = noSerialPreprocess; } @Override @@ -270,12 +285,17 @@ public HTTP getHttp() { @Override public void proceed() { - if (index > 0) { - Preprocessor last = preprocessors[index - 1]; + if (noSerialPreprocess) { + while (index < preprocessors.length + && preprocessors[index] instanceof SerialPreprocessor) { + index++; + } + } else { + Preprocessor last = preprocessors[index - 1]; if (last instanceof SerialPreprocessor) { ((SerialPreprocessor) last).afterProcess(); } - } + } if (index < preprocessors.length) { preprocessors[index++].doProcess(this); } else { diff --git a/okhttps/src/main/java/com/ejlchina/okhttps/internal/SyncHttpTask.java b/okhttps/src/main/java/com/ejlchina/okhttps/internal/SyncHttpTask.java index 666c0a90..ba931fce 100644 --- a/okhttps/src/main/java/com/ejlchina/okhttps/internal/SyncHttpTask.java +++ b/okhttps/src/main/java/com/ejlchina/okhttps/internal/SyncHttpTask.java @@ -86,7 +86,7 @@ public HttpResult request(String method) { } finally { latch.countDown(); } - }); + }, noPreprocess, noSerialPreprocess); boolean timeout = false; if (result.getState() == null) { timeout = !timeoutAwait(latch); diff --git a/okhttps/src/main/java/com/ejlchina/okhttps/internal/WebSocketTask.java b/okhttps/src/main/java/com/ejlchina/okhttps/internal/WebSocketTask.java index c0897e38..e083716e 100644 --- a/okhttps/src/main/java/com/ejlchina/okhttps/internal/WebSocketTask.java +++ b/okhttps/src/main/java/com/ejlchina/okhttps/internal/WebSocketTask.java @@ -1,6 +1,5 @@ package com.ejlchina.okhttps.internal; -import java.io.IOException; import java.util.ArrayList; import java.util.List; @@ -20,7 +19,7 @@ public class WebSocketTask extends HttpTask { private Listener onOnen; - private Listener onException; + private Listener onException; public WebSocketTask(HttpClient httpClient, String url) { @@ -41,7 +40,7 @@ public WebSocket listen() { socket.setWebSocket(httpClient.webSocket(request, listener)); } } - }); + }, noPreprocess, noSerialPreprocess); return socket; } @@ -85,7 +84,9 @@ public void onClosed(okhttp3.WebSocket webSocket, int code, String reason) { @Override public void onFailure(okhttp3.WebSocket webSocket, Throwable t, Response response) { if (onException != null) { -// onException.on(this.webSocket, t); + onException.on(this.webSocket, t); + } else if (!nothrow) { + throw new HttpException("WebSockt 异常", t); } } From 360098c16cac30b148e177fe8555989f6bfd581c Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?=E5=91=A8=E6=97=AD?= Date: Fri, 8 May 2020 16:45:22 +0800 Subject: [PATCH 204/924] V2.0.0 --- okhttps-fastjson/pom.xml | 2 +- okhttps-gson/pom.xml | 2 +- okhttps-jackson/pom.xml | 2 +- okhttps-kotlin/pom.xml | 2 +- okhttps/pom.xml | 2 +- pom.xml | 2 +- 6 files changed, 6 insertions(+), 6 deletions(-) diff --git a/okhttps-fastjson/pom.xml b/okhttps-fastjson/pom.xml index bdf2ab35..330d0843 100644 --- a/okhttps-fastjson/pom.xml +++ b/okhttps-fastjson/pom.xml @@ -8,7 +8,7 @@ com.ejlchina okhttps-parent - 1.0.5 + 2.0.0 diff --git a/okhttps-gson/pom.xml b/okhttps-gson/pom.xml index c595205b..31755f32 100644 --- a/okhttps-gson/pom.xml +++ b/okhttps-gson/pom.xml @@ -8,7 +8,7 @@ com.ejlchina okhttps-parent - 1.0.5 + 2.0.0 diff --git a/okhttps-jackson/pom.xml b/okhttps-jackson/pom.xml index ad226219..da562191 100644 --- a/okhttps-jackson/pom.xml +++ b/okhttps-jackson/pom.xml @@ -8,7 +8,7 @@ com.ejlchina okhttps-parent - 1.0.5 + 2.0.0 diff --git a/okhttps-kotlin/pom.xml b/okhttps-kotlin/pom.xml index acbaf2e6..75144398 100644 --- a/okhttps-kotlin/pom.xml +++ b/okhttps-kotlin/pom.xml @@ -8,7 +8,7 @@ com.ejlchina okhttps-parent - 1.0.5 + 2.0.0 diff --git a/okhttps/pom.xml b/okhttps/pom.xml index c2cd72c2..93fbdada 100644 --- a/okhttps/pom.xml +++ b/okhttps/pom.xml @@ -8,7 +8,7 @@ com.ejlchina okhttps-parent - 1.0.5 + 2.0.0 diff --git a/pom.xml b/pom.xml index d342656e..77da9d24 100644 --- a/pom.xml +++ b/pom.xml @@ -3,7 +3,7 @@ com.ejlchina okhttps-parent - 1.0.5 + 2.0.0 OkHttps pom From 3f248e84e835b73dba8881814efd92e5cba66c72 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?=E5=91=A8=E6=97=AD?= Date: Fri, 8 May 2020 17:31:54 +0800 Subject: [PATCH 205/924] =?UTF-8?q?=E6=96=B0=E5=A2=9E=20JsonObj=20?= =?UTF-8?q?=E5=92=8C=20JsonArr=20=E6=8E=A5=E5=8F=A3?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- .../java/com/ejlchina/okhttps/JsonArr.java | 93 +++++++++++++++ .../java/com/ejlchina/okhttps/JsonObj.java | 111 ++++++++++++++++++ 2 files changed, 204 insertions(+) create mode 100644 okhttps/src/main/java/com/ejlchina/okhttps/JsonArr.java create mode 100644 okhttps/src/main/java/com/ejlchina/okhttps/JsonObj.java diff --git a/okhttps/src/main/java/com/ejlchina/okhttps/JsonArr.java b/okhttps/src/main/java/com/ejlchina/okhttps/JsonArr.java new file mode 100644 index 00000000..f297a2d5 --- /dev/null +++ b/okhttps/src/main/java/com/ejlchina/okhttps/JsonArr.java @@ -0,0 +1,93 @@ +package com.ejlchina.okhttps; + +public interface JsonArr { + + /** + * @return JSON 的键值对数量 + */ + int size(); + + /** + * @return 是否为空 + */ + boolean isEmpty(); + + /** + * @param index 元素下标 + * @return 子 JsonObj + */ + JsonObj getJsonOjb(int index); + + /** + * @param index 元素下标 + * @return 子 JsonArr + */ + JsonArr getJsonArr(int index); + + /** + * @param index 元素下标 + * @return Boolean 值 + */ + Boolean getBool(int index); + + /** + * @param index 元素下标 + * @return boolean 值 + */ + boolean getBoolVal(int index); + + /** + * @param index 元素下标 + * @return Integer 值 + */ + Integer getInt(int index); + + /** + * @param index 元素下标 + * @return int 值 + */ + int getIntVal(int index); + + /** + * @param index 元素下标 + * @return Short 值 + */ + Short getShort(int index); + + /** + * @param index 元素下标 + * @return short 值 + */ + short getShortVal(int index); + + /** + * @param index 元素下标 + * @return Float 值 + */ + Float getFloat(int index); + + /** + * @param index 元素下标 + * @return float 值 + */ + float getFloatVal(int index); + + /** + * @param index 元素下标 + * @return Double 值 + */ + Double getDouble(int index); + + /** + * @param index 元素下标 + * @return double 值 + */ + double getDoubleVal(int index); + + /** + * @param index 元素下标 + * @return String 值 + */ + String getString(int index); + +} diff --git a/okhttps/src/main/java/com/ejlchina/okhttps/JsonObj.java b/okhttps/src/main/java/com/ejlchina/okhttps/JsonObj.java new file mode 100644 index 00000000..609dabee --- /dev/null +++ b/okhttps/src/main/java/com/ejlchina/okhttps/JsonObj.java @@ -0,0 +1,111 @@ +package com.ejlchina.okhttps; + +import java.util.Set; + +/** + * JSON 对象 + * @author 15735 + * + */ +public interface JsonObj { + + /** + * @return JSON 的键值对数量 + */ + public int size(); + + /** + * @return 是否为空 + */ + boolean isEmpty(); + + /** + * @param key 键名 + * @return 子 JsonObj + */ + JsonObj getJsonOjb(String key); + + /** + * @param key 键名 + * @return 子 JsonArr + */ + JsonArr getJsonArr(String key); + + /** + * @param key 键名 + * @return Boolean 值 + */ + Boolean getBool(String key); + + /** + * @param key 键名 + * @return boolean 值 + */ + boolean getBoolVal(String key); + + /** + * @param key 键名 + * @return Integer 值 + */ + Integer getInt(String key); + + /** + * @param key 键名 + * @return int 值 + */ + int getIntVal(String key); + + /** + * @param key 键名 + * @return Short 值 + */ + Short getShort(String key); + + /** + * @param key 键名 + * @return short 值 + */ + short getShortVal(String key); + + /** + * @param key 键名 + * @return Float 值 + */ + Float getFloat(String key); + + /** + * @param key 键名 + * @return float 值 + */ + float getFloatVal(String key); + + /** + * @param key 键名 + * @return Double 值 + */ + Double getDouble(String key); + + /** + * @param key 键名 + * @return double 值 + */ + double getDoubleVal(String key); + + /** + * @param key 键名 + * @return String 值 + */ + String getString(String key); + + /** + * @param key 键名 + * @return 是否有该键 + */ + boolean has(String key); + + /** + * @return JSON 的键集合 + */ + public Set keySet(); + +} From c54019aa42ffdb52733cacd8854f0c971323395c Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?=E5=91=A8=E6=97=AD?= Date: Fri, 8 May 2020 18:39:23 +0800 Subject: [PATCH 206/924] =?UTF-8?q?okhttps=20=E4=B8=8E=20fastjson=20?= =?UTF-8?q?=E8=A7=A3=E8=80=A6?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- okhttps-fastjson/pom.xml | 11 ++++ okhttps-gson/pom.xml | 10 +++ .../com/ejlchina/okhttps/gson/TestCase.java | 12 ++++ okhttps-jackson/pom.xml | 10 +++ okhttps/pom.xml | 6 -- .../java/com/ejlchina/okhttps/HttpResult.java | 6 +- .../java/com/ejlchina/okhttps/HttpTask.java | 12 ++-- .../com/ejlchina/okhttps/JsonFactory.java | 57 +++++++++++++++++ .../java/com/ejlchina/okhttps/WebSocket.java | 8 +++ .../ejlchina/okhttps/internal/HttpClient.java | 20 +++++- .../ejlchina/okhttps/internal/ResultBody.java | 31 ++++++--- .../okhttps/internal/TaskExecutor.java | 24 ++++--- .../okhttps/internal/WebSocketTask.java | 24 ++++--- .../java/com/ejlchina/test/CacheTests.java | 4 +- .../java/com/ejlchina/test/SimpleTests.java | 63 ++++++++----------- 15 files changed, 220 insertions(+), 78 deletions(-) create mode 100644 okhttps-gson/src/test/java/com/ejlchina/okhttps/gson/TestCase.java create mode 100644 okhttps/src/main/java/com/ejlchina/okhttps/JsonFactory.java diff --git a/okhttps-fastjson/pom.xml b/okhttps-fastjson/pom.xml index 330d0843..e69a9497 100644 --- a/okhttps-fastjson/pom.xml +++ b/okhttps-fastjson/pom.xml @@ -11,6 +11,17 @@ 2.0.0 + + + + com.alibaba + fastjson + ${fastjson.version} + + + + + okhttps-fastjson diff --git a/okhttps-gson/pom.xml b/okhttps-gson/pom.xml index 31755f32..f78670ea 100644 --- a/okhttps-gson/pom.xml +++ b/okhttps-gson/pom.xml @@ -11,6 +11,16 @@ 2.0.0 + + + + com.google.code.gson + gson + 2.8.6 + + + + okhttps-gson diff --git a/okhttps-gson/src/test/java/com/ejlchina/okhttps/gson/TestCase.java b/okhttps-gson/src/test/java/com/ejlchina/okhttps/gson/TestCase.java new file mode 100644 index 00000000..9611f79c --- /dev/null +++ b/okhttps-gson/src/test/java/com/ejlchina/okhttps/gson/TestCase.java @@ -0,0 +1,12 @@ +package com.ejlchina.okhttps.gson; + +import org.junit.Test; + +public class TestCase { + + @Test + public void test() { + + } + +} diff --git a/okhttps-jackson/pom.xml b/okhttps-jackson/pom.xml index da562191..e149b9a5 100644 --- a/okhttps-jackson/pom.xml +++ b/okhttps-jackson/pom.xml @@ -11,6 +11,16 @@ 2.0.0 + + + + com.fasterxml.jackson.core + jackson-core + 2.11.0 + + + + okhttps-jackson diff --git a/okhttps/pom.xml b/okhttps/pom.xml index 93fbdada..ebffcd88 100644 --- a/okhttps/pom.xml +++ b/okhttps/pom.xml @@ -13,12 +13,6 @@ - - com.alibaba - fastjson - ${fastjson.version} - - com.squareup.okhttp3 mockwebserver diff --git a/okhttps/src/main/java/com/ejlchina/okhttps/HttpResult.java b/okhttps/src/main/java/com/ejlchina/okhttps/HttpResult.java index c3d31928..6a1ae528 100644 --- a/okhttps/src/main/java/com/ejlchina/okhttps/HttpResult.java +++ b/okhttps/src/main/java/com/ejlchina/okhttps/HttpResult.java @@ -6,8 +6,6 @@ import java.io.Reader; import java.util.List; -import com.alibaba.fastjson.JSONArray; -import com.alibaba.fastjson.JSONObject; import com.ejlchina.okhttps.internal.RealHttpResult; import com.ejlchina.okhttps.internal.TaskExecutor; @@ -153,13 +151,13 @@ public interface Body { * 同一个 Body 对象的 toXXX 类方法只可使用一个并且只能调用一次 * @return 报文体转Json对象 */ - JSONObject toJsonObject(); + JsonObj toJsonObj(); /** * 同一个 Body 对象的 toXXX 类方法只可使用一个并且只能调用一次 * @return 报文体转Json数组 */ - JSONArray toJsonArray(); + JsonArr toJsonArr(); /** * 同一个 Body 对象的 toXXX 类方法只可使用一个并且只能调用一次 diff --git a/okhttps/src/main/java/com/ejlchina/okhttps/HttpTask.java b/okhttps/src/main/java/com/ejlchina/okhttps/HttpTask.java index 2d7b8b17..68b78b1b 100644 --- a/okhttps/src/main/java/com/ejlchina/okhttps/HttpTask.java +++ b/okhttps/src/main/java/com/ejlchina/okhttps/HttpTask.java @@ -13,7 +13,6 @@ import java.util.concurrent.CountDownLatch; import java.util.concurrent.TimeUnit; -import com.alibaba.fastjson.JSON; import com.ejlchina.okhttps.HttpResult.State; import com.ejlchina.okhttps.internal.HttpClient; import com.ejlchina.okhttps.internal.HttpClient.TagTask; @@ -420,9 +419,13 @@ public C setRequestJson(Object json, String dateFormat) { if (json instanceof String) { requestJson = json.toString(); } else if (dateFormat != null) { - requestJson = JSON.toJSONStringWithDateFormat(json, dateFormat); + requestJson = httpClient.getExecutor() + .getJsonFactoryNotNull() + .toJsonStr(json, dateFormat); } else { - requestJson = JSON.toJSONString(json); + requestJson = httpClient.getExecutor() + .getJsonFactoryNotNull() + .toJsonStr(json); } } return (C) this; @@ -653,7 +656,8 @@ protected State toState(IOException e, boolean sync) { private RequestBody buildRequestBody() { if (jsonParams != null) { - requestJson = JSON.toJSONString(jsonParams); + requestJson = httpClient.getExecutor().getJsonFactoryNotNull() + .toJsonStr(jsonParams); } if (files != null) { MultipartBody.Builder builder = new MultipartBody.Builder().setType(MultipartBody.FORM); diff --git a/okhttps/src/main/java/com/ejlchina/okhttps/JsonFactory.java b/okhttps/src/main/java/com/ejlchina/okhttps/JsonFactory.java new file mode 100644 index 00000000..b9c4e3e2 --- /dev/null +++ b/okhttps/src/main/java/com/ejlchina/okhttps/JsonFactory.java @@ -0,0 +1,57 @@ +package com.ejlchina.okhttps; + +import java.util.List; + + +public interface JsonFactory { + + + /** + * 将 json 文本解析为 JsonObj + * @param json 文本 + * @return JsonObj + */ + JsonObj newJsonObj(String json); + + /** + * 将 json 文本解析为 JsonArr + * @param json 文本 + * @return JsonArr + */ + JsonArr newJsonArr(String json); + + /** + * 将 Java 对象序列化为 Json 字符串 + * @param bean Java Bean + * @return Json 字符串 + */ + String toJsonStr(Object bean); + + /** + * 将 Java 对象序列化为 Json 字符串 + * @param bean Java Bean + * @param dateFormat 日期类的处理格式 + * @return Json 字符串 + */ + String toJsonStr(Object bean, String dateFormat); + + /** + * 将 json 文本 解析为 Java Bean + * @param 目标泛型 + * @param type 目标类型 + * @param json 文本 + * @return Java Bean + */ + T jsonToBean(Class type, String json); + + /** + * 将 json 文本 解析为 Java List + * @param 目标泛型 + * @param type 目标类型 + * @param json 文本 + * @return Java List + */ + List jsonToList(Class type, String json); + + +} diff --git a/okhttps/src/main/java/com/ejlchina/okhttps/WebSocket.java b/okhttps/src/main/java/com/ejlchina/okhttps/WebSocket.java index 015d46cb..f8cb6e39 100644 --- a/okhttps/src/main/java/com/ejlchina/okhttps/WebSocket.java +++ b/okhttps/src/main/java/com/ejlchina/okhttps/WebSocket.java @@ -34,6 +34,14 @@ public interface Listener { */ public boolean send(Object bean); + /** + * 以JSON文本格式发送对象消息 + * @param bean 待发送的对象 + * @param dateFormat 日期类型字段的处理格式 + * @return 如果连接已断开 返回 false + */ + public boolean send(Object bean, String dateFormat); + /** * 发送字节流 * @param data 待发送的数据 diff --git a/okhttps/src/main/java/com/ejlchina/okhttps/internal/HttpClient.java b/okhttps/src/main/java/com/ejlchina/okhttps/internal/HttpClient.java index 511bca79..2174e816 100644 --- a/okhttps/src/main/java/com/ejlchina/okhttps/internal/HttpClient.java +++ b/okhttps/src/main/java/com/ejlchina/okhttps/internal/HttpClient.java @@ -33,7 +33,7 @@ private HttpClient(Builder builder) { this.executor = new TaskExecutor(client.dispatcher().executorService(), builder.mainExecutor, builder.downloadListener, builder.responseListener, builder.exceptionListener, - builder.completeListener); + builder.completeListener, builder.jsonFactory); this.preprocessors = builder.preprocessors.toArray(new Preprocessor[0]); this.tagTasks = new LinkedList<>(); } @@ -349,6 +349,8 @@ public static class Builder { private TaskListener completeListener; + private JsonFactory jsonFactory; + public Builder() { mediaTypes = new HashMap<>(); mediaTypes.put("*", "application/octet-stream"); @@ -374,6 +376,11 @@ private Builder(HttpClient hc) { this.mediaTypes = hc.mediaTypes; this.preprocessors = new ArrayList<>(); Collections.addAll(this.preprocessors, hc.preprocessors); + this.downloadListener = hc.executor.downloadListener; + this.responseListener = hc.executor.responseListener; + this.exceptionListener = hc.executor.exceptionListener; + this.completeListener = hc.executor.completeListener; + this.jsonFactory = hc.executor.jsonFactory; } /** @@ -498,6 +505,17 @@ public Builder downloadListener(DownListener listener) { return this; } + /** + * 设置 JSON 工厂 + * @param jsonFactory JSON 工厂 + * @return Builder + */ + public Builder jsonFactory(JsonFactory jsonFactory) { + this.jsonFactory = jsonFactory; + return this; + } + + public HTTP build() { if (configurator != null || client == null) { OkHttpClient.Builder builder = new OkHttpClient.Builder(); diff --git a/okhttps/src/main/java/com/ejlchina/okhttps/internal/ResultBody.java b/okhttps/src/main/java/com/ejlchina/okhttps/internal/ResultBody.java index 1123668e..03d51e3c 100644 --- a/okhttps/src/main/java/com/ejlchina/okhttps/internal/ResultBody.java +++ b/okhttps/src/main/java/com/ejlchina/okhttps/internal/ResultBody.java @@ -14,14 +14,13 @@ import java.nio.charset.Charset; import java.util.List; -import com.alibaba.fastjson.JSON; -import com.alibaba.fastjson.JSONArray; -import com.alibaba.fastjson.JSONObject; import com.ejlchina.okhttps.Download; +import com.ejlchina.okhttps.HttpResult.Body; import com.ejlchina.okhttps.HttpTask; +import com.ejlchina.okhttps.JsonArr; +import com.ejlchina.okhttps.JsonObj; import com.ejlchina.okhttps.OnCallback; import com.ejlchina.okhttps.Process; -import com.ejlchina.okhttps.HttpResult.Body; import okhttp3.MediaType; import okhttp3.Response; @@ -149,23 +148,35 @@ public String toString() { } @Override - public JSONObject toJsonObject() { - return JSON.parseObject(toString()); + public JsonObj toJsonObj() { + if (taskExecutor == null) { + throw new IllegalStateException("没有 taskExecutor，不可做 Json 转换！"); + } + return taskExecutor.getJsonFactoryNotNull().newJsonObj(toString()); } @Override - public JSONArray toJsonArray() { - return JSON.parseArray(toString()); + public JsonArr toJsonArr() { + if (taskExecutor == null) { + throw new IllegalStateException("没有 taskExecutor，不可做 Json 转换！"); + } + return taskExecutor.getJsonFactoryNotNull().newJsonArr(toString()); } @Override public T toBean(Class type) { - return JSON.parseObject(toString(), type); + if (taskExecutor == null) { + throw new IllegalStateException("没有 taskExecutor，不可做 Json 转换！"); + } + return taskExecutor.getJsonFactoryNotNull().jsonToBean(type, toString()); } @Override public List toList(Class type) { - return JSON.parseArray(toString(), type); + if (taskExecutor == null) { + throw new IllegalStateException("没有 taskExecutor，不可做 Json 转换！"); + } + return taskExecutor.getJsonFactoryNotNull().jsonToList(type, toString()); } @Override diff --git a/okhttps/src/main/java/com/ejlchina/okhttps/internal/TaskExecutor.java b/okhttps/src/main/java/com/ejlchina/okhttps/internal/TaskExecutor.java index 42d2e19e..1df24b71 100644 --- a/okhttps/src/main/java/com/ejlchina/okhttps/internal/TaskExecutor.java +++ b/okhttps/src/main/java/com/ejlchina/okhttps/internal/TaskExecutor.java @@ -10,28 +10,31 @@ import com.ejlchina.okhttps.Download; import com.ejlchina.okhttps.HttpResult; import com.ejlchina.okhttps.HttpTask; +import com.ejlchina.okhttps.JsonFactory; import com.ejlchina.okhttps.OnCallback; import com.ejlchina.okhttps.TaskListener; import com.ejlchina.okhttps.HttpResult.State; public class TaskExecutor { - private Executor ioExecutor; - private Executor mainExecutor; - private DownListener downloadListener; - private TaskListener responseListener; - private TaskListener exceptionListener; - private TaskListener completeListener; + Executor ioExecutor; + Executor mainExecutor; + DownListener downloadListener; + TaskListener responseListener; + TaskListener exceptionListener; + TaskListener completeListener; + JsonFactory jsonFactory; public TaskExecutor(Executor ioExecutor, Executor mainExecutor, DownListener downloadListener, TaskListener responseListener, TaskListener exceptionListener, - TaskListener completeListener) { + TaskListener completeListener, JsonFactory jsonFactory) { this.ioExecutor = ioExecutor; this.mainExecutor = mainExecutor; this.downloadListener = downloadListener; this.responseListener = responseListener; this.exceptionListener = exceptionListener; this.completeListener = completeListener; + this.jsonFactory = jsonFactory; } public Executor getExecutor(boolean onIoThread) { @@ -96,6 +99,13 @@ public void executeOnComplete(HttpTask task, OnCallback onComplete, St } } + public JsonFactory getJsonFactoryNotNull() { + if (jsonFactory != null) { + return jsonFactory; + } + throw new IllegalStateException("没有设置 JsonFactory，不可做 Json 操作！"); + } + /** * 关闭线程池 * @since OkHttps V1.0.2 diff --git a/okhttps/src/main/java/com/ejlchina/okhttps/internal/WebSocketTask.java b/okhttps/src/main/java/com/ejlchina/okhttps/internal/WebSocketTask.java index e083716e..9a3726be 100644 --- a/okhttps/src/main/java/com/ejlchina/okhttps/internal/WebSocketTask.java +++ b/okhttps/src/main/java/com/ejlchina/okhttps/internal/WebSocketTask.java @@ -3,7 +3,6 @@ import java.util.ArrayList; import java.util.List; -import com.alibaba.fastjson.JSON; import com.ejlchina.okhttps.HttpResult; import com.ejlchina.okhttps.HttpTask; import com.ejlchina.okhttps.WebSocket; @@ -28,7 +27,7 @@ public WebSocketTask(HttpClient httpClient, String url) { public WebSocket listen() { - WebSocketImpl socket = new WebSocketImpl(); + WebSocketImpl socket = new WebSocketImpl(httpClient.executor); registeTagTask(socket); httpClient.preprocess(this, () -> { synchronized (socket) { @@ -101,6 +100,12 @@ static class WebSocketImpl implements WebSocket { List queues = new ArrayList<>(); + TaskExecutor taskExecutor; + + public WebSocketImpl(TaskExecutor taskExecutor) { + this.taskExecutor = taskExecutor; + } + @Override public synchronized boolean cancel() { if (webSocket != null) { @@ -147,13 +152,14 @@ public boolean send(ByteString bytes) { @Override public boolean send(Object bean) { - if (webSocket != null) { - return send(webSocket, bean); - } - queueMsgToSend(bean); - return true; + return send(taskExecutor.getJsonFactoryNotNull().toJsonStr(bean)); } + @Override + public boolean send(Object bean, String dateFormat) { + return send(taskExecutor.getJsonFactoryNotNull().toJsonStr(bean, dateFormat)); + } + @Override public boolean send(byte[] data) { if (webSocket != null) { @@ -163,6 +169,8 @@ public boolean send(byte[] data) { return true; } + + void queueMsgToSend(Object msg) { if (msg == null) { return; @@ -201,7 +209,7 @@ boolean send(okhttp3.WebSocket webSocket, Object msg) { if (msg instanceof byte[]) { return webSocket.send(ByteString.of((byte[]) msg)); } - return webSocket.send(JSON.toJSONString(msg)); + return webSocket.send(taskExecutor.getJsonFactoryNotNull().toJsonStr(msg)); } } diff --git a/okhttps/src/test/java/com/ejlchina/test/CacheTests.java b/okhttps/src/test/java/com/ejlchina/test/CacheTests.java index baa95483..962eebb8 100644 --- a/okhttps/src/test/java/com/ejlchina/test/CacheTests.java +++ b/okhttps/src/test/java/com/ejlchina/test/CacheTests.java @@ -16,12 +16,12 @@ public void testCache() { .cache(); println("result = " + body.toString()); - println("result = " + body.toJsonArray()); + println("result = " + body.toJsonArr()); body.close(); println("result = " + body.toString()); - println("result = " + body.toJsonArray()); + println("result = " + body.toJsonArr()); } } diff --git a/okhttps/src/test/java/com/ejlchina/test/SimpleTests.java b/okhttps/src/test/java/com/ejlchina/test/SimpleTests.java index 4b0ef9ef..0f54880a 100644 --- a/okhttps/src/test/java/com/ejlchina/test/SimpleTests.java +++ b/okhttps/src/test/java/com/ejlchina/test/SimpleTests.java @@ -1,16 +1,7 @@ package com.ejlchina.test; -import static org.junit.Assert.assertEquals; - -import java.util.Arrays; -import java.util.List; - -import org.junit.Test; - -import com.alibaba.fastjson.JSON; import com.ejlchina.okhttps.HTTP; -import okhttp3.mockwebserver.MockResponse; import okhttp3.mockwebserver.MockWebServer; public class SimpleTests extends BaseTest { @@ -26,38 +17,38 @@ public class SimpleTests extends BaseTest { * 同步请求示例 * 同步请求直接得到结果，无需设置回调 */ - @Test - public void testSyncToBean() { - User u1 = new User(1, "Jack"); - server.enqueue(new MockResponse().setBody(JSON.toJSONString(u1))); - - User user = http.sync("/users") // http://localhost:8080/users - .get() // GET请求 - .getBody() // 获取响应报文体 - .toBean(User.class); // 得到目标数据 - - assertEquals(u1, user); - } +// @Test +// public void testSyncToBean() { +// User u1 = new User(1, "Jack"); +// server.enqueue(new MockResponse().setBody(JSON.toJSONString(u1))); +// +// User user = http.sync("/users") // http://localhost:8080/users +// .get() // GET请求 +// .getBody() // 获取响应报文体 +// .toBean(User.class); // 得到目标数据 +// +// assertEquals(u1, user); +// } /** * 同步请求示例 * 同步请求直接得到结果，无需设置回调 */ - @Test - public void testSyncToList() { - User u1 = new User(1, "Jack"); - User u2 = new User(2, "Tom"); - List list = Arrays.asList(u1, u2); - server.enqueue(new MockResponse().setBody(JSON.toJSONString(list))); - - List users = http.sync("/users") // http://localhost:8080/users - .get() // GET请求 - .getBody() // 获取响应报文体 - .toList(User.class); // 得到目标数据 - - assertEquals(u1, users.get(0)); - assertEquals(u2, users.get(1)); - } +// @Test +// public void testSyncToList() { +// User u1 = new User(1, "Jack"); +// User u2 = new User(2, "Tom"); +// List list = Arrays.asList(u1, u2); +// server.enqueue(new MockResponse().setBody(JSON.toJSONString(list))); +// +// List users = http.sync("/users") // http://localhost:8080/users +// .get() // GET请求 +// .getBody() // 获取响应报文体 +// .toList(User.class); // 得到目标数据 +// +// assertEquals(u1, users.get(0)); +// assertEquals(u2, users.get(1)); +// } // // /** // * 异步请求示例 From 00738199dec55f5bef79b2895f0e90878a87b8a0 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?=E5=91=A8=E6=97=AD?= Date: Fri, 8 May 2020 20:15:11 +0800 Subject: [PATCH 207/924] =?UTF-8?q?=E9=A1=B9=E7=9B=AE=E4=BE=9D=E8=B5=96?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- okhttps-fastjson/pom.xml | 9 ++++++--- okhttps-gson/pom.xml | 9 ++++++--- okhttps-jackson/pom.xml | 9 ++++++--- okhttps-kotlin/pom.xml | 10 +++++++++- pom.xml | 3 ++- 5 files changed, 29 insertions(+), 11 deletions(-) diff --git a/okhttps-fastjson/pom.xml b/okhttps-fastjson/pom.xml index e69a9497..a68e2685 100644 --- a/okhttps-fastjson/pom.xml +++ b/okhttps-fastjson/pom.xml @@ -8,17 +8,20 @@ com.ejlchina okhttps-parent - 2.0.0 + ${okhttps.version} - + + com.ejlchina + okhttps + ${okhttps.version} + com.alibaba fastjson ${fastjson.version} - diff --git a/okhttps-gson/pom.xml b/okhttps-gson/pom.xml index f78670ea..8add3318 100644 --- a/okhttps-gson/pom.xml +++ b/okhttps-gson/pom.xml @@ -8,17 +8,20 @@ com.ejlchina okhttps-parent - 2.0.0 + ${okhttps.version} - + + com.ejlchina + okhttps + ${okhttps.version} + com.google.code.gson gson 2.8.6 - diff --git a/okhttps-jackson/pom.xml b/okhttps-jackson/pom.xml index e149b9a5..f0129540 100644 --- a/okhttps-jackson/pom.xml +++ b/okhttps-jackson/pom.xml @@ -8,17 +8,20 @@ com.ejlchina okhttps-parent - 2.0.0 + ${okhttps.version} - + + com.ejlchina + okhttps + ${okhttps.version} + com.fasterxml.jackson.core jackson-core 2.11.0 - diff --git a/okhttps-kotlin/pom.xml b/okhttps-kotlin/pom.xml index 75144398..48cdb7ed 100644 --- a/okhttps-kotlin/pom.xml +++ b/okhttps-kotlin/pom.xml @@ -8,9 +8,17 @@ com.ejlchina okhttps-parent - 2.0.0 + ${okhttps.version} + + + com.ejlchina + okhttps + ${okhttps.version} + + + okhttps-kotlin diff --git a/pom.xml b/pom.xml index 77da9d24..7b815fe3 100644 --- a/pom.xml +++ b/pom.xml @@ -3,7 +3,7 @@ com.ejlchina okhttps-parent - 2.0.0 + ${okhttps.version} OkHttps pom @@ -17,6 +17,7 @@ + 2.0.0 1.8 3.14.7 1.2.67 From a3120aea77c809b14a768c9bf37155b177c41ddd Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?=E5=91=A8=E6=97=AD?= Date: Fri, 8 May 2020 20:48:44 +0800 Subject: [PATCH 208/924] =?UTF-8?q?=E5=AE=9E=E7=8E=B0=20okhttps-fastjson?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- .../com/ejlchina/okhttps/FastJsonArr.java | 97 +++++++++++++++ .../com/ejlchina/okhttps/FastJsonObj.java | 111 ++++++++++++++++++ .../com/ejlchina/okhttps/FastjsonFactory.java | 39 ++++++ 3 files changed, 247 insertions(+) create mode 100644 okhttps-fastjson/src/main/java/com/ejlchina/okhttps/FastJsonArr.java create mode 100644 okhttps-fastjson/src/main/java/com/ejlchina/okhttps/FastJsonObj.java create mode 100644 okhttps-fastjson/src/main/java/com/ejlchina/okhttps/FastjsonFactory.java diff --git a/okhttps-fastjson/src/main/java/com/ejlchina/okhttps/FastJsonArr.java b/okhttps-fastjson/src/main/java/com/ejlchina/okhttps/FastJsonArr.java new file mode 100644 index 00000000..68218a13 --- /dev/null +++ b/okhttps-fastjson/src/main/java/com/ejlchina/okhttps/FastJsonArr.java @@ -0,0 +1,97 @@ +package com.ejlchina.okhttps; + +import com.alibaba.fastjson.JSONArray; +import com.alibaba.fastjson.JSONObject; + +public class FastJsonArr implements JsonArr { + + private JSONArray json; + + public FastJsonArr(JSONArray json) { + this.json = json; + } + + @Override + public int size() { + return json.size(); + } + + @Override + public boolean isEmpty() { + return json.isEmpty(); + } + + @Override + public JsonObj getJsonOjb(int index) { + JSONObject subJson = json.getJSONObject(index); + if (subJson != null) { + return new FastJsonObj(subJson); + } + return null; + } + + @Override + public JsonArr getJsonArr(int index) { + JSONArray subJson = json.getJSONArray(index); + if (subJson != null) { + return new FastJsonArr(subJson); + } + return null; + } + + @Override + public Boolean getBool(int index) { + return json.getBoolean(index); + } + + @Override + public boolean getBoolVal(int index) { + return json.getBooleanValue(index); + } + + @Override + public Integer getInt(int index) { + return json.getInteger(index); + } + + @Override + public int getIntVal(int index) { + return json.getIntValue(index); + } + + @Override + public Short getShort(int index) { + return json.getShort(index); + } + + @Override + public short getShortVal(int index) { + return json.getShortValue(index); + } + + @Override + public Float getFloat(int index) { + return json.getFloat(index); + } + + @Override + public float getFloatVal(int index) { + return json.getFloatValue(index); + } + + @Override + public Double getDouble(int index) { + return json.getDouble(index); + } + + @Override + public double getDoubleVal(int index) { + return json.getDoubleValue(index); + } + + @Override + public String getString(int index) { + return json.getString(index); + } + +} diff --git a/okhttps-fastjson/src/main/java/com/ejlchina/okhttps/FastJsonObj.java b/okhttps-fastjson/src/main/java/com/ejlchina/okhttps/FastJsonObj.java new file mode 100644 index 00000000..217147b6 --- /dev/null +++ b/okhttps-fastjson/src/main/java/com/ejlchina/okhttps/FastJsonObj.java @@ -0,0 +1,111 @@ +package com.ejlchina.okhttps; + +import java.util.Set; + +import com.alibaba.fastjson.JSONArray; +import com.alibaba.fastjson.JSONObject; + +public class FastJsonObj implements JsonObj { + + + private JSONObject json; + + + public FastJsonObj(JSONObject json) { + this.json = json; + } + + @Override + public int size() { + return json.size(); + } + + @Override + public boolean isEmpty() { + return json.isEmpty(); + } + + @Override + public JsonObj getJsonOjb(String key) { + JSONObject subJson = json.getJSONObject(key); + if (subJson != null) { + return new FastJsonObj(subJson); + } + return null; + } + + @Override + public JsonArr getJsonArr(String key) { + JSONArray subJson = json.getJSONArray(key); + if (subJson != null) { + return new FastJsonArr(subJson); + } + return null; + } + + @Override + public Boolean getBool(String key) { + return json.getBoolean(key); + } + + @Override + public boolean getBoolVal(String key) { + return json.getBooleanValue(key); + } + + @Override + public Integer getInt(String key) { + return json.getInteger(key); + } + + @Override + public int getIntVal(String key) { + return json.getIntValue(key); + } + + @Override + public Short getShort(String key) { + return json.getShort(key); + } + + @Override + public short getShortVal(String key) { + return json.getShortValue(key); + } + + @Override + public Float getFloat(String key) { + return json.getFloat(key); + } + + @Override + public float getFloatVal(String key) { + return json.getFloatValue(key); + } + + @Override + public Double getDouble(String key) { + return json.getDouble(key); + } + + @Override + public double getDoubleVal(String key) { + return json.getDoubleValue(key); + } + + @Override + public String getString(String key) { + return json.getString(key); + } + + @Override + public boolean has(String key) { + return json.containsKey(key); + } + + @Override + public Set keySet() { + return json.keySet(); + } + +} diff --git a/okhttps-fastjson/src/main/java/com/ejlchina/okhttps/FastjsonFactory.java b/okhttps-fastjson/src/main/java/com/ejlchina/okhttps/FastjsonFactory.java new file mode 100644 index 00000000..a725fc4e --- /dev/null +++ b/okhttps-fastjson/src/main/java/com/ejlchina/okhttps/FastjsonFactory.java @@ -0,0 +1,39 @@ +package com.ejlchina.okhttps; + +import java.util.List; + +import com.alibaba.fastjson.JSON; + +public class FastjsonFactory implements JsonFactory { + + @Override + public JsonObj newJsonObj(String json) { + return new FastJsonObj(JSON.parseObject(json)); + } + + @Override + public JsonArr newJsonArr(String json) { + return new FastJsonArr(JSON.parseArray(json)); + } + + @Override + public String toJsonStr(Object bean) { + return JSON.toJSONString(bean); + } + + @Override + public String toJsonStr(Object bean, String dateFormat) { + return JSON.toJSONStringWithDateFormat(bean, dateFormat); + } + + @Override + public T jsonToBean(Class type, String json) { + return JSON.parseObject(json, type); + } + + @Override + public List jsonToList(Class type, String json) { + return JSON.parseArray(json, type); + } + +} From 75866b255443c0bc8ae20c54f65f63ae76d7ac11 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?=E5=91=A8=E6=97=AD?= Date: Fri, 8 May 2020 20:53:59 +0800 Subject: [PATCH 209/924] =?UTF-8?q?=E4=BC=98=E5=8C=96=E5=91=BD=E5=90=8D?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- .../okhttps/{FastjsonFactory.java => FastJsonFactory.java} | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) rename okhttps-fastjson/src/main/java/com/ejlchina/okhttps/{FastjsonFactory.java => FastJsonFactory.java} (93%) diff --git a/okhttps-fastjson/src/main/java/com/ejlchina/okhttps/FastjsonFactory.java b/okhttps-fastjson/src/main/java/com/ejlchina/okhttps/FastJsonFactory.java similarity index 93% rename from okhttps-fastjson/src/main/java/com/ejlchina/okhttps/FastjsonFactory.java rename to okhttps-fastjson/src/main/java/com/ejlchina/okhttps/FastJsonFactory.java index a725fc4e..925be7b0 100644 --- a/okhttps-fastjson/src/main/java/com/ejlchina/okhttps/FastjsonFactory.java +++ b/okhttps-fastjson/src/main/java/com/ejlchina/okhttps/FastJsonFactory.java @@ -4,7 +4,7 @@ import com.alibaba.fastjson.JSON; -public class FastjsonFactory implements JsonFactory { +public class FastJsonFactory implements JsonFactory { @Override public JsonObj newJsonObj(String json) { From 41f962bd59dd1128fe1bb15b7f3f35bfcc92d566 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?=E5=91=A8=E6=97=AD?= Date: Fri, 8 May 2020 22:30:18 +0800 Subject: [PATCH 210/924] =?UTF-8?q?=E5=AE=9E=E7=8E=B0=20okhttps-fastjson?= =?UTF-8?q?=20=E4=B8=8E=20okhttps-gson?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- .../com/ejlchina/okhttps/FastJsonArr.java | 14 ++ .../com/ejlchina/okhttps/FastJsonFactory.java | 20 +- .../com/ejlchina/okhttps/FastJsonObj.java | 14 +- .../java/com/ejlchina/okhttps/GsonArr.java | 162 ++++++++++++++++ .../com/ejlchina/okhttps/GsonFactory.java | 83 +++++++++ .../java/com/ejlchina/okhttps/GsonObj.java | 173 ++++++++++++++++++ .../com/ejlchina/okhttps/gson/TestCase.java | 121 ++++++++++++ .../java/com/ejlchina/okhttps/JsonArr.java | 15 ++ .../java/com/ejlchina/okhttps/JsonObj.java | 14 ++ 9 files changed, 610 insertions(+), 6 deletions(-) create mode 100644 okhttps-gson/src/main/java/com/ejlchina/okhttps/GsonArr.java create mode 100644 okhttps-gson/src/main/java/com/ejlchina/okhttps/GsonFactory.java create mode 100644 okhttps-gson/src/main/java/com/ejlchina/okhttps/GsonObj.java diff --git a/okhttps-fastjson/src/main/java/com/ejlchina/okhttps/FastJsonArr.java b/okhttps-fastjson/src/main/java/com/ejlchina/okhttps/FastJsonArr.java index 68218a13..81c178bb 100644 --- a/okhttps-fastjson/src/main/java/com/ejlchina/okhttps/FastJsonArr.java +++ b/okhttps-fastjson/src/main/java/com/ejlchina/okhttps/FastJsonArr.java @@ -1,5 +1,8 @@ package com.ejlchina.okhttps; +import java.math.BigDecimal; +import java.math.BigInteger; + import com.alibaba.fastjson.JSONArray; import com.alibaba.fastjson.JSONObject; @@ -94,4 +97,15 @@ public String getString(int index) { return json.getString(index); } + @Override + public BigDecimal getBigDecimal(int index) { + // TODO Auto-generated method stub + return json.getBigDecimal(index); + } + + @Override + public BigInteger getBigInteger(int index) { + return json.getBigInteger(index); + } + } diff --git a/okhttps-fastjson/src/main/java/com/ejlchina/okhttps/FastJsonFactory.java b/okhttps-fastjson/src/main/java/com/ejlchina/okhttps/FastJsonFactory.java index 925be7b0..26fd8b4f 100644 --- a/okhttps-fastjson/src/main/java/com/ejlchina/okhttps/FastJsonFactory.java +++ b/okhttps-fastjson/src/main/java/com/ejlchina/okhttps/FastJsonFactory.java @@ -8,12 +8,18 @@ public class FastJsonFactory implements JsonFactory { @Override public JsonObj newJsonObj(String json) { - return new FastJsonObj(JSON.parseObject(json)); + if (json != null) { + return new FastJsonObj(JSON.parseObject(json)); + } + return null; } @Override public JsonArr newJsonArr(String json) { - return new FastJsonArr(JSON.parseArray(json)); + if (json != null) { + return new FastJsonArr(JSON.parseArray(json)); + } + return null; } @Override @@ -28,12 +34,18 @@ public String toJsonStr(Object bean, String dateFormat) { @Override public T jsonToBean(Class type, String json) { - return JSON.parseObject(json, type); + if (json != null) { + return JSON.parseObject(json, type); + } + return null; } @Override public List jsonToList(Class type, String json) { - return JSON.parseArray(json, type); + if (json != null) { + return JSON.parseArray(json, type); + } + return null; } } diff --git a/okhttps-fastjson/src/main/java/com/ejlchina/okhttps/FastJsonObj.java b/okhttps-fastjson/src/main/java/com/ejlchina/okhttps/FastJsonObj.java index 217147b6..2eb401b9 100644 --- a/okhttps-fastjson/src/main/java/com/ejlchina/okhttps/FastJsonObj.java +++ b/okhttps-fastjson/src/main/java/com/ejlchina/okhttps/FastJsonObj.java @@ -1,5 +1,7 @@ package com.ejlchina.okhttps; +import java.math.BigDecimal; +import java.math.BigInteger; import java.util.Set; import com.alibaba.fastjson.JSONArray; @@ -7,10 +9,8 @@ public class FastJsonObj implements JsonObj { - private JSONObject json; - public FastJsonObj(JSONObject json) { this.json = json; } @@ -98,6 +98,16 @@ public String getString(String key) { return json.getString(key); } + @Override + public BigDecimal getBigDecimal(String key) { + return json.getBigDecimal(key); + } + + @Override + public BigInteger getBigInteger(String key) { + return json.getBigInteger(key); + } + @Override public boolean has(String key) { return json.containsKey(key); diff --git a/okhttps-gson/src/main/java/com/ejlchina/okhttps/GsonArr.java b/okhttps-gson/src/main/java/com/ejlchina/okhttps/GsonArr.java new file mode 100644 index 00000000..8d77e4bb --- /dev/null +++ b/okhttps-gson/src/main/java/com/ejlchina/okhttps/GsonArr.java @@ -0,0 +1,162 @@ +package com.ejlchina.okhttps; + +import java.math.BigDecimal; +import java.math.BigInteger; + +import com.google.gson.JsonArray; +import com.google.gson.JsonElement; + +public class GsonArr implements JsonArr { + + private JsonArray json; + + public GsonArr(JsonArray json) { + this.json = json; + } + + @Override + public int size() { + return json.size(); + } + + @Override + public boolean isEmpty() { + return json.size() == 0; + } + + @Override + public JsonObj getJsonOjb(int index) { + JsonElement subJson = json.get(index); + if (subJson != null) { + return new GsonObj(subJson.getAsJsonObject()); + } + return null; + } + + @Override + public JsonArr getJsonArr(int index) { + JsonElement subJson = json.get(index); + if (subJson != null) { + return new GsonArr(subJson.getAsJsonArray()); + } + return null; + } + + @Override + public Boolean getBool(int index) { + JsonElement val = json.get(index); + if (val != null) { + return val.getAsBoolean(); + } + return null; + } + + @Override + public boolean getBoolVal(int index) { + JsonElement val = json.get(index); + if (val != null) { + return val.getAsBoolean(); + } + return false; + } + + @Override + public Integer getInt(int index) { + JsonElement val = json.get(index); + if (val != null) { + return val.getAsInt(); + } + return null; + } + + @Override + public int getIntVal(int index) { + JsonElement val = json.get(index); + if (val != null) { + return val.getAsInt(); + } + return 0; + } + + @Override + public Short getShort(int index) { + JsonElement val = json.get(index); + if (val != null) { + return val.getAsShort(); + } + return null; + } + + @Override + public short getShortVal(int index) { + JsonElement val = json.get(index); + if (val != null) { + return val.getAsShort(); + } + return 0; + } + + @Override + public Float getFloat(int index) { + JsonElement val = json.get(index); + if (val != null) { + return val.getAsFloat(); + } + return null; + } + + @Override + public float getFloatVal(int index) { + JsonElement val = json.get(index); + if (val != null) { + return val.getAsFloat(); + } + return 0; + } + + @Override + public Double getDouble(int index) { + JsonElement val = json.get(index); + if (val != null) { + return val.getAsDouble(); + } + return null; + } + + @Override + public double getDoubleVal(int index) { + JsonElement val = json.get(index); + if (val != null) { + return val.getAsDouble(); + } + return 0; + } + + @Override + public String getString(int index) { + JsonElement val = json.get(index); + if (val != null) { + return val.getAsString(); + } + return null; + } + + @Override + public BigDecimal getBigDecimal(int index) { + JsonElement val = json.get(index); + if (val != null) { + return val.getAsBigDecimal(); + } + return null; + } + + @Override + public BigInteger getBigInteger(int index) { + JsonElement val = json.get(index); + if (val != null) { + return val.getAsBigInteger(); + } + return null; + } + +} diff --git a/okhttps-gson/src/main/java/com/ejlchina/okhttps/GsonFactory.java b/okhttps-gson/src/main/java/com/ejlchina/okhttps/GsonFactory.java new file mode 100644 index 00000000..5a581534 --- /dev/null +++ b/okhttps-gson/src/main/java/com/ejlchina/okhttps/GsonFactory.java @@ -0,0 +1,83 @@ +package com.ejlchina.okhttps; + +import java.util.ArrayList; +import java.util.Collections; +import java.util.List; + +import com.google.gson.Gson; +import com.google.gson.JsonArray; +import com.google.gson.JsonObject; +import com.google.gson.reflect.TypeToken; + +public class GsonFactory implements JsonFactory { + + private final Gson gson; + + public GsonFactory() { + this(new Gson()); + } + + public GsonFactory(Gson gson) { + this.gson = gson; + } + + @Override + public JsonObj newJsonObj(String json) { + if (json != null) { + return new GsonObj(gson.fromJson(json, JsonObject.class)); + } + return null; + } + + @Override + public JsonArr newJsonArr(String json) { + if (json != null) { + return new GsonArr(gson.fromJson(json, JsonArray.class)); + } + return null; + } + + @Override + public String toJsonStr(Object bean) { + return gson.toJson(bean); + } + + @Override + public String toJsonStr(Object bean, String dateFormat) { + return gson.newBuilder().setDateFormat(dateFormat).create().toJson(bean); + } + + @Override + public T jsonToBean(Class type, String json) { + if (json != null) { + return gson.fromJson(json, type); + } + return null; + } + + @Override + public List jsonToList(Class type, String json) { + if (json != null) { + T[] beans = gson.fromJson(json, TypeToken.getArray(type).getType()); + List list = new ArrayList<>(); + Collections.addAll(list, beans); + return list; + } + return null; + } + +} + + + + + + + + + + + + + + diff --git a/okhttps-gson/src/main/java/com/ejlchina/okhttps/GsonObj.java b/okhttps-gson/src/main/java/com/ejlchina/okhttps/GsonObj.java new file mode 100644 index 00000000..744c6aa5 --- /dev/null +++ b/okhttps-gson/src/main/java/com/ejlchina/okhttps/GsonObj.java @@ -0,0 +1,173 @@ +package com.ejlchina.okhttps; + +import java.math.BigDecimal; +import java.math.BigInteger; +import java.util.Set; + +import com.google.gson.JsonElement; +import com.google.gson.JsonObject; + +public class GsonObj implements JsonObj { + + private JsonObject json; + + public GsonObj(JsonObject json) { + this.json = json; + } + + @Override + public int size() { + return json.size(); + } + + @Override + public boolean isEmpty() { + return json.size() == 0; + } + + @Override + public JsonObj getJsonOjb(String key) { + JsonElement subJson = json.get(key); + if (subJson != null) { + return new GsonObj(subJson.getAsJsonObject()); + } + return null; + } + + @Override + public JsonArr getJsonArr(String key) { + JsonElement subJson = json.get(key); + if (subJson != null) { + return new GsonArr(subJson.getAsJsonArray()); + } + return null; + } + + @Override + public Boolean getBool(String key) { + JsonElement val = json.get(key); + if (val != null) { + return val.getAsBoolean(); + } + return null; + } + + @Override + public boolean getBoolVal(String key) { + JsonElement val = json.get(key); + if (val != null) { + return val.getAsBoolean(); + } + return false; + } + + @Override + public Integer getInt(String key) { + JsonElement val = json.get(key); + if (val != null) { + return val.getAsInt(); + } + return null; + } + + @Override + public int getIntVal(String key) { + JsonElement val = json.get(key); + if (val != null) { + return val.getAsInt(); + } + return 0; + } + + @Override + public Short getShort(String key) { + JsonElement val = json.get(key); + if (val != null) { + return val.getAsShort(); + } + return null; + } + + @Override + public short getShortVal(String key) { + JsonElement val = json.get(key); + if (val != null) { + return val.getAsShort(); + } + return 0; + } + + @Override + public Float getFloat(String key) { + JsonElement val = json.get(key); + if (val != null) { + return val.getAsFloat(); + } + return null; + } + + @Override + public float getFloatVal(String key) { + JsonElement val = json.get(key); + if (val != null) { + return val.getAsFloat(); + } + return 0; + } + + @Override + public Double getDouble(String key) { + JsonElement val = json.get(key); + if (val != null) { + return val.getAsDouble(); + } + return null; + } + + @Override + public double getDoubleVal(String key) { + JsonElement val = json.get(key); + if (val != null) { + return val.getAsDouble(); + } + return 0; + } + + @Override + public String getString(String key) { + JsonElement val = json.get(key); + if (val != null) { + return val.getAsString(); + } + return null; + } + + @Override + public BigDecimal getBigDecimal(String key) { + JsonElement val = json.get(key); + if (val != null) { + return val.getAsBigDecimal(); + } + return null; + } + + @Override + public BigInteger getBigInteger(String key) { + JsonElement val = json.get(key); + if (val != null) { + return val.getAsBigInteger(); + } + return null; + } + + @Override + public boolean has(String key) { + return json.has(key); + } + + @Override + public Set keySet() { + return json.keySet(); + } + +} diff --git a/okhttps-gson/src/test/java/com/ejlchina/okhttps/gson/TestCase.java b/okhttps-gson/src/test/java/com/ejlchina/okhttps/gson/TestCase.java index 9611f79c..beb3d645 100644 --- a/okhttps-gson/src/test/java/com/ejlchina/okhttps/gson/TestCase.java +++ b/okhttps-gson/src/test/java/com/ejlchina/okhttps/gson/TestCase.java @@ -1,12 +1,133 @@ package com.ejlchina.okhttps.gson; +import java.util.ArrayList; +import java.util.Collections; +import java.util.Date; +import java.util.List; + import org.junit.Test; +import com.google.gson.Gson; +import com.google.gson.JsonArray; +import com.google.gson.JsonObject; +import com.google.gson.reflect.TypeToken; + public class TestCase { + + Gson gson = new Gson(); + @Test public void test() { + + User u1 = new User(1, "Tom"); + User u2 = new User(2, "Jack"); + List list = new ArrayList<>(); + list.add(u1); + list.add(u2); + + String json = gson.toJson(list); + + System.out.println("json = " + json); + +// User[] users = gson.fromJson(json, TypeToken.getArray(User.class).getType()); + + List users = jsonToList(User.class, json); + + System.out.println(users.get(0)); + System.out.println(users.get(0)); + } + + @Test + public void test2() { + User u1 = new User(1, "Tom"); + System.out.println(toJsonStr(u1, "yyyy-MM-dd HH:mm:ss")); + } + + @Test + public void test3() { + User u1 = new User(1, "Tom"); + String json = gson.toJson(u1); + System.out.println(json); + + JsonObject jsonObj = gson.fromJson(json, JsonObject.class); + + System.out.println(jsonObj); + System.out.println(jsonObj.get("id").getAsInt()); + System.out.println(jsonObj.get("name").getAsString()); + } + + @Test + public void test4() { + User u1 = new User(1, "Tom"); + User u2 = new User(2, "Jack"); + List list = new ArrayList<>(); + list.add(u1); + list.add(u2); + + String json = gson.toJson(list); + + JsonArray jsonArr = gson.fromJson(json, JsonArray.class); + + System.out.println(jsonArr); + System.out.println(jsonArr.get(0)); + System.out.println(jsonArr.get(1)); + } + + public List jsonToList(Class type, String json) { + T[] objs = gson.fromJson(json, TypeToken.getArray(type).getType()); + List list = new ArrayList<>(); + Collections.addAll(list, objs); + return list; + } + + + public String toJsonStr(Object bean, String dateFormat) { + return gson.newBuilder().setDateFormat(dateFormat).create().toJson(bean); + } + + + public static class User { + + private int id; + private String name; + private Date date = new Date(); + + public User() { + } + + public User(int id, String name) { + this.id = id; + this.name = name; + } + + public int getId() { + return id; + } + public void setId(int id) { + this.id = id; + } + public String getName() { + return name; + } + public void setName(String name) { + this.name = name; + } + + public Date getDate() { + return date; + } + + public void setDate(Date date) { + this.date = date; + } + + @Override + public String toString() { + return "User [id=" + id + ", name=" + name + ", date=" + date + "]"; + } + } } diff --git a/okhttps/src/main/java/com/ejlchina/okhttps/JsonArr.java b/okhttps/src/main/java/com/ejlchina/okhttps/JsonArr.java index f297a2d5..0f2ecbe0 100644 --- a/okhttps/src/main/java/com/ejlchina/okhttps/JsonArr.java +++ b/okhttps/src/main/java/com/ejlchina/okhttps/JsonArr.java @@ -1,5 +1,8 @@ package com.ejlchina.okhttps; +import java.math.BigDecimal; +import java.math.BigInteger; + public interface JsonArr { /** @@ -90,4 +93,16 @@ public interface JsonArr { */ String getString(int index); + /** + * @param key 键名 + * @return BigDecimal 值 + */ + BigDecimal getBigDecimal(int index); + + /** + * @param key 键名 + * @return BigInteger 值 + */ + BigInteger getBigInteger(int index); + } diff --git a/okhttps/src/main/java/com/ejlchina/okhttps/JsonObj.java b/okhttps/src/main/java/com/ejlchina/okhttps/JsonObj.java index 609dabee..0eecbac5 100644 --- a/okhttps/src/main/java/com/ejlchina/okhttps/JsonObj.java +++ b/okhttps/src/main/java/com/ejlchina/okhttps/JsonObj.java @@ -1,5 +1,7 @@ package com.ejlchina.okhttps; +import java.math.BigDecimal; +import java.math.BigInteger; import java.util.Set; /** @@ -97,6 +99,18 @@ public interface JsonObj { */ String getString(String key); + /** + * @param key 键名 + * @return BigDecimal 值 + */ + BigDecimal getBigDecimal(String key); + + /** + * @param key 键名 + * @return BigInteger 值 + */ + BigInteger getBigInteger(String key); + /** * @param key 键名 * @return 是否有该键 From 650bafb236652c47e6a7bf757da66fee8f419c54 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?=E5=91=A8=E6=97=AD?= Date: Sat, 9 May 2020 00:04:50 +0800 Subject: [PATCH 211/924] =?UTF-8?q?=E7=89=88=E6=9C=AC?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- okhttps-gson/pom.xml | 2 +- okhttps-jackson/pom.xml | 6 +++--- pom.xml | 2 ++ 3 files changed, 6 insertions(+), 4 deletions(-) diff --git a/okhttps-gson/pom.xml b/okhttps-gson/pom.xml index 8add3318..7d511711 100644 --- a/okhttps-gson/pom.xml +++ b/okhttps-gson/pom.xml @@ -20,7 +20,7 @@ com.google.code.gson gson - 2.8.6 + ${gson.version} diff --git a/okhttps-jackson/pom.xml b/okhttps-jackson/pom.xml index f0129540..381ca8d1 100644 --- a/okhttps-jackson/pom.xml +++ b/okhttps-jackson/pom.xml @@ -17,10 +17,10 @@ okhttps ${okhttps.version} - + com.fasterxml.jackson.core - jackson-core - 2.11.0 + jackson-databind + ${jackson.version} diff --git a/pom.xml b/pom.xml index 7b815fe3..59c0f71d 100644 --- a/pom.xml +++ b/pom.xml @@ -20,7 +20,9 @@ 2.0.0 1.8 3.14.7 + 2.8.6 1.2.67 + 2.11.0 4.12 UTF-8 https://oss.sonatype.org/content/repositories/snapshots/ From e86855674e93f043daa5dd69745ce6a56af88759 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?=E5=91=A8=E6=97=AD?= Date: Sat, 9 May 2020 00:05:10 +0800 Subject: [PATCH 212/924] =?UTF-8?q?=E9=9B=86=E6=88=90=20Jackson?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- .../ejlchina/okhttps/{gson => }/TestCase.java | 2 +- .../java/com/ejlchina/okhttps/JacksonArr.java | 110 ++++++++++++++++ .../com/ejlchina/okhttps/JacksonFactory.java | 83 ++++++++++++ .../java/com/ejlchina/okhttps/JacksonObj.java | 123 ++++++++++++++++++ .../java/com/ejlchina/okhttps/TestCase.java | 117 +++++++++++++++++ 5 files changed, 434 insertions(+), 1 deletion(-) rename okhttps-gson/src/test/java/com/ejlchina/okhttps/{gson => }/TestCase.java (98%) create mode 100644 okhttps-jackson/src/main/java/com/ejlchina/okhttps/JacksonArr.java create mode 100644 okhttps-jackson/src/main/java/com/ejlchina/okhttps/JacksonFactory.java create mode 100644 okhttps-jackson/src/main/java/com/ejlchina/okhttps/JacksonObj.java create mode 100644 okhttps-jackson/src/test/java/com/ejlchina/okhttps/TestCase.java diff --git a/okhttps-gson/src/test/java/com/ejlchina/okhttps/gson/TestCase.java b/okhttps-gson/src/test/java/com/ejlchina/okhttps/TestCase.java similarity index 98% rename from okhttps-gson/src/test/java/com/ejlchina/okhttps/gson/TestCase.java rename to okhttps-gson/src/test/java/com/ejlchina/okhttps/TestCase.java index beb3d645..232d096b 100644 --- a/okhttps-gson/src/test/java/com/ejlchina/okhttps/gson/TestCase.java +++ b/okhttps-gson/src/test/java/com/ejlchina/okhttps/TestCase.java @@ -1,4 +1,4 @@ -package com.ejlchina.okhttps.gson; +package com.ejlchina.okhttps; import java.util.ArrayList; import java.util.Collections; diff --git a/okhttps-jackson/src/main/java/com/ejlchina/okhttps/JacksonArr.java b/okhttps-jackson/src/main/java/com/ejlchina/okhttps/JacksonArr.java new file mode 100644 index 00000000..c33a19a7 --- /dev/null +++ b/okhttps-jackson/src/main/java/com/ejlchina/okhttps/JacksonArr.java @@ -0,0 +1,110 @@ +package com.ejlchina.okhttps; + +import java.math.BigDecimal; +import java.math.BigInteger; + +public class JacksonArr implements JsonArr { + + @Override + public int size() { + // TODO Auto-generated method stub + return 0; + } + + @Override + public boolean isEmpty() { + // TODO Auto-generated method stub + return false; + } + + @Override + public JsonObj getJsonOjb(int index) { + // TODO Auto-generated method stub + return null; + } + + @Override + public JsonArr getJsonArr(int index) { + // TODO Auto-generated method stub + return null; + } + + @Override + public Boolean getBool(int index) { + // TODO Auto-generated method stub + return null; + } + + @Override + public boolean getBoolVal(int index) { + // TODO Auto-generated method stub + return false; + } + + @Override + public Integer getInt(int index) { + // TODO Auto-generated method stub + return null; + } + + @Override + public int getIntVal(int index) { + // TODO Auto-generated method stub + return 0; + } + + @Override + public Short getShort(int index) { + // TODO Auto-generated method stub + return null; + } + + @Override + public short getShortVal(int index) { + // TODO Auto-generated method stub + return 0; + } + + @Override + public Float getFloat(int index) { + // TODO Auto-generated method stub + return null; + } + + @Override + public float getFloatVal(int index) { + // TODO Auto-generated method stub + return 0; + } + + @Override + public Double getDouble(int index) { + // TODO Auto-generated method stub + return null; + } + + @Override + public double getDoubleVal(int index) { + // TODO Auto-generated method stub + return 0; + } + + @Override + public String getString(int index) { + // TODO Auto-generated method stub + return null; + } + + @Override + public BigDecimal getBigDecimal(int index) { + // TODO Auto-generated method stub + return null; + } + + @Override + public BigInteger getBigInteger(int index) { + // TODO Auto-generated method stub + return null; + } + +} diff --git a/okhttps-jackson/src/main/java/com/ejlchina/okhttps/JacksonFactory.java b/okhttps-jackson/src/main/java/com/ejlchina/okhttps/JacksonFactory.java new file mode 100644 index 00000000..93fbb78d --- /dev/null +++ b/okhttps-jackson/src/main/java/com/ejlchina/okhttps/JacksonFactory.java @@ -0,0 +1,83 @@ +package com.ejlchina.okhttps; + +import java.text.SimpleDateFormat; +import java.util.ArrayList; +import java.util.List; + +import com.ejlchina.okhttps.internal.HttpException; +import com.fasterxml.jackson.core.JsonProcessingException; +import com.fasterxml.jackson.databind.ObjectMapper; +import com.fasterxml.jackson.databind.SerializationFeature; +import com.fasterxml.jackson.databind.type.CollectionType; + +public class JacksonFactory implements JsonFactory { + + private ObjectMapper objectMapper; + + public JacksonFactory() { + this(new ObjectMapper()); + } + + public JacksonFactory(ObjectMapper objectMapper) { + this.objectMapper = objectMapper; + } + + @Override + public JsonObj newJsonObj(String json) { + // TODO Auto-generated method stub + return null; + } + + @Override + public JsonArr newJsonArr(String json) { + // TODO Auto-generated method stub + return null; + } + + @Override + public String toJsonStr(Object bean) { + try { + return objectMapper.writeValueAsString(bean); + } catch (JsonProcessingException e) { + throw new HttpException("Java Bean [" + bean + "] Jackson 序列化异常", e); + } + } + + @Override + public String toJsonStr(Object bean, String dateFormat) { + ObjectMapper mapper = objectMapper.copy(); + mapper.configure(SerializationFeature.WRITE_DATES_AS_TIMESTAMPS, false); + mapper.setDateFormat(new SimpleDateFormat(dateFormat)); + try { + return mapper.writeValueAsString(bean); + } catch (JsonProcessingException e) { + throw new HttpException("Java Bean [" + bean + "] Jackson 序列化异常", e); + } + } + + @Override + public T jsonToBean(Class type, String json) { + if (json != null) { + try { + return objectMapper.readValue(json, type); + } catch (JsonProcessingException e) { + throw new HttpException("Jackson 解析异常：" + json, e); + } + } + return null; + } + + @Override + public List jsonToList(Class type, String json) { + if (json != null) { + CollectionType javaType = objectMapper.getTypeFactory().constructCollectionType(ArrayList.class, type); + try { + return objectMapper.readValue(json, javaType); + } catch (JsonProcessingException e) { + throw new HttpException("Jackson 解析异常：" + json, e); + } + } + return null; + } + +} diff --git a/okhttps-jackson/src/main/java/com/ejlchina/okhttps/JacksonObj.java b/okhttps-jackson/src/main/java/com/ejlchina/okhttps/JacksonObj.java new file mode 100644 index 00000000..fed71eea --- /dev/null +++ b/okhttps-jackson/src/main/java/com/ejlchina/okhttps/JacksonObj.java @@ -0,0 +1,123 @@ +package com.ejlchina.okhttps; + +import java.math.BigDecimal; +import java.math.BigInteger; +import java.util.Set; + +public class JacksonObj implements JsonObj { + + @Override + public int size() { + // TODO Auto-generated method stub + return 0; + } + + @Override + public boolean isEmpty() { + // TODO Auto-generated method stub + return false; + } + + @Override + public JsonObj getJsonOjb(String key) { + // TODO Auto-generated method stub + return null; + } + + @Override + public JsonArr getJsonArr(String key) { + // TODO Auto-generated method stub + return null; + } + + @Override + public Boolean getBool(String key) { + // TODO Auto-generated method stub + return null; + } + + @Override + public boolean getBoolVal(String key) { + // TODO Auto-generated method stub + return false; + } + + @Override + public Integer getInt(String key) { + // TODO Auto-generated method stub + return null; + } + + @Override + public int getIntVal(String key) { + // TODO Auto-generated method stub + return 0; + } + + @Override + public Short getShort(String key) { + // TODO Auto-generated method stub + return null; + } + + @Override + public short getShortVal(String key) { + // TODO Auto-generated method stub + return 0; + } + + @Override + public Float getFloat(String key) { + // TODO Auto-generated method stub + return null; + } + + @Override + public float getFloatVal(String key) { + // TODO Auto-generated method stub + return 0; + } + + @Override + public Double getDouble(String key) { + // TODO Auto-generated method stub + return null; + } + + @Override + public double getDoubleVal(String key) { + // TODO Auto-generated method stub + return 0; + } + + @Override + public String getString(String key) { + // TODO Auto-generated method stub + return null; + } + + @Override + public BigDecimal getBigDecimal(String key) { + // TODO Auto-generated method stub + return null; + } + + @Override + public BigInteger getBigInteger(String key) { + // TODO Auto-generated method stub + return null; + } + + @Override + public boolean has(String key) { + // TODO Auto-generated method stub + return false; + } + + @Override + public Set keySet() { + // TODO Auto-generated method stub + return null; + } + +} diff --git a/okhttps-jackson/src/test/java/com/ejlchina/okhttps/TestCase.java b/okhttps-jackson/src/test/java/com/ejlchina/okhttps/TestCase.java new file mode 100644 index 00000000..41d7dfce --- /dev/null +++ b/okhttps-jackson/src/test/java/com/ejlchina/okhttps/TestCase.java @@ -0,0 +1,117 @@ +package com.ejlchina.okhttps; + +import java.text.SimpleDateFormat; +import java.util.ArrayList; +import java.util.Date; +import java.util.List; + +import org.junit.Test; + +import com.ejlchina.okhttps.internal.HttpException; +import com.fasterxml.jackson.core.JsonProcessingException; +import com.fasterxml.jackson.databind.ObjectMapper; +import com.fasterxml.jackson.databind.SerializationFeature; +import com.fasterxml.jackson.databind.type.CollectionType; + +public class TestCase { + + + ObjectMapper objectMapper = new ObjectMapper(); + + @Test + public void test() throws JsonProcessingException { + + User u1 = new User(1, "Tom"); + + ObjectMapper mapper = objectMapper.copy(); + + mapper.configure(SerializationFeature.WRITE_DATES_AS_TIMESTAMPS, false); + + mapper.setDateFormat(new SimpleDateFormat("yyyy-MM-dd HH:mm:ss")); + + String json = mapper.writeValueAsString(u1); + + System.out.println("json = " + json); + + json = objectMapper.writeValueAsString(u1); + + System.out.println("json = " + json); + } + + + @Test + public void test1() throws JsonProcessingException { + + User u1 = new User(1, "Tom"); + User u2 = new User(2, "Jack"); + List list = new ArrayList<>(); + list.add(u1); + list.add(u2); + + String json = objectMapper.writeValueAsString(list); + + System.out.println("json = " + json); + + List nlist = jsonToList(User.class, json); + + System.out.println(nlist); + } + + + + public List jsonToList(Class type, String json) { + if (json != null) { + CollectionType javaType = objectMapper.getTypeFactory().constructCollectionType(ArrayList.class, type); + try { + return objectMapper.readValue(json, javaType); + } catch (JsonProcessingException e) { + throw new HttpException("Jackson 解析异常：" + json, e); + } + } + return null; + } + + + public static class User { + + private int id; + private String name; + private Date date = new Date(); + + public User() { + } + + public User(int id, String name) { + this.id = id; + this.name = name; + } + + public int getId() { + return id; + } + public void setId(int id) { + this.id = id; + } + public String getName() { + return name; + } + public void setName(String name) { + this.name = name; + } + + public Date getDate() { + return date; + } + + public void setDate(Date date) { + this.date = date; + } + + @Override + public String toString() { + return "User [id=" + id + ", name=" + name + ", date=" + date + "]"; + } + + } + +} From 60e598056e608bd8dc975c7c442be310b8e99d39 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?=E5=91=A8=E6=97=AD?= Date: Sat, 9 May 2020 11:49:09 +0800 Subject: [PATCH 213/924] =?UTF-8?q?=E5=AE=9E=E7=8E=B0=20okhttp-jackson?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- .../com/ejlchina/okhttps/FastJsonArr.java | 39 +----- .../com/ejlchina/okhttps/FastJsonFactory.java | 61 ++++++--- .../com/ejlchina/okhttps/FastJsonObj.java | 38 +----- .../java/com/ejlchina/okhttps/GsonArr.java | 62 +-------- .../com/ejlchina/okhttps/GsonFactory.java | 46 ++++--- .../java/com/ejlchina/okhttps/GsonObj.java | 62 +-------- .../java/com/ejlchina/okhttps/JacksonArr.java | 105 ++++++++-------- .../com/ejlchina/okhttps/JacksonFactory.java | 73 +++++++---- .../java/com/ejlchina/okhttps/JacksonObj.java | 118 +++++++++--------- .../java/com/ejlchina/okhttps/JsonArr.java | 44 +------ .../com/ejlchina/okhttps/JsonFactory.java | 25 ++-- .../java/com/ejlchina/okhttps/JsonObj.java | 44 +------ .../ejlchina/okhttps/internal/ResultBody.java | 8 +- 13 files changed, 269 insertions(+), 456 deletions(-) diff --git a/okhttps-fastjson/src/main/java/com/ejlchina/okhttps/FastJsonArr.java b/okhttps-fastjson/src/main/java/com/ejlchina/okhttps/FastJsonArr.java index 81c178bb..e116c378 100644 --- a/okhttps-fastjson/src/main/java/com/ejlchina/okhttps/FastJsonArr.java +++ b/okhttps-fastjson/src/main/java/com/ejlchina/okhttps/FastJsonArr.java @@ -43,52 +43,22 @@ public JsonArr getJsonArr(int index) { } @Override - public Boolean getBool(int index) { - return json.getBoolean(index); - } - - @Override - public boolean getBoolVal(int index) { + public boolean getBool(int index) { return json.getBooleanValue(index); } @Override - public Integer getInt(int index) { - return json.getInteger(index); - } - - @Override - public int getIntVal(int index) { + public int getInt(int index) { return json.getIntValue(index); } @Override - public Short getShort(int index) { - return json.getShort(index); - } - - @Override - public short getShortVal(int index) { - return json.getShortValue(index); - } - - @Override - public Float getFloat(int index) { - return json.getFloat(index); - } - - @Override - public float getFloatVal(int index) { + public float getFloat(int index) { return json.getFloatValue(index); } @Override - public Double getDouble(int index) { - return json.getDouble(index); - } - - @Override - public double getDoubleVal(int index) { + public double getDouble(int index) { return json.getDoubleValue(index); } @@ -99,7 +69,6 @@ public String getString(int index) { @Override public BigDecimal getBigDecimal(int index) { - // TODO Auto-generated method stub return json.getBigDecimal(index); } diff --git a/okhttps-fastjson/src/main/java/com/ejlchina/okhttps/FastJsonFactory.java b/okhttps-fastjson/src/main/java/com/ejlchina/okhttps/FastJsonFactory.java index 26fd8b4f..bfbcc84f 100644 --- a/okhttps-fastjson/src/main/java/com/ejlchina/okhttps/FastJsonFactory.java +++ b/okhttps-fastjson/src/main/java/com/ejlchina/okhttps/FastJsonFactory.java @@ -1,25 +1,36 @@ package com.ejlchina.okhttps; +import java.io.IOException; +import java.io.InputStream; +import java.nio.charset.Charset; +import java.nio.charset.StandardCharsets; import java.util.List; import com.alibaba.fastjson.JSON; +import com.ejlchina.okhttps.internal.HttpException; + +import okio.Okio; public class FastJsonFactory implements JsonFactory { + private Charset charset; + + public FastJsonFactory() { + this(StandardCharsets.UTF_8); + } + + public FastJsonFactory(Charset charset) { + this.charset = charset; + } + @Override - public JsonObj newJsonObj(String json) { - if (json != null) { - return new FastJsonObj(JSON.parseObject(json)); - } - return null; + public JsonObj newJsonObj(InputStream in) { + return new FastJsonObj(JSON.parseObject(toString(in))); } @Override - public JsonArr newJsonArr(String json) { - if (json != null) { - return new FastJsonArr(JSON.parseArray(json)); - } - return null; + public JsonArr newJsonArr(InputStream in) { + return new FastJsonArr(JSON.parseArray(toString(in))); } @Override @@ -33,19 +44,33 @@ public String toJsonStr(Object bean, String dateFormat) { } @Override - public T jsonToBean(Class type, String json) { - if (json != null) { - return JSON.parseObject(json, type); + public T jsonToBean(Class type, InputStream in) { + try { + return JSON.parseObject(in, type); + } catch (IOException e) { + throw new HttpException("读取文本异常", e); } - return null; } @Override - public List jsonToList(Class type, String json) { - if (json != null) { - return JSON.parseArray(json, type); + public List jsonToList(Class type, InputStream in) { + return JSON.parseArray(toString(in), type); + } + + private String toString(InputStream in) { + try { + return Okio.buffer(Okio.source(in)).readString(charset); + } catch (IOException e) { + throw new HttpException("读取文本异常", e); } - return null; + } + + public Charset getCharset() { + return charset; + } + + public void setCharset(Charset charset) { + this.charset = charset; } } diff --git a/okhttps-fastjson/src/main/java/com/ejlchina/okhttps/FastJsonObj.java b/okhttps-fastjson/src/main/java/com/ejlchina/okhttps/FastJsonObj.java index 2eb401b9..484b32c9 100644 --- a/okhttps-fastjson/src/main/java/com/ejlchina/okhttps/FastJsonObj.java +++ b/okhttps-fastjson/src/main/java/com/ejlchina/okhttps/FastJsonObj.java @@ -44,52 +44,22 @@ public JsonArr getJsonArr(String key) { } @Override - public Boolean getBool(String key) { - return json.getBoolean(key); - } - - @Override - public boolean getBoolVal(String key) { + public boolean getBool(String key) { return json.getBooleanValue(key); } @Override - public Integer getInt(String key) { - return json.getInteger(key); - } - - @Override - public int getIntVal(String key) { + public int getInt(String key) { return json.getIntValue(key); } @Override - public Short getShort(String key) { - return json.getShort(key); - } - - @Override - public short getShortVal(String key) { - return json.getShortValue(key); - } - - @Override - public Float getFloat(String key) { - return json.getFloat(key); - } - - @Override - public float getFloatVal(String key) { + public float getFloat(String key) { return json.getFloatValue(key); } @Override - public Double getDouble(String key) { - return json.getDouble(key); - } - - @Override - public double getDoubleVal(String key) { + public double getDouble(String key) { return json.getDoubleValue(key); } diff --git a/okhttps-gson/src/main/java/com/ejlchina/okhttps/GsonArr.java b/okhttps-gson/src/main/java/com/ejlchina/okhttps/GsonArr.java index 8d77e4bb..a63c3e67 100644 --- a/okhttps-gson/src/main/java/com/ejlchina/okhttps/GsonArr.java +++ b/okhttps-gson/src/main/java/com/ejlchina/okhttps/GsonArr.java @@ -43,16 +43,7 @@ public JsonArr getJsonArr(int index) { } @Override - public Boolean getBool(int index) { - JsonElement val = json.get(index); - if (val != null) { - return val.getAsBoolean(); - } - return null; - } - - @Override - public boolean getBoolVal(int index) { + public boolean getBool(int index) { JsonElement val = json.get(index); if (val != null) { return val.getAsBoolean(); @@ -61,52 +52,16 @@ public boolean getBoolVal(int index) { } @Override - public Integer getInt(int index) { + public int getInt(int index) { JsonElement val = json.get(index); if (val != null) { return val.getAsInt(); } - return null; - } - - @Override - public int getIntVal(int index) { - JsonElement val = json.get(index); - if (val != null) { - return val.getAsInt(); - } - return 0; - } - - @Override - public Short getShort(int index) { - JsonElement val = json.get(index); - if (val != null) { - return val.getAsShort(); - } - return null; - } - - @Override - public short getShortVal(int index) { - JsonElement val = json.get(index); - if (val != null) { - return val.getAsShort(); - } return 0; } @Override - public Float getFloat(int index) { - JsonElement val = json.get(index); - if (val != null) { - return val.getAsFloat(); - } - return null; - } - - @Override - public float getFloatVal(int index) { + public float getFloat(int index) { JsonElement val = json.get(index); if (val != null) { return val.getAsFloat(); @@ -115,16 +70,7 @@ public float getFloatVal(int index) { } @Override - public Double getDouble(int index) { - JsonElement val = json.get(index); - if (val != null) { - return val.getAsDouble(); - } - return null; - } - - @Override - public double getDoubleVal(int index) { + public double getDouble(int index) { JsonElement val = json.get(index); if (val != null) { return val.getAsDouble(); diff --git a/okhttps-gson/src/main/java/com/ejlchina/okhttps/GsonFactory.java b/okhttps-gson/src/main/java/com/ejlchina/okhttps/GsonFactory.java index 5a581534..17f464e0 100644 --- a/okhttps-gson/src/main/java/com/ejlchina/okhttps/GsonFactory.java +++ b/okhttps-gson/src/main/java/com/ejlchina/okhttps/GsonFactory.java @@ -1,5 +1,7 @@ package com.ejlchina.okhttps; +import java.io.InputStream; +import java.io.InputStreamReader; import java.util.ArrayList; import java.util.Collections; import java.util.List; @@ -11,7 +13,7 @@ public class GsonFactory implements JsonFactory { - private final Gson gson; + private Gson gson; public GsonFactory() { this(new Gson()); @@ -22,19 +24,13 @@ public GsonFactory(Gson gson) { } @Override - public JsonObj newJsonObj(String json) { - if (json != null) { - return new GsonObj(gson.fromJson(json, JsonObject.class)); - } - return null; + public JsonObj newJsonObj(InputStream in) { + return new GsonObj(gson.fromJson(new InputStreamReader(in), JsonObject.class)); } @Override - public JsonArr newJsonArr(String json) { - if (json != null) { - return new GsonArr(gson.fromJson(json, JsonArray.class)); - } - return null; + public JsonArr newJsonArr(InputStream in) { + return new GsonArr(gson.fromJson(new InputStreamReader(in), JsonArray.class)); } @Override @@ -48,22 +44,24 @@ public String toJsonStr(Object bean, String dateFormat) { } @Override - public T jsonToBean(Class type, String json) { - if (json != null) { - return gson.fromJson(json, type); - } - return null; + public T jsonToBean(Class type, InputStream in) { + return gson.fromJson(new InputStreamReader(in), type); } @Override - public List jsonToList(Class type, String json) { - if (json != null) { - T[] beans = gson.fromJson(json, TypeToken.getArray(type).getType()); - List list = new ArrayList<>(); - Collections.addAll(list, beans); - return list; - } - return null; + public List jsonToList(Class type, InputStream in) { + T[] beans = gson.fromJson(new InputStreamReader(in), TypeToken.getArray(type).getType()); + List list = new ArrayList<>(); + Collections.addAll(list, beans); + return list; + } + + public Gson getGson() { + return gson; + } + + public void setGson(Gson gson) { + this.gson = gson; } } diff --git a/okhttps-gson/src/main/java/com/ejlchina/okhttps/GsonObj.java b/okhttps-gson/src/main/java/com/ejlchina/okhttps/GsonObj.java index 744c6aa5..5441ce81 100644 --- a/okhttps-gson/src/main/java/com/ejlchina/okhttps/GsonObj.java +++ b/okhttps-gson/src/main/java/com/ejlchina/okhttps/GsonObj.java @@ -44,16 +44,7 @@ public JsonArr getJsonArr(String key) { } @Override - public Boolean getBool(String key) { - JsonElement val = json.get(key); - if (val != null) { - return val.getAsBoolean(); - } - return null; - } - - @Override - public boolean getBoolVal(String key) { + public boolean getBool(String key) { JsonElement val = json.get(key); if (val != null) { return val.getAsBoolean(); @@ -62,52 +53,16 @@ public boolean getBoolVal(String key) { } @Override - public Integer getInt(String key) { + public int getInt(String key) { JsonElement val = json.get(key); if (val != null) { return val.getAsInt(); } - return null; - } - - @Override - public int getIntVal(String key) { - JsonElement val = json.get(key); - if (val != null) { - return val.getAsInt(); - } - return 0; - } - - @Override - public Short getShort(String key) { - JsonElement val = json.get(key); - if (val != null) { - return val.getAsShort(); - } - return null; - } - - @Override - public short getShortVal(String key) { - JsonElement val = json.get(key); - if (val != null) { - return val.getAsShort(); - } return 0; } @Override - public Float getFloat(String key) { - JsonElement val = json.get(key); - if (val != null) { - return val.getAsFloat(); - } - return null; - } - - @Override - public float getFloatVal(String key) { + public float getFloat(String key) { JsonElement val = json.get(key); if (val != null) { return val.getAsFloat(); @@ -116,16 +71,7 @@ public float getFloatVal(String key) { } @Override - public Double getDouble(String key) { - JsonElement val = json.get(key); - if (val != null) { - return val.getAsDouble(); - } - return null; - } - - @Override - public double getDoubleVal(String key) { + public double getDouble(String key) { JsonElement val = json.get(key); if (val != null) { return val.getAsDouble(); diff --git a/okhttps-jackson/src/main/java/com/ejlchina/okhttps/JacksonArr.java b/okhttps-jackson/src/main/java/com/ejlchina/okhttps/JacksonArr.java index c33a19a7..ae519f91 100644 --- a/okhttps-jackson/src/main/java/com/ejlchina/okhttps/JacksonArr.java +++ b/okhttps-jackson/src/main/java/com/ejlchina/okhttps/JacksonArr.java @@ -3,107 +3,106 @@ import java.math.BigDecimal; import java.math.BigInteger; +import com.fasterxml.jackson.databind.JsonNode; +import com.fasterxml.jackson.databind.node.ArrayNode; +import com.fasterxml.jackson.databind.node.ObjectNode; + public class JacksonArr implements JsonArr { + private ArrayNode json; + + public JacksonArr(ArrayNode json) { + this.json = json; + } + @Override public int size() { - // TODO Auto-generated method stub - return 0; + return json.size(); } @Override public boolean isEmpty() { - // TODO Auto-generated method stub - return false; + return json.isEmpty(); } @Override public JsonObj getJsonOjb(int index) { - // TODO Auto-generated method stub + JsonNode subJson = json.get(index); + if (subJson != null && subJson.isObject()) { + return new JacksonObj((ObjectNode) subJson); + } return null; } @Override public JsonArr getJsonArr(int index) { - // TODO Auto-generated method stub - return null; - } - - @Override - public Boolean getBool(int index) { - // TODO Auto-generated method stub + JsonNode subJson = json.get(index); + if (subJson != null && subJson.isArray()) { + return new JacksonArr((ArrayNode) subJson); + } return null; } @Override - public boolean getBoolVal(int index) { - // TODO Auto-generated method stub + public boolean getBool(int index) { + JsonNode subJson = json.get(index); + if (subJson != null && subJson.asBoolean()) { + return subJson.asBoolean(); + } return false; } @Override - public Integer getInt(int index) { - // TODO Auto-generated method stub - return null; - } - - @Override - public int getIntVal(int index) { - // TODO Auto-generated method stub - return 0; - } - - @Override - public Short getShort(int index) { - // TODO Auto-generated method stub - return null; - } - - @Override - public short getShortVal(int index) { - // TODO Auto-generated method stub + public int getInt(int index) { + JsonNode subJson = json.get(index); + if (subJson != null && subJson.isNumber()) { + return subJson.intValue(); + } return 0; } @Override - public Float getFloat(int index) { - // TODO Auto-generated method stub - return null; - } - - @Override - public float getFloatVal(int index) { - // TODO Auto-generated method stub + public float getFloat(int index) { + JsonNode subJson = json.get(index); + if (subJson != null && subJson.isNumber()) { + return subJson.floatValue(); + } return 0; } @Override - public Double getDouble(int index) { - // TODO Auto-generated method stub - return null; - } - - @Override - public double getDoubleVal(int index) { - // TODO Auto-generated method stub + public double getDouble(int index) { + JsonNode subJson = json.get(index); + if (subJson != null && subJson.isNumber()) { + return subJson.doubleValue(); + } return 0; } @Override public String getString(int index) { - // TODO Auto-generated method stub + JsonNode subJson = json.get(index); + if (subJson != null) { + return subJson.asText(); + } return null; } @Override public BigDecimal getBigDecimal(int index) { - // TODO Auto-generated method stub + JsonNode subJson = json.get(index); + if (subJson != null && subJson.isNumber()) { + return subJson.decimalValue(); + } return null; } @Override public BigInteger getBigInteger(int index) { - // TODO Auto-generated method stub + JsonNode subJson = json.get(index); + if (subJson != null && subJson.isNumber()) { + return subJson.bigIntegerValue(); + } return null; } diff --git a/okhttps-jackson/src/main/java/com/ejlchina/okhttps/JacksonFactory.java b/okhttps-jackson/src/main/java/com/ejlchina/okhttps/JacksonFactory.java index 93fbb78d..8fa0e7c2 100644 --- a/okhttps-jackson/src/main/java/com/ejlchina/okhttps/JacksonFactory.java +++ b/okhttps-jackson/src/main/java/com/ejlchina/okhttps/JacksonFactory.java @@ -1,13 +1,18 @@ package com.ejlchina.okhttps; +import java.io.IOException; +import java.io.InputStream; import java.text.SimpleDateFormat; import java.util.ArrayList; import java.util.List; import com.ejlchina.okhttps.internal.HttpException; import com.fasterxml.jackson.core.JsonProcessingException; +import com.fasterxml.jackson.databind.JsonNode; import com.fasterxml.jackson.databind.ObjectMapper; import com.fasterxml.jackson.databind.SerializationFeature; +import com.fasterxml.jackson.databind.node.ArrayNode; +import com.fasterxml.jackson.databind.node.ObjectNode; import com.fasterxml.jackson.databind.type.CollectionType; public class JacksonFactory implements JsonFactory { @@ -23,15 +28,35 @@ public JacksonFactory(ObjectMapper objectMapper) { } @Override - public JsonObj newJsonObj(String json) { - // TODO Auto-generated method stub - return null; + public JsonObj newJsonObj(InputStream in) { + try { + JsonNode json = objectMapper.readTree(in); + if (json.isObject()) { + return new JacksonObj((ObjectNode) json); + } + if (json.isNull() || json.isMissingNode()) { + return null; + } + throw new HttpException("不是 一个 json 对象：" + json); + } catch (IOException e) { + throw new HttpException("Jackson 解析异常", e); + } } @Override - public JsonArr newJsonArr(String json) { - // TODO Auto-generated method stub - return null; + public JsonArr newJsonArr(InputStream in) { + try { + JsonNode json = objectMapper.readTree(in); + if (json.isArray()) { + return new JacksonArr((ArrayNode) json); + } + if (json.isNull() || json.isMissingNode()) { + return null; + } + throw new HttpException("不是 一个 json 数组：" + json); + } catch (IOException e) { + throw new HttpException("Jackson 解析异常", e); + } } @Override @@ -56,28 +81,30 @@ public String toJsonStr(Object bean, String dateFormat) { } @Override - public T jsonToBean(Class type, String json) { - if (json != null) { - try { - return objectMapper.readValue(json, type); - } catch (JsonProcessingException e) { - throw new HttpException("Jackson 解析异常：" + json, e); - } + public T jsonToBean(Class type, InputStream in) { + try { + return objectMapper.readValue(in, type); + } catch (IOException e) { + throw new HttpException("Jackson 解析异常", e); } - return null; } @Override - public List jsonToList(Class type, String json) { - if (json != null) { - CollectionType javaType = objectMapper.getTypeFactory().constructCollectionType(ArrayList.class, type); - try { - return objectMapper.readValue(json, javaType); - } catch (JsonProcessingException e) { - throw new HttpException("Jackson 解析异常：" + json, e); - } + public List jsonToList(Class type, InputStream in) { + CollectionType javaType = objectMapper.getTypeFactory().constructCollectionType(ArrayList.class, type); + try { + return objectMapper.readValue(in, javaType); + } catch (IOException e) { + throw new HttpException("Jackson 解析异常", e); } - return null; + } + + public ObjectMapper getObjectMapper() { + return objectMapper; + } + + public void setObjectMapper(ObjectMapper objectMapper) { + this.objectMapper = objectMapper; } } diff --git a/okhttps-jackson/src/main/java/com/ejlchina/okhttps/JacksonObj.java b/okhttps-jackson/src/main/java/com/ejlchina/okhttps/JacksonObj.java index fed71eea..6ff76c67 100644 --- a/okhttps-jackson/src/main/java/com/ejlchina/okhttps/JacksonObj.java +++ b/okhttps-jackson/src/main/java/com/ejlchina/okhttps/JacksonObj.java @@ -2,122 +2,126 @@ import java.math.BigDecimal; import java.math.BigInteger; +import java.util.HashSet; +import java.util.Iterator; import java.util.Set; +import com.fasterxml.jackson.databind.JsonNode; +import com.fasterxml.jackson.databind.node.ArrayNode; +import com.fasterxml.jackson.databind.node.ObjectNode; + public class JacksonObj implements JsonObj { + private ObjectNode json; + + public JacksonObj(ObjectNode json) { + this.json = json; + } + @Override public int size() { - // TODO Auto-generated method stub - return 0; + return json.size(); } @Override public boolean isEmpty() { - // TODO Auto-generated method stub - return false; + return json.isEmpty(); } @Override public JsonObj getJsonOjb(String key) { - // TODO Auto-generated method stub + JsonNode subJson = json.get(key); + if (subJson != null && subJson.isObject()) { + return new JacksonObj((ObjectNode) subJson); + } return null; } @Override public JsonArr getJsonArr(String key) { - // TODO Auto-generated method stub - return null; - } - - @Override - public Boolean getBool(String key) { - // TODO Auto-generated method stub + JsonNode subJson = json.get(key); + if (subJson != null && subJson.isArray()) { + return new JacksonArr((ArrayNode) subJson); + } return null; } @Override - public boolean getBoolVal(String key) { - // TODO Auto-generated method stub + public boolean getBool(String key) { + JsonNode subJson = json.get(key); + if (subJson != null && subJson.asBoolean()) { + return subJson.asBoolean(); + } return false; } @Override - public Integer getInt(String key) { - // TODO Auto-generated method stub - return null; - } - - @Override - public int getIntVal(String key) { - // TODO Auto-generated method stub + public int getInt(String key) { + JsonNode subJson = json.get(key); + if (subJson != null && subJson.isNumber()) { + return subJson.intValue(); + } return 0; } @Override - public Short getShort(String key) { - // TODO Auto-generated method stub - return null; - } - - @Override - public short getShortVal(String key) { - // TODO Auto-generated method stub + public float getFloat(String key) { + JsonNode subJson = json.get(key); + if (subJson != null && subJson.isNumber()) { + return subJson.floatValue(); + } return 0; } @Override - public Float getFloat(String key) { - // TODO Auto-generated method stub - return null; - } - - @Override - public float getFloatVal(String key) { - // TODO Auto-generated method stub - return 0; - } - - @Override - public Double getDouble(String key) { - // TODO Auto-generated method stub - return null; - } - - @Override - public double getDoubleVal(String key) { - // TODO Auto-generated method stub + public double getDouble(String key) { + JsonNode subJson = json.get(key); + if (subJson != null && subJson.isNumber()) { + return subJson.doubleValue(); + } return 0; } @Override public String getString(String key) { - // TODO Auto-generated method stub + JsonNode subJson = json.get(key); + if (subJson != null) { + return subJson.asText(); + } return null; } @Override public BigDecimal getBigDecimal(String key) { - // TODO Auto-generated method stub + JsonNode subJson = json.get(key); + if (subJson != null && subJson.isNumber()) { + return subJson.decimalValue(); + } return null; } @Override public BigInteger getBigInteger(String key) { - // TODO Auto-generated method stub + JsonNode subJson = json.get(key); + if (subJson != null && subJson.isNumber()) { + return subJson.bigIntegerValue(); + } return null; } @Override public boolean has(String key) { - // TODO Auto-generated method stub - return false; + return json.has(key); } @Override public Set keySet() { - // TODO Auto-generated method stub - return null; + Iterator it = json.fieldNames(); + Set set = new HashSet<>(); + while (it.hasNext()) { + set.add(it.next()); + } + return set; } } diff --git a/okhttps/src/main/java/com/ejlchina/okhttps/JsonArr.java b/okhttps/src/main/java/com/ejlchina/okhttps/JsonArr.java index 0f2ecbe0..97c1fe43 100644 --- a/okhttps/src/main/java/com/ejlchina/okhttps/JsonArr.java +++ b/okhttps/src/main/java/com/ejlchina/okhttps/JsonArr.java @@ -27,65 +27,29 @@ public interface JsonArr { */ JsonArr getJsonArr(int index); - /** - * @param index 元素下标 - * @return Boolean 值 - */ - Boolean getBool(int index); - /** * @param index 元素下标 * @return boolean 值 */ - boolean getBoolVal(int index); - - /** - * @param index 元素下标 - * @return Integer 值 - */ - Integer getInt(int index); + boolean getBool(int index); /** * @param index 元素下标 * @return int 值 */ - int getIntVal(int index); - - /** - * @param index 元素下标 - * @return Short 值 - */ - Short getShort(int index); - - /** - * @param index 元素下标 - * @return short 值 - */ - short getShortVal(int index); - - /** - * @param index 元素下标 - * @return Float 值 - */ - Float getFloat(int index); + int getInt(int index); /** * @param index 元素下标 * @return float 值 */ - float getFloatVal(int index); - - /** - * @param index 元素下标 - * @return Double 值 - */ - Double getDouble(int index); + float getFloat(int index); /** * @param index 元素下标 * @return double 值 */ - double getDoubleVal(int index); + double getDouble(int index); /** * @param index 元素下标 diff --git a/okhttps/src/main/java/com/ejlchina/okhttps/JsonFactory.java b/okhttps/src/main/java/com/ejlchina/okhttps/JsonFactory.java index b9c4e3e2..0ffcb9d9 100644 --- a/okhttps/src/main/java/com/ejlchina/okhttps/JsonFactory.java +++ b/okhttps/src/main/java/com/ejlchina/okhttps/JsonFactory.java @@ -1,5 +1,6 @@ package com.ejlchina.okhttps; +import java.io.InputStream; import java.util.List; @@ -7,18 +8,18 @@ public interface JsonFactory { /** - * 将 json 文本解析为 JsonObj - * @param json 文本 + * 解析 JsonObj + * @param in 输入流 * @return JsonObj */ - JsonObj newJsonObj(String json); + JsonObj newJsonObj(InputStream in); /** - * 将 json 文本解析为 JsonArr - * @param json 文本 + * 解析 JsonArr + * @param in 输入流 * @return JsonArr */ - JsonArr newJsonArr(String json); + JsonArr newJsonArr(InputStream in); /** * 将 Java 对象序列化为 Json 字符串 @@ -36,22 +37,22 @@ public interface JsonFactory { String toJsonStr(Object bean, String dateFormat); /** - * 将 json 文本 解析为 Java Bean + * 解析 Java Bean * @param 目标泛型 * @param type 目标类型 - * @param json 文本 + * @param in 输入流 * @return Java Bean */ - T jsonToBean(Class type, String json); + T jsonToBean(Class type, InputStream in); /** - * 将 json 文本 解析为 Java List + * 解析为 Java List * @param 目标泛型 * @param type 目标类型 - * @param json 文本 + * @param in 输入流 * @return Java List */ - List jsonToList(Class type, String json); + List jsonToList(Class type, InputStream in); } diff --git a/okhttps/src/main/java/com/ejlchina/okhttps/JsonObj.java b/okhttps/src/main/java/com/ejlchina/okhttps/JsonObj.java index 0eecbac5..aa54d343 100644 --- a/okhttps/src/main/java/com/ejlchina/okhttps/JsonObj.java +++ b/okhttps/src/main/java/com/ejlchina/okhttps/JsonObj.java @@ -33,65 +33,29 @@ public interface JsonObj { */ JsonArr getJsonArr(String key); - /** - * @param key 键名 - * @return Boolean 值 - */ - Boolean getBool(String key); - /** * @param key 键名 * @return boolean 值 */ - boolean getBoolVal(String key); - - /** - * @param key 键名 - * @return Integer 值 - */ - Integer getInt(String key); + boolean getBool(String key); /** * @param key 键名 * @return int 值 */ - int getIntVal(String key); - - /** - * @param key 键名 - * @return Short 值 - */ - Short getShort(String key); - - /** - * @param key 键名 - * @return short 值 - */ - short getShortVal(String key); - - /** - * @param key 键名 - * @return Float 值 - */ - Float getFloat(String key); + int getInt(String key); /** * @param key 键名 * @return float 值 */ - float getFloatVal(String key); - - /** - * @param key 键名 - * @return Double 值 - */ - Double getDouble(String key); + float getFloat(String key); /** * @param key 键名 * @return double 值 */ - double getDoubleVal(String key); + double getDouble(String key); /** * @param key 键名 diff --git a/okhttps/src/main/java/com/ejlchina/okhttps/internal/ResultBody.java b/okhttps/src/main/java/com/ejlchina/okhttps/internal/ResultBody.java index 03d51e3c..df84faa1 100644 --- a/okhttps/src/main/java/com/ejlchina/okhttps/internal/ResultBody.java +++ b/okhttps/src/main/java/com/ejlchina/okhttps/internal/ResultBody.java @@ -152,7 +152,7 @@ public JsonObj toJsonObj() { if (taskExecutor == null) { throw new IllegalStateException("没有 taskExecutor，不可做 Json 转换！"); } - return taskExecutor.getJsonFactoryNotNull().newJsonObj(toString()); + return taskExecutor.getJsonFactoryNotNull().newJsonObj(toByteStream()); } @Override @@ -160,7 +160,7 @@ public JsonArr toJsonArr() { if (taskExecutor == null) { throw new IllegalStateException("没有 taskExecutor，不可做 Json 转换！"); } - return taskExecutor.getJsonFactoryNotNull().newJsonArr(toString()); + return taskExecutor.getJsonFactoryNotNull().newJsonArr(toByteStream()); } @Override @@ -168,7 +168,7 @@ public T toBean(Class type) { if (taskExecutor == null) { throw new IllegalStateException("没有 taskExecutor，不可做 Json 转换！"); } - return taskExecutor.getJsonFactoryNotNull().jsonToBean(type, toString()); + return taskExecutor.getJsonFactoryNotNull().jsonToBean(type, toByteStream()); } @Override @@ -176,7 +176,7 @@ public List toList(Class type) { if (taskExecutor == null) { throw new IllegalStateException("没有 taskExecutor，不可做 Json 转换！"); } - return taskExecutor.getJsonFactoryNotNull().jsonToList(type, toString()); + return taskExecutor.getJsonFactoryNotNull().jsonToList(type, toByteStream()); } @Override From 6f0da36194b10dd2141d5d527afc6b74371db072 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?=E5=91=A8=E6=97=AD?= Date: Sat, 9 May 2020 11:56:23 +0800 Subject: [PATCH 214/924] =?UTF-8?q?Json=20=E8=A7=A3=E8=80=A6?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- okhttps/src/main/java/com/ejlchina/okhttps/JsonArr.java | 6 ++++++ okhttps/src/main/java/com/ejlchina/okhttps/JsonObj.java | 6 ++++++ 2 files changed, 12 insertions(+) diff --git a/okhttps/src/main/java/com/ejlchina/okhttps/JsonArr.java b/okhttps/src/main/java/com/ejlchina/okhttps/JsonArr.java index 97c1fe43..063fb7fe 100644 --- a/okhttps/src/main/java/com/ejlchina/okhttps/JsonArr.java +++ b/okhttps/src/main/java/com/ejlchina/okhttps/JsonArr.java @@ -39,6 +39,12 @@ public interface JsonArr { */ int getInt(int index); + /** + * @param index 元素下标 + * @return long 值 + */ + long getLong(int index); + /** * @param index 元素下标 * @return float 值 diff --git a/okhttps/src/main/java/com/ejlchina/okhttps/JsonObj.java b/okhttps/src/main/java/com/ejlchina/okhttps/JsonObj.java index aa54d343..5a8cd48a 100644 --- a/okhttps/src/main/java/com/ejlchina/okhttps/JsonObj.java +++ b/okhttps/src/main/java/com/ejlchina/okhttps/JsonObj.java @@ -45,6 +45,12 @@ public interface JsonObj { */ int getInt(String key); + /** + * @param key 键名 + * @return long 值 + */ + long getLong(String key); + /** * @param key 键名 * @return float 值 From 6c99c5e3b60da64bf1023941f2a4d0e08e10ca90 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?=E5=91=A8=E6=97=AD?= Date: Sat, 9 May 2020 11:56:56 +0800 Subject: [PATCH 215/924] =?UTF-8?q?=E9=9B=86=E6=88=90=20fastjaon?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- .../src/main/java/com/ejlchina/okhttps/FastJsonArr.java | 5 +++++ .../src/main/java/com/ejlchina/okhttps/FastJsonObj.java | 5 +++++ 2 files changed, 10 insertions(+) diff --git a/okhttps-fastjson/src/main/java/com/ejlchina/okhttps/FastJsonArr.java b/okhttps-fastjson/src/main/java/com/ejlchina/okhttps/FastJsonArr.java index e116c378..2ea27798 100644 --- a/okhttps-fastjson/src/main/java/com/ejlchina/okhttps/FastJsonArr.java +++ b/okhttps-fastjson/src/main/java/com/ejlchina/okhttps/FastJsonArr.java @@ -52,6 +52,11 @@ public int getInt(int index) { return json.getIntValue(index); } + @Override + public long getLong(int index) { + return json.getLongValue(index); + } + @Override public float getFloat(int index) { return json.getFloatValue(index); diff --git a/okhttps-fastjson/src/main/java/com/ejlchina/okhttps/FastJsonObj.java b/okhttps-fastjson/src/main/java/com/ejlchina/okhttps/FastJsonObj.java index 484b32c9..7d4ebd0b 100644 --- a/okhttps-fastjson/src/main/java/com/ejlchina/okhttps/FastJsonObj.java +++ b/okhttps-fastjson/src/main/java/com/ejlchina/okhttps/FastJsonObj.java @@ -53,6 +53,11 @@ public int getInt(String key) { return json.getIntValue(key); } + @Override + public long getLong(String key) { + return json.getLongValue(key); + } + @Override public float getFloat(String key) { return json.getFloatValue(key); From 60fc2a3fcd90fdca1f83667d423444a878da6936 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?=E5=91=A8=E6=97=AD?= Date: Sat, 9 May 2020 11:57:12 +0800 Subject: [PATCH 216/924] =?UTF-8?q?=E9=9B=86=E6=88=90=20gson?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- .../src/main/java/com/ejlchina/okhttps/GsonArr.java | 9 +++++++++ .../src/main/java/com/ejlchina/okhttps/GsonObj.java | 9 +++++++++ 2 files changed, 18 insertions(+) diff --git a/okhttps-gson/src/main/java/com/ejlchina/okhttps/GsonArr.java b/okhttps-gson/src/main/java/com/ejlchina/okhttps/GsonArr.java index a63c3e67..de121c95 100644 --- a/okhttps-gson/src/main/java/com/ejlchina/okhttps/GsonArr.java +++ b/okhttps-gson/src/main/java/com/ejlchina/okhttps/GsonArr.java @@ -60,6 +60,15 @@ public int getInt(int index) { return 0; } + @Override + public long getLong(int index) { + JsonElement val = json.get(index); + if (val != null) { + return val.getAsLong(); + } + return 0; + } + @Override public float getFloat(int index) { JsonElement val = json.get(index); diff --git a/okhttps-gson/src/main/java/com/ejlchina/okhttps/GsonObj.java b/okhttps-gson/src/main/java/com/ejlchina/okhttps/GsonObj.java index 5441ce81..9b7c0d7c 100644 --- a/okhttps-gson/src/main/java/com/ejlchina/okhttps/GsonObj.java +++ b/okhttps-gson/src/main/java/com/ejlchina/okhttps/GsonObj.java @@ -61,6 +61,15 @@ public int getInt(String key) { return 0; } + @Override + public long getLong(String key) { + JsonElement val = json.get(key); + if (val != null) { + return val.getAsLong(); + } + return 0; + } + @Override public float getFloat(String key) { JsonElement val = json.get(key); From d0583764e9d9b6c636cbfe4e59a91b23c7f5ba58 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?=E5=91=A8=E6=97=AD?= Date: Sat, 9 May 2020 11:57:25 +0800 Subject: [PATCH 217/924] =?UTF-8?q?=E9=9B=86=E6=88=90=20jackson?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- .../src/main/java/com/ejlchina/okhttps/JacksonArr.java | 9 +++++++++ .../src/main/java/com/ejlchina/okhttps/JacksonObj.java | 9 +++++++++ 2 files changed, 18 insertions(+) diff --git a/okhttps-jackson/src/main/java/com/ejlchina/okhttps/JacksonArr.java b/okhttps-jackson/src/main/java/com/ejlchina/okhttps/JacksonArr.java index ae519f91..c6870240 100644 --- a/okhttps-jackson/src/main/java/com/ejlchina/okhttps/JacksonArr.java +++ b/okhttps-jackson/src/main/java/com/ejlchina/okhttps/JacksonArr.java @@ -61,6 +61,15 @@ public int getInt(int index) { return 0; } + @Override + public long getLong(int index) { + JsonNode subJson = json.get(index); + if (subJson != null && subJson.isNumber()) { + return subJson.longValue(); + } + return 0; + } + @Override public float getFloat(int index) { JsonNode subJson = json.get(index); diff --git a/okhttps-jackson/src/main/java/com/ejlchina/okhttps/JacksonObj.java b/okhttps-jackson/src/main/java/com/ejlchina/okhttps/JacksonObj.java index 6ff76c67..79c5b0cf 100644 --- a/okhttps-jackson/src/main/java/com/ejlchina/okhttps/JacksonObj.java +++ b/okhttps-jackson/src/main/java/com/ejlchina/okhttps/JacksonObj.java @@ -64,6 +64,15 @@ public int getInt(String key) { return 0; } + @Override + public long getLong(String key) { + JsonNode subJson = json.get(key); + if (subJson != null && subJson.isNumber()) { + return subJson.longValue(); + } + return 0; + } + @Override public float getFloat(String key) { JsonNode subJson = json.get(key); From bdb9e5cff69de9e5442c46c3af1ae29f229e0e35 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?=E5=91=A8=E6=97=AD?= Date: Sat, 9 May 2020 12:05:42 +0800 Subject: [PATCH 218/924] json toString --- .../src/main/java/com/ejlchina/okhttps/FastJsonArr.java | 5 +++++ .../src/main/java/com/ejlchina/okhttps/FastJsonObj.java | 5 +++++ okhttps-gson/src/main/java/com/ejlchina/okhttps/GsonArr.java | 5 +++++ okhttps-gson/src/main/java/com/ejlchina/okhttps/GsonObj.java | 5 +++++ .../src/main/java/com/ejlchina/okhttps/JacksonArr.java | 5 +++++ .../src/main/java/com/ejlchina/okhttps/JacksonObj.java | 5 +++++ 6 files changed, 30 insertions(+) diff --git a/okhttps-fastjson/src/main/java/com/ejlchina/okhttps/FastJsonArr.java b/okhttps-fastjson/src/main/java/com/ejlchina/okhttps/FastJsonArr.java index 2ea27798..829fcb50 100644 --- a/okhttps-fastjson/src/main/java/com/ejlchina/okhttps/FastJsonArr.java +++ b/okhttps-fastjson/src/main/java/com/ejlchina/okhttps/FastJsonArr.java @@ -82,4 +82,9 @@ public BigInteger getBigInteger(int index) { return json.getBigInteger(index); } + @Override + public String toString() { + return json.toJSONString(); + } + } diff --git a/okhttps-fastjson/src/main/java/com/ejlchina/okhttps/FastJsonObj.java b/okhttps-fastjson/src/main/java/com/ejlchina/okhttps/FastJsonObj.java index 7d4ebd0b..dfddd9c6 100644 --- a/okhttps-fastjson/src/main/java/com/ejlchina/okhttps/FastJsonObj.java +++ b/okhttps-fastjson/src/main/java/com/ejlchina/okhttps/FastJsonObj.java @@ -93,4 +93,9 @@ public Set keySet() { return json.keySet(); } + @Override + public String toString() { + return json.toJSONString(); + } + } diff --git a/okhttps-gson/src/main/java/com/ejlchina/okhttps/GsonArr.java b/okhttps-gson/src/main/java/com/ejlchina/okhttps/GsonArr.java index de121c95..85ae0620 100644 --- a/okhttps-gson/src/main/java/com/ejlchina/okhttps/GsonArr.java +++ b/okhttps-gson/src/main/java/com/ejlchina/okhttps/GsonArr.java @@ -114,4 +114,9 @@ public BigInteger getBigInteger(int index) { return null; } + @Override + public String toString() { + return json.toString(); + } + } diff --git a/okhttps-gson/src/main/java/com/ejlchina/okhttps/GsonObj.java b/okhttps-gson/src/main/java/com/ejlchina/okhttps/GsonObj.java index 9b7c0d7c..88d3afbf 100644 --- a/okhttps-gson/src/main/java/com/ejlchina/okhttps/GsonObj.java +++ b/okhttps-gson/src/main/java/com/ejlchina/okhttps/GsonObj.java @@ -125,4 +125,9 @@ public Set keySet() { return json.keySet(); } + @Override + public String toString() { + return json.toString(); + } + } diff --git a/okhttps-jackson/src/main/java/com/ejlchina/okhttps/JacksonArr.java b/okhttps-jackson/src/main/java/com/ejlchina/okhttps/JacksonArr.java index c6870240..3d65cf0b 100644 --- a/okhttps-jackson/src/main/java/com/ejlchina/okhttps/JacksonArr.java +++ b/okhttps-jackson/src/main/java/com/ejlchina/okhttps/JacksonArr.java @@ -115,4 +115,9 @@ public BigInteger getBigInteger(int index) { return null; } + @Override + public String toString() { + return json.toString(); + } + } diff --git a/okhttps-jackson/src/main/java/com/ejlchina/okhttps/JacksonObj.java b/okhttps-jackson/src/main/java/com/ejlchina/okhttps/JacksonObj.java index 79c5b0cf..f67a1d2a 100644 --- a/okhttps-jackson/src/main/java/com/ejlchina/okhttps/JacksonObj.java +++ b/okhttps-jackson/src/main/java/com/ejlchina/okhttps/JacksonObj.java @@ -133,4 +133,9 @@ public Set keySet() { return set; } + @Override + public String toString() { + return json.toString(); + } + } From abefa818487b0e0b567ca56f202773858d9b6ed4 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?=E5=91=A8=E6=97=AD?= Date: Sat, 9 May 2020 12:17:25 +0800 Subject: [PATCH 219/924] gitignore --- okhttps-fastjson/.gitignore | 1 + okhttps-gson/.gitignore | 1 + okhttps-jackson/.gitignore | 1 + 3 files changed, 3 insertions(+) create mode 100644 okhttps-fastjson/.gitignore create mode 100644 okhttps-gson/.gitignore create mode 100644 okhttps-jackson/.gitignore diff --git a/okhttps-fastjson/.gitignore b/okhttps-fastjson/.gitignore new file mode 100644 index 00000000..b83d2226 --- /dev/null +++ b/okhttps-fastjson/.gitignore @@ -0,0 +1 @@ +/target/ diff --git a/okhttps-gson/.gitignore b/okhttps-gson/.gitignore new file mode 100644 index 00000000..b83d2226 --- /dev/null +++ b/okhttps-gson/.gitignore @@ -0,0 +1 @@ +/target/ diff --git a/okhttps-jackson/.gitignore b/okhttps-jackson/.gitignore new file mode 100644 index 00000000..b83d2226 --- /dev/null +++ b/okhttps-jackson/.gitignore @@ -0,0 +1 @@ +/target/ From d080050f1b93ef6c73c7ef298164f2cc381f81ab Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?=E5=91=A8=E6=97=AD?= Date: Sat, 9 May 2020 13:13:08 +0800 Subject: [PATCH 220/924] =?UTF-8?q?HTTP=20=E6=8E=A5=E5=8F=A3=E6=96=B0?= =?UTF-8?q?=E5=A2=9E=20newBuilder=20=E6=96=B9=E6=B3=95?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- okhttps/src/main/java/com/ejlchina/okhttps/HTTP.java | 6 ++++++ 1 file changed, 6 insertions(+) diff --git a/okhttps/src/main/java/com/ejlchina/okhttps/HTTP.java b/okhttps/src/main/java/com/ejlchina/okhttps/HTTP.java index 5e534549..12218242 100644 --- a/okhttps/src/main/java/com/ejlchina/okhttps/HTTP.java +++ b/okhttps/src/main/java/com/ejlchina/okhttps/HTTP.java @@ -87,6 +87,12 @@ public interface HTTP { */ TaskExecutor getExecutor(); + /** + * 新的构建器 + * @return Builder + */ + Builder newBuilder(); + /** * HTTP 构建器 * @return HTTP 构建器 From c9e2502f9531559e5a80a3423ba9cf696bda6280 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?=E5=91=A8=E6=97=AD?= Date: Sat, 9 May 2020 13:16:39 +0800 Subject: [PATCH 221/924] refactor: JsonFactory -> JsonService --- ...FastJsonFactory.java => FastJsonService.java} | 6 +++--- .../{GsonFactory.java => GsonService.java} | 6 +++--- .../{JacksonFactory.java => JacksonService.java} | 6 +++--- .../main/java/com/ejlchina/okhttps/HttpTask.java | 6 +++--- .../{JsonFactory.java => JsonService.java} | 3 +-- .../ejlchina/okhttps/internal/HttpClient.java | 16 +++++++++------- .../ejlchina/okhttps/internal/ResultBody.java | 8 ++++---- .../ejlchina/okhttps/internal/TaskExecutor.java | 16 ++++++++-------- .../ejlchina/okhttps/internal/WebSocketTask.java | 6 +++--- 9 files changed, 37 insertions(+), 36 deletions(-) rename okhttps-fastjson/src/main/java/com/ejlchina/okhttps/{FastJsonFactory.java => FastJsonService.java} (92%) rename okhttps-gson/src/main/java/com/ejlchina/okhttps/{GsonFactory.java => GsonService.java} (92%) rename okhttps-jackson/src/main/java/com/ejlchina/okhttps/{JacksonFactory.java => JacksonService.java} (95%) rename okhttps/src/main/java/com/ejlchina/okhttps/{JsonFactory.java => JsonService.java} (96%) diff --git a/okhttps-fastjson/src/main/java/com/ejlchina/okhttps/FastJsonFactory.java b/okhttps-fastjson/src/main/java/com/ejlchina/okhttps/FastJsonService.java similarity index 92% rename from okhttps-fastjson/src/main/java/com/ejlchina/okhttps/FastJsonFactory.java rename to okhttps-fastjson/src/main/java/com/ejlchina/okhttps/FastJsonService.java index bfbcc84f..d1678548 100644 --- a/okhttps-fastjson/src/main/java/com/ejlchina/okhttps/FastJsonFactory.java +++ b/okhttps-fastjson/src/main/java/com/ejlchina/okhttps/FastJsonService.java @@ -11,15 +11,15 @@ import okio.Okio; -public class FastJsonFactory implements JsonFactory { +public class FastJsonService implements JsonService { private Charset charset; - public FastJsonFactory() { + public FastJsonService() { this(StandardCharsets.UTF_8); } - public FastJsonFactory(Charset charset) { + public FastJsonService(Charset charset) { this.charset = charset; } diff --git a/okhttps-gson/src/main/java/com/ejlchina/okhttps/GsonFactory.java b/okhttps-gson/src/main/java/com/ejlchina/okhttps/GsonService.java similarity index 92% rename from okhttps-gson/src/main/java/com/ejlchina/okhttps/GsonFactory.java rename to okhttps-gson/src/main/java/com/ejlchina/okhttps/GsonService.java index 17f464e0..87b0b741 100644 --- a/okhttps-gson/src/main/java/com/ejlchina/okhttps/GsonFactory.java +++ b/okhttps-gson/src/main/java/com/ejlchina/okhttps/GsonService.java @@ -11,15 +11,15 @@ import com.google.gson.JsonObject; import com.google.gson.reflect.TypeToken; -public class GsonFactory implements JsonFactory { +public class GsonService implements JsonService { private Gson gson; - public GsonFactory() { + public GsonService() { this(new Gson()); } - public GsonFactory(Gson gson) { + public GsonService(Gson gson) { this.gson = gson; } diff --git a/okhttps-jackson/src/main/java/com/ejlchina/okhttps/JacksonFactory.java b/okhttps-jackson/src/main/java/com/ejlchina/okhttps/JacksonService.java similarity index 95% rename from okhttps-jackson/src/main/java/com/ejlchina/okhttps/JacksonFactory.java rename to okhttps-jackson/src/main/java/com/ejlchina/okhttps/JacksonService.java index 8fa0e7c2..764b9f53 100644 --- a/okhttps-jackson/src/main/java/com/ejlchina/okhttps/JacksonFactory.java +++ b/okhttps-jackson/src/main/java/com/ejlchina/okhttps/JacksonService.java @@ -15,15 +15,15 @@ import com.fasterxml.jackson.databind.node.ObjectNode; import com.fasterxml.jackson.databind.type.CollectionType; -public class JacksonFactory implements JsonFactory { +public class JacksonService implements JsonService { private ObjectMapper objectMapper; - public JacksonFactory() { + public JacksonService() { this(new ObjectMapper()); } - public JacksonFactory(ObjectMapper objectMapper) { + public JacksonService(ObjectMapper objectMapper) { this.objectMapper = objectMapper; } diff --git a/okhttps/src/main/java/com/ejlchina/okhttps/HttpTask.java b/okhttps/src/main/java/com/ejlchina/okhttps/HttpTask.java index 68b78b1b..ae2ea2c7 100644 --- a/okhttps/src/main/java/com/ejlchina/okhttps/HttpTask.java +++ b/okhttps/src/main/java/com/ejlchina/okhttps/HttpTask.java @@ -420,11 +420,11 @@ public C setRequestJson(Object json, String dateFormat) { requestJson = json.toString(); } else if (dateFormat != null) { requestJson = httpClient.getExecutor() - .getJsonFactoryNotNull() + .jsonServiceNotNull() .toJsonStr(json, dateFormat); } else { requestJson = httpClient.getExecutor() - .getJsonFactoryNotNull() + .jsonServiceNotNull() .toJsonStr(json); } } @@ -656,7 +656,7 @@ protected State toState(IOException e, boolean sync) { private RequestBody buildRequestBody() { if (jsonParams != null) { - requestJson = httpClient.getExecutor().getJsonFactoryNotNull() + requestJson = httpClient.getExecutor().jsonServiceNotNull() .toJsonStr(jsonParams); } if (files != null) { diff --git a/okhttps/src/main/java/com/ejlchina/okhttps/JsonFactory.java b/okhttps/src/main/java/com/ejlchina/okhttps/JsonService.java similarity index 96% rename from okhttps/src/main/java/com/ejlchina/okhttps/JsonFactory.java rename to okhttps/src/main/java/com/ejlchina/okhttps/JsonService.java index 0ffcb9d9..c4108c8b 100644 --- a/okhttps/src/main/java/com/ejlchina/okhttps/JsonFactory.java +++ b/okhttps/src/main/java/com/ejlchina/okhttps/JsonService.java @@ -4,9 +4,8 @@ import java.util.List; -public interface JsonFactory { +public interface JsonService { - /** * 解析 JsonObj * @param in 输入流 diff --git a/okhttps/src/main/java/com/ejlchina/okhttps/internal/HttpClient.java b/okhttps/src/main/java/com/ejlchina/okhttps/internal/HttpClient.java index 2174e816..96dca4ef 100644 --- a/okhttps/src/main/java/com/ejlchina/okhttps/internal/HttpClient.java +++ b/okhttps/src/main/java/com/ejlchina/okhttps/internal/HttpClient.java @@ -33,7 +33,7 @@ private HttpClient(Builder builder) { this.executor = new TaskExecutor(client.dispatcher().executorService(), builder.mainExecutor, builder.downloadListener, builder.responseListener, builder.exceptionListener, - builder.completeListener, builder.jsonFactory); + builder.completeListener, builder.jsonService); this.preprocessors = builder.preprocessors.toArray(new Preprocessor[0]); this.tagTasks = new LinkedList<>(); } @@ -174,6 +174,7 @@ public MediaType getMediaType(String type) { return MediaType.parse("application/octet-stream"); } + @Override public TaskExecutor getExecutor() { return executor; } @@ -305,6 +306,7 @@ public void proceed() { } + @Override public Builder newBuilder() { return new Builder(this); } @@ -349,7 +351,7 @@ public static class Builder { private TaskListener completeListener; - private JsonFactory jsonFactory; + private JsonService jsonService; public Builder() { mediaTypes = new HashMap<>(); @@ -380,7 +382,7 @@ private Builder(HttpClient hc) { this.responseListener = hc.executor.responseListener; this.exceptionListener = hc.executor.exceptionListener; this.completeListener = hc.executor.completeListener; - this.jsonFactory = hc.executor.jsonFactory; + this.jsonService = hc.executor.jsonService; } /** @@ -506,12 +508,12 @@ public Builder downloadListener(DownListener listener) { } /** - * 设置 JSON 工厂 - * @param jsonFactory JSON 工厂 + * 设置 JSON 服务 + * @param jsonService JSON 服务 * @return Builder */ - public Builder jsonFactory(JsonFactory jsonFactory) { - this.jsonFactory = jsonFactory; + public Builder jsonService(JsonService jsonService) { + this.jsonService = jsonService; return this; } diff --git a/okhttps/src/main/java/com/ejlchina/okhttps/internal/ResultBody.java b/okhttps/src/main/java/com/ejlchina/okhttps/internal/ResultBody.java index df84faa1..14e7725a 100644 --- a/okhttps/src/main/java/com/ejlchina/okhttps/internal/ResultBody.java +++ b/okhttps/src/main/java/com/ejlchina/okhttps/internal/ResultBody.java @@ -152,7 +152,7 @@ public JsonObj toJsonObj() { if (taskExecutor == null) { throw new IllegalStateException("没有 taskExecutor，不可做 Json 转换！"); } - return taskExecutor.getJsonFactoryNotNull().newJsonObj(toByteStream()); + return taskExecutor.jsonServiceNotNull().newJsonObj(toByteStream()); } @Override @@ -160,7 +160,7 @@ public JsonArr toJsonArr() { if (taskExecutor == null) { throw new IllegalStateException("没有 taskExecutor，不可做 Json 转换！"); } - return taskExecutor.getJsonFactoryNotNull().newJsonArr(toByteStream()); + return taskExecutor.jsonServiceNotNull().newJsonArr(toByteStream()); } @Override @@ -168,7 +168,7 @@ public T toBean(Class type) { if (taskExecutor == null) { throw new IllegalStateException("没有 taskExecutor，不可做 Json 转换！"); } - return taskExecutor.getJsonFactoryNotNull().jsonToBean(type, toByteStream()); + return taskExecutor.jsonServiceNotNull().jsonToBean(type, toByteStream()); } @Override @@ -176,7 +176,7 @@ public List toList(Class type) { if (taskExecutor == null) { throw new IllegalStateException("没有 taskExecutor，不可做 Json 转换！"); } - return taskExecutor.getJsonFactoryNotNull().jsonToList(type, toByteStream()); + return taskExecutor.jsonServiceNotNull().jsonToList(type, toByteStream()); } @Override diff --git a/okhttps/src/main/java/com/ejlchina/okhttps/internal/TaskExecutor.java b/okhttps/src/main/java/com/ejlchina/okhttps/internal/TaskExecutor.java index 1df24b71..1381006d 100644 --- a/okhttps/src/main/java/com/ejlchina/okhttps/internal/TaskExecutor.java +++ b/okhttps/src/main/java/com/ejlchina/okhttps/internal/TaskExecutor.java @@ -10,7 +10,7 @@ import com.ejlchina.okhttps.Download; import com.ejlchina.okhttps.HttpResult; import com.ejlchina.okhttps.HttpTask; -import com.ejlchina.okhttps.JsonFactory; +import com.ejlchina.okhttps.JsonService; import com.ejlchina.okhttps.OnCallback; import com.ejlchina.okhttps.TaskListener; import com.ejlchina.okhttps.HttpResult.State; @@ -23,18 +23,18 @@ public class TaskExecutor { TaskListener responseListener; TaskListener exceptionListener; TaskListener completeListener; - JsonFactory jsonFactory; + JsonService jsonService; public TaskExecutor(Executor ioExecutor, Executor mainExecutor, DownListener downloadListener, TaskListener responseListener, TaskListener exceptionListener, - TaskListener completeListener, JsonFactory jsonFactory) { + TaskListener completeListener, JsonService jsonService) { this.ioExecutor = ioExecutor; this.mainExecutor = mainExecutor; this.downloadListener = downloadListener; this.responseListener = responseListener; this.exceptionListener = exceptionListener; this.completeListener = completeListener; - this.jsonFactory = jsonFactory; + this.jsonService = jsonService; } public Executor getExecutor(boolean onIoThread) { @@ -99,11 +99,11 @@ public void executeOnComplete(HttpTask task, OnCallback onComplete, St } } - public JsonFactory getJsonFactoryNotNull() { - if (jsonFactory != null) { - return jsonFactory; + public JsonService jsonServiceNotNull() { + if (jsonService != null) { + return jsonService; } - throw new IllegalStateException("没有设置 JsonFactory，不可做 Json 操作！"); + throw new IllegalStateException("没有设置 JsonService，不可做 Json 操作！"); } /** diff --git a/okhttps/src/main/java/com/ejlchina/okhttps/internal/WebSocketTask.java b/okhttps/src/main/java/com/ejlchina/okhttps/internal/WebSocketTask.java index 9a3726be..7a36e24a 100644 --- a/okhttps/src/main/java/com/ejlchina/okhttps/internal/WebSocketTask.java +++ b/okhttps/src/main/java/com/ejlchina/okhttps/internal/WebSocketTask.java @@ -152,12 +152,12 @@ public boolean send(ByteString bytes) { @Override public boolean send(Object bean) { - return send(taskExecutor.getJsonFactoryNotNull().toJsonStr(bean)); + return send(taskExecutor.jsonServiceNotNull().toJsonStr(bean)); } @Override public boolean send(Object bean, String dateFormat) { - return send(taskExecutor.getJsonFactoryNotNull().toJsonStr(bean, dateFormat)); + return send(taskExecutor.jsonServiceNotNull().toJsonStr(bean, dateFormat)); } @Override @@ -209,7 +209,7 @@ boolean send(okhttp3.WebSocket webSocket, Object msg) { if (msg instanceof byte[]) { return webSocket.send(ByteString.of((byte[]) msg)); } - return webSocket.send(taskExecutor.getJsonFactoryNotNull().toJsonStr(msg)); + return webSocket.send(taskExecutor.jsonServiceNotNull().toJsonStr(msg)); } } From c372871cffd97953a7444d43a2d5b8b0f9ccab15 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?=E5=91=A8=E6=97=AD?= Date: Sat, 9 May 2020 13:59:57 +0800 Subject: [PATCH 222/924] refactor --- .../java/com/ejlchina/okhttps/FastJsonService.java | 4 ++-- .../main/java/com/ejlchina/okhttps/GsonService.java | 4 ++-- .../java/com/ejlchina/okhttps/JacksonService.java | 4 ++-- .../main/java/com/ejlchina/okhttps/JsonService.java | 12 ++++++------ .../com/ejlchina/okhttps/internal/ResultBody.java | 4 ++-- 5 files changed, 14 insertions(+), 14 deletions(-) diff --git a/okhttps-fastjson/src/main/java/com/ejlchina/okhttps/FastJsonService.java b/okhttps-fastjson/src/main/java/com/ejlchina/okhttps/FastJsonService.java index d1678548..7cd6436a 100644 --- a/okhttps-fastjson/src/main/java/com/ejlchina/okhttps/FastJsonService.java +++ b/okhttps-fastjson/src/main/java/com/ejlchina/okhttps/FastJsonService.java @@ -24,12 +24,12 @@ public FastJsonService(Charset charset) { } @Override - public JsonObj newJsonObj(InputStream in) { + public JsonObj toJsonObj(InputStream in) { return new FastJsonObj(JSON.parseObject(toString(in))); } @Override - public JsonArr newJsonArr(InputStream in) { + public JsonArr toJsonArr(InputStream in) { return new FastJsonArr(JSON.parseArray(toString(in))); } diff --git a/okhttps-gson/src/main/java/com/ejlchina/okhttps/GsonService.java b/okhttps-gson/src/main/java/com/ejlchina/okhttps/GsonService.java index 87b0b741..1b25c59e 100644 --- a/okhttps-gson/src/main/java/com/ejlchina/okhttps/GsonService.java +++ b/okhttps-gson/src/main/java/com/ejlchina/okhttps/GsonService.java @@ -24,12 +24,12 @@ public GsonService(Gson gson) { } @Override - public JsonObj newJsonObj(InputStream in) { + public JsonObj toJsonObj(InputStream in) { return new GsonObj(gson.fromJson(new InputStreamReader(in), JsonObject.class)); } @Override - public JsonArr newJsonArr(InputStream in) { + public JsonArr toJsonArr(InputStream in) { return new GsonArr(gson.fromJson(new InputStreamReader(in), JsonArray.class)); } diff --git a/okhttps-jackson/src/main/java/com/ejlchina/okhttps/JacksonService.java b/okhttps-jackson/src/main/java/com/ejlchina/okhttps/JacksonService.java index 764b9f53..301d5a73 100644 --- a/okhttps-jackson/src/main/java/com/ejlchina/okhttps/JacksonService.java +++ b/okhttps-jackson/src/main/java/com/ejlchina/okhttps/JacksonService.java @@ -28,7 +28,7 @@ public JacksonService(ObjectMapper objectMapper) { } @Override - public JsonObj newJsonObj(InputStream in) { + public JsonObj toJsonObj(InputStream in) { try { JsonNode json = objectMapper.readTree(in); if (json.isObject()) { @@ -44,7 +44,7 @@ public JsonObj newJsonObj(InputStream in) { } @Override - public JsonArr newJsonArr(InputStream in) { + public JsonArr toJsonArr(InputStream in) { try { JsonNode json = objectMapper.readTree(in); if (json.isArray()) { diff --git a/okhttps/src/main/java/com/ejlchina/okhttps/JsonService.java b/okhttps/src/main/java/com/ejlchina/okhttps/JsonService.java index c4108c8b..094d60d4 100644 --- a/okhttps/src/main/java/com/ejlchina/okhttps/JsonService.java +++ b/okhttps/src/main/java/com/ejlchina/okhttps/JsonService.java @@ -8,17 +8,17 @@ public interface JsonService { /** * 解析 JsonObj - * @param in 输入流 + * @param in JSON 输入流 * @return JsonObj */ - JsonObj newJsonObj(InputStream in); + JsonObj toJsonObj(InputStream in); /** * 解析 JsonArr - * @param in 输入流 + * @param in JSON 输入流 * @return JsonArr */ - JsonArr newJsonArr(InputStream in); + JsonArr toJsonArr(InputStream in); /** * 将 Java 对象序列化为 Json 字符串 @@ -39,7 +39,7 @@ public interface JsonService { * 解析 Java Bean * @param 目标泛型 * @param type 目标类型 - * @param in 输入流 + * @param in JSON 输入流 * @return Java Bean */ T jsonToBean(Class type, InputStream in); @@ -48,7 +48,7 @@ public interface JsonService { * 解析为 Java List * @param 目标泛型 * @param type 目标类型 - * @param in 输入流 + * @param in JSON 输入流 * @return Java List */ List jsonToList(Class type, InputStream in); diff --git a/okhttps/src/main/java/com/ejlchina/okhttps/internal/ResultBody.java b/okhttps/src/main/java/com/ejlchina/okhttps/internal/ResultBody.java index 14e7725a..44df2806 100644 --- a/okhttps/src/main/java/com/ejlchina/okhttps/internal/ResultBody.java +++ b/okhttps/src/main/java/com/ejlchina/okhttps/internal/ResultBody.java @@ -152,7 +152,7 @@ public JsonObj toJsonObj() { if (taskExecutor == null) { throw new IllegalStateException("没有 taskExecutor，不可做 Json 转换！"); } - return taskExecutor.jsonServiceNotNull().newJsonObj(toByteStream()); + return taskExecutor.jsonServiceNotNull().toJsonObj(toByteStream()); } @Override @@ -160,7 +160,7 @@ public JsonArr toJsonArr() { if (taskExecutor == null) { throw new IllegalStateException("没有 taskExecutor，不可做 Json 转换！"); } - return taskExecutor.jsonServiceNotNull().newJsonArr(toByteStream()); + return taskExecutor.jsonServiceNotNull().toJsonArr(toByteStream()); } @Override From 41a9f7951e88b3802b338bffeb171853bb96877f Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?=E5=91=A8=E6=97=AD?= Date: Sat, 9 May 2020 15:48:21 +0800 Subject: [PATCH 223/924] TestCases --- .../java/com/ejlchina/okhttps/DateBean.java | 40 ++++++ .../java/com/ejlchina/okhttps/TestCases.java | 88 ++++++++++++ .../test/java/com/ejlchina/okhttps/User.java | 66 +++++++++ .../java/com/ejlchina/okhttps/DateBean.java | 40 ++++++ .../java/com/ejlchina/okhttps/TestCase.java | 133 ------------------ .../java/com/ejlchina/okhttps/TestCases.java | 88 ++++++++++++ .../test/java/com/ejlchina/okhttps/User.java | 66 +++++++++ .../java/com/ejlchina/okhttps/DateBean.java | 40 ++++++ .../java/com/ejlchina/okhttps/TestCase.java | 117 --------------- .../java/com/ejlchina/okhttps/TestCases.java | 88 ++++++++++++ .../test/java/com/ejlchina/okhttps/User.java | 66 +++++++++ 11 files changed, 582 insertions(+), 250 deletions(-) create mode 100644 okhttps-fastjson/src/test/java/com/ejlchina/okhttps/DateBean.java create mode 100644 okhttps-fastjson/src/test/java/com/ejlchina/okhttps/TestCases.java create mode 100644 okhttps-fastjson/src/test/java/com/ejlchina/okhttps/User.java create mode 100644 okhttps-gson/src/test/java/com/ejlchina/okhttps/DateBean.java delete mode 100644 okhttps-gson/src/test/java/com/ejlchina/okhttps/TestCase.java create mode 100644 okhttps-gson/src/test/java/com/ejlchina/okhttps/TestCases.java create mode 100644 okhttps-gson/src/test/java/com/ejlchina/okhttps/User.java create mode 100644 okhttps-jackson/src/test/java/com/ejlchina/okhttps/DateBean.java delete mode 100644 okhttps-jackson/src/test/java/com/ejlchina/okhttps/TestCase.java create mode 100644 okhttps-jackson/src/test/java/com/ejlchina/okhttps/TestCases.java create mode 100644 okhttps-jackson/src/test/java/com/ejlchina/okhttps/User.java diff --git a/okhttps-fastjson/src/test/java/com/ejlchina/okhttps/DateBean.java b/okhttps-fastjson/src/test/java/com/ejlchina/okhttps/DateBean.java new file mode 100644 index 00000000..2e016c80 --- /dev/null +++ b/okhttps-fastjson/src/test/java/com/ejlchina/okhttps/DateBean.java @@ -0,0 +1,40 @@ +package com.ejlchina.okhttps; + +import java.util.Date; + +public class DateBean { + + private int id; + private Date date; + + + public DateBean() { + } + + public DateBean(int id, Date date) { + this.id = id; + this.date = date; + } + + public int getId() { + return id; + } + + public void setId(int id) { + this.id = id; + } + + public Date getDate() { + return date; + } + + public void setDate(Date date) { + this.date = date; + } + + @Override + public String toString() { + return "DateBean [id=" + id + ", date=" + date + "]"; + } + +} diff --git a/okhttps-fastjson/src/test/java/com/ejlchina/okhttps/TestCases.java b/okhttps-fastjson/src/test/java/com/ejlchina/okhttps/TestCases.java new file mode 100644 index 00000000..c5657995 --- /dev/null +++ b/okhttps-fastjson/src/test/java/com/ejlchina/okhttps/TestCases.java @@ -0,0 +1,88 @@ +package com.ejlchina.okhttps; + +import java.io.ByteArrayInputStream; +import java.io.InputStream; +import java.text.ParseException; +import java.text.SimpleDateFormat; +import java.util.List; +import java.util.Set; + +import org.junit.Assert; +import org.junit.Test; + + +public class TestCases { + + JsonService jsonService = new FastJsonService(); + + @Test + public void testToJsonObj() { + String json = "{\"id\":1,\"name\":\"Jack\"}"; + InputStream in = new ByteArrayInputStream(json.getBytes()); + JsonObj jsonObj = jsonService.toJsonObj(in); + Set keys = jsonObj.keySet(); + Assert.assertTrue(keys.size() == 2); + Assert.assertTrue(keys.contains("id")); + Assert.assertTrue(keys.contains("name")); + Assert.assertTrue(!jsonObj.isEmpty()); + Assert.assertTrue(2 == jsonObj.size()); + Assert.assertTrue(1 == jsonObj.getInt("id")); + Assert.assertTrue(!jsonObj.has("age")); + Assert.assertTrue(0 == jsonObj.getInt("age")); + Assert.assertEquals("Jack", jsonObj.getString("name")); + } + + @Test + public void testToJsonArr() { + String json = "[{\"id\":1,\"name\":\"Jack\"},{\"id\":2,\"name\":\"Tom\"}]"; + InputStream in = new ByteArrayInputStream(json.getBytes()); + JsonArr jsonObj = jsonService.toJsonArr(in); + Assert.assertTrue(!jsonObj.isEmpty()); + Assert.assertTrue(jsonObj.size() == 2); + JsonObj json1 = jsonObj.getJsonOjb(0); + JsonObj json2 = jsonObj.getJsonOjb(1); + Assert.assertEquals(1, json1.getInt("id")); + Assert.assertEquals("Jack", json1.getString("name")); + Assert.assertEquals(2, json2.getInt("id")); + Assert.assertEquals("Tom", json2.getString("name")); + } + + @Test + public void testToJsonStr() { + String json = jsonService.toJsonStr(new User(1, "Jack")); + Assert.assertEquals("{\"id\":1,\"name\":\"Jack\"}", json); + } + + @Test + public void testToJsonStrWithDateFormat() throws ParseException { + String dataFormat = "yyyy-MM-dd HH:mm:ss"; + SimpleDateFormat sdf = new SimpleDateFormat(dataFormat); + String date = "2020-05-09 12:30:15"; + String json = jsonService.toJsonStr(new DateBean(1, sdf.parse(date)), dataFormat); + Assert.assertTrue(json.contains(date)); + } + + @Test + public void testJsonToBean() { + String json = "{\"id\":1,\"name\":\"Jack\"}"; + InputStream in = new ByteArrayInputStream(json.getBytes()); + User user = jsonService.jsonToBean(User.class, in); + Assert.assertEquals(1, user.getId()); + Assert.assertEquals("Jack", user.getName()); + } + + @Test + public void testJsonToList() { + String json = "[{\"id\":1,\"name\":\"Jack\"},{\"id\":2,\"name\":\"Tom\"}]"; + InputStream in = new ByteArrayInputStream(json.getBytes()); + List users = jsonService.jsonToList(User.class, in); + Assert.assertTrue(2 == users.size()); + User u1 = users.get(0); + User u2 = users.get(1); + Assert.assertEquals(1, u1.getId()); + Assert.assertEquals("Jack", u1.getName()); + Assert.assertEquals(2, u2.getId()); + Assert.assertEquals("Tom", u2.getName()); + } + +} diff --git a/okhttps-fastjson/src/test/java/com/ejlchina/okhttps/User.java b/okhttps-fastjson/src/test/java/com/ejlchina/okhttps/User.java new file mode 100644 index 00000000..1fcb6484 --- /dev/null +++ b/okhttps-fastjson/src/test/java/com/ejlchina/okhttps/User.java @@ -0,0 +1,66 @@ +package com.ejlchina.okhttps; + +public class User { + + private int id; + private String name; + + + public User() { + } + + public User(int id, String name) { + this.id = id; + this.name = name; + } + + public void setId(int id) { + this.id = id; + } + + public void setName(String name) { + this.name = name; + } + + public int getId() { + return id; + } + + public String getName() { + return name; + } + + @Override + public String toString() { + return "User [id=" + id + ", name=" + name + "]"; + } + + @Override + public int hashCode() { + final int prime = 31; + int result = 1; + result = prime * result + id; + result = prime * result + ((name == null) ? 0 : name.hashCode()); + return result; + } + + @Override + public boolean equals(Object obj) { + if (this == obj) + return true; + if (obj == null) + return false; + if (getClass() != obj.getClass()) + return false; + User other = (User) obj; + if (id != other.id) + return false; + if (name == null) { + if (other.name != null) + return false; + } else if (!name.equals(other.name)) + return false; + return true; + } + +} diff --git a/okhttps-gson/src/test/java/com/ejlchina/okhttps/DateBean.java b/okhttps-gson/src/test/java/com/ejlchina/okhttps/DateBean.java new file mode 100644 index 00000000..2e016c80 --- /dev/null +++ b/okhttps-gson/src/test/java/com/ejlchina/okhttps/DateBean.java @@ -0,0 +1,40 @@ +package com.ejlchina.okhttps; + +import java.util.Date; + +public class DateBean { + + private int id; + private Date date; + + + public DateBean() { + } + + public DateBean(int id, Date date) { + this.id = id; + this.date = date; + } + + public int getId() { + return id; + } + + public void setId(int id) { + this.id = id; + } + + public Date getDate() { + return date; + } + + public void setDate(Date date) { + this.date = date; + } + + @Override + public String toString() { + return "DateBean [id=" + id + ", date=" + date + "]"; + } + +} diff --git a/okhttps-gson/src/test/java/com/ejlchina/okhttps/TestCase.java b/okhttps-gson/src/test/java/com/ejlchina/okhttps/TestCase.java deleted file mode 100644 index 232d096b..00000000 --- a/okhttps-gson/src/test/java/com/ejlchina/okhttps/TestCase.java +++ /dev/null @@ -1,133 +0,0 @@ -package com.ejlchina.okhttps; - -import java.util.ArrayList; -import java.util.Collections; -import java.util.Date; -import java.util.List; - -import org.junit.Test; - -import com.google.gson.Gson; -import com.google.gson.JsonArray; -import com.google.gson.JsonObject; -import com.google.gson.reflect.TypeToken; - -public class TestCase { - - - Gson gson = new Gson(); - - @Test - public void test() { - - - User u1 = new User(1, "Tom"); - User u2 = new User(2, "Jack"); - List list = new ArrayList<>(); - list.add(u1); - list.add(u2); - - String json = gson.toJson(list); - - System.out.println("json = " + json); - -// User[] users = gson.fromJson(json, TypeToken.getArray(User.class).getType()); - - List users = jsonToList(User.class, json); - - System.out.println(users.get(0)); - System.out.println(users.get(0)); - } - - @Test - public void test2() { - User u1 = new User(1, "Tom"); - System.out.println(toJsonStr(u1, "yyyy-MM-dd HH:mm:ss")); - } - - @Test - public void test3() { - User u1 = new User(1, "Tom"); - String json = gson.toJson(u1); - System.out.println(json); - - JsonObject jsonObj = gson.fromJson(json, JsonObject.class); - - System.out.println(jsonObj); - System.out.println(jsonObj.get("id").getAsInt()); - System.out.println(jsonObj.get("name").getAsString()); - } - - @Test - public void test4() { - User u1 = new User(1, "Tom"); - User u2 = new User(2, "Jack"); - List list = new ArrayList<>(); - list.add(u1); - list.add(u2); - - String json = gson.toJson(list); - - JsonArray jsonArr = gson.fromJson(json, JsonArray.class); - - System.out.println(jsonArr); - System.out.println(jsonArr.get(0)); - System.out.println(jsonArr.get(1)); - } - - public List jsonToList(Class type, String json) { - T[] objs = gson.fromJson(json, TypeToken.getArray(type).getType()); - List list = new ArrayList<>(); - Collections.addAll(list, objs); - return list; - } - - - public String toJsonStr(Object bean, String dateFormat) { - return gson.newBuilder().setDateFormat(dateFormat).create().toJson(bean); - } - - - public static class User { - - private int id; - private String name; - private Date date = new Date(); - - public User() { - } - - public User(int id, String name) { - this.id = id; - this.name = name; - } - - public int getId() { - return id; - } - public void setId(int id) { - this.id = id; - } - public String getName() { - return name; - } - public void setName(String name) { - this.name = name; - } - - public Date getDate() { - return date; - } - - public void setDate(Date date) { - this.date = date; - } - - @Override - public String toString() { - return "User [id=" + id + ", name=" + name + ", date=" + date + "]"; - } - - } - -} diff --git a/okhttps-gson/src/test/java/com/ejlchina/okhttps/TestCases.java b/okhttps-gson/src/test/java/com/ejlchina/okhttps/TestCases.java new file mode 100644 index 00000000..ebf03180 --- /dev/null +++ b/okhttps-gson/src/test/java/com/ejlchina/okhttps/TestCases.java @@ -0,0 +1,88 @@ +package com.ejlchina.okhttps; + +import java.io.ByteArrayInputStream; +import java.io.InputStream; +import java.text.ParseException; +import java.text.SimpleDateFormat; +import java.util.List; +import java.util.Set; + +import org.junit.Assert; +import org.junit.Test; + + +public class TestCases { + + JsonService jsonService = new GsonService(); + + @Test + public void testToJsonObj() { + String json = "{\"id\":1,\"name\":\"Jack\"}"; + InputStream in = new ByteArrayInputStream(json.getBytes()); + JsonObj jsonObj = jsonService.toJsonObj(in); + Set keys = jsonObj.keySet(); + Assert.assertTrue(keys.size() == 2); + Assert.assertTrue(keys.contains("id")); + Assert.assertTrue(keys.contains("name")); + Assert.assertTrue(!jsonObj.isEmpty()); + Assert.assertTrue(2 == jsonObj.size()); + Assert.assertTrue(1 == jsonObj.getInt("id")); + Assert.assertTrue(!jsonObj.has("age")); + Assert.assertTrue(0 == jsonObj.getInt("age")); + Assert.assertEquals("Jack", jsonObj.getString("name")); + } + + @Test + public void testToJsonArr() { + String json = "[{\"id\":1,\"name\":\"Jack\"},{\"id\":2,\"name\":\"Tom\"}]"; + InputStream in = new ByteArrayInputStream(json.getBytes()); + JsonArr jsonObj = jsonService.toJsonArr(in); + Assert.assertTrue(!jsonObj.isEmpty()); + Assert.assertTrue(jsonObj.size() == 2); + JsonObj json1 = jsonObj.getJsonOjb(0); + JsonObj json2 = jsonObj.getJsonOjb(1); + Assert.assertEquals(1, json1.getInt("id")); + Assert.assertEquals("Jack", json1.getString("name")); + Assert.assertEquals(2, json2.getInt("id")); + Assert.assertEquals("Tom", json2.getString("name")); + } + + @Test + public void testToJsonStr() { + String json = jsonService.toJsonStr(new User(1, "Jack")); + Assert.assertEquals("{\"id\":1,\"name\":\"Jack\"}", json); + } + + @Test + public void testToJsonStrWithDateFormat() throws ParseException { + String dataFormat = "yyyy-MM-dd HH:mm:ss"; + SimpleDateFormat sdf = new SimpleDateFormat(dataFormat); + String date = "2020-05-09 12:30:15"; + String json = jsonService.toJsonStr(new DateBean(1, sdf.parse(date)), dataFormat); + Assert.assertTrue(json.contains(date)); + } + + @Test + public void testJsonToBean() { + String json = "{\"id\":1,\"name\":\"Jack\"}"; + InputStream in = new ByteArrayInputStream(json.getBytes()); + User user = jsonService.jsonToBean(User.class, in); + Assert.assertEquals(1, user.getId()); + Assert.assertEquals("Jack", user.getName()); + } + + @Test + public void testJsonToList() { + String json = "[{\"id\":1,\"name\":\"Jack\"},{\"id\":2,\"name\":\"Tom\"}]"; + InputStream in = new ByteArrayInputStream(json.getBytes()); + List users = jsonService.jsonToList(User.class, in); + Assert.assertTrue(2 == users.size()); + User u1 = users.get(0); + User u2 = users.get(1); + Assert.assertEquals(1, u1.getId()); + Assert.assertEquals("Jack", u1.getName()); + Assert.assertEquals(2, u2.getId()); + Assert.assertEquals("Tom", u2.getName()); + } + +} diff --git a/okhttps-gson/src/test/java/com/ejlchina/okhttps/User.java b/okhttps-gson/src/test/java/com/ejlchina/okhttps/User.java new file mode 100644 index 00000000..1fcb6484 --- /dev/null +++ b/okhttps-gson/src/test/java/com/ejlchina/okhttps/User.java @@ -0,0 +1,66 @@ +package com.ejlchina.okhttps; + +public class User { + + private int id; + private String name; + + + public User() { + } + + public User(int id, String name) { + this.id = id; + this.name = name; + } + + public void setId(int id) { + this.id = id; + } + + public void setName(String name) { + this.name = name; + } + + public int getId() { + return id; + } + + public String getName() { + return name; + } + + @Override + public String toString() { + return "User [id=" + id + ", name=" + name + "]"; + } + + @Override + public int hashCode() { + final int prime = 31; + int result = 1; + result = prime * result + id; + result = prime * result + ((name == null) ? 0 : name.hashCode()); + return result; + } + + @Override + public boolean equals(Object obj) { + if (this == obj) + return true; + if (obj == null) + return false; + if (getClass() != obj.getClass()) + return false; + User other = (User) obj; + if (id != other.id) + return false; + if (name == null) { + if (other.name != null) + return false; + } else if (!name.equals(other.name)) + return false; + return true; + } + +} diff --git a/okhttps-jackson/src/test/java/com/ejlchina/okhttps/DateBean.java b/okhttps-jackson/src/test/java/com/ejlchina/okhttps/DateBean.java new file mode 100644 index 00000000..2e016c80 --- /dev/null +++ b/okhttps-jackson/src/test/java/com/ejlchina/okhttps/DateBean.java @@ -0,0 +1,40 @@ +package com.ejlchina.okhttps; + +import java.util.Date; + +public class DateBean { + + private int id; + private Date date; + + + public DateBean() { + } + + public DateBean(int id, Date date) { + this.id = id; + this.date = date; + } + + public int getId() { + return id; + } + + public void setId(int id) { + this.id = id; + } + + public Date getDate() { + return date; + } + + public void setDate(Date date) { + this.date = date; + } + + @Override + public String toString() { + return "DateBean [id=" + id + ", date=" + date + "]"; + } + +} diff --git a/okhttps-jackson/src/test/java/com/ejlchina/okhttps/TestCase.java b/okhttps-jackson/src/test/java/com/ejlchina/okhttps/TestCase.java deleted file mode 100644 index 41d7dfce..00000000 --- a/okhttps-jackson/src/test/java/com/ejlchina/okhttps/TestCase.java +++ /dev/null @@ -1,117 +0,0 @@ -package com.ejlchina.okhttps; - -import java.text.SimpleDateFormat; -import java.util.ArrayList; -import java.util.Date; -import java.util.List; - -import org.junit.Test; - -import com.ejlchina.okhttps.internal.HttpException; -import com.fasterxml.jackson.core.JsonProcessingException; -import com.fasterxml.jackson.databind.ObjectMapper; -import com.fasterxml.jackson.databind.SerializationFeature; -import com.fasterxml.jackson.databind.type.CollectionType; - -public class TestCase { - - - ObjectMapper objectMapper = new ObjectMapper(); - - @Test - public void test() throws JsonProcessingException { - - User u1 = new User(1, "Tom"); - - ObjectMapper mapper = objectMapper.copy(); - - mapper.configure(SerializationFeature.WRITE_DATES_AS_TIMESTAMPS, false); - - mapper.setDateFormat(new SimpleDateFormat("yyyy-MM-dd HH:mm:ss")); - - String json = mapper.writeValueAsString(u1); - - System.out.println("json = " + json); - - json = objectMapper.writeValueAsString(u1); - - System.out.println("json = " + json); - } - - - @Test - public void test1() throws JsonProcessingException { - - User u1 = new User(1, "Tom"); - User u2 = new User(2, "Jack"); - List list = new ArrayList<>(); - list.add(u1); - list.add(u2); - - String json = objectMapper.writeValueAsString(list); - - System.out.println("json = " + json); - - List nlist = jsonToList(User.class, json); - - System.out.println(nlist); - } - - - - public List jsonToList(Class type, String json) { - if (json != null) { - CollectionType javaType = objectMapper.getTypeFactory().constructCollectionType(ArrayList.class, type); - try { - return objectMapper.readValue(json, javaType); - } catch (JsonProcessingException e) { - throw new HttpException("Jackson 解析异常：" + json, e); - } - } - return null; - } - - - public static class User { - - private int id; - private String name; - private Date date = new Date(); - - public User() { - } - - public User(int id, String name) { - this.id = id; - this.name = name; - } - - public int getId() { - return id; - } - public void setId(int id) { - this.id = id; - } - public String getName() { - return name; - } - public void setName(String name) { - this.name = name; - } - - public Date getDate() { - return date; - } - - public void setDate(Date date) { - this.date = date; - } - - @Override - public String toString() { - return "User [id=" + id + ", name=" + name + ", date=" + date + "]"; - } - - } - -} diff --git a/okhttps-jackson/src/test/java/com/ejlchina/okhttps/TestCases.java b/okhttps-jackson/src/test/java/com/ejlchina/okhttps/TestCases.java new file mode 100644 index 00000000..63953de4 --- /dev/null +++ b/okhttps-jackson/src/test/java/com/ejlchina/okhttps/TestCases.java @@ -0,0 +1,88 @@ +package com.ejlchina.okhttps; + +import java.io.ByteArrayInputStream; +import java.io.InputStream; +import java.text.ParseException; +import java.text.SimpleDateFormat; +import java.util.List; +import java.util.Set; + +import org.junit.Assert; +import org.junit.Test; + + +public class TestCases { + + JsonService jsonService = new JacksonService(); + + @Test + public void testToJsonObj() { + String json = "{\"id\":1,\"name\":\"Jack\"}"; + InputStream in = new ByteArrayInputStream(json.getBytes()); + JsonObj jsonObj = jsonService.toJsonObj(in); + Set keys = jsonObj.keySet(); + Assert.assertTrue(keys.size() == 2); + Assert.assertTrue(keys.contains("id")); + Assert.assertTrue(keys.contains("name")); + Assert.assertTrue(!jsonObj.isEmpty()); + Assert.assertTrue(2 == jsonObj.size()); + Assert.assertTrue(1 == jsonObj.getInt("id")); + Assert.assertTrue(!jsonObj.has("age")); + Assert.assertTrue(0 == jsonObj.getInt("age")); + Assert.assertEquals("Jack", jsonObj.getString("name")); + } + + @Test + public void testToJsonArr() { + String json = "[{\"id\":1,\"name\":\"Jack\"},{\"id\":2,\"name\":\"Tom\"}]"; + InputStream in = new ByteArrayInputStream(json.getBytes()); + JsonArr jsonObj = jsonService.toJsonArr(in); + Assert.assertTrue(!jsonObj.isEmpty()); + Assert.assertTrue(jsonObj.size() == 2); + JsonObj json1 = jsonObj.getJsonOjb(0); + JsonObj json2 = jsonObj.getJsonOjb(1); + Assert.assertEquals(1, json1.getInt("id")); + Assert.assertEquals("Jack", json1.getString("name")); + Assert.assertEquals(2, json2.getInt("id")); + Assert.assertEquals("Tom", json2.getString("name")); + } + + @Test + public void testToJsonStr() { + String json = jsonService.toJsonStr(new User(1, "Jack")); + Assert.assertEquals("{\"id\":1,\"name\":\"Jack\"}", json); + } + + @Test + public void testToJsonStrWithDateFormat() throws ParseException { + String dataFormat = "yyyy-MM-dd HH:mm:ss"; + SimpleDateFormat sdf = new SimpleDateFormat(dataFormat); + String date = "2020-05-09 12:30:15"; + String json = jsonService.toJsonStr(new DateBean(1, sdf.parse(date)), dataFormat); + Assert.assertTrue(json.contains(date)); + } + + @Test + public void testJsonToBean() { + String json = "{\"id\":1,\"name\":\"Jack\"}"; + InputStream in = new ByteArrayInputStream(json.getBytes()); + User user = jsonService.jsonToBean(User.class, in); + Assert.assertEquals(1, user.getId()); + Assert.assertEquals("Jack", user.getName()); + } + + @Test + public void testJsonToList() { + String json = "[{\"id\":1,\"name\":\"Jack\"},{\"id\":2,\"name\":\"Tom\"}]"; + InputStream in = new ByteArrayInputStream(json.getBytes()); + List users = jsonService.jsonToList(User.class, in); + Assert.assertTrue(2 == users.size()); + User u1 = users.get(0); + User u2 = users.get(1); + Assert.assertEquals(1, u1.getId()); + Assert.assertEquals("Jack", u1.getName()); + Assert.assertEquals(2, u2.getId()); + Assert.assertEquals("Tom", u2.getName()); + } + +} diff --git a/okhttps-jackson/src/test/java/com/ejlchina/okhttps/User.java b/okhttps-jackson/src/test/java/com/ejlchina/okhttps/User.java new file mode 100644 index 00000000..1fcb6484 --- /dev/null +++ b/okhttps-jackson/src/test/java/com/ejlchina/okhttps/User.java @@ -0,0 +1,66 @@ +package com.ejlchina.okhttps; + +public class User { + + private int id; + private String name; + + + public User() { + } + + public User(int id, String name) { + this.id = id; + this.name = name; + } + + public void setId(int id) { + this.id = id; + } + + public void setName(String name) { + this.name = name; + } + + public int getId() { + return id; + } + + public String getName() { + return name; + } + + @Override + public String toString() { + return "User [id=" + id + ", name=" + name + "]"; + } + + @Override + public int hashCode() { + final int prime = 31; + int result = 1; + result = prime * result + id; + result = prime * result + ((name == null) ? 0 : name.hashCode()); + return result; + } + + @Override + public boolean equals(Object obj) { + if (this == obj) + return true; + if (obj == null) + return false; + if (getClass() != obj.getClass()) + return false; + User other = (User) obj; + if (id != other.id) + return false; + if (name == null) { + if (other.name != null) + return false; + } else if (!name.equals(other.name)) + return false; + return true; + } + +} From e2bdada67bfc3bdc25f3df1abc5d6000db678aa9 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?=E5=91=A8=E6=97=AD?= Date: Sat, 9 May 2020 16:19:34 +0800 Subject: [PATCH 224/924] =?UTF-8?q?HTTP.builder()=20=E6=96=B0=E5=A2=9E=20p?= =?UTF-8?q?reprocTimeoutTimes=20=E6=96=B9=E6=B3=95?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- .../java/com/ejlchina/okhttps/HttpTask.java | 2 +- .../ejlchina/okhttps/internal/HttpClient.java | 28 ++++++++++++++++--- 2 files changed, 25 insertions(+), 5 deletions(-) diff --git a/okhttps/src/main/java/com/ejlchina/okhttps/HttpTask.java b/okhttps/src/main/java/com/ejlchina/okhttps/HttpTask.java index ae2ea2c7..d16e775c 100644 --- a/okhttps/src/main/java/com/ejlchina/okhttps/HttpTask.java +++ b/okhttps/src/main/java/com/ejlchina/okhttps/HttpTask.java @@ -780,7 +780,7 @@ protected void assertNotConflict(boolean isGetRequest) { */ protected boolean timeoutAwait(CountDownLatch latch) { try { - return latch.await(httpClient.totalTimeoutMillis() * 10, + return latch.await(httpClient.preprocTimeoutMillis(), TimeUnit.MILLISECONDS); } catch (InterruptedException e) { throw new HttpException("超时", e); diff --git a/okhttps/src/main/java/com/ejlchina/okhttps/internal/HttpClient.java b/okhttps/src/main/java/com/ejlchina/okhttps/internal/HttpClient.java index 96dca4ef..c622552e 100644 --- a/okhttps/src/main/java/com/ejlchina/okhttps/internal/HttpClient.java +++ b/okhttps/src/main/java/com/ejlchina/okhttps/internal/HttpClient.java @@ -24,7 +24,8 @@ public class HttpClient implements HTTP { final Preprocessor[] preprocessors; // 持有标签的任务 final List tagTasks; - + // 最大预处理时间倍数（相对于普通请求的超时时间） + final int preprocTimeoutTimes; private HttpClient(Builder builder) { this.client = builder.client; @@ -35,6 +36,7 @@ private HttpClient(Builder builder) { builder.responseListener, builder.exceptionListener, builder.completeListener, builder.jsonService); this.preprocessors = builder.preprocessors.toArray(new Preprocessor[0]); + this.preprocTimeoutTimes = builder.preprocTimeoutTimes; this.tagTasks = new LinkedList<>(); } @@ -109,8 +111,10 @@ public OkHttpClient getOkClient() { return client; } - public int totalTimeoutMillis() { - return client.connectTimeoutMillis() + client.writeTimeoutMillis() + client.readTimeoutMillis(); + public int preprocTimeoutMillis() { + return preprocTimeoutTimes * (client.connectTimeoutMillis() + + client.writeTimeoutMillis() + + client.readTimeoutMillis()); } public int getTagTaskCount() { @@ -157,7 +161,7 @@ public class TagTask { boolean isExpired() { // 生存时间大于10倍的总超时限值 - return System.nanoTime() - createAt > 10_000_000 * totalTimeoutMillis(); + return System.nanoTime() - createAt > 1_000_000 * preprocTimeoutMillis(); } public void setTag(String tag) { @@ -353,6 +357,8 @@ public static class Builder { private JsonService jsonService; + private int preprocTimeoutTimes = 10; + public Builder() { mediaTypes = new HashMap<>(); mediaTypes.put("*", "application/octet-stream"); @@ -383,6 +389,7 @@ private Builder(HttpClient hc) { this.exceptionListener = hc.executor.exceptionListener; this.completeListener = hc.executor.completeListener; this.jsonService = hc.executor.jsonService; + this.preprocTimeoutTimes = hc.preprocTimeoutTimes; } /** @@ -462,6 +469,19 @@ public Builder addSerialPreprocessor(Preprocessor preprocessor) { preprocessors.add(new SerialPreprocessor(preprocessor)); return this; } + + /** + * 最大预处理时间（倍数，相当普通请求的超时时间） + * + * @param times 普通超时时间的倍数，默认为 10 + * @return + */ + public Builder preprocTimeoutTimes(int times) { + if (times > 0) { + this.preprocTimeoutTimes = times; + } + return this; + } /** * 设置全局响应监听 From 153f4b4fed97d5ba58b94efe1907ea7c08f8f102 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?=E5=91=A8=E6=97=AD?= Date: Sat, 9 May 2020 16:28:19 +0800 Subject: [PATCH 225/924] =?UTF-8?q?=E4=BC=98=E5=8C=96?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- .../main/java/com/ejlchina/okhttps/HttpTask.java | 16 ++++++++-------- .../ejlchina/okhttps/internal/AsyncHttpTask.java | 2 +- .../ejlchina/okhttps/internal/HttpClient.java | 8 ++++---- .../ejlchina/okhttps/internal/SyncHttpTask.java | 2 +- .../ejlchina/okhttps/internal/WebSocketTask.java | 3 +-- 5 files changed, 15 insertions(+), 16 deletions(-) diff --git a/okhttps/src/main/java/com/ejlchina/okhttps/HttpTask.java b/okhttps/src/main/java/com/ejlchina/okhttps/HttpTask.java index d16e775c..10a6060e 100644 --- a/okhttps/src/main/java/com/ejlchina/okhttps/HttpTask.java +++ b/okhttps/src/main/java/com/ejlchina/okhttps/HttpTask.java @@ -62,8 +62,8 @@ public abstract class HttpTask> implements Cancelable { private TagTask tagTask; private Cancelable canceler; - protected boolean noPreprocess = false; - protected boolean noSerialPreprocess = false; + protected boolean skipPreproc = false; + protected boolean skipSerialPreproc = false; public HttpTask(HttpClient httpClient, String url) { @@ -127,20 +127,20 @@ public C nothrow() { } /** - * 指定该请求不经过任何预处理器 + * 指定该请求跳过任何预处理器（包括串行和并行） * @return HttpTask 实例 */ - public C noPreprocess() { - this.noPreprocess = true; + public C skipPreproc() { + this.skipPreproc = true; return (C) this; } /** - * 指定该请求不经过并行预处理器 + * 指定该请求跳过任何串行预处理器 * @return HttpTask 实例 */ - public C noSerialPreprocess() { - this.noSerialPreprocess = true; + public C skipSerialPreproc() { + this.skipSerialPreproc = true; return (C) this; } diff --git a/okhttps/src/main/java/com/ejlchina/okhttps/internal/AsyncHttpTask.java b/okhttps/src/main/java/com/ejlchina/okhttps/internal/AsyncHttpTask.java index 2fb42b88..8fd8c0ec 100644 --- a/okhttps/src/main/java/com/ejlchina/okhttps/internal/AsyncHttpTask.java +++ b/okhttps/src/main/java/com/ejlchina/okhttps/internal/AsyncHttpTask.java @@ -120,7 +120,7 @@ public HttpCall request(String method) { call.setCall(executeCall(prepareCall(method))); } } - }, noPreprocess, noSerialPreprocess); + }, skipPreproc, skipSerialPreproc); return call; } diff --git a/okhttps/src/main/java/com/ejlchina/okhttps/internal/HttpClient.java b/okhttps/src/main/java/com/ejlchina/okhttps/internal/HttpClient.java index c622552e..958a841f 100644 --- a/okhttps/src/main/java/com/ejlchina/okhttps/internal/HttpClient.java +++ b/okhttps/src/main/java/com/ejlchina/okhttps/internal/HttpClient.java @@ -184,13 +184,13 @@ public TaskExecutor getExecutor() { } public void preprocess(HttpTask> httpTask, Runnable request, - boolean noPreprocess, boolean noSerialPreprocess) { - if (preprocessors.length == 0 || noPreprocess) { + boolean skipPreproc, boolean skipSerialPreproc) { + if (preprocessors.length == 0 || skipPreproc) { request.run(); return; } int index = 0; - if (noSerialPreprocess) { + if (skipSerialPreproc) { while (index < preprocessors.length && preprocessors[index] instanceof SerialPreprocessor) { index++; @@ -199,7 +199,7 @@ public void preprocess(HttpTask> httpTask, Runnable reques if (index < preprocessors.length) { RealPreChain chain = new RealPreChain(preprocessors, httpTask, request, index + 1, - noSerialPreprocess); + skipSerialPreproc); preprocessors[index].doProcess(chain); } else { request.run(); diff --git a/okhttps/src/main/java/com/ejlchina/okhttps/internal/SyncHttpTask.java b/okhttps/src/main/java/com/ejlchina/okhttps/internal/SyncHttpTask.java index ba931fce..f93f4a96 100644 --- a/okhttps/src/main/java/com/ejlchina/okhttps/internal/SyncHttpTask.java +++ b/okhttps/src/main/java/com/ejlchina/okhttps/internal/SyncHttpTask.java @@ -86,7 +86,7 @@ public HttpResult request(String method) { } finally { latch.countDown(); } - }, noPreprocess, noSerialPreprocess); + }, skipPreproc, skipSerialPreproc); boolean timeout = false; if (result.getState() == null) { timeout = !timeoutAwait(latch); diff --git a/okhttps/src/main/java/com/ejlchina/okhttps/internal/WebSocketTask.java b/okhttps/src/main/java/com/ejlchina/okhttps/internal/WebSocketTask.java index 7a36e24a..3f901785 100644 --- a/okhttps/src/main/java/com/ejlchina/okhttps/internal/WebSocketTask.java +++ b/okhttps/src/main/java/com/ejlchina/okhttps/internal/WebSocketTask.java @@ -39,7 +39,7 @@ public WebSocket listen() { socket.setWebSocket(httpClient.webSocket(request, listener)); } } - }, noPreprocess, noSerialPreprocess); + }, skipPreproc, skipSerialPreproc); return socket; } @@ -169,7 +169,6 @@ public boolean send(byte[] data) { return true; } - void queueMsgToSend(Object msg) { if (msg == null) { From dbf9bf56362fdad0a3146b5c746310573fc5cb6f Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?=E5=91=A8=E6=97=AD?= Date: Sat, 9 May 2020 17:11:21 +0800 Subject: [PATCH 226/924] =?UTF-8?q?=E5=85=BC=E5=AE=B9=20fastjson=20android?= =?UTF-8?q?=20=E7=89=88?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- .../src/main/java/com/ejlchina/okhttps/FastJsonService.java | 6 +----- 1 file changed, 1 insertion(+), 5 deletions(-) diff --git a/okhttps-fastjson/src/main/java/com/ejlchina/okhttps/FastJsonService.java b/okhttps-fastjson/src/main/java/com/ejlchina/okhttps/FastJsonService.java index 7cd6436a..8f0c57fe 100644 --- a/okhttps-fastjson/src/main/java/com/ejlchina/okhttps/FastJsonService.java +++ b/okhttps-fastjson/src/main/java/com/ejlchina/okhttps/FastJsonService.java @@ -45,11 +45,7 @@ public String toJsonStr(Object bean, String dateFormat) { @Override public T jsonToBean(Class type, InputStream in) { - try { - return JSON.parseObject(in, type); - } catch (IOException e) { - throw new HttpException("读取文本异常", e); - } + return JSON.parseObject(toString(in), type); } @Override From f9493085205c30361f3197fcf0bd59b6872f657a Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?=E5=91=A8=E6=97=AD?= Date: Sat, 9 May 2020 19:42:58 +0800 Subject: [PATCH 227/924] =?UTF-8?q?=E7=AE=80=E5=8C=96=20WebSocekt=20?= =?UTF-8?q?=E7=BC=96=E7=A8=8B?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- .../java/com/ejlchina/okhttps/WebSocket.java | 103 +++++++++++++++++- .../okhttps/internal/AbstractBody.java | 53 +++++++++ .../okhttps/internal/MessageBody.java | 81 ++++++++++++++ .../ejlchina/okhttps/internal/ResultBody.java | 40 +------ .../okhttps/internal/WebSocketTask.java | 71 ++++++++++-- 5 files changed, 300 insertions(+), 48 deletions(-) create mode 100644 okhttps/src/main/java/com/ejlchina/okhttps/internal/AbstractBody.java create mode 100644 okhttps/src/main/java/com/ejlchina/okhttps/internal/MessageBody.java diff --git a/okhttps/src/main/java/com/ejlchina/okhttps/WebSocket.java b/okhttps/src/main/java/com/ejlchina/okhttps/WebSocket.java index f8cb6e39..1aee7154 100644 --- a/okhttps/src/main/java/com/ejlchina/okhttps/WebSocket.java +++ b/okhttps/src/main/java/com/ejlchina/okhttps/WebSocket.java @@ -1,19 +1,118 @@ package com.ejlchina.okhttps; +import java.io.InputStream; +import java.io.Reader; +import java.util.List; + import okio.ByteString; public interface WebSocket extends Cancelable { + public interface Message { + + /** + * 判断是文本消息还是二进制消息 + * @return 是否是文本消息 + */ + boolean isText(); + + /** + * @return 消息体转字节流 + */ + InputStream toByteStream(); + + /** + * @return 消息体转字节数组 + */ + byte[] toBytes(); + + /** + * @return ByteString + */ + ByteString toByteString(); + + /** + * @return 消息体转字符流 + */ + Reader toCharStream(); + + /** + * @return 消息体转字符串 + */ + String toString(); + + /** + * @return 消息体转Json对象 + */ + JsonObj toJsonObj(); + + /** + * @return 消息体转Json数组 + */ + JsonArr toJsonArr(); + + /** + * @param 目标泛型 + * @param type 目标类型 + * @return 报文体Json文本转JavaBean + */ + T toBean(Class type); + + /** + * @param 目标泛型 + * @param type 目标类型 + * @return 报文体Json文本转JavaBean列表 + */ + List toList(Class type); + + } + + + public static class Close { + + private int code; + private String reason; + + public Close(int code, String reason) { + this.code = code; + this.reason = reason; + } + + public int getCode() { + return code; + } + + public void setCode(int code) { + this.code = code; + } + + public String getReason() { + return reason; + } + + public void setReason(String reason) { + this.reason = reason; + } + + @Override + public String toString() { + return "Close [code=" + code + ", reason=" + reason + "]"; + } + } + + public interface Listener { void on(WebSocket ws, T data); } - /** - * 同 {@link okhttp3.WebSocket#queueSize()} + * 若连接已打开，则： + * 同 {@link okhttp3.WebSocket#queueSize()}，返回排序消息的字节数 + * 否则： + * 返回排队消息的数量 */ long queueSize(); diff --git a/okhttps/src/main/java/com/ejlchina/okhttps/internal/AbstractBody.java b/okhttps/src/main/java/com/ejlchina/okhttps/internal/AbstractBody.java new file mode 100644 index 00000000..d3a0a78e --- /dev/null +++ b/okhttps/src/main/java/com/ejlchina/okhttps/internal/AbstractBody.java @@ -0,0 +1,53 @@ +package com.ejlchina.okhttps.internal; + +import java.io.InputStream; +import java.util.List; + +import com.ejlchina.okhttps.JsonArr; +import com.ejlchina.okhttps.JsonObj; + +public abstract class AbstractBody { + + + protected TaskExecutor taskExecutor; + + + public AbstractBody(TaskExecutor taskExecutor) { + this.taskExecutor = taskExecutor; + } + + public abstract InputStream toByteStream(); + + + public JsonObj toJsonObj() { + if (taskExecutor == null) { + throw new IllegalStateException("没有 taskExecutor，不可做 Json 转换！"); + } + return taskExecutor.jsonServiceNotNull().toJsonObj(toByteStream()); + } + + + public JsonArr toJsonArr() { + if (taskExecutor == null) { + throw new IllegalStateException("没有 taskExecutor，不可做 Json 转换！"); + } + return taskExecutor.jsonServiceNotNull().toJsonArr(toByteStream()); + } + + + public T toBean(Class type) { + if (taskExecutor == null) { + throw new IllegalStateException("没有 taskExecutor，不可做 Json 转换！"); + } + return taskExecutor.jsonServiceNotNull().jsonToBean(type, toByteStream()); + } + + + public List toList(Class type) { + if (taskExecutor == null) { + throw new IllegalStateException("没有 taskExecutor，不可做 Json 转换！"); + } + return taskExecutor.jsonServiceNotNull().jsonToList(type, toByteStream()); + } + +} diff --git a/okhttps/src/main/java/com/ejlchina/okhttps/internal/MessageBody.java b/okhttps/src/main/java/com/ejlchina/okhttps/internal/MessageBody.java new file mode 100644 index 00000000..b3a9e2aa --- /dev/null +++ b/okhttps/src/main/java/com/ejlchina/okhttps/internal/MessageBody.java @@ -0,0 +1,81 @@ +package com.ejlchina.okhttps.internal; + +import java.io.ByteArrayInputStream; +import java.io.IOException; +import java.io.InputStream; +import java.io.InputStreamReader; +import java.io.Reader; +import java.nio.ByteBuffer; +import java.nio.charset.StandardCharsets; + +import com.ejlchina.okhttps.WebSocket.Message; + +import okio.ByteString; + +public class MessageBody extends AbstractBody implements Message { + + private String text; + private ByteString bytes; + + + public MessageBody(String text, TaskExecutor taskExecutor) { + super(taskExecutor); + this.text = text; + } + + public MessageBody(ByteString bytes, TaskExecutor taskExecutor) { + super(taskExecutor); + this.bytes = bytes; + } + + @Override + public boolean isText() { + return text != null; + } + + @Override + public byte[] toBytes() { + if (text != null) { + return text.getBytes(StandardCharsets.UTF_8); + } + if (bytes != null) { + return bytes.toByteArray(); + } + return null; + } + + @Override + public ByteString toByteString() { + if (text != null) { + return ByteString.encodeUtf8(text); + } + return bytes; + } + + @Override + public Reader toCharStream() { + return new InputStreamReader(toByteStream()); + } + + @Override + public InputStream toByteStream() { + if (text != null) { + return new ByteArrayInputStream(text.getBytes(StandardCharsets.UTF_8)); + } + if (bytes != null) { + ByteBuffer buffer = bytes.asByteBuffer(); + return new InputStream() { + + @Override + public int read() throws IOException { + if (buffer.hasRemaining()) { + return buffer.get(); + } + return -1; + } + }; + } + return null; + } + +} diff --git a/okhttps/src/main/java/com/ejlchina/okhttps/internal/ResultBody.java b/okhttps/src/main/java/com/ejlchina/okhttps/internal/ResultBody.java index 44df2806..9bafee28 100644 --- a/okhttps/src/main/java/com/ejlchina/okhttps/internal/ResultBody.java +++ b/okhttps/src/main/java/com/ejlchina/okhttps/internal/ResultBody.java @@ -12,13 +12,10 @@ import java.net.HttpURLConnection; import java.net.URLDecoder; import java.nio.charset.Charset; -import java.util.List; import com.ejlchina.okhttps.Download; import com.ejlchina.okhttps.HttpResult.Body; import com.ejlchina.okhttps.HttpTask; -import com.ejlchina.okhttps.JsonArr; -import com.ejlchina.okhttps.JsonObj; import com.ejlchina.okhttps.OnCallback; import com.ejlchina.okhttps.Process; @@ -26,10 +23,9 @@ import okhttp3.Response; import okio.Buffer; -public class ResultBody implements Body { +public class ResultBody extends AbstractBody implements Body { private Response response; - private TaskExecutor taskExecutor; private boolean onIO = false; private OnCallback onProcess; private long stepBytes = 0; @@ -40,9 +36,9 @@ public class ResultBody implements Body { private byte[] data; ResultBody(HttpTask httpTask, Response response, TaskExecutor taskExecutor) { + super(taskExecutor); this.httpTask = httpTask; this.response = response; - this.taskExecutor = taskExecutor; } @Override @@ -147,38 +143,6 @@ public String toString() { } } - @Override - public JsonObj toJsonObj() { - if (taskExecutor == null) { - throw new IllegalStateException("没有 taskExecutor，不可做 Json 转换！"); - } - return taskExecutor.jsonServiceNotNull().toJsonObj(toByteStream()); - } - - @Override - public JsonArr toJsonArr() { - if (taskExecutor == null) { - throw new IllegalStateException("没有 taskExecutor，不可做 Json 转换！"); - } - return taskExecutor.jsonServiceNotNull().toJsonArr(toByteStream()); - } - - @Override - public T toBean(Class type) { - if (taskExecutor == null) { - throw new IllegalStateException("没有 taskExecutor，不可做 Json 转换！"); - } - return taskExecutor.jsonServiceNotNull().jsonToBean(type, toByteStream()); - } - - @Override - public List toList(Class type) { - if (taskExecutor == null) { - throw new IllegalStateException("没有 taskExecutor，不可做 Json 转换！"); - } - return taskExecutor.jsonServiceNotNull().jsonToList(type, toByteStream()); - } - @Override public Download toFile(String filePath) { return toFile(new File(filePath)); diff --git a/okhttps/src/main/java/com/ejlchina/okhttps/internal/WebSocketTask.java b/okhttps/src/main/java/com/ejlchina/okhttps/internal/WebSocketTask.java index 3f901785..1edd2010 100644 --- a/okhttps/src/main/java/com/ejlchina/okhttps/internal/WebSocketTask.java +++ b/okhttps/src/main/java/com/ejlchina/okhttps/internal/WebSocketTask.java @@ -6,7 +6,9 @@ import com.ejlchina.okhttps.HttpResult; import com.ejlchina.okhttps.HttpTask; import com.ejlchina.okhttps.WebSocket; +import com.ejlchina.okhttps.WebSocket.Close; import com.ejlchina.okhttps.WebSocket.Listener; +import com.ejlchina.okhttps.WebSocket.Message; import okhttp3.Request; import okhttp3.Response; @@ -17,8 +19,11 @@ public class WebSocketTask extends HttpTask { - private Listener onOnen; + private Listener onOpen; private Listener onException; + private Listener onMessage; + private Listener onClosing; + private Listener onClosed; public WebSocketTask(HttpClient httpClient, String url) { @@ -54,30 +59,40 @@ public MessageListener(WebSocket webSocket) { @Override public void onOpen(okhttp3.WebSocket webSocket, Response response) { - if (onOnen != null) { + if (onOpen != null) { HttpResult result = new RealHttpResult(WebSocketTask.this, response, httpClient.executor); - onOnen.on(this.webSocket, result); + onOpen.on(this.webSocket, result); } } + // 接收文本数据 仅当 websocket 消息中的 opcode == 1 时 @Override public void onMessage(okhttp3.WebSocket webSocket, String text) { - // TODO Auto-generated method stub + if (onMessage != null) { + onMessage.on(this.webSocket, new MessageBody(text, httpClient.executor)); + } } + // 接收二进制数据 仅当 websocket 消息中的 opcode == 2 时 @Override public void onMessage(okhttp3.WebSocket webSocket, ByteString bytes) { - // TODO Auto-generated method stub + if (onMessage != null) { + onMessage.on(this.webSocket, new MessageBody(bytes, httpClient.executor)); + } } @Override public void onClosing(okhttp3.WebSocket webSocket, int code, String reason) { - // TODO Auto-generated method stub + if (onClosing != null) { + onClosing.on(this.webSocket, new Close(code, reason)); + } } @Override public void onClosed(okhttp3.WebSocket webSocket, int code, String reason) { - // TODO Auto-generated method stub + if (onClosed != null) { + onClosed.on(this.webSocket, new Close(code, reason)); + } } @Override @@ -129,7 +144,7 @@ public long queueSize() { if (webSocket != null) { return webSocket.queueSize(); } - return 0; + return queues.size(); } @Override @@ -213,4 +228,44 @@ boolean send(okhttp3.WebSocket webSocket, Object msg) { } + /** + * 连接打开监听 + * @param onOpen 监听器 + */ + public void setOnOpen(Listener onOpen) { + this.onOpen = onOpen; + } + + /** + * 连接异常监听 + * @param onException 监听器 + */ + public void setOnException(Listener onException) { + this.onException = onException; + } + + /** + * 消息监听 + * @param onTextMessage 监听器 + */ + public void setOnTextMessage(Listener onMessage) { + this.onMessage = onMessage; + } + + /** + * 正在关闭监听 + * @param onClosing 监听器 + */ + public void setOnClosing(Listener onClosing) { + this.onClosing = onClosing; + } + + /** + * 已关闭监听 + * @param onClosed 监听器 + */ + public void setOnClosed(Listener onClosed) { + this.onClosed = onClosed; + } + } From 43b149afab6c0b41891a7939dbd84445d1154d4d Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?=E5=91=A8=E6=97=AD?= Date: Sat, 9 May 2020 19:46:17 +0800 Subject: [PATCH 228/924] =?UTF-8?q?=E6=B7=BB=E5=8A=A0=E6=B3=A8=E9=87=8A?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- .../java/com/ejlchina/okhttps/internal/WebSocketTask.java | 5 ++++- 1 file changed, 4 insertions(+), 1 deletion(-) diff --git a/okhttps/src/main/java/com/ejlchina/okhttps/internal/WebSocketTask.java b/okhttps/src/main/java/com/ejlchina/okhttps/internal/WebSocketTask.java index 1edd2010..ea88a090 100644 --- a/okhttps/src/main/java/com/ejlchina/okhttps/internal/WebSocketTask.java +++ b/okhttps/src/main/java/com/ejlchina/okhttps/internal/WebSocketTask.java @@ -30,7 +30,10 @@ public WebSocketTask(HttpClient httpClient, String url) { super(httpClient, url); } - + /** + * 启动 WebSocket 监听 + * @return WebSocket + */ public WebSocket listen() { WebSocketImpl socket = new WebSocketImpl(httpClient.executor); registeTagTask(socket); From 74bf97cd4541a0db46349bcc17478f15e25cc2fe Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?=E5=91=A8=E6=97=AD?= Date: Sat, 9 May 2020 19:59:06 +0800 Subject: [PATCH 229/924] =?UTF-8?q?=E7=A7=BB=E9=99=A4=20=20HTTP#sync()=20?= =?UTF-8?q?=E5=92=8C=20HTTP#async()=20=E6=96=B9=E6=B3=95=EF=BC=8C=E5=8F=AF?= =?UTF-8?q?=E4=BD=BF=E7=94=A8=20HTTP#sync(null)=20=E5=92=8C=20HTTP#async(n?= =?UTF-8?q?ull)=20=E4=BB=A3=E6=9B=BF?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- .../main/java/com/ejlchina/okhttps/HTTP.java | 26 +++++-------------- .../java/com/ejlchina/okhttps/HttpUtils.java | 16 ------------ .../ejlchina/okhttps/internal/HttpClient.java | 18 +++++-------- 3 files changed, 14 insertions(+), 46 deletions(-) diff --git a/okhttps/src/main/java/com/ejlchina/okhttps/HTTP.java b/okhttps/src/main/java/com/ejlchina/okhttps/HTTP.java index 12218242..93aec89c 100644 --- a/okhttps/src/main/java/com/ejlchina/okhttps/HTTP.java +++ b/okhttps/src/main/java/com/ejlchina/okhttps/HTTP.java @@ -18,31 +18,19 @@ */ public interface HTTP { - /** - * 异步请求 - * @param url 请求地址 - * @return 异步HTTP任务 - */ - AsyncHttpTask async(String url); - - /** - * 异步请求 - * @return 异步HTTP任务 - */ - AsyncHttpTask async(); - /** * 同步请求 * @param url 请求地址 * @return 同步HTTP任务 */ SyncHttpTask sync(String url); - + /** - * 同步请求 - * @return 同步HTTP任务 + * 异步请求 + * @param url 请求地址 + * @return 异步HTTP任务 */ - SyncHttpTask sync(); + AsyncHttpTask async(String url); /** * Websocket 连接 @@ -66,14 +54,14 @@ public interface HTTP { void cancelAll(); /** - * OkHttp 原生请求 （该请求不经过 预处理器） + * OkHttp 的 HTTP 原生请求 （该请求不经过 预处理器） * @param request 请求 * @return Call */ Call request(Request request); /** - * Websocket（该请求不经过 预处理器） + * OkHttp 的 Websocket 原生请求（该请求不经过 预处理器） * * @param request 请求 * @param listener 监听器 diff --git a/okhttps/src/main/java/com/ejlchina/okhttps/HttpUtils.java b/okhttps/src/main/java/com/ejlchina/okhttps/HttpUtils.java index ae36b8f2..99936b22 100644 --- a/okhttps/src/main/java/com/ejlchina/okhttps/HttpUtils.java +++ b/okhttps/src/main/java/com/ejlchina/okhttps/HttpUtils.java @@ -59,14 +59,6 @@ public static AsyncHttpTask async(String url) { return getHttp().async(url); } - /** - * 异步请求 - * @return 异步 HttpTask - */ - public static AsyncHttpTask async() { - return getHttp().async(); - } - /** * 同步请求 * @param url 请求地址 @@ -76,14 +68,6 @@ public static SyncHttpTask sync(String url) { return getHttp().sync(url); } - /** - * 同步请求 - * @return 同步 HttpTask - */ - public static SyncHttpTask sync() { - return getHttp().sync(); - } - /** * 根据标签取消HTTP任务，只要任务的标签包含指定的Tag就会被取消 * @param tag 标签 diff --git a/okhttps/src/main/java/com/ejlchina/okhttps/internal/HttpClient.java b/okhttps/src/main/java/com/ejlchina/okhttps/internal/HttpClient.java index 958a841f..2502ab72 100644 --- a/okhttps/src/main/java/com/ejlchina/okhttps/internal/HttpClient.java +++ b/okhttps/src/main/java/com/ejlchina/okhttps/internal/HttpClient.java @@ -40,21 +40,11 @@ private HttpClient(Builder builder) { this.tagTasks = new LinkedList<>(); } - @Override - public AsyncHttpTask async() { - return async(null); - } - @Override public AsyncHttpTask async(String url) { return new AsyncHttpTask(this, urlPath(url)); } - @Override - public SyncHttpTask sync() { - return sync(null); - } - @Override public SyncHttpTask sync(String url) { return new SyncHttpTask(this, urlPath(url)); @@ -62,7 +52,13 @@ public SyncHttpTask sync(String url) { @Override public WebSocketTask webSocket(String url) { - return new WebSocketTask(this, urlPath(url)); + String path = urlPath(url); + if (path.startsWith("https://")) { + path = path.replace("https://", "wss://"); + } else if (path.startsWith("http://")) { + path = path.replace("http://", "ws://"); + } + return new WebSocketTask(this, path); } @Override From 8786fe23032166e57a0f185c22331685e8eb420e Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?=E5=91=A8=E6=97=AD?= Date: Sat, 9 May 2020 23:00:34 +0800 Subject: [PATCH 230/924] =?UTF-8?q?=E6=95=B4=E7=90=86?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- okhttps-fastjson/pom.xml | 2 +- okhttps-gson/pom.xml | 2 +- okhttps-jackson/pom.xml | 2 +- okhttps-kotlin/pom.xml | 2 +- .../java/com/ejlchina/okhttps/JsonArr.java | 4 ++-- .../java/com/ejlchina/okhttps/WebSocket.java | 4 ++++ .../ejlchina/okhttps/internal/HttpClient.java | 2 +- .../okhttps/internal/SyncHttpTask.java | 2 +- .../okhttps/internal/WebSocketTask.java | 22 ++++++++++++++----- pom.xml | 3 ++- 10 files changed, 30 insertions(+), 15 deletions(-) diff --git a/okhttps-fastjson/pom.xml b/okhttps-fastjson/pom.xml index a68e2685..2ce76aa4 100644 --- a/okhttps-fastjson/pom.xml +++ b/okhttps-fastjson/pom.xml @@ -8,7 +8,7 @@ com.ejlchina okhttps-parent - ${okhttps.version} + 2.0.0 diff --git a/okhttps-gson/pom.xml b/okhttps-gson/pom.xml index 7d511711..3fefaaf1 100644 --- a/okhttps-gson/pom.xml +++ b/okhttps-gson/pom.xml @@ -8,7 +8,7 @@ com.ejlchina okhttps-parent - ${okhttps.version} + 2.0.0 diff --git a/okhttps-jackson/pom.xml b/okhttps-jackson/pom.xml index 381ca8d1..62d867ec 100644 --- a/okhttps-jackson/pom.xml +++ b/okhttps-jackson/pom.xml @@ -8,7 +8,7 @@ com.ejlchina okhttps-parent - ${okhttps.version} + 2.0.0 diff --git a/okhttps-kotlin/pom.xml b/okhttps-kotlin/pom.xml index 48cdb7ed..799eef8c 100644 --- a/okhttps-kotlin/pom.xml +++ b/okhttps-kotlin/pom.xml @@ -8,7 +8,7 @@ com.ejlchina okhttps-parent - ${okhttps.version} + 2.0.0 diff --git a/okhttps/src/main/java/com/ejlchina/okhttps/JsonArr.java b/okhttps/src/main/java/com/ejlchina/okhttps/JsonArr.java index 063fb7fe..e9782b66 100644 --- a/okhttps/src/main/java/com/ejlchina/okhttps/JsonArr.java +++ b/okhttps/src/main/java/com/ejlchina/okhttps/JsonArr.java @@ -64,13 +64,13 @@ public interface JsonArr { String getString(int index); /** - * @param key 键名 + * @param index 元素下标 * @return BigDecimal 值 */ BigDecimal getBigDecimal(int index); /** - * @param key 键名 + * @param index 元素下标 * @return BigInteger 值 */ BigInteger getBigInteger(int index); diff --git a/okhttps/src/main/java/com/ejlchina/okhttps/WebSocket.java b/okhttps/src/main/java/com/ejlchina/okhttps/WebSocket.java index 1aee7154..fad33e60 100644 --- a/okhttps/src/main/java/com/ejlchina/okhttps/WebSocket.java +++ b/okhttps/src/main/java/com/ejlchina/okhttps/WebSocket.java @@ -118,11 +118,15 @@ public interface Listener { /** * 同 {@link okhttp3.WebSocket#send(String)} + * @param text 文本数据 + * @return 是否可以发送 */ boolean send(String text); /** * 同 {@link okhttp3.WebSocket#send(ByteString)} + * @param bytes 二进制数据 + * @return 是否可以发送 */ boolean send(ByteString bytes); diff --git a/okhttps/src/main/java/com/ejlchina/okhttps/internal/HttpClient.java b/okhttps/src/main/java/com/ejlchina/okhttps/internal/HttpClient.java index 2502ab72..923b470e 100644 --- a/okhttps/src/main/java/com/ejlchina/okhttps/internal/HttpClient.java +++ b/okhttps/src/main/java/com/ejlchina/okhttps/internal/HttpClient.java @@ -470,7 +470,7 @@ public Builder addSerialPreprocessor(Preprocessor preprocessor) { * 最大预处理时间（倍数，相当普通请求的超时时间） * * @param times 普通超时时间的倍数，默认为 10 - * @return + * @return Builder */ public Builder preprocTimeoutTimes(int times) { if (times > 0) { diff --git a/okhttps/src/main/java/com/ejlchina/okhttps/internal/SyncHttpTask.java b/okhttps/src/main/java/com/ejlchina/okhttps/internal/SyncHttpTask.java index f93f4a96..f574880f 100644 --- a/okhttps/src/main/java/com/ejlchina/okhttps/internal/SyncHttpTask.java +++ b/okhttps/src/main/java/com/ejlchina/okhttps/internal/SyncHttpTask.java @@ -57,7 +57,7 @@ public HttpResult delete() { /** * 发起 HTTP 请求 - * @param method + * @param method 请求方法 * @return 请求结果 */ public HttpResult request(String method) { diff --git a/okhttps/src/main/java/com/ejlchina/okhttps/internal/WebSocketTask.java b/okhttps/src/main/java/com/ejlchina/okhttps/internal/WebSocketTask.java index ea88a090..b0da5adc 100644 --- a/okhttps/src/main/java/com/ejlchina/okhttps/internal/WebSocketTask.java +++ b/okhttps/src/main/java/com/ejlchina/okhttps/internal/WebSocketTask.java @@ -234,41 +234,51 @@ boolean send(okhttp3.WebSocket webSocket, Object msg) { /** * 连接打开监听 * @param onOpen 监听器 + * @return WebSocketTask */ - public void setOnOpen(Listener onOpen) { + public WebSocketTask setOnOpen(Listener onOpen) { this.onOpen = onOpen; + return this; } /** * 连接异常监听 * @param onException 监听器 + * @return WebSocketTask */ - public void setOnException(Listener onException) { + public WebSocketTask setOnException(Listener onException) { this.onException = onException; + return this; } /** * 消息监听 - * @param onTextMessage 监听器 + * @param onMessage 监听器 + * @return WebSocketTask */ - public void setOnTextMessage(Listener onMessage) { + public WebSocketTask setOnTextMessage(Listener onMessage) { this.onMessage = onMessage; + return this; } /** * 正在关闭监听 * @param onClosing 监听器 + * @return WebSocketTask */ - public void setOnClosing(Listener onClosing) { + public WebSocketTask setOnClosing(Listener onClosing) { this.onClosing = onClosing; + return this; } /** * 已关闭监听 * @param onClosed 监听器 + * @return WebSocketTask */ - public void setOnClosed(Listener onClosed) { + public WebSocketTask setOnClosed(Listener onClosed) { this.onClosed = onClosed; + return this; } } diff --git a/pom.xml b/pom.xml index 59c0f71d..9975fd79 100644 --- a/pom.xml +++ b/pom.xml @@ -3,7 +3,7 @@ com.ejlchina okhttps-parent - ${okhttps.version} + 2.0.0 OkHttps pom @@ -113,6 +113,7 @@ org.apache.maven.plugins maven-compiler-plugin + 3.8.1 ${java-version} ${java-version} From a04a03df8ea65bc4cb7562acf1d884c8160baabc Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?=E5=91=A8=E6=97=AD?= Date: Sat, 9 May 2020 23:03:42 +0800 Subject: [PATCH 231/924] ignore --- .gitignore | 2 ++ 1 file changed, 2 insertions(+) diff --git a/.gitignore b/.gitignore index 5a66362c..ea5b62f4 100644 --- a/.gitignore +++ b/.gitignore @@ -8,6 +8,8 @@ /*/node_modules/ /*/.vuepress/dist/* /*/*.iml +**.versionsBackup +/target/ *.iml /.idea/ .settings/ From 3051ae2a22faa266f3e5bdb376153c3f5338a00e Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?=E5=91=A8=E6=97=AD?= Date: Sat, 9 May 2020 23:04:48 +0800 Subject: [PATCH 232/924] delete kotlin --- okhttps-kotlin/pom.xml | 25 ------------------------- 1 file changed, 25 deletions(-) delete mode 100644 okhttps-kotlin/pom.xml diff --git a/okhttps-kotlin/pom.xml b/okhttps-kotlin/pom.xml deleted file mode 100644 index 799eef8c..00000000 --- a/okhttps-kotlin/pom.xml +++ /dev/null @@ -1,25 +0,0 @@ - - 4.0.0 - - okhttps-kotlin - OkHttps Kotlin - jar - - - com.ejlchina - okhttps-parent - 2.0.0 - - - - - com.ejlchina - okhttps - ${okhttps.version} - - - - - okhttps-kotlin - - \ No newline at end of file From 696b2acad9d02ca3c76ef372b4e32721ea99becf Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?=E5=91=A8=E6=97=AD?= Date: Sat, 9 May 2020 23:05:05 +0800 Subject: [PATCH 233/924] modules --- pom.xml | 1 - 1 file changed, 1 deletion(-) diff --git a/pom.xml b/pom.xml index 9975fd79..5440f01d 100644 --- a/pom.xml +++ b/pom.xml @@ -13,7 +13,6 @@ okhttps-fastjson okhttps-gson okhttps-jackson - okhttps-kotlin From e69bd8c94a0f700d1019f60db90e42b265cef49e Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?=E5=91=A8=E6=97=AD?= <15735559897@qq.com> Date: Sun, 10 May 2020 00:48:17 +0800 Subject: [PATCH 234/924] baidu-tongji --- okhttps-doc/package.json | 1 + 1 file changed, 1 insertion(+) diff --git a/okhttps-doc/package.json b/okhttps-doc/package.json index cfbe1cec..f9d1f6a9 100644 --- a/okhttps-doc/package.json +++ b/okhttps-doc/package.json @@ -7,6 +7,7 @@ "@vuepress/plugin-back-to-top": "^1.4.1", "vuepress": "^1.4.1", "vuepress-plugin-baidu-autopush": "^1.0.1", + "vuepress-plugin-baidu-tongji": "^1.0.1", "vuepress-plugin-seo": "^0.1.2" }, "dependencies": { From 4f795193ba3ceb4d4157f85eded9766f6bf03240 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?=E5=91=A8=E6=97=AD?= <15735559897@qq.com> Date: Sun, 10 May 2020 13:45:28 +0800 Subject: [PATCH 235/924] =?UTF-8?q?MessageBody=20=E5=AE=9E=E7=8E=B0=20toSt?= =?UTF-8?q?ring=20=E6=96=B9=E6=B3=95?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- .../com/ejlchina/okhttps/internal/MessageBody.java | 11 +++++++++++ 1 file changed, 11 insertions(+) diff --git a/okhttps/src/main/java/com/ejlchina/okhttps/internal/MessageBody.java b/okhttps/src/main/java/com/ejlchina/okhttps/internal/MessageBody.java index b3a9e2aa..4da07e39 100644 --- a/okhttps/src/main/java/com/ejlchina/okhttps/internal/MessageBody.java +++ b/okhttps/src/main/java/com/ejlchina/okhttps/internal/MessageBody.java @@ -44,6 +44,17 @@ public byte[] toBytes() { return null; } + @Override + public String toString() { + if (text != null) { + return text; + } + if (bytes != null) { + return bytes.utf8(); + } + return null; + } + @Override public ByteString toByteString() { if (text != null) { From 565c8a9b0eab923ca0caf1acfbd1a60ea6a487b4 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?=E5=91=A8=E6=97=AD?= <15735559897@qq.com> Date: Sun, 10 May 2020 13:45:55 +0800 Subject: [PATCH 236/924] =?UTF-8?q?=E4=BC=98=E5=8C=96?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- .../ejlchina/okhttps/internal/HttpClient.java | 44 +++++++++++-------- .../okhttps/internal/WebSocketTask.java | 2 +- 2 files changed, 26 insertions(+), 20 deletions(-) diff --git a/okhttps/src/main/java/com/ejlchina/okhttps/internal/HttpClient.java b/okhttps/src/main/java/com/ejlchina/okhttps/internal/HttpClient.java index 923b470e..75e9de3d 100644 --- a/okhttps/src/main/java/com/ejlchina/okhttps/internal/HttpClient.java +++ b/okhttps/src/main/java/com/ejlchina/okhttps/internal/HttpClient.java @@ -42,23 +42,17 @@ private HttpClient(Builder builder) { @Override public AsyncHttpTask async(String url) { - return new AsyncHttpTask(this, urlPath(url)); + return new AsyncHttpTask(this, urlPath(url, false)); } @Override public SyncHttpTask sync(String url) { - return new SyncHttpTask(this, urlPath(url)); + return new SyncHttpTask(this, urlPath(url, false)); } @Override public WebSocketTask webSocket(String url) { - String path = urlPath(url); - if (path.startsWith("https://")) { - path = path.replace("https://", "wss://"); - } else if (path.startsWith("http://")) { - path = path.replace("http://", "ws://"); - } - return new WebSocketTask(this, path); + return new WebSocketTask(this, urlPath(url, true)); } @Override @@ -311,22 +305,34 @@ public Builder newBuilder() { return new Builder(this); } - private String urlPath(String urlPath) { + private String urlPath(String urlPath, boolean websocket) { + String fullUrl; if (urlPath == null) { if (baseUrl != null) { - return baseUrl; + fullUrl = baseUrl; + } else { + throw new HttpException("在设置 BaseUrl 之前，您必须指定具体路径才能发起请求！"); + } + } else { + boolean isFullPath = urlPath.startsWith("https://") + || urlPath.startsWith("http://") + || urlPath.startsWith("wss://") + || urlPath.startsWith("ws://"); + if (isFullPath) { + fullUrl = urlPath; + } else if (baseUrl != null) { + fullUrl = baseUrl + urlPath; + } else { + throw new HttpException("在设置 BaseUrl 之前，您必须使用全路径URL发起请求，当前URL为：" + urlPath); } - throw new HttpException("在设置 BaseUrl 之前，您必须指定具体路径才能发起请求！"); } - boolean isFullPath = urlPath.startsWith("https://") - || urlPath.startsWith("http://"); - if (isFullPath) { - return urlPath; + if (websocket && fullUrl.startsWith("http")) { + return fullUrl.replaceFirst("http", "ws"); } - if (baseUrl != null) { - return baseUrl + urlPath; + if (!websocket && fullUrl.startsWith("ws")) { + return fullUrl.replaceFirst("ws", "http"); } - throw new HttpException("在设置 BaseUrl 之前，您必须使用全路径URL发起请求，当前URL为：" + urlPath); + return fullUrl; } public static class Builder { diff --git a/okhttps/src/main/java/com/ejlchina/okhttps/internal/WebSocketTask.java b/okhttps/src/main/java/com/ejlchina/okhttps/internal/WebSocketTask.java index b0da5adc..c4a31090 100644 --- a/okhttps/src/main/java/com/ejlchina/okhttps/internal/WebSocketTask.java +++ b/okhttps/src/main/java/com/ejlchina/okhttps/internal/WebSocketTask.java @@ -256,7 +256,7 @@ public WebSocketTask setOnException(Listener onException) { * @param onMessage 监听器 * @return WebSocketTask */ - public WebSocketTask setOnTextMessage(Listener onMessage) { + public WebSocketTask setOnMessage(Listener onMessage) { this.onMessage = onMessage; return this; } From b44acebc946de32c67edfa1a8cc31bd063fcefc3 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?=E5=91=A8=E6=97=AD?= <15735559897@qq.com> Date: Sun, 10 May 2020 14:24:19 +0800 Subject: [PATCH 237/924] =?UTF-8?q?HttpUtils=20=E8=87=AA=E5=8A=A8=E5=AF=BB?= =?UTF-8?q?=E6=89=BE=20JsonService?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- .../java/com/ejlchina/okhttps/HttpUtils.java | 24 ++++++++++++++++++- 1 file changed, 23 insertions(+), 1 deletion(-) diff --git a/okhttps/src/main/java/com/ejlchina/okhttps/HttpUtils.java b/okhttps/src/main/java/com/ejlchina/okhttps/HttpUtils.java index 99936b22..9aac93b5 100644 --- a/okhttps/src/main/java/com/ejlchina/okhttps/HttpUtils.java +++ b/okhttps/src/main/java/com/ejlchina/okhttps/HttpUtils.java @@ -46,10 +46,32 @@ static synchronized HTTP getHttp() { if (http != null) { return http; } - http = HTTP.builder().build(); + http = HTTP.builder().jsonService(findJsonService(new String[] { + "com.ejlchina.okhttps.GsonService", + "com.ejlchina.okhttps.FastJsonService", + "com.ejlchina.okhttps.JacksonService" + }, 0)).build(); return http; } + static JsonService findJsonService(String[] classes, int index) { + if (index >= classes.length) { + return null; + } + Class clazz = null; + try { + clazz = Class.forName(classes[0]); + } catch (Exception ignore) {} + if (clazz == null || !JsonService.class.isAssignableFrom(clazz)) { + return findJsonService(classes, index + 1); + } + try { + return (JsonService) clazz.getDeclaredConstructor().newInstance(); + } catch (Exception ignore) { + return null; + } + } + /** * 异步请求 * @param url 请求地址 From e321ed3dbca91f4f1737324407d35e2089097d0d Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?=E5=91=A8=E6=97=AD?= <15735559897@qq.com> Date: Sun, 10 May 2020 14:34:03 +0800 Subject: [PATCH 238/924] . --- okhttps-doc/.gitignore | 5 + okhttps-doc/docs/.vuepress/dist/404.html | 19 -- .../dist/assets/css/0.styles.86d9e6f9.css | 1 - .../dist/assets/img/search.83621669.svg | 1 - .../.vuepress/dist/assets/js/10.bc5e580e.js | 1 - .../.vuepress/dist/assets/js/11.152d132f.js | 1 - .../.vuepress/dist/assets/js/12.92e24a16.js | 1 - .../.vuepress/dist/assets/js/13.d857e269.js | 1 - .../.vuepress/dist/assets/js/2.16cbe9f2.js | 1 - .../.vuepress/dist/assets/js/3.972ca2ed.js | 1 - .../.vuepress/dist/assets/js/4.fe3bf0b0.js | 1 - .../.vuepress/dist/assets/js/5.93d38f11.js | 1 - .../.vuepress/dist/assets/js/6.fd474f39.js | 1 - .../.vuepress/dist/assets/js/7.51e5642d.js | 1 - .../.vuepress/dist/assets/js/8.d296d289.js | 1 - .../.vuepress/dist/assets/js/9.bff804f8.js | 1 - .../.vuepress/dist/assets/js/app.1e2fa6f5.js | 13 -- .../docs/.vuepress/dist/guide/android.html | 161 --------------- .../.vuepress/dist/guide/configuration.html | 137 ------------ .../docs/.vuepress/dist/guide/features.html | 150 -------------- .../docs/.vuepress/dist/guide/foundation.html | 130 ------------ .../docs/.vuepress/dist/guide/index.html | 79 ------- .../docs/.vuepress/dist/guide/updown.html | 195 ------------------ okhttps-doc/docs/.vuepress/dist/index.html | 72 ------- okhttps-doc/docs/.vuepress/dist/logo.png | Bin 5800 -> 0 bytes .../java/com/ejlchina/test/SimpleTests.java | 16 +- .../com/ejlchina/test/WebSocketTests.java | 50 +++++ 27 files changed, 64 insertions(+), 977 deletions(-) create mode 100644 okhttps-doc/.gitignore delete mode 100644 okhttps-doc/docs/.vuepress/dist/404.html delete mode 100644 okhttps-doc/docs/.vuepress/dist/assets/css/0.styles.86d9e6f9.css delete mode 100644 okhttps-doc/docs/.vuepress/dist/assets/img/search.83621669.svg delete mode 100644 okhttps-doc/docs/.vuepress/dist/assets/js/10.bc5e580e.js delete mode 100644 okhttps-doc/docs/.vuepress/dist/assets/js/11.152d132f.js delete mode 100644 okhttps-doc/docs/.vuepress/dist/assets/js/12.92e24a16.js delete mode 100644 okhttps-doc/docs/.vuepress/dist/assets/js/13.d857e269.js delete mode 100644 okhttps-doc/docs/.vuepress/dist/assets/js/2.16cbe9f2.js delete mode 100644 okhttps-doc/docs/.vuepress/dist/assets/js/3.972ca2ed.js delete mode 100644 okhttps-doc/docs/.vuepress/dist/assets/js/4.fe3bf0b0.js delete mode 100644 okhttps-doc/docs/.vuepress/dist/assets/js/5.93d38f11.js delete mode 100644 okhttps-doc/docs/.vuepress/dist/assets/js/6.fd474f39.js delete mode 100644 okhttps-doc/docs/.vuepress/dist/assets/js/7.51e5642d.js delete mode 100644 okhttps-doc/docs/.vuepress/dist/assets/js/8.d296d289.js delete mode 100644 okhttps-doc/docs/.vuepress/dist/assets/js/9.bff804f8.js delete mode 100644 okhttps-doc/docs/.vuepress/dist/assets/js/app.1e2fa6f5.js delete mode 100644 okhttps-doc/docs/.vuepress/dist/guide/android.html delete mode 100644 okhttps-doc/docs/.vuepress/dist/guide/configuration.html delete mode 100644 okhttps-doc/docs/.vuepress/dist/guide/features.html delete mode 100644 okhttps-doc/docs/.vuepress/dist/guide/foundation.html delete mode 100644 okhttps-doc/docs/.vuepress/dist/guide/index.html delete mode 100644 okhttps-doc/docs/.vuepress/dist/guide/updown.html delete mode 100644 okhttps-doc/docs/.vuepress/dist/index.html delete mode 100644 okhttps-doc/docs/.vuepress/dist/logo.png create mode 100644 okhttps/src/test/java/com/ejlchina/test/WebSocketTests.java diff --git a/okhttps-doc/.gitignore b/okhttps-doc/.gitignore new file mode 100644 index 00000000..e2a59199 --- /dev/null +++ b/okhttps-doc/.gitignore @@ -0,0 +1,5 @@ +/package-lock.json +/node_modules/ +/docs/.vuepress/dist/ +/docs/.vuepress/dist/* +docs/.vuepress/dist/* \ No newline at end of file diff --git a/okhttps-doc/docs/.vuepress/dist/404.html b/okhttps-doc/docs/.vuepress/dist/404.html deleted file mode 100644 index 8d2b3afc..00000000 --- a/okhttps-doc/docs/.vuepress/dist/404.html +++ /dev/null @@ -1,19 +0,0 @@ - - - - - - OkHttps - - - - - - - -

404

That's a Four-Oh-Four.
- Take me home. -
- - - diff --git a/okhttps-doc/docs/.vuepress/dist/assets/css/0.styles.86d9e6f9.css b/okhttps-doc/docs/.vuepress/dist/assets/css/0.styles.86d9e6f9.css deleted file mode 100644 index 355d531c..00000000 --- a/okhttps-doc/docs/.vuepress/dist/assets/css/0.styles.86d9e6f9.css +++ /dev/null @@ -1 +0,0 @@ -#nprogress{pointer-events:none}#nprogress .bar{background:#3eaf7c;position:fixed;z-index:1031;top:0;left:0;width:100%;height:2px}#nprogress .peg{display:block;position:absolute;right:0;width:100px;height:100%;box-shadow:0 0 10px #3eaf7c,0 0 5px #3eaf7c;opacity:1;transform:rotate(3deg) translateY(-4px)}#nprogress .spinner{display:block;position:fixed;z-index:1031;top:15px;right:15px}#nprogress .spinner-icon{width:18px;height:18px;box-sizing:border-box;border-color:#3eaf7c transparent transparent #3eaf7c;border-style:solid;border-width:2px;border-radius:50%;-webkit-animation:nprogress-spinner .4s linear infinite;animation:nprogress-spinner .4s linear infinite}.nprogress-custom-parent{overflow:hidden;position:relative}.nprogress-custom-parent #nprogress .bar,.nprogress-custom-parent #nprogress .spinner{position:absolute}@-webkit-keyframes nprogress-spinner{0%{transform:rotate(0deg)}to{transform:rotate(1turn)}}@keyframes nprogress-spinner{0%{transform:rotate(0deg)}to{transform:rotate(1turn)}}html{scroll-behavior:smooth}.go-to-top[data-v-5fd4ef0c]{cursor:pointer;position:fixed;bottom:2rem;right:2.5rem;width:2rem;color:#3eaf7c;z-index:1}.go-to-top[data-v-5fd4ef0c]:hover{color:#72cda4}@media (max-width:959px){.go-to-top[data-v-5fd4ef0c]{display:none}}.fade-enter-active[data-v-5fd4ef0c],.fade-leave-active[data-v-5fd4ef0c]{transition:opacity .3s}.fade-enter[data-v-5fd4ef0c],.fade-leave-to[data-v-5fd4ef0c]{opacity:0}.code-switcher div[class*=language-]:before{content:""}.code-switcher .tab-header ul{padding:0;text-align:right;margin-bottom:-5px;margin-top:20px}.code-switcher .tab-header li{display:inline-block;padding:0 10px;cursor:pointer;border-radius:4px;border:2px solid #eaecef;margin-left:5px;font-size:80%}.code-switcher .tab-header li.active{border-color:#3eaf7c}.icon.outbound{color:#aaa;display:inline-block;vertical-align:middle;position:relative;top:-1px}.home{padding:3.6rem 2rem 0;max-width:960px;margin:0 auto;display:block}.home .hero{text-align:center}.home .hero img{max-width:100%;max-height:280px;display:block;margin:3rem auto 1.5rem}.home .hero h1{font-size:3rem}.home .hero .action,.home .hero .description,.home .hero h1{margin:1.8rem auto}.home .hero .description{max-width:35rem;font-size:1.6rem;line-height:1.3;color:#6a8bad}.home .hero .action-button{display:inline-block;font-size:1.2rem;color:#fff;background-color:#3eaf7c;padding:.8rem 1.6rem;border-radius:4px;transition:background-color .1s ease;box-sizing:border-box;border-bottom:1px solid #389d70}.home .hero .action-button:hover{background-color:#4abf8a}.home .features{border-top:1px solid #eaecef;padding:1.2rem 0;margin-top:2.5rem;display:flex;flex-wrap:wrap;align-items:flex-start;align-content:stretch;justify-content:space-between}.home .feature{flex-grow:1;flex-basis:30%;max-width:30%}.home .feature h2{font-size:1.4rem;font-weight:500;border-bottom:none;padding-bottom:0;color:#3a5169}.home .feature p{color:#4e6e8e}.home .footer{padding:2.5rem;border-top:1px solid #eaecef;text-align:center;color:#4e6e8e}@media (max-width:719px){.home .features{flex-direction:column}.home .feature{max-width:100%;padding:0 2.5rem}}@media (max-width:419px){.home{padding-left:1.5rem;padding-right:1.5rem}.home .hero img{max-height:210px;margin:2rem auto 1.2rem}.home .hero h1{font-size:2rem}.home .hero .action,.home .hero .description,.home .hero h1{margin:1.2rem auto}.home .hero .description{font-size:1.2rem}.home .hero .action-button{font-size:1rem;padding:.6rem 1.2rem}.home .feature h2{font-size:1.25rem}}.search-box{display:inline-block;position:relative;margin-right:1rem}.search-box input{cursor:text;width:10rem;height:2rem;color:#4e6e8e;display:inline-block;border:1px solid #cfd4db;border-radius:2rem;font-size:.9rem;line-height:2rem;padding:0 .5rem 0 2rem;outline:none;transition:all .2s ease;background:#fff url(/assets/img/search.83621669.svg) .6rem .5rem no-repeat;background-size:1rem}.search-box input:focus{cursor:auto;border-color:#3eaf7c}.search-box .suggestions{background:#fff;width:20rem;position:absolute;top:2rem;border:1px solid #cfd4db;border-radius:6px;padding:.4rem;list-style-type:none}.search-box .suggestions.align-right{right:0}.search-box .suggestion{line-height:1.4;padding:.4rem .6rem;border-radius:4px;cursor:pointer}.search-box .suggestion a{white-space:normal;color:#5d82a6}.search-box .suggestion a .page-title{font-weight:600}.search-box .suggestion a .header{font-size:.9em;margin-left:.25em}.search-box .suggestion.focused{background-color:#f3f4f5}.search-box .suggestion.focused a{color:#3eaf7c}@media (max-width:959px){.search-box input{cursor:pointer;width:0;border-color:transparent;position:relative}.search-box input:focus{cursor:text;left:0;width:10rem}}@media (-ms-high-contrast:none){.search-box input{height:2rem}}@media (max-width:959px) and (min-width:719px){.search-box .suggestions{left:0}}@media (max-width:719px){.search-box{margin-right:0}.search-box input{left:1rem}.search-box .suggestions{right:0}}@media (max-width:419px){.search-box .suggestions{width:calc(100vw - 4rem)}.search-box input:focus{width:8rem}}.sidebar-button{cursor:pointer;display:none;width:1.25rem;height:1.25rem;position:absolute;padding:.6rem;top:.6rem;left:1rem}.sidebar-button .icon{display:block;width:1.25rem;height:1.25rem}@media (max-width:719px){.sidebar-button{display:block}}.dropdown-enter,.dropdown-leave-to{height:0!important}.dropdown-wrapper{cursor:pointer}.dropdown-wrapper .dropdown-title{display:block;font-size:.9rem;font-family:inherit;cursor:inherit;padding:inherit;line-height:1.4rem;background:transparent;border:none;font-weight:500;color:#2c3e50;pointer-events:none}.dropdown-wrapper .dropdown-title:hover{border-color:transparent}.dropdown-wrapper .dropdown-title .arrow{vertical-align:middle;margin-top:-1px;margin-left:.4rem}.dropdown-wrapper .nav-dropdown .dropdown-item{color:inherit;line-height:1.7rem}.dropdown-wrapper .nav-dropdown .dropdown-item h4{margin:.45rem 0 0;border-top:1px solid #eee;padding:.45rem 1.5rem 0 1.25rem}.dropdown-wrapper .nav-dropdown .dropdown-item .dropdown-subitem-wrapper{padding:0;list-style:none}.dropdown-wrapper .nav-dropdown .dropdown-item .dropdown-subitem-wrapper .dropdown-subitem{font-size:.9em}.dropdown-wrapper .nav-dropdown .dropdown-item a{display:block;line-height:1.7rem;position:relative;border-bottom:none;font-weight:400;margin-bottom:0;padding:0 1.5rem 0 1.25rem}.dropdown-wrapper .nav-dropdown .dropdown-item a.router-link-active,.dropdown-wrapper .nav-dropdown .dropdown-item a:hover{color:#3eaf7c}.dropdown-wrapper .nav-dropdown .dropdown-item a.router-link-active:after{content:"";width:0;height:0;border-left:5px solid #3eaf7c;border-top:3px solid transparent;border-bottom:3px solid transparent;position:absolute;top:calc(50% - 2px);left:9px}.dropdown-wrapper .nav-dropdown .dropdown-item:first-child h4{margin-top:0;padding-top:0;border-top:0}@media (max-width:719px){.dropdown-wrapper.open .dropdown-title{margin-bottom:.5rem}.dropdown-wrapper .dropdown-title{font-weight:600;font-size:inherit}.dropdown-wrapper .dropdown-title:hover{color:#3eaf7c}.dropdown-wrapper .nav-dropdown{transition:height .1s ease-out;overflow:hidden}.dropdown-wrapper .nav-dropdown .dropdown-item h4{border-top:0;margin-top:0;padding-top:0}.dropdown-wrapper .nav-dropdown .dropdown-item>a,.dropdown-wrapper .nav-dropdown .dropdown-item h4{font-size:15px;line-height:2rem}.dropdown-wrapper .nav-dropdown .dropdown-item .dropdown-subitem{font-size:14px;padding-left:1rem}}@media (min-width:719px){.dropdown-wrapper{height:1.8rem}.dropdown-wrapper.open .nav-dropdown,.dropdown-wrapper:hover .nav-dropdown{display:block!important}.dropdown-wrapper.open:blur{display:none}.dropdown-wrapper .dropdown-title .arrow{border-left:4px solid transparent;border-right:4px solid transparent;border-top:6px solid #ccc;border-bottom:0}.dropdown-wrapper .nav-dropdown{display:none;height:auto!important;box-sizing:border-box;max-height:calc(100vh - 2.7rem);overflow-y:auto;position:absolute;top:100%;right:0;background-color:#fff;padding:.6rem 0;border:1px solid;border-color:#ddd #ddd #ccc;text-align:left;border-radius:.25rem;white-space:nowrap;margin:0}}.nav-links{display:inline-block}.nav-links a{line-height:1.4rem;color:inherit}.nav-links a.router-link-active,.nav-links a:hover{color:#3eaf7c}.nav-links .nav-item{position:relative;display:inline-block;margin-left:1.5rem;line-height:2rem}.nav-links .nav-item:first-child{margin-left:0}.nav-links .repo-link{margin-left:1.5rem}@media (max-width:719px){.nav-links .nav-item,.nav-links .repo-link{margin-left:0}}@media (min-width:719px){.nav-links a.router-link-active,.nav-links a:hover{color:#2c3e50}.nav-item>a:not(.external).router-link-active,.nav-item>a:not(.external):hover{margin-bottom:-2px;border-bottom:2px solid #46bd87}}.navbar{padding:.7rem 1.5rem;line-height:2.2rem}.navbar a,.navbar img,.navbar span{display:inline-block}.navbar .logo{height:2.2rem;min-width:2.2rem;margin-right:.8rem;vertical-align:top}.navbar .site-name{font-size:1.3rem;font-weight:600;color:#2c3e50;position:relative}.navbar .links{padding-left:1.5rem;box-sizing:border-box;background-color:#fff;white-space:nowrap;font-size:.9rem;position:absolute;right:1.5rem;top:.7rem;display:flex}.navbar .links .search-box{flex:0 0 auto;vertical-align:top}@media (max-width:719px){.navbar{padding-left:4rem}.navbar .can-hide{display:none}.navbar .links{padding-left:1.5rem}.navbar .site-name{width:calc(100vw - 9.4rem);overflow:hidden;white-space:nowrap;text-overflow:ellipsis}}.page-edit{max-width:740px;margin:0 auto;padding:2rem 2.5rem}@media (max-width:959px){.page-edit{padding:2rem}}@media (max-width:419px){.page-edit{padding:1.5rem}}.page-edit{padding-top:1rem;padding-bottom:1rem;overflow:auto}.page-edit .edit-link{display:inline-block}.page-edit .edit-link a{color:#4e6e8e;margin-right:.25rem}.page-edit .last-updated{float:right;font-size:.9em}.page-edit .last-updated .prefix{font-weight:500;color:#4e6e8e}.page-edit .last-updated .time{font-weight:400;color:#aaa}@media (max-width:719px){.page-edit .edit-link{margin-bottom:.5rem}.page-edit .last-updated{font-size:.8em;float:none;text-align:left}}.page-nav{max-width:740px;margin:0 auto;padding:2rem 2.5rem}@media (max-width:959px){.page-nav{padding:2rem}}@media (max-width:419px){.page-nav{padding:1.5rem}}.page-nav{padding-top:1rem;padding-bottom:0}.page-nav .inner{min-height:2rem;margin-top:0;border-top:1px solid #eaecef;padding-top:1rem;overflow:auto}.page-nav .next{float:right}.page{padding-bottom:2rem;display:block}.sidebar-group .sidebar-group{padding-left:.5em}.sidebar-group:not(.collapsable) .sidebar-heading:not(.clickable){cursor:auto;color:inherit}.sidebar-group.is-sub-group{padding-left:0}.sidebar-group.is-sub-group>.sidebar-heading{font-size:.95em;line-height:1.4;font-weight:400;padding-left:2rem}.sidebar-group.is-sub-group>.sidebar-heading:not(.clickable){opacity:.5}.sidebar-group.is-sub-group>.sidebar-group-items{padding-left:1rem}.sidebar-group.is-sub-group>.sidebar-group-items>li>.sidebar-link{font-size:.95em;border-left:none}.sidebar-group.depth-2>.sidebar-heading{border-left:none}.sidebar-heading{color:#2c3e50;transition:color .15s ease;cursor:pointer;font-size:1.1em;font-weight:700;padding:.35rem 1.5rem .35rem 1.25rem;width:100%;box-sizing:border-box;margin:0;border-left:.25rem solid transparent}.sidebar-heading.open,.sidebar-heading:hover{color:inherit}.sidebar-heading .arrow{position:relative;top:-.12em;left:.5em}.sidebar-heading.clickable.active{font-weight:600;color:#3eaf7c;border-left-color:#3eaf7c}.sidebar-heading.clickable:hover{color:#3eaf7c}.sidebar-group-items{transition:height .1s ease-out;font-size:.95em;overflow:hidden}.sidebar .sidebar-sub-headers{padding-left:1rem;font-size:.95em}a.sidebar-link{font-size:1em;font-weight:400;display:inline-block;color:#2c3e50;border-left:.25rem solid transparent;padding:.35rem 1rem .35rem 1.25rem;line-height:1.4;width:100%;box-sizing:border-box}a.sidebar-link:hover{color:#3eaf7c}a.sidebar-link.active{font-weight:600;color:#3eaf7c;border-left-color:#3eaf7c}.sidebar-group a.sidebar-link{padding-left:2rem}.sidebar-sub-headers a.sidebar-link{padding-top:.25rem;padding-bottom:.25rem;border-left:none}.sidebar-sub-headers a.sidebar-link.active{font-weight:500}.sidebar ul{padding:0;margin:0;list-style-type:none}.sidebar a{display:inline-block}.sidebar .nav-links{display:none;border-bottom:1px solid #eaecef;padding:.5rem 0 .75rem}.sidebar .nav-links a{font-weight:600}.sidebar .nav-links .nav-item,.sidebar .nav-links .repo-link{display:block;line-height:1.25rem;font-size:1.1em;padding:.5rem 0 .5rem 1.5rem}.sidebar>.sidebar-links{padding:1.5rem 0}.sidebar>.sidebar-links>li>a.sidebar-link{font-size:1.1em;line-height:1.7;font-weight:700}.sidebar>.sidebar-links>li:not(:first-child){margin-top:.75rem}@media (max-width:719px){.sidebar .nav-links{display:block}.sidebar .nav-links .dropdown-wrapper .nav-dropdown .dropdown-item a.router-link-active:after{top:calc(1rem - 2px)}.sidebar>.sidebar-links{padding:1rem 0}}code[class*=language-],pre[class*=language-]{color:#ccc;background:none;font-family:Consolas,Monaco,Andale Mono,Ubuntu Mono,monospace;font-size:1em;text-align:left;white-space:pre;word-spacing:normal;word-break:normal;word-wrap:normal;line-height:1.5;-moz-tab-size:4;-o-tab-size:4;tab-size:4;-webkit-hyphens:none;-ms-hyphens:none;hyphens:none}pre[class*=language-]{padding:1em;margin:.5em 0;overflow:auto}:not(pre)>code[class*=language-],pre[class*=language-]{background:#2d2d2d}:not(pre)>code[class*=language-]{padding:.1em;border-radius:.3em;white-space:normal}.token.block-comment,.token.cdata,.token.comment,.token.doctype,.token.prolog{color:#999}.token.punctuation{color:#ccc}.token.attr-name,.token.deleted,.token.namespace,.token.tag{color:#e2777a}.token.function-name{color:#6196cc}.token.boolean,.token.function,.token.number{color:#f08d49}.token.class-name,.token.constant,.token.property,.token.symbol{color:#f8c555}.token.atrule,.token.builtin,.token.important,.token.keyword,.token.selector{color:#cc99cd}.token.attr-value,.token.char,.token.regex,.token.string,.token.variable{color:#7ec699}.token.entity,.token.operator,.token.url{color:#67cdcc}.token.bold,.token.important{font-weight:700}.token.italic{font-style:italic}.token.entity{cursor:help}.token.inserted{color:green}.theme-default-content code{color:#476582;padding:.25rem .5rem;margin:0;font-size:.85em;background-color:rgba(27,31,35,.05);border-radius:3px}.theme-default-content code .token.deleted{color:#ec5975}.theme-default-content code .token.inserted{color:#3eaf7c}.theme-default-content pre,.theme-default-content pre[class*=language-]{line-height:1.4;padding:1.25rem 1.5rem;margin:.85rem 0;background-color:#282c34;border-radius:6px;overflow:auto}.theme-default-content pre[class*=language-] code,.theme-default-content pre code{color:#fff;padding:0;background-color:transparent;border-radius:0}div[class*=language-]{position:relative;background-color:#282c34;border-radius:6px}div[class*=language-] .highlight-lines{-webkit-user-select:none;-ms-user-select:none;user-select:none;padding-top:1.3rem;position:absolute;top:0;left:0;width:100%;line-height:1.4}div[class*=language-] .highlight-lines .highlighted{background-color:rgba(0,0,0,.66)}div[class*=language-] pre,div[class*=language-] pre[class*=language-]{background:transparent;position:relative;z-index:1}div[class*=language-]:before{position:absolute;z-index:3;top:.8em;right:1em;font-size:.75rem;color:hsla(0,0%,100%,.4)}div[class*=language-]:not(.line-numbers-mode) .line-numbers-wrapper{display:none}div[class*=language-].line-numbers-mode .highlight-lines .highlighted{position:relative}div[class*=language-].line-numbers-mode .highlight-lines .highlighted:before{content:" ";position:absolute;z-index:3;left:0;top:0;display:block;width:3.5rem;height:100%;background-color:rgba(0,0,0,.66)}div[class*=language-].line-numbers-mode pre{padding-left:4.5rem;vertical-align:middle}div[class*=language-].line-numbers-mode .line-numbers-wrapper{position:absolute;top:0;width:3.5rem;text-align:center;color:hsla(0,0%,100%,.3);padding:1.25rem 0;line-height:1.4}div[class*=language-].line-numbers-mode .line-numbers-wrapper br{-webkit-user-select:none;-ms-user-select:none;user-select:none}div[class*=language-].line-numbers-mode .line-numbers-wrapper .line-number{position:relative;z-index:4;-webkit-user-select:none;-ms-user-select:none;user-select:none;font-size:.85em}div[class*=language-].line-numbers-mode:after{content:"";position:absolute;z-index:2;top:0;left:0;width:3.5rem;height:100%;border-radius:6px 0 0 6px;border-right:1px solid rgba(0,0,0,.66);background-color:#282c34}div[class~=language-js]:before{content:"js"}div[class~=language-ts]:before{content:"ts"}div[class~=language-html]:before{content:"html"}div[class~=language-md]:before{content:"md"}div[class~=language-vue]:before{content:"vue"}div[class~=language-css]:before{content:"css"}div[class~=language-sass]:before{content:"sass"}div[class~=language-scss]:before{content:"scss"}div[class~=language-less]:before{content:"less"}div[class~=language-stylus]:before{content:"stylus"}div[class~=language-go]:before{content:"go"}div[class~=language-java]:before{content:"java"}div[class~=language-c]:before{content:"c"}div[class~=language-sh]:before{content:"sh"}div[class~=language-yaml]:before{content:"yaml"}div[class~=language-py]:before{content:"py"}div[class~=language-docker]:before{content:"docker"}div[class~=language-dockerfile]:before{content:"dockerfile"}div[class~=language-makefile]:before{content:"makefile"}div[class~=language-javascript]:before{content:"js"}div[class~=language-typescript]:before{content:"ts"}div[class~=language-markup]:before{content:"html"}div[class~=language-markdown]:before{content:"md"}div[class~=language-json]:before{content:"json"}div[class~=language-ruby]:before{content:"rb"}div[class~=language-python]:before{content:"py"}div[class~=language-bash]:before{content:"sh"}div[class~=language-php]:before{content:"php"}.custom-block .custom-block-title{font-weight:600;margin-bottom:-.4rem}.custom-block.danger,.custom-block.tip,.custom-block.warning{padding:.1rem 1.5rem;border-left-width:.5rem;border-left-style:solid;margin:1rem 0}.custom-block.tip{background-color:#f3f5f7;border-color:#42b983}.custom-block.warning{background-color:rgba(255,229,100,.3);border-color:#e7c000;color:#6b5900}.custom-block.warning .custom-block-title{color:#b29400}.custom-block.warning a{color:#2c3e50}.custom-block.danger{background-color:#ffe6e6;border-color:#c00;color:#4d0000}.custom-block.danger .custom-block-title{color:#900}.custom-block.danger a{color:#2c3e50}.custom-block.details{display:block;position:relative;border-radius:2px;margin:1.6em 0;padding:1.6em;background-color:#eee}.custom-block.details h4{margin-top:0}.custom-block.details figure:last-child,.custom-block.details p:last-child{margin-bottom:0;padding-bottom:0}.custom-block.details summary{outline:none;cursor:pointer}.arrow{display:inline-block;width:0;height:0}.arrow.up{border-bottom:6px solid #ccc}.arrow.down,.arrow.up{border-left:4px solid transparent;border-right:4px solid transparent}.arrow.down{border-top:6px solid #ccc}.arrow.right{border-left:6px solid #ccc}.arrow.left,.arrow.right{border-top:4px solid transparent;border-bottom:4px solid transparent}.arrow.left{border-right:6px solid #ccc}.theme-default-content:not(.custom){max-width:740px;margin:0 auto;padding:2rem 2.5rem}@media (max-width:959px){.theme-default-content:not(.custom){padding:2rem}}@media (max-width:419px){.theme-default-content:not(.custom){padding:1.5rem}}.table-of-contents .badge{vertical-align:middle}body,html{padding:0;margin:0;background-color:#fff}body{font-family:-apple-system,BlinkMacSystemFont,Segoe UI,Roboto,Oxygen,Ubuntu,Cantarell,Fira Sans,Droid Sans,Helvetica Neue,sans-serif;-webkit-font-smoothing:antialiased;-moz-osx-font-smoothing:grayscale;font-size:16px;color:#2c3e50}.page{padding-left:20rem}.navbar{z-index:20;right:0;height:3.6rem;background-color:#fff;box-sizing:border-box;border-bottom:1px solid #eaecef}.navbar,.sidebar-mask{position:fixed;top:0;left:0}.sidebar-mask{z-index:9;width:100vw;height:100vh;display:none}.sidebar{font-size:16px;background-color:#fff;width:20rem;position:fixed;z-index:10;margin:0;top:3.6rem;left:0;bottom:0;box-sizing:border-box;border-right:1px solid #eaecef;overflow-y:auto}.theme-default-content:not(.custom)>:first-child{margin-top:3.6rem}.theme-default-content:not(.custom) a:hover{text-decoration:underline}.theme-default-content:not(.custom) p.demo{padding:1rem 1.5rem;border:1px solid #ddd;border-radius:4px}.theme-default-content:not(.custom) img{max-width:100%}.theme-default-content.custom{padding:0;margin:0}.theme-default-content.custom img{max-width:100%}a{font-weight:500;text-decoration:none}a,p a code{color:#3eaf7c}p a code{font-weight:400}kbd{background:#eee;border:.15rem solid #ddd;border-bottom:.25rem solid #ddd;border-radius:.15rem;padding:0 .15em}blockquote{font-size:1rem;color:#999;border-left:.2rem solid #dfe2e5;margin:1rem 0;padding:.25rem 0 .25rem 1rem}blockquote>p{margin:0}ol,ul{padding-left:1.2em}strong{font-weight:600}h1,h2,h3,h4,h5,h6{font-weight:600;line-height:1.25}.theme-default-content:not(.custom)>h1,.theme-default-content:not(.custom)>h2,.theme-default-content:not(.custom)>h3,.theme-default-content:not(.custom)>h4,.theme-default-content:not(.custom)>h5,.theme-default-content:not(.custom)>h6{margin-top:-3.1rem;padding-top:4.6rem;margin-bottom:0}.theme-default-content:not(.custom)>h1:first-child,.theme-default-content:not(.custom)>h2:first-child,.theme-default-content:not(.custom)>h3:first-child,.theme-default-content:not(.custom)>h4:first-child,.theme-default-content:not(.custom)>h5:first-child,.theme-default-content:not(.custom)>h6:first-child{margin-top:-1.5rem;margin-bottom:1rem}.theme-default-content:not(.custom)>h1:first-child+.custom-block,.theme-default-content:not(.custom)>h1:first-child+p,.theme-default-content:not(.custom)>h1:first-child+pre,.theme-default-content:not(.custom)>h2:first-child+.custom-block,.theme-default-content:not(.custom)>h2:first-child+p,.theme-default-content:not(.custom)>h2:first-child+pre,.theme-default-content:not(.custom)>h3:first-child+.custom-block,.theme-default-content:not(.custom)>h3:first-child+p,.theme-default-content:not(.custom)>h3:first-child+pre,.theme-default-content:not(.custom)>h4:first-child+.custom-block,.theme-default-content:not(.custom)>h4:first-child+p,.theme-default-content:not(.custom)>h4:first-child+pre,.theme-default-content:not(.custom)>h5:first-child+.custom-block,.theme-default-content:not(.custom)>h5:first-child+p,.theme-default-content:not(.custom)>h5:first-child+pre,.theme-default-content:not(.custom)>h6:first-child+.custom-block,.theme-default-content:not(.custom)>h6:first-child+p,.theme-default-content:not(.custom)>h6:first-child+pre{margin-top:2rem}h1:hover .header-anchor,h2:hover .header-anchor,h3:hover .header-anchor,h4:hover .header-anchor,h5:hover .header-anchor,h6:hover .header-anchor{opacity:1}h1{font-size:2.2rem}h2{font-size:1.65rem;padding-bottom:.3rem;border-bottom:1px solid #eaecef}h3{font-size:1.35rem}a.header-anchor{font-size:.85em;float:left;margin-left:-.87em;padding-right:.23em;margin-top:.125em;opacity:0}a.header-anchor:hover{text-decoration:none}.line-number,code,kbd{font-family:source-code-pro,Menlo,Monaco,Consolas,Courier New,monospace}ol,p,ul{line-height:1.7}hr{border:0;border-top:1px solid #eaecef}table{border-collapse:collapse;margin:1rem 0;display:block;overflow-x:auto}tr{border-top:1px solid #dfe2e5}tr:nth-child(2n){background-color:#f6f8fa}td,th{border:1px solid #dfe2e5;padding:.6em 1em}.theme-container.sidebar-open .sidebar-mask{display:block}.theme-container.no-navbar .theme-default-content:not(.custom)>h1,.theme-container.no-navbar h2,.theme-container.no-navbar h3,.theme-container.no-navbar h4,.theme-container.no-navbar h5,.theme-container.no-navbar h6{margin-top:1.5rem;padding-top:0}.theme-container.no-navbar .sidebar{top:0}@media (min-width:720px){.theme-container.no-sidebar .sidebar{display:none}.theme-container.no-sidebar .page{padding-left:0}}@media (max-width:959px){.sidebar{font-size:15px;width:16.4rem}.page{padding-left:16.4rem}}@media (max-width:719px){.sidebar{top:0;padding-top:3.6rem;transform:translateX(-100%);transition:transform .2s ease}.page{padding-left:0}.theme-container.sidebar-open .sidebar{transform:translateX(0)}.theme-container.no-navbar .sidebar{padding-top:0}}@media (max-width:419px){h1{font-size:1.9rem}.theme-default-content div[class*=language-]{margin:.85rem -1.5rem;border-radius:0}}.home .hero img{height:200px}.badge[data-v-15b7b770]{display:inline-block;font-size:14px;height:18px;line-height:18px;border-radius:3px;padding:0 6px;color:#fff}.badge.green[data-v-15b7b770],.badge.tip[data-v-15b7b770],.badge[data-v-15b7b770]{background-color:#42b983}.badge.error[data-v-15b7b770]{background-color:#da5961}.badge.warn[data-v-15b7b770],.badge.warning[data-v-15b7b770],.badge.yellow[data-v-15b7b770]{background-color:#e7c000}.badge+.badge[data-v-15b7b770]{margin-left:5px} \ No newline at end of file diff --git a/okhttps-doc/docs/.vuepress/dist/assets/img/search.83621669.svg b/okhttps-doc/docs/.vuepress/dist/assets/img/search.83621669.svg deleted file mode 100644 index 03d83913..00000000 --- a/okhttps-doc/docs/.vuepress/dist/assets/img/search.83621669.svg +++ /dev/null @@ -1 +0,0 @@ - diff --git a/okhttps-doc/docs/.vuepress/dist/assets/js/10.bc5e580e.js b/okhttps-doc/docs/.vuepress/dist/assets/js/10.bc5e580e.js deleted file mode 100644 index 8f8cfd50..00000000 --- a/okhttps-doc/docs/.vuepress/dist/assets/js/10.bc5e580e.js +++ /dev/null @@ -1 +0,0 @@ -(window.webpackJsonp=window.webpackJsonp||[]).push([[10],{333:function(s,t,a){"use strict";a.r(t);var n=a(19),e=Object(n.a)({},(function(){var s=this,t=s.$createElement,a=s._self._c||t;return a("ContentSlotsDistributor",{attrs:{"slot-key":s.$parent.slotKey}},[a("h1",{attrs:{id:"特色"}},[a("a",{staticClass:"header-anchor",attrs:{href:"#特色"}},[s._v("#")]),s._v(" 特色")]),s._v(" "),a("h2",{attrs:{id:"使用-httputils-类"}},[a("a",{staticClass:"header-anchor",attrs:{href:"#使用-httputils-类"}},[s._v("#")]),s._v(" 使用 HttpUtils 类")]),s._v(" "),a("p",[s._v("类"),a("code",[s._v("HttpUtils")]),s._v("本是 "),a("a",{attrs:{href:"https://gitee.com/ejlchina-zhxu/httputils",target:"_blank",rel:"noopener noreferrer"}},[s._v("前身 HttpUtils"),a("OutboundLink")],1),s._v(" 的 1.x 版本里的最重要的核心类，由于在后来的版本里抽象出了"),a("code",[s._v("HTTP")]),s._v("接口，使得它的重要性已不如往昔。但合理的使用它，仍然可以带来不少便利，特别是在没有IOC容器的环境里，比如在Android开发和一些工具项目的开发中。")]),s._v(" "),a("p",[s._v("类"),a("code",[s._v("HttpUtils")]),s._v("共定义了四个静态方法：")]),s._v(" "),a("ul",[a("li",[a("code",[s._v("of(HTTP http)")]),s._v(" 配置"),a("code",[s._v("HttpUtils")]),s._v("持有的"),a("code",[s._v("HTTP")]),s._v("实例（不调用此方法前默认使用一个没有没有经过任何配置的"),a("code",[s._v("HTTP")]),s._v("懒实例）")]),s._v(" "),a("li",[a("code",[s._v("sync(String url)")]),s._v(" 开始一个同步请求 （内部通过一个"),a("code",[s._v("HTTP")]),s._v("单例实现）")]),s._v(" "),a("li",[a("code",[s._v("async(String url)")]),s._v(" 开始一个异步请求 （内部通过一个"),a("code",[s._v("HTTP")]),s._v("单例实现）")]),s._v(" "),a("li",[a("code",[s._v("cancel(String tag)")]),s._v(" 按标签取消请求（内部通过一个"),a("code",[s._v("HTTP")]),s._v("单例实现）")]),s._v(" "),a("li",[a("code",[s._v("cancelAll()")]),s._v(" 取消所有HTTP任务，包括同步和异步（内部通过一个"),a("code",[s._v("HTTP")]),s._v("单例实现）")]),s._v(" "),a("li",[a("code",[s._v("request(Request request)")]),s._v(" OkHttp 原生请求 （该请求不经过 预处理器）")]),s._v(" "),a("li",[a("code",[s._v("webSocket(Request request, WebSocketListener listener)")]),s._v(" WebSocket通讯\n　　也就是说，能使用"),a("code",[s._v("http")]),s._v("实例的地方，都可以使用"),a("code",[s._v("HttpUtils")]),s._v("类，例如：")])]),s._v(" "),a("div",{staticClass:"language-java line-numbers-mode"},[a("pre",{pre:!0,attrs:{class:"language-java"}},[a("code",[a("span",{pre:!0,attrs:{class:"token comment"}},[s._v("// 在配置HTTP实例之前，只能使用全路径方式")]),s._v("\n"),a("span",{pre:!0,attrs:{class:"token class-name"}},[s._v("List")]),a("span",{pre:!0,attrs:{class:"token generics"}},[a("span",{pre:!0,attrs:{class:"token punctuation"}},[s._v("<")]),a("span",{pre:!0,attrs:{class:"token class-name"}},[s._v("Role")]),a("span",{pre:!0,attrs:{class:"token punctuation"}},[s._v(">")])]),s._v(" roles "),a("span",{pre:!0,attrs:{class:"token operator"}},[s._v("=")]),s._v(" "),a("span",{pre:!0,attrs:{class:"token class-name"}},[s._v("HttpUtils")]),a("span",{pre:!0,attrs:{class:"token punctuation"}},[s._v(".")]),a("span",{pre:!0,attrs:{class:"token function"}},[s._v("sync")]),a("span",{pre:!0,attrs:{class:"token punctuation"}},[s._v("(")]),a("span",{pre:!0,attrs:{class:"token string"}},[s._v('"http://api.demo.com/roles"')]),a("span",{pre:!0,attrs:{class:"token punctuation"}},[s._v(")")]),s._v("\n "),a("span",{pre:!0,attrs:{class:"token punctuation"}},[s._v(".")]),a("span",{pre:!0,attrs:{class:"token function"}},[s._v("get")]),a("span",{pre:!0,attrs:{class:"token punctuation"}},[s._v("(")]),a("span",{pre:!0,attrs:{class:"token punctuation"}},[s._v(")")]),a("span",{pre:!0,attrs:{class:"token punctuation"}},[s._v(".")]),a("span",{pre:!0,attrs:{class:"token function"}},[s._v("getBody")]),a("span",{pre:!0,attrs:{class:"token punctuation"}},[s._v("(")]),a("span",{pre:!0,attrs:{class:"token punctuation"}},[s._v(")")]),a("span",{pre:!0,attrs:{class:"token punctuation"}},[s._v(".")]),a("span",{pre:!0,attrs:{class:"token function"}},[s._v("toList")]),a("span",{pre:!0,attrs:{class:"token punctuation"}},[s._v("(")]),a("span",{pre:!0,attrs:{class:"token class-name"}},[s._v("Role")]),a("span",{pre:!0,attrs:{class:"token punctuation"}},[s._v(".")]),a("span",{pre:!0,attrs:{class:"token keyword"}},[s._v("class")]),a("span",{pre:!0,attrs:{class:"token punctuation"}},[s._v(")")]),a("span",{pre:!0,attrs:{class:"token punctuation"}},[s._v(";")]),s._v("\n\n"),a("span",{pre:!0,attrs:{class:"token comment"}},[s._v("// 配置HTTP实例,全局生效")]),s._v("\n"),a("span",{pre:!0,attrs:{class:"token class-name"}},[s._v("HttpUtils")]),a("span",{pre:!0,attrs:{class:"token punctuation"}},[s._v(".")]),a("span",{pre:!0,attrs:{class:"token function"}},[s._v("of")]),a("span",{pre:!0,attrs:{class:"token punctuation"}},[s._v("(")]),s._v("HTTP"),a("span",{pre:!0,attrs:{class:"token punctuation"}},[s._v(".")]),a("span",{pre:!0,attrs:{class:"token function"}},[s._v("builder")]),a("span",{pre:!0,attrs:{class:"token punctuation"}},[s._v("(")]),a("span",{pre:!0,attrs:{class:"token punctuation"}},[s._v(")")]),s._v("\n "),a("span",{pre:!0,attrs:{class:"token punctuation"}},[s._v(".")]),a("span",{pre:!0,attrs:{class:"token function"}},[s._v("baseUrl")]),a("span",{pre:!0,attrs:{class:"token punctuation"}},[s._v("(")]),a("span",{pre:!0,attrs:{class:"token string"}},[s._v('"http://api.demo.com"')]),a("span",{pre:!0,attrs:{class:"token punctuation"}},[s._v(")")]),s._v("\n "),a("span",{pre:!0,attrs:{class:"token punctuation"}},[s._v(".")]),a("span",{pre:!0,attrs:{class:"token function"}},[s._v("build")]),a("span",{pre:!0,attrs:{class:"token punctuation"}},[s._v("(")]),a("span",{pre:!0,attrs:{class:"token punctuation"}},[s._v(")")]),a("span",{pre:!0,attrs:{class:"token punctuation"}},[s._v(")")]),a("span",{pre:!0,attrs:{class:"token punctuation"}},[s._v(";")]),s._v("\n\n"),a("span",{pre:!0,attrs:{class:"token comment"}},[s._v("// 内部使用新的HTTP实例")]),s._v("\n"),a("span",{pre:!0,attrs:{class:"token class-name"}},[s._v("List")]),a("span",{pre:!0,attrs:{class:"token generics"}},[a("span",{pre:!0,attrs:{class:"token punctuation"}},[s._v("<")]),a("span",{pre:!0,attrs:{class:"token class-name"}},[s._v("User")]),a("span",{pre:!0,attrs:{class:"token punctuation"}},[s._v(">")])]),s._v(" users "),a("span",{pre:!0,attrs:{class:"token operator"}},[s._v("=")]),s._v(" "),a("span",{pre:!0,attrs:{class:"token class-name"}},[s._v("HttpUtils")]),a("span",{pre:!0,attrs:{class:"token punctuation"}},[s._v(".")]),a("span",{pre:!0,attrs:{class:"token function"}},[s._v("sync")]),a("span",{pre:!0,attrs:{class:"token punctuation"}},[s._v("(")]),a("span",{pre:!0,attrs:{class:"token string"}},[s._v('"/users"')]),a("span",{pre:!0,attrs:{class:"token punctuation"}},[s._v(")")]),s._v("\n "),a("span",{pre:!0,attrs:{class:"token punctuation"}},[s._v(".")]),a("span",{pre:!0,attrs:{class:"token function"}},[s._v("get")]),a("span",{pre:!0,attrs:{class:"token punctuation"}},[s._v("(")]),a("span",{pre:!0,attrs:{class:"token punctuation"}},[s._v(")")]),a("span",{pre:!0,attrs:{class:"token punctuation"}},[s._v(".")]),a("span",{pre:!0,attrs:{class:"token function"}},[s._v("getBody")]),a("span",{pre:!0,attrs:{class:"token punctuation"}},[s._v("(")]),a("span",{pre:!0,attrs:{class:"token punctuation"}},[s._v(")")]),a("span",{pre:!0,attrs:{class:"token punctuation"}},[s._v(".")]),a("span",{pre:!0,attrs:{class:"token function"}},[s._v("toList")]),a("span",{pre:!0,attrs:{class:"token punctuation"}},[s._v("(")]),a("span",{pre:!0,attrs:{class:"token class-name"}},[s._v("User")]),a("span",{pre:!0,attrs:{class:"token punctuation"}},[s._v(".")]),a("span",{pre:!0,attrs:{class:"token keyword"}},[s._v("class")]),a("span",{pre:!0,attrs:{class:"token punctuation"}},[s._v(")")]),a("span",{pre:!0,attrs:{class:"token punctuation"}},[s._v(";")]),s._v("\n")])]),s._v(" "),a("div",{staticClass:"line-numbers-wrapper"},[a("span",{staticClass:"line-number"},[s._v("1")]),a("br"),a("span",{staticClass:"line-number"},[s._v("2")]),a("br"),a("span",{staticClass:"line-number"},[s._v("3")]),a("br"),a("span",{staticClass:"line-number"},[s._v("4")]),a("br"),a("span",{staticClass:"line-number"},[s._v("5")]),a("br"),a("span",{staticClass:"line-number"},[s._v("6")]),a("br"),a("span",{staticClass:"line-number"},[s._v("7")]),a("br"),a("span",{staticClass:"line-number"},[s._v("8")]),a("br"),a("span",{staticClass:"line-number"},[s._v("9")]),a("br"),a("span",{staticClass:"line-number"},[s._v("10")]),a("br"),a("span",{staticClass:"line-number"},[s._v("11")]),a("br"),a("span",{staticClass:"line-number"},[s._v("12")]),a("br")])]),a("h2",{attrs:{id:"异常处理"}},[a("a",{staticClass:"header-anchor",attrs:{href:"#异常处理"}},[s._v("#")]),s._v(" 异常处理")]),s._v(" "),a("p",[s._v("使用 OkHttps 时，"),a("strong",[s._v("异常处理不是必须的")]),s._v("，但相比其它的 HTTP 开发包，它还提供一个特别的处理方法："),a("code",[s._v("nothrow()")]),s._v("，以满足不同的异常处理需求。")]),s._v(" "),a("h3",{attrs:{id:"同步请求的异常"}},[a("a",{staticClass:"header-anchor",attrs:{href:"#同步请求的异常"}},[s._v("#")]),s._v(" 同步请求的异常")]),s._v(" "),a("p",[s._v("默认情况下，当同步请求执行异常时，会直接向外抛出，我们可以用 "),a("code",[s._v("try catch")]),s._v(" 来捕获，例如：")]),s._v(" "),a("div",{staticClass:"language-java line-numbers-mode"},[a("pre",{pre:!0,attrs:{class:"language-java"}},[a("code",[a("span",{pre:!0,attrs:{class:"token keyword"}},[s._v("try")]),s._v(" "),a("span",{pre:!0,attrs:{class:"token punctuation"}},[s._v("{")]),s._v("\n "),a("span",{pre:!0,attrs:{class:"token class-name"}},[s._v("HttpResult")]),s._v(" result "),a("span",{pre:!0,attrs:{class:"token operator"}},[s._v("=")]),s._v(" http"),a("span",{pre:!0,attrs:{class:"token punctuation"}},[s._v(".")]),a("span",{pre:!0,attrs:{class:"token function"}},[s._v("sync")]),a("span",{pre:!0,attrs:{class:"token punctuation"}},[s._v("(")]),a("span",{pre:!0,attrs:{class:"token string"}},[s._v('"/users/1"')]),a("span",{pre:!0,attrs:{class:"token punctuation"}},[s._v(")")]),a("span",{pre:!0,attrs:{class:"token punctuation"}},[s._v(".")]),a("span",{pre:!0,attrs:{class:"token function"}},[s._v("get")]),a("span",{pre:!0,attrs:{class:"token punctuation"}},[s._v("(")]),a("span",{pre:!0,attrs:{class:"token punctuation"}},[s._v(")")]),a("span",{pre:!0,attrs:{class:"token punctuation"}},[s._v(";")]),s._v("\n"),a("span",{pre:!0,attrs:{class:"token punctuation"}},[s._v("}")]),s._v(" "),a("span",{pre:!0,attrs:{class:"token keyword"}},[s._v("catch")]),s._v(" "),a("span",{pre:!0,attrs:{class:"token punctuation"}},[s._v("(")]),a("span",{pre:!0,attrs:{class:"token class-name"}},[s._v("HttpException")]),s._v(" e"),a("span",{pre:!0,attrs:{class:"token punctuation"}},[s._v(")")]),s._v(" "),a("span",{pre:!0,attrs:{class:"token punctuation"}},[s._v("{")]),s._v("\n "),a("span",{pre:!0,attrs:{class:"token class-name"}},[s._v("Throwable")]),s._v(" cause "),a("span",{pre:!0,attrs:{class:"token operator"}},[s._v("=")]),s._v(" e"),a("span",{pre:!0,attrs:{class:"token punctuation"}},[s._v(".")]),a("span",{pre:!0,attrs:{class:"token function"}},[s._v("getCause")]),a("span",{pre:!0,attrs:{class:"token punctuation"}},[s._v("(")]),a("span",{pre:!0,attrs:{class:"token punctuation"}},[s._v(")")]),a("span",{pre:!0,attrs:{class:"token punctuation"}},[s._v(";")]),s._v(" "),a("span",{pre:!0,attrs:{class:"token comment"}},[s._v("// 得到异常原因")]),s._v("\n "),a("span",{pre:!0,attrs:{class:"token keyword"}},[s._v("if")]),s._v(" "),a("span",{pre:!0,attrs:{class:"token punctuation"}},[s._v("(")]),s._v("cause "),a("span",{pre:!0,attrs:{class:"token keyword"}},[s._v("instanceof")]),s._v(" "),a("span",{pre:!0,attrs:{class:"token class-name"}},[s._v("ConnectException")]),a("span",{pre:!0,attrs:{class:"token punctuation"}},[s._v(")")]),s._v(" "),a("span",{pre:!0,attrs:{class:"token punctuation"}},[s._v("{")]),s._v("\n "),a("span",{pre:!0,attrs:{class:"token comment"}},[s._v("// 当没网络时，会抛出连接异常")]),s._v("\n "),a("span",{pre:!0,attrs:{class:"token punctuation"}},[s._v("}")]),s._v("\n "),a("span",{pre:!0,attrs:{class:"token keyword"}},[s._v("if")]),s._v(" "),a("span",{pre:!0,attrs:{class:"token punctuation"}},[s._v("(")]),s._v("cause "),a("span",{pre:!0,attrs:{class:"token keyword"}},[s._v("instanceof")]),s._v(" "),a("span",{pre:!0,attrs:{class:"token class-name"}},[s._v("SocketTimeoutException")]),a("span",{pre:!0,attrs:{class:"token punctuation"}},[s._v(")")]),s._v(" "),a("span",{pre:!0,attrs:{class:"token punctuation"}},[s._v("{")]),s._v("\n "),a("span",{pre:!0,attrs:{class:"token comment"}},[s._v("// 当接口长时间未响应，会抛出超时异常")]),s._v("\n "),a("span",{pre:!0,attrs:{class:"token punctuation"}},[s._v("}")]),s._v("\n "),a("span",{pre:!0,attrs:{class:"token keyword"}},[s._v("if")]),s._v(" "),a("span",{pre:!0,attrs:{class:"token punctuation"}},[s._v("(")]),s._v("cause "),a("span",{pre:!0,attrs:{class:"token keyword"}},[s._v("instanceof")]),s._v(" "),a("span",{pre:!0,attrs:{class:"token class-name"}},[s._v("UnknownHostException")]),a("span",{pre:!0,attrs:{class:"token punctuation"}},[s._v(")")]),s._v(" "),a("span",{pre:!0,attrs:{class:"token punctuation"}},[s._v("{")]),s._v("\n "),a("span",{pre:!0,attrs:{class:"token comment"}},[s._v("// 当把域名或IP写错，会抛出 UnknownHost 异常")]),s._v("\n "),a("span",{pre:!0,attrs:{class:"token punctuation"}},[s._v("}")]),s._v("\n "),a("span",{pre:!0,attrs:{class:"token comment"}},[s._v("// ...")]),s._v("\n"),a("span",{pre:!0,attrs:{class:"token punctuation"}},[s._v("}")]),s._v("\n")])]),s._v(" "),a("div",{staticClass:"line-numbers-wrapper"},[a("span",{staticClass:"line-number"},[s._v("1")]),a("br"),a("span",{staticClass:"line-number"},[s._v("2")]),a("br"),a("span",{staticClass:"line-number"},[s._v("3")]),a("br"),a("span",{staticClass:"line-number"},[s._v("4")]),a("br"),a("span",{staticClass:"line-number"},[s._v("5")]),a("br"),a("span",{staticClass:"line-number"},[s._v("6")]),a("br"),a("span",{staticClass:"line-number"},[s._v("7")]),a("br"),a("span",{staticClass:"line-number"},[s._v("8")]),a("br"),a("span",{staticClass:"line-number"},[s._v("9")]),a("br"),a("span",{staticClass:"line-number"},[s._v("10")]),a("br"),a("span",{staticClass:"line-number"},[s._v("11")]),a("br"),a("span",{staticClass:"line-number"},[s._v("12")]),a("br"),a("span",{staticClass:"line-number"},[s._v("13")]),a("br"),a("span",{staticClass:"line-number"},[s._v("14")]),a("br"),a("span",{staticClass:"line-number"},[s._v("15")]),a("br")])]),a("p",[s._v("这种传统的异常处理方式，当然可以解决问题，但 OkHttps 有更佳的方案：")]),s._v(" "),a("div",{staticClass:"language-java line-numbers-mode"},[a("pre",{pre:!0,attrs:{class:"language-java"}},[a("code",[a("span",{pre:!0,attrs:{class:"token comment"}},[s._v("// 方法 nothrow() 让异常不直接抛出")]),s._v("\n"),a("span",{pre:!0,attrs:{class:"token class-name"}},[s._v("HttpResult")]),s._v(" result "),a("span",{pre:!0,attrs:{class:"token operator"}},[s._v("=")]),s._v(" http"),a("span",{pre:!0,attrs:{class:"token punctuation"}},[s._v(".")]),a("span",{pre:!0,attrs:{class:"token function"}},[s._v("sync")]),a("span",{pre:!0,attrs:{class:"token punctuation"}},[s._v("(")]),a("span",{pre:!0,attrs:{class:"token string"}},[s._v('"/users/1"')]),a("span",{pre:!0,attrs:{class:"token punctuation"}},[s._v(")")]),a("span",{pre:!0,attrs:{class:"token punctuation"}},[s._v(".")]),a("span",{pre:!0,attrs:{class:"token function"}},[s._v("nothrow")]),a("span",{pre:!0,attrs:{class:"token punctuation"}},[s._v("(")]),a("span",{pre:!0,attrs:{class:"token punctuation"}},[s._v(")")]),a("span",{pre:!0,attrs:{class:"token punctuation"}},[s._v(".")]),a("span",{pre:!0,attrs:{class:"token function"}},[s._v("get")]),a("span",{pre:!0,attrs:{class:"token punctuation"}},[s._v("(")]),a("span",{pre:!0,attrs:{class:"token punctuation"}},[s._v(")")]),a("span",{pre:!0,attrs:{class:"token punctuation"}},[s._v(";")]),s._v("\n"),a("span",{pre:!0,attrs:{class:"token comment"}},[s._v("// 判断执行状态")]),s._v("\n"),a("span",{pre:!0,attrs:{class:"token keyword"}},[s._v("switch")]),s._v(" "),a("span",{pre:!0,attrs:{class:"token punctuation"}},[s._v("(")]),s._v("result"),a("span",{pre:!0,attrs:{class:"token punctuation"}},[s._v(".")]),a("span",{pre:!0,attrs:{class:"token function"}},[s._v("getState")]),a("span",{pre:!0,attrs:{class:"token punctuation"}},[s._v("(")]),a("span",{pre:!0,attrs:{class:"token punctuation"}},[s._v(")")]),a("span",{pre:!0,attrs:{class:"token punctuation"}},[s._v(")")]),s._v(" "),a("span",{pre:!0,attrs:{class:"token punctuation"}},[s._v("{")]),s._v("\n "),a("span",{pre:!0,attrs:{class:"token keyword"}},[s._v("case")]),s._v(" RESPONSED"),a("span",{pre:!0,attrs:{class:"token operator"}},[s._v(":")]),s._v(" "),a("span",{pre:!0,attrs:{class:"token comment"}},[s._v("// 请求已正常响应")]),s._v("\n "),a("span",{pre:!0,attrs:{class:"token keyword"}},[s._v("break")]),a("span",{pre:!0,attrs:{class:"token punctuation"}},[s._v(";")]),s._v("\n "),a("span",{pre:!0,attrs:{class:"token keyword"}},[s._v("case")]),s._v(" CANCELED"),a("span",{pre:!0,attrs:{class:"token operator"}},[s._v(":")]),s._v(" "),a("span",{pre:!0,attrs:{class:"token comment"}},[s._v("// 请求已被取消")]),s._v("\n "),a("span",{pre:!0,attrs:{class:"token keyword"}},[s._v("break")]),a("span",{pre:!0,attrs:{class:"token punctuation"}},[s._v(";")]),s._v("\n "),a("span",{pre:!0,attrs:{class:"token keyword"}},[s._v("case")]),s._v(" NETWORK_ERROR"),a("span",{pre:!0,attrs:{class:"token operator"}},[s._v(":")]),s._v(" "),a("span",{pre:!0,attrs:{class:"token comment"}},[s._v("// 网络错误，说明用户没网了")]),s._v("\n "),a("span",{pre:!0,attrs:{class:"token keyword"}},[s._v("break")]),a("span",{pre:!0,attrs:{class:"token punctuation"}},[s._v(";")]),s._v("\n "),a("span",{pre:!0,attrs:{class:"token keyword"}},[s._v("case")]),s._v(" TIMEOUT"),a("span",{pre:!0,attrs:{class:"token operator"}},[s._v(":")]),s._v(" "),a("span",{pre:!0,attrs:{class:"token comment"}},[s._v("// 请求超时")]),s._v("\n "),a("span",{pre:!0,attrs:{class:"token keyword"}},[s._v("break")]),a("span",{pre:!0,attrs:{class:"token punctuation"}},[s._v(";")]),s._v("\n "),a("span",{pre:!0,attrs:{class:"token keyword"}},[s._v("case")]),s._v(" EXCEPTION"),a("span",{pre:!0,attrs:{class:"token operator"}},[s._v(":")]),s._v(" "),a("span",{pre:!0,attrs:{class:"token comment"}},[s._v("// 其它异常")]),s._v("\n "),a("span",{pre:!0,attrs:{class:"token keyword"}},[s._v("break")]),a("span",{pre:!0,attrs:{class:"token punctuation"}},[s._v(";")]),s._v("\n"),a("span",{pre:!0,attrs:{class:"token punctuation"}},[s._v("}")]),s._v("\n"),a("span",{pre:!0,attrs:{class:"token comment"}},[s._v("// 还可以获得具体的异常信息")]),s._v("\n"),a("span",{pre:!0,attrs:{class:"token class-name"}},[s._v("IOException")]),s._v(" error "),a("span",{pre:!0,attrs:{class:"token operator"}},[s._v("=")]),s._v(" result"),a("span",{pre:!0,attrs:{class:"token punctuation"}},[s._v(".")]),a("span",{pre:!0,attrs:{class:"token function"}},[s._v("getError")]),a("span",{pre:!0,attrs:{class:"token punctuation"}},[s._v("(")]),a("span",{pre:!0,attrs:{class:"token punctuation"}},[s._v(")")]),a("span",{pre:!0,attrs:{class:"token punctuation"}},[s._v(";")]),s._v("\n")])]),s._v(" "),a("div",{staticClass:"line-numbers-wrapper"},[a("span",{staticClass:"line-number"},[s._v("1")]),a("br"),a("span",{staticClass:"line-number"},[s._v("2")]),a("br"),a("span",{staticClass:"line-number"},[s._v("3")]),a("br"),a("span",{staticClass:"line-number"},[s._v("4")]),a("br"),a("span",{staticClass:"line-number"},[s._v("5")]),a("br"),a("span",{staticClass:"line-number"},[s._v("6")]),a("br"),a("span",{staticClass:"line-number"},[s._v("7")]),a("br"),a("span",{staticClass:"line-number"},[s._v("8")]),a("br"),a("span",{staticClass:"line-number"},[s._v("9")]),a("br"),a("span",{staticClass:"line-number"},[s._v("10")]),a("br"),a("span",{staticClass:"line-number"},[s._v("11")]),a("br"),a("span",{staticClass:"line-number"},[s._v("12")]),a("br"),a("span",{staticClass:"line-number"},[s._v("13")]),a("br"),a("span",{staticClass:"line-number"},[s._v("14")]),a("br"),a("span",{staticClass:"line-number"},[s._v("15")]),a("br"),a("span",{staticClass:"line-number"},[s._v("16")]),a("br"),a("span",{staticClass:"line-number"},[s._v("17")]),a("br")])]),a("h3",{attrs:{id:"异步请求的异常"}},[a("a",{staticClass:"header-anchor",attrs:{href:"#异步请求的异常"}},[s._v("#")]),s._v(" 异步请求的异常")]),s._v(" "),a("p",[s._v("异步请求最常用的异常处理方式就是设置一个异常回调：")]),s._v(" "),a("div",{staticClass:"language-java line-numbers-mode"},[a("pre",{pre:!0,attrs:{class:"language-java"}},[a("code",[s._v("http"),a("span",{pre:!0,attrs:{class:"token punctuation"}},[s._v(".")]),a("span",{pre:!0,attrs:{class:"token function"}},[s._v("async")]),a("span",{pre:!0,attrs:{class:"token punctuation"}},[s._v("(")]),a("span",{pre:!0,attrs:{class:"token string"}},[s._v('"/users/1"')]),a("span",{pre:!0,attrs:{class:"token punctuation"}},[s._v(")")]),s._v("\n "),a("span",{pre:!0,attrs:{class:"token punctuation"}},[s._v(".")]),a("span",{pre:!0,attrs:{class:"token function"}},[s._v("setOnResponse")]),a("span",{pre:!0,attrs:{class:"token punctuation"}},[s._v("(")]),a("span",{pre:!0,attrs:{class:"token punctuation"}},[s._v("(")]),a("span",{pre:!0,attrs:{class:"token class-name"}},[s._v("HttpResult")]),s._v(" result"),a("span",{pre:!0,attrs:{class:"token punctuation"}},[s._v(")")]),s._v(" "),a("span",{pre:!0,attrs:{class:"token operator"}},[s._v("->")]),s._v(" "),a("span",{pre:!0,attrs:{class:"token punctuation"}},[s._v("{")]),s._v("\n "),a("span",{pre:!0,attrs:{class:"token comment"}},[s._v("// 当发生异常时就不会走这里")]),s._v("\n "),a("span",{pre:!0,attrs:{class:"token punctuation"}},[s._v("}")]),a("span",{pre:!0,attrs:{class:"token punctuation"}},[s._v(")")]),s._v("\n "),a("span",{pre:!0,attrs:{class:"token punctuation"}},[s._v(".")]),a("span",{pre:!0,attrs:{class:"token function"}},[s._v("setOnException")]),a("span",{pre:!0,attrs:{class:"token punctuation"}},[s._v("(")]),a("span",{pre:!0,attrs:{class:"token punctuation"}},[s._v("(")]),a("span",{pre:!0,attrs:{class:"token class-name"}},[s._v("IOException")]),s._v(" e"),a("span",{pre:!0,attrs:{class:"token punctuation"}},[s._v(")")]),s._v(" "),a("span",{pre:!0,attrs:{class:"token operator"}},[s._v("->")]),s._v(" "),a("span",{pre:!0,attrs:{class:"token punctuation"}},[s._v("{")]),s._v("\n "),a("span",{pre:!0,attrs:{class:"token comment"}},[s._v("// 这里处理请求异常")]),s._v("\n "),a("span",{pre:!0,attrs:{class:"token punctuation"}},[s._v("}")]),a("span",{pre:!0,attrs:{class:"token punctuation"}},[s._v(")")]),s._v("\n "),a("span",{pre:!0,attrs:{class:"token punctuation"}},[s._v(".")]),a("span",{pre:!0,attrs:{class:"token function"}},[s._v("get")]),a("span",{pre:!0,attrs:{class:"token punctuation"}},[s._v("(")]),a("span",{pre:!0,attrs:{class:"token punctuation"}},[s._v(")")]),a("span",{pre:!0,attrs:{class:"token punctuation"}},[s._v(";")]),s._v("\n")])]),s._v(" "),a("div",{staticClass:"line-numbers-wrapper"},[a("span",{staticClass:"line-number"},[s._v("1")]),a("br"),a("span",{staticClass:"line-number"},[s._v("2")]),a("br"),a("span",{staticClass:"line-number"},[s._v("3")]),a("br"),a("span",{staticClass:"line-number"},[s._v("4")]),a("br"),a("span",{staticClass:"line-number"},[s._v("5")]),a("br"),a("span",{staticClass:"line-number"},[s._v("6")]),a("br"),a("span",{staticClass:"line-number"},[s._v("7")]),a("br"),a("span",{staticClass:"line-number"},[s._v("8")]),a("br")])]),a("p",[s._v("当然，还有一个全局异常监听（"),a("code",[s._v("ExceptionListener")]),s._v("）：")]),s._v(" "),a("div",{staticClass:"language-java line-numbers-mode"},[a("pre",{pre:!0,attrs:{class:"language-java"}},[a("code",[a("span",{pre:!0,attrs:{class:"token class-name"}},[s._v("HTTP")]),s._v(" http "),a("span",{pre:!0,attrs:{class:"token operator"}},[s._v("=")]),s._v(" HTTP"),a("span",{pre:!0,attrs:{class:"token punctuation"}},[s._v(".")]),a("span",{pre:!0,attrs:{class:"token function"}},[s._v("builder")]),a("span",{pre:!0,attrs:{class:"token punctuation"}},[s._v("(")]),a("span",{pre:!0,attrs:{class:"token punctuation"}},[s._v(")")]),s._v("\n "),a("span",{pre:!0,attrs:{class:"token punctuation"}},[s._v(".")]),a("span",{pre:!0,attrs:{class:"token function"}},[s._v("exceptionListener")]),a("span",{pre:!0,attrs:{class:"token punctuation"}},[s._v("(")]),a("span",{pre:!0,attrs:{class:"token punctuation"}},[s._v("(")]),a("span",{pre:!0,attrs:{class:"token class-name"}},[s._v("HttpTask")]),a("span",{pre:!0,attrs:{class:"token generics"}},[a("span",{pre:!0,attrs:{class:"token punctuation"}},[s._v("<")]),a("span",{pre:!0,attrs:{class:"token operator"}},[s._v("?")]),a("span",{pre:!0,attrs:{class:"token punctuation"}},[s._v(">")])]),s._v(" task"),a("span",{pre:!0,attrs:{class:"token punctuation"}},[s._v(",")]),s._v(" "),a("span",{pre:!0,attrs:{class:"token class-name"}},[s._v("IOException")]),s._v(" error"),a("span",{pre:!0,attrs:{class:"token punctuation"}},[s._v(")")]),s._v(" "),a("span",{pre:!0,attrs:{class:"token operator"}},[s._v("->")]),s._v(" "),a("span",{pre:!0,attrs:{class:"token punctuation"}},[s._v("{")]),s._v("\n "),a("span",{pre:!0,attrs:{class:"token comment"}},[s._v("// 所有请求发生异常都会走这里")]),s._v("\n\n "),a("span",{pre:!0,attrs:{class:"token keyword"}},[s._v("return")]),s._v(" "),a("span",{pre:!0,attrs:{class:"token boolean"}},[s._v("true")]),a("span",{pre:!0,attrs:{class:"token punctuation"}},[s._v(";")]),s._v(" "),a("span",{pre:!0,attrs:{class:"token comment"}},[s._v("// 返回 true 表示继续执行 task 的 OnException 回调，false 表示不再执行")]),s._v("\n "),a("span",{pre:!0,attrs:{class:"token punctuation"}},[s._v("}")]),a("span",{pre:!0,attrs:{class:"token punctuation"}},[s._v(")")]),s._v("\n "),a("span",{pre:!0,attrs:{class:"token punctuation"}},[s._v(".")]),a("span",{pre:!0,attrs:{class:"token function"}},[s._v("build")]),a("span",{pre:!0,attrs:{class:"token punctuation"}},[s._v("(")]),a("span",{pre:!0,attrs:{class:"token punctuation"}},[s._v(")")]),a("span",{pre:!0,attrs:{class:"token punctuation"}},[s._v(";")]),s._v("\n")])]),s._v(" "),a("div",{staticClass:"line-numbers-wrapper"},[a("span",{staticClass:"line-number"},[s._v("1")]),a("br"),a("span",{staticClass:"line-number"},[s._v("2")]),a("br"),a("span",{staticClass:"line-number"},[s._v("3")]),a("br"),a("span",{staticClass:"line-number"},[s._v("4")]),a("br"),a("span",{staticClass:"line-number"},[s._v("5")]),a("br"),a("span",{staticClass:"line-number"},[s._v("6")]),a("br"),a("span",{staticClass:"line-number"},[s._v("7")]),a("br")])]),a("p",[s._v("如果不设置"),a("code",[s._v("OnException")]),s._v("回调，也没有"),a("code",[s._v("ExceptionListener")]),s._v("，发生异常时会在 "),a("strong",[s._v("IO 线程")]),s._v(" 中向上抛出，外层无法捕获：")]),s._v(" "),a("div",{staticClass:"language-java line-numbers-mode"},[a("pre",{pre:!0,attrs:{class:"language-java"}},[a("code",[a("span",{pre:!0,attrs:{class:"token keyword"}},[s._v("try")]),s._v(" "),a("span",{pre:!0,attrs:{class:"token punctuation"}},[s._v("{")]),s._v("\n http"),a("span",{pre:!0,attrs:{class:"token punctuation"}},[s._v(".")]),a("span",{pre:!0,attrs:{class:"token function"}},[s._v("async")]),a("span",{pre:!0,attrs:{class:"token punctuation"}},[s._v("(")]),a("span",{pre:!0,attrs:{class:"token string"}},[s._v('"/users/1"')]),a("span",{pre:!0,attrs:{class:"token punctuation"}},[s._v(")")]),s._v("\n "),a("span",{pre:!0,attrs:{class:"token punctuation"}},[s._v(".")]),a("span",{pre:!0,attrs:{class:"token function"}},[s._v("setOnResponse")]),a("span",{pre:!0,attrs:{class:"token punctuation"}},[s._v("(")]),a("span",{pre:!0,attrs:{class:"token punctuation"}},[s._v("(")]),a("span",{pre:!0,attrs:{class:"token class-name"}},[s._v("HttpResult")]),s._v(" result"),a("span",{pre:!0,attrs:{class:"token punctuation"}},[s._v(")")]),s._v(" "),a("span",{pre:!0,attrs:{class:"token operator"}},[s._v("->")]),s._v(" "),a("span",{pre:!0,attrs:{class:"token punctuation"}},[s._v("{")]),s._v("\n "),a("span",{pre:!0,attrs:{class:"token comment"}},[s._v("// 当发生异常时就不会走这里")]),s._v("\n "),a("span",{pre:!0,attrs:{class:"token punctuation"}},[s._v("}")]),a("span",{pre:!0,attrs:{class:"token punctuation"}},[s._v(")")]),s._v("\n "),a("span",{pre:!0,attrs:{class:"token punctuation"}},[s._v(".")]),a("span",{pre:!0,attrs:{class:"token function"}},[s._v("get")]),a("span",{pre:!0,attrs:{class:"token punctuation"}},[s._v("(")]),a("span",{pre:!0,attrs:{class:"token punctuation"}},[s._v(")")]),a("span",{pre:!0,attrs:{class:"token punctuation"}},[s._v(";")]),s._v("\n"),a("span",{pre:!0,attrs:{class:"token punctuation"}},[s._v("}")]),s._v(" "),a("span",{pre:!0,attrs:{class:"token keyword"}},[s._v("catch")]),s._v(" "),a("span",{pre:!0,attrs:{class:"token punctuation"}},[s._v("(")]),a("span",{pre:!0,attrs:{class:"token class-name"}},[s._v("HttpException")]),s._v(" e"),a("span",{pre:!0,attrs:{class:"token punctuation"}},[s._v(")")]),s._v(" "),a("span",{pre:!0,attrs:{class:"token punctuation"}},[s._v("{")]),s._v("\n "),a("span",{pre:!0,attrs:{class:"token comment"}},[s._v("// 这种方式是捕获不到异常的！！！！！！")]),s._v("\n"),a("span",{pre:!0,attrs:{class:"token punctuation"}},[s._v("}")]),s._v("\n")])]),s._v(" "),a("div",{staticClass:"line-numbers-wrapper"},[a("span",{staticClass:"line-number"},[s._v("1")]),a("br"),a("span",{staticClass:"line-number"},[s._v("2")]),a("br"),a("span",{staticClass:"line-number"},[s._v("3")]),a("br"),a("span",{staticClass:"line-number"},[s._v("4")]),a("br"),a("span",{staticClass:"line-number"},[s._v("5")]),a("br"),a("span",{staticClass:"line-number"},[s._v("6")]),a("br"),a("span",{staticClass:"line-number"},[s._v("7")]),a("br"),a("span",{staticClass:"line-number"},[s._v("8")]),a("br"),a("span",{staticClass:"line-number"},[s._v("9")]),a("br")])]),a("p",[s._v("即使没有"),a("code",[s._v("OnException")]),s._v("回调，发生异常时，依然会走"),a("code",[s._v("OnComplete")]),s._v("回调，如果设置了的话：")]),s._v(" "),a("div",{staticClass:"language-java line-numbers-mode"},[a("pre",{pre:!0,attrs:{class:"language-java"}},[a("code",[s._v("http"),a("span",{pre:!0,attrs:{class:"token punctuation"}},[s._v(".")]),a("span",{pre:!0,attrs:{class:"token function"}},[s._v("async")]),a("span",{pre:!0,attrs:{class:"token punctuation"}},[s._v("(")]),a("span",{pre:!0,attrs:{class:"token string"}},[s._v('"/users/1"')]),a("span",{pre:!0,attrs:{class:"token punctuation"}},[s._v(")")]),s._v("\n "),a("span",{pre:!0,attrs:{class:"token punctuation"}},[s._v(".")]),a("span",{pre:!0,attrs:{class:"token function"}},[s._v("setOnResponse")]),a("span",{pre:!0,attrs:{class:"token punctuation"}},[s._v("(")]),a("span",{pre:!0,attrs:{class:"token punctuation"}},[s._v("(")]),a("span",{pre:!0,attrs:{class:"token class-name"}},[s._v("HttpResult")]),s._v(" result"),a("span",{pre:!0,attrs:{class:"token punctuation"}},[s._v(")")]),s._v(" "),a("span",{pre:!0,attrs:{class:"token operator"}},[s._v("->")]),s._v(" "),a("span",{pre:!0,attrs:{class:"token punctuation"}},[s._v("{")]),s._v("\n "),a("span",{pre:!0,attrs:{class:"token comment"}},[s._v("// 当发生异常时就不会走这里")]),s._v("\n "),a("span",{pre:!0,attrs:{class:"token punctuation"}},[s._v("}")]),a("span",{pre:!0,attrs:{class:"token punctuation"}},[s._v(")")]),s._v("\n "),a("span",{pre:!0,attrs:{class:"token punctuation"}},[s._v(".")]),a("span",{pre:!0,attrs:{class:"token function"}},[s._v("setOnComplete")]),a("span",{pre:!0,attrs:{class:"token punctuation"}},[s._v("(")]),a("span",{pre:!0,attrs:{class:"token punctuation"}},[s._v("(")]),a("span",{pre:!0,attrs:{class:"token class-name"}},[s._v("State")]),s._v(" state"),a("span",{pre:!0,attrs:{class:"token punctuation"}},[s._v(")")]),s._v(" "),a("span",{pre:!0,attrs:{class:"token operator"}},[s._v("->")]),s._v(" "),a("span",{pre:!0,attrs:{class:"token punctuation"}},[s._v("{")]),s._v("\n "),a("span",{pre:!0,attrs:{class:"token comment"}},[s._v("// 发生异常，会先执行这里，可以根据 state 判断发生了什么")]),s._v("\n "),a("span",{pre:!0,attrs:{class:"token comment"}},[s._v("// 但执行完后依然会在IO线程中向上抛出")]),s._v("\n "),a("span",{pre:!0,attrs:{class:"token punctuation"}},[s._v("}")]),a("span",{pre:!0,attrs:{class:"token punctuation"}},[s._v(")")]),s._v("\n "),a("span",{pre:!0,attrs:{class:"token punctuation"}},[s._v(".")]),a("span",{pre:!0,attrs:{class:"token function"}},[s._v("get")]),a("span",{pre:!0,attrs:{class:"token punctuation"}},[s._v("(")]),a("span",{pre:!0,attrs:{class:"token punctuation"}},[s._v(")")]),a("span",{pre:!0,attrs:{class:"token punctuation"}},[s._v(";")]),s._v("\n")])]),s._v(" "),a("div",{staticClass:"line-numbers-wrapper"},[a("span",{staticClass:"line-number"},[s._v("1")]),a("br"),a("span",{staticClass:"line-number"},[s._v("2")]),a("br"),a("span",{staticClass:"line-number"},[s._v("3")]),a("br"),a("span",{staticClass:"line-number"},[s._v("4")]),a("br"),a("span",{staticClass:"line-number"},[s._v("5")]),a("br"),a("span",{staticClass:"line-number"},[s._v("6")]),a("br"),a("span",{staticClass:"line-number"},[s._v("7")]),a("br"),a("span",{staticClass:"line-number"},[s._v("8")]),a("br"),a("span",{staticClass:"line-number"},[s._v("9")]),a("br")])]),a("p",[s._v("如果就是想 "),a("strong",[s._v("不处理异常，也不向上抛出")]),s._v("，发生错误完全无视，可以做到吗？可以！还是使用"),a("code",[s._v("nothrow()")]),s._v("方法：")]),s._v(" "),a("div",{staticClass:"language-java line-numbers-mode"},[a("pre",{pre:!0,attrs:{class:"language-java"}},[a("code",[s._v("http"),a("span",{pre:!0,attrs:{class:"token punctuation"}},[s._v(".")]),a("span",{pre:!0,attrs:{class:"token function"}},[s._v("async")]),a("span",{pre:!0,attrs:{class:"token punctuation"}},[s._v("(")]),a("span",{pre:!0,attrs:{class:"token string"}},[s._v('"/users/1"')]),a("span",{pre:!0,attrs:{class:"token punctuation"}},[s._v(")")]),s._v("\n "),a("span",{pre:!0,attrs:{class:"token punctuation"}},[s._v(".")]),a("span",{pre:!0,attrs:{class:"token function"}},[s._v("nothrow")]),a("span",{pre:!0,attrs:{class:"token punctuation"}},[s._v("(")]),a("span",{pre:!0,attrs:{class:"token punctuation"}},[s._v(")")]),s._v(" "),a("span",{pre:!0,attrs:{class:"token comment"}},[s._v("// 告诉 OkHttps 发生异常时不向外抛出")]),s._v("\n "),a("span",{pre:!0,attrs:{class:"token punctuation"}},[s._v(".")]),a("span",{pre:!0,attrs:{class:"token function"}},[s._v("setOnResponse")]),a("span",{pre:!0,attrs:{class:"token punctuation"}},[s._v("(")]),a("span",{pre:!0,attrs:{class:"token punctuation"}},[s._v("(")]),a("span",{pre:!0,attrs:{class:"token class-name"}},[s._v("HttpResult")]),s._v(" result"),a("span",{pre:!0,attrs:{class:"token punctuation"}},[s._v(")")]),s._v(" "),a("span",{pre:!0,attrs:{class:"token operator"}},[s._v("->")]),s._v(" "),a("span",{pre:!0,attrs:{class:"token punctuation"}},[s._v("{")]),s._v("\n "),a("span",{pre:!0,attrs:{class:"token comment"}},[s._v("// 当发生异常时就不会走这里")]),s._v("\n "),a("span",{pre:!0,attrs:{class:"token punctuation"}},[s._v("}")]),a("span",{pre:!0,attrs:{class:"token punctuation"}},[s._v(")")]),s._v("\n "),a("span",{pre:!0,attrs:{class:"token punctuation"}},[s._v(".")]),a("span",{pre:!0,attrs:{class:"token function"}},[s._v("get")]),a("span",{pre:!0,attrs:{class:"token punctuation"}},[s._v("(")]),a("span",{pre:!0,attrs:{class:"token punctuation"}},[s._v(")")]),a("span",{pre:!0,attrs:{class:"token punctuation"}},[s._v(";")]),s._v("\n")])]),s._v(" "),a("div",{staticClass:"line-numbers-wrapper"},[a("span",{staticClass:"line-number"},[s._v("1")]),a("br"),a("span",{staticClass:"line-number"},[s._v("2")]),a("br"),a("span",{staticClass:"line-number"},[s._v("3")]),a("br"),a("span",{staticClass:"line-number"},[s._v("4")]),a("br"),a("span",{staticClass:"line-number"},[s._v("5")]),a("br"),a("span",{staticClass:"line-number"},[s._v("6")]),a("br")])]),a("h2",{attrs:{id:"取消请求"}},[a("a",{staticClass:"header-anchor",attrs:{href:"#取消请求"}},[s._v("#")]),s._v(" 取消请求")]),s._v(" "),a("p",[s._v("在 OkHttps 里取消请求共有 "),a("strong",[s._v("4 种")]),s._v(" 方式可选：")]),s._v(" "),a("ul",[a("li",[s._v("使用"),a("code",[s._v("HttpCall#cancel()")]),s._v("取消单个请求（适用于异步请求，"),a("a",{attrs:{href:"#33-httpcall"}},[s._v("详见 3.3 章节")]),s._v("）")]),s._v(" "),a("li",[s._v("使用"),a("code",[s._v("HttpTask#cancel()")]),s._v("取消单个请求（适用于所有请求）（since v1.0.4）")])]),s._v(" "),a("div",{staticClass:"language-java line-numbers-mode"},[a("pre",{pre:!0,attrs:{class:"language-java"}},[a("code",[a("span",{pre:!0,attrs:{class:"token class-name"}},[s._v("HttpTask")]),a("span",{pre:!0,attrs:{class:"token generics"}},[a("span",{pre:!0,attrs:{class:"token punctuation"}},[s._v("<")]),a("span",{pre:!0,attrs:{class:"token operator"}},[s._v("?")]),a("span",{pre:!0,attrs:{class:"token punctuation"}},[s._v(">")])]),s._v(" task "),a("span",{pre:!0,attrs:{class:"token operator"}},[s._v("=")]),s._v(" http"),a("span",{pre:!0,attrs:{class:"token punctuation"}},[s._v(".")]),a("span",{pre:!0,attrs:{class:"token function"}},[s._v("async")]),a("span",{pre:!0,attrs:{class:"token punctuation"}},[s._v("(")]),a("span",{pre:!0,attrs:{class:"token string"}},[s._v('"/users"')]),a("span",{pre:!0,attrs:{class:"token punctuation"}},[s._v(")")]),s._v("\n "),a("span",{pre:!0,attrs:{class:"token punctuation"}},[s._v(".")]),a("span",{pre:!0,attrs:{class:"token function"}},[s._v("setOnResponse")]),a("span",{pre:!0,attrs:{class:"token punctuation"}},[s._v("(")]),a("span",{pre:!0,attrs:{class:"token punctuation"}},[s._v("(")]),a("span",{pre:!0,attrs:{class:"token class-name"}},[s._v("HttpResult")]),s._v(" result"),a("span",{pre:!0,attrs:{class:"token punctuation"}},[s._v(")")]),s._v(" "),a("span",{pre:!0,attrs:{class:"token operator"}},[s._v("->")]),s._v(" "),a("span",{pre:!0,attrs:{class:"token punctuation"}},[s._v("{")]),s._v("\n "),a("span",{pre:!0,attrs:{class:"token comment"}},[s._v("// 响应回调")]),s._v("\n "),a("span",{pre:!0,attrs:{class:"token punctuation"}},[s._v("}")]),a("span",{pre:!0,attrs:{class:"token punctuation"}},[s._v(")")]),a("span",{pre:!0,attrs:{class:"token punctuation"}},[s._v(";")]),s._v("\n\ntask"),a("span",{pre:!0,attrs:{class:"token punctuation"}},[s._v(".")]),a("span",{pre:!0,attrs:{class:"token function"}},[s._v("get")]),a("span",{pre:!0,attrs:{class:"token punctuation"}},[s._v("(")]),a("span",{pre:!0,attrs:{class:"token punctuation"}},[s._v(")")]),a("span",{pre:!0,attrs:{class:"token punctuation"}},[s._v(";")]),s._v(" "),a("span",{pre:!0,attrs:{class:"token comment"}},[s._v("// 发起 GET 请求")]),s._v("\n\n"),a("span",{pre:!0,attrs:{class:"token comment"}},[s._v("// 取消请求，并返回是否取消成功")]),s._v("\n"),a("span",{pre:!0,attrs:{class:"token keyword"}},[s._v("boolean")]),s._v(" canceled "),a("span",{pre:!0,attrs:{class:"token operator"}},[s._v("=")]),s._v(" task"),a("span",{pre:!0,attrs:{class:"token punctuation"}},[s._v(".")]),a("span",{pre:!0,attrs:{class:"token function"}},[s._v("cancel")]),a("span",{pre:!0,attrs:{class:"token punctuation"}},[s._v("(")]),a("span",{pre:!0,attrs:{class:"token punctuation"}},[s._v(")")]),a("span",{pre:!0,attrs:{class:"token punctuation"}},[s._v(";")]),s._v(" \n")])]),s._v(" "),a("div",{staticClass:"line-numbers-wrapper"},[a("span",{staticClass:"line-number"},[s._v("1")]),a("br"),a("span",{staticClass:"line-number"},[s._v("2")]),a("br"),a("span",{staticClass:"line-number"},[s._v("3")]),a("br"),a("span",{staticClass:"line-number"},[s._v("4")]),a("br"),a("span",{staticClass:"line-number"},[s._v("5")]),a("br"),a("span",{staticClass:"line-number"},[s._v("6")]),a("br"),a("span",{staticClass:"line-number"},[s._v("7")]),a("br"),a("span",{staticClass:"line-number"},[s._v("8")]),a("br"),a("span",{staticClass:"line-number"},[s._v("9")]),a("br")])]),a("ul",[a("li",[s._v("使用"),a("code",[s._v("HTTP#cancel(String tag)")]),s._v("按标签批量取消请求（适用于所有请求，"),a("a",{attrs:{href:"#5-%E4%BD%BF%E7%94%A8%E6%A0%87%E7%AD%BE"}},[s._v("详见第 5 章节")]),s._v("）")]),s._v(" "),a("li",[s._v("使用"),a("code",[s._v("HTTP#cancelAll()")]),s._v("取消所有请求（适用于所有请求）（since v1.0.2）")])]),s._v(" "),a("div",{staticClass:"language-java line-numbers-mode"},[a("pre",{pre:!0,attrs:{class:"language-java"}},[a("code",[s._v("http"),a("span",{pre:!0,attrs:{class:"token punctuation"}},[s._v(".")]),a("span",{pre:!0,attrs:{class:"token function"}},[s._v("cancelAll")]),a("span",{pre:!0,attrs:{class:"token punctuation"}},[s._v("(")]),a("span",{pre:!0,attrs:{class:"token punctuation"}},[s._v(")")]),a("span",{pre:!0,attrs:{class:"token punctuation"}},[s._v(";")]),s._v(" "),a("span",{pre:!0,attrs:{class:"token comment"}},[s._v("// 取消所有请求")]),s._v("\n")])]),s._v(" "),a("div",{staticClass:"line-numbers-wrapper"},[a("span",{staticClass:"line-number"},[s._v("1")]),a("br")])])])}),[],!1,null,null,null);t.default=e.exports}}]); \ No newline at end of file diff --git a/okhttps-doc/docs/.vuepress/dist/assets/js/11.152d132f.js b/okhttps-doc/docs/.vuepress/dist/assets/js/11.152d132f.js deleted file mode 100644 index 4ce64ac2..00000000 --- a/okhttps-doc/docs/.vuepress/dist/assets/js/11.152d132f.js +++ /dev/null @@ -1 +0,0 @@ -(window.webpackJsonp=window.webpackJsonp||[]).push([[11],{335:function(t,s,a){"use strict";a.r(s);var n=a(19),e=Object(n.a)({},(function(){var t=this,s=t.$createElement,a=t._self._c||s;return a("ContentSlotsDistributor",{attrs:{"slot-key":t.$parent.slotKey}},[a("h1",{attrs:{id:"基础"}},[a("a",{staticClass:"header-anchor",attrs:{href:"#基础"}},[t._v("#")]),t._v(" 基础")]),t._v(" "),a("h2",{attrs:{id:"请求方法"}},[a("a",{staticClass:"header-anchor",attrs:{href:"#请求方法"}},[t._v("#")]),t._v(" 请求方法")]),t._v(" "),a("p",[t._v("同步与异步的"),a("code",[t._v("HttpTask")]),t._v("都拥有"),a("code",[t._v("get")]),t._v("、"),a("code",[t._v("post")]),t._v("、"),a("code",[t._v("put")]),t._v("与"),a("code",[t._v("delete")]),t._v("方法。不同的是：同步"),a("code",[t._v("HttpTask")]),t._v("的这些方法返回一个"),a("code",[t._v("HttpResult")]),t._v("，而异步"),a("code",[t._v("HttpTask")]),t._v("的这些方法返回一个"),a("code",[t._v("HttpCall")]),t._v("。")]),t._v(" "),a("div",{staticClass:"language-java line-numbers-mode"},[a("pre",{pre:!0,attrs:{class:"language-java"}},[a("code",[a("span",{pre:!0,attrs:{class:"token class-name"}},[t._v("HttpResult")]),t._v(" res1 "),a("span",{pre:!0,attrs:{class:"token operator"}},[t._v("=")]),t._v(" http"),a("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v(".")]),a("span",{pre:!0,attrs:{class:"token function"}},[t._v("sync")]),a("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v("(")]),a("span",{pre:!0,attrs:{class:"token string"}},[t._v('"/users"')]),a("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v(")")]),a("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v(".")]),a("span",{pre:!0,attrs:{class:"token function"}},[t._v("get")]),a("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v("(")]),a("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v(")")]),a("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v(";")]),t._v(" "),a("span",{pre:!0,attrs:{class:"token comment"}},[t._v("// 同步 GET")]),t._v("\n"),a("span",{pre:!0,attrs:{class:"token class-name"}},[t._v("HttpResult")]),t._v(" res2 "),a("span",{pre:!0,attrs:{class:"token operator"}},[t._v("=")]),t._v(" http"),a("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v(".")]),a("span",{pre:!0,attrs:{class:"token function"}},[t._v("sync")]),a("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v("(")]),a("span",{pre:!0,attrs:{class:"token string"}},[t._v('"/users"')]),a("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v(")")]),a("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v(".")]),a("span",{pre:!0,attrs:{class:"token function"}},[t._v("post")]),a("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v("(")]),a("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v(")")]),a("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v(";")]),t._v(" "),a("span",{pre:!0,attrs:{class:"token comment"}},[t._v("// 同步 POST")]),t._v("\n"),a("span",{pre:!0,attrs:{class:"token class-name"}},[t._v("HttpResult")]),t._v(" res3 "),a("span",{pre:!0,attrs:{class:"token operator"}},[t._v("=")]),t._v(" http"),a("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v(".")]),a("span",{pre:!0,attrs:{class:"token function"}},[t._v("sync")]),a("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v("(")]),a("span",{pre:!0,attrs:{class:"token string"}},[t._v('"/users/1"')]),a("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v(")")]),a("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v(".")]),a("span",{pre:!0,attrs:{class:"token function"}},[t._v("put")]),a("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v("(")]),a("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v(")")]),a("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v(";")]),t._v(" "),a("span",{pre:!0,attrs:{class:"token comment"}},[t._v("// 同步 PUT")]),t._v("\n"),a("span",{pre:!0,attrs:{class:"token class-name"}},[t._v("HttpResult")]),t._v(" res4 "),a("span",{pre:!0,attrs:{class:"token operator"}},[t._v("=")]),t._v(" http"),a("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v(".")]),a("span",{pre:!0,attrs:{class:"token function"}},[t._v("sync")]),a("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v("(")]),a("span",{pre:!0,attrs:{class:"token string"}},[t._v('"/users/1"')]),a("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v(")")]),a("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v(".")]),a("span",{pre:!0,attrs:{class:"token function"}},[t._v("delete")]),a("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v("(")]),a("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v(")")]),a("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v(";")]),a("span",{pre:!0,attrs:{class:"token comment"}},[t._v("// 同步 DELETE")]),t._v("\n"),a("span",{pre:!0,attrs:{class:"token class-name"}},[t._v("HttpCall")]),t._v(" call1 "),a("span",{pre:!0,attrs:{class:"token operator"}},[t._v("=")]),t._v(" http"),a("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v(".")]),a("span",{pre:!0,attrs:{class:"token function"}},[t._v("async")]),a("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v("(")]),a("span",{pre:!0,attrs:{class:"token string"}},[t._v('"/users"')]),a("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v(")")]),a("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v(".")]),a("span",{pre:!0,attrs:{class:"token function"}},[t._v("get")]),a("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v("(")]),a("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v(")")]),a("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v(";")]),t._v(" "),a("span",{pre:!0,attrs:{class:"token comment"}},[t._v("// 异步 GET")]),t._v("\n"),a("span",{pre:!0,attrs:{class:"token class-name"}},[t._v("HttpCall")]),t._v(" call2 "),a("span",{pre:!0,attrs:{class:"token operator"}},[t._v("=")]),t._v(" http"),a("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v(".")]),a("span",{pre:!0,attrs:{class:"token function"}},[t._v("async")]),a("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v("(")]),a("span",{pre:!0,attrs:{class:"token string"}},[t._v('"/users"')]),a("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v(")")]),a("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v(".")]),a("span",{pre:!0,attrs:{class:"token function"}},[t._v("post")]),a("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v("(")]),a("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v(")")]),a("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v(";")]),t._v(" "),a("span",{pre:!0,attrs:{class:"token comment"}},[t._v("// 异步 POST")]),t._v("\n"),a("span",{pre:!0,attrs:{class:"token class-name"}},[t._v("HttpCall")]),t._v(" call3 "),a("span",{pre:!0,attrs:{class:"token operator"}},[t._v("=")]),t._v(" http"),a("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v(".")]),a("span",{pre:!0,attrs:{class:"token function"}},[t._v("async")]),a("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v("(")]),a("span",{pre:!0,attrs:{class:"token string"}},[t._v('"/users/1"')]),a("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v(")")]),a("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v(".")]),a("span",{pre:!0,attrs:{class:"token function"}},[t._v("put")]),a("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v("(")]),a("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v(")")]),a("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v(";")]),t._v(" "),a("span",{pre:!0,attrs:{class:"token comment"}},[t._v("// 异步 PUT")]),t._v("\n"),a("span",{pre:!0,attrs:{class:"token class-name"}},[t._v("HttpCall")]),t._v(" call4 "),a("span",{pre:!0,attrs:{class:"token operator"}},[t._v("=")]),t._v(" http"),a("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v(".")]),a("span",{pre:!0,attrs:{class:"token function"}},[t._v("async")]),a("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v("(")]),a("span",{pre:!0,attrs:{class:"token string"}},[t._v('"/users/1"')]),a("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v(")")]),a("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v(".")]),a("span",{pre:!0,attrs:{class:"token function"}},[t._v("delete")]),a("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v("(")]),a("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v(")")]),a("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v(";")]),a("span",{pre:!0,attrs:{class:"token comment"}},[t._v("// 异步 DELETE")]),t._v("\n")])]),t._v(" "),a("div",{staticClass:"line-numbers-wrapper"},[a("span",{staticClass:"line-number"},[t._v("1")]),a("br"),a("span",{staticClass:"line-number"},[t._v("2")]),a("br"),a("span",{staticClass:"line-number"},[t._v("3")]),a("br"),a("span",{staticClass:"line-number"},[t._v("4")]),a("br"),a("span",{staticClass:"line-number"},[t._v("5")]),a("br"),a("span",{staticClass:"line-number"},[t._v("6")]),a("br"),a("span",{staticClass:"line-number"},[t._v("7")]),a("br"),a("span",{staticClass:"line-number"},[t._v("8")]),a("br")])]),a("h2",{attrs:{id:"回调函数"}},[a("a",{staticClass:"header-anchor",attrs:{href:"#回调函数"}},[t._v("#")]),t._v(" 回调函数")]),t._v(" "),a("p",[t._v("OkHttps 的回调函数全部使用单方法模式，这样可以充分利用 Java8 或 Kotlin 中的 Lambda 表达式，使你的代码更加简洁优雅：")]),t._v(" "),a("div",{staticClass:"language-java line-numbers-mode"},[a("pre",{pre:!0,attrs:{class:"language-java"}},[a("code",[t._v("http"),a("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v(".")]),a("span",{pre:!0,attrs:{class:"token function"}},[t._v("async")]),a("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v("(")]),a("span",{pre:!0,attrs:{class:"token string"}},[t._v('"/users/{id}"')]),a("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v(")")]),t._v(" "),a("span",{pre:!0,attrs:{class:"token comment"}},[t._v("// http://api.demo.com/users/1")]),t._v("\n "),a("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v(".")]),a("span",{pre:!0,attrs:{class:"token function"}},[t._v("addPathParam")]),a("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v("(")]),a("span",{pre:!0,attrs:{class:"token string"}},[t._v('"id"')]),a("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v(",")]),t._v(" "),a("span",{pre:!0,attrs:{class:"token number"}},[t._v("1")]),a("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v(")")]),t._v("\n "),a("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v(".")]),a("span",{pre:!0,attrs:{class:"token function"}},[t._v("setOnResponse")]),a("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v("(")]),a("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v("(")]),a("span",{pre:!0,attrs:{class:"token class-name"}},[t._v("HttpResult")]),t._v(" result"),a("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v(")")]),t._v(" "),a("span",{pre:!0,attrs:{class:"token operator"}},[t._v("->")]),t._v(" "),a("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v("{")]),t._v("\n "),a("span",{pre:!0,attrs:{class:"token comment"}},[t._v("// 响应回调")]),t._v("\n "),a("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v("}")]),a("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v(")")]),t._v("\n "),a("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v(".")]),a("span",{pre:!0,attrs:{class:"token function"}},[t._v("setOnException")]),a("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v("(")]),a("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v("(")]),a("span",{pre:!0,attrs:{class:"token class-name"}},[t._v("IOException")]),t._v(" e"),a("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v(")")]),t._v(" "),a("span",{pre:!0,attrs:{class:"token operator"}},[t._v("->")]),t._v(" "),a("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v("{")]),t._v("\n "),a("span",{pre:!0,attrs:{class:"token comment"}},[t._v("// 异常回调")]),t._v("\n "),a("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v("}")]),a("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v(")")]),t._v("\n "),a("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v(".")]),a("span",{pre:!0,attrs:{class:"token function"}},[t._v("setOnComplete")]),a("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v("(")]),a("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v("(")]),a("span",{pre:!0,attrs:{class:"token class-name"}},[t._v("State")]),t._v(" state"),a("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v(")")]),t._v(" "),a("span",{pre:!0,attrs:{class:"token operator"}},[t._v("->")]),t._v(" "),a("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v("{")]),t._v("\n "),a("span",{pre:!0,attrs:{class:"token comment"}},[t._v("// 完成回调，无论成功失败都会执行")]),t._v("\n "),a("span",{pre:!0,attrs:{class:"token comment"}},[t._v("// 并且在 响应|异常回调 之前执行")]),t._v("\n "),a("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v("}")]),a("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v(")")]),t._v("\n "),a("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v(".")]),a("span",{pre:!0,attrs:{class:"token function"}},[t._v("get")]),a("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v("(")]),a("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v(")")]),a("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v(";")]),t._v("\n")])]),t._v(" "),a("div",{staticClass:"line-numbers-wrapper"},[a("span",{staticClass:"line-number"},[t._v("1")]),a("br"),a("span",{staticClass:"line-number"},[t._v("2")]),a("br"),a("span",{staticClass:"line-number"},[t._v("3")]),a("br"),a("span",{staticClass:"line-number"},[t._v("4")]),a("br"),a("span",{staticClass:"line-number"},[t._v("5")]),a("br"),a("span",{staticClass:"line-number"},[t._v("6")]),a("br"),a("span",{staticClass:"line-number"},[t._v("7")]),a("br"),a("span",{staticClass:"line-number"},[t._v("8")]),a("br"),a("span",{staticClass:"line-number"},[t._v("9")]),a("br"),a("span",{staticClass:"line-number"},[t._v("10")]),a("br"),a("span",{staticClass:"line-number"},[t._v("11")]),a("br"),a("span",{staticClass:"line-number"},[t._v("12")]),a("br"),a("span",{staticClass:"line-number"},[t._v("13")]),a("br")])]),a("p",[t._v("OkHttps 同时还支持 "),a("strong",[t._v("全局回调")]),t._v(" 和 "),a("strong",[t._v("回调阻断")]),t._v(" 机制，详见 "),a("RouterLink",{attrs:{to:"/guide/configuration.html#全局回调监听"}},[t._v("全局回调监听")]),t._v("。")],1),t._v(" "),a("div",{staticClass:"custom-block tip"},[a("p",{staticClass:"custom-block-title"},[t._v("TIP")]),t._v(" "),a("ul",[a("li",[t._v("只有异步请求才可以设置这三种（响应|异常|完成）回调")]),t._v(" "),a("li",[t._v("同步请求直接返回结果，无需使用回调")])])]),t._v(" "),a("h2",{attrs:{id:"httpresult"}},[a("a",{staticClass:"header-anchor",attrs:{href:"#httpresult"}},[t._v("#")]),t._v(" HttpResult")]),t._v(" "),a("p",[a("code",[t._v("HttpResult")]),t._v("是HTTP请求执行完后的结果，它是同步请求方法（ "),a("code",[t._v("get")]),t._v("、"),a("code",[t._v("post")]),t._v("、"),a("code",[t._v("put")]),t._v("、"),a("code",[t._v("delete")]),t._v("）的返回值，也是异步请求响应回调（"),a("code",[t._v("OnResponse")]),t._v("）的参数，它定义了如下方法：")]),t._v(" "),a("ul",[a("li",[a("code",[t._v("getState()")]),t._v(" 得到请求执行状态枚举，它有以下取值：\n"),a("ul",[a("li",[a("code",[t._v("State.CANCELED")]),t._v(" 请求被取消")]),t._v(" "),a("li",[a("code",[t._v("State.RESPONSED")]),t._v(" 已收到响应")]),t._v(" "),a("li",[a("code",[t._v("State.TIMEOUT")]),t._v(" 请求超时")]),t._v(" "),a("li",[a("code",[t._v("State.NETWORK_ERROR")]),t._v(" 网络错误")]),t._v(" "),a("li",[a("code",[t._v("State.EXCEPTION")]),t._v(" 其它请求异常")])])]),t._v(" "),a("li",[a("code",[t._v("getStatus()")]),t._v(" 得到HTTP状态码")]),t._v(" "),a("li",[a("code",[t._v("isSuccessful()")]),t._v(" 是否响应成功，状态码在 [200..300) 之间")]),t._v(" "),a("li",[a("code",[t._v("getHeaders()")]),t._v(" 得到HTTP响应头")]),t._v(" "),a("li",[a("code",[t._v("getHeaders(String name)")]),t._v(" 得到HTTP响应头")]),t._v(" "),a("li",[a("code",[t._v("getHeader(String name)")]),t._v(" 得到HTTP响应头")]),t._v(" "),a("li",[a("code",[t._v("getBody()")]),t._v(" 得到响应报文体"),a("code",[t._v("Body")]),t._v("实例，它定义了如下方法（对同一个"),a("code",[t._v("Body")]),t._v("实例，以下的"),a("code",[t._v("toXXX()")]),t._v("类方法只能使用一个且仅能调用一次，除非先使用 cache 方法）：\n"),a("ul",[a("li",[a("code",[t._v("toBytes()")]),t._v(" 返回字节数组")]),t._v(" "),a("li",[a("code",[t._v("toByteStream()")]),t._v(" 返回字节输入流")]),t._v(" "),a("li",[a("code",[t._v("toCharStream()")]),t._v(" 返回字符输入流")]),t._v(" "),a("li",[a("code",[t._v("toString()")]),t._v(" 返回字符串")]),t._v(" "),a("li",[a("code",[t._v("toJsonObject()")]),t._v(" 返回Json对象")]),t._v(" "),a("li",[a("code",[t._v("toJsonArray()")]),t._v(" 返回Json数组")]),t._v(" "),a("li",[a("code",[t._v("toBean(Class type)")]),t._v(" 返回根据type自动json解析后的JavaBean")]),t._v(" "),a("li",[a("code",[t._v("toList(Class type)")]),t._v(" 返回根据type自动json解析后的JavaBean列表")]),t._v(" "),a("li",[a("code",[t._v("toFile(String filePath)")]),t._v(" 下载到指定路径")]),t._v(" "),a("li",[a("code",[t._v("toFile(File file)")]),t._v(" 下载到指定文件")]),t._v(" "),a("li",[a("code",[t._v("toFolder(String dirPath)")]),t._v(" 下载到指定目录")]),t._v(" "),a("li",[a("code",[t._v("toFolder(File dir)")]),t._v(" 下载到指定目录")]),t._v(" "),a("li",[a("code",[t._v("getContentType()")]),t._v(" 返回报文体的媒体类型")]),t._v(" "),a("li",[a("code",[t._v("getContentLength()")]),t._v(" 返回报文体的字节长度")]),t._v(" "),a("li",[a("code",[t._v("cache()")]),t._v(" 缓存报文体，开启缓存后可重复使用"),a("code",[t._v("toXXX()")]),t._v("类方法")]),t._v(" "),a("li",[a("code",[t._v("close()")]),t._v(" 关闭报文体，未对报文体做任何消费时使用，比如只读取报文头")])])]),t._v(" "),a("li",[a("code",[t._v("getError()")]),t._v(" 执行中发生的异常，自动捕获执行请求时发生的 网络超时、网络错误 和 其它IO异常")]),t._v(" "),a("li",[a("code",[t._v("close()")]),t._v(" 关闭报文，未对报文体做任何消费时使用，比如只读取长度")])]),t._v(" "),a("p",[t._v("示例，请求结果自动转Bean和List：")]),t._v(" "),a("div",{staticClass:"language-java line-numbers-mode"},[a("pre",{pre:!0,attrs:{class:"language-java"}},[a("code",[a("span",{pre:!0,attrs:{class:"token comment"}},[t._v("// 自动转Bean")]),t._v("\n"),a("span",{pre:!0,attrs:{class:"token class-name"}},[t._v("Order")]),t._v(" order "),a("span",{pre:!0,attrs:{class:"token operator"}},[t._v("=")]),t._v(" http"),a("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v(".")]),a("span",{pre:!0,attrs:{class:"token function"}},[t._v("sync")]),a("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v("(")]),a("span",{pre:!0,attrs:{class:"token string"}},[t._v('"/orders/1"')]),a("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v(")")]),t._v("\n "),a("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v(".")]),a("span",{pre:!0,attrs:{class:"token function"}},[t._v("get")]),a("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v("(")]),a("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v(")")]),a("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v(".")]),a("span",{pre:!0,attrs:{class:"token function"}},[t._v("getBody")]),a("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v("(")]),a("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v(")")]),a("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v(".")]),a("span",{pre:!0,attrs:{class:"token function"}},[t._v("toBean")]),a("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v("(")]),a("span",{pre:!0,attrs:{class:"token class-name"}},[t._v("Order")]),a("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v(".")]),a("span",{pre:!0,attrs:{class:"token keyword"}},[t._v("class")]),a("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v(")")]),a("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v(";")]),t._v("\n \n"),a("span",{pre:!0,attrs:{class:"token comment"}},[t._v("// 自动转List")]),t._v("\n"),a("span",{pre:!0,attrs:{class:"token class-name"}},[t._v("List")]),a("span",{pre:!0,attrs:{class:"token generics"}},[a("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v("<")]),a("span",{pre:!0,attrs:{class:"token class-name"}},[t._v("Order")]),a("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v(">")])]),t._v(" orders "),a("span",{pre:!0,attrs:{class:"token operator"}},[t._v("=")]),t._v(" http"),a("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v(".")]),a("span",{pre:!0,attrs:{class:"token function"}},[t._v("sync")]),a("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v("(")]),a("span",{pre:!0,attrs:{class:"token string"}},[t._v('"/orders"')]),a("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v(")")]),t._v("\n "),a("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v(".")]),a("span",{pre:!0,attrs:{class:"token function"}},[t._v("get")]),a("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v("(")]),a("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v(")")]),a("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v(".")]),a("span",{pre:!0,attrs:{class:"token function"}},[t._v("getBody")]),a("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v("(")]),a("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v(")")]),a("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v(".")]),a("span",{pre:!0,attrs:{class:"token function"}},[t._v("toList")]),a("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v("(")]),a("span",{pre:!0,attrs:{class:"token class-name"}},[t._v("Order")]),a("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v(".")]),a("span",{pre:!0,attrs:{class:"token keyword"}},[t._v("class")]),a("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v(")")]),a("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v(";")]),t._v("\n")])]),t._v(" "),a("div",{staticClass:"line-numbers-wrapper"},[a("span",{staticClass:"line-number"},[t._v("1")]),a("br"),a("span",{staticClass:"line-number"},[t._v("2")]),a("br"),a("span",{staticClass:"line-number"},[t._v("3")]),a("br"),a("span",{staticClass:"line-number"},[t._v("4")]),a("br"),a("span",{staticClass:"line-number"},[t._v("5")]),a("br"),a("span",{staticClass:"line-number"},[t._v("6")]),a("br"),a("span",{staticClass:"line-number"},[t._v("7")]),a("br")])]),a("p",[t._v("示例，使用 cache 方法：")]),t._v(" "),a("div",{staticClass:"language-java line-numbers-mode"},[a("pre",{pre:!0,attrs:{class:"language-java"}},[a("code",[a("span",{pre:!0,attrs:{class:"token class-name"}},[t._v("Body")]),t._v(" body "),a("span",{pre:!0,attrs:{class:"token operator"}},[t._v("=")]),t._v(" http"),a("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v(".")]),a("span",{pre:!0,attrs:{class:"token function"}},[t._v("sync")]),a("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v("(")]),a("span",{pre:!0,attrs:{class:"token string"}},[t._v('"/orders"')]),a("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v(")")]),a("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v(".")]),a("span",{pre:!0,attrs:{class:"token function"}},[t._v("get")]),a("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v("(")]),a("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v(")")]),a("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v(".")]),a("span",{pre:!0,attrs:{class:"token function"}},[t._v("getBody")]),a("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v("(")]),a("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v(")")]),a("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v(".")]),a("span",{pre:!0,attrs:{class:"token function"}},[t._v("cache")]),a("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v("(")]),a("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v(")")]),a("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v(";")]),t._v("\n\n"),a("span",{pre:!0,attrs:{class:"token comment"}},[t._v("// 使用 cache 后，可以多次使用 toXXX() 方法")]),t._v("\n"),a("span",{pre:!0,attrs:{class:"token class-name"}},[t._v("System")]),a("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v(".")]),t._v("out"),a("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v(".")]),a("span",{pre:!0,attrs:{class:"token function"}},[t._v("println")]),a("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v("(")]),t._v("body"),a("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v(".")]),a("span",{pre:!0,attrs:{class:"token function"}},[t._v("toString")]),a("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v("(")]),a("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v(")")]),a("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v(")")]),a("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v(";")]),t._v("\n"),a("span",{pre:!0,attrs:{class:"token class-name"}},[t._v("System")]),a("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v(".")]),t._v("out"),a("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v(".")]),a("span",{pre:!0,attrs:{class:"token function"}},[t._v("println")]),a("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v("(")]),t._v("body"),a("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v(".")]),a("span",{pre:!0,attrs:{class:"token function"}},[t._v("toJsonArray")]),a("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v("(")]),a("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v(")")]),a("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v(")")]),a("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v(";")]),t._v("\n"),a("span",{pre:!0,attrs:{class:"token class-name"}},[t._v("System")]),a("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v(".")]),t._v("out"),a("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v(".")]),a("span",{pre:!0,attrs:{class:"token function"}},[t._v("println")]),a("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v("(")]),t._v("body"),a("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v(".")]),a("span",{pre:!0,attrs:{class:"token function"}},[t._v("toList")]),a("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v("(")]),a("span",{pre:!0,attrs:{class:"token class-name"}},[t._v("Order")]),a("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v(".")]),a("span",{pre:!0,attrs:{class:"token keyword"}},[t._v("class")]),a("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v(")")]),a("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v(")")]),a("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v(";")]),t._v("\n")])]),t._v(" "),a("div",{staticClass:"line-numbers-wrapper"},[a("span",{staticClass:"line-number"},[t._v("1")]),a("br"),a("span",{staticClass:"line-number"},[t._v("2")]),a("br"),a("span",{staticClass:"line-number"},[t._v("3")]),a("br"),a("span",{staticClass:"line-number"},[t._v("4")]),a("br"),a("span",{staticClass:"line-number"},[t._v("5")]),a("br"),a("span",{staticClass:"line-number"},[t._v("6")]),a("br")])]),a("p",[t._v("示例，获取下载文件的大小：")]),t._v(" "),a("div",{staticClass:"language-java line-numbers-mode"},[a("pre",{pre:!0,attrs:{class:"language-java"}},[a("code",[a("span",{pre:!0,attrs:{class:"token keyword"}},[t._v("long")]),t._v(" size "),a("span",{pre:!0,attrs:{class:"token operator"}},[t._v("=")]),t._v(" http"),a("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v(".")]),a("span",{pre:!0,attrs:{class:"token function"}},[t._v("sync")]),a("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v("(")]),a("span",{pre:!0,attrs:{class:"token string"}},[t._v('"/download/test.zip"')]),a("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v(")")]),t._v("\n "),a("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v(".")]),a("span",{pre:!0,attrs:{class:"token function"}},[t._v("get")]),a("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v("(")]),a("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v(")")]),a("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v(".")]),a("span",{pre:!0,attrs:{class:"token function"}},[t._v("getBody")]),a("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v("(")]),a("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v(")")]),t._v("\n "),a("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v(".")]),a("span",{pre:!0,attrs:{class:"token function"}},[t._v("close")]),a("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v("(")]),a("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v(")")]),t._v(" "),a("span",{pre:!0,attrs:{class:"token comment"}},[t._v("// 只是想获得文件大小，不消费报文体，所以直接关闭")]),t._v("\n "),a("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v(".")]),a("span",{pre:!0,attrs:{class:"token function"}},[t._v("getContentLength")]),a("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v("(")]),a("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v(")")]),a("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v(";")]),t._v(" "),a("span",{pre:!0,attrs:{class:"token comment"}},[t._v("// 获得待下载文件的大小")]),t._v("\n\n"),a("span",{pre:!0,attrs:{class:"token comment"}},[t._v("// 由于未消费报文体，所以本次请求不会消耗下载报文体的时间和网络流量")]),t._v("\n\n"),a("span",{pre:!0,attrs:{class:"token class-name"}},[t._v("System")]),a("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v(".")]),t._v("out"),a("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v(".")]),a("span",{pre:!0,attrs:{class:"token function"}},[t._v("println")]),a("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v("(")]),a("span",{pre:!0,attrs:{class:"token string"}},[t._v('"size = "')]),t._v(" "),a("span",{pre:!0,attrs:{class:"token operator"}},[t._v("+")]),t._v(" size"),a("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v(")")]),a("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v(";")]),t._v("\n")])]),t._v(" "),a("div",{staticClass:"line-numbers-wrapper"},[a("span",{staticClass:"line-number"},[t._v("1")]),a("br"),a("span",{staticClass:"line-number"},[t._v("2")]),a("br"),a("span",{staticClass:"line-number"},[t._v("3")]),a("br"),a("span",{staticClass:"line-number"},[t._v("4")]),a("br"),a("span",{staticClass:"line-number"},[t._v("5")]),a("br"),a("span",{staticClass:"line-number"},[t._v("6")]),a("br"),a("span",{staticClass:"line-number"},[t._v("7")]),a("br"),a("span",{staticClass:"line-number"},[t._v("8")]),a("br")])]),a("h2",{attrs:{id:"httpcall"}},[a("a",{staticClass:"header-anchor",attrs:{href:"#httpcall"}},[t._v("#")]),t._v(" HttpCall")]),t._v(" "),a("p",[a("code",[t._v("HttpCall")]),t._v("对象是异步请求方法（"),a("code",[t._v("get")]),t._v("、"),a("code",[t._v("post")]),t._v("、"),a("code",[t._v("put")]),t._v("、"),a("code",[t._v("delete")]),t._v("）的返回值，与"),a("code",[t._v("java")]),t._v("的"),a("code",[t._v("Future")]),t._v("接口很像，它有如下方法：")]),t._v(" "),a("ul",[a("li",[a("code",[t._v("cancel()")]),t._v(" 取消本次请求，返回取消结果")]),t._v(" "),a("li",[a("code",[t._v("isCanceled()")]),t._v(" 返回请求是否被取消")]),t._v(" "),a("li",[a("code",[t._v("isDone()")]),t._v(" 返回是否执行完成，包含取消和失败")]),t._v(" "),a("li",[a("code",[t._v("getResult()")]),t._v(" 返回执行结果"),a("code",[t._v("HttpResult")]),t._v("对象，若请求未执行完，则挂起当前线程直到执行完成再返回")])]),t._v(" "),a("p",[t._v("取消一个异步请求示例：")]),t._v(" "),a("div",{staticClass:"language-java line-numbers-mode"},[a("pre",{pre:!0,attrs:{class:"language-java"}},[a("code",[a("span",{pre:!0,attrs:{class:"token class-name"}},[t._v("HttpCall")]),t._v(" call "),a("span",{pre:!0,attrs:{class:"token operator"}},[t._v("=")]),t._v(" http"),a("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v(".")]),a("span",{pre:!0,attrs:{class:"token function"}},[t._v("async")]),a("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v("(")]),a("span",{pre:!0,attrs:{class:"token string"}},[t._v('"/users/1"')]),a("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v(")")]),a("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v(".")]),a("span",{pre:!0,attrs:{class:"token function"}},[t._v("get")]),a("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v("(")]),a("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v(")")]),a("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v(";")]),t._v("\n\n"),a("span",{pre:!0,attrs:{class:"token class-name"}},[t._v("System")]),a("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v(".")]),t._v("out"),a("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v(".")]),a("span",{pre:!0,attrs:{class:"token function"}},[t._v("println")]),a("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v("(")]),t._v("call"),a("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v(".")]),a("span",{pre:!0,attrs:{class:"token function"}},[t._v("isCanceled")]),a("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v("(")]),a("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v(")")]),a("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v(")")]),a("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v(";")]),t._v(" "),a("span",{pre:!0,attrs:{class:"token comment"}},[t._v("// false")]),t._v("\n\n"),a("span",{pre:!0,attrs:{class:"token keyword"}},[t._v("boolean")]),t._v(" success "),a("span",{pre:!0,attrs:{class:"token operator"}},[t._v("=")]),t._v(" call"),a("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v(".")]),a("span",{pre:!0,attrs:{class:"token function"}},[t._v("cancel")]),a("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v("(")]),a("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v(")")]),a("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v(";")]),t._v(" "),a("span",{pre:!0,attrs:{class:"token comment"}},[t._v("// 取消请求")]),t._v("\n\n"),a("span",{pre:!0,attrs:{class:"token class-name"}},[t._v("System")]),a("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v(".")]),t._v("out"),a("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v(".")]),a("span",{pre:!0,attrs:{class:"token function"}},[t._v("println")]),a("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v("(")]),t._v("success"),a("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v(")")]),a("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v(";")]),t._v(" "),a("span",{pre:!0,attrs:{class:"token comment"}},[t._v("// true")]),t._v("\n"),a("span",{pre:!0,attrs:{class:"token class-name"}},[t._v("System")]),a("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v(".")]),t._v("out"),a("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v(".")]),a("span",{pre:!0,attrs:{class:"token function"}},[t._v("println")]),a("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v("(")]),t._v("call"),a("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v(".")]),a("span",{pre:!0,attrs:{class:"token function"}},[t._v("isCanceled")]),a("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v("(")]),a("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v(")")]),a("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v(")")]),a("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v(";")]),t._v(" "),a("span",{pre:!0,attrs:{class:"token comment"}},[t._v("// true")]),t._v("\n")])]),t._v(" "),a("div",{staticClass:"line-numbers-wrapper"},[a("span",{staticClass:"line-number"},[t._v("1")]),a("br"),a("span",{staticClass:"line-number"},[t._v("2")]),a("br"),a("span",{staticClass:"line-number"},[t._v("3")]),a("br"),a("span",{staticClass:"line-number"},[t._v("4")]),a("br"),a("span",{staticClass:"line-number"},[t._v("5")]),a("br"),a("span",{staticClass:"line-number"},[t._v("6")]),a("br"),a("span",{staticClass:"line-number"},[t._v("7")]),a("br"),a("span",{staticClass:"line-number"},[t._v("8")]),a("br")])]),a("h2",{attrs:{id:"构建http任务"}},[a("a",{staticClass:"header-anchor",attrs:{href:"#构建http任务"}},[t._v("#")]),t._v(" 构建HTTP任务")]),t._v(" "),a("p",[a("code",[t._v("HTTP")]),t._v("对象的"),a("code",[t._v("sync")]),t._v("与"),a("code",[t._v("async")]),t._v("方法返回一个"),a("code",[t._v("HttpTask")]),t._v("对象，该对象提供了可链式调用的"),a("code",[t._v("addXXX")]),t._v("与"),a("code",[t._v("setXXX")]),t._v("等系列方法用于构建任务本身。")]),t._v(" "),a("ul",[a("li",[a("p",[a("code",[t._v("addHeader(String name, String value)")]),t._v(" 添加请求头")])]),t._v(" "),a("li",[a("p",[a("code",[t._v("addHeader(Map headers)")]),t._v(" 添加请求头")])]),t._v(" "),a("li",[a("p",[a("code",[t._v("addPathParam(String name, Object value)")]),t._v(" 添加路径参数：替换URL里的{name}占位符")])]),t._v(" "),a("li",[a("p",[a("code",[t._v("addPathParam(Map params)")]),t._v(" 添加路径参数：替换URL里的{name}占位符")])]),t._v(" "),a("li",[a("p",[a("code",[t._v("addUrlParam(String name, Object value)")]),t._v(" 添加URL参数：拼接在URL的?之后（查询参数）")])]),t._v(" "),a("li",[a("p",[a("code",[t._v("addUrlParam(Map params)")]),t._v(" 添加URL参数：拼接在URL的?之后（查询参数）")])]),t._v(" "),a("li",[a("p",[a("code",[t._v("addBodyParam(String name, Object value)")]),t._v(" 添加Body参数：以表单key=value&的形式放在报文体内（表单参数）")])]),t._v(" "),a("li",[a("p",[a("code",[t._v("addBodyParam(Map params)")]),t._v(" 添加Body参数：以表单key=value&的形式放在报文体内（表单参数）")])]),t._v(" "),a("li",[a("p",[a("code",[t._v("addJsonParam(String name, Object value)")]),t._v(" 添加Json参数：请求体为Json（支持多层结构）")])]),t._v(" "),a("li",[a("p",[a("code",[t._v("addJsonParam(Map params)")]),t._v(" 添加Json参数：请求体为Json（支持多层结构）")])]),t._v(" "),a("li",[a("p",[a("code",[t._v("setRequestJson(Object json)")]),t._v(" 设置请求体的Json字符串 或待转换为 Json的 JavaBean")])]),t._v(" "),a("li",[a("p",[a("code",[t._v("setRequestJson(Object bean, String dateFormat)")]),t._v(" 设置请求体的Json字符串 或待转换为 Json的 JavaBean")])]),t._v(" "),a("li",[a("p",[a("code",[t._v("addFileParam(String name, String filePath)")]),t._v(" 上传文件")])]),t._v(" "),a("li",[a("p",[a("code",[t._v("addFileParam(String name, File file)")]),t._v(" 上传文件")])]),t._v(" "),a("li",[a("p",[a("code",[t._v("addFileParam(String name, String type, InputStream inputStream)")]),t._v(" 上传文件")])]),t._v(" "),a("li",[a("p",[a("code",[t._v("addFileParam(String name, String type, String fileName, InputStream input)")]),t._v(" 上传文件")])]),t._v(" "),a("li",[a("p",[a("code",[t._v("addFileParam(String name, String type, byte[] content)")]),t._v(" 上传文件")])]),t._v(" "),a("li",[a("p",[a("code",[t._v("addFileParam(String name, String type, String fileName, byte[] content)")]),t._v(" 上传文件")])]),t._v(" "),a("li",[a("p",[a("code",[t._v("setTag(String tag)")]),t._v(" 为HTTP任务添加标签")])]),t._v(" "),a("li",[a("p",[a("code",[t._v("setRange(long rangeStart)")]),t._v(" 设置Range头信息，用于"),a("RouterLink",{attrs:{to:"/guide/updown.html#实现断点续传"}},[t._v("断点续传")])],1)]),t._v(" "),a("li",[a("p",[a("code",[t._v("setRange(long rangeStart, long rangeEnd)")]),t._v(" 设置Range头信息，可用于"),a("RouterLink",{attrs:{to:"/guide/updown.html#实现分块下载"}},[t._v("分块下载")])],1)]),t._v(" "),a("li",[a("p",[a("code",[t._v("bind(Object object)")]),t._v(" 绑定一个对象，可用于实现Android里的"),a("RouterLink",{attrs:{to:"/guide/android.html#生命周期绑定"}},[t._v("生命周期绑定")])],1)])]),t._v(" "),a("h2",{attrs:{id:"使用标签"}},[a("a",{staticClass:"header-anchor",attrs:{href:"#使用标签"}},[t._v("#")]),t._v(" 使用标签")]),t._v(" "),a("p",[t._v("有时候我们想对HTTP任务加以分类，这时候可以使用标签功能：")]),t._v(" "),a("div",{staticClass:"language-java line-numbers-mode"},[a("pre",{pre:!0,attrs:{class:"language-java"}},[a("code",[t._v("http"),a("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v(".")]),a("span",{pre:!0,attrs:{class:"token function"}},[t._v("async")]),a("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v("(")]),a("span",{pre:!0,attrs:{class:"token string"}},[t._v('"/users"')]),a("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v(")")]),t._v(" "),a("span",{pre:!0,attrs:{class:"token comment"}},[t._v("//（1）")]),t._v("\n "),a("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v(".")]),a("span",{pre:!0,attrs:{class:"token function"}},[t._v("setTag")]),a("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v("(")]),a("span",{pre:!0,attrs:{class:"token string"}},[t._v('"A"')]),a("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v(")")]),t._v("\n "),a("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v(".")]),a("span",{pre:!0,attrs:{class:"token function"}},[t._v("get")]),a("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v("(")]),a("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v(")")]),a("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v(";")]),t._v("\n \nhttp"),a("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v(".")]),a("span",{pre:!0,attrs:{class:"token function"}},[t._v("async")]),a("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v("(")]),a("span",{pre:!0,attrs:{class:"token string"}},[t._v('"/users"')]),a("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v(")")]),t._v(" "),a("span",{pre:!0,attrs:{class:"token comment"}},[t._v("//（2）")]),t._v("\n "),a("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v(".")]),a("span",{pre:!0,attrs:{class:"token function"}},[t._v("setTag")]),a("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v("(")]),a("span",{pre:!0,attrs:{class:"token string"}},[t._v('"A.B"')]),a("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v(")")]),t._v("\n "),a("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v(".")]),a("span",{pre:!0,attrs:{class:"token function"}},[t._v("get")]),a("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v("(")]),a("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v(")")]),a("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v(";")]),t._v("\n \nhttp"),a("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v(".")]),a("span",{pre:!0,attrs:{class:"token function"}},[t._v("async")]),a("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v("(")]),a("span",{pre:!0,attrs:{class:"token string"}},[t._v('"/users"')]),a("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v(")")]),t._v(" "),a("span",{pre:!0,attrs:{class:"token comment"}},[t._v("//（3）")]),t._v("\n "),a("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v(".")]),a("span",{pre:!0,attrs:{class:"token function"}},[t._v("setTag")]),a("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v("(")]),a("span",{pre:!0,attrs:{class:"token string"}},[t._v('"B"')]),a("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v(")")]),t._v("\n "),a("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v(".")]),a("span",{pre:!0,attrs:{class:"token function"}},[t._v("get")]),a("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v("(")]),a("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v(")")]),a("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v(";")]),t._v("\n \nhttp"),a("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v(".")]),a("span",{pre:!0,attrs:{class:"token function"}},[t._v("async")]),a("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v("(")]),a("span",{pre:!0,attrs:{class:"token string"}},[t._v('"/users"')]),a("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v(")")]),t._v(" "),a("span",{pre:!0,attrs:{class:"token comment"}},[t._v("//（4）")]),t._v("\n "),a("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v(".")]),a("span",{pre:!0,attrs:{class:"token function"}},[t._v("setTag")]),a("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v("(")]),a("span",{pre:!0,attrs:{class:"token string"}},[t._v('"B"')]),a("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v(")")]),t._v("\n "),a("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v(".")]),a("span",{pre:!0,attrs:{class:"token function"}},[t._v("setTag")]),a("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v("(")]),a("span",{pre:!0,attrs:{class:"token string"}},[t._v('"C"')]),a("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v(")")]),t._v(" "),a("span",{pre:!0,attrs:{class:"token comment"}},[t._v('// 从 v1.0.4 标签将以追加模式添加，等效于 setTag("B.C")')]),t._v("\n "),a("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v(".")]),a("span",{pre:!0,attrs:{class:"token function"}},[t._v("get")]),a("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v("(")]),a("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v(")")]),a("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v(";")]),t._v("\n \nhttp"),a("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v(".")]),a("span",{pre:!0,attrs:{class:"token function"}},[t._v("async")]),a("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v("(")]),a("span",{pre:!0,attrs:{class:"token string"}},[t._v('"/users"')]),a("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v(")")]),t._v(" "),a("span",{pre:!0,attrs:{class:"token comment"}},[t._v("//（5）")]),t._v("\n "),a("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v(".")]),a("span",{pre:!0,attrs:{class:"token function"}},[t._v("setTag")]),a("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v("(")]),a("span",{pre:!0,attrs:{class:"token string"}},[t._v('"C"')]),a("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v(")")]),t._v("\n "),a("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v(".")]),a("span",{pre:!0,attrs:{class:"token function"}},[t._v("get")]),a("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v("(")]),a("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v(")")]),a("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v(";")]),t._v("\n")])]),t._v(" "),a("div",{staticClass:"line-numbers-wrapper"},[a("span",{staticClass:"line-number"},[t._v("1")]),a("br"),a("span",{staticClass:"line-number"},[t._v("2")]),a("br"),a("span",{staticClass:"line-number"},[t._v("3")]),a("br"),a("span",{staticClass:"line-number"},[t._v("4")]),a("br"),a("span",{staticClass:"line-number"},[t._v("5")]),a("br"),a("span",{staticClass:"line-number"},[t._v("6")]),a("br"),a("span",{staticClass:"line-number"},[t._v("7")]),a("br"),a("span",{staticClass:"line-number"},[t._v("8")]),a("br"),a("span",{staticClass:"line-number"},[t._v("9")]),a("br"),a("span",{staticClass:"line-number"},[t._v("10")]),a("br"),a("span",{staticClass:"line-number"},[t._v("11")]),a("br"),a("span",{staticClass:"line-number"},[t._v("12")]),a("br"),a("span",{staticClass:"line-number"},[t._v("13")]),a("br"),a("span",{staticClass:"line-number"},[t._v("14")]),a("br"),a("span",{staticClass:"line-number"},[t._v("15")]),a("br"),a("span",{staticClass:"line-number"},[t._v("16")]),a("br"),a("span",{staticClass:"line-number"},[t._v("17")]),a("br"),a("span",{staticClass:"line-number"},[t._v("18")]),a("br"),a("span",{staticClass:"line-number"},[t._v("19")]),a("br"),a("span",{staticClass:"line-number"},[t._v("20")]),a("br")])]),a("p",[t._v("当使用标签后，就可以按标签批量的对HTTP任务进行取消：")]),t._v(" "),a("div",{staticClass:"language-java line-numbers-mode"},[a("pre",{pre:!0,attrs:{class:"language-java"}},[a("code",[a("span",{pre:!0,attrs:{class:"token keyword"}},[t._v("int")]),t._v(" count "),a("span",{pre:!0,attrs:{class:"token operator"}},[t._v("=")]),t._v(" http"),a("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v(".")]),a("span",{pre:!0,attrs:{class:"token function"}},[t._v("cancel")]),a("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v("(")]),a("span",{pre:!0,attrs:{class:"token string"}},[t._v('"B"')]),a("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v(")")]),a("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v(";")]),t._v(" "),a("span",{pre:!0,attrs:{class:"token comment"}},[t._v('//（2）（3）（4）被取消（取消标签包含"B"的任务）')]),t._v("\n"),a("span",{pre:!0,attrs:{class:"token class-name"}},[t._v("System")]),a("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v(".")]),t._v("out"),a("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v(".")]),a("span",{pre:!0,attrs:{class:"token function"}},[t._v("println")]),a("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v("(")]),t._v("count"),a("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v(")")]),a("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v(";")]),t._v(" "),a("span",{pre:!0,attrs:{class:"token comment"}},[t._v("// 输出 3")]),t._v("\n")])]),t._v(" "),a("div",{staticClass:"line-numbers-wrapper"},[a("span",{staticClass:"line-number"},[t._v("1")]),a("br"),a("span",{staticClass:"line-number"},[t._v("2")]),a("br")])]),a("p",[t._v("标签除了可以用来取消任务，在预处理器中它也可以发挥作用，请参见 "),a("RouterLink",{attrs:{to:"/guide/configuration.html#并行预处理器"}},[t._v("并行预处理器")]),t._v(" 与 "),a("RouterLink",{attrs:{to:"/guide/configuration.html#串行预处理器（token问题最佳解决方案）"}},[t._v("串行预处理器（token问题最佳解决方案）")]),t._v("。")],1)])}),[],!1,null,null,null);s.default=e.exports}}]); \ No newline at end of file diff --git a/okhttps-doc/docs/.vuepress/dist/assets/js/12.92e24a16.js b/okhttps-doc/docs/.vuepress/dist/assets/js/12.92e24a16.js deleted file mode 100644 index e954337f..00000000 --- a/okhttps-doc/docs/.vuepress/dist/assets/js/12.92e24a16.js +++ /dev/null @@ -1 +0,0 @@ -(window.webpackJsonp=window.webpackJsonp||[]).push([[12],{332:function(t,s,a){"use strict";a.r(s);var n=a(19),e=Object(n.a)({},(function(){var t=this,s=t.$createElement,a=t._self._c||s;return a("ContentSlotsDistributor",{attrs:{"slot-key":t.$parent.slotKey}},[a("h1",{attrs:{id:"上传下载"}},[a("a",{staticClass:"header-anchor",attrs:{href:"#上传下载"}},[t._v("#")]),t._v(" 上传下载")]),t._v(" "),a("h2",{attrs:{id:"文件下载"}},[a("a",{staticClass:"header-anchor",attrs:{href:"#文件下载"}},[t._v("#")]),t._v(" 文件下载")]),t._v(" "),a("p",[t._v("OkHttps 并没有把文件的下载排除在常规的请求之外，同一套API，它优雅的设计使得下载与常规请求融合的毫无违和感，一个最简单的示例：")]),t._v(" "),a("div",{staticClass:"language-java line-numbers-mode"},[a("pre",{pre:!0,attrs:{class:"language-java"}},[a("code",[t._v("http"),a("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v(".")]),a("span",{pre:!0,attrs:{class:"token function"}},[t._v("sync")]),a("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v("(")]),a("span",{pre:!0,attrs:{class:"token string"}},[t._v('"/download/test.zip"')]),a("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v(")")]),t._v("\n "),a("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v(".")]),a("span",{pre:!0,attrs:{class:"token function"}},[t._v("get")]),a("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v("(")]),a("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v(")")]),t._v(" "),a("span",{pre:!0,attrs:{class:"token comment"}},[t._v("// 使用 GET 方法（其它方法也可以，看服务器支持）")]),t._v("\n "),a("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v(".")]),a("span",{pre:!0,attrs:{class:"token function"}},[t._v("getBody")]),a("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v("(")]),a("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v(")")]),t._v(" "),a("span",{pre:!0,attrs:{class:"token comment"}},[t._v("// 得到报文体")]),t._v("\n "),a("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v(".")]),a("span",{pre:!0,attrs:{class:"token function"}},[t._v("toFile")]),a("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v("(")]),a("span",{pre:!0,attrs:{class:"token string"}},[t._v('"D:/download/test.zip"')]),a("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v(")")]),t._v(" "),a("span",{pre:!0,attrs:{class:"token comment"}},[t._v("// 下载到指定的路径")]),t._v("\n "),a("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v(".")]),a("span",{pre:!0,attrs:{class:"token function"}},[t._v("start")]),a("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v("(")]),a("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v(")")]),a("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v(";")]),t._v(" "),a("span",{pre:!0,attrs:{class:"token comment"}},[t._v("// 启动下载")]),t._v("\n\nhttp"),a("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v(".")]),a("span",{pre:!0,attrs:{class:"token function"}},[t._v("sync")]),a("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v("(")]),a("span",{pre:!0,attrs:{class:"token string"}},[t._v('"/download/test.zip"')]),a("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v(")")]),a("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v(".")]),a("span",{pre:!0,attrs:{class:"token function"}},[t._v("get")]),a("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v("(")]),a("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v(")")]),a("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v(".")]),a("span",{pre:!0,attrs:{class:"token function"}},[t._v("getBody")]),a("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v("(")]),a("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v(")")]),t._v(" \n "),a("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v(".")]),a("span",{pre:!0,attrs:{class:"token function"}},[t._v("toFolder")]),a("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v("(")]),a("span",{pre:!0,attrs:{class:"token string"}},[t._v('"D:/download"')]),a("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v(")")]),t._v(" "),a("span",{pre:!0,attrs:{class:"token comment"}},[t._v("// 下载到指定的目录，文件名将根据下载信息自动生成")]),t._v("\n "),a("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v(".")]),a("span",{pre:!0,attrs:{class:"token function"}},[t._v("start")]),a("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v("(")]),a("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v(")")]),a("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v(";")]),t._v("\n")])]),t._v(" "),a("div",{staticClass:"line-numbers-wrapper"},[a("span",{staticClass:"line-number"},[t._v("1")]),a("br"),a("span",{staticClass:"line-number"},[t._v("2")]),a("br"),a("span",{staticClass:"line-number"},[t._v("3")]),a("br"),a("span",{staticClass:"line-number"},[t._v("4")]),a("br"),a("span",{staticClass:"line-number"},[t._v("5")]),a("br"),a("span",{staticClass:"line-number"},[t._v("6")]),a("br"),a("span",{staticClass:"line-number"},[t._v("7")]),a("br"),a("span",{staticClass:"line-number"},[t._v("8")]),a("br"),a("span",{staticClass:"line-number"},[t._v("9")]),a("br")])]),a("p",[t._v("或使用异步连接方式：")]),t._v(" "),a("div",{staticClass:"language-java line-numbers-mode"},[a("pre",{pre:!0,attrs:{class:"language-java"}},[a("code",[t._v("http"),a("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v(".")]),a("span",{pre:!0,attrs:{class:"token function"}},[t._v("async")]),a("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v("(")]),a("span",{pre:!0,attrs:{class:"token string"}},[t._v('"/download/test.zip"')]),a("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v(")")]),t._v("\n "),a("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v(".")]),a("span",{pre:!0,attrs:{class:"token function"}},[t._v("setOnResponse")]),a("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v("(")]),a("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v("(")]),a("span",{pre:!0,attrs:{class:"token class-name"}},[t._v("HttpResult")]),t._v(" result"),a("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v(")")]),t._v(" "),a("span",{pre:!0,attrs:{class:"token operator"}},[t._v("->")]),t._v(" "),a("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v("{")]),t._v("\n result"),a("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v(".")]),a("span",{pre:!0,attrs:{class:"token function"}},[t._v("getBody")]),a("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v("(")]),a("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v(")")]),a("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v(".")]),a("span",{pre:!0,attrs:{class:"token function"}},[t._v("toFolder")]),a("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v("(")]),a("span",{pre:!0,attrs:{class:"token string"}},[t._v('"D:/download"')]),a("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v(")")]),a("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v(".")]),a("span",{pre:!0,attrs:{class:"token function"}},[t._v("start")]),a("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v("(")]),a("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v(")")]),a("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v(";")]),t._v("\n "),a("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v("}")]),a("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v(")")]),t._v("\n "),a("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v(".")]),a("span",{pre:!0,attrs:{class:"token function"}},[t._v("get")]),a("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v("(")]),a("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v(")")]),a("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v(";")]),t._v("\n")])]),t._v(" "),a("div",{staticClass:"line-numbers-wrapper"},[a("span",{staticClass:"line-number"},[t._v("1")]),a("br"),a("span",{staticClass:"line-number"},[t._v("2")]),a("br"),a("span",{staticClass:"line-number"},[t._v("3")]),a("br"),a("span",{staticClass:"line-number"},[t._v("4")]),a("br"),a("span",{staticClass:"line-number"},[t._v("5")]),a("br")])]),a("p",[t._v("这里要说明一下："),a("code",[t._v("sync")]),t._v("与"),a("code",[t._v("async")]),t._v("的区别在于连接服务器并得到响应这个过程的同步与异步（这个过程的耗时在大文件下载中占比极小），而"),a("code",[t._v("start")]),t._v("方法启动的下载过程则都是异步的。")]),t._v(" "),a("h3",{attrs:{id:"下载进度监听"}},[a("a",{staticClass:"header-anchor",attrs:{href:"#下载进度监听"}},[t._v("#")]),t._v(" 下载进度监听")]),t._v(" "),a("p",[t._v("就直接上代码啦，诸君一看便懂：")]),t._v(" "),a("div",{staticClass:"language-java line-numbers-mode"},[a("pre",{pre:!0,attrs:{class:"language-java"}},[a("code",[t._v("http"),a("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v(".")]),a("span",{pre:!0,attrs:{class:"token function"}},[t._v("sync")]),a("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v("(")]),a("span",{pre:!0,attrs:{class:"token string"}},[t._v('"/download/test.zip"')]),a("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v(")")]),t._v("\n "),a("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v(".")]),a("span",{pre:!0,attrs:{class:"token function"}},[t._v("get")]),a("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v("(")]),a("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v(")")]),t._v("\n "),a("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v(".")]),a("span",{pre:!0,attrs:{class:"token function"}},[t._v("getBody")]),a("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v("(")]),a("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v(")")]),t._v("\n "),a("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v(".")]),a("span",{pre:!0,attrs:{class:"token function"}},[t._v("setStepBytes")]),a("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v("(")]),a("span",{pre:!0,attrs:{class:"token number"}},[t._v("1024")]),a("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v(")")]),t._v(" "),a("span",{pre:!0,attrs:{class:"token comment"}},[t._v("// 设置每接收 1024 个字节执行一次进度回调（不设置默认为 8192） ")]),t._v("\n "),a("span",{pre:!0,attrs:{class:"token comment"}},[t._v("// .setStepRate(0.01) // 设置每接收 1% 执行一次进度回调（不设置以 StepBytes 为准） ")]),t._v("\n "),a("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v(".")]),a("span",{pre:!0,attrs:{class:"token function"}},[t._v("setOnProcess")]),a("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v("(")]),a("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v("(")]),a("span",{pre:!0,attrs:{class:"token class-name"}},[t._v("Process")]),t._v(" process"),a("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v(")")]),t._v(" "),a("span",{pre:!0,attrs:{class:"token operator"}},[t._v("->")]),t._v(" "),a("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v("{")]),t._v(" "),a("span",{pre:!0,attrs:{class:"token comment"}},[t._v("// 下载进度回调")]),t._v("\n "),a("span",{pre:!0,attrs:{class:"token keyword"}},[t._v("long")]),t._v(" doneBytes "),a("span",{pre:!0,attrs:{class:"token operator"}},[t._v("=")]),t._v(" process"),a("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v(".")]),a("span",{pre:!0,attrs:{class:"token function"}},[t._v("getDoneBytes")]),a("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v("(")]),a("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v(")")]),a("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v(";")]),t._v(" "),a("span",{pre:!0,attrs:{class:"token comment"}},[t._v("// 已下载字节数")]),t._v("\n "),a("span",{pre:!0,attrs:{class:"token keyword"}},[t._v("long")]),t._v(" totalBytes "),a("span",{pre:!0,attrs:{class:"token operator"}},[t._v("=")]),t._v(" process"),a("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v(".")]),a("span",{pre:!0,attrs:{class:"token function"}},[t._v("getTotalBytes")]),a("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v("(")]),a("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v(")")]),a("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v(";")]),t._v(" "),a("span",{pre:!0,attrs:{class:"token comment"}},[t._v("// 总共的字节数")]),t._v("\n "),a("span",{pre:!0,attrs:{class:"token keyword"}},[t._v("double")]),t._v(" rate "),a("span",{pre:!0,attrs:{class:"token operator"}},[t._v("=")]),t._v(" process"),a("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v(".")]),a("span",{pre:!0,attrs:{class:"token function"}},[t._v("getRate")]),a("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v("(")]),a("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v(")")]),a("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v(";")]),t._v(" "),a("span",{pre:!0,attrs:{class:"token comment"}},[t._v("// 已下载的比例")]),t._v("\n "),a("span",{pre:!0,attrs:{class:"token keyword"}},[t._v("boolean")]),t._v(" isDone "),a("span",{pre:!0,attrs:{class:"token operator"}},[t._v("=")]),t._v(" process"),a("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v(".")]),a("span",{pre:!0,attrs:{class:"token function"}},[t._v("isDone")]),a("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v("(")]),a("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v(")")]),a("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v(";")]),t._v(" "),a("span",{pre:!0,attrs:{class:"token comment"}},[t._v("// 是否下载完成")]),t._v("\n "),a("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v("}")]),a("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v(")")]),t._v("\n "),a("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v(".")]),a("span",{pre:!0,attrs:{class:"token function"}},[t._v("toFolder")]),a("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v("(")]),a("span",{pre:!0,attrs:{class:"token string"}},[t._v('"D:/download/"')]),a("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v(")")]),t._v(" "),a("span",{pre:!0,attrs:{class:"token comment"}},[t._v("// 指定下载的目录，文件名将根据下载信息自动生成")]),t._v("\n "),a("span",{pre:!0,attrs:{class:"token comment"}},[t._v('// .toFile("D:/download/test.zip") // 指定下载的路径，若文件已存在则覆盖')]),t._v("\n "),a("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v(".")]),a("span",{pre:!0,attrs:{class:"token function"}},[t._v("setOnSuccess")]),a("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v("(")]),a("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v("(")]),a("span",{pre:!0,attrs:{class:"token class-name"}},[t._v("File")]),t._v(" file"),a("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v(")")]),t._v(" "),a("span",{pre:!0,attrs:{class:"token operator"}},[t._v("->")]),t._v(" "),a("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v("{")]),t._v(" "),a("span",{pre:!0,attrs:{class:"token comment"}},[t._v("// 下载成功回调")]),t._v("\n \n "),a("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v("}")]),a("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v(")")]),t._v("\n "),a("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v(".")]),a("span",{pre:!0,attrs:{class:"token function"}},[t._v("start")]),a("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v("(")]),a("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v(")")]),a("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v(";")]),t._v("\n")])]),t._v(" "),a("div",{staticClass:"line-numbers-wrapper"},[a("span",{staticClass:"line-number"},[t._v("1")]),a("br"),a("span",{staticClass:"line-number"},[t._v("2")]),a("br"),a("span",{staticClass:"line-number"},[t._v("3")]),a("br"),a("span",{staticClass:"line-number"},[t._v("4")]),a("br"),a("span",{staticClass:"line-number"},[t._v("5")]),a("br"),a("span",{staticClass:"line-number"},[t._v("6")]),a("br"),a("span",{staticClass:"line-number"},[t._v("7")]),a("br"),a("span",{staticClass:"line-number"},[t._v("8")]),a("br"),a("span",{staticClass:"line-number"},[t._v("9")]),a("br"),a("span",{staticClass:"line-number"},[t._v("10")]),a("br"),a("span",{staticClass:"line-number"},[t._v("11")]),a("br"),a("span",{staticClass:"line-number"},[t._v("12")]),a("br"),a("span",{staticClass:"line-number"},[t._v("13")]),a("br"),a("span",{staticClass:"line-number"},[t._v("14")]),a("br"),a("span",{staticClass:"line-number"},[t._v("15")]),a("br"),a("span",{staticClass:"line-number"},[t._v("16")]),a("br"),a("span",{staticClass:"line-number"},[t._v("17")]),a("br")])]),a("p",[t._v("值得一提的是：由于 OkHttps 并没有把下载做的很特别，这里设置的进度回调不只对下载文件起用作，即使对响应JSON的常规请求，只要设置了进度回调，它也会告诉你报文接收的进度（提前是服务器响应的报文有"),a("code",[t._v("Content-Length")]),t._v("头），例如：")]),t._v(" "),a("div",{staticClass:"language-java line-numbers-mode"},[a("pre",{pre:!0,attrs:{class:"language-java"}},[a("code",[a("span",{pre:!0,attrs:{class:"token class-name"}},[t._v("List")]),a("span",{pre:!0,attrs:{class:"token generics"}},[a("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v("<")]),a("span",{pre:!0,attrs:{class:"token class-name"}},[t._v("User")]),a("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v(">")])]),t._v(" users "),a("span",{pre:!0,attrs:{class:"token operator"}},[t._v("=")]),t._v(" http"),a("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v(".")]),a("span",{pre:!0,attrs:{class:"token function"}},[t._v("sync")]),a("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v("(")]),a("span",{pre:!0,attrs:{class:"token string"}},[t._v('"/users"')]),a("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v(")")]),t._v("\n "),a("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v(".")]),a("span",{pre:!0,attrs:{class:"token function"}},[t._v("get")]),a("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v("(")]),a("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v(")")]),t._v("\n "),a("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v(".")]),a("span",{pre:!0,attrs:{class:"token function"}},[t._v("getBody")]),a("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v("(")]),a("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v(")")]),t._v("\n "),a("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v(".")]),a("span",{pre:!0,attrs:{class:"token function"}},[t._v("setStepBytes")]),a("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v("(")]),a("span",{pre:!0,attrs:{class:"token number"}},[t._v("2")]),a("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v(")")]),t._v("\n "),a("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v(".")]),a("span",{pre:!0,attrs:{class:"token function"}},[t._v("setOnProcess")]),a("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v("(")]),a("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v("(")]),a("span",{pre:!0,attrs:{class:"token class-name"}},[t._v("Process")]),t._v(" process"),a("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v(")")]),t._v(" "),a("span",{pre:!0,attrs:{class:"token operator"}},[t._v("->")]),t._v(" "),a("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v("{")]),t._v("\n "),a("span",{pre:!0,attrs:{class:"token class-name"}},[t._v("System")]),a("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v(".")]),t._v("out"),a("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v(".")]),a("span",{pre:!0,attrs:{class:"token function"}},[t._v("println")]),a("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v("(")]),t._v("process"),a("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v(".")]),a("span",{pre:!0,attrs:{class:"token function"}},[t._v("getRate")]),a("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v("(")]),a("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v(")")]),a("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v(")")]),a("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v(";")]),t._v("\n "),a("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v("}")]),a("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v(")")]),t._v("\n "),a("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v(".")]),a("span",{pre:!0,attrs:{class:"token function"}},[t._v("toList")]),a("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v("(")]),a("span",{pre:!0,attrs:{class:"token class-name"}},[t._v("User")]),a("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v(".")]),a("span",{pre:!0,attrs:{class:"token keyword"}},[t._v("class")]),a("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v(")")]),a("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v(";")]),t._v("\n")])]),t._v(" "),a("div",{staticClass:"line-numbers-wrapper"},[a("span",{staticClass:"line-number"},[t._v("1")]),a("br"),a("span",{staticClass:"line-number"},[t._v("2")]),a("br"),a("span",{staticClass:"line-number"},[t._v("3")]),a("br"),a("span",{staticClass:"line-number"},[t._v("4")]),a("br"),a("span",{staticClass:"line-number"},[t._v("5")]),a("br"),a("span",{staticClass:"line-number"},[t._v("6")]),a("br"),a("span",{staticClass:"line-number"},[t._v("7")]),a("br"),a("span",{staticClass:"line-number"},[t._v("8")]),a("br")])]),a("h3",{attrs:{id:"下载过程控制"}},[a("a",{staticClass:"header-anchor",attrs:{href:"#下载过程控制"}},[t._v("#")]),t._v(" 下载过程控制")]),t._v(" "),a("p",[t._v("过于简单：还是直接上代码：")]),t._v(" "),a("div",{staticClass:"language-java line-numbers-mode"},[a("pre",{pre:!0,attrs:{class:"language-java"}},[a("code",[a("span",{pre:!0,attrs:{class:"token class-name"}},[t._v("Ctrl")]),t._v(" ctrl "),a("span",{pre:!0,attrs:{class:"token operator"}},[t._v("=")]),t._v(" http"),a("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v(".")]),a("span",{pre:!0,attrs:{class:"token function"}},[t._v("sync")]),a("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v("(")]),a("span",{pre:!0,attrs:{class:"token string"}},[t._v('"/download/test.zip"')]),a("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v(")")]),t._v("\n "),a("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v(".")]),a("span",{pre:!0,attrs:{class:"token function"}},[t._v("get")]),a("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v("(")]),a("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v(")")]),t._v("\n "),a("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v(".")]),a("span",{pre:!0,attrs:{class:"token function"}},[t._v("getBody")]),a("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v("(")]),a("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v(")")]),t._v("\n "),a("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v(".")]),a("span",{pre:!0,attrs:{class:"token function"}},[t._v("setOnProcess")]),a("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v("(")]),a("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v("(")]),a("span",{pre:!0,attrs:{class:"token class-name"}},[t._v("Process")]),t._v(" process"),a("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v(")")]),t._v(" "),a("span",{pre:!0,attrs:{class:"token operator"}},[t._v("->")]),t._v(" "),a("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v("{")]),t._v("\n "),a("span",{pre:!0,attrs:{class:"token class-name"}},[t._v("System")]),a("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v(".")]),t._v("out"),a("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v(".")]),a("span",{pre:!0,attrs:{class:"token function"}},[t._v("println")]),a("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v("(")]),t._v("process"),a("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v(".")]),a("span",{pre:!0,attrs:{class:"token function"}},[t._v("getRate")]),a("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v("(")]),a("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v(")")]),a("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v(")")]),a("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v(";")]),t._v("\n "),a("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v("}")]),a("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v(")")]),t._v("\n "),a("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v(".")]),a("span",{pre:!0,attrs:{class:"token function"}},[t._v("toFolder")]),a("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v("(")]),a("span",{pre:!0,attrs:{class:"token string"}},[t._v('"D:/download/"')]),a("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v(")")]),t._v("\n "),a("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v(".")]),a("span",{pre:!0,attrs:{class:"token function"}},[t._v("start")]),a("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v("(")]),a("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v(")")]),a("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v(";")]),t._v(" "),a("span",{pre:!0,attrs:{class:"token comment"}},[t._v("// 该方法返回一个下载过程控制器")]),t._v("\n \nctrl"),a("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v(".")]),a("span",{pre:!0,attrs:{class:"token function"}},[t._v("status")]),a("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v("(")]),a("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v(")")]),a("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v(";")]),t._v(" "),a("span",{pre:!0,attrs:{class:"token comment"}},[t._v("// 下载状态")]),t._v("\nctrl"),a("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v(".")]),a("span",{pre:!0,attrs:{class:"token function"}},[t._v("pause")]),a("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v("(")]),a("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v(")")]),a("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v(";")]),t._v(" "),a("span",{pre:!0,attrs:{class:"token comment"}},[t._v("// 暂停下载")]),t._v("\nctrl"),a("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v(".")]),a("span",{pre:!0,attrs:{class:"token function"}},[t._v("resume")]),a("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v("(")]),a("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v(")")]),a("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v(";")]),t._v(" "),a("span",{pre:!0,attrs:{class:"token comment"}},[t._v("// 恢复下载")]),t._v("\nctrl"),a("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v(".")]),a("span",{pre:!0,attrs:{class:"token function"}},[t._v("cancel")]),a("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v("(")]),a("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v(")")]),a("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v(";")]),t._v(" "),a("span",{pre:!0,attrs:{class:"token comment"}},[t._v("// 取消下载（同时会删除文件，不可恢复）")]),t._v("\n")])]),t._v(" "),a("div",{staticClass:"line-numbers-wrapper"},[a("span",{staticClass:"line-number"},[t._v("1")]),a("br"),a("span",{staticClass:"line-number"},[t._v("2")]),a("br"),a("span",{staticClass:"line-number"},[t._v("3")]),a("br"),a("span",{staticClass:"line-number"},[t._v("4")]),a("br"),a("span",{staticClass:"line-number"},[t._v("5")]),a("br"),a("span",{staticClass:"line-number"},[t._v("6")]),a("br"),a("span",{staticClass:"line-number"},[t._v("7")]),a("br"),a("span",{staticClass:"line-number"},[t._v("8")]),a("br"),a("span",{staticClass:"line-number"},[t._v("9")]),a("br"),a("span",{staticClass:"line-number"},[t._v("10")]),a("br"),a("span",{staticClass:"line-number"},[t._v("11")]),a("br"),a("span",{staticClass:"line-number"},[t._v("12")]),a("br"),a("span",{staticClass:"line-number"},[t._v("13")]),a("br")])]),a("p",[t._v("无论是同步还是异步发起的下载请求，都可以做以上的控制：")]),t._v(" "),a("div",{staticClass:"language-java line-numbers-mode"},[a("pre",{pre:!0,attrs:{class:"language-java"}},[a("code",[t._v("http"),a("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v(".")]),a("span",{pre:!0,attrs:{class:"token function"}},[t._v("async")]),a("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v("(")]),a("span",{pre:!0,attrs:{class:"token string"}},[t._v('"/download/test.zip"')]),a("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v(")")]),t._v("\n "),a("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v(".")]),a("span",{pre:!0,attrs:{class:"token function"}},[t._v("setOnResponse")]),a("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v("(")]),a("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v("(")]),a("span",{pre:!0,attrs:{class:"token class-name"}},[t._v("HttpResult")]),t._v(" result"),a("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v(")")]),t._v(" "),a("span",{pre:!0,attrs:{class:"token operator"}},[t._v("->")]),t._v(" "),a("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v("{")]),t._v("\n "),a("span",{pre:!0,attrs:{class:"token comment"}},[t._v("// 拿到下载控制器")]),t._v("\n "),a("span",{pre:!0,attrs:{class:"token class-name"}},[t._v("Ctrl")]),t._v(" ctrl "),a("span",{pre:!0,attrs:{class:"token operator"}},[t._v("=")]),t._v(" result"),a("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v(".")]),a("span",{pre:!0,attrs:{class:"token function"}},[t._v("getBody")]),a("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v("(")]),a("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v(")")]),a("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v(".")]),a("span",{pre:!0,attrs:{class:"token function"}},[t._v("toFolder")]),a("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v("(")]),a("span",{pre:!0,attrs:{class:"token string"}},[t._v('"D:/download/"')]),a("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v(")")]),a("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v(".")]),a("span",{pre:!0,attrs:{class:"token function"}},[t._v("start")]),a("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v("(")]),a("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v(")")]),a("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v(";")]),t._v("\n "),a("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v("}")]),a("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v(")")]),t._v("\n "),a("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v(".")]),a("span",{pre:!0,attrs:{class:"token function"}},[t._v("get")]),a("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v("(")]),a("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v(")")]),a("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v(";")]),t._v("\n")])]),t._v(" "),a("div",{staticClass:"line-numbers-wrapper"},[a("span",{staticClass:"line-number"},[t._v("1")]),a("br"),a("span",{staticClass:"line-number"},[t._v("2")]),a("br"),a("span",{staticClass:"line-number"},[t._v("3")]),a("br"),a("span",{staticClass:"line-number"},[t._v("4")]),a("br"),a("span",{staticClass:"line-number"},[t._v("5")]),a("br"),a("span",{staticClass:"line-number"},[t._v("6")]),a("br")])]),a("h3",{attrs:{id:"实现断点续传"}},[a("a",{staticClass:"header-anchor",attrs:{href:"#实现断点续传"}},[t._v("#")]),t._v(" 实现断点续传")]),t._v(" "),a("p",[t._v("OkHttps 对断点续传并没有再做更高层次的封装，因为这是app该去做的事情，它在设计上使各种网络问题的处理变简单的同时力求纯粹。下面的例子可以看到，OkHttps 通过一个失败回调拿到 "),a("strong",[t._v("断点")]),t._v("，便将复杂的问题变得简单：")]),t._v(" "),a("div",{staticClass:"language-java line-numbers-mode"},[a("pre",{pre:!0,attrs:{class:"language-java"}},[a("code",[t._v("http"),a("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v(".")]),a("span",{pre:!0,attrs:{class:"token function"}},[t._v("sync")]),a("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v("(")]),a("span",{pre:!0,attrs:{class:"token string"}},[t._v('"/download/test.zip"')]),a("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v(")")]),t._v("\n "),a("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v(".")]),a("span",{pre:!0,attrs:{class:"token function"}},[t._v("get")]),a("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v("(")]),a("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v(")")]),t._v("\n "),a("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v(".")]),a("span",{pre:!0,attrs:{class:"token function"}},[t._v("getBody")]),a("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v("(")]),a("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v(")")]),t._v("\n "),a("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v(".")]),a("span",{pre:!0,attrs:{class:"token function"}},[t._v("toFolder")]),a("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v("(")]),a("span",{pre:!0,attrs:{class:"token string"}},[t._v('"D:/download/"')]),a("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v(")")]),t._v("\n "),a("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v(".")]),a("span",{pre:!0,attrs:{class:"token function"}},[t._v("setOnFailure")]),a("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v("(")]),a("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v("(")]),a("span",{pre:!0,attrs:{class:"token class-name"}},[t._v("Failure")]),t._v(" failure"),a("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v(")")]),t._v(" "),a("span",{pre:!0,attrs:{class:"token operator"}},[t._v("->")]),t._v(" "),a("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v("{")]),t._v(" "),a("span",{pre:!0,attrs:{class:"token comment"}},[t._v("// 下载失败回调，以便接收诸如网络错误等失败信息")]),t._v("\n "),a("span",{pre:!0,attrs:{class:"token class-name"}},[t._v("IOException")]),t._v(" e "),a("span",{pre:!0,attrs:{class:"token operator"}},[t._v("=")]),t._v(" failure"),a("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v(".")]),a("span",{pre:!0,attrs:{class:"token function"}},[t._v("getException")]),a("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v("(")]),a("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v(")")]),a("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v(";")]),t._v(" "),a("span",{pre:!0,attrs:{class:"token comment"}},[t._v("// 具体的异常信息")]),t._v("\n "),a("span",{pre:!0,attrs:{class:"token keyword"}},[t._v("long")]),t._v(" doneBytes "),a("span",{pre:!0,attrs:{class:"token operator"}},[t._v("=")]),t._v(" failure"),a("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v(".")]),a("span",{pre:!0,attrs:{class:"token function"}},[t._v("getDoneBytes")]),a("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v("(")]),a("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v(")")]),a("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v(";")]),t._v(" "),a("span",{pre:!0,attrs:{class:"token comment"}},[t._v("// 已下载的字节数（断点），需要保存，用于断点续传")]),t._v("\n "),a("span",{pre:!0,attrs:{class:"token class-name"}},[t._v("File")]),t._v(" file "),a("span",{pre:!0,attrs:{class:"token operator"}},[t._v("=")]),t._v(" failure"),a("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v(".")]),a("span",{pre:!0,attrs:{class:"token function"}},[t._v("getFile")]),a("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v("(")]),a("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v(")")]),a("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v(";")]),t._v(" "),a("span",{pre:!0,attrs:{class:"token comment"}},[t._v("// 下载生成的文件，需要保存 ，用于断点续传（只保存路径也可以）")]),t._v("\n "),a("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v("}")]),a("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v(")")]),t._v("\n "),a("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v(".")]),a("span",{pre:!0,attrs:{class:"token function"}},[t._v("start")]),a("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v("(")]),a("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v(")")]),a("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v(";")]),t._v("\n")])]),t._v(" "),a("div",{staticClass:"line-numbers-wrapper"},[a("span",{staticClass:"line-number"},[t._v("1")]),a("br"),a("span",{staticClass:"line-number"},[t._v("2")]),a("br"),a("span",{staticClass:"line-number"},[t._v("3")]),a("br"),a("span",{staticClass:"line-number"},[t._v("4")]),a("br"),a("span",{staticClass:"line-number"},[t._v("5")]),a("br"),a("span",{staticClass:"line-number"},[t._v("6")]),a("br"),a("span",{staticClass:"line-number"},[t._v("7")]),a("br"),a("span",{staticClass:"line-number"},[t._v("8")]),a("br"),a("span",{staticClass:"line-number"},[t._v("9")]),a("br"),a("span",{staticClass:"line-number"},[t._v("10")]),a("br")])]),a("p",[t._v("下面代码实现续传：")]),t._v(" "),a("div",{staticClass:"language-java line-numbers-mode"},[a("pre",{pre:!0,attrs:{class:"language-java"}},[a("code",[a("span",{pre:!0,attrs:{class:"token keyword"}},[t._v("long")]),t._v(" doneBytes "),a("span",{pre:!0,attrs:{class:"token operator"}},[t._v("=")]),t._v(" "),a("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v(".")]),a("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v(".")]),a("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v(".")]),t._v(" "),a("span",{pre:!0,attrs:{class:"token comment"}},[t._v("// 拿到保存的断点")]),t._v("\n"),a("span",{pre:!0,attrs:{class:"token class-name"}},[t._v("File")]),t._v(" file "),a("span",{pre:!0,attrs:{class:"token operator"}},[t._v("=")]),t._v(" "),a("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v(".")]),a("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v(".")]),a("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v(".")]),t._v(" "),a("span",{pre:!0,attrs:{class:"token comment"}},[t._v("// 待续传的文件")]),t._v("\n\nhttp"),a("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v(".")]),a("span",{pre:!0,attrs:{class:"token function"}},[t._v("sync")]),a("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v("(")]),a("span",{pre:!0,attrs:{class:"token string"}},[t._v('"/download/test.zip"')]),a("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v(")")]),t._v("\n "),a("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v(".")]),a("span",{pre:!0,attrs:{class:"token function"}},[t._v("setRange")]),a("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v("(")]),t._v("doneBytes"),a("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v(")")]),t._v(" "),a("span",{pre:!0,attrs:{class:"token comment"}},[t._v("// 设置断点（已下载的字节数）")]),t._v("\n "),a("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v(".")]),a("span",{pre:!0,attrs:{class:"token function"}},[t._v("get")]),a("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v("(")]),a("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v(")")]),t._v("\n "),a("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v(".")]),a("span",{pre:!0,attrs:{class:"token function"}},[t._v("getBody")]),a("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v("(")]),a("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v(")")]),t._v("\n "),a("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v(".")]),a("span",{pre:!0,attrs:{class:"token function"}},[t._v("toFile")]),a("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v("(")]),t._v("file"),a("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v(")")]),t._v(" "),a("span",{pre:!0,attrs:{class:"token comment"}},[t._v("// 下载到同一个文件里")]),t._v("\n "),a("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v(".")]),a("span",{pre:!0,attrs:{class:"token function"}},[t._v("setAppended")]),a("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v("(")]),a("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v(")")]),t._v(" "),a("span",{pre:!0,attrs:{class:"token comment"}},[t._v("// 开启文件追加模式")]),t._v("\n "),a("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v(".")]),a("span",{pre:!0,attrs:{class:"token function"}},[t._v("setOnSuccess")]),a("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v("(")]),a("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v("(")]),a("span",{pre:!0,attrs:{class:"token class-name"}},[t._v("File")]),t._v(" file"),a("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v(")")]),t._v(" "),a("span",{pre:!0,attrs:{class:"token operator"}},[t._v("->")]),t._v(" "),a("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v("{")]),t._v("\n\n "),a("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v("}")]),a("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v(")")]),t._v("\n "),a("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v(".")]),a("span",{pre:!0,attrs:{class:"token function"}},[t._v("setOnFailure")]),a("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v("(")]),a("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v("(")]),a("span",{pre:!0,attrs:{class:"token class-name"}},[t._v("Failure")]),t._v(" failure"),a("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v(")")]),t._v(" "),a("span",{pre:!0,attrs:{class:"token operator"}},[t._v("->")]),t._v(" "),a("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v("{")]),t._v("\n \n "),a("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v("}")]),a("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v(")")]),t._v("\n "),a("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v(".")]),a("span",{pre:!0,attrs:{class:"token function"}},[t._v("start")]),a("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v("(")]),a("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v(")")]),a("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v(";")]),t._v("\n")])]),t._v(" "),a("div",{staticClass:"line-numbers-wrapper"},[a("span",{staticClass:"line-number"},[t._v("1")]),a("br"),a("span",{staticClass:"line-number"},[t._v("2")]),a("br"),a("span",{staticClass:"line-number"},[t._v("3")]),a("br"),a("span",{staticClass:"line-number"},[t._v("4")]),a("br"),a("span",{staticClass:"line-number"},[t._v("5")]),a("br"),a("span",{staticClass:"line-number"},[t._v("6")]),a("br"),a("span",{staticClass:"line-number"},[t._v("7")]),a("br"),a("span",{staticClass:"line-number"},[t._v("8")]),a("br"),a("span",{staticClass:"line-number"},[t._v("9")]),a("br"),a("span",{staticClass:"line-number"},[t._v("10")]),a("br"),a("span",{staticClass:"line-number"},[t._v("11")]),a("br"),a("span",{staticClass:"line-number"},[t._v("12")]),a("br"),a("span",{staticClass:"line-number"},[t._v("13")]),a("br"),a("span",{staticClass:"line-number"},[t._v("14")]),a("br"),a("span",{staticClass:"line-number"},[t._v("15")]),a("br"),a("span",{staticClass:"line-number"},[t._v("16")]),a("br")])]),a("h3",{attrs:{id:"实现分块下载"}},[a("a",{staticClass:"header-anchor",attrs:{href:"#实现分块下载"}},[t._v("#")]),t._v(" 实现分块下载")]),t._v(" "),a("p",[t._v("当文件很大时，有时候我们会考虑分块下载，与断点续传的思路是一样的，示例代码：")]),t._v(" "),a("div",{staticClass:"language-java line-numbers-mode"},[a("pre",{pre:!0,attrs:{class:"language-java"}},[a("code",[a("span",{pre:!0,attrs:{class:"token keyword"}},[t._v("static")]),t._v(" "),a("span",{pre:!0,attrs:{class:"token class-name"}},[t._v("String")]),t._v(" url "),a("span",{pre:!0,attrs:{class:"token operator"}},[t._v("=")]),t._v(" "),a("span",{pre:!0,attrs:{class:"token string"}},[t._v('"http://api.demo.com/download/test.zip"')]),t._v("\n\n"),a("span",{pre:!0,attrs:{class:"token keyword"}},[t._v("public")]),t._v(" "),a("span",{pre:!0,attrs:{class:"token keyword"}},[t._v("static")]),t._v(" "),a("span",{pre:!0,attrs:{class:"token keyword"}},[t._v("void")]),t._v(" "),a("span",{pre:!0,attrs:{class:"token function"}},[t._v("main")]),a("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v("(")]),a("span",{pre:!0,attrs:{class:"token class-name"}},[t._v("String")]),a("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v("[")]),a("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v("]")]),t._v(" args"),a("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v(")")]),t._v(" "),a("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v("{")]),t._v("\n "),a("span",{pre:!0,attrs:{class:"token keyword"}},[t._v("long")]),t._v(" totalSize "),a("span",{pre:!0,attrs:{class:"token operator"}},[t._v("=")]),t._v(" "),a("span",{pre:!0,attrs:{class:"token class-name"}},[t._v("HttpUtils")]),a("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v(".")]),a("span",{pre:!0,attrs:{class:"token function"}},[t._v("sync")]),a("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v("(")]),t._v("url"),a("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v(")")]),a("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v(".")]),a("span",{pre:!0,attrs:{class:"token function"}},[t._v("get")]),a("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v("(")]),a("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v(")")]),a("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v(".")]),a("span",{pre:!0,attrs:{class:"token function"}},[t._v("getBody")]),a("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v("(")]),a("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v(")")]),t._v("\n "),a("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v(".")]),a("span",{pre:!0,attrs:{class:"token function"}},[t._v("close")]),a("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v("(")]),a("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v(")")]),t._v(" "),a("span",{pre:!0,attrs:{class:"token comment"}},[t._v("// 因为这次请求只是为了获得文件大小，不消费报文体，所以直接关闭")]),t._v("\n "),a("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v(".")]),a("span",{pre:!0,attrs:{class:"token function"}},[t._v("getContentLength")]),a("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v("(")]),a("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v(")")]),a("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v(";")]),t._v(" "),a("span",{pre:!0,attrs:{class:"token comment"}},[t._v("// 获得待下载文件的大小（由于未消费报文体，所以该请求不会消耗下载报文体的时间和网络流量）")]),t._v("\n "),a("span",{pre:!0,attrs:{class:"token function"}},[t._v("download")]),a("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v("(")]),t._v("totalSize"),a("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v(",")]),t._v(" "),a("span",{pre:!0,attrs:{class:"token number"}},[t._v("0")]),a("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v(")")]),a("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v(";")]),t._v(" "),a("span",{pre:!0,attrs:{class:"token comment"}},[t._v("// 从第 0 块开始下载")]),t._v("\n "),a("span",{pre:!0,attrs:{class:"token function"}},[t._v("sleep")]),a("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v("(")]),a("span",{pre:!0,attrs:{class:"token number"}},[t._v("50000")]),a("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v(")")]),a("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v(";")]),t._v(" "),a("span",{pre:!0,attrs:{class:"token comment"}},[t._v("// 等待下载完成（不然本例的主线程就结束啦）")]),t._v("\n"),a("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v("}")]),t._v("\n\n"),a("span",{pre:!0,attrs:{class:"token keyword"}},[t._v("static")]),t._v(" "),a("span",{pre:!0,attrs:{class:"token keyword"}},[t._v("void")]),t._v(" "),a("span",{pre:!0,attrs:{class:"token function"}},[t._v("download")]),a("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v("(")]),a("span",{pre:!0,attrs:{class:"token keyword"}},[t._v("long")]),t._v(" totalSize"),a("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v(",")]),t._v(" "),a("span",{pre:!0,attrs:{class:"token keyword"}},[t._v("int")]),t._v(" index"),a("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v(")")]),t._v(" "),a("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v("{")]),t._v("\n "),a("span",{pre:!0,attrs:{class:"token keyword"}},[t._v("long")]),t._v(" size "),a("span",{pre:!0,attrs:{class:"token operator"}},[t._v("=")]),t._v(" "),a("span",{pre:!0,attrs:{class:"token number"}},[t._v("3")]),t._v(" "),a("span",{pre:!0,attrs:{class:"token operator"}},[t._v("*")]),t._v(" "),a("span",{pre:!0,attrs:{class:"token number"}},[t._v("1024")]),t._v(" "),a("span",{pre:!0,attrs:{class:"token operator"}},[t._v("*")]),t._v(" "),a("span",{pre:!0,attrs:{class:"token number"}},[t._v("1024")]),a("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v(";")]),t._v(" "),a("span",{pre:!0,attrs:{class:"token comment"}},[t._v("// 每块下载 3M ")]),t._v("\n "),a("span",{pre:!0,attrs:{class:"token keyword"}},[t._v("long")]),t._v(" start "),a("span",{pre:!0,attrs:{class:"token operator"}},[t._v("=")]),t._v(" index "),a("span",{pre:!0,attrs:{class:"token operator"}},[t._v("*")]),t._v(" size"),a("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v(";")]),t._v("\n "),a("span",{pre:!0,attrs:{class:"token keyword"}},[t._v("long")]),t._v(" end "),a("span",{pre:!0,attrs:{class:"token operator"}},[t._v("=")]),t._v(" "),a("span",{pre:!0,attrs:{class:"token class-name"}},[t._v("Math")]),a("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v(".")]),a("span",{pre:!0,attrs:{class:"token function"}},[t._v("min")]),a("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v("(")]),t._v("start "),a("span",{pre:!0,attrs:{class:"token operator"}},[t._v("+")]),t._v(" size"),a("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v(",")]),t._v(" totalSize"),a("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v(")")]),a("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v(";")]),t._v("\n "),a("span",{pre:!0,attrs:{class:"token class-name"}},[t._v("HttpUtils")]),a("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v(".")]),a("span",{pre:!0,attrs:{class:"token function"}},[t._v("sync")]),a("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v("(")]),t._v("url"),a("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v(")")]),t._v("\n "),a("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v(".")]),a("span",{pre:!0,attrs:{class:"token function"}},[t._v("setRange")]),a("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v("(")]),t._v("start"),a("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v(",")]),t._v(" end"),a("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v(")")]),t._v(" "),a("span",{pre:!0,attrs:{class:"token comment"}},[t._v("// 设置本次下载的范围")]),t._v("\n "),a("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v(".")]),a("span",{pre:!0,attrs:{class:"token function"}},[t._v("get")]),a("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v("(")]),a("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v(")")]),a("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v(".")]),a("span",{pre:!0,attrs:{class:"token function"}},[t._v("getBody")]),a("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v("(")]),a("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v(")")]),t._v("\n "),a("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v(".")]),a("span",{pre:!0,attrs:{class:"token function"}},[t._v("toFile")]),a("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v("(")]),a("span",{pre:!0,attrs:{class:"token string"}},[t._v('"D:/download/test.zip"')]),a("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v(")")]),t._v(" "),a("span",{pre:!0,attrs:{class:"token comment"}},[t._v("// 下载到同一个文件里")]),t._v("\n "),a("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v(".")]),a("span",{pre:!0,attrs:{class:"token function"}},[t._v("setAppended")]),a("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v("(")]),a("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v(")")]),t._v(" "),a("span",{pre:!0,attrs:{class:"token comment"}},[t._v("// 开启文件追加模式")]),t._v("\n "),a("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v(".")]),a("span",{pre:!0,attrs:{class:"token function"}},[t._v("setOnSuccess")]),a("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v("(")]),a("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v("(")]),a("span",{pre:!0,attrs:{class:"token class-name"}},[t._v("File")]),t._v(" file"),a("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v(")")]),t._v(" "),a("span",{pre:!0,attrs:{class:"token operator"}},[t._v("->")]),t._v(" "),a("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v("{")]),t._v("\n "),a("span",{pre:!0,attrs:{class:"token keyword"}},[t._v("if")]),t._v(" "),a("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v("(")]),t._v("end "),a("span",{pre:!0,attrs:{class:"token operator"}},[t._v("<")]),t._v(" totalSize"),a("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v(")")]),t._v(" "),a("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v("{")]),t._v(" "),a("span",{pre:!0,attrs:{class:"token comment"}},[t._v("// 若未下载完，则继续下载下一块")]),t._v("\n "),a("span",{pre:!0,attrs:{class:"token function"}},[t._v("download")]),a("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v("(")]),t._v("totalSize"),a("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v(",")]),t._v(" index "),a("span",{pre:!0,attrs:{class:"token operator"}},[t._v("+")]),t._v(" "),a("span",{pre:!0,attrs:{class:"token number"}},[t._v("1")]),a("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v(")")]),a("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v(";")]),t._v(" \n "),a("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v("}")]),t._v(" "),a("span",{pre:!0,attrs:{class:"token keyword"}},[t._v("else")]),t._v(" "),a("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v("{")]),t._v("\n "),a("span",{pre:!0,attrs:{class:"token class-name"}},[t._v("System")]),a("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v(".")]),t._v("out"),a("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v(".")]),a("span",{pre:!0,attrs:{class:"token function"}},[t._v("println")]),a("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v("(")]),a("span",{pre:!0,attrs:{class:"token string"}},[t._v('"下载完成"')]),a("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v(")")]),a("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v(";")]),t._v("\n "),a("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v("}")]),t._v("\n "),a("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v("}")]),a("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v(")")]),t._v("\n "),a("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v(".")]),a("span",{pre:!0,attrs:{class:"token function"}},[t._v("start")]),a("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v("(")]),a("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v(")")]),a("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v(";")]),t._v("\n"),a("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v("}")]),t._v("\n")])]),t._v(" "),a("div",{staticClass:"line-numbers-wrapper"},[a("span",{staticClass:"line-number"},[t._v("1")]),a("br"),a("span",{staticClass:"line-number"},[t._v("2")]),a("br"),a("span",{staticClass:"line-number"},[t._v("3")]),a("br"),a("span",{staticClass:"line-number"},[t._v("4")]),a("br"),a("span",{staticClass:"line-number"},[t._v("5")]),a("br"),a("span",{staticClass:"line-number"},[t._v("6")]),a("br"),a("span",{staticClass:"line-number"},[t._v("7")]),a("br"),a("span",{staticClass:"line-number"},[t._v("8")]),a("br"),a("span",{staticClass:"line-number"},[t._v("9")]),a("br"),a("span",{staticClass:"line-number"},[t._v("10")]),a("br"),a("span",{staticClass:"line-number"},[t._v("11")]),a("br"),a("span",{staticClass:"line-number"},[t._v("12")]),a("br"),a("span",{staticClass:"line-number"},[t._v("13")]),a("br"),a("span",{staticClass:"line-number"},[t._v("14")]),a("br"),a("span",{staticClass:"line-number"},[t._v("15")]),a("br"),a("span",{staticClass:"line-number"},[t._v("16")]),a("br"),a("span",{staticClass:"line-number"},[t._v("17")]),a("br"),a("span",{staticClass:"line-number"},[t._v("18")]),a("br"),a("span",{staticClass:"line-number"},[t._v("19")]),a("br"),a("span",{staticClass:"line-number"},[t._v("20")]),a("br"),a("span",{staticClass:"line-number"},[t._v("21")]),a("br"),a("span",{staticClass:"line-number"},[t._v("22")]),a("br"),a("span",{staticClass:"line-number"},[t._v("23")]),a("br"),a("span",{staticClass:"line-number"},[t._v("24")]),a("br"),a("span",{staticClass:"line-number"},[t._v("25")]),a("br"),a("span",{staticClass:"line-number"},[t._v("26")]),a("br"),a("span",{staticClass:"line-number"},[t._v("27")]),a("br"),a("span",{staticClass:"line-number"},[t._v("28")]),a("br")])]),a("h2",{attrs:{id:"文件上传"}},[a("a",{staticClass:"header-anchor",attrs:{href:"#文件上传"}},[t._v("#")]),t._v(" 文件上传")]),t._v(" "),a("p",[t._v("一个简单文件上传的示例：")]),t._v(" "),a("div",{staticClass:"language-java line-numbers-mode"},[a("pre",{pre:!0,attrs:{class:"language-java"}},[a("code",[t._v("http"),a("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v(".")]),a("span",{pre:!0,attrs:{class:"token function"}},[t._v("sync")]),a("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v("(")]),a("span",{pre:!0,attrs:{class:"token string"}},[t._v('"/upload"')]),a("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v(")")]),t._v("\n "),a("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v(".")]),a("span",{pre:!0,attrs:{class:"token function"}},[t._v("addFileParam")]),a("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v("(")]),a("span",{pre:!0,attrs:{class:"token string"}},[t._v('"test"')]),a("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v(",")]),t._v(" "),a("span",{pre:!0,attrs:{class:"token string"}},[t._v('"D:/download/test.zip"')]),a("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v(")")]),t._v("\n "),a("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v(".")]),a("span",{pre:!0,attrs:{class:"token function"}},[t._v("post")]),a("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v("(")]),a("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v(")")]),a("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v(";")]),t._v(" "),a("span",{pre:!0,attrs:{class:"token comment"}},[t._v("// 上传发法一般使用 POST 或 PUT，看服务器支持")]),t._v("\n")])]),t._v(" "),a("div",{staticClass:"line-numbers-wrapper"},[a("span",{staticClass:"line-number"},[t._v("1")]),a("br"),a("span",{staticClass:"line-number"},[t._v("2")]),a("br"),a("span",{staticClass:"line-number"},[t._v("3")]),a("br")])]),a("p",[t._v("异步上传也是完全一样：")]),t._v(" "),a("div",{staticClass:"language-java line-numbers-mode"},[a("pre",{pre:!0,attrs:{class:"language-java"}},[a("code",[t._v("http"),a("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v(".")]),a("span",{pre:!0,attrs:{class:"token function"}},[t._v("async")]),a("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v("(")]),a("span",{pre:!0,attrs:{class:"token string"}},[t._v('"/upload"')]),a("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v(")")]),t._v("\n "),a("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v(".")]),a("span",{pre:!0,attrs:{class:"token function"}},[t._v("addFileParam")]),a("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v("(")]),a("span",{pre:!0,attrs:{class:"token string"}},[t._v('"test"')]),a("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v(",")]),t._v(" "),a("span",{pre:!0,attrs:{class:"token string"}},[t._v('"D:/download/test.zip"')]),a("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v(")")]),t._v("\n "),a("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v(".")]),a("span",{pre:!0,attrs:{class:"token function"}},[t._v("post")]),a("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v("(")]),a("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v(")")]),a("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v(";")]),t._v("\n")])]),t._v(" "),a("div",{staticClass:"line-numbers-wrapper"},[a("span",{staticClass:"line-number"},[t._v("1")]),a("br"),a("span",{staticClass:"line-number"},[t._v("2")]),a("br"),a("span",{staticClass:"line-number"},[t._v("3")]),a("br")])]),a("h3",{attrs:{id:"上传进度监听"}},[a("a",{staticClass:"header-anchor",attrs:{href:"#上传进度监听"}},[t._v("#")]),t._v(" 上传进度监听")]),t._v(" "),a("p",[t._v("OkHttps 的上传进度监听，监听的是所有请求报文体的发送进度，示例代码：")]),t._v(" "),a("div",{staticClass:"language-java line-numbers-mode"},[a("pre",{pre:!0,attrs:{class:"language-java"}},[a("code",[t._v("http"),a("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v(".")]),a("span",{pre:!0,attrs:{class:"token function"}},[t._v("sync")]),a("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v("(")]),a("span",{pre:!0,attrs:{class:"token string"}},[t._v('"/upload"')]),a("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v(")")]),t._v("\n "),a("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v(".")]),a("span",{pre:!0,attrs:{class:"token function"}},[t._v("addBodyParam")]),a("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v("(")]),a("span",{pre:!0,attrs:{class:"token string"}},[t._v('"name"')]),a("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v(",")]),t._v(" "),a("span",{pre:!0,attrs:{class:"token string"}},[t._v('"Jack"')]),a("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v(")")]),t._v("\n "),a("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v(".")]),a("span",{pre:!0,attrs:{class:"token function"}},[t._v("addBodyParam")]),a("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v("(")]),a("span",{pre:!0,attrs:{class:"token string"}},[t._v('"age"')]),a("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v(",")]),t._v(" "),a("span",{pre:!0,attrs:{class:"token number"}},[t._v("20")]),a("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v(")")]),t._v("\n "),a("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v(".")]),a("span",{pre:!0,attrs:{class:"token function"}},[t._v("addFileParam")]),a("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v("(")]),a("span",{pre:!0,attrs:{class:"token string"}},[t._v('"avatar"')]),a("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v(",")]),t._v(" "),a("span",{pre:!0,attrs:{class:"token string"}},[t._v('"D:/image/avatar.jpg"')]),a("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v(")")]),t._v("\n "),a("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v(".")]),a("span",{pre:!0,attrs:{class:"token function"}},[t._v("setStepBytes")]),a("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v("(")]),a("span",{pre:!0,attrs:{class:"token number"}},[t._v("1024")]),a("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v(")")]),t._v(" "),a("span",{pre:!0,attrs:{class:"token comment"}},[t._v("// 设置每发送 1024 个字节执行一次进度回调（不设置默认为 8192） ")]),t._v("\n "),a("span",{pre:!0,attrs:{class:"token comment"}},[t._v("// .setStepRate(0.01) // 设置每发送 1% 执行一次进度回调（不设置以 StepBytes 为准） ")]),t._v("\n "),a("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v(".")]),a("span",{pre:!0,attrs:{class:"token function"}},[t._v("setOnProcess")]),a("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v("(")]),a("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v("(")]),a("span",{pre:!0,attrs:{class:"token class-name"}},[t._v("Process")]),t._v(" process"),a("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v(")")]),t._v(" "),a("span",{pre:!0,attrs:{class:"token operator"}},[t._v("->")]),t._v(" "),a("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v("{")]),t._v(" "),a("span",{pre:!0,attrs:{class:"token comment"}},[t._v("// 上传进度回调")]),t._v("\n "),a("span",{pre:!0,attrs:{class:"token keyword"}},[t._v("long")]),t._v(" doneBytes "),a("span",{pre:!0,attrs:{class:"token operator"}},[t._v("=")]),t._v(" process"),a("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v(".")]),a("span",{pre:!0,attrs:{class:"token function"}},[t._v("getDoneBytes")]),a("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v("(")]),a("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v(")")]),a("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v(";")]),t._v(" "),a("span",{pre:!0,attrs:{class:"token comment"}},[t._v("// 已发送字节数")]),t._v("\n "),a("span",{pre:!0,attrs:{class:"token keyword"}},[t._v("long")]),t._v(" totalBytes "),a("span",{pre:!0,attrs:{class:"token operator"}},[t._v("=")]),t._v(" process"),a("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v(".")]),a("span",{pre:!0,attrs:{class:"token function"}},[t._v("getTotalBytes")]),a("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v("(")]),a("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v(")")]),a("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v(";")]),t._v(" "),a("span",{pre:!0,attrs:{class:"token comment"}},[t._v("// 总共的字节数")]),t._v("\n "),a("span",{pre:!0,attrs:{class:"token keyword"}},[t._v("double")]),t._v(" rate "),a("span",{pre:!0,attrs:{class:"token operator"}},[t._v("=")]),t._v(" process"),a("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v(".")]),a("span",{pre:!0,attrs:{class:"token function"}},[t._v("getRate")]),a("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v("(")]),a("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v(")")]),a("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v(";")]),t._v(" "),a("span",{pre:!0,attrs:{class:"token comment"}},[t._v("// 已发送的比例")]),t._v("\n "),a("span",{pre:!0,attrs:{class:"token keyword"}},[t._v("boolean")]),t._v(" isDone "),a("span",{pre:!0,attrs:{class:"token operator"}},[t._v("=")]),t._v(" process"),a("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v(".")]),a("span",{pre:!0,attrs:{class:"token function"}},[t._v("isDone")]),a("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v("(")]),a("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v(")")]),a("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v(";")]),t._v(" "),a("span",{pre:!0,attrs:{class:"token comment"}},[t._v("// 是否发送完成")]),t._v("\n "),a("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v("}")]),a("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v(")")]),t._v("\n "),a("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v(".")]),a("span",{pre:!0,attrs:{class:"token function"}},[t._v("post")]),a("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v("(")]),a("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v(")")]),a("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v(";")]),t._v("\n")])]),t._v(" "),a("div",{staticClass:"line-numbers-wrapper"},[a("span",{staticClass:"line-number"},[t._v("1")]),a("br"),a("span",{staticClass:"line-number"},[t._v("2")]),a("br"),a("span",{staticClass:"line-number"},[t._v("3")]),a("br"),a("span",{staticClass:"line-number"},[t._v("4")]),a("br"),a("span",{staticClass:"line-number"},[t._v("5")]),a("br"),a("span",{staticClass:"line-number"},[t._v("6")]),a("br"),a("span",{staticClass:"line-number"},[t._v("7")]),a("br"),a("span",{staticClass:"line-number"},[t._v("8")]),a("br"),a("span",{staticClass:"line-number"},[t._v("9")]),a("br"),a("span",{staticClass:"line-number"},[t._v("10")]),a("br"),a("span",{staticClass:"line-number"},[t._v("11")]),a("br"),a("span",{staticClass:"line-number"},[t._v("12")]),a("br"),a("span",{staticClass:"line-number"},[t._v("13")]),a("br")])]),a("p",[t._v("咦！怎么感觉和下载的进度回调的一样？没错！OkHttps 还是使用同一套API处理上传和下载的进度回调，区别只在于上传是在"),a("code",[t._v("get/post")]),t._v("方法之前使用这些API，下载是在"),a("code",[t._v("getBody")]),t._v("方法之后使用。很好理解："),a("code",[t._v("get/post")]),t._v("之前是准备发送请求时段，有上传的含义，而"),a("code",[t._v("getBody")]),t._v("之后，已是报文响应的时段，当然是下载。")]),t._v(" "),a("h3",{attrs:{id:"上传过程控制"}},[a("a",{staticClass:"header-anchor",attrs:{href:"#上传过程控制"}},[t._v("#")]),t._v(" 上传过程控制")]),t._v(" "),a("p",[t._v("上传文件的过程控制就很简单，和常规请求一样，只有异步发起的上传可以取消：")]),t._v(" "),a("div",{staticClass:"language-java line-numbers-mode"},[a("pre",{pre:!0,attrs:{class:"language-java"}},[a("code",[a("span",{pre:!0,attrs:{class:"token class-name"}},[t._v("HttpCall")]),t._v(" call "),a("span",{pre:!0,attrs:{class:"token operator"}},[t._v("=")]),t._v(" http"),a("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v(".")]),a("span",{pre:!0,attrs:{class:"token function"}},[t._v("async")]),a("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v("(")]),a("span",{pre:!0,attrs:{class:"token string"}},[t._v('"/upload"')]),a("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v(")")]),t._v("\n "),a("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v(".")]),a("span",{pre:!0,attrs:{class:"token function"}},[t._v("addFileParam")]),a("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v("(")]),a("span",{pre:!0,attrs:{class:"token string"}},[t._v('"test"')]),a("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v(",")]),t._v(" "),a("span",{pre:!0,attrs:{class:"token string"}},[t._v('"D:/download/test.zip"')]),a("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v(")")]),t._v("\n "),a("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v(".")]),a("span",{pre:!0,attrs:{class:"token function"}},[t._v("setOnProcess")]),a("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v("(")]),a("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v("(")]),a("span",{pre:!0,attrs:{class:"token class-name"}},[t._v("Process")]),t._v(" process"),a("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v(")")]),t._v(" "),a("span",{pre:!0,attrs:{class:"token operator"}},[t._v("->")]),t._v(" "),a("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v("{")]),t._v("\n "),a("span",{pre:!0,attrs:{class:"token class-name"}},[t._v("System")]),a("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v(".")]),t._v("out"),a("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v(".")]),a("span",{pre:!0,attrs:{class:"token function"}},[t._v("println")]),a("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v("(")]),t._v("process"),a("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v(".")]),a("span",{pre:!0,attrs:{class:"token function"}},[t._v("getRate")]),a("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v("(")]),a("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v(")")]),a("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v(")")]),a("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v(";")]),t._v("\n "),a("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v("}")]),a("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v(")")]),t._v("\n "),a("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v(".")]),a("span",{pre:!0,attrs:{class:"token function"}},[t._v("post")]),a("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v("(")]),a("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v(")")]),a("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v(";")]),t._v("\n\ncall"),a("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v(".")]),a("span",{pre:!0,attrs:{class:"token function"}},[t._v("cancel")]),a("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v("(")]),a("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v(")")]),a("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v(";")]),t._v(" "),a("span",{pre:!0,attrs:{class:"token comment"}},[t._v("// 取消上传")]),t._v("\n")])]),t._v(" "),a("div",{staticClass:"line-numbers-wrapper"},[a("span",{staticClass:"line-number"},[t._v("1")]),a("br"),a("span",{staticClass:"line-number"},[t._v("2")]),a("br"),a("span",{staticClass:"line-number"},[t._v("3")]),a("br"),a("span",{staticClass:"line-number"},[t._v("4")]),a("br"),a("span",{staticClass:"line-number"},[t._v("5")]),a("br"),a("span",{staticClass:"line-number"},[t._v("6")]),a("br"),a("span",{staticClass:"line-number"},[t._v("7")]),a("br"),a("span",{staticClass:"line-number"},[t._v("8")]),a("br")])]),a("p",[t._v("上传就没有暂停和继续这个功能啦，应该没人有这个需求吧?")])])}),[],!1,null,null,null);s.default=e.exports}}]); \ No newline at end of file diff --git a/okhttps-doc/docs/.vuepress/dist/assets/js/13.d857e269.js b/okhttps-doc/docs/.vuepress/dist/assets/js/13.d857e269.js deleted file mode 100644 index 126a94c9..00000000 --- a/okhttps-doc/docs/.vuepress/dist/assets/js/13.d857e269.js +++ /dev/null @@ -1 +0,0 @@ -(window.webpackJsonp=window.webpackJsonp||[]).push([[13],{281:function(n,w,o){}}]); \ No newline at end of file diff --git a/okhttps-doc/docs/.vuepress/dist/assets/js/2.16cbe9f2.js b/okhttps-doc/docs/.vuepress/dist/assets/js/2.16cbe9f2.js deleted file mode 100644 index 7e02b99a..00000000 --- a/okhttps-doc/docs/.vuepress/dist/assets/js/2.16cbe9f2.js +++ /dev/null @@ -1 +0,0 @@ -(window.webpackJsonp=window.webpackJsonp||[]).push([[2],{282:function(t,e,n){"use strict";n.d(e,"d",(function(){return i})),n.d(e,"a",(function(){return a})),n.d(e,"i",(function(){return s})),n.d(e,"f",(function(){return u})),n.d(e,"g",(function(){return c})),n.d(e,"h",(function(){return l})),n.d(e,"b",(function(){return h})),n.d(e,"e",(function(){return f})),n.d(e,"k",(function(){return p})),n.d(e,"l",(function(){return d})),n.d(e,"c",(function(){return g})),n.d(e,"j",(function(){return v}));n(20),n(84),n(143),n(298),n(145),n(57),n(25),n(283),n(58),n(148),n(88);var i=/#.*$/,r=/\.(md|html)$/,a=/\/$/,s=/^[a-z]+:/i;function o(t){return decodeURI(t).replace(i,"").replace(r,"")}function u(t){return s.test(t)}function c(t){return/^mailto:/.test(t)}function l(t){return/^tel:/.test(t)}function h(t){if(u(t))return t;var e=t.match(i),n=e?e[0]:"",r=o(t);return a.test(r)?t:r+".html"+n}function f(t,e){var n=decodeURIComponent(t.hash),r=function(t){var e=t.match(i);if(e)return e[0]}(e);return(!r||n===r)&&o(t.path)===o(e)}function p(t,e,n){if(u(e))return{type:"external",path:e};n&&(e=function(t,e,n){var i=t.charAt(0);if("/"===i)return t;if("?"===i||"#"===i)return e+t;var r=e.split("/");n&&r[r.length-1]||r.pop();for(var a=t.replace(/^\//,"").split("/"),s=0;s3&&void 0!==arguments[3]?arguments[3]:1;if("string"==typeof e)return p(n,e,i);if(Array.isArray(e))return Object.assign(p(n,e[0],i),{title:e[1]});var a=e.children||[];return 0===a.length&&e.path?Object.assign(p(n,e.path,i),{title:e.title}):{type:"group",path:e.path,title:e.title,sidebarDepth:e.sidebarDepth,children:a.map((function(e){return t(e,n,i,r+1)})),collapsable:!1!==e.collapsable}}(t,r,c)})):[]}return[]}function g(t){var e;return(t=t.map((function(t){return Object.assign({},t)}))).forEach((function(t){2===t.level?e=t:e&&(e.children||(e.children=[])).push(t)})),t.filter((function(t){return 2===t.level}))}function v(t){return Object.assign(t,{type:t.items&&t.items.length?"links":"link"})}},283:function(t,e,n){"use strict";var i=n(89),r=n(8),a=n(14),s=n(13),o=n(90),u=n(91);i("match",1,(function(t,e,n){return[function(e){var n=s(this),i=null==e?void 0:e[t];return void 0!==i?i.call(e,n):new RegExp(e)[t](String(n))},function(t){var i=n(e,t,this);if(i.done)return i.value;var s=r(t),c=String(this);if(!s.global)return u(s,c);var l=s.unicode;s.lastIndex=0;for(var h,f=[],p=0;null!==(h=u(s,c));){var d=String(h[0]);f[p]=d,""===d&&(s.lastIndex=o(c,a(s.lastIndex),l)),p++}return 0===p?null:f}]}))},284:function(t,e,n){},285:function(t,e,n){},286:function(t,e,n){},287:function(t,e,n){},288:function(t,e,n){},289:function(t,e,n){},290:function(t,e,n){},291:function(t,e,n){},292:function(t,e,n){},293:function(t,e,n){},294:function(t,e,n){},295:function(t,e,n){},296:function(t,e,n){},298:function(t,e,n){n(0)({target:"Array",stat:!0},{isArray:n(40)})},299:function(t,e,n){"use strict";var i=n(0),r=n(146).trim;i({target:"String",proto:!0,forced:n(311)("trim")},{trim:function(){return r(this)}})},300:function(t,e,n){var i=n(6),r=n(3),a=n(82),s=n(155),o=n(7).f,u=n(39).f,c=n(86),l=n(144),h=n(150),f=n(21),p=n(1),d=n(37).set,g=n(312),v=n(2)("match"),m=r.RegExp,b=m.prototype,k=/a/g,_=/a/g,x=new m(k)!==k,C=h.UNSUPPORTED_Y;if(i&&a("RegExp",!x||C||p((function(){return _[v]=!1,m(k)!=k||m(_)==_||"/a/i"!=m(k,"i")})))){for(var $=function(t,e){var n,i=this instanceof $,r=c(t),a=void 0===e;if(!i&&r&&t.constructor===$&&a)return t;x?r&&!a&&(t=t.source):t instanceof $&&(a&&(e=l.call(t)),t=t.source),C&&(n=!!e&&e.indexOf("y")>-1)&&(e=e.replace(/y/g,""));var o=s(x?new m(t,e):m(t,e),i?this:b,$);return C&&n&&d(o,{sticky:n}),o},L=function(t){t in $||o($,t,{configurable:!0,get:function(){return m[t]},set:function(e){m[t]=e}})},y=u(m),w=0;y.length>w;)L(y[w++]);b.constructor=$,$.prototype=b,f(r,"RegExp",$)}g("RegExp")},301:function(t,e,n){"use strict";var i=n(21),r=n(8),a=n(1),s=n(144),o=RegExp.prototype,u=o.toString,c=a((function(){return"/a/b"!=u.call({source:"a",flags:"b"})})),l="toString"!=u.name;(c||l)&&i(RegExp.prototype,"toString",(function(){var t=r(this),e=String(t.source),n=t.flags;return"/"+e+"/"+String(void 0===n&&t instanceof RegExp&&!("flags"in o)?s.call(t):n)}),{unsafe:!0})},302:function(t,e){t.exports=function(t){return null==t}},303:function(t,e,n){"use strict";n.r(e);n(142);var i=n(282),r={name:"SidebarGroup",components:{DropdownTransition:n(304).a},props:["item","open","collapsable","depth"],beforeCreate:function(){this.$options.components.SidebarLinks=n(303).default},methods:{isActive:i.e}},a=(n(324),n(19)),s=Object(a.a)(r,(function(){var t=this,e=t.$createElement,n=t._self._c||e;return n("section",{staticClass:"sidebar-group",class:[{collapsable:t.collapsable,"is-sub-group":0!==t.depth},"depth-"+t.depth]},[t.item.path?n("RouterLink",{staticClass:"sidebar-heading clickable",class:{open:t.open,active:t.isActive(t.$route,t.item.path)},attrs:{to:t.item.path},nativeOn:{click:function(e){return t.$emit("toggle")}}},[n("span",[t._v(t._s(t.item.title))]),t._v(" "),t.collapsable?n("span",{staticClass:"arrow",class:t.open?"down":"right"}):t._e()]):n("p",{staticClass:"sidebar-heading",class:{open:t.open},on:{click:function(e){return t.$emit("toggle")}}},[n("span",[t._v(t._s(t.item.title))]),t._v(" "),t.collapsable?n("span",{staticClass:"arrow",class:t.open?"down":"right"}):t._e()]),t._v(" "),n("DropdownTransition",[t.open||!t.collapsable?n("SidebarLinks",{staticClass:"sidebar-group-items",attrs:{items:t.item.children,"sidebar-depth":t.item.sidebarDepth,depth:t.depth+1}}):t._e()],1)],1)}),[],!1,null,null,null).exports;n(325),n(57);function o(t,e,n,i,r){var a={props:{to:e,activeClass:"",exactActiveClass:""},class:{active:i,"sidebar-link":!0}};return r>2&&(a.style={"padding-left":r+"rem"}),t("RouterLink",a,n)}function u(t,e,n,r,a){var s=arguments.length>5&&void 0!==arguments[5]?arguments[5]:1;return!e||s>a?null:t("ul",{class:"sidebar-sub-headers"},e.map((function(e){var c=Object(i.e)(r,n+"#"+e.slug);return t("li",{class:"sidebar-sub-header"},[o(t,n+"#"+e.slug,e.title,c,e.level-1),u(t,e.children,n,r,a,s+1)])})))}var c={functional:!0,props:["item","sidebarDepth"],render:function(t,e){var n=e.parent,r=n.$page,a=(n.$site,n.$route),s=n.$themeConfig,c=n.$themeLocaleConfig,l=e.props,h=l.item,f=l.sidebarDepth,p=Object(i.e)(a,h.path),d="auto"===h.type?p||h.children.some((function(t){return Object(i.e)(a,h.basePath+"#"+t.slug)})):p,g="external"===h.type?function(t,e,n){return t("a",{attrs:{href:e,target:"_blank",rel:"noopener noreferrer"},class:{"sidebar-link":!0}},[n,t("OutboundLink")])}(t,h.path,h.title||h.path):o(t,h.path,h.title||h.path,d),v=[r.frontmatter.sidebarDepth,f,c.sidebarDepth,s.sidebarDepth,1].find((function(t){return void 0!==t})),m=c.displayAllHeaders||s.displayAllHeaders;return"auto"===h.type?[g,u(t,h.children,h.basePath,a,v)]:(d||m)&&h.headers&&!i.d.test(h.path)?[g,u(t,Object(i.c)(h.headers),h.path,a,v)]:g}};n(326);function l(t,e){return"group"===e.type&&e.children.some((function(e){return"group"===e.type?l(t,e):"page"===e.type&&Object(i.e)(t,e.path)}))}var h={name:"SidebarLinks",components:{SidebarGroup:s,SidebarLink:Object(a.a)(c,void 0,void 0,!1,null,null,null).exports},props:["items","depth","sidebarDepth"],data:function(){return{openGroupIndex:0}},watch:{$route:function(){this.refreshIndex()}},created:function(){this.refreshIndex()},methods:{refreshIndex:function(){var t=function(t,e){for(var n=0;n-1&&(this.openGroupIndex=t)},toggleGroup:function(t){this.openGroupIndex=t===this.openGroupIndex?-1:t},isActive:function(t){return Object(i.e)(this.$route,t.regularPath)}}},f=Object(a.a)(h,(function(){var t=this,e=t.$createElement,n=t._self._c||e;return t.items.length?n("ul",{staticClass:"sidebar-links"},t._l(t.items,(function(e,i){return n("li",{key:i},["group"===e.type?n("SidebarGroup",{attrs:{item:e,open:i===t.openGroupIndex,collapsable:e.collapsable||e.collapsible,depth:t.depth},on:{toggle:function(e){return t.toggleGroup(i)}}}):n("SidebarLink",{attrs:{"sidebar-depth":t.sidebarDepth,item:e}})],1)})),0):t._e()}),[],!1,null,null,null);e.default=f.exports},304:function(t,e,n){"use strict";var i={name:"DropdownTransition",methods:{setHeight:function(t){t.style.height=t.scrollHeight+"px"},unsetHeight:function(t){t.style.height=""}}},r=(n(316),n(19)),a=Object(r.a)(i,(function(){var t=this.$createElement;return(this._self._c||t)("transition",{attrs:{name:"dropdown"},on:{enter:this.setHeight,"after-enter":this.unsetHeight,"before-leave":this.setHeight}},[this._t("default")],2)}),[],!1,null,null,null);e.a=a.exports},305:function(t,e,n){"use strict";var i=n(0),r=n(306);i({target:"String",proto:!0,forced:n(307)("link")},{link:function(t){return r(this,"a","href",t)}})},306:function(t,e,n){var i=n(13),r=/"/g;t.exports=function(t,e,n,a){var s=String(i(t)),o="<"+e;return""!==n&&(o+=" "+n+'="'+String(a).replace(r,""")+'"'),o+">"+s+""}},307:function(t,e,n){var i=n(1);t.exports=function(t){return i((function(){var e=""[t]('"');return e!==e.toLowerCase()||e.split('"').length>3}))}},308:function(t,e,n){"use strict";var i=n(284);n.n(i).a},309:function(t,e,n){var i=n(0),r=n(310);i({global:!0,forced:parseInt!=r},{parseInt:r})},310:function(t,e,n){var i=n(3),r=n(146).trim,a=n(147),s=i.parseInt,o=/^[+-]?0[Xx]/,u=8!==s(a+"08")||22!==s(a+"0x16");t.exports=u?function(t,e){var n=r(String(t));return s(n,e>>>0||(o.test(n)?16:10))}:s},311:function(t,e,n){var i=n(1),r=n(147);t.exports=function(t){return i((function(){return!!r[t]()||"​…᠎"!="​…᠎"[t]()||r[t].name!==t}))}},312:function(t,e,n){"use strict";var i=n(38),r=n(7),a=n(2),s=n(6),o=a("species");t.exports=function(t){var e=i(t),n=r.f;s&&e&&!e[o]&&n(e,o,{configurable:!0,get:function(){return this}})}},313:function(t,e,n){"use strict";var i,r=n(0),a=n(22).f,s=n(14),o=n(85),u=n(13),c=n(87),l=n(26),h="".endsWith,f=Math.min,p=c("endsWith");r({target:"String",proto:!0,forced:!!(l||p||(i=a(String.prototype,"endsWith"),!i||i.writable))&&!p},{endsWith:function(t){var e=String(u(this));o(t);var n=arguments.length>1?arguments[1]:void 0,i=s(e.length),r=void 0===n?i:f(s(n),i),a=String(t);return h?h.call(e,a,r):e.slice(r-a.length,r)===a}})},314:function(t,e,n){"use strict";var i=n(285);n.n(i).a},315:function(t,e,n){"use strict";var i=n(286);n.n(i).a},316:function(t,e,n){"use strict";var i=n(287);n.n(i).a},317:function(t,e,n){"use strict";var i=n(288);n.n(i).a},318:function(t,e,n){"use strict";var i=n(289);n.n(i).a},319:function(t,e,n){"use strict";var i=n(290);n.n(i).a},320:function(t,e,n){"use strict";var i=n(291);n.n(i).a},321:function(t,e,n){var i=n(28),r=n(10),a=n(23);t.exports=function(t){return"string"==typeof t||!r(t)&&a(t)&&"[object String]"==i(t)}},322:function(t,e,n){"use strict";var i=n(292);n.n(i).a},323:function(t,e,n){"use strict";var i=n(293);n.n(i).a},324:function(t,e,n){"use strict";var i=n(294);n.n(i).a},325:function(t,e,n){"use strict";var i=n(0),r=n(27).find,a=n(83),s=n(15),o=!0,u=s("find");"find"in[]&&Array(1).find((function(){o=!1})),i({target:"Array",proto:!0,forced:o||!u},{find:function(t){return r(this,t,arguments.length>1?arguments[1]:void 0)}}),a("find")},326:function(t,e,n){"use strict";var i=n(295);n.n(i).a},327:function(t,e,n){"use strict";var i=n(296);n.n(i).a},329:function(t,e,n){"use strict";n.r(e);n(142),n(81),n(305);var i=n(282),r={name:"NavLink",props:{item:{required:!0}},computed:{link:function(){return Object(i.b)(this.item.link)},exact:function(){var t=this;return this.$site.locales?Object.keys(this.$site.locales).some((function(e){return e===t.link})):"/"===this.link},isNonHttpURI:function(){return Object(i.g)(this.link)||Object(i.h)(this.link)},isBlankTarget:function(){return"_blank"===this.target},isInternal:function(){return!Object(i.f)(this.link)&&!this.isBlankTarget},target:function(){return this.isNonHttpURI?null:this.item.target?this.item.target:Object(i.f)(this.link)?"_blank":""},rel:function(){return this.isNonHttpURI?null:this.item.rel?this.item.rel:this.isBlankTarget?"noopener noreferrer":""}},methods:{focusoutAction:function(){this.$emit("focusout")}}},a=n(19),s=Object(a.a)(r,(function(){var t=this,e=t.$createElement,n=t._self._c||e;return t.isInternal?n("RouterLink",{staticClass:"nav-link",attrs:{to:t.link,exact:t.exact},nativeOn:{focusout:function(e){return t.focusoutAction(e)}}},[t._v("\n "+t._s(t.item.text)+"\n")]):n("a",{staticClass:"nav-link external",attrs:{href:t.link,target:t.target,rel:t.rel},on:{focusout:t.focusoutAction}},[t._v("\n "+t._s(t.item.text)+"\n "),t.isBlankTarget?n("OutboundLink"):t._e()],1)}),[],!1,null,null,null).exports,o={name:"Home",components:{NavLink:s},computed:{data:function(){return this.$page.frontmatter},actionLink:function(){return{link:this.data.actionLink,text:this.data.actionText}}}},u=(n(308),Object(a.a)(o,(function(){var t=this,e=t.$createElement,n=t._self._c||e;return n("main",{staticClass:"home",attrs:{"aria-labelledby":"main-title"}},[n("header",{staticClass:"hero"},[t.data.heroImage?n("img",{attrs:{src:t.$withBase(t.data.heroImage),alt:t.data.heroAlt||"hero"}}):t._e(),t._v(" "),null!==t.data.heroText?n("h1",{attrs:{id:"main-title"}},[t._v("\n "+t._s(t.data.heroText||t.$title||"Hello")+"\n ")]):t._e(),t._v(" "),null!==t.data.tagline?n("p",{staticClass:"description"},[t._v("\n "+t._s(t.data.tagline||t.$description||"Welcome to your VuePress site")+"\n ")]):t._e(),t._v(" "),t.data.actionText&&t.data.actionLink?n("p",{staticClass:"action"},[n("NavLink",{staticClass:"action-button",attrs:{item:t.actionLink}})],1):t._e()]),t._v(" "),t.data.features&&t.data.features.length?n("div",{staticClass:"features"},t._l(t.data.features,(function(e,i){return n("div",{key:i,staticClass:"feature"},[n("h2",[t._v(t._s(e.title))]),t._v(" "),n("p",[t._v(t._s(e.details))])])})),0):t._e(),t._v(" "),n("Content",{staticClass:"theme-default-content custom"}),t._v(" "),t.data.footer?n("div",{staticClass:"footer"},[t._v("\n "+t._s(t.data.footer)+"\n ")]):t._e()],1)}),[],!1,null,null,null).exports),c=(n(309),n(20),n(149),n(143),n(298),n(25),n(151),n(283),n(299),n(145),n(57),n(300),n(301),n(313),n(58),n(148),n(153)),l=n.n(c),h=function(t,e){var n=arguments.length>2&&void 0!==arguments[2]?arguments[2]:null,i=l()(e,"title","");return l()(e,"frontmatter.tags")&&(i+=" ".concat(e.frontmatter.tags.join(" "))),n&&(i+=" ".concat(n)),f(t,i)},f=function(t,e){var n=function(t){return t.replace(/[-/\\^$*+?.()|[\]{}]/g,"\\$&")},i=new RegExp("[^\0-]"),r=t.split(/\s+/g).map((function(t){return t.trim()})).filter((function(t){return!!t}));if(i.test(t))return r.some((function(t){return e.toLowerCase().indexOf(t)>-1}));var a=t.endsWith(" ");return new RegExp(r.map((function(t,e){return r.length!==e+1||a?"(?=.*\\b".concat(n(t),"\\b)"):"(?=.*\\b".concat(n(t),")")})).join("")+".+","gi").test(e)},p={name:"SearchBox",data:function(){return{query:"",focused:!1,focusIndex:0,placeholder:void 0}},computed:{showSuggestions:function(){return this.focused&&this.suggestions&&this.suggestions.length},suggestions:function(){var t=this.query.trim().toLowerCase();if(t){for(var e=this.$site.pages,n=this.$site.themeConfig.searchMaxSuggestions||5,i=this.$localePath,r=[],a=0;a=n);a++){var s=e[a];if(this.getPageLocalePath(s)===i&&this.isSearchable(s))if(h(t,s))r.push(s);else if(s.headers)for(var o=0;o=n);o++){var u=s.headers[o];u.title&&h(t,s,u.title)&&r.push(Object.assign({},s,{path:s.path+"#"+u.slug,header:u}))}}return r}},alignRight:function(){return(this.$site.themeConfig.nav||[]).length+(this.$site.repo?1:0)<=2}},mounted:function(){this.placeholder=this.$site.themeConfig.searchPlaceholder||"",document.addEventListener("keydown",this.onHotkey)},beforeDestroy:function(){document.removeEventListener("keydown",this.onHotkey)},methods:{getPageLocalePath:function(t){for(var e in this.$site.locales||{})if("/"!==e&&0===t.path.indexOf(e))return e;return"/"},isSearchable:function(t){var e=null;return null===e||(e=Array.isArray(e)?e:new Array(e)).filter((function(e){return t.path.match(e)})).length>0},onHotkey:function(t){t.srcElement===document.body&&["s","/"].includes(t.key)&&(this.$refs.input.focus(),t.preventDefault())},onUp:function(){this.showSuggestions&&(this.focusIndex>0?this.focusIndex--:this.focusIndex=this.suggestions.length-1)},onDown:function(){this.showSuggestions&&(this.focusIndex "+t._s(e.header.title))]):t._e()])])})),0):t._e()])}),[],!1,null,null,null).exports),g=(n(315),Object(a.a)({},(function(){var t=this,e=t.$createElement,n=t._self._c||e;return n("div",{staticClass:"sidebar-button",on:{click:function(e){return t.$emit("toggle-sidebar")}}},[n("svg",{staticClass:"icon",attrs:{xmlns:"http://www.w3.org/2000/svg","aria-hidden":"true",role:"img",viewBox:"0 0 448 512"}},[n("path",{attrs:{fill:"currentColor",d:"M436 124H12c-6.627 0-12-5.373-12-12V80c0-6.627 5.373-12 12-12h424c6.627 0 12 5.373 12 12v32c0 6.627-5.373 12-12 12zm0 160H12c-6.627 0-12-5.373-12-12v-32c0-6.627 5.373-12 12-12h424c6.627 0 12 5.373 12 12v32c0 6.627-5.373 12-12 12zm0 160H12c-6.627 0-12-5.373-12-12v-32c0-6.627 5.373-12 12-12h424c6.627 0 12 5.373 12 12v32c0 6.627-5.373 12-12 12z"}})])])}),[],!1,null,null,null).exports),v=(n(152),n(35)),m=n(304),b=n(154),k=n.n(b),_={name:"DropdownLink",components:{NavLink:s,DropdownTransition:m.a},props:{item:{required:!0}},data:function(){return{open:!1}},computed:{dropdownAriaLabel:function(){return this.item.ariaLabel||this.item.text}},watch:{$route:function(){this.open=!1}},methods:{setOpen:function(t){this.open=t},isLastItemOfArray:function(t,e){return k()(e)===t}}},x=(n(317),{name:"NavLinks",components:{NavLink:s,DropdownLink:Object(a.a)(_,(function(){var t=this,e=t.$createElement,n=t._self._c||e;return n("div",{staticClass:"dropdown-wrapper",class:{open:t.open}},[n("button",{staticClass:"dropdown-title",attrs:{type:"button","aria-label":t.dropdownAriaLabel},on:{click:function(e){return t.setOpen(!t.open)}}},[n("span",{staticClass:"title"},[t._v(t._s(t.item.text))]),t._v(" "),n("span",{staticClass:"arrow",class:t.open?"down":"right"})]),t._v(" "),n("DropdownTransition",[n("ul",{directives:[{name:"show",rawName:"v-show",value:t.open,expression:"open"}],staticClass:"nav-dropdown"},t._l(t.item.items,(function(e,i){return n("li",{key:e.link||i,staticClass:"dropdown-item"},["links"===e.type?n("h4",[t._v("\n "+t._s(e.text)+"\n ")]):t._e(),t._v(" "),"links"===e.type?n("ul",{staticClass:"dropdown-subitem-wrapper"},t._l(e.items,(function(i){return n("li",{key:i.link,staticClass:"dropdown-subitem"},[n("NavLink",{attrs:{item:i},on:{focusout:function(n){t.isLastItemOfArray(i,e.items)&&t.isLastItemOfArray(e,t.item.items)&&t.setOpen(!1)}}})],1)})),0):n("NavLink",{attrs:{item:e},on:{focusout:function(n){t.isLastItemOfArray(e,t.item.items)&&t.setOpen(!1)}}})],1)})),0)])],1)}),[],!1,null,null,null).exports},computed:{userNav:function(){return this.$themeLocaleConfig.nav||this.$site.themeConfig.nav||[]},nav:function(){var t=this,e=this.$site.locales;if(e&&Object.keys(e).length>1){var n=this.$page.path,i=this.$router.options.routes,r=this.$site.themeConfig.locales||{},a={text:this.$themeLocaleConfig.selectText||"Languages",ariaLabel:this.$themeLocaleConfig.ariaLabel||"Select language",items:Object.keys(e).map((function(a){var s,o=e[a],u=r[a]&&r[a].label||o.lang;return o.lang===t.$lang?s=n:(s=n.replace(t.$localeConfig.path,a),i.some((function(t){return t.path===s}))||(s=a)),{text:u,link:s}}))};return[].concat(Object(v.a)(this.userNav),[a])}return this.userNav},userLinks:function(){return(this.nav||[]).map((function(t){return Object.assign(Object(i.j)(t),{items:(t.items||[]).map(i.j)})}))},repoLink:function(){var t=this.$site.themeConfig.repo;return t?/^https?:/.test(t)?t:"https://github.com/".concat(t):null},repoLabel:function(){if(this.repoLink){if(this.$site.themeConfig.repoLabel)return this.$site.themeConfig.repoLabel;for(var t=this.repoLink.match(/^https?:\/\/[^/]+/)[0],e=["GitHub","GitLab","Bitbucket"],n=0;nMath.abs(n)&&Math.abs(e)>40&&(e>0&&this.touchStart.x<=80?this.toggleSidebar(!0):this.toggleSidebar(!1))}}}),B=Object(a.a)(W,(function(){var t=this,e=t.$createElement,n=t._self._c||e;return n("div",{staticClass:"theme-container",class:t.pageClasses,on:{touchstart:t.onTouchStart,touchend:t.onTouchEnd}},[t.shouldShowNavbar?n("Navbar",{on:{"toggle-sidebar":t.toggleSidebar}}):t._e(),t._v(" "),n("div",{staticClass:"sidebar-mask",on:{click:function(e){return t.toggleSidebar(!1)}}}),t._v(" "),n("Sidebar",{attrs:{items:t.sidebarItems},on:{"toggle-sidebar":t.toggleSidebar},scopedSlots:t._u([{key:"top",fn:function(){return[t._t("sidebar-top")]},proxy:!0},{key:"bottom",fn:function(){return[t._t("sidebar-bottom")]},proxy:!0}],null,!0)}),t._v(" "),t.$page.frontmatter.home?n("Home"):n("Page",{attrs:{"sidebar-items":t.sidebarItems},scopedSlots:t._u([{key:"top",fn:function(){return[t._t("page-top")]},proxy:!0},{key:"bottom",fn:function(){return[t._t("page-bottom")]},proxy:!0}],null,!0)})],1)}),[],!1,null,null,null);e.default=B.exports}}]); \ No newline at end of file diff --git a/okhttps-doc/docs/.vuepress/dist/assets/js/3.972ca2ed.js b/okhttps-doc/docs/.vuepress/dist/assets/js/3.972ca2ed.js deleted file mode 100644 index 1f8e660f..00000000 --- a/okhttps-doc/docs/.vuepress/dist/assets/js/3.972ca2ed.js +++ /dev/null @@ -1 +0,0 @@ -(window.webpackJsonp=window.webpackJsonp||[]).push([[3],{297:function(t,e,n){},328:function(t,e,n){"use strict";var i=n(297);n.n(i).a},334:function(t,e,n){"use strict";n.r(e);var i={functional:!0,props:{type:{type:String,default:"tip"},text:String,vertical:{type:String,default:"top"}},render:function(t,e){var n=e.props,i=e.slots;return t("span",{class:["badge",n.type],style:{verticalAlign:n.vertical}},n.text||i().default)}},r=(n(328),n(19)),a=Object(r.a)(i,void 0,void 0,!1,null,"15b7b770",null);e.default=a.exports}}]); \ No newline at end of file diff --git a/okhttps-doc/docs/.vuepress/dist/assets/js/4.fe3bf0b0.js b/okhttps-doc/docs/.vuepress/dist/assets/js/4.fe3bf0b0.js deleted file mode 100644 index 6c638411..00000000 --- a/okhttps-doc/docs/.vuepress/dist/assets/js/4.fe3bf0b0.js +++ /dev/null @@ -1 +0,0 @@ -(window.webpackJsonp=window.webpackJsonp||[]).push([[4],{331:function(t,e,s){"use strict";s.r(e);var n=["There's nothing here.","How did we get here?","That's a Four-Oh-Four.","Looks like we've got some broken links."],o={methods:{getMsg:function(){return n[Math.floor(Math.random()*n.length)]}}},i=s(19),h=Object(i.a)(o,(function(){var t=this.$createElement,e=this._self._c||t;return e("div",{staticClass:"theme-container"},[e("div",{staticClass:"theme-default-content"},[e("h1",[this._v("404")]),this._v(" "),e("blockquote",[this._v(this._s(this.getMsg()))]),this._v(" "),e("RouterLink",{attrs:{to:"/"}},[this._v("\n Take me home.\n ")])],1)])}),[],!1,null,null,null);e.default=h.exports}}]); \ No newline at end of file diff --git a/okhttps-doc/docs/.vuepress/dist/assets/js/5.93d38f11.js b/okhttps-doc/docs/.vuepress/dist/assets/js/5.93d38f11.js deleted file mode 100644 index 8b93dda2..00000000 --- a/okhttps-doc/docs/.vuepress/dist/assets/js/5.93d38f11.js +++ /dev/null @@ -1 +0,0 @@ -(window.webpackJsonp=window.webpackJsonp||[]).push([[5],{330:function(e,t,a){"use strict";a.r(t);a(143),a(92),a(81);var n={props:{name:{type:String,default:"default"},isolated:{type:Boolean,default:!1},languages:Object},data:function(){return{selectedLanguage:Object.keys(this.languages)[0]}},computed:{root:function(){for(var e,t=this;e=t.$parent;)t=e;return t},localStorageKey:function(){return"vuepress-plugin-code-switcher@".concat(this.name)}},methods:{switchLanguage:function(e){if(this.isolated)return this.selectedLanguage=e;"undefined"!=typeof localStorage&&localStorage.setItem(this.localStorageKey,e),this.root.$emit("change",{name:this.name,value:e})}},created:function(){var e=this;if(!this.isolated){if("undefined"!=typeof localStorage){var t=localStorage.getItem(this.localStorageKey);t&&-1!==Object.keys(this.languages).indexOf(t)&&(this.selectedLanguage=t)}this.root.$on("change",(function(t){var a=t.name,n=t.value;a===e.name&&(e.selectedLanguage=n)}))}}},s=a(19),i=Object(s.a)(n,(function(){var e=this,t=e.$createElement,a=e._self._c||t;return a("div",{staticClass:"code-switcher"},[a("div",{staticClass:"tab-header"},[a("ul",e._l(e.languages,(function(t,n){return a("li",{key:n,class:{active:e.selectedLanguage===n},on:{click:function(t){return e.switchLanguage(n)}}},[e._v(" "+e._s(t)+"\n ")])})),0)]),e._v(" "),e._l(e.languages,(function(t,n){return a("div",{directives:[{name:"show",rawName:"v-show",value:n===e.selectedLanguage,expression:"shorthand === selectedLanguage"}],key:n,staticClass:"tab-content"},[e._t(n)],2)}))],2)}),[],!1,null,null,null);t.default=i.exports}}]); \ No newline at end of file diff --git a/okhttps-doc/docs/.vuepress/dist/assets/js/6.fd474f39.js b/okhttps-doc/docs/.vuepress/dist/assets/js/6.fd474f39.js deleted file mode 100644 index 66342655..00000000 --- a/okhttps-doc/docs/.vuepress/dist/assets/js/6.fd474f39.js +++ /dev/null @@ -1 +0,0 @@ -(window.webpackJsonp=window.webpackJsonp||[]).push([[6],{337:function(s,t,n){"use strict";n.r(t);var a=n(19),e=Object(a.a)({},(function(){var s=this,t=s.$createElement,n=s._self._c||t;return n("ContentSlotsDistributor",{attrs:{"slot-key":s.$parent.slotKey}},[n("div",{staticClass:"language-java line-numbers-mode"},[n("pre",{pre:!0,attrs:{class:"language-java"}},[n("code",[n("span",{pre:!0,attrs:{class:"token comment"}},[s._v("// 构建 HTTP")]),s._v("\n"),n("span",{pre:!0,attrs:{class:"token class-name"}},[s._v("HTTP")]),s._v(" http "),n("span",{pre:!0,attrs:{class:"token operator"}},[s._v("=")]),s._v(" HTTP"),n("span",{pre:!0,attrs:{class:"token punctuation"}},[s._v(".")]),n("span",{pre:!0,attrs:{class:"token function"}},[s._v("builder")]),n("span",{pre:!0,attrs:{class:"token punctuation"}},[s._v("(")]),n("span",{pre:!0,attrs:{class:"token punctuation"}},[s._v(")")]),s._v("\n "),n("span",{pre:!0,attrs:{class:"token punctuation"}},[s._v(".")]),n("span",{pre:!0,attrs:{class:"token function"}},[s._v("baseUrl")]),n("span",{pre:!0,attrs:{class:"token punctuation"}},[s._v("(")]),n("span",{pre:!0,attrs:{class:"token string"}},[s._v('"https://api.demo.com"')]),n("span",{pre:!0,attrs:{class:"token punctuation"}},[s._v(")")]),s._v("\n "),n("span",{pre:!0,attrs:{class:"token punctuation"}},[s._v(".")]),n("span",{pre:!0,attrs:{class:"token function"}},[s._v("build")]),n("span",{pre:!0,attrs:{class:"token punctuation"}},[s._v("(")]),n("span",{pre:!0,attrs:{class:"token punctuation"}},[s._v(")")]),n("span",{pre:!0,attrs:{class:"token punctuation"}},[s._v(";")]),s._v("\n\n"),n("span",{pre:!0,attrs:{class:"token comment"}},[s._v("// 同步请求")]),s._v("\n"),n("span",{pre:!0,attrs:{class:"token class-name"}},[s._v("List")]),n("span",{pre:!0,attrs:{class:"token generics"}},[n("span",{pre:!0,attrs:{class:"token punctuation"}},[s._v("<")]),n("span",{pre:!0,attrs:{class:"token class-name"}},[s._v("User")]),n("span",{pre:!0,attrs:{class:"token punctuation"}},[s._v(">")])]),s._v(" users "),n("span",{pre:!0,attrs:{class:"token operator"}},[s._v("=")]),s._v(" http"),n("span",{pre:!0,attrs:{class:"token punctuation"}},[s._v(".")]),n("span",{pre:!0,attrs:{class:"token function"}},[s._v("sync")]),n("span",{pre:!0,attrs:{class:"token punctuation"}},[s._v("(")]),n("span",{pre:!0,attrs:{class:"token string"}},[s._v('"/users"')]),n("span",{pre:!0,attrs:{class:"token punctuation"}},[s._v(")")]),s._v(" "),n("span",{pre:!0,attrs:{class:"token comment"}},[s._v("// http://api.demo.com/users")]),s._v("\n "),n("span",{pre:!0,attrs:{class:"token punctuation"}},[s._v(".")]),n("span",{pre:!0,attrs:{class:"token function"}},[s._v("get")]),n("span",{pre:!0,attrs:{class:"token punctuation"}},[s._v("(")]),n("span",{pre:!0,attrs:{class:"token punctuation"}},[s._v(")")]),s._v(" "),n("span",{pre:!0,attrs:{class:"token comment"}},[s._v("// GET请求")]),s._v("\n "),n("span",{pre:!0,attrs:{class:"token punctuation"}},[s._v(".")]),n("span",{pre:!0,attrs:{class:"token function"}},[s._v("getBody")]),n("span",{pre:!0,attrs:{class:"token punctuation"}},[s._v("(")]),n("span",{pre:!0,attrs:{class:"token punctuation"}},[s._v(")")]),s._v(" "),n("span",{pre:!0,attrs:{class:"token comment"}},[s._v("// 获取响应报文体")]),s._v("\n "),n("span",{pre:!0,attrs:{class:"token punctuation"}},[s._v(".")]),n("span",{pre:!0,attrs:{class:"token function"}},[s._v("toList")]),n("span",{pre:!0,attrs:{class:"token punctuation"}},[s._v("(")]),n("span",{pre:!0,attrs:{class:"token class-name"}},[s._v("User")]),n("span",{pre:!0,attrs:{class:"token punctuation"}},[s._v(".")]),n("span",{pre:!0,attrs:{class:"token keyword"}},[s._v("class")]),n("span",{pre:!0,attrs:{class:"token punctuation"}},[s._v(")")]),n("span",{pre:!0,attrs:{class:"token punctuation"}},[s._v(";")]),s._v(" "),n("span",{pre:!0,attrs:{class:"token comment"}},[s._v("// 得到目标数据")]),s._v("\n\n"),n("span",{pre:!0,attrs:{class:"token comment"}},[s._v("// 异步请求")]),s._v("\nhttp"),n("span",{pre:!0,attrs:{class:"token punctuation"}},[s._v(".")]),n("span",{pre:!0,attrs:{class:"token function"}},[s._v("async")]),n("span",{pre:!0,attrs:{class:"token punctuation"}},[s._v("(")]),n("span",{pre:!0,attrs:{class:"token string"}},[s._v('"/users/jack"')]),n("span",{pre:!0,attrs:{class:"token punctuation"}},[s._v(")")]),s._v(" "),n("span",{pre:!0,attrs:{class:"token comment"}},[s._v("// http://api.demo.com/users/jack")]),s._v("\n "),n("span",{pre:!0,attrs:{class:"token punctuation"}},[s._v(".")]),n("span",{pre:!0,attrs:{class:"token function"}},[s._v("setOnResponse")]),n("span",{pre:!0,attrs:{class:"token punctuation"}},[s._v("(")]),n("span",{pre:!0,attrs:{class:"token punctuation"}},[s._v("(")]),n("span",{pre:!0,attrs:{class:"token class-name"}},[s._v("HttpResult")]),s._v(" result"),n("span",{pre:!0,attrs:{class:"token punctuation"}},[s._v(")")]),s._v(" "),n("span",{pre:!0,attrs:{class:"token operator"}},[s._v("->")]),s._v(" "),n("span",{pre:!0,attrs:{class:"token punctuation"}},[s._v("{")]),s._v("\n "),n("span",{pre:!0,attrs:{class:"token comment"}},[s._v("// 得到目标数据")]),s._v("\n "),n("span",{pre:!0,attrs:{class:"token class-name"}},[s._v("User")]),s._v(" jack "),n("span",{pre:!0,attrs:{class:"token operator"}},[s._v("=")]),s._v(" result"),n("span",{pre:!0,attrs:{class:"token punctuation"}},[s._v(".")]),n("span",{pre:!0,attrs:{class:"token function"}},[s._v("getBody")]),n("span",{pre:!0,attrs:{class:"token punctuation"}},[s._v("(")]),n("span",{pre:!0,attrs:{class:"token punctuation"}},[s._v(")")]),n("span",{pre:!0,attrs:{class:"token punctuation"}},[s._v(".")]),n("span",{pre:!0,attrs:{class:"token function"}},[s._v("toBean")]),n("span",{pre:!0,attrs:{class:"token punctuation"}},[s._v("(")]),n("span",{pre:!0,attrs:{class:"token class-name"}},[s._v("User")]),n("span",{pre:!0,attrs:{class:"token punctuation"}},[s._v(".")]),n("span",{pre:!0,attrs:{class:"token keyword"}},[s._v("class")]),n("span",{pre:!0,attrs:{class:"token punctuation"}},[s._v(")")]),n("span",{pre:!0,attrs:{class:"token punctuation"}},[s._v(";")]),s._v("\n "),n("span",{pre:!0,attrs:{class:"token punctuation"}},[s._v("}")]),n("span",{pre:!0,attrs:{class:"token punctuation"}},[s._v(")")]),s._v("\n "),n("span",{pre:!0,attrs:{class:"token punctuation"}},[s._v(".")]),n("span",{pre:!0,attrs:{class:"token function"}},[s._v("get")]),n("span",{pre:!0,attrs:{class:"token punctuation"}},[s._v("(")]),n("span",{pre:!0,attrs:{class:"token punctuation"}},[s._v(")")]),n("span",{pre:!0,attrs:{class:"token punctuation"}},[s._v(";")]),s._v(" "),n("span",{pre:!0,attrs:{class:"token comment"}},[s._v("// GET请求")]),s._v("\n")])]),s._v(" "),n("div",{staticClass:"line-numbers-wrapper"},[n("span",{staticClass:"line-number"},[s._v("1")]),n("br"),n("span",{staticClass:"line-number"},[s._v("2")]),n("br"),n("span",{staticClass:"line-number"},[s._v("3")]),n("br"),n("span",{staticClass:"line-number"},[s._v("4")]),n("br"),n("span",{staticClass:"line-number"},[s._v("5")]),n("br"),n("span",{staticClass:"line-number"},[s._v("6")]),n("br"),n("span",{staticClass:"line-number"},[s._v("7")]),n("br"),n("span",{staticClass:"line-number"},[s._v("8")]),n("br"),n("span",{staticClass:"line-number"},[s._v("9")]),n("br"),n("span",{staticClass:"line-number"},[s._v("10")]),n("br"),n("span",{staticClass:"line-number"},[s._v("11")]),n("br"),n("span",{staticClass:"line-number"},[s._v("12")]),n("br"),n("span",{staticClass:"line-number"},[s._v("13")]),n("br"),n("span",{staticClass:"line-number"},[s._v("14")]),n("br"),n("span",{staticClass:"line-number"},[s._v("15")]),n("br"),n("span",{staticClass:"line-number"},[s._v("16")]),n("br"),n("span",{staticClass:"line-number"},[s._v("17")]),n("br"),n("span",{staticClass:"line-number"},[s._v("18")]),n("br")])]),s._v(" "),n("p",[n("strong",[n("center",[s._v("竟然不到 "),n("font",{attrs:{size:"5"}},[s._v("15")]),s._v(" 秒，你已学会 "),n("font",{attrs:{size:"6"}},[s._v("90")]),s._v("% 的精髓！")],1)],1),s._v(" "),n("center",[n("RouterLink",{attrs:{to:"/guide/"}},[n("strong",[s._v("了解更多")])])],1)],1)])}),[],!1,null,null,null);t.default=e.exports}}]); \ No newline at end of file diff --git a/okhttps-doc/docs/.vuepress/dist/assets/js/7.51e5642d.js b/okhttps-doc/docs/.vuepress/dist/assets/js/7.51e5642d.js deleted file mode 100644 index c76c8a33..00000000 --- a/okhttps-doc/docs/.vuepress/dist/assets/js/7.51e5642d.js +++ /dev/null @@ -1 +0,0 @@ -(window.webpackJsonp=window.webpackJsonp||[]).push([[7],{338:function(s,t,a){"use strict";a.r(t);var n=a(19),e=Object(n.a)({},(function(){var s=this,t=s.$createElement,a=s._self._c||t;return a("ContentSlotsDistributor",{attrs:{"slot-key":s.$parent.slotKey}},[a("h1",{attrs:{id:"起步"}},[a("a",{staticClass:"header-anchor",attrs:{href:"#起步"}},[s._v("#")]),s._v(" 起步")]),s._v(" "),a("p",[s._v("OkHttps 是近期开源的对 OkHttp3 轻量封装的框架，它独创的异步预处理器，特色的标签，灵活的上传下载进度监听与过程控制功能，在轻松解决很多原本另人头疼问题的同时，设计上也力求纯粹与优雅。")]),s._v(" "),a("ul",[a("li",[s._v("链式调用，一点到底")]),s._v(" "),a("li",[s._v("BaseURL、URL占位符、JSON自动封装与解析")]),s._v(" "),a("li",[s._v("同步拦截器、异步预处理器、回调执行器、全局监听、回调阻断")]),s._v(" "),a("li",[s._v("文件上传下载（过程控制、进度监听）")]),s._v(" "),a("li",[s._v("单方法回调，充分利用 Lambda 表达式")]),s._v(" "),a("li",[s._v("TCP连接池、Http2")])]),s._v(" "),a("div",{staticClass:"custom-block tip"},[a("p",{staticClass:"custom-block-title"},[s._v("TIP")]),s._v(" "),a("ul",[a("li",[s._v("OkHttps 非常轻量（59Kb），仅是 Retrofit（124Kb）的一半，并且更加的开箱即用，API 也更加自然和语义化。")]),s._v(" "),a("li",[s._v("OkHttps 是一个纯粹的 Java 网络开发包，并不依赖 Android，这一点和 Retrofit 不同")]),s._v(" "),a("li",[s._v("OkHttps 用起来很优美，可以像 RxJava 那样链式用，却比 RxJava 更简单。")])])]),s._v(" "),a("h2",{attrs:{id:"安装"}},[a("a",{staticClass:"header-anchor",attrs:{href:"#安装"}},[s._v("#")]),s._v(" 安装")]),s._v(" "),a("h3",{attrs:{id:"maven"}},[a("a",{staticClass:"header-anchor",attrs:{href:"#maven"}},[s._v("#")]),s._v(" Maven")]),s._v(" "),a("div",{staticClass:"language-xml line-numbers-mode"},[a("pre",{pre:!0,attrs:{class:"language-xml"}},[a("code",[a("span",{pre:!0,attrs:{class:"token tag"}},[a("span",{pre:!0,attrs:{class:"token tag"}},[a("span",{pre:!0,attrs:{class:"token punctuation"}},[s._v("<")]),s._v("dependency")]),a("span",{pre:!0,attrs:{class:"token punctuation"}},[s._v(">")])]),s._v("\n "),a("span",{pre:!0,attrs:{class:"token tag"}},[a("span",{pre:!0,attrs:{class:"token tag"}},[a("span",{pre:!0,attrs:{class:"token punctuation"}},[s._v("<")]),s._v("groupId")]),a("span",{pre:!0,attrs:{class:"token punctuation"}},[s._v(">")])]),s._v("com.ejlchina"),a("span",{pre:!0,attrs:{class:"token tag"}},[a("span",{pre:!0,attrs:{class:"token tag"}},[a("span",{pre:!0,attrs:{class:"token punctuation"}},[s._v("")])]),s._v("\n "),a("span",{pre:!0,attrs:{class:"token tag"}},[a("span",{pre:!0,attrs:{class:"token tag"}},[a("span",{pre:!0,attrs:{class:"token punctuation"}},[s._v("<")]),s._v("artifactId")]),a("span",{pre:!0,attrs:{class:"token punctuation"}},[s._v(">")])]),s._v("okhttps"),a("span",{pre:!0,attrs:{class:"token tag"}},[a("span",{pre:!0,attrs:{class:"token tag"}},[a("span",{pre:!0,attrs:{class:"token punctuation"}},[s._v("")])]),s._v("\n "),a("span",{pre:!0,attrs:{class:"token tag"}},[a("span",{pre:!0,attrs:{class:"token tag"}},[a("span",{pre:!0,attrs:{class:"token punctuation"}},[s._v("<")]),s._v("version")]),a("span",{pre:!0,attrs:{class:"token punctuation"}},[s._v(">")])]),s._v("1.0.5"),a("span",{pre:!0,attrs:{class:"token tag"}},[a("span",{pre:!0,attrs:{class:"token tag"}},[a("span",{pre:!0,attrs:{class:"token punctuation"}},[s._v("")])]),s._v("\n"),a("span",{pre:!0,attrs:{class:"token tag"}},[a("span",{pre:!0,attrs:{class:"token tag"}},[a("span",{pre:!0,attrs:{class:"token punctuation"}},[s._v("")])]),s._v("\n")])]),s._v(" "),a("div",{staticClass:"line-numbers-wrapper"},[a("span",{staticClass:"line-number"},[s._v("1")]),a("br"),a("span",{staticClass:"line-number"},[s._v("2")]),a("br"),a("span",{staticClass:"line-number"},[s._v("3")]),a("br"),a("span",{staticClass:"line-number"},[s._v("4")]),a("br"),a("span",{staticClass:"line-number"},[s._v("5")]),a("br")])]),a("h3",{attrs:{id:"gradle"}},[a("a",{staticClass:"header-anchor",attrs:{href:"#gradle"}},[s._v("#")]),s._v(" Gradle")]),s._v(" "),a("div",{staticClass:"language-groovy line-numbers-mode"},[a("pre",{pre:!0,attrs:{class:"language-groovy"}},[a("code",[s._v("implementation "),a("span",{pre:!0,attrs:{class:"token string"}},[s._v("'com.ejlchina:okhttps:1.0.5'")]),s._v("\n")])]),s._v(" "),a("div",{staticClass:"line-numbers-wrapper"},[a("span",{staticClass:"line-number"},[s._v("1")]),a("br")])]),a("p",[s._v("安卓中使用需要把 JDK 版本调成 1.8，在 app 模块的 build.gradle 中加入以下配置即可：")]),s._v(" "),a("div",{staticClass:"language-groovy line-numbers-mode"},[a("pre",{pre:!0,attrs:{class:"language-groovy"}},[a("code",[s._v("android "),a("span",{pre:!0,attrs:{class:"token punctuation"}},[s._v("{")]),s._v("\n "),a("span",{pre:!0,attrs:{class:"token comment"}},[s._v("// 省略其它配置..")]),s._v("\n compileOptions "),a("span",{pre:!0,attrs:{class:"token punctuation"}},[s._v("{")]),s._v("\n sourceCompatibility "),a("span",{pre:!0,attrs:{class:"token operator"}},[s._v("=")]),s._v(" "),a("span",{pre:!0,attrs:{class:"token number"}},[s._v("1.8")]),s._v("\n targetCompatibility "),a("span",{pre:!0,attrs:{class:"token operator"}},[s._v("=")]),s._v(" "),a("span",{pre:!0,attrs:{class:"token number"}},[s._v("1.8")]),s._v("\n "),a("span",{pre:!0,attrs:{class:"token punctuation"}},[s._v("}")]),s._v("\n"),a("span",{pre:!0,attrs:{class:"token punctuation"}},[s._v("}")]),s._v("\n")])]),s._v(" "),a("div",{staticClass:"line-numbers-wrapper"},[a("span",{staticClass:"line-number"},[s._v("1")]),a("br"),a("span",{staticClass:"line-number"},[s._v("2")]),a("br"),a("span",{staticClass:"line-number"},[s._v("3")]),a("br"),a("span",{staticClass:"line-number"},[s._v("4")]),a("br"),a("span",{staticClass:"line-number"},[s._v("5")]),a("br"),a("span",{staticClass:"line-number"},[s._v("6")]),a("br"),a("span",{staticClass:"line-number"},[s._v("7")]),a("br")])]),a("h2",{attrs:{id:"使用"}},[a("a",{staticClass:"header-anchor",attrs:{href:"#使用"}},[s._v("#")]),s._v(" 使用")]),s._v(" "),a("h3",{attrs:{id:"构建实例"}},[a("a",{staticClass:"header-anchor",attrs:{href:"#构建实例"}},[s._v("#")]),s._v(" 构建实例")]),s._v(" "),a("div",{staticClass:"language-java line-numbers-mode"},[a("pre",{pre:!0,attrs:{class:"language-java"}},[a("code",[a("span",{pre:!0,attrs:{class:"token class-name"}},[s._v("HTTP")]),s._v(" http "),a("span",{pre:!0,attrs:{class:"token operator"}},[s._v("=")]),s._v(" HTTP"),a("span",{pre:!0,attrs:{class:"token punctuation"}},[s._v(".")]),a("span",{pre:!0,attrs:{class:"token function"}},[s._v("builder")]),a("span",{pre:!0,attrs:{class:"token punctuation"}},[s._v("(")]),a("span",{pre:!0,attrs:{class:"token punctuation"}},[s._v(")")]),a("span",{pre:!0,attrs:{class:"token punctuation"}},[s._v(".")]),a("span",{pre:!0,attrs:{class:"token function"}},[s._v("build")]),a("span",{pre:!0,attrs:{class:"token punctuation"}},[s._v("(")]),a("span",{pre:!0,attrs:{class:"token punctuation"}},[s._v(")")]),a("span",{pre:!0,attrs:{class:"token punctuation"}},[s._v(";")]),s._v("\n")])]),s._v(" "),a("div",{staticClass:"line-numbers-wrapper"},[a("span",{staticClass:"line-number"},[s._v("1")]),a("br")])]),a("p",[s._v("以上代码构建了一个最简单的"),a("code",[s._v("HTTP")]),s._v("实例，它拥有以下方法：")]),s._v(" "),a("ul",[a("li",[a("code",[s._v("sync(String url)")]),s._v(" 开始一个同步请求")]),s._v(" "),a("li",[a("code",[s._v("async(String url)")]),s._v(" 开始一个异步请求")]),s._v(" "),a("li",[a("code",[s._v("cancel(String tag)")]),s._v(" 按标签取消请求")]),s._v(" "),a("li",[a("code",[s._v("cancelAll()")]),s._v(" 取消所有HTTP任务，包括同步和异步")]),s._v(" "),a("li",[a("code",[s._v("request(Request request)")]),s._v(" OkHttp 原生请求")]),s._v(" "),a("li",[a("code",[s._v("webSocket(Request request, WebSocketListener listener)")]),s._v(" WebSocket通讯")])]),s._v(" "),a("p",[s._v("为了使用方便，在构建的时候，我们更愿意指定一个"),a("code",[s._v("BaseUrl")]),s._v("（详见 "),a("RouterLink",{attrs:{to:"/guide/configuration.html#设置-baseurl"}},[s._v("设置 BaseUrl")]),s._v("）:")],1),s._v(" "),a("div",{staticClass:"language-java line-numbers-mode"},[a("pre",{pre:!0,attrs:{class:"language-java"}},[a("code",[a("span",{pre:!0,attrs:{class:"token class-name"}},[s._v("HTTP")]),s._v(" http "),a("span",{pre:!0,attrs:{class:"token operator"}},[s._v("=")]),s._v(" HTTP"),a("span",{pre:!0,attrs:{class:"token punctuation"}},[s._v(".")]),a("span",{pre:!0,attrs:{class:"token function"}},[s._v("builder")]),a("span",{pre:!0,attrs:{class:"token punctuation"}},[s._v("(")]),a("span",{pre:!0,attrs:{class:"token punctuation"}},[s._v(")")]),s._v("\n "),a("span",{pre:!0,attrs:{class:"token punctuation"}},[s._v(".")]),a("span",{pre:!0,attrs:{class:"token function"}},[s._v("baseUrl")]),a("span",{pre:!0,attrs:{class:"token punctuation"}},[s._v("(")]),a("span",{pre:!0,attrs:{class:"token string"}},[s._v('"http://api.demo.com"')]),a("span",{pre:!0,attrs:{class:"token punctuation"}},[s._v(")")]),s._v("\n "),a("span",{pre:!0,attrs:{class:"token punctuation"}},[s._v(".")]),a("span",{pre:!0,attrs:{class:"token function"}},[s._v("build")]),a("span",{pre:!0,attrs:{class:"token punctuation"}},[s._v("(")]),a("span",{pre:!0,attrs:{class:"token punctuation"}},[s._v(")")]),a("span",{pre:!0,attrs:{class:"token punctuation"}},[s._v(";")]),s._v("\n")])]),s._v(" "),a("div",{staticClass:"line-numbers-wrapper"},[a("span",{staticClass:"line-number"},[s._v("1")]),a("br"),a("span",{staticClass:"line-number"},[s._v("2")]),a("br"),a("span",{staticClass:"line-number"},[s._v("3")]),a("br")])]),a("p",[s._v("为了简化文档，下文中出现的"),a("code",[s._v("http")]),s._v("均是在构建时设置了"),a("code",[s._v("BaseUrl")]),s._v("的"),a("code",[s._v("HTTP")]),s._v("实例。")]),s._v(" "),a("h3",{attrs:{id:"同步请求"}},[a("a",{staticClass:"header-anchor",attrs:{href:"#同步请求"}},[s._v("#")]),s._v(" 同步请求")]),s._v(" "),a("p",[s._v("使用方法"),a("code",[s._v("sync(String url)")]),s._v("开始一个同步请求：")]),s._v(" "),a("div",{staticClass:"language-java line-numbers-mode"},[a("pre",{pre:!0,attrs:{class:"language-java"}},[a("code",[a("span",{pre:!0,attrs:{class:"token class-name"}},[s._v("List")]),a("span",{pre:!0,attrs:{class:"token generics"}},[a("span",{pre:!0,attrs:{class:"token punctuation"}},[s._v("<")]),a("span",{pre:!0,attrs:{class:"token class-name"}},[s._v("User")]),a("span",{pre:!0,attrs:{class:"token punctuation"}},[s._v(">")])]),s._v(" users "),a("span",{pre:!0,attrs:{class:"token operator"}},[s._v("=")]),s._v(" http"),a("span",{pre:!0,attrs:{class:"token punctuation"}},[s._v(".")]),a("span",{pre:!0,attrs:{class:"token function"}},[s._v("sync")]),a("span",{pre:!0,attrs:{class:"token punctuation"}},[s._v("(")]),a("span",{pre:!0,attrs:{class:"token string"}},[s._v('"/users"')]),a("span",{pre:!0,attrs:{class:"token punctuation"}},[s._v(")")]),s._v(" "),a("span",{pre:!0,attrs:{class:"token comment"}},[s._v("// http://api.demo.com/users")]),s._v("\n "),a("span",{pre:!0,attrs:{class:"token punctuation"}},[s._v(".")]),a("span",{pre:!0,attrs:{class:"token function"}},[s._v("get")]),a("span",{pre:!0,attrs:{class:"token punctuation"}},[s._v("(")]),a("span",{pre:!0,attrs:{class:"token punctuation"}},[s._v(")")]),s._v(" "),a("span",{pre:!0,attrs:{class:"token comment"}},[s._v("// GET请求")]),s._v("\n "),a("span",{pre:!0,attrs:{class:"token punctuation"}},[s._v(".")]),a("span",{pre:!0,attrs:{class:"token function"}},[s._v("getBody")]),a("span",{pre:!0,attrs:{class:"token punctuation"}},[s._v("(")]),a("span",{pre:!0,attrs:{class:"token punctuation"}},[s._v(")")]),s._v(" "),a("span",{pre:!0,attrs:{class:"token comment"}},[s._v("// 获取响应报文体")]),s._v("\n "),a("span",{pre:!0,attrs:{class:"token punctuation"}},[s._v(".")]),a("span",{pre:!0,attrs:{class:"token function"}},[s._v("toList")]),a("span",{pre:!0,attrs:{class:"token punctuation"}},[s._v("(")]),a("span",{pre:!0,attrs:{class:"token class-name"}},[s._v("User")]),a("span",{pre:!0,attrs:{class:"token punctuation"}},[s._v(".")]),a("span",{pre:!0,attrs:{class:"token keyword"}},[s._v("class")]),a("span",{pre:!0,attrs:{class:"token punctuation"}},[s._v(")")]),a("span",{pre:!0,attrs:{class:"token punctuation"}},[s._v(";")]),s._v(" "),a("span",{pre:!0,attrs:{class:"token comment"}},[s._v("// 得到目标数据")]),s._v("\n")])]),s._v(" "),a("div",{staticClass:"line-numbers-wrapper"},[a("span",{staticClass:"line-number"},[s._v("1")]),a("br"),a("span",{staticClass:"line-number"},[s._v("2")]),a("br"),a("span",{staticClass:"line-number"},[s._v("3")]),a("br"),a("span",{staticClass:"line-number"},[s._v("4")]),a("br")])]),a("p",[s._v("方法"),a("code",[s._v("sync")]),s._v("返回一个同步"),a("code",[s._v("HttpTask")]),s._v("，可链式使用。")]),s._v(" "),a("h3",{attrs:{id:"异步请求"}},[a("a",{staticClass:"header-anchor",attrs:{href:"#异步请求"}},[s._v("#")]),s._v(" 异步请求")]),s._v(" "),a("p",[s._v("使用方法"),a("code",[s._v("async(String url)")]),s._v("开始一个异步请求：")]),s._v(" "),a("div",{staticClass:"language-java line-numbers-mode"},[a("pre",{pre:!0,attrs:{class:"language-java"}},[a("code",[s._v("http"),a("span",{pre:!0,attrs:{class:"token punctuation"}},[s._v(".")]),a("span",{pre:!0,attrs:{class:"token function"}},[s._v("async")]),a("span",{pre:!0,attrs:{class:"token punctuation"}},[s._v("(")]),a("span",{pre:!0,attrs:{class:"token string"}},[s._v('"/users/1"')]),a("span",{pre:!0,attrs:{class:"token punctuation"}},[s._v(")")]),s._v(" "),a("span",{pre:!0,attrs:{class:"token comment"}},[s._v("// http://api.demo.com/users/1")]),s._v("\n "),a("span",{pre:!0,attrs:{class:"token punctuation"}},[s._v(".")]),a("span",{pre:!0,attrs:{class:"token function"}},[s._v("setOnResponse")]),a("span",{pre:!0,attrs:{class:"token punctuation"}},[s._v("(")]),a("span",{pre:!0,attrs:{class:"token punctuation"}},[s._v("(")]),a("span",{pre:!0,attrs:{class:"token class-name"}},[s._v("HttpResult")]),s._v(" result"),a("span",{pre:!0,attrs:{class:"token punctuation"}},[s._v(")")]),s._v(" "),a("span",{pre:!0,attrs:{class:"token operator"}},[s._v("->")]),s._v(" "),a("span",{pre:!0,attrs:{class:"token punctuation"}},[s._v("{")]),s._v("\n "),a("span",{pre:!0,attrs:{class:"token comment"}},[s._v("// 得到目标数据")]),s._v("\n "),a("span",{pre:!0,attrs:{class:"token class-name"}},[s._v("User")]),s._v(" user "),a("span",{pre:!0,attrs:{class:"token operator"}},[s._v("=")]),s._v(" result"),a("span",{pre:!0,attrs:{class:"token punctuation"}},[s._v(".")]),a("span",{pre:!0,attrs:{class:"token function"}},[s._v("getBody")]),a("span",{pre:!0,attrs:{class:"token punctuation"}},[s._v("(")]),a("span",{pre:!0,attrs:{class:"token punctuation"}},[s._v(")")]),a("span",{pre:!0,attrs:{class:"token punctuation"}},[s._v(".")]),a("span",{pre:!0,attrs:{class:"token function"}},[s._v("toBean")]),a("span",{pre:!0,attrs:{class:"token punctuation"}},[s._v("(")]),a("span",{pre:!0,attrs:{class:"token class-name"}},[s._v("User")]),a("span",{pre:!0,attrs:{class:"token punctuation"}},[s._v(".")]),a("span",{pre:!0,attrs:{class:"token keyword"}},[s._v("class")]),a("span",{pre:!0,attrs:{class:"token punctuation"}},[s._v(")")]),a("span",{pre:!0,attrs:{class:"token punctuation"}},[s._v(";")]),s._v("\n "),a("span",{pre:!0,attrs:{class:"token punctuation"}},[s._v("}")]),a("span",{pre:!0,attrs:{class:"token punctuation"}},[s._v(")")]),s._v("\n "),a("span",{pre:!0,attrs:{class:"token punctuation"}},[s._v(".")]),a("span",{pre:!0,attrs:{class:"token function"}},[s._v("get")]),a("span",{pre:!0,attrs:{class:"token punctuation"}},[s._v("(")]),a("span",{pre:!0,attrs:{class:"token punctuation"}},[s._v(")")]),a("span",{pre:!0,attrs:{class:"token punctuation"}},[s._v(";")]),s._v(" "),a("span",{pre:!0,attrs:{class:"token comment"}},[s._v("// GET请求")]),s._v("\n")])]),s._v(" "),a("div",{staticClass:"line-numbers-wrapper"},[a("span",{staticClass:"line-number"},[s._v("1")]),a("br"),a("span",{staticClass:"line-number"},[s._v("2")]),a("br"),a("span",{staticClass:"line-number"},[s._v("3")]),a("br"),a("span",{staticClass:"line-number"},[s._v("4")]),a("br"),a("span",{staticClass:"line-number"},[s._v("5")]),a("br"),a("span",{staticClass:"line-number"},[s._v("6")]),a("br")])]),a("p",[s._v("方法"),a("code",[s._v("async")]),s._v("返回一个异步"),a("code",[s._v("HttpTask")]),s._v("，可链式使用。")]),s._v(" "),a("p",[a("strong",[s._v("至此，你已轻松学会了 OkHttps 95% 的常规用法！但别急，后面还有更精彩的。")])])])}),[],!1,null,null,null);t.default=e.exports}}]); \ No newline at end of file diff --git a/okhttps-doc/docs/.vuepress/dist/assets/js/8.d296d289.js b/okhttps-doc/docs/.vuepress/dist/assets/js/8.d296d289.js deleted file mode 100644 index 791bf3d0..00000000 --- a/okhttps-doc/docs/.vuepress/dist/assets/js/8.d296d289.js +++ /dev/null @@ -1 +0,0 @@ -(window.webpackJsonp=window.webpackJsonp||[]).push([[8],{336:function(s,t,a){"use strict";a.r(t);var n=a(19),e=Object(n.a)({},(function(){var s=this,t=s.$createElement,a=s._self._c||t;return a("ContentSlotsDistributor",{attrs:{"slot-key":s.$parent.slotKey}},[a("h1",{attrs:{id:"安卓"}},[a("a",{staticClass:"header-anchor",attrs:{href:"#安卓"}},[s._v("#")]),s._v(" 安卓")]),s._v(" "),a("h2",{attrs:{id:"回调线程切换"}},[a("a",{staticClass:"header-anchor",attrs:{href:"#回调线程切换"}},[s._v("#")]),s._v(" 回调线程切换")]),s._v(" "),a("p",[s._v("在 Android 开发中，经常会把某些代码放到特点的线程去执行，比如网络请求响应后的页面更新在主线程（UI线程）执行，而保存文件则在IO线程操作。OkHttps 为这类问题提供了良好的方案。")]),s._v(" "),a("p",[s._v("在 "),a("strong",[s._v("默认")]),s._v(" 情况下，"),a("strong",[s._v("所有回调")]),s._v(" 函数都会 "),a("strong",[s._v("在 IO 线程")]),s._v(" 执行。为什么会设计如此呢？这是因为 OkHttps 只是纯粹的 Java 领域 Http工具包，本身对 Android 不会有任何依赖，因此也不知 Android 的 UI 线程为何物。这么设计也让它在 Android 之外有更多的可能性。")]),s._v(" "),a("h3",{attrs:{id:"配置"}},[a("a",{staticClass:"header-anchor",attrs:{href:"#配置"}},[s._v("#")]),s._v(" 配置")]),s._v(" "),a("p",[s._v("但是在 Android 里使用 OkHttps 的话，UI线程的问题能否优雅的解决呢？当然可以！简单粗暴的方法就是配置一个 回调执行器：")]),s._v(" "),a("div",{staticClass:"language-java line-numbers-mode"},[a("pre",{pre:!0,attrs:{class:"language-java"}},[a("code",[a("span",{pre:!0,attrs:{class:"token class-name"}},[s._v("HTTP")]),s._v(" http "),a("span",{pre:!0,attrs:{class:"token operator"}},[s._v("=")]),s._v(" HTTP"),a("span",{pre:!0,attrs:{class:"token punctuation"}},[s._v(".")]),a("span",{pre:!0,attrs:{class:"token function"}},[s._v("builder")]),a("span",{pre:!0,attrs:{class:"token punctuation"}},[s._v("(")]),a("span",{pre:!0,attrs:{class:"token punctuation"}},[s._v(")")]),s._v("\n "),a("span",{pre:!0,attrs:{class:"token punctuation"}},[s._v(".")]),a("span",{pre:!0,attrs:{class:"token function"}},[s._v("callbackExecutor")]),a("span",{pre:!0,attrs:{class:"token punctuation"}},[s._v("(")]),a("span",{pre:!0,attrs:{class:"token punctuation"}},[s._v("(")]),a("span",{pre:!0,attrs:{class:"token class-name"}},[s._v("Runnable")]),s._v(" run"),a("span",{pre:!0,attrs:{class:"token punctuation"}},[s._v(")")]),s._v(" "),a("span",{pre:!0,attrs:{class:"token operator"}},[s._v("->")]),s._v(" "),a("span",{pre:!0,attrs:{class:"token punctuation"}},[s._v("{")]),s._v("\n "),a("span",{pre:!0,attrs:{class:"token comment"}},[s._v("// 实际编码中可以吧 Handler 提出来，不需要每次执行回调都重新创建")]),s._v("\n "),a("span",{pre:!0,attrs:{class:"token keyword"}},[s._v("new")]),s._v(" "),a("span",{pre:!0,attrs:{class:"token class-name"}},[s._v("Handler")]),a("span",{pre:!0,attrs:{class:"token punctuation"}},[s._v("(")]),a("span",{pre:!0,attrs:{class:"token class-name"}},[s._v("Looper")]),a("span",{pre:!0,attrs:{class:"token punctuation"}},[s._v(".")]),a("span",{pre:!0,attrs:{class:"token function"}},[s._v("getMainLooper")]),a("span",{pre:!0,attrs:{class:"token punctuation"}},[s._v("(")]),a("span",{pre:!0,attrs:{class:"token punctuation"}},[s._v(")")]),a("span",{pre:!0,attrs:{class:"token punctuation"}},[s._v(")")]),a("span",{pre:!0,attrs:{class:"token punctuation"}},[s._v(".")]),a("span",{pre:!0,attrs:{class:"token function"}},[s._v("post")]),a("span",{pre:!0,attrs:{class:"token punctuation"}},[s._v("(")]),s._v("run"),a("span",{pre:!0,attrs:{class:"token punctuation"}},[s._v(")")]),a("span",{pre:!0,attrs:{class:"token punctuation"}},[s._v(";")]),s._v(" "),a("span",{pre:!0,attrs:{class:"token comment"}},[s._v("// 在主线程执行")]),s._v("\n "),a("span",{pre:!0,attrs:{class:"token punctuation"}},[s._v("}")]),a("span",{pre:!0,attrs:{class:"token punctuation"}},[s._v(")")]),s._v("\n "),a("span",{pre:!0,attrs:{class:"token punctuation"}},[s._v(".")]),a("span",{pre:!0,attrs:{class:"token function"}},[s._v("build")]),a("span",{pre:!0,attrs:{class:"token punctuation"}},[s._v("(")]),a("span",{pre:!0,attrs:{class:"token punctuation"}},[s._v(")")]),a("span",{pre:!0,attrs:{class:"token punctuation"}},[s._v(";")]),s._v("\n")])]),s._v(" "),a("div",{staticClass:"line-numbers-wrapper"},[a("span",{staticClass:"line-number"},[s._v("1")]),a("br"),a("span",{staticClass:"line-number"},[s._v("2")]),a("br"),a("span",{staticClass:"line-number"},[s._v("3")]),a("br"),a("span",{staticClass:"line-number"},[s._v("4")]),a("br"),a("span",{staticClass:"line-number"},[s._v("5")]),a("br"),a("span",{staticClass:"line-number"},[s._v("6")]),a("br")])]),a("h3",{attrs:{id:"用例"}},[a("a",{staticClass:"header-anchor",attrs:{href:"#用例"}},[s._v("#")]),s._v(" 用例")]),s._v(" "),a("p",[s._v("上述代码便实现了让 "),a("strong",[s._v("所有")]),s._v(" 的 "),a("strong",[s._v("回调函数")]),s._v(" 都在 "),a("strong",[s._v("主线程（UI线程）")]),s._v(" 执行的目的，如：")]),s._v(" "),a("div",{staticClass:"language-java line-numbers-mode"},[a("pre",{pre:!0,attrs:{class:"language-java"}},[a("code",[s._v("http"),a("span",{pre:!0,attrs:{class:"token punctuation"}},[s._v(".")]),a("span",{pre:!0,attrs:{class:"token function"}},[s._v("async")]),a("span",{pre:!0,attrs:{class:"token punctuation"}},[s._v("(")]),a("span",{pre:!0,attrs:{class:"token string"}},[s._v('"/users"')]),a("span",{pre:!0,attrs:{class:"token punctuation"}},[s._v(")")]),s._v("\n "),a("span",{pre:!0,attrs:{class:"token punctuation"}},[s._v(".")]),a("span",{pre:!0,attrs:{class:"token function"}},[s._v("addBodyParam")]),a("span",{pre:!0,attrs:{class:"token punctuation"}},[s._v("(")]),a("span",{pre:!0,attrs:{class:"token string"}},[s._v('"name"')]),a("span",{pre:!0,attrs:{class:"token punctuation"}},[s._v(",")]),s._v(" "),a("span",{pre:!0,attrs:{class:"token string"}},[s._v('"Jack"')]),a("span",{pre:!0,attrs:{class:"token punctuation"}},[s._v(")")]),s._v("\n "),a("span",{pre:!0,attrs:{class:"token punctuation"}},[s._v(".")]),a("span",{pre:!0,attrs:{class:"token function"}},[s._v("setOnProcess")]),a("span",{pre:!0,attrs:{class:"token punctuation"}},[s._v("(")]),a("span",{pre:!0,attrs:{class:"token punctuation"}},[s._v("(")]),a("span",{pre:!0,attrs:{class:"token class-name"}},[s._v("Process")]),s._v(" process"),a("span",{pre:!0,attrs:{class:"token punctuation"}},[s._v(")")]),s._v(" "),a("span",{pre:!0,attrs:{class:"token operator"}},[s._v("->")]),s._v(" "),a("span",{pre:!0,attrs:{class:"token punctuation"}},[s._v("{")]),s._v("\n "),a("span",{pre:!0,attrs:{class:"token comment"}},[s._v("// 在主线程执行")]),s._v("\n "),a("span",{pre:!0,attrs:{class:"token punctuation"}},[s._v("}")]),a("span",{pre:!0,attrs:{class:"token punctuation"}},[s._v(")")]),s._v("\n "),a("span",{pre:!0,attrs:{class:"token punctuation"}},[s._v(".")]),a("span",{pre:!0,attrs:{class:"token function"}},[s._v("setOnResponse")]),a("span",{pre:!0,attrs:{class:"token punctuation"}},[s._v("(")]),a("span",{pre:!0,attrs:{class:"token punctuation"}},[s._v("(")]),a("span",{pre:!0,attrs:{class:"token class-name"}},[s._v("HttpResult")]),s._v(" result"),a("span",{pre:!0,attrs:{class:"token punctuation"}},[s._v(")")]),s._v(" "),a("span",{pre:!0,attrs:{class:"token operator"}},[s._v("->")]),s._v(" "),a("span",{pre:!0,attrs:{class:"token punctuation"}},[s._v("{")]),s._v("\n "),a("span",{pre:!0,attrs:{class:"token comment"}},[s._v("// 在主线程执行")]),s._v("\n "),a("span",{pre:!0,attrs:{class:"token punctuation"}},[s._v("}")]),a("span",{pre:!0,attrs:{class:"token punctuation"}},[s._v(")")]),s._v("\n "),a("span",{pre:!0,attrs:{class:"token punctuation"}},[s._v(".")]),a("span",{pre:!0,attrs:{class:"token function"}},[s._v("setOnException")]),a("span",{pre:!0,attrs:{class:"token punctuation"}},[s._v("(")]),a("span",{pre:!0,attrs:{class:"token punctuation"}},[s._v("(")]),a("span",{pre:!0,attrs:{class:"token class-name"}},[s._v("Exception")]),s._v(" e"),a("span",{pre:!0,attrs:{class:"token punctuation"}},[s._v(")")]),s._v(" "),a("span",{pre:!0,attrs:{class:"token operator"}},[s._v("->")]),s._v(" "),a("span",{pre:!0,attrs:{class:"token punctuation"}},[s._v("{")]),s._v("\n "),a("span",{pre:!0,attrs:{class:"token comment"}},[s._v("// 在主线程执行")]),s._v("\n "),a("span",{pre:!0,attrs:{class:"token punctuation"}},[s._v("}")]),a("span",{pre:!0,attrs:{class:"token punctuation"}},[s._v(")")]),s._v("\n "),a("span",{pre:!0,attrs:{class:"token punctuation"}},[s._v(".")]),a("span",{pre:!0,attrs:{class:"token function"}},[s._v("setOnComplete")]),a("span",{pre:!0,attrs:{class:"token punctuation"}},[s._v("(")]),a("span",{pre:!0,attrs:{class:"token punctuation"}},[s._v("(")]),a("span",{pre:!0,attrs:{class:"token class-name"}},[s._v("State")]),s._v(" state"),a("span",{pre:!0,attrs:{class:"token punctuation"}},[s._v(")")]),s._v(" "),a("span",{pre:!0,attrs:{class:"token operator"}},[s._v("->")]),s._v(" "),a("span",{pre:!0,attrs:{class:"token punctuation"}},[s._v("{")]),s._v("\n "),a("span",{pre:!0,attrs:{class:"token comment"}},[s._v("// 在主线程执行")]),s._v("\n "),a("span",{pre:!0,attrs:{class:"token punctuation"}},[s._v("}")]),a("span",{pre:!0,attrs:{class:"token punctuation"}},[s._v(")")]),s._v("\n "),a("span",{pre:!0,attrs:{class:"token punctuation"}},[s._v(".")]),a("span",{pre:!0,attrs:{class:"token function"}},[s._v("post")]),a("span",{pre:!0,attrs:{class:"token punctuation"}},[s._v("(")]),a("span",{pre:!0,attrs:{class:"token punctuation"}},[s._v(")")]),a("span",{pre:!0,attrs:{class:"token punctuation"}},[s._v(";")]),s._v("\n")])]),s._v(" "),a("div",{staticClass:"line-numbers-wrapper"},[a("span",{staticClass:"line-number"},[s._v("1")]),a("br"),a("span",{staticClass:"line-number"},[s._v("2")]),a("br"),a("span",{staticClass:"line-number"},[s._v("3")]),a("br"),a("span",{staticClass:"line-number"},[s._v("4")]),a("br"),a("span",{staticClass:"line-number"},[s._v("5")]),a("br"),a("span",{staticClass:"line-number"},[s._v("6")]),a("br"),a("span",{staticClass:"line-number"},[s._v("7")]),a("br"),a("span",{staticClass:"line-number"},[s._v("8")]),a("br"),a("span",{staticClass:"line-number"},[s._v("9")]),a("br"),a("span",{staticClass:"line-number"},[s._v("10")]),a("br"),a("span",{staticClass:"line-number"},[s._v("11")]),a("br"),a("span",{staticClass:"line-number"},[s._v("12")]),a("br"),a("span",{staticClass:"line-number"},[s._v("13")]),a("br"),a("span",{staticClass:"line-number"},[s._v("14")]),a("br"),a("span",{staticClass:"line-number"},[s._v("15")]),a("br")])]),a("p",[s._v("但是，如果同时还想让某些回调放在IO线程，实现 "),a("strong",[s._v("自由切换")]),s._v("，怎么办呢？OkHttps 给出了非常灵活的方法，如下：")]),s._v(" "),a("div",{staticClass:"language-java line-numbers-mode"},[a("pre",{pre:!0,attrs:{class:"language-java"}},[a("code",[s._v("http"),a("span",{pre:!0,attrs:{class:"token punctuation"}},[s._v(".")]),a("span",{pre:!0,attrs:{class:"token function"}},[s._v("async")]),a("span",{pre:!0,attrs:{class:"token punctuation"}},[s._v("(")]),a("span",{pre:!0,attrs:{class:"token string"}},[s._v('"/users"')]),a("span",{pre:!0,attrs:{class:"token punctuation"}},[s._v(")")]),s._v("\n "),a("span",{pre:!0,attrs:{class:"token punctuation"}},[s._v(".")]),a("span",{pre:!0,attrs:{class:"token function"}},[s._v("addBodyParam")]),a("span",{pre:!0,attrs:{class:"token punctuation"}},[s._v("(")]),a("span",{pre:!0,attrs:{class:"token string"}},[s._v('"name"')]),a("span",{pre:!0,attrs:{class:"token punctuation"}},[s._v(",")]),s._v(" "),a("span",{pre:!0,attrs:{class:"token string"}},[s._v('"Jack"')]),a("span",{pre:!0,attrs:{class:"token punctuation"}},[s._v(")")]),s._v("\n "),a("span",{pre:!0,attrs:{class:"token punctuation"}},[s._v(".")]),a("span",{pre:!0,attrs:{class:"token function"}},[s._v("setOnProcess")]),a("span",{pre:!0,attrs:{class:"token punctuation"}},[s._v("(")]),a("span",{pre:!0,attrs:{class:"token punctuation"}},[s._v("(")]),a("span",{pre:!0,attrs:{class:"token class-name"}},[s._v("Process")]),s._v(" process"),a("span",{pre:!0,attrs:{class:"token punctuation"}},[s._v(")")]),s._v(" "),a("span",{pre:!0,attrs:{class:"token operator"}},[s._v("->")]),s._v(" "),a("span",{pre:!0,attrs:{class:"token punctuation"}},[s._v("{")]),s._v("\n "),a("span",{pre:!0,attrs:{class:"token comment"}},[s._v("// 在主线程执行")]),s._v("\n "),a("span",{pre:!0,attrs:{class:"token punctuation"}},[s._v("}")]),a("span",{pre:!0,attrs:{class:"token punctuation"}},[s._v(")")]),s._v("\n "),a("span",{pre:!0,attrs:{class:"token punctuation"}},[s._v(".")]),a("span",{pre:!0,attrs:{class:"token function"}},[s._v("nextOnIO")]),a("span",{pre:!0,attrs:{class:"token punctuation"}},[s._v("(")]),a("span",{pre:!0,attrs:{class:"token punctuation"}},[s._v(")")]),s._v(" "),a("span",{pre:!0,attrs:{class:"token comment"}},[s._v("// 指定下一个回调在 IO 线程执行")]),s._v("\n "),a("span",{pre:!0,attrs:{class:"token punctuation"}},[s._v(".")]),a("span",{pre:!0,attrs:{class:"token function"}},[s._v("setOnResponse")]),a("span",{pre:!0,attrs:{class:"token punctuation"}},[s._v("(")]),a("span",{pre:!0,attrs:{class:"token punctuation"}},[s._v("(")]),a("span",{pre:!0,attrs:{class:"token class-name"}},[s._v("HttpResult")]),s._v(" result"),a("span",{pre:!0,attrs:{class:"token punctuation"}},[s._v(")")]),s._v(" "),a("span",{pre:!0,attrs:{class:"token operator"}},[s._v("->")]),s._v(" "),a("span",{pre:!0,attrs:{class:"token punctuation"}},[s._v("{")]),s._v("\n "),a("span",{pre:!0,attrs:{class:"token comment"}},[s._v("// 在 IO 线程执行")]),s._v("\n "),a("span",{pre:!0,attrs:{class:"token punctuation"}},[s._v("}")]),a("span",{pre:!0,attrs:{class:"token punctuation"}},[s._v(")")]),s._v("\n "),a("span",{pre:!0,attrs:{class:"token punctuation"}},[s._v(".")]),a("span",{pre:!0,attrs:{class:"token function"}},[s._v("setOnException")]),a("span",{pre:!0,attrs:{class:"token punctuation"}},[s._v("(")]),a("span",{pre:!0,attrs:{class:"token punctuation"}},[s._v("(")]),a("span",{pre:!0,attrs:{class:"token class-name"}},[s._v("Exception")]),s._v(" e"),a("span",{pre:!0,attrs:{class:"token punctuation"}},[s._v(")")]),s._v(" "),a("span",{pre:!0,attrs:{class:"token operator"}},[s._v("->")]),s._v(" "),a("span",{pre:!0,attrs:{class:"token punctuation"}},[s._v("{")]),s._v("\n "),a("span",{pre:!0,attrs:{class:"token comment"}},[s._v("// 在主线程执行（没有指明 nextOnIO 则在回调执行器里执行）")]),s._v("\n "),a("span",{pre:!0,attrs:{class:"token punctuation"}},[s._v("}")]),a("span",{pre:!0,attrs:{class:"token punctuation"}},[s._v(")")]),s._v("\n "),a("span",{pre:!0,attrs:{class:"token punctuation"}},[s._v(".")]),a("span",{pre:!0,attrs:{class:"token function"}},[s._v("nextOnIO")]),a("span",{pre:!0,attrs:{class:"token punctuation"}},[s._v("(")]),a("span",{pre:!0,attrs:{class:"token punctuation"}},[s._v(")")]),s._v(" "),a("span",{pre:!0,attrs:{class:"token comment"}},[s._v("// 指定下一个回调在 IO 线程执行")]),s._v("\n "),a("span",{pre:!0,attrs:{class:"token punctuation"}},[s._v(".")]),a("span",{pre:!0,attrs:{class:"token function"}},[s._v("setOnComplete")]),a("span",{pre:!0,attrs:{class:"token punctuation"}},[s._v("(")]),a("span",{pre:!0,attrs:{class:"token punctuation"}},[s._v("(")]),a("span",{pre:!0,attrs:{class:"token class-name"}},[s._v("State")]),s._v(" state"),a("span",{pre:!0,attrs:{class:"token punctuation"}},[s._v(")")]),s._v(" "),a("span",{pre:!0,attrs:{class:"token operator"}},[s._v("->")]),s._v(" "),a("span",{pre:!0,attrs:{class:"token punctuation"}},[s._v("{")]),s._v("\n "),a("span",{pre:!0,attrs:{class:"token comment"}},[s._v("// 在 IO 线程执行")]),s._v("\n "),a("span",{pre:!0,attrs:{class:"token punctuation"}},[s._v("}")]),a("span",{pre:!0,attrs:{class:"token punctuation"}},[s._v(")")]),s._v("\n "),a("span",{pre:!0,attrs:{class:"token punctuation"}},[s._v(".")]),a("span",{pre:!0,attrs:{class:"token function"}},[s._v("post")]),a("span",{pre:!0,attrs:{class:"token punctuation"}},[s._v("(")]),a("span",{pre:!0,attrs:{class:"token punctuation"}},[s._v(")")]),a("span",{pre:!0,attrs:{class:"token punctuation"}},[s._v(";")]),s._v("\n")])]),s._v(" "),a("div",{staticClass:"line-numbers-wrapper"},[a("span",{staticClass:"line-number"},[s._v("1")]),a("br"),a("span",{staticClass:"line-number"},[s._v("2")]),a("br"),a("span",{staticClass:"line-number"},[s._v("3")]),a("br"),a("span",{staticClass:"line-number"},[s._v("4")]),a("br"),a("span",{staticClass:"line-number"},[s._v("5")]),a("br"),a("span",{staticClass:"line-number"},[s._v("6")]),a("br"),a("span",{staticClass:"line-number"},[s._v("7")]),a("br"),a("span",{staticClass:"line-number"},[s._v("8")]),a("br"),a("span",{staticClass:"line-number"},[s._v("9")]),a("br"),a("span",{staticClass:"line-number"},[s._v("10")]),a("br"),a("span",{staticClass:"line-number"},[s._v("11")]),a("br"),a("span",{staticClass:"line-number"},[s._v("12")]),a("br"),a("span",{staticClass:"line-number"},[s._v("13")]),a("br"),a("span",{staticClass:"line-number"},[s._v("14")]),a("br"),a("span",{staticClass:"line-number"},[s._v("15")]),a("br"),a("span",{staticClass:"line-number"},[s._v("16")]),a("br"),a("span",{staticClass:"line-number"},[s._v("17")]),a("br")])]),a("p",[s._v("无论是哪一个回调，都可以使用"),a("code",[s._v("nextOnIO()")]),s._v("方法自由切换。同样，对于文件下载也是一样：")]),s._v(" "),a("div",{staticClass:"language-java line-numbers-mode"},[a("pre",{pre:!0,attrs:{class:"language-java"}},[a("code",[s._v("http"),a("span",{pre:!0,attrs:{class:"token punctuation"}},[s._v(".")]),a("span",{pre:!0,attrs:{class:"token function"}},[s._v("sync")]),a("span",{pre:!0,attrs:{class:"token punctuation"}},[s._v("(")]),a("span",{pre:!0,attrs:{class:"token string"}},[s._v('"/download/test.zip"')]),a("span",{pre:!0,attrs:{class:"token punctuation"}},[s._v(")")]),s._v("\n "),a("span",{pre:!0,attrs:{class:"token punctuation"}},[s._v(".")]),a("span",{pre:!0,attrs:{class:"token function"}},[s._v("get")]),a("span",{pre:!0,attrs:{class:"token punctuation"}},[s._v("(")]),a("span",{pre:!0,attrs:{class:"token punctuation"}},[s._v(")")]),s._v("\n "),a("span",{pre:!0,attrs:{class:"token punctuation"}},[s._v(".")]),a("span",{pre:!0,attrs:{class:"token function"}},[s._v("getBody")]),a("span",{pre:!0,attrs:{class:"token punctuation"}},[s._v("(")]),a("span",{pre:!0,attrs:{class:"token punctuation"}},[s._v(")")]),s._v("\n "),a("span",{pre:!0,attrs:{class:"token punctuation"}},[s._v(".")]),a("span",{pre:!0,attrs:{class:"token function"}},[s._v("setOnProcess")]),a("span",{pre:!0,attrs:{class:"token punctuation"}},[s._v("(")]),a("span",{pre:!0,attrs:{class:"token punctuation"}},[s._v("(")]),a("span",{pre:!0,attrs:{class:"token class-name"}},[s._v("Process")]),s._v(" process"),a("span",{pre:!0,attrs:{class:"token punctuation"}},[s._v(")")]),s._v(" "),a("span",{pre:!0,attrs:{class:"token operator"}},[s._v("->")]),s._v(" "),a("span",{pre:!0,attrs:{class:"token punctuation"}},[s._v("{")]),s._v("\n "),a("span",{pre:!0,attrs:{class:"token comment"}},[s._v("// 在主线程执行")]),s._v("\n "),a("span",{pre:!0,attrs:{class:"token punctuation"}},[s._v("}")]),a("span",{pre:!0,attrs:{class:"token punctuation"}},[s._v(")")]),s._v("\n "),a("span",{pre:!0,attrs:{class:"token punctuation"}},[s._v(".")]),a("span",{pre:!0,attrs:{class:"token function"}},[s._v("toFolder")]),a("span",{pre:!0,attrs:{class:"token punctuation"}},[s._v("(")]),a("span",{pre:!0,attrs:{class:"token string"}},[s._v('"D:/download/"')]),a("span",{pre:!0,attrs:{class:"token punctuation"}},[s._v(")")]),s._v("\n "),a("span",{pre:!0,attrs:{class:"token punctuation"}},[s._v(".")]),a("span",{pre:!0,attrs:{class:"token function"}},[s._v("nextOnIO")]),a("span",{pre:!0,attrs:{class:"token punctuation"}},[s._v("(")]),a("span",{pre:!0,attrs:{class:"token punctuation"}},[s._v(")")]),s._v(" "),a("span",{pre:!0,attrs:{class:"token comment"}},[s._v("// 指定下一个回调在 IO 线程执行")]),s._v("\n "),a("span",{pre:!0,attrs:{class:"token punctuation"}},[s._v(".")]),a("span",{pre:!0,attrs:{class:"token function"}},[s._v("setOnSuccess")]),a("span",{pre:!0,attrs:{class:"token punctuation"}},[s._v("(")]),a("span",{pre:!0,attrs:{class:"token punctuation"}},[s._v("(")]),a("span",{pre:!0,attrs:{class:"token class-name"}},[s._v("File")]),s._v(" file"),a("span",{pre:!0,attrs:{class:"token punctuation"}},[s._v(")")]),s._v(" "),a("span",{pre:!0,attrs:{class:"token operator"}},[s._v("->")]),s._v(" "),a("span",{pre:!0,attrs:{class:"token punctuation"}},[s._v("{")]),s._v("\n "),a("span",{pre:!0,attrs:{class:"token comment"}},[s._v("// 在 IO 线程执行")]),s._v("\n "),a("span",{pre:!0,attrs:{class:"token punctuation"}},[s._v("}")]),a("span",{pre:!0,attrs:{class:"token punctuation"}},[s._v(")")]),s._v("\n "),a("span",{pre:!0,attrs:{class:"token punctuation"}},[s._v(".")]),a("span",{pre:!0,attrs:{class:"token function"}},[s._v("setOnFailure")]),a("span",{pre:!0,attrs:{class:"token punctuation"}},[s._v("(")]),a("span",{pre:!0,attrs:{class:"token punctuation"}},[s._v("(")]),a("span",{pre:!0,attrs:{class:"token class-name"}},[s._v("Failure")]),s._v(" failure"),a("span",{pre:!0,attrs:{class:"token punctuation"}},[s._v(")")]),s._v(" "),a("span",{pre:!0,attrs:{class:"token operator"}},[s._v("->")]),s._v(" "),a("span",{pre:!0,attrs:{class:"token punctuation"}},[s._v("{")]),s._v("\n "),a("span",{pre:!0,attrs:{class:"token comment"}},[s._v("// 在主线程执行")]),s._v("\n "),a("span",{pre:!0,attrs:{class:"token punctuation"}},[s._v("}")]),a("span",{pre:!0,attrs:{class:"token punctuation"}},[s._v(")")]),s._v("\n "),a("span",{pre:!0,attrs:{class:"token punctuation"}},[s._v(".")]),a("span",{pre:!0,attrs:{class:"token function"}},[s._v("start")]),a("span",{pre:!0,attrs:{class:"token punctuation"}},[s._v("(")]),a("span",{pre:!0,attrs:{class:"token punctuation"}},[s._v(")")]),a("span",{pre:!0,attrs:{class:"token punctuation"}},[s._v(";")]),s._v("\n")])]),s._v(" "),a("div",{staticClass:"line-numbers-wrapper"},[a("span",{staticClass:"line-number"},[s._v("1")]),a("br"),a("span",{staticClass:"line-number"},[s._v("2")]),a("br"),a("span",{staticClass:"line-number"},[s._v("3")]),a("br"),a("span",{staticClass:"line-number"},[s._v("4")]),a("br"),a("span",{staticClass:"line-number"},[s._v("5")]),a("br"),a("span",{staticClass:"line-number"},[s._v("6")]),a("br"),a("span",{staticClass:"line-number"},[s._v("7")]),a("br"),a("span",{staticClass:"line-number"},[s._v("8")]),a("br"),a("span",{staticClass:"line-number"},[s._v("9")]),a("br"),a("span",{staticClass:"line-number"},[s._v("10")]),a("br"),a("span",{staticClass:"line-number"},[s._v("11")]),a("br"),a("span",{staticClass:"line-number"},[s._v("12")]),a("br"),a("span",{staticClass:"line-number"},[s._v("13")]),a("br"),a("span",{staticClass:"line-number"},[s._v("14")]),a("br"),a("span",{staticClass:"line-number"},[s._v("15")]),a("br")])]),a("h2",{attrs:{id:"生命周期绑定"}},[a("a",{staticClass:"header-anchor",attrs:{href:"#生命周期绑定"}},[s._v("#")]),s._v(" 生命周期绑定")]),s._v(" "),a("p",[s._v("由于 OkHttps 并不依赖于 Android，所以它并没有提供关于生命周期绑定的直接实现，但它的一些扩展机制让我们很容易就可以实现这个需求。在开始之前，我们首先要理解何为生命周期绑定：")]),s._v(" "),a("div",{staticClass:"custom-block tip"},[a("p",{staticClass:"custom-block-title"},[s._v("HTTP 请求的生命周期绑定")]),s._v(" "),a("p",[s._v("所谓的生命周期绑定：即是让 HTTP 任务感知其所属的 Activity 或 Fragment 的生命周期，当 Activity 或 Fragment 将被销毁时，框架应自动的把由它们发起的但尚未完成的 HTTP 任务全部取消，以免导致程序出错！")])]),s._v(" "),a("p",[s._v("现在我们需要对"),a("code",[s._v("HTTP")]),s._v("实例进行配置，配置后的"),a("code",[s._v("HTTP")]),s._v("实例具有生命周期绑定的功能，在"),a("code",[s._v("Activity")]),s._v("或"),a("code",[s._v("Fragment")]),s._v("里，它的使用效果如下：")]),s._v(" "),a("div",{staticClass:"language-java line-numbers-mode"},[a("pre",{pre:!0,attrs:{class:"language-java"}},[a("code",[a("span",{pre:!0,attrs:{class:"token comment"}},[s._v("// 在 Activity 或 Fragment 内发起请求")]),s._v("\nhttp"),a("span",{pre:!0,attrs:{class:"token punctuation"}},[s._v(".")]),a("span",{pre:!0,attrs:{class:"token function"}},[s._v("async")]),a("span",{pre:!0,attrs:{class:"token punctuation"}},[s._v("(")]),a("span",{pre:!0,attrs:{class:"token string"}},[s._v('"http://www.baidu.com"')]),a("span",{pre:!0,attrs:{class:"token punctuation"}},[s._v(")")]),s._v("\n "),a("span",{pre:!0,attrs:{class:"token punctuation"}},[s._v(".")]),a("span",{pre:!0,attrs:{class:"token function"}},[s._v("bind")]),a("span",{pre:!0,attrs:{class:"token punctuation"}},[s._v("(")]),a("span",{pre:!0,attrs:{class:"token function"}},[s._v("getLifecycle")]),a("span",{pre:!0,attrs:{class:"token punctuation"}},[s._v("(")]),a("span",{pre:!0,attrs:{class:"token punctuation"}},[s._v(")")]),a("span",{pre:!0,attrs:{class:"token punctuation"}},[s._v(")")]),s._v(" "),a("span",{pre:!0,attrs:{class:"token comment"}},[s._v("// 绑定生命周期")]),s._v("\n "),a("span",{pre:!0,attrs:{class:"token punctuation"}},[s._v(".")]),a("span",{pre:!0,attrs:{class:"token function"}},[s._v("setOnResponse")]),a("span",{pre:!0,attrs:{class:"token punctuation"}},[s._v("(")]),a("span",{pre:!0,attrs:{class:"token punctuation"}},[s._v("(")]),a("span",{pre:!0,attrs:{class:"token class-name"}},[s._v("HttpResult")]),s._v(" result"),a("span",{pre:!0,attrs:{class:"token punctuation"}},[s._v(")")]),s._v(" "),a("span",{pre:!0,attrs:{class:"token operator"}},[s._v("->")]),s._v(" "),a("span",{pre:!0,attrs:{class:"token punctuation"}},[s._v("{")]),s._v("\n "),a("span",{pre:!0,attrs:{class:"token class-name"}},[s._v("Log")]),a("span",{pre:!0,attrs:{class:"token punctuation"}},[s._v(".")]),a("span",{pre:!0,attrs:{class:"token function"}},[s._v("i")]),a("span",{pre:!0,attrs:{class:"token punctuation"}},[s._v("(")]),a("span",{pre:!0,attrs:{class:"token string"}},[s._v('"FirstFragment"')]),a("span",{pre:!0,attrs:{class:"token punctuation"}},[s._v(",")]),s._v(" "),a("span",{pre:!0,attrs:{class:"token string"}},[s._v('"收到请求："')]),s._v(" "),a("span",{pre:!0,attrs:{class:"token operator"}},[s._v("+")]),s._v(" result"),a("span",{pre:!0,attrs:{class:"token punctuation"}},[s._v(".")]),a("span",{pre:!0,attrs:{class:"token function"}},[s._v("toString")]),a("span",{pre:!0,attrs:{class:"token punctuation"}},[s._v("(")]),a("span",{pre:!0,attrs:{class:"token punctuation"}},[s._v(")")]),a("span",{pre:!0,attrs:{class:"token punctuation"}},[s._v(")")]),a("span",{pre:!0,attrs:{class:"token punctuation"}},[s._v(";")]),s._v("\n "),a("span",{pre:!0,attrs:{class:"token punctuation"}},[s._v("}")]),a("span",{pre:!0,attrs:{class:"token punctuation"}},[s._v(")")]),s._v("\n "),a("span",{pre:!0,attrs:{class:"token punctuation"}},[s._v(".")]),a("span",{pre:!0,attrs:{class:"token function"}},[s._v("get")]),a("span",{pre:!0,attrs:{class:"token punctuation"}},[s._v("(")]),a("span",{pre:!0,attrs:{class:"token punctuation"}},[s._v(")")]),a("span",{pre:!0,attrs:{class:"token punctuation"}},[s._v(";")]),s._v("\n")])]),s._v(" "),a("div",{staticClass:"line-numbers-wrapper"},[a("span",{staticClass:"line-number"},[s._v("1")]),a("br"),a("span",{staticClass:"line-number"},[s._v("2")]),a("br"),a("span",{staticClass:"line-number"},[s._v("3")]),a("br"),a("span",{staticClass:"line-number"},[s._v("4")]),a("br"),a("span",{staticClass:"line-number"},[s._v("5")]),a("br"),a("span",{staticClass:"line-number"},[s._v("6")]),a("br"),a("span",{staticClass:"line-number"},[s._v("7")]),a("br")])]),a("p",[s._v("上述代码中的"),a("code",[s._v("getLifecycle()")]),s._v("是"),a("code",[s._v("Activity")]),s._v("或"),a("code",[s._v("Fragment")]),s._v("自带的方法，而"),a("code",[s._v("bind()")]),s._v("是"),a("code",[s._v("HttpTask")]),s._v("的现有方法。在配置好"),a("code",[s._v("HTTP")]),s._v("实例后，上述代码发起的请求便可以感知"),a("code",[s._v("Activity")]),s._v("或"),a("code",[s._v("Fragment")]),s._v("的生命周期。")]),s._v(" "),a("p",[s._v("那"),a("code",[s._v("HTTP")]),s._v("实例到底该如何配置呢？")]),s._v(" "),a("h3",{attrs:{id:"第一步：配置预处理器"}},[a("a",{staticClass:"header-anchor",attrs:{href:"#第一步：配置预处理器"}},[s._v("#")]),s._v(" 第一步：配置预处理器")]),s._v(" "),a("div",{staticClass:"language-java line-numbers-mode"},[a("pre",{pre:!0,attrs:{class:"language-java"}},[a("code",[a("span",{pre:!0,attrs:{class:"token class-name"}},[s._v("HTTP")]),s._v(" http "),a("span",{pre:!0,attrs:{class:"token operator"}},[s._v("=")]),s._v(" HTTP"),a("span",{pre:!0,attrs:{class:"token punctuation"}},[s._v(".")]),a("span",{pre:!0,attrs:{class:"token function"}},[s._v("builder")]),a("span",{pre:!0,attrs:{class:"token punctuation"}},[s._v("(")]),a("span",{pre:!0,attrs:{class:"token punctuation"}},[s._v(")")]),s._v("\n "),a("span",{pre:!0,attrs:{class:"token punctuation"}},[s._v(".")]),a("span",{pre:!0,attrs:{class:"token punctuation"}},[s._v(".")]),a("span",{pre:!0,attrs:{class:"token punctuation"}},[s._v(".")]),s._v(" "),a("span",{pre:!0,attrs:{class:"token comment"}},[s._v("// 省略其它配置项")]),s._v("\n "),a("span",{pre:!0,attrs:{class:"token punctuation"}},[s._v(".")]),a("span",{pre:!0,attrs:{class:"token function"}},[s._v("addPreprocessor")]),a("span",{pre:!0,attrs:{class:"token punctuation"}},[s._v("(")]),a("span",{pre:!0,attrs:{class:"token punctuation"}},[s._v("(")]),a("span",{pre:!0,attrs:{class:"token class-name"}},[s._v("Preprocessor")]),a("span",{pre:!0,attrs:{class:"token punctuation"}},[s._v(".")]),a("span",{pre:!0,attrs:{class:"token class-name"}},[s._v("PreChain")]),s._v(" chain"),a("span",{pre:!0,attrs:{class:"token punctuation"}},[s._v(")")]),s._v(" "),a("span",{pre:!0,attrs:{class:"token operator"}},[s._v("->")]),s._v(" "),a("span",{pre:!0,attrs:{class:"token punctuation"}},[s._v("{")]),s._v("\n "),a("span",{pre:!0,attrs:{class:"token class-name"}},[s._v("HttpTask")]),a("span",{pre:!0,attrs:{class:"token generics"}},[a("span",{pre:!0,attrs:{class:"token punctuation"}},[s._v("<")]),a("span",{pre:!0,attrs:{class:"token operator"}},[s._v("?")]),a("span",{pre:!0,attrs:{class:"token punctuation"}},[s._v(">")])]),s._v(" task "),a("span",{pre:!0,attrs:{class:"token operator"}},[s._v("=")]),s._v(" chain"),a("span",{pre:!0,attrs:{class:"token punctuation"}},[s._v(".")]),a("span",{pre:!0,attrs:{class:"token function"}},[s._v("getTask")]),a("span",{pre:!0,attrs:{class:"token punctuation"}},[s._v("(")]),a("span",{pre:!0,attrs:{class:"token punctuation"}},[s._v(")")]),a("span",{pre:!0,attrs:{class:"token punctuation"}},[s._v(";")]),s._v("\n "),a("span",{pre:!0,attrs:{class:"token class-name"}},[s._v("Object")]),s._v(" bound "),a("span",{pre:!0,attrs:{class:"token operator"}},[s._v("=")]),s._v(" task"),a("span",{pre:!0,attrs:{class:"token punctuation"}},[s._v(".")]),a("span",{pre:!0,attrs:{class:"token function"}},[s._v("getBound")]),a("span",{pre:!0,attrs:{class:"token punctuation"}},[s._v("(")]),a("span",{pre:!0,attrs:{class:"token punctuation"}},[s._v(")")]),a("span",{pre:!0,attrs:{class:"token punctuation"}},[s._v(";")]),s._v("\n "),a("span",{pre:!0,attrs:{class:"token comment"}},[s._v("// 判断 task 是否绑定了 Lifecycle 对象")]),s._v("\n "),a("span",{pre:!0,attrs:{class:"token keyword"}},[s._v("if")]),s._v(" "),a("span",{pre:!0,attrs:{class:"token punctuation"}},[s._v("(")]),s._v("bound "),a("span",{pre:!0,attrs:{class:"token keyword"}},[s._v("instanceof")]),s._v(" "),a("span",{pre:!0,attrs:{class:"token class-name"}},[s._v("Lifecycle")]),a("span",{pre:!0,attrs:{class:"token punctuation"}},[s._v(")")]),s._v(" "),a("span",{pre:!0,attrs:{class:"token punctuation"}},[s._v("{")]),s._v("\n "),a("span",{pre:!0,attrs:{class:"token comment"}},[s._v("// 重新绑定一个 生命周期监视器（LCObserver）对象，它的定义见下一步")]),s._v("\n task"),a("span",{pre:!0,attrs:{class:"token punctuation"}},[s._v(".")]),a("span",{pre:!0,attrs:{class:"token function"}},[s._v("bind")]),a("span",{pre:!0,attrs:{class:"token punctuation"}},[s._v("(")]),a("span",{pre:!0,attrs:{class:"token keyword"}},[s._v("new")]),s._v(" "),a("span",{pre:!0,attrs:{class:"token class-name"}},[s._v("LCObserver")]),a("span",{pre:!0,attrs:{class:"token punctuation"}},[s._v("(")]),s._v("task"),a("span",{pre:!0,attrs:{class:"token punctuation"}},[s._v(",")]),s._v(" "),a("span",{pre:!0,attrs:{class:"token punctuation"}},[s._v("(")]),a("span",{pre:!0,attrs:{class:"token class-name"}},[s._v("Lifecycle")]),a("span",{pre:!0,attrs:{class:"token punctuation"}},[s._v(")")]),s._v(" bound"),a("span",{pre:!0,attrs:{class:"token punctuation"}},[s._v(")")]),a("span",{pre:!0,attrs:{class:"token punctuation"}},[s._v(")")]),a("span",{pre:!0,attrs:{class:"token punctuation"}},[s._v(";")]),s._v("\n "),a("span",{pre:!0,attrs:{class:"token punctuation"}},[s._v("}")]),s._v("\n chain"),a("span",{pre:!0,attrs:{class:"token punctuation"}},[s._v(".")]),a("span",{pre:!0,attrs:{class:"token function"}},[s._v("proceed")]),a("span",{pre:!0,attrs:{class:"token punctuation"}},[s._v("(")]),a("span",{pre:!0,attrs:{class:"token punctuation"}},[s._v(")")]),a("span",{pre:!0,attrs:{class:"token punctuation"}},[s._v(";")]),s._v("\n "),a("span",{pre:!0,attrs:{class:"token punctuation"}},[s._v("}")]),a("span",{pre:!0,attrs:{class:"token punctuation"}},[s._v(")")]),s._v("\n "),a("span",{pre:!0,attrs:{class:"token punctuation"}},[s._v(".")]),a("span",{pre:!0,attrs:{class:"token punctuation"}},[s._v(".")]),a("span",{pre:!0,attrs:{class:"token punctuation"}},[s._v(".")]),s._v(" "),a("span",{pre:!0,attrs:{class:"token comment"}},[s._v("// 省略其它配置项")]),s._v("\n "),a("span",{pre:!0,attrs:{class:"token punctuation"}},[s._v(".")]),a("span",{pre:!0,attrs:{class:"token function"}},[s._v("build")]),a("span",{pre:!0,attrs:{class:"token punctuation"}},[s._v("(")]),a("span",{pre:!0,attrs:{class:"token punctuation"}},[s._v(")")]),a("span",{pre:!0,attrs:{class:"token punctuation"}},[s._v(";")]),s._v("\n")])]),s._v(" "),a("div",{staticClass:"line-numbers-wrapper"},[a("span",{staticClass:"line-number"},[s._v("1")]),a("br"),a("span",{staticClass:"line-number"},[s._v("2")]),a("br"),a("span",{staticClass:"line-number"},[s._v("3")]),a("br"),a("span",{staticClass:"line-number"},[s._v("4")]),a("br"),a("span",{staticClass:"line-number"},[s._v("5")]),a("br"),a("span",{staticClass:"line-number"},[s._v("6")]),a("br"),a("span",{staticClass:"line-number"},[s._v("7")]),a("br"),a("span",{staticClass:"line-number"},[s._v("8")]),a("br"),a("span",{staticClass:"line-number"},[s._v("9")]),a("br"),a("span",{staticClass:"line-number"},[s._v("10")]),a("br"),a("span",{staticClass:"line-number"},[s._v("11")]),a("br"),a("span",{staticClass:"line-number"},[s._v("12")]),a("br"),a("span",{staticClass:"line-number"},[s._v("13")]),a("br"),a("span",{staticClass:"line-number"},[s._v("14")]),a("br")])]),a("h3",{attrs:{id:"第二步：定义生命周期监视器"}},[a("a",{staticClass:"header-anchor",attrs:{href:"#第二步：定义生命周期监视器"}},[s._v("#")]),s._v(" 第二步：定义生命周期监视器")]),s._v(" "),a("div",{staticClass:"language-java line-numbers-mode"},[a("pre",{pre:!0,attrs:{class:"language-java"}},[a("code",[a("span",{pre:!0,attrs:{class:"token keyword"}},[s._v("public")]),s._v(" "),a("span",{pre:!0,attrs:{class:"token keyword"}},[s._v("class")]),s._v(" "),a("span",{pre:!0,attrs:{class:"token class-name"}},[s._v("LCObserver")]),s._v(" "),a("span",{pre:!0,attrs:{class:"token keyword"}},[s._v("implements")]),s._v(" "),a("span",{pre:!0,attrs:{class:"token class-name"}},[s._v("LifecycleObserver")]),s._v(" "),a("span",{pre:!0,attrs:{class:"token punctuation"}},[s._v("{")]),s._v("\n\n "),a("span",{pre:!0,attrs:{class:"token class-name"}},[s._v("HttpTask")]),a("span",{pre:!0,attrs:{class:"token generics"}},[a("span",{pre:!0,attrs:{class:"token punctuation"}},[s._v("<")]),a("span",{pre:!0,attrs:{class:"token operator"}},[s._v("?")]),a("span",{pre:!0,attrs:{class:"token punctuation"}},[s._v(">")])]),s._v(" task"),a("span",{pre:!0,attrs:{class:"token punctuation"}},[s._v(";")]),s._v("\n "),a("span",{pre:!0,attrs:{class:"token class-name"}},[s._v("Lifecycle")]),s._v(" lifecycle"),a("span",{pre:!0,attrs:{class:"token punctuation"}},[s._v(";")]),s._v("\n\n "),a("span",{pre:!0,attrs:{class:"token class-name"}},[s._v("LCObserver")]),a("span",{pre:!0,attrs:{class:"token punctuation"}},[s._v("(")]),a("span",{pre:!0,attrs:{class:"token class-name"}},[s._v("HttpTask")]),a("span",{pre:!0,attrs:{class:"token generics"}},[a("span",{pre:!0,attrs:{class:"token punctuation"}},[s._v("<")]),a("span",{pre:!0,attrs:{class:"token operator"}},[s._v("?")]),a("span",{pre:!0,attrs:{class:"token punctuation"}},[s._v(">")])]),s._v(" task"),a("span",{pre:!0,attrs:{class:"token punctuation"}},[s._v(",")]),s._v(" "),a("span",{pre:!0,attrs:{class:"token class-name"}},[s._v("Lifecycle")]),s._v(" lifecycle"),a("span",{pre:!0,attrs:{class:"token punctuation"}},[s._v(")")]),s._v(" "),a("span",{pre:!0,attrs:{class:"token punctuation"}},[s._v("{")]),s._v("\n "),a("span",{pre:!0,attrs:{class:"token keyword"}},[s._v("this")]),a("span",{pre:!0,attrs:{class:"token punctuation"}},[s._v(".")]),s._v("task "),a("span",{pre:!0,attrs:{class:"token operator"}},[s._v("=")]),s._v(" task"),a("span",{pre:!0,attrs:{class:"token punctuation"}},[s._v(";")]),s._v("\n "),a("span",{pre:!0,attrs:{class:"token keyword"}},[s._v("this")]),a("span",{pre:!0,attrs:{class:"token punctuation"}},[s._v(".")]),s._v("lifecycle "),a("span",{pre:!0,attrs:{class:"token operator"}},[s._v("=")]),s._v(" lifecycle"),a("span",{pre:!0,attrs:{class:"token punctuation"}},[s._v(";")]),s._v("\n lifecycle"),a("span",{pre:!0,attrs:{class:"token punctuation"}},[s._v(".")]),a("span",{pre:!0,attrs:{class:"token function"}},[s._v("addObserver")]),a("span",{pre:!0,attrs:{class:"token punctuation"}},[s._v("(")]),a("span",{pre:!0,attrs:{class:"token keyword"}},[s._v("this")]),a("span",{pre:!0,attrs:{class:"token punctuation"}},[s._v(")")]),a("span",{pre:!0,attrs:{class:"token punctuation"}},[s._v(";")]),s._v("\n "),a("span",{pre:!0,attrs:{class:"token punctuation"}},[s._v("}")]),s._v("\n\n "),a("span",{pre:!0,attrs:{class:"token annotation punctuation"}},[s._v("@OnLifecycleEvent")]),a("span",{pre:!0,attrs:{class:"token punctuation"}},[s._v("(")]),a("span",{pre:!0,attrs:{class:"token class-name"}},[s._v("Lifecycle")]),a("span",{pre:!0,attrs:{class:"token punctuation"}},[s._v(".")]),a("span",{pre:!0,attrs:{class:"token class-name"}},[s._v("Event")]),a("span",{pre:!0,attrs:{class:"token punctuation"}},[s._v(".")]),s._v("ON_STOP"),a("span",{pre:!0,attrs:{class:"token punctuation"}},[s._v(")")]),s._v("\n "),a("span",{pre:!0,attrs:{class:"token keyword"}},[s._v("public")]),s._v(" "),a("span",{pre:!0,attrs:{class:"token keyword"}},[s._v("void")]),s._v(" "),a("span",{pre:!0,attrs:{class:"token function"}},[s._v("onStop")]),a("span",{pre:!0,attrs:{class:"token punctuation"}},[s._v("(")]),a("span",{pre:!0,attrs:{class:"token punctuation"}},[s._v(")")]),s._v(" "),a("span",{pre:!0,attrs:{class:"token punctuation"}},[s._v("{")]),s._v("\n task"),a("span",{pre:!0,attrs:{class:"token punctuation"}},[s._v(".")]),a("span",{pre:!0,attrs:{class:"token function"}},[s._v("cancel")]),a("span",{pre:!0,attrs:{class:"token punctuation"}},[s._v("(")]),a("span",{pre:!0,attrs:{class:"token punctuation"}},[s._v(")")]),a("span",{pre:!0,attrs:{class:"token punctuation"}},[s._v(";")]),s._v(" "),a("span",{pre:!0,attrs:{class:"token comment"}},[s._v("// 在 ON_STOP 事件中，取消对应的 HTTP 任务")]),s._v("\n "),a("span",{pre:!0,attrs:{class:"token punctuation"}},[s._v("}")]),s._v("\n\n "),a("span",{pre:!0,attrs:{class:"token keyword"}},[s._v("public")]),s._v(" "),a("span",{pre:!0,attrs:{class:"token keyword"}},[s._v("void")]),s._v(" "),a("span",{pre:!0,attrs:{class:"token function"}},[s._v("unbind")]),a("span",{pre:!0,attrs:{class:"token punctuation"}},[s._v("(")]),a("span",{pre:!0,attrs:{class:"token punctuation"}},[s._v(")")]),s._v(" "),a("span",{pre:!0,attrs:{class:"token punctuation"}},[s._v("{")]),s._v("\n "),a("span",{pre:!0,attrs:{class:"token comment"}},[s._v("// 在请求完成之后移除监视器")]),s._v("\n lifecycle"),a("span",{pre:!0,attrs:{class:"token punctuation"}},[s._v(".")]),a("span",{pre:!0,attrs:{class:"token function"}},[s._v("removeObserver")]),a("span",{pre:!0,attrs:{class:"token punctuation"}},[s._v("(")]),a("span",{pre:!0,attrs:{class:"token keyword"}},[s._v("this")]),a("span",{pre:!0,attrs:{class:"token punctuation"}},[s._v(")")]),a("span",{pre:!0,attrs:{class:"token punctuation"}},[s._v(";")]),s._v("\n "),a("span",{pre:!0,attrs:{class:"token punctuation"}},[s._v("}")]),s._v("\n\n"),a("span",{pre:!0,attrs:{class:"token punctuation"}},[s._v("}")]),s._v("\n")])]),s._v(" "),a("div",{staticClass:"line-numbers-wrapper"},[a("span",{staticClass:"line-number"},[s._v("1")]),a("br"),a("span",{staticClass:"line-number"},[s._v("2")]),a("br"),a("span",{staticClass:"line-number"},[s._v("3")]),a("br"),a("span",{staticClass:"line-number"},[s._v("4")]),a("br"),a("span",{staticClass:"line-number"},[s._v("5")]),a("br"),a("span",{staticClass:"line-number"},[s._v("6")]),a("br"),a("span",{staticClass:"line-number"},[s._v("7")]),a("br"),a("span",{staticClass:"line-number"},[s._v("8")]),a("br"),a("span",{staticClass:"line-number"},[s._v("9")]),a("br"),a("span",{staticClass:"line-number"},[s._v("10")]),a("br"),a("span",{staticClass:"line-number"},[s._v("11")]),a("br"),a("span",{staticClass:"line-number"},[s._v("12")]),a("br"),a("span",{staticClass:"line-number"},[s._v("13")]),a("br"),a("span",{staticClass:"line-number"},[s._v("14")]),a("br"),a("span",{staticClass:"line-number"},[s._v("15")]),a("br"),a("span",{staticClass:"line-number"},[s._v("16")]),a("br"),a("span",{staticClass:"line-number"},[s._v("17")]),a("br"),a("span",{staticClass:"line-number"},[s._v("18")]),a("br"),a("span",{staticClass:"line-number"},[s._v("19")]),a("br"),a("span",{staticClass:"line-number"},[s._v("20")]),a("br"),a("span",{staticClass:"line-number"},[s._v("21")]),a("br"),a("span",{staticClass:"line-number"},[s._v("22")]),a("br")])]),a("h3",{attrs:{id:"第三步：配置全局回调监听"}},[a("a",{staticClass:"header-anchor",attrs:{href:"#第三步：配置全局回调监听"}},[s._v("#")]),s._v(" 第三步：配置全局回调监听")]),s._v(" "),a("p",[s._v("以上两步其实已经实现了生命周期绑定的功能，但是在请求完成之后，我们需要在"),a("code",[s._v("lifecycle")]),s._v("中移除"),a("code",[s._v("LCObserver")]),s._v("对象：")]),s._v(" "),a("div",{staticClass:"language-java line-numbers-mode"},[a("pre",{pre:!0,attrs:{class:"language-java"}},[a("code",[a("span",{pre:!0,attrs:{class:"token class-name"}},[s._v("HTTP")]),s._v(" http "),a("span",{pre:!0,attrs:{class:"token operator"}},[s._v("=")]),s._v(" HTTP"),a("span",{pre:!0,attrs:{class:"token punctuation"}},[s._v(".")]),a("span",{pre:!0,attrs:{class:"token function"}},[s._v("builder")]),a("span",{pre:!0,attrs:{class:"token punctuation"}},[s._v("(")]),a("span",{pre:!0,attrs:{class:"token punctuation"}},[s._v(")")]),s._v("\n "),a("span",{pre:!0,attrs:{class:"token punctuation"}},[s._v(".")]),a("span",{pre:!0,attrs:{class:"token punctuation"}},[s._v(".")]),a("span",{pre:!0,attrs:{class:"token punctuation"}},[s._v(".")]),s._v(" "),a("span",{pre:!0,attrs:{class:"token comment"}},[s._v("// 省略其它配置项")]),s._v("\n "),a("span",{pre:!0,attrs:{class:"token punctuation"}},[s._v(".")]),a("span",{pre:!0,attrs:{class:"token function"}},[s._v("completeListener")]),a("span",{pre:!0,attrs:{class:"token punctuation"}},[s._v("(")]),a("span",{pre:!0,attrs:{class:"token punctuation"}},[s._v("(")]),a("span",{pre:!0,attrs:{class:"token class-name"}},[s._v("HttpTask")]),a("span",{pre:!0,attrs:{class:"token generics"}},[a("span",{pre:!0,attrs:{class:"token punctuation"}},[s._v("<")]),a("span",{pre:!0,attrs:{class:"token operator"}},[s._v("?")]),a("span",{pre:!0,attrs:{class:"token punctuation"}},[s._v(">")])]),s._v(" task"),a("span",{pre:!0,attrs:{class:"token punctuation"}},[s._v(",")]),s._v(" "),a("span",{pre:!0,attrs:{class:"token class-name"}},[s._v("HttpResult")]),a("span",{pre:!0,attrs:{class:"token punctuation"}},[s._v(".")]),a("span",{pre:!0,attrs:{class:"token class-name"}},[s._v("State")]),s._v(" state"),a("span",{pre:!0,attrs:{class:"token punctuation"}},[s._v(")")]),s._v(" "),a("span",{pre:!0,attrs:{class:"token operator"}},[s._v("->")]),s._v(" "),a("span",{pre:!0,attrs:{class:"token punctuation"}},[s._v("{")]),s._v("\n "),a("span",{pre:!0,attrs:{class:"token class-name"}},[s._v("Object")]),s._v(" bound "),a("span",{pre:!0,attrs:{class:"token operator"}},[s._v("=")]),s._v(" task"),a("span",{pre:!0,attrs:{class:"token punctuation"}},[s._v(".")]),a("span",{pre:!0,attrs:{class:"token function"}},[s._v("getBound")]),a("span",{pre:!0,attrs:{class:"token punctuation"}},[s._v("(")]),a("span",{pre:!0,attrs:{class:"token punctuation"}},[s._v(")")]),a("span",{pre:!0,attrs:{class:"token punctuation"}},[s._v(";")]),s._v("\n "),a("span",{pre:!0,attrs:{class:"token comment"}},[s._v("// 判断 task 是否绑定了生命周期监视器（LCObserver）对象")]),s._v("\n "),a("span",{pre:!0,attrs:{class:"token keyword"}},[s._v("if")]),s._v(" "),a("span",{pre:!0,attrs:{class:"token punctuation"}},[s._v("(")]),s._v("bound "),a("span",{pre:!0,attrs:{class:"token keyword"}},[s._v("instanceof")]),s._v(" "),a("span",{pre:!0,attrs:{class:"token class-name"}},[s._v("LCObserver")]),a("span",{pre:!0,attrs:{class:"token punctuation"}},[s._v(")")]),s._v(" "),a("span",{pre:!0,attrs:{class:"token punctuation"}},[s._v("{")]),s._v("\n "),a("span",{pre:!0,attrs:{class:"token comment"}},[s._v("// 解绑监视器")]),s._v("\n "),a("span",{pre:!0,attrs:{class:"token punctuation"}},[s._v("(")]),a("span",{pre:!0,attrs:{class:"token punctuation"}},[s._v("(")]),a("span",{pre:!0,attrs:{class:"token class-name"}},[s._v("LCObserver")]),a("span",{pre:!0,attrs:{class:"token punctuation"}},[s._v(")")]),s._v(" bound"),a("span",{pre:!0,attrs:{class:"token punctuation"}},[s._v(")")]),a("span",{pre:!0,attrs:{class:"token punctuation"}},[s._v(".")]),a("span",{pre:!0,attrs:{class:"token function"}},[s._v("unbind")]),a("span",{pre:!0,attrs:{class:"token punctuation"}},[s._v("(")]),a("span",{pre:!0,attrs:{class:"token punctuation"}},[s._v(")")]),a("span",{pre:!0,attrs:{class:"token punctuation"}},[s._v(";")]),s._v("\n "),a("span",{pre:!0,attrs:{class:"token punctuation"}},[s._v("}")]),s._v("\n "),a("span",{pre:!0,attrs:{class:"token keyword"}},[s._v("return")]),s._v(" "),a("span",{pre:!0,attrs:{class:"token boolean"}},[s._v("true")]),a("span",{pre:!0,attrs:{class:"token punctuation"}},[s._v(";")]),s._v("\n "),a("span",{pre:!0,attrs:{class:"token punctuation"}},[s._v("}")]),a("span",{pre:!0,attrs:{class:"token punctuation"}},[s._v(")")]),s._v("\n "),a("span",{pre:!0,attrs:{class:"token punctuation"}},[s._v(".")]),a("span",{pre:!0,attrs:{class:"token punctuation"}},[s._v(".")]),a("span",{pre:!0,attrs:{class:"token punctuation"}},[s._v(".")]),s._v(" "),a("span",{pre:!0,attrs:{class:"token comment"}},[s._v("// 省略其它配置项")]),s._v("\n "),a("span",{pre:!0,attrs:{class:"token punctuation"}},[s._v(".")]),a("span",{pre:!0,attrs:{class:"token function"}},[s._v("build")]),a("span",{pre:!0,attrs:{class:"token punctuation"}},[s._v("(")]),a("span",{pre:!0,attrs:{class:"token punctuation"}},[s._v(")")]),a("span",{pre:!0,attrs:{class:"token punctuation"}},[s._v(";")]),s._v("\n")])]),s._v(" "),a("div",{staticClass:"line-numbers-wrapper"},[a("span",{staticClass:"line-number"},[s._v("1")]),a("br"),a("span",{staticClass:"line-number"},[s._v("2")]),a("br"),a("span",{staticClass:"line-number"},[s._v("3")]),a("br"),a("span",{staticClass:"line-number"},[s._v("4")]),a("br"),a("span",{staticClass:"line-number"},[s._v("5")]),a("br"),a("span",{staticClass:"line-number"},[s._v("6")]),a("br"),a("span",{staticClass:"line-number"},[s._v("7")]),a("br"),a("span",{staticClass:"line-number"},[s._v("8")]),a("br"),a("span",{staticClass:"line-number"},[s._v("9")]),a("br"),a("span",{staticClass:"line-number"},[s._v("10")]),a("br"),a("span",{staticClass:"line-number"},[s._v("11")]),a("br"),a("span",{staticClass:"line-number"},[s._v("12")]),a("br"),a("span",{staticClass:"line-number"},[s._v("13")]),a("br")])]),a("p",[a("strong",[s._v("以上三步便在Android中实现了生命周期与HTTP请求绑定的功能")])]),s._v(" "),a("p",[s._v("非常简单，懒得敲代码的同学还可以 "),a("a",{attrs:{href:"https://gitee.com/ejlchina-zhxu/okhttps-android-demo/blob/master/app/src/main/java/com/flower/myapplication/http/OkHttps.java",target:"_blank",rel:"noopener noreferrer"}},[s._v("点这里 OkHttps.java"),a("OutboundLink")],1),s._v(" 直接下载封装好的源码，其中不仅编写了生命周期绑定的配置，还有在UI线程执行回调的配置。")]),s._v(" "),a("p",[s._v("有需要的同学，可以直接下载下来使用，还可以基于它再次扩展，比如实现自动添加 TOKEN 的功能，具体可以参考"),a("a",{attrs:{href:"#65-%E4%B8%B2%E8%A1%8C%E9%A2%84%E5%A4%84%E7%90%86%E5%99%A8token%E9%97%AE%E9%A2%98%E6%9C%80%E4%BD%B3%E8%A7%A3%E5%86%B3%E6%96%B9%E6%A1%88"}},[s._v("6.5 串行预处理器（TOKEN问题最佳解决方案）")]),s._v("，再比如扩展实现生命周期与下载事件绑定的功能，都非常简单。")])])}),[],!1,null,null,null);t.default=e.exports}}]); \ No newline at end of file diff --git a/okhttps-doc/docs/.vuepress/dist/assets/js/9.bff804f8.js b/okhttps-doc/docs/.vuepress/dist/assets/js/9.bff804f8.js deleted file mode 100644 index 2dae5b30..00000000 --- a/okhttps-doc/docs/.vuepress/dist/assets/js/9.bff804f8.js +++ /dev/null @@ -1 +0,0 @@ -(window.webpackJsonp=window.webpackJsonp||[]).push([[9],{339:function(t,s,a){"use strict";a.r(s);var n=a(19),e=Object(n.a)({},(function(){var t=this,s=t.$createElement,a=t._self._c||s;return a("ContentSlotsDistributor",{attrs:{"slot-key":t.$parent.slotKey}},[a("h1",{attrs:{id:"配置"}},[a("a",{staticClass:"header-anchor",attrs:{href:"#配置"}},[t._v("#")]),t._v(" 配置")]),t._v(" "),a("h2",{attrs:{id:"设置-baseurl"}},[a("a",{staticClass:"header-anchor",attrs:{href:"#设置-baseurl"}},[t._v("#")]),t._v(" 设置 BaseUrl")]),t._v(" "),a("div",{staticClass:"language-java line-numbers-mode"},[a("pre",{pre:!0,attrs:{class:"language-java"}},[a("code",[a("span",{pre:!0,attrs:{class:"token class-name"}},[t._v("HTTP")]),t._v(" http "),a("span",{pre:!0,attrs:{class:"token operator"}},[t._v("=")]),t._v(" HTTP"),a("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v(".")]),a("span",{pre:!0,attrs:{class:"token function"}},[t._v("builder")]),a("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v("(")]),a("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v(")")]),t._v("\n "),a("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v(".")]),a("span",{pre:!0,attrs:{class:"token function"}},[t._v("baseUrl")]),a("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v("(")]),a("span",{pre:!0,attrs:{class:"token string"}},[t._v('"http://api.demo.com"')]),a("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v(")")]),t._v(" "),a("span",{pre:!0,attrs:{class:"token comment"}},[t._v("// 设置 BaseUrl")]),t._v("\n "),a("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v(".")]),a("span",{pre:!0,attrs:{class:"token function"}},[t._v("build")]),a("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v("(")]),a("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v(")")]),a("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v(";")]),t._v("\n")])]),t._v(" "),a("div",{staticClass:"line-numbers-wrapper"},[a("span",{staticClass:"line-number"},[t._v("1")]),a("br"),a("span",{staticClass:"line-number"},[t._v("2")]),a("br"),a("span",{staticClass:"line-number"},[t._v("3")]),a("br")])]),a("p",[t._v("该配置全局生效，在配置了"),a("code",[t._v("BaseUrl")]),t._v("之后，具体的请求便可以省略"),a("code",[t._v("BaseUrl")]),t._v("部分，使得代码更加简洁，例如：")]),t._v(" "),a("div",{staticClass:"language-java line-numbers-mode"},[a("pre",{pre:!0,attrs:{class:"language-java"}},[a("code",[t._v("http"),a("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v(".")]),a("span",{pre:!0,attrs:{class:"token function"}},[t._v("sync")]),a("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v("(")]),a("span",{pre:!0,attrs:{class:"token string"}},[t._v('"/users"')]),a("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v(")")]),a("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v(".")]),a("span",{pre:!0,attrs:{class:"token function"}},[t._v("get")]),a("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v("(")]),a("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v(")")]),t._v(" "),a("span",{pre:!0,attrs:{class:"token comment"}},[t._v("// http://api.demo.com/users")]),t._v("\n\nhttp"),a("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v(".")]),a("span",{pre:!0,attrs:{class:"token function"}},[t._v("sync")]),a("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v("(")]),a("span",{pre:!0,attrs:{class:"token string"}},[t._v('"/auth/signin"')]),a("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v(")")]),t._v(" "),a("span",{pre:!0,attrs:{class:"token comment"}},[t._v("// http://api.demo.com/auth/signin")]),t._v("\n "),a("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v(".")]),a("span",{pre:!0,attrs:{class:"token function"}},[t._v("addBodyParam")]),a("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v("(")]),a("span",{pre:!0,attrs:{class:"token string"}},[t._v('"username"')]),a("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v(",")]),t._v(" "),a("span",{pre:!0,attrs:{class:"token string"}},[t._v('"Jackson"')]),a("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v(")")]),t._v("\n "),a("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v(".")]),a("span",{pre:!0,attrs:{class:"token function"}},[t._v("addBodyParam")]),a("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v("(")]),a("span",{pre:!0,attrs:{class:"token string"}},[t._v('"password"')]),a("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v(",")]),t._v(" "),a("span",{pre:!0,attrs:{class:"token string"}},[t._v('"xxxxxx"')]),a("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v(")")]),t._v("\n "),a("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v(".")]),a("span",{pre:!0,attrs:{class:"token function"}},[t._v("post")]),a("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v("(")]),a("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v(")")]),a("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v(";")]),t._v(" "),a("span",{pre:!0,attrs:{class:"token comment"}},[t._v("// POST请求")]),t._v("\n")])]),t._v(" "),a("div",{staticClass:"line-numbers-wrapper"},[a("span",{staticClass:"line-number"},[t._v("1")]),a("br"),a("span",{staticClass:"line-number"},[t._v("2")]),a("br"),a("span",{staticClass:"line-number"},[t._v("3")]),a("br"),a("span",{staticClass:"line-number"},[t._v("4")]),a("br"),a("span",{staticClass:"line-number"},[t._v("5")]),a("br"),a("span",{staticClass:"line-number"},[t._v("6")]),a("br")])]),a("p",[t._v("在配置了"),a("code",[t._v("BaseUrl")]),t._v("之后，如有特殊请求任务，仍然可以使用全路径的方式，一点都不妨碍：")]),t._v(" "),a("div",{staticClass:"language-java line-numbers-mode"},[a("pre",{pre:!0,attrs:{class:"language-java"}},[a("code",[t._v("http"),a("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v(".")]),a("span",{pre:!0,attrs:{class:"token function"}},[t._v("sync")]),a("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v("(")]),a("span",{pre:!0,attrs:{class:"token string"}},[t._v('"https://www.baidu.com"')]),a("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v(")")]),a("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v(".")]),a("span",{pre:!0,attrs:{class:"token function"}},[t._v("get")]),a("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v("(")]),a("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v(")")]),a("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v(";")]),t._v("\n")])]),t._v(" "),a("div",{staticClass:"line-numbers-wrapper"},[a("span",{staticClass:"line-number"},[t._v("1")]),a("br")])]),a("h2",{attrs:{id:"回调执行器"}},[a("a",{staticClass:"header-anchor",attrs:{href:"#回调执行器"}},[t._v("#")]),t._v(" 回调执行器")]),t._v(" "),a("p",[t._v("OkHttps 默认所有回调都在 "),a("strong",[t._v("IO线程")]),t._v(" 执行，如何想改变执行回调的线程时，可以配置回调执行器。例如在Android里，让所有的回调函数都在UI线程执行，则可以在构建"),a("code",[t._v("HTTP")]),t._v("时配置如下：")]),t._v(" "),a("div",{staticClass:"language-java line-numbers-mode"},[a("pre",{pre:!0,attrs:{class:"language-java"}},[a("code",[a("span",{pre:!0,attrs:{class:"token class-name"}},[t._v("HTTP")]),t._v(" http "),a("span",{pre:!0,attrs:{class:"token operator"}},[t._v("=")]),t._v(" HTTP"),a("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v(".")]),a("span",{pre:!0,attrs:{class:"token function"}},[t._v("builder")]),a("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v("(")]),a("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v(")")]),t._v("\n "),a("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v(".")]),a("span",{pre:!0,attrs:{class:"token function"}},[t._v("callbackExecutor")]),a("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v("(")]),a("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v("(")]),a("span",{pre:!0,attrs:{class:"token class-name"}},[t._v("Runnable")]),t._v(" run"),a("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v(")")]),t._v(" "),a("span",{pre:!0,attrs:{class:"token operator"}},[t._v("->")]),t._v(" "),a("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v("{")]),t._v("\n "),a("span",{pre:!0,attrs:{class:"token function"}},[t._v("runOnUiThread")]),a("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v("(")]),t._v("run"),a("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v(")")]),a("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v(";")]),t._v(" "),a("span",{pre:!0,attrs:{class:"token comment"}},[t._v("// 在UI线程执行")]),t._v("\n "),a("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v("}")]),a("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v(")")]),t._v("\n "),a("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v(".")]),a("span",{pre:!0,attrs:{class:"token function"}},[t._v("build")]),a("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v("(")]),a("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v(")")]),a("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v(";")]),t._v("\n")])]),t._v(" "),a("div",{staticClass:"line-numbers-wrapper"},[a("span",{staticClass:"line-number"},[t._v("1")]),a("br"),a("span",{staticClass:"line-number"},[t._v("2")]),a("br"),a("span",{staticClass:"line-number"},[t._v("3")]),a("br"),a("span",{staticClass:"line-number"},[t._v("4")]),a("br"),a("span",{staticClass:"line-number"},[t._v("5")]),a("br")])]),a("p",[t._v("该配置默认 "),a("strong",[t._v("影响所有回调")]),t._v("。")]),t._v(" "),a("h2",{attrs:{id:"配置-okhttpclient"}},[a("a",{staticClass:"header-anchor",attrs:{href:"#配置-okhttpclient"}},[t._v("#")]),t._v(" 配置 OkHttpClient")]),t._v(" "),a("p",[t._v("与其他封装 OkHttp3 的框架不同，OkHttps 并不会遮蔽 OkHttp3 本身就很好用的功能，如下：")]),t._v(" "),a("div",{staticClass:"language-java line-numbers-mode"},[a("pre",{pre:!0,attrs:{class:"language-java"}},[a("code",[a("span",{pre:!0,attrs:{class:"token class-name"}},[t._v("HTTP")]),t._v(" http "),a("span",{pre:!0,attrs:{class:"token operator"}},[t._v("=")]),t._v(" HTTP"),a("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v(".")]),a("span",{pre:!0,attrs:{class:"token function"}},[t._v("builder")]),a("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v("(")]),a("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v(")")]),t._v("\n "),a("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v(".")]),a("span",{pre:!0,attrs:{class:"token function"}},[t._v("config")]),a("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v("(")]),a("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v("(")]),a("span",{pre:!0,attrs:{class:"token class-name"}},[t._v("Builder")]),t._v(" builder"),a("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v(")")]),t._v(" "),a("span",{pre:!0,attrs:{class:"token operator"}},[t._v("->")]),t._v(" "),a("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v("{")]),t._v("\n "),a("span",{pre:!0,attrs:{class:"token comment"}},[t._v("// 配置连接池 最小10个连接（不配置默认为 5）")]),t._v("\n builder"),a("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v(".")]),a("span",{pre:!0,attrs:{class:"token function"}},[t._v("connectionPool")]),a("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v("(")]),a("span",{pre:!0,attrs:{class:"token keyword"}},[t._v("new")]),t._v(" "),a("span",{pre:!0,attrs:{class:"token class-name"}},[t._v("ConnectionPool")]),a("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v("(")]),a("span",{pre:!0,attrs:{class:"token number"}},[t._v("10")]),a("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v(",")]),t._v(" "),a("span",{pre:!0,attrs:{class:"token number"}},[t._v("5")]),a("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v(",")]),t._v(" "),a("span",{pre:!0,attrs:{class:"token class-name"}},[t._v("TimeUnit")]),a("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v(".")]),t._v("MINUTES"),a("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v(")")]),a("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v(")")]),a("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v(";")]),t._v("\n "),a("span",{pre:!0,attrs:{class:"token comment"}},[t._v("// 配置连接超时时间（默认10秒）")]),t._v("\n builder"),a("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v(".")]),a("span",{pre:!0,attrs:{class:"token function"}},[t._v("connectTimeout")]),a("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v("(")]),a("span",{pre:!0,attrs:{class:"token number"}},[t._v("20")]),a("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v(",")]),t._v(" "),a("span",{pre:!0,attrs:{class:"token class-name"}},[t._v("TimeUnit")]),a("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v(".")]),t._v("SECONDS"),a("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v(")")]),a("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v(";")]),t._v("\n "),a("span",{pre:!0,attrs:{class:"token comment"}},[t._v("// 配置拦截器")]),t._v("\n builder"),a("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v(".")]),a("span",{pre:!0,attrs:{class:"token function"}},[t._v("addInterceptor")]),a("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v("(")]),a("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v("(")]),a("span",{pre:!0,attrs:{class:"token class-name"}},[t._v("Chain")]),t._v(" chain"),a("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v(")")]),t._v(" "),a("span",{pre:!0,attrs:{class:"token operator"}},[t._v("->")]),t._v(" "),a("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v("{")]),t._v("\n "),a("span",{pre:!0,attrs:{class:"token class-name"}},[t._v("Request")]),t._v(" request "),a("span",{pre:!0,attrs:{class:"token operator"}},[t._v("=")]),t._v(" chain"),a("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v(".")]),a("span",{pre:!0,attrs:{class:"token function"}},[t._v("request")]),a("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v("(")]),a("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v(")")]),a("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v(";")]),t._v("\n "),a("span",{pre:!0,attrs:{class:"token comment"}},[t._v("// 必须同步返回，拦截器内无法执行异步操作")]),t._v("\n "),a("span",{pre:!0,attrs:{class:"token keyword"}},[t._v("return")]),t._v(" chain"),a("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v(".")]),a("span",{pre:!0,attrs:{class:"token function"}},[t._v("proceed")]),a("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v("(")]),t._v("request"),a("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v(")")]),a("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v(";")]),t._v("\n "),a("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v("}")]),a("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v(")")]),a("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v(";")]),t._v("\n "),a("span",{pre:!0,attrs:{class:"token comment"}},[t._v("// 其它配置: CookieJar、SSL、缓存、代理、事件监听...")]),t._v("\n "),a("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v("}")]),a("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v(")")]),t._v("\n "),a("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v(".")]),a("span",{pre:!0,attrs:{class:"token function"}},[t._v("build")]),a("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v("(")]),a("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v(")")]),a("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v(";")]),t._v("\n")])]),t._v(" "),a("div",{staticClass:"line-numbers-wrapper"},[a("span",{staticClass:"line-number"},[t._v("1")]),a("br"),a("span",{staticClass:"line-number"},[t._v("2")]),a("br"),a("span",{staticClass:"line-number"},[t._v("3")]),a("br"),a("span",{staticClass:"line-number"},[t._v("4")]),a("br"),a("span",{staticClass:"line-number"},[t._v("5")]),a("br"),a("span",{staticClass:"line-number"},[t._v("6")]),a("br"),a("span",{staticClass:"line-number"},[t._v("7")]),a("br"),a("span",{staticClass:"line-number"},[t._v("8")]),a("br"),a("span",{staticClass:"line-number"},[t._v("9")]),a("br"),a("span",{staticClass:"line-number"},[t._v("10")]),a("br"),a("span",{staticClass:"line-number"},[t._v("11")]),a("br"),a("span",{staticClass:"line-number"},[t._v("12")]),a("br"),a("span",{staticClass:"line-number"},[t._v("13")]),a("br"),a("span",{staticClass:"line-number"},[t._v("14")]),a("br"),a("span",{staticClass:"line-number"},[t._v("15")]),a("br")])]),a("h2",{attrs:{id:"并行预处理器"}},[a("a",{staticClass:"header-anchor",attrs:{href:"#并行预处理器"}},[t._v("#")]),t._v(" 并行预处理器")]),t._v(" "),a("p",[t._v("预处理器（"),a("code",[t._v("Preprocessor")]),t._v("）可以让我们在请求发出之前对请求本身做一些改变，但与"),a("code",[t._v("OkHttp")]),t._v("的拦截器（"),a("code",[t._v("Interceptor")]),t._v("）不同：预处理器可以让我们 "),a("strong",[t._v("异步")]),t._v(" 处理这些问题。")]),t._v(" "),a("p",[t._v("例如，当我们想为请求任务自动添加"),a("code",[t._v("Token")]),t._v("头信息，而"),a("code",[t._v("Token")]),t._v("只能通过异步方法"),a("code",[t._v("requestToken")]),t._v("获取时，这时使用"),a("code",[t._v("Interceptor")]),t._v("就很难处理了，但可以使用预处理器轻松解决：")]),t._v(" "),a("div",{staticClass:"language-java line-numbers-mode"},[a("pre",{pre:!0,attrs:{class:"language-java"}},[a("code",[a("span",{pre:!0,attrs:{class:"token class-name"}},[t._v("HTTP")]),t._v(" http "),a("span",{pre:!0,attrs:{class:"token operator"}},[t._v("=")]),t._v(" HTTP"),a("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v(".")]),a("span",{pre:!0,attrs:{class:"token function"}},[t._v("builder")]),a("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v("(")]),a("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v(")")]),t._v("\n "),a("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v(".")]),a("span",{pre:!0,attrs:{class:"token function"}},[t._v("addPreprocessor")]),a("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v("(")]),a("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v("(")]),a("span",{pre:!0,attrs:{class:"token class-name"}},[t._v("PreChain")]),t._v(" chain"),a("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v(")")]),t._v(" "),a("span",{pre:!0,attrs:{class:"token operator"}},[t._v("->")]),t._v(" "),a("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v("{")]),t._v("\n "),a("span",{pre:!0,attrs:{class:"token class-name"}},[t._v("HttpTask")]),a("span",{pre:!0,attrs:{class:"token generics"}},[a("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v("<")]),a("span",{pre:!0,attrs:{class:"token operator"}},[t._v("?")]),a("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v(">")])]),t._v(" task "),a("span",{pre:!0,attrs:{class:"token operator"}},[t._v("=")]),t._v(" chain"),a("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v(".")]),a("span",{pre:!0,attrs:{class:"token function"}},[t._v("getTask")]),a("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v("(")]),a("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v(")")]),a("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v(";")]),a("span",{pre:!0,attrs:{class:"token comment"}},[t._v("// 获得当前的HTTP任务")]),t._v("\n "),a("span",{pre:!0,attrs:{class:"token keyword"}},[t._v("if")]),t._v(" "),a("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v("(")]),a("span",{pre:!0,attrs:{class:"token operator"}},[t._v("!")]),t._v("task"),a("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v(".")]),a("span",{pre:!0,attrs:{class:"token function"}},[t._v("isTagged")]),a("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v("(")]),a("span",{pre:!0,attrs:{class:"token string"}},[t._v('"Auth"')]),a("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v(")")]),a("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v(")")]),t._v(" "),a("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v("{")]),t._v(" "),a("span",{pre:!0,attrs:{class:"token comment"}},[t._v("// 根据标签判断该任务是否需要Token")]),t._v("\n chain"),a("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v(".")]),a("span",{pre:!0,attrs:{class:"token function"}},[t._v("proceed")]),a("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v("(")]),a("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v(")")]),a("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v(";")]),t._v("\n "),a("span",{pre:!0,attrs:{class:"token keyword"}},[t._v("return")]),a("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v(";")]),t._v("\n "),a("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v("}")]),t._v("\n "),a("span",{pre:!0,attrs:{class:"token function"}},[t._v("requestToken")]),a("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v("(")]),a("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v("(")]),a("span",{pre:!0,attrs:{class:"token class-name"}},[t._v("String")]),t._v(" token"),a("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v(")")]),t._v(" "),a("span",{pre:!0,attrs:{class:"token operator"}},[t._v("->")]),t._v(" "),a("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v("{")]),t._v(" "),a("span",{pre:!0,attrs:{class:"token comment"}},[t._v("// 异步获取 Token")]),t._v("\n task"),a("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v(".")]),a("span",{pre:!0,attrs:{class:"token function"}},[t._v("addHeader")]),a("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v("(")]),a("span",{pre:!0,attrs:{class:"token string"}},[t._v('"Token"')]),a("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v(",")]),t._v(" token"),a("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v(")")]),a("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v(";")]),a("span",{pre:!0,attrs:{class:"token comment"}},[t._v("// 为任务添加头信息")]),t._v("\n chain"),a("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v(".")]),a("span",{pre:!0,attrs:{class:"token function"}},[t._v("proceed")]),a("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v("(")]),a("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v(")")]),a("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v(";")]),t._v(" "),a("span",{pre:!0,attrs:{class:"token comment"}},[t._v("// 继续当前的任务")]),t._v("\n "),a("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v("}")]),a("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v(")")]),a("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v(";")]),t._v("\n "),a("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v("}")]),a("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v(")")]),t._v("\n "),a("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v(".")]),a("span",{pre:!0,attrs:{class:"token function"}},[t._v("build")]),a("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v("(")]),a("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v(")")]),a("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v(";")]),t._v("\n")])]),t._v(" "),a("div",{staticClass:"line-numbers-wrapper"},[a("span",{staticClass:"line-number"},[t._v("1")]),a("br"),a("span",{staticClass:"line-number"},[t._v("2")]),a("br"),a("span",{staticClass:"line-number"},[t._v("3")]),a("br"),a("span",{staticClass:"line-number"},[t._v("4")]),a("br"),a("span",{staticClass:"line-number"},[t._v("5")]),a("br"),a("span",{staticClass:"line-number"},[t._v("6")]),a("br"),a("span",{staticClass:"line-number"},[t._v("7")]),a("br"),a("span",{staticClass:"line-number"},[t._v("8")]),a("br"),a("span",{staticClass:"line-number"},[t._v("9")]),a("br"),a("span",{staticClass:"line-number"},[t._v("10")]),a("br"),a("span",{staticClass:"line-number"},[t._v("11")]),a("br"),a("span",{staticClass:"line-number"},[t._v("12")]),a("br"),a("span",{staticClass:"line-number"},[t._v("13")]),a("br")])]),a("p",[t._v("和"),a("code",[t._v("Interceptor")]),t._v("一样，"),a("code",[t._v("Preprocessor")]),t._v("也可以添加多个。他们之间的区别如下:")]),t._v(" "),a("div",{staticClass:"custom-block tip"},[a("p",{staticClass:"custom-block-title"},[t._v("拦截器与预处理器的区别")]),t._v(" "),a("ul",[a("li",[t._v("拦截器只能处理同步操作，预处理器支持处理异步操作")]),t._v(" "),a("li",[t._v("拦截器都是并行处理请求，预处理器支持串行处理（详见6.5章节）")]),t._v(" "),a("li",[t._v("拦截器处理时机在请求前和响应后，预处理器只在请求前，并且先于拦截器执行。关于响应后，OkHttps还提供了全局回调监听（详见6.6章节）")])])]),t._v(" "),a("h2",{attrs:{id:"串行预处理器（token问题最佳解决方案）"}},[a("a",{staticClass:"header-anchor",attrs:{href:"#串行预处理器（token问题最佳解决方案）"}},[t._v("#")]),t._v(" 串行预处理器（TOKEN问题最佳解决方案）")]),t._v(" "),a("p",[t._v("普通预处理器都是可并行处理的，然而有时我们希望某个预处理器同时只处理一个任务。比如 当"),a("code",[t._v("Token")]),t._v("过期时我们需要去刷新获取新"),a("code",[t._v("Token")]),t._v("，而刷新"),a("code",[t._v("Token")]),t._v("这个操作只能有一个任务去执行，因为如果"),a("code",[t._v("n")]),t._v("个任务同时执行的话，那么必有"),a("code",[t._v("n-1")]),t._v("个任务刚刷新得到的"),a("code",[t._v("Token")]),t._v("可能就立马失效了，而这是我们所不希望的。")]),t._v(" "),a("p",[t._v("为了解决这个问题，OkHttps 提供了串行预处理器，它可以让 HTTP 任务排好队，一个一个地进入预处理器：")]),t._v(" "),a("div",{staticClass:"language-java line-numbers-mode"},[a("pre",{pre:!0,attrs:{class:"language-java"}},[a("code",[a("span",{pre:!0,attrs:{class:"token class-name"}},[t._v("HTTP")]),t._v(" http "),a("span",{pre:!0,attrs:{class:"token operator"}},[t._v("=")]),t._v(" HTTP"),a("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v(".")]),a("span",{pre:!0,attrs:{class:"token function"}},[t._v("builder")]),a("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v("(")]),a("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v(")")]),t._v("\n "),a("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v(".")]),a("span",{pre:!0,attrs:{class:"token function"}},[t._v("addSerialPreprocessor")]),a("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v("(")]),a("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v("(")]),a("span",{pre:!0,attrs:{class:"token class-name"}},[t._v("PreChain")]),t._v(" chain"),a("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v(")")]),t._v(" "),a("span",{pre:!0,attrs:{class:"token operator"}},[t._v("->")]),t._v(" "),a("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v("{")]),t._v("\n "),a("span",{pre:!0,attrs:{class:"token class-name"}},[t._v("HttpTask")]),a("span",{pre:!0,attrs:{class:"token generics"}},[a("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v("<")]),a("span",{pre:!0,attrs:{class:"token operator"}},[t._v("?")]),a("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v(">")])]),t._v(" task "),a("span",{pre:!0,attrs:{class:"token operator"}},[t._v("=")]),t._v(" chain"),a("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v(".")]),a("span",{pre:!0,attrs:{class:"token function"}},[t._v("getTask")]),a("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v("(")]),a("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v(")")]),a("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v(";")]),t._v("\n "),a("span",{pre:!0,attrs:{class:"token keyword"}},[t._v("if")]),t._v(" "),a("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v("(")]),a("span",{pre:!0,attrs:{class:"token operator"}},[t._v("!")]),t._v("task"),a("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v(".")]),a("span",{pre:!0,attrs:{class:"token function"}},[t._v("isTagged")]),a("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v("(")]),a("span",{pre:!0,attrs:{class:"token string"}},[t._v('"Auth"')]),a("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v(")")]),a("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v(")")]),t._v(" "),a("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v("{")]),t._v("\n chain"),a("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v(".")]),a("span",{pre:!0,attrs:{class:"token function"}},[t._v("proceed")]),a("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v("(")]),a("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v(")")]),a("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v(";")]),t._v("\n "),a("span",{pre:!0,attrs:{class:"token keyword"}},[t._v("return")]),a("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v(";")]),t._v("\n "),a("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v("}")]),t._v("\n "),a("span",{pre:!0,attrs:{class:"token comment"}},[t._v("// 检查过期，若需要则刷新Token")]),t._v("\n "),a("span",{pre:!0,attrs:{class:"token function"}},[t._v("requestTokenAndRefreshIfExpired")]),a("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v("(")]),a("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v("(")]),a("span",{pre:!0,attrs:{class:"token class-name"}},[t._v("String")]),t._v(" token"),a("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v(")")]),t._v(" "),a("span",{pre:!0,attrs:{class:"token operator"}},[t._v("->")]),t._v(" "),a("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v("{")]),t._v("\n task"),a("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v(".")]),a("span",{pre:!0,attrs:{class:"token function"}},[t._v("addHeader")]),a("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v("(")]),a("span",{pre:!0,attrs:{class:"token string"}},[t._v('"Token"')]),a("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v(",")]),t._v(" token"),a("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v(")")]),a("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v(";")]),t._v(" \n chain"),a("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v(".")]),a("span",{pre:!0,attrs:{class:"token function"}},[t._v("proceed")]),a("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v("(")]),a("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v(")")]),a("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v(";")]),t._v(" "),a("span",{pre:!0,attrs:{class:"token comment"}},[t._v("// 调用此方法前，不会有其它任务进入该处理器")]),t._v("\n "),a("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v("}")]),a("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v(")")]),a("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v(";")]),t._v("\n "),a("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v("}")]),a("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v(")")]),t._v("\n "),a("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v(".")]),a("span",{pre:!0,attrs:{class:"token function"}},[t._v("build")]),a("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v("(")]),a("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v(")")]),a("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v(";")]),t._v("\n")])]),t._v(" "),a("div",{staticClass:"line-numbers-wrapper"},[a("span",{staticClass:"line-number"},[t._v("1")]),a("br"),a("span",{staticClass:"line-number"},[t._v("2")]),a("br"),a("span",{staticClass:"line-number"},[t._v("3")]),a("br"),a("span",{staticClass:"line-number"},[t._v("4")]),a("br"),a("span",{staticClass:"line-number"},[t._v("5")]),a("br"),a("span",{staticClass:"line-number"},[t._v("6")]),a("br"),a("span",{staticClass:"line-number"},[t._v("7")]),a("br"),a("span",{staticClass:"line-number"},[t._v("8")]),a("br"),a("span",{staticClass:"line-number"},[t._v("9")]),a("br"),a("span",{staticClass:"line-number"},[t._v("10")]),a("br"),a("span",{staticClass:"line-number"},[t._v("11")]),a("br"),a("span",{staticClass:"line-number"},[t._v("12")]),a("br"),a("span",{staticClass:"line-number"},[t._v("13")]),a("br"),a("span",{staticClass:"line-number"},[t._v("14")]),a("br")])]),a("p",[t._v("串行预处理器实现了让HTTP任务排队串行处理的功能，但值得一提的是：它并没有因此而阻塞任何线程！")]),t._v(" "),a("h2",{attrs:{id:"全局回调监听"}},[a("a",{staticClass:"header-anchor",attrs:{href:"#全局回调监听"}},[t._v("#")]),t._v(" 全局回调监听")]),t._v(" "),a("p",[t._v("全局回调是实际开发中经常需要的功能，比如对服务器响应的状态码进行统一处理等，同时 OkHttps 的全局回调还具有 "),a("strong",[t._v("回调阻断")]),t._v(" 的功能：")]),t._v(" "),a("div",{staticClass:"language-java line-numbers-mode"},[a("pre",{pre:!0,attrs:{class:"language-java"}},[a("code",[a("span",{pre:!0,attrs:{class:"token class-name"}},[t._v("HTTP")]),t._v(" http "),a("span",{pre:!0,attrs:{class:"token operator"}},[t._v("=")]),t._v(" HTTP"),a("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v(".")]),a("span",{pre:!0,attrs:{class:"token function"}},[t._v("builder")]),a("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v("(")]),a("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v(")")]),t._v("\n "),a("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v(".")]),a("span",{pre:!0,attrs:{class:"token function"}},[t._v("responseListener")]),a("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v("(")]),a("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v("(")]),a("span",{pre:!0,attrs:{class:"token class-name"}},[t._v("HttpTask")]),a("span",{pre:!0,attrs:{class:"token generics"}},[a("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v("<")]),a("span",{pre:!0,attrs:{class:"token operator"}},[t._v("?")]),a("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v(">")])]),t._v(" task"),a("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v(",")]),t._v(" "),a("span",{pre:!0,attrs:{class:"token class-name"}},[t._v("HttpResult")]),t._v(" result"),a("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v(")")]),t._v(" "),a("span",{pre:!0,attrs:{class:"token operator"}},[t._v("->")]),t._v(" "),a("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v("{")]),t._v("\n "),a("span",{pre:!0,attrs:{class:"token comment"}},[t._v("// 所有请求响应后都会走这里")]),t._v("\n\n "),a("span",{pre:!0,attrs:{class:"token keyword"}},[t._v("return")]),t._v(" "),a("span",{pre:!0,attrs:{class:"token boolean"}},[t._v("true")]),a("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v(";")]),t._v(" "),a("span",{pre:!0,attrs:{class:"token comment"}},[t._v("// 返回 true 表示继续执行 task 的 OnResponse 回调，false 表示不再执行")]),t._v("\n "),a("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v("}")]),a("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v(")")]),t._v("\n "),a("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v(".")]),a("span",{pre:!0,attrs:{class:"token function"}},[t._v("completeListener")]),a("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v("(")]),a("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v("(")]),a("span",{pre:!0,attrs:{class:"token class-name"}},[t._v("HttpTask")]),a("span",{pre:!0,attrs:{class:"token generics"}},[a("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v("<")]),a("span",{pre:!0,attrs:{class:"token operator"}},[t._v("?")]),a("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v(">")])]),t._v(" task"),a("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v(",")]),t._v(" "),a("span",{pre:!0,attrs:{class:"token class-name"}},[t._v("State")]),t._v(" state"),a("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v(")")]),t._v(" "),a("span",{pre:!0,attrs:{class:"token operator"}},[t._v("->")]),t._v(" "),a("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v("{")]),t._v("\n "),a("span",{pre:!0,attrs:{class:"token comment"}},[t._v("// 所有请求执行完都会走这里")]),t._v("\n\n "),a("span",{pre:!0,attrs:{class:"token keyword"}},[t._v("return")]),t._v(" "),a("span",{pre:!0,attrs:{class:"token boolean"}},[t._v("true")]),a("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v(";")]),t._v(" "),a("span",{pre:!0,attrs:{class:"token comment"}},[t._v("// 返回 true 表示继续执行 task 的 OnComplete 回调，false 表示不再执行")]),t._v("\n "),a("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v("}")]),a("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v(")")]),t._v("\n "),a("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v(".")]),a("span",{pre:!0,attrs:{class:"token function"}},[t._v("exceptionListener")]),a("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v("(")]),a("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v("(")]),a("span",{pre:!0,attrs:{class:"token class-name"}},[t._v("HttpTask")]),a("span",{pre:!0,attrs:{class:"token generics"}},[a("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v("<")]),a("span",{pre:!0,attrs:{class:"token operator"}},[t._v("?")]),a("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v(">")])]),t._v(" task"),a("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v(",")]),t._v(" "),a("span",{pre:!0,attrs:{class:"token class-name"}},[t._v("IOException")]),t._v(" error"),a("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v(")")]),t._v(" "),a("span",{pre:!0,attrs:{class:"token operator"}},[t._v("->")]),t._v(" "),a("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v("{")]),t._v("\n "),a("span",{pre:!0,attrs:{class:"token comment"}},[t._v("// 所有请求发生异常都会走这里")]),t._v("\n\n "),a("span",{pre:!0,attrs:{class:"token keyword"}},[t._v("return")]),t._v(" "),a("span",{pre:!0,attrs:{class:"token boolean"}},[t._v("true")]),a("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v(";")]),t._v(" "),a("span",{pre:!0,attrs:{class:"token comment"}},[t._v("// 返回 true 表示继续执行 task 的 OnException 回调，false 表示不再执行")]),t._v("\n "),a("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v("}")]),a("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v(")")]),t._v("\n "),a("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v(".")]),a("span",{pre:!0,attrs:{class:"token function"}},[t._v("build")]),a("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v("(")]),a("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v(")")]),a("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v(";")]),t._v("\n")])]),t._v(" "),a("div",{staticClass:"line-numbers-wrapper"},[a("span",{staticClass:"line-number"},[t._v("1")]),a("br"),a("span",{staticClass:"line-number"},[t._v("2")]),a("br"),a("span",{staticClass:"line-number"},[t._v("3")]),a("br"),a("span",{staticClass:"line-number"},[t._v("4")]),a("br"),a("span",{staticClass:"line-number"},[t._v("5")]),a("br"),a("span",{staticClass:"line-number"},[t._v("6")]),a("br"),a("span",{staticClass:"line-number"},[t._v("7")]),a("br"),a("span",{staticClass:"line-number"},[t._v("8")]),a("br"),a("span",{staticClass:"line-number"},[t._v("9")]),a("br"),a("span",{staticClass:"line-number"},[t._v("10")]),a("br"),a("span",{staticClass:"line-number"},[t._v("11")]),a("br"),a("span",{staticClass:"line-number"},[t._v("12")]),a("br"),a("span",{staticClass:"line-number"},[t._v("13")]),a("br"),a("span",{staticClass:"line-number"},[t._v("14")]),a("br"),a("span",{staticClass:"line-number"},[t._v("15")]),a("br"),a("span",{staticClass:"line-number"},[t._v("16")]),a("br"),a("span",{staticClass:"line-number"},[t._v("17")]),a("br")])]),a("div",{staticClass:"custom-block tip"},[a("p",{staticClass:"custom-block-title"},[t._v("全局回调监听与拦截器的异同：")]),t._v(" "),a("ul",[a("li",[t._v("拦截器可以添加多个，全局回调监听分三种，每种最多添加一个")]),t._v(" "),a("li",[t._v("拦截器处的理时机在请求前和响应后，全局回调监听只在响应后，并且晚于拦截器")]),t._v(" "),a("li",[t._v("全局回调监听可以 "),a("strong",[t._v("阻断")]),t._v("（return false）某个请求的具体回调，而拦截器不能")])])]),t._v(" "),a("h2",{attrs:{id:"全局下载监听"}},[a("a",{staticClass:"header-anchor",attrs:{href:"#全局下载监听"}},[t._v("#")]),t._v(" 全局下载监听")]),t._v(" "),a("div",{staticClass:"language-java line-numbers-mode"},[a("pre",{pre:!0,attrs:{class:"language-java"}},[a("code",[a("span",{pre:!0,attrs:{class:"token class-name"}},[t._v("HTTP")]),t._v(" http "),a("span",{pre:!0,attrs:{class:"token operator"}},[t._v("=")]),t._v(" HTTP"),a("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v(".")]),a("span",{pre:!0,attrs:{class:"token function"}},[t._v("builder")]),a("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v("(")]),a("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v(")")]),t._v("\n "),a("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v(".")]),a("span",{pre:!0,attrs:{class:"token function"}},[t._v("downloadListener")]),a("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v("(")]),a("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v("(")]),a("span",{pre:!0,attrs:{class:"token class-name"}},[t._v("HttpTask")]),a("span",{pre:!0,attrs:{class:"token generics"}},[a("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v("<")]),a("span",{pre:!0,attrs:{class:"token operator"}},[t._v("?")]),a("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v(">")])]),t._v(" task"),a("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v(",")]),t._v(" "),a("span",{pre:!0,attrs:{class:"token class-name"}},[t._v("Download")]),t._v(" download"),a("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v(")")]),t._v(" "),a("span",{pre:!0,attrs:{class:"token operator"}},[t._v("->")]),t._v(" "),a("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v("{")]),t._v("\n "),a("span",{pre:!0,attrs:{class:"token comment"}},[t._v("// 所有下载在开始之前都会先走这里")]),t._v("\n "),a("span",{pre:!0,attrs:{class:"token class-name"}},[t._v("Ctrl")]),t._v(" ctrl "),a("span",{pre:!0,attrs:{class:"token operator"}},[t._v("=")]),t._v(" download"),a("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v(".")]),a("span",{pre:!0,attrs:{class:"token function"}},[t._v("getCtrl")]),a("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v("(")]),a("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v(")")]),a("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v(";")]),t._v(" "),a("span",{pre:!0,attrs:{class:"token comment"}},[t._v("// 下载控制器")]),t._v("\n \n "),a("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v("}")]),a("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v(")")]),t._v("\n "),a("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v(".")]),a("span",{pre:!0,attrs:{class:"token function"}},[t._v("build")]),a("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v("(")]),a("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v(")")]),a("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v(";")]),t._v("\n")])]),t._v(" "),a("div",{staticClass:"line-numbers-wrapper"},[a("span",{staticClass:"line-number"},[t._v("1")]),a("br"),a("span",{staticClass:"line-number"},[t._v("2")]),a("br"),a("span",{staticClass:"line-number"},[t._v("3")]),a("br"),a("span",{staticClass:"line-number"},[t._v("4")]),a("br"),a("span",{staticClass:"line-number"},[t._v("5")]),a("br"),a("span",{staticClass:"line-number"},[t._v("6")]),a("br"),a("span",{staticClass:"line-number"},[t._v("7")]),a("br")])])])}),[],!1,null,null,null);s.default=e.exports}}]); \ No newline at end of file diff --git a/okhttps-doc/docs/.vuepress/dist/assets/js/app.1e2fa6f5.js b/okhttps-doc/docs/.vuepress/dist/assets/js/app.1e2fa6f5.js deleted file mode 100644 index 4a930851..00000000 --- a/okhttps-doc/docs/.vuepress/dist/assets/js/app.1e2fa6f5.js +++ /dev/null @@ -1,13 +0,0 @@ -(window.webpackJsonp=window.webpackJsonp||[]).push([[0],[]]);!function(t){function e(e){for(var r,a,c=e[0],u=e[1],s=e[2],l=0,p=[];l0?o(r(t),9007199254740991):0}},function(t,e,n){var r=n(6),o=n(1),i=n(4),a=Object.defineProperty,c={},u=function(t){throw t};t.exports=function(t,e){if(i(c,t))return c[t];e||(e={});var n=[][t],s=!!i(e,"ACCESSORS")&&e.ACCESSORS,f=i(e,0)?e[0]:u,l=i(e,1)?e[1]:void 0;return c[t]=!!n&&!o((function(){if(s&&!r)return!0;var t={length:-1};s?a(t,1,{enumerable:!0,get:u}):t[1]=1,n.call(t,f,l)}))}},function(t,e,n){var r=n(13);t.exports=function(t){return Object(r(t))}},function(t,e,n){var r=n(67),o=n(21),i=n(160);r||o(Object.prototype,"toString",i,{unsafe:!0})},function(t,e,n){var r=n(193),o=n(196);t.exports=function(t,e){var n=o(t,e);return r(n)?n:void 0}},function(t,e,n){"use strict";function r(t,e,n,r,o,i,a,c){var u,s="function"==typeof t?t.options:t;if(e&&(s.render=e,s.staticRenderFns=n,s._compiled=!0),r&&(s.functional=!0),i&&(s._scopeId="data-v-"+i),a?(u=function(t){(t=t||this.$vnode&&this.$vnode.ssrContext||this.parent&&this.parent.$vnode&&this.parent.$vnode.ssrContext)||"undefined"==typeof __VUE_SSR_CONTEXT__||(t=__VUE_SSR_CONTEXT__),o&&o.call(this,t),t&&t._registeredComponents&&t._registeredComponents.add(a)},s._ssrRegister=u):o&&(u=c?function(){o.call(this,this.$root.$options.shadowRoot)}:o),u)if(s.functional){s._injectStyles=u;var f=s.render;s.render=function(t,e){return u.call(e),f(t,e)}}else{var l=s.beforeCreate;s.beforeCreate=l?[].concat(l,u):[u]}return{exports:t,options:s}}n.d(e,"a",(function(){return r}))},function(t,e,n){"use strict";var r=n(0),o=n(27).filter,i=n(45),a=n(15),c=i("filter"),u=a("filter");r({target:"Array",proto:!0,forced:!c||!u},{filter:function(t){return o(this,t,arguments.length>1?arguments[1]:void 0)}})},function(t,e,n){var r=n(3),o=n(9),i=n(4),a=n(59),c=n(96),u=n(37),s=u.get,f=u.enforce,l=String(String).split("String");(t.exports=function(t,e,n,c){var u=!!c&&!!c.unsafe,s=!!c&&!!c.enumerable,p=!!c&&!!c.noTargetGet;"function"==typeof n&&("string"!=typeof e||i(n,"name")||o(n,"name",e),f(n).source=l.join("string"==typeof e?e:"")),t!==r?(u?!p&&t[e]&&(s=!0):delete t[e],s?t[e]=n:o(t,e,n)):s?t[e]=n:a(e,n)})(Function.prototype,"toString",(function(){return"function"==typeof this&&s(this).source||c(this)}))},function(t,e,n){var r=n(6),o=n(93),i=n(29),a=n(11),c=n(30),u=n(4),s=n(94),f=Object.getOwnPropertyDescriptor;e.f=r?f:function(t,e){if(t=a(t),e=c(e,!0),s)try{return f(t,e)}catch(t){}if(u(t,e))return i(!o.f.call(t,e),t[e])}},function(t,e){t.exports=function(t){return null!=t&&"object"==typeof t}},function(t,e){var n={}.toString;t.exports=function(t){return n.call(t).slice(8,-1)}},function(t,e,n){"use strict";var r=n(0),o=n(46);r({target:"RegExp",proto:!0,forced:/./.exec!==o},{exec:o})},function(t,e){t.exports=!1},function(t,e,n){var r=n(158),o=n(41),i=n(16),a=n(14),c=n(104),u=[].push,s=function(t){var e=1==t,n=2==t,s=3==t,f=4==t,l=6==t,p=5==t||l;return function(d,h,v,y){for(var m,g,b=i(d),_=o(b),x=r(h,v,3),w=a(_.length),O=0,S=y||c,j=e?S(d,w):n?S(d,0):void 0;w>O;O++)if((p||O in _)&&(g=x(m=_[O],O,b),t))if(e)j[O]=g;else if(g)switch(t){case 3:return!0;case 5:return m;case 6:return O;case 2:u.call(j,m)}else if(f)return!1;return l?-1:s||f?f:j}};t.exports={forEach:s(0),map:s(1),filter:s(2),some:s(3),every:s(4),find:s(5),findIndex:s(6)}},function(t,e,n){var r=n(34),o=n(178),i=n(179),a=r?r.toStringTag:void 0;t.exports=function(t){return null==t?void 0===t?"[object Undefined]":"[object Null]":a&&a in Object(t)?o(t):i(t)}},function(t,e){t.exports=function(t,e){return{enumerable:!(1&t),configurable:!(2&t),writable:!(4&t),value:e}}},function(t,e,n){var r=n(5);t.exports=function(t,e){if(!r(t))return t;var n,o;if(e&&"function"==typeof(n=t.toString)&&!r(o=n.call(t)))return o;if("function"==typeof(n=t.valueOf)&&!r(o=n.call(t)))return o;if(!e&&"function"==typeof(n=t.toString)&&!r(o=n.call(t)))return o;throw TypeError("Can't convert object to primitive value")}},function(t,e){t.exports={}},function(t,e,n){var r,o=n(8),i=n(163),a=n(62),c=n(31),u=n(164),s=n(95),f=n(42),l=f("IE_PROTO"),p=function(){},d=function(t){return" - - diff --git a/okhttps-doc/docs/.vuepress/dist/guide/configuration.html b/okhttps-doc/docs/.vuepress/dist/guide/configuration.html deleted file mode 100644 index 0564067a..00000000 --- a/okhttps-doc/docs/.vuepress/dist/guide/configuration.html +++ /dev/null @@ -1,137 +0,0 @@ - - - - - - 配置 | OkHttps - - - - - - - - - - - - - - - - - - -
OkHttps

# 配置

# 设置 BaseUrl

HTTP http = HTTP.builder()
-        .baseUrl("http://api.demo.com")    // 设置 BaseUrl
-        .build();
-
1
2
3

该配置全局生效，在配置了BaseUrl之后，具体的请求便可以省略BaseUrl部分，使得代码更加简洁，例如：

http.sync("/users").get()                  // http://api.demo.com/users
-
-http.sync("/auth/signin")                  // http://api.demo.com/auth/signin
-        .addBodyParam("username", "Jackson")
-        .addBodyParam("password", "xxxxxx")
-        .post();                           // POST请求
-
1
2
3
4
5
6

在配置了BaseUrl之后，如有特殊请求任务，仍然可以使用全路径的方式，一点都不妨碍：

http.sync("https://www.baidu.com").get();
-
1

# 回调执行器

OkHttps 默认所有回调都在 IO线程 执行，如何想改变执行回调的线程时，可以配置回调执行器。例如在Android里，让所有的回调函数都在UI线程执行，则可以在构建HTTP时配置如下：

HTTP http = HTTP.builder()
-        .callbackExecutor((Runnable run) -> {
-            runOnUiThread(run);            // 在UI线程执行
-        })
-        .build();
-
1
2
3
4
5

该配置默认 影响所有回调。

# 配置 OkHttpClient

与其他封装 OkHttp3 的框架不同，OkHttps 并不会遮蔽 OkHttp3 本身就很好用的功能，如下：

HTTP http = HTTP.builder()
-    .config((Builder builder) -> {
-        // 配置连接池 最小10个连接（不配置默认为 5）
-        builder.connectionPool(new ConnectionPool(10, 5, TimeUnit.MINUTES));
-        // 配置连接超时时间（默认10秒）
-        builder.connectTimeout(20, TimeUnit.SECONDS);
-        // 配置拦截器
-        builder.addInterceptor((Chain chain) -> {
-            Request request = chain.request();
-            // 必须同步返回，拦截器内无法执行异步操作
-            return chain.proceed(request);
-        });
-        // 其它配置: CookieJar、SSL、缓存、代理、事件监听...
-    })
-    .build();
-
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15

# 并行预处理器

预处理器（Preprocessor）可以让我们在请求发出之前对请求本身做一些改变，但与OkHttp的拦截器（Interceptor）不同：预处理器可以让我们 异步 处理这些问题。

例如，当我们想为请求任务自动添加Token头信息，而Token只能通过异步方法requestToken获取时，这时使用Interceptor就很难处理了，但可以使用预处理器轻松解决：

HTTP http = HTTP.builder()
-        .addPreprocessor((PreChain chain) -> {
-            HttpTask<?> task = chain.getTask();// 获得当前的HTTP任务
-            if (!task.isTagged("Auth")) {      // 根据标签判断该任务是否需要Token
-                chain.proceed();
-                return;
-            }
-            requestToken((String token) -> {   // 异步获取 Token
-                task.addHeader("Token", token);// 为任务添加头信息
-                chain.proceed();               // 继续当前的任务
-            });
-        })
-        .build();
-
1
2
3
4
5
6
7
8
9
10
11
12
13

和Interceptor一样，Preprocessor也可以添加多个。他们之间的区别如下:

拦截器与预处理器的区别

  • 拦截器只能处理同步操作，预处理器支持处理异步操作
  • 拦截器都是并行处理请求，预处理器支持串行处理（详见6.5章节）
  • 拦截器处理时机在请求前和响应后，预处理器只在请求前，并且先于拦截器执行。关于响应后，OkHttps还提供了全局回调监听（详见6.6章节）

# 串行预处理器（TOKEN问题最佳解决方案）

普通预处理器都是可并行处理的，然而有时我们希望某个预处理器同时只处理一个任务。比如 当Token过期时我们需要去刷新获取新Token，而刷新Token这个操作只能有一个任务去执行，因为如果n个任务同时执行的话，那么必有n-1个任务刚刷新得到的Token可能就立马失效了，而这是我们所不希望的。

为了解决这个问题，OkHttps 提供了串行预处理器，它可以让 HTTP 任务排好队，一个一个地进入预处理器：

HTTP http = HTTP.builder()
-        .addSerialPreprocessor((PreChain chain) -> {
-            HttpTask<?> task = chain.getTask();
-            if (!task.isTagged("Auth")) {
-                chain.proceed();
-                return;
-            }
-            // 检查过期，若需要则刷新Token
-            requestTokenAndRefreshIfExpired((String token) -> {
-                task.addHeader("Token", token);            
-                chain.proceed();               // 调用此方法前，不会有其它任务进入该处理器
-            });
-        })
-        .build();
-
1
2
3
4
5
6
7
8
9
10
11
12
13
14

串行预处理器实现了让HTTP任务排队串行处理的功能，但值得一提的是：它并没有因此而阻塞任何线程！

# 全局回调监听

全局回调是实际开发中经常需要的功能，比如对服务器响应的状态码进行统一处理等，同时 OkHttps 的全局回调还具有 回调阻断 的功能：

HTTP http = HTTP.builder()
-        .responseListener((HttpTask<?> task, HttpResult result) -> {
-            // 所有请求响应后都会走这里
-
-            return true; // 返回 true 表示继续执行 task 的 OnResponse 回调，false 表示不再执行
-        })
-        .completeListener((HttpTask<?> task, State state) -> {
-            // 所有请求执行完都会走这里
-
-            return true; // 返回 true 表示继续执行 task 的 OnComplete 回调，false 表示不再执行
-        })
-        .exceptionListener((HttpTask<?> task, IOException error) -> {
-            // 所有请求发生异常都会走这里
-
-            return true; // 返回 true 表示继续执行 task 的 OnException 回调，false 表示不再执行
-        })
-        .build();
-
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17

全局回调监听与拦截器的异同：

  • 拦截器可以添加多个，全局回调监听分三种，每种最多添加一个
  • 拦截器处的理时机在请求前和响应后，全局回调监听只在响应后，并且晚于拦截器
  • 全局回调监听可以 阻断（return false）某个请求的具体回调，而拦截器不能

# 全局下载监听

HTTP http = HTTP.builder()
-        .downloadListener((HttpTask<?> task, Download download) -> {
-            // 所有下载在开始之前都会先走这里
-            Ctrl ctrl = download.getCtrl();         // 下载控制器
-            
-        })
-        .build();
-
1
2
3
4
5
6
7

- ← - - 特色 - - → -

- - - diff --git a/okhttps-doc/docs/.vuepress/dist/guide/features.html b/okhttps-doc/docs/.vuepress/dist/guide/features.html deleted file mode 100644 index 23771675..00000000 --- a/okhttps-doc/docs/.vuepress/dist/guide/features.html +++ /dev/null @@ -1,150 +0,0 @@ - - - - - - 特色 | OkHttps - - - - - - - - - - - - - - - - - - -
OkHttps

# 特色

# 使用 HttpUtils 类

类HttpUtils本是 前身 HttpUtils 的 1.x 版本里的最重要的核心类，由于在后来的版本里抽象出了HTTP接口，使得它的重要性已不如往昔。但合理的使用它，仍然可以带来不少便利，特别是在没有IOC容器的环境里，比如在Android开发和一些工具项目的开发中。

类HttpUtils共定义了四个静态方法：

  • of(HTTP http) 配置HttpUtils持有的HTTP实例（不调用此方法前默认使用一个没有没有经过任何配置的HTTP懒实例）
  • sync(String url) 开始一个同步请求 （内部通过一个HTTP单例实现）
  • async(String url) 开始一个异步请求 （内部通过一个HTTP单例实现）
  • cancel(String tag) 按标签取消请求（内部通过一个HTTP单例实现）
  • cancelAll() 取消所有HTTP任务，包括同步和异步（内部通过一个HTTP单例实现）
  • request(Request request) OkHttp 原生请求 （该请求不经过 预处理器）
  • webSocket(Request request, WebSocketListener listener) WebSocket通讯 -　　也就是说，能使用http实例的地方，都可以使用HttpUtils类，例如：
// 在配置HTTP实例之前，只能使用全路径方式
-List<Role> roles = HttpUtils.sync("http://api.demo.com/roles")
-        .get().getBody().toList(Role.class);
-
-// 配置HTTP实例,全局生效
-HttpUtils.of(HTTP.builder()
-        .baseUrl("http://api.demo.com")
-        .build());
-
-// 内部使用新的HTTP实例
-List<User> users = HttpUtils.sync("/users")
-        .get().getBody().toList(User.class);
-
1
2
3
4
5
6
7
8
9
10
11
12

# 异常处理

使用 OkHttps 时，异常处理不是必须的，但相比其它的 HTTP 开发包，它还提供一个特别的处理方法：nothrow()，以满足不同的异常处理需求。

# 同步请求的异常

默认情况下，当同步请求执行异常时，会直接向外抛出，我们可以用 try catch 来捕获，例如：

try {
-    HttpResult result = http.sync("/users/1").get();
-} catch (HttpException e) {
-    Throwable cause = e.getCause(); // 得到异常原因
-    if (cause instanceof ConnectException) {
-        // 当没网络时，会抛出连接异常
-    }
-    if (cause instanceof SocketTimeoutException) {
-        // 当接口长时间未响应，会抛出超时异常
-    }
-    if (cause instanceof UnknownHostException) {
-        // 当把域名或IP写错，会抛出 UnknownHost 异常
-    }
-    // ...
-}
-
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15

这种传统的异常处理方式，当然可以解决问题，但 OkHttps 有更佳的方案：

// 方法  nothrow() 让异常不直接抛出
-HttpResult result = http.sync("/users/1").nothrow().get();
-// 判断执行状态
-switch (result.getState()) {
-    case RESPONSED:     // 请求已正常响应
-        break;
-    case CANCELED:      // 请求已被取消
-        break;
-    case NETWORK_ERROR: // 网络错误，说明用户没网了
-        break;
-    case TIMEOUT:       // 请求超时
-        break;
-    case EXCEPTION:     // 其它异常
-        break;
-}
-// 还可以获得具体的异常信息
-IOException error = result.getError();
-
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17

# 异步请求的异常

异步请求最常用的异常处理方式就是设置一个异常回调：

http.async("/users/1")
-        .setOnResponse((HttpResult result) -> {
-            // 当发生异常时就不会走这里
-        })
-        .setOnException((IOException e) -> {
-            // 这里处理请求异常
-        })
-        .get();
-
1
2
3
4
5
6
7
8

当然，还有一个全局异常监听（ExceptionListener）：

HTTP http = HTTP.builder()
-        .exceptionListener((HttpTask<?> task, IOException error) -> {
-            // 所有请求发生异常都会走这里
-
-            return true; // 返回 true 表示继续执行 task 的 OnException 回调，false 表示不再执行
-        })
-        .build();
-
1
2
3
4
5
6
7

如果不设置OnException回调，也没有ExceptionListener，发生异常时会在 IO 线程 中向上抛出，外层无法捕获：

try {
-    http.async("/users/1")
-            .setOnResponse((HttpResult result) -> {
-                // 当发生异常时就不会走这里
-            })
-            .get();
-} catch (HttpException e) {
-    // 这种方式是捕获不到异常的！！！！！！
-}
-
1
2
3
4
5
6
7
8
9

即使没有OnException回调，发生异常时，依然会走OnComplete回调，如果设置了的话：

http.async("/users/1")
-        .setOnResponse((HttpResult result) -> {
-            // 当发生异常时就不会走这里
-        })
-        .setOnComplete((State state) -> {
-            // 发生异常，会先执行这里，可以根据 state 判断发生了什么
-            // 但执行完后依然会在IO线程中向上抛出
-        })
-        .get();
-
1
2
3
4
5
6
7
8
9

如果就是想 不处理异常，也不向上抛出，发生错误完全无视，可以做到吗？可以！还是使用nothrow()方法：

http.async("/users/1")
-        .nothrow()  // 告诉 OkHttps 发生异常时不向外抛出
-        .setOnResponse((HttpResult result) -> {
-            // 当发生异常时就不会走这里
-        })
-        .get();
-
1
2
3
4
5
6

# 取消请求

在 OkHttps 里取消请求共有 4 种 方式可选：

  • 使用HttpCall#cancel()取消单个请求（适用于异步请求，详见 3.3 章节）
  • 使用HttpTask#cancel()取消单个请求（适用于所有请求）（since v1.0.4）
HttpTask<?> task = http.async("/users")
-        .setOnResponse((HttpResult result) -> {
-            // 响应回调
-        });
-
-task.get(); // 发起 GET 请求
-
-// 取消请求，并返回是否取消成功
-boolean canceled = task.cancel();   
-
1
2
3
4
5
6
7
8
9
  • 使用HTTP#cancel(String tag)按标签批量取消请求（适用于所有请求，详见第 5 章节）
  • 使用HTTP#cancelAll()取消所有请求（适用于所有请求）（since v1.0.2）
http.cancelAll();   // 取消所有请求
-
1

- ← - - 上传下载 - - → -

- - - diff --git a/okhttps-doc/docs/.vuepress/dist/guide/foundation.html b/okhttps-doc/docs/.vuepress/dist/guide/foundation.html deleted file mode 100644 index 54bfdf7b..00000000 --- a/okhttps-doc/docs/.vuepress/dist/guide/foundation.html +++ /dev/null @@ -1,130 +0,0 @@ - - - - - - 基础 | OkHttps - - - - - - - - - - - - - - - - - - -
OkHttps

# 基础

# 请求方法

同步与异步的HttpTask都拥有get、post、put与delete方法。不同的是：同步HttpTask的这些方法返回一个HttpResult，而异步HttpTask的这些方法返回一个HttpCall。

HttpResult res1 = http.sync("/users").get();     // 同步 GET
-HttpResult res2 = http.sync("/users").post();    // 同步 POST
-HttpResult res3 = http.sync("/users/1").put();   // 同步 PUT
-HttpResult res4 = http.sync("/users/1").delete();// 同步 DELETE
-HttpCall call1 = http.async("/users").get();     // 异步 GET
-HttpCall call2 = http.async("/users").post();    // 异步 POST
-HttpCall call3 = http.async("/users/1").put();   // 异步 PUT
-HttpCall call4 = http.async("/users/1").delete();// 异步 DELETE
-
1
2
3
4
5
6
7
8

# 回调函数

OkHttps 的回调函数全部使用单方法模式，这样可以充分利用 Java8 或 Kotlin 中的 Lambda 表达式，使你的代码更加简洁优雅：

http.async("/users/{id}")             // http://api.demo.com/users/1
-        .addPathParam("id", 1)
-        .setOnResponse((HttpResult result) -> {
-            // 响应回调
-        })
-        .setOnException((IOException e) -> {
-            // 异常回调
-        })
-        .setOnComplete((State state) -> {
-            // 完成回调，无论成功失败都会执行
-            // 并且在 响应|异常回调 之前执行
-        })
-        .get();
-
1
2
3
4
5
6
7
8
9
10
11
12
13

OkHttps 同时还支持 全局回调 和 回调阻断 机制，详见 全局回调监听。

TIP

  • 只有异步请求才可以设置这三种（响应|异常|完成）回调
  • 同步请求直接返回结果，无需使用回调

# HttpResult

HttpResult是HTTP请求执行完后的结果，它是同步请求方法（ get、post、put、delete）的返回值，也是异步请求响应回调（OnResponse）的参数，它定义了如下方法：

  • getState() 得到请求执行状态枚举，它有以下取值： -
    • State.CANCELED 请求被取消
    • State.RESPONSED 已收到响应
    • State.TIMEOUT 请求超时
    • State.NETWORK_ERROR 网络错误
    • State.EXCEPTION 其它请求异常
  • getStatus() 得到HTTP状态码
  • isSuccessful() 是否响应成功，状态码在 [200..300) 之间
  • getHeaders() 得到HTTP响应头
  • getHeaders(String name) 得到HTTP响应头
  • getHeader(String name) 得到HTTP响应头
  • getBody() 得到响应报文体Body实例，它定义了如下方法（对同一个Body实例，以下的toXXX()类方法只能使用一个且仅能调用一次，除非先使用 cache 方法）： -
    • toBytes() 返回字节数组
    • toByteStream() 返回字节输入流
    • toCharStream() 返回字符输入流
    • toString() 返回字符串
    • toJsonObject() 返回Json对象
    • toJsonArray() 返回Json数组
    • toBean(Class<T> type) 返回根据type自动json解析后的JavaBean
    • toList(Class<T> type) 返回根据type自动json解析后的JavaBean列表
    • toFile(String filePath) 下载到指定路径
    • toFile(File file) 下载到指定文件
    • toFolder(String dirPath) 下载到指定目录
    • toFolder(File dir) 下载到指定目录
    • getContentType() 返回报文体的媒体类型
    • getContentLength() 返回报文体的字节长度
    • cache() 缓存报文体，开启缓存后可重复使用toXXX()类方法
    • close() 关闭报文体，未对报文体做任何消费时使用，比如只读取报文头
  • getError() 执行中发生的异常，自动捕获执行请求时发生的 网络超时、网络错误 和 其它IO异常
  • close() 关闭报文，未对报文体做任何消费时使用，比如只读取长度

示例，请求结果自动转Bean和List：

// 自动转Bean
-Order order = http.sync("/orders/1")
-        .get().getBody().toBean(Order.class);
-        
-// 自动转List
-List<Order> orders = http.sync("/orders")
-        .get().getBody().toList(Order.class);
-
1
2
3
4
5
6
7

示例，使用 cache 方法：

Body body = http.sync("/orders").get().getBody().cache();
-
-// 使用 cache 后，可以多次使用 toXXX() 方法
-System.out.println(body.toString());
-System.out.println(body.toJsonArray());
-System.out.println(body.toList(Order.class));
-
1
2
3
4
5
6

示例，获取下载文件的大小：

long size = http.sync("/download/test.zip")
-            .get().getBody()
-            .close()             // 只是想获得文件大小，不消费报文体，所以直接关闭
-            .getContentLength(); // 获得待下载文件的大小
-
-// 由于未消费报文体，所以本次请求不会消耗下载报文体的时间和网络流量
-
-System.out.println("size = " + size);
-
1
2
3
4
5
6
7
8

# HttpCall

HttpCall对象是异步请求方法（get、post、put、delete）的返回值，与java的Future接口很像，它有如下方法：

  • cancel() 取消本次请求，返回取消结果
  • isCanceled() 返回请求是否被取消
  • isDone() 返回是否执行完成，包含取消和失败
  • getResult() 返回执行结果HttpResult对象，若请求未执行完，则挂起当前线程直到执行完成再返回

取消一个异步请求示例：

HttpCall call = http.async("/users/1").get();
-
-System.out.println(call.isCanceled());     // false
-
-boolean success = call.cancel();           // 取消请求
-
-System.out.println(success);               // true
-System.out.println(call.isCanceled());     // true
-
1
2
3
4
5
6
7
8

# 构建HTTP任务

HTTP对象的sync与async方法返回一个HttpTask对象，该对象提供了可链式调用的addXXX与setXXX等系列方法用于构建任务本身。

  • addHeader(String name, String value) 添加请求头

  • addHeader(Map<String, String> headers) 添加请求头

  • addPathParam(String name, Object value) 添加路径参数：替换URL里的{name}占位符

  • addPathParam(Map<String, ?> params) 添加路径参数：替换URL里的{name}占位符

  • addUrlParam(String name, Object value) 添加URL参数：拼接在URL的?之后（查询参数）

  • addUrlParam(Map<String, ?> params) 添加URL参数：拼接在URL的?之后（查询参数）

  • addBodyParam(String name, Object value) 添加Body参数：以表单key=value&的形式放在报文体内（表单参数）

  • addBodyParam(Map<String, ?> params) 添加Body参数：以表单key=value&的形式放在报文体内（表单参数）

  • addJsonParam(String name, Object value) 添加Json参数：请求体为Json（支持多层结构）

  • addJsonParam(Map<String, ?> params) 添加Json参数：请求体为Json（支持多层结构）

  • setRequestJson(Object json) 设置请求体的Json字符串 或待转换为 Json的 JavaBean

  • setRequestJson(Object bean, String dateFormat) 设置请求体的Json字符串 或待转换为 Json的 JavaBean

  • addFileParam(String name, String filePath) 上传文件

  • addFileParam(String name, File file) 上传文件

  • addFileParam(String name, String type, InputStream inputStream) 上传文件

  • addFileParam(String name, String type, String fileName, InputStream input) 上传文件

  • addFileParam(String name, String type, byte[] content) 上传文件

  • addFileParam(String name, String type, String fileName, byte[] content) 上传文件

  • setTag(String tag) 为HTTP任务添加标签

  • setRange(long rangeStart) 设置Range头信息，用于断点续传

  • setRange(long rangeStart, long rangeEnd) 设置Range头信息，可用于分块下载

  • bind(Object object) 绑定一个对象，可用于实现Android里的生命周期绑定

# 使用标签

有时候我们想对HTTP任务加以分类，这时候可以使用标签功能：

http.async("/users")    //（1）
-        .setTag("A")
-        .get();
-        
-http.async("/users")    //（2）
-        .setTag("A.B")
-        .get();
-        
-http.async("/users")    //（3）
-        .setTag("B")
-        .get();
-        
-http.async("/users")    //（4）
-        .setTag("B")
-        .setTag("C")    // 从 v1.0.4 标签将以追加模式添加，等效于 setTag("B.C")
-        .get();
-        
-http.async("/users")    //（5）
-        .setTag("C")
-        .get();
-
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20

当使用标签后，就可以按标签批量的对HTTP任务进行取消：

int count = http.cancel("B");              //（2）（3）（4）被取消（取消标签包含"B"的任务）
-System.out.println(count);                 // 输出 3
-
1
2

标签除了可以用来取消任务，在预处理器中它也可以发挥作用，请参见 并行预处理器 与 串行预处理器（token问题最佳解决方案）。

- ← - - 配置 - - → -

- - - diff --git a/okhttps-doc/docs/.vuepress/dist/guide/index.html b/okhttps-doc/docs/.vuepress/dist/guide/index.html deleted file mode 100644 index 9b6c66b0..00000000 --- a/okhttps-doc/docs/.vuepress/dist/guide/index.html +++ /dev/null @@ -1,79 +0,0 @@ - - - - - - 起步 | OkHttps - - - - - - - - - - - - - - - - - - -
OkHttps

# 起步

OkHttps 是近期开源的对 OkHttp3 轻量封装的框架，它独创的异步预处理器，特色的标签，灵活的上传下载进度监听与过程控制功能，在轻松解决很多原本另人头疼问题的同时，设计上也力求纯粹与优雅。

  • 链式调用，一点到底
  • BaseURL、URL占位符、JSON自动封装与解析
  • 同步拦截器、异步预处理器、回调执行器、全局监听、回调阻断
  • 文件上传下载（过程控制、进度监听）
  • 单方法回调，充分利用 Lambda 表达式
  • TCP连接池、Http2

TIP

  • OkHttps 非常轻量（59Kb），仅是 Retrofit（124Kb）的一半，并且更加的开箱即用，API 也更加自然和语义化。
  • OkHttps 是一个纯粹的 Java 网络开发包，并不依赖 Android，这一点和 Retrofit 不同
  • OkHttps 用起来很优美，可以像 RxJava 那样链式用，却比 RxJava 更简单。

# 安装

# Maven

<dependency>
-     <groupId>com.ejlchina</groupId>
-     <artifactId>okhttps</artifactId>
-     <version>1.0.5</version>
-</dependency>
-
1
2
3
4
5

# Gradle

implementation 'com.ejlchina:okhttps:1.0.5'
-
1

安卓中使用需要把 JDK 版本调成 1.8，在 app 模块的 build.gradle 中加入以下配置即可：

android {
-    // 省略其它配置..
-    compileOptions {
-        sourceCompatibility = 1.8
-        targetCompatibility = 1.8
-    }
-}
-
1
2
3
4
5
6
7

# 使用

# 构建实例

HTTP http = HTTP.builder().build();
-
1

以上代码构建了一个最简单的HTTP实例，它拥有以下方法：

  • sync(String url) 开始一个同步请求
  • async(String url) 开始一个异步请求
  • cancel(String tag) 按标签取消请求
  • cancelAll() 取消所有HTTP任务，包括同步和异步
  • request(Request request) OkHttp 原生请求
  • webSocket(Request request, WebSocketListener listener) WebSocket通讯

为了使用方便，在构建的时候，我们更愿意指定一个BaseUrl（详见 设置 BaseUrl）:

HTTP http = HTTP.builder()
-        .baseUrl("http://api.demo.com")
-        .build();
-
1
2
3

为了简化文档，下文中出现的http均是在构建时设置了BaseUrl的HTTP实例。

# 同步请求

使用方法sync(String url)开始一个同步请求：

List<User> users = http.sync("/users") // http://api.demo.com/users
-        .get()                         // GET请求
-        .getBody()                     // 获取响应报文体
-        .toList(User.class);           // 得到目标数据
-
1
2
3
4

方法sync返回一个同步HttpTask，可链式使用。

# 异步请求

使用方法async(String url)开始一个异步请求：

http.async("/users/1")                //  http://api.demo.com/users/1
-        .setOnResponse((HttpResult result) -> {
-            // 得到目标数据
-            User user = result.getBody().toBean(User.class);
-        })
-        .get();                       // GET请求
-
1
2
3
4
5
6

方法async返回一个异步HttpTask，可链式使用。

至此，你已轻松学会了 OkHttps 95% 的常规用法！但别急，后面还有更精彩的。

- 基础 - - → -

- - - diff --git a/okhttps-doc/docs/.vuepress/dist/guide/updown.html b/okhttps-doc/docs/.vuepress/dist/guide/updown.html deleted file mode 100644 index 32ad8f39..00000000 --- a/okhttps-doc/docs/.vuepress/dist/guide/updown.html +++ /dev/null @@ -1,195 +0,0 @@ - - - - - - 上传下载 | OkHttps - - - - - - - - - - - - - - - - - - -
OkHttps

# 上传下载

# 文件下载

OkHttps 并没有把文件的下载排除在常规的请求之外，同一套API，它优雅的设计使得下载与常规请求融合的毫无违和感，一个最简单的示例：

http.sync("/download/test.zip")
-        .get()                           // 使用 GET 方法（其它方法也可以，看服务器支持）
-        .getBody()                       // 得到报文体
-        .toFile("D:/download/test.zip")  // 下载到指定的路径
-        .start();                        // 启动下载
-
-http.sync("/download/test.zip").get().getBody()                  
-        .toFolder("D:/download")         // 下载到指定的目录，文件名将根据下载信息自动生成
-        .start();
-
1
2
3
4
5
6
7
8
9

或使用异步连接方式：

http.async("/download/test.zip")
-        .setOnResponse((HttpResult result) -> {
-            result.getBody().toFolder("D:/download").start();
-        })
-        .get();
-
1
2
3
4
5

这里要说明一下：sync与async的区别在于连接服务器并得到响应这个过程的同步与异步（这个过程的耗时在大文件下载中占比极小），而start方法启动的下载过程则都是异步的。

# 下载进度监听

就直接上代码啦，诸君一看便懂：

http.sync("/download/test.zip")
-        .get()
-        .getBody()
-        .setStepBytes(1024)   // 设置每接收 1024 个字节执行一次进度回调（不设置默认为 8192）  
- //     .setStepRate(0.01)    // 设置每接收 1% 执行一次进度回调（不设置以 StepBytes 为准）  
-        .setOnProcess((Process process) -> {           // 下载进度回调
-            long doneBytes = process.getDoneBytes();   // 已下载字节数
-            long totalBytes = process.getTotalBytes(); // 总共的字节数
-            double rate = process.getRate();           // 已下载的比例
-            boolean isDone = process.isDone();         // 是否下载完成
-        })
-        .toFolder("D:/download/")        // 指定下载的目录，文件名将根据下载信息自动生成
- //     .toFile("D:/download/test.zip")  // 指定下载的路径，若文件已存在则覆盖
-        .setOnSuccess((File file) -> {   // 下载成功回调
-            
-        })
-        .start();
-
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17

值得一提的是：由于 OkHttps 并没有把下载做的很特别，这里设置的进度回调不只对下载文件起用作，即使对响应JSON的常规请求，只要设置了进度回调，它也会告诉你报文接收的进度（提前是服务器响应的报文有Content-Length头），例如：

List<User> users = http.sync("/users")
-        .get()
-        .getBody()
-        .setStepBytes(2)
-        .setOnProcess((Process process) -> {
-            System.out.println(process.getRate());
-        })
-        .toList(User.class);
-
1
2
3
4
5
6
7
8

# 下载过程控制

过于简单：还是直接上代码：

Ctrl ctrl = http.sync("/download/test.zip")
-        .get()
-        .getBody()
-        .setOnProcess((Process process) -> {
-            System.out.println(process.getRate());
-        })
-        .toFolder("D:/download/")
-        .start();   // 该方法返回一个下载过程控制器
- 
-ctrl.status();      // 下载状态
-ctrl.pause();       // 暂停下载
-ctrl.resume();      // 恢复下载
-ctrl.cancel();      // 取消下载（同时会删除文件，不可恢复）
-
1
2
3
4
5
6
7
8
9
10
11
12
13

无论是同步还是异步发起的下载请求，都可以做以上的控制：

http.async("/download/test.zip")
-        .setOnResponse((HttpResult result) -> {
-            // 拿到下载控制器
-            Ctrl ctrl = result.getBody().toFolder("D:/download/").start();
-        })
-        .get();
-
1
2
3
4
5
6

# 实现断点续传

OkHttps 对断点续传并没有再做更高层次的封装，因为这是app该去做的事情，它在设计上使各种网络问题的处理变简单的同时力求纯粹。下面的例子可以看到，OkHttps 通过一个失败回调拿到 断点，便将复杂的问题变得简单：

http.sync("/download/test.zip")
-        .get()
-        .getBody()
-        .toFolder("D:/download/")
-        .setOnFailure((Failure failure) -> {         // 下载失败回调，以便接收诸如网络错误等失败信息
-            IOException e = failure.getException();  // 具体的异常信息
-            long doneBytes = failure.getDoneBytes(); // 已下载的字节数（断点），需要保存，用于断点续传
-            File file = failure.getFile();           // 下载生成的文件，需要保存 ，用于断点续传（只保存路径也可以）
-        })
-        .start();
-
1
2
3
4
5
6
7
8
9
10

下面代码实现续传：

long doneBytes = ...    // 拿到保存的断点
-File file =  ...        // 待续传的文件
-
-http.sync("/download/test.zip")
-        .setRange(doneBytes)                         // 设置断点（已下载的字节数）
-        .get()
-        .getBody()
-        .toFile(file)                                // 下载到同一个文件里
-        .setAppended()                               // 开启文件追加模式
-        .setOnSuccess((File file) -> {
-
-        })
-        .setOnFailure((Failure failure) -> {
-        
-        })
-        .start();
-
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16

# 实现分块下载

当文件很大时，有时候我们会考虑分块下载，与断点续传的思路是一样的，示例代码：

static String url = "http://api.demo.com/download/test.zip"
-
-public static void main(String[] args) {
-    long totalSize = HttpUtils.sync(url).get().getBody()
-            .close()             // 因为这次请求只是为了获得文件大小，不消费报文体，所以直接关闭
-            .getContentLength(); // 获得待下载文件的大小（由于未消费报文体，所以该请求不会消耗下载报文体的时间和网络流量）
-    download(totalSize, 0);      // 从第 0 块开始下载
-    sleep(50000);                // 等待下载完成（不然本例的主线程就结束啦）
-}
-
-static void download(long totalSize, int index) {
-    long size = 3 * 1024 * 1024;                 // 每块下载 3M  
-    long start = index * size;
-    long end = Math.min(start + size, totalSize);
-    HttpUtils.sync(url)
-            .setRange(start, end)                // 设置本次下载的范围
-            .get().getBody()
-            .toFile("D:/download/test.zip")      // 下载到同一个文件里
-            .setAppended()                       // 开启文件追加模式
-            .setOnSuccess((File file) -> {
-                if (end < totalSize) {           // 若未下载完，则继续下载下一块
-                    download(totalSize, index + 1); 
-                } else {
-                    System.out.println("下载完成");
-                }
-            })
-            .start();
-}
-
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

# 文件上传

一个简单文件上传的示例：

http.sync("/upload")
-        .addFileParam("test", "D:/download/test.zip")
-        .post();     // 上传发法一般使用 POST 或 PUT，看服务器支持
-
1
2
3

异步上传也是完全一样：

http.async("/upload")
-        .addFileParam("test", "D:/download/test.zip")
-        .post();
-
1
2
3

# 上传进度监听

OkHttps 的上传进度监听，监听的是所有请求报文体的发送进度，示例代码：

http.sync("/upload")
-        .addBodyParam("name", "Jack")
-        .addBodyParam("age", 20)
-        .addFileParam("avatar", "D:/image/avatar.jpg")
-        .setStepBytes(1024)   // 设置每发送 1024 个字节执行一次进度回调（不设置默认为 8192）  
- //     .setStepRate(0.01)    // 设置每发送 1% 执行一次进度回调（不设置以 StepBytes 为准）  
-        .setOnProcess((Process process) -> {           // 上传进度回调
-            long doneBytes = process.getDoneBytes();   // 已发送字节数
-            long totalBytes = process.getTotalBytes(); // 总共的字节数
-            double rate = process.getRate();           // 已发送的比例
-            boolean isDone = process.isDone();         // 是否发送完成
-        })
-        .post();
-
1
2
3
4
5
6
7
8
9
10
11
12
13

咦！怎么感觉和下载的进度回调的一样？没错！OkHttps 还是使用同一套API处理上传和下载的进度回调，区别只在于上传是在get/post方法之前使用这些API，下载是在getBody方法之后使用。很好理解：get/post之前是准备发送请求时段，有上传的含义，而getBody之后，已是报文响应的时段，当然是下载。

# 上传过程控制

上传文件的过程控制就很简单，和常规请求一样，只有异步发起的上传可以取消：

HttpCall call = http.async("/upload")
-        .addFileParam("test", "D:/download/test.zip")
-        .setOnProcess((Process process) -> {
-            System.out.println(process.getRate());
-        })
-        .post();
-
-call.cancel();  // 取消上传
-
1
2
3
4
5
6
7
8

上传就没有暂停和继续这个功能啦，应该没人有这个需求吧?

- ← - - 安卓 - - → -

- - - diff --git a/okhttps-doc/docs/.vuepress/dist/index.html b/okhttps-doc/docs/.vuepress/dist/index.html deleted file mode 100644 index 3d0605ad..00000000 --- a/okhttps-doc/docs/.vuepress/dist/index.html +++ /dev/null @@ -1,72 +0,0 @@ - - - - - - OkHttps - - - - - - - - - - - - - - - - -
OkHttps
hero

- OkHttps -

- 基于 OkHttp 增强版 HTTP 客户端 -

- 极速上手 → -

轻量纯粹优雅

OkHttps 非常轻量，体积仅是 Retrofit 的一半不到，并且不依赖于特定平台，API 语义简洁舒适。

开箱即用的功能

异步预处理器、回调执行器、全局监听器、回调阻断机制、文件上传下载、过程控制、进度监听。

更多实用特性

URL 占位符、Lambda 回调、JSON自动封装解析、OkHttp 的特性：拦截器、连接池、CookieJar 等。

// 构建 HTTP
-HTTP http = HTTP.builder()
-        .baseUrl("https://api.demo.com")
-        .build();
-
-// 同步请求
-List<User> users = http.sync("/users")  // http://api.demo.com/users
-        .get()                          // GET请求
-        .getBody()                      // 获取响应报文体
-        .toList(User.class);            // 得到目标数据
-
-// 异步请求
-http.async("/users/jack")               //  http://api.demo.com/users/jack
-        .setOnResponse((HttpResult result) -> {
-            // 得到目标数据
-            User jack = result.getBody().toBean(User.class);
-        })
-        .get();                         // GET请求
-
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18

竟然不到 15 秒，你已学会 90% 的精髓！
了解更多

- Apache Licensed | Copyright © 2020-present ejlchina -
- - - diff --git a/okhttps-doc/docs/.vuepress/dist/logo.png b/okhttps-doc/docs/.vuepress/dist/logo.png deleted file mode 100644 index 3b3b2845420b470e4b091e3862ff98653c4b1cb0..0000000000000000000000000000000000000000 GIT binary patch literal 0 HcmV?d00001 literal 5800 zcmX9?c|2768$RclVT^4s*_RpXRMuoG%P?dtA*m#L(n8lZmMhEHm&71ZWGfe4Wi5Ng zo~ww;5;4j}cES*5ese#+KhEcUKi~Izp69He_j%rATWd2Oq!=R5sxYDrp^2IMU_Bh0y>E*~O>!|ph0Kd1zw>qt@EFdT#`V|KkDr5H~Vx$ zx)qN}Ap!Ni=LJ%~4KJ^GhuGQh?bUZ0gP6bYt%j3+HhGK!?l=fvsUG{UYoE##$O+3L zcXJaDBgO*^4X}+3<@1HV`X40nk{wF!_t4kKDi{!MFP%L1P(CCI|9baxI_?ea=Cg%nKp+fbIeFs4TS`T<+@j9@WN^=z+q2S+UuVX zJ08S5nc@z=+e|L71(Fns;bfH}MHahx5{!0&1nRSZk5wOCfttxuth$gLL|cTK2_TWX zJy=EO-aO=tH^Tv(ESk4IyZSS_H|=cFbqDUos}!-J$@LBeU)J`r0{1d~(0R95-6|8PJ$uBxn)R!h`R!oGVeOt8Zk_3mb8P&Qx~Rsl$qY?5ZAR znd`p}FIl_Y?L7>yjD{#egzxhQ3HK8`fNlA7fprdau?sC9x7N+c=0Kh5hbjX-cSBk5zHwMB>BZEb<@Y z#2oE^)g|o!thYh_Z;NtWb_uo_kjDYZHRbcd(KoHQObKGM#7!0I1t3$N^xf+9EksGM zz?0D8jd%BiBi@wHzh0B1_YHj>Y?_S8X^cUb zTq`U5d{K4O=DM?QvY|!LDG|$HEbx7t?<{v@;!>kx#Y(ZOkz;*$>fvdxVN|z5unN_^ z7MEEG1A3I{iHB8-FNL@29d9r3-{^=)az0HG`5CAjSoYZouLY5F>IW*@lf8N^Wi(RH z{B|h5FO9jW?j%szc+R+*C`>Ws1-!>?Aclo6flubmOR+fP_uX!ZROPR~3 z>&xdOdw%#Y&a|+q|54hu?xvMe08=F)FO{0>0~y8X^3X&JSpr7wv^LPdf?nq5FZhgS z1Q7X6G53V=AR@7pg4rFJP!LN*w>lgzL3pl00TWzm;*DIkDT(**ymB-uZ)}JZlrbfM zTG2t+NqtCn6`pieaHjVxF|K05tP@;AnNIgZuXCSTVIvKyUVtiYTlKhpnuhs>ESA`%fNPm-I6&ic%!=cur zrJu^WpyGwoakaA%#V_8iIN{gscF?P>Zrz=~S6x0o?5faZP378&T(l-2G^Tm>&jzwE za-bhZt7erF%l||?uO^@^2^t($@Vz$^*f zO!9d7+0I9N0Tuo6&uD!s==x;pjaeu~kj&nNHQMlW5Ql_x(H`;kMAYCpJ*JWqz6PTC z3`No@)D-046&)>w6zin}1SY({gvc>mi1Yomph7dPCZi7H%pSkLSr8~mfJW({t+$c|! zwfYLT1unZ0tEFO%{e;EICSCD-`_S54$mr^ioaZY6tsYi<7McJh%w@_`fy6ez4qs+iXK0=H;rm!}>Ft77(PG9d`cPmaL6)z%?%Es&N zYmVB55_lBv-*LGe@#bL>kV^F<7JW?)<@Q64VYvVJIh3dWcER)d*0?Qj&ZBWP_xG%v zol>$%*HYBj@kR`nEdX^`cgvZE>V;xbLu9=4tVWGN1mgQzo?d?3bBF+7MFc45A^_o0 z-<9U5=;6Va0K{PAs)J>00<~O67pAlR_z0SipC%<=!U6oVvvS>H+@MSh&slEHB+*3x z?MB2`;z8TE#4OZZ5eQd{7Kqbp3s!PTohEQ8W$Kaub~iYm8fV-1I?v8=nM4n-dPTlPzo<##cHv9x+IN=y@JUN$W1QHR!G781TfE+uY zA{NVv2m&O4MB+WD;AxKA_6dW_zHXB>aYcX#2ix2I8m%9`GC#Y_Em)Y`;|CVAw&yu( z_4DO~alkq1DD5A&of!ua0g(i#2$6Oy&z)AL_o<|i(xJ^Xz*yK=^j ze&#qwJMKeqX{7`@4*DqAO0hXr^{t`1B`fS7Yl5*FY!P%Z={-2JG3No|0LfXJHc01( zC1CL!I(r{zfhuJV5m>MYsHb-L@}}VNB9IUESw~dzmS>_@iSCMprw&U;QP~B=4;RW! zTB%#lmzyKgB=7ScanLuiEKFrh-Q>_@O{=Afs$%#o=bndotMZ?3|bMG$hPhg%6nwsV*iVcjh-QaCd;cW>uUxQTywg9 zpL?QlGH7#rCzLF0*%a5J_oUJg4UmNo-V@_zj%kTXUQP4md2^iBf8$Au5{vxhC;{n3D+ zf7IoLWm)&Viwje(tWuk)rlDPHJAwD-#aGZ0FWmt?*xSfPF@0;A z7Q-w^fCg`*KIL)xDlC*iV^0YHa*qsCL(O>^JUAWD;J)U=dB9^37C!r?dJg7cBwU@~ z0R!ryD%qveb@wKt5mOIHP0p1j6nTpPpvH>~r~ehgVZ5(4^6w&a8D|X03^K0VdSVpD zYAK23X%D?ZD&UTrjWH7V${(enem#CKh$q=dpyfjuKwW8{@Jf@9<4c%2`vNSjI@F01 zB6p{6+kKM1`DnA~55wMhtdtJY!VggQVwPyp5rY5zSrKVW@Kgq>!$$PigzFizc-#hl z@6_4FE4F$~XUQUbkL%1s(`4je_l1EgWPr#w*f(`YOe*f;NXuS|FpyIRP#KmX`!~MZ z@ZJ`-4Hu!E3IRso()ma5Vy>jF1`USK2;W%vGfw-qedmznw2|H90gWGj3!6FAW;ymM zzdfNgxk}9n``tvlANaO>UOPUL?#5m)JC?5->T`ixCV#|OIkNShotY8!{l&6DkaI|1N`ax|&rZ7l z?z&&4G?ri$mD#tosdTvUP}h)WiuU>bJ3$BElSJgJCR-JSCM0=|ps9Xvoopb`+AT?t z!Tc%R!roPI%To~u&COJ9|1uECzuvd#>t+m-i359@$r6&}xh}mimjknKsb3GDo<&LA zm5Xl}*8|{1(l6=^r_NW2?oZDAel)p1O?TPbj2g>2U_bMd7)kHh<#<?7jM!H4`$P+ zY#7^p;vDS@E$v6m2U%_UAE(dUFpKe)_+0OhbPL;r)OS(bI{=pp8nc`y< z9)=!JU3<7XJ}i%Y3vrEV8!#MOdoC+a6*KG3!aYZCBbQ3b-~VW6!1}Jx(Z( zK3@Be+DY);;lt_CXu1t^YiNigz?HF}-R^JL-WbZb$;I_A%x#!QPrit4F)i3Ee{_`^ z3A8giIEG$^UupH;n>b*OYi5*xldc}0e`+^}1MIHe`LZXdvHs&t)PgC^HENTK&KNTE zD-8erv-j#ZMc$+KO+!hq$ixZPYe2V&P9VK8L*iP@e%yo!jcySvw)PM9&5t*uKMo$Z z^>gmEK?8a5?DNR_yl5Q-uq*2s8){Oml`qE|?p>50I|KCdzV%8Q3`Vt@YPNG~tIZ$kt;NT+`hR=gEYMzO6ZD|2Hyu^ewRy6Dkv$++c^3 zFseFe(-b91|8kMr5^X(VT5SmM34NLBoGm*sw*)+QU5Q1X>Z^WpGufAxVQnJx?T+4n z1W;M&>2DVQIQgBd*dN)B&=lpD7p9-1<+?f_MclzZL#e~y_^-U9gnT&u>#n1t?9j2F z9~n{S zIU&?_t)>S{gj3M=QTl~!vkvwNF5sa-Z`iszA$nNCOegYCpxB+&KANFEKad-KPOYM> z4v}owcXM0D6an0Uo@Yh#76Vt{VKJ4=BScPf%4tzKg82f}{dIFkC3rT27vqz1qd%R; z_s`44A|N$#Uqpo(_)o0TWCzXg0gA5ex9eJ5pB3%V1Tc-qtdMU4B;5O}X4P{TE`Q;` zq!s87DyJ=Ml*P)pI+aFhI(gaWRati(c>NDrF`^QTWwJbxl=`l#jXy*_7M&YG!$Fof zZiZzqBk%YQi8ekND$b7!4x)0=o);9DN*xx6-ei729|wr+`bpsv=V0&iPolUGGq=0r zTw~(}ADqAVg3YfwzD6L1Co+h3+q}nkT(($!uWI~t#Z#rpm=Ji~=Ec&1gCkCkrmq+0 z^bTv6&ssG24ZSP=>#yUEz|@%PQpR`7FgX9aJAuf!9f!u^1+CT{Rh7?T#;+EjZTEzW zB#&$Mi4_jb?ym=N|tg2236iIFNRu<^P(9?`q#FJX_mht! z3WEcbZDH>_I;2rZJO>U^Xf)22=7_@QvMqv_IhITWy^eR48ekWJFme$6=$&$p#e#&X zfy5#75#;W6nDBe$`Awq(LX-L3WZ(1WaGJUi(h)3|)Y*#n3&&nG9gyZgvJ|huSS4z`Y`R zf2Y_2aYl(#k2@4(9Y3y#$3Q4fWXG>)!|TVZlyN}Daa+XT@EC<{27?CVt3CW~HGUa& zuvXhJ3py@SYYRLynrTCNP=0T@2ckos{>Cbn;z2doW!@9{K3ORuP9*|cxuQqgEN27v z_(+=jrY)qP^yrLW;73JP@8YLujJqy<6(7JlX*nmV(?mbrguyZH800-v++ST);? { + System.out.println("连接已打开：" + result); + webSocket.send("Hello"); + }) + .setOnMessage((WebSocket webSocket, Message message) -> { + System.out.println("接收到消息：" + message.toString()); + }) + .setOnException((WebSocket webSocket, Throwable throwable) -> { + System.out.println("连接异常：" + throwable); + }) + .setOnClosing((WebSocket webSocket, WebSocket.Close close) -> { + System.out.println("正在关闭：" + close); + }) + .setOnClosed((WebSocket webSocket, WebSocket.Close close) -> { + System.out.println("已关闭：" + close); + }) + .listen(); + + Thread.sleep(2000); + + socket.send("你好呀"); + + Thread.sleep(5000); + + socket.close(1000, "close"); + + Thread.sleep(3000); + System.out.println("。。。"); + } + + +} From 26606094c60a0f3da14416f378b4f9252c0afc7b Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?=E5=91=A8=E6=97=AD?= <15735559897@qq.com> Date: Sun, 10 May 2020 15:37:52 +0800 Subject: [PATCH 239/924] =?UTF-8?q?=E6=95=B4=E7=90=86?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- .../main/java/com/ejlchina/okhttps/HTTP.java | 287 +++++++++++++++++- .../ejlchina/okhttps/internal/HttpClient.java | 275 +++-------------- .../okhttps/internal/TaskExecutor.java | 28 ++ 3 files changed, 344 insertions(+), 246 deletions(-) diff --git a/okhttps/src/main/java/com/ejlchina/okhttps/HTTP.java b/okhttps/src/main/java/com/ejlchina/okhttps/HTTP.java index 93aec89c..577f90b4 100644 --- a/okhttps/src/main/java/com/ejlchina/okhttps/HTTP.java +++ b/okhttps/src/main/java/com/ejlchina/okhttps/HTTP.java @@ -1,15 +1,13 @@ package com.ejlchina.okhttps; -import com.ejlchina.okhttps.internal.AsyncHttpTask; -import com.ejlchina.okhttps.internal.SyncHttpTask; -import com.ejlchina.okhttps.internal.TaskExecutor; -import com.ejlchina.okhttps.internal.WebSocketTask; -import com.ejlchina.okhttps.internal.HttpClient.Builder; - -import okhttp3.Call; -import okhttp3.Request; +import com.ejlchina.okhttps.internal.*; + +import okhttp3.*; import okhttp3.WebSocket; -import okhttp3.WebSocketListener; + +import java.io.IOException; +import java.util.*; +import java.util.concurrent.Executor; /** * HTTP 客户端接口 @@ -89,4 +87,275 @@ static Builder builder() { return new Builder(); } + + class Builder { + + private OkHttpClient okClient; + + private String baseUrl; + + private Map mediaTypes; + + private Configurator configurator; + + private Executor mainExecutor; + + private List preprocessors; + + private DownListener downloadListener; + + private TaskListener responseListener; + + private TaskListener exceptionListener; + + private TaskListener completeListener; + + private JsonService jsonService; + + private int preprocTimeoutTimes = 10; + + public Builder() { + mediaTypes = new HashMap<>(); + mediaTypes.put("*", "application/octet-stream"); + mediaTypes.put("png", "image/png"); + mediaTypes.put("jpg", "image/jpeg"); + mediaTypes.put("jpeg", "image/jpeg"); + mediaTypes.put("wav", "audio/wav"); + mediaTypes.put("mp3", "audio/mp3"); + mediaTypes.put("mp4", "video/mpeg4"); + mediaTypes.put("txt", "text/plain"); + mediaTypes.put("xls", "application/x-xls"); + mediaTypes.put("xml", "text/xml"); + mediaTypes.put("apk", "application/vnd.android.package-archive"); + mediaTypes.put("doc", "application/msword"); + mediaTypes.put("pdf", "application/pdf"); + mediaTypes.put("html", "text/html"); + preprocessors = new ArrayList<>(); + } + + public Builder(HttpClient hc) { + this.okClient = hc.getOkClient(); + this.baseUrl = hc.getBaseUrl(); + this.mediaTypes = hc.getMediaTypes(); + this.preprocessors = new ArrayList<>(); + Collections.addAll(this.preprocessors, hc.getPreprocessors()); + TaskExecutor executor = hc.getExecutor(); + this.downloadListener = executor.getDownloadListener(); + this.responseListener = executor.getResponseListener(); + this.exceptionListener = executor.getExceptionListener(); + this.completeListener = executor.getCompleteListener(); + this.jsonService = executor.getJsonService(); + this.preprocTimeoutTimes = hc.getPreprocTimeoutTimes(); + } + + /** + * 配置 OkHttpClient + * + * @param configurator 配置器 + * @return Builder + */ + public Builder config(Configurator configurator) { + this.configurator = configurator; + return this; + } + + /** + * 设置 baseUrl + * + * @param baseUrl 全局URL前缀 + * @return Builder + */ + public Builder baseUrl(String baseUrl) { + this.baseUrl = baseUrl; + return this; + } + + /** + * 配置媒体类型 + * + * @param mediaTypes 媒体类型 + * @return Builder + */ + public Builder mediaTypes(Map mediaTypes) { + this.mediaTypes.putAll(mediaTypes); + return this; + } + + /** + * 配置媒体类型 + * + * @param key 媒体类型KEY + * @param value 媒体类型VALUE + * @return Builder + */ + public Builder mediaTypes(String key, String value) { + this.mediaTypes.put(key, value); + return this; + } + + /** + * 设置回调执行器，例如实现切换线程功能，只对异步请求有效 + * + * @param executor 回调执行器 + * @return Builder + */ + public Builder callbackExecutor(Executor executor) { + this.mainExecutor = executor; + return this; + } + + /** + * 添加可并行处理请求任务的预处理器 + * + * @param preprocessor 预处理器 + * @return Builder + */ + public Builder addPreprocessor(Preprocessor preprocessor) { + preprocessors.add(preprocessor); + return this; + } + + /** + * 添加预处理器 + * + * @param preprocessor 预处理器 + * @return Builder + */ + public Builder addSerialPreprocessor(Preprocessor preprocessor) { + preprocessors.add(new HttpClient.SerialPreprocessor(preprocessor)); + return this; + } + + /** + * 最大预处理时间（倍数，相当普通请求的超时时间） + * + * @param times 普通超时时间的倍数，默认为 10 + * @return Builder + */ + public Builder preprocTimeoutTimes(int times) { + if (times > 0) { + this.preprocTimeoutTimes = times; + } + return this; + } + + /** + * 设置全局响应监听 + * + * @param listener 监听器 + * @return Builder + */ + public Builder responseListener(TaskListener listener) { + this.responseListener = listener; + return this; + } + + /** + * 设置全局异常监听 + * + * @param listener 监听器 + * @return Builder + */ + public Builder exceptionListener(TaskListener listener) { + this.exceptionListener = listener; + return this; + } + + /** + * 设置全局完成监听 + * + * @param listener 监听器 + * @return Builder + */ + public Builder completeListener(TaskListener listener) { + this.completeListener = listener; + return this; + } + + /** + * 设置下载监听器 + * + * @param listener 监听器 + * @return Builder + */ + public Builder downloadListener(DownListener listener) { + this.downloadListener = listener; + return this; + } + + /** + * 设置 JSON 服务 + * @param jsonService JSON 服务 + * @return Builder + */ + public Builder jsonService(JsonService jsonService) { + this.jsonService = jsonService; + return this; + } + + /** + * 构建 HTTP 实例 + * @return HTTP + */ + public HTTP build() { + if (configurator != null || okClient == null) { + OkHttpClient.Builder builder = new OkHttpClient.Builder(); + if (configurator != null) { + configurator.config(builder); + } + okClient = builder.build(); + } + return new HttpClient(this); + } + + public OkHttpClient getOkClient() { + return okClient; + } + + public String getBaseUrl() { + return baseUrl; + } + + public Map getMediaTypes() { + return mediaTypes; + } + + public Configurator getConfigurator() { + return configurator; + } + + public Executor getMainExecutor() { + return mainExecutor; + } + + public List getPreprocessors() { + return preprocessors; + } + + public DownListener getDownloadListener() { + return downloadListener; + } + + public TaskListener getResponseListener() { + return responseListener; + } + + public TaskListener getExceptionListener() { + return exceptionListener; + } + + public TaskListener getCompleteListener() { + return completeListener; + } + + public JsonService getJsonService() { + return jsonService; + } + + public int getPreprocTimeoutTimes() { + return preprocTimeoutTimes; + } + + } + } diff --git a/okhttps/src/main/java/com/ejlchina/okhttps/internal/HttpClient.java b/okhttps/src/main/java/com/ejlchina/okhttps/internal/HttpClient.java index 75e9de3d..f27c1812 100644 --- a/okhttps/src/main/java/com/ejlchina/okhttps/internal/HttpClient.java +++ b/okhttps/src/main/java/com/ejlchina/okhttps/internal/HttpClient.java @@ -1,19 +1,18 @@ package com.ejlchina.okhttps.internal; -import com.ejlchina.okhttps.*; -import com.ejlchina.okhttps.HttpResult.State; +import com.ejlchina.okhttps.Cancelable; +import com.ejlchina.okhttps.HTTP; +import com.ejlchina.okhttps.HttpTask; +import com.ejlchina.okhttps.Preprocessor; import okhttp3.*; -import okhttp3.WebSocket; -import java.io.IOException; import java.util.*; -import java.util.concurrent.Executor; public class HttpClient implements HTTP { // OkHttpClient - final OkHttpClient client; + final OkHttpClient okClient; // 根URL final String baseUrl; // 媒体类型 @@ -27,16 +26,16 @@ public class HttpClient implements HTTP { // 最大预处理时间倍数（相对于普通请求的超时时间） final int preprocTimeoutTimes; - private HttpClient(Builder builder) { - this.client = builder.client; - this.baseUrl = builder.baseUrl; - this.mediaTypes = builder.mediaTypes; - this.executor = new TaskExecutor(client.dispatcher().executorService(), - builder.mainExecutor, builder.downloadListener, - builder.responseListener, builder.exceptionListener, - builder.completeListener, builder.jsonService); - this.preprocessors = builder.preprocessors.toArray(new Preprocessor[0]); - this.preprocTimeoutTimes = builder.preprocTimeoutTimes; + public HttpClient(Builder builder) { + this.okClient = builder.getOkClient(); + this.baseUrl = builder.getBaseUrl(); + this.mediaTypes = builder.getMediaTypes(); + this.executor = new TaskExecutor(okClient.dispatcher().executorService(), + builder.getMainExecutor(), builder.getDownloadListener(), + builder.getResponseListener(), builder.getExceptionListener(), + builder.getCompleteListener(), builder.getJsonService()); + this.preprocessors = builder.getPreprocessors().toArray(new Preprocessor[0]); + this.preprocTimeoutTimes = builder.getPreprocTimeoutTimes(); this.tagTasks = new LinkedList<>(); } @@ -81,7 +80,7 @@ public int cancel(String tag) { @Override public void cancelAll() { - client.dispatcher().cancelAll(); + okClient.dispatcher().cancelAll(); synchronized (tagTasks) { tagTasks.clear(); } @@ -89,22 +88,22 @@ public void cancelAll() { @Override public Call request(Request request) { - return client.newCall(request); + return okClient.newCall(request); } @Override public WebSocket webSocket(Request request, WebSocketListener listener) { - return client.newWebSocket(request, listener); + return okClient.newWebSocket(request, listener); } public OkHttpClient getOkClient() { - return client; + return okClient; } public int preprocTimeoutMillis() { - return preprocTimeoutTimes * (client.connectTimeoutMillis() - + client.writeTimeoutMillis() - + client.readTimeoutMillis()); + return preprocTimeoutTimes * (okClient.connectTimeoutMillis() + + okClient.writeTimeoutMillis() + + okClient.readTimeoutMillis()); } public int getTagTaskCount() { @@ -200,7 +199,7 @@ public void preprocess(HttpTask> httpTask, Runnable reques * 串行预处理器 * @author Troy.Zhou */ - static class SerialPreprocessor implements Preprocessor { + public static class SerialPreprocessor implements Preprocessor { // 预处理器 private Preprocessor preprocessor; @@ -209,7 +208,7 @@ static class SerialPreprocessor implements Preprocessor { // 是否有任务正在执行 private boolean running = false; - SerialPreprocessor(Preprocessor preprocessor) { + public SerialPreprocessor(Preprocessor preprocessor) { this.preprocessor = preprocessor; this.pendings = new LinkedList<>(); } @@ -335,222 +334,24 @@ private String urlPath(String urlPath, boolean websocket) { return fullUrl; } - public static class Builder { - - private OkHttpClient client; - - private String baseUrl; - - private Map mediaTypes; - - private Configurator configurator; - - private Executor mainExecutor; - - private List preprocessors; - - private DownListener downloadListener; - - private TaskListener responseListener; - - private TaskListener exceptionListener; - - private TaskListener completeListener; - - private JsonService jsonService; - - private int preprocTimeoutTimes = 10; - - public Builder() { - mediaTypes = new HashMap<>(); - mediaTypes.put("*", "application/octet-stream"); - mediaTypes.put("png", "image/png"); - mediaTypes.put("jpg", "image/jpeg"); - mediaTypes.put("jpeg", "image/jpeg"); - mediaTypes.put("wav", "audio/wav"); - mediaTypes.put("mp3", "audio/mp3"); - mediaTypes.put("mp4", "video/mpeg4"); - mediaTypes.put("txt", "text/plain"); - mediaTypes.put("xls", "application/x-xls"); - mediaTypes.put("xml", "text/xml"); - mediaTypes.put("apk", "application/vnd.android.package-archive"); - mediaTypes.put("doc", "application/msword"); - mediaTypes.put("pdf", "application/pdf"); - mediaTypes.put("html", "text/html"); - preprocessors = new ArrayList<>(); - } - - private Builder(HttpClient hc) { - this.client = hc.client; - this.baseUrl = hc.baseUrl; - this.mediaTypes = hc.mediaTypes; - this.preprocessors = new ArrayList<>(); - Collections.addAll(this.preprocessors, hc.preprocessors); - this.downloadListener = hc.executor.downloadListener; - this.responseListener = hc.executor.responseListener; - this.exceptionListener = hc.executor.exceptionListener; - this.completeListener = hc.executor.completeListener; - this.jsonService = hc.executor.jsonService; - this.preprocTimeoutTimes = hc.preprocTimeoutTimes; - } - - /** - * 配置 OkHttpClient - * - * @param configurator 配置器 - * @return Builder - */ - public Builder config(Configurator configurator) { - this.configurator = configurator; - return this; - } - - /** - * 设置 baseUrl - * - * @param baseUrl 全局URL前缀 - * @return Builder - */ - public Builder baseUrl(String baseUrl) { - this.baseUrl = baseUrl; - return this; - } - - /** - * 配置媒体类型 - * - * @param mediaTypes 媒体类型 - * @return Builder - */ - public Builder mediaTypes(Map mediaTypes) { - this.mediaTypes.putAll(mediaTypes); - return this; - } - - /** - * 配置媒体类型 - * - * @param key 媒体类型KEY - * @param value 媒体类型VALUE - * @return Builder - */ - public Builder mediaTypes(String key, String value) { - this.mediaTypes.put(key, value); - return this; - } - - /** - * 设置回调执行器，例如实现切换线程功能，只对异步请求有效 - * - * @param executor 回调执行器 - * @return Builder - */ - public Builder callbackExecutor(Executor executor) { - this.mainExecutor = executor; - return this; - } - - /** - * 添加可并行处理请求任务的预处理器 - * - * @param preprocessor 预处理器 - * @return Builder - */ - public Builder addPreprocessor(Preprocessor preprocessor) { - preprocessors.add(preprocessor); - return this; - } - - /** - * 添加预处理器 - * - * @param preprocessor 预处理器 - * @return Builder - */ - public Builder addSerialPreprocessor(Preprocessor preprocessor) { - preprocessors.add(new SerialPreprocessor(preprocessor)); - return this; - } - - /** - * 最大预处理时间（倍数，相当普通请求的超时时间） - * - * @param times 普通超时时间的倍数，默认为 10 - * @return Builder - */ - public Builder preprocTimeoutTimes(int times) { - if (times > 0) { - this.preprocTimeoutTimes = times; - } - return this; - } - - /** - * 设置全局响应监听 - * - * @param listener 监听器 - * @return Builder - */ - public Builder responseListener(TaskListener listener) { - this.responseListener = listener; - return this; - } - - /** - * 设置全局异常监听 - * - * @param listener 监听器 - * @return Builder - */ - public Builder exceptionListener(TaskListener listener) { - this.exceptionListener = listener; - return this; - } + public String getBaseUrl() { + return baseUrl; + } - /** - * 设置全局完成监听 - * - * @param listener 监听器 - * @return Builder - */ - public Builder completeListener(TaskListener listener) { - this.completeListener = listener; - return this; - } + public Map getMediaTypes() { + return mediaTypes; + } - /** - * 设置下载监听器 - * - * @param listener 监听器 - * @return Builder - */ - public Builder downloadListener(DownListener listener) { - this.downloadListener = listener; - return this; - } + public Preprocessor[] getPreprocessors() { + return preprocessors; + } - /** - * 设置 JSON 服务 - * @param jsonService JSON 服务 - * @return Builder - */ - public Builder jsonService(JsonService jsonService) { - this.jsonService = jsonService; - return this; - } - - - public HTTP build() { - if (configurator != null || client == null) { - OkHttpClient.Builder builder = new OkHttpClient.Builder(); - if (configurator != null) { - configurator.config(builder); - } - client = builder.build(); - } - return new HttpClient(this); - } + public List getTagTasks() { + return tagTasks; + } + public int getPreprocTimeoutTimes() { + return preprocTimeoutTimes; } } diff --git a/okhttps/src/main/java/com/ejlchina/okhttps/internal/TaskExecutor.java b/okhttps/src/main/java/com/ejlchina/okhttps/internal/TaskExecutor.java index 1381006d..036da400 100644 --- a/okhttps/src/main/java/com/ejlchina/okhttps/internal/TaskExecutor.java +++ b/okhttps/src/main/java/com/ejlchina/okhttps/internal/TaskExecutor.java @@ -119,4 +119,32 @@ public void shutdown() { } } + public Executor getIoExecutor() { + return ioExecutor; + } + + public Executor getMainExecutor() { + return mainExecutor; + } + + public DownListener getDownloadListener() { + return downloadListener; + } + + public TaskListener getResponseListener() { + return responseListener; + } + + public TaskListener getExceptionListener() { + return exceptionListener; + } + + public TaskListener getCompleteListener() { + return completeListener; + } + + public JsonService getJsonService() { + return jsonService; + } + } From 31e38ee99c7953023dee30a860b32e2b0f5c031a Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?=E5=91=A8=E6=97=AD?= <15735559897@qq.com> Date: Sun, 10 May 2020 15:38:39 +0800 Subject: [PATCH 240/924] Deprecated HttpUtils#of(HTTP http) --- okhttps/src/main/java/com/ejlchina/okhttps/HttpUtils.java | 1 + 1 file changed, 1 insertion(+) diff --git a/okhttps/src/main/java/com/ejlchina/okhttps/HttpUtils.java b/okhttps/src/main/java/com/ejlchina/okhttps/HttpUtils.java index 9aac93b5..a446bebd 100644 --- a/okhttps/src/main/java/com/ejlchina/okhttps/HttpUtils.java +++ b/okhttps/src/main/java/com/ejlchina/okhttps/HttpUtils.java @@ -33,6 +33,7 @@ public class HttpUtils { * 配置HttpUtils持有的HTTP实例（不调用此方法前默认使用一个没有没有经过任何配置的HTTP懒实例） * @param http HTTP实例 */ + @Deprecated public static void of(HTTP http) { if (http != null) { HttpUtils.http = http; From f073b34053d78fb4ce6d27482ad477517354c89a Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?=E5=91=A8=E6=97=AD?= <15735559897@qq.com> Date: Sun, 10 May 2020 15:46:33 +0800 Subject: [PATCH 241/924] =?UTF-8?q?=E6=96=B0=E5=A2=9E=20HttpUtils#webSocke?= =?UTF-8?q?t(String=20url)=20=E6=96=B9=E6=B3=95?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- .../main/java/com/ejlchina/okhttps/HttpUtils.java | 14 ++++++++++++-- 1 file changed, 12 insertions(+), 2 deletions(-) diff --git a/okhttps/src/main/java/com/ejlchina/okhttps/HttpUtils.java b/okhttps/src/main/java/com/ejlchina/okhttps/HttpUtils.java index a446bebd..c71902db 100644 --- a/okhttps/src/main/java/com/ejlchina/okhttps/HttpUtils.java +++ b/okhttps/src/main/java/com/ejlchina/okhttps/HttpUtils.java @@ -4,6 +4,7 @@ import com.ejlchina.okhttps.internal.SyncHttpTask; import com.ejlchina.okhttps.internal.TaskExecutor; +import com.ejlchina.okhttps.internal.WebSocketTask; import okhttp3.Call; import okhttp3.Request; import okhttp3.WebSocket; @@ -55,7 +56,7 @@ static synchronized HTTP getHttp() { return http; } - static JsonService findJsonService(String[] classes, int index) { + static private JsonService findJsonService(String[] classes, int index) { if (index >= classes.length) { return null; } @@ -91,6 +92,15 @@ public static SyncHttpTask sync(String url) { return getHttp().sync(url); } + /** + * Websocket 连接 + * @param url 连接地址 + * @return WebSocket 任务 + */ + public static WebSocketTask webSocket(String url) { + return getHttp().webSocket(url); + } + /** * 根据标签取消HTTP任务，只要任务的标签包含指定的Tag就会被取消 * @param tag 标签 @@ -116,7 +126,7 @@ public void cancelAll() { public static Call request(Request request) { return getHttp().request(request); } - + /** * Websocket（该请求不经过 预处理器） * @param request 请求 From 3948d0d2f568584dd357dde4a8ab300a4ba85f2b Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?=E5=91=A8=E6=97=AD?= <15735559897@qq.com> Date: Sun, 10 May 2020 15:52:25 +0800 Subject: [PATCH 242/924] =?UTF-8?q?=E6=96=B0=E5=A2=9E=20OkHttps=20?= =?UTF-8?q?=E5=B7=A5=E5=85=B7=E7=B1=BB?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- .../java/com/ejlchina/okhttps/HttpUtils.java | 14 +-- .../java/com/ejlchina/okhttps/OkHttps.java | 109 ++++++++++++++++++ 2 files changed, 112 insertions(+), 11 deletions(-) create mode 100644 okhttps/src/main/java/com/ejlchina/okhttps/OkHttps.java diff --git a/okhttps/src/main/java/com/ejlchina/okhttps/HttpUtils.java b/okhttps/src/main/java/com/ejlchina/okhttps/HttpUtils.java index c71902db..1cd1bbe9 100644 --- a/okhttps/src/main/java/com/ejlchina/okhttps/HttpUtils.java +++ b/okhttps/src/main/java/com/ejlchina/okhttps/HttpUtils.java @@ -11,17 +11,9 @@ import okhttp3.WebSocketListener; /** - * Http 工具类，封装 OkHttp - - * 特性： - * 同步请求 - * 异步请求 - * Restfull路径 - * 文件上传 - * JSON自动解析 - * TCP连接池 - * Http2 - * + * Http 工具类（可供第三方库，非主应用使用） + * 若需要配置，请使用 {@link OkHttps } 类 + * * @author Troy.Zhou */ public class HttpUtils { diff --git a/okhttps/src/main/java/com/ejlchina/okhttps/OkHttps.java b/okhttps/src/main/java/com/ejlchina/okhttps/OkHttps.java new file mode 100644 index 00000000..6a4daa40 --- /dev/null +++ b/okhttps/src/main/java/com/ejlchina/okhttps/OkHttps.java @@ -0,0 +1,109 @@ +package com.ejlchina.okhttps; + +import com.ejlchina.okhttps.internal.*; +import okhttp3.Call; +import okhttp3.Request; +import okhttp3.WebSocket; +import okhttp3.WebSocketListener; + +import java.util.ServiceLoader; + +/** + * OkHttps 工具类 + * 支持 SPI 方式配置 + */ +public class OkHttps { + + public interface Config { + + void withConfig(HTTP.Builder builder); + + } + + private static HTTP http; + + static synchronized HTTP getHttp() { + if (http != null) { + return http; + } + HTTP.Builder builder = HTTP.builder(); + for (Config config : ServiceLoader.load(Config.class)) { + config.withConfig(builder); + } + http = builder.build(); + return http; + } + + + /** + * 异步请求 + * @param url 请求地址 + * @return 异步 HttpTask + */ + public static AsyncHttpTask async(String url) { + return getHttp().async(url); + } + + /** + * 同步请求 + * @param url 请求地址 + * @return 同步 HttpTask + */ + public static SyncHttpTask sync(String url) { + return getHttp().sync(url); + } + + /** + * Websocket 连接 + * @param url 连接地址 + * @return WebSocket 任务 + */ + public static WebSocketTask webSocket(String url) { + return getHttp().webSocket(url); + } + + /** + * 根据标签取消HTTP任务，只要任务的标签包含指定的Tag就会被取消 + * @param tag 标签 + * @return 被取消的任务数量 + */ + public static int cancel(String tag) { + return getHttp().cancel(tag); + } + + /** + * @since 1.0.3 + * 取消所有HTTP任务，包括同步和异步 + */ + public void cancelAll() { + getHttp().cancelAll(); + } + + /** + * OkHttp 原生请求 （该请求不经过 预处理器） + * @param request 请求 + * @return Call + */ + public static Call request(Request request) { + return getHttp().request(request); + } + + /** + * Websocket（该请求不经过 预处理器） + * @param request 请求 + * @param listener 监听器 + * @return WebSocket + */ + public static WebSocket webSocket(Request request, WebSocketListener listener) { + return getHttp().webSocket(request, listener); + } + + /** + * 获取任务执行器 + * @return TaskExecutor + */ + public static TaskExecutor getExecutor() { + return getHttp().getExecutor(); + } + +} From 1cb63c36696e370e323f00886cbfeed93c7cb159 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?=E5=91=A8=E6=97=AD?= <15735559897@qq.com> Date: Sun, 10 May 2020 15:54:11 +0800 Subject: [PATCH 243/924] .. --- okhttps/src/main/java/com/ejlchina/okhttps/OkHttps.java | 4 +++- 1 file changed, 3 insertions(+), 1 deletion(-) diff --git a/okhttps/src/main/java/com/ejlchina/okhttps/OkHttps.java b/okhttps/src/main/java/com/ejlchina/okhttps/OkHttps.java index 6a4daa40..b581bb21 100644 --- a/okhttps/src/main/java/com/ejlchina/okhttps/OkHttps.java +++ b/okhttps/src/main/java/com/ejlchina/okhttps/OkHttps.java @@ -12,7 +12,9 @@ * OkHttps 工具类 * 支持 SPI 方式配置 */ -public class OkHttps { +public final class OkHttps { + + private OkHttps() {} public interface Config { From c8cf532a66599d92312a5b381e00d0a0987708cd Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?=E5=91=A8=E6=97=AD?= <15735559897@qq.com> Date: Sun, 10 May 2020 16:03:24 +0800 Subject: [PATCH 244/924] =?UTF-8?q?OkHttps=20JSON=20=E8=87=AA=E5=8A=A8?= =?UTF-8?q?=E9=85=8D=E7=BD=AE?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- .../java/com/ejlchina/okhttps/FastJsonConfig.java | 12 ++++++++++++ .../services/com.ejlchina.okhttps.OkHttps.Config | 1 + .../main/java/com/ejlchina/okhttps/GsonConfig.java | 12 ++++++++++++ .../services/com.ejlchina.okhttps.OkHttps.Config | 1 + .../java/com/ejlchina/okhttps/JacksonConfig.java | 12 ++++++++++++ .../services/com.ejlchina.okhttps.OkHttps.Config | 1 + 6 files changed, 39 insertions(+) create mode 100644 okhttps-fastjson/src/main/java/com/ejlchina/okhttps/FastJsonConfig.java create mode 100644 okhttps-fastjson/src/main/resources/META-INF/services/com.ejlchina.okhttps.OkHttps.Config create mode 100644 okhttps-gson/src/main/java/com/ejlchina/okhttps/GsonConfig.java create mode 100644 okhttps-gson/src/main/resources/META-INF/services/com.ejlchina.okhttps.OkHttps.Config create mode 100644 okhttps-jackson/src/main/java/com/ejlchina/okhttps/JacksonConfig.java create mode 100644 okhttps-jackson/src/main/resources/META-INF/services/com.ejlchina.okhttps.OkHttps.Config diff --git a/okhttps-fastjson/src/main/java/com/ejlchina/okhttps/FastJsonConfig.java b/okhttps-fastjson/src/main/java/com/ejlchina/okhttps/FastJsonConfig.java new file mode 100644 index 00000000..68062977 --- /dev/null +++ b/okhttps-fastjson/src/main/java/com/ejlchina/okhttps/FastJsonConfig.java @@ -0,0 +1,12 @@ +package com.ejlchina.okhttps; + +public class FastJsonConfig implements OkHttps.Config { + + @Override + public void withConfig(HTTP.Builder builder) { + if (builder.getJsonService() == null) { + builder.jsonService(new FastJsonService()); + } + } + +} diff --git a/okhttps-fastjson/src/main/resources/META-INF/services/com.ejlchina.okhttps.OkHttps.Config b/okhttps-fastjson/src/main/resources/META-INF/services/com.ejlchina.okhttps.OkHttps.Config new file mode 100644 index 00000000..365b9421 --- /dev/null +++ b/okhttps-fastjson/src/main/resources/META-INF/services/com.ejlchina.okhttps.OkHttps.Config @@ -0,0 +1 @@ +com.ejlchina.okhttps.GsonConfig \ No newline at end of file diff --git a/okhttps-gson/src/main/java/com/ejlchina/okhttps/GsonConfig.java b/okhttps-gson/src/main/java/com/ejlchina/okhttps/GsonConfig.java new file mode 100644 index 00000000..c2190221 --- /dev/null +++ b/okhttps-gson/src/main/java/com/ejlchina/okhttps/GsonConfig.java @@ -0,0 +1,12 @@ +package com.ejlchina.okhttps; + +public class GsonConfig implements OkHttps.Config { + + @Override + public void withConfig(HTTP.Builder builder) { + if (builder.getJsonService() == null) { + builder.jsonService(new GsonService()); + } + } + +} diff --git a/okhttps-gson/src/main/resources/META-INF/services/com.ejlchina.okhttps.OkHttps.Config b/okhttps-gson/src/main/resources/META-INF/services/com.ejlchina.okhttps.OkHttps.Config new file mode 100644 index 00000000..365b9421 --- /dev/null +++ b/okhttps-gson/src/main/resources/META-INF/services/com.ejlchina.okhttps.OkHttps.Config @@ -0,0 +1 @@ +com.ejlchina.okhttps.GsonConfig \ No newline at end of file diff --git a/okhttps-jackson/src/main/java/com/ejlchina/okhttps/JacksonConfig.java b/okhttps-jackson/src/main/java/com/ejlchina/okhttps/JacksonConfig.java new file mode 100644 index 00000000..70946da7 --- /dev/null +++ b/okhttps-jackson/src/main/java/com/ejlchina/okhttps/JacksonConfig.java @@ -0,0 +1,12 @@ +package com.ejlchina.okhttps; + +public class JacksonConfig implements OkHttps.Config { + + @Override + public void withConfig(HTTP.Builder builder) { + if (builder.getJsonService() == null) { + builder.jsonService(new JacksonService()); + } + } + +} diff --git a/okhttps-jackson/src/main/resources/META-INF/services/com.ejlchina.okhttps.OkHttps.Config b/okhttps-jackson/src/main/resources/META-INF/services/com.ejlchina.okhttps.OkHttps.Config new file mode 100644 index 00000000..f00ef42b --- /dev/null +++ b/okhttps-jackson/src/main/resources/META-INF/services/com.ejlchina.okhttps.OkHttps.Config @@ -0,0 +1 @@ +com.ejlchina.okhttps.JacksonConfig \ No newline at end of file From 104ee49025902162ca53a08195dc6421976cba43 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?=E5=91=A8=E6=97=AD?= <15735559897@qq.com> Date: Sun, 10 May 2020 16:04:28 +0800 Subject: [PATCH 245/924] =?UTF-8?q?OkHttps=20JSON=20=E8=87=AA=E5=8A=A8?= =?UTF-8?q?=E9=85=8D=E7=BD=AE?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- .../META-INF/services/com.ejlchina.okhttps.OkHttps.Config | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/okhttps-fastjson/src/main/resources/META-INF/services/com.ejlchina.okhttps.OkHttps.Config b/okhttps-fastjson/src/main/resources/META-INF/services/com.ejlchina.okhttps.OkHttps.Config index 365b9421..98b6b6e7 100644 --- a/okhttps-fastjson/src/main/resources/META-INF/services/com.ejlchina.okhttps.OkHttps.Config +++ b/okhttps-fastjson/src/main/resources/META-INF/services/com.ejlchina.okhttps.OkHttps.Config @@ -1 +1 @@ -com.ejlchina.okhttps.GsonConfig \ No newline at end of file +com.ejlchina.okhttps.FastJsonConfig \ No newline at end of file From ce2adf2953457ebbee566002f3079a5ccbae18b3 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?=E5=91=A8=E6=97=AD?= <15735559897@qq.com> Date: Sun, 10 May 2020 16:16:32 +0800 Subject: [PATCH 246/924] JsonService AutoConfig --- .../okhttps/{FastJsonConfig.java => FastJsonAutoConfig.java} | 2 +- .../META-INF/services/com.ejlchina.okhttps.OkHttps.Config | 2 +- .../ejlchina/okhttps/{GsonConfig.java => GsonAutoConfig.java} | 2 +- .../META-INF/services/com.ejlchina.okhttps.OkHttps.Config | 2 +- .../okhttps/{JacksonConfig.java => JacksonAutoConfig.java} | 2 +- .../META-INF/services/com.ejlchina.okhttps.OkHttps.Config | 2 +- 6 files changed, 6 insertions(+), 6 deletions(-) rename okhttps-fastjson/src/main/java/com/ejlchina/okhttps/{FastJsonConfig.java => FastJsonAutoConfig.java} (78%) rename okhttps-gson/src/main/java/com/ejlchina/okhttps/{GsonConfig.java => GsonAutoConfig.java} (79%) rename okhttps-jackson/src/main/java/com/ejlchina/okhttps/{JacksonConfig.java => JacksonAutoConfig.java} (78%) diff --git a/okhttps-fastjson/src/main/java/com/ejlchina/okhttps/FastJsonConfig.java b/okhttps-fastjson/src/main/java/com/ejlchina/okhttps/FastJsonAutoConfig.java similarity index 78% rename from okhttps-fastjson/src/main/java/com/ejlchina/okhttps/FastJsonConfig.java rename to okhttps-fastjson/src/main/java/com/ejlchina/okhttps/FastJsonAutoConfig.java index 68062977..52ab16fa 100644 --- a/okhttps-fastjson/src/main/java/com/ejlchina/okhttps/FastJsonConfig.java +++ b/okhttps-fastjson/src/main/java/com/ejlchina/okhttps/FastJsonAutoConfig.java @@ -1,6 +1,6 @@ package com.ejlchina.okhttps; -public class FastJsonConfig implements OkHttps.Config { +public class FastJsonAutoConfig implements OkHttps.Config { @Override public void withConfig(HTTP.Builder builder) { diff --git a/okhttps-fastjson/src/main/resources/META-INF/services/com.ejlchina.okhttps.OkHttps.Config b/okhttps-fastjson/src/main/resources/META-INF/services/com.ejlchina.okhttps.OkHttps.Config index 98b6b6e7..a590a34f 100644 --- a/okhttps-fastjson/src/main/resources/META-INF/services/com.ejlchina.okhttps.OkHttps.Config +++ b/okhttps-fastjson/src/main/resources/META-INF/services/com.ejlchina.okhttps.OkHttps.Config @@ -1 +1 @@ -com.ejlchina.okhttps.FastJsonConfig \ No newline at end of file +com.ejlchina.okhttps.FastJsonAutoConfig \ No newline at end of file diff --git a/okhttps-gson/src/main/java/com/ejlchina/okhttps/GsonConfig.java b/okhttps-gson/src/main/java/com/ejlchina/okhttps/GsonAutoConfig.java similarity index 79% rename from okhttps-gson/src/main/java/com/ejlchina/okhttps/GsonConfig.java rename to okhttps-gson/src/main/java/com/ejlchina/okhttps/GsonAutoConfig.java index c2190221..1695741b 100644 --- a/okhttps-gson/src/main/java/com/ejlchina/okhttps/GsonConfig.java +++ b/okhttps-gson/src/main/java/com/ejlchina/okhttps/GsonAutoConfig.java @@ -1,6 +1,6 @@ package com.ejlchina.okhttps; -public class GsonConfig implements OkHttps.Config { +public class GsonAutoConfig implements OkHttps.Config { @Override public void withConfig(HTTP.Builder builder) { diff --git a/okhttps-gson/src/main/resources/META-INF/services/com.ejlchina.okhttps.OkHttps.Config b/okhttps-gson/src/main/resources/META-INF/services/com.ejlchina.okhttps.OkHttps.Config index 365b9421..637f6eb7 100644 --- a/okhttps-gson/src/main/resources/META-INF/services/com.ejlchina.okhttps.OkHttps.Config +++ b/okhttps-gson/src/main/resources/META-INF/services/com.ejlchina.okhttps.OkHttps.Config @@ -1 +1 @@ -com.ejlchina.okhttps.GsonConfig \ No newline at end of file +com.ejlchina.okhttps.GsonAutoConfig \ No newline at end of file diff --git a/okhttps-jackson/src/main/java/com/ejlchina/okhttps/JacksonConfig.java b/okhttps-jackson/src/main/java/com/ejlchina/okhttps/JacksonAutoConfig.java similarity index 78% rename from okhttps-jackson/src/main/java/com/ejlchina/okhttps/JacksonConfig.java rename to okhttps-jackson/src/main/java/com/ejlchina/okhttps/JacksonAutoConfig.java index 70946da7..7e7a3a0c 100644 --- a/okhttps-jackson/src/main/java/com/ejlchina/okhttps/JacksonConfig.java +++ b/okhttps-jackson/src/main/java/com/ejlchina/okhttps/JacksonAutoConfig.java @@ -1,6 +1,6 @@ package com.ejlchina.okhttps; -public class JacksonConfig implements OkHttps.Config { +public class JacksonAutoConfig implements OkHttps.Config { @Override public void withConfig(HTTP.Builder builder) { diff --git a/okhttps-jackson/src/main/resources/META-INF/services/com.ejlchina.okhttps.OkHttps.Config b/okhttps-jackson/src/main/resources/META-INF/services/com.ejlchina.okhttps.OkHttps.Config index f00ef42b..1aca027c 100644 --- a/okhttps-jackson/src/main/resources/META-INF/services/com.ejlchina.okhttps.OkHttps.Config +++ b/okhttps-jackson/src/main/resources/META-INF/services/com.ejlchina.okhttps.OkHttps.Config @@ -1 +1 @@ -com.ejlchina.okhttps.JacksonConfig \ No newline at end of file +com.ejlchina.okhttps.JacksonAutoConfig \ No newline at end of file From bee4ba93c11e811ca29d203d1f9111599bb2e5b2 Mon Sep 17 00:00:00 2001 From: ejlchina Date: Mon, 11 May 2020 09:14:16 +0800 Subject: [PATCH 247/924] update README.md. --- README.md | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/README.md b/README.md index ed3a8f1c..aea850a2 100644 --- a/README.md +++ b/README.md @@ -1,6 +1,6 @@

- logo + logo

@@ -1072,7 +1072,7 @@ HTTP http = HTTP.builder() ## 联系方式 -* 微信： +* 微信： * 邮箱：zhou.xu@ejlchina.com ## 参与贡献 From 3537513446fe1a8db69ddc115ead6663d91ca83c Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?=E5=91=A8=E6=97=AD?= Date: Mon, 11 May 2020 09:38:05 +0800 Subject: [PATCH 248/924] =?UTF-8?q?=E9=87=8D=E6=9E=84?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- .../com/ejlchina/okhttps/FastJsonService.java | 16 +++++----- .../{FastJsonArr.java => FastjsonArray.java} | 12 ++++---- .../{FastJsonObj.java => FastjsonMapper.java} | 12 ++++---- .../java/com/ejlchina/okhttps/TestCases.java | 30 +++++++++---------- .../java/com/ejlchina/okhttps/GsonArr.java | 6 ++-- .../java/com/ejlchina/okhttps/GsonObj.java | 6 ++-- .../com/ejlchina/okhttps/GsonService.java | 12 ++++---- .../java/com/ejlchina/okhttps/TestCases.java | 30 +++++++++---------- .../java/com/ejlchina/okhttps/JacksonArr.java | 6 ++-- .../java/com/ejlchina/okhttps/JacksonObj.java | 6 ++-- .../com/ejlchina/okhttps/JacksonService.java | 12 ++++---- .../java/com/ejlchina/okhttps/TestCases.java | 30 +++++++++---------- .../okhttps/{JsonArr.java => Array.java} | 6 ++-- .../java/com/ejlchina/okhttps/HttpResult.java | 4 +-- .../java/com/ejlchina/okhttps/HttpTask.java | 6 ++-- .../com/ejlchina/okhttps/JsonService.java | 24 +++++++-------- .../okhttps/{JsonObj.java => Mapper.java} | 10 +++---- .../java/com/ejlchina/okhttps/WebSocket.java | 4 +-- .../okhttps/internal/AbstractBody.java | 16 +++++----- .../okhttps/internal/WebSocketTask.java | 6 ++-- .../java/com/ejlchina/test/SimpleTests.java | 3 -- 21 files changed, 127 insertions(+), 130 deletions(-) rename okhttps-fastjson/src/main/java/com/ejlchina/okhttps/{FastJsonArr.java => FastjsonArray.java} (85%) rename okhttps-fastjson/src/main/java/com/ejlchina/okhttps/{FastJsonObj.java => FastjsonMapper.java} (86%) rename okhttps/src/main/java/com/ejlchina/okhttps/{JsonArr.java => Array.java} (92%) rename okhttps/src/main/java/com/ejlchina/okhttps/{JsonObj.java => Mapper.java} (89%) diff --git a/okhttps-fastjson/src/main/java/com/ejlchina/okhttps/FastJsonService.java b/okhttps-fastjson/src/main/java/com/ejlchina/okhttps/FastJsonService.java index 8f0c57fe..4093be9d 100644 --- a/okhttps-fastjson/src/main/java/com/ejlchina/okhttps/FastJsonService.java +++ b/okhttps-fastjson/src/main/java/com/ejlchina/okhttps/FastJsonService.java @@ -24,32 +24,32 @@ public FastJsonService(Charset charset) { } @Override - public JsonObj toJsonObj(InputStream in) { - return new FastJsonObj(JSON.parseObject(toString(in))); + public Mapper toMapper(InputStream in) { + return new FastjsonMapper(JSON.parseObject(toString(in))); } @Override - public JsonArr toJsonArr(InputStream in) { - return new FastJsonArr(JSON.parseArray(toString(in))); + public Array toArray(InputStream in) { + return new FastjsonArray(JSON.parseArray(toString(in))); } @Override - public String toJsonStr(Object bean) { + public String serialize(Object bean) { return JSON.toJSONString(bean); } @Override - public String toJsonStr(Object bean, String dateFormat) { + public String serialize(Object bean, String dateFormat) { return JSON.toJSONStringWithDateFormat(bean, dateFormat); } @Override - public T jsonToBean(Class type, InputStream in) { + public T toBean(Class type, InputStream in) { return JSON.parseObject(toString(in), type); } @Override - public List jsonToList(Class type, InputStream in) { + public List toList(Class type, InputStream in) { return JSON.parseArray(toString(in), type); } diff --git a/okhttps-fastjson/src/main/java/com/ejlchina/okhttps/FastJsonArr.java b/okhttps-fastjson/src/main/java/com/ejlchina/okhttps/FastjsonArray.java similarity index 85% rename from okhttps-fastjson/src/main/java/com/ejlchina/okhttps/FastJsonArr.java rename to okhttps-fastjson/src/main/java/com/ejlchina/okhttps/FastjsonArray.java index 829fcb50..3bcdff89 100644 --- a/okhttps-fastjson/src/main/java/com/ejlchina/okhttps/FastJsonArr.java +++ b/okhttps-fastjson/src/main/java/com/ejlchina/okhttps/FastjsonArray.java @@ -6,11 +6,11 @@ import com.alibaba.fastjson.JSONArray; import com.alibaba.fastjson.JSONObject; -public class FastJsonArr implements JsonArr { +public class FastjsonArray implements Array { private JSONArray json; - public FastJsonArr(JSONArray json) { + public FastjsonArray(JSONArray json) { this.json = json; } @@ -25,19 +25,19 @@ public boolean isEmpty() { } @Override - public JsonObj getJsonOjb(int index) { + public Mapper getMapper(int index) { JSONObject subJson = json.getJSONObject(index); if (subJson != null) { - return new FastJsonObj(subJson); + return new FastjsonMapper(subJson); } return null; } @Override - public JsonArr getJsonArr(int index) { + public Array getArray(int index) { JSONArray subJson = json.getJSONArray(index); if (subJson != null) { - return new FastJsonArr(subJson); + return new FastjsonArray(subJson); } return null; } diff --git a/okhttps-fastjson/src/main/java/com/ejlchina/okhttps/FastJsonObj.java b/okhttps-fastjson/src/main/java/com/ejlchina/okhttps/FastjsonMapper.java similarity index 86% rename from okhttps-fastjson/src/main/java/com/ejlchina/okhttps/FastJsonObj.java rename to okhttps-fastjson/src/main/java/com/ejlchina/okhttps/FastjsonMapper.java index dfddd9c6..c7c16ee6 100644 --- a/okhttps-fastjson/src/main/java/com/ejlchina/okhttps/FastJsonObj.java +++ b/okhttps-fastjson/src/main/java/com/ejlchina/okhttps/FastjsonMapper.java @@ -7,11 +7,11 @@ import com.alibaba.fastjson.JSONArray; import com.alibaba.fastjson.JSONObject; -public class FastJsonObj implements JsonObj { +public class FastjsonMapper implements Mapper { private JSONObject json; - public FastJsonObj(JSONObject json) { + public FastjsonMapper(JSONObject json) { this.json = json; } @@ -26,19 +26,19 @@ public boolean isEmpty() { } @Override - public JsonObj getJsonOjb(String key) { + public Mapper getMapper(String key) { JSONObject subJson = json.getJSONObject(key); if (subJson != null) { - return new FastJsonObj(subJson); + return new FastjsonMapper(subJson); } return null; } @Override - public JsonArr getJsonArr(String key) { + public Array getArray(String key) { JSONArray subJson = json.getJSONArray(key); if (subJson != null) { - return new FastJsonArr(subJson); + return new FastjsonArray(subJson); } return null; } diff --git a/okhttps-fastjson/src/test/java/com/ejlchina/okhttps/TestCases.java b/okhttps-fastjson/src/test/java/com/ejlchina/okhttps/TestCases.java index c5657995..1acb99a8 100644 --- a/okhttps-fastjson/src/test/java/com/ejlchina/okhttps/TestCases.java +++ b/okhttps-fastjson/src/test/java/com/ejlchina/okhttps/TestCases.java @@ -19,28 +19,28 @@ public class TestCases { public void testToJsonObj() { String json = "{\"id\":1,\"name\":\"Jack\"}"; InputStream in = new ByteArrayInputStream(json.getBytes()); - JsonObj jsonObj = jsonService.toJsonObj(in); - Set keys = jsonObj.keySet(); + Mapper mapper = jsonService.toMapper(in); + Set keys = mapper.keySet(); Assert.assertTrue(keys.size() == 2); Assert.assertTrue(keys.contains("id")); Assert.assertTrue(keys.contains("name")); - Assert.assertTrue(!jsonObj.isEmpty()); - Assert.assertTrue(2 == jsonObj.size()); - Assert.assertTrue(1 == jsonObj.getInt("id")); - Assert.assertTrue(!jsonObj.has("age")); - Assert.assertTrue(0 == jsonObj.getInt("age")); - Assert.assertEquals("Jack", jsonObj.getString("name")); + Assert.assertTrue(!mapper.isEmpty()); + Assert.assertTrue(2 == mapper.size()); + Assert.assertTrue(1 == mapper.getInt("id")); + Assert.assertTrue(!mapper.has("age")); + Assert.assertTrue(0 == mapper.getInt("age")); + Assert.assertEquals("Jack", mapper.getString("name")); } @Test public void testToJsonArr() { String json = "[{\"id\":1,\"name\":\"Jack\"},{\"id\":2,\"name\":\"Tom\"}]"; InputStream in = new ByteArrayInputStream(json.getBytes()); - JsonArr jsonObj = jsonService.toJsonArr(in); + Array jsonObj = jsonService.toArray(in); Assert.assertTrue(!jsonObj.isEmpty()); Assert.assertTrue(jsonObj.size() == 2); - JsonObj json1 = jsonObj.getJsonOjb(0); - JsonObj json2 = jsonObj.getJsonOjb(1); + Mapper json1 = jsonObj.getMapper(0); + Mapper json2 = jsonObj.getMapper(1); Assert.assertEquals(1, json1.getInt("id")); Assert.assertEquals("Jack", json1.getString("name")); Assert.assertEquals(2, json2.getInt("id")); @@ -49,7 +49,7 @@ public void testToJsonArr() { @Test public void testToJsonStr() { - String json = jsonService.toJsonStr(new User(1, "Jack")); + String json = jsonService.serialize(new User(1, "Jack")); Assert.assertEquals("{\"id\":1,\"name\":\"Jack\"}", json); } @@ -58,7 +58,7 @@ public void testToJsonStrWithDateFormat() throws ParseException { String dataFormat = "yyyy-MM-dd HH:mm:ss"; SimpleDateFormat sdf = new SimpleDateFormat(dataFormat); String date = "2020-05-09 12:30:15"; - String json = jsonService.toJsonStr(new DateBean(1, sdf.parse(date)), dataFormat); + String json = jsonService.serialize(new DateBean(1, sdf.parse(date)), dataFormat); Assert.assertTrue(json.contains(date)); } @@ -66,7 +66,7 @@ public void testToJsonStrWithDateFormat() throws ParseException { public void testJsonToBean() { String json = "{\"id\":1,\"name\":\"Jack\"}"; InputStream in = new ByteArrayInputStream(json.getBytes()); - User user = jsonService.jsonToBean(User.class, in); + User user = jsonService.toBean(User.class, in); Assert.assertEquals(1, user.getId()); Assert.assertEquals("Jack", user.getName()); } @@ -75,7 +75,7 @@ public void testJsonToBean() { public void testJsonToList() { String json = "[{\"id\":1,\"name\":\"Jack\"},{\"id\":2,\"name\":\"Tom\"}]"; InputStream in = new ByteArrayInputStream(json.getBytes()); - List users = jsonService.jsonToList(User.class, in); + List users = jsonService.toList(User.class, in); Assert.assertTrue(2 == users.size()); User u1 = users.get(0); User u2 = users.get(1); diff --git a/okhttps-gson/src/main/java/com/ejlchina/okhttps/GsonArr.java b/okhttps-gson/src/main/java/com/ejlchina/okhttps/GsonArr.java index 85ae0620..52c6dc98 100644 --- a/okhttps-gson/src/main/java/com/ejlchina/okhttps/GsonArr.java +++ b/okhttps-gson/src/main/java/com/ejlchina/okhttps/GsonArr.java @@ -6,7 +6,7 @@ import com.google.gson.JsonArray; import com.google.gson.JsonElement; -public class GsonArr implements JsonArr { +public class GsonArr implements Array { private JsonArray json; @@ -25,7 +25,7 @@ public boolean isEmpty() { } @Override - public JsonObj getJsonOjb(int index) { + public Mapper getMapper(int index) { JsonElement subJson = json.get(index); if (subJson != null) { return new GsonObj(subJson.getAsJsonObject()); @@ -34,7 +34,7 @@ public JsonObj getJsonOjb(int index) { } @Override - public JsonArr getJsonArr(int index) { + public Array getArray(int index) { JsonElement subJson = json.get(index); if (subJson != null) { return new GsonArr(subJson.getAsJsonArray()); diff --git a/okhttps-gson/src/main/java/com/ejlchina/okhttps/GsonObj.java b/okhttps-gson/src/main/java/com/ejlchina/okhttps/GsonObj.java index 88d3afbf..fb2fa2f4 100644 --- a/okhttps-gson/src/main/java/com/ejlchina/okhttps/GsonObj.java +++ b/okhttps-gson/src/main/java/com/ejlchina/okhttps/GsonObj.java @@ -7,7 +7,7 @@ import com.google.gson.JsonElement; import com.google.gson.JsonObject; -public class GsonObj implements JsonObj { +public class GsonObj implements Mapper { private JsonObject json; @@ -26,7 +26,7 @@ public boolean isEmpty() { } @Override - public JsonObj getJsonOjb(String key) { + public Mapper getMapper(String key) { JsonElement subJson = json.get(key); if (subJson != null) { return new GsonObj(subJson.getAsJsonObject()); @@ -35,7 +35,7 @@ public JsonObj getJsonOjb(String key) { } @Override - public JsonArr getJsonArr(String key) { + public Array getArray(String key) { JsonElement subJson = json.get(key); if (subJson != null) { return new GsonArr(subJson.getAsJsonArray()); diff --git a/okhttps-gson/src/main/java/com/ejlchina/okhttps/GsonService.java b/okhttps-gson/src/main/java/com/ejlchina/okhttps/GsonService.java index 1b25c59e..ead466a4 100644 --- a/okhttps-gson/src/main/java/com/ejlchina/okhttps/GsonService.java +++ b/okhttps-gson/src/main/java/com/ejlchina/okhttps/GsonService.java @@ -24,32 +24,32 @@ public GsonService(Gson gson) { } @Override - public JsonObj toJsonObj(InputStream in) { + public Mapper toMapper(InputStream in) { return new GsonObj(gson.fromJson(new InputStreamReader(in), JsonObject.class)); } @Override - public JsonArr toJsonArr(InputStream in) { + public Array toArray(InputStream in) { return new GsonArr(gson.fromJson(new InputStreamReader(in), JsonArray.class)); } @Override - public String toJsonStr(Object bean) { + public String serialize(Object bean) { return gson.toJson(bean); } @Override - public String toJsonStr(Object bean, String dateFormat) { + public String serialize(Object bean, String dateFormat) { return gson.newBuilder().setDateFormat(dateFormat).create().toJson(bean); } @Override - public T jsonToBean(Class type, InputStream in) { + public T toBean(Class type, InputStream in) { return gson.fromJson(new InputStreamReader(in), type); } @Override - public List jsonToList(Class type, InputStream in) { + public List toList(Class type, InputStream in) { T[] beans = gson.fromJson(new InputStreamReader(in), TypeToken.getArray(type).getType()); List list = new ArrayList<>(); Collections.addAll(list, beans); diff --git a/okhttps-gson/src/test/java/com/ejlchina/okhttps/TestCases.java b/okhttps-gson/src/test/java/com/ejlchina/okhttps/TestCases.java index ebf03180..ce9603f7 100644 --- a/okhttps-gson/src/test/java/com/ejlchina/okhttps/TestCases.java +++ b/okhttps-gson/src/test/java/com/ejlchina/okhttps/TestCases.java @@ -19,28 +19,28 @@ public class TestCases { public void testToJsonObj() { String json = "{\"id\":1,\"name\":\"Jack\"}"; InputStream in = new ByteArrayInputStream(json.getBytes()); - JsonObj jsonObj = jsonService.toJsonObj(in); - Set keys = jsonObj.keySet(); + Mapper mapper = jsonService.toMapper(in); + Set keys = mapper.keySet(); Assert.assertTrue(keys.size() == 2); Assert.assertTrue(keys.contains("id")); Assert.assertTrue(keys.contains("name")); - Assert.assertTrue(!jsonObj.isEmpty()); - Assert.assertTrue(2 == jsonObj.size()); - Assert.assertTrue(1 == jsonObj.getInt("id")); - Assert.assertTrue(!jsonObj.has("age")); - Assert.assertTrue(0 == jsonObj.getInt("age")); - Assert.assertEquals("Jack", jsonObj.getString("name")); + Assert.assertTrue(!mapper.isEmpty()); + Assert.assertTrue(2 == mapper.size()); + Assert.assertTrue(1 == mapper.getInt("id")); + Assert.assertTrue(!mapper.has("age")); + Assert.assertTrue(0 == mapper.getInt("age")); + Assert.assertEquals("Jack", mapper.getString("name")); } @Test public void testToJsonArr() { String json = "[{\"id\":1,\"name\":\"Jack\"},{\"id\":2,\"name\":\"Tom\"}]"; InputStream in = new ByteArrayInputStream(json.getBytes()); - JsonArr jsonObj = jsonService.toJsonArr(in); + Array jsonObj = jsonService.toArray(in); Assert.assertTrue(!jsonObj.isEmpty()); Assert.assertTrue(jsonObj.size() == 2); - JsonObj json1 = jsonObj.getJsonOjb(0); - JsonObj json2 = jsonObj.getJsonOjb(1); + Mapper json1 = jsonObj.getMapper(0); + Mapper json2 = jsonObj.getMapper(1); Assert.assertEquals(1, json1.getInt("id")); Assert.assertEquals("Jack", json1.getString("name")); Assert.assertEquals(2, json2.getInt("id")); @@ -49,7 +49,7 @@ public void testToJsonArr() { @Test public void testToJsonStr() { - String json = jsonService.toJsonStr(new User(1, "Jack")); + String json = jsonService.serialize(new User(1, "Jack")); Assert.assertEquals("{\"id\":1,\"name\":\"Jack\"}", json); } @@ -58,7 +58,7 @@ public void testToJsonStrWithDateFormat() throws ParseException { String dataFormat = "yyyy-MM-dd HH:mm:ss"; SimpleDateFormat sdf = new SimpleDateFormat(dataFormat); String date = "2020-05-09 12:30:15"; - String json = jsonService.toJsonStr(new DateBean(1, sdf.parse(date)), dataFormat); + String json = jsonService.serialize(new DateBean(1, sdf.parse(date)), dataFormat); Assert.assertTrue(json.contains(date)); } @@ -66,7 +66,7 @@ public void testToJsonStrWithDateFormat() throws ParseException { public void testJsonToBean() { String json = "{\"id\":1,\"name\":\"Jack\"}"; InputStream in = new ByteArrayInputStream(json.getBytes()); - User user = jsonService.jsonToBean(User.class, in); + User user = jsonService.toBean(User.class, in); Assert.assertEquals(1, user.getId()); Assert.assertEquals("Jack", user.getName()); } @@ -75,7 +75,7 @@ public void testJsonToBean() { public void testJsonToList() { String json = "[{\"id\":1,\"name\":\"Jack\"},{\"id\":2,\"name\":\"Tom\"}]"; InputStream in = new ByteArrayInputStream(json.getBytes()); - List users = jsonService.jsonToList(User.class, in); + List users = jsonService.toList(User.class, in); Assert.assertTrue(2 == users.size()); User u1 = users.get(0); User u2 = users.get(1); diff --git a/okhttps-jackson/src/main/java/com/ejlchina/okhttps/JacksonArr.java b/okhttps-jackson/src/main/java/com/ejlchina/okhttps/JacksonArr.java index 3d65cf0b..b5ba9bd2 100644 --- a/okhttps-jackson/src/main/java/com/ejlchina/okhttps/JacksonArr.java +++ b/okhttps-jackson/src/main/java/com/ejlchina/okhttps/JacksonArr.java @@ -7,7 +7,7 @@ import com.fasterxml.jackson.databind.node.ArrayNode; import com.fasterxml.jackson.databind.node.ObjectNode; -public class JacksonArr implements JsonArr { +public class JacksonArr implements Array { private ArrayNode json; @@ -26,7 +26,7 @@ public boolean isEmpty() { } @Override - public JsonObj getJsonOjb(int index) { + public Mapper getMapper(int index) { JsonNode subJson = json.get(index); if (subJson != null && subJson.isObject()) { return new JacksonObj((ObjectNode) subJson); @@ -35,7 +35,7 @@ public JsonObj getJsonOjb(int index) { } @Override - public JsonArr getJsonArr(int index) { + public Array getArray(int index) { JsonNode subJson = json.get(index); if (subJson != null && subJson.isArray()) { return new JacksonArr((ArrayNode) subJson); diff --git a/okhttps-jackson/src/main/java/com/ejlchina/okhttps/JacksonObj.java b/okhttps-jackson/src/main/java/com/ejlchina/okhttps/JacksonObj.java index f67a1d2a..1bc58905 100644 --- a/okhttps-jackson/src/main/java/com/ejlchina/okhttps/JacksonObj.java +++ b/okhttps-jackson/src/main/java/com/ejlchina/okhttps/JacksonObj.java @@ -10,7 +10,7 @@ import com.fasterxml.jackson.databind.node.ArrayNode; import com.fasterxml.jackson.databind.node.ObjectNode; -public class JacksonObj implements JsonObj { +public class JacksonObj implements Mapper { private ObjectNode json; @@ -29,7 +29,7 @@ public boolean isEmpty() { } @Override - public JsonObj getJsonOjb(String key) { + public Mapper getMapper(String key) { JsonNode subJson = json.get(key); if (subJson != null && subJson.isObject()) { return new JacksonObj((ObjectNode) subJson); @@ -38,7 +38,7 @@ public JsonObj getJsonOjb(String key) { } @Override - public JsonArr getJsonArr(String key) { + public Array getArray(String key) { JsonNode subJson = json.get(key); if (subJson != null && subJson.isArray()) { return new JacksonArr((ArrayNode) subJson); diff --git a/okhttps-jackson/src/main/java/com/ejlchina/okhttps/JacksonService.java b/okhttps-jackson/src/main/java/com/ejlchina/okhttps/JacksonService.java index 301d5a73..7b831649 100644 --- a/okhttps-jackson/src/main/java/com/ejlchina/okhttps/JacksonService.java +++ b/okhttps-jackson/src/main/java/com/ejlchina/okhttps/JacksonService.java @@ -28,7 +28,7 @@ public JacksonService(ObjectMapper objectMapper) { } @Override - public JsonObj toJsonObj(InputStream in) { + public Mapper toMapper(InputStream in) { try { JsonNode json = objectMapper.readTree(in); if (json.isObject()) { @@ -44,7 +44,7 @@ public JsonObj toJsonObj(InputStream in) { } @Override - public JsonArr toJsonArr(InputStream in) { + public Array toArray(InputStream in) { try { JsonNode json = objectMapper.readTree(in); if (json.isArray()) { @@ -60,7 +60,7 @@ public JsonArr toJsonArr(InputStream in) { } @Override - public String toJsonStr(Object bean) { + public String serialize(Object bean) { try { return objectMapper.writeValueAsString(bean); } catch (JsonProcessingException e) { @@ -69,7 +69,7 @@ public String toJsonStr(Object bean) { } @Override - public String toJsonStr(Object bean, String dateFormat) { + public String serialize(Object bean, String dateFormat) { ObjectMapper mapper = objectMapper.copy(); mapper.configure(SerializationFeature.WRITE_DATES_AS_TIMESTAMPS, false); mapper.setDateFormat(new SimpleDateFormat(dateFormat)); @@ -81,7 +81,7 @@ public String toJsonStr(Object bean, String dateFormat) { } @Override - public T jsonToBean(Class type, InputStream in) { + public T toBean(Class type, InputStream in) { try { return objectMapper.readValue(in, type); } catch (IOException e) { @@ -90,7 +90,7 @@ public T jsonToBean(Class type, InputStream in) { } @Override - public List jsonToList(Class type, InputStream in) { + public List toList(Class type, InputStream in) { CollectionType javaType = objectMapper.getTypeFactory().constructCollectionType(ArrayList.class, type); try { return objectMapper.readValue(in, javaType); diff --git a/okhttps-jackson/src/test/java/com/ejlchina/okhttps/TestCases.java b/okhttps-jackson/src/test/java/com/ejlchina/okhttps/TestCases.java index 63953de4..8d01d3ad 100644 --- a/okhttps-jackson/src/test/java/com/ejlchina/okhttps/TestCases.java +++ b/okhttps-jackson/src/test/java/com/ejlchina/okhttps/TestCases.java @@ -19,28 +19,28 @@ public class TestCases { public void testToJsonObj() { String json = "{\"id\":1,\"name\":\"Jack\"}"; InputStream in = new ByteArrayInputStream(json.getBytes()); - JsonObj jsonObj = jsonService.toJsonObj(in); - Set keys = jsonObj.keySet(); + Mapper mapper = jsonService.toMapper(in); + Set keys = mapper.keySet(); Assert.assertTrue(keys.size() == 2); Assert.assertTrue(keys.contains("id")); Assert.assertTrue(keys.contains("name")); - Assert.assertTrue(!jsonObj.isEmpty()); - Assert.assertTrue(2 == jsonObj.size()); - Assert.assertTrue(1 == jsonObj.getInt("id")); - Assert.assertTrue(!jsonObj.has("age")); - Assert.assertTrue(0 == jsonObj.getInt("age")); - Assert.assertEquals("Jack", jsonObj.getString("name")); + Assert.assertTrue(!mapper.isEmpty()); + Assert.assertTrue(2 == mapper.size()); + Assert.assertTrue(1 == mapper.getInt("id")); + Assert.assertTrue(!mapper.has("age")); + Assert.assertTrue(0 == mapper.getInt("age")); + Assert.assertEquals("Jack", mapper.getString("name")); } @Test public void testToJsonArr() { String json = "[{\"id\":1,\"name\":\"Jack\"},{\"id\":2,\"name\":\"Tom\"}]"; InputStream in = new ByteArrayInputStream(json.getBytes()); - JsonArr jsonObj = jsonService.toJsonArr(in); + Array jsonObj = jsonService.toArray(in); Assert.assertTrue(!jsonObj.isEmpty()); Assert.assertTrue(jsonObj.size() == 2); - JsonObj json1 = jsonObj.getJsonOjb(0); - JsonObj json2 = jsonObj.getJsonOjb(1); + Mapper json1 = jsonObj.getMapper(0); + Mapper json2 = jsonObj.getMapper(1); Assert.assertEquals(1, json1.getInt("id")); Assert.assertEquals("Jack", json1.getString("name")); Assert.assertEquals(2, json2.getInt("id")); @@ -49,7 +49,7 @@ public void testToJsonArr() { @Test public void testToJsonStr() { - String json = jsonService.toJsonStr(new User(1, "Jack")); + String json = jsonService.serialize(new User(1, "Jack")); Assert.assertEquals("{\"id\":1,\"name\":\"Jack\"}", json); } @@ -58,7 +58,7 @@ public void testToJsonStrWithDateFormat() throws ParseException { String dataFormat = "yyyy-MM-dd HH:mm:ss"; SimpleDateFormat sdf = new SimpleDateFormat(dataFormat); String date = "2020-05-09 12:30:15"; - String json = jsonService.toJsonStr(new DateBean(1, sdf.parse(date)), dataFormat); + String json = jsonService.serialize(new DateBean(1, sdf.parse(date)), dataFormat); Assert.assertTrue(json.contains(date)); } @@ -66,7 +66,7 @@ public void testToJsonStrWithDateFormat() throws ParseException { public void testJsonToBean() { String json = "{\"id\":1,\"name\":\"Jack\"}"; InputStream in = new ByteArrayInputStream(json.getBytes()); - User user = jsonService.jsonToBean(User.class, in); + User user = jsonService.toBean(User.class, in); Assert.assertEquals(1, user.getId()); Assert.assertEquals("Jack", user.getName()); } @@ -75,7 +75,7 @@ public void testJsonToBean() { public void testJsonToList() { String json = "[{\"id\":1,\"name\":\"Jack\"},{\"id\":2,\"name\":\"Tom\"}]"; InputStream in = new ByteArrayInputStream(json.getBytes()); - List users = jsonService.jsonToList(User.class, in); + List users = jsonService.toList(User.class, in); Assert.assertTrue(2 == users.size()); User u1 = users.get(0); User u2 = users.get(1); diff --git a/okhttps/src/main/java/com/ejlchina/okhttps/JsonArr.java b/okhttps/src/main/java/com/ejlchina/okhttps/Array.java similarity index 92% rename from okhttps/src/main/java/com/ejlchina/okhttps/JsonArr.java rename to okhttps/src/main/java/com/ejlchina/okhttps/Array.java index e9782b66..ce34e899 100644 --- a/okhttps/src/main/java/com/ejlchina/okhttps/JsonArr.java +++ b/okhttps/src/main/java/com/ejlchina/okhttps/Array.java @@ -3,7 +3,7 @@ import java.math.BigDecimal; import java.math.BigInteger; -public interface JsonArr { +public interface Array { /** * @return JSON 的键值对数量 @@ -19,13 +19,13 @@ public interface JsonArr { * @param index 元素下标 * @return 子 JsonObj */ - JsonObj getJsonOjb(int index); + Mapper getMapper(int index); /** * @param index 元素下标 * @return 子 JsonArr */ - JsonArr getJsonArr(int index); + Array getArray(int index); /** * @param index 元素下标 diff --git a/okhttps/src/main/java/com/ejlchina/okhttps/HttpResult.java b/okhttps/src/main/java/com/ejlchina/okhttps/HttpResult.java index 6a1ae528..6c1dd203 100644 --- a/okhttps/src/main/java/com/ejlchina/okhttps/HttpResult.java +++ b/okhttps/src/main/java/com/ejlchina/okhttps/HttpResult.java @@ -151,13 +151,13 @@ public interface Body { * 同一个 Body 对象的 toXXX 类方法只可使用一个并且只能调用一次 * @return 报文体转Json对象 */ - JsonObj toJsonObj(); + Mapper toJsonObj(); /** * 同一个 Body 对象的 toXXX 类方法只可使用一个并且只能调用一次 * @return 报文体转Json数组 */ - JsonArr toJsonArr(); + Array toJsonArr(); /** * 同一个 Body 对象的 toXXX 类方法只可使用一个并且只能调用一次 diff --git a/okhttps/src/main/java/com/ejlchina/okhttps/HttpTask.java b/okhttps/src/main/java/com/ejlchina/okhttps/HttpTask.java index 10a6060e..d1354408 100644 --- a/okhttps/src/main/java/com/ejlchina/okhttps/HttpTask.java +++ b/okhttps/src/main/java/com/ejlchina/okhttps/HttpTask.java @@ -421,11 +421,11 @@ public C setRequestJson(Object json, String dateFormat) { } else if (dateFormat != null) { requestJson = httpClient.getExecutor() .jsonServiceNotNull() - .toJsonStr(json, dateFormat); + .serialize(json, dateFormat); } else { requestJson = httpClient.getExecutor() .jsonServiceNotNull() - .toJsonStr(json); + .serialize(json); } } return (C) this; @@ -657,7 +657,7 @@ protected State toState(IOException e, boolean sync) { private RequestBody buildRequestBody() { if (jsonParams != null) { requestJson = httpClient.getExecutor().jsonServiceNotNull() - .toJsonStr(jsonParams); + .serialize(jsonParams); } if (files != null) { MultipartBody.Builder builder = new MultipartBody.Builder().setType(MultipartBody.FORM); diff --git a/okhttps/src/main/java/com/ejlchina/okhttps/JsonService.java b/okhttps/src/main/java/com/ejlchina/okhttps/JsonService.java index 094d60d4..43edcdb7 100644 --- a/okhttps/src/main/java/com/ejlchina/okhttps/JsonService.java +++ b/okhttps/src/main/java/com/ejlchina/okhttps/JsonService.java @@ -7,33 +7,33 @@ public interface JsonService { /** - * 解析 JsonObj + * 解析 Mapper * @param in JSON 输入流 * @return JsonObj */ - JsonObj toJsonObj(InputStream in); + Mapper toMapper(InputStream in); /** - * 解析 JsonArr + * 解析 Array * @param in JSON 输入流 * @return JsonArr */ - JsonArr toJsonArr(InputStream in); + Array toArray(InputStream in); /** - * 将 Java 对象序列化为 Json 字符串 + * 将 Java 对象序列化为字符串 * @param bean Java Bean - * @return Json 字符串 + * @return 字符串 */ - String toJsonStr(Object bean); + String serialize(Object bean); /** - * 将 Java 对象序列化为 Json 字符串 + * 将 Java 对象序列化为字符串 * @param bean Java Bean * @param dateFormat 日期类的处理格式 - * @return Json 字符串 + * @return 字符串 */ - String toJsonStr(Object bean, String dateFormat); + String serialize(Object bean, String dateFormat); /** * 解析 Java Bean @@ -42,7 +42,7 @@ public interface JsonService { * @param in JSON 输入流 * @return Java Bean */ - T jsonToBean(Class type, InputStream in); + T toBean(Class type, InputStream in); /** * 解析为 Java List @@ -51,7 +51,7 @@ public interface JsonService { * @param in JSON 输入流 * @return Java List */ - List jsonToList(Class type, InputStream in); + List toList(Class type, InputStream in); } diff --git a/okhttps/src/main/java/com/ejlchina/okhttps/JsonObj.java b/okhttps/src/main/java/com/ejlchina/okhttps/Mapper.java similarity index 89% rename from okhttps/src/main/java/com/ejlchina/okhttps/JsonObj.java rename to okhttps/src/main/java/com/ejlchina/okhttps/Mapper.java index 5a8cd48a..e5f9ec80 100644 --- a/okhttps/src/main/java/com/ejlchina/okhttps/JsonObj.java +++ b/okhttps/src/main/java/com/ejlchina/okhttps/Mapper.java @@ -9,12 +9,12 @@ * @author 15735 * */ -public interface JsonObj { +public interface Mapper { /** * @return JSON 的键值对数量 */ - public int size(); + int size(); /** * @return 是否为空 @@ -25,13 +25,13 @@ public interface JsonObj { * @param key 键名 * @return 子 JsonObj */ - JsonObj getJsonOjb(String key); + Mapper getMapper(String key); /** * @param key 键名 * @return 子 JsonArr */ - JsonArr getJsonArr(String key); + Array getArray(String key); /** * @param key 键名 @@ -90,6 +90,6 @@ public interface JsonObj { /** * @return JSON 的键集合 */ - public Set keySet(); + Set keySet(); } diff --git a/okhttps/src/main/java/com/ejlchina/okhttps/WebSocket.java b/okhttps/src/main/java/com/ejlchina/okhttps/WebSocket.java index fad33e60..7b05ddaf 100644 --- a/okhttps/src/main/java/com/ejlchina/okhttps/WebSocket.java +++ b/okhttps/src/main/java/com/ejlchina/okhttps/WebSocket.java @@ -45,12 +45,12 @@ public interface Message { /** * @return 消息体转Json对象 */ - JsonObj toJsonObj(); + Mapper toJsonObj(); /** * @return 消息体转Json数组 */ - JsonArr toJsonArr(); + Array toJsonArr(); /** * @param 目标泛型 diff --git a/okhttps/src/main/java/com/ejlchina/okhttps/internal/AbstractBody.java b/okhttps/src/main/java/com/ejlchina/okhttps/internal/AbstractBody.java index d3a0a78e..8c8ab239 100644 --- a/okhttps/src/main/java/com/ejlchina/okhttps/internal/AbstractBody.java +++ b/okhttps/src/main/java/com/ejlchina/okhttps/internal/AbstractBody.java @@ -3,8 +3,8 @@ import java.io.InputStream; import java.util.List; -import com.ejlchina.okhttps.JsonArr; -import com.ejlchina.okhttps.JsonObj; +import com.ejlchina.okhttps.Array; +import com.ejlchina.okhttps.Mapper; public abstract class AbstractBody { @@ -19,19 +19,19 @@ public AbstractBody(TaskExecutor taskExecutor) { public abstract InputStream toByteStream(); - public JsonObj toJsonObj() { + public Mapper toJsonObj() { if (taskExecutor == null) { throw new IllegalStateException("没有 taskExecutor，不可做 Json 转换！"); } - return taskExecutor.jsonServiceNotNull().toJsonObj(toByteStream()); + return taskExecutor.jsonServiceNotNull().toMapper(toByteStream()); } - public JsonArr toJsonArr() { + public Array toJsonArr() { if (taskExecutor == null) { throw new IllegalStateException("没有 taskExecutor，不可做 Json 转换！"); } - return taskExecutor.jsonServiceNotNull().toJsonArr(toByteStream()); + return taskExecutor.jsonServiceNotNull().toArray(toByteStream()); } @@ -39,7 +39,7 @@ public T toBean(Class type) { if (taskExecutor == null) { throw new IllegalStateException("没有 taskExecutor，不可做 Json 转换！"); } - return taskExecutor.jsonServiceNotNull().jsonToBean(type, toByteStream()); + return taskExecutor.jsonServiceNotNull().toBean(type, toByteStream()); } @@ -47,7 +47,7 @@ public List toList(Class type) { if (taskExecutor == null) { throw new IllegalStateException("没有 taskExecutor，不可做 Json 转换！"); } - return taskExecutor.jsonServiceNotNull().jsonToList(type, toByteStream()); + return taskExecutor.jsonServiceNotNull().toList(type, toByteStream()); } } diff --git a/okhttps/src/main/java/com/ejlchina/okhttps/internal/WebSocketTask.java b/okhttps/src/main/java/com/ejlchina/okhttps/internal/WebSocketTask.java index c4a31090..1eab9f2f 100644 --- a/okhttps/src/main/java/com/ejlchina/okhttps/internal/WebSocketTask.java +++ b/okhttps/src/main/java/com/ejlchina/okhttps/internal/WebSocketTask.java @@ -170,12 +170,12 @@ public boolean send(ByteString bytes) { @Override public boolean send(Object bean) { - return send(taskExecutor.jsonServiceNotNull().toJsonStr(bean)); + return send(taskExecutor.jsonServiceNotNull().serialize(bean)); } @Override public boolean send(Object bean, String dateFormat) { - return send(taskExecutor.jsonServiceNotNull().toJsonStr(bean, dateFormat)); + return send(taskExecutor.jsonServiceNotNull().serialize(bean, dateFormat)); } @Override @@ -226,7 +226,7 @@ boolean send(okhttp3.WebSocket webSocket, Object msg) { if (msg instanceof byte[]) { return webSocket.send(ByteString.of((byte[]) msg)); } - return webSocket.send(taskExecutor.jsonServiceNotNull().toJsonStr(msg)); + return webSocket.send(taskExecutor.jsonServiceNotNull().serialize(msg)); } } diff --git a/okhttps/src/test/java/com/ejlchina/test/SimpleTests.java b/okhttps/src/test/java/com/ejlchina/test/SimpleTests.java index b9e9144e..019aaf2f 100644 --- a/okhttps/src/test/java/com/ejlchina/test/SimpleTests.java +++ b/okhttps/src/test/java/com/ejlchina/test/SimpleTests.java @@ -2,10 +2,7 @@ import com.ejlchina.okhttps.HTTP; -import com.ejlchina.okhttps.JsonObj; -import okhttp3.mockwebserver.MockResponse; import okhttp3.mockwebserver.MockWebServer; -import org.junit.Test; public class SimpleTests extends BaseTest { From 713074068eb1eabef9c4ac537bea50cd568bb698 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?=E5=91=A8=E6=97=AD?= Date: Mon, 11 May 2020 09:42:35 +0800 Subject: [PATCH 249/924] =?UTF-8?q?=E9=87=8D=E6=9E=84?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- .../java/com/ejlchina/okhttps/HttpResult.java | 8 ++++---- .../java/com/ejlchina/okhttps/WebSocket.java | 16 ++++++++-------- .../ejlchina/okhttps/internal/AbstractBody.java | 4 ++-- .../test/java/com/ejlchina/test/CacheTests.java | 4 ++-- 4 files changed, 16 insertions(+), 16 deletions(-) diff --git a/okhttps/src/main/java/com/ejlchina/okhttps/HttpResult.java b/okhttps/src/main/java/com/ejlchina/okhttps/HttpResult.java index 6c1dd203..74edfb21 100644 --- a/okhttps/src/main/java/com/ejlchina/okhttps/HttpResult.java +++ b/okhttps/src/main/java/com/ejlchina/okhttps/HttpResult.java @@ -44,7 +44,7 @@ static HttpResult of(Response response, TaskExecutor taskExecutor) { } - public enum State { + enum State { /** * 执行异常 @@ -76,7 +76,7 @@ public enum State { /** * HTTP响应报文体 */ - public interface Body { + interface Body { /** * @return 媒体类型 @@ -151,13 +151,13 @@ public interface Body { * 同一个 Body 对象的 toXXX 类方法只可使用一个并且只能调用一次 * @return 报文体转Json对象 */ - Mapper toJsonObj(); + Mapper toMapper(); /** * 同一个 Body 对象的 toXXX 类方法只可使用一个并且只能调用一次 * @return 报文体转Json数组 */ - Array toJsonArr(); + Array toArray(); /** * 同一个 Body 对象的 toXXX 类方法只可使用一个并且只能调用一次 diff --git a/okhttps/src/main/java/com/ejlchina/okhttps/WebSocket.java b/okhttps/src/main/java/com/ejlchina/okhttps/WebSocket.java index 7b05ddaf..bdd16b3c 100644 --- a/okhttps/src/main/java/com/ejlchina/okhttps/WebSocket.java +++ b/okhttps/src/main/java/com/ejlchina/okhttps/WebSocket.java @@ -9,7 +9,7 @@ public interface WebSocket extends Cancelable { - public interface Message { + interface Message { /** * 判断是文本消息还是二进制消息 @@ -45,12 +45,12 @@ public interface Message { /** * @return 消息体转Json对象 */ - Mapper toJsonObj(); + Mapper toMapper(); /** * @return 消息体转Json数组 */ - Array toJsonArr(); + Array toArray(); /** * @param 目标泛型 @@ -69,7 +69,7 @@ public interface Message { } - public static class Close { + class Close { private int code; private String reason; @@ -102,7 +102,7 @@ public String toString() { } - public interface Listener { + interface Listener { void on(WebSocket ws, T data); @@ -135,7 +135,7 @@ public interface Listener { * @param bean 待发送的对象 * @return 如果连接已断开 返回 false */ - public boolean send(Object bean); + boolean send(Object bean); /** * 以JSON文本格式发送对象消息 @@ -143,14 +143,14 @@ public interface Listener { * @param dateFormat 日期类型字段的处理格式 * @return 如果连接已断开 返回 false */ - public boolean send(Object bean, String dateFormat); + boolean send(Object bean, String dateFormat); /** * 发送字节流 * @param data 待发送的数据 * @return 如果连接已断开 返回 false */ - public boolean send(byte[] data); + boolean send(byte[] data); /** * 同 {@link okhttp3.WebSocket#close(int, String)} diff --git a/okhttps/src/main/java/com/ejlchina/okhttps/internal/AbstractBody.java b/okhttps/src/main/java/com/ejlchina/okhttps/internal/AbstractBody.java index 8c8ab239..82378892 100644 --- a/okhttps/src/main/java/com/ejlchina/okhttps/internal/AbstractBody.java +++ b/okhttps/src/main/java/com/ejlchina/okhttps/internal/AbstractBody.java @@ -19,7 +19,7 @@ public AbstractBody(TaskExecutor taskExecutor) { public abstract InputStream toByteStream(); - public Mapper toJsonObj() { + public Mapper toMapper() { if (taskExecutor == null) { throw new IllegalStateException("没有 taskExecutor，不可做 Json 转换！"); } @@ -27,7 +27,7 @@ public Mapper toJsonObj() { } - public Array toJsonArr() { + public Array toArray() { if (taskExecutor == null) { throw new IllegalStateException("没有 taskExecutor，不可做 Json 转换！"); } diff --git a/okhttps/src/test/java/com/ejlchina/test/CacheTests.java b/okhttps/src/test/java/com/ejlchina/test/CacheTests.java index 962eebb8..add97d87 100644 --- a/okhttps/src/test/java/com/ejlchina/test/CacheTests.java +++ b/okhttps/src/test/java/com/ejlchina/test/CacheTests.java @@ -16,12 +16,12 @@ public void testCache() { .cache(); println("result = " + body.toString()); - println("result = " + body.toJsonArr()); + println("result = " + body.toArray()); body.close(); println("result = " + body.toString()); - println("result = " + body.toJsonArr()); + println("result = " + body.toArray()); } } From fd81805a41a8bc03a8e98fd32863aa616259591f Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?=E5=91=A8=E6=97=AD?= Date: Mon, 11 May 2020 09:47:44 +0800 Subject: [PATCH 250/924] =?UTF-8?q?=E9=87=8D=E6=9E=84?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- .../com/ejlchina/okhttps/{GsonArr.java => GsonArray.java} | 8 ++++---- .../ejlchina/okhttps/{GsonObj.java => GsonMapper.java} | 8 ++++---- .../src/main/java/com/ejlchina/okhttps/GsonService.java | 4 ++-- .../okhttps/{JacksonArr.java => JacksonArray.java} | 8 ++++---- .../okhttps/{JacksonObj.java => JacksonMapper.java} | 8 ++++---- .../main/java/com/ejlchina/okhttps/JacksonService.java | 4 ++-- 6 files changed, 20 insertions(+), 20 deletions(-) rename okhttps-gson/src/main/java/com/ejlchina/okhttps/{GsonArr.java => GsonArray.java} (91%) rename okhttps-gson/src/main/java/com/ejlchina/okhttps/{GsonObj.java => GsonMapper.java} (91%) rename okhttps-jackson/src/main/java/com/ejlchina/okhttps/{JacksonArr.java => JacksonArray.java} (92%) rename okhttps-jackson/src/main/java/com/ejlchina/okhttps/{JacksonObj.java => JacksonMapper.java} (93%) diff --git a/okhttps-gson/src/main/java/com/ejlchina/okhttps/GsonArr.java b/okhttps-gson/src/main/java/com/ejlchina/okhttps/GsonArray.java similarity index 91% rename from okhttps-gson/src/main/java/com/ejlchina/okhttps/GsonArr.java rename to okhttps-gson/src/main/java/com/ejlchina/okhttps/GsonArray.java index 52c6dc98..3208b56a 100644 --- a/okhttps-gson/src/main/java/com/ejlchina/okhttps/GsonArr.java +++ b/okhttps-gson/src/main/java/com/ejlchina/okhttps/GsonArray.java @@ -6,11 +6,11 @@ import com.google.gson.JsonArray; import com.google.gson.JsonElement; -public class GsonArr implements Array { +public class GsonArray implements Array { private JsonArray json; - public GsonArr(JsonArray json) { + public GsonArray(JsonArray json) { this.json = json; } @@ -28,7 +28,7 @@ public boolean isEmpty() { public Mapper getMapper(int index) { JsonElement subJson = json.get(index); if (subJson != null) { - return new GsonObj(subJson.getAsJsonObject()); + return new GsonMapper(subJson.getAsJsonObject()); } return null; } @@ -37,7 +37,7 @@ public Mapper getMapper(int index) { public Array getArray(int index) { JsonElement subJson = json.get(index); if (subJson != null) { - return new GsonArr(subJson.getAsJsonArray()); + return new GsonArray(subJson.getAsJsonArray()); } return null; } diff --git a/okhttps-gson/src/main/java/com/ejlchina/okhttps/GsonObj.java b/okhttps-gson/src/main/java/com/ejlchina/okhttps/GsonMapper.java similarity index 91% rename from okhttps-gson/src/main/java/com/ejlchina/okhttps/GsonObj.java rename to okhttps-gson/src/main/java/com/ejlchina/okhttps/GsonMapper.java index fb2fa2f4..2b52c9f4 100644 --- a/okhttps-gson/src/main/java/com/ejlchina/okhttps/GsonObj.java +++ b/okhttps-gson/src/main/java/com/ejlchina/okhttps/GsonMapper.java @@ -7,11 +7,11 @@ import com.google.gson.JsonElement; import com.google.gson.JsonObject; -public class GsonObj implements Mapper { +public class GsonMapper implements Mapper { private JsonObject json; - public GsonObj(JsonObject json) { + public GsonMapper(JsonObject json) { this.json = json; } @@ -29,7 +29,7 @@ public boolean isEmpty() { public Mapper getMapper(String key) { JsonElement subJson = json.get(key); if (subJson != null) { - return new GsonObj(subJson.getAsJsonObject()); + return new GsonMapper(subJson.getAsJsonObject()); } return null; } @@ -38,7 +38,7 @@ public Mapper getMapper(String key) { public Array getArray(String key) { JsonElement subJson = json.get(key); if (subJson != null) { - return new GsonArr(subJson.getAsJsonArray()); + return new GsonArray(subJson.getAsJsonArray()); } return null; } diff --git a/okhttps-gson/src/main/java/com/ejlchina/okhttps/GsonService.java b/okhttps-gson/src/main/java/com/ejlchina/okhttps/GsonService.java index ead466a4..b8501bb6 100644 --- a/okhttps-gson/src/main/java/com/ejlchina/okhttps/GsonService.java +++ b/okhttps-gson/src/main/java/com/ejlchina/okhttps/GsonService.java @@ -25,12 +25,12 @@ public GsonService(Gson gson) { @Override public Mapper toMapper(InputStream in) { - return new GsonObj(gson.fromJson(new InputStreamReader(in), JsonObject.class)); + return new GsonMapper(gson.fromJson(new InputStreamReader(in), JsonObject.class)); } @Override public Array toArray(InputStream in) { - return new GsonArr(gson.fromJson(new InputStreamReader(in), JsonArray.class)); + return new GsonArray(gson.fromJson(new InputStreamReader(in), JsonArray.class)); } @Override diff --git a/okhttps-jackson/src/main/java/com/ejlchina/okhttps/JacksonArr.java b/okhttps-jackson/src/main/java/com/ejlchina/okhttps/JacksonArray.java similarity index 92% rename from okhttps-jackson/src/main/java/com/ejlchina/okhttps/JacksonArr.java rename to okhttps-jackson/src/main/java/com/ejlchina/okhttps/JacksonArray.java index b5ba9bd2..a0c5e69e 100644 --- a/okhttps-jackson/src/main/java/com/ejlchina/okhttps/JacksonArr.java +++ b/okhttps-jackson/src/main/java/com/ejlchina/okhttps/JacksonArray.java @@ -7,11 +7,11 @@ import com.fasterxml.jackson.databind.node.ArrayNode; import com.fasterxml.jackson.databind.node.ObjectNode; -public class JacksonArr implements Array { +public class JacksonArray implements Array { private ArrayNode json; - public JacksonArr(ArrayNode json) { + public JacksonArray(ArrayNode json) { this.json = json; } @@ -29,7 +29,7 @@ public boolean isEmpty() { public Mapper getMapper(int index) { JsonNode subJson = json.get(index); if (subJson != null && subJson.isObject()) { - return new JacksonObj((ObjectNode) subJson); + return new JacksonMapper((ObjectNode) subJson); } return null; } @@ -38,7 +38,7 @@ public Mapper getMapper(int index) { public Array getArray(int index) { JsonNode subJson = json.get(index); if (subJson != null && subJson.isArray()) { - return new JacksonArr((ArrayNode) subJson); + return new JacksonArray((ArrayNode) subJson); } return null; } diff --git a/okhttps-jackson/src/main/java/com/ejlchina/okhttps/JacksonObj.java b/okhttps-jackson/src/main/java/com/ejlchina/okhttps/JacksonMapper.java similarity index 93% rename from okhttps-jackson/src/main/java/com/ejlchina/okhttps/JacksonObj.java rename to okhttps-jackson/src/main/java/com/ejlchina/okhttps/JacksonMapper.java index 1bc58905..9e81fa4d 100644 --- a/okhttps-jackson/src/main/java/com/ejlchina/okhttps/JacksonObj.java +++ b/okhttps-jackson/src/main/java/com/ejlchina/okhttps/JacksonMapper.java @@ -10,11 +10,11 @@ import com.fasterxml.jackson.databind.node.ArrayNode; import com.fasterxml.jackson.databind.node.ObjectNode; -public class JacksonObj implements Mapper { +public class JacksonMapper implements Mapper { private ObjectNode json; - public JacksonObj(ObjectNode json) { + public JacksonMapper(ObjectNode json) { this.json = json; } @@ -32,7 +32,7 @@ public boolean isEmpty() { public Mapper getMapper(String key) { JsonNode subJson = json.get(key); if (subJson != null && subJson.isObject()) { - return new JacksonObj((ObjectNode) subJson); + return new JacksonMapper((ObjectNode) subJson); } return null; } @@ -41,7 +41,7 @@ public Mapper getMapper(String key) { public Array getArray(String key) { JsonNode subJson = json.get(key); if (subJson != null && subJson.isArray()) { - return new JacksonArr((ArrayNode) subJson); + return new JacksonArray((ArrayNode) subJson); } return null; } diff --git a/okhttps-jackson/src/main/java/com/ejlchina/okhttps/JacksonService.java b/okhttps-jackson/src/main/java/com/ejlchina/okhttps/JacksonService.java index 7b831649..d3c71519 100644 --- a/okhttps-jackson/src/main/java/com/ejlchina/okhttps/JacksonService.java +++ b/okhttps-jackson/src/main/java/com/ejlchina/okhttps/JacksonService.java @@ -32,7 +32,7 @@ public Mapper toMapper(InputStream in) { try { JsonNode json = objectMapper.readTree(in); if (json.isObject()) { - return new JacksonObj((ObjectNode) json); + return new JacksonMapper((ObjectNode) json); } if (json.isNull() || json.isMissingNode()) { return null; @@ -48,7 +48,7 @@ public Array toArray(InputStream in) { try { JsonNode json = objectMapper.readTree(in); if (json.isArray()) { - return new JacksonArr((ArrayNode) json); + return new JacksonArray((ArrayNode) json); } if (json.isNull() || json.isMissingNode()) { return null; From 13d6cf716c65991c2bfa7c5cfb21c7141b85ab64 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?=E5=91=A8=E6=97=AD?= Date: Mon, 11 May 2020 10:00:54 +0800 Subject: [PATCH 251/924] =?UTF-8?q?=E9=87=8D=E6=9E=84?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- .../ejlchina/okhttps/FastJsonAutoConfig.java | 4 ++-- ...nService.java => FastjsonMsgConvertor.java} | 6 +++--- .../java/com/ejlchina/okhttps/TestCases.java | 14 +++++++------- .../com/ejlchina/okhttps/GsonAutoConfig.java | 4 ++-- ...{GsonService.java => GsonMsgConvertor.java} | 6 +++--- .../java/com/ejlchina/okhttps/TestCases.java | 14 +++++++------- .../ejlchina/okhttps/JacksonAutoConfig.java | 4 ++-- ...onService.java => JacksonMsgConvertor.java} | 6 +++--- .../java/com/ejlchina/okhttps/TestCases.java | 14 +++++++------- .../main/java/com/ejlchina/okhttps/HTTP.java | 16 ++++++++-------- .../java/com/ejlchina/okhttps/HttpUtils.java | 8 ++++---- .../{JsonService.java => MsgConvertor.java} | 9 +++++---- .../ejlchina/okhttps/internal/HttpClient.java | 2 +- .../okhttps/internal/TaskExecutor.java | 18 +++++++++--------- 14 files changed, 63 insertions(+), 62 deletions(-) rename okhttps-fastjson/src/main/java/com/ejlchina/okhttps/{FastJsonService.java => FastjsonMsgConvertor.java} (90%) rename okhttps-gson/src/main/java/com/ejlchina/okhttps/{GsonService.java => GsonMsgConvertor.java} (91%) rename okhttps-jackson/src/main/java/com/ejlchina/okhttps/{JacksonService.java => JacksonMsgConvertor.java} (95%) rename okhttps/src/main/java/com/ejlchina/okhttps/{JsonService.java => MsgConvertor.java} (94%) diff --git a/okhttps-fastjson/src/main/java/com/ejlchina/okhttps/FastJsonAutoConfig.java b/okhttps-fastjson/src/main/java/com/ejlchina/okhttps/FastJsonAutoConfig.java index 52ab16fa..e29139bc 100644 --- a/okhttps-fastjson/src/main/java/com/ejlchina/okhttps/FastJsonAutoConfig.java +++ b/okhttps-fastjson/src/main/java/com/ejlchina/okhttps/FastJsonAutoConfig.java @@ -4,8 +4,8 @@ public class FastJsonAutoConfig implements OkHttps.Config { @Override public void withConfig(HTTP.Builder builder) { - if (builder.getJsonService() == null) { - builder.jsonService(new FastJsonService()); + if (builder.getMsgConvertor() == null) { + builder.msgConvertor(new FastjsonMsgConvertor()); } } diff --git a/okhttps-fastjson/src/main/java/com/ejlchina/okhttps/FastJsonService.java b/okhttps-fastjson/src/main/java/com/ejlchina/okhttps/FastjsonMsgConvertor.java similarity index 90% rename from okhttps-fastjson/src/main/java/com/ejlchina/okhttps/FastJsonService.java rename to okhttps-fastjson/src/main/java/com/ejlchina/okhttps/FastjsonMsgConvertor.java index 4093be9d..a43b7288 100644 --- a/okhttps-fastjson/src/main/java/com/ejlchina/okhttps/FastJsonService.java +++ b/okhttps-fastjson/src/main/java/com/ejlchina/okhttps/FastjsonMsgConvertor.java @@ -11,15 +11,15 @@ import okio.Okio; -public class FastJsonService implements JsonService { +public class FastjsonMsgConvertor implements MsgConvertor { private Charset charset; - public FastJsonService() { + public FastjsonMsgConvertor() { this(StandardCharsets.UTF_8); } - public FastJsonService(Charset charset) { + public FastjsonMsgConvertor(Charset charset) { this.charset = charset; } diff --git a/okhttps-fastjson/src/test/java/com/ejlchina/okhttps/TestCases.java b/okhttps-fastjson/src/test/java/com/ejlchina/okhttps/TestCases.java index 1acb99a8..0006da0a 100644 --- a/okhttps-fastjson/src/test/java/com/ejlchina/okhttps/TestCases.java +++ b/okhttps-fastjson/src/test/java/com/ejlchina/okhttps/TestCases.java @@ -13,13 +13,13 @@ public class TestCases { - JsonService jsonService = new FastJsonService(); + MsgConvertor msgConvertor = new FastjsonMsgConvertor(); @Test public void testToJsonObj() { String json = "{\"id\":1,\"name\":\"Jack\"}"; InputStream in = new ByteArrayInputStream(json.getBytes()); - Mapper mapper = jsonService.toMapper(in); + Mapper mapper = msgConvertor.toMapper(in); Set keys = mapper.keySet(); Assert.assertTrue(keys.size() == 2); Assert.assertTrue(keys.contains("id")); @@ -36,7 +36,7 @@ public void testToJsonObj() { public void testToJsonArr() { String json = "[{\"id\":1,\"name\":\"Jack\"},{\"id\":2,\"name\":\"Tom\"}]"; InputStream in = new ByteArrayInputStream(json.getBytes()); - Array jsonObj = jsonService.toArray(in); + Array jsonObj = msgConvertor.toArray(in); Assert.assertTrue(!jsonObj.isEmpty()); Assert.assertTrue(jsonObj.size() == 2); Mapper json1 = jsonObj.getMapper(0); @@ -49,7 +49,7 @@ public void testToJsonArr() { @Test public void testToJsonStr() { - String json = jsonService.serialize(new User(1, "Jack")); + String json = msgConvertor.serialize(new User(1, "Jack")); Assert.assertEquals("{\"id\":1,\"name\":\"Jack\"}", json); } @@ -58,7 +58,7 @@ public void testToJsonStrWithDateFormat() throws ParseException { String dataFormat = "yyyy-MM-dd HH:mm:ss"; SimpleDateFormat sdf = new SimpleDateFormat(dataFormat); String date = "2020-05-09 12:30:15"; - String json = jsonService.serialize(new DateBean(1, sdf.parse(date)), dataFormat); + String json = msgConvertor.serialize(new DateBean(1, sdf.parse(date)), dataFormat); Assert.assertTrue(json.contains(date)); } @@ -66,7 +66,7 @@ public void testToJsonStrWithDateFormat() throws ParseException { public void testJsonToBean() { String json = "{\"id\":1,\"name\":\"Jack\"}"; InputStream in = new ByteArrayInputStream(json.getBytes()); - User user = jsonService.toBean(User.class, in); + User user = msgConvertor.toBean(User.class, in); Assert.assertEquals(1, user.getId()); Assert.assertEquals("Jack", user.getName()); } @@ -75,7 +75,7 @@ public void testJsonToBean() { public void testJsonToList() { String json = "[{\"id\":1,\"name\":\"Jack\"},{\"id\":2,\"name\":\"Tom\"}]"; InputStream in = new ByteArrayInputStream(json.getBytes()); - List users = jsonService.toList(User.class, in); + List users = msgConvertor.toList(User.class, in); Assert.assertTrue(2 == users.size()); User u1 = users.get(0); User u2 = users.get(1); diff --git a/okhttps-gson/src/main/java/com/ejlchina/okhttps/GsonAutoConfig.java b/okhttps-gson/src/main/java/com/ejlchina/okhttps/GsonAutoConfig.java index 1695741b..670103f2 100644 --- a/okhttps-gson/src/main/java/com/ejlchina/okhttps/GsonAutoConfig.java +++ b/okhttps-gson/src/main/java/com/ejlchina/okhttps/GsonAutoConfig.java @@ -4,8 +4,8 @@ public class GsonAutoConfig implements OkHttps.Config { @Override public void withConfig(HTTP.Builder builder) { - if (builder.getJsonService() == null) { - builder.jsonService(new GsonService()); + if (builder.getMsgConvertor() == null) { + builder.msgConvertor(new GsonMsgConvertor()); } } diff --git a/okhttps-gson/src/main/java/com/ejlchina/okhttps/GsonService.java b/okhttps-gson/src/main/java/com/ejlchina/okhttps/GsonMsgConvertor.java similarity index 91% rename from okhttps-gson/src/main/java/com/ejlchina/okhttps/GsonService.java rename to okhttps-gson/src/main/java/com/ejlchina/okhttps/GsonMsgConvertor.java index b8501bb6..770c886d 100644 --- a/okhttps-gson/src/main/java/com/ejlchina/okhttps/GsonService.java +++ b/okhttps-gson/src/main/java/com/ejlchina/okhttps/GsonMsgConvertor.java @@ -11,15 +11,15 @@ import com.google.gson.JsonObject; import com.google.gson.reflect.TypeToken; -public class GsonService implements JsonService { +public class GsonMsgConvertor implements MsgConvertor { private Gson gson; - public GsonService() { + public GsonMsgConvertor() { this(new Gson()); } - public GsonService(Gson gson) { + public GsonMsgConvertor(Gson gson) { this.gson = gson; } diff --git a/okhttps-gson/src/test/java/com/ejlchina/okhttps/TestCases.java b/okhttps-gson/src/test/java/com/ejlchina/okhttps/TestCases.java index ce9603f7..f87aeb66 100644 --- a/okhttps-gson/src/test/java/com/ejlchina/okhttps/TestCases.java +++ b/okhttps-gson/src/test/java/com/ejlchina/okhttps/TestCases.java @@ -13,13 +13,13 @@ public class TestCases { - JsonService jsonService = new GsonService(); + MsgConvertor msgConvertor = new GsonMsgConvertor(); @Test public void testToJsonObj() { String json = "{\"id\":1,\"name\":\"Jack\"}"; InputStream in = new ByteArrayInputStream(json.getBytes()); - Mapper mapper = jsonService.toMapper(in); + Mapper mapper = msgConvertor.toMapper(in); Set keys = mapper.keySet(); Assert.assertTrue(keys.size() == 2); Assert.assertTrue(keys.contains("id")); @@ -36,7 +36,7 @@ public void testToJsonObj() { public void testToJsonArr() { String json = "[{\"id\":1,\"name\":\"Jack\"},{\"id\":2,\"name\":\"Tom\"}]"; InputStream in = new ByteArrayInputStream(json.getBytes()); - Array jsonObj = jsonService.toArray(in); + Array jsonObj = msgConvertor.toArray(in); Assert.assertTrue(!jsonObj.isEmpty()); Assert.assertTrue(jsonObj.size() == 2); Mapper json1 = jsonObj.getMapper(0); @@ -49,7 +49,7 @@ public void testToJsonArr() { @Test public void testToJsonStr() { - String json = jsonService.serialize(new User(1, "Jack")); + String json = msgConvertor.serialize(new User(1, "Jack")); Assert.assertEquals("{\"id\":1,\"name\":\"Jack\"}", json); } @@ -58,7 +58,7 @@ public void testToJsonStrWithDateFormat() throws ParseException { String dataFormat = "yyyy-MM-dd HH:mm:ss"; SimpleDateFormat sdf = new SimpleDateFormat(dataFormat); String date = "2020-05-09 12:30:15"; - String json = jsonService.serialize(new DateBean(1, sdf.parse(date)), dataFormat); + String json = msgConvertor.serialize(new DateBean(1, sdf.parse(date)), dataFormat); Assert.assertTrue(json.contains(date)); } @@ -66,7 +66,7 @@ public void testToJsonStrWithDateFormat() throws ParseException { public void testJsonToBean() { String json = "{\"id\":1,\"name\":\"Jack\"}"; InputStream in = new ByteArrayInputStream(json.getBytes()); - User user = jsonService.toBean(User.class, in); + User user = msgConvertor.toBean(User.class, in); Assert.assertEquals(1, user.getId()); Assert.assertEquals("Jack", user.getName()); } @@ -75,7 +75,7 @@ public void testJsonToBean() { public void testJsonToList() { String json = "[{\"id\":1,\"name\":\"Jack\"},{\"id\":2,\"name\":\"Tom\"}]"; InputStream in = new ByteArrayInputStream(json.getBytes()); - List users = jsonService.toList(User.class, in); + List users = msgConvertor.toList(User.class, in); Assert.assertTrue(2 == users.size()); User u1 = users.get(0); User u2 = users.get(1); diff --git a/okhttps-jackson/src/main/java/com/ejlchina/okhttps/JacksonAutoConfig.java b/okhttps-jackson/src/main/java/com/ejlchina/okhttps/JacksonAutoConfig.java index 7e7a3a0c..d8413273 100644 --- a/okhttps-jackson/src/main/java/com/ejlchina/okhttps/JacksonAutoConfig.java +++ b/okhttps-jackson/src/main/java/com/ejlchina/okhttps/JacksonAutoConfig.java @@ -4,8 +4,8 @@ public class JacksonAutoConfig implements OkHttps.Config { @Override public void withConfig(HTTP.Builder builder) { - if (builder.getJsonService() == null) { - builder.jsonService(new JacksonService()); + if (builder.getMsgConvertor() == null) { + builder.msgConvertor(new JacksonMsgConvertor()); } } diff --git a/okhttps-jackson/src/main/java/com/ejlchina/okhttps/JacksonService.java b/okhttps-jackson/src/main/java/com/ejlchina/okhttps/JacksonMsgConvertor.java similarity index 95% rename from okhttps-jackson/src/main/java/com/ejlchina/okhttps/JacksonService.java rename to okhttps-jackson/src/main/java/com/ejlchina/okhttps/JacksonMsgConvertor.java index d3c71519..25d896c0 100644 --- a/okhttps-jackson/src/main/java/com/ejlchina/okhttps/JacksonService.java +++ b/okhttps-jackson/src/main/java/com/ejlchina/okhttps/JacksonMsgConvertor.java @@ -15,15 +15,15 @@ import com.fasterxml.jackson.databind.node.ObjectNode; import com.fasterxml.jackson.databind.type.CollectionType; -public class JacksonService implements JsonService { +public class JacksonMsgConvertor implements MsgConvertor { private ObjectMapper objectMapper; - public JacksonService() { + public JacksonMsgConvertor() { this(new ObjectMapper()); } - public JacksonService(ObjectMapper objectMapper) { + public JacksonMsgConvertor(ObjectMapper objectMapper) { this.objectMapper = objectMapper; } diff --git a/okhttps-jackson/src/test/java/com/ejlchina/okhttps/TestCases.java b/okhttps-jackson/src/test/java/com/ejlchina/okhttps/TestCases.java index 8d01d3ad..c7b8ec3b 100644 --- a/okhttps-jackson/src/test/java/com/ejlchina/okhttps/TestCases.java +++ b/okhttps-jackson/src/test/java/com/ejlchina/okhttps/TestCases.java @@ -13,13 +13,13 @@ public class TestCases { - JsonService jsonService = new JacksonService(); + MsgConvertor msgConvertor = new JacksonMsgConvertor(); @Test public void testToJsonObj() { String json = "{\"id\":1,\"name\":\"Jack\"}"; InputStream in = new ByteArrayInputStream(json.getBytes()); - Mapper mapper = jsonService.toMapper(in); + Mapper mapper = msgConvertor.toMapper(in); Set keys = mapper.keySet(); Assert.assertTrue(keys.size() == 2); Assert.assertTrue(keys.contains("id")); @@ -36,7 +36,7 @@ public void testToJsonObj() { public void testToJsonArr() { String json = "[{\"id\":1,\"name\":\"Jack\"},{\"id\":2,\"name\":\"Tom\"}]"; InputStream in = new ByteArrayInputStream(json.getBytes()); - Array jsonObj = jsonService.toArray(in); + Array jsonObj = msgConvertor.toArray(in); Assert.assertTrue(!jsonObj.isEmpty()); Assert.assertTrue(jsonObj.size() == 2); Mapper json1 = jsonObj.getMapper(0); @@ -49,7 +49,7 @@ public void testToJsonArr() { @Test public void testToJsonStr() { - String json = jsonService.serialize(new User(1, "Jack")); + String json = msgConvertor.serialize(new User(1, "Jack")); Assert.assertEquals("{\"id\":1,\"name\":\"Jack\"}", json); } @@ -58,7 +58,7 @@ public void testToJsonStrWithDateFormat() throws ParseException { String dataFormat = "yyyy-MM-dd HH:mm:ss"; SimpleDateFormat sdf = new SimpleDateFormat(dataFormat); String date = "2020-05-09 12:30:15"; - String json = jsonService.serialize(new DateBean(1, sdf.parse(date)), dataFormat); + String json = msgConvertor.serialize(new DateBean(1, sdf.parse(date)), dataFormat); Assert.assertTrue(json.contains(date)); } @@ -66,7 +66,7 @@ public void testToJsonStrWithDateFormat() throws ParseException { public void testJsonToBean() { String json = "{\"id\":1,\"name\":\"Jack\"}"; InputStream in = new ByteArrayInputStream(json.getBytes()); - User user = jsonService.toBean(User.class, in); + User user = msgConvertor.toBean(User.class, in); Assert.assertEquals(1, user.getId()); Assert.assertEquals("Jack", user.getName()); } @@ -75,7 +75,7 @@ public void testJsonToBean() { public void testJsonToList() { String json = "[{\"id\":1,\"name\":\"Jack\"},{\"id\":2,\"name\":\"Tom\"}]"; InputStream in = new ByteArrayInputStream(json.getBytes()); - List users = jsonService.toList(User.class, in); + List users = msgConvertor.toList(User.class, in); Assert.assertTrue(2 == users.size()); User u1 = users.get(0); User u2 = users.get(1); diff --git a/okhttps/src/main/java/com/ejlchina/okhttps/HTTP.java b/okhttps/src/main/java/com/ejlchina/okhttps/HTTP.java index 577f90b4..d70d99d4 100644 --- a/okhttps/src/main/java/com/ejlchina/okhttps/HTTP.java +++ b/okhttps/src/main/java/com/ejlchina/okhttps/HTTP.java @@ -110,7 +110,7 @@ class Builder { private TaskListener completeListener; - private JsonService jsonService; + private MsgConvertor msgConvertor; private int preprocTimeoutTimes = 10; @@ -144,7 +144,7 @@ public Builder(HttpClient hc) { this.responseListener = executor.getResponseListener(); this.exceptionListener = executor.getExceptionListener(); this.completeListener = executor.getCompleteListener(); - this.jsonService = executor.getJsonService(); + this.msgConvertor = executor.getMsgConvertor(); this.preprocTimeoutTimes = hc.getPreprocTimeoutTimes(); } @@ -284,12 +284,12 @@ public Builder downloadListener(DownListener listener) { } /** - * 设置 JSON 服务 - * @param jsonService JSON 服务 + * 设置消息转换器 + * @param msgConvertor JSON 服务 * @return Builder */ - public Builder jsonService(JsonService jsonService) { - this.jsonService = jsonService; + public Builder msgConvertor(MsgConvertor msgConvertor) { + this.msgConvertor = msgConvertor; return this; } @@ -348,8 +348,8 @@ public TaskListener getCompleteListener() { return completeListener; } - public JsonService getJsonService() { - return jsonService; + public MsgConvertor getMsgConvertor() { + return msgConvertor; } public int getPreprocTimeoutTimes() { diff --git a/okhttps/src/main/java/com/ejlchina/okhttps/HttpUtils.java b/okhttps/src/main/java/com/ejlchina/okhttps/HttpUtils.java index 1cd1bbe9..6862d111 100644 --- a/okhttps/src/main/java/com/ejlchina/okhttps/HttpUtils.java +++ b/okhttps/src/main/java/com/ejlchina/okhttps/HttpUtils.java @@ -40,7 +40,7 @@ static synchronized HTTP getHttp() { if (http != null) { return http; } - http = HTTP.builder().jsonService(findJsonService(new String[] { + http = HTTP.builder().msgConvertor(findJsonService(new String[] { "com.ejlchina.okhttps.GsonService", "com.ejlchina.okhttps.FastJsonService", "com.ejlchina.okhttps.JacksonService" @@ -48,7 +48,7 @@ static synchronized HTTP getHttp() { return http; } - static private JsonService findJsonService(String[] classes, int index) { + static private MsgConvertor findJsonService(String[] classes, int index) { if (index >= classes.length) { return null; } @@ -56,11 +56,11 @@ static private JsonService findJsonService(String[] classes, int index) { try { clazz = Class.forName(classes[0]); } catch (Exception ignore) {} - if (clazz == null || !JsonService.class.isAssignableFrom(clazz)) { + if (clazz == null || !MsgConvertor.class.isAssignableFrom(clazz)) { return findJsonService(classes, index + 1); } try { - return (JsonService) clazz.getDeclaredConstructor().newInstance(); + return (MsgConvertor) clazz.getDeclaredConstructor().newInstance(); } catch (Exception ignore) { return null; } diff --git a/okhttps/src/main/java/com/ejlchina/okhttps/JsonService.java b/okhttps/src/main/java/com/ejlchina/okhttps/MsgConvertor.java similarity index 94% rename from okhttps/src/main/java/com/ejlchina/okhttps/JsonService.java rename to okhttps/src/main/java/com/ejlchina/okhttps/MsgConvertor.java index 43edcdb7..2bea803b 100644 --- a/okhttps/src/main/java/com/ejlchina/okhttps/JsonService.java +++ b/okhttps/src/main/java/com/ejlchina/okhttps/MsgConvertor.java @@ -3,8 +3,10 @@ import java.io.InputStream; import java.util.List; - -public interface JsonService { +/** + * 消息转换器接口 + */ +public interface MsgConvertor { /** * 解析 Mapper @@ -52,6 +54,5 @@ public interface JsonService { * @return Java List */ List toList(Class type, InputStream in); - - + } diff --git a/okhttps/src/main/java/com/ejlchina/okhttps/internal/HttpClient.java b/okhttps/src/main/java/com/ejlchina/okhttps/internal/HttpClient.java index f27c1812..05ed17e7 100644 --- a/okhttps/src/main/java/com/ejlchina/okhttps/internal/HttpClient.java +++ b/okhttps/src/main/java/com/ejlchina/okhttps/internal/HttpClient.java @@ -33,7 +33,7 @@ public HttpClient(Builder builder) { this.executor = new TaskExecutor(okClient.dispatcher().executorService(), builder.getMainExecutor(), builder.getDownloadListener(), builder.getResponseListener(), builder.getExceptionListener(), - builder.getCompleteListener(), builder.getJsonService()); + builder.getCompleteListener(), builder.getMsgConvertor()); this.preprocessors = builder.getPreprocessors().toArray(new Preprocessor[0]); this.preprocTimeoutTimes = builder.getPreprocTimeoutTimes(); this.tagTasks = new LinkedList<>(); diff --git a/okhttps/src/main/java/com/ejlchina/okhttps/internal/TaskExecutor.java b/okhttps/src/main/java/com/ejlchina/okhttps/internal/TaskExecutor.java index 036da400..3c1404ff 100644 --- a/okhttps/src/main/java/com/ejlchina/okhttps/internal/TaskExecutor.java +++ b/okhttps/src/main/java/com/ejlchina/okhttps/internal/TaskExecutor.java @@ -10,7 +10,7 @@ import com.ejlchina.okhttps.Download; import com.ejlchina.okhttps.HttpResult; import com.ejlchina.okhttps.HttpTask; -import com.ejlchina.okhttps.JsonService; +import com.ejlchina.okhttps.MsgConvertor; import com.ejlchina.okhttps.OnCallback; import com.ejlchina.okhttps.TaskListener; import com.ejlchina.okhttps.HttpResult.State; @@ -23,18 +23,18 @@ public class TaskExecutor { TaskListener responseListener; TaskListener exceptionListener; TaskListener completeListener; - JsonService jsonService; + MsgConvertor msgConvertor; public TaskExecutor(Executor ioExecutor, Executor mainExecutor, DownListener downloadListener, TaskListener responseListener, TaskListener exceptionListener, - TaskListener completeListener, JsonService jsonService) { + TaskListener completeListener, MsgConvertor msgConvertor) { this.ioExecutor = ioExecutor; this.mainExecutor = mainExecutor; this.downloadListener = downloadListener; this.responseListener = responseListener; this.exceptionListener = exceptionListener; this.completeListener = completeListener; - this.jsonService = jsonService; + this.msgConvertor = msgConvertor; } public Executor getExecutor(boolean onIoThread) { @@ -99,9 +99,9 @@ public void executeOnComplete(HttpTask task, OnCallback onComplete, St } } - public JsonService jsonServiceNotNull() { - if (jsonService != null) { - return jsonService; + public MsgConvertor jsonServiceNotNull() { + if (msgConvertor != null) { + return msgConvertor; } throw new IllegalStateException("没有设置 JsonService，不可做 Json 操作！"); } @@ -143,8 +143,8 @@ public TaskListener getCompleteListener() { return completeListener; } - public JsonService getJsonService() { - return jsonService; + public MsgConvertor getMsgConvertor() { + return msgConvertor; } } From f758c336a86c90e8922f3550fe99402db68166ff Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?=E5=91=A8=E6=97=AD?= Date: Mon, 11 May 2020 10:46:28 +0800 Subject: [PATCH 252/924] =?UTF-8?q?=E9=87=8D=E6=9E=84?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- .../ejlchina/okhttps/FastJsonAutoConfig.java | 12 ------- .../okhttps/FastjsonMsgConvertor.java | 7 +++- .../com.ejlchina.okhttps.ConvertProvider | 1 + .../com.ejlchina.okhttps.OkHttps.Config | 1 - .../com/ejlchina/okhttps/GsonAutoConfig.java | 12 ------- .../ejlchina/okhttps/GsonMsgConvertor.java | 9 +++-- .../com.ejlchina.okhttps.ConvertProvider | 1 + .../com.ejlchina.okhttps.OkHttps.Config | 1 - .../ejlchina/okhttps/JacksonAutoConfig.java | 12 ------- .../ejlchina/okhttps/JacksonMsgConvertor.java | 7 +++- .../com.ejlchina.okhttps.ConvertProvider | 1 + .../com.ejlchina.okhttps.OkHttps.Config | 1 - .../java/com/ejlchina/okhttps/Config.java | 18 ++++++++++ .../com/ejlchina/okhttps/Configurator.java | 17 ---------- .../com/ejlchina/okhttps/ConvertProvider.java | 21 ++++++++++++ .../main/java/com/ejlchina/okhttps/HTTP.java | 33 ++++++++++++------- .../java/com/ejlchina/okhttps/HttpUtils.java | 29 +++------------- .../java/com/ejlchina/okhttps/OkHttps.java | 10 ++---- 18 files changed, 90 insertions(+), 103 deletions(-) delete mode 100644 okhttps-fastjson/src/main/java/com/ejlchina/okhttps/FastJsonAutoConfig.java create mode 100644 okhttps-fastjson/src/main/resources/META-INF/services/com.ejlchina.okhttps.ConvertProvider delete mode 100644 okhttps-fastjson/src/main/resources/META-INF/services/com.ejlchina.okhttps.OkHttps.Config delete mode 100644 okhttps-gson/src/main/java/com/ejlchina/okhttps/GsonAutoConfig.java create mode 100644 okhttps-gson/src/main/resources/META-INF/services/com.ejlchina.okhttps.ConvertProvider delete mode 100644 okhttps-gson/src/main/resources/META-INF/services/com.ejlchina.okhttps.OkHttps.Config delete mode 100644 okhttps-jackson/src/main/java/com/ejlchina/okhttps/JacksonAutoConfig.java create mode 100644 okhttps-jackson/src/main/resources/META-INF/services/com.ejlchina.okhttps.ConvertProvider delete mode 100644 okhttps-jackson/src/main/resources/META-INF/services/com.ejlchina.okhttps.OkHttps.Config create mode 100644 okhttps/src/main/java/com/ejlchina/okhttps/Config.java delete mode 100644 okhttps/src/main/java/com/ejlchina/okhttps/Configurator.java create mode 100644 okhttps/src/main/java/com/ejlchina/okhttps/ConvertProvider.java diff --git a/okhttps-fastjson/src/main/java/com/ejlchina/okhttps/FastJsonAutoConfig.java b/okhttps-fastjson/src/main/java/com/ejlchina/okhttps/FastJsonAutoConfig.java deleted file mode 100644 index e29139bc..00000000 --- a/okhttps-fastjson/src/main/java/com/ejlchina/okhttps/FastJsonAutoConfig.java +++ /dev/null @@ -1,12 +0,0 @@ -package com.ejlchina.okhttps; - -public class FastJsonAutoConfig implements OkHttps.Config { - - @Override - public void withConfig(HTTP.Builder builder) { - if (builder.getMsgConvertor() == null) { - builder.msgConvertor(new FastjsonMsgConvertor()); - } - } - -} diff --git a/okhttps-fastjson/src/main/java/com/ejlchina/okhttps/FastjsonMsgConvertor.java b/okhttps-fastjson/src/main/java/com/ejlchina/okhttps/FastjsonMsgConvertor.java index a43b7288..d5290e4d 100644 --- a/okhttps-fastjson/src/main/java/com/ejlchina/okhttps/FastjsonMsgConvertor.java +++ b/okhttps-fastjson/src/main/java/com/ejlchina/okhttps/FastjsonMsgConvertor.java @@ -11,7 +11,7 @@ import okio.Okio; -public class FastjsonMsgConvertor implements MsgConvertor { +public class FastjsonMsgConvertor implements MsgConvertor, ConvertProvider { private Charset charset; @@ -53,6 +53,11 @@ public List toList(Class type, InputStream in) { return JSON.parseArray(toString(in), type); } + @Override + public MsgConvertor getConvertor() { + return new FastjsonMsgConvertor(); + } + private String toString(InputStream in) { try { return Okio.buffer(Okio.source(in)).readString(charset); diff --git a/okhttps-fastjson/src/main/resources/META-INF/services/com.ejlchina.okhttps.ConvertProvider b/okhttps-fastjson/src/main/resources/META-INF/services/com.ejlchina.okhttps.ConvertProvider new file mode 100644 index 00000000..88f3b11d --- /dev/null +++ b/okhttps-fastjson/src/main/resources/META-INF/services/com.ejlchina.okhttps.ConvertProvider @@ -0,0 +1 @@ +com.ejlchina.okhttps.FastjsonMsgConvertor \ No newline at end of file diff --git a/okhttps-fastjson/src/main/resources/META-INF/services/com.ejlchina.okhttps.OkHttps.Config b/okhttps-fastjson/src/main/resources/META-INF/services/com.ejlchina.okhttps.OkHttps.Config deleted file mode 100644 index a590a34f..00000000 --- a/okhttps-fastjson/src/main/resources/META-INF/services/com.ejlchina.okhttps.OkHttps.Config +++ /dev/null @@ -1 +0,0 @@ -com.ejlchina.okhttps.FastJsonAutoConfig \ No newline at end of file diff --git a/okhttps-gson/src/main/java/com/ejlchina/okhttps/GsonAutoConfig.java b/okhttps-gson/src/main/java/com/ejlchina/okhttps/GsonAutoConfig.java deleted file mode 100644 index 670103f2..00000000 --- a/okhttps-gson/src/main/java/com/ejlchina/okhttps/GsonAutoConfig.java +++ /dev/null @@ -1,12 +0,0 @@ -package com.ejlchina.okhttps; - -public class GsonAutoConfig implements OkHttps.Config { - - @Override - public void withConfig(HTTP.Builder builder) { - if (builder.getMsgConvertor() == null) { - builder.msgConvertor(new GsonMsgConvertor()); - } - } - -} diff --git a/okhttps-gson/src/main/java/com/ejlchina/okhttps/GsonMsgConvertor.java b/okhttps-gson/src/main/java/com/ejlchina/okhttps/GsonMsgConvertor.java index 770c886d..b4597263 100644 --- a/okhttps-gson/src/main/java/com/ejlchina/okhttps/GsonMsgConvertor.java +++ b/okhttps-gson/src/main/java/com/ejlchina/okhttps/GsonMsgConvertor.java @@ -11,7 +11,7 @@ import com.google.gson.JsonObject; import com.google.gson.reflect.TypeToken; -public class GsonMsgConvertor implements MsgConvertor { +public class GsonMsgConvertor implements MsgConvertor, ConvertProvider { private Gson gson; @@ -56,6 +56,11 @@ public List toList(Class type, InputStream in) { return list; } + @Override + public MsgConvertor getConvertor() { + return new GsonMsgConvertor(); + } + public Gson getGson() { return gson; } @@ -63,7 +68,7 @@ public Gson getGson() { public void setGson(Gson gson) { this.gson = gson; } - + } diff --git a/okhttps-gson/src/main/resources/META-INF/services/com.ejlchina.okhttps.ConvertProvider b/okhttps-gson/src/main/resources/META-INF/services/com.ejlchina.okhttps.ConvertProvider new file mode 100644 index 00000000..5eb90888 --- /dev/null +++ b/okhttps-gson/src/main/resources/META-INF/services/com.ejlchina.okhttps.ConvertProvider @@ -0,0 +1 @@ +com.ejlchina.okhttps.GsonMsgConvertor \ No newline at end of file diff --git a/okhttps-gson/src/main/resources/META-INF/services/com.ejlchina.okhttps.OkHttps.Config b/okhttps-gson/src/main/resources/META-INF/services/com.ejlchina.okhttps.OkHttps.Config deleted file mode 100644 index 637f6eb7..00000000 --- a/okhttps-gson/src/main/resources/META-INF/services/com.ejlchina.okhttps.OkHttps.Config +++ /dev/null @@ -1 +0,0 @@ -com.ejlchina.okhttps.GsonAutoConfig \ No newline at end of file diff --git a/okhttps-jackson/src/main/java/com/ejlchina/okhttps/JacksonAutoConfig.java b/okhttps-jackson/src/main/java/com/ejlchina/okhttps/JacksonAutoConfig.java deleted file mode 100644 index d8413273..00000000 --- a/okhttps-jackson/src/main/java/com/ejlchina/okhttps/JacksonAutoConfig.java +++ /dev/null @@ -1,12 +0,0 @@ -package com.ejlchina.okhttps; - -public class JacksonAutoConfig implements OkHttps.Config { - - @Override - public void withConfig(HTTP.Builder builder) { - if (builder.getMsgConvertor() == null) { - builder.msgConvertor(new JacksonMsgConvertor()); - } - } - -} diff --git a/okhttps-jackson/src/main/java/com/ejlchina/okhttps/JacksonMsgConvertor.java b/okhttps-jackson/src/main/java/com/ejlchina/okhttps/JacksonMsgConvertor.java index 25d896c0..abc78517 100644 --- a/okhttps-jackson/src/main/java/com/ejlchina/okhttps/JacksonMsgConvertor.java +++ b/okhttps-jackson/src/main/java/com/ejlchina/okhttps/JacksonMsgConvertor.java @@ -15,7 +15,7 @@ import com.fasterxml.jackson.databind.node.ObjectNode; import com.fasterxml.jackson.databind.type.CollectionType; -public class JacksonMsgConvertor implements MsgConvertor { +public class JacksonMsgConvertor implements MsgConvertor, ConvertProvider { private ObjectMapper objectMapper; @@ -99,6 +99,11 @@ public List toList(Class type, InputStream in) { } } + @Override + public MsgConvertor getConvertor() { + return new JacksonMsgConvertor(); + } + public ObjectMapper getObjectMapper() { return objectMapper; } diff --git a/okhttps-jackson/src/main/resources/META-INF/services/com.ejlchina.okhttps.ConvertProvider b/okhttps-jackson/src/main/resources/META-INF/services/com.ejlchina.okhttps.ConvertProvider new file mode 100644 index 00000000..ddfa7bde --- /dev/null +++ b/okhttps-jackson/src/main/resources/META-INF/services/com.ejlchina.okhttps.ConvertProvider @@ -0,0 +1 @@ +com.ejlchina.okhttps.JacksonMsgConvertor \ No newline at end of file diff --git a/okhttps-jackson/src/main/resources/META-INF/services/com.ejlchina.okhttps.OkHttps.Config b/okhttps-jackson/src/main/resources/META-INF/services/com.ejlchina.okhttps.OkHttps.Config deleted file mode 100644 index 1aca027c..00000000 --- a/okhttps-jackson/src/main/resources/META-INF/services/com.ejlchina.okhttps.OkHttps.Config +++ /dev/null @@ -1 +0,0 @@ -com.ejlchina.okhttps.JacksonAutoConfig \ No newline at end of file diff --git a/okhttps/src/main/java/com/ejlchina/okhttps/Config.java b/okhttps/src/main/java/com/ejlchina/okhttps/Config.java new file mode 100644 index 00000000..71a803c7 --- /dev/null +++ b/okhttps/src/main/java/com/ejlchina/okhttps/Config.java @@ -0,0 +1,18 @@ +package com.ejlchina.okhttps; + +import java.util.ServiceLoader; + +/** + * OkHttps 配置器 + */ +public interface Config { + + void with(HTTP.Builder builder); + + static void config(HTTP.Builder builder) { + for (Config config : ServiceLoader.load(Config.class)) { + config.with(builder); + } + } + +} diff --git a/okhttps/src/main/java/com/ejlchina/okhttps/Configurator.java b/okhttps/src/main/java/com/ejlchina/okhttps/Configurator.java deleted file mode 100644 index 54f954ad..00000000 --- a/okhttps/src/main/java/com/ejlchina/okhttps/Configurator.java +++ /dev/null @@ -1,17 +0,0 @@ -package com.ejlchina.okhttps; - -import okhttp3.OkHttpClient.Builder; - -/** - * Http 配置器 - * - */ -public interface Configurator { - - /** - * 使用 builder 配置 HttpClient - * @param builder OkHttpClient 构建器 - */ - void config(Builder builder); - -} diff --git a/okhttps/src/main/java/com/ejlchina/okhttps/ConvertProvider.java b/okhttps/src/main/java/com/ejlchina/okhttps/ConvertProvider.java new file mode 100644 index 00000000..28dc47ba --- /dev/null +++ b/okhttps/src/main/java/com/ejlchina/okhttps/ConvertProvider.java @@ -0,0 +1,21 @@ +package com.ejlchina.okhttps; + +import java.util.ServiceLoader; + +/** + * MsgConvertor 提供者 + */ +public interface ConvertProvider { + + MsgConvertor getConvertor(); + + static void inject(HTTP.Builder builder) { + for (ConvertProvider provider : ServiceLoader.load(ConvertProvider.class)) { + MsgConvertor convertor = provider.getConvertor(); + if (convertor != null) { + builder.msgConvertor(convertor); + } + } + } + +} diff --git a/okhttps/src/main/java/com/ejlchina/okhttps/HTTP.java b/okhttps/src/main/java/com/ejlchina/okhttps/HTTP.java index d70d99d4..5d1ccdc6 100644 --- a/okhttps/src/main/java/com/ejlchina/okhttps/HTTP.java +++ b/okhttps/src/main/java/com/ejlchina/okhttps/HTTP.java @@ -88,6 +88,21 @@ static Builder builder() { } + /** + * Http 配置器 + * + */ + interface OkConfig { + + /** + * 使用 builder 配置 HttpClient + * @param builder OkHttpClient 构建器 + */ + void config(OkHttpClient.Builder builder); + + } + + class Builder { private OkHttpClient okClient; @@ -96,7 +111,7 @@ class Builder { private Map mediaTypes; - private Configurator configurator; + private OkConfig config; private Executor mainExecutor; @@ -151,11 +166,11 @@ public Builder(HttpClient hc) { /** * 配置 OkHttpClient * - * @param configurator 配置器 + * @param config 配置器 * @return Builder */ - public Builder config(Configurator configurator) { - this.configurator = configurator; + public Builder config(OkConfig config) { + this.config = config; return this; } @@ -298,10 +313,10 @@ public Builder msgConvertor(MsgConvertor msgConvertor) { * @return HTTP */ public HTTP build() { - if (configurator != null || okClient == null) { + if (config != null || okClient == null) { OkHttpClient.Builder builder = new OkHttpClient.Builder(); - if (configurator != null) { - configurator.config(builder); + if (config != null) { + config.config(builder); } okClient = builder.build(); } @@ -320,10 +335,6 @@ public Map getMediaTypes() { return mediaTypes; } - public Configurator getConfigurator() { - return configurator; - } - public Executor getMainExecutor() { return mainExecutor; } diff --git a/okhttps/src/main/java/com/ejlchina/okhttps/HttpUtils.java b/okhttps/src/main/java/com/ejlchina/okhttps/HttpUtils.java index 6862d111..74bd8a5b 100644 --- a/okhttps/src/main/java/com/ejlchina/okhttps/HttpUtils.java +++ b/okhttps/src/main/java/com/ejlchina/okhttps/HttpUtils.java @@ -10,6 +10,8 @@ import okhttp3.WebSocket; import okhttp3.WebSocketListener; +import java.util.ServiceLoader; + /** * Http 工具类（可供第三方库，非主应用使用） * 若需要配置，请使用 {@link OkHttps } 类 @@ -21,7 +23,6 @@ public class HttpUtils { private static HTTP http; - /** * 配置HttpUtils持有的HTTP实例（不调用此方法前默认使用一个没有没有经过任何配置的HTTP懒实例） * @param http HTTP实例 @@ -40,32 +41,12 @@ static synchronized HTTP getHttp() { if (http != null) { return http; } - http = HTTP.builder().msgConvertor(findJsonService(new String[] { - "com.ejlchina.okhttps.GsonService", - "com.ejlchina.okhttps.FastJsonService", - "com.ejlchina.okhttps.JacksonService" - }, 0)).build(); + HTTP.Builder builder = HTTP.builder(); + ConvertProvider.inject(builder); + http = builder.build(); return http; } - static private MsgConvertor findJsonService(String[] classes, int index) { - if (index >= classes.length) { - return null; - } - Class clazz = null; - try { - clazz = Class.forName(classes[0]); - } catch (Exception ignore) {} - if (clazz == null || !MsgConvertor.class.isAssignableFrom(clazz)) { - return findJsonService(classes, index + 1); - } - try { - return (MsgConvertor) clazz.getDeclaredConstructor().newInstance(); - } catch (Exception ignore) { - return null; - } - } - /** * 异步请求 * @param url 请求地址 diff --git a/okhttps/src/main/java/com/ejlchina/okhttps/OkHttps.java b/okhttps/src/main/java/com/ejlchina/okhttps/OkHttps.java index b581bb21..3d24a4f2 100644 --- a/okhttps/src/main/java/com/ejlchina/okhttps/OkHttps.java +++ b/okhttps/src/main/java/com/ejlchina/okhttps/OkHttps.java @@ -16,11 +16,6 @@ public final class OkHttps { private OkHttps() {} - public interface Config { - - void withConfig(HTTP.Builder builder); - - } private static HTTP http; @@ -29,9 +24,8 @@ static synchronized HTTP getHttp() { return http; } HTTP.Builder builder = HTTP.builder(); - for (Config config : ServiceLoader.load(Config.class)) { - config.withConfig(builder); - } + ConvertProvider.inject(builder); + Config.config(builder); http = builder.build(); return http; } From 32f002dc980e9362943c8a13488295cf1cff42cc Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?=E5=91=A8=E6=97=AD?= Date: Mon, 11 May 2020 11:00:58 +0800 Subject: [PATCH 253/924] =?UTF-8?q?=E9=87=8D=E6=9E=84?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- .../main/java/com/ejlchina/okhttps/HttpTask.java | 6 +++--- .../ejlchina/okhttps/internal/AbstractBody.java | 16 ++++++++-------- .../ejlchina/okhttps/internal/TaskExecutor.java | 4 ++-- .../ejlchina/okhttps/internal/WebSocketTask.java | 16 +++++++--------- 4 files changed, 20 insertions(+), 22 deletions(-) diff --git a/okhttps/src/main/java/com/ejlchina/okhttps/HttpTask.java b/okhttps/src/main/java/com/ejlchina/okhttps/HttpTask.java index d1354408..6c656ce7 100644 --- a/okhttps/src/main/java/com/ejlchina/okhttps/HttpTask.java +++ b/okhttps/src/main/java/com/ejlchina/okhttps/HttpTask.java @@ -420,11 +420,11 @@ public C setRequestJson(Object json, String dateFormat) { requestJson = json.toString(); } else if (dateFormat != null) { requestJson = httpClient.getExecutor() - .jsonServiceNotNull() + .convertor() .serialize(json, dateFormat); } else { requestJson = httpClient.getExecutor() - .jsonServiceNotNull() + .convertor() .serialize(json); } } @@ -656,7 +656,7 @@ protected State toState(IOException e, boolean sync) { private RequestBody buildRequestBody() { if (jsonParams != null) { - requestJson = httpClient.getExecutor().jsonServiceNotNull() + requestJson = httpClient.getExecutor().convertor() .serialize(jsonParams); } if (files != null) { diff --git a/okhttps/src/main/java/com/ejlchina/okhttps/internal/AbstractBody.java b/okhttps/src/main/java/com/ejlchina/okhttps/internal/AbstractBody.java index 82378892..f7007012 100644 --- a/okhttps/src/main/java/com/ejlchina/okhttps/internal/AbstractBody.java +++ b/okhttps/src/main/java/com/ejlchina/okhttps/internal/AbstractBody.java @@ -21,33 +21,33 @@ public AbstractBody(TaskExecutor taskExecutor) { public Mapper toMapper() { if (taskExecutor == null) { - throw new IllegalStateException("没有 taskExecutor，不可做 Json 转换！"); + throw new IllegalStateException("没有 taskExecutor，不可做 Mapper 转换！"); } - return taskExecutor.jsonServiceNotNull().toMapper(toByteStream()); + return taskExecutor.convertor().toMapper(toByteStream()); } public Array toArray() { if (taskExecutor == null) { - throw new IllegalStateException("没有 taskExecutor，不可做 Json 转换！"); + throw new IllegalStateException("没有 taskExecutor，不可做 Array 转换！"); } - return taskExecutor.jsonServiceNotNull().toArray(toByteStream()); + return taskExecutor.convertor().toArray(toByteStream()); } public T toBean(Class type) { if (taskExecutor == null) { - throw new IllegalStateException("没有 taskExecutor，不可做 Json 转换！"); + throw new IllegalStateException("没有 taskExecutor，不可做 Bean 转换！"); } - return taskExecutor.jsonServiceNotNull().toBean(type, toByteStream()); + return taskExecutor.convertor().toBean(type, toByteStream()); } public List toList(Class type) { if (taskExecutor == null) { - throw new IllegalStateException("没有 taskExecutor，不可做 Json 转换！"); + throw new IllegalStateException("没有 taskExecutor，不可做 List 转换！"); } - return taskExecutor.jsonServiceNotNull().toList(type, toByteStream()); + return taskExecutor.convertor().toList(type, toByteStream()); } } diff --git a/okhttps/src/main/java/com/ejlchina/okhttps/internal/TaskExecutor.java b/okhttps/src/main/java/com/ejlchina/okhttps/internal/TaskExecutor.java index 3c1404ff..8e5b0f0b 100644 --- a/okhttps/src/main/java/com/ejlchina/okhttps/internal/TaskExecutor.java +++ b/okhttps/src/main/java/com/ejlchina/okhttps/internal/TaskExecutor.java @@ -99,11 +99,11 @@ public void executeOnComplete(HttpTask task, OnCallback onComplete, St } } - public MsgConvertor jsonServiceNotNull() { + public MsgConvertor convertor() { if (msgConvertor != null) { return msgConvertor; } - throw new IllegalStateException("没有设置 JsonService，不可做 Json 操作！"); + throw new IllegalStateException("没有设置 MsgConvertor，不可做转换操作！"); } /** diff --git a/okhttps/src/main/java/com/ejlchina/okhttps/internal/WebSocketTask.java b/okhttps/src/main/java/com/ejlchina/okhttps/internal/WebSocketTask.java index 1eab9f2f..895def2e 100644 --- a/okhttps/src/main/java/com/ejlchina/okhttps/internal/WebSocketTask.java +++ b/okhttps/src/main/java/com/ejlchina/okhttps/internal/WebSocketTask.java @@ -116,7 +116,7 @@ static class WebSocketImpl implements WebSocket { okhttp3.WebSocket webSocket; - List queues = new ArrayList<>(); + final List queues = new ArrayList<>(); TaskExecutor taskExecutor; @@ -170,12 +170,12 @@ public boolean send(ByteString bytes) { @Override public boolean send(Object bean) { - return send(taskExecutor.jsonServiceNotNull().serialize(bean)); + return send(taskExecutor.convertor().serialize(bean)); } @Override public boolean send(Object bean, String dateFormat) { - return send(taskExecutor.jsonServiceNotNull().serialize(bean, dateFormat)); + return send(taskExecutor.convertor().serialize(bean, dateFormat)); } @Override @@ -193,12 +193,10 @@ void queueMsgToSend(Object msg) { return; } synchronized (queues) { - if (queues != null) { - queues.add(msg); - } else if (webSocket != null) { + if (webSocket != null) { send(webSocket, msg); } else { - throw new IllegalStateException(); + queues.add(msg); } } } @@ -209,7 +207,7 @@ void setWebSocket(okhttp3.WebSocket webSocket) { send(webSocket, msg); } this.webSocket = webSocket; - queues = null; + queues.clear(); } } @@ -226,7 +224,7 @@ boolean send(okhttp3.WebSocket webSocket, Object msg) { if (msg instanceof byte[]) { return webSocket.send(ByteString.of((byte[]) msg)); } - return webSocket.send(taskExecutor.jsonServiceNotNull().serialize(msg)); + return webSocket.send(taskExecutor.convertor().serialize(msg)); } } From 8cbae3757b8039152b56bc91b89fdbce4602321b Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?=E5=91=A8=E6=97=AD?= Date: Mon, 11 May 2020 11:13:24 +0800 Subject: [PATCH 254/924] =?UTF-8?q?=E6=96=B0=E5=A2=9E=20patch=20=E4=BE=BF?= =?UTF-8?q?=E6=8D=B7=E8=AF=B7=E6=B1=82=E6=96=B9=E6=B3=95=EF=BC=8C=E6=B7=BB?= =?UTF-8?q?=E5=8A=A0=20restfull=20=E9=87=8A=E4=B9=89?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- .../okhttps/internal/AsyncHttpTask.java | 16 ++++++++++++---- .../okhttps/internal/SyncHttpTask.java | 18 +++++++++++++----- 2 files changed, 25 insertions(+), 9 deletions(-) diff --git a/okhttps/src/main/java/com/ejlchina/okhttps/internal/AsyncHttpTask.java b/okhttps/src/main/java/com/ejlchina/okhttps/internal/AsyncHttpTask.java index 8fd8c0ec..f7f228d7 100644 --- a/okhttps/src/main/java/com/ejlchina/okhttps/internal/AsyncHttpTask.java +++ b/okhttps/src/main/java/com/ejlchina/okhttps/internal/AsyncHttpTask.java @@ -70,7 +70,7 @@ public AsyncHttpTask setOnResponse(OnCallback onResponse) { } /** - * 发起 GET 请求 + * 发起 GET 请求（Rest：读取资源，幂等） * @return HttpCall */ public HttpCall get() { @@ -78,7 +78,7 @@ public HttpCall get() { } /** - * 发起 POST 请求 + * 发起 POST 请求（Rest：创建资源，非幂等） * @return HttpCall */ public HttpCall post() { @@ -86,15 +86,23 @@ public HttpCall post() { } /** - * 发起 PUT 请求 + * 发起 PUT 请求（Rest：更新资源，幂等） * @return HttpCall */ public HttpCall put() { return request("PUT"); } + /** + * 发起 PATCH 请求（Rest：更新资源，部分更新，幂等） + * @return HttpCall + */ + public HttpCall patch() { + return request("PATCH"); + } + /** - * 发起 DELETE 请求 + * 发起 DELETE 请求（Rest：删除资源，幂等） * @return HttpCall */ public HttpCall delete() { diff --git a/okhttps/src/main/java/com/ejlchina/okhttps/internal/SyncHttpTask.java b/okhttps/src/main/java/com/ejlchina/okhttps/internal/SyncHttpTask.java index f574880f..a1cfe03e 100644 --- a/okhttps/src/main/java/com/ejlchina/okhttps/internal/SyncHttpTask.java +++ b/okhttps/src/main/java/com/ejlchina/okhttps/internal/SyncHttpTask.java @@ -24,7 +24,7 @@ public SyncHttpTask(HttpClient client, String url) { } /** - * 发起 GET 请求 + * 发起 GET 请求（Rest：获取资源，幂等） * @return 请求结果 */ public HttpResult get() { @@ -32,7 +32,7 @@ public HttpResult get() { } /** - * 发起 POST 请求 + * 发起 POST 请求（Rest：创建资源，非幂等） * @return 请求结果 */ public HttpResult post() { @@ -40,15 +40,23 @@ public HttpResult post() { } /** - * 发起 PUT 请求 + * 发起 PUT 请求（Rest：更新资源，幂等） * @return 请求结果 */ public HttpResult put() { return request("PUT"); } - + + /** + * 发起 PATCH 请求（Rest：更新资源，部分更新，幂等） + * @return HttpCall + */ + public HttpResult patch() { + return request("PATCH"); + } + /** - * 发起 DELETE 请求 + * 发起 DELETE 请求（Rest：删除资源，幂等） * @return 请求结果 */ public HttpResult delete() { From a911b426d3031172085fe18fc848f2e1f2a01794 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?=E5=91=A8=E6=97=AD?= Date: Mon, 11 May 2020 12:08:32 +0800 Subject: [PATCH 255/924] =?UTF-8?q?MsgConvertor=20=E6=8E=A5=E5=8F=A3?= =?UTF-8?q?=E6=96=B0=E5=A2=9E=20mediaType=20=E6=96=B9=E6=B3=95?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- .../okhttps/FastjsonMsgConvertor.java | 5 +++ .../ejlchina/okhttps/GsonMsgConvertor.java | 15 +++++++-- .../ejlchina/okhttps/JacksonMsgConvertor.java | 23 +++++++++++-- .../java/com/ejlchina/okhttps/HttpTask.java | 5 ++- .../com/ejlchina/okhttps/MsgConvertor.java | 6 ++++ .../okhttps/internal/TaskExecutor.java | 32 ++++++++++++++----- 6 files changed, 69 insertions(+), 17 deletions(-) diff --git a/okhttps-fastjson/src/main/java/com/ejlchina/okhttps/FastjsonMsgConvertor.java b/okhttps-fastjson/src/main/java/com/ejlchina/okhttps/FastjsonMsgConvertor.java index d5290e4d..13d8cdca 100644 --- a/okhttps-fastjson/src/main/java/com/ejlchina/okhttps/FastjsonMsgConvertor.java +++ b/okhttps-fastjson/src/main/java/com/ejlchina/okhttps/FastjsonMsgConvertor.java @@ -23,6 +23,11 @@ public FastjsonMsgConvertor(Charset charset) { this.charset = charset; } + @Override + public String mediaType() { + return "application/json; charset=" + charset.displayName(); + } + @Override public Mapper toMapper(InputStream in) { return new FastjsonMapper(JSON.parseObject(toString(in))); diff --git a/okhttps-gson/src/main/java/com/ejlchina/okhttps/GsonMsgConvertor.java b/okhttps-gson/src/main/java/com/ejlchina/okhttps/GsonMsgConvertor.java index b4597263..a39dd25c 100644 --- a/okhttps-gson/src/main/java/com/ejlchina/okhttps/GsonMsgConvertor.java +++ b/okhttps-gson/src/main/java/com/ejlchina/okhttps/GsonMsgConvertor.java @@ -2,6 +2,8 @@ import java.io.InputStream; import java.io.InputStreamReader; +import java.nio.charset.Charset; +import java.nio.charset.StandardCharsets; import java.util.ArrayList; import java.util.Collections; import java.util.List; @@ -14,13 +16,20 @@ public class GsonMsgConvertor implements MsgConvertor, ConvertProvider { private Gson gson; - + private Charset charset; + public GsonMsgConvertor() { - this(new Gson()); + this(new Gson(), StandardCharsets.UTF_8); } - public GsonMsgConvertor(Gson gson) { + public GsonMsgConvertor(Gson gson, Charset charset) { this.gson = gson; + this.charset = charset; + } + + @Override + public String mediaType() { + return "application/json; charset=" + charset.displayName(); } @Override diff --git a/okhttps-jackson/src/main/java/com/ejlchina/okhttps/JacksonMsgConvertor.java b/okhttps-jackson/src/main/java/com/ejlchina/okhttps/JacksonMsgConvertor.java index abc78517..6916c8f7 100644 --- a/okhttps-jackson/src/main/java/com/ejlchina/okhttps/JacksonMsgConvertor.java +++ b/okhttps-jackson/src/main/java/com/ejlchina/okhttps/JacksonMsgConvertor.java @@ -2,6 +2,8 @@ import java.io.IOException; import java.io.InputStream; +import java.nio.charset.Charset; +import java.nio.charset.StandardCharsets; import java.text.SimpleDateFormat; import java.util.ArrayList; import java.util.List; @@ -18,13 +20,21 @@ public class JacksonMsgConvertor implements MsgConvertor, ConvertProvider { private ObjectMapper objectMapper; - + + private Charset charset; + public JacksonMsgConvertor() { - this(new ObjectMapper()); + this(new ObjectMapper(), StandardCharsets.UTF_8); } - public JacksonMsgConvertor(ObjectMapper objectMapper) { + public JacksonMsgConvertor(ObjectMapper objectMapper, Charset charset) { this.objectMapper = objectMapper; + this.charset = charset; + } + + @Override + public String mediaType() { + return "application/json; charset=" + charset.displayName(); } @Override @@ -112,4 +122,11 @@ public void setObjectMapper(ObjectMapper objectMapper) { this.objectMapper = objectMapper; } + public Charset getCharset() { + return charset; + } + + public void setCharset(Charset charset) { + this.charset = charset; + } } diff --git a/okhttps/src/main/java/com/ejlchina/okhttps/HttpTask.java b/okhttps/src/main/java/com/ejlchina/okhttps/HttpTask.java index 6c656ce7..5a5c6a97 100644 --- a/okhttps/src/main/java/com/ejlchina/okhttps/HttpTask.java +++ b/okhttps/src/main/java/com/ejlchina/okhttps/HttpTask.java @@ -36,8 +36,7 @@ @SuppressWarnings("unchecked") public abstract class HttpTask> implements Cancelable { - private static final MediaType TYPE_JSON = MediaType.parse("application/json; charset=utf-8"); - private static String PATH_PARAM_REGEX = "[A-Za-z0-9_\\-/]*\\{[A-Za-z0-9_\\-]+\\}[A-Za-z0-9_\\-/]*"; + private static final String PATH_PARAM_REGEX = "[A-Za-z0-9_\\-/]*\\{[A-Za-z0-9_\\-]+\\}[A-Za-z0-9_\\-/]*"; protected HttpClient httpClient; protected boolean nothrow; @@ -680,7 +679,7 @@ private RequestBody buildRequestBody() { } return builder.build(); } else if (requestJson != null) { - return RequestBody.create(TYPE_JSON, requestJson); + return RequestBody.create(httpClient.getExecutor().getMapperMediaType(), requestJson); } else { FormBody.Builder builder = new FormBody.Builder(); if (bodyParams != null) { diff --git a/okhttps/src/main/java/com/ejlchina/okhttps/MsgConvertor.java b/okhttps/src/main/java/com/ejlchina/okhttps/MsgConvertor.java index 2bea803b..b937e71f 100644 --- a/okhttps/src/main/java/com/ejlchina/okhttps/MsgConvertor.java +++ b/okhttps/src/main/java/com/ejlchina/okhttps/MsgConvertor.java @@ -8,6 +8,12 @@ */ public interface MsgConvertor { + /** + * 消息的媒体类型 + * @return 媒体类型 + */ + String mediaType(); + /** * 解析 Mapper * @param in JSON 输入流 diff --git a/okhttps/src/main/java/com/ejlchina/okhttps/internal/TaskExecutor.java b/okhttps/src/main/java/com/ejlchina/okhttps/internal/TaskExecutor.java index 8e5b0f0b..e0db7f70 100644 --- a/okhttps/src/main/java/com/ejlchina/okhttps/internal/TaskExecutor.java +++ b/okhttps/src/main/java/com/ejlchina/okhttps/internal/TaskExecutor.java @@ -14,16 +14,17 @@ import com.ejlchina.okhttps.OnCallback; import com.ejlchina.okhttps.TaskListener; import com.ejlchina.okhttps.HttpResult.State; +import okhttp3.MediaType; public class TaskExecutor { - Executor ioExecutor; - Executor mainExecutor; - DownListener downloadListener; - TaskListener responseListener; - TaskListener exceptionListener; - TaskListener completeListener; - MsgConvertor msgConvertor; + private Executor ioExecutor; + private Executor mainExecutor; + private DownListener downloadListener; + private TaskListener responseListener; + private TaskListener exceptionListener; + private TaskListener completeListener; + private MsgConvertor msgConvertor; public TaskExecutor(Executor ioExecutor, Executor mainExecutor, DownListener downloadListener, TaskListener responseListener, TaskListener exceptionListener, @@ -105,7 +106,22 @@ public MsgConvertor convertor() { } throw new IllegalStateException("没有设置 MsgConvertor，不可做转换操作！"); } - + + private MediaType mapperMediaType; + + public MediaType getMapperMediaType() { + if (mapperMediaType == null && msgConvertor != null) { + String mediaType = msgConvertor.mediaType(); + if (mediaType != null) { + mapperMediaType = MediaType.parse(mediaType); + } + } + if (mapperMediaType == null) { + MediaType.parse("application/json; charset=utf-8"); + } + return mapperMediaType; + } + /** * 关闭线程池 * @since OkHttps V1.0.2 From 5bbd058d1c6fd940c97568dca9c56f62ea66104c Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?=E5=91=A8=E6=97=AD?= Date: Mon, 11 May 2020 14:16:58 +0800 Subject: [PATCH 256/924] =?UTF-8?q?=E6=96=B0=E5=A2=9E=20HTTP.Builder#chars?= =?UTF-8?q?et(Charset=20charset)=20=E6=96=B9=E6=B3=95?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- .../okhttps/FastjsonMsgConvertor.java | 8 +-- .../ejlchina/okhttps/GsonMsgConvertor.java | 8 +-- .../ejlchina/okhttps/JacksonMsgConvertor.java | 9 +-- .../main/java/com/ejlchina/okhttps/HTTP.java | 53 ++++++++++++------ .../java/com/ejlchina/okhttps/HttpResult.java | 2 +- .../java/com/ejlchina/okhttps/HttpTask.java | 27 +++++---- .../java/com/ejlchina/okhttps/HttpUtils.java | 4 +- .../com/ejlchina/okhttps/MsgConvertor.java | 13 +++-- .../java/com/ejlchina/okhttps/OkHttps.java | 4 +- .../okhttps/internal/AsyncHttpTask.java | 4 +- .../ejlchina/okhttps/internal/HttpClient.java | 56 ++++++++++++------- .../okhttps/internal/SyncHttpTask.java | 2 +- .../okhttps/internal/TaskExecutor.java | 15 ----- 13 files changed, 114 insertions(+), 91 deletions(-) diff --git a/okhttps-fastjson/src/main/java/com/ejlchina/okhttps/FastjsonMsgConvertor.java b/okhttps-fastjson/src/main/java/com/ejlchina/okhttps/FastjsonMsgConvertor.java index 13d8cdca..dc36a7a1 100644 --- a/okhttps-fastjson/src/main/java/com/ejlchina/okhttps/FastjsonMsgConvertor.java +++ b/okhttps-fastjson/src/main/java/com/ejlchina/okhttps/FastjsonMsgConvertor.java @@ -39,13 +39,13 @@ public Array toArray(InputStream in) { } @Override - public String serialize(Object bean) { - return JSON.toJSONString(bean); + public byte[] serialize(Object bean) { + return JSON.toJSONString(bean).getBytes(charset); } @Override - public String serialize(Object bean, String dateFormat) { - return JSON.toJSONStringWithDateFormat(bean, dateFormat); + public byte[] serialize(Object bean, String dateFormat) { + return JSON.toJSONStringWithDateFormat(bean, dateFormat).getBytes(charset); } @Override diff --git a/okhttps-gson/src/main/java/com/ejlchina/okhttps/GsonMsgConvertor.java b/okhttps-gson/src/main/java/com/ejlchina/okhttps/GsonMsgConvertor.java index a39dd25c..621ce9dd 100644 --- a/okhttps-gson/src/main/java/com/ejlchina/okhttps/GsonMsgConvertor.java +++ b/okhttps-gson/src/main/java/com/ejlchina/okhttps/GsonMsgConvertor.java @@ -43,13 +43,13 @@ public Array toArray(InputStream in) { } @Override - public String serialize(Object bean) { - return gson.toJson(bean); + public byte[] serialize(Object bean) { + return gson.toJson(bean).getBytes(charset); } @Override - public String serialize(Object bean, String dateFormat) { - return gson.newBuilder().setDateFormat(dateFormat).create().toJson(bean); + public byte[] serialize(Object bean, String dateFormat) { + return gson.newBuilder().setDateFormat(dateFormat).create().toJson(bean).getBytes(charset); } @Override diff --git a/okhttps-jackson/src/main/java/com/ejlchina/okhttps/JacksonMsgConvertor.java b/okhttps-jackson/src/main/java/com/ejlchina/okhttps/JacksonMsgConvertor.java index 6916c8f7..1ae8579c 100644 --- a/okhttps-jackson/src/main/java/com/ejlchina/okhttps/JacksonMsgConvertor.java +++ b/okhttps-jackson/src/main/java/com/ejlchina/okhttps/JacksonMsgConvertor.java @@ -70,21 +70,22 @@ public Array toArray(InputStream in) { } @Override - public String serialize(Object bean) { + public byte[] serialize(Object bean) { try { - return objectMapper.writeValueAsString(bean); + objectMapper.writeValueAsBytes(bean); + return objectMapper.writeValueAsString(bean).getBytes(charset); } catch (JsonProcessingException e) { throw new HttpException("Java Bean [" + bean + "] Jackson 序列化异常", e); } } @Override - public String serialize(Object bean, String dateFormat) { + public byte[] serialize(Object bean, String dateFormat) { ObjectMapper mapper = objectMapper.copy(); mapper.configure(SerializationFeature.WRITE_DATES_AS_TIMESTAMPS, false); mapper.setDateFormat(new SimpleDateFormat(dateFormat)); try { - return mapper.writeValueAsString(bean); + return mapper.writeValueAsString(bean).getBytes(charset); } catch (JsonProcessingException e) { throw new HttpException("Java Bean [" + bean + "] Jackson 序列化异常", e); } diff --git a/okhttps/src/main/java/com/ejlchina/okhttps/HTTP.java b/okhttps/src/main/java/com/ejlchina/okhttps/HTTP.java index 5d1ccdc6..5dd03323 100644 --- a/okhttps/src/main/java/com/ejlchina/okhttps/HTTP.java +++ b/okhttps/src/main/java/com/ejlchina/okhttps/HTTP.java @@ -6,6 +6,8 @@ import okhttp3.WebSocket; import java.io.IOException; +import java.nio.charset.Charset; +import java.nio.charset.StandardCharsets; import java.util.*; import java.util.concurrent.Executor; @@ -71,7 +73,7 @@ public interface HTTP { * 获取任务执行器 * @return TaskExecutor */ - TaskExecutor getExecutor(); + TaskExecutor executor(); /** * 新的构建器 @@ -129,6 +131,8 @@ class Builder { private int preprocTimeoutTimes = 10; + private Charset charset = StandardCharsets.UTF_8; + public Builder() { mediaTypes = new HashMap<>(); mediaTypes.put("*", "application/octet-stream"); @@ -149,18 +153,19 @@ public Builder() { } public Builder(HttpClient hc) { - this.okClient = hc.getOkClient(); - this.baseUrl = hc.getBaseUrl(); - this.mediaTypes = hc.getMediaTypes(); + this.okClient = hc.okClient(); + this.baseUrl = hc.baseUrl(); + this.mediaTypes = hc.mediaTypes(); this.preprocessors = new ArrayList<>(); - Collections.addAll(this.preprocessors, hc.getPreprocessors()); - TaskExecutor executor = hc.getExecutor(); + Collections.addAll(this.preprocessors, hc.preprocessors()); + TaskExecutor executor = hc.executor(); this.downloadListener = executor.getDownloadListener(); this.responseListener = executor.getResponseListener(); this.exceptionListener = executor.getExceptionListener(); this.completeListener = executor.getCompleteListener(); this.msgConvertor = executor.getMsgConvertor(); - this.preprocTimeoutTimes = hc.getPreprocTimeoutTimes(); + this.preprocTimeoutTimes = hc.preprocTimeoutTimes(); + this.charset = hc.charset(); } /** @@ -308,6 +313,16 @@ public Builder msgConvertor(MsgConvertor msgConvertor) { return this; } + /** + * 设置编码格式 + * @param charset 编码 + * @return Builder + */ + public Builder charset(Charset charset) { + this.charset = charset; + return this; + } + /** * 构建 HTTP 实例 * @return HTTP @@ -323,11 +338,11 @@ public HTTP build() { return new HttpClient(this); } - public OkHttpClient getOkClient() { + public OkHttpClient okClient() { return okClient; } - public String getBaseUrl() { + public String baseUrl() { return baseUrl; } @@ -335,38 +350,42 @@ public Map getMediaTypes() { return mediaTypes; } - public Executor getMainExecutor() { + public Executor mainExecutor() { return mainExecutor; } - public List getPreprocessors() { + public List preprocessors() { return preprocessors; } - public DownListener getDownloadListener() { + public DownListener downloadListener() { return downloadListener; } - public TaskListener getResponseListener() { + public TaskListener responseListener() { return responseListener; } - public TaskListener getExceptionListener() { + public TaskListener exceptionListener() { return exceptionListener; } - public TaskListener getCompleteListener() { + public TaskListener completeListener() { return completeListener; } - public MsgConvertor getMsgConvertor() { + public MsgConvertor msgConvertor() { return msgConvertor; } - public int getPreprocTimeoutTimes() { + public int preprocTimeoutTimes() { return preprocTimeoutTimes; } + public Charset charset() { + return charset; + } + } } diff --git a/okhttps/src/main/java/com/ejlchina/okhttps/HttpResult.java b/okhttps/src/main/java/com/ejlchina/okhttps/HttpResult.java index 74edfb21..0e331db2 100644 --- a/okhttps/src/main/java/com/ejlchina/okhttps/HttpResult.java +++ b/okhttps/src/main/java/com/ejlchina/okhttps/HttpResult.java @@ -33,7 +33,7 @@ static HttpResult of(Response response) { /** * 构造一个 HttpResult * @param response Response - * @param taskExecutor 任务执行器, 可通过方法 {@link HTTP#getExecutor()} 获得 + * @param taskExecutor 任务执行器, 可通过方法 {@link HTTP#executor()} 获得 * @return HttpResult */ static HttpResult of(Response response, TaskExecutor taskExecutor) { diff --git a/okhttps/src/main/java/com/ejlchina/okhttps/HttpTask.java b/okhttps/src/main/java/com/ejlchina/okhttps/HttpTask.java index 5a5c6a97..4e1907a4 100644 --- a/okhttps/src/main/java/com/ejlchina/okhttps/HttpTask.java +++ b/okhttps/src/main/java/com/ejlchina/okhttps/HttpTask.java @@ -50,7 +50,7 @@ public abstract class HttpTask> implements Cancelable { private Map bodyParams; private Map jsonParams; private Map files; - private String requestJson; + private byte[] requestJson; private OnCallback onProcess; private boolean pOnIO; private long stepBytes = 0; @@ -415,14 +415,16 @@ public C setRequestJson(Object json) { **/ public C setRequestJson(Object json, String dateFormat) { if (json != null) { - if (json instanceof String) { - requestJson = json.toString(); + if (json instanceof byte[]) { + requestJson = (byte[]) json; + } else if (json instanceof String) { + requestJson = json.toString().getBytes(httpClient.charset()); } else if (dateFormat != null) { - requestJson = httpClient.getExecutor() + requestJson = httpClient.executor() .convertor() .serialize(json, dateFormat); } else { - requestJson = httpClient.getExecutor() + requestJson = httpClient.executor() .convertor() .serialize(json); } @@ -596,7 +598,7 @@ protected Request prepareRequest(String method) { stepBytes = Process.DEFAULT_STEP_BYTES; } reqBody = new ProcessRequestBody(reqBody, onProcess, - httpClient.getExecutor().getExecutor(pOnIO), + httpClient.executor().getExecutor(pOnIO), contentLength, stepBytes); } } @@ -655,20 +657,21 @@ protected State toState(IOException e, boolean sync) { private RequestBody buildRequestBody() { if (jsonParams != null) { - requestJson = httpClient.getExecutor().convertor() + requestJson = httpClient.executor().convertor() .serialize(jsonParams); } if (files != null) { MultipartBody.Builder builder = new MultipartBody.Builder().setType(MultipartBody.FORM); if (bodyParams != null) { for (String name : bodyParams.keySet()) { - String value = bodyParams.get(name); - builder.addFormDataPart(name, value); + byte[] value = bodyParams.get(name).getBytes(httpClient.charset()); + RequestBody body = RequestBody.create(null, value); + builder.addPart(MultipartBody.Part.createFormData(name, null, body)); } } for (String name : files.keySet()) { FilePara file = files.get(name); - MediaType type = httpClient.getMediaType(file.type); + MediaType type = httpClient.mediaType(file.type); RequestBody bodyPart; if (file.file != null) { bodyPart = RequestBody.create(type, file.file); @@ -679,9 +682,9 @@ private RequestBody buildRequestBody() { } return builder.build(); } else if (requestJson != null) { - return RequestBody.create(httpClient.getExecutor().getMapperMediaType(), requestJson); + return RequestBody.create(httpClient.mapperType(), requestJson); } else { - FormBody.Builder builder = new FormBody.Builder(); + FormBody.Builder builder = new FormBody.Builder(httpClient.charset()); if (bodyParams != null) { for (String name : bodyParams.keySet()) { String value = bodyParams.get(name); diff --git a/okhttps/src/main/java/com/ejlchina/okhttps/HttpUtils.java b/okhttps/src/main/java/com/ejlchina/okhttps/HttpUtils.java index 74bd8a5b..d8db6a5a 100644 --- a/okhttps/src/main/java/com/ejlchina/okhttps/HttpUtils.java +++ b/okhttps/src/main/java/com/ejlchina/okhttps/HttpUtils.java @@ -10,8 +10,6 @@ import okhttp3.WebSocket; import okhttp3.WebSocketListener; -import java.util.ServiceLoader; - /** * Http 工具类（可供第三方库，非主应用使用） * 若需要配置，请使用 {@link OkHttps } 类 @@ -115,7 +113,7 @@ public static WebSocket webSocket(Request request, WebSocketListener listener) { * @return TaskExecutor */ public static TaskExecutor getExecutor() { - return getHttp().getExecutor(); + return getHttp().executor(); } } diff --git a/okhttps/src/main/java/com/ejlchina/okhttps/MsgConvertor.java b/okhttps/src/main/java/com/ejlchina/okhttps/MsgConvertor.java index b937e71f..508664e6 100644 --- a/okhttps/src/main/java/com/ejlchina/okhttps/MsgConvertor.java +++ b/okhttps/src/main/java/com/ejlchina/okhttps/MsgConvertor.java @@ -1,6 +1,7 @@ package com.ejlchina.okhttps; import java.io.InputStream; +import java.nio.charset.Charset; import java.util.List; /** @@ -29,19 +30,19 @@ public interface MsgConvertor { Array toArray(InputStream in); /** - * 将 Java 对象序列化为字符串 + * 将 Java 对象序列化为字节数组 * @param bean Java Bean - * @return 字符串 + * @return 字节数组 */ - String serialize(Object bean); + byte[] serialize(Object bean); /** - * 将 Java 对象序列化为字符串 + * 将 Java 对象序列化为字节数组 * @param bean Java Bean * @param dateFormat 日期类的处理格式 - * @return 字符串 + * @return 字节数组 */ - String serialize(Object bean, String dateFormat); + byte[] serialize(Object bean, String dateFormat); /** * 解析 Java Bean diff --git a/okhttps/src/main/java/com/ejlchina/okhttps/OkHttps.java b/okhttps/src/main/java/com/ejlchina/okhttps/OkHttps.java index 3d24a4f2..c52d77e8 100644 --- a/okhttps/src/main/java/com/ejlchina/okhttps/OkHttps.java +++ b/okhttps/src/main/java/com/ejlchina/okhttps/OkHttps.java @@ -6,8 +6,6 @@ import okhttp3.WebSocket; import okhttp3.WebSocketListener; -import java.util.ServiceLoader; - /** * OkHttps 工具类 * 支持 SPI 方式配置 @@ -99,7 +97,7 @@ public static WebSocket webSocket(Request request, WebSocketListener listener) { * @return TaskExecutor */ public static TaskExecutor getExecutor() { - return getHttp().getExecutor(); + return getHttp().executor(); } } diff --git a/okhttps/src/main/java/com/ejlchina/okhttps/internal/AsyncHttpTask.java b/okhttps/src/main/java/com/ejlchina/okhttps/internal/AsyncHttpTask.java index f7f228d7..78cabb14 100644 --- a/okhttps/src/main/java/com/ejlchina/okhttps/internal/AsyncHttpTask.java +++ b/okhttps/src/main/java/com/ejlchina/okhttps/internal/AsyncHttpTask.java @@ -234,7 +234,7 @@ public void onFailure(Call call, IOException error) { State state = toState(error, false); HttpResult result = new RealHttpResult(AsyncHttpTask.this, state, error); onCallback(httpCall, result, () -> { - TaskExecutor executor = httpClient.getExecutor(); + TaskExecutor executor = httpClient.executor(); executor.executeOnComplete(AsyncHttpTask.this, onComplete, state, cOnIO); if (!executor.executeOnException(AsyncHttpTask.this, onException, error, eOnIO) && !nothrow) { @@ -245,7 +245,7 @@ public void onFailure(Call call, IOException error) { @Override public void onResponse(Call call, Response response) throws IOException { - TaskExecutor executor = httpClient.getExecutor(); + TaskExecutor executor = httpClient.executor(); HttpResult result = new RealHttpResult(AsyncHttpTask.this, response, executor); onCallback(httpCall, result, () -> { executor.executeOnComplete(AsyncHttpTask.this, onComplete, State.RESPONSED, cOnIO); diff --git a/okhttps/src/main/java/com/ejlchina/okhttps/internal/HttpClient.java b/okhttps/src/main/java/com/ejlchina/okhttps/internal/HttpClient.java index 05ed17e7..480b3e13 100644 --- a/okhttps/src/main/java/com/ejlchina/okhttps/internal/HttpClient.java +++ b/okhttps/src/main/java/com/ejlchina/okhttps/internal/HttpClient.java @@ -1,11 +1,10 @@ package com.ejlchina.okhttps.internal; -import com.ejlchina.okhttps.Cancelable; -import com.ejlchina.okhttps.HTTP; -import com.ejlchina.okhttps.HttpTask; -import com.ejlchina.okhttps.Preprocessor; +import com.ejlchina.okhttps.*; import okhttp3.*; +import okhttp3.WebSocket; +import java.nio.charset.Charset; import java.util.*; @@ -25,18 +24,29 @@ public class HttpClient implements HTTP { final List tagTasks; // 最大预处理时间倍数（相对于普通请求的超时时间） final int preprocTimeoutTimes; + // 编码格式 + final Charset charset; + // Mapper的媒体类型 + final MediaType mapperType; public HttpClient(Builder builder) { - this.okClient = builder.getOkClient(); - this.baseUrl = builder.getBaseUrl(); + this.okClient = builder.okClient(); + this.baseUrl = builder.baseUrl(); this.mediaTypes = builder.getMediaTypes(); + MsgConvertor convertor = builder.msgConvertor(); this.executor = new TaskExecutor(okClient.dispatcher().executorService(), - builder.getMainExecutor(), builder.getDownloadListener(), - builder.getResponseListener(), builder.getExceptionListener(), - builder.getCompleteListener(), builder.getMsgConvertor()); - this.preprocessors = builder.getPreprocessors().toArray(new Preprocessor[0]); - this.preprocTimeoutTimes = builder.getPreprocTimeoutTimes(); + builder.mainExecutor(), builder.downloadListener(), + builder.responseListener(), builder.exceptionListener(), + builder.completeListener(), convertor); + this.preprocessors = builder.preprocessors().toArray(new Preprocessor[0]); + this.preprocTimeoutTimes = builder.preprocTimeoutTimes(); + this.charset = builder.charset(); this.tagTasks = new LinkedList<>(); + String mediaType = convertor != null ? convertor.mediaType() : null; + if (mediaType == null) { + mediaType = "application/json"; + } + this.mapperType = MediaType.parse(mediaType + "; charset=" + charset.name()); } @Override @@ -96,7 +106,7 @@ public WebSocket webSocket(Request request, WebSocketListener listener) { return okClient.newWebSocket(request, listener); } - public OkHttpClient getOkClient() { + public OkHttpClient okClient() { return okClient; } @@ -159,7 +169,7 @@ public void setTag(String tag) { } - public MediaType getMediaType(String type) { + public MediaType mediaType(String type) { String mediaType = mediaTypes.get(type); if (mediaType != null) { return MediaType.parse(mediaType); @@ -168,7 +178,7 @@ public MediaType getMediaType(String type) { } @Override - public TaskExecutor getExecutor() { + public TaskExecutor executor() { return executor; } @@ -334,24 +344,32 @@ private String urlPath(String urlPath, boolean websocket) { return fullUrl; } - public String getBaseUrl() { + public String baseUrl() { return baseUrl; } - public Map getMediaTypes() { + public Map mediaTypes() { return mediaTypes; } - public Preprocessor[] getPreprocessors() { + public Preprocessor[] preprocessors() { return preprocessors; } - public List getTagTasks() { + public List tagTasks() { return tagTasks; } - public int getPreprocTimeoutTimes() { + public int preprocTimeoutTimes() { return preprocTimeoutTimes; } + public Charset charset() { + return charset; + } + + public MediaType mapperType() { + return mapperType; + } + } diff --git a/okhttps/src/main/java/com/ejlchina/okhttps/internal/SyncHttpTask.java b/okhttps/src/main/java/com/ejlchina/okhttps/internal/SyncHttpTask.java index a1cfe03e..f778d1fa 100644 --- a/okhttps/src/main/java/com/ejlchina/okhttps/internal/SyncHttpTask.java +++ b/okhttps/src/main/java/com/ejlchina/okhttps/internal/SyncHttpTask.java @@ -72,7 +72,7 @@ public HttpResult request(String method) { if (method == null || method.isEmpty()) { throw new IllegalArgumentException("HTTP 请求方法 method 不可为空！"); } - RealHttpResult result = new RealHttpResult(this, httpClient.getExecutor()); + RealHttpResult result = new RealHttpResult(this, httpClient.executor()); SyncHttpCall httpCall = new SyncHttpCall(); // 注册标签任务 registeTagTask(httpCall); diff --git a/okhttps/src/main/java/com/ejlchina/okhttps/internal/TaskExecutor.java b/okhttps/src/main/java/com/ejlchina/okhttps/internal/TaskExecutor.java index e0db7f70..859a40a9 100644 --- a/okhttps/src/main/java/com/ejlchina/okhttps/internal/TaskExecutor.java +++ b/okhttps/src/main/java/com/ejlchina/okhttps/internal/TaskExecutor.java @@ -107,21 +107,6 @@ public MsgConvertor convertor() { throw new IllegalStateException("没有设置 MsgConvertor，不可做转换操作！"); } - private MediaType mapperMediaType; - - public MediaType getMapperMediaType() { - if (mapperMediaType == null && msgConvertor != null) { - String mediaType = msgConvertor.mediaType(); - if (mediaType != null) { - mapperMediaType = MediaType.parse(mediaType); - } - } - if (mapperMediaType == null) { - MediaType.parse("application/json; charset=utf-8"); - } - return mapperMediaType; - } - /** * 关闭线程池 * @since OkHttps V1.0.2 From 31de0dd7b0c3a87efe504071ade39847659fb071 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?=E5=91=A8=E6=97=AD?= Date: Mon, 11 May 2020 15:10:21 +0800 Subject: [PATCH 257/924] =?UTF-8?q?=E4=BC=98=E5=8C=96?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- .../java/com/ejlchina/okhttps/HttpTask.java | 28 ++++----- .../com/ejlchina/okhttps/MsgConvertor.java | 18 ++++-- .../okhttps/internal/AbstractBody.java | 14 +++-- .../okhttps/internal/RealHttpResult.java | 10 ++- .../ejlchina/okhttps/internal/ResultBody.java | 63 ++++++++++++------- .../okhttps/internal/WebSocketTask.java | 18 ++++-- 6 files changed, 90 insertions(+), 61 deletions(-) diff --git a/okhttps/src/main/java/com/ejlchina/okhttps/HttpTask.java b/okhttps/src/main/java/com/ejlchina/okhttps/HttpTask.java index 4e1907a4..4b4f626c 100644 --- a/okhttps/src/main/java/com/ejlchina/okhttps/HttpTask.java +++ b/okhttps/src/main/java/com/ejlchina/okhttps/HttpTask.java @@ -7,6 +7,7 @@ import java.net.SocketException; import java.net.SocketTimeoutException; import java.net.UnknownHostException; +import java.nio.charset.Charset; import java.util.HashMap; import java.util.Iterator; import java.util.Map; @@ -20,16 +21,10 @@ import com.ejlchina.okhttps.internal.ProcessRequestBody; import com.ejlchina.okhttps.internal.RealHttpResult; -import okhttp3.Call; -import okhttp3.FormBody; -import okhttp3.MediaType; -import okhttp3.MultipartBody; -import okhttp3.Request; -import okhttp3.RequestBody; +import okhttp3.*; import okhttp3.internal.Util; import okio.Buffer; - /** * Created by 周旭（Troy.Zhou） on 2020/3/11. */ @@ -420,13 +415,11 @@ public C setRequestJson(Object json, String dateFormat) { } else if (json instanceof String) { requestJson = json.toString().getBytes(httpClient.charset()); } else if (dateFormat != null) { - requestJson = httpClient.executor() - .convertor() - .serialize(json, dateFormat); + requestJson = httpClient.executor().convertor() + .serialize(json, dateFormat, httpClient.charset()); } else { - requestJson = httpClient.executor() - .convertor() - .serialize(json); + requestJson = httpClient.executor().convertor() + .serialize(json, httpClient.charset()); } } return (C) this; @@ -658,7 +651,7 @@ protected State toState(IOException e, boolean sync) { private RequestBody buildRequestBody() { if (jsonParams != null) { requestJson = httpClient.executor().convertor() - .serialize(jsonParams); + .serialize(jsonParams, httpClient.charset()); } if (files != null) { MultipartBody.Builder builder = new MultipartBody.Builder().setType(MultipartBody.FORM); @@ -796,4 +789,11 @@ protected HttpResult timeoutResult() { throw new HttpException(State.TIMEOUT, "执行超时"); } + public Charset charset(Response response) { + ResponseBody b = response.body(); + MediaType type = b != null ? b.contentType() : null; + Charset defaultCharset = httpClient.charset(); + return type != null ? type.charset(defaultCharset) : defaultCharset; + } + } diff --git a/okhttps/src/main/java/com/ejlchina/okhttps/MsgConvertor.java b/okhttps/src/main/java/com/ejlchina/okhttps/MsgConvertor.java index 508664e6..8d102f66 100644 --- a/okhttps/src/main/java/com/ejlchina/okhttps/MsgConvertor.java +++ b/okhttps/src/main/java/com/ejlchina/okhttps/MsgConvertor.java @@ -18,48 +18,54 @@ public interface MsgConvertor { /** * 解析 Mapper * @param in JSON 输入流 + * @param charset 编码格式 * @return JsonObj */ - Mapper toMapper(InputStream in); + Mapper toMapper(InputStream in, Charset charset); /** * 解析 Array * @param in JSON 输入流 + * @param charset 编码格式 * @return JsonArr */ - Array toArray(InputStream in); + Array toArray(InputStream in, Charset charset); /** * 将 Java 对象序列化为字节数组 * @param bean Java Bean + * @param charset 编码格式 * @return 字节数组 */ - byte[] serialize(Object bean); + byte[] serialize(Object bean, Charset charset); /** * 将 Java 对象序列化为字节数组 * @param bean Java Bean * @param dateFormat 日期类的处理格式 + * @param charset 编码格式 * @return 字节数组 */ - byte[] serialize(Object bean, String dateFormat); + byte[] serialize(Object bean, String dateFormat, Charset charset); /** * 解析 Java Bean * @param 目标泛型 * @param type 目标类型 * @param in JSON 输入流 + * @param charset 编码格式 * @return Java Bean */ - T toBean(Class type, InputStream in); + T toBean(Class type, InputStream in, Charset charset); /** * 解析为 Java List * @param 目标泛型 * @param type 目标类型 * @param in JSON 输入流 + * @param charset 编码格式 * @return Java List */ - List toList(Class type, InputStream in); + List toList(Class type, InputStream in, Charset charset); } diff --git a/okhttps/src/main/java/com/ejlchina/okhttps/internal/AbstractBody.java b/okhttps/src/main/java/com/ejlchina/okhttps/internal/AbstractBody.java index f7007012..271cf7a7 100644 --- a/okhttps/src/main/java/com/ejlchina/okhttps/internal/AbstractBody.java +++ b/okhttps/src/main/java/com/ejlchina/okhttps/internal/AbstractBody.java @@ -1,6 +1,7 @@ package com.ejlchina.okhttps.internal; import java.io.InputStream; +import java.nio.charset.Charset; import java.util.List; import com.ejlchina.okhttps.Array; @@ -10,10 +11,11 @@ public abstract class AbstractBody { protected TaskExecutor taskExecutor; + protected Charset charset; - - public AbstractBody(TaskExecutor taskExecutor) { + public AbstractBody(TaskExecutor taskExecutor, Charset charset) { this.taskExecutor = taskExecutor; + this.charset = charset; } public abstract InputStream toByteStream(); @@ -23,7 +25,7 @@ public Mapper toMapper() { if (taskExecutor == null) { throw new IllegalStateException("没有 taskExecutor，不可做 Mapper 转换！"); } - return taskExecutor.convertor().toMapper(toByteStream()); + return taskExecutor.convertor().toMapper(toByteStream(), charset); } @@ -31,7 +33,7 @@ public Array toArray() { if (taskExecutor == null) { throw new IllegalStateException("没有 taskExecutor，不可做 Array 转换！"); } - return taskExecutor.convertor().toArray(toByteStream()); + return taskExecutor.convertor().toArray(toByteStream(), charset); } @@ -39,7 +41,7 @@ public T toBean(Class type) { if (taskExecutor == null) { throw new IllegalStateException("没有 taskExecutor，不可做 Bean 转换！"); } - return taskExecutor.convertor().toBean(type, toByteStream()); + return taskExecutor.convertor().toBean(type, toByteStream(), charset); } @@ -47,7 +49,7 @@ public List toList(Class type) { if (taskExecutor == null) { throw new IllegalStateException("没有 taskExecutor，不可做 List 转换！"); } - return taskExecutor.convertor().toList(type, toByteStream()); + return taskExecutor.convertor().toList(type, toByteStream(), charset); } } diff --git a/okhttps/src/main/java/com/ejlchina/okhttps/internal/RealHttpResult.java b/okhttps/src/main/java/com/ejlchina/okhttps/internal/RealHttpResult.java index aa4974fc..89614bf9 100644 --- a/okhttps/src/main/java/com/ejlchina/okhttps/internal/RealHttpResult.java +++ b/okhttps/src/main/java/com/ejlchina/okhttps/internal/RealHttpResult.java @@ -1,15 +1,14 @@ package com.ejlchina.okhttps.internal; -import java.io.IOException; -import java.util.Collections; -import java.util.List; - import com.ejlchina.okhttps.HttpResult; import com.ejlchina.okhttps.HttpTask; - import okhttp3.Headers; import okhttp3.Response; +import java.io.IOException; +import java.util.Collections; +import java.util.List; + public class RealHttpResult implements HttpResult { @@ -111,7 +110,6 @@ public IOException getError() { public Response getResponse() { return response; } - @Override public String toString() { diff --git a/okhttps/src/main/java/com/ejlchina/okhttps/internal/ResultBody.java b/okhttps/src/main/java/com/ejlchina/okhttps/internal/ResultBody.java index 9bafee28..aa3d0eb6 100644 --- a/okhttps/src/main/java/com/ejlchina/okhttps/internal/ResultBody.java +++ b/okhttps/src/main/java/com/ejlchina/okhttps/internal/ResultBody.java @@ -1,17 +1,8 @@ package com.ejlchina.okhttps.internal; -import static java.nio.charset.StandardCharsets.UTF_8; - -import java.io.ByteArrayInputStream; -import java.io.File; -import java.io.IOException; -import java.io.InputStream; -import java.io.InputStreamReader; -import java.io.Reader; -import java.io.UnsupportedEncodingException; +import java.io.*; import java.net.HttpURLConnection; import java.net.URLDecoder; -import java.nio.charset.Charset; import com.ejlchina.okhttps.Download; import com.ejlchina.okhttps.HttpResult.Body; @@ -21,6 +12,7 @@ import okhttp3.MediaType; import okhttp3.Response; +import okhttp3.ResponseBody; import okio.Buffer; public class ResultBody extends AbstractBody implements Body { @@ -36,19 +28,29 @@ public class ResultBody extends AbstractBody implements Body { private byte[] data; ResultBody(HttpTask httpTask, Response response, TaskExecutor taskExecutor) { - super(taskExecutor); + super(taskExecutor, httpTask.charset(response)); this.httpTask = httpTask; this.response = response; } + + @Override public MediaType getContentType() { - return response.body().contentType(); + ResponseBody body = response.body(); + if (body != null) { + return body.contentType(); + } + return null; } @Override public long getContentLength() { - return response.body().contentLength(); + ResponseBody body = response.body(); + if (body != null) { + return body.contentLength(); + } + return 0; } @Override @@ -93,7 +95,12 @@ public InputStream toByteStream() { if (cached) { input = new ByteArrayInputStream(cacheBytes()); } else { - input = response.body().byteStream(); + ResponseBody body = response.body(); + if (body != null) { + input = body.byteStream(); + } else { + input = new ByteArrayInputStream(new byte[]{}); + } } if (onProcess != null) { long rangeStart = getRangeStart(); @@ -126,21 +133,27 @@ public Reader toCharStream() { if (cached || onProcess != null) { return new InputStreamReader(toByteStream()); } - return response.body().charStream(); + ResponseBody body = response.body(); + if (body != null) { + return body.charStream(); + } + return new CharArrayReader(new char[]{}); } - + @Override public String toString() { if (cached || onProcess != null) { - MediaType contentType = getContentType(); - Charset charset = contentType != null ? contentType.charset(UTF_8) : UTF_8; return new String(toBytes(), charset); } try { - return response.body().string(); + ResponseBody body = response.body(); + if (body != null) { + return new String(body.bytes(), charset); + } } catch (IOException e) { throw new HttpException("报文体转化字符串出错", e); } + return null; } @Override @@ -231,11 +244,15 @@ private byte[] bodyToBytes() { buffer.close(); } } - try { - return response.body().bytes(); - } catch (IOException e) { - throw new HttpException("报文体转化字节数组出错", e); + ResponseBody body = response.body(); + if (body != null) { + try { + return body.bytes(); + } catch (IOException e) { + throw new HttpException("报文体转化字节数组出错", e); + } } + return new byte[]{}; } private long getRangeStart() { diff --git a/okhttps/src/main/java/com/ejlchina/okhttps/internal/WebSocketTask.java b/okhttps/src/main/java/com/ejlchina/okhttps/internal/WebSocketTask.java index 895def2e..d8b9809c 100644 --- a/okhttps/src/main/java/com/ejlchina/okhttps/internal/WebSocketTask.java +++ b/okhttps/src/main/java/com/ejlchina/okhttps/internal/WebSocketTask.java @@ -1,5 +1,7 @@ package com.ejlchina.okhttps.internal; +import java.nio.charset.Charset; +import java.nio.charset.StandardCharsets; import java.util.ArrayList; import java.util.List; @@ -35,7 +37,7 @@ public WebSocketTask(HttpClient httpClient, String url) { * @return WebSocket */ public WebSocket listen() { - WebSocketImpl socket = new WebSocketImpl(httpClient.executor); + WebSocketImpl socket = new WebSocketImpl(httpClient.executor, httpClient.charset); registeTagTask(socket); httpClient.preprocess(this, () -> { synchronized (socket) { @@ -119,9 +121,12 @@ static class WebSocketImpl implements WebSocket { final List queues = new ArrayList<>(); TaskExecutor taskExecutor; - - public WebSocketImpl(TaskExecutor taskExecutor) { + + Charset charset; + + public WebSocketImpl(TaskExecutor taskExecutor, Charset charset) { this.taskExecutor = taskExecutor; + this.charset = charset; } @Override @@ -170,12 +175,12 @@ public boolean send(ByteString bytes) { @Override public boolean send(Object bean) { - return send(taskExecutor.convertor().serialize(bean)); + return send(taskExecutor.convertor().serialize(bean, charset)); } @Override public boolean send(Object bean, String dateFormat) { - return send(taskExecutor.convertor().serialize(bean, dateFormat)); + return send(taskExecutor.convertor().serialize(bean, dateFormat, charset)); } @Override @@ -224,7 +229,8 @@ boolean send(okhttp3.WebSocket webSocket, Object msg) { if (msg instanceof byte[]) { return webSocket.send(ByteString.of((byte[]) msg)); } - return webSocket.send(taskExecutor.convertor().serialize(msg)); + byte[] bytes = taskExecutor.convertor().serialize(msg, charset); + return webSocket.send(new String(bytes, StandardCharsets.UTF_8)); } } From 24053c7c7b90c1eebc22f40abcbc5c088d2375fa Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?=E5=91=A8=E6=97=AD?= Date: Mon, 11 May 2020 15:12:58 +0800 Subject: [PATCH 258/924] =?UTF-8?q?=E4=BC=98=E5=8C=96?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- .../main/java/com/ejlchina/okhttps/internal/ResultBody.java | 4 +--- 1 file changed, 1 insertion(+), 3 deletions(-) diff --git a/okhttps/src/main/java/com/ejlchina/okhttps/internal/ResultBody.java b/okhttps/src/main/java/com/ejlchina/okhttps/internal/ResultBody.java index aa3d0eb6..dddb0f59 100644 --- a/okhttps/src/main/java/com/ejlchina/okhttps/internal/ResultBody.java +++ b/okhttps/src/main/java/com/ejlchina/okhttps/internal/ResultBody.java @@ -234,14 +234,12 @@ private byte[] cacheBytes() { private byte[] bodyToBytes() { if (onProcess != null) { - Buffer buffer = new Buffer(); - try { + try (Buffer buffer = new Buffer()) { return buffer.readFrom(toByteStream()).readByteArray(); } catch (IOException e) { throw new HttpException("报文体转化字节数组出错", e); } finally { response.close(); - buffer.close(); } } ResponseBody body = response.body(); From 0001d6ab8e5a7b0f7b5095f9669864f057206c49 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?=E5=91=A8=E6=97=AD?= Date: Mon, 11 May 2020 15:22:37 +0800 Subject: [PATCH 259/924] =?UTF-8?q?=E6=95=B4=E7=90=86?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- .../okhttps/FastjsonMsgConvertor.java | 52 ++++++------------- .../ejlchina/okhttps/GsonMsgConvertor.java | 20 ++++--- .../ejlchina/okhttps/JacksonMsgConvertor.java | 28 ++++------ 3 files changed, 34 insertions(+), 66 deletions(-) diff --git a/okhttps-fastjson/src/main/java/com/ejlchina/okhttps/FastjsonMsgConvertor.java b/okhttps-fastjson/src/main/java/com/ejlchina/okhttps/FastjsonMsgConvertor.java index dc36a7a1..df74d6f4 100644 --- a/okhttps-fastjson/src/main/java/com/ejlchina/okhttps/FastjsonMsgConvertor.java +++ b/okhttps-fastjson/src/main/java/com/ejlchina/okhttps/FastjsonMsgConvertor.java @@ -1,61 +1,49 @@ package com.ejlchina.okhttps; +import com.alibaba.fastjson.JSON; +import com.ejlchina.okhttps.internal.HttpException; +import okio.Okio; + import java.io.IOException; import java.io.InputStream; import java.nio.charset.Charset; -import java.nio.charset.StandardCharsets; import java.util.List; -import com.alibaba.fastjson.JSON; -import com.ejlchina.okhttps.internal.HttpException; - -import okio.Okio; - public class FastjsonMsgConvertor implements MsgConvertor, ConvertProvider { - private Charset charset; - - public FastjsonMsgConvertor() { - this(StandardCharsets.UTF_8); - } - - public FastjsonMsgConvertor(Charset charset) { - this.charset = charset; - } - @Override public String mediaType() { - return "application/json; charset=" + charset.displayName(); + return "application/json"; } @Override - public Mapper toMapper(InputStream in) { - return new FastjsonMapper(JSON.parseObject(toString(in))); + public Mapper toMapper(InputStream in, Charset charset) { + return new FastjsonMapper(JSON.parseObject(toString(in, charset))); } @Override - public Array toArray(InputStream in) { - return new FastjsonArray(JSON.parseArray(toString(in))); + public Array toArray(InputStream in, Charset charset) { + return new FastjsonArray(JSON.parseArray(toString(in, charset))); } @Override - public byte[] serialize(Object bean) { + public byte[] serialize(Object bean, Charset charset) { return JSON.toJSONString(bean).getBytes(charset); } @Override - public byte[] serialize(Object bean, String dateFormat) { + public byte[] serialize(Object bean, String dateFormat, Charset charset) { return JSON.toJSONStringWithDateFormat(bean, dateFormat).getBytes(charset); } @Override - public T toBean(Class type, InputStream in) { - return JSON.parseObject(toString(in), type); + public T toBean(Class type, InputStream in, Charset charset) { + return JSON.parseObject(toString(in, charset), type); } @Override - public List toList(Class type, InputStream in) { - return JSON.parseArray(toString(in), type); + public List toList(Class type, InputStream in, Charset charset) { + return JSON.parseArray(toString(in, charset), type); } @Override @@ -63,7 +51,7 @@ public MsgConvertor getConvertor() { return new FastjsonMsgConvertor(); } - private String toString(InputStream in) { + private String toString(InputStream in, Charset charset) { try { return Okio.buffer(Okio.source(in)).readString(charset); } catch (IOException e) { @@ -71,12 +59,4 @@ private String toString(InputStream in) { } } - public Charset getCharset() { - return charset; - } - - public void setCharset(Charset charset) { - this.charset = charset; - } - } diff --git a/okhttps-gson/src/main/java/com/ejlchina/okhttps/GsonMsgConvertor.java b/okhttps-gson/src/main/java/com/ejlchina/okhttps/GsonMsgConvertor.java index 621ce9dd..39943604 100644 --- a/okhttps-gson/src/main/java/com/ejlchina/okhttps/GsonMsgConvertor.java +++ b/okhttps-gson/src/main/java/com/ejlchina/okhttps/GsonMsgConvertor.java @@ -16,49 +16,47 @@ public class GsonMsgConvertor implements MsgConvertor, ConvertProvider { private Gson gson; - private Charset charset; public GsonMsgConvertor() { - this(new Gson(), StandardCharsets.UTF_8); + this(new Gson()); } - public GsonMsgConvertor(Gson gson, Charset charset) { + public GsonMsgConvertor(Gson gson) { this.gson = gson; - this.charset = charset; } @Override public String mediaType() { - return "application/json; charset=" + charset.displayName(); + return "application/json"; } @Override - public Mapper toMapper(InputStream in) { + public Mapper toMapper(InputStream in, Charset charset) { return new GsonMapper(gson.fromJson(new InputStreamReader(in), JsonObject.class)); } @Override - public Array toArray(InputStream in) { + public Array toArray(InputStream in, Charset charset) { return new GsonArray(gson.fromJson(new InputStreamReader(in), JsonArray.class)); } @Override - public byte[] serialize(Object bean) { + public byte[] serialize(Object bean, Charset charset) { return gson.toJson(bean).getBytes(charset); } @Override - public byte[] serialize(Object bean, String dateFormat) { + public byte[] serialize(Object bean, String dateFormat, Charset charset) { return gson.newBuilder().setDateFormat(dateFormat).create().toJson(bean).getBytes(charset); } @Override - public T toBean(Class type, InputStream in) { + public T toBean(Class type, InputStream in, Charset charset) { return gson.fromJson(new InputStreamReader(in), type); } @Override - public List toList(Class type, InputStream in) { + public List toList(Class type, InputStream in, Charset charset) { T[] beans = gson.fromJson(new InputStreamReader(in), TypeToken.getArray(type).getType()); List list = new ArrayList<>(); Collections.addAll(list, beans); diff --git a/okhttps-jackson/src/main/java/com/ejlchina/okhttps/JacksonMsgConvertor.java b/okhttps-jackson/src/main/java/com/ejlchina/okhttps/JacksonMsgConvertor.java index 1ae8579c..85053eb3 100644 --- a/okhttps-jackson/src/main/java/com/ejlchina/okhttps/JacksonMsgConvertor.java +++ b/okhttps-jackson/src/main/java/com/ejlchina/okhttps/JacksonMsgConvertor.java @@ -21,24 +21,21 @@ public class JacksonMsgConvertor implements MsgConvertor, ConvertProvider { private ObjectMapper objectMapper; - private Charset charset; - public JacksonMsgConvertor() { - this(new ObjectMapper(), StandardCharsets.UTF_8); + this(new ObjectMapper()); } - public JacksonMsgConvertor(ObjectMapper objectMapper, Charset charset) { + public JacksonMsgConvertor(ObjectMapper objectMapper) { this.objectMapper = objectMapper; - this.charset = charset; } @Override public String mediaType() { - return "application/json; charset=" + charset.displayName(); + return "application/json"; } @Override - public Mapper toMapper(InputStream in) { + public Mapper toMapper(InputStream in, Charset charset) { try { JsonNode json = objectMapper.readTree(in); if (json.isObject()) { @@ -54,7 +51,7 @@ public Mapper toMapper(InputStream in) { } @Override - public Array toArray(InputStream in) { + public Array toArray(InputStream in, Charset charset) { try { JsonNode json = objectMapper.readTree(in); if (json.isArray()) { @@ -70,7 +67,7 @@ public Array toArray(InputStream in) { } @Override - public byte[] serialize(Object bean) { + public byte[] serialize(Object bean, Charset charset) { try { objectMapper.writeValueAsBytes(bean); return objectMapper.writeValueAsString(bean).getBytes(charset); @@ -80,7 +77,7 @@ public byte[] serialize(Object bean) { } @Override - public byte[] serialize(Object bean, String dateFormat) { + public byte[] serialize(Object bean, String dateFormat, Charset charset) { ObjectMapper mapper = objectMapper.copy(); mapper.configure(SerializationFeature.WRITE_DATES_AS_TIMESTAMPS, false); mapper.setDateFormat(new SimpleDateFormat(dateFormat)); @@ -92,7 +89,7 @@ public byte[] serialize(Object bean, String dateFormat) { } @Override - public T toBean(Class type, InputStream in) { + public T toBean(Class type, InputStream in, Charset charset) { try { return objectMapper.readValue(in, type); } catch (IOException e) { @@ -101,7 +98,7 @@ public T toBean(Class type, InputStream in) { } @Override - public List toList(Class type, InputStream in) { + public List toList(Class type, InputStream in, Charset charset) { CollectionType javaType = objectMapper.getTypeFactory().constructCollectionType(ArrayList.class, type); try { return objectMapper.readValue(in, javaType); @@ -123,11 +120,4 @@ public void setObjectMapper(ObjectMapper objectMapper) { this.objectMapper = objectMapper; } - public Charset getCharset() { - return charset; - } - - public void setCharset(Charset charset) { - this.charset = charset; - } } From 276f0d255215dd7913c8c368bf4e64f0804752ee Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?=E5=91=A8=E6=97=AD?= Date: Mon, 11 May 2020 15:24:15 +0800 Subject: [PATCH 260/924] . --- .../src/main/java/com/ejlchina/okhttps/JacksonMsgConvertor.java | 1 - 1 file changed, 1 deletion(-) diff --git a/okhttps-jackson/src/main/java/com/ejlchina/okhttps/JacksonMsgConvertor.java b/okhttps-jackson/src/main/java/com/ejlchina/okhttps/JacksonMsgConvertor.java index 85053eb3..648321b7 100644 --- a/okhttps-jackson/src/main/java/com/ejlchina/okhttps/JacksonMsgConvertor.java +++ b/okhttps-jackson/src/main/java/com/ejlchina/okhttps/JacksonMsgConvertor.java @@ -69,7 +69,6 @@ public Array toArray(InputStream in, Charset charset) { @Override public byte[] serialize(Object bean, Charset charset) { try { - objectMapper.writeValueAsBytes(bean); return objectMapper.writeValueAsString(bean).getBytes(charset); } catch (JsonProcessingException e) { throw new HttpException("Java Bean [" + bean + "] Jackson 序列化异常", e); From 25f92fee224eccef18226610a32baa610329b7d1 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?=E5=91=A8=E6=97=AD?= Date: Mon, 11 May 2020 15:31:53 +0800 Subject: [PATCH 261/924] =?UTF-8?q?=E4=BC=98=E5=8C=96?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- .../src/main/java/com/ejlchina/okhttps/GsonMsgConvertor.java | 1 - .../main/java/com/ejlchina/okhttps/JacksonMsgConvertor.java | 1 - okhttps/src/main/java/com/ejlchina/okhttps/HTTP.java | 4 ++-- 3 files changed, 2 insertions(+), 4 deletions(-) diff --git a/okhttps-gson/src/main/java/com/ejlchina/okhttps/GsonMsgConvertor.java b/okhttps-gson/src/main/java/com/ejlchina/okhttps/GsonMsgConvertor.java index 39943604..9ef63e93 100644 --- a/okhttps-gson/src/main/java/com/ejlchina/okhttps/GsonMsgConvertor.java +++ b/okhttps-gson/src/main/java/com/ejlchina/okhttps/GsonMsgConvertor.java @@ -3,7 +3,6 @@ import java.io.InputStream; import java.io.InputStreamReader; import java.nio.charset.Charset; -import java.nio.charset.StandardCharsets; import java.util.ArrayList; import java.util.Collections; import java.util.List; diff --git a/okhttps-jackson/src/main/java/com/ejlchina/okhttps/JacksonMsgConvertor.java b/okhttps-jackson/src/main/java/com/ejlchina/okhttps/JacksonMsgConvertor.java index 648321b7..af677f6e 100644 --- a/okhttps-jackson/src/main/java/com/ejlchina/okhttps/JacksonMsgConvertor.java +++ b/okhttps-jackson/src/main/java/com/ejlchina/okhttps/JacksonMsgConvertor.java @@ -3,7 +3,6 @@ import java.io.IOException; import java.io.InputStream; import java.nio.charset.Charset; -import java.nio.charset.StandardCharsets; import java.text.SimpleDateFormat; import java.util.ArrayList; import java.util.List; diff --git a/okhttps/src/main/java/com/ejlchina/okhttps/HTTP.java b/okhttps/src/main/java/com/ejlchina/okhttps/HTTP.java index 5dd03323..db6345a4 100644 --- a/okhttps/src/main/java/com/ejlchina/okhttps/HTTP.java +++ b/okhttps/src/main/java/com/ejlchina/okhttps/HTTP.java @@ -314,11 +314,11 @@ public Builder msgConvertor(MsgConvertor msgConvertor) { } /** - * 设置编码格式 + * 设置默认编码格式 * @param charset 编码 * @return Builder */ - public Builder charset(Charset charset) { + public Builder defaultCharset(Charset charset) { this.charset = charset; return this; } From e4addb1ca8cb025bcbfd024a5d710164ef5355a0 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?=E5=91=A8=E6=97=AD?= Date: Mon, 11 May 2020 21:07:38 +0800 Subject: [PATCH 262/924] =?UTF-8?q?=E4=BC=98=E5=8C=96?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- .../okhttps/FastjsonMsgConvertor.java | 17 ++++++++--- .../ejlchina/okhttps/GsonMsgConvertor.java | 18 +++++++++--- .../ejlchina/okhttps/JacksonMsgConvertor.java | 28 +++++++++++-------- 3 files changed, 43 insertions(+), 20 deletions(-) diff --git a/okhttps-fastjson/src/main/java/com/ejlchina/okhttps/FastjsonMsgConvertor.java b/okhttps-fastjson/src/main/java/com/ejlchina/okhttps/FastjsonMsgConvertor.java index df74d6f4..e226c5f4 100644 --- a/okhttps-fastjson/src/main/java/com/ejlchina/okhttps/FastjsonMsgConvertor.java +++ b/okhttps-fastjson/src/main/java/com/ejlchina/okhttps/FastjsonMsgConvertor.java @@ -27,13 +27,22 @@ public Array toArray(InputStream in, Charset charset) { } @Override - public byte[] serialize(Object bean, Charset charset) { - return JSON.toJSONString(bean).getBytes(charset); + public byte[] serialize(Object object, Charset charset) { + return serialize(object, null, charset); } @Override - public byte[] serialize(Object bean, String dateFormat, Charset charset) { - return JSON.toJSONStringWithDateFormat(bean, dateFormat).getBytes(charset); + public byte[] serialize(Object object, String dateFormat, Charset charset) { + if (object instanceof byte[]) { + return (byte[]) object; + } + if (object instanceof String) { + return object.toString().getBytes(charset); + } + if (dateFormat != null) { + return JSON.toJSONStringWithDateFormat(object, dateFormat).getBytes(charset); + } + return JSON.toJSONString(object).getBytes(charset); } @Override diff --git a/okhttps-gson/src/main/java/com/ejlchina/okhttps/GsonMsgConvertor.java b/okhttps-gson/src/main/java/com/ejlchina/okhttps/GsonMsgConvertor.java index 9ef63e93..045c0096 100644 --- a/okhttps-gson/src/main/java/com/ejlchina/okhttps/GsonMsgConvertor.java +++ b/okhttps-gson/src/main/java/com/ejlchina/okhttps/GsonMsgConvertor.java @@ -40,13 +40,23 @@ public Array toArray(InputStream in, Charset charset) { } @Override - public byte[] serialize(Object bean, Charset charset) { - return gson.toJson(bean).getBytes(charset); + public byte[] serialize(Object object, Charset charset) { + return serialize(object, null, charset); } @Override - public byte[] serialize(Object bean, String dateFormat, Charset charset) { - return gson.newBuilder().setDateFormat(dateFormat).create().toJson(bean).getBytes(charset); + public byte[] serialize(Object object, String dateFormat, Charset charset) { + if (object instanceof byte[]) { + return (byte[]) object; + } + if (object instanceof String) { + return object.toString().getBytes(charset); + } + Gson gson = this.gson; + if (dateFormat != null) { + gson = gson.newBuilder().setDateFormat(dateFormat).create(); + } + return gson.toJson(object).getBytes(charset); } @Override diff --git a/okhttps-jackson/src/main/java/com/ejlchina/okhttps/JacksonMsgConvertor.java b/okhttps-jackson/src/main/java/com/ejlchina/okhttps/JacksonMsgConvertor.java index af677f6e..f9827d81 100644 --- a/okhttps-jackson/src/main/java/com/ejlchina/okhttps/JacksonMsgConvertor.java +++ b/okhttps-jackson/src/main/java/com/ejlchina/okhttps/JacksonMsgConvertor.java @@ -66,23 +66,27 @@ public Array toArray(InputStream in, Charset charset) { } @Override - public byte[] serialize(Object bean, Charset charset) { - try { - return objectMapper.writeValueAsString(bean).getBytes(charset); - } catch (JsonProcessingException e) { - throw new HttpException("Java Bean [" + bean + "] Jackson 序列化异常", e); - } + public byte[] serialize(Object object, Charset charset) { + return serialize(object, null, charset); } @Override - public byte[] serialize(Object bean, String dateFormat, Charset charset) { - ObjectMapper mapper = objectMapper.copy(); - mapper.configure(SerializationFeature.WRITE_DATES_AS_TIMESTAMPS, false); - mapper.setDateFormat(new SimpleDateFormat(dateFormat)); + public byte[] serialize(Object object, String dateFormat, Charset charset) { + if (object instanceof byte[]) { + return (byte[]) object; + } + if (object instanceof String) { + return object.toString().getBytes(charset); + } + ObjectMapper mapper = objectMapper; + if (dateFormat != null) { + mapper = mapper.copy().configure(SerializationFeature.WRITE_DATES_AS_TIMESTAMPS, false) + .setDateFormat(new SimpleDateFormat(dateFormat)); + } try { - return mapper.writeValueAsString(bean).getBytes(charset); + return mapper.writeValueAsString(object).getBytes(charset); } catch (JsonProcessingException e) { - throw new HttpException("Java Bean [" + bean + "] Jackson 序列化异常", e); + throw new HttpException("Java Bean [" + object + "] Jackson 序列化异常", e); } } From 0ac98f1db2608bd1c84ed002dfddca76be3707c9 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?=E5=91=A8=E6=97=AD?= Date: Mon, 11 May 2020 21:21:27 +0800 Subject: [PATCH 263/924] =?UTF-8?q?=E9=87=8D=E6=9E=84?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- .../com/ejlchina/okhttps/ConvertProvider.java | 3 +- .../main/java/com/ejlchina/okhttps/HTTP.java | 64 +++- .../java/com/ejlchina/okhttps/HttpTask.java | 307 ++++++++++++------ .../com/ejlchina/okhttps/MsgConvertor.java | 74 ++++- .../ejlchina/okhttps/internal/HttpClient.java | 20 +- .../okhttps/internal/TaskExecutor.java | 62 +++- 6 files changed, 386 insertions(+), 144 deletions(-) diff --git a/okhttps/src/main/java/com/ejlchina/okhttps/ConvertProvider.java b/okhttps/src/main/java/com/ejlchina/okhttps/ConvertProvider.java index 28dc47ba..1bead6a4 100644 --- a/okhttps/src/main/java/com/ejlchina/okhttps/ConvertProvider.java +++ b/okhttps/src/main/java/com/ejlchina/okhttps/ConvertProvider.java @@ -13,7 +13,8 @@ static void inject(HTTP.Builder builder) { for (ConvertProvider provider : ServiceLoader.load(ConvertProvider.class)) { MsgConvertor convertor = provider.getConvertor(); if (convertor != null) { - builder.msgConvertor(convertor); + builder.addMsgConvertor(new MsgConvertor.FormMsgConvertor(convertor)); + builder.addMsgConvertor(convertor); } } } diff --git a/okhttps/src/main/java/com/ejlchina/okhttps/HTTP.java b/okhttps/src/main/java/com/ejlchina/okhttps/HTTP.java index db6345a4..73194ba9 100644 --- a/okhttps/src/main/java/com/ejlchina/okhttps/HTTP.java +++ b/okhttps/src/main/java/com/ejlchina/okhttps/HTTP.java @@ -127,12 +127,14 @@ class Builder { private TaskListener completeListener; - private MsgConvertor msgConvertor; + private List msgConvertors; private int preprocTimeoutTimes = 10; private Charset charset = StandardCharsets.UTF_8; + private String bodyType = "json"; + public Builder() { mediaTypes = new HashMap<>(); mediaTypes.put("*", "application/octet-stream"); @@ -150,6 +152,7 @@ public Builder() { mediaTypes.put("pdf", "application/pdf"); mediaTypes.put("html", "text/html"); preprocessors = new ArrayList<>(); + msgConvertors = new ArrayList<>(); } public Builder(HttpClient hc) { @@ -163,9 +166,11 @@ public Builder(HttpClient hc) { this.responseListener = executor.getResponseListener(); this.exceptionListener = executor.getExceptionListener(); this.completeListener = executor.getCompleteListener(); - this.msgConvertor = executor.getMsgConvertor(); + this.msgConvertors = new ArrayList<>(); + Collections.addAll(this.msgConvertors, executor.getMsgConvertors()); this.preprocTimeoutTimes = hc.preprocTimeoutTimes(); this.charset = hc.charset(); + this.bodyType = hc.bodyType(); } /** @@ -197,7 +202,9 @@ public Builder baseUrl(String baseUrl) { * @return Builder */ public Builder mediaTypes(Map mediaTypes) { - this.mediaTypes.putAll(mediaTypes); + if (mediaTypes != null) { + this.mediaTypes.putAll(mediaTypes); + } return this; } @@ -209,7 +216,9 @@ public Builder mediaTypes(Map mediaTypes) { * @return Builder */ public Builder mediaTypes(String key, String value) { - this.mediaTypes.put(key, value); + if (key != null && value != null) { + this.mediaTypes.put(key, value); + } return this; } @@ -231,7 +240,9 @@ public Builder callbackExecutor(Executor executor) { * @return Builder */ public Builder addPreprocessor(Preprocessor preprocessor) { - preprocessors.add(preprocessor); + if (preprocessor != null) { + preprocessors.add(preprocessor); + } return this; } @@ -242,7 +253,9 @@ public Builder addPreprocessor(Preprocessor preprocessor) { * @return Builder */ public Builder addSerialPreprocessor(Preprocessor preprocessor) { - preprocessors.add(new HttpClient.SerialPreprocessor(preprocessor)); + if (preprocessor != null) { + preprocessors.add(new HttpClient.SerialPreprocessor(preprocessor)); + } return this; } @@ -304,22 +317,41 @@ public Builder downloadListener(DownListener listener) { } /** - * 设置消息转换器 + * @since 2.0.0 + * 添加消息转换器 * @param msgConvertor JSON 服务 * @return Builder */ - public Builder msgConvertor(MsgConvertor msgConvertor) { - this.msgConvertor = msgConvertor; + public Builder addMsgConvertor(MsgConvertor msgConvertor) { + if (msgConvertor != null) { + this.msgConvertors.add(msgConvertor); + } return this; } /** + * @since 2.0.0 * 设置默认编码格式 * @param charset 编码 * @return Builder */ public Builder defaultCharset(Charset charset) { - this.charset = charset; + if (charset != null) { + this.charset = charset; + } + return this; + } + + /** + * @since 2.0.0 + * 设置默认请求体类型 + * @param bodyType 请求体类型 + * @return Builder + */ + public Builder defaultBodyType(String bodyType) { + if (bodyType != null) { + this.bodyType = bodyType; + } return this; } @@ -354,8 +386,8 @@ public Executor mainExecutor() { return mainExecutor; } - public List preprocessors() { - return preprocessors; + public Preprocessor[] preprocessors() { + return preprocessors.toArray(new Preprocessor[0]); } public DownListener downloadListener() { @@ -374,8 +406,8 @@ public TaskListener completeListener() { return completeListener; } - public MsgConvertor msgConvertor() { - return msgConvertor; + public MsgConvertor[] msgConvertors() { + return msgConvertors.toArray(new MsgConvertor[0]); } public int preprocTimeoutTimes() { @@ -386,6 +418,10 @@ public Charset charset() { return charset; } + public String bodyType() { + return bodyType; + } + } } diff --git a/okhttps/src/main/java/com/ejlchina/okhttps/HttpTask.java b/okhttps/src/main/java/com/ejlchina/okhttps/HttpTask.java index 4b4f626c..6fdf4b9a 100644 --- a/okhttps/src/main/java/com/ejlchina/okhttps/HttpTask.java +++ b/okhttps/src/main/java/com/ejlchina/okhttps/HttpTask.java @@ -9,17 +9,13 @@ import java.net.UnknownHostException; import java.nio.charset.Charset; import java.util.HashMap; -import java.util.Iterator; import java.util.Map; import java.util.concurrent.CountDownLatch; import java.util.concurrent.TimeUnit; import com.ejlchina.okhttps.HttpResult.State; -import com.ejlchina.okhttps.internal.HttpClient; +import com.ejlchina.okhttps.internal.*; import com.ejlchina.okhttps.internal.HttpClient.TagTask; -import com.ejlchina.okhttps.internal.HttpException; -import com.ejlchina.okhttps.internal.ProcessRequestBody; -import com.ejlchina.okhttps.internal.RealHttpResult; import okhttp3.*; import okhttp3.internal.Util; @@ -43,9 +39,10 @@ public abstract class HttpTask> implements Cancelable { private Map pathParams; private Map urlParams; private Map bodyParams; - private Map jsonParams; private Map files; - private byte[] requestJson; + private Object requestBody; + private String dateFormat; + private String bodyType; private OnCallback onProcess; private boolean pOnIO; private long stepBytes = 0; @@ -55,14 +52,17 @@ public abstract class HttpTask> implements Cancelable { private TagTask tagTask; private Cancelable canceler; + private Charset charset; protected boolean skipPreproc = false; protected boolean skipSerialPreproc = false; - - + + public HttpTask(HttpClient httpClient, String url) { - this.httpClient = httpClient; this.urlPath = url; + this.httpClient = httpClient; + this.charset = httpClient.charset(); + this.bodyType = httpClient.bodyType(); } /** @@ -137,14 +137,19 @@ public C skipSerialPreproc() { this.skipSerialPreproc = true; return (C) this; } - + + @Deprecated + public C setTag(String tag) { + return tag(tag); + } + /** + * @since 2.2.0 * 为请求任务添加标签 - * v1.0.4 之后，若 set 多次，标签将连接在一起 * @param tag 标签 * @return HttpTask 实例 */ - public C setTag(String tag) { + public C tag(String tag) { if (tag != null) { if (this.tag != null) { this.tag = this.tag + "." + tag; @@ -155,7 +160,33 @@ public C setTag(String tag) { } return (C) this; } - + + /** + * @since 2.0.0 + * 设置该请求的编码格式 + * @param charset 编码格式 + * @return HttpTask 实例 + */ + public C charset(Charset charset) { + if (charset != null) { + this.charset = charset; + } + return (C) this; + } + + /** + * @since 2.0.0 + * 设置请求体的类型，如：form、json、xml、protobuf 等，默认为 form + * @param type 请求类型 + * @return HttpTask 实例 + */ + public C bodyType(String type) { + if (type != null) { + this.bodyType = type; + } + return (C) this; + } + /** * 下一个回调在IO线程执行 * @return HttpTask 实例 @@ -261,13 +292,18 @@ public C setStepRate(double stepRate) { return (C) this; } + @Deprecated + public C addPathParam(String name, Object value) { + return addPathPara(name, value); + } + /** * 路径参数：替换URL里的{name} * @param name 参数名 * @param value 参数值 * @return HttpTask 实例 **/ - public C addPathParam(String name, Object value) { + public C addPathPara(String name, Object value) { if (name != null && value != null) { if (pathParams == null) { pathParams = new HashMap<>(); @@ -277,12 +313,17 @@ public C addPathParam(String name, Object value) { return (C) this; } + @Deprecated + public C addPathParam(Map params) { + return addPathPara(params); + } + /** * 路径参数：替换URL里的{name} * @param params 参数集合 * @return HttpTask 实例 **/ - public C addPathParam(Map params) { + public C addPathPara(Map params) { if (pathParams == null) { pathParams = new HashMap<>(); } @@ -290,13 +331,18 @@ public C addPathParam(Map params) { return (C) this; } + @Deprecated + public C addUrlParam(String name, Object value) { + return addUrlPara(name, value); + } + /** * URL参数：拼接在URL后的参数 * @param name 参数名 * @param value 参数值 * @return HttpTask 实例 **/ - public C addUrlParam(String name, Object value) { + public C addUrlPara(String name, Object value) { if (name != null && value != null) { if (urlParams == null) { urlParams = new HashMap<>(); @@ -306,12 +352,17 @@ public C addUrlParam(String name, Object value) { return (C) this; } + @Deprecated + public C addUrlParam(Map params) { + return addUrlPara(params); + } + /** * URL参数：拼接在URL后的参数 * @param params 参数集合 * @return HttpTask 实例 **/ - public C addUrlParam(Map params) { + public C addUrlPara(Map params) { if (urlParams == null) { urlParams = new HashMap<>(); } @@ -319,13 +370,18 @@ public C addUrlParam(Map params) { return (C) this; } + @Deprecated + public C addBodyParam(String name, Object value) { + return addBodyPara(name, value); + } + /** * Body参数：放在Body里的参数 * @param name 参数名 * @param value 参数值 * @return HttpTask 实例 **/ - public C addBodyParam(String name, Object value) { + public C addBodyPara(String name, Object value) { if (name != null && value != null) { if (bodyParams == null) { bodyParams = new HashMap<>(); @@ -335,12 +391,17 @@ public C addBodyParam(String name, Object value) { return (C) this; } + @Deprecated + public C addBodyParam(Map params) { + return addBodyPara(params); + } + /** * Body参数：放在Body里的参数 * @param params 参数集合 * @return HttpTask 实例 **/ - public C addBodyParam(Map params) { + public C addBodyPara(Map params) { if (bodyParams == null) { bodyParams = new HashMap<>(); } @@ -350,9 +411,7 @@ public C addBodyParam(Map params) { private void doAddParams(Map taskParams, Map params) { if (params != null) { - Iterator it = params.keySet().iterator(); - while (it.hasNext()) { - String name = it.next(); + for (String name : params.keySet()) { Object value = params.get(name); if (name != null && value != null) { taskParams.put(name, value.toString()); @@ -362,77 +421,85 @@ private void doAddParams(Map taskParams, Map params) } /** + * 推荐方案：setBodyParam 与 bodyType 方法 * Json参数：请求体为Json，支持多层结构 * @param name JSON键名 * @param value JSON键值 * @return HttpTask 实例 */ + @Deprecated public C addJsonParam(String name, Object value) { - if (name != null && value != null) { - if (jsonParams == null) { - jsonParams = new HashMap<>(); - } - jsonParams.put(name, value); - } - return (C) this; + this.bodyType = "json"; + return addBodyPara(name, value); } /** + * 推荐方案：setBodyParam 与 bodyType 方法 * Json参数：请求体为Json，只支持单层Json * 若请求json为多层结构，请使用setRequestJson方法 * @param params JSON键值集合 * @return HttpTask 实例 */ + @Deprecated public C addJsonParam(Map params) { - if (params != null) { - if (jsonParams == null) { - jsonParams = new HashMap<>(); - } - jsonParams.putAll(params); - } - return (C) this; + this.bodyType = "json"; + return addBodyPara(params); } /** + * 推荐方案：setBodyPara 与 bodyType 方法 * 设置 json 请求体 - * @param json JSON字符串 或 Java对象（将依据 对象的get方法序列化为 json 字符串） + * @param body JSON字符串 或 Java对象（将依据 对象的get方法序列化为 json 字符串） * @return HttpTask 实例 **/ - public C setRequestJson(Object json) { - return setRequestJson(json, null); + @Deprecated + public C setRequestJson(Object body) { + this.bodyType = "json"; + return setBodyPara(body); } /** - * 请求体为json - * @param json JSON字符串 或 Java对象，将跟换 bean的get方法序列化程 json 字符串 - * @param dateFormat 序列化json时对日期类型字段的处理格式 + * 此方法性能较低 + * 推荐方案：setBodyPara 与 bodyType 方法，日期格式在 Java Bean 上使用注解的方式指定 + * @param body Json 请求体 + * @param dateFormat 日期格式 + * @return HttpTask 实例 + */ + @Deprecated + public C setRequestJson(Object body, String dateFormat) { + this.bodyType = "json"; + this.dateFormat = dateFormat; + return setBodyPara(body); + } + + /** + * 设置 json 请求体 + * @param body 请求体，字节数组、字符串 或 Java对象（由 MsgConvertor 来序列化） * @return HttpTask 实例 **/ - public C setRequestJson(Object json, String dateFormat) { - if (json != null) { - if (json instanceof byte[]) { - requestJson = (byte[]) json; - } else if (json instanceof String) { - requestJson = json.toString().getBytes(httpClient.charset()); - } else if (dateFormat != null) { - requestJson = httpClient.executor().convertor() - .serialize(json, dateFormat, httpClient.charset()); - } else { - requestJson = httpClient.executor().convertor() - .serialize(json, httpClient.charset()); - } - } + public C setBodyPara(Object body) { + this.requestBody = body; return (C) this; } + @Deprecated + public C addFileParam(String name, String filePath) { + return addFilePara(name, filePath); + } + /** * 添加文件参数 * @param name 参数名 * @param filePath 文件路径 * @return HttpTask 实例 */ - public C addFileParam(String name, String filePath) { - return addFileParam(name, new File(filePath)); + public C addFilePara(String name, String filePath) { + return addFilePara(name, new File(filePath)); + } + + @Deprecated + public C addFileParam(String name, File file) { + return addFilePara(name, file); } /** @@ -441,7 +508,7 @@ public C addFileParam(String name, String filePath) { * @param file 文件 * @return HttpTask 实例 */ - public C addFileParam(String name, File file) { + public C addFilePara(String name, File file) { if (name != null && file != null && file.exists()) { String fileName = file.getName(); String type = fileName.substring(fileName.lastIndexOf(".") + 1); @@ -454,17 +521,20 @@ public C addFileParam(String name, File file) { } /** + * 建议直接使用文件上传，使用输入流性能较差 * 添加文件参数 * @param name 参数名 * @param type 文件类型: 如 png、jpg、jpeg 等 * @param inputStream 文件输入流 * @return HttpTask 实例 */ + @Deprecated public C addFileParam(String name, String type, InputStream inputStream) { return addFileParam(name, type, null, inputStream); } /** + * 建议直接使用文件上传，使用输入流性能较差 * 添加文件参数 * @param name 参数名 * @param type 文件类型: 如 png、jpg、jpeg 等 @@ -472,6 +542,7 @@ public C addFileParam(String name, String type, InputStream inputStream) { * @param input 文件输入流 * @return HttpTask 实例 */ + @Deprecated public C addFileParam(String name, String type, String fileName, InputStream input) { if (name != null && input != null) { byte[] content = null; @@ -484,11 +555,16 @@ public C addFileParam(String name, String type, String fileName, InputStream inp } finally { Util.closeQuietly(input); } - addFileParam(name, type, fileName, content); + addFilePara(name, type, fileName, content); } return (C) this; } + @Deprecated + public C addFileParam(String name, String type, byte[] content) { + return addFilePara(name, type, content); + } + /** * 添加文件参数 * @param name 参数名 @@ -496,8 +572,13 @@ public C addFileParam(String name, String type, String fileName, InputStream inp * @param content 文件内容 * @return HttpTask 实例 */ - public C addFileParam(String name, String type, byte[] content) { - return addFileParam(name, type, null, content); + public C addFilePara(String name, String type, byte[] content) { + return addFilePara(name, type, null, content); + } + + @Deprecated + public C addFileParam(String name, String type, String fileName, byte[] content) { + return addFilePara(name, type, fileName, content); } /** @@ -508,7 +589,7 @@ public C addFileParam(String name, String type, byte[] content) { * @param content 文件内容 * @return HttpTask 实例 */ - public C addFileParam(String name, String type, String fileName, byte[] content) { + public C addFilePara(String name, String type, String fileName, byte[] content) { if (name != null && content != null) { if (files == null) { files = new HashMap<>(); @@ -648,16 +729,38 @@ protected State toState(IOException e, boolean sync) { return State.EXCEPTION; } - private RequestBody buildRequestBody() { - if (jsonParams != null) { - requestJson = httpClient.executor().convertor() - .serialize(jsonParams, httpClient.charset()); + + /** + * 请求体为json + * @param body JSON字符串 或 Java对象，将跟换 bean的get方法序列化程 json 字符串 + * @return HttpTask 实例 + **/ + public C setBodyParaxxx(Object body) { + if (bodyType == null) { + throw new IllegalArgumentException("type can not be null"); + } + if (body != null) { + if (body instanceof byte[]) { + requestBody = body; + } else if (body instanceof String) { + requestBody = body.toString().getBytes(charset); + } else if (dateFormat != null) { + requestBody = httpClient.executor().doMsgConvert(bodyType, (MsgConvertor c) -> + c.serialize(body, dateFormat, charset)); + } else { + requestBody = httpClient.executor().doMsgConvert(bodyType, (MsgConvertor c) -> + c.serialize(body, charset)); + } } + return (C) this; + } + + private RequestBody buildRequestBody() { if (files != null) { MultipartBody.Builder builder = new MultipartBody.Builder().setType(MultipartBody.FORM); if (bodyParams != null) { for (String name : bodyParams.keySet()) { - byte[] value = bodyParams.get(name).getBytes(httpClient.charset()); + byte[] value = bodyParams.get(name).getBytes(charset); RequestBody body = RequestBody.create(null, value); builder.addPart(MultipartBody.Part.createFormData(name, null, body)); } @@ -674,18 +777,34 @@ private RequestBody buildRequestBody() { builder.addFormDataPart(name, file.fileName, bodyPart); } return builder.build(); - } else if (requestJson != null) { - return RequestBody.create(httpClient.mapperType(), requestJson); - } else { - FormBody.Builder builder = new FormBody.Builder(httpClient.charset()); - if (bodyParams != null) { - for (String name : bodyParams.keySet()) { - String value = bodyParams.get(name); - builder.add(name, value); - } + } + if (requestBody != null) { + return toRequestBody(requestBody); + } + if (bodyParams == null) { + return new FormBody.Builder(charset).build(); + } + if (bodyType.toLowerCase().contains("form")) { + FormBody.Builder builder = new FormBody.Builder(charset); + for (String name : bodyParams.keySet()) { + String value = bodyParams.get(name); + builder.add(name, value); } return builder.build(); } + return toRequestBody(bodyParams); + } + + private RequestBody toRequestBody(Object object) { + TaskExecutor.Data data = httpClient.executor() + .doMsgConvert(bodyType, (MsgConvertor c) + -> c.serialize(object, dateFormat, charset)); + byte[] body = data.data; + String mediaType = data.mediaType; + if (mediaType == null) { + mediaType = "application/json"; + } + return RequestBody.create(MediaType.parse(mediaType + "; charset=" + charset.name()), body); } private String buildUrlPath() { @@ -735,37 +854,26 @@ private String buildUrl(String url) { protected void assertNotConflict(boolean isGetRequest) { if (isGetRequest) { - if (requestJson != null) { - throw new HttpException("GET 请求 不能调用 setRequestJson 方法！"); - } - if (jsonParams != null) { - throw new HttpException("GET 请求 不能调用 addJsonParam 方法！"); + if (requestBody != null) { + throw new HttpException("GET 请求 不能调用 setBodyPara 方法！"); } if (bodyParams != null) { - throw new HttpException("GET 请求 不能调用 addBodyParam 方法！"); + throw new HttpException("GET 请求 不能调用 addBodyPara 方法！"); } if (files != null) { - throw new HttpException("GET 请求 不能调用 addFileParam 方法！"); + throw new HttpException("GET 请求 不能调用 addFilePara 方法！"); } } - if (requestJson != null) { - if (jsonParams != null) { - throw new HttpException("方法 addJsonParam 与 setRequestJson 不能同时调用！"); - } + if (requestBody != null) { if (bodyParams != null) { - throw new HttpException("方法 addBodyParam 与 setRequestJson 不能同时调用！"); + throw new HttpException("方法 addBodyPara 与 setBodyPara 不能同时调用！"); } if (files != null) { - throw new HttpException("方法 addFileParam 与 setRequestJson 不能同时调用！"); + throw new HttpException("方法 addFilePara 与 setBodyPara 不能同时调用！"); } } - if (jsonParams != null) { - if (bodyParams != null) { - throw new HttpException("方法 addBodyParam 与 addJsonParam 不能同时调用！"); - } - if (files != null) { - throw new HttpException("方法 addFileParam 与 addJsonParam 不能同时调用！"); - } + if (files != null && "form".equals(bodyType)) { + throw new HttpException("方法 addFilePara 只能使用 form 方式请求！"); } } @@ -792,8 +900,7 @@ protected HttpResult timeoutResult() { public Charset charset(Response response) { ResponseBody b = response.body(); MediaType type = b != null ? b.contentType() : null; - Charset defaultCharset = httpClient.charset(); - return type != null ? type.charset(defaultCharset) : defaultCharset; + return type != null ? type.charset(charset) : charset; } } diff --git a/okhttps/src/main/java/com/ejlchina/okhttps/MsgConvertor.java b/okhttps/src/main/java/com/ejlchina/okhttps/MsgConvertor.java index 8d102f66..9b1251c7 100644 --- a/okhttps/src/main/java/com/ejlchina/okhttps/MsgConvertor.java +++ b/okhttps/src/main/java/com/ejlchina/okhttps/MsgConvertor.java @@ -1,5 +1,6 @@ package com.ejlchina.okhttps; +import java.io.ByteArrayInputStream; import java.io.InputStream; import java.nio.charset.Charset; import java.util.List; @@ -19,7 +20,7 @@ public interface MsgConvertor { * 解析 Mapper * @param in JSON 输入流 * @param charset 编码格式 - * @return JsonObj + * @return Mapper */ Mapper toMapper(InputStream in, Charset charset); @@ -27,26 +28,26 @@ public interface MsgConvertor { * 解析 Array * @param in JSON 输入流 * @param charset 编码格式 - * @return JsonArr + * @return Array */ Array toArray(InputStream in, Charset charset); /** * 将 Java 对象序列化为字节数组 - * @param bean Java Bean + * @param object Java 对象 * @param charset 编码格式 * @return 字节数组 */ - byte[] serialize(Object bean, Charset charset); + byte[] serialize(Object object, Charset charset); /** * 将 Java 对象序列化为字节数组 - * @param bean Java Bean + * @param object Java 对象 * @param dateFormat 日期类的处理格式 * @param charset 编码格式 * @return 字节数组 */ - byte[] serialize(Object bean, String dateFormat, Charset charset); + byte[] serialize(Object object, String dateFormat, Charset charset); /** * 解析 Java Bean @@ -68,4 +69,65 @@ public interface MsgConvertor { */ List toList(Class type, InputStream in, Charset charset); + + class FormMsgConvertor implements MsgConvertor { + + MsgConvertor convertor; + + public FormMsgConvertor(MsgConvertor convertor) { + this.convertor = convertor; + } + + @Override + public String mediaType() { + return "application/x-www-form-urlencoded"; + } + + @Override + public Mapper toMapper(InputStream in, Charset charset) { + return convertor.toMapper(in, charset); + } + + @Override + public Array toArray(InputStream in, Charset charset) { + return convertor.toArray(in, charset); + } + + @Override + public byte[] serialize(Object object, Charset charset) { + return serialize(object, null, charset); + } + + @Override + public byte[] serialize(Object object, String dateFormat, Charset charset) { + if (object instanceof byte[]) { + return (byte[]) object; + } + if (object instanceof String) { + return object.toString().getBytes(charset); + } + byte[] data = convertor.serialize(object, dateFormat, charset); + Mapper mapper = convertor.toMapper(new ByteArrayInputStream(data), charset); + StringBuilder sb = new StringBuilder(); + for (String key: mapper.keySet()) { + sb.append(key).append('=').append(mapper.getString(key)).append('&'); + } + if (sb.length() > 1) { + sb.deleteCharAt(sb.length() - 1); + } + return sb.toString().getBytes(charset); + } + + @Override + public T toBean(Class type, InputStream in, Charset charset) { + return convertor.toBean(type, in, charset); + } + + @Override + public List toList(Class type, InputStream in, Charset charset) { + return convertor.toList(type, in, charset); + } + + } + } diff --git a/okhttps/src/main/java/com/ejlchina/okhttps/internal/HttpClient.java b/okhttps/src/main/java/com/ejlchina/okhttps/internal/HttpClient.java index 480b3e13..ca2f33ed 100644 --- a/okhttps/src/main/java/com/ejlchina/okhttps/internal/HttpClient.java +++ b/okhttps/src/main/java/com/ejlchina/okhttps/internal/HttpClient.java @@ -26,27 +26,22 @@ public class HttpClient implements HTTP { final int preprocTimeoutTimes; // 编码格式 final Charset charset; - // Mapper的媒体类型 - final MediaType mapperType; + // 默认的请求体类型 + final String bodyType; public HttpClient(Builder builder) { this.okClient = builder.okClient(); this.baseUrl = builder.baseUrl(); this.mediaTypes = builder.getMediaTypes(); - MsgConvertor convertor = builder.msgConvertor(); this.executor = new TaskExecutor(okClient.dispatcher().executorService(), builder.mainExecutor(), builder.downloadListener(), builder.responseListener(), builder.exceptionListener(), - builder.completeListener(), convertor); - this.preprocessors = builder.preprocessors().toArray(new Preprocessor[0]); + builder.completeListener(), builder.msgConvertors()); + this.preprocessors = builder.preprocessors(); this.preprocTimeoutTimes = builder.preprocTimeoutTimes(); this.charset = builder.charset(); + this.bodyType = builder.bodyType(); this.tagTasks = new LinkedList<>(); - String mediaType = convertor != null ? convertor.mediaType() : null; - if (mediaType == null) { - mediaType = "application/json"; - } - this.mapperType = MediaType.parse(mediaType + "; charset=" + charset.name()); } @Override @@ -368,8 +363,9 @@ public Charset charset() { return charset; } - public MediaType mapperType() { - return mapperType; + public String bodyType() { + return bodyType; } + } diff --git a/okhttps/src/main/java/com/ejlchina/okhttps/internal/TaskExecutor.java b/okhttps/src/main/java/com/ejlchina/okhttps/internal/TaskExecutor.java index 859a40a9..efc4e41a 100644 --- a/okhttps/src/main/java/com/ejlchina/okhttps/internal/TaskExecutor.java +++ b/okhttps/src/main/java/com/ejlchina/okhttps/internal/TaskExecutor.java @@ -14,7 +14,6 @@ import com.ejlchina.okhttps.OnCallback; import com.ejlchina.okhttps.TaskListener; import com.ejlchina.okhttps.HttpResult.State; -import okhttp3.MediaType; public class TaskExecutor { @@ -24,18 +23,18 @@ public class TaskExecutor { private TaskListener responseListener; private TaskListener exceptionListener; private TaskListener completeListener; - private MsgConvertor msgConvertor; + private MsgConvertor[] msgConvertors; public TaskExecutor(Executor ioExecutor, Executor mainExecutor, DownListener downloadListener, TaskListener responseListener, TaskListener exceptionListener, - TaskListener completeListener, MsgConvertor msgConvertor) { + TaskListener completeListener, MsgConvertor[] msgConvertors) { this.ioExecutor = ioExecutor; this.mainExecutor = mainExecutor; this.downloadListener = downloadListener; this.responseListener = responseListener; this.exceptionListener = exceptionListener; this.completeListener = completeListener; - this.msgConvertor = msgConvertor; + this.msgConvertors = msgConvertors; } public Executor getExecutor(boolean onIoThread) { @@ -100,11 +99,52 @@ public void executeOnComplete(HttpTask task, OnCallback onComplete, St } } - public MsgConvertor convertor() { - if (msgConvertor != null) { - return msgConvertor; - } - throw new IllegalStateException("没有设置 MsgConvertor，不可做转换操作！"); + public interface ConvertFunc { + + T apply(MsgConvertor convertor); + + } + + public static class Data { + + public T data; + public String mediaType; + + public Data(T data, String mediaType) { + this.data = data; + this.mediaType = mediaType; + } + } + + public Data doMsgConvert(String type, ConvertFunc callable) { + Throwable cause = null; + for (int i = msgConvertors.length - 1; i >= 0; i--) { + MsgConvertor convertor = msgConvertors[i]; + String mediaType = convertor.mediaType(); + if (mediaType == null || !mediaType.contains(type)) { + continue; + } + try { + return new Data<>(callable.apply(convertor), mediaType); + } catch (Exception e) { + if (cause != null) { + initRootCause(e, cause); + } + cause = e; + } + } + if (cause != null) { + throw new HttpException("转换失败", cause); + } + throw new HttpException("没有匹配[" + type + "]类型的转换器！"); + } + + private void initRootCause(Throwable throwable, Throwable cause) { + Throwable lastCause = throwable.getCause(); + if (lastCause != null) { + initRootCause(lastCause, cause); + } + throwable.initCause(cause); } /** @@ -144,8 +184,8 @@ public TaskListener getCompleteListener() { return completeListener; } - public MsgConvertor getMsgConvertor() { - return msgConvertor; + public MsgConvertor[] getMsgConvertors() { + return msgConvertors; } } From 5ba46343bd01c7372b53e5d5bef5d6eda37cec49 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?=E5=91=A8=E6=97=AD?= Date: Mon, 11 May 2020 21:24:44 +0800 Subject: [PATCH 264/924] . --- okhttps/src/main/java/com/ejlchina/okhttps/HttpTask.java | 6 +++--- 1 file changed, 3 insertions(+), 3 deletions(-) diff --git a/okhttps/src/main/java/com/ejlchina/okhttps/HttpTask.java b/okhttps/src/main/java/com/ejlchina/okhttps/HttpTask.java index 6fdf4b9a..32794ded 100644 --- a/okhttps/src/main/java/com/ejlchina/okhttps/HttpTask.java +++ b/okhttps/src/main/java/com/ejlchina/okhttps/HttpTask.java @@ -176,7 +176,7 @@ public C charset(Charset charset) { /** * @since 2.0.0 - * 设置请求体的类型，如：form、json、xml、protobuf 等，默认为 form + * 设置请求体的类型，如：form、json、xml、protobuf 等 * @param type 请求类型 * @return HttpTask 实例 */ @@ -421,7 +421,7 @@ private void doAddParams(Map taskParams, Map params) } /** - * 推荐方案：setBodyParam 与 bodyType 方法 + * 推荐方案：setBodyPara 与 bodyType 方法 * Json参数：请求体为Json，支持多层结构 * @param name JSON键名 * @param value JSON键值 @@ -434,7 +434,7 @@ public C addJsonParam(String name, Object value) { } /** - * 推荐方案：setBodyParam 与 bodyType 方法 + * 推荐方案：setBodyPara 与 bodyType 方法 * Json参数：请求体为Json，只支持单层Json * 若请求json为多层结构，请使用setRequestJson方法 * @param params JSON键值集合 From c308475dc2af42b29ee32731ea7943638a909bf7 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?=E5=91=A8=E6=97=AD?= <15735559897@qq.com> Date: Tue, 12 May 2020 00:03:25 +0800 Subject: [PATCH 265/924] =?UTF-8?q?=E9=87=8D=E6=9E=84?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- .../java/com/ejlchina/okhttps/HttpTask.java | 45 +++-------- .../java/com/ejlchina/okhttps/WebSocket.java | 34 +------- .../okhttps/internal/AbstractBody.java | 12 +-- .../okhttps/internal/MessageBody.java | 9 ++- .../okhttps/internal/TaskExecutor.java | 15 +++- .../okhttps/internal/WebSocketTask.java | 79 +++++++------------ 6 files changed, 66 insertions(+), 128 deletions(-) diff --git a/okhttps/src/main/java/com/ejlchina/okhttps/HttpTask.java b/okhttps/src/main/java/com/ejlchina/okhttps/HttpTask.java index 32794ded..627044f3 100644 --- a/okhttps/src/main/java/com/ejlchina/okhttps/HttpTask.java +++ b/okhttps/src/main/java/com/ejlchina/okhttps/HttpTask.java @@ -81,6 +81,10 @@ public String getTag() { return tag; } + public String getBodyType() { + return bodyType; + } + /** * 标签匹配 * 判断任务标签与指定的标签是否匹配（包含指定的标签） @@ -729,32 +733,6 @@ protected State toState(IOException e, boolean sync) { return State.EXCEPTION; } - - /** - * 请求体为json - * @param body JSON字符串 或 Java对象，将跟换 bean的get方法序列化程 json 字符串 - * @return HttpTask 实例 - **/ - public C setBodyParaxxx(Object body) { - if (bodyType == null) { - throw new IllegalArgumentException("type can not be null"); - } - if (body != null) { - if (body instanceof byte[]) { - requestBody = body; - } else if (body instanceof String) { - requestBody = body.toString().getBytes(charset); - } else if (dateFormat != null) { - requestBody = httpClient.executor().doMsgConvert(bodyType, (MsgConvertor c) -> - c.serialize(body, dateFormat, charset)); - } else { - requestBody = httpClient.executor().doMsgConvert(bodyType, (MsgConvertor c) -> - c.serialize(body, charset)); - } - } - return (C) this; - } - private RequestBody buildRequestBody() { if (files != null) { MultipartBody.Builder builder = new MultipartBody.Builder().setType(MultipartBody.FORM); @@ -796,15 +774,14 @@ private RequestBody buildRequestBody() { } private RequestBody toRequestBody(Object object) { + if (object instanceof byte[] || object instanceof String) { + String mediaType = httpClient.executor().doMsgConvert(bodyType, null).mediaType; + byte[] body = object instanceof byte[] ? (byte[]) object : ((String) object).getBytes(charset); + return RequestBody.create(MediaType.parse(mediaType + "; charset=" + charset.name()), body); + } TaskExecutor.Data data = httpClient.executor() - .doMsgConvert(bodyType, (MsgConvertor c) - -> c.serialize(object, dateFormat, charset)); - byte[] body = data.data; - String mediaType = data.mediaType; - if (mediaType == null) { - mediaType = "application/json"; - } - return RequestBody.create(MediaType.parse(mediaType + "; charset=" + charset.name()), body); + .doMsgConvert(bodyType, (MsgConvertor c) -> c.serialize(object, dateFormat, charset)); + return RequestBody.create(MediaType.parse(data.mediaType + "; charset=" + charset.name()), data.data); } private String buildUrlPath() { diff --git a/okhttps/src/main/java/com/ejlchina/okhttps/WebSocket.java b/okhttps/src/main/java/com/ejlchina/okhttps/WebSocket.java index bdd16b3c..3fb62071 100644 --- a/okhttps/src/main/java/com/ejlchina/okhttps/WebSocket.java +++ b/okhttps/src/main/java/com/ejlchina/okhttps/WebSocket.java @@ -117,40 +117,10 @@ interface Listener { long queueSize(); /** - * 同 {@link okhttp3.WebSocket#send(String)} - * @param text 文本数据 - * @return 是否可以发送 - */ - boolean send(String text); - - /** - * 同 {@link okhttp3.WebSocket#send(ByteString)} - * @param bytes 二进制数据 - * @return 是否可以发送 - */ - boolean send(ByteString bytes); - - /** - * 以JSON文本格式发送对象消息 - * @param bean 待发送的对象 - * @return 如果连接已断开 返回 false - */ - boolean send(Object bean); - - /** - * 以JSON文本格式发送对象消息 - * @param bean 待发送的对象 - * @param dateFormat 日期类型字段的处理格式 - * @return 如果连接已断开 返回 false - */ - boolean send(Object bean, String dateFormat); - - /** - * 发送字节流 - * @param data 待发送的数据 + * @param object 待发送的对象，可以是 String | ByteString | byte[] | Java Bean * @return 如果连接已断开 返回 false */ - boolean send(byte[] data); + boolean send(Object object); /** * 同 {@link okhttp3.WebSocket#close(int, String)} diff --git a/okhttps/src/main/java/com/ejlchina/okhttps/internal/AbstractBody.java b/okhttps/src/main/java/com/ejlchina/okhttps/internal/AbstractBody.java index 271cf7a7..8b73ff7c 100644 --- a/okhttps/src/main/java/com/ejlchina/okhttps/internal/AbstractBody.java +++ b/okhttps/src/main/java/com/ejlchina/okhttps/internal/AbstractBody.java @@ -6,13 +6,13 @@ import com.ejlchina.okhttps.Array; import com.ejlchina.okhttps.Mapper; +import com.ejlchina.okhttps.MsgConvertor; public abstract class AbstractBody { - protected TaskExecutor taskExecutor; protected Charset charset; - + public AbstractBody(TaskExecutor taskExecutor, Charset charset) { this.taskExecutor = taskExecutor; this.charset = charset; @@ -25,7 +25,7 @@ public Mapper toMapper() { if (taskExecutor == null) { throw new IllegalStateException("没有 taskExecutor，不可做 Mapper 转换！"); } - return taskExecutor.convertor().toMapper(toByteStream(), charset); + return taskExecutor.doMsgConvert((MsgConvertor c) -> c.toMapper(toByteStream(), charset)); } @@ -33,7 +33,7 @@ public Array toArray() { if (taskExecutor == null) { throw new IllegalStateException("没有 taskExecutor，不可做 Array 转换！"); } - return taskExecutor.convertor().toArray(toByteStream(), charset); + return taskExecutor.doMsgConvert((MsgConvertor c) -> c.toArray(toByteStream(), charset)); } @@ -41,7 +41,7 @@ public T toBean(Class type) { if (taskExecutor == null) { throw new IllegalStateException("没有 taskExecutor，不可做 Bean 转换！"); } - return taskExecutor.convertor().toBean(type, toByteStream(), charset); + return taskExecutor.doMsgConvert((MsgConvertor c) -> c.toBean(type, toByteStream(), charset)); } @@ -49,7 +49,7 @@ public List toList(Class type) { if (taskExecutor == null) { throw new IllegalStateException("没有 taskExecutor，不可做 List 转换！"); } - return taskExecutor.convertor().toList(type, toByteStream(), charset); + return taskExecutor.doMsgConvert((MsgConvertor c) -> c.toList(type, toByteStream(), charset)); } } diff --git a/okhttps/src/main/java/com/ejlchina/okhttps/internal/MessageBody.java b/okhttps/src/main/java/com/ejlchina/okhttps/internal/MessageBody.java index 4da07e39..f8ae709d 100644 --- a/okhttps/src/main/java/com/ejlchina/okhttps/internal/MessageBody.java +++ b/okhttps/src/main/java/com/ejlchina/okhttps/internal/MessageBody.java @@ -6,6 +6,7 @@ import java.io.InputStreamReader; import java.io.Reader; import java.nio.ByteBuffer; +import java.nio.charset.Charset; import java.nio.charset.StandardCharsets; import com.ejlchina.okhttps.WebSocket.Message; @@ -18,13 +19,13 @@ public class MessageBody extends AbstractBody implements Message { private ByteString bytes; - public MessageBody(String text, TaskExecutor taskExecutor) { - super(taskExecutor); + public MessageBody(String text, TaskExecutor taskExecutor, Charset charset) { + super(taskExecutor, charset); this.text = text; } - public MessageBody(ByteString bytes, TaskExecutor taskExecutor) { - super(taskExecutor); + public MessageBody(ByteString bytes, TaskExecutor taskExecutor, Charset charset) { + super(taskExecutor, charset); this.bytes = bytes; } diff --git a/okhttps/src/main/java/com/ejlchina/okhttps/internal/TaskExecutor.java b/okhttps/src/main/java/com/ejlchina/okhttps/internal/TaskExecutor.java index efc4e41a..9bc3b764 100644 --- a/okhttps/src/main/java/com/ejlchina/okhttps/internal/TaskExecutor.java +++ b/okhttps/src/main/java/com/ejlchina/okhttps/internal/TaskExecutor.java @@ -116,15 +116,24 @@ public Data(T data, String mediaType) { } } + public V doMsgConvert(ConvertFunc callable) { + Data vData = doMsgConvert(null, callable); + return vData != null ? vData.data : null; + } + public Data doMsgConvert(String type, ConvertFunc callable) { Throwable cause = null; for (int i = msgConvertors.length - 1; i >= 0; i--) { MsgConvertor convertor = msgConvertors[i]; String mediaType = convertor.mediaType(); - if (mediaType == null || !mediaType.contains(type)) { + if (type != null && (mediaType == null || !mediaType.contains(type))) { continue; } + if (callable == null && mediaType != null) { + return new Data<>(null, mediaType); + } try { + assert callable != null; return new Data<>(callable.apply(convertor), mediaType); } catch (Exception e) { if (cause != null) { @@ -133,9 +142,13 @@ public Data doMsgConvert(String type, ConvertFunc callable) { cause = e; } } + if (callable == null) { + return new Data<>(null, "application/x-www-form-urlencoded"); + } if (cause != null) { throw new HttpException("转换失败", cause); } + throw new HttpException("没有匹配[" + type + "]类型的转换器！"); } diff --git a/okhttps/src/main/java/com/ejlchina/okhttps/internal/WebSocketTask.java b/okhttps/src/main/java/com/ejlchina/okhttps/internal/WebSocketTask.java index d8b9809c..76930bf5 100644 --- a/okhttps/src/main/java/com/ejlchina/okhttps/internal/WebSocketTask.java +++ b/okhttps/src/main/java/com/ejlchina/okhttps/internal/WebSocketTask.java @@ -1,12 +1,12 @@ package com.ejlchina.okhttps.internal; import java.nio.charset.Charset; -import java.nio.charset.StandardCharsets; import java.util.ArrayList; import java.util.List; import com.ejlchina.okhttps.HttpResult; import com.ejlchina.okhttps.HttpTask; +import com.ejlchina.okhttps.MsgConvertor; import com.ejlchina.okhttps.WebSocket; import com.ejlchina.okhttps.WebSocket.Close; import com.ejlchina.okhttps.WebSocket.Listener; @@ -30,6 +30,9 @@ public class WebSocketTask extends HttpTask { public WebSocketTask(HttpClient httpClient, String url) { super(httpClient, url); + if (getBodyType().toLowerCase().contains("form")) { + bodyType("json"); + } } /** @@ -37,7 +40,7 @@ public WebSocketTask(HttpClient httpClient, String url) { * @return WebSocket */ public WebSocket listen() { - WebSocketImpl socket = new WebSocketImpl(httpClient.executor, httpClient.charset); + WebSocketImpl socket = new WebSocketImpl(httpClient.executor, getBodyType()); registeTagTask(socket); httpClient.preprocess(this, () -> { synchronized (socket) { @@ -45,8 +48,7 @@ public WebSocket listen() { removeTagTask(); } else { Request request = prepareRequest("GET"); - MessageListener listener = new MessageListener(socket); - socket.setWebSocket(httpClient.webSocket(request, listener)); + httpClient.webSocket(request, new MessageListener(socket)); } } }, skipPreproc, skipSerialPreproc); @@ -56,14 +58,19 @@ public WebSocket listen() { class MessageListener extends WebSocketListener { - WebSocket webSocket; + WebSocketImpl webSocket; + + Charset charset; - public MessageListener(WebSocket webSocket) { + public MessageListener(WebSocketImpl webSocket) { this.webSocket = webSocket; } @Override public void onOpen(okhttp3.WebSocket webSocket, Response response) { + this.charset = charset(response); + this.webSocket.setCharset(charset); + this.webSocket.setWebSocket(webSocket); if (onOpen != null) { HttpResult result = new RealHttpResult(WebSocketTask.this, response, httpClient.executor); onOpen.on(this.webSocket, result); @@ -74,7 +81,7 @@ public void onOpen(okhttp3.WebSocket webSocket, Response response) { @Override public void onMessage(okhttp3.WebSocket webSocket, String text) { if (onMessage != null) { - onMessage.on(this.webSocket, new MessageBody(text, httpClient.executor)); + onMessage.on(this.webSocket, new MessageBody(text, httpClient.executor, charset)); } } @@ -82,7 +89,7 @@ public void onMessage(okhttp3.WebSocket webSocket, String text) { @Override public void onMessage(okhttp3.WebSocket webSocket, ByteString bytes) { if (onMessage != null) { - onMessage.on(this.webSocket, new MessageBody(bytes, httpClient.executor)); + onMessage.on(this.webSocket, new MessageBody(bytes, httpClient.executor, charset)); } } @@ -124,8 +131,14 @@ static class WebSocketImpl implements WebSocket { Charset charset; - public WebSocketImpl(TaskExecutor taskExecutor, Charset charset) { + String bodyType; + + public WebSocketImpl(TaskExecutor taskExecutor, String bodyType) { this.taskExecutor = taskExecutor; + this.bodyType = bodyType; + } + + public void setCharset(Charset charset) { this.charset = charset; } @@ -156,54 +169,18 @@ public long queueSize() { } @Override - public boolean send(String text) { - if (webSocket != null) { - return webSocket.send(text); - } - queueMsgToSend(text); - return true; - } - - @Override - public boolean send(ByteString bytes) { - if (webSocket != null) { - return webSocket.send(bytes); - } - queueMsgToSend(bytes); - return true; - } - - @Override - public boolean send(Object bean) { - return send(taskExecutor.convertor().serialize(bean, charset)); - } - - @Override - public boolean send(Object bean, String dateFormat) { - return send(taskExecutor.convertor().serialize(bean, dateFormat, charset)); - } - - @Override - public boolean send(byte[] data) { - if (webSocket != null) { - return send(webSocket, data); - } - queueMsgToSend(data); - return true; - } - - - void queueMsgToSend(Object msg) { + public boolean send(Object msg) { if (msg == null) { - return; + return false; } synchronized (queues) { if (webSocket != null) { - send(webSocket, msg); + return send(webSocket, msg); } else { queues.add(msg); } } + return true; } void setWebSocket(okhttp3.WebSocket webSocket) { @@ -229,8 +206,8 @@ boolean send(okhttp3.WebSocket webSocket, Object msg) { if (msg instanceof byte[]) { return webSocket.send(ByteString.of((byte[]) msg)); } - byte[] bytes = taskExecutor.convertor().serialize(msg, charset); - return webSocket.send(new String(bytes, StandardCharsets.UTF_8)); + byte[] bytes = taskExecutor.doMsgConvert(bodyType, (MsgConvertor c) -> c.serialize(msg, charset)).data; + return webSocket.send(new String(bytes, charset)); } } From cc4749731abab05bb570b745dccab361face4e72 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?=E5=91=A8=E6=97=AD?= Date: Tue, 12 May 2020 09:25:10 +0800 Subject: [PATCH 266/924] LOGO --- okhttps-doc/OkHttps. logo.ai | 1327 ++++++++++++++++++++++++++++++++++ 1 file changed, 1327 insertions(+) create mode 100644 okhttps-doc/OkHttps. logo.ai diff --git a/okhttps-doc/OkHttps. logo.ai b/okhttps-doc/OkHttps. logo.ai new file mode 100644 index 00000000..e9a96afc --- /dev/null +++ b/okhttps-doc/OkHttps. logo.ai @@ -0,0 +1,1327 @@ +%PDF-1.5 % +1 0 obj <>/OCGs[28 0 R]>>/Pages 3 0 R/Type/Catalog>> endobj 2 0 obj <>stream + + + + + application/pdf + + + OKhttps. logo + + + Adobe Illustrator 24.0 (Macintosh) + 2020-04-28T11:13:07+08:00 + 2020-04-28T11:13:09+08:00 + 2020-04-28T11:13:09+08:00 + + + + 256 + 160 + JPEG + /9j/4AAQSkZJRgABAgEASABIAAD/7QAsUGhvdG9zaG9wIDMuMAA4QklNA+0AAAAAABAASAAAAAEA AQBIAAAAAQAB/+4ADkFkb2JlAGTAAAAAAf/bAIQABgQEBAUEBgUFBgkGBQYJCwgGBggLDAoKCwoK DBAMDAwMDAwQDA4PEA8ODBMTFBQTExwbGxscHx8fHx8fHx8fHwEHBwcNDA0YEBAYGhURFRofHx8f Hx8fHx8fHx8fHx8fHx8fHx8fHx8fHx8fHx8fHx8fHx8fHx8fHx8fHx8fHx8f/8AAEQgAoAEAAwER AAIRAQMRAf/EAaIAAAAHAQEBAQEAAAAAAAAAAAQFAwIGAQAHCAkKCwEAAgIDAQEBAQEAAAAAAAAA AQACAwQFBgcICQoLEAACAQMDAgQCBgcDBAIGAnMBAgMRBAAFIRIxQVEGE2EicYEUMpGhBxWxQiPB UtHhMxZi8CRygvElQzRTkqKyY3PCNUQnk6OzNhdUZHTD0uIIJoMJChgZhJRFRqS0VtNVKBry4/PE 1OT0ZXWFlaW1xdXl9WZ2hpamtsbW5vY3R1dnd4eXp7fH1+f3OEhYaHiImKi4yNjo+Ck5SVlpeYmZ qbnJ2en5KjpKWmp6ipqqusra6voRAAICAQIDBQUEBQYECAMDbQEAAhEDBCESMUEFURNhIgZxgZEy obHwFMHR4SNCFVJicvEzJDRDghaSUyWiY7LCB3PSNeJEgxdUkwgJChgZJjZFGidkdFU38qOzwygp 0+PzhJSktMTU5PRldYWVpbXF1eX1RlZmdoaWprbG1ub2R1dnd4eXp7fH1+f3OEhYaHiImKi4yNjo +DlJWWl5iZmpucnZ6fkqOkpaanqKmqq6ytrq+v/aAAwDAQACEQMRAD8A9U4q7FXYq7FXYq7FXYq7 FXYq7FXYqlHmzzb5f8p6Hca3r14lnp9sPikf7TtQlY416u7U2Ub4q+GPzb/Obzd+bHmCHTbGGaHR TMsek6DDV3llY8VeUJ/eSsTsOi9B3JVfZn5OaF5m0H8s9B0nzPK02t2sDC6LyeqyBpXeKIvU1MUT KmxptttirMsVdirsVdirsVdirsVdirsVdirsVdiqldXVvaWs11cyLFbW6NLNKxoqIgLMxPgAK4q8 /wDI35//AJY+ddZk0bRtSZNQBP1aG7ja3+sAdTBz+1/qmje3XFXouKuxV2KuxV2KuxV2KuxV2Kux V2KuxV2KuxV2KvkH/nNqLzH/AIp0KVxOfLQseNud/q4vvWlM3t6hi9Pr2G3fFUX/AM4by/lgt3cx zrTz+3L6u93xKG27iy8Hp/eD7VOnw8sVfWeKuxV2KuxV2KuxV2KuxV2KuxV2KuxV2KobU9OtNT02 7029T1LO+hktrmOtOUUqFHWo8VbFXwv+cv8Azjv5p/Lm5bWdJeXUvLKuHi1GIET2hBqouAn2aHpI vw/6poMVehfkj/zllJEbfy9+Ykpkj2itfMVKsvZVvAPtD/i0b/zA7tir6rt7i3uYI7i2lSa3mUPD NGwdHRhVWVhUEEdCMVVMVdirsVdirsVdirsVdirsVdirsVdirsVSvzN5Y0LzPotzouu2aXum3S0l hkHcfZZWG6sp3VhuMVfDX5xfkb5q/K7W49T0ySe70AyiTTdZhBWW3kB5JHMU+xItPhcUDdRQ1UKv sL8ltc8167+Weiap5rhaLWriNzMXT0mkRZWWKVo6DiZIwrdN+vfFWb4q7FXYq7FXYq7FXYq7FXYq 7FXYq7FXYqtliilieKVFkikUrJGwDKysKEEHYgjFXy3+en/OKdsY7nzN5BSO2KBpr7QWYJER1ZrR moqf8Yyafy02UqvKvyd/5yA82flteLpt0JNS8teoRc6RMSHgJPxtbM392wO5Q/C3eh+IKvtvyR58 8r+dtEj1jy7erd2rUEqfZlhelTHNH1Rh+PUVGKsgxV2KuxV2KuxV2KuxV2KuxV2KuxV2KuxV2Kux V2KuxV2KuxV2KuxV2KuxV2KuxV2KuxV2KvPPzn/OTRPy08vrdXCi81q95LpWmA0MjLTlJIR9mNKi p79B7KvivWvNn5r/AJueYBaySXms3UrF7fSbRW+rQrXqsK/AirXd3/2TYqyEf84p/ncbP6x+hYhJ /wAspvLX1aUr/vzh/wANirEtP1H8yfyo81iWNbvy/rUQHqW8yFUmir0dG+CaJqbHcdwajFX23+Sf 50aR+ZmgvMsa2Wu2PFdU03lULy+zLETu0b0+anY9iVXoN9f2Fhbtc31zFaWyfbnndY0HzZiAMVVI J4J4lmgkWWFxVJEIZWHiCNjiq/FXYq7FXYq7FXYq7FXYq7FXYq7FXYq7FXYq7FXYq7FXYq7FXYq7 FXYq7FXYq7FX55/nB5m1T8xfzhvvqpM4lvV0jQ4Qfh9JJfRhC/8AGRyXPuxxV9t/lZ+WOgfl55Xg 0fTI1e6ZVfU9Q40kuZ6fE7HrxHRF/ZHvUlVmOKsS/M78ttA/MDyvcaLqsSibizaffcQZbaenwyI3 WlQOa/tDbFXw7+V3mLV/y0/OCz+tkwPZ3zaVrcAJ4mFpfRnBp9rgRzX3UYqzL/nMXVPME35pJp18 8i6TaWUEmkwEkRFZQfWlVa0LNKrIW8FA7Yq88/LD81/NX5e67Df6Tcu1gZAdQ0pnP1e4j6MGToHp 9lwKj5VBVforo+qWer6TZarZNzstQt4rq2c7FopkEiH6VYYqi8VdirsVdirsVdirsVdirsVdirsV dirsVdirsVdirsVdirsVdirsVdirsVdir85/ygkj0385/LX6VPEw6vFFOz9pjJ6YLFqdJCCScVfo xirsVdir86fzxlt7/wDOXzV9QHNX1KSFQm/KVKRvT5yKcVfe/m7yD5N84W0Vt5l0m31OOAkwNKpE kdacuEqFZFDcRyAbfvir4/8A+cl/yX0Pyd5p0FPKEEgi8yerHDo6s8zJcQtEgERcs/GX1xRSTuD2 2Cr7D8i6DN5f8laDoU7B59M0+2tJmBJBkhiVHIJ7cgaYqnmKuxV2KuxV2KuxV2KuxV2KuxV2KuxV 2KuxV2KuxV2KuxV2KuxV2KuxV2KuxV8Gf85Mfl3feTPzMutUtUaPSdelfUdOuI6qEnZg1xECKcWS VuQp+yy4q+jPyK/5yG8v+dtItdK1y7isPN8CLFNDMwjW8KgD1oCaKWfq0Y3BrQccVez4q8d/PD/n IXy35G0m603SLuLUPN8qtFb2sREi2rnb1bkioXh1EZ+IntTfFXzR/wA44/l7qHnj8zrW/ukabS9G mXUtWuZKsHkVucMbE/aaWUbg/shjir75xVjcHkDQB5oHmm+Emp69FH6FneXhVvq0RrVLeNFjijry NWC8z3bFWSYq7FXYq7FXYq7FXYq7FXYq7FXYq7FXYq7FXYq7FXYq7FXYq7FXYq7FXYq7FXYqkHnj yN5d87eXp9B1+39ezm+JHU8ZIpQCElib9l1rt27GoqMVfHX5gf8AOJn5j+X7qWXy/EPMek1Jikty qXSr2EkDEEt/xjLfR0xVhg8vfnqsf6IGm+Z1iI4/UBDqASlK09KlKU9sVZh+X/8Azid+ZPmK5jl1 yEeW9JqDJLdUa5Ze4jt1PIN/xkK/Tir7F8h+QvLXkby9DoWgW/o2sfxyyvRpp5T9qWZwByY0+QGw oBTFWRYq7FXYq7FXYq7FXYq7FXYq7FXYq7FXYq7FXYq7FXYq7FXYq7FXYq7FXYq7FXYq7FXYq7FX Yq7FXYq7FXYq7FXYq7FXYq7FXYq7FXYq7FXYq7FXYq7FXYq7FXYq7FXYq7FXYq7FXYq7FXYq7FXY q7FXYq7FXYq7FXYq7FXYq7FXYq7FXYq7FXYq7FXYq7FXYqgtI1rR9Zs/ruk3sN/Zl3jFxbSLLHzj Yq68lJFVYUxVG4q7FXYq7FXYq7FXYq7FXYq7FXYq7FXYq7FXYq7FXYq7FXYq7FXYq7FXYq7FXYq7 FXYq7FXYqkPk7z35U85aa+oeXL9L23ikMU60aOWKQEjjLFIFkQ7bcl3xVLPzi1i90b8rfNGo2TFL uHTpxBIpoyNIvphwfFOXIYq+bP8AnDj8yf0Z5iu/I9/LSy1mtzpnI7LeRL8aD/jLEv3oB3xV9iYq 7FXYq7FXYq7FXYq7FXYq7FXYq7FXYq7FXYq7FXYq7FXYq7FXYq7FXYq7FXYq7FVO5nEFvLOVZxEj OVUVY8RWgHc4q+WvKP8AzmrLP5kaHzVo8Nn5enfjBc2XqPPbgnZpgzMJh/NwVT4A9MVfT2kavpes abb6npV1Fe6fdKHt7mBg6Op8CPuPhir4R85S+c/yV/ObVJdDnazV52u7JWBNvdWM7l0jkStHQboe 4ZTShxV9P/l1+bfkv85fKd/oNzSx1a7tJbbVdHdgX9OVDG8tu5A9RPi69VPUdCVXxr5v8p+bPyv8 9CzuuVtqWmTpdaZfoCElWN+UNxET1BK9OxqDuMVfoB+XHnax87eS9K8y2lFF9CDcQg19K4T4JovH 4ZAQK9RQ98VZJirsVdirsVdirsVdirsVdirsVdirsVdirsVdirsVdirsVa5LyC1HIgkL3IFKn8cV bxV2KuxV2KuxV2KuxV89/nf/AM4saX5lNz5g8lpHp3mBuUtzpxolrdv1JXtDK3j9hj1pUtir57/L 780vzC/J/wAx3GnvDKlvHLTVvL16GRGYUqygiscnHo69dq8hir6guYfyn/5yL8nL6crQarYglCOK 39hJJSoZDVXicrv+y3Yhhsq8I1r/AJxd/Ojyhq8ep+WCmqmzkEtpf6dMsFwhXoxilZGDeyFsVeze WtN1X83PLEnlb83PKF7putadGXtPMHoGBHNVQvDIRxSU7Fo90cCtOwVTr8jfyq84/llqmtaHPfQ6 p5PvaXmnXQJjniugRG6PAagepHSrBiPgHjir1/FXYq7FXYq7FXYq7FXYq7FXYq7FXYq7FXYq7FXY q7FUp8zXWqWemm90+W3RrZhJPHdEJHJGNinqEgIx7E4C0aiUox4o1t3sL8pXmo67rFtqFtqMcv6P MiPBMzfWPq0zDnFKACr8KVSVTuR8XtCO7rtLOWWYkJfT86PQ/oPzelZY7h2KuxV2KuxV2KuxV2Kv Df8AnJKD8jL7TTb+c9SisPMsUf8AuOuLNPW1BKiqq8UdS0Rr9mUgdeJB3xV8Z6H5j1nyxryar5d1 GW0vLVz9WvIvgLJX9pDUFXH2kaoPQ4q+zPyT/wCcndA85rBonmUxaP5oPGOIk8bW8Y7D0mb7EhO3 psdz9knoFXuWKuxV2KuxV2KuxV2KuxV2KuxV2KuxV2KuxV2KuxV2KuxV2KsZ8+2lzNp9lPHbteW1 lexXN9ZRjk0sKV5AL+1QkHj3yMnD1sSYg1YEgSPJJtGKap5r0y+sBJMlktz+kNQa2NqpjkTjDb0I XmY2+7IjcuNh9eWMo71dmq9w+DP8sdq7FXYq7FXYq7FXYq8Q/wCcl/zyn8haVDoOguo80arGXE5o fqlsSU9ah6yOwIjrtsT2AKr5j/LT8mvP35qajcX1s/Cx9U/pDXr5nZTK3xMAd3ml3qQP9kRXFXu0 H/OEHlcWfCfzNfPe/wC/kghSKv8AxiJdv+SmKvHvza/5xr85+QLeXVYpF1vy7Gf3moQKUkhBIAM8 BLFBU/aVmXxIxV6v/wA4tfn5qGqXUXkPzVcm4uih/QepSmsj+mKtbSuftNxFY2O+3H+XFX0/irsV dirsVdirsVdirsVdirsVdirsVdirsVdirsVdirsVdirsVdirsVdirsVdirsVdir87vzS1DUPPP52 6vHG/Ka+1b9F2FTVRHHKLSClNgCFBNO5xV99+UvLGl+VvLeneX9LjEdjp0Kwx0ABYjd5Gp+3IxLM e5OKvP8AzF/zkz+V3l/zo/lO/nujdQSi3vNQjiVrO3lJoyyuXEnwH7RVGA+g4q9Ruba2u7WW2uY1 ntrhGjmicBkeNxxZWB2IYGhxV+df5h6Fcflr+buoWWlyFG0O/iu9LkJJKxnhdW9T3Kq6g4q/Q/St Qi1HS7PUIhSK8gjuIxWvwyoHG49jiqKxV2KuxV2KuxV2KuxV2KuxV2KuxV2KuxV2KuxV2KuxV2Ku xV2KuxV2KuxV2KuxV2Kvzo8xNL5L/PC8uJkP+4PzCbxV6lo4bv14yK/zIAcVfojY3tpf2VvfWcqz 2l1Gk9vMm6vHIoZGX2ZTXFXhHm7/AJxE8t+YvP8Ac+Z21qa107ULk3mo6QkIZpJJG5zenceovpiR jX+7alT9Cr3xESNFjQBUQBVUdABsAMVfnn+fnmCHzV+cuv3emH6zA1xHY2nDfmbaNLc8KfaDyIxU ++Kvv3y7pp0vy/pmmGlbG0gtjQ1H7mNU2J/1cVTDFXYq7FXYq7FXYq7FXYq7FXYq7FXYq7FXYq7F XYq7FXYq7FXYq7FXYq7FXYq7FXYq+W/+cu/ycvbyUfmHoduZzHEsXmCCMVcJEKR3dBuQqAJJ4AKe nIhVhv5E/wDOT0/kuwi8teaYZdQ8vQ1FjdQ0a5tQTX0+LFRJFU7CtV7VFAFX0ZB/zkj+Sc1n9bHm iBIwKtG8Vwso9vSMfM/QMVeM/nH/AM5c219ptzoP5fpNGLlWiuNfmUxOEbZhaxn41LDbm9CvYVoQ qxb/AJxX/Jy98yeaLfzhqluU8u6LKJbVnG11eRmsapXqkTfEzeIC+NFX2zirsVdirsVdirsVdirs VdirsVdirsVdirsVdirsVdirsVdirsVdirsVdirsVdirsVdirTKrKVYBlYUZTuCD2OKvCPzH/wCc RvJHmW6m1Hy/cN5b1CYl5IYoxNZOx3qIaoY6/wCQ1P8AJxV5VL/zhN+YgueMWt6Q9tv+8Z7lX70+ AQMPD9rFWe+Rf+cMPLenXMd55u1V9aZCGGnWyG2tyQekj8mlkX5cMVfRNhYWOn2cNjYW8drZ26CO 3toVCRoi7BVVaAAYqr4q7FXYq7FXYq7FXYq7FXYq7FXYq7FXYq7FXYq7FXYq7FX/2Q== + + + + proof:pdf + uuid:65E6390686CF11DBA6E2D887CEACB407 + xmp.did:e162cb60-21aa-4ff8-8217-8d09729c2dd3 + uuid:6f336833-9404-b643-9a8f-9e47e02abffc + + xmp.iid:77657c28-e3ae-4323-aeac-9c0f28920502 + xmp.did:77657c28-e3ae-4323-aeac-9c0f28920502 + uuid:65E6390686CF11DBA6E2D887CEACB407 + proof:pdf + + + + + saved + xmp.iid:2afc754f-ab50-44e3-9c34-d29c32560605 + 2020-04-28T10:58:27+08:00 + Adobe Illustrator 24.0 (Macintosh) + / + + + saved + xmp.iid:e162cb60-21aa-4ff8-8217-8d09729c2dd3 + 2020-04-28T11:13:05+08:00 + Adobe Illustrator 24.0 (Macintosh) + / + + + + Web + Document + AIRobin + Adobe PDF library 15.00 + 21.0.0 + 1 + False + False + + 256.000000 + 256.000000 + Pixels + + + + Cyan + Magenta + Yellow + + + + + + 默认色板组 + 0 + + + + 白色 + RGB + PROCESS + 255 + 255 + 255 + + + 黑色 + RGB + PROCESS + 0 + 0 + 0 + + + RGB 红 + RGB + PROCESS + 255 + 0 + 0 + + + RGB 黄 + RGB + PROCESS + 255 + 255 + 0 + + + RGB 绿 + RGB + PROCESS + 0 + 255 + 0 + + + RGB 青 + RGB + PROCESS + 0 + 255 + 255 + + + RGB 蓝 + RGB + PROCESS + 0 + 0 + 255 + + + RGB 洋红 + RGB + PROCESS + 255 + 0 + 255 + + + R=193 G=39 B=45 + RGB + PROCESS + 193 + 39 + 45 + + + R=237 G=28 B=36 + RGB + PROCESS + 237 + 28 + 36 + + + R=241 G=90 B=36 + RGB + PROCESS + 241 + 90 + 36 + + + R=247 G=147 B=30 + RGB + PROCESS + 247 + 147 + 30 + + + R=251 G=176 B=59 + RGB + PROCESS + 251 + 176 + 59 + + + R=252 G=238 B=33 + RGB + PROCESS + 252 + 238 + 33 + + + R=217 G=224 B=33 + RGB + PROCESS + 217 + 224 + 33 + + + R=140 G=198 B=63 + RGB + PROCESS + 140 + 198 + 63 + + + R=57 G=181 B=74 + RGB + PROCESS + 57 + 181 + 74 + + + R=0 G=146 B=69 + RGB + PROCESS + 0 + 146 + 69 + + + R=0 G=104 B=55 + RGB + PROCESS + 0 + 104 + 55 + + + R=34 G=181 B=115 + RGB + PROCESS + 34 + 181 + 115 + + + R=0 G=169 B=157 + RGB + PROCESS + 0 + 169 + 157 + + + R=41 G=171 B=226 + RGB + PROCESS + 41 + 171 + 226 + + + R=0 G=113 B=188 + RGB + PROCESS + 0 + 113 + 188 + + + R=46 G=49 B=146 + RGB + PROCESS + 46 + 49 + 146 + + + R=27 G=20 B=100 + RGB + PROCESS + 27 + 20 + 100 + + + R=102 G=45 B=145 + RGB + PROCESS + 102 + 45 + 145 + + + R=147 G=39 B=143 + RGB + PROCESS + 147 + 39 + 143 + + + R=158 G=0 B=93 + RGB + PROCESS + 158 + 0 + 93 + + + R=212 G=20 B=90 + RGB + PROCESS + 212 + 20 + 90 + + + R=237 G=30 B=121 + RGB + PROCESS + 237 + 30 + 121 + + + R=199 G=178 B=153 + RGB + PROCESS + 199 + 178 + 153 + + + R=153 G=134 B=117 + RGB + PROCESS + 153 + 134 + 117 + + + R=115 G=99 B=87 + RGB + PROCESS + 115 + 99 + 87 + + + R=83 G=71 B=65 + RGB + PROCESS + 83 + 71 + 65 + + + R=198 G=156 B=109 + RGB + PROCESS + 198 + 156 + 109 + + + R=166 G=124 B=82 + RGB + PROCESS + 166 + 124 + 82 + + + R=140 G=98 B=57 + RGB + PROCESS + 140 + 98 + 57 + + + R=117 G=76 B=36 + RGB + PROCESS + 117 + 76 + 36 + + + R=96 G=56 B=19 + RGB + PROCESS + 96 + 56 + 19 + + + R=66 G=33 B=11 + RGB + PROCESS + 66 + 33 + 11 + + + + + + 灰色 + 1 + + + + R=0 G=0 B=0 + RGB + PROCESS + 0 + 0 + 0 + + + R=26 G=26 B=26 + RGB + PROCESS + 26 + 26 + 26 + + + R=51 G=51 B=51 + RGB + PROCESS + 51 + 51 + 51 + + + R=77 G=77 B=77 + RGB + PROCESS + 77 + 77 + 77 + + + R=102 G=102 B=102 + RGB + PROCESS + 102 + 102 + 102 + + + R=128 G=128 B=128 + RGB + PROCESS + 128 + 128 + 128 + + + R=153 G=153 B=153 + RGB + PROCESS + 153 + 153 + 153 + + + R=179 G=179 B=179 + RGB + PROCESS + 179 + 179 + 179 + + + R=204 G=204 B=204 + RGB + PROCESS + 204 + 204 + 204 + + + R=230 G=230 B=230 + RGB + PROCESS + 230 + 230 + 230 + + + R=242 G=242 B=242 + RGB + PROCESS + 242 + 242 + 242 + + + + + + Web 颜色组 + 1 + + + + R=63 G=169 B=245 + RGB + PROCESS + 63 + 169 + 245 + + + R=122 G=201 B=67 + RGB + PROCESS + 122 + 201 + 67 + + + R=255 G=147 B=30 + RGB + PROCESS + 255 + 147 + 30 + + + R=255 G=29 B=37 + RGB + PROCESS + 255 + 29 + 37 + + + R=255 G=123 B=172 + RGB + PROCESS + 255 + 123 + 172 + + + R=189 G=204 B=212 + RGB + PROCESS + 189 + 204 + 212 + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + endstream endobj 3 0 obj <> endobj 5 0 obj <>/Resources<>/ExtGState<>/Properties<>>>/Thumb 33 0 R/TrimBox[0.0 0.0 256.0 256.0]/Type/Page>> endobj 30 0 obj <>stream +Hln%E RvzK@F0b]չt_׏>>>?=O%}c:%ikxxk*Y[9x+??\ߞ˟Ï$$I\4[Uju?/h,Vt7qљWm354/=LMoc&ɧ]]%<~|OCk.4EjE>:p ("TL,H Jxra +O + k.ZF{^5<W&_8CNɃY +,p^x?S6SD@^BFajbAI+[ mHo:_+BGzAJEgz>1%&AكMMFWsq)K2mL +%T1 +P^@NȮ2(Gȭlsd9)iv0A0Jem"b}DÉFQikԇ"B.uq}[K s>Uŋ>+Y`* endstream endobj 33 0 obj <>stream +8;V_XJJ#jD#Xd4d5+1SX4k?U7kXQc'G=>.H6q"@BLur1a^ul6G:$$B0#_4l*GRFZb +ec9[[Yo*>D!^mYY!'TMP[%[P_FB]Hl=l#A^/CJ)-5eZb/6L[pm(T]sucI\gipAofZ +ni2^*Z"gR?)ci72n@(8#s#g=>fBS![-X30TkI(+/ +m;(X,!3nPEQi~> endstream endobj 34 0 obj [/Indexed/DeviceRGB 255 35 0 R] endobj 35 0 obj <>stream +8;X]O>EqN@%''O_@%e@?J;%+8(9e>X=MR6S?i^YgA3=].HDXF.R$lIL@"pJ+EP(%0 +b]6ajmNZn*!='OQZeQ^Y*,=]?C.B+\Ulg9dhD*"iC[;*=3`oP1[!S^)?1)IZ4dup` +E1r!/,*0[*9.aFIR2&b-C#soRZ7Dl%MLY\.?d>Mn +6%Q2oYfNRF$$+ON<+]RUJmC0InDZ4OTs0S!saG>GGKUlQ*Q?45:CI&4J'_2j$XKrcYp0n+Xl_nU*O( +l[$6Nn+Z_Nq0]s7hs]`XX1nZ8&94a\~> endstream endobj 28 0 obj <> endobj 36 0 obj [/View/Design] endobj 37 0 obj <>>> endobj 32 0 obj <> endobj 31 0 obj [/ICCBased 38 0 R] endobj 38 0 obj <>stream +HyTSwoɞc [5laQIBHADED2mtFOE.c}08׎8GNg9w߽'0 ֠Jb  + 2y.-;!KZ ^i"L0- @8(r;q7Ly&Qq4j|9 +V)gB0iW8#8wթ8_٥ʨQQj@&A)/g>'Kt;\ ӥ$պFZUn(4T%)뫔0C&Zi8bxEB;Pӓ̹A om?W= +x-[0}y)7ta>jT7@tܛ`q2ʀ&6ZLĄ?_yxg)˔zçLU*uSkSeO4?׸c. R ߁-25 S>ӣVd`rn~Y&+`;A4 A9=-tl`;~p Gp| [`L`< "A YA+Cb(R,*T2B- +ꇆnQt}MA0alSx k&^>0|>_',G!"F$H:R!zFQd?r 9\A&G rQ hE]a4zBgE#H *B=0HIpp0MxJ$D1D, VĭKĻYdE"EI2EBGt4MzNr!YK ?%_&#(0J:EAiQ(()ӔWT6U@P+!~mD eԴ!hӦh/']B/ҏӿ?a0nhF!X8܌kc&5S6lIa2cKMA!E#ƒdV(kel }}Cq9 +N')].uJr + wG xR^[oƜchg`>b$*~ :Eb~,m,-ݖ,Y¬*6X[ݱF=3뭷Y~dó ti zf6~`{v.Ng#{}}jc1X6fm;'_9 r:8q:˜O:ϸ8uJqnv=MmR 4 +n3ܣkGݯz=[==<=GTB(/S,]6*-W:#7*e^YDY}UjAyT`#D="b{ų+ʯ:!kJ4Gmt}uC%K7YVfFY .=b?SƕƩȺy چ k5%4m7lqlioZlG+Zz͹mzy]?uuw|"űNwW&e֥ﺱ*|j5kyݭǯg^ykEklD_p߶7Dmo꿻1ml{Mś nLl<9O[$h՛BdҞ@iءG&vVǥ8nRĩ7u\ЭD-u`ֲK³8%yhYѹJº;.! +zpg_XQKFAǿ=ȼ:ɹ8ʷ6˶5̵5͵6ζ7ϸ9к<Ѿ?DINU\dlvۀ܊ݖޢ)߯6DScs 2F[p(@Xr4Pm8Ww)Km endstream endobj 7 0 obj <> endobj 22 0 obj <> endobj 23 0 obj <>stream +%!PS-Adobe-3.0 %%Creator: Adobe Illustrator(R) 24.0 %%AI8_CreatorVersion: 24.0.0 %%For: (Geoffrey) () %%Title: (未标题-1) %%CreationDate: 2020/4/28 上午11:13 %%Canvassize: 16383 %%BoundingBox: 346 -1086 4373 1381 %%HiResBoundingBox: 346.440002441406 -1085.90124511719 4372.73776087041 1380.27267906984 %%DocumentProcessColors: Cyan Magenta Yellow Black %AI5_FileFormat 14.0 %AI12_BuildNumber: 332 %AI3_ColorUsage: Color %AI7_ImageSettings: 0 %%RGBProcessColor: 0 0 0 ([套版色]) %AI3_Cropmarks: 372 -628 628 -372 %AI3_TemplateBox: 500.5 -500.5 500.5 -500.5 %AI3_TileBox: 220.5 -880 779.5 -97 %AI3_DocumentPreview: None %AI5_ArtSize: 14400 14400 %AI5_RulerUnits: 6 %AI9_ColorModel: 1 %AI5_ArtFlags: 0 0 0 1 0 0 1 0 0 %AI5_TargetResolution: 800 %AI5_NumLayers: 1 %AI9_OpenToView: 34.7825975116702 -216.213424585018 2.27083790911365 2548 1324 18 1 0 6 43 0 0 0 1 1 0 1 1 0 0 %AI5_OpenViewLayers: 7 %%PageOrigin:100 -800 %AI7_GridSettings: 72 8 72 8 1 0 0.800000011920929 0.800000011920929 0.800000011920929 0.899999976158142 0.899999976158142 0.899999976158142 %AI9_Flatten: 1 %AI12_CMSettings: 00.MS %%EndComments endstream endobj 24 0 obj <>stream +%AI24_ZStandard_Data(/Xܩ.!F 9BkUUUU-֏0OM$.u Tx.j}$pHz*$Q ځwvO8$iHK)l0t!mNmm6w6`b@0\@ *A6 C + + B +pq+Æ2l`B. 8` p`01czAc`,$p *@ n锫%*tWxw$ 6pP'JAư4|T_t-sf~F(Mf莰ȨښtrĆUvp0 +2c G`@& L iCdATFH0@0/ {@ (!#@B,W!( p$< @d$ c&atHYevInɔ]Ghe5ya^M.THfsmc%N渲L^Lј"h PT_0j3X0 +DAWFaDX>:a] Eb sӨi$ﱉ@C(D4D20FH,j".1s$F# C'HAHFf$# AaT_u)s ;YF LeN(EeX Qs^h +o "л +aO O(;LĂ() +0VP$O+r"3D@>|#o$D`Ճ1,D0# +DF`,hnqC:D=0OdOgpM.EDb.S\×W|˜X0Qk|TZ}9I='s UnOL^էɏV2wCTo94DB_8x.DXZ^.nL, @aQCcq@QX$ΰ'8D%0DB1+EO`8g(  jXo(C`(D= cyH "!/`1Ʊܠ%2b)@$P H, +KE"cH1 {).t>Yhԃ@,"XY)HPʓ@DCC5q0EP 4FDC 3pLWj0I NC33 `(,(,(0\@X@1c츣.s[mfgf9謎3{$b G%"H4(0)P+ +b`(,-p/ b`,00828#P0 x`L 7Q k\x#P4 FxhC@`ăaxh<<< BT!h,JQLaV8a6et(&cUכ{!0%, 6PbºrA ZNIHGFE#fX4l&.o{Rv0ab1" @8|́@ `8p@A8(k + f:%hha +,p6`-@ ) +f46@`ZHAXC @85BͰa'HalPAvdBnaĠQZH&*tpB@U*tpc,`űZH! 4 ,A ZX! + `4 +&`a +>`X ZȠ,a-h + 3 +mK((tT@  +F(Q +wBP@ +UBE(!8phX!p )HB 0F( +=BK(+C-d@LlXC 4d !Ѐ + A(PRp +PC `8 +Z`tP +A. Xh. ,AC -ƒi=I +,8l&A)P@Æ pp QYÎϑr#;V.D)@ pp `8 +h`A +0 +$-@,h@ DB +h +*<8 +@!o@XA +(LZX!C P )Ѐ/arc2m6\Ɍih!N` @*#}8t Nax2pB dЄa P,. 8 "డ4X@R0A0`4 00q4|(T؀-`::l@ <=`xРB .pB8 + 4, Vp6 `$.\@T +th!Z`*Ѐ8 +ZHA + @: Q PJ%^O鼎*ɥe(IaX#=K;M7XPW4K5͡͝ 摚UfZaCuIT_e|XuCr/XCF\[;~*Q&)j2Fc6{x'R?d,7oSWMjgdEғ8u{֤%]pZciYvWTDȪ&?XȖHfX6%exOravԳع[f{HjGǼG;zP||]s^4sgkaGWT?OnuXuSO9,U[ֽz-4s7WA*L3_Ӈeveۯ4Xy\b)ӐLUetNUsO}Yij]kͩ#KTmFxg}lj4M迡:m}|w/2K>]^Lyê'Sz\wAi%ݫ5VF';+Lfi3Ye{cDw~KYyK[כB)"3T_̐}(8,'=w^wY>!ue"]kOU2I$oV}Ζ])Г3dHO2HXjS<&E5r_YYm;%YAm(%m*qpdžJI齱Wvw̒q\`ov&rzv|8v/IBrt4e9yͫkmrec2˻Ra+y-=y6xWj)W'd2-TWfu2im3-2|=]%٬{D7[iWSWzRƏIFO"vB14ie)ܘpx#4Fjcd'ʺl&_S^BXê&C;WOs2Uի˩Z{朐3v6~3(fbTdΉe)r9#mXMo5?'u(v}۲Wٜ_ٞcvRGhZ{LI5%ɗX~$G0]|Κ*чt7mNuKXU֕,)IVg<=<:aS^x729n\c$U#[)5=j*-s^a ǻ$Tb3sv}MKY^-Ů^yjA3A&ɜ%$srca_YWzy&h}Ϊܽ9RʪxY<鱃_ɼH{Hr,t/™l6ʧdŮ Nb'oR#V wͻkȇՙ\򎙗roWBs7/UJ;R]wjҪѝl X:ws}ķ3 ffWʢ/ΌgwN㝏G+X$VٞVXv᬴4E9MVIޘI͗HLirٶZzEW9vve+iCtquiO9!1+ю׃ȝ B;eu~ԞX&7jħNX?(B +NZozU}N/nщ\Nz&L} p&Y_8e7~lƞ{#չ)g{fnEfۘ{Sk&wӓy?LDf2&dc;'UnNl[m"B"zXٙ=p<)tKcQRWxNFt|Lu֛ʯUJ H-6cbv/wcu;,(c;{Tȡe7hRYwBȏS0CZ*ek gJF̎{ѫ^4 V7IjV?+YAӲ.W=J9;;2\.)םyA$}f: qKsj1 (|M4܏<^H%g#^>,R?_X;]eJjN Ճ#t)^L>O,|oJNb͵%۝{s2]I:xK|zãOe9WHwX=<;\{7% YKK-Ɏsy*mUC6p C NaÆ" -*`"-[VW*?=grs.SKc(=,9{e(9;]$zI|iD%:{eN͟ ЎZ8`plauyRÒ?4a`< {#)*GLK0SK6QDm8]*͟t蠩IQ3&at}#I3DiYrx+hH$yI#٠YwM>)F>^eRJhTIQ+9AE.'I@!L:SG#C棙zH|&uzy$UZw!Ui#TDc=ʏ>ݕzgzfK|xn4(vhHZG^(,碓_K`V:.]L<ԔcӛjtU*.bM:WnC% Ō7~~),wbdY4wgxuݾI$X4%VX!$t]$ꡓ>s6d8UHD,:os{fդgW8s&QAcTt{ҕGa-S2k`Q v|r˖ѿY w4%Dtvy +>\J{٩>~ Q[u/[ʔtE=r TAvGQY])>R_Q$HG9n}k912b?u_i i84Uәnw$i$:fIN٭$XGdΫ3^\G-:~,q"Q]}GC2wy)T;jyR.wN[RII3n>f%ilI:1wm:LN(Ee/L4쒱hIEL?#Ou`͝Q%:f(V_GQ|:2qh)icv9)MR~r]nZ:*$[4]dkd*i6!qHؘ8:˗Gs2ցU4{J[WHSF&iyc%Ji<;]/ّvqnE9oi6%):FSGi.;)DK"LfLL\e)i ѲK|k:(ϑ6u|xz)49Ah^ޏjB#Þ8GӧRWq${ vOQ\GMRGҞvIRRՑ|FsS X9IyiO%9 f(42kRw&/ާb˷UWfq +)MzSx»:aIj^]H<ػٙv,_̡,5˗dkD< H(cOY'uC3 UeRM>Ţo]x'F{,ohbZ _f%8洫qgv\6bT7f,{3wUDiO7 05gޟ!!07`84-pАa `  A4.`A -pha 6`h! 0@A6l Tp4TjN>@0a :,0`C.'= JM2Y˧D8+Kt4L[*g#h5EA I;RT9{DdI7>!#x*g\Dbt9pᮒu;V(ʿo/m1\@d$rLDi Q. Fug|XrJx!4*O,),ɫ#!T!X% V%v$Qr(MeJ3i>3`>Ub Kv#:.oo].khYv vu7hwk?gP ]h,юu5ubl!,fgo4+u$"njR[$o/4d}J0ídt:39% ȕuVl|gU*q)zь++:(chxs%dΡ b#cO+Wb9c{L2=;nV~HU(dtw"P&d=K1Cq2x=ORjY?SIlITV(Kq.3н钫rED2YQkgϵ3N.ClNmɳl,Y:#VRr=DN,!nzS̆YY5(FҜY*JI65CgħYśq0CslZS dG0;4F(-F,{$rRn*gѯ5jnGOiΓ4t[ǶB%9T6Yd6:uHRO;y9G7YJ" 341=Rh󦒇3u)ʯ) }WMxՃuՊL+i;jCyfя.8cYG,5,Ϋٽ:&GH±zrlIdq]oZ=-X'dۗzkHjwΪK,5>IkteFrvu#SOkdwIph/ɳ86U;H3TG33n9DuxE77uFs?:Ǫ:9KJe*u$t:i-/HIb]Vʩ\39(gP7W{U54=S9LkZq~YNUӌlZ6Zޠ:EJYy*1;X)zfFΊk~6I|n 3 2Ix>?˓;׳dE<,x$;^RUYO,3=˖Te#YWS3N]Ѽ:yui6h{_6w4S$^fװ&[{<~^|M.t:ªqfìyy9S#%-G7232JkGʼt>FOdD_*{Cgyos|9I۬fTfjgtuWYVGka5D9펓>WCޫ9cNg1G^fQqil.dI//m#F$Sw6~*\C[ӕgӑRէByNbinwCer}f&K~|9:$B:64&T$kM'ޥ\|ۤj4E:݉Ш݋߮N-U|J)ļSﮦ*(wejS3:|̻=,.Fң-gHNǭboWtz-4);G㞈tg4YrI:o9rĴݏ¢}dIS٤12YHeREgnyvh$'@VG3gGZ"ΙUQ%~ u7ڤ˛\WeV9)GHD&vќ%{}WRUs[I +?Fڟ=eMDGgYG ݹH29 G$U?.z&Ivb&bR,*S~*gBev?%e +)?D9Ha B{sXuf%ĿjYdhluEg]}i?ƜC#NZx4ܮZ󱊽!ԮiwIJ4ޅգF8-q05V:lh!:T(Ȑ!P +` *@ iqɉιg5)-hT*C"=i!;mGu|}#ʶUշl.Xw&Ͷ)6k-aol*n֫,WfJ!Z)9xٍG;N]&'1sz41;I{Tjh0t~4σƴgWL{Q-UUiϽJJs5g5w19+ݜOBwVY6wFhsr.w3KhrtsT'F3㙱CfgE)oUޔgCuNT%$dR2"re+MVra;+=1>BW(m(3ߠVd!$% bL}렏r֔Cse:~kq\562e,Q/jlVYN!꠿UxĩVNUqxxD&98UvF:)אLlkm9x;lZuuJn0N k9?G9ƣ~[KF:ꧪ_fl +Ϻ(cm-5"VsVݲ#Ί4J[{Jk%}P lx,Zx1ѤGl2.Z&__$_eѳHF5QDB?<݄:x%D.sO892aEy2He29sTL:giY݈.?A/582;.u/\<2;fGtT>Z]e?{ eVo4;Z8sV:YliCDUt]|PhD)+-фxO2ʼZѩs(^KmJX .}eJo9GcqMqZ"K+tf̌ǜuWtoEK`~͜0ovDev^Δ iFF7zb(dT:*[F<5r¹⑝R暕|d&<&M?"f{Wt:IQ(.'LOGW +& ̻I!<aevkB?nzRrM8ziW12_V7(=1uTL%;yMXX!YhUMdFy.4a❵L97I8c%^YwHu9M37oG-)^5W|"41PY["&Y%Q^r1y>X"FB΋_qM z LMi:h!ߢ1b.n~tLAXHZ62CF,V +oVD!%Rgc5֗(h5S9]KC>"<|1MZ3,AZ@Kr"G@fT(#i_yTJieWHMtlBB_ݙv=QQLE ٠Ā ɭ88dUbkeWtF7ډ"pԈdW y6[tH&\ mZ|ضڂ2N}ƀ缛xeE= ۢ u#:\L =zԽW6r&W ?Rb>{wa䷨7ާսuod ; i7_JOܩFl&)mjlqcdZ t h5}C •AS@Χ Ś%"P?=i&;xd8p>FOe%!ȫe<E欰cw$:R6D@$PgME/@T\6kq&1Sͼ jL&E+a5zZR$ 2aB<^,xk^[k:5Q?&')0$z ܿf af6@f\ .I0OP< i&r_Ylr^c<>@Dגq RA=j@=_L*=EPăï'y֞ =Z4NDz)''dRA|*;Nb1?9 +^@|PiA'_g +{#@'RG^\׾Sq=iPTa b59ڸ?+O98TH1:YpW_s?@˵SsȪ^H{Q~^|uEYtޟ!qW& X ۝*˵2BRA!sp+ӪcFD_9gz)N)姢ByX4 戀d#Nc,&68kppד5qj@iUaE?]J}T%֚?%Di? M\_!K3@^g!VA$3<*VTýb%,(ߟ"5=[6"Z#v'}q4O! +"6˾X21P Q\㾒r|+0/Jr 71~28ZLszҦ9aOόy9G h8aa 7 sQiVe +3j̠a cR@Df;SLʿ b /1itcd8VXږʪMF~#CZl1YI{7vU/I{ditE._hDoI,QTB\[L؎+?A,Q\r"7E4'`$*M0͡[+9h׳:3Qޡ7/]]LQ%n8ig{( +krMзӹLY y Ohn:o*pI+ ]@KJNxED{'Rh."sZ#Pո'0-Cq,F4Ly~=4௷ 2Y?k8vlK͜Eصj [b"JVIo2eo/kM\+EW߸БV{/sP (ȿ c +R!lf[IJ8q͈dL:@]ʊ\`eIi((to)|gּW`A*ְ^'mS=Qu$KR<9JfiAgȓ$ErojQQr[paf萚>Иg1/^Jhއ7頒$ ឰrȪ+>4ܴ?Ah'b_|D_c]L9*p3qGFHgr~H*}i]^3gsRg-C>`c9gE_],I+nQ;FXdSr#Ki<{oF)`P=/@ͺCIKaNSo* LKޔ8bP;VtEa:V00ĕtv[I&wY~Pb;ZP3P[^A +XexL= v׏(p]3wt9>CڬjԄCj7/+ Vt~Q:]&NݞRv<*~9@%`Q^̏o4G!)&^d '`"x47B=[~CvǴgDEt 9~'m$t8#b']Ql#>˒2ʼn{4Oc&8:,>T(*܉OoU?lM*L2 PuԊ11^yA+LFC]R5דJ—:[ ;ECYscgf;Sm +_[%#3mM`tmDCoM`@L _θ 8rr/߮SL{\n2;JK)~Ѓ:bMgqEjPcS' 3hy#ģC,P擒K-`"V_x?6ۏSy xzzZ] )*y%2̬V\ +M50ˊrN)ws11ߙ1hk U=? IeOP4w`Z98";3 1}s[j+Í,N'$lve^(^<)D If ٚ0-kxؓI8z!s ьC1ƪPp0?pȿ:@`Anvg3X_R4"\ 3̘5-_YLPMwdz>_CgJQТq +G`xGk6XˎβԆSد*K]5CvkBa$,፹͔_DfKVVPy2΅sT +>ﺋFhWa[j͠|fTʙg7'(+J&OdD;UT=UĢjGR[RSR*pO6R_#\aS4G`k&|h}>!{!fьGZq*l J 3sYA7ƒ~KDB.4`"(уsvp H6R,lV7@2 3/ݢuS|"n.=;8Ka ςQ% +=t%5\T=ĥ(E~ibB&&|;&E>ՏՏCc`Zrz̝Rdz٩ _ |?H-3cXӫ1^Qt/j 8'bKuC;+.*gf?AMZFxFPK9\ a#;8P|@Zcṥ%1Ckma瓚O \>]OujʴtDb_Om_Ѓ)$ir1I/ +| `$ i߀,SK[+k8Ic;7,խ Zq5dHZ眒x~n?AgXY `ԜLqnѶfaNYSikR7˯ّ&V>G{;^y 9d1"ŷ ?TsB8`I_i7ֶ,dS!X5BU X%}kL6*K3/bkdn_=Ӭ̱Y3@I'a b8^(:0:C<\ϗI=MV15Cɤ1tk!,LFz~: )@ T:ν[8Ld ~\<.z6O?>8jX<%=ʅ]<^eb=p虃 zʗ.TH&I^+QAe-fQ"c*8:|␀_K +/C +lwzXsI yA<،=qH1uUz3`5l + R 1ɃK(KBin!+8GN7o:AUK$sU,B$3`}i,%BsSe@c-h[4"D.]A&l7O؃($,;CZU*bIvN8TGv 2Ґ.Ev?8yt1ч(1!jX:ϵ+s1+TS]p`A[]r1$FȪlY,ue1MN"0?MoF/ 2lwVX;Ȁg.;}BP7p?tQ!}qZ,O^;X!NA~6n}i,yS1%SJ$<^zcҡz|n}QY20tE@;n +q0Q(x7)@>U'gZW Phƍ`Pp&`ΆWQA. +6O1 +︡$DZթ%Cl`)M .n VL 1 4utdm)ƝȄ8A ELZF)aV QlU P_oh.r~R$5d5Pp⹊.3u +;fO`8eٵ@Z(6v)>r1!si2->2$̲FV{!|*ZngED@0vOD,=\Vfmlo2xw%F ',zz ж^lQnR0`뽲-q{]R;q.}tYu +|z}VQX♄absS`"ire? aiӪm+Aa^~wO5Vb*۰n(d nT.Gk1(YP$R9bI)0@dڸp&j:z$45њ?Y'0\^Vd~}9F9 +t㝶TVz~y-GC"BϚ'e:,%ӱo"k,ٴo+үv!))9g백dFI6U }<̻RDfs`9uO!I#6Z +g5 wX*4@MX +k<7Ӝ4_ꢳƕ u++ؠ=#$P +?e6Tis9/ <3jx)PWsrzX}xޠ/ev*[r~t"*ambH(tbM|?ɶaTKS K\@v.]ؚ:0X|-vi$(גW47x^5 8N/&.;r["獙&Cw~b4aB^=i " h }%HHxYщg2Ʒ2igӒn%P9v؃h"?!Y2/8ĵfl ?e-8×IpeN=_ ̸%uJFzN'Ӕ+ _x< TUhHX'%4C +GuB%LOw*`c% 6Sz}~VIXѪTT|z<YRΓkX1? Z6![٧sWEWוRCW{I~`r ea,ZY*ܣ<LՖ2tپňf\m.fPrY1.&fo2_hY_L/1 ˆ`8ZnQ[Z?0שlCe5QCU/2Sݮ.9I #EVwu2Q^=QG ^̻d$il_Boe 6ٌa6@6 YDVa &Sm L~,[fq24Bfps4sh3˓3v[(Lz江B@z~2Ѩh_ M5?/Ҝ@ftM'$^w b3>& IHLE1I\ yݘem'Un,*y!7^<ށ!0%"ݵe=Mc~^0MXCcļ4 +2 +efK 3F{ΰ b u38tcD~ DCf\Ov~_vDJϘIYd@V-)Eg\[OL+xlg s_cLQ xЖW ^z"Nh%8|AtPcqy9?Esp*%)NFKR\ELK?5ϕivV`'nO%Xl'QN#a_8!`SX58hӖEPPUXتհ4GeN$c6L̡:ٲt)R_z1?: +`^VOu5ιL6I;p=1wZ?DC!XVcr]Zf@4Mia^96C +nLA7j^Q$&sfNa&! [0܆@m{Zgb.Q`jo_RϚ^ˌ0Q@& 0;!H{p3݅I*ǃϡ@5<Cc= *M0tճH΀JyCj%m1Mo|紗$=E,WG؂%A5x3 %RrM>Y+<ɱU]&Z9~$BƢdwXN}-0[QpsP[\(YvrЏ|1RYչ7+}lGohEǑ&4: ފ9b DB׮eXic, ? +xB3!kAC"hlJi#UQH"VI'8ldAh(Q0Vm\ #颾NK5Zcc4 (.. {hS'= +pKĵ^3Q^;+. g Dr*+jh9H$\:!Jy + +5 B-8D2؝ )pޡn."d̀i 6ݖ(xX! ՐP@ u\,4-*' A ZB0MXL:=8\P* A#+MCtp: >2.iGh@l 'b@aB?PT' c?Va;_M8Dy'|@9>w>tGok[6盆v?OONNyń4[еTmy}3ҀgA<@jTTtْ.<%uOv 퀌@$_ti7sti=5U] ծu؃/ Ah[ߠu5 r'X{>Kt؄~SBC(bŁw&iiNƵ8囘e4òz3 >÷};rxGP}M`f_|c8!yAH'LD, 奣-]`q@WflrFKWcEyjkjRn91JLAKD9#ivb͙! b.SvPg0Qզ86MfЩ,$V7 +U'/%[2wOxAwB8^%#=L ]d\ /7r]lV{o%ڋ9Oc5gjq(ѓ.pYYHqq{\;Fg֠-2֕įOFbE0-*Z], Q>Z  潪èx)\Ep(k2d<3 +g0IhCVp(Єsi\Hpƌ6EAމ160a 3k>gl>p i M?Lv'3y<(?j60z7Zѽ~)[Z@"}qQIU)d 3s"mS*M|Yٍ!:O3C@?v1$j6*+ Je5)~V5g 7^g?Xy}uwΧSl5aBah +Xդ .x@߸ ˭䇕~]Inh,``A*LYq{M:-pKt_bKr*2deQ9IQ h7aWAh@t |Fz/;*_U}&`)Ԁ؄BuhbQJ;'-^ahț@чY6&-*ge3 6Udh]3Ze&I3/?Vxn.ZMX] u o;!m-HՆ[S%\z:RJnb.Ut%Ȗ,9b[0Ey;L\=tOi x9v‚z'҃U[*AU~ "ִ!`]x\JǨBr˫dkT`Dϝv[<(oI#5F렱Bic~4d)psYP5_6r jP_mv2sƢVB_BS pg;zqW&'WCQ5OorJC̯E4'œ:a$XYx&mNr~P/ĸ +ryԛT>VEfn $X8j+X+l`44GJ;%{O#EH ,K%5ɭgqբZRq!kJ,Ŏ@: zj|KV^8"5d < a۠uUE%^7Φ,1~T9:oX1-.p:I,TTʜ >fTSPH,ʼn_ZtS5z!_V֊-Y^o^PЕDj6]'~S#v_%+͇&&GMј8Q E{ +"?J! D.y $B4B^wl 3X=Q`][q ęҲ_ amg<ꋃ|5|9VS$ +_ _=.%حMOz fvNJī& ӎs`< +FbK㹧Čg5/*QX(jBq썝qn{ ʷRnwCzy_U?Q?Yzh&Xl`SR2OGM+yhڈB dNi{сkWu:opgO! W+ҟ @jkC"NUeJDʃ*O .3XXPii7Z1O~V2gKJpF$SՖlUz$#͉js+ģx僄ul-4wQfAsI6 +>V/7diäOZ%$rmh)+!JW;I o=>9~f[AW%OIzƅ$b<,$#yEAjtkE 4u im632,Xay/JE ЧqޕEY3ϋDQbW Q+}ҡ;ڦ5"W:.bIZ9#] ԘBz^Nﱜ∖ސ&r,*?pnX WM~9IW +? +U0R174|+ZҋOW80 /:JH=X PR^ N?{'CBhi'miO:FCؼ"(T+; m)XVUm T]"O7n6 pņaZ/h j5P[P# +m|ܚ ]ZbJZ1ob֬lPC=u\; +!K-ѨG;(R}IJ cU brRXYe@sr27ruAsE!!`0$b։Шuqm`uaCck}Q<D5[ܵvPw-+L[c$OlUI[U;UJ-a*ՃgSةm1R(&hKHa`>l2]q|l@Hj|H+ f! p&+5{uYOnZ҈Y}l*pqDkz1\+;YN]Z"0YISmeO1ؓ$V$(8B #~rYD 7LbAJ;Zr>'fkm%6>B4 g 6aewXGl8\4FB,ǩtM5g"ݢ56Dy^1+3JPb)i jȜV E96?VvC03.r[3Ob₾dkT +n0Zhc:2m7S2qwIc`O+v9=+h#rbz[rkb9)К+ }樴`>%Vlptc-k!<U `*zezL?l1 +7x!SN- +]*@ugyD/19ilHAP8CKqs쌢Uc~6>:mp;\'YMkQUS͵]AUy6y(̌ա ̓]AB a̵zp[,8!lğ e[#UP&鹸`fqkRj߮xCPߡ5^JgF)o+{Jn)j ~^*AC3 =5۬pZ;_P dK"sa $r$.촹Ygu͓D#KT6.8V %~Ǡ^Mrj~JpZc il#^ T,/כ#V)z*Y]otB]>t JA^HeG߃%;WlN̒I)=\eYQҿP0=FAO,iv +?Xm82fj:>JJzDAHRZCH4LFnHJ!O>JQyt9zl&b2+~#?Dfs}kT3[*F.cU*I76fl3w3& 2עdgy*ދ:o&\@eV"VFRaL *H0=-%ፄ, F1CS101=w'N7??Nw"H!e,<ɸdH!⇩b./6s474Ioo r,YЬ+:Wg"/2/,۝6 Gm>aQ_Feh괧>z))zwGu9ͳ>w9e:@ɭGKP4D(bA߮טHXu} +a^ߵ,oʷ1D8뛻 'WdcBcA341ى:4@G/O>T:'!ɶH`tZcȻfrA =7@ +b)>a 6׭:.P]7mB}!>rAb|Rffr^_XnݎߓcivS>T]D-o]'Z8+hZ *-i;=-KUO.Zy:Ą)f@J6?yq366 wOZTLފ%#ysKX&Q4ڍ/+Lz~C-2-|6? )o?48t[~J'JjmWh\䍐(!5^3[xț4f!0=^W]B׈#0.~@H9izȴ2 V$w =+iCh*8{| -/h'X{kʳ+OW?#y]qhi#\Z!3W>J&] +Lvɻne =9r +^}q?,` zP64jywk)`)bcs"a:4Ua-JwKbx´$B^uy_yz1Fr*c{ՏTlt;2 #F>Evpt9s}t2B^ t$OLRk:jlɯ:^lcg^Wfc\l;}eRYioSPJԸ8U o`s\2lPߜ6RbC3Ya3O(i&3^3ZXpFZ33VVvwp39UUѾA]u`GiG9 HIJ_띎un7]C>)@:&$d [:mnr˼3  K|I/ pR_,aleQna6 ǕӠaCfpF .Z} EKgI$LιMqxT2e?b [w"5a)1%ļLI/lو2+u-OI?`/+A~(h5-OY1ۃ3_4ǘǏEb'v@rT˺HXD!{ץD +%BSma `FG~: U BV$sᯔ|7>BS >YSGw;RtD_ĥw#y QUq:md^%w$diI݈^DpYkˊ HnlGlRORRDs;37OI#(t=*Y9^`T.WYxΉ,=tIRTm$T[5%fVԕD/Zr-FcՋp}*Tߤ)JhjnVAB]=_2Jό=+XJ(Fs5Tf [ܤGщw؏ q8\,MY2l\\}Za8ve#HՊPHZQH,8f_Yc̞RП*0)JF)?A/`#<0ik!XvQ'D xHO + @Ї՟]D}܍뼩g~1kDcVR]){n*LiW0GvF DBr_MUJ+Plwd)'C==n*ٌA(ӳiÿ6f=ť/UuO}2A 謮6H<,(a/jDY4

lJŖ Ltv%?_R?Th:1Rt*0.|B?Ik'V Womw9n/,__WvY| ]Vms~}j^~ -Ln}QU&L6CdK}roTf$0b{[Hq- hSPUq,]v.k Pނ((ߵ'1kv'eaPSI^]oTPvnQS0 _OP^ +2AǭÊpw-)V6 NnP- n./iwrX0eTj@KS n!wQC/Ξ(h곈>WUZ|~t +Vw0Yݧ{ܣqrݜ,g6o<̌틢c t-]SNkR, F֯X/SL`Es7Y3 $hz˾[cOwN ŕG.^18T -̶Z=?f}ofw(ѺhIDȴ$`tӻ&$B) 6V(7 ^lsIbX.ypw0" kmtqA҈WVq G8|;- (<8J~H% ;;#!r bC9EQnWQ\/r;yጼ4Ft + q/%{])B BM!iTUJmp3k#%,9u6 qQO]{TRQ?Vj]B"L{}z藑P΢nzo$g$3םXjrnmnVd04+Ui4]~| YKTF6žw(U!sn>VcTHhTF%#d=6NRu֯YT>p1}f:0T~\#u_)fE*HÁ2`_Ǥ`QW)7zip̠;蘙z `\!4OڭJf7By(=@!5]%J5]Ӡ +ZQc),r7.zWlw|,dv +Q>r[h a GFyD)g0.@x6- ?:yڇڈYV0<܎g3E8\jiAѰŝ&&"7"ߓwĝ%}-j".{@IO ;jP>]\e3l65͕ 69V0X#*@I$)ɈDh4ρj@𫥃?eXbA " TqSV4as{0O\B]o(}?!yϱ?R"DR HL 0ntLl>e%*JIue ʄt+vn{Om8َ4km=J9@I%\h}C4ȕfNv[''&+.]eIKAzP4؍QB]@+3blR4-({? ިoY%qz^dbmpZ?:wfd{`]-b>U\ yONe{ah!ObR^zML`aa, +:cWgYqw/YD8g?~3&!d,*,ɴaϙrNP86%sE2H.Ɠ&[-f*'}ZDF0JRBC-\JF5&r*|or N[6 &?\3v"F"&,u+u.JIPHBzFnO,,GzKL{  +̆Q` X><#<2$eZ% VIgBBE?%R3T5*aDkQ J<Α!J8W"TɘDXlK""F $AhaF^MZB+B555}C7Y\6MgJ6L8OZ#*JE HDipj㜂eqbb2\@vPՈCNHP(@bF&^%E()]((%0GiTL$TrRpHS!BB%(8!!2Erj1+`p"CydB!8D!^ 11XPEQ((9!$&3p6@D +2Lc004mݶBVZ(͇+P`˖l`k>N`;m +k҂K(3P.36bqx +1 ^Ra>SÔbE Զsʆ&{a{՘RpLR +Ub",&4TT*"CU&<1֤7aՃP0Jae) +UI*V3XB)3aBhB? 8aZ2HRлYpWL 2 CfEMh@sB Pa(xEJs WЌ^W98;M3/ϴBS z\ixA4 v$ +uh蟅Z4q[xqEJ[M>iUDһ QAjp7c)8K2=>S'iѝ[ʔOz$ XI$,"E#QR j%FrWC+F)򧝣HSPI}ZH,̨R\ "YK ! B!rL^8DC +2$GoJWpUV>pdn'??zoId&)mP=scAh2~\2ItMg?̜qIX®i5\hre݊,&⪶)^#*.\VxfATeFUWMJbO֒ɧBG,2$.Xf%pу7Ɲ-2- +"$?2$ $Bdc&(0욷0lۢZ ҔuM.+jAh*ZD0:OLЅTb:ZP'EثG].$&t{[%Hm}DErFؙD*EK[7} +Y!qЭѫa* +M9K*Oуxd +tE&NQ,44!NI㐛LSA.2gF@ +Oc( +r<ߥL±p!MX2ti>k+k%Ep%TdfNáxCC551!^D qy_6GBdJJQ$zWwj 5J%z/ɾBau"j ++FÊYڶS2lyi,D0<8|F $N)"<ETmDg%o( iYe2aJ,DPRU"$$U231BlT*QT<a\i(L<ϭNߏwz&0'#h<3%1A""""B1Db)ū7LsigVщhg qQ}׫6#fPEUEEE· Q쮐,N!sȊjOeAqnEKT0]l9LUNMY}Qc{/pF9\p˄v .ȑb"wd'duF~_QjSGԈdLXRMbkFِѮ^}\XPB<#q\Ñ\*6)ܼ."Ti>j 'hxx,0P@y8NMYUj.;ԣ%YU@f! 1<Á +̳'f),Q'ROh:`2X`@ X+jr%fxT/ \QTʹQ/   L 1 D  (Ͷr>IØs88hV3u)ř=4j.3nQxDcHkg#"$l43c &SbT) 8XC{c!1,`Raaeшł%~H^G,>QɌ4rG?ReEk餛VD*kX׊|=ZԄSM ġ֩.o.ܘ{^C'S]D& _5TeEyrƏ.s(*7D8?$sP߷?kWS|oýOGB($f3/qy+1#o\Y:vus|h*/$IsB\VHD.b r>k[)0|ӦJrͳZ;l!J:q,1gtF"Ȑ!gԉ~UFg:uj 5hUGڦ.83 Mj}$Ea٬${]ĞQ1%fE[Ѩj"Q>ZT O!sF+RԈMmj%\<1R5 +&3ʨksܕ{73 Y_ѓ?S}"5j$/'IKhGecܙ٥Q}K.Ǭ_g4+dِfE7bJH+Cl_#<3qA2<-ohUB tGd!$S?N-L-4І$쪙kR qlۮ&!k:!Htc3ddY*Sq+%u錋3akbYK4O]:~v"d񲸏1U'E6+8sNEc5AaԘN㒑:EJ qb?pQTDQS}f3w\Y"^R5xUV&I./Ⓕ$g.΃t7DgU-VcCeyVۼPDdP켉PV+ &[޽WaڨW+TF/ZN4<OzO:KڰUfvHj4Ӥb6s +3m/ʴb .AB +U8$CG zQb.iq̌,Pl-qYd<8@(XSA0j "` +(^i -n#y8pp3J+F$R2iI>5 Ӟ塣3F;h @ +v#9EF5M6ĂT#AdP`ɠɳ K!BH5T/R뻄\UAKSSS*)YjQG%3BpZpP*PF¨u$T d\ɧC}fE~*H4hA 4"΀й cnfE^B2py,P&4M thhbZBCtk_};H"V@~bQAW+T2wC +4Cga`*/ LP(Q 4"~Qo@:I9L +aHY.(*'S(U4:p@ Ctx8FCBA(*"T')$!]\L\̛ds)J`EQ^b硻!!pƭ?C̨4&xJT#8އm–*poPr6w 1n!;~|iLL)[.bS/9佃,!kae@r K61LJxPp[bwkMyu5#t' so$fm(A sF'\M?h&.hnzOP!a?^d6{EgnI}ӏd!=wcOpz2Ii{#-*hv딏߬dRJbļNסI6CwC8\G>A8~e"pb+ݯAGP9'Z-'_LL+Pd%AeĉJ n/lDڧfX8Y56;pBx~s#t\)_HFi6"0\D)Qx›^wy1,@޼H8qcYlI~# %|)*'I쭗󨿑Gj:^Tюo/BKɀ-7keE b3G*xu> 0 g_c)N =!r^ =Uv/p&NPm Z>|+( KLf8QFK$uue?");Kl+aoLj^|lt4K}l8ͦ  12ͦ4k`. 5#qs{4sμn\>ahʐ!1$\wwQpU,FurZȶ0!1+e4M؂Hx+2Y}HFu|ON/ҩ`G{rcm<8Xt@p!dJw/T̖CzST[|aLޚ WE?v(@IHРuI!# T8;.'Q146L В%@?s,ܾ)NH}Z)0ӠZi'ĤG`XO>Lij4O @?D6sB %:cǢ&5%K13xrpNbHV(jLViOUϼ.Ttc*A:iDm5!8$Thn*?MJQĚit|d 4-#>h^j+#Vua_ݍ}lxeArU]HTKvh:}V3RmcGfyMCl[Sm{ٕQƏӀ5 +nx!FVĪ"ܭ"ʺrSE+R_N} 843,i2"9mbIw@}^68C c*4 >=Np婅+4v=DajX 5 +`f13Y7p]2aEŇN DҼ!efV''vJ1I[:1zk7d5O:2MZw?Aq4mfn$&|gpfO׍ᑅCҰ0p4Z&NzjB|$Lc 5f+2}G`p6 +"db|g27\{Fʄ~]H2FI9JGCh Dt4_UfTnI z]ET乡 LʒK%,,e"AG=pB*gL"4'0M/L21,̧.C܊tqk!~,ETsHd]ܳ#ь:I@a ]UH}/dVfPlu9/O0ZZ[@`JÆ^eEz_Dux=޿f8Zt]*NZb T0nY1bąw9P2wN=M"R#]9|bQq\otdԻϢpZB8ƈMD + ]&f&FAy*olWb.7'Ϝ!-I5C&0ќj*zr[t53T$)~nX$ 5yrxt.HSl'7\3% +@{e0 +eu'DtYIFSk#A覐^4#TlY@9e#F?^k0WkhdW7őMm+j'dSlcdPяs1> bߤ΀ ㈧yvn:;c'8\hDD,a70Dp%|;< v*O8}:Nj#o%ԣ!fcB<jzbរIף|.ƭيVe@|U 8zq+?~GH97aND` 6|Þ/@U^Vvy}!4H>ٳN=Uтh&)wM`jZ0 ?r5"f"25J]6"ijMycL!DtqSf?fWXWte®{# d{KW14fMuPyE"NwKУ= :{UI8l/ +Hm(]zj2ӊQ4&k_aaV =clUѶPq,(F7 g;+3-PyGߔ:5O&!r#eØHy M){K2o 㪓=4mF\}Q)V̡&lYW}z_.0aaA`ꮨ0~fn㐔X?1ɼ/`F}:! +%->:{h0$a1;68éyfVJ8NAÉbi<$$xwl>d ㈒&q|I"m6^>iJ%@24V8l|E<"CRAQby5LTW千Gut2|vQ(&!g35Jw+s .۬1.!v!Ν;T|FxmiQfܽQY=&< +Ie}O,@ 3I+>e—|; +d*&ʺǸ(ƓLPѮ/6ՉDZ9İBF.dp3~NA)簒oe{HҊ BKh0+ #G}dоj_pLGpi̴Ѝh)>W9mnV ^I0=8{9;bnZ_ NyyIԮ}#& "_Z%ޚߓrn(}bG͡B1$ =r6zr=VboEAk( +4W""q{~B$LX, <څ2Bë3n1A$/s wdzXC)N7D}PH0 +ڤP>Ǚ@#Ŧ\%X1,(%kt-,y0\ȈZΗ*V/RZ%}~]![l'DD&r o浝G,ZT2 OtS4ʙ9fFkY+ P:Zm5NM -z "Rޥn)= 쮈?{fK%CK/H 0G`A{TyTD~"0uz|b1;򺭎 #zE A'ڡhJ$Ř[ИYAyIS + ,t8JxTs޾yI\A1_e]-k]sL_fDaV6e.!KB%9?ao5A4*i*#bu6(ŻJea0eI \p\$9 sfjf7G:$$K}z<AH~,HO).^ЭA^1Q|2T6@α+p FTC&%Im?[~"{E8$tߣ-*.Jl4׽Y.N֛rZ"]6.WcqSBKȐj*?XoO)wMa EtXO[BaxkY-ƝߡK8=\`_;+7qkxsIo۴;Bɧ5OC %!IXc\v7y*(3z shvSA=~q#/B(EO9lv87=d"?jD#YN]r"`OT6 +f:?Xc!Tp 20d9rtmS ^ J-Ox82 ]sU{㐛"hI)U{ܲ(S@a$ɬ;u7v\iY)U۱(vFRaQPKX*1Y`Ȧ]m\?gU l-Kd gD_ Z0OӇ3k| ꐤT-1" n7@%n]+}#-%aܓ>_MIRO d I--SoQ81 L6*fpfE{Fculj|@؞}7ZXdVa)ٶWаR[9}KcUT%3ơyK8;T%D9rHAq]^/v2N崰9` !3D3}?;+Us޶-ahki]=XZuabVL[F$0U(6)V3?O,_l5FZKXK&"-\D牶_&VE U1Φz'Ŗd)HaY*Bh5IF.=FH(}tb(%TM?>m?73L)U"3x`z{$Y}/ ZzVi| $́,`x"EBD`L m}5;cKR=F~Dw#-"-j2 LYCe 1P?4\ afq@ߥ"9,uƀiՍ_DQT0G"]Pnp^`0 GZ԰Y C%ѰMD^C/\R4݊^? UtjU'{+TՕѭZ {;4_sv'b95i\KX˟.(R:Ld* +6w!W +p1_Njî2,2H lya^B0DJd+Nq rkC6 +K6 *%7ٓ抴=mpJHG ^l[i6k c G\Ҡ 0tt{="YAa싥,!ƊY޳V~CY?m z{bgN:4f1XTň>=]W. ԶĈŸ0]S 0b^PM0R0q@E`k/2 vr{;3 J0]1H:4(c@Q xP.2XÀZ!d8DFao Uq' i[D4$J @rpV(5-65#HDw+p8VEȄC%2VOםὊa(с: Q̬/v͐r]; 5;>E'xk"H'iHL45_c|aGaO#`gD4g:"@X5D\G& D#D!Š ҟC@iۂCm@`Ct8 +ACh!_1~ܐ#;!€@ؐ< i gWd"dQ @`PDZ\ I֋W!fSHuVH )8V>)#<("AV0">Q++䣃B>*0|@ů߃eq7=zg{FZv0d-Lh!Cz-,TpߪG78zP#ӃCzp'CJxym G 8<]8[n)!,/:lPBqƃeq頤g\tp%4B ̠FHJc"4&j(953tѸj_@_ DrAk ׀?9( %lٰ4rφ S6=veqmq*X&qFKsCA8xLJ#qp4o,EqgoF8$yCPGu#C&<Ȑc"wѤCE^E 8޹7qlZR!r)oorlX9Zq7/qnTqFr2KL2A +$SJǗaͲ:  3MŴNu!haN :PpP 1TvW)ԝm u뀻6`jзƹc&p ic~uā6l8]dmnlFxLNGH 9y{14ծO. +p:<=k65xt2f^# |S Bՠ$џ'9K Q50$!~i8#:N6AC ш_Ѐi3 3|``3i/\)ܧxbsPn`j30Y3" f: ȅq_엁Qsl7'22V2j 쌟 #nqdRspR"22#hclmc(d914G+Ƶ0r "k| J FҊBA :b9pqaa@/ * ?\" ri Ua5%5$1FdG7 Kto9FCC9 +^yr; h9&x:X@X:0a.`\s)߀^g+c!BUj? /˫/)/#wqQN{^^t0/͏H~FGwtb~tj!vAj.:ӅWaj7SĞ 5Ӭg: b;;;׎pJ[4kow|2An!-@)maY<d ׂCym-eKG&<@W联xYzhqw=wfA #e,p|SސGdaS>A.8 `GB?GX8iWH+^dsI+S@B,<ѴM &h"oV@ b3 VL1 Ŭ ?V! b&DV. +SZ( +dm>$mBY4n +>h &>=,SO2Or'0\ ĕB4rB@d{-%C$h%x0&ȆHk.jM"CĜhnegBZ +GfHD3dBB cG"q"L  /A%r 6@/[1nDj u/HY%W"x9"ÒHкDz7d aRD%KEy[NBH$TDmllĶ=ȔAa$TG`DDhHX#0rO6# }#q +:nG`dG O*p=b@T>bG $6 O#^Hg A$<8F@# $@K!x"lak&"os)“8B.%CBC'BW1&%%B)|DMۤi+C\d R-?%(pϸ҉]!K_8l8&* +1B64!7!42`%k&(uيA&J4y;PDrjMfM$qmrP}o3 ǜd;uT@AӸ'I 2}O"I|(>/ |ғd9z{{o;d'T=eۀ|UCr(U{h%G7u}y^J +S[pLqf'N!(}uF_= N=[#{"-oRyQ_\H +˕sqDžf\0- +$ +`# .FTA G X0;;lD?r€x|JʋPB'l;/r&]/_iə_0rUL\ Lܾ̘!pK~˗+XÙgyPf||Tg\|9mޙI%BtP q4_9&tDSL\!2A8XiAWIs7P7 |)k3n@U nm| kH j0Ҁgd k5QWǚ̜&jpd&׸062 2z ~+kzGHݏA~"6rAI ka.B0@/ dɈit7x1)4G&:`WUQBP4FXBgEY vy1d4TNH\gLzhQR&£ 0943PWT+CQKa0w+5@[nMr[BǙ{-T -, o>@~WiaK?C%/0b$O ,0|yƩGE.4*ܛy 4IAZ G(">|վ3N}!/ +3j_'y~yۼt˕-rJ&~(oiNwxl +XRf$sS#?+B%j0f^f0&=J0>UwG*` k_^T@Y:|1o5ZiϏgEn eL~-j&gϏB%}4:VI-S;/?6+Cv#5a|-K{  +9 .=cBU^)Qb.T珎@]哐VJT0*:-?aS-;dȐ`'N~B!N>YԊ"kY2KO\Mގ$5a|UQEAᎯ.n|bžd3RN[9˴+(^Auϊ40euȀ./9k0PY=eㅚ0~|~`\@>zj//c<l{6_vwSk7j{:xsK7g;M玉-8wh=u>>C G~z + Ek[S6{T bD3Ds~F]#{wKIEuGT-7op2!Cyت4!5R}m0#nV$G^MRxjU*(m<QaEr{ ,^=&X oUɳMb謑S2!>-2a4wI5٦>Ʌ:J[>lqHOI1FC3r=3xP}35]h}yf6HQ瓳Y#*&]@/wX/9'vKa<㓶&iy~hE{% c^M>/?fduN[N١0Ikc7ISr$^Bow9҈0V ld=g37|drl>nPwB@L>sb;NN~nUy%@6lAwxN21tg2[4]Ҟ"K'i8nh Ccq<0WOoWBBzvN؞w"}lDZf;R30W~U?!@:"@Ol#l?ԇx- p<:;trvP6U/4X>%ِylއ= _Zt XK,Z㰧IWrw` ;$*e>-ya%߉xGeNȢ`N?PT (]c$7)ۻ/9hN#Mx,9@]&],Z3p4)uΝ?} +ٶ8#]$e^8"ր;|tJ< y)J'a)xG.qrw +{* \P>iҀjSڽAf|)]+s- ,0qq{\[;`ں30P's{yxNK`Bq"w+7 ;j=Ř~%wp Ӝp3`y&l,`X daªhlG+rwF sЙ0+b)i{Nk9TAv!>^]Rp45\3fgdv8֞N,ۧ°OT-9D짽35FҎbWb'v, v!7F; u/|~T.-Mܢ{O\ԙb-m3a5{J"̾WŲS5Z ZHMOFflwś5ޜRp[=&p4vzg.|Uj# F^i-GO3xFQ+ߒ`_Jd XEv/YP!.WSKwvn=["uZF70ce-A̤A:/ t.y +Ǥ߀ p k-u~-w̌HiY@aSֹWJ<$=j0% ;Ul>^eBKfdxtEY]mMtRC6W9Feީ([ʱ/ +H[\`]}#:A~n0NnI~2=r`UOS˶' +l +h ãzHK=LO^7lZa^ɵtAt^ Ufz^ +I󀂚BBzAܥ{g{Uq+K/RIv2_x*t&T:(]>G5P(`rIWz,HBݻwA/Ǡkr*чf Bw4@>_H%@۳2oEG) \YD/*zGݩ(aCDZ ~Rǭ_& й&BxR?>6Q0lprBk`D9t)T9]'30D;@習4k,zI'ܝ}7,?C;A=(SӫV|P;!6΍0K +F=:`c- :'%U\rzBm ~t K>l~13aM8|R>$]4Ҩ_&k-w/ps ey[sqkWLKQKTQ c.]S{b VGT?e#U1^oco`:d_Dfv^^$uH7*.vc]~ww)\EH?К,e{#ʕ)JZ#*nNxHVΎ_bT9 Ev_+\VPb);#,70$NEp&+ztړ)V󉌜NJ#B&̂{uI 熯Юǖ)Nr?H~d˫(H wcA_kX(0>+T-\ +JᩮZg GGE'u ︑WhSNmw`SYY=h +7/EQX3 SM[‡E`[dOᡓyMQ)jqOŌTS8NC6i)^e-=t˹Y!<9yʙ…}ЊO;r b^a>øc&p6L C*i/VףH`ˡ.zD{C3s^s21yYghm |%4C D;[LpO$DJ8? +е5 +/8Y endstream endobj 25 0 obj <>stream +٩w<+c4P x[G~Wiҁ; O/y=8l +\\nnOzIX1/+a&!o__(EMӘt)QrVж7*iI. =sb ؞y,<QEf ,=Ic8N%Q|Pu4oMuK/: +_{z@uE,i2u˜`U;%EY7"@~Voz5T4N?JX:o6E tMoBH]7>? +ȃ2Y#thx YۿnC,7L3DC=Q%bǩ:ɋft7sTU8Jt8nemG&$rtP)Z?Gz;^v{1g76yM 3 GdaT_4snm_f[ FAVTbZ)=+;§;Ԓn<`#StGlDO|qYktPNeP ˜y\Ӎfm\dX%~\oOm]f\}ArpjMzϺyQ.uqKmRzTw =^nr_w0 &:.cPkԉ.nm +g=Rp.80u{j%ҳ^ ޕjm +]HknCd`Y`ݍ5ʹmE37^º_4~u{mMlXRZLy|t> +VC]֭L\nh[ @\w[h&\wY]5jO4ֆ^dXw+aМ +;haݹ 4𴰏뫩[7}=Sw7W$*zuP# eՓB^݃O5q xWC*W7 h3nDu;!5M'Mܛ ;Z[[-ࠌlMݗ#VR-`஘h\7[s݊$ւ݄Xn|z"Xuo =\ZÎ >ZCtu@1wS VB٦'mnLkz`uBI0XJ!p΍}gnfJ<tܗl?fT_Ͻk$31N3# :ns>H(-MNx( ?R{<(6K 7ʂ niWP Cc2uze;$dPpeߩJ9x{66pE  Ň"k}mZ|q;!X:m5yZ0l7d䤏ǖD=^~|I˶$EyjЉa{bH L赋R`-sɵcަ/ ?ȷm֡+Y{Ev?[N/h< +"5#ìZL^~0v-~#m< kVHʼZ0]&}݈0gn=8Yٯ r,ف @Fa`@v՜ư 0S(̞e5B+U!f#u"=Z!.םEqS +nePkYݠln9=ʑ-9l)F +ge|A<sl=cȯ{ǷXcY2}_R)g,vwMppMs ]i܈ `mWCkQv<>fTp gyQ{h0`'×lCo8рqVlMʮ|<60~-ռK~Y}-1h&jQhk(]5/A~)E^YaNf!l}fk''v/{Gџ(ِt!]W='=["K8ĵs 03''O78K3usmk߱5Sڊ]ɤ-\ZKÈ&ɲ j m(%jֹ +@< Y~ +P`eaX%;α6qv%'֍ v;q-:)?`=#\5ECWO~< 5w5 /\h +@s~bzi5IwíKҟ7ՂpB+[s氌:)jRw%cN& IP)%pVBqPXKj,P|8in12 t9b.u&g49jPӚתd8}KiEid$-tfI06n 4Gaz1+{HEaL|!`T~t4NNCH5{ډGtJP%07nқ&:H%JOlD :w~'MP& ֯ +)i;2%=oXHhP~hӅzQ;[!ű`)4lX4Ѡd.0ŖIA`d@l +D8{ʚc 4Hk|r1e\ݫ}k*Ӣ9*c/UtR7ǯsUY>>FT bsT8G4j?Rه1 rBVi Pg>5zb9!uSE)4C7`rY㕷Z_@4mt2DEB" cEfldpw %ш23Ot8-1@"hu@<怶t0 ݍvHx|=;^I\)ԅȿ\\(,)YK'iI>N>T9fM,؞¿1U&%Mz1\uͳ$*JùCY#e2)dn\zqNȺEF#5ʩPjk;S@Q(tx%;k(N63uY hI tn&7ioO!ҧX]h.Hڗ55@oɅ#i_֞fQ` +,;H)ٞymfp?5kk={j:'XfA#ÎXsR͌^`yFXlOաTWlLM+/]sIkƚI1BŮu㔅JhbhfR3,AYA5LRKͧ]S I(>1fXXM!֒. +J}\[.nж͌?|W7@:axlfO/3$iw3bJ?a2ܻ!\DÝ i#B?>Y3çBۘ)bUs|?S `yG(jB#@P,:DđLRf~.?vzM_mm?)% Q˖&qtG͞JoHSרpm+[ι/__|םEj_NEM~'bYX OX$' +OF91XWOע_8F9{JPkҋ#~6 +$MݾϮOӭc1u3?SDjkS4MP@ea(Ä'~h.S=k` v)AhTŢO(pY ^wh$ѣl#U +cBʙ8Qyk0%ݼ{E9@D1=h8qtѬ QG,7k? U ۇ XZ\H' [%u f4x8ƈi:8sT\)]rccӧm,8¥.u[*Ժ>g`Ss-11%.^&j3]; ij܀6h`Mmb5"LtpsNUyN%2Br} +ejS4@<B <ى P7-` cMkEF@"JZGC!TI [aKtq6iVq^S9!1XVMUWÆ}A=aތ8%U:kVYZMOr|3"PzU-utrOu2`%V:.ĂjG4ur| ~YYM$FFSPDn^ִn f +^Pu\%c@u Nn+YYYrZrNK%/km8TbjYvOOɳj$ϊy"5Y +YhfuU^z}̓6X`ZR94P={Zj'UѻZWP&xlom0t^kcLPZ-4[{6-Z-bzk?n;So[QNp'moۜ~֧Ht@(p'ᤕLnMi[[+"eFbw.p; wrP)xdq{ոI4h#W\^ssmŹhX[9EmLYVt]ѷ1u6Y. ,Y yEn6 Gڍ|t* w͉HݞmzfA^[.!S^I"<2/@%ӲޥkRMN:k ^yGChȽ-yи{/ci—P}yG.`?-/?^C"\o]w ZAGw׀ +09D㯈w=> p[]R;zKwS}kӤ |eNhe[T)3m@Tc;xN ]d8v쌐):`l1}oŔpY9$BΗSyӔd+ rJ/gRbJXA";%ThM\kw&e*0<FJ$-˖Yz[@w!1ƈvHP[ {~ +;`8fY0_3;`[q٧QpP9}(`s(rԇ1:"}Y3'hz+t}''3eR* `rѩ/l:^ *x}on.Le+A |R#jkM|~˨^ +5sV®_ (Ue\40o!j$r\t4곕kh$y~+Y`%XZǙy%Gш'-@6~P +ͨ}izI] +K>14ƯY zt9m#lqrL;~1DS[_y7e~Vpރ P''xcA|%B $S6I*?At D'Ĝj_JJw8cHNN~9d|f:A]8;)s0;T^ou(&-/s,FgD7:M`Dl[I) T3 ?%' eє&'5_e<~wGB:̈́X8F8%"#[ Nzv ˆ0`m^"0!vw%2FO@K/! "VtS`慉ў^e"y{ I#x>(D } _.? TiI鰽rH *ZV?&AYd'^iFxS/,z̖Sy V&^t$i0se\`#Y!v ebZkߝvF4maǫB s Pð&Աq5R <|*ÛnXBlW1"!$L'"Z Y?Ո~+yClG#vG\q7wW:P0dW,Ɨ2^bQuvDѦ 4tcIK&vDֱ1Z2`[sKE;(Kx85?P+|Pi¤?%rgxq I!Ğnԉ|+JG>[I,`J=)h,g6KS2\8jmԐ]&9^v969>n:s`<eMK\Y9xK|Hqi24YLH |L4S.kf1\Wu?!bI[N6 -8d3 _!V1[Aa4y$&ѓs(&'SЂE2'HFOA~&p]~AcAɈazj?'**ॣ'\n6;~rk6!aD=:{%$xW;S d@efb1Q6([eգL+ ~>nI jiɤ6c>/EæEV~h<'<埁{NsNY-SQ+77\嬱[9EݶdXK Hh[nM G\oH-y,.g cƤ˼mٷu\_5e ;53 vXţ&*w_.,ܮ9-aΟ_tǼM6 |f2`/AqHG=+dF˷ZsRP _\6*`8ů 7hrFS+6Tni*$ZXd^ϴsC2Fltpj::]%RΏZC҂8P1N0B$=XI+>]!eCG#G"$DK|L]qiؠ4fLE6XF/ }4 +dK Ϡ.Ƥ{}QLMJJGLrz~KM1 KMJET+6q@u~OOȎ ]c9Om>?uaꌕ O uW#NfjW X'[UȂ?u~-S^Mø~jhvPMVfwCyܥg ^Y#s%WxTg7 jBWEjWHXvB&QM 4Fl+^jmV>SrT +|$WT@(GRuM5:zd?8TYVt!i{QǬ9@} C5{?x0j b(~RݽNU[ѾMp3K7e6#V[CAԘ ,(= uThn`v)Qc j$muFUvET~ Ǐ9Ow@4yjQvpp+><%x>zPUeS9gҴ35d o3bq2)/oO/Qb +4]:',M=&S$m$S{_)P E=v:Z@ѐE џX1mc^Υcoy;eGjB[ 53e\{+:\ x$zGQ( )׏Q6+&#ΆʵKf7e +|5*C6%rB*`W*Lo jK.Oאp\}kU`#-EO+]򾈁KzbNDX^CXۮ4k$VFЭ2[*hL/ٵ0-܉* +>u*sOܒ{bJ>ZV&TvsGaR&([8 ޥ%NjJZ_N#ar%K'o.TyW +L󦞛7ye;oiʴa%%fq-?EBq9P+=A/Z@mLWCۗQ_ !&5[F 9k]U=uv!m=ngϋ/f(!R7""!22[mn5Ȋ,p/0UrJ[G {7]٫Bix*1m}%%s }~fgh[pSD̜Za>~l}et!_GpSgOPQ' <1װ?GYIi{. +}eg{j=6!#" h I/a~Q~:%<5uh73qcLX{s7RcwL)k!>^;i&b>t2wlY +g]$K>k$@{;߹^wV̝A{԰0s*ANw*4lOQY+pX#Mn{>8ӕA{i3l'`xFgKT7bܳ47@C|~;yw_'P}'<ǘg||^O)?WjЮ4rf=fl=˿8 ^<t35b-єVGe F4N2nPCgHYW8KܦNAShg3vb4O'Mj4C|7 mebes=CG}6l3`luYNgiŤahв>uu؏P.u!Hi:WFH7qut&eW9l<  +`$+^t&C{64l3uk2i H2%rkA$L Fd&]%2q bb_NoS'L5|hУv kKyj {5wl5\u:[8n;hs i4IhMcHguY GcPC\3i%LޏD?vZn\P_ F;\9?a_O/ ¾k:ݸSׅloVuZ0Zc1iJ$z1S&?u +@k M:-')fό|H ND;}roznl&M]U:2_op tyfh.}Y&n`**tGf[ѴNV upFm f8V=,U~ B^"ȿt|L\[7H[騤Ȁ +|jl*TC*6 F}E/ԸwpP?u_hq!?v6N`g/4{gY0[BH[™%UUx0'?+ɧ:5AzQ +57|lR_jtZܳoؼY,Q%Xƻun#iy(Ұgz-]gcȲa>r}Ⱦ 'ݠDBzh+XG!I/XK1IGs:W(Q: HFjԳs>s<8mvQ`e,+s)a7KbSAYSqIK!Y7i~sm^Fn,;S76<AI4yg H۟#]G&-UZh'Yv)O%L]YMa@-jX:l:M HMZMSW6lOpW0cv㱾9W9/@N +-DT& +m+ԩgŽXy" +~ϝW~ͯ R"6ԧ)x'MAy&Z컑$o#G?[jAvPؙeknZeqMotFy񹬜GwtGp ZHeJةN ɾ{gM]-ڧ;ivvmy/fgʲD|2bF_ OG~>mJ=op> jpu9o1$5zj^ dQQ$˸2nb3[M_Y=s'Fȕ9[1~fTfh n0.ezУoz,}uy7'QW?]C9CM+IDL?vC<65P,(5Mu%u+=Е8]6:? + d8*NEbon]ԫnC=/ׇ*=ÑιGoW8 ^<(R:\9xg;}~P 25RcsN +LLQKb}g }E;aFc/6iZl01,$ Ki+YˀM3wlL_sw&򒦷[k_2sX>v#3WR/+.*&h 8*inBRB>AdolM ;'<#mjw5ҶyC'NBo@4l?vm&@[q(Hhg6Iݛ7Zn,{6QyNO$qz[P^#hG7j݇p']n=9J>"hm#rg;}w>t;إLP ;޸!<(Hr)}<{Q.z䳇F{+i蚻~ֿs= W<2 =9{p&r2Q~K[I̵"7Xl 4uj3MݙĈ#xV<ĴOb]c:,d_CpbP"ŴΰS>r;ݹ Q8e N6P{} ߚK7l]fy.3'#ɲa3K&Y> جoj -}_p6ZMAqm Yvf.Mq#gdn[C}P^O b4-?3>Wj-[lZZn쌝Mg&1dW J>v];G,u"H>m>4'Ѝu@yuu!'B{}+0\yF8mu,&; G@=r#9H~rt>_Sk/]}@IgւM(aNADh=yӍAyH">a~V?s^[?"k?O丷㍳m<#708otϠ]?M]|z h>> +/ir?S/8cXݔ/0ٔLqذV; H6F?Í?xC|6PuzAvNXKlZumnWZ÷&Bz='6[:6f; Hs&NC|5Q_mDX]P`c=u 9-H=sG*BMz:A ÞBOSWVĉeeL}0k[}ט4V_c(QB;y$1'4ziY1,NuEn$4Km=5qG*(9=u='Z16A)q: ]\&Cz>ʴ@ y/ u Ƽz[O0HH_RGbg=ezp̐`dN$z2^B9{s,>}$Az;gt㼎 \!Czg|<ϗ="?D4߉{C^ 8{o-%J%N@x&/ˬ=9kK +j,lû/w:]gf=Ch7 X4Ⱦ/\{aVC 'u(ӯ!G b=H%cm%݀7yugtE~)B:->ugin! +Mvp]m{"'rܳ&>B;I:<\ZL>jP z'а?JT ؑ2{U : ^W@PdҥS(HQ#qO&ͯ :Böe-Azy_:m(O;C;Dh3Y~$@[HQ%J][jt6 $o!<'w E|Qc}$wt:[)>eMgx7.E}?2N"ɾ_4g+Unˮ]Ål"ƽ{*Vm-v4tcηx߼ZУ/Cz~ k?uzŠB?I3u;3HRW Xv'Q)id<3Ə!G@twhϭsm:k:ܹnV[lv7|l/;1zFlٶ?:hk Mm< 'jelyfLEtxq?/FbAShׅP^5zjM[m$@ZN{v0ñK~_ʴ#MrNwxj&ίgB%L\ 0Q?=E7 Ā%">?p|O'N{ +SHb/{s/ܳ 8dw7qvv E{JfL[JvD2m6UVr웽~փ>ӥV~%ˮb̳snSTQlqТ7xl>"̳*6{V19ǫf}-s Hp;x}|mBy',WjŹ#(,P:;`N76ݲ̜6>w5Cgu~megf6l Y}mLmUִ;KSg62r>˵\]|em3rd4riZִ INS;\{qlX-#wq?QpNw}/7 FI0Wپ;`:gpAy +o O~R;\2үv)^Nae +Q L~A[I̵P*5M_ )}!OBy7 4Q$W +J$Sd ֻups +: |;^9CH}/]ck?F A; ǻt)h'QD}_H)M7H &lɼoFܱAw3XΟK[-?9^w6">-ލfAu7㞭m3rbUYpۿselLY+ &#w8۶:oӼܥVfmWUBy'[:6͇Ũa1g2̝6vwh>3f{Vԕel7֚\+Ř=fcȲaޫ3wZyN̜Xk}!@ZBX< \W4oimB|_HQB齃}?N3ef5L3w&ؑ3rfr!EPޭWwi"Ğ2Z̯j38>tM[ً5tjG#1no߂dqܾk'e5zl3[nKhZԻ*ӧV Mٝo\/N_mVpnn]FLeKcd0]$daַf;a0>:ſDxKK, ѮXҲi2m,'I~Yf,S& 7]69 ƹ@de]ؚ>,+ֵƳ#?WW f}벌ݍgnmŐ]b¾VYn0kYMl;ݹ3Hg?wueAnP"Osm$@_$;ܹ.#Gvnj$_@wu!Ps{!}ú{wo6?J wpόanj'mhy<&﬎)ؘ,֚& 8nmKi<9u72wj=5uhЩ4tg ڟq+f_٘[ӇFy9%>uwO8N[col"=$m'Om usy{tS~ТFz7|k>#]yA?CW6|? |?e~Ivf@v7uo&c()5b-;8/maac\\2vwP0~ 1ű!F;LK,lkfojFܙam}uqMW`[6 '̑ء]k7_$8X< BXݲ^V:W{|D +Jg]kӲ5iYm\EƬeoi+oI1 !e˪FYh3lHY&1"DsE dwd g 64%ǖ5T +*B$a#U '1}!@@%mK:$9e̘IR.\"7(J!Q92,DT bBJID3qIe+lV؄[T?8Eok80cLa4v + 9]9OBRHq#}88|pN4sĥxԑI];P=Ժ050H Pb8Ț`)zS<6 YlKa!bA!( *. tn>*\TbIji)sr;F_- ?.ANC!ğxȒ%]8F%9&pp%YO3G<Ëdx8H\/Qq:A+MTt'.ē_E܉OK +#p@(|VV@QY'd$= sCl6 KJED1 n"BjrBdQeM21D.]<KF$> =0+HRy4!:ZI`1~LjfleށǢ{@o`ŵ!60$ep1EE4Qq7 W +7Ȋ/Et@Zp62 k"Q|'O`IU\L% +A!  TLbب$?n,W1K%0!,q5e6vrS 9qS%&j^i[$#o` 4) Ds54[$|b%3 +d7ȌJJ8't;G9Fr<Vt(~QɖSRNC$L-!.a2J>+@YUJ.{<@:޸auct/Z~eٲ\YВV)$,56KIUOWPgS E +zmw|x": +Z00 /f*5.Q nR |hoy%.e,mʁQYfD*7+.3G \6O(uP,)RRh^*YĜ\ue{x+\}`dEr4/I&-&HD'LPL)$_NwGx?$Q%,i)̕hdXq# +)pXt f'Fl*>|&ZBU+~q6p*kE% .b#:&4& \B2p +I&"&*X,ȗt'%&g_%-gP`O2f٣٤.c)}zJuPWP8Z8!QBtA,:ir%ΓF2ΪfD1 +2&bdnm]%XcT,#`~JA$#_%]#0&܀sIH(@ #ωqa&S,ShQde-hBܕd9#5]=DP/aU[_rCl`)XIH#_V\АH!|Wt)Y|j;KpQYP,|`2,3"*&|,L eh9LFoj65$#}JD-I}c䑯ȿ$?"qԓ +db/IB%P)bqFYY*le$&b#2/uxA|e8NW&h!;T2q$Ө=K +Fܵ +F$-Ow-7dݮ2&[Bl X7Zڹ#9yHtE)u9Qo`brv~$RrnA]IB7`_В1Jh-$ٴ `Kv#ؿ+TE)[U/Pċ-!*_͋9ll㚕M0S/M۠˲ӰuRzsN9':n"ǒ#w!"n\MLRĶب0/h5.;|ZcsRr0͢8U܌S"[0_\QsTb{fLed&#U9)6T0v zb<+xF#al"]f +#{$3D +hS@"I|Y^Bi[Dg]Hi)>*&8?#=@} m[҂Lb%_PKeKXL F@GvKR`pC8ѼrHC侱`ʀI䕨ϖ"%V?(!4e}d܈IPbF£C ʜ6nrf%|#T@T}~Յz!geF]kQ`puXwWrZvX-C:zZ/9Y k,WIѻ `!kLV'¦]XLaZT cjIfhXJ-*u⢓ưm+2:Eݫ 5TI9\XdW +(E܇U9-Gj~>Y1xh1!RbVF;GVG7R^f.76-=<] ^M`EY(96'9* :e-hEegY C`!LP)QAeBS=^SLҞA&m ,wIךbpf0L\tDfQw$X{ +_E +mK_myPɓ{3G5,cPhlOؗ(]p9s$*K`uK|gt3X*q(UW _4X b?lI\ ZVD" ACgHIS "8E~]kKibVC= J +[!)@ćXٞ9y,LJg#bl h92=UAt&ŴZEJXqCl 1$ƣ=pcU3G!{F /$^)2z٪ [ %~_%_㲣tY]Feˀ3r4 /40%hT;[B-tU9D'Aj/+DZʨ`tP~SET"*gp aES"1v$mʌ҂a`XaBB*-ʉ!h9ybU՞eVnt?FU`/(/+'jSF E2 M: +@. 9(k +<$T)X,n 16)8f@4P!t X*݁JgF$!If BZy_j͘sbCmA05.8I[0G㒄06&@6#H6M4ȷ:lnd. <3cPvBLQ'_M墰Pd&%= Z0rI3+dCSٙDF/qfA'ݠ_c?H(ƄؙbV= HS0fIp)&%Y +o$ݳĠ9 pzR~0r`rcR`|JګY] Gyk*)|MEzÆ]ŶܨC,p*_%+_iQ(/u5Epet`t9W(rI_P)g`9_`)g`9k){X/?B:{2*S(RI;IO X~6= R |d^OL?&jgMb)et*;- ɜR/ ,,4 H6i M:g M:gU<,/Ӛizcg`9W 9K78Ѭ30!7!G[ 9TP2IhGrJ6?A~hV+&O7?[N;Y(aeęTmX-*zt.3,٫0Y0q YBXv*:gH<OBJ +p:!_C +6(|wNx G;D*PE:a ܥ:=TL#οzr$jXC +ȺC M\21$ՏKYJj,!Gd!Ifwj B 8. G>g&>h@N.5&i E8g,'z_О*Ah&-!d*-:N_ Ţ +I#I@ +?&;v*"=+q7R6,t x䟝$sB"XD J[D !c_#an{# 2pcXk,#t5ӧ|4OM5zhf-;#g&Kz̓m]춤60Jؗ2(r/2p#PahMAw_W0k^FN;@wB,-JtvP^W P2=R&`j&:OYJ +"Jb C-ٔ- ɜXODh xXNaEZP ^4 ?*g+B^B+]vxkJ>eQ< ?*2 Ti]4g# ~Q!&tgl;Og,Ęg+e|<_=UGz6BF;DHIv*TPaAx_)3 dl8GPn)4PX[qOo&[ĮV&7v) 4tlXys{Fx߼ZMcw6 uMWbQH#˿. 5I1IO1ٯ~rLFd=uj<`ŠRAlTD|{+Un@1ЬPBy'9RrTt\X$(} D(QA27i~mKz +Eawqfg)* ʺʞD$D{wQޭTaO"/enNwB{ +GlGO{I}Fly$1 /U +>#HW$~*Š0䒁 ~4}lܺ Z3g8>#GF𛷪y9,f`oI|D=/7CQpL f0z"yofN%N?`BX+7+y7Ā]1/mnԉc Fd26(=~ F  2͇RT|'5`-$ΫP>R:L`SC2%NDiJ:%6"5U)bOU'4> o7YmMpOb/hV KZMO_e$3[GFw [9H񤯀`U'yr5Q$7B{=IQOdœb"ZgU %訤`FveOVMݙҢc ͈ -USYjW8bHv_gxƌĠ@Z$IǐVz,%(Z +<.ľd2_E$@gIT_B/eB85}tvQ6*#(hO~$1Ϡ!EbN4סF_E7nȑ/Ibݍm;< g蘲ws_ZZC}PBMhw@a_z]mW7H/Hcq)q=[2QlnpLMuѯ!w@h4 N5xg5^VZ[ F'X[h9/!9S0YkpIc~f5XJ<{5^jtvϯtw5RʚŒ_e;im*SCtQ'QXGI)4\Wp/bU!('}K I|z!:ݸ$Mz4lHnD( E=zxK[;M:O +!nkֲ6۵KL {)/ӯeop9G1YK(Ju]IAD{R*b @Z  j<lLLa7z^Cj,Š)̀dtf7ty+C֯bc+ü8ܪxQES-VC(g^DAz26B+Xd-4HIMR>Qu(/-'5U?NʏO{1{@)69񱤄jDU&;)֔ӺCOzCP)ltF ICjfm SgEz(~A >47Yݴי:kܼ4uhY3֋_H@p 2 f’BϫTLųa[4ujYNf!g=|AvP$*unX(q5ƒ&rg!E01%̆qa1=Q`3%1n%*_VN#Y3 -DF +EI4\YrÖ{ +=bhaIhC*<"IpZֲ̕3Vňu/J/47s 8p ,p Xֶlfo,Kgv^T6"0~:tg`۵KW8I)# [[}4{ĻL`ߨtTt CXb?(`zE@,C5$j(#in#M@Zsۉ$f CR&JIU;yr +D/wlI~ehUSW1h R/K@3lc(Pe t ^pv IXW1 / @fAjfP`VO>X f>sҦlġ$6.,wfwBz2"lDMr*־)aAU3UH{P jL +Tp篎LL^Y$ XKD 4V :pD{pʼo0A3.)(]*Hthxxc%]~q)`d6AGBk9X +ZgҙPER˞o)1ڑ}C+ +ʨF#'S&e+X0'P S#nizq-,K*:E)Ὢq<ŶFzJT{c/Hޅ'"t. F` c$ &M |*`1$G8AH[Xb *pB&D}6-bpzXQ q){C`3T饑2)!agȒ7U(}E>e%Gn+91Əm5zg3WWS \ -093\ד Gq>&5555#@kEąVc\pBJx 1FaK I:!1DM8qQ ! '+2\^C(p"KWY῰J(L ZN"(!_ĐǠc0l @:?OL{;18/.!`ZU5 +Ipdy +Ԡ~[ hvŬ"xW{$*aXHč 7.61]"U: YB&VS0aGTLشJ l@hR,D|_HS3Ua}E"]Q)/ii WFp?:t=ů&Ydn`=S'e lDfy4ykaC\0zYЀzE X5G=P:EF?qB H9Ct &)tVX<&=.#b<}1q:3y~k(CoWyQR*Oౙ0r򱉍 %V)SiV`ךwi] YćBy蟌 G#/+'_R*&@àPÊH^9w"RCPq͒0~!bø c"Y0jYfɰ p +lEŵX^^8( x}PZ!=!FؗS:,Mfk=t(b "̌ $KʊRR RXf V+-&IbU Bg%"eTxFKˡ+"FdRwȐ(S/lCPò/*$ +@%.@t7#t9tPo6%ܰhN2̜UUd8Iq.Ph0?f-2)@\*iYRwU-tu-> bakh>w3؎dǷ)+!x \I*WˋŮYǮaa"AEp]c&`~hZEP0v&\>Hq335X=ء2B; "|RV`8'8BROL2bvDser\f^Z!z\fB{OM0 fy-y $VQlѻ7X;.M 'txʗ~cKd0dPU 0^)@V;ֆ1 8TvYV٫\W43\ + ueء + 1bkC'K5(4ӧd޴2φmԉa.dX BܘG` IX@;:gt1@j`@'1`St +]w?ˋ09/.C T?}< FYPfq0{%6U7F L;6`X [ng,G3A|(S;81] ?`104L/*UTw?K _dMWi˒( yLy%Ģ,p>(E ኊQ3Y2L% vFy:x /W(##4u?0V )2 1IvP|BQ L7?|IƇzxd˽CVQ;X_%AdYjEP!1~X42#f=y D0 +(6rrB j 0*bc^}|m%o &k65.%xc'\q-^s+CD*bVOU>C܇pN#ţ",aL22B"0[8bt=Pd4!쐤;H +m: ++Hyu2@od h0Y+X+ Wc!x6 0W,s{xIژ]Y-YG.U=: k#0X+hv]qëe@ů6)Nبg(%l8"kwyq*sUܼ_ac#] +(u6>iL3 qXKWX\x_B ŧjkd$6va`qB$4D 8[aÉ$Lq +JJ\JGC $!u“0,Rp>.dmPE|`ЋV :Yrer:Dɒ\鱑/qj-Z `:l, +` #QXI.L66~a$zg]EUU[)lp  A߮(~}j8M OY;xmRMa1dd a (ѱ 2yM#-*!`U\LFG-z^\1aL. nIj1g!RkS6 +@O1`aÄqLc =MdLI/pBpU,"ȈW0"tFÁ=!IE+٫&{"H%]JpSq7J La~Uc(["NDP!jC 4<$ _Gfv ;rNɱu0ScM"j 2G}so)0-q%#ąfpft?& gr4&CXDUHvH4 4&@lLr̰DLukJsᅌPH^n|X01$jga +B]cXU&4y0Nŷ8!Dčhь_!L4CAGGLjqA^FPhB%w/%.dq<:1 wbJ| \dUA/\۸W8_3*` sc͊c 8W^E(N/_x%.AH7R x &"fWS/DaXR |x Oҩ4xv06n%L^yEָRJt>A3I&Y6KV-BX~}QYCSRQ!7j+8 1(dXEa8'>2XIF\KJ{%P&~Gh^RI|K +`2rcědB|qq3RIN@&GT-XGkj~YL~RoweN|CBtx"^cėCg>{xUCq#nMA05β f`*[$Z.U*DR+AhTrȠYBRdH$="]hTDx`awfG"$q/)$) DF|GV~dN $3ędU'q$kЌ) c'"brSxB]R%t'IMnjT&] P.>`s@X&"5^Dhx]^ #Gp>E#ĝ?\q!Ëb|8 ?:\.gd"P5NzTL Vb),"J٘DrɖrV<#G]">l~}r0JD)bj%px +:I܇^e89@a* lV~Ԩa r{f M(]!O,?l +hB E0RTI)h|-Yc!hT]n?E82fp9|XL Zel -1 /f_'||MD-A2-R X\ +%e?KE#B0-$bB"WFlXyLԱi󈱖,% |/De)Xp u!ĸط>•6H{2K.(^4 6(B^?tTw 4I9CrGN01U6YF%V\1cYDT; +8 9|c211<2 O H\]723]֓UxȮ#j;2gqYSSc1Bz +Ea\F@8oM1]WP VPCfNH AI(ܫXpJ x"- X,6qv"G?[)۔)~ϡ\@yԉD/i%.C)ĿDMUK~=lד/G%*k#~AFOLIBnUOXl$ؠ!̀اP Q+Yv!B?v<9-7E}HSq%O"˽?W2=JtОE<hhL~*838כ:ia YyvC{ + <`?VFsƯ[_4siRf "%%ήw +BzЮMxN )})?bw/mnQ%96okcO~>8s[)/ 锫P0IJfB2!NOޛIL2 +%YnUH!/p,I3l/h8j G}e-[}D*^ E +ySih?zGPO?HܠƢ%JhG~1cnksV;} + @, 9&(\{rfluV E$mmb$AOp:T o±3qnmL ǂY{@"J%)զQa6W#FZdX&)O E̙KBju%tT' ?"} Co`T^$j>(;(Wz ~ae}z7hf% +T,~*B/\x*h[#䈬 z$mgBD_9o]w4%u,0^gx y }0ه>7FvYΜ_Q7 ^$x(Д;]MH}frCRz+@ih˾D +" 't9KɧJUM\-VQϞ"=vX 5&)AC}0 KLA +D&L#8w0W@:EM/ZhO}**!A,Knt?v( F>f(%BQ qj[Sh<ִ_]_9|pm5 ID#v E8G4=o:Y3P""FoC\ :."HJ =i:6wުF7k/x(^,ڙbM7S&RG}wU +CIM*%݀#eZ؇&:cmdW@ \>zOLu2,-ºngoJ.'IB5G7 YSw1e0^b`X֊Vcq'PzOYƒJC٣@W}}7S"VqIwpY_Kۻ.a+oV. F{ +3UvGIhU@Sk3qf #_*@+8؟2#@[k3HhO}fh7l2͞f6xiTu[E[XF&!*(e_jsڴ3ofР؄bՄԖ0c/xho)c(9G!م' L>e +;0 C8$>Ð +*D~hҏlC B2(Ĥ>b L43pbs|!b +l+ +-'hȵJTG+i|W0 \,L0R֮:M"m=:lY[<bKK۟cG 3ugHg;yui\y6ht||we޴̛VQ}<)--%j >(gKVtJ %X +`,ֵ9e1&O-]vmɮ6P>r FvՉD`Egu8[ղ m'w-MZ)P;sNY3vUZ-#Lʄ)R2:M) m]eh+E!Mt%V!BکJP^_v*A +?aG%6yx売`8"YG>= -O"}C~ġMD}U E:۸O#wV̝y>f{̳n4i\&Q3]v83w:#VV^.-/!-K!Ip9!clDv/BMJQJ<e-Ջ\] ,P[!􀬏,;m5&/实#u:*ou`C\O7W_\L}/4 +Cʭ$ x1& +>--@_k|XOXΦ!G}7cIE .&ͯ]w16xj}N[y9:1S(_RJKHi)?NPNL]mP"AJe`CR;qBt鵓&6{kάyНec毘2f_ursP#^kZjԲN޿h}*-ZP&%^K6ɴR;ŨDo=㕫\; IT%r@N[yR&ݴٵ;(1%%e7~l=8gSZM@=8;/s㾍Z/0#[ONk&I@9ntݴ}8~p53-hHEb I2ټN8>5L!(/R;B q}5W1P$H@10S('6g=D{rT*Yv=[ic}&no=gj8.S&Fˬݵ< +,{|-5j,6w5*6i +@<]yqx~ݙ5tkg6֚f2nbM5L= ;H$UM:v5'쨤` ̛JõTB)'vW3Uw,JcA +'aA%2곖t~+]A n]:E d,ƜX[}SJ T>=&Rmqj= ;} +~'O'jIbU:w引gp/mA@Ѵih"I$m9|r{A65zJd; ij0YW@; +^h@@:j4l/avKBKFn,KSyѷ; AU*ERƍ-IK>.' G:&ήCd2=3pdF =aVgez-;gaHj]1g)* OJ,Φ38lJi3l-ɥ=sc?'%keB hJۯ}ho]/ez;_#!̉Z;w(2uzF! !H䬁 +2p쌝=L߳'2l**h :,í=_2?*Hd=bɧ͡ g >"^">x+]7~m;˪V_{ jQ'^Hk䘵 \YXn1 #M@AYL  P: +N}CP9Q +"(G~>D7HdYJ:?T l{2kZά1i7$VAkW@iP< tgүfD4't7k O7 Ѭ=!pdPObmM} (S'Jh?&5йExW[k_Z6)ԯ*!`J]4 + `4M_Õ{wO>z58oVñsrx"J_Yk)ԱhqϖqCz-KY'6YG}"v&MA6fΌv`v <,}:9 WK)mѰR1c=˻bf,]t*ڧήvr+F֭kmE'FǨ^ oMY$følS .ɦge2aw + +C2߶GY58٤, }3$JB D8g(_w;$1+@-6L X+az;O}0~%!OauSEtAnM>2^!+zlbTh-,&f'Ͱ3`;AqO B9/iv}U +~ "=ifڌ3'MA-cȲ`l?kô8؈"!3wciήCp!,ue.ûه^BzLXVlb +X!lDm3vL"TKkmb|7p(,Ą-!v0ñ3pAddRRAg)Rn$;^>#gu͟ ĈGec/cqfkڿZݴWEǐ+uז_*hm Yΰpb`>y3>6}iu }aV5dWWH {>86&˰ewuK +ZIgp +?2 PB'!<ꨳTaX +ee8@Qoc@0 PҮ<A&B UӖC WMܜ|R5XMfYec'(L̳1}:Bլ6MKjei6߿*vlkM6a& IހjЎ$MR֦զUxSxo15oNyt,̊@n7.Kx=ٺ}D٪ڜ$/ `.W. 1J"\)V<ߧUtzvu"fHKR̟#!yHwHXe9;d~q1OU2O|_YJS=:!{y[ c\#~wO_^O.sk{X*. b5U B?Y;v՜+<=z{ÅvgRa;ҝ4%z|yNq +5ˆE}`ת8a)|T^<|es<1Ѝ*[_~`p a/G̵7xzcdpaMHJD%OܲģeO,ݒkU[T~Gn+~r2=}q^绯 )񎎑vϏgsxO= 23y> bJtϪga +1}v5urz~g2Գf YL=Gatszo/xa{~ (9o?5\>VoۀQXz#gm?-q-#~àjB8 m` kݚQq3k`ˑz5{,p!MОY~B+{?DuN[e5qիL+K&> +`YpK꼍}Y7c:'ܫOKι_lHh ᕇQ*U#bV̇LyL9[87:٧!{ОNo?39py?-pYHrڙZ`;hsbk t]yv@Oi|0AgC; + ӖWcw>,/K/$-3& /<.w?F@ZIwrzvBu 3ÍqJՄvEUK ځk>:G4t"ޯ 򛆅p~w?zSHR-'ߵuȒX#&ĝ&ߎ>a)$c WLsëI }h^DZ9OʠrތtO\9ќmݪZ%[51<Tg_ɹV̻Ow({| In rU,O|6] Zj +k#d7]aTӺMkM)mԑxsKힿÆtn.%ǟ*f r&h,fkmUvas;AjWels쑸o!>Bj[#*𢡄jd3k&ϖ0Xlh=ltLYz,~YL}3P,B5fpR~Lb=sy:9w}kH㽵: ; p\푿F/ua"=1?,sh'u,%9t3٤ڨt$iAP). CC۸?Ufݾe3~O(?:9UT_UӃ(b!i'w8l9hwÌCW0=7Ю)&樎6?jj8}f5{| a [B8(4T=訵9px}ͷu8^.,a[Lp?Gn:+nc=ҍCb+*?UY{E!\{aR|g* 9dk/'.Kzə7,@枳aAY;;zz8Az(8]De^ݸd$nGDMmtxOSb:ug)0:E킣F=4Jj$S6 Zb`Wߛ~ 註(=>1;"aiVSbw̾(N  +ϰ%7)&6.$%t;r*8i"|8]ދXeIn5#,*O*tJ((mAm[|jm.=#PѬ}@Bxahё)݂IS\~ntsEh+"j4FՔpP/afYܹAVW ߔwo54@=y?VFq!+WJD̳Cs؋l*eZj.6(K:`1 `qm|/?{&F7-I2]vXʣlυ; 3qN&69&<ڦe"/Yn +K@nX]ŷ`tvPq Jl=- Of2.*";! + K?Tqpo8pftFE !38'Xg`g_QM;2}5_='AfԂ4T:魦lzB[-A.g+H)O^q|[`Q}]ĉ1}3fUlXV? }gT>#HȊ B$!&%/ HQe{3LI̝$AF0/-csOʷanw/?4 d@R,2_$+((k&R`ߟy<<=nWdaFYWUUqXU8RݘnU9 V+QXq9s r2ThH$TEnLߏx$׍8.5$l¸P$oseHP9k8#%gp,kLFŠtt+@0۽%Kg2޹~3y`,>v1Qde23& B* >yKLJtoL+/gʞ{-RIMΌ f;U0M]ՐPˊHhH&e=wf` yS:|(:)ؓ:vk vM':no4UvkuW]ӝŤ5mb6iwM?dZǓJ9_HW㛮n&>,e0H `\a)P`Ѐ + @(Z0厀+RIҴa)Z瑡$˺d( )˸Sũ&=>}t쭩B #%mݾ)ilZ3=[j;|?'k#k2=\% Wg9JsIOԞq_u|յǣc,H|B(S> Э;nZtӗ)qRRVNrkpJQ)ennw5 cwך6aZ:awo6Lۄ?Ws5;#T@,0bT3\#ϦMx8α;v~Jt:pOߵgM;~~_kj($P‚(bx('|zkcVh-jMW[~޵>gٮ5l?JRݳBQI[@ +(BZ%F1݌$B6n lGFpئP W-}0OkO_}Rk3ll3NZc C@pH%CI;@Q@ A0 H @Q1 GG>(:tm('ĢW6s<1Tz;re-rl vElA\ʋ_|@?D͊NL #L)tMV4.8wdhُm`h€Z_kͤ +jL3SE?Tdl/&bUTHxb+yT>1c$!4,W 5Ddai2FAL|ߏP ݻ2.l8`N˪њ#~^a [/{3emt%,gDn+F\m*Q?}Oa{JJ A˘-|bu?7oNo190<oSVH\V(zyWHǕnbM|N"_M:bs"B}sD#"LM tQyQE;jn]o^IKoȎ##HiAΉ GϤ893ʡ09k> 7M٢s:߸޲;Y~)1 ۿC|(%י? ,  +Ad"y<I6qcREһFx&J,QD; !0 $dJfs~h4cebT+6:$!#1,/2yW6nrtG;=M;[bL]\%(faM +mK5AFkf<-70&yGpqC?04"`р'~, T_[H/k R(yT-۠dDn2P|yBJnaq7w5p7фDYT-U3]J@-ޛkG?gUWzw:2˜/>,pDdv  Zh~GL= z6g"KOLF zx؏wIHگ\'@ui6EGHEeG‡PLl2ol3}v$J-6ީ}M!%dQ@EH U#\EJ$]yhd+8nulx~pHZ"K TWULt60xѡo#_v$tw:`dNrG PZX9EH(oCʚt;ۆýi)_%oX̹` n\ŕy11N =%N fk WO)Zs)۴-lOj=SI/m66]3]|RmC}O!WKahG)z(_މZ'a7{<_dLg#| O`:SHb +usGN9 +aMaS$˅H2PP (<= ^2}Rm/;7~.(}v'/؝Uƀx}-u.~۬sQh+"fŸgi+*WY`D`-|*2x0,V)#k;}ƒL4N涉BO, K%Ҳp<%6ѪԲ;03SJ!,8)o.JC$w-$$,xL3g)?;1Lvx3nKΥ wÀ˚0qZZ*XPZbaP.8_,jE-ljnSs^H.cހXTO' vsA>/}5 +Leugig1Ħ誌wuARckXF\s_b}a3`;2yVp4])*_hh0ŴJpl%7!_jYG!m<1%}ȤRQZҢ0?9˰ʢ%cH'U9@?Yħ\ QXzEhS2ÄDWV*X5QegX=KyU1fB3rNR (fF@gIZ2vpPG:bxe\#B}1w.y8 567F/Wb BIC 1LG =Z T{,ب~6Z!sIL+|4\ST#= xvsI9z%+6:0V?p6{6 7uU FoMLvvi/,^,򪔹w ĵ-C? pgj_Q+КF\VaQ0&L @6S.3Lܠ Y%4&QD3 +kZ;JSEG㼭O:-׼I՛1]\o"/S0(SR&8b^&v;LŦy'jO\dl.8@*6{U +ʱyD^vBCqފ/\'Z:lPH%7_*2!yp 4 R%;s m[',=խyaQȦ7]-TGQZiNpZvK5Cy0F' W4 =Y%(8-1_Cʔ\- +W9eBIo 3Pwp(Ӂш2;imQc 5EǭfQ(zK9o\MփNX^EVyQZL3_lWS?4_ C^GHUoƅC=KSIYpPpޕ}"S㢻%8t|tP >nN X غzp/{Zkm4 }e!x3kLba_(Xg$;Wzw) +J\:byT99HL'ٷnzN-.A^5PqIb 'N LEd\fy;A!vP1&gZ.gu;V`0r8݊#rv$`$]2,rtFʙ<EФ:;` -\}KcK%O8Y܏ t Qehb9È-F6h__:Z|kY80.:ﭵi1]F<X0j1]FgSu3g1Wl_ +o+mmUt_u +_m?_i|Wj㏑+w۸W_Y+tt*o]2+WռC6ff_Œf̍]d%9ggΌ7׏b_{Z޹DϵZ8A|v=9FvN4ڧDvpy78uW]'| " _ޙk]߶~Ws}ZSsaAoՂmWFQljub3wAlTV݂FeY+xckډZ C +Ld(Pb}(ևB>סX>'⼲>͵w"SkT'BuNԉP"n{iՉ}ZmZkuP(c9+jw"m)Cu"QNf~cZۯ=J-~c[jy޶RwPsߌbbQhkkѷ}QU+ou~ͷr9 +Kaօlh@Wb}> +h"Z+$e:P/El`}32L*Tȕfg} A !|,^gCX_ hb}|a0)u~ݟmֽ֚֭~L{Wz͚z]^s1|)cko\^m{ͻz~v{7Y͵_1-Xo)qԵkmW2MPdx4sݟ>߫C]9Cuz{ͳ͹;SXc}>Xc}>Xc}>'v=3gl{Sι>Nį_ `'z/ݟXJwvf}^nPs;R7Wib};9S;W8_;TM9ݕϮ vji~liڂ]; ,@jP Xzs^iV|V|EڵfշOq~s5;g `H.!l7v[p^wZ1v{w|5{o~sZs]Zbyjwz֊kZ{kZ{u{sfjOSPXwm/8-8qUߌqƺ됭=1Y5385ܥ&z=jjpj nkW7kkw;cX`P >knD(t +T~ׯ+sWվ<޿.cV aXXA.$~y4&oAL'>ݗ^RމZ{͜V/8DvL+辥x[R++Ԃ3cp>ZkL/8smWNduM9h>}pޘfmI9XjucY;nZ}-8k--} ^iszck`GOZzAřT߻5+6[˩Vl9C"p'CՂ ޚ&B58D?vYE|֋;vv(6wi1L;(۝(յwF=g\\wYE@~r 9}|NjpK[Nt78V@.p;_kVXͷCͮ6Vk584upQF_7$Gq8хˑG\.FR .[lL0ΕF1Vn0L, q_# v{"EgܬҚ GN3d 1biњF{kHZ`[IGgFH`-ȀX 0t$ p 1_8܋JҺ( iT, k2:pب46 !8Mtͷ'H-'{ h)+myuXb cGrhk9BB|,mn~-ֶZtJlT$  &+ JHroq$4\8Ud#nEFY5H_S{ڭqi4Q+i{y Qh i,FlaG \)M$dۨzIVMT1T@3$m2ZU(%2ZØ%6Y?J -W:fRl1[xxMMD&,<0e_xJg QbI)%|n&Aup]a _L[￥K6ipCuC(6* %LD2%M epJ[ڞ@FNkp׬v2ʸmČ}3@\A0`X_jiyu%-<FLDr81n4S6:X,%bI+Zpeb#',Gqr1E (A( n 8+,0eBڭ,oTk$%d4Ҏ#m)jFX#v+ɜKV(1"XYuaX1E,RKM +Kً4Kč)i e}7Wpn8‘/X2Kp1đp,g?^6֚bnLFQą[ޜ9_cxkc8?\2mfi;?>g4LB|wqƶn{;gwTomr[y׷7U9뻹ǯ|ft!&dN-3-~Oh> ZN|kv^׫ &ioV˷wg-~}۽-{ߞ~~n}}ij'_jy{}̿Zmݽv޽[߯ߛ-6~}ouk_};{BfOVUg}7f\sϵmk~sOhմ32`0v.U".U\.H 'bn+oo7[1MZc~iw:Ͽ5>?ֶ-Usf:ky{;ߝsｘc/j[ijm{[~5M+׼n~{ՙռ|//9מдc_lloו_\{Bwif{߬_cy8cZil9{so1z_~M묷ﮱxy6KZ}mo;-Ϝb7x7\ͻ'44yίic\o֌{g3޽r[1lo_{zB3ci~㛯>߸mżͿzB~YWՕXsyycijy~~ys k'4 ]5x_-jmsjlo6l{;gOh+uzoq9f57klk]c߮ۿ\oͷ^q>[i|?w9/fmc[Vo~?滳[ugq{ǜ΋;Vmݸ[|?yϞf^uZl/[g+~Ŵj[}q֝os[4-lT&DN͉)DL_ȜL#&O3E1-J=y(&HM##)!c4R$(!2bDZ\+00`"}P]}5BSh$4V\E!% /& GEB x ܬ>nDtё!nqJa +->3FXp2vsTX|DZ#g0q>7S< ,+Zx2/#=$`'!N +Bf"Lapx=DFe4z(DFhxgC怋  +G)98`4" "I0: +K\TD[<|(pUpHz[s_{Q1b_Wzex~iZK426F'T$눐Fsk ʙGD"SlKlɆKbDeS6 ز!M洓El|d +FQ|d^3ʐS# +3qKR*1hqƢa|FD”ăq]c>:b<YyaPD.Xn<.Ҹ8]"tY=`<\H|tDzGYf bjhi0(X<ˆ6HY*:uLbU\B-ł×g`OE2h#GI$2È> X }ķ[]reaΓ{>j*q 9dHB*aj09PhT ;5xO kj^n0x 1ȦDĹ4".( % Y2l3xJMD*Pp]rT@*d1Vg恪DbT`!Q=@TȰ+krmeBk,SE`KaԠT4ǥ|݉p\F9QL|Eay, +ZQ +B(9(6 Z^B;(bDȈ(' "|(+s +LZ^C)5Bp|0K%dB +%ThcP0qݐ>![*Uh8|l8)LCFid>'+)XbA)da Jhʴ2}6 vկÁD+|V$aiba@ +/P#+׫Y*2#b8TQܓ~s6 R2KQ(lDrt:0'S(KHG #%vbODE%sN3%ԦSJ;<ɸ0QDU܈g3}6&sOQB[(nFH#q@H#ɒFH_w"Yoh.|(G!\)HFiDHWe +;hŇU:z*U*U*>B|vx.ṼH,gda` \ endstream endobj 26 0 obj <>stream +8VTS4E SbOVE 7&Jh/ 8H nfX;PwFau:8>n d^:oym|l|l|d2$dH&HXV(TaH&.zCU*y_Wx8"*p#V4_}T9Dl(Io7Ga#[Io舸_w R,{)ja"1dr`2_wٔ_w29UJRO&F˫Lh:S8X^U}W) Up'J2$Lf2m}6?QbHS!G>B)?00}\`2:DrBVfN!_gza0-ĥ!WɄsPg'qBE<[ϭDb8)/9֩>y | gV(*13Ztq)V҈2},T% +RNJTr@,ِ:F>4baU1}ۚ+rj忮2co$:!Hco)G|6!Q>B2QU)]T͈nhyd5JhX^UEE`dhNmHpC8c%D!WJ G +?8x  z n + }`Xpk% +W9}RhjIr5h` fz@>X,H”hFU|ibPPME'$hHTeGB(6@JF ;b$FIDɆ2"/gpy m6^ (2@O`>\<J HTK3 {sQP0*F4b J+$b\vdufU}3{QCC + +G +`IGx<:BAObCT +6(&_7 dž=j*%b:HHǃڨ>R;׍H6tJ$;mxjVP.wҨVL AQN! +yW48*n[^4'ƚА @f+Rze]0qD`ظ* $"U4١QTS9}RaQ{؈dי%s!G8cƃ-6Nɋ#.!2Z \T|]]|HaťQfdD!1BPTă4ܘp=l>2ö1>_#EqT2! Mgdly&>*bxeM ܩ0$jbyկg-"#Z^c~VHd4gs(6$p~H."p"68 s؇|6^G] +bq<94JB^,}]%1FFe6gK5$2TzG]\Y0qum0q ŋ ? 6 +=Fr#>`\ M2SN:"6$6]Ia2=d`bek%"9b.[*DFǑH/C5vPQ)$HQxU. >NPJ97Ol+{!.sQ~VӀ}jhs 4A8rAًf3ϩgR۬4LN.6 & q=dVX63ZQl7Y ˢqQrKl}x\\' ! ++3!X]/~+Ē(-+[WGKxhaNPC%A!萈WSC*CFHf&"ɝpdpŜX$lw1R!ٴJC` u*|pՊ<'F^!#%"DCl*CQ9p6(Db`У?D!2 $WjV\|L6zP>NV:x,'갞1{90$4(p8T8*. G Vl\`T|cxňF+cఈ +ZFDwdlQULFFo`_aV9Q,UnqRUث.3'G :2x(hQdYJ{^ƱdTg3)J +ds(t"0h$(uhcT0rRD,PRHqQda +apزQ3OY}ݒNZi[uv:[3ګ,tnQr+Q<{k/ ԙA.a{O[ZJQ++;ݞ'l}Xs j5/J0:5}iBl!lNhuUOˠ "E6enkGgg\hc5܆y9а|wy31҉ĭǯƭQs1+}Zl0[d5{Y.u X2xd7oXR=.ËJF +AG>hT. +gpK\bxg1oh M##Us/dYǀ ,3~RK.k6e +ޣ +H= T~1Z6r~1CAQԲ1銣&hKN ޑZUEj shy(}qBM j.ceLd ~Oq2a96-VBѰlg)s2/j?eJ@̽6JxB r'D`) 5iC +֢b&a /?xS=h_25Mл^Β!/6W)$컩>6E:qK4@!=HlW]ĭ,fz.w'Qtv9x]@\FʫoI(HD3jr:I15@zc=qBc 5.P3v5D09Ne8j, hQ7*h>YԆx"gmVhpQT%v!r6TzxѧҐnuVێlM!Dlݽ?S)Z@zzZue( 1cVjv xNX V%}9!9P?W: >EJ2mdЉ(#Ǫ=-@B]Sc mH*R;PIiqo]&2&Ya$AXH!r+[;|m3Huə ,Didؓ){Ü(!0H\%8JBZvс5,ِnq^exR5"LK!73|x5 ;RX/s%wƐm/A\BLdy,⽼~-n$ث?fay Bq3AWP{VwI kHv붚C :]^5ݳY<)OOy\Jj8ls#z)rV!f Rޖ./~.+#e@clE|%J2mh1Lt= +B^1, zɴ&Wc&*\gDe5{#ϪRb8E}BiclGba0O \!Ζ} AB,#t3IIs'./s~^<5PԈ=ӦxMD?r)[y2ڵ̦9tyᘹ@>qkOpkD$~L>PCImF>?=cPu!/+@1 D0W)RL/)0@[);eJ <68<\z5#0YI$hd]X2k@'[n1 ܇H)C{[䔨R5ePHd4Qɪ椛 +cߌYoB@ڑ5%^؛,9tI0Ŀ%5xHdШ4qGPNΦE aZE3g%=uAda2̓ +q\A;kV qYjGd,,5 ڽ&sƵ@/[$B:g,Oۛz,Ui>PBɜvh/)leЭ?ze1N[q(c`g!s|M@i#;EjFN-jbU+`P¾35 +%2"JB3}5TI8*Iܚ ptMibhvr,\}uU x4Eӫ+[dCE\>MوFCaGձ*DLЩOyp Q!X۰TtEn` :璩+v,Jrx@Wapa$~㥀 +oa |,½3"'Z7'_܌I!mqOp ZwQ('R%gvHq蕳{)cSӆ7RJ9-HKcx_!?eDwl?Mm0ؿlU7ej?ʡ0 G a ,fEc xiEؤ )rچ8ohL ";ejo1,HZوӇiSၞBom%_sCSmfW % ؏Kd`{=ufe`dJ8n]72B7{h"mZ!̗xCo#Hgbg EY`"<@ ?8igW)3|00Qy:I`~X84_[pKMvd{EI 5u!0. #w2ݤϯ|9DJ =>NCP\K5雉6qC(V츲9ټ + I][i( +*8Zc챍YH^` 쁦^#LJ; +Zagsm1{'JEv\b>ikO&\>񍻈,]FTZ\C*#_j0L?~H'qΞ45,r⻺mץ3^CY5*(!m= F2Yȱevo.0Zv #JrcdL|alVD~zuU=WSo0jßD/QDb9А@CeOQC[5B&'xU+{"8KMV׷[1ӫ>( N"M#xJoZ; Nղ_[튯UM:./ +5g49  e4E'-9r 0Ba: ̰B=: +O sn<'MNƐ8sN€_8HɟjlEy\BMQҵť48`DSC0oM3jlx[eOz +Jz5=J.9Yá̊7a/.SaчuKzQۣ1#xb-d8Ҩ7| sECjZA.ӌyWLҵ0fiJ}?=Edsru?@Ј#}",.jē Lydfu8;|l" `CdCPbC'g;X+ k.d`CD(Csi=ݥťblNpi-<T28 %#YRş:ў|򬬜-^*n(UH^-}%;Jsy|&pzIPuIJlX.SO19F(.zۅ J.U'Yح$4o/3ʥ6dǨx:7 oo7" u7[{pUS ;xԗaX.641YժiԷ\43&[pqdFv74"ebQxb6&Uai=-cVDϪ]*I5:{ @OY5#M'u +A/H,!rV-딱¨33*f[Yp2aK@H\Ax&V~+\r8PYl9HUe9{.q,a2]c8W~O5-$ kF.t9]iJdB!:}pj1T(rhBggH쨩/4뼗UiG5Ek;"'Wɣ1Vg\UNJ/f( HOl尿zc;km6^MV=Q ބR_J:UOT$_QZa+u--]elbPou:Y)@Aq%FR}T4 }:MۢS ׁ.L*0_Hˋ!=*[>ի 5qN(6+\nDK;Йv +& X!#sG%Y郠a p9\Mn0 +rR)}CxS+RL,;듙DXc;1Ŕ?o8pxr[w@_z56Pwԗs? >oWaJYbŇv(p+&oz$Rfzl~"rizxGqVTҕ$DbFM(ODFS*3ZDŽb} 1R)f>p~OHf#Ĉ~L" |D 盛P#*R~Z;g~k I#Z3b2Lr+o"H^$&Qs}^A~\\3I&7qEXzYc}2oz)9ސkxJF1.D>-cf~Uj?pHZ%Ka#'2!:$E>uxhř(ioKE^i. oȈbwֲ&b9^~5V1092LM=ܭR+'W9Dm,HIpBp'D(Ft|9%g*u$ + <m5= _+YVo~v6xà˻dCՏ7251sN#' +a5`y)].X^pzHnԃ )RpY9hl~o3eQjȭĸ+yv2r઀L.`&uDŽ5!DH3ȁL7qC=^+RxBdRwtkPԈH;dNT +3*UJfv P6݂$g3a,軍m+7;?#2#<)eUJWDh} +q:.l :TJ{p@K|U^ .ҀdP|]tzKp?CBW^;ɝ4 i_%O .Br%*(_WIb#1@%R)00G8wEa*4J(ڜEhKB +5y$=Id{DM""$B(?Dlb|[ $%u5O@W?1"Ph;G ^=0[<3\G\c;;&t$@W_[^G|o^4H3p!!DF9GxUi0*ErA'%`<eV +LGָ9QOo/h+Aދdy:: TAd0)29$&Eo2Pɉ̖%hVfyc$8yf2CQ66ll pL:b^E +nc72!+p5<;flg=2,o`md~n\_)rq!~e.ϑwa{Fݐ~n E +VٮCct-e%r!>̚%=,<5q5?KXEcR/|_>੕mb ",<brcb Nrsۍ%OcL6Mx#%e6HU*m,c `@"P" +DhZ+3Ц#Z!*ցNvTS[.(!SOy^S7Eu+;y̙ٞM;xlg(Ax1*wP0:;u-ɓ6cc4m;Tk5,¥T3H=*n8w7%xЧQ(<Q^4 fNOvQ)1z.\ ITd[]KF:%1cKX>ڴG'< 5? +uEa`&lY݌%W.gQq$T?YJV@d }MJV%1 %p;t$mNzIH:̠/uto$l|)JDtbwMpo i*='5pBu{83媸}}nϩSN׾e޲%E*pdd/Ҡ0.`u bc[j sc𨩉~y7|LoKSӉRjwv:tq>}L: pa[mJ =U!!j;;PC޲W҈4؋%FyKu`ŮL ӭ&+"Sj֓{QWCθ nRbR5dRr ΋̮N +uC< 0]WHn'o,a&cWLTX[ɓj$|ʍ.}`]zRcN8++=?uyb£R?qH5Bg0#dΔ(7GkxN[9 XD{ x(i3%aeO,Dş/iBeS^D3qk {}HǗR{Zo[\-fM>G-&,L4SoW"+m.8/@OmRo.gXN*k-ЃIӟ8KFM|e_Kk6j9c>˕"=NEq503ͻz#5MjcpԦb7$XRQ FHdH/oYopCm߰d,TiDXddʼxuhqdWMј [#o-&h(=V_$I>rսGkTv f"/wvp> lD998SMEn~Ff,/523N F9m'2BV} C_IdIpϜs,rSCgMw+N%QEWP,$|r2& I܃<$oST? YH]lkonŊ3dʨp "y#-9NE(r74͂W,f( Z,ؔ71RdIGP(A%ȣ²7-òM+7@]*QzR8Tz$LH=>񔾐֤tO0^8n&C6\^fvfq + ĺa[TZ z(w.U1Z{Jy" 2 Zσ?Xtm]D? +K?(VVXVޱւȹ ɓ"@ ?(t0#DU.@VORkyzhPU8~Elʜ}vR743yWϸmՋL3jRG)?? ;XwD(̅΋|L6P4>&O#5t +s}z-l#ޅ_|~#af%8߫$AJqM8+O\ S‚3]4t"KX?'a{:nDs{@ ,'u &k@g)[Z?#CIy.cTOZ~gA!ِS!8XMqd!b\<Ĵci6+"\\@AE M$󴧑-E;!v-0+. $ l^Z*(YLOϩdէP-7w>S:xK'Kz.zY5hoۤ&UeluVRߵ|<^쳺xUղ#9>b$`m9l 28pާQ~8ۇ&S jmOusE#7@P̈'֒z,T|O|0Ѫ"ӉHۑA4z3฀Pˬƺn\]]W6*&ɝq6rR@xҪ%5$kƫ LAJb2<MSY,Dpl1/ ؉^zЃ`iw8>28J+ax(~3J&Вg~9pׇ#j/!{#Zޅ`5;EѪ?6+!j7{2fgu mCtI1@ʢ%f5{<6"`K8eKVO"kٚY:T^p'rTgh2y_I 5L^oϟW%]~^N$?Pa썝\sPҔ.U\T+*F&r!9V(Pfd :^e}t}[K/HYqͮrܿD&ylAfX.`療ܷ=Ɣ6oV)5ŵ~ґMNjW!>'\Z#!}ڥ3n 'hX3H|1\P"H5 @]Z+rB8gbn=έ@2EAx%ӇXҤЮ|H (pWf6 +%\L 3C 5[ZUoq2UƔ\3qy&2HAUjmDn:7٘6%qY艈?զR&nџMS`z!6$ˡj l v)况rT~kS^v\WPDq$w)ߤT2ܟ>T&-G.vup H9H8nosEx+MO\{JczNABW)1uni+3n[fGX6{XG3/`f{oDo dLDX. >(*ڀ$l@"`>\Np5Xfa48Yl۱*ı؎mTa86Zφ#2Jzyl"B٬p0Hی$< H` lDJ:,BRDžBy&<$gֳi0JrQ zi 2pjȘՀ|@@z@P٨g(TB`J!%"$LD<]#Hɦ%dI, Yp$!ay)tl}tlLgLg3&n yM4 E@fL:u + +3`PDDDJ$(@F.1r"9PD L@1p qA Ȉa1J -+2""(6l6,<z6" +')"3w1J0'Bιi>`tt:)>3q" .Lh:Q@cf]\x΁AG#Jz@IEtG8h9Qa #4 +htDVlH$tS$L*PŒR hT +8 +!ٰ :24(gF3QABAՃZqi8yEJe;P `@!˄ +BG#ڱCCPŘF`nf41h4Ba Hd2A 111&!i`#011bDld4$\@,;9a#%}La +tEE:88B˄*63`Abi$L 4y@iF)! 6`@~*d:xF$aH٠@` +FI"~.)itr>t( ( !e /2"gAI2" p--8r!÷|fŃ  rUR#H6LL $pё1qKJBü̘4H@gACCIHci*(IBG x2`x`/ =ZH8xq yXVN܃BCE+6 efP1=2舺у$hN4 QhO + QQYltB5H@N@">`AĐr`p./BP %ˆg4l`L(DD& ^B@$2(!>%d) hJ" XD.R#Q(((.%%xy iyd 1$$xPe6".b(0*J0(``DCK7+K_^}iؾ7MWי_jW^3#wS^>e}3_MkV3v*6/7O46˼Uij=isOMMsj5yw>MۮyZMyhjt[/- Ws'gf>o~Dw[L~Ux8Ond}w>[ɆϨkݹ츹ɞu[wS Y_۽ֳ::K^x̆կCG[眬pO|}m cgū\MǾ5WWk/=sn[My&muvram۸6xq-/u>dt^'LڛN֛ry97IE^B^}6T䥿hLJk\bj7]rjz{i~Քl&]ݍWSrߓ>-s,q]~5b[oՕ'}&6]s۟Z>~gڿfqllI<{iWz+Wߴx_Mqy{5:klյޘ֫37uJ]~gw]Ml.J\\=_k&PTv$X`8N((( B& B!0b;VDEJyP]H%tU $Cv <|Rf6HN6R@Bc,vX9Y6*U, ]3t:B! + $:MY&еl0|csM6 abBLPRk@ 1P8)ԇs2Aj}6 6`(XTL EG %Q:$LJ.x(8:"  thAi@UQ%# 4!12M_ :;; H"5r,VM8Ѣ#G%$1!7   BT(QA"bANXZh@Si<.$4 .$8LD8f:LP|`lv"`s HHLtȬRYaE`Dfe<P PIjLP%Y<bbZHZ:vŪ-BIұ +4Q9*P9#Q鈨T *)p" c, D N@)jQPlAȄHH.ht@B:6aH9p U;% - u̅ʈ0!)B$8̨49V6 6J!t|ACI-fSi@t0t4( #ԩH `AI(cFc$hFX`DH#yCI{d*0*$Xap蠤 > /#`BC""*5OmG2>2 ! +hYXAA1!夕4=o1ۗueI+ϖk r}a:f/~js pB}sQUtݲ7?j:-z{KVeh抹ߘkߌڦˉvȜ;/f^{r.ۿ&'#n߹+gcggK^D3<[ZNq*w[S=uoSsxu*sRts7yJ^h15ٗ嚦wiTIՏשz:ISLܧn܇~!z2W{{Nxx+=m1|~Ny̗Sz|&Ϗ3E˵q_>~vZa/sgo_>VO'l^6^OzskU]ʓj.ze{NϽPw_=]uN\kɭ]n%%s[ٺ_Y޹oU^Nw·:=:ޟ3v=^wؼQuVZO ߖ6ol^vا^{isWi{~_wӳ޽kۺ{]z?7MV_|?!5 + s\kKÛ /54$u)OzO"0NL"'|v$NӏOr=W7^UswfwyӦsf'5$Z:N8N儊8Mk[;ur.m<ůlujFTk^;enϔSfz~hkǎl֬Yϻ#/G]vL3[s4չ!J+bn#oBVO<[ݏc}\DO[:᯳vZ2Nm9ZݲlMV~[=v1J+S^oiVclm YOgz>V5GTcꋘ:ݭmNnvsTI:uMS=نy:Fվ\ۻ̌V_&Ncnd)&cړfD3^YMlz~8jV2B?^C|;Ʃ_vy_5?.t5\'L|8q}2_~c/}o}Ce]5=_ poO׵cVʷ9F|N2BB2 +(8 -=en,?дq!o.dCieBk|ͻ|k81REQ$b +b&ѨLhaEH IDH D.RF j$ +@&ۚI++nnf&}y+YVvf~kRV[ei~ﻲ{6ϻ[zӖvDls[o[C}ujV{/Lӳ<[߿uW.!dXqsuz{u~wSϳlWwd|+?qYn5]&Tf\i[ڱˤ~,.ltv|v}w3̥gy=/5WZѼ{[ٙm缯owח>w3w)w:k}[؝fiKW+sc5&6ͳ -oWZܝp{67u:u^kKN3M?'yg|̸~2yi}j 9qˊxkilK]l-I5UOUoyͲXuu-ۻeZj_x;2}lIyWLhyƧ~:aR{]^kʸxvTLjk3<|Wng7?LRVѲrVt][|Ũ&z[FDScNu_k_ɵs}[cj.}&ec6{{eKSƼ劋jnK7S1?zzfvǬ˹,їsY[]m7הU>NxɎݬGuOM]W't[][]?.fŸ}yVӲzlnjV^;VS.UxͱUqZn5q-kj⡷?I/M}JkV<4FSɷ}z{^O}LOi3:j͝,VSr[Njؚ謎 7Qn=ݭ}}}=˝Ѽ\W?#3:i u%ڿcsw>[S}ͥku'ttӭ&Exq.txy{Y.eƵe-Ut m}7uOm=woy9Vwޣ{k1+kVӾ*5;$9geܵ9顴lȷoiu~\[M+wXVJ)$fؖkܟiyk$raI QP,HP )#.)d&xp~ϵy֨TQ&ũX$TJ& 0@$ eHY\,HD4"` (!0 2 +! ȡ)vN}a/&+ @(;DXnoIjpT|aL?bo]2d3&:v8#<%iMDZb}&'CUq&rc<+ٸ;N0H(C#ZH c+ClZy?9J+ŭA +^n|;8|T!+-2t6-ZtD/) IN-KEUM̕?!mf ?!Ѐ 2{}_2X}#K2gPцǞjQmR?%v^ ugؤ'{P,l+"W W:7dq4^^?@3= }Dᱵ̱b;xs2r2qb ٝY6{ch&C_>'0RLpU|T(ۢ Z2`m?̮D=3SN`-ǭBMN B.0$h $fjm6/ˢpݙE}w%Z}r["J~"FtbkL$`2mek$GuKC䱂f­4T?'W SD +:<8QBJ>PuC$5TK3T-$F%/$*Xz^Zy!@7y9c̎A6QwAsMp|Dp4aFE~KSbxGq2mf a^wOwgWʘTF +;su,Bpn%=+2B#KE1|aw5i⋥QJpmFd:թ!Yב(!tjVuŨ+\QLQv\&f}D&q 0r=hlxHkk\db\fyۀfOm\%K#(ݩ#-5(U|2׆="GN__i,_dR¦yڷ$Qa`s3b +2͢i#bB/2 %k |X-AS +UˠU;V5\ĚWbpE4 A,~`9Qt\\˪7ZNY~Ǵ7;$DlZ"}Ko+\Ŝr d +;x$.P EmQ'ƳD0bbSuYĂO h2Arb`۝T<"[*ۮ-3dE7b)s-)Jja#b4rb+EO{ns\c5b?!b?v.LGrDlB$OǩIE4Heb[vጥU?=n/I$:Z2vuexb=ւt@lڜdU<{D /e5B?ѾfP<1c X4-޲zߑ*|J1{];q(M/#$|ez=qPMdևPǞAbQ})Hѿ^bO3W +mBrc9 $941x@`gTvI[\eە p$;J)PX_o! HUV5\҇oH#;ۂ:>'O7C"zpϜiC9IԴ8_b'P!oE!F2d9O9HBp"L ސf^wgme=`<I;Q|4[k,i0 o$JLdՍ8C}/J O\D#Y*f_P$O6.{ͷӑ,c+ nG9C\unVߜ 34PRpE;Y/Q +-R2 YvQsB_(5H\ 쩛 &՚gƅN(}f I+ROhfuF'5sU1%Q0$L4i7T0.ޏa3h\"֑ l߻1xFÊpgGN3LIJB s3qN4 (^u]UZMN={`Kg@t=ӮvFE:[z'g-#OK.iaC-a<K&nX)S9 +Ou\ vw{ʪGBMZ7i*UB-f<h;}+n9_9NMxƲ3N6FCٹȂDKPH&K]a@ !ȟʾ]ו!? i Sף6DX${v7(hi<%B *ujTrt`!I3NSܺ;.#4tBaHK 8Qҡ{|&Kot7- sha'vANdK.a3 . Sb]_/8(Fq{F]T!K 1ɀ=u( +f cb.;^:^VPc.˦O>>u୽e*k>bf#ꝷ"XP>b@0< '(LQk2u'hIdX(Fl=y, 5ZT*EU8rM,@DVȆV>vV%Vy'SD5[lg*&>'0z{Z׶S$1+e loKؤGF pFcw(P;_ ;%J{,U )Yp҉VEg*,>7)"SrTHQi U!롚e45y$N;8Xo-69*mI7()IL#^,6jC %ކZjBCѷBep7:Q5W9@ ?;!iZ.'+S^^D3.ReFJH9PȟlpCF0-y >ZVPp~ JXޕ7YML _IQ=sbP!.VrUb~ߍ51G~ +(Q4q b&!WdwUߒj,u[IUTVk˽Nol2<EH6#Lʙ 72Qƽ931AJ'*`Ƹײe# :QзmW,ڠ~vxJ#+0uqdUYǔ\0#@M,o9'صZ;YFH8I#*lx0t?q@ۜ|!fm7+ۓ5*؜3B\aNe˓ mqƇ@t f_t˔fu㪚(VJ.9Ul[6oZJ +O.m>RI . K|v<*Nw.h >^x/^ 8/~ sSXK9A +Br.]: +' żi?4?R< ~D S[gV!cc?Hp/|ye*(\ +իd2★unDMt 3Rf9:'hC!x}TGxy5sȸR#E9 f1YҀM\jWԮ'3*:- sF˅h +[0}6C7݉Aj~`JL`*0HEbyw{RG4̉W'2A2~~C@QFkC+NpAn L3x)KCSҀTU@y[EʙWHccX*3=2Gx\"S/ţ4o6J&W4YRQ[~ +荭&~̱>60fhN1=)QCͨ:%T6E ̍c\:!@5 *xӅf[dNT.)@s}!N Z' +>Hfo8kcGN8NEԉxPOp>$ R Ѣ=%#c!P% NwZaYb.Vp\kK5i-p ,e%L p45IiF+dRCgg*-`HIni ַ=๻v#0u!ƀK2ybցOY̑zh^u9(8#5;n(SVSCIzbK7@=:]LNɃ ơ/%rbC5˓ʬnHf`aQv2Ύ ?{A*?SFHtĿǯDL0brCDyh@":&_?T_^)Ģ$,y4%)8&6Tf)W&c.eE/"<(ftm+jv514! (pѓu|d~w*4+3{SpjɫoxFV+|?|!: ɿc`Xf'v旯` 0㦚iڅtئ<)\vvBuo +TOnd{U9]*<=3(+Ofc!maF Zɾ1BP]3պN齿Xzb1pkX;L_Se|WlEYfjjuvDp]dmv()KhI~EGyIN(vw.O8>By|'7c\(.MXsL-0690c ?b`N˰Q>X# Gq>=.5B84RʼYX1r]Sݔyd3wӘ. TسBex)M +}oy/}tD۫/SB)un$CNC6^VjN1j@%w5mVPЄJ~b+.N2?aJ'iy]Gn96VfrǨ60Μc"l1o&=;Ѿ `wWKEɕf;`,EGH 320$<~W'ł!"ՌL,tob1HU\ H=6Ĺ!ae: i(EF>cK*#3L}C1b#PmO\*I `Vf?j# xVT_Z7 / %0 3R +޶ҬS@}%&7~l8D/|`vV7LLK\!}~5LDHMFMԯ0_b.:%tڗ7>GiΥԠCbR )hYpDCr՗{;2~&:mM+^9/Y]sz#GEJT6 sLWG/Wd G9عioWП2;!%ot;R~Jǰ3m9Ssa:^@R..ը94̶ܮ^h-0WTӖ,jFvT3랏3afinƫ0%2QPgۤak~)Rޱ *$)vi  yS|BtҜC1<(5hWC of_ 栢o.}`a*/qtz[fh;cKr;]U`e@ bRgSJj"/NVuB>_Zkueb!K~OMReQr% +1UZf~?%a̮(uwM"&SԒ J 5CM'I:JcޔQxdLl6Rj7{|~o|Z9Ok (g ۯ +[}oeQ~f?oerd}!~PC _we)W*&<XIŴCvlTы^fYNa_H0+Ҝx~ĴuX_(Lb3vllE4?.-"is~sسl4TDכOc="'[2熗~u~7C+R;7JwgM ~n +)R/ػPz:뽂uR9ye.dMqm/8⦌K~j pEc6 7.%Wn#Hh8|k 3Vo\(&Wں Gx'3+otD'wdzݪpd֙VoTBR*/ӝ`>em}IW;(Ls֪" dYۥF0DŰ̂_Gh̿ey-ӑ7oWýh8Yg|Y +o ;ִjnߝ)\4ol|(f+MCOf՞~s]rheB,ڡ[!&8{B[l_G'wl29&j˼}q5@9a +k0ߩ{#8L0N +0˩D`z#Y9$g {k#;<+oo>^-iUUoAIʵ`S.Ysj{+ZU px&J}/'l(_ F)J0\7 ̈рbR~_= G/C&$vM}!3)XFȤGܛAU%g_HKLKS=ec3!6GdH|5Pۚx +dX XvL%?A(VS lv˕OBȄ!\+0?=t&oJ _>Eӂ53=IfŶaʄnSP?;&yKש߂U{OiN!Ҵj!: 8[` P״ +-4ڳ; ,Y(7 +:glz} }_eZ!L&~'cW6zIܥyN +u\bɝP!b34Uw_SOIjYd<o'h:ۘn@@6npk$7=;?p<]ĉ5ܟ\O /?*u?ܒyҎQC|;P McO.#T|,AOETi>w$*f5eiE@RGA4-͜EqH%%l%p@bO(<;?,&ݒҭC3rkOi.ph1 |dڿW`:Ra,Ξteć[F. =s +%QniU@U7*4>I-}ll(Ip6g)QrJL?qHO!*J5 (w_s+{~L}V2Δ ؖK\0ĕ+wtB!ɌwjN"foV>"39M}@&h)ZSړiR0ot܄PqKuf[WRpaM {-ji-)4)oҁ t՟Usm #f1x]e9yT=iy][ C8F"(fX$!VJS +!%= #/e?Nm<n$xO#s +RXt}2^20_cBCV:Rag]c0$>~ڮ}؊V 9 4VVP*QQז;-lx]uI˵syt($D]Cc*tﲨOxuDݭ?H\B;ӭtu } +bqJL& 3Rvmz'Xjucw-,kDruEKaKbfUhf[1"k5ʶGkpFEoZsԝs1N!%٨+p evzQw5+o/Zn1Y;) Pu*}kԍf29t{dG M/MݮG]d Y*!u|[.~܏u!Dk6B*Eit5펺֘iTLp9G!.pg+6Ԏ=Uz! 9wQ 3txnxyngNǺ=c2fVi肌~W ٢Òayjs":oRj/QOE3T9G E8EoeW(K6\^cw[?Qq3hr|KA8- ޕ_۰Pw< endstream endobj 29 0 obj [28 0 R] endobj 39 0 obj <> endobj xref +0 40 +0000000004 65535 f +0000000016 00000 n +0000000147 00000 n +0000040637 00000 n +0000000000 00000 f +0000040688 00000 n +0000000000 00000 f +0000046158 00000 n +0000000000 00000 f +0000000000 00000 f +0000000000 00000 f +0000000000 00000 f +0000000000 00000 f +0000000000 00000 f +0000000000 00000 f +0000000000 00000 f +0000000000 00000 f +0000000000 00000 f +0000000000 00000 f +0000000000 00000 f +0000000000 00000 f +0000000000 00000 f +0000046231 00000 n +0000046427 00000 n +0000047598 00000 n +0000113186 00000 n +0000178774 00000 n +0000000000 00000 f +0000043171 00000 n +0000215111 00000 n +0000041070 00000 n +0000043475 00000 n +0000043362 00000 n +0000042257 00000 n +0000042610 00000 n +0000042658 00000 n +0000043246 00000 n +0000043277 00000 n +0000043510 00000 n +0000215136 00000 n +trailer <]>> startxref 215352 %%EOF \ No newline at end of file From 0cb33072f8c92be57d7dba4a4ff92f8225f9e9bb Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?=E5=91=A8=E6=97=AD?= Date: Tue, 12 May 2020 09:32:12 +0800 Subject: [PATCH 267/924] =?UTF-8?q?=E4=BC=98=E5=8C=96?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- .../java/com/ejlchina/okhttps/FastjsonMsgConvertor.java | 6 ------ .../main/java/com/ejlchina/okhttps/GsonMsgConvertor.java | 6 ------ .../main/java/com/ejlchina/okhttps/JacksonMsgConvertor.java | 6 ------ .../src/main/java/com/ejlchina/okhttps/MsgConvertor.java | 6 ------ 4 files changed, 24 deletions(-) diff --git a/okhttps-fastjson/src/main/java/com/ejlchina/okhttps/FastjsonMsgConvertor.java b/okhttps-fastjson/src/main/java/com/ejlchina/okhttps/FastjsonMsgConvertor.java index e226c5f4..e138e701 100644 --- a/okhttps-fastjson/src/main/java/com/ejlchina/okhttps/FastjsonMsgConvertor.java +++ b/okhttps-fastjson/src/main/java/com/ejlchina/okhttps/FastjsonMsgConvertor.java @@ -33,12 +33,6 @@ public byte[] serialize(Object object, Charset charset) { @Override public byte[] serialize(Object object, String dateFormat, Charset charset) { - if (object instanceof byte[]) { - return (byte[]) object; - } - if (object instanceof String) { - return object.toString().getBytes(charset); - } if (dateFormat != null) { return JSON.toJSONStringWithDateFormat(object, dateFormat).getBytes(charset); } diff --git a/okhttps-gson/src/main/java/com/ejlchina/okhttps/GsonMsgConvertor.java b/okhttps-gson/src/main/java/com/ejlchina/okhttps/GsonMsgConvertor.java index 045c0096..e0792fbd 100644 --- a/okhttps-gson/src/main/java/com/ejlchina/okhttps/GsonMsgConvertor.java +++ b/okhttps-gson/src/main/java/com/ejlchina/okhttps/GsonMsgConvertor.java @@ -46,12 +46,6 @@ public byte[] serialize(Object object, Charset charset) { @Override public byte[] serialize(Object object, String dateFormat, Charset charset) { - if (object instanceof byte[]) { - return (byte[]) object; - } - if (object instanceof String) { - return object.toString().getBytes(charset); - } Gson gson = this.gson; if (dateFormat != null) { gson = gson.newBuilder().setDateFormat(dateFormat).create(); diff --git a/okhttps-jackson/src/main/java/com/ejlchina/okhttps/JacksonMsgConvertor.java b/okhttps-jackson/src/main/java/com/ejlchina/okhttps/JacksonMsgConvertor.java index f9827d81..35fe7085 100644 --- a/okhttps-jackson/src/main/java/com/ejlchina/okhttps/JacksonMsgConvertor.java +++ b/okhttps-jackson/src/main/java/com/ejlchina/okhttps/JacksonMsgConvertor.java @@ -72,12 +72,6 @@ public byte[] serialize(Object object, Charset charset) { @Override public byte[] serialize(Object object, String dateFormat, Charset charset) { - if (object instanceof byte[]) { - return (byte[]) object; - } - if (object instanceof String) { - return object.toString().getBytes(charset); - } ObjectMapper mapper = objectMapper; if (dateFormat != null) { mapper = mapper.copy().configure(SerializationFeature.WRITE_DATES_AS_TIMESTAMPS, false) diff --git a/okhttps/src/main/java/com/ejlchina/okhttps/MsgConvertor.java b/okhttps/src/main/java/com/ejlchina/okhttps/MsgConvertor.java index 9b1251c7..e8aa54ca 100644 --- a/okhttps/src/main/java/com/ejlchina/okhttps/MsgConvertor.java +++ b/okhttps/src/main/java/com/ejlchina/okhttps/MsgConvertor.java @@ -100,12 +100,6 @@ public byte[] serialize(Object object, Charset charset) { @Override public byte[] serialize(Object object, String dateFormat, Charset charset) { - if (object instanceof byte[]) { - return (byte[]) object; - } - if (object instanceof String) { - return object.toString().getBytes(charset); - } byte[] data = convertor.serialize(object, dateFormat, charset); Mapper mapper = convertor.toMapper(new ByteArrayInputStream(data), charset); StringBuilder sb = new StringBuilder(); From 61c04603801f204f532e664166214368c37b24d8 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?=E5=91=A8=E6=97=AD?= Date: Tue, 12 May 2020 09:33:11 +0800 Subject: [PATCH 268/924] logo --- okhttps-doc/{OkHttps. logo.ai => OkHttps.logo.ai} | 0 1 file changed, 0 insertions(+), 0 deletions(-) rename okhttps-doc/{OkHttps. logo.ai => OkHttps.logo.ai} (100%) diff --git a/okhttps-doc/OkHttps. logo.ai b/okhttps-doc/OkHttps.logo.ai similarity index 100% rename from okhttps-doc/OkHttps. logo.ai rename to okhttps-doc/OkHttps.logo.ai From 18b20c35d63951ec25d713f91c4a12e9374c75dc Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?=E5=91=A8=E6=97=AD?= Date: Tue, 12 May 2020 10:04:56 +0800 Subject: [PATCH 269/924] TestCase --- okhttps-fastjson/pom.xml | 6 ++ .../java/com/ejlchina/okhttps/TestCase.java | 17 ++++ .../java/com/ejlchina/okhttps/TestCases.java | 88 ------------------- .../test/java/com/ejlchina/okhttps/User.java | 66 -------------- okhttps-gson/pom.xml | 6 ++ .../java/com/ejlchina/okhttps/DateBean.java | 40 --------- .../java/com/ejlchina/okhttps/TestCase.java | 15 ++++ okhttps-jackson/pom.xml | 6 ++ .../java/com/ejlchina/okhttps/DateBean.java | 40 --------- .../java/com/ejlchina/okhttps/TestCase.java | 15 ++++ .../java/com/ejlchina/okhttps/TestCases.java | 88 ------------------- .../test/java/com/ejlchina/okhttps/User.java | 66 -------------- okhttps-test/.gitignore | 1 + okhttps-test/pom.xml | 30 +++++++ .../com/ejlchina/okhttps/test}/DateBean.java | 2 +- .../okhttps/test/MsgConvertorTest.java | 88 +++++++++++-------- .../java/com/ejlchina/okhttps/test}/User.java | 2 +- pom.xml | 1 + 18 files changed, 150 insertions(+), 427 deletions(-) create mode 100644 okhttps-fastjson/src/test/java/com/ejlchina/okhttps/TestCase.java delete mode 100644 okhttps-fastjson/src/test/java/com/ejlchina/okhttps/TestCases.java delete mode 100644 okhttps-fastjson/src/test/java/com/ejlchina/okhttps/User.java delete mode 100644 okhttps-gson/src/test/java/com/ejlchina/okhttps/DateBean.java create mode 100644 okhttps-gson/src/test/java/com/ejlchina/okhttps/TestCase.java delete mode 100644 okhttps-jackson/src/test/java/com/ejlchina/okhttps/DateBean.java create mode 100644 okhttps-jackson/src/test/java/com/ejlchina/okhttps/TestCase.java delete mode 100644 okhttps-jackson/src/test/java/com/ejlchina/okhttps/TestCases.java delete mode 100644 okhttps-jackson/src/test/java/com/ejlchina/okhttps/User.java create mode 100644 okhttps-test/.gitignore create mode 100644 okhttps-test/pom.xml rename {okhttps-fastjson/src/test/java/com/ejlchina/okhttps => okhttps-test/src/main/java/com/ejlchina/okhttps/test}/DateBean.java (93%) rename okhttps-gson/src/test/java/com/ejlchina/okhttps/TestCases.java => okhttps-test/src/main/java/com/ejlchina/okhttps/test/MsgConvertorTest.java (51%) rename {okhttps-gson/src/test/java/com/ejlchina/okhttps => okhttps-test/src/main/java/com/ejlchina/okhttps/test}/User.java (96%) diff --git a/okhttps-fastjson/pom.xml b/okhttps-fastjson/pom.xml index 2ce76aa4..9c7a04ab 100644 --- a/okhttps-fastjson/pom.xml +++ b/okhttps-fastjson/pom.xml @@ -22,6 +22,12 @@ fastjson ${fastjson.version} + + com.ejlchina + okhttps-test + ${okhttps.version} + test + diff --git a/okhttps-fastjson/src/test/java/com/ejlchina/okhttps/TestCase.java b/okhttps-fastjson/src/test/java/com/ejlchina/okhttps/TestCase.java new file mode 100644 index 00000000..dc3e6d1c --- /dev/null +++ b/okhttps-fastjson/src/test/java/com/ejlchina/okhttps/TestCase.java @@ -0,0 +1,17 @@ +package com.ejlchina.okhttps; + +import com.ejlchina.okhttps.test.MsgConvertorTest; +import org.junit.Test; + + +public class TestCase { + + + @Test + public void doTest() throws Exception { + MsgConvertor msgConvertor = new FastjsonMsgConvertor(); + new MsgConvertorTest(msgConvertor).run(); + } + + +} diff --git a/okhttps-fastjson/src/test/java/com/ejlchina/okhttps/TestCases.java b/okhttps-fastjson/src/test/java/com/ejlchina/okhttps/TestCases.java deleted file mode 100644 index 0006da0a..00000000 --- a/okhttps-fastjson/src/test/java/com/ejlchina/okhttps/TestCases.java +++ /dev/null @@ -1,88 +0,0 @@ -package com.ejlchina.okhttps; - -import java.io.ByteArrayInputStream; -import java.io.InputStream; -import java.text.ParseException; -import java.text.SimpleDateFormat; -import java.util.List; -import java.util.Set; - -import org.junit.Assert; -import org.junit.Test; - - -public class TestCases { - - MsgConvertor msgConvertor = new FastjsonMsgConvertor(); - - @Test - public void testToJsonObj() { - String json = "{\"id\":1,\"name\":\"Jack\"}"; - InputStream in = new ByteArrayInputStream(json.getBytes()); - Mapper mapper = msgConvertor.toMapper(in); - Set keys = mapper.keySet(); - Assert.assertTrue(keys.size() == 2); - Assert.assertTrue(keys.contains("id")); - Assert.assertTrue(keys.contains("name")); - Assert.assertTrue(!mapper.isEmpty()); - Assert.assertTrue(2 == mapper.size()); - Assert.assertTrue(1 == mapper.getInt("id")); - Assert.assertTrue(!mapper.has("age")); - Assert.assertTrue(0 == mapper.getInt("age")); - Assert.assertEquals("Jack", mapper.getString("name")); - } - - @Test - public void testToJsonArr() { - String json = "[{\"id\":1,\"name\":\"Jack\"},{\"id\":2,\"name\":\"Tom\"}]"; - InputStream in = new ByteArrayInputStream(json.getBytes()); - Array jsonObj = msgConvertor.toArray(in); - Assert.assertTrue(!jsonObj.isEmpty()); - Assert.assertTrue(jsonObj.size() == 2); - Mapper json1 = jsonObj.getMapper(0); - Mapper json2 = jsonObj.getMapper(1); - Assert.assertEquals(1, json1.getInt("id")); - Assert.assertEquals("Jack", json1.getString("name")); - Assert.assertEquals(2, json2.getInt("id")); - Assert.assertEquals("Tom", json2.getString("name")); - } - - @Test - public void testToJsonStr() { - String json = msgConvertor.serialize(new User(1, "Jack")); - Assert.assertEquals("{\"id\":1,\"name\":\"Jack\"}", json); - } - - @Test - public void testToJsonStrWithDateFormat() throws ParseException { - String dataFormat = "yyyy-MM-dd HH:mm:ss"; - SimpleDateFormat sdf = new SimpleDateFormat(dataFormat); - String date = "2020-05-09 12:30:15"; - String json = msgConvertor.serialize(new DateBean(1, sdf.parse(date)), dataFormat); - Assert.assertTrue(json.contains(date)); - } - - @Test - public void testJsonToBean() { - String json = "{\"id\":1,\"name\":\"Jack\"}"; - InputStream in = new ByteArrayInputStream(json.getBytes()); - User user = msgConvertor.toBean(User.class, in); - Assert.assertEquals(1, user.getId()); - Assert.assertEquals("Jack", user.getName()); - } - - @Test - public void testJsonToList() { - String json = "[{\"id\":1,\"name\":\"Jack\"},{\"id\":2,\"name\":\"Tom\"}]"; - InputStream in = new ByteArrayInputStream(json.getBytes()); - List users = msgConvertor.toList(User.class, in); - Assert.assertTrue(2 == users.size()); - User u1 = users.get(0); - User u2 = users.get(1); - Assert.assertEquals(1, u1.getId()); - Assert.assertEquals("Jack", u1.getName()); - Assert.assertEquals(2, u2.getId()); - Assert.assertEquals("Tom", u2.getName()); - } - -} diff --git a/okhttps-fastjson/src/test/java/com/ejlchina/okhttps/User.java b/okhttps-fastjson/src/test/java/com/ejlchina/okhttps/User.java deleted file mode 100644 index 1fcb6484..00000000 --- a/okhttps-fastjson/src/test/java/com/ejlchina/okhttps/User.java +++ /dev/null @@ -1,66 +0,0 @@ -package com.ejlchina.okhttps; - -public class User { - - private int id; - private String name; - - - public User() { - } - - public User(int id, String name) { - this.id = id; - this.name = name; - } - - public void setId(int id) { - this.id = id; - } - - public void setName(String name) { - this.name = name; - } - - public int getId() { - return id; - } - - public String getName() { - return name; - } - - @Override - public String toString() { - return "User [id=" + id + ", name=" + name + "]"; - } - - @Override - public int hashCode() { - final int prime = 31; - int result = 1; - result = prime * result + id; - result = prime * result + ((name == null) ? 0 : name.hashCode()); - return result; - } - - @Override - public boolean equals(Object obj) { - if (this == obj) - return true; - if (obj == null) - return false; - if (getClass() != obj.getClass()) - return false; - User other = (User) obj; - if (id != other.id) - return false; - if (name == null) { - if (other.name != null) - return false; - } else if (!name.equals(other.name)) - return false; - return true; - } - -} diff --git a/okhttps-gson/pom.xml b/okhttps-gson/pom.xml index 3fefaaf1..fdf36c1b 100644 --- a/okhttps-gson/pom.xml +++ b/okhttps-gson/pom.xml @@ -22,6 +22,12 @@ gson ${gson.version} + + com.ejlchina + okhttps-test + ${okhttps.version} + test + diff --git a/okhttps-gson/src/test/java/com/ejlchina/okhttps/DateBean.java b/okhttps-gson/src/test/java/com/ejlchina/okhttps/DateBean.java deleted file mode 100644 index 2e016c80..00000000 --- a/okhttps-gson/src/test/java/com/ejlchina/okhttps/DateBean.java +++ /dev/null @@ -1,40 +0,0 @@ -package com.ejlchina.okhttps; - -import java.util.Date; - -public class DateBean { - - private int id; - private Date date; - - - public DateBean() { - } - - public DateBean(int id, Date date) { - this.id = id; - this.date = date; - } - - public int getId() { - return id; - } - - public void setId(int id) { - this.id = id; - } - - public Date getDate() { - return date; - } - - public void setDate(Date date) { - this.date = date; - } - - @Override - public String toString() { - return "DateBean [id=" + id + ", date=" + date + "]"; - } - -} diff --git a/okhttps-gson/src/test/java/com/ejlchina/okhttps/TestCase.java b/okhttps-gson/src/test/java/com/ejlchina/okhttps/TestCase.java new file mode 100644 index 00000000..1f82e948 --- /dev/null +++ b/okhttps-gson/src/test/java/com/ejlchina/okhttps/TestCase.java @@ -0,0 +1,15 @@ +package com.ejlchina.okhttps; + +import com.ejlchina.okhttps.test.MsgConvertorTest; +import org.junit.Test; + + +public class TestCase { + + @Test + public void doTest() throws Exception { + MsgConvertor msgConvertor = new GsonMsgConvertor(); + new MsgConvertorTest(msgConvertor).run(); + } + +} diff --git a/okhttps-jackson/pom.xml b/okhttps-jackson/pom.xml index 62d867ec..e5a2e005 100644 --- a/okhttps-jackson/pom.xml +++ b/okhttps-jackson/pom.xml @@ -22,6 +22,12 @@ jackson-databind ${jackson.version} + + com.ejlchina + okhttps-test + ${okhttps.version} + test + diff --git a/okhttps-jackson/src/test/java/com/ejlchina/okhttps/DateBean.java b/okhttps-jackson/src/test/java/com/ejlchina/okhttps/DateBean.java deleted file mode 100644 index 2e016c80..00000000 --- a/okhttps-jackson/src/test/java/com/ejlchina/okhttps/DateBean.java +++ /dev/null @@ -1,40 +0,0 @@ -package com.ejlchina.okhttps; - -import java.util.Date; - -public class DateBean { - - private int id; - private Date date; - - - public DateBean() { - } - - public DateBean(int id, Date date) { - this.id = id; - this.date = date; - } - - public int getId() { - return id; - } - - public void setId(int id) { - this.id = id; - } - - public Date getDate() { - return date; - } - - public void setDate(Date date) { - this.date = date; - } - - @Override - public String toString() { - return "DateBean [id=" + id + ", date=" + date + "]"; - } - -} diff --git a/okhttps-jackson/src/test/java/com/ejlchina/okhttps/TestCase.java b/okhttps-jackson/src/test/java/com/ejlchina/okhttps/TestCase.java new file mode 100644 index 00000000..71f5d99e --- /dev/null +++ b/okhttps-jackson/src/test/java/com/ejlchina/okhttps/TestCase.java @@ -0,0 +1,15 @@ +package com.ejlchina.okhttps; + +import com.ejlchina.okhttps.test.MsgConvertorTest; +import org.junit.Test; + + +public class TestCase { + + @Test + public void doTest() throws Exception { + MsgConvertor msgConvertor = new JacksonMsgConvertor(); + new MsgConvertorTest(msgConvertor).run(); + } + +} diff --git a/okhttps-jackson/src/test/java/com/ejlchina/okhttps/TestCases.java b/okhttps-jackson/src/test/java/com/ejlchina/okhttps/TestCases.java deleted file mode 100644 index c7b8ec3b..00000000 --- a/okhttps-jackson/src/test/java/com/ejlchina/okhttps/TestCases.java +++ /dev/null @@ -1,88 +0,0 @@ -package com.ejlchina.okhttps; - -import java.io.ByteArrayInputStream; -import java.io.InputStream; -import java.text.ParseException; -import java.text.SimpleDateFormat; -import java.util.List; -import java.util.Set; - -import org.junit.Assert; -import org.junit.Test; - - -public class TestCases { - - MsgConvertor msgConvertor = new JacksonMsgConvertor(); - - @Test - public void testToJsonObj() { - String json = "{\"id\":1,\"name\":\"Jack\"}"; - InputStream in = new ByteArrayInputStream(json.getBytes()); - Mapper mapper = msgConvertor.toMapper(in); - Set keys = mapper.keySet(); - Assert.assertTrue(keys.size() == 2); - Assert.assertTrue(keys.contains("id")); - Assert.assertTrue(keys.contains("name")); - Assert.assertTrue(!mapper.isEmpty()); - Assert.assertTrue(2 == mapper.size()); - Assert.assertTrue(1 == mapper.getInt("id")); - Assert.assertTrue(!mapper.has("age")); - Assert.assertTrue(0 == mapper.getInt("age")); - Assert.assertEquals("Jack", mapper.getString("name")); - } - - @Test - public void testToJsonArr() { - String json = "[{\"id\":1,\"name\":\"Jack\"},{\"id\":2,\"name\":\"Tom\"}]"; - InputStream in = new ByteArrayInputStream(json.getBytes()); - Array jsonObj = msgConvertor.toArray(in); - Assert.assertTrue(!jsonObj.isEmpty()); - Assert.assertTrue(jsonObj.size() == 2); - Mapper json1 = jsonObj.getMapper(0); - Mapper json2 = jsonObj.getMapper(1); - Assert.assertEquals(1, json1.getInt("id")); - Assert.assertEquals("Jack", json1.getString("name")); - Assert.assertEquals(2, json2.getInt("id")); - Assert.assertEquals("Tom", json2.getString("name")); - } - - @Test - public void testToJsonStr() { - String json = msgConvertor.serialize(new User(1, "Jack")); - Assert.assertEquals("{\"id\":1,\"name\":\"Jack\"}", json); - } - - @Test - public void testToJsonStrWithDateFormat() throws ParseException { - String dataFormat = "yyyy-MM-dd HH:mm:ss"; - SimpleDateFormat sdf = new SimpleDateFormat(dataFormat); - String date = "2020-05-09 12:30:15"; - String json = msgConvertor.serialize(new DateBean(1, sdf.parse(date)), dataFormat); - Assert.assertTrue(json.contains(date)); - } - - @Test - public void testJsonToBean() { - String json = "{\"id\":1,\"name\":\"Jack\"}"; - InputStream in = new ByteArrayInputStream(json.getBytes()); - User user = msgConvertor.toBean(User.class, in); - Assert.assertEquals(1, user.getId()); - Assert.assertEquals("Jack", user.getName()); - } - - @Test - public void testJsonToList() { - String json = "[{\"id\":1,\"name\":\"Jack\"},{\"id\":2,\"name\":\"Tom\"}]"; - InputStream in = new ByteArrayInputStream(json.getBytes()); - List users = msgConvertor.toList(User.class, in); - Assert.assertTrue(2 == users.size()); - User u1 = users.get(0); - User u2 = users.get(1); - Assert.assertEquals(1, u1.getId()); - Assert.assertEquals("Jack", u1.getName()); - Assert.assertEquals(2, u2.getId()); - Assert.assertEquals("Tom", u2.getName()); - } - -} diff --git a/okhttps-jackson/src/test/java/com/ejlchina/okhttps/User.java b/okhttps-jackson/src/test/java/com/ejlchina/okhttps/User.java deleted file mode 100644 index 1fcb6484..00000000 --- a/okhttps-jackson/src/test/java/com/ejlchina/okhttps/User.java +++ /dev/null @@ -1,66 +0,0 @@ -package com.ejlchina.okhttps; - -public class User { - - private int id; - private String name; - - - public User() { - } - - public User(int id, String name) { - this.id = id; - this.name = name; - } - - public void setId(int id) { - this.id = id; - } - - public void setName(String name) { - this.name = name; - } - - public int getId() { - return id; - } - - public String getName() { - return name; - } - - @Override - public String toString() { - return "User [id=" + id + ", name=" + name + "]"; - } - - @Override - public int hashCode() { - final int prime = 31; - int result = 1; - result = prime * result + id; - result = prime * result + ((name == null) ? 0 : name.hashCode()); - return result; - } - - @Override - public boolean equals(Object obj) { - if (this == obj) - return true; - if (obj == null) - return false; - if (getClass() != obj.getClass()) - return false; - User other = (User) obj; - if (id != other.id) - return false; - if (name == null) { - if (other.name != null) - return false; - } else if (!name.equals(other.name)) - return false; - return true; - } - -} diff --git a/okhttps-test/.gitignore b/okhttps-test/.gitignore new file mode 100644 index 00000000..b83d2226 --- /dev/null +++ b/okhttps-test/.gitignore @@ -0,0 +1 @@ +/target/ diff --git a/okhttps-test/pom.xml b/okhttps-test/pom.xml new file mode 100644 index 00000000..de096609 --- /dev/null +++ b/okhttps-test/pom.xml @@ -0,0 +1,30 @@ + + 4.0.0 + + okhttps-test + OkHttps Test + jar + + + com.ejlchina + okhttps-parent + 2.0.0 + + + + + com.ejlchina + okhttps + ${okhttps.version} + + + junit + junit + ${junit.version} + + + + + okhttps-test + + \ No newline at end of file diff --git a/okhttps-fastjson/src/test/java/com/ejlchina/okhttps/DateBean.java b/okhttps-test/src/main/java/com/ejlchina/okhttps/test/DateBean.java similarity index 93% rename from okhttps-fastjson/src/test/java/com/ejlchina/okhttps/DateBean.java rename to okhttps-test/src/main/java/com/ejlchina/okhttps/test/DateBean.java index 2e016c80..34cfdb53 100644 --- a/okhttps-fastjson/src/test/java/com/ejlchina/okhttps/DateBean.java +++ b/okhttps-test/src/main/java/com/ejlchina/okhttps/test/DateBean.java @@ -1,4 +1,4 @@ -package com.ejlchina.okhttps; +package com.ejlchina.okhttps.test; import java.util.Date; diff --git a/okhttps-gson/src/test/java/com/ejlchina/okhttps/TestCases.java b/okhttps-test/src/main/java/com/ejlchina/okhttps/test/MsgConvertorTest.java similarity index 51% rename from okhttps-gson/src/test/java/com/ejlchina/okhttps/TestCases.java rename to okhttps-test/src/main/java/com/ejlchina/okhttps/test/MsgConvertorTest.java index f87aeb66..4f2d6bd1 100644 --- a/okhttps-gson/src/test/java/com/ejlchina/okhttps/TestCases.java +++ b/okhttps-test/src/main/java/com/ejlchina/okhttps/test/MsgConvertorTest.java @@ -1,44 +1,59 @@ -package com.ejlchina.okhttps; +package com.ejlchina.okhttps.test; + +import com.ejlchina.okhttps.Array; +import com.ejlchina.okhttps.Mapper; +import com.ejlchina.okhttps.MsgConvertor; +import org.junit.Assert; import java.io.ByteArrayInputStream; import java.io.InputStream; +import java.nio.charset.StandardCharsets; import java.text.ParseException; import java.text.SimpleDateFormat; import java.util.List; import java.util.Set; -import org.junit.Assert; -import org.junit.Test; +public class MsgConvertorTest { -public class TestCases { + MsgConvertor msgConvertor; - MsgConvertor msgConvertor = new GsonMsgConvertor(); - - @Test - public void testToJsonObj() { + public MsgConvertorTest(MsgConvertor msgConvertor) { + this.msgConvertor = msgConvertor; + } + + public void run() throws Exception { + testToMapper(); + testToArray(); + testSerialize(); + testSerializeWithDateFormat(); + testToBean(); + testToList(); + } + + + void testToMapper() { String json = "{\"id\":1,\"name\":\"Jack\"}"; InputStream in = new ByteArrayInputStream(json.getBytes()); - Mapper mapper = msgConvertor.toMapper(in); + Mapper mapper = msgConvertor.toMapper(in, StandardCharsets.UTF_8); Set keys = mapper.keySet(); - Assert.assertTrue(keys.size() == 2); + Assert.assertEquals(2, keys.size()); Assert.assertTrue(keys.contains("id")); Assert.assertTrue(keys.contains("name")); - Assert.assertTrue(!mapper.isEmpty()); - Assert.assertTrue(2 == mapper.size()); - Assert.assertTrue(1 == mapper.getInt("id")); - Assert.assertTrue(!mapper.has("age")); - Assert.assertTrue(0 == mapper.getInt("age")); + Assert.assertFalse(mapper.isEmpty()); + Assert.assertEquals(2, mapper.size()); + Assert.assertEquals(1, mapper.getInt("id")); + Assert.assertFalse(mapper.has("age")); + Assert.assertEquals(0, mapper.getInt("age")); Assert.assertEquals("Jack", mapper.getString("name")); } - - @Test - public void testToJsonArr() { + + void testToArray() { String json = "[{\"id\":1,\"name\":\"Jack\"},{\"id\":2,\"name\":\"Tom\"}]"; InputStream in = new ByteArrayInputStream(json.getBytes()); - Array jsonObj = msgConvertor.toArray(in); - Assert.assertTrue(!jsonObj.isEmpty()); - Assert.assertTrue(jsonObj.size() == 2); + Array jsonObj = msgConvertor.toArray(in, StandardCharsets.UTF_8); + Assert.assertFalse(jsonObj.isEmpty()); + Assert.assertEquals(2, jsonObj.size()); Mapper json1 = jsonObj.getMapper(0); Mapper json2 = jsonObj.getMapper(1); Assert.assertEquals(1, json1.getInt("id")); @@ -46,37 +61,36 @@ public void testToJsonArr() { Assert.assertEquals(2, json2.getInt("id")); Assert.assertEquals("Tom", json2.getString("name")); } - - @Test - public void testToJsonStr() { - String json = msgConvertor.serialize(new User(1, "Jack")); + + void testSerialize() { + byte[] data = msgConvertor.serialize(new User(1, "Jack"), StandardCharsets.UTF_8); + String json = new String(data, StandardCharsets.UTF_8); Assert.assertEquals("{\"id\":1,\"name\":\"Jack\"}", json); } - @Test - public void testToJsonStrWithDateFormat() throws ParseException { + + void testSerializeWithDateFormat() throws ParseException { String dataFormat = "yyyy-MM-dd HH:mm:ss"; SimpleDateFormat sdf = new SimpleDateFormat(dataFormat); String date = "2020-05-09 12:30:15"; - String json = msgConvertor.serialize(new DateBean(1, sdf.parse(date)), dataFormat); + byte[] data = msgConvertor.serialize(new DateBean(1, sdf.parse(date)), dataFormat, StandardCharsets.UTF_8); + String json = new String(data, StandardCharsets.UTF_8); Assert.assertTrue(json.contains(date)); } - - @Test - public void testJsonToBean() { + + void testToBean() { String json = "{\"id\":1,\"name\":\"Jack\"}"; InputStream in = new ByteArrayInputStream(json.getBytes()); - User user = msgConvertor.toBean(User.class, in); + User user = msgConvertor.toBean(User.class, in, StandardCharsets.UTF_8); Assert.assertEquals(1, user.getId()); Assert.assertEquals("Jack", user.getName()); } - - @Test - public void testJsonToList() { + + void testToList() { String json = "[{\"id\":1,\"name\":\"Jack\"},{\"id\":2,\"name\":\"Tom\"}]"; InputStream in = new ByteArrayInputStream(json.getBytes()); - List users = msgConvertor.toList(User.class, in); - Assert.assertTrue(2 == users.size()); + List users = msgConvertor.toList(User.class, in, StandardCharsets.UTF_8); + Assert.assertEquals(2, users.size()); User u1 = users.get(0); User u2 = users.get(1); Assert.assertEquals(1, u1.getId()); diff --git a/okhttps-gson/src/test/java/com/ejlchina/okhttps/User.java b/okhttps-test/src/main/java/com/ejlchina/okhttps/test/User.java similarity index 96% rename from okhttps-gson/src/test/java/com/ejlchina/okhttps/User.java rename to okhttps-test/src/main/java/com/ejlchina/okhttps/test/User.java index 1fcb6484..deb7c6dd 100644 --- a/okhttps-gson/src/test/java/com/ejlchina/okhttps/User.java +++ b/okhttps-test/src/main/java/com/ejlchina/okhttps/test/User.java @@ -1,4 +1,4 @@ -package com.ejlchina.okhttps; +package com.ejlchina.okhttps.test; public class User { diff --git a/pom.xml b/pom.xml index 5440f01d..fa6f9743 100644 --- a/pom.xml +++ b/pom.xml @@ -13,6 +13,7 @@ okhttps-fastjson okhttps-gson okhttps-jackson + okhttps-test From 92c59102f74177bd032861c3bcdec8bc39b3452f Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?=E5=91=A8=E6=97=AD?= Date: Tue, 12 May 2020 11:51:37 +0800 Subject: [PATCH 270/924] =?UTF-8?q?WebSocket=20=E6=96=B0=E5=A2=9E=20msgTyp?= =?UTF-8?q?e=20=E6=96=B9=E6=B3=95?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- .../java/com/ejlchina/okhttps/WebSocket.java | 8 +++++++- .../okhttps/internal/WebSocketTask.java | 19 +++++++++++++------ 2 files changed, 20 insertions(+), 7 deletions(-) diff --git a/okhttps/src/main/java/com/ejlchina/okhttps/WebSocket.java b/okhttps/src/main/java/com/ejlchina/okhttps/WebSocket.java index 3fb62071..1e30a087 100644 --- a/okhttps/src/main/java/com/ejlchina/okhttps/WebSocket.java +++ b/okhttps/src/main/java/com/ejlchina/okhttps/WebSocket.java @@ -126,5 +126,11 @@ interface Listener { * 同 {@link okhttp3.WebSocket#close(int, String)} */ boolean close(int code, String reason); - + + /** + * 设置消息类型 + * @param type 消息类型，如 json、xml、protobuf 等 + */ + void msgType(String type); + } diff --git a/okhttps/src/main/java/com/ejlchina/okhttps/internal/WebSocketTask.java b/okhttps/src/main/java/com/ejlchina/okhttps/internal/WebSocketTask.java index 76930bf5..b2592cc0 100644 --- a/okhttps/src/main/java/com/ejlchina/okhttps/internal/WebSocketTask.java +++ b/okhttps/src/main/java/com/ejlchina/okhttps/internal/WebSocketTask.java @@ -40,7 +40,9 @@ public WebSocketTask(HttpClient httpClient, String url) { * @return WebSocket */ public WebSocket listen() { - WebSocketImpl socket = new WebSocketImpl(httpClient.executor, getBodyType()); + String bodyType = getBodyType(); + String msgType = bodyType.toLowerCase().contains("form") ? "json" : bodyType; + WebSocketImpl socket = new WebSocketImpl(httpClient.executor, msgType); registeTagTask(socket); httpClient.preprocess(this, () -> { synchronized (socket) { @@ -131,11 +133,11 @@ static class WebSocketImpl implements WebSocket { Charset charset; - String bodyType; + String msgType; - public WebSocketImpl(TaskExecutor taskExecutor, String bodyType) { + public WebSocketImpl(TaskExecutor taskExecutor, String msgType) { this.taskExecutor = taskExecutor; - this.bodyType = bodyType; + this.msgType = msgType; } public void setCharset(Charset charset) { @@ -159,7 +161,12 @@ public synchronized boolean close(int code, String reason) { cancelOrClosed = true; return true; } - + + @Override + public void msgType(String type) { + this.msgType = type; + } + @Override public long queueSize() { if (webSocket != null) { @@ -206,7 +213,7 @@ boolean send(okhttp3.WebSocket webSocket, Object msg) { if (msg instanceof byte[]) { return webSocket.send(ByteString.of((byte[]) msg)); } - byte[] bytes = taskExecutor.doMsgConvert(bodyType, (MsgConvertor c) -> c.serialize(msg, charset)).data; + byte[] bytes = taskExecutor.doMsgConvert(msgType, (MsgConvertor c) -> c.serialize(msg, charset)).data; return webSocket.send(new String(bytes, charset)); } From 8f23d237a9c03a55fec0bd211116b80fcc007841 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?=E5=91=A8=E6=97=AD?= Date: Tue, 12 May 2020 12:01:47 +0800 Subject: [PATCH 271/924] =?UTF-8?q?=E6=8A=BD=E8=B1=A1=20Toable=20=E6=8E=A5?= =?UTF-8?q?=E5=8F=A3?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- .../java/com/ejlchina/okhttps/HttpResult.java | 54 +--------------- .../java/com/ejlchina/okhttps/Toable.java | 60 ++++++++++++++++++ .../java/com/ejlchina/okhttps/WebSocket.java | 61 ++----------------- .../okhttps/internal/AbstractBody.java | 14 ++--- .../okhttps/internal/WebSocketTask.java | 4 +- .../{MessageBody.java => WebsocketMsg.java} | 6 +- 6 files changed, 76 insertions(+), 123 deletions(-) create mode 100644 okhttps/src/main/java/com/ejlchina/okhttps/Toable.java rename okhttps/src/main/java/com/ejlchina/okhttps/internal/{MessageBody.java => WebsocketMsg.java} (87%) diff --git a/okhttps/src/main/java/com/ejlchina/okhttps/HttpResult.java b/okhttps/src/main/java/com/ejlchina/okhttps/HttpResult.java index 0e331db2..d6c31dec 100644 --- a/okhttps/src/main/java/com/ejlchina/okhttps/HttpResult.java +++ b/okhttps/src/main/java/com/ejlchina/okhttps/HttpResult.java @@ -76,7 +76,7 @@ enum State { /** * HTTP响应报文体 */ - interface Body { + interface Body extends Toable { /** * @return 媒体类型 @@ -122,59 +122,7 @@ interface Body { * @return Body */ Body setRangeIgnored(); - - /** - * 同一个 Body 对象的 toXXX 类方法只可使用一个并且只能调用一次 - * @return 报文体转字节流 - */ - InputStream toByteStream(); - - /** - * 同一个 Body 对象的 toXXX 类方法只可使用一个并且只能调用一次 - * @return 报文体转字节数组 - */ - byte[] toBytes(); - - /** - * 同一个 Body 对象的 toXXX 类方法只可使用一个并且只能调用一次 - * @return 报文体转字符流 - */ - Reader toCharStream(); - - /** - * 同一个 Body 对象的 toXXX 类方法只可使用一个并且只能调用一次 - * @return 报文体转字符串 - */ - String toString(); - /** - * 同一个 Body 对象的 toXXX 类方法只可使用一个并且只能调用一次 - * @return 报文体转Json对象 - */ - Mapper toMapper(); - - /** - * 同一个 Body 对象的 toXXX 类方法只可使用一个并且只能调用一次 - * @return 报文体转Json数组 - */ - Array toArray(); - - /** - * 同一个 Body 对象的 toXXX 类方法只可使用一个并且只能调用一次 - * @param 目标泛型 - * @param type 目标类型 - * @return 报文体Json文本转JavaBean - */ - T toBean(Class type); - - /** - * 同一个 Body 对象的 toXXX 类方法只可使用一个并且只能调用一次 - * @param 目标泛型 - * @param type 目标类型 - * @return 报文体Json文本转JavaBean列表 - */ - List toList(Class type); - /** * 下载到指定路径 * 同一个 Body 对象的 toXXX 类方法只可使用一个并且只能调用一次 diff --git a/okhttps/src/main/java/com/ejlchina/okhttps/Toable.java b/okhttps/src/main/java/com/ejlchina/okhttps/Toable.java new file mode 100644 index 00000000..ef8cff4d --- /dev/null +++ b/okhttps/src/main/java/com/ejlchina/okhttps/Toable.java @@ -0,0 +1,60 @@ +package com.ejlchina.okhttps; + +import okio.ByteString; + +import java.io.InputStream; +import java.io.Reader; +import java.util.List; + +public interface Toable { + + /** + * @return 消息体转字节流 + */ + InputStream toByteStream(); + + /** + * @return 消息体转字节数组 + */ + byte[] toBytes(); + + /** + * @return ByteString + */ + ByteString toByteString(); + + /** + * @return 消息体转字符流 + */ + Reader toCharStream(); + + /** + * @return 消息体转字符串 + */ + String toString(); + + /** + * @return 消息体转Json对象 + */ + Mapper toMapper(); + + /** + * @return 消息体转Json数组 + */ + Array toArray(); + + /** + * @param 目标泛型 + * @param type 目标类型 + * @return 报文体Json文本转JavaBean + */ + T toBean(Class type); + + /** + * @param 目标泛型 + * @param type 目标类型 + * @return 报文体Json文本转JavaBean列表 + */ + List toList(Class type); + +} diff --git a/okhttps/src/main/java/com/ejlchina/okhttps/WebSocket.java b/okhttps/src/main/java/com/ejlchina/okhttps/WebSocket.java index 1e30a087..5c943f53 100644 --- a/okhttps/src/main/java/com/ejlchina/okhttps/WebSocket.java +++ b/okhttps/src/main/java/com/ejlchina/okhttps/WebSocket.java @@ -1,71 +1,18 @@ package com.ejlchina.okhttps; -import java.io.InputStream; -import java.io.Reader; -import java.util.List; - -import okio.ByteString; - public interface WebSocket extends Cancelable { - - interface Message { + /** + * WebSocket 消息 + */ + interface Message extends Toable { /** * 判断是文本消息还是二进制消息 * @return 是否是文本消息 */ boolean isText(); - - /** - * @return 消息体转字节流 - */ - InputStream toByteStream(); - - /** - * @return 消息体转字节数组 - */ - byte[] toBytes(); - - /** - * @return ByteString - */ - ByteString toByteString(); - - /** - * @return 消息体转字符流 - */ - Reader toCharStream(); - - /** - * @return 消息体转字符串 - */ - String toString(); - - /** - * @return 消息体转Json对象 - */ - Mapper toMapper(); - - /** - * @return 消息体转Json数组 - */ - Array toArray(); - - /** - * @param 目标泛型 - * @param type 目标类型 - * @return 报文体Json文本转JavaBean - */ - T toBean(Class type); - /** - * @param 目标泛型 - * @param type 目标类型 - * @return 报文体Json文本转JavaBean列表 - */ - List toList(Class type); - } diff --git a/okhttps/src/main/java/com/ejlchina/okhttps/internal/AbstractBody.java b/okhttps/src/main/java/com/ejlchina/okhttps/internal/AbstractBody.java index 8b73ff7c..507ee093 100644 --- a/okhttps/src/main/java/com/ejlchina/okhttps/internal/AbstractBody.java +++ b/okhttps/src/main/java/com/ejlchina/okhttps/internal/AbstractBody.java @@ -1,14 +1,14 @@ package com.ejlchina.okhttps.internal; -import java.io.InputStream; import java.nio.charset.Charset; import java.util.List; import com.ejlchina.okhttps.Array; import com.ejlchina.okhttps.Mapper; import com.ejlchina.okhttps.MsgConvertor; +import com.ejlchina.okhttps.Toable; -public abstract class AbstractBody { +public abstract class AbstractBody implements Toable { protected TaskExecutor taskExecutor; protected Charset charset; @@ -18,9 +18,7 @@ public AbstractBody(TaskExecutor taskExecutor, Charset charset) { this.charset = charset; } - public abstract InputStream toByteStream(); - - + @Override public Mapper toMapper() { if (taskExecutor == null) { throw new IllegalStateException("没有 taskExecutor，不可做 Mapper 转换！"); @@ -28,7 +26,7 @@ public Mapper toMapper() { return taskExecutor.doMsgConvert((MsgConvertor c) -> c.toMapper(toByteStream(), charset)); } - + @Override public Array toArray() { if (taskExecutor == null) { throw new IllegalStateException("没有 taskExecutor，不可做 Array 转换！"); @@ -36,15 +34,15 @@ public Array toArray() { return taskExecutor.doMsgConvert((MsgConvertor c) -> c.toArray(toByteStream(), charset)); } - + @Override public T toBean(Class type) { if (taskExecutor == null) { throw new IllegalStateException("没有 taskExecutor，不可做 Bean 转换！"); } return taskExecutor.doMsgConvert((MsgConvertor c) -> c.toBean(type, toByteStream(), charset)); } - + @Override public List toList(Class type) { if (taskExecutor == null) { throw new IllegalStateException("没有 taskExecutor，不可做 List 转换！"); diff --git a/okhttps/src/main/java/com/ejlchina/okhttps/internal/WebSocketTask.java b/okhttps/src/main/java/com/ejlchina/okhttps/internal/WebSocketTask.java index b2592cc0..0f4884f1 100644 --- a/okhttps/src/main/java/com/ejlchina/okhttps/internal/WebSocketTask.java +++ b/okhttps/src/main/java/com/ejlchina/okhttps/internal/WebSocketTask.java @@ -83,7 +83,7 @@ public void onOpen(okhttp3.WebSocket webSocket, Response response) { @Override public void onMessage(okhttp3.WebSocket webSocket, String text) { if (onMessage != null) { - onMessage.on(this.webSocket, new MessageBody(text, httpClient.executor, charset)); + onMessage.on(this.webSocket, new WebsocketMsg(text, httpClient.executor, charset)); } } @@ -91,7 +91,7 @@ public void onMessage(okhttp3.WebSocket webSocket, String text) { @Override public void onMessage(okhttp3.WebSocket webSocket, ByteString bytes) { if (onMessage != null) { - onMessage.on(this.webSocket, new MessageBody(bytes, httpClient.executor, charset)); + onMessage.on(this.webSocket, new WebsocketMsg(bytes, httpClient.executor, charset)); } } diff --git a/okhttps/src/main/java/com/ejlchina/okhttps/internal/MessageBody.java b/okhttps/src/main/java/com/ejlchina/okhttps/internal/WebsocketMsg.java similarity index 87% rename from okhttps/src/main/java/com/ejlchina/okhttps/internal/MessageBody.java rename to okhttps/src/main/java/com/ejlchina/okhttps/internal/WebsocketMsg.java index f8ae709d..f0569061 100644 --- a/okhttps/src/main/java/com/ejlchina/okhttps/internal/MessageBody.java +++ b/okhttps/src/main/java/com/ejlchina/okhttps/internal/WebsocketMsg.java @@ -13,18 +13,18 @@ import okio.ByteString; -public class MessageBody extends AbstractBody implements Message { +public class WebsocketMsg extends AbstractBody implements Message { private String text; private ByteString bytes; - public MessageBody(String text, TaskExecutor taskExecutor, Charset charset) { + public WebsocketMsg(String text, TaskExecutor taskExecutor, Charset charset) { super(taskExecutor, charset); this.text = text; } - public MessageBody(ByteString bytes, TaskExecutor taskExecutor, Charset charset) { + public WebsocketMsg(ByteString bytes, TaskExecutor taskExecutor, Charset charset) { super(taskExecutor, charset); this.bytes = bytes; } From 6bfa5c590eade44992800a4f61980625848d48d6 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?=E5=91=A8=E6=97=AD?= Date: Tue, 12 May 2020 12:14:54 +0800 Subject: [PATCH 272/924] =?UTF-8?q?=E7=AE=80=E5=8C=96=20Mapper=20=E5=92=8C?= =?UTF-8?q?=20Array=20=E6=8E=A5=E5=8F=A3?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- .../com/ejlchina/okhttps/FastjsonArray.java | 13 --------- .../com/ejlchina/okhttps/FastjsonMapper.java | 16 ++--------- .../java/com/ejlchina/okhttps/GsonArray.java | 21 -------------- .../java/com/ejlchina/okhttps/GsonMapper.java | 24 ++-------------- .../com/ejlchina/okhttps/JacksonArray.java | 21 -------------- .../com/ejlchina/okhttps/JacksonMapper.java | 28 +++---------------- .../main/java/com/ejlchina/okhttps/Array.java | 20 ++++--------- .../java/com/ejlchina/okhttps/Mapper.java | 21 +++----------- .../java/com/ejlchina/okhttps/OkHttps.java | 6 ++-- 9 files changed, 19 insertions(+), 151 deletions(-) diff --git a/okhttps-fastjson/src/main/java/com/ejlchina/okhttps/FastjsonArray.java b/okhttps-fastjson/src/main/java/com/ejlchina/okhttps/FastjsonArray.java index 3bcdff89..0755c484 100644 --- a/okhttps-fastjson/src/main/java/com/ejlchina/okhttps/FastjsonArray.java +++ b/okhttps-fastjson/src/main/java/com/ejlchina/okhttps/FastjsonArray.java @@ -1,8 +1,5 @@ package com.ejlchina.okhttps; -import java.math.BigDecimal; -import java.math.BigInteger; - import com.alibaba.fastjson.JSONArray; import com.alibaba.fastjson.JSONObject; @@ -72,16 +69,6 @@ public String getString(int index) { return json.getString(index); } - @Override - public BigDecimal getBigDecimal(int index) { - return json.getBigDecimal(index); - } - - @Override - public BigInteger getBigInteger(int index) { - return json.getBigInteger(index); - } - @Override public String toString() { return json.toJSONString(); diff --git a/okhttps-fastjson/src/main/java/com/ejlchina/okhttps/FastjsonMapper.java b/okhttps-fastjson/src/main/java/com/ejlchina/okhttps/FastjsonMapper.java index c7c16ee6..7e5aa6d4 100644 --- a/okhttps-fastjson/src/main/java/com/ejlchina/okhttps/FastjsonMapper.java +++ b/okhttps-fastjson/src/main/java/com/ejlchina/okhttps/FastjsonMapper.java @@ -1,12 +1,10 @@ package com.ejlchina.okhttps; -import java.math.BigDecimal; -import java.math.BigInteger; -import java.util.Set; - import com.alibaba.fastjson.JSONArray; import com.alibaba.fastjson.JSONObject; +import java.util.Set; + public class FastjsonMapper implements Mapper { private JSONObject json; @@ -73,16 +71,6 @@ public String getString(String key) { return json.getString(key); } - @Override - public BigDecimal getBigDecimal(String key) { - return json.getBigDecimal(key); - } - - @Override - public BigInteger getBigInteger(String key) { - return json.getBigInteger(key); - } - @Override public boolean has(String key) { return json.containsKey(key); diff --git a/okhttps-gson/src/main/java/com/ejlchina/okhttps/GsonArray.java b/okhttps-gson/src/main/java/com/ejlchina/okhttps/GsonArray.java index 3208b56a..99795e4b 100644 --- a/okhttps-gson/src/main/java/com/ejlchina/okhttps/GsonArray.java +++ b/okhttps-gson/src/main/java/com/ejlchina/okhttps/GsonArray.java @@ -1,8 +1,5 @@ package com.ejlchina.okhttps; -import java.math.BigDecimal; -import java.math.BigInteger; - import com.google.gson.JsonArray; import com.google.gson.JsonElement; @@ -96,24 +93,6 @@ public String getString(int index) { return null; } - @Override - public BigDecimal getBigDecimal(int index) { - JsonElement val = json.get(index); - if (val != null) { - return val.getAsBigDecimal(); - } - return null; - } - - @Override - public BigInteger getBigInteger(int index) { - JsonElement val = json.get(index); - if (val != null) { - return val.getAsBigInteger(); - } - return null; - } - @Override public String toString() { return json.toString(); diff --git a/okhttps-gson/src/main/java/com/ejlchina/okhttps/GsonMapper.java b/okhttps-gson/src/main/java/com/ejlchina/okhttps/GsonMapper.java index 2b52c9f4..90ea3f90 100644 --- a/okhttps-gson/src/main/java/com/ejlchina/okhttps/GsonMapper.java +++ b/okhttps-gson/src/main/java/com/ejlchina/okhttps/GsonMapper.java @@ -1,12 +1,10 @@ package com.ejlchina.okhttps; -import java.math.BigDecimal; -import java.math.BigInteger; -import java.util.Set; - import com.google.gson.JsonElement; import com.google.gson.JsonObject; +import java.util.Set; + public class GsonMapper implements Mapper { private JsonObject json; @@ -97,24 +95,6 @@ public String getString(String key) { return null; } - @Override - public BigDecimal getBigDecimal(String key) { - JsonElement val = json.get(key); - if (val != null) { - return val.getAsBigDecimal(); - } - return null; - } - - @Override - public BigInteger getBigInteger(String key) { - JsonElement val = json.get(key); - if (val != null) { - return val.getAsBigInteger(); - } - return null; - } - @Override public boolean has(String key) { return json.has(key); diff --git a/okhttps-jackson/src/main/java/com/ejlchina/okhttps/JacksonArray.java b/okhttps-jackson/src/main/java/com/ejlchina/okhttps/JacksonArray.java index a0c5e69e..95559db5 100644 --- a/okhttps-jackson/src/main/java/com/ejlchina/okhttps/JacksonArray.java +++ b/okhttps-jackson/src/main/java/com/ejlchina/okhttps/JacksonArray.java @@ -1,8 +1,5 @@ package com.ejlchina.okhttps; -import java.math.BigDecimal; -import java.math.BigInteger; - import com.fasterxml.jackson.databind.JsonNode; import com.fasterxml.jackson.databind.node.ArrayNode; import com.fasterxml.jackson.databind.node.ObjectNode; @@ -97,24 +94,6 @@ public String getString(int index) { return null; } - @Override - public BigDecimal getBigDecimal(int index) { - JsonNode subJson = json.get(index); - if (subJson != null && subJson.isNumber()) { - return subJson.decimalValue(); - } - return null; - } - - @Override - public BigInteger getBigInteger(int index) { - JsonNode subJson = json.get(index); - if (subJson != null && subJson.isNumber()) { - return subJson.bigIntegerValue(); - } - return null; - } - @Override public String toString() { return json.toString(); diff --git a/okhttps-jackson/src/main/java/com/ejlchina/okhttps/JacksonMapper.java b/okhttps-jackson/src/main/java/com/ejlchina/okhttps/JacksonMapper.java index 9e81fa4d..49bad435 100644 --- a/okhttps-jackson/src/main/java/com/ejlchina/okhttps/JacksonMapper.java +++ b/okhttps-jackson/src/main/java/com/ejlchina/okhttps/JacksonMapper.java @@ -1,15 +1,13 @@ package com.ejlchina.okhttps; -import java.math.BigDecimal; -import java.math.BigInteger; -import java.util.HashSet; -import java.util.Iterator; -import java.util.Set; - import com.fasterxml.jackson.databind.JsonNode; import com.fasterxml.jackson.databind.node.ArrayNode; import com.fasterxml.jackson.databind.node.ObjectNode; +import java.util.HashSet; +import java.util.Iterator; +import java.util.Set; + public class JacksonMapper implements Mapper { private ObjectNode json; @@ -100,24 +98,6 @@ public String getString(String key) { return null; } - @Override - public BigDecimal getBigDecimal(String key) { - JsonNode subJson = json.get(key); - if (subJson != null && subJson.isNumber()) { - return subJson.decimalValue(); - } - return null; - } - - @Override - public BigInteger getBigInteger(String key) { - JsonNode subJson = json.get(key); - if (subJson != null && subJson.isNumber()) { - return subJson.bigIntegerValue(); - } - return null; - } - @Override public boolean has(String key) { return json.has(key); diff --git a/okhttps/src/main/java/com/ejlchina/okhttps/Array.java b/okhttps/src/main/java/com/ejlchina/okhttps/Array.java index ce34e899..99b897c2 100644 --- a/okhttps/src/main/java/com/ejlchina/okhttps/Array.java +++ b/okhttps/src/main/java/com/ejlchina/okhttps/Array.java @@ -1,8 +1,10 @@ package com.ejlchina.okhttps; -import java.math.BigDecimal; -import java.math.BigInteger; - +/** + * @since 2.0.0 + * Array 接口 类似于 JsonArray + * 但为什么不取名为 json 呢，因它不止是 json，它还可以是 xml、yml、protobuf 等任何一种格式的数据 + */ public interface Array { /** @@ -62,17 +64,5 @@ public interface Array { * @return String 值 */ String getString(int index); - - /** - * @param index 元素下标 - * @return BigDecimal 值 - */ - BigDecimal getBigDecimal(int index); - - /** - * @param index 元素下标 - * @return BigInteger 值 - */ - BigInteger getBigInteger(int index); } diff --git a/okhttps/src/main/java/com/ejlchina/okhttps/Mapper.java b/okhttps/src/main/java/com/ejlchina/okhttps/Mapper.java index e5f9ec80..e99ab8cc 100644 --- a/okhttps/src/main/java/com/ejlchina/okhttps/Mapper.java +++ b/okhttps/src/main/java/com/ejlchina/okhttps/Mapper.java @@ -1,13 +1,12 @@ package com.ejlchina.okhttps; -import java.math.BigDecimal; -import java.math.BigInteger; import java.util.Set; /** - * JSON 对象 + * @since 2.0.0 + * Mapper 接口，类似于 json + * 但为什么不取名为 json 呢，因它不止是 json，它还可以是 xml、yml、protobuf 等任何一种格式的数据 * @author 15735 - * */ public interface Mapper { @@ -68,19 +67,7 @@ public interface Mapper { * @return String 值 */ String getString(String key); - - /** - * @param key 键名 - * @return BigDecimal 值 - */ - BigDecimal getBigDecimal(String key); - - /** - * @param key 键名 - * @return BigInteger 值 - */ - BigInteger getBigInteger(String key); - + /** * @param key 键名 * @return 是否有该键 diff --git a/okhttps/src/main/java/com/ejlchina/okhttps/OkHttps.java b/okhttps/src/main/java/com/ejlchina/okhttps/OkHttps.java index c52d77e8..7a2c0cf1 100644 --- a/okhttps/src/main/java/com/ejlchina/okhttps/OkHttps.java +++ b/okhttps/src/main/java/com/ejlchina/okhttps/OkHttps.java @@ -12,11 +12,10 @@ */ public final class OkHttps { - private OkHttps() {} - - private static HTTP http; + private OkHttps() {} + static synchronized HTTP getHttp() { if (http != null) { return http; @@ -28,7 +27,6 @@ static synchronized HTTP getHttp() { return http; } - /** * 异步请求 * @param url 请求地址 From bf2c95eee1aa752dcb0de77ef6fd2df8260f493e Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?=E5=91=A8=E6=97=AD?= Date: Tue, 12 May 2020 12:36:38 +0800 Subject: [PATCH 273/924] =?UTF-8?q?ResultBody=20=E5=AE=9E=E7=8E=B0=20toByt?= =?UTF-8?q?eString=20=E6=96=B9=E6=B3=95?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- .../java/com/ejlchina/okhttps/internal/ResultBody.java | 10 ++++++++-- 1 file changed, 8 insertions(+), 2 deletions(-) diff --git a/okhttps/src/main/java/com/ejlchina/okhttps/internal/ResultBody.java b/okhttps/src/main/java/com/ejlchina/okhttps/internal/ResultBody.java index dddb0f59..b65382f7 100644 --- a/okhttps/src/main/java/com/ejlchina/okhttps/internal/ResultBody.java +++ b/okhttps/src/main/java/com/ejlchina/okhttps/internal/ResultBody.java @@ -14,6 +14,7 @@ import okhttp3.Response; import okhttp3.ResponseBody; import okio.Buffer; +import okio.ByteString; public class ResultBody extends AbstractBody implements Body { @@ -99,7 +100,7 @@ public InputStream toByteStream() { if (body != null) { input = body.byteStream(); } else { - input = new ByteArrayInputStream(new byte[]{}); + input = new ByteArrayInputStream(new byte[0]); } } if (onProcess != null) { @@ -156,6 +157,11 @@ public String toString() { return null; } + @Override + public ByteString toByteString() { + return ByteString.of(toBytes()); + } + @Override public Download toFile(String filePath) { return toFile(new File(filePath)); @@ -250,7 +256,7 @@ private byte[] bodyToBytes() { throw new HttpException("报文体转化字节数组出错", e); } } - return new byte[]{}; + return new byte[0]; } private long getRangeStart() { From 18a5ccbe6f6343b94ce8cd481a39c30589bbc430 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?=E5=91=A8=E6=97=AD?= Date: Tue, 12 May 2020 13:59:04 +0800 Subject: [PATCH 274/924] =?UTF-8?q?=E4=BC=98=E5=8C=96?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- okhttps/src/main/java/com/ejlchina/okhttps/HTTP.java | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/okhttps/src/main/java/com/ejlchina/okhttps/HTTP.java b/okhttps/src/main/java/com/ejlchina/okhttps/HTTP.java index 73194ba9..36b30d85 100644 --- a/okhttps/src/main/java/com/ejlchina/okhttps/HTTP.java +++ b/okhttps/src/main/java/com/ejlchina/okhttps/HTTP.java @@ -335,7 +335,7 @@ public Builder addMsgConvertor(MsgConvertor msgConvertor) { * @param charset 编码 * @return Builder */ - public Builder defaultCharset(Charset charset) { + public Builder charset(Charset charset) { if (charset != null) { this.charset = charset; } @@ -348,7 +348,7 @@ public Builder defaultCharset(Charset charset) { * @param bodyType 请求体类型 * @return Builder */ - public Builder defaultBodyType(String bodyType) { + public Builder bodyType(String bodyType) { if (bodyType != null) { this.bodyType = bodyType; } From fe2ef94aa36afadb433f5e33d04206369877008c Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?=E5=91=A8=E6=97=AD?= Date: Tue, 12 May 2020 14:13:28 +0800 Subject: [PATCH 275/924] =?UTF-8?q?=E4=BC=98=E5=8C=96?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- .../main/java/com/ejlchina/okhttps/HTTP.java | 2 +- .../java/com/ejlchina/okhttps/HttpTask.java | 12 ++++----- .../java/com/ejlchina/okhttps/OkHttps.java | 5 ++++ .../okhttps/internal/WebSocketTask.java | 26 +++++++------------ 4 files changed, 22 insertions(+), 23 deletions(-) diff --git a/okhttps/src/main/java/com/ejlchina/okhttps/HTTP.java b/okhttps/src/main/java/com/ejlchina/okhttps/HTTP.java index 36b30d85..f21a3d84 100644 --- a/okhttps/src/main/java/com/ejlchina/okhttps/HTTP.java +++ b/okhttps/src/main/java/com/ejlchina/okhttps/HTTP.java @@ -133,7 +133,7 @@ class Builder { private Charset charset = StandardCharsets.UTF_8; - private String bodyType = "json"; + private String bodyType = OkHttps.FORM; public Builder() { mediaTypes = new HashMap<>(); diff --git a/okhttps/src/main/java/com/ejlchina/okhttps/HttpTask.java b/okhttps/src/main/java/com/ejlchina/okhttps/HttpTask.java index 627044f3..a93376e0 100644 --- a/okhttps/src/main/java/com/ejlchina/okhttps/HttpTask.java +++ b/okhttps/src/main/java/com/ejlchina/okhttps/HttpTask.java @@ -433,7 +433,7 @@ private void doAddParams(Map taskParams, Map params) */ @Deprecated public C addJsonParam(String name, Object value) { - this.bodyType = "json"; + this.bodyType = OkHttps.JSON; return addBodyPara(name, value); } @@ -446,7 +446,7 @@ public C addJsonParam(String name, Object value) { */ @Deprecated public C addJsonParam(Map params) { - this.bodyType = "json"; + this.bodyType = OkHttps.JSON; return addBodyPara(params); } @@ -458,7 +458,7 @@ public C addJsonParam(Map params) { **/ @Deprecated public C setRequestJson(Object body) { - this.bodyType = "json"; + this.bodyType = OkHttps.JSON; return setBodyPara(body); } @@ -471,7 +471,7 @@ public C setRequestJson(Object body) { */ @Deprecated public C setRequestJson(Object body, String dateFormat) { - this.bodyType = "json"; + this.bodyType = OkHttps.JSON; this.dateFormat = dateFormat; return setBodyPara(body); } @@ -762,7 +762,7 @@ private RequestBody buildRequestBody() { if (bodyParams == null) { return new FormBody.Builder(charset).build(); } - if (bodyType.toLowerCase().contains("form")) { + if (bodyType.toLowerCase().contains(OkHttps.FORM)) { FormBody.Builder builder = new FormBody.Builder(charset); for (String name : bodyParams.keySet()) { String value = bodyParams.get(name); @@ -849,7 +849,7 @@ protected void assertNotConflict(boolean isGetRequest) { throw new HttpException("方法 addFilePara 与 setBodyPara 不能同时调用！"); } } - if (files != null && "form".equals(bodyType)) { + if (files != null && OkHttps.FORM.equals(bodyType)) { throw new HttpException("方法 addFilePara 只能使用 form 方式请求！"); } } diff --git a/okhttps/src/main/java/com/ejlchina/okhttps/OkHttps.java b/okhttps/src/main/java/com/ejlchina/okhttps/OkHttps.java index 7a2c0cf1..2e4d705a 100644 --- a/okhttps/src/main/java/com/ejlchina/okhttps/OkHttps.java +++ b/okhttps/src/main/java/com/ejlchina/okhttps/OkHttps.java @@ -12,6 +12,11 @@ */ public final class OkHttps { + public static final String FORM = "form"; + public static final String JSON = "json"; + public static final String XML = "xml"; + public static final String PROTOBUF = "protobuf"; + private static HTTP http; private OkHttps() {} diff --git a/okhttps/src/main/java/com/ejlchina/okhttps/internal/WebSocketTask.java b/okhttps/src/main/java/com/ejlchina/okhttps/internal/WebSocketTask.java index 0f4884f1..4711b6a9 100644 --- a/okhttps/src/main/java/com/ejlchina/okhttps/internal/WebSocketTask.java +++ b/okhttps/src/main/java/com/ejlchina/okhttps/internal/WebSocketTask.java @@ -4,10 +4,7 @@ import java.util.ArrayList; import java.util.List; -import com.ejlchina.okhttps.HttpResult; -import com.ejlchina.okhttps.HttpTask; -import com.ejlchina.okhttps.MsgConvertor; -import com.ejlchina.okhttps.WebSocket; +import com.ejlchina.okhttps.*; import com.ejlchina.okhttps.WebSocket.Close; import com.ejlchina.okhttps.WebSocket.Listener; import com.ejlchina.okhttps.WebSocket.Message; @@ -30,9 +27,6 @@ public class WebSocketTask extends HttpTask { public WebSocketTask(HttpClient httpClient, String url) { super(httpClient, url); - if (getBodyType().toLowerCase().contains("form")) { - bodyType("json"); - } } /** @@ -41,7 +35,7 @@ public WebSocketTask(HttpClient httpClient, String url) { */ public WebSocket listen() { String bodyType = getBodyType(); - String msgType = bodyType.toLowerCase().contains("form") ? "json" : bodyType; + String msgType = bodyType.toLowerCase().contains(OkHttps.FORM) ? OkHttps.JSON : bodyType; WebSocketImpl socket = new WebSocketImpl(httpClient.executor, msgType); registeTagTask(socket); httpClient.preprocess(this, () -> { @@ -123,17 +117,17 @@ public void onFailure(okhttp3.WebSocket webSocket, Throwable t, Response respons static class WebSocketImpl implements WebSocket { - boolean cancelOrClosed; + private boolean cancelOrClosed; - okhttp3.WebSocket webSocket; - - final List queues = new ArrayList<>(); - - TaskExecutor taskExecutor; + private okhttp3.WebSocket webSocket; - Charset charset; + private final List queues = new ArrayList<>(); + + private TaskExecutor taskExecutor; + + private Charset charset; - String msgType; + private String msgType; public WebSocketImpl(TaskExecutor taskExecutor, String msgType) { this.taskExecutor = taskExecutor; From 6f3d691ba3ac031ecabfd1780654c9a06a907da6 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?=E5=91=A8=E6=97=AD?= Date: Tue, 12 May 2020 14:31:42 +0800 Subject: [PATCH 276/924] =?UTF-8?q?=E5=8F=82=E6=95=B0=E9=AA=8C=E8=AF=81?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- .../main/java/com/ejlchina/okhttps/internal/WebSocketTask.java | 3 +++ 1 file changed, 3 insertions(+) diff --git a/okhttps/src/main/java/com/ejlchina/okhttps/internal/WebSocketTask.java b/okhttps/src/main/java/com/ejlchina/okhttps/internal/WebSocketTask.java index 4711b6a9..8fa5e5dc 100644 --- a/okhttps/src/main/java/com/ejlchina/okhttps/internal/WebSocketTask.java +++ b/okhttps/src/main/java/com/ejlchina/okhttps/internal/WebSocketTask.java @@ -158,6 +158,9 @@ public synchronized boolean close(int code, String reason) { @Override public void msgType(String type) { + if (type == null || type.equalsIgnoreCase(OkHttps.FORM)) { + throw new IllegalArgumentException("msgType 不可为空 或 form"); + } this.msgType = type; } From 56d70587ff508b14606485154a34f9d185cdf711 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?=E5=91=A8=E6=97=AD?= Date: Tue, 12 May 2020 14:34:43 +0800 Subject: [PATCH 277/924] =?UTF-8?q?=E4=BC=98=E5=8C=96?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- okhttps/src/main/java/com/ejlchina/okhttps/HttpTask.java | 2 +- .../main/java/com/ejlchina/okhttps/internal/WebSocketTask.java | 2 +- 2 files changed, 2 insertions(+), 2 deletions(-) diff --git a/okhttps/src/main/java/com/ejlchina/okhttps/HttpTask.java b/okhttps/src/main/java/com/ejlchina/okhttps/HttpTask.java index a93376e0..0ae3aa00 100644 --- a/okhttps/src/main/java/com/ejlchina/okhttps/HttpTask.java +++ b/okhttps/src/main/java/com/ejlchina/okhttps/HttpTask.java @@ -762,7 +762,7 @@ private RequestBody buildRequestBody() { if (bodyParams == null) { return new FormBody.Builder(charset).build(); } - if (bodyType.toLowerCase().contains(OkHttps.FORM)) { + if (OkHttps.FORM.equalsIgnoreCase(bodyType)) { FormBody.Builder builder = new FormBody.Builder(charset); for (String name : bodyParams.keySet()) { String value = bodyParams.get(name); diff --git a/okhttps/src/main/java/com/ejlchina/okhttps/internal/WebSocketTask.java b/okhttps/src/main/java/com/ejlchina/okhttps/internal/WebSocketTask.java index 8fa5e5dc..a7f71407 100644 --- a/okhttps/src/main/java/com/ejlchina/okhttps/internal/WebSocketTask.java +++ b/okhttps/src/main/java/com/ejlchina/okhttps/internal/WebSocketTask.java @@ -35,7 +35,7 @@ public WebSocketTask(HttpClient httpClient, String url) { */ public WebSocket listen() { String bodyType = getBodyType(); - String msgType = bodyType.toLowerCase().contains(OkHttps.FORM) ? OkHttps.JSON : bodyType; + String msgType = OkHttps.FORM.equalsIgnoreCase(bodyType) ? OkHttps.JSON : bodyType; WebSocketImpl socket = new WebSocketImpl(httpClient.executor, msgType); registeTagTask(socket); httpClient.preprocess(this, () -> { From 301745208cccf1117504306f6889e32871ac577f Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?=E5=91=A8=E6=97=AD?= Date: Tue, 12 May 2020 15:37:36 +0800 Subject: [PATCH 278/924] V2.0.0.RC --- okhttps-fastjson/pom.xml | 2 +- okhttps-gson/pom.xml | 2 +- okhttps-jackson/pom.xml | 2 +- okhttps-test/pom.xml | 12 +++++++++++- okhttps/pom.xml | 2 +- pom.xml | 4 ++-- 6 files changed, 17 insertions(+), 7 deletions(-) diff --git a/okhttps-fastjson/pom.xml b/okhttps-fastjson/pom.xml index 9c7a04ab..9fd65d29 100644 --- a/okhttps-fastjson/pom.xml +++ b/okhttps-fastjson/pom.xml @@ -8,7 +8,7 @@ com.ejlchina okhttps-parent - 2.0.0 + 2.0.0.RC diff --git a/okhttps-gson/pom.xml b/okhttps-gson/pom.xml index fdf36c1b..f7a13cd1 100644 --- a/okhttps-gson/pom.xml +++ b/okhttps-gson/pom.xml @@ -8,7 +8,7 @@ com.ejlchina okhttps-parent - 2.0.0 + 2.0.0.RC diff --git a/okhttps-jackson/pom.xml b/okhttps-jackson/pom.xml index e5a2e005..973c8d9e 100644 --- a/okhttps-jackson/pom.xml +++ b/okhttps-jackson/pom.xml @@ -8,7 +8,7 @@ com.ejlchina okhttps-parent - 2.0.0 + 2.0.0.RC diff --git a/okhttps-test/pom.xml b/okhttps-test/pom.xml index de096609..252a9e94 100644 --- a/okhttps-test/pom.xml +++ b/okhttps-test/pom.xml @@ -8,7 +8,7 @@ com.ejlchina okhttps-parent - 2.0.0 + 2.0.0.RC @@ -26,5 +26,15 @@ okhttps-test + + + org.apache.maven.plugins + maven-deploy-plugin + 2.8.2 + + true + + + \ No newline at end of file diff --git a/okhttps/pom.xml b/okhttps/pom.xml index ebffcd88..cdc49691 100644 --- a/okhttps/pom.xml +++ b/okhttps/pom.xml @@ -8,7 +8,7 @@ com.ejlchina okhttps-parent - 2.0.0 + 2.0.0.RC diff --git a/pom.xml b/pom.xml index fa6f9743..942a5544 100644 --- a/pom.xml +++ b/pom.xml @@ -3,7 +3,7 @@ com.ejlchina okhttps-parent - 2.0.0 + 2.0.0.RC OkHttps pom @@ -17,7 +17,7 @@ - 2.0.0 + 2.0.0.RC 1.8 3.14.7 2.8.6 From 7dc4d867e2ea84d193b4aaf9908674d181b5cf9f Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?=E5=91=A8=E6=97=AD?= Date: Tue, 12 May 2020 17:16:46 +0800 Subject: [PATCH 279/924] remove unused imports --- okhttps/src/main/java/com/ejlchina/okhttps/HttpResult.java | 2 -- 1 file changed, 2 deletions(-) diff --git a/okhttps/src/main/java/com/ejlchina/okhttps/HttpResult.java b/okhttps/src/main/java/com/ejlchina/okhttps/HttpResult.java index d6c31dec..001b3a73 100644 --- a/okhttps/src/main/java/com/ejlchina/okhttps/HttpResult.java +++ b/okhttps/src/main/java/com/ejlchina/okhttps/HttpResult.java @@ -2,8 +2,6 @@ import java.io.File; import java.io.IOException; -import java.io.InputStream; -import java.io.Reader; import java.util.List; import com.ejlchina.okhttps.internal.RealHttpResult; From df5d92d0ab612e8cacd7fcd9de63f7d62bba55ed Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?=E5=91=A8=E6=97=AD?= Date: Tue, 12 May 2020 18:56:16 +0800 Subject: [PATCH 280/924] =?UTF-8?q?=E6=B3=A8=E9=87=8A?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- okhttps/src/main/java/com/ejlchina/okhttps/Toable.java | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/okhttps/src/main/java/com/ejlchina/okhttps/Toable.java b/okhttps/src/main/java/com/ejlchina/okhttps/Toable.java index ef8cff4d..0f89c1af 100644 --- a/okhttps/src/main/java/com/ejlchina/okhttps/Toable.java +++ b/okhttps/src/main/java/com/ejlchina/okhttps/Toable.java @@ -34,12 +34,12 @@ public interface Toable { String toString(); /** - * @return 消息体转Json对象 + * @return 消息体转 Mapper 对象（不想定义 Java Bean 时使用） */ Mapper toMapper(); /** - * @return 消息体转Json数组 + * @return 消息体转 Array 数组（不想定义 Java Bean 时使用） */ Array toArray(); From cf2cbcb007ab887f0d7c472a7d02b37d86093e2d Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?=E5=91=A8=E6=97=AD?= <15735559897@qq.com> Date: Wed, 13 May 2020 00:30:39 +0800 Subject: [PATCH 281/924] =?UTF-8?q?=E6=96=87=E6=A1=A3?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- okhttps-doc/docs/.vuepress/config.js | 35 ++- okhttps-doc/docs/README.md | 4 +- okhttps-doc/docs/{guide => v1}/README.md | 2 +- okhttps-doc/docs/{guide => v1}/android.md | 0 .../docs/{guide => v1}/configuration.md | 0 okhttps-doc/docs/{guide => v1}/features.md | 0 okhttps-doc/docs/{guide => v1}/foundation.md | 10 +- okhttps-doc/docs/{guide => v1}/updown.md | 0 okhttps-doc/docs/v2/README.md | 103 ++++++++ okhttps-doc/docs/v2/android.md | 181 ++++++++++++++ okhttps-doc/docs/v2/configuration.md | 158 +++++++++++++ okhttps-doc/docs/v2/features.md | 170 +++++++++++++ okhttps-doc/docs/v2/foundation.md | 209 ++++++++++++++++ okhttps-doc/docs/v2/updown.md | 223 ++++++++++++++++++ 14 files changed, 1078 insertions(+), 17 deletions(-) rename okhttps-doc/docs/{guide => v1}/README.md (97%) rename okhttps-doc/docs/{guide => v1}/android.md (100%) rename okhttps-doc/docs/{guide => v1}/configuration.md (100%) rename okhttps-doc/docs/{guide => v1}/features.md (100%) rename okhttps-doc/docs/{guide => v1}/foundation.md (94%) rename okhttps-doc/docs/{guide => v1}/updown.md (100%) create mode 100644 okhttps-doc/docs/v2/README.md create mode 100644 okhttps-doc/docs/v2/android.md create mode 100644 okhttps-doc/docs/v2/configuration.md create mode 100644 okhttps-doc/docs/v2/features.md create mode 100644 okhttps-doc/docs/v2/foundation.md create mode 100644 okhttps-doc/docs/v2/updown.md diff --git a/okhttps-doc/docs/.vuepress/config.js b/okhttps-doc/docs/.vuepress/config.js index 3e22cadd..ca27057a 100644 --- a/okhttps-doc/docs/.vuepress/config.js +++ b/okhttps-doc/docs/.vuepress/config.js @@ -7,19 +7,36 @@ module.exports = { themeConfig: { logo: '/logo.png', nav: [ - { text: '教程', link: '/guide/' }, + { + text: '教程', + ariaLabel: '版本', + items: [ + { text: 'v1.x', link: '/v1/' }, + { text: 'v2.x', link: '/v2/' } + ] + }, { text: '历史版本', link: 'https://gitee.com/ejlchina-zhxu/okhttps/releases' }, { text: 'Grails 中文', link: 'http://grails.ejlchina.com' }, { text: '码云', link: 'https://gitee.com/ejlchina-zhxu/okhttps' } ], - sidebar: [ - ['/guide/', '起步'], - ['/guide/foundation', '基础'], - ['/guide/configuration', '配置'], - ['/guide/features', '特色'], - ['/guide/updown', '上传下载'], - ['/guide/android', '安卓'], - ], + sidebar: { + '/v1/': [ + '', + 'foundation', + 'configuration', + 'features', + 'updown', + 'android' + ], + '/v2/': [ + '', + 'foundation', + 'configuration', + 'features', + 'updown', + 'android' + ] + }, sidebarDepth: 2, smoothScroll: true, lastUpdated: '上次更新', diff --git a/okhttps-doc/docs/README.md b/okhttps-doc/docs/README.md index e7ab259a..c57380ab 100644 --- a/okhttps-doc/docs/README.md +++ b/okhttps-doc/docs/README.md @@ -4,7 +4,7 @@ heroImage: /logo.png heroText: OkHttps tagline: 基于 OkHttp 增强版 HTTP 客户端 actionText: 极速上手 → -actionLink: /guide/ +actionLink: /v2/ features: - title: 轻量纯粹优雅 details: OkHttps 非常轻量，体积仅是 Retrofit 的一半不到，并且不依赖于特定平台，API 语义简洁舒适。 @@ -68,4 +68,4 @@ http.async("/users/jack") // http://api.demo.com/users/jack --> **
竟然不到 15 秒，你已学会 90% 的精髓！
** -
[**了解更多**](/guide/)
\ No newline at end of file +
[**了解更多**](/v2/)
\ No newline at end of file diff --git a/okhttps-doc/docs/guide/README.md b/okhttps-doc/docs/v1/README.md similarity index 97% rename from okhttps-doc/docs/guide/README.md rename to okhttps-doc/docs/v1/README.md index ea0465f7..84a45c42 100644 --- a/okhttps-doc/docs/guide/README.md +++ b/okhttps-doc/docs/v1/README.md @@ -64,7 +64,7 @@ HTTP http = HTTP.builder().build(); * `request(Request request)` OkHttp 原生请求 * `webSocket(Request request, WebSocketListener listener)` WebSocket通讯 -　　为了使用方便，在构建的时候，我们更愿意指定一个`BaseUrl`（详见 [设置 BaseUrl](/guide/configuration.html#设置-baseurl)）: +　　为了使用方便，在构建的时候，我们更愿意指定一个`BaseUrl`（详见 [设置 BaseUrl](/v1/configuration.html#设置-baseurl)）: ```java HTTP http = HTTP.builder() diff --git a/okhttps-doc/docs/guide/android.md b/okhttps-doc/docs/v1/android.md similarity index 100% rename from okhttps-doc/docs/guide/android.md rename to okhttps-doc/docs/v1/android.md diff --git a/okhttps-doc/docs/guide/configuration.md b/okhttps-doc/docs/v1/configuration.md similarity index 100% rename from okhttps-doc/docs/guide/configuration.md rename to okhttps-doc/docs/v1/configuration.md diff --git a/okhttps-doc/docs/guide/features.md b/okhttps-doc/docs/v1/features.md similarity index 100% rename from okhttps-doc/docs/guide/features.md rename to okhttps-doc/docs/v1/features.md diff --git a/okhttps-doc/docs/guide/foundation.md b/okhttps-doc/docs/v1/foundation.md similarity index 94% rename from okhttps-doc/docs/guide/foundation.md rename to okhttps-doc/docs/v1/foundation.md index 4cccf799..e48cd8af 100644 --- a/okhttps-doc/docs/guide/foundation.md +++ b/okhttps-doc/docs/v1/foundation.md @@ -39,7 +39,7 @@ http.async("/users/{id}") // http://api.demo.com/users/1 .get(); ``` -　　OkHttps 同时还支持 **全局回调** 和 **回调阻断** 机制，详见 [全局回调监听](/guide/configuration.html#全局回调监听)。 +　　OkHttps 同时还支持 **全局回调** 和 **回调阻断** 机制，详见 [全局回调监听](/v1/configuration.html#全局回调监听)。 ::: tip * 只有异步请求才可以设置这三种（响应|异常|完成）回调 @@ -169,10 +169,10 @@ System.out.println(call.isCanceled()); // true * `addFileParam(String name, String type, String fileName, byte[] content)` 上传文件 * `setTag(String tag)` 为HTTP任务添加标签 -* `setRange(long rangeStart)` 设置Range头信息，用于[断点续传](/guide/updown.html#实现断点续传) -* `setRange(long rangeStart, long rangeEnd)` 设置Range头信息，可用于[分块下载](/guide/updown.html#实现分块下载) +* `setRange(long rangeStart)` 设置Range头信息，用于[断点续传](/v1/updown.html#实现断点续传) +* `setRange(long rangeStart, long rangeEnd)` 设置Range头信息，可用于[分块下载](/v1/updown.html#实现分块下载) -* `bind(Object object)` 绑定一个对象，可用于实现Android里的[生命周期绑定](/guide/android.html#生命周期绑定) +* `bind(Object object)` 绑定一个对象，可用于实现Android里的[生命周期绑定](/v1/android.html#生命周期绑定) ## 使用标签 @@ -206,4 +206,4 @@ http.async("/users") //（5） int count = http.cancel("B"); //（2）（3）（4）被取消（取消标签包含"B"的任务） System.out.println(count); // 输出 3 ``` -　　标签除了可以用来取消任务，在预处理器中它也可以发挥作用，请参见 [并行预处理器](/guide/configuration.html#并行预处理器) 与 [串行预处理器（token问题最佳解决方案）](/guide/configuration.html#串行预处理器（token问题最佳解决方案）)。 +　　标签除了可以用来取消任务，在预处理器中它也可以发挥作用，请参见 [并行预处理器](/v1/configuration.html#并行预处理器) 与 [串行预处理器（token问题最佳解决方案）](/v1/configuration.html#串行预处理器（token问题最佳解决方案）)。 diff --git a/okhttps-doc/docs/guide/updown.md b/okhttps-doc/docs/v1/updown.md similarity index 100% rename from okhttps-doc/docs/guide/updown.md rename to okhttps-doc/docs/v1/updown.md diff --git a/okhttps-doc/docs/v2/README.md b/okhttps-doc/docs/v2/README.md new file mode 100644 index 00000000..84a45c42 --- /dev/null +++ b/okhttps-doc/docs/v2/README.md @@ -0,0 +1,103 @@ +--- +description: OkHttps 安装 构建实例 HTTP build 同步请求 异步请求 sync async BaseUrl request webSocket gradle maven ejlchina +--- + +# 起步 + +　　OkHttps 是近期开源的对 OkHttp3 轻量封装的框架，它独创的异步预处理器，特色的标签，灵活的上传下载进度监听与过程控制功能，在轻松解决很多原本另人头疼问题的同时，设计上也力求纯粹与优雅。 + + * 链式调用，一点到底 + * BaseURL、URL占位符、JSON自动封装与解析 + * 同步拦截器、异步预处理器、回调执行器、全局监听、回调阻断 + * 文件上传下载（过程控制、进度监听） + * 单方法回调，充分利用 Lambda 表达式 + * TCP连接池、Http2 + +::: tip +* OkHttps 非常轻量（59Kb），仅是 Retrofit（124Kb）的一半，并且更加的开箱即用，API 也更加自然和语义化。 +* OkHttps 是一个纯粹的 Java 网络开发包，并不依赖 Android，这一点和 Retrofit 不同 +* OkHttps 用起来很优美，可以像 RxJava 那样链式用，却比 RxJava 更简单。 +::: + +## 安装 + +### Maven + +```xml + + com.ejlchina + okhttps + 1.0.5 + +``` +### Gradle + +```groovy +implementation 'com.ejlchina:okhttps:1.0.5' +``` + +安卓中使用需要把 JDK 版本调成 1.8，在 app 模块的 build.gradle 中加入以下配置即可： + +```groovy +android { + // 省略其它配置.. + compileOptions { + sourceCompatibility = 1.8 + targetCompatibility = 1.8 + } +} +``` + +## 使用 + +### 构建实例 + +```java +HTTP http = HTTP.builder().build(); +``` +　　以上代码构建了一个最简单的`HTTP`实例，它拥有以下方法： + +* `sync(String url)` 开始一个同步请求 +* `async(String url)` 开始一个异步请求 +* `cancel(String tag)` 按标签取消请求 +* `cancelAll()` 取消所有HTTP任务，包括同步和异步 +* `request(Request request)` OkHttp 原生请求 +* `webSocket(Request request, WebSocketListener listener)` WebSocket通讯 + +　　为了使用方便，在构建的时候，我们更愿意指定一个`BaseUrl`（详见 [设置 BaseUrl](/v1/configuration.html#设置-baseurl)）: + +```java +HTTP http = HTTP.builder() + .baseUrl("http://api.demo.com") + .build(); +``` +　　为了简化文档，下文中出现的`http`均是在构建时设置了`BaseUrl`的`HTTP`实例。 + +### 同步请求 + +　　使用方法`sync(String url)`开始一个同步请求： + +```java +List users = http.sync("/users") // http://api.demo.com/users + .get() // GET请求 + .getBody() // 获取响应报文体 + .toList(User.class); // 得到目标数据 +``` +　　方法`sync`返回一个同步`HttpTask`，可链式使用。 + +### 异步请求 + +　　使用方法`async(String url)`开始一个异步请求： + +```java +http.async("/users/1") // http://api.demo.com/users/1 + .setOnResponse((HttpResult result) -> { + // 得到目标数据 + User user = result.getBody().toBean(User.class); + }) + .get(); // GET请求 +``` +　　方法`async`返回一个异步`HttpTask`，可链式使用。 + + +**至此，你已轻松学会了 OkHttps 95% 的常规用法！但别急，后面还有更精彩的。** \ No newline at end of file diff --git a/okhttps-doc/docs/v2/android.md b/okhttps-doc/docs/v2/android.md new file mode 100644 index 00000000..73c7fde5 --- /dev/null +++ b/okhttps-doc/docs/v2/android.md @@ -0,0 +1,181 @@ +--- +description: OkHttps 安卓 生命周期 UI线程 主线程 IO线程 自由 灵活 切换 生命周期绑定 配置预处理器 定义生命周期监视器 配置全局回调监听 +--- + +# 安卓 + +## 回调线程切换 + +　　在 Android 开发中，经常会把某些代码放到特点的线程去执行，比如网络请求响应后的页面更新在主线程（UI线程）执行，而保存文件则在IO线程操作。OkHttps 为这类问题提供了良好的方案。 + +　　在 **默认** 情况下，**所有回调** 函数都会 **在 IO 线程** 执行。为什么会设计如此呢？这是因为 OkHttps 只是纯粹的 Java 领域 Http工具包，本身对 Android 不会有任何依赖，因此也不知 Android 的 UI 线程为何物。这么设计也让它在 Android 之外有更多的可能性。 + +### 配置 + +　　但是在 Android 里使用 OkHttps 的话，UI线程的问题能否优雅的解决呢？当然可以！简单粗暴的方法就是配置一个 回调执行器： + + ```java +HTTP http = HTTP.builder() + .callbackExecutor((Runnable run) -> { + // 实际编码中可以吧 Handler 提出来，不需要每次执行回调都重新创建 + new Handler(Looper.getMainLooper()).post(run); // 在主线程执行 + }) + .build(); +``` + +### 用例 + +　　上述代码便实现了让 **所有** 的 **回调函数** 都在 **主线程（UI线程）** 执行的目的，如： + +```java +http.async("/users") + .addBodyParam("name", "Jack") + .setOnProcess((Process process) -> { + // 在主线程执行 + }) + .setOnResponse((HttpResult result) -> { + // 在主线程执行 + }) + .setOnException((Exception e) -> { + // 在主线程执行 + }) + .setOnComplete((State state) -> { + // 在主线程执行 + }) + .post(); +``` +　　但是，如果同时还想让某些回调放在IO线程，实现 **自由切换**，怎么办呢？OkHttps 给出了非常灵活的方法，如下： + +```java +http.async("/users") + .addBodyParam("name", "Jack") + .setOnProcess((Process process) -> { + // 在主线程执行 + }) + .nextOnIO() // 指定下一个回调在 IO 线程执行 + .setOnResponse((HttpResult result) -> { + // 在 IO 线程执行 + }) + .setOnException((Exception e) -> { + // 在主线程执行（没有指明 nextOnIO 则在回调执行器里执行） + }) + .nextOnIO() // 指定下一个回调在 IO 线程执行 + .setOnComplete((State state) -> { + // 在 IO 线程执行 + }) + .post(); +``` +　　无论是哪一个回调，都可以使用`nextOnIO()`方法自由切换。同样，对于文件下载也是一样： + +```java +http.sync("/download/test.zip") + .get() + .getBody() + .setOnProcess((Process process) -> { + // 在主线程执行 + }) + .toFolder("D:/download/") + .nextOnIO() // 指定下一个回调在 IO 线程执行 + .setOnSuccess((File file) -> { + // 在 IO 线程执行 + }) + .setOnFailure((Failure failure) -> { + // 在主线程执行 + }) + .start(); +``` + +## 生命周期绑定 + +　　由于 OkHttps 并不依赖于 Android，所以它并没有提供关于生命周期绑定的直接实现，但它的一些扩展机制让我们很容易就可以实现这个需求。在开始之前，我们首先要理解何为生命周期绑定： + +::: tip HTTP 请求的生命周期绑定 +所谓的生命周期绑定：即是让 HTTP 任务感知其所属的 Activity 或 Fragment 的生命周期，当 Activity 或 Fragment 将被销毁时，框架应自动的把由它们发起的但尚未完成的 HTTP 任务全部取消，以免导致程序出错！ +::: + +　　现在我们需要对`HTTP`实例进行配置，配置后的`HTTP`实例具有生命周期绑定的功能，在`Activity`或`Fragment`里，它的使用效果如下： + +```java +// 在 Activity 或 Fragment 内发起请求 +http.async("http://www.baidu.com") + .bind(getLifecycle()) // 绑定生命周期 + .setOnResponse((HttpResult result) -> { + Log.i("FirstFragment", "收到请求：" + result.toString()); + }) + .get(); +``` +　　上述代码中的`getLifecycle()`是`Activity`或`Fragment`自带的方法，而`bind()`是`HttpTask`的现有方法。在配置好`HTTP`实例后，上述代码发起的请求便可以感知`Activity`或`Fragment`的生命周期。 + +　　那`HTTP`实例到底该如何配置呢？ + +### 第一步：配置预处理器 + +```java +HTTP http = HTTP.builder() + ... // 省略其它配置项 + .addPreprocessor((Preprocessor.PreChain chain) -> { + HttpTask task = chain.getTask(); + Object bound = task.getBound(); + // 判断 task 是否绑定了 Lifecycle 对象 + if (bound instanceof Lifecycle) { + // 重新绑定一个 生命周期监视器（LCObserver）对象，它的定义见下一步 + task.bind(new LCObserver(task, (Lifecycle) bound)); + } + chain.proceed(); + }) + ... // 省略其它配置项 + .build(); +``` + +### 第二步：定义生命周期监视器 + +```java +public class LCObserver implements LifecycleObserver { + + HttpTask task; + Lifecycle lifecycle; + + LCObserver(HttpTask task, Lifecycle lifecycle) { + this.task = task; + this.lifecycle = lifecycle; + lifecycle.addObserver(this); + } + + @OnLifecycleEvent(Lifecycle.Event.ON_STOP) + public void onStop() { + task.cancel(); // 在 ON_STOP 事件中，取消对应的 HTTP 任务 + } + + public void unbind() { + // 在请求完成之后移除监视器 + lifecycle.removeObserver(this); + } + +} +``` + +### 第三步：配置全局回调监听 + +　　以上两步其实已经实现了生命周期绑定的功能，但是在请求完成之后，我们需要在`lifecycle`中移除`LCObserver`对象： + +```java +HTTP http = HTTP.builder() + ... // 省略其它配置项 + .completeListener((HttpTask task, HttpResult.State state) -> { + Object bound = task.getBound(); + // 判断 task 是否绑定了生命周期监视器（LCObserver）对象 + if (bound instanceof LCObserver) { + // 解绑监视器 + ((LCObserver) bound).unbind(); + } + return true; + }) + ... // 省略其它配置项 + .build(); +``` + +**以上三步便在Android中实现了生命周期与HTTP请求绑定的功能** + +　　非常简单，懒得敲代码的同学还可以 [点这里 OkHttps.java](https://gitee.com/ejlchina-zhxu/okhttps-android-demo/blob/master/app/src/main/java/com/flower/myapplication/http/OkHttps.java) 直接下载封装好的源码，其中不仅编写了生命周期绑定的配置，还有在UI线程执行回调的配置。 + +　　有需要的同学，可以直接下载下来使用，还可以基于它再次扩展，比如实现自动添加 TOKEN 的功能，具体可以参考[6.5 串行预处理器（TOKEN问题最佳解决方案）](#65-串行预处理器token问题最佳解决方案)，再比如扩展实现生命周期与下载事件绑定的功能，都非常简单。 diff --git a/okhttps-doc/docs/v2/configuration.md b/okhttps-doc/docs/v2/configuration.md new file mode 100644 index 00000000..30bf60e9 --- /dev/null +++ b/okhttps-doc/docs/v2/configuration.md @@ -0,0 +1,158 @@ +--- +description: OkHttps 配置 BaseUrl 回调执行器 主线程 UI线程 OkHttpClient 预处理器 TOKEN问题最佳解决方案 刷新TOKEN 全局 回调监听 下载监听 回调阻断 拦截器 CookieJar、SSL、缓存、代理、事件监听 +--- + +# 配置 + +## 设置 BaseUrl + +```java +HTTP http = HTTP.builder() + .baseUrl("http://api.demo.com") // 设置 BaseUrl + .build(); +``` +　　该配置全局生效，在配置了`BaseUrl`之后，具体的请求便可以省略`BaseUrl`部分，使得代码更加简洁，例如： + +```java +http.sync("/users").get() // http://api.demo.com/users + +http.sync("/auth/signin") // http://api.demo.com/auth/signin + .addBodyParam("username", "Jackson") + .addBodyParam("password", "xxxxxx") + .post(); // POST请求 +``` +　　在配置了`BaseUrl`之后，如有特殊请求任务，仍然可以使用全路径的方式，一点都不妨碍： + +```java +http.sync("https://www.baidu.com").get(); +``` + +## 回调执行器 + +　　OkHttps 默认所有回调都在 **IO线程** 执行，如何想改变执行回调的线程时，可以配置回调执行器。例如在Android里，让所有的回调函数都在UI线程执行，则可以在构建`HTTP`时配置如下： + +```java +HTTP http = HTTP.builder() + .callbackExecutor((Runnable run) -> { + runOnUiThread(run); // 在UI线程执行 + }) + .build(); +``` +　　该配置默认 **影响所有回调**。 + +## 配置 OkHttpClient + +　　与其他封装 OkHttp3 的框架不同，OkHttps 并不会遮蔽 OkHttp3 本身就很好用的功能，如下： + +```java +HTTP http = HTTP.builder() + .config((Builder builder) -> { + // 配置连接池 最小10个连接（不配置默认为 5） + builder.connectionPool(new ConnectionPool(10, 5, TimeUnit.MINUTES)); + // 配置连接超时时间（默认10秒） + builder.connectTimeout(20, TimeUnit.SECONDS); + // 配置拦截器 + builder.addInterceptor((Chain chain) -> { + Request request = chain.request(); + // 必须同步返回，拦截器内无法执行异步操作 + return chain.proceed(request); + }); + // 其它配置: CookieJar、SSL、缓存、代理、事件监听... + }) + .build(); +``` + +## 并行预处理器 + +　　预处理器（`Preprocessor`）可以让我们在请求发出之前对请求本身做一些改变，但与`OkHttp`的拦截器（`Interceptor`）不同：预处理器可以让我们 **异步** 处理这些问题。 + +　　例如，当我们想为请求任务自动添加`Token`头信息，而`Token`只能通过异步方法`requestToken`获取时，这时使用`Interceptor`就很难处理了，但可以使用预处理器轻松解决： + +```java +HTTP http = HTTP.builder() + .addPreprocessor((PreChain chain) -> { + HttpTask task = chain.getTask();// 获得当前的HTTP任务 + if (!task.isTagged("Auth")) { // 根据标签判断该任务是否需要Token + chain.proceed(); + return; + } + requestToken((String token) -> { // 异步获取 Token + task.addHeader("Token", token);// 为任务添加头信息 + chain.proceed(); // 继续当前的任务 + }); + }) + .build(); +``` +　　和`Interceptor`一样，`Preprocessor`也可以添加多个。他们之间的区别如下: + +::: tip 拦截器与预处理器的区别 +* 拦截器只能处理同步操作，预处理器支持处理异步操作 +* 拦截器都是并行处理请求，预处理器支持串行处理（详见6.5章节） +* 拦截器处理时机在请求前和响应后，预处理器只在请求前，并且先于拦截器执行。关于响应后，OkHttps还提供了全局回调监听（详见6.6章节） +::: + +## 串行预处理器（TOKEN问题最佳解决方案） + +　　普通预处理器都是可并行处理的，然而有时我们希望某个预处理器同时只处理一个任务。比如 当`Token`过期时我们需要去刷新获取新`Token`，而刷新`Token`这个操作只能有一个任务去执行，因为如果`n`个任务同时执行的话，那么必有`n-1`个任务刚刷新得到的`Token`可能就立马失效了，而这是我们所不希望的。 + +　　为了解决这个问题，OkHttps 提供了串行预处理器，它可以让 HTTP 任务排好队，一个一个地进入预处理器： + +```java +HTTP http = HTTP.builder() + .addSerialPreprocessor((PreChain chain) -> { + HttpTask task = chain.getTask(); + if (!task.isTagged("Auth")) { + chain.proceed(); + return; + } + // 检查过期，若需要则刷新Token + requestTokenAndRefreshIfExpired((String token) -> { + task.addHeader("Token", token); + chain.proceed(); // 调用此方法前，不会有其它任务进入该处理器 + }); + }) + .build(); +``` +　　串行预处理器实现了让HTTP任务排队串行处理的功能，但值得一提的是：它并没有因此而阻塞任何线程！ + +## 全局回调监听 + +　　全局回调是实际开发中经常需要的功能，比如对服务器响应的状态码进行统一处理等，同时 OkHttps 的全局回调还具有 **回调阻断** 的功能： + +```java +HTTP http = HTTP.builder() + .responseListener((HttpTask task, HttpResult result) -> { + // 所有请求响应后都会走这里 + + return true; // 返回 true 表示继续执行 task 的 OnResponse 回调，false 表示不再执行 + }) + .completeListener((HttpTask task, State state) -> { + // 所有请求执行完都会走这里 + + return true; // 返回 true 表示继续执行 task 的 OnComplete 回调，false 表示不再执行 + }) + .exceptionListener((HttpTask task, IOException error) -> { + // 所有请求发生异常都会走这里 + + return true; // 返回 true 表示继续执行 task 的 OnException 回调，false 表示不再执行 + }) + .build(); +``` + +::: tip 全局回调监听与拦截器的异同： +* 拦截器可以添加多个，全局回调监听分三种，每种最多添加一个 +* 拦截器处的理时机在请求前和响应后，全局回调监听只在响应后，并且晚于拦截器 +* 全局回调监听可以 **阻断**（return false）某个请求的具体回调，而拦截器不能 +::: + +## 全局下载监听 + +```java +HTTP http = HTTP.builder() + .downloadListener((HttpTask task, Download download) -> { + // 所有下载在开始之前都会先走这里 + Ctrl ctrl = download.getCtrl(); // 下载控制器 + + }) + .build(); +``` \ No newline at end of file diff --git a/okhttps-doc/docs/v2/features.md b/okhttps-doc/docs/v2/features.md new file mode 100644 index 00000000..56771574 --- /dev/null +++ b/okhttps-doc/docs/v2/features.md @@ -0,0 +1,170 @@ +--- +description: OkHttps 使用 HttpUtils 类 WebSocket 异常处理 nothrow 异常回调 多种方式 取消请求 标签 批量取消 cancelAll +--- + +# 特色 + +## 使用 HttpUtils 类 + +　　类`HttpUtils`本是 [前身 HttpUtils](https://gitee.com/ejlchina-zhxu/httputils) 的 1.x 版本里的最重要的核心类，由于在后来的版本里抽象出了`HTTP`接口，使得它的重要性已不如往昔。但合理的使用它，仍然可以带来不少便利，特别是在没有IOC容器的环境里，比如在Android开发和一些工具项目的开发中。 + +　　类`HttpUtils`共定义了四个静态方法： + +* `of(HTTP http)` 配置`HttpUtils`持有的`HTTP`实例（不调用此方法前默认使用一个没有没有经过任何配置的`HTTP`懒实例） +* `sync(String url)` 开始一个同步请求 （内部通过一个`HTTP`单例实现） +* `async(String url)` 开始一个异步请求 （内部通过一个`HTTP`单例实现） +* `cancel(String tag)` 按标签取消请求（内部通过一个`HTTP`单例实现） +* `cancelAll()` 取消所有HTTP任务，包括同步和异步（内部通过一个`HTTP`单例实现） +* `request(Request request)` OkHttp 原生请求 （该请求不经过 预处理器） +* `webSocket(Request request, WebSocketListener listener)` WebSocket通讯 +　　也就是说，能使用`http`实例的地方，都可以使用`HttpUtils`类，例如： + +```java +// 在配置HTTP实例之前，只能使用全路径方式 +List roles = HttpUtils.sync("http://api.demo.com/roles") + .get().getBody().toList(Role.class); + +// 配置HTTP实例,全局生效 +HttpUtils.of(HTTP.builder() + .baseUrl("http://api.demo.com") + .build()); + +// 内部使用新的HTTP实例 +List users = HttpUtils.sync("/users") + .get().getBody().toList(User.class); +``` + +## 异常处理 + +　　使用 OkHttps 时，**异常处理不是必须的**，但相比其它的 HTTP 开发包，它还提供一个特别的处理方法：`nothrow()`，以满足不同的异常处理需求。 + +### 同步请求的异常 + +　　默认情况下，当同步请求执行异常时，会直接向外抛出，我们可以用 `try catch` 来捕获，例如： + +```java +try { + HttpResult result = http.sync("/users/1").get(); +} catch (HttpException e) { + Throwable cause = e.getCause(); // 得到异常原因 + if (cause instanceof ConnectException) { + // 当没网络时，会抛出连接异常 + } + if (cause instanceof SocketTimeoutException) { + // 当接口长时间未响应，会抛出超时异常 + } + if (cause instanceof UnknownHostException) { + // 当把域名或IP写错，会抛出 UnknownHost 异常 + } + // ... +} +``` +　　这种传统的异常处理方式，当然可以解决问题，但 OkHttps 有更佳的方案： + +```java +// 方法 nothrow() 让异常不直接抛出 +HttpResult result = http.sync("/users/1").nothrow().get(); +// 判断执行状态 +switch (result.getState()) { + case RESPONSED: // 请求已正常响应 + break; + case CANCELED: // 请求已被取消 + break; + case NETWORK_ERROR: // 网络错误，说明用户没网了 + break; + case TIMEOUT: // 请求超时 + break; + case EXCEPTION: // 其它异常 + break; +} +// 还可以获得具体的异常信息 +IOException error = result.getError(); +``` + +### 异步请求的异常 + +　　异步请求最常用的异常处理方式就是设置一个异常回调： + +```java +http.async("/users/1") + .setOnResponse((HttpResult result) -> { + // 当发生异常时就不会走这里 + }) + .setOnException((IOException e) -> { + // 这里处理请求异常 + }) + .get(); +``` +　　当然，还有一个全局异常监听（`ExceptionListener`）： + +```java +HTTP http = HTTP.builder() + .exceptionListener((HttpTask task, IOException error) -> { + // 所有请求发生异常都会走这里 + + return true; // 返回 true 表示继续执行 task 的 OnException 回调，false 表示不再执行 + }) + .build(); +``` +　　如果不设置`OnException`回调，也没有`ExceptionListener`，发生异常时会在 **IO 线程** 中向上抛出，外层无法捕获： + +```java +try { + http.async("/users/1") + .setOnResponse((HttpResult result) -> { + // 当发生异常时就不会走这里 + }) + .get(); +} catch (HttpException e) { + // 这种方式是捕获不到异常的！！！！！！ +} +``` +　　即使没有`OnException`回调，发生异常时，依然会走`OnComplete`回调，如果设置了的话： + +```java +http.async("/users/1") + .setOnResponse((HttpResult result) -> { + // 当发生异常时就不会走这里 + }) + .setOnComplete((State state) -> { + // 发生异常，会先执行这里，可以根据 state 判断发生了什么 + // 但执行完后依然会在IO线程中向上抛出 + }) + .get(); +``` +　　如果就是想 **不处理异常，也不向上抛出**，发生错误完全无视，可以做到吗？可以！还是使用`nothrow()`方法： + +```java +http.async("/users/1") + .nothrow() // 告诉 OkHttps 发生异常时不向外抛出 + .setOnResponse((HttpResult result) -> { + // 当发生异常时就不会走这里 + }) + .get(); +``` + +## 取消请求 + +　　在 OkHttps 里取消请求共有 **4 种** 方式可选： + +* 使用`HttpCall#cancel()`取消单个请求（适用于异步请求，[详见 3.3 章节](#33-httpcall)） +* 使用`HttpTask#cancel()`取消单个请求（适用于所有请求）（since v1.0.4） + +```java +HttpTask task = http.async("/users") + .setOnResponse((HttpResult result) -> { + // 响应回调 + }); + +task.get(); // 发起 GET 请求 + +// 取消请求，并返回是否取消成功 +boolean canceled = task.cancel(); +``` + +* 使用`HTTP#cancel(String tag)`按标签批量取消请求（适用于所有请求，[详见第 5 章节](#5-使用标签)） +* 使用`HTTP#cancelAll()`取消所有请求（适用于所有请求）（since v1.0.2） + +```java +http.cancelAll(); // 取消所有请求 +``` \ No newline at end of file diff --git a/okhttps-doc/docs/v2/foundation.md b/okhttps-doc/docs/v2/foundation.md new file mode 100644 index 00000000..e48cd8af --- /dev/null +++ b/okhttps-doc/docs/v2/foundation.md @@ -0,0 +1,209 @@ +--- +description: OkHttps 请求方法 回调函数 HttpResult cache 多次 消费报文体 HttpCall 构建HTTP任务 请求参数 JSON 使用标签 发起请求 取消请求 +--- + +# 基础 + +## 请求方法 + +　　同步与异步的`HttpTask`都拥有`get`、`post`、`put`与`delete`方法。不同的是：同步`HttpTask`的这些方法返回一个`HttpResult`，而异步`HttpTask`的这些方法返回一个`HttpCall`。 + +```java +HttpResult res1 = http.sync("/users").get(); // 同步 GET +HttpResult res2 = http.sync("/users").post(); // 同步 POST +HttpResult res3 = http.sync("/users/1").put(); // 同步 PUT +HttpResult res4 = http.sync("/users/1").delete();// 同步 DELETE +HttpCall call1 = http.async("/users").get(); // 异步 GET +HttpCall call2 = http.async("/users").post(); // 异步 POST +HttpCall call3 = http.async("/users/1").put(); // 异步 PUT +HttpCall call4 = http.async("/users/1").delete();// 异步 DELETE +``` + +## 回调函数 + +　　OkHttps 的回调函数全部使用单方法模式，这样可以充分利用 Java8 或 Kotlin 中的 Lambda 表达式，使你的代码更加简洁优雅： + +```java +http.async("/users/{id}") // http://api.demo.com/users/1 + .addPathParam("id", 1) + .setOnResponse((HttpResult result) -> { + // 响应回调 + }) + .setOnException((IOException e) -> { + // 异常回调 + }) + .setOnComplete((State state) -> { + // 完成回调，无论成功失败都会执行 + // 并且在 响应|异常回调 之前执行 + }) + .get(); +``` + +　　OkHttps 同时还支持 **全局回调** 和 **回调阻断** 机制，详见 [全局回调监听](/v1/configuration.html#全局回调监听)。 + +::: tip +* 只有异步请求才可以设置这三种（响应|异常|完成）回调 +* 同步请求直接返回结果，无需使用回调 +::: + +## HttpResult + +　　`HttpResult`是HTTP请求执行完后的结果，它是同步请求方法（ `get`、`post`、`put`、`delete`）的返回值，也是异步请求响应回调（`OnResponse`）的参数，它定义了如下方法： + +* `getState()` 得到请求执行状态枚举，它有以下取值： + * `State.CANCELED` 请求被取消 + * `State.RESPONSED` 已收到响应 + * `State.TIMEOUT` 请求超时 + * `State.NETWORK_ERROR` 网络错误 + * `State.EXCEPTION` 其它请求异常 +* `getStatus()` 得到HTTP状态码 +* `isSuccessful()` 是否响应成功，状态码在 [200..300) 之间 +* `getHeaders()` 得到HTTP响应头 +* `getHeaders(String name)` 得到HTTP响应头 +* `getHeader(String name)` 得到HTTP响应头 +* `getBody()` 得到响应报文体`Body`实例，它定义了如下方法（对同一个`Body`实例，以下的`toXXX()`类方法只能使用一个且仅能调用一次，除非先使用 cache 方法）： + * `toBytes()` 返回字节数组 + * `toByteStream()` 返回字节输入流 + * `toCharStream()` 返回字符输入流 + * `toString()` 返回字符串 + * `toJsonObject()` 返回Json对象 + * `toJsonArray()` 返回Json数组 + * `toBean(Class type)` 返回根据type自动json解析后的JavaBean + * `toList(Class type)` 返回根据type自动json解析后的JavaBean列表 + * `toFile(String filePath)` 下载到指定路径 + * `toFile(File file)` 下载到指定文件 + * `toFolder(String dirPath)` 下载到指定目录 + * `toFolder(File dir)` 下载到指定目录 + * `getContentType()` 返回报文体的媒体类型 + * `getContentLength()` 返回报文体的字节长度 + * `cache()` 缓存报文体，开启缓存后可重复使用`toXXX()`类方法 + * `close()` 关闭报文体，未对报文体做任何消费时使用，比如只读取报文头 +* `getError()` 执行中发生的异常，自动捕获执行请求时发生的 网络超时、网络错误 和 其它IO异常 +* `close()` 关闭报文，未对报文体做任何消费时使用，比如只读取长度 + +　　示例，请求结果自动转Bean和List： + +```java +// 自动转Bean +Order order = http.sync("/orders/1") + .get().getBody().toBean(Order.class); + +// 自动转List +List orders = http.sync("/orders") + .get().getBody().toList(Order.class); +``` + +　　示例，使用 cache 方法： + +```java +Body body = http.sync("/orders").get().getBody().cache(); + +// 使用 cache 后，可以多次使用 toXXX() 方法 +System.out.println(body.toString()); +System.out.println(body.toJsonArray()); +System.out.println(body.toList(Order.class)); +``` + +　　示例，获取下载文件的大小： + +```java +long size = http.sync("/download/test.zip") + .get().getBody() + .close() // 只是想获得文件大小，不消费报文体，所以直接关闭 + .getContentLength(); // 获得待下载文件的大小 + +// 由于未消费报文体，所以本次请求不会消耗下载报文体的时间和网络流量 + +System.out.println("size = " + size); +``` + +## HttpCall + +　　`HttpCall`对象是异步请求方法（`get`、`post`、`put`、`delete`）的返回值，与`java`的`Future`接口很像，它有如下方法： + +* `cancel()` 取消本次请求，返回取消结果 +* `isCanceled()` 返回请求是否被取消 +* `isDone()` 返回是否执行完成，包含取消和失败 +* `getResult()` 返回执行结果`HttpResult`对象，若请求未执行完，则挂起当前线程直到执行完成再返回 + +　　取消一个异步请求示例： + +```java +HttpCall call = http.async("/users/1").get(); + +System.out.println(call.isCanceled()); // false + +boolean success = call.cancel(); // 取消请求 + +System.out.println(success); // true +System.out.println(call.isCanceled()); // true +``` + +## 构建HTTP任务 + +　　`HTTP`对象的`sync`与`async`方法返回一个`HttpTask`对象，该对象提供了可链式调用的`addXXX`与`setXXX`等系列方法用于构建任务本身。 + +* `addHeader(String name, String value)` 添加请求头 +* `addHeader(Map headers)` 添加请求头 + +* `addPathParam(String name, Object value)` 添加路径参数：替换URL里的{name}占位符 +* `addPathParam(Map params)` 添加路径参数：替换URL里的{name}占位符 + +* `addUrlParam(String name, Object value)` 添加URL参数：拼接在URL的?之后（查询参数） +* `addUrlParam(Map params)` 添加URL参数：拼接在URL的?之后（查询参数） + +* `addBodyParam(String name, Object value)` 添加Body参数：以表单key=value&的形式放在报文体内（表单参数） +* `addBodyParam(Map params)` 添加Body参数：以表单key=value&的形式放在报文体内（表单参数） + +* `addJsonParam(String name, Object value)` 添加Json参数：请求体为Json（支持多层结构） +* `addJsonParam(Map params)` 添加Json参数：请求体为Json（支持多层结构） + +* `setRequestJson(Object json)` 设置请求体的Json字符串 或待转换为 Json的 JavaBean +* `setRequestJson(Object bean, String dateFormat)` 设置请求体的Json字符串 或待转换为 Json的 JavaBean + +* `addFileParam(String name, String filePath)` 上传文件 +* `addFileParam(String name, File file)` 上传文件 +* `addFileParam(String name, String type, InputStream inputStream)` 上传文件 +* `addFileParam(String name, String type, String fileName, InputStream input)` 上传文件 +* `addFileParam(String name, String type, byte[] content)` 上传文件 +* `addFileParam(String name, String type, String fileName, byte[] content)` 上传文件 + +* `setTag(String tag)` 为HTTP任务添加标签 +* `setRange(long rangeStart)` 设置Range头信息，用于[断点续传](/v1/updown.html#实现断点续传) +* `setRange(long rangeStart, long rangeEnd)` 设置Range头信息，可用于[分块下载](/v1/updown.html#实现分块下载) + +* `bind(Object object)` 绑定一个对象，可用于实现Android里的[生命周期绑定](/v1/android.html#生命周期绑定) + +## 使用标签 + +　　有时候我们想对HTTP任务加以分类，这时候可以使用标签功能： + +```java +http.async("/users") //（1） + .setTag("A") + .get(); + +http.async("/users") //（2） + .setTag("A.B") + .get(); + +http.async("/users") //（3） + .setTag("B") + .get(); + +http.async("/users") //（4） + .setTag("B") + .setTag("C") // 从 v1.0.4 标签将以追加模式添加，等效于 setTag("B.C") + .get(); + +http.async("/users") //（5） + .setTag("C") + .get(); +``` +　　当使用标签后，就可以按标签批量的对HTTP任务进行取消： + +```java +int count = http.cancel("B"); //（2）（3）（4）被取消（取消标签包含"B"的任务） +System.out.println(count); // 输出 3 +``` +　　标签除了可以用来取消任务，在预处理器中它也可以发挥作用，请参见 [并行预处理器](/v1/configuration.html#并行预处理器) 与 [串行预处理器（token问题最佳解决方案）](/v1/configuration.html#串行预处理器（token问题最佳解决方案）)。 diff --git a/okhttps-doc/docs/v2/updown.md b/okhttps-doc/docs/v2/updown.md new file mode 100644 index 00000000..73486bac --- /dev/null +++ b/okhttps-doc/docs/v2/updown.md @@ -0,0 +1,223 @@ +--- +description: OkHttps 文件 上传 下载 进度监听 过程控制 断点续传 分块下载 +--- + +# 上传下载 + +## 文件下载 + +　　OkHttps 并没有把文件的下载排除在常规的请求之外，同一套API，它优雅的设计使得下载与常规请求融合的毫无违和感，一个最简单的示例： + +```java +http.sync("/download/test.zip") + .get() // 使用 GET 方法（其它方法也可以，看服务器支持） + .getBody() // 得到报文体 + .toFile("D:/download/test.zip") // 下载到指定的路径 + .start(); // 启动下载 + +http.sync("/download/test.zip").get().getBody() + .toFolder("D:/download") // 下载到指定的目录，文件名将根据下载信息自动生成 + .start(); +``` +　　或使用异步连接方式： + +```java +http.async("/download/test.zip") + .setOnResponse((HttpResult result) -> { + result.getBody().toFolder("D:/download").start(); + }) + .get(); +``` +　　这里要说明一下：`sync`与`async`的区别在于连接服务器并得到响应这个过程的同步与异步（这个过程的耗时在大文件下载中占比极小），而`start`方法启动的下载过程则都是异步的。 + +### 下载进度监听 + +　　就直接上代码啦，诸君一看便懂： + +```java +http.sync("/download/test.zip") + .get() + .getBody() + .setStepBytes(1024) // 设置每接收 1024 个字节执行一次进度回调（不设置默认为 8192） + // .setStepRate(0.01) // 设置每接收 1% 执行一次进度回调（不设置以 StepBytes 为准） + .setOnProcess((Process process) -> { // 下载进度回调 + long doneBytes = process.getDoneBytes(); // 已下载字节数 + long totalBytes = process.getTotalBytes(); // 总共的字节数 + double rate = process.getRate(); // 已下载的比例 + boolean isDone = process.isDone(); // 是否下载完成 + }) + .toFolder("D:/download/") // 指定下载的目录，文件名将根据下载信息自动生成 + // .toFile("D:/download/test.zip") // 指定下载的路径，若文件已存在则覆盖 + .setOnSuccess((File file) -> { // 下载成功回调 + + }) + .start(); +``` +　　值得一提的是：由于 OkHttps 并没有把下载做的很特别，这里设置的进度回调不只对下载文件起用作，即使对响应JSON的常规请求，只要设置了进度回调，它也会告诉你报文接收的进度（提前是服务器响应的报文有`Content-Length`头），例如： + +```java +List users = http.sync("/users") + .get() + .getBody() + .setStepBytes(2) + .setOnProcess((Process process) -> { + System.out.println(process.getRate()); + }) + .toList(User.class); +``` + +### 下载过程控制 + +　　过于简单：还是直接上代码： + +```java +Ctrl ctrl = http.sync("/download/test.zip") + .get() + .getBody() + .setOnProcess((Process process) -> { + System.out.println(process.getRate()); + }) + .toFolder("D:/download/") + .start(); // 该方法返回一个下载过程控制器 + +ctrl.status(); // 下载状态 +ctrl.pause(); // 暂停下载 +ctrl.resume(); // 恢复下载 +ctrl.cancel(); // 取消下载（同时会删除文件，不可恢复） +``` +　　无论是同步还是异步发起的下载请求，都可以做以上的控制： + +```java +http.async("/download/test.zip") + .setOnResponse((HttpResult result) -> { + // 拿到下载控制器 + Ctrl ctrl = result.getBody().toFolder("D:/download/").start(); + }) + .get(); +``` + +### 实现断点续传 + +　　OkHttps 对断点续传并没有再做更高层次的封装，因为这是app该去做的事情，它在设计上使各种网络问题的处理变简单的同时力求纯粹。下面的例子可以看到，OkHttps 通过一个失败回调拿到 **断点**，便将复杂的问题变得简单： + +```java +http.sync("/download/test.zip") + .get() + .getBody() + .toFolder("D:/download/") + .setOnFailure((Failure failure) -> { // 下载失败回调，以便接收诸如网络错误等失败信息 + IOException e = failure.getException(); // 具体的异常信息 + long doneBytes = failure.getDoneBytes(); // 已下载的字节数（断点），需要保存，用于断点续传 + File file = failure.getFile(); // 下载生成的文件，需要保存 ，用于断点续传（只保存路径也可以） + }) + .start(); +``` +　　下面代码实现续传： + +```java +long doneBytes = ... // 拿到保存的断点 +File file = ... // 待续传的文件 + +http.sync("/download/test.zip") + .setRange(doneBytes) // 设置断点（已下载的字节数） + .get() + .getBody() + .toFile(file) // 下载到同一个文件里 + .setAppended() // 开启文件追加模式 + .setOnSuccess((File file) -> { + + }) + .setOnFailure((Failure failure) -> { + + }) + .start(); +``` + +### 实现分块下载 + +　　当文件很大时，有时候我们会考虑分块下载，与断点续传的思路是一样的，示例代码： + +```java +static String url = "http://api.demo.com/download/test.zip" + +public static void main(String[] args) { + long totalSize = HttpUtils.sync(url).get().getBody() + .close() // 因为这次请求只是为了获得文件大小，不消费报文体，所以直接关闭 + .getContentLength(); // 获得待下载文件的大小（由于未消费报文体，所以该请求不会消耗下载报文体的时间和网络流量） + download(totalSize, 0); // 从第 0 块开始下载 + sleep(50000); // 等待下载完成（不然本例的主线程就结束啦） +} + +static void download(long totalSize, int index) { + long size = 3 * 1024 * 1024; // 每块下载 3M + long start = index * size; + long end = Math.min(start + size, totalSize); + HttpUtils.sync(url) + .setRange(start, end) // 设置本次下载的范围 + .get().getBody() + .toFile("D:/download/test.zip") // 下载到同一个文件里 + .setAppended() // 开启文件追加模式 + .setOnSuccess((File file) -> { + if (end < totalSize) { // 若未下载完，则继续下载下一块 + download(totalSize, index + 1); + } else { + System.out.println("下载完成"); + } + }) + .start(); +} +``` + +## 文件上传 + +　　一个简单文件上传的示例： + +```java +http.sync("/upload") + .addFileParam("test", "D:/download/test.zip") + .post(); // 上传发法一般使用 POST 或 PUT，看服务器支持 +``` +　　异步上传也是完全一样： + +```java +http.async("/upload") + .addFileParam("test", "D:/download/test.zip") + .post(); +``` + +### 上传进度监听 + +　　OkHttps 的上传进度监听，监听的是所有请求报文体的发送进度，示例代码： + +```java +http.sync("/upload") + .addBodyParam("name", "Jack") + .addBodyParam("age", 20) + .addFileParam("avatar", "D:/image/avatar.jpg") + .setStepBytes(1024) // 设置每发送 1024 个字节执行一次进度回调（不设置默认为 8192） + // .setStepRate(0.01) // 设置每发送 1% 执行一次进度回调（不设置以 StepBytes 为准） + .setOnProcess((Process process) -> { // 上传进度回调 + long doneBytes = process.getDoneBytes(); // 已发送字节数 + long totalBytes = process.getTotalBytes(); // 总共的字节数 + double rate = process.getRate(); // 已发送的比例 + boolean isDone = process.isDone(); // 是否发送完成 + }) + .post(); +``` +　　咦！怎么感觉和下载的进度回调的一样？没错！OkHttps 还是使用同一套API处理上传和下载的进度回调，区别只在于上传是在`get/post`方法之前使用这些API，下载是在`getBody`方法之后使用。很好理解：`get/post`之前是准备发送请求时段，有上传的含义，而`getBody`之后，已是报文响应的时段，当然是下载。 + +### 上传过程控制 + +　　上传文件的过程控制就很简单，和常规请求一样，只有异步发起的上传可以取消： + +```java +HttpCall call = http.async("/upload") + .addFileParam("test", "D:/download/test.zip") + .setOnProcess((Process process) -> { + System.out.println(process.getRate()); + }) + .post(); + +call.cancel(); // 取消上传 +``` +　　上传就没有暂停和继续这个功能啦，应该没人有这个需求吧? \ No newline at end of file From f519009621607fcd72bf5ccb33af471299803eb8 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?=E5=91=A8=E6=97=AD?= Date: Wed, 13 May 2020 09:03:24 +0800 Subject: [PATCH 282/924] =?UTF-8?q?=E4=BC=98=E5=8C=96=20pom=20=E7=BB=93?= =?UTF-8?q?=E6=9E=84?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- okhttps/pom.xml | 7 +++++-- pom.xml | 14 -------------- 2 files changed, 5 insertions(+), 16 deletions(-) diff --git a/okhttps/pom.xml b/okhttps/pom.xml index cdc49691..25996b07 100644 --- a/okhttps/pom.xml +++ b/okhttps/pom.xml @@ -12,14 +12,17 @@ - + + com.squareup.okhttp3 + okhttp + ${okhttp.version} + com.squareup.okhttp3 mockwebserver ${okhttp.version} test - diff --git a/pom.xml b/pom.xml index 942a5544..fd8b563e 100644 --- a/pom.xml +++ b/pom.xml @@ -52,20 +52,12 @@ - - - com.squareup.okhttp3 - okhttp - ${okhttp.version} - - junit junit ${junit.version} test - @@ -98,7 +90,6 @@ okhttps - org.apache.maven.plugins maven-release-plugin @@ -109,7 +100,6 @@ -Psonatype-oss-release - org.apache.maven.plugins maven-compiler-plugin @@ -121,7 +111,6 @@ true - org.apache.maven.plugins maven-source-plugin @@ -135,7 +124,6 @@ - org.apache.maven.plugins maven-javadoc-plugin @@ -149,7 +137,6 @@ - org.apache.maven.plugins maven-gpg-plugin @@ -164,7 +151,6 @@ - From 1ab1a199043bb2897d07dd61b584bb6816470a5f Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?=E5=91=A8=E6=97=AD?= Date: Wed, 13 May 2020 10:17:37 +0800 Subject: [PATCH 283/924] =?UTF-8?q?v2=E6=96=87=E6=A1=A3?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- okhttps-doc/docs/.vuepress/config.js | 1 + okhttps-doc/docs/v2/README.md | 95 ++++++---------------------- okhttps-doc/docs/v2/getstart.md | 88 ++++++++++++++++++++++++++ 3 files changed, 110 insertions(+), 74 deletions(-) create mode 100644 okhttps-doc/docs/v2/getstart.md diff --git a/okhttps-doc/docs/.vuepress/config.js b/okhttps-doc/docs/.vuepress/config.js index ca27057a..ab1603b0 100644 --- a/okhttps-doc/docs/.vuepress/config.js +++ b/okhttps-doc/docs/.vuepress/config.js @@ -30,6 +30,7 @@ module.exports = { ], '/v2/': [ '', + 'getstart', 'foundation', 'configuration', 'features', diff --git a/okhttps-doc/docs/v2/README.md b/okhttps-doc/docs/v2/README.md index 84a45c42..caecab82 100644 --- a/okhttps-doc/docs/v2/README.md +++ b/okhttps-doc/docs/v2/README.md @@ -2,102 +2,49 @@ description: OkHttps 安装 构建实例 HTTP build 同步请求 异步请求 sync async BaseUrl request webSocket gradle maven ejlchina --- -# 起步 +# 介绍 + +## OkHttps 简介 　　OkHttps 是近期开源的对 OkHttp3 轻量封装的框架，它独创的异步预处理器，特色的标签，灵活的上传下载进度监听与过程控制功能，在轻松解决很多原本另人头疼问题的同时，设计上也力求纯粹与优雅。 * 链式调用，一点到底 - * BaseURL、URL占位符、JSON自动封装与解析 + * BaseURL、URL占位符、HTTP、WebSocket + * JSON、Xml 等自动封装与解析，且支持与任意格式的数据解析框架集成 * 同步拦截器、异步预处理器、回调执行器、全局监听、回调阻断 * 文件上传下载（过程控制、进度监听） * 单方法回调，充分利用 Lambda 表达式 * TCP连接池、Http2 ::: tip -* OkHttps 非常轻量（59Kb），仅是 Retrofit（124Kb）的一半，并且更加的开箱即用，API 也更加自然和语义化。 +* OkHttps 非常轻量（83Kb，Retrofit：124Kb），除 Okhttp 无第三方依赖，并且更加的开箱即用，API 也更加自然和语义化。 * OkHttps 是一个纯粹的 Java 网络开发包，并不依赖 Android，这一点和 Retrofit 不同 * OkHttps 用起来很优美，可以像 RxJava 那样链式用，却比 RxJava 更简单。 ::: -## 安装 - -### Maven - -```xml - - com.ejlchina - okhttps - 1.0.5 - -``` -### Gradle - -```groovy -implementation 'com.ejlchina:okhttps:1.0.5' -``` - -安卓中使用需要把 JDK 版本调成 1.8，在 app 模块的 build.gradle 中加入以下配置即可： - -```groovy -android { - // 省略其它配置.. - compileOptions { - sourceCompatibility = 1.8 - targetCompatibility = 1.8 - } -} -``` - -## 使用 - -### 构建实例 - -```java -HTTP http = HTTP.builder().build(); -``` -　　以上代码构建了一个最简单的`HTTP`实例，它拥有以下方法： +### 可选依赖 -* `sync(String url)` 开始一个同步请求 -* `async(String url)` 开始一个异步请求 -* `cancel(String tag)` 按标签取消请求 -* `cancelAll()` 取消所有HTTP任务，包括同步和异步 -* `request(Request request)` OkHttp 原生请求 -* `webSocket(Request request, WebSocketListener listener)` WebSocket通讯 +项目 | 最新版本 | 描述 +-|-|- +okhttps-fastjson | 2.0.0.RC | 与 fastjson 集成 +okhttps-gson | 2.0.0.RC | 与 gson 集成 +okhttps-jackson | 2.0.0.RC | 与 jackson 集成 -　　为了使用方便，在构建的时候，我们更愿意指定一个`BaseUrl`（详见 [设置 BaseUrl](/v1/configuration.html#设置-baseurl)）: +以上是官方维护的与三大JSON框架集成的案例，后续将提供 xml 和 protobuf 的集成。 -```java -HTTP http = HTTP.builder() - .baseUrl("http://api.demo.com") - .build(); -``` -　　为了简化文档，下文中出现的`http`均是在构建时设置了`BaseUrl`的`HTTP`实例。 -### 同步请求 +## v2.x 的新特性 -　　使用方法`sync(String url)`开始一个同步请求： +* HTTP 任务新增`patch()`方法，可发起 PATCH 请求，目前直接支持的 HTTP 方法有：GET、POST、PUT、PATCH、DELETE，并且暴露了`request(String method)`方法，可自定义发起任何请求，如：HEAD、OPTIONS、TRACE、CONNECT 等； -```java -List users = http.sync("/users") // http://api.demo.com/users - .get() // GET请求 - .getBody() // 获取响应报文体 - .toList(User.class); // 得到目标数据 -``` -　　方法`sync`返回一个同步`HttpTask`，可链式使用。 +* HTTP 任务新增`skipPreproc()`和`skipSerialPreproc()`，具体请求可跳过 所有 或只跳过 串行 预处理器； -### 异步请求 +* 新增`MsgConvertor`接口，实现 OkHttps 与 fastjson 解耦，且不再依赖某个具体 json 框架、甚至不依赖 json，它可以与 **任何格式** 的数据解析框架 集成，如：json 、xml 、protobuf 等; -　　使用方法`async(String url)`开始一个异步请求： +* 构建`HTTP`实例时支持注入多个`MsgConvertor`，可实现同一个`HTTP`实例下，既有 json 解析，又有 xml 解析等强大特性，同时还可以让表单（form）请求参数 同 json、xml 一样，支持序列化功能。 -```java -http.async("/users/1") // http://api.demo.com/users/1 - .setOnResponse((HttpResult result) -> { - // 得到目标数据 - User user = result.getBody().toBean(User.class); - }) - .get(); // GET请求 -``` -　　方法`async`返回一个异步`HttpTask`，可链式使用。 +* `HTTP`接口新增`webSocket(String url)`方法，与`sync(String url)`和`async(String url)`一样，支持 Lamda 编程、预处理器机制、消息数据自动序列化和反序列化机制； +* 新增`OkHttps`工具类，支持 SPI 方式注入配置，`OkHttps`和`HttpUtils`默认自动以 SPI 方式寻找依赖中的`MsgConvertor`； -**至此，你已轻松学会了 OkHttps 95% 的常规用法！但别急，后面还有更精彩的。** \ No newline at end of file +* 新增可自定义默认编码（不自定义依然默认为 utf-8）、具体请求可指定特殊编码功能。 \ No newline at end of file diff --git a/okhttps-doc/docs/v2/getstart.md b/okhttps-doc/docs/v2/getstart.md new file mode 100644 index 00000000..7b75628c --- /dev/null +++ b/okhttps-doc/docs/v2/getstart.md @@ -0,0 +1,88 @@ +--- +description: OkHttps 安装 构建实例 HTTP build 同步请求 异步请求 sync async BaseUrl request webSocket gradle maven ejlchina +--- + +# 起步 + +## 安装 + +### Maven + +```xml + + com.ejlchina + okhttps + 1.0.5 + +``` +### Gradle + +```groovy +implementation 'com.ejlchina:okhttps:1.0.5' +``` + +安卓中使用需要把 JDK 版本调成 1.8，在 app 模块的 build.gradle 中加入以下配置即可： + +```groovy +android { + // 省略其它配置.. + compileOptions { + sourceCompatibility = 1.8 + targetCompatibility = 1.8 + } +} +``` + +## 使用 + +### 构建实例 + +```java +HTTP http = HTTP.builder().build(); +``` +　　以上代码构建了一个最简单的`HTTP`实例，它拥有以下方法： + +* `sync(String url)` 开始一个同步请求 +* `async(String url)` 开始一个异步请求 +* `cancel(String tag)` 按标签取消请求 +* `cancelAll()` 取消所有HTTP任务，包括同步和异步 +* `request(Request request)` OkHttp 原生请求 +* `webSocket(Request request, WebSocketListener listener)` WebSocket通讯 + +　　为了使用方便，在构建的时候，我们更愿意指定一个`BaseUrl`（详见 [设置 BaseUrl](/v1/configuration.html#设置-baseurl)）: + +```java +HTTP http = HTTP.builder() + .baseUrl("http://api.demo.com") + .build(); +``` +　　为了简化文档，下文中出现的`http`均是在构建时设置了`BaseUrl`的`HTTP`实例。 + +### 同步请求 + +　　使用方法`sync(String url)`开始一个同步请求： + +```java +List users = http.sync("/users") // http://api.demo.com/users + .get() // GET请求 + .getBody() // 获取响应报文体 + .toList(User.class); // 得到目标数据 +``` +　　方法`sync`返回一个同步`HttpTask`，可链式使用。 + +### 异步请求 + +　　使用方法`async(String url)`开始一个异步请求： + +```java +http.async("/users/1") // http://api.demo.com/users/1 + .setOnResponse((HttpResult result) -> { + // 得到目标数据 + User user = result.getBody().toBean(User.class); + }) + .get(); // GET请求 +``` +　　方法`async`返回一个异步`HttpTask`，可链式使用。 + + +**至此，你已轻松学会了 OkHttps 95% 的常规用法！但别急，后面还有更精彩的。** \ No newline at end of file From 64b1227e83e8fe6395cd802889aee925251b694d Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?=E5=91=A8=E6=97=AD?= Date: Wed, 13 May 2020 10:29:52 +0800 Subject: [PATCH 284/924] =?UTF-8?q?v2=E6=96=87=E6=A1=A3?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- README.md | 52 ++++++++++++++++++++++++++++++++++- okhttps-doc/docs/v2/README.md | 8 +++--- 2 files changed, 55 insertions(+), 5 deletions(-) diff --git a/README.md b/README.md index aea850a2..e8068c0e 100644 --- a/README.md +++ b/README.md @@ -9,10 +9,60 @@ Troy.Zhou

-## Documentation +# 文档 官网 http://okhttps.ejlchina.com/ +# OkHttps 简介 + +　　OkHttps 是近期开源的对 OkHttp3 轻量封装的框架，它独创的异步预处理器，特色的标签，灵活的上传下载进度监听与过程控制功能，在轻松解决很多原本另人头疼问题的同时，设计上也力求纯粹与优雅。 + + * 链式调用，一点到底 + * BaseURL、URL占位符、HTTP、WebSocket + * JSON、Xml 等自动封装与解析，且支持与任意格式的数据解析框架集成 + * 同步拦截器、异步预处理器、回调执行器、全局监听、回调阻断 + * 文件上传下载（过程控制、进度监听） + * 单方法回调，充分利用 Lambda 表达式 + * TCP连接池、Http2 + +::: tip +* OkHttps 非常轻量（83Kb，Retrofit：124Kb），除 Okhttp 无第三方依赖，并且更加的开箱即用，API 也更加自然和语义化。 +* OkHttps 是一个纯粹的 Java 网络开发包，并不依赖 Android，这一点和 Retrofit 不同 +* OkHttps 用起来很优美，可以像 RxJava 那样链式用，却比 RxJava 更简单。 +::: + +# 相关项目 + +项目 | 最新版本 | 描述 +-|-|- +okhttps-fastjson | 2.0.0.RC | 与 fastjson 集成 +okhttps-gson | 2.0.0.RC | 与 gson 集成 +okhttps-jackson | 2.0.0.RC | 与 jackson 集成 + +以上是官方维护的与三大 JSON 框架集成的案例，后续将提供 xml 和 protobuf 的集成。 + + +# v2.x 的新特性 + +* HTTP 任务新增`patch()`方法，可发起 PATCH 请求，目前直接支持的 HTTP 方法有：GET、POST、PUT、PATCH、DELETE，并且暴露了`request(String method)`方法，可自定义发起任何请求，如：HEAD、OPTIONS、TRACE、CONNECT 等； + +* HTTP 任务新增`skipPreproc()`和`skipSerialPreproc()`方法，具体请求可跳过 所有 或只跳过 串行 预处理器； + +* 新增`MsgConvertor`接口，实现 OkHttps 与 fastjson 解耦，且不再依赖某个具体 json 框架、甚至不依赖 json，它可以与 **任何格式** 的数据解析框架集成，如：json 、xml 、protobuf 等; + +* 构建`HTTP`实例时支持注入多个`MsgConvertor`，可实现同一个`HTTP`实例下，既有 json 解析，又有 xml 解析等强大特性，同时还可以让表单（form）请求参数 同 json、xml 一样，支持序列化功能。 + +* `HTTP`接口新增`webSocket(String url)`方法，与`sync(String url)`和`async(String url)`一样，支持 Lamda 编程、预处理器机制、消息数据自动序列化和反序列化机制； + +* 新增`OkHttps`工具类，支持 SPI 方式注入配置，`OkHttps`和`HttpUtils`默认自动以 SPI 方式寻找依赖中的`MsgConvertor`； + +* 新增可自定义默认编码（不自定义依然默认为 utf-8）、具体请求可指定特殊编码功能。 + + +## v2.x 的文档续完善中请关注官网：http://okhttps.ejlchina.com/ + +## 以下是 v1.x 的文档 + ## 介绍 　　OkHttps 是近期开源的对 OkHttp3 轻量封装的框架，它独创的异步预处理器，特色的标签，灵活的上传下载进度监听与过程控制功能，在轻松解决很多原本另人头疼问题的同时，设计上也力求纯粹与优雅。 diff --git a/okhttps-doc/docs/v2/README.md b/okhttps-doc/docs/v2/README.md index caecab82..279f47c1 100644 --- a/okhttps-doc/docs/v2/README.md +++ b/okhttps-doc/docs/v2/README.md @@ -22,7 +22,7 @@ description: OkHttps 安装 构建实例 HTTP build 同步请求 异步请求 sy * OkHttps 用起来很优美，可以像 RxJava 那样链式用，却比 RxJava 更简单。 ::: -### 可选依赖 +### 相关项目 项目 | 最新版本 | 描述 -|-|- @@ -30,16 +30,16 @@ okhttps-fastjson | 2.0.0.RC | 与 fastjson 集成 okhttps-gson | 2.0.0.RC | 与 gson 集成 okhttps-jackson | 2.0.0.RC | 与 jackson 集成 -以上是官方维护的与三大JSON框架集成的案例，后续将提供 xml 和 protobuf 的集成。 +以上是官方维护的与三大 JSON 框架集成的案例，后续将提供 xml 和 protobuf 的集成。 ## v2.x 的新特性 * HTTP 任务新增`patch()`方法，可发起 PATCH 请求，目前直接支持的 HTTP 方法有：GET、POST、PUT、PATCH、DELETE，并且暴露了`request(String method)`方法，可自定义发起任何请求，如：HEAD、OPTIONS、TRACE、CONNECT 等； -* HTTP 任务新增`skipPreproc()`和`skipSerialPreproc()`，具体请求可跳过 所有 或只跳过 串行 预处理器； +* HTTP 任务新增`skipPreproc()`和`skipSerialPreproc()`方法，具体请求可跳过 所有 或只跳过 串行 预处理器； -* 新增`MsgConvertor`接口，实现 OkHttps 与 fastjson 解耦，且不再依赖某个具体 json 框架、甚至不依赖 json，它可以与 **任何格式** 的数据解析框架 集成，如：json 、xml 、protobuf 等; +* 新增`MsgConvertor`接口，实现 OkHttps 与 fastjson 解耦，且不再依赖某个具体 json 框架、甚至不依赖 json，它可以与 **任何格式** 的数据解析框架集成，如：json 、xml 、protobuf 等; * 构建`HTTP`实例时支持注入多个`MsgConvertor`，可实现同一个`HTTP`实例下，既有 json 解析，又有 xml 解析等强大特性，同时还可以让表单（form）请求参数 同 json、xml 一样，支持序列化功能。 From 2db058d3f06f3d4ef4da339c0a1f96f50a0eb516 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?=E5=91=A8=E6=97=AD?= Date: Wed, 13 May 2020 10:32:35 +0800 Subject: [PATCH 285/924] =?UTF-8?q?v2=E6=96=87=E6=A1=A3?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- README.md | 6 ------ 1 file changed, 6 deletions(-) diff --git a/README.md b/README.md index e8068c0e..1756934c 100644 --- a/README.md +++ b/README.md @@ -25,12 +25,6 @@ * 单方法回调，充分利用 Lambda 表达式 * TCP连接池、Http2 -::: tip -* OkHttps 非常轻量（83Kb，Retrofit：124Kb），除 Okhttp 无第三方依赖，并且更加的开箱即用，API 也更加自然和语义化。 -* OkHttps 是一个纯粹的 Java 网络开发包，并不依赖 Android，这一点和 Retrofit 不同 -* OkHttps 用起来很优美，可以像 RxJava 那样链式用，却比 RxJava 更简单。 -::: - # 相关项目 项目 | 最新版本 | 描述 From 19b55ed47f01b34106b8f929bea437a47928320e Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?=E5=91=A8=E6=97=AD?= Date: Wed, 13 May 2020 10:35:11 +0800 Subject: [PATCH 286/924] =?UTF-8?q?v2=E6=96=87=E6=A1=A3?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- README.md | 6 +----- 1 file changed, 1 insertion(+), 5 deletions(-) diff --git a/README.md b/README.md index 1756934c..faba8872 100644 --- a/README.md +++ b/README.md @@ -53,7 +53,7 @@ okhttps-jackson | 2.0.0.RC | 与 jackson 集成 * 新增可自定义默认编码（不自定义依然默认为 utf-8）、具体请求可指定特殊编码功能。 -## v2.x 的文档续完善中请关注官网：http://okhttps.ejlchina.com/ +## v2.x 的文档续完善中，请关注官网：http://okhttps.ejlchina.com/ ## 以下是 v1.x 的文档 @@ -160,9 +160,7 @@ HTTP http = HTTP.builder().build(); 　　以上代码构建了一个最简单的`HTTP`实例，它拥有以下方法： * `async(String url)` 开始一个异步请求 （内部通过一个`HTTP`单例实现） -* `async()` 开始一个异步HTTP任务，使用该方法必须在构建时设置 BaseUrl * `sync(String url)` 开始一个同步请求 （内部通过一个`HTTP`单例实现） -* `sync()` 开始一个同步HTTP任务，使用该方法必须在构建时设置 BaseUrl * `cancel(String tag)` 按标签取消请求（内部通过一个`HTTP`单例实现） * `cancelAll()` 取消所有HTTP任务，包括同步和异步（内部通过一个`HTTP`单例实现） * `request(Request request)` OkHttp 原生请求 （该请求不经过 预处理器） @@ -563,9 +561,7 @@ HTTP http = HTTP.builder() * `of(HTTP http)` 配置`HttpUtils`持有的`HTTP`实例（不调用此方法前默认使用一个没有没有经过任何配置的`HTTP`懒实例） * `async(String url)` 开始一个异步请求 （内部通过一个`HTTP`单例实现） -* `async()` 开始一个异步HTTP任务，使用该方法必须在构建时设置 BaseUrl * `sync(String url)` 开始一个同步请求 （内部通过一个`HTTP`单例实现） -* `sync()` 开始一个同步HTTP任务，使用该方法必须在构建时设置 BaseUrl * `cancel(String tag)` 按标签取消请求（内部通过一个`HTTP`单例实现） * `cancelAll()` 取消所有HTTP任务，包括同步和异步（内部通过一个`HTTP`单例实现） * `request(Request request)` OkHttp 原生请求 （该请求不经过 预处理器） From b86a2728618e9b3372e47b87d6075320443930d9 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?=E5=91=A8=E6=97=AD?= Date: Wed, 13 May 2020 10:38:25 +0800 Subject: [PATCH 287/924] update README.md --- README.md | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/README.md b/README.md index faba8872..81a52566 100644 --- a/README.md +++ b/README.md @@ -53,7 +53,7 @@ okhttps-jackson | 2.0.0.RC | 与 jackson 集成 * 新增可自定义默认编码（不自定义依然默认为 utf-8）、具体请求可指定特殊编码功能。 -## v2.x 的文档续完善中，请关注官网：http://okhttps.ejlchina.com/ +## v2.x 的文档将在官网中持续完善，请关注：http://okhttps.ejlchina.com/ ## 以下是 v1.x 的文档 From 347432ed2d190ea3f7bac9827d8b2f347bb10de8 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?=E5=91=A8=E6=97=AD?= Date: Wed, 13 May 2020 11:05:34 +0800 Subject: [PATCH 288/924] v2 doc --- okhttps-doc/docs/v2/README.md | 1 - okhttps-doc/docs/v2/android.md | 2 ++ okhttps-doc/docs/v2/configuration.md | 2 ++ okhttps-doc/docs/v2/features.md | 2 ++ okhttps-doc/docs/v2/foundation.md | 2 ++ okhttps-doc/docs/v2/getstart.md | 2 ++ okhttps-doc/docs/v2/updown.md | 2 ++ 7 files changed, 12 insertions(+), 1 deletion(-) diff --git a/okhttps-doc/docs/v2/README.md b/okhttps-doc/docs/v2/README.md index 279f47c1..a589f702 100644 --- a/okhttps-doc/docs/v2/README.md +++ b/okhttps-doc/docs/v2/README.md @@ -32,7 +32,6 @@ okhttps-jackson | 2.0.0.RC | 与 jackson 集成 以上是官方维护的与三大 JSON 框架集成的案例，后续将提供 xml 和 protobuf 的集成。 - ## v2.x 的新特性 * HTTP 任务新增`patch()`方法，可发起 PATCH 请求，目前直接支持的 HTTP 方法有：GET、POST、PUT、PATCH、DELETE，并且暴露了`request(String method)`方法，可自定义发起任何请求，如：HEAD、OPTIONS、TRACE、CONNECT 等； diff --git a/okhttps-doc/docs/v2/android.md b/okhttps-doc/docs/v2/android.md index 73c7fde5..36c8399d 100644 --- a/okhttps-doc/docs/v2/android.md +++ b/okhttps-doc/docs/v2/android.md @@ -4,6 +4,8 @@ description: OkHttps 安卓 生命周期 UI线程 主线程 IO线程 自由 灵 # 安卓 +#### 哎呀，作者还在加班中，2.x 的文档很快就出来，先看一下 1.x 的文档吧 :joy: + ## 回调线程切换 　　在 Android 开发中，经常会把某些代码放到特点的线程去执行，比如网络请求响应后的页面更新在主线程（UI线程）执行，而保存文件则在IO线程操作。OkHttps 为这类问题提供了良好的方案。 diff --git a/okhttps-doc/docs/v2/configuration.md b/okhttps-doc/docs/v2/configuration.md index 30bf60e9..a2026b82 100644 --- a/okhttps-doc/docs/v2/configuration.md +++ b/okhttps-doc/docs/v2/configuration.md @@ -4,6 +4,8 @@ description: OkHttps 配置 BaseUrl 回调执行器 主线程 UI线程 OkHttpCli # 配置 +#### 哎呀，作者还在加班中，2.x 的文档很快就出来，先看一下 1.x 的文档吧 :joy: + ## 设置 BaseUrl ```java diff --git a/okhttps-doc/docs/v2/features.md b/okhttps-doc/docs/v2/features.md index 56771574..72e4d754 100644 --- a/okhttps-doc/docs/v2/features.md +++ b/okhttps-doc/docs/v2/features.md @@ -4,6 +4,8 @@ description: OkHttps 使用 HttpUtils 类 WebSocket 异常处理 nothrow 异常 # 特色 +#### 哎呀，作者还在加班中，2.x 的文档很快就出来，先看一下 1.x 的文档吧 :joy: + ## 使用 HttpUtils 类 　　类`HttpUtils`本是 [前身 HttpUtils](https://gitee.com/ejlchina-zhxu/httputils) 的 1.x 版本里的最重要的核心类，由于在后来的版本里抽象出了`HTTP`接口，使得它的重要性已不如往昔。但合理的使用它，仍然可以带来不少便利，特别是在没有IOC容器的环境里，比如在Android开发和一些工具项目的开发中。 diff --git a/okhttps-doc/docs/v2/foundation.md b/okhttps-doc/docs/v2/foundation.md index e48cd8af..6679df54 100644 --- a/okhttps-doc/docs/v2/foundation.md +++ b/okhttps-doc/docs/v2/foundation.md @@ -4,6 +4,8 @@ description: OkHttps 请求方法 回调函数 HttpResult cache 多次 消费报 # 基础 +#### 哎呀，作者还在加班中，2.x 的文档很快就出来，先看一下 1.x 的文档吧 :joy: + ## 请求方法 　　同步与异步的`HttpTask`都拥有`get`、`post`、`put`与`delete`方法。不同的是：同步`HttpTask`的这些方法返回一个`HttpResult`，而异步`HttpTask`的这些方法返回一个`HttpCall`。 diff --git a/okhttps-doc/docs/v2/getstart.md b/okhttps-doc/docs/v2/getstart.md index 7b75628c..04c3cd11 100644 --- a/okhttps-doc/docs/v2/getstart.md +++ b/okhttps-doc/docs/v2/getstart.md @@ -4,6 +4,8 @@ description: OkHttps 安装 构建实例 HTTP build 同步请求 异步请求 sy # 起步 +#### 哎呀，作者还在加班中，2.x 的文档很快就出来，先看一下 1.x 的文档吧 :joy: + ## 安装 ### Maven diff --git a/okhttps-doc/docs/v2/updown.md b/okhttps-doc/docs/v2/updown.md index 73486bac..679efd46 100644 --- a/okhttps-doc/docs/v2/updown.md +++ b/okhttps-doc/docs/v2/updown.md @@ -4,6 +4,8 @@ description: OkHttps 文件 上传 下载 进度监听 过程控制 断点续传 # 上传下载 +#### 哎呀，作者还在加班中，2.x 的文档很快就出来，先看一下 1.x 的文档吧 :joy: + ## 文件下载 　　OkHttps 并没有把文件的下载排除在常规的请求之外，同一套API，它优雅的设计使得下载与常规请求融合的毫无违和感，一个最简单的示例： From f62709aef38ce1591c658271257a40f56d8aaf8e Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?=E5=91=A8=E6=97=AD?= Date: Wed, 13 May 2020 11:18:13 +0800 Subject: [PATCH 289/924] v2 doc --- okhttps-doc/docs/.vuepress/config.js | 2 +- okhttps-doc/package.json | 4 +--- 2 files changed, 2 insertions(+), 4 deletions(-) diff --git a/okhttps-doc/docs/.vuepress/config.js b/okhttps-doc/docs/.vuepress/config.js index ab1603b0..6ad753aa 100644 --- a/okhttps-doc/docs/.vuepress/config.js +++ b/okhttps-doc/docs/.vuepress/config.js @@ -51,7 +51,7 @@ module.exports = { }, // 若全局使用 vuepress，back-to-top 就会失效 plugins: [ - '@vuepress/back-to-top', 'code-switcher', 'baidu-autopush', 'seo', + '@vuepress/back-to-top', 'baidu-autopush', 'seo', ['baidu-tongji', {hm: '6eb41c0ab450d5a4ae8769682ecb0ab2'}], ], markdown: { diff --git a/okhttps-doc/package.json b/okhttps-doc/package.json index f9d1f6a9..338b4466 100644 --- a/okhttps-doc/package.json +++ b/okhttps-doc/package.json @@ -7,11 +7,9 @@ "@vuepress/plugin-back-to-top": "^1.4.1", "vuepress": "^1.4.1", "vuepress-plugin-baidu-autopush": "^1.0.1", - "vuepress-plugin-baidu-tongji": "^1.0.1", "vuepress-plugin-seo": "^0.1.2" }, "dependencies": { - "vuepress-plugin-code-switcher": "^1.0.3", - "vuepress-plugin-smartlook": "0.0.6" + "vuepress-plugin-baidu-tongji": "^1.0.1" } } From 23a4c268005bd59cd2d32eefe2f649b5e7ee3da6 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?=E5=91=A8=E6=97=AD?= Date: Wed, 13 May 2020 17:22:58 +0800 Subject: [PATCH 290/924] =?UTF-8?q?v2=20doc-=E8=B5=B7=E6=AD=A5?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- .../.vuepress/public/spi_config_android.png | Bin 0 -> 11143 bytes okhttps-doc/docs/README.md | 52 ++--- okhttps-doc/docs/v2/getstart.md | 204 ++++++++++++++++-- .../com/ejlchina/test/WebSocketTests.java | 16 +- 4 files changed, 212 insertions(+), 60 deletions(-) create mode 100644 okhttps-doc/docs/.vuepress/public/spi_config_android.png diff --git a/okhttps-doc/docs/.vuepress/public/spi_config_android.png b/okhttps-doc/docs/.vuepress/public/spi_config_android.png new file mode 100644 index 0000000000000000000000000000000000000000..82db91236b3e6aab516b7a0fd37163abf4c314a8 GIT binary patch literal 11143 zcmb_?XH-+`)@}f$iZqd}NR@zerGwHzIw(jFguSImk3i_51}Q2{AX0=)??FQ`bPc-c zAOd2jMu|w5-r=r9-DjV1&mDJ+?>j#T$(yV>=bGi2&wSS#f6G{hk^Uk*2n1r()73Hs zfhZv$5XBilqz(eTNMbnr{WS2I4yJ4E3j&?( zApKEvdY3tZK%$rQwAAke+Alxzd?e6`$eXKGv8H9+Wn&jOPZfBI>Nce&v%{&nl&-7y zz-ltrm?>_myrWeUxaB9O@kaMXfxT`#t<&Y;NP$}vv=1-}35}xFMUy>gZwlXBH?8yA zoEmSuJ`_^09Vm4nRnQVscYX(w84foOFb{y6>=+Ij8ZB>tR9F1qaQN1efpXQt;)P4x z+#(vZd`Mi3iQv`lwou2ObuFt@_A|LR==gFFS8WYGYp`rA(aW2;kdc2Mr)lpez z**e~7hw9iHWG*pqv1y)XL04MVROoOAY3bOv9yG#&{EFgUKAY1^&$ralQ|(Wuz_ z@UpE~<$EMk*-qO|>q6VXirJSnE3%9yO8Ix2zlO{l5 z!oq^MDr#56_#q*d#~R^Bg~QOAA_yvZgpFjJg%HGKs@SV>{ycolEE0kAP}3@!-pJi4 zGeInvxrK*AQPy-RW2S-!MFW^3cYA!Q9}5~~AFPMiX`UIaX+JqytuzVW9}eP~txxM# zDZdP#x;vI06l37nn_zC;;IVgec7L^8er9cB0Ws!uP`mIfphXiQaYr&~N^;@fm&8U?t3(*GdGJL6eW%){?YFO)c9K%91 z&!Iz@ryS4GHywBn(bO`LuD-sWYu%TxZ|7G#?wZ^n>Y-XBP@`Z{Lez1fUAdc<1>wDRCW>&23&@96 zl0IfFV#P7rG5m1i(|2v~;%Zno&x7GolgjI>Ez+n8q1-_J8Oa*Y#*vgJpGOmaDZTGB z+Mpe4Vy%UB@1c0_3-&Tg#EaTVwjNqmI~jb|r<|AcrAMXb#g2GlCIfrz7KH6OJ?0vX zlpQCAr5y+S%h8fPM8rvlx4bG8F$*?T$Ckyw4e>h+O{*5w(qkf7!;yO&A9dXh79+ud4iLQU1Cji?g$%I%r9 zaDLnAYtskzUSoCFY9+O+{19KdOY8h%7Leqk{R%PdL-w+XT-M7~Q1-LE-N`0VzSxs< zJ%s&UscEU5gk95}kdt_z&NOwe(4yKU!G!%S=n3j|9UIz1t*YntpOD@(F2jB`HyRUB z8+F3{yVR?p4V^6M2?Bd_6^nPjALr}a%5KdbGAU4gvMbD1<7sIcfPeGZx#*HJlRZT5 z9fI%~T(omBDhex{?Q3c%IYv2SDOW>?HcGT8-Ha{^6keQ+HS@6H&}Y1vaS(Io+?-%E z%$3D=VxRyl`Z2Mn8K##Tw(p8ieS8!xUQ;Y~2bJ9Pyy)q4Y5{wNH62%Wsn^xB8O>6> z(XQ4aSq(;;Y7&$L9j1@zug6=^><`uzi^83o-&+_d4}S=))ml0D-CmV<%u=Oo{?Lol zv!U1NeZwZcom;YgHBWDDwSGyo!97NFWTmQ2;l++eykE@9yjudPeEe)oH+SmUC5CTW zV;3?`hn$z_ZuFhoR2@ZiE#BhN$if+I%umU9$B4)@gRK)`_{fGEw1eYvt`}ire2^yl zsWXqCWUj`xLnS?w!fU1wy(|)s%IzVLMlP4@(1Gld$@Y?B0e%lY=phoZscQQMNjPw~W4V=J9jokPA&7r-*GU`=<`vpq;8eD6LnY|%fV>G&X}-mEL8S`?l&uqx(qk!9_rQFCy)l;5;r;5tHf z$9g_ai|DBUhi9Ry8&9@yPA@&Phwmy)%cy#5VARf=M8mdnFfbNOBuh#vUesD@wh-~T zC)gRwuOIYW5NJAH9cEd#Ar_?H4)!1o292*tYqQ3QvG*KVlaQ)f4`>uy^^dTRfQBR- z76>N;0O#G!z5#mbFa14&45-c48)gT< z*!6jt*Ak>5)2W}`91X}dn;{87CSM`7?{RYb1e$hEGVqct_n#ZNMrs`G7$Q6{iy7lU z(#3?+rq$#BSN9#rQ>~%pa~uYG{(F<$&~-fw^2|Aq8f6@;JdfMMZ#H^MlQ@PJ*3d=L z9kqQpO`wbrPy@PtrSZ3&dI?$%kN^cB&>F7MUISOhf_UiwBG6UAwvVW0z?}x^MF4hM zJbSn5ZpSPE(xpU-PKAE{5P9(oW^z9s_Usr_YCHuA$c=A;Up37uOY=6(La!DHgfJ}) zj`WvqCm^7lmD$%1b7I1vi%~ENHC7phu@m#~^>;#}LaKXuTb-5~2VZD$qiN>xIDXuy z-%^5hXPl<_9nSr=_>_y2H!PsNy*+Tta0J?eiCPoB;7$mBX4+^h)O!wHT`g{os&yH3 z4)1pU{(Ys;-Z)RO6wM8h51{~Mn6$#;J(SCiXJZVTn9)Z470BZG8`=Dj_a<`?8~&;) zna#^0gr0HENhP`^TQTT$*`?|!(mhg7OiZZbQ`b8>I+i5yXL@i>zOEg@D#y)$~ z$xy=jiTBKfU3X_`M~B9}5i6!PspMR#&X*U@EjsHu-r64Tq7G;l`?B-G6DpOW2&T$c z9I*X5RDR)|yNi!=(YC_LjbPZo4ktlsHS*2&@P~~jdd9P1N*{{H9|)!po9sw`HNtn|zb@2#p!GqvJ(i83A=iq+^9q z)Y9Y8cY8OJ1WO>xJ@CoybcV}}p2-57rK_h0VLt^p?;^qN__%+cJ0?kzwdt(u@Lpqf@D~QVX>=B z?(x{w?mijc62r2DW#MPrRBAoE5N$jTXMQ2Da%g!Hq7qP^H{dWf$st_Hljh!Qvnicc zAgOI_jrBT0ZkA8RnyOmzLV~KgGWNOjr?#9{;T>Dm>e%(P8WZp4PIlM7tysyct2rn& zJA4!i)I&kc;_j~1^2&-EKD7oj6_adOug4YgWj;Fv`c(4H@uPHGId@f1k>NNlossgj zx(3q~r*2`S;Pso-`IymoW7sRXo?4HM7`&|aLGfHits2* zUt?_Sdv4I&5OL*2aoEC9m@2~y;hwCW`bPgJul9ml+YS%h8mLzH7SNK{1IF_9QMO=9zp7e+PVE7v*tht4`H-dB+G zg#>c~xPl*HuoSde*Nx+c-U?@_YMz#v>PTl&8*We84!?P%-j~5ab(@p$9$wNJMD<9E z>CV93QbggPIrmaRq}-D#F}%^bwQ4pH>Vd||ZPBr3;8kxsRU@~Wny<>0XRsyqLxW#m zPp&3Sculo=joG&)+Si!a4>F@i?V%kn>c`{{Lhc-jop;J_)Ab0S%v%(*&d#41YYH4B zGzDJcRTrnF%iv6@<~iJC-^$B9fG$9nW(wPniS9L7gsJ~(qP2K~6-hR;&S#6H`|;%-wI*{>Z%SOGpMng5oIgW;2o-z~Nqfq`?Z_O}=CF6oANEq*h@rM3P~T ztYq{V{LmMIy$B%ppWMiY%$NlvkXjfi0wu^w5awg#cT^tu6mlaOBg5p2Ci!4Jf3Nf|x z_6~KN7`6Hn4PH0(E0!A1Y@COm4Cf=H*Q1##LyRAf%=2_@&y5_FPFLri9er}+$P2!Z z%T&pO+-A`TrUULv_}xR8^6{?aD1i_Veb7`S29c|=+nss6zXi;wdSF@(t=9~L*&Lva zp@%R}PtWq@Wl#9=q5SC3(5S;Rpmkbg-dJ+!7_;)PA0TUCJ=Ox;e0p}zaQxl@<`D<;w5AlXr0ciM} zCD6CO-XnXz;$muF-_-!B2e7RNxtJzuAjQd^R`K4y8s>x{4rD1KRB_r}m}uB*o4w@; z27Kz|`a?YHWi=hvJVJ$VwhmUKH&#rT6|>0;c`kRn6eVdZ$8&%%qxe%<=o_~LpxNjQ z?zHpopi8&qM54wuL z;<-lo#k|A9=MFJA#?5!EKQqZnIN%ud+-fw2^IJX;V?Kce;8vw_8$YYg)_DQ~Y)Jg0 z;4JR6sOFn){j^a30#WmPEFAd8`R{KClk!scQ#lF5t*TB9-C61LOu7BJHwPIvuSS={ zC_ry|kB^V{b0&0u^57J`9oi@<%3YMJN zm8do6>-M=^>i`lbRfHRG9cL{!)7rCAL+uDWF9gI)a^mBrLDRYvC#{H#zgK3I+0Tn} zdZosm)dEA9R#g^=o0+}~3$Nj|FB#ZmFFqTy>~5A@zt#_Uir99^NMsUpmyfOK2q zW?b9mVAV6yI$`JGV3l$KTLcTO4xZ_g>K2tK}i882) z6VRYPRmjJ^n^!`qcAXjhKaTe zF;kSJgOwe?9g-6gcJ9#vQ^}~M;pqr}z`G!j6A+f`(}jG7ASDvF90APm?@4;_=`O@R;9AK#;`E!wSYck~C<(EvTFOdad69GLXr=~wxg-~YJ=C{6zULggyW&s1>lM93h; zM8m!t*HZnd{P$vr%o`cZ8`^g)NCr>=Q1@40JdD?Z-kqcTC7qXkT}QJeH)$)fQSC?W z#8DpHqumSSX)I;<^YU#v%e~7X|Kh5j1fpQ-=RWFa#=*F5xYJXN4?l!GQx35JAa3;L z_RD+#22tC41ZstHUI_E)y+S^FZvdhI4CLbGu2^1P{?kLRamia#w_*Gg=>2KHp65vq zb`Qck&w>03UxKywG+9{D65(nZQlo;PWPt8#MIvP0sO~nGfd1rcr5hXCjJ^MFOig3y zaje_b-=01i5fC;1LQs1w$R?Y*P6)K&f9m;!pdflWVk;V^E_3)rUSx~uBo`0*cC$vl zAKK{imQ4b`qM=(dUWA*rV)X6y=|)yEU*&ruF2KNR%q$T{4LBh}@tZj|F)3+uWd)rf zz9%waM@z!S7t$7*#E`US1gUJC<7}TFg_;L&vy9tA%pl))l`y(7wB0Zc3~eSOap%B2 z>opB5NRAQ7P@wLW6TT?Ya>TX`G>C25);G>$)P zU}6>~nXYyRx3&8vsj{O(vsPBsiG&g-Rpl?JEv`VOX#$$dL*3-n4go8ZDR0w_efW?u zK0R$QH<)J$(D9PG>wI{(C&ieh3uO)mKcL7iO<9)v?724TMG#OJ=i-d99{&FRBg9_R z=wnX#zUgg}Co|}Ar>}C5wbub{w7I$R2-TC^P$@t_(5Kgud z@o>af{RIhH95q<~GZ zB{B`(z+852%HlpZv@OABr_pW?<3_v$>Lrcu=i>CS`}{x%C_!sv;{}9)n4cxZ=)akn z|B?mBCnhZ^BEIG{1;eJ6?5Or@8Kws9PDM2QN;Z70%jky>7M_mboWEw~yKjLneaTe< zpml6)tXoLP^((ff5(g8^snv265xYO4Z)=*Ss=!BBSdYE(k6Y3bg8W}YWQE~~ZU&_g zMnK_KwChbaVea{{)cj`SGSu1H^%gICm8=HAr*fULo}dUC5}#xy8f{pjA!|s3hGu3G zhvWB=NiQH+xq>kTPDVX!40Ok_9HqS!!jOk_;b1G2!6?7p9U4rEFyVW77Gn*JM0ZlBtrp+mhwlC4$8 zo5gugTe;rl6?e^nDf_5Mu1zi?QS~ni-@m`}=r^&(dJMFFziUrtX;aGh^qJL(&JW@CY_pjQrS36>45j zGM20m+<1YsG<}^eR4emTk}Knln^ezsJY)~PkVK(-fgBBMLc#)6xG8E@oU=zFv)*S` zZ{e(tn~Wd#+2Ws3w#o8nuo{as-S7t@_9`@&YyyVjkcBGO(P$*o)3 zqz+1H5b?8gcp;){k`zh?QJ{C+BxN9ijo|(oBj!xk()m}wtOH;@kUAvl3KEX^L4y8Q zOO{ms##%W*78JiM+aiqqYB?03UTTs9bxpAi4GkmP+YL(L$1O@qN>asBweLq+Lo)lOz-C(NaPAmmS;pHwQ z)|&oKBCdPi-4(jYB86^ZJtQDl2e*DfQe41n63`s2h6fceF;S;=pQ;DC=Of6b{fKR& zYtm)2jP5RgWTy7}05sOJ3uFw;#Q;+7z+{RX4O1Z&$O}0_-8oTTSeYk?LNc=A;{0&uyjNJ ziqA54Vmht(Qc>XhJ>3Fb={&L**q0la(a9}A%dTJNIbZqwz>M>xhvW4CJ#jK<>+$E% zkRp~SCqB2TyMnha;Lkk#hzDB+mvmj*>q{$Ee?W;dpVusI6$Vs0=>3Q#0}8f0E-MaM zuNNhaevq(FmQic-yw|z$_Zufi=u!BYQW$)h^Hu6Ei28-*semF1Jn;B{lq0kEMD)M3 zOe)JgKlQCA<$RS!1SX{VBC_&*Z2UzRXL+3&PzE`|Fn$sVO(ou>?f23Pb$g@5VEV#w zj=}i0%J;K%2ElRzk3O8+d9Y2mlX}qwd#Z-X*w%OJrajM{mYO;bgnpf}`SK>ZDm3 z*y(bo{x<@GW!>6S4KqZztYQ*d{CCpLij&!(UL{uX^J3C)9Jn*fNv@_p7>5H(YBN6z z>*Is$Ej>$|fYv^8GgWT4b8fYpQkn9fk)A5q)ZD2t%7zn-j-s`H^lS8a$j|X9O7!-i z^2v!|x#{2$kzu;cr$WJp|9vXcQt^6f-#PxPMsGdbkiG6Y3w>>!zM1)1>cPf`t&>FHcqC7P>aywNKAbMJMp2dO4FB53Ou zb)Sgpt+>~CpM5-6G0(F}`2*MLXUFT^ZLqWMmXP>VYw=zUX-HH`^b1iX-)=)|EF|A& z_{PIwF^E~+N5kG0&iRSWq14g-w>!y3D?4#xUBIkVTjp!$TR1y+XlC;amo(t zG;dWRvJ9OhCOqy1D41Rj3C|Mmt$8{5RqHYQ?Sp^1#6pdPR{HR(W0YTP)wG=ttt-}- z49u}wIU0l06{0WeSkNsdc1ZUGm6xs5FEMD#B~kx=h45m=Ipy!;RiZl+=w%);UdjJe#qyZk-B74INQ4L*MT<|{r;<=DMm&dfSDoV?t)?GnZw-f^ zWb3!Cxr`F_ylECU0jk1l$Bbqiyqu(rZdbt`g^LJ}fgRau&k|CLI|{FdTRzNans*sV zT5XrKs#yi@V?GMz3DW`&gQPq4X6WR3Pot;(ItR-G5M~Xl=HBgqY9@`XbzLso_H#AW z=8m?liz|`A2Pln$i~E^c829iguHnTzu^j}o9(J^A#$y(K@HM;so?fE&k<(V8j`18F z*RUl(kNwoKax%Zpyy);C-Mdr59RDcVSPP+oH_b8R?KKuugWFdtS-^`Wf2ouAeqRIBJMr*!CrxYJuwd_biIn`Ys^|YwJ}e;5^}cOOa;34+i>jQxw%bL!(_u@u>FkRRKarawY7s!?L6Sy7|(^{ zk*(U1=_zls_9f35bX)Sv#WDCn8ESJK;gx4N8&WVKk{;sP)Zliqd?17&a(!uCCHfn2 zN*|c!O~)+m&5fF@wAvmme=m9du_(hf>_u|jOt1@|Yw9pmOkg=v)Y%FY;S>S$bf~&@ zG+r}xvCo6hL;a@W(&?UhL;UNJGe!R2>k8P#j5xb@3b82u@56B@6T9%LexME z1aRP_AnaO(e9T+q?tPcxu!C)l_bS^5#~v4Zb3xT=Sh=efWzJx~D&r}KOJV^|YShD+ zJ2IZx-y$KWa7o_pEHeRWUz{7FY2N~-sq<0p4IT8^<0=-zJ0Mzd!fUIL{z z@!sVmxMid*T<}@@7^dbUnjL+sxprUbGGY)`{Ux`0di}v!Ivx` zH;>pW-YsPmg%dDTomjYn$-b|+zu zxWa?7q>TgHkgy%B&-DTSwj6n*#-vqxuEnh>?l0TFXStr#E@r|#jgDp}!EbN%3{E8o zuD>%6Xebl*KksVMb{yA!$%-R`jv|>kYdQqT4{Eaymm>|9smVkrYcJ*XeydSGO>*PA4|WBbxY0Xwhh6!wUzm&H za9muw=lG~Wdj5tp?#XIpLX%wMj~Pht%A?Q?}i#qIq2L}Gfs#wH=`!i$p9C4v${ z%j{=>ZcJ8!oE1rX_hLu@y6}g8Wfo%|VLjs<#}n~xCE$rp&B^!3!)vTQPY`9sc|R^7 zfi#>Rl^ArZqA##}(cxJxz&(J0PMbDf$(=)jtue`9WsQD$@m~B}q<->?1d*RJ{QIsB*WQK;dZ7lG(rkcn;pbEVSNnC4Q6Jd2 zbx^PfajumPxhs3=%qSKesXdVwtDm<$5(w;@yapz$k}D#DZZf|aoiLE6xPG1T6Q+=e X%2QHOL1Vz-S&*K#u@+jxA?p7CHC??a literal 0 HcmV?d00001 diff --git a/okhttps-doc/docs/README.md b/okhttps-doc/docs/README.md index c57380ab..7f4e3b61 100644 --- a/okhttps-doc/docs/README.md +++ b/okhttps-doc/docs/README.md @@ -1,7 +1,7 @@ --- home: true heroImage: /logo.png -heroText: OkHttps +heroText: OkHttps V2 tagline: 基于 OkHttp 增强版 HTTP 客户端 actionText: 极速上手 → actionLink: /v2/ @@ -20,52 +20,30 @@ footer: Apache Licensed | Copyright © 2020-present ejlchina