Comment remplacer les 'if' avec rx-java pour éviter le rappel de l'enfer?

Je cherche à remplacer mon code avec rx-java. (Il est très petit code.)

C'est fini et ça fonctionne.

Mais je veux savoir...

1. Est-ce une bonne Rx style?
2. Si pas bon, veuillez indiquer mauvais point

Ci-dessous mon code qui est de l'api de manipulation.

avant

Random r = new Random();
boolean apiResult = r.nextBoolean(); //it represents api result. ex. {"result": true} or {"result": false}

if (apiResult == true) {
    //do something

    System.out.println("result:" + "success");
} else {
    //do something

    System.out.println("result:" + "failure");
}

après

Random r = new Random();
Observable<Boolean> apiResultStream = Observable.create(new OnSubscribe<Boolean>() {
    @Override
    public void call(Subscriber<? super Boolean> subscriber) {
        //emit true or false
         subscriber.onNext(r.nextBoolean());
    }
}).cache(1);


//I used filter for split. Is it Rx style?
//success if true emitted.
Observable<Boolean> successStream = apiResultStream
        .filter(aBoolean -> aBoolean == true); //here

//failure if false emitted.
Observable<Boolean> failureStream = apiResultStream
        .filter(aBoolean -> aBoolean == false); //here


//success flow
successStream
        .flatMap(aBoolean -> Observable.just("success"))
        //and do something
        .subscribe(aString -> System.out.println("result:" + aString));

//failure flow
failureStream
        .flatMap(aBoolean -> Observable.just("failure"))
        //and do something.
        //I want to keep subscriber.
        .subscribe(aString -> System.out.println("result:" + aString));

MODIFIER

J'ai presque remplacé. merci pour les bon commentaire.
(mais j'ai un peu de non-remplacement de code. Il ont beaucoup de rappel et si le relevé).

Je veux éviter de "rappel de l'enfer'.

La clé est différente type de résultat entre les "callSuccessApi" et "callFailureApi'

avant rx

//callback hell!
callApi(new Callback<Result>(){
    @Override
    public void success(Result result) {
        if (result.Response == true) {
            callSuccessApi(new Callback<ResultSuccess>(){
                @Override
                public void success(ResultSuccess result) {
                    //and more callbacks...
                }
            }
        } else { //result.Response == false
            callFailureApi(new Callback<ResultFailure>(){
                @Override
                public void success(ResultFailure result) {
                    //and more callbacks...
                }
            }
        }
    }
}

après avec rx(éviter de rappel de l'enfer! Est-ce une bonne Rx style?)

//change 1st api to observable.(I changed other api to observable)
Observable<Result> apiResultStream = Observable.create(new OnSubscribe<Boolean>() {
    @Override
    public void call(Subscriber<? super Boolean> subscriber) {
        callApi(new Callback<Result>(){
            @Override
            public void success(Result result) {
                subscriber.onNext(result);
            }
        });
    }
}).cache(1); //ensure same Observable<Result> for success and failure.


//I used filter for split. Is it Rx style?
//success if result.response == true.
Observable<ResultSuccess> successStream = apiResultStream
        .filter(result -> result.response == true); //here

//failure if result.response == false.
Observable<ResultFailure> failureStream = apiResultStream
        .filter(result -> result.response == false); //here


//success flow. callSuccessApi return Observable<ResultSuccess>
successStream
        .flatMap(result -> callSuccessApi(result))
        //and more api call with flatMap...
        .subscribe(resultSuccessN -> System.out.println("result:" + resultSuccessN.toString()));

//failure flow. callFailureApi return Observable<ResultFailure>
failureStream
.flatMap(resultFailure -> callFailureApi(result))
        //and more api call with flatMap...
        .subscribe(resultFailureN -> System.out.println("result:" + resultFailureN.toString()));

désolé pour mon mauvais anglais et longue question.

Mis À Jour Mon Code

J'ai eu 2 informations importantes dans cette question.(merci @Tomáš Dvořák, @Will

1. si c'est une bonne voie à suivre dépend de la situation particulière.
2. Il n'y a rien de mal à utiliser une instruction if dans une carte /flatmap /abonnez-vous.

mise à jour du code

Observable<Result> apiResultStream = Observable.create(new OnSubscribe<Boolean>() {
        @Override
        public void call(Subscriber<? super Boolean> subscriber) {
            callApi(new Callback<Result>() {
                @Override
                public void success(Result result) {
                    subscriber.onNext(result);
                }
            });
        }
    });

    //In this case,   I used 'if' for simply and cleanly.
    apiResultStream
            .subscribe(result -> {
                if (result.response == true) {
                    callSuccessApi(); //this line looks like 'callback'. but I used this for simply and cleanly.
                } else {
                    callFailureApi();
                }
            });

OriginalL'auteur kyanro | 2015-02-03