코드 가독성 개선
익명 클래스를 람다 표현식으로 리팩토링 하기
Runnable r1 = new Runnable() {
@Override
public void run() {
System.out.println("hello");
}
};
Runnable r2 = () -> System.out.println("hello");코드 유연성 개선
함수형 인터페이스 적용
조건부 연기 실행
- 만일 클라이언트 코드에서 객체 상태를 자주 확인하거나, 객체의 일부 메서드를 호출하는 상황이라면 람다나 메서드 참조를 인수로 사용하여, 내부적으로 객체의 상태를 확인한 다음에 메서드를 호출하도록 새로운 메서드로 구현하는 것이 좋다. 가독성도 좋아지고 캡슐화도 강화된다.
실행 어라운드
- 매번 같은 준비, 종료 과정을 반복적으로 수행하는 코드가 있다면 람다로 변환할 수 있다. 준비, 종료 과정을 처리하는 로직을 재사용함으로써 코드 중복을 줄일 수 있다.
람다로 객체지향 디자인 패턴 리팩토링하기
전략
- 전략 패턴은 한 유형의 알고리즘을 보유한 상태에서 런타임에 적절한 알고리즘을 선택하는 기법이다.
- 전략을 구현하는 새로운 클래스를 람다 표현식을 통해 직접 전달할 수 있다.
기존
@FunctionalInterface
public interface ValidationStrategy {
boolean execute(String s);
}
public class IsAllLowerCase implements ValidationStrategy {
@Override
public boolean execute(String s) {
return s.matches("[a-z]+");
}
}
public class isNumeric implements ValidationStrategy {
@Override
public boolean execute(String s) {
return s.matches("\d+");
}
}
public class Validator {
private final ValidationStrategy validationStrategy;
public Validator(ValidationStrategy validationStrategy) {
this.validationStrategy = validationStrategy;
}
public boolean validate(String s) {
return validationStrategy.execute(s);
}
}
Validator numericValidator = new Validator(new isNumeric());
numericValidator.validate("aaa");
Validator lowerCaseValidator = new Validator(new IsAllLowerCase());
lowerCaseValidator.validate("bbbb");람다 사용
Validator lowerCaseValidator2 = new Validator((String s) -> s.matches("[a-z]+"));
lowerCaseValidator2.validate("bbbb");
Validator numericValidator2 = new Validator((String s) -> s.matches("\d+"));
numericValidator2.validate("1234");템플릿 메서드
- 알고리즘의 개요를 제시한 다음에
알고리즘의 일부를 고칠 수 있는 유연함을 제공해야 할 때 템플릿 메서드 디자인 패턴을 사용한다. - 추상 메서드로 원하는 동작을 구현하는 곳을 람다 표현식을 통해 전달할 수 있다.
기존
abstract class OnlineBanking {
public void processCustomer(int id) {
Customer c = Database.getCustomerWithId(id);
makeCustomerHappy(c);
}
abstract void makeCustomerHappay(Customer c);
}람다 사용
public void processCustomer(int id, Cusumer<Customer> makeCustomerHappy) {
Customer c = Database.getCustomerWithId(id);
makeCustomerHappy.accept(c);
}
new OnlineBankingLambda().processCustomer(1337, (Customer c) -> print("hello" + c.getName()));옵저버
- 어떤 이벤트가 발생했을 때 한 객체(subject)가 다른 객체 리스트(observer)에 자동으로 알림을 보내야 하는 상황에서 사용하는 패턴이다.
기존
interface Observer {
void notify(String tweet);
}
public class NyTimes implements Observer {
@Override
public void notify(String tweet) {
if (tweet != null && tweet.contains("monety")) {
System.out.println("Breaking news in NY ! " + tweet);
}
}
}
public class Guardian implements Observer {
@Override
public void notify(String tweet) {
if (tweet != null && tweet.contains("queen")) {
System.out.println("Yet more new from London .. " + tweet);
}
}
}
public class LeMonde implements Observer {
@Override
public void notify(String tweet) {
if (tweet != null && tweet.contains("wine")) {
System.out.println("Today cheese, wine and news! " + tweet);
}
}
}
public interface NotiSubject {
void registerObserver(NotiObserver o);
void notifyObservers(String tweet);
}
public class Feed implements NotiSubject {
private final List<NotiObserver> observers = new ArrayList<>();
@Override
public void registerObserver(NotiObserver o) {
observers.add(o);
}
@Override
public void notifyObservers(String tweet) {
observers.forEach(o -> o.notify(tweet));
}
}
Feed f = new Feed();
f.registerObserver(new NyTimes());
f.registerObserver(new LeMonde());
f.registerObserver(new Guardian());
f.notifyObservers("The Queen ...")- Observer 인터페이스는 새로운 트윗이 있을 때 subject가 호출할 수 있도록 notify라고 하는 하나의 메서드를 제공한다.
- Observer 인테페이스를 구현하는 클래스를 만드는 대신 람다 표현식을 직접 전달해서 실행할 동작을 지정할 수 있다.
람다 사용
Feed feed = new Feed();
feed.registerObserver((String tweet) -> {
if(tweet != null && tweet.contains("money")) {
System.out.println("Breaking news in NY ! " + tweet);
}
});
feed.registerObserver((String tweet) -> {
if(tweet != null && tweet.contains("queen")) {
System.out.println("Yet more new from London .." + tweet);
}
});- 하지만
옵저버가상태를 가지며, 여러 메서드를 정의하는 등복잡하다면 람다 표현식보다기존의 클래스 구현방식을 고수하는 것이 바람직할 수 있다.
의무 체인
- 작업 처리 객체의 체인(동작 체인 등)을 만들 때는 의무 체인 패턴을 사용한다.
- 한 객체가 어떤 작업을 처리한 다음에 다른 객체로 결과를 전달하고, 다른 객체도 해야 할 작업을 처리한 다음에 또 다른 객체로 전달하는 식이다.
- 일반적으로 다음으로 처리할 객체 정보를 유지하는 필드를 포함하는
작업 처리 추상 클래스로 의무 체인 패턴을 구성한다.- 작업 처리 객체가 자신의 작업을 끝냈으면 다음 작업 처리 객체로 결과를 전달한다.
예제 코드
public abstract class ProcessingObject<T> {
protected ProcessingObject<T> successor;
public void setSuccessor(ProcessingObject<T> successor) {
this.successor = successor;
}
public T handle(T input) {
T r = handleWork(input);
if (successor != null) {
return successor.handle(r);
}
return r;
}
abstract protected T handleWork(T input);
}- UML를 자세히 살펴보면 템플릿 메서드 패턴이 사용되었음을 알 수 있다.
- handle 메서드는 일부 작업을 어떻게 처리할지 전체적으로 서술한다.
- ProcessingObject 클래스를 상속받아 handleWork 메서드를 구현하여 다양한 종류의 작업 처리 객체를 만들수 있다.
기존
public class HandleTextProcessing extends ProcessingObject<String> {
@Override
protected String hadleWork(String input) {
return "From Raoul, Mario and Alan : " + input;
}
}
public class SpellCheckProcessing extends ProcessingObject<String> {
@Override
protected String hadleWork(String input) {
return input.replaceAll("labda", "lambda");
}
}
ProcessingObject<String> p1 = new HandleTextProcessing();
ProcessingObject<String> p2 = new SpellCheckProcessing();
p1.setSuccessor(p2);
p1.handle("Aren't ladbas really sexy?");람다 사용
UnaryOperator<String> headerProcessing = (String text) -> "From Raoul, Mario and Alan : " + text;
UnaryOperator<String> spellCheckProcessing = (String text) -> text.replaceAll("labda", "lambda");
Function<String, String> pipeline = headerProcessing.andThen(spellCheckProcessing);
pipeline.apply("Aren't ladbas really sexy?");팩토리
- 인스턴스화 로직을 클라이언트에게 노출하지 않고 객체를 만들 때 팩토리 디자인 패턴을 사용한다.
기존
public class ProductFactory {
public static Product createProduct(String name) {
switch (name) {
case "loan" : return new Loan();
case "stock" : return new Stock();
case "bond" : return new Bond();
default: throw new RuntimeException("...");
}
}
}
Product p = ProductFactory.createProduct("loan");- createProduct 메서드는 생산된 상품을 설정하는 로직을 포함할 수 도 있지만, 주요 목적은 생성자와 설정을 외부로 노출하지 않음으로써 클라이언트가 단순하게 상품을 create 할 수 있다는 점
람다 사용
final static Map<String, Supplier<Product>> map = new HashMap<>();
static {
map.put("loan", Loan::new);
map.put("stock", Stock::new);
map.put("bond", Bond::new);
}
public static Product createProduct(String name) {
Supplier<Product> p = map.get(name);
if (p != null) {
return p.get();
}
throw new IllegalArgumentException("No such product: " + name);
...
}람다 테스팅
- 람다에 대해서도 단위 테스팅(unit testing)이 작성되어야만 한다.
- 하지만 람다는 익명이므로 테스트 코드 이름을 호출할 수 없다.
보이는 람다 표현식의 동작 테스팅
- 람다의 동작을 테스트 하기 위해 람다를 필드에 저장해서 테스트할 수 있다.
람다를 사용하는 메서드의 동작에 집중
- 람다의 목표는 정해진 동작을 다른 메서드에서 사용할 수 있도록 하나의 조각으로 캡슐화 하는것이다.
람다 표현식을 사용하는 메서드의 동작을 테스트함으로서 람다 표현식을 검증 할 수 있다.
복잡한 람다를 개별 메서드로 분할
- 복잡한 로직이 포함된 람다를 구현하게 된다면 로직을 분리 하거나 메서드 레퍼런스를 활용하도록 하자.
- 그러면 일반 메서드를 테스트하듯이 람다 표현식을 테스트할 수 있다.
고차원 함수 테스팅
고차원 함수 : 함수를 인수로 받거나 다른 함수를 반환하는 메서드
- 메서드가 람다를 인수로 받는다면 다른 람다로 메서드의 동작을 테스트 할 수 있다.
- 테스트해야하는 함수가 다른 함수를 반환한다면 함수형 인터페이스의 인스턴스로 간주하고 테스트 할 수 있다.
디버깅
스택 트레이스 확인
- 람다 표현식은 이름이 없기 때문에 조금 복잡한 스택 트레이스가 생성된다.
- 그렇기에 람다 표현식과 관련된 스택 트레이스는 이해하기 어려울 수 있다.
- 이는 미래의 자바 컴파일러가 개선해야 할 부분이다.
정보 로깅
- forEach를 통해 스트림 결과를 출력하거나 로깅할 수 있다. 하지만 forEach는 스트림을 소비하는 연산이다.
- 스트림 파이프라인에 적용된 각각의 연산의 결과를 확인할 수 있다면 대신 peek라는 스트림 연산을 활용할 수 있다.
- peek는 스트림의 각 요소를 소비한것 처럼 동작을 실행하지만, 실제로 스트림을 소비하지않고 자신이 확인한 요소를 파이프라인의 다음 연산으로 그대로 전달한다.
