[RxSwift] Observable & Observer (just, of, from, create)

---

 

RxSwfit

Reactive eXension + Swift
비동기 프로그래밍을 직관적으로 작성할 수 있도록 도움을 주는 라이브러리

RxSwift는 구독(Observe)을 해서 데이터 변화에 반응하기 때문에 비동기 처리를 쉽게 할 수 있도록 도움을 주는 라이브러리이다.

 

Observable & Observer

▷ Observable을 통해서 이벤트 값을 방출(Emit)할 수 있고, 이 값을 구독(Subscribe)하여 관찰하고 반응할 수 있다.

▷ 하나 이상의 관잘차(Observer)가 실시간으로 데이터 변화에 반응하여 처리한다. (ex. UI 업데이트, 클릭 이벤트, ...)
→ Observable을 구독하고 있는 Observer

▷ Observable은 3가지 이벤트를 방출할 수 있다.
 - onNext: 다음 값을 전달하는 이벤트(새로운 값이 배출될 때마다 호출)
 - onError: 값 배출 과정에서 에러가 발생하면 error를 방출하고 종료시키는 이벤트(= disposed)
 - onCompleted: 성공할 경우 이벤트 시퀀스를 종료시키는 이벤트(= disposed)

 

Observable LifeCycle

1. Observable 생성
2. Subscribe를 한 시점부터 Observable 실행
3. next를 통해 이벤트 방출

---

Observable 생성 방법

이벤트가 전달되는 시점은 Observer가 Observable를 구독(subscribe)을 한 이후 부터이다.

Observable를 생성하는 방법은 4가지가 있다.

1. just
2. of
3. from
4. Create

---

just는 오직 하나의 값을 방출하는 Observable Sequence를 생성한다.

let observable = Observable.just(1)

이렇게 단 하나의 항목만 파라미터로 넘겨줄 수 있다.
이 상태로 subscribe(구독)을 하게 되면,

obaservable.subscribe { value in
            print(value)
        } onError: { error in
            print(error)
        } onCompleted: {
            print("onCompleted")
        } onDisposed: {
            print("onDisposed")
        }
        .disposed(by: disposeBag)
        
// <실행 결과>
// 1
// onCompleted
// onDisposed

이렇게 1을 한번 방출하고, 바로 complete → dispose 된다.
이렇게 하나만 방출하기 때문에 만약 배열을 just에 넣은 경우에는 배열 자체를 방출하고 종료된다.

---

of는 1개 이상의 항목을 방출하는 Observable Sequence를 생성한다.

let observable = Observable.of(1, 2, 3) // 1번

let observable = Observable.of([1, 2, 3]) // 2번

1번은 1 → 2→ 3→ 종료!

2번처럼 of의 인자로 배열을 넣게 되면,
[1, 2, 3] → 종료!
이렇게 단일 요소로 방출한다.

of는 이렇게 방출하고 싶은 만큼 항목을 넘길 수 있다. 단, 타입을 모두 동일해야한다.

// 1번
obaservable.subscribe { value in
            print(value)
        } onError: { error in
            print(error)
        } onCompleted: {
            print("onCompleted")
        } onDisposed: {
            print("onDisposed")
        }
        .disposed(by: disposeBag)
        
// <실행 결과>
// 1
// 2
// 3
// onCompleted
// onDisposed

1번에서 넘겨준 1, 2, 3을 순서대로 방출하고 dispose된다.

// 2번
obaservable.subscribe { value in
            print(value)
        } onError: { error in
            print(error)
        } onCompleted: {
            print("onCompleted")
        } onDisposed: {
            print("onDisposed")
        }
        .disposed(by: disposeBag)
        
// <실행 결과>
// [1, 2, 3]
// onCompleted
// onDisposed

이렇게 2번처럼 배열을 넣은 경우에는
파라미터 하나를 항목으로 취급하기 때문에 just처럼 배열을 하나의 항목으로 방출한다

---

from은 배열의 각 요소들을 순서대로 Observable Sequence를 생성한다.

let observable3 = Observable.from([1, 2, 3])

 

from은 각각의 값들은 받을 수 없고, 오직 배열만 받을 수 있다.

obaservable.subscribe { value in
            print(value)
        } onError: { error in
            print(error)
        } onCompleted: {
            print("onCompleted")
        } onDisposed: {
            print("onDisposed")
        }
        .disposed(by: disposeBag)
   
// <실행 결과>
// 1 
// 2
// 3
// onCompleted
// onDisposed

이렇게 파라미터로 보낸 배열의 요소들을 순서대로 하나씩 방출한다.

---

정리해보면,
Observable를 구독한 시점부터 파라미터로 전달한 항목들이 순서대로 방출되고, 이 과정이 끝나면 complete가 불리면서 dispose된다.

of는 Observable 배열을 만들고! from은 배열의 각 요소들을 Observable로 만든다.
타입으로 보면, of는 Observable<[Int]>,  from은 Observable<Int> 이다.

---

마지막으로
create는 파라미터로 Observer를 매개변수로 받는 클로저를 전달받는 Observable Sequence를 생성한다.
위에서 언급했던 onNext, onError, onCompleted를 직접 호출할 수 있다. (onError, onCompleted 1번만 호출 가능)

 let obaservable = Observable<Int>.create { observer in
            observer.onNext(1)
            observer.onNext(2)
            observer.onCompleted()
            observer.onNext(3)
            return Disposables.create()
        }

create는 just, of, from 과 다르게 이렇게 클로저를 이용해서
onNext를 통해 어떤 이벤트를 방출할지,
언제 onComplete, onError 이벤트를 방출할지를 직접 호출할 수 있다.
단, onComplete, onError가 호출되면, dispose가 되어 종료되기 때문에 이후에는 어떤 메서드도 호출되지 않는다.

obaservable.subscribe { value in
            print(value)
        } onError: { error in
            print(error)
        } onCompleted: {
            print("onCompleted")
        } onDisposed: {
            print("onDisposed")
        }
        .disposed(by: disposeBag)

// <실행 결과>
// 1
// 2
// onCompleted
// onDisposed

실행결과를 보면, onCompleted 다음에 호출된 3은 방출되지 않은 것을 확인할 수 있다.

 

subscribe(구독)을 한 후, dispose 하는 방법

Observer가 Observable을 subscribe를 통해서 이벤트를 받는다.

만약, 더이상 Observable에 대한 이벤트를 받고 싶지 않다면..?

이때 사용하는 것이 Disposable이다.

Disposable은 subscribe 중인 상황에서 원한는 시기에 dispose(처리)할 수 있도록 도움을 주는 역할을 한다.

.dispose() 메소드를 사용하면 된다. 

하지만,

클래스 메모리가 해제되는 시점(deinit)에 Disposable이 되는데, 클래스가 RootVC인 경우에는 메모리에서 Disposable이 되지 않는다.

이런 경우에는 직접 필요한 시점에 dispose를 호출해 주어야 하는데, 구독 객체가 많아질수록 관리하기 힘들어진다.

이러한 문제점들이 있기 때문에 DisposeBag을 사용한다.
(공식 문서에도 dispose() 직접호출 보다 DisposeBag을 사용하라고 써있음)

이보다 더 좋은 방법이 있다. 바로, DisposeBag을 사용하는 방법이다.
DisposeBag을 만들어서 Disposable을 담아두었다가 한 번에 호출하는 것이다.

let disposeBag = DisposeBag()

이렇게 disposeBag을 만들어 놓고, 해제가 필요한 시점에

.disposed(by: disposeBag)

이렇게 호출하면 된다. (이미 just, of ,from, create 예시에서 사용하고 있음)

이렇게 DisposeBag을 사용하게 되면, 필요한 시점에서 DisposeBag의 인스턴스 초기화 과정을 통해서 한 번에 정리할 수 있다.

---