Kotlin Flow로 비동기 데이터 스트림, 반응형 UI와 에러를 견고하게 처리하는 비법

Kotlin Flow를 활용해 모바일 앱의 비동기 데이터 스트림을 효율적으로 처리하고, 반응형 UI 설계와 견고한 에러 처리 전략을 구축하는 실전 노하우를 소개합니다.

📑 목차

• Kotlin Flow, 모바일 앱 개발에서 왜 중요할까요?
• Kotlin Flow의 핵심: '콜드 스트림'과 '핫 스트림' 이해하기
• 콜드 스트림: 요청이 있을 때만 데이터를 생산
• 핫 스트림: 구독 여부와 관계없이 데이터를 생산
• 반응형 UI를 위한 Kotlin Flow 활용 전략
• 데이터 계층에서 UI 계층으로 Flow 연결하기
• 튼튼한 앱을 위한 Kotlin Flow 에러 처리 기법
• catch 연산자를 활용한 에러 복구 및 알림
• retry, retryWhen을 이용한 재시도 전략
• Kotlin Flow 실전 점검 체크리스트
• 마무리하며: 지속 가능한 앱 개발을 위한 Kotlin Flow

Image by Boskampi on Pixabay

Kotlin Flow, 모바일 앱 개발에서 왜 중요할까요?

안녕하세요! 모바일 앱 개발의 세계에 오신 여러분을 환영합니다. 앱을 만들다 보면 사용자에게 끊김 없는 경험을 제공하는 것이 정말 중요하다는 것을 느끼실 거예요. 예를 들어, 인터넷에서 데이터를 가져오는 동안 앱 화면이 멈추거나, 데이터 로딩이 실패했을 때 앱이 갑자기 꺼진다면 사용자는 얼마나 불편할까요?

이러한 문제를 해결하기 위해 비동기 처리(Asynchronous Processing)라는 기술이 필요합니다. 비동기 처리는 동시에 여러 작업을 수행하면서도 앱의 UI(사용자 인터페이스)가 멈추지 않고 부드럽게 작동하도록 돕는 방식입니다. 마치 식당에서 주문을 받은 요리사가 한 음식만 만들지 않고, 여러 음식 주문을 동시에 처리하면서 손님들이 기다리지 않도록 하는 것과 비슷하죠.

Kotlin 언어에는 이러한 비동기 처리를 훨씬 쉽고 효율적으로 할 수 있게 도와주는 코루틴(Coroutine)이라는 강력한 기능이 있습니다. 그리고 이 코루틴을 기반으로 데이터 스트림(Data Stream)을 다루는 데 특화된 도구가 바로 Kotlin Flow입니다. 데이터 스트림이란, 데이터가 마치 물이 흐르듯 연속적으로 발생하고 전달되는 방식을 의미해요. 예를 들어, 사용자가 좋아요 버튼을 여러 번 누르거나, 서버에서 새로운 알림이 계속 도착하는 상황 등을 생각할 수 있습니다.

Kotlin Flow를 사용하면 복잡한 비동기 작업을 단순하고 읽기 쉬운 코드로 작성할 수 있고, 앱의 반응성을 크게 향상시킬 수 있습니다. 특히, 실시간으로 변화하는 데이터를 UI에 즉시 반영해야 하는 반응형 앱을 개발할 때 그 진가가 발휘됩니다. 이제부터 Kotlin Flow가 무엇인지, 어떻게 앱 개발에 활용할 수 있는지 함께 살펴보겠습니다.

Kotlin Flow의 핵심: '콜드 스트림'과 '핫 스트림' 이해하기

Kotlin Flow를 제대로 활용하려면 가장 먼저 콜드 스트림(Cold Stream)과 핫 스트림(Hot Stream)이라는 두 가지 개념을 이해해야 합니다. 이 둘은 데이터가 구독자(데이터를 받는 쪽)에게 전달되는 방식에 차이가 있습니다.

콜드 스트림: 요청이 있을 때만 데이터를 생산

콜드 스트림은 마치 수도꼭지와 같습니다. 누군가 수도꼭지를 틀어 물을 요청해야만 물(데이터)이 나옵니다. 즉, 구독자(Collector)가 나타나서 데이터를 요청(collect)할 때까지는 아무런 데이터도 생성하지 않습니다. 그리고 각각의 구독자는 자신만의 새로운 데이터 흐름을 받게 됩니다. 예를 들어, Flow를 사용하여 네트워크에서 한 번 데이터를 가져오는 작업을 정의했다면, 이 Flow를 두 번 구독하면 네트워크 요청도 두 번 발생하게 됩니다.

fun createColdFlow(): Flow<String> = flow {
    println("콜드 스트림: 데이터 생성 시작 (요청 시에만)")
    delay(1000) // 1초 대기
    emit("첫 번째 데이터")
    delay(1000)
    emit("두 번째 데이터")
}

suspend fun main() {
    val coldFlow = createColdFlow()

    println("첫 번째 구독자")
    coldFlow.collect { value -> println("첫 번째 구독자 받음: $value") }

    println("두 번째 구독자")
    coldFlow.collect { value -> println("두 번째 구독자 받음: $value") }
}
// 출력 예시:
// 첫 번째 구독자
// 콜드 스트림: 데이터 생성 시작 (요청 시에만)
// 첫 번째 구독자 받음: 첫 번째 데이터
// 첫 번째 구독자 받음: 두 번째 데이터
// 두 번째 구독자
// 콜드 스트림: 데이터 생성 시작 (요청 시에만)
// 두 번째 구독자 받음: 첫 번째 데이터
// 두 번째 구독자 받음: 두 번째 데이터

위 코드에서 보듯이, 두 번의 collect 호출마다 "데이터 생성 시작" 메시지가 두 번 출력되는 것을 확인할 수 있습니다. 이는 각 구독이 독립적으로 데이터를 생성한다는 것을 의미합니다.

핫 스트림: 구독 여부와 관계없이 데이터를 생산

반면, 핫 스트림은 라디오 방송과 비슷합니다. 라디오 방송은 청취자가 듣고 있든 아니든 항상 방송을 내보냅니다. 즉, 구독자가 없어도 데이터를 계속 생성하며, 여러 구독자가 같은 시점에 생성되는 데이터를 공유합니다. 나중에 구독을 시작한 구독자는 그 시점부터의 데이터를 받게 됩니다.

Kotlin Flow에서는 MutableSharedFlow나 MutableStateFlow를 통해 핫 스트림을 구현할 수 있습니다. 특히 StateFlow는 특정 상태(State) 값을 가지고 있다가 이 값이 변경될 때만 새로운 값을 내보내는 핫 스트림의 한 종류로, UI 상태 관리에 매우 유용합니다.

fun createHotFlow(): MutableSharedFlow<String> {
    val hotFlow = MutableSharedFlow<String>()
    // 백그라운드에서 데이터를 주기적으로 발행
    CoroutineScope(Dispatchers.Default).launch {
        var count = 0
        while (true) {
            delay(1000)
            hotFlow.emit("핫 스트림 데이터: ${count++}")
        }
    }
    return hotFlow
}

suspend fun main() {
    val hotFlow = createHotFlow()

    println("첫 번째 구독자 시작 (2초 후)")
    delay(2000)
    CoroutineScope(Dispatchers.Default).launch {
        hotFlow.collect { value -> println("첫 번째 구독자 받음: $value") }
    }

    println("두 번째 구독자 시작 (4초 후)")
    delay(2000) // 총 4초 대기
    CoroutineScope(Dispatchers.Default).launch {
        hotFlow.collect { value -> println("두 번째 구독자 받음: $value") }
    }

    delay(5000) // 충분히 기다려 데이터 수신 확인
}
// 출력 예시 (시간에 따라 다를 수 있음):
// 첫 번째 구독자 시작 (2초 후)
// 핫 스트림 데이터: 2 (<- 이 시점부터 받기 시작)
// 첫 번째 구독자 받음: 2
// 핫 스트림 데이터: 3
// 첫 번째 구독자 받음: 3
// 두 번째 구독자 시작 (4초 후)
// 핫 스트림 데이터: 4 (<- 이 시점부터 두 번째 구독자도 받기 시작)
// 첫 번째 구독자 받음: 4
// 두 번째 구독자 받음: 4
// 핫 스트림 데이터: 5
// 첫 번째 구독자 받음: 5
// 두 번째 구독자 받음: 5

위 예시에서 첫 번째 구독자가 2초 후에 시작하고, 두 번째 구독자는 4초 후에 시작합니다. 두 번째 구독자는 첫 번째 구독자가 이미 받았던 데이터를 다시 받지 않고, 자신이 구독을 시작한 시점부터의 데이터를 공유받는 것을 볼 수 있습니다. 이처럼 콜드 스트림과 핫 스트림은 각각의 장단점을 가지고 있으므로, 앱의 요구사항에 맞춰 적절한 것을 선택하는 것이 중요합니다.

구분	콜드 스트림 (Flow)	핫 스트림 (SharedFlow/StateFlow)
데이터 생성 시점	구독자가 있을 때만 생성	구독 여부와 관계없이 계속 생성
구독자별 데이터	각 구독자가 독립적인 데이터 흐름을 받음	모든 구독자가 동일한 데이터 흐름을 공유
주요 사용처	단일 요청(네트워크 호출, DB 쿼리), UI 업데이트	실시간 이벤트(채팅, 위치 업데이트), UI 상태 관리
예시	flow { emit(repository.fetchData()) }	MutableStateFlow(initialState), MutableSharedFlow()

반응형 UI를 위한 Kotlin Flow 활용 전략

Kotlin Flow는 사용자에게 즉각적으로 반응하는 반응형 UI(Reactive UI)를 설계하는 데 매우 강력한 도구입니다. 데이터가 변경되면 UI가 자동으로 업데이트되도록 하는 것이 핵심이죠. 이를 위해서는 데이터 계층(Data Layer)에서 UI 계층으로 데이터를 효율적으로 전달하는 방법을 알아야 합니다.

데이터 계층에서 UI 계층으로 Flow 연결하기

일반적으로 앱 아키텍처는 데이터 계층(Repository), 비즈니스 로직 계층(ViewModel), UI 계층(Activity/Fragment)으로 나뉩니다. Kotlin Flow는 이 모든 계층을 아우르며 데이터 흐름을 연결합니다.

1. 데이터 계층 (Repository): 네트워크 호출이나 데이터베이스 쿼리와 같은 데이터 소스에서 데이터를 가져와 Flow 형태로 반환합니다.
2. 비즈니스 로직 계층 (ViewModel): Repository에서 받은 Flow를 가공하거나 여러 Flow를 조합하여 UI에서 필요한 형태로 만듭니다. 이때 StateFlow나 SharedFlow를 사용하여 UI 상태를 관리하는 것이 일반적입니다.
3. UI 계층 (Activity/Fragment): ViewModel에서 노출하는 StateFlow나 SharedFlow를 구독(collect)하여 데이터 변경을 감지하고, 그에 따라 UI를 업데이트합니다.

// ViewModel 예시
class MyViewModel(private val repository: MyRepository) : ViewModel() {

    private val _uiState = MutableStateFlow(MyUiState.Loading) // UI 상태를 나타내는 StateFlow
    val uiState: StateFlow<MyUiState> = _uiState.asStateFlow()

    init {
        fetchData()
    }

    fun fetchData() {
        viewModelScope.launch { // 코루틴 스코프 내에서 Flow 구독
            repository.getItems()
                .onStart { _uiState.value = MyUiState.Loading } // 데이터 로딩 시작 알림
                .catch { e -> _uiState.value = MyUiState.Error(e.message ?: "알 수 없는 에러") } // 에러 처리
                .collect { items -> _uiState.value = MyUiState.Success(items) } // 데이터 수신 시 UI 상태 업데이트
        }
    }
}

// Activity/Fragment 예시 (Compose UI 기준)
@Composable
fun MyScreen(viewModel: MyViewModel = viewModel()) {
    val uiState by viewModel.uiState.collectAsState() // StateFlow를 Compose 상태로 구독

    when (uiState) {
        is MyUiState.Loading -> { CircularProgressIndicator() }
        is MyUiState.Success -> {
            val items = (uiState as MyUiState.Success).data
            LazyColumn {
                items(items) { item -> Text(text = item) }
            }
        }
        is MyUiState.Error -> {
            val errorMessage = (uiState as MyUiState.Error).message
            Text(text = "에러 발생: $errorMessage", color = Color.Red)
        }
    }
}

위 코드에서 StateFlow를 사용하여 로딩, 성공, 에러 세 가지 상태를 효과적으로 관리하고, UI는 collectAsState()를 통해 이 상태 변화를 감지하여 자동으로 화면을 갱신합니다. 이렇게 하면 UI 코드가 데이터 변경 로직과 분리되어 훨씬 깔끔하고 유지보수하기 쉬워집니다.

Image by Pexels on Pixabay

튼튼한 앱을 위한 Kotlin Flow 에러 처리 기법

아무리 잘 만든 앱이라도 에러는 언제든 발생할 수 있습니다. 네트워크 연결 실패, 서버 오류, 잘못된 데이터 형식 등 다양한 상황에서 앱이 멈추거나 예기치 않은 동작을 하는 것을 방지하려면 견고한 에러 처리 전략이 필수적입니다. Kotlin Flow는 이러한 에러를 효과적으로 처리할 수 있는 다양한 연산자(Operator)를 제공합니다.

catch 연산자를 활용한 에러 복구 및 알림

Kotlin Flow에서 에러를 처리하는 가장 기본적인 방법은 catch 연산자를 사용하는 것입니다. catch는 업스트림(상위 Flow)에서 발생한 예외를 잡아내어 처리하고, 필요하다면 새로운 값을 방출하거나 Flow를 종료시킬 수 있습니다.

fun fetchDataWithError(): Flow<String> = flow {
    emit("데이터 1")
    delay(500)
    throw Exception("데이터 로딩 중 에러 발생!") // 고의로 에러 발생
    emit("데이터 2 (도달하지 못함)")
}

suspend fun main() {
    fetchDataWithError()
        .catch { e ->
            println("Flow에서 에러 발생: ${e.message}")
            emit("복구 데이터") // 에러 발생 시 대체 데이터 방출
        }
        .collect { value ->
            println("수신된 데이터: $value")
        }
}
// 출력 예시:
// 수신된 데이터: 데이터 1
// Flow에서 에러 발생: 데이터 로딩 중 에러 발생!
// 수신된 데이터: 복구 데이터

위 예시처럼 catch 블록 안에서 에러 메시지를 기록하거나, 사용자에게 에러를 알리는 UI를 업데이트하거나, 심지어는 다른 기본 데이터를 방출하여 Flow를 계속 이어갈 수도 있습니다. 중요한 점은 catch가 적용된 이후의 다운스트림(하위 Flow)은 에러 없이 계속 작동한다는 것입니다. 만약 catch 없이 에러가 발생하면, Flow는 즉시 종료되고 다운스트림으로 에러가 전파되어 앱이 비정상 종료될 수 있습니다.

retry, retryWhen을 이용한 재시도 전략

일시적인 네트워크 문제 등으로 인해 에러가 발생했을 때는 몇 번 재시도해보는 것이 좋은 전략입니다. Kotlin Flow는 retry와 retryWhen 연산자를 제공하여 이러한 재시도 로직을 쉽게 구현할 수 있습니다.

• retry(times: Long): 특정 횟수만큼 Flow를 재시도합니다.
• retryWhen(predicate: (cause: Throwable, attempt: Long) -> Boolean): 특정 조건에 따라 재시도 여부를 결정하고, 재시도 사이에 지연 시간을 줄 수도 있습니다.

var attemptCount = 0

fun unreliableDataFlow(): Flow<String> = flow {
    attemptCount++
    if (attemptCount < 3) {
        println("데이터 로딩 시도 #$attemptCount (실패)")
        throw Exception("네트워크 오류!")
    } else {
        println("데이터 로딩 시도 #$attemptCount (성공!)")
        emit("최종 데이터")
    }
}

suspend fun main() {
    unreliableDataFlow()
        .retry(2) // 최대 2번 재시도 (총 3번 시도)
        .catch { e -> println("최종 에러 발생: ${e.message}") } // 모든 재시도 실패 시
        .collect { value -> println("수신된 데이터: $value") }
}
// 출력 예시:
// 데이터 로딩 시도 #1 (실패)
// 데이터 로딩 시도 #2 (실패)
// 데이터 로딩 시도 #3 (성공!)
// 수신된 데이터: 최종 데이터

위 코드에서는 retry(2)를 사용하여 최대 2번의 재시도를 시도합니다. 즉, 원래 시도 1번 + 재시도 2번으로 총 3번의 시도가 이루어집니다. 3번째 시도에서 성공하면 데이터가 정상적으로 수신됩니다. 만약 모든 재시도가 실패하면 catch 블록으로 에러가 전달됩니다.

retryWhen을 사용하면 더욱 섬세한 재시도 로직을 구현할 수 있습니다. 예를 들어, 특정 종류의 에러에 대해서만 재시도하고, 재시도 사이에 점진적으로 대기 시간을 늘리는 백오프(Backoff) 전략을 적용할 수 있습니다. 이는 서버에 과도한 부하를 주지 않으면서도 일시적인 문제를 해결하는 데 효과적입니다.

Image by Pexels on Pixabay

Kotlin Flow 실전 점검 체크리스트

이제 Kotlin Flow를 실제 앱에 적용할 때 점검해야 할 중요한 사항들을 체크리스트 형태로 정리해 보겠습니다. 이 가이드를 통해 더 안정적이고 효율적인 앱을 만들 수 있을 거예요.

1. 적절한 Flow 타입 선택: 콜드 vs 핫 스트림
   • 콜드 스트림 (flow { ... }): 각 구독자에게 독립적인 데이터 흐름이 필요한 경우 (예: 한 번의 네트워크 요청). 불필요한 리소스 낭비를 줄입니다.
   • 핫 스트림 (StateFlow, SharedFlow): 여러 구독자가 동일한 데이터를 공유해야 하거나, 구독 여부와 관계없이 데이터가 지속적으로 생성되어야 하는 경우 (예: UI 상태, 실시간 이벤트).
2. 적절한 코루틴 스코프 사용
   • viewModelScope: ViewModel 내에서 Flow를 구독할 때 사용합니다. ViewModel이 파괴될 때 자동으로 코루틴이 취소되어 메모리 누수를 방지합니다.
   • lifecycleScope: Activity/Fragment 내에서 Flow를 구독할 때 사용합니다. 생명주기에 맞춰 코루틴이 시작/중지/취소됩니다.
   • GlobalScope: 사용을 지양합니다. 앱 전체 생명주기와 같아 제어가 어렵고 메모리 누수 위험이 큽니다.
3. 데이터 흐름 취소 관리
   • Flow는 코루틴의 취소 메커니즘을 따릅니다. collect를 호출하는 코루틴이 취소되면, Flow의 업스트림도 자동으로 취소됩니다.
   • onCompletion 연산자를 사용하여 Flow가 정상적으로 완료되거나 취소될 때 특정 작업을 수행할 수 있습니다 (예: 로딩 상태 해제).

   flow { emit("데이터") }
       .onCompletion { cause ->
           if (cause == null) println("Flow 정상 완료")
           else println("Flow 에러/취소로 완료: ${cause.message}")
       }
       .collect { /* ... */ }
           

4. 에러 처리 전략 수립 및 적용
   • catch 연산자: Flow 내에서 발생할 수 있는 예외를 처리하고, 복구 로직(대체 데이터 발행, 에러 메시지 UI 표시 등)을 구현합니다. 항상 collect 직전에 두는 것이 좋습니다.
   • retry / retryWhen: 일시적인 문제로 인한 실패에 대비하여 재시도 로직을 구현합니다. 특히 네트워크 관련 작업에 유용합니다.
   • UI 상태에 에러 반영: ViewModel의 StateFlow를 통해 에러 상태를 UI에 명확하게 전달하고, 사용자에게 적절한 피드백을 제공합니다.
5. 백프레셔(Backpressure) 관리
   • Flow는 기본적으로 백프레셔를 지원합니다. 이는 생산자(데이터를 만드는 쪽)가 소비자가 처리할 수 있는 속도보다 더 빠르게 데이터를 생산할 때, 소비자가 과부하되지 않도록 생산자의 속도를 조절하는 메커니즘입니다.
   • buffer, conflate, collectLatest 등의 연산자를 사용하여 필요에 따라 백프레셔 전략을 조절할 수 있습니다.
     • buffer(): 중간 버퍼를 두어 생산자와 소비자 속도 차이를 흡수합니다.
     • conflate(): 가장 최신 데이터만 유지하고 이전 데이터를 버립니다 (빠른 UI 업데이트에 유용).
     • collectLatest(): 새로운 데이터가 오면 이전 데이터 처리를 취소하고 최신 데이터만 처리합니다.
6. 테스트 용이성 확보
   • Flow는 테스트하기 쉽도록 설계되었습니다. runTest 코루틴 테스트 유틸리티를 사용하여 Flow의 동작을 검증합니다.
   • 특히 핫 스트림(StateFlow, SharedFlow)은 상태 변화를 쉽게 모의(mock)하고 검증할 수 있어 UI 테스트에 매우 유용합니다.

마무리하며: 지속 가능한 앱 개발을 위한 Kotlin Flow

지금까지 Kotlin Flow를 활용한 비동기 데이터 스트림 처리, 반응형 UI 설계, 그리고 견고한 에러 처리 전략에 대해 상세히 살펴보았습니다. Kotlin Flow는 코루틴의 강력함을 바탕으로 복잡했던 비동기 코드를 훨씬 직관적이고 안전하게 만들 수 있도록 돕는 도구입니다.

콜드 스트림과 핫 스트림의 차이를 이해하고, 앱의 각 계층에서 Flow를 어떻게 연결하며, 발생할 수 있는 에러들을 catch, retry 등의 연산자로 어떻게 현명하게 다룰 수 있는지에 대한 지식은 여러분의 앱을 더욱 튼튼하고 사용자 친화적으로 만드는 데 큰 도움이 될 것입니다.

특히, 모바일 앱 개발에서 사용자 경험은 앱의 성공을 좌우하는 중요한 요소입니다. Kotlin Flow는 반응형 UI를 통해 사용자가 느끼는 앱의 끊김 없는 흐름과 즉각적인 피드백을 구현하는 데 핵심적인 역할을 합니다. 이 점검 가이드가 여러분이 Kotlin Flow를 마스터하고, 더 나아가 지속 가능하고 고품질의 모바일 앱을 개발하는 데 든든한 나침반이 되기를 바랍니다.

Kotlin Flow를 사용하면서 겪었던 재미있는 경험이나 궁금한 점이 있다면 언제든지 댓글로 공유해주세요!

📌 함께 읽으면 좋은 글

• [모바일 앱 개발] 모바일 앱 푸시 알림, 그 동작 원리를 완벽하게 이해하는 방법
• [테스트 QA] 외부 API 의존성 테스트, 7가지 핵심 질문: Record/Replay vs Explicit Mocking 전략 가이드
• [AI 머신러닝] 산업 비정형 데이터 전이 학습: 실무에서 성공하는 7가지 모델 커스터마이징 전략

이 글이 도움이 되셨다면 공감(♥)과 댓글로 응원해 주세요!
궁금한 점이나 다루었으면 하는 주제가 있다면 댓글로 남겨주세요.