🐣 chap10. 람다를 이용한 도메인 전용 언어

chap10. 람다를 이용한 도메인 전용 언어

10.1 도메인 전용 언어

DSL(domain specific languages)은 범용 프로그래밍 언어가 아니라 특정 비즈니스 도메인의 문제를 해결하려고 만든 언어다.

특정 도메인에만 국한되므로 오직 자신의 문제를 어떻게 해결할지에만 집중할 수 있고 복잡성을 잘 다룰 수 있다.

• DSL을 개발하기 위해 필요한 점
  • 의사 소통의 왕: 프로그래머가 아닌 사람도 이해할 수 있도록 코드의 의도가 명확히 전달되어야 함(코드가 비즈니스 요구사항에 부합하는지 확인 가능)
  • 한 번 코드를 구현하지만 여러번 읽는다: 가독성은 유지보수의 핵심. 동료가 쉽게 이해할 수 있도록 코드 구현 필수

장점

• 간결함
• 가독성
• 유지보수
• 높은 수준의 추상화
• 집중
• 관심사 분리(Separation of concerns)

단점

• DLS 설계의 어려움
• 개발 비용
• 추가 우회 계층
• 새로 배워야 하는 언어
• 호스팅 언어 한계

내부 DSL

• 순수 자바코드 같은 기존 호스팅 언어를 기반으로 구현한 DSL
• 유연성이 떨어지기 때문에 간단하고 표현력 있는 DSL을 만드는데 한계가 있었지만 람다 표현식이 등장하면서 어느정도 해결될 수 있음
• 순수 자바로 DSL 을 구현 시 장점
  • 외부 DSL에 비해 새로운 패턴과 기술을 배워 DSL을 구현하는 노력이 감소
  • 순수 자바로 DSL 을 구현하면 나머지 코드와 함께 컴파일 가능. (다른 언어의 컴파일러 또는 외부 DSL을 만드는 도구를 사용하지 않아도 됨)
  • 새로운 언어를 배우거나 복잡한 외부 도구를 배울 필요가 없음
  • DSL 사용자는 기존의 자바 IDE로 자동 완성, 리팩터링 기능 그대로 사용 가능
  • 추가 DSL을 쉽게 합칠 수 있음

다중 DSL

자바는 아니지만 JVM에서 실행되며 더 유연하고 표현력이 가능한 언어(ex. 스칼라, 그루비…)로 구현한 DSL

코틀린, 실론 같이 스칼라와 호환성이 유지되며 단순하고 쉽게 배울 수 있는 새 언어도 존재한다.

이 언어들은 모두 자바보다 젋으며 제약을 줄이고, 간편한 문법을 지향하도록 설계되었다.

DSL 친화적이지만 다음과 같은 단점들이 존재한다.

• 새로운 프로그래밍 언어를 배우거나 누군가 해당 기술을 지니고 있어야 함
• 두 개 이상의 언어가 혼재하므로 여러 컴파일러로 소스를 빌드하도록 빌드 과정을 개선해야 함
• JVM 에서 실행되지만 자바와 호환성이 완벽하지 않은 경우가 많음 (성능 손실 가능)

외부 DSL

• 스탠드어론(standalone)
• 호스팅 언어와는 독립적으로 자체의 문법을 가지는 DSL

자신만의 문법과 구문으로 새 언어를 설계해야 하고 언어 파싱, 파서의 결과 분석, 외부 DSL 실행할 코드를 만들어야 함

이 방법을 선택해야 한다면 ANTLR 같은 자바 기반 파서 생성기를 이용하면 도움을 받을 수 있음

• 장점
  • 무한한 유연성을 가짐
  • 필요한 특성을 완벽하게 제공하는 언어로 설계 가능
  • 비즈니스 문제를 묘사하고 해결하는 가독성 좋은 언어 선택 가능
  • 자바로 개발된 인프라구조 코드와 비즈니스 코드를 명확하게 분리 가능
• 단점
  • 일반적인 작업이 아니며 쉽게 기술을 얻을 수 없음
  • 작업이 복잡하고 제어 범위를 쉽게 벗어날 수 있음
  • 처음 설계한 목적을 벗어나는 경우가 많음
  • DSL과 호스트 언어 사이에 인공 계층이 생김

10.2 최신 자바 API의 작은 DSL

네이티브 자바 API 에는 자바 새로운 기능의 장점들이 적용되었다.

스트림 API 를 통해 DSL 이 사용된 예를 확인한다.

스트림 API는 컬렉션을 조작하는 DSL

Stream 인터페이스는 네이티브 자바 API 에 작은 내부 DSL을 적용한 좋은 예다.

컬렉션의 항목을 필터, 정렬, 변환, 그룹화, 조작하는 작지만 강력한 DSL 이다.

Stream 인터페이스를 이용하여 함수형으로 구현하면 쉽고 간결하다.

스트림 API의 플루언트 형식 또한 설계된 DSL의 특징 중 하나이다.(중간 연산 게으름, 다른 연산으로 파이프라인 가능)

**Files.**lines**(Paths.**get**(**fileName**)).**filter**(**line **->** line**.**startWith**(**"ERROR"**)).**limit**(**40**).**collect**(**toList**());**

데이터를 수집하는 DSL인 Collectors

Collector 인터페이스는 데이터 수집(수집, 그룹화, 파이션)을 수행하는 DSL로 간주할 수 있다.

특히 다중 필드 정렬을 지원하도록 합쳐질 수 있으며, Collectors 는 다중 수준 그룹화를 달성할 수 있도록 합쳐질 수 있다.

**Map<String,** **Map<Color,** **List<Car>>>** carsByBrandAndColor **=** cars**.**stream**().**collect**(**grouping**(**Car:**:**getBrand**,** groupingBy**(**Car:**:**getColor**)));**

*// 두 Comparators 연결*
**Comparator<Person>** comparator **=** comparing**(**Person:**:**getAge**).**thenComparing**(**Person:**:**getName**);**

*// 중첩*
**Collector<?** **super** **Car,** **?,** **Map<Brand,** **Map<Color,** **List<Car>>>>** carGroupingCollector **=**groupingBy**(**Car:**:**getBrand**,** groupingBy**(**Car:**:**getColor**));**

10.3 자바로 DSL을 만드는 패턴과 기법

• 주식 가격을 모델링하는 순수 자바 빈즈

public class Stock {
    private String symbol;
    private String market;
    public String getSymbol(){
        return symbol;
    }
    public void setSymbol(String symbol) {
        this.symbol = symbol;
    }
    ...
}
public class Trade {
    public enum Type { BUY, SELL }

    private Type type;
    private Stock stock;
    private int quantity;
    private double price;
    ...
}

public class Order {
    private String customer;
    private List<Trade> trades = new ArrayList<>();
    ...
}

주문 생성 코드

Order order = new Order();
order.setCustomer("BigBank");

Trade trade1 = new Trade();
trade1.setType(Trade.Type.Buy);

Stock stock1 = new Stock();
stock1.setSymbol("IBM");
stock1.setMarket("NYSE");

trade.setStock(stock1);
...

하지만 이러한 코드는 장황하고 비개발자인 도메인 전문가가 이해하고 검증하기 어렵다.

직관적으로 도메인 모델을 반영할 수 있는 DSL 이 필요하다. 이 책에서는 다음과 같은 DSL 패턴들을 소개하고 있다.

• 메서드 체인
• 중첩된 함수
• 람다 표현식을 이용한 함수 시퀀싱

메서드 체인

메서드 체인은 DSL 에서 가장 흔한 방식 중 하나이다.

• 장점

  • 사용자가 지정된 절차에 따라 플루언트 API의 메서드 호출을 강제
  • 파라미터가 빌더 내부로 국한 됨
  • 메서드 이름이 인수의 이름을 대신하여 가독성 개선
  • 문법적 잡음이 최소화
  • 선택형 파라미터와 잘 동작
  • 정적 메서드 사용을 최소화하거나 없앨 수 있음

• 단점

  • 빌더를 구현해야 함
  • 상위 수준의 빌더를 하위 수준의 빌더와 연결할 많은 접착 코드가 필요
  • 도멘인 객체의 중첩 구조와 일치하게 들여쓰기를 강제할 수 없음

Order order = forCustomer("BigBank")
    .buy(80)
    .stock("IBM")
    .on("NYSE")
    ...
    .end();

⇒ 최상 수준 빌더를 만들고 주문을 감싸서 거래를 추가할 수 있도록 해야 함

public class MethodChainingOrderBuilder {

    public final Order order = new Order();

    private MethodChainingOrderBuilder(String customer) {
        order.setCustomer(customer);
    }
    public static MethodChainingOrderBuilder forCustomer(String customer) {
        return new MethodChainingOrderBuilder(customer);
    }
    public TradeBuilder buy(int quantity) {
        return new TradeBuilder(this, Trade.Type.SELL, quantity);
    }
    public MethodChainingOrderBuilder addTrade(Trade trade) {
        order.addTrade(trade);
        return this;
    }
    public Order end() {
        return order;
    }
}

public class TradeBuilder {
    private final MethodChainingOrderBuilder builder;
    public final Trade trade = new Trade();

    private TradeBuilder(MethodChainingOrderBuilder builder, Trade.Type type, int quantity) {
        this.builder = builder;
        trade.setType(type);
        trade.setQuantity(quantity);
    }
    public StockBuilder stock(String symbol) {
        return new StockBuilder(builder, trade, symbol);
    }
}

public class StockBuilder {
    private final MethodChainingOrderBuilder builder;
    private final Trade trade;
    private final Stock stock = new Stock();

    private StockBuilder(MethodChainingOrderBuilder builder, Trade trade, String symbol) {
        this.builder = builder;
        this.trade = trade;
        stock.setSymbol(symbol);
    }
    public TradeBuilderWithStock on(String market) {
        stock.setMarket(market);
        trade.setStock(stock);
        return new TradeBuilderWithStock(builder, trade);
    }
}

public class TradeBuilderWithStock {
    private final MethodChainingOrderBuilder builder;
    private final Trade trade;

    public TradeBuilderWithStock(MethodChainingOrderBuilder builder, Trade trade) {
        this.builder = builder;
        this.trade = trade;
    }
    public MethodChainingOrderBuilder at(double price) {
        trade.setPrice(price);
        return builder.addTrade(trade);
    }
}

중첩된 함수 이용

중첩된 함수 DSL 패턴은 다른 함수 안에 함수를 이용해 도메인 모델을 만든다.

• 장점
  • 중첩 방식이 도메인 객체 계층 구조에 그대로 반영
  • 구현의 장황함을 줄일 수 있음
• 단점
  • 결과 DSL 에 더 많은 괄호를 사용
  • 정적 메서드 사용이 빈번
  • 인수 목록을 정적 메서드에 넘겨줘야 함
  • 인수의 의미가 이름이 아니라 위치에 의해 정의 됨
  • 도메인에 선택 사항 필드가 있으면 인수를 생략할 수 있으므로 메서드 오버로딩 필요

Order order = order("BigBank",
                    buy(80, stock("IBM", on("NYSE")), at(125.00)),
                    sell(50, stock("GOOGLE", on("NASDAQ")), at(375.00))
                    );

구현 코드

public class NestedFunctionOrderBuilder {

    public static Order order(String customer, Trade... trades) {
        Order order = new Order();
        order.setCustomer(customer);
        Stream.of(trades).forEach(order::addTrade);
        return order;
    }
    public static Trade buy(int quantity, Stock stock, double price) {
        return buildTrade(quantity, stock, price, Trade.Type.BUY);
    }
    private static Trade buildTrade(int quantity, Stock stock, double price, Trade.Type type) {
        Trade trade = new Trade();
        trade.setQuantity(quantity);
        trade.setType(type);
        trade.setStock(stock);
        trade.setPrice(price);
        return trade;
    }
    public static double at(double price) {
        return price;
    }
    publid static Stock stock(String Symbol, String market) {
        Stock stock = new Stock();
        stock.setSymbol(symbol);
        stock.setMarket(market);
        return stock;
    }
}

람다 표현식을 이용한 함수 시퀀싱

람다 표현식으로 정의한 함수 시퀀스를 사용한다.

• 장점
  • 플루언트 방식으로 도메인 객체 정의 가능
  • 중첩 방식이 도메인 객체 계층 구조에 그대로 반영
  • 선택형 파라미터와 잘 동작
  • 정적 메서드를 최소화하거나 없앨 수 있음
  • 빌더의 접착 코드가 없음
• 단점
  • 설정 코드가 필요
  • 람다 표현식 문법에 의한 잡음의 영향을 받음

조합하기

중첩된 함수 패턴과 람다 기법을 혼용하면 다음과 같이 사용할 수 있다.

• 장점
  • 가독성 향상
• 단점
  • 여러 기법을 혼용했기 때문에 사용자가 DSL을 배우는 시간이 오래 걸림