[도메인주도개발시작하기] Chapter4-리포지터리와 모델구현(JPA 중심)

@Embeddable
public class Orderer {
	// MemberId에 정의된 칼럼 이름을 변경하기 위해
  // @AttributeOverride 애노테이션 사용
  @Embedded
  @AttributeOverrides(@AttributeOverride(name = "id", column = @Column(name = "orderer_id")))
  private MemberId memberId;
  
  @Column(name = "orderer_name")
  private String name;
}

@Embeddable
public class Receiver {
  protected Receiver() {} 
}

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

public class Product {
  @Column(name = "WIDTH")
  private String width;

  public Length getWidth() {
    return new Length(width); // DB 칼럼 값을 실제 프로퍼티 타입으로 변환
  }

  void setWidth(Length width) {
    this.width = width.toString(); // 실제 프로퍼티 타입을 DB 칼럼 값으로 변환
  }
}

public interface AttributeConverter<X, Y> {
    Y convertToDatabaseColumn(X var1);

    X convertToEntityAttribute(Y var1);
}

// 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);
  }
}

public class Order {
  ...

  @Column(name = "total_amounts")
  @Convert(converter = MoneyConverter.class)
  private Money toalAmounts;
}

@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;
  ...
}

@Embeddable
public class OrderLine {
  @Embedded
  private ProductId productId;
  
  @Column(name = "price")
  private Money price;
  
  ...  
}

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
public class OrderNo implements Serializable {
  @Column(name = "order_number")
  private String number;
  
  // 1세대 시스템의 주문 번호와 2세대 시스템의 주문 번호가 있다고 가정할 때 이를 구분하기 위한 메서드 구현
  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
@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 {
  ...

  @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);
  }
}

@Embeddable
public class Image {
  @Column(name = "image_type")
  private String imageType;
  @Column(name = "image_path")
  private String path;

  ...
  public boolean hasThumbnail() {
    // 성능을 위해 다형을 포기하고 if-else로 구현
    if (imageType.equals("II")) {
      return true;
    }

    return false;
  }
}

@Entity
@Table(name = "product")
public class Product {
  @EmbeddedId
  private ProductId id;
    
  @ElementCollection 
  @CollectionTable(name = "product_category", joinColumns = @JoinColumn(name = "product_id"))
  private Set<CategoryId> categoryIds;

  ...
}

// product 는 완전한 하나여야 한다.
Prodcut product = productRepository.findById(id);

@Entity
public class Product {
  ...
  @OneToMany(
    cascade = {CascadeType.PERSIST, CascadeType.REMOVE},
    orphanRemoval = true,
    fetch = FetchType.Eager)
  @JoineColumn(name = "product_id")
  @OrderColumn(name = "list_idx")
  private List<Image> images = new ArrayList<>();

  @ElementCollection(fetch = FetchType.EAGER)
  @CollectionTable(name = "product_option", joinColumns = @JoinColumn(name = "product_id"))
  @OrderColumn(name = "list_idx")
  private List<Option> options = new ArrayList<>();
  
  ...
}

@Transactional
public void removeOptions(ProductId id, int optIdxToBeDeleted) {
  // Product 를 로딩. 컬렉션은 지연 로딩으로 설정했다면, Option은 로딩하지 않음
  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<>();

public class OrderIdService {
  public OrderId createId(UserId userId) {
    if (userId == null) {
      throw new IllegalArgumentException("invalid userid: " + userId);

      return new OrderId(userId.toString() + "-" + timestamp());
    }
  }

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

public interface ProductRepository {
  ...
  ProductId nexxtId();
  ...
}