Thanks to @fimuxd 🖤

https://github.com/ReactiveX/RxSwift
https://github.com/fimuxd/RxSwift

RxSwift = 새로운 데이터에 반응하고 순차적으로 분리된 방식 처리. 비동기식 프로그램 개발을 간소화.

iOS에서 이미 제공된 비동기를 짤 수 있는 API
– Notification Center
– Delegate Pattern
– GCD
– Closure

Section I:
Getting Started with RxSwift

기초

3가지 구성요소 : Observables(생산자), Operators(연산자), Schedulers(스케쥴러)

1. Observables
Observable<T>
– T 타입의 데이터 shopshot을 전달할 수 있는 이벤트를 비동기적으로 생성하는 기능.
– 다른 클래스에서 만든 값을 시간에 따라 읽을 수 있다.
– 수신 가능 유형
– next : 최신, 다음 데이터를 전달하는 이벤트
– completed : 이벤트를 종료시키는 이벤트 (= 더이상의 이벤트 생성은 없다.)
– error : Observable 이 error를 발생시킴. 추가적인 이벤트 생성은 없다.

2. Operators
– 비동기 입력을 받아 부수작용 없이 return 생성

3. Schedulers
– Rx의 Dispatch Queue.



Architecture
– MVP, MVC, MVVM 모두 가능. MVVM이 가장 활용성 높음.


RxCocoa
– UI 컴포넌트에 rx 를 추가해서 사용.

Observable

– Observable = observable sequence = sequence
– Observable 들은 일정 기간동안 계속해서 이벤트를 생성하고, 이걸 emitting(방출) 이라고 한다.
– 이벤트들은 숫자나 인스턴스 등의 값을 가질 수 있고, 탭과 같은 제스처 인식도 가능.



생명주기
– Observable은 어떤 구성요소를 가지는 next 이벤트를 계속해서 방출 가능.
– Observable은 error 이벤트를 방출해서 완전 종료 가능.
– error는 Swift.Error
– Observable은 complete 이벤트를 방출해서 완전 종료 가능.
– instance 없이 바로 종료.



Observable(Observable Sequence) 정의

let one = 1
let two = 2
let three = 3

// just = 정의한 타입의 Observable Sequence 를 생성.
let observable: Observable<Int> = Observable<Int>.just(1)

// of = 타입 추론을 통해 Observable Sequence 생성.
let observable2 = Observable.of(one, two, three)
let observable3 = Observable.of([one, two, three])

// from = array의 각각의 요소를 하나씩 방출하는 Sequence.
let observable4 = Observable.from([one, two, three])

– just : 타입과 함께 정의
– of : 타입 추론
– from : Array의 각각의 값을 각각의 요소로 하는 Observable sequence가 됨.



Observable 구독(subscribing)
– Observable은 구독자이기 때문에 구독되기 전에는 아무런 이벤트도 보내지 않는다.

1. .subscribe()

let numbers: [Int] = [1, 2, 3]
let observable = Observable.from(numbers)

observable.subscribe { event in
    print(event)
    print(event.element ?? "")
}

// print
next(1)
1
next(2)
2
next(3)
3
completed

2. .subscribe(onNext:)

observable.subscribe(onNext: { num in
    print(num)
}, onError: { error in
    print(error)
}, onCompleted: {
    print("DONE !")
}) {
    //dispose
}

// print
1
2
3
DONE !

3. .empty()

let emptyValue = Observable<Void>.empty()

– 활용 예
– 즉시 종료할 수 있는 Observable 을 리턴하고 싶을 때.
– 의도적으로 0개의 값을 가지는 observable을 리턴하고 싶을 때


4. .never()

let emptyValue = Observable<Void>.never()

let disposeBag = DisposeBag()
let observable = Observable<Void>.never()

observable
    .do(onSubscribe: {
        print("Subscribed !")
    })
    .subscribe(onNext: { element in
        print(element)
    }, onCompleted: {
        print("COMPLETED!")
    })
    .disposed(by: disposeBag)

// print결과
Subscribed !

– do


5. .range()

let observable = Observable<Int>.range(start: 0, count: 5)

Disposing과 종료
– subscrption = observable 이 이벤트를 방출하는 방아쇠
– unsubscription = observable 을 수동적으로 종료 = Dispose
– dispose 하지 않으면 메모리 누수 …………… 😡

1. .dispose()

let subscription = observable.subscribe { event in
    print(event)
}

subscription.dispose()

2. DisposeBag()
– 각각의 subscription을 관리하는건 상당히 비효율적.

let disposeBag = DisposeBag()
subscription.disposed(by: disposeBag)

– disposable은 Dispose bag이 할당 해제하려고 할 때마다 dispose() 를 호출.


3. .create(:)

Observable<Int>.create { observer -> Disposable in
    observer.onNext(1)
    observer.onNext(2)

    return Disposables.create()
}.subscribe(onNext: { num in
    print(1)
}) {
    print("Disposed")
}.disposed(by: disposeBag)

– error, complete 없이도 observable sequence에 더이상 없으면 종료가되고 dispose 된다.





Observable Factory 만들기
– Observable Factory : 각 subscriber에게 새롭게 Observable 항목을 제공하는 것. (공용적인 개념 아님.)
– .deferred : Observable을 리턴하는 메소드. subscribe 될 때 실행된다.

let disposeBag = DisposeBag()
var isTrue = true

let factory: Observable<Int> = Observable.deferred {
    isTrue.toggle()

    if isTrue {
        return Observable.of(1, 2, 3)
    } else {
        return Observable.of(4, 5, 6)
    }
}

for _ in 0...3 {
    factory
        .subscribe { print($0) }
        .disposed(by: disposeBag)
}

Traits 사용
– 좁은 범위의 Observable. (?????????????????)

1. Single

let observable = Observable<Int>.just(0)
observable.asSingle()

let subject = PublishSubject<Int>()
subject.asSingle()

– 두 가지 이벤트 방출 : .success(value), .error
– .success(value) = .next + .completed
– 사용 예 : 성공, 실패로 확인될 수 있는 1회성 프로세스(데이터 다운로드 등)

2. Completable

let completable = Completable.create(subscribe: (@escaping Completable.CompletableObserver) -> Disposable)

– 두 가지 이벤트 방출 : .completed, .error
– observable을 completable로 변경은 불가능.
– 사용 예 : 연산이 제대로 완료되었는지만 확인할 때.

3. Maybe

let observable = Observable<Int>.just(0)
observable.asMaybe()

let subject = PublishSubject<Int>()
subject.asMaybe()

– 1. Single + 2. Completable
– .success(value), .completed, .error. 3가지 모두 방출 가능.
– .complete 되더라도 아무 값을 방출하지 않는다.



Debug

let disposeBag = DisposeBag()
let observable = Observable<Void>.never()

observable
    .debug("DEBUG")
    .subscribe()
    .disposed(by: disposeBag)

// 실행 결과
2020-05-28 17:00:40.348: DEBUG -> subscribed
2020-05-28 17:00:40.350: DEBUG -> isDisposed

Subjects

실시간으로 Observable에 새로운 값을 추가하고 subscriber에게 방출하는 것.
Observable이자 Observal.
Subject = Observable + Observer

– subject는 .next 이벤트를 받고, 이벤트를 받을 때마다 subscriber에게 방출한다.
– subscriber가 존재하지 않는 이상, subject에 새로운 값을 추가해도 실행되지 않는다.



Subject 의 종류 (4가지)
– PublishSubject : 빈 상태로 시작하여 새로운 값만을 subscriber에게 방출.
– BehaviorSubject : 하나의 초기값을 가진 상태로 시작. 새로운 subscriber에게 초기값 또는 최신값을 방출
– ReplaySubject : 버퍼를 두고 초기화. 버퍼 사이즈 만큼의 값들을 유지하면서 새로운 subscriber 에게 방출
– Variable : BehaviorSubject 를 래핑하고 현재의 값의 상태로 보존. 가장 최신/초기 값만을 새로운 subscriber 에게 방출 → BehaviorRelay

PublishSubjects
– 구독하는 순간, 새로운 이벤트 수신을 알리고 싶을 때 용이.
– .complete, .error 를 통해 Subject가 완전 종료될 때까지 지속.
– 활용 예 : 시간에 민감한 데이터를 모델링할 때.


BehaviorSubjects

– 새로운 subscriber 등록 전, 마지막 .next 이벤트를 새로운 subscriber 에게 반복시킴.
– 그래서 하나의 초기값이 필요.
– 이걸 제외하면 PublishSubject 와 유사.
– 활용 예 : 화면을 새로 Refresh시킬 때 사용하면 유용
(이전의 가장 최신 데이터를 표시시킨 후, 새로운 값이 오면 바로 표시시킬 수 있다.)




ReplaySubject

let disposeBag = DisposeBag()

let subject = ReplaySubject<String>.create(bufferSize: 2)
subject.onNext("1")
subject.onNext("2")
subject.onNext("3")

subject
    .subscribe { print("1: ($0)") }
    .disposed(by: disposeBag)

// print 결과
1: next(2)
1: next(3)

– bufferSize 개의 이벤트를 저장했다가 subscribe 되면 저장된 이벤트를 모두 방출.



Variable(Deprecated)
– BehaviorSubject 의 현재값은 value 프로퍼티를 통해서 알 수 있다.
– .complete, .error 는 사용할 수 없다. value 의 변화의 생겼을 때의 .next뿐.
– 메모리 할당이 해제되었을 때 자동적으로 .completed
– 활용 예 : 유저 상태를 나타내야 할 때. (로그아웃 당했을 때의 처리 등)
– BehaviorRelay로 사용.



Replay (RxCocoa)
– PublishRelay, BehaviorRelay 의 두 종류가 존재.
– 차이점 : BehaviorRelay 에서는 현재값을 알 수 있는 .value가 존재.
– 공통점 : .onNext가 없어지고, .accept 가 같은 역할.

– BehaviorRelay
– .value통해서 현재의 값을 가져올 수 있다. get-property
– .value를 변경하기 위해서는 .accept
– Variable의 역할을 수행.

let relay = BehaviorRelay<String>(value: "1")

relay
    .asObservable()
    .subscribe { print("1: ($0)") }
    .disposed(by: disposeBag)

relay.accept("2")

relay
    .asObservable()
    .subscribe { print("2: ($0)") }
    .disposed(by: disposeBag)

relay.accept("3")

Subject vs Relay
– subject는 .complete, .error 가 발생되면 종료되지만 Relay 는 Dispose되기 전까지 계속 작동한다.
– .complete 나 .error 가 발생하면 안되는 경우. 계속해서 sequence가 생성되어야 할 때 사용.
– UIEvent에서는 Relay가 적절.

Practice : Observables & Subjects

CODE
https://gist.github.com/unnnyong/9cf91f1849b5ab9d7facd4757359ec4f