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

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

10.1 도메인 전용 언어

DSL은 특정 비즈니스 도메인의 문제를 해결하려고 만든 언어이다.

DSL이란 특정 비즈니스 도메인을 인터페이스로 만든 API라고 생각할 수 있다.

• 코드의 의도가 명확히 전달되어야 하며 프로그래머가 아닌 사람도 이해할 수 있어야 한다.
• 가독성은 유지보수의 핵심이다

10.1.1 DSL의 장점과 단점

• 장점
  • 간결함: API는 비즈니스 로직을 캡슐화하여 반복을 피하고 코드를 간결하게 한다
  • 가독성: 비 도메인 전문가도 코드를 쉽게 이해할 수 있다
  • 유지보수: 잘 설계된 DSL로 구현한 코드는 쉽게 유지보수하고 바꿀 수 있다
  • 높은 수준의 추상화: 추상화 수준에서 동작하므로 도메인과 직접적으로 관련되지 않은 세부사항을 숨긴다
  • 집중: 프로그래머가 특정 코드에 집중할 수 있고 결과적으로 생산성이 좋아진다
  • 관심사의 분리: 어플리케이션의 인프라 구조와 관련된 문제와 독립적으로 비즈니스 관련된 코드에 집중하기 용이하다. 결과적으로 유지보수가 쉬운 코드를 구현한다.
• 단점
  • 설계의 어려움: 간결하게 제한적인 언어에 도메인 지식을 담는 것은 쉽지 않다
  • 개발 비용: 초기 프로젝트에 많은 비용과 시간이 소모되며 유지보수와 변경은 부담을 주는 요소이다
  • 추가 우회 계층: DSL은 추가 계층으로 도메인 모델을 감싸며 계층을 최대한 작게 만들어 성능 문제를 회피해야 한다.
  • 새로 배워야하는 언어: 팀이 배워야하는 언어가 한 개 더 늘어난다는 부담이 있다
  • 호스팅 언어 한계: 장황한 프로그래밍 언어를 기반으로 만든 DSL은 성가신 문법의 제약을 받고 읽기가 어려워진다.

10.1.2 JVM에서 이용할 수 있는 다른 DSL 해결책

내부 DSL

자바 기준으로 자바로 구현한 DSL을 의미한다.

장점

• 기존 자바 언어를 이용하면 외부 DSL에 비해 새로운 기술에 대한 노력이 현저하게 줄어든다.
• 다른 언어의 컴파일러를 이용하거나 외부 DSL 도구에 대한 추가 비용이 들지 않는다
• 새로운 언어를 배우지 않아도 된다
• 기존 자바 IDE의 자동 완성, 자동 리팩터링 같은 기능을 그대로 사용할 수 있다.
• 추가 DSL을 개발해야 하는 상황에 쉽게 합칠 수 있다.

다중 DSL

JVM에서 실행되는 언어는 100개가 넘는다.

단점

• 새로운 프로그래밍 언어를 배우거나 이미 해당 기술을 가지고 있어야 한다.
• 여러 컴파일러로 소스를 빌드하도록 빌드 과정을 개선해야 한다.
• 자바와 호환성이 완벽하지 않아 성능 손실이 발생할 수도 있다.

외부 DSL

자신만의 문법과 구문으로 새 언어를 설계해야 한다.

장점은 무한한 유연성을 제공한다는 것이지만, 비즈니스 코드의 분리로 인공 계층이 생기기 때문에 양날의 검과 같다.

10.2 최신 자바 API의 작은 DSL

• 네이티브 자바 API

자바 8에서 람다와 메서드 참조를 통해 재사용성과 메서드 결합도가 높아졌다.

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

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

List<String> errors = new ArrayList<>();
int errorCount = 0;
BufferedReader bufferedReader
	= new BufferedReader(new FileReader(fileName));
String line = bufferedReader.readLine();
while (errorCount < 40 && line != null) {
	if (line.startWith("ERROR")) {
		errors.add(line);
		errorCount++;
	}
	line = bufferedReader.readLine();
}

코드가 장황에 의도를 한눈에 파악하기 어려운 코드이다.

이를 Stream 인터페이스를 이용해 함수형으로 구현하면 쉽고 간결하게 코드를 구현할 수 있다.

List<String> errors = Files.lines(Paths.get(fileName)
													 .filter(line -> line.startsWith("ERROR"))
													 .limit(40)
													 .collect(toList());

스트림 API의 플루언트 형식은 잘 설계된 DSL의 특징이다.

10.2.2 데이터를 수집하는 DSL인 Collectors

Collector 인터페이스는 데이터 수집을 수행하는 DSL로 간주할 수 있다.

그룹화 평가 순서가 달라질 수 있는데 이는 GroupingBuilder 를 만들어 작업을 위임하면 해결할 수 있다.

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

10.3.1 메서드 체인

DSL에서 가장 흔한 방식이다. 이를 이용하면 한 개의 메서드 호출 체인으로 거래 주문을 정의할 수 있다.

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

이를 위해 플루언트 API로 도메인 객체를 만드는 몇 개의 빌더를 구현해야 한다.

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.BUY, quantity);
		}

		public TradeBuilder sell(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;
		}
}

buy, sell 메서드는 다른 주문을 만들어 추가할 수 있도록 자신을 만들어 반환한다

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

Stock 클래스의 인스턴스를 만드는 TradeBuilder 의 공개 메서드를 이용해야 한다.

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

주식 시장을 지정하고 거래에 주식을 추가하고 최종 빌더를 반환하는 on 메서드 한 개를 정의한다.

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

사용자가 미리 지정된 절차에 따라 플루언트 API의 메서드를 호출하도록 강제하여 기존 거래를 올바로 설정하게 된다.

다만 상위 수준의 빌더를 하위 수준의 빌더와 연결할 접착 많은 코드가 필요하다는 것이 단점이다.

10.3.2 중첩된 함수 이용

다름 함수 안에 함수를 이용해 도메인 모델을 만드는 DSL 패턴이다.

Order oder = 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);
		}

		public static Trade sell(int quantity, Stock stock, double price) {
				return buildTrade(quantity, stock, price, Trade.Type.SELL);
		}

		private static Trade buildTrade(int quantity, Stock stock, double price, Trade.Type buy) {
				Trade trade = new Trade();
				trade.setQuantity(quantity);
				trade.setType(buy);
				trade.setStock(stock);
				trade.setPrice(price);
				return trade;
		}

		public static double at(double price) {
				return price;
		}

		public static Stock stock(String symbol, String market) {
				Stock stock = new Stock();
				stock.setSymbol(symbol);
				stock.setMarket(market);
				return stock;
		}

		public static String on(String market) {
				return market;
		}
}

메서드 체이닝에 비해 구현이 간단하다.

하지만 결과 DSL에 더 많은 괄호를 사용해야 하고 인수 목록을 정적 메서드에 넘겨줘야 한다는 제약이 있다.

인수 생략에 대한 가능성을 처리할 수 있도록 여러 메서드 오버라이드를 구현해야 한다.

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

public class LambdaOrderBuilder {
		private Order order = new Order();

		public static Order order(Consumer<LambdaOrderBuilder> consumer) {
				LambdaOrderBuilder builder = new LambdaOrderBulider();
				consumer.accept(builder)
				return builder.order;
		}

		public void forCustomer(String customer) {
				order.setCustomer(customer);
		}

		public void buy(Consumer<TradeBuilder> consumer) {
				trade(consumer, Trade.Type.BUY);
		}

		public void sell(Consumer<TradeBuilder> consumer) {
				trade(consumer, Trade.Type.SELL);
		}

		private void trade(Consumer<TradeBuilder> consumer, Trade.Type type) {
				TradeBuilder builder = new TradeBulder();
				builder.trade.setType(type);
				consumer.accept(builder);
				order.addTrade(builder.trade);
		}
}

buy sell 메서드는 두 개의 Consumer 람다 표현식을 받고, 이를 실행하면 거래가 만들어진다.

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

		public void quantity(int quantity) {
				trade.setQuantity(quantity);
		}

		public void price(double price) {
				trade.setPrice(price);
		}

		public void stock(Consumer<StockBuilder> consumer) {
				StockBuilder builder = new StockBuilder();
				consumer.accept(builder);
				trade.setStock(builder.stock);
		}
}

public class StockBuilder {
		private Stock stock = new Stock();

		public void symbol(String symbol) {
				stock.setSymbol(symbol);
		}

		public void market(String market) {
				stock.setMarket(market);
		}
}

메서드 체인 패턴처럼 플루언트 방식으로 거래 주문을 정의할 수 있고,

중첩 함수 형식처럼 다양한 람다 표현식의 중첩 수준과 비슷하게 도메인 객체의 계층 구조를 유지한다.

다만 DSL 자체가 자바 8 람다 표현식 문법에 의한 잡음의 영향을 받게 된다.

10.3.4 조합하기

Order order =
		forCustomer("BigBank",
								buy(t -> t.quantity(80
													.stock("IBM") // 거래 객체를 만드는 람다 표현식 바디의 메서드 체인
													.on("NYSE")
													.at(125.00)),
								sell(t -> t.quantity(50)
													 .stock("GOOGLE")
													 .on("NASDAQ")
													 .at(125.00)) );

public class MixedBuilder {

		public static Order forCustomer(String customer, TradeBuilder... builders) {
				Order order = new Order();
				order.setCustomer(customer);
				Stream.of(builders).forEach(b -> order.addTrade(b.trade));
				return order;
		}

		public static TradeBuilder buy(Consumer<TradeBuilder> consumer) {
				return buildTrade(consumer, Trade.Type.BUY);
		}

		public static TradeBuilder sell(Consumer<TradeBulder> consumer) {
				return buildTrade(consumer, Trade.Type.SELL);
		}

		private static TradeBuilder buildTrade(Consumer<TradeBuilder> consumer, Trade.Type type) {
				TradeBuilder builder = new TradeBuilder();
				builder.trade.setType(buy);
				consumer.accept(builder);
				return builder;
		}
}

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

		public TradeBuilder quantity(int quantity) {
				trade.setQuantity(quantity);
				return this;
		}

		public TradeBuilder at(double price) {
				trade.setPrice(price);
				return this;
		}

		public StockBuilder stock(String symbol) {
				return StockBuilder(this, trade, symbol);
		}
}

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

		private StockBuilder(TradeBuilder builder, Trade trade, String symbol){
				this.builder = builder;
				this.trade = trade;
				stock.setSymbol(symbol);
		}

		public TradeBuilder on(String market) {
				stock.setMarket(market);
				trade.setStock(stock);
				return builder;
		}
}

세 가지 DSL 패턴을 혼용해 가독성 있는 DSL을 만드는 방법이 있다.

여러 패턴의 장점을 활용할 수 있지만 여러 가지 기법을 혼용하고 있기 때문에 사용자가 DSL을 배우는데 오랜 시간이 걸리게 된다.

10.3.5 DLS에 메서드 참조 사용하기

public class TaxCalculator {
		private boolean useRegional;
		private boolean useGeneral;
		private boolean useSurcharge;

		public TaxCalculator withTaxRegional() {
				useRegoinal = true;
				return this;
		}

		public TaxCalculator withTaxGeneral() {
				useGeneral = true;
				return this;
		}

		public TaxCalculator withTaxSurcharge() {
				useSurcharge = true;
				return this;
		}

		public double calculate(Order order) {
				return calculate(order, useRegional, useGeneral, useSurcharge);
		}
}

double value = new TaxCalculator().withTaxRegional()
																	.withTaxSurcharge()
																	.calculate(order)

TaxCalculator 는 지역 세금과 추가 요금을 주문에 추가하고 싶다는 점을 명확하게 보여주지만

코드가 장황하다는 것이 문제이다.

자바의 함수형 기능을 이용하면 더 간결하고 유연한 방식으로 가독성을 달성할 수 있다.

public class TaxCalculator {
		public DoubleUnaryOperator taxFunction = d -> d;

		public TaxCalculator with(DoubleUnaryOperator f) {
				taxFunction = taxFunction.andThen(f);
				return this;
		}

		public double calculate(Order order) {
				return taxFunction.applyAsDouble(order.getValue());
		}
}

double value = new TaxCalculator().with(Tax::regional)
																	.with(Tax::surcharge)
																	.calculate(order);

이 기법은 주문의 총 합에 적용할 함수 한 개의 필드만 필요로하며, TaxCalculator 클래스를 통해 모든 세금 설정이 적용된다.

10.4 실생활의 자바 8 DSL

10.4.1 jOOQ

SQL을 구현하는 내부적 DSL로 자바에 직접 내장된 형식 안정 언어이다.

데이터베이스 스키마를 역공학하는 소스코드 생성기 덕분에 자바 컴파일러가 복잡한 SQL 구문의 형식을 확인할 수 있다.

create.selectFrom(BOOK)
			.where(BOOK.PUBLISHED_IN.eq(2016))
			.orderBy(BOOK.TITLE)

스트림 API와 조합해 사용할 수 있다는 것이 또다른 장점이다.

10.4.2 큐컴버

BDD(동작 주도 개발)는 테스트 주도 개발의 확장으로 다양한 비즈니스 시나리오를 구조적으로 서술하는 간단한 도메인 전용 스크립팅 언어를 사용한다.

큐컴버 스크립팅 언어로 간단한 비즈니스 시나리오를 정의할 수 있다.

Feature: Buy stock
	Senario: Buy 10 IBM stocks
		Given the price of a "IBM" stock is 125$
		When I buy 10 "IBM"
		Then the order value should be 1250$

전제조건 정의 Given

시험하려는 도메인 객체의 실질 호출 When

테스트 케이스의 결과를 확인하는 Assertion Then

세 가지로 구분되는 개념을 사용한다.

public class BuyStocksSteps {
	private Map<String, Integer> stockUnitPrices = new HashMap<>();
	private Order order = new Order();

	@Given("^the price of a \"(.*?)\" stock is (\\d+\\$$")
	public void setUnitPrice(String stockName, int unitPrice) {
		stockUnitValues.put(stockName, unitPrice);
	}

	@When("\I buy (\\d+) \"(.*?)\"$")
	public void buyStocks(int quantity, String stockName) {
		...
	}

	@Then("^the Order value should be (\\d+)\\$$")
	public void checkOrderValue(int expectedValue) {
		assertEqulas(expectedValue, order.getValue());
	}
}

자바 8이 람다 표현식을 지원하면서 두 개의 인수 메서드를 이용해 어노테이션을 제거하는 다른 문법을 개발할 수도 있다.

public class BuyStocksSteps {
	private Map<String, Integer> stockUnitPrices = new HashMap<>();
	private Order order = new Order();

	public BuyStocksSteps() {
		Given("^the price of a \"(.*?)\" stock is (\\d+\\$$",
			(String stockName, int unitPrice) -> {
				stockUnitValues.put(stockName, unitPrice);
			});
		...
	}

테스트 메서드가 무명 람다로 바뀌면서 의미를 가진 메서드 이름을 찾는 부담이 없어졌다.

10.4.3 스프링 통합

유명한 엔터프라이즈 통합 패턴을 지원할 수 있도록 의존성 주입에 기반한 스프링 프로그래밍 모델을 확장한다.

스프링 기반 어플리케이션 내의 경량의 원격, 메세징, 스케쥴링을 지원하고 채널, 엔드포인트, 폴러, 채널 인터셉터 등 메세지 기반의 어플리케이션에서 필요한 가장 공통의 패턴을 모두 구현한다.

@Configuration
@EnableIntegration
public class MyConfiguration {
	@Bean
	public MessageSource<?> integerMessageSource() {
		MethodInvokingMessageSource source = new MethodInvokingMessageSource();
		source.setObject(new AtomicInteger());
		source.setMethodName("getAndIncrement");
		return source;
	}

	@Bean
	public DirectChannel inputChannel() {
		return new DirectChannel();
	}

	@Bean
	public IntegrationFlow myFlow() {
		return IntegrationFlows
				.from(this.integerMessageSource(), c -> c.poller(Pollers.fixedRate(10)))
				.channel(this.inputChannel())
				.filter((Integer p) -> p % 2 == 0)
				.transform(Object::toString)
				.channel(MessageChannels.queue("queueChannel"))
				.get();
	}
}

메서드 체인 패턴을 구현하는 IntegrationFlows 클래스가 제공하는 유연한 빌더를 사용한다.

플로우는 고정 속도로 MessageSource 를 폴링하면서 일련의 정수를 제공하고, 홀수를 문자열로 변환해 최종적으로 결과를 출력 채널에 전달한다.