[RxSwift] 에러 핸들링

RxSwift + MVVM + Clean Architecture로 구성된 프로젝트를 예시로 작성했읍니다.

 

1. 원하는 error 을 enum형으로 정의

rx에서는 onError를 사용해서 error를 전달하는데,

onError 안에는 Error 타입을 받기 때문에 Error 프로토콜을 채택한 APIError를 생성해줬습니다.

// MARK: - APIError

import Foundation

enum APIError: Error, Equatable {
    case pathErr
    case serverErr
    case userInfoErr
    case decodingErr
		case duplicatedUserErr(userId: [Int])
		
		var type: String {
        switch self {
        case .pathErr:
            return "pathErr"
        case .serverErr:
            return "serverErr"
        case .userInfoErr:
            return "userInfoErr"
        case .duplicatedUserErr:
            return "duplicatedUserErr"
        case .decodingErr:
            return "decodingErr"
        }
    }
    
    var value: [Int] {
        switch self {
        case .duplicatedUserErr(let userId):
            return userId
        default:
            return []
        }
    }
}

 

2. onError로 에러 던지기

성공할 경우(200, 201 등) onNext(), onCompleted()를 보내준다면,

실패할 경우(에러가 발생하는 경우)에는 onError를 통해서 그 안에 error를 넣어 보내주게 됩니다.

 

Service

// MARK: - ~Service
func requestObjectInRx<T: Decodable>(_ target: TargetType) -> Observable<T?> {
        return Observable<T?>.create { observer in
            self.provider.rx
                .request(target)
                .subscribe { event in
                    switch event {
                    case .success(let value):
                        do {
                            let decoder = JSONDecoder()
                            let statusCode = value.statusCode
                            switch statusCode {
                            case 200, 201:
                                let body = try decoder.decode(ResponseObject<T>.self, from: value.data)
                                print("✅", body)
                                observer.onNext(body.data)
                                observer.onCompleted()
							...

                            case 401:
                                observer.onError(APIError.userInfoErr)
                            case 500:
                                observer.onError(APIError.serverErr)
                            default:
                                observer.onError(APIError.pathErr)
                            }
                        } catch let error {
                            dump(error)
                            observer.onError(error)
                        }
                    case .failure(let error):
                        dump(error)
                        observer.onError(error)
                    }
                }.disposed(by: self.disposeBag)
            return Disposables.create()
        }
}

 

UseCase

clean architecture + MVVM을 사용했기 때문에

repository가 service로부터 어떤 서버 통신을 요청하고 받은 값을 useCase로 전달하도록 했고,

useCase에서는 에러를 받은 경우, 에러 종류에 따라 분기처리가 필요한 경우 분기처리할 수 있도록 했습니다.

// MARK: - ~UseCase

var duplicatedUserId: PublishRelay<[Int]> { get set }
var networkError: PublishRelay<Error> { get set }

...

func getUserInfo(id: Int) {
        repository.getUserInfo(id: id)
            .subscribe(onNext: { [weak self] entity in
                ...
            }, onError: { error in
				// 한 종류의 에러로 처리하는 경우
                self.networkError.accept(error)
            }).disposed(by: disposeBag)
}
    
func postStartMatch(requestModel: RequestModel) {
        repository.postStartMatch(requestModel: requestModel)
            .subscribe(onNext: { [weak self] entity in
                ...
            }, onError: { error in
				// 에러 내에서 분기처리가 필요한 경우
				// ex) 둘 이상의 사용자끼리 매칭을 해주는 post api -> 중복되는 유저가 발생하는 경우, duplicatedUserErr 전달받음
				// 네트워크 에러와 중복 유저 두가지로 분기처리
                guard let error = error as? APIError else { return }
                if error.type == "duplicatedUserErr" {
                    self.duplicatedUserId.accept(error.value)
                } else {
                    self.networkError.accept(error)
                }
            })
            .disposed(by: disposeBag)
}

 

3. 전달받은 에러 처리하기

useCase의 에러 이벤트를 전달하는 PublishRelay를 구독하고 해당 시퀀스에서 이벤트가 발생할 경우

ViewModel에 output으로 전달하고,

ViewController에서는 그 ViewModeld output 시퀀스를 구독하여 에러 발생시 UI에 적용할 부분을 구현하도록 했습니다.

(alert, 토스트메세지 등)

 

ViewModel + ViewController

// MARK: - ~ViewModel

struct Output {
		...
		var networkError = PublishRelay<Void>()
}

...

useCase.networkError.subscribe { error in 
		// output으로 ViewController에 전달
		output.networkError.accept(())
}.disposed(by: self.disposeBag)

// MARK: - ~ViewController

private func bindViewModels() {
        let input = AddPlayerViewModel.Input(...)
        let output = self.viewModel.transform(from: input, disposeBag: self.disposeBag)

        ...
        
        output.networkError
            .subscribe { _ in
                self.showNetworkAlert { _ in
                    self.dismiss(animated: true)
                }
            }.disposed(by: self.disposeBag)
}