[JPA] 연관관계 매핑

목차

• 연관관계가 필요한 이유
• 단방향 연관관계
• 객체와 테이블이 관계를 맺는 차이
• 연관관계의 주인(Owner)
• 양방향 매핑시 가장 많이 하는 실수

 

연관관계가 필요한 이유

예제 시나리오

• 회원과 팀이 있다. 
• 회원은 하나의 팀에만 소속될 수 있다. 
• 회원과 팀은 다대일 관계다.

 

객체를 테이블에 맞추어 모델링 예시

 

1. 연관관계가 없는 객체

 

2. 참조 대신에 외래 키를 그대로 사용

@Entity
public class Member { 
    
    @Id @GeneratedValue
    private Long id;
    
    @Column(name = "USERNAME")
    private String name;
    
    @Column(name = "TEAM_ID")
    private Long teamId; 
    … 
} 

@Entity
public class Team {

    @Id @GeneratedValue
    private Long id;
    
    private String name; 
    … 
}

 

3. 외래 키 식별자를 직접 다룸

//팀 저장
Team team = new Team();
team.setName("TeamA");
em.persist(team);
 
//회원 저장
Member member = new Member();
member.setName("member1");
member.setTeamId(team.getId());
em.persist(member);

 

 

4. 식별자로 다시 조회, 객체 지향적인 방법은 아니다.

//조회
Member findMember = em.find(Member.class, member.getId());
 
//연관관계가 없음
Team findTeam = em.find(Team.class, team.getId());

 

 

 

객체를 테이블에 맞추어 데이터 중심으로 모델링하면, 협력 관계를 만들 수 없다.

• 테이블은 외래 키로 조인을 사용해서 연관된 테이블을 찾는다. 
• 객체는 참조를 사용해서 연관된 객체를 찾는다. 
• 테이블과 객체 사이에는 이런 큰 간격이 있다.

 

 

 

단방향 연관관계

 

객체 지향 모델링 예시

 

1. 객체 연관관계 사용

 

 

2. 객체의 참조와 테이블의 외래 키를 매핑

@Entity
public class Member { 
    
    @Id @GeneratedValue
    private Long id;
    
    @Column(name = "USERNAME")
    private String name;
    
    private int age;
    
   // @Column(name = "TEAM_ID")
   // private Long teamId;
   
    @ManyToOne
    @JoinColumn(name = "TEAM_ID")
    private Team team;
    …
}

 

 

 

3. ORM 매핑

 

 

 

4. 연관관계 저장

//팀 저장
Team team = new Team();
team.setName("TeamA");
em.persist(team);
 
//회원 저장
Member member = new Member();
member.setName("member1");
member.setTeam(team); //단방향 연관관계 설정, 참조 저장
em.persist(member);

 

 

5. 참조로 연관관계 조회 - 객체 그래프 탐색

//조회
Member findMember = em.find(Member.class, member.getId()); 
 
//참조를 사용해서 연관관계 조회
Team findTeam = findMember.getTeam();

 

 

6. 연관관계 수정

// 새로운 팀B
Team teamB = new Team();
teamB.setName("TeamB");
em.persist(teamB);

// 회원1에 새로운 팀B 설정
member.setTeam(teamB);

 

 

 

 

양방향 연관관계와 연관관계의 주인

양방향 매핑

• 중요한 점은 테이블의 연관관계는 외래 키 하나로 양방향이 다 있는 것이다.
• 테이블에서는 JOIN을 통해 TEAM에 속한 MEMBER들을 찾을 수 있지만 객체의 단 방향 연관관계에서는 찾지 못한다.
• 쉽게 말하면 Member에 Team을 가지고 있어 Team에 접근할 수 있지만, Team에서 Member로는 가지 못한다.
• 다시말해 Team에서 members를 넣어주어야 접근이 가능하다는 말이다.

 

1. Member 엔티티는 단방향과 동일

@Entity
public class Member { 
    @Id @GeneratedValue
    private Long id;
    
    @Column(name = "USERNAME")
    private String name;
    
    private int age;
    
    @ManyToOne
    @JoinColumn(name = "TEAM_ID")
    private Team team;
    …
}

 

 

2. Team 엔티티는 컬렉션 추가

@Entity
public class Team {

    @Id @GeneratedValue
    private Long id;
    
    private String name;
    
    @OneToMany(mappedBy = "team")
    List<Member> members = new ArrayList<Member>(); // 관례: 필드에서 초기화
    … 
}

 

 

3. 반대 방향으로 객체 그래프 탐색

//조회
Team findTeam = em.find(Team.class, team.getId()); 
int memberSize = findTeam.getMembers().size(); //역방향 조회

 

 

연관관계의 주인과 mappedBy

• mappedBy = JPA의 멘탈붕괴 난이도
• mappedBy는 처음에는 이해하기 어렵다. 
• 객체와 테이블간에 연관관계를 맺는 차이를 이해해야 한다.

 

 

객체와 테이블이 관계를 맺는 차이

객체 연관관계 = 2개

• 회원 => 팀 연관관계 1개(단방향) 
• 팀 => 회원 연관관계 1개(단방향) 

테이블 연관관계 = 1개

• 회원 <=> 팀의 연관관계 1개(양방향)

 

사실 객체 연관관계는 멤버 => 팀으로 가는 연관관계(단방향), 팀 => 멤버(단방향) 으로 가는 연관관계

단방향 연관관계가 2개 있는 것이다.

이와 반대로 테이블에는 외래 키로 조인해서 양쪽의 연관관계를 알 수 있다.

반대로 객체 세상에서는 Member, Team에 참조가 둘다 있어야 한다. (차이점)

이것이 테이블과 객체의 패러다임 차이다.

 

 

 

 

 

객체의 양방향 관계

• 객체의 양방향 관계는 사실 양방향 관계가 아니라 서로 다른 단뱡향 관계 2개다.
• 객체를 양방향으로 참조하려면 단방향 연관관계를 2개 만들어야 한다. 
• A -> B (a.getB())
• B -> A (b.getA())

class A {
    B b; 
    }
    
class B {
    A a;
    }

 

 

 

테이블의 양방향 연관관계

• 테이블은 외래 키 하나로 두 테이블의 연관관계를 관리
• MEMBER.TEAM_ID 외래 키 하나로 양방향 연관관계 가짐 (양쪽으로 조인할 수 있다.)

SELECT * 
FROM MEMBER M
JOIN TEAM T ON M.TEAM_ID = T.TEAM_ID 

SELECT * 
FROM TEAM T
JOIN MEMBER M ON T.TEAM_ID = M.TEAM_ID

• 위 두개의 쿼리문이 외래 키 하나로 만들 수 있다.

 

 

둘 중 하나로 외래 키를 관리해야 한다.

• 그렇다면 객체 세상에서는 어떤 것을 둘 중 어떤 것을 매핑해야 할까?
• Member의 team이 바뀌었을 때 외래 키 값이 업데이트 되어야 할까
• Team의 members 들이 바뀌었을 때 외래 키 값이 업데이트 되어야 할까
• 쉽게 말하면 Member의 team이 팀을 바꾸거나 새로운 팀에 들어갈 때 TEAM_ID가 바뀌어야 할까?
• Team의 members가 바뀌었을 때 TEAM_ID의 값이 바뀌어야 할까?
• 둘 다 맞는 말이고 어떻게든 Member 테이블의 TEAM_ID 만 바뀌면 된다.

 

 

 

 

연관관계의 주인(Owner)

 

양방향 매핑 규칙

• 객체의 두 관계중 하나를 연관관계의 주인으로 지정
• 연관관계의 주인만이 외래 키를 관리(등록, 수정) 
• 주인이 아닌쪽은 읽기만 가능
• 주인은 mappedBy 속성 사용X 
• 주인이 아니면 mappedBy 속성으로 주인 지정

 

누구를 주인으로?

• 외래 키가 있는 있는 곳을 주인으로 정해라
• 여기서는 Member.team이 연관관계의 주인

• 정말 단순하게 얘기하면 DB 테이블로 따져서 N 쪽이 연관관계의 주인이 되면 된다.

 

 

양방향 매핑시 가장 많이 하는 실수

1. 연관관계의 주인에 값을 입력하지 않음

Member member = new Member();
member.setUsername("member1");
em.persist(member);

Team team = new Team();
team.setName("TeamA");
team.getMembers().add(member); //역방향(주인이 아닌 방향)만 연관관계 설정
// member.setTeam(team); // 정방향
em.persist(team);

• mappedBy 속성은 값을 쓰지못하고 읽기만 가능하다.
• 가짜 매핑된 team의 members에서 값을 넣으려하다 보니 실제 테이블에 값이 반영되진 않는다. (객체에는 들어감)
• 둘다 넣는 것은 가능하다. (하지만 읽기 전용이기 때문에 JPA는 이 값을 쓰지는 않는다.)

 

 

2. 양방향 매핑시 연관관계의 주인에 값을 입력해야 한다. 

(순수한 객체 관계를 고려하면 항상 양쪽다 값을 입력해야 한다.)

try {
    Team team = new Team();
    team.setName("TeamA");
    em.persist(team);

    Member member = new Member();
    member.setUsername("member1");
    member.setTeam(team);
    em.persist(member);

    Member member2 = new Member();
    member2.setUsername("member2");
    member2.setTeam(team);
    em.persist(member2);

    //team.getMembers().add(member); // 입력해야 한다.
    //team.getMembers().add(member2); // 입력해야 한다.

    //em.flush();
    //em.clear();

    Team findTeam = em.find(Team.class, team.getId());
    List<Member> members = findTeam.getMembers(); // 순수한 객체 상태로 들어가 있다.
    System.out.println("============================");
    for (Member m : members) {
        System.out.println("m.getUsername() = " + m.getUsername());
    }
    System.out.println("============================");

    tx.commit();

• flush가 없으면 DB에 반영하지 못한다. (영구히 DB에 저장하는 것은 아님, 하지만 find로 찾을 수는 있는 상태)
• 이는 Member와 Team의 연관관계를 모르기 때문에 1차 캐시에 들어가 있는 것은 순수한 객체 상태이다.
• clear( )가 없다면 영속성 컨텍스트 안에는 Team 앤티티가 존재하고 있을 것이다.
• 그렇다면 find( )는 1차 캐시에 있는 Team 앤티티의 상태를 참조할 것이다.
• 그래서 List<Member> members 는 비어있는 상태다. 즉, 원하는 값을 찾을 수 없다.

 

 

양방향 연관관계 주의

• 순수 객체 상태를 고려해서 항상 양쪽에 값을 설정하자 
• 연관관계 편의 메소드를 생성하자
• 양방향 매핑시에 무한 루프를 조심하자
• 예: toString(), lombok, JSON 생성 라이브러리

package hellojpa.domain;

import jakarta.persistence.*;

@Entity
public class Member {

    @Id
    @GeneratedValue
    @Column(name = "MEMBER_ID")
    private Long id;

    @Column(name = "USERNAME")
    private String username;

//    @Column(name = "TEAM_ID", nullable = false)
//    private Long teamId;

    @ManyToOne(fetch = FetchType.LAZY)
    @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;
    }
    
 // !!!! 자신의 인스턴스 넣어주기, set 말고 중요한 메서드 이름으로 설정하기
    public void changeTeam(Team team) {
        this.team = team;
        team.getMembers().add(this);
    } 
}

 

 

양방향 매핑 정리

• 단방향 매핑만으로도 이미 연관관계 매핑은 완료
• 양방향 매핑은 반대 방향으로 조회(객체 그래프 탐색) 기능이 추가된 것 뿐
• JPQL에서 역방향으로 탐색할 일이 많음
• 단방향 매핑을 잘 하고 양방향은 필요할 때 추가해도 됨 (테이블에 영향을 주지 않음)

 

연관관계의 주인을 정하는 기준

• 비즈니스 로직을 기준으로 연관관계의 주인을 선택하면 안됨
• 연관관계의 주인은 외래 키의 위치를 기준으로 정해야함