介绍

介绍RxJava的实际应用场景：

网络请求

• 基本的RxJava结合Retrofit网络请求
• 串行请求多个服务端接口：在第1个网络请求成功后，继续再进行一次网络请求
• 并行请求多个服务端接口

其它

• 定时器
• 异步任务超时
• 点击事件去重

基本的RxJava结合Retrofit请求服务端接口

在 Android 开发中，Retrofit 是一个常用的网络请求库，而 RxJava 则可以与 Retrofit 结合使用，简化异步网络请求的处理。

1. 定义 API 接口

定义一个使用 RxJava 的 Retrofit API 接口：

public interface ApiService {
    @GET("users/{user}")
    Observable<User> getUser(@Path("user") String user);
}

2. 创建 Retrofit 实例

创建 Retrofit 实例并配置 RxJava 适配器：

Retrofit retrofit=new Retrofit.Builder()
        .baseUrl("https://api.github.com/")
        .addConverterFactory(GsonConverterFactory.create())
        .addCallAdapterFactory(RxJava2CallAdapterFactory.create())
        .build();

        ApiService apiService=retrofit.create(ApiService.class);

3. 使用 RxJava 进行网络请求

使用 RxJava 的 Observable 进行网络请求，并处理返回的数据：

apiService.getUser("octocat")
        .subscribeOn(Schedulers.io())
        .observeOn(AndroidSchedulers.mainThread())
        .subscribe(new Observer<User>(){
@Override
public void onSubscribe(Disposable d){
        // 开始订阅
        }

@Override
public void onNext(User user){
        // 处理返回的用户数据
        Log.d("RxJava","User: "+user.getName());
        }

@Override
public void onError(Throwable e){
        // 处理错误
        Log.e("RxJava","Error: "+e.getMessage());
        }

@Override
public void onComplete(){
        // 请求完成
        Log.d("RxJava","Completed");
        }
        });

串行请求多个服务端接口

在第一个网络请求成功后，继续进行另一个网络请求：

apiService.getUser("octocat")
        .subscribeOn(Schedulers.io())
        .flatMap(user->apiService.getFollowers(user.getLogin()))
        .observeOn(AndroidSchedulers.mainThread())
        .subscribe(new Observer<List<Follower>>(){
@Override
public void onSubscribe(Disposable d){
        // 开始订阅
        }

@Override
public void onNext(List<Follower> followers){
        // 处理返回的关注者数据
        Log.d("RxJava","Followers: "+followers.size());
        }

@Override
public void onError(Throwable e){
        // 处理错误
        Log.e("RxJava","Error: "+e.getMessage());
        }

@Override
public void onComplete(){
        // 请求完成
        Log.d("RxJava","Completed");
        }
        });

并行请求多个服务端接口

合并多个网络请求的数据，例如同时请求用户信息和用户的仓库列表：

Observable<User> userObservable=apiService.getUser("octocat");
Observable<List<Repo>>reposObservable=apiService.getRepos("octocat");

Observable.zip(userObservable,reposObservable,(user,repos)->{
        // 合并用户信息和仓库列表
        return new UserWithRepos(user,repos);
        })
        .subscribeOn(Schedulers.io())
        .observeOn(AndroidSchedulers.mainThread())
        .subscribe(new Observer<UserWithRepos>(){
@Override
public void onSubscribe(Disposable d){
        // 开始订阅
        }

@Override
public void onNext(UserWithRepos userWithRepos){
        // 处理返回的用户信息和仓库列表
        Log.d("RxJava","User: "+userWithRepos.getUser().getName());
        Log.d("RxJava","Repos: "+userWithRepos.getRepos().size());
        }

@Override
public void onError(Throwable e){
        // 处理错误
        Log.e("RxJava","Error: "+e.getMessage());
        }

@Override
public void onComplete(){
        // 请求完成
        Log.d("RxJava","Completed");
        }
        });

定时器

使用 RxJava 的 Observable.timer 实现定时任务：

Observable.timer(5,TimeUnit.SECONDS)
        .subscribeOn(Schedulers.io())
        .observeOn(AndroidSchedulers.mainThread())
        .subscribe(new Observer<Long>(){
@Override
public void onSubscribe(Disposable d){
        // 开始订阅
        }

@Override
public void onNext(Long aLong){
        // 定时任务触发
        Log.d("RxJava","Timer triggered");
        }

@Override
public void onError(Throwable e){
        // 处理错误
        Log.e("RxJava","Error: "+e.getMessage());
        }

@Override
public void onComplete(){
        // 定时任务完成
        Log.d("RxJava","Timer completed");
        }
        });

异步任务超时

使用 Observable.timeout 实现异步任务超时：

Observable.fromCallable(()->{
        // 执行耗时任务
        Thread.sleep(5000);
        return"Task completed";
        })
        .timeout(3,TimeUnit.SECONDS) // 设置超时时间为3秒
        .subscribeOn(Schedulers.io())
        .observeOn(AndroidSchedulers.mainThread())
        .subscribe(new Consumer<String>(){
@Override
public void accept(String result)throws Exception{
        // 处理结果
        textView.setText(result);
        }
        },new Consumer<Throwable>(){
@Override
public void accept(Throwable throwable)throws Exception{
        // 处理超时错误
        textView.setText("Task timed out");
        }
        });

点击事件去重

首先，在你的 build.gradle 文件中添加 RxBinding 的依赖：

dependencies {
    implementation 'com.jakewharton.rxbinding4:rxbinding:4.0.0'
}

使用 Observable.throttleFirst 去除快速重复点击事件：

RxView.clicks(button)
        .throttleFirst(1,TimeUnit.SECONDS)
        .subscribe(new Observer<Object>(){
@Override
public void onSubscribe(Disposable d){
        // 开始订阅
        }

@Override
public void onNext(Object o){
        // 处理点击事件
        Log.d("RxJava","Button clicked");
        }

@Override
public void onError(Throwable e){
        // 处理错误
        Log.e("RxJava","Error: "+e.getMessage());
        }

@Override
public void onComplete(){
        // 点击事件完成
        Log.d("RxJava","Completed");
        }
        });