#02장 동작 파라미터화로 코드 넘기기

Raoul-Gabriel Urma 저, 우정은 역 「Modern Java in Action, 2019」를 읽고 정리하였습니다.

요구사항이 계속 변화하면서, 동작 파라미터가 어떤 이점을 주는지 사과 필터링에 대한 예로 설명한다.

Apple.java

package com.company;

public class Apple {
    String Color;
    private int weight;

    public Apple(String color, int weight) {
        Color = color;
        this.weight = weight;
    }

    public String getColor() {
        return Color;
    }

    public void setColor(String color) {
        Color = color;
    }

    public int getWeight() {
        return weight;
    }

    public void setWeight(int weight) {
        this.weight = weight;
    }

    @Override
    public String toString() {
        return "Apple{" +
                "Color='" + Color + '\'' +
                ", weight=" + weight +
                '}';
    }
}

1-1 인벤토리에서 초록색 사과만 가져온다.

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

인벤토리에는 다양한 무게의 빨간색, 파란색 사과들이 들어가있다.

1-2 인수로 조건을 받아 해당 사과만 가져온다. (파라미터 사용 시작)

//색상으로 필터링
public static List<Apple> filterApplesByColor(List<Apple> inventory, Color color) {
    List<Apple> result = new ArrayList<>();
    for (Apple apple: inventory) {
        if ( apple.getColor().equals(color) ) {
            result.add(apple);
        }
    }
    return result;
}

//무게로 필터링
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 yourself principle)를 어긴다.

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

위 코드는 형편없는 코드다. 이렇게 플래그를 이용한다면, 추후에 오는 요구사항들을 모두 반영하기 위해서는 여러 중복된 필터 메서드를 만들거난 모든것을 처리하는 거대한 하나의 필터메서드를 만들어야 된다.

2-1 동작 파라미터화 사용하기.

동작 파라미터를 사용한 전략 디자인 패턴이다. (strategy design pattern) ApplePredicate = 알고리즘 패밀리, AppleGreenColorPredicate = 전략

//인터페이스 
//Predicate - 참 또는 거짓을 반환하는 함수.
public interface ApplePredicate{
 boolean test (Apple apple);
}
//-------------------------------------------------------------
//무게 필터링
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 AppleRedAndHeavyPredicate implements ApplePredicate {
 public boolean test(Apple apple){
  return RED.equals(apple.getColor())
  && apple.getWeight() > 150;
 }
}
//-------------------------------------------------------------
//ApplePredicate을 추가 = 추상적 기준에 의한 필터링(인터페이스사용하였으므로)
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;
}
//-------------------------------------------------------------
//메인에서 실행
List<Apple> redAndHeavyApples = 
        filterApples(inventory, new AppleRedAndHeavyPredicate());
        //AppleRedAndHeavyPredicate를 인스턴스화 하였다.       

컬렉션을 반복하는 로직과 컬렉션의 각요소에 적용할 동작을 분리할 수 있게 되었다. (1-3과 비교를 해보면 알 수 있다.)

AppleRedAndHeavyPredicate나 AppleHeavyWeightPredicate 등 자유롭게 필터링 조건을 걸어 filterApples의 매개변수에 인스턴스화하여 이제 유연함을 누릴 수 있게 되었다. 하지만, 한번만 사용할 클래스를 구현해서 인스턴스화하는 과정이 조금은 부담이 될 수 있다. 개선할 방법을 알아보자.

2-2 익명 클래스 사용해보자

한번만 사용할 클래스를 생성하지 않고 익명클래스로 만들었다.

//빨간색 사과들만 가져온다.
List<Apple> redApples = filterApples(inventory, new ApplePredicate() {
 public boolean test(Apple apple){
  return RED.equals(apple.getColor());
 }
});

하지만, 익명클래스가 모든것을 해결해 주지 않는다. 가독성이 조금 떨어지기 때문이다.

2-3 람다 사용하기

훨씬 간단해졌다...

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

3 실전 예제

• ​실습 해볼 3가지

  • Comparator로 정렬

  • Runnable로 코드 블록 실행

  • GUI 이벤트 처리

3-1 Comparator로 정렬

sort 연산을 파라미터화 해보자.

// java.util.Comparator 인터페이스 
public interface Comparator<T> {
 int compare(T o1, T o2);
}

//사과인벤토리에서 무게별로 정렬
//sort 안에 정렬 세부사항은 추상화 되어있어 신결 쓸 필요 x
inventory.sort(new Comparator<Apple>() {
 public int compare(Apple a1, Apple a2) {
  return a1.getWeight().compareTo(a2.getWeight());
 }
});

// 람다를 이용해 더 깔끔하게 만들 수 있다.
inventory.sort((Apple a1, Apple a2)->a1.getWeight().compareTo(a2.getWeight()));

3-2 Runnable로 코드 블록 실행

// java.lang.Runnable 인터페이스
public interface Runnable {
 void run();
} 

// 쓰레드 생성 위해 Runnable 사용
Thread t = new Thread(new Runnable() {
 public void run() {
 System.out.println("Hello world");
 }
});

// 람다를 이용해 더 깔끔하게 만들 수 있다.
Thread t = new Thread(() -> System.out.println("Hello world"));

3-3-1 Callable를 이용해 결과를 반환

Callable 인터페이스를 이용해 결과를 반환하는 태스크를 만든다. 위 3-2인 스레드와 Runnable을 이용하는 방식과 다르게 태스크를 스레드 풀로 보내고 결과를 future에 저장할 수 있다.

// java.util.concurrent.Callable
public interface Callable<V> {
 V call();
}

//Callable를 사용해 결과를 반환한다.
ExecutorService executorService = Executors.newCachedThreadPool();
Future<String> threadName = executorService.submit(new Callable<String>() {
 @Override
 public String call() throws Exception {
  return Thread.currentThread().getName();
 }
});

// 람다를 이용해 더 깔끔하게 만들 수 있다.
Future<String> threadName = 
             executorService.submit(()->Thread.currentThread().getName());

3-3-2 GUI 이벤트 처리

JavaFX에서 사용하는 액션 이벤트

//setOnAction 메서드의 동작이 EventHandler 객체와 함께 파라미터화 되었다. 
Button button = new Button("Send");
button.setOnAction(new EventHandler<ActionEvent>() {
 public void handle(ActionEvent event) {
  label.setText("Sent!!");
 }
});

// 람다를 이용해 더 깔끔하게 만들 수 있다.
button.setOnAction((ActionEvent event) -> label.setText("Sent!!"));

정리

• 동작 파라미터화 -> 메서드에게 여러 다른 동작들을 파라미터로써 취하고 내부적으로 다른 동작들이 진행되게끔 사용한다.

• 코드가 요구사항 변화에 더 적응가능해지고 미래의 엔지니어들의 시간을 아낀다.

• 코드를 넘기는 것은 메서드에게 인수로 새로운 동작을 주는 것이다. 그러나 자바 8 이전에는 너무 장황하였고, 익명 클래스들이 오직 한번만 필요한 인터페이스를 위해 여러 구상클래스(concrete classes)를 선언하는데 장황함을 없애는데 약간의 도움을 주었다

• 자바 API는 다른동작들로 파라미터화 할 수 있는 많은 메소드(소팅, 쓰레드 그리고 GUI 핸들링)들은 담고 있다.

• 프로그래머는 동작 파라미터화를 꼭 사용해야 한다!