[RxSwift] RxSwift 입문하기

시간이 갈수록 점점 RxSwift는 꼭 알아야 하는 트렌드죠~~?ㅎㅎ

Apple에서도 Rx+MVVM Base인 SwiftUI를 사용하기를 점점 지향하는 것 같고요 ㅎㅎ (개인적인 생각ㅋ)

업무를 하면서는 접해볼 기회가 없어서, 혼자 따로라도 한번 공부하면서 "적어도 개념정도는 알고 기본정도는 사용할 수 있어야겠다" 해서 시작해보려고 해요!! 😎

 

그만큼 왕초보를 위한 입문용 포스팅이 되겠지만, 핵심 개념이나 원리는 예제와 함께 상세히 다뤄볼 예정이라 조금은 긴 포스팅이 될 것 같습니다!! 😭

그치만! 이 포스팅을 천천히라도 완주하신다면 RxSwift에 대한 개념이나 기본적인 사용법은 익히실 수 있을거에요 🧑‍💻

 

---

RxSwift에 대해서 알아보기 시작하기 전에, 기본적인 Swift에 대한 내용은 알고 있다고 생각하고 써볼거에요.

먼저 한가지 샘플을 소개드리면서 시작해볼게요!

이렇게 상단에 타이머가 흘러가고, LoadJson 버튼을 통해 서버로부터 Json을 내려받고 있어요.

이때 다운받는 동안 타이머가 멈추지 않고, User Interaction에 반응하기위해, 서버로부터 Json을 내려받는 Task는 background에서 일어나고, UI와 관련된 Task는 메인스레드에서 실행하게끔 비동기적으로 설계하죠~?

func downloadJson(urlString: String, completion: @escaping (String) -> Void) {
        guard let url = URL(string: urlString) else { return }
        URLSession.shared.dataTask(with: url) { data, response, error in
            guard data != nil, error == nil else { return }
            
            guard let text = String(data: data!, encoding: .utf8) else { return }
            completion(text)
            
        }.resume()
    }

아마 대부분 이런식으로 다운로드가 완료되면 completion 클로저 혹은 Delegate, Notification 등을 통해 데이터를 전달하고, 전달받은 데이터로 UI 변경과 관련된 로직을 실행할거에요.

downloadJson(urlString: Constants.BASE_URL + Constants.API_KEY) { text in
            DispatchQueue.main.async {
                self.contentsTextView.text = text
                self.setVisibleWithAnimation(status: false)
            }
        }

 

 

이렇게 데이터 다운로드가 완료되었음을 인지하고 그 데이터를 completion같은 클로저를 통해 받은 뒤, 해당 데이터를 가지고 UI를 업데이트 하는 Task를 수행하는 과정을 통해서 UI를 업데이트 해야하죠.

이런 데이터를 요청하고, 전달받고, UI를 업데이트하는 일련의 과정을 따로 수행하지 않고, 만약 우리가 어떤 데이터를 "관찰" 하고 있는데 그 데이터가 "변경" 될때 알아서 UI를 업데이트 해주면 되지 않을까?

---

바로 이런 생각의 프로그래밍 패러다임이 Reactive Programming(반응형 프로그래밍) 이에요. 그리고 이걸 Swift에서 쉽게 구현할 수 있도록 지원해주는게 RxSwift에요. 즉 비동기로 생기는 결과값을 completion 클로저등을 통해 전달하는게 아니라, 어떤 데이터에 관심을 갖고 관찰(Observe)하게끔만 해놓으면 알아서 해준다는거죠! 

 

여기 저기를 찾아봐도, Rx의 정의에 대해서는 대부분 비슷할거에요.

"관찰 가능한 시퀀스를 사용하여 비동기식 및 이벤트 기반 프로그램을 구성하기 위한 라이브러리"

 

응~ 근데 굳이 RxSwift를 써야돼~? 그냥 Swift로도 didSet을 이용하거나 등등 활용하면 되지않아~?

맞습니다!!  RxSwift 라이브러리를 사용하지 않고도 충분히 Reactive하게끔 코드를 짤 수 있어요.

 

그런데 우리가 네트워크 통신을 위해 Alamofire같은 3rd-party 라이브러리를 사용하죠~? 왜사용해요~?

답은 당연히 "사용하기 편하니까" 죠! URLSession으로 네트워크 통신을 구현해도 네트워크 통신을 할 수 있어요. 그치만 누군가 Alamofire를 만들고, 네트워크 통신할때 쓰기 편하게 만들어 놓았기 때문에, 그걸 사용하는것 뿐이죠!

 

마찬가지로, 바로 Reactive eXtension Swift (RxSwift)가 Reactive 하게 Swift 코드를 작성하기 쉽게 도와주는 라이브러리에요.

간단하게 개념과 용도를 한번 살펴보았는데요! 그럼 이제 RxSwift에 대해 한번 알아볼까요~?🧑‍💻

 

github.com/ReactiveX/RxSwift

ReactiveX/RxSwift

 

먼저 RxSwift의 핵심 개념 3가지와, 각각의 사용법을 알아볼게요.

 

Observable

• 이벤트를 시간 흐름에 따라 전달하는 "전달자"
• 비동기로 동작하는 일련의 항목들을 나타내는 "시퀀스"
• Observable은 3가지 타입의 이벤트를 배출하고, Observer가 Observable을 "구독"하여 이벤트를 수신 합니다.
• next : next는 다음 데이터를 배출하는 이벤트, 그 데이터를 Observer가 수신 (Emission)
• completed : completed는 시퀀스를 성공적으로 종료하고 더이상 이벤트를 배출하지 않음 (Notification)
• error : error는 오류가 발생하여 시퀀스를 종료하고, 더이상 이벤트를 배출하지 않음 (Notification)

아까 위의 예시에서 어떤 데이터를 "관찰" 한다고 했죠~? 말 그대로 observable 은 "관찰가능한" 친구에요. 

위에서 들었던 예시를 똑같이 Observable을 사용해볼게요.

func downloadJson(urlString: String) -> Observable<String?> {
        // 비동기로 생기는 데이터를 Observable로 감싸서 리턴
        return Observable.create { emitter in
            let url = URL(string: urlString)
            let task = URLSession.shared.dataTask(with: url!) { data, response, error in
                guard error == nil else {
                    emitter.onError(error!)
                    return
                }
                guard data != nil else { return }
                guard let text = String(data: data!, encoding: .utf8) else { return }

                // 실제 데이터 전달
                emitter.onNext(text)
                // 완료 처리
                emitter.onCompleted()
            }
            task.resume()
            // 취소되었을때 어떻게 처리할건지 전달
            return Disposables.create() {
                task.cancel()
            }
        }
    }

이렇게 Observable한 어떤 객체를 리턴하게 됩니다. 단순히 Observable.create() 메소드로 하나의 Observable을 만들 수 있어요. 실제로 정의를 보면 어떤 Observable을 리턴하도록 되어있네요!

위의 코드를 보면, 방금 설명했던 3가지 이벤트가 모두 들어가 있는 것 보이시나요~? 

먼저 error가 발생했으면 onError 이벤트를 통해 에러 이벤트를 배출해요! 혹은 정상적으로 뭔가 처리되었다면, onNext 이벤트를 통해 처리된 결과 데이터를 배출하고, 이 후에는 onCompleted 이벤트로 Observable의 이벤트를 완료처리합니다.

 

그리고 정의를 보면 파라미터로 들어가는 클로저가 Disposable이라는 걸 리턴하게끔 되어있죠?

이게 바로 return Disposables.create() 에요. 이건 만약에 이 Observable이 취소되었을때 어떻게 동작할건지 전달하는거에요. 즉, 여기서는 만약 취소되면 데이터를 요청했던 Task를 취소하라고 해준 거에요!

 

이제 Observable(관찰 가능한) 대상을 만들어 줬으니, 이 데이터를 "관찰" 해야겠죠~? 그걸 RxSwift에서는 "구독"한다고 하고, subscribe한다고 해요.

downloadJson(urlString: Constants.BASE_URL + Constants.API_KEY)
            .debug()
            .subscribe { event in
                switch event {
                case .next(let text):
                    DispatchQueue.main.async {
                        self.contentsTextView.text = text
                        self.setVisibleWithAnimation(status: false)
                    }
                case .completed:
                    break
                case .error:
                    break
                }
            }

이렇게 위에서 만든 downloadJson Observable을 subscribe(구독) 해주는거에요.

그러면 위에서 옵저버블이 배출한 onNext, onCompleted, onError 이벤트를 여기서 수신하게 되요.

여기서, subscribe 클로저를 보면 self.~하고 클로저 내에서 자기참조를 하고 있죠!? 바로 순환참조가 발생할 수 있는 포인트에요. 사실 우리는 [weak self] 를 통해서 자기참조로 인한 순환참조를 막아주는데요~!

 

여기서는 저 subscribe 클로저가 complete 이후에 종료되면 클로저가 삭제되고, 클로저가 삭제되면 자기참조 하던 reference count도 같이 줄어들기 때문에, 따로 [weak self]를 사용하지 않아도 된다고 해요. (근데 저는 쓸듯.. 😂)

이 옵저버가 어떤 이벤트를 받았고, 어떤 데이터를 받았는지는 .debug() 메소드를 써주면 콘솔에서 볼 수 있어요.

 

아까 Observable.create()의 정의를 봤을때, 클로저는 disposable을 리턴하도록 되어있었죠?

let disposable = downloadJson(urlString: Constants.BASE_URL + Constants.API_KEY)
            .subscribe { event in
            ...
            }
        disposable.dispose()

이렇게도 쓸 수 있을거에요. dispose() 메소드를 통해 error, complete 이벤트 발생 전에도 구독을 취소할 수 있어요.

 

이 disposable에 대해 조금만 더 알아볼게요.

var disposables: [Disposable] = []

let disposable = downloadJson(urlString: Constants.BASE_URL + Constants.API_KEY)
            .subscribe {
            ...
            }
        disposables.append(disposable)

그럼 이렇게 전역적으로 사용할 수 있는 Disposable 배열을 만들고, 뭔가 다운로드가 진행중이지만 이 화면을 벗어날때는 다운로드를 멈추게 한다는 등의 액션을 할때는 아래처럼 구현할 수 있겠네요!

override func viewWillDisappear(_ animated: Bool) {
        super.viewWillDisappear(animated)
        disposables.forEach { $0.dispose() }
    }

근데 이건 약~간 귀찮죠??ㅎㅎ 그래서 RxSwift에서 제공해주는 DisposeBag 이라는 친구가 있어요.

말그대로 Disposable 들을 담고있는 가방이에요. 이런 친구들을 Sugar API또는 Operator라고 하는데, 아래에서 상세히 다룰게요!

이친구는 viewWillDisappear에서 따로 dispose해주지 않아도, 뷰컨트롤러의 지역변수로 선언해놓으면 이 화면이 없어질때 자동적으로 같이 없어져서 따로 dispose를 호추해주지 않아도 되요.

 var disposeBag = DisposeBag()

그리고 옵저버블이 생길때 append 대신 insert 메소드로 넣어줄 수 있어요.

disposeBag.insert(disposable)

응.. 근데 그럼 옵저버블을 만들때마다 disposeBag에다가 insert해줘야돼??

아.니.요.! 이렇게 disposed() 메소드를 통해 옵저버블을 생길때마다 그냥 어떤 disposeBag에서 관리할건지만 알려주면 되요!

let disposable = downloadJson(urlString: Constants.BASE_URL + Constants.API_KEY)
            .subscribe ({
            ...
            })
            .disposed(by: disposeBag)

 

 

그럼, Observable의 생명주기는 이렇게 표현할 수 있을 것 같아요.

1. Create
2. Subscribe
3. onNext
4. onCompleted / onError
5. Disposed

이렇게 먼저 첫번째 키워드인 Observable에 대해서 살펴보았는데요~! 어떤건지 좀 느낌이 오시나요~?

요악하면 딱 이거에요.

Observable(관찰대상)을 만들고, Observer는 그 관찰대상을 subscribe(구독) 합니다. Observable이 이벤트를 배출하면, Observer가 이벤트를 수신해서 어떤 액션을 수행합니다.

 

 

그런데.. 뭔가 굉장히 쉽게 쓸 수 있는 라이브러리처럼 소개해놓고, 사실은 똑같이 복잡하네? 라는 생각이 드실거에요.

삐빅- 정상입니다. 🧑‍💻

 

---

사실은 지금까지 Observable의 원리를 자세하게 설명하기 위해서 예시를 통해서 한번 알아본거고, 지금부터는 Observable을 조금 더 간단하게 사용할 수 있는 방법을 알아볼거에요!

 

예를 들어서 "Hello World"라는 문자열을 이벤트로 보내는 Observable이 있어요.

func something() -> Observable<String?> {
        return Observable.create { emitter in
            emitter.onNext("Hello World")
            emitter.onCompleted()
            return Disposables.create()
        }
    }

지금까지 대로라면.. 이 단순한 문자열을 하나 보내는데 이런 많은 과정이 필요하죠~~? 😂 그럼 굳이 왜써...

그래서~!! RxSwift에서 제공해주는 Operator(Sugar API) 의 개념이 등장합니다.

func something() -> Observable<String?> {
        return Observable.just("Hello World")
    }

just는 정말 단순하게 하나의 데이터를 배출할때 사용할 수 있는 Operator에요. 단, 하나만 배출할 수 있어요!

그럼 두개 이상은 어떻게 하냐~~?

func something() -> Observable<[String?]> {
        return Observable.just(["Hello World", "Hi World"])
    }

이렇게! just를 똑같이 사용하되 [ ] 배열로 이벤트를 보내버릴 수도 있어요 ㅋ.ㅋ 👍

그런데 이렇게 해버리면, 배열 전체를 한번에 받는 방법밖에는 없어요.

만약 배열 안의 데이터를 하나씩 받고 싶으면 어떻게 할까요~? 이럴때 from을 사용하는 방법이 있어요.

func something() -> Observable<String?> {
        return Observable.from(["Hello World", "Hi World"])
    }

이러면 배열 안의 데이터가 하나씩 이벤트로 데이터가 배출될 수 있습니다.

음~~ 근데 배열은 싫은데 여러 데이터를 이벤트로 보내려면 어떻게 하는데~~?

이때! of 를 사용하면 됩니다.

func something() -> Observable<String?> {
        return Observable.of("Hello World", "Hi World")
    }

 

요약

• 하나의 요소를 배출하는 옵저버블 생성시에는 just
• 둘 이상의 요소를 배출하는 옵저버블 생성시에는 of
• just와 of는 인자를 그대로 배출하기 때문에 배열을 전달하면 배열을 그대로 배출
• 배열에 저장된 요소를 순차적으로 배출하는 옵저버블 생성시에는 from

 

그럼 subscribe할때는 이런게 없을까요~? 물론 있습니다!!

func getSomething() {
        something()
            .subscribe(onNext: { print($0) },
                       onError: { err in print(err) },
                       onCompleted: { print("completed") } )
    }

이렇게 subscribe할때 파라미터로 onNext, onError, onCompleted, onDisposed를 사용할 수 있어요! 

모두 옵셔널로, 선택적으로 처리할 이벤트에 대해서만 구독하게끔 가능해요.

예를 들어서 onNext 이벤트만 받아서 뭔가를 처리하려면, 이렇게 한줄이면 충분하답니다 👍

func getSomething() {
        something()
            .subscribe(onNext: { print($0) })
    }

 

그럼 위에서 만들었던 예시도 Sugar API를 사용하면 이렇게 간단하게 변환할 수 있겠죠~?

@IBAction func loadTapped(_ sender: Any) {
        setVisibleWithAnimation(status: true)
        downloadJson(urlString: Constants.BASE_URL + Constants.API_KEY)
            .subscribe(onNext: { text in
                DispatchQueue.main.async {
                    self.contentsTextView.text = text
                    self.setVisibleWithAnimation(status: false)
                }
            })
    }

 

이 외에도 다양한 Operator(Sugar API)가 존재하고, 상세 내용은 여기서 확인할 수 있어요.

Operator 중에도 Observable을 만들어내는 생성 Operator, Observable 배출한 데이터를 가공하는 Operator, 해당 데이터를 subscribe(구독) 하는 Operator 등등 있어요. 이 Operator는 RxSwift의 핵심 개념 3가지중 하나에요! 😎 그럼 연산자에 대해서 한번 알아보도록 할게요!

 

 

Operator(연산자)

연산자의 종류는 목적에 따라 생성, 데이터 변형, 데이터 필터링, 데이터 병합, 에러핸들링, 유틸리티 등 분류로 나눠져요.

연산자는 대표적으로 observe(on:), Map, Filter, CombineLatest 등이 있어요!

observe(On:) observOn이 이름이 변경되었네요. 은 어떤 스케쥴러(스레드)에서 관찰할건지를 정할 수 있어요. 여기서 나온 Scheduler는 있다가 좀 더 자세하게 알아볼게요!

예를 들면 방금 위에서 봤던 코드에서 우리가 DispatchQueue.main.async 이렇게 메인스레드에서 동작하도록 해주던걸, 그냥 observe(on:) 메소드로 해결할 수 있어요.

@IBAction func loadTapped(_ sender: Any) {
        setVisibleWithAnimation(status: true)
        downloadJson(urlString: Constants.BASE_URL + Constants.API_KEY)
            .observe(on: MainScheduler.instance)
            .subscribe(onNext: { text in
                self.contentsTextView.text = text
                self.setVisibleWithAnimation(status: false)
            })
    }

 

map, filter는 우리가 알던 고차함수와 같은 역할을 해요. 이 2가지에 대한 자세한 설명은 패스할게요! 

혹시라도 잘 모르시면 이 포스팅을 한번 봐주세요~!

downloadJson(urlString: Constants.BASE_URL + Constants.API_KEY)
            .map { text in text?.count ?? 0 }
            .filter { cnt in cnt > 0 }
            .map { "\($0)"}
            .observe(on: MainScheduler.instance)
            .subscribe(onNext: { text in
                self.contentsTextView.text = text
                self.setVisibleWithAnimation(status: false)
            })

이런식으로 옵저버블이 배출한 데이터를 map, filter를 통해 가공하고 subscribe하게끔 할 수 있어요.

 

이번에는 병합 연산자중에 하나인 zip에 대해서 예를 들어볼까요?

병합은 말그대로 여러개의 옵저버블을 합치는거에요. Zip은 두 옵저버블의 요소들을 합쳐서 하나의 데이터로 병합한 옵저버블을 만드는데요~! 예를들면 이렇게 "Hello"라는 데이터와 우리가 서버에서 내려받았던 Json 데이터를 합쳐서 옵저버블을 생성하게 되요.

let jsonObservable = downloadJson(urlString: Constants.BASE_URL + Constants.API_KEY)
let helloObservable = Observable.just("Hello")
            
        Observable.zip(jsonObservable, helloObservable) { $1 + "\n" + $0  }
            .observe(on: MainScheduler.instance)
            .subscribe(onNext: { text in
                self.contentsTextView.text = text
                self.setVisibleWithAnimation(status: false)
            })

 

좀전에 위에서 잠깐 소개한 연산자 이 외에도 엄청 다양한 연산자들이 있고, 여기서 확인 가능하다고 했죠~?

종류는 많고, 뭐가 뭔지 모르겠더라구요!! 대신 그중에 하나를 한번 눌러보면, 뭔가 Input과 Output이 있는 다이어그램이 보일거에요. 이 다이어그램을 마블 다이어그램 이라고 불러요.

 

음.. 오케이. 근데 마블 다이어그램 이거 어떻게 보는건데?

간단한 예제를 통해서 조금씩 살펴볼게요!! 먼저 생성 Operator중 하나인 Just를 볼게요. 

빨간 텍스트로 어떤 모양이 뭘 의미하는지를 한번 적어봤어요!

즉, Just 연산자는 어떤 데이터를 넣고 Just 연산자를 적용시키면, 어떤 Observable(가로화살표)이 나오는데, "이 옵저버블은 Input에 넣었던 데이터와 동일한 데이터가 이벤트(next)에 포함되고 Completed 이벤트가 있다." 라고 해석하면 되겠네요!

 

아직 약간 헷갈리시죠~!? 방금 같이 살펴봤던 From 연산자를 볼까요?

어떤 배열에 데이터를 넣고 From 연산자를 적용시켰더니, 옵저버블이 나왔네요. 근데 이 옵저버블은 Input으로 넣었던 배열의 각 요소들을 데이터 이벤트(next)로 포함하고, Completed이벤트도 같이 있는 옵저버블이네요!!

이제 좀 이 마블 다이어그램을 어떻게 봐야 하는지 느낌 오시나요~~?

 

생성 연산자에 대한건 봤으니, 필터링 연산자에 대해서 한번 볼게요!

어떤 옵저버블을 filter 연산자에 넣었더니, 그 조건에 맞도록 필터링된 옵저버블이 나왔다. 라고 해석할 수 있겠죠?

여기서 생성과 필터링 연산자의 차이 중 하나는 Input의 형태가 그냥 데이터이거나, 옵저버블이거나! 이 차이가 있네요!! 👍

 

자, 이제 한가지만 더 이해하시면 마블다이어 그램을 다 이해할 수 있을거에요.

바로 observeOn 연산자에요! 이건 지금까지 한것들을 한번 종합적으로 볼게요!

음.. 일단 복잡하네요 😂 아닙니다!! 전혀 복잡하지 않아요. 천천히 해석해봅시다.

 

위에서 잠깐 observeOn은 어떤 쓰레드에서 처리할건지를 정한다고 했죠?

1. 처음엔 파란색 쓰레드에서 수행되는 동그라미 데이터 이벤트를 가진 옵저버블이 있네요!
2. 이 옵저버블이 observeOn(주황색) 연산자를 만나 주황색 쓰레드에서 동작하는 옵저버블이 됐어요.
3. 그리고 이 옵저버블은 map 연산자를 만나 네모 데이터로 변환이 되었어요!
4. 근데 subscribeOn(파랑) 은 뭘까요? 바로 최초에 어떤 쓰레드에서 시작할지를 정하는거에요. 이 subscribeOn(파랑)의 영향으로 제일 처음 시작되는 쓰레드가 파란색 쓰레드가 되는거에요.
5. 그리고 마지막으로 observeOn(분홍)을 만나, 결론적으로 분홍쓰레드에서 동작하는 네모데이터(next) 이벤트들과, completed 이벤트가 있는 옵저버블이 완성되었어요!

어렵지 않죠!? 모르고 보면 굉장히 복잡하게 느껴질 수 있는데, 알고 보면 간단해요! 🤟🤟🤟

이렇게 마블 다이어그램을 해석하는 방법까지 알아봤으니, 그럼 이제는 저 링크에 있던 다양~~~~한 연산자들을 눌러서 마블다이어그램만 보면 아~ 이게 어떤 연산자구나. 하고 이해할 수 있겠죠!?

 

 

Scheduler

핵심 키워드 3가지중 2가지 (Observable, Operator)를 알아봤고, 이제 마지막! Scheduler에 대해 알아보려고 해요!

위에서 observe(on:) 연산자를 소개하면서 어떤 "쓰레드"에서 동작하게 할건지 정한다고 했었어요. 기억나시나요?😁

 

우리는 RxSwift를 쓰지 않을때는 어떻게 멀티 쓰레드에서 동작하도록 했었죠~?

바로 GCD를 사용해서였죠! DispatchQueue, OperationQueue 이것들요!

GCD를 통해 어떤 "큐"에 작업을 할당하고, 그 "큐"가 어떤 "쓰레드" 에서 실제로 작업을 수행할지는 정해서 알아서 해줬죠?

마찬가지에요. GCD와 같은게 Scheduler라고 생각해도 될 것 같아요.

let jsonObservable = downloadJson(urlString: Constants.BASE_URL + Constants.API_KEY)
let helloObservable = Observable.just("Hello")
            
        Observable.zip(jsonObservable, helloObservable) { $1 + "\n" + $0  }
            .observe(on: MainScheduler.instance)
            .subscribe(onNext: { text in
                self.contentsTextView.text = text
                self.setVisibleWithAnimation(status: false)
            })
            .disposed(by: disposeBag)

여기서 .observe(on: MainScheduler.instance) 이렇게 메인스케쥴러, 백그라운드 스케쥴러, 커스텀 스케쥴러 중 용도에 맞게 스케쥴러에 등록하고, 스케쥴러는 알아서 쓰레드를 할당해서 작업을 해준다는거죠! 핵심 개념이지만 이해하기 쉽죠~~?

 

 

지금까지 긴 시간동안 RxSwift에 핵심 개념과, 기본 사용법에 대해서 알아보았는데요!

** 요악

Observable은 데이터를 배출하는 관찰가능한 시퀀스이다. Observer는 Observable을 구독(subscribe)하고, Observable이 이벤트를 배출하면 해당 Observable을 구독하는 Observer가 데이터를 수신한다. Observable을 생성하고, 구독하는 과정에서 사용의 편리성이나 기능확장을 위해 사용할 수 있는 다양한 Operator(연산자) 가 있었고, 데이터 수신 후 observeOn과 Scheduler를 통해 어떤 스케쥴러에서 작업을 수행할지 정할 수 있었다.

 

 

워우~~ 짧게 요약한다고 해봤는데 이제 이 문장이 이해가 가시나요!? 😂

솔직히 RxSwift에 대해서 공부하기 전에는 Observable, 시퀀스, 구독 등등 뭔말이야~ 싶었는데, 이제 보니 이해가 되죠?

저는 기회가 되면 RxSwift를 활용해서 최소 Toy Project나, 실제 업무에서도 스윽 하고 활용해보려고요!! 

 

---

 

그럼 RxSwift를 쓰면 장점은 뭐고, 단점은 뭘까요~?

이번 포스팅이 과하게 길어졌으니.. 다음 포스팅에서 장단점을 살펴볼게요!!

 

 

긴 글 읽어주셔서 감사합니다.

오늘도 누군가에게 도움이 되었길 바래요 🙏

 

 

참고자료 : 야곰님의 유투브를 참고하여 작성된 글입니다.