[Kotlin] 두 객체의 서로 다른 필드의 값 찾기

🛠️ 개발 환경

• kotlin : 1.8.22

💬 상황 설명

회사에서 개발을 하던 중, 동일한 클래스에 대한 두 인스턴스의 값을 비교해 다른 부분을 찾아 프론트에서 보여주는 로직이 필요했다.

enum class PostCategory(val title: String) {  
    C1("자유 게시판"), C2("정보 게시판")

    override fun toString(): String {  
        return title  
    }  
}

class Post() {  
    var title: String = ""  
    var content: String = ""  
    var isDeleted: Boolean = false
    var category: PostCategory = PostCategory.C1
    var writer: Member
}

예를 들어, 위와 같이 있을 때, 제목이 변경되었다면 (제목 : 기존 내용 -> 바뀐 내용) 이런 식으로 보여줘야하는 것이다. 우선 회사에서는 급하게 개발을 하다보니 다음과 같이 구현했다.

/**
* 변화된 부분을 찾아 리스트로 반환하는 함수
*/
fun findChanges(
    origin: Post, 
    target: Post
): List<Triple<String, String, String>> {  
    val list = mutableListOf<Triple<String, String, String>>()  

    if (origin.title != target.title) {  
        list += Triple("제목", origin.title, target.title)  
    }  

    if (origin.content != target.content) {  
        list += Triple("내용", origin.content, target.content)  
    }  

    if (origin.isDeleted != target.isDeleted) {  
        val t1 = if(origin.isDeleted) "삭제됨" else "삭제되지 않음"  
        val t2 = if(target.isDeleted) "삭제됨" else "삭제되지 않음"    
        list += Triple("삭제 여부", t1, t2)  
    }

    if (origin.category != target.category) {  
        list += Triple("카테고리", origin.category.title, target.category.title)  
    }

    return list  
}

예제에서는 필드가 4개인 간단한 Post를 예시로 작성했지만, 실제 코드에서 비교한 필드는 8가지 정도 된다. 이렇게 작성을 하다보니 모든 필드를 하나하나 직접 비교해야하는 번거로움이 있었고, 비교하는 과정에서 실수도 일어날 수 있어 위험한 코드라고 생각했다.

✅ 해결 과정

사실 현재 클래스에서만 이런 기능이 존재한다면 위 방식으로 구성해도 크게 문제가 없다. 하지만 나름 개발자로서 다른 곳에서도 사용할 수 있도록 만들고 싶은 욕심이 생겼고, 더 효율적으로 처리할 수 없을까에 대한 고민을 하게 되었다.

1. 요구 분석

현재 내가 만드려고 하는 기능이 무엇을 필요로 하는지 분석했다.

• 변경된 프로퍼티의 레이블
  • 예) title -> 제목
• 변경된 프로퍼티의 값
  • 예) Boolean -> 사용 함 / 사용하지 않음 || 삭제됨 / 삭제되지 않음

이것만 봐도 벌써 복잡하다. Boolean 타입이더라도 동일한 레이블을 사용하지 못하고, 클라이언트가 원하는 값을 넣을 수 있도록 해야 한다. 또한, 기획 의도에 의해 변경된 값들이 보여질 순서도 지정해줄 수 있어야 한다.

2. 틀 만들기

우선, 클라이언트에서 아래 클래스에 대한 리스트를 보내준다고 가정하자.

data class Item(  
    val order: Int,  
    val propertyName: String,  
    val label: String,  
    val v1: String = "",  
    val v2: String = ""  
)

val items = listOf(  
    Item(1, "title", "제목"),  
    Item(2, "writer", "작성자", origin.writer.username, changed.writer.username), 
    Item(3, "category", "카테고리"),  
    Item(4, "isDeleted", "삭제여부", "삭제됨", "삭제되지 않음")
)

findChanges(items)

해당 정보를 토대로 리플렉션을 사용해 제네릭으로 들어온 클래스에 대한 정보를 받고, 해당 클래스가 갖고 있는 각각의 필드를 순회하며, 클라이언트가 보내준 필드와 일치하는지 비교할 것이다.

이제 클래스 내부에 다른 객체를 참조하고 있는 경우도 있으니, 정확한 비교를 할 수 있도록 equals, hashCode를 구현하게 강제해보자.

interface Detectable {  
    override fun hashCode(): Int  
    override fun equals(other: Any?): Boolean  
}

class Post(  
    val title: String = "",  
    val content: String = "",  
    val isDeleted: Boolean = false,  
    val category: PostCategory = PostCategory.C1,  
    val writer: Member  
) : Detectable {

    override fun equals(other: Any?): Boolean {  
        ...
    }  

    override fun hashCode(): Int {  
        ...
    }  

}

위와 같이 Detectable 인터페이스를 구현하도록 하면, 내부에 다른 객체를 참조하고 있더라도 정확한 비교를 할 수 있게 된다.

3. 구현

앞서 설명한 것과 같이 리플렉션을 사용해 제네릭에 대한 클래스를 받아올 것이다. 그러기 위해서는 런타임에도 타입 정보가 살아있어야 하기 때문에 inline 함수와 reified를 사용할 것이다.

/**  
* 두 객체를 비교해 변경된 부분을 찾는 함수  
* @param origin 기존 객체  
* @param target 비교 대상 객체  
* @param itemList 변경을 감지할 아이템 리스트  
* */  
inline fun <reified T : Detectable> findChanges(  
    origin: T,  
    target: T,  
    itemList: List<Item>  
): List<Item> { ... }

inline 함수를 사용하면, 함수 호출부가 함수 본문으로 대치된다. 덕분에 reified를 사용해 런타임에도 제네릭 타입 정보를 갖고 있을 수 있게 된다. 만약 일반 함수와 reified 키워드를 사용하지 않을 경우, 다음과 같은 에러가 발생한다.

Cannot use 'T' as reified type parameter. Use a class instead.

제네릭은 런타임에 타입 정보가 소거되기 때문에 타입 정보를 실체화 해주기 위해 reified 키워드를 사용해야 한다. 해당 키워드는 inline 함수에서 사용이 가능하다. 또한, T는 기본적으로 Any?를 상한으로 지정하기 때문에 Detectable을 구현한 구현체만 들어올 수 있도록 한다.

Kotlin in action 8장(고차 함수; 파라미터와 반환 값으로 람다 사용)에 대한 내용을 보면, inline 함수는 람다와 사용할 때만 사용하는 것을 추천한다고 한다. 하지만 클래스로 만들기엔 애매하니 우선 진행하도록 하겠다.

이제 ...에 대한 내용을 구현해보자.

// 실체화된 T 타입의 클래스 정보 받아오기
val clazz = T::class // Type: KClass<T>

// 결과 리스트를 담을 Item 리스트
val result = mutableListOf<Item>()

for (property in clazz.memberProperties) {  
    val propertyName = property.name
    itemList.find { it.propertyName == propertyName }?.let {  
        ...
    }  
}

위와 같이 clazz가 갖고있는 멤버 프로퍼티들을 가져와 iterator를 돌려주고, 해당 프로퍼티의 이름이 클라이언트가 보내준 itemList에 포함되어 있는지 검사해준다. 만약 포함이 되어있을 경우 값에 대한 비교를 진행해주기만 하면 끝난다.

// 기존 객체의 값
val originValue = property.get(origin).toString()  
// 타겟 객체의 값
val targetValue = property.get(target).toString()  

// 두 값이 다른지 비교
if (originValue != targetValue) {  
    // item 객체의 v1이 비어있을 경우 originValue를 그대로 사용
    val v1 = it.v1.ifEmpty { originValue }  
    // item 객체의 v2가 비어있을 경우 targetValue를 그대로 사용
    val v2 = it.v2.ifEmpty { targetValue }  

    // 결과 리스트에 추가
    result += Item(it.order, it.propertyName, it.label, v1, v2)  
}

기존에는 내가 모든 필드를 비교해야 했지만, 이제는 다음과 같이 간단하게 리스트만 만들어서 함수를 호출하기만 하면 두 객체의 값을 쉽게 비교할 수 있다.

val items = listOf(  
   Item(1, "title", "제목"),  
   Item(2, "writer", "작성자", origin.writer.username, changed.writer.username),
   Item(3, "category", "카테고리"),  
   Item(4, "isDeleted", "삭제여부", "삭제됨", "삭제되지 않음")  
)

전체 코드와 결과 값은 아래와 같다.

/**  
 * 두 객체를 비교해 변경된 부분을 찾는 함수  
 * @param origin 기존 객체  
 * @param target 비교 대상 객체  
 * @param itemList 변경을 감지할 아이템 리스트  
* */  
inline fun <reified T : Detectable> findChanges(  
    origin: T,  
    target: T,  
    itemList: List<Item>  
): List<Item> {  
    val clazz = T::class  

    val result = mutableListOf<Item>()  

    for (property in clazz.memberProperties) {  
        val propertyName = property.name  

        itemList.find { it.propertyName == propertyName }?.let {  
            val originValue = property.get(origin).toString()  
            val targetValue = property.get(target).toString()  

            if (originValue != targetValue) {  
            val v1 = it.v1.ifEmpty { originValue }  
            val v2 = it.v2.ifEmpty { targetValue }  

            result += Item(it.order, it.propertyName, it.label, v1, v2)  
            }  
        }  
    }  
    return result.sortedBy { it.order }  
}

// 결과 (title은 값이 동일하기 때문에 결과 리스트에 추가되지 않음)
[Item(order=2, field=category, label=카테고리, v1=자유 게시판, v2=정보 게시판),
Item(order=3, field=isDeleted, label=삭제여부, v1=삭제됨, v2=삭제되지 않음),
Item(order=4, field=writer, label=작성자, v1=admin, v2=tester)]

🤔 회고

코틀린을 시작한지 2달 정도인지라 많이 미숙하다. 사실 처음에 비교한 방식은 O(N) 만큼의 복잡도를 가지지만, 변경한 코드는 O(N^2) 만큼의 복잡도를 가진다. 때문에 처음에 비교한 방식이 성능적으로 더 좋지만, 하나하나 비교를 한다는 것은 불편하기 때문에 이정도의 성능 차이는 감수해야할 것 같다. 이보다 더 효율적으로 만들 수 있을지 더 고민해보고, 리팩터링하는 시간을 가져야겠다!

레퍼런스

• Kotlin In Action - Chapter08; 고차 함수; 파라미터와 반환 값으로 람다 사용
• Kotlin In Action - Chapter09; 제네릭스