美文网首页
Rxjava2学习笔记二:RxJava2进阶使用-zip操作符

Rxjava2学习笔记二:RxJava2进阶使用-zip操作符

作者: 橘子树上结西瓜 | 来源:发表于2018-01-15 14:27 被阅读32次

    参考链接:
    https://www.jianshu.com/p/464fa025229e
    Rxjava2学习笔记一:RxJava2基本使用
    https://www.jianshu.com/p/cf1dbe7654fc
    Rxjava2学习笔记三:RxJava2进阶使用-map操作符
    https://www.jianshu.com/p/f7efc1aeb6c9

    基本使用

    • 1.Zip通过一个函数将多个Observable发送的事件结合到一起,然后发送这些组合到一起的事件. 它按照严格的顺序应用这个函数。它只发射与发射数据项最少的那个Observable一样多的数据

      Alt text
      其中一根水管负责发送圆形事件 , 另外一根水管负责发送三角形事件 , 通过Zip操作符, 使得圆形事件 和三角形事件 合并为了一个矩形事件
    • 2.代码(两个上游都在不同的线程)

        Observable<Integer> observable1 = Observable.create(new ObservableOnSubscribe<Integer>() {         
      

      @Override
      public void subscribe(ObservableEmitter<Integer> emitter) throws Exception {
      Log.d(TAG, "emit 1");
      emitter.onNext(1);
      Thread.sleep(1000);

        Log.d(TAG, "emit 2");                                                                      
        emitter.onNext(2);                                                                         
        Thread.sleep(1000);                                                                        
      
        Log.d(TAG, "emit 3");                                                                      
        emitter.onNext(3);                                                                         
        Thread.sleep(1000);                                                                        
      
        Log.d(TAG, "emit 4");                                                                      
        emitter.onNext(4);                                                                         
        Thread.sleep(1000);                                                                        
      
        Log.d(TAG, "emit complete1");                                                              
        emitter.onComplete();                                                                      
      

      }
      }).subscribeOn(Schedulers.io());

        Observable<String> observable2 = Observable.create(new ObservableOnSubscribe<String>() {           
            @Override                                                                                      
            public void subscribe(ObservableEmitter<String> emitter) throws Exception {                    
                Log.d(TAG, "emit A");                                                                      
                emitter.onNext("A");                                                                       
                Thread.sleep(1000);                                                                        
        
                Log.d(TAG, "emit B");                                                                      
                emitter.onNext("B");                                                                       
                Thread.sleep(1000);                                                                        
        
                Log.d(TAG, "emit C");                                                                      
                emitter.onNext("C");                                                                       
                Thread.sleep(1000);                                                                        
        
                Log.d(TAG, "emit complete2");                                                              
                emitter.onComplete();                                                                      
            }                                                                                              
        }).subscribeOn(Schedulers.io());                                                                   
        
        Observable.zip(observable1, observable2, new BiFunction<Integer, String, String>() {               
            @Override                                                                                      
            public String apply(Integer integer, String s) throws Exception {                              
                return integer + s;                                                                        
            }                                                                                              
        }).subscribe(new Observer<String>() {                    
            @Override                                                                                      
            public void onSubscribe(Disposable d) {                                                        
                Log.d(TAG, "onSubscribe");                                                                 
            }                                                                                              
        
            @Override                                                                                      
            public void onNext(String value) {                                                             
                Log.d(TAG, "onNext: " + value);                                                            
            }                                                                                              
        
            @Override                                                                                      
            public void onError(Throwable e) {                                                             
                Log.d(TAG, "onError");                                                                     
            }                                                                                              
        
            @Override                                                                                      
            public void onComplete() {                                                                     
                Log.d(TAG, "onComplete");                                                                  
            }                                                                                              
        });
      

    打印:

    D/TAG: onSubscribe
    D/TAG: emit A
    D/TAG: emit 1
    D/TAG: onNext: 1A
    D/TAG: emit B
    D/TAG: emit 2
    D/TAG: onNext: 2B
    D/TAG: emit C
    D/TAG: emit 3
    D/TAG: onNext: 3C
    D/TAG: emit complete2
    D/TAG: onComplete
    注:第一根水管发送了四个数据,但是最后只接收了三个数据,zip操作符-发送的事件数量跟上游中发送事件最少的那一根水管的事件数量一致

    实际应用

    • 1.需求:
      一个界面需要展示用户的一些信息, 而这些信息分别要从两个服务器接口中获取, 而只有当两个都获取到了之后才能进行展示。
    • 2.实现:

    接口-

        public interface Api {
            @GET
            Observable<UserBaseInfoResponse> getUserBaseInfo(@Body UserBaseInfoRequest request);
        
            @GET
            Observable<UserExtraInfoResponse> getUserExtraInfo(@Body UserExtraInfoRequest request);
        
        }  
    

    网络请求(zip打包请求)-

        Observable<UserBaseInfoResponse> observable1 =                                            
                api.getUserBaseInfo(new UserBaseInfoRequest()).subscribeOn(Schedulers.io());      
        
        Observable<UserExtraInfoResponse> observable2 =                                           
                api.getUserExtraInfo(new UserExtraInfoRequest()).subscribeOn(Schedulers.io());    
        
        Observable.zip(observable1, observable2,                                                  
                new BiFunction<UserBaseInfoResponse, UserExtraInfoResponse, UserInfo>() {         
                    @Override                                                                     
                    public UserInfo apply(UserBaseInfoResponse baseInfo,                          
                                          UserExtraInfoResponse extraInfo) throws Exception {     
                        return new UserInfo(baseInfo, extraInfo);                                 
                    }                                                                             
                }).observeOn(AndroidSchedulers.mainThread())                                      
                .subscribe(new Consumer<UserInfo>() {                                             
                    @Override                                                                     
                    public void accept(UserInfo userInfo) throws Exception {                      
                        //do something;                                                           
                    }                                                                             
                });
    

    小知识-电脑生成GIF图

    软件:GifCam

    相关文章

      网友评论

          本文标题:Rxjava2学习笔记二:RxJava2进阶使用-zip操作符

          本文链接:https://www.haomeiwen.com/subject/tmzroxtx.html