diff --git a/EasyHttp.apk b/EasyHttp.apk
index a82c03b..2ea264c 100644
Binary files a/EasyHttp.apk and b/EasyHttp.apk differ
diff --git a/EasyHttp.jpg b/EasyHttp.jpg
index 9b3fed7..fd756ba 100644
Binary files a/EasyHttp.jpg and b/EasyHttp.jpg differ
diff --git a/HelpDoc.md b/HelpDoc.md
index 5ed841f..a7acaf7 100644
--- a/HelpDoc.md
+++ b/HelpDoc.md
@@ -1,10 +1,266 @@
+# 目录
+
+> 文档大致分为三类
+
+* [集成文档](#集成文档)
+
+* [使用文档](#使用文档)
+
+* [疑难解答](#疑难解答)
+
+# 集成文档
+
+#### 配置权限
+
+```xml
+<!-- 联网权限 -->
+<uses-permission android:name="android.permission.INTERNET" />
+
+<!-- 访问网络状态 -->
+<uses-permission android:name="android.permission.ACCESS_NETWORK_STATE" />
+<uses-permission android:name="android.permission.ACCESS_WIFI_STATE" />
+```
+
+#### 关于 Http 明文请求
+
+> Android P 限制了明文流量的网络请求，非加密的流量请求都会被系统禁止掉。
+如果当前应用的请求是 http 请求，而非 https ,这样就会导系统禁止当前应用进行该请求，如果 WebView 的 url 用 http 协议，同样会出现加载失败，https 不受影响
+
+> 在 res 下新建一个 xml 目录，然后创建一个名为：network_security_config.xml 文件 ，该文件内容如下
+
+```xml
+<?xml version="1.0" encoding="utf-8"?>
+<network-security-config>
+    <base-config cleartextTrafficPermitted="true" />
+</network-security-config>
+```
+
+> 然后在 AndroidManifest.xml application 标签内应用上面的xml配置
+
+```xml
+<application
+    android:networkSecurityConfig="@xml/network_security_config" />
+```
+
+#### 服务器配置
+
+```java
+public class RequestServer implements IRequestServer {
+
+    @Override
+    public String getHost() {
+        return "https://www.baidu.com/";
+    }
+
+    @Override
+    public String getPath() {
+        return "api/";
+    }
+
+    @Override
+    public BodyType getType() {
+        // 参数以 Json 格式提交（默认是表单）
+        return BodyType.JSON;
+    }
+}
+```
+
+#### 框架初始化
+
+> 需要配置请求结果处理，具体封装可以参考 [RequestHandler](app/src/main/java/com/hjq/http/demo/http/model/RequestHandler.java)
+
+```java
+OkHttpClient okHttpClient = new OkHttpClient.Builder()
+        .build();
+
+EasyConfig.with(okHttpClient)
+        // 是否打印日志
+        .setLogEnabled(BuildConfig.DEBUG)
+        // 设置服务器配置
+        .setServer(server)
+        // 设置请求处理策略
+        .setHandler(new RequestHandler())
+        // 设置请求重试次数
+        .setRetryCount(3)
+        // 添加全局请求参数
+        //.addParam("token", "6666666")
+        // 添加全局请求头
+        //.addHeader("time", "20191030")
+        // 启用配置
+        .into();
+```
+
+> 上述是创建配置，更新配置可以使用
+
+```java
+EasyConfig.getInstance()
+        .addParam("token", data.getData().getToken());
+```
+
+# 使用文档
+
+#### 配置接口
+
+```java
+public final class LoginApi implements IRequestApi {
+
+    @Override
+    public String getApi() {
+        return "user/login";
+    }
+
+    /** 用户名 */
+    private String userName;
+
+    /** 登录密码 */
+    private String password;
+
+    public LoginApi setUserName(String userName) {
+        this.userName = userName;
+        return this;
+    }
+
+    public LoginApi setPassword(String password) {
+        this.password = password;
+        return this;
+    }
+}
+```
+
+* 可为这个类的字段加上一些注解
+
+	* @HttpHeader：标记这个字段是一个请求头参数
+
+	* @HttpIgnore：标记这个字段不会被发送给后台
+
+	* @HttpRename：重新定义这个字段发送给后台的参数名称
+
+* 可在这个类实现一些接口
+
+	* implements IRequestHost：实现这个接口之后可以重新指定这个请求的主机地址
+
+	* implements IRequestPath：实现这个接口之后可以重新指定这个请求的接口路径
+
+	* implements IRequestType：实现这个接口之后可以重新指定这个请求的提交方式
+
+#### 发起请求
+
+> 需要配置请求状态及生命周期处理，具体封装可以参考 [BaseActivity](app/src/main/java/com/hjq/http/demo/BaseActivity.java)
+
+```java
+EasyHttp.post(this)
+        .api(new LoginApi()
+                .setUserName("Android 轮子哥")
+                .setPassword("123456"))
+        .request(new HttpCallback<HttpData<LoginBean>>(activity) {
+
+            @Override
+            public void onSucceed(HttpData<LoginBean> data) {
+                ToastUtils.show("登录成功");
+            }
+        });
+```
+
+#### 上传文件
+
+```java
+EasyHttp.post(this)
+        .api(new UpdateImageApi(file))
+        .request(new OnUpdateListener<Void>() {
+
+            @Override
+            public void onStart(Call call) {
+                mProgressBar.setVisibility(View.VISIBLE);
+            }
+
+            @Override
+            public void onUpdate(long totalByte, long updateByte, int progress) {
+                mProgressBar.setProgress(progress);
+            }
+
+            @Override
+            public void onSucceed(Void result) {
+                ToastUtils.show("上传成功");
+            }
+
+            @Override
+            public void onFail(Exception e) {
+                ToastUtils.show("上传失败");
+            }
+
+            @Override
+            public void onEnd(Call call) {
+                mProgressBar.setVisibility(View.GONE);
+            }
+        });
+```
+
+#### 下载文件
+
+> 下载缓存策略：在指定下载文件 md5 或者后台有返回 md5 的情况下，下载框架默认开启下载缓存模式，如果这个文件已经存在手机中，并且经过 md5 校验文件完整，框架就不会重复下载，而是直接回调下载监听。减轻服务器压力，减少用户等待时间。
+
+```java
+EasyHttp.download(this)
+        .method(HttpMethod.GET)
+        .file(new File(Environment.getExternalStorageDirectory(), "微信.apk"))
+        //.url("https://qd.myapp.com/myapp/qqteam/AndroidQQ/mobileqq_android.apk")
+        .url("http://dldir1.qq.com/weixin/android/weixin708android1540.apk")
+        .md5("2E8BDD7686474A7BC4A51ADC3667CABF")
+        .listener(new OnDownloadListener() {
+
+            @Override
+            public void onStart(File file) {
+                mProgressBar.setVisibility(View.VISIBLE);
+            }
+
+            @Override
+            public void onProgress(File file, long totalByte, long downloadByte, int progress) {
+                mProgressBar.setProgress(progress);
+            }
+
+            @Override
+            public void onComplete(File file) {
+                ToastUtils.show("下载完成：" + file.getPath());
+                installApk(MainActivity.this, file);
+            }
+
+            @Override
+            public void onError(File file, Exception e) {
+                ToastUtils.show("下载出错：" + e.getMessage());
+            }
+
+            @Override
+            public void onEnd(File file) {
+                mProgressBar.setVisibility(View.GONE);
+            }
+
+        }).start();
+```
+
+#### 同步请求
+
+```java
+try {
+    HttpData<SearchBean> data = EasyHttp.post(MainActivity.this)
+            .api(new SearchBlogsApi()
+                    .setKeyword("搬砖不再有"))
+            .execute(new DataClass<HttpData<SearchBean>>() {});
+    ToastUtils.show("请求成功，请看日志");
+} catch (Exception e) {
+    e.printStackTrace();
+    ToastUtils.show(e.getMessage());
+}
+```
+
+# 疑难解答
+
 #### 如何添加全局参数？
 
 ```java
 // 添加全局请求参数
-EasyConfig.getInstance().addHeader("token", "abc");
-// 添加全局请求头
 EasyConfig.getInstance().addParam("token", "abc");
+// 添加全局请求头
+EasyConfig.getInstance().addHeader("token", "abc");
 ```
 
 #### 如何定义全局的动态参数？
@@ -149,14 +405,29 @@ public class XxxServer implements IRequestServer {
 }
 ```
 
-* 当然也支持对某个接口进行单独配置，和上个问题雷同，这里略过
+* 当然也支持对某个接口进行单独配置
+
+```java
+public final class XxxApi implements IRequestApi, IRequestType {
+
+    @Override
+    public String getApi() {
+        return "xxx/xxxx";
+    }
+
+    @Override
+    public BodyType getType() {
+        return BodyType.JSON;
+    }
+}
+```
 
 * 表单和 Json 方式提交的优缺点对比
 
 |  场景  | 表单方式  | Json 方式 |
 | :----: | :------: |  :-----: |
-|    参数嵌套   | 不支持 | 支持 |
-|    文件上传   | 支持 | 不支持 |
+|   参数嵌套  |  不支持  |   支持  |
+|   文件上传  |   支持  |  不支持  |
 
 #### 如何忽略某个参数？
 
@@ -264,11 +535,97 @@ public final class XxxApi implements IRequestApi {
 #### 如何设置超时重试？
 
 ```java
+// 设置请求重试次数
 EasyConfig.getInstance().setRetryCount(3);
+// 设置请求重试时间
+EasyConfig.getInstance().setRetryTime(1000);
+```
+
+#### 如何设置请求超时时间？
+
+* 全局配置（所有接口都生效）
+
+```java
+OkHttpClient.Builder builder = new OkHttpClient.Builder();
+builder.readTimeout(5000, TimeUnit.MILLISECONDS);
+builder.writeTimeout(5000, TimeUnit.MILLISECONDS);
+builder.connectTimeout(5000, TimeUnit.MILLISECONDS);
+EasyConfig.with(builder.build())
+        .into();
+```
+
+* 局部配置（只在某个请求生效）
+
+```java
+OkHttpClient.Builder builder = EasyConfig.getInstance().getClient().newBuilder();
+builder.readTimeout(5000, TimeUnit.MILLISECONDS);
+builder.writeTimeout(5000, TimeUnit.MILLISECONDS);
+builder.connectTimeout(5000, TimeUnit.MILLISECONDS);
+
+EasyHttp.post(this)
+        .api(new XxxApi())
+        .client(builder.build())
+        .request(new HttpCallback<HttpData<Void>>(this) {
+
+            @Override
+            public void onSucceed(HttpData<Void> data) {
+
+            }
+        });
 ```
 
 #### 如何设置不打印日志？
 
 ```java
 EasyConfig.getInstance().setLogEnabled(false);
+```
+
+#### 框架指定只能传入 LifecycleOwner，我想传入其他对象怎么办？
+
+* 其中 AppCompatActivity 和 AndroidX.Fragment 都是 LifecycleOwner 子类的，这个是毋庸置疑的
+
+* 但是你如果传入的是 Activity 对象，并非 AppCompatActivity 对象，那么你可以这样写
+
+```java
+EasyHttp.post(new ActivityLifecycle(this))
+        .api(new XxxApi())
+        .request(new HttpCallback<HttpData<XxxBean>>(this) {
+
+            @Override
+            public void onSucceed(HttpData<XxxBean> result) {
+
+            }
+        });
+```
+
+* 如果以上条件都不满足，但是你就是想在某个地方请求网络，那么你可以这样写
+
+```java
+EasyHttp.post(new ApplicationLifecycle())
+        .api(new XxxApi())
+        .tag("abc")
+        .request(new HttpCallback<HttpData<XxxBean>>(this) {
+
+            @Override
+            public void onSucceed(HttpData<XxxBean> result) {
+
+            }
+        });
+```
+
+* 但是你需要注意，传入 ApplicationLifecycle 将意味着框架无法自动把控请求的生命周期
+
+* 如果你采用了这样的写法，那么为了避免内存泄漏或者崩溃的事情发生
+
+* 需要你在请求的时候设置对应的 Tag，然后在恰当的时机手动取消请求（一般都在销毁或者退出的时候取消请求）
+
+#### 如何取消已发起的请求？
+
+```java
+// 取消和这个 LifecycleOwner 关联的请求
+EasyHttp.cancel(LifecycleOwner lifecycleOwner);
+// 取消指定 Tag 标记的请求
+EasyHttp.cancel(Object tag);
+// 取消所有请求
+EasyHttp.cancel();
 ```
\ No newline at end of file
diff --git a/README.md b/README.md
index aff36ab..68a5348 100644
--- a/README.md
+++ b/README.md
@@ -8,225 +8,71 @@
 
 #### Gradle 集成
 
-	android {
-	    // 支持 JDK 1.8
-	    compileOptions {
-	        targetCompatibility JavaVersion.VERSION_1_8
-	        sourceCompatibility JavaVersion.VERSION_1_8
-	    }
-	}
-
-    dependencies {
-        implementation 'com.hjq:http:8.2'
-	    implementation 'com.squareup.okhttp3:okhttp:3.12.10'
-	    implementation 'com.google.code.gson:gson:2.8.5'
+```groovy
+android {
+    // 支持 JDK 1.8
+    compileOptions {
+        targetCompatibility JavaVersion.VERSION_1_8
+        sourceCompatibility JavaVersion.VERSION_1_8
     }
+}
+
+dependencies {
+    implementation 'com.hjq:http:8.6'
+    implementation 'com.squareup.okhttp3:okhttp:3.12.12'
+    implementation 'com.google.code.gson:gson:2.8.5'
+}
+```
+            
+#### 具体用法[请点击这里查看](HelpDoc.md)
+    
+#### 不同网络请求框架之间的对比
 
-#### 配置权限
-
-    <!-- 联网权限 -->
-    <uses-permission android:name="android.permission.INTERNET" />
-
-    <!-- 访问网络状态 -->
-    <uses-permission android:name="android.permission.ACCESS_NETWORK_STATE" />
-    <uses-permission android:name="android.permission.ACCESS_WIFI_STATE" />
-
-#### 服务器配置
-
-	public class RequestServer implements IRequestServer {
-	
-	    @Override
-	    public String getHost() {
-	        return "https://www.baidu.com/";
-	    }
-	
-	    @Override
-	    public String getPath() {
-	        return "api/";
-	    }
-
-	    @Override
-	    public BodyType getType() {
-	        // 参数以 Json 格式提交（默认是表单）
-	        return BodyType.JSON;
-	    }
-	}
-
-#### 初始化
-
-> 需要配置请求结果处理，具体封装可以参考 [RequestHandler](https://github.com/getActivity/EasyHttp/blob/master/app/src/main/java/com/hjq/http/demo/http/model/RequestHandler.java)
-
-    EasyConfig.with(new OkHttpClient())
-            // 是否打印日志
-            .setLogEnabled(BuildConfig.DEBUG)
-            // 设置服务器配置
-            .setServer(server)
-            // 设置请求处理策略
-            .setHandler(new RequestHandler())
-            // 设置请求重试次数
-            .setRetryCount(3)
-            // 添加全局请求参数
-            //.addParam("token", "6666666")
-            // 添加全局请求头
-            //.addHeader("time", "20191030")
-            // 启用配置
-            .into();
-
-> 上述是创建配置，更新配置可以使用
-
-    EasyConfig.getInstance()
-            .addParam("token", data.getData().getToken());
-
-#### 配置接口
-
-	public final class LoginApi implements IRequestApi {
-
-	    @Override
-	    public String getApi() {
-	        return "user/login";
-	    }
-	
-	    /** 用户名 */
-	    private String userName;
-	    
-	    /** 登录密码 */
-	    private String password;
-	
-	    public LoginApi setUserName(String userName) {
-	        this.userName = userName;
-	        return this;
-	    }
-	
-	    public LoginApi setPassword(String password) {
-	        this.password = password;
-	        return this;
-	    }
-	}
-
-* 可为这个类的字段加上一些注解
-
-	* @HttpHeader：标记这个字段是一个请求头参数
-	
-	* @HttpIgnore：标记这个字段不会被发送给后台
-	
-	* @HttpRename：重新定义这个字段发送给后台的参数名称
-
-* 可在这个类实现一些接口
-
-	* implements IRequestHost：实现这个接口之后可以重新指定这个请求的主机地址
-
-	* implements IRequestPath：实现这个接口之后可以重新指定这个请求的接口路径
-
-	* implements IRequestType：实现这个接口之后可以重新指定这个请求的提交方式
-
-* 具体用法可以[点击这里查看](HelpDoc.md)
-
-#### 发起请求
-
-> 需要配置请求状态及生命周期处理，具体封装可以参考 [BaseActivity](https://github.com/getActivity/EasyHttp/blob/master/app/src/main/java/com/hjq/http/demo/BaseActivity.java)
-
-    EasyHttp.post(this)
-            .api(new LoginApi()
-                    .setUserName("Android 轮子哥")
-                    .setPassword("123456"))
-            .request(new HttpCallback<HttpData<LoginBean>>(activity) {
-
-                @Override
-                public void onSucceed(HttpData<LoginBean> data) {
-                    ToastUtils.show("登录成功");
-                }
-            });
-
-#### 下载文件
-
-> 下载缓存策略：在指定下载文件 md5 或者后台有返回 md5 的情况下，下载框架默认开启下载缓存模式，如果这个文件已经存在手机中，并且经过 md5 校验文件完整，框架就不会重复下载，而是直接回调下载监听。减轻服务器压力，减少用户等待时间。
-
-    EasyHttp.download(this)
-            .method(HttpMethod.GET)
-            .file(new File(Environment.getExternalStorageDirectory(), "微信.apk"))
-            .url("http://dldir1.qq.com/weixin/android/weixin708android1540.apk")
-            .md5("2E8BDD7686474A7BC4A51ADC3667CABF")
-            .listener(new OnDownloadListener() {
-
-                @Override
-                public void onStart(Call call) {
-                    mProgressBar.setVisibility(View.VISIBLE);
-                    ToastUtils.show("下载开始");
-                }
-
-                @Override
-                public void onProgress(DownloadInfo info) {
-                    mProgressBar.setProgress(info.getDownloadProgress());
-                }
-
-                @Override
-                public void onComplete(DownloadInfo info) {
-                    ToastUtils.show("下载完成：" + info.getFile().getPath());
-                    installApk(MainActivity.this, info.getFile());
-                }
-
-                @Override
-                public void onError(DownloadInfo info, Exception e) {
-                    ToastUtils.show("下载出错：" + e.getMessage());
-                }
-
-                @Override
-                public void onEnd(Call call) {
-                    mProgressBar.setVisibility(View.GONE);
-                    ToastUtils.show("下载结束");
-                }
-
-            }).start();
+|  功能  | [EasyHttp](https://github.com/getActivity/EasyHttp) | [Retrofit](https://github.com/square/retrofit) | [OkGo](https://github.com/jeasonlzy/okhttp-OkGo) |
+| :----: | :------: |  :-----: |  :-----: |
+|    动态 Host  |  支持  |  不支持  |   支持   |
+|    全局参数   |  支持  |  不支持  |    支持   |
+|    超时重试   |  支持  |  不支持  |    支持   |
+|    极速下载   |  支持  |  不支持  |   不支持  |
+|    下载校验   |  支持  |  不支持  |   不支持  |
+|    注解数量   |  3 个  |  25 个  |   0 个  |
+|    上传文件类型   | File / InputStream | RequestBody |  File  |
+|    批量上传文件   |  支持  |   不支持   |    支持    |
+|    上传进度监听   |  支持  |   不支持   |    支持    |
+|    Json 参数提交  |  支持  |    支持   |   支持   |
+|    请求生命周期  | 自动管控 |   需要封装  |   需要封装  |
+|    参数传值方式  |  字段名 + 字段值  | 方法参数名 + 方法参数值 |  定义 key 和 value  |
+|    参数灵活性  | 不强制传入 | 强制全部传入 |   不强制传入 |
+|   框架维护状态 |  维护中  |   维护中   |   停止维护  |
 
-#### 关于 Http 明文请求
-
-> Android P 限制了明文流量的网络请求，非加密的流量请求都会被系统禁止掉。
-如果当前应用的请求是 http 请求，而非 https ,这样就会导系统禁止当前应用进行该请求，如果 WebView 的 url 用 http 协议，同样会出现加载失败，https 不受影响
-
-> 在 res 下新建一个 xml 目录，然后创建一个名为：network_security_config.xml 文件 ，该文件内容如下
+* Retrofit 在我看来并不是那么好用，因为很多常用的功能实现起来比较麻烦，动态 Host 要写拦截器，日志打印要写拦截器，就连最常用的添加全局参数也要写拦截器，一个拦截器意味着要写很多代码，如果写得不够严谨还有可能出现 Bug，从而影响整个 OkHttp 请求流程，我经常在想这些功能能不能都用一句代码搞定，因为我觉得这些功能是框架设计的时候应该考虑的，这便是我做这个框架的初心。
 
-	<?xml version="1.0" encoding="utf-8"?>
-	<network-security-config>
-	    <base-config cleartextTrafficPermitted="true" />
-	</network-security-config>
+* 本框架采用了 OOP 思想，一个请求代表一个对象，通过类的继承和实现的特性来实现接口的动态化，几乎涵盖接口开发中所有的功能，使用起来非常简单灵活。
 
-> 然后在 AndroidManifest.xml application 标签内应用上面的xml配置
+* 有很多人觉得写一个接口类很麻烦，这个点确实有点麻烦，但是这块的付出是有收获的，从前期开发的效率考虑：OkGo > EasyHttp > Retrofit，但是从后期维护的效率考虑：EasyHttp > Retrofit > OkGo，之所以比较这三个框架，是因为框架的设计思想不同，但是我始终认为 EasyHttp 才是最好的设计，所以我创造了它。
 
-	<application
-	    android:networkSecurityConfig="@xml/network_security_config" />
+* 前期开发和后期维护哪个更重要？我觉得都重要，但是如果两者之间有利益冲突，我会毫不犹豫选择后期维护，因为前期开发占据的是小头，后期的持续维护才是大头。
 
 #### 混淆规则
-	
-	# OkHttp3
-	-keepattributes Signature
-	-keepattributes *Annotation*
-	-keep class okhttp3.** { *; }
-	-keep interface okhttp3.** { *; }
-	-dontwarn okhttp3.**
-	-dontwarn okio.**
-
-	# 不混淆这个包下的字段名
-    -keepclassmembernames class com.hjq.http.demo.http.** {
-        <fields>;
-    }
-    
-#### 对比 Retrofit 
-
-|  功能  | Retrofit 框架  | EasyHttp 框架 |
-| :----: | :------: |  :-----: |
-|    动态 Host  | 不支持 | 支持 |
-|    全局参数   |  不支持  | 支持 |
-|    动态参数   |  不支持  | 支持 |
-|    超时重试   | 不支持 | 支持 |
-|    极速下载   | 不支持 | 支持 |
-|    下载校验   | 不支持 | 支持 |
-|    注解数量   |  25 个  | 3 个 |
-|    上传文件   | RequestBody | File / InputStream |
-|    生命周期  |  需要封装  | 自动管控 |
+
+```groovy
+# OkHttp3
+-keepattributes Signature
+-keepattributes *Annotation*
+-keep class okhttp3.** { *; }
+-keep interface okhttp3.** { *; }
+-dontwarn okhttp3.**
+-dontwarn okio.**
+
+# 不混淆这个包下的字段名
+-keepclassmembernames class com.hjq.http.demo.http.** {
+    <fields>;
+}
+```
 
 #### 作者的其他开源项目
 
-* 架构工程：[AndroidProject](https://github.com/getActivity/AndroidProject)
+* 安卓架构：[AndroidProject](https://github.com/getActivity/AndroidProject)
 
 * 日志框架：[Logcat](https://github.com/getActivity/Logcat)
 
@@ -240,12 +86,6 @@
 
 * 悬浮窗框架：[XToast](https://github.com/getActivity/XToast)
 
-#### 特别感谢
-
-[张鸿洋](https://github.com/hongyangAndroid)
-
-[WanAndroid](https://www.wanandroid.com/)
-
 #### Android技术讨论Q群：78797078
 
 #### 如果您觉得我的开源库帮你节省了大量的开发时间，请扫描下方的二维码随意打赏，要是能打赏个 10.24 :monkey_face:就太:thumbsup:了。您的支持将鼓励我继续创作:octocat:
@@ -254,6 +94,12 @@
 
 #### [点击查看捐赠列表](https://github.com/getActivity/Donate)
 
+#### 特别感谢
+
+[张鸿洋](https://github.com/hongyangAndroid)
+
+[WanAndroid](https://www.wanandroid.com/)
+
 ## License
 
 ```text
diff --git a/app/build.gradle b/app/build.gradle
index 6208f60..c1058c2 100644
--- a/app/build.gradle
+++ b/app/build.gradle
@@ -1,7 +1,11 @@
 apply plugin: 'com.android.application'
 
 android {
-    compileSdkVersion 28
+    compileSdkVersion 30
+
+    lintOptions {
+        abortOnError false
+    }
 
     // 支持 JDK 1.8
     compileOptions {
@@ -12,9 +16,9 @@ android {
     defaultConfig {
         applicationId "com.hjq.http.demo"
         minSdkVersion 14
-        targetSdkVersion 28
-        versionCode 82
-        versionName "8.2"
+        targetSdkVersion 30
+        versionCode 86
+        versionName "8.6"
         testInstrumentationRunner "androidx.test.runner.AndroidJUnitRunner"
     }
 
@@ -24,35 +28,37 @@ android {
             proguardFiles getDefaultProguardFile('proguard-android.txt'), 'proguard-rules.pro'
         }
         release {
-            minifyEnabled true
+            minifyEnabled false
             proguardFiles getDefaultProguardFile('proguard-android.txt'), 'proguard-rules.pro'
         }
     }
 }
 
 dependencies {
+    // 依赖 libs 目录下所有的 jar 和 aar 包
     implementation fileTree(include: ['*.jar'], dir: 'libs')
+    implementation fileTree(include: ['*.aar'], dir: 'libs')
+    
     implementation project(':library')
 
     testImplementation 'junit:junit:4.13'
-    androidTestImplementation 'androidx.test.ext:junit:1.1.1'
-    androidTestImplementation 'androidx.test.espresso:espresso-core:3.2.0'
-
+    androidTestImplementation 'androidx.test.ext:junit:1.1.2'
+    androidTestImplementation 'androidx.test.espresso:espresso-core:3.3.0'
 
-    implementation 'androidx.appcompat:appcompat:1.1.0'
-    implementation 'com.google.android.material:material:1.1.0'
+    // 谷歌兼容库：https://developer.android.google.cn/jetpack/androidx/releases/appcompat?hl=zh-cn
+    implementation 'androidx.appcompat:appcompat:1.3.0-alpha02'
 
     // 标题栏：https://github.com/getActivity/TitleBar
-    implementation 'com.hjq:titlebar:6.5'
+    implementation 'com.hjq:titlebar:8.0'
     // 吐司工具类：https://github.com/getActivity/ToastUtils
-    implementation 'com.hjq:toast:8.6'
+    implementation 'com.hjq:toast:8.8'
     // 权限请求框架：https://github.com/getActivity/XXPermissions
-    implementation 'com.hjq:xxpermissions:6.5'
+    implementation 'com.hjq:xxpermissions:8.8'
     // Json 解析框架：https://github.com/google/gson
     implementation 'com.google.code.gson:gson:2.8.5'
     // OkHttp 框架：https://github.com/square/okhttp
     // 升级注意事项：https://www.jianshu.com/p/d12d0f536f55
-    implementation 'com.squareup.okhttp3:okhttp:3.12.10'
+    implementation 'com.squareup.okhttp3:okhttp:3.12.12'
     // 日志调试：https://github.com/getActivity/Logcat
-    debugImplementation 'com.hjq:logcat:8.2'
+    debugImplementation 'com.hjq:logcat:8.6'
 }
\ No newline at end of file
diff --git a/app/src/main/AndroidManifest.xml b/app/src/main/AndroidManifest.xml
index 3ee8451..a4991a7 100644
--- a/app/src/main/AndroidManifest.xml
+++ b/app/src/main/AndroidManifest.xml
@@ -10,6 +10,7 @@
     <uses-permission android:name="android.permission.ACCESS_WIFI_STATE" />
 
     <!-- 外部存储读写权限 -->
+    <uses-permission android:name="android.permission.MANAGE_EXTERNAL_STORAGE" />
     <uses-permission android:name="android.permission.READ_EXTERNAL_STORAGE" />
     <uses-permission android:name="android.permission.WRITE_EXTERNAL_STORAGE" />
 
@@ -23,6 +24,7 @@
         android:networkSecurityConfig="@xml/network_security_config"
         android:roundIcon="@mipmap/ic_launcher_round"
         android:theme="@style/AppTheme"
+        tools:ignore="LockedOrientationActivity"
         tools:targetApi="n">
 
         <!-- 适配 Android 7.0 文件意图 -->
diff --git a/app/src/main/java/com/hjq/http/demo/MainActivity.java b/app/src/main/java/com/hjq/http/demo/MainActivity.java
index 10de53e..2f748b4 100644
--- a/app/src/main/java/com/hjq/http/demo/MainActivity.java
+++ b/app/src/main/java/com/hjq/http/demo/MainActivity.java
@@ -16,7 +16,6 @@
 import androidx.core.content.FileProvider;
 
 import com.hjq.http.EasyHttp;
-import com.hjq.http.EasyLog;
 import com.hjq.http.demo.http.model.HttpData;
 import com.hjq.http.demo.http.request.SearchAuthorApi;
 import com.hjq.http.demo.http.request.SearchBlogsApi;
@@ -24,7 +23,8 @@
 import com.hjq.http.demo.http.response.SearchBean;
 import com.hjq.http.listener.HttpCallback;
 import com.hjq.http.listener.OnDownloadListener;
-import com.hjq.http.model.DownloadInfo;
+import com.hjq.http.listener.OnUpdateListener;
+import com.hjq.http.model.DataClass;
 import com.hjq.http.model.HttpMethod;
 import com.hjq.permissions.OnPermission;
 import com.hjq.permissions.Permission;
@@ -57,6 +57,7 @@ protected void onCreate(Bundle savedInstanceState) {
 
         findViewById(R.id.btn_main_get).setOnClickListener(this);
         findViewById(R.id.btn_main_post).setOnClickListener(this);
+        findViewById(R.id.btn_main_exec).setOnClickListener(this);
         findViewById(R.id.btn_main_update).setOnClickListener(this);
         findViewById(R.id.btn_main_download).setOnClickListener(this);
         requestPermission();
@@ -64,7 +65,7 @@ protected void onCreate(Bundle savedInstanceState) {
 
     private void requestPermission() {
         XXPermissions.with(this)
-                .permission(Permission.Group.STORAGE)
+                .permission(Permission.MANAGE_EXTERNAL_STORAGE)
                 .request(this);
     }
 
@@ -78,10 +79,10 @@ public void hasPermission(List<String> granted, boolean all) {
     }
 
     @Override
-    public void noPermission(List<String> denied, boolean quick) {
-        if (quick) {
+    public void noPermission(List<String> denied, boolean never) {
+        if (never) {
             ToastUtils.show("授权失败，请手动授予权限");
-            XXPermissions.startPermissionActivity(this, true);
+            XXPermissions.startPermissionActivity(this, denied);
         } else {
             ToastUtils.show("请先授予权限");
             requestPermission();
@@ -91,7 +92,7 @@ public void noPermission(List<String> denied, boolean quick) {
     @Override
     protected void onRestart() {
         super.onRestart();
-        if (XXPermissions.hasPermission(this, Permission.Group.STORAGE)) {
+        if (XXPermissions.hasPermission(this, Permission.MANAGE_EXTERNAL_STORAGE)) {
             hasPermission(null, true);
         } else {
             requestPermission();
@@ -109,7 +110,7 @@ public void onClick(View v) {
 
                             @Override
                             public void onSucceed(HttpData<SearchBean> result) {
-                                ToastUtils.show("请求成功，请看日志");
+                                ToastUtils.show("Get 请求成功，请看日志");
                             }
                         });
                 break;
@@ -121,26 +122,73 @@ public void onSucceed(HttpData<SearchBean> result) {
 
                             @Override
                             public void onSucceed(HttpData<SearchBean> result) {
-                                ToastUtils.show("请求成功，请看日志");
+                                ToastUtils.show("Post 请求成功，请看日志");
                             }
                         });
                 break;
+            case R.id.btn_main_exec:
+                // 在主线程中不能做耗时操作
+                new Thread(() -> {
+                    runOnUiThread(this::showDialog);
+                    try {
+                        HttpData<SearchBean> data = EasyHttp.post(MainActivity.this)
+                                .api(new SearchBlogsApi()
+                                        .setKeyword("搬砖不再有"))
+                                .execute(new DataClass<HttpData<SearchBean>>() {});
+                        ToastUtils.show("同步请求成功，请看日志");
+                    } catch (Exception e) {
+                        e.printStackTrace();
+                        ToastUtils.show(e.getMessage());
+                    }
+                    runOnUiThread(this::hideDialog);
+                }).start();
+                break;
             case R.id.btn_main_update:
+                if (mProgressBar.getVisibility() == View.VISIBLE) {
+                    ToastUtils.show("当前正在上传或者下载，请等待完成之后再进行操作");
+                    return;
+                }
+
                 File file = new File(Environment.getExternalStorageDirectory(), getString(R.string.app_name) + ".png");
                 // 生成图片到本地
-                drawableToFile(ContextCompat.getDrawable(this, R.mipmap.ic_launcher), file);
+                drawableToFile(ContextCompat.getDrawable(this, R.drawable.bg_material), file);
 
                 EasyHttp.post(this)
                         .api(new UpdateImageApi(file))
-                        .request(new HttpCallback<String>(this) {
+                        .request(new OnUpdateListener<Void>() {
+
+                            @Override
+                            public void onStart(Call call) {
+                                mProgressBar.setVisibility(View.VISIBLE);
+                            }
+
+                            @Override
+                            public void onUpdate(long totalByte, long updateByte, int progress) {
+                                mProgressBar.setProgress(progress);
+                            }
 
                             @Override
-                            public void onSucceed(String result) {
+
+                            public void onSucceed(Void result) {
                                 ToastUtils.show("上传成功");
                             }
+
+                            @Override
+                            public void onFail(Exception e) {
+                                ToastUtils.show("上传失败");
+                            }
+
+                            @Override
+                            public void onEnd(Call call) {
+                                mProgressBar.setVisibility(View.GONE);
+                            }
                         });
                 break;
             case R.id.btn_main_download:
+                if (mProgressBar.getVisibility() == View.VISIBLE) {
+                    ToastUtils.show("当前正在上传或者下载，请等待完成之后再进行操作");
+                    return;
+                }
                 EasyHttp.download(this)
                         .method(HttpMethod.GET)
                         .file(new File(Environment.getExternalStorageDirectory(), "微信.apk"))
@@ -150,31 +198,29 @@ public void onSucceed(String result) {
                         .listener(new OnDownloadListener() {
 
                             @Override
-                            public void onStart(Call call) {
+                            public void onStart(File file) {
                                 mProgressBar.setVisibility(View.VISIBLE);
-                                ToastUtils.show("下载开始");
                             }
 
                             @Override
-                            public void onProgress(DownloadInfo info) {
-                                mProgressBar.setProgress(info.getDownloadProgress());
+                            public void onProgress(File file, long totalByte, long downloadByte, int progress) {
+                                mProgressBar.setProgress(progress);
                             }
 
                             @Override
-                            public void onComplete(DownloadInfo info) {
-                                ToastUtils.show("下载完成：" + info.getFile().getPath());
-                                installApk(MainActivity.this, info.getFile());
+                            public void onComplete(File file) {
+                                ToastUtils.show("下载完成：" + file.getPath());
+                                installApk(MainActivity.this, file);
                             }
 
                             @Override
-                            public void onError(DownloadInfo info, Exception e) {
+                            public void onError(File file, Exception e) {
                                 ToastUtils.show("下载出错：" + e.getMessage());
                             }
 
                             @Override
-                            public void onEnd(Call call) {
+                            public void onEnd(File file) {
                                 mProgressBar.setVisibility(View.GONE);
-                                ToastUtils.show("下载结束");
                             }
 
                         }).start();
@@ -193,8 +239,8 @@ private void installApk(final Context context, final File file) {
                 .permission(Permission.REQUEST_INSTALL_PACKAGES)
                 .request(new OnPermission() {
                     @Override
-                    public void hasPermission(List<String> granted, boolean isAll) {
-                        if (isAll) {
+                    public void hasPermission(List<String> granted, boolean all) {
+                        if (all) {
                             Intent intent = new Intent();
                             intent.setAction(Intent.ACTION_VIEW);
                             Uri uri;
@@ -240,7 +286,7 @@ private void drawableToFile(Drawable drawable, File file) {
             ((BitmapDrawable) drawable).getBitmap().compress(Bitmap.CompressFormat.PNG, 100, out);
             out.close();
         } catch (IOException e) {
-            EasyLog.print(e);
+            e.printStackTrace();
         }
     }
 }
\ No newline at end of file
diff --git a/app/src/main/java/com/hjq/http/demo/MyApplication.java b/app/src/main/java/com/hjq/http/demo/MyApplication.java
index 3474fe7..b6322f4 100644
--- a/app/src/main/java/com/hjq/http/demo/MyApplication.java
+++ b/app/src/main/java/com/hjq/http/demo/MyApplication.java
@@ -29,7 +29,10 @@ public void onCreate() {
             server = new ReleaseServer();
         }
 
-        EasyConfig.with(new OkHttpClient())
+        OkHttpClient okHttpClient = new OkHttpClient.Builder()
+                .build();
+
+        EasyConfig.with(okHttpClient)
                 // 是否打印日志
                 //.setLogEnabled(BuildConfig.DEBUG)
                 // 设置服务器配置
@@ -45,6 +48,8 @@ public void intercept(String url, String tag, HttpParams params, HttpHeaders hea
                 })
                 // 设置请求重试次数
                 .setRetryCount(1)
+                // 设置请求重试时间
+                .setRetryTime(1000)
                 // 添加全局请求参数
                 //.addParam("token", "6666666")
                 // 添加全局请求头
diff --git a/app/src/main/java/com/hjq/http/demo/http/model/HttpListData.java b/app/src/main/java/com/hjq/http/demo/http/model/HttpListData.java
new file mode 100644
index 0000000..ce66bfa
--- /dev/null
+++ b/app/src/main/java/com/hjq/http/demo/http/model/HttpListData.java
@@ -0,0 +1,47 @@
+package com.hjq.http.demo.http.model;
+
+import java.util.List;
+
+/**
+ *    author : Android 轮子哥
+ *    github : https://github.com/getActivity/EasyHttp
+ *    time   : 2020/10/07
+ *    desc   : 统一接口列表数据结构
+ */
+public class HttpListData<T> extends HttpData<HttpListData.ListBean<T>> {
+
+    public static class ListBean<T> {
+
+        /** 当前页码 */
+        private int pageIndex;
+        /** 页大小 */
+        private int pageSize;
+        /** 总数量 */
+        private int totalNumber;
+        /** 数据 */
+        private List<T> items;
+
+        /**
+         * 判断是否是最后一页
+         */
+        public boolean isLastPage() {
+            return Math.ceil((float) totalNumber / pageSize) <= pageIndex;
+        }
+
+        public int getTotalNumber() {
+            return totalNumber;
+        }
+
+        public int getPageIndex() {
+            return pageIndex;
+        }
+
+        public int getPageSize() {
+            return pageSize;
+        }
+
+        public List<T> getItems() {
+            return items;
+        }
+    }
+}
\ No newline at end of file
diff --git a/app/src/main/java/com/hjq/http/demo/http/model/RequestHandler.java b/app/src/main/java/com/hjq/http/demo/http/model/RequestHandler.java
index 3dc1f63..90d9ab2 100644
--- a/app/src/main/java/com/hjq/http/demo/http/model/RequestHandler.java
+++ b/app/src/main/java/com/hjq/http/demo/http/model/RequestHandler.java
@@ -2,8 +2,6 @@
 
 import android.app.Application;
 import android.content.Context;
-import android.graphics.Bitmap;
-import android.graphics.BitmapFactory;
 import android.net.ConnectivityManager;
 import android.net.NetworkInfo;
 
@@ -38,11 +36,13 @@
 import org.json.JSONObject;
 
 import java.io.IOException;
+import java.io.InputStream;
 import java.lang.reflect.Type;
 import java.net.SocketTimeoutException;
 import java.net.UnknownHostException;
 import java.util.List;
 
+import okhttp3.Headers;
 import okhttp3.Response;
 import okhttp3.ResponseBody;
 
@@ -74,14 +74,17 @@ public Object requestSucceed(LifecycleOwner lifecycle, Response response, Type t
             throw new ResponseException(mApplication.getString(R.string.http_response_error) + "，responseCode：" + response.code() + "，message：" + response.message(), response);
         }
 
+        if (Headers.class.equals(type)) {
+            return response.headers();
+        }
+
         ResponseBody body = response.body();
         if (body == null) {
             return null;
         }
 
-        if (Bitmap.class.equals(type)) {
-            // 如果这是一个 Bitmap 对象
-            return BitmapFactory.decodeStream(body.byteStream());
+        if (InputStream.class.equals(type)) {
+            return body.byteStream();
         }
 
         String text;
diff --git a/app/src/main/java/com/hjq/http/demo/http/request/UpdateImageApi.java b/app/src/main/java/com/hjq/http/demo/http/request/UpdateImageApi.java
index ea21fa3..2e09357 100644
--- a/app/src/main/java/com/hjq/http/demo/http/request/UpdateImageApi.java
+++ b/app/src/main/java/com/hjq/http/demo/http/request/UpdateImageApi.java
@@ -1,9 +1,11 @@
 package com.hjq.http.demo.http.request;
 
 import com.hjq.http.config.IRequestApi;
-import com.hjq.http.config.IRequestHost;
+import com.hjq.http.config.IRequestServer;
 
 import java.io.File;
+import java.util.ArrayList;
+import java.util.List;
 
 /**
  *    author : Android 轮子哥
@@ -11,7 +13,7 @@
  *    time   : 2019/12/14
  *    desc   : 上传图片
  */
-public final class UpdateImageApi implements IRequestHost, IRequestApi {
+public final class UpdateImageApi implements IRequestServer, IRequestApi {
 
     @Override
     public String getHost() {
@@ -26,12 +28,15 @@ public String getApi() {
     /** 本地图片 */
     private File image;
 
+    private List<File> files = new ArrayList<>();
+
     public UpdateImageApi(File image) {
         this.image = image;
     }
 
     public UpdateImageApi setImage(File image) {
         this.image = image;
+        files.add(image);
         return this;
     }
 }
\ No newline at end of file
diff --git a/app/src/main/res/drawable/bg_material.jpg b/app/src/main/res/drawable/bg_material.jpg
new file mode 100644
index 0000000..b0a3f67
Binary files /dev/null and b/app/src/main/res/drawable/bg_material.jpg differ
diff --git a/app/src/main/res/layout/activity_main.xml b/app/src/main/res/layout/activity_main.xml
index 378754c..06f772b 100644
--- a/app/src/main/res/layout/activity_main.xml
+++ b/app/src/main/res/layout/activity_main.xml
@@ -34,14 +34,21 @@
             android:id="@+id/btn_main_get"
             android:layout_width="wrap_content"
             android:layout_height="wrap_content"
-            android:text="Get请求" />
+            android:text="Get 请求" />
 
         <Button
             android:id="@+id/btn_main_post"
             android:layout_width="wrap_content"
             android:layout_height="wrap_content"
             android:layout_marginTop="20dp"
-            android:text="Post请求" />
+            android:text="Post 请求" />
+
+        <Button
+            android:id="@+id/btn_main_exec"
+            android:layout_width="wrap_content"
+            android:layout_height="wrap_content"
+            android:layout_marginTop="20dp"
+            android:text="同步请求" />
 
         <Button
             android:id="@+id/btn_main_update"
diff --git a/library/build.gradle b/library/build.gradle
index ca8a839..ff7bc2d 100644
--- a/library/build.gradle
+++ b/library/build.gradle
@@ -2,7 +2,7 @@ apply plugin: 'com.android.library'
 apply plugin: 'com.novoda.bintray-release'
 
 android {
-    compileSdkVersion 26
+    compileSdkVersion 29
 
     // 使用 JDK 1.8
     compileOptions {
@@ -12,22 +12,22 @@ android {
 
     defaultConfig {
         minSdkVersion 14
-        targetSdkVersion 26
-        versionCode 82
-        versionName "8.2"
+        versionCode 86
+        versionName "8.6"
     }
 }
 
 dependencies {
-    implementation 'com.squareup.okhttp3:okhttp:3.12.10'
+    implementation 'com.squareup.okhttp3:okhttp:3.12.12'
     implementation 'androidx.lifecycle:lifecycle-common:2.1.0'
+    implementation 'androidx.lifecycle:lifecycle-runtime:2.1.0'
 }
 
 publish {
     userOrg = 'getactivity'
     groupId = 'com.hjq'
     artifactId = 'http'
-    version = '8.2'
+    version = '8.6'
     description = 'Easy-to-use network request framework'
     website = "https://github.com/getActivity/EasyHttp"
 }
diff --git a/library/src/main/java/com/hjq/http/EasyConfig.java b/library/src/main/java/com/hjq/http/EasyConfig.java
index 66ab9ad..ee6ed41 100644
--- a/library/src/main/java/com/hjq/http/EasyConfig.java
+++ b/library/src/main/java/com/hjq/http/EasyConfig.java
@@ -97,22 +97,32 @@ public EasyConfig setClient(OkHttpClient client) {
     }
 
     public EasyConfig setParams(HashMap<String, Object> params) {
+        if (params == null) {
+            params = new HashMap<>();
+        }
         mParams = params;
         return this;
     }
 
     public EasyConfig setHeaders(HashMap<String, String> headers) {
+        if (headers == null) {
+            headers = new HashMap<>();
+        }
         mHeaders = headers;
         return this;
     }
 
     public EasyConfig addHeader(String key, String value) {
-        mHeaders.put(key, value);
+        if (key != null && value != null) {
+            mHeaders.put(key, value);
+        }
         return this;
     }
 
     public EasyConfig addParam(String key, String value) {
-        mParams.put(key, value);
+        if (key != null && value != null) {
+            mParams.put(key, value);
+        }
         return this;
     }
 
@@ -140,12 +150,13 @@ public EasyConfig setRetryCount(int count) {
         return this;
     }
 
-    public void setRetryTime(long time) {
+    public EasyConfig setRetryTime(long time) {
         if (time < 0) {
             // 重试时间必须大于等于 0 毫秒
             throw new IllegalArgumentException("The retry time must be greater than 0");
         }
         mRetryTime = time;
+        return this;
     }
 
     public IRequestServer getServer() {
diff --git a/library/src/main/java/com/hjq/http/EasyHttp.java b/library/src/main/java/com/hjq/http/EasyHttp.java
index b0ae4ee..3c370d0 100644
--- a/library/src/main/java/com/hjq/http/EasyHttp.java
+++ b/library/src/main/java/com/hjq/http/EasyHttp.java
@@ -2,9 +2,13 @@
 
 import androidx.lifecycle.LifecycleOwner;
 
+import com.hjq.http.request.DeleteRequest;
 import com.hjq.http.request.DownloadRequest;
 import com.hjq.http.request.GetRequest;
+import com.hjq.http.request.HeadRequest;
+import com.hjq.http.request.PatchRequest;
 import com.hjq.http.request.PostRequest;
+import com.hjq.http.request.PutRequest;
 
 import okhttp3.Call;
 import okhttp3.OkHttpClient;
@@ -19,6 +23,11 @@ public final class EasyHttp {
 
     /**
      * Get 请求
+     *
+     * @param lifecycleOwner      请传入 AppCompatActivity 或者 AndroidX.Fragment 子类
+     *                            如需传入其他对象请参考以下两个类
+     *                            {@link com.hjq.http.lifecycle.ActivityLifecycle}
+     *                            {@link com.hjq.http.lifecycle.ApplicationLifecycle}
      */
     public static GetRequest get(LifecycleOwner lifecycleOwner) {
         return new GetRequest(lifecycleOwner).tag(lifecycleOwner);
@@ -26,13 +35,71 @@ public static GetRequest get(LifecycleOwner lifecycleOwner) {
 
     /**
      * Post 请求
+     *
+     * @param lifecycleOwner      请传入 AppCompatActivity 或者 AndroidX.Fragment 子类
+     *                            如需传入其他对象请参考以下两个类
+     *                            {@link com.hjq.http.lifecycle.ActivityLifecycle}
+     *                            {@link com.hjq.http.lifecycle.ApplicationLifecycle}
      */
     public static PostRequest post(LifecycleOwner lifecycleOwner) {
         return new PostRequest(lifecycleOwner).tag(lifecycleOwner);
     }
 
+    /**
+     * Head 请求
+     *
+     * @param lifecycleOwner      请传入 AppCompatActivity 或者 AndroidX.Fragment 子类
+     *                            如需传入其他对象请参考以下两个类
+     *                            {@link com.hjq.http.lifecycle.ActivityLifecycle}
+     *                            {@link com.hjq.http.lifecycle.ApplicationLifecycle}
+     */
+    public static HeadRequest head(LifecycleOwner lifecycleOwner) {
+        return new HeadRequest(lifecycleOwner).tag(lifecycleOwner);
+    }
+
+    /**
+     * Delete 请求
+     *
+     * @param lifecycleOwner      请传入 AppCompatActivity 或者 AndroidX.Fragment 子类
+     *                            如需传入其他对象请参考以下两个类
+     *                            {@link com.hjq.http.lifecycle.ActivityLifecycle}
+     *                            {@link com.hjq.http.lifecycle.ApplicationLifecycle}
+     */
+    public static DeleteRequest delete(LifecycleOwner lifecycleOwner) {
+        return new DeleteRequest(lifecycleOwner).tag(lifecycleOwner);
+    }
+
+    /**
+     * Put 请求
+     *
+     * @param lifecycleOwner      请传入 AppCompatActivity 或者 AndroidX.Fragment 子类
+     *                            如需传入其他对象请参考以下两个类
+     *                            {@link com.hjq.http.lifecycle.ActivityLifecycle}
+     *                            {@link com.hjq.http.lifecycle.ApplicationLifecycle}
+     */
+    public static PutRequest put(LifecycleOwner lifecycleOwner) {
+        return new PutRequest(lifecycleOwner).tag(lifecycleOwner);
+    }
+
+    /**
+     * Patch 请求
+     *
+     * @param lifecycleOwner      请传入 AppCompatActivity 或者 AndroidX.Fragment 子类
+     *                            如需传入其他对象请参考以下两个类
+     *                            {@link com.hjq.http.lifecycle.ActivityLifecycle}
+     *                            {@link com.hjq.http.lifecycle.ApplicationLifecycle}
+     */
+    public static PatchRequest patch(LifecycleOwner lifecycleOwner) {
+        return new PatchRequest(lifecycleOwner).tag(lifecycleOwner);
+    }
+
     /**
      * 下载请求
+     *
+     * @param lifecycleOwner      请传入 AppCompatActivity 或者 AndroidX.Fragment 子类
+     *                            如需传入其他对象请参考以下两个类
+     *                            {@link com.hjq.http.lifecycle.ActivityLifecycle}
+     *                            {@link com.hjq.http.lifecycle.ApplicationLifecycle}
      */
     public static DownloadRequest download(LifecycleOwner lifecycleOwner) {
         return new DownloadRequest(lifecycleOwner).tag(lifecycleOwner);
@@ -42,7 +109,7 @@ public static DownloadRequest download(LifecycleOwner lifecycleOwner) {
      * 取消请求
      */
     public static void cancel(LifecycleOwner lifecycleOwner) {
-        cancel(lifecycleOwner.getLifecycle().toString());
+        cancel(lifecycleOwner.toString());
     }
 
     /**
diff --git a/library/src/main/java/com/hjq/http/EasyLog.java b/library/src/main/java/com/hjq/http/EasyLog.java
index e611a4a..a2faf5c 100644
--- a/library/src/main/java/com/hjq/http/EasyLog.java
+++ b/library/src/main/java/com/hjq/http/EasyLog.java
@@ -12,7 +12,7 @@ public final class EasyLog {
      * 打印分割线
      */
     public static void print() {
-        print("--------------------");
+        print("----------------------------------------");
     }
 
     /**
diff --git a/library/src/main/java/com/hjq/http/EasyUtils.java b/library/src/main/java/com/hjq/http/EasyUtils.java
index cb6fb89..028e504 100644
--- a/library/src/main/java/com/hjq/http/EasyUtils.java
+++ b/library/src/main/java/com/hjq/http/EasyUtils.java
@@ -2,6 +2,7 @@
 
 import android.os.Handler;
 import android.os.Looper;
+import android.text.TextUtils;
 
 import com.hjq.http.annotation.HttpIgnore;
 import com.hjq.http.annotation.HttpRename;
@@ -18,6 +19,7 @@
 import java.lang.reflect.Field;
 import java.lang.reflect.ParameterizedType;
 import java.lang.reflect.Type;
+import java.net.URLEncoder;
 import java.security.DigestInputStream;
 import java.security.MessageDigest;
 import java.security.NoSuchAlgorithmException;
@@ -38,20 +40,10 @@ public final class EasyUtils {
 
     private static final Handler HANDLER = new Handler(Looper.getMainLooper());
 
-    /**
-     * 只有满足条件才在主线程中执行
-     */
-    public static boolean runOnUiThread(boolean execute, Runnable r) {
-        if (execute) {
-            return runOnUiThread(r);
-        }
-        return false;
-    }
-
     /**
      * 在主线程中执行
      */
-    public static boolean runOnUiThread(Runnable r) {
+    public static boolean post(Runnable r) {
         return HANDLER.post(r);
     }
 
@@ -91,7 +83,7 @@ public static boolean createFolder(File targetFolder) {
     }
 
     /**
-     * 获取文件的 MD5
+     * 获取文件的 md5
      */
     public static String getFileMd5(File file) {
         if (file == null) {
@@ -118,7 +110,7 @@ public static String getFileMd5(File file) {
         } catch (NoSuchAlgorithmException | IOException e) {
             EasyLog.print(e);
         } finally {
-            closeStream(inputStream);
+            EasyUtils.closeStream(inputStream);
         }
         return null;
     }
@@ -153,7 +145,7 @@ public static boolean isMultipart(Field[] fields) {
                 return true;
             } else if (List.class.equals(clazz)) {
                 Type[] actualTypeArguments = ((ParameterizedType) field.getGenericType()).getActualTypeArguments();
-                if (actualTypeArguments != null && actualTypeArguments.length == 1 && File.class.equals(actualTypeArguments[0])) {
+                if (actualTypeArguments.length == 1 && File.class.equals(actualTypeArguments[0])) {
                     return true;
                 }
             }
@@ -304,4 +296,40 @@ public static HashMap<String, Object> beanToHashMap(Object object) {
 
         return data;
     }
+
+    /**
+     * 获取对象反射类型
+     */
+    public static Type getReflectType(Object object) {
+        Type type;
+        Type[] types = object.getClass().getGenericInterfaces();
+        if (types.length > 0) {
+            // 如果这个监听对象是直接实现了接口
+            type = ((ParameterizedType) types[0]).getActualTypeArguments()[0];
+        } else {
+            // 如果这个监听对象是通过类继承
+            type = ((ParameterizedType) object.getClass().getGenericSuperclass()).getActualTypeArguments()[0];
+        }
+        return type;
+    }
+
+    /**
+     * 获取进度百分比
+     */
+    public static int getProgressPercent(long totalByte, long currentByte) {
+        // 计算百分比，这里踩了两个坑
+        // 当文件很大的时候：字节数 * 100 会超过 int 最大值，计算结果会变成负数
+        // 还有需要注意的是，long 除以 long 等于 long，这里的字节数除以总字节数应该要 double 类型的
+        return (int) (((double) currentByte / totalByte) * 100);
+    }
+
+    /**
+     * 字符串编码
+     */
+    public static String encodeString(String text) {
+        if (TextUtils.isEmpty(text)) {
+            return "";
+        }
+        return URLEncoder.encode(text);
+    }
 }
\ No newline at end of file
diff --git a/library/src/main/java/com/hjq/http/body/JsonArrayBody.java b/library/src/main/java/com/hjq/http/body/JsonArrayBody.java
new file mode 100644
index 0000000..ee4f8cc
--- /dev/null
+++ b/library/src/main/java/com/hjq/http/body/JsonArrayBody.java
@@ -0,0 +1,40 @@
+package com.hjq.http.body;
+
+import org.json.JSONArray;
+
+import java.io.IOException;
+import java.util.List;
+
+import okio.BufferedSink;
+
+/**
+ *    author : Android 轮子哥
+ *    github : https://github.com/getActivity/EasyHttp
+ *    time   : 2019/12/28
+ *    desc   : JsonArray 参数提交
+ */
+public final class JsonArrayBody extends JsonBaseBody {
+
+    private final JSONArray mJsonArray;
+
+    public JsonArrayBody() {
+        this(new JSONArray());
+    }
+
+    public JsonArrayBody(List list) {
+        this(new JSONArray(list));
+    }
+
+    public JsonArrayBody(JSONArray jsonArray) {
+        mJsonArray = jsonArray;
+    }
+
+    public JSONArray getJsonObject() {
+        return mJsonArray;
+    }
+
+    @Override
+    public void writeTo(BufferedSink sink) throws IOException {
+        writeTo(sink, mJsonArray.toString());
+    }
+}
\ No newline at end of file
diff --git a/library/src/main/java/com/hjq/http/body/JsonBaseBody.java b/library/src/main/java/com/hjq/http/body/JsonBaseBody.java
new file mode 100644
index 0000000..68d6304
--- /dev/null
+++ b/library/src/main/java/com/hjq/http/body/JsonBaseBody.java
@@ -0,0 +1,28 @@
+package com.hjq.http.body;
+
+import java.io.IOException;
+
+import okhttp3.MediaType;
+import okhttp3.RequestBody;
+import okio.BufferedSink;
+
+/**
+ *    author : Android 轮子哥
+ *    github : https://github.com/getActivity/EasyHttp
+ *    time   : 2019/12/28
+ *    desc   : Json 参数提交
+ */
+public abstract class JsonBaseBody extends RequestBody {
+
+    private static final MediaType CONTENT_TYPE = MediaType.get("application/json; charset=utf-8");
+
+    @Override
+    public MediaType contentType() {
+        return CONTENT_TYPE;
+    }
+
+    public void writeTo(BufferedSink sink, String json) throws IOException {
+        byte[] bytes = json.getBytes();
+        sink.write(bytes, 0, bytes.length);
+    }
+}
\ No newline at end of file
diff --git a/library/src/main/java/com/hjq/http/model/JsonBody.java b/library/src/main/java/com/hjq/http/body/JsonObjectBody.java
similarity index 50%
rename from library/src/main/java/com/hjq/http/model/JsonBody.java
rename to library/src/main/java/com/hjq/http/body/JsonObjectBody.java
index 8fad053..57acca5 100644
--- a/library/src/main/java/com/hjq/http/model/JsonBody.java
+++ b/library/src/main/java/com/hjq/http/body/JsonObjectBody.java
@@ -1,35 +1,31 @@
-package com.hjq.http.model;
+package com.hjq.http.body;
 
 import org.json.JSONObject;
 
 import java.io.IOException;
 import java.util.Map;
 
-import okhttp3.MediaType;
-import okhttp3.RequestBody;
 import okio.BufferedSink;
 
 /**
  *    author : Android 轮子哥
  *    github : https://github.com/getActivity/EasyHttp
  *    time   : 2019/12/28
- *    desc   : Json 提交模型
+ *    desc   : JsonObject 参数提交
  */
-public final class JsonBody extends RequestBody {
-
-    private static final MediaType CONTENT_TYPE = MediaType.get("application/json; charset=utf-8");
+public final class JsonObjectBody extends JsonBaseBody {
 
     private final JSONObject mJsonObject;
 
-    public JsonBody() {
+    public JsonObjectBody() {
         this(new JSONObject());
     }
 
-    public JsonBody(Map map) {
+    public JsonObjectBody(Map map) {
         this(new JSONObject(map));
     }
 
-    public JsonBody(JSONObject jsonObject) {
+    public JsonObjectBody(JSONObject jsonObject) {
         mJsonObject = jsonObject;
     }
 
@@ -37,14 +33,8 @@ public JSONObject getJsonObject() {
         return mJsonObject;
     }
 
-    @Override
-    public MediaType contentType() {
-        return CONTENT_TYPE;
-    }
-
     @Override
     public void writeTo(BufferedSink sink) throws IOException {
-        byte[] bytes = mJsonObject.toString().getBytes();
-        sink.write(bytes, 0, bytes.length);
+        writeTo(sink, mJsonObject.toString());
     }
 }
\ No newline at end of file
diff --git a/library/src/main/java/com/hjq/http/body/MultipartBodyProxy.java b/library/src/main/java/com/hjq/http/body/MultipartBodyProxy.java
new file mode 100644
index 0000000..3508253
--- /dev/null
+++ b/library/src/main/java/com/hjq/http/body/MultipartBodyProxy.java
@@ -0,0 +1,151 @@
+package com.hjq.http.body;
+
+import androidx.annotation.Nullable;
+import androidx.lifecycle.LifecycleOwner;
+
+import com.hjq.http.EasyLog;
+import com.hjq.http.EasyUtils;
+import com.hjq.http.lifecycle.HttpLifecycleControl;
+import com.hjq.http.listener.OnUpdateListener;
+
+import java.io.File;
+import java.io.FileNotFoundException;
+import java.io.IOException;
+import java.io.InputStream;
+
+import okhttp3.MediaType;
+import okhttp3.MultipartBody;
+import okhttp3.RequestBody;
+import okio.Buffer;
+import okio.BufferedSink;
+import okio.ForwardingSink;
+import okio.Okio;
+
+/**
+ *    author : Android 轮子哥
+ *    github : https://github.com/getActivity/EasyHttp
+ *    time   : 2020/08/15
+ *    desc   : MultipartBody 代理类
+ */
+public final class MultipartBodyProxy extends RequestBody {
+
+    private final MultipartBody mMultipartBody;
+    private final OnUpdateListener mListener;
+    private final LifecycleOwner mLifecycleOwner;
+
+    public MultipartBodyProxy(MultipartBody body, LifecycleOwner lifecycleOwner, OnUpdateListener listener) {
+        mMultipartBody = body;
+        mLifecycleOwner = lifecycleOwner;
+        mListener = listener;
+    }
+
+    @Override
+    public MediaType contentType() {
+        return mMultipartBody.contentType();
+    }
+
+    @Override
+    public long contentLength() throws IOException {
+        return mMultipartBody.contentLength();
+    }
+
+    @Override
+    public void writeTo(BufferedSink sink) throws IOException {
+        final long totalByte = contentLength();
+        mMultipartBody.writeTo(sink = Okio.buffer(new ForwardingSink(sink) {
+
+            private long updateByte;
+
+            @Override
+            public void write(Buffer source, long byteCount) throws IOException {
+                super.write(source, byteCount);
+                updateByte += byteCount;
+                int progress = EasyUtils.getProgressPercent(totalByte, updateByte);
+                EasyLog.print("正在进行上传" +
+                        "，总字节：" + totalByte +
+                        "，已上传：" + updateByte +
+                        "，进度：" + progress + "%");
+                EasyUtils.post(() -> {
+                    if (mListener != null && HttpLifecycleControl.isLifecycleActive(mLifecycleOwner)) {
+                        mListener.onUpdate(totalByte, updateByte, progress);
+                    }
+                });
+            }
+        }));
+        sink.flush();
+    }
+
+    public static final class Builder {
+
+        private final MultipartBody.Builder mBuilder;
+        private OnUpdateListener mListener;
+        private LifecycleOwner mLifecycleOwner;
+
+        public Builder() {
+            mBuilder = new MultipartBody.Builder();
+        }
+
+        public Builder setType(MediaType type) {
+            mBuilder.setType(type);
+            return this;
+        }
+
+        public Builder addPart(MultipartBody.Part part) {
+            mBuilder.addPart(part);
+            return this;
+        }
+
+        public Builder addFormDataPart(String name, String value) {
+            mBuilder.addFormDataPart(name, value);
+            return this;
+        }
+
+        public Builder addFormDataPart(String name, @Nullable String filename, RequestBody body) {
+            mBuilder.addFormDataPart(name, filename, body);
+            return this;
+        }
+
+        public Builder setOnUpdateListener(OnUpdateListener listener) {
+            mListener = listener;
+            return this;
+        }
+
+        public Builder setLifecycleOwner(LifecycleOwner lifecycleOwner)  {
+            mLifecycleOwner = lifecycleOwner;
+            return this;
+        }
+
+        public MultipartBodyProxy build() {
+            return new MultipartBodyProxy(mBuilder.build(), mLifecycleOwner, mListener);
+        }
+    }
+
+    /**
+     * 根据 File 对象创建一个流媒体
+     */
+    public static MultipartBody.Part createPart(String key, File file) {
+        if (file.exists() && file.isFile()) {
+            try {
+                // 文件名必须不能带中文，所以这里要编码
+                return MultipartBody.Part.createFormData(key, EasyUtils.encodeString(file.getName()), new UpdateBody(file));
+            } catch (FileNotFoundException e) {
+                EasyLog.print(e);
+            }
+        } else {
+            EasyLog.print("文件不存在，将被忽略上传：" + key + " = " + file.getPath());
+        }
+        return null;
+    }
+
+    /**
+     * 根据 InputStream 对象创建一个流媒体
+     */
+    public static MultipartBody.Part createPart(String key, InputStream inputStream) {
+        try {
+            return MultipartBody.Part.createFormData(key, null, new UpdateBody(inputStream, key));
+        } catch (IOException e) {
+            EasyLog.print(e);
+        }
+        return null;
+    }
+}
\ No newline at end of file
diff --git a/library/src/main/java/com/hjq/http/model/UpdateBody.java b/library/src/main/java/com/hjq/http/body/UpdateBody.java
similarity index 52%
rename from library/src/main/java/com/hjq/http/model/UpdateBody.java
rename to library/src/main/java/com/hjq/http/body/UpdateBody.java
index 99c8313..e688d25 100644
--- a/library/src/main/java/com/hjq/http/model/UpdateBody.java
+++ b/library/src/main/java/com/hjq/http/body/UpdateBody.java
@@ -1,6 +1,6 @@
-package com.hjq.http.model;
+package com.hjq.http.body;
 
-import com.hjq.http.EasyLog;
+import com.hjq.http.EasyUtils;
 
 import java.io.File;
 import java.io.FileNotFoundException;
@@ -8,12 +8,9 @@
 import java.io.InputStream;
 import java.net.FileNameMap;
 import java.net.URLConnection;
-import java.net.URLEncoder;
 
 import okhttp3.MediaType;
-import okhttp3.MultipartBody;
 import okhttp3.RequestBody;
-import okio.Buffer;
 import okio.BufferedSink;
 import okio.Okio;
 import okio.Source;
@@ -22,31 +19,26 @@
  *    author : Android 轮子哥
  *    github : https://github.com/getActivity/EasyHttp
  *    time   : 2019/12/14
- *    desc   : 上传文件请求
+ *    desc   : 上传文件流
  */
-public final class UpdateBody extends RequestBody {
+public class UpdateBody extends RequestBody {
 
     public static final MediaType MEDIA_TYPE = MediaType.parse("application/octet-stream");
 
-    /**
-     * 上传源
-     */
+    /** 上传源 */
     private final Source mSource;
-    /**
-     * 内容类型
-     */
+
+    /** 内容类型 */
     private final MediaType mMediaType;
-    /**
-     * 内容名称
-     */
+
+    /** 内容名称 */
     private final String mName;
-    /**
-     * 内容大小
-     */
+
+    /** 内容大小 */
     private final long mLength;
 
     public UpdateBody(File file) throws FileNotFoundException {
-        this(Okio.source(file), guessMimeType(file.getName()), file.getPath(), file.length());
+        this(Okio.source(file), guessMimeType(file.getName()), file.getName(), file.length());
     }
 
     public UpdateBody(InputStream inputStream, String name) throws IOException {
@@ -72,20 +64,17 @@ public long contentLength() {
 
     @Override
     public void writeTo(BufferedSink sink) throws IOException {
-        Buffer buffer = new Buffer();
-        long totalLength = contentLength();
-        long updateLength = 0;
-        long readCount;
-        while ((readCount = mSource.read(buffer, 2048)) != -1) {
-            sink.write(buffer, readCount);
-            updateLength += readCount;
-
-            EasyLog.print(mName + " 正在上传" +
-                    "，文件总字节：" + totalLength +
-                    "，已上传字节：" + updateLength);
+        try {
+            sink.writeAll(mSource);
+        } finally {
+            EasyUtils.closeStream(mSource);
         }
     }
 
+    public String getName() {
+        return mName;
+    }
+
     /**
      * 根据文件名获取 MIME 类型
      */
@@ -103,34 +92,4 @@ public static MediaType guessMimeType(String fileName) {
         }
         return type;
     }
-
-
-    /**
-     * 根据 File 对象创建一个流媒体
-     */
-    public static MultipartBody.Part createPart(String key, File file) {
-        if (file.exists() && file.isFile()) {
-            try {
-                // 文件名必须不能带中文，所以这里要编码
-                return MultipartBody.Part.createFormData(key, URLEncoder.encode(file.getName()), new UpdateBody(file));
-            } catch (FileNotFoundException e) {
-                EasyLog.print(e);
-            }
-        } else {
-            EasyLog.print("文件不存在，将被忽略上传：" + key + " = " + file.getPath());
-        }
-        return null;
-    }
-
-    /**
-     * 根据 InputStream 对象创建一个流媒体
-     */
-    public static MultipartBody.Part createPart(String key, InputStream inputStream) {
-        try {
-            return MultipartBody.Part.createFormData(key, null, new UpdateBody(inputStream, key));
-        } catch (IOException e) {
-            EasyLog.print(e);
-        }
-        return null;
-    }
 }
\ No newline at end of file
diff --git a/library/src/main/java/com/hjq/http/callback/BaseCallback.java b/library/src/main/java/com/hjq/http/callback/BaseCallback.java
index 91ee8df..9da9a30 100644
--- a/library/src/main/java/com/hjq/http/callback/BaseCallback.java
+++ b/library/src/main/java/com/hjq/http/callback/BaseCallback.java
@@ -1,13 +1,12 @@
 package com.hjq.http.callback;
 
-import androidx.lifecycle.Lifecycle;
 import androidx.lifecycle.LifecycleOwner;
 
 import com.hjq.http.EasyConfig;
 import com.hjq.http.EasyLog;
 import com.hjq.http.EasyUtils;
+import com.hjq.http.lifecycle.HttpLifecycleControl;
 import com.hjq.http.model.CallProxy;
-import com.hjq.http.model.HttpLifecycle;
 
 import java.io.IOException;
 import java.net.SocketTimeoutException;
@@ -36,18 +35,23 @@ public abstract class BaseCallback implements Callback {
     BaseCallback(LifecycleOwner lifecycleOwner, CallProxy call) {
         mCall = call;
         mLifecycleOwner = lifecycleOwner;
-        HttpLifecycle.with(lifecycleOwner);
+        HttpLifecycleControl.bind(lifecycleOwner);
     }
 
     CallProxy getCall() {
         return mCall;
     }
 
+    LifecycleOwner getLifecycleOwner() {
+        return mLifecycleOwner;
+    }
+
     @Override
     public void onResponse(Call call, Response response) {
         try {
+            // 收到响应
             onResponse(response);
-        } catch (final Exception e) {
+        } catch (Exception e) {
             // 回调失败
             onFailure(e);
         } finally {
@@ -63,7 +67,7 @@ public void onFailure(Call call, IOException e) {
             // 设置延迟 N 秒后重试该请求
             EasyUtils.postDelayed(() -> {
                 // 前提是宿主还没有被销毁
-                if (isLifecycleActive()) {
+                if (HttpLifecycleControl.isLifecycleActive(mLifecycleOwner)) {
                     mRetryCount++;
                     Call newCall = call.clone();
                     mCall.setCall(newCall);
@@ -78,13 +82,6 @@ public void onFailure(Call call, IOException e) {
         onFailure(e);
     }
 
-    /**
-     * 判断宿主是否处于活动状态
-     */
-    protected boolean isLifecycleActive() {
-        return mLifecycleOwner.getLifecycle().getCurrentState() != Lifecycle.State.DESTROYED;
-    }
-
     protected abstract void onResponse(Response response) throws Exception;
 
     protected abstract void onFailure(Exception e);
diff --git a/library/src/main/java/com/hjq/http/callback/DownloadCallback.java b/library/src/main/java/com/hjq/http/callback/DownloadCallback.java
index c08542f..1e46749 100644
--- a/library/src/main/java/com/hjq/http/callback/DownloadCallback.java
+++ b/library/src/main/java/com/hjq/http/callback/DownloadCallback.java
@@ -8,6 +8,7 @@
 import com.hjq.http.EasyUtils;
 import com.hjq.http.exception.MD5Exception;
 import com.hjq.http.exception.NullBodyException;
+import com.hjq.http.lifecycle.HttpLifecycleControl;
 import com.hjq.http.listener.OnDownloadListener;
 import com.hjq.http.model.CallProxy;
 import com.hjq.http.model.DownloadInfo;
@@ -27,70 +28,65 @@
  */
 public final class DownloadCallback extends BaseCallback {
 
-    /**
-     * 文件 MD5 正则表达式
-     */
+    /** 文件 MD5 正则表达式 */
     private static final String FILE_MD5_REGEX = "^[\\w]{32}$";
 
-    /**
-     * 下载任务
-     */
-    private DownloadInfo mDownloadInfo;
-
-    /**
-     * 保存的文件
-     */
+    /** 保存的文件 */
     private File mFile;
 
-    /**
-     * 校验的 MD5
-     */
-    private String mMD5;
+    /** 校验的 MD5 */
+    private String mMd5;
 
-    /**
-     * 下载监听回调
-     */
+    /** 下载监听回调 */
     private OnDownloadListener mListener;
 
     public DownloadCallback(LifecycleOwner lifecycleOwner, CallProxy call, File file, String md5, OnDownloadListener listener) {
         super(lifecycleOwner, call);
-        mDownloadInfo = new DownloadInfo(file);
         mFile = file;
-        mMD5 = md5;
+        mMd5 = md5;
         mListener = listener;
 
-        EasyUtils.runOnUiThread(mListener != null && isLifecycleActive(), () -> mListener.onStart(getCall()));
+        EasyUtils.post(() -> {
+            if (mListener != null && HttpLifecycleControl.isLifecycleActive(getLifecycleOwner())) {
+                mListener.onStart(mFile);
+            }
+        });
     }
 
     @Override
     protected void onResponse(Response response) throws Exception {
         // 如果没有指定文件的 md5 值
-        if (mMD5 == null) {
+        if (mMd5 == null) {
             // 获取响应头中的文件 MD5 值
             String md5 = response.header("Content-MD5");
             // 这个 md5 值必须是文件的 md5 值
             if (!TextUtils.isEmpty(md5) && md5.matches(FILE_MD5_REGEX)) {
-                mMD5 = md5;
+                mMd5 = md5;
             }
         }
 
         EasyUtils.createFolder(mFile.getParentFile());
         ResponseBody body = response.body();
         if (body == null) {
-            EasyUtils.runOnUiThread(mListener != null && isLifecycleActive(), () -> {
-                mListener.onError(mDownloadInfo, new NullBodyException("The response body is empty"));
-                mListener.onEnd(getCall());
+            EasyUtils.post(() -> {
+                if (mListener != null && HttpLifecycleControl.isLifecycleActive(getLifecycleOwner())) {
+                    mListener.onError(mFile, new NullBodyException("The response body is empty"));
+                    mListener.onEnd(mFile);
+                }
             });
             return;
         }
 
-        mDownloadInfo.setTotalLength(body.contentLength());
+        DownloadInfo downloadInfo = new DownloadInfo();
+        downloadInfo.setTotalByte(body.contentLength());
         // 如果这个文件已经下载过，并且经过校验 MD5 是同一个文件的话，就直接回调下载成功监听
-        if (!TextUtils.isEmpty(mMD5) && mFile.exists() && mFile.isFile() && mMD5.equalsIgnoreCase(EasyUtils.getFileMd5(mFile))) {
-            EasyUtils.runOnUiThread(mListener != null && isLifecycleActive(), () -> {
-                mDownloadInfo.setDownloadLength(mDownloadInfo.getTotalLength());
-                mListener.onComplete(mDownloadInfo);
-                mListener.onEnd(getCall());
+        if (!TextUtils.isEmpty(mMd5) && mFile.exists() && mFile.isFile() && mMd5.equalsIgnoreCase(EasyUtils.getFileMd5(mFile))) {
+            EasyUtils.post(() -> {
+                if (mListener != null && HttpLifecycleControl.isLifecycleActive(getLifecycleOwner())) {
+                    downloadInfo.setDownloadByte(downloadInfo.getTotalByte());
+                    mListener.onComplete(mFile);
+                    mListener.onEnd(mFile);
+                }
             });
             return;
         }
@@ -103,22 +99,28 @@ protected void onResponse(Response response) throws Exception {
         while ((readLength = inputStream.read(bytes)) != -1) {
             downloadSize += readLength;
             outputStream.write(bytes, 0, readLength);
-            mDownloadInfo.setDownloadLength(downloadSize);
-            EasyUtils.runOnUiThread(mListener != null && isLifecycleActive(), () -> mListener.onProgress(mDownloadInfo));
+            downloadInfo.setDownloadByte(downloadSize);
+            EasyUtils.post(() -> {
+                if (mListener != null && HttpLifecycleControl.isLifecycleActive(getLifecycleOwner())) {
+                    mListener.onProgress(mFile, downloadInfo.getTotalByte(), downloadInfo.getDownloadByte(), downloadInfo.getDownloadProgress());
+                }
+            });
             EasyLog.print(mFile.getPath() + " 正在下载" +
-                    "，文件总字节：" + mDownloadInfo.getTotalLength() +
-                    "，已下载字节：" + mDownloadInfo.getDownloadLength() +
-                    "，下载进度：" + mDownloadInfo.getDownloadProgress() + " %");
+                    "，文件总字节：" + downloadInfo.getTotalByte() +
+                    "，已下载字节：" + downloadInfo.getDownloadByte() +
+                    "，下载进度：" + downloadInfo.getDownloadProgress() + " %");
         }
         outputStream.flush();
 
-        EasyUtils.runOnUiThread(mListener != null && isLifecycleActive(), () -> {
-            String md5 = EasyUtils.getFileMd5(mDownloadInfo.getFile());
-            if (!TextUtils.isEmpty(mMD5) && !mMD5.equalsIgnoreCase(md5)) {
-                onFailure(new MD5Exception("MD5 verify failure", md5));
-            } else {
-                mListener.onComplete(mDownloadInfo);
-                mListener.onEnd(getCall());
+        String md5 = EasyUtils.getFileMd5(mFile);
+        if (!TextUtils.isEmpty(mMd5) && !mMd5.equalsIgnoreCase(md5)) {
+            onFailure(new MD5Exception("MD5 verify failure", md5));
+        }
+
+        EasyUtils.post(() -> {
+            if (mListener != null && HttpLifecycleControl.isLifecycleActive(getLifecycleOwner())) {
+                mListener.onComplete(mFile);
+                mListener.onEnd(mFile);
             }
         });
 
@@ -129,9 +131,11 @@ protected void onResponse(Response response) throws Exception {
     @Override
     protected void onFailure(final Exception e) {
         EasyLog.print(e);
-        EasyUtils.runOnUiThread(mListener != null && isLifecycleActive(), () -> {
-            mListener.onError(mDownloadInfo, e);
-            mListener.onEnd(getCall());
+        EasyUtils.post(() -> {
+            if (mListener != null && HttpLifecycleControl.isLifecycleActive(getLifecycleOwner())) {
+                mListener.onError(mFile, e);
+                mListener.onEnd(mFile);
+            }
         });
     }
 }
\ No newline at end of file
diff --git a/library/src/main/java/com/hjq/http/callback/NormalCallback.java b/library/src/main/java/com/hjq/http/callback/NormalCallback.java
index 4d23874..65be7f3 100644
--- a/library/src/main/java/com/hjq/http/callback/NormalCallback.java
+++ b/library/src/main/java/com/hjq/http/callback/NormalCallback.java
@@ -5,12 +5,10 @@
 import com.hjq.http.EasyConfig;
 import com.hjq.http.EasyLog;
 import com.hjq.http.EasyUtils;
+import com.hjq.http.lifecycle.HttpLifecycleControl;
 import com.hjq.http.listener.OnHttpListener;
 import com.hjq.http.model.CallProxy;
 
-import java.lang.reflect.ParameterizedType;
-import java.lang.reflect.Type;
-
 import okhttp3.Response;
 
 /**
@@ -23,35 +21,29 @@ public final class NormalCallback extends BaseCallback {
 
     private LifecycleOwner mLifecycle;
     private OnHttpListener mListener;
-    private long mRequestTime;
 
     public NormalCallback(LifecycleOwner lifecycleOwner, CallProxy call, OnHttpListener listener) {
         super(lifecycleOwner, call);
         mLifecycle = lifecycleOwner;
         mListener = listener;
-        mRequestTime = System.currentTimeMillis();
 
-        EasyUtils.runOnUiThread(mListener != null && isLifecycleActive(), () -> mListener.onStart(call));
+        EasyUtils.post(() -> {
+            if (mListener != null && HttpLifecycleControl.isLifecycleActive(getLifecycleOwner())) {
+                mListener.onStart(call);
+            }
+        });
     }
 
     @SuppressWarnings("unchecked")
     @Override
     protected void onResponse(Response response) throws Exception {
-        Type type;
-        Type[] types = mListener.getClass().getGenericInterfaces();
-        if (types.length > 0) {
-            // 如果这个监听对象是直接实现了接口
-            type = ((ParameterizedType) types[0]).getActualTypeArguments()[0];
-        } else {
-            // 如果这个监听对象是通过类继承
-            type = ((ParameterizedType) mListener.getClass().getGenericSuperclass()).getActualTypeArguments()[0];
-        }
-
-        EasyLog.print("RequestTime：" + (System.currentTimeMillis() - mRequestTime) + " ms");
-        final Object result = EasyConfig.getInstance().getHandler().requestSucceed(mLifecycle, response, type);
-        EasyUtils.runOnUiThread(mListener != null && isLifecycleActive(), () -> {
-            mListener.onSucceed(result);
-            mListener.onEnd(getCall());
+        EasyLog.print("RequestTime：" + (response.receivedResponseAtMillis() - response.sentRequestAtMillis()) + " ms");
+        final Object result = EasyConfig.getInstance().getHandler().requestSucceed(mLifecycle, response, EasyUtils.getReflectType(mListener));
+        EasyUtils.post( () -> {
+            if (mListener != null && HttpLifecycleControl.isLifecycleActive(getLifecycleOwner())) {
+                mListener.onSucceed(result);
+                mListener.onEnd(getCall());
+            }
         });
     }
 
@@ -59,9 +51,11 @@ protected void onResponse(Response response) throws Exception {
     protected void onFailure(Exception e) {
         EasyLog.print(e);
         final Exception exception = EasyConfig.getInstance().getHandler().requestFail(mLifecycle, e);
-        EasyUtils.runOnUiThread(mListener != null && isLifecycleActive(), () -> {
-            mListener.onFail(exception);
-            mListener.onEnd(getCall());
+        EasyUtils.post(() -> {
+            if (mListener != null && HttpLifecycleControl.isLifecycleActive(getLifecycleOwner())) {
+                mListener.onFail(exception);
+                mListener.onEnd(getCall());
+            }
         });
     }
 }
\ No newline at end of file
diff --git a/library/src/main/java/com/hjq/http/lifecycle/ActivityLifecycle.java b/library/src/main/java/com/hjq/http/lifecycle/ActivityLifecycle.java
new file mode 100644
index 0000000..0e68f0b
--- /dev/null
+++ b/library/src/main/java/com/hjq/http/lifecycle/ActivityLifecycle.java
@@ -0,0 +1,114 @@
+package com.hjq.http.lifecycle;
+
+import android.app.Activity;
+import android.app.Application;
+import android.os.Bundle;
+
+import androidx.annotation.NonNull;
+import androidx.lifecycle.Lifecycle;
+import androidx.lifecycle.LifecycleEventObserver;
+import androidx.lifecycle.LifecycleOwner;
+import androidx.lifecycle.LifecycleRegistry;
+
+/**
+ *    author : Android 轮子哥
+ *    github : https://github.com/getActivity/EasyHttp
+ *    time   : 2020/09/01
+ *    desc   : Activity 生命周期策略
+ */
+public final class ActivityLifecycle implements
+        LifecycleOwner, LifecycleEventObserver,
+        Application.ActivityLifecycleCallbacks {
+
+    private final LifecycleRegistry mLifecycle = new LifecycleRegistry(this);
+
+    private Activity mActivity;
+
+    public ActivityLifecycle(Activity activity) {
+        mActivity = activity;
+
+        if (mActivity instanceof LifecycleOwner) {
+            ((LifecycleOwner) mActivity).getLifecycle().addObserver(this);
+        } else {
+            mActivity.getApplication().registerActivityLifecycleCallbacks(this);
+        }
+    }
+
+    /**
+     * {@link LifecycleOwner}
+     */
+
+    @NonNull
+    @Override
+    public Lifecycle getLifecycle() {
+        return mLifecycle;
+    }
+
+    /**
+     * {@link LifecycleEventObserver}
+     */
+
+    @Override
+    public void onStateChanged(@NonNull LifecycleOwner source, @NonNull Lifecycle.Event event) {
+        mLifecycle.handleLifecycleEvent(event);
+        switch (event) {
+            case ON_DESTROY:
+                source.getLifecycle().removeObserver(this);
+                mActivity = null;
+                break;
+            default:
+                break;
+        }
+    }
+
+    /**
+     * {@link Application.ActivityLifecycleCallbacks}
+     */
+
+    @Override
+    public void onActivityCreated(Activity activity, Bundle savedInstanceState) {
+        if (mActivity == activity) {
+            mLifecycle.handleLifecycleEvent(Lifecycle.Event.ON_CREATE);
+        }
+    }
+
+    @Override
+    public void onActivityStarted(Activity activity) {
+        if (mActivity == activity) {
+            mLifecycle.handleLifecycleEvent(Lifecycle.Event.ON_START);
+        }
+    }
+
+    @Override
+    public void onActivityResumed(Activity activity) {
+        if (mActivity == activity) {
+            mLifecycle.handleLifecycleEvent(Lifecycle.Event.ON_RESUME);
+        }
+    }
+
+    @Override
+    public void onActivityPaused(Activity activity) {
+        if (mActivity == activity) {
+            mLifecycle.handleLifecycleEvent(Lifecycle.Event.ON_PAUSE);
+        }
+    }
+
+    @Override
+    public void onActivityStopped(Activity activity) {
+        if (mActivity == activity) {
+            mLifecycle.handleLifecycleEvent(Lifecycle.Event.ON_STOP);
+        }
+    }
+
+    @Override
+    public void onActivityDestroyed(Activity activity) {
+        if (mActivity == activity) {
+            mLifecycle.handleLifecycleEvent(Lifecycle.Event.ON_DESTROY);
+            mActivity.getApplication().unregisterActivityLifecycleCallbacks(this);
+            mActivity = null;
+        }
+    }
+
+    @Override
+    public void onActivitySaveInstanceState(Activity activity, Bundle outState) {}
+}
\ No newline at end of file
diff --git a/library/src/main/java/com/hjq/http/lifecycle/ApplicationLifecycle.java b/library/src/main/java/com/hjq/http/lifecycle/ApplicationLifecycle.java
new file mode 100644
index 0000000..ecb8b72
--- /dev/null
+++ b/library/src/main/java/com/hjq/http/lifecycle/ApplicationLifecycle.java
@@ -0,0 +1,23 @@
+package com.hjq.http.lifecycle;
+
+import androidx.annotation.NonNull;
+import androidx.lifecycle.Lifecycle;
+import androidx.lifecycle.LifecycleOwner;
+import androidx.lifecycle.LifecycleRegistry;
+
+/**
+ *    author : Android 轮子哥
+ *    github : https://github.com/getActivity/EasyHttp
+ *    time   : 2020/09/01
+ *    desc   : 全局的生命周期策略
+ */
+public final class ApplicationLifecycle implements LifecycleOwner {
+
+    private final LifecycleRegistry mLifecycle = new LifecycleRegistry(this);
+
+    @NonNull
+    @Override
+    public Lifecycle getLifecycle() {
+        return mLifecycle;
+    }
+}
\ No newline at end of file
diff --git a/library/src/main/java/com/hjq/http/model/HttpLifecycle.java b/library/src/main/java/com/hjq/http/lifecycle/HttpLifecycleControl.java
similarity index 58%
rename from library/src/main/java/com/hjq/http/model/HttpLifecycle.java
rename to library/src/main/java/com/hjq/http/lifecycle/HttpLifecycleControl.java
index 25cf659..a373b5c 100644
--- a/library/src/main/java/com/hjq/http/model/HttpLifecycle.java
+++ b/library/src/main/java/com/hjq/http/lifecycle/HttpLifecycleControl.java
@@ -1,4 +1,4 @@
-package com.hjq.http.model;
+package com.hjq.http.lifecycle;
 
 import androidx.annotation.NonNull;
 import androidx.lifecycle.Lifecycle;
@@ -13,10 +13,20 @@
  *    time   : 2020/04/05
  *    desc   : 请求生命周期控制
  */
-public class HttpLifecycle implements LifecycleEventObserver {
+public final class HttpLifecycleControl implements LifecycleEventObserver {
 
-    public static void with(LifecycleOwner lifecycleOwner) {
-        lifecycleOwner.getLifecycle().addObserver(new HttpLifecycle());
+    /**
+     * 绑定组件的生命周期
+     */
+    public static void bind(LifecycleOwner lifecycleOwner) {
+        lifecycleOwner.getLifecycle().addObserver(new HttpLifecycleControl());
+    }
+
+    /**
+     * 判断宿主是否处于活动状态
+     */
+    public static boolean isLifecycleActive(LifecycleOwner lifecycleOwner) {
+        return lifecycleOwner != null && lifecycleOwner.getLifecycle().getCurrentState() != Lifecycle.State.DESTROYED;
     }
 
     @Override
diff --git a/library/src/main/java/com/hjq/http/listener/OnDownloadListener.java b/library/src/main/java/com/hjq/http/listener/OnDownloadListener.java
index 7bd52fa..9ed5a3b 100644
--- a/library/src/main/java/com/hjq/http/listener/OnDownloadListener.java
+++ b/library/src/main/java/com/hjq/http/listener/OnDownloadListener.java
@@ -1,8 +1,6 @@
 package com.hjq.http.listener;
 
-import com.hjq.http.model.DownloadInfo;
-
-import okhttp3.Call;
+import java.io.File;
 
 /**
  *    author : Android 轮子哥
@@ -15,25 +13,25 @@ public interface OnDownloadListener {
     /**
      * 下载开始
      */
-    void onStart(Call call);
+    void onStart(File file);
 
     /**
      * 下载进度改变
      */
-    void onProgress(DownloadInfo info);
+    void onProgress(File file, long totalByte, long downloadByte, int progress);
 
     /**
      * 下载完成
      */
-    void onComplete(DownloadInfo info);
+    void onComplete(File file);
 
     /**
      * 下载出错
      */
-    void onError(DownloadInfo info, Exception e);
+    void onError(File file, Exception e);
 
     /**
      * 下载结束
      */
-    void onEnd(Call call);
+    void onEnd(File file);
 }
\ No newline at end of file
diff --git a/library/src/main/java/com/hjq/http/listener/OnUpdateListener.java b/library/src/main/java/com/hjq/http/listener/OnUpdateListener.java
new file mode 100644
index 0000000..bb0573f
--- /dev/null
+++ b/library/src/main/java/com/hjq/http/listener/OnUpdateListener.java
@@ -0,0 +1,19 @@
+package com.hjq.http.listener;
+
+/**
+ *    author : Android 轮子哥
+ *    github : https://github.com/getActivity/EasyHttp
+ *    time   : 2020/08/15
+ *    desc   : 带上传进度回调的监听器
+ */
+public interface OnUpdateListener<T> extends OnHttpListener<T> {
+
+    /**
+     * 上传进度发生变化
+     *
+     * @param totalByte         总字节数
+     * @param updateByte        已上传字节数
+     * @param progress          上传进度值（0-100）
+     */
+    void onUpdate(long totalByte, long updateByte, int progress);
+}
\ No newline at end of file
diff --git a/library/src/main/java/com/hjq/http/model/DataClass.java b/library/src/main/java/com/hjq/http/model/DataClass.java
new file mode 100644
index 0000000..3d547c1
--- /dev/null
+++ b/library/src/main/java/com/hjq/http/model/DataClass.java
@@ -0,0 +1,9 @@
+package com.hjq.http.model;
+
+/**
+ *    author : Android 轮子哥
+ *    github : https://github.com/getActivity/EasyHttp
+ *    time   : 2020/08/14
+ *    desc   : 数据解析模型类
+ */
+public abstract class DataClass<T> {}
\ No newline at end of file
diff --git a/library/src/main/java/com/hjq/http/model/DownloadInfo.java b/library/src/main/java/com/hjq/http/model/DownloadInfo.java
index 5dc5969..f281336 100644
--- a/library/src/main/java/com/hjq/http/model/DownloadInfo.java
+++ b/library/src/main/java/com/hjq/http/model/DownloadInfo.java
@@ -1,6 +1,6 @@
 package com.hjq.http.model;
 
-import java.io.File;
+import com.hjq.http.EasyUtils;
 
 /**
  *    author : Android 轮子哥
@@ -10,56 +10,36 @@
  */
 public final class DownloadInfo {
 
-    /**
-     * 文件对象
-     */
-    private final File mFile;
-
-    /**
-     * 总字节数
-     */
-    private long mTotalLength;
+    /** 总字节数 */
+    private long mTotalByte;
 
-    /**
-     * 已下载字节数
-     */
-    private long mDownloadLength;
-
-    public DownloadInfo(File file) {
-        mFile = file;
-    }
-
-    public File getFile() {
-        return mFile;
-    }
+    /** 已下载字节数 */
+    private long mDownloadByte;
 
-    public long getTotalLength() {
+    public long getTotalByte() {
         // 如果没有获取到下载内容的大小，就直接返回已下载字节大小
-        if (mTotalLength <= 0) {
-            return mDownloadLength;
+        if (mTotalByte <= 0) {
+            return mDownloadByte;
         }
-        return mTotalLength;
+        return mTotalByte;
     }
 
-    public void setTotalLength(long length) {
-        mTotalLength = length;
+    public void setTotalByte(long size) {
+        mTotalByte = size;
     }
 
-    public long getDownloadLength() {
-        return mDownloadLength;
+    public long getDownloadByte() {
+        return mDownloadByte;
     }
 
-    public void setDownloadLength(long length) {
-        mDownloadLength = length;
+    public void setDownloadByte(long size) {
+        mDownloadByte = size;
     }
 
     /**
      * 获取当前进度
      */
     public int getDownloadProgress() {
-        // 计算百分比，这里踩了两个坑
-        // 当文件很大的时候：字节数 * 100 会超过 int 最大值，计算结果会变成负数
-        // 还有需要注意的是，long 除以 long 等于 long，这里的字节数除以总字节数应该要 double 类型的
-        return (int) (((double) getDownloadLength() / getTotalLength()) * 100);
+        return EasyUtils.getProgressPercent(mTotalByte, mDownloadByte);
     }
 }
\ No newline at end of file
diff --git a/library/src/main/java/com/hjq/http/model/HttpMethod.java b/library/src/main/java/com/hjq/http/model/HttpMethod.java
index 9154625..7fbb400 100644
--- a/library/src/main/java/com/hjq/http/model/HttpMethod.java
+++ b/library/src/main/java/com/hjq/http/model/HttpMethod.java
@@ -1,5 +1,7 @@
 package com.hjq.http.model;
 
+import androidx.annotation.NonNull;
+
 /**
  *    author : Android 轮子哥
  *    github : https://github.com/getActivity/EasyHttp
@@ -8,13 +10,33 @@
  */
 public enum HttpMethod {
 
-    /**
-     * GET 请求
-     */
-    GET,
+    /** GET 请求 */
+    GET("GET"),
+
+    /** Post 请求 */
+    POST("POST"),
+
+    /** Head 请求 */
+    HEAD("HEAD"),
+
+    /** Delete 请求 */
+    DELETE("DELETE"),
+
+    /** Put 请求 */
+    PUT("PUT"),
+
+    /** Patch 请求 */
+    PATCH("PATCH");
+
+    private final String method;
+
+    HttpMethod(String method) {
+        this.method = method;
+    }
 
-    /**
-     * Post 请求
-     */
-    POST
+    @NonNull
+    @Override
+    public String toString() {
+        return method;
+    }
 }
\ No newline at end of file
diff --git a/library/src/main/java/com/hjq/http/request/BaseRequest.java b/library/src/main/java/com/hjq/http/request/BaseRequest.java
index 6993267..98d0b1f 100644
--- a/library/src/main/java/com/hjq/http/request/BaseRequest.java
+++ b/library/src/main/java/com/hjq/http/request/BaseRequest.java
@@ -8,6 +8,7 @@
 import com.hjq.http.annotation.HttpHeader;
 import com.hjq.http.annotation.HttpIgnore;
 import com.hjq.http.annotation.HttpRename;
+import com.hjq.http.callback.NormalCallback;
 import com.hjq.http.config.IRequestApi;
 import com.hjq.http.config.IRequestHost;
 import com.hjq.http.config.IRequestInterceptor;
@@ -16,7 +17,10 @@
 import com.hjq.http.config.IRequestType;
 import com.hjq.http.config.RequestApi;
 import com.hjq.http.config.RequestServer;
+import com.hjq.http.listener.OnHttpListener;
 import com.hjq.http.model.BodyType;
+import com.hjq.http.model.CallProxy;
+import com.hjq.http.model.DataClass;
 import com.hjq.http.model.HttpHeaders;
 import com.hjq.http.model.HttpParams;
 
@@ -27,6 +31,7 @@
 import okhttp3.Call;
 import okhttp3.OkHttpClient;
 import okhttp3.Request;
+import okhttp3.Response;
 
 /**
  *    author : Android 轮子哥
@@ -37,38 +42,32 @@
 @SuppressWarnings("unchecked")
 public abstract class BaseRequest<T extends BaseRequest> {
 
-    /**
-     * Http 客户端
-     */
+    /** OkHttp 客户端 */
     private OkHttpClient mClient = EasyConfig.getInstance().getClient();
 
-    /**
-     * 请求主机配置
-     */
+    /** 接口主机地址 */
     private IRequestHost mRequestHost = EasyConfig.getInstance().getServer();
-    /**
-     * 请求路径配置
-     */
+    /** 接口路径地址 */
     private IRequestPath mRequestPath = EasyConfig.getInstance().getServer();
-    /**
-     * 参数提交类型
-     */
+    /** 提交参数类型 */
     private IRequestType mRequestType = EasyConfig.getInstance().getServer();
-    /**
-     * 请求接口配置
-     */
+
+    /** 请求接口配置 */
     private IRequestApi mRequestApi;
 
-    /**
-     * 请求的上下文
-     */
+    /** 请求生命周期控制 */
     private LifecycleOwner mLifecycleOwner;
-    /**
-     * 请求标记
-     */
+
+    /** 请求执行代理类 */
+    private CallProxy mCallProxy;
+
+    /** 请求标记 */
     private String mTag;
 
     public BaseRequest(LifecycleOwner lifecycle) {
+        if (lifecycle == null) {
+            throw new IllegalArgumentException("are you ok?");
+        }
         mLifecycleOwner = lifecycle;
     }
 
@@ -161,7 +160,7 @@ public Call create() {
 
         params.setMultipart(EasyUtils.isMultipart(fields));
         // 如果参数中包含流参数并且当前请求方式不是表单的话
-        if (type != BodyType.FORM && params.isMultipart()) {
+        if (params.isMultipart() && type != BodyType.FORM) {
             // 就强制设置成以表单形式提交参数
             type = BodyType.FORM;
         }
@@ -262,9 +261,46 @@ public Call create() {
         return mClient.newCall(create(url, mTag, params, headers, type));
     }
 
-    public LifecycleOwner getLifecycleOwner() {
+    /**
+     * 执行异步请求
+     */
+    public T request(OnHttpListener listener) {
+        mCallProxy = new CallProxy(create());
+        mCallProxy.enqueue(new NormalCallback(getLifecycle(), mCallProxy, listener));
+        return (T) this;
+    }
+
+    /**
+     * 执行同步请求
+     * @param t                 需要解析泛型的对象
+     * @return                  返回解析完成的对象
+     * @throws Exception        如果请求失败或者解析失败则抛出异常
+     */
+    public <T> T execute(DataClass<T> t) throws Exception {
+        try {
+            mCallProxy = new CallProxy(create());
+            Response response = mCallProxy.execute();
+            return (T) EasyConfig.getInstance().getHandler().requestSucceed(getLifecycle(), response, EasyUtils.getReflectType(t));
+        } catch (Exception e) {
+            throw EasyConfig.getInstance().getHandler().requestFail(getLifecycle(), e);
+        }
+    }
+
+    /**
+     * 取消请求
+     */
+    public T cancel() {
+        if (mCallProxy != null) {
+            mCallProxy.cancel();
+        }
+        return (T) this;
+    }
+
+    protected LifecycleOwner getLifecycle() {
         return mLifecycleOwner;
     }
 
+    protected abstract String getMethod();
+
     protected abstract Request create(String url, String tag, HttpParams params, HttpHeaders headers, BodyType type);
 }
\ No newline at end of file
diff --git a/library/src/main/java/com/hjq/http/request/BodyRequest.java b/library/src/main/java/com/hjq/http/request/BodyRequest.java
new file mode 100644
index 0000000..b6acf70
--- /dev/null
+++ b/library/src/main/java/com/hjq/http/request/BodyRequest.java
@@ -0,0 +1,192 @@
+package com.hjq.http.request;
+
+import androidx.lifecycle.LifecycleOwner;
+
+import com.hjq.http.EasyConfig;
+import com.hjq.http.EasyLog;
+import com.hjq.http.EasyUtils;
+import com.hjq.http.body.JsonObjectBody;
+import com.hjq.http.body.MultipartBodyProxy;
+import com.hjq.http.body.UpdateBody;
+import com.hjq.http.listener.OnHttpListener;
+import com.hjq.http.listener.OnUpdateListener;
+import com.hjq.http.model.BodyType;
+import com.hjq.http.model.HttpHeaders;
+import com.hjq.http.model.HttpParams;
+
+import java.io.File;
+import java.io.InputStream;
+import java.util.List;
+import java.util.Map;
+
+import okhttp3.FormBody;
+import okhttp3.MultipartBody;
+import okhttp3.Request;
+import okhttp3.RequestBody;
+
+/**
+ *    author : Android 轮子哥
+ *    github : https://github.com/getActivity/EasyHttp
+ *    time   : 2020/10/07
+ *    desc   : Post 请求
+ */
+public abstract class BodyRequest<T extends BodyRequest> extends BaseRequest<T> {
+
+    private OnUpdateListener mListener;
+
+    private RequestBody mRequestBody;
+
+    public BodyRequest(LifecycleOwner lifecycle) {
+        super(lifecycle);
+    }
+
+    /**
+     * 自定义请求参数的 Map
+     */
+    public T body(Map map) {
+        return body(new JsonObjectBody(map));
+    }
+
+    /**
+     * 自定义请求 Body
+     */
+    public T body(RequestBody body) {
+        mRequestBody = body;
+        return (T) this;
+    }
+
+    @Override
+    protected Request create(String url, String tag, HttpParams params, HttpHeaders headers, BodyType type) {
+        Request.Builder request = new Request.Builder();
+        request.url(url);
+
+        EasyLog.print("RequestUrl", url);
+        EasyLog.print("RequestMethod", getMethod());
+
+        if (tag != null) {
+            request.tag(tag);
+        }
+
+        // 添加请求头
+        if (!headers.isEmpty()) {
+            for (String key : headers.getNames()) {
+                request.addHeader(key, headers.get(key));
+            }
+        }
+
+        RequestBody body = mRequestBody;
+        if (mRequestBody == null) {
+            if (params.isMultipart() && !params.isEmpty()) {
+                MultipartBodyProxy.Builder builder = new MultipartBodyProxy.Builder();
+                builder.setType(MultipartBody.FORM);
+                builder.setLifecycleOwner(getLifecycle());
+                builder.setOnUpdateListener(mListener);
+                for (String key : params.getNames()) {
+                    Object object = params.get(key);
+                    if (object instanceof File) {
+                        // 如果这是一个文件
+                        MultipartBody.Part part = MultipartBodyProxy.createPart(key, (File) object);
+                        if (part != null) {
+                            builder.addPart(part);
+                        }
+                    } else if (object instanceof InputStream) {
+                        // 如果这是一个输入流
+                        MultipartBody.Part part = MultipartBodyProxy.createPart(key, (InputStream) object);
+                        if (part != null) {
+                            builder.addPart(part);
+                        }
+                    } else if (object instanceof RequestBody) {
+                        // 如果这是一个自定义 RequestBody
+                        if (object instanceof UpdateBody) {
+                            builder.addFormDataPart(key, EasyUtils.encodeString(((UpdateBody) object).getName()), (RequestBody) object);
+                        } else {
+                            builder.addFormDataPart(key, null, (RequestBody) object);
+                        }
+                    } else {
+                        if (object instanceof List && EasyUtils.isFileList((List) object)) {
+                            // 上传文件列表
+                            for (Object item : (List) object) {
+                                MultipartBody.Part part = MultipartBodyProxy.createPart(key, (File) item);
+                                if (part != null) {
+                                    builder.addPart(part);
+                                }
+                            }
+                        } else {
+                            // 如果这是一个普通参数
+                            builder.addFormDataPart(key, object.toString());
+                        }
+                    }
+                }
+                try {
+                    body = builder.build();
+                } catch (IllegalStateException ignore) {
+                    // 如果里面没有任何参数会抛出异常
+                    // java.lang.IllegalStateException: Multipart body must have at least one part.
+                    body = new FormBody.Builder().build();
+                }
+            } else {
+                if (type == BodyType.JSON) {
+                    if (!params.isEmpty()) {
+                        body = new JsonObjectBody(params.getParams());
+                    } else {
+                        body = new JsonObjectBody();
+                    }
+                } else {
+                    FormBody.Builder builder = new FormBody.Builder();
+                    if (!params.isEmpty()) {
+                        for (String key : params.getNames()) {
+                            builder.add(key, params.get(key).toString());
+                        }
+                    }
+                    body = builder.build();
+                }
+            }
+        }
+        request.method(getMethod(), body);
+
+        if (EasyConfig.getInstance().isLogEnabled()) {
+
+            if (!headers.isEmpty() || !params.isEmpty()) {
+                EasyLog.print();
+            }
+
+            for (String key : headers.getNames()) {
+                EasyLog.print(key, headers.get(key));
+            }
+
+            if (!headers.isEmpty() && !params.isEmpty()) {
+                EasyLog.print();
+            }
+
+            if (body instanceof JsonObjectBody) {
+                EasyLog.json(((JsonObjectBody) body).getJsonObject().toString());
+            } else {
+                for (String key : params.getNames()) {
+                    Object value = params.get(key);
+                    if (value instanceof String) {
+                        EasyLog.print(key, "\"" + value.toString() + "\"");
+                    } else {
+                        EasyLog.print(key, value.toString());
+                    }
+                }
+            }
+
+            if (!headers.isEmpty() || !params.isEmpty()) {
+                EasyLog.print();
+            }
+        }
+
+        return request.build();
+    }
+
+    /**
+     * 执行异步请求（执行传入上传进度监听器）
+     */
+    @Override
+    public T request(OnHttpListener listener) {
+        if (listener instanceof OnUpdateListener) {
+            mListener = (OnUpdateListener) listener;
+        }
+        return super.request(listener);
+    }
+}
\ No newline at end of file
diff --git a/library/src/main/java/com/hjq/http/request/DeleteRequest.java b/library/src/main/java/com/hjq/http/request/DeleteRequest.java
new file mode 100644
index 0000000..05dc627
--- /dev/null
+++ b/library/src/main/java/com/hjq/http/request/DeleteRequest.java
@@ -0,0 +1,23 @@
+package com.hjq.http.request;
+
+import androidx.lifecycle.LifecycleOwner;
+
+import com.hjq.http.model.HttpMethod;
+
+/**
+ *    author : Android 轮子哥
+ *    github : https://github.com/getActivity/EasyHttp
+ *    time   : 2020/10/07
+ *    desc   : Delete 请求
+ */
+public final class DeleteRequest extends BodyRequest<DeleteRequest> {
+
+    public DeleteRequest(LifecycleOwner lifecycle) {
+        super(lifecycle);
+    }
+
+    @Override
+    protected String getMethod() {
+        return HttpMethod.DELETE.toString();
+    }
+}
\ No newline at end of file
diff --git a/library/src/main/java/com/hjq/http/request/DownloadRequest.java b/library/src/main/java/com/hjq/http/request/DownloadRequest.java
index 77a9af0..0647c87 100644
--- a/library/src/main/java/com/hjq/http/request/DownloadRequest.java
+++ b/library/src/main/java/com/hjq/http/request/DownloadRequest.java
@@ -6,8 +6,10 @@
 import com.hjq.http.config.RequestApi;
 import com.hjq.http.config.RequestServer;
 import com.hjq.http.listener.OnDownloadListener;
+import com.hjq.http.listener.OnHttpListener;
 import com.hjq.http.model.BodyType;
 import com.hjq.http.model.CallProxy;
+import com.hjq.http.model.DataClass;
 import com.hjq.http.model.HttpHeaders;
 import com.hjq.http.model.HttpMethod;
 import com.hjq.http.model.HttpParams;
@@ -24,30 +26,23 @@
  */
 public final class DownloadRequest extends BaseRequest<DownloadRequest> {
 
-    /**
-     * 下载方式
-     */
+    /** 下载请求方式 */
     private HttpMethod mMethod = HttpMethod.GET;
 
-    /**
-     * 保存的文件
-     */
+    /** 保存的文件 */
     private File mFile;
-    /**
-     * 校验的 MD5
-     */
-    private String mMD5;
-    /**
-     * 下载监听回调
-     */
+
+    /** 校验的 md5 */
+    private String mMd5;
+
+    /** 下载监听回调 */
     private OnDownloadListener mListener;
-    /**
-     * 下载请求对象
-     */
+
+    /** 请求执行对象 */
     private CallProxy mCallProxy;
 
-    public DownloadRequest(LifecycleOwner lifecycleOwner) {
-        super(lifecycleOwner);
+    public DownloadRequest(LifecycleOwner lifecycle) {
+        super(lifecycle);
     }
 
     /**
@@ -84,7 +79,7 @@ public DownloadRequest file(String file) {
      * 设置 MD5 值
      */
     public DownloadRequest md5(String md5) {
-        mMD5 = md5;
+        mMd5 = md5;
         return this;
     }
 
@@ -101,10 +96,10 @@ protected Request create(String url, String tag, HttpParams params, HttpHeaders
         switch (mMethod) {
             case GET:
                 // 如果这个下载请求方式是 Get
-                return new GetRequest(getLifecycleOwner()).create(url, tag, params, headers, type);
+                return new GetRequest(getLifecycle()).create(url, tag, params, headers, type);
             case POST:
                 // 如果这个下载请求方式是 Post
-                return new PostRequest(getLifecycleOwner()).create(url, tag, params, headers, type);
+                return new PostRequest(getLifecycle()).create(url, tag, params, headers, type);
             default:
                 throw new IllegalStateException("are you ok?");
         }
@@ -116,16 +111,40 @@ protected Request create(String url, String tag, HttpParams params, HttpHeaders
     public DownloadRequest start() {
         mCallProxy = new CallProxy(create());
         /** 下载回调对象 */
-        mCallProxy.enqueue(new DownloadCallback(getLifecycleOwner(), mCallProxy, mFile, mMD5, mListener));
+        mCallProxy.enqueue(new DownloadCallback(getLifecycle(), mCallProxy, mFile, mMd5, mListener));
         return this;
     }
 
     /**
      * 取消下载
      */
-    public void cancel() {
+    public DownloadRequest stop() {
         if (mCallProxy != null) {
             mCallProxy.cancel();
         }
+        return this;
+    }
+
+    @Override
+    public DownloadRequest request(OnHttpListener listener) {
+        // 请调用 start 方法
+        throw new IllegalStateException("are you ok?");
+    }
+
+    @Override
+    public <T> T execute(DataClass<T> t) {
+        // 请调用 start 方法
+        throw new IllegalStateException("are you ok?");
+    }
+
+    @Override
+    public DownloadRequest cancel() {
+        // 请调用 stop 方法
+        throw new IllegalStateException("are you ok?");
+    }
+
+    @Override
+    protected String getMethod() {
+        return mMethod.toString();
     }
 }
\ No newline at end of file
diff --git a/library/src/main/java/com/hjq/http/request/GetRequest.java b/library/src/main/java/com/hjq/http/request/GetRequest.java
index 0ec9644..7bfd6e7 100644
--- a/library/src/main/java/com/hjq/http/request/GetRequest.java
+++ b/library/src/main/java/com/hjq/http/request/GetRequest.java
@@ -1,74 +1,23 @@
-package com.hjq.http.request;
-
-import androidx.lifecycle.LifecycleOwner;
-
-import com.hjq.http.EasyLog;
-import com.hjq.http.callback.NormalCallback;
-import com.hjq.http.listener.OnHttpListener;
-import com.hjq.http.model.BodyType;
-import com.hjq.http.model.CallProxy;
-import com.hjq.http.model.HttpHeaders;
-import com.hjq.http.model.HttpParams;
-
-import okhttp3.HttpUrl;
-import okhttp3.Request;
-
-/**
- *    author : Android 轮子哥
- *    github : https://github.com/getActivity/EasyHttp
- *    time   : 2019/07/20
- *    desc   : Get 请求
- */
-public final class GetRequest extends BaseRequest<GetRequest> {
-
-    private CallProxy mCallProxy;
-
-    public GetRequest(LifecycleOwner lifecycleOwner) {
-        super(lifecycleOwner);
-    }
-
-    @Override
-    protected Request create(String url, String tag, HttpParams params, HttpHeaders headers, BodyType type) {
-        Request.Builder request = new Request.Builder();
-
-        if (tag != null) {
-            request.tag(tag);
-        }
-
-        // 添加请求头
-        if (!headers.isEmpty()) {
-            for (String key : headers.getNames()) {
-                request.addHeader(key, headers.get(key));
-            }
-        }
-
-        HttpUrl.Builder builder = HttpUrl.get(url).newBuilder();
-        // 添加参数
-        if (!params.isEmpty()) {
-            for (String key : params.getNames()) {
-                builder.addEncodedQueryParameter(key, params.get(key).toString());
-            }
-        }
-        HttpUrl link = builder.build();
-        request.get().url(link);
-
-        EasyLog.print("GetUrl", link.toString());
-        return request.build();
-    }
-
-    /**
-     * 执行请求
-     */
-    public GetRequest request(OnHttpListener listener) {
-        mCallProxy = new CallProxy(create());
-        mCallProxy.enqueue(new NormalCallback(getLifecycleOwner(), mCallProxy, listener));
-        return this;
-    }
-
-    /**
-     * 取消请求
-     */
-    public void cancel() {
-        mCallProxy.cancel();
-    }
+package com.hjq.http.request;
+
+import androidx.lifecycle.LifecycleOwner;
+
+import com.hjq.http.model.HttpMethod;
+
+/**
+ *    author : Android 轮子哥
+ *    github : https://github.com/getActivity/EasyHttp
+ *    time   : 2019/07/20
+ *    desc   : Get 请求
+ */
+public final class GetRequest extends UrlRequest<GetRequest> {
+
+    public GetRequest(LifecycleOwner lifecycle) {
+        super(lifecycle);
+    }
+
+    @Override
+    protected String getMethod() {
+        return HttpMethod.GET.toString();
+    }
 }
\ No newline at end of file
diff --git a/library/src/main/java/com/hjq/http/request/HeadRequest.java b/library/src/main/java/com/hjq/http/request/HeadRequest.java
new file mode 100644
index 0000000..86ea3ac
--- /dev/null
+++ b/library/src/main/java/com/hjq/http/request/HeadRequest.java
@@ -0,0 +1,23 @@
+package com.hjq.http.request;
+
+import androidx.lifecycle.LifecycleOwner;
+
+import com.hjq.http.model.HttpMethod;
+
+/**
+ *    author : Android 轮子哥
+ *    github : https://github.com/getActivity/EasyHttp
+ *    time   : 2020/10/07
+ *    desc   : Head 请求
+ */
+public final class HeadRequest extends UrlRequest<HeadRequest> {
+
+    public HeadRequest(LifecycleOwner lifecycle) {
+        super(lifecycle);
+    }
+
+    @Override
+    protected String getMethod() {
+        return HttpMethod.HEAD.toString();
+    }
+}
\ No newline at end of file
diff --git a/library/src/main/java/com/hjq/http/request/PatchRequest.java b/library/src/main/java/com/hjq/http/request/PatchRequest.java
new file mode 100644
index 0000000..d5c6721
--- /dev/null
+++ b/library/src/main/java/com/hjq/http/request/PatchRequest.java
@@ -0,0 +1,23 @@
+package com.hjq.http.request;
+
+import androidx.lifecycle.LifecycleOwner;
+
+import com.hjq.http.model.HttpMethod;
+
+/**
+ *    author : Android 轮子哥
+ *    github : https://github.com/getActivity/EasyHttp
+ *    time   : 2020/10/07
+ *    desc   : Patch 请求
+ */
+public final class PatchRequest extends BodyRequest<PatchRequest> {
+
+    public PatchRequest(LifecycleOwner lifecycle) {
+        super(lifecycle);
+    }
+
+    @Override
+    protected String getMethod() {
+        return HttpMethod.PATCH.toString();
+    }
+}
\ No newline at end of file
diff --git a/library/src/main/java/com/hjq/http/request/PostRequest.java b/library/src/main/java/com/hjq/http/request/PostRequest.java
index 93c326e..f42b09b 100644
--- a/library/src/main/java/com/hjq/http/request/PostRequest.java
+++ b/library/src/main/java/com/hjq/http/request/PostRequest.java
@@ -2,171 +2,22 @@
 
 import androidx.lifecycle.LifecycleOwner;
 
-import com.hjq.http.EasyConfig;
-import com.hjq.http.EasyLog;
-import com.hjq.http.EasyUtils;
-import com.hjq.http.callback.NormalCallback;
-import com.hjq.http.listener.OnHttpListener;
-import com.hjq.http.model.BodyType;
-import com.hjq.http.model.CallProxy;
-import com.hjq.http.model.HttpHeaders;
-import com.hjq.http.model.HttpParams;
-import com.hjq.http.model.JsonBody;
-import com.hjq.http.model.UpdateBody;
-
-import java.io.File;
-import java.io.InputStream;
-import java.util.List;
-
-import okhttp3.FormBody;
-import okhttp3.MultipartBody;
-import okhttp3.Request;
-import okhttp3.RequestBody;
+import com.hjq.http.model.HttpMethod;
 
 /**
  *    author : Android 轮子哥
  *    github : https://github.com/getActivity/EasyHttp
  *    time   : 2019/07/20
- *    desc   : Post 请求
+ *    desc   : 主体请求
  */
-public final class PostRequest extends BaseRequest<PostRequest> {
-
-    private CallProxy mCallProxy;
+public final class PostRequest extends BodyRequest<PostRequest> {
 
-    public PostRequest(LifecycleOwner lifecycleOwner) {
-        super(lifecycleOwner);
+    public PostRequest(LifecycleOwner lifecycle) {
+        super(lifecycle);
     }
 
     @Override
-    protected Request create(String url, String tag, HttpParams params, HttpHeaders headers, BodyType type) {
-        Request.Builder request = new Request.Builder();
-        request.url(url);
-
-        EasyLog.print("PostUrl", url);
-
-        if (tag != null) {
-            request.tag(tag);
-        }
-
-        // 添加请求头
-        if (!headers.isEmpty()) {
-            for (String key : headers.getNames()) {
-                request.addHeader(key, headers.get(key));
-            }
-        }
-
-        RequestBody body;
-        if (params.isMultipart()) {
-            MultipartBody.Builder builder = new MultipartBody.Builder();
-            builder.setType(MultipartBody.FORM);
-            if (!params.isEmpty()) {
-                for (String key : params.getNames()) {
-                    Object object = params.get(key);
-                    if (object instanceof File) {
-                        // 如果这是一个文件
-                        MultipartBody.Part part = UpdateBody.createPart(key, (File) object);
-                        if (part != null) {
-                            builder.addPart(part);
-                        }
-                    } else if (object instanceof InputStream) {
-                        // 如果这是一个输入流
-                        MultipartBody.Part part = UpdateBody.createPart(key, (InputStream) object);
-                        if (part != null) {
-                            builder.addPart(part);
-                        }
-                    } else if (object instanceof RequestBody) {
-                        // 如果这是一个自定义 RequestBody
-                        builder.addFormDataPart(key, null, (RequestBody) object);
-                    } else {
-                        if (object instanceof List && EasyUtils.isFileList((List) object)) {
-                            // 上传文件列表
-                            for (Object item : (List) object) {
-                                MultipartBody.Part part = UpdateBody.createPart(key, (File) item);
-                                if (part != null) {
-                                    builder.addPart(part);
-                                }
-                            }
-                        } else {
-                            // 如果这是一个普通参数
-                            builder.addFormDataPart(key, object.toString());
-                        }
-                    }
-                }
-            }
-            try {
-                body = builder.build();
-            } catch (IllegalStateException ignore) {
-                // 如果里面没有任何参数会抛出异常
-                // java.lang.IllegalStateException: Multipart body must have at least one part.
-                body = new FormBody.Builder().build();
-            }
-        } else {
-            if (type == BodyType.JSON) {
-                if (!params.isEmpty()) {
-                    body = new JsonBody(params.getParams());
-                } else {
-                    body = new JsonBody();
-                }
-            } else {
-                FormBody.Builder builder = new FormBody.Builder();
-                if (!params.isEmpty()) {
-                    for (String key : params.getNames()) {
-                        builder.add(key, params.get(key).toString());
-                    }
-                }
-                body = builder.build();
-            }
-        }
-        request.post(body);
-
-        if (EasyConfig.getInstance().isLogEnabled()) {
-
-            if (!headers.isEmpty() || !params.isEmpty()) {
-                EasyLog.print();
-            }
-
-            for (String key : headers.getNames()) {
-                EasyLog.print(key, headers.get(key));
-            }
-
-            if (!headers.isEmpty() && !params.isEmpty()) {
-                EasyLog.print();
-            }
-
-            if (body instanceof JsonBody) {
-                EasyLog.json(((JsonBody) body).getJsonObject().toString());
-            } else {
-                for (String key : params.getNames()) {
-                    Object value = params.get(key);
-                    if (value instanceof String) {
-                        EasyLog.print(key, "\"" + value.toString() + "\"");
-                    } else {
-                        EasyLog.print(key, value.toString());
-                    }
-                }
-            }
-
-            if (!headers.isEmpty() || !params.isEmpty()) {
-                EasyLog.print();
-            }
-        }
-
-        return request.build();
-    }
-
-    /**
-     * 执行请求
-     */
-    public PostRequest request(OnHttpListener listener) {
-        mCallProxy = new CallProxy(create());
-        mCallProxy.enqueue(new NormalCallback(getLifecycleOwner(), mCallProxy, listener));
-        return this;
-    }
-
-    /**
-     * 取消请求
-     */
-    public void cancel() {
-        mCallProxy.cancel();
+    protected String getMethod() {
+        return HttpMethod.POST.toString();
     }
 }
\ No newline at end of file
diff --git a/library/src/main/java/com/hjq/http/request/PutRequest.java b/library/src/main/java/com/hjq/http/request/PutRequest.java
new file mode 100644
index 0000000..1b2c5c1
--- /dev/null
+++ b/library/src/main/java/com/hjq/http/request/PutRequest.java
@@ -0,0 +1,23 @@
+package com.hjq.http.request;
+
+import androidx.lifecycle.LifecycleOwner;
+
+import com.hjq.http.model.HttpMethod;
+
+/**
+ *    author : Android 轮子哥
+ *    github : https://github.com/getActivity/EasyHttp
+ *    time   : 2020/10/07
+ *    desc   : Put 请求
+ */
+public final class PutRequest extends BodyRequest<PutRequest> {
+
+    public PutRequest(LifecycleOwner lifecycle) {
+        super(lifecycle);
+    }
+
+    @Override
+    protected String getMethod() {
+        return HttpMethod.PUT.toString();
+    }
+}
\ No newline at end of file
diff --git a/library/src/main/java/com/hjq/http/request/UrlRequest.java b/library/src/main/java/com/hjq/http/request/UrlRequest.java
new file mode 100644
index 0000000..9e49d76
--- /dev/null
+++ b/library/src/main/java/com/hjq/http/request/UrlRequest.java
@@ -0,0 +1,69 @@
+package com.hjq.http.request;
+
+import androidx.lifecycle.LifecycleOwner;
+
+import com.hjq.http.EasyLog;
+import com.hjq.http.model.BodyType;
+import com.hjq.http.model.HttpHeaders;
+import com.hjq.http.model.HttpParams;
+
+import okhttp3.CacheControl;
+import okhttp3.HttpUrl;
+import okhttp3.Request;
+
+/**
+ *    author : Android 轮子哥
+ *    github : https://github.com/getActivity/EasyHttp
+ *    time   : 2020/10/07
+ *    desc   : url 类型请求
+ */
+public abstract class UrlRequest<T extends UrlRequest> extends BaseRequest<T> {
+
+    private CacheControl mCacheControl;
+
+    public UrlRequest(LifecycleOwner lifecycle) {
+        super(lifecycle);
+    }
+
+    /**
+     * 设置缓存模式
+     */
+    public T cache(CacheControl cacheControl) {
+        mCacheControl = cacheControl;
+        return (T) this;
+    }
+
+    @Override
+    protected Request create(String url, String tag, HttpParams params, HttpHeaders headers, BodyType type) {
+        Request.Builder request = new Request.Builder();
+        if (mCacheControl != null) {
+            request.cacheControl(mCacheControl);
+        }
+
+        if (tag != null) {
+            request.tag(tag);
+        }
+
+        // 添加请求头
+        if (!headers.isEmpty()) {
+            for (String key : headers.getNames()) {
+                request.addHeader(key, headers.get(key));
+            }
+        }
+
+        HttpUrl.Builder builder = HttpUrl.get(url).newBuilder();
+        // 添加参数
+        if (!params.isEmpty()) {
+            for (String key : params.getNames()) {
+                builder.addEncodedQueryParameter(key, params.get(key).toString());
+            }
+        }
+        HttpUrl link = builder.build();
+        request.url(link);
+        request.method(getMethod(), null);
+
+        EasyLog.print("RequestUrl", link.toString());
+        EasyLog.print("RequestMethod", getMethod());
+        return request.build();
+    }
+}
\ No newline at end of file