도메인 주도 개발 스터디

Chapter 2 아키텍처 개요

막이86 2023. 11. 8. 17:35

728x90

도메인 주도 개발 시작하기 2장을 요약한 내용입니다.

2.1 네 개의 영역

“표현”, “응용”, “도메인”, “인프라스트럭처”는 아키텍처를 설계할 때 출현하는 전형적인 네 가지 영역
- 표현 영역
  - 사용자의 요청을 받아 응용 영역에 전달, 응용 영역의 처리 결과를 사용자에게 전달
  - 스프링 MVC 프레임워크가 표현 영역의 기술
- 응용 영역
  - 표현 영역을 통해 사용자의 요청을 전달받은 응용 영역은 시스템이 사용자에게 제공해야할 기능을 구현
  - “주문 등록”, “주문 취소”, “상품 상세 조회” 등의 기능을 예로 들수 있다.
  - 기능을 구현하기 위한 도메인 영역의 도메인 모델을 사용
  - “주문 취소” 기능을 제공하는 응용 서비스를 도메인 모델을 사용해서 기능 구현이 가능
  - public class CancelOrderService { @Transactional public void cancelOrder(String orderId) { Order order = findOrderById(orderId); if (order == null) { throw new OrderNotFoundException(orderId); } order.cancel(); } }
  - 로직을 직접 수행하기보다는 도메인 모델에 로직 수행을 위임
    - “주문 취소” 로직을 직접 구현하지 않고 Order 객체에 취소 처리를 위임 하고 있다
- 도메인 영역
  - Order, OrderLine, ShippingInfo와 같은 도메인 모델
  - 도메인 모델은 핵심 로직을 구현한다.
    - “배송지 변경”, “결제 완료”, “주문 총액 계산”과 같은 핵심 로직을 도메인 모델에 구현한다.
- 인프라스트럭처 영역
  - 구현 기술에 대한 것을 다룬다
  - RDBMS 연동, 메시징 큐에 메시지 전송과 수신, 몽고DB나 레디스의 데이터 연동 처리 등
  - 논리적인 개념을 표현하기보다는 실제 구현을 다룬다
  - 도메인 영역, 응용 영역, 표현 영역은 구현 기술을 사용한 코드를 직접 만들지 않는다.
    - 인프라스트럭처 영역에서 제공하는 기능을 사용해서 필요한 기능을 개발

2.2 계층 구조 아키텍처

네 영역을 구성할 때 많이 사용하는 아키텍처가 그림과 같은 계층 구조이다.
- 표현 영역과 응용 영역은 도메인 영역을 사용
- 도메인 영역은 인프라스트럭처 영역을 사용
도메인의 복잡도에 따라 응용과 도메인을 분리하기도 하고 한 계층으로 합치기도 하지만 전체적인 아키텍처는 계층 구조를 따른다.
계층 구조는 특성상 상위 계층에서 하위 계층으로의 의존만 존재하고 하위 계층은 상위 계층에 의존하지 않는다.
계층 구조를 엄격하게 적용한다면 상위 계층은 바로 아래의 계층에만 의존을 가져야 하지만 구현의 편리함을 위해 계층 구조를 유연하게 적용하기도 한다.
응용 영역과 도메인 영역은 DB나 외부 시스템 연동을 위해 인프라스트럭처의 기능을 사용하므로 계층 구조를 사용하는 것이 직관적으로 이해하기 쉽다.
- 표현, 응용, 도메인 계층이 상세한 구현 기술을 다루는 인프라스트럭처 계층에 종속된다

도메인의 가격 계산 규칙의 예제

할인 금액을 계산하기 위해 Drools라는 룰 엔진을 사용해서 계산 로직을 수행하는 인프라스트럭처 영역의 코드를 만들어 보자

public class DroolsRuleEngine {
	private KieContainer kContainer;

	public DroolsRuleEngine() {
		KieServices ks = KieServices.Factory.get();
		kContainer = ks.getKieClasspathContainer();		
	}

	public void evalute(String sessionName, List<?> facts) {
		KiSession kSession = kContainer.newKieSession(sessionName);
		try {
			facts.forEach(x -> kSession.insert(x));
			kSession.fireAllRules();
		} finaly {
			kSession.dispose();
		}
	}
}

응용 영역은 가격 계산을 위해 인프라스트럭처 영역의 DroolsRuleEngine을 사용

public class CalcuateDiscountService {
	private DroolsRuleEngine ruleEngine;
	
	public CalculateDiscountService() {
		ruleEngine = new DroolsRuleEngine();
	}

	public Money calculateDiscount(List<OrderLine> orderLines, String customerId) {
		Customer customer = findCustomer(customerId);
		
		MutableMoney money = new MutableMoney(0);
		List<?> facts = Arrays.asList(customer, money);
		facts.addAll(orderLines);
		ruleEngine.evalute("discountCalculation", facts);
		return money.toImmutableMoney();
	}
}

CalculateDiscountService가 동작은 하겠지만 두가지 문제를 안고 있다.
- CalculateDiscountService를 테스트하기 어렵다
  - RuleEngine이 완벽하게 동작해야 한다.
  - RuleEngine 클래스와 관련 설정 파일 모두 만든 이후에 CalculateDiscountService 를 확인할 수 있다.
- 구현 방식을 변경하기 어렵다
  - ‘discountCalculation’ 문자열은 Drools의 세션 이름을 의미한다.
  - 세션 이름을 변경하면 CalculateDiscountService 코드도 함께 변경해야 한다.
CalculateDiscountService가 겉으로는 인프라스트럭처의 기술에 직접적인 의존을 하지 않는 것처럼 보여도 실제로는 Drools라는 인프라스트럭처 영역의 기술에 완전하게 의존하고 있다.
인프라스트럭처에 의존하면 ‘테스트 어려움’과 ‘기능 확장 어려움’이라는 두가지 문제가 발생한다.
- 문제 해답은 DIP에 있다.

2.3 DIP

가격 할인 계산을 하려면 고객 정보를 구해야하고, 구한 고객 정보와 주문 정보를 이용해서 룰을 실행해야 한다.
CalculateDiscountService는 고수준 모듈이다.
- 고수준 모듈은 의미 있는 단일 기능을 제공하는 모듈로 ‘가격 할인 계산’이라는 기능을 구현
- 가격 할인 계싼 기능을 구현하려면 고객 정보를 구해야하고 룰을 실행해야 하는데 이 두 기능이 하위 기능이다.
저수준 모듈은 하위 기능을 실제로 구현한 것이다.
- JPA를 이용해서 고객 정보를 읽어오는 모듈과 Drools로 룰을 실행하는 모듈이 저수준 모듈이 된다.

DIP는 저수준 모듈이 고수준 모듈에 의존하도록 바꾼다.

추상화 인터페이스를 사용

public interface RuleDiscounter {
	Money applyRules(Customer customer, List<OrderLine> orderLines);
}

CalculateDiscountService가 RuleDiscounter를 이용하도록 변경
- Drools에 의존하는 코드가 없다

public class CalcuateDiscountService {
	private RuleDiscounter ruleDiscounter;
	
	public CalculateDiscountService(RuleDiscounter ruleDiscounter) {
		this.ruleDiscounter = ruleDiscounter;
	}

	public Money calculateDiscount(List<OrderLine> orderLines, String customerId) {
		Customer customer = findCustomer(customerId);
		return ruleDiscounter.applyRules(customer, orderLines);
	}
}

RuleDiscounter를 상속받아 구현

public class DroolsRuleDiscounter implements RuleDiscounter {
	private KieCountainer kContainer;
	
	public DroolsRuleEngine() {
		KieService ks = KieServices.Factory.get();
		kContainer = ks.getKieClasspathContainer();
	}

	@Override
	public Money applyRules(Customer customer, List<OrderLine> orderLines) {
		KieSession kSession = kContainer.newKieSession("discountSession");
		try {
			...
			kSession.fireAllRules();
		} finally {
			kSession.dispose();
		}
		return money.toImmutableMoney();
	}
}

RuleDiscounter가 출현하면서 바뀐 구조
CalculateDiscountService는 더이상 구현 기술인 Drools에 의존하지 않는다.
- RuleDiscounter 인터페이스에 의존할 뿐
- ‘룰을 이용한 할인 금액 계산’은 고수준 모듈의 개념이므로 RuleDiscounter 인터페이스는 고수준 모듈에 속한다.
- DroolsRuleDiscounter는 고수준의 하위 기능인 RuleDiscounter를 구현한 것이므로 저수준 모듈에 속한다.

DIP를 적용하면 저수준 모듈이 고수준 모듈에 의존하게 된다.
- 고수준 모듈이 저수준 모듈을 사용하려면 고수준 모듈이 저수준 모듈에 의존해야 하는데, 반대로 저수준 모듈이 고수준 모듈에 의존한다고 해서 이를 DIP(Dependency Inversion Principle, 의존 역전 원칙)이라 부른다.
DIP를 적용하면 다른 영역인 인프라스트럭처 영역에 의존할 떄 발생했던 두가지 문제인 구현 교체가 어렵다는 것과 테스트가 어려운 문제를 해소할 수 있다.

고수준 모듈은 더 이상 저수준 모듈에 의존하지 않고 구현을 추상화한 인터페이스에 의존할 수 있다.

구현 기술이 변경되더라도 저수준 구현 객체를 생성하는 코드만 변경하면 된다.

// 기존 코드
RuleDiscounter roleDiscounter = new DroolsRuleDiscounter();
CalculateDiscountService disService = new CalculateDiscountService(roleDiscounter);

// 구현 기술 변경 
RuleDiscounter roleDiscounter = new SimpleRuleDiscounter();
CalculateDiscountService disService = new CalculateDiscountService(roleDiscounter);

스프링과 같은 의존 주입을 지원하는 프레임워크를 사용하면 설정 코드를 수정해서 쉽게 구현체를 변경할 수 있다.
CalculateDiscountService가 제대로 동작하는지 테스트하려면 CustomerRepository와 RuleDiscounter를 구현한 객체가 필요하다.
- CacluateDiscountService가 저수준 모듈에 직접 의존했다면 저수준 모듈이 만들어지기 전까진 테스트를 할 수 없음
- 인터페이스에 의존함으로 대역 객체를 사용해서 테스트를 진행 할수 있다.
- 실제 구현 대신 스텁이나 모의 객체와 같은 테스트 목적의 대역을 사용하여 거의 모든 상황을 테스트할 수 있다.
```
public class CalculateDiscountServiceTest {
	@Test
	public void noCustomer_thenExcetionShouldBeThrown() {
		CustomerRepository stubRepo = mock(CustomerRepository.class);
		when(stubRepo.findById("noCustId")).thenRetrun(null);

		RuleDiscounter stubRule = (cust, lines) -> null;
		
		CalculateDiscountService calDisSvc = new CalculateDiscountService(stbRepo, stubRule);
		assertThrows(NoCustomerException.class, () -> calDisSvc.calculateDiscount(ssomeLines, "noCustId"));
	}
}
```
실제 구현 없이 테스트를 할 수 있는 이유는 DIP를 적용해서 고수준 모듈이 저수준 모듈에 의존하지 않도록 했기 때문이다.

2.3.1 DIP 주의사항

DIP를 잘못 생각하면 단순히 인터페이스와 구현 클래스를 분리하는 정도로 받아드릴 수 있다.
DIP의 핵심은 고수준 모듈이 저수준 모듈의 의존하지 않도록 하기 위함이다.
잘못된 구조
- 도메인 영역은 구현 기술을 다루는 인프라스트럭처 영역에 의존하고 있다.
- 고수준 모듈이 저수준 모듈에 의존하고 있다.
DIP를 적용할 때 하위 기능을 추상화한 인터페이스는 고수준 모듈 관점에서 도출한다.
- CalculateDiscountService는 할인 금액을 구하기 위한 룰 엔진을 사용하는지 직접 연산하는지 중요하지 않다.
- 규칙에 따라 할인 금액을 계산하는 것이 중요
- ‘할인 금액 계산’을 추상화한 인터페이스는 저수준 모듈이 아닌 고수준 모듈에 위치한다.

2.3.2 DIP와 아키텍처

인프라스트럭처 영역은 구현 기술을 다루는 저수준 모듈이고 응용 영역과 도메인 영역은 고수준 모듈이다.
인프라스트럭처 계층이 가장 하단에 위치하는 계층형 구조와 달리 아키텍처에 DIP를 적용하면 인프라스트럭처 영역이 응용 영역와 도메인 영역에 의존하는 구조가 된다.
인프라스트럭처에 위치한 클래스가 도메인이나 응용 영역에 정의한 인터페이스를 상속받아 구현하는 구조가 되므로 도메인과 응용 영역에 대한 영향을 주지 않거나 최소화하면서 구현 기술을 변경하는 것이 가능하다.
주문 시 통지 방식에 SMS를 추가해야 한다는 요구사항이 들어왔을 때 OrderService는 변경할 필요가 없다.
- 두 통지 방식을 함께 제공하는 Notifier 구현 클래스를 인프라스트럭처 영역에 추가하면 된다.
마이바티스 대신 JPA를 구현 기술로 사용하고 싶다면 JPA를 이용한 OrderRepository 구현 클래스를 인프라 스트럭처 영역에 추가하면 된다.

2.4 도메인 영역의 주요 구성요소

도메인 영역을 구성하는 요소요소 설명

엔티티 ENTITY	고유 식별자를 갖는 객체로 자신의 라이프 사이클을 갖는다. Order, Member, Product와 같이 도메인의 고유한 개념을 표현한다. 도메인 모델의 데이터를 포함하며 해당 데이터와 관련된 기능을 함께 제공
밸류 VALUE	고유 식별자를 갖지 않는 객체로 주로 개념적으로 하나의 값을 표현할 때 사용된다. 배송지 주소를 표현하기 위한 Address나 구매한 금액을 위한 Money와 같은 타입이 밸류 타입이다. 엔티티의 속성으로 사용할 뿐만 아니라 다른 밸류 타입의 속성도 사용할 수 있다.
애그리거트 AGGREGATE	애그리거트는 연관된 엔티티와 밸류 객체를 개념적으로 하나로 묶는 것이다. 주문과 관련된 Order 엔티티, OrderLine 밸류, Orderer 밸류 객체를 주문 애그리거트로 묶을 수 있다.
리포지터리 REPOSITORY	도메인 모델의 영속성을 처리한다. DBMS 테이블에서 엔티티 객체를 로딩하거나 저장하는 기능을 제공
도메인 서비스 DOMAIN SERVICE	특정 엔티티에 속하지 않는 도메인 로직을 제공한다. ‘할인 금액 계산’은 상품, 쿠폰, 회원 등급, 구매 금액 등 다양한 조건을 이용해서 구현하게 되는데 이렇게 도메인 로직이 여러 엔티티와 밸류를 필요로 하면 도메인 서비스에 로직을 구현

2.4.1 엔티티와 밸류

엔티티와 도메인 모델의 가장 큰 차이점은 도메인 모델의 엔티티는 데이터와 함께 도메인 기능을 함께 제공한다는 점
- 주문을 표현하는 엔티티는 주문과 관련된 데이터뿐만 아니라 배송지 주소 변경을 위한 기능을 함께 제공
```
public class Order {
	private OrderNo number;
	private Orderer orderer;
	private ShippingInfo shippingInfo;
	
	// 도메인 모델 엔티티는 도메인 기능도 함께 제공
	public void shangeShippingInfo(ShippingInfo newShippingInfo) {
		...	
	}
}
```
도메인 모델의 엔티티는 단순히 데이터를 담고 있는 데이터 구조라기보다는 데이터와 함께 기능을 제공하는 객체
도메인 관점에서 기능을 구현하고 기능 구현을 캡슐화해서 데이터가 임의로 변경되는 것을 막는다.
도메인 모델의 엔티티는 두 개 이상의 데이터가 개념적으로 하나인 경우 밸류 타입을 이용해서 표현할 수 있다
- Orderer는 밸류 타입으로 주문자 이름과 이메일 데이터를 포함할 수 있다.
```
public class Orderer {
	private String name;
	private String email;
}
```
RDBMS와 같은 관계형 데이터베이스는 밸류 타입을 재대로 표현하기 힘들다.
- Ordere의 개별 데이터를 저장하거나 밸로 테이블로 분리해서 저장해야 한다.
- 한 테이블에 주문자 정보 함께 넣기
  - 주문자라는 개념이 들어나지 않고 주문자의 개별 데이터만 드러난다.
- 다른 테이블에 주문자 정보 넣기
  - 주문자 데이터를 별도 테이블에 저장했지만 이것은 테이블의 엔티티에 가까우며 밸류 타입의 의미가 드러나지 않는다.

밸류는 불변으로 구현할 것을 권장

엔티티의 밸류 타입 데이터를 변경할 떄는 객체 자체를 완전히 교체한다는 것을 의미

public class Order {
	private ShippingInfo shippingInfo;
	
	public void shangeShippingInfo(ShippingInfo newShippingInfo) {
		checkShippingInfoChangeable();
		setShippingInfo(newShippingInfo);
	}

	private void setShippingInfo(ShippingInfo newShippingInfo) {
		if (newShippingInfo == null) {
			throw new IllegalArgumentException();
		}
		this.shippingInfo = newShippingInfo;
	}
}

2.4.2 애그리거트

도메인이 커질수록 개발할 도메인 모델도 커지면서 많은 엔티티와 밸류가 출현한다.
도메인 모델이 복잡해지면 개발자가 전체 구조가 아닌 한 개 엔티티와 밸류에만 집중하는 상황이 발생한다.
- 상위 수준에서 모델을 관리하지 않고 개별 요소에만 초점을 맞추다 보면, 큰 수준에서 모델을 이해하지 못해 큰 틀에서 모델은 관리할 수 없는 상황에 빠질 수 있다.
도메인 모델에 전체 구조를 이해하는데 도움이 되는 것이 바로 애그리거트(AGGREGATE)이다.
애그리거트는 관련 객체를 하나로 묶은 군집이다.
- 모메인 개념은“주문”, “배송지 정보”, “주문자”, “주문 목록”, “총 결제 금액”의 하위 모델로 구성된다.
- 하위 내념을 표현한 모델을 하나로 묶어서 “주문”이라는 상위 개념으로 표현할 수 있다.
애그리거트를 사용하면 개별 객체가 아닌 관련 객체를 묶어서 객체 군집 단위로 모델을 바라볼 수 있게 된다.
- 개별 객체 간의 관계가 아닌 애그리거트 간의 관계로 도메인 모델을 이해하고 구현하고, 큰 틀에서 도메인 모델을 관리할 수 있다.
애그리거트는 군집에 속한 객체를 관리하는 루트 엔티티를 갖는다.
- 루트 엔티티는 애그리거트에 속해 있는 엔티티와 밸류 객체를 이용해서 애그리거트가 구현해야 할 기능을 제공
- 애그리거트를 사용하는 코드는 애그리거트 루트가 제공하는 기능을 실행
- 애그리거트 루트를 통해 간접적으로 애그리거트 내의 다른 엔티티나 밸류 객체에 접근
- 애그리거트의 내부 구현을 숨겨서 애그리거트 단위로 구현을 캡슐화할 수 있도록 돕는다.
주문 애그리거트
- 애그리거트 루트인 Order는 주문 도메인 로직에 맞게 애그리거트의 상태를 관리
- Order의 배송지 정보 변경 기능은 배송지를 변경할 수 있는지를 확인한 위에 배송지 정보를 변경
- 주문 애그리거트는 Order를 통하지 않고 ShippingInfo를 변경할 수 있는 방법을 제공하지 않는다.
  - 배송지를 변경하려면 루트 엔티티인 Order를 사용해야 하므로 배소지 정보를 변경할 때는 Order가 구현한 도메인 로직을 항상 따르게 된다.
애그리거트를 구현할 때는 고려할 것이 많다.
- 애그리거트를 어떻게 구성했느냐에 따라 구현이 복잡해지기도 하고
- 트랜잭션 범위가 달라지기도 한다.

2.4.3 리포지터리

도메인 객체를 지속적으로 사용하려면 RDBMS, NoSQL, 로컬 파일과 같은 물리적인 저장소에 도메인 객체를 보관해야 한다.
- 이를 위한 도메인 모델이 리포지터리(Repository)이다.
엔티티나 밸류가 요구사항에 도출되는 도메인 모델이라면 리포리터리는 구현을 위한 도메인 모델이다.
리포지터리는 애그리거트 단위로 도메인 객체를 저장하고 조회하는 기능을 정의
- OrderRepository의 메서드를 보면 대상을 찾고 저장하는 단위가 애그리거트 루트인 Order인 것을 알 수 있다.
- Order는 애그리거트에 속한 모든 객체를 포함하고 있으므로 결과적으로 애그리거트 단위로 저장하고 조회한다.
```
public interface OrderRepository {
	Order findByNumber(OrderNumber number);
	void save(Order order);
	void delete(Order order);
}
```
도메인 모델을 사용해야 하는 코드는 리포지터리를 통해서 도메인 객체를 구한 뒤에 도메인 객체의 기능을 실행
public class CancelOrderService { private OrderRepository orderRepository; public void cancel(OrderNumber number) { Order order = orderRepository.findByNumber(number); if (order == null) { throw new OrderNotFoundException(orderId); } order.cancel(); } }
도메인 모델 관점에서 OrderRepository는 도메인 객체를 영속화하는 데 필요한 기능을 추상화 한것으로 고수준 모듈에 속한다.
기반 기술을 이용해서 OrderRepository를 구현한 클래스는 저수준 모듈로 인프라스트럭처 영역에 속한다.
전체 모듈 구조
응용 서비스는 의존 주입과 같은 방식을 사용해서 실제 리포지터리 구현 객체에 접근
응용 서비스와 리포지터리는 밀접한 연관이 있다.
- 응용 서비스는 필요한 도메인 객체를 구하거나 저장할 때 리포지터리를 사용한다.
- 응용 서비스는 트랜잭션을 관리하는데, 트랜잭션 처리는 리포지터리 구현 기술의 영향을 받는다.
리포지터리를 사용하는 주체가 응용 서비스이기 때문에 리포지터리는 응용 서비스가 필요로 하는 메서드를 제공한다.
- 애그리거트를 저장하는 메서드
- 애그리거트 루트 식별자로 애그리거트를 조회하는 메서드

2.5 요청 처리 흐름

표현 영역은 사용자가 전송한 데이터 형식이 올바른지 검사하고 문제가 없다면 데이터를 이용해서 응용 서비스에 기능 실행을 위임
표현 영역은 사용자가 전송한 데이터를 응용 서비스가 요구하는 형식으로 변환해서 전달
요청 처리 흐름
- 웹 브라우저에서 기능 실행 요청
- 표현 영역에 해당하는 컨트롤러는 HTTP 요청 파라미터를 응용 서비스가 필요로 하는 데이터로 변환 해서 응용 서비스의 인자로 전달
- 응용 서비스는 도메인 모델을 이용해서 로직 실행
- 도메인 객체를 리포지터리에서 가져와 실행하거나 신규 도메인 객체를 생성해 리포지터리에 저장
“예매하기”나 “예매 취소”와 같은 기능을 제공하는 응용 서비스는 도메인의 상태를 변경하므로 변경 상태가 물리 저장소에 올바르게 반영되도록 트랜잭션을 관리 해야한다.
- 스프링 프레임워크를 사용한다면 @Transactional 애너테이션을 이용해 트랜잭션을 처리할 수 있다.
```
public class CancelOrderService {
	private OrderRepository orderRepository;
	
	@Transactional
	public void cancel(OrderNumber number) {
		Order order = orderRepository.findByNumber(number);
		if (order == null) {
			throw new NoOrderException(number);
		}
		order.cancel()
	}
}
```

2.6 인프라스트럭처 개요

인프라스트럭처는 표현 영역, 응용 영역, 도메인 영역을 지원한다.
도메인 영역과 응용 영역에서 인프라스트럭처의 기능을 직접 사용하는 것보다 두 영역에서 정의한 인터페이스를 인프라스트럭처 영역에서 구현하는 것이 시스템을 더 유연하고 테스트하기 쉽게 만들어 준다.
무조건 인프라스트럭처에 대한 의존성을 없앨 필요는 없다.
- 스프링을 사용할 경우 응용 서비스는 트랜잭션 처리를 위해 @Transactional을 사용하는 것이 편리하다.
- 영속성 처리를 위해 JPA를 사용할 경우 @Entity나 @Table과 같은 JPA 전용 애너테이션을 도메인 모델 클래스에서 사용하는 것이 XML 매핑 설정을 이용하는 것보다 편리하다.
구현의 편리함은 DIP가 주는 다른 장점만큼 중요하기 때문에 DIP의 장점을 해치지 않는 범위에서 응용 영역과 도메인 영역에서 구현 기술에 대한 의존을 가져가는 것이 나쁘지 않다고 생각한다.
응용 영역과 도메인 영역이 인프라스트럭처에 대한 의존을 완전히 갖지 않도록 시도하는 것은 구현을 더 복잡하고 어렵게 만들 수 있다.
- @Transactional을 사용하면 한 줄로 트랙잭션을 처리할 수 있는데 코드에서 스프링에 대한 의존을 없애려면 복잡한 스프링 설정을 사용해야 한다.
- 의존은 없앴지만 특별히 테스트를 더 쉽게 할 수 있다거나 유연함을 증가시켜 주지 못한다.
- 설정만 복잡해지고 개발 시간만 늘어난다.
표현 영역은 항상 인프라스트럭처 영역과 쌍을 이룬다.
- 스프링 MVC를 사용해서 웹 요청을 처리하려면 스프링이 제공하는 MVC 프레임워크에 맞게 표현 영역을 구현
- Vert.x를 사용해서 Rest API 서버를 구축하려면 Vert.x에 맞게 웹 요청 처리 부분을 구현

2.7 모듈 구성

아키텍처의 각 영역은 별도 패키지에 위치한다.
패키지 구성 규칙에 정답이 존재하는 것은 안지만 영역별로 모듈이 위치할 패키지를 구성할 수 있을 것 이다.
도메인이 크면 하위 도메인으로 나누고 하위 도메인마다 별도 패키지를 구성한다.
도메인 모듈은 도메인에 속한 애그리거트를 기준으로 다시 패키지를 구성한다.
- 카탈로그 하위 도메인이 상품 애그리거트와 카테고리 애그리커트로 구성될 경우 도메인을 두 개의 하위 패키지로 구성할 수 있다.
애그리거트, 모델, 리포지터리는 같은 패키지에 위치시킨다.
- Order, OrderLine, Orderer, OrderRepository 등은 com.myshop.order.domain 패키지에 위치시킨다.
도메인이 복잡하면 도메인 모델과 도메인 서비스를 별도 패키지에 위치시킬 수도 있다.
- com.myshop.order.domain.order: 애그리거트 위치
- com.myshop.order.domain.service: 도메인 서비스 위치
응용 서비스도 도메인 별로 패키지를 구분할 수 있다.
- com.myshop.catalog.application.product
- com.myshop.catalog.application.category
모듈 구조를 얼마나 세분하게해야 하는지에 대한 정해진 규칙은 없다.
한 패키지에 너무 많은 타입이 몰려서 코드를 찾을 때 불편할 정도만 아니면 된다.

2.1 네 개의 영역

“표현”, “응용”, “도메인”, “인프라스트럭처”는 아키텍처를 설계할 때 출현하는 전형적인 네 가지 영역
- 표현 영역
  - 사용자의 요청을 받아 응용 영역에 전달, 응용 영역의 처리 결과를 사용자에게 전달
  - 스프링 MVC 프레임워크가 표현 영역의 기술
- 응용 영역
  - 표현 영역을 통해 사용자의 요청을 전달받은 응용 영역은 시스템이 사용자에게 제공해야할 기능을 구현
  - “주문 등록”, “주문 취소”, “상품 상세 조회” 등의 기능을 예로 들수 있다.
  - 기능을 구현하기 위한 도메인 영역의 도메인 모델을 사용
  - “주문 취소” 기능을 제공하는 응용 서비스를 도메인 모델을 사용해서 기능 구현이 가능
  - public class CancelOrderService { @Transactional public void cancelOrder(String orderId) { Order order = findOrderById(orderId); if (order == null) { throw new OrderNotFoundException(orderId); } order.cancel(); } }
  - 로직을 직접 수행하기보다는 도메인 모델에 로직 수행을 위임
    - “주문 취소” 로직을 직접 구현하지 않고 Order 객체에 취소 처리를 위임 하고 있다
- 도메인 영역
  - Order, OrderLine, ShippingInfo와 같은 도메인 모델
  - 도메인 모델은 핵심 로직을 구현한다.
    - “배송지 변경”, “결제 완료”, “주문 총액 계산”과 같은 핵심 로직을 도메인 모델에 구현한다.
- 인프라스트럭처 영역
  - 구현 기술에 대한 것을 다룬다
  - RDBMS 연동, 메시징 큐에 메시지 전송과 수신, 몽고DB나 레디스의 데이터 연동 처리 등
  - 논리적인 개념을 표현하기보다는 실제 구현을 다룬다
  - 도메인 영역, 응용 영역, 표현 영역은 구현 기술을 사용한 코드를 직접 만들지 않는다.
    - 인프라스트럭처 영역에서 제공하는 기능을 사용해서 필요한 기능을 개발

2.2 계층 구조 아키텍처

네 영역을 구성할 때 많이 사용하는 아키텍처가 그림과 같은 계층 구조이다.
- 표현 영역과 응용 영역은 도메인 영역을 사용
- 도메인 영역은 인프라스트럭처 영역을 사용
도메인의 복잡도에 따라 응용과 도메인을 분리하기도 하고 한 계층으로 합치기도 하지만 전체적인 아키텍처는 계층 구조를 따른다.
계층 구조는 특성상 상위 계층에서 하위 계층으로의 의존만 존재하고 하위 계층은 상위 계층에 의존하지 않는다.
계층 구조를 엄격하게 적용한다면 상위 계층은 바로 아래의 계층에만 의존을 가져야 하지만 구현의 편리함을 위해 계층 구조를 유연하게 적용하기도 한다.
응용 영역과 도메인 영역은 DB나 외부 시스템 연동을 위해 인프라스트럭처의 기능을 사용하므로 계층 구조를 사용하는 것이 직관적으로 이해하기 쉽다.
- 표현, 응용, 도메인 계층이 상세한 구현 기술을 다루는 인프라스트럭처 계층에 종속된다

도메인의 가격 계산 규칙의 예제

할인 금액을 계산하기 위해 Drools라는 룰 엔진을 사용해서 계산 로직을 수행하는 인프라스트럭처 영역의 코드를 만들어 보자

public class DroolsRuleEngine {
	private KieContainer kContainer;

	public DroolsRuleEngine() {
		KieServices ks = KieServices.Factory.get();
		kContainer = ks.getKieClasspathContainer();		
	}

	public void evalute(String sessionName, List<?> facts) {
		KiSession kSession = kContainer.newKieSession(sessionName);
		try {
			facts.forEach(x -> kSession.insert(x));
			kSession.fireAllRules();
		} finaly {
			kSession.dispose();
		}
	}
}

응용 영역은 가격 계산을 위해 인프라스트럭처 영역의 DroolsRuleEngine을 사용

public class CalcuateDiscountService {
	private DroolsRuleEngine ruleEngine;
	
	public CalculateDiscountService() {
		ruleEngine = new DroolsRuleEngine();
	}

	public Money calculateDiscount(List<OrderLine> orderLines, String customerId) {
		Customer customer = findCustomer(customerId);
		
		MutableMoney money = new MutableMoney(0);
		List<?> facts = Arrays.asList(customer, money);
		facts.addAll(orderLines);
		ruleEngine.evalute("discountCalculation", facts);
		return money.toImmutableMoney();
	}
}

CalculateDiscountService가 동작은 하겠지만 두가지 문제를 안고 있다.
- CalculateDiscountService를 테스트하기 어렵다
  - RuleEngine이 완벽하게 동작해야 한다.
  - RuleEngine 클래스와 관련 설정 파일 모두 만든 이후에 CalculateDiscountService 를 확인할 수 있다.
- 구현 방식을 변경하기 어렵다
  - ‘discountCalculation’ 문자열은 Drools의 세션 이름을 의미한다.
  - 세션 이름을 변경하면 CalculateDiscountService 코드도 함께 변경해야 한다.
CalculateDiscountService가 겉으로는 인프라스트럭처의 기술에 직접적인 의존을 하지 않는 것처럼 보여도 실제로는 Drools라는 인프라스트럭처 영역의 기술에 완전하게 의존하고 있다.
인프라스트럭처에 의존하면 ‘테스트 어려움’과 ‘기능 확장 어려움’이라는 두가지 문제가 발생한다.
- 문제 해답은 DIP에 있다.

2.3 DIP

가격 할인 계산을 하려면 고객 정보를 구해야하고, 구한 고객 정보와 주문 정보를 이용해서 룰을 실행해야 한다.
CalculateDiscountService는 고수준 모듈이다.
- 고수준 모듈은 의미 있는 단일 기능을 제공하는 모듈로 ‘가격 할인 계산’이라는 기능을 구현
- 가격 할인 계싼 기능을 구현하려면 고객 정보를 구해야하고 룰을 실행해야 하는데 이 두 기능이 하위 기능이다.
저수준 모듈은 하위 기능을 실제로 구현한 것이다.
- JPA를 이용해서 고객 정보를 읽어오는 모듈과 Drools로 룰을 실행하는 모듈이 저수준 모듈이 된다.

DIP는 저수준 모듈이 고수준 모듈에 의존하도록 바꾼다.

추상화 인터페이스를 사용

public interface RuleDiscounter {
	Money applyRules(Customer customer, List<OrderLine> orderLines);
}

CalculateDiscountService가 RuleDiscounter를 이용하도록 변경
- Drools에 의존하는 코드가 없다

public class CalcuateDiscountService {
	private RuleDiscounter ruleDiscounter;
	
	public CalculateDiscountService(RuleDiscounter ruleDiscounter) {
		this.ruleDiscounter = ruleDiscounter;
	}

	public Money calculateDiscount(List<OrderLine> orderLines, String customerId) {
		Customer customer = findCustomer(customerId);
		return ruleDiscounter.applyRules(customer, orderLines);
	}
}

RuleDiscounter를 상속받아 구현

public class DroolsRuleDiscounter implements RuleDiscounter {
	private KieCountainer kContainer;
	
	public DroolsRuleEngine() {
		KieService ks = KieServices.Factory.get();
		kContainer = ks.getKieClasspathContainer();
	}

	@Override
	public Money applyRules(Customer customer, List<OrderLine> orderLines) {
		KieSession kSession = kContainer.newKieSession("discountSession");
		try {
			...
			kSession.fireAllRules();
		} finally {
			kSession.dispose();
		}
		return money.toImmutableMoney();
	}
}

RuleDiscounter가 출현하면서 바뀐 구조
CalculateDiscountService는 더이상 구현 기술인 Drools에 의존하지 않는다.
- RuleDiscounter 인터페이스에 의존할 뿐
- ‘룰을 이용한 할인 금액 계산’은 고수준 모듈의 개념이므로 RuleDiscounter 인터페이스는 고수준 모듈에 속한다.
- DroolsRuleDiscounter는 고수준의 하위 기능인 RuleDiscounter를 구현한 것이므로 저수준 모듈에 속한다.

DIP를 적용하면 저수준 모듈이 고수준 모듈에 의존하게 된다.
- 고수준 모듈이 저수준 모듈을 사용하려면 고수준 모듈이 저수준 모듈에 의존해야 하는데, 반대로 저수준 모듈이 고수준 모듈에 의존한다고 해서 이를 DIP(Dependency Inversion Principle, 의존 역전 원칙)이라 부른다.
DIP를 적용하면 다른 영역인 인프라스트럭처 영역에 의존할 떄 발생했던 두가지 문제인 구현 교체가 어렵다는 것과 테스트가 어려운 문제를 해소할 수 있다.

고수준 모듈은 더 이상 저수준 모듈에 의존하지 않고 구현을 추상화한 인터페이스에 의존할 수 있다.

구현 기술이 변경되더라도 저수준 구현 객체를 생성하는 코드만 변경하면 된다.

// 기존 코드
RuleDiscounter roleDiscounter = new DroolsRuleDiscounter();
CalculateDiscountService disService = new CalculateDiscountService(roleDiscounter);

// 구현 기술 변경 
RuleDiscounter roleDiscounter = new SimpleRuleDiscounter();
CalculateDiscountService disService = new CalculateDiscountService(roleDiscounter);

스프링과 같은 의존 주입을 지원하는 프레임워크를 사용하면 설정 코드를 수정해서 쉽게 구현체를 변경할 수 있다.
CalculateDiscountService가 제대로 동작하는지 테스트하려면 CustomerRepository와 RuleDiscounter를 구현한 객체가 필요하다.
- CacluateDiscountService가 저수준 모듈에 직접 의존했다면 저수준 모듈이 만들어지기 전까진 테스트를 할 수 없음
- 인터페이스에 의존함으로 대역 객체를 사용해서 테스트를 진행 할수 있다.
- 실제 구현 대신 스텁이나 모의 객체와 같은 테스트 목적의 대역을 사용하여 거의 모든 상황을 테스트할 수 있다.
```
public class CalculateDiscountServiceTest {
	@Test
	public void noCustomer_thenExcetionShouldBeThrown() {
		CustomerRepository stubRepo = mock(CustomerRepository.class);
		when(stubRepo.findById("noCustId")).thenRetrun(null);

		RuleDiscounter stubRule = (cust, lines) -> null;
		
		CalculateDiscountService calDisSvc = new CalculateDiscountService(stbRepo, stubRule);
		assertThrows(NoCustomerException.class, () -> calDisSvc.calculateDiscount(ssomeLines, "noCustId"));
	}
}
```
실제 구현 없이 테스트를 할 수 있는 이유는 DIP를 적용해서 고수준 모듈이 저수준 모듈에 의존하지 않도록 했기 때문이다.

2.3.1 DIP 주의사항

DIP를 잘못 생각하면 단순히 인터페이스와 구현 클래스를 분리하는 정도로 받아드릴 수 있다.
DIP의 핵심은 고수준 모듈이 저수준 모듈의 의존하지 않도록 하기 위함이다.
잘못된 구조
- 도메인 영역은 구현 기술을 다루는 인프라스트럭처 영역에 의존하고 있다.
- 고수준 모듈이 저수준 모듈에 의존하고 있다.
DIP를 적용할 때 하위 기능을 추상화한 인터페이스는 고수준 모듈 관점에서 도출한다.
- CalculateDiscountService는 할인 금액을 구하기 위한 룰 엔진을 사용하는지 직접 연산하는지 중요하지 않다.
- 규칙에 따라 할인 금액을 계산하는 것이 중요
- ‘할인 금액 계산’을 추상화한 인터페이스는 저수준 모듈이 아닌 고수준 모듈에 위치한다.

2.3.2 DIP와 아키텍처

인프라스트럭처 영역은 구현 기술을 다루는 저수준 모듈이고 응용 영역과 도메인 영역은 고수준 모듈이다.
인프라스트럭처 계층이 가장 하단에 위치하는 계층형 구조와 달리 아키텍처에 DIP를 적용하면 인프라스트럭처 영역이 응용 영역와 도메인 영역에 의존하는 구조가 된다.
인프라스트럭처에 위치한 클래스가 도메인이나 응용 영역에 정의한 인터페이스를 상속받아 구현하는 구조가 되므로 도메인과 응용 영역에 대한 영향을 주지 않거나 최소화하면서 구현 기술을 변경하는 것이 가능하다.
주문 시 통지 방식에 SMS를 추가해야 한다는 요구사항이 들어왔을 때 OrderService는 변경할 필요가 없다.
- 두 통지 방식을 함께 제공하는 Notifier 구현 클래스를 인프라스트럭처 영역에 추가하면 된다.
마이바티스 대신 JPA를 구현 기술로 사용하고 싶다면 JPA를 이용한 OrderRepository 구현 클래스를 인프라 스트럭처 영역에 추가하면 된다.

2.4 도메인 영역의 주요 구성요소

도메인 영역을 구성하는 요소요소 설명

엔티티 ENTITY	고유 식별자를 갖는 객체로 자신의 라이프 사이클을 갖는다. Order, Member, Product와 같이 도메인의 고유한 개념을 표현한다. 도메인 모델의 데이터를 포함하며 해당 데이터와 관련된 기능을 함께 제공
밸류 VALUE	고유 식별자를 갖지 않는 객체로 주로 개념적으로 하나의 값을 표현할 때 사용된다. 배송지 주소를 표현하기 위한 Address나 구매한 금액을 위한 Money와 같은 타입이 밸류 타입이다. 엔티티의 속성으로 사용할 뿐만 아니라 다른 밸류 타입의 속성도 사용할 수 있다.
애그리거트 AGGREGATE	애그리거트는 연관된 엔티티와 밸류 객체를 개념적으로 하나로 묶는 것이다. 주문과 관련된 Order 엔티티, OrderLine 밸류, Orderer 밸류 객체를 주문 애그리거트로 묶을 수 있다.
리포지터리 REPOSITORY	도메인 모델의 영속성을 처리한다. DBMS 테이블에서 엔티티 객체를 로딩하거나 저장하는 기능을 제공
도메인 서비스 DOMAIN SERVICE	특정 엔티티에 속하지 않는 도메인 로직을 제공한다. ‘할인 금액 계산’은 상품, 쿠폰, 회원 등급, 구매 금액 등 다양한 조건을 이용해서 구현하게 되는데 이렇게 도메인 로직이 여러 엔티티와 밸류를 필요로 하면 도메인 서비스에 로직을 구현

2.4.1 엔티티와 밸류

엔티티와 도메인 모델의 가장 큰 차이점은 도메인 모델의 엔티티는 데이터와 함께 도메인 기능을 함께 제공한다는 점
- 주문을 표현하는 엔티티는 주문과 관련된 데이터뿐만 아니라 배송지 주소 변경을 위한 기능을 함께 제공
```
public class Order {
	private OrderNo number;
	private Orderer orderer;
	private ShippingInfo shippingInfo;
	
	// 도메인 모델 엔티티는 도메인 기능도 함께 제공
	public void shangeShippingInfo(ShippingInfo newShippingInfo) {
		...	
	}
}
```
도메인 모델의 엔티티는 단순히 데이터를 담고 있는 데이터 구조라기보다는 데이터와 함께 기능을 제공하는 객체
도메인 관점에서 기능을 구현하고 기능 구현을 캡슐화해서 데이터가 임의로 변경되는 것을 막는다.
도메인 모델의 엔티티는 두 개 이상의 데이터가 개념적으로 하나인 경우 밸류 타입을 이용해서 표현할 수 있다
- Orderer는 밸류 타입으로 주문자 이름과 이메일 데이터를 포함할 수 있다.
```
public class Orderer {
	private String name;
	private String email;
}
```
RDBMS와 같은 관계형 데이터베이스는 밸류 타입을 재대로 표현하기 힘들다.
- Ordere의 개별 데이터를 저장하거나 밸로 테이블로 분리해서 저장해야 한다.
- 한 테이블에 주문자 정보 함께 넣기
  - 주문자라는 개념이 들어나지 않고 주문자의 개별 데이터만 드러난다.
- 다른 테이블에 주문자 정보 넣기
  - 주문자 데이터를 별도 테이블에 저장했지만 이것은 테이블의 엔티티에 가까우며 밸류 타입의 의미가 드러나지 않는다.

밸류는 불변으로 구현할 것을 권장

엔티티의 밸류 타입 데이터를 변경할 떄는 객체 자체를 완전히 교체한다는 것을 의미

public class Order {
	private ShippingInfo shippingInfo;
	
	public void shangeShippingInfo(ShippingInfo newShippingInfo) {
		checkShippingInfoChangeable();
		setShippingInfo(newShippingInfo);
	}

	private void setShippingInfo(ShippingInfo newShippingInfo) {
		if (newShippingInfo == null) {
			throw new IllegalArgumentException();
		}
		this.shippingInfo = newShippingInfo;
	}
}

2.4.2 애그리거트

도메인이 커질수록 개발할 도메인 모델도 커지면서 많은 엔티티와 밸류가 출현한다.
도메인 모델이 복잡해지면 개발자가 전체 구조가 아닌 한 개 엔티티와 밸류에만 집중하는 상황이 발생한다.
- 상위 수준에서 모델을 관리하지 않고 개별 요소에만 초점을 맞추다 보면, 큰 수준에서 모델을 이해하지 못해 큰 틀에서 모델은 관리할 수 없는 상황에 빠질 수 있다.
도메인 모델에 전체 구조를 이해하는데 도움이 되는 것이 바로 애그리거트(AGGREGATE)이다.
애그리거트는 관련 객체를 하나로 묶은 군집이다.
- 모메인 개념은“주문”, “배송지 정보”, “주문자”, “주문 목록”, “총 결제 금액”의 하위 모델로 구성된다.
- 하위 내념을 표현한 모델을 하나로 묶어서 “주문”이라는 상위 개념으로 표현할 수 있다.
애그리거트를 사용하면 개별 객체가 아닌 관련 객체를 묶어서 객체 군집 단위로 모델을 바라볼 수 있게 된다.
- 개별 객체 간의 관계가 아닌 애그리거트 간의 관계로 도메인 모델을 이해하고 구현하고, 큰 틀에서 도메인 모델을 관리할 수 있다.
애그리거트는 군집에 속한 객체를 관리하는 루트 엔티티를 갖는다.
- 루트 엔티티는 애그리거트에 속해 있는 엔티티와 밸류 객체를 이용해서 애그리거트가 구현해야 할 기능을 제공
- 애그리거트를 사용하는 코드는 애그리거트 루트가 제공하는 기능을 실행
- 애그리거트 루트를 통해 간접적으로 애그리거트 내의 다른 엔티티나 밸류 객체에 접근
- 애그리거트의 내부 구현을 숨겨서 애그리거트 단위로 구현을 캡슐화할 수 있도록 돕는다.
주문 애그리거트
- 애그리거트 루트인 Order는 주문 도메인 로직에 맞게 애그리거트의 상태를 관리
- Order의 배송지 정보 변경 기능은 배송지를 변경할 수 있는지를 확인한 위에 배송지 정보를 변경
- 주문 애그리거트는 Order를 통하지 않고 ShippingInfo를 변경할 수 있는 방법을 제공하지 않는다.
  - 배송지를 변경하려면 루트 엔티티인 Order를 사용해야 하므로 배소지 정보를 변경할 때는 Order가 구현한 도메인 로직을 항상 따르게 된다.
애그리거트를 구현할 때는 고려할 것이 많다.
- 애그리거트를 어떻게 구성했느냐에 따라 구현이 복잡해지기도 하고
- 트랜잭션 범위가 달라지기도 한다.

2.4.3 리포지터리

도메인 객체를 지속적으로 사용하려면 RDBMS, NoSQL, 로컬 파일과 같은 물리적인 저장소에 도메인 객체를 보관해야 한다.
- 이를 위한 도메인 모델이 리포지터리(Repository)이다.
엔티티나 밸류가 요구사항에 도출되는 도메인 모델이라면 리포리터리는 구현을 위한 도메인 모델이다.
리포지터리는 애그리거트 단위로 도메인 객체를 저장하고 조회하는 기능을 정의
- OrderRepository의 메서드를 보면 대상을 찾고 저장하는 단위가 애그리거트 루트인 Order인 것을 알 수 있다.
- Order는 애그리거트에 속한 모든 객체를 포함하고 있으므로 결과적으로 애그리거트 단위로 저장하고 조회한다.
```
public interface OrderRepository {
	Order findByNumber(OrderNumber number);
	void save(Order order);
	void delete(Order order);
}
```
도메인 모델을 사용해야 하는 코드는 리포지터리를 통해서 도메인 객체를 구한 뒤에 도메인 객체의 기능을 실행
public class CancelOrderService { private OrderRepository orderRepository; public void cancel(OrderNumber number) { Order order = orderRepository.findByNumber(number); if (order == null) { throw new OrderNotFoundException(orderId); } order.cancel(); } }
도메인 모델 관점에서 OrderRepository는 도메인 객체를 영속화하는 데 필요한 기능을 추상화 한것으로 고수준 모듈에 속한다.
기반 기술을 이용해서 OrderRepository를 구현한 클래스는 저수준 모듈로 인프라스트럭처 영역에 속한다.
전체 모듈 구조
응용 서비스는 의존 주입과 같은 방식을 사용해서 실제 리포지터리 구현 객체에 접근
응용 서비스와 리포지터리는 밀접한 연관이 있다.
- 응용 서비스는 필요한 도메인 객체를 구하거나 저장할 때 리포지터리를 사용한다.
- 응용 서비스는 트랜잭션을 관리하는데, 트랜잭션 처리는 리포지터리 구현 기술의 영향을 받는다.
리포지터리를 사용하는 주체가 응용 서비스이기 때문에 리포지터리는 응용 서비스가 필요로 하는 메서드를 제공한다.
- 애그리거트를 저장하는 메서드
- 애그리거트 루트 식별자로 애그리거트를 조회하는 메서드

2.5 요청 처리 흐름

표현 영역은 사용자가 전송한 데이터 형식이 올바른지 검사하고 문제가 없다면 데이터를 이용해서 응용 서비스에 기능 실행을 위임
표현 영역은 사용자가 전송한 데이터를 응용 서비스가 요구하는 형식으로 변환해서 전달
요청 처리 흐름
- 웹 브라우저에서 기능 실행 요청
- 표현 영역에 해당하는 컨트롤러는 HTTP 요청 파라미터를 응용 서비스가 필요로 하는 데이터로 변환 해서 응용 서비스의 인자로 전달
- 응용 서비스는 도메인 모델을 이용해서 로직 실행
- 도메인 객체를 리포지터리에서 가져와 실행하거나 신규 도메인 객체를 생성해 리포지터리에 저장
“예매하기”나 “예매 취소”와 같은 기능을 제공하는 응용 서비스는 도메인의 상태를 변경하므로 변경 상태가 물리 저장소에 올바르게 반영되도록 트랜잭션을 관리 해야한다.
- 스프링 프레임워크를 사용한다면 @Transactional 애너테이션을 이용해 트랜잭션을 처리할 수 있다.
```
public class CancelOrderService {
	private OrderRepository orderRepository;
	
	@Transactional
	public void cancel(OrderNumber number) {
		Order order = orderRepository.findByNumber(number);
		if (order == null) {
			throw new NoOrderException(number);
		}
		order.cancel()
	}
}
```

2.6 인프라스트럭처 개요

인프라스트럭처는 표현 영역, 응용 영역, 도메인 영역을 지원한다.
도메인 영역과 응용 영역에서 인프라스트럭처의 기능을 직접 사용하는 것보다 두 영역에서 정의한 인터페이스를 인프라스트럭처 영역에서 구현하는 것이 시스템을 더 유연하고 테스트하기 쉽게 만들어 준다.
무조건 인프라스트럭처에 대한 의존성을 없앨 필요는 없다.
- 스프링을 사용할 경우 응용 서비스는 트랜잭션 처리를 위해 @Transactional을 사용하는 것이 편리하다.
- 영속성 처리를 위해 JPA를 사용할 경우 @Entity나 @Table과 같은 JPA 전용 애너테이션을 도메인 모델 클래스에서 사용하는 것이 XML 매핑 설정을 이용하는 것보다 편리하다.
구현의 편리함은 DIP가 주는 다른 장점만큼 중요하기 때문에 DIP의 장점을 해치지 않는 범위에서 응용 영역과 도메인 영역에서 구현 기술에 대한 의존을 가져가는 것이 나쁘지 않다고 생각한다.
응용 영역과 도메인 영역이 인프라스트럭처에 대한 의존을 완전히 갖지 않도록 시도하는 것은 구현을 더 복잡하고 어렵게 만들 수 있다.
- @Transactional을 사용하면 한 줄로 트랙잭션을 처리할 수 있는데 코드에서 스프링에 대한 의존을 없애려면 복잡한 스프링 설정을 사용해야 한다.
- 의존은 없앴지만 특별히 테스트를 더 쉽게 할 수 있다거나 유연함을 증가시켜 주지 못한다.
- 설정만 복잡해지고 개발 시간만 늘어난다.
표현 영역은 항상 인프라스트럭처 영역과 쌍을 이룬다.
- 스프링 MVC를 사용해서 웹 요청을 처리하려면 스프링이 제공하는 MVC 프레임워크에 맞게 표현 영역을 구현
- Vert.x를 사용해서 Rest API 서버를 구축하려면 Vert.x에 맞게 웹 요청 처리 부분을 구현

2.7 모듈 구성

아키텍처의 각 영역은 별도 패키지에 위치한다.
패키지 구성 규칙에 정답이 존재하는 것은 안지만 영역별로 모듈이 위치할 패키지를 구성할 수 있을 것 이다.
도메인이 크면 하위 도메인으로 나누고 하위 도메인마다 별도 패키지를 구성한다.
도메인 모듈은 도메인에 속한 애그리거트를 기준으로 다시 패키지를 구성한다.
- 카탈로그 하위 도메인이 상품 애그리거트와 카테고리 애그리커트로 구성될 경우 도메인을 두 개의 하위 패키지로 구성할 수 있다.
애그리거트, 모델, 리포지터리는 같은 패키지에 위치시킨다.
- Order, OrderLine, Orderer, OrderRepository 등은 com.myshop.order.domain 패키지에 위치시킨다.
도메인이 복잡하면 도메인 모델과 도메인 서비스를 별도 패키지에 위치시킬 수도 있다.
- com.myshop.order.domain.order: 애그리거트 위치
- com.myshop.order.domain.service: 도메인 서비스 위치
응용 서비스도 도메인 별로 패키지를 구분할 수 있다.
- com.myshop.catalog.application.product
- com.myshop.catalog.application.category
모듈 구조를 얼마나 세분하게해야 하는지에 대한 정해진 규칙은 없다.
한 패키지에 너무 많은 타입이 몰려서 코드를 찾을 때 불편할 정도만 아니면 된다.

2.1 네 개의 영역

“표현”, “응용”, “도메인”, “인프라스트럭처”는 아키텍처를 설계할 때 출현하는 전형적인 네 가지 영역
- 표현 영역
  - 사용자의 요청을 받아 응용 영역에 전달, 응용 영역의 처리 결과를 사용자에게 전달
  - 스프링 MVC 프레임워크가 표현 영역의 기술
- 응용 영역
  - 표현 영역을 통해 사용자의 요청을 전달받은 응용 영역은 시스템이 사용자에게 제공해야할 기능을 구현
  - “주문 등록”, “주문 취소”, “상품 상세 조회” 등의 기능을 예로 들수 있다.
  - 기능을 구현하기 위한 도메인 영역의 도메인 모델을 사용
  - “주문 취소” 기능을 제공하는 응용 서비스를 도메인 모델을 사용해서 기능 구현이 가능
  - public class CancelOrderService { @Transactional public void cancelOrder(String orderId) { Order order = findOrderById(orderId); if (order == null) { throw new OrderNotFoundException(orderId); } order.cancel(); } }
  - 로직을 직접 수행하기보다는 도메인 모델에 로직 수행을 위임
    - “주문 취소” 로직을 직접 구현하지 않고 Order 객체에 취소 처리를 위임 하고 있다
- 도메인 영역
  - Order, OrderLine, ShippingInfo와 같은 도메인 모델
  - 도메인 모델은 핵심 로직을 구현한다.
    - “배송지 변경”, “결제 완료”, “주문 총액 계산”과 같은 핵심 로직을 도메인 모델에 구현한다.
- 인프라스트럭처 영역
  - 구현 기술에 대한 것을 다룬다
  - RDBMS 연동, 메시징 큐에 메시지 전송과 수신, 몽고DB나 레디스의 데이터 연동 처리 등
  - 논리적인 개념을 표현하기보다는 실제 구현을 다룬다
  - 도메인 영역, 응용 영역, 표현 영역은 구현 기술을 사용한 코드를 직접 만들지 않는다.
    - 인프라스트럭처 영역에서 제공하는 기능을 사용해서 필요한 기능을 개발

2.2 계층 구조 아키텍처

네 영역을 구성할 때 많이 사용하는 아키텍처가 그림과 같은 계층 구조이다.
- 표현 영역과 응용 영역은 도메인 영역을 사용
- 도메인 영역은 인프라스트럭처 영역을 사용
도메인의 복잡도에 따라 응용과 도메인을 분리하기도 하고 한 계층으로 합치기도 하지만 전체적인 아키텍처는 계층 구조를 따른다.
계층 구조는 특성상 상위 계층에서 하위 계층으로의 의존만 존재하고 하위 계층은 상위 계층에 의존하지 않는다.
계층 구조를 엄격하게 적용한다면 상위 계층은 바로 아래의 계층에만 의존을 가져야 하지만 구현의 편리함을 위해 계층 구조를 유연하게 적용하기도 한다.
응용 영역과 도메인 영역은 DB나 외부 시스템 연동을 위해 인프라스트럭처의 기능을 사용하므로 계층 구조를 사용하는 것이 직관적으로 이해하기 쉽다.
- 표현, 응용, 도메인 계층이 상세한 구현 기술을 다루는 인프라스트럭처 계층에 종속된다

도메인의 가격 계산 규칙의 예제

할인 금액을 계산하기 위해 Drools라는 룰 엔진을 사용해서 계산 로직을 수행하는 인프라스트럭처 영역의 코드를 만들어 보자

public class DroolsRuleEngine {
	private KieContainer kContainer;

	public DroolsRuleEngine() {
		KieServices ks = KieServices.Factory.get();
		kContainer = ks.getKieClasspathContainer();		
	}

	public void evalute(String sessionName, List<?> facts) {
		KiSession kSession = kContainer.newKieSession(sessionName);
		try {
			facts.forEach(x -> kSession.insert(x));
			kSession.fireAllRules();
		} finaly {
			kSession.dispose();
		}
	}
}

응용 영역은 가격 계산을 위해 인프라스트럭처 영역의 DroolsRuleEngine을 사용

public class CalcuateDiscountService {
	private DroolsRuleEngine ruleEngine;
	
	public CalculateDiscountService() {
		ruleEngine = new DroolsRuleEngine();
	}

	public Money calculateDiscount(List<OrderLine> orderLines, String customerId) {
		Customer customer = findCustomer(customerId);
		
		MutableMoney money = new MutableMoney(0);
		List<?> facts = Arrays.asList(customer, money);
		facts.addAll(orderLines);
		ruleEngine.evalute("discountCalculation", facts);
		return money.toImmutableMoney();
	}
}

CalculateDiscountService가 동작은 하겠지만 두가지 문제를 안고 있다.
- CalculateDiscountService를 테스트하기 어렵다
  - RuleEngine이 완벽하게 동작해야 한다.
  - RuleEngine 클래스와 관련 설정 파일 모두 만든 이후에 CalculateDiscountService 를 확인할 수 있다.
- 구현 방식을 변경하기 어렵다
  - ‘discountCalculation’ 문자열은 Drools의 세션 이름을 의미한다.
  - 세션 이름을 변경하면 CalculateDiscountService 코드도 함께 변경해야 한다.
CalculateDiscountService가 겉으로는 인프라스트럭처의 기술에 직접적인 의존을 하지 않는 것처럼 보여도 실제로는 Drools라는 인프라스트럭처 영역의 기술에 완전하게 의존하고 있다.
인프라스트럭처에 의존하면 ‘테스트 어려움’과 ‘기능 확장 어려움’이라는 두가지 문제가 발생한다.
- 문제 해답은 DIP에 있다.

2.3 DIP

가격 할인 계산을 하려면 고객 정보를 구해야하고, 구한 고객 정보와 주문 정보를 이용해서 룰을 실행해야 한다.
CalculateDiscountService는 고수준 모듈이다.
- 고수준 모듈은 의미 있는 단일 기능을 제공하는 모듈로 ‘가격 할인 계산’이라는 기능을 구현
- 가격 할인 계싼 기능을 구현하려면 고객 정보를 구해야하고 룰을 실행해야 하는데 이 두 기능이 하위 기능이다.
저수준 모듈은 하위 기능을 실제로 구현한 것이다.
- JPA를 이용해서 고객 정보를 읽어오는 모듈과 Drools로 룰을 실행하는 모듈이 저수준 모듈이 된다.

DIP는 저수준 모듈이 고수준 모듈에 의존하도록 바꾼다.

추상화 인터페이스를 사용

public interface RuleDiscounter {
	Money applyRules(Customer customer, List<OrderLine> orderLines);
}

CalculateDiscountService가 RuleDiscounter를 이용하도록 변경
- Drools에 의존하는 코드가 없다

public class CalcuateDiscountService {
	private RuleDiscounter ruleDiscounter;
	
	public CalculateDiscountService(RuleDiscounter ruleDiscounter) {
		this.ruleDiscounter = ruleDiscounter;
	}

	public Money calculateDiscount(List<OrderLine> orderLines, String customerId) {
		Customer customer = findCustomer(customerId);
		return ruleDiscounter.applyRules(customer, orderLines);
	}
}

RuleDiscounter를 상속받아 구현

public class DroolsRuleDiscounter implements RuleDiscounter {
	private KieCountainer kContainer;
	
	public DroolsRuleEngine() {
		KieService ks = KieServices.Factory.get();
		kContainer = ks.getKieClasspathContainer();
	}

	@Override
	public Money applyRules(Customer customer, List<OrderLine> orderLines) {
		KieSession kSession = kContainer.newKieSession("discountSession");
		try {
			...
			kSession.fireAllRules();
		} finally {
			kSession.dispose();
		}
		return money.toImmutableMoney();
	}
}

RuleDiscounter가 출현하면서 바뀐 구조
CalculateDiscountService는 더이상 구현 기술인 Drools에 의존하지 않는다.
- RuleDiscounter 인터페이스에 의존할 뿐
- ‘룰을 이용한 할인 금액 계산’은 고수준 모듈의 개념이므로 RuleDiscounter 인터페이스는 고수준 모듈에 속한다.
- DroolsRuleDiscounter는 고수준의 하위 기능인 RuleDiscounter를 구현한 것이므로 저수준 모듈에 속한다.

DIP를 적용하면 저수준 모듈이 고수준 모듈에 의존하게 된다.
- 고수준 모듈이 저수준 모듈을 사용하려면 고수준 모듈이 저수준 모듈에 의존해야 하는데, 반대로 저수준 모듈이 고수준 모듈에 의존한다고 해서 이를 DIP(Dependency Inversion Principle, 의존 역전 원칙)이라 부른다.
DIP를 적용하면 다른 영역인 인프라스트럭처 영역에 의존할 떄 발생했던 두가지 문제인 구현 교체가 어렵다는 것과 테스트가 어려운 문제를 해소할 수 있다.

고수준 모듈은 더 이상 저수준 모듈에 의존하지 않고 구현을 추상화한 인터페이스에 의존할 수 있다.

구현 기술이 변경되더라도 저수준 구현 객체를 생성하는 코드만 변경하면 된다.

// 기존 코드
RuleDiscounter roleDiscounter = new DroolsRuleDiscounter();
CalculateDiscountService disService = new CalculateDiscountService(roleDiscounter);

// 구현 기술 변경 
RuleDiscounter roleDiscounter = new SimpleRuleDiscounter();
CalculateDiscountService disService = new CalculateDiscountService(roleDiscounter);

스프링과 같은 의존 주입을 지원하는 프레임워크를 사용하면 설정 코드를 수정해서 쉽게 구현체를 변경할 수 있다.
CalculateDiscountService가 제대로 동작하는지 테스트하려면 CustomerRepository와 RuleDiscounter를 구현한 객체가 필요하다.
- CacluateDiscountService가 저수준 모듈에 직접 의존했다면 저수준 모듈이 만들어지기 전까진 테스트를 할 수 없음
- 인터페이스에 의존함으로 대역 객체를 사용해서 테스트를 진행 할수 있다.
- 실제 구현 대신 스텁이나 모의 객체와 같은 테스트 목적의 대역을 사용하여 거의 모든 상황을 테스트할 수 있다.
```
public class CalculateDiscountServiceTest {
	@Test
	public void noCustomer_thenExcetionShouldBeThrown() {
		CustomerRepository stubRepo = mock(CustomerRepository.class);
		when(stubRepo.findById("noCustId")).thenRetrun(null);

		RuleDiscounter stubRule = (cust, lines) -> null;
		
		CalculateDiscountService calDisSvc = new CalculateDiscountService(stbRepo, stubRule);
		assertThrows(NoCustomerException.class, () -> calDisSvc.calculateDiscount(ssomeLines, "noCustId"));
	}
}
```
실제 구현 없이 테스트를 할 수 있는 이유는 DIP를 적용해서 고수준 모듈이 저수준 모듈에 의존하지 않도록 했기 때문이다.

2.3.1 DIP 주의사항

DIP를 잘못 생각하면 단순히 인터페이스와 구현 클래스를 분리하는 정도로 받아드릴 수 있다.
DIP의 핵심은 고수준 모듈이 저수준 모듈의 의존하지 않도록 하기 위함이다.
잘못된 구조
- 도메인 영역은 구현 기술을 다루는 인프라스트럭처 영역에 의존하고 있다.
- 고수준 모듈이 저수준 모듈에 의존하고 있다.
DIP를 적용할 때 하위 기능을 추상화한 인터페이스는 고수준 모듈 관점에서 도출한다.
- CalculateDiscountService는 할인 금액을 구하기 위한 룰 엔진을 사용하는지 직접 연산하는지 중요하지 않다.
- 규칙에 따라 할인 금액을 계산하는 것이 중요
- ‘할인 금액 계산’을 추상화한 인터페이스는 저수준 모듈이 아닌 고수준 모듈에 위치한다.

2.3.2 DIP와 아키텍처

인프라스트럭처 영역은 구현 기술을 다루는 저수준 모듈이고 응용 영역과 도메인 영역은 고수준 모듈이다.
인프라스트럭처 계층이 가장 하단에 위치하는 계층형 구조와 달리 아키텍처에 DIP를 적용하면 인프라스트럭처 영역이 응용 영역와 도메인 영역에 의존하는 구조가 된다.
인프라스트럭처에 위치한 클래스가 도메인이나 응용 영역에 정의한 인터페이스를 상속받아 구현하는 구조가 되므로 도메인과 응용 영역에 대한 영향을 주지 않거나 최소화하면서 구현 기술을 변경하는 것이 가능하다.
주문 시 통지 방식에 SMS를 추가해야 한다는 요구사항이 들어왔을 때 OrderService는 변경할 필요가 없다.
- 두 통지 방식을 함께 제공하는 Notifier 구현 클래스를 인프라스트럭처 영역에 추가하면 된다.
마이바티스 대신 JPA를 구현 기술로 사용하고 싶다면 JPA를 이용한 OrderRepository 구현 클래스를 인프라 스트럭처 영역에 추가하면 된다.

2.4 도메인 영역의 주요 구성요소

도메인 영역을 구성하는 요소요소 설명

엔티티 ENTITY	고유 식별자를 갖는 객체로 자신의 라이프 사이클을 갖는다. Order, Member, Product와 같이 도메인의 고유한 개념을 표현한다. 도메인 모델의 데이터를 포함하며 해당 데이터와 관련된 기능을 함께 제공
밸류 VALUE	고유 식별자를 갖지 않는 객체로 주로 개념적으로 하나의 값을 표현할 때 사용된다. 배송지 주소를 표현하기 위한 Address나 구매한 금액을 위한 Money와 같은 타입이 밸류 타입이다. 엔티티의 속성으로 사용할 뿐만 아니라 다른 밸류 타입의 속성도 사용할 수 있다.
애그리거트 AGGREGATE	애그리거트는 연관된 엔티티와 밸류 객체를 개념적으로 하나로 묶는 것이다. 주문과 관련된 Order 엔티티, OrderLine 밸류, Orderer 밸류 객체를 주문 애그리거트로 묶을 수 있다.
리포지터리 REPOSITORY	도메인 모델의 영속성을 처리한다. DBMS 테이블에서 엔티티 객체를 로딩하거나 저장하는 기능을 제공
도메인 서비스 DOMAIN SERVICE	특정 엔티티에 속하지 않는 도메인 로직을 제공한다. ‘할인 금액 계산’은 상품, 쿠폰, 회원 등급, 구매 금액 등 다양한 조건을 이용해서 구현하게 되는데 이렇게 도메인 로직이 여러 엔티티와 밸류를 필요로 하면 도메인 서비스에 로직을 구현

2.4.1 엔티티와 밸류

엔티티와 도메인 모델의 가장 큰 차이점은 도메인 모델의 엔티티는 데이터와 함께 도메인 기능을 함께 제공한다는 점
- 주문을 표현하는 엔티티는 주문과 관련된 데이터뿐만 아니라 배송지 주소 변경을 위한 기능을 함께 제공
```
public class Order {
	private OrderNo number;
	private Orderer orderer;
	private ShippingInfo shippingInfo;
	
	// 도메인 모델 엔티티는 도메인 기능도 함께 제공
	public void shangeShippingInfo(ShippingInfo newShippingInfo) {
		...	
	}
}
```
도메인 모델의 엔티티는 단순히 데이터를 담고 있는 데이터 구조라기보다는 데이터와 함께 기능을 제공하는 객체
도메인 관점에서 기능을 구현하고 기능 구현을 캡슐화해서 데이터가 임의로 변경되는 것을 막는다.
도메인 모델의 엔티티는 두 개 이상의 데이터가 개념적으로 하나인 경우 밸류 타입을 이용해서 표현할 수 있다
- Orderer는 밸류 타입으로 주문자 이름과 이메일 데이터를 포함할 수 있다.
```
public class Orderer {
	private String name;
	private String email;
}
```
RDBMS와 같은 관계형 데이터베이스는 밸류 타입을 재대로 표현하기 힘들다.
- Ordere의 개별 데이터를 저장하거나 밸로 테이블로 분리해서 저장해야 한다.
- 한 테이블에 주문자 정보 함께 넣기
  - 주문자라는 개념이 들어나지 않고 주문자의 개별 데이터만 드러난다.
- 다른 테이블에 주문자 정보 넣기
  - 주문자 데이터를 별도 테이블에 저장했지만 이것은 테이블의 엔티티에 가까우며 밸류 타입의 의미가 드러나지 않는다.

밸류는 불변으로 구현할 것을 권장

엔티티의 밸류 타입 데이터를 변경할 떄는 객체 자체를 완전히 교체한다는 것을 의미

public class Order {
	private ShippingInfo shippingInfo;
	
	public void shangeShippingInfo(ShippingInfo newShippingInfo) {
		checkShippingInfoChangeable();
		setShippingInfo(newShippingInfo);
	}

	private void setShippingInfo(ShippingInfo newShippingInfo) {
		if (newShippingInfo == null) {
			throw new IllegalArgumentException();
		}
		this.shippingInfo = newShippingInfo;
	}
}

2.4.2 애그리거트

도메인이 커질수록 개발할 도메인 모델도 커지면서 많은 엔티티와 밸류가 출현한다.
도메인 모델이 복잡해지면 개발자가 전체 구조가 아닌 한 개 엔티티와 밸류에만 집중하는 상황이 발생한다.
- 상위 수준에서 모델을 관리하지 않고 개별 요소에만 초점을 맞추다 보면, 큰 수준에서 모델을 이해하지 못해 큰 틀에서 모델은 관리할 수 없는 상황에 빠질 수 있다.
도메인 모델에 전체 구조를 이해하는데 도움이 되는 것이 바로 애그리거트(AGGREGATE)이다.
애그리거트는 관련 객체를 하나로 묶은 군집이다.
- 모메인 개념은“주문”, “배송지 정보”, “주문자”, “주문 목록”, “총 결제 금액”의 하위 모델로 구성된다.
- 하위 내념을 표현한 모델을 하나로 묶어서 “주문”이라는 상위 개념으로 표현할 수 있다.
애그리거트를 사용하면 개별 객체가 아닌 관련 객체를 묶어서 객체 군집 단위로 모델을 바라볼 수 있게 된다.
- 개별 객체 간의 관계가 아닌 애그리거트 간의 관계로 도메인 모델을 이해하고 구현하고, 큰 틀에서 도메인 모델을 관리할 수 있다.
애그리거트는 군집에 속한 객체를 관리하는 루트 엔티티를 갖는다.
- 루트 엔티티는 애그리거트에 속해 있는 엔티티와 밸류 객체를 이용해서 애그리거트가 구현해야 할 기능을 제공
- 애그리거트를 사용하는 코드는 애그리거트 루트가 제공하는 기능을 실행
- 애그리거트 루트를 통해 간접적으로 애그리거트 내의 다른 엔티티나 밸류 객체에 접근
- 애그리거트의 내부 구현을 숨겨서 애그리거트 단위로 구현을 캡슐화할 수 있도록 돕는다.
주문 애그리거트
- 애그리거트 루트인 Order는 주문 도메인 로직에 맞게 애그리거트의 상태를 관리
- Order의 배송지 정보 변경 기능은 배송지를 변경할 수 있는지를 확인한 위에 배송지 정보를 변경
- 주문 애그리거트는 Order를 통하지 않고 ShippingInfo를 변경할 수 있는 방법을 제공하지 않는다.
  - 배송지를 변경하려면 루트 엔티티인 Order를 사용해야 하므로 배소지 정보를 변경할 때는 Order가 구현한 도메인 로직을 항상 따르게 된다.
애그리거트를 구현할 때는 고려할 것이 많다.
- 애그리거트를 어떻게 구성했느냐에 따라 구현이 복잡해지기도 하고
- 트랜잭션 범위가 달라지기도 한다.

2.4.3 리포지터리

도메인 객체를 지속적으로 사용하려면 RDBMS, NoSQL, 로컬 파일과 같은 물리적인 저장소에 도메인 객체를 보관해야 한다.
- 이를 위한 도메인 모델이 리포지터리(Repository)이다.
엔티티나 밸류가 요구사항에 도출되는 도메인 모델이라면 리포리터리는 구현을 위한 도메인 모델이다.
리포지터리는 애그리거트 단위로 도메인 객체를 저장하고 조회하는 기능을 정의
- OrderRepository의 메서드를 보면 대상을 찾고 저장하는 단위가 애그리거트 루트인 Order인 것을 알 수 있다.
- Order는 애그리거트에 속한 모든 객체를 포함하고 있으므로 결과적으로 애그리거트 단위로 저장하고 조회한다.
```
public interface OrderRepository {
	Order findByNumber(OrderNumber number);
	void save(Order order);
	void delete(Order order);
}
```
도메인 모델을 사용해야 하는 코드는 리포지터리를 통해서 도메인 객체를 구한 뒤에 도메인 객체의 기능을 실행
public class CancelOrderService { private OrderRepository orderRepository; public void cancel(OrderNumber number) { Order order = orderRepository.findByNumber(number); if (order == null) { throw new OrderNotFoundException(orderId); } order.cancel(); } }
도메인 모델 관점에서 OrderRepository는 도메인 객체를 영속화하는 데 필요한 기능을 추상화 한것으로 고수준 모듈에 속한다.
기반 기술을 이용해서 OrderRepository를 구현한 클래스는 저수준 모듈로 인프라스트럭처 영역에 속한다.
전체 모듈 구조
응용 서비스는 의존 주입과 같은 방식을 사용해서 실제 리포지터리 구현 객체에 접근
응용 서비스와 리포지터리는 밀접한 연관이 있다.
- 응용 서비스는 필요한 도메인 객체를 구하거나 저장할 때 리포지터리를 사용한다.
- 응용 서비스는 트랜잭션을 관리하는데, 트랜잭션 처리는 리포지터리 구현 기술의 영향을 받는다.
리포지터리를 사용하는 주체가 응용 서비스이기 때문에 리포지터리는 응용 서비스가 필요로 하는 메서드를 제공한다.
- 애그리거트를 저장하는 메서드
- 애그리거트 루트 식별자로 애그리거트를 조회하는 메서드

2.5 요청 처리 흐름

표현 영역은 사용자가 전송한 데이터 형식이 올바른지 검사하고 문제가 없다면 데이터를 이용해서 응용 서비스에 기능 실행을 위임
표현 영역은 사용자가 전송한 데이터를 응용 서비스가 요구하는 형식으로 변환해서 전달
요청 처리 흐름
- 웹 브라우저에서 기능 실행 요청
- 표현 영역에 해당하는 컨트롤러는 HTTP 요청 파라미터를 응용 서비스가 필요로 하는 데이터로 변환 해서 응용 서비스의 인자로 전달
- 응용 서비스는 도메인 모델을 이용해서 로직 실행
- 도메인 객체를 리포지터리에서 가져와 실행하거나 신규 도메인 객체를 생성해 리포지터리에 저장
“예매하기”나 “예매 취소”와 같은 기능을 제공하는 응용 서비스는 도메인의 상태를 변경하므로 변경 상태가 물리 저장소에 올바르게 반영되도록 트랜잭션을 관리 해야한다.
- 스프링 프레임워크를 사용한다면 @Transactional 애너테이션을 이용해 트랜잭션을 처리할 수 있다.
```
public class CancelOrderService {
	private OrderRepository orderRepository;
	
	@Transactional
	public void cancel(OrderNumber number) {
		Order order = orderRepository.findByNumber(number);
		if (order == null) {
			throw new NoOrderException(number);
		}
		order.cancel()
	}
}
```

2.6 인프라스트럭처 개요

인프라스트럭처는 표현 영역, 응용 영역, 도메인 영역을 지원한다.
도메인 영역과 응용 영역에서 인프라스트럭처의 기능을 직접 사용하는 것보다 두 영역에서 정의한 인터페이스를 인프라스트럭처 영역에서 구현하는 것이 시스템을 더 유연하고 테스트하기 쉽게 만들어 준다.
무조건 인프라스트럭처에 대한 의존성을 없앨 필요는 없다.
- 스프링을 사용할 경우 응용 서비스는 트랜잭션 처리를 위해 @Transactional을 사용하는 것이 편리하다.
- 영속성 처리를 위해 JPA를 사용할 경우 @Entity나 @Table과 같은 JPA 전용 애너테이션을 도메인 모델 클래스에서 사용하는 것이 XML 매핑 설정을 이용하는 것보다 편리하다.
구현의 편리함은 DIP가 주는 다른 장점만큼 중요하기 때문에 DIP의 장점을 해치지 않는 범위에서 응용 영역과 도메인 영역에서 구현 기술에 대한 의존을 가져가는 것이 나쁘지 않다고 생각한다.
응용 영역과 도메인 영역이 인프라스트럭처에 대한 의존을 완전히 갖지 않도록 시도하는 것은 구현을 더 복잡하고 어렵게 만들 수 있다.
- @Transactional을 사용하면 한 줄로 트랙잭션을 처리할 수 있는데 코드에서 스프링에 대한 의존을 없애려면 복잡한 스프링 설정을 사용해야 한다.
- 의존은 없앴지만 특별히 테스트를 더 쉽게 할 수 있다거나 유연함을 증가시켜 주지 못한다.
- 설정만 복잡해지고 개발 시간만 늘어난다.
표현 영역은 항상 인프라스트럭처 영역과 쌍을 이룬다.
- 스프링 MVC를 사용해서 웹 요청을 처리하려면 스프링이 제공하는 MVC 프레임워크에 맞게 표현 영역을 구현
- Vert.x를 사용해서 Rest API 서버를 구축하려면 Vert.x에 맞게 웹 요청 처리 부분을 구현

2.7 모듈 구성

아키텍처의 각 영역은 별도 패키지에 위치한다.
패키지 구성 규칙에 정답이 존재하는 것은 안지만 영역별로 모듈이 위치할 패키지를 구성할 수 있을 것 이다.
도메인이 크면 하위 도메인으로 나누고 하위 도메인마다 별도 패키지를 구성한다.
도메인 모듈은 도메인에 속한 애그리거트를 기준으로 다시 패키지를 구성한다.
- 카탈로그 하위 도메인이 상품 애그리거트와 카테고리 애그리커트로 구성될 경우 도메인을 두 개의 하위 패키지로 구성할 수 있다.
애그리거트, 모델, 리포지터리는 같은 패키지에 위치시킨다.
- Order, OrderLine, Orderer, OrderRepository 등은 com.myshop.order.domain 패키지에 위치시킨다.
도메인이 복잡하면 도메인 모델과 도메인 서비스를 별도 패키지에 위치시킬 수도 있다.
- com.myshop.order.domain.order: 애그리거트 위치
- com.myshop.order.domain.service: 도메인 서비스 위치
응용 서비스도 도메인 별로 패키지를 구분할 수 있다.
- com.myshop.catalog.application.product
- com.myshop.catalog.application.category
모듈 구조를 얼마나 세분하게해야 하는지에 대한 정해진 규칙은 없다.
한 패키지에 너무 많은 타입이 몰려서 코드를 찾을 때 불편할 정도만 아니면 된다.

2.1 네 개의 영역

“표현”, “응용”, “도메인”, “인프라스트럭처”는 아키텍처를 설계할 때 출현하는 전형적인 네 가지 영역
- 표현 영역
  - 사용자의 요청을 받아 응용 영역에 전달, 응용 영역의 처리 결과를 사용자에게 전달
  - 스프링 MVC 프레임워크가 표현 영역의 기술
- 응용 영역
  - 표현 영역을 통해 사용자의 요청을 전달받은 응용 영역은 시스템이 사용자에게 제공해야할 기능을 구현
  - “주문 등록”, “주문 취소”, “상품 상세 조회” 등의 기능을 예로 들수 있다.
  - 기능을 구현하기 위한 도메인 영역의 도메인 모델을 사용
  - “주문 취소” 기능을 제공하는 응용 서비스를 도메인 모델을 사용해서 기능 구현이 가능
  - public class CancelOrderService { @Transactional public void cancelOrder(String orderId) { Order order = findOrderById(orderId); if (order == null) { throw new OrderNotFoundException(orderId); } order.cancel(); } }
  - 로직을 직접 수행하기보다는 도메인 모델에 로직 수행을 위임
    - “주문 취소” 로직을 직접 구현하지 않고 Order 객체에 취소 처리를 위임 하고 있다
- 도메인 영역
  - Order, OrderLine, ShippingInfo와 같은 도메인 모델
  - 도메인 모델은 핵심 로직을 구현한다.
    - “배송지 변경”, “결제 완료”, “주문 총액 계산”과 같은 핵심 로직을 도메인 모델에 구현한다.
- 인프라스트럭처 영역
  - 구현 기술에 대한 것을 다룬다
  - RDBMS 연동, 메시징 큐에 메시지 전송과 수신, 몽고DB나 레디스의 데이터 연동 처리 등
  - 논리적인 개념을 표현하기보다는 실제 구현을 다룬다
  - 도메인 영역, 응용 영역, 표현 영역은 구현 기술을 사용한 코드를 직접 만들지 않는다.
    - 인프라스트럭처 영역에서 제공하는 기능을 사용해서 필요한 기능을 개발

2.2 계층 구조 아키텍처

네 영역을 구성할 때 많이 사용하는 아키텍처가 그림과 같은 계층 구조이다.
- 표현 영역과 응용 영역은 도메인 영역을 사용
- 도메인 영역은 인프라스트럭처 영역을 사용
도메인의 복잡도에 따라 응용과 도메인을 분리하기도 하고 한 계층으로 합치기도 하지만 전체적인 아키텍처는 계층 구조를 따른다.
계층 구조는 특성상 상위 계층에서 하위 계층으로의 의존만 존재하고 하위 계층은 상위 계층에 의존하지 않는다.
계층 구조를 엄격하게 적용한다면 상위 계층은 바로 아래의 계층에만 의존을 가져야 하지만 구현의 편리함을 위해 계층 구조를 유연하게 적용하기도 한다.
응용 영역과 도메인 영역은 DB나 외부 시스템 연동을 위해 인프라스트럭처의 기능을 사용하므로 계층 구조를 사용하는 것이 직관적으로 이해하기 쉽다.
- 표현, 응용, 도메인 계층이 상세한 구현 기술을 다루는 인프라스트럭처 계층에 종속된다

도메인의 가격 계산 규칙의 예제

할인 금액을 계산하기 위해 Drools라는 룰 엔진을 사용해서 계산 로직을 수행하는 인프라스트럭처 영역의 코드를 만들어 보자

public class DroolsRuleEngine {
	private KieContainer kContainer;

	public DroolsRuleEngine() {
		KieServices ks = KieServices.Factory.get();
		kContainer = ks.getKieClasspathContainer();		
	}

	public void evalute(String sessionName, List<?> facts) {
		KiSession kSession = kContainer.newKieSession(sessionName);
		try {
			facts.forEach(x -> kSession.insert(x));
			kSession.fireAllRules();
		} finaly {
			kSession.dispose();
		}
	}
}

응용 영역은 가격 계산을 위해 인프라스트럭처 영역의 DroolsRuleEngine을 사용

public class CalcuateDiscountService {
	private DroolsRuleEngine ruleEngine;
	
	public CalculateDiscountService() {
		ruleEngine = new DroolsRuleEngine();
	}

	public Money calculateDiscount(List<OrderLine> orderLines, String customerId) {
		Customer customer = findCustomer(customerId);
		
		MutableMoney money = new MutableMoney(0);
		List<?> facts = Arrays.asList(customer, money);
		facts.addAll(orderLines);
		ruleEngine.evalute("discountCalculation", facts);
		return money.toImmutableMoney();
	}
}

CalculateDiscountService가 동작은 하겠지만 두가지 문제를 안고 있다.
- CalculateDiscountService를 테스트하기 어렵다
  - RuleEngine이 완벽하게 동작해야 한다.
  - RuleEngine 클래스와 관련 설정 파일 모두 만든 이후에 CalculateDiscountService 를 확인할 수 있다.
- 구현 방식을 변경하기 어렵다
  - ‘discountCalculation’ 문자열은 Drools의 세션 이름을 의미한다.
  - 세션 이름을 변경하면 CalculateDiscountService 코드도 함께 변경해야 한다.
CalculateDiscountService가 겉으로는 인프라스트럭처의 기술에 직접적인 의존을 하지 않는 것처럼 보여도 실제로는 Drools라는 인프라스트럭처 영역의 기술에 완전하게 의존하고 있다.
인프라스트럭처에 의존하면 ‘테스트 어려움’과 ‘기능 확장 어려움’이라는 두가지 문제가 발생한다.
- 문제 해답은 DIP에 있다.

2.3 DIP

가격 할인 계산을 하려면 고객 정보를 구해야하고, 구한 고객 정보와 주문 정보를 이용해서 룰을 실행해야 한다.
CalculateDiscountService는 고수준 모듈이다.
- 고수준 모듈은 의미 있는 단일 기능을 제공하는 모듈로 ‘가격 할인 계산’이라는 기능을 구현
- 가격 할인 계싼 기능을 구현하려면 고객 정보를 구해야하고 룰을 실행해야 하는데 이 두 기능이 하위 기능이다.
저수준 모듈은 하위 기능을 실제로 구현한 것이다.
- JPA를 이용해서 고객 정보를 읽어오는 모듈과 Drools로 룰을 실행하는 모듈이 저수준 모듈이 된다.

DIP는 저수준 모듈이 고수준 모듈에 의존하도록 바꾼다.

추상화 인터페이스를 사용

public interface RuleDiscounter {
	Money applyRules(Customer customer, List<OrderLine> orderLines);
}

CalculateDiscountService가 RuleDiscounter를 이용하도록 변경
- Drools에 의존하는 코드가 없다

public class CalcuateDiscountService {
	private RuleDiscounter ruleDiscounter;
	
	public CalculateDiscountService(RuleDiscounter ruleDiscounter) {
		this.ruleDiscounter = ruleDiscounter;
	}

	public Money calculateDiscount(List<OrderLine> orderLines, String customerId) {
		Customer customer = findCustomer(customerId);
		return ruleDiscounter.applyRules(customer, orderLines);
	}
}

RuleDiscounter를 상속받아 구현

public class DroolsRuleDiscounter implements RuleDiscounter {
	private KieCountainer kContainer;
	
	public DroolsRuleEngine() {
		KieService ks = KieServices.Factory.get();
		kContainer = ks.getKieClasspathContainer();
	}

	@Override
	public Money applyRules(Customer customer, List<OrderLine> orderLines) {
		KieSession kSession = kContainer.newKieSession("discountSession");
		try {
			...
			kSession.fireAllRules();
		} finally {
			kSession.dispose();
		}
		return money.toImmutableMoney();
	}
}

RuleDiscounter가 출현하면서 바뀐 구조
CalculateDiscountService는 더이상 구현 기술인 Drools에 의존하지 않는다.
- RuleDiscounter 인터페이스에 의존할 뿐
- ‘룰을 이용한 할인 금액 계산’은 고수준 모듈의 개념이므로 RuleDiscounter 인터페이스는 고수준 모듈에 속한다.
- DroolsRuleDiscounter는 고수준의 하위 기능인 RuleDiscounter를 구현한 것이므로 저수준 모듈에 속한다.

DIP를 적용하면 저수준 모듈이 고수준 모듈에 의존하게 된다.
- 고수준 모듈이 저수준 모듈을 사용하려면 고수준 모듈이 저수준 모듈에 의존해야 하는데, 반대로 저수준 모듈이 고수준 모듈에 의존한다고 해서 이를 DIP(Dependency Inversion Principle, 의존 역전 원칙)이라 부른다.
DIP를 적용하면 다른 영역인 인프라스트럭처 영역에 의존할 떄 발생했던 두가지 문제인 구현 교체가 어렵다는 것과 테스트가 어려운 문제를 해소할 수 있다.

고수준 모듈은 더 이상 저수준 모듈에 의존하지 않고 구현을 추상화한 인터페이스에 의존할 수 있다.

구현 기술이 변경되더라도 저수준 구현 객체를 생성하는 코드만 변경하면 된다.

// 기존 코드
RuleDiscounter roleDiscounter = new DroolsRuleDiscounter();
CalculateDiscountService disService = new CalculateDiscountService(roleDiscounter);

// 구현 기술 변경 
RuleDiscounter roleDiscounter = new SimpleRuleDiscounter();
CalculateDiscountService disService = new CalculateDiscountService(roleDiscounter);

스프링과 같은 의존 주입을 지원하는 프레임워크를 사용하면 설정 코드를 수정해서 쉽게 구현체를 변경할 수 있다.
CalculateDiscountService가 제대로 동작하는지 테스트하려면 CustomerRepository와 RuleDiscounter를 구현한 객체가 필요하다.
- CacluateDiscountService가 저수준 모듈에 직접 의존했다면 저수준 모듈이 만들어지기 전까진 테스트를 할 수 없음
- 인터페이스에 의존함으로 대역 객체를 사용해서 테스트를 진행 할수 있다.
- 실제 구현 대신 스텁이나 모의 객체와 같은 테스트 목적의 대역을 사용하여 거의 모든 상황을 테스트할 수 있다.
```
public class CalculateDiscountServiceTest {
	@Test
	public void noCustomer_thenExcetionShouldBeThrown() {
		CustomerRepository stubRepo = mock(CustomerRepository.class);
		when(stubRepo.findById("noCustId")).thenRetrun(null);

		RuleDiscounter stubRule = (cust, lines) -> null;
		
		CalculateDiscountService calDisSvc = new CalculateDiscountService(stbRepo, stubRule);
		assertThrows(NoCustomerException.class, () -> calDisSvc.calculateDiscount(ssomeLines, "noCustId"));
	}
}
```
실제 구현 없이 테스트를 할 수 있는 이유는 DIP를 적용해서 고수준 모듈이 저수준 모듈에 의존하지 않도록 했기 때문이다.

2.3.1 DIP 주의사항

DIP를 잘못 생각하면 단순히 인터페이스와 구현 클래스를 분리하는 정도로 받아드릴 수 있다.
DIP의 핵심은 고수준 모듈이 저수준 모듈의 의존하지 않도록 하기 위함이다.
잘못된 구조
- 도메인 영역은 구현 기술을 다루는 인프라스트럭처 영역에 의존하고 있다.
- 고수준 모듈이 저수준 모듈에 의존하고 있다.
DIP를 적용할 때 하위 기능을 추상화한 인터페이스는 고수준 모듈 관점에서 도출한다.
- CalculateDiscountService는 할인 금액을 구하기 위한 룰 엔진을 사용하는지 직접 연산하는지 중요하지 않다.
- 규칙에 따라 할인 금액을 계산하는 것이 중요
- ‘할인 금액 계산’을 추상화한 인터페이스는 저수준 모듈이 아닌 고수준 모듈에 위치한다.

2.3.2 DIP와 아키텍처

인프라스트럭처 영역은 구현 기술을 다루는 저수준 모듈이고 응용 영역과 도메인 영역은 고수준 모듈이다.
인프라스트럭처 계층이 가장 하단에 위치하는 계층형 구조와 달리 아키텍처에 DIP를 적용하면 인프라스트럭처 영역이 응용 영역와 도메인 영역에 의존하는 구조가 된다.
인프라스트럭처에 위치한 클래스가 도메인이나 응용 영역에 정의한 인터페이스를 상속받아 구현하는 구조가 되므로 도메인과 응용 영역에 대한 영향을 주지 않거나 최소화하면서 구현 기술을 변경하는 것이 가능하다.
주문 시 통지 방식에 SMS를 추가해야 한다는 요구사항이 들어왔을 때 OrderService는 변경할 필요가 없다.
- 두 통지 방식을 함께 제공하는 Notifier 구현 클래스를 인프라스트럭처 영역에 추가하면 된다.
마이바티스 대신 JPA를 구현 기술로 사용하고 싶다면 JPA를 이용한 OrderRepository 구현 클래스를 인프라 스트럭처 영역에 추가하면 된다.

2.4 도메인 영역의 주요 구성요소

도메인 영역을 구성하는 요소요소 설명

엔티티 ENTITY	고유 식별자를 갖는 객체로 자신의 라이프 사이클을 갖는다. Order, Member, Product와 같이 도메인의 고유한 개념을 표현한다. 도메인 모델의 데이터를 포함하며 해당 데이터와 관련된 기능을 함께 제공
밸류 VALUE	고유 식별자를 갖지 않는 객체로 주로 개념적으로 하나의 값을 표현할 때 사용된다. 배송지 주소를 표현하기 위한 Address나 구매한 금액을 위한 Money와 같은 타입이 밸류 타입이다. 엔티티의 속성으로 사용할 뿐만 아니라 다른 밸류 타입의 속성도 사용할 수 있다.
애그리거트 AGGREGATE	애그리거트는 연관된 엔티티와 밸류 객체를 개념적으로 하나로 묶는 것이다. 주문과 관련된 Order 엔티티, OrderLine 밸류, Orderer 밸류 객체를 주문 애그리거트로 묶을 수 있다.
리포지터리 REPOSITORY	도메인 모델의 영속성을 처리한다. DBMS 테이블에서 엔티티 객체를 로딩하거나 저장하는 기능을 제공
도메인 서비스 DOMAIN SERVICE	특정 엔티티에 속하지 않는 도메인 로직을 제공한다. ‘할인 금액 계산’은 상품, 쿠폰, 회원 등급, 구매 금액 등 다양한 조건을 이용해서 구현하게 되는데 이렇게 도메인 로직이 여러 엔티티와 밸류를 필요로 하면 도메인 서비스에 로직을 구현

2.4.1 엔티티와 밸류

엔티티와 도메인 모델의 가장 큰 차이점은 도메인 모델의 엔티티는 데이터와 함께 도메인 기능을 함께 제공한다는 점
- 주문을 표현하는 엔티티는 주문과 관련된 데이터뿐만 아니라 배송지 주소 변경을 위한 기능을 함께 제공
```
public class Order {
	private OrderNo number;
	private Orderer orderer;
	private ShippingInfo shippingInfo;
	
	// 도메인 모델 엔티티는 도메인 기능도 함께 제공
	public void shangeShippingInfo(ShippingInfo newShippingInfo) {
		...	
	}
}
```
도메인 모델의 엔티티는 단순히 데이터를 담고 있는 데이터 구조라기보다는 데이터와 함께 기능을 제공하는 객체
도메인 관점에서 기능을 구현하고 기능 구현을 캡슐화해서 데이터가 임의로 변경되는 것을 막는다.
도메인 모델의 엔티티는 두 개 이상의 데이터가 개념적으로 하나인 경우 밸류 타입을 이용해서 표현할 수 있다
- Orderer는 밸류 타입으로 주문자 이름과 이메일 데이터를 포함할 수 있다.
```
public class Orderer {
	private String name;
	private String email;
}
```
RDBMS와 같은 관계형 데이터베이스는 밸류 타입을 재대로 표현하기 힘들다.
- Ordere의 개별 데이터를 저장하거나 밸로 테이블로 분리해서 저장해야 한다.
- 한 테이블에 주문자 정보 함께 넣기
  - 주문자라는 개념이 들어나지 않고 주문자의 개별 데이터만 드러난다.
- 다른 테이블에 주문자 정보 넣기
  - 주문자 데이터를 별도 테이블에 저장했지만 이것은 테이블의 엔티티에 가까우며 밸류 타입의 의미가 드러나지 않는다.

밸류는 불변으로 구현할 것을 권장

엔티티의 밸류 타입 데이터를 변경할 떄는 객체 자체를 완전히 교체한다는 것을 의미

public class Order {
	private ShippingInfo shippingInfo;
	
	public void shangeShippingInfo(ShippingInfo newShippingInfo) {
		checkShippingInfoChangeable();
		setShippingInfo(newShippingInfo);
	}

	private void setShippingInfo(ShippingInfo newShippingInfo) {
		if (newShippingInfo == null) {
			throw new IllegalArgumentException();
		}
		this.shippingInfo = newShippingInfo;
	}
}

2.4.2 애그리거트

도메인이 커질수록 개발할 도메인 모델도 커지면서 많은 엔티티와 밸류가 출현한다.
도메인 모델이 복잡해지면 개발자가 전체 구조가 아닌 한 개 엔티티와 밸류에만 집중하는 상황이 발생한다.
- 상위 수준에서 모델을 관리하지 않고 개별 요소에만 초점을 맞추다 보면, 큰 수준에서 모델을 이해하지 못해 큰 틀에서 모델은 관리할 수 없는 상황에 빠질 수 있다.
도메인 모델에 전체 구조를 이해하는데 도움이 되는 것이 바로 애그리거트(AGGREGATE)이다.
애그리거트는 관련 객체를 하나로 묶은 군집이다.
- 모메인 개념은“주문”, “배송지 정보”, “주문자”, “주문 목록”, “총 결제 금액”의 하위 모델로 구성된다.
- 하위 내념을 표현한 모델을 하나로 묶어서 “주문”이라는 상위 개념으로 표현할 수 있다.
애그리거트를 사용하면 개별 객체가 아닌 관련 객체를 묶어서 객체 군집 단위로 모델을 바라볼 수 있게 된다.
- 개별 객체 간의 관계가 아닌 애그리거트 간의 관계로 도메인 모델을 이해하고 구현하고, 큰 틀에서 도메인 모델을 관리할 수 있다.
애그리거트는 군집에 속한 객체를 관리하는 루트 엔티티를 갖는다.
- 루트 엔티티는 애그리거트에 속해 있는 엔티티와 밸류 객체를 이용해서 애그리거트가 구현해야 할 기능을 제공
- 애그리거트를 사용하는 코드는 애그리거트 루트가 제공하는 기능을 실행
- 애그리거트 루트를 통해 간접적으로 애그리거트 내의 다른 엔티티나 밸류 객체에 접근
- 애그리거트의 내부 구현을 숨겨서 애그리거트 단위로 구현을 캡슐화할 수 있도록 돕는다.
주문 애그리거트
- 애그리거트 루트인 Order는 주문 도메인 로직에 맞게 애그리거트의 상태를 관리
- Order의 배송지 정보 변경 기능은 배송지를 변경할 수 있는지를 확인한 위에 배송지 정보를 변경
- 주문 애그리거트는 Order를 통하지 않고 ShippingInfo를 변경할 수 있는 방법을 제공하지 않는다.
  - 배송지를 변경하려면 루트 엔티티인 Order를 사용해야 하므로 배소지 정보를 변경할 때는 Order가 구현한 도메인 로직을 항상 따르게 된다.
애그리거트를 구현할 때는 고려할 것이 많다.
- 애그리거트를 어떻게 구성했느냐에 따라 구현이 복잡해지기도 하고
- 트랜잭션 범위가 달라지기도 한다.

2.4.3 리포지터리

도메인 객체를 지속적으로 사용하려면 RDBMS, NoSQL, 로컬 파일과 같은 물리적인 저장소에 도메인 객체를 보관해야 한다.
- 이를 위한 도메인 모델이 리포지터리(Repository)이다.
엔티티나 밸류가 요구사항에 도출되는 도메인 모델이라면 리포리터리는 구현을 위한 도메인 모델이다.
리포지터리는 애그리거트 단위로 도메인 객체를 저장하고 조회하는 기능을 정의
- OrderRepository의 메서드를 보면 대상을 찾고 저장하는 단위가 애그리거트 루트인 Order인 것을 알 수 있다.
- Order는 애그리거트에 속한 모든 객체를 포함하고 있으므로 결과적으로 애그리거트 단위로 저장하고 조회한다.
```
public interface OrderRepository {
	Order findByNumber(OrderNumber number);
	void save(Order order);
	void delete(Order order);
}
```
도메인 모델을 사용해야 하는 코드는 리포지터리를 통해서 도메인 객체를 구한 뒤에 도메인 객체의 기능을 실행
public class CancelOrderService { private OrderRepository orderRepository; public void cancel(OrderNumber number) { Order order = orderRepository.findByNumber(number); if (order == null) { throw new OrderNotFoundException(orderId); } order.cancel(); } }
도메인 모델 관점에서 OrderRepository는 도메인 객체를 영속화하는 데 필요한 기능을 추상화 한것으로 고수준 모듈에 속한다.
기반 기술을 이용해서 OrderRepository를 구현한 클래스는 저수준 모듈로 인프라스트럭처 영역에 속한다.
전체 모듈 구조
응용 서비스는 의존 주입과 같은 방식을 사용해서 실제 리포지터리 구현 객체에 접근
응용 서비스와 리포지터리는 밀접한 연관이 있다.
- 응용 서비스는 필요한 도메인 객체를 구하거나 저장할 때 리포지터리를 사용한다.
- 응용 서비스는 트랜잭션을 관리하는데, 트랜잭션 처리는 리포지터리 구현 기술의 영향을 받는다.
리포지터리를 사용하는 주체가 응용 서비스이기 때문에 리포지터리는 응용 서비스가 필요로 하는 메서드를 제공한다.
- 애그리거트를 저장하는 메서드
- 애그리거트 루트 식별자로 애그리거트를 조회하는 메서드

2.5 요청 처리 흐름

표현 영역은 사용자가 전송한 데이터 형식이 올바른지 검사하고 문제가 없다면 데이터를 이용해서 응용 서비스에 기능 실행을 위임
표현 영역은 사용자가 전송한 데이터를 응용 서비스가 요구하는 형식으로 변환해서 전달
요청 처리 흐름
- 웹 브라우저에서 기능 실행 요청
- 표현 영역에 해당하는 컨트롤러는 HTTP 요청 파라미터를 응용 서비스가 필요로 하는 데이터로 변환 해서 응용 서비스의 인자로 전달
- 응용 서비스는 도메인 모델을 이용해서 로직 실행
- 도메인 객체를 리포지터리에서 가져와 실행하거나 신규 도메인 객체를 생성해 리포지터리에 저장
“예매하기”나 “예매 취소”와 같은 기능을 제공하는 응용 서비스는 도메인의 상태를 변경하므로 변경 상태가 물리 저장소에 올바르게 반영되도록 트랜잭션을 관리 해야한다.
- 스프링 프레임워크를 사용한다면 @Transactional 애너테이션을 이용해 트랜잭션을 처리할 수 있다.
```
public class CancelOrderService {
	private OrderRepository orderRepository;
	
	@Transactional
	public void cancel(OrderNumber number) {
		Order order = orderRepository.findByNumber(number);
		if (order == null) {
			throw new NoOrderException(number);
		}
		order.cancel()
	}
}
```

2.6 인프라스트럭처 개요

인프라스트럭처는 표현 영역, 응용 영역, 도메인 영역을 지원한다.
도메인 영역과 응용 영역에서 인프라스트럭처의 기능을 직접 사용하는 것보다 두 영역에서 정의한 인터페이스를 인프라스트럭처 영역에서 구현하는 것이 시스템을 더 유연하고 테스트하기 쉽게 만들어 준다.
무조건 인프라스트럭처에 대한 의존성을 없앨 필요는 없다.
- 스프링을 사용할 경우 응용 서비스는 트랜잭션 처리를 위해 @Transactional을 사용하는 것이 편리하다.
- 영속성 처리를 위해 JPA를 사용할 경우 @Entity나 @Table과 같은 JPA 전용 애너테이션을 도메인 모델 클래스에서 사용하는 것이 XML 매핑 설정을 이용하는 것보다 편리하다.
구현의 편리함은 DIP가 주는 다른 장점만큼 중요하기 때문에 DIP의 장점을 해치지 않는 범위에서 응용 영역과 도메인 영역에서 구현 기술에 대한 의존을 가져가는 것이 나쁘지 않다고 생각한다.
응용 영역과 도메인 영역이 인프라스트럭처에 대한 의존을 완전히 갖지 않도록 시도하는 것은 구현을 더 복잡하고 어렵게 만들 수 있다.
- @Transactional을 사용하면 한 줄로 트랙잭션을 처리할 수 있는데 코드에서 스프링에 대한 의존을 없애려면 복잡한 스프링 설정을 사용해야 한다.
- 의존은 없앴지만 특별히 테스트를 더 쉽게 할 수 있다거나 유연함을 증가시켜 주지 못한다.
- 설정만 복잡해지고 개발 시간만 늘어난다.
표현 영역은 항상 인프라스트럭처 영역과 쌍을 이룬다.
- 스프링 MVC를 사용해서 웹 요청을 처리하려면 스프링이 제공하는 MVC 프레임워크에 맞게 표현 영역을 구현
- Vert.x를 사용해서 Rest API 서버를 구축하려면 Vert.x에 맞게 웹 요청 처리 부분을 구현

2.7 모듈 구성

아키텍처의 각 영역은 별도 패키지에 위치한다.
패키지 구성 규칙에 정답이 존재하는 것은 안지만 영역별로 모듈이 위치할 패키지를 구성할 수 있을 것 이다.
도메인이 크면 하위 도메인으로 나누고 하위 도메인마다 별도 패키지를 구성한다.
도메인 모듈은 도메인에 속한 애그리거트를 기준으로 다시 패키지를 구성한다.
- 카탈로그 하위 도메인이 상품 애그리거트와 카테고리 애그리커트로 구성될 경우 도메인을 두 개의 하위 패키지로 구성할 수 있다.
애그리거트, 모델, 리포지터리는 같은 패키지에 위치시킨다.
- Order, OrderLine, Orderer, OrderRepository 등은 com.myshop.order.domain 패키지에 위치시킨다.
도메인이 복잡하면 도메인 모델과 도메인 서비스를 별도 패키지에 위치시킬 수도 있다.
- com.myshop.order.domain.order: 애그리거트 위치
- com.myshop.order.domain.service: 도메인 서비스 위치
응용 서비스도 도메인 별로 패키지를 구분할 수 있다.
- com.myshop.catalog.application.product
- com.myshop.catalog.application.category
모듈 구조를 얼마나 세분하게해야 하는지에 대한 정해진 규칙은 없다.
한 패키지에 너무 많은 타입이 몰려서 코드를 찾을 때 불편할 정도만 아니면 된다.

2.1 네 개의 영역

“표현”, “응용”, “도메인”, “인프라스트럭처”는 아키텍처를 설계할 때 출현하는 전형적인 네 가지 영역
- 표현 영역
  - 사용자의 요청을 받아 응용 영역에 전달, 응용 영역의 처리 결과를 사용자에게 전달
  - 스프링 MVC 프레임워크가 표현 영역의 기술
- 응용 영역
  - 표현 영역을 통해 사용자의 요청을 전달받은 응용 영역은 시스템이 사용자에게 제공해야할 기능을 구현
  - “주문 등록”, “주문 취소”, “상품 상세 조회” 등의 기능을 예로 들수 있다.
  - 기능을 구현하기 위한 도메인 영역의 도메인 모델을 사용
  - “주문 취소” 기능을 제공하는 응용 서비스를 도메인 모델을 사용해서 기능 구현이 가능
  - public class CancelOrderService { @Transactional public void cancelOrder(String orderId) { Order order = findOrderById(orderId); if (order == null) { throw new OrderNotFoundException(orderId); } order.cancel(); } }
  - 로직을 직접 수행하기보다는 도메인 모델에 로직 수행을 위임
    - “주문 취소” 로직을 직접 구현하지 않고 Order 객체에 취소 처리를 위임 하고 있다
- 도메인 영역
  - Order, OrderLine, ShippingInfo와 같은 도메인 모델
  - 도메인 모델은 핵심 로직을 구현한다.
    - “배송지 변경”, “결제 완료”, “주문 총액 계산”과 같은 핵심 로직을 도메인 모델에 구현한다.
- 인프라스트럭처 영역
  - 구현 기술에 대한 것을 다룬다
  - RDBMS 연동, 메시징 큐에 메시지 전송과 수신, 몽고DB나 레디스의 데이터 연동 처리 등
  - 논리적인 개념을 표현하기보다는 실제 구현을 다룬다
  - 도메인 영역, 응용 영역, 표현 영역은 구현 기술을 사용한 코드를 직접 만들지 않는다.
    - 인프라스트럭처 영역에서 제공하는 기능을 사용해서 필요한 기능을 개발

2.2 계층 구조 아키텍처

네 영역을 구성할 때 많이 사용하는 아키텍처가 그림과 같은 계층 구조이다.
- 표현 영역과 응용 영역은 도메인 영역을 사용
- 도메인 영역은 인프라스트럭처 영역을 사용
도메인의 복잡도에 따라 응용과 도메인을 분리하기도 하고 한 계층으로 합치기도 하지만 전체적인 아키텍처는 계층 구조를 따른다.
계층 구조는 특성상 상위 계층에서 하위 계층으로의 의존만 존재하고 하위 계층은 상위 계층에 의존하지 않는다.
계층 구조를 엄격하게 적용한다면 상위 계층은 바로 아래의 계층에만 의존을 가져야 하지만 구현의 편리함을 위해 계층 구조를 유연하게 적용하기도 한다.
응용 영역과 도메인 영역은 DB나 외부 시스템 연동을 위해 인프라스트럭처의 기능을 사용하므로 계층 구조를 사용하는 것이 직관적으로 이해하기 쉽다.
- 표현, 응용, 도메인 계층이 상세한 구현 기술을 다루는 인프라스트럭처 계층에 종속된다

도메인의 가격 계산 규칙의 예제

할인 금액을 계산하기 위해 Drools라는 룰 엔진을 사용해서 계산 로직을 수행하는 인프라스트럭처 영역의 코드를 만들어 보자

public class DroolsRuleEngine {
	private KieContainer kContainer;

	public DroolsRuleEngine() {
		KieServices ks = KieServices.Factory.get();
		kContainer = ks.getKieClasspathContainer();		
	}

	public void evalute(String sessionName, List<?> facts) {
		KiSession kSession = kContainer.newKieSession(sessionName);
		try {
			facts.forEach(x -> kSession.insert(x));
			kSession.fireAllRules();
		} finaly {
			kSession.dispose();
		}
	}
}

응용 영역은 가격 계산을 위해 인프라스트럭처 영역의 DroolsRuleEngine을 사용

public class CalcuateDiscountService {
	private DroolsRuleEngine ruleEngine;
	
	public CalculateDiscountService() {
		ruleEngine = new DroolsRuleEngine();
	}

	public Money calculateDiscount(List<OrderLine> orderLines, String customerId) {
		Customer customer = findCustomer(customerId);
		
		MutableMoney money = new MutableMoney(0);
		List<?> facts = Arrays.asList(customer, money);
		facts.addAll(orderLines);
		ruleEngine.evalute("discountCalculation", facts);
		return money.toImmutableMoney();
	}
}

CalculateDiscountService가 동작은 하겠지만 두가지 문제를 안고 있다.
- CalculateDiscountService를 테스트하기 어렵다
  - RuleEngine이 완벽하게 동작해야 한다.
  - RuleEngine 클래스와 관련 설정 파일 모두 만든 이후에 CalculateDiscountService 를 확인할 수 있다.
- 구현 방식을 변경하기 어렵다
  - ‘discountCalculation’ 문자열은 Drools의 세션 이름을 의미한다.
  - 세션 이름을 변경하면 CalculateDiscountService 코드도 함께 변경해야 한다.
CalculateDiscountService가 겉으로는 인프라스트럭처의 기술에 직접적인 의존을 하지 않는 것처럼 보여도 실제로는 Drools라는 인프라스트럭처 영역의 기술에 완전하게 의존하고 있다.
인프라스트럭처에 의존하면 ‘테스트 어려움’과 ‘기능 확장 어려움’이라는 두가지 문제가 발생한다.
- 문제 해답은 DIP에 있다.

2.3 DIP

가격 할인 계산을 하려면 고객 정보를 구해야하고, 구한 고객 정보와 주문 정보를 이용해서 룰을 실행해야 한다.
CalculateDiscountService는 고수준 모듈이다.
- 고수준 모듈은 의미 있는 단일 기능을 제공하는 모듈로 ‘가격 할인 계산’이라는 기능을 구현
- 가격 할인 계싼 기능을 구현하려면 고객 정보를 구해야하고 룰을 실행해야 하는데 이 두 기능이 하위 기능이다.
저수준 모듈은 하위 기능을 실제로 구현한 것이다.
- JPA를 이용해서 고객 정보를 읽어오는 모듈과 Drools로 룰을 실행하는 모듈이 저수준 모듈이 된다.

DIP는 저수준 모듈이 고수준 모듈에 의존하도록 바꾼다.

추상화 인터페이스를 사용

public interface RuleDiscounter {
	Money applyRules(Customer customer, List<OrderLine> orderLines);
}

CalculateDiscountService가 RuleDiscounter를 이용하도록 변경
- Drools에 의존하는 코드가 없다

public class CalcuateDiscountService {
	private RuleDiscounter ruleDiscounter;
	
	public CalculateDiscountService(RuleDiscounter ruleDiscounter) {
		this.ruleDiscounter = ruleDiscounter;
	}

	public Money calculateDiscount(List<OrderLine> orderLines, String customerId) {
		Customer customer = findCustomer(customerId);
		return ruleDiscounter.applyRules(customer, orderLines);
	}
}

RuleDiscounter를 상속받아 구현

public class DroolsRuleDiscounter implements RuleDiscounter {
	private KieCountainer kContainer;
	
	public DroolsRuleEngine() {
		KieService ks = KieServices.Factory.get();
		kContainer = ks.getKieClasspathContainer();
	}

	@Override
	public Money applyRules(Customer customer, List<OrderLine> orderLines) {
		KieSession kSession = kContainer.newKieSession("discountSession");
		try {
			...
			kSession.fireAllRules();
		} finally {
			kSession.dispose();
		}
		return money.toImmutableMoney();
	}
}

RuleDiscounter가 출현하면서 바뀐 구조
CalculateDiscountService는 더이상 구현 기술인 Drools에 의존하지 않는다.
- RuleDiscounter 인터페이스에 의존할 뿐
- ‘룰을 이용한 할인 금액 계산’은 고수준 모듈의 개념이므로 RuleDiscounter 인터페이스는 고수준 모듈에 속한다.
- DroolsRuleDiscounter는 고수준의 하위 기능인 RuleDiscounter를 구현한 것이므로 저수준 모듈에 속한다.

DIP를 적용하면 저수준 모듈이 고수준 모듈에 의존하게 된다.
- 고수준 모듈이 저수준 모듈을 사용하려면 고수준 모듈이 저수준 모듈에 의존해야 하는데, 반대로 저수준 모듈이 고수준 모듈에 의존한다고 해서 이를 DIP(Dependency Inversion Principle, 의존 역전 원칙)이라 부른다.
DIP를 적용하면 다른 영역인 인프라스트럭처 영역에 의존할 떄 발생했던 두가지 문제인 구현 교체가 어렵다는 것과 테스트가 어려운 문제를 해소할 수 있다.

고수준 모듈은 더 이상 저수준 모듈에 의존하지 않고 구현을 추상화한 인터페이스에 의존할 수 있다.

구현 기술이 변경되더라도 저수준 구현 객체를 생성하는 코드만 변경하면 된다.

// 기존 코드
RuleDiscounter roleDiscounter = new DroolsRuleDiscounter();
CalculateDiscountService disService = new CalculateDiscountService(roleDiscounter);

// 구현 기술 변경 
RuleDiscounter roleDiscounter = new SimpleRuleDiscounter();
CalculateDiscountService disService = new CalculateDiscountService(roleDiscounter);

스프링과 같은 의존 주입을 지원하는 프레임워크를 사용하면 설정 코드를 수정해서 쉽게 구현체를 변경할 수 있다.
CalculateDiscountService가 제대로 동작하는지 테스트하려면 CustomerRepository와 RuleDiscounter를 구현한 객체가 필요하다.
- CacluateDiscountService가 저수준 모듈에 직접 의존했다면 저수준 모듈이 만들어지기 전까진 테스트를 할 수 없음
- 인터페이스에 의존함으로 대역 객체를 사용해서 테스트를 진행 할수 있다.
- 실제 구현 대신 스텁이나 모의 객체와 같은 테스트 목적의 대역을 사용하여 거의 모든 상황을 테스트할 수 있다.
```
public class CalculateDiscountServiceTest {
	@Test
	public void noCustomer_thenExcetionShouldBeThrown() {
		CustomerRepository stubRepo = mock(CustomerRepository.class);
		when(stubRepo.findById("noCustId")).thenRetrun(null);

		RuleDiscounter stubRule = (cust, lines) -> null;
		
		CalculateDiscountService calDisSvc = new CalculateDiscountService(stbRepo, stubRule);
		assertThrows(NoCustomerException.class, () -> calDisSvc.calculateDiscount(ssomeLines, "noCustId"));
	}
}
```
실제 구현 없이 테스트를 할 수 있는 이유는 DIP를 적용해서 고수준 모듈이 저수준 모듈에 의존하지 않도록 했기 때문이다.

2.3.1 DIP 주의사항

DIP를 잘못 생각하면 단순히 인터페이스와 구현 클래스를 분리하는 정도로 받아드릴 수 있다.
DIP의 핵심은 고수준 모듈이 저수준 모듈의 의존하지 않도록 하기 위함이다.
잘못된 구조
- 도메인 영역은 구현 기술을 다루는 인프라스트럭처 영역에 의존하고 있다.
- 고수준 모듈이 저수준 모듈에 의존하고 있다.
DIP를 적용할 때 하위 기능을 추상화한 인터페이스는 고수준 모듈 관점에서 도출한다.
- CalculateDiscountService는 할인 금액을 구하기 위한 룰 엔진을 사용하는지 직접 연산하는지 중요하지 않다.
- 규칙에 따라 할인 금액을 계산하는 것이 중요
- ‘할인 금액 계산’을 추상화한 인터페이스는 저수준 모듈이 아닌 고수준 모듈에 위치한다.

2.3.2 DIP와 아키텍처

인프라스트럭처 영역은 구현 기술을 다루는 저수준 모듈이고 응용 영역과 도메인 영역은 고수준 모듈이다.
인프라스트럭처 계층이 가장 하단에 위치하는 계층형 구조와 달리 아키텍처에 DIP를 적용하면 인프라스트럭처 영역이 응용 영역와 도메인 영역에 의존하는 구조가 된다.
인프라스트럭처에 위치한 클래스가 도메인이나 응용 영역에 정의한 인터페이스를 상속받아 구현하는 구조가 되므로 도메인과 응용 영역에 대한 영향을 주지 않거나 최소화하면서 구현 기술을 변경하는 것이 가능하다.
주문 시 통지 방식에 SMS를 추가해야 한다는 요구사항이 들어왔을 때 OrderService는 변경할 필요가 없다.
- 두 통지 방식을 함께 제공하는 Notifier 구현 클래스를 인프라스트럭처 영역에 추가하면 된다.
마이바티스 대신 JPA를 구현 기술로 사용하고 싶다면 JPA를 이용한 OrderRepository 구현 클래스를 인프라 스트럭처 영역에 추가하면 된다.

2.4 도메인 영역의 주요 구성요소

도메인 영역을 구성하는 요소요소 설명

엔티티 ENTITY	고유 식별자를 갖는 객체로 자신의 라이프 사이클을 갖는다. Order, Member, Product와 같이 도메인의 고유한 개념을 표현한다. 도메인 모델의 데이터를 포함하며 해당 데이터와 관련된 기능을 함께 제공
밸류 VALUE	고유 식별자를 갖지 않는 객체로 주로 개념적으로 하나의 값을 표현할 때 사용된다. 배송지 주소를 표현하기 위한 Address나 구매한 금액을 위한 Money와 같은 타입이 밸류 타입이다. 엔티티의 속성으로 사용할 뿐만 아니라 다른 밸류 타입의 속성도 사용할 수 있다.
애그리거트 AGGREGATE	애그리거트는 연관된 엔티티와 밸류 객체를 개념적으로 하나로 묶는 것이다. 주문과 관련된 Order 엔티티, OrderLine 밸류, Orderer 밸류 객체를 주문 애그리거트로 묶을 수 있다.
리포지터리 REPOSITORY	도메인 모델의 영속성을 처리한다. DBMS 테이블에서 엔티티 객체를 로딩하거나 저장하는 기능을 제공
도메인 서비스 DOMAIN SERVICE	특정 엔티티에 속하지 않는 도메인 로직을 제공한다. ‘할인 금액 계산’은 상품, 쿠폰, 회원 등급, 구매 금액 등 다양한 조건을 이용해서 구현하게 되는데 이렇게 도메인 로직이 여러 엔티티와 밸류를 필요로 하면 도메인 서비스에 로직을 구현

2.4.1 엔티티와 밸류

엔티티와 도메인 모델의 가장 큰 차이점은 도메인 모델의 엔티티는 데이터와 함께 도메인 기능을 함께 제공한다는 점
- 주문을 표현하는 엔티티는 주문과 관련된 데이터뿐만 아니라 배송지 주소 변경을 위한 기능을 함께 제공
```
public class Order {
	private OrderNo number;
	private Orderer orderer;
	private ShippingInfo shippingInfo;
	
	// 도메인 모델 엔티티는 도메인 기능도 함께 제공
	public void shangeShippingInfo(ShippingInfo newShippingInfo) {
		...	
	}
}
```
도메인 모델의 엔티티는 단순히 데이터를 담고 있는 데이터 구조라기보다는 데이터와 함께 기능을 제공하는 객체
도메인 관점에서 기능을 구현하고 기능 구현을 캡슐화해서 데이터가 임의로 변경되는 것을 막는다.
도메인 모델의 엔티티는 두 개 이상의 데이터가 개념적으로 하나인 경우 밸류 타입을 이용해서 표현할 수 있다
- Orderer는 밸류 타입으로 주문자 이름과 이메일 데이터를 포함할 수 있다.
```
public class Orderer {
	private String name;
	private String email;
}
```
RDBMS와 같은 관계형 데이터베이스는 밸류 타입을 재대로 표현하기 힘들다.
- Ordere의 개별 데이터를 저장하거나 밸로 테이블로 분리해서 저장해야 한다.
- 한 테이블에 주문자 정보 함께 넣기
  - 주문자라는 개념이 들어나지 않고 주문자의 개별 데이터만 드러난다.
- 다른 테이블에 주문자 정보 넣기
  - 주문자 데이터를 별도 테이블에 저장했지만 이것은 테이블의 엔티티에 가까우며 밸류 타입의 의미가 드러나지 않는다.

밸류는 불변으로 구현할 것을 권장

엔티티의 밸류 타입 데이터를 변경할 떄는 객체 자체를 완전히 교체한다는 것을 의미

public class Order {
	private ShippingInfo shippingInfo;
	
	public void shangeShippingInfo(ShippingInfo newShippingInfo) {
		checkShippingInfoChangeable();
		setShippingInfo(newShippingInfo);
	}

	private void setShippingInfo(ShippingInfo newShippingInfo) {
		if (newShippingInfo == null) {
			throw new IllegalArgumentException();
		}
		this.shippingInfo = newShippingInfo;
	}
}

2.4.2 애그리거트

도메인이 커질수록 개발할 도메인 모델도 커지면서 많은 엔티티와 밸류가 출현한다.
도메인 모델이 복잡해지면 개발자가 전체 구조가 아닌 한 개 엔티티와 밸류에만 집중하는 상황이 발생한다.
- 상위 수준에서 모델을 관리하지 않고 개별 요소에만 초점을 맞추다 보면, 큰 수준에서 모델을 이해하지 못해 큰 틀에서 모델은 관리할 수 없는 상황에 빠질 수 있다.
도메인 모델에 전체 구조를 이해하는데 도움이 되는 것이 바로 애그리거트(AGGREGATE)이다.
애그리거트는 관련 객체를 하나로 묶은 군집이다.
- 모메인 개념은“주문”, “배송지 정보”, “주문자”, “주문 목록”, “총 결제 금액”의 하위 모델로 구성된다.
- 하위 내념을 표현한 모델을 하나로 묶어서 “주문”이라는 상위 개념으로 표현할 수 있다.
애그리거트를 사용하면 개별 객체가 아닌 관련 객체를 묶어서 객체 군집 단위로 모델을 바라볼 수 있게 된다.
- 개별 객체 간의 관계가 아닌 애그리거트 간의 관계로 도메인 모델을 이해하고 구현하고, 큰 틀에서 도메인 모델을 관리할 수 있다.
애그리거트는 군집에 속한 객체를 관리하는 루트 엔티티를 갖는다.
- 루트 엔티티는 애그리거트에 속해 있는 엔티티와 밸류 객체를 이용해서 애그리거트가 구현해야 할 기능을 제공
- 애그리거트를 사용하는 코드는 애그리거트 루트가 제공하는 기능을 실행
- 애그리거트 루트를 통해 간접적으로 애그리거트 내의 다른 엔티티나 밸류 객체에 접근
- 애그리거트의 내부 구현을 숨겨서 애그리거트 단위로 구현을 캡슐화할 수 있도록 돕는다.
주문 애그리거트
- 애그리거트 루트인 Order는 주문 도메인 로직에 맞게 애그리거트의 상태를 관리
- Order의 배송지 정보 변경 기능은 배송지를 변경할 수 있는지를 확인한 위에 배송지 정보를 변경
- 주문 애그리거트는 Order를 통하지 않고 ShippingInfo를 변경할 수 있는 방법을 제공하지 않는다.
  - 배송지를 변경하려면 루트 엔티티인 Order를 사용해야 하므로 배소지 정보를 변경할 때는 Order가 구현한 도메인 로직을 항상 따르게 된다.
애그리거트를 구현할 때는 고려할 것이 많다.
- 애그리거트를 어떻게 구성했느냐에 따라 구현이 복잡해지기도 하고
- 트랜잭션 범위가 달라지기도 한다.

2.4.3 리포지터리

도메인 객체를 지속적으로 사용하려면 RDBMS, NoSQL, 로컬 파일과 같은 물리적인 저장소에 도메인 객체를 보관해야 한다.
- 이를 위한 도메인 모델이 리포지터리(Repository)이다.
엔티티나 밸류가 요구사항에 도출되는 도메인 모델이라면 리포리터리는 구현을 위한 도메인 모델이다.
리포지터리는 애그리거트 단위로 도메인 객체를 저장하고 조회하는 기능을 정의
- OrderRepository의 메서드를 보면 대상을 찾고 저장하는 단위가 애그리거트 루트인 Order인 것을 알 수 있다.
- Order는 애그리거트에 속한 모든 객체를 포함하고 있으므로 결과적으로 애그리거트 단위로 저장하고 조회한다.
```
public interface OrderRepository {
	Order findByNumber(OrderNumber number);
	void save(Order order);
	void delete(Order order);
}
```
도메인 모델을 사용해야 하는 코드는 리포지터리를 통해서 도메인 객체를 구한 뒤에 도메인 객체의 기능을 실행
public class CancelOrderService { private OrderRepository orderRepository; public void cancel(OrderNumber number) { Order order = orderRepository.findByNumber(number); if (order == null) { throw new OrderNotFoundException(orderId); } order.cancel(); } }
도메인 모델 관점에서 OrderRepository는 도메인 객체를 영속화하는 데 필요한 기능을 추상화 한것으로 고수준 모듈에 속한다.
기반 기술을 이용해서 OrderRepository를 구현한 클래스는 저수준 모듈로 인프라스트럭처 영역에 속한다.
전체 모듈 구조
응용 서비스는 의존 주입과 같은 방식을 사용해서 실제 리포지터리 구현 객체에 접근
응용 서비스와 리포지터리는 밀접한 연관이 있다.
- 응용 서비스는 필요한 도메인 객체를 구하거나 저장할 때 리포지터리를 사용한다.
- 응용 서비스는 트랜잭션을 관리하는데, 트랜잭션 처리는 리포지터리 구현 기술의 영향을 받는다.
리포지터리를 사용하는 주체가 응용 서비스이기 때문에 리포지터리는 응용 서비스가 필요로 하는 메서드를 제공한다.
- 애그리거트를 저장하는 메서드
- 애그리거트 루트 식별자로 애그리거트를 조회하는 메서드

2.5 요청 처리 흐름

표현 영역은 사용자가 전송한 데이터 형식이 올바른지 검사하고 문제가 없다면 데이터를 이용해서 응용 서비스에 기능 실행을 위임
표현 영역은 사용자가 전송한 데이터를 응용 서비스가 요구하는 형식으로 변환해서 전달
요청 처리 흐름
- 웹 브라우저에서 기능 실행 요청
- 표현 영역에 해당하는 컨트롤러는 HTTP 요청 파라미터를 응용 서비스가 필요로 하는 데이터로 변환 해서 응용 서비스의 인자로 전달
- 응용 서비스는 도메인 모델을 이용해서 로직 실행
- 도메인 객체를 리포지터리에서 가져와 실행하거나 신규 도메인 객체를 생성해 리포지터리에 저장
“예매하기”나 “예매 취소”와 같은 기능을 제공하는 응용 서비스는 도메인의 상태를 변경하므로 변경 상태가 물리 저장소에 올바르게 반영되도록 트랜잭션을 관리 해야한다.
- 스프링 프레임워크를 사용한다면 @Transactional 애너테이션을 이용해 트랜잭션을 처리할 수 있다.
```
public class CancelOrderService {
	private OrderRepository orderRepository;
	
	@Transactional
	public void cancel(OrderNumber number) {
		Order order = orderRepository.findByNumber(number);
		if (order == null) {
			throw new NoOrderException(number);
		}
		order.cancel()
	}
}
```

2.6 인프라스트럭처 개요

인프라스트럭처는 표현 영역, 응용 영역, 도메인 영역을 지원한다.
도메인 영역과 응용 영역에서 인프라스트럭처의 기능을 직접 사용하는 것보다 두 영역에서 정의한 인터페이스를 인프라스트럭처 영역에서 구현하는 것이 시스템을 더 유연하고 테스트하기 쉽게 만들어 준다.
무조건 인프라스트럭처에 대한 의존성을 없앨 필요는 없다.
- 스프링을 사용할 경우 응용 서비스는 트랜잭션 처리를 위해 @Transactional을 사용하는 것이 편리하다.
- 영속성 처리를 위해 JPA를 사용할 경우 @Entity나 @Table과 같은 JPA 전용 애너테이션을 도메인 모델 클래스에서 사용하는 것이 XML 매핑 설정을 이용하는 것보다 편리하다.
구현의 편리함은 DIP가 주는 다른 장점만큼 중요하기 때문에 DIP의 장점을 해치지 않는 범위에서 응용 영역과 도메인 영역에서 구현 기술에 대한 의존을 가져가는 것이 나쁘지 않다고 생각한다.
응용 영역과 도메인 영역이 인프라스트럭처에 대한 의존을 완전히 갖지 않도록 시도하는 것은 구현을 더 복잡하고 어렵게 만들 수 있다.
- @Transactional을 사용하면 한 줄로 트랙잭션을 처리할 수 있는데 코드에서 스프링에 대한 의존을 없애려면 복잡한 스프링 설정을 사용해야 한다.
- 의존은 없앴지만 특별히 테스트를 더 쉽게 할 수 있다거나 유연함을 증가시켜 주지 못한다.
- 설정만 복잡해지고 개발 시간만 늘어난다.
표현 영역은 항상 인프라스트럭처 영역과 쌍을 이룬다.
- 스프링 MVC를 사용해서 웹 요청을 처리하려면 스프링이 제공하는 MVC 프레임워크에 맞게 표현 영역을 구현
- Vert.x를 사용해서 Rest API 서버를 구축하려면 Vert.x에 맞게 웹 요청 처리 부분을 구현

2.7 모듈 구성

아키텍처의 각 영역은 별도 패키지에 위치한다.
패키지 구성 규칙에 정답이 존재하는 것은 안지만 영역별로 모듈이 위치할 패키지를 구성할 수 있을 것 이다.
도메인이 크면 하위 도메인으로 나누고 하위 도메인마다 별도 패키지를 구성한다.
도메인 모듈은 도메인에 속한 애그리거트를 기준으로 다시 패키지를 구성한다.
- 카탈로그 하위 도메인이 상품 애그리거트와 카테고리 애그리커트로 구성될 경우 도메인을 두 개의 하위 패키지로 구성할 수 있다.
애그리거트, 모델, 리포지터리는 같은 패키지에 위치시킨다.
- Order, OrderLine, Orderer, OrderRepository 등은 com.myshop.order.domain 패키지에 위치시킨다.
도메인이 복잡하면 도메인 모델과 도메인 서비스를 별도 패키지에 위치시킬 수도 있다.
- com.myshop.order.domain.order: 애그리거트 위치
- com.myshop.order.domain.service: 도메인 서비스 위치
응용 서비스도 도메인 별로 패키지를 구분할 수 있다.
- com.myshop.catalog.application.product
- com.myshop.catalog.application.category
모듈 구조를 얼마나 세분하게해야 하는지에 대한 정해진 규칙은 없다.
한 패키지에 너무 많은 타입이 몰려서 코드를 찾을 때 불편할 정도만 아니면 된다.

2.1 네 개의 영역

“표현”, “응용”, “도메인”, “인프라스트럭처”는 아키텍처를 설계할 때 출현하는 전형적인 네 가지 영역
- 표현 영역
  - 사용자의 요청을 받아 응용 영역에 전달, 응용 영역의 처리 결과를 사용자에게 전달
  - 스프링 MVC 프레임워크가 표현 영역의 기술
- 응용 영역
  - 표현 영역을 통해 사용자의 요청을 전달받은 응용 영역은 시스템이 사용자에게 제공해야할 기능을 구현
  - “주문 등록”, “주문 취소”, “상품 상세 조회” 등의 기능을 예로 들수 있다.
  - 기능을 구현하기 위한 도메인 영역의 도메인 모델을 사용
  - “주문 취소” 기능을 제공하는 응용 서비스를 도메인 모델을 사용해서 기능 구현이 가능
  - public class CancelOrderService { @Transactional public void cancelOrder(String orderId) { Order order = findOrderById(orderId); if (order == null) { throw new OrderNotFoundException(orderId); } order.cancel(); } }
  - 로직을 직접 수행하기보다는 도메인 모델에 로직 수행을 위임
    - “주문 취소” 로직을 직접 구현하지 않고 Order 객체에 취소 처리를 위임 하고 있다
- 도메인 영역
  - Order, OrderLine, ShippingInfo와 같은 도메인 모델
  - 도메인 모델은 핵심 로직을 구현한다.
    - “배송지 변경”, “결제 완료”, “주문 총액 계산”과 같은 핵심 로직을 도메인 모델에 구현한다.
- 인프라스트럭처 영역
  - 구현 기술에 대한 것을 다룬다
  - RDBMS 연동, 메시징 큐에 메시지 전송과 수신, 몽고DB나 레디스의 데이터 연동 처리 등
  - 논리적인 개념을 표현하기보다는 실제 구현을 다룬다
  - 도메인 영역, 응용 영역, 표현 영역은 구현 기술을 사용한 코드를 직접 만들지 않는다.
    - 인프라스트럭처 영역에서 제공하는 기능을 사용해서 필요한 기능을 개발

2.2 계층 구조 아키텍처

네 영역을 구성할 때 많이 사용하는 아키텍처가 그림과 같은 계층 구조이다.
- 표현 영역과 응용 영역은 도메인 영역을 사용
- 도메인 영역은 인프라스트럭처 영역을 사용
도메인의 복잡도에 따라 응용과 도메인을 분리하기도 하고 한 계층으로 합치기도 하지만 전체적인 아키텍처는 계층 구조를 따른다.
계층 구조는 특성상 상위 계층에서 하위 계층으로의 의존만 존재하고 하위 계층은 상위 계층에 의존하지 않는다.
계층 구조를 엄격하게 적용한다면 상위 계층은 바로 아래의 계층에만 의존을 가져야 하지만 구현의 편리함을 위해 계층 구조를 유연하게 적용하기도 한다.
응용 영역과 도메인 영역은 DB나 외부 시스템 연동을 위해 인프라스트럭처의 기능을 사용하므로 계층 구조를 사용하는 것이 직관적으로 이해하기 쉽다.
- 표현, 응용, 도메인 계층이 상세한 구현 기술을 다루는 인프라스트럭처 계층에 종속된다

도메인의 가격 계산 규칙의 예제

할인 금액을 계산하기 위해 Drools라는 룰 엔진을 사용해서 계산 로직을 수행하는 인프라스트럭처 영역의 코드를 만들어 보자

public class DroolsRuleEngine {
	private KieContainer kContainer;

	public DroolsRuleEngine() {
		KieServices ks = KieServices.Factory.get();
		kContainer = ks.getKieClasspathContainer();		
	}

	public void evalute(String sessionName, List<?> facts) {
		KiSession kSession = kContainer.newKieSession(sessionName);
		try {
			facts.forEach(x -> kSession.insert(x));
			kSession.fireAllRules();
		} finaly {
			kSession.dispose();
		}
	}
}

응용 영역은 가격 계산을 위해 인프라스트럭처 영역의 DroolsRuleEngine을 사용

public class CalcuateDiscountService {
	private DroolsRuleEngine ruleEngine;
	
	public CalculateDiscountService() {
		ruleEngine = new DroolsRuleEngine();
	}

	public Money calculateDiscount(List<OrderLine> orderLines, String customerId) {
		Customer customer = findCustomer(customerId);
		
		MutableMoney money = new MutableMoney(0);
		List<?> facts = Arrays.asList(customer, money);
		facts.addAll(orderLines);
		ruleEngine.evalute("discountCalculation", facts);
		return money.toImmutableMoney();
	}
}

CalculateDiscountService가 동작은 하겠지만 두가지 문제를 안고 있다.
- CalculateDiscountService를 테스트하기 어렵다
  - RuleEngine이 완벽하게 동작해야 한다.
  - RuleEngine 클래스와 관련 설정 파일 모두 만든 이후에 CalculateDiscountService 를 확인할 수 있다.
- 구현 방식을 변경하기 어렵다
  - ‘discountCalculation’ 문자열은 Drools의 세션 이름을 의미한다.
  - 세션 이름을 변경하면 CalculateDiscountService 코드도 함께 변경해야 한다.
CalculateDiscountService가 겉으로는 인프라스트럭처의 기술에 직접적인 의존을 하지 않는 것처럼 보여도 실제로는 Drools라는 인프라스트럭처 영역의 기술에 완전하게 의존하고 있다.
인프라스트럭처에 의존하면 ‘테스트 어려움’과 ‘기능 확장 어려움’이라는 두가지 문제가 발생한다.
- 문제 해답은 DIP에 있다.

2.3 DIP

가격 할인 계산을 하려면 고객 정보를 구해야하고, 구한 고객 정보와 주문 정보를 이용해서 룰을 실행해야 한다.
CalculateDiscountService는 고수준 모듈이다.
- 고수준 모듈은 의미 있는 단일 기능을 제공하는 모듈로 ‘가격 할인 계산’이라는 기능을 구현
- 가격 할인 계싼 기능을 구현하려면 고객 정보를 구해야하고 룰을 실행해야 하는데 이 두 기능이 하위 기능이다.
저수준 모듈은 하위 기능을 실제로 구현한 것이다.
- JPA를 이용해서 고객 정보를 읽어오는 모듈과 Drools로 룰을 실행하는 모듈이 저수준 모듈이 된다.

DIP는 저수준 모듈이 고수준 모듈에 의존하도록 바꾼다.

추상화 인터페이스를 사용

public interface RuleDiscounter {
	Money applyRules(Customer customer, List<OrderLine> orderLines);
}

CalculateDiscountService가 RuleDiscounter를 이용하도록 변경
- Drools에 의존하는 코드가 없다

public class CalcuateDiscountService {
	private RuleDiscounter ruleDiscounter;
	
	public CalculateDiscountService(RuleDiscounter ruleDiscounter) {
		this.ruleDiscounter = ruleDiscounter;
	}

	public Money calculateDiscount(List<OrderLine> orderLines, String customerId) {
		Customer customer = findCustomer(customerId);
		return ruleDiscounter.applyRules(customer, orderLines);
	}
}

RuleDiscounter를 상속받아 구현

public class DroolsRuleDiscounter implements RuleDiscounter {
	private KieCountainer kContainer;
	
	public DroolsRuleEngine() {
		KieService ks = KieServices.Factory.get();
		kContainer = ks.getKieClasspathContainer();
	}

	@Override
	public Money applyRules(Customer customer, List<OrderLine> orderLines) {
		KieSession kSession = kContainer.newKieSession("discountSession");
		try {
			...
			kSession.fireAllRules();
		} finally {
			kSession.dispose();
		}
		return money.toImmutableMoney();
	}
}

RuleDiscounter가 출현하면서 바뀐 구조
CalculateDiscountService는 더이상 구현 기술인 Drools에 의존하지 않는다.
- RuleDiscounter 인터페이스에 의존할 뿐
- ‘룰을 이용한 할인 금액 계산’은 고수준 모듈의 개념이므로 RuleDiscounter 인터페이스는 고수준 모듈에 속한다.
- DroolsRuleDiscounter는 고수준의 하위 기능인 RuleDiscounter를 구현한 것이므로 저수준 모듈에 속한다.

DIP를 적용하면 저수준 모듈이 고수준 모듈에 의존하게 된다.
- 고수준 모듈이 저수준 모듈을 사용하려면 고수준 모듈이 저수준 모듈에 의존해야 하는데, 반대로 저수준 모듈이 고수준 모듈에 의존한다고 해서 이를 DIP(Dependency Inversion Principle, 의존 역전 원칙)이라 부른다.
DIP를 적용하면 다른 영역인 인프라스트럭처 영역에 의존할 떄 발생했던 두가지 문제인 구현 교체가 어렵다는 것과 테스트가 어려운 문제를 해소할 수 있다.

고수준 모듈은 더 이상 저수준 모듈에 의존하지 않고 구현을 추상화한 인터페이스에 의존할 수 있다.

구현 기술이 변경되더라도 저수준 구현 객체를 생성하는 코드만 변경하면 된다.

// 기존 코드
RuleDiscounter roleDiscounter = new DroolsRuleDiscounter();
CalculateDiscountService disService = new CalculateDiscountService(roleDiscounter);

// 구현 기술 변경 
RuleDiscounter roleDiscounter = new SimpleRuleDiscounter();
CalculateDiscountService disService = new CalculateDiscountService(roleDiscounter);

스프링과 같은 의존 주입을 지원하는 프레임워크를 사용하면 설정 코드를 수정해서 쉽게 구현체를 변경할 수 있다.
CalculateDiscountService가 제대로 동작하는지 테스트하려면 CustomerRepository와 RuleDiscounter를 구현한 객체가 필요하다.
- CacluateDiscountService가 저수준 모듈에 직접 의존했다면 저수준 모듈이 만들어지기 전까진 테스트를 할 수 없음
- 인터페이스에 의존함으로 대역 객체를 사용해서 테스트를 진행 할수 있다.
- 실제 구현 대신 스텁이나 모의 객체와 같은 테스트 목적의 대역을 사용하여 거의 모든 상황을 테스트할 수 있다.
```
public class CalculateDiscountServiceTest {
	@Test
	public void noCustomer_thenExcetionShouldBeThrown() {
		CustomerRepository stubRepo = mock(CustomerRepository.class);
		when(stubRepo.findById("noCustId")).thenRetrun(null);

		RuleDiscounter stubRule = (cust, lines) -> null;
		
		CalculateDiscountService calDisSvc = new CalculateDiscountService(stbRepo, stubRule);
		assertThrows(NoCustomerException.class, () -> calDisSvc.calculateDiscount(ssomeLines, "noCustId"));
	}
}
```
실제 구현 없이 테스트를 할 수 있는 이유는 DIP를 적용해서 고수준 모듈이 저수준 모듈에 의존하지 않도록 했기 때문이다.

2.3.1 DIP 주의사항

DIP를 잘못 생각하면 단순히 인터페이스와 구현 클래스를 분리하는 정도로 받아드릴 수 있다.
DIP의 핵심은 고수준 모듈이 저수준 모듈의 의존하지 않도록 하기 위함이다.
잘못된 구조
- 도메인 영역은 구현 기술을 다루는 인프라스트럭처 영역에 의존하고 있다.
- 고수준 모듈이 저수준 모듈에 의존하고 있다.
DIP를 적용할 때 하위 기능을 추상화한 인터페이스는 고수준 모듈 관점에서 도출한다.
- CalculateDiscountService는 할인 금액을 구하기 위한 룰 엔진을 사용하는지 직접 연산하는지 중요하지 않다.
- 규칙에 따라 할인 금액을 계산하는 것이 중요
- ‘할인 금액 계산’을 추상화한 인터페이스는 저수준 모듈이 아닌 고수준 모듈에 위치한다.

2.3.2 DIP와 아키텍처

인프라스트럭처 영역은 구현 기술을 다루는 저수준 모듈이고 응용 영역과 도메인 영역은 고수준 모듈이다.
인프라스트럭처 계층이 가장 하단에 위치하는 계층형 구조와 달리 아키텍처에 DIP를 적용하면 인프라스트럭처 영역이 응용 영역와 도메인 영역에 의존하는 구조가 된다.
인프라스트럭처에 위치한 클래스가 도메인이나 응용 영역에 정의한 인터페이스를 상속받아 구현하는 구조가 되므로 도메인과 응용 영역에 대한 영향을 주지 않거나 최소화하면서 구현 기술을 변경하는 것이 가능하다.
주문 시 통지 방식에 SMS를 추가해야 한다는 요구사항이 들어왔을 때 OrderService는 변경할 필요가 없다.
- 두 통지 방식을 함께 제공하는 Notifier 구현 클래스를 인프라스트럭처 영역에 추가하면 된다.
마이바티스 대신 JPA를 구현 기술로 사용하고 싶다면 JPA를 이용한 OrderRepository 구현 클래스를 인프라 스트럭처 영역에 추가하면 된다.

2.4 도메인 영역의 주요 구성요소

도메인 영역을 구성하는 요소요소 설명

엔티티 ENTITY	고유 식별자를 갖는 객체로 자신의 라이프 사이클을 갖는다. Order, Member, Product와 같이 도메인의 고유한 개념을 표현한다. 도메인 모델의 데이터를 포함하며 해당 데이터와 관련된 기능을 함께 제공
밸류 VALUE	고유 식별자를 갖지 않는 객체로 주로 개념적으로 하나의 값을 표현할 때 사용된다. 배송지 주소를 표현하기 위한 Address나 구매한 금액을 위한 Money와 같은 타입이 밸류 타입이다. 엔티티의 속성으로 사용할 뿐만 아니라 다른 밸류 타입의 속성도 사용할 수 있다.
애그리거트 AGGREGATE	애그리거트는 연관된 엔티티와 밸류 객체를 개념적으로 하나로 묶는 것이다. 주문과 관련된 Order 엔티티, OrderLine 밸류, Orderer 밸류 객체를 주문 애그리거트로 묶을 수 있다.
리포지터리 REPOSITORY	도메인 모델의 영속성을 처리한다. DBMS 테이블에서 엔티티 객체를 로딩하거나 저장하는 기능을 제공
도메인 서비스 DOMAIN SERVICE	특정 엔티티에 속하지 않는 도메인 로직을 제공한다. ‘할인 금액 계산’은 상품, 쿠폰, 회원 등급, 구매 금액 등 다양한 조건을 이용해서 구현하게 되는데 이렇게 도메인 로직이 여러 엔티티와 밸류를 필요로 하면 도메인 서비스에 로직을 구현

2.4.1 엔티티와 밸류

엔티티와 도메인 모델의 가장 큰 차이점은 도메인 모델의 엔티티는 데이터와 함께 도메인 기능을 함께 제공한다는 점
- 주문을 표현하는 엔티티는 주문과 관련된 데이터뿐만 아니라 배송지 주소 변경을 위한 기능을 함께 제공
```
public class Order {
	private OrderNo number;
	private Orderer orderer;
	private ShippingInfo shippingInfo;
	
	// 도메인 모델 엔티티는 도메인 기능도 함께 제공
	public void shangeShippingInfo(ShippingInfo newShippingInfo) {
		...	
	}
}
```
도메인 모델의 엔티티는 단순히 데이터를 담고 있는 데이터 구조라기보다는 데이터와 함께 기능을 제공하는 객체
도메인 관점에서 기능을 구현하고 기능 구현을 캡슐화해서 데이터가 임의로 변경되는 것을 막는다.
도메인 모델의 엔티티는 두 개 이상의 데이터가 개념적으로 하나인 경우 밸류 타입을 이용해서 표현할 수 있다
- Orderer는 밸류 타입으로 주문자 이름과 이메일 데이터를 포함할 수 있다.
```
public class Orderer {
	private String name;
	private String email;
}
```
RDBMS와 같은 관계형 데이터베이스는 밸류 타입을 재대로 표현하기 힘들다.
- Ordere의 개별 데이터를 저장하거나 밸로 테이블로 분리해서 저장해야 한다.
- 한 테이블에 주문자 정보 함께 넣기
  - 주문자라는 개념이 들어나지 않고 주문자의 개별 데이터만 드러난다.
- 다른 테이블에 주문자 정보 넣기
  - 주문자 데이터를 별도 테이블에 저장했지만 이것은 테이블의 엔티티에 가까우며 밸류 타입의 의미가 드러나지 않는다.

밸류는 불변으로 구현할 것을 권장

엔티티의 밸류 타입 데이터를 변경할 떄는 객체 자체를 완전히 교체한다는 것을 의미

public class Order {
	private ShippingInfo shippingInfo;
	
	public void shangeShippingInfo(ShippingInfo newShippingInfo) {
		checkShippingInfoChangeable();
		setShippingInfo(newShippingInfo);
	}

	private void setShippingInfo(ShippingInfo newShippingInfo) {
		if (newShippingInfo == null) {
			throw new IllegalArgumentException();
		}
		this.shippingInfo = newShippingInfo;
	}
}

2.4.2 애그리거트

도메인이 커질수록 개발할 도메인 모델도 커지면서 많은 엔티티와 밸류가 출현한다.
도메인 모델이 복잡해지면 개발자가 전체 구조가 아닌 한 개 엔티티와 밸류에만 집중하는 상황이 발생한다.
- 상위 수준에서 모델을 관리하지 않고 개별 요소에만 초점을 맞추다 보면, 큰 수준에서 모델을 이해하지 못해 큰 틀에서 모델은 관리할 수 없는 상황에 빠질 수 있다.
도메인 모델에 전체 구조를 이해하는데 도움이 되는 것이 바로 애그리거트(AGGREGATE)이다.
애그리거트는 관련 객체를 하나로 묶은 군집이다.
- 모메인 개념은“주문”, “배송지 정보”, “주문자”, “주문 목록”, “총 결제 금액”의 하위 모델로 구성된다.
- 하위 내념을 표현한 모델을 하나로 묶어서 “주문”이라는 상위 개념으로 표현할 수 있다.
애그리거트를 사용하면 개별 객체가 아닌 관련 객체를 묶어서 객체 군집 단위로 모델을 바라볼 수 있게 된다.
- 개별 객체 간의 관계가 아닌 애그리거트 간의 관계로 도메인 모델을 이해하고 구현하고, 큰 틀에서 도메인 모델을 관리할 수 있다.
애그리거트는 군집에 속한 객체를 관리하는 루트 엔티티를 갖는다.
- 루트 엔티티는 애그리거트에 속해 있는 엔티티와 밸류 객체를 이용해서 애그리거트가 구현해야 할 기능을 제공
- 애그리거트를 사용하는 코드는 애그리거트 루트가 제공하는 기능을 실행
- 애그리거트 루트를 통해 간접적으로 애그리거트 내의 다른 엔티티나 밸류 객체에 접근
- 애그리거트의 내부 구현을 숨겨서 애그리거트 단위로 구현을 캡슐화할 수 있도록 돕는다.
주문 애그리거트
- 애그리거트 루트인 Order는 주문 도메인 로직에 맞게 애그리거트의 상태를 관리
- Order의 배송지 정보 변경 기능은 배송지를 변경할 수 있는지를 확인한 위에 배송지 정보를 변경
- 주문 애그리거트는 Order를 통하지 않고 ShippingInfo를 변경할 수 있는 방법을 제공하지 않는다.
  - 배송지를 변경하려면 루트 엔티티인 Order를 사용해야 하므로 배소지 정보를 변경할 때는 Order가 구현한 도메인 로직을 항상 따르게 된다.
애그리거트를 구현할 때는 고려할 것이 많다.
- 애그리거트를 어떻게 구성했느냐에 따라 구현이 복잡해지기도 하고
- 트랜잭션 범위가 달라지기도 한다.

2.4.3 리포지터리

도메인 객체를 지속적으로 사용하려면 RDBMS, NoSQL, 로컬 파일과 같은 물리적인 저장소에 도메인 객체를 보관해야 한다.
- 이를 위한 도메인 모델이 리포지터리(Repository)이다.
엔티티나 밸류가 요구사항에 도출되는 도메인 모델이라면 리포리터리는 구현을 위한 도메인 모델이다.
리포지터리는 애그리거트 단위로 도메인 객체를 저장하고 조회하는 기능을 정의
- OrderRepository의 메서드를 보면 대상을 찾고 저장하는 단위가 애그리거트 루트인 Order인 것을 알 수 있다.
- Order는 애그리거트에 속한 모든 객체를 포함하고 있으므로 결과적으로 애그리거트 단위로 저장하고 조회한다.
```
public interface OrderRepository {
	Order findByNumber(OrderNumber number);
	void save(Order order);
	void delete(Order order);
}
```
도메인 모델을 사용해야 하는 코드는 리포지터리를 통해서 도메인 객체를 구한 뒤에 도메인 객체의 기능을 실행
public class CancelOrderService { private OrderRepository orderRepository; public void cancel(OrderNumber number) { Order order = orderRepository.findByNumber(number); if (order == null) { throw new OrderNotFoundException(orderId); } order.cancel(); } }
도메인 모델 관점에서 OrderRepository는 도메인 객체를 영속화하는 데 필요한 기능을 추상화 한것으로 고수준 모듈에 속한다.
기반 기술을 이용해서 OrderRepository를 구현한 클래스는 저수준 모듈로 인프라스트럭처 영역에 속한다.
전체 모듈 구조
응용 서비스는 의존 주입과 같은 방식을 사용해서 실제 리포지터리 구현 객체에 접근
응용 서비스와 리포지터리는 밀접한 연관이 있다.
- 응용 서비스는 필요한 도메인 객체를 구하거나 저장할 때 리포지터리를 사용한다.
- 응용 서비스는 트랜잭션을 관리하는데, 트랜잭션 처리는 리포지터리 구현 기술의 영향을 받는다.
리포지터리를 사용하는 주체가 응용 서비스이기 때문에 리포지터리는 응용 서비스가 필요로 하는 메서드를 제공한다.
- 애그리거트를 저장하는 메서드
- 애그리거트 루트 식별자로 애그리거트를 조회하는 메서드

2.5 요청 처리 흐름

표현 영역은 사용자가 전송한 데이터 형식이 올바른지 검사하고 문제가 없다면 데이터를 이용해서 응용 서비스에 기능 실행을 위임
표현 영역은 사용자가 전송한 데이터를 응용 서비스가 요구하는 형식으로 변환해서 전달
요청 처리 흐름
- 웹 브라우저에서 기능 실행 요청
- 표현 영역에 해당하는 컨트롤러는 HTTP 요청 파라미터를 응용 서비스가 필요로 하는 데이터로 변환 해서 응용 서비스의 인자로 전달
- 응용 서비스는 도메인 모델을 이용해서 로직 실행
- 도메인 객체를 리포지터리에서 가져와 실행하거나 신규 도메인 객체를 생성해 리포지터리에 저장
“예매하기”나 “예매 취소”와 같은 기능을 제공하는 응용 서비스는 도메인의 상태를 변경하므로 변경 상태가 물리 저장소에 올바르게 반영되도록 트랜잭션을 관리 해야한다.
- 스프링 프레임워크를 사용한다면 @Transactional 애너테이션을 이용해 트랜잭션을 처리할 수 있다.
```
public class CancelOrderService {
	private OrderRepository orderRepository;
	
	@Transactional
	public void cancel(OrderNumber number) {
		Order order = orderRepository.findByNumber(number);
		if (order == null) {
			throw new NoOrderException(number);
		}
		order.cancel()
	}
}
```

2.6 인프라스트럭처 개요

인프라스트럭처는 표현 영역, 응용 영역, 도메인 영역을 지원한다.
도메인 영역과 응용 영역에서 인프라스트럭처의 기능을 직접 사용하는 것보다 두 영역에서 정의한 인터페이스를 인프라스트럭처 영역에서 구현하는 것이 시스템을 더 유연하고 테스트하기 쉽게 만들어 준다.
무조건 인프라스트럭처에 대한 의존성을 없앨 필요는 없다.
- 스프링을 사용할 경우 응용 서비스는 트랜잭션 처리를 위해 @Transactional을 사용하는 것이 편리하다.
- 영속성 처리를 위해 JPA를 사용할 경우 @Entity나 @Table과 같은 JPA 전용 애너테이션을 도메인 모델 클래스에서 사용하는 것이 XML 매핑 설정을 이용하는 것보다 편리하다.
구현의 편리함은 DIP가 주는 다른 장점만큼 중요하기 때문에 DIP의 장점을 해치지 않는 범위에서 응용 영역과 도메인 영역에서 구현 기술에 대한 의존을 가져가는 것이 나쁘지 않다고 생각한다.
응용 영역과 도메인 영역이 인프라스트럭처에 대한 의존을 완전히 갖지 않도록 시도하는 것은 구현을 더 복잡하고 어렵게 만들 수 있다.
- @Transactional을 사용하면 한 줄로 트랙잭션을 처리할 수 있는데 코드에서 스프링에 대한 의존을 없애려면 복잡한 스프링 설정을 사용해야 한다.
- 의존은 없앴지만 특별히 테스트를 더 쉽게 할 수 있다거나 유연함을 증가시켜 주지 못한다.
- 설정만 복잡해지고 개발 시간만 늘어난다.
표현 영역은 항상 인프라스트럭처 영역과 쌍을 이룬다.
- 스프링 MVC를 사용해서 웹 요청을 처리하려면 스프링이 제공하는 MVC 프레임워크에 맞게 표현 영역을 구현
- Vert.x를 사용해서 Rest API 서버를 구축하려면 Vert.x에 맞게 웹 요청 처리 부분을 구현

2.7 모듈 구성

아키텍처의 각 영역은 별도 패키지에 위치한다.
패키지 구성 규칙에 정답이 존재하는 것은 안지만 영역별로 모듈이 위치할 패키지를 구성할 수 있을 것 이다.
도메인이 크면 하위 도메인으로 나누고 하위 도메인마다 별도 패키지를 구성한다.
도메인 모듈은 도메인에 속한 애그리거트를 기준으로 다시 패키지를 구성한다.
- 카탈로그 하위 도메인이 상품 애그리거트와 카테고리 애그리커트로 구성될 경우 도메인을 두 개의 하위 패키지로 구성할 수 있다.
애그리거트, 모델, 리포지터리는 같은 패키지에 위치시킨다.
- Order, OrderLine, Orderer, OrderRepository 등은 com.myshop.order.domain 패키지에 위치시킨다.
도메인이 복잡하면 도메인 모델과 도메인 서비스를 별도 패키지에 위치시킬 수도 있다.
- com.myshop.order.domain.order: 애그리거트 위치
- com.myshop.order.domain.service: 도메인 서비스 위치
응용 서비스도 도메인 별로 패키지를 구분할 수 있다.
- com.myshop.catalog.application.product
- com.myshop.catalog.application.category
모듈 구조를 얼마나 세분하게해야 하는지에 대한 정해진 규칙은 없다.
한 패키지에 너무 많은 타입이 몰려서 코드를 찾을 때 불편할 정도만 아니면 된다.

2.1 네 개의 영역

“표현”, “응용”, “도메인”, “인프라스트럭처”는 아키텍처를 설계할 때 출현하는 전형적인 네 가지 영역
- 표현 영역
  - 사용자의 요청을 받아 응용 영역에 전달, 응용 영역의 처리 결과를 사용자에게 전달
  - 스프링 MVC 프레임워크가 표현 영역의 기술
- 응용 영역
  - 표현 영역을 통해 사용자의 요청을 전달받은 응용 영역은 시스템이 사용자에게 제공해야할 기능을 구현
  - “주문 등록”, “주문 취소”, “상품 상세 조회” 등의 기능을 예로 들수 있다.
  - 기능을 구현하기 위한 도메인 영역의 도메인 모델을 사용
  - “주문 취소” 기능을 제공하는 응용 서비스를 도메인 모델을 사용해서 기능 구현이 가능
  - public class CancelOrderService { @Transactional public void cancelOrder(String orderId) { Order order = findOrderById(orderId); if (order == null) { throw new OrderNotFoundException(orderId); } order.cancel(); } }
  - 로직을 직접 수행하기보다는 도메인 모델에 로직 수행을 위임
    - “주문 취소” 로직을 직접 구현하지 않고 Order 객체에 취소 처리를 위임 하고 있다
- 도메인 영역
  - Order, OrderLine, ShippingInfo와 같은 도메인 모델
  - 도메인 모델은 핵심 로직을 구현한다.
    - “배송지 변경”, “결제 완료”, “주문 총액 계산”과 같은 핵심 로직을 도메인 모델에 구현한다.
- 인프라스트럭처 영역
  - 구현 기술에 대한 것을 다룬다
  - RDBMS 연동, 메시징 큐에 메시지 전송과 수신, 몽고DB나 레디스의 데이터 연동 처리 등
  - 논리적인 개념을 표현하기보다는 실제 구현을 다룬다
  - 도메인 영역, 응용 영역, 표현 영역은 구현 기술을 사용한 코드를 직접 만들지 않는다.
    - 인프라스트럭처 영역에서 제공하는 기능을 사용해서 필요한 기능을 개발

2.2 계층 구조 아키텍처

네 영역을 구성할 때 많이 사용하는 아키텍처가 그림과 같은 계층 구조이다.
- 표현 영역과 응용 영역은 도메인 영역을 사용
- 도메인 영역은 인프라스트럭처 영역을 사용
도메인의 복잡도에 따라 응용과 도메인을 분리하기도 하고 한 계층으로 합치기도 하지만 전체적인 아키텍처는 계층 구조를 따른다.
계층 구조는 특성상 상위 계층에서 하위 계층으로의 의존만 존재하고 하위 계층은 상위 계층에 의존하지 않는다.
계층 구조를 엄격하게 적용한다면 상위 계층은 바로 아래의 계층에만 의존을 가져야 하지만 구현의 편리함을 위해 계층 구조를 유연하게 적용하기도 한다.
응용 영역과 도메인 영역은 DB나 외부 시스템 연동을 위해 인프라스트럭처의 기능을 사용하므로 계층 구조를 사용하는 것이 직관적으로 이해하기 쉽다.
- 표현, 응용, 도메인 계층이 상세한 구현 기술을 다루는 인프라스트럭처 계층에 종속된다

도메인의 가격 계산 규칙의 예제

할인 금액을 계산하기 위해 Drools라는 룰 엔진을 사용해서 계산 로직을 수행하는 인프라스트럭처 영역의 코드를 만들어 보자

public class DroolsRuleEngine {
	private KieContainer kContainer;

	public DroolsRuleEngine() {
		KieServices ks = KieServices.Factory.get();
		kContainer = ks.getKieClasspathContainer();		
	}

	public void evalute(String sessionName, List<?> facts) {
		KiSession kSession = kContainer.newKieSession(sessionName);
		try {
			facts.forEach(x -> kSession.insert(x));
			kSession.fireAllRules();
		} finaly {
			kSession.dispose();
		}
	}
}

응용 영역은 가격 계산을 위해 인프라스트럭처 영역의 DroolsRuleEngine을 사용

public class CalcuateDiscountService {
	private DroolsRuleEngine ruleEngine;
	
	public CalculateDiscountService() {
		ruleEngine = new DroolsRuleEngine();
	}

	public Money calculateDiscount(List<OrderLine> orderLines, String customerId) {
		Customer customer = findCustomer(customerId);
		
		MutableMoney money = new MutableMoney(0);
		List<?> facts = Arrays.asList(customer, money);
		facts.addAll(orderLines);
		ruleEngine.evalute("discountCalculation", facts);
		return money.toImmutableMoney();
	}
}

CalculateDiscountService가 동작은 하겠지만 두가지 문제를 안고 있다.
- CalculateDiscountService를 테스트하기 어렵다
  - RuleEngine이 완벽하게 동작해야 한다.
  - RuleEngine 클래스와 관련 설정 파일 모두 만든 이후에 CalculateDiscountService 를 확인할 수 있다.
- 구현 방식을 변경하기 어렵다
  - ‘discountCalculation’ 문자열은 Drools의 세션 이름을 의미한다.
  - 세션 이름을 변경하면 CalculateDiscountService 코드도 함께 변경해야 한다.
CalculateDiscountService가 겉으로는 인프라스트럭처의 기술에 직접적인 의존을 하지 않는 것처럼 보여도 실제로는 Drools라는 인프라스트럭처 영역의 기술에 완전하게 의존하고 있다.
인프라스트럭처에 의존하면 ‘테스트 어려움’과 ‘기능 확장 어려움’이라는 두가지 문제가 발생한다.
- 문제 해답은 DIP에 있다.

2.3 DIP

가격 할인 계산을 하려면 고객 정보를 구해야하고, 구한 고객 정보와 주문 정보를 이용해서 룰을 실행해야 한다.
CalculateDiscountService는 고수준 모듈이다.
- 고수준 모듈은 의미 있는 단일 기능을 제공하는 모듈로 ‘가격 할인 계산’이라는 기능을 구현
- 가격 할인 계싼 기능을 구현하려면 고객 정보를 구해야하고 룰을 실행해야 하는데 이 두 기능이 하위 기능이다.
저수준 모듈은 하위 기능을 실제로 구현한 것이다.
- JPA를 이용해서 고객 정보를 읽어오는 모듈과 Drools로 룰을 실행하는 모듈이 저수준 모듈이 된다.

DIP는 저수준 모듈이 고수준 모듈에 의존하도록 바꾼다.

추상화 인터페이스를 사용

public interface RuleDiscounter {
	Money applyRules(Customer customer, List<OrderLine> orderLines);
}

CalculateDiscountService가 RuleDiscounter를 이용하도록 변경
- Drools에 의존하는 코드가 없다

public class CalcuateDiscountService {
	private RuleDiscounter ruleDiscounter;
	
	public CalculateDiscountService(RuleDiscounter ruleDiscounter) {
		this.ruleDiscounter = ruleDiscounter;
	}

	public Money calculateDiscount(List<OrderLine> orderLines, String customerId) {
		Customer customer = findCustomer(customerId);
		return ruleDiscounter.applyRules(customer, orderLines);
	}
}

RuleDiscounter를 상속받아 구현

public class DroolsRuleDiscounter implements RuleDiscounter {
	private KieCountainer kContainer;
	
	public DroolsRuleEngine() {
		KieService ks = KieServices.Factory.get();
		kContainer = ks.getKieClasspathContainer();
	}

	@Override
	public Money applyRules(Customer customer, List<OrderLine> orderLines) {
		KieSession kSession = kContainer.newKieSession("discountSession");
		try {
			...
			kSession.fireAllRules();
		} finally {
			kSession.dispose();
		}
		return money.toImmutableMoney();
	}
}

RuleDiscounter가 출현하면서 바뀐 구조
CalculateDiscountService는 더이상 구현 기술인 Drools에 의존하지 않는다.
- RuleDiscounter 인터페이스에 의존할 뿐
- ‘룰을 이용한 할인 금액 계산’은 고수준 모듈의 개념이므로 RuleDiscounter 인터페이스는 고수준 모듈에 속한다.
- DroolsRuleDiscounter는 고수준의 하위 기능인 RuleDiscounter를 구현한 것이므로 저수준 모듈에 속한다.

DIP를 적용하면 저수준 모듈이 고수준 모듈에 의존하게 된다.
- 고수준 모듈이 저수준 모듈을 사용하려면 고수준 모듈이 저수준 모듈에 의존해야 하는데, 반대로 저수준 모듈이 고수준 모듈에 의존한다고 해서 이를 DIP(Dependency Inversion Principle, 의존 역전 원칙)이라 부른다.
DIP를 적용하면 다른 영역인 인프라스트럭처 영역에 의존할 떄 발생했던 두가지 문제인 구현 교체가 어렵다는 것과 테스트가 어려운 문제를 해소할 수 있다.

고수준 모듈은 더 이상 저수준 모듈에 의존하지 않고 구현을 추상화한 인터페이스에 의존할 수 있다.

구현 기술이 변경되더라도 저수준 구현 객체를 생성하는 코드만 변경하면 된다.

// 기존 코드
RuleDiscounter roleDiscounter = new DroolsRuleDiscounter();
CalculateDiscountService disService = new CalculateDiscountService(roleDiscounter);

// 구현 기술 변경 
RuleDiscounter roleDiscounter = new SimpleRuleDiscounter();
CalculateDiscountService disService = new CalculateDiscountService(roleDiscounter);

스프링과 같은 의존 주입을 지원하는 프레임워크를 사용하면 설정 코드를 수정해서 쉽게 구현체를 변경할 수 있다.
CalculateDiscountService가 제대로 동작하는지 테스트하려면 CustomerRepository와 RuleDiscounter를 구현한 객체가 필요하다.
- CacluateDiscountService가 저수준 모듈에 직접 의존했다면 저수준 모듈이 만들어지기 전까진 테스트를 할 수 없음
- 인터페이스에 의존함으로 대역 객체를 사용해서 테스트를 진행 할수 있다.
- 실제 구현 대신 스텁이나 모의 객체와 같은 테스트 목적의 대역을 사용하여 거의 모든 상황을 테스트할 수 있다.
```
public class CalculateDiscountServiceTest {
	@Test
	public void noCustomer_thenExcetionShouldBeThrown() {
		CustomerRepository stubRepo = mock(CustomerRepository.class);
		when(stubRepo.findById("noCustId")).thenRetrun(null);

		RuleDiscounter stubRule = (cust, lines) -> null;
		
		CalculateDiscountService calDisSvc = new CalculateDiscountService(stbRepo, stubRule);
		assertThrows(NoCustomerException.class, () -> calDisSvc.calculateDiscount(ssomeLines, "noCustId"));
	}
}
```
실제 구현 없이 테스트를 할 수 있는 이유는 DIP를 적용해서 고수준 모듈이 저수준 모듈에 의존하지 않도록 했기 때문이다.

2.3.1 DIP 주의사항

DIP를 잘못 생각하면 단순히 인터페이스와 구현 클래스를 분리하는 정도로 받아드릴 수 있다.
DIP의 핵심은 고수준 모듈이 저수준 모듈의 의존하지 않도록 하기 위함이다.
잘못된 구조
- 도메인 영역은 구현 기술을 다루는 인프라스트럭처 영역에 의존하고 있다.
- 고수준 모듈이 저수준 모듈에 의존하고 있다.
DIP를 적용할 때 하위 기능을 추상화한 인터페이스는 고수준 모듈 관점에서 도출한다.
- CalculateDiscountService는 할인 금액을 구하기 위한 룰 엔진을 사용하는지 직접 연산하는지 중요하지 않다.
- 규칙에 따라 할인 금액을 계산하는 것이 중요
- ‘할인 금액 계산’을 추상화한 인터페이스는 저수준 모듈이 아닌 고수준 모듈에 위치한다.

2.3.2 DIP와 아키텍처

인프라스트럭처 영역은 구현 기술을 다루는 저수준 모듈이고 응용 영역과 도메인 영역은 고수준 모듈이다.
인프라스트럭처 계층이 가장 하단에 위치하는 계층형 구조와 달리 아키텍처에 DIP를 적용하면 인프라스트럭처 영역이 응용 영역와 도메인 영역에 의존하는 구조가 된다.
인프라스트럭처에 위치한 클래스가 도메인이나 응용 영역에 정의한 인터페이스를 상속받아 구현하는 구조가 되므로 도메인과 응용 영역에 대한 영향을 주지 않거나 최소화하면서 구현 기술을 변경하는 것이 가능하다.
주문 시 통지 방식에 SMS를 추가해야 한다는 요구사항이 들어왔을 때 OrderService는 변경할 필요가 없다.
- 두 통지 방식을 함께 제공하는 Notifier 구현 클래스를 인프라스트럭처 영역에 추가하면 된다.
마이바티스 대신 JPA를 구현 기술로 사용하고 싶다면 JPA를 이용한 OrderRepository 구현 클래스를 인프라 스트럭처 영역에 추가하면 된다.

2.4 도메인 영역의 주요 구성요소

도메인 영역을 구성하는 요소요소 설명

엔티티 ENTITY	고유 식별자를 갖는 객체로 자신의 라이프 사이클을 갖는다. Order, Member, Product와 같이 도메인의 고유한 개념을 표현한다. 도메인 모델의 데이터를 포함하며 해당 데이터와 관련된 기능을 함께 제공
밸류 VALUE	고유 식별자를 갖지 않는 객체로 주로 개념적으로 하나의 값을 표현할 때 사용된다. 배송지 주소를 표현하기 위한 Address나 구매한 금액을 위한 Money와 같은 타입이 밸류 타입이다. 엔티티의 속성으로 사용할 뿐만 아니라 다른 밸류 타입의 속성도 사용할 수 있다.
애그리거트 AGGREGATE	애그리거트는 연관된 엔티티와 밸류 객체를 개념적으로 하나로 묶는 것이다. 주문과 관련된 Order 엔티티, OrderLine 밸류, Orderer 밸류 객체를 주문 애그리거트로 묶을 수 있다.
리포지터리 REPOSITORY	도메인 모델의 영속성을 처리한다. DBMS 테이블에서 엔티티 객체를 로딩하거나 저장하는 기능을 제공
도메인 서비스 DOMAIN SERVICE	특정 엔티티에 속하지 않는 도메인 로직을 제공한다. ‘할인 금액 계산’은 상품, 쿠폰, 회원 등급, 구매 금액 등 다양한 조건을 이용해서 구현하게 되는데 이렇게 도메인 로직이 여러 엔티티와 밸류를 필요로 하면 도메인 서비스에 로직을 구현

2.4.1 엔티티와 밸류

엔티티와 도메인 모델의 가장 큰 차이점은 도메인 모델의 엔티티는 데이터와 함께 도메인 기능을 함께 제공한다는 점
- 주문을 표현하는 엔티티는 주문과 관련된 데이터뿐만 아니라 배송지 주소 변경을 위한 기능을 함께 제공
```
public class Order {
	private OrderNo number;
	private Orderer orderer;
	private ShippingInfo shippingInfo;
	
	// 도메인 모델 엔티티는 도메인 기능도 함께 제공
	public void shangeShippingInfo(ShippingInfo newShippingInfo) {
		...	
	}
}
```
도메인 모델의 엔티티는 단순히 데이터를 담고 있는 데이터 구조라기보다는 데이터와 함께 기능을 제공하는 객체
도메인 관점에서 기능을 구현하고 기능 구현을 캡슐화해서 데이터가 임의로 변경되는 것을 막는다.
도메인 모델의 엔티티는 두 개 이상의 데이터가 개념적으로 하나인 경우 밸류 타입을 이용해서 표현할 수 있다
- Orderer는 밸류 타입으로 주문자 이름과 이메일 데이터를 포함할 수 있다.
```
public class Orderer {
	private String name;
	private String email;
}
```
RDBMS와 같은 관계형 데이터베이스는 밸류 타입을 재대로 표현하기 힘들다.
- Ordere의 개별 데이터를 저장하거나 밸로 테이블로 분리해서 저장해야 한다.
- 한 테이블에 주문자 정보 함께 넣기
  - 주문자라는 개념이 들어나지 않고 주문자의 개별 데이터만 드러난다.
- 다른 테이블에 주문자 정보 넣기
  - 주문자 데이터를 별도 테이블에 저장했지만 이것은 테이블의 엔티티에 가까우며 밸류 타입의 의미가 드러나지 않는다.

밸류는 불변으로 구현할 것을 권장

엔티티의 밸류 타입 데이터를 변경할 떄는 객체 자체를 완전히 교체한다는 것을 의미

public class Order {
	private ShippingInfo shippingInfo;
	
	public void shangeShippingInfo(ShippingInfo newShippingInfo) {
		checkShippingInfoChangeable();
		setShippingInfo(newShippingInfo);
	}

	private void setShippingInfo(ShippingInfo newShippingInfo) {
		if (newShippingInfo == null) {
			throw new IllegalArgumentException();
		}
		this.shippingInfo = newShippingInfo;
	}
}

2.4.2 애그리거트

도메인이 커질수록 개발할 도메인 모델도 커지면서 많은 엔티티와 밸류가 출현한다.
도메인 모델이 복잡해지면 개발자가 전체 구조가 아닌 한 개 엔티티와 밸류에만 집중하는 상황이 발생한다.
- 상위 수준에서 모델을 관리하지 않고 개별 요소에만 초점을 맞추다 보면, 큰 수준에서 모델을 이해하지 못해 큰 틀에서 모델은 관리할 수 없는 상황에 빠질 수 있다.
도메인 모델에 전체 구조를 이해하는데 도움이 되는 것이 바로 애그리거트(AGGREGATE)이다.
애그리거트는 관련 객체를 하나로 묶은 군집이다.
- 모메인 개념은“주문”, “배송지 정보”, “주문자”, “주문 목록”, “총 결제 금액”의 하위 모델로 구성된다.
- 하위 내념을 표현한 모델을 하나로 묶어서 “주문”이라는 상위 개념으로 표현할 수 있다.
애그리거트를 사용하면 개별 객체가 아닌 관련 객체를 묶어서 객체 군집 단위로 모델을 바라볼 수 있게 된다.
- 개별 객체 간의 관계가 아닌 애그리거트 간의 관계로 도메인 모델을 이해하고 구현하고, 큰 틀에서 도메인 모델을 관리할 수 있다.
애그리거트는 군집에 속한 객체를 관리하는 루트 엔티티를 갖는다.
- 루트 엔티티는 애그리거트에 속해 있는 엔티티와 밸류 객체를 이용해서 애그리거트가 구현해야 할 기능을 제공
- 애그리거트를 사용하는 코드는 애그리거트 루트가 제공하는 기능을 실행
- 애그리거트 루트를 통해 간접적으로 애그리거트 내의 다른 엔티티나 밸류 객체에 접근
- 애그리거트의 내부 구현을 숨겨서 애그리거트 단위로 구현을 캡슐화할 수 있도록 돕는다.
주문 애그리거트
- 애그리거트 루트인 Order는 주문 도메인 로직에 맞게 애그리거트의 상태를 관리
- Order의 배송지 정보 변경 기능은 배송지를 변경할 수 있는지를 확인한 위에 배송지 정보를 변경
- 주문 애그리거트는 Order를 통하지 않고 ShippingInfo를 변경할 수 있는 방법을 제공하지 않는다.
  - 배송지를 변경하려면 루트 엔티티인 Order를 사용해야 하므로 배소지 정보를 변경할 때는 Order가 구현한 도메인 로직을 항상 따르게 된다.
애그리거트를 구현할 때는 고려할 것이 많다.
- 애그리거트를 어떻게 구성했느냐에 따라 구현이 복잡해지기도 하고
- 트랜잭션 범위가 달라지기도 한다.

2.4.3 리포지터리

도메인 객체를 지속적으로 사용하려면 RDBMS, NoSQL, 로컬 파일과 같은 물리적인 저장소에 도메인 객체를 보관해야 한다.
- 이를 위한 도메인 모델이 리포지터리(Repository)이다.
엔티티나 밸류가 요구사항에 도출되는 도메인 모델이라면 리포리터리는 구현을 위한 도메인 모델이다.
리포지터리는 애그리거트 단위로 도메인 객체를 저장하고 조회하는 기능을 정의
- OrderRepository의 메서드를 보면 대상을 찾고 저장하는 단위가 애그리거트 루트인 Order인 것을 알 수 있다.
- Order는 애그리거트에 속한 모든 객체를 포함하고 있으므로 결과적으로 애그리거트 단위로 저장하고 조회한다.
```
public interface OrderRepository {
	Order findByNumber(OrderNumber number);
	void save(Order order);
	void delete(Order order);
}
```
도메인 모델을 사용해야 하는 코드는 리포지터리를 통해서 도메인 객체를 구한 뒤에 도메인 객체의 기능을 실행
public class CancelOrderService { private OrderRepository orderRepository; public void cancel(OrderNumber number) { Order order = orderRepository.findByNumber(number); if (order == null) { throw new OrderNotFoundException(orderId); } order.cancel(); } }
도메인 모델 관점에서 OrderRepository는 도메인 객체를 영속화하는 데 필요한 기능을 추상화 한것으로 고수준 모듈에 속한다.
기반 기술을 이용해서 OrderRepository를 구현한 클래스는 저수준 모듈로 인프라스트럭처 영역에 속한다.
전체 모듈 구조
응용 서비스는 의존 주입과 같은 방식을 사용해서 실제 리포지터리 구현 객체에 접근
응용 서비스와 리포지터리는 밀접한 연관이 있다.
- 응용 서비스는 필요한 도메인 객체를 구하거나 저장할 때 리포지터리를 사용한다.
- 응용 서비스는 트랜잭션을 관리하는데, 트랜잭션 처리는 리포지터리 구현 기술의 영향을 받는다.
리포지터리를 사용하는 주체가 응용 서비스이기 때문에 리포지터리는 응용 서비스가 필요로 하는 메서드를 제공한다.
- 애그리거트를 저장하는 메서드
- 애그리거트 루트 식별자로 애그리거트를 조회하는 메서드

2.5 요청 처리 흐름

표현 영역은 사용자가 전송한 데이터 형식이 올바른지 검사하고 문제가 없다면 데이터를 이용해서 응용 서비스에 기능 실행을 위임
표현 영역은 사용자가 전송한 데이터를 응용 서비스가 요구하는 형식으로 변환해서 전달
요청 처리 흐름
- 웹 브라우저에서 기능 실행 요청
- 표현 영역에 해당하는 컨트롤러는 HTTP 요청 파라미터를 응용 서비스가 필요로 하는 데이터로 변환 해서 응용 서비스의 인자로 전달
- 응용 서비스는 도메인 모델을 이용해서 로직 실행
- 도메인 객체를 리포지터리에서 가져와 실행하거나 신규 도메인 객체를 생성해 리포지터리에 저장
“예매하기”나 “예매 취소”와 같은 기능을 제공하는 응용 서비스는 도메인의 상태를 변경하므로 변경 상태가 물리 저장소에 올바르게 반영되도록 트랜잭션을 관리 해야한다.
- 스프링 프레임워크를 사용한다면 @Transactional 애너테이션을 이용해 트랜잭션을 처리할 수 있다.
```
public class CancelOrderService {
	private OrderRepository orderRepository;
	
	@Transactional
	public void cancel(OrderNumber number) {
		Order order = orderRepository.findByNumber(number);
		if (order == null) {
			throw new NoOrderException(number);
		}
		order.cancel()
	}
}
```

2.6 인프라스트럭처 개요

인프라스트럭처는 표현 영역, 응용 영역, 도메인 영역을 지원한다.
도메인 영역과 응용 영역에서 인프라스트럭처의 기능을 직접 사용하는 것보다 두 영역에서 정의한 인터페이스를 인프라스트럭처 영역에서 구현하는 것이 시스템을 더 유연하고 테스트하기 쉽게 만들어 준다.
무조건 인프라스트럭처에 대한 의존성을 없앨 필요는 없다.
- 스프링을 사용할 경우 응용 서비스는 트랜잭션 처리를 위해 @Transactional을 사용하는 것이 편리하다.
- 영속성 처리를 위해 JPA를 사용할 경우 @Entity나 @Table과 같은 JPA 전용 애너테이션을 도메인 모델 클래스에서 사용하는 것이 XML 매핑 설정을 이용하는 것보다 편리하다.
구현의 편리함은 DIP가 주는 다른 장점만큼 중요하기 때문에 DIP의 장점을 해치지 않는 범위에서 응용 영역과 도메인 영역에서 구현 기술에 대한 의존을 가져가는 것이 나쁘지 않다고 생각한다.
응용 영역과 도메인 영역이 인프라스트럭처에 대한 의존을 완전히 갖지 않도록 시도하는 것은 구현을 더 복잡하고 어렵게 만들 수 있다.
- @Transactional을 사용하면 한 줄로 트랙잭션을 처리할 수 있는데 코드에서 스프링에 대한 의존을 없애려면 복잡한 스프링 설정을 사용해야 한다.
- 의존은 없앴지만 특별히 테스트를 더 쉽게 할 수 있다거나 유연함을 증가시켜 주지 못한다.
- 설정만 복잡해지고 개발 시간만 늘어난다.
표현 영역은 항상 인프라스트럭처 영역과 쌍을 이룬다.
- 스프링 MVC를 사용해서 웹 요청을 처리하려면 스프링이 제공하는 MVC 프레임워크에 맞게 표현 영역을 구현
- Vert.x를 사용해서 Rest API 서버를 구축하려면 Vert.x에 맞게 웹 요청 처리 부분을 구현

2.7 모듈 구성

아키텍처의 각 영역은 별도 패키지에 위치한다.
패키지 구성 규칙에 정답이 존재하는 것은 안지만 영역별로 모듈이 위치할 패키지를 구성할 수 있을 것 이다.
도메인이 크면 하위 도메인으로 나누고 하위 도메인마다 별도 패키지를 구성한다.
도메인 모듈은 도메인에 속한 애그리거트를 기준으로 다시 패키지를 구성한다.
- 카탈로그 하위 도메인이 상품 애그리거트와 카테고리 애그리커트로 구성될 경우 도메인을 두 개의 하위 패키지로 구성할 수 있다.
애그리거트, 모델, 리포지터리는 같은 패키지에 위치시킨다.
- Order, OrderLine, Orderer, OrderRepository 등은 com.myshop.order.domain 패키지에 위치시킨다.
도메인이 복잡하면 도메인 모델과 도메인 서비스를 별도 패키지에 위치시킬 수도 있다.
- com.myshop.order.domain.order: 애그리거트 위치
- com.myshop.order.domain.service: 도메인 서비스 위치
응용 서비스도 도메인 별로 패키지를 구분할 수 있다.
- com.myshop.catalog.application.product
- com.myshop.catalog.application.category
모듈 구조를 얼마나 세분하게해야 하는지에 대한 정해진 규칙은 없다.
한 패키지에 너무 많은 타입이 몰려서 코드를 찾을 때 불편할 정도만 아니면 된다.

2.1 네 개의 영역

“표현”, “응용”, “도메인”, “인프라스트럭처”는 아키텍처를 설계할 때 출현하는 전형적인 네 가지 영역
- 표현 영역
  - 사용자의 요청을 받아 응용 영역에 전달, 응용 영역의 처리 결과를 사용자에게 전달
  - 스프링 MVC 프레임워크가 표현 영역의 기술
- 응용 영역
  - 표현 영역을 통해 사용자의 요청을 전달받은 응용 영역은 시스템이 사용자에게 제공해야할 기능을 구현
  - “주문 등록”, “주문 취소”, “상품 상세 조회” 등의 기능을 예로 들수 있다.
  - 기능을 구현하기 위한 도메인 영역의 도메인 모델을 사용
  - “주문 취소” 기능을 제공하는 응용 서비스를 도메인 모델을 사용해서 기능 구현이 가능
  - public class CancelOrderService { @Transactional public void cancelOrder(String orderId) { Order order = findOrderById(orderId); if (order == null) { throw new OrderNotFoundException(orderId); } order.cancel(); } }
  - 로직을 직접 수행하기보다는 도메인 모델에 로직 수행을 위임
    - “주문 취소” 로직을 직접 구현하지 않고 Order 객체에 취소 처리를 위임 하고 있다
- 도메인 영역
  - Order, OrderLine, ShippingInfo와 같은 도메인 모델
  - 도메인 모델은 핵심 로직을 구현한다.
    - “배송지 변경”, “결제 완료”, “주문 총액 계산”과 같은 핵심 로직을 도메인 모델에 구현한다.
- 인프라스트럭처 영역
  - 구현 기술에 대한 것을 다룬다
  - RDBMS 연동, 메시징 큐에 메시지 전송과 수신, 몽고DB나 레디스의 데이터 연동 처리 등
  - 논리적인 개념을 표현하기보다는 실제 구현을 다룬다
  - 도메인 영역, 응용 영역, 표현 영역은 구현 기술을 사용한 코드를 직접 만들지 않는다.
    - 인프라스트럭처 영역에서 제공하는 기능을 사용해서 필요한 기능을 개발

2.2 계층 구조 아키텍처

네 영역을 구성할 때 많이 사용하는 아키텍처가 그림과 같은 계층 구조이다.
- 표현 영역과 응용 영역은 도메인 영역을 사용
- 도메인 영역은 인프라스트럭처 영역을 사용
도메인의 복잡도에 따라 응용과 도메인을 분리하기도 하고 한 계층으로 합치기도 하지만 전체적인 아키텍처는 계층 구조를 따른다.
계층 구조는 특성상 상위 계층에서 하위 계층으로의 의존만 존재하고 하위 계층은 상위 계층에 의존하지 않는다.
계층 구조를 엄격하게 적용한다면 상위 계층은 바로 아래의 계층에만 의존을 가져야 하지만 구현의 편리함을 위해 계층 구조를 유연하게 적용하기도 한다.
응용 영역과 도메인 영역은 DB나 외부 시스템 연동을 위해 인프라스트럭처의 기능을 사용하므로 계층 구조를 사용하는 것이 직관적으로 이해하기 쉽다.
- 표현, 응용, 도메인 계층이 상세한 구현 기술을 다루는 인프라스트럭처 계층에 종속된다

도메인의 가격 계산 규칙의 예제

할인 금액을 계산하기 위해 Drools라는 룰 엔진을 사용해서 계산 로직을 수행하는 인프라스트럭처 영역의 코드를 만들어 보자

public class DroolsRuleEngine {
	private KieContainer kContainer;

	public DroolsRuleEngine() {
		KieServices ks = KieServices.Factory.get();
		kContainer = ks.getKieClasspathContainer();		
	}

	public void evalute(String sessionName, List<?> facts) {
		KiSession kSession = kContainer.newKieSession(sessionName);
		try {
			facts.forEach(x -> kSession.insert(x));
			kSession.fireAllRules();
		} finaly {
			kSession.dispose();
		}
	}
}

응용 영역은 가격 계산을 위해 인프라스트럭처 영역의 DroolsRuleEngine을 사용

public class CalcuateDiscountService {
	private DroolsRuleEngine ruleEngine;
	
	public CalculateDiscountService() {
		ruleEngine = new DroolsRuleEngine();
	}

	public Money calculateDiscount(List<OrderLine> orderLines, String customerId) {
		Customer customer = findCustomer(customerId);
		
		MutableMoney money = new MutableMoney(0);
		List<?> facts = Arrays.asList(customer, money);
		facts.addAll(orderLines);
		ruleEngine.evalute("discountCalculation", facts);
		return money.toImmutableMoney();
	}
}

CalculateDiscountService가 동작은 하겠지만 두가지 문제를 안고 있다.
- CalculateDiscountService를 테스트하기 어렵다
  - RuleEngine이 완벽하게 동작해야 한다.
  - RuleEngine 클래스와 관련 설정 파일 모두 만든 이후에 CalculateDiscountService 를 확인할 수 있다.
- 구현 방식을 변경하기 어렵다
  - ‘discountCalculation’ 문자열은 Drools의 세션 이름을 의미한다.
  - 세션 이름을 변경하면 CalculateDiscountService 코드도 함께 변경해야 한다.
CalculateDiscountService가 겉으로는 인프라스트럭처의 기술에 직접적인 의존을 하지 않는 것처럼 보여도 실제로는 Drools라는 인프라스트럭처 영역의 기술에 완전하게 의존하고 있다.
인프라스트럭처에 의존하면 ‘테스트 어려움’과 ‘기능 확장 어려움’이라는 두가지 문제가 발생한다.
- 문제 해답은 DIP에 있다.

2.3 DIP

가격 할인 계산을 하려면 고객 정보를 구해야하고, 구한 고객 정보와 주문 정보를 이용해서 룰을 실행해야 한다.
CalculateDiscountService는 고수준 모듈이다.
- 고수준 모듈은 의미 있는 단일 기능을 제공하는 모듈로 ‘가격 할인 계산’이라는 기능을 구현
- 가격 할인 계싼 기능을 구현하려면 고객 정보를 구해야하고 룰을 실행해야 하는데 이 두 기능이 하위 기능이다.
저수준 모듈은 하위 기능을 실제로 구현한 것이다.
- JPA를 이용해서 고객 정보를 읽어오는 모듈과 Drools로 룰을 실행하는 모듈이 저수준 모듈이 된다.

DIP는 저수준 모듈이 고수준 모듈에 의존하도록 바꾼다.

추상화 인터페이스를 사용

public interface RuleDiscounter {
	Money applyRules(Customer customer, List<OrderLine> orderLines);
}

CalculateDiscountService가 RuleDiscounter를 이용하도록 변경
- Drools에 의존하는 코드가 없다

public class CalcuateDiscountService {
	private RuleDiscounter ruleDiscounter;
	
	public CalculateDiscountService(RuleDiscounter ruleDiscounter) {
		this.ruleDiscounter = ruleDiscounter;
	}

	public Money calculateDiscount(List<OrderLine> orderLines, String customerId) {
		Customer customer = findCustomer(customerId);
		return ruleDiscounter.applyRules(customer, orderLines);
	}
}

RuleDiscounter를 상속받아 구현

public class DroolsRuleDiscounter implements RuleDiscounter {
	private KieCountainer kContainer;
	
	public DroolsRuleEngine() {
		KieService ks = KieServices.Factory.get();
		kContainer = ks.getKieClasspathContainer();
	}

	@Override
	public Money applyRules(Customer customer, List<OrderLine> orderLines) {
		KieSession kSession = kContainer.newKieSession("discountSession");
		try {
			...
			kSession.fireAllRules();
		} finally {
			kSession.dispose();
		}
		return money.toImmutableMoney();
	}
}

RuleDiscounter가 출현하면서 바뀐 구조
CalculateDiscountService는 더이상 구현 기술인 Drools에 의존하지 않는다.
- RuleDiscounter 인터페이스에 의존할 뿐
- ‘룰을 이용한 할인 금액 계산’은 고수준 모듈의 개념이므로 RuleDiscounter 인터페이스는 고수준 모듈에 속한다.
- DroolsRuleDiscounter는 고수준의 하위 기능인 RuleDiscounter를 구현한 것이므로 저수준 모듈에 속한다.

DIP를 적용하면 저수준 모듈이 고수준 모듈에 의존하게 된다.
- 고수준 모듈이 저수준 모듈을 사용하려면 고수준 모듈이 저수준 모듈에 의존해야 하는데, 반대로 저수준 모듈이 고수준 모듈에 의존한다고 해서 이를 DIP(Dependency Inversion Principle, 의존 역전 원칙)이라 부른다.
DIP를 적용하면 다른 영역인 인프라스트럭처 영역에 의존할 떄 발생했던 두가지 문제인 구현 교체가 어렵다는 것과 테스트가 어려운 문제를 해소할 수 있다.

고수준 모듈은 더 이상 저수준 모듈에 의존하지 않고 구현을 추상화한 인터페이스에 의존할 수 있다.

구현 기술이 변경되더라도 저수준 구현 객체를 생성하는 코드만 변경하면 된다.

// 기존 코드
RuleDiscounter roleDiscounter = new DroolsRuleDiscounter();
CalculateDiscountService disService = new CalculateDiscountService(roleDiscounter);

// 구현 기술 변경 
RuleDiscounter roleDiscounter = new SimpleRuleDiscounter();
CalculateDiscountService disService = new CalculateDiscountService(roleDiscounter);

스프링과 같은 의존 주입을 지원하는 프레임워크를 사용하면 설정 코드를 수정해서 쉽게 구현체를 변경할 수 있다.
CalculateDiscountService가 제대로 동작하는지 테스트하려면 CustomerRepository와 RuleDiscounter를 구현한 객체가 필요하다.
- CacluateDiscountService가 저수준 모듈에 직접 의존했다면 저수준 모듈이 만들어지기 전까진 테스트를 할 수 없음
- 인터페이스에 의존함으로 대역 객체를 사용해서 테스트를 진행 할수 있다.
- 실제 구현 대신 스텁이나 모의 객체와 같은 테스트 목적의 대역을 사용하여 거의 모든 상황을 테스트할 수 있다.
```
public class CalculateDiscountServiceTest {
	@Test
	public void noCustomer_thenExcetionShouldBeThrown() {
		CustomerRepository stubRepo = mock(CustomerRepository.class);
		when(stubRepo.findById("noCustId")).thenRetrun(null);

		RuleDiscounter stubRule = (cust, lines) -> null;
		
		CalculateDiscountService calDisSvc = new CalculateDiscountService(stbRepo, stubRule);
		assertThrows(NoCustomerException.class, () -> calDisSvc.calculateDiscount(ssomeLines, "noCustId"));
	}
}
```
실제 구현 없이 테스트를 할 수 있는 이유는 DIP를 적용해서 고수준 모듈이 저수준 모듈에 의존하지 않도록 했기 때문이다.

2.3.1 DIP 주의사항

DIP를 잘못 생각하면 단순히 인터페이스와 구현 클래스를 분리하는 정도로 받아드릴 수 있다.
DIP의 핵심은 고수준 모듈이 저수준 모듈의 의존하지 않도록 하기 위함이다.
잘못된 구조
- 도메인 영역은 구현 기술을 다루는 인프라스트럭처 영역에 의존하고 있다.
- 고수준 모듈이 저수준 모듈에 의존하고 있다.
DIP를 적용할 때 하위 기능을 추상화한 인터페이스는 고수준 모듈 관점에서 도출한다.
- CalculateDiscountService는 할인 금액을 구하기 위한 룰 엔진을 사용하는지 직접 연산하는지 중요하지 않다.
- 규칙에 따라 할인 금액을 계산하는 것이 중요
- ‘할인 금액 계산’을 추상화한 인터페이스는 저수준 모듈이 아닌 고수준 모듈에 위치한다.

2.3.2 DIP와 아키텍처

인프라스트럭처 영역은 구현 기술을 다루는 저수준 모듈이고 응용 영역과 도메인 영역은 고수준 모듈이다.
인프라스트럭처 계층이 가장 하단에 위치하는 계층형 구조와 달리 아키텍처에 DIP를 적용하면 인프라스트럭처 영역이 응용 영역와 도메인 영역에 의존하는 구조가 된다.
인프라스트럭처에 위치한 클래스가 도메인이나 응용 영역에 정의한 인터페이스를 상속받아 구현하는 구조가 되므로 도메인과 응용 영역에 대한 영향을 주지 않거나 최소화하면서 구현 기술을 변경하는 것이 가능하다.
주문 시 통지 방식에 SMS를 추가해야 한다는 요구사항이 들어왔을 때 OrderService는 변경할 필요가 없다.
- 두 통지 방식을 함께 제공하는 Notifier 구현 클래스를 인프라스트럭처 영역에 추가하면 된다.
마이바티스 대신 JPA를 구현 기술로 사용하고 싶다면 JPA를 이용한 OrderRepository 구현 클래스를 인프라 스트럭처 영역에 추가하면 된다.

2.4 도메인 영역의 주요 구성요소

도메인 영역을 구성하는 요소요소 설명

엔티티 ENTITY	고유 식별자를 갖는 객체로 자신의 라이프 사이클을 갖는다. Order, Member, Product와 같이 도메인의 고유한 개념을 표현한다. 도메인 모델의 데이터를 포함하며 해당 데이터와 관련된 기능을 함께 제공
밸류 VALUE	고유 식별자를 갖지 않는 객체로 주로 개념적으로 하나의 값을 표현할 때 사용된다. 배송지 주소를 표현하기 위한 Address나 구매한 금액을 위한 Money와 같은 타입이 밸류 타입이다. 엔티티의 속성으로 사용할 뿐만 아니라 다른 밸류 타입의 속성도 사용할 수 있다.
애그리거트 AGGREGATE	애그리거트는 연관된 엔티티와 밸류 객체를 개념적으로 하나로 묶는 것이다. 주문과 관련된 Order 엔티티, OrderLine 밸류, Orderer 밸류 객체를 주문 애그리거트로 묶을 수 있다.
리포지터리 REPOSITORY	도메인 모델의 영속성을 처리한다. DBMS 테이블에서 엔티티 객체를 로딩하거나 저장하는 기능을 제공
도메인 서비스 DOMAIN SERVICE	특정 엔티티에 속하지 않는 도메인 로직을 제공한다. ‘할인 금액 계산’은 상품, 쿠폰, 회원 등급, 구매 금액 등 다양한 조건을 이용해서 구현하게 되는데 이렇게 도메인 로직이 여러 엔티티와 밸류를 필요로 하면 도메인 서비스에 로직을 구현

2.4.1 엔티티와 밸류

엔티티와 도메인 모델의 가장 큰 차이점은 도메인 모델의 엔티티는 데이터와 함께 도메인 기능을 함께 제공한다는 점
- 주문을 표현하는 엔티티는 주문과 관련된 데이터뿐만 아니라 배송지 주소 변경을 위한 기능을 함께 제공
```
public class Order {
	private OrderNo number;
	private Orderer orderer;
	private ShippingInfo shippingInfo;
	
	// 도메인 모델 엔티티는 도메인 기능도 함께 제공
	public void shangeShippingInfo(ShippingInfo newShippingInfo) {
		...	
	}
}
```
도메인 모델의 엔티티는 단순히 데이터를 담고 있는 데이터 구조라기보다는 데이터와 함께 기능을 제공하는 객체
도메인 관점에서 기능을 구현하고 기능 구현을 캡슐화해서 데이터가 임의로 변경되는 것을 막는다.
도메인 모델의 엔티티는 두 개 이상의 데이터가 개념적으로 하나인 경우 밸류 타입을 이용해서 표현할 수 있다
- Orderer는 밸류 타입으로 주문자 이름과 이메일 데이터를 포함할 수 있다.
```
public class Orderer {
	private String name;
	private String email;
}
```
RDBMS와 같은 관계형 데이터베이스는 밸류 타입을 재대로 표현하기 힘들다.
- Ordere의 개별 데이터를 저장하거나 밸로 테이블로 분리해서 저장해야 한다.
- 한 테이블에 주문자 정보 함께 넣기
  - 주문자라는 개념이 들어나지 않고 주문자의 개별 데이터만 드러난다.
- 다른 테이블에 주문자 정보 넣기
  - 주문자 데이터를 별도 테이블에 저장했지만 이것은 테이블의 엔티티에 가까우며 밸류 타입의 의미가 드러나지 않는다.

밸류는 불변으로 구현할 것을 권장

엔티티의 밸류 타입 데이터를 변경할 떄는 객체 자체를 완전히 교체한다는 것을 의미

public class Order {
	private ShippingInfo shippingInfo;
	
	public void shangeShippingInfo(ShippingInfo newShippingInfo) {
		checkShippingInfoChangeable();
		setShippingInfo(newShippingInfo);
	}

	private void setShippingInfo(ShippingInfo newShippingInfo) {
		if (newShippingInfo == null) {
			throw new IllegalArgumentException();
		}
		this.shippingInfo = newShippingInfo;
	}
}

2.4.2 애그리거트

도메인이 커질수록 개발할 도메인 모델도 커지면서 많은 엔티티와 밸류가 출현한다.
도메인 모델이 복잡해지면 개발자가 전체 구조가 아닌 한 개 엔티티와 밸류에만 집중하는 상황이 발생한다.
- 상위 수준에서 모델을 관리하지 않고 개별 요소에만 초점을 맞추다 보면, 큰 수준에서 모델을 이해하지 못해 큰 틀에서 모델은 관리할 수 없는 상황에 빠질 수 있다.
도메인 모델에 전체 구조를 이해하는데 도움이 되는 것이 바로 애그리거트(AGGREGATE)이다.
애그리거트는 관련 객체를 하나로 묶은 군집이다.
- 모메인 개념은“주문”, “배송지 정보”, “주문자”, “주문 목록”, “총 결제 금액”의 하위 모델로 구성된다.
- 하위 내념을 표현한 모델을 하나로 묶어서 “주문”이라는 상위 개념으로 표현할 수 있다.
애그리거트를 사용하면 개별 객체가 아닌 관련 객체를 묶어서 객체 군집 단위로 모델을 바라볼 수 있게 된다.
- 개별 객체 간의 관계가 아닌 애그리거트 간의 관계로 도메인 모델을 이해하고 구현하고, 큰 틀에서 도메인 모델을 관리할 수 있다.
애그리거트는 군집에 속한 객체를 관리하는 루트 엔티티를 갖는다.
- 루트 엔티티는 애그리거트에 속해 있는 엔티티와 밸류 객체를 이용해서 애그리거트가 구현해야 할 기능을 제공
- 애그리거트를 사용하는 코드는 애그리거트 루트가 제공하는 기능을 실행
- 애그리거트 루트를 통해 간접적으로 애그리거트 내의 다른 엔티티나 밸류 객체에 접근
- 애그리거트의 내부 구현을 숨겨서 애그리거트 단위로 구현을 캡슐화할 수 있도록 돕는다.
주문 애그리거트
- 애그리거트 루트인 Order는 주문 도메인 로직에 맞게 애그리거트의 상태를 관리
- Order의 배송지 정보 변경 기능은 배송지를 변경할 수 있는지를 확인한 위에 배송지 정보를 변경
- 주문 애그리거트는 Order를 통하지 않고 ShippingInfo를 변경할 수 있는 방법을 제공하지 않는다.
  - 배송지를 변경하려면 루트 엔티티인 Order를 사용해야 하므로 배소지 정보를 변경할 때는 Order가 구현한 도메인 로직을 항상 따르게 된다.
애그리거트를 구현할 때는 고려할 것이 많다.
- 애그리거트를 어떻게 구성했느냐에 따라 구현이 복잡해지기도 하고
- 트랜잭션 범위가 달라지기도 한다.

2.4.3 리포지터리

도메인 객체를 지속적으로 사용하려면 RDBMS, NoSQL, 로컬 파일과 같은 물리적인 저장소에 도메인 객체를 보관해야 한다.
- 이를 위한 도메인 모델이 리포지터리(Repository)이다.
엔티티나 밸류가 요구사항에 도출되는 도메인 모델이라면 리포리터리는 구현을 위한 도메인 모델이다.
리포지터리는 애그리거트 단위로 도메인 객체를 저장하고 조회하는 기능을 정의
- OrderRepository의 메서드를 보면 대상을 찾고 저장하는 단위가 애그리거트 루트인 Order인 것을 알 수 있다.
- Order는 애그리거트에 속한 모든 객체를 포함하고 있으므로 결과적으로 애그리거트 단위로 저장하고 조회한다.
```
public interface OrderRepository {
	Order findByNumber(OrderNumber number);
	void save(Order order);
	void delete(Order order);
}
```
도메인 모델을 사용해야 하는 코드는 리포지터리를 통해서 도메인 객체를 구한 뒤에 도메인 객체의 기능을 실행
public class CancelOrderService { private OrderRepository orderRepository; public void cancel(OrderNumber number) { Order order = orderRepository.findByNumber(number); if (order == null) { throw new OrderNotFoundException(orderId); } order.cancel(); } }
도메인 모델 관점에서 OrderRepository는 도메인 객체를 영속화하는 데 필요한 기능을 추상화 한것으로 고수준 모듈에 속한다.
기반 기술을 이용해서 OrderRepository를 구현한 클래스는 저수준 모듈로 인프라스트럭처 영역에 속한다.
전체 모듈 구조
응용 서비스는 의존 주입과 같은 방식을 사용해서 실제 리포지터리 구현 객체에 접근
응용 서비스와 리포지터리는 밀접한 연관이 있다.
- 응용 서비스는 필요한 도메인 객체를 구하거나 저장할 때 리포지터리를 사용한다.
- 응용 서비스는 트랜잭션을 관리하는데, 트랜잭션 처리는 리포지터리 구현 기술의 영향을 받는다.
리포지터리를 사용하는 주체가 응용 서비스이기 때문에 리포지터리는 응용 서비스가 필요로 하는 메서드를 제공한다.
- 애그리거트를 저장하는 메서드
- 애그리거트 루트 식별자로 애그리거트를 조회하는 메서드

2.5 요청 처리 흐름

표현 영역은 사용자가 전송한 데이터 형식이 올바른지 검사하고 문제가 없다면 데이터를 이용해서 응용 서비스에 기능 실행을 위임
표현 영역은 사용자가 전송한 데이터를 응용 서비스가 요구하는 형식으로 변환해서 전달
요청 처리 흐름
- 웹 브라우저에서 기능 실행 요청
- 표현 영역에 해당하는 컨트롤러는 HTTP 요청 파라미터를 응용 서비스가 필요로 하는 데이터로 변환 해서 응용 서비스의 인자로 전달
- 응용 서비스는 도메인 모델을 이용해서 로직 실행
- 도메인 객체를 리포지터리에서 가져와 실행하거나 신규 도메인 객체를 생성해 리포지터리에 저장
“예매하기”나 “예매 취소”와 같은 기능을 제공하는 응용 서비스는 도메인의 상태를 변경하므로 변경 상태가 물리 저장소에 올바르게 반영되도록 트랜잭션을 관리 해야한다.
- 스프링 프레임워크를 사용한다면 @Transactional 애너테이션을 이용해 트랜잭션을 처리할 수 있다.
```
public class CancelOrderService {
	private OrderRepository orderRepository;
	
	@Transactional
	public void cancel(OrderNumber number) {
		Order order = orderRepository.findByNumber(number);
		if (order == null) {
			throw new NoOrderException(number);
		}
		order.cancel()
	}
}
```

2.6 인프라스트럭처 개요

인프라스트럭처는 표현 영역, 응용 영역, 도메인 영역을 지원한다.
도메인 영역과 응용 영역에서 인프라스트럭처의 기능을 직접 사용하는 것보다 두 영역에서 정의한 인터페이스를 인프라스트럭처 영역에서 구현하는 것이 시스템을 더 유연하고 테스트하기 쉽게 만들어 준다.
무조건 인프라스트럭처에 대한 의존성을 없앨 필요는 없다.
- 스프링을 사용할 경우 응용 서비스는 트랜잭션 처리를 위해 @Transactional을 사용하는 것이 편리하다.
- 영속성 처리를 위해 JPA를 사용할 경우 @Entity나 @Table과 같은 JPA 전용 애너테이션을 도메인 모델 클래스에서 사용하는 것이 XML 매핑 설정을 이용하는 것보다 편리하다.
구현의 편리함은 DIP가 주는 다른 장점만큼 중요하기 때문에 DIP의 장점을 해치지 않는 범위에서 응용 영역과 도메인 영역에서 구현 기술에 대한 의존을 가져가는 것이 나쁘지 않다고 생각한다.
응용 영역과 도메인 영역이 인프라스트럭처에 대한 의존을 완전히 갖지 않도록 시도하는 것은 구현을 더 복잡하고 어렵게 만들 수 있다.
- @Transactional을 사용하면 한 줄로 트랙잭션을 처리할 수 있는데 코드에서 스프링에 대한 의존을 없애려면 복잡한 스프링 설정을 사용해야 한다.
- 의존은 없앴지만 특별히 테스트를 더 쉽게 할 수 있다거나 유연함을 증가시켜 주지 못한다.
- 설정만 복잡해지고 개발 시간만 늘어난다.
표현 영역은 항상 인프라스트럭처 영역과 쌍을 이룬다.
- 스프링 MVC를 사용해서 웹 요청을 처리하려면 스프링이 제공하는 MVC 프레임워크에 맞게 표현 영역을 구현
- Vert.x를 사용해서 Rest API 서버를 구축하려면 Vert.x에 맞게 웹 요청 처리 부분을 구현

2.7 모듈 구성

아키텍처의 각 영역은 별도 패키지에 위치한다.
패키지 구성 규칙에 정답이 존재하는 것은 안지만 영역별로 모듈이 위치할 패키지를 구성할 수 있을 것 이다.
도메인이 크면 하위 도메인으로 나누고 하위 도메인마다 별도 패키지를 구성한다.
도메인 모듈은 도메인에 속한 애그리거트를 기준으로 다시 패키지를 구성한다.
- 카탈로그 하위 도메인이 상품 애그리거트와 카테고리 애그리커트로 구성될 경우 도메인을 두 개의 하위 패키지로 구성할 수 있다.
애그리거트, 모델, 리포지터리는 같은 패키지에 위치시킨다.
- Order, OrderLine, Orderer, OrderRepository 등은 com.myshop.order.domain 패키지에 위치시킨다.
도메인이 복잡하면 도메인 모델과 도메인 서비스를 별도 패키지에 위치시킬 수도 있다.
- com.myshop.order.domain.order: 애그리거트 위치
- com.myshop.order.domain.service: 도메인 서비스 위치
응용 서비스도 도메인 별로 패키지를 구분할 수 있다.
- com.myshop.catalog.application.product
- com.myshop.catalog.application.category
모듈 구조를 얼마나 세분하게해야 하는지에 대한 정해진 규칙은 없다.
한 패키지에 너무 많은 타입이 몰려서 코드를 찾을 때 불편할 정도만 아니면 된다.

2.1 네 개의 영역

“표현”, “응용”, “도메인”, “인프라스트럭처”는 아키텍처를 설계할 때 출현하는 전형적인 네 가지 영역
- 표현 영역
  - 사용자의 요청을 받아 응용 영역에 전달, 응용 영역의 처리 결과를 사용자에게 전달
  - 스프링 MVC 프레임워크가 표현 영역의 기술
- 응용 영역
  - 표현 영역을 통해 사용자의 요청을 전달받은 응용 영역은 시스템이 사용자에게 제공해야할 기능을 구현
  - “주문 등록”, “주문 취소”, “상품 상세 조회” 등의 기능을 예로 들수 있다.
  - 기능을 구현하기 위한 도메인 영역의 도메인 모델을 사용
  - “주문 취소” 기능을 제공하는 응용 서비스를 도메인 모델을 사용해서 기능 구현이 가능
  - public class CancelOrderService { @Transactional public void cancelOrder(String orderId) { Order order = findOrderById(orderId); if (order == null) { throw new OrderNotFoundException(orderId); } order.cancel(); } }
  - 로직을 직접 수행하기보다는 도메인 모델에 로직 수행을 위임
    - “주문 취소” 로직을 직접 구현하지 않고 Order 객체에 취소 처리를 위임 하고 있다
- 도메인 영역
  - Order, OrderLine, ShippingInfo와 같은 도메인 모델
  - 도메인 모델은 핵심 로직을 구현한다.
    - “배송지 변경”, “결제 완료”, “주문 총액 계산”과 같은 핵심 로직을 도메인 모델에 구현한다.
- 인프라스트럭처 영역
  - 구현 기술에 대한 것을 다룬다
  - RDBMS 연동, 메시징 큐에 메시지 전송과 수신, 몽고DB나 레디스의 데이터 연동 처리 등
  - 논리적인 개념을 표현하기보다는 실제 구현을 다룬다
  - 도메인 영역, 응용 영역, 표현 영역은 구현 기술을 사용한 코드를 직접 만들지 않는다.
    - 인프라스트럭처 영역에서 제공하는 기능을 사용해서 필요한 기능을 개발

2.2 계층 구조 아키텍처

네 영역을 구성할 때 많이 사용하는 아키텍처가 그림과 같은 계층 구조이다.
- 표현 영역과 응용 영역은 도메인 영역을 사용
- 도메인 영역은 인프라스트럭처 영역을 사용
도메인의 복잡도에 따라 응용과 도메인을 분리하기도 하고 한 계층으로 합치기도 하지만 전체적인 아키텍처는 계층 구조를 따른다.
계층 구조는 특성상 상위 계층에서 하위 계층으로의 의존만 존재하고 하위 계층은 상위 계층에 의존하지 않는다.
계층 구조를 엄격하게 적용한다면 상위 계층은 바로 아래의 계층에만 의존을 가져야 하지만 구현의 편리함을 위해 계층 구조를 유연하게 적용하기도 한다.
응용 영역과 도메인 영역은 DB나 외부 시스템 연동을 위해 인프라스트럭처의 기능을 사용하므로 계층 구조를 사용하는 것이 직관적으로 이해하기 쉽다.
- 표현, 응용, 도메인 계층이 상세한 구현 기술을 다루는 인프라스트럭처 계층에 종속된다

도메인의 가격 계산 규칙의 예제

할인 금액을 계산하기 위해 Drools라는 룰 엔진을 사용해서 계산 로직을 수행하는 인프라스트럭처 영역의 코드를 만들어 보자

public class DroolsRuleEngine {
	private KieContainer kContainer;

	public DroolsRuleEngine() {
		KieServices ks = KieServices.Factory.get();
		kContainer = ks.getKieClasspathContainer();		
	}

	public void evalute(String sessionName, List<?> facts) {
		KiSession kSession = kContainer.newKieSession(sessionName);
		try {
			facts.forEach(x -> kSession.insert(x));
			kSession.fireAllRules();
		} finaly {
			kSession.dispose();
		}
	}
}

응용 영역은 가격 계산을 위해 인프라스트럭처 영역의 DroolsRuleEngine을 사용

public class CalcuateDiscountService {
	private DroolsRuleEngine ruleEngine;
	
	public CalculateDiscountService() {
		ruleEngine = new DroolsRuleEngine();
	}

	public Money calculateDiscount(List<OrderLine> orderLines, String customerId) {
		Customer customer = findCustomer(customerId);
		
		MutableMoney money = new MutableMoney(0);
		List<?> facts = Arrays.asList(customer, money);
		facts.addAll(orderLines);
		ruleEngine.evalute("discountCalculation", facts);
		return money.toImmutableMoney();
	}
}

CalculateDiscountService가 동작은 하겠지만 두가지 문제를 안고 있다.
- CalculateDiscountService를 테스트하기 어렵다
  - RuleEngine이 완벽하게 동작해야 한다.
  - RuleEngine 클래스와 관련 설정 파일 모두 만든 이후에 CalculateDiscountService 를 확인할 수 있다.
- 구현 방식을 변경하기 어렵다
  - ‘discountCalculation’ 문자열은 Drools의 세션 이름을 의미한다.
  - 세션 이름을 변경하면 CalculateDiscountService 코드도 함께 변경해야 한다.
CalculateDiscountService가 겉으로는 인프라스트럭처의 기술에 직접적인 의존을 하지 않는 것처럼 보여도 실제로는 Drools라는 인프라스트럭처 영역의 기술에 완전하게 의존하고 있다.
인프라스트럭처에 의존하면 ‘테스트 어려움’과 ‘기능 확장 어려움’이라는 두가지 문제가 발생한다.
- 문제 해답은 DIP에 있다.

2.3 DIP

가격 할인 계산을 하려면 고객 정보를 구해야하고, 구한 고객 정보와 주문 정보를 이용해서 룰을 실행해야 한다.
CalculateDiscountService는 고수준 모듈이다.
- 고수준 모듈은 의미 있는 단일 기능을 제공하는 모듈로 ‘가격 할인 계산’이라는 기능을 구현
- 가격 할인 계싼 기능을 구현하려면 고객 정보를 구해야하고 룰을 실행해야 하는데 이 두 기능이 하위 기능이다.
저수준 모듈은 하위 기능을 실제로 구현한 것이다.
- JPA를 이용해서 고객 정보를 읽어오는 모듈과 Drools로 룰을 실행하는 모듈이 저수준 모듈이 된다.

DIP는 저수준 모듈이 고수준 모듈에 의존하도록 바꾼다.

추상화 인터페이스를 사용

public interface RuleDiscounter {
	Money applyRules(Customer customer, List<OrderLine> orderLines);
}

CalculateDiscountService가 RuleDiscounter를 이용하도록 변경
- Drools에 의존하는 코드가 없다

public class CalcuateDiscountService {
	private RuleDiscounter ruleDiscounter;
	
	public CalculateDiscountService(RuleDiscounter ruleDiscounter) {
		this.ruleDiscounter = ruleDiscounter;
	}

	public Money calculateDiscount(List<OrderLine> orderLines, String customerId) {
		Customer customer = findCustomer(customerId);
		return ruleDiscounter.applyRules(customer, orderLines);
	}
}

RuleDiscounter를 상속받아 구현

public class DroolsRuleDiscounter implements RuleDiscounter {
	private KieCountainer kContainer;
	
	public DroolsRuleEngine() {
		KieService ks = KieServices.Factory.get();
		kContainer = ks.getKieClasspathContainer();
	}

	@Override
	public Money applyRules(Customer customer, List<OrderLine> orderLines) {
		KieSession kSession = kContainer.newKieSession("discountSession");
		try {
			...
			kSession.fireAllRules();
		} finally {
			kSession.dispose();
		}
		return money.toImmutableMoney();
	}
}

RuleDiscounter가 출현하면서 바뀐 구조
CalculateDiscountService는 더이상 구현 기술인 Drools에 의존하지 않는다.
- RuleDiscounter 인터페이스에 의존할 뿐
- ‘룰을 이용한 할인 금액 계산’은 고수준 모듈의 개념이므로 RuleDiscounter 인터페이스는 고수준 모듈에 속한다.
- DroolsRuleDiscounter는 고수준의 하위 기능인 RuleDiscounter를 구현한 것이므로 저수준 모듈에 속한다.

DIP를 적용하면 저수준 모듈이 고수준 모듈에 의존하게 된다.
- 고수준 모듈이 저수준 모듈을 사용하려면 고수준 모듈이 저수준 모듈에 의존해야 하는데, 반대로 저수준 모듈이 고수준 모듈에 의존한다고 해서 이를 DIP(Dependency Inversion Principle, 의존 역전 원칙)이라 부른다.
DIP를 적용하면 다른 영역인 인프라스트럭처 영역에 의존할 떄 발생했던 두가지 문제인 구현 교체가 어렵다는 것과 테스트가 어려운 문제를 해소할 수 있다.

고수준 모듈은 더 이상 저수준 모듈에 의존하지 않고 구현을 추상화한 인터페이스에 의존할 수 있다.

구현 기술이 변경되더라도 저수준 구현 객체를 생성하는 코드만 변경하면 된다.

// 기존 코드
RuleDiscounter roleDiscounter = new DroolsRuleDiscounter();
CalculateDiscountService disService = new CalculateDiscountService(roleDiscounter);

// 구현 기술 변경 
RuleDiscounter roleDiscounter = new SimpleRuleDiscounter();
CalculateDiscountService disService = new CalculateDiscountService(roleDiscounter);

스프링과 같은 의존 주입을 지원하는 프레임워크를 사용하면 설정 코드를 수정해서 쉽게 구현체를 변경할 수 있다.
CalculateDiscountService가 제대로 동작하는지 테스트하려면 CustomerRepository와 RuleDiscounter를 구현한 객체가 필요하다.
- CacluateDiscountService가 저수준 모듈에 직접 의존했다면 저수준 모듈이 만들어지기 전까진 테스트를 할 수 없음
- 인터페이스에 의존함으로 대역 객체를 사용해서 테스트를 진행 할수 있다.
- 실제 구현 대신 스텁이나 모의 객체와 같은 테스트 목적의 대역을 사용하여 거의 모든 상황을 테스트할 수 있다.
```
public class CalculateDiscountServiceTest {
	@Test
	public void noCustomer_thenExcetionShouldBeThrown() {
		CustomerRepository stubRepo = mock(CustomerRepository.class);
		when(stubRepo.findById("noCustId")).thenRetrun(null);

		RuleDiscounter stubRule = (cust, lines) -> null;
		
		CalculateDiscountService calDisSvc = new CalculateDiscountService(stbRepo, stubRule);
		assertThrows(NoCustomerException.class, () -> calDisSvc.calculateDiscount(ssomeLines, "noCustId"));
	}
}
```
실제 구현 없이 테스트를 할 수 있는 이유는 DIP를 적용해서 고수준 모듈이 저수준 모듈에 의존하지 않도록 했기 때문이다.

2.3.1 DIP 주의사항

DIP를 잘못 생각하면 단순히 인터페이스와 구현 클래스를 분리하는 정도로 받아드릴 수 있다.
DIP의 핵심은 고수준 모듈이 저수준 모듈의 의존하지 않도록 하기 위함이다.
잘못된 구조
- 도메인 영역은 구현 기술을 다루는 인프라스트럭처 영역에 의존하고 있다.
- 고수준 모듈이 저수준 모듈에 의존하고 있다.
DIP를 적용할 때 하위 기능을 추상화한 인터페이스는 고수준 모듈 관점에서 도출한다.
- CalculateDiscountService는 할인 금액을 구하기 위한 룰 엔진을 사용하는지 직접 연산하는지 중요하지 않다.
- 규칙에 따라 할인 금액을 계산하는 것이 중요
- ‘할인 금액 계산’을 추상화한 인터페이스는 저수준 모듈이 아닌 고수준 모듈에 위치한다.

2.3.2 DIP와 아키텍처

인프라스트럭처 영역은 구현 기술을 다루는 저수준 모듈이고 응용 영역과 도메인 영역은 고수준 모듈이다.
인프라스트럭처 계층이 가장 하단에 위치하는 계층형 구조와 달리 아키텍처에 DIP를 적용하면 인프라스트럭처 영역이 응용 영역와 도메인 영역에 의존하는 구조가 된다.
인프라스트럭처에 위치한 클래스가 도메인이나 응용 영역에 정의한 인터페이스를 상속받아 구현하는 구조가 되므로 도메인과 응용 영역에 대한 영향을 주지 않거나 최소화하면서 구현 기술을 변경하는 것이 가능하다.
주문 시 통지 방식에 SMS를 추가해야 한다는 요구사항이 들어왔을 때 OrderService는 변경할 필요가 없다.
- 두 통지 방식을 함께 제공하는 Notifier 구현 클래스를 인프라스트럭처 영역에 추가하면 된다.
마이바티스 대신 JPA를 구현 기술로 사용하고 싶다면 JPA를 이용한 OrderRepository 구현 클래스를 인프라 스트럭처 영역에 추가하면 된다.

2.4 도메인 영역의 주요 구성요소

도메인 영역을 구성하는 요소요소 설명

엔티티 ENTITY	고유 식별자를 갖는 객체로 자신의 라이프 사이클을 갖는다. Order, Member, Product와 같이 도메인의 고유한 개념을 표현한다. 도메인 모델의 데이터를 포함하며 해당 데이터와 관련된 기능을 함께 제공
밸류 VALUE	고유 식별자를 갖지 않는 객체로 주로 개념적으로 하나의 값을 표현할 때 사용된다. 배송지 주소를 표현하기 위한 Address나 구매한 금액을 위한 Money와 같은 타입이 밸류 타입이다. 엔티티의 속성으로 사용할 뿐만 아니라 다른 밸류 타입의 속성도 사용할 수 있다.
애그리거트 AGGREGATE	애그리거트는 연관된 엔티티와 밸류 객체를 개념적으로 하나로 묶는 것이다. 주문과 관련된 Order 엔티티, OrderLine 밸류, Orderer 밸류 객체를 주문 애그리거트로 묶을 수 있다.
리포지터리 REPOSITORY	도메인 모델의 영속성을 처리한다. DBMS 테이블에서 엔티티 객체를 로딩하거나 저장하는 기능을 제공
도메인 서비스 DOMAIN SERVICE	특정 엔티티에 속하지 않는 도메인 로직을 제공한다. ‘할인 금액 계산’은 상품, 쿠폰, 회원 등급, 구매 금액 등 다양한 조건을 이용해서 구현하게 되는데 이렇게 도메인 로직이 여러 엔티티와 밸류를 필요로 하면 도메인 서비스에 로직을 구현

2.4.1 엔티티와 밸류

엔티티와 도메인 모델의 가장 큰 차이점은 도메인 모델의 엔티티는 데이터와 함께 도메인 기능을 함께 제공한다는 점
- 주문을 표현하는 엔티티는 주문과 관련된 데이터뿐만 아니라 배송지 주소 변경을 위한 기능을 함께 제공
```
public class Order {
	private OrderNo number;
	private Orderer orderer;
	private ShippingInfo shippingInfo;
	
	// 도메인 모델 엔티티는 도메인 기능도 함께 제공
	public void shangeShippingInfo(ShippingInfo newShippingInfo) {
		...	
	}
}
```
도메인 모델의 엔티티는 단순히 데이터를 담고 있는 데이터 구조라기보다는 데이터와 함께 기능을 제공하는 객체
도메인 관점에서 기능을 구현하고 기능 구현을 캡슐화해서 데이터가 임의로 변경되는 것을 막는다.
도메인 모델의 엔티티는 두 개 이상의 데이터가 개념적으로 하나인 경우 밸류 타입을 이용해서 표현할 수 있다
- Orderer는 밸류 타입으로 주문자 이름과 이메일 데이터를 포함할 수 있다.
```
public class Orderer {
	private String name;
	private String email;
}
```
RDBMS와 같은 관계형 데이터베이스는 밸류 타입을 재대로 표현하기 힘들다.
- Ordere의 개별 데이터를 저장하거나 밸로 테이블로 분리해서 저장해야 한다.
- 한 테이블에 주문자 정보 함께 넣기
  - 주문자라는 개념이 들어나지 않고 주문자의 개별 데이터만 드러난다.
- 다른 테이블에 주문자 정보 넣기
  - 주문자 데이터를 별도 테이블에 저장했지만 이것은 테이블의 엔티티에 가까우며 밸류 타입의 의미가 드러나지 않는다.

밸류는 불변으로 구현할 것을 권장

엔티티의 밸류 타입 데이터를 변경할 떄는 객체 자체를 완전히 교체한다는 것을 의미

public class Order {
	private ShippingInfo shippingInfo;
	
	public void shangeShippingInfo(ShippingInfo newShippingInfo) {
		checkShippingInfoChangeable();
		setShippingInfo(newShippingInfo);
	}

	private void setShippingInfo(ShippingInfo newShippingInfo) {
		if (newShippingInfo == null) {
			throw new IllegalArgumentException();
		}
		this.shippingInfo = newShippingInfo;
	}
}

2.4.2 애그리거트

도메인이 커질수록 개발할 도메인 모델도 커지면서 많은 엔티티와 밸류가 출현한다.
도메인 모델이 복잡해지면 개발자가 전체 구조가 아닌 한 개 엔티티와 밸류에만 집중하는 상황이 발생한다.
- 상위 수준에서 모델을 관리하지 않고 개별 요소에만 초점을 맞추다 보면, 큰 수준에서 모델을 이해하지 못해 큰 틀에서 모델은 관리할 수 없는 상황에 빠질 수 있다.
도메인 모델에 전체 구조를 이해하는데 도움이 되는 것이 바로 애그리거트(AGGREGATE)이다.
애그리거트는 관련 객체를 하나로 묶은 군집이다.
- 모메인 개념은“주문”, “배송지 정보”, “주문자”, “주문 목록”, “총 결제 금액”의 하위 모델로 구성된다.
- 하위 내념을 표현한 모델을 하나로 묶어서 “주문”이라는 상위 개념으로 표현할 수 있다.
애그리거트를 사용하면 개별 객체가 아닌 관련 객체를 묶어서 객체 군집 단위로 모델을 바라볼 수 있게 된다.
- 개별 객체 간의 관계가 아닌 애그리거트 간의 관계로 도메인 모델을 이해하고 구현하고, 큰 틀에서 도메인 모델을 관리할 수 있다.
애그리거트는 군집에 속한 객체를 관리하는 루트 엔티티를 갖는다.
- 루트 엔티티는 애그리거트에 속해 있는 엔티티와 밸류 객체를 이용해서 애그리거트가 구현해야 할 기능을 제공
- 애그리거트를 사용하는 코드는 애그리거트 루트가 제공하는 기능을 실행
- 애그리거트 루트를 통해 간접적으로 애그리거트 내의 다른 엔티티나 밸류 객체에 접근
- 애그리거트의 내부 구현을 숨겨서 애그리거트 단위로 구현을 캡슐화할 수 있도록 돕는다.
주문 애그리거트
- 애그리거트 루트인 Order는 주문 도메인 로직에 맞게 애그리거트의 상태를 관리
- Order의 배송지 정보 변경 기능은 배송지를 변경할 수 있는지를 확인한 위에 배송지 정보를 변경
- 주문 애그리거트는 Order를 통하지 않고 ShippingInfo를 변경할 수 있는 방법을 제공하지 않는다.
  - 배송지를 변경하려면 루트 엔티티인 Order를 사용해야 하므로 배소지 정보를 변경할 때는 Order가 구현한 도메인 로직을 항상 따르게 된다.
애그리거트를 구현할 때는 고려할 것이 많다.
- 애그리거트를 어떻게 구성했느냐에 따라 구현이 복잡해지기도 하고
- 트랜잭션 범위가 달라지기도 한다.

2.4.3 리포지터리

도메인 객체를 지속적으로 사용하려면 RDBMS, NoSQL, 로컬 파일과 같은 물리적인 저장소에 도메인 객체를 보관해야 한다.
- 이를 위한 도메인 모델이 리포지터리(Repository)이다.
엔티티나 밸류가 요구사항에 도출되는 도메인 모델이라면 리포리터리는 구현을 위한 도메인 모델이다.
리포지터리는 애그리거트 단위로 도메인 객체를 저장하고 조회하는 기능을 정의
- OrderRepository의 메서드를 보면 대상을 찾고 저장하는 단위가 애그리거트 루트인 Order인 것을 알 수 있다.
- Order는 애그리거트에 속한 모든 객체를 포함하고 있으므로 결과적으로 애그리거트 단위로 저장하고 조회한다.
```
public interface OrderRepository {
	Order findByNumber(OrderNumber number);
	void save(Order order);
	void delete(Order order);
}
```
도메인 모델을 사용해야 하는 코드는 리포지터리를 통해서 도메인 객체를 구한 뒤에 도메인 객체의 기능을 실행
public class CancelOrderService { private OrderRepository orderRepository; public void cancel(OrderNumber number) { Order order = orderRepository.findByNumber(number); if (order == null) { throw new OrderNotFoundException(orderId); } order.cancel(); } }
도메인 모델 관점에서 OrderRepository는 도메인 객체를 영속화하는 데 필요한 기능을 추상화 한것으로 고수준 모듈에 속한다.
기반 기술을 이용해서 OrderRepository를 구현한 클래스는 저수준 모듈로 인프라스트럭처 영역에 속한다.
전체 모듈 구조
응용 서비스는 의존 주입과 같은 방식을 사용해서 실제 리포지터리 구현 객체에 접근
응용 서비스와 리포지터리는 밀접한 연관이 있다.
- 응용 서비스는 필요한 도메인 객체를 구하거나 저장할 때 리포지터리를 사용한다.
- 응용 서비스는 트랜잭션을 관리하는데, 트랜잭션 처리는 리포지터리 구현 기술의 영향을 받는다.
리포지터리를 사용하는 주체가 응용 서비스이기 때문에 리포지터리는 응용 서비스가 필요로 하는 메서드를 제공한다.
- 애그리거트를 저장하는 메서드
- 애그리거트 루트 식별자로 애그리거트를 조회하는 메서드

2.5 요청 처리 흐름

표현 영역은 사용자가 전송한 데이터 형식이 올바른지 검사하고 문제가 없다면 데이터를 이용해서 응용 서비스에 기능 실행을 위임
표현 영역은 사용자가 전송한 데이터를 응용 서비스가 요구하는 형식으로 변환해서 전달
요청 처리 흐름
- 웹 브라우저에서 기능 실행 요청
- 표현 영역에 해당하는 컨트롤러는 HTTP 요청 파라미터를 응용 서비스가 필요로 하는 데이터로 변환 해서 응용 서비스의 인자로 전달
- 응용 서비스는 도메인 모델을 이용해서 로직 실행
- 도메인 객체를 리포지터리에서 가져와 실행하거나 신규 도메인 객체를 생성해 리포지터리에 저장
“예매하기”나 “예매 취소”와 같은 기능을 제공하는 응용 서비스는 도메인의 상태를 변경하므로 변경 상태가 물리 저장소에 올바르게 반영되도록 트랜잭션을 관리 해야한다.
- 스프링 프레임워크를 사용한다면 @Transactional 애너테이션을 이용해 트랜잭션을 처리할 수 있다.
```
public class CancelOrderService {
	private OrderRepository orderRepository;
	
	@Transactional
	public void cancel(OrderNumber number) {
		Order order = orderRepository.findByNumber(number);
		if (order == null) {
			throw new NoOrderException(number);
		}
		order.cancel()
	}
}
```

2.6 인프라스트럭처 개요

인프라스트럭처는 표현 영역, 응용 영역, 도메인 영역을 지원한다.
도메인 영역과 응용 영역에서 인프라스트럭처의 기능을 직접 사용하는 것보다 두 영역에서 정의한 인터페이스를 인프라스트럭처 영역에서 구현하는 것이 시스템을 더 유연하고 테스트하기 쉽게 만들어 준다.
무조건 인프라스트럭처에 대한 의존성을 없앨 필요는 없다.
- 스프링을 사용할 경우 응용 서비스는 트랜잭션 처리를 위해 @Transactional을 사용하는 것이 편리하다.
- 영속성 처리를 위해 JPA를 사용할 경우 @Entity나 @Table과 같은 JPA 전용 애너테이션을 도메인 모델 클래스에서 사용하는 것이 XML 매핑 설정을 이용하는 것보다 편리하다.
구현의 편리함은 DIP가 주는 다른 장점만큼 중요하기 때문에 DIP의 장점을 해치지 않는 범위에서 응용 영역과 도메인 영역에서 구현 기술에 대한 의존을 가져가는 것이 나쁘지 않다고 생각한다.
응용 영역과 도메인 영역이 인프라스트럭처에 대한 의존을 완전히 갖지 않도록 시도하는 것은 구현을 더 복잡하고 어렵게 만들 수 있다.
- @Transactional을 사용하면 한 줄로 트랙잭션을 처리할 수 있는데 코드에서 스프링에 대한 의존을 없애려면 복잡한 스프링 설정을 사용해야 한다.
- 의존은 없앴지만 특별히 테스트를 더 쉽게 할 수 있다거나 유연함을 증가시켜 주지 못한다.
- 설정만 복잡해지고 개발 시간만 늘어난다.
표현 영역은 항상 인프라스트럭처 영역과 쌍을 이룬다.
- 스프링 MVC를 사용해서 웹 요청을 처리하려면 스프링이 제공하는 MVC 프레임워크에 맞게 표현 영역을 구현
- Vert.x를 사용해서 Rest API 서버를 구축하려면 Vert.x에 맞게 웹 요청 처리 부분을 구현

2.7 모듈 구성

아키텍처의 각 영역은 별도 패키지에 위치한다.
패키지 구성 규칙에 정답이 존재하는 것은 안지만 영역별로 모듈이 위치할 패키지를 구성할 수 있을 것 이다.
도메인이 크면 하위 도메인으로 나누고 하위 도메인마다 별도 패키지를 구성한다.
도메인 모듈은 도메인에 속한 애그리거트를 기준으로 다시 패키지를 구성한다.
- 카탈로그 하위 도메인이 상품 애그리거트와 카테고리 애그리커트로 구성될 경우 도메인을 두 개의 하위 패키지로 구성할 수 있다.
애그리거트, 모델, 리포지터리는 같은 패키지에 위치시킨다.
- Order, OrderLine, Orderer, OrderRepository 등은 com.myshop.order.domain 패키지에 위치시킨다.
도메인이 복잡하면 도메인 모델과 도메인 서비스를 별도 패키지에 위치시킬 수도 있다.
- com.myshop.order.domain.order: 애그리거트 위치
- com.myshop.order.domain.service: 도메인 서비스 위치
응용 서비스도 도메인 별로 패키지를 구분할 수 있다.
- com.myshop.catalog.application.product
- com.myshop.catalog.application.category
모듈 구조를 얼마나 세분하게해야 하는지에 대한 정해진 규칙은 없다.
한 패키지에 너무 많은 타입이 몰려서 코드를 찾을 때 불편할 정도만 아니면 된다.

2.1 네 개의 영역

“표현”, “응용”, “도메인”, “인프라스트럭처”는 아키텍처를 설계할 때 출현하는 전형적인 네 가지 영역
- 표현 영역
  - 사용자의 요청을 받아 응용 영역에 전달, 응용 영역의 처리 결과를 사용자에게 전달
  - 스프링 MVC 프레임워크가 표현 영역의 기술
- 응용 영역
  - 표현 영역을 통해 사용자의 요청을 전달받은 응용 영역은 시스템이 사용자에게 제공해야할 기능을 구현
  - “주문 등록”, “주문 취소”, “상품 상세 조회” 등의 기능을 예로 들수 있다.
  - 기능을 구현하기 위한 도메인 영역의 도메인 모델을 사용
  - “주문 취소” 기능을 제공하는 응용 서비스를 도메인 모델을 사용해서 기능 구현이 가능
  - public class CancelOrderService { @Transactional public void cancelOrder(String orderId) { Order order = findOrderById(orderId); if (order == null) { throw new OrderNotFoundException(orderId); } order.cancel(); } }
  - 로직을 직접 수행하기보다는 도메인 모델에 로직 수행을 위임
    - “주문 취소” 로직을 직접 구현하지 않고 Order 객체에 취소 처리를 위임 하고 있다
- 도메인 영역
  - Order, OrderLine, ShippingInfo와 같은 도메인 모델
  - 도메인 모델은 핵심 로직을 구현한다.
    - “배송지 변경”, “결제 완료”, “주문 총액 계산”과 같은 핵심 로직을 도메인 모델에 구현한다.
- 인프라스트럭처 영역
  - 구현 기술에 대한 것을 다룬다
  - RDBMS 연동, 메시징 큐에 메시지 전송과 수신, 몽고DB나 레디스의 데이터 연동 처리 등
  - 논리적인 개념을 표현하기보다는 실제 구현을 다룬다
  - 도메인 영역, 응용 영역, 표현 영역은 구현 기술을 사용한 코드를 직접 만들지 않는다.
    - 인프라스트럭처 영역에서 제공하는 기능을 사용해서 필요한 기능을 개발

2.2 계층 구조 아키텍처

네 영역을 구성할 때 많이 사용하는 아키텍처가 그림과 같은 계층 구조이다.
- 표현 영역과 응용 영역은 도메인 영역을 사용
- 도메인 영역은 인프라스트럭처 영역을 사용
도메인의 복잡도에 따라 응용과 도메인을 분리하기도 하고 한 계층으로 합치기도 하지만 전체적인 아키텍처는 계층 구조를 따른다.
계층 구조는 특성상 상위 계층에서 하위 계층으로의 의존만 존재하고 하위 계층은 상위 계층에 의존하지 않는다.
계층 구조를 엄격하게 적용한다면 상위 계층은 바로 아래의 계층에만 의존을 가져야 하지만 구현의 편리함을 위해 계층 구조를 유연하게 적용하기도 한다.
응용 영역과 도메인 영역은 DB나 외부 시스템 연동을 위해 인프라스트럭처의 기능을 사용하므로 계층 구조를 사용하는 것이 직관적으로 이해하기 쉽다.
- 표현, 응용, 도메인 계층이 상세한 구현 기술을 다루는 인프라스트럭처 계층에 종속된다

도메인의 가격 계산 규칙의 예제

할인 금액을 계산하기 위해 Drools라는 룰 엔진을 사용해서 계산 로직을 수행하는 인프라스트럭처 영역의 코드를 만들어 보자

public class DroolsRuleEngine {
	private KieContainer kContainer;

	public DroolsRuleEngine() {
		KieServices ks = KieServices.Factory.get();
		kContainer = ks.getKieClasspathContainer();		
	}

	public void evalute(String sessionName, List<?> facts) {
		KiSession kSession = kContainer.newKieSession(sessionName);
		try {
			facts.forEach(x -> kSession.insert(x));
			kSession.fireAllRules();
		} finaly {
			kSession.dispose();
		}
	}
}

응용 영역은 가격 계산을 위해 인프라스트럭처 영역의 DroolsRuleEngine을 사용

public class CalcuateDiscountService {
	private DroolsRuleEngine ruleEngine;
	
	public CalculateDiscountService() {
		ruleEngine = new DroolsRuleEngine();
	}

	public Money calculateDiscount(List<OrderLine> orderLines, String customerId) {
		Customer customer = findCustomer(customerId);
		
		MutableMoney money = new MutableMoney(0);
		List<?> facts = Arrays.asList(customer, money);
		facts.addAll(orderLines);
		ruleEngine.evalute("discountCalculation", facts);
		return money.toImmutableMoney();
	}
}

CalculateDiscountService가 동작은 하겠지만 두가지 문제를 안고 있다.
- CalculateDiscountService를 테스트하기 어렵다
  - RuleEngine이 완벽하게 동작해야 한다.
  - RuleEngine 클래스와 관련 설정 파일 모두 만든 이후에 CalculateDiscountService 를 확인할 수 있다.
- 구현 방식을 변경하기 어렵다
  - ‘discountCalculation’ 문자열은 Drools의 세션 이름을 의미한다.
  - 세션 이름을 변경하면 CalculateDiscountService 코드도 함께 변경해야 한다.
CalculateDiscountService가 겉으로는 인프라스트럭처의 기술에 직접적인 의존을 하지 않는 것처럼 보여도 실제로는 Drools라는 인프라스트럭처 영역의 기술에 완전하게 의존하고 있다.
인프라스트럭처에 의존하면 ‘테스트 어려움’과 ‘기능 확장 어려움’이라는 두가지 문제가 발생한다.
- 문제 해답은 DIP에 있다.

2.3 DIP

가격 할인 계산을 하려면 고객 정보를 구해야하고, 구한 고객 정보와 주문 정보를 이용해서 룰을 실행해야 한다.
CalculateDiscountService는 고수준 모듈이다.
- 고수준 모듈은 의미 있는 단일 기능을 제공하는 모듈로 ‘가격 할인 계산’이라는 기능을 구현
- 가격 할인 계싼 기능을 구현하려면 고객 정보를 구해야하고 룰을 실행해야 하는데 이 두 기능이 하위 기능이다.
저수준 모듈은 하위 기능을 실제로 구현한 것이다.
- JPA를 이용해서 고객 정보를 읽어오는 모듈과 Drools로 룰을 실행하는 모듈이 저수준 모듈이 된다.

DIP는 저수준 모듈이 고수준 모듈에 의존하도록 바꾼다.

추상화 인터페이스를 사용

public interface RuleDiscounter {
	Money applyRules(Customer customer, List<OrderLine> orderLines);
}

CalculateDiscountService가 RuleDiscounter를 이용하도록 변경
- Drools에 의존하는 코드가 없다

public class CalcuateDiscountService {
	private RuleDiscounter ruleDiscounter;
	
	public CalculateDiscountService(RuleDiscounter ruleDiscounter) {
		this.ruleDiscounter = ruleDiscounter;
	}

	public Money calculateDiscount(List<OrderLine> orderLines, String customerId) {
		Customer customer = findCustomer(customerId);
		return ruleDiscounter.applyRules(customer, orderLines);
	}
}

RuleDiscounter를 상속받아 구현

public class DroolsRuleDiscounter implements RuleDiscounter {
	private KieCountainer kContainer;
	
	public DroolsRuleEngine() {
		KieService ks = KieServices.Factory.get();
		kContainer = ks.getKieClasspathContainer();
	}

	@Override
	public Money applyRules(Customer customer, List<OrderLine> orderLines) {
		KieSession kSession = kContainer.newKieSession("discountSession");
		try {
			...
			kSession.fireAllRules();
		} finally {
			kSession.dispose();
		}
		return money.toImmutableMoney();
	}
}

RuleDiscounter가 출현하면서 바뀐 구조
CalculateDiscountService는 더이상 구현 기술인 Drools에 의존하지 않는다.
- RuleDiscounter 인터페이스에 의존할 뿐
- ‘룰을 이용한 할인 금액 계산’은 고수준 모듈의 개념이므로 RuleDiscounter 인터페이스는 고수준 모듈에 속한다.
- DroolsRuleDiscounter는 고수준의 하위 기능인 RuleDiscounter를 구현한 것이므로 저수준 모듈에 속한다.

DIP를 적용하면 저수준 모듈이 고수준 모듈에 의존하게 된다.
- 고수준 모듈이 저수준 모듈을 사용하려면 고수준 모듈이 저수준 모듈에 의존해야 하는데, 반대로 저수준 모듈이 고수준 모듈에 의존한다고 해서 이를 DIP(Dependency Inversion Principle, 의존 역전 원칙)이라 부른다.
DIP를 적용하면 다른 영역인 인프라스트럭처 영역에 의존할 떄 발생했던 두가지 문제인 구현 교체가 어렵다는 것과 테스트가 어려운 문제를 해소할 수 있다.

고수준 모듈은 더 이상 저수준 모듈에 의존하지 않고 구현을 추상화한 인터페이스에 의존할 수 있다.

구현 기술이 변경되더라도 저수준 구현 객체를 생성하는 코드만 변경하면 된다.

// 기존 코드
RuleDiscounter roleDiscounter = new DroolsRuleDiscounter();
CalculateDiscountService disService = new CalculateDiscountService(roleDiscounter);

// 구현 기술 변경 
RuleDiscounter roleDiscounter = new SimpleRuleDiscounter();
CalculateDiscountService disService = new CalculateDiscountService(roleDiscounter);

스프링과 같은 의존 주입을 지원하는 프레임워크를 사용하면 설정 코드를 수정해서 쉽게 구현체를 변경할 수 있다.
CalculateDiscountService가 제대로 동작하는지 테스트하려면 CustomerRepository와 RuleDiscounter를 구현한 객체가 필요하다.
- CacluateDiscountService가 저수준 모듈에 직접 의존했다면 저수준 모듈이 만들어지기 전까진 테스트를 할 수 없음
- 인터페이스에 의존함으로 대역 객체를 사용해서 테스트를 진행 할수 있다.
- 실제 구현 대신 스텁이나 모의 객체와 같은 테스트 목적의 대역을 사용하여 거의 모든 상황을 테스트할 수 있다.
```
public class CalculateDiscountServiceTest {
	@Test
	public void noCustomer_thenExcetionShouldBeThrown() {
		CustomerRepository stubRepo = mock(CustomerRepository.class);
		when(stubRepo.findById("noCustId")).thenRetrun(null);

		RuleDiscounter stubRule = (cust, lines) -> null;
		
		CalculateDiscountService calDisSvc = new CalculateDiscountService(stbRepo, stubRule);
		assertThrows(NoCustomerException.class, () -> calDisSvc.calculateDiscount(ssomeLines, "noCustId"));
	}
}
```
실제 구현 없이 테스트를 할 수 있는 이유는 DIP를 적용해서 고수준 모듈이 저수준 모듈에 의존하지 않도록 했기 때문이다.

2.3.1 DIP 주의사항

DIP를 잘못 생각하면 단순히 인터페이스와 구현 클래스를 분리하는 정도로 받아드릴 수 있다.
DIP의 핵심은 고수준 모듈이 저수준 모듈의 의존하지 않도록 하기 위함이다.
잘못된 구조
- 도메인 영역은 구현 기술을 다루는 인프라스트럭처 영역에 의존하고 있다.
- 고수준 모듈이 저수준 모듈에 의존하고 있다.
DIP를 적용할 때 하위 기능을 추상화한 인터페이스는 고수준 모듈 관점에서 도출한다.
- CalculateDiscountService는 할인 금액을 구하기 위한 룰 엔진을 사용하는지 직접 연산하는지 중요하지 않다.
- 규칙에 따라 할인 금액을 계산하는 것이 중요
- ‘할인 금액 계산’을 추상화한 인터페이스는 저수준 모듈이 아닌 고수준 모듈에 위치한다.

2.3.2 DIP와 아키텍처

인프라스트럭처 영역은 구현 기술을 다루는 저수준 모듈이고 응용 영역과 도메인 영역은 고수준 모듈이다.
인프라스트럭처 계층이 가장 하단에 위치하는 계층형 구조와 달리 아키텍처에 DIP를 적용하면 인프라스트럭처 영역이 응용 영역와 도메인 영역에 의존하는 구조가 된다.
인프라스트럭처에 위치한 클래스가 도메인이나 응용 영역에 정의한 인터페이스를 상속받아 구현하는 구조가 되므로 도메인과 응용 영역에 대한 영향을 주지 않거나 최소화하면서 구현 기술을 변경하는 것이 가능하다.
주문 시 통지 방식에 SMS를 추가해야 한다는 요구사항이 들어왔을 때 OrderService는 변경할 필요가 없다.
- 두 통지 방식을 함께 제공하는 Notifier 구현 클래스를 인프라스트럭처 영역에 추가하면 된다.
마이바티스 대신 JPA를 구현 기술로 사용하고 싶다면 JPA를 이용한 OrderRepository 구현 클래스를 인프라 스트럭처 영역에 추가하면 된다.

2.4 도메인 영역의 주요 구성요소

도메인 영역을 구성하는 요소요소 설명

엔티티 ENTITY	고유 식별자를 갖는 객체로 자신의 라이프 사이클을 갖는다. Order, Member, Product와 같이 도메인의 고유한 개념을 표현한다. 도메인 모델의 데이터를 포함하며 해당 데이터와 관련된 기능을 함께 제공
밸류 VALUE	고유 식별자를 갖지 않는 객체로 주로 개념적으로 하나의 값을 표현할 때 사용된다. 배송지 주소를 표현하기 위한 Address나 구매한 금액을 위한 Money와 같은 타입이 밸류 타입이다. 엔티티의 속성으로 사용할 뿐만 아니라 다른 밸류 타입의 속성도 사용할 수 있다.
애그리거트 AGGREGATE	애그리거트는 연관된 엔티티와 밸류 객체를 개념적으로 하나로 묶는 것이다. 주문과 관련된 Order 엔티티, OrderLine 밸류, Orderer 밸류 객체를 주문 애그리거트로 묶을 수 있다.
리포지터리 REPOSITORY	도메인 모델의 영속성을 처리한다. DBMS 테이블에서 엔티티 객체를 로딩하거나 저장하는 기능을 제공
도메인 서비스 DOMAIN SERVICE	특정 엔티티에 속하지 않는 도메인 로직을 제공한다. ‘할인 금액 계산’은 상품, 쿠폰, 회원 등급, 구매 금액 등 다양한 조건을 이용해서 구현하게 되는데 이렇게 도메인 로직이 여러 엔티티와 밸류를 필요로 하면 도메인 서비스에 로직을 구현

2.4.1 엔티티와 밸류

엔티티와 도메인 모델의 가장 큰 차이점은 도메인 모델의 엔티티는 데이터와 함께 도메인 기능을 함께 제공한다는 점
- 주문을 표현하는 엔티티는 주문과 관련된 데이터뿐만 아니라 배송지 주소 변경을 위한 기능을 함께 제공
```
public class Order {
	private OrderNo number;
	private Orderer orderer;
	private ShippingInfo shippingInfo;
	
	// 도메인 모델 엔티티는 도메인 기능도 함께 제공
	public void shangeShippingInfo(ShippingInfo newShippingInfo) {
		...	
	}
}
```
도메인 모델의 엔티티는 단순히 데이터를 담고 있는 데이터 구조라기보다는 데이터와 함께 기능을 제공하는 객체
도메인 관점에서 기능을 구현하고 기능 구현을 캡슐화해서 데이터가 임의로 변경되는 것을 막는다.
도메인 모델의 엔티티는 두 개 이상의 데이터가 개념적으로 하나인 경우 밸류 타입을 이용해서 표현할 수 있다
- Orderer는 밸류 타입으로 주문자 이름과 이메일 데이터를 포함할 수 있다.
```
public class Orderer {
	private String name;
	private String email;
}
```
RDBMS와 같은 관계형 데이터베이스는 밸류 타입을 재대로 표현하기 힘들다.
- Ordere의 개별 데이터를 저장하거나 밸로 테이블로 분리해서 저장해야 한다.
- 한 테이블에 주문자 정보 함께 넣기
  - 주문자라는 개념이 들어나지 않고 주문자의 개별 데이터만 드러난다.
- 다른 테이블에 주문자 정보 넣기
  - 주문자 데이터를 별도 테이블에 저장했지만 이것은 테이블의 엔티티에 가까우며 밸류 타입의 의미가 드러나지 않는다.

밸류는 불변으로 구현할 것을 권장

엔티티의 밸류 타입 데이터를 변경할 떄는 객체 자체를 완전히 교체한다는 것을 의미

public class Order {
	private ShippingInfo shippingInfo;
	
	public void shangeShippingInfo(ShippingInfo newShippingInfo) {
		checkShippingInfoChangeable();
		setShippingInfo(newShippingInfo);
	}

	private void setShippingInfo(ShippingInfo newShippingInfo) {
		if (newShippingInfo == null) {
			throw new IllegalArgumentException();
		}
		this.shippingInfo = newShippingInfo;
	}
}

2.4.2 애그리거트

도메인이 커질수록 개발할 도메인 모델도 커지면서 많은 엔티티와 밸류가 출현한다.
도메인 모델이 복잡해지면 개발자가 전체 구조가 아닌 한 개 엔티티와 밸류에만 집중하는 상황이 발생한다.
- 상위 수준에서 모델을 관리하지 않고 개별 요소에만 초점을 맞추다 보면, 큰 수준에서 모델을 이해하지 못해 큰 틀에서 모델은 관리할 수 없는 상황에 빠질 수 있다.
도메인 모델에 전체 구조를 이해하는데 도움이 되는 것이 바로 애그리거트(AGGREGATE)이다.
애그리거트는 관련 객체를 하나로 묶은 군집이다.
- 모메인 개념은“주문”, “배송지 정보”, “주문자”, “주문 목록”, “총 결제 금액”의 하위 모델로 구성된다.
- 하위 내념을 표현한 모델을 하나로 묶어서 “주문”이라는 상위 개념으로 표현할 수 있다.
애그리거트를 사용하면 개별 객체가 아닌 관련 객체를 묶어서 객체 군집 단위로 모델을 바라볼 수 있게 된다.
- 개별 객체 간의 관계가 아닌 애그리거트 간의 관계로 도메인 모델을 이해하고 구현하고, 큰 틀에서 도메인 모델을 관리할 수 있다.
애그리거트는 군집에 속한 객체를 관리하는 루트 엔티티를 갖는다.
- 루트 엔티티는 애그리거트에 속해 있는 엔티티와 밸류 객체를 이용해서 애그리거트가 구현해야 할 기능을 제공
- 애그리거트를 사용하는 코드는 애그리거트 루트가 제공하는 기능을 실행
- 애그리거트 루트를 통해 간접적으로 애그리거트 내의 다른 엔티티나 밸류 객체에 접근
- 애그리거트의 내부 구현을 숨겨서 애그리거트 단위로 구현을 캡슐화할 수 있도록 돕는다.
주문 애그리거트
- 애그리거트 루트인 Order는 주문 도메인 로직에 맞게 애그리거트의 상태를 관리
- Order의 배송지 정보 변경 기능은 배송지를 변경할 수 있는지를 확인한 위에 배송지 정보를 변경
- 주문 애그리거트는 Order를 통하지 않고 ShippingInfo를 변경할 수 있는 방법을 제공하지 않는다.
  - 배송지를 변경하려면 루트 엔티티인 Order를 사용해야 하므로 배소지 정보를 변경할 때는 Order가 구현한 도메인 로직을 항상 따르게 된다.
애그리거트를 구현할 때는 고려할 것이 많다.
- 애그리거트를 어떻게 구성했느냐에 따라 구현이 복잡해지기도 하고
- 트랜잭션 범위가 달라지기도 한다.

2.4.3 리포지터리

도메인 객체를 지속적으로 사용하려면 RDBMS, NoSQL, 로컬 파일과 같은 물리적인 저장소에 도메인 객체를 보관해야 한다.
- 이를 위한 도메인 모델이 리포지터리(Repository)이다.
엔티티나 밸류가 요구사항에 도출되는 도메인 모델이라면 리포리터리는 구현을 위한 도메인 모델이다.
리포지터리는 애그리거트 단위로 도메인 객체를 저장하고 조회하는 기능을 정의
- OrderRepository의 메서드를 보면 대상을 찾고 저장하는 단위가 애그리거트 루트인 Order인 것을 알 수 있다.
- Order는 애그리거트에 속한 모든 객체를 포함하고 있으므로 결과적으로 애그리거트 단위로 저장하고 조회한다.
```
public interface OrderRepository {
	Order findByNumber(OrderNumber number);
	void save(Order order);
	void delete(Order order);
}
```
도메인 모델을 사용해야 하는 코드는 리포지터리를 통해서 도메인 객체를 구한 뒤에 도메인 객체의 기능을 실행
public class CancelOrderService { private OrderRepository orderRepository; public void cancel(OrderNumber number) { Order order = orderRepository.findByNumber(number); if (order == null) { throw new OrderNotFoundException(orderId); } order.cancel(); } }
도메인 모델 관점에서 OrderRepository는 도메인 객체를 영속화하는 데 필요한 기능을 추상화 한것으로 고수준 모듈에 속한다.
기반 기술을 이용해서 OrderRepository를 구현한 클래스는 저수준 모듈로 인프라스트럭처 영역에 속한다.
전체 모듈 구조
응용 서비스는 의존 주입과 같은 방식을 사용해서 실제 리포지터리 구현 객체에 접근
응용 서비스와 리포지터리는 밀접한 연관이 있다.
- 응용 서비스는 필요한 도메인 객체를 구하거나 저장할 때 리포지터리를 사용한다.
- 응용 서비스는 트랜잭션을 관리하는데, 트랜잭션 처리는 리포지터리 구현 기술의 영향을 받는다.
리포지터리를 사용하는 주체가 응용 서비스이기 때문에 리포지터리는 응용 서비스가 필요로 하는 메서드를 제공한다.
- 애그리거트를 저장하는 메서드
- 애그리거트 루트 식별자로 애그리거트를 조회하는 메서드

2.5 요청 처리 흐름

표현 영역은 사용자가 전송한 데이터 형식이 올바른지 검사하고 문제가 없다면 데이터를 이용해서 응용 서비스에 기능 실행을 위임
표현 영역은 사용자가 전송한 데이터를 응용 서비스가 요구하는 형식으로 변환해서 전달
요청 처리 흐름
- 웹 브라우저에서 기능 실행 요청
- 표현 영역에 해당하는 컨트롤러는 HTTP 요청 파라미터를 응용 서비스가 필요로 하는 데이터로 변환 해서 응용 서비스의 인자로 전달
- 응용 서비스는 도메인 모델을 이용해서 로직 실행
- 도메인 객체를 리포지터리에서 가져와 실행하거나 신규 도메인 객체를 생성해 리포지터리에 저장
“예매하기”나 “예매 취소”와 같은 기능을 제공하는 응용 서비스는 도메인의 상태를 변경하므로 변경 상태가 물리 저장소에 올바르게 반영되도록 트랜잭션을 관리 해야한다.
- 스프링 프레임워크를 사용한다면 @Transactional 애너테이션을 이용해 트랜잭션을 처리할 수 있다.
```
public class CancelOrderService {
	private OrderRepository orderRepository;
	
	@Transactional
	public void cancel(OrderNumber number) {
		Order order = orderRepository.findByNumber(number);
		if (order == null) {
			throw new NoOrderException(number);
		}
		order.cancel()
	}
}
```

2.6 인프라스트럭처 개요

인프라스트럭처는 표현 영역, 응용 영역, 도메인 영역을 지원한다.
도메인 영역과 응용 영역에서 인프라스트럭처의 기능을 직접 사용하는 것보다 두 영역에서 정의한 인터페이스를 인프라스트럭처 영역에서 구현하는 것이 시스템을 더 유연하고 테스트하기 쉽게 만들어 준다.
무조건 인프라스트럭처에 대한 의존성을 없앨 필요는 없다.
- 스프링을 사용할 경우 응용 서비스는 트랜잭션 처리를 위해 @Transactional을 사용하는 것이 편리하다.
- 영속성 처리를 위해 JPA를 사용할 경우 @Entity나 @Table과 같은 JPA 전용 애너테이션을 도메인 모델 클래스에서 사용하는 것이 XML 매핑 설정을 이용하는 것보다 편리하다.
구현의 편리함은 DIP가 주는 다른 장점만큼 중요하기 때문에 DIP의 장점을 해치지 않는 범위에서 응용 영역과 도메인 영역에서 구현 기술에 대한 의존을 가져가는 것이 나쁘지 않다고 생각한다.
응용 영역과 도메인 영역이 인프라스트럭처에 대한 의존을 완전히 갖지 않도록 시도하는 것은 구현을 더 복잡하고 어렵게 만들 수 있다.
- @Transactional을 사용하면 한 줄로 트랙잭션을 처리할 수 있는데 코드에서 스프링에 대한 의존을 없애려면 복잡한 스프링 설정을 사용해야 한다.
- 의존은 없앴지만 특별히 테스트를 더 쉽게 할 수 있다거나 유연함을 증가시켜 주지 못한다.
- 설정만 복잡해지고 개발 시간만 늘어난다.
표현 영역은 항상 인프라스트럭처 영역과 쌍을 이룬다.
- 스프링 MVC를 사용해서 웹 요청을 처리하려면 스프링이 제공하는 MVC 프레임워크에 맞게 표현 영역을 구현
- Vert.x를 사용해서 Rest API 서버를 구축하려면 Vert.x에 맞게 웹 요청 처리 부분을 구현

2.7 모듈 구성

아키텍처의 각 영역은 별도 패키지에 위치한다.
패키지 구성 규칙에 정답이 존재하는 것은 안지만 영역별로 모듈이 위치할 패키지를 구성할 수 있을 것 이다.
도메인이 크면 하위 도메인으로 나누고 하위 도메인마다 별도 패키지를 구성한다.
도메인 모듈은 도메인에 속한 애그리거트를 기준으로 다시 패키지를 구성한다.
- 카탈로그 하위 도메인이 상품 애그리거트와 카테고리 애그리커트로 구성될 경우 도메인을 두 개의 하위 패키지로 구성할 수 있다.
애그리거트, 모델, 리포지터리는 같은 패키지에 위치시킨다.
- Order, OrderLine, Orderer, OrderRepository 등은 com.myshop.order.domain 패키지에 위치시킨다.
도메인이 복잡하면 도메인 모델과 도메인 서비스를 별도 패키지에 위치시킬 수도 있다.
- com.myshop.order.domain.order: 애그리거트 위치
- com.myshop.order.domain.service: 도메인 서비스 위치
응용 서비스도 도메인 별로 패키지를 구분할 수 있다.
- com.myshop.catalog.application.product
- com.myshop.catalog.application.category
모듈 구조를 얼마나 세분하게해야 하는지에 대한 정해진 규칙은 없다.
한 패키지에 너무 많은 타입이 몰려서 코드를 찾을 때 불편할 정도만 아니면 된다.

2.1 네 개의 영역

“표현”, “응용”, “도메인”, “인프라스트럭처”는 아키텍처를 설계할 때 출현하는 전형적인 네 가지 영역
- 표현 영역
  - 사용자의 요청을 받아 응용 영역에 전달, 응용 영역의 처리 결과를 사용자에게 전달
  - 스프링 MVC 프레임워크가 표현 영역의 기술
- 응용 영역
  - 표현 영역을 통해 사용자의 요청을 전달받은 응용 영역은 시스템이 사용자에게 제공해야할 기능을 구현
  - “주문 등록”, “주문 취소”, “상품 상세 조회” 등의 기능을 예로 들수 있다.
  - 기능을 구현하기 위한 도메인 영역의 도메인 모델을 사용
  - “주문 취소” 기능을 제공하는 응용 서비스를 도메인 모델을 사용해서 기능 구현이 가능
  - public class CancelOrderService { @Transactional public void cancelOrder(String orderId) { Order order = findOrderById(orderId); if (order == null) { throw new OrderNotFoundException(orderId); } order.cancel(); } }
  - 로직을 직접 수행하기보다는 도메인 모델에 로직 수행을 위임
    - “주문 취소” 로직을 직접 구현하지 않고 Order 객체에 취소 처리를 위임 하고 있다
- 도메인 영역
  - Order, OrderLine, ShippingInfo와 같은 도메인 모델
  - 도메인 모델은 핵심 로직을 구현한다.
    - “배송지 변경”, “결제 완료”, “주문 총액 계산”과 같은 핵심 로직을 도메인 모델에 구현한다.
- 인프라스트럭처 영역
  - 구현 기술에 대한 것을 다룬다
  - RDBMS 연동, 메시징 큐에 메시지 전송과 수신, 몽고DB나 레디스의 데이터 연동 처리 등
  - 논리적인 개념을 표현하기보다는 실제 구현을 다룬다
  - 도메인 영역, 응용 영역, 표현 영역은 구현 기술을 사용한 코드를 직접 만들지 않는다.
    - 인프라스트럭처 영역에서 제공하는 기능을 사용해서 필요한 기능을 개발

2.2 계층 구조 아키텍처

네 영역을 구성할 때 많이 사용하는 아키텍처가 그림과 같은 계층 구조이다.
- 표현 영역과 응용 영역은 도메인 영역을 사용
- 도메인 영역은 인프라스트럭처 영역을 사용
도메인의 복잡도에 따라 응용과 도메인을 분리하기도 하고 한 계층으로 합치기도 하지만 전체적인 아키텍처는 계층 구조를 따른다.
계층 구조는 특성상 상위 계층에서 하위 계층으로의 의존만 존재하고 하위 계층은 상위 계층에 의존하지 않는다.
계층 구조를 엄격하게 적용한다면 상위 계층은 바로 아래의 계층에만 의존을 가져야 하지만 구현의 편리함을 위해 계층 구조를 유연하게 적용하기도 한다.
응용 영역과 도메인 영역은 DB나 외부 시스템 연동을 위해 인프라스트럭처의 기능을 사용하므로 계층 구조를 사용하는 것이 직관적으로 이해하기 쉽다.
- 표현, 응용, 도메인 계층이 상세한 구현 기술을 다루는 인프라스트럭처 계층에 종속된다

도메인의 가격 계산 규칙의 예제

할인 금액을 계산하기 위해 Drools라는 룰 엔진을 사용해서 계산 로직을 수행하는 인프라스트럭처 영역의 코드를 만들어 보자

public class DroolsRuleEngine {
	private KieContainer kContainer;

	public DroolsRuleEngine() {
		KieServices ks = KieServices.Factory.get();
		kContainer = ks.getKieClasspathContainer();		
	}

	public void evalute(String sessionName, List<?> facts) {
		KiSession kSession = kContainer.newKieSession(sessionName);
		try {
			facts.forEach(x -> kSession.insert(x));
			kSession.fireAllRules();
		} finaly {
			kSession.dispose();
		}
	}
}

응용 영역은 가격 계산을 위해 인프라스트럭처 영역의 DroolsRuleEngine을 사용

public class CalcuateDiscountService {
	private DroolsRuleEngine ruleEngine;
	
	public CalculateDiscountService() {
		ruleEngine = new DroolsRuleEngine();
	}

	public Money calculateDiscount(List<OrderLine> orderLines, String customerId) {
		Customer customer = findCustomer(customerId);
		
		MutableMoney money = new MutableMoney(0);
		List<?> facts = Arrays.asList(customer, money);
		facts.addAll(orderLines);
		ruleEngine.evalute("discountCalculation", facts);
		return money.toImmutableMoney();
	}
}

CalculateDiscountService가 동작은 하겠지만 두가지 문제를 안고 있다.
- CalculateDiscountService를 테스트하기 어렵다
  - RuleEngine이 완벽하게 동작해야 한다.
  - RuleEngine 클래스와 관련 설정 파일 모두 만든 이후에 CalculateDiscountService 를 확인할 수 있다.
- 구현 방식을 변경하기 어렵다
  - ‘discountCalculation’ 문자열은 Drools의 세션 이름을 의미한다.
  - 세션 이름을 변경하면 CalculateDiscountService 코드도 함께 변경해야 한다.
CalculateDiscountService가 겉으로는 인프라스트럭처의 기술에 직접적인 의존을 하지 않는 것처럼 보여도 실제로는 Drools라는 인프라스트럭처 영역의 기술에 완전하게 의존하고 있다.
인프라스트럭처에 의존하면 ‘테스트 어려움’과 ‘기능 확장 어려움’이라는 두가지 문제가 발생한다.
- 문제 해답은 DIP에 있다.

2.3 DIP

가격 할인 계산을 하려면 고객 정보를 구해야하고, 구한 고객 정보와 주문 정보를 이용해서 룰을 실행해야 한다.
CalculateDiscountService는 고수준 모듈이다.
- 고수준 모듈은 의미 있는 단일 기능을 제공하는 모듈로 ‘가격 할인 계산’이라는 기능을 구현
- 가격 할인 계싼 기능을 구현하려면 고객 정보를 구해야하고 룰을 실행해야 하는데 이 두 기능이 하위 기능이다.
저수준 모듈은 하위 기능을 실제로 구현한 것이다.
- JPA를 이용해서 고객 정보를 읽어오는 모듈과 Drools로 룰을 실행하는 모듈이 저수준 모듈이 된다.

DIP는 저수준 모듈이 고수준 모듈에 의존하도록 바꾼다.

추상화 인터페이스를 사용

public interface RuleDiscounter {
	Money applyRules(Customer customer, List<OrderLine> orderLines);
}

CalculateDiscountService가 RuleDiscounter를 이용하도록 변경
- Drools에 의존하는 코드가 없다

public class CalcuateDiscountService {
	private RuleDiscounter ruleDiscounter;
	
	public CalculateDiscountService(RuleDiscounter ruleDiscounter) {
		this.ruleDiscounter = ruleDiscounter;
	}

	public Money calculateDiscount(List<OrderLine> orderLines, String customerId) {
		Customer customer = findCustomer(customerId);
		return ruleDiscounter.applyRules(customer, orderLines);
	}
}

RuleDiscounter를 상속받아 구현

public class DroolsRuleDiscounter implements RuleDiscounter {
	private KieCountainer kContainer;
	
	public DroolsRuleEngine() {
		KieService ks = KieServices.Factory.get();
		kContainer = ks.getKieClasspathContainer();
	}

	@Override
	public Money applyRules(Customer customer, List<OrderLine> orderLines) {
		KieSession kSession = kContainer.newKieSession("discountSession");
		try {
			...
			kSession.fireAllRules();
		} finally {
			kSession.dispose();
		}
		return money.toImmutableMoney();
	}
}

RuleDiscounter가 출현하면서 바뀐 구조
CalculateDiscountService는 더이상 구현 기술인 Drools에 의존하지 않는다.
- RuleDiscounter 인터페이스에 의존할 뿐
- ‘룰을 이용한 할인 금액 계산’은 고수준 모듈의 개념이므로 RuleDiscounter 인터페이스는 고수준 모듈에 속한다.
- DroolsRuleDiscounter는 고수준의 하위 기능인 RuleDiscounter를 구현한 것이므로 저수준 모듈에 속한다.

DIP를 적용하면 저수준 모듈이 고수준 모듈에 의존하게 된다.
- 고수준 모듈이 저수준 모듈을 사용하려면 고수준 모듈이 저수준 모듈에 의존해야 하는데, 반대로 저수준 모듈이 고수준 모듈에 의존한다고 해서 이를 DIP(Dependency Inversion Principle, 의존 역전 원칙)이라 부른다.
DIP를 적용하면 다른 영역인 인프라스트럭처 영역에 의존할 떄 발생했던 두가지 문제인 구현 교체가 어렵다는 것과 테스트가 어려운 문제를 해소할 수 있다.

고수준 모듈은 더 이상 저수준 모듈에 의존하지 않고 구현을 추상화한 인터페이스에 의존할 수 있다.

구현 기술이 변경되더라도 저수준 구현 객체를 생성하는 코드만 변경하면 된다.

// 기존 코드
RuleDiscounter roleDiscounter = new DroolsRuleDiscounter();
CalculateDiscountService disService = new CalculateDiscountService(roleDiscounter);

// 구현 기술 변경 
RuleDiscounter roleDiscounter = new SimpleRuleDiscounter();
CalculateDiscountService disService = new CalculateDiscountService(roleDiscounter);

스프링과 같은 의존 주입을 지원하는 프레임워크를 사용하면 설정 코드를 수정해서 쉽게 구현체를 변경할 수 있다.
CalculateDiscountService가 제대로 동작하는지 테스트하려면 CustomerRepository와 RuleDiscounter를 구현한 객체가 필요하다.
- CacluateDiscountService가 저수준 모듈에 직접 의존했다면 저수준 모듈이 만들어지기 전까진 테스트를 할 수 없음
- 인터페이스에 의존함으로 대역 객체를 사용해서 테스트를 진행 할수 있다.
- 실제 구현 대신 스텁이나 모의 객체와 같은 테스트 목적의 대역을 사용하여 거의 모든 상황을 테스트할 수 있다.
```
public class CalculateDiscountServiceTest {
	@Test
	public void noCustomer_thenExcetionShouldBeThrown() {
		CustomerRepository stubRepo = mock(CustomerRepository.class);
		when(stubRepo.findById("noCustId")).thenRetrun(null);

		RuleDiscounter stubRule = (cust, lines) -> null;
		
		CalculateDiscountService calDisSvc = new CalculateDiscountService(stbRepo, stubRule);
		assertThrows(NoCustomerException.class, () -> calDisSvc.calculateDiscount(ssomeLines, "noCustId"));
	}
}
```
실제 구현 없이 테스트를 할 수 있는 이유는 DIP를 적용해서 고수준 모듈이 저수준 모듈에 의존하지 않도록 했기 때문이다.

2.3.1 DIP 주의사항

DIP를 잘못 생각하면 단순히 인터페이스와 구현 클래스를 분리하는 정도로 받아드릴 수 있다.
DIP의 핵심은 고수준 모듈이 저수준 모듈의 의존하지 않도록 하기 위함이다.
잘못된 구조
- 도메인 영역은 구현 기술을 다루는 인프라스트럭처 영역에 의존하고 있다.
- 고수준 모듈이 저수준 모듈에 의존하고 있다.
DIP를 적용할 때 하위 기능을 추상화한 인터페이스는 고수준 모듈 관점에서 도출한다.
- CalculateDiscountService는 할인 금액을 구하기 위한 룰 엔진을 사용하는지 직접 연산하는지 중요하지 않다.
- 규칙에 따라 할인 금액을 계산하는 것이 중요
- ‘할인 금액 계산’을 추상화한 인터페이스는 저수준 모듈이 아닌 고수준 모듈에 위치한다.

2.3.2 DIP와 아키텍처

인프라스트럭처 영역은 구현 기술을 다루는 저수준 모듈이고 응용 영역과 도메인 영역은 고수준 모듈이다.
인프라스트럭처 계층이 가장 하단에 위치하는 계층형 구조와 달리 아키텍처에 DIP를 적용하면 인프라스트럭처 영역이 응용 영역와 도메인 영역에 의존하는 구조가 된다.
인프라스트럭처에 위치한 클래스가 도메인이나 응용 영역에 정의한 인터페이스를 상속받아 구현하는 구조가 되므로 도메인과 응용 영역에 대한 영향을 주지 않거나 최소화하면서 구현 기술을 변경하는 것이 가능하다.
주문 시 통지 방식에 SMS를 추가해야 한다는 요구사항이 들어왔을 때 OrderService는 변경할 필요가 없다.
- 두 통지 방식을 함께 제공하는 Notifier 구현 클래스를 인프라스트럭처 영역에 추가하면 된다.
마이바티스 대신 JPA를 구현 기술로 사용하고 싶다면 JPA를 이용한 OrderRepository 구현 클래스를 인프라 스트럭처 영역에 추가하면 된다.

2.4 도메인 영역의 주요 구성요소

도메인 영역을 구성하는 요소요소 설명

엔티티 ENTITY	고유 식별자를 갖는 객체로 자신의 라이프 사이클을 갖는다. Order, Member, Product와 같이 도메인의 고유한 개념을 표현한다. 도메인 모델의 데이터를 포함하며 해당 데이터와 관련된 기능을 함께 제공
밸류 VALUE	고유 식별자를 갖지 않는 객체로 주로 개념적으로 하나의 값을 표현할 때 사용된다. 배송지 주소를 표현하기 위한 Address나 구매한 금액을 위한 Money와 같은 타입이 밸류 타입이다. 엔티티의 속성으로 사용할 뿐만 아니라 다른 밸류 타입의 속성도 사용할 수 있다.
애그리거트 AGGREGATE	애그리거트는 연관된 엔티티와 밸류 객체를 개념적으로 하나로 묶는 것이다. 주문과 관련된 Order 엔티티, OrderLine 밸류, Orderer 밸류 객체를 주문 애그리거트로 묶을 수 있다.
리포지터리 REPOSITORY	도메인 모델의 영속성을 처리한다. DBMS 테이블에서 엔티티 객체를 로딩하거나 저장하는 기능을 제공
도메인 서비스 DOMAIN SERVICE	특정 엔티티에 속하지 않는 도메인 로직을 제공한다. ‘할인 금액 계산’은 상품, 쿠폰, 회원 등급, 구매 금액 등 다양한 조건을 이용해서 구현하게 되는데 이렇게 도메인 로직이 여러 엔티티와 밸류를 필요로 하면 도메인 서비스에 로직을 구현

2.4.1 엔티티와 밸류

엔티티와 도메인 모델의 가장 큰 차이점은 도메인 모델의 엔티티는 데이터와 함께 도메인 기능을 함께 제공한다는 점
- 주문을 표현하는 엔티티는 주문과 관련된 데이터뿐만 아니라 배송지 주소 변경을 위한 기능을 함께 제공
```
public class Order {
	private OrderNo number;
	private Orderer orderer;
	private ShippingInfo shippingInfo;
	
	// 도메인 모델 엔티티는 도메인 기능도 함께 제공
	public void shangeShippingInfo(ShippingInfo newShippingInfo) {
		...	
	}
}
```
도메인 모델의 엔티티는 단순히 데이터를 담고 있는 데이터 구조라기보다는 데이터와 함께 기능을 제공하는 객체
도메인 관점에서 기능을 구현하고 기능 구현을 캡슐화해서 데이터가 임의로 변경되는 것을 막는다.
도메인 모델의 엔티티는 두 개 이상의 데이터가 개념적으로 하나인 경우 밸류 타입을 이용해서 표현할 수 있다
- Orderer는 밸류 타입으로 주문자 이름과 이메일 데이터를 포함할 수 있다.
```
public class Orderer {
	private String name;
	private String email;
}
```
RDBMS와 같은 관계형 데이터베이스는 밸류 타입을 재대로 표현하기 힘들다.
- Ordere의 개별 데이터를 저장하거나 밸로 테이블로 분리해서 저장해야 한다.
- 한 테이블에 주문자 정보 함께 넣기
  - 주문자라는 개념이 들어나지 않고 주문자의 개별 데이터만 드러난다.
- 다른 테이블에 주문자 정보 넣기
  - 주문자 데이터를 별도 테이블에 저장했지만 이것은 테이블의 엔티티에 가까우며 밸류 타입의 의미가 드러나지 않는다.

밸류는 불변으로 구현할 것을 권장

엔티티의 밸류 타입 데이터를 변경할 떄는 객체 자체를 완전히 교체한다는 것을 의미

public class Order {
	private ShippingInfo shippingInfo;
	
	public void shangeShippingInfo(ShippingInfo newShippingInfo) {
		checkShippingInfoChangeable();
		setShippingInfo(newShippingInfo);
	}

	private void setShippingInfo(ShippingInfo newShippingInfo) {
		if (newShippingInfo == null) {
			throw new IllegalArgumentException();
		}
		this.shippingInfo = newShippingInfo;
	}
}

2.4.2 애그리거트

도메인이 커질수록 개발할 도메인 모델도 커지면서 많은 엔티티와 밸류가 출현한다.
도메인 모델이 복잡해지면 개발자가 전체 구조가 아닌 한 개 엔티티와 밸류에만 집중하는 상황이 발생한다.
- 상위 수준에서 모델을 관리하지 않고 개별 요소에만 초점을 맞추다 보면, 큰 수준에서 모델을 이해하지 못해 큰 틀에서 모델은 관리할 수 없는 상황에 빠질 수 있다.
도메인 모델에 전체 구조를 이해하는데 도움이 되는 것이 바로 애그리거트(AGGREGATE)이다.
애그리거트는 관련 객체를 하나로 묶은 군집이다.
- 모메인 개념은“주문”, “배송지 정보”, “주문자”, “주문 목록”, “총 결제 금액”의 하위 모델로 구성된다.
- 하위 내념을 표현한 모델을 하나로 묶어서 “주문”이라는 상위 개념으로 표현할 수 있다.
애그리거트를 사용하면 개별 객체가 아닌 관련 객체를 묶어서 객체 군집 단위로 모델을 바라볼 수 있게 된다.
- 개별 객체 간의 관계가 아닌 애그리거트 간의 관계로 도메인 모델을 이해하고 구현하고, 큰 틀에서 도메인 모델을 관리할 수 있다.
애그리거트는 군집에 속한 객체를 관리하는 루트 엔티티를 갖는다.
- 루트 엔티티는 애그리거트에 속해 있는 엔티티와 밸류 객체를 이용해서 애그리거트가 구현해야 할 기능을 제공
- 애그리거트를 사용하는 코드는 애그리거트 루트가 제공하는 기능을 실행
- 애그리거트 루트를 통해 간접적으로 애그리거트 내의 다른 엔티티나 밸류 객체에 접근
- 애그리거트의 내부 구현을 숨겨서 애그리거트 단위로 구현을 캡슐화할 수 있도록 돕는다.
주문 애그리거트
- 애그리거트 루트인 Order는 주문 도메인 로직에 맞게 애그리거트의 상태를 관리
- Order의 배송지 정보 변경 기능은 배송지를 변경할 수 있는지를 확인한 위에 배송지 정보를 변경
- 주문 애그리거트는 Order를 통하지 않고 ShippingInfo를 변경할 수 있는 방법을 제공하지 않는다.
  - 배송지를 변경하려면 루트 엔티티인 Order를 사용해야 하므로 배소지 정보를 변경할 때는 Order가 구현한 도메인 로직을 항상 따르게 된다.
애그리거트를 구현할 때는 고려할 것이 많다.
- 애그리거트를 어떻게 구성했느냐에 따라 구현이 복잡해지기도 하고
- 트랜잭션 범위가 달라지기도 한다.

2.4.3 리포지터리

도메인 객체를 지속적으로 사용하려면 RDBMS, NoSQL, 로컬 파일과 같은 물리적인 저장소에 도메인 객체를 보관해야 한다.
- 이를 위한 도메인 모델이 리포지터리(Repository)이다.
엔티티나 밸류가 요구사항에 도출되는 도메인 모델이라면 리포리터리는 구현을 위한 도메인 모델이다.
리포지터리는 애그리거트 단위로 도메인 객체를 저장하고 조회하는 기능을 정의
- OrderRepository의 메서드를 보면 대상을 찾고 저장하는 단위가 애그리거트 루트인 Order인 것을 알 수 있다.
- Order는 애그리거트에 속한 모든 객체를 포함하고 있으므로 결과적으로 애그리거트 단위로 저장하고 조회한다.
```
public interface OrderRepository {
	Order findByNumber(OrderNumber number);
	void save(Order order);
	void delete(Order order);
}
```
도메인 모델을 사용해야 하는 코드는 리포지터리를 통해서 도메인 객체를 구한 뒤에 도메인 객체의 기능을 실행
public class CancelOrderService { private OrderRepository orderRepository; public void cancel(OrderNumber number) { Order order = orderRepository.findByNumber(number); if (order == null) { throw new OrderNotFoundException(orderId); } order.cancel(); } }
도메인 모델 관점에서 OrderRepository는 도메인 객체를 영속화하는 데 필요한 기능을 추상화 한것으로 고수준 모듈에 속한다.
기반 기술을 이용해서 OrderRepository를 구현한 클래스는 저수준 모듈로 인프라스트럭처 영역에 속한다.
전체 모듈 구조
응용 서비스는 의존 주입과 같은 방식을 사용해서 실제 리포지터리 구현 객체에 접근
응용 서비스와 리포지터리는 밀접한 연관이 있다.
- 응용 서비스는 필요한 도메인 객체를 구하거나 저장할 때 리포지터리를 사용한다.
- 응용 서비스는 트랜잭션을 관리하는데, 트랜잭션 처리는 리포지터리 구현 기술의 영향을 받는다.
리포지터리를 사용하는 주체가 응용 서비스이기 때문에 리포지터리는 응용 서비스가 필요로 하는 메서드를 제공한다.
- 애그리거트를 저장하는 메서드
- 애그리거트 루트 식별자로 애그리거트를 조회하는 메서드

2.5 요청 처리 흐름

표현 영역은 사용자가 전송한 데이터 형식이 올바른지 검사하고 문제가 없다면 데이터를 이용해서 응용 서비스에 기능 실행을 위임
표현 영역은 사용자가 전송한 데이터를 응용 서비스가 요구하는 형식으로 변환해서 전달
요청 처리 흐름
- 웹 브라우저에서 기능 실행 요청
- 표현 영역에 해당하는 컨트롤러는 HTTP 요청 파라미터를 응용 서비스가 필요로 하는 데이터로 변환 해서 응용 서비스의 인자로 전달
- 응용 서비스는 도메인 모델을 이용해서 로직 실행
- 도메인 객체를 리포지터리에서 가져와 실행하거나 신규 도메인 객체를 생성해 리포지터리에 저장
“예매하기”나 “예매 취소”와 같은 기능을 제공하는 응용 서비스는 도메인의 상태를 변경하므로 변경 상태가 물리 저장소에 올바르게 반영되도록 트랜잭션을 관리 해야한다.
- 스프링 프레임워크를 사용한다면 @Transactional 애너테이션을 이용해 트랜잭션을 처리할 수 있다.
```
public class CancelOrderService {
	private OrderRepository orderRepository;
	
	@Transactional
	public void cancel(OrderNumber number) {
		Order order = orderRepository.findByNumber(number);
		if (order == null) {
			throw new NoOrderException(number);
		}
		order.cancel()
	}
}
```

2.6 인프라스트럭처 개요

인프라스트럭처는 표현 영역, 응용 영역, 도메인 영역을 지원한다.
도메인 영역과 응용 영역에서 인프라스트럭처의 기능을 직접 사용하는 것보다 두 영역에서 정의한 인터페이스를 인프라스트럭처 영역에서 구현하는 것이 시스템을 더 유연하고 테스트하기 쉽게 만들어 준다.
무조건 인프라스트럭처에 대한 의존성을 없앨 필요는 없다.
- 스프링을 사용할 경우 응용 서비스는 트랜잭션 처리를 위해 @Transactional을 사용하는 것이 편리하다.
- 영속성 처리를 위해 JPA를 사용할 경우 @Entity나 @Table과 같은 JPA 전용 애너테이션을 도메인 모델 클래스에서 사용하는 것이 XML 매핑 설정을 이용하는 것보다 편리하다.
구현의 편리함은 DIP가 주는 다른 장점만큼 중요하기 때문에 DIP의 장점을 해치지 않는 범위에서 응용 영역과 도메인 영역에서 구현 기술에 대한 의존을 가져가는 것이 나쁘지 않다고 생각한다.
응용 영역과 도메인 영역이 인프라스트럭처에 대한 의존을 완전히 갖지 않도록 시도하는 것은 구현을 더 복잡하고 어렵게 만들 수 있다.
- @Transactional을 사용하면 한 줄로 트랙잭션을 처리할 수 있는데 코드에서 스프링에 대한 의존을 없애려면 복잡한 스프링 설정을 사용해야 한다.
- 의존은 없앴지만 특별히 테스트를 더 쉽게 할 수 있다거나 유연함을 증가시켜 주지 못한다.
- 설정만 복잡해지고 개발 시간만 늘어난다.
표현 영역은 항상 인프라스트럭처 영역과 쌍을 이룬다.
- 스프링 MVC를 사용해서 웹 요청을 처리하려면 스프링이 제공하는 MVC 프레임워크에 맞게 표현 영역을 구현
- Vert.x를 사용해서 Rest API 서버를 구축하려면 Vert.x에 맞게 웹 요청 처리 부분을 구현

2.7 모듈 구성

아키텍처의 각 영역은 별도 패키지에 위치한다.
패키지 구성 규칙에 정답이 존재하는 것은 안지만 영역별로 모듈이 위치할 패키지를 구성할 수 있을 것 이다.
도메인이 크면 하위 도메인으로 나누고 하위 도메인마다 별도 패키지를 구성한다.
도메인 모듈은 도메인에 속한 애그리거트를 기준으로 다시 패키지를 구성한다.
- 카탈로그 하위 도메인이 상품 애그리거트와 카테고리 애그리커트로 구성될 경우 도메인을 두 개의 하위 패키지로 구성할 수 있다.
애그리거트, 모델, 리포지터리는 같은 패키지에 위치시킨다.
- Order, OrderLine, Orderer, OrderRepository 등은 com.myshop.order.domain 패키지에 위치시킨다.
도메인이 복잡하면 도메인 모델과 도메인 서비스를 별도 패키지에 위치시킬 수도 있다.
- com.myshop.order.domain.order: 애그리거트 위치
- com.myshop.order.domain.service: 도메인 서비스 위치
응용 서비스도 도메인 별로 패키지를 구분할 수 있다.
- com.myshop.catalog.application.product
- com.myshop.catalog.application.category
모듈 구조를 얼마나 세분하게해야 하는지에 대한 정해진 규칙은 없다.
한 패키지에 너무 많은 타입이 몰려서 코드를 찾을 때 불편할 정도만 아니면 된다.

2.1 네 개의 영역

“표현”, “응용”, “도메인”, “인프라스트럭처”는 아키텍처를 설계할 때 출현하는 전형적인 네 가지 영역
- 표현 영역
  - 사용자의 요청을 받아 응용 영역에 전달, 응용 영역의 처리 결과를 사용자에게 전달
  - 스프링 MVC 프레임워크가 표현 영역의 기술
- 응용 영역
  - 표현 영역을 통해 사용자의 요청을 전달받은 응용 영역은 시스템이 사용자에게 제공해야할 기능을 구현
  - “주문 등록”, “주문 취소”, “상품 상세 조회” 등의 기능을 예로 들수 있다.
  - 기능을 구현하기 위한 도메인 영역의 도메인 모델을 사용
  - “주문 취소” 기능을 제공하는 응용 서비스를 도메인 모델을 사용해서 기능 구현이 가능
  - public class CancelOrderService { @Transactional public void cancelOrder(String orderId) { Order order = findOrderById(orderId); if (order == null) { throw new OrderNotFoundException(orderId); } order.cancel(); } }
  - 로직을 직접 수행하기보다는 도메인 모델에 로직 수행을 위임
    - “주문 취소” 로직을 직접 구현하지 않고 Order 객체에 취소 처리를 위임 하고 있다
- 도메인 영역
  - Order, OrderLine, ShippingInfo와 같은 도메인 모델
  - 도메인 모델은 핵심 로직을 구현한다.
    - “배송지 변경”, “결제 완료”, “주문 총액 계산”과 같은 핵심 로직을 도메인 모델에 구현한다.
- 인프라스트럭처 영역
  - 구현 기술에 대한 것을 다룬다
  - RDBMS 연동, 메시징 큐에 메시지 전송과 수신, 몽고DB나 레디스의 데이터 연동 처리 등
  - 논리적인 개념을 표현하기보다는 실제 구현을 다룬다
  - 도메인 영역, 응용 영역, 표현 영역은 구현 기술을 사용한 코드를 직접 만들지 않는다.
    - 인프라스트럭처 영역에서 제공하는 기능을 사용해서 필요한 기능을 개발

2.2 계층 구조 아키텍처

네 영역을 구성할 때 많이 사용하는 아키텍처가 그림과 같은 계층 구조이다.
- 표현 영역과 응용 영역은 도메인 영역을 사용
- 도메인 영역은 인프라스트럭처 영역을 사용
도메인의 복잡도에 따라 응용과 도메인을 분리하기도 하고 한 계층으로 합치기도 하지만 전체적인 아키텍처는 계층 구조를 따른다.
계층 구조는 특성상 상위 계층에서 하위 계층으로의 의존만 존재하고 하위 계층은 상위 계층에 의존하지 않는다.
계층 구조를 엄격하게 적용한다면 상위 계층은 바로 아래의 계층에만 의존을 가져야 하지만 구현의 편리함을 위해 계층 구조를 유연하게 적용하기도 한다.
응용 영역과 도메인 영역은 DB나 외부 시스템 연동을 위해 인프라스트럭처의 기능을 사용하므로 계층 구조를 사용하는 것이 직관적으로 이해하기 쉽다.
- 표현, 응용, 도메인 계층이 상세한 구현 기술을 다루는 인프라스트럭처 계층에 종속된다

도메인의 가격 계산 규칙의 예제

할인 금액을 계산하기 위해 Drools라는 룰 엔진을 사용해서 계산 로직을 수행하는 인프라스트럭처 영역의 코드를 만들어 보자

public class DroolsRuleEngine {
	private KieContainer kContainer;

	public DroolsRuleEngine() {
		KieServices ks = KieServices.Factory.get();
		kContainer = ks.getKieClasspathContainer();		
	}

	public void evalute(String sessionName, List<?> facts) {
		KiSession kSession = kContainer.newKieSession(sessionName);
		try {
			facts.forEach(x -> kSession.insert(x));
			kSession.fireAllRules();
		} finaly {
			kSession.dispose();
		}
	}
}

응용 영역은 가격 계산을 위해 인프라스트럭처 영역의 DroolsRuleEngine을 사용

public class CalcuateDiscountService {
	private DroolsRuleEngine ruleEngine;
	
	public CalculateDiscountService() {
		ruleEngine = new DroolsRuleEngine();
	}

	public Money calculateDiscount(List<OrderLine> orderLines, String customerId) {
		Customer customer = findCustomer(customerId);
		
		MutableMoney money = new MutableMoney(0);
		List<?> facts = Arrays.asList(customer, money);
		facts.addAll(orderLines);
		ruleEngine.evalute("discountCalculation", facts);
		return money.toImmutableMoney();
	}
}

CalculateDiscountService가 동작은 하겠지만 두가지 문제를 안고 있다.
- CalculateDiscountService를 테스트하기 어렵다
  - RuleEngine이 완벽하게 동작해야 한다.
  - RuleEngine 클래스와 관련 설정 파일 모두 만든 이후에 CalculateDiscountService 를 확인할 수 있다.
- 구현 방식을 변경하기 어렵다
  - ‘discountCalculation’ 문자열은 Drools의 세션 이름을 의미한다.
  - 세션 이름을 변경하면 CalculateDiscountService 코드도 함께 변경해야 한다.
CalculateDiscountService가 겉으로는 인프라스트럭처의 기술에 직접적인 의존을 하지 않는 것처럼 보여도 실제로는 Drools라는 인프라스트럭처 영역의 기술에 완전하게 의존하고 있다.
인프라스트럭처에 의존하면 ‘테스트 어려움’과 ‘기능 확장 어려움’이라는 두가지 문제가 발생한다.
- 문제 해답은 DIP에 있다.

2.3 DIP

가격 할인 계산을 하려면 고객 정보를 구해야하고, 구한 고객 정보와 주문 정보를 이용해서 룰을 실행해야 한다.
CalculateDiscountService는 고수준 모듈이다.
- 고수준 모듈은 의미 있는 단일 기능을 제공하는 모듈로 ‘가격 할인 계산’이라는 기능을 구현
- 가격 할인 계싼 기능을 구현하려면 고객 정보를 구해야하고 룰을 실행해야 하는데 이 두 기능이 하위 기능이다.
저수준 모듈은 하위 기능을 실제로 구현한 것이다.
- JPA를 이용해서 고객 정보를 읽어오는 모듈과 Drools로 룰을 실행하는 모듈이 저수준 모듈이 된다.

DIP는 저수준 모듈이 고수준 모듈에 의존하도록 바꾼다.

추상화 인터페이스를 사용

public interface RuleDiscounter {
	Money applyRules(Customer customer, List<OrderLine> orderLines);
}

CalculateDiscountService가 RuleDiscounter를 이용하도록 변경
- Drools에 의존하는 코드가 없다

public class CalcuateDiscountService {
	private RuleDiscounter ruleDiscounter;
	
	public CalculateDiscountService(RuleDiscounter ruleDiscounter) {
		this.ruleDiscounter = ruleDiscounter;
	}

	public Money calculateDiscount(List<OrderLine> orderLines, String customerId) {
		Customer customer = findCustomer(customerId);
		return ruleDiscounter.applyRules(customer, orderLines);
	}
}

RuleDiscounter를 상속받아 구현

public class DroolsRuleDiscounter implements RuleDiscounter {
	private KieCountainer kContainer;
	
	public DroolsRuleEngine() {
		KieService ks = KieServices.Factory.get();
		kContainer = ks.getKieClasspathContainer();
	}

	@Override
	public Money applyRules(Customer customer, List<OrderLine> orderLines) {
		KieSession kSession = kContainer.newKieSession("discountSession");
		try {
			...
			kSession.fireAllRules();
		} finally {
			kSession.dispose();
		}
		return money.toImmutableMoney();
	}
}

RuleDiscounter가 출현하면서 바뀐 구조
CalculateDiscountService는 더이상 구현 기술인 Drools에 의존하지 않는다.
- RuleDiscounter 인터페이스에 의존할 뿐
- ‘룰을 이용한 할인 금액 계산’은 고수준 모듈의 개념이므로 RuleDiscounter 인터페이스는 고수준 모듈에 속한다.
- DroolsRuleDiscounter는 고수준의 하위 기능인 RuleDiscounter를 구현한 것이므로 저수준 모듈에 속한다.

DIP를 적용하면 저수준 모듈이 고수준 모듈에 의존하게 된다.
- 고수준 모듈이 저수준 모듈을 사용하려면 고수준 모듈이 저수준 모듈에 의존해야 하는데, 반대로 저수준 모듈이 고수준 모듈에 의존한다고 해서 이를 DIP(Dependency Inversion Principle, 의존 역전 원칙)이라 부른다.
DIP를 적용하면 다른 영역인 인프라스트럭처 영역에 의존할 떄 발생했던 두가지 문제인 구현 교체가 어렵다는 것과 테스트가 어려운 문제를 해소할 수 있다.

고수준 모듈은 더 이상 저수준 모듈에 의존하지 않고 구현을 추상화한 인터페이스에 의존할 수 있다.

구현 기술이 변경되더라도 저수준 구현 객체를 생성하는 코드만 변경하면 된다.

// 기존 코드
RuleDiscounter roleDiscounter = new DroolsRuleDiscounter();
CalculateDiscountService disService = new CalculateDiscountService(roleDiscounter);

// 구현 기술 변경 
RuleDiscounter roleDiscounter = new SimpleRuleDiscounter();
CalculateDiscountService disService = new CalculateDiscountService(roleDiscounter);

스프링과 같은 의존 주입을 지원하는 프레임워크를 사용하면 설정 코드를 수정해서 쉽게 구현체를 변경할 수 있다.
CalculateDiscountService가 제대로 동작하는지 테스트하려면 CustomerRepository와 RuleDiscounter를 구현한 객체가 필요하다.
- CacluateDiscountService가 저수준 모듈에 직접 의존했다면 저수준 모듈이 만들어지기 전까진 테스트를 할 수 없음
- 인터페이스에 의존함으로 대역 객체를 사용해서 테스트를 진행 할수 있다.
- 실제 구현 대신 스텁이나 모의 객체와 같은 테스트 목적의 대역을 사용하여 거의 모든 상황을 테스트할 수 있다.
```
public class CalculateDiscountServiceTest {
	@Test
	public void noCustomer_thenExcetionShouldBeThrown() {
		CustomerRepository stubRepo = mock(CustomerRepository.class);
		when(stubRepo.findById("noCustId")).thenRetrun(null);

		RuleDiscounter stubRule = (cust, lines) -> null;
		
		CalculateDiscountService calDisSvc = new CalculateDiscountService(stbRepo, stubRule);
		assertThrows(NoCustomerException.class, () -> calDisSvc.calculateDiscount(ssomeLines, "noCustId"));
	}
}
```
실제 구현 없이 테스트를 할 수 있는 이유는 DIP를 적용해서 고수준 모듈이 저수준 모듈에 의존하지 않도록 했기 때문이다.

2.3.1 DIP 주의사항

DIP를 잘못 생각하면 단순히 인터페이스와 구현 클래스를 분리하는 정도로 받아드릴 수 있다.
DIP의 핵심은 고수준 모듈이 저수준 모듈의 의존하지 않도록 하기 위함이다.
잘못된 구조
- 도메인 영역은 구현 기술을 다루는 인프라스트럭처 영역에 의존하고 있다.
- 고수준 모듈이 저수준 모듈에 의존하고 있다.
DIP를 적용할 때 하위 기능을 추상화한 인터페이스는 고수준 모듈 관점에서 도출한다.
- CalculateDiscountService는 할인 금액을 구하기 위한 룰 엔진을 사용하는지 직접 연산하는지 중요하지 않다.
- 규칙에 따라 할인 금액을 계산하는 것이 중요
- ‘할인 금액 계산’을 추상화한 인터페이스는 저수준 모듈이 아닌 고수준 모듈에 위치한다.

2.3.2 DIP와 아키텍처

인프라스트럭처 영역은 구현 기술을 다루는 저수준 모듈이고 응용 영역과 도메인 영역은 고수준 모듈이다.
인프라스트럭처 계층이 가장 하단에 위치하는 계층형 구조와 달리 아키텍처에 DIP를 적용하면 인프라스트럭처 영역이 응용 영역와 도메인 영역에 의존하는 구조가 된다.
인프라스트럭처에 위치한 클래스가 도메인이나 응용 영역에 정의한 인터페이스를 상속받아 구현하는 구조가 되므로 도메인과 응용 영역에 대한 영향을 주지 않거나 최소화하면서 구현 기술을 변경하는 것이 가능하다.
주문 시 통지 방식에 SMS를 추가해야 한다는 요구사항이 들어왔을 때 OrderService는 변경할 필요가 없다.
- 두 통지 방식을 함께 제공하는 Notifier 구현 클래스를 인프라스트럭처 영역에 추가하면 된다.
마이바티스 대신 JPA를 구현 기술로 사용하고 싶다면 JPA를 이용한 OrderRepository 구현 클래스를 인프라 스트럭처 영역에 추가하면 된다.

2.4 도메인 영역의 주요 구성요소

도메인 영역을 구성하는 요소요소 설명

엔티티 ENTITY	고유 식별자를 갖는 객체로 자신의 라이프 사이클을 갖는다. Order, Member, Product와 같이 도메인의 고유한 개념을 표현한다. 도메인 모델의 데이터를 포함하며 해당 데이터와 관련된 기능을 함께 제공
밸류 VALUE	고유 식별자를 갖지 않는 객체로 주로 개념적으로 하나의 값을 표현할 때 사용된다. 배송지 주소를 표현하기 위한 Address나 구매한 금액을 위한 Money와 같은 타입이 밸류 타입이다. 엔티티의 속성으로 사용할 뿐만 아니라 다른 밸류 타입의 속성도 사용할 수 있다.
애그리거트 AGGREGATE	애그리거트는 연관된 엔티티와 밸류 객체를 개념적으로 하나로 묶는 것이다. 주문과 관련된 Order 엔티티, OrderLine 밸류, Orderer 밸류 객체를 주문 애그리거트로 묶을 수 있다.
리포지터리 REPOSITORY	도메인 모델의 영속성을 처리한다. DBMS 테이블에서 엔티티 객체를 로딩하거나 저장하는 기능을 제공
도메인 서비스 DOMAIN SERVICE	특정 엔티티에 속하지 않는 도메인 로직을 제공한다. ‘할인 금액 계산’은 상품, 쿠폰, 회원 등급, 구매 금액 등 다양한 조건을 이용해서 구현하게 되는데 이렇게 도메인 로직이 여러 엔티티와 밸류를 필요로 하면 도메인 서비스에 로직을 구현

2.4.1 엔티티와 밸류

엔티티와 도메인 모델의 가장 큰 차이점은 도메인 모델의 엔티티는 데이터와 함께 도메인 기능을 함께 제공한다는 점
- 주문을 표현하는 엔티티는 주문과 관련된 데이터뿐만 아니라 배송지 주소 변경을 위한 기능을 함께 제공
```
public class Order {
	private OrderNo number;
	private Orderer orderer;
	private ShippingInfo shippingInfo;
	
	// 도메인 모델 엔티티는 도메인 기능도 함께 제공
	public void shangeShippingInfo(ShippingInfo newShippingInfo) {
		...	
	}
}
```
도메인 모델의 엔티티는 단순히 데이터를 담고 있는 데이터 구조라기보다는 데이터와 함께 기능을 제공하는 객체
도메인 관점에서 기능을 구현하고 기능 구현을 캡슐화해서 데이터가 임의로 변경되는 것을 막는다.
도메인 모델의 엔티티는 두 개 이상의 데이터가 개념적으로 하나인 경우 밸류 타입을 이용해서 표현할 수 있다
- Orderer는 밸류 타입으로 주문자 이름과 이메일 데이터를 포함할 수 있다.
```
public class Orderer {
	private String name;
	private String email;
}
```
RDBMS와 같은 관계형 데이터베이스는 밸류 타입을 재대로 표현하기 힘들다.
- Ordere의 개별 데이터를 저장하거나 밸로 테이블로 분리해서 저장해야 한다.
- 한 테이블에 주문자 정보 함께 넣기
  - 주문자라는 개념이 들어나지 않고 주문자의 개별 데이터만 드러난다.
- 다른 테이블에 주문자 정보 넣기
  - 주문자 데이터를 별도 테이블에 저장했지만 이것은 테이블의 엔티티에 가까우며 밸류 타입의 의미가 드러나지 않는다.

밸류는 불변으로 구현할 것을 권장

엔티티의 밸류 타입 데이터를 변경할 떄는 객체 자체를 완전히 교체한다는 것을 의미

public class Order {
	private ShippingInfo shippingInfo;
	
	public void shangeShippingInfo(ShippingInfo newShippingInfo) {
		checkShippingInfoChangeable();
		setShippingInfo(newShippingInfo);
	}

	private void setShippingInfo(ShippingInfo newShippingInfo) {
		if (newShippingInfo == null) {
			throw new IllegalArgumentException();
		}
		this.shippingInfo = newShippingInfo;
	}
}

2.4.2 애그리거트

도메인이 커질수록 개발할 도메인 모델도 커지면서 많은 엔티티와 밸류가 출현한다.
도메인 모델이 복잡해지면 개발자가 전체 구조가 아닌 한 개 엔티티와 밸류에만 집중하는 상황이 발생한다.
- 상위 수준에서 모델을 관리하지 않고 개별 요소에만 초점을 맞추다 보면, 큰 수준에서 모델을 이해하지 못해 큰 틀에서 모델은 관리할 수 없는 상황에 빠질 수 있다.
도메인 모델에 전체 구조를 이해하는데 도움이 되는 것이 바로 애그리거트(AGGREGATE)이다.
애그리거트는 관련 객체를 하나로 묶은 군집이다.
- 모메인 개념은“주문”, “배송지 정보”, “주문자”, “주문 목록”, “총 결제 금액”의 하위 모델로 구성된다.
- 하위 내념을 표현한 모델을 하나로 묶어서 “주문”이라는 상위 개념으로 표현할 수 있다.
애그리거트를 사용하면 개별 객체가 아닌 관련 객체를 묶어서 객체 군집 단위로 모델을 바라볼 수 있게 된다.
- 개별 객체 간의 관계가 아닌 애그리거트 간의 관계로 도메인 모델을 이해하고 구현하고, 큰 틀에서 도메인 모델을 관리할 수 있다.
애그리거트는 군집에 속한 객체를 관리하는 루트 엔티티를 갖는다.
- 루트 엔티티는 애그리거트에 속해 있는 엔티티와 밸류 객체를 이용해서 애그리거트가 구현해야 할 기능을 제공
- 애그리거트를 사용하는 코드는 애그리거트 루트가 제공하는 기능을 실행
- 애그리거트 루트를 통해 간접적으로 애그리거트 내의 다른 엔티티나 밸류 객체에 접근
- 애그리거트의 내부 구현을 숨겨서 애그리거트 단위로 구현을 캡슐화할 수 있도록 돕는다.
주문 애그리거트
- 애그리거트 루트인 Order는 주문 도메인 로직에 맞게 애그리거트의 상태를 관리
- Order의 배송지 정보 변경 기능은 배송지를 변경할 수 있는지를 확인한 위에 배송지 정보를 변경
- 주문 애그리거트는 Order를 통하지 않고 ShippingInfo를 변경할 수 있는 방법을 제공하지 않는다.
  - 배송지를 변경하려면 루트 엔티티인 Order를 사용해야 하므로 배소지 정보를 변경할 때는 Order가 구현한 도메인 로직을 항상 따르게 된다.
애그리거트를 구현할 때는 고려할 것이 많다.
- 애그리거트를 어떻게 구성했느냐에 따라 구현이 복잡해지기도 하고
- 트랜잭션 범위가 달라지기도 한다.

2.4.3 리포지터리

도메인 객체를 지속적으로 사용하려면 RDBMS, NoSQL, 로컬 파일과 같은 물리적인 저장소에 도메인 객체를 보관해야 한다.
- 이를 위한 도메인 모델이 리포지터리(Repository)이다.
엔티티나 밸류가 요구사항에 도출되는 도메인 모델이라면 리포리터리는 구현을 위한 도메인 모델이다.
리포지터리는 애그리거트 단위로 도메인 객체를 저장하고 조회하는 기능을 정의
- OrderRepository의 메서드를 보면 대상을 찾고 저장하는 단위가 애그리거트 루트인 Order인 것을 알 수 있다.
- Order는 애그리거트에 속한 모든 객체를 포함하고 있으므로 결과적으로 애그리거트 단위로 저장하고 조회한다.
```
public interface OrderRepository {
	Order findByNumber(OrderNumber number);
	void save(Order order);
	void delete(Order order);
}
```
도메인 모델을 사용해야 하는 코드는 리포지터리를 통해서 도메인 객체를 구한 뒤에 도메인 객체의 기능을 실행
public class CancelOrderService { private OrderRepository orderRepository; public void cancel(OrderNumber number) { Order order = orderRepository.findByNumber(number); if (order == null) { throw new OrderNotFoundException(orderId); } order.cancel(); } }
도메인 모델 관점에서 OrderRepository는 도메인 객체를 영속화하는 데 필요한 기능을 추상화 한것으로 고수준 모듈에 속한다.
기반 기술을 이용해서 OrderRepository를 구현한 클래스는 저수준 모듈로 인프라스트럭처 영역에 속한다.
전체 모듈 구조
응용 서비스는 의존 주입과 같은 방식을 사용해서 실제 리포지터리 구현 객체에 접근
응용 서비스와 리포지터리는 밀접한 연관이 있다.
- 응용 서비스는 필요한 도메인 객체를 구하거나 저장할 때 리포지터리를 사용한다.
- 응용 서비스는 트랜잭션을 관리하는데, 트랜잭션 처리는 리포지터리 구현 기술의 영향을 받는다.
리포지터리를 사용하는 주체가 응용 서비스이기 때문에 리포지터리는 응용 서비스가 필요로 하는 메서드를 제공한다.
- 애그리거트를 저장하는 메서드
- 애그리거트 루트 식별자로 애그리거트를 조회하는 메서드

2.5 요청 처리 흐름

표현 영역은 사용자가 전송한 데이터 형식이 올바른지 검사하고 문제가 없다면 데이터를 이용해서 응용 서비스에 기능 실행을 위임
표현 영역은 사용자가 전송한 데이터를 응용 서비스가 요구하는 형식으로 변환해서 전달
요청 처리 흐름
- 웹 브라우저에서 기능 실행 요청
- 표현 영역에 해당하는 컨트롤러는 HTTP 요청 파라미터를 응용 서비스가 필요로 하는 데이터로 변환 해서 응용 서비스의 인자로 전달
- 응용 서비스는 도메인 모델을 이용해서 로직 실행
- 도메인 객체를 리포지터리에서 가져와 실행하거나 신규 도메인 객체를 생성해 리포지터리에 저장
“예매하기”나 “예매 취소”와 같은 기능을 제공하는 응용 서비스는 도메인의 상태를 변경하므로 변경 상태가 물리 저장소에 올바르게 반영되도록 트랜잭션을 관리 해야한다.
- 스프링 프레임워크를 사용한다면 @Transactional 애너테이션을 이용해 트랜잭션을 처리할 수 있다.
```
public class CancelOrderService {
	private OrderRepository orderRepository;
	
	@Transactional
	public void cancel(OrderNumber number) {
		Order order = orderRepository.findByNumber(number);
		if (order == null) {
			throw new NoOrderException(number);
		}
		order.cancel()
	}
}
```

2.6 인프라스트럭처 개요

인프라스트럭처는 표현 영역, 응용 영역, 도메인 영역을 지원한다.
도메인 영역과 응용 영역에서 인프라스트럭처의 기능을 직접 사용하는 것보다 두 영역에서 정의한 인터페이스를 인프라스트럭처 영역에서 구현하는 것이 시스템을 더 유연하고 테스트하기 쉽게 만들어 준다.
무조건 인프라스트럭처에 대한 의존성을 없앨 필요는 없다.
- 스프링을 사용할 경우 응용 서비스는 트랜잭션 처리를 위해 @Transactional을 사용하는 것이 편리하다.
- 영속성 처리를 위해 JPA를 사용할 경우 @Entity나 @Table과 같은 JPA 전용 애너테이션을 도메인 모델 클래스에서 사용하는 것이 XML 매핑 설정을 이용하는 것보다 편리하다.
구현의 편리함은 DIP가 주는 다른 장점만큼 중요하기 때문에 DIP의 장점을 해치지 않는 범위에서 응용 영역과 도메인 영역에서 구현 기술에 대한 의존을 가져가는 것이 나쁘지 않다고 생각한다.
응용 영역과 도메인 영역이 인프라스트럭처에 대한 의존을 완전히 갖지 않도록 시도하는 것은 구현을 더 복잡하고 어렵게 만들 수 있다.
- @Transactional을 사용하면 한 줄로 트랙잭션을 처리할 수 있는데 코드에서 스프링에 대한 의존을 없애려면 복잡한 스프링 설정을 사용해야 한다.
- 의존은 없앴지만 특별히 테스트를 더 쉽게 할 수 있다거나 유연함을 증가시켜 주지 못한다.
- 설정만 복잡해지고 개발 시간만 늘어난다.
표현 영역은 항상 인프라스트럭처 영역과 쌍을 이룬다.
- 스프링 MVC를 사용해서 웹 요청을 처리하려면 스프링이 제공하는 MVC 프레임워크에 맞게 표현 영역을 구현
- Vert.x를 사용해서 Rest API 서버를 구축하려면 Vert.x에 맞게 웹 요청 처리 부분을 구현

2.7 모듈 구성

아키텍처의 각 영역은 별도 패키지에 위치한다.
패키지 구성 규칙에 정답이 존재하는 것은 안지만 영역별로 모듈이 위치할 패키지를 구성할 수 있을 것 이다.
도메인이 크면 하위 도메인으로 나누고 하위 도메인마다 별도 패키지를 구성한다.
도메인 모듈은 도메인에 속한 애그리거트를 기준으로 다시 패키지를 구성한다.
- 카탈로그 하위 도메인이 상품 애그리거트와 카테고리 애그리커트로 구성될 경우 도메인을 두 개의 하위 패키지로 구성할 수 있다.
애그리거트, 모델, 리포지터리는 같은 패키지에 위치시킨다.
- Order, OrderLine, Orderer, OrderRepository 등은 com.myshop.order.domain 패키지에 위치시킨다.
도메인이 복잡하면 도메인 모델과 도메인 서비스를 별도 패키지에 위치시킬 수도 있다.
- com.myshop.order.domain.order: 애그리거트 위치
- com.myshop.order.domain.service: 도메인 서비스 위치
응용 서비스도 도메인 별로 패키지를 구분할 수 있다.
- com.myshop.catalog.application.product
- com.myshop.catalog.application.category
모듈 구조를 얼마나 세분하게해야 하는지에 대한 정해진 규칙은 없다.
한 패키지에 너무 많은 타입이 몰려서 코드를 찾을 때 불편할 정도만 아니면 된다.

2.1 네 개의 영역

“표현”, “응용”, “도메인”, “인프라스트럭처”는 아키텍처를 설계할 때 출현하는 전형적인 네 가지 영역
- 표현 영역
  - 사용자의 요청을 받아 응용 영역에 전달, 응용 영역의 처리 결과를 사용자에게 전달
  - 스프링 MVC 프레임워크가 표현 영역의 기술
- 응용 영역
  - 표현 영역을 통해 사용자의 요청을 전달받은 응용 영역은 시스템이 사용자에게 제공해야할 기능을 구현
  - “주문 등록”, “주문 취소”, “상품 상세 조회” 등의 기능을 예로 들수 있다.
  - 기능을 구현하기 위한 도메인 영역의 도메인 모델을 사용
  - “주문 취소” 기능을 제공하는 응용 서비스를 도메인 모델을 사용해서 기능 구현이 가능
  - public class CancelOrderService { @Transactional public void cancelOrder(String orderId) { Order order = findOrderById(orderId); if (order == null) { throw new OrderNotFoundException(orderId); } order.cancel(); } }
  - 로직을 직접 수행하기보다는 도메인 모델에 로직 수행을 위임
    - “주문 취소” 로직을 직접 구현하지 않고 Order 객체에 취소 처리를 위임 하고 있다
- 도메인 영역
  - Order, OrderLine, ShippingInfo와 같은 도메인 모델
  - 도메인 모델은 핵심 로직을 구현한다.
    - “배송지 변경”, “결제 완료”, “주문 총액 계산”과 같은 핵심 로직을 도메인 모델에 구현한다.
- 인프라스트럭처 영역
  - 구현 기술에 대한 것을 다룬다
  - RDBMS 연동, 메시징 큐에 메시지 전송과 수신, 몽고DB나 레디스의 데이터 연동 처리 등
  - 논리적인 개념을 표현하기보다는 실제 구현을 다룬다
  - 도메인 영역, 응용 영역, 표현 영역은 구현 기술을 사용한 코드를 직접 만들지 않는다.
    - 인프라스트럭처 영역에서 제공하는 기능을 사용해서 필요한 기능을 개발

2.2 계층 구조 아키텍처

네 영역을 구성할 때 많이 사용하는 아키텍처가 그림과 같은 계층 구조이다.
- 표현 영역과 응용 영역은 도메인 영역을 사용
- 도메인 영역은 인프라스트럭처 영역을 사용
도메인의 복잡도에 따라 응용과 도메인을 분리하기도 하고 한 계층으로 합치기도 하지만 전체적인 아키텍처는 계층 구조를 따른다.
계층 구조는 특성상 상위 계층에서 하위 계층으로의 의존만 존재하고 하위 계층은 상위 계층에 의존하지 않는다.
계층 구조를 엄격하게 적용한다면 상위 계층은 바로 아래의 계층에만 의존을 가져야 하지만 구현의 편리함을 위해 계층 구조를 유연하게 적용하기도 한다.
응용 영역과 도메인 영역은 DB나 외부 시스템 연동을 위해 인프라스트럭처의 기능을 사용하므로 계층 구조를 사용하는 것이 직관적으로 이해하기 쉽다.
- 표현, 응용, 도메인 계층이 상세한 구현 기술을 다루는 인프라스트럭처 계층에 종속된다

도메인의 가격 계산 규칙의 예제

할인 금액을 계산하기 위해 Drools라는 룰 엔진을 사용해서 계산 로직을 수행하는 인프라스트럭처 영역의 코드를 만들어 보자

public class DroolsRuleEngine {
	private KieContainer kContainer;

	public DroolsRuleEngine() {
		KieServices ks = KieServices.Factory.get();
		kContainer = ks.getKieClasspathContainer();		
	}

	public void evalute(String sessionName, List<?> facts) {
		KiSession kSession = kContainer.newKieSession(sessionName);
		try {
			facts.forEach(x -> kSession.insert(x));
			kSession.fireAllRules();
		} finaly {
			kSession.dispose();
		}
	}
}

응용 영역은 가격 계산을 위해 인프라스트럭처 영역의 DroolsRuleEngine을 사용

public class CalcuateDiscountService {
	private DroolsRuleEngine ruleEngine;
	
	public CalculateDiscountService() {
		ruleEngine = new DroolsRuleEngine();
	}

	public Money calculateDiscount(List<OrderLine> orderLines, String customerId) {
		Customer customer = findCustomer(customerId);
		
		MutableMoney money = new MutableMoney(0);
		List<?> facts = Arrays.asList(customer, money);
		facts.addAll(orderLines);
		ruleEngine.evalute("discountCalculation", facts);
		return money.toImmutableMoney();
	}
}

CalculateDiscountService가 동작은 하겠지만 두가지 문제를 안고 있다.
- CalculateDiscountService를 테스트하기 어렵다
  - RuleEngine이 완벽하게 동작해야 한다.
  - RuleEngine 클래스와 관련 설정 파일 모두 만든 이후에 CalculateDiscountService 를 확인할 수 있다.
- 구현 방식을 변경하기 어렵다
  - ‘discountCalculation’ 문자열은 Drools의 세션 이름을 의미한다.
  - 세션 이름을 변경하면 CalculateDiscountService 코드도 함께 변경해야 한다.
CalculateDiscountService가 겉으로는 인프라스트럭처의 기술에 직접적인 의존을 하지 않는 것처럼 보여도 실제로는 Drools라는 인프라스트럭처 영역의 기술에 완전하게 의존하고 있다.
인프라스트럭처에 의존하면 ‘테스트 어려움’과 ‘기능 확장 어려움’이라는 두가지 문제가 발생한다.
- 문제 해답은 DIP에 있다.

2.3 DIP

가격 할인 계산을 하려면 고객 정보를 구해야하고, 구한 고객 정보와 주문 정보를 이용해서 룰을 실행해야 한다.
CalculateDiscountService는 고수준 모듈이다.
- 고수준 모듈은 의미 있는 단일 기능을 제공하는 모듈로 ‘가격 할인 계산’이라는 기능을 구현
- 가격 할인 계싼 기능을 구현하려면 고객 정보를 구해야하고 룰을 실행해야 하는데 이 두 기능이 하위 기능이다.
저수준 모듈은 하위 기능을 실제로 구현한 것이다.
- JPA를 이용해서 고객 정보를 읽어오는 모듈과 Drools로 룰을 실행하는 모듈이 저수준 모듈이 된다.

DIP는 저수준 모듈이 고수준 모듈에 의존하도록 바꾼다.

추상화 인터페이스를 사용

public interface RuleDiscounter {
	Money applyRules(Customer customer, List<OrderLine> orderLines);
}

CalculateDiscountService가 RuleDiscounter를 이용하도록 변경
- Drools에 의존하는 코드가 없다

public class CalcuateDiscountService {
	private RuleDiscounter ruleDiscounter;
	
	public CalculateDiscountService(RuleDiscounter ruleDiscounter) {
		this.ruleDiscounter = ruleDiscounter;
	}

	public Money calculateDiscount(List<OrderLine> orderLines, String customerId) {
		Customer customer = findCustomer(customerId);
		return ruleDiscounter.applyRules(customer, orderLines);
	}
}

RuleDiscounter를 상속받아 구현

public class DroolsRuleDiscounter implements RuleDiscounter {
	private KieCountainer kContainer;
	
	public DroolsRuleEngine() {
		KieService ks = KieServices.Factory.get();
		kContainer = ks.getKieClasspathContainer();
	}

	@Override
	public Money applyRules(Customer customer, List<OrderLine> orderLines) {
		KieSession kSession = kContainer.newKieSession("discountSession");
		try {
			...
			kSession.fireAllRules();
		} finally {
			kSession.dispose();
		}
		return money.toImmutableMoney();
	}
}

RuleDiscounter가 출현하면서 바뀐 구조
CalculateDiscountService는 더이상 구현 기술인 Drools에 의존하지 않는다.
- RuleDiscounter 인터페이스에 의존할 뿐
- ‘룰을 이용한 할인 금액 계산’은 고수준 모듈의 개념이므로 RuleDiscounter 인터페이스는 고수준 모듈에 속한다.
- DroolsRuleDiscounter는 고수준의 하위 기능인 RuleDiscounter를 구현한 것이므로 저수준 모듈에 속한다.

DIP를 적용하면 저수준 모듈이 고수준 모듈에 의존하게 된다.
- 고수준 모듈이 저수준 모듈을 사용하려면 고수준 모듈이 저수준 모듈에 의존해야 하는데, 반대로 저수준 모듈이 고수준 모듈에 의존한다고 해서 이를 DIP(Dependency Inversion Principle, 의존 역전 원칙)이라 부른다.
DIP를 적용하면 다른 영역인 인프라스트럭처 영역에 의존할 떄 발생했던 두가지 문제인 구현 교체가 어렵다는 것과 테스트가 어려운 문제를 해소할 수 있다.

고수준 모듈은 더 이상 저수준 모듈에 의존하지 않고 구현을 추상화한 인터페이스에 의존할 수 있다.

구현 기술이 변경되더라도 저수준 구현 객체를 생성하는 코드만 변경하면 된다.

// 기존 코드
RuleDiscounter roleDiscounter = new DroolsRuleDiscounter();
CalculateDiscountService disService = new CalculateDiscountService(roleDiscounter);

// 구현 기술 변경 
RuleDiscounter roleDiscounter = new SimpleRuleDiscounter();
CalculateDiscountService disService = new CalculateDiscountService(roleDiscounter);

스프링과 같은 의존 주입을 지원하는 프레임워크를 사용하면 설정 코드를 수정해서 쉽게 구현체를 변경할 수 있다.
CalculateDiscountService가 제대로 동작하는지 테스트하려면 CustomerRepository와 RuleDiscounter를 구현한 객체가 필요하다.
- CacluateDiscountService가 저수준 모듈에 직접 의존했다면 저수준 모듈이 만들어지기 전까진 테스트를 할 수 없음
- 인터페이스에 의존함으로 대역 객체를 사용해서 테스트를 진행 할수 있다.
- 실제 구현 대신 스텁이나 모의 객체와 같은 테스트 목적의 대역을 사용하여 거의 모든 상황을 테스트할 수 있다.
```
public class CalculateDiscountServiceTest {
	@Test
	public void noCustomer_thenExcetionShouldBeThrown() {
		CustomerRepository stubRepo = mock(CustomerRepository.class);
		when(stubRepo.findById("noCustId")).thenRetrun(null);

		RuleDiscounter stubRule = (cust, lines) -> null;
		
		CalculateDiscountService calDisSvc = new CalculateDiscountService(stbRepo, stubRule);
		assertThrows(NoCustomerException.class, () -> calDisSvc.calculateDiscount(ssomeLines, "noCustId"));
	}
}
```
실제 구현 없이 테스트를 할 수 있는 이유는 DIP를 적용해서 고수준 모듈이 저수준 모듈에 의존하지 않도록 했기 때문이다.

2.3.1 DIP 주의사항

DIP를 잘못 생각하면 단순히 인터페이스와 구현 클래스를 분리하는 정도로 받아드릴 수 있다.
DIP의 핵심은 고수준 모듈이 저수준 모듈의 의존하지 않도록 하기 위함이다.
잘못된 구조
- 도메인 영역은 구현 기술을 다루는 인프라스트럭처 영역에 의존하고 있다.
- 고수준 모듈이 저수준 모듈에 의존하고 있다.
DIP를 적용할 때 하위 기능을 추상화한 인터페이스는 고수준 모듈 관점에서 도출한다.
- CalculateDiscountService는 할인 금액을 구하기 위한 룰 엔진을 사용하는지 직접 연산하는지 중요하지 않다.
- 규칙에 따라 할인 금액을 계산하는 것이 중요
- ‘할인 금액 계산’을 추상화한 인터페이스는 저수준 모듈이 아닌 고수준 모듈에 위치한다.

2.3.2 DIP와 아키텍처

인프라스트럭처 영역은 구현 기술을 다루는 저수준 모듈이고 응용 영역과 도메인 영역은 고수준 모듈이다.
인프라스트럭처 계층이 가장 하단에 위치하는 계층형 구조와 달리 아키텍처에 DIP를 적용하면 인프라스트럭처 영역이 응용 영역와 도메인 영역에 의존하는 구조가 된다.
인프라스트럭처에 위치한 클래스가 도메인이나 응용 영역에 정의한 인터페이스를 상속받아 구현하는 구조가 되므로 도메인과 응용 영역에 대한 영향을 주지 않거나 최소화하면서 구현 기술을 변경하는 것이 가능하다.
주문 시 통지 방식에 SMS를 추가해야 한다는 요구사항이 들어왔을 때 OrderService는 변경할 필요가 없다.
- 두 통지 방식을 함께 제공하는 Notifier 구현 클래스를 인프라스트럭처 영역에 추가하면 된다.
마이바티스 대신 JPA를 구현 기술로 사용하고 싶다면 JPA를 이용한 OrderRepository 구현 클래스를 인프라 스트럭처 영역에 추가하면 된다.

2.4 도메인 영역의 주요 구성요소

도메인 영역을 구성하는 요소요소 설명

엔티티 ENTITY	고유 식별자를 갖는 객체로 자신의 라이프 사이클을 갖는다. Order, Member, Product와 같이 도메인의 고유한 개념을 표현한다. 도메인 모델의 데이터를 포함하며 해당 데이터와 관련된 기능을 함께 제공
밸류 VALUE	고유 식별자를 갖지 않는 객체로 주로 개념적으로 하나의 값을 표현할 때 사용된다. 배송지 주소를 표현하기 위한 Address나 구매한 금액을 위한 Money와 같은 타입이 밸류 타입이다. 엔티티의 속성으로 사용할 뿐만 아니라 다른 밸류 타입의 속성도 사용할 수 있다.
애그리거트 AGGREGATE	애그리거트는 연관된 엔티티와 밸류 객체를 개념적으로 하나로 묶는 것이다. 주문과 관련된 Order 엔티티, OrderLine 밸류, Orderer 밸류 객체를 주문 애그리거트로 묶을 수 있다.
리포지터리 REPOSITORY	도메인 모델의 영속성을 처리한다. DBMS 테이블에서 엔티티 객체를 로딩하거나 저장하는 기능을 제공
도메인 서비스 DOMAIN SERVICE	특정 엔티티에 속하지 않는 도메인 로직을 제공한다. ‘할인 금액 계산’은 상품, 쿠폰, 회원 등급, 구매 금액 등 다양한 조건을 이용해서 구현하게 되는데 이렇게 도메인 로직이 여러 엔티티와 밸류를 필요로 하면 도메인 서비스에 로직을 구현

2.4.1 엔티티와 밸류

엔티티와 도메인 모델의 가장 큰 차이점은 도메인 모델의 엔티티는 데이터와 함께 도메인 기능을 함께 제공한다는 점
- 주문을 표현하는 엔티티는 주문과 관련된 데이터뿐만 아니라 배송지 주소 변경을 위한 기능을 함께 제공
```
public class Order {
	private OrderNo number;
	private Orderer orderer;
	private ShippingInfo shippingInfo;
	
	// 도메인 모델 엔티티는 도메인 기능도 함께 제공
	public void shangeShippingInfo(ShippingInfo newShippingInfo) {
		...	
	}
}
```
도메인 모델의 엔티티는 단순히 데이터를 담고 있는 데이터 구조라기보다는 데이터와 함께 기능을 제공하는 객체
도메인 관점에서 기능을 구현하고 기능 구현을 캡슐화해서 데이터가 임의로 변경되는 것을 막는다.
도메인 모델의 엔티티는 두 개 이상의 데이터가 개념적으로 하나인 경우 밸류 타입을 이용해서 표현할 수 있다
- Orderer는 밸류 타입으로 주문자 이름과 이메일 데이터를 포함할 수 있다.
```
public class Orderer {
	private String name;
	private String email;
}
```
RDBMS와 같은 관계형 데이터베이스는 밸류 타입을 재대로 표현하기 힘들다.
- Ordere의 개별 데이터를 저장하거나 밸로 테이블로 분리해서 저장해야 한다.
- 한 테이블에 주문자 정보 함께 넣기
  - 주문자라는 개념이 들어나지 않고 주문자의 개별 데이터만 드러난다.
- 다른 테이블에 주문자 정보 넣기
  - 주문자 데이터를 별도 테이블에 저장했지만 이것은 테이블의 엔티티에 가까우며 밸류 타입의 의미가 드러나지 않는다.

밸류는 불변으로 구현할 것을 권장

엔티티의 밸류 타입 데이터를 변경할 떄는 객체 자체를 완전히 교체한다는 것을 의미

public class Order {
	private ShippingInfo shippingInfo;
	
	public void shangeShippingInfo(ShippingInfo newShippingInfo) {
		checkShippingInfoChangeable();
		setShippingInfo(newShippingInfo);
	}

	private void setShippingInfo(ShippingInfo newShippingInfo) {
		if (newShippingInfo == null) {
			throw new IllegalArgumentException();
		}
		this.shippingInfo = newShippingInfo;
	}
}

2.4.2 애그리거트

도메인이 커질수록 개발할 도메인 모델도 커지면서 많은 엔티티와 밸류가 출현한다.
도메인 모델이 복잡해지면 개발자가 전체 구조가 아닌 한 개 엔티티와 밸류에만 집중하는 상황이 발생한다.
- 상위 수준에서 모델을 관리하지 않고 개별 요소에만 초점을 맞추다 보면, 큰 수준에서 모델을 이해하지 못해 큰 틀에서 모델은 관리할 수 없는 상황에 빠질 수 있다.
도메인 모델에 전체 구조를 이해하는데 도움이 되는 것이 바로 애그리거트(AGGREGATE)이다.
애그리거트는 관련 객체를 하나로 묶은 군집이다.
- 모메인 개념은“주문”, “배송지 정보”, “주문자”, “주문 목록”, “총 결제 금액”의 하위 모델로 구성된다.
- 하위 내념을 표현한 모델을 하나로 묶어서 “주문”이라는 상위 개념으로 표현할 수 있다.
애그리거트를 사용하면 개별 객체가 아닌 관련 객체를 묶어서 객체 군집 단위로 모델을 바라볼 수 있게 된다.
- 개별 객체 간의 관계가 아닌 애그리거트 간의 관계로 도메인 모델을 이해하고 구현하고, 큰 틀에서 도메인 모델을 관리할 수 있다.
애그리거트는 군집에 속한 객체를 관리하는 루트 엔티티를 갖는다.
- 루트 엔티티는 애그리거트에 속해 있는 엔티티와 밸류 객체를 이용해서 애그리거트가 구현해야 할 기능을 제공
- 애그리거트를 사용하는 코드는 애그리거트 루트가 제공하는 기능을 실행
- 애그리거트 루트를 통해 간접적으로 애그리거트 내의 다른 엔티티나 밸류 객체에 접근
- 애그리거트의 내부 구현을 숨겨서 애그리거트 단위로 구현을 캡슐화할 수 있도록 돕는다.
주문 애그리거트
- 애그리거트 루트인 Order는 주문 도메인 로직에 맞게 애그리거트의 상태를 관리
- Order의 배송지 정보 변경 기능은 배송지를 변경할 수 있는지를 확인한 위에 배송지 정보를 변경
- 주문 애그리거트는 Order를 통하지 않고 ShippingInfo를 변경할 수 있는 방법을 제공하지 않는다.
  - 배송지를 변경하려면 루트 엔티티인 Order를 사용해야 하므로 배소지 정보를 변경할 때는 Order가 구현한 도메인 로직을 항상 따르게 된다.
애그리거트를 구현할 때는 고려할 것이 많다.
- 애그리거트를 어떻게 구성했느냐에 따라 구현이 복잡해지기도 하고
- 트랜잭션 범위가 달라지기도 한다.

2.4.3 리포지터리

도메인 객체를 지속적으로 사용하려면 RDBMS, NoSQL, 로컬 파일과 같은 물리적인 저장소에 도메인 객체를 보관해야 한다.
- 이를 위한 도메인 모델이 리포지터리(Repository)이다.
엔티티나 밸류가 요구사항에 도출되는 도메인 모델이라면 리포리터리는 구현을 위한 도메인 모델이다.
리포지터리는 애그리거트 단위로 도메인 객체를 저장하고 조회하는 기능을 정의
- OrderRepository의 메서드를 보면 대상을 찾고 저장하는 단위가 애그리거트 루트인 Order인 것을 알 수 있다.
- Order는 애그리거트에 속한 모든 객체를 포함하고 있으므로 결과적으로 애그리거트 단위로 저장하고 조회한다.
```
public interface OrderRepository {
	Order findByNumber(OrderNumber number);
	void save(Order order);
	void delete(Order order);
}
```
도메인 모델을 사용해야 하는 코드는 리포지터리를 통해서 도메인 객체를 구한 뒤에 도메인 객체의 기능을 실행
public class CancelOrderService { private OrderRepository orderRepository; public void cancel(OrderNumber number) { Order order = orderRepository.findByNumber(number); if (order == null) { throw new OrderNotFoundException(orderId); } order.cancel(); } }
도메인 모델 관점에서 OrderRepository는 도메인 객체를 영속화하는 데 필요한 기능을 추상화 한것으로 고수준 모듈에 속한다.
기반 기술을 이용해서 OrderRepository를 구현한 클래스는 저수준 모듈로 인프라스트럭처 영역에 속한다.
전체 모듈 구조
응용 서비스는 의존 주입과 같은 방식을 사용해서 실제 리포지터리 구현 객체에 접근
응용 서비스와 리포지터리는 밀접한 연관이 있다.
- 응용 서비스는 필요한 도메인 객체를 구하거나 저장할 때 리포지터리를 사용한다.
- 응용 서비스는 트랜잭션을 관리하는데, 트랜잭션 처리는 리포지터리 구현 기술의 영향을 받는다.
리포지터리를 사용하는 주체가 응용 서비스이기 때문에 리포지터리는 응용 서비스가 필요로 하는 메서드를 제공한다.
- 애그리거트를 저장하는 메서드
- 애그리거트 루트 식별자로 애그리거트를 조회하는 메서드

2.5 요청 처리 흐름

표현 영역은 사용자가 전송한 데이터 형식이 올바른지 검사하고 문제가 없다면 데이터를 이용해서 응용 서비스에 기능 실행을 위임
표현 영역은 사용자가 전송한 데이터를 응용 서비스가 요구하는 형식으로 변환해서 전달
요청 처리 흐름
- 웹 브라우저에서 기능 실행 요청
- 표현 영역에 해당하는 컨트롤러는 HTTP 요청 파라미터를 응용 서비스가 필요로 하는 데이터로 변환 해서 응용 서비스의 인자로 전달
- 응용 서비스는 도메인 모델을 이용해서 로직 실행
- 도메인 객체를 리포지터리에서 가져와 실행하거나 신규 도메인 객체를 생성해 리포지터리에 저장
“예매하기”나 “예매 취소”와 같은 기능을 제공하는 응용 서비스는 도메인의 상태를 변경하므로 변경 상태가 물리 저장소에 올바르게 반영되도록 트랜잭션을 관리 해야한다.
- 스프링 프레임워크를 사용한다면 @Transactional 애너테이션을 이용해 트랜잭션을 처리할 수 있다.
```
public class CancelOrderService {
	private OrderRepository orderRepository;
	
	@Transactional
	public void cancel(OrderNumber number) {
		Order order = orderRepository.findByNumber(number);
		if (order == null) {
			throw new NoOrderException(number);
		}
		order.cancel()
	}
}
```

2.6 인프라스트럭처 개요

인프라스트럭처는 표현 영역, 응용 영역, 도메인 영역을 지원한다.
도메인 영역과 응용 영역에서 인프라스트럭처의 기능을 직접 사용하는 것보다 두 영역에서 정의한 인터페이스를 인프라스트럭처 영역에서 구현하는 것이 시스템을 더 유연하고 테스트하기 쉽게 만들어 준다.
무조건 인프라스트럭처에 대한 의존성을 없앨 필요는 없다.
- 스프링을 사용할 경우 응용 서비스는 트랜잭션 처리를 위해 @Transactional을 사용하는 것이 편리하다.
- 영속성 처리를 위해 JPA를 사용할 경우 @Entity나 @Table과 같은 JPA 전용 애너테이션을 도메인 모델 클래스에서 사용하는 것이 XML 매핑 설정을 이용하는 것보다 편리하다.
구현의 편리함은 DIP가 주는 다른 장점만큼 중요하기 때문에 DIP의 장점을 해치지 않는 범위에서 응용 영역과 도메인 영역에서 구현 기술에 대한 의존을 가져가는 것이 나쁘지 않다고 생각한다.
응용 영역과 도메인 영역이 인프라스트럭처에 대한 의존을 완전히 갖지 않도록 시도하는 것은 구현을 더 복잡하고 어렵게 만들 수 있다.
- @Transactional을 사용하면 한 줄로 트랙잭션을 처리할 수 있는데 코드에서 스프링에 대한 의존을 없애려면 복잡한 스프링 설정을 사용해야 한다.
- 의존은 없앴지만 특별히 테스트를 더 쉽게 할 수 있다거나 유연함을 증가시켜 주지 못한다.
- 설정만 복잡해지고 개발 시간만 늘어난다.
표현 영역은 항상 인프라스트럭처 영역과 쌍을 이룬다.
- 스프링 MVC를 사용해서 웹 요청을 처리하려면 스프링이 제공하는 MVC 프레임워크에 맞게 표현 영역을 구현
- Vert.x를 사용해서 Rest API 서버를 구축하려면 Vert.x에 맞게 웹 요청 처리 부분을 구현

2.7 모듈 구성

아키텍처의 각 영역은 별도 패키지에 위치한다.
패키지 구성 규칙에 정답이 존재하는 것은 안지만 영역별로 모듈이 위치할 패키지를 구성할 수 있을 것 이다.
도메인이 크면 하위 도메인으로 나누고 하위 도메인마다 별도 패키지를 구성한다.
도메인 모듈은 도메인에 속한 애그리거트를 기준으로 다시 패키지를 구성한다.
- 카탈로그 하위 도메인이 상품 애그리거트와 카테고리 애그리커트로 구성될 경우 도메인을 두 개의 하위 패키지로 구성할 수 있다.
애그리거트, 모델, 리포지터리는 같은 패키지에 위치시킨다.
- Order, OrderLine, Orderer, OrderRepository 등은 com.myshop.order.domain 패키지에 위치시킨다.
도메인이 복잡하면 도메인 모델과 도메인 서비스를 별도 패키지에 위치시킬 수도 있다.
- com.myshop.order.domain.order: 애그리거트 위치
- com.myshop.order.domain.service: 도메인 서비스 위치
응용 서비스도 도메인 별로 패키지를 구분할 수 있다.
- com.myshop.catalog.application.product
- com.myshop.catalog.application.category
모듈 구조를 얼마나 세분하게해야 하는지에 대한 정해진 규칙은 없다.
한 패키지에 너무 많은 타입이 몰려서 코드를 찾을 때 불편할 정도만 아니면 된다.

2.1 네 개의 영역

“표현”, “응용”, “도메인”, “인프라스트럭처”는 아키텍처를 설계할 때 출현하는 전형적인 네 가지 영역
- 표현 영역
  - 사용자의 요청을 받아 응용 영역에 전달, 응용 영역의 처리 결과를 사용자에게 전달
  - 스프링 MVC 프레임워크가 표현 영역의 기술
- 응용 영역
  - 표현 영역을 통해 사용자의 요청을 전달받은 응용 영역은 시스템이 사용자에게 제공해야할 기능을 구현
  - “주문 등록”, “주문 취소”, “상품 상세 조회” 등의 기능을 예로 들수 있다.
  - 기능을 구현하기 위한 도메인 영역의 도메인 모델을 사용
  - “주문 취소” 기능을 제공하는 응용 서비스를 도메인 모델을 사용해서 기능 구현이 가능
  - public class CancelOrderService { @Transactional public void cancelOrder(String orderId) { Order order = findOrderById(orderId); if (order == null) { throw new OrderNotFoundException(orderId); } order.cancel(); } }
  - 로직을 직접 수행하기보다는 도메인 모델에 로직 수행을 위임
    - “주문 취소” 로직을 직접 구현하지 않고 Order 객체에 취소 처리를 위임 하고 있다
- 도메인 영역
  - Order, OrderLine, ShippingInfo와 같은 도메인 모델
  - 도메인 모델은 핵심 로직을 구현한다.
    - “배송지 변경”, “결제 완료”, “주문 총액 계산”과 같은 핵심 로직을 도메인 모델에 구현한다.
- 인프라스트럭처 영역
  - 구현 기술에 대한 것을 다룬다
  - RDBMS 연동, 메시징 큐에 메시지 전송과 수신, 몽고DB나 레디스의 데이터 연동 처리 등
  - 논리적인 개념을 표현하기보다는 실제 구현을 다룬다
  - 도메인 영역, 응용 영역, 표현 영역은 구현 기술을 사용한 코드를 직접 만들지 않는다.
    - 인프라스트럭처 영역에서 제공하는 기능을 사용해서 필요한 기능을 개발

2.2 계층 구조 아키텍처

네 영역을 구성할 때 많이 사용하는 아키텍처가 그림과 같은 계층 구조이다.
- 표현 영역과 응용 영역은 도메인 영역을 사용
- 도메인 영역은 인프라스트럭처 영역을 사용
도메인의 복잡도에 따라 응용과 도메인을 분리하기도 하고 한 계층으로 합치기도 하지만 전체적인 아키텍처는 계층 구조를 따른다.
계층 구조는 특성상 상위 계층에서 하위 계층으로의 의존만 존재하고 하위 계층은 상위 계층에 의존하지 않는다.
계층 구조를 엄격하게 적용한다면 상위 계층은 바로 아래의 계층에만 의존을 가져야 하지만 구현의 편리함을 위해 계층 구조를 유연하게 적용하기도 한다.
응용 영역과 도메인 영역은 DB나 외부 시스템 연동을 위해 인프라스트럭처의 기능을 사용하므로 계층 구조를 사용하는 것이 직관적으로 이해하기 쉽다.
- 표현, 응용, 도메인 계층이 상세한 구현 기술을 다루는 인프라스트럭처 계층에 종속된다

도메인의 가격 계산 규칙의 예제

할인 금액을 계산하기 위해 Drools라는 룰 엔진을 사용해서 계산 로직을 수행하는 인프라스트럭처 영역의 코드를 만들어 보자

public class DroolsRuleEngine {
	private KieContainer kContainer;

	public DroolsRuleEngine() {
		KieServices ks = KieServices.Factory.get();
		kContainer = ks.getKieClasspathContainer();		
	}

	public void evalute(String sessionName, List<?> facts) {
		KiSession kSession = kContainer.newKieSession(sessionName);
		try {
			facts.forEach(x -> kSession.insert(x));
			kSession.fireAllRules();
		} finaly {
			kSession.dispose();
		}
	}
}

응용 영역은 가격 계산을 위해 인프라스트럭처 영역의 DroolsRuleEngine을 사용

public class CalcuateDiscountService {
	private DroolsRuleEngine ruleEngine;
	
	public CalculateDiscountService() {
		ruleEngine = new DroolsRuleEngine();
	}

	public Money calculateDiscount(List<OrderLine> orderLines, String customerId) {
		Customer customer = findCustomer(customerId);
		
		MutableMoney money = new MutableMoney(0);
		List<?> facts = Arrays.asList(customer, money);
		facts.addAll(orderLines);
		ruleEngine.evalute("discountCalculation", facts);
		return money.toImmutableMoney();
	}
}

CalculateDiscountService가 동작은 하겠지만 두가지 문제를 안고 있다.
- CalculateDiscountService를 테스트하기 어렵다
  - RuleEngine이 완벽하게 동작해야 한다.
  - RuleEngine 클래스와 관련 설정 파일 모두 만든 이후에 CalculateDiscountService 를 확인할 수 있다.
- 구현 방식을 변경하기 어렵다
  - ‘discountCalculation’ 문자열은 Drools의 세션 이름을 의미한다.
  - 세션 이름을 변경하면 CalculateDiscountService 코드도 함께 변경해야 한다.
CalculateDiscountService가 겉으로는 인프라스트럭처의 기술에 직접적인 의존을 하지 않는 것처럼 보여도 실제로는 Drools라는 인프라스트럭처 영역의 기술에 완전하게 의존하고 있다.
인프라스트럭처에 의존하면 ‘테스트 어려움’과 ‘기능 확장 어려움’이라는 두가지 문제가 발생한다.
- 문제 해답은 DIP에 있다.

2.3 DIP

가격 할인 계산을 하려면 고객 정보를 구해야하고, 구한 고객 정보와 주문 정보를 이용해서 룰을 실행해야 한다.
CalculateDiscountService는 고수준 모듈이다.
- 고수준 모듈은 의미 있는 단일 기능을 제공하는 모듈로 ‘가격 할인 계산’이라는 기능을 구현
- 가격 할인 계싼 기능을 구현하려면 고객 정보를 구해야하고 룰을 실행해야 하는데 이 두 기능이 하위 기능이다.
저수준 모듈은 하위 기능을 실제로 구현한 것이다.
- JPA를 이용해서 고객 정보를 읽어오는 모듈과 Drools로 룰을 실행하는 모듈이 저수준 모듈이 된다.

DIP는 저수준 모듈이 고수준 모듈에 의존하도록 바꾼다.

추상화 인터페이스를 사용

public interface RuleDiscounter {
	Money applyRules(Customer customer, List<OrderLine> orderLines);
}

CalculateDiscountService가 RuleDiscounter를 이용하도록 변경
- Drools에 의존하는 코드가 없다

public class CalcuateDiscountService {
	private RuleDiscounter ruleDiscounter;
	
	public CalculateDiscountService(RuleDiscounter ruleDiscounter) {
		this.ruleDiscounter = ruleDiscounter;
	}

	public Money calculateDiscount(List<OrderLine> orderLines, String customerId) {
		Customer customer = findCustomer(customerId);
		return ruleDiscounter.applyRules(customer, orderLines);
	}
}

RuleDiscounter를 상속받아 구현

public class DroolsRuleDiscounter implements RuleDiscounter {
	private KieCountainer kContainer;
	
	public DroolsRuleEngine() {
		KieService ks = KieServices.Factory.get();
		kContainer = ks.getKieClasspathContainer();
	}

	@Override
	public Money applyRules(Customer customer, List<OrderLine> orderLines) {
		KieSession kSession = kContainer.newKieSession("discountSession");
		try {
			...
			kSession.fireAllRules();
		} finally {
			kSession.dispose();
		}
		return money.toImmutableMoney();
	}
}

RuleDiscounter가 출현하면서 바뀐 구조
CalculateDiscountService는 더이상 구현 기술인 Drools에 의존하지 않는다.
- RuleDiscounter 인터페이스에 의존할 뿐
- ‘룰을 이용한 할인 금액 계산’은 고수준 모듈의 개념이므로 RuleDiscounter 인터페이스는 고수준 모듈에 속한다.
- DroolsRuleDiscounter는 고수준의 하위 기능인 RuleDiscounter를 구현한 것이므로 저수준 모듈에 속한다.

DIP를 적용하면 저수준 모듈이 고수준 모듈에 의존하게 된다.
- 고수준 모듈이 저수준 모듈을 사용하려면 고수준 모듈이 저수준 모듈에 의존해야 하는데, 반대로 저수준 모듈이 고수준 모듈에 의존한다고 해서 이를 DIP(Dependency Inversion Principle, 의존 역전 원칙)이라 부른다.
DIP를 적용하면 다른 영역인 인프라스트럭처 영역에 의존할 떄 발생했던 두가지 문제인 구현 교체가 어렵다는 것과 테스트가 어려운 문제를 해소할 수 있다.

고수준 모듈은 더 이상 저수준 모듈에 의존하지 않고 구현을 추상화한 인터페이스에 의존할 수 있다.

구현 기술이 변경되더라도 저수준 구현 객체를 생성하는 코드만 변경하면 된다.

// 기존 코드
RuleDiscounter roleDiscounter = new DroolsRuleDiscounter();
CalculateDiscountService disService = new CalculateDiscountService(roleDiscounter);

// 구현 기술 변경 
RuleDiscounter roleDiscounter = new SimpleRuleDiscounter();
CalculateDiscountService disService = new CalculateDiscountService(roleDiscounter);

스프링과 같은 의존 주입을 지원하는 프레임워크를 사용하면 설정 코드를 수정해서 쉽게 구현체를 변경할 수 있다.
CalculateDiscountService가 제대로 동작하는지 테스트하려면 CustomerRepository와 RuleDiscounter를 구현한 객체가 필요하다.
- CacluateDiscountService가 저수준 모듈에 직접 의존했다면 저수준 모듈이 만들어지기 전까진 테스트를 할 수 없음
- 인터페이스에 의존함으로 대역 객체를 사용해서 테스트를 진행 할수 있다.
- 실제 구현 대신 스텁이나 모의 객체와 같은 테스트 목적의 대역을 사용하여 거의 모든 상황을 테스트할 수 있다.
```
public class CalculateDiscountServiceTest {
	@Test
	public void noCustomer_thenExcetionShouldBeThrown() {
		CustomerRepository stubRepo = mock(CustomerRepository.class);
		when(stubRepo.findById("noCustId")).thenRetrun(null);

		RuleDiscounter stubRule = (cust, lines) -> null;
		
		CalculateDiscountService calDisSvc = new CalculateDiscountService(stbRepo, stubRule);
		assertThrows(NoCustomerException.class, () -> calDisSvc.calculateDiscount(ssomeLines, "noCustId"));
	}
}
```
실제 구현 없이 테스트를 할 수 있는 이유는 DIP를 적용해서 고수준 모듈이 저수준 모듈에 의존하지 않도록 했기 때문이다.

2.3.1 DIP 주의사항

DIP를 잘못 생각하면 단순히 인터페이스와 구현 클래스를 분리하는 정도로 받아드릴 수 있다.
DIP의 핵심은 고수준 모듈이 저수준 모듈의 의존하지 않도록 하기 위함이다.
잘못된 구조
- 도메인 영역은 구현 기술을 다루는 인프라스트럭처 영역에 의존하고 있다.
- 고수준 모듈이 저수준 모듈에 의존하고 있다.
DIP를 적용할 때 하위 기능을 추상화한 인터페이스는 고수준 모듈 관점에서 도출한다.
- CalculateDiscountService는 할인 금액을 구하기 위한 룰 엔진을 사용하는지 직접 연산하는지 중요하지 않다.
- 규칙에 따라 할인 금액을 계산하는 것이 중요
- ‘할인 금액 계산’을 추상화한 인터페이스는 저수준 모듈이 아닌 고수준 모듈에 위치한다.

2.3.2 DIP와 아키텍처

인프라스트럭처 영역은 구현 기술을 다루는 저수준 모듈이고 응용 영역과 도메인 영역은 고수준 모듈이다.
인프라스트럭처 계층이 가장 하단에 위치하는 계층형 구조와 달리 아키텍처에 DIP를 적용하면 인프라스트럭처 영역이 응용 영역와 도메인 영역에 의존하는 구조가 된다.
인프라스트럭처에 위치한 클래스가 도메인이나 응용 영역에 정의한 인터페이스를 상속받아 구현하는 구조가 되므로 도메인과 응용 영역에 대한 영향을 주지 않거나 최소화하면서 구현 기술을 변경하는 것이 가능하다.
주문 시 통지 방식에 SMS를 추가해야 한다는 요구사항이 들어왔을 때 OrderService는 변경할 필요가 없다.
- 두 통지 방식을 함께 제공하는 Notifier 구현 클래스를 인프라스트럭처 영역에 추가하면 된다.
마이바티스 대신 JPA를 구현 기술로 사용하고 싶다면 JPA를 이용한 OrderRepository 구현 클래스를 인프라 스트럭처 영역에 추가하면 된다.

2.4 도메인 영역의 주요 구성요소

도메인 영역을 구성하는 요소요소 설명

엔티티 ENTITY	고유 식별자를 갖는 객체로 자신의 라이프 사이클을 갖는다. Order, Member, Product와 같이 도메인의 고유한 개념을 표현한다. 도메인 모델의 데이터를 포함하며 해당 데이터와 관련된 기능을 함께 제공
밸류 VALUE	고유 식별자를 갖지 않는 객체로 주로 개념적으로 하나의 값을 표현할 때 사용된다. 배송지 주소를 표현하기 위한 Address나 구매한 금액을 위한 Money와 같은 타입이 밸류 타입이다. 엔티티의 속성으로 사용할 뿐만 아니라 다른 밸류 타입의 속성도 사용할 수 있다.
애그리거트 AGGREGATE	애그리거트는 연관된 엔티티와 밸류 객체를 개념적으로 하나로 묶는 것이다. 주문과 관련된 Order 엔티티, OrderLine 밸류, Orderer 밸류 객체를 주문 애그리거트로 묶을 수 있다.
리포지터리 REPOSITORY	도메인 모델의 영속성을 처리한다. DBMS 테이블에서 엔티티 객체를 로딩하거나 저장하는 기능을 제공
도메인 서비스 DOMAIN SERVICE	특정 엔티티에 속하지 않는 도메인 로직을 제공한다. ‘할인 금액 계산’은 상품, 쿠폰, 회원 등급, 구매 금액 등 다양한 조건을 이용해서 구현하게 되는데 이렇게 도메인 로직이 여러 엔티티와 밸류를 필요로 하면 도메인 서비스에 로직을 구현

2.4.1 엔티티와 밸류

엔티티와 도메인 모델의 가장 큰 차이점은 도메인 모델의 엔티티는 데이터와 함께 도메인 기능을 함께 제공한다는 점
- 주문을 표현하는 엔티티는 주문과 관련된 데이터뿐만 아니라 배송지 주소 변경을 위한 기능을 함께 제공
```
public class Order {
	private OrderNo number;
	private Orderer orderer;
	private ShippingInfo shippingInfo;
	
	// 도메인 모델 엔티티는 도메인 기능도 함께 제공
	public void shangeShippingInfo(ShippingInfo newShippingInfo) {
		...	
	}
}
```
도메인 모델의 엔티티는 단순히 데이터를 담고 있는 데이터 구조라기보다는 데이터와 함께 기능을 제공하는 객체
도메인 관점에서 기능을 구현하고 기능 구현을 캡슐화해서 데이터가 임의로 변경되는 것을 막는다.
도메인 모델의 엔티티는 두 개 이상의 데이터가 개념적으로 하나인 경우 밸류 타입을 이용해서 표현할 수 있다
- Orderer는 밸류 타입으로 주문자 이름과 이메일 데이터를 포함할 수 있다.
```
public class Orderer {
	private String name;
	private String email;
}
```
RDBMS와 같은 관계형 데이터베이스는 밸류 타입을 재대로 표현하기 힘들다.
- Ordere의 개별 데이터를 저장하거나 밸로 테이블로 분리해서 저장해야 한다.
- 한 테이블에 주문자 정보 함께 넣기
  - 주문자라는 개념이 들어나지 않고 주문자의 개별 데이터만 드러난다.
- 다른 테이블에 주문자 정보 넣기
  - 주문자 데이터를 별도 테이블에 저장했지만 이것은 테이블의 엔티티에 가까우며 밸류 타입의 의미가 드러나지 않는다.

밸류는 불변으로 구현할 것을 권장

엔티티의 밸류 타입 데이터를 변경할 떄는 객체 자체를 완전히 교체한다는 것을 의미

public class Order {
	private ShippingInfo shippingInfo;
	
	public void shangeShippingInfo(ShippingInfo newShippingInfo) {
		checkShippingInfoChangeable();
		setShippingInfo(newShippingInfo);
	}

	private void setShippingInfo(ShippingInfo newShippingInfo) {
		if (newShippingInfo == null) {
			throw new IllegalArgumentException();
		}
		this.shippingInfo = newShippingInfo;
	}
}

2.4.2 애그리거트

도메인이 커질수록 개발할 도메인 모델도 커지면서 많은 엔티티와 밸류가 출현한다.
도메인 모델이 복잡해지면 개발자가 전체 구조가 아닌 한 개 엔티티와 밸류에만 집중하는 상황이 발생한다.
- 상위 수준에서 모델을 관리하지 않고 개별 요소에만 초점을 맞추다 보면, 큰 수준에서 모델을 이해하지 못해 큰 틀에서 모델은 관리할 수 없는 상황에 빠질 수 있다.
도메인 모델에 전체 구조를 이해하는데 도움이 되는 것이 바로 애그리거트(AGGREGATE)이다.
애그리거트는 관련 객체를 하나로 묶은 군집이다.
- 모메인 개념은“주문”, “배송지 정보”, “주문자”, “주문 목록”, “총 결제 금액”의 하위 모델로 구성된다.
- 하위 내념을 표현한 모델을 하나로 묶어서 “주문”이라는 상위 개념으로 표현할 수 있다.
애그리거트를 사용하면 개별 객체가 아닌 관련 객체를 묶어서 객체 군집 단위로 모델을 바라볼 수 있게 된다.
- 개별 객체 간의 관계가 아닌 애그리거트 간의 관계로 도메인 모델을 이해하고 구현하고, 큰 틀에서 도메인 모델을 관리할 수 있다.
애그리거트는 군집에 속한 객체를 관리하는 루트 엔티티를 갖는다.
- 루트 엔티티는 애그리거트에 속해 있는 엔티티와 밸류 객체를 이용해서 애그리거트가 구현해야 할 기능을 제공
- 애그리거트를 사용하는 코드는 애그리거트 루트가 제공하는 기능을 실행
- 애그리거트 루트를 통해 간접적으로 애그리거트 내의 다른 엔티티나 밸류 객체에 접근
- 애그리거트의 내부 구현을 숨겨서 애그리거트 단위로 구현을 캡슐화할 수 있도록 돕는다.
주문 애그리거트
- 애그리거트 루트인 Order는 주문 도메인 로직에 맞게 애그리거트의 상태를 관리
- Order의 배송지 정보 변경 기능은 배송지를 변경할 수 있는지를 확인한 위에 배송지 정보를 변경
- 주문 애그리거트는 Order를 통하지 않고 ShippingInfo를 변경할 수 있는 방법을 제공하지 않는다.
  - 배송지를 변경하려면 루트 엔티티인 Order를 사용해야 하므로 배소지 정보를 변경할 때는 Order가 구현한 도메인 로직을 항상 따르게 된다.
애그리거트를 구현할 때는 고려할 것이 많다.
- 애그리거트를 어떻게 구성했느냐에 따라 구현이 복잡해지기도 하고
- 트랜잭션 범위가 달라지기도 한다.

2.4.3 리포지터리

도메인 객체를 지속적으로 사용하려면 RDBMS, NoSQL, 로컬 파일과 같은 물리적인 저장소에 도메인 객체를 보관해야 한다.
- 이를 위한 도메인 모델이 리포지터리(Repository)이다.
엔티티나 밸류가 요구사항에 도출되는 도메인 모델이라면 리포리터리는 구현을 위한 도메인 모델이다.
리포지터리는 애그리거트 단위로 도메인 객체를 저장하고 조회하는 기능을 정의
- OrderRepository의 메서드를 보면 대상을 찾고 저장하는 단위가 애그리거트 루트인 Order인 것을 알 수 있다.
- Order는 애그리거트에 속한 모든 객체를 포함하고 있으므로 결과적으로 애그리거트 단위로 저장하고 조회한다.
```
public interface OrderRepository {
	Order findByNumber(OrderNumber number);
	void save(Order order);
	void delete(Order order);
}
```
도메인 모델을 사용해야 하는 코드는 리포지터리를 통해서 도메인 객체를 구한 뒤에 도메인 객체의 기능을 실행
public class CancelOrderService { private OrderRepository orderRepository; public void cancel(OrderNumber number) { Order order = orderRepository.findByNumber(number); if (order == null) { throw new OrderNotFoundException(orderId); } order.cancel(); } }
도메인 모델 관점에서 OrderRepository는 도메인 객체를 영속화하는 데 필요한 기능을 추상화 한것으로 고수준 모듈에 속한다.
기반 기술을 이용해서 OrderRepository를 구현한 클래스는 저수준 모듈로 인프라스트럭처 영역에 속한다.
전체 모듈 구조
응용 서비스는 의존 주입과 같은 방식을 사용해서 실제 리포지터리 구현 객체에 접근
응용 서비스와 리포지터리는 밀접한 연관이 있다.
- 응용 서비스는 필요한 도메인 객체를 구하거나 저장할 때 리포지터리를 사용한다.
- 응용 서비스는 트랜잭션을 관리하는데, 트랜잭션 처리는 리포지터리 구현 기술의 영향을 받는다.
리포지터리를 사용하는 주체가 응용 서비스이기 때문에 리포지터리는 응용 서비스가 필요로 하는 메서드를 제공한다.
- 애그리거트를 저장하는 메서드
- 애그리거트 루트 식별자로 애그리거트를 조회하는 메서드

2.5 요청 처리 흐름

표현 영역은 사용자가 전송한 데이터 형식이 올바른지 검사하고 문제가 없다면 데이터를 이용해서 응용 서비스에 기능 실행을 위임
표현 영역은 사용자가 전송한 데이터를 응용 서비스가 요구하는 형식으로 변환해서 전달
요청 처리 흐름
- 웹 브라우저에서 기능 실행 요청
- 표현 영역에 해당하는 컨트롤러는 HTTP 요청 파라미터를 응용 서비스가 필요로 하는 데이터로 변환 해서 응용 서비스의 인자로 전달
- 응용 서비스는 도메인 모델을 이용해서 로직 실행
- 도메인 객체를 리포지터리에서 가져와 실행하거나 신규 도메인 객체를 생성해 리포지터리에 저장
“예매하기”나 “예매 취소”와 같은 기능을 제공하는 응용 서비스는 도메인의 상태를 변경하므로 변경 상태가 물리 저장소에 올바르게 반영되도록 트랜잭션을 관리 해야한다.
- 스프링 프레임워크를 사용한다면 @Transactional 애너테이션을 이용해 트랜잭션을 처리할 수 있다.
```
public class CancelOrderService {
	private OrderRepository orderRepository;
	
	@Transactional
	public void cancel(OrderNumber number) {
		Order order = orderRepository.findByNumber(number);
		if (order == null) {
			throw new NoOrderException(number);
		}
		order.cancel()
	}
}
```

2.6 인프라스트럭처 개요

인프라스트럭처는 표현 영역, 응용 영역, 도메인 영역을 지원한다.
도메인 영역과 응용 영역에서 인프라스트럭처의 기능을 직접 사용하는 것보다 두 영역에서 정의한 인터페이스를 인프라스트럭처 영역에서 구현하는 것이 시스템을 더 유연하고 테스트하기 쉽게 만들어 준다.
무조건 인프라스트럭처에 대한 의존성을 없앨 필요는 없다.
- 스프링을 사용할 경우 응용 서비스는 트랜잭션 처리를 위해 @Transactional을 사용하는 것이 편리하다.
- 영속성 처리를 위해 JPA를 사용할 경우 @Entity나 @Table과 같은 JPA 전용 애너테이션을 도메인 모델 클래스에서 사용하는 것이 XML 매핑 설정을 이용하는 것보다 편리하다.
구현의 편리함은 DIP가 주는 다른 장점만큼 중요하기 때문에 DIP의 장점을 해치지 않는 범위에서 응용 영역과 도메인 영역에서 구현 기술에 대한 의존을 가져가는 것이 나쁘지 않다고 생각한다.
응용 영역과 도메인 영역이 인프라스트럭처에 대한 의존을 완전히 갖지 않도록 시도하는 것은 구현을 더 복잡하고 어렵게 만들 수 있다.
- @Transactional을 사용하면 한 줄로 트랙잭션을 처리할 수 있는데 코드에서 스프링에 대한 의존을 없애려면 복잡한 스프링 설정을 사용해야 한다.
- 의존은 없앴지만 특별히 테스트를 더 쉽게 할 수 있다거나 유연함을 증가시켜 주지 못한다.
- 설정만 복잡해지고 개발 시간만 늘어난다.
표현 영역은 항상 인프라스트럭처 영역과 쌍을 이룬다.
- 스프링 MVC를 사용해서 웹 요청을 처리하려면 스프링이 제공하는 MVC 프레임워크에 맞게 표현 영역을 구현
- Vert.x를 사용해서 Rest API 서버를 구축하려면 Vert.x에 맞게 웹 요청 처리 부분을 구현

2.7 모듈 구성

아키텍처의 각 영역은 별도 패키지에 위치한다.
패키지 구성 규칙에 정답이 존재하는 것은 안지만 영역별로 모듈이 위치할 패키지를 구성할 수 있을 것 이다.
도메인이 크면 하위 도메인으로 나누고 하위 도메인마다 별도 패키지를 구성한다.
도메인 모듈은 도메인에 속한 애그리거트를 기준으로 다시 패키지를 구성한다.
- 카탈로그 하위 도메인이 상품 애그리거트와 카테고리 애그리커트로 구성될 경우 도메인을 두 개의 하위 패키지로 구성할 수 있다.
애그리거트, 모델, 리포지터리는 같은 패키지에 위치시킨다.
- Order, OrderLine, Orderer, OrderRepository 등은 com.myshop.order.domain 패키지에 위치시킨다.
도메인이 복잡하면 도메인 모델과 도메인 서비스를 별도 패키지에 위치시킬 수도 있다.
- com.myshop.order.domain.order: 애그리거트 위치
- com.myshop.order.domain.service: 도메인 서비스 위치
응용 서비스도 도메인 별로 패키지를 구분할 수 있다.
- com.myshop.catalog.application.product
- com.myshop.catalog.application.category
모듈 구조를 얼마나 세분하게해야 하는지에 대한 정해진 규칙은 없다.
한 패키지에 너무 많은 타입이 몰려서 코드를 찾을 때 불편할 정도만 아니면 된다.

2.1 네 개의 영역

“표현”, “응용”, “도메인”, “인프라스트럭처”는 아키텍처를 설계할 때 출현하는 전형적인 네 가지 영역
- 표현 영역
  - 사용자의 요청을 받아 응용 영역에 전달, 응용 영역의 처리 결과를 사용자에게 전달
  - 스프링 MVC 프레임워크가 표현 영역의 기술
- 응용 영역
  - 표현 영역을 통해 사용자의 요청을 전달받은 응용 영역은 시스템이 사용자에게 제공해야할 기능을 구현
  - “주문 등록”, “주문 취소”, “상품 상세 조회” 등의 기능을 예로 들수 있다.
  - 기능을 구현하기 위한 도메인 영역의 도메인 모델을 사용
  - “주문 취소” 기능을 제공하는 응용 서비스를 도메인 모델을 사용해서 기능 구현이 가능
  - public class CancelOrderService { @Transactional public void cancelOrder(String orderId) { Order order = findOrderById(orderId); if (order == null) { throw new OrderNotFoundException(orderId); } order.cancel(); } }
  - 로직을 직접 수행하기보다는 도메인 모델에 로직 수행을 위임
    - “주문 취소” 로직을 직접 구현하지 않고 Order 객체에 취소 처리를 위임 하고 있다
- 도메인 영역
  - Order, OrderLine, ShippingInfo와 같은 도메인 모델
  - 도메인 모델은 핵심 로직을 구현한다.
    - “배송지 변경”, “결제 완료”, “주문 총액 계산”과 같은 핵심 로직을 도메인 모델에 구현한다.
- 인프라스트럭처 영역
  - 구현 기술에 대한 것을 다룬다
  - RDBMS 연동, 메시징 큐에 메시지 전송과 수신, 몽고DB나 레디스의 데이터 연동 처리 등
  - 논리적인 개념을 표현하기보다는 실제 구현을 다룬다
  - 도메인 영역, 응용 영역, 표현 영역은 구현 기술을 사용한 코드를 직접 만들지 않는다.
    - 인프라스트럭처 영역에서 제공하는 기능을 사용해서 필요한 기능을 개발

2.2 계층 구조 아키텍처

네 영역을 구성할 때 많이 사용하는 아키텍처가 그림과 같은 계층 구조이다.
- 표현 영역과 응용 영역은 도메인 영역을 사용
- 도메인 영역은 인프라스트럭처 영역을 사용
도메인의 복잡도에 따라 응용과 도메인을 분리하기도 하고 한 계층으로 합치기도 하지만 전체적인 아키텍처는 계층 구조를 따른다.
계층 구조는 특성상 상위 계층에서 하위 계층으로의 의존만 존재하고 하위 계층은 상위 계층에 의존하지 않는다.
계층 구조를 엄격하게 적용한다면 상위 계층은 바로 아래의 계층에만 의존을 가져야 하지만 구현의 편리함을 위해 계층 구조를 유연하게 적용하기도 한다.
응용 영역과 도메인 영역은 DB나 외부 시스템 연동을 위해 인프라스트럭처의 기능을 사용하므로 계층 구조를 사용하는 것이 직관적으로 이해하기 쉽다.
- 표현, 응용, 도메인 계층이 상세한 구현 기술을 다루는 인프라스트럭처 계층에 종속된다

도메인의 가격 계산 규칙의 예제

할인 금액을 계산하기 위해 Drools라는 룰 엔진을 사용해서 계산 로직을 수행하는 인프라스트럭처 영역의 코드를 만들어 보자

public class DroolsRuleEngine {
	private KieContainer kContainer;

	public DroolsRuleEngine() {
		KieServices ks = KieServices.Factory.get();
		kContainer = ks.getKieClasspathContainer();		
	}

	public void evalute(String sessionName, List<?> facts) {
		KiSession kSession = kContainer.newKieSession(sessionName);
		try {
			facts.forEach(x -> kSession.insert(x));
			kSession.fireAllRules();
		} finaly {
			kSession.dispose();
		}
	}
}

응용 영역은 가격 계산을 위해 인프라스트럭처 영역의 DroolsRuleEngine을 사용

public class CalcuateDiscountService {
	private DroolsRuleEngine ruleEngine;
	
	public CalculateDiscountService() {
		ruleEngine = new DroolsRuleEngine();
	}

	public Money calculateDiscount(List<OrderLine> orderLines, String customerId) {
		Customer customer = findCustomer(customerId);
		
		MutableMoney money = new MutableMoney(0);
		List<?> facts = Arrays.asList(customer, money);
		facts.addAll(orderLines);
		ruleEngine.evalute("discountCalculation", facts);
		return money.toImmutableMoney();
	}
}

CalculateDiscountService가 동작은 하겠지만 두가지 문제를 안고 있다.
- CalculateDiscountService를 테스트하기 어렵다
  - RuleEngine이 완벽하게 동작해야 한다.
  - RuleEngine 클래스와 관련 설정 파일 모두 만든 이후에 CalculateDiscountService 를 확인할 수 있다.
- 구현 방식을 변경하기 어렵다
  - ‘discountCalculation’ 문자열은 Drools의 세션 이름을 의미한다.
  - 세션 이름을 변경하면 CalculateDiscountService 코드도 함께 변경해야 한다.
CalculateDiscountService가 겉으로는 인프라스트럭처의 기술에 직접적인 의존을 하지 않는 것처럼 보여도 실제로는 Drools라는 인프라스트럭처 영역의 기술에 완전하게 의존하고 있다.
인프라스트럭처에 의존하면 ‘테스트 어려움’과 ‘기능 확장 어려움’이라는 두가지 문제가 발생한다.
- 문제 해답은 DIP에 있다.

2.3 DIP

가격 할인 계산을 하려면 고객 정보를 구해야하고, 구한 고객 정보와 주문 정보를 이용해서 룰을 실행해야 한다.
CalculateDiscountService는 고수준 모듈이다.
- 고수준 모듈은 의미 있는 단일 기능을 제공하는 모듈로 ‘가격 할인 계산’이라는 기능을 구현
- 가격 할인 계싼 기능을 구현하려면 고객 정보를 구해야하고 룰을 실행해야 하는데 이 두 기능이 하위 기능이다.
저수준 모듈은 하위 기능을 실제로 구현한 것이다.
- JPA를 이용해서 고객 정보를 읽어오는 모듈과 Drools로 룰을 실행하는 모듈이 저수준 모듈이 된다.

DIP는 저수준 모듈이 고수준 모듈에 의존하도록 바꾼다.

추상화 인터페이스를 사용

public interface RuleDiscounter {
	Money applyRules(Customer customer, List<OrderLine> orderLines);
}

CalculateDiscountService가 RuleDiscounter를 이용하도록 변경
- Drools에 의존하는 코드가 없다

public class CalcuateDiscountService {
	private RuleDiscounter ruleDiscounter;
	
	public CalculateDiscountService(RuleDiscounter ruleDiscounter) {
		this.ruleDiscounter = ruleDiscounter;
	}

	public Money calculateDiscount(List<OrderLine> orderLines, String customerId) {
		Customer customer = findCustomer(customerId);
		return ruleDiscounter.applyRules(customer, orderLines);
	}
}

RuleDiscounter를 상속받아 구현

public class DroolsRuleDiscounter implements RuleDiscounter {
	private KieCountainer kContainer;
	
	public DroolsRuleEngine() {
		KieService ks = KieServices.Factory.get();
		kContainer = ks.getKieClasspathContainer();
	}

	@Override
	public Money applyRules(Customer customer, List<OrderLine> orderLines) {
		KieSession kSession = kContainer.newKieSession("discountSession");
		try {
			...
			kSession.fireAllRules();
		} finally {
			kSession.dispose();
		}
		return money.toImmutableMoney();
	}
}

RuleDiscounter가 출현하면서 바뀐 구조
CalculateDiscountService는 더이상 구현 기술인 Drools에 의존하지 않는다.
- RuleDiscounter 인터페이스에 의존할 뿐
- ‘룰을 이용한 할인 금액 계산’은 고수준 모듈의 개념이므로 RuleDiscounter 인터페이스는 고수준 모듈에 속한다.
- DroolsRuleDiscounter는 고수준의 하위 기능인 RuleDiscounter를 구현한 것이므로 저수준 모듈에 속한다.

DIP를 적용하면 저수준 모듈이 고수준 모듈에 의존하게 된다.
- 고수준 모듈이 저수준 모듈을 사용하려면 고수준 모듈이 저수준 모듈에 의존해야 하는데, 반대로 저수준 모듈이 고수준 모듈에 의존한다고 해서 이를 DIP(Dependency Inversion Principle, 의존 역전 원칙)이라 부른다.
DIP를 적용하면 다른 영역인 인프라스트럭처 영역에 의존할 떄 발생했던 두가지 문제인 구현 교체가 어렵다는 것과 테스트가 어려운 문제를 해소할 수 있다.

고수준 모듈은 더 이상 저수준 모듈에 의존하지 않고 구현을 추상화한 인터페이스에 의존할 수 있다.

구현 기술이 변경되더라도 저수준 구현 객체를 생성하는 코드만 변경하면 된다.

// 기존 코드
RuleDiscounter roleDiscounter = new DroolsRuleDiscounter();
CalculateDiscountService disService = new CalculateDiscountService(roleDiscounter);

// 구현 기술 변경 
RuleDiscounter roleDiscounter = new SimpleRuleDiscounter();
CalculateDiscountService disService = new CalculateDiscountService(roleDiscounter);

스프링과 같은 의존 주입을 지원하는 프레임워크를 사용하면 설정 코드를 수정해서 쉽게 구현체를 변경할 수 있다.
CalculateDiscountService가 제대로 동작하는지 테스트하려면 CustomerRepository와 RuleDiscounter를 구현한 객체가 필요하다.
- CacluateDiscountService가 저수준 모듈에 직접 의존했다면 저수준 모듈이 만들어지기 전까진 테스트를 할 수 없음
- 인터페이스에 의존함으로 대역 객체를 사용해서 테스트를 진행 할수 있다.
- 실제 구현 대신 스텁이나 모의 객체와 같은 테스트 목적의 대역을 사용하여 거의 모든 상황을 테스트할 수 있다.
```
public class CalculateDiscountServiceTest {
	@Test
	public void noCustomer_thenExcetionShouldBeThrown() {
		CustomerRepository stubRepo = mock(CustomerRepository.class);
		when(stubRepo.findById("noCustId")).thenRetrun(null);

		RuleDiscounter stubRule = (cust, lines) -> null;
		
		CalculateDiscountService calDisSvc = new CalculateDiscountService(stbRepo, stubRule);
		assertThrows(NoCustomerException.class, () -> calDisSvc.calculateDiscount(ssomeLines, "noCustId"));
	}
}
```
실제 구현 없이 테스트를 할 수 있는 이유는 DIP를 적용해서 고수준 모듈이 저수준 모듈에 의존하지 않도록 했기 때문이다.

2.3.1 DIP 주의사항

DIP를 잘못 생각하면 단순히 인터페이스와 구현 클래스를 분리하는 정도로 받아드릴 수 있다.
DIP의 핵심은 고수준 모듈이 저수준 모듈의 의존하지 않도록 하기 위함이다.
잘못된 구조
- 도메인 영역은 구현 기술을 다루는 인프라스트럭처 영역에 의존하고 있다.
- 고수준 모듈이 저수준 모듈에 의존하고 있다.
DIP를 적용할 때 하위 기능을 추상화한 인터페이스는 고수준 모듈 관점에서 도출한다.
- CalculateDiscountService는 할인 금액을 구하기 위한 룰 엔진을 사용하는지 직접 연산하는지 중요하지 않다.
- 규칙에 따라 할인 금액을 계산하는 것이 중요
- ‘할인 금액 계산’을 추상화한 인터페이스는 저수준 모듈이 아닌 고수준 모듈에 위치한다.

2.3.2 DIP와 아키텍처

인프라스트럭처 영역은 구현 기술을 다루는 저수준 모듈이고 응용 영역과 도메인 영역은 고수준 모듈이다.
인프라스트럭처 계층이 가장 하단에 위치하는 계층형 구조와 달리 아키텍처에 DIP를 적용하면 인프라스트럭처 영역이 응용 영역와 도메인 영역에 의존하는 구조가 된다.
인프라스트럭처에 위치한 클래스가 도메인이나 응용 영역에 정의한 인터페이스를 상속받아 구현하는 구조가 되므로 도메인과 응용 영역에 대한 영향을 주지 않거나 최소화하면서 구현 기술을 변경하는 것이 가능하다.
주문 시 통지 방식에 SMS를 추가해야 한다는 요구사항이 들어왔을 때 OrderService는 변경할 필요가 없다.
- 두 통지 방식을 함께 제공하는 Notifier 구현 클래스를 인프라스트럭처 영역에 추가하면 된다.
마이바티스 대신 JPA를 구현 기술로 사용하고 싶다면 JPA를 이용한 OrderRepository 구현 클래스를 인프라 스트럭처 영역에 추가하면 된다.

2.4 도메인 영역의 주요 구성요소

도메인 영역을 구성하는 요소요소 설명

엔티티 ENTITY	고유 식별자를 갖는 객체로 자신의 라이프 사이클을 갖는다. Order, Member, Product와 같이 도메인의 고유한 개념을 표현한다. 도메인 모델의 데이터를 포함하며 해당 데이터와 관련된 기능을 함께 제공
밸류 VALUE	고유 식별자를 갖지 않는 객체로 주로 개념적으로 하나의 값을 표현할 때 사용된다. 배송지 주소를 표현하기 위한 Address나 구매한 금액을 위한 Money와 같은 타입이 밸류 타입이다. 엔티티의 속성으로 사용할 뿐만 아니라 다른 밸류 타입의 속성도 사용할 수 있다.
애그리거트 AGGREGATE	애그리거트는 연관된 엔티티와 밸류 객체를 개념적으로 하나로 묶는 것이다. 주문과 관련된 Order 엔티티, OrderLine 밸류, Orderer 밸류 객체를 주문 애그리거트로 묶을 수 있다.
리포지터리 REPOSITORY	도메인 모델의 영속성을 처리한다. DBMS 테이블에서 엔티티 객체를 로딩하거나 저장하는 기능을 제공
도메인 서비스 DOMAIN SERVICE	특정 엔티티에 속하지 않는 도메인 로직을 제공한다. ‘할인 금액 계산’은 상품, 쿠폰, 회원 등급, 구매 금액 등 다양한 조건을 이용해서 구현하게 되는데 이렇게 도메인 로직이 여러 엔티티와 밸류를 필요로 하면 도메인 서비스에 로직을 구현

2.4.1 엔티티와 밸류

엔티티와 도메인 모델의 가장 큰 차이점은 도메인 모델의 엔티티는 데이터와 함께 도메인 기능을 함께 제공한다는 점
- 주문을 표현하는 엔티티는 주문과 관련된 데이터뿐만 아니라 배송지 주소 변경을 위한 기능을 함께 제공
```
public class Order {
	private OrderNo number;
	private Orderer orderer;
	private ShippingInfo shippingInfo;
	
	// 도메인 모델 엔티티는 도메인 기능도 함께 제공
	public void shangeShippingInfo(ShippingInfo newShippingInfo) {
		...	
	}
}
```
도메인 모델의 엔티티는 단순히 데이터를 담고 있는 데이터 구조라기보다는 데이터와 함께 기능을 제공하는 객체
도메인 관점에서 기능을 구현하고 기능 구현을 캡슐화해서 데이터가 임의로 변경되는 것을 막는다.
도메인 모델의 엔티티는 두 개 이상의 데이터가 개념적으로 하나인 경우 밸류 타입을 이용해서 표현할 수 있다
- Orderer는 밸류 타입으로 주문자 이름과 이메일 데이터를 포함할 수 있다.
```
public class Orderer {
	private String name;
	private String email;
}
```
RDBMS와 같은 관계형 데이터베이스는 밸류 타입을 재대로 표현하기 힘들다.
- Ordere의 개별 데이터를 저장하거나 밸로 테이블로 분리해서 저장해야 한다.
- 한 테이블에 주문자 정보 함께 넣기
  - 주문자라는 개념이 들어나지 않고 주문자의 개별 데이터만 드러난다.
- 다른 테이블에 주문자 정보 넣기
  - 주문자 데이터를 별도 테이블에 저장했지만 이것은 테이블의 엔티티에 가까우며 밸류 타입의 의미가 드러나지 않는다.

밸류는 불변으로 구현할 것을 권장

엔티티의 밸류 타입 데이터를 변경할 떄는 객체 자체를 완전히 교체한다는 것을 의미

public class Order {
	private ShippingInfo shippingInfo;
	
	public void shangeShippingInfo(ShippingInfo newShippingInfo) {
		checkShippingInfoChangeable();
		setShippingInfo(newShippingInfo);
	}

	private void setShippingInfo(ShippingInfo newShippingInfo) {
		if (newShippingInfo == null) {
			throw new IllegalArgumentException();
		}
		this.shippingInfo = newShippingInfo;
	}
}

2.4.2 애그리거트

도메인이 커질수록 개발할 도메인 모델도 커지면서 많은 엔티티와 밸류가 출현한다.
도메인 모델이 복잡해지면 개발자가 전체 구조가 아닌 한 개 엔티티와 밸류에만 집중하는 상황이 발생한다.
- 상위 수준에서 모델을 관리하지 않고 개별 요소에만 초점을 맞추다 보면, 큰 수준에서 모델을 이해하지 못해 큰 틀에서 모델은 관리할 수 없는 상황에 빠질 수 있다.
도메인 모델에 전체 구조를 이해하는데 도움이 되는 것이 바로 애그리거트(AGGREGATE)이다.
애그리거트는 관련 객체를 하나로 묶은 군집이다.
- 모메인 개념은“주문”, “배송지 정보”, “주문자”, “주문 목록”, “총 결제 금액”의 하위 모델로 구성된다.
- 하위 내념을 표현한 모델을 하나로 묶어서 “주문”이라는 상위 개념으로 표현할 수 있다.
애그리거트를 사용하면 개별 객체가 아닌 관련 객체를 묶어서 객체 군집 단위로 모델을 바라볼 수 있게 된다.
- 개별 객체 간의 관계가 아닌 애그리거트 간의 관계로 도메인 모델을 이해하고 구현하고, 큰 틀에서 도메인 모델을 관리할 수 있다.
애그리거트는 군집에 속한 객체를 관리하는 루트 엔티티를 갖는다.
- 루트 엔티티는 애그리거트에 속해 있는 엔티티와 밸류 객체를 이용해서 애그리거트가 구현해야 할 기능을 제공
- 애그리거트를 사용하는 코드는 애그리거트 루트가 제공하는 기능을 실행
- 애그리거트 루트를 통해 간접적으로 애그리거트 내의 다른 엔티티나 밸류 객체에 접근
- 애그리거트의 내부 구현을 숨겨서 애그리거트 단위로 구현을 캡슐화할 수 있도록 돕는다.
주문 애그리거트
- 애그리거트 루트인 Order는 주문 도메인 로직에 맞게 애그리거트의 상태를 관리
- Order의 배송지 정보 변경 기능은 배송지를 변경할 수 있는지를 확인한 위에 배송지 정보를 변경
- 주문 애그리거트는 Order를 통하지 않고 ShippingInfo를 변경할 수 있는 방법을 제공하지 않는다.
  - 배송지를 변경하려면 루트 엔티티인 Order를 사용해야 하므로 배소지 정보를 변경할 때는 Order가 구현한 도메인 로직을 항상 따르게 된다.
애그리거트를 구현할 때는 고려할 것이 많다.
- 애그리거트를 어떻게 구성했느냐에 따라 구현이 복잡해지기도 하고
- 트랜잭션 범위가 달라지기도 한다.

2.4.3 리포지터리

도메인 객체를 지속적으로 사용하려면 RDBMS, NoSQL, 로컬 파일과 같은 물리적인 저장소에 도메인 객체를 보관해야 한다.
- 이를 위한 도메인 모델이 리포지터리(Repository)이다.
엔티티나 밸류가 요구사항에 도출되는 도메인 모델이라면 리포리터리는 구현을 위한 도메인 모델이다.
리포지터리는 애그리거트 단위로 도메인 객체를 저장하고 조회하는 기능을 정의
- OrderRepository의 메서드를 보면 대상을 찾고 저장하는 단위가 애그리거트 루트인 Order인 것을 알 수 있다.
- Order는 애그리거트에 속한 모든 객체를 포함하고 있으므로 결과적으로 애그리거트 단위로 저장하고 조회한다.
```
public interface OrderRepository {
	Order findByNumber(OrderNumber number);
	void save(Order order);
	void delete(Order order);
}
```
도메인 모델을 사용해야 하는 코드는 리포지터리를 통해서 도메인 객체를 구한 뒤에 도메인 객체의 기능을 실행
public class CancelOrderService { private OrderRepository orderRepository; public void cancel(OrderNumber number) { Order order = orderRepository.findByNumber(number); if (order == null) { throw new OrderNotFoundException(orderId); } order.cancel(); } }
도메인 모델 관점에서 OrderRepository는 도메인 객체를 영속화하는 데 필요한 기능을 추상화 한것으로 고수준 모듈에 속한다.
기반 기술을 이용해서 OrderRepository를 구현한 클래스는 저수준 모듈로 인프라스트럭처 영역에 속한다.
전체 모듈 구조
응용 서비스는 의존 주입과 같은 방식을 사용해서 실제 리포지터리 구현 객체에 접근
응용 서비스와 리포지터리는 밀접한 연관이 있다.
- 응용 서비스는 필요한 도메인 객체를 구하거나 저장할 때 리포지터리를 사용한다.
- 응용 서비스는 트랜잭션을 관리하는데, 트랜잭션 처리는 리포지터리 구현 기술의 영향을 받는다.
리포지터리를 사용하는 주체가 응용 서비스이기 때문에 리포지터리는 응용 서비스가 필요로 하는 메서드를 제공한다.
- 애그리거트를 저장하는 메서드
- 애그리거트 루트 식별자로 애그리거트를 조회하는 메서드

2.5 요청 처리 흐름

표현 영역은 사용자가 전송한 데이터 형식이 올바른지 검사하고 문제가 없다면 데이터를 이용해서 응용 서비스에 기능 실행을 위임
표현 영역은 사용자가 전송한 데이터를 응용 서비스가 요구하는 형식으로 변환해서 전달
요청 처리 흐름
- 웹 브라우저에서 기능 실행 요청
- 표현 영역에 해당하는 컨트롤러는 HTTP 요청 파라미터를 응용 서비스가 필요로 하는 데이터로 변환 해서 응용 서비스의 인자로 전달
- 응용 서비스는 도메인 모델을 이용해서 로직 실행
- 도메인 객체를 리포지터리에서 가져와 실행하거나 신규 도메인 객체를 생성해 리포지터리에 저장
“예매하기”나 “예매 취소”와 같은 기능을 제공하는 응용 서비스는 도메인의 상태를 변경하므로 변경 상태가 물리 저장소에 올바르게 반영되도록 트랜잭션을 관리 해야한다.
- 스프링 프레임워크를 사용한다면 @Transactional 애너테이션을 이용해 트랜잭션을 처리할 수 있다.
```
public class CancelOrderService {
	private OrderRepository orderRepository;
	
	@Transactional
	public void cancel(OrderNumber number) {
		Order order = orderRepository.findByNumber(number);
		if (order == null) {
			throw new NoOrderException(number);
		}
		order.cancel()
	}
}
```

2.6 인프라스트럭처 개요

인프라스트럭처는 표현 영역, 응용 영역, 도메인 영역을 지원한다.
도메인 영역과 응용 영역에서 인프라스트럭처의 기능을 직접 사용하는 것보다 두 영역에서 정의한 인터페이스를 인프라스트럭처 영역에서 구현하는 것이 시스템을 더 유연하고 테스트하기 쉽게 만들어 준다.
무조건 인프라스트럭처에 대한 의존성을 없앨 필요는 없다.
- 스프링을 사용할 경우 응용 서비스는 트랜잭션 처리를 위해 @Transactional을 사용하는 것이 편리하다.
- 영속성 처리를 위해 JPA를 사용할 경우 @Entity나 @Table과 같은 JPA 전용 애너테이션을 도메인 모델 클래스에서 사용하는 것이 XML 매핑 설정을 이용하는 것보다 편리하다.
구현의 편리함은 DIP가 주는 다른 장점만큼 중요하기 때문에 DIP의 장점을 해치지 않는 범위에서 응용 영역과 도메인 영역에서 구현 기술에 대한 의존을 가져가는 것이 나쁘지 않다고 생각한다.
응용 영역과 도메인 영역이 인프라스트럭처에 대한 의존을 완전히 갖지 않도록 시도하는 것은 구현을 더 복잡하고 어렵게 만들 수 있다.
- @Transactional을 사용하면 한 줄로 트랙잭션을 처리할 수 있는데 코드에서 스프링에 대한 의존을 없애려면 복잡한 스프링 설정을 사용해야 한다.
- 의존은 없앴지만 특별히 테스트를 더 쉽게 할 수 있다거나 유연함을 증가시켜 주지 못한다.
- 설정만 복잡해지고 개발 시간만 늘어난다.
표현 영역은 항상 인프라스트럭처 영역과 쌍을 이룬다.
- 스프링 MVC를 사용해서 웹 요청을 처리하려면 스프링이 제공하는 MVC 프레임워크에 맞게 표현 영역을 구현
- Vert.x를 사용해서 Rest API 서버를 구축하려면 Vert.x에 맞게 웹 요청 처리 부분을 구현

2.7 모듈 구성

아키텍처의 각 영역은 별도 패키지에 위치한다.
패키지 구성 규칙에 정답이 존재하는 것은 안지만 영역별로 모듈이 위치할 패키지를 구성할 수 있을 것 이다.
도메인이 크면 하위 도메인으로 나누고 하위 도메인마다 별도 패키지를 구성한다.
도메인 모듈은 도메인에 속한 애그리거트를 기준으로 다시 패키지를 구성한다.
- 카탈로그 하위 도메인이 상품 애그리거트와 카테고리 애그리커트로 구성될 경우 도메인을 두 개의 하위 패키지로 구성할 수 있다.
애그리거트, 모델, 리포지터리는 같은 패키지에 위치시킨다.
- Order, OrderLine, Orderer, OrderRepository 등은 com.myshop.order.domain 패키지에 위치시킨다.
도메인이 복잡하면 도메인 모델과 도메인 서비스를 별도 패키지에 위치시킬 수도 있다.
- com.myshop.order.domain.order: 애그리거트 위치
- com.myshop.order.domain.service: 도메인 서비스 위치
응용 서비스도 도메인 별로 패키지를 구분할 수 있다.
- com.myshop.catalog.application.product
- com.myshop.catalog.application.category
모듈 구조를 얼마나 세분하게해야 하는지에 대한 정해진 규칙은 없다.
한 패키지에 너무 많은 타입이 몰려서 코드를 찾을 때 불편할 정도만 아니면 된다.

2.1 네 개의 영역

“표현”, “응용”, “도메인”, “인프라스트럭처”는 아키텍처를 설계할 때 출현하는 전형적인 네 가지 영역
- 표현 영역
  - 사용자의 요청을 받아 응용 영역에 전달, 응용 영역의 처리 결과를 사용자에게 전달
  - 스프링 MVC 프레임워크가 표현 영역의 기술
- 응용 영역
  - 표현 영역을 통해 사용자의 요청을 전달받은 응용 영역은 시스템이 사용자에게 제공해야할 기능을 구현
  - “주문 등록”, “주문 취소”, “상품 상세 조회” 등의 기능을 예로 들수 있다.
  - 기능을 구현하기 위한 도메인 영역의 도메인 모델을 사용
  - “주문 취소” 기능을 제공하는 응용 서비스를 도메인 모델을 사용해서 기능 구현이 가능
  - public class CancelOrderService { @Transactional public void cancelOrder(String orderId) { Order order = findOrderById(orderId); if (order == null) { throw new OrderNotFoundException(orderId); } order.cancel(); } }
  - 로직을 직접 수행하기보다는 도메인 모델에 로직 수행을 위임
    - “주문 취소” 로직을 직접 구현하지 않고 Order 객체에 취소 처리를 위임 하고 있다
- 도메인 영역
  - Order, OrderLine, ShippingInfo와 같은 도메인 모델
  - 도메인 모델은 핵심 로직을 구현한다.
    - “배송지 변경”, “결제 완료”, “주문 총액 계산”과 같은 핵심 로직을 도메인 모델에 구현한다.
- 인프라스트럭처 영역
  - 구현 기술에 대한 것을 다룬다
  - RDBMS 연동, 메시징 큐에 메시지 전송과 수신, 몽고DB나 레디스의 데이터 연동 처리 등
  - 논리적인 개념을 표현하기보다는 실제 구현을 다룬다
  - 도메인 영역, 응용 영역, 표현 영역은 구현 기술을 사용한 코드를 직접 만들지 않는다.
    - 인프라스트럭처 영역에서 제공하는 기능을 사용해서 필요한 기능을 개발

2.2 계층 구조 아키텍처

네 영역을 구성할 때 많이 사용하는 아키텍처가 그림과 같은 계층 구조이다.
- 표현 영역과 응용 영역은 도메인 영역을 사용
- 도메인 영역은 인프라스트럭처 영역을 사용
도메인의 복잡도에 따라 응용과 도메인을 분리하기도 하고 한 계층으로 합치기도 하지만 전체적인 아키텍처는 계층 구조를 따른다.
계층 구조는 특성상 상위 계층에서 하위 계층으로의 의존만 존재하고 하위 계층은 상위 계층에 의존하지 않는다.
계층 구조를 엄격하게 적용한다면 상위 계층은 바로 아래의 계층에만 의존을 가져야 하지만 구현의 편리함을 위해 계층 구조를 유연하게 적용하기도 한다.
응용 영역과 도메인 영역은 DB나 외부 시스템 연동을 위해 인프라스트럭처의 기능을 사용하므로 계층 구조를 사용하는 것이 직관적으로 이해하기 쉽다.
- 표현, 응용, 도메인 계층이 상세한 구현 기술을 다루는 인프라스트럭처 계층에 종속된다

도메인의 가격 계산 규칙의 예제

할인 금액을 계산하기 위해 Drools라는 룰 엔진을 사용해서 계산 로직을 수행하는 인프라스트럭처 영역의 코드를 만들어 보자

public class DroolsRuleEngine {
	private KieContainer kContainer;

	public DroolsRuleEngine() {
		KieServices ks = KieServices.Factory.get();
		kContainer = ks.getKieClasspathContainer();		
	}

	public void evalute(String sessionName, List<?> facts) {
		KiSession kSession = kContainer.newKieSession(sessionName);
		try {
			facts.forEach(x -> kSession.insert(x));
			kSession.fireAllRules();
		} finaly {
			kSession.dispose();
		}
	}
}

응용 영역은 가격 계산을 위해 인프라스트럭처 영역의 DroolsRuleEngine을 사용

public class CalcuateDiscountService {
	private DroolsRuleEngine ruleEngine;
	
	public CalculateDiscountService() {
		ruleEngine = new DroolsRuleEngine();
	}

	public Money calculateDiscount(List<OrderLine> orderLines, String customerId) {
		Customer customer = findCustomer(customerId);
		
		MutableMoney money = new MutableMoney(0);
		List<?> facts = Arrays.asList(customer, money);
		facts.addAll(orderLines);
		ruleEngine.evalute("discountCalculation", facts);
		return money.toImmutableMoney();
	}
}

CalculateDiscountService가 동작은 하겠지만 두가지 문제를 안고 있다.
- CalculateDiscountService를 테스트하기 어렵다
  - RuleEngine이 완벽하게 동작해야 한다.
  - RuleEngine 클래스와 관련 설정 파일 모두 만든 이후에 CalculateDiscountService 를 확인할 수 있다.
- 구현 방식을 변경하기 어렵다
  - ‘discountCalculation’ 문자열은 Drools의 세션 이름을 의미한다.
  - 세션 이름을 변경하면 CalculateDiscountService 코드도 함께 변경해야 한다.
CalculateDiscountService가 겉으로는 인프라스트럭처의 기술에 직접적인 의존을 하지 않는 것처럼 보여도 실제로는 Drools라는 인프라스트럭처 영역의 기술에 완전하게 의존하고 있다.
인프라스트럭처에 의존하면 ‘테스트 어려움’과 ‘기능 확장 어려움’이라는 두가지 문제가 발생한다.
- 문제 해답은 DIP에 있다.

2.3 DIP

가격 할인 계산을 하려면 고객 정보를 구해야하고, 구한 고객 정보와 주문 정보를 이용해서 룰을 실행해야 한다.
CalculateDiscountService는 고수준 모듈이다.
- 고수준 모듈은 의미 있는 단일 기능을 제공하는 모듈로 ‘가격 할인 계산’이라는 기능을 구현
- 가격 할인 계싼 기능을 구현하려면 고객 정보를 구해야하고 룰을 실행해야 하는데 이 두 기능이 하위 기능이다.
저수준 모듈은 하위 기능을 실제로 구현한 것이다.
- JPA를 이용해서 고객 정보를 읽어오는 모듈과 Drools로 룰을 실행하는 모듈이 저수준 모듈이 된다.

DIP는 저수준 모듈이 고수준 모듈에 의존하도록 바꾼다.

추상화 인터페이스를 사용

public interface RuleDiscounter {
	Money applyRules(Customer customer, List<OrderLine> orderLines);
}

CalculateDiscountService가 RuleDiscounter를 이용하도록 변경
- Drools에 의존하는 코드가 없다

public class CalcuateDiscountService {
	private RuleDiscounter ruleDiscounter;
	
	public CalculateDiscountService(RuleDiscounter ruleDiscounter) {
		this.ruleDiscounter = ruleDiscounter;
	}

	public Money calculateDiscount(List<OrderLine> orderLines, String customerId) {
		Customer customer = findCustomer(customerId);
		return ruleDiscounter.applyRules(customer, orderLines);
	}
}

RuleDiscounter를 상속받아 구현

public class DroolsRuleDiscounter implements RuleDiscounter {
	private KieCountainer kContainer;
	
	public DroolsRuleEngine() {
		KieService ks = KieServices.Factory.get();
		kContainer = ks.getKieClasspathContainer();
	}

	@Override
	public Money applyRules(Customer customer, List<OrderLine> orderLines) {
		KieSession kSession = kContainer.newKieSession("discountSession");
		try {
			...
			kSession.fireAllRules();
		} finally {
			kSession.dispose();
		}
		return money.toImmutableMoney();
	}
}

RuleDiscounter가 출현하면서 바뀐 구조
CalculateDiscountService는 더이상 구현 기술인 Drools에 의존하지 않는다.
- RuleDiscounter 인터페이스에 의존할 뿐
- ‘룰을 이용한 할인 금액 계산’은 고수준 모듈의 개념이므로 RuleDiscounter 인터페이스는 고수준 모듈에 속한다.
- DroolsRuleDiscounter는 고수준의 하위 기능인 RuleDiscounter를 구현한 것이므로 저수준 모듈에 속한다.

DIP를 적용하면 저수준 모듈이 고수준 모듈에 의존하게 된다.
- 고수준 모듈이 저수준 모듈을 사용하려면 고수준 모듈이 저수준 모듈에 의존해야 하는데, 반대로 저수준 모듈이 고수준 모듈에 의존한다고 해서 이를 DIP(Dependency Inversion Principle, 의존 역전 원칙)이라 부른다.
DIP를 적용하면 다른 영역인 인프라스트럭처 영역에 의존할 떄 발생했던 두가지 문제인 구현 교체가 어렵다는 것과 테스트가 어려운 문제를 해소할 수 있다.

고수준 모듈은 더 이상 저수준 모듈에 의존하지 않고 구현을 추상화한 인터페이스에 의존할 수 있다.

구현 기술이 변경되더라도 저수준 구현 객체를 생성하는 코드만 변경하면 된다.

// 기존 코드
RuleDiscounter roleDiscounter = new DroolsRuleDiscounter();
CalculateDiscountService disService = new CalculateDiscountService(roleDiscounter);

// 구현 기술 변경 
RuleDiscounter roleDiscounter = new SimpleRuleDiscounter();
CalculateDiscountService disService = new CalculateDiscountService(roleDiscounter);

스프링과 같은 의존 주입을 지원하는 프레임워크를 사용하면 설정 코드를 수정해서 쉽게 구현체를 변경할 수 있다.
CalculateDiscountService가 제대로 동작하는지 테스트하려면 CustomerRepository와 RuleDiscounter를 구현한 객체가 필요하다.
- CacluateDiscountService가 저수준 모듈에 직접 의존했다면 저수준 모듈이 만들어지기 전까진 테스트를 할 수 없음
- 인터페이스에 의존함으로 대역 객체를 사용해서 테스트를 진행 할수 있다.
- 실제 구현 대신 스텁이나 모의 객체와 같은 테스트 목적의 대역을 사용하여 거의 모든 상황을 테스트할 수 있다.
```
public class CalculateDiscountServiceTest {
	@Test
	public void noCustomer_thenExcetionShouldBeThrown() {
		CustomerRepository stubRepo = mock(CustomerRepository.class);
		when(stubRepo.findById("noCustId")).thenRetrun(null);

		RuleDiscounter stubRule = (cust, lines) -> null;
		
		CalculateDiscountService calDisSvc = new CalculateDiscountService(stbRepo, stubRule);
		assertThrows(NoCustomerException.class, () -> calDisSvc.calculateDiscount(ssomeLines, "noCustId"));
	}
}
```
실제 구현 없이 테스트를 할 수 있는 이유는 DIP를 적용해서 고수준 모듈이 저수준 모듈에 의존하지 않도록 했기 때문이다.

2.3.1 DIP 주의사항

DIP를 잘못 생각하면 단순히 인터페이스와 구현 클래스를 분리하는 정도로 받아드릴 수 있다.
DIP의 핵심은 고수준 모듈이 저수준 모듈의 의존하지 않도록 하기 위함이다.
잘못된 구조
- 도메인 영역은 구현 기술을 다루는 인프라스트럭처 영역에 의존하고 있다.
- 고수준 모듈이 저수준 모듈에 의존하고 있다.
DIP를 적용할 때 하위 기능을 추상화한 인터페이스는 고수준 모듈 관점에서 도출한다.
- CalculateDiscountService는 할인 금액을 구하기 위한 룰 엔진을 사용하는지 직접 연산하는지 중요하지 않다.
- 규칙에 따라 할인 금액을 계산하는 것이 중요
- ‘할인 금액 계산’을 추상화한 인터페이스는 저수준 모듈이 아닌 고수준 모듈에 위치한다.

2.3.2 DIP와 아키텍처

인프라스트럭처 영역은 구현 기술을 다루는 저수준 모듈이고 응용 영역과 도메인 영역은 고수준 모듈이다.
인프라스트럭처 계층이 가장 하단에 위치하는 계층형 구조와 달리 아키텍처에 DIP를 적용하면 인프라스트럭처 영역이 응용 영역와 도메인 영역에 의존하는 구조가 된다.
인프라스트럭처에 위치한 클래스가 도메인이나 응용 영역에 정의한 인터페이스를 상속받아 구현하는 구조가 되므로 도메인과 응용 영역에 대한 영향을 주지 않거나 최소화하면서 구현 기술을 변경하는 것이 가능하다.
주문 시 통지 방식에 SMS를 추가해야 한다는 요구사항이 들어왔을 때 OrderService는 변경할 필요가 없다.
- 두 통지 방식을 함께 제공하는 Notifier 구현 클래스를 인프라스트럭처 영역에 추가하면 된다.
마이바티스 대신 JPA를 구현 기술로 사용하고 싶다면 JPA를 이용한 OrderRepository 구현 클래스를 인프라 스트럭처 영역에 추가하면 된다.

2.4 도메인 영역의 주요 구성요소

도메인 영역을 구성하는 요소요소 설명

엔티티 ENTITY	고유 식별자를 갖는 객체로 자신의 라이프 사이클을 갖는다. Order, Member, Product와 같이 도메인의 고유한 개념을 표현한다. 도메인 모델의 데이터를 포함하며 해당 데이터와 관련된 기능을 함께 제공
밸류 VALUE	고유 식별자를 갖지 않는 객체로 주로 개념적으로 하나의 값을 표현할 때 사용된다. 배송지 주소를 표현하기 위한 Address나 구매한 금액을 위한 Money와 같은 타입이 밸류 타입이다. 엔티티의 속성으로 사용할 뿐만 아니라 다른 밸류 타입의 속성도 사용할 수 있다.
애그리거트 AGGREGATE	애그리거트는 연관된 엔티티와 밸류 객체를 개념적으로 하나로 묶는 것이다. 주문과 관련된 Order 엔티티, OrderLine 밸류, Orderer 밸류 객체를 주문 애그리거트로 묶을 수 있다.
리포지터리 REPOSITORY	도메인 모델의 영속성을 처리한다. DBMS 테이블에서 엔티티 객체를 로딩하거나 저장하는 기능을 제공
도메인 서비스 DOMAIN SERVICE	특정 엔티티에 속하지 않는 도메인 로직을 제공한다. ‘할인 금액 계산’은 상품, 쿠폰, 회원 등급, 구매 금액 등 다양한 조건을 이용해서 구현하게 되는데 이렇게 도메인 로직이 여러 엔티티와 밸류를 필요로 하면 도메인 서비스에 로직을 구현

2.4.1 엔티티와 밸류

엔티티와 도메인 모델의 가장 큰 차이점은 도메인 모델의 엔티티는 데이터와 함께 도메인 기능을 함께 제공한다는 점
- 주문을 표현하는 엔티티는 주문과 관련된 데이터뿐만 아니라 배송지 주소 변경을 위한 기능을 함께 제공
```
public class Order {
	private OrderNo number;
	private Orderer orderer;
	private ShippingInfo shippingInfo;
	
	// 도메인 모델 엔티티는 도메인 기능도 함께 제공
	public void shangeShippingInfo(ShippingInfo newShippingInfo) {
		...	
	}
}
```
도메인 모델의 엔티티는 단순히 데이터를 담고 있는 데이터 구조라기보다는 데이터와 함께 기능을 제공하는 객체
도메인 관점에서 기능을 구현하고 기능 구현을 캡슐화해서 데이터가 임의로 변경되는 것을 막는다.
도메인 모델의 엔티티는 두 개 이상의 데이터가 개념적으로 하나인 경우 밸류 타입을 이용해서 표현할 수 있다
- Orderer는 밸류 타입으로 주문자 이름과 이메일 데이터를 포함할 수 있다.
```
public class Orderer {
	private String name;
	private String email;
}
```
RDBMS와 같은 관계형 데이터베이스는 밸류 타입을 재대로 표현하기 힘들다.
- Ordere의 개별 데이터를 저장하거나 밸로 테이블로 분리해서 저장해야 한다.
- 한 테이블에 주문자 정보 함께 넣기
  - 주문자라는 개념이 들어나지 않고 주문자의 개별 데이터만 드러난다.
- 다른 테이블에 주문자 정보 넣기
  - 주문자 데이터를 별도 테이블에 저장했지만 이것은 테이블의 엔티티에 가까우며 밸류 타입의 의미가 드러나지 않는다.

밸류는 불변으로 구현할 것을 권장

엔티티의 밸류 타입 데이터를 변경할 떄는 객체 자체를 완전히 교체한다는 것을 의미

public class Order {
	private ShippingInfo shippingInfo;
	
	public void shangeShippingInfo(ShippingInfo newShippingInfo) {
		checkShippingInfoChangeable();
		setShippingInfo(newShippingInfo);
	}

	private void setShippingInfo(ShippingInfo newShippingInfo) {
		if (newShippingInfo == null) {
			throw new IllegalArgumentException();
		}
		this.shippingInfo = newShippingInfo;
	}
}

2.4.2 애그리거트

도메인이 커질수록 개발할 도메인 모델도 커지면서 많은 엔티티와 밸류가 출현한다.
도메인 모델이 복잡해지면 개발자가 전체 구조가 아닌 한 개 엔티티와 밸류에만 집중하는 상황이 발생한다.
- 상위 수준에서 모델을 관리하지 않고 개별 요소에만 초점을 맞추다 보면, 큰 수준에서 모델을 이해하지 못해 큰 틀에서 모델은 관리할 수 없는 상황에 빠질 수 있다.
도메인 모델에 전체 구조를 이해하는데 도움이 되는 것이 바로 애그리거트(AGGREGATE)이다.
애그리거트는 관련 객체를 하나로 묶은 군집이다.
- 모메인 개념은“주문”, “배송지 정보”, “주문자”, “주문 목록”, “총 결제 금액”의 하위 모델로 구성된다.
- 하위 내념을 표현한 모델을 하나로 묶어서 “주문”이라는 상위 개념으로 표현할 수 있다.
애그리거트를 사용하면 개별 객체가 아닌 관련 객체를 묶어서 객체 군집 단위로 모델을 바라볼 수 있게 된다.
- 개별 객체 간의 관계가 아닌 애그리거트 간의 관계로 도메인 모델을 이해하고 구현하고, 큰 틀에서 도메인 모델을 관리할 수 있다.
애그리거트는 군집에 속한 객체를 관리하는 루트 엔티티를 갖는다.
- 루트 엔티티는 애그리거트에 속해 있는 엔티티와 밸류 객체를 이용해서 애그리거트가 구현해야 할 기능을 제공
- 애그리거트를 사용하는 코드는 애그리거트 루트가 제공하는 기능을 실행
- 애그리거트 루트를 통해 간접적으로 애그리거트 내의 다른 엔티티나 밸류 객체에 접근
- 애그리거트의 내부 구현을 숨겨서 애그리거트 단위로 구현을 캡슐화할 수 있도록 돕는다.
주문 애그리거트
- 애그리거트 루트인 Order는 주문 도메인 로직에 맞게 애그리거트의 상태를 관리
- Order의 배송지 정보 변경 기능은 배송지를 변경할 수 있는지를 확인한 위에 배송지 정보를 변경
- 주문 애그리거트는 Order를 통하지 않고 ShippingInfo를 변경할 수 있는 방법을 제공하지 않는다.
  - 배송지를 변경하려면 루트 엔티티인 Order를 사용해야 하므로 배소지 정보를 변경할 때는 Order가 구현한 도메인 로직을 항상 따르게 된다.
애그리거트를 구현할 때는 고려할 것이 많다.
- 애그리거트를 어떻게 구성했느냐에 따라 구현이 복잡해지기도 하고
- 트랜잭션 범위가 달라지기도 한다.

2.4.3 리포지터리

도메인 객체를 지속적으로 사용하려면 RDBMS, NoSQL, 로컬 파일과 같은 물리적인 저장소에 도메인 객체를 보관해야 한다.
- 이를 위한 도메인 모델이 리포지터리(Repository)이다.
엔티티나 밸류가 요구사항에 도출되는 도메인 모델이라면 리포리터리는 구현을 위한 도메인 모델이다.
리포지터리는 애그리거트 단위로 도메인 객체를 저장하고 조회하는 기능을 정의
- OrderRepository의 메서드를 보면 대상을 찾고 저장하는 단위가 애그리거트 루트인 Order인 것을 알 수 있다.
- Order는 애그리거트에 속한 모든 객체를 포함하고 있으므로 결과적으로 애그리거트 단위로 저장하고 조회한다.
```
public interface OrderRepository {
	Order findByNumber(OrderNumber number);
	void save(Order order);
	void delete(Order order);
}
```
도메인 모델을 사용해야 하는 코드는 리포지터리를 통해서 도메인 객체를 구한 뒤에 도메인 객체의 기능을 실행
public class CancelOrderService { private OrderRepository orderRepository; public void cancel(OrderNumber number) { Order order = orderRepository.findByNumber(number); if (order == null) { throw new OrderNotFoundException(orderId); } order.cancel(); } }
도메인 모델 관점에서 OrderRepository는 도메인 객체를 영속화하는 데 필요한 기능을 추상화 한것으로 고수준 모듈에 속한다.
기반 기술을 이용해서 OrderRepository를 구현한 클래스는 저수준 모듈로 인프라스트럭처 영역에 속한다.
전체 모듈 구조
응용 서비스는 의존 주입과 같은 방식을 사용해서 실제 리포지터리 구현 객체에 접근
응용 서비스와 리포지터리는 밀접한 연관이 있다.
- 응용 서비스는 필요한 도메인 객체를 구하거나 저장할 때 리포지터리를 사용한다.
- 응용 서비스는 트랜잭션을 관리하는데, 트랜잭션 처리는 리포지터리 구현 기술의 영향을 받는다.
리포지터리를 사용하는 주체가 응용 서비스이기 때문에 리포지터리는 응용 서비스가 필요로 하는 메서드를 제공한다.
- 애그리거트를 저장하는 메서드
- 애그리거트 루트 식별자로 애그리거트를 조회하는 메서드

2.5 요청 처리 흐름

표현 영역은 사용자가 전송한 데이터 형식이 올바른지 검사하고 문제가 없다면 데이터를 이용해서 응용 서비스에 기능 실행을 위임
표현 영역은 사용자가 전송한 데이터를 응용 서비스가 요구하는 형식으로 변환해서 전달
요청 처리 흐름
- 웹 브라우저에서 기능 실행 요청
- 표현 영역에 해당하는 컨트롤러는 HTTP 요청 파라미터를 응용 서비스가 필요로 하는 데이터로 변환 해서 응용 서비스의 인자로 전달
- 응용 서비스는 도메인 모델을 이용해서 로직 실행
- 도메인 객체를 리포지터리에서 가져와 실행하거나 신규 도메인 객체를 생성해 리포지터리에 저장
“예매하기”나 “예매 취소”와 같은 기능을 제공하는 응용 서비스는 도메인의 상태를 변경하므로 변경 상태가 물리 저장소에 올바르게 반영되도록 트랜잭션을 관리 해야한다.
- 스프링 프레임워크를 사용한다면 @Transactional 애너테이션을 이용해 트랜잭션을 처리할 수 있다.
```
public class CancelOrderService {
	private OrderRepository orderRepository;
	
	@Transactional
	public void cancel(OrderNumber number) {
		Order order = orderRepository.findByNumber(number);
		if (order == null) {
			throw new NoOrderException(number);
		}
		order.cancel()
	}
}
```

2.6 인프라스트럭처 개요

인프라스트럭처는 표현 영역, 응용 영역, 도메인 영역을 지원한다.
도메인 영역과 응용 영역에서 인프라스트럭처의 기능을 직접 사용하는 것보다 두 영역에서 정의한 인터페이스를 인프라스트럭처 영역에서 구현하는 것이 시스템을 더 유연하고 테스트하기 쉽게 만들어 준다.
무조건 인프라스트럭처에 대한 의존성을 없앨 필요는 없다.
- 스프링을 사용할 경우 응용 서비스는 트랜잭션 처리를 위해 @Transactional을 사용하는 것이 편리하다.
- 영속성 처리를 위해 JPA를 사용할 경우 @Entity나 @Table과 같은 JPA 전용 애너테이션을 도메인 모델 클래스에서 사용하는 것이 XML 매핑 설정을 이용하는 것보다 편리하다.
구현의 편리함은 DIP가 주는 다른 장점만큼 중요하기 때문에 DIP의 장점을 해치지 않는 범위에서 응용 영역과 도메인 영역에서 구현 기술에 대한 의존을 가져가는 것이 나쁘지 않다고 생각한다.
응용 영역과 도메인 영역이 인프라스트럭처에 대한 의존을 완전히 갖지 않도록 시도하는 것은 구현을 더 복잡하고 어렵게 만들 수 있다.
- @Transactional을 사용하면 한 줄로 트랙잭션을 처리할 수 있는데 코드에서 스프링에 대한 의존을 없애려면 복잡한 스프링 설정을 사용해야 한다.
- 의존은 없앴지만 특별히 테스트를 더 쉽게 할 수 있다거나 유연함을 증가시켜 주지 못한다.
- 설정만 복잡해지고 개발 시간만 늘어난다.
표현 영역은 항상 인프라스트럭처 영역과 쌍을 이룬다.
- 스프링 MVC를 사용해서 웹 요청을 처리하려면 스프링이 제공하는 MVC 프레임워크에 맞게 표현 영역을 구현
- Vert.x를 사용해서 Rest API 서버를 구축하려면 Vert.x에 맞게 웹 요청 처리 부분을 구현

2.7 모듈 구성

아키텍처의 각 영역은 별도 패키지에 위치한다.
패키지 구성 규칙에 정답이 존재하는 것은 안지만 영역별로 모듈이 위치할 패키지를 구성할 수 있을 것 이다.
도메인이 크면 하위 도메인으로 나누고 하위 도메인마다 별도 패키지를 구성한다.
도메인 모듈은 도메인에 속한 애그리거트를 기준으로 다시 패키지를 구성한다.
- 카탈로그 하위 도메인이 상품 애그리거트와 카테고리 애그리커트로 구성될 경우 도메인을 두 개의 하위 패키지로 구성할 수 있다.
애그리거트, 모델, 리포지터리는 같은 패키지에 위치시킨다.
- Order, OrderLine, Orderer, OrderRepository 등은 com.myshop.order.domain 패키지에 위치시킨다.
도메인이 복잡하면 도메인 모델과 도메인 서비스를 별도 패키지에 위치시킬 수도 있다.
- com.myshop.order.domain.order: 애그리거트 위치
- com.myshop.order.domain.service: 도메인 서비스 위치
응용 서비스도 도메인 별로 패키지를 구분할 수 있다.
- com.myshop.catalog.application.product
- com.myshop.catalog.application.category
모듈 구조를 얼마나 세분하게해야 하는지에 대한 정해진 규칙은 없다.
한 패키지에 너무 많은 타입이 몰려서 코드를 찾을 때 불편할 정도만 아니면 된다.

2.1 네 개의 영역

“표현”, “응용”, “도메인”, “인프라스트럭처”는 아키텍처를 설계할 때 출현하는 전형적인 네 가지 영역
- 표현 영역
  - 사용자의 요청을 받아 응용 영역에 전달, 응용 영역의 처리 결과를 사용자에게 전달
  - 스프링 MVC 프레임워크가 표현 영역의 기술
- 응용 영역
  - 표현 영역을 통해 사용자의 요청을 전달받은 응용 영역은 시스템이 사용자에게 제공해야할 기능을 구현
  - “주문 등록”, “주문 취소”, “상품 상세 조회” 등의 기능을 예로 들수 있다.
  - 기능을 구현하기 위한 도메인 영역의 도메인 모델을 사용
  - “주문 취소” 기능을 제공하는 응용 서비스를 도메인 모델을 사용해서 기능 구현이 가능
  - public class CancelOrderService { @Transactional public void cancelOrder(String orderId) { Order order = findOrderById(orderId); if (order == null) { throw new OrderNotFoundException(orderId); } order.cancel(); } }
  - 로직을 직접 수행하기보다는 도메인 모델에 로직 수행을 위임
    - “주문 취소” 로직을 직접 구현하지 않고 Order 객체에 취소 처리를 위임 하고 있다
- 도메인 영역
  - Order, OrderLine, ShippingInfo와 같은 도메인 모델
  - 도메인 모델은 핵심 로직을 구현한다.
    - “배송지 변경”, “결제 완료”, “주문 총액 계산”과 같은 핵심 로직을 도메인 모델에 구현한다.
- 인프라스트럭처 영역
  - 구현 기술에 대한 것을 다룬다
  - RDBMS 연동, 메시징 큐에 메시지 전송과 수신, 몽고DB나 레디스의 데이터 연동 처리 등
  - 논리적인 개념을 표현하기보다는 실제 구현을 다룬다
  - 도메인 영역, 응용 영역, 표현 영역은 구현 기술을 사용한 코드를 직접 만들지 않는다.
    - 인프라스트럭처 영역에서 제공하는 기능을 사용해서 필요한 기능을 개발

2.2 계층 구조 아키텍처

네 영역을 구성할 때 많이 사용하는 아키텍처가 그림과 같은 계층 구조이다.
- 표현 영역과 응용 영역은 도메인 영역을 사용
- 도메인 영역은 인프라스트럭처 영역을 사용
도메인의 복잡도에 따라 응용과 도메인을 분리하기도 하고 한 계층으로 합치기도 하지만 전체적인 아키텍처는 계층 구조를 따른다.
계층 구조는 특성상 상위 계층에서 하위 계층으로의 의존만 존재하고 하위 계층은 상위 계층에 의존하지 않는다.
계층 구조를 엄격하게 적용한다면 상위 계층은 바로 아래의 계층에만 의존을 가져야 하지만 구현의 편리함을 위해 계층 구조를 유연하게 적용하기도 한다.
응용 영역과 도메인 영역은 DB나 외부 시스템 연동을 위해 인프라스트럭처의 기능을 사용하므로 계층 구조를 사용하는 것이 직관적으로 이해하기 쉽다.
- 표현, 응용, 도메인 계층이 상세한 구현 기술을 다루는 인프라스트럭처 계층에 종속된다

도메인의 가격 계산 규칙의 예제

할인 금액을 계산하기 위해 Drools라는 룰 엔진을 사용해서 계산 로직을 수행하는 인프라스트럭처 영역의 코드를 만들어 보자

public class DroolsRuleEngine {
	private KieContainer kContainer;

	public DroolsRuleEngine() {
		KieServices ks = KieServices.Factory.get();
		kContainer = ks.getKieClasspathContainer();		
	}

	public void evalute(String sessionName, List<?> facts) {
		KiSession kSession = kContainer.newKieSession(sessionName);
		try {
			facts.forEach(x -> kSession.insert(x));
			kSession.fireAllRules();
		} finaly {
			kSession.dispose();
		}
	}
}

응용 영역은 가격 계산을 위해 인프라스트럭처 영역의 DroolsRuleEngine을 사용

public class CalcuateDiscountService {
	private DroolsRuleEngine ruleEngine;
	
	public CalculateDiscountService() {
		ruleEngine = new DroolsRuleEngine();
	}

	public Money calculateDiscount(List<OrderLine> orderLines, String customerId) {
		Customer customer = findCustomer(customerId);
		
		MutableMoney money = new MutableMoney(0);
		List<?> facts = Arrays.asList(customer, money);
		facts.addAll(orderLines);
		ruleEngine.evalute("discountCalculation", facts);
		return money.toImmutableMoney();
	}
}

CalculateDiscountService가 동작은 하겠지만 두가지 문제를 안고 있다.
- CalculateDiscountService를 테스트하기 어렵다
  - RuleEngine이 완벽하게 동작해야 한다.
  - RuleEngine 클래스와 관련 설정 파일 모두 만든 이후에 CalculateDiscountService 를 확인할 수 있다.
- 구현 방식을 변경하기 어렵다
  - ‘discountCalculation’ 문자열은 Drools의 세션 이름을 의미한다.
  - 세션 이름을 변경하면 CalculateDiscountService 코드도 함께 변경해야 한다.
CalculateDiscountService가 겉으로는 인프라스트럭처의 기술에 직접적인 의존을 하지 않는 것처럼 보여도 실제로는 Drools라는 인프라스트럭처 영역의 기술에 완전하게 의존하고 있다.
인프라스트럭처에 의존하면 ‘테스트 어려움’과 ‘기능 확장 어려움’이라는 두가지 문제가 발생한다.
- 문제 해답은 DIP에 있다.

2.3 DIP

가격 할인 계산을 하려면 고객 정보를 구해야하고, 구한 고객 정보와 주문 정보를 이용해서 룰을 실행해야 한다.
CalculateDiscountService는 고수준 모듈이다.
- 고수준 모듈은 의미 있는 단일 기능을 제공하는 모듈로 ‘가격 할인 계산’이라는 기능을 구현
- 가격 할인 계싼 기능을 구현하려면 고객 정보를 구해야하고 룰을 실행해야 하는데 이 두 기능이 하위 기능이다.
저수준 모듈은 하위 기능을 실제로 구현한 것이다.
- JPA를 이용해서 고객 정보를 읽어오는 모듈과 Drools로 룰을 실행하는 모듈이 저수준 모듈이 된다.

DIP는 저수준 모듈이 고수준 모듈에 의존하도록 바꾼다.

추상화 인터페이스를 사용

public interface RuleDiscounter {
	Money applyRules(Customer customer, List<OrderLine> orderLines);
}

CalculateDiscountService가 RuleDiscounter를 이용하도록 변경
- Drools에 의존하는 코드가 없다

public class CalcuateDiscountService {
	private RuleDiscounter ruleDiscounter;
	
	public CalculateDiscountService(RuleDiscounter ruleDiscounter) {
		this.ruleDiscounter = ruleDiscounter;
	}

	public Money calculateDiscount(List<OrderLine> orderLines, String customerId) {
		Customer customer = findCustomer(customerId);
		return ruleDiscounter.applyRules(customer, orderLines);
	}
}

RuleDiscounter를 상속받아 구현

public class DroolsRuleDiscounter implements RuleDiscounter {
	private KieCountainer kContainer;
	
	public DroolsRuleEngine() {
		KieService ks = KieServices.Factory.get();
		kContainer = ks.getKieClasspathContainer();
	}

	@Override
	public Money applyRules(Customer customer, List<OrderLine> orderLines) {
		KieSession kSession = kContainer.newKieSession("discountSession");
		try {
			...
			kSession.fireAllRules();
		} finally {
			kSession.dispose();
		}
		return money.toImmutableMoney();
	}
}

RuleDiscounter가 출현하면서 바뀐 구조
CalculateDiscountService는 더이상 구현 기술인 Drools에 의존하지 않는다.
- RuleDiscounter 인터페이스에 의존할 뿐
- ‘룰을 이용한 할인 금액 계산’은 고수준 모듈의 개념이므로 RuleDiscounter 인터페이스는 고수준 모듈에 속한다.
- DroolsRuleDiscounter는 고수준의 하위 기능인 RuleDiscounter를 구현한 것이므로 저수준 모듈에 속한다.

DIP를 적용하면 저수준 모듈이 고수준 모듈에 의존하게 된다.
- 고수준 모듈이 저수준 모듈을 사용하려면 고수준 모듈이 저수준 모듈에 의존해야 하는데, 반대로 저수준 모듈이 고수준 모듈에 의존한다고 해서 이를 DIP(Dependency Inversion Principle, 의존 역전 원칙)이라 부른다.
DIP를 적용하면 다른 영역인 인프라스트럭처 영역에 의존할 떄 발생했던 두가지 문제인 구현 교체가 어렵다는 것과 테스트가 어려운 문제를 해소할 수 있다.

고수준 모듈은 더 이상 저수준 모듈에 의존하지 않고 구현을 추상화한 인터페이스에 의존할 수 있다.

구현 기술이 변경되더라도 저수준 구현 객체를 생성하는 코드만 변경하면 된다.

// 기존 코드
RuleDiscounter roleDiscounter = new DroolsRuleDiscounter();
CalculateDiscountService disService = new CalculateDiscountService(roleDiscounter);

// 구현 기술 변경 
RuleDiscounter roleDiscounter = new SimpleRuleDiscounter();
CalculateDiscountService disService = new CalculateDiscountService(roleDiscounter);

스프링과 같은 의존 주입을 지원하는 프레임워크를 사용하면 설정 코드를 수정해서 쉽게 구현체를 변경할 수 있다.
CalculateDiscountService가 제대로 동작하는지 테스트하려면 CustomerRepository와 RuleDiscounter를 구현한 객체가 필요하다.
- CacluateDiscountService가 저수준 모듈에 직접 의존했다면 저수준 모듈이 만들어지기 전까진 테스트를 할 수 없음
- 인터페이스에 의존함으로 대역 객체를 사용해서 테스트를 진행 할수 있다.
- 실제 구현 대신 스텁이나 모의 객체와 같은 테스트 목적의 대역을 사용하여 거의 모든 상황을 테스트할 수 있다.
```
public class CalculateDiscountServiceTest {
	@Test
	public void noCustomer_thenExcetionShouldBeThrown() {
		CustomerRepository stubRepo = mock(CustomerRepository.class);
		when(stubRepo.findById("noCustId")).thenRetrun(null);

		RuleDiscounter stubRule = (cust, lines) -> null;
		
		CalculateDiscountService calDisSvc = new CalculateDiscountService(stbRepo, stubRule);
		assertThrows(NoCustomerException.class, () -> calDisSvc.calculateDiscount(ssomeLines, "noCustId"));
	}
}
```
실제 구현 없이 테스트를 할 수 있는 이유는 DIP를 적용해서 고수준 모듈이 저수준 모듈에 의존하지 않도록 했기 때문이다.

2.3.1 DIP 주의사항

DIP를 잘못 생각하면 단순히 인터페이스와 구현 클래스를 분리하는 정도로 받아드릴 수 있다.
DIP의 핵심은 고수준 모듈이 저수준 모듈의 의존하지 않도록 하기 위함이다.
잘못된 구조
- 도메인 영역은 구현 기술을 다루는 인프라스트럭처 영역에 의존하고 있다.
- 고수준 모듈이 저수준 모듈에 의존하고 있다.
DIP를 적용할 때 하위 기능을 추상화한 인터페이스는 고수준 모듈 관점에서 도출한다.
- CalculateDiscountService는 할인 금액을 구하기 위한 룰 엔진을 사용하는지 직접 연산하는지 중요하지 않다.
- 규칙에 따라 할인 금액을 계산하는 것이 중요
- ‘할인 금액 계산’을 추상화한 인터페이스는 저수준 모듈이 아닌 고수준 모듈에 위치한다.

2.3.2 DIP와 아키텍처

인프라스트럭처 영역은 구현 기술을 다루는 저수준 모듈이고 응용 영역과 도메인 영역은 고수준 모듈이다.
인프라스트럭처 계층이 가장 하단에 위치하는 계층형 구조와 달리 아키텍처에 DIP를 적용하면 인프라스트럭처 영역이 응용 영역와 도메인 영역에 의존하는 구조가 된다.
인프라스트럭처에 위치한 클래스가 도메인이나 응용 영역에 정의한 인터페이스를 상속받아 구현하는 구조가 되므로 도메인과 응용 영역에 대한 영향을 주지 않거나 최소화하면서 구현 기술을 변경하는 것이 가능하다.
주문 시 통지 방식에 SMS를 추가해야 한다는 요구사항이 들어왔을 때 OrderService는 변경할 필요가 없다.
- 두 통지 방식을 함께 제공하는 Notifier 구현 클래스를 인프라스트럭처 영역에 추가하면 된다.
마이바티스 대신 JPA를 구현 기술로 사용하고 싶다면 JPA를 이용한 OrderRepository 구현 클래스를 인프라 스트럭처 영역에 추가하면 된다.

2.4 도메인 영역의 주요 구성요소

도메인 영역을 구성하는 요소요소 설명

엔티티 ENTITY	고유 식별자를 갖는 객체로 자신의 라이프 사이클을 갖는다. Order, Member, Product와 같이 도메인의 고유한 개념을 표현한다. 도메인 모델의 데이터를 포함하며 해당 데이터와 관련된 기능을 함께 제공
밸류 VALUE	고유 식별자를 갖지 않는 객체로 주로 개념적으로 하나의 값을 표현할 때 사용된다. 배송지 주소를 표현하기 위한 Address나 구매한 금액을 위한 Money와 같은 타입이 밸류 타입이다. 엔티티의 속성으로 사용할 뿐만 아니라 다른 밸류 타입의 속성도 사용할 수 있다.
애그리거트 AGGREGATE	애그리거트는 연관된 엔티티와 밸류 객체를 개념적으로 하나로 묶는 것이다. 주문과 관련된 Order 엔티티, OrderLine 밸류, Orderer 밸류 객체를 주문 애그리거트로 묶을 수 있다.
리포지터리 REPOSITORY	도메인 모델의 영속성을 처리한다. DBMS 테이블에서 엔티티 객체를 로딩하거나 저장하는 기능을 제공
도메인 서비스 DOMAIN SERVICE	특정 엔티티에 속하지 않는 도메인 로직을 제공한다. ‘할인 금액 계산’은 상품, 쿠폰, 회원 등급, 구매 금액 등 다양한 조건을 이용해서 구현하게 되는데 이렇게 도메인 로직이 여러 엔티티와 밸류를 필요로 하면 도메인 서비스에 로직을 구현

2.4.1 엔티티와 밸류

엔티티와 도메인 모델의 가장 큰 차이점은 도메인 모델의 엔티티는 데이터와 함께 도메인 기능을 함께 제공한다는 점
- 주문을 표현하는 엔티티는 주문과 관련된 데이터뿐만 아니라 배송지 주소 변경을 위한 기능을 함께 제공
```
public class Order {
	private OrderNo number;
	private Orderer orderer;
	private ShippingInfo shippingInfo;
	
	// 도메인 모델 엔티티는 도메인 기능도 함께 제공
	public void shangeShippingInfo(ShippingInfo newShippingInfo) {
		...	
	}
}
```
도메인 모델의 엔티티는 단순히 데이터를 담고 있는 데이터 구조라기보다는 데이터와 함께 기능을 제공하는 객체
도메인 관점에서 기능을 구현하고 기능 구현을 캡슐화해서 데이터가 임의로 변경되는 것을 막는다.
도메인 모델의 엔티티는 두 개 이상의 데이터가 개념적으로 하나인 경우 밸류 타입을 이용해서 표현할 수 있다
- Orderer는 밸류 타입으로 주문자 이름과 이메일 데이터를 포함할 수 있다.
```
public class Orderer {
	private String name;
	private String email;
}
```
RDBMS와 같은 관계형 데이터베이스는 밸류 타입을 재대로 표현하기 힘들다.
- Ordere의 개별 데이터를 저장하거나 밸로 테이블로 분리해서 저장해야 한다.
- 한 테이블에 주문자 정보 함께 넣기
  - 주문자라는 개념이 들어나지 않고 주문자의 개별 데이터만 드러난다.
- 다른 테이블에 주문자 정보 넣기
  - 주문자 데이터를 별도 테이블에 저장했지만 이것은 테이블의 엔티티에 가까우며 밸류 타입의 의미가 드러나지 않는다.

밸류는 불변으로 구현할 것을 권장

엔티티의 밸류 타입 데이터를 변경할 떄는 객체 자체를 완전히 교체한다는 것을 의미

public class Order {
	private ShippingInfo shippingInfo;
	
	public void shangeShippingInfo(ShippingInfo newShippingInfo) {
		checkShippingInfoChangeable();
		setShippingInfo(newShippingInfo);
	}

	private void setShippingInfo(ShippingInfo newShippingInfo) {
		if (newShippingInfo == null) {
			throw new IllegalArgumentException();
		}
		this.shippingInfo = newShippingInfo;
	}
}

2.4.2 애그리거트

도메인이 커질수록 개발할 도메인 모델도 커지면서 많은 엔티티와 밸류가 출현한다.
도메인 모델이 복잡해지면 개발자가 전체 구조가 아닌 한 개 엔티티와 밸류에만 집중하는 상황이 발생한다.
- 상위 수준에서 모델을 관리하지 않고 개별 요소에만 초점을 맞추다 보면, 큰 수준에서 모델을 이해하지 못해 큰 틀에서 모델은 관리할 수 없는 상황에 빠질 수 있다.
도메인 모델에 전체 구조를 이해하는데 도움이 되는 것이 바로 애그리거트(AGGREGATE)이다.
애그리거트는 관련 객체를 하나로 묶은 군집이다.
- 모메인 개념은“주문”, “배송지 정보”, “주문자”, “주문 목록”, “총 결제 금액”의 하위 모델로 구성된다.
- 하위 내념을 표현한 모델을 하나로 묶어서 “주문”이라는 상위 개념으로 표현할 수 있다.
애그리거트를 사용하면 개별 객체가 아닌 관련 객체를 묶어서 객체 군집 단위로 모델을 바라볼 수 있게 된다.
- 개별 객체 간의 관계가 아닌 애그리거트 간의 관계로 도메인 모델을 이해하고 구현하고, 큰 틀에서 도메인 모델을 관리할 수 있다.
애그리거트는 군집에 속한 객체를 관리하는 루트 엔티티를 갖는다.
- 루트 엔티티는 애그리거트에 속해 있는 엔티티와 밸류 객체를 이용해서 애그리거트가 구현해야 할 기능을 제공
- 애그리거트를 사용하는 코드는 애그리거트 루트가 제공하는 기능을 실행
- 애그리거트 루트를 통해 간접적으로 애그리거트 내의 다른 엔티티나 밸류 객체에 접근
- 애그리거트의 내부 구현을 숨겨서 애그리거트 단위로 구현을 캡슐화할 수 있도록 돕는다.
주문 애그리거트
- 애그리거트 루트인 Order는 주문 도메인 로직에 맞게 애그리거트의 상태를 관리
- Order의 배송지 정보 변경 기능은 배송지를 변경할 수 있는지를 확인한 위에 배송지 정보를 변경
- 주문 애그리거트는 Order를 통하지 않고 ShippingInfo를 변경할 수 있는 방법을 제공하지 않는다.
  - 배송지를 변경하려면 루트 엔티티인 Order를 사용해야 하므로 배소지 정보를 변경할 때는 Order가 구현한 도메인 로직을 항상 따르게 된다.
애그리거트를 구현할 때는 고려할 것이 많다.
- 애그리거트를 어떻게 구성했느냐에 따라 구현이 복잡해지기도 하고
- 트랜잭션 범위가 달라지기도 한다.

2.4.3 리포지터리

도메인 객체를 지속적으로 사용하려면 RDBMS, NoSQL, 로컬 파일과 같은 물리적인 저장소에 도메인 객체를 보관해야 한다.
- 이를 위한 도메인 모델이 리포지터리(Repository)이다.
엔티티나 밸류가 요구사항에 도출되는 도메인 모델이라면 리포리터리는 구현을 위한 도메인 모델이다.
리포지터리는 애그리거트 단위로 도메인 객체를 저장하고 조회하는 기능을 정의
- OrderRepository의 메서드를 보면 대상을 찾고 저장하는 단위가 애그리거트 루트인 Order인 것을 알 수 있다.
- Order는 애그리거트에 속한 모든 객체를 포함하고 있으므로 결과적으로 애그리거트 단위로 저장하고 조회한다.
```
public interface OrderRepository {
	Order findByNumber(OrderNumber number);
	void save(Order order);
	void delete(Order order);
}
```
도메인 모델을 사용해야 하는 코드는 리포지터리를 통해서 도메인 객체를 구한 뒤에 도메인 객체의 기능을 실행
public class CancelOrderService { private OrderRepository orderRepository; public void cancel(OrderNumber number) { Order order = orderRepository.findByNumber(number); if (order == null) { throw new OrderNotFoundException(orderId); } order.cancel(); } }
도메인 모델 관점에서 OrderRepository는 도메인 객체를 영속화하는 데 필요한 기능을 추상화 한것으로 고수준 모듈에 속한다.
기반 기술을 이용해서 OrderRepository를 구현한 클래스는 저수준 모듈로 인프라스트럭처 영역에 속한다.
전체 모듈 구조
응용 서비스는 의존 주입과 같은 방식을 사용해서 실제 리포지터리 구현 객체에 접근
응용 서비스와 리포지터리는 밀접한 연관이 있다.
- 응용 서비스는 필요한 도메인 객체를 구하거나 저장할 때 리포지터리를 사용한다.
- 응용 서비스는 트랜잭션을 관리하는데, 트랜잭션 처리는 리포지터리 구현 기술의 영향을 받는다.
리포지터리를 사용하는 주체가 응용 서비스이기 때문에 리포지터리는 응용 서비스가 필요로 하는 메서드를 제공한다.
- 애그리거트를 저장하는 메서드
- 애그리거트 루트 식별자로 애그리거트를 조회하는 메서드

2.5 요청 처리 흐름

표현 영역은 사용자가 전송한 데이터 형식이 올바른지 검사하고 문제가 없다면 데이터를 이용해서 응용 서비스에 기능 실행을 위임
표현 영역은 사용자가 전송한 데이터를 응용 서비스가 요구하는 형식으로 변환해서 전달
요청 처리 흐름
- 웹 브라우저에서 기능 실행 요청
- 표현 영역에 해당하는 컨트롤러는 HTTP 요청 파라미터를 응용 서비스가 필요로 하는 데이터로 변환 해서 응용 서비스의 인자로 전달
- 응용 서비스는 도메인 모델을 이용해서 로직 실행
- 도메인 객체를 리포지터리에서 가져와 실행하거나 신규 도메인 객체를 생성해 리포지터리에 저장
“예매하기”나 “예매 취소”와 같은 기능을 제공하는 응용 서비스는 도메인의 상태를 변경하므로 변경 상태가 물리 저장소에 올바르게 반영되도록 트랜잭션을 관리 해야한다.
- 스프링 프레임워크를 사용한다면 @Transactional 애너테이션을 이용해 트랜잭션을 처리할 수 있다.
```
public class CancelOrderService {
	private OrderRepository orderRepository;
	
	@Transactional
	public void cancel(OrderNumber number) {
		Order order = orderRepository.findByNumber(number);
		if (order == null) {
			throw new NoOrderException(number);
		}
		order.cancel()
	}
}
```

2.6 인프라스트럭처 개요

인프라스트럭처는 표현 영역, 응용 영역, 도메인 영역을 지원한다.
도메인 영역과 응용 영역에서 인프라스트럭처의 기능을 직접 사용하는 것보다 두 영역에서 정의한 인터페이스를 인프라스트럭처 영역에서 구현하는 것이 시스템을 더 유연하고 테스트하기 쉽게 만들어 준다.
무조건 인프라스트럭처에 대한 의존성을 없앨 필요는 없다.
- 스프링을 사용할 경우 응용 서비스는 트랜잭션 처리를 위해 @Transactional을 사용하는 것이 편리하다.
- 영속성 처리를 위해 JPA를 사용할 경우 @Entity나 @Table과 같은 JPA 전용 애너테이션을 도메인 모델 클래스에서 사용하는 것이 XML 매핑 설정을 이용하는 것보다 편리하다.
구현의 편리함은 DIP가 주는 다른 장점만큼 중요하기 때문에 DIP의 장점을 해치지 않는 범위에서 응용 영역과 도메인 영역에서 구현 기술에 대한 의존을 가져가는 것이 나쁘지 않다고 생각한다.
응용 영역과 도메인 영역이 인프라스트럭처에 대한 의존을 완전히 갖지 않도록 시도하는 것은 구현을 더 복잡하고 어렵게 만들 수 있다.
- @Transactional을 사용하면 한 줄로 트랙잭션을 처리할 수 있는데 코드에서 스프링에 대한 의존을 없애려면 복잡한 스프링 설정을 사용해야 한다.
- 의존은 없앴지만 특별히 테스트를 더 쉽게 할 수 있다거나 유연함을 증가시켜 주지 못한다.
- 설정만 복잡해지고 개발 시간만 늘어난다.
표현 영역은 항상 인프라스트럭처 영역과 쌍을 이룬다.
- 스프링 MVC를 사용해서 웹 요청을 처리하려면 스프링이 제공하는 MVC 프레임워크에 맞게 표현 영역을 구현
- Vert.x를 사용해서 Rest API 서버를 구축하려면 Vert.x에 맞게 웹 요청 처리 부분을 구현

2.7 모듈 구성

아키텍처의 각 영역은 별도 패키지에 위치한다.
패키지 구성 규칙에 정답이 존재하는 것은 안지만 영역별로 모듈이 위치할 패키지를 구성할 수 있을 것 이다.
도메인이 크면 하위 도메인으로 나누고 하위 도메인마다 별도 패키지를 구성한다.
도메인 모듈은 도메인에 속한 애그리거트를 기준으로 다시 패키지를 구성한다.
- 카탈로그 하위 도메인이 상품 애그리거트와 카테고리 애그리커트로 구성될 경우 도메인을 두 개의 하위 패키지로 구성할 수 있다.
애그리거트, 모델, 리포지터리는 같은 패키지에 위치시킨다.
- Order, OrderLine, Orderer, OrderRepository 등은 com.myshop.order.domain 패키지에 위치시킨다.
도메인이 복잡하면 도메인 모델과 도메인 서비스를 별도 패키지에 위치시킬 수도 있다.
- com.myshop.order.domain.order: 애그리거트 위치
- com.myshop.order.domain.service: 도메인 서비스 위치
응용 서비스도 도메인 별로 패키지를 구분할 수 있다.
- com.myshop.catalog.application.product
- com.myshop.catalog.application.category
모듈 구조를 얼마나 세분하게해야 하는지에 대한 정해진 규칙은 없다.
한 패키지에 너무 많은 타입이 몰려서 코드를 찾을 때 불편할 정도만 아니면 된다.

2.1 네 개의 영역

“표현”, “응용”, “도메인”, “인프라스트럭처”는 아키텍처를 설계할 때 출현하는 전형적인 네 가지 영역
- 표현 영역
  - 사용자의 요청을 받아 응용 영역에 전달, 응용 영역의 처리 결과를 사용자에게 전달
  - 스프링 MVC 프레임워크가 표현 영역의 기술
- 응용 영역
  - 표현 영역을 통해 사용자의 요청을 전달받은 응용 영역은 시스템이 사용자에게 제공해야할 기능을 구현
  - “주문 등록”, “주문 취소”, “상품 상세 조회” 등의 기능을 예로 들수 있다.
  - 기능을 구현하기 위한 도메인 영역의 도메인 모델을 사용
  - “주문 취소” 기능을 제공하는 응용 서비스를 도메인 모델을 사용해서 기능 구현이 가능
  - public class CancelOrderService { @Transactional public void cancelOrder(String orderId) { Order order = findOrderById(orderId); if (order == null) { throw new OrderNotFoundException(orderId); } order.cancel(); } }
  - 로직을 직접 수행하기보다는 도메인 모델에 로직 수행을 위임
    - “주문 취소” 로직을 직접 구현하지 않고 Order 객체에 취소 처리를 위임 하고 있다
- 도메인 영역
  - Order, OrderLine, ShippingInfo와 같은 도메인 모델
  - 도메인 모델은 핵심 로직을 구현한다.
    - “배송지 변경”, “결제 완료”, “주문 총액 계산”과 같은 핵심 로직을 도메인 모델에 구현한다.
- 인프라스트럭처 영역
  - 구현 기술에 대한 것을 다룬다
  - RDBMS 연동, 메시징 큐에 메시지 전송과 수신, 몽고DB나 레디스의 데이터 연동 처리 등
  - 논리적인 개념을 표현하기보다는 실제 구현을 다룬다
  - 도메인 영역, 응용 영역, 표현 영역은 구현 기술을 사용한 코드를 직접 만들지 않는다.
    - 인프라스트럭처 영역에서 제공하는 기능을 사용해서 필요한 기능을 개발

2.2 계층 구조 아키텍처

네 영역을 구성할 때 많이 사용하는 아키텍처가 그림과 같은 계층 구조이다.
- 표현 영역과 응용 영역은 도메인 영역을 사용
- 도메인 영역은 인프라스트럭처 영역을 사용
도메인의 복잡도에 따라 응용과 도메인을 분리하기도 하고 한 계층으로 합치기도 하지만 전체적인 아키텍처는 계층 구조를 따른다.
계층 구조는 특성상 상위 계층에서 하위 계층으로의 의존만 존재하고 하위 계층은 상위 계층에 의존하지 않는다.
계층 구조를 엄격하게 적용한다면 상위 계층은 바로 아래의 계층에만 의존을 가져야 하지만 구현의 편리함을 위해 계층 구조를 유연하게 적용하기도 한다.
응용 영역과 도메인 영역은 DB나 외부 시스템 연동을 위해 인프라스트럭처의 기능을 사용하므로 계층 구조를 사용하는 것이 직관적으로 이해하기 쉽다.
- 표현, 응용, 도메인 계층이 상세한 구현 기술을 다루는 인프라스트럭처 계층에 종속된다

도메인의 가격 계산 규칙의 예제

할인 금액을 계산하기 위해 Drools라는 룰 엔진을 사용해서 계산 로직을 수행하는 인프라스트럭처 영역의 코드를 만들어 보자

public class DroolsRuleEngine {
	private KieContainer kContainer;

	public DroolsRuleEngine() {
		KieServices ks = KieServices.Factory.get();
		kContainer = ks.getKieClasspathContainer();		
	}

	public void evalute(String sessionName, List<?> facts) {
		KiSession kSession = kContainer.newKieSession(sessionName);
		try {
			facts.forEach(x -> kSession.insert(x));
			kSession.fireAllRules();
		} finaly {
			kSession.dispose();
		}
	}
}

응용 영역은 가격 계산을 위해 인프라스트럭처 영역의 DroolsRuleEngine을 사용

public class CalcuateDiscountService {
	private DroolsRuleEngine ruleEngine;
	
	public CalculateDiscountService() {
		ruleEngine = new DroolsRuleEngine();
	}

	public Money calculateDiscount(List<OrderLine> orderLines, String customerId) {
		Customer customer = findCustomer(customerId);
		
		MutableMoney money = new MutableMoney(0);
		List<?> facts = Arrays.asList(customer, money);
		facts.addAll(orderLines);
		ruleEngine.evalute("discountCalculation", facts);
		return money.toImmutableMoney();
	}
}

CalculateDiscountService가 동작은 하겠지만 두가지 문제를 안고 있다.
- CalculateDiscountService를 테스트하기 어렵다
  - RuleEngine이 완벽하게 동작해야 한다.
  - RuleEngine 클래스와 관련 설정 파일 모두 만든 이후에 CalculateDiscountService 를 확인할 수 있다.
- 구현 방식을 변경하기 어렵다
  - ‘discountCalculation’ 문자열은 Drools의 세션 이름을 의미한다.
  - 세션 이름을 변경하면 CalculateDiscountService 코드도 함께 변경해야 한다.
CalculateDiscountService가 겉으로는 인프라스트럭처의 기술에 직접적인 의존을 하지 않는 것처럼 보여도 실제로는 Drools라는 인프라스트럭처 영역의 기술에 완전하게 의존하고 있다.
인프라스트럭처에 의존하면 ‘테스트 어려움’과 ‘기능 확장 어려움’이라는 두가지 문제가 발생한다.
- 문제 해답은 DIP에 있다.

2.3 DIP

가격 할인 계산을 하려면 고객 정보를 구해야하고, 구한 고객 정보와 주문 정보를 이용해서 룰을 실행해야 한다.
CalculateDiscountService는 고수준 모듈이다.
- 고수준 모듈은 의미 있는 단일 기능을 제공하는 모듈로 ‘가격 할인 계산’이라는 기능을 구현
- 가격 할인 계싼 기능을 구현하려면 고객 정보를 구해야하고 룰을 실행해야 하는데 이 두 기능이 하위 기능이다.
저수준 모듈은 하위 기능을 실제로 구현한 것이다.
- JPA를 이용해서 고객 정보를 읽어오는 모듈과 Drools로 룰을 실행하는 모듈이 저수준 모듈이 된다.

DIP는 저수준 모듈이 고수준 모듈에 의존하도록 바꾼다.

추상화 인터페이스를 사용

public interface RuleDiscounter {
	Money applyRules(Customer customer, List<OrderLine> orderLines);
}

CalculateDiscountService가 RuleDiscounter를 이용하도록 변경
- Drools에 의존하는 코드가 없다

public class CalcuateDiscountService {
	private RuleDiscounter ruleDiscounter;
	
	public CalculateDiscountService(RuleDiscounter ruleDiscounter) {
		this.ruleDiscounter = ruleDiscounter;
	}

	public Money calculateDiscount(List<OrderLine> orderLines, String customerId) {
		Customer customer = findCustomer(customerId);
		return ruleDiscounter.applyRules(customer, orderLines);
	}
}

RuleDiscounter를 상속받아 구현

public class DroolsRuleDiscounter implements RuleDiscounter {
	private KieCountainer kContainer;
	
	public DroolsRuleEngine() {
		KieService ks = KieServices.Factory.get();
		kContainer = ks.getKieClasspathContainer();
	}

	@Override
	public Money applyRules(Customer customer, List<OrderLine> orderLines) {
		KieSession kSession = kContainer.newKieSession("discountSession");
		try {
			...
			kSession.fireAllRules();
		} finally {
			kSession.dispose();
		}
		return money.toImmutableMoney();
	}
}

RuleDiscounter가 출현하면서 바뀐 구조
CalculateDiscountService는 더이상 구현 기술인 Drools에 의존하지 않는다.
- RuleDiscounter 인터페이스에 의존할 뿐
- ‘룰을 이용한 할인 금액 계산’은 고수준 모듈의 개념이므로 RuleDiscounter 인터페이스는 고수준 모듈에 속한다.
- DroolsRuleDiscounter는 고수준의 하위 기능인 RuleDiscounter를 구현한 것이므로 저수준 모듈에 속한다.

DIP를 적용하면 저수준 모듈이 고수준 모듈에 의존하게 된다.
- 고수준 모듈이 저수준 모듈을 사용하려면 고수준 모듈이 저수준 모듈에 의존해야 하는데, 반대로 저수준 모듈이 고수준 모듈에 의존한다고 해서 이를 DIP(Dependency Inversion Principle, 의존 역전 원칙)이라 부른다.
DIP를 적용하면 다른 영역인 인프라스트럭처 영역에 의존할 떄 발생했던 두가지 문제인 구현 교체가 어렵다는 것과 테스트가 어려운 문제를 해소할 수 있다.

고수준 모듈은 더 이상 저수준 모듈에 의존하지 않고 구현을 추상화한 인터페이스에 의존할 수 있다.

구현 기술이 변경되더라도 저수준 구현 객체를 생성하는 코드만 변경하면 된다.

// 기존 코드
RuleDiscounter roleDiscounter = new DroolsRuleDiscounter();
CalculateDiscountService disService = new CalculateDiscountService(roleDiscounter);

// 구현 기술 변경 
RuleDiscounter roleDiscounter = new SimpleRuleDiscounter();
CalculateDiscountService disService = new CalculateDiscountService(roleDiscounter);

스프링과 같은 의존 주입을 지원하는 프레임워크를 사용하면 설정 코드를 수정해서 쉽게 구현체를 변경할 수 있다.
CalculateDiscountService가 제대로 동작하는지 테스트하려면 CustomerRepository와 RuleDiscounter를 구현한 객체가 필요하다.
- CacluateDiscountService가 저수준 모듈에 직접 의존했다면 저수준 모듈이 만들어지기 전까진 테스트를 할 수 없음
- 인터페이스에 의존함으로 대역 객체를 사용해서 테스트를 진행 할수 있다.
- 실제 구현 대신 스텁이나 모의 객체와 같은 테스트 목적의 대역을 사용하여 거의 모든 상황을 테스트할 수 있다.
```
public class CalculateDiscountServiceTest {
	@Test
	public void noCustomer_thenExcetionShouldBeThrown() {
		CustomerRepository stubRepo = mock(CustomerRepository.class);
		when(stubRepo.findById("noCustId")).thenRetrun(null);

		RuleDiscounter stubRule = (cust, lines) -> null;
		
		CalculateDiscountService calDisSvc = new CalculateDiscountService(stbRepo, stubRule);
		assertThrows(NoCustomerException.class, () -> calDisSvc.calculateDiscount(ssomeLines, "noCustId"));
	}
}
```
실제 구현 없이 테스트를 할 수 있는 이유는 DIP를 적용해서 고수준 모듈이 저수준 모듈에 의존하지 않도록 했기 때문이다.

2.3.1 DIP 주의사항

DIP를 잘못 생각하면 단순히 인터페이스와 구현 클래스를 분리하는 정도로 받아드릴 수 있다.
DIP의 핵심은 고수준 모듈이 저수준 모듈의 의존하지 않도록 하기 위함이다.
잘못된 구조
- 도메인 영역은 구현 기술을 다루는 인프라스트럭처 영역에 의존하고 있다.
- 고수준 모듈이 저수준 모듈에 의존하고 있다.
DIP를 적용할 때 하위 기능을 추상화한 인터페이스는 고수준 모듈 관점에서 도출한다.
- CalculateDiscountService는 할인 금액을 구하기 위한 룰 엔진을 사용하는지 직접 연산하는지 중요하지 않다.
- 규칙에 따라 할인 금액을 계산하는 것이 중요
- ‘할인 금액 계산’을 추상화한 인터페이스는 저수준 모듈이 아닌 고수준 모듈에 위치한다.

2.3.2 DIP와 아키텍처

인프라스트럭처 영역은 구현 기술을 다루는 저수준 모듈이고 응용 영역과 도메인 영역은 고수준 모듈이다.
인프라스트럭처 계층이 가장 하단에 위치하는 계층형 구조와 달리 아키텍처에 DIP를 적용하면 인프라스트럭처 영역이 응용 영역와 도메인 영역에 의존하는 구조가 된다.
인프라스트럭처에 위치한 클래스가 도메인이나 응용 영역에 정의한 인터페이스를 상속받아 구현하는 구조가 되므로 도메인과 응용 영역에 대한 영향을 주지 않거나 최소화하면서 구현 기술을 변경하는 것이 가능하다.
주문 시 통지 방식에 SMS를 추가해야 한다는 요구사항이 들어왔을 때 OrderService는 변경할 필요가 없다.
- 두 통지 방식을 함께 제공하는 Notifier 구현 클래스를 인프라스트럭처 영역에 추가하면 된다.
마이바티스 대신 JPA를 구현 기술로 사용하고 싶다면 JPA를 이용한 OrderRepository 구현 클래스를 인프라 스트럭처 영역에 추가하면 된다.

2.4 도메인 영역의 주요 구성요소

도메인 영역을 구성하는 요소요소 설명

엔티티 ENTITY	고유 식별자를 갖는 객체로 자신의 라이프 사이클을 갖는다. Order, Member, Product와 같이 도메인의 고유한 개념을 표현한다. 도메인 모델의 데이터를 포함하며 해당 데이터와 관련된 기능을 함께 제공
밸류 VALUE	고유 식별자를 갖지 않는 객체로 주로 개념적으로 하나의 값을 표현할 때 사용된다. 배송지 주소를 표현하기 위한 Address나 구매한 금액을 위한 Money와 같은 타입이 밸류 타입이다. 엔티티의 속성으로 사용할 뿐만 아니라 다른 밸류 타입의 속성도 사용할 수 있다.
애그리거트 AGGREGATE	애그리거트는 연관된 엔티티와 밸류 객체를 개념적으로 하나로 묶는 것이다. 주문과 관련된 Order 엔티티, OrderLine 밸류, Orderer 밸류 객체를 주문 애그리거트로 묶을 수 있다.
리포지터리 REPOSITORY	도메인 모델의 영속성을 처리한다. DBMS 테이블에서 엔티티 객체를 로딩하거나 저장하는 기능을 제공
도메인 서비스 DOMAIN SERVICE	특정 엔티티에 속하지 않는 도메인 로직을 제공한다. ‘할인 금액 계산’은 상품, 쿠폰, 회원 등급, 구매 금액 등 다양한 조건을 이용해서 구현하게 되는데 이렇게 도메인 로직이 여러 엔티티와 밸류를 필요로 하면 도메인 서비스에 로직을 구현

2.4.1 엔티티와 밸류

엔티티와 도메인 모델의 가장 큰 차이점은 도메인 모델의 엔티티는 데이터와 함께 도메인 기능을 함께 제공한다는 점
- 주문을 표현하는 엔티티는 주문과 관련된 데이터뿐만 아니라 배송지 주소 변경을 위한 기능을 함께 제공
```
public class Order {
	private OrderNo number;
	private Orderer orderer;
	private ShippingInfo shippingInfo;
	
	// 도메인 모델 엔티티는 도메인 기능도 함께 제공
	public void shangeShippingInfo(ShippingInfo newShippingInfo) {
		...	
	}
}
```
도메인 모델의 엔티티는 단순히 데이터를 담고 있는 데이터 구조라기보다는 데이터와 함께 기능을 제공하는 객체
도메인 관점에서 기능을 구현하고 기능 구현을 캡슐화해서 데이터가 임의로 변경되는 것을 막는다.
도메인 모델의 엔티티는 두 개 이상의 데이터가 개념적으로 하나인 경우 밸류 타입을 이용해서 표현할 수 있다
- Orderer는 밸류 타입으로 주문자 이름과 이메일 데이터를 포함할 수 있다.
```
public class Orderer {
	private String name;
	private String email;
}
```
RDBMS와 같은 관계형 데이터베이스는 밸류 타입을 재대로 표현하기 힘들다.
- Ordere의 개별 데이터를 저장하거나 밸로 테이블로 분리해서 저장해야 한다.
- 한 테이블에 주문자 정보 함께 넣기
  - 주문자라는 개념이 들어나지 않고 주문자의 개별 데이터만 드러난다.
- 다른 테이블에 주문자 정보 넣기
  - 주문자 데이터를 별도 테이블에 저장했지만 이것은 테이블의 엔티티에 가까우며 밸류 타입의 의미가 드러나지 않는다.

밸류는 불변으로 구현할 것을 권장

엔티티의 밸류 타입 데이터를 변경할 떄는 객체 자체를 완전히 교체한다는 것을 의미

public class Order {
	private ShippingInfo shippingInfo;
	
	public void shangeShippingInfo(ShippingInfo newShippingInfo) {
		checkShippingInfoChangeable();
		setShippingInfo(newShippingInfo);
	}

	private void setShippingInfo(ShippingInfo newShippingInfo) {
		if (newShippingInfo == null) {
			throw new IllegalArgumentException();
		}
		this.shippingInfo = newShippingInfo;
	}
}

2.4.2 애그리거트

도메인이 커질수록 개발할 도메인 모델도 커지면서 많은 엔티티와 밸류가 출현한다.
도메인 모델이 복잡해지면 개발자가 전체 구조가 아닌 한 개 엔티티와 밸류에만 집중하는 상황이 발생한다.
- 상위 수준에서 모델을 관리하지 않고 개별 요소에만 초점을 맞추다 보면, 큰 수준에서 모델을 이해하지 못해 큰 틀에서 모델은 관리할 수 없는 상황에 빠질 수 있다.
도메인 모델에 전체 구조를 이해하는데 도움이 되는 것이 바로 애그리거트(AGGREGATE)이다.
애그리거트는 관련 객체를 하나로 묶은 군집이다.
- 모메인 개념은“주문”, “배송지 정보”, “주문자”, “주문 목록”, “총 결제 금액”의 하위 모델로 구성된다.
- 하위 내념을 표현한 모델을 하나로 묶어서 “주문”이라는 상위 개념으로 표현할 수 있다.
애그리거트를 사용하면 개별 객체가 아닌 관련 객체를 묶어서 객체 군집 단위로 모델을 바라볼 수 있게 된다.
- 개별 객체 간의 관계가 아닌 애그리거트 간의 관계로 도메인 모델을 이해하고 구현하고, 큰 틀에서 도메인 모델을 관리할 수 있다.
애그리거트는 군집에 속한 객체를 관리하는 루트 엔티티를 갖는다.
- 루트 엔티티는 애그리거트에 속해 있는 엔티티와 밸류 객체를 이용해서 애그리거트가 구현해야 할 기능을 제공
- 애그리거트를 사용하는 코드는 애그리거트 루트가 제공하는 기능을 실행
- 애그리거트 루트를 통해 간접적으로 애그리거트 내의 다른 엔티티나 밸류 객체에 접근
- 애그리거트의 내부 구현을 숨겨서 애그리거트 단위로 구현을 캡슐화할 수 있도록 돕는다.
주문 애그리거트
- 애그리거트 루트인 Order는 주문 도메인 로직에 맞게 애그리거트의 상태를 관리
- Order의 배송지 정보 변경 기능은 배송지를 변경할 수 있는지를 확인한 위에 배송지 정보를 변경
- 주문 애그리거트는 Order를 통하지 않고 ShippingInfo를 변경할 수 있는 방법을 제공하지 않는다.
  - 배송지를 변경하려면 루트 엔티티인 Order를 사용해야 하므로 배소지 정보를 변경할 때는 Order가 구현한 도메인 로직을 항상 따르게 된다.
애그리거트를 구현할 때는 고려할 것이 많다.
- 애그리거트를 어떻게 구성했느냐에 따라 구현이 복잡해지기도 하고
- 트랜잭션 범위가 달라지기도 한다.

2.4.3 리포지터리

도메인 객체를 지속적으로 사용하려면 RDBMS, NoSQL, 로컬 파일과 같은 물리적인 저장소에 도메인 객체를 보관해야 한다.
- 이를 위한 도메인 모델이 리포지터리(Repository)이다.
엔티티나 밸류가 요구사항에 도출되는 도메인 모델이라면 리포리터리는 구현을 위한 도메인 모델이다.
리포지터리는 애그리거트 단위로 도메인 객체를 저장하고 조회하는 기능을 정의
- OrderRepository의 메서드를 보면 대상을 찾고 저장하는 단위가 애그리거트 루트인 Order인 것을 알 수 있다.
- Order는 애그리거트에 속한 모든 객체를 포함하고 있으므로 결과적으로 애그리거트 단위로 저장하고 조회한다.
```
public interface OrderRepository {
	Order findByNumber(OrderNumber number);
	void save(Order order);
	void delete(Order order);
}
```
도메인 모델을 사용해야 하는 코드는 리포지터리를 통해서 도메인 객체를 구한 뒤에 도메인 객체의 기능을 실행
public class CancelOrderService { private OrderRepository orderRepository; public void cancel(OrderNumber number) { Order order = orderRepository.findByNumber(number); if (order == null) { throw new OrderNotFoundException(orderId); } order.cancel(); } }
도메인 모델 관점에서 OrderRepository는 도메인 객체를 영속화하는 데 필요한 기능을 추상화 한것으로 고수준 모듈에 속한다.
기반 기술을 이용해서 OrderRepository를 구현한 클래스는 저수준 모듈로 인프라스트럭처 영역에 속한다.
전체 모듈 구조
응용 서비스는 의존 주입과 같은 방식을 사용해서 실제 리포지터리 구현 객체에 접근
응용 서비스와 리포지터리는 밀접한 연관이 있다.
- 응용 서비스는 필요한 도메인 객체를 구하거나 저장할 때 리포지터리를 사용한다.
- 응용 서비스는 트랜잭션을 관리하는데, 트랜잭션 처리는 리포지터리 구현 기술의 영향을 받는다.
리포지터리를 사용하는 주체가 응용 서비스이기 때문에 리포지터리는 응용 서비스가 필요로 하는 메서드를 제공한다.
- 애그리거트를 저장하는 메서드
- 애그리거트 루트 식별자로 애그리거트를 조회하는 메서드

2.5 요청 처리 흐름

표현 영역은 사용자가 전송한 데이터 형식이 올바른지 검사하고 문제가 없다면 데이터를 이용해서 응용 서비스에 기능 실행을 위임
표현 영역은 사용자가 전송한 데이터를 응용 서비스가 요구하는 형식으로 변환해서 전달
요청 처리 흐름
- 웹 브라우저에서 기능 실행 요청
- 표현 영역에 해당하는 컨트롤러는 HTTP 요청 파라미터를 응용 서비스가 필요로 하는 데이터로 변환 해서 응용 서비스의 인자로 전달
- 응용 서비스는 도메인 모델을 이용해서 로직 실행
- 도메인 객체를 리포지터리에서 가져와 실행하거나 신규 도메인 객체를 생성해 리포지터리에 저장
“예매하기”나 “예매 취소”와 같은 기능을 제공하는 응용 서비스는 도메인의 상태를 변경하므로 변경 상태가 물리 저장소에 올바르게 반영되도록 트랜잭션을 관리 해야한다.
- 스프링 프레임워크를 사용한다면 @Transactional 애너테이션을 이용해 트랜잭션을 처리할 수 있다.
```
public class CancelOrderService {
	private OrderRepository orderRepository;
	
	@Transactional
	public void cancel(OrderNumber number) {
		Order order = orderRepository.findByNumber(number);
		if (order == null) {
			throw new NoOrderException(number);
		}
		order.cancel()
	}
}
```

2.6 인프라스트럭처 개요

인프라스트럭처는 표현 영역, 응용 영역, 도메인 영역을 지원한다.
도메인 영역과 응용 영역에서 인프라스트럭처의 기능을 직접 사용하는 것보다 두 영역에서 정의한 인터페이스를 인프라스트럭처 영역에서 구현하는 것이 시스템을 더 유연하고 테스트하기 쉽게 만들어 준다.
무조건 인프라스트럭처에 대한 의존성을 없앨 필요는 없다.
- 스프링을 사용할 경우 응용 서비스는 트랜잭션 처리를 위해 @Transactional을 사용하는 것이 편리하다.
- 영속성 처리를 위해 JPA를 사용할 경우 @Entity나 @Table과 같은 JPA 전용 애너테이션을 도메인 모델 클래스에서 사용하는 것이 XML 매핑 설정을 이용하는 것보다 편리하다.
구현의 편리함은 DIP가 주는 다른 장점만큼 중요하기 때문에 DIP의 장점을 해치지 않는 범위에서 응용 영역과 도메인 영역에서 구현 기술에 대한 의존을 가져가는 것이 나쁘지 않다고 생각한다.
응용 영역과 도메인 영역이 인프라스트럭처에 대한 의존을 완전히 갖지 않도록 시도하는 것은 구현을 더 복잡하고 어렵게 만들 수 있다.
- @Transactional을 사용하면 한 줄로 트랙잭션을 처리할 수 있는데 코드에서 스프링에 대한 의존을 없애려면 복잡한 스프링 설정을 사용해야 한다.
- 의존은 없앴지만 특별히 테스트를 더 쉽게 할 수 있다거나 유연함을 증가시켜 주지 못한다.
- 설정만 복잡해지고 개발 시간만 늘어난다.
표현 영역은 항상 인프라스트럭처 영역과 쌍을 이룬다.
- 스프링 MVC를 사용해서 웹 요청을 처리하려면 스프링이 제공하는 MVC 프레임워크에 맞게 표현 영역을 구현
- Vert.x를 사용해서 Rest API 서버를 구축하려면 Vert.x에 맞게 웹 요청 처리 부분을 구현

2.7 모듈 구성

아키텍처의 각 영역은 별도 패키지에 위치한다.
패키지 구성 규칙에 정답이 존재하는 것은 안지만 영역별로 모듈이 위치할 패키지를 구성할 수 있을 것 이다.
도메인이 크면 하위 도메인으로 나누고 하위 도메인마다 별도 패키지를 구성한다.
도메인 모듈은 도메인에 속한 애그리거트를 기준으로 다시 패키지를 구성한다.
- 카탈로그 하위 도메인이 상품 애그리거트와 카테고리 애그리커트로 구성될 경우 도메인을 두 개의 하위 패키지로 구성할 수 있다.
애그리거트, 모델, 리포지터리는 같은 패키지에 위치시킨다.
- Order, OrderLine, Orderer, OrderRepository 등은 com.myshop.order.domain 패키지에 위치시킨다.
도메인이 복잡하면 도메인 모델과 도메인 서비스를 별도 패키지에 위치시킬 수도 있다.
- com.myshop.order.domain.order: 애그리거트 위치
- com.myshop.order.domain.service: 도메인 서비스 위치
응용 서비스도 도메인 별로 패키지를 구분할 수 있다.
- com.myshop.catalog.application.product
- com.myshop.catalog.application.category
모듈 구조를 얼마나 세분하게해야 하는지에 대한 정해진 규칙은 없다.
한 패키지에 너무 많은 타입이 몰려서 코드를 찾을 때 불편할 정도만 아니면 된다.

2.1 네 개의 영역

“표현”, “응용”, “도메인”, “인프라스트럭처”는 아키텍처를 설계할 때 출현하는 전형적인 네 가지 영역
- 표현 영역
  - 사용자의 요청을 받아 응용 영역에 전달, 응용 영역의 처리 결과를 사용자에게 전달
  - 스프링 MVC 프레임워크가 표현 영역의 기술
- 응용 영역
  - 표현 영역을 통해 사용자의 요청을 전달받은 응용 영역은 시스템이 사용자에게 제공해야할 기능을 구현
  - “주문 등록”, “주문 취소”, “상품 상세 조회” 등의 기능을 예로 들수 있다.
  - 기능을 구현하기 위한 도메인 영역의 도메인 모델을 사용
  - “주문 취소” 기능을 제공하는 응용 서비스를 도메인 모델을 사용해서 기능 구현이 가능
  - public class CancelOrderService { @Transactional public void cancelOrder(String orderId) { Order order = findOrderById(orderId); if (order == null) { throw new OrderNotFoundException(orderId); } order.cancel(); } }
  - 로직을 직접 수행하기보다는 도메인 모델에 로직 수행을 위임
    - “주문 취소” 로직을 직접 구현하지 않고 Order 객체에 취소 처리를 위임 하고 있다
- 도메인 영역
  - Order, OrderLine, ShippingInfo와 같은 도메인 모델
  - 도메인 모델은 핵심 로직을 구현한다.
    - “배송지 변경”, “결제 완료”, “주문 총액 계산”과 같은 핵심 로직을 도메인 모델에 구현한다.
- 인프라스트럭처 영역
  - 구현 기술에 대한 것을 다룬다
  - RDBMS 연동, 메시징 큐에 메시지 전송과 수신, 몽고DB나 레디스의 데이터 연동 처리 등
  - 논리적인 개념을 표현하기보다는 실제 구현을 다룬다
  - 도메인 영역, 응용 영역, 표현 영역은 구현 기술을 사용한 코드를 직접 만들지 않는다.
    - 인프라스트럭처 영역에서 제공하는 기능을 사용해서 필요한 기능을 개발

2.2 계층 구조 아키텍처

네 영역을 구성할 때 많이 사용하는 아키텍처가 그림과 같은 계층 구조이다.
- 표현 영역과 응용 영역은 도메인 영역을 사용
- 도메인 영역은 인프라스트럭처 영역을 사용
도메인의 복잡도에 따라 응용과 도메인을 분리하기도 하고 한 계층으로 합치기도 하지만 전체적인 아키텍처는 계층 구조를 따른다.
계층 구조는 특성상 상위 계층에서 하위 계층으로의 의존만 존재하고 하위 계층은 상위 계층에 의존하지 않는다.
계층 구조를 엄격하게 적용한다면 상위 계층은 바로 아래의 계층에만 의존을 가져야 하지만 구현의 편리함을 위해 계층 구조를 유연하게 적용하기도 한다.
응용 영역과 도메인 영역은 DB나 외부 시스템 연동을 위해 인프라스트럭처의 기능을 사용하므로 계층 구조를 사용하는 것이 직관적으로 이해하기 쉽다.
- 표현, 응용, 도메인 계층이 상세한 구현 기술을 다루는 인프라스트럭처 계층에 종속된다

도메인의 가격 계산 규칙의 예제

할인 금액을 계산하기 위해 Drools라는 룰 엔진을 사용해서 계산 로직을 수행하는 인프라스트럭처 영역의 코드를 만들어 보자

public class DroolsRuleEngine {
	private KieContainer kContainer;

	public DroolsRuleEngine() {
		KieServices ks = KieServices.Factory.get();
		kContainer = ks.getKieClasspathContainer();		
	}

	public void evalute(String sessionName, List<?> facts) {
		KiSession kSession = kContainer.newKieSession(sessionName);
		try {
			facts.forEach(x -> kSession.insert(x));
			kSession.fireAllRules();
		} finaly {
			kSession.dispose();
		}
	}
}

응용 영역은 가격 계산을 위해 인프라스트럭처 영역의 DroolsRuleEngine을 사용

public class CalcuateDiscountService {
	private DroolsRuleEngine ruleEngine;
	
	public CalculateDiscountService() {
		ruleEngine = new DroolsRuleEngine();
	}

	public Money calculateDiscount(List<OrderLine> orderLines, String customerId) {
		Customer customer = findCustomer(customerId);
		
		MutableMoney money = new MutableMoney(0);
		List<?> facts = Arrays.asList(customer, money);
		facts.addAll(orderLines);
		ruleEngine.evalute("discountCalculation", facts);
		return money.toImmutableMoney();
	}
}

CalculateDiscountService가 동작은 하겠지만 두가지 문제를 안고 있다.
- CalculateDiscountService를 테스트하기 어렵다
  - RuleEngine이 완벽하게 동작해야 한다.
  - RuleEngine 클래스와 관련 설정 파일 모두 만든 이후에 CalculateDiscountService 를 확인할 수 있다.
- 구현 방식을 변경하기 어렵다
  - ‘discountCalculation’ 문자열은 Drools의 세션 이름을 의미한다.
  - 세션 이름을 변경하면 CalculateDiscountService 코드도 함께 변경해야 한다.
CalculateDiscountService가 겉으로는 인프라스트럭처의 기술에 직접적인 의존을 하지 않는 것처럼 보여도 실제로는 Drools라는 인프라스트럭처 영역의 기술에 완전하게 의존하고 있다.
인프라스트럭처에 의존하면 ‘테스트 어려움’과 ‘기능 확장 어려움’이라는 두가지 문제가 발생한다.
- 문제 해답은 DIP에 있다.

2.3 DIP

가격 할인 계산을 하려면 고객 정보를 구해야하고, 구한 고객 정보와 주문 정보를 이용해서 룰을 실행해야 한다.
CalculateDiscountService는 고수준 모듈이다.
- 고수준 모듈은 의미 있는 단일 기능을 제공하는 모듈로 ‘가격 할인 계산’이라는 기능을 구현
- 가격 할인 계싼 기능을 구현하려면 고객 정보를 구해야하고 룰을 실행해야 하는데 이 두 기능이 하위 기능이다.
저수준 모듈은 하위 기능을 실제로 구현한 것이다.
- JPA를 이용해서 고객 정보를 읽어오는 모듈과 Drools로 룰을 실행하는 모듈이 저수준 모듈이 된다.

DIP는 저수준 모듈이 고수준 모듈에 의존하도록 바꾼다.

추상화 인터페이스를 사용

public interface RuleDiscounter {
	Money applyRules(Customer customer, List<OrderLine> orderLines);
}

CalculateDiscountService가 RuleDiscounter를 이용하도록 변경
- Drools에 의존하는 코드가 없다

public class CalcuateDiscountService {
	private RuleDiscounter ruleDiscounter;
	
	public CalculateDiscountService(RuleDiscounter ruleDiscounter) {
		this.ruleDiscounter = ruleDiscounter;
	}

	public Money calculateDiscount(List<OrderLine> orderLines, String customerId) {
		Customer customer = findCustomer(customerId);
		return ruleDiscounter.applyRules(customer, orderLines);
	}
}

RuleDiscounter를 상속받아 구현

public class DroolsRuleDiscounter implements RuleDiscounter {
	private KieCountainer kContainer;
	
	public DroolsRuleEngine() {
		KieService ks = KieServices.Factory.get();
		kContainer = ks.getKieClasspathContainer();
	}

	@Override
	public Money applyRules(Customer customer, List<OrderLine> orderLines) {
		KieSession kSession = kContainer.newKieSession("discountSession");
		try {
			...
			kSession.fireAllRules();
		} finally {
			kSession.dispose();
		}
		return money.toImmutableMoney();
	}
}

RuleDiscounter가 출현하면서 바뀐 구조
CalculateDiscountService는 더이상 구현 기술인 Drools에 의존하지 않는다.
- RuleDiscounter 인터페이스에 의존할 뿐
- ‘룰을 이용한 할인 금액 계산’은 고수준 모듈의 개념이므로 RuleDiscounter 인터페이스는 고수준 모듈에 속한다.
- DroolsRuleDiscounter는 고수준의 하위 기능인 RuleDiscounter를 구현한 것이므로 저수준 모듈에 속한다.

DIP를 적용하면 저수준 모듈이 고수준 모듈에 의존하게 된다.
- 고수준 모듈이 저수준 모듈을 사용하려면 고수준 모듈이 저수준 모듈에 의존해야 하는데, 반대로 저수준 모듈이 고수준 모듈에 의존한다고 해서 이를 DIP(Dependency Inversion Principle, 의존 역전 원칙)이라 부른다.
DIP를 적용하면 다른 영역인 인프라스트럭처 영역에 의존할 떄 발생했던 두가지 문제인 구현 교체가 어렵다는 것과 테스트가 어려운 문제를 해소할 수 있다.

고수준 모듈은 더 이상 저수준 모듈에 의존하지 않고 구현을 추상화한 인터페이스에 의존할 수 있다.

구현 기술이 변경되더라도 저수준 구현 객체를 생성하는 코드만 변경하면 된다.

// 기존 코드
RuleDiscounter roleDiscounter = new DroolsRuleDiscounter();
CalculateDiscountService disService = new CalculateDiscountService(roleDiscounter);

// 구현 기술 변경 
RuleDiscounter roleDiscounter = new SimpleRuleDiscounter();
CalculateDiscountService disService = new CalculateDiscountService(roleDiscounter);

스프링과 같은 의존 주입을 지원하는 프레임워크를 사용하면 설정 코드를 수정해서 쉽게 구현체를 변경할 수 있다.
CalculateDiscountService가 제대로 동작하는지 테스트하려면 CustomerRepository와 RuleDiscounter를 구현한 객체가 필요하다.
- CacluateDiscountService가 저수준 모듈에 직접 의존했다면 저수준 모듈이 만들어지기 전까진 테스트를 할 수 없음
- 인터페이스에 의존함으로 대역 객체를 사용해서 테스트를 진행 할수 있다.
- 실제 구현 대신 스텁이나 모의 객체와 같은 테스트 목적의 대역을 사용하여 거의 모든 상황을 테스트할 수 있다.
```
public class CalculateDiscountServiceTest {
	@Test
	public void noCustomer_thenExcetionShouldBeThrown() {
		CustomerRepository stubRepo = mock(CustomerRepository.class);
		when(stubRepo.findById("noCustId")).thenRetrun(null);

		RuleDiscounter stubRule = (cust, lines) -> null;
		
		CalculateDiscountService calDisSvc = new CalculateDiscountService(stbRepo, stubRule);
		assertThrows(NoCustomerException.class, () -> calDisSvc.calculateDiscount(ssomeLines, "noCustId"));
	}
}
```
실제 구현 없이 테스트를 할 수 있는 이유는 DIP를 적용해서 고수준 모듈이 저수준 모듈에 의존하지 않도록 했기 때문이다.

2.3.1 DIP 주의사항

DIP를 잘못 생각하면 단순히 인터페이스와 구현 클래스를 분리하는 정도로 받아드릴 수 있다.
DIP의 핵심은 고수준 모듈이 저수준 모듈의 의존하지 않도록 하기 위함이다.
잘못된 구조
- 도메인 영역은 구현 기술을 다루는 인프라스트럭처 영역에 의존하고 있다.
- 고수준 모듈이 저수준 모듈에 의존하고 있다.
DIP를 적용할 때 하위 기능을 추상화한 인터페이스는 고수준 모듈 관점에서 도출한다.
- CalculateDiscountService는 할인 금액을 구하기 위한 룰 엔진을 사용하는지 직접 연산하는지 중요하지 않다.
- 규칙에 따라 할인 금액을 계산하는 것이 중요
- ‘할인 금액 계산’을 추상화한 인터페이스는 저수준 모듈이 아닌 고수준 모듈에 위치한다.

2.3.2 DIP와 아키텍처

인프라스트럭처 영역은 구현 기술을 다루는 저수준 모듈이고 응용 영역과 도메인 영역은 고수준 모듈이다.
인프라스트럭처 계층이 가장 하단에 위치하는 계층형 구조와 달리 아키텍처에 DIP를 적용하면 인프라스트럭처 영역이 응용 영역와 도메인 영역에 의존하는 구조가 된다.
인프라스트럭처에 위치한 클래스가 도메인이나 응용 영역에 정의한 인터페이스를 상속받아 구현하는 구조가 되므로 도메인과 응용 영역에 대한 영향을 주지 않거나 최소화하면서 구현 기술을 변경하는 것이 가능하다.
주문 시 통지 방식에 SMS를 추가해야 한다는 요구사항이 들어왔을 때 OrderService는 변경할 필요가 없다.
- 두 통지 방식을 함께 제공하는 Notifier 구현 클래스를 인프라스트럭처 영역에 추가하면 된다.
마이바티스 대신 JPA를 구현 기술로 사용하고 싶다면 JPA를 이용한 OrderRepository 구현 클래스를 인프라 스트럭처 영역에 추가하면 된다.

2.4 도메인 영역의 주요 구성요소

도메인 영역을 구성하는 요소요소 설명

엔티티 ENTITY	고유 식별자를 갖는 객체로 자신의 라이프 사이클을 갖는다. Order, Member, Product와 같이 도메인의 고유한 개념을 표현한다. 도메인 모델의 데이터를 포함하며 해당 데이터와 관련된 기능을 함께 제공
밸류 VALUE	고유 식별자를 갖지 않는 객체로 주로 개념적으로 하나의 값을 표현할 때 사용된다. 배송지 주소를 표현하기 위한 Address나 구매한 금액을 위한 Money와 같은 타입이 밸류 타입이다. 엔티티의 속성으로 사용할 뿐만 아니라 다른 밸류 타입의 속성도 사용할 수 있다.
애그리거트 AGGREGATE	애그리거트는 연관된 엔티티와 밸류 객체를 개념적으로 하나로 묶는 것이다. 주문과 관련된 Order 엔티티, OrderLine 밸류, Orderer 밸류 객체를 주문 애그리거트로 묶을 수 있다.
리포지터리 REPOSITORY	도메인 모델의 영속성을 처리한다. DBMS 테이블에서 엔티티 객체를 로딩하거나 저장하는 기능을 제공
도메인 서비스 DOMAIN SERVICE	특정 엔티티에 속하지 않는 도메인 로직을 제공한다. ‘할인 금액 계산’은 상품, 쿠폰, 회원 등급, 구매 금액 등 다양한 조건을 이용해서 구현하게 되는데 이렇게 도메인 로직이 여러 엔티티와 밸류를 필요로 하면 도메인 서비스에 로직을 구현

2.4.1 엔티티와 밸류

엔티티와 도메인 모델의 가장 큰 차이점은 도메인 모델의 엔티티는 데이터와 함께 도메인 기능을 함께 제공한다는 점
- 주문을 표현하는 엔티티는 주문과 관련된 데이터뿐만 아니라 배송지 주소 변경을 위한 기능을 함께 제공
```
public class Order {
	private OrderNo number;
	private Orderer orderer;
	private ShippingInfo shippingInfo;
	
	// 도메인 모델 엔티티는 도메인 기능도 함께 제공
	public void shangeShippingInfo(ShippingInfo newShippingInfo) {
		...	
	}
}
```
도메인 모델의 엔티티는 단순히 데이터를 담고 있는 데이터 구조라기보다는 데이터와 함께 기능을 제공하는 객체
도메인 관점에서 기능을 구현하고 기능 구현을 캡슐화해서 데이터가 임의로 변경되는 것을 막는다.
도메인 모델의 엔티티는 두 개 이상의 데이터가 개념적으로 하나인 경우 밸류 타입을 이용해서 표현할 수 있다
- Orderer는 밸류 타입으로 주문자 이름과 이메일 데이터를 포함할 수 있다.
```
public class Orderer {
	private String name;
	private String email;
}
```
RDBMS와 같은 관계형 데이터베이스는 밸류 타입을 재대로 표현하기 힘들다.
- Ordere의 개별 데이터를 저장하거나 밸로 테이블로 분리해서 저장해야 한다.
- 한 테이블에 주문자 정보 함께 넣기
  - 주문자라는 개념이 들어나지 않고 주문자의 개별 데이터만 드러난다.
- 다른 테이블에 주문자 정보 넣기
  - 주문자 데이터를 별도 테이블에 저장했지만 이것은 테이블의 엔티티에 가까우며 밸류 타입의 의미가 드러나지 않는다.

밸류는 불변으로 구현할 것을 권장

엔티티의 밸류 타입 데이터를 변경할 떄는 객체 자체를 완전히 교체한다는 것을 의미

public class Order {
	private ShippingInfo shippingInfo;
	
	public void shangeShippingInfo(ShippingInfo newShippingInfo) {
		checkShippingInfoChangeable();
		setShippingInfo(newShippingInfo);
	}

	private void setShippingInfo(ShippingInfo newShippingInfo) {
		if (newShippingInfo == null) {
			throw new IllegalArgumentException();
		}
		this.shippingInfo = newShippingInfo;
	}
}

2.4.2 애그리거트

도메인이 커질수록 개발할 도메인 모델도 커지면서 많은 엔티티와 밸류가 출현한다.
도메인 모델이 복잡해지면 개발자가 전체 구조가 아닌 한 개 엔티티와 밸류에만 집중하는 상황이 발생한다.
- 상위 수준에서 모델을 관리하지 않고 개별 요소에만 초점을 맞추다 보면, 큰 수준에서 모델을 이해하지 못해 큰 틀에서 모델은 관리할 수 없는 상황에 빠질 수 있다.
도메인 모델에 전체 구조를 이해하는데 도움이 되는 것이 바로 애그리거트(AGGREGATE)이다.
애그리거트는 관련 객체를 하나로 묶은 군집이다.
- 모메인 개념은“주문”, “배송지 정보”, “주문자”, “주문 목록”, “총 결제 금액”의 하위 모델로 구성된다.
- 하위 내념을 표현한 모델을 하나로 묶어서 “주문”이라는 상위 개념으로 표현할 수 있다.
애그리거트를 사용하면 개별 객체가 아닌 관련 객체를 묶어서 객체 군집 단위로 모델을 바라볼 수 있게 된다.
- 개별 객체 간의 관계가 아닌 애그리거트 간의 관계로 도메인 모델을 이해하고 구현하고, 큰 틀에서 도메인 모델을 관리할 수 있다.
애그리거트는 군집에 속한 객체를 관리하는 루트 엔티티를 갖는다.
- 루트 엔티티는 애그리거트에 속해 있는 엔티티와 밸류 객체를 이용해서 애그리거트가 구현해야 할 기능을 제공
- 애그리거트를 사용하는 코드는 애그리거트 루트가 제공하는 기능을 실행
- 애그리거트 루트를 통해 간접적으로 애그리거트 내의 다른 엔티티나 밸류 객체에 접근
- 애그리거트의 내부 구현을 숨겨서 애그리거트 단위로 구현을 캡슐화할 수 있도록 돕는다.
주문 애그리거트
- 애그리거트 루트인 Order는 주문 도메인 로직에 맞게 애그리거트의 상태를 관리
- Order의 배송지 정보 변경 기능은 배송지를 변경할 수 있는지를 확인한 위에 배송지 정보를 변경
- 주문 애그리거트는 Order를 통하지 않고 ShippingInfo를 변경할 수 있는 방법을 제공하지 않는다.
  - 배송지를 변경하려면 루트 엔티티인 Order를 사용해야 하므로 배소지 정보를 변경할 때는 Order가 구현한 도메인 로직을 항상 따르게 된다.
애그리거트를 구현할 때는 고려할 것이 많다.
- 애그리거트를 어떻게 구성했느냐에 따라 구현이 복잡해지기도 하고
- 트랜잭션 범위가 달라지기도 한다.

2.4.3 리포지터리

도메인 객체를 지속적으로 사용하려면 RDBMS, NoSQL, 로컬 파일과 같은 물리적인 저장소에 도메인 객체를 보관해야 한다.
- 이를 위한 도메인 모델이 리포지터리(Repository)이다.
엔티티나 밸류가 요구사항에 도출되는 도메인 모델이라면 리포리터리는 구현을 위한 도메인 모델이다.
리포지터리는 애그리거트 단위로 도메인 객체를 저장하고 조회하는 기능을 정의
- OrderRepository의 메서드를 보면 대상을 찾고 저장하는 단위가 애그리거트 루트인 Order인 것을 알 수 있다.
- Order는 애그리거트에 속한 모든 객체를 포함하고 있으므로 결과적으로 애그리거트 단위로 저장하고 조회한다.
```
public interface OrderRepository {
	Order findByNumber(OrderNumber number);
	void save(Order order);
	void delete(Order order);
}
```
도메인 모델을 사용해야 하는 코드는 리포지터리를 통해서 도메인 객체를 구한 뒤에 도메인 객체의 기능을 실행
public class CancelOrderService { private OrderRepository orderRepository; public void cancel(OrderNumber number) { Order order = orderRepository.findByNumber(number); if (order == null) { throw new OrderNotFoundException(orderId); } order.cancel(); } }
도메인 모델 관점에서 OrderRepository는 도메인 객체를 영속화하는 데 필요한 기능을 추상화 한것으로 고수준 모듈에 속한다.
기반 기술을 이용해서 OrderRepository를 구현한 클래스는 저수준 모듈로 인프라스트럭처 영역에 속한다.
전체 모듈 구조
응용 서비스는 의존 주입과 같은 방식을 사용해서 실제 리포지터리 구현 객체에 접근
응용 서비스와 리포지터리는 밀접한 연관이 있다.
- 응용 서비스는 필요한 도메인 객체를 구하거나 저장할 때 리포지터리를 사용한다.
- 응용 서비스는 트랜잭션을 관리하는데, 트랜잭션 처리는 리포지터리 구현 기술의 영향을 받는다.
리포지터리를 사용하는 주체가 응용 서비스이기 때문에 리포지터리는 응용 서비스가 필요로 하는 메서드를 제공한다.
- 애그리거트를 저장하는 메서드
- 애그리거트 루트 식별자로 애그리거트를 조회하는 메서드

2.5 요청 처리 흐름

표현 영역은 사용자가 전송한 데이터 형식이 올바른지 검사하고 문제가 없다면 데이터를 이용해서 응용 서비스에 기능 실행을 위임
표현 영역은 사용자가 전송한 데이터를 응용 서비스가 요구하는 형식으로 변환해서 전달
요청 처리 흐름
- 웹 브라우저에서 기능 실행 요청
- 표현 영역에 해당하는 컨트롤러는 HTTP 요청 파라미터를 응용 서비스가 필요로 하는 데이터로 변환 해서 응용 서비스의 인자로 전달
- 응용 서비스는 도메인 모델을 이용해서 로직 실행
- 도메인 객체를 리포지터리에서 가져와 실행하거나 신규 도메인 객체를 생성해 리포지터리에 저장
“예매하기”나 “예매 취소”와 같은 기능을 제공하는 응용 서비스는 도메인의 상태를 변경하므로 변경 상태가 물리 저장소에 올바르게 반영되도록 트랜잭션을 관리 해야한다.
- 스프링 프레임워크를 사용한다면 @Transactional 애너테이션을 이용해 트랜잭션을 처리할 수 있다.
```
public class CancelOrderService {
	private OrderRepository orderRepository;
	
	@Transactional
	public void cancel(OrderNumber number) {
		Order order = orderRepository.findByNumber(number);
		if (order == null) {
			throw new NoOrderException(number);
		}
		order.cancel()
	}
}
```

2.6 인프라스트럭처 개요

인프라스트럭처는 표현 영역, 응용 영역, 도메인 영역을 지원한다.
도메인 영역과 응용 영역에서 인프라스트럭처의 기능을 직접 사용하는 것보다 두 영역에서 정의한 인터페이스를 인프라스트럭처 영역에서 구현하는 것이 시스템을 더 유연하고 테스트하기 쉽게 만들어 준다.
무조건 인프라스트럭처에 대한 의존성을 없앨 필요는 없다.
- 스프링을 사용할 경우 응용 서비스는 트랜잭션 처리를 위해 @Transactional을 사용하는 것이 편리하다.
- 영속성 처리를 위해 JPA를 사용할 경우 @Entity나 @Table과 같은 JPA 전용 애너테이션을 도메인 모델 클래스에서 사용하는 것이 XML 매핑 설정을 이용하는 것보다 편리하다.
구현의 편리함은 DIP가 주는 다른 장점만큼 중요하기 때문에 DIP의 장점을 해치지 않는 범위에서 응용 영역과 도메인 영역에서 구현 기술에 대한 의존을 가져가는 것이 나쁘지 않다고 생각한다.
응용 영역과 도메인 영역이 인프라스트럭처에 대한 의존을 완전히 갖지 않도록 시도하는 것은 구현을 더 복잡하고 어렵게 만들 수 있다.
- @Transactional을 사용하면 한 줄로 트랙잭션을 처리할 수 있는데 코드에서 스프링에 대한 의존을 없애려면 복잡한 스프링 설정을 사용해야 한다.
- 의존은 없앴지만 특별히 테스트를 더 쉽게 할 수 있다거나 유연함을 증가시켜 주지 못한다.
- 설정만 복잡해지고 개발 시간만 늘어난다.
표현 영역은 항상 인프라스트럭처 영역과 쌍을 이룬다.
- 스프링 MVC를 사용해서 웹 요청을 처리하려면 스프링이 제공하는 MVC 프레임워크에 맞게 표현 영역을 구현
- Vert.x를 사용해서 Rest API 서버를 구축하려면 Vert.x에 맞게 웹 요청 처리 부분을 구현

2.7 모듈 구성

아키텍처의 각 영역은 별도 패키지에 위치한다.
패키지 구성 규칙에 정답이 존재하는 것은 안지만 영역별로 모듈이 위치할 패키지를 구성할 수 있을 것 이다.
도메인이 크면 하위 도메인으로 나누고 하위 도메인마다 별도 패키지를 구성한다.
도메인 모듈은 도메인에 속한 애그리거트를 기준으로 다시 패키지를 구성한다.
- 카탈로그 하위 도메인이 상품 애그리거트와 카테고리 애그리커트로 구성될 경우 도메인을 두 개의 하위 패키지로 구성할 수 있다.
애그리거트, 모델, 리포지터리는 같은 패키지에 위치시킨다.
- Order, OrderLine, Orderer, OrderRepository 등은 com.myshop.order.domain 패키지에 위치시킨다.
도메인이 복잡하면 도메인 모델과 도메인 서비스를 별도 패키지에 위치시킬 수도 있다.
- com.myshop.order.domain.order: 애그리거트 위치
- com.myshop.order.domain.service: 도메인 서비스 위치
응용 서비스도 도메인 별로 패키지를 구분할 수 있다.
- com.myshop.catalog.application.product
- com.myshop.catalog.application.category
모듈 구조를 얼마나 세분하게해야 하는지에 대한 정해진 규칙은 없다.
한 패키지에 너무 많은 타입이 몰려서 코드를 찾을 때 불편할 정도만 아니면 된다.

2.1 네 개의 영역

“표현”, “응용”, “도메인”, “인프라스트럭처”는 아키텍처를 설계할 때 출현하는 전형적인 네 가지 영역
- 표현 영역
  - 사용자의 요청을 받아 응용 영역에 전달, 응용 영역의 처리 결과를 사용자에게 전달
  - 스프링 MVC 프레임워크가 표현 영역의 기술
- 응용 영역
  - 표현 영역을 통해 사용자의 요청을 전달받은 응용 영역은 시스템이 사용자에게 제공해야할 기능을 구현
  - “주문 등록”, “주문 취소”, “상품 상세 조회” 등의 기능을 예로 들수 있다.
  - 기능을 구현하기 위한 도메인 영역의 도메인 모델을 사용
  - “주문 취소” 기능을 제공하는 응용 서비스를 도메인 모델을 사용해서 기능 구현이 가능
  - public class CancelOrderService { @Transactional public void cancelOrder(String orderId) { Order order = findOrderById(orderId); if (order == null) { throw new OrderNotFoundException(orderId); } order.cancel(); } }
  - 로직을 직접 수행하기보다는 도메인 모델에 로직 수행을 위임
    - “주문 취소” 로직을 직접 구현하지 않고 Order 객체에 취소 처리를 위임 하고 있다
- 도메인 영역
  - Order, OrderLine, ShippingInfo와 같은 도메인 모델
  - 도메인 모델은 핵심 로직을 구현한다.
    - “배송지 변경”, “결제 완료”, “주문 총액 계산”과 같은 핵심 로직을 도메인 모델에 구현한다.
- 인프라스트럭처 영역
  - 구현 기술에 대한 것을 다룬다
  - RDBMS 연동, 메시징 큐에 메시지 전송과 수신, 몽고DB나 레디스의 데이터 연동 처리 등
  - 논리적인 개념을 표현하기보다는 실제 구현을 다룬다
  - 도메인 영역, 응용 영역, 표현 영역은 구현 기술을 사용한 코드를 직접 만들지 않는다.
    - 인프라스트럭처 영역에서 제공하는 기능을 사용해서 필요한 기능을 개발

2.2 계층 구조 아키텍처

네 영역을 구성할 때 많이 사용하는 아키텍처가 그림과 같은 계층 구조이다.
- 표현 영역과 응용 영역은 도메인 영역을 사용
- 도메인 영역은 인프라스트럭처 영역을 사용
도메인의 복잡도에 따라 응용과 도메인을 분리하기도 하고 한 계층으로 합치기도 하지만 전체적인 아키텍처는 계층 구조를 따른다.
계층 구조는 특성상 상위 계층에서 하위 계층으로의 의존만 존재하고 하위 계층은 상위 계층에 의존하지 않는다.
계층 구조를 엄격하게 적용한다면 상위 계층은 바로 아래의 계층에만 의존을 가져야 하지만 구현의 편리함을 위해 계층 구조를 유연하게 적용하기도 한다.
응용 영역과 도메인 영역은 DB나 외부 시스템 연동을 위해 인프라스트럭처의 기능을 사용하므로 계층 구조를 사용하는 것이 직관적으로 이해하기 쉽다.
- 표현, 응용, 도메인 계층이 상세한 구현 기술을 다루는 인프라스트럭처 계층에 종속된다

도메인의 가격 계산 규칙의 예제

할인 금액을 계산하기 위해 Drools라는 룰 엔진을 사용해서 계산 로직을 수행하는 인프라스트럭처 영역의 코드를 만들어 보자

public class DroolsRuleEngine {
	private KieContainer kContainer;

	public DroolsRuleEngine() {
		KieServices ks = KieServices.Factory.get();
		kContainer = ks.getKieClasspathContainer();		
	}

	public void evalute(String sessionName, List<?> facts) {
		KiSession kSession = kContainer.newKieSession(sessionName);
		try {
			facts.forEach(x -> kSession.insert(x));
			kSession.fireAllRules();
		} finaly {
			kSession.dispose();
		}
	}
}

응용 영역은 가격 계산을 위해 인프라스트럭처 영역의 DroolsRuleEngine을 사용

public class CalcuateDiscountService {
	private DroolsRuleEngine ruleEngine;
	
	public CalculateDiscountService() {
		ruleEngine = new DroolsRuleEngine();
	}

	public Money calculateDiscount(List<OrderLine> orderLines, String customerId) {
		Customer customer = findCustomer(customerId);
		
		MutableMoney money = new MutableMoney(0);
		List<?> facts = Arrays.asList(customer, money);
		facts.addAll(orderLines);
		ruleEngine.evalute("discountCalculation", facts);
		return money.toImmutableMoney();
	}
}

CalculateDiscountService가 동작은 하겠지만 두가지 문제를 안고 있다.
- CalculateDiscountService를 테스트하기 어렵다
  - RuleEngine이 완벽하게 동작해야 한다.
  - RuleEngine 클래스와 관련 설정 파일 모두 만든 이후에 CalculateDiscountService 를 확인할 수 있다.
- 구현 방식을 변경하기 어렵다
  - ‘discountCalculation’ 문자열은 Drools의 세션 이름을 의미한다.
  - 세션 이름을 변경하면 CalculateDiscountService 코드도 함께 변경해야 한다.
CalculateDiscountService가 겉으로는 인프라스트럭처의 기술에 직접적인 의존을 하지 않는 것처럼 보여도 실제로는 Drools라는 인프라스트럭처 영역의 기술에 완전하게 의존하고 있다.
인프라스트럭처에 의존하면 ‘테스트 어려움’과 ‘기능 확장 어려움’이라는 두가지 문제가 발생한다.
- 문제 해답은 DIP에 있다.

2.3 DIP

가격 할인 계산을 하려면 고객 정보를 구해야하고, 구한 고객 정보와 주문 정보를 이용해서 룰을 실행해야 한다.
CalculateDiscountService는 고수준 모듈이다.
- 고수준 모듈은 의미 있는 단일 기능을 제공하는 모듈로 ‘가격 할인 계산’이라는 기능을 구현
- 가격 할인 계싼 기능을 구현하려면 고객 정보를 구해야하고 룰을 실행해야 하는데 이 두 기능이 하위 기능이다.
저수준 모듈은 하위 기능을 실제로 구현한 것이다.
- JPA를 이용해서 고객 정보를 읽어오는 모듈과 Drools로 룰을 실행하는 모듈이 저수준 모듈이 된다.

DIP는 저수준 모듈이 고수준 모듈에 의존하도록 바꾼다.

추상화 인터페이스를 사용

public interface RuleDiscounter {
	Money applyRules(Customer customer, List<OrderLine> orderLines);
}

CalculateDiscountService가 RuleDiscounter를 이용하도록 변경
- Drools에 의존하는 코드가 없다

public class CalcuateDiscountService {
	private RuleDiscounter ruleDiscounter;
	
	public CalculateDiscountService(RuleDiscounter ruleDiscounter) {
		this.ruleDiscounter = ruleDiscounter;
	}

	public Money calculateDiscount(List<OrderLine> orderLines, String customerId) {
		Customer customer = findCustomer(customerId);
		return ruleDiscounter.applyRules(customer, orderLines);
	}
}

RuleDiscounter를 상속받아 구현

public class DroolsRuleDiscounter implements RuleDiscounter {
	private KieCountainer kContainer;
	
	public DroolsRuleEngine() {
		KieService ks = KieServices.Factory.get();
		kContainer = ks.getKieClasspathContainer();
	}

	@Override
	public Money applyRules(Customer customer, List<OrderLine> orderLines) {
		KieSession kSession = kContainer.newKieSession("discountSession");
		try {
			...
			kSession.fireAllRules();
		} finally {
			kSession.dispose();
		}
		return money.toImmutableMoney();
	}
}

RuleDiscounter가 출현하면서 바뀐 구조
CalculateDiscountService는 더이상 구현 기술인 Drools에 의존하지 않는다.
- RuleDiscounter 인터페이스에 의존할 뿐
- ‘룰을 이용한 할인 금액 계산’은 고수준 모듈의 개념이므로 RuleDiscounter 인터페이스는 고수준 모듈에 속한다.
- DroolsRuleDiscounter는 고수준의 하위 기능인 RuleDiscounter를 구현한 것이므로 저수준 모듈에 속한다.

DIP를 적용하면 저수준 모듈이 고수준 모듈에 의존하게 된다.
- 고수준 모듈이 저수준 모듈을 사용하려면 고수준 모듈이 저수준 모듈에 의존해야 하는데, 반대로 저수준 모듈이 고수준 모듈에 의존한다고 해서 이를 DIP(Dependency Inversion Principle, 의존 역전 원칙)이라 부른다.
DIP를 적용하면 다른 영역인 인프라스트럭처 영역에 의존할 떄 발생했던 두가지 문제인 구현 교체가 어렵다는 것과 테스트가 어려운 문제를 해소할 수 있다.

고수준 모듈은 더 이상 저수준 모듈에 의존하지 않고 구현을 추상화한 인터페이스에 의존할 수 있다.

구현 기술이 변경되더라도 저수준 구현 객체를 생성하는 코드만 변경하면 된다.

// 기존 코드
RuleDiscounter roleDiscounter = new DroolsRuleDiscounter();
CalculateDiscountService disService = new CalculateDiscountService(roleDiscounter);

// 구현 기술 변경 
RuleDiscounter roleDiscounter = new SimpleRuleDiscounter();
CalculateDiscountService disService = new CalculateDiscountService(roleDiscounter);

스프링과 같은 의존 주입을 지원하는 프레임워크를 사용하면 설정 코드를 수정해서 쉽게 구현체를 변경할 수 있다.
CalculateDiscountService가 제대로 동작하는지 테스트하려면 CustomerRepository와 RuleDiscounter를 구현한 객체가 필요하다.
- CacluateDiscountService가 저수준 모듈에 직접 의존했다면 저수준 모듈이 만들어지기 전까진 테스트를 할 수 없음
- 인터페이스에 의존함으로 대역 객체를 사용해서 테스트를 진행 할수 있다.
- 실제 구현 대신 스텁이나 모의 객체와 같은 테스트 목적의 대역을 사용하여 거의 모든 상황을 테스트할 수 있다.
```
public class CalculateDiscountServiceTest {
	@Test
	public void noCustomer_thenExcetionShouldBeThrown() {
		CustomerRepository stubRepo = mock(CustomerRepository.class);
		when(stubRepo.findById("noCustId")).thenRetrun(null);

		RuleDiscounter stubRule = (cust, lines) -> null;
		
		CalculateDiscountService calDisSvc = new CalculateDiscountService(stbRepo, stubRule);
		assertThrows(NoCustomerException.class, () -> calDisSvc.calculateDiscount(ssomeLines, "noCustId"));
	}
}
```
실제 구현 없이 테스트를 할 수 있는 이유는 DIP를 적용해서 고수준 모듈이 저수준 모듈에 의존하지 않도록 했기 때문이다.

2.3.1 DIP 주의사항

DIP를 잘못 생각하면 단순히 인터페이스와 구현 클래스를 분리하는 정도로 받아드릴 수 있다.
DIP의 핵심은 고수준 모듈이 저수준 모듈의 의존하지 않도록 하기 위함이다.
잘못된 구조
- 도메인 영역은 구현 기술을 다루는 인프라스트럭처 영역에 의존하고 있다.
- 고수준 모듈이 저수준 모듈에 의존하고 있다.
DIP를 적용할 때 하위 기능을 추상화한 인터페이스는 고수준 모듈 관점에서 도출한다.
- CalculateDiscountService는 할인 금액을 구하기 위한 룰 엔진을 사용하는지 직접 연산하는지 중요하지 않다.
- 규칙에 따라 할인 금액을 계산하는 것이 중요
- ‘할인 금액 계산’을 추상화한 인터페이스는 저수준 모듈이 아닌 고수준 모듈에 위치한다.

2.3.2 DIP와 아키텍처

인프라스트럭처 영역은 구현 기술을 다루는 저수준 모듈이고 응용 영역과 도메인 영역은 고수준 모듈이다.
인프라스트럭처 계층이 가장 하단에 위치하는 계층형 구조와 달리 아키텍처에 DIP를 적용하면 인프라스트럭처 영역이 응용 영역와 도메인 영역에 의존하는 구조가 된다.
인프라스트럭처에 위치한 클래스가 도메인이나 응용 영역에 정의한 인터페이스를 상속받아 구현하는 구조가 되므로 도메인과 응용 영역에 대한 영향을 주지 않거나 최소화하면서 구현 기술을 변경하는 것이 가능하다.
주문 시 통지 방식에 SMS를 추가해야 한다는 요구사항이 들어왔을 때 OrderService는 변경할 필요가 없다.
- 두 통지 방식을 함께 제공하는 Notifier 구현 클래스를 인프라스트럭처 영역에 추가하면 된다.
마이바티스 대신 JPA를 구현 기술로 사용하고 싶다면 JPA를 이용한 OrderRepository 구현 클래스를 인프라 스트럭처 영역에 추가하면 된다.

2.4 도메인 영역의 주요 구성요소

도메인 영역을 구성하는 요소요소 설명

엔티티 ENTITY	고유 식별자를 갖는 객체로 자신의 라이프 사이클을 갖는다. Order, Member, Product와 같이 도메인의 고유한 개념을 표현한다. 도메인 모델의 데이터를 포함하며 해당 데이터와 관련된 기능을 함께 제공
밸류 VALUE	고유 식별자를 갖지 않는 객체로 주로 개념적으로 하나의 값을 표현할 때 사용된다. 배송지 주소를 표현하기 위한 Address나 구매한 금액을 위한 Money와 같은 타입이 밸류 타입이다. 엔티티의 속성으로 사용할 뿐만 아니라 다른 밸류 타입의 속성도 사용할 수 있다.
애그리거트 AGGREGATE	애그리거트는 연관된 엔티티와 밸류 객체를 개념적으로 하나로 묶는 것이다. 주문과 관련된 Order 엔티티, OrderLine 밸류, Orderer 밸류 객체를 주문 애그리거트로 묶을 수 있다.
리포지터리 REPOSITORY	도메인 모델의 영속성을 처리한다. DBMS 테이블에서 엔티티 객체를 로딩하거나 저장하는 기능을 제공
도메인 서비스 DOMAIN SERVICE	특정 엔티티에 속하지 않는 도메인 로직을 제공한다. ‘할인 금액 계산’은 상품, 쿠폰, 회원 등급, 구매 금액 등 다양한 조건을 이용해서 구현하게 되는데 이렇게 도메인 로직이 여러 엔티티와 밸류를 필요로 하면 도메인 서비스에 로직을 구현

2.4.1 엔티티와 밸류

엔티티와 도메인 모델의 가장 큰 차이점은 도메인 모델의 엔티티는 데이터와 함께 도메인 기능을 함께 제공한다는 점
- 주문을 표현하는 엔티티는 주문과 관련된 데이터뿐만 아니라 배송지 주소 변경을 위한 기능을 함께 제공
```
public class Order {
	private OrderNo number;
	private Orderer orderer;
	private ShippingInfo shippingInfo;
	
	// 도메인 모델 엔티티는 도메인 기능도 함께 제공
	public void shangeShippingInfo(ShippingInfo newShippingInfo) {
		...	
	}
}
```
도메인 모델의 엔티티는 단순히 데이터를 담고 있는 데이터 구조라기보다는 데이터와 함께 기능을 제공하는 객체
도메인 관점에서 기능을 구현하고 기능 구현을 캡슐화해서 데이터가 임의로 변경되는 것을 막는다.
도메인 모델의 엔티티는 두 개 이상의 데이터가 개념적으로 하나인 경우 밸류 타입을 이용해서 표현할 수 있다
- Orderer는 밸류 타입으로 주문자 이름과 이메일 데이터를 포함할 수 있다.
```
public class Orderer {
	private String name;
	private String email;
}
```
RDBMS와 같은 관계형 데이터베이스는 밸류 타입을 재대로 표현하기 힘들다.
- Ordere의 개별 데이터를 저장하거나 밸로 테이블로 분리해서 저장해야 한다.
- 한 테이블에 주문자 정보 함께 넣기
  - 주문자라는 개념이 들어나지 않고 주문자의 개별 데이터만 드러난다.
- 다른 테이블에 주문자 정보 넣기
  - 주문자 데이터를 별도 테이블에 저장했지만 이것은 테이블의 엔티티에 가까우며 밸류 타입의 의미가 드러나지 않는다.

밸류는 불변으로 구현할 것을 권장

엔티티의 밸류 타입 데이터를 변경할 떄는 객체 자체를 완전히 교체한다는 것을 의미

public class Order {
	private ShippingInfo shippingInfo;
	
	public void shangeShippingInfo(ShippingInfo newShippingInfo) {
		checkShippingInfoChangeable();
		setShippingInfo(newShippingInfo);
	}

	private void setShippingInfo(ShippingInfo newShippingInfo) {
		if (newShippingInfo == null) {
			throw new IllegalArgumentException();
		}
		this.shippingInfo = newShippingInfo;
	}
}

2.4.2 애그리거트

도메인이 커질수록 개발할 도메인 모델도 커지면서 많은 엔티티와 밸류가 출현한다.
도메인 모델이 복잡해지면 개발자가 전체 구조가 아닌 한 개 엔티티와 밸류에만 집중하는 상황이 발생한다.
- 상위 수준에서 모델을 관리하지 않고 개별 요소에만 초점을 맞추다 보면, 큰 수준에서 모델을 이해하지 못해 큰 틀에서 모델은 관리할 수 없는 상황에 빠질 수 있다.
도메인 모델에 전체 구조를 이해하는데 도움이 되는 것이 바로 애그리거트(AGGREGATE)이다.
애그리거트는 관련 객체를 하나로 묶은 군집이다.
- 모메인 개념은“주문”, “배송지 정보”, “주문자”, “주문 목록”, “총 결제 금액”의 하위 모델로 구성된다.
- 하위 내념을 표현한 모델을 하나로 묶어서 “주문”이라는 상위 개념으로 표현할 수 있다.
애그리거트를 사용하면 개별 객체가 아닌 관련 객체를 묶어서 객체 군집 단위로 모델을 바라볼 수 있게 된다.
- 개별 객체 간의 관계가 아닌 애그리거트 간의 관계로 도메인 모델을 이해하고 구현하고, 큰 틀에서 도메인 모델을 관리할 수 있다.
애그리거트는 군집에 속한 객체를 관리하는 루트 엔티티를 갖는다.
- 루트 엔티티는 애그리거트에 속해 있는 엔티티와 밸류 객체를 이용해서 애그리거트가 구현해야 할 기능을 제공
- 애그리거트를 사용하는 코드는 애그리거트 루트가 제공하는 기능을 실행
- 애그리거트 루트를 통해 간접적으로 애그리거트 내의 다른 엔티티나 밸류 객체에 접근
- 애그리거트의 내부 구현을 숨겨서 애그리거트 단위로 구현을 캡슐화할 수 있도록 돕는다.
주문 애그리거트
- 애그리거트 루트인 Order는 주문 도메인 로직에 맞게 애그리거트의 상태를 관리
- Order의 배송지 정보 변경 기능은 배송지를 변경할 수 있는지를 확인한 위에 배송지 정보를 변경
- 주문 애그리거트는 Order를 통하지 않고 ShippingInfo를 변경할 수 있는 방법을 제공하지 않는다.
  - 배송지를 변경하려면 루트 엔티티인 Order를 사용해야 하므로 배소지 정보를 변경할 때는 Order가 구현한 도메인 로직을 항상 따르게 된다.
애그리거트를 구현할 때는 고려할 것이 많다.
- 애그리거트를 어떻게 구성했느냐에 따라 구현이 복잡해지기도 하고
- 트랜잭션 범위가 달라지기도 한다.

2.4.3 리포지터리

도메인 객체를 지속적으로 사용하려면 RDBMS, NoSQL, 로컬 파일과 같은 물리적인 저장소에 도메인 객체를 보관해야 한다.
- 이를 위한 도메인 모델이 리포지터리(Repository)이다.
엔티티나 밸류가 요구사항에 도출되는 도메인 모델이라면 리포리터리는 구현을 위한 도메인 모델이다.
리포지터리는 애그리거트 단위로 도메인 객체를 저장하고 조회하는 기능을 정의
- OrderRepository의 메서드를 보면 대상을 찾고 저장하는 단위가 애그리거트 루트인 Order인 것을 알 수 있다.
- Order는 애그리거트에 속한 모든 객체를 포함하고 있으므로 결과적으로 애그리거트 단위로 저장하고 조회한다.
```
public interface OrderRepository {
	Order findByNumber(OrderNumber number);
	void save(Order order);
	void delete(Order order);
}
```
도메인 모델을 사용해야 하는 코드는 리포지터리를 통해서 도메인 객체를 구한 뒤에 도메인 객체의 기능을 실행
public class CancelOrderService { private OrderRepository orderRepository; public void cancel(OrderNumber number) { Order order = orderRepository.findByNumber(number); if (order == null) { throw new OrderNotFoundException(orderId); } order.cancel(); } }
도메인 모델 관점에서 OrderRepository는 도메인 객체를 영속화하는 데 필요한 기능을 추상화 한것으로 고수준 모듈에 속한다.
기반 기술을 이용해서 OrderRepository를 구현한 클래스는 저수준 모듈로 인프라스트럭처 영역에 속한다.
전체 모듈 구조
응용 서비스는 의존 주입과 같은 방식을 사용해서 실제 리포지터리 구현 객체에 접근
응용 서비스와 리포지터리는 밀접한 연관이 있다.
- 응용 서비스는 필요한 도메인 객체를 구하거나 저장할 때 리포지터리를 사용한다.
- 응용 서비스는 트랜잭션을 관리하는데, 트랜잭션 처리는 리포지터리 구현 기술의 영향을 받는다.
리포지터리를 사용하는 주체가 응용 서비스이기 때문에 리포지터리는 응용 서비스가 필요로 하는 메서드를 제공한다.
- 애그리거트를 저장하는 메서드
- 애그리거트 루트 식별자로 애그리거트를 조회하는 메서드

2.5 요청 처리 흐름

표현 영역은 사용자가 전송한 데이터 형식이 올바른지 검사하고 문제가 없다면 데이터를 이용해서 응용 서비스에 기능 실행을 위임
표현 영역은 사용자가 전송한 데이터를 응용 서비스가 요구하는 형식으로 변환해서 전달
요청 처리 흐름
- 웹 브라우저에서 기능 실행 요청
- 표현 영역에 해당하는 컨트롤러는 HTTP 요청 파라미터를 응용 서비스가 필요로 하는 데이터로 변환 해서 응용 서비스의 인자로 전달
- 응용 서비스는 도메인 모델을 이용해서 로직 실행
- 도메인 객체를 리포지터리에서 가져와 실행하거나 신규 도메인 객체를 생성해 리포지터리에 저장
“예매하기”나 “예매 취소”와 같은 기능을 제공하는 응용 서비스는 도메인의 상태를 변경하므로 변경 상태가 물리 저장소에 올바르게 반영되도록 트랜잭션을 관리 해야한다.
- 스프링 프레임워크를 사용한다면 @Transactional 애너테이션을 이용해 트랜잭션을 처리할 수 있다.
```
public class CancelOrderService {
	private OrderRepository orderRepository;
	
	@Transactional
	public void cancel(OrderNumber number) {
		Order order = orderRepository.findByNumber(number);
		if (order == null) {
			throw new NoOrderException(number);
		}
		order.cancel()
	}
}
```

2.6 인프라스트럭처 개요

인프라스트럭처는 표현 영역, 응용 영역, 도메인 영역을 지원한다.
도메인 영역과 응용 영역에서 인프라스트럭처의 기능을 직접 사용하는 것보다 두 영역에서 정의한 인터페이스를 인프라스트럭처 영역에서 구현하는 것이 시스템을 더 유연하고 테스트하기 쉽게 만들어 준다.
무조건 인프라스트럭처에 대한 의존성을 없앨 필요는 없다.
- 스프링을 사용할 경우 응용 서비스는 트랜잭션 처리를 위해 @Transactional을 사용하는 것이 편리하다.
- 영속성 처리를 위해 JPA를 사용할 경우 @Entity나 @Table과 같은 JPA 전용 애너테이션을 도메인 모델 클래스에서 사용하는 것이 XML 매핑 설정을 이용하는 것보다 편리하다.
구현의 편리함은 DIP가 주는 다른 장점만큼 중요하기 때문에 DIP의 장점을 해치지 않는 범위에서 응용 영역과 도메인 영역에서 구현 기술에 대한 의존을 가져가는 것이 나쁘지 않다고 생각한다.
응용 영역과 도메인 영역이 인프라스트럭처에 대한 의존을 완전히 갖지 않도록 시도하는 것은 구현을 더 복잡하고 어렵게 만들 수 있다.
- @Transactional을 사용하면 한 줄로 트랙잭션을 처리할 수 있는데 코드에서 스프링에 대한 의존을 없애려면 복잡한 스프링 설정을 사용해야 한다.
- 의존은 없앴지만 특별히 테스트를 더 쉽게 할 수 있다거나 유연함을 증가시켜 주지 못한다.
- 설정만 복잡해지고 개발 시간만 늘어난다.
표현 영역은 항상 인프라스트럭처 영역과 쌍을 이룬다.
- 스프링 MVC를 사용해서 웹 요청을 처리하려면 스프링이 제공하는 MVC 프레임워크에 맞게 표현 영역을 구현
- Vert.x를 사용해서 Rest API 서버를 구축하려면 Vert.x에 맞게 웹 요청 처리 부분을 구현

2.7 모듈 구성

아키텍처의 각 영역은 별도 패키지에 위치한다.
패키지 구성 규칙에 정답이 존재하는 것은 안지만 영역별로 모듈이 위치할 패키지를 구성할 수 있을 것 이다.
도메인이 크면 하위 도메인으로 나누고 하위 도메인마다 별도 패키지를 구성한다.
도메인 모듈은 도메인에 속한 애그리거트를 기준으로 다시 패키지를 구성한다.
- 카탈로그 하위 도메인이 상품 애그리거트와 카테고리 애그리커트로 구성될 경우 도메인을 두 개의 하위 패키지로 구성할 수 있다.
애그리거트, 모델, 리포지터리는 같은 패키지에 위치시킨다.
- Order, OrderLine, Orderer, OrderRepository 등은 com.myshop.order.domain 패키지에 위치시킨다.
도메인이 복잡하면 도메인 모델과 도메인 서비스를 별도 패키지에 위치시킬 수도 있다.
- com.myshop.order.domain.order: 애그리거트 위치
- com.myshop.order.domain.service: 도메인 서비스 위치
응용 서비스도 도메인 별로 패키지를 구분할 수 있다.
- com.myshop.catalog.application.product
- com.myshop.catalog.application.category
모듈 구조를 얼마나 세분하게해야 하는지에 대한 정해진 규칙은 없다.
한 패키지에 너무 많은 타입이 몰려서 코드를 찾을 때 불편할 정도만 아니면 된다.

2.1 네 개의 영역

“표현”, “응용”, “도메인”, “인프라스트럭처”는 아키텍처를 설계할 때 출현하는 전형적인 네 가지 영역
- 표현 영역
  - 사용자의 요청을 받아 응용 영역에 전달, 응용 영역의 처리 결과를 사용자에게 전달
  - 스프링 MVC 프레임워크가 표현 영역의 기술
- 응용 영역
  - 표현 영역을 통해 사용자의 요청을 전달받은 응용 영역은 시스템이 사용자에게 제공해야할 기능을 구현
  - “주문 등록”, “주문 취소”, “상품 상세 조회” 등의 기능을 예로 들수 있다.
  - 기능을 구현하기 위한 도메인 영역의 도메인 모델을 사용
  - “주문 취소” 기능을 제공하는 응용 서비스를 도메인 모델을 사용해서 기능 구현이 가능
  - public class CancelOrderService { @Transactional public void cancelOrder(String orderId) { Order order = findOrderById(orderId); if (order == null) { throw new OrderNotFoundException(orderId); } order.cancel(); } }
  - 로직을 직접 수행하기보다는 도메인 모델에 로직 수행을 위임
    - “주문 취소” 로직을 직접 구현하지 않고 Order 객체에 취소 처리를 위임 하고 있다
- 도메인 영역
  - Order, OrderLine, ShippingInfo와 같은 도메인 모델
  - 도메인 모델은 핵심 로직을 구현한다.
    - “배송지 변경”, “결제 완료”, “주문 총액 계산”과 같은 핵심 로직을 도메인 모델에 구현한다.
- 인프라스트럭처 영역
  - 구현 기술에 대한 것을 다룬다
  - RDBMS 연동, 메시징 큐에 메시지 전송과 수신, 몽고DB나 레디스의 데이터 연동 처리 등
  - 논리적인 개념을 표현하기보다는 실제 구현을 다룬다
  - 도메인 영역, 응용 영역, 표현 영역은 구현 기술을 사용한 코드를 직접 만들지 않는다.
    - 인프라스트럭처 영역에서 제공하는 기능을 사용해서 필요한 기능을 개발

2.2 계층 구조 아키텍처

네 영역을 구성할 때 많이 사용하는 아키텍처가 그림과 같은 계층 구조이다.
- 표현 영역과 응용 영역은 도메인 영역을 사용
- 도메인 영역은 인프라스트럭처 영역을 사용
도메인의 복잡도에 따라 응용과 도메인을 분리하기도 하고 한 계층으로 합치기도 하지만 전체적인 아키텍처는 계층 구조를 따른다.
계층 구조는 특성상 상위 계층에서 하위 계층으로의 의존만 존재하고 하위 계층은 상위 계층에 의존하지 않는다.
계층 구조를 엄격하게 적용한다면 상위 계층은 바로 아래의 계층에만 의존을 가져야 하지만 구현의 편리함을 위해 계층 구조를 유연하게 적용하기도 한다.
응용 영역과 도메인 영역은 DB나 외부 시스템 연동을 위해 인프라스트럭처의 기능을 사용하므로 계층 구조를 사용하는 것이 직관적으로 이해하기 쉽다.
- 표현, 응용, 도메인 계층이 상세한 구현 기술을 다루는 인프라스트럭처 계층에 종속된다

도메인의 가격 계산 규칙의 예제

할인 금액을 계산하기 위해 Drools라는 룰 엔진을 사용해서 계산 로직을 수행하는 인프라스트럭처 영역의 코드를 만들어 보자

public class DroolsRuleEngine {
	private KieContainer kContainer;

	public DroolsRuleEngine() {
		KieServices ks = KieServices.Factory.get();
		kContainer = ks.getKieClasspathContainer();		
	}

	public void evalute(String sessionName, List<?> facts) {
		KiSession kSession = kContainer.newKieSession(sessionName);
		try {
			facts.forEach(x -> kSession.insert(x));
			kSession.fireAllRules();
		} finaly {
			kSession.dispose();
		}
	}
}

응용 영역은 가격 계산을 위해 인프라스트럭처 영역의 DroolsRuleEngine을 사용

public class CalcuateDiscountService {
	private DroolsRuleEngine ruleEngine;
	
	public CalculateDiscountService() {
		ruleEngine = new DroolsRuleEngine();
	}

	public Money calculateDiscount(List<OrderLine> orderLines, String customerId) {
		Customer customer = findCustomer(customerId);
		
		MutableMoney money = new MutableMoney(0);
		List<?> facts = Arrays.asList(customer, money);
		facts.addAll(orderLines);
		ruleEngine.evalute("discountCalculation", facts);
		return money.toImmutableMoney();
	}
}

CalculateDiscountService가 동작은 하겠지만 두가지 문제를 안고 있다.
- CalculateDiscountService를 테스트하기 어렵다
  - RuleEngine이 완벽하게 동작해야 한다.
  - RuleEngine 클래스와 관련 설정 파일 모두 만든 이후에 CalculateDiscountService 를 확인할 수 있다.
- 구현 방식을 변경하기 어렵다
  - ‘discountCalculation’ 문자열은 Drools의 세션 이름을 의미한다.
  - 세션 이름을 변경하면 CalculateDiscountService 코드도 함께 변경해야 한다.
CalculateDiscountService가 겉으로는 인프라스트럭처의 기술에 직접적인 의존을 하지 않는 것처럼 보여도 실제로는 Drools라는 인프라스트럭처 영역의 기술에 완전하게 의존하고 있다.
인프라스트럭처에 의존하면 ‘테스트 어려움’과 ‘기능 확장 어려움’이라는 두가지 문제가 발생한다.
- 문제 해답은 DIP에 있다.

2.3 DIP

가격 할인 계산을 하려면 고객 정보를 구해야하고, 구한 고객 정보와 주문 정보를 이용해서 룰을 실행해야 한다.
CalculateDiscountService는 고수준 모듈이다.
- 고수준 모듈은 의미 있는 단일 기능을 제공하는 모듈로 ‘가격 할인 계산’이라는 기능을 구현
- 가격 할인 계싼 기능을 구현하려면 고객 정보를 구해야하고 룰을 실행해야 하는데 이 두 기능이 하위 기능이다.
저수준 모듈은 하위 기능을 실제로 구현한 것이다.
- JPA를 이용해서 고객 정보를 읽어오는 모듈과 Drools로 룰을 실행하는 모듈이 저수준 모듈이 된다.

DIP는 저수준 모듈이 고수준 모듈에 의존하도록 바꾼다.

추상화 인터페이스를 사용

public interface RuleDiscounter {
	Money applyRules(Customer customer, List<OrderLine> orderLines);
}

CalculateDiscountService가 RuleDiscounter를 이용하도록 변경
- Drools에 의존하는 코드가 없다

public class CalcuateDiscountService {
	private RuleDiscounter ruleDiscounter;
	
	public CalculateDiscountService(RuleDiscounter ruleDiscounter) {
		this.ruleDiscounter = ruleDiscounter;
	}

	public Money calculateDiscount(List<OrderLine> orderLines, String customerId) {
		Customer customer = findCustomer(customerId);
		return ruleDiscounter.applyRules(customer, orderLines);
	}
}

RuleDiscounter를 상속받아 구현

public class DroolsRuleDiscounter implements RuleDiscounter {
	private KieCountainer kContainer;
	
	public DroolsRuleEngine() {
		KieService ks = KieServices.Factory.get();
		kContainer = ks.getKieClasspathContainer();
	}

	@Override
	public Money applyRules(Customer customer, List<OrderLine> orderLines) {
		KieSession kSession = kContainer.newKieSession("discountSession");
		try {
			...
			kSession.fireAllRules();
		} finally {
			kSession.dispose();
		}
		return money.toImmutableMoney();
	}
}

RuleDiscounter가 출현하면서 바뀐 구조
CalculateDiscountService는 더이상 구현 기술인 Drools에 의존하지 않는다.
- RuleDiscounter 인터페이스에 의존할 뿐
- ‘룰을 이용한 할인 금액 계산’은 고수준 모듈의 개념이므로 RuleDiscounter 인터페이스는 고수준 모듈에 속한다.
- DroolsRuleDiscounter는 고수준의 하위 기능인 RuleDiscounter를 구현한 것이므로 저수준 모듈에 속한다.

DIP를 적용하면 저수준 모듈이 고수준 모듈에 의존하게 된다.
- 고수준 모듈이 저수준 모듈을 사용하려면 고수준 모듈이 저수준 모듈에 의존해야 하는데, 반대로 저수준 모듈이 고수준 모듈에 의존한다고 해서 이를 DIP(Dependency Inversion Principle, 의존 역전 원칙)이라 부른다.
DIP를 적용하면 다른 영역인 인프라스트럭처 영역에 의존할 떄 발생했던 두가지 문제인 구현 교체가 어렵다는 것과 테스트가 어려운 문제를 해소할 수 있다.

고수준 모듈은 더 이상 저수준 모듈에 의존하지 않고 구현을 추상화한 인터페이스에 의존할 수 있다.

구현 기술이 변경되더라도 저수준 구현 객체를 생성하는 코드만 변경하면 된다.

// 기존 코드
RuleDiscounter roleDiscounter = new DroolsRuleDiscounter();
CalculateDiscountService disService = new CalculateDiscountService(roleDiscounter);

// 구현 기술 변경 
RuleDiscounter roleDiscounter = new SimpleRuleDiscounter();
CalculateDiscountService disService = new CalculateDiscountService(roleDiscounter);

스프링과 같은 의존 주입을 지원하는 프레임워크를 사용하면 설정 코드를 수정해서 쉽게 구현체를 변경할 수 있다.
CalculateDiscountService가 제대로 동작하는지 테스트하려면 CustomerRepository와 RuleDiscounter를 구현한 객체가 필요하다.
- CacluateDiscountService가 저수준 모듈에 직접 의존했다면 저수준 모듈이 만들어지기 전까진 테스트를 할 수 없음
- 인터페이스에 의존함으로 대역 객체를 사용해서 테스트를 진행 할수 있다.
- 실제 구현 대신 스텁이나 모의 객체와 같은 테스트 목적의 대역을 사용하여 거의 모든 상황을 테스트할 수 있다.
```
public class CalculateDiscountServiceTest {
	@Test
	public void noCustomer_thenExcetionShouldBeThrown() {
		CustomerRepository stubRepo = mock(CustomerRepository.class);
		when(stubRepo.findById("noCustId")).thenRetrun(null);

		RuleDiscounter stubRule = (cust, lines) -> null;
		
		CalculateDiscountService calDisSvc = new CalculateDiscountService(stbRepo, stubRule);
		assertThrows(NoCustomerException.class, () -> calDisSvc.calculateDiscount(ssomeLines, "noCustId"));
	}
}
```
실제 구현 없이 테스트를 할 수 있는 이유는 DIP를 적용해서 고수준 모듈이 저수준 모듈에 의존하지 않도록 했기 때문이다.

2.3.1 DIP 주의사항

DIP를 잘못 생각하면 단순히 인터페이스와 구현 클래스를 분리하는 정도로 받아드릴 수 있다.
DIP의 핵심은 고수준 모듈이 저수준 모듈의 의존하지 않도록 하기 위함이다.
잘못된 구조
- 도메인 영역은 구현 기술을 다루는 인프라스트럭처 영역에 의존하고 있다.
- 고수준 모듈이 저수준 모듈에 의존하고 있다.
DIP를 적용할 때 하위 기능을 추상화한 인터페이스는 고수준 모듈 관점에서 도출한다.
- CalculateDiscountService는 할인 금액을 구하기 위한 룰 엔진을 사용하는지 직접 연산하는지 중요하지 않다.
- 규칙에 따라 할인 금액을 계산하는 것이 중요
- ‘할인 금액 계산’을 추상화한 인터페이스는 저수준 모듈이 아닌 고수준 모듈에 위치한다.

2.3.2 DIP와 아키텍처

인프라스트럭처 영역은 구현 기술을 다루는 저수준 모듈이고 응용 영역과 도메인 영역은 고수준 모듈이다.
인프라스트럭처 계층이 가장 하단에 위치하는 계층형 구조와 달리 아키텍처에 DIP를 적용하면 인프라스트럭처 영역이 응용 영역와 도메인 영역에 의존하는 구조가 된다.
인프라스트럭처에 위치한 클래스가 도메인이나 응용 영역에 정의한 인터페이스를 상속받아 구현하는 구조가 되므로 도메인과 응용 영역에 대한 영향을 주지 않거나 최소화하면서 구현 기술을 변경하는 것이 가능하다.
주문 시 통지 방식에 SMS를 추가해야 한다는 요구사항이 들어왔을 때 OrderService는 변경할 필요가 없다.
- 두 통지 방식을 함께 제공하는 Notifier 구현 클래스를 인프라스트럭처 영역에 추가하면 된다.
마이바티스 대신 JPA를 구현 기술로 사용하고 싶다면 JPA를 이용한 OrderRepository 구현 클래스를 인프라 스트럭처 영역에 추가하면 된다.

2.4 도메인 영역의 주요 구성요소

도메인 영역을 구성하는 요소요소 설명

엔티티 ENTITY	고유 식별자를 갖는 객체로 자신의 라이프 사이클을 갖는다. Order, Member, Product와 같이 도메인의 고유한 개념을 표현한다. 도메인 모델의 데이터를 포함하며 해당 데이터와 관련된 기능을 함께 제공
밸류 VALUE	고유 식별자를 갖지 않는 객체로 주로 개념적으로 하나의 값을 표현할 때 사용된다. 배송지 주소를 표현하기 위한 Address나 구매한 금액을 위한 Money와 같은 타입이 밸류 타입이다. 엔티티의 속성으로 사용할 뿐만 아니라 다른 밸류 타입의 속성도 사용할 수 있다.
애그리거트 AGGREGATE	애그리거트는 연관된 엔티티와 밸류 객체를 개념적으로 하나로 묶는 것이다. 주문과 관련된 Order 엔티티, OrderLine 밸류, Orderer 밸류 객체를 주문 애그리거트로 묶을 수 있다.
리포지터리 REPOSITORY	도메인 모델의 영속성을 처리한다. DBMS 테이블에서 엔티티 객체를 로딩하거나 저장하는 기능을 제공
도메인 서비스 DOMAIN SERVICE	특정 엔티티에 속하지 않는 도메인 로직을 제공한다. ‘할인 금액 계산’은 상품, 쿠폰, 회원 등급, 구매 금액 등 다양한 조건을 이용해서 구현하게 되는데 이렇게 도메인 로직이 여러 엔티티와 밸류를 필요로 하면 도메인 서비스에 로직을 구현

2.4.1 엔티티와 밸류

엔티티와 도메인 모델의 가장 큰 차이점은 도메인 모델의 엔티티는 데이터와 함께 도메인 기능을 함께 제공한다는 점
- 주문을 표현하는 엔티티는 주문과 관련된 데이터뿐만 아니라 배송지 주소 변경을 위한 기능을 함께 제공
```
public class Order {
	private OrderNo number;
	private Orderer orderer;
	private ShippingInfo shippingInfo;
	
	// 도메인 모델 엔티티는 도메인 기능도 함께 제공
	public void shangeShippingInfo(ShippingInfo newShippingInfo) {
		...	
	}
}
```
도메인 모델의 엔티티는 단순히 데이터를 담고 있는 데이터 구조라기보다는 데이터와 함께 기능을 제공하는 객체
도메인 관점에서 기능을 구현하고 기능 구현을 캡슐화해서 데이터가 임의로 변경되는 것을 막는다.
도메인 모델의 엔티티는 두 개 이상의 데이터가 개념적으로 하나인 경우 밸류 타입을 이용해서 표현할 수 있다
- Orderer는 밸류 타입으로 주문자 이름과 이메일 데이터를 포함할 수 있다.
```
public class Orderer {
	private String name;
	private String email;
}
```
RDBMS와 같은 관계형 데이터베이스는 밸류 타입을 재대로 표현하기 힘들다.
- Ordere의 개별 데이터를 저장하거나 밸로 테이블로 분리해서 저장해야 한다.
- 한 테이블에 주문자 정보 함께 넣기
  - 주문자라는 개념이 들어나지 않고 주문자의 개별 데이터만 드러난다.
- 다른 테이블에 주문자 정보 넣기
  - 주문자 데이터를 별도 테이블에 저장했지만 이것은 테이블의 엔티티에 가까우며 밸류 타입의 의미가 드러나지 않는다.

밸류는 불변으로 구현할 것을 권장

엔티티의 밸류 타입 데이터를 변경할 떄는 객체 자체를 완전히 교체한다는 것을 의미

public class Order {
	private ShippingInfo shippingInfo;
	
	public void shangeShippingInfo(ShippingInfo newShippingInfo) {
		checkShippingInfoChangeable();
		setShippingInfo(newShippingInfo);
	}

	private void setShippingInfo(ShippingInfo newShippingInfo) {
		if (newShippingInfo == null) {
			throw new IllegalArgumentException();
		}
		this.shippingInfo = newShippingInfo;
	}
}

2.4.2 애그리거트

도메인이 커질수록 개발할 도메인 모델도 커지면서 많은 엔티티와 밸류가 출현한다.
도메인 모델이 복잡해지면 개발자가 전체 구조가 아닌 한 개 엔티티와 밸류에만 집중하는 상황이 발생한다.
- 상위 수준에서 모델을 관리하지 않고 개별 요소에만 초점을 맞추다 보면, 큰 수준에서 모델을 이해하지 못해 큰 틀에서 모델은 관리할 수 없는 상황에 빠질 수 있다.
도메인 모델에 전체 구조를 이해하는데 도움이 되는 것이 바로 애그리거트(AGGREGATE)이다.
애그리거트는 관련 객체를 하나로 묶은 군집이다.
- 모메인 개념은“주문”, “배송지 정보”, “주문자”, “주문 목록”, “총 결제 금액”의 하위 모델로 구성된다.
- 하위 내념을 표현한 모델을 하나로 묶어서 “주문”이라는 상위 개념으로 표현할 수 있다.
애그리거트를 사용하면 개별 객체가 아닌 관련 객체를 묶어서 객체 군집 단위로 모델을 바라볼 수 있게 된다.
- 개별 객체 간의 관계가 아닌 애그리거트 간의 관계로 도메인 모델을 이해하고 구현하고, 큰 틀에서 도메인 모델을 관리할 수 있다.
애그리거트는 군집에 속한 객체를 관리하는 루트 엔티티를 갖는다.
- 루트 엔티티는 애그리거트에 속해 있는 엔티티와 밸류 객체를 이용해서 애그리거트가 구현해야 할 기능을 제공
- 애그리거트를 사용하는 코드는 애그리거트 루트가 제공하는 기능을 실행
- 애그리거트 루트를 통해 간접적으로 애그리거트 내의 다른 엔티티나 밸류 객체에 접근
- 애그리거트의 내부 구현을 숨겨서 애그리거트 단위로 구현을 캡슐화할 수 있도록 돕는다.
주문 애그리거트
- 애그리거트 루트인 Order는 주문 도메인 로직에 맞게 애그리거트의 상태를 관리
- Order의 배송지 정보 변경 기능은 배송지를 변경할 수 있는지를 확인한 위에 배송지 정보를 변경
- 주문 애그리거트는 Order를 통하지 않고 ShippingInfo를 변경할 수 있는 방법을 제공하지 않는다.
  - 배송지를 변경하려면 루트 엔티티인 Order를 사용해야 하므로 배소지 정보를 변경할 때는 Order가 구현한 도메인 로직을 항상 따르게 된다.
애그리거트를 구현할 때는 고려할 것이 많다.
- 애그리거트를 어떻게 구성했느냐에 따라 구현이 복잡해지기도 하고
- 트랜잭션 범위가 달라지기도 한다.

2.4.3 리포지터리

도메인 객체를 지속적으로 사용하려면 RDBMS, NoSQL, 로컬 파일과 같은 물리적인 저장소에 도메인 객체를 보관해야 한다.
- 이를 위한 도메인 모델이 리포지터리(Repository)이다.
엔티티나 밸류가 요구사항에 도출되는 도메인 모델이라면 리포리터리는 구현을 위한 도메인 모델이다.
리포지터리는 애그리거트 단위로 도메인 객체를 저장하고 조회하는 기능을 정의
- OrderRepository의 메서드를 보면 대상을 찾고 저장하는 단위가 애그리거트 루트인 Order인 것을 알 수 있다.
- Order는 애그리거트에 속한 모든 객체를 포함하고 있으므로 결과적으로 애그리거트 단위로 저장하고 조회한다.
```
public interface OrderRepository {
	Order findByNumber(OrderNumber number);
	void save(Order order);
	void delete(Order order);
}
```
도메인 모델을 사용해야 하는 코드는 리포지터리를 통해서 도메인 객체를 구한 뒤에 도메인 객체의 기능을 실행
public class CancelOrderService { private OrderRepository orderRepository; public void cancel(OrderNumber number) { Order order = orderRepository.findByNumber(number); if (order == null) { throw new OrderNotFoundException(orderId); } order.cancel(); } }
도메인 모델 관점에서 OrderRepository는 도메인 객체를 영속화하는 데 필요한 기능을 추상화 한것으로 고수준 모듈에 속한다.
기반 기술을 이용해서 OrderRepository를 구현한 클래스는 저수준 모듈로 인프라스트럭처 영역에 속한다.
전체 모듈 구조
응용 서비스는 의존 주입과 같은 방식을 사용해서 실제 리포지터리 구현 객체에 접근
응용 서비스와 리포지터리는 밀접한 연관이 있다.
- 응용 서비스는 필요한 도메인 객체를 구하거나 저장할 때 리포지터리를 사용한다.
- 응용 서비스는 트랜잭션을 관리하는데, 트랜잭션 처리는 리포지터리 구현 기술의 영향을 받는다.
리포지터리를 사용하는 주체가 응용 서비스이기 때문에 리포지터리는 응용 서비스가 필요로 하는 메서드를 제공한다.
- 애그리거트를 저장하는 메서드
- 애그리거트 루트 식별자로 애그리거트를 조회하는 메서드

2.5 요청 처리 흐름

표현 영역은 사용자가 전송한 데이터 형식이 올바른지 검사하고 문제가 없다면 데이터를 이용해서 응용 서비스에 기능 실행을 위임
표현 영역은 사용자가 전송한 데이터를 응용 서비스가 요구하는 형식으로 변환해서 전달
요청 처리 흐름
- 웹 브라우저에서 기능 실행 요청
- 표현 영역에 해당하는 컨트롤러는 HTTP 요청 파라미터를 응용 서비스가 필요로 하는 데이터로 변환 해서 응용 서비스의 인자로 전달
- 응용 서비스는 도메인 모델을 이용해서 로직 실행
- 도메인 객체를 리포지터리에서 가져와 실행하거나 신규 도메인 객체를 생성해 리포지터리에 저장
“예매하기”나 “예매 취소”와 같은 기능을 제공하는 응용 서비스는 도메인의 상태를 변경하므로 변경 상태가 물리 저장소에 올바르게 반영되도록 트랜잭션을 관리 해야한다.
- 스프링 프레임워크를 사용한다면 @Transactional 애너테이션을 이용해 트랜잭션을 처리할 수 있다.
```
public class CancelOrderService {
	private OrderRepository orderRepository;
	
	@Transactional
	public void cancel(OrderNumber number) {
		Order order = orderRepository.findByNumber(number);
		if (order == null) {
			throw new NoOrderException(number);
		}
		order.cancel()
	}
}
```

2.6 인프라스트럭처 개요

인프라스트럭처는 표현 영역, 응용 영역, 도메인 영역을 지원한다.
도메인 영역과 응용 영역에서 인프라스트럭처의 기능을 직접 사용하는 것보다 두 영역에서 정의한 인터페이스를 인프라스트럭처 영역에서 구현하는 것이 시스템을 더 유연하고 테스트하기 쉽게 만들어 준다.
무조건 인프라스트럭처에 대한 의존성을 없앨 필요는 없다.
- 스프링을 사용할 경우 응용 서비스는 트랜잭션 처리를 위해 @Transactional을 사용하는 것이 편리하다.
- 영속성 처리를 위해 JPA를 사용할 경우 @Entity나 @Table과 같은 JPA 전용 애너테이션을 도메인 모델 클래스에서 사용하는 것이 XML 매핑 설정을 이용하는 것보다 편리하다.
구현의 편리함은 DIP가 주는 다른 장점만큼 중요하기 때문에 DIP의 장점을 해치지 않는 범위에서 응용 영역과 도메인 영역에서 구현 기술에 대한 의존을 가져가는 것이 나쁘지 않다고 생각한다.
응용 영역과 도메인 영역이 인프라스트럭처에 대한 의존을 완전히 갖지 않도록 시도하는 것은 구현을 더 복잡하고 어렵게 만들 수 있다.
- @Transactional을 사용하면 한 줄로 트랙잭션을 처리할 수 있는데 코드에서 스프링에 대한 의존을 없애려면 복잡한 스프링 설정을 사용해야 한다.
- 의존은 없앴지만 특별히 테스트를 더 쉽게 할 수 있다거나 유연함을 증가시켜 주지 못한다.
- 설정만 복잡해지고 개발 시간만 늘어난다.
표현 영역은 항상 인프라스트럭처 영역과 쌍을 이룬다.
- 스프링 MVC를 사용해서 웹 요청을 처리하려면 스프링이 제공하는 MVC 프레임워크에 맞게 표현 영역을 구현
- Vert.x를 사용해서 Rest API 서버를 구축하려면 Vert.x에 맞게 웹 요청 처리 부분을 구현

2.7 모듈 구성

아키텍처의 각 영역은 별도 패키지에 위치한다.
패키지 구성 규칙에 정답이 존재하는 것은 안지만 영역별로 모듈이 위치할 패키지를 구성할 수 있을 것 이다.
도메인이 크면 하위 도메인으로 나누고 하위 도메인마다 별도 패키지를 구성한다.
도메인 모듈은 도메인에 속한 애그리거트를 기준으로 다시 패키지를 구성한다.
- 카탈로그 하위 도메인이 상품 애그리거트와 카테고리 애그리커트로 구성될 경우 도메인을 두 개의 하위 패키지로 구성할 수 있다.
애그리거트, 모델, 리포지터리는 같은 패키지에 위치시킨다.
- Order, OrderLine, Orderer, OrderRepository 등은 com.myshop.order.domain 패키지에 위치시킨다.
도메인이 복잡하면 도메인 모델과 도메인 서비스를 별도 패키지에 위치시킬 수도 있다.
- com.myshop.order.domain.order: 애그리거트 위치
- com.myshop.order.domain.service: 도메인 서비스 위치
응용 서비스도 도메인 별로 패키지를 구분할 수 있다.
- com.myshop.catalog.application.product
- com.myshop.catalog.application.category
모듈 구조를 얼마나 세분하게해야 하는지에 대한 정해진 규칙은 없다.
한 패키지에 너무 많은 타입이 몰려서 코드를 찾을 때 불편할 정도만 아니면 된다.

2.1 네 개의 영역

“표현”, “응용”, “도메인”, “인프라스트럭처”는 아키텍처를 설계할 때 출현하는 전형적인 네 가지 영역
- 표현 영역
  - 사용자의 요청을 받아 응용 영역에 전달, 응용 영역의 처리 결과를 사용자에게 전달
  - 스프링 MVC 프레임워크가 표현 영역의 기술
- 응용 영역
  - 표현 영역을 통해 사용자의 요청을 전달받은 응용 영역은 시스템이 사용자에게 제공해야할 기능을 구현
  - “주문 등록”, “주문 취소”, “상품 상세 조회” 등의 기능을 예로 들수 있다.
  - 기능을 구현하기 위한 도메인 영역의 도메인 모델을 사용
  - “주문 취소” 기능을 제공하는 응용 서비스를 도메인 모델을 사용해서 기능 구현이 가능
  - public class CancelOrderService { @Transactional public void cancelOrder(String orderId) { Order order = findOrderById(orderId); if (order == null) { throw new OrderNotFoundException(orderId); } order.cancel(); } }
  - 로직을 직접 수행하기보다는 도메인 모델에 로직 수행을 위임
    - “주문 취소” 로직을 직접 구현하지 않고 Order 객체에 취소 처리를 위임 하고 있다
- 도메인 영역
  - Order, OrderLine, ShippingInfo와 같은 도메인 모델
  - 도메인 모델은 핵심 로직을 구현한다.
    - “배송지 변경”, “결제 완료”, “주문 총액 계산”과 같은 핵심 로직을 도메인 모델에 구현한다.
- 인프라스트럭처 영역
  - 구현 기술에 대한 것을 다룬다
  - RDBMS 연동, 메시징 큐에 메시지 전송과 수신, 몽고DB나 레디스의 데이터 연동 처리 등
  - 논리적인 개념을 표현하기보다는 실제 구현을 다룬다
  - 도메인 영역, 응용 영역, 표현 영역은 구현 기술을 사용한 코드를 직접 만들지 않는다.
    - 인프라스트럭처 영역에서 제공하는 기능을 사용해서 필요한 기능을 개발

2.2 계층 구조 아키텍처

네 영역을 구성할 때 많이 사용하는 아키텍처가 그림과 같은 계층 구조이다.
- 표현 영역과 응용 영역은 도메인 영역을 사용
- 도메인 영역은 인프라스트럭처 영역을 사용
도메인의 복잡도에 따라 응용과 도메인을 분리하기도 하고 한 계층으로 합치기도 하지만 전체적인 아키텍처는 계층 구조를 따른다.
계층 구조는 특성상 상위 계층에서 하위 계층으로의 의존만 존재하고 하위 계층은 상위 계층에 의존하지 않는다.
계층 구조를 엄격하게 적용한다면 상위 계층은 바로 아래의 계층에만 의존을 가져야 하지만 구현의 편리함을 위해 계층 구조를 유연하게 적용하기도 한다.
응용 영역과 도메인 영역은 DB나 외부 시스템 연동을 위해 인프라스트럭처의 기능을 사용하므로 계층 구조를 사용하는 것이 직관적으로 이해하기 쉽다.
- 표현, 응용, 도메인 계층이 상세한 구현 기술을 다루는 인프라스트럭처 계층에 종속된다

도메인의 가격 계산 규칙의 예제

할인 금액을 계산하기 위해 Drools라는 룰 엔진을 사용해서 계산 로직을 수행하는 인프라스트럭처 영역의 코드를 만들어 보자

public class DroolsRuleEngine {
	private KieContainer kContainer;

	public DroolsRuleEngine() {
		KieServices ks = KieServices.Factory.get();
		kContainer = ks.getKieClasspathContainer();		
	}

	public void evalute(String sessionName, List<?> facts) {
		KiSession kSession = kContainer.newKieSession(sessionName);
		try {
			facts.forEach(x -> kSession.insert(x));
			kSession.fireAllRules();
		} finaly {
			kSession.dispose();
		}
	}
}

응용 영역은 가격 계산을 위해 인프라스트럭처 영역의 DroolsRuleEngine을 사용

public class CalcuateDiscountService {
	private DroolsRuleEngine ruleEngine;
	
	public CalculateDiscountService() {
		ruleEngine = new DroolsRuleEngine();
	}

	public Money calculateDiscount(List<OrderLine> orderLines, String customerId) {
		Customer customer = findCustomer(customerId);
		
		MutableMoney money = new MutableMoney(0);
		List<?> facts = Arrays.asList(customer, money);
		facts.addAll(orderLines);
		ruleEngine.evalute("discountCalculation", facts);
		return money.toImmutableMoney();
	}
}

CalculateDiscountService가 동작은 하겠지만 두가지 문제를 안고 있다.
- CalculateDiscountService를 테스트하기 어렵다
  - RuleEngine이 완벽하게 동작해야 한다.
  - RuleEngine 클래스와 관련 설정 파일 모두 만든 이후에 CalculateDiscountService 를 확인할 수 있다.
- 구현 방식을 변경하기 어렵다
  - ‘discountCalculation’ 문자열은 Drools의 세션 이름을 의미한다.
  - 세션 이름을 변경하면 CalculateDiscountService 코드도 함께 변경해야 한다.
CalculateDiscountService가 겉으로는 인프라스트럭처의 기술에 직접적인 의존을 하지 않는 것처럼 보여도 실제로는 Drools라는 인프라스트럭처 영역의 기술에 완전하게 의존하고 있다.
인프라스트럭처에 의존하면 ‘테스트 어려움’과 ‘기능 확장 어려움’이라는 두가지 문제가 발생한다.
- 문제 해답은 DIP에 있다.

2.3 DIP

가격 할인 계산을 하려면 고객 정보를 구해야하고, 구한 고객 정보와 주문 정보를 이용해서 룰을 실행해야 한다.
CalculateDiscountService는 고수준 모듈이다.
- 고수준 모듈은 의미 있는 단일 기능을 제공하는 모듈로 ‘가격 할인 계산’이라는 기능을 구현
- 가격 할인 계싼 기능을 구현하려면 고객 정보를 구해야하고 룰을 실행해야 하는데 이 두 기능이 하위 기능이다.
저수준 모듈은 하위 기능을 실제로 구현한 것이다.
- JPA를 이용해서 고객 정보를 읽어오는 모듈과 Drools로 룰을 실행하는 모듈이 저수준 모듈이 된다.

DIP는 저수준 모듈이 고수준 모듈에 의존하도록 바꾼다.

추상화 인터페이스를 사용

public interface RuleDiscounter {
	Money applyRules(Customer customer, List<OrderLine> orderLines);
}

CalculateDiscountService가 RuleDiscounter를 이용하도록 변경
- Drools에 의존하는 코드가 없다

public class CalcuateDiscountService {
	private RuleDiscounter ruleDiscounter;
	
	public CalculateDiscountService(RuleDiscounter ruleDiscounter) {
		this.ruleDiscounter = ruleDiscounter;
	}

	public Money calculateDiscount(List<OrderLine> orderLines, String customerId) {
		Customer customer = findCustomer(customerId);
		return ruleDiscounter.applyRules(customer, orderLines);
	}
}

RuleDiscounter를 상속받아 구현

public class DroolsRuleDiscounter implements RuleDiscounter {
	private KieCountainer kContainer;
	
	public DroolsRuleEngine() {
		KieService ks = KieServices.Factory.get();
		kContainer = ks.getKieClasspathContainer();
	}

	@Override
	public Money applyRules(Customer customer, List<OrderLine> orderLines) {
		KieSession kSession = kContainer.newKieSession("discountSession");
		try {
			...
			kSession.fireAllRules();
		} finally {
			kSession.dispose();
		}
		return money.toImmutableMoney();
	}
}

RuleDiscounter가 출현하면서 바뀐 구조
CalculateDiscountService는 더이상 구현 기술인 Drools에 의존하지 않는다.
- RuleDiscounter 인터페이스에 의존할 뿐
- ‘룰을 이용한 할인 금액 계산’은 고수준 모듈의 개념이므로 RuleDiscounter 인터페이스는 고수준 모듈에 속한다.
- DroolsRuleDiscounter는 고수준의 하위 기능인 RuleDiscounter를 구현한 것이므로 저수준 모듈에 속한다.

DIP를 적용하면 저수준 모듈이 고수준 모듈에 의존하게 된다.
- 고수준 모듈이 저수준 모듈을 사용하려면 고수준 모듈이 저수준 모듈에 의존해야 하는데, 반대로 저수준 모듈이 고수준 모듈에 의존한다고 해서 이를 DIP(Dependency Inversion Principle, 의존 역전 원칙)이라 부른다.
DIP를 적용하면 다른 영역인 인프라스트럭처 영역에 의존할 떄 발생했던 두가지 문제인 구현 교체가 어렵다는 것과 테스트가 어려운 문제를 해소할 수 있다.

고수준 모듈은 더 이상 저수준 모듈에 의존하지 않고 구현을 추상화한 인터페이스에 의존할 수 있다.

구현 기술이 변경되더라도 저수준 구현 객체를 생성하는 코드만 변경하면 된다.

// 기존 코드
RuleDiscounter roleDiscounter = new DroolsRuleDiscounter();
CalculateDiscountService disService = new CalculateDiscountService(roleDiscounter);

// 구현 기술 변경 
RuleDiscounter roleDiscounter = new SimpleRuleDiscounter();
CalculateDiscountService disService = new CalculateDiscountService(roleDiscounter);

스프링과 같은 의존 주입을 지원하는 프레임워크를 사용하면 설정 코드를 수정해서 쉽게 구현체를 변경할 수 있다.
CalculateDiscountService가 제대로 동작하는지 테스트하려면 CustomerRepository와 RuleDiscounter를 구현한 객체가 필요하다.
- CacluateDiscountService가 저수준 모듈에 직접 의존했다면 저수준 모듈이 만들어지기 전까진 테스트를 할 수 없음
- 인터페이스에 의존함으로 대역 객체를 사용해서 테스트를 진행 할수 있다.
- 실제 구현 대신 스텁이나 모의 객체와 같은 테스트 목적의 대역을 사용하여 거의 모든 상황을 테스트할 수 있다.
```
public class CalculateDiscountServiceTest {
	@Test
	public void noCustomer_thenExcetionShouldBeThrown() {
		CustomerRepository stubRepo = mock(CustomerRepository.class);
		when(stubRepo.findById("noCustId")).thenRetrun(null);

		RuleDiscounter stubRule = (cust, lines) -> null;
		
		CalculateDiscountService calDisSvc = new CalculateDiscountService(stbRepo, stubRule);
		assertThrows(NoCustomerException.class, () -> calDisSvc.calculateDiscount(ssomeLines, "noCustId"));
	}
}
```
실제 구현 없이 테스트를 할 수 있는 이유는 DIP를 적용해서 고수준 모듈이 저수준 모듈에 의존하지 않도록 했기 때문이다.

2.3.1 DIP 주의사항

DIP를 잘못 생각하면 단순히 인터페이스와 구현 클래스를 분리하는 정도로 받아드릴 수 있다.
DIP의 핵심은 고수준 모듈이 저수준 모듈의 의존하지 않도록 하기 위함이다.
잘못된 구조
- 도메인 영역은 구현 기술을 다루는 인프라스트럭처 영역에 의존하고 있다.
- 고수준 모듈이 저수준 모듈에 의존하고 있다.
DIP를 적용할 때 하위 기능을 추상화한 인터페이스는 고수준 모듈 관점에서 도출한다.
- CalculateDiscountService는 할인 금액을 구하기 위한 룰 엔진을 사용하는지 직접 연산하는지 중요하지 않다.
- 규칙에 따라 할인 금액을 계산하는 것이 중요
- ‘할인 금액 계산’을 추상화한 인터페이스는 저수준 모듈이 아닌 고수준 모듈에 위치한다.

2.3.2 DIP와 아키텍처

인프라스트럭처 영역은 구현 기술을 다루는 저수준 모듈이고 응용 영역과 도메인 영역은 고수준 모듈이다.
인프라스트럭처 계층이 가장 하단에 위치하는 계층형 구조와 달리 아키텍처에 DIP를 적용하면 인프라스트럭처 영역이 응용 영역와 도메인 영역에 의존하는 구조가 된다.
인프라스트럭처에 위치한 클래스가 도메인이나 응용 영역에 정의한 인터페이스를 상속받아 구현하는 구조가 되므로 도메인과 응용 영역에 대한 영향을 주지 않거나 최소화하면서 구현 기술을 변경하는 것이 가능하다.
주문 시 통지 방식에 SMS를 추가해야 한다는 요구사항이 들어왔을 때 OrderService는 변경할 필요가 없다.
- 두 통지 방식을 함께 제공하는 Notifier 구현 클래스를 인프라스트럭처 영역에 추가하면 된다.
마이바티스 대신 JPA를 구현 기술로 사용하고 싶다면 JPA를 이용한 OrderRepository 구현 클래스를 인프라 스트럭처 영역에 추가하면 된다.

2.4 도메인 영역의 주요 구성요소

도메인 영역을 구성하는 요소요소 설명

엔티티 ENTITY	고유 식별자를 갖는 객체로 자신의 라이프 사이클을 갖는다. Order, Member, Product와 같이 도메인의 고유한 개념을 표현한다. 도메인 모델의 데이터를 포함하며 해당 데이터와 관련된 기능을 함께 제공
밸류 VALUE	고유 식별자를 갖지 않는 객체로 주로 개념적으로 하나의 값을 표현할 때 사용된다. 배송지 주소를 표현하기 위한 Address나 구매한 금액을 위한 Money와 같은 타입이 밸류 타입이다. 엔티티의 속성으로 사용할 뿐만 아니라 다른 밸류 타입의 속성도 사용할 수 있다.
애그리거트 AGGREGATE	애그리거트는 연관된 엔티티와 밸류 객체를 개념적으로 하나로 묶는 것이다. 주문과 관련된 Order 엔티티, OrderLine 밸류, Orderer 밸류 객체를 주문 애그리거트로 묶을 수 있다.
리포지터리 REPOSITORY	도메인 모델의 영속성을 처리한다. DBMS 테이블에서 엔티티 객체를 로딩하거나 저장하는 기능을 제공
도메인 서비스 DOMAIN SERVICE	특정 엔티티에 속하지 않는 도메인 로직을 제공한다. ‘할인 금액 계산’은 상품, 쿠폰, 회원 등급, 구매 금액 등 다양한 조건을 이용해서 구현하게 되는데 이렇게 도메인 로직이 여러 엔티티와 밸류를 필요로 하면 도메인 서비스에 로직을 구현

2.4.1 엔티티와 밸류

엔티티와 도메인 모델의 가장 큰 차이점은 도메인 모델의 엔티티는 데이터와 함께 도메인 기능을 함께 제공한다는 점
- 주문을 표현하는 엔티티는 주문과 관련된 데이터뿐만 아니라 배송지 주소 변경을 위한 기능을 함께 제공
```
public class Order {
	private OrderNo number;
	private Orderer orderer;
	private ShippingInfo shippingInfo;
	
	// 도메인 모델 엔티티는 도메인 기능도 함께 제공
	public void shangeShippingInfo(ShippingInfo newShippingInfo) {
		...	
	}
}
```
도메인 모델의 엔티티는 단순히 데이터를 담고 있는 데이터 구조라기보다는 데이터와 함께 기능을 제공하는 객체
도메인 관점에서 기능을 구현하고 기능 구현을 캡슐화해서 데이터가 임의로 변경되는 것을 막는다.
도메인 모델의 엔티티는 두 개 이상의 데이터가 개념적으로 하나인 경우 밸류 타입을 이용해서 표현할 수 있다
- Orderer는 밸류 타입으로 주문자 이름과 이메일 데이터를 포함할 수 있다.
```
public class Orderer {
	private String name;
	private String email;
}
```
RDBMS와 같은 관계형 데이터베이스는 밸류 타입을 재대로 표현하기 힘들다.
- Ordere의 개별 데이터를 저장하거나 밸로 테이블로 분리해서 저장해야 한다.
- 한 테이블에 주문자 정보 함께 넣기
  - 주문자라는 개념이 들어나지 않고 주문자의 개별 데이터만 드러난다.
- 다른 테이블에 주문자 정보 넣기
  - 주문자 데이터를 별도 테이블에 저장했지만 이것은 테이블의 엔티티에 가까우며 밸류 타입의 의미가 드러나지 않는다.

밸류는 불변으로 구현할 것을 권장

엔티티의 밸류 타입 데이터를 변경할 떄는 객체 자체를 완전히 교체한다는 것을 의미

public class Order {
	private ShippingInfo shippingInfo;
	
	public void shangeShippingInfo(ShippingInfo newShippingInfo) {
		checkShippingInfoChangeable();
		setShippingInfo(newShippingInfo);
	}

	private void setShippingInfo(ShippingInfo newShippingInfo) {
		if (newShippingInfo == null) {
			throw new IllegalArgumentException();
		}
		this.shippingInfo = newShippingInfo;
	}
}

2.4.2 애그리거트

도메인이 커질수록 개발할 도메인 모델도 커지면서 많은 엔티티와 밸류가 출현한다.
도메인 모델이 복잡해지면 개발자가 전체 구조가 아닌 한 개 엔티티와 밸류에만 집중하는 상황이 발생한다.
- 상위 수준에서 모델을 관리하지 않고 개별 요소에만 초점을 맞추다 보면, 큰 수준에서 모델을 이해하지 못해 큰 틀에서 모델은 관리할 수 없는 상황에 빠질 수 있다.
도메인 모델에 전체 구조를 이해하는데 도움이 되는 것이 바로 애그리거트(AGGREGATE)이다.
애그리거트는 관련 객체를 하나로 묶은 군집이다.
- 모메인 개념은“주문”, “배송지 정보”, “주문자”, “주문 목록”, “총 결제 금액”의 하위 모델로 구성된다.
- 하위 내념을 표현한 모델을 하나로 묶어서 “주문”이라는 상위 개념으로 표현할 수 있다.
애그리거트를 사용하면 개별 객체가 아닌 관련 객체를 묶어서 객체 군집 단위로 모델을 바라볼 수 있게 된다.
- 개별 객체 간의 관계가 아닌 애그리거트 간의 관계로 도메인 모델을 이해하고 구현하고, 큰 틀에서 도메인 모델을 관리할 수 있다.
애그리거트는 군집에 속한 객체를 관리하는 루트 엔티티를 갖는다.
- 루트 엔티티는 애그리거트에 속해 있는 엔티티와 밸류 객체를 이용해서 애그리거트가 구현해야 할 기능을 제공
- 애그리거트를 사용하는 코드는 애그리거트 루트가 제공하는 기능을 실행
- 애그리거트 루트를 통해 간접적으로 애그리거트 내의 다른 엔티티나 밸류 객체에 접근
- 애그리거트의 내부 구현을 숨겨서 애그리거트 단위로 구현을 캡슐화할 수 있도록 돕는다.
주문 애그리거트
- 애그리거트 루트인 Order는 주문 도메인 로직에 맞게 애그리거트의 상태를 관리
- Order의 배송지 정보 변경 기능은 배송지를 변경할 수 있는지를 확인한 위에 배송지 정보를 변경
- 주문 애그리거트는 Order를 통하지 않고 ShippingInfo를 변경할 수 있는 방법을 제공하지 않는다.
  - 배송지를 변경하려면 루트 엔티티인 Order를 사용해야 하므로 배소지 정보를 변경할 때는 Order가 구현한 도메인 로직을 항상 따르게 된다.
애그리거트를 구현할 때는 고려할 것이 많다.
- 애그리거트를 어떻게 구성했느냐에 따라 구현이 복잡해지기도 하고
- 트랜잭션 범위가 달라지기도 한다.

2.4.3 리포지터리

도메인 객체를 지속적으로 사용하려면 RDBMS, NoSQL, 로컬 파일과 같은 물리적인 저장소에 도메인 객체를 보관해야 한다.
- 이를 위한 도메인 모델이 리포지터리(Repository)이다.
엔티티나 밸류가 요구사항에 도출되는 도메인 모델이라면 리포리터리는 구현을 위한 도메인 모델이다.
리포지터리는 애그리거트 단위로 도메인 객체를 저장하고 조회하는 기능을 정의
- OrderRepository의 메서드를 보면 대상을 찾고 저장하는 단위가 애그리거트 루트인 Order인 것을 알 수 있다.
- Order는 애그리거트에 속한 모든 객체를 포함하고 있으므로 결과적으로 애그리거트 단위로 저장하고 조회한다.
```
public interface OrderRepository {
	Order findByNumber(OrderNumber number);
	void save(Order order);
	void delete(Order order);
}
```
도메인 모델을 사용해야 하는 코드는 리포지터리를 통해서 도메인 객체를 구한 뒤에 도메인 객체의 기능을 실행
public class CancelOrderService { private OrderRepository orderRepository; public void cancel(OrderNumber number) { Order order = orderRepository.findByNumber(number); if (order == null) { throw new OrderNotFoundException(orderId); } order.cancel(); } }
도메인 모델 관점에서 OrderRepository는 도메인 객체를 영속화하는 데 필요한 기능을 추상화 한것으로 고수준 모듈에 속한다.
기반 기술을 이용해서 OrderRepository를 구현한 클래스는 저수준 모듈로 인프라스트럭처 영역에 속한다.
전체 모듈 구조
응용 서비스는 의존 주입과 같은 방식을 사용해서 실제 리포지터리 구현 객체에 접근
응용 서비스와 리포지터리는 밀접한 연관이 있다.
- 응용 서비스는 필요한 도메인 객체를 구하거나 저장할 때 리포지터리를 사용한다.
- 응용 서비스는 트랜잭션을 관리하는데, 트랜잭션 처리는 리포지터리 구현 기술의 영향을 받는다.
리포지터리를 사용하는 주체가 응용 서비스이기 때문에 리포지터리는 응용 서비스가 필요로 하는 메서드를 제공한다.
- 애그리거트를 저장하는 메서드
- 애그리거트 루트 식별자로 애그리거트를 조회하는 메서드

2.5 요청 처리 흐름

표현 영역은 사용자가 전송한 데이터 형식이 올바른지 검사하고 문제가 없다면 데이터를 이용해서 응용 서비스에 기능 실행을 위임
표현 영역은 사용자가 전송한 데이터를 응용 서비스가 요구하는 형식으로 변환해서 전달
요청 처리 흐름
- 웹 브라우저에서 기능 실행 요청
- 표현 영역에 해당하는 컨트롤러는 HTTP 요청 파라미터를 응용 서비스가 필요로 하는 데이터로 변환 해서 응용 서비스의 인자로 전달
- 응용 서비스는 도메인 모델을 이용해서 로직 실행
- 도메인 객체를 리포지터리에서 가져와 실행하거나 신규 도메인 객체를 생성해 리포지터리에 저장
“예매하기”나 “예매 취소”와 같은 기능을 제공하는 응용 서비스는 도메인의 상태를 변경하므로 변경 상태가 물리 저장소에 올바르게 반영되도록 트랜잭션을 관리 해야한다.
- 스프링 프레임워크를 사용한다면 @Transactional 애너테이션을 이용해 트랜잭션을 처리할 수 있다.
```
public class CancelOrderService {
	private OrderRepository orderRepository;
	
	@Transactional
	public void cancel(OrderNumber number) {
		Order order = orderRepository.findByNumber(number);
		if (order == null) {
			throw new NoOrderException(number);
		}
		order.cancel()
	}
}
```

2.6 인프라스트럭처 개요

인프라스트럭처는 표현 영역, 응용 영역, 도메인 영역을 지원한다.
도메인 영역과 응용 영역에서 인프라스트럭처의 기능을 직접 사용하는 것보다 두 영역에서 정의한 인터페이스를 인프라스트럭처 영역에서 구현하는 것이 시스템을 더 유연하고 테스트하기 쉽게 만들어 준다.
무조건 인프라스트럭처에 대한 의존성을 없앨 필요는 없다.
- 스프링을 사용할 경우 응용 서비스는 트랜잭션 처리를 위해 @Transactional을 사용하는 것이 편리하다.
- 영속성 처리를 위해 JPA를 사용할 경우 @Entity나 @Table과 같은 JPA 전용 애너테이션을 도메인 모델 클래스에서 사용하는 것이 XML 매핑 설정을 이용하는 것보다 편리하다.
구현의 편리함은 DIP가 주는 다른 장점만큼 중요하기 때문에 DIP의 장점을 해치지 않는 범위에서 응용 영역과 도메인 영역에서 구현 기술에 대한 의존을 가져가는 것이 나쁘지 않다고 생각한다.
응용 영역과 도메인 영역이 인프라스트럭처에 대한 의존을 완전히 갖지 않도록 시도하는 것은 구현을 더 복잡하고 어렵게 만들 수 있다.
- @Transactional을 사용하면 한 줄로 트랙잭션을 처리할 수 있는데 코드에서 스프링에 대한 의존을 없애려면 복잡한 스프링 설정을 사용해야 한다.
- 의존은 없앴지만 특별히 테스트를 더 쉽게 할 수 있다거나 유연함을 증가시켜 주지 못한다.
- 설정만 복잡해지고 개발 시간만 늘어난다.
표현 영역은 항상 인프라스트럭처 영역과 쌍을 이룬다.
- 스프링 MVC를 사용해서 웹 요청을 처리하려면 스프링이 제공하는 MVC 프레임워크에 맞게 표현 영역을 구현
- Vert.x를 사용해서 Rest API 서버를 구축하려면 Vert.x에 맞게 웹 요청 처리 부분을 구현

2.7 모듈 구성

아키텍처의 각 영역은 별도 패키지에 위치한다.
패키지 구성 규칙에 정답이 존재하는 것은 안지만 영역별로 모듈이 위치할 패키지를 구성할 수 있을 것 이다.
도메인이 크면 하위 도메인으로 나누고 하위 도메인마다 별도 패키지를 구성한다.
도메인 모듈은 도메인에 속한 애그리거트를 기준으로 다시 패키지를 구성한다.
- 카탈로그 하위 도메인이 상품 애그리거트와 카테고리 애그리커트로 구성될 경우 도메인을 두 개의 하위 패키지로 구성할 수 있다.
애그리거트, 모델, 리포지터리는 같은 패키지에 위치시킨다.
- Order, OrderLine, Orderer, OrderRepository 등은 com.myshop.order.domain 패키지에 위치시킨다.
도메인이 복잡하면 도메인 모델과 도메인 서비스를 별도 패키지에 위치시킬 수도 있다.
- com.myshop.order.domain.order: 애그리거트 위치
- com.myshop.order.domain.service: 도메인 서비스 위치
응용 서비스도 도메인 별로 패키지를 구분할 수 있다.
- com.myshop.catalog.application.product
- com.myshop.catalog.application.category
모듈 구조를 얼마나 세분하게해야 하는지에 대한 정해진 규칙은 없다.
한 패키지에 너무 많은 타입이 몰려서 코드를 찾을 때 불편할 정도만 아니면 된다.

728x90

저작자표시 비영리 변경금지

'도메인 주도 개발 스터디' 카테고리의 다른 글

Chapter 7 도메인 서비스 (0)	2023.11.08
Chapter 6 응용 서비스와 표현 영역 (0)	2023.11.08
Chapter 5 스프링 데이터 JPA를 이용한 조회 기능 (0)	2023.11.08
Chapter 4 리포지터리와 모델 구현 (1)	2023.11.08
Chapter 1 도메인 모델 시작하기 (0)	2023.11.08

현재글Chapter 2 아키텍처 개요

250x250

개발 스터디

엘라스틱서치, 검색엔진 스터디, 검색엔진, 엘라스틱서치 실무 가이드,

Today :
Yesterday :

일	월	화	수	목	금	토
1	2	3	4	5	6	7
8	9	10	11	12	13	14
15	16	17	18	19	20	21
22	23	24	25	26	27	28
29	30