[JPA] 연관관계 매핑
Updated:
1. 개요
테이블은 외래키(FK)를 통해 관계를 맺지만, 객체는 참조를 통해 관계를 맺기 때문에 차이가 있다. 이번에는 객체의 참조를 사용하는 연관관계 매핑에 대해 알아보도록 하자.
2. 연관관계 방향
DB 테이블은 하나의 외래 키로 조인을 통해 양쪽 모두 접근이 가능하여 따로 방향이라는 개념이 존재하지 않는다. 하지만 객체는 참조용 필드가 있는 쪽으로만 참조가 가능한데, 한쪽만 참조하면 단방향, 양쪽이 서로 참조하면 양방향 연관관계라고 한다.
2-1. 단방향 연관관계
객체 A와 객체 B가 있을 때, A → B 또는 B → A 둘 중 한 방향으로만 참조가 가능한 연관관계를 단방향 연관관계라고 한다. @ManyToOne, @ManyToMany, @OneToOne, @OneToMany 중 해당 테이블 기준으로 관계를 설정하고, @JoinColumn을 통해 어느 컬럼을 매핑할지 설정하면 된다.
2-1-1. 예제 코드
[Member.java]
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
@Entity
public class Member {
@Id @GeneratedValue
@Column(name = "MEMBER_ID")
private Long id;
@Column(name = "USERNAME")
private String username;
@ManyToOne
@JoinColumn(name = "TEAM_ID")
private Team team;
public Long getId() {
return id;
}
public void setId(Long id) {
this.id = id;
}
public String getUsername() {
return username;
}
public void setUsername(String username) {
this.username = username;
}
public Team getTeam() {
return team;
}
public void setTeam(Team team) {
this.team = team;
}
}
Line 11 ~ 13 : 다대일 관계이고, TEAM_ID 컬럼과 연결되는 필드 정의
[Team.java]
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
@Entity
public class Team {
@Id @GeneratedValue
@Column(name = "TEAM_ID")
private Long id;
private String name;
public Long getId() {
return id;
}
public void setId(Long id) {
this.id = id;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
}
[JpaMain.java]
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
public class JpaMain {
public static void main(String[] args) {
EntityManagerFactory emf = Persistence.createEntityManagerFactory("hello");
EntityManager em = emf.createEntityManager();
EntityTransaction tx = em.getTransaction();
tx.begin();
try {
Team team = new Team();
team.setName("TeamA");
em.persist(team);
Member member = new Member();
member.setUsername("member1");
member.setTeam(team);
em.persist(member);
tx.commit();
} catch (Exception e) {
tx.rollback();
} finally {
em.close();
}
emf.close();
}
}
2-1-2. 실행 결과
2-2. 양방향 연관관계
객체 A와 객체 B가 있을 때, A → B, B → A 양방향으로 참조가 가능한 연관관계를 양방향 연관관계라고 하는데, 실제로는 단방향 연관관계가 두 개 있는 것이라고 보면된다. @ManyToOne, @ManyToMany, @OneToOne, @OneToMany 중 해당 테이블 기준으로 관계를 설정하는 것 까지는 동일하지만, 양방향 연관관계에서는 연관관계의 주인을 설정해줘야 한다.
일반적으로 외래키를 갖는 테이블을 연관관계의 주인으로 정한다. 연관관계 주인은 등록, 수정이 가능하고, 연관관계 주인이 아닌 쪽은 읽기만 가능하다. 연관관계 주인은 @JoinColumn을 통해 어느 컬럼을 매핑할지 설정하고, 연관관계 주인이 아닌 쪽은 mappedBy 속성으로 주인이 아님을 명시해야 한다.
연관관계 주인과 주인이 아닌 쪽의 데이터가 동일해야 하는데, 따로따로 넣으면 누락되는 상황이 생길 수 있으므로 연관관계 편의 메서드를 통해 한 쪽에 값을 넣을 때 다른 쪽에도 값을 같이 넣어준다.
1
2
3
4
public void changeTeam(Team team) {
this.team = team;
team.getMembers().add(this);
}
2-2-1. 소스 코드
[Member.java]
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
@Entity
public class Member {
@Id @GeneratedValue
@Column(name = "MEMBER_ID")
private Long id;
@Column(name = "USERNAME")
private String username;
@ManyToOne
@JoinColumn(name = "TEAM_ID")
private Team team;
public Long getId() {
return id;
}
public void setId(Long id) {
this.id = id;
}
public String getUsername() {
return username;
}
public void setUsername(String username) {
this.username = username;
}
public Team getTeam() {
return team;
}
public void setTeam(Team team) {
this.team = team;
}
public void changeTeam(Team team) {
this.team = team;
team.getMembers().add(this);
}
}
Line 11 ~ 13 : 다대일 관계이고, TEAM_ID 컬럼과 연결되는 필드 정의
Line 39 ~ 42 : 연관관계 편의 메서드 정의
[Team.java]
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
@Entity
public class Team {
@Id @GeneratedValue
@Column(name = "TEAM_ID")
private Long id;
private String name;
@OneToMany(mappedBy = "team")
private List<Member> members = new ArrayList<>();
public Long getId() {
return id;
}
public void setId(Long id) {
this.id = id;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public List<Member> getMembers() {
return members;
}
public void setMembers(List<Member> members) {
this.members = members;
}
}
Line 10 ~ 11 : mappedBy 속성을 통해 연관관계 주인이 아님을 명시
[JpaMain.java]
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
public class JpaMain {
public static void main(String[] args) {
EntityManagerFactory emf = Persistence.createEntityManagerFactory("hello");
EntityManager em = emf.createEntityManager();
EntityTransaction tx = em.getTransaction();
tx.begin();
try {
Team team = new Team();
team.setName("TeamA");
em.persist(team);
Member member = new Member();
member.setUsername("member1");
member.changeTeam(team);
em.persist(member);
Team findTeam = em.find(Team.class, team.getId());
List<Member> members = findTeam.getMembers();
System.out.println("============");
for (Member m : members) {
System.out.println("member = " + m.getUsername());
}
System.out.println("============");
tx.commit();
} catch (Exception e) {
tx.rollback();
} finally {
em.close();
}
emf.close();
}
}
Line 17 : 연관관계 편의 메서드를 통해 양쪽 모두에 값을 넣어줌
2-2-2. 실행 결과
3. 다중성
3-1. 다대일 (N:1)
3-1-1. 다대일 단방향
3-1-1-1. 소스 코드
[Member.java]
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
@Entity
public class Member {
@Id @GeneratedValue
@Column(name = "MEMBER_ID")
private Long id;
@Column(name = "USERNAME")
private String username;
@ManyToOne
@JoinColumn(name = "TEAM_ID")
private Team team;
public Long getId() {
return id;
}
public void setId(Long id) {
this.id = id;
}
public String getUsername() {
return username;
}
public void setUsername(String username) {
this.username = username;
}
public Team getTeam() {
return team;
}
public void setTeam(Team team) {
this.team = team;
}
}
Line 11 ~ 13 : 다대일 관계이고, TEAM_ID 컬럼과 연결되는 필드 정의
[Team.java]
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
@Entity
public class Team {
@Id @GeneratedValue
@Column(name = "TEAM_ID")
private Long id;
private String name;
public Long getId() {
return id;
}
public void setId(Long id) {
this.id = id;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
}
[JpaMain.java]
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
public class JpaMain {
public static void main(String[] args) {
EntityManagerFactory emf = Persistence.createEntityManagerFactory("hello");
EntityManager em = emf.createEntityManager();
EntityTransaction tx = em.getTransaction();
tx.begin();
try {
Team team = new Team();
team.setName("TeamA");
em.persist(team);
Member member = new Member();
member.setUsername("member1");
member.setTeam(team);
em.persist(member);
tx.commit();
} catch (Exception e) {
tx.rollback();
} finally {
em.close();
}
emf.close();
}
}
3-1-1-2. 실행 결과
3-1-2. 다대일 양방향
3-1-2-1. 소스 코드
[Member.java]
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
@Entity
public class Member {
@Id @GeneratedValue
@Column(name = "MEMBER_ID")
private Long id;
@Column(name = "USERNAME")
private String username;
@ManyToOne
@JoinColumn(name = "TEAM_ID")
private Team team;
public Long getId() {
return id;
}
public void setId(Long id) {
this.id = id;
}
public String getUsername() {
return username;
}
public void setUsername(String username) {
this.username = username;
}
public Team getTeam() {
return team;
}
public void setTeam(Team team) {
this.team = team;
}
public void changeTeam(Team team) {
this.team = team;
team.getMembers().add(this);
}
}
Line 11 ~ 13 : 다대일 관계이고, TEAM_ID 컬럼과 연결되는 필드 정의
Line 39 ~ 42 : 연관관계 편의 메서드 정의
[Team.java]
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
@Entity
public class Team {
@Id @GeneratedValue
@Column(name = "TEAM_ID")
private Long id;
private String name;
@OneToMany(mappedBy = "team")
private List<Member> members = new ArrayList<>();
public Long getId() {
return id;
}
public void setId(Long id) {
this.id = id;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public List<Member> getMembers() {
return members;
}
public void setMembers(List<Member> members) {
this.members = members;
}
}
Line 10 ~ 11 : mappedBy 속성을 통해 연관관계 주인이 아님을 명시
[JpaMain.java]
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
public class JpaMain {
public static void main(String[] args) {
EntityManagerFactory emf = Persistence.createEntityManagerFactory("hello");
EntityManager em = emf.createEntityManager();
EntityTransaction tx = em.getTransaction();
tx.begin();
try {
Team team = new Team();
team.setName("TeamA");
em.persist(team);
Member member = new Member();
member.setUsername("member1");
member.changeTeam(team);
em.persist(member);
Team findTeam = em.find(Team.class, team.getId());
List<Member> members = findTeam.getMembers();
System.out.println("============");
for (Member m : members) {
System.out.println("member = " + m.getUsername());
}
System.out.println("============");
tx.commit();
} catch (Exception e) {
tx.rollback();
} finally {
em.close();
}
emf.close();
}
}
Line 17 : 연관관계 편의 메서드를 통해 양쪽 모두에 값을 넣어줌
3-1-2-2. 실행 결과
3-2. 일대다 (1:N)
3-2-1. 일대다 단방향
일대다 단방향은 일(1)이 연관관계의 주인이다. 테이블에는 항상 다(N) 쪽에 외래 키가 있는데, 엔티티가 관리하는 외래 키가 다른 테이블에 있고, 추가로 UPDATE 문이 호출된다는 단점이 있다. @JoinColumn을 사용하지 않으면 조인 테이블 전략을 사용하게 되므로 일대다 단방향에서 반드시 @JoinColumn을 사용해야 한다.
3-2-1-1. 소스 코드
[Member.java]
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
@Entity
public class Member {
@Id @GeneratedValue
@Column(name = "MEMBER_ID")
private Long id;
@Column(name = "USERNAME")
private String username;
public Long getId() {
return id;
}
public void setId(Long id) {
this.id = id;
}
public String getUsername() {
return username;
}
public void setUsername(String username) {
this.username = username;
}
}
[Team.java]
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
@Entity
public class Team {
@Id @GeneratedValue
@Column(name = "TEAM_ID")
private Long id;
private String name;
@OneToMany
@JoinColumn(name = "TEAM_ID")
private List<Member> members = new ArrayList<>();
public Long getId() {
return id;
}
public void setId(Long id) {
this.id = id;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public List<Member> getMembers() {
return members;
}
public void setMembers(List<Member> members) {
this.members = members;
}
}
Line 11 : @JoinColumn을 통해 어느 컬럼과 매핑되는지 지정해줘야 한다.
[JpaMain.java]
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
public class JpaMain {
public static void main(String[] args) {
EntityManagerFactory emf = Persistence.createEntityManagerFactory("hello");
EntityManager em = emf.createEntityManager();
EntityTransaction tx = em.getTransaction();
tx.begin();
try {
Member member = new Member();
member.setUsername("member1");
em.persist(member);
Team team = new Team();
team.setName("teamA");
team.getMembers().add(member);
em.persist(team);
tx.commit();
} catch (Exception e) {
tx.rollback();
e.printStackTrace();
} finally {
em.close();
}
emf.close();
}
}
3-2-1-2. 실행 결과
3-2-2. 일대다 양방향
공식적으로 지원하지 않는 매핑 방식이다. @JoinColumn의 insertable, updateable을 false로 설정해서 양방향 처럼 사용할 수는 있다.
3-2-2-1. 소스 코드
[Member.java]
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
@Entity
public class Member {
@Id @GeneratedValue
@Column(name = "MEMBER_ID")
private Long id;
@Column(name = "USERNAME")
private String username;
@ManyToOne
@JoinColumn(name = "TEAM_ID", insertable = false, updatable = false)
private Team team;
public Long getId() {
return id;
}
public void setId(Long id) {
this.id = id;
}
public String getUsername() {
return username;
}
public void setUsername(String username) {
this.username = username;
}
public Team getTeam() {
return team;
}
public void setTeam(Team team) {
this.team = team;
}
}
[Team.java]
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
@Entity
public class Team {
@Id @GeneratedValue
@Column(name = "TEAM_ID")
private Long id;
private String name;
@OneToMany
@JoinColumn(name = "TEAM_ID")
private List<Member> members = new ArrayList<>();
public Long getId() {
return id;
}
public void setId(Long id) {
this.id = id;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public List<Member> getMembers() {
return members;
}
public void setMembers(List<Member> members) {
this.members = members;
}
}
Line 11 : @JoinColumn을 통해 어느 컬럼과 매핑되는지 지정해줘야 한다.
[JpaMain.java]
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
public class JpaMain {
public static void main(String[] args) {
EntityManagerFactory emf = Persistence.createEntityManagerFactory("hello");
EntityManager em = emf.createEntityManager();
EntityTransaction tx = em.getTransaction();
tx.begin();
try {
Member member = new Member();
member.setUsername("member1");
em.persist(member);
Team team = new Team();
team.setName("teamA");
team.getMembers().add(member);
em.persist(team);
tx.commit();
} catch (Exception e) {
tx.rollback();
e.printStackTrace();
} finally {
em.close();
}
emf.close();
}
}
3-2-2-2. 실행 결과
3-3. 일대일 (1:1)
일대일 관계는 주 테이블이나 대상 테이블 중 어디에 외래키를 놓을지 선택 가능하다.
3-3-1. 일대일 단방향
다대일 단방향 매핑과 동일한 방식으로 매핑하면 된다.
3-3-1-1. 소스 코드
[Member.java]
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
@Entity
public class Member {
@Id @GeneratedValue
@Column(name = "MEMBER_ID")
private Long id;
@Column(name = "USERNAME")
private String username;
@OneToOne
@JoinColumn(name = "LOCKER_ID")
private Locker locker;
public Long getId() {
return id;
}
public void setId(Long id) {
this.id = id;
}
public String getUsername() {
return username;
}
public void setUsername(String username) {
this.username = username;
}
public Locker getLocker() {
return locker;
}
public void setLocker(Locker locker) {
this.locker = locker;
}
}
Line 11 ~ 13 : @OneToOne을 통해 일대일 관계를 설정하고, @JoinColumn을 통해 어느 컬럼과 매핑할지 지정
[Locker.java]
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
@Entity
public class Locker {
@Id @GeneratedValue
private Long id;
private String name;
public Long getId() {
return id;
}
public void setId(Long id) {
this.id = id;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
}
[JpaMain.java]
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
public class JpaMain {
public static void main(String[] args) {
EntityManagerFactory emf = Persistence.createEntityManagerFactory("hello");
EntityManager em = emf.createEntityManager();
EntityTransaction tx = em.getTransaction();
tx.begin();
try {
Locker locker = new Locker();
locker.setName("locker1");
em.persist(locker);
Member member = new Member();
member.setUsername("member1");
member.setLocker(locker);
em.persist(member);
tx.commit();
} catch (Exception e) {
tx.rollback();
e.printStackTrace();
} finally {
em.close();
}
emf.close();
}
}
3-3-1-2. 실행 결과
3-3-2. 일대일 양방향
다대일 단방향 매핑과 동일한 방식으로 매핑하면 된다.
3-3-2-1. 소스 코드
[Member.java]
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
@Entity
public class Member {
@Id @GeneratedValue
@Column(name = "MEMBER_ID")
private Long id;
@Column(name = "USERNAME")
private String username;
@OneToOne
@JoinColumn(name = "LOCKER_ID")
private Locker locker;
public Long getId() {
return id;
}
public void setId(Long id) {
this.id = id;
}
public String getUsername() {
return username;
}
public void setUsername(String username) {
this.username = username;
}
public Locker getLocker() {
return locker;
}
public void setLocker(Locker locker) {
this.locker = locker;
}
public void changeLocker(Locker locker) {
this.locker = locker;
locker.setMember(this);
}
}
Line 11 ~ 13 : @OneToOne을 통해 일대일 관계를 설정하고, @JoinColumn을 통해 어느 컬럼과 매핑할지 지정
Line 39 ~ 42 : 연관관계 편의 메서드 지정
[Locker.java]
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
@Entity
public class Locker {
@Id @GeneratedValue
private Long id;
private String name;
@OneToOne(mappedBy = "locker")
private Member member;
public Long getId() {
return id;
}
public void setId(Long id) {
this.id = id;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public Member getMember() {
return member;
}
public void setMember(Member member) {
this.member = member;
}
}
Line 9 : mappedBy 속성을 통해 연관관계 주인이 아님을 명시
[JpaMain.java]
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
public class JpaMain {
public static void main(String[] args) {
EntityManagerFactory emf = Persistence.createEntityManagerFactory("hello");
EntityManager em = emf.createEntityManager();
EntityTransaction tx = em.getTransaction();
tx.begin();
try {
Locker locker = new Locker();
locker.setName("locker1");
em.persist(locker);
Member member = new Member();
member.setUsername("member1");
member.setLocker(locker);
em.persist(member);
tx.commit();
} catch (Exception e) {
tx.rollback();
e.printStackTrace();
} finally {
em.close();
}
emf.close();
}
}
3-3-2-2. 실행 결과
3-4. 다대다 (N:M)
객체는 컬렉션을 통해 객체 2개로 다대다 관계를 표현할 수 있지만, DB는 다대다 관계를 표현할 수 없다. 따라서 일대다, 다대일 관계로 풀어내야 한다. JPA에서 @ManyToMany로 연결 테이블을 지정하여 다대다 관계를 설정할 수 있지만, @ManyToOne, @OneToMany를 사용하도록 하자.
Leave a comment