RxJava, callback, sens

0

Krótkie pytanie jak zastąpić tego rodzaju callback za pomocą RxJavy.

Klasa A, B i interfejs. Standardowo wygląda to tak:

interface CustomCallback {
    void onCallbackCalled(String str);
}

class ClassA {
    private ClassB classB;
    public ClassA() {
        classB = new ClassB(new CustomCallback() {
            @Override
            public void onCallbackCalled(String str) {
                System.out.println("Callback called " + str);
            }
        });
    }
}

class ClassB {
    private CustomCallback customCallback;
    public ClassB(CustomCallback callback) {
        customCallback = callback;
    }
    private void somethingHappened() {
        customCallback.onCallbackCalled("method somethingHappened");
    }
}

Metodę onCallbackCalled(String str) z poziomu klasy B mogę wywoływać wielokrotnie;
KLASA A
↓ ............................................ wstrzyknięcie interfejsu przez konstruktor
................↑ ↑ ↑ ↑ ↑ ↑ ↑ ↑ ↑ ↑ ↑ ↑ ↑ onCallbackCalled(...) ile razy chcę
KLASA B

RxJava
W 99% przypadków które znalazłem, powtarza się schemat:

class ClassA {
    private ClassB classB;
    public ClassA() {
        classB = new ClassB();
    }

    public void rxJavaMethod() {
                DisposableObserver<String> observer = classB.getObservable()
                .subscribeOn(Schedulers.io())
                .observeOn(AndroidSchedulers.mainThread())
                .subscribeWith(new DisposableObserver<String>() {

                    @Override
                    public void onNext(String s) {}

                    @Override
                    public void onError(Throwable e) {}

                    @Override
                    public void onComplete() {}
                });
    }
}

class ClassB {
    private Observable<String> getObservable() {
        return Observable.just(jakiś AsyncTask, Http connection czy cokolwiek innego do wykonania, 128218 opcji);
    }
}

Oczywiście schemat wygląda jak:
KLASA A
↓ jedno żądanie zwrócenia zasobu Observable
................↑ zwraca 0...n obiektów observable na jedno żądanie
KLASA B

Myślałem, że jeżeli zrobię w klasie B zmienną Observable, to później będzie możliwe wykonywanie callbacków na takiej samej zasadzie jak standardowo w Java... wszak jest połączenie z obserwatorem za pomocą subskrybcji ( załóżmy, że obserwator też jest zadeklarowany jako pole w klasie A).

class ClassB {
    private Observable<String> observable;

    // wywołane z poziomu klasy A, nawiązanie połączenia z obserwatorem 
    private Observable<String> getObservable() {
        observable = new Observable<String>() {
        ....
        }
        return observable;
    }

    // wywołanie już po nawiązaniu połączenia z obserwatorem z klasy A
    // pytanie -> jak to osiągnąć?
    private void callbackByRxJava {
        observable. ( tutaj czary-mary i callback do klasy A)
    }
}

Pytania:
1) Jak osiągnąć taki callback za pomocą RxJava.
2) Czy jest sens? Jakaś przewaga nad standardowym callbackiem za pomocą interfejsu?
3) Słowa-klucze do poszukania przeze mnie i poczytania w dokumentacji ( związane z tym zagadnieniem)?
4) Dlaczego na forum jest tak mało pytań odnośnie RxJavy? ( tag rxjava raptem 4 razy, wliczając dwa tematy zrobione przeze mnie)?

Mam nadzieję, że mniej więcej objaśniłem o co mi chodzi. Trzeba sporo napisać, żeby się dobrze wysłowić, ale nie chcę dodawać tutaj epopei.

0

Pytań jest mało bo w Javie to jeszcze nie jest mocno rozpowszechnione. Dopiero Java 9 to zmieni, ale oficjalnie nie została wydana ;)
Słyszałem że to jest dobrym materiałem: http://helion.pl/ksiazki/reac[...]sen,e_09le.htm#section4_shift :)

0
scibi92 napisał(a):

Pytań jest mało bo w Javie to jeszcze nie jest mocno rozpowszechnione. Dopiero Java 9 to zmieni, ale oficjalnie nie została wydana ;)

To by tłumaczyło dlaczego po wpisaniu frazy RxJava ( cośtam) w google dostaje się 32981732819 tutoriali w stylu "Jak zastąpić AsyncTask".

1 użytkowników online, w tym zalogowanych: 0, gości: 1, botów: 0