[모던 자바 인 액션] 동작 파라미터화 코드 전달하기

필요성

동작 파라미터화를 이용하면 자주 바뀌는 요구사항에 효과적으로 대응할 수 있다. 동작 파라미터화란 아직은 어떻게 동작할 것인지 결정하지 않은 코드 블록을 의미한다.

 

변화하는 요구사항에 대응하기

첫 번째 시도 : 녹색 사과 필터링

사과 재고 목록에서 초록색 사과만 필터링하는 기능을 구현하면, 다음과 같다.

public static List<Apple> filterGreenApples(List<Apple> inventory){
    List<Apple> result = new ArrayList<>();
    for (Apple apple : inventory){
        if (Color.GREEN.equals(apple.getColor())){
            result.add(apple);
        }
    }
    return result;
}

 

위의 경우에서, 빨간색 사과를 필터링하는 것으로 바꾸고 싶을 때는 조건문의 색깔을 바꾼 메소드를 생성하면 된다. 하지만, 색깔이 훨씬 더 다양할 경우, 생성해야 하는 메소드가 매우 많아지는 문제가 발생한다. 이런 상황에서 좋은 규칙이 있다.

 

'거의 비슷한 코드가 반복 존재한다면, 그 코드를 추상화한다.'

 

두 번째 시도 : 색을 파라미터화

색깔을 추상화한 코드는 다음과 같다.

public static List<Apple> filterApplesByColor(List<Apple> inventory, Color color){
    List<Apple> result = new ArrayList<>();
    for (Apple apple : inventory){
        if (color.equals(apple.getColor())){
            result.add(apple);
        }
    }
    return result;
}

 

위 코드를 이용하여 다음과 같이  필터링할 수 있을 것이다.

List<Apple> greenApples = filterApplesByColor(inventory, Color.GREEN);
List<Apple> redApples = filterApplesByColor(inventory, Color.RED);

 

비슷하게, 무게를 가지고 필터링하고 싶을 때는 다음과 같이 구현한다.

public static List<Apple> filterApplesByWeight(List<Apple> inventory, int weight){
    List<Apple> result = new ArrayList<>();
    for (Apple apple : inventory){
        if (apple.getWeight() > weight){
            result.add(apple);
        }
    }
    return result;
}

 

하지만, 색깔로 필터링하는 메소드와 무게로 필터링하는 메소드를 비교해보면, 상당 부분이 중복되는 것을 발견할 수 있다. 이는 소프트웨어공학의 DRY(같은 것을 반복하지 말 것) 원칙을 어기는 것이다. 가장 쉽게 떠올릴 수 있는 해결책은 플래그를 이용하여 색깔과 무게를 동시에 필터링하는 것이다.

 

세 번째 시도 : 가능한 모든 속성으로 필터링

public static List<Apple> filterApples(List<Apple> inventory, Color color, int weight, boolean flag){
    List<Apple> result = new ArrayList<>();
    for (Apple apple : inventory){
        if ((flag && color.equals(apple.getColor()) || !flag && apple.getWeight() > weight)){
            result.add(apple);
        }
    }
    return result;
}

List<Apple> redApples = filterApples(inventory, Color.RED, 0, true);
List<Apple> heavyApples = filterApples(inventory, null, 100, false);

 

flag가 true이면, 색깔로 필터링하고, flag가 false이면, 무게로 필터링한다.

 

문제는 사용 시, true와 false가 무엇을 의미하는지 한눈에 파악하기도 어렵다. 어떤 기준으로 필터링할 것인지 정확히, 그리고 효과적으로 전달해야 한다.

 

동작 파라미터화

네 번째 시도 : 추상적 조건으로 필터링

사과의 어떤 속성에 기초해서 불리안 값을 반환하는 메소드를 정의할 수 있다. 참 또는 거짓을 반환하는 함수를 Predicate라고 한다. 선택 조건을 결정하는 인터페이스를 정의하면 다음과 같다.

public interface ApplePredicate {
    boolean test(Apple apple);
}

public class AppleHeavyWeightPredicate implements ApplePredicate{
    @Override
    public boolean test(Apple apple) {
        return apple.getWeight() > 100;
    }
}

public class AppleGreenColorPredicate implements ApplePredicate{
    @Override
    public boolean test(Apple apple) {
        return apple.getColor().equals(Color.GREEN);
    }
}

이를 전략 디자인 패턴이라고 부른다. 전략 디자인 패턴은 각 알고리즘을 캡슐화하는 알고리즘 패밀리(인터페이스)를 정의해 둔 다음에 런타임에 알고리즘(구현 메소드)을 선택하는 방법이다.

 

public static List<Apple> filterApples(List<Apple> inventory, ApplePredicate applePredicate){
    List<Apple> result = new ArrayList<>();
    for (Apple apple : inventory){
        if (applePredicate.test(apple)){
            result.add(apple);
        }
    }
    return result;
}

이렇게 메소드(filterApples)가 다양한 동작 또는 전략(applePredicate)를 받아서 내부적으로 다양한 동작(test)을 수행할 수 있다.

 

기존의 코드에 비해, 훨씬 더 유연한 코드를 얻었으며 가독성과 사용 용이성이 높아졌다. 한 개의 파라미터에 메소드를 바꿔 전달하는 것으로 다양한 동작이 가능해졌다.

 

사과에 대한 정보를 동적 파라미터를 이용하여 다르게 출력하는 것은 아래와 같이 구현할 수 있다.

public interface AppleFormatter {
    public String accept(Apple apple);
}

public class AppleSimpleFormatter implements AppleFormatter{
    @Override
    public String accept(Apple apple) {
        return apple.getColor() + " 색 " + apple.getWeight() + "g 사과";
    }
}

public class AppleDetailFormatter implements AppleFormatter{
    @Override
    public String accept(Apple apple) {
        return "이 사과의 색깔은 " + apple.getColor() + ", 무게는 " + apple.getWeight() + "g 입니다.";
    }
}

prettyPrintApple(inventory, new AppleDetailFormatter());
prettyPrintApple(inventory, new AppleSimpleFormatter());

 

복잡한 과정 간소화

익명 클래스

익명 클래스는 자바의 지역 클래스(블록 내부에 선언된 클래스)와 비슷한 개념이다. 익명 클래스는 말 그대로 이름이 없는 인터페이스를 구현한 클래스로, 익명 클래스를 이용하면, 즉석에서 필요한 구현을 만들어서 사용할 수 있다. 

 

다섯 번째 시도 : 익명 클래스 사용

ApplePredicate의 구현체를 일일이 생성하지 않고, 익명 클래스를 생성하여 간단히 할 수 있다.

List<Apple> redApples = filterApples(inventory, new ApplePredicate() {
            @Override
            public boolean test(Apple apple) {
                return Color.RED.equals(apple.getColor());
            }
        });

 

 

여섯 번째 시도 : 람다 표현식 사용

람다식을 익명 클래스로 사용할 수 있다.

List<Apple> redApples = filterApples(inventory, (Apple apple) -> Color.RED.equals(apple.getColor()));

 

 

일곱 번째 시도 : 리스트 형식으로 추상화

public static <T> List<T> filter(List<T> list, Predicate<T> predicate){
    List<T> result = new ArrayList<>();
    for (T t : list) {
        if (predicate.test(t)){
            result.add(t);
        }
    }
    return result;
}

List<Apple> redApples = filter(inventory, (Apple apple) -> Color.RED.equals(apple.getColor()));
List<Grape> heavyGrape = filter(inventory, (Grape grape) -> grape.getWeight() > 100);

 

실전 예제

Comparator로 정렬하기

List의 파라미터는 Comparator<T>인데, 인터페이스이다. 따라서, 익명 클래스나 람다 표현식을 이용할 수 있다.

inventory.sort(
        (Apple a1, Apple a2) -> a1.getWeight().compareTo(a2.getWeight())
);