Android RxHttp在实战中的运用

最新推荐文章于 2024-09-10 09:15:19 发布
最新推荐文章于 2024-09-10 09:15:19 发布
阅读量2.2k 收藏 6
点赞数
分类专栏： Android 网络通信
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_32136827/article/details/106131541
版权

至于RxHttp是什么，在这里就不讲了，有需要的可以前往查看RxHttp详解，Github讲解

RxHttp如何实现像Retrfit+RxJava那样链式多条请求的请移步

本篇主要来看一下在实战中是如何运用的
1、导入相关的库文件

	implementation 'com.rxjava.rxhttp:rxhttp:2.1.0' //必须
    annotationProcessor 'com.rxjava.rxhttp:rxhttp-compiler:2.1.0' //注解处理器，生成RxHttp类,必须
    implementation 'com.rxjava.rxlife:rxlife-x:2.0.0'
    implementation 'io.reactivex.rxjava2:rxandroid:2.1.1'
    implementation 'com.squareup.okhttp3:logging-interceptor:3.8.0'

2、支持JDK8

	compileOptions {
        sourceCompatibility JavaVersion.VERSION_1_8
        targetCompatibility JavaVersion.VERSION_1_8
    }

3、工具类

import android.text.TextUtils;
import androidx.fragment.app.FragmentActivity;
import com.rxjava.rxlife.RxLife;

import java.io.File;
import java.util.Map;
import java.util.concurrent.TimeUnit;

import io.reactivex.ObservableSource;
import io.reactivex.Observer;
import io.reactivex.android.schedulers.AndroidSchedulers;
import io.reactivex.disposables.Disposable;
import io.reactivex.functions.Consumer;
import io.reactivex.functions.Function;
import okhttp3.OkHttpClient;
import okhttp3.logging.HttpLoggingInterceptor;
import rxhttp.wrapper.annotation.DefaultDomain;
import rxhttp.wrapper.entity.Progress;
import rxhttp.wrapper.param.RxHttp;

/**
 * FileName: RxhttpUtil
 * Author: admin
 * Date: 2020/5/14 15:27
 * Description:
 */
public class RxhttpUtil {

    @DefaultDomain
    public static String baseUrl = "http://www.baidu.com/";

    private static volatile RxhttpUtil instance = null;

    public static RxhttpUtil getInstance() {
        if (instance == null) {
            synchronized (RxhttpUtil.class) {
                if (instance == null) {
                    instance = new RxhttpUtil();
                }
            }
        }
        return instance;
    }

    /**
     * 初始化RxHttp
     *
     * @param debug false:非debug模式，true:debug模式
     * @param url   更换BaseUrl
     */
    public static void init(boolean debug, String url) {
        if (!TextUtils.isEmpty(url)) {
            baseUrl = url;
        }
        setOkhttp(debug);
    }

    /**
     * 初始化RxHttp
     *
     * @param debug false:非debug模式，true:debug模式
     */
    public static void init(boolean debug) {
        setOkhttp(debug);
    }

    private static void setOkhttp(boolean debug) {
        OkHttpClient.Builder builder = new OkHttpClient.Builder()
                .readTimeout(30 * 1000, TimeUnit.MILLISECONDS)
                .writeTimeout(30 * 1000, TimeUnit.MILLISECONDS)
                .connectTimeout(30 * 1000, TimeUnit.MILLISECONDS);
        /**
         * 注入请求日志
         */
        HttpLoggingInterceptor loggingInterceptor = new HttpLoggingInterceptor();
        loggingInterceptor.setLevel(HttpLoggingInterceptor.Level.BODY);
        builder.addInterceptor(loggingInterceptor);
        RxHttp.init(builder.build(), debug);
    }

    /**
     * get 请求
     *
     * @param url          接口地址
     * @param a
     * @param httpCallBack
     */
    public void get(String url, FragmentActivity a, RxHttpCallBack httpCallBack) {
        RxHttp.get(url)
                .asString()
                .observeOn(AndroidSchedulers.mainThread())
                .as(RxLife.asOnMain(a))
                .subscribe(new Observer<String>() {
                    @Override
                    public void onSubscribe(Disposable d) {
                        httpCallBack.onStart();
                    }

                    @Override
                    public void onNext(String s) {
                        httpCallBack.onSuccess(s);
                    }

                    @Override
                    public void onError(Throwable e) {
                        httpCallBack.onError(e.getMessage());
                    }

                    @Override
                    public void onComplete() {
                        httpCallBack.onFinish();
                    }
                });
    }

    /**
     * get 请求
     *
     * @param url          接口地址
     * @param map          请求参数
     * @param a
     * @param httpCallBack
     */
    public void get(String url, Map<String, String> map, FragmentActivity a, RxHttpCallBack httpCallBack) {
        RxHttp.get(url)
                .addAll(map)
                .asString()
                .observeOn(AndroidSchedulers.mainThread())
                .as(RxLife.asOnMain(a))
                .subscribe(new Observer<String>() {
                    @Override
                    public void onSubscribe(Disposable d) {
                        httpCallBack.onStart();
                    }

                    @Override
                    public void onNext(String s) {
                        httpCallBack.onSuccess(s);
                    }

                    @Override
                    public void onError(Throwable e) {
                        httpCallBack.onError(e.getMessage());
                    }

                    @Override
                    public void onComplete() {
                        httpCallBack.onFinish();
                    }
                });
    }

    /**
     * get请求
     *
     * @param url            接口地址
     * @param map            请求参数
     * @param rxBaseResponse 请求返回的数据对象
     * @param a
     * @param httpResponse
     */
    public void get(String url, Map<String, String> map, RxBaseResponse rxBaseResponse, FragmentActivity a, RxHttpResponse httpResponse) {
        RxHttp.get(url)
                .addAll(map)
                .asResponse(rxBaseResponse.getClass())
                .observeOn(AndroidSchedulers.mainThread())
                .as(RxLife.asOnMain(a))
                .subscribe(new Observer<RxBaseResponse>() {
                    @Override
                    public void onSubscribe(Disposable d) {
                        httpResponse.onStart();
                    }

                    @Override
                    public void onNext(RxBaseResponse rxBaseResponse) {
                        httpResponse.onSuccess(rxBaseResponse);
                    }

                    @Override
                    public void onError(Throwable e) {
                        httpResponse.onError(e.getMessage());
                    }

                    @Override
                    public void onComplete() {
                        httpResponse.onFinish();
                    }
                });
    }

    /**
     * post请求
     *
     * @param url          接口地址
     * @param map          请求参数
     * @param a
     * @param httpCallBack
     */
    public void post(String url, Map<String, String> map, FragmentActivity a, RxHttpCallBack httpCallBack) {
        RxHttp.postForm(url)
                .addAll(map)
                .asString()
                .observeOn(AndroidSchedulers.mainThread())
                .as(RxLife.asOnMain(a))
                .subscribe(new Observer<String>() {
                    @Override
                    public void onSubscribe(Disposable d) {
                        httpCallBack.onStart();
                    }

                    @Override
                    public void onNext(String s) {
                        httpCallBack.onSuccess(s);
                    }

                    @Override
                    public void onError(Throwable e) {
                        httpCallBack.onError(e.getMessage());
                    }

                    @Override
                    public void onComplete() {
                        httpCallBack.onFinish();
                    }
                });
    }

    /**
     * post请求
     *
     * @param url          接口地址
     * @param map          请求参数
     * @param baseResponse 请求返回的数据对象
     * @param a
     * @param httpCallBack
     */
    public void post(String url, Map<String, String> map, RxBaseResponse baseResponse, FragmentActivity a, RxHttpResponse httpCallBack) {
        RxHttp.postForm(url)
                .addAll(map)
                .asObject(baseResponse.getClass())
                .observeOn(AndroidSchedulers.mainThread())
                .as(RxLife.asOnMain(a))
                .subscribe(new Observer<RxBaseResponse>() {
                    @Override
                    public void onSubscribe(Disposable d) {
                        httpCallBack.onStart();
                    }

                    @Override
                    public void onNext(RxBaseResponse s) {
                        httpCallBack.onSuccess(s);
                    }

                    @Override
                    public void onError(Throwable e) {
                        httpCallBack.onError(e.getMessage());
                    }

                    @Override
                    public void onComplete() {
                        httpCallBack.onFinish();
                    }
                });
    }

    /**
     * post表单请求
     *
     * @param url          接口地址
     * @param map          请求参数
     * @param a
     * @param httpCallBack
     */
    public void postFrom(String url, Map<String, String> map, FragmentActivity a, RxHttpCallBack httpCallBack) {
        RxHttp.postForm(url)
                .addAll(map)
                .asString()
                .observeOn(AndroidSchedulers.mainThread())
                .as(RxLife.asOnMain(a))     //界面销毁，自动关闭请求
                .subscribe(new Observer<String>() {
                    @Override
                    public void onSubscribe(Disposable d) {
                        httpCallBack.onStart();
                    }

                    @Override
                    public void onNext(String s) {
                        httpCallBack.onSuccess(s);
                    }

                    @Override
                    public void onError(Throwable e) {
                        httpCallBack.onError(e.getMessage());
                    }

                    @Override
                    public void onComplete() {
                        httpCallBack.onFinish();
                    }
                });
    }

    /**
     * 上传文件
     *
     * @param url        上传地址
     * @param key        文件key
     * @param filePath   本地文件地址
     * @param rxHttpFile 上传回调
     */
    public void uploadFile(String url, String key, String filePath, FragmentActivity a, RxHttpFile rxHttpFile) {
        RxHttp.postForm(url) //发送Form表单形式的Post请求
                .addFile(key, new File(filePath))
                .asUpload(new Consumer<Progress>() {
                    @Override
                    public void accept(Progress progress) throws Exception {
                        rxHttpFile.onProgress(progress.getProgress(), progress.getCurrentSize(), progress.getTotalSize());
                    }
                }, AndroidSchedulers.mainThread())
                .as(RxLife.asOnMain(a))
                .subscribe(new Observer<String>() {
                    @Override
                    public void onSubscribe(Disposable d) {
                        rxHttpFile.onStart();
                    }

                    @Override
                    public void onNext(String s) {
                        rxHttpFile.onSuccess(s);
                    }

                    @Override
                    public void onError(Throwable e) {
                        rxHttpFile.onError(e.getMessage());
                    }

                    @Override
                    public void onComplete() {
                        rxHttpFile.onFinish();
                    }
                });
    }

    /**
     * 文件下载
     *
     * @param httpUrl  下载的文件网络位置
     * @param filePath 下载到本地的位置
     * @param a        activity
     * @param httpFile 下载回调
     */
    public void downloadFile(String httpUrl, String filePath, FragmentActivity a, RxHttpFile httpFile) {
        RxHttp.get(httpUrl)
                .asDownload(filePath, new Consumer<Progress>() {
                    @Override
                    public void accept(Progress progress) throws Exception {
                        httpFile.onProgress(progress.getProgress(), progress.getCurrentSize(), progress.getTotalSize());
                    }
                }, AndroidSchedulers.mainThread()) //指定主线程回调
                .as(RxLife.asOnMain(a))
                .subscribe(new Observer<String>() {
                    @Override
                    public void onSubscribe(Disposable d) {
                        httpFile.onStart();
                    }

                    @Override
                    public void onNext(String s) {
                        httpFile.onSuccess(s);
                    }

                    @Override
                    public void onError(Throwable e) {
                        httpFile.onError(e.getMessage());
                    }

                    @Override
                    public void onComplete() {
                        httpFile.onFinish();
                    }
                });
    }

    /**
     * 链式请求实例,可根据实际需求做调整
     *
     * @param a
     * @param url1 第一个接口地址
     * @param url2 第二个接口地址
     * @param map1 第一个接口请求的参数
     * @param map2 第二个接口请求的参数
     */
    public void post(FragmentActivity a, String url1, String url2, Map<String, String> map1, Map<String, String> map2, RxHttpCallBack callBack) {
        RxHttp.postForm(url1)
                .addAll(map1)
                .asString()
                .flatMap(new Function<String, ObservableSource<?>>() {
                    @Override
                    public ObservableSource<?> apply(String s) throws Exception {
                        return RxHttp.get(url2)
                                .addAll(map2)
                                .subscribeOnCurrent()
                                .asString();
                    }
                })
                .as(RxLife.asOnMain(a))
                .subscribe(new Observer<Object>() {
                    @Override
                    public void onSubscribe(Disposable d) {
                        callBack.onStart();
                    }

                    @Override
                    public void onNext(Object o) {
                        callBack.onSuccess(o.toString());
                    }

                    @Override
                    public void onError(Throwable e) {
                        callBack.onError(e.toString());
                    }

                    @Override
                    public void onComplete() {
                        callBack.onFinish();
                    }
                });
    }

    public interface RxHttpCallBack {
        /**
         * 开始请求
         */
        void onStart();

        /**
         * 请求成功
         *
         * @param response
         */
        void onSuccess(String response);

        /**
         * 请求异常
         *
         * @param error
         */
        void onError(String error);

        /**
         * 请求结束
         */
        void onFinish();
    }

    public interface RxHttpResponse {
        /**
         * 开始请求
         */
        void onStart();

        /**
         * 请求成功
         *
         * @param response
         */
        void onSuccess(RxBaseResponse response);

        /**
         * 请求异常
         *
         * @param error
         */
        void onError(String error);

        /**
         * 请求结束
         */
        void onFinish();
    }

    public interface RxHttpFile {
        /**
         * 开始请求
         */
        void onStart();

        /**
         * 请求成功
         *
         * @param response
         */
        void onSuccess(String response);

        /**
         * 上传进度或下载进度
         *
         * @param progress    当前进度
         * @param currentSize 已上传或下载字节大小
         * @param totalSize   总字节大小
         */
        void onProgress(int progress, long currentSize, long totalSize);

        /**
         * 请求异常
         *
         * @param error
         */
        void onError(String error);

        /**
         * 请求结束
         */
        void onFinish();
    }
}

如果需要请求结果返回对象可进行简单封装

public abstract class RxBaseResponse<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;
    }
}

解析器

@Parser(name = "Response")
public class RxResponseParser<T> extends AbstractParser<T> {

    protected RxResponseParser() {
        super();
    }

    public RxResponseParser(Type type) {
        super(type);
    }

    @Override
    public T onParse(okhttp3.Response response) throws IOException {
        final Type type = ParameterizedTypeImpl.get(RxBaseResponse.class, mType); //获取泛型类型
        RxBaseResponse<T> data = convert(response, type);
        T t = data.getData(); //获取data字段
        if (data.getCode() != 200 || t == null) {//这里假设code不等于200，代表数据不正确，抛出异常
            throw new ParseException(String.valueOf(data.getCode()), data.getMsg(), response);
        }
        return t;
    }
}

致辞结束！

落魄的Android开发
关注
专栏目录
RxHttp-一条链发送请求，新一代Http请求神器，flutter面试题
m0_61417997的博客
09-02 247
Disposable disposable = HttpSender.from(param) .subscribe(s -> { //这里的s为String类型，即Http请求的返回结果 //成功回调 }, throwable -> { //失败回调 }); `疑问：说好的一条链发送请求呢？别着急，还没到放大招的时候` 到这，我可以告诉大家，`Param`承担的是一个请求体的一个角色，我们通过`Param`可以确定请求方式(如：Get、Post、Put、Delete等请求方式)、添加请求参数、
RxHttp-完美适配Android-10-11-上传-下载-进度监听，三步即可搞懂任意请求
m0_65511807的博客
12-19 520
当我们App的targetSdkVersion更改为28以上，并且运行在Android 10以上设备时，我们无法再以绝对路径的方式，去读写非沙盒目录下的文件，当然，如果App是覆盖安装（如：targetSdkVersion 28 覆盖安装为 29），则会保持原来的访问方式。 requestLegacyExternalStorage属性 如果我们的app将targetSdkVersion更改为28以上，且想保持原来的访问方式，则需要在清单文件中将 requestLegacyExternalStorage 的值
Android-RxRetroHttp一个AndroidHttp请求库支持同时存在多种返回格式和多个baseurl
08-13
RxRetroHttp 一个Android Http请求库，支持同时存在多种返回格式和多个base url
RxHttp 完美适配Android 10/11 上传/下载/进度监听
Android技术之家
10-20 849
1、前言随着Android 11的正式发布，适配Android 10/11 分区存储就更加的迫切了，因为Android 11开始，将强制开启分区存储，我们就无法再以绝对路径的方式去读写非...
**Rx-HTTP 请求库使用指南**
最新发布
gitblog_01200的博客
09-10 340
Rx-HTTP 请求库使用指南 rx-http-requestThe world-famous HTTP client Request now RxJS compliant, wrote in full Typescript | ES6 for client and server side.项目地址:https://gitcode.com/gh_mirrors/rx/rx-http-reques...
好文推荐：RxHttp-完美适配Android-10-11-上传-下载-进度监听
2401_84149724的博客
05-07 374
val result = RxHttp.postForm(“/service/…”) .add(“key”, “value”) .addPart(context, “file”, uri) .awaitString() //awaitXxx系列方法是挂断方法//RxJava RxHttp.postForm(“/service/…”) .add(“key”, “value”) .addPart(context, “file”, uri) .asString() .subscribe({ //成功回调 },
Android应用安全实战：Frida协议分析.docx
09-13
在 Android 应用安全实战中，Frida 协议是一种非常强大的工具，能够帮助开发人员深入了解应用的运行机制，检测和修复安全漏洞。Frida 协议可以用于对 Android 应用进行 hook 和注入，检测应用中的安全漏洞，并修复...
Android底层开发实战_Android底层开发实战_android_android开发实战_
10-02
在Android开发中，底层开发通常涉及操作系统、硬件接口、驱动程序和系统服务等核心部分，这对于优化性能、解决复杂问题以及创新功能至关重要。以下是该书可能涵盖的一些关键知识点： 1. **Android系统架构**：了解...
Android Studio开发实战：从零基础到App上线
08-28
在学习过程中，章节结构通常按照Android应用开发的基础知识逐步展开，例如： - **Chapter 08** 可能涉及UI设计，讲解如何使用布局管理器（如LinearLayout、RelativeLayout、ConstraintLayout）来构建用户界面，以及...
android实战 Android应用市场（android studio源程序工程）
01-19
在Android应用市场项目中，你将看到以下几个关键组件： 1. **主界面**：通常包含一个可滚动的应用列表，展示各种应用程序。这些数据可能来源于网络API，通过网络请求获取，也可能存储在本地数据库或文件中。使用...
Android项目实战——应用市场
06-09
在本“Android项目实战——应用市场”的教程中，我们将运用Android平台的各种技术和工具来构建一个类似Google Play的应用商店。这个实战项目将涵盖多个关键知识点，包括用户界面设计、数据存储、网络请求、数据解析...
博客更新后RxAndroid+Retrofit+okhttp框架Demo
05-13
这是我写的一篇博客：http://blog.csdn.net/adzcsx2/article/details/51333890 中解决Android中RxJava内存泄漏问题的Demo，以及如何封装，加上Retrofit,okhttp搭建好的未完成框架。方便其他人学习。5月13号更新
okhttp-RxHttp：on基于OkHttp封装，支持Kotlin协程，RxJava2，RxJava3； 30秒钟开始
02-21
RxHttp English | 适用于Android的类型安全的HTTP客户端。 基于OkHttp编写 1，特点 支持Kotlin协程，RxJava2，RxJava3 支持Gson，Xml，ProtoBuf，FastJson和其他第三方数据解析工具 支持自动关闭FragmentActivity，Fragment，View，ViewModel和任何类中的请求 支持全局加密和解密，添加通用参数和标头，网络缓存，均支持单独设置请求 2，用途 1，添加依赖项和配置 必需的 // Must be used when using kapt apply plugin : ' kotlin-kapt ' android { // Java 8 or higher compileOptions { sourceCompatibility JavaVersion . V
RxHttpUtils, Rxjava Retrofit封装，便捷使用.zip
09-16
RxHttpUtils, Rxjava Retrofit封装，便捷使用.zip
rxhttp的简单使用（android）
weixin_48516064的博客
06-03 1197
rxhttp使用
RxHttp 2000+star，协程请求，循序渐进
m0_65511807的博客
12-19 224
// name 参数在这会生成 setDomainToGoogleIfAbsent方法，可随意指定名称 // className 参数在这会生成RxGoogleHttp类，可随意指定名称 @Domain(name = “Google”, className = “Google”) public static String GOOGLE = “https://www.google.com”; } 以上配置www.wanandroid.com为默认域名，www.google.com为非默认域名 多BaseUrl
2024年安卓最新安卓学习笔记---开篇（目录结构），2024年最新软件开发面试题及答案
2301_82244182的博客
05-08 553
找到一套好的视频资料，紧跟大牛梳理好的知识框架进行学习。多练。（视频优势是互动感强，容易集中注意力）你不需要是天才，也不需要具备强悍的天赋，只要做到这两点，短期内成功的概率是非常高的。对于很多初中级Android工程师而言，想要提升技能，往往是自己摸索成长，不成体系的学习效果低效漫长且无助。
Android浅谈RxJava
ZHappyDragon的博客
05-09 263
前言 最近学习了一下RxJava，真的觉得它是一个很好的东西，虽然代码稍微有点多，但是他的逻辑性是能够一眼就看出来的，并且能实现异步操作，因此在这里简单介绍一下RxJava，后续可能会继续补充。 RxJava 到底是什么 不想看那些高大上的解释，那么， RxJava 的本质可以压缩为异步这一个词。说到根上，它就是一个实现异步操作的库。 观察者模式 RxJava 有四个基本概念：Observable (可观察者，即被观察者)、 Observer (观察者)、 subscribe (订阅)、事件。 Observ
评论 7
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

落魄的Android开发

感谢支持

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值