[도메인주도개발시작하기] Chapter2-아키텍처 개요

네 개의 영역

표현 영역

• 표현 영역(UI영역)은 사용자의 요청을 받아 응용 영역에 전달하고 응용 영역의 처리 결과를 다시 사용자에게 보여주는 역할을 한다.
  • 표현 영역의 사용자는 웹 브라우저를 사용하는 사람일 수 도 있고, REST API 를 호출하는 외부 시스템일 수도 있다.
• 표현 영역을 통해 사용자의 요청을 전달받는 응용 영역은 시스템이 사용자에게 제공해야 할 기능을 제공한다.
  • 예를 들어, ‘주문 등록’, ‘주문 취소’, ‘상품 상세조회’ 와 같은 기능을 구현한다.

응용 영역

• 응용 영역은 기능을 구현하기 위해 도메인 영역의 도메인 도메인 모델을 사용한다.
• 응용 서비스는 로직을 직접 수행하기보단 도메인 모델에 로직 수행을 위임한다. 마치 아래 예제 코드처럼 Order 도메인 모델에 취소 처리를 위임하는 것처럼.

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15

@Service
public class CancelOrderService {
    ...

    @Transactional
    public void cancel(String orderId) {
        Order order = findOrderById(orderId);
        if (order == null) {
            throw new OrderNotFoundException(orderId);
        }
        order.cancel();
    }

	...
}

도메인 영역

• 도메인 영역은 도메인 모델을 구현한다.
  • 도메인 모델은 도메인의 핵심 로직을 구현한다. (ex. 주문 도메인의 배송지 변경, 결제 완료, 주문 총액 계산과 같은)

인프라스트럭처 영역

• 구현 기술에 대한 것을 다룬다.
• 예를 들어, RDBMS, MessageQueue, 몽고 DB, HBase 와의 연동을 처리한다.
• 추가적으로 SMTP를 이용한 메일 발송 기능을 구현하거나 HTTP 클라이언트를 이용해서 REST API 를 호출하는 것도 처리한다.

도메인, 응용, 표현 영역은 실제 구현 기술을 사용한 코드를 직접 만들지 않는다. 대신 인프라스트럭처 영역에서 제공하는 기능을 ㅅ용해서 필요한 기능을 개발한다. 예를 들어, 응용 영역에서 DB에 보관된 데이터가 필요하면 인프라스트럭처 영역의 DB 모듈을 사용해서 데이터를 읽어온다. 비슷하게 외부에 메일을 발송하려면 인프라스트럭처가 제공하는 SMTP 연동 모듈을 이용해 메일을 발송한다.

계층 구조 아키텍처

• 네 영역을 구성할 때 많이 사용하는 아키텍처가 [그림2.4]와 같은 계층 구조이다.
  • 도메인의 복잡도에 따라 응용과 도메인을 분리하기도 하고 합치기도 한다.

• 계층 구조는 단방향(하위 계층)으로만 의존하게 한다.
• 계층 구조를 엄격하게 적용하면 상위 계층은 바로 아래 계층에만 의존을 가져야 하지만, 구현의 편리함을 위해 계층 구조를 유옇나게 적용한다.
  • 예를 들어, 응용 계층에서 외부 시스템과의 연동을 위해 더 아래 계층인 인프라 계층에 의존하기도 한다.
• 계층 구조에 따르면 도메인과 응용 계층은 룰 엔진과 DB 연동을 위해 아래 이밎와 같이 인프라 모듈에 의존하게 된다.

• 여기서 짚고 넘어가야 할 것은 표현, 응용, 도메인 계층이 상세한 구현 기술을 다루는 인프라 계층에 종속된다는 점이다.
• 이때 문제가 생길 수 있는 부분이 있다.
• 도메인의 가격 계산 규칙을 정할 때 할인 금액 계산 로직이 복잡해지면 객체 지향으로 로직을 구현하는 것 보단 룰 엔진을 사용하는 것이 더 알맞을 때가 있다.
• Drools라는 룰 엔진을 사용해서 로직을 수행할 수 있는 인프라 스트럭처 코드이다. (Drools는 무시해도 된다.)
• 핵심은 evalute() 메서드에 값을 주면 별도 파일로 작성한 규칙을 이용해서 연산을 수행하는 코드라는 것 정도로만 이해하면 된다.

1
2
3
4
5
6
7

// 인프라스트럭처 영역
public class DroolsRuleEngine {
 ...
 public void evalute(String sessionName, List<?> facts) {
  ...
 }
}

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

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20

// 응용 영역
public class CalculateDiscountService {
 
 private DroolsRuleEngine ruleEngine;

 public CalculateDiscountService() {
	ruleEngine = new DroolsRuleEngine();
 }

 public Money calculateDiscount(OrderLine orderLines, String customerId) {
  Customer customer = findCusotmer(customerId);

  MutableMoney money = new MutableMoney(0);
  List<?> facts = Arrays.asList(customer, money);
  facts.addAll(orderLines);
  ruleEngine.evalute("discountCalculation", facts);
  return money.toImmutableMoney();
 }
 ...
}

• 위 응용 영역에 위치한 서비스 코드는 두 가지 문제가 존재한다.
  • 1)CalculateDiscountService 만 테스트하기 어렵다. RuleEnigne이 완벽하게 동작해야만 하며 이에 대한 설정 파일도 필요하게 된다.
  • 2)구현 방식을 변경하기 어렵다는 점이다. discountCalculation 문자열은 Drools의 세션 이름이다. Drools의 세션 이름을 변경시 CalculateDiscountService의 코드도 같이 변경되어야한다.
• 이처럼 인프라스트럭처 계층에 의존하면 테스트의 어려움과 기능 확장의 어려움 이라는 두 가지 문제가 생긴다. 이를 해결하기 위해 SOLID 원칙 중 하나인 DIP 를 적용하면 된다.

DIP

• 가격 할인 계산을 하려면 아래 이미지의 왼쪽과 같이 고객 정보를 구해야 하고, 구현할 고객 정보와 주문 정보를 이용해서 룰을 실행해야 한다.

• 위 이미지에서 CalculateDicountService 는 고수준 모듈이다.
• 고수준 모듈이란 의미 있는 단일 기능을 제공하는 모듈이다.
• CalculateDicountService는 ‘가격 할인 계산’ 이라는 기능을 구현한다.
• 고수준 모듈의 기능을 구현하려면 여러 하위 기능이 필요하다.
• 가격 할인 계산 기능을 구현하려면 고객 정보를 구해야 하고 룰을 실힝해야 하는데 이 두 기능이 하위 기능이다.
• 저수준 모듈은 하위 기능을 실제로 구현한 것이다.

• [그림 2.7] 에서 JPA를 이용해서 고객 정보를 읽어오는 모듈과 Drools로 룰을 실행하는 모듈이 저수준 모듈이다.

• 고수준 모듈이 제대로 동작하려면 저수준 모듈을 사용해야 한다. 그런데, 고수준 모듈이 저수준 모듈을 사용하면 앞서 계층 구조 아키텍처에서 언급했던 두 가지 문제(구현 변경과 테스트가 어려움)가 발생한다.
• DIP 는 이 문제를 해결하기 위해 저수준 모듈이 고수준 모듈에 의존하도록 바꾼다.
  • 이렇게 하기 위해서 추상화한 인터페이스가 필요하게 된다.
• CalculateDiscountService 입장에서 봤을 땐 룰 적용을 Drools 로 구현했는지, 자바로 직접 구현했는지 중요치 않다.
  • 단지, ‘고객 정보와 구매 정보에 룰을 적용해서 할인 금액을 구한다’ 는 것이 중요할 뿐이다.
• 이를 추상화한 인터페이스는 다음과 같다.

1
2
3

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

이제 CalCulateDiscountService 가 RuleDiscounter 를 이용하도록 바꿔보자.

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21

public class CalculateDiscountService {
 private RuleDiscounter ruleDiscounter;
 private CustomerRepository customerRepository;

 public CalculateDiscountService(RuleDiscounter ruleDiscounter, CustomerRepository customerRepository) {
  this.ruleDiscounter = ruleDiscounter;
  this.customerRepository = customerRepository
 }

 public Money calculateDiscount(OrderLine orderLines, String customerId) {
  Customer customer = customerRepository.findCusotmer(customerId);
  return ruleDiscounter.applyRules(customer, orderLines);
 }

 private Customer findCustomer(String customerId) {
  Customer customer = customerRepository.findById(customerId);
  if (customer == null) throw new NoCustomerException();
  return customer;
 }
 ...
}

• CalculateDiscountService 는 Drools 에 의존하는 코드를 포함하고 있지 않다.
  • 단지 RuleDiscounter가 룰을 적용한다는 것만 알 뿐이다.
• 룰 적용을 구현한 클래스는 RuleDiscounter 인터페이스를 상속받아 구현하다.

1
2
3
4
5
6
7
8
9

public class DroolsRuleDiscounter implements RuleDiscounter {
  ...

  @Override
  public Money applyRule(Customer customer, List<OrderLine> orderLines) {
    // 실제 구현 코드 생략
    return money;
  }
}

• 아래 이미지는 RuleDiscounter가 출현하면서 바뀐 구조를 보여주고 있다.

• 위 이미지 [그림 2.8]의 구조를 보면 CalculateDiscountService는 더 이상 구현 기술인 Drools에 의존하지 않는다.
• ‘룰을 이용한 할인 금액 계산’을 추상화한 RuleDiscounter 인터페이스에 의존할 뿐이다.
• ‘룰을 이용한 할인 금액 계산’은 고수준 모듈의 개념이므로 RuleDiscounter 인터페이스는 고수준 모듈에 속한다.
• DroolsRuleDiscounter는 고수준의 하위 기능인 RuleDiscounter를 구현한 것이므로 저수준 모듈에 속한다.

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

1) 구현체 교체의 어려움 해결

• 고수준 모듈은 더 이상 저수준 모듈에 의존하지 않고 구현을 추상화한 인터페이스에 의존한다.
• 실제 사용할 저수준 구현 객체는 아래 코드처럼 의존 주입을 이용해 전달받을 수 있다.

1
2
3
4
5

// 사용할 저수준 객체 생성
RuleDiscounter ruleDiscounter = new DroolsRuleDiscounter();

// 생성자 방식으로 주입
CalculateDiscountService calculateDiscountService = new CalculateDiscountService(ruleDiscounter);

• 만약 구현 기술을 변경하더라도 CalculateDicountService를 수정할 필요가 없다.
• 아래 코드처럼 사용할 저수준 구현 객체를 생성하는 부분의 코드만 변경하면 되기 때문이다.

1
2
3
4
5

// 사용할 저수준 구현 객체 변경
RuleDiscounter ruleDiscounter = new SimpleRuleDiscounter();

// 사용할 저수준 모듈을 변경해도 고수준 모듈을 수정할 필요가 없다.
CalculateDiscountService calculateDiscountService = new CalculateDiscountService(ruleDiscounter);

• 의존 주입을 지원하는 스프링과 같은 프레임워크를 사용하면 설정 코드를 수정해서 쉽게 구현체를 변경할 수 있다.

1) 테스트 어려움 해결

• CalculateDiscountService가 제대로 동작하는지 테스트하려면 CustomerRepository와 RuleDiscounter를 구현한 객체가 필요하다.
• 하지만 둘 다 인터페이스로 추상화 했기 때문에 대용 객체를 사용해서 테스트를 진행할 수 있다.
• 다음은 대용 객체를 사용해서 Customer가 존재하지 않는 경우 익셉션이 발생하는지 검증하는 테스트 코드인데, 실제 구현 클래스 없이 테스트 가능함을 보여준다.

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15

public class CalculateDiscountServiceTest {

  @Test(expected = NoCustomerException.class);
  public void noCustomer_thenExceptionShouldBeThrown() {
    // 테스트 목적의 대용 객체
    CustomerRepository stubRepo = mock(CustomerRepository.class);
    when(stubRepo.findById("noCustId")).thenReturn(null);

    RuleDiscounter stubRule = (cust, lines) -> null;

    // 대용 객체를 주입받아 테스트 진행
    CalculateDiscountService calcDisSvc = new CalculateDiscountService(stubRepo, stubRule);
    calcDisSvc.calculateDiscount(someLines, "noCustId");
  }
}

• 이렇게 실제 구현 없이 테스트 할 수 있는 이유는 DIP를 적용해서 고수준 모듈이이 저수준 모듈에 의존하지 않도록 했기 때문이다.
  • 고수준 모듈인 CalculateDiscountService는 저수준 모듈에 직접 의존하지 않기 때문에 실제 저수준 구현 클래스 없이도 테스트 대용 객체를 이용해서 거의 모든 기능을 테스트할 수 있는 것이다.

DIP 주의사항

• DIP의 핵심은 고수준 모듈이 저수준 모듈에 의존하지 않도록 하기 위함이다.
• 하지만 아래 이미지와 같이 저수준 모듈에서 인터페이스를 추출하는 경우가 있다.

• 위 이미지는 잘못된 구조이다.
• 이 구조에서 도메인 영역은 이프라 스트러거 영역에 의존하고 있다.
  • 즉, 여전히 고수준 모듈이 저수준 모듈에 의존하고 있는 것이다.
• RuleEngine 인터페이스는 고수준 모듈인 도메인 관점이 아니라 룰 엔진이라는 저수준 모듈 관점에서 도출한 것이다.
• DIP를 적용할 때 하위 기능을 추상화한 인터페이스는 고수준 모듈 관점(도메인 영역)에서 도출한다.
  • CalculateDiscountService 입장에서 봤을 때 할인 금액을 구하기 위해 룰 엔진을 사용하는지, 직접 연산하는지 여부는 중요치 않다.
  • 단지 규칙에 따라 할인 금액을 계산한다는 것이 중요할 뿐이다.
  • 즉, ‘할인 금액 계산’을 추상화한 인터페이스는 저수준 모듈이 아닌 고수준 모듈에 위치한다.(아래 이미지 참고)

DIP와 아키텍처

• 인프라스트럭처 영역은 구현 기술을 다루는 저수준 모듈이고 응용 영여과 도메인 영역은 고수준 모듈이다.
• 인프라스트럭처 계층의 가장 하단에 위치하는 계층형 구조와 달리 아키텍처에 DIP를 적용하면 [그림 2.12]와 같이 인프라스트럭처 영역이 응용 영역과 도메인 영역에 의존(상속)하는 구조가 된다.

• 인프라스트럭처에 위치한 클래스가 도메인이나 응용 영역에 정의한 인터페이스를 상속받아 구현하는 구조가 되므로 도메인과 응용 영역에 대한 영향을 주지 않거나 최소화하면서 구현 기술을 변경하는 것이 가능하다.

• 위 이미지에서 인프라스트럭처 영역의 EmailNotifier 클래스는 응용 영역의 Notifier 인터페이스를 상속 받고 있다.
  • 주문 시 통지 방식에 SMS를 추가해야 한다는 요구사항이 들어왔을땐 응용 영역의 OrderService를 변경할 필요가 없다.
  • [그림 2.14]와 같이 두 통지 방식을 함께 제공하는 Notifier 구현 클래스를 인프라 스트럭처 영역에 추가하면 된다.
  • 비슷하게 MyBatis 대신 JPA를 구현 기술로 사용하고 싶다면 JPA를 이용한 OrderRepository 구현 클래스를 인프라스트럭처 영역에 추가하면 된다.

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

• 엔티티:
  • 고유의 식별자를 갖는 객체로 자신의 라이프 사이클을 가진다.
  • 주문(Order), 회원(Member), 상품(Product)과 같이 도메인의 고유한 개념을 표현한다.
  • 도메인 모델의 데이터를 포함하며 해당 데이터와 관련된 기능을 함께 제공한다.
• 밸류:
  • 고유의 식별자를 갖지 않는 개체로 주로 개념적으로 하나인 도메인 객체의 속성을 표현할 때 사용된다.
  • 주소(Address), 금액(Money)와 같은 타입이 밸류 타입이다.
  • 엔티티의 속성으로 사용될 뿐 아니라 다른 밸류 타입의 속성으로도 사용될 수 있다.
• 애그리거트(Aggregate):
  • 관련된 엔티티와 밸류 객체를 개념적으로 하나로 묶은 것이다.
  • 예를 들어, 주문과 관련된 Order 엔티티, OrderLine 밸류, Orderer 밸류 객체를 ‘주문’ 애그리거트로 묶을 수 있다.
• 리포지토리(Repository):
  • 도메인 모델의 영속성을 처리한다.
• 도메인 서비스(Domain Service):
  • 특정 엥ㄴ티티에 속하지 않은 도메인 로직을 제공한다.
  • ‘할인 금액 계산’은 상품, 쿠폰, 회원 등급, 구매 금액 등 다양한 조건을 이용해서 구현하게 되는데, 이렇게 도메인 로직이 여러 엔티티와 밸류를 필요로 할 경우 도메인 서비스에서 로직을 구현한다.

엔티티와 밸류

• 실제 도메인 모델의 엔티티와 DB 관계형 모델의 엔티티는 같은 것이라 볼 수 없다.
• 위 두 모델의 가장 큰 차이점은 도메인 모델의 엔티티는 데이터와 도메인 기능을 함께 제공한다는 점이다.

1
2
3
4
5
6
7
8
9
10
11

public class Order {
  // 주문 도메인 모델의 데이터
  private OrderNo number;
  private Orderer orderer;
  private ShippingInfo shippingInfo;

  // 도메인 모델 엔티티는 모데인 기능도 함께 제공
  public void changeShippingInfo(ShippingInfo newShippingInfo) {
    ...
  }
}

• 또 다른 차이점은 모데인 모델의 엔티티는 두 개 이상의 데이터가 개념적으로 하나인 경우 밸류 타입을 이용해서 표현할 수 있다는 것ㅇ이다.
• 위 코드에서 주문자를 푠현하는 Orderer 는 밸류 타입으로 다음과 같이 주문자이름과 이메일 데이터를 포함할 수 있다.

1
2
3
4
5

public class Orderer {
  private String name;
  private String email;
  ...
}

• 이를 DB 테이블로 표현하려면 아래 이미지와 같이 두 가지 방식을 적용할 수 있다.

• 왼쪽 테이블의 경우 주문자(Orderer)라는 개념이 드러나지 않고 주문자의 개별 데이터만 드러난다.
• 오른쪽 테이블의 경우 주문자 데이터를 별도 테이블에 저장했찌만 이는 테이블의 엔티티에 가깝지 밸류 타입의 의미가 드러나진 않는다.
• 반면 도메인 모델의 Orderer 는 주문자라는 개념을 잘 반영하므로 도메인을 보다 잘 이해할 수 있도록 돕는다.
• 그리고 앞서 설명했던 것처럼 밸류는 불변으로 구현하는 것을 권장한다.
  • 이는 엔티티의 밸류 타입 데이터를 변경시 객체 자체를 완전히 새로 교체한다는 것을 의미한다.

애그리거트

애그리거트의 필요성

• 도메인이 커질수록 개발할 도메인 모델도 커지면서 많은 엔티티와 밸류가 출현한다.
• 엔티티와 밸류 개수가 많아지면 많아질수록 모델은 점점 더 복잡해진다.
• 도메인 모델이 복잡해지면 개발자가 전체 구조가 아닌 한 개 엔티티와 밸류에만 집중하게 되는 경우가 발생한다.
• 이떄 상위 수준에서 모델을 관리하기보다 개별 요소에만 초점을 맞추다 보면 큰 수준에서 모델을 이해하지 못해 큰 틀에서 모델을 관리할 수 없는 상항에 빠질 수 있다.
• 도메인 모델도 개별 객체뿐만 아니라 상위 수준에서 모델을 볼 수 있어야 전체 모델의 관계와 개별 모델을 이해하는데 도움이 된다.
• 도메인 모델에서 전체 구조를 이해하는데 도움이 되는 것이 바로 애그리거트(Aggregate) 이다.

애그리거트의 정의

• 애그리거트는 관련 객체를 하나로 묶은 군집이다.
• 대표적인 예가 주문이다.
  • 주문이라는 도메인 개념은 ‘주문’, ‘배송지 정보’, ‘주문자’, ‘주문목록’, ‘총결제 금액’ 의 하위 모델로 구성되는데 이때 이 하위 개념을 표현한 모델을 하나로 묶어서 ‘주문’이라는 상위 개념으로 표현할 수 있다.

• 애그리거트를 사용하면 개별 객체가 아닌 관련 객체를 묶어서 객체 군집 단위로 모델을 바라볼 수 있게 된다.

• 개별 객체 간의 관계가 아닌 애그리거트 간의 관계로 도메인 모델을 이해하고 구현할 수 있게 되며, 이를 통해 큰 틀에서 도메인 모델을 관리할 수 있게 된다.

• 애그리거트는 군집에 속한 객체들을 관리하는 루트 엔티티를 갖는다.
• 루트 엔티티는 애그리거트에 속해 있는 엔티티와 밸류 객체를 이용해서 애그리거트가 구현해야 할 기능을 제공한다.
• 애그리거트를 사용하는 코드는 애그리거트 루트가 제공하는 기능을 실행하고 애그리거트 루트를 통해서 간접적으로 애그리거트 내의 다른 엔티티나 밸류 객체에 접근하게 된다.
• 이는 애그리거트의 내부 구현을 숨겨서 애그리거트 단위로 구현을 캡슐화할 수 있도록 돕는다.

• 위 이미지는 주문 애그리거트를 보여주고 있다.
• 애그리거트 루트인 Order는 주문 도메인 로직에 맞게 애그리거트의 상태를 관리한다.
• 예를 들어, Order의 배송지 정보 변경 기능은 배송지를 변경할 수 있는지 확인한 뒤에 배송지 정보를 변경한다.

1
2
3
4
5
6
7
8
9
10
11

public class Order {
 ...
 public void changeShippingInfo(ShippingInfo shippinginfo) {
  checkShippingInfoChangeable(); // 배송지 변경 가능 여부 확인
  this.shippingInfo = newInfo;
 }

 private Boolean checkShippingInfoChangeable() {
  ... 배송지 정보를 변경할 수 있는지 여부를 확인하는 도메인 규칙 구현
 }
}

• checkShippingInfoChangeable() 메서드는 도메인 규칙에 따라 배송지를 변경할 수 있는지 확인할 것이다.
  • 예를 들어, 이미 배송이 시작된 경우 익셉션을 발생하는 식으로 도메인 규칙을 구현할 것이다.
• 주문 애그리거트는 Order 를 통하지 않고 ShippingInfo를 변경할 수 있는 방법을 제공하지 않는다.
  • 즉, 배송지를 변경하려면 루트 엔티티인 Order 를 사용해야 하므로 배송지 정보를 변경시엔 Order 가 구현한 로직을 항상 따르게 된다.
• 애그리거트를 구현할 떈 고려할 것이 많다.
  • 애그리거트를 어떻게 구성했느냐에 따라 구현이 복잡해지기도 하고 트랜잭션 범위가 달라지기도 한다.
  • 또한 선택한 구현 기술에 따라 애그리거트 구현에 제약이 생기기도 한다.
  • 애그리거트의 구현에 대한 내용은 3장에서 자세히 다룬다.

리포지터리

• 도메인 객체를 지속적으로 사용하기 위해서는 RDBMS, NoSQL, 로컬 파일과 같은 물리적인 저장소에 도메인 객체를 보관해야한다.
• 이를 위한 도메인 리포지터리이다.
• 리포지터리는 애그리게이트 단위로 도메인 객체를 저장하고 조회하는 기능을 정의한다.

1
2
3
4
5

public interface OrderRepository {
  public Order findByNumber(OrderNumber number);
  public void save(Order order);
  public void delete(Order order);
}

• 도메인 모델을 사용해야 하는 코드(주로 응용 서비스 영역의 코드일 것이다) 는 리포지토리를 통해 도메인 객체를 구한 뒤 도메인 객체의 기능을 실행하게 된다.

1
2
3
4
5
6
7
8
9

public class CancelOrderService {
  private OrderRepository orderRepository; // DI

  public void cancel(OrderNumber number) {
    Order order = orderRepository.findByNumber(number);
    if (order == null) throw new NoOrderException(number);
    order.cancel();
  }
}

• 도메인 모델 관점에서 OrderRepository 는 도메인 객체를 영속화하는데 필요한 기능을 추상화한 것으로 고수준 모델에 속한다.
• 기반 기술을 이용해 OrderRepository를 구현한 클래스는 저수준 모듈로 인프라스트럭처 영역에 속한다.
• 즉, 모듈 구조는 아래 이미지와 같을 것이다.

요청 처리 흐름

• 표현 영역은 사용자가 전송한 데이터 형식을 올바른지 검사하고 문제가 없다면 데이터를 이용해서 으용 서비스에 기능 실행을 위임한다.
• 이떄 표현 영역은 사용자가 전송한 데이터를 응용 서비스가 요구하는 형식으로 변환해서 전달한다.
  • RQ 모델을 그대로 응용 서비스에 전달하는게 아닌 validation 체크 후 도메인 모델로 컨버팅해서 전달하는 방식이 될 것이다.
• 웹 브라우저를 이용해서 기능 실행을 요청할 경우, 아래 이미지처럼 표현 영역에 해당하는 컨트롤러는 과정1.1처럼 HTTP 요청 파라미터를 응용 서비스가 필요로 하는 데이터로 변환 후 응용 서비스를 실행할 떄 파라미터로 전달한다.

• 응용 서비스는 도메인 모델을 이용해 기능을 구현한다.
• 기능 구현에 필요한 도메인 객체를 리포지토리에서 가져와 실행하거나 신규 도메인 객체를 생성해서 리포지터리에 쩌장한다.
  • 두 개 이상의 도메인 객체를 사용해서 구현하기도 한다.
• 응용 서비스의 역할 중 하나는 아래 코드와 같이 트랜잭션을 관리하는 것이다.

1
2
3
4
5
6
7
8
9
10

public class CancelOrderService {
  private OrderRepository orderRepository; // DI

  @Transactional // 응용 서비스는 트랜잭션을 관리한다.
  public void cancel(OrderNumber number) {
    Order order = orderRepository.findByNumber(number);
    if (order == null) throw new NoOrderException(number);
    order.cancel();
  }
}

인프라스트럭처 개요

• 인프라스트럭처는 표현 영역, 응용 영역, 도메인 영역을 지원한다.
• 도메인 객체의 영속성 처리, 트랜잭션, SMTP 클라이언트, REST 클라이언트 등 다른 영역에서 필요로 하는 프레임워크, 구현 기술, 보조 기능을 지원한다.

• DIP에서 언급했듯이 도메인 영역과 응용 영역이 인프라스트럭처의 기능을 직접 사용하는 것보다, 이 두 영역에 정의한 인터페이스를 인프라스트럭처 영역에서 구현하는 것이 시스템을 더 유연하고 테스트하기 쉽게 만들어준다.

• 하지만, 무조건 인프라스트럭처에 대한 의존을 없애는 것이 좋은 것은 아니다.
• 예를 들어, 스프링을 사용할 경우 응용 서비스는 트랜잭션 처리를 위해 스프링에 제공하는 @Transactional 을 사용하는 것이 편리하다.
• 영속성 처리를 위해 JPA를 사용할 경우 @Entity 나 @Table과 같은 JPA 전용 애노테이션을 도메인 모델 클래스에 사용하는 것이 XML 매핑 설정을 이용하는 것보다 편리하다.

1
2
3
4
5
6
7
8

// 구현의 편리함을 위해ㅣ 인프라스트럭처에 대한 의존을 일부 도메인에 넣은 코드
// JPA의 @Table 애노테이션을 이용해서 엔티티를 저장할 테이블 이름을 지정했다.
// XML 설정 보다 편리하게 테이블 이름을 지정 가능하다.
@Entity
@Table(name = "TBL_ORDER")
public class Order {

}

• 구현의 편리함은 DIP가 주는 다른 장점(변경의 유연함, 테스트가 쉬움) 만큼 중요하기 떄문에 DIP의 장점을 해치지 않는 범위에서 응용 영역과 도메인 영역에서 구현 기술에 대한 의존을 가져가는 것이 현명하다.
• 응용 영역과 도메인 영역이 인프라스트럭처에 대한 의존을 완전히 갖지 않도록 시도하는 것은 자칫 구현을 더 복잡하고 어렵게 만들 수 있다.
• 예를 들어, 스프링의 @Transaction 어노테이션을 사용하면 한 줄로 트랜잭션을 처리할 수 있는데, 코드에서 스프링에 대한 의존을 없애려면 복잡한 스프링 설정을 사용해야 한다.
  • 의존은 없애지만 특별히 테스트를 더 쉽게 할 수있다거나 유연함을 증가 시켜주지 못한다. 단지 설정만 복잡해지고 개발 시간만 늘어날 뿐이다…

모듈 구성

• 아키텍처의 각 영역은 패키지에 위치한다.
• 패키지 구성 규칙에 한 개의 정답만 존재하는 것은 아니지만 아래와 같이 영역별로 모듈이 위치할 때 패키지를 구성할 수 있을 것이다.

• 도메인이 크면 아래 이미지의 [그림 2.22]와 같이 하위 도메인으로 나누고 각 하위 도메인마다 별도 패키지를 구성한다.

• domain 모듈은 도메인에 속한 애그리거트를 기준으로 다시 패키지를 구성한다.
  • 예를 들어, 카탈로그 하위 도메인을 위한 도메인은 상품 애그리거트와 카테고리 애그리거트로 구성된다고 할 경우, [그림 2.23] 과 같이 domain을 두 개의 하위 패키지로 구성해볼 수 있다.

• 각 애그리거트와 모델과 리포지토리는 같은 패키지에 위치시킨다.
  • 예를 들어, 주문고 ㅏ관련된 Order, OrderLine, OrderRepository 등은 com.myshop.order.domain 패키지에 위치시킨다.
• 도메인이 복잡하면 도메인 모델과 도메인 서비스를 다음과 같이 별도 패키지에 위치시킬 수도 있다.

1
2

com.myshop.order.domain.order: 애그리거트 위치
com.myshop.order.domain.servicee: 도메인 서비스 위치

응용 서비스도 다음과 같이 도메인 별로 패키지를 구분할 수 있다.

1
2

com.myshop.catalog.application.product
com.myshop.catalog.application.category

Note: 모듈 구조를 얼마나 세분화 할지에 대해서는 정해진 규칙은 없다. 한 패키지에 너무 많은 타입이 몰려서 코드를 찾을 때 불편한 정도만 아니면 된다. 저자는 한 패키지에 가능하면 10개 미만으로 타입 개수를 유지하려고 노력한다고 한다. 이 개수가 넘어가면 모듈을 분리하는 시도를 해보자.