🐹 chap2. 동작 파라미터화 코드 전달하기

동작 파라미터화(behavior parameterization)

아직은 어떻게 실행할 것인지 결정하지 않은 코드 블록

이 코드 블록의 실행은 나중으로 미뤄지고, 결과적으로 코드 블록에 따라 메서드의 동작이 파라미터화됨

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

사과 농장의 재고 파악을 위한 리스트 필터링 기능을 예시로 한다.

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

사과 색을 정의하는 Color num이 존재한다.

enum Color { RED, GREEN }

첫 번째 시도 결과 코드이다.

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;
}

굵게 된 부분은 녹색 사과를 선택하는 데 필요한 조건이다.

그런데 농부가 변심하여 녹색 사과 말고 빨간 사과도 필터링 하고싶어졌다. 메서드를 복사하여 filterRedApples라는 새로운 메서드를 만들고, if문의 조건을 빨간 사과로 바꿀 수 있지만, 나중에 더 다양한 색으로 필터링 하는 등의 변화에 적절하게 대응할 수 없다.

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

2.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;
}

다음처럼 구현한 메서드를 호출한다.

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 yourself) 원칙을 어기는 것이다.

색과 무게를 filter라는 메서드로 합치는 방법이 있지만 이는 어떤 기준으로 사과를 필터링할 지 구분하는 또 다른 방법으로 플래그를 추가해야한다. 하지만 실전에서는 절대 이 방법을 사용하지 말아야 한다.

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 && apple.getColor().equals(color)) || 
						(!flag && apple.getWeight() > weight))** {  // 색이나 무게 선택 방식이 별로임
						result.add(apple);
				}
		}
		return result;
}

실행 코드

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

위 코드를 봤을 때 true와 false가 무엇을 의미하는지 파악하기 어렵고, 앞으로 요구사항이 바뀌었을 때 유연하게 대응할 수도 없다. 만약 크기, 모양, 출하지 등으로 필터링 하고 싶다면 결국 중복된 필터 메서드를 만들거나, 모든 것을 처리하는 거대한 하나의 필터 메서드를 구현해야 한다.

2.2 동작 파라미터화

프레디케이트 : 참 또는 거짓을 반환하는 함수

선택 조건을 결정하는 인터페이스를 정의하자.

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

다음과 같이 다양한 선택 조건을 대표하는 여러 버전의 ApplePredicate를 정의할 수 있다.

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());
		}
}

위 조건에 따라 filter 메서드가 다르게 동작할 것이라고 예상할 수 있고, 이를 전략 디자인 패턴 이라고 한다.

전략 디자인 패턴

각 알고리즘(전략이라 불리는)을 캡슐화하는 알고리즘 패밀리를 정의해둔 다음에 런타임에 알고리즘을 선택하는 기법

위에서는 ApplePredicate가 알고리즘 패밀리이고, AppleHeavyWeightPredicate와 AppleGreenColorPredicate가 전략이다.

이제 filterApples에서 ApplePredicate의 객체를 받아 애플의 조건을 검사하도록 메서드를 고쳐야한다. 이렇게 동작 파라미터화, 즉 메서드가 다양한 동작(또는 전략)을 받아 내부적으로 다양한 동작을 수행할 수 있다.

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

다음은 ApplePredicate를 이용한 필터 메서드이다.

public static List<Apple> filterApples(List<Apple> inventroy, **ApplePredicate p**) 
{
		List<Apple> result = new ArrayList<>();
		for (Apple apple : inventory) {
				if (p.test(apple)) {  // 프레디케이트 객체로 사과 검사 조건을 캡슐화
						result.add(apple);
				}
		}
		return result;
}

코드/동작 전달하기

이제 농부의 검색 조건에 따라 ApplePredicate를 적절히 구현하는 클래스만 만들면 된다. 이제 Apple의 속성과 관련한 모든 변화에 대응할 수 있는 유연한 코드를 준비한 것이다.

150그램이 넘는 빨간 사과를 검색해달라

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

List<Apple> redAndHeeavyApples = 
		filterApples(inventory, new AppleRedAndHeavyPredicate());

전달한 ApplePredicate 객체에 의해 filterApples 메서드의 동작이 결정된다. 즉, filterApples 메서드의 동작을 파라미터화한 것이다.

filterApples 메서드의 새로운 동작을 정의하는 것이 test 메서드이다. 메서드는 객체만 인수로 받으므로 test 메서드를 ApplePredicate 객체로 감싸서 전달해야 한다.

한 개의 파라미터, 다양한 동작

• 동작 파라미터화의 강점
  • 컬렉션 탐색 로직과 각 항목에 적용할 동작을 분리할 수 있다.

  • 한 메서드가 다른 동작을 수행하도록 재활용할 수 있다.

    

  • 유연한 API를 만들 수 있다.

• Quiz. 유연한 prettyPrintApple 메서드 구현하기

  사과 리스트를 인수로 받아 다양한 방법으로 문자열을 생성(커스터마이즈된 다양한 toString 메서드와 같이)할 수 있도록 파라미터화된 prettyPrintApple 메서드를 구현하시오. 예를 들어 prettyPrintApple 메서드가 각각의 사과 무게를 출력하도록 지시할 수 있다. 혹은 각각의 사과가 무거운지 가벼운지 출력하도록 지시할 수 있다. prettyPrintApple 메서드는 지금까지 살펴본 필터링 예제와 비슷한 방법으로 구현할 수 있다. 좀 더 쉽게 문제를 해결할 수 있도록 대략적인 코드를 공개한다.

    public static void prettyPrintApple(List<Apple> inventory, ???) {
    		for (Apple apple: inventory) {
    				String output = ???.???(apple);
    				System.out.println(output);
    		}
    }
  

  • 정답

    우선 Apple을 인수로 받아 정해진 문자열로 반환할 수단이 있어야 한다. ApplePredicate 인터페이스를 생각해보자.

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

    이제 AppleFormatter 인터페이스를 구현해 여러 포맷 동작을 만들 수 있다.

      public class AppleFancyFormatter implements AppleFormatter {
      		public String accept(Apple apple) {
      				String characteristic = apple.getWeight() > 150 ? "heavy" :
      						"light";
      				return "A " + characteristic + " " + apple.getColor() + " apple";
      }
            
      public class AppleSimpleFormatter implements AppleFormatter(
      		public String accept(Apple apple) {
      				return "An apple of " + apple.getWeight() + "g";
      		}
      }
    

    마지막으로 prettyPrintApple 메서드가 AppleFormatter 객체를 인수로 받아 내부적으로 사용하도록 지시한다. 즉, prettyPrintApple에 파라미터를 추가한다.

      public static void prettyPrintApple(List<Apple> inventory, 
      																		AppleFormatter formatter) {
      		for (Apple apple : inventory) {
      				String output = formatter.accept(apple);
      				System.out.println(output);
      		}
      }
    

    이제 다양한 동작을 prettyPrintApple 메서드로 전달할 수 있다. AppleFormatter의 구현을 객체화한 다음에 prettyPrintApple의 인수로 전달한다.

      prettyPrintAppple(inventory, new AppleFancyFormatter());
    

    코드 실행 결과는 다음과 같다.

      A light green apple
      A heavy red apple 
    

    또는 다음과 같이 구현한다.

      prettyPrintApple(inventory, new AppleSimpleFormatter());
    

    다음은 코드 실행 결과이다.

      An apple of 80g
      An apple of 155g
    

동작을 추상화 하여 변화하는 요구사항에 대응하는 코드를 구현했지만, 여러 클래스를 구현해서 인스턴스화하는 과정을 개선할 방법을 알아보자.

2.3 복잡한 과정 간소화

• [ 동작 파라미터화 : 프레디케이트로 사과 필터링 ] 예제

    // 무거운 사과 선택
    public class AppleHeavyWeightPreidicate 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));
    				List<Apple> heavyApples =  // 결과 리스트느 155그램의 사과 한개를 포함한다. 
    						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;
    		}
    }
  

  로직과 관련 없는 코드가 많이 추가되어있다.

자바는 클래스의 선언과 인스턴스화를 동시에 수행할 수 있도록 익명 클래스라는 기법을 제공한다. 익명 클래스를 이용하면 코드의 양을 줄일 수 있다. (하지만 람다 표현식을 사용할 수도 있음)

2.3.1 익명 클래스

자바의 지역 클래스(블록 내부에 선언된 클래스)와 비슷한 개념으로 말 그대로 이름이 없는 클래스다.

익명 클래스를 이용하면 클래스 선언과 인스턴스화를 동시에 할 수 있다.

즉, 즉석에서 필요한 구현을 만들어 사용할 수 있다.

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

다음은 익명 클래스를 이용해서 ApplePredicate를 구현하는 객체를 만드는 방법으로 필터링 예제를 다시 구현한 코드다.

List<Apple> redApples = filterApples(inventory, new ApplePredicate() {
		// filterApples 메서드의 동작을 직접 파라미터화 했다!
		public boolean test(Apple apple) {
				return RED.equals(apple.getColor());
		}
}

GUI 애플리케이션에서 이벤트 핸들러 객체를 구현할 때 익명 클래스가 종종 사용된다.

• 익명 클래스의 부족한 점

  • 많은 공간 차지

      List<Apple> redApples = filterApples(inventory, new ApplePredicate() {
      		public boolean test(Apple a) {
      				return RED.equals(a.getColor());
      		}
      });
      button.setOnAction(new EventHandler<ActionEvent>() {
      		public void handle(ActionEvent event) {
      				System.out.println("Whoooo a click!!");
      		}
      }
    

    코드가 반복되어 지저분하다.

  • 많은 프로그래머가 익명 클래스 사용에 익숙하지 않다.

    장황한 코드는 구현하고 유지보수하는 데 시간이 오래 걸릴 뿐 아니라 읽는 즐거움도 뺏는다.

    한 눈에 이해할 수 있어야 좋은 코드다.

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

자바 8의 람다 표현식을 위해 이전 예제 코드를 간단하게 재구현할 수 있다.

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) {//형식 파라미터 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);

자바 8 이후부터 가능한 코드이다.

2.4 실전 예제

2.4.1 Comparator로 정렬하기

자바 8의 List에는 sort 메서드가 포함되어 있다(물론 Collections.sort도 존재).

다음과 같은 인터페이스를 갖는 java.util.Comparator 객체를 이용해서 sort의 동작을 파라미터화 할 수 있다.

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

Comparator를 구현해서 sort 메서드의 동작을 다양화할 수 있다.

1. 익명 클래스를 이용해 무게가 적은 순서로 사과를 정렬

    inventory.sort(new Comparator<Apple>() {
    		public int compare(Apple a1, Apple a2) {
    				return a1.getWeight().compareTo(a2.getWeight());
    		}
    });
   

   요구사항이 변경되면 새로운 요구사항에 맞는 Comparator을 만들어 sort에 전달한다.

2. 람다 표현식으로 변경

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

2.4.2 Runnable로 코드 블록 실행하기

자바 스레드를 이용하면 병렬로 코드 블록을 실행할 수 있다.

자바 8까지는 Thread 생성자에 객체만을 전달할 수 있었으므로 보통 결과를 반환하지 않는 void run 메소드를 포함하는 익명 클래스가 Runnable 인터페이스를 구현하도록 하는 것이 일반적인 방법이었다.

자바에서는 Runnable 인터페이스를 이용해서 실행할 코드 블록을 지정할 수 있다.

// java.lang.Runnable
public interface Runnable {
		void run();
} // 코드 블록 실행 결과 void

Runnable을 이용해서 다양한 동작을 스레드로 실행 가능하다.

Thread t = new Thread(new Runnable() {
		public void run() {
				System.out.println("Hello world");
		}
});

자바 8부터 지원하는 람다 표현식을 이용하면 다음처럼 스레드 코드를 구현할 수 있다.

Thread t = new Thread(() -> System.out.println("Hello world"));

2.4.3 Callable을 결과로 반환하기

• ExecutorService(인터페이스)
  • 자바 5부터 지원하는 추상화 개념
  • 태스크 제출과 실행 과정의 연관성을 끊어줌
  • 태스크를 스레드 풀로 보내고 결과를 Future로 저장 가능(스레드와 Runnable을 이용하는 방식과 다름)

Callable 인터페이스를 이용해 결과를 반환하는 태스크를 만든다. (Runnable의 업그레이드 버전)

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

아래 코드에서 볼 수 있듯이 실행 서비스에 태스크를 제출해서 위 코드를 활용할 수 있따. 다음 예제는 태스크를 실행하는 스레드의 이름을 반환한다.

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());

2.4.4 GUI 이벤트 처리하기

• GUI 프로그래밍
  • 마우스 클릭, 문자열 위로 이동 등의 이벤트 대응 동작 수해
  • 변화에 대응할 수 있는 유연한 코드 필요(모든 동작에 반응해야함)

자바FX에서는 setOnAction 메서드에 EventHandler를 전달함으로써 이벤트에 어떻게 반응할지 설정 가능

Button button = new Button("Send");
button.setOnAction(new EventHandler<ActionEvent>() {
		public void handle(ActionEvent event) {
				label.setText("Sent!!");
		}
});

즉, EventHandler는 setOnAction 메서드의 동작을 파라미터화한다. 람다표현식은 다음과 같다.

button.setOnAction((ActionEvent event) -> label.setText("Sent!!"));

2.5 마치며

• 동작 파라미터화에서는 메서드 내부적으로 다양한 동작을 수행할 수 있도록 코드를 메서드 인수로 전달한다.
• 동작 파라미터화를 이용하면 변화하는 요구사항에 더 잘 대응할 수 있는 코드를 구현할 수 있으며 나중에 엔지니어링 비용을 줄일 수 있다.
• 코드 전달 기법을 이용하면 동작을 메서드의 인수로 전달할 수 있다. 하지만 자바 8 이전에는 코드를 지저분하게 구현해야 했다. 익명 클래스로도 어느 정도 코드를 깔끔하게 만들 수 있지만 자바 8에서는 인터페이스를 상속받아 여러 클래스를 구현해야 하는 수고를 없앨 수 있는 방법을 제공한다.
• 자바 API의 많은 메서드는 정렬, 스레드, GUI 처리 등을 포함한 다양한 동작으로 파라미터화할 수 있다.