☺️Android : flow를 순차적으로 사용해보자~!

요구사항 정리하기 

구현해야할 요구사항은 아래와 같다.

ㅌ

먼저 상황을 이해해보면

기존에는 팔로우 여부에 따른 처리없이 팔로워 리스트를 리사이클러뷰로 보여주었다.

따라서 Flow<팔로워 리스트>를 반환하는  유즈케이스를 통해 데이터를 받은 후 이를 StateFlow 변수에 넣어주고 UI를 업데이트해주었다. 

 

추가된 사항은 내가 해당 유저에 대한 팔로우 여부에 따라 UI요소에 변화를 주는 것이었다.

따라서 팔로우 리스트를 반환하는 유즈 케이스와 유저에 대한 팔로우 여부를 반환하는 유즈 케이스를 결합한 후 결합한 데이터를 리사이클러뷰에 전달해주어야했다.

 

그렇다면 두 데이터를 어떻게 결합하면 좋을까? 

 

찾아본 결과 combine과 zip, flatMapLatest에 대해서 나왔다. 

 flow를 collect하는 것과 어떻게 다르고, 각 차이가 뭔지, 내 기능 구현에는 어떤 방식이 적합한지 알아본 과정을 정리해서 기록해두려고 한다.

---

 flow를 collect 하는 것의 의미

flow는 여러 값을 순차적으로 내보낼 수 있는 데이터 스트림이다. 

flow를 collect하게 되면 데이터 방출이 시작되고, 방출된 순서대로 처리할 수 있다. 

collect 연산자는 각 값을 수신할 때까지 일시 중지하고 각 값을 순차적으로 처리한다. 

flow의 생성부터 처리까지의 흐름을 그려보았다

1️⃣ map 사용 

Map을 통해 기존 flow를 변환시켜 내보낼 수 있다. 

팔로워 리스트를 가져와서 followerUserInfoList.map을 통해 각 팔로워 유저에 대해 내가 팔로잉 중인지 여부를 확인하는 유즈 케이스 호출 후 데이터를 결합해서 _mutualFollowerList.value에 반영해주었다. 

 fun getFollowerList(userId: String) {
            viewModelScope.launch {
                getFollowerListUseCase(userId)
                    .map {
                        it.followerUserInfoList
                            .map { userInfo ->
                                userInfo.userId?.let { it1 ->
                                    val isFollowing = checkIsFollowUseCase(it1).first()?.isFollowing ?: false
                                    MutualFollowUserInfo(
                                        email = userInfo.email,
                                        userId = userInfo.userId,
                                        type = userInfo.type,
                                        nickname = userInfo.nickname,
                                        profileUrl = userInfo.profileUrl,
                                        lastLoginDate = userInfo.lastLoginDate,
                                        introduction = userInfo.introduction,
                                        roles = userInfo.roles,
                                        createDate = userInfo.createDate,
                                        lastModifiedDate = userInfo.lastModifiedDate,
                                        isFollowing = isFollowing,
                                    )
                                } ?: MutualFollowUserInfo()
                            }
                    }.collect {
                        _mutualFollowerList.value = it
                    }
            }
        }

map으로 구현한 결과이다.

 

이 코드로 기능은 정상적으로 작동할 수 있지만 모두 순차적으로 처리된다는 단점이 있다. 모두 순차적으로 처리되는 경우 팔로워 리스트가 많아지면 느려질 수 있겠다 

순차 과정 확인 로그 : 각 아이템에 대해 시작 ~ 완료가 순차적으로 이루어진다.

---

결과

현재 구현할 로직의 경우 각 팔로워에 대한 userId를 이용해서 나의 해당 유저에 대한 팔로우 여부를 얻어야한다.

즉  각 팔로워에 대한 userId -> 팔로우 여부 라는 순서가 존재한다.

 

따라서 map을 통해 순차적으로 처리하는 것이 적절하다고 생각했다. 

그러나 만약 팔로워 리스트가 늘어나서 순차적 처리에 느린 속도가 느껴진다면 병렬 처리로 개선해보기로 한다.

---

병렬 처리 방식에 대해 궁금해서 테스트해보았다!

➕map & combine을 통해 병렬로 처리하기

병렬로 처리했을 때의 출력

아까 map으로 순차처리했을 때와 달리 combine을 통해 병렬로 처리해준 경우 팔로워에 대해서 상태 확인 시작 ~ 완료가 끝난 후 다음 팔로워에 대한 로직이 수행되는 것이 아니라 각  팔로워에 대한 상태 확인 시작 ~ 완료까지가 병렬로 이루어지고  있다.

코드를 보면 아래와 같다!

     // 2 . 병렬 처리(map & combine 사용)
        fun getFollowingListParallel(userId: String) {
            viewModelScope.launch {
                getFollowingListUseCase(userId)
                    .map { followingResponse ->
                        println("1. 팔로잉 응답 처리 시작")
                        // null 체크 후 리스트 가져오기
                        val userList = followingResponse?.followingUserInfoList ?: emptyList()

                        // 각 사용자별로 Flow 생성
                        val followStatusFlows =
                            userList.map { user ->
                                println("2. 사용자 ${user.userId} 팔로우 상태 확인 시작")
                                // 각 사용자의 팔로우 상태를 확인하는 Flow 생성
                                checkIsFollowUseCase(user.userId ?: "").map { followResponse ->
                                    println("3. 사용자 ${user.userId} 팔로우 상태 확인 완료")
                                    MutualFollowUserInfo(
                                        email = user.email,
                                        userId = user.userId,
                                        type = user.type,
                                        nickname = user.nickname,
                                        profileUrl = user.profileUrl,
                                        lastLoginDate = user.lastLoginDate,
                                        introduction = user.introduction,
                                        roles = user.roles,
                                        createDate = user.createDate,
                                        lastModifiedDate = user.lastModifiedDate,
                                        isFollowing = followResponse?.isFollowing,
                                    )
                                }
                            }

                        // Flow 리스트가 비어있는 경우 처리
                        if (followStatusFlows.isEmpty()) {
                            flow { emit(emptyList()) }
                        } else {
                            // combine을 사용해 모든 Flow를 병렬로 처리
                            println("4. 팔로잉 리스트 병렬 처리 시작")
                            combine(followStatusFlows) { userInfoArray ->
                                println("5. 팔로잉 리스트 병렬 처리 완료")
                                userInfoArray.toList()
                            }
                        }
                    }.collect {
                    
                    // 여기서는 결과가 Flow 형태로 와서 어떻게 변화를 해줄 지 모르겠어서 일단 first()를 사용해주었다. 
                        _followingList.value = it.first()
                    }
            }
        }

 

map과 combine에 대한 설명

- map : 원래의 Flow에서 각 값에 변환 함수를 적용한 결과를 포함한 flow를 반환해준다.

- combine : 각 flow에서 방출된 가장 최근의 값을 결합하여 변환 함수를 적용하여 생성된 값들의 flow를 반환한다.

combine을 통해서는 각 Flow가 동시에 독립적으로 값을 방출할 수 있어 병렬 처리가 가능하다. 

 

공식 예제는 아래와 같다. 

val flow = flowOf(1, 2).onEach { delay(10) }
val flow2 = flowOf("a", "b", "c").onEach { delay(15) }
combine(flow, flow2) { i, s -> i.toString() + s }.collect {
    println(it) // Will print "1a 2a 2b 2c"
}

 

그런데 이럴 경우 나는 팔로워 리스트 얻기 ->  각 팔로워 리스트의 userId 얻기 -> userId로 팔로우 여부 확인하기

를 처리해줘야한다.

이 때 combine으로 할 경우 팔로잉 여부를 얻기 전에 가장 최근의 값이 B 팔로워 리스트의 값 true였을 경우에 A 팔로워 리스트에  B 팔로워 여부가 적용되는 문제가 생길 수도 있을까??

결론부터 말하면 아니었다

 

나의 경우 각 팔로워에 대하여 userId를 이용해서 팔로우 여부를 얻고 있다. 구체적으로 풀어보면 

- checkIsFollowUseCase는 각 팔로워의 userId에 따라 고유의 flow로 작동하고 있다. 

- combine은 각 flow에서 방출된 최신값들을 모아 배열로 생성하므로 , 각 팔로워에 대해 조회된 팔로워 상태가 다른 팔로워의 정보와 섞이지 않는다.

 

즉 combine을  통해 사용하면 각 팔로워에 대한 나의 팔로우 정보를 매핑하고 병렬로 처리해줄 수 있다.