[DDD Start]4장. 리포지터리와 모델 구현

public class changeOrderService {
  @Transactional
  public void changeShippingInfo(OrderNo no, ShippingInfo newShippingInfo) {
    Order order = orderRepository.findById(no);
    if (order == null) throw new OrderNotFoundException();
    // UPDATE 쿼리 실행
    order.changeSshippingInfo(newShippingInfo);
  }
}

@Entity
@Table(name = "puchase_order")
public class Order {
  ....
  @Embedded
  private Orderer orderer;
}

@Embeddable
public class Orderer {
	// Embeddable 타입에 설정한 칼럼 이름과 실제 칼럼 이름이 다르므로 Orderer의 memberId 프로퍼티를 매핑할 때
  // @Attributeoverrides 애노테이션을 이용해 매핑할 칼럼 이름을 변경한다.
  @Embedded
  @AttributeOverrides(@AttributeOverride(name = "id", column = @Column(name = "orderer_id")))
  private MemberId id;
  
  @Column(name = "orderer_name")
  private String name;
}

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

@Embbeddable
public class ShippingInfo {
  // JPA 2부터 @Embeddable은 중첩을 허용하므로 밸류인 ShippingInfo가 또 다른 밸류인 Address를 포함할 수 있다.
  @Embedded
  @AttributeOverrides({
    @AttributeOverride(name = "zipCode", column = @Column(name = "shipping_zipcode")),
    @AttributeOverride(name = "address1", column = @Column(name = "shipping_addr1")),
    @AttributeOverride(name = "address2", column = @Column(name = "shipping_addr2"))
  })
  private Address address;
  
  @Column(name = "shipping_message")
  private String message;
}

@Embeddable
public class Receiver {
  ...
  // JPA 프로바이더가 객체를 생성할 때만 사용하기 위함이므로,
  // 다른 코드에서 기본 생성자를 사용하지 못하도록 protected로 선언한다.
  protected Receiver() {} 
  ..
}

@Entity
// @Access(AccessType.PROPERTY)
@Access(AccessType.FIELD)
public class Order {
  @EmbeddableId
  private OrderNo number;
  
  ...
}

// autoApply가 true일 경우, 모델에 출현하는 모든 Money 타입의 프로퍼티에 대해 MoneyConverter를 자동으로 적용한다.
// false인 경우, 프로퍼티 값을 변환할 때 사용할 컨버터를 직접 지정할 수 있다.
@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 = "purchase_order")
public class Order {
  ...
  @ElementCollection
  // 밸류 저장 테이블명과 외부키로 사용할 칼럼 지정
  // 외부키가 두 개 이상인 경우, @JoinColumn의 배열을 이용해 외부키 목록 지정
  @CollectionTable(name = "order_line", joinColumns = @JoinColumn(name = "order_number"))
  // OrderLine은 List의 인덱스 값을 저장하기 위한 프로퍼티는 따로 존재하지 않는다.
  // List 타입 자체가 인덱스를 갖기 때문인데, 이를 위해 JPA는 @OrderColumn 애노테이션을 이용해 지정한 컬럼에 저장한다.
  @OrderColumn(name = "line_idx")
  private List<OrderLine> orderLines;
  ...
}

@Embeddable
public class OrderLine {
  @Embedded
  private ProductId productId;
  
  @Column(name = "price")
  private Money price;
  ...
    
  // List 인덱스 프로퍼티 따로 없음.
}

public class EmailSet {
  private Set<Email> emails = new HashSet<>();
  
  private EmailSet(){}
  private EmailSet(Set<Email> emails) {
    this.emails.addAll(emails);
  }
  
  public Set<Email> getEmails() {
    return Collections.unmodifiableSet(emails);
  }
}

@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(","));
  }
  
  @Override
  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);
  }
}

@Column(name = "emails")
@Convert(converter = EmailSetConverter.class)
private EmailSet emailSet;

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

@Embeddable
// JPA에서 식별자 타입은 Serializable 타입이어야 하므로 인터페이스를 상속받아야 한다.
public class OrderNo implements Serializable {
  @Column(name = "order_number")
  private String number;
  
  // 밸류 타입의 식별자를 구현할 때 얻을 수 있는 장점은 식별자에 기능을 추가할 수 있다.
  public boolean is2ndGeneration() {
    return number.startWith("N");
  }
}

@Entity
@Table(name = "article")
@SecondaryTable(
	name = "article_content",
  pkJoinColumns = @PrimaryKeyJoinColumn(name = "id")
)
public class Article {
  @Id
  private Long id;
  
  ...
  @AttributeOverrides({
    @AttributeOverride(name = "content", column = @Column(table = "article_content")),
    @AttributeOverride(name = "contentType", column = @Column(table = "article_content"))
  })
  private ArticleContent content;
}

Article article = entityManager.find(Article.class, 1L);

// 밸류를 @Entity로 매핑했으므로 상태 변경 메서드를 제공하지 않는다.
@Entity
// 하위 클래스를 매핑하므로 @Inhertance를 적용하고 SINGE_TABLE로 설정한다.
@Inheritance(startegy = InheritanceType.SINGLE_TABLE)
// 타입을 구분하는 용도로 사용할 컬럼을 지정한다.
@Descriminator(name = "image_type")
@Table(name = "image")
public abstract class Image {
  ...
}

@Entity
@DiscriminatorValue("II")
public class InternalImage extends Image {
  ...
}

@Entity
@DiscrimnatorValue("EI")
public class ExternalImage extends Image {
  ...
}

@Entity
@Table(name = "product")
public class Product {
  ...
  // Image가 @Entity 이므로 목록을 담고 있는 Product는 @OneToMany를 이용해 매핑을 처리한다.
  // Image는 밸류이므로 독자적인 라이프사이클을 갖지 않고 Product에 완전히 의존하기 위해 `cascade` 속성을 적용해, 
  // Product를 저장할 때 함께 저장되고, Product가 삭제될 때 함께 삭제되도록 설정한다.
  // 또한, 리스트에서 Image 객체를 제거하면 DB에서 함께 삭제되도록 orphanRemoval도 true로 설정한다.
  @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);
  }
}

@Entity
@Table(name = "product")
public class Product {
  ...
    
  // Product 삭제시 매핑에 사용한 조인 테이블의 데이터도 함께 삭제된다.
  // 따라서 영속성 전파나 로딩 전략에 대해 고민할 필요가 없어진다.
  @ElementCollection
  // 밸류 컬렉션 매핑과 유사하지만 집합의 값에 밸류 대신 연관을 맺는 식별자가 온다.
  @CollectionTable(name = "product_category", joinColumns = @JoinColumn(name = "product_id"))
  private Set<CategoryId> categoryIds;
}

@Transactional
public void removeOptions(ProductId id, int optIdxToBeDeleted) {
  Prodcut product = productRepository.findById(id);
  // 트랜잭션 범위이므로 지연 로딩으로 설정한 연관 로딩 가능.
  product.removeOption(optIdxToBeDeleted);
}

@Entity
public class Product {
  @ElementCollection(fetch = FetchType.LAZY)
  @CollectionTable(name = "product_option", joinColumns = @JoinColumn(name = "product_id"))
  @OrderColumn(name = "list_idx")
  private List<Option> options = new ArrayList<>();
  
  public void removeOption(int optIdx) {
    // 실제 컬렉션에 접근할 때 로딩
    this.options.remove(optIdx);
  }
}

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