Android之RxAndroid2、RxJava2的zip应用场景及示例

ゝ一世哀愁。 2024-02-17 22:01 113阅读 0赞

**Android之RxAndroid2、RxJava2的zip应用场景及示例**

RxAndroid2、RxJava2的zip操作目的是为了合并两个Observable并最终发射一个单一的Observable结果。  
应用场景：比如在Android APP的开发中，涉及到和后台接口交互，网络请求结果往往不是单一的一次成型完成所有操作，以一个用户登录并获取用户头像Bitmap的流程为例。

第一阶段、先登录成功，获得该用户的用户id诸如此类的必要元数据。  
第二阶段、根据第一步获得的用户id然后再次发起网络请求获取该id头像的Bitmap数据，然后显示在ImageView里面。

这两阶段，虽然可以在第一阶段请求成功后再次发起第二阶段网络请求，如在Okhttp中的onSuccess里面拿到用户id，发起第二阶段的头像请求。但是代码逻辑嵌套深，不易于理解和维护。  
这样的场景就比较契合RxJava2、RxAndroid2的zip的设计。  
现在给出一个小例子说明：

package zhangphil.app;
    
    import android.os.Bundle;
    import android.support.annotation.NonNull;
    import android.support.annotation.Nullable;
    import android.support.v7.app.AppCompatActivity;
    import android.util.Log;
    
    import java.util.concurrent.Callable;
    
    import io.reactivex.Observable;
    import io.reactivex.android.schedulers.AndroidSchedulers;
    import io.reactivex.disposables.CompositeDisposable;
    import io.reactivex.functions.BiFunction;
    import io.reactivex.observers.DisposableObserver;
    import io.reactivex.schedulers.Schedulers;
    
    public class MainActivity extends AppCompatActivity {
        private final String TAG = getClass().getSimpleName();
        private CompositeDisposable mCompositeDisposable = new CompositeDisposable();
    
        @Override
        public void onCreate(@Nullable Bundle savedInstanceState) {
            super.onCreate(savedInstanceState);
            addItems();
        }
    
        private void addItems() {
            DisposableObserver disposableObserver = new DisposableObserver<DataObject>() {
                @Override
                public void onNext(@NonNull DataObject object) {
                    Log.d(TAG, "#####开始#####");
                    Log.d(TAG + "数据", String.valueOf(object.A));
                    Log.d(TAG + "数据", String.valueOf(object.B));
                    Log.d(TAG, "#####结束#####");
                }
    
                @Override
                public void onComplete() {
    
                }
    
                @Override
                public void onError(Throwable e) {
                    Log.e(TAG, e.toString(), e);
                }
            };
    
            mCompositeDisposable.add(
                    Observable.zip(getObservableA(null), getObservableB(null),
                            new BiFunction<String, String, DataObject>() {
                                @Override
                                public DataObject apply(String a, String b)
                                        throws Exception {
    
                                    DataObject object = new DataObject();
                                    object.A = a;
                                    object.B = b;
    
                                    return object;
                                }
                            })
                            .subscribeOn(Schedulers.io())
                            .observeOn(AndroidSchedulers.mainThread())
                            .subscribeWith(disposableObserver));
        }
    
        @Override
        protected void onDestroy() {
            super.onDestroy();
    
            // 如果退出程序，就清除后台任务
            mCompositeDisposable.clear();
        }
    
        private Observable<String> getObservableA(@NonNull
        final TempObject tempObject) {
            return Observable.fromCallable(new Callable<String>() {
                @Override
                public String call() throws Exception {
                    try {
                        Thread.sleep(5000); // 假设此处是耗时操作
                    } catch (Exception e) {
                        e.printStackTrace();
                    }
    
                    return "A";
                }
            });
        }
    
        private Observable<String> getObservableB(@NonNull
        final TempObject tempObject) {
            return Observable.fromCallable(new Callable<String>() {
                @Override
                public String call() throws Exception {
                    try {
                        Thread.sleep(5000); // 假设此处是耗时操作
                    } catch (Exception e) {
                        e.printStackTrace();
                    }
    
                    return "B";
                }
            });
        }
    
        private class DataObject {
            public String A = null;
            public String B = null;
        }
    
        /**
         * 这是一个废弃无用的数据结构，用以演示如何在请求之间传递参数
         */
        private class TempObject {
            public String temp;
        }
    }

代码运行输出：

05-12 17:36:53.614 30041-30041/zhangphil.app D/MainActivity: #####开始#####
    05-12 17:36:53.615 30041-30041/zhangphil.app D/MainActivity数据: A
    05-12 17:36:53.615 30041-30041/zhangphil.app D/MainActivity数据: B
    05-12 17:36:53.616 30041-30041/zhangphil.app D/MainActivity: #####结束#####