#04장 Repo와 모델 구현 (JPA 중심)

최범균 저「DDD START!, 2016」를 읽고 정리하였습니다.

• 다룰 내용

  • JPA 이용 리포 구현

  • 엔티티와 밸류 매핑

  • 밸류 컬렉션 매핑

  • 애그리거트 로딩 전략과 영속성 전파

  • 식별자 생성 기능

JPA 이용 리포 구현

• JPA: 도메인 모델과 리포 구현시 선호되는 기술 (ORM 기반)

• 가능한, 리포 구현 클래스를 infra 영역에 위치 시켜 의존성을 낮춰야

• 기본 구현 방법

  • ID로 애그 조회

    public Order findById(OrderNo no){
    	em.find(Order.class, no);
    }

  • 애그 저장

    public void save(Order order){
    	em.persist(order);
    }

  • 삭제

    // 고객이 요구해도, 보통 바로 삭제는 안함 (관리자가 삭제한 데이터도 조회해야될때도 있으니)
    public void remove(Order order) {
    	entityManager.remove(order);
    }

• 트랜잭션 예시

public class ChangeOrderService {
	@Transactional // 트랜잭션 범위에서 변경한 데이터를 DB에 자동 (메서드 끝나면 UPDATE 반영)
	public void changeShippingInfo(OrderNo no, Shippinglnfo newShippinglnfo) {
		Order order = orderRepository.findByld(no);
		if (order == null) throw new OrderNotFoundException();
			order.changeShippinglnfo(newShippinglnfo);
		}
		//...
	}
}

• 명명 규칙: findBy 뒤에 조건 (e.g., findByOrdererld())

• ID 외로 agg 조회시 Criteria나 JPQL 사용

// JPQL 예시
// 해당ID를 가진 주문자가 주문한 주문들 가져오기
@Override
public List<Order> findByOrdererId(String ordererld, int startRow, int fetchSize) {
	TypedQuery<Order> query = entityManager.createQuery(
				"select o from Order o " +
				"where o.orderer.memberld.id = :ordererId " +
				"order by o.number.number desc",
				Order.class);
	query.setParameter("ordererId", ordererld);
	query.setFirstResult(startRow);
	query.setMaxResults(fetchSize);
	return query.getResultList();
}

매핑

• 애그와 JPA 매핑을 위한 기본 규칙

  • agg 루트는 엔티티이므로 @Entity로 매핑 설정

  • 한 테이블에 엔티티와 밸류가 공존시

    • 밸류 는 @Embeddable로 설정

    • 밸류 는 @Embedded로 설정

• 다이어그램을 보고, 코드로 확인해보자.

  • 사례: 주문 (엔티티), 주문자(밸류), 배송지정보(밸류) → 주문 내역서 (purchase_order) 테이블에 다 포함

• @Entity

@Entity
@Table(name = "purchase_order")
public class Order { // 애그리거트 루트 
	@Embedded // 밸류 타입 프로퍼티 설정 어노테이션
	private Orderer orderer;
	@Embedded
	private Shippinglnfo shippinglnfo;
	//...
}

• @Embeddable, @Embedded

import javax.persistence.Embeddable;
@Embeddable 
public class Orderer { // 주문자
	@Embedded
	@AttributeOverrides( // 칼럼 이름 변경 위해 사용 (DB에 orderer_id로 들어감)
		@AttributeOverride(name = "id", column = @Column(name = "orderer_id"))
	)
	private MemberId memberld;

	@Column(name = "orderer_name")
	private String name;
}

@Embeddable
public class Memberld implements Serializable {
	(@Column (name="member_id ")
	private String id;
}

• JPA 2 부터 @Embeddable은 중첩 허용해서, 아래 처럼, Shippinglnfo 안에 Address랑 Receiver 포함

@Embeddable
public class Shippinglnfo {
	@Embedded
	@AttributeOverrides({
		@AttributeOverride(name = "zipCode"j
			column = (@Column (name = "shipping_zipcode"))
			(@AttributeOverride(name = "addressl",
			column = (@Column(name = "shipping_addn")),
			(@AttributeOverride(name = "address2"j
			column = (@Column (name = "shipping_addr2")
		)
	})
	private Address address;
	
	@Column (name = "shippingjnessage")
	private String message;
	
	@Embedded
	private Receiver receiver;

}

기본 생성자

public class Receiver {
	private String name;
	private String phone;
	public Receiver(String name, String phone) {
		this.name = name;
		this.phone = phone;
	}
	// Receiver 불변이면, setter 메서드는 제공하지 않으며,
	// 기본 생성자도 생성할 필요가 없지만,  
	// JPA의 @Entity @Embeddable은 사용시 자동으로 생성된다. (기술적 제약)
	// 그에 대응하여, protected 로 선언한다. 
}

필드 접근 방식 사용

• 엔티티를 객체가 제공할 기능 중심으로 구현하도록 유도하면, JPA 매핑 처리를 프로퍼티 방식이 아닌 필드방식으로 선택해서, 불필요한 get/set메서드를 구현하지 말아야 한다.

@Entity
@Access(AccessType.FIELD) // AccessType.PROPERTY가 아닌 필드로
public class Order {
	@Column(name = ,fstate")
	@Enumerated(EnumType.STRING)
	public OrderState getState() {
		return state;
	}

	public void setState(OrderState state) {
		this.state = state;
	}
	//...
}

AttributeConverter를 이용한 밸류 매핑 처리

• 밸류 타입의 프로퍼티를 한개 컬럼에 매핑해야될때가 있다. (e.g. DB에 1000mm 저장)

public class Length {
	// 두개의 프로퍼티를 1000mmm로 한개의 컬럼에 매핑 
	private int value; // 1000
	private String unit; // mm
}

• AttributeConverter: 밸류 타입과 칼럼 데이터 간의 변환 처리를 해준다.

public interface AttributeConverter<X,Y> {
	public Y convertToDatabaseColumn (X attribute);
	public X convertToEntityAttribute (Y dbData);
}
// ------------------------------------------
// Money를 위한 AttributeConverter 구현
@Converter(autoApply = true)
public class MoneyConverter implements AttributeConverter<Money, Integer> {
	@Override
	public Integer convertToDatabaseColumn(Money money) {
		if (money == null)
			return null;
		else
		return money.getValue();
	}

	@Override
	public Money convertToEntityAttribute(Integer value) {
		if (value == null) return null;
		else return new Money(value);
	}
}
// ------------------------------------------
@Entity
@Table(name == Hpurchase_orderu)
public class Order {
	@Column(name = "total_amounts")
	@Convert(converter = MoneyConverter.class) // 컨버터 지정
	private Money totalAmounts; // DB에 변환된 값은 넣는다. 
	//...
}

밸류 컬렉션: 별도 테이블 매핑

• 밸류 컬렉션 별도 테이블로 매핑할때는 @ElementCollection과 @CollectionTable 사용

@Entity
@Table(name = "purchase_order")
public class Order {
	@ElementCollection
	@CollectionTable(name == "order_line")
							joinColumns = @JoinColumn(name = "order__number"))
	@OrderColumn(name = "line_idx")
	private List<OrderLine> orderLines;
	//...
}

밸류 컬렉션: 한개 컬럼 매핑

• 사례: 도메인 모델에서 이메일을 Set으로 보관하고, DB에서는 한컬럼에 콤마로 구분해서 저장할때

• AttributeConverter 사용 하기

@Converter
public class EmailSetConverter implements AttributeConverter<EmailSet, String> {
	@Override
	public String convertToDatabaseColumn(EmailSet attribute) {
		if (attribute == null) return null;
		return attribute.getEmails().stream()
							.map(Email::toString)
							.collect(Collectors.joining(","));
	}

	@0verride
	public EmailSet convertToEntityAttribute(String dbData) {
	if (dbData == null) return null;
		String[] emails = dbData.split(",");
		Set<Email> emailSet = Arrays.stream(emails)
										.map(value -> new Email(value))
										.collect(toSet());
		return new EmailSet(emailSet);
	}
}

// ----------------------------
// EmailSet가 컨버터 사용하도록 지정 
@Column(name = "emails")
@Convert(converter = EmailSetConverter.class)
private EmailSet emailSet;

밸류를 이용한 아이디 매핑

• 식별자 대게 String이나 Long

• 근데, 밸류타입을 식별자로 지정하려면, @Id대신 @EmbeddedId 사용

@Entity
@Table(name = "purchase_order")
public class Order {
	@EmbeddedId
	private OrderNo number;
	//...
}

@Embeddable
public class OrderNo implements Serializable { // JPA 에서 식별자는 Serializable 상속
	@Column(name="order_number")
	private String number;
	//...
}

• 위와 같이 사용해서 장점은, 주문번호가 1세대 2세대가 있다면, OrderNo 안에서 구분짓게 할 수 있다.

@Embeddable
public class OrderNo implements Serializable {
	@Column(name = "order_number")
	private String number;
	public boolean is2ndGeneration() {
		return number.startsWith("N");
	}
	//...
}

별도 테이블에 저장하는 밸류 매핑

• 상품 화면에 리뷰가 있다고 리뷰가 상품 애그리거트에 포함되있는게 아니다. 서로의 변경이 영향을 주지 않기에, 리뷰는 엔티티가 맞지만 상품 애그리거트에 속한 것은 아니다.

• 밸류인지 애그리거트인지 구별 방법: 고유식별자 갖는지 확인하면 된다. 다만, DB에 넣기 위한 ID 식별자와 헷갈리지 말자.

• 예, Aritcle(엔티티) - ArticleContent(밸류타입)

• 밸류를 매핑한 테이블 지정은 @SecondaryTable와 @AttributeOverrides 사용

@Entity
@Table(name = "article")
@SecondaryTable(
	name = "article_content", // 밸류 저장한 테이블 지정
	pkJoinColumns = @PrimaryKeyJoinColumn(name = "id")
)
public class Article {
	@Id
	private Long id;
	private String title;
	@AttributeOverrides({
		@AttributeOverride(name = "content”,
			column = @Column(table = "article_content™)),
		@AttributeOverride(name = “contentType",
			column = @Column(table = "article_content"))
	})
	private ArticleContent content;
}

밸류 컬렉션을 @Entity로 매핑하기

• 개념적으로 밸류인데 기술 제약으로 엔티티로 사용해야 될때가 있다.

• 예를 들어, 상속 구조를 갖는 밸류 타입을 사용하면, @Embeddable대신 @Entity 사용

  • 아래 Image는 엔티티로 선언된다. 다만, 사실상 밸류임으로 상태 변경하는 기능은 추가하지 않는다.

  • Image의 라이프사이클은 Product에 달려있다. (orphanRemoval true로 사용)

@Entity
@Inheritance(strategy = InheritanceType.SINGLE_TABLE)
@DiscriminatorColumn(name = "image_type") // 이미지 타입 구분을 위한
@Table(name = "image")
public abstract class Image {
	@Id
	@GeneratedValue(strategy = GenerationType.IDENTITY)
	@Column(name = "image id")
	private Long id;
	@Column(name = "image path")
	private String path;
	//...
}
// ---------------------------------------------
@Entity
@DiscriminatorValue("II") // 구분자로 매핑 설정
public class InternalImage extends Image {
}
@Entity
@DiscriminatorValue("EI") // 구분자로 매핑 설정
public class ExternalImage extends Image {
}
// ---------------------------------------------

@Entity
@Table(name = "product")
public class Product {
	@EmbeddedId
	private ProductId id;
	private String name;

	@Convert(converter = MoneyConverter.class)
	private Money price;
	private String detail;

	@OneToMany(cascade = {CascadeType.PERSIST, CascadeType.REMOVE},
		orphanRemoval = true)
	@JoinColumn(name = "product_id")
	@OrderColumn(name = "list_idx")
	private List<Image> images = new ArrayList<>();
	public void changeImages(List<Image> newImages) {
		images.clear();
		images.addAll(newImages);
	}
}

ID 참조와 조인 테이블을 이용한 단방향 M:N 매핑

• 애그리거트 간 집합 연관은 피해야하지만, 그렇게 하는 것이 유리하다면, ID 참조를 이용한 단방향 집합 연관을 적용할 수 있다.

@Entity
@Table(name = "product**)
public class Product {
	@EmbeddedId
	private ProductId id;

	@ElementCollection // Product 삭제시 product_category 테이블 데이터도 함께 삭제
	@CollectionTable(name = "product_category"
		joinColumns = @JoinColumn(name = "product_id"))
	private Set<CategoryId> categorylds;
	//...
}

애그리거트 로딩 전략

• JPA 매핑을 설정시, 애그리거트에 속한 객체가 모두 모여야 완전한 하나가 된다는 것을 알아두자.

  • 속한 모든 객체가 완전한 상태여야 함을 의미한다.

// product는 완전한 하나이다.
Product product = productRepository.findByld(id);

• 조회 시점에서 애그리거트를 완전한 상태가 되도록 하려면 → FetchType.EAGER

  • 하지만 항상 좋은것은 아니다. 책에선 카타시안 조인 나타나는 문제를 보여준다.

// @Entity 컬렉션에 대한 즉시 로딩 설정
@OneToMany(cascade = {CascadeType.PERSIST, CascadeType.REMOVE}
orphanRemoval = true, fetch = FetchType.EAGER)
@JoinColumn(name = "product_id")
@OrderColumn(name = "list_idx")
private List<Image> images = new ArrayList<>();1

// @Embeddable 컬렉션에 대한 즉시 로딩 설정
@ElementCollection(fetch = FetchType.EAGER)
@CollectionTable(name = "orderjine"
	joincolumns = @JoinColumn(name = "order_number"))
@OrderColumn (name = "line_idx")
private List<OrderLine> orderLines;

애그리거트의 영속성 전파

• 완전한 하나라는 것은, 조회 뿐만아니라 저장하고 삭제할 때도 하나로 처리

• 저장/삭제시, 루트뿐만 아니라 속한 모든 객체 저장/삭제하기

  • Cascade 사용

@OneToMany(cascade = {CascadeType.PERSIST, CascadeType.REMOVE},
orphanRemoval = true)

식별자 생성 기능

• 방법

  • 사용자가 직접 생성 (e.g., 이메일)

  • 도메인 로직으로 생성

  • DB 일련번호 사용

엔티티가 식별자 생성 기능을 제공하는 것보다는 별도 서비스로 식별자 생성 기능을 분리해야 한다.

public class ProductldService {
	public Productld nextId() {
		// 정해진 규칙으로 식별자 생성
	}
}

// 도메인 서비스에서 이를 이용해서 다음 식별자를 생성 후 엔티티를 생성한다.
public class CreateProductService {
	@Autowired 
	private ProductldService idService;
	@Autowired 
	private ProductRepository productRepository;

	@Transactional
	public Productld createProduct(ProductCreationCommand cmd) {
		// 응용 서비스는 도메인 서비스를 이용해서 식별자를 생성
		Productld id = productldService.nextId();
		Product product = new Product(id, cmd.getDetail(), cmd.getPrice()， .... );
		productRepository.save(product);
		return id;
	}
}

// 특정 값의 조합으로 식별자가 생성하기
public class OrderldService {
	public Orderld createld(Userid userid) {
		if (userid == null)
			throw new IllegalArgumentException("invalid userid: " + userid);
		return new Orderld(userid.toString() + "-" + timestampO); // 주문번호를 고객 ID와 타임스탬프로 구성
	}

	private String timestamp() {
		return Long.toString(System.currentTimeMillis());
	}
}

식별자 생성의 적합한 또 다른 장소는 리포지터리이다.

public interface ProductRepository {
	Productld nextld();
}

// DB의 자동 증가 칼럼을 사용할 경우 GenerationType 사용
@Id
@GeneratedValue(strategy = GenerationType.IDENTITY)
private Long id;