RxEasyHttp

Project Url: zhou-you/RxEasyHttp
Introduction: 本库是一款基于 RxJava2+Retrofit2 实现简单易用的网络请求框架,结合 android 平台特性的网络封装库,采用 api 链式调用一点到底,集成 cookie 管理,多种缓存模式,极简 https 配置,上传下载进度显示,请求错误自动重试,请求携带 token、时间戳、签名 sign 动态配置,自动登录成功后请求重发功能,3 种层次的参数设置默认全局局部,默认标准 ApiResult 同时可以支持自定义的数据结构,已经能满足现在的大部分网络请求。
More: Author   ReportBugs   
Tags:

本库是一款基于 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 csdn

联系方式

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

欢迎加入 QQ 交流群(Q1 群已满,请加入 Q2 群)

演示(请 star 支持)

RxEasyHttp 与 Rxjava 结合使用场景演示

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

版本说明

当前版本

release

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

用法介绍

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

点击按钮下载 Demo

downloads

扫码下载 Demo

build.gradle 设置

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

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

jcenter

权限说明

如果使用本库实现文件下载到 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 设置:

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转换器接口目前支持SerializableDiskConverterGsonDiskConverter两种方式,也可以自定义 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 中完整的混淆文件

Apps
About Me
GitHub: Trinea
Facebook: Dev Tools