336x280(권장), 300x250(권장), 250x250, 200x200 크기의 광고 코드만 넣을 수 있습니다.

 

[목차]==================================================

1. onError 해주지 않으면 Crash가 발생 주의
2. subscribe 에서 에러 처리
3. Error 캐치 - onErrorReturn
4. Error 캐치 - OnErrorResumeNext
5. Retry
6. Retry 횟수 제한
7. RetryWhen

======================================================

 

 

RxJava & RxAndroid 사용 시 항상 에러 핸들러를 구독하고 제공하는지 항상 확인해야 합니다. 그렇지 않으면 특히 Scheduler를 적용할 때 스택 트레이스에 아무것도 없을 수 있습니다. 물론 RxJava & RxAndroid 에서 뭔가 잘못됐다고 알려주긴 하지만 어디서 발생했는지 찾을 방법이 없습니다. 항상 에러 콜백을 사용하고, 에러가 발생한다면 에러를 로그로 남겨서 예상치 못한 오류를 기록해야 합니다.

 

1. onError 해주지 않으면 Crash가 발생 주의

 Observable.create(new ObservableOnSubscribe<String>() {
            @Override
            public void subscribe(ObservableEmitter<String> subscriber) throws Exception {
                log("subscribe");
                subscriber.onNext("emit 1");
                subscriber.onNext("emit 2");
                subscriber.onError(new Throwable());
            }
        }).subscribe(new Consumer<String>() {
            @Override
            public void accept(String s) throws Exception {
                log("on next: " + s);
            }
        });

 

2. subscribe 에서 에러 처리

 

Observable.create(new ObservableOnSubscribe<String>() {
            @Override
            public void subscribe(ObservableEmitter<String> subscriber) throws Exception {
                log("subscribe");
                subscriber.onNext("emit 1");
                subscriber.onNext("emit 2");
                subscriber.onError(new Throwable());
            }
        }).subscribe(new DefaultObserver<String>() {
            @Override
            public void onNext(String value) {
                log("on next: " + value);
            }

            @Override
            public void onError(Throwable e) {

                // 에러시 처리를 여기로 받음
                log("error:" + e);
            }

            @Override
            public void onComplete() {
                log("completed");
            }
        });

[출력결과]
subscribe
on next: emit 1
on next: emit 2
error:java.lang.Throwable

 

3. Error 캐치 - onErrorReturn
Observable 체인 안에서 발생한 Error 를 캐치해서, 대체할 Object로 변환하는 것으로 subscriber에 Error가 전달되는 것을 막을 수 있다.

 Observable.create(new ObservableOnSubscribe<String>() {
            @Override
            public void subscribe(ObservableEmitter<String> subscriber) throws Exception {
                log("subscribe");
                subscriber.onNext("emit 1");
                subscriber.onNext("emit 2");
                subscriber.onError(new Throwable());
            }
        }).onErrorReturn(new Function<Throwable, String>() {
            @Override
            public String apply(Throwable throwable) throws Exception {
                return "return";
            }
        }).subscribe(new DefaultObserver<String>() {
            @Override
            public void onNext(String value) {
                log("on next: " + value);
            }

            @Override
            public void onError(Throwable e) {
                // 에러시 처리를 여기로 받음
                log("error:" + e);
            }

            @Override
            public void onComplete() {
                log("completed");
            }
        });

[출력결과]
subscribe
on next: emit 1
on next: emit 2
on next: return
completed


4. Error 캐치 - OnErrorResumeNext
Observable 체인에서 발생한 Error를 캐치해서, 그 안에서 다시 한 번 Observable를 호출하면 에러시 대체 Stream을 반환할 수 있다.

 Observable.create(new ObservableOnSubscribe<String>() {
            @Override
            public void subscribe(ObservableEmitter<String> subscriber) throws Exception {
                log("subscribe");
                subscriber.onNext("emit 1");
                subscriber.onNext("emit 2");
                subscriber.onError(new Throwable());
            }
        }).onErrorResumeNext(new Function<Throwable, ObservableSource<? extends String>>() {
            @Override
            public ObservableSource<? extends String> apply(Throwable throwable) throws Exception {
                return Observable.fromArray(new String[]{"resume 1", "resume 2"});
            }
        }).subscribe(new DefaultObserver<String>() {
            @Override
            public void onNext(String value) {
                log("on next: " + value);
            }

            @Override
            public void onError(Throwable e) {
                // 에러시 처리를 여기로 받음
                log("error:" + e);
            }

            @Override
            public void onComplete() {
                log("completed");
            }
        });

[출력결과]
subscribe
on next: emit 1
on next: emit 2
on next: resume 1
on next: resume 2
completed

 

5. Retry
Error가 일어났을 때, 자동으로 subscribe를 다시 해준다.

성공할때까지 계속... 무한루프 될 가능성이 있으므로 유의해야 한다

 Observable.create(subscriber -> {
            log("subscribe");
            subscriber.onNext("emit 1");
            subscriber.onNext("emit 2");
            subscriber.onError(new Throwable());
        })
        .retry()
        .subscribe()

[출력결과]
subscribe
on next: emit 1
on next: emit 2
subscribe
on next: emit 1
on next: emit 2
subscribe
on next: emit 1
on next: emit 2
.
.
.

반복


6. Retry 횟수 제한

 Observable.create(subscriber -> {
            log("subscribe");
            subscriber.onNext("emit 1");
            subscriber.onNext("emit 2");
            subscriber.onError(new Throwable());
        })
        .retry(3)
        .subscribe()

[출력결과]
subscribe
on next: emit 1
on next: emit 2
subscribe
on next: emit 1
on next: emit 2
subscribe
on next: emit 1
on next: emit 2
subscribe
on next: emit 1
on next: emit 2
error:java.lang.Throwable

 

Retry 좀 더 구체적인 설정

 Observable.create(subscriber -> {
            log("subscribe");
            subscriber.onNext("emit 1");
            subscriber.onNext("emit 2");
            subscriber.onError(new Throwable());
        })
        .retry(new BiPredicate<Integer, Throwable>() {
            @Override
            public boolean test(Integer integer, Throwable throwable) throws Exception {
                if (integer < 3) {
                    return true;
                }
                return throwable instanceof IllegalStateException;
            }
        })

        .subscribe(s -> log("on next: " + s)
            , e -> log("error:" + e)
            , () -> log("completed"));

[출력결과]
subscribe
on next: emit 1
on next: emit 2
subscribe
on next: emit 1
on next: emit 2
subscribe
on next: emit 1
on next: emit 2
error:java.lang.Throwable

 

7. RetryWhen
보다 세밀하게 retry 처리를 제어하기 위한 함수.

 Observable.create(subscriber -> {

            log("subscribe");
            subscriber.onNext("emit 1");
            subscriber.onNext("emit 2");
            subscriber.onError(new Throwable());
        }).retryWhen(new Function<Observable<Throwable>, ObservableSource<?>>() {
            @Override
            public ObservableSource<?> apply(Observable<Throwable> throwableObservable) throws Exception {
                return throwableObservable.flatMap(new Function<Throwable, ObservableSource<?>>() {
                    @Override
                    public ObservableSource<?> apply(Throwable throwable) throws Exception {
                        return Observable.timer(3, TimeUnit.SECONDS);
                    }
                });
            }
        }).subscribe(s -> log("on next: " + s)
                        , e -> log("error:" + e)
                        , () -> log("completed"));

[출력결과]
subscribe
on next: emit 1
on next: emit 2
// 3초 후
subscribe
on next: emit 1
on next: emit 2
// 3초 후
subscribe
on next: emit 1
on next: emit 2
.
.
.
반복

 

그냥 Error인채로 종료

 Observable.create(subscriber -> {
            log("subscribe");
            subscriber.onNext("emit 1");
            subscriber.onNext("emit 2");
            subscriber.onError(new Throwable());
        }).subscribeOn(AndroidSchedulers.mainThread())
                .retryWhen(throwableObservable -> throwableObservable.flatMap(
                        throwable -> Observable.error(throwable)
                ))
.subscribe(s -> log("on next: " + s)
                , e -> log("error:" + e)
                , () -> log("completed"));

 

Error에 대한 처리를 하지 않고 Complete하기

 Observable.create(subscriber -> {
            log("subscribe");
            subscriber.onNext("emit 1");
            subscriber.onNext("emit 2");
            subscriber.onError(new Throwable());
        }).onErrorResumeNext(throwable -> {Observable.empty();})
                .subscribe(s -> log("on next: " + s)
                , e -> log("error:" + e)
                , () -> log("completed"));

[출력결과]
subscribe
on next: emit 1
on next: emit 2
completed

 

3번 retry하고 종료
이 경우, 앞의 retry(count) 함수와의 차이는 retry(count)에서는 retry 횟수가 제한에 도달한 후에 error로 종료합니다만, 이 케이스는 completed 에서 종료한다는 점이다.

 Observable.create(subscriber -> {
            log("subscribe");
            subscriber.onNext("emit 1");
            subscriber.onNext("emit 2");
            subscriber.onError(new Throwable());
        }).retryWhen(throwableObservable -> throwableObservable.take(3))
                .subscribe(s -> log("on next: " + s)
                , e -> log("error:" + e)
                , () -> log("completed"));

[출력결과]
subscribe
on next: emit 1
on next: emit 2
subscribe
on next: emit 1
on next: emit 2
subscribe
on next: emit 1
on next: emit 2
completed


3초 retry를 3번 하고 종료하기

 Observable.create(subscriber -> {
            log("subscribe");
            subscriber.onNext("emit 1");
            subscriber.onNext("emit 2");
            subscriber.onError(new Throwable());
        }).retryWhen(new Function<Observable<Throwable>, ObservableSource<?>>() {
            @Override
            public ObservableSource<?> apply(@NonNull Observable<Throwable> throwableObservable) throws Exception {
                return throwableObservable.take(3).flatMap(new Function<Throwable, ObservableSource<?>>() {
                    @Override
                    public ObservableSource<?> apply(@NonNull Throwable throwable) throws Exception {
                        return Observable.timer(3, TimeUnit.SECONDS);
                    }
                });
        
    }
        }).subscribe(s -> log("on next: " + s)
                        , e -> log("error:" + e)
                        , () -> log("completed"));

[출력결과]
subscribe
on next: emit 1
on next: emit 2
// 3초 후
subscribe
on next: emit 1
on next: emit 2
// 3초 후
subscribe
on next: emit 1
on next: emit 2
completed


 

 


 출처 : 인터넷에서 RxAndroid 검색하여 필요한 정보를 다양한 사이트에서 종합하여 작성된 것입니다. 많은 사이트 내용을 종합하여 공부하여 작성하다보니 일일이 나열하지 못하였습니다. ㅈㅅ(_ _) 이글은 자유롭게 퍼 가셔서 도움이 되었으면 좋겠습니다. 감사합니다. 

 

블로그 이미지

차봉규

IT개발 공부하려고 만든 블로그 입니다^^ 부족한점 많더라고...도움 많이 부탁해요

,
336x280(권장), 300x250(권장), 250x250, 200x200 크기의 광고 코드만 넣을 수 있습니다.

 

[목차]==================================================

1. RxJava와 RxAndroid에서 제공하는 Scheduler 종류

1) RxJava가 제공하는 Scheduler

2) RxAndroid는 제공하는 Scheduler

2. 독립적으로 사용 가능한 Scheduler

3. 사용법 예제

1) Scheduler 안한 경우 기본 동작
2) subscribeOn() API만 사용한 경우 동작
3) observerOn() API만 사용한 경우 동작
4) subscribeOn() & observerOn() 1번씩 API 사용한 경우 동작
5) subscribeOn() & observerOn() 다수 API 사용한 경우 동작

======================================================

 

 

RxAndroid에서는 Scheduler를 통해 어느 쓰레드에서 실행이 될지 결정 할 수 있습니다.
Scheduler는 subsctibeOn(), observeOn() 에서 각각 지정할 수 있는데

subsctibeOn()observable의 작업을 시작하는 쓰레드를 선택 할 수 있습니다.( 중복해서 적을 경우 가장 마지막에 적힌 스레드에서 시작합니다.)

observeOn()은 이후에 나오는 Operator, subscribe의 Scheduler를 변경 할 수 있습니다.

 

1. RxJava와 RxAndroid에서 제공하는 Scheduler 종류

1) RxJava가 제공하는 Scheduler

  • Schedulers.computation()

이벤트 룹에서 간단한 연산이나 콜백 처리를 위해서 쓰는 것입니다. I/O 처리를 여기에서 해서는 안됩니다.

RxComputationThreadPool라는 별도의 스레드 풀에서 돌아갑니다. 최대 cpu갯수 ?개의 스레드 풀이 순환하면서 실행됩니다.

  • Schedulers.from(executor)

특정 executor를 스케쥴러로 사용합니다

  • Schedulers.immediate

현재 스레드에서 즉시 수행합니다.
observeOn()이 여러번 쓰였을 경우 immediate()를 선언한 바로 윗쪽의 스레드를 따라갑니다.

  • Schedulers.io()

동기 I/O를 별도로 처리시켜 비동기 효율을 얻기 위한 스케줄러입니다. 자체적인 스레드 풀에 의존합니다.
자체적인 스레드 풀 CachedThreadPool을 사용합니다. API 호출 등 네트워크를 사용한 호출 시 사용됩니다.

  • Schedulers.newThread()

항상 새로운 스레드를 만드는 스케쥴러입니다.

  • Schedulers.trampoline()

큐에 있는 일이 끝나면 이어서 현재 스레드에서 수행하는 스케쥴러

 

※ 일부 오퍼레이터들은 자체적으로 어떤 스케쥴러를 사용할지 지정합니다. 예를 들어 buffer 오퍼레이터는 Schedulers.computation()에 의존하며 repeat은 Schedulers.trampoline()를 사용합니다.

 

 

2) RxAndroid는 제공하는 Scheduler

  • AndroidSchedulers.mainThread()

안드로이드의 UI 스레드에서 동작

  • HandlerScheduler.from(handler)

특정 핸들러 handler에 의존하여 동작

 

※ 안드로이드에 특화된 스케쥴러입니다. 보통은 RxAndroid가 제공하는 AndroidSchedulers.mainThread()와 RxJava가 제공하는 Schedulers.io()를 조합해서 Schedulers.io()에서 수행한 결과를 AndroidSchedulers.mainThread()에서 받아 UI에 반영하는 패턴등이 일반적으로 쓰입니다.

 

 

2. 독립적으로 사용 가능한 Scheduler

Scheduler는 Observable, Operator, Subscriber 모델 밖에서 별도로 사용할 수 있습니다.

 worker = Schedulers.newThread().createWorker();


worker.schedule(new Action0() {

    @Override
    public void call() {
        realmJob();
    }

});

 

 Scheduler.Worker worker = Schedulers.newThread().createWorker();
        worker.schedule(new Runnable() {
            @Override
            public void run() {
                log("worker: " + Thread.currentThread().getName());
            }
        });

[출력결과]
worker: RxNewThreadScheduler-1

 


3. 사용법 예제

1) Scheduler 안한 경우 기본 동작

Observable.create(new ObservableOnSubscribe<String>() {
            @Override
            public void subscribe(ObservableEmitter<String> e) throws Exception {
                log("subscribe:" + Thread.currentThread().getName());
                e.onNext("next");
            }
        }).map(s1 -> {
            log("map: " + Thread.currentThread().getName());
            return s1;
        }).subscribe(s -> log("on next: " + Thread.currentThread().getName()));

[출력결과]
subscribe:main
map: main
on next: main


2) subscribeOn() API만 사용한 경우 동작

Observable.create(new ObservableOnSubscribe<String>() {
            @Override
            public void subscribe(ObservableEmitter<String> e) throws Exception {
                log("subscribe:" + Thread.currentThread().getName());
                e.onNext("next");
            }
        }).subscribeOn(Schedulers.computation()).map(s1 -> {
            log("map: " + Thread.currentThread().getName());
            return s1;
        }).subscribe(s -> log("on next: " + Thread.currentThread().getName()));

[출력결과]
subscribe:RxComputationThreadPool-1
map: RxComputationThreadPool-1
on next: RxComputationThreadPool-1


3) observerOn() API만 사용한 경우 동작

Observable.create(new ObservableOnSubscribe<String>() {
            @Override
            public void subscribe(ObservableEmitter<String> e) throws Exception {
                log("subscribe:" + Thread.currentThread().getName());
                e.onNext("next");
            }
        }).observeOn(Schedulers.computation()).map(s1 -> {
            log("map: " + Thread.currentThread().getName());
            return s1;
        }).subscribe(s -> log("on next: " + Thread.currentThread().getName()));

[출력결과]
subscribe:main
map: RxComputationThreadPool-1
on next: RxComputationThreadPool-1


4) subscribeOn() & observerOn() 1번씩 API 사용한 경우 동작

Observable.create(new ObservableOnSubscribe<String>() {
            @Override
            public void subscribe(ObservableEmitter<String> e) throws Exception {
                log("subscribe:" + Thread.currentThread().getName());
                e.onNext("next");
            }
        }).subscribeOn(Schedulers.io())
              .observeOn(AndroidSchedulers.mainThread())
                .map(s1 -> {
                        log("map: " + Thread.currentThread().getName());
                        return s1;
         }).subscribe(s -> log("on next: " + Thread.currentThread().getName()));

[출력결과]
subscribe:RxCachedThreadScheduler-1
map: main
on next: main


5) subscribeOn() & observerOn() 다수 API 사용한 경우 동작

 Observable.create(new ObservableOnSubscribe<String>() {
            @Override
            public void subscribe(ObservableEmitter<String> e) throws Exception {
                log("subscribe:" + Thread.currentThread().getName());
                e.onNext("next");
            }
        }).subscribeOn(Schedulers.io())
          .subscribeOn(Schedulers.computation())
          .observeOn(AndroidSchedulers.mainThread()).map(s1 -> {
                        log("map1: " + Thread.currentThread().getName());
                        return s1;
         }).observeOn(Schedulers.newThread()).map(s2 -> {
                        log("map2: " + Thread.currentThread().getName());
                        return s2;
         }).observeOn(Schedulers.single()).map(s3 -> {
                        log("map3: " + Thread.currentThread().getName());
                        return s3;
         }).subscribe(s -> log("on next: " + Thread.currentThread().getName()));

[출력결과]
subscribe:RxCachedThreadScheduler-1
map1: main
map2: RxNewThreadScheduler-1
map3: RxSingleScheduler-1
on next: RxSingleScheduler-1

 



 

출처 : 인터넷에서 RxAndroid 검색하여 필요한 정보를 다양한 사이트에서 종합하여 작성된 것입니다. 많은 사이트 내용을 종합하여 공부하여 작성하다보니 일일이 나열하지 못하였습니다. ㅈㅅ(_ _) 이글은 자유롭게 퍼 가셔서 도움이 되었으면 좋겠습니다. 감사합니다. 

 

블로그 이미지

차봉규

IT개발 공부하려고 만든 블로그 입니다^^ 부족한점 많더라고...도움 많이 부탁해요

,
336x280(권장), 300x250(권장), 250x250, 200x200 크기의 광고 코드만 넣을 수 있습니다.

 

[목차]==================================================

1. Rxandroid 메모리누수

2. RxLifecycle 사용법(compose)

3. RxJava의 Lifecycle 사용방법 - CompositeSubscription

4. MVP 패턴에서의 CompositeSubscription

======================================================

 

1. Rxandroid 메모리누수

  • Rxandroid 는 메모리누수에 대한 문제점이 있는데,
    Observable이 Context를 복사해서 유지하고 있기 때문에 엑티비티가 종료 될때 unsubscribe하지 않으면 안된다. 기본 예제에서는 명시적으로 onPause 나 onDestory에 명시적으로 unsubscribe()를 호출하도록 되어 있다.(참고로 정상적으로 onComplete()나 onError()콜백으로 진입 하게 되면 알아서 unsubscribe()된다)

  •  => 이러한 부분을 쉽게 사용하기 위해서 RxLifecycle 라이브러리를 사용하면 쉽게 사용 할 수 있다.

2. RxLifecycle 사용법(compose)

  • Activity의 상속을 RxAppCompatActivity으로 변경하고 compose를 사용하여 Rxlifecycle을 적용해 줍니다.

  • onCreate 에서 subscribe을 하면 onDestory 에서 자동으로 unsubscribe 되고 onResume 에서 subscribe을 하면 onPause 에서 자동으로 unsubscribe 됩니다.

  • 만약에 종료되는 시점은 바꾸고 싶다면 직접 bindUntilEvent 선언하여 조정할 수 있습니다.

  • 프로젝트에 의존성 추가

 

 

 

package tiii.com.rxandroid;

import android.os.Bundle;
import android.util.Log;
import android.widget.TextView;

import com.trello.rxlifecycle.ActivityEvent;
import com.trello.rxlifecycle.components.support.RxAppCompatActivity;

import rx.Observable;
import rx.Subscriber;

public class MainActivity extends RxAppCompatActivity {
    public static final String TAG = MainActivity.class.getSimpleName();

    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_main);

        Observable<String> simpleObservable =
                Observable.create(new Observable.OnSubscribe<String>() {
                    @Override
                    public void call(Subscriber<? super String> subscriber) {
                        subscriber.onNext("Hello RxAndroid !!");
                        subscriber.onCompleted();
                    }
                })
                // `this.<String>` is necessary if you're compiling on JDK7 or below.
                //
                // If you're using JDK8+, then you can safely remove
                .compose(this.<String>bindToLifecycle());
                //.compose(this.<String>bindUntilEvent(ActivityEvent.DESTROY));


        simpleObservable.subscribe(new Subscriber<String>() {
            @Override
            public void onCompleted() {
                Log.d(TAG, "complete!");
            }

            @Override
            public void onError(Throwable e) {
                Log.e(TAG, "error: " + e.getMessage());
            }

            @Override
            public void onNext(String text) {
                ((TextView) findViewById(R.id.textview)).setText(text);
            }
        });
    }
}

 

 

3. RxJava의 Lifecycle 사용방법 - CompositeSubscription

  • RxJava에는 CompositeSubscription이라는 클래스를 제공 한다. 이 클래스는 생성된 Subscription인스턴스를 하나로 관리 해주는 클래스 이다.
  • CompositeSubscription클래스의 remove()메소드를 보면, Removes a Subscription from this CompositeSubscription, and unsubscribes the Subscription.이라고 되어 있다. 이 CompositeSubscription에 add()된 Subscription에 remove()메소드를 콜하면 CompositeSubscripnt에서 제거 되면 동시에 unsubscribe된다고 명시 되어 있다
    Activity나 Fragment등의 onCreate()메소드 에서는 멤버변수로 존재 하는 CompositeSubscription인스턴스를 생성 하는 기능이 들어 간다.

  • 어떠한 작업을 위해서 subscribe()를 하게 되면 Subscription인스턴스를 변수로 정의 한 다음 CompositeSubscription에 add()해 준다. Activity나 Fragment등의 onDestroy()메소등에서는 생성된 인스턴스로 존재 하는 CompositeSubscription인스턴스를 unsubscribe()한다. Activity나 Fragment에서 생성되어지고 add()된 모든 Rx의 subscribe들은 이제 unubcribe()될 것 이다.

 public class MainActivity
    extends Activity {
  private CompositeSubscription compositeSubscription;

  @Override
  protected void onCreate(Bundle savedInstanceState) {
    super.onCreate(savedInstanceState);
    compositeSubscription = new CompositeSubscription();

    Observable<String> observable = Observable.create(
        (Observable.OnSubscribe<String>) subscriber -> {
          ...
        }
    );
    Subscription subscription = observable
        .observeOn(Schedulers.computation())
        .subscribeOn(AndroidSchedulers.mainThread())
        .subscribe(
            s -> {
              ...
            }
        );
    compositeSubscription.add(subscription);
  }

  @Override
  protected void onDestroy() {
    if (compositeSubscription != null) {
      compositeSubscription.unsubscribe();
    }

    super.onDestroy();
  }
}

 

4. MVP 패턴에서의 CompositeSubscription

  • 위의 3번 방법에서는 Activity나 Fragment에 바로 Subscription을 생성하고 멤버변수로 CompositeSubscription을 생성하여 add(), unsubscribe()하는 것을 알 수 있다.

  • 하지만, MVP패턴에서는 Subscription을 실제로 생성하고 비동기 작업을 요청 하는곳이 Activity나 Fragment가 아닌 Presenter에서 하게 된다. Presenter에 CompositeSubscription을 멤버로 두고 관리하게 하는건 무리가 없을것이다. 하지만 Activity나 Fragment의 Lifecycle에 맞추어 Subscription을 관리 하려 하는 목적에 어긋난다.

  • 아래 소스는 Presenter의 부모 클래스로서 CompositeSubscription에 Subscriber를 등록 하고 destroy()메소드를 액티비티나 프래그먼트의 라이프 사이클에 맞추어 콜 하는 그 예 이다.

 public class BasePresenter {
  private CompositeSubscription compositeSubscriptionl;
 
  public BasePresenter() {
    this.compositeSubscriptionl = new CompositeSubscription();
  }
 
  public <T> void addSubscriber(@NonNull Subscriber<T> subscriber) {
    if (compositeSubscriptionl != null) {
      compositeSubscriptionl.add(subscriber);
    }
  }
 
  public void destroy() {
    if (compositeSubscriptionl != null) {
      compositeSubscriptionl.unsubscribe();
    }
  }
}

1) Presenter의 부모 클래스를 만들고 CompositeSubscription의 멤버변수를 추가 한다.
2) 부모 클래스의 생성자에서는 CompositeSubscription의 인스턴스를 생성 한다.
3) 부모 클래스에는 만들게 될 Subscriber의 인스턴스를 add()하는 메소드와 lifecycle의 onDestroy()에 맞춰 unsubscribe()하는 메소드인destroy()`메소드를 추가 한다.
4) 앞으로 만들게 되는 모든 Presenter들은 부모 Presenter를 상속해서 만든다.
5) 그리고 Activity나 Fragment를 상속한 부모 클래스들을 또 만들고, onCreate()메소드 군 에서는 presenter의 인스턴스를 생성 한다.
6) 또한 onDestroy()에서는 presenter의 destroy()메소드를 꼭 호출 하여 생성된 모든 Subscription을 unsubscribe()하게 해 준다.

이러한 부분이 번거롭다면, 그냥 Trello에서 개발 한 RxLifecycle을 사용 하자!

 

 

 

 


 

출처 : 인터넷에서 RxAndroid 검색하여 필요한 정보를 다양한 사이트에서 종합하여 작성된 것입니다. 많은 사이트 내용을 종합하여 공부하여 작성하다보니 일일이 나열하지 못하였습니다. ㅈㅅ(_ _) 이글은 자유롭게 퍼 가셔서 도움이 되었으면 좋겠습니다. 감사합니다. 

블로그 이미지

차봉규

IT개발 공부하려고 만든 블로그 입니다^^ 부족한점 많더라고...도움 많이 부탁해요

,