[Intellij] 안전한 리팩터링 진행하기 - Intellij를 활용한 점진적 리팩터링

🌱 들어가기 전

나는 평소에 마우스는 사용하지 않지만, 맥북 터치패드를 정말 많이 사용하는 편이었어서 개발할 때 단축키를많이 사용하지 않는 편이었다. 그러다 보니 자동으로 개발할 때 미묘하게 속도 차이가 났었는데, 이번에 단축키도 공부할겸, 리팩터링 시 어떻게 하면 Intellij 를 최대한 활용할 수 있는지 스터디 하는 시간을 가졌다. (갓나니개발자님 덕분에 많이 배울 수 있는 시간이었다 ㅎ_ㅎ)

 

이번 포스팅에서 사용된 샘플 코드는 백명석 님의 깃허브를 가면 확인할 수 있는데, 나는 사내에서 코틀린을 사용하고 있다 보니까 해당 코드를 코틀린 + Kotest로 변환하여 연습을 해보았다.

 

어떤 식으로 리팩터링을 했는지는 아래의 레파지토리에 커밋별로 나타내었다.

GitHub - Cl8D/kotlin-expense: rafactoring practice

main 브랜치의 경우 리팩터링 이전의 코드이고, refactoring 브랜치를 가면 점진적 리팩터링 과정을 참고할 수 있으니 혹시 필요한 분이 계시다면 참고하면 좋을 것 같다.

 

 

---

 

🌱 원본 코드의 문제점 

우선, 리팩터링이 되기 이전의 샘플 코드이다.

class Expense(
    var type: Type,
    var amount: Int
) {
    enum class Type {
        DINNER,
        BREAKFAST,
        CAR_RENTAL
    }
}

interface ReportPrinter {
    fun print(text: String?)
}

class ExpenseReport {
    private val expenses: MutableList<Expense> = ArrayList()
    private val date: String
        get() = "9/12/2002"
    
    fun printReport(printer: ReportPrinter) {
        var total = 0
        var mealExpenses = 0
        printer.print("Expenses " + date + "\\n")

        for (expense in expenses) {
            if (expense.type == Expense.Type.BREAKFAST || expense.type == Expense.Type.DINNER) {
                mealExpenses += expense.amount
            }
            var name = "TILT"

            when (expense.type) {
                Expense.Type.DINNER -> name = "Dinner"
                Expense.Type.BREAKFAST -> name = "Breakfast"
                Expense.Type.CAR_RENTAL -> name = "Car Rental"
            }

            printer.print(
                String.format(
                    "%s\\t%s\\t$%.02f\\n",
                    if (expense.type == Expense.Type.DINNER
                        && expense.amount > 5000
                        || expense.type === Expense.Type.BREAKFAST
                        && expense.amount > 1000) "X" else " ",
                    name, expense.amount / 100.0
                )
            )
            total += expense.amount
        }
        printer.print(String.format("\\nMeal expenses $%.02f", mealExpenses / 100.0))
        printer.print(String.format("\\nTotal $%.02f", total / 100.0))
    }

    fun addExpense(expense: Expense) {
        expenses.add(expense)
    }
}

 

앞으로 위의 코드가 우리가 원하는 시나리오대로 잘 동작하는지 검증할 수 있도록, 아래의 테스트 코드를 사용할 것이다.

모든 리팩터링의 시작은, ‘우리가 코드를 수정하더라도 정상적으로 작동하는 것을 보장받을 수 있는가?’로부터 시작하는 것 같다. 실무에서는 테스트 코드가 작성되어 있지 않다면 어렵겠지만, 웬만하면 리팩터링을 진행할 때 테스트 코드를 함께 동반하는 것이 좋은 것 같다.

class MockReportPrinter : ReportPrinter {
    private var printedText = ""

    override fun print(text: String?) {
        printedText += text

    }

    fun getText(): String {
        return printedText
    }
}

internal class ExpenseReportTest : StringSpec({
    lateinit var report: ExpenseReport
    lateinit var printer: MockReportPrinter

    beforeTest {
        report = ExpenseReport()
        printer = MockReportPrinter()
    }

    "printEmpty" {
        report.printReport(printer)

        printer.getText() shouldBe """
            Expenses 9/12/2002

            Meal expenses $0.00
            Total $0.00
        """.trimIndent()
    }

    "printOneDinner" {
        report.addExpense(Expense(Expense.Type.DINNER, 1678))
        report.printReport(printer)

        printer.getText() shouldBe """
            Expenses 9/12/2002
             	Dinner	$16.78

            Meal expenses $16.78
            Total $16.78
        """.trimIndent()
    }

    "twoMeals" {
        report.addExpense(Expense(Expense.Type.DINNER, 1000))
        report.addExpense(Expense(Expense.Type.BREAKFAST, 500))
        report.printReport(printer)

        printer.getText() shouldBe """
            Expenses 9/12/2002
             	Dinner	$10.00
             	Breakfast	$5.00

            Meal expenses $15.00
            Total $15.00
        """.trimIndent()
    }

    "twoMealsAndCarRental" {
        report.addExpense(Expense(Expense.Type.DINNER, 1000))
        report.addExpense(Expense(Expense.Type.BREAKFAST, 500))
        report.addExpense(Expense(Expense.Type.CAR_RENTAL, 50000))
        report.printReport(printer)

        printer.getText() shouldBe """
            Expenses 9/12/2002
             	Dinner	$10.00
             	Breakfast	$5.00
             	Car Rental	$500.00

            Meal expenses $15.00
            Total $515.00
        """.trimIndent()
    }

    "overages" {
        report.addExpense(Expense(Expense.Type.BREAKFAST, 1000))
        report.addExpense(Expense(Expense.Type.BREAKFAST, 1001))
        report.addExpense(Expense(Expense.Type.DINNER, 5000))
        report.addExpense(Expense(Expense.Type.DINNER, 5001))
        report.printReport(printer)

        printer.getText() shouldBe """
            Expenses 9/12/2002
             	Breakfast	$10.00
            X	Breakfast	$10.01
             	Dinner	$50.00
            X	Dinner	$50.01

            Meal expenses $120.02
            Total $120.02
        """.trimIndent()
    }
})

 

 

기존의 코드의 경우 다음과 같은 문제점이 존재한다.

1. ExpenseReport 가 하고 있는 일이 너무 많음
2. 비용에 대한 계산을 하는 함수와 출력에 대한 함수가 합쳐져 있어서 기능 자체의 결합도가 높음
3. 비용에 대한 변수의 스코프가 printReport() 함수의 지역 변수로 선언되어 있어, 개발자가 인지하기가 어려움.
4. 비용에 대한 타입이 추가되었을 때 확장하기가 어려움

 

그래서 우리는 위의 문제점을 최대한 수정할 수 있도록 점진적인 리팩터링을 진행할 것이다.

 

---

 

🌱 Step1 - 가장 간단한 부분에 대해서 함수로 분리하기

fun printReport(printer: ReportPrinter) {
    var total = 0
    var mealExpenses = 0
    printer.print("Expenses " + date + "\\n")

    for (expense in expenses) {
        if (expense.type == Expense.Type.BREAKFAST || expense.type == Expense.Type.DINNER) {
            mealExpenses += expense.amount
        }
        var name = "TILT"

        when (expense.type) {
            Expense.Type.DINNER -> name = "Dinner"
            Expense.Type.BREAKFAST -> name = "Breakfast"
            Expense.Type.CAR_RENTAL -> name = "Car Rental"
        }

        printer.print(
            String.format(
                "%s\\t%s\\t$%.02f\\n",
                if (expense.type == Expense.Type.DINNER
                    && expense.amount > 5000
                    || expense.type === Expense.Type.BREAKFAST
                    && expense.amount > 1000) "X" else " ",
                name, expense.amount / 100.0
            )
        )
        total += expense.amount
    }
    printer.print(String.format("\\nMeal expenses $%.02f", mealExpenses / 100.0))
    printer.print(String.format("\\nTotal $%.02f", total / 100.0))
}

 

먼저, 위 함수에서 분리할 수 있는 부분을 최대한 추출하여 함수로 만들어보자.

 

우리는 위의 함수를 크게 3가지 부분으로 분리할 수 있다.

1. 헤더 정보 출력하기
2. 비용을 계산하고 중간 계산 결과를 출력하기
3. 최종 비용을 출력하기

 

비교적 복잡한 2번 내용을 우선 배제하고, 1번과 3번 내용을 추출하기 위해 다음과 같이 함수로 추출하자.

이때, 1번 내용에서 total, mealExpenses 는 헤더 정보를 출력하기 위해 사용되는 정보는 아니기 때문에 선언된 변수를 2번 부분에게 내릴 수 있으며, 3번 부분의 경우 파라미터를 통해 total, mealExpenses를 넘겨주면 되기 때문에 크게 무리가 없다.

 

command + option + m (extract method) 을 통해 각각을 함수로 분리하자.

그럼 아래와 같이 분리가 되었을 텐데, 테스트 코드를 통해서 아직 기능이 잘 작동하는지 체크하자.

 

fun printReport(printer: ReportPrinter) {
    printHeader(printer)
    var total = 0
    var mealExpenses = 0

    for (expense in expenses) {
        if (expense.type == Expense.Type.BREAKFAST || expense.type == Expense.Type.DINNER) {
            mealExpenses += expense.amount
        }
        var name = "TILT"

        when (expense.type) {
            Expense.Type.DINNER -> name = "Dinner"
            Expense.Type.BREAKFAST -> name = "Breakfast"
            Expense.Type.CAR_RENTAL -> name = "Car Rental"
        }

        printer.print(
            String.format(
                "%s\\t%s\\t$%.02f\\n",
                if (expense.type == Expense.Type.DINNER
                    && expense.amount > 5000
                    || expense.type === Expense.Type.BREAKFAST
                    && expense.amount > 1000) "X" else " ",
                name, expense.amount / 100.0
            )
        )
        total += expense.amount
    }
    printTotal(printer, mealExpenses, total)
}

private fun printTotal(printer: ReportPrinter, mealExpenses: Int, total: Int) {
    printer.print(String.format("\\nMeal expenses $%.02f", mealExpenses / 100.0))
    printer.print(String.format("\\nTotal $%.02f", total / 100.0))
}

private fun printHeader(printer: ReportPrinter) {
    printer.print("Expenses " + date + "\\n")
}

 

테스트가 정상적으로 통과한다면, 안심하고 다음 스텝으로 넘어가보자.

 

---

 

🌱 Step 2 - 비즈니스 로직과 출력을 분리하자

이 다음에는 2번 부분을 뿌실 차례이다. 해당 부분은 출력과 계산이 함께 혼합되어 있기 때문에 분리하기가 현재로서는 어려우니, 반복문을 2개로 분리하여 출력과 계산을 분리해보자.

 

마찬가지로 분리 후에도 테스트 코드를 실행해보자. 잘 통과하는 모습을 볼 수 있을 것이다.

참고로, 코드 블록을 선택할 때 option + 방향키 윗키를 누르게 되면 블록별로 한 번에 select를 할 수 있다.

터치패드나 마우스를 쓰지 않고도 블록을 선택할 수 있는 좋은 키이다.

fun printReport(printer: ReportPrinter) {
    printHeader(printer)
    var total = 0
    var mealExpenses = 0

    for (expense in expenses) {
        if (expense.type == Expense.Type.BREAKFAST || expense.type == Expense.Type.DINNER) {
            mealExpenses += expense.amount
        }
        total += expense.amount
    }

    for (expense in expenses) {
        var name = "TILT"

        when (expense.type) {
            Expense.Type.DINNER -> name = "Dinner"
            Expense.Type.BREAKFAST -> name = "Breakfast"
            Expense.Type.CAR_RENTAL -> name = "Car Rental"
        }

        printer.print(
            String.format(
                "%s\\t%s\\t$%.02f\\n",
                if (expense.type == Expense.Type.DINNER
                    && expense.amount > 5000
                    || expense.type === Expense.Type.BREAKFAST
                    && expense.amount > 1000) "X" else " ",
                name, expense.amount / 100.0
            )
        )
    }

    printTotal(printer, mealExpenses, total)
}

 

그렇다면, 이제 비용을 계산하는 부분에 대해서 함수로 분리해보자.

이때, Intellij의 도움을 받는다면 꽤나 이상한 형태로 분리를 해주는 모습을 볼 수 있다.

private fun calculateExpense(): Pair<Int, Int> {
    var total = 0
    var mealExpenses = 0

    for (expense in expenses) {
        if (expense.type == Expense.Type.BREAKFAST || expense.type == Expense.Type.DINNER) {
            mealExpenses += expense.amount
        }
        total += expense.amount
    }
    return Pair(total, mealExpenses)
}

 

위와 같이 Pair를 통해서 분리를 해주려고 한다. Pair의 경우 first, second 를 통해서 각각의 변수에 접근할 수 있지만, 읽는 사람의 입장에서 각 변수가 무엇을 뜻하는지 인지하기가 어려워진다.

그래서, 이 방법 대신에 total, mealExpenses의 변수를 클래스의 변수로 옮겨서, 실질적으로 해당 함수에는 클래스의 변수를 접근하여 값을 계산할 수 있도록 만들어보자.

 

이때, 자바에서는 해당 변수에 커서를 대고 command + option + F (extract field)를 누르게 되면, 아래와 같이 해당 변수를 어디로 옮길지 선택할 수 있는 창이 뜨게 된다.

하지만, 코틀린에서는 var 변수의 경우 잘 동작하지 않아서 수동으로 옮겨주었다. (val 변수면 괜찮을 것 같은데, var 변수여서 잘 적용이 안 된 것 같아서 아쉽다.)

class ExpenseReport {  
    private var total = 0
    private var mealExpenses = 0
		....
}

 

이제, 비즈니스 로직에 대해서 함수로 분리를 해보자. 비용에 대한 계산을 진행하고 있으니, calculateExpense 라는 이름을 붙였다.

private fun calculateExpenses() {
    for (expense in expenses) {
        if (expense.type == Expense.Type.BREAKFAST || expense.type == Expense.Type.DINNER) {
            mealExpenses += expense.amount
        }
        total += expense.amount
    }
}

 

이 함수는 현재 if문이 하는 일을 정확하게 알기 어려우니, 해당 부분도 함수로 분리해보자.

비용의 타입이 아침이나 저녁인 경우 mealExpenses를 더하고 있으니, 간단하게 isMeal 이라는 네이밍을 붙여주었다.

private fun calculateExpenses() {
    for (expense in expenses) {
        if (isMeal(expense)) {
            mealExpenses += expense.amount
        }
        total += expense.amount
    }
}

private fun isMeal(expense: Expense) = expense.type == Expense.Type.BREAKFAST || expense.type == Expense.Type.DINNER

 

여전히 함수가 2 depth 여서 알아보기가 어렵다. 한 번 더 분리를 해주자.

private fun calculateExpenses() {
    for (expense in expenses) {
        addTotal(expense)
    }
}

private fun addTotal(expense: Expense) {
    if (isMeal(expense)) {
        mealExpenses += expense.amount
    }
    total += expense.amount
}

 

 

마찬가지로, 출력에 대한 부분도 함수로 분리해보자.

private fun printExpenses(printer: ReportPrinter) {
    for (expense in expenses) {
        var name = "TILT"

        when (expense.type) {
            Expense.Type.DINNER -> name = "Dinner"
            Expense.Type.BREAKFAST -> name = "Breakfast"
            Expense.Type.CAR_RENTAL -> name = "Car Rental"
        }

        printer.print(
            String.format(
                "%s\t%s\t$%.02f\n",
                if (expense.type == Expense.Type.DINNER
                    && expense.amount > 5000
                    || expense.type === Expense.Type.BREAKFAST
                    && expense.amount > 1000
                ) "X" else " ",
                name, expense.amount / 100.0
            )
        )
    }
}

 

위 함수에서도 크게 2가지로 분리할 수 있게 된다.

1. 비용에 대한 이름을 계산하기
2. 실질적으로 비용에 대한 이름을 출력하기

 

이에 따라서 함수를 또 2개로 분리하였다.

이때, name의 경우 함수로부터 얻어오게 되기 때문에 더 이상 var 로 있을 필요가 없기 때문에 val로 변경해주었다.

private fun printExpenses(printer: ReportPrinter) {
    for (expense in expenses) {
        val name = getName(expense)

        printer.print(
            String.format(
                "%s\\t%s\\t$%.02f\\n",
                if (expense.type == Expense.Type.DINNER
                    && expense.amount > 5000
                    || expense.type === Expense.Type.BREAKFAST
                    && expense.amount > 1000
                ) "X" else " ",
                name, expense.amount / 100.0
            )
        )
    }
}

private fun getName(expense: Expense): String {
    var name = "TILT"

    when (expense.type) {
        Expense.Type.DINNER -> name = "Dinner"
        Expense.Type.BREAKFAST -> name = "Breakfast"
        Expense.Type.CAR_RENTAL -> name = "Car Rental"
    }
    return name
}

 

여기까지 진행하고, 마찬가지로 테스트 코드를 통해 중간중간 체크를 진행해주자.

 

---

 

🌱 Step3 - 불필요한 메서드 파라미터 제거하기

Step 1, 2를 진행하면서 가장 메인이 되면 public 함수인 printReport() 가 간결해진 것을 확인할 수 있다.

class ExpenseReport {
    private val expenses: MutableList<Expense> = ArrayList()
    private val date: String
        get() = "9/12/2002"

    private var total = 0
    private var mealExpenses = 0

    fun printReport(printer: ReportPrinter) {
        printHeader(printer)
        calculateExpenses()
        printExpenses(printer)
        printTotal(printer, mealExpenses, total)
    }

    private fun printExpenses(printer: ReportPrinter) {
        for (expense in expenses) {
            val name = getName(expense)

            printer.print(
                String.format(
                    "%s\t%s\t$%.02f\n",
                    if (expense.type == Expense.Type.DINNER
                        && expense.amount > 5000
                        || expense.type === Expense.Type.BREAKFAST
                        && expense.amount > 1000
                    ) "X" else " ",
                    name, expense.amount / 100.0
                )
            )
        }
    }

    private fun getName(expense: Expense): String {
        var name = "TILT"

        when (expense.type) {
            Expense.Type.DINNER -> name = "Dinner"
            Expense.Type.BREAKFAST -> name = "Breakfast"
            Expense.Type.CAR_RENTAL -> name = "Car Rental"
        }
        return name
    }

    private fun calculateExpenses() {
        for (expense in expenses) {
            addTotal(expense)
        }
    }

    private fun addTotal(expense: Expense) {
        if (isMeal(expense)) {
            mealExpenses += expense.amount
        }
        total += expense.amount
    }

    private fun isMeal(expense: Expense) = expense.type == Expense.Type.BREAKFAST || expense.type == Expense.Type.DINNER

    private fun printTotal(printer: ReportPrinter, mealExpenses: Int, total: Int) {
        printer.print(String.format("\nMeal expenses $%.02f", mealExpenses / 100.0))
        printer.print(String.format("\nTotal $%.02f", total / 100.0))
    }

    private fun printHeader(printer: ReportPrinter) {
        printer.print("Expenses " + date + "\n")
    }

    fun addExpense(expense: Expense) {
        expenses.add(expense)
    }
}

 

크게 헤더를 출력하기 / 비용을 계산하기 / 비용을 출력하기 / 총 합계를 출력하기, 이렇게 4가지로 분리되었다.

그러나, 함수로 추출하면서 parameter drilling 으로 인해 필요가 없음에도 인자로 계속 넘겨주는 부분들이 눈에 들어올 것이다.

이번 단계에서는 해당 부분에 대해 제거해보고자 한다.

 

가장 눈에 띄는 것은 ReportPrinter 가 계속해서 인자로 넘어가고 있다는 점이다.

해당 부분을 제거하기 위해, 마찬가지로 ReportPrinter에 대해 클래스의 변수로 승격시키는 작업을 진행해보자.

 

마찬가지로 자바 코드였다면 command + option + F 를 통해서 잘 추출이 되지만, 코틀린이기 때문에 우선 수기로 추출을 진행해주었다. 이때, printer의 경우 NPE 방지를 위해서 lateinit 을 통해 지연 초기화가 가능하도록 설정해주었다.

private lateinit var printer: ReportPrinter

fun printReport(printer: ReportPrinter) {
    this.printer = printer
    printHeader(printer)
    calculateExpenses()
    printExpenses(printer)
    printTotal(printer, mealExpenses, total)
}

 

 

이러면, 클래스의 필드 레벨에서 printer가 선언이 되어 있기 때문에 더 이상 인자로 계속 넘겨줄 필요가 없어진다.

자바라면 대상이 되는 함수에서 command + option + n (Inline Parameter) 을 누르면 위와 같이 클래스의 변수로 선언된 값을 사용하도록 쉽게 리팩터링이 가능하다.

 

하지만, 코틀린이라서 그런지 잘 동작하지 않아 command + F6 (Change Signature) 를 통해서 인자로 넘어온 printer 를 제거해주었다. printer를 인자로 받는 함수들에 대해서 모두 적용해보도록 하자.

 

참고로 내부적으로 지울 때는 command + backspace를 활용하고 command + enter를 누르면 변경된 내용이 적용된다. (이런 부분에 대해서도 터치패드를 사용하지 않는 노력을 하는 것이 좋을 것 같다.)

이 과정에서 conflict view가 나오면 continue로 타겟을 옮긴 다음 space를 눌려주면 적용된다!

 

그럼 여기까지 했을 때 아래와 같은 모습이 나올 것이며, 한 번 더 테스트 코드를 돌려 체크해주자.

cf) 테스트 코드를 실행할 때도 control + r (바로 이전의 실행 내역 재실행) 을 하거나, control + option + r을 통해서 실행 내역 중에서 원하는 것을 실행할 수 있도록 해보자.

class ExpenseReport {
    private val expenses: MutableList<Expense> = ArrayList()
    private val date: String
        get() = "9/12/2002"

    private var total = 0
    private var mealExpenses = 0
    private lateinit var printer: ReportPrinter

    fun printReport(printer: ReportPrinter) {
        this.printer = printer
        printHeader()
        calculateExpenses()
        printExpenses()
        printTotal()
    }

    private fun printExpenses() {
        for (expense in expenses) {
            val name = getName(expense)

            printer.print(
                String.format(
                    "%s\t%s\t$%.02f\n",
                    if (expense.type == Expense.Type.DINNER
                        && expense.amount > 5000
                        || expense.type === Expense.Type.BREAKFAST
                        && expense.amount > 1000
                    ) "X" else " ",
                    name, expense.amount / 100.0
                )
            )
        }
    }

    private fun getName(expense: Expense): String {
        var name = "TILT"

        when (expense.type) {
            Expense.Type.DINNER -> name = "Dinner"
            Expense.Type.BREAKFAST -> name = "Breakfast"
            Expense.Type.CAR_RENTAL -> name = "Car Rental"
        }
        return name
    }

    private fun calculateExpenses() {
        for (expense in expenses) {
            addTotal(expense)
        }
    }

    private fun addTotal(expense: Expense) {
        if (isMeal(expense)) {
            mealExpenses += expense.amount
        }
        total += expense.amount
    }

    private fun isMeal(expense: Expense) = expense.type == Expense.Type.BREAKFAST || expense.type == Expense.Type.DINNER

    private fun printTotal() {
        printer.print(String.format("\nMeal expenses $%.02f", mealExpenses / 100.0))
        printer.print(String.format("\nTotal $%.02f", total / 100.0))
    }

    private fun printHeader() {
        printer.print("Expenses " + date + "\n")
    }

    fun addExpense(expense: Expense) {
        expenses.add(expense)
    }
}

 

여기에서, printReport()의 함수를 한 번 더 분리하여 완전하게 계산과 출력에 대한 부분으로 나누자.

fun printReport(printer: ReportPrinter) {
    this.printer = printer
    calculateExpenses()
    printExpensesAndTotal()
}

private fun printExpensesAndTotal() {
    printHeader()
    printExpenses()
    printTotal()
}

 

printExpenses() 역시 함수가 2 depth 를 넘어가니 알아보기 어려운 것 같다. 한 번 더 분리해주자.

private fun printExpenses() {
    for (expense in expenses) {
        printExpense(expense)
    }
}

private fun printExpense(expense: Expense) {
    val name = getName(expense)

    printer.print(
        String.format(
            "%s\t%s\t$%.02f\n",
            if (expense.type == Expense.Type.DINNER
                && expense.amount > 5000
                || expense.type === Expense.Type.BREAKFAST
                && expense.amount > 1000
            ) "X" else " ",
            name, expense.amount / 100.0
        )
    )
}

 

printExpense() 내부에서 name 이 한 곳에서만 쓰이고 있으니 inline 을 통해서 조금 더 줄여줄 수 있다.

private fun printExpense(expense: Expense) {
    printer.print(
        String.format(
            "%s\t%s\t$%.02f\n",
            if (expense.type == Expense.Type.DINNER
                && expense.amount > 5000
                || expense.type === Expense.Type.BREAKFAST
                && expense.amount > 1000
            ) "X" else " ",
            getName(expense), expense.amount / 100.0
        )
    )
}

 

추가적으로 값을 포맷팅 하는 부분의 가독성을 위해 if문을 한 번 더 함수로 분리해주자.

private fun printExpense(expense: Expense) {
    printer.print(
        String.format(
            "%s\t%s\t$%.02f\n",
            if (isOverage(expense)) "X" else " ",
            getName(expense), expense.amount / 100.0
        )
    )
}

private fun isOverage(expense: Expense) = (expense.type == Expense.Type.DINNER
        && expense.amount > 5000
        || expense.type === Expense.Type.BREAKFAST
        && expense.amount > 1000)

 

마지막으로, 기존 코드에서는 100으로 나누는 부분들이 상당히 겹치는 것을 볼 수 있었다. 이 부분에 대해서 함수로 추출해보자.

이때, 현재 상태에서 단순하게 함수로 추출하게 되면 겹치는 부분들에 대해 intellij 가 추천을 해주지 않기 때문에, 1차적으로 지역변수로 분리를 해보자. (어차피 사라질 변수들이기 때문에 이름을 대충 지었다.)

private fun printExpense(expense: Expense) {
    val amount = expense.amount
    printer.print(
        String.format(
            "%s\\t%s\\t$%.02f\\n",
            if (isOverage(expense)) "X" else " ",
            getName(expense), amount / 100.0
        )
    )
}

private fun printTotal() {
    val tempMealExpense = mealExpenses
    val tempTotal = total
    printer.print(String.format("\\nMeal expenses $%.02f", tempMealExpense / 100.0))
    printer.print(String.format("\\nTotal $%.02f", tempTotal / 100.0))
}

 

이 상태에서 extract method 를 하게 되면, 함수의 시그니처가 Int → Double 로 고정되기 때문에 사용되는 모든 부분에 대해서 전부 교체가 가능해진다.

private fun printExpense(expense: Expense) {
    val amount = expense.amount
    printer.print(
        String.format(
            "%s\t%s\t$%.02f\n",
            if (isOverage(expense)) "X" else " ",
            getName(expense), getRate(amount)
        )
    )
}

private fun printTotal() {
    val tempMealExpense = mealExpenses
    val tempTotal = total
    printer.print(String.format("\nMeal expenses $%.02f", getRate(tempMealExpense)))
    printer.print(String.format("\nTotal $%.02f", getRate(tempTotal)))
}

private fun getRate(amount: Int) = amount / 100.0

 

마지막으로 inline variable 을 통해서 임시 변수를 제거해주자.

그럼 최종적으로 우리가 원하는 형태로 잘 수정된 것을 볼 수 있다.

private fun printExpense(expense: Expense) {
    printer.print(
        String.format(
            "%s\t%s\t$%.02f\n",
            if (isOverage(expense)) "X" else " ",
            getName(expense), getRate(expense.amount)
        )
    )
}

private fun printTotal() {
    printer.print(String.format("\nMeal expenses $%.02f", getRate(mealExpenses)))
    printer.print(String.format("\nTotal $%.02f", getRate(total)))
}

private fun getRate(amount: Int) = amount / 100.0

 

---

 

🌱 Step4 - 도메인의 응집도를 높여보자

여기까지 하고 나면 전체적인 클래스에 대해 읽기 쉬운 코드가 되어 있을 것이다.

하지만, 핵심 도메인인 Expense 가 하는 일이 굉장히 빈약하게 느껴진다.

출력과 클래스의 전역 변수와 관련없이 수행되고 있는 ‘비용의 이름에 대해서 가져오는 기능’과 ‘meal인지 판단하는 기능’, ‘평균인지 계산하는 기능’은 도메인에게 넘겨줄 수 있지 않을까?

 

f6을 눌러 (Move Method) 도메인에게 해당 기능을 위임해보자.

참고로, 코틀린에서는 기본적으로 이 기능이 꺼져 있기 때문에 별도의 설정이 필요하다.

아래의 글에서 설정하는 방법을 바탕으로 미리 해두면 좋다. (갓망규)

[Kotlin] 인텔리제이(IntelliJ)에서 코틀린 move instance method(다른 클래스로 메소드 옮기기) 리팩토링

 

그러면 아래와 같이 도메인에게 해당 기능들이 잘 넘어간 것을 볼 수 있다.

class Expense(
    var type: Type,
    var amount: Int
) {
    enum class Type {
        DINNER,
        BREAKFAST,
        CAR_RENTAL
    }

    fun getName(): String {
        var name = "TILT"

        when (this.type) {
            Type.DINNER -> name = "Dinner"
            Type.BREAKFAST -> name = "Breakfast"
            Type.CAR_RENTAL -> name = "Car Rental"
        }
        return name
    }

    fun isMeal() = this.type == Type.BREAKFAST || this.type == Type.DINNER

    fun isOverage() = (this.type == Type.DINNER
        && this.amount > 5000
        || this.type === Type.BREAKFAST
        && this.amount > 1000)
}

 

---

 

🌱 Step5 - 출력하는 부분에 대해서 분리해보자

 

여전히 출력과 비즈니스 로직이 합쳐져 있다는 부분이 마음에 걸린다.

그래서, 우리는 비용을 계산하는 부분과 출력을 담당하는 부분을 별도의 클래스로 분리하여 기능별 응집도를 높여보도록 할 것이다.

그러나… 자바에는 control + t → extract delegate 를 선택하면 쉽게 분리가 가능하지만, 코틀린에는 존재하지 않는다. (가장 아쉽다)

 

그래서, extract delegate 대신 extract superclass를 활용하여 약간의 꼼수로 클래스를 분리해보고자 한다.

먼저, 기존의 클래스의 이름을 ExpenseReporter 로 변경하여 출력에 대한 기능들만 남길 수 있도록 의미를 부여해주었다. (Shift + F6 - Rename)

그리고, extract superclass를 통해서 비용을 계산하는 부분을 추출해주자.

 

함수를 선택하다 보면 위와 같이 !가 떠있는 것을 볼 수 있는데, 이는 같이 옮겨야 깨지지 않는 친구들을 Intellj 가 감지하여 알려준다.

!가 뜬 친구들까지 함께 체크하여 선택해준다.

 

그럼 아래와 같이 ExpenseReport 라는 친구가 생기게 된다. 우리는 SuperClass로 어쩔 수 없이 생성했기 때문에 open class가 되었는데, 해당 클래스를 일반 클래스로 바꾸어주고, 외부에서 호출할 수 있도록 함수 역시 public 으로 열어두도록 하자.

// AS-IS
open class ExpenseReport {
    protected val expenses: MutableList<Expense> = ArrayList()
    protected var total = 0
    protected var mealExpenses = 0
    protected fun calculateExpenses() {
        for (expense in expenses) {
            addTotal(expense)
        }
    }

    private fun addTotal(expense: Expense) {
        if (expense.isMeal()) {
            mealExpenses += expense.amount
        }
        total += expense.amount
    }

    fun addExpense(expense: Expense) {
        expenses.add(expense)
    }
}

// TO-BE
class ExpenseReport {
     val expenses: MutableList<Expense> = ArrayList()
     var total = 0
     var mealExpenses = 0

     fun calculateExpenses() {
        for (expense in expenses) {
            addTotal(expense)
        }
    }

    private fun addTotal(expense: Expense) {
        if (expense.isMeal()) {
            mealExpenses += expense.amount
        }
        total += expense.amount
    }

    fun addExpense(expense: Expense) {
        expenses.add(expense)
    }
}

 

또한, 기존 클래스도 깨져있을 테니까 수정이 필요하다. Report에 대해 전역 변수를 선언해준 다음, F2를 눌러 오류 부분을 찾아가며 수정해주자. (addExpense의 경우 테스트 코드를 최대한 덜 깨지게 하기 위해서 다시 만들어 두었다.)

class ExpenseReporter {
    private val date: String
        get() = "9/12/2002"

    private lateinit var printer: ReportPrinter
    private val expenseReport = ExpenseReport()

    fun printReport(printer: ReportPrinter) {
        this.printer = printer
        expenseReport.calculateExpenses()
        printExpensesAndTotal()
    }

    private fun printExpensesAndTotal() {
        printHeader()
        printExpenses()
        printTotal()
    }

    private fun printExpenses() {
        for (expense in expenseReport.expenses) {
            printExpense(expense)
        }
    }

    private fun printExpense(expense: Expense) {
        printer.print(
            String.format(
                "%s\t%s\t$%.02f\n",
                if (isOverage(expense)) "X" else " ",
                expense.getName(), expense.amount / 100.0
            )
        )
    }

    private fun isOverage(expense: Expense) = (expense.type == Expense.Type.DINNER
            && expense.amount > 5000
            || expense.type === Expense.Type.BREAKFAST
            && expense.amount > 1000)

    private fun printTotal() {
        printer.print(String.format("\nMeal expenses $%.02f", expenseReport.mealExpenses / 100.0))
        printer.print(String.format("\nTotal $%.02f", expenseReport.total / 100.0))
    }

    private fun printHeader() {
        printer.print("Expenses " + date + "\n")
    }

    fun addExpense(expense: Expense) {
        expenseReport.expenses.add(expense)
    }
}

 

---

 

🌱 Step6 - OCP를 개선해보자

여기까지 잘 실행했다면 클래스가 꽤나 간결해진 것을 볼 수 있을 것이다.

// 출력을 담당하는 클래스
class ExpenseReporter {
    private val date: String
        get() = "9/12/2002"
    private lateinit var printer: ReportPrinter
    private val expenseReport: ExpenseReport = ExpenseReport()

    fun printReport(printer: ReportPrinter) {
        this.printer = printer
        expenseReport.calculateExpenses()
        printExpensesAndTotal()
    }

    private fun printExpensesAndTotal() {
        printHeader()
        printExpenses()
        printTotal()
    }

    private fun printExpenses() {
        for (expense in expenseReport.expenses) {
            printExpense(expense)
        }
    }

    private fun printExpense(expense: Expense) {
        printer.print(
            String.format(
                "%s\t%s\t$%.02f\n",
                if (expense.isOverage()) "X" else " ",
                expense.getName(), getRate(expense.amount)
            )
        )
    }

    private fun printTotal() {
        printer.print(String.format("\nMeal expenses $%.02f", getRate(expenseReport.mealExpenses)))
        printer.print(String.format("\nTotal $%.02f", getRate(expenseReport.total)))
    }

    private fun getRate(amount: Int) = amount / 100.0

    private fun printHeader() {
        printer.print("Expenses " + date + "\n")
    }

    fun addExpense(expense: Expense) {
        expenseReport.addExpense(expense)
    }
}

// 계산을 담당하는 클래스
class ExpenseReport {
    val expenses: MutableList<Expense> = ArrayList()
    var total = 0
    var mealExpenses = 0

    fun calculateExpenses() {
        for (expense in expenses) {
            addTotal(expense)
        }
    }

    private fun addTotal(expense: Expense) {
        if (expense.isMeal()) {
            mealExpenses += expense.amount
        }
        total += expense.amount
    }

    fun addExpense(expense: Expense) {
        expenses.add(expense)
    }
}

// 비용에 대한 도메인
class Expense(
    var type: Type,
    var amount: Int
) {
    enum class Type {
        DINNER,
        BREAKFAST,
        CAR_RENTAL
    }

    fun getName(): String {
        var name = "TILT"

        when (this.type) {
            Type.DINNER -> name = "Dinner"
            Type.BREAKFAST -> name = "Breakfast"
            Type.CAR_RENTAL -> name = "Car Rental"
        }
        return name
    }

    fun isMeal() = this.type == Type.BREAKFAST || this.type == Type.DINNER

    fun isOverage() = (this.type == Type.DINNER
            && this.amount > 5000
            || this.type === Type.BREAKFAST
            && this.amount > 1000)
}

 

우리는 이제 마지막으로, 새로운 Expense의 타입이 추가되었을 때 유연하게 확장할 수 있도록 각각에 대해 클래스로 분리하는 작업을 진행할 것이다.

먼저, 원활한 작업을 위해서 Expense의 클래스를 미리 abstract class로 바꾸어두자. (이렇게 하지 않으면, 아래에서 세부 클래스들을 만들 때 단축키를 사용할 수 없다.)

abstract class Expense(
    var type: Type,
    var amount: Int
)

 

그리고, 테스트 코드를 수정하는 작업을 진행해보자. 

기존의 테스트 코드에서 비용 객체를 생성하기 위해 Dinner 타입을 넘겨준 부분을, 저녁에 대한 비용을 나타내는 새로운 클래스를 만들어주기 위해 새롭게 생성해준다.

// AS-IS
"printOneDinner" {
    report.addExpense(Expense(Expense.Type.DINNER, 1678))
    report.printReport(printer)

    printer.getText() shouldBe """
        Expenses 9/12/2002
         	Dinner	$16.78

        Meal expenses $16.78
        Total $16.78
    """.trimIndent()
}

// TO-BE
"printOneDinner" {
    report.addExpense(DinnerExpense(1678))
    report.printReport(printer)

    printer.getText() shouldBe """
        Expenses 9/12/2002
         	Dinner	$16.78

        Meal expenses $16.78
        Total $16.78
    """.trimIndent()
}

 

그럼, 우리는 이 테스트를 깨지지 않도록 만드는 것이 가장 중요하다. DinnerExpense라는 클래스를 새롭게 만들어주자.

(마치 TDD를 하는 것처럼, 테스트를 중점으로 하여 리팩터링을 진행하는 것이다.)

 

option + enter를 누르면 위와 같이 create class를 통해 만들어줄 수 있다.

같은 방법으로 나머지 타입에 대한 클래스도 만들어주자.

이미 클래스에서 어떤 타입인지 드러나고 있어, 인자로 type 조건을 넘겨주는 것이 어색하기 때문에 클래스 생성 후 change Signature를 통해 일괄적으로 제거해주었다.

class DinnerExpense(amount: Int) : Expense(Type.DINNER, amount) 

class BreakfastExpense(amount: Int) : Expense(Type.BREAKFAST, amount)

class CarRentalExpense(amount: Int) : Expense(Type.CAR_RENTAL, amount)

 

그럼, 테스트 코드 역시 아래와 같이 바뀌었을 것이다.

internal class ExpenseReportTest : StringSpec({
    lateinit var report: ExpenseReporter
    lateinit var printer: MockReportPrinter

    beforeTest {
        report = ExpenseReporter()
        printer = MockReportPrinter()
    }

    "printEmpty" {
        report.printReport(printer)

        printer.getText() shouldBe """
            Expenses 9/12/2002

            Meal expenses $0.00
            Total $0.00
        """.trimIndent()
    }

    "printOneDinner" {
        report.addExpense(DinnerExpense(1678))
        report.printReport(printer)

        printer.getText() shouldBe """
            Expenses 9/12/2002
             	Dinner	$16.78

            Meal expenses $16.78
            Total $16.78
        """.trimIndent()
    }

    "twoMeals" {
        report.addExpense(DinnerExpense(1000))
        report.addExpense(BreakfastExpense(500))
        report.printReport(printer)

        printer.getText() shouldBe """
            Expenses 9/12/2002
             	Dinner	$10.00
             	Breakfast	$5.00

            Meal expenses $15.00
            Total $15.00
        """.trimIndent()
    }

    "twoMealsAndCarRental" {
        report.addExpense(DinnerExpense(1000))
        report.addExpense(BreakfastExpense(500))
        report.addExpense(CarRentalExpense(50000))
        report.printReport(printer)

        printer.getText() shouldBe """
            Expenses 9/12/2002
             	Dinner	$10.00
             	Breakfast	$5.00
             	Car Rental	$500.00

            Meal expenses $15.00
            Total $515.00
        """.trimIndent()
    }

    "overages" {
        report.addExpense(BreakfastExpense(1000))
        report.addExpense(BreakfastExpense(1001))
        report.addExpense(DinnerExpense(5000))
        report.addExpense(DinnerExpense(5001))
        report.printReport(printer)

        printer.getText() shouldBe """
            Expenses 9/12/2002
             	Breakfast	$10.00
            X	Breakfast	$10.01
             	Dinner	$50.00
            X	Dinner	$50.01

            Meal expenses $120.02
            Total $120.02
        """.trimIndent()
    }
})

 

---

 

🌱 Step7 - 자식 클래스들에게 책임을 분리하자

각 클래스들을 만들어주었지만, 깡통 클래스이기 때문에 굉장히 부실하다.

우리의 Expense 클래스를 되돌아보자. 여기에서 각 함수들은 자식 클래스들로 내려가기에 좋아 보인다.

abstract class Expense(
    var type: Type,
    var amount: Int
) {
    enum class Type {
        DINNER,
        BREAKFAST,
        CAR_RENTAL
    }

    fun getName(): String {
        var name = "TILT"

        when (this.type) {
            Type.DINNER -> name = "Dinner"
            Type.BREAKFAST -> name = "Breakfast"
            Type.CAR_RENTAL -> name = "Car Rental"
        }
        return name
    }

    fun isMeal() = this.type == Type.BREAKFAST || this.type == Type.DINNER
    fun isOverage() = (this.type == Type.DINNER
            && this.amount > 5000
            || this.type === Type.BREAKFAST
            && this.amount > 1000)
}

 

이를 위해서, 각각의 함수를 자식 클래스들에게 넘겨주기 위해 control + t → push member down을 눌러주자.

 

그러면, 아래와 같이 Expense 클래스의 각 메서드들이 abstract 클래스로 변하게 된다.

abstract class Expense(
    var type: Type,
    var amount: Int
) {
    enum class Type {
        DINNER,
        BREAKFAST,
        CAR_RENTAL
    }

    abstract fun getName(): String
    abstract fun isMeal(): Boolean
    abstract fun isOverage(): Boolean
}

 

이제, 각각의 클래스들에게 가서 어울리는 행동을 할 수 있도록 수정해주자.

// AS-IS
class BreakfastExpense(amount: Int) : Expense(Type.BREAKFAST, amount) {
    override fun getName(): String {
        var name = "TILT"

        when (this.type) {
            Type.DINNER -> name = "Dinner"
            Type.BREAKFAST -> name = "Breakfast"
            Type.CAR_RENTAL -> name = "Car Rental"
        }
        return name
    }

    override fun isMeal() = this.type == Type.BREAKFAST || this.type == Type.DINNER
    override fun isOverage() = (this.type == Type.DINNER
            && this.amount > 5000
            || this.type === Type.BREAKFAST
            && this.amount > 1000)

}

// TO-BE
class BreakfastExpense(amount: Int) : Expense(Type.BREAKFAST, amount) {
    override fun getName(): String = "Breakfast"
    override fun isMeal() = true
    override fun isOverage() = this.amount > 1000
}

// 나머지도 동일하게 변경
class CarRentalExpense(amount: Int) : Expense(Type.CAR_RENTAL, amount) {
    override fun getName(): String = "Car Rental"
    override fun isMeal() = false
    override fun isOverage() = false
}

class DinnerExpense(amount: Int) : Expense(Type.DINNER, amount) {
    override fun getName(): String = "Dinner"
    override fun isMeal() = true
    override fun isOverage() = this.amount > 5000
}

 

또한, 여기에서 기존에 정의해주었던 Expense 클래스 내부의 Type이라는 enum class는 getName을 위해서 사용되었던 클래스이기 때문에 제거해도 무리가 없다. 지워주도록 하자. 마찬가지로 이전에 사용했던 command + F6 (Change Signature)를 사용하자. 이렇게 하면 자식 클래스에 가서 직접 제거해줄 필요가 없이 편하게 지울 수 있다.

 

여기까지 와서 테스트 코드를 한 번 돌려보도록 하자. 다 돌아갔다면 성공이다.

 

 

---

 

🌱 마무리

 

최종적으로 위와 같은 관계도를 가지는 것을 볼 수 있으며, 이전과 비교했을 때 코드 역시 훨씬 읽기 좋고 깔끔한 코드로 변경되었다.

 

뿌듯!

 

글이 굉장히 길어졌기도 하고, 실제로 리팩터링을 진행하는데도 꽤 오래 걸렸다.

이번 리팩터링의 핵심은, 어떻게 하면 안전하게 리팩터링을 할 수 있는지가 중점이 되었다.

처음에 원본 코드를 보았을 때는 코드의 설계 관점만 생각해서 수기로 클래스를 만들고 분리하는 일들을 많이 했었는데, 이번 리팩터링을 각 단계마다 천천히 진행하면서 느꼈던 건 Intellij 에서 생각보다 많은 기능을 지원해주고 있었다는 점이었다.

또한, 실무에서 리팩터링을 하다 보면 정말 많은 클래스에 대해서 반복적으로 같은 작업을 하는 것들이 많아서 복사 붙여넣기를 하느라 시간을 엄청 썼었는데, 앞으로는 기본으로 제공하는 기능을 먼저 찾아보고 써야겠다는 생각이 들었다. (잃어버린 내 시간들...)

 

그리고 무엇보다 중요한 건, 기능을 수정했을 때 불안하지 않도록 테스트 코드를 꼭 작성해야 한다는 점이다.

일을 진행하면서 코드 대신에 직접 수기로 QA를 하던 날들이 많았는데, 앞으로는 리팩터링 할 때 최대한 테스트 코드에 의존하여 수정하도록 습관을 들여야겠다. 단축키 연습도 열심히 해서 앞으로는 키보드로만 개발할 수 있도록... 노력해야겠다 🥹