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

参考链接：
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