기본 Entity Mapping

// 기존 테이블: tbl_products (레거시 네이밍)
@Entity
@Table(
    name = "tbl_products",
    indexes = {
        @Index(name = "idx_product_name", columnList = "name"),
        @Index(name = "idx_product_category", columnList = "category_id")
    },
    uniqueConstraints = {
        @UniqueConstraint(name = "uk_product_sku", columnNames = {"sku"})
    }
)
public class Product {
    @Id
    @GeneratedValue(strategy = GenerationType.IDENTITY)
    @Column(name = "product_id")
    private Long id;
    
    @Column(name = "product_name", nullable = false)
    private String name;
    
    // ...
}

# application.yml
spring:
  jpa:
    hibernate:
      naming:
        # 논리적 이름 전략 (Entity → 논리명)
        implicit-strategy: org.hibernate.boot.model.naming.ImplicitNamingStrategyJpaCompliantImpl
        # 물리적 이름 전략 (논리명 → 실제 테이블/컬럼명)
        physical-strategy: org.hibernate.boot.model.naming.CamelCaseToUnderscoresNamingStrategy

# 결과:
# productName → product_name
# OrderItem → order_item

// 방법 1: @IdClass
public class OrderItemId implements Serializable {
    private Long orderId;
    private Long productId;
    
    // 기본 생성자, equals(), hashCode() 필수
    @Override
    public boolean equals(Object o) { ... }
    @Override
    public int hashCode() { ... }
}

@Entity
@IdClass(OrderItemId.class)
public class OrderItem {
    @Id 
    @Column(name = "order_id")
    private Long orderId;
    
    @Id 
    @Column(name = "product_id")
    private Long productId;
    
    private int quantity;
}

// 방법 2: @EmbeddedId (권장)
@Embeddable
public class OrderItemId implements Serializable {
    @Column(name = "order_id")
    private Long orderId;
    
    @Column(name = "product_id")
    private Long productId;
    
    // equals(), hashCode() 필수
}

@Entity
public class OrderItem {
    @EmbeddedId
    private OrderItemId id;
    
    private int quantity;
    
    // 조회 시
    // OrderItem item = em.find(OrderItem.class, new OrderItemId(1L, 100L));
}

// 기존 DB: status 컬럼에 10, 20, 30 저장
public enum OrderStatus {
    PENDING(10),
    PAID(20),
    SHIPPED(30),
    DELIVERED(40);
    
    private final int code;
    
    OrderStatus(int code) {
        this.code = code;
    }
    
    public int getCode() {
        return code;
    }
    
    public static OrderStatus fromCode(int code) {
        return Arrays.stream(values())
            .filter(s -> s.code == code)
            .findFirst()
            .orElseThrow(() -> new IllegalArgumentException("Unknown code: " + code));
    }
}

@Converter(autoApply = true)  // 모든 OrderStatus에 자동 적용
public class OrderStatusConverter implements AttributeConverter<OrderStatus, Integer> {
    @Override
    public Integer convertToDatabaseColumn(OrderStatus status) {
        return status != null ? status.getCode() : null;
    }
    
    @Override
    public OrderStatus convertToEntityAttribute(Integer code) {
        return code != null ? OrderStatus.fromCode(code) : null;
    }
}

@Entity
public class Order {
    // @Convert 생략 가능 (autoApply = true)
    @Column(name = "status")
    private OrderStatus status;  // DB에는 10, 20, 30으로 저장
}

@Entity
public class Order {
    // 날짜만 (DATE)
    private LocalDate orderDate;

    // 날짜 + 시간 (DATETIME/TIMESTAMP)
    private LocalDateTime createdAt;

    // 시간만 (TIME) - 잘 사용 안함
    private LocalTime deliveryTime;

    // 타임존 포함 (TIMESTAMP WITH TIME ZONE)
    // PostgreSQL 지원, MySQL은 제한적
    private ZonedDateTime scheduledAt;

    // Instant (UTC 기준 TIMESTAMP)
    // 서버 간 시간 동기화에 유용
    private Instant processedAt;
    
    // 기간 (Period, Duration)은 직접 매핑 안됨
    // → String이나 Long으로 변환 필요
}

@Entity
public class Product {
    @Id
    @GeneratedValue(strategy = GenerationType.IDENTITY)
    private Long id;
    
    private String name;
    
    @Column(updatable = false)
    private LocalDateTime createdAt;
    
    private LocalDateTime updatedAt;
    
    // INSERT 전 호출
    @PrePersist
    protected void onCreate() {
        createdAt = LocalDateTime.now();
        updatedAt = LocalDateTime.now();
    }
    
    // UPDATE 전 호출
    @PreUpdate
    protected void onUpdate() {
        updatedAt = LocalDateTime.now();
    }
}

// 1. 설정 클래스에 @EnableJpaAuditing 추가
@Configuration
@EnableJpaAuditing
public class JpaConfig {
}

// 2. 공통 BaseEntity 생성
@MappedSuperclass
@EntityListeners(AuditingEntityListener.class)
@Getter
public abstract class BaseEntity {
    
    @CreatedDate
    @Column(updatable = false)
    private LocalDateTime createdAt;
    
    @LastModifiedDate
    private LocalDateTime updatedAt;
    
    // 작성자/수정자도 추가 가능
    @CreatedBy
    @Column(updatable = false)
    private String createdBy;
    
    @LastModifiedBy
    private String updatedBy;
}

// 3. Entity에서 상속
@Entity
public class Product extends BaseEntity {
    @Id
    @GeneratedValue(strategy = GenerationType.IDENTITY)
    private Long id;
    
    private String name;
    // createdAt, updatedAt 자동 관리
}

// 4. 작성자 정보 제공 (선택)
@Configuration
public class AuditorConfig {
    @Bean
    public AuditorAware<String> auditorProvider() {
        return () -> Optional.ofNullable(SecurityContextHolder.getContext())
            .map(SecurityContext::getAuthentication)
            .map(Authentication::getName);
    }
}

// 값 타입 정의
@Embeddable
@Getter
@NoArgsConstructor(access = AccessLevel.PROTECTED)
public class Address {
    @Column(length = 10)
    private String zipCode;
    
    @Column(length = 100)
    private String city;
    
    @Column(length = 100)
    private String street;
    
    @Column(length = 100)
    private String detail;
    
    public Address(String zipCode, String city, String street, String detail) {
        this.zipCode = zipCode;
        this.city = city;
        this.street = street;
        this.detail = detail;
    }
    
    // 값 타입은 불변으로 설계
    public Address changeDetail(String newDetail) {
        return new Address(this.zipCode, this.city, this.street, newDetail);
    }
}

// 금액 값 타입
@Embeddable
@Getter
@NoArgsConstructor(access = AccessLevel.PROTECTED)
public class Money {
    @Column(precision = 12, scale = 2)
    private BigDecimal amount;
    
    @Column(length = 3)
    private String currency;
    
    public Money(BigDecimal amount, String currency) {
        this.amount = amount;
        this.currency = currency;
    }
    
    public static Money krw(BigDecimal amount) {
        return new Money(amount, "KRW");
    }
    
    public Money add(Money other) {
        if (!this.currency.equals(other.currency)) {
            throw new IllegalArgumentException("통화가 다릅니다");
        }
        return new Money(this.amount.add(other.amount), this.currency);
    }
}

@Entity
public class Customer {
    @Id
    @GeneratedValue(strategy = GenerationType.IDENTITY)
    private Long id;
    
    private String name;
    
    // 임베디드 타입 사용
    @Embedded
    private Address address;
    
    // 같은 타입을 여러 번 사용할 때 컬럼명 재정의
    @Embedded
    @AttributeOverrides({
        @AttributeOverride(name = "zipCode", column = @Column(name = "work_zip_code")),
        @AttributeOverride(name = "city", column = @Column(name = "work_city")),
        @AttributeOverride(name = "street", column = @Column(name = "work_street")),
        @AttributeOverride(name = "detail", column = @Column(name = "work_detail"))
    })
    private Address workAddress;
}

@Entity
public class Order {
    @Id
    @GeneratedValue(strategy = GenerationType.IDENTITY)
    private Long id;
    
    @Embedded
    @AttributeOverrides({
        @AttributeOverride(name = "amount", column = @Column(name = "total_amount")),
        @AttributeOverride(name = "currency", column = @Column(name = "currency"))
    })
    private Money totalPrice;
    
    @Embedded
    private Address shippingAddress;
}

// 생성되는 테이블
// customers: id, name, zip_code, city, street, detail, 
//            work_zip_code, work_city, work_street, work_detail
// orders: id, total_amount, currency, zip_code, city, street, detail

-- 기존 PHP 시스템의 테이블
CREATE TABLE tbl_products (
    product_id BIGINT AUTO_INCREMENT PRIMARY KEY,
    product_name VARCHAR(200) NOT NULL,
    sku VARCHAR(50) NOT NULL UNIQUE,
    price DECIMAL(10,2) NOT NULL,
    discount_price DECIMAL(10,2),
    stock_qty INT DEFAULT 0,
    status VARCHAR(20) DEFAULT 'DRAFT',
    description TEXT,
    created_at DATETIME DEFAULT CURRENT_TIMESTAMP,
    updated_at DATETIME ON UPDATE CURRENT_TIMESTAMP
);

CREATE TABLE tbl_categories (
    category_id BIGINT AUTO_INCREMENT PRIMARY KEY,
    category_name VARCHAR(100) NOT NULL,
    parent_id BIGINT,
    sort_order INT DEFAULT 0,
    is_active TINYINT(1) DEFAULT 1
);

CREATE TABLE tbl_customers (
    customer_id BIGINT AUTO_INCREMENT PRIMARY KEY,
    email VARCHAR(100) NOT NULL UNIQUE,
    name VARCHAR(50) NOT NULL,
    phone VARCHAR(20),
    zip_code VARCHAR(10),
    city VARCHAR(50),
    street VARCHAR(100),
    address_detail VARCHAR(100),
    created_at DATETIME DEFAULT CURRENT_TIMESTAMP
);

// BaseEntity - 공통 필드
@MappedSuperclass
@EntityListeners(AuditingEntityListener.class)
@Getter
public abstract class BaseEntity {
    @CreatedDate
    @Column(name = "created_at", updatable = false)
    private LocalDateTime createdAt;
    
    @LastModifiedDate
    @Column(name = "updated_at")
    private LocalDateTime updatedAt;
}

// Product Entity
@Entity
@Table(name = "tbl_products")
@Getter
@NoArgsConstructor(access = AccessLevel.PROTECTED)
public class Product extends BaseEntity {

    @Id
    @GeneratedValue(strategy = GenerationType.IDENTITY)
    @Column(name = "product_id")
    private Long id;

    @Column(name = "product_name", nullable = false, length = 200)
    private String name;

    @Column(nullable = false, unique = true, length = 50)
    private String sku;

    @Column(nullable = false, precision = 10, scale = 2)
    private BigDecimal price;

    @Column(name = "discount_price", precision = 10, scale = 2)
    private BigDecimal discountPrice;

    @Column(name = "stock_qty", nullable = false)
    private Integer stockQuantity = 0;

    @Enumerated(EnumType.STRING)
    @Column(nullable = false, length = 20)
    private ProductStatus status = ProductStatus.DRAFT;

    @Lob
    private String description;
    
    // 생성 메서드
    public static Product create(String name, String sku, BigDecimal price) {
        Product product = new Product();
        product.name = name;
        product.sku = sku;
        product.price = price;
        product.status = ProductStatus.DRAFT;
        return product;
    }
    
    // 비즈니스 메서드
    public void activate() {
        this.status = ProductStatus.ACTIVE;
    }
    
    public void updatePrice(BigDecimal price, BigDecimal discountPrice) {
        this.price = price;
        this.discountPrice = discountPrice;
    }
}

// Category Entity
@Entity
@Table(name = "tbl_categories")
@Getter
@NoArgsConstructor(access = AccessLevel.PROTECTED)
public class Category {

    @Id
    @GeneratedValue(strategy = GenerationType.IDENTITY)
    @Column(name = "category_id")
    private Long id;

    @Column(name = "category_name", nullable = false, length = 100)
    private String name;

    @Column(name = "parent_id")
    private Long parentId;  // 다음 세션에서 연관관계로 변경

    @Column(name = "sort_order")
    private Integer sortOrder = 0;

    @Column(name = "is_active", nullable = false)
    private Boolean active = true;
}

// Customer Entity with Embedded Address
@Entity
@Table(name = "tbl_customers")
@Getter
@NoArgsConstructor(access = AccessLevel.PROTECTED)
public class Customer extends BaseEntity {

    @Id
    @GeneratedValue(strategy = GenerationType.IDENTITY)
    @Column(name = "customer_id")
    private Long id;

    @Column(nullable = false, unique = true, length = 100)
    private String email;

    @Column(nullable = false, length = 50)
    private String name;

    @Column(length = 20)
    private String phone;

    @Embedded
    @AttributeOverrides({
        @AttributeOverride(name = "zipCode", column = @Column(name = "zip_code")),
        @AttributeOverride(name = "city", column = @Column(name = "city")),
        @AttributeOverride(name = "street", column = @Column(name = "street")),
        @AttributeOverride(name = "detail", column = @Column(name = "address_detail"))
    })
    private Address address;
}