RxHttp 让你眼前一亮的Http请求框架

最新推荐文章于 2024-05-17 02:10:01 发布
最新推荐文章于 2024-05-17 02:10:01 发布
阅读量1.6k 收藏 4
点赞数
分类专栏： android 文章标签： android RxHttp
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/ZyClient/article/details/103901294
版权

1

前言

 

RxHttp在今年4月份一经推出，就受到了广大Android 开发者的喜爱，截止本文发表在github上已有800+star，为此，我自己也建个RxHttp&RxLife 的群（群号：290611780）

 

 

 

目前群里也有将近120号人，里面有不少小伙伴提了很多有价值的创意，才使得RxHttp一直坚持走到了现在，在此，感谢大家的喜爱。

 

这期间，一直有人问我，retrofit不香吗？

 

之前不知道该如何回答这个问题，现在我想说，香！！retrofit无疑是目前综合得分最高的选手，但它也有它的不足。

 

RxHttp相较于retrofit，功能上，两者均能实现，并无多大差异，更多的差异体现功能的使用上，也就是易用性，如对文件上传/下载/进度监听的操作上，RxHttp用及简的API，可以说碾压retrofit；

 

另外在baseUrl、公共参数/请求头、请求加解密等功能上的易用性都要优于retrofit；然而这些，个人觉得都不算什么，个人觉得RxHttp最大的优势在于它近乎为0的上手成本、及简的API以及高扩展性，看完这篇文章，相信你会有同感。

 

那RxHttp就没有缺点吗？

 

有，那就是它的稳定性目前还不如retrofit，毕竟RxHttp刚出道8个月，且全部是我一个人在维护，当然，并不是说RxHttp不稳定，RxHttp未开源前，在我司的项目已经使用了近2年，接着今年4月份将其开源，至今大大小小已迭代20多个版本，目前用的人也不在少数，可以说很稳定了。

 

2

 简介

 

RxHttp是基于OkHttp的二次封装，并与RxJava做到无缝衔接，一条链就能发送任意请求。主要优势如下：

 

1. 支持Gson、Xml、ProtoBuf、FastJson等第三方数据解析工具

2. 支持Get、Post、Put、Delete等任意请求方式，可自定义请求方式

3. 支持在Activity/Fragment/View/ViewModel/任意类中，自动关闭请求

4. 支持统一加解密，且可对单个请求设置是否加解密

5. 支持添加公共参数/头部，且可对单个请求设置是否添加公共参数/头部

6. 优雅的实现文件上传/下载及进度的监听，且支持断点下载

7. 优雅的对错误统一处理，且不打破Lambda表达式

8. 优雅的处理多个BaseUrl及动态BaseUrl

9. 30秒即可上手，学习成本极低

 

gradle依赖

 

 
implementation 'com.rxjava.rxhttp:rxhttp:1.3.4'
//注解处理器，生成RxHttp类，即可一条链发送请求
annotationProcessor 'com.rxjava.rxhttp:rxhttp-compiler:1.3.4'
//管理RxJava及生命周期，Activity/Fragment 销毁，自动关闭未完成的请求
implementation 'com.rxjava.rxlife:rxlife:1.1.0'

//非必须 根据自己需求选择Converter  RxHttp默认内置了GsonConverter
implementation 'com.rxjava.rxhttp:converter-jackson:1.3.4'
implementation 'com.rxjava.rxhttp:converter-fastjson:1.3.4'
implementation 'com.rxjava.rxhttp:converter-protobuf:1.3.4'
implementation 'com.rxjava.rxhttp:converter-simplexml:1.3.4'

 

注：kotlin用户，请使用kapt替代annotationProcessor

 

3

  使用

 

3.1、准备工作

 

RxHttp 要求项目使用Java 8，请在 app 的 build.gradle 文件中添加以下代码

 

 
compileOptions {
    sourceCompatibility JavaVersion.VERSION_1_8
    targetCompatibility JavaVersion.VERSION_1_8
}

 

 

此时，再Rebuild一下项目（通过Rebuild生成RxHttp类），就可以开始RxHttp的入坑之旅

 

3.2、配置默认的BaseUrl

 

通过@DefaultDomain注解配置默认域名，如下：

 

 
public class Url {
    @DefaultDomain //设置为默认域名
    public static String baseUrl = "https://www.wanandroid.com/";
}

 

 

此步骤是非必须的，这里先介绍@DefaultDomain注解的用法，更多有关域名的介绍，请查看本文3.6章节----多域名/动态域名

 

3.3、请求三部曲

 

先来看看如何发送一个最简单的请求，如下

 

 
RxHttp.get("http://...")  //第一步, 通过get、postXxx、putXxx等方法，确定请求类型         
    .asString()           //第二步, 通过asXxx系列方法，确定返回数据类型    
    .subscribe(s -> {     //第三步, 订阅回调(此步骤同RxJava订阅观察者)
        //请求成功                                         
    }, throwable -> {                                  
        //请求失败                                         
    });                                                

 

是的，不用怀疑，就是这么简单，重要的事情说3遍

 

任意请求，任意返回数据类型，皆遵循请求三部曲

任意请求，任意返回数据类型，皆遵循请求三部曲

任意请求，任意返回数据类型，皆遵循请求三部曲

 

到这，你已经掌握了RxHttp的精髓，我们只需牢记请求三部曲，使用RxHttp就会得心应手。

 

3.3.1、第一部曲：确定请求类型

 

RxHttp内部共提供了14个请求方法，如下：

 

 
RxHttp.get(String)              //get请求    参数拼接在url后面
RxHttp.head(String)             //head请求   参数拼接在url后面
RxHttp.postForm(String)         //post请求   参数以{application/x-www-form-urlencoded}形式提交
RxHttp.postJson(String)         //post请求   参数以{application/json; charset=utf-8}形式提交，发送Json对象
RxHttp.postJsonArray(String)    //post请求   参数以{application/json; charset=utf-8}形式提交，发送Json数组
RxHttp.putForm(String)          //put请求    参数以{application/x-www-form-urlencoded}形式提交
RxHttp.putJson(String)          //put请求    参数以{application/json; charset=utf-8}形式提交，发送Json对象
RxHttp.putJsonArray(String)     //put请求    参数以{application/json; charset=utf-8}形式提交，发送Json数组
RxHttp.patchForm(String)        //patch请求  参数以{application/x-www-form-urlencoded}形式提交
RxHttp.patchJson(String)        //patch请求  参数以{application/json; charset=utf-8}形式提交，发送Json对象
RxHttp.patchJsonArray(String)   //patch请求  参数以{application/json; charset=utf-8}形式提交，发送Json数组
RxHttp.deleteForm(String)       //delete请求 参数以{application/x-www-form-urlencoded}形式提交
RxHttp.deleteJson(String)       //delete请求 参数以{application/json; charset=utf-8}形式提交，发送Json对象
RxHttp.deleteJsonArray(String)  //delete请求 参数以{application/json; charset=utf-8}形式提交，发送Json数组

 

 

以上14个请求方法你会发现，其实就6个类型，分别对应是Get、Head、Post、Put、Patch、Delete方法，只是其中Post、Put、Patch、Delete各有3个方法有不同形式的提交方式，只需要根据自己的需求选择就好。

 

如以上方法还不能满足你的需求，我们还可以通过@Param注解自定义请求方法，有关注解的使用，本文后续会详细介绍。

 

注：当调用xxxForm方法发送请求时，通过setMultiForm()方法或者调用addFile(String, File)添加文件时，内部会自动将参数以{multipart/form-data}方式提交

 

添加参数/请求头确定请求方法后，我们就可以调用一系列addXxx()方法添加参数/请求头，如下：

 

 
RxHttp.get("/service/...")       //发送get请求
    .add("key", "value")         //添加参数
    .addAll(new HashMap<>())     //通过Map添加多个参数
    .addHeader("deviceType", "android")     //添加请求头
    ...

 

任意请求，都可调用以上3个方法添加参数/请求头，当然，在不同的请求方式下，也会有不同的addXxx方法供开发者调用。

 

如下：

 

 
//postJson请求方法下会有更多addAll等方法可供调用
RxHttp.postJson("/service/...") //发送post Json请求
    .addAll(new JsonObject())   //通过json对象添加多个参数
    .addAll("{\"height\":180,\"weight\":70}") //通过json字符串添加多个参数
    ...

//postForm请求方法下会有一系列addFile方法可供调用
RxHttp.postForm("/service/...")  //发送post表单请求
    .addFile("file", new File("xxx/1.png")) //添加单个文件
    .addFile("fileList", new ArrayList<>()) //添加多个文件
    ...

 

以上只列出了几个常用的addXxx方法，更多方法请下载源码体验。

 

3.3.2、第二部曲：确定返回数据类型

 

添加好参数/请求头后，正式进入第二部曲，确定返回数据类型，我们通过asXxx方法确定返回类型，比如，我们要返回一个Student对象，就可以通过asObject(Class<T>)方法，如下：

 

 
RxHttp.postForm("/service/...")  //发送post表单请求
    .add("key", "value")         //添加参数，可调用多次
    .asObject(Student.class)    //返回Student类型
    .subscribe(student -> {   
        //请求成功，这里就能拿到 Student对象               
    }, throwable -> {         
        //请求失败                
    });    

 

 

如果要返回Student对象列表，则可以通过asList(Class<T>)方法，如下：

 

 
RxHttp.postForm("/service/...")  //发送post表单请求
    .add("key", "value")         //添加参数，可调用多次
    .asList(Student.class)       //返回List<Student>类型
    .subscribe(students -> {   
        //请求成功，这里就能拿到 Student对象列表               
    }, throwable -> {         
        //请求失败                
    });    

 

解析Response<T>类型数据然而，现实开发中，大多数人的接口，返回的数据结构都类似下面的这个样子

 

 
public class Response<T> {
    private int    code;
    private String msg;
    private T      data;
    //这里省略get、set方法
}

 

 

对于这种数据结构，按传统的写法，每次都要对code做判断，如果有100个请求，就要判断100次，真的会逼死强迫症患者。

 

RxHttp对于这种情况，给出完美的答案，比如Response<T>里面的T代表一个Student对象，则可以通过asResponse(Class<T>)方法获取，如下：

 

 
RxHttp.postForm("/service/...")   //发送post表单请求
    .add("key", "value")          //添加参数，可调用多次
    .asResponse(Student.class)    //返回Student类型
    .subscribe(student -> {   
        //请求成功，这里能拿到 Student对象               
    }, throwable -> {         
        //请求失败                
    });    

 

如果Response<T>里面的T代表一个List<Student>列表对象，则可以通过asResponseList(Class<T>)方法获取，如下

 

 
RxHttp.postForm("/service/...")   //发送post表单请求
    .add("key", "value")          //添加参数，可调用多次
    .asResponseList(Student.class)    //返回List<Student>类型
    .subscribe(students -> {   
        //请求成功，这里能拿到List<Student>列表对象               
    }, throwable -> {         
        //请求失败                
    });    

 

 

更多时候，我们的列表数据是分页的，类似下面的数据结构

 

 
{
    "code": 0,
    "msg": "",
    "data": {
        "totalPage": 0,
        "list": []
    }
}

 

此时，调用RxHttp的asResponsePageList(Class<T>)方法依然可以完美解决，如下：

 

 
RxHttp.postForm("/service/...")   //发送post表单请求
    .add("key", "value")          //添加参数，可调用多次
    .asResponsePageList(Student.class)    //返回PageList<Student>类型
    .subscribe(pageList -> {   
        //请求成功，这里能拿到PageList<Student>列表对象 
       int totalPage = pageList.getTotalPage();   //总页数
       List<Student> students = pageList.getData();  //单页列表数据        
    }, throwable -> {         
        //请求失败                
    });    

 

 

到这，估计很多人会问我：

 

  • 你的code在哪里判断的？

  • 我的code是100或者其它值才代表正确，怎么改？

  • 我的Response<T>类里面的字段名，跟你的都不一样，怎么该？

  • 你这成功的时候直接返回Response<T>里面的T，那我还要拿到code做其他的判断，执行不同业务逻辑，怎么办？

 

这里可以先告诉大家，asResponse(Class<T>)、asResponseList(Class<T>)、asResponsePageList(Class<T>)这3个方法并不是RxHttp内部提供的，而是通过自定义解析器生成，里面的code判断、Response<T>类都是开发者自定义的，如何自定义解析器，请查看本文5.1章节----自定义Parser。

 

接着回答第4个问题，如何拿到code做其他的业务逻辑判断，很简单，我们只需用OnError接口处理错误回调即可，如下：

 

 
RxHttp.postForm("/service/...")   //发送post表单请求
    .add("key", "value")          //添加参数，可调用多次
    .asResponse(Student.class)    //返回Student类型
    .subscribe(student -> {   
        //请求成功，这里能拿到 Student对象               
    }, (OnError) error -> {     //注意，这里要用OnError接口，其中error是一个ErrorInfo对象  
        //失败回调
        //拿到code字段，此时就可以对code做判断，执行不同的业务逻辑 
        int code = error.getErrorCode();     
        String errorMsg = error.getErrorMsg()  //拿到msg字段             
    });    

 

 

注：上面的OnError接口并非是RxHttp内部提供的，而是自定义的，在Demo里可以找到

以上介绍的5个asXxx方法，可以说基本涵盖80%以上的业务场景，接下来我们看看RxHttp都提供了哪些asXxx方法，如下：

 

 

RxHttp内部共提供了23个asXXX方法，其中：

 

  • 有7个是返回基本类型的包装类型，如：asInteger、asBoolean、asLong等等；

  • 还有7个是返回对象类型，如：asString、asBitmap、asList、asMap(3个)以及最常用asObject方法；

  • 剩下9个是asParser(Parser<T>)、 asUpload系列方法及asDownload系列方法。

 

duang、duang、duang !!! 划重点，这里我可以告诉大家，其实前面的14个方法，最终都是通过asParser(Parser<T>)方法实现的，具体实现过程，这里先跳过，后续会详细讲解。

 

3.3.3、第三部曲：订阅回调

 

这一步就很简单了，在第二部曲中，asXxx方法会返回Observable<T>对象，没错，就是RxJava内部的Observable<T>对象，此时我们便可通过subscribe系列方法订阅回调，如下：

 
//不处理任何回调
RxHttp.postForm("/service/...")   //发送post表单请求
    .add("key", "value")          //添加参数，可调用多次
    .asResponseList(Student.class)    //返回List<Student>类型
    .subscribe();    //不订阅任何回调

//仅订阅成功回调
RxHttp.postForm("/service/...")   //发送post表单请求
    .add("key", "value")          //添加参数，可调用多次
    .asResponseList(Student.class)    //返回List<Student>类型
    .subscribe(students -> {   
        //请求成功，这里能拿到List<Student>列表对象               
    });    

//订阅成功与失败回调
RxHttp.postForm("/service/...")   //发送post表单请求
    .add("key", "value")          //添加参数，可调用多次
    .asResponseList(Student.class)    //返回List<Student>类型
    .subscribe(students -> {   
        //请求成功，这里能拿到List<Student>列表对象               
    }, throwable -> {         
        //请求失败                
    });

//等等，省略

 

 

另外，我们还可以订阅请求开始/结束的回调，如下：

 
RxHttp.get("/service/...")
    .asString()
    .observeOn(AndroidSchedulers.mainThread())
    .doOnSubscribe(disposable -> {
        //请求开始，当前在主线程回调
    })
    .doFinally(() -> {
        //请求结束，当前在主线程回调
    })
    .as(RxLife.as(this))  //感知生命周期
    .subscribe(pageList -> {
        //成功回调，当前在主线程回调
    }, (OnError) error -> {
        //失败回调，当前在主线程回调
    });

 

到这，请求三部曲介绍完毕，接着，将介绍其它常用的功能

 

3.4、初始化

 

 
//设置debug模式，默认为false，设置为true后，发请求，过滤"RxHttp"能看到请求日志
RxHttp.setDebug(boolean debug)
//非必须,只能初始化一次，第二次将抛出异常
RxHttp.init(OkHttpClient okHttpClient)
//或者，调试模式下会有日志输出
RxHttp.init(OkHttpClient okHttpClient, boolean debug)

 

此步骤是非必须的，如需要添加拦截器等其他业务需求，则可调用init方法进行初始化，不初始化或者传入null即代表使用默认OkHttpClient对象，建议在Application中初始化，默认的OkHttpClient对象在HttpSender类中可以找到，如下：

 

 
private static OkHttpClient getDefaultOkHttpClient() {                              
    X509TrustManager trustAllCert = new X509TrustManagerImpl();                     
    SSLSocketFactory sslSocketFactory = new SSLSocketFactoryImpl(trustAllCert);     
    return new OkHttpClient.Builder()                                               
        .connectTimeout(10, TimeUnit.SECONDS)                                       
        .readTimeout(10, TimeUnit.SECONDS)                                          
        .writeTimeout(10, TimeUnit.SECONDS)                                         
        .sslSocketFactory(sslSocketFactory, trustAllCert) //添加信任证书                  
        .hostnameVerifier((hostname, session) -> true) //忽略host验证                   
        .build();                                                                   
}                                                                                   

 

虽然初始化是非必须的，但是建议大家传入自定义的OkHttpClient对象，一来，自定义的OkHttpClient能最大化满足自身的业务；二来，随着RxHttp版本的升级，默认的OkHttpClient可能会发生变化(虽然可能性很小)，故建议自定义OkHttpClient对象传入RxHttp。

 

3.5、公共参数/请求头

 

RxHttp支持为所有的请求添加公共参数/请求头，当然，如果你希望某个请求不添加公共参数/请求头，也是支持的，而且非常简单。如下：

 

 
RxHttp.setOnParamAssembly(new Function() {
    @Override
    public Param apply(Param p) { //此方法在子线程中执行，即请求发起线程
        Method method = p.getMethod();
        if (method.isGet()) {     //可根据请求类型添加不同的参数
        } else if (method.isPost()) {
        }
        return p.add("versionName", "1.0.0")//添加公共参数
                .addHeader("deviceType", "android"); //添加公共请求头
    }
});

 

我们需要调用RxHttp.setOnParamAssembly(Function)方法，并传入一个Function接口对象，每次发起请求，都会回调该接口。

 

当然，如果希望某个请求不回调该接口，即不添加公共参数/请求头，则可以调用setAssemblyEnabled(boolean)方法，并传入false即可，如下：

 
RxHttp.get("/service/...")       //get请求 
    .setAssemblyEnabled(false)   //设置是否添加公共参数/头部，默认为true    
    .asString()                  //返回字符串数据    
    .subscribe(s -> {            //这里的s为String类型
        //请求成功                                         
    }, throwable -> {                                  
        //请求失败                                         
    });                                                

 

3.6、多域名/动态域名

 

3.6.1、多域名

 

现实开发中，我们经常会遇到多个域名的情况，其中1个为默认域名，其它为非默认域名，对于这种情况，RxHttp提供了@DefaultDomain()、@Domain()这两个注解来标明默认域名和非默认域名，如下：

 

 
public class Url {
    @DefaultDomain() //设置为默认域名
    public static String baseUrl = "https://www.wanandroid.com/"

    @Domain(name = "BaseUrlBaidu") //非默认域名，并取别名为BaseUrlBaidu
    public static String baidu = "https://www.baidu.com/";

    @Domain(name = "BaseUrlGoogle") //非默认域名，并取别名为BaseUrlGoogle
    public static String google = "https://www.google.com/";
}

 

 

通过@Domain()注解标注非默认域名，就会在RxHttp类中生成setDomainToXxxIfAbsent()方法，其中Xxx就是注解中取的别名。

 

上面我们使用了两个@Domain()注解，此时(需要Rebuild一下项目)就会在RxHttp类中生成setDomainToBaseUrlBaiduIfAbsent()、setDomainToBaseUrlGoogleIfAbsent()这两方法，此时发请求，我们就可以使用指定的域名，如下：

 

//使用默认域名，则无需添加任何额外代码
//此时 url = "https://www.wanandroid.com/service/..." 
RxHttp.get("/service/...")
    .asString()  
    .subscribe();

//手动输入域名，此时 url = "https://www.mi.com/service/..."
RxHttp.get("https://www.mi.com/service/...")
    .asString()  
    .subscribe();

//手动输入域名时，若再次指定域名，则无效
//此时 url = "https://www.mi.com/service/..."
RxHttp.get("https://www.mi.com/service/...")
    .setDomainToBaseUrlBaiduIfAbsent()  //此时指定Baidu域名无效
    .asString()  
    .subscribe();

//使用谷歌域名，此时 url = "https://www.google.com/service/..."       
RxHttp.get("/service/...")
    .setDomainToBaseUrlGoogleIfAbsent() //指定使用Google域名
    .asString()  
    .subscribe();

 

通过以上案例，可以知道，RxHttp共有3种指定域名的方式，按优先级排名分别是：手动输入域名 > 指定非默认域名 > 使用默认域名。

 

3.6.2、动态域名

 

现实开发中，也会有动态域名切换的需求，如域名被封、或者需要根据服务端下发的域名去配置，这对于RxHttp来说简直就是 so easy !!! 我们只需要对BaseUrl重新赋值，此时发请求便会立即生效，如下：

 

//此时 url = "https://www.wanandroid.com/service/..."
RxHttp.get("/service/...")
    .asString()  
    .subscribe();

Url.baseUrl = "https://www.qq.com"; //动态更改默认域名，改完立即生效，非默认域名同理
//此时 url = "https://www.qq.com/service/..."
RxHttp.get("/service/...")
    .asString()  
    .subscribe();

 

3.7、关闭请求

 

我们知道，在Activity/Fragment中发起请求，如果页面销毁时，请求还未结束，就会有内存泄漏的危险，因此，我们需要在页面销毁时，关闭一些还未完成的请求，RxHttp提供了两种关闭请求的方式，分别是自动+手动。

 

3.7.1、自动关闭请求

 

自动关闭请求，需要引入本人开源的另一个库RxLife，先来看看如何用：

https://github.com/liujingxing/RxLife

 
//以下代码均在FragmentActivty/Fragment中调用

RxHttp.postForm("/service/...")
    .asString()
    .as(RxLife.as(this)) //页面销毁、自动关闭请求
    .subscribe();
    //或者
RxHttp.postForm("/service/...")
    .asString()
    .as(RxLife.asOnMain(this)) //页面销毁、自动关闭请求 并且在主线程回调观察者
    .subscribe();

//kotlin用户，请使用life或lifeOnMain方法，如下：
RxHttp.postForm("/service/...")
    .asString()
    .life(this) //页面销毁、自动关闭请求
    .subscribe();
    //或者
RxHttp.postForm("/service/...")
    .asString()
    .lifeOnMain(this) //页面销毁、自动关闭请求 并且在主线程回调观察者
    .subscribe();

 

上面的this为LifecycleOwner接口对象，我们的FragmentActivity/Fragment均实现了这个接口，所有我们在FragmentActivity/Fragment中可以直接传this。

 

3.7.2、手动关闭请求

 

手动关闭请求，我们只需要在订阅回调的时候拿到Disposable对象，通过该对象可以判断请求是否结束，如果没有，就可以关闭请求，如下：

 

 
//订阅回调，可以拿到Disposable对象
Disposable disposable = RxHttp.get("/service/...")
    .asString()  
    .subscribe(s -> { 
       //成功回调
    }, throwable -> {
       //失败回调
    });

if (!disposable.isDisposed()) {  //判断请求有没有结束
    disposable.dispose();       //没有结束，则关闭请求
}                              

 

 

3.8、文件上传/下载/进度监听

 

RxHttp可以非常优雅的实现上传/下载及进度的监听，是骡子是马，拉出来溜溜

 

3.8.1上传

 

通过addFile系列方法添加文件，如下：

 

RxHttp.postForm("/service/...") //发送Form表单形式的Post请求  
    .addFile("file1", new File("xxx/1.png"))  //添加单个文件      
    .addFile("fileList", new ArrayList<>())   //通过List对象，添加多个文件     
    .asString()                                      
    .subscribe(s -> {                              
        //上传成功                                     
    }, throwable -> {                              
        //上传失败                                     
    });                                            

 

通过asUpload系列方法监听上传进度，如下:

 

RxHttp.postForm("/service/...") //发送Form表单形式的Post请求                                    
    .addFile("file1", new File("xxx/1.png"))                                         
    .addFile("file2", new File("xxx/2.png"))                                         
    .asUpload(progress -> {                                                          
        //上传进度回调,0-100，仅在进度有更新时才会回调                                                  
        int currentProgress = progress.getProgress(); //当前进度 0-100                   
        long currentSize = progress.getCurrentSize(); //当前已上传的字节大小                   
        long totalSize = progress.getTotalSize();     //要上传的总字节大小                    
    }, AndroidSchedulers.mainThread())   //指定回调(进度/成功/失败)线程,不指定,默认在请求所在线程回调                                           
    .subscribe(s -> {                                                                
        //上传成功                                                                       
    }, throwable -> {                                                                
        //上传失败                                                                       
    });                                                                              

 

 

可以看到，跟上传的代码相比，我们仅仅是使用了asUpload(Consumer, Scheduler)方法替换asString()方法，第一个参数是进度监听接口，每当进度有更新时，都会回调该接口，第二个参数是指定回调的线程，这里我们指定了在UI线程中回调。

 

3.8.2、下载

 

下载使用asDownload(String)方法，传入本地路径即可

 

  //文件存储路径
String destPath = getExternalCacheDir() + "/" + System.currentTimeMillis() + ".apk";
RxHttp.get("http://update.9158.com/miaolive/Miaolive.apk")
    .asDownload(destPath) //注意这里使用asDownload操作符，并传入本地路径
    .subscribe(s -> {
        //下载成功,回调文件下载路径
    }, throwable -> {
        //下载失败
    });

 

 

3.8.3、带进度下载

 

带进度下载使用asDownload(String,Consumer,Scheduler)方法

 

  //文件存储路径
String destPath = getExternalCacheDir() + "/" + System.currentTimeMillis() + ".apk";
RxHttp.get("http://update.9158.com/miaolive/Miaolive.apk")
    .asDownload(destPath, progress -> {
        //下载进度回调,0-100，仅在进度有更新时才会回调，最多回调101次，最后一次回调文件存储路径
        int currentProgress = progress.getProgress(); //当前进度 0-100
        long currentSize = progress.getCurrentSize(); //当前已下载的字节大小
        long totalSize = progress.getTotalSize();     //要下载的总字节大小
    }, AndroidSchedulers.mainThread()) //指定主线程回调
    .subscribe(s -> {//s为String类型，这里为文件存储路径
        //下载完成，处理相关逻辑
    }, throwable -> {
        //下载失败，处理相关逻辑
    });

 

 

3.8.4、断点下载

 

断点下载相较于下载，仅需要调用setRangeHeader(long startIndex, long endIndex)方法传入开始及结束位置即可（结束位置不传默认为文件末尾），其它没有任何差别

 

 
String destPath = getExternalCacheDir() + "/" + "Miaobo.apk";
long length = new File(destPath).length(); //已下载的文件长度
RxHttp.get("http://update.9158.com/miaolive/Miaolive.apk")
    .setRangeHeader(length)  //设置开始下载位置，结束位置默认为文件末尾
    .asDownload(destPath)
    .subscribe(s -> { //s为String类型
        //下载成功，处理相关逻辑
    }, throwable -> {
        //下载失败，处理相关逻辑
    });

 

 

3.8.5、带进度断点下载

 

带进度断点下载相较于带进度下载仅需要调用setRangeHeader方法传入开始及结束位置即可（结束位置不传默认为文件末尾），其它没有任何差别

 

 
String destPath = getExternalCacheDir() + "/" + "Miaobo.apk";
long length = new File(destPath).length(); //已下载的文件长度
RxHttp.get("http://update.9158.com/miaolive/Miaolive.apk")
    .setRangeHeader(length)  //设置开始下载位置，结束位置默认为文件末尾
    .asDownload(destPath, progress -> {
        //下载进度回调,0-100，仅在进度有更新时才会回调
        int currentProgress = progress.getProgress(); //当前进度 0-100
        long currentSize = progress.getCurrentSize(); //当前已下载的字节大小
        long totalSize = progress.getTotalSize();     //要下载的总字节大小
    }, AndroidSchedulers.mainThread()) //指定主线程回调
    .subscribe(s -> { //s为String类型
        //下载成功，处理相关逻辑
    }, throwable -> {
        //下载失败，处理相关逻辑
    });

 

 

注：上面带进度断点下载中，返回的进度会从0开始，如果需要衔接上次下载的进度，则调用asDownload(String,long,Consumer,Scheduler)方法传入上次已经下载好的长度(第二个参数)，如下：

 

 
String destPath = getExternalCacheDir() + "/" + "Miaobo.apk";
long length = new File(destPath).length(); //已下载的文件长度
RxHttp.get("http://update.9158.com/miaolive/Miaolive.apk")
    .setRangeHeader(length)  //设置开始下载位置，结束位置默认为文件末尾
    .asDownload(destPath, length, progress -> {
        //下载进度回调,0-100，仅在进度有更新时才会回调
        int currentProgress = progress.getProgress(); //当前进度 0-100
        long currentSize = progress.getCurrentSize(); //当前已下载的字节大小
        long totalSize = progress.getTotalSize();     //要下载的总字节大小
    }, AndroidSchedulers.mainThread()) //指定主线程回调
    .subscribe(s -> { //s为String类型
        //下载成功，处理相关逻辑
    }, throwable -> {
        //下载失败，处理相关逻辑
    });

 

为了节省一下篇幅，让出源码解析的内容，这里省略了一些配置内容，也省略了一些扩展但是，但不影响整体阅读：

 

 

3.9、超时设置

3.10、设置Converter

 

3.11、请求加解密

 

3.12、指定请求/回调线程

 

3.13、 Retrofit用户

 

4

  原理剖析

 

 

4.1、工作流程

 

在RxHttp有4个重要的角色，分别是：

 

  • Param：RxHttp类中所有添加的参数/请求头/文件都交由它处理，它最终目的就是为了构建一个Request对象

  • HttpSender ：它负责从Param对象中拿到Request对象，从而执行请求，最终返回Response对象

  • Parser：它负责将HttpSender返回的Response对象，解析成我们期望的实体类对象，也就是泛型T

  • RxHttp：它像一个管家，指挥前面3个角色做事情，当然，它也有自己的事情要做，比如：请求线程的调度，BaseUrl的处理、允许开发者自定义API等等

 

为此，我画了一个流程图，可以直观的了解到RxHttp的大致工作流程

 

 

我想应该很好理解，RxHttp要做的事情，就是把添加的参数/请求头等全部丢给Param处理，自己啥事也不敢；

 

随后将Param交给HttpSender，让它去执行请求，执行完毕，返回Response对象；

 

接着又将Response对象丢给Parser去做数据解析工作，并返回实体类对象T；

 

最后，将T通过回调传给开发者，到此，一个请求就处理完成。

 

4.2、Param

 

首先，附上一张Param类的继承关系图

 

 

下面将从上往下对上图中的类做个简单的介绍：

 

  • IHeaders：接口类，里面定义了一系列addHeader方法

  • IParam：接口类，里面定义了add(String,Object)、addAll(Map)等方法，

  • IRequest：接口类，里面定义了一系列getXxx方法，通过这些方法最终构建一个Request对象

  • Param：接口类，是一个空接口，继承了前面3个接口，里面有一系列静态方法可以获取到Param的具体实现类

  • AbstractParam：Param接口的抽象实现类，实现了Param接口的所有方法

  • IFile：接口类，里面定义了一系列addFile方法

  • IUploadLengthLimit：接口类，里面就定义了一个checkLength()方法，用于限制文件上传大小

  • NoBodyParam：Param的具体实现类，Get、Head请求就是通过该类去实现的

  • JsonParam：Param的具体实现类，调用RxHttp.xxxJson(String)请求方法时，内部就是通过该类去实现的

  • JsonArrayParam：Param的具体实现类，调用RxHttp.xxxJsonArray(String)请求方法时，内部就是通过该类去实现的

  • FormParam：Param的具体实现类，同时又实现了IFile、IUploadLengthLimit两个接口，调用RxHttp.xxxForm(String)请求方法时，内部就是通过该类去实现的

 

4.3、HttpSender

 

HttpSender可以把它理解为请求发送者，里面声明OkHttpClient对象和一系列静态方法，我们来简单看下：

 
public final class HttpSender {

    private static OkHttpClient mOkHttpClient; //只能初始化一次,第二次将抛出异常
    //处理化OkHttpClient对象
    public static void init(OkHttpClient okHttpClient) {
        if (mOkHttpClient != null)
            throw new IllegalArgumentException("OkHttpClient can only be initialized once");
        mOkHttpClient = okHttpClient;
    }

    //通过Param对象同步执行一个请求
    public static Response execute(@NonNull Param param) throws IOException {
        return newCall(param).execute();
    }

    static Call newCall(Param param) throws IOException {
        return newCall(getOkHttpClient(), param);
    }
    //所有的请求，最终都会调此方法拿到Call对象，然后执行请求
    static Call newCall(OkHttpClient client, Param param) throws IOException {
        param = RxHttpPlugins.onParamAssembly(param);
        if (param instanceof IUploadLengthLimit) {
            ((IUploadLengthLimit) param).checkLength();
        }
        Request request = param.buildRequest();  //通过Param拿到Request对象
        LogUtil.log(request);
        return client.newCall(request);
    }

    //省略了部分方法
}

 

这里我们重点看下newCall(OkHttpClient, Param)方法，该方法第一行就是为Param添加公共参数；然后判断Param有没有实现IUploadLengthLimit接口，有的话，检查文件上传大小，超出大小，则抛出IO异常；接着就是通过Param拿到Request对象；最后拿到Call对象，就可以发送一个请求。

 

4.4、Parser

 

先看下Parser继承结构图

 

 

这里对上图中的类做个简单的介绍

 

  • Parser：接口类，里面定义了一个T onParse(Response)方法，输入Response对象，输出实体类对象T

  • AbstractParser：抽象类，里面没有任何具体实现，主要作用是在构造方法内获取泛型类型

  • SimpleParser：是一个万能的解析器，可以解析任意数据结构，RxHttp内置的大部分asXxx方法，内部就是通过该解析器实现的

  • ListParser：是一个列表解析器，可以解析任意列表数据，内置asList(Class<T>)方法，就是通过该解析器实现的

  • MapParser：是一个Map解析器，可以解析任意Map数据类型，内置的asMap系列方法，就是通过该解析器实现的

  • BitmapParser：是一个Bitmap解析器，通过该解析器可以获得一个Bitmap对象，asBitmap()方法内部就是通过该解析器实现的

  • DownloadParser：文件下载解析器，用于文件下载，内置的一系列asDownload方法就是通过该解析器实现的

 

5

  小技巧

 

在这教大家一个小技巧，由于使用RxHttp发送请求都遵循请求三部曲，故我们可以在android studio 设置代码模版,如下

 

 

如图设置好后，写代码时，输入rp,就会自动生成模版，如下：

 

 

6

  小结

 

到这，RxHttp常用功能介绍完毕，你会发现，一切都是那么的美好，无论你是get、post、加密请求、自定义解析器，还是文件上传/下载/进度监听等等，皆遵循请求三部曲。

ZyClient
关注
  • 0
    点赞
  • 踩
  • 4
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
RxHttp 让你眼前一亮的Http请求框架，2024年最新HarmonyOS鸿蒙自定义控件面试
2301_79098963的博客
04-15 773
前面第二部曲中，我们介绍了一系列asXxx方法，通过该系列方法可以很方便的指定数据返回类型，特别是自定义的这3个方法，将Reponse类型数据，处理的简直不要太完美，下面我们就来看看如何自定义Parser。源码永远是最好的学习方式，在学习自定义Parser前，我们不妨先看看内置的Parser是如何实现的其中，是的扩展方法，定义如下：!该方法的目的就是把服务器返回的数据，转换为我们期望的实体类对象。到这，我想大家应该就多少有点明白了，自定义Parser，无非就是继承。
一个基于rxhttp +rxjava3 封装的mvvm.zip
11-02
一个基于rxhttp +rxjava3 封装的mvvm.zip一个基于rxhttp +rxjava3 封装的mvvm.zip一个基于rxhttp +rxjava3 封装的mvvm.zip一个基于rxhttp +rxjava3 封装的mvvm.zip一个基于rxhttp +rxjava3 封装的mvvm.zip
2024年HarmonyOS鸿蒙最全RxHttp 让你眼前一亮的Http请求框架，鸿蒙工程师面试
2401_84850485的博客
05-14 1062
asDownload(destPath, AndroidSchedulers.mainThread(), progress -> { //第二个参数指定主线程回调。//当前已下载的字节大小。.as(RxLife.asOnMain(this)) //主线程回调，并在页面销毁自动关闭请求(如果还未关闭的话).observeOn(AndroidSchedulers.mainThread()) //指定在主线程回调。
移动开发最新RxHttp-完美适配Android-10-11-上传-下载-进度监听，2024-2024蚂蚁金服Android面试真题解析
2401_84123113的博客
05-12 692
对于程序员来说，要学习的知识内容、技术有太多太多，要想不被环境淘汰就只有不断提升自己，从来都是我们去适应环境，而不是环境来适应我们！当你有了学习线路，学习哪些内容，也知道以后的路怎么走了，理论看多了总要实践的最后，互联网不存在所谓的寒冬，只是你没有努力罢了！网上学习资料一大堆，但如果学到的知识不成体系，遇到问题时只是浅尝辄止，不再深入研究，那么很难做到真正的技术提升。需要这份系统化学习资料的朋友，可以戳这里获取一个人可以走的很快，但一群人才能走的更远！
RxHttp 一款让你眼前一亮的 Http 请求框架
技术小黑屋
12-28 1492
本文系 RxHttp作者不怕天黑 向本博客投稿，并授权在本站发表。 1、前言 RxHttp在今年4月份一经推出，就受到了广大Android 开发者的喜爱，截止本文发表在github上已有1100+star，为此，我自己也建个RxHttp&RxLife 的群（群号：378530627）目前群里也有将近120号人，里面有不少小伙伴提了很多有价值的创意，才使得RxHttp一直坚持走到了现在，在此...
2024年RxHttp 让你眼前一亮的Http请求框架(3)，发布面试结果文案
2401_84853048的博客
05-14 345
asDownload(destPath, AndroidSchedulers.mainThread(), progress -> { //第二个参数指定主线程回调。.as(RxLife.asOnMain(this)) //主线程回调，并在页面销毁自动关闭请求(如果还未关闭的话).observeOn(AndroidSchedulers.mainThread()) //指定在主线程回调。.setAssemblyEnabled(false) //设置是否添加公共参数/头部，默认为true。
2024年鸿蒙最新RxHttp 让你眼前一亮的Http请求框架(1)，面试下载
2401_84871072的博客
05-15 271
asDownload(destPath, AndroidSchedulers.mainThread(), progress -> { //第二个参数指定主线程回调。.as(RxLife.asOnMain(this)) //主线程回调，并在页面销毁自动关闭请求(如果还未关闭的话).setCache(File, long, CacheMode) //配置缓存目录，最大size及缓存模式。.observeOn(AndroidSchedulers.mainThread()) //指定在主线程回调。
2024年HarmonyOS鸿蒙最全RxHttp 让你眼前一亮的Http请求框架(4)，2024年最新小红书软件测试面试
2401_84850485的博客
05-14 871
RxHttp.deleteJson(String) //delete请求 参数以{application/json;RxHttp.postForm(String) //post请求 参数以{application/x-www-form-urlencoded}形式提交。RxHttp.deleteForm(String) //delete请求 参数以{application/x-www-form-urlencoded}形式提交。
HarmonyOS鸿蒙最新RxHttp 让你眼前一亮的Http请求框架(2)，2024年最新h5手机端页面开发
最新发布
2401_84862025的博客
05-17 281
RxHttp.deleteJson(String) //delete请求 参数以{application/json;RxHttp.postForm(String) //post请求 参数以{application/x-www-form-urlencoded}形式提交。RxHttp.deleteForm(String) //delete请求 参数以{application/x-www-form-urlencoded}形式提交。
2024年RxHttp 让你眼前一亮的Http请求框架(6)，2024年最新字节跳动面试内容
2401_84853048的博客
05-14 677
/rxjava2 (RxJava2/Rxjava3二选一，使用asXxx方法时必须)implementation ‘com.github.liujingxing.rxlife:rxlife-rxjava2:2.2.1’ //管理RxJava2生命周期，页面销毁，关闭请求@DefaultDomain //设置为默认域名RxHttp.get(“http://…”) //第一步, 通过get、postXxx、putXxx等方法，确定请求类型。
RxHttp 全网Http缓存最优解
刘敬兴的博客
12-22 624
1、前言 距离上一文RxHttp 让你眼前一亮的Http请求框架的发表，已过去两周，文章一经发表，RxHttp就收获了众多的好评，Github上Star数，也正式突破了1000，这对于我来说，是非常有动力的事情，感谢大家的支持，我再接再厉。 也有很多人跟说我，希望RxHttp能支持协程和缓存这两大功能，这不，非常好用的缓存公共就能来了，看完本文，相信你会再一次爱上RxHttp。另外，协程也已经在路...
EasyHttp_OkHttp网络请求框架_EasyHttp_
09-30
EasyHttp是一个基于OkHttp的网络请求框架，专为简化Android应用中的网络操作而设计。OkHttp作为现代HTTP客户端，以其高效、稳定和易用性在Android开发者中广受欢迎。EasyHttp将OkHttp的功能进一步封装，提供了更加...
RxHttp,OKHTTP+RXJava一、二、三.zip
10-11
RxHttp是一款结合了OKHTTP的高效网络请求能力和RXJava的响应式编程理念的开源项目。本文将深入探讨RxHttp的原理、使用方法以及它如何借助OKHTTP和RXJava的优势，为开发者带来更流畅的编程体验。 一、RxHttp概述 ...
安卓常用框架
01-03
一个较好的网络请求框架 优秀文档 Fragmentation 流行的单acitivity多fragment框架 优秀文档 Banner 挺方便的轮播图框架 官网文档 Iconics 一个字体图标库 官网文档 searchview 一个比较好的搜索框 基本介绍 Spinner...
详解RxJava2 Retrofit2 网络框架简洁轻便封装
08-28
RxJava2 Retrofit2 网络框架简洁轻便封装 本资源主要介绍了RxJava2 Retrofit2 网络...RxHttp是一个网络框架的管理类，用于简化网络请求的处理。在本资源中，RxHttp的封装用于实现网络框架的简洁轻便封装，方便调用。
关于Android Studio真机测试时找不到设备问题
ZyClient的博客
08-14 6673
目前遇到AS找不到设备的情况有三种。 第一种：设备没有开启开发者模式。 关于开启开发者模式，现在很多手机都会隐藏掉，这时候只需要打开设备设置→关于手机→连续点击操作系统多次。这时候开发者模式就出现了，一般是在“更多设置”里。进去打开开发者模式，记得把USB调试一起打开。 第二种：adb被占用 有些电脑，在手机连接上以后，会自动连接手机助手，导致adb被占用，以至于AS无法检测到设备，只要把...
[Android]今日头条的屏幕适配方案，简单又粗暴！
ZyClient的博客
08-24 4580
骚年你的屏幕适配方式该升级了!-今日头条适配方案 JessYan鸿洋前天 本文作者 作者：JessYan 链接： https://juejin.im/post/5b7a29736fb9a019d53e7ee2 本文由作者授权发布。 1 前言 这个月在 Android 技术圈中 屏幕适配 这个词曝光率挺高的，为什么这么说呢？因为这个月陆续有多个大佬发布了屏幕适...
Android中compileSdkVersion、buildToolsVersion、minSdkVersion和targetSdkVersion的含义作用
ZyClient的博客
12-18 3401
compileSdkVersion和minSdkVersion还比较通俗易懂，compileSdkVersion表示当前项目的编译版本，即你想让AndroidStudio以什么SDK版本去编译你的项目，minSdkVersion表示当前项目支持的最低安卓系统版本， buildToolsVersion则是指构建工具的SDK版本，也就是AndroidStudio中设置的AndroidSDK版本，bu...
android RxHttp 网络请求案例代码
05-19
以下是使用 RxHttp 进行网络请求的一个示例代码： ```java RxHttp.get("https://www.example.com/api") .addHeader("Authorization", "Bearer " + token) .addParam("page", "1") .addParam("limit", "10") .as...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值