[ DDD ] 02. 아키텍처 개요

이 게시글은 "도메인 주도 개발 시작하기 : DDD 핵심 개념 정리부터 구현까지" 최범균 님의 책을 기반으로 작성하였습니다.

[DDD] 01. 도메인 모델 시작하기

 

네 개의 영역

• 표현 영역
  • 사용자의 요청을 받아 응용 영역에 전달, 응용 영역의 처리 결과를 다시 사용자에게 보여주는 역할을 한다.
  • 표현 영역의 사용자는 웹 브라우저를 사용하는 사람일 수도 있고, REST API를 호출하는 외부 시스템일 수도 있다.
• 응용 영역
  • 사용자의 요청을 전달받아 사용자에게 제공할 기능을 구현한다.
  • 기능을 구현하기 위해 도메인 영역의 도메인 모델을 사용한다.
  • 로직을 직접 수행하기보다는 도메인 모델에 로직 수행을 위임한다.
• 도메인 영역
  • 도메인 모델(도메인의 핵심 로직)을 구현한다.
• 인프라스트럭처 영역
  • 구현 기술에 대한 것을 다루며, 데이터 연동을 처리하는 곳이다.
  • RDBMS 연동, 메시지 전송&수신, 데이터 연동 등을 처리한다.
  • SMTP를 이용한 메일 발송 기능을 구현하거나 HTTP 클라이언트를 이용해서 REST API를 호출 처리도 인프라 영역에서 처리한다.
  • 표현, 응용, 도메인 영역은 구현 기술을 사용한 코드를 직접 만들지 않고 인프라 영역을 이용하여 처리한다.

 

계층 구조 아키텍처

• 계층 구조는 특성상 상위 계층에서 하위 계층으로의 의존만 존재하고 하위 계층은 상위 계층에 의존하지 않는다.
  • ex) 표현 계층은 응용 계층에 의존하고 응용 계층이 도메인 계층에 의존하지만, 반대로 인프라 계층이 도메인에 의존하거나 도메인이 응용 계층에 의존하지는 않는다.
• 계층 구조를 엄격하게 적용하면 상위 계층은 바로 아래의 하위 계층만 의존해야하지만 구현의 편리함을 위해 유연하게 적용하기도 한다.
  • ex) 응용 계층에서는 바로 하위인 도메인 계층만 의존해야하지만 응용 계층에서 DB 접근이 필요할 때 인프라스트럭처 계층에 의존한다.
  • 하지만 표현, 응용, 도메인 계층이 상세한 구현 기술을 다루는 인프라스트럭처 계층에 종속된다는 점이다.
  • ex) 아래의 예시 코드는 Drools라는 룰 엔진(infra)을 이용하여 할인 금액을 계산하는 로직이다.

// 룰 엔진을 사용한 계산 로직
public class DroolsRuleEngine {
	private KieContainer kContainer;
    
    public DroolsRuleEngine() {
    	KieService ks = KieServices.Factory.get();
        kcontainer = ks.getKieClasspathContainer();
    }
    
    public void evalute( String sessionName, List<?> facts ) {
    	KieSession kSession = kContainer.newKieSession( sessionName );
        try {
        	facts.forEach( x -> kSession.insert(x) );
            kSession.fireAllRules();
        } finally {
        	kSession.dispose();
        }
    }
}

// service에서 RuleEngine을 사용하여 가격 계산하는 로직
public class CalculateDiscountService {
	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();
    }
}

• • 현재 위 코드는 service에서 ruleEngine인 infra영역을 의존하고 있다.
  • 이런 상황에서 나중에 다른 구현 기술로 변경하게 되면 많은 부분에 수정이 필요하다.
  • 응용 계층에서 인프라스트럭처 계층을 의존하면 응용 계층만 테스트하기 어렵고, 기능 확장의 어려움이 있다.

 

DIP

Dependency Inversion Principle 의 약어로 의존 역전 원칙이라고 한다.

고수준 모듈이 저수준 모듈을 사용하려면 고수준 모듈이 저수준 모듈에 의존해야 하는데, DIP는 반대로 저수준 모듈이 고수준 모듈에 의존한다.

• 고수준 모듈
  • 의미 있는 단일 기능을 제공(구현)하는 모듈이다.
• 저수준 모듈
  • 고수준 모듈을 구현하려면 여러 하위 기능이 필요한데 그 하위 기능을 실제로 구현한 것이다.

고수준 모듈이 제대로 동작하려면 저수준 모듈을 사용해야하지만 이렇게 되면 위에서 언급한 문제, 구현 변경과 테스트가 어렵다는 문제가 발생한다.

DIP는 이 문제를 해결하기 위해 저수준 모듈이 고수준 모듈에 의존하도록 바꾼 것이다.

저수준 모듈이 고수준 모듈에 의존하려면 추상화한 인터페이스를 이용해야한다.

 

응용 영역에서 봤을 때 룰을 이용해 할인 금액을 구할 때 룰이 뭘로 구현됐는지는 중요하지 않다. 그냥 '룰을 이용해 할인 금액을 구한다' 라는 것만 중요할 뿐이다.

// 룰을 추상화한 인터페이스
public interface RuleDiscounter {
	Money applyRules( Customer customer, List<OrderLine> orderLines );
}

// infra 영역에서 작성할 코드
public class DroolsRuleDiscounter implements RuleDiscounter {
	@Override
    public Money applyRules ( Customer customer, List<OrderLine> orderLines ) {
    	// 여기에 기존 rule이 작업하던 코드 작성
    }
}


// 응용영역에서 인터페이스를 바라보도록 바꿈
public class CalculateDiscountService {
	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 );
    }
}

이렇게 되면 위 처럼 인프라스트럭처 영역에 의존하지 않으며 구현 기술을 변경하게 될 경우 추상화 인터페이스만 갈아 끼워주면 된다.

이렇게 적용하게되면 저수준 모듈이 고수준 모듈에 의존하게 된다. 이것을 바로 DIP 의존 역전 원칙 이라고 한다.

DIP를 적용하면 다른 영역이 인프라스트럭처 영역에 의존할 때 발생한 구현 교체가 어렵고, 테스트가 어렵다는 문제를 해결할 수 있다.

 

기존 고수준 모듈이 저수준 모듈을 의존하게 되면 수정이 생길 경우 많은 부분 수정이 필요하지만,

저수준 모듈이 고수준 모듈을 의존하게 되면 새로운 구현 객체로 아래 처럼 갈아끼워주면 된다.

// 사용할 저수준 객체 생성
RuleDiscounter ruleDiscounter = new DroolsRuleDiscounter();
// 생성자 방식으로 주입
CalculateDiscountService disService = new CalculateDiscountService( ruleDiscounter );


// 사용할 저수준 구현 객체 변경
RuleDiscounter ruleDiscounter = new SimpleRuleDiscounter();
// 사용할 저수준 모듈을 변경해도 고수준 모듈을 수정할 필요가 없다.
CalculateDiscountService disService = new CalculateDiscountService( ruleDiscouter );

원래는 테스트가 어려웠던 문제 중에 하나가 고수준 모듈이 저수준 모듈을 의존하면서 저수준 모듈로 구현이 되어야 테스트가 가능했지만 DIP가 적용 되면서 테스트 진행할 때 인터페이스로 대역 객체를 사용해서 테스트를 진행할 수 있다.

 

DIP 주의사항

• DIP를 잘못 생각하면 단순히 인터페이스와 구현 클래스를 분리하는 정도로 받아들일 수 있다.
• DIP를 적용할 때 하위 기능을 추상화한 인터페이스는 고수준 모듈 관점에서 도출한다.
  • ex) 응용 영역 입장에서 봤을 때 할인 금액을 구하기 위해서 룰 엔진을 사용하는지 직접 계산하는지는 중요하지않다. 단지 규칙에 따라 할인 금액을 계산하다는 것이 중요할 뿐. 즉, 할인 금액 계산을 추상화한 인터페이스는 저수준 모듈이 아닌 고수준 모듈에 위치한다.

DIP와 아키텍처

인프라스트럭처 영역은 구현을 다루는 저수준 모듈, 응용 영역과 도메인 영역은 고수준 모듈이다.

인터페이스 작성은 고수준 모듈인 응용 영역 or 도메인 영역에서 해야한다.

DIP는 항상 적용할 필요는 없다. 사용하는 구현 기술에 따라 완벽한 DIP를 적용하기보다는 구현 기술에 의존적인 코드를 도메인에 일부 포함하는 게 효과적일 때도 있기 때문에 무조건 적용하지말고 검토해봐야한다.

 

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

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

엔티티와 밸류 (질문있음)

• DB 테이블의 엔티티와 도메인 모델의 엔티티의 차이점
  • 도메인 모델의 엔티티는 데이터와 함께 도메인 기능을 제공한다는 점이다.
    • 도메인 관점에서 기능을 구현을 캡슐화해서 데이터가 임의로 변경되는 것을 막는다.
  • 도메인 모델의 엔티티는 두 개 이상의 데이터가 개념적으로 하나인 경우 밸류 타입을 이용한다.
• RDBMS의 경우 밸류 타입을 제대로 표현하기 힘들다.
• 밸류는 불변으로 구현할 것을 권장하며, 엔티티의 밸류 타입 데이터를 변경할 때는 객체 자체를 완전히 교체한다는 것을 의미한다.

애그리거트 AGGREGATE

• 관련 객체를 하나로 묶은 군집이다.
• 도메인이 커질수록 많아지는 엔티티와 밸류로 도메인 모델은 점점 더 복잡해진다.
• 도메인 모델에서 전체 구조를 이해하는 데 도움이 되는 것이 바로 애그리거트이다.
• ex) 주문 애그리거트 안에는 주문, 배송지 정보, 주문자, 주문 목록, 총 결제 금액의 하위 모델로 구성된다.
• 애그리거트를 사용하면 개별 객체가 아닌 관련 객체를 묶어서 객체 군집 단위로 모델을 바라볼 수 있게 된다.
• 애그리거트는 군집에 속한 객체를 관리하는 루트 엔티티를 갖는다.
• 애그리거트를 사용하는 코드는 애그리거트 루트가 제공하는 기능을 실행하고 애그리거트 루트를 통해 간접적으로 애그리거트 내의 다른 엔티티나 밸류 객체에 접근한다.
• 이것은 애그리거트의 내부 구현을 숨겨서 애그리거트 단위로 구현을 캡슐화할 수 있도록 돕는다.

리포지터리 REPOSITORY

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

• 도메인 객체를 지속적으로 사용하려면 RDBMS, NoSQL, 로컬 파일과 같은 물리적인 저장소에 도메인 객체를 보관해야한다. 이를 위한 도메인 모델이 리포지터리 이다.
• 리포지터리는 애그리거트 단위로 도메인 객체를 저장하고 조회하는 기능을 정의한다.
• Repository의 메서드를 보면 대상을 찾고 저장하는 단위가 애그리거트 루트인 것을 알 수 있다.
• 도메인 모델을 사용해야 하는 코드는 리포지터리를 통해서 도메인 객체를 구한 뒤에 도메인 객체의 기능을 실행한다.
• 도메인 모델 관점에서 Repository는 도메인 객체를 영속화하는 데 필요한 기능을 추상화한 것으로 고수준 모듈에 속한다.
• 응용 서비스는 의존 주입과 같은 방식을 사용해서 실제 리포지터리 구현 객체에 접근한다.
• 응용 서비스는 필요한 도메인 객체를 구하거나 저장할 때 리포지터리를 사용하고, 트랜잭션을 관리하는데, 트랜잭션 처리는 리포지터리 구현 기술의 영향을 받는다.
• 리포지터리를 사용하는 주체가 응용 서비스로 응용 서비스가 필요로 하는 메서드 두개는 기본이 된다.
  • 애그리거트를 저장하는 메서드
  • 애그리거트 루트 식별자로 애그리거트를 조회하는 메서드
  • 이 외에 필요에 따라 delete(id), counts() 등의 메서드를 제공하기도 한다.

public interface SomeRepository {
	
    void save( Some some );
    Some findById( SomeId id );
}

 

요청 처리 흐름

• 표현 영역은 사용자가 전송한 데이터 형식이 올바른지 검사하고 문제가 없다면 데이터를 이용해서 응용 서비스에 기능 실행을 위임한다.
• 응용 서비스는 도메인 모델을 이용해서 기능을 구현한다.
• 기능 구현에 필요한 도메인 객체를 리포지터리에서 가져와 실행하거나 신규 도메인 객체를 생성해서 리포지터리에 저장한다.
• 응용 서비스는 도메인의 상태를 변경하므로 변경 상태가 물리 저장소에 올바르게 반영되도록 트랜잭션을 관리해야 한다.

 

인프라스트럭처 개요

• 인프라스트럭처는 표현 영역, 응용 영역, 도메인 영역을 지원한다.
• DIP에서 언급한 것처럼 도메인 영역과 응용 영역에서 인프라스트럭처의 기능을 직접 사용하는 것보다 이 두 영역에 정의한 인터페이스를 인프라스트럭처 영역에서 구현하는 것이 시스템을 더 유연하고 테스트하기 쉽게 만들어 준다.
• 무조건 인프라스트럭처에 대한 의존을 없앨 필요는 없다.
  • 스프링을 사용할 경우 응용 서비스는 트랜잭션 처리를 위해 스프링이 제공하는 @Transactional을 사용하는 것이 편리하다.
  • 영속성 처리를 위해 JPA를 사용할 경우 @Entity @Table과 같은 JPA 전용 애너테이션을 도메인 모델 클래스에 사용하는 것이 XML 매핑 설정을 이용하는 것보다 편리하다.
  • * 영속성 처리 : 데이터를 지속적으로 저장하고 관리하여 프로그램의 실행을 보다 안정적으로 만드는 기능

• DIP가 주는 장점인 변경의 유연함, 테스트가 쉬움 만큼 구현의 편리함도 중요하다.
• 그렇기에 DIP의 장점을 해치지 않는 범위에서 응용 영역과 도메인 영역에서 구현 기술에 대한 의존을 가져가는 것도 나쁘지 않다.
  • ex) 스프링의 @Transactional 애너테이션을 사용하면 한 줄로 트랜잭션 처리를 할 수 있는데 의존을 없애려면 복잡한 스프링 설정을 사용해야한다. 이럴 경우 설정만 복잡해지고 개발 시간만 늘어나니 그냥 애너테이션을 사용하자.

 

모듈 구성

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

• 내가 하는 프로젝트의 경우 애그리거트 별 패키지를 생성하기로 했다.

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