[iOS] - RxSwift 개념 이해하기_04

🎯 RxSwift 이해하기_04

RxSwift 이해하기_01 - https://jayb-log.tistory.com/275

RxSwift 이해하기_02 - https://jayb-log.tistory.com/276

RxSwift 이해하기_03 - https://jayb-log.tistory.com/277

• 🙋 이 글은 RxSwift에 대한 엄청난 이해나 본질을 파악한다기보다 입문하는 입장에서 작성하는 글이에요! 곰튀김님의 강의(하단에 링크) 를 들으며 정리한 내용, 생각들을 작성할 예정이에요. 틀린 부분이나 추가하면 좋은 부분에 대한 피드백은 언제나 환영입니다 :]

🧑🏻‍💻 Subscribe 하기

• 우선 아래 코드의 결과물은 당연히 Stream이 됩니다.

  
  

  Observable.just("HelloWorld")

  
  

  이 Stream의 최종 데이터를 사용하고 싶을 때 subscribe라는 메소드를 사용해요 :]

  
  

  Observable.just("HelloWorld")
      .subscribe()

  
  

  이렇게 하면 "HelloWorld"가 내려오고 그냥 끝나게되요. 예를 들면, Analytic에 데이터를 보낼 때 보낸 후 어떻게 되든 신경쓰고 싶지 않다 라는 상황에서는 위와 같이 처리할 수 있겠죠.

  하지만 subscribe에는 이것 외에도 다양한 옵션이 있어요.

  가장 기본적인 것은 on이에요.

  
  

  Observable.just("HelloWorld")
      .subscribe(on: (Event<String>) -> Void)

  
  

  on에서 이벤트 타입이 와요.

  이벤트 타입은 enum으로 next, error, completed의 3가지 타입이 있어요.

  
  

  Observable.just("HelloWorld")
      .subscribe { event in
      switch event {
        case .next(let str):
          break
        case .error(let err):
          break
        case .completed:
          break
        }
    }
    .disposed(by: self.disposeBag)

  
  

  다른 Operator들은 return type이 stream으로 모두 Observable이에요. 유일하게 subscribe만 return 타입이 disposable이에요. 그래서 subscribe이 끝나면 dispose 처리를 해줘야해요.

  
  

  next: 데이터를 그대로 전달해줘요.

  error: 에러를 전달해줘요.

  completed: 모든 stream이 완료가 되면 complete이 되요.

  
  

  그래서 stream은 error일 때, 그리고 completed 일 때 종료가 되요.

  just의 경우 받은 데이터를 그대로 넘겨주기 때문에 next가 데이터를 한 번 그대로 전달하지만, from의 경우는 어떨까요?

  
  

  Observable.from(["test", "array", 1, "입니다."])
      .subscribe { event in
      switch event {
        case .next(let str):
          break
        case .error(let err):
          break
        case .completed:
          break
        }
    }
    .disposed(by: self.disposeBag)

  
  

  위의 경우에는 4번 데이터가 불리기 때문에 next 역시 4번 불리게 될 거에요!

  그럼 아래의 경우 어떤 결과물이 나올지 예상해볼게요.

  
  

  Observable.from(["test", "array", 1, "입니다."])
      .subscribe { event in
      switch event {
        case .next(let str):
                  print("next: \(str)")
            break
        case .error(let err):
            print("next: \(err.localizedDescription)")
          break
        case .completed:
            print("completed")
          break
        }
    }
    .disposed(by: self.disposeBag)

  
  

  출력 결과물은 아래와 같아요

  
  

  /**
  next: test
  next: arrray
  next: 1
  next: 입니다.
  completed
  */

  
  

  여기서 포인트는 completed가 있다는 점이에요. event에서 모든 데이터가 next로 넘어왔다고 하더라도 stream이 종료가되면 무조건 .completed의 case로 들어오는 것이죠.

  이번엔 에러를 일으켜 볼게요.

  
  

  Observable.from(["test", "array", 1, "입니다."])
      .single()
      .subscribe { event in
      switch event {
        case .next(let str):
                  print("next: \(str)")
            break
        case .error(let err):
            print("next: \(err.localizedDescription)")
          break
        case .completed:
            print("completed")
          break
        }
    }
    .disposed(by: self.disposeBag)

  
  

  single의 경우 1개의 값만 들어오고 complete bar가 있었죠? single인데 여러 값이 들어올 경우 에러가 발생해요. 그래서 위의 경우에는 아래와 같이 출력될 거에요.

  
  

  /**
  next: test
  error: The operation 블라블라 (에러 메세지)
  */

  
  

  여기서도 중요한 건 stream이기 때문에 error가 발생하기 전 첫번째 stream은 동작을 한다는 것이죠. 에러가 발생할 경우 단순히 에러만 로깅되는 경우가 있는데 Rx에서는 에러가 나오는 시점 이전까지 작업은 정상적으로 진행되기 때문이에요!

  그럼 위의 상황 때문에 생기기 쉬운 문제는 어떤 경우일까요?

  
  

  // Progress on
  Observable.from(["test", "array", 1, "입니다."])
      .single()
      .subscribe { event in
      switch event {
        case .next(let str):
                  print("next: \(str)")
            break
        case .error(let err):
            print("next: \(err.localizedDescription)")
          break
        case .completed:
            // Progress off
            print("completed")
          break
        }
    }
    .disposed(by: self.disposeBag)

  
  

  위의 경우 error가 발생하게 되면 Progress가 절대 off 되지 않아요. stream이 계속 next만 진행될 경우 마지막에 stream의 종료가 있어 completed가 동작하지만 error가 발생하면 그 즉시 stream이 멈추기 때문에 complete bar 타임까지 돌아오지 않아 .completed가 동작할 일이 없게 되요.

  
  

• 이번엔 subscribe onNext를 알아볼게요!

  onNext는 아래와 같은 구조로 구현되요 :]

  
  

  Observable.from(["test", "array", 1, "입니다."])
      .single()
      .subscribe(onNext: ~~, onError: ~~, onCompleted: ~~, onDisposed: ~~)

  
  

  onNext가 아닌 단순 on으로 구현이 되었을 때에는 switch에 빠지는 조건이 없으면 안됬어요. case가 3개이니까 무조건 switch에 3가지 경우 모두가 구현 되어야하죠.

  그런데 이게 불필요하게 코드가 길어지고 귀찮을 때가 있죠? 그래서 Next일 때만 작업할거야 라는 상황이 필요할 때가 있어요. 나머지는 특히 optional이기 때문에 굳이 작성해줄 필요가 없죠! 그래서 아래와 같이 작성할 수 있어요.

  
  

  Observable.from(["test", "array", 1, "입니다."])
      .single()
      .subscribe(onNext: { event in
                            print(event)
                       }
              ).disposed(by: self.disposeBag)

  
  

  이제 onError나 onCompleted, onDisposed도 작성해볼게요!

  
  

  Observable.from(["test", "array", 1, "입니다."])
      .single()
      .subscribe(onNext: { event in
                            print(event)
                       },
               onError: { err in 
                            print(err.localizedDescription)
                        },
               onCompleted: {
                                             print("onCompleted")
                                           },
               onDisposed: {
                                             print("disposed")
                                           }
              ).disposed(by: self.disposeBag)

  
  

  여기서 역시 error가 발생할 텐데요, on에서 했던 예시와 다른 것은 "disposed"가 출력된다는 점이에요. onDisposed는 말 그대로 dispose될 때이고, dispose는 Error나 Complete 여부와 관계없이 동작하기 때문이에요!

  
  

  그런데 위의 코드는 조금 지저분해요. 그래서 아래와 같이 좀 더 가독성 좋게 변경할 수 있어요.

  
  

  private func output(_ event: Any) {
    print(event)
  }
  
  func exampleFrom() {
    Observable.from(["test", "array", 1, "입니다."])
      .single()
      .subscribe(onNext: output)
        .disposed(by: self.disposeBag)
  }

  
  

  훨씬 간단하고 깔끔해졌어요. onNext 뒤에 들어갈 클로저는 input parameter가 event, 작업 결과물이 Void로 print이기 때문에 그 조건에 맞춘 메소드로 분리 가능해요.

4편은 여기까지 입니다! 5편에서는 observeOn처럼 Main Thread가 아닌 Concurrency Thread에서 작업하는 법에 대해 이야기 해볼게요! :]

ReactiveX

RxSwift by 곰튀김