本库是一款基于 RxJava2+Retrofit2 实现简单易用的网络请求框架，结合 android 平台特性的网络封装库,采用 api 链式调用一点到底,集成 cookie 管理,多种缓存模式,极简 https 配置,上传下载进度显示,请求错误自动重试,请求携带 token、时间戳、签名 sign 动态配置,自动登录成功后请求重发功能,3 种层次的参数设置默认全局局部,默认标准 ApiResult 同时可以支持自定义的数据结构，已经能满足现在的大部分网络请求。 注：Retrofit 和 Rxjava 是当下非常火爆的开源框架，均来自神一般的公司。本库就不介绍 Retrofit 和 Rxjava2 的用法。

为什么会封装此库？

网上好的开源网络库像 Volley、async-http、okhttp、retrofit 等都非常强大，但是实际应用中我们不会直接去使用，一般都会根据自己的业务再封装一层，这样更方便快捷，又能统一处理业务共性的东西例如：统一的数据结构（code、msg、data）、token 处理、网络异常等情况。在使用 retrofit 来请求网络的时候，项目的需求越来越多，api 也随之越来越多，一个普通的应用 api 一般也在 100+左右。如果把这些 api 放在一个 ApiService 内会很臃肿，不利于查看 api.如果采用模块的方式对 api 进行分类，每个模块对应若干个 api.以 retrofit 的使用方式又需要创建若干个 ApiService，这种方式维护方便，但是模块增多了，类也增多了很多。对于懒人来说就想通过一个 URL 就能回调你所需要的数据，什么 ApiService 都不想理会，同时又可以很快的与自己的业务相关联，就类似于代替你在开源网络库基础上再封装一层的作用，于是本库就应运而生。

特点

• 比 Retrofit 使用更简单、更易用。
• 采用链式调用一点到底
• 加入基础 ApiService，减少 Api 冗余
• 支持动态配置和自定义底层框架 Okhttpclient、Retrofit.
• 支持多种方式访问网络 GET、POST、PUT、DELETE 等请求协议
• 支持网络缓存,八种缓存策略可选,涵盖大多数业务场景
• 支持固定添加 header 和动态添加 header
• 支持添加全局参数和动态添加局部参数
• 支持文件下载、多文件上传和表单提交数据
• 支持文件请求、上传、下载的进度回调、错误回调，也可以自定义回调
• 支持默认、全局、局部三个层次的配置功能
• 支持任意数据结构的自动解析
• 支持添加动态参数例如 timeStamp 时间戳、token、签名 sign
• 支持自定义的扩展 API
• 支持多个请求合并
• 支持 Cookie 管理
• 支持异步、同步请求
• 支持 Https、自签名网站 Https 的访问、双向验证
• 支持失败重试机制，可以指定重试次数、重试间隔时间
• 支持根据 ky 删除网络缓存和清空网络缓存
• 提供默认的标准 ApiResult 解析和回调，并且可自定义 ApiResult
• 支持取消数据请求，取消订阅，带有对话框的请求不需要手动取消请求，对话框消失会自动取消请求
• 支持请求数据结果采用回调和订阅两种方式
• api 设计上结合 http 协议和 android 平台特点来实现,loading 对话框,实时进度条显示
• 返回结果和异常统一处理
• 结合 RxJava2，线程智能控制

关于我

联系方式

本群旨在为使用我 github 项目的人提供方便，如果遇到问题欢迎在群里提问。

欢迎加入 QQ 交流群（Q1 群已满，请加入 Q2 群）

演示（请 star 支持）

RxEasyHttp 与 Rxjava 结合使用场景演示

RxEasyHttp 网络库与 Rxjava2 结合常见使用场景介绍 点我！！！>>

版本说明

当前版本

历史版本，点我、点我、点我>>

用法介绍

目前只支持主流开发工具 AndtoidStudio 的使用，没有提供 Eclipse 使用方式. 本项目 Demo 的网络请求的服务器地址为了安全，把 url 去掉了，但是 Demo 程序中的示例都是 ok 的

点击按钮下载 Demo

扫码下载 Demo

build.gradle 设置

dependencies {
 compile 'com.zhouyou:rxeasyhttp:2.1.5'
}

想查看所有版本，请点击下面地址。

权限说明

如果使用本库实现文件下载到 SD 卡、或者配置了缓存数据到 SD 卡，你必须要考虑到 Android6.0 及以上系统的运行时权限，给大家推荐两个权限库：

AndPermission
RxPermissions

因为要请求网络、从 SD 卡读写缓存、下载文件到 SD 卡等等，所以需要在 manifest.xml 中配置以下几个权限，如果你已经配置过了这些权限，请不要重复配置：

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

全局配置

一般在 Aplication，或者基类中，只需要调用一次即可，可以配置调试开关，全局的超时时间，公共的请求头和请求参数等信息 初始化需要一个 Context，最好在 Application#onCreate()中初始化，记得在 manifest.xml 中注册 Application。

Application:

public class MyApplication extends Application {
    @Override
    public void onCreate() {
        super.onCreate();
    }
}

manifest.xml：

...

<application
    android:name=".MyApplication"
    ...
 />

默认初始化

如果使用默认始化后，一切采用默认设置。如果你需要配置全局超时时间、缓存、Cookie、底层为 OkHttp 的话，请看高级初始化。

public class MyApplication extends Application {

    @Override
    public void onCreate() {
        super.onCreate();
        EasyHttp.init(this);//默认初始化
    }
}

高级初始化

可以进行超时配置、网络缓存配置、okhttp 相关参数配置、retrofit 相关参数配置、cookie 配置等，这些参数可以选择性的根据业务需要配置。

public class MyApplication extends Application {

    @Override
    public void onCreate() {
        super.onCreate();
        EasyHttp.init(this);//默认初始化,必须调用

        //全局设置请求头
        HttpHeaders headers = new HttpHeaders();
        headers.put("User-Agent", SystemInfoUtils.getUserAgent(this, AppConstant.APPID));
        //全局设置请求参数
        HttpParams params = new HttpParams();
        params.put("appId", AppConstant.APPID);

        //以下设置的所有参数是全局参数,同样的参数可以在请求的时候再设置一遍,那么对于该请求来讲,请求中的参数会覆盖全局参数
        EasyHttp.getInstance()

                //可以全局统一设置全局 URL
                .setBaseUrl(Url)//设置全局 URL  url 只能是域名 或者域名+端口号 

                // 打开该调试开关并设置 TAG,不需要就不要加入该行
                // 最后的 true 表示是否打印内部异常，一般打开方便调试错误
                .debug("EasyHttp", true)

                //如果使用默认的 60 秒,以下三行也不需要设置
                .setReadTimeOut(60 * 1000)
                .setWriteTimeOut(60 * 100)
                .setConnectTimeout(60 * 100)

                //可以全局统一设置超时重连次数,默认为 3 次,那么最差的情况会请求 4 次(一次原始请求,三次重连请求),
                //不需要可以设置为 0
                .setRetryCount(3)//网络不好自动重试 3 次
                //可以全局统一设置超时重试间隔时间,默认为 500ms,不需要可以设置为 0
                .setRetryDelay(500)//每次延时 500ms 重试
                //可以全局统一设置超时重试间隔叠加时间,默认为 0ms 不叠加
                .setRetryIncreaseDelay(500)//每次延时叠加 500ms

                //可以全局统一设置缓存模式,默认是不使用缓存,可以不传,具体请看 CacheMode
                .setCacheMode(CacheMode.NO_CACHE)
                //可以全局统一设置缓存时间,默认永不过期
                .setCacheTime(-1)//-1 表示永久缓存,单位:秒 ，Okhttp 和自定义 RxCache 缓存都起作用
                //全局设置自定义缓存保存转换器，主要针对自定义 RxCache 缓存
                .setCacheDiskConverter(new SerializableDiskConverter())//默认缓存使用序列化转化
                //全局设置自定义缓存大小，默认 50M
                .setCacheMaxSize(100 * 1024 * 1024)//设置缓存大小为 100M
                //设置缓存版本，如果缓存有变化，修改版本后，缓存就不会被加载。特别是用于版本重大升级时缓存不能使用的情况
                .setCacheVersion(1)//缓存版本为 1
                //.setHttpCache(new Cache())//设置 Okhttp 缓存，在缓存模式为 DEFAULT 才起作用

                //可以设置 https 的证书,以下几种方案根据需要自己设置
                .setCertificates()                                  //方法一：信任所有证书,不安全有风险
                //.setCertificates(new SafeTrustManager())            //方法二：自定义信任规则，校验服务端证书
                //配置 https 的域名匹配规则，不需要就不要加入，使用不当会导致 https 握手失败
                //.setHostnameVerifier(new SafeHostnameVerifier())
                //.addConverterFactory(GsonConverterFactory.create(gson))//本框架没有采用 Retrofit 的 Gson 转化，所以不用配置
                .addCommonHeaders(headers)//设置全局公共头
                .addCommonParams(params)//设置全局公共参数
                //.addNetworkInterceptor(new NoCacheInterceptor())//设置网络拦截器
                //.setCallFactory()//局设置 Retrofit 对象 Factory
                //.setCookieStore()//设置 cookie
                //.setOkproxy()//设置全局代理
                //.setOkconnectionPool()//设置请求连接池
                //.setCallbackExecutor()//全局设置 Retrofit callbackExecutor
                //可以添加全局拦截器，不需要就不要加入，错误写法直接导致任何回调不执行
                //.addInterceptor(new GzipRequestInterceptor())//开启 post 数据进行 gzip 后发送给服务器
                .addInterceptor(new CustomSignInterceptor());//添加参数签名拦截器
    }
}

请求数据

网络请求，采用链式调用，支持一点到底。

入口方法

  /**
     * get 请求
     */
    public static GetRequest get(String url);

    /**
     * post 请求和文件上传
     */
    public static PostRequest post(String url);

    /**
     * delete 请求
     */
    public static DeleteRequest delete(String url) ;

    /**
     * 自定义请求
     */
    public static CustomRequest custom();

    /**
     * 文件下载
     */
    public static DownloadRequest downLoad(String url) ;

    /**
     * put 请求
     */
    public static PutRequest put(String url);

通用功能配置

1.包含一次普通请求所有能配置的参数，真实使用时不需要配置这么多，按自己的需要选择性的使用即可
2.以下配置全部是单次请求配置，不会影响全局配置，没有配置的仍然是使用全局参数。
3.为单个请求设置超时，比如涉及到文件的需要设置读写等待时间多一点。
完整参数 GET 示例：

EasyHttp.get("/v1/app/chairdressing/skinAnalyzePower/skinTestResult")
                .baseUrl("http://www.xxxx.com")//设置 url
                .writeTimeOut(30*1000)//局部写超时 30s,单位毫秒
                .readTimeOut(30*1000)//局部读超时 30s,单位毫秒
                .connectTimeout(30*1000)//局部连接超时 30s,单位毫秒
                .headers(new HttpHeaders("header1","header1Value"))//添加请求头参数
                .headers("header2","header2Value")//支持添加多个请求头同时添加
                .headers("header3","header3Value")//支持添加多个请求头同时添加
                .params("param1","param1Value")//支持添加多个参数同时添加
                .params("param2","param2Value")//支持添加多个参数同时添加
                //.addCookie(new CookieManger(this).addCookies())//支持添加 Cookie
                .cacheTime(300)//缓存 300s 单位 s
                .cacheKey("cachekey")//缓存 key
                .cacheMode(CacheMode.CACHEANDREMOTE)//设置请求缓存模式
                //.okCache()//使用模式缓存模式时，走 Okhttp 缓存
                .cacheDiskConverter(new GsonDiskConverter())//GSON-数据转换器
                //.certificates()添加证书
                .retryCount(5)//本次请求重试次数
                .retryDelay(500)//本次请求重试延迟时间 500ms
                .addInterceptor(Interceptor)//添加拦截器
                .okproxy()//设置代理
                .removeHeader("header2")//移除头部 header2
                .removeAllHeaders()//移除全部请求头
                .removeParam("param1")
                .accessToken(true)//本次请求是否追加 token
                .timeStamp(false)//本次请求是否携带时间戳
                .sign(false)//本次请求是否需要签名
                .syncRequest(true)//是否是同步请求，默认异步请求。true:同步请求
                .execute(new CallBack<SkinTestResult>() {
                    @Override
                    public void onStart() {
                        //开始请求
                    }

                    @Override
                    public void onCompleted() {
                       //请求完成
                    }

                    @Override
                    public void onError(ApiException e) {
                      //请求错误
                    }

                    @Override
                    public void onSuccess(SkinTestResult response) {
                      //请求成功
                    }
                });

url

Url 可以通过初始化配置的时候传入EasyHttp.getInstance().setBaseUrl("http://www.xxx.com");
入口方法传入： EasyHttp.get("/v1/app/chairdressing/skinAnalyzePower/skinTestResult").baseUrl("http://www.xxxx.com") 如果入口方法中传入的 url 含有 http 或者 https,则不会拼接初始化设置的 baseUrl. 例如：EasyHttp.get("http://www.xxx.com/v1/app/chairdressing/skinAnalyzePower/skinTestResult")则 setBaseUrl()和 baseUrl()传入的 baseurl 都不会被拼接。 注:EasyHttp.get/post/put/等采用拼接的用法时请注意，url 要用/斜杠开头，例如：EasyHttp.get("/v1/login") 正确 EasyHttp.get("v1/login") 错误

http 请求参数

两种设置方式 .params(HttpParams params) .params("param1","param1Value")//添加参数键值对

HttpParams params = new HttpParams(); params.put("appId", AppConstant.APPID); .addCommonParams(params)//设置全局公共参数

http 请求头

.headers(HttpHeaders headers) .headers("header2","header2Value")//添加参数键值对

.addCommonHeaders(headers)//设置全局公共头

普通网络请求

支持 get/post/delete/put 等 链式调用的终点请求的执行方式有：execute(Class clazz) 、execute(Type type)、execute(CallBack callBack)三种方式，都是针对标准的 ApiResult

execute(CallBack callBack)

1.EasyHttp（推荐） 示例：

方式一：
 //EasyHttp.post("/v1/app/chairdressing/skinAnalyzePower/skinTestResult")
 EasyHttp.get("/v1/app/chairdressing/skinAnalyzePower/skinTestResult")
                .readTimeOut(30 * 1000)//局部定义读超时
                .writeTimeOut(30 * 1000)
                .connectTimeout(30 * 1000)
                .params("name","张三")
                .timeStamp(true)
                .execute(new SimpleCallBack<SkinTestResult>() {
                    @Override
                    public void onError(ApiException e) {
                        showToast(e.getMessage());
                    }

                    @Override
                    public void onSuccess(SkinTestResult response) {
                        if (response != null) showToast(response.toString());
                    }
                });

2.手动创建请求对象

 //GetRequest 、PostRequest、DeleteRequest、PutRequest
 GetRequest request = new GetRequest("/v1/app/chairdressing/skinAnalyzePower/skinTestResult");
        request.readTimeOut(30 * 1000)//局部定义读超时
                .params("param1", "param1Value1")
                .execute(new SimpleCallBack<SkinTestResult>() {
                    @Override
                    public void onError(ApiException e) {

                    }

                    @Override
                    public void onSuccess(SkinTestResult response) {

                    }
                });

execute(Class clazz)和 execute(Type type)

execute(Class clazz)和 execute(Type type)功能基本一样，execute(Type type)主要是针对集合不能直接传递 Class

EasyHttp.get(url)
                .params("param1", "paramValue1")
                .execute(SkinTestResult.class)//非常简单直接传目标 class
                //.execute(new TypeToken<List<SectionItem>>() {}.getType())//Type 类型
                .subscribe(new BaseSubscriber<SkinTestResult>() {
                    @Override
                    public void onError(ApiException e) {
                        showToast(e.getMessage());
                    }

                    @Override
                    public void onNext(SkinTestResult skinTestResult) {
                        showToast(skinTestResult.toString());
                    }
                });

请求返回 Disposable

网络请求会返回 Disposable 对象，方便取消网络请求

Disposable disposable = EasyHttp.get("/v1/app/chairdressing/skinAnalyzePower/skinTestResult")
                .params("param1", "paramValue1")
                .execute(new SimpleCallBack<SkinTestResult>() {
                    @Override
                    public void onError(ApiException e) {
                        showToast(e.getMessage());
                    }

                    @Override
                    public void onSuccess(SkinTestResult response) {
                        showToast(response.toString());
                    }
                });

        //在需要取消网络请求的地方调用,一般在 onDestroy()中
        //EasyHttp.cancelSubscription(disposable);

带有进度框的请求

带有进度框的请求，可以设置对话框消失是否自动取消网络和自定义对话框功能，具体参数作用请看请求回调讲解

方式一：ProgressDialogCallBack

ProgressDialogCallBack 带有进度框的请求，可以设置对话框消失是否自动取消网络和自定义对话框功能，具体参数作用请看自定义 CallBack 讲解

 IProgressDialog mProgressDialog = new IProgressDialog() {
            @Override
            public Dialog getDialog() {
                ProgressDialog dialog = new ProgressDialog(MainActivity.this);
                dialog.setMessage("请稍候...");
                return dialog;
            }
        };
        EasyHttp.get("/v1/app/chairdressing/")
                .params("param1", "paramValue1")
                .execute(new ProgressDialogCallBack<SkinTestResult>(mProgressDialog, true, true) {
                    @Override
                    public void onError(ApiException e) {
                        super.onError(e);//super.onError(e)必须写不能删掉或者忘记了
                        //请求失败
                    }

                    @Override
                    public void onSuccess(SkinTestResult response) {
                       //请求成功
                    }
                });

注：错误回调 super.onError(e);必须写

方式二：ProgressSubscriber

IProgressDialog mProgressDialog = new IProgressDialog() {
            @Override
            public Dialog getDialog() {
                ProgressDialog dialog = new ProgressDialog(MainActivity.this);
                dialog.setMessage("请稍候...");
                return dialog;
            }
        };
 EasyHttp.get(URL)
                .timeStamp(true)
                .execute(SkinTestResult.class)
                .subscribe(new ProgressSubscriber<SkinTestResult>(this, mProgressDialog) {
                    @Override
                    public void onError(ApiException e) {
                        super.onError(e);
                        showToast(e.getMessage());
                    }

                    @Override
                    public void onNext(SkinTestResult skinTestResult) {
                        showToast(skinTestResult.toString());
                    }
                });

请求返回 Observable

通过网络请求可以返回 Observable，这样就可以很好的通过 Rxjava 与其它场景业务结合处理，甚至可以通过 Rxjava 的 connect()操作符处理多个网络请求。例如：在一个页面有多个网络请求，如何在多个请求都访问成功后再显示页面呢？这也是 Rxjava 强大之处。 注：目前通过 execute(Class clazz)方式只支持标注的 ApiResult 结构，不支持自定义的 ApiResult 示例：

Observable<SkinTestResult> observable = EasyHttp.get(url)
                .params("param1", "paramValue1")
                .execute(SkinTestResult.class);

        observable.subscribe(new BaseSubscriber<SkinTestResult>() {
            @Override
            public void onError(ApiException e) {
                showToast(e.getMessage());
            }

            @Override
            public void onNext(SkinTestResult skinTestResult) {
                showToast(skinTestResult.toString());
            }
        });

文件下载

本库提供的文件下载非常简单，没有提供复杂的下载方式例如：下载管理器、断点续传、多线程下载等，因为不想把本库做重。如果复杂的下载方式，还请考虑其它下载方案。 文件目录如果不指定,默认下载的目录为/storage/emulated/0/Android/data/包名/files 文件名如果不指定,则按照以下规则命名:

1.首先检查用户是否传入了文件名,如果传入,将以用户传入的文件名命名 2.如果没有传入文件名，默认名字是时间戳生成的。 3.如果传入了文件名但是没有后缀，程序会自动解析类型追加后缀名

示例：

 String url = "http://61.144.207.146:8081/b8154d3d-4166-4561-ad8d-7188a96eb195/2005/07/6c/076ce42f-3a78-4b5b-9aae-3c2959b7b1ba/kfid/2475751/qqlite_3.5.0.660_android_r108360_GuanWang_537047121_release_10000484.apk";
        EasyHttp.downLoad(url)
                .savePath("/sdcard/test/QQ")
                .saveName("release_10000484.apk")//不设置默认名字是时间戳生成的
                .execute(new DownloadProgressCallBack<String>() {
                    @Override
                    public void update(long bytesRead, long contentLength, boolean done) {
                        int progress = (int) (bytesRead * 100 / contentLength);
                        HttpLog.e(progress + "% ");
                        dialog.setProgress(progress);
                        if (done) {//下载完成
                        }
                        ...
                    }

                    @Override
                    public void onStart() {
                       //开始下载
                    }

                    @Override
                    public void onComplete(String path) {
                       //下载完成，path：下载文件保存的完整路径
                    }

                    @Override
                    public void onError(ApiException e) {
                        //下载失败
                    }
                });

POST 请求，上传 String、json、object、body、byte[]

一般此种用法用于与服务器约定的数据格式，当使用该方法时，params 中的参数设置是无效的，所有参数均需要通过需要上传的文本中指定，此外，额外指定的 header 参数仍然保持有效。

• .upString("这是要上传的长文本数据！")//默认类型是：MediaType.parse("text/plain")
• 如果你对请求头有自己的要求，可以使用这个重载的形式，传入自定义的 content-type 文本 upString("这是要上传的长文本数据！", "application/xml") // 比如上传 xml 数据，这里就可以自己指定请求头
• upJson 该方法与 upString 没有本质区别，只是数据格式是 json,通常需要自己创建一个实体 bean 或者一个 map，把需要的参数设置进去，然后通过三方的 Gson 或者 fastjson 转换成 json 字符串，最后直接使用该方法提交到服务器。 .upJson(jsonObject.toString())//上传 json
• .upBytes(new byte[]{})//上传 byte[]
• .requestBody(body)//上传自定义 RequestBody
• .upObject(object)//上传对象 object 必须要增加.addConverterFactory(GsonConverterFactory.create())设置

1.upString、upJson、requestBody、upBytes、upObject 五个方法不能同时使用，当前只能选用一个 2.使用 upJson、upObject 时候 params、sign(true/false)、accessToken（true/false）、拦截器都不会起作用

示例：

HashMap<String, String> params = new HashMap<>();
params.put("key1", "value1");
params.put("key2", "这里是需要提交的 json 格式数据");
params.put("key3", "也可以使用三方工具将对象转成 json 字符串");
JSONObject jsonObject = new JSONObject(params);

RequestBody body=RequestBody.create(MediaType.parse("xxx/xx"),"内容");
EasyHttp.post("v1/app/chairdressing/news/favorite")
                //.params("param1", "paramValue1")//不能使用 params，upString 与 params 是互斥的，只有 upString 的数据会被上传
                .upString("这里是要上传的文本！")//默认类型是：MediaType.parse("text/plain")
                //.upString("这是要上传的长文本数据！", "application/xml") // 比如上传 xml 数据，这里就可以自己指定请求头

                 //.upJson(jsonObject.toString())
                 //.requestBody(body)
                 //.upBytes(new byte[]{})
                 //.upObject(object)
                .execute(new SimpleCallBack<String>() {
                    @Override
                    public void onError(ApiException e) {
                        showToast(e.getMessage());
                    }

                    @Override
                    public void onSuccess(String response) {
                        showToast(response);
                    }
                });

上传图片或者文件

支持单文件上传、多文件上传、混合上传，同时支持进度回调， 暂不实现多线程上传/分片上传/断点续传等高级功能

上传文件支持文件与参数一起同时上传，也支持一个 key 上传多个文件，以下方式可以任选 上传文件支持两种进度回调：ProgressResponseCallBack(线程中回调)和 UIProgressResponseCallBack（可以刷新 UI）

final UIProgressResponseCallBack listener = new UIProgressResponseCallBack() {
            @Override
            public void onUIResponseProgress(long bytesRead, long contentLength, boolean done) {
                int progress = (int) (bytesRead * 100 / contentLength);
                if (done) {//完成
                }
                ...
            }
        };
        EasyHttp.post("/v1/user/uploadAvatar")
                //支持上传新增的参数
                //.params(String key, File file, ProgressResponseCallBack responseCallBack)
                //.params(String key, InputStream stream, String fileName, ProgressResponseCallBack responseCallBack)
                //.params(String key, byte[] bytes, String fileName, ProgressResponseCallBack responseCallBack) 
                //.addFileParams(String key, List<File> files, ProgressResponseCallBack responseCallBack)
                //.addFileWrapperParams(String key, List<HttpParams.FileWrapper> fileWrappers)
                //.params(String key, File file, String fileName, ProgressResponseCallBack responseCallBack)
                //.params(String key, T file, String fileName, MediaType contentType, ProgressResponseCallBack responseCallBack)

                //方式一：文件上传
                File file = new File("/sdcard/1.jpg");
                //如果有文件名字可以不用再传 Type,会自动解析到是 image/*
                .params("avatar", file, file.getName(), listener)
                //.params("avatar", file, file.getName(),MediaType.parse("image/*"), listener)

                //方式二：InputStream 上传
               final InputStream inputStream = getResources().getAssets().open("1.jpg");
                .params("avatar", inputStream, "test.png", listener)

                //方式三：byte[]上传
                Bitmap bitmap = BitmapFactory.decodeResource(getResources(), R.mipmap.test);
                ByteArrayOutputStream baos = new ByteArrayOutputStream();
                bitmap.compress(Bitmap.CompressFormat.PNG, 100, baos);
                final byte[] bytes = baos.toByteArray();
                //.params("avatar",bytes,"streamfile.png",MediaType.parse("image/*"),listener)
                //如果有文件名字可以不用再传 Type,会自动解析到是 image/*
                .params("avatar", bytes, "streamfile.png", listener)

                .params("file1", new File("filepath1"))   // 可以添加文件上传
                .params("file2", new File("filepath2"))     // 支持多文件同时添加上传
                .addFileParams("key", List<File> files)    // 这里支持一个 key 传多个文件
                .params("param1", "paramValue1")         // 这里可以上传参数
                .accessToken(true)
                .timeStamp(true)
                .execute(new ProgressDialogCallBack<String>(mProgressDialog, true, true) {
                    @Override
                    public void onError(ApiException e) {
                        super.onError(e);
                        showToast(e.getMessage());
                    }

                    @Override
                    public void onSuccess(String response) {
                        showToast(response);
                    }
                });

取消请求

通过 Disposable 取消

每个请求前都会返回一个 Disposable，取消订阅就可以取消网络请求，如果是带有进度框的网络请求，则不需要手动取消网络请求，会自动取消。

 Disposable mSubscription = EasyHttp.get(url).execute(callback);
  ...
  @Override
    protected void onDestroy() {
        super.onDestroy();
        EasyHttp.cancelSubscription(mSubscription);
    }

通过 dialog 取消

自动取消使用 ProgressDialogCallBack 回调或者使用 ProgressSubscriber,就不用再手动调用 cancelSubscription(); ProgressDialogCallBack:

EasyHttp.get(url).execute(new ProgressDialogCallBack());

ProgressSubscriber

EasyHttp.get(url).execute(SkinTestResult.class).subscribe(new ProgressSubscriber<SkinTestResult>(this, mProgressDialog) {
            @Override
            public void onError(ApiException e) {
                super.onError(e);
                showToast(e.getMessage());
            }

            @Override
            public void onNext(SkinTestResult skinTestResult) {
                showToast(skinTestResult.toString());
            }
        })

同步请求

同步请求只需要设置 syncRequest()方法

 EasyHttp.get("/v1/app/chairdressing/skinAnalyzePower/skinTestResult")
                ...
                .syncRequest(true)//设置同步请求
                .execute(new CallBack<SkinTestResult>() {});

请求回调 CallBack 支持的类型

//支持回调的类型可以是 Bean、String、CacheResult<Bean>、CacheResult<String>、List<Bean>
new SimpleCallBack<CacheResult<Bean>>()//支持缓存的回调，请看缓存讲解
new SimpleCallBack<CacheResult<String>>()//支持缓存的回调，请看缓存讲解
new SimpleCallBack<Bean>()//返回 Bean
new SimpleCallBack<String>()//返回字符串
new SimpleCallBack<List<Bean>()//返回集合

注：其它回调同理

cookie 使用

cookie 的内容主要包括：名字，值，过期时间，路径和域。路径与域一起构成 cookie 的作用范围,关于 cookie 的作用这里就不再科普，自己可以去了解 cookie 设置：

EasyHttp.getInstance()
                    ...
                  //如果不想让本库管理 cookie,以下不需要
                .setCookieStore(new CookieManger(this)) //cookie 持久化存储，如果 cookie 不过期，则一直有效
                 ...

• 查看 url 所对应的 cookie

HttpUrl httpUrl = HttpUrl.parse("http://www.xxx.com/test");
CookieManger cookieManger = getCookieJar();
List<Cookie> cookies =  cookieManger.loadForRequest(httpUrl);

• 查看 CookieManger 所有 cookie

PersistentCookieStore cookieStore= getCookieJar().getCookieStore();
List<Cookie> cookies1= cookieStore.getCookies();

• 添加 cookie

Cookie.Builder builder = new Cookie.Builder();
Cookie cookie = builder.name("mCookieKey1").value("mCookieValue1").domain(httpUrl.host()).build();
CookieManger cookieManger = getCookieJar();
cookieManger.saveFromResponse(httpUrl, cookie);
//cookieStore.saveFromResponse(httpUrl, cookieList);//添加 cookie 集合

• 移除 cookie

HttpUrl httpUrl = HttpUrl.parse("http://www.xxx.com/test");
CookieManger cookieManger = EasyHttp.getCookieJar();
Cookie cookie = builder.name("mCookieKey1").value("mCookieValue1").domain(httpUrl.host()).build();
cookieManger.remove(httpUrl,cookie);

• 清空 cookie

CookieManger cookieManger = EasyHttp.getCookieJar();
cookieManger.removeAll();

自定义 call()请求

提供了用户自定义 ApiService 的接口，您只需调用 call 方法即可. 示例：

public interface LoginService {
    @POST("{path}")
    @FormUrlEncoded
    Observable<ApiResult<AuthModel>> login(@Path("path") String path, @FieldMap Map<String, String> map);
}

final CustomRequest request = EasyHttp.custom()
                .addConverterFactory(GsonConverterFactory.create(new Gson()))//自定义的可以设置 GsonConverterFactory
                .params("param1", "paramValue1")
                .build();

        LoginService mLoginService = request.create(LoginService.class);
        LoginService mLoginService = request.create(LoginService.class);
        Observable<ApiResult<AuthModel>> observable = request.call(mLoginService.login("v1/account/login", request.getParams().urlParamsMap));
        Disposable subscription = observable.subscribe(new Action1<ApiResult<AuthModel>>() {
            @Override
            public void call(ApiResult<AuthModel> result) {
                //请求成功
            }
        }, new Action1<Throwable>() {
            @Override
            public void call(Throwable throwable) {
                //请求失败
            }
        });

自定义 apiCall()请求

提供默认的支持 ApiResult 结构，数据返回不需要带 ApiResult,直接返回目标. 示例：

Observable<AuthModel> observable = request.apiCall(mLoginService.login("v1/account/login", request.getParams().urlParamsMap));

请求回调和订阅

请求回调本库提供两种方式 Callback 和 Subscriber

回调方式

此种方式主要针对 execute(CallBack callBack)，目前内部提供的回调包含 CallBack, SimpleCallBack ,ProgressDialogCallBack ,DownloadProgressCallBack 可以根据自己的需求去自定义 Callback

• CallBack 所有回调的基类，抽象类
• SimpleCallBack 简单回调，只有成功和失败
• ProgressDialogCallBack 带有进度框的回调，可以自定义进度框、支持是否可以取消对话框、对话框消失自动取消网络请求等参数设置
• DownloadProgressCallBack 如果要做文件下载，则必须使用该回调，内部封装了关于文件下载进度回调的方法，如果使用其他回调也可以，但是没有进度通知

该网络框架的核心使用方法即为 Callback 的继承使用，因为不同的项目需求，会有个性化的回调请自定义

CallBack 回调

new CallBack<T>() {
                    @Override
                    public void onStart() {
                       //请求开始
                    }

                    @Override
                    public void onCompleted() {
                       //请求完成
                    }

                    @Override
                    public void onError(ApiException e) {
                       //请求失败
                    }

                    @Override
                    public void onSuccess(T t) {
                       //请求成功
                    }
                }

SimpleCallBack 回调

new SimpleCallBack<T>() {
                    @Override
                    public void onError(ApiException e) {
                         //请求失败
                    }

                    @Override
                    public void onSuccess(T t) {
                        //请求成功
                    }
                }

ProgressDialogCallBack 回调

可以自定义带有加载进度框的回调，取消对话框会自动取消掉网络请求

提供两个构造

public ProgressDialogCallBack(IProgressDialog progressDialog);//默认不能取消对话框 public ProgressDialogCallBack(IProgressDialog progressDialog, boolean isShowProgress, boolean isCancel);//自定义加载进度框,可以设置是否显示弹出框，是否可以取消 progressDialog: dialog 对象接口 isShowProgress：对话框消失是否取消网络请求 isCancel：是否可以取消对话框对应 Dialog 的 setCancelable(isCancel)方法;

自定义 ProgressDialog 对话框

 private IProgressDialog mProgressDialog = new IProgressDialog() {
        @Override
        public Dialog getDialog() {
            ProgressDialog dialog = new ProgressDialog(MainActivity.this);
            dialog.setMessage("请稍候...");
            return dialog;
        }
    };

DownloadProgressCallBack 回调

此回调只用于文件下载，具体请看文件下载讲解

自定义 CallBack 回调

如果对回调有特殊需求，支持可以继承 CallBack 自己扩展功能

订阅方式

此种方式主要是针对 execute(Class clazz)和 execute(Type type)，目前内部提供的 Subscriber 包含 BaseSubscriber、DownloadSubscriber、ProgressSubscriber，可以根据自己的需求去自定义 Subscriber

• BaseSubscriber 所有订阅者的基类，抽象类
• DownloadSubscriber 下载的订阅者，上层不需要关注
• ProgressSubscriber 带有进度框的订阅，可以自定义进度框、支持是否可以取消对话框、对话框消失自动取消网络请求等参数设置

new BaseSubscriber<T>() {
            @Override
            public void onError(ApiException e) {
               //请求失败
            }

            @Override
            public void onNext(T t) {
                //请求成功
            }
        }

new ProgressSubscriber<T>(this, mProgressDialog) {
                    @Override
                    public void onError(ApiException e) {
                        super.onError(e);
                        //请求失败
                    }

                    @Override
                    public void onNext(T t) {
                         //请求成功
                    }
                }

自定义 Subscriber

如果对 Subscriber 有特殊需求，支持可以继承 BaseSubscriber 自己扩展订阅者

缓存使用

缓存介绍

本库的缓存主要分 okhttp 的 Cache 缓存和自定义的 RxCache 缓存,大家有疑问 okhttp 有缓存，retrofit 也是支持通过 header 来设置缓存，为什么还要自定义一个缓存机制呢？通过自定义 RxCache 缓存使用更简单，更符合我们常用的业务需求(常用的缓存策略也不会太复杂)， retrofit 的缓存借助于 okhttp 通过拦截器 interceptor 实现或者通过@Headers("Cache-Control: public, max-age=3600)具体用法这里不做详细描述，有兴趣的可以自己去了解。动态修改缓存时间不方便，例如：同一个接口，不同时间段请求的内容缓存的时间不一样，需要动态修改。

对于DEFAULT模式是 okhttp 的 Cache 缓存。因为该模式是完全遵循标准的 http 协议的,缓存时间是依靠服务端响应头来控制，也可以通过拦截器自己处理

对于 RxCache 的缓存支持多种存储方式，提供IDiskConverter转换器接口目前支持SerializableDiskConverter和GsonDiskConverter两种方式，也可以自定义 Parcelable、fastjson、xml、kryo 等转换器 SerializableDiskConverter 使用缓存前，必须让缓存的数据所有 javaBean 对象实现 Serializable 接口，否则会报 NotSerializableException。 因为缓存的原理是将对象序列化后保存，如果不实现 Serializable 接口，会导致对象无法序列化，进而无法保存，也就达不到缓存的效果。 优点：存储和读取都不用再转化直接就是需要的对象速度快 缺点：如果 javabean 里面还有 javabean 且层级比较多，也必须每个都要实现 Serializable 接口，比较麻烦 GsonDiskConverter 此种方式就是以 json 字符串的方式存储 优点：相对于 SerializableDiskConverter 转换器，存储的对象不需要进行序列化 缺点：就是存储和读取都要使用 Gson 进行转换，object->String->Object 的给一个过程，相对来说每次都要转换性能略低，但是性能基本忽略不计

目前提供了八种 CacheMode 缓存模式,每种缓存模式都可以指定对应的 CacheTime,将复杂常用的业务场景封装在里面，让你不用关心缓存的具体实现，而专注于数据的处理

• NO_CACHE：不使用缓存,该模式下,cacheKey,cacheTime 等参数均无效
• DEFAULT：按照 HTTP 协议的默认缓存规则，走 OKhttp 的 Cache 缓存
• FIRSTREMOTE：先请求网络，请求网络失败后再加载缓存
• FIRSTCACHE：先加载缓存，缓存没有再去请求网络
• ONLYREMOTE：仅加载网络，但数据依然会被缓存
• ONLYCACHE：只读取缓存，缓存没有会返回 null
• CACHEANDREMOTE:先使用缓存，不管是否存在，仍然请求网络，CallBack 会回调两次.
• CACHEANDREMOTEDISTINCT:先使用缓存，不管是否存在，仍然请求网络，CallBack 回调不一定是两次，如果发现请求的网络数据和缓存数据是一样的，就不会再返回网络的回调,既回调一次。否则不相同仍然会回调两次。（目的是为了防止数据没有发生变化，也需要回调两次导致界面无用的重复刷新）,此种模式缓存的对象 bean 一定要重写 tostring()方法

注：无论对于哪种缓存模式，都可以指定一个 cacheKey，建议针对不同需要缓存的页面设置不同的 cacheKey，如果相同，会导致数据覆盖。

缓存设置

缓存设置有两种方式 方式一：全局设置，所有请求都会默认使用此模式

 EasyHttp.getInstance()
                 ...
                .setCacheMode(CacheMode.CACHEANDREMOTE)//不设置默认是 NO_CACHE 模式
                ...

方式二：单个请求设置缓存模式

 EasyHttp.get(URL)
                 ...
                .cacheMode(CacheMode.FIRSTREMOTE)
                ...

设置转换器

方式一：全局设置，所有请求都会默认使用此存储转换器

EasyHttp.getInstance().setCacheDiskConverter(new SerializableDiskConverter())//默认缓存使用序列化转化

方式二：单个请求设置存储转换器

EasyHttp.get(URL).cacheDiskConverter(new GsonDiskConverter());

注：一个请求就选用一种转换器，切记不要使用 SerializableDiskConverter 来缓存，又用 GsonDiskConverter 来读会报错

自定义转换器

如果你想拥有自己的转换器请实现IDiskConverter接口。 示例：

public class CustomDiskConverter implements IDiskConverter {
    @Override
    public <T> T load(InputStream source, Type type) {
        //实现读功能
        return null;
    }

    @Override
    public boolean writer(OutputStream sink, Object data) {
        //实现写功能
        return false;
    }
}

缓存回调

对具有缓存的回调 CallBack，如果你想知道当前的缓存是来自本地还是网络，只需要回调中加入 CacheResult，其它和普通的网络请求方式一模一样。CacheResult 中的 isFromCache 可以知道是否来自缓存，true：来自缓存，false：来自网络。请使用new SimpleCallBack<CacheResult<T>>() 也就是在你原有的 T 上包含一层 CacheResult 就可以了。如果不想用到 isFromCache 就不需要用 CacheResult，直接使用new SimpleCallBack<T>() 带有 CacheResult 回调示例：

 EasyHttp.get(url)
                .readTimeOut(30 * 1000)//测试局部读超时 30s
                .cacheMode(cacheMode)
                .cacheKey(this.getClass().getSimpleName())//缓存 key
                .retryCount(5)//重试次数
                .cacheTime(5 * 60)//缓存时间 300s，默认 -1 永久缓存  okhttp 和自定义缓存都起作用
                //.okCache(new Cache());//okhttp 缓存，模式为默认模式（CacheMode.DEFAULT）才生效
                //.cacheDiskConverter(new GsonDiskConverter())//默认使用的是 new SerializableDiskConverter();
                .cacheDiskConverter(new SerializableDiskConverter())//默认使用的是 new SerializableDiskConverter();
                .timeStamp(true)
                .execute(new SimpleCallBack<CacheResult<SkinTestResult>>() {

                    @Override
                    public void onError(ApiException e) {
                       //请求失败
                    }

                    @Override
                    public void onSuccess(CacheResult<SkinTestResult> cacheResult) {
                        HttpLog.i(cacheResult.toString());
                        String from = "";
                        if (cacheResult.isFromCache) {
                            from = "我来自缓存";
                        } else {
                            from = "我来自远程网络";
                        }
                       ....
                    }
                });

移除缓存

支持根据缓存 key 移除缓存，主要是针对 RxCache 才能起作用

EasyHttp.removeCache("cachekey");

清空缓存

EasyHttp.clearCache();

RxCache

RxCache 是自己封装的一个本地缓存功能库，采用 Rxjava+DiskLruCache 来实现，线程安全内部采用 ReadWriteLock 机制防止频繁读写缓存造成的异常，可以独立使用，单独用 RxCache 来存储数据。采用 transformer 与网络请求结合，可以实现网络缓存功能,本地硬缓存，具有缓存读写功能（异步）、缓存是否存在、根据 key 删除缓存、清空缓存（异步）、缓存 Key 会自动进行 MD5 加密、可以设置缓存磁盘大小、缓存 key、缓存时间、缓存存储的转换器、缓存目录、缓存 Version 等功能本库不作为重点介绍。后期会将此代码独立开源一个库，作为一分钟让你自己的网络库也具有缓存功能，敬请期待！！！

动态参数

动态参数就是像我们的 token、时间戳 timeStamp、签名 sign 等，这些参数不能是全局参数因为是变化的，设置成局部参数又太麻烦，每次都要获取。token 是有有效时间的或者异地登录等都会变化重新获取，时间戳一般是根据系统的时间，sign 是根据请求的 url 和参数进行加密签名一般都有自己的签名规则。有的接口需要这些参数有的接口不需要，本库很好的解决这个问题。

1.在请求的时候可以设置下面三个参数

.accessToken(true)//本次请求是否追加 token
.timeStamp(false)//本次请求是否携带时间戳
.sign(false)//本次请求是否需要签名

2.需要继承库中提供的动态拦截器 BaseDynamicInterceptor

继承 BaseDynamicInterceptor 后就可以获取到参数的设置值，请详细看CustomSignInterceptor的注释讲解，也可以查看 Demo 示例 示例:

/**
 * <p>描述：对参数进行签名、添加 token、时间戳处理的拦截器</p>
 * 主要功能说明：<br>
 * 因为参数签名没办法统一，签名的规则不一样，签名加密的方式也不同有 MD5、BASE64 等等，只提供自己能够扩展的能力。<br>
 * 作者： zhouyou<br>
 * 日期： 2017/5/4 15:21 <br>
 * 版本： v1.0<br>
 */
public class CustomSignInterceptor extends BaseDynamicInterceptor<CustomSignInterceptor> {
    @Override
    public TreeMap<String, String> dynamic(TreeMap<String, String> dynamicMap) {
        //dynamicMap:是原有的全局参数+局部参数
        //你不必关心当前是 get/post/上传文件/混合上传等，库中会自动帮你处理。
        //根据需要自己处理，如果你只用到 token 则不必处理 isTimeStamp()、isSign()
        if (isTimeStamp()) {//是否添加时间戳，因为你的字段 key 可能不是 timestamp,这种动态的自己处理
            dynamicMap.put(ComParamContact.Common.TIMESTAMP, String.valueOf(System.currentTimeMillis()));
        }
        if (isSign()) {是否签名
            //1.因为你的字段 key 可能不是 sign，这种需要动态的自己处理
            //2.因为你的签名的规则不一样，签名加密方式也不一样，只提供自己能够扩展的能力
            dynamicMap.put(ComParamContact.Common.SIGN, sign(dynamicMap));
        }
        if (isAccessToken()) {//是否添加 token
            String acccess = TokenManager.getInstance().getAuthModel().getAccessToken();
            dynamicMap.put(ComParamContact.Common.ACCESSTOKEN, acccess);
        }
        //Logc.i("dynamicMap:" + dynamicMap.toString());
        return dynamicMap;//dynamicMap:是原有的全局参数+局部参数+新增的动态参数
    }

    //示例->签名规则：POST+url+参数的拼装+secret
    private String sign(TreeMap<String, String> dynamicMap) {
        String url = getHttpUrl().url().toString();
        url = url.replaceAll("%2F", "/");
        StringBuilder sb = new StringBuilder("POST");
        sb.append(url);
        for (Map.Entry<String, String> entry : dynamicMap.entrySet()) {
            sb.append(entry.getKey()).append("=").append(entry.getValue()).append("&");
        }

        sb.append(AppConstant.APP_SECRET);
        HttpLog.i(sb.toString());
        return MD5.encode(sb.toString());
    }
}

3.设置自定义的动态拦截器

最好通过全局的方式设置，因为一般很多接口都会使用到

 EasyHttp.getInstance()
                 ...
                .addInterceptor(new CustomSignInterceptor())//添加动态参数（签名、token、时间戳）拦截器
                 ...

自定义 ApiResult

本库中默认提供的是标准 ApiResult.内部是靠 ApiResult 进行解析的，如果你的数据结构跟 ApiResult 不同，你可以在你的项目中继承 ApiResult，然后重写 getCode()、getData()、getMsg()和 isOk()等方法来实现自己的需求。 本库中 ApiResult 如下：

public class ApiResult<T> {
    private int code;
    private String msg;
    private T data;
    public int getCode() {
        return code;
    }

    public void setCode(int code) {
        this.code = code;
    }

    public String getMsg() {
        return msg;
    }

    public void setMsg(String msg) {
        this.msg = msg;
    }

    public T getData() {
        return data;
    }

    public void setData(T data) {
        this.data = data;
    }

    public boolean isOk() {//请求成功的判断方法
        return code == 0 ? true : false;
    }
}

json 格式类似:

{
"code": 100010101,
"data": 内容,
"msg": "请求成功"
}

假如你的数据结构是这样的：

{
"error_code": 0,
"result": 内容,
"reason": "请求成功"
}

那么你的 basebean 可以写成这样

public class CustomApiResult<T> extends ApiResult<T> {
    String reason;
    int error_code;
    //int resultcode;
    T result;
    @Override
    public int getCode() {
        return error_code;
    }
    @Override
    public void setCode(int code) {
        error_code = code;
    }
    @Override
    public String getMsg() {
        return reason;
    }
    @Override
    public void setMsg(String msg) {
        reason = msg;
    }
    @Override
    public T getData() {
        return result;
    }
    @Override
    public void setData(T data) {
        result = data;
    }
   /* @Override
    public boolean isOk() {
        return error_code==200;//如果不是 0 表示成功，请重写 isOk()方法。
    }*/
}

那么你的网络请求可以这样写

自定义 ApiResult 回调方式（通过 CallBackProxy 代理）

EasyHttp.get(url)
                .readTimeOut(30 * 1000)//局部定义读超时
                .writeTimeOut(30 * 1000)
                .connectTimeout(30 * 1000)
                //.cacheKey(this.getClass().getSimpleName()+"11")
                //.cacheMode(CacheMode.CACHEANDREMOTE)
                //.cacheMode(CacheMode.ONLYREMOTE)
                //.headers("","")//设置头参数
                //.params("name","张三")//设置参数
                //.addInterceptor()
                //.addConverterFactory()
                //.addCookie()
                //.timeStamp(true)
                .baseUrl("http://apis.juhe.cn")
                .params("phone", "手机号")
                .params("dtype", "json")
                .params("key", "5682c1f44a7f486e40f9720d6c97ffe4")
                .execute(new CallBackProxy<CustomApiResult<ResultBean>, ResultBean>(new SimpleCallBack<ResultBean>() {
                    @Override
                    public void onError(ApiException e) {
                        //请求错误
                    }

                    @Override
                    public void onSuccess(ResultBean response) {
                        //请求成功
                    }
                }) {
                });

这种写法会觉得有点长，CallBackProxy 的泛型参数每次都需要填写，其中 CustomApiResult 是继承 ApiResult 的，CustomApiResult 相当于项目的 basebean,对于一个实际项目来讲，basebean 是固定的，所以我们可以继续封装这个方法，根据需要一般只需要封装 get 和 post 请求就可以了。

 public static <T> Disposable customExecute(CallBack<T> callBack) {
        return execute(new CallBackProxy<CustomApiResult<T>, T>(callBack) {
        });
    }

通过以上改造，再次调用时直接使用 CallBack，不用再关注 CallBackProxy，是不是明显简单很多了，具体请看代码 Demo!!!

自定义 ApiResult 订阅方式（通过 CallClazzProxy 代理）

Observable<ResultBean> observable = EasyHttp.get("/mobile/get")
                .readTimeOut(30 * 1000)//局部定义读超时
                .writeTimeOut(30 * 1000)
                .baseUrl("http://apis.juhe.cn")
                .params("phone", "18688994275")
                .params("dtype", "json")
                .params("key", "5682c1f44a7f486e40f9720d6c97ffe4")
                .execute(new CallClazzProxy<CustomApiResult<ResultBean>, ResultBean>(ResultBean.class) {
                });
        observable.subscribe(new ProgressSubscriber<ResultBean>(this, mProgressDialog) {
            @Override
            public void onError(ApiException e) {
                super.onError(e);
                showToast(e.getMessage());
            }

            @Override
            public void onNext(ResultBean result) {
                showToast(result.toString());
            }
        });

调试模式

一个好的库，一定有比较人性化的调试模式，为了方便开发者查看请求过程和请求日志，本库提供详细的日志打印，最好在开发阶段，请打开调试模式输出优雅的 Log. 调试模式的控制在初始化配置时就可以直接设置。

public class MyApplication extends Application {
        @Override
        public void onCreate() {
            super.onCreate();
            ...
            EasyHttp.getInstance()
                    ...
                    // 打开该调试开关并设置 TAG,不需要就不要加入该行
                    // 最后的 true 表示是否打印内部异常，一般打开方便调试错误
                    .debug("EasyHttp", true);
        }
    }

Log 预览说明

这里一个成功请求的例子： 上方的 Log 打印了一个 Request 完整的声明周期，一个请求的 Log 有以下特点： 1.开头和结尾打了-->http is start 和 -->http is Complete 分割请求，完整的生命周期的内容都会打印在开头和结尾的里面。 2.request 请求和 response 响应分割，分别是

-------------------------------request-------------------------------

-------------------------------response-------------------------------

3.在---request---之后会打印请求的 url、当前请求的类型 GET/POST... -->GET/POST 开头 -->END GET/POST 结尾。如果是 GET、HEAD 请求方式添加的参数将会在这里完整的以 url?key=value&key=value 的形式打印。 4.在----response----之后会打印（在服务器响应后被打印），包含响应码、响应状态、响应头、cookie,body 等以<--200(响应码)开头，<--END HTTP 结尾 5.loadCache key=如果设置了缓存，会看到缓存的 key，开启了网络缓存功能才会输出。 6.loadCache result=从缓存里读取的结果，开启了网络缓存功能才会输出。 7.save status => true 保存缓存的状态

混淆

#okhttp
-dontwarn com.squareup.okhttp3.**
-keep class com.squareup.okhttp3.** { *;}
-dontwarn okio.**

# Retrofit
-dontwarn retrofit2.**
-keep class retrofit2.** { *; }
-keepattributes Exceptions

# Retrolambda
-dontwarn java.lang.invoke.*

# RxJava RxAndroid
-dontwarn sun.misc.**
-keepclassmembers class rx.internal.util.unsafe.*ArrayQueue*Field* {
    long producerIndex;
    long consumerIndex;
}
-keepclassmembers class rx.internal.util.unsafe.BaseLinkedQueueProducerNodeRef {
    rx.internal.util.atomic.LinkedQueueNode producerNode;
}
-keepclassmembers class rx.internal.util.unsafe.BaseLinkedQueueConsumerNodeRef {
    rx.internal.util.atomic.LinkedQueueNode consumerNode;
}
###rxandroid-1.2.1
-keepclassmembers class rx.android.**{*;}

# Gson
-keep class com.google.gson.stream.** { *; }
-keepattributes EnclosingMethod
-keep class org.xz_sale.entity.**{*;}
-keep class com.google.gson.** {*;}
-keep class com.google.**{*;}
-keep class sun.misc.Unsafe { *; }
-keep class com.google.gson.stream.** { *; }
-keep class com.google.gson.examples.android.model.** { *; }

#RxEasyHttp
-keep class com.zhouyou.http.model.** {*;}
-keep class com.zhouyou.http.cache.model.** {*;}
-keep class com.zhouyou.http.cache.stategy.**{*;}

请查看 Demo 中完整的混淆文件