[RxSwift] Traits 와 side effect & Subject 기본

Traits

traits은 기존 Observable 보다 좀더 작은 범위의 기능을 수행하는 Observable 이다 필수로 알아야 하는 개념은 아니다

하지만 내가 작성한 코드를 다른 사람이 볼때 좀더 명확하게 볼 수 있다. 꼭 필요한 것은 아니란 말씀

Single : .success(value) == .next혹은 .error == .completed 이벤트를 방출한다 데이터를 다운로드 하거나 디스크로 부터 로딩이 걸릴 때 사용되나 보다

Completable .completed 혹은 .error 이벤트를 반환. 어떠한 값도 방출하지 않는다. 만약에 오직 성공과 실패로 끝나는 오퍼레이터가 필요한 경우 사용될 수 있다. 예를 들면 파일을 읽고 그것이 성공했는지 안했는지 방출할 수 있다.

Maybe single과 completable 을 모두 방출할 수 있다. succeed와 fail도 가능하고 값과 함께 success도 가능하다. 

 

오직 읽기 위한 옵저버블 시퀀스 프로퍼티를 struct로 워레핑 해서 심플하게 사용할 수 있다

옵셔널인 이유가 꼭 Traits를 사용하지 않더라도 다른 operator을 사용할 수 있기 때문인데 왜 Traits를 사용해야 하느냐?

 

쉽게 시퀀스를 전달하고 확인 할 수 있으며 각각 특별화된 특징과 구체적인 부분이 있어서 구현하고자 하는 기능을 잘 표현할 수 있으며 개발자의 의도를 다른 개발자와 쉽게 공유 가능하다는 것이다(언제나 느끼는 것이지만 같이 Rx에 대한 이해가 충분할 때 다른 개발자와의 소통이 원활하다고 생각한다 나는 Rx인데 다른 팀원이 Rx 코드를 본다? 그건 소통이 안되는 것임. 코드가 아무리 좋아도 의사소통도 중요하다)

 

Single

success와 error 두개의 이벤트를 방출하고 success일 때는 하나의 element를 방출하는 traits 이다

네트워크 통신을 통해 데이터를 가지고 오거나 경로를 통해 데이터를 읽어 들일 때 사용할 수 있다 성공하면 데이터를(single element)를 실패하면 .error(NotFound)를 방출하면 된다

기억할 것은 success 일때 하나의 element 아니면 error을 방출하면 된다고 생각하면 된다

그런데 error 에서 빨간 줄 그이는데 한번 살펴보면

 

결국 SingleEvent는 Result로 되어 있는데 .success와 .failure라 .error 쓰면 빌드가 안되었던 것.

import UIKit
import RxSwift

public enum NetworkError: Error {
    case networkingFailed
}

class TraitsViewController: UIViewController {
    
    var isDataDownloaded = true

    override func viewDidLoad() {
        super.viewDidLoad()

        let disposeBag = DisposeBag()
        
        loadText(from: "test")
            .subscribe { element in
                print(element)
            } onFailure: { error in
                print(error)
            } onDisposed: {
                print("dispossed")
            }.disposed(by: disposeBag)

    }
    
    func loadText(from name: String) -> Single<String> {
        return Single.create { single in
            
            if self.isDataDownloaded {
                // 다운로드 완료시
                single(.success("새로운 데이터로 교체됨"))
            } else {
                single(.failure(NetworkError.networkingFailed))
            }
            
            return Disposables.create()
        }
    }


}

 

Single에서 success는 .next + .complete의 의미로 볼 수 있는데 이는 .complete를 의미하는 것이 아니다 traits가 observable보다 좁은 범위이기 때문에 Single은  .complete 이벤트를 방출할 수 없다!

네트워킹 통신할 때 싱글톤을 사용하는데 싱글톤안에 네트워킹 하는 함수의 반환값을 Single 로 만들면 subscribe 해서 사용하면 좋겠다는 생각이 든당

 

Completable

하나의 element를 방출했던 Single과 달리 아무런 값도 방출하지 않는 traits 이다

그래서 데이터 없이 .completed와 .error 이벤트를 방출한다 이벤트로 결과만 받을 수 있기 때문에 값이 상관 없는 곳에서 사용할 수 있는데 데이터의 변경 후 알림을 받을 때라던지 데이터는 필요 없고 다운로드 및 업데이트가 성공적으로 되었는지만 확인 하고 싶은 경우(스플레시 같은..)에만 사용하면 되겠다!

앞서 살펴본 Single과 달리  Completable은 이벤트 방출시 Element가 없다!

 

    func loadCompletable(isAvailable: Bool) -> Completable {
        return Completable.create { event in
            if isAvailable {
                event(.completed)
            } else {
                event(.error(NetworkError.networkingFailed))
            }
            
            return Disposables.create()
        }
    }

        loadCompletable(isAvailable: true)
            .subscribe { event in
                print(event)
            }.disposed(by: disposeBag)

>>> completed 

가 콘솔창에 찍힌당

 

Maybe

Single과 Completable 기능을 수행 할 수 있는 Traits 이다! .success 와 .completed, .error 이벤트를 방출 가능하다

Completable 의 .completed 에서와 같이 아무런 element 없이 이벤트 방출도 가능하다

=> 에러 이벤트 방출 가능 or element와 함께 .success 이벤트 방출, element 없이 .completed 이벤트 방출 가능

 

    var previousString = "old data"
    
    func loadStringWithMaybe() -> Maybe<String> {
        return Maybe.create { event in
            let newString = "new String"
            
            if self.previousString == newString {
                event(.completed)
            } else if self.previousString != newString {
                event(.success(newString))
            } else {
                event(.error(NetworkError.networkingFailed))
            }
            
            return Disposables.create {
                print("maybe disposed")
            }
        }
    }

전역변수로 되어 있는 previousString과 새로운 데이터가 같은 경우 .completed 이벤트를 방출하고 

만약 데이터가 다르면 해당 데이터와 함께 .success 이벤트를 방출하도록 한 코드이다 

이 코드를 .success 이벤트의 element로 함께 방출하는 이유는 다른 곳에서 업데이트 하려고 해놓은 것인데,,,

사실 이 코드 내부에서 해도 상관 없는데 예제를 생각해 보다가 우선 테스트만 해보고자 간단하게 만들었당 

subscribe는 이렇게 작성하면 된다

        loadStringWithMaybe()
            .subscribe { maybe in
                switch maybe {
                case .success(let newData):
                    self.previousString = newData
                    print(self.previousString)
                case .error(let error):
                    print(error)
                case .completed:
                    print("completed maybe")
                }
            }
            .disposed(by: disposeBag)

.success에서만 element를 받을 수 있다!

 

Do 

side effect

do()로 event를 찍어보면서 디버깅 가능

출처 https://reactivex.io/

이런 식으로 이벤트가 방출 될때 마다 Do에서 정의해서 값을 사용 할 수 있다

디버깅 할 때 print로 찍어 볼 수 있음

.next 이벤트가 발생할 때마다 do가 호출 됨

side effet란  observable 밖으로 데이터를 내보내는 행위를 말하는데

시퀀스에서 next로 여러 event들이 방출되면 중간 중간 값을 캐치해서 쓰나보다 원래 목적으로 쓰이지 않고 부작용을 일으키는게 사이드 이펙트라고 생각했는데

원래 Observable 처럼 쓰이지 않고 side로 쓰여서 그런걸까?

side effect를 통해서 코드 현재 흐름 확인 가능, 메소드 실행되기 전에 작업 지정가능하다는 장점이 있음

 

        let disposeBag = DisposeBag()
        
        Observable.of(1, 2, 3)
            .do(onNext: { element in
                print("옵저빙 do : \(element)")
            })
            .subscribe(onNext: {
                print("next event : \($0)")
            })
            .disposed(by: disposeBag)

 

옵저빙 do : 1
next event : 1
옵저빙 do : 2
next event : 2
옵저빙 do : 3
next event : 3

이벤트가 방출 될 때마다 do에서 해당 이벤트의  element에 원하는 처리를 할 수 있다!

 

Subjects 

observable과 observer을 동시에 수행할 수 있음

이전에 배웠던 Observer와 다른 점은 multicast 방식이라는 것이다

여러 Observer가 동시에 구독하여 이벤트를 발행시킬 수 있다

가장 대표적으로 PublishSubject 가 있당

아직 공부 중이라 잘 모르겠는데 이걸로 아마 비동기적인걸 동기적 처럼 쓸 수 있을 모양이당

 

헷갈리니 Observer을 다시 보면

        let observer = Observable.of("1", "2") // 옵저버블 : 이벤트 전달
        
        // 옵저버블을 감시하고 있다가 전달되는 이벤트를 처리함
        let subscription3 = observer.subscribe(onNext: { element in
            print("3 : \(element)")
        })
        
        let subscription4 = observer.subscribe(onNext: { element in
            print("4 : \(element)")
        })

옵저버블을 생성

옵저버블은 이벤트를 방출시킨다 Observer는 subscribe로 옵저버블을 감시하고 있다가 전달되는 이벤트를 처리하게 된다

옵저버블이 있다 -> 구독했다 -> 옵저버블의 이벤트를 받아 처리한다

 

위 코드를 마블 다이어그램으로 표현하면 이러하당

subejct랑 헷갈리면 안되는 것이 각자 구독했다는 것이다. 그러니까 subscription3와 subscription 4의 시퀀스는 다르다 각각 따로 간다 1:1로 구성되어 있는 것

그런데 subject는 Subject가 있고 이를 구독하는 여러개의 subscriber가 있다

당연히 시퀀스는 따로 간다

 

 

        let subject = PublishSubject<String>()
        subject.onNext("1") // publisher는 있지만 Observer가 없으므로 아무것도 출력되지 않는다
        
        let subscriptionOne = subject
            .subscribe(onNext: { element in
                print("one : \(element)")
            })
        subject.onNext("3")
        
        let subscriptionTwo = subject
            .subscribe(onNext: { element in
                print("two : \(element)")
            })
        
        subject.onNext("2")

 

 

데이터를 subscriber에게 뿌려줄 수 잇음

subscriber는 subscribe 한 시점 이후에 발생되는 이벤트만 전달 받는다

 

 

두 그림을 보면 알 수 있듯이 Observer와 Subject는 observable의 역활을 하고

Subject는 여기서 Observer의 역활도 한다고 볼 수 있다

 

 

 

 

참고 사이트 및 도서 

https://medium.com/@priya_talreja/rxswift-traits-4408d66cb6ad

rxswift reactive programming with swift _ raywenderlich

ㄴ https://www.raywenderlich.com/books/rxswift-reactive-programming-with-swift

https://velog.io/@sangjin98/iOS-RxSwift-Observable-Disposable 

ㄴ side effect 장점 참고