RxSwift) 4.Observable
내용
- Observable 을 생성하고 구독하는 몇가지 예를 살펴봅시다.
RxSwift: Reactive Programming with Swift, Chapter 1: Hello, RxSwift!
RxSwift/GettingStarted.md at main · ReactiveX/RxSwift
위의 글을 번역 및 요약한 글입니다.
What is an observable?
Observable 은 Rx 의 핵심입니다. observable 이 무엇인지 어덯게 생성하고, 어떻게 사용하는지 알아보겠습니다.
Rx 에서 언급되는 “observable”, “observable sequence”, “sequence”, “stream” 는 서로 같은 의미입니다.
Observable 은 일정 기간 동안 이벤트를 생성하며 이를 방출이라고 합니다. 이벤트는 숫자나 사용자 정의 유형의 인스턴스와 같은 값을 포함하거나 탭과 같은 제스처를 포함할 수 있습니다.
이것을 개념화하는 가장 좋은 방법 중 하나는 아래와 같은 타임라인에 값이 표시되는 marble diagrams 를 사용하는 것입니다.
왼쪽에서 오른족 화살표는 시간을 나타내고 번호가 매겨진 원은 sequence 의 elements 를 의미합니다.
sequence 는 0개 이상의 element 를 가질 수 있습니다. error 와 completed 이벤트가 수신되면 시퀀스는 다른 요소를 생성할 수 없습니다.
Event
next
observable 이 observer 에게 elements 를 포함하는 next event 를 방출합니다.
completed
observable 을 구독한 observer 에게 완료되었음을 알립니다. 이를 completed event 라고 합니다. 오른쪽 끝에 선이 있는 것은 tap 이벤트 3개를 방출한 후 종료되는 것음 의미합니다.
error
observer 에게 오류가 포함된 error event 를 방출하여 알립니다. 에러 이벤트는 x 로 표시합니다.
Observable 이 종료되면 더 이상 이벤트를 생성할 수 없습니다.
RxSwift 에서 Event 는 enumeration cases 로 다음과 같이 구현되어 있습니다.
enum Event<Element> {
case next(Element) // next element of a sequence
case error(Swift.Error) // sequence failed with error
case completed // sequence terminated successfully
}
Creating observables
1) just
let one = 1
let two = 2
let three = 3
let observable = Observable<Int>.just(one)
just operator 는 하나의 element 만 포함하는 sequence 를 생성합니다. Observable 의 static method 입니다.
2) of
let observable2 = Observable.of(one, two, three)
이번에는 타입을 명시적으로 선언하지 않았습니다. 여러가지 정수를 제공하기 떄문에 Observable<Int> 라고 생각할 수 있습니다.
observable2 의 추론된 유형을 보게되면 배열이 아닌 Int 의 Observable 임을 알 수 있습니다.
of operator 는 가변 파라미터가 있고, Swift 는 이를 기반으로 observable 의 타입을 유추할 수 있습니다.
가변 변수. elements: Int…
observable 배열을 원할 경우 of 를 사용해서 전달할 수 있습니다.
let observable3 = Observable.of([one, two, three])
observable3 는 [Int] 의 Observable 입니다. just 연산자도 배열을 단일 element 로 사용할 수도 있습니다. 단순하게 생각해서 배열 자체가 단일 요소이지 안의 내용이 요소가 아닙니다.
3) from
let observable4 = Observable.from([one, two, three])
from operator 는 배열에서 개별적으로 관찰 가능한 elements 를 만듭니다. observable4 는 [Int] 가 아닌 Int 의 Observable 임을 알 수 있습니다. from 연산자는 배열만 사용합니다.
Subscribing to observables
RxSwift 에서 subscribe 은 observers 에게 broadcoasts 하는 NotificationCenter 와 매우 유사합니다. addObserver() 대신에 subscribe() 를 사용하게 됩니다. 더 중요한 차이는 **Observable 은 subscriber 가 있을때까지 events 를 보내거나 작업을 수행하지 않는 다는 것입니다.**
observable 은 next, error, completed 이벤트를 방출한다는 것을 앞에서 알아보았습니다. next 이벤트는 핸들러에 방출되는 element 를 전달하고 error 이벤트는 error instance 가 포함됩니다.
let one = 1
let two = 2
let three = 3
let observable = Observable.of(one, two, three)
// 🔥 다음과 같이 observable 을 구독할 수 있습니다.
// observable 에서 방출하는 각 event 를 출력합니다.
observable.subscribe { event in
print(event)
}
/*
next(1)
next(2)
next(3)
completed
*/
subscribe operator 를 살펴보면 Int 타입의 event 를 수신하고 아무것도 반환하지 않는 클로저 매개변수를 사용하고 Disposable 을 반환하는 것을 볼 수 있습니다.
결과에 대해서 살펴보겠습니다.
/*
next(1)
next(2)
next(3)
completed
*/
observable 은 각 요소들에 대해서 next 이벤트를 방출한 뒤 completed 이벤트를 방출하고 종료됩니다.
elements 에 직접 액세스하는 코드를 살펴 보겠습니다.
observable.subscribe { event in
if let element = event.element {
print(element)
}
}
/*
1
2
3
*/
Event 에는 element 프로퍼티가 없습니다. next 이벤트에만 element 가 있기 때문에 optional 값입니다. 따라서 옵셔널 바인딩을 상요하여 래핑을 해제합니다.
이것은 좋은 패턴이고, 자주 사용하기 때문에 RxSwift 에서 shortcut 이 있습니다. observable 이 방출하는 각 타입의 이벤트마다 subscribe 연산자가 있습니다.
위의 코드를 변경해보겠습니다.
observable.subscribe(onNext: { element in
print(element)
})
이제 여러분들은 next 이벤트의 elements 만 핸들링하고 다른 것들은(옵셔널 바인딩과 같은 과정) 무시할 수 있습니다. onNext 클로저는 next 이벤트의 elements 를 인수로 받기 때문에 event 에서 수동으로 추출할 필요가 없습니다.
1) empty
한 개와 여러 element 의 observable 을 만드는 방법을 알아보았습니다. 그렇다면 요소가 없는 observable 은 어떨까요?
비어있는 observable 시퀀스는 empty 연산자로 생성할 수 있고 오직 completed 이벤트만 방출합니다.
let observable = Observable<Void>.empty()
empty 는 타입을 유추할 수 있는 것이 없기 때문에 위의 코드처럼 명시적으로 정의해야 합니다.
observable.subscribe(
// 1
onNext: { element in
print(element)
},
// 2
onCompleted: {
print("Completed")
}
)
// Completed
아무것도 없으니 element 가 출력되지 않고 completed 이벤트만 발생하게 됩니다.
그렇다면 빈 observable 의 용도가 무엇일까요? 즉시 종료되거나 의도적으로 값이 0인 observable 을 반환하려는 경우 사용됩니다.
2) never
empty 연산자와는 반대로 never 연산자는 아무것도 방출하지 않고 절대 종료되지 않는 observable 을 생성합니다. 무한으로 지속되는 시간을 나타낼 수 있습니다.
let observable = Observable<Void>.never()
observable.subscribe(
onNext: { element in
print(element)
},
onCompleted: {
print("Completed")
}
)
//
아무것도 출력되지 않습니다. Completed 도 출력되지 않습니다.
3) range
지금까지 특정 elements 또는 values 의 observables 으로 작업했습니다. 하지만, range of values 로 부터 observable 을 생성하는 것이 가능합니다.
// 🔥 시작 정수 값과 연속 개수를 사용하는 range 연산자를 사용하여 Observable 생성.
let observable = Observable<Int>.range(start: 1, count: 10)
// 🔥 방출된 element 에 대해 n 번째 피보나치 수를 계산하고 출력.
observable
.subscribe(onNext: { i in
// 2
let n = Double(i)
let fibonacci = Int(
((pow(1.61803, n) - pow(0.61803, n)) /
2.23606).rounded()
)
print(fibonacci)
})
Disposing and terminating
observable 의 작업을 트리거하는 subscription 은 error 또는 completed 이벤트가 observable 을 종료할 때까지 새 이벤트를 방출합니다. 그러나 subscription 을 취소하여 observable 을 수동으로 종료할 수 있습니다.
명시적으로 구독을 취소하기 위해서 dispose() 를 호출합니다. 구독이 취소되거나 dispose 된 후 observable 은 이벤트 방출을 중단합니다.
let observable = Observable.of("A", "B", "C")
let subscription = observable.subscribe { event in
print(event)
}
// 🔥 종료
subscription.dispose()
각 subscription 을 개별적으로 관리하는 것은 지루할 수 있으므로 RxSwift 는 DisposeBag 타입이 있습니다. dispose bag 은 일반적으로 disposed(by:) 메서드를 사용하여 disposables 를 담고 있습니다. 그래서 dispose bag 이 할당 해제되려고 할 때 각각에 대해 dispose() 를 호출합니다.
let disposeBag = DisposeBag()
Observable.of("A", "B", "C").subscribe {
print($0)
}
.disposed(by: disposeBag)
// 🔥 dispose bag 에 담긴 disposables 각각에 대해 dispose() 메서드를 호출.
이러한 observable 을 생성하고 구독하고 즉시 dispose bag 에 넣는 패턴을 자주 사용하게 될 것입니다.
그렇다면 왜 disposables 을 신경쓸까요?
dispose bag 에 추가하는 것을 잊었거나 subcription 이 끝났을 때 수동으로 dispose 를 호출하거나 다른 방식으로 observable 이 어떤 시점에 종료되도록 하면 메모리 누수가 발생할 수 있습니다.
(RxSwift 깃허브에서 발췌)
시퀀스가 유한한 시간에 종료되면 dispose 를 호출하지 않거나 diposed(by: disposeBag) 를 사용하지 않아도 영구적인 resource leaks 가 발생하지 않습니다. 하지만, 이러한 리소스는 elements 의 생산을 complete 하거나 error 를 반환하여 시퀀스가 완료될 때까지 사용됩니다. (즉, completed 와 error event 가 발생하기 전까지는 사용됩니다.)
일련의 버튼 탭과 같은 시퀀스가 자체적으로 종료되지 않으면 dipose 가 수동으로, disposeBag 내부에서 자동으로 , takeUntil operator 를 사용하여 또는 다른 방법으로 호출되지 않는 한 영구적으로 할당됩니다.
그래서 시퀀스가 유한한 시간에 종료되는 경우에도 사용하는 것이 좋습니다.
잊어버리더라도 걱정마세요! Swift 컴파일러가 사용되지 않는 disposables 에 대해 경고해줄 것입니다.
create
이전 예시에서는 특정 next 이벤트 elelments 를 가진 observables 을 만들었습니다. **create 연산자를 사용하는 것은 subscribers 에게 방출할 모든 이벤트를 지정하는 또다른 방법입니다.**
let disposeBag = DisposeBag()
Observable<String>.create { observer in
// ...
}
subscribe 매개변수는 AnyObserver 를 사용하고 Disposable 을 반환하는 탈출 클로저입니다. AnyObserver 는 observable sequence 에 값을 추가하는 것을 용이하게하는 제네릭 타입입니다.
이를 통해 observer 에게 이벤트를 클로저안에서 방출해줄 수 있습니다.
create 의 구현부를 변경해보겠습니다.
Observable<String>.create { observer in
observer.onNext("1")
observer.onCompleted()
observer.onNext("?")
// 🔥 observable 이 종료되거나 disposed 될 때 어떤 일이 발생하는지 정의하는 disposble 을 반환합니다.
// 🔥 이 경우 별도의 정리가 필요하지 않으므로 empty disposble 리턴.
return Disposables.create()
}
두 번째 onNext 의 element ? 가 subscribers 에게 방출될 수 있을까요? 아래의 코드를 뒤에 추가해서 확인해봅시다.
.subscribe(
onNext: { print($0) },
onError: { print($0) },
onCompleted: { print("Completed") },
onDisposed: { print("Disposed") }
)
.disposed(by: disposeBag)
/*
1
Completed
Disposed
*/
결과는 첫 번째 next 이벤트 요소와 Completed 그리고 Disposed 가 출력됩니다. 두 번째 next 이벤트는 observable 이 completed 이벤트를 방출하고 종료되기 전에 추가되지 않았기 때문에 출력되지 않습니다.
observer 에게 error 를 추가하면 어떻게 될까요?
// 🔥 error 추가
enum MyError: Error {
case anError
}
let disposeBag = DisposeBag()
Observable<String>.create { observer in
observer.onNext("1")
observer.onCompleted()
// 🔥 error 추가
observer.onError(MyError.anError)
observer.onNext("?")
return Disposables.create()
}
.subscribe(
onNext: { print($0) },
onError: { print($0) },
onCompleted: { print("Completed") },
onDisposed: { print("Disposed") }
)
.disposed(by: disposeBag)
/*
1
anError
Disposed
*/
이제 observable 이 종료되기 전에 error 를 방출합니다.
그렇다면 completed 또는 error 이벤트를 추가하지 않고 disposeBag 에 구독을 추가하지 않으면 어떻게 될까요? 주석처리를 해서 알아봅시다.
enum MyError: Error {
case anError
}
let disposeBag = DisposeBag()
Observable<String>.create { observer in
observer.onNext("1")
// observer.onError(MyError.anError)
// 1 끝나지 않음.
// observer.onCompleted()
observer.onNext("?")
return Disposables.create()
}
.subscribe(
onNext: { print($0) },
onError: { print($0) },
onCompleted: { print("Completed") },
onDisposed: { print("Disposed") }
)
// 2 폐기되지 않음.
// .disposed(by: disposeBag)
/*
1
?
*/
onNext 이벤트인 ? 가 출력되었습니다.
메모리 누수(memory leak)가 발생하였습니다! observable 은 절대 끝나지 않을 것이고, disposable 은 절대 폐기되지 않을 것입니다.
Creating observable factories
subscribers 를 기다리는 observable 을 만드는 대신 각 subscriber 에게 새로운 observable 을 제공하는 observable factories 를 만드는 것이 가능합니다.
deferred
lazy var 변수와 같이 observable 이 subscribe 하는 순간 실행됩니다.
let disposeBag = DisposeBag()
var flip = false
let factory: Observable<Int> = Observable.deferred {
// 🔥 factory 가 구독될 때마다 toggle.
flip.toggle()
// 🔥 flip 참, 거짓에 따라 다른 observable 를 반환합니다.
if flip {
return Observable.of(1, 2, 3)
} else {
return Observable.of(4, 5, 6)
}
}
외부적으로 observble factory 와 일반 observable 을 구별할 수 없습니다. 다음의 코드를 하단에 추가하여 factory 를 4번 구독해봅시다.
for _ in 0...3 {
// 🔥 4번을 구독.
factory.subscribe(onNext: {
// 한 줄 출력.
print($0, terminator: "")
})
.disposed(by: disposeBag)
// 줄 바꿈.
print()
}
/*
123
456
123
456
*/
Using Traits
traits 은 일반 observables 보다 좁은 범위의 observables 입니다. 사용은 선택적입니다. 목적은 코드를 읽는 API 를 소비하는 사람들에게 명확하게 전달할 수 있는 방법을 제공하는 것입니다. trait 를 사용하여 암시하는 context 는 코드를 보다 직관적으로 만드는데 도움이 될 수 있습니다.
Single, Maybe 와 Completable 세 가지가 있습니다.
1) Single
Single 은 success(value) 또는 error(error) 이벤트를 방출합니다. success(value) 는 실제로 next 와 completed 이벤트의 조합입니다.
이는 데이터를 다운로드하거나 디스크에서 로등할 때와 같이 성공하여 값을 생성하거나 실패하는 일회성 프로세스에 유용합니다.
2) Completable
Completable 은 completed 또는 error(error) 이벤트만 방출합니다. 값은 방출하지 않습니다. 파일 쓰기와 같이 작업이 성공적으로 완료되었는지 실패했는지 관심이 있는 경우 사용할 수 있습니다.
3) Maybe
Maybe 는 Single 과 Completable 의 매쉬업입니다. success(value), completed 또는 error(error) 방출할 수 있습니다. 만약 성공하거나 실패할 수 있는 작업을 구현하고 선택적으로 성공시 값을 반환해야하는 경우에 사용할 수 있습니다.
let disposeBag = DisposeBag()
// 🔥 디스크에서 데이터를 읽을 때 발생할 수 있는 오류들을 모델링.
enum FileReadError: Error {
case fileNotFound, unreadable, encodingFailed
}
// 🔥 Single 을 반환하는 디스크에서 텍스트를 로드하는 함수 구현.
func loadText(from name: String) -> Single<String> {
return Single.create { single in
let disposable = Disposables.create()
// 🔥 경로 혹은 파일을 찾을 수 없는 경우 error를 Single에 추가하고 disposable 반환.
guard let path = Bundle.main.path(forResource: name, ofType: "txt") else {
single(.error(FileReadError.fileNotFound))
return disposable
}
// 🔥 경로의 파일에서 데이터를 가져오거나 읽을 수 없는 error를 Single에 추가하고 disposable 반환.
guard let data = FileManager.default.contents(atPath: path) else {
single(.error(FileReadError.unreadable))
return disposable
}
// 🔥 데이터를 문자열로 변환하고, 인코딩 실패 error를 Single에 추가하고 diposable 반환.
guard let contents = String(data: data, encoding: .utf8) else {
single(.error(FileReadError.encodingFailed))
return disposable
}
// 🔥 여기까지 다다랐다면 Single에 contents를 성공적으로 추가하고 disposable 반환.
single(.success(contents))
return disposable
}
}
이제 아래의 코드를 붙여서 작동하게 할 수 있습니다.
loadText(from: "Copyright")
// 2 Single 구독.
.subscribe {
// 3
switch $0 {
case .success(let string):
print(string)
case .error(let error):
print(error)
}
}
.disposed(by: disposeBag)
디스크의 파일 텍스트가 출력되게 된다. 파일 이름을 다른 것으로 변경하게 되면 파일을 찾을 수 없다는 에러가 대신 출력되게 됩니다.
do & debug
do
observable 의 방출된 이벤트에 영향을 미치지 않는 부수작업을 수행하려는 경우에 유용한 다른 연산자가 있습니다.
**do 연산자를 사용하면 side effects 를 삽입할 수 있습니다. 즉, 방출된 이벤트를 어떤식으로든 변경하지 않는 작업을 수행하는 핸들러입니다.** 대신 do 는 이벤트를 next 연산자의 체인으로 전달합니다. subscribe 과 달리 do 는 onSubscribe 핸들러도 포함합니다.(onSubscribe 핸들러는 구독하기 전에 호출할 액션입니다.)
기존의 never 예제 코드에 사용해보겠습니다. never 는 subscribe() 가 실행되지만 completed 이벤트를 방출하지 않아서 동작을 했는지 조차 모르는데 do 를 사용하면 알 수 있습니다.
let observable = Observable<Any>.never()
let disposeBag = DisposeBag()
observable.do(
onSubscribe: { print("Subscribe")}
).subscribe(
onNext: { (element) in
print(element)
},
onCompleted: {
print("Completed")
})
.disposed(by: disposeBag)
/*
Subscribe
*/
debug
side effects 를 수행하는 것은 Rx 코드를 디버그하는 한 가지 방법입니다. 하지만 더 나은 기능이 있습니다. debug 연산자는 observable 에 대한 모든 정보를 출력합니다.
몇 가지 옵셔널 매개변수가 있지만 가장 유용한 것은 출력되는 식별자 문자열을 포함하는 것입니다. 여러 위치에 debug 호출을 추가할 수 있는 Rx 체인에서 이는 각 출력물의 소스를 구별하는데 실제로 도움이 될 수 있습니다.
- 콘솔창 출력 형식:
날짜 시간: \(작성한문자열) -> <subscribed/isDisposed>
let observable = Observable<Any>.never()
let disposeBag = DisposeBag()
observable.debug("debug")
.subscribe()
.disposed(by: disposeBag)
/*
2022-07-11 01:43:01.445: debug -> subscribed
2022-07-11 01:43:01.449: debug -> isDisposed
*/