6.1 다대일 (N:1)

6.1.1 다대일, 단방향, [N:1]

SCR-20240905-lxhv

  • @Joincolumn (name = "TEAM_ID")를 사용해서 Member.team 필드를 TEAM_ID 외래 키와 매핑했다.

  • 따라서 Member.team 필드로 회원 테이블의 TEAM_ID 외래키를 관리한다.

6.1.2 다대일, 양방향, [N:1, 1:N]

SCR-20240905-lxum

SCR-20240905-lzaa

SCR-20240905-lzaj

  • 양뱡향은 외래 키가 있는 쪽이 연관관계의 주인이다.
    • 일대다와 다대일 연관관계는 항상 다(N)에 외래 키가 있다.
    • 여기서는 다쪽인 MEMBER 테이블이 외래 키를 가지고 있으므로 Member.team이 연관관계의 주인이다.
    • JPA는 외래 키를 관리할 때 연관관계의 주인만 사용한다.
    • 주인이 아닌 Team.members는 조회를 위한 JPQL이나 객체 그래프를 탐색할 때 사용한다.
  • 양뱡향 연관관계는 항상 서로를 참조해야 한다.
    • 항상 서로 참조하게 하려면 편의 메소드가 있으면 좋다, Ex) 회원의 setTeam(), 팀의 addMember()
    • 양쪽에 다 작성하면 무한루프에 빠지므로 주의해야 한다.

6.2 일대다 (1:N)

6.2.1 일대다, 단방향, [1:N]

SCR-20240905-lzgd

SCR-20240905-madd

SCR-20240905-madr

  • 일대다 단방향 관계는 약간 특이한데, 엔티티의 Team.members로 회원 테이블의 TEAM_ID 외래 키를 관리한다.

  • 보통 자신이 매핑한 테이블의 외래 키를 관리하는데, 이 매핑은 반대쪽 테이블에 있는 외래 키를 관리한다.

    • 그럴 수밖에 없는 것이 일대다 관계에서 외래 키는 항상 다쪽 테이블에 있다.
    • 하지만 다 쪽인 Member 엔티티에는 외래 키를 매핑할 수 있는 참조 필드가 없다.
    • 대신에 반대쪽인 Team 엔티티에만 참조 필드인 members가 있다.
    • 따라서 반대편 테이블의 외래 키를 관리하는 특이한 모습이 나타난다.

  • 일대다 단방향 관계를 매핑할 때는 @JoinColumn을 명시해야 한다.

    • 그렇지 않으면 JPA는 조인 테이블(JoinTable) 전략을 기본으로 사용해서 매핑한다.

[ 일대다 단방향 매핑의 단점 ]

SCR-20240905-mbit

SCR-20240905-mbjc

  • 일대다 단방향 매핑의 단점은 매핑한 객체가 관리하는 외래 키가 다른 테이블에 있다는 점이다.

  • 본인 테이블에 외래 키가 있으면 엔티티의 저장과 연관관계 처리를 INSERT SQL 한 번으로 끝낼 수 있다

  • 하지만, 다른 테이블에 외래 키가 있으면 연관관계 처리를 위한 UPDATE SQL을 추가로 실행해야 한다.

  • 일대다 단방향 매핑보다는 다대일 양방향 매핑을 사용하자

    • 일대다 단방향 매핑을 사용하면 엔티티를 매핑한 테이블이 아닌 다른 테이블의 외래 키를 관리해야 한다.
    • 성능 문제도 있지만 관리도 부담
    • 문제를 해결하는 좋은 방법은 일대다 단방향 매핑 대신에 다대일 양방향 매핑을 사용하는 것이다.

6.2.2 일대다, 양방향, [1:N, N:1]

  • 일대다 양방향 매핑은 존재하지 않는다. 대신 다대일 양방향 매핑을 사용해야 한다

    • 일대다 양방향과 다대일 양방향은 사실 똑같은 말이다.
    • 여기서는 왼쪽을 연관관계의 주인으로 가정해서 분류했다. 예를 들어 다대일이면 다(N)가 연관관계의 주인이다.

  • 더 정확히 말하자면 양방향 매핑에서 @OneToMany는 연관관계의 주인이 될 수 없다.

    • 왜냐하면 관계형 데이터베이스의 특성상 일대다, 다대일 관계는 항상 다쪽에 외래 키가 있다.

  • 따라서 @OneToMany, @ManyToOne 둘 중에 연관관계의 주인은 항상 다 쪽인 @ManyToOne을 사용한 곳이다.

    • 이런 이유로 @ManyToOne에는 mappedBy 속성이 없다.

  • 그렇다고 일대다 양방향 매핑이 완전히 불가능한 것은 아니다.

    • 일대다 단방향 매핑 반대편에 같은 외래 키를 사용하는 다대일 단방향 매핑을 읽기 전용으로 하나 추가하면 된다.

    • 하지만 일대다 단방향 매핑이 가지는 단점을 그대로 가지기 때문에, 될 수 있으면 다대일 양방향 매핑을 사용하자

SCR-20240905-mgse

SCR-20240905-mgxk

6.3 일대일 (1:1)

  • 일대일 관계는 그 반대도 일대일 관계다.
  • 테이블 관계에서 일대다, 다대일은 항상 다(N)쪽이 외래 키를 가진다.
    • 반면에 일대일 관계는 주 테이블이나 대상 테이블 둘 중 어느 곳이나 외래 키를 가질 수 있다.
    • 따라서 일대일 관계는 주 테이블이나 대상 테이블 중에 누가 외래 키를 가질지 선택해야 한다.

6.3.1 주 테이블에 외래 키

일대일 관계를 구성할 때 객체지향 개발자들은 주 테이블에 외래 키가 있는 것을 선호한다.

JPA도 주 테이블에 외래 키가 있으면 좀 더 편리하게 매핑할 수 있다.

단방향

SCR-20240905-oclf

SCR-20240905-ocyv

  • 일대일 관계이므로 객체 매핑에 @OneToOne을 사용했고 데이터베이스에는 LOCKER_ID 외래 키에 유니크 제약 조건(UNI) 을 추가했다.
    • 이 관계는 다대일 단방향(@ManyToOne)과 거의 비슷하다.

양방향

SCR-20240905-ocmr

SCR-20240905-odfe

SCR-20240905-odgk

  • 양방향이므로 연관관계의 주인을 정해야 한다.
  • MEMBER 테이블이 외래 키를 가지고 있으므로 Member 엔티티에 있는 Member.locker가 연관관계의 주인이다.
  • 따라서 반대 매핑인 사물함의 Locker.member는 mappedBy를 선언해서 연관관계의 주인이 아니라고 설정

6.3.2 대상 테이블에 외래 키

단방향

SCR-20240905-oehd

양방향

SCR-20240905-oejm

SCR-20240905-oerx

  • 일대일 매핑에서 대상 테이블에 외래 키를 두고 싶으면 이렇게 양방향으로 매핑한다.
  • 주 엔티티인 Member 엔티티 대신에 대상 엔티티인 Locker를 연관관계의 주인으로 만들어서, LOCKER 테이블의 외래 키를 관리

6.4 다대다 (N:M)

SCR-20240905-ofeb

SCR-20240905-ofeq

관계형 데이터베이스는 정규화된 테이블 2개로 다대다 관계를 표현할 수 없다.

그래서 보통 다대다 관계를 일대다, 다대일 관계로 풀어내는 연결 테이블을 사용한다.

예를 들어 회원들은 상품을 주문한다. 반대로 상품들은 회원들에 의해 주문된다.

둘은 다대다 관계다. 따라서 회원 테이블과 상품 테이블만으로는 이 관계를 표현할 수 없다.

SCR-20240905-ofgn

그런데 객체는 테이블과 다르게 객체 2개로 다대다 관계를 만들 수 있다.

회원 객체는 컬렉션을 사용해서 상품들을 참조하면 되고 반대로 상품들도 컬렉션을 사용해서 회원들을 참조하면 된다.

@ManyToMany를 사용하면 다대다 관계를 편리하게 매핑할 수 있다.

6.4.1 다대다: 단방향

SCR-20240905-oghn

SCR-20240905-oghy

SCR-20240905-ogmi

회원 엔티티와 상품 엔티티를 @ManyToMany로 매핑했다.

중요한 점은 @ManyToMany와 @JoinTable을 사용해서 연결 테이블을 바로 매핑한 것이다.

따라서 회원과 상품을 연결하는 회원_상품(Member_Product) 엔티티 없이 매핑을 완료할수 있다.

@ManyToMany로 매핑한 덕분에 다대다 관계를 사용할 때는 이 연결 테이블을 신경 쓰지 않아도 된다.

[ 연결 테이블을 매핑하는 @JoinTable의 속성 ]

  • @JoinTable.name: 연결 테이블을 지정한다. 여기서는 MEMBER_PRODUCT 테이블을 선택
  • @JoinTable.joinColumns: 현재 방향인 회원과 매핑할 조인 컬럼 정보를 지정한다. MEMBER_ID로 지정
  • @JoinTable.inversejoinColumns: 반대 방향인 상품과 매핑할 조인 컬럼 정보를 지정한다. PRODUCT_ID로 지정

6.4.2 다대다: 양방향

SCR-20240905-ohwa

6.4.3 다대다: 매핑의 한계와 극복, 연결 엔티티 사용

SCR-20240905-oibq

@ManyToMany를 사용하면 연결 테이블을 자동으로 처리해주므로 도메인 모델이 단순해지고 여러 가지로 편리하다.

하지만 이 매핑을 실무에서 사용하기에는 한계가 있다. 회원이 상품을 주문하면 연결 테이블에 단순히 주문한 회원 아이디와 상품 아이디만 담고 끝나지 않는다.

보통은 연결 테이블에 주문 수량 컬럼이나 주문한 날짜 같은 컬럼이 더 필요하다.

SCR-20240905-oipf

결국, 연결 테이블을 매핑하는 연결 엔티티를 만들고 이곳에 추가한 컬럼들을 매핑해야 한다.

그리고 엔티티 간의 관계도 테이블 관계처럼 다대다에서 일대다, 다대일 관계로 풀어야 한다.

여기서는 회원상품(MemberProduct) 엔티티를 추가했다.

SCR-20240905-oium

SCR-20240905-oivs

회원상품(MemberProduct) 엔티티를 보면, 기본 키를 매핑하는 @Id 와 외래 키를 매핑하는 @JoinColumn을 동시에 사용해서 기본 키 + 외래 키를 한번에 매핑했다.

그리고 @Idclass를 사용해서 복합 기본 키를 매핑했다.

복합 기본 키

회원상품 엔티티는 기본 키가 MEMBER_ID와 PRODUCT_ID로 이루어진 복합 기본 키(=복합 키)

JPA에서 복합 키를 사용하려면 별도의 식별자 클래스를 만들어야 한다.

그리고 엔티티에 @IdClass를 사용해서 식별자 클래스를 지정하면 된다.

MemberProductId 클래스를 복합 키를 위한 식별자 클래스로 사용한다.

[ 복합 키를 위한 식별자 클래스 특징 ]

  • 복합 키는 별도의 식별자 클래스로 만들어야 한다.
  • Serializable을 구현해야 한다.
  • equals와 hashCode 메소드를 구현해야 한다.
  • 기본 생성자가 있어야 한다.
  • 식별자 클래스는 public이어야 한다.
  • @ldClass를 사용하는 방법 외에 @EmbeddedId를 사용하는 방법도 있다.

회원상품(MemberProduct) 은 회원과 상품의 기본 키를 받아서 자신의 기본 키로 사용한다.

이렇게 부모 테이블의 기본 키를 받아서 자신의 기본 키 + 외래 키로 사용하는 것을 식별 관계 (Identifying Relationship) 라 한다.

SCR-20240905-okye

SCR-20240905-olcu

지금까지는 기본 키가 단순해서 기본 키를 위한 객체를 사용하는 일이 없었지만 복합 키가 되면 이야기가 달라진다.

복합 키는 항상 식별자 클래스를 만들어야한다. em.find()를 보면 생성한 식별자 클래스로 엔티티를 조회한다.

복합 키를 사용하는 방법은 복잡하다. 복합 키를 사용하면 ORM 매핑에서 처리할 일이 상당히 많아진다.

6.4.4 다대다: 새로운 기본 키 사용

SCR-20240905-olwj

추천하는 기본 키 생성 전략은 데이터베이스에서 자동으로 생성해주는 대리 키를 Long 값으로 사용하는 것이다.

장점은 간편하고 거의 영구히 쓸 수 있으며, 비즈니스에 의존하지 않는다.

또한 ORM 매핑 시에 복합 키를 만들지 않아도 되므로 간단히 매핑을 완성할 수 있다.

SCR-20240905-ombw

SCR-20240905-ombi

SCR-20240905-ombw

SCR-20240905-omks

식별자 클래스를 사용하지 않아서 코드가 한결 단순해짐

이처럼 새로운 기본 키를 사용해서 다대다 관계를 풀어내는 것도 좋은 방법

6.4.5 다대다 연관관계 정리

  • 식별 관계: 받아온 식별자를 기본 키 + 외래 키로 사용한다.
  • 비식별 관계: 받아온 식별자는 외래 키로만 사용하고 새로운 식별자를 추가한다.
    • 식별자 클래스를 만들지 않아도 편리하게 ORM 매핑 가능
    • 이런 이유로 식별 관계보다는 비식별 관계를 추천

6.5 활용 (Kotlin)

요구 사항 분석 및 설계

SCR-20240909-migk

SCR-20240909-mihg

Code

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16

// build.gradle.kts에 아래 설정이 있다고 가정
// Kotlin으로 JPA을 쉽게 사용하기 위한 설정

plugins {
    kotlin("plugin.jpa") version "1.9.24"
}

allOpen {
    annotation("jakarta.persistence.Entity")
    annotation("jakarta.persistence.Embeddable")
    annotation("jakarta.persistence.MappedSuperclass")
}

noArg {
	annotation("jakarta.persistence.Entity")
}

  1
  2
  3
  4
  5
  6
  7
  8
  9
 10
 11
 12
 13
 14
 15
 16
 17
 18
 19
 20
 21
 22
 23
 24
 25
 26
 27
 28
 29
 30
 31
 32
 33
 34
 35
 36
 37
 38
 39
 40
 41
 42
 43
 44
 45
 46
 47
 48
 49
 50
 51
 52
 53
 54
 55
 56
 57
 58
 59
 60
 61
 62
 63
 64
 65
 66
 67
 68
 69
 70
 71
 72
 73
 74
 75
 76
 77
 78
 79
 80
 81
 82
 83
 84
 85
 86
 87
 88
 89
 90
 91
 92
 93
 94
 95
 96
 97
 98
 99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167

package ~~

import jakarta.persistence.*
import java.util.Date

@Entity
class Member(
    name: String,
    street: String,
    zipcode: String
) {
    @Id
    @GeneratedValue
    @Column(name = "MEMBER_ID")
    var id: Long? = null
        protected set
    var name = name
        protected set
    var street = street
        protected set
    var zipcode = zipcode
        protected set

    @OneToMany(mappedBy = "member")
    val orders: MutableList<Order> = mutableListOf()
}

enum class OrderStatus { ORDER, CANCEL }
enum class DeliveryStatus { READY, COMP }


@Entity
@Table(name = "DELIVERY")
class Delivery(
    zipcode: String,
    status: DeliveryStatus
) {
    @Id
    @GeneratedValue
    @Column(name = "DELIVERY_ID")
    var id: Long? = null
        protected set

    var zipcode = zipcode
        protected set

    @Enumerated(EnumType.STRING)
    var status: DeliveryStatus = status
        protected set

    @OneToOne(mappedBy = "delivery")
    var order: Order? = null
        protected set

    fun associateWithOrder(order: Order) {
        this.order = order
    }
}

@Entity
@Table(name = "ORDERS")
class Order(
    member: Member,
    orderDate: Date,
    status: OrderStatus
) {
    @Id
    @GeneratedValue
    @Column(name = "ORDER_ID")
    var id: Long? = null
        protected set

    @Column(name = "MEMBER_ID")
    var memberId: Long? = null
        protected set

    @Temporal(TemporalType.TIMESTAMP)
    var orderDate: Date = orderDate
        protected set

    @Enumerated(EnumType.STRING)
    var status: OrderStatus = status
        protected set

    @ManyToOne
    @JoinColumn(name = "MEMBER_ID")
    var member: Member? = member
        protected set

    @OneToMany(mappedBy = "order")
    val orderItems: MutableList<OrderItem> = mutableListOf()

    @OneToOne
    @JoinColumn(name = "DELIVERY_ID")
    var delivery: Delivery? = null
        protected set

    fun settingMember(member: Member) {
        this.member?.let { it.orders.remove(this) }
        this.member = member
        member.orders.add(this)
    }

    fun addOrderItem(orderItem: OrderItem) {
        orderItem.order?.let { it.orderItems.remove(orderItem) }
        orderItems.add(orderItem)
        orderItem.associateWithOrder(this)
    }

    fun settingDelivery(delivery: Delivery) {
        this.delivery = delivery
        delivery.associateWithOrder(this)
    }

}

@Entity
class OrderItem(
    orderPrice: Int,
    count: Int
) {
    @Id
    @GeneratedValue
    @Column(name = "ORDER_ITEM_ID")
    var id: Long? = null
        protected set

    @Column(name = "ITEM_ID")
    var itemID: Long? = null
        protected set

    var orderPrice: Int = orderPrice
        protected set

    var count: Int = count
        protected set

    @ManyToOne
    @JoinColumn(name = "ORDER_ID")
    var order: Order? = null
        protected set

    fun associateWithOrder(order: Order) {
        this.order = order
    }
}

@Entity
class Item(
    name: String,
    price: Int,
    stockQuantity: Int
) {
    @Id
    @GeneratedValue
    @Column(name = "ITEM_ID")
    var id: Long? = null

    var name: String = name
        protected set

    var price: Int = price
        protected set

    var stockQuantity: Int = stockQuantity
        protected set
}

Reference