[Android, Kotlin] Android clean architecture 프로젝트에서 api 에러 핸들링하기

 

clean architecture 프로젝트를 구상하고 개발하다 보면 api error 처리를 어떻게 하고 있는가?

예전의 필자는 그냥 무지성으로(?) presentation layer에 try catch를 이용해 처리를 했었었다.

하지만 그 방법을 사용했을 때, 일일이 try catch문을 작성해야 하는 불편함과 presentation layer에서만 처리하는 것이 맞나 이런 의문들이 들기 시작했다.

 

그래서 이번 포스팅에서 clean architecture project에서 api error handling logic을 작성하는 방법을 공부하고 적어보았다.

 

1. error handling 로직은 어떤 layer에 작성되어야 하는가??

필자는 data layer에서 http status code에 따른 예외에 따른 exception을 날리고 domain layer의 use case에서 try catch를 이용해 presentation layer의 viewmodel에서 error에 따른 state를 부여해서 ui에서 state에 따른 로직을 처리하게 작성해 보겠다.

 

2. data layer에서의 작업

data layer에서의 작업을 보면 일단 network 로직을 받아와서 그 결과에 따른 로직을 try catch로 처리해 준다.

suspend fun <T> safeApiCall(call: suspend () -> T): T {
    return try {
        call.invoke()
    } catch (e: HttpException) {
        val message = e.message
        throw when(e.code()) {
            400 -> BadRequestException(message = message)
            401 -> UnauthorizedException(message = message)
            403 -> ForbiddenException(message = message)
            404 -> NotFoundException(message = message)
            500, 501, 502, 503 -> ServerException(message = message)
            else -> OtherHttpException(
                code = e.code(),
                message = message
            )
        }
    } catch (e: SocketTimeoutException) {
        throw TimeOutException(message = e.message)
    } catch (e: UnknownHostException) {
        throw InternetException()
    } catch (e: Exception) {
        throw UnknownException(message = e.message)
    }
}

 

서버에서 알려주는 status 코드에 따라 다른 exception을 throw 한다. 다른 따로 처리할 exception들이 있다면 catch를 열어서 처리해도 된다.

exception에 대한 정보는 HttpException 파일에서 확인해 볼 수 있다.

package com.mvi.data.exception

/**
 * 400: bad request
 */
class BadRequestException(
    override val message: String?
): RuntimeException()

/**
 * 401: unauthorized
 */
class UnauthorizedException(
    override val message: String?
): RuntimeException()

/**
 * 403: forbidden
 */
class ForbiddenException(
    override val message: String?
): RuntimeException()

/**
 * 404: not found
 */
class NotFoundException(
    override val message: String?
): RuntimeException()

/**
 * 500: server error
 */
class ServerException(
    override val message: String?
): RuntimeException()

/**
 * response time out
 */
class TimeOutException(
    override val message: String?
) : RuntimeException()

/**
 * other error
 */
class OtherHttpException(
    val code: Int?,
    override val message: String?
): RuntimeException()

/**
 * unknown error
 */
class UnknownException(
    override val message: String?
): RuntimeException()

 

 

3. domain layer에서의 작업

domain에서의 작업을 보면

usecase 쪽에서 handling 작업을 한다.

class OAuthTokenUseCase @Inject constructor(
    private val twitchAuthRepository: TwitchAuthRepository
) {
    suspend operator fun invoke(
        clientId: String,
        clientSecret: String,
        grantType: String
    ) = kotlin.runCatching { twitchAuthRepository.oAuthToken(clientId, clientSecret, grantType) }
}

operator function을 사용해 runcatch문을 돌린다.

runcatch의 결과는 presentation layer에서 처리한다.

 

4. presentation layer에서의 작업

presentation layer에서는 viewModel에서 usecase에서 반환된 runcatch 결과에 따라 각각 state를 할당한다.

class TwitchAuthViewModel @Inject constructor(
    private val oAuthTokenUseCase: OAuthTokenUseCase
): ViewModel() {
    private val _oAuth = MutableLiveData<ApiState<OAuthResponseDomain>>(ApiState.Loading)
    val oAuth: LiveData<ApiState<OAuthResponseDomain>> = _oAuth

    fun getOAuthToken(
        clientId: String,
        clientSecret: String,
        grantType: String
    ) {
        viewModelScope.launch {
            oAuthTokenUseCase(clientId, clientSecret, grantType).onSuccess {
                _oAuth.value = ApiState.Success(data = it)
            }.onFailure {
                it.exceptionErrorHandling(
                    badRequestAction = { _oAuth.value = ApiState.BadRequest },
                    forbiddenAction = { _oAuth.value = ApiState.Forbidden },
                    timeOutAction = { _oAuth.value = ApiState.TimeOut },
                    serverAction = { _oAuth.value = ApiState.Server },
                    unknownAction = { _oAuth.value = ApiState.Unknown }
                )
            }
        }
    }
}

기존에 liveData만 이용하던 변수에 ApiState가 추가되었다.

함수 로직에서는 useCase에서의 runcatch 결과에 따라 apiState에서 state를 주는 것을 확인할 수 있다.

ApiState 파일에서는 다양한 state를 선언해 놓았다.

sealed interface ApiState<out T> {
    object Loading: ApiState<Nothing>
    data class Success<T>(val data: T? = null): ApiState<T>
    object BadRequest: ApiState<Nothing>
    object Unauthorized: ApiState<Nothing>
    object Forbidden: ApiState<Nothing>
    object NotFound: ApiState<Nothing>
    object TimeOut: ApiState<Nothing>
    object Server: ApiState<Nothing>
    object Unknown: ApiState<Nothing>
}

또한 api 통신에 실패했을 때에는 data layer에서 throw 된 exception에 맞게 수행되는 고차 함수들로 이루어져 있다.

ExceptionHandling 파일에서 확인해 볼 수 있다.

fun Throwable.exceptionErrorHandling(
    badRequestAction: () -> Unit = {},
    unauthorizedAction: () -> Unit = {},
    forbiddenAction: () -> Unit = {},
    notFoundAction: () -> Unit = {},
    timeOutAction: () -> Unit = {},
    serverAction: () -> Unit = {},
    unknownAction: () -> Unit = {},
) {
    when (this) {
        is BadRequestException -> badRequestAction()
        is UnauthorizedException -> unauthorizedAction()
        is ForbiddenException -> forbiddenAction()
        is NotFoundException -> notFoundAction()
        is TimeOutException -> timeOutAction()
        is ServerException -> serverAction()
        else -> unknownAction()
    }
}

 

정리

---

이번 포스팅에서는 clean architecture 관점에서의 api error handling 방법에 대해서 정리해 보았다.

기존에 제대로 알지 못하고 사용했던 api error handling을 더 자세히 알게 되었던 시간이었다.

또한 직접 사용해 보면서 구현해 놓은 로직을 ui에서 간단히 사용할 수 있어서 좋았던 것 같다.

이 방법 말고도 더 효율 좋은 방법을 아시는 분들은 댓글로 알려주시면 감사하겠습니다.