RxSwift Observable 알아보기

RxSwift Observable

Observable이란?

• 일정 기간 동안 계속해서 비동기적 이벤트를 생성(emit)
• 비동기적(asynchronous)
• Observable = Observable Sequence = Sequence

Observable 생명주기

• Observable은 어떤 구성요소를 가지는 next 이벤트를 계속해서 방출할 수 있다.
• Observable은 error 이벤트를 방출하여 완전 종료될 수 있다.
• Observable은 completed 이벤트를 방출하여 완전 종료 될 수 있다.

 

• marble diagram : 시간의 흐름에 따라서 값을 표시하는 방식

• next 이벤트

• completed 이벤트

• error 이벤트

/// Represents a sequence event.
///
/// Sequence grammar:
/// **next\* (error | completed)**
public enum Event<Element> {
    /// Next element is produced.
    case next(Element)

    /// Sequence terminated with an error.
    case error(Swift.Error)

    /// Sequence completed successfully.
    case completed
}

• 위 예제에서 next 이벤트는 어떠한 Element 인스턴스를 가지고 있는걸 확인할 수 있습니다.
• error 이벤트는 Swift.Error 이벤트를 가지고 있습니다.
• completed 이벤트는 아무런 인스턴스를 가지고 있지 않고 단순히 이벤트를 종료시키는 이벤트 입니다.

Observable 실습

• just

Observable<Int>.just(1) // 하나의 Element만 방출하는 Observable 생성 Oparator입니다.
    .subscribe(onNext: {
        print($0)
    })
// Observable은 실제로는 Sequence 정의 일뿐 Subscribe(구독)되기 전에는 아무런 이벤트도 내보내지 않습니다.
// 확인을 할려면 반드시 subscribe를 해줘야 한다.

• of

print("-----Of1-----")
Observable<Int>.of(1, 2, 3, 4, 5) // 다양한 형태의 이벤트들을 넣을 수 있습니다.

print("-----Of2-----")
Observable.of([1, 2, 3, 4, 5]) // 타입추론을 통해서 Observable Sequence를 생성

• from

Observable.from([1, 2, 3, 4, 5]) 
// Array형태의 값만 받는다. 자동적으로 자기가 받은 Array속에 있는 Element들을 하나씩 꺼내서 방출하게 된다.

Subscribe

• Observable은 실제로는 Sequence 정의 일뿐 Subscribe(구독)되기 전에는 아무런 이벤트도 내보내지 않습니다. 확인을 할려면 반드시 subscribe를 해줘야 한다.

// Subscribe1
Observable.of(1, 2, 3)
    .subscribe {
        print($0)
    }
// .subscribe만 이용하면 어떤 이벤트에 어떠한 값이 씌워져서 나오고 completed 이벤트가 발생했는지 여부를 확인해줌

// Subscribe2
Observable.of(1, 2, 3)
    .subscribe {
        if let element = $0.element {
            print(element)
        }
    }

// Subscribe3
Observable.of(1, 2, 3)
    .subscribe(onNext: {
        print($0)
    })

empty

• 요소를 하나도 가지지 않은 어떤 카운트 0인 Observable을 만들때 혹은 즉시 종료하고 싶은 Observable을 만들고 싶을때 사용한다.

Observable.empty()
    .subscribe {
        print($0)
    }

never

• 작동은 하지만 아무것도 내보내지 않는 연산자입니다.
• 확인을 하고싶으면 .debug 연산자를 사용해야 합니다.

Observable.never()
    .debug("never") // 2022-05-20 02:13:39.901: never -> subscribed
    .subscribe(
        onNext: {
            print($0)
        },
        onCompleted: {
            print("완료")
        })

range

• start 값부터 count를 하나씩 늘려가면서 Observable Sequence를 생성한다.

// range
Observable.range(start: 1, count: 9)
    .subscribe(onNext: {
        print("3*\($0)=\(3*$0)")
    })

dispose

• 구독을 취소하여 Observable을 종료시킵니다. 

// dispose : 구독 취소
Observable.of(1, 2, 3)
    .subscribe {
        print($0)
    }
    .dispose()

disposeBag

• 방출된 리턴값을 disposeBag에 호출한다. Observable에 대해서 구독을 하고 있을 때 이것을 즉시 disposeBag에 추가한다. disposeBag은 이것을 가지고 있다가 자신이 할당 해제할때 모든 구독에 대해서 dispose를 날린다.

let disposeBag = DisposeBag()

Observable.of(1, 2, 3)
    .subscribe {
        print($0)
    }
    .disposed(by: disposeBag)

create

• Observable에서 직접 이벤트 방출

// create
Observable.create { observable -> Disposable in
    observable.onNext(1)
//    observable.on(.next(1)) // 같은 표현
    observable.onCompleted()
    observable.onNext(2) // onCompleted 이벤트 때문에 이벤트가 방출되지 않음
    return Disposables.create()
}
.subscribe {
    print($0)
}
.disposed(by: disposeBag)

// create2
enum MyError: Error {
    case anError
}

Observable<Int>.create { observable -> Disposable in
    observable.onNext(1)
    observable.onError(MyError.anError)
    observable.onCompleted()
    observable.onNext(2)
    return Disposables.create()
}
.subscribe(
    onNext: {
        print($0)
    },
    onError: {
        print($0.localizedDescription)
    },
    onCompleted: {
        print("완료")
    },
    onDisposed: {
        print("disposed")
    }
)
.disposed(by: disposeBag)

deffered

• subscribe를 기다리는 observable을 만드는 대신에 각 subscribe에 새롭게 observable을 제공하는 observable factory를 만드는 방식

// deffered
Observable.deferred {
    Observable.of(1, 2, 3)
}
.subscribe {
    print($0)
}
.disposed(by: disposeBag)

// deffered 2
var 뒤집기: Bool = false

let factory: Observable<String> = Observable.deferred {
    뒤집기 = !뒤집기
    
    if 뒤집기 {
        return Observable.of("👍")
    } else {
        return Observable.of("👎")
    }
}

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