用RxJava中的observable替換回調

Question

我使用偵聽器作為回調來觀察Android的異步操作，但我認為用RxJava替換這個偵聽器可能很棒，我是新的使用這個庫，但我真的很喜歡它，我總是在Android項目中使用它。

這是我重構的代碼：

public void getData( final OnResponseListener listener ){
   if(data!=null && !data.isEmpty()){
       listener.onSuccess();
   }
   else{
       listener.onError();
   }
}

一個簡單的回調：

public interface OnResponseListener {
   public void onSuccess();
   public void onError(); 
}

而“觀察者”：

object.getData( new OnResponseListener() {
    @Override
    public void onSuccess() {
       Log.w(TAG," on success");
    }

    @Override
    public void onError() {
       Log.e(TAG," on error");
    }
});

謝謝！

Answer 1

例如，您可以使用Observable.fromCallable為您的數據創建observable。

public Observable<Data> getData(){
    return Observable.fromCallable(() -> {
        Data result = null;
        //do something, get your Data object
        return result;
    });
}

然后使用你的數據

 getData().subscribeOn(Schedulers.io())
            .observeOn(AndroidSchedulers.mainThread())
            .subscribe(data -> {
                //do something with your data
            }, error -> {
                //do something on error
            });

使用rxjava 1.x和lambda表達式。

編輯：

如果我理解你，你想要替換那個監聽器，而不是把它包裝成可觀察的。 我在參考你的評論時添加了其他例子。 哦..如果你只期待一件商品，也應該使用Single 。

public Single<Data> getData() {
        return Single.create(singleSubscriber -> {
            Data result = object.getData();
            if(result == null){
                singleSubscriber.onError(new Exception("no data"));
            } else {
                singleSubscriber.onSuccess(result);
            }
        });
    }

getData().subscribeOn(Schedulers.io())
            .observeOn(AndroidSchedulers.mainThread())
            .subscribe(data -> {
                //do something with your data
            }, error -> {
                //do something on error
            });

Answer 2

您正在尋找Completable.create ：

Completable ：表示沒有任何值的延遲計算，但僅表示完成或異常。 該類遵循與Reactive-Streams類似的事件模式：onSubscribe（onError | onComplete）？

Completable.create(subscriber -> {
    object.getData(new OnResponseListener() {
        @Override
        public void onSuccess() {
           subscriber.onCompleted();
        }

        @Override
        public void onError() {
           subscriber.onError(* put appropriate Throwable here *);
        }
    }
})
...//apply Schedulers
.subscribe((() -> *success*), (throwable -> *error*));

Answer 3

我將如何重構你的代碼; 除了getData方法，我還將getData方法包裝為Single：

public void getData( final OnResponseListener listener ){
    if(data!=null && !data.isEmpty()){
        listener.onSuccess();
    }
    else{
        listener.onError();
    }
}

public Single<Boolean> getDataSingle() {
    return Single.create(new SingleOnSubscribe<Boolean>() {
        @Override
        public void subscribe(SingleEmitter<Boolean> e) throws Exception {
            getData(new OnResponseListener() {
                @Override
                public void onSuccess() {
                    e.onSuccess(true);
                }

                @Override
                public void onError() {
                    e.onSuccess(false);
                }
            });
        }
    });
}

或者使用Java 8：

public Single<Boolean> getDataSingle() {
    return Single.create(e -> getData(
            new OnResponseListener() {
                @Override
                public void onSuccess() {
                    e.onSuccess(true);
                }

                @Override
                public void onError() {
                    e.onSuccess(false);
                }
            })
    );
}

現在，您已經在回調函數旁邊公開了一個Rx API。 假設它是您自己的某種DataProvider，您現在可以在不處理回調的情況下使用它，如下所示：

dataProvider.getDataSingle()
        .map(result -> result ? "User exist" : "User doesn't exist")
        .subscribe(message -> display(message));

我使用Rx2但是使用Rx1邏輯是相同的。

我還使用了Single而不是Observable，因為你只等待一個值。 興趣是你的功能更具表現力的合同。

您不能代表Observable發出值，即調用類似myObservable.send（value）的值。 第一種解決方案是使用主題 。 另一個解決方案（上面的解決方案）是使用Observable.create（）（或Single.create（））創建observable。 你調用回調方法並在方法Observable.create（）中創建監聽器，因為它在Observable.create（）內部，你可以調用onSuccess（）方法，該方法告訴Observable傳遞一個值。

這是我用來將回調包裝成可觀察的東西。 起初有點復雜，但很容易適應。

我問你另一個例子。 假設您要將EditText的更改顯示為Snackbar：

View rootView;
EditText editTextView;

//Wrap Android addTextChangedListener into an Observable
Observable<String> textObservable = Observable.create(consumer ->
        editTextView.addTextChangedListener(new TextWatcher() {
            @Override
            public void beforeTextChanged(CharSequence s, int start, int count, int after) {

            }

            @Override
            public void onTextChanged(CharSequence s, int start, int before, int count) {

            }

            @Override
            public void afterTextChanged(Editable s) {
                consumer.onNext(s.toString());
            }
        })
);

//Use it
textObservable.subscribe(text -> Snackbar.make(rootView, text, Snackbar.LENGTH_SHORT).show());

Answer 4

Maybe.<String>create(new MaybeOnSubscribe<String>() {
      @Override
      public void subscribe(MaybeEmitter<String> e) throws Exception {
        OnSuccessListener(uri->{
          e.onSuccess(uri));
        })
        .addOnFailureListener(throwable -> {
          e.onError(throwable);
        });
      }
    });