[CHAPTER 2] - 동작 파라미터화 코드 전달하기

[coalong]

[CHAPTER 2] - 동작 파라미터화 코드 전달하기

이번 챕터는 동작 파라미터화 로 자주 변경되는 요구사항에 유연하게 대응할 수 있는 코드를 설계하자! 는 내용이다.
이번 챕터에서는 동작 파라미터화에 대해 자세히 보고 챕터 3에서 람다의 사용에 대해 자세히 살펴보자.

소비자의 요구사항은 계속 바뀔 수 있고 이에 유연하게 대처하면서 비용은 최소로 하고, 장기적으로 유지보수가 가능해야 한다.

동작 파라미터화를 이용하면 자주 바뀌는 요구사항에 효과적으로 대응할 수 있다.

동작 파라미터화 란?

• 아직은 어떻게 실행할 것인지 결정한지 않은 코드 블록을 의미.
• 즉, 실행을 뒤로 미루면서 호출될 때 실행되기 때문에 자주 바뀌는 요구사항에 효과적으로 대응할 수 있다.

---

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

아래 예제를 통해 변화에 대응하는 유연한 코드를 작성하는 과정을 살펴보자.

농부가 재고목록 조사를 쉽게할 수 있도록 돕는 애플리케이션 개발

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

public static List<Apple> filterGreenApples(List<Apple> inventory){
        List<Apple> result = new ArrayList<>();   # 사과 누적 리스트
        for (Apple apple : inventory) {
            if (GREEN.eqauls(apple.getColor())) {   # 녹색 사과만 선택
                result.add(apple);
            }
        }
        return result;
    }

비교적 간단한 기능 구현이다.

여기서 농부가 녹색 사과 대신 빨간 사과도 필터링 하고 싶어진다면?
단순하게 생각하면, filterReadApples 메서드를 하나 더 만들고 조건문을 수정하면 된다.
하지만, 더 다양한 색을 필터링하는 요구사항이 온다면?

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

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

• 모든 색을 대응할 수 있도록 파라미터에 색깔을 받아서 메서드를 작성하면 된다.

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

이제 농부가 원하는 모든 색상을 대응할 수 있다.

List<Apple> greenApples = filterApplesByColor(inventory, GREEN);
List<Apple> redApples = filterApplesByColor(inventory, 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(don't repeat youreslf) 원칙에 위배된다.

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

• 모든 속성을 메서드 파라미터에 추가한 코드

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.eqauls(apple.getColor()) ||) {
                (!flag && apple.getWeight() > weight))
                result.add(apple);
            }
        }
        return result;
    }

위 메서드를 아래와 같이 사용한다.

List<Apple> greenApples = filterApples(inventory, GREEN, 0, true);
List<Apple> heavyApples = filterApples(inventory, null, 150, false);

• 이 코드를 보면 직관적으로 의미를 알 수 없을 뿐더러, 요구사항이 바뀌었을 때 유연하게 대응할 수도 없다.

2.2 동작 파라미터화

• 파라미터를 추가하지 않고 변화하는 요구사항에 유연하게 대응하는 방법이 필요하다.
• 프레디케이트(Predicate)를 사용해보자!
• Predicate 란?
  • argument 를 받아 boolean 값을 반환하는 함수형 인터페이스

// 사과 선택 조건을 결정하는 인터페이스를 정의
public interface ApplePredicate{
  boolean test(Apple a);
}

// 무거운 사과만 선택
public class AppleHeavyWeightPredicate implements ApplePredicate {
    public boolean test(Apple apple) {
        return apple.getWeight() > 150;
    }
}

//녹색 사과만 선택
public class AppleGreenColorPredicate implements ApplePredicate {
    public boolean test(Apple apple) {
        return GREEN.equals(apple.getColor());
    }
}

• 이것이 전략 디자인 패턴이다.

  • 각 알고리즘을 캡슐화하는 알고리즘 패밀리를 정의(e.g. ApplePredicate) 해두고 런타임 시점에 알고리즘(e.g. AppleHeavyWeightPredicate, AppleGreenColorPredicate)을 선택하는 방법이다.

• 메서드에서 ApplePredicate 객체를 받아 사과의 조건을 검사하도록 메서드를 작성해보자.

  • 이렇게 하면 사과가 담긴 리스트를 반복하는 로직과 리스트의 각 요소에 적용할 동작(사과를 선택하는 조건, 프레디케이트)을 분리할 수 있다.

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

// 필터링 방법으로 코드를 수정
public static List<Apple> filterApples(List<Apple> inventory, ApplePredicate p) {
    List<Apple> result = new ArrayList<>();
    for(Apple apple: inventory) {
        if(p.test(apple: inventory)) {    // 프레디케이트 객체로 사과 검사 조건을 캡슐화했다.
            result.add(apple);
        }
    }
    return result;
}

• 이제 우리는 어떤 요구사항이 와도 대응할 수 있게 되었다.
• 예를 들면, 150그램 이상이고 빨간 사과를 원하면 ApplePredicate 를 구현한 클래스를 작성하기만 하면 된다.

public class AppleRedAndHeavyPredicate implements ApplePredicate {
    public bolean test(Apple apple) {
        return RED.equals(apple.getColor())
            && apple.getWeight() > 150 ;
    }        
}            

List<Apple> heavyAndRedApples = filterApples(apples, new AppleHeavyWeightPredicate());

filterApples 메서드의 동작을 파라미터화 한 것이다.
런타임 시점에 넘어가는 ApplePredicate 객체에 의해 filterApples 메서드의 동작이 결정된다.!

❔ 여러 클래스를 구현해서 인스턴스화하는 과정을 간소화할 수 없을까?

---

2.3 복잡한 과정 간소화

// 무거운 사과 선택
public class AppleHeavyWeightPredicate implements ApplePredicate {
    public boolean test(Apple apple) {
        return apple.getWeight() > 150;
    }
    
// 녹색 사과 선택
public class AppleGreenColorPredicate implements ApplePredicate {
    public boolean test(Apple apple) {
        return GREEN.equals(apple.getColor());
    }

    public class FilteringApples {
        public static void main(String...args) {
            List<Apple> inventory = Arrays.asList(new Apple(80, GREEN), new Apple(155, GREEN), new Apple(120, RED));

             // 결과 리스트는 155그램의 사과 한 개를 포함한다.
            List<Apple> heavyApples = filterApples(inventory, new AppleHeavyWeightPredicate());
            // 결과 리스트는 녹색 사과 두 개를 포함한다.
            List<Apple> greenApples = filterApples(inventory, new AppleGreenColorPredicate());
    }

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

• 위와 같이 인터페이스를 정의하여 동작 파라미터화를 하면 여러 클래스를 정의하고 인스턴스화를 해야 한다.
• 로직과 관련없는 코드가 많이 추가되어 복잡하고 사용하기 번거로움.

이러한 과정을 익명 클래스(anonymous class)를 사용해서 개선할 수 있다!!

2.3.1 익명 클래스(Anonymous class)

익명 클래스(anonymous class) 란?

• 이름이 없는 내부 클래스로, 클래스 선언과 인스턴스화를 동시에 할 수 있으며, 주로 단일 인스턴스를 생성할 때 유용하다.

람다(Lambda) 란?

• 익명 함수(Anonymous Function) 의 형태로 작성되며, 함수를 간결하게 표현하여 전달하는 방법이다.
• 람다는 추상 메서드를 구현하거나 대체하는 역할을 하며, 함수형 인터페이스의 객체를 생성하는데 사용된다.

함수형 인터페이스(Functional Interface) 란?

• 함수형 인터페이스는 정확히 하나의 추상 메서드를 가진 인터페이스 이다.
  (3장에서 함수형 인터페이스에 대해 설명)

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

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

• 위의 코드는 필터링 조건을 구현한 클래스인AppleHeavyWeightPredicate, AppleHeavyWeightPredicate 을 만드는 대신 익명클래스를 이용해서 ApplePredicate 인터페이스를 구현한 방법이다.

• 이렇게 구현하게 되면 각 조건에 따라 계속 클래스를 만들지 않아도 되었지만, 여전히 반복되는 코드가 있고 코드를 작성하고 읽기 어려워진다.

이러한 문제점을 람다 표현식 을 사용하여 해결한다.

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

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

• 코드를 반복하지 않고 간결하고 가독성 또한 좋아졌다.

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

public interface Predicate<T> {
    boolean test(T t);
}

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

List<Apple> redApples = filter(inventory, (Apple apple) -> RED.equals(apple.getColor()));
List<Integer> evenNumbers = filter(numbers, (Integer i) -> i % 2 == 0);

• 형식 파라미터(Type Parameter) T 를 사용하여 추상화한 코드이다.

---

지금까지 전체 흐름을 보면 계속 변경되는 요구사항을 어떻게 해결할까?
값 파라미터화 -> 동작 파라미터화(클래스 -> 익명클래스 -> 람다) 로 점차 코드를 개선해나가고 있다.
다음 챕터 3에서는 람다에 대해서 자세히 알아보자.