[Kotlin/Coroutine] 코루틴으로 비동기처리 Cool 하게 하기
이용자가 로그인하면 응답받은 회원 정보로 계좌목록 조회해 주시고 각 계좌별 은행 서버에 잔액 조회해 주시고 대표계좌는 최근 일주일 거래내역 조회해 주시고 각 거래내역 별 .....
위 상황은 물론 과장한 가상의 케이스이지만 API 요청에 대한 응답을 받은 후 다른 API 요청을 보내는 일은 실제로 빈번하다.
꼭 API 요청이 아니더라도 비동기적으로 처리하는 로직에 대해 종료시점 또는 응답값 반환시점에 필요한 행위를 하기 위해 Callback 을 많이 사용한다.
Callback
위와 같은 상황을 해결하기 위해선(네트워크 요청이 비동기적이라는 가정 하에) 아래처럼 응답을 받은 후 호출할 함수를 인자로 넘겨주어 순차적으로 호출되도록 만든다.
fun main() {
foo() {
boo(it) {
// ...
}
}
}하지만 이렇게 하면 문제점이 존재하는데...
Callback Hell
콜백이 많아지면 Callback Hell 에 빠진다.
이런 코드는 가독성도 해치고 유지보수성도 낮아진다.
코틀린의 코루틴을 사용하면 이런 문제를 어느 정도 해결할 수 있다.
네트워크 요청을 통해 콜백과 코루틴 비교
비동기 네트워크 요청하는 코드를 이용해 콜백과 코루틴을 사용했을 때 각각 어떻게 달라지는지 비교해보고자 한다.
우선 네트워크 요청에 필요한 간단한 네트워크 요청 클라이언트를 구현했다.
private val client = OkHttpClient.Builder().build()
private const val BASE_URL = "http://localhost:8080"
private val gson = Gson()
private val mapType = object : TypeToken<Map<String, String>>() {}.type
// Json 문자열을 Map 으로 변환
private fun toMap(bodyString: String): Map<String, String> = gson.fromJson(bodyString, mapType)
fun createRequest(url: String, method: String, body: RequestBody? = null): Request {
val builder = Request.Builder()
.url(url)
when (method.uppercase()) {
"GET" -> builder.get()
"POST" -> body?.let { builder.post(it) }
}
return builder.build()
}클라이언트는 OkHttpClient 를 이용해 간단하게 구성했다.
아래는 네트워크 요청/응답에 사용할 DTO 객체이다.
data class UserRequest(
val id: Int? = null,
val name: String? = null,
val age: Int? = null
) {
fun toQueryStringMap(): Map<String, String> = buildMap {
this@UserRequest.let { request ->
request.id?.let { put("id", it.toString()) }
request.name?.let { put("id", it) }
request.age?.let { put("id", it.toString()) }
}
}
fun toJsonBody(): String = Gson().toJson(this)
}
data class UserResponse(
@SerializedName("code")
val code: Int,
@SerializedName("id")
val id: Int? = null,
@SerializedName("name")
val name: String? = null,
@SerializedName("age")
val age: Int? = null
) {
override fun toString(): String {
return "UserResponse(code=$code${if (id != null) ", id=$id" else ""}${if (name != null) ", name=$name" else ""}${if (age != null) ", age=$age" else ""})"
}
}
콜백을 이용한 비동기 네트워크 요청
우선 고전적인 콜백을 이용해서 비동기 네트워크 요청을 하는 코드로 구현해 봤다.
private fun baseCallV1(uri: String, method: String, body: RequestBody? = null, callback: (response: Response) -> Unit) {
val request = createRequest("$BASE_URL$uri", method, body)
Thread {
client.newCall(request).execute().use(callback)
}.start()
}
fun callSaveUserV1() {
baseCallV1("/users", "POST", UserRequest(name = "hong", age = 25).toJsonBody().toRequestBody("application/json".toMediaType())) {
it?.body?.string()?.let { bosyString ->
val body: Map<String, String> = toMap(bosyString)
callGetAgeV1(body["id"]?.toInt() ?: throw IllegalArgumentException("id is null"))
}
}
}
fun callGetAgeV1(id: Int) {
baseCallV1("/users/age?id=$id", "GET") {
it?.body?.string()?.let { bosyString ->
val body: Map<String, String> = toMap(bosyString)
println("result: ${body["age"]}")
}
}
}callSaveUserV1() 을 호출해 이용자 정보를 저장하면, 응답으로 받은 id 값으로 age 를 조회하는 요청을 보내는 로직이다.
callSaveUserV1() 함수 안에서 응답을 받으면 콜백을 호출해 callGetAgeV1() 을 호출하게 된다.
이런 로직이 늘어나면 위에서 본 Callback Hell 처럼 콜백이 그득하게 있는 코드가 되는 거다.
이 경우 함수의 단위 테스트가 불가능하는 등 문제가 있을 수 있다.
그럼 코루틴으로 이런 문제를 해결해 보겠다.
코루틴으로 비동기처리 1
private fun baseCallV2(uri: String, method: String, body: RequestBody? = null): Response {
val request = createRequest("$BASE_URL$uri", method, body)
return client.newCall(request).execute()
}
fun callSaveUserV2(): Map<String, String> {
val response = baseCallV2("/users", "POST", UserRequest(name = "hong", age = 25).toJsonBody().toRequestBody("application/json".toMediaType()))
return response.body?.string()?.let { toMap(it) } ?: emptyMap()
}
fun callGetAgeV2(id: Int): Map<String, String> {
val response = baseCallV2("/users/age?id=$id", "GET")
return response.body?.string()?.let { toMap(it) } ?: emptyMap()
}우선 네트워크 요청을 보내는 코드이다.
눈에 띄는 차이점은 Thread 를 이용하지 않았기 때문에 명시적 반환값을 사용할 수 있다는 것이다.
코루틴은 분명 비동기 프로그래밍으로 알려져 있는데 Thread 생성 없이 어떻게 비동기를 처리한단 말인가?
이 비밀은 코루틴과 스레드의 차이에 있다. 이 둘의 차이를 간단하게 말하자면
- 스레드: 작업공간을 분리시켜 각 스레드 간 메모리 공유가 불가
- 코루틴: 하나의 스레드 내에서 여러 루틴을 번갈아가며 실행이 가능. 메모리 공유되고, 루틴을 잠시 중지시키면 사용하던 변수를 보관
라고 할 수 있다.
코루틴을 사용하려면 일단 suspend 함수 내에서 호출해야 한다. 코루틴을 생성하는 간단한 방법은 함수를 runBlocking 블록으로 감싸면 된다.
suspend fun main(): Unit = runBlocking {
val saveUserApiResponse: Deferred<Map<String,String>> = async(Dispatchers.IO) { callSaveUserV2() }
val getAgeApiResponse: Deferred<Map<String,String>> = async(Dispatchers.IO) { callGetAgeV2(saveUserApiResponse.await()["id"]?.toInt() ?: throw IllegalArgumentException("id is null")) }
println("result: ${getAgeApiResponse.await()["age"]}")
}코루틴의 async 를 사용해 위와 같이 깔끔하게 해결을 해주었다.
async 를 이용하면 Deferred 를 반환받게 된다. 이 Deferred 변수에 await() 를 호출하면 해당 루틴시 실행되고 반환값을 받을 수 있다.
이 정도도 충분히 좋지만 작은 문제가 더 존재한다. 바로 반환값인 Deferred 에 의존하게 된다는 것이다.
이렇게 되면 수평확장에 닫혀있을 수 있으므로 Map<String, String> 를 바로 반환받도록 하는 것이 좋다.
코루틴으로 비동기처리 2
이 문제를 해결하는 방법은 간단하다.
코루틴 안에서 호출할 루틴들을 코루틴(suspend fun)으로 바꿔주면 된다.
private suspend fun baseCallV3(uri: String, method: String, body: RequestBody? = null): Response = CoroutineScope(Dispatchers.IO).async {
val request = createRequest("$BASE_URL$uri", method, body)
client.newCall(request).execute()
}.await()
suspend fun callSaveUserV3(): Map<String, String> = coroutineScope {
async {
val response = baseCallV3("/users", "POST", UserRequest(name = "hong", age = 25).toJsonBody().toRequestBody("application/json".toMediaType()))
response.body?.string()?.let { toMap(it) } ?: emptyMap()
}.await()
}
suspend fun callGetAgeV3(id: Int): Map<String, String> = coroutineScope {
async {
val response = baseCallV3("/users/age?id=$id", "GET")
response.body?.string()?.let { toMap(it) } ?: emptyMap()
}.await()
}
suspend fun main(): Unit = runBlocking {
val saveUserApiResponse: Map<String, String> = callSaveUserV3()
val getAgeApiResponse: Map<String, String> = callGetAgeV3(saveUserApiResponse["id"]?.toInt() ?: throw IllegalArgumentException("id is null"))
println("result: ${getAgeApiResponse["age"]}")
}이제 완벽하게 문제를 해결한 코드가 됐다.
예시를 네트워크 요청으로 들었지만, 이런 상황 외에도 여러 비동기 처리 로직에서 이용하기 좋은 방법이라 생각된다.