[JPA] 연관관계 매핑 - 양방향 연관관계

---

바로 이전 포스팅에서 단방향 연관관계에 대해 알아보았습니다.

 

단방향 연관관계를 간단히 짚고 넘어가자면, Member ▶︎ Team의 단방향 연관관계를 가질 때 Member 엔티티에서는 Team 엔티티를 알 수 있지만, Team 엔티티에서는 Member에 대해서 알 수 없었어요.

 

이 연관관계를 객체에서는 참조를 통해 연관관계를 맺어주었고, 테이블에서는 외래키를 통해 연관관계를 맺어주었습니다.

 

그리고 JPA에서는 연관관계를 맺는 엔티티를 매핑해주기 위해서

Member Entity에는 @ManyToOne 어노테이션을 Team 필드에 붙여주고 @JoinColumn 어노테이션으로 참조할 외래키를 설정해주었습니다.

@Entity
public class Member{

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

    private String username;

    // 연관관계 매핑

    @ManyToOne
    @JoinColumn(name="TEAM_ID")
    private Team team;
   
   	...
}

 

 

연관관계를 매핑해 준 후 수정, 조회, 삽입 작업은 기존과 동일하지만 삭제 작업에서는 외래키 제약조건으로 인해 연관관계를 먼저 삭제해주어야 엔티티를 삭제할 수 있었습니다.

member1.setTeam(null);
em.remove(member1);

 

이번 포스팅에서는 단방향이 아닌 양방향 연관관계에 대해 알아보겠습니다.

---

양방향 연관관계

양방향 연관관계라고 함은 화살표로 ↔️를 사용해서 "Member ↔️ Team"와 같이 나타냅니다.

이 양방향 연관관계에서는 Member에서 Team을 알 수 있음과 동시에, Team에서도 Member를 알 수 있습니다.

 

객체 연관관계부터 살펴봅시다.

한 Team에는 여러 Member를 가질 수 있기 때문에, 기존의 Team에 List 컬렉션을 사용해서 members를 추가했습니다.

• Member -> Team ( Member.team ), Team -> Member ( Team.members ) 양방향 연관관계를 갖습니다.

다음으로 테이블 연관관계를 살펴봅시다.

 

[JPA] 연관관계 매핑 - 단방향 연관관계

테이블에서는 단방향 연관관계에서 설명했듯이, 두 엔티티가 외래키로 연관관계를 맺고있으면 처음부터 양방향 관계를 맺고 있기 때문에, 테이블에서는 객체와 달리 따로 추가해줄 부분이 없습니다.

 

자 이제, JPA를 사용해 객체와 테이블간 연관관계를 매핑해보도록 하겠습니다.

 

Member에는 Member(N) ➡️ Team(1) 연관관계 그대로기 때문에 따로 변경점이 없습니다.

@Entity
public class Member {
    @Id
    @Column(name = "MEMBER_ID")
    private String id;

    private String username;

    @ManyToOne
    @JoinColumn(name = "TEAM_ID")
    private Team team;

 

Team에는 Team ➡️ Member 연관관계가 추가되었으니 변경점이 있습니다.

@Entity
public class Team {

    @Id
    @Column(name = "TEAM_ID")
    private String id;

    private String name;

    @OneToMany(mappedBy = "team") // mappedBy = Team (team)
    private List<Member> members = new ArrayList<Member>();

@OneToMany(mappedBy = "team") 
private List<Member> members = new ArrayList<Member>();

• @OneToMany : 한 Team에는 여러 Member가 들어올 수 있습니다. Member와 Team을 다대일, 거꾸로 보면 Team과 Member는 일대다 관계를 갖기 때문에, Team 엔티티의 member 필드에 다중성 어노테이션 @OneToMany를 사용했습니다.
  
  • mappedBy 속성 : mappedBy 속성은 양방향 매핑일 때 사용하는데, 반대 쪽 매핑의 필드 이름을 값으로 주면 됩니다.
• List<Member> members : 객체 연관관계 매핑에서 언급한 List 컬렉션을 사용했습니다. 

양방향 매핑이 끝났습니다. 생각보다 복잡하지 않죠? 이제부터는 단방향 매핑에서 추가적으로 Team에서도 Member로 객체 그래프 탐색을 할 수 있습니다.

EntityManagerFactory emf = Persistence.createEntityManagerFactory("hello");
EntityManager em = emf.createEntityManager();

Team team1 = em.find(Team.class, "team1");
List<Member> members = team1.getMembers();

for (Member member : members) {
    System.out.println("member.getUsername() = " + member.getUsername());
}

---

연관관계의 주인 

[JPA] 연관관계 매핑 - 단방향 연관관계

 

양방향 연관관계에서 Team의 members 필드에 다중성 어노테이션 @OneToMany를 지정해주었습니다.

@OneToMany의 mappedBy 속성에 team도 지정해주었는데요, mappedBy 속성은 왜 필요할까요? 이 질문에 대답하기에 전에 양방향 관계를 다시 한 번 조금 자세히 짚어보겠습니다.

 

 

엄밀히 말하면 객체에는 양방향 연관관계라는 것이 없습니다. 단순히 단방향 연관관계가 2개가 존재합니다.

서로다른 단방향 연관관계 2개에 애플리케이션 로직을 잘 묶어서 마치 양방향인것처럼 보이게 할 뿐이에요.

 

반면에 테이블에서는 외래키 하나만 있으면 양방향 연관관계를 맺습니다.

 

객체와 테이블 매핑에서 엔티티를 단방향으로 설정하면 참조를 하나만 사용하기 때문에 이 참조를 가진 쪽에서 외래키를 관리하면 됩니다.

하지만 객체와 테이블 매핑에서 엔티티를 양방향으로 설정하면 참조를 두 개를 사용하기 때문에 객체의 연관관계를 관리하는 포인트가 두 지점입니다. 다시 말해서, 외래키는 하나이기 때문에 외래키를 관리하는 곳을 명시해 주어야 합니다.

 

바로 양방향 연관관계에서 외래키를 관리하는 곳이 연관관계의 주인(외래키 관리자)이 됩니다. 

• 양방향 연관관계 매핑 시 두 연관관계 중 하나를 연관관계의 주인으로 설정해야 합니다. 
• 연관관계의 주인만이 데이터베이스 연관관계와 매핑되고 외래 키를 관리(등록,수정,삭제,조회) 할 수 있습니다. 
• 반면 주인이 아닌쪽에서는 읽기(조회)만 할 수 있습니다.
• 주인이 아닌 쪽에는 반드시 mappedBy 속성을 사용해주어야 합니다.
• 연관관계의 주인에는 mappedBy 속성을 사용하지 않습니다.

그렇다면 연관관계의 주인은 어떻게 정할까요?

연관관계의 주인, 외래키 관리자는 외래키를 갖고 있는 쪽으로 설정합니다. 

 

데이터베이스 테이블의 다대일, 일대다 관계에서는 항상 다 쪽이 외래키를 가집니다.
따라서 @ManyToOne은 항상 연관관계의 주인이 되므로 mappedBy를 설정할 수 없습니다.

---

양방향 연관관계 저장

양방향 연관관계를 저장할 때 주의할 점이 있습니다. 

연관관계의 주인에는 값을 입력하지 않고 주인이 아닌곳에만 값을 입력하는 경우 정상적으로 저장되지 않습니다.

public static void main(String[] args) {
    EntityManagerFactory emf = Persistence.createEntityManagerFactory("hello");
    EntityManager em = emf.createEntityManager();
    EntityTransaction tx = em.getTransaction();

    tx.begin();
    try
    {
        // Member에는 Member -> Team 연관관계 설정 X
        Member member1 = new Member("member1", "회원1");
        em.persist(member1);
        
        // 주인이 아닌 Team에는 Team -> Member 연관관계 설정 
        Team team1 = new Team("team1", "팀1");
        team1.getMembers().add(member1);
        em.persist(team1);
        
        tx.commit();
    } catch (Exception e) {
        tx.rollback();
    }finally {
        em.close();
    }

    emf.close();
}

• Member 테이블의 TEAM_ID가 null로 설정됨.
  • 연관관계 설정 X

반면 연관관계의 주인에만 연관관계를 설정해주어도 주인이 아닌 곳에도 값이 저장 됩니다.

public static void main(String[] args) {
        EntityManagerFactory emf = Persistence.createEntityManagerFactory("hello");
        EntityManager em = emf.createEntityManager();
        EntityTransaction tx = em.getTransaction();
        tx.begin();
       
        try
        {	
        	// 팀1 설정 
            Team team1 = new Team("team1", "팀1");
            em.persist(team1); // 저장
	            
            // 회원1 설정
            Member member1 = new Member("member1", "회원1");
            member1.setTeam(team1); // 연관관계 설정 Member->Team
            em.persist(member1); // 저장
            
            tx.commit();
        } catch (Exception e) {
            tx.rollback();
        }finally {
            em.close();
        }

        emf.close();
    }

 

그렇다면 연관관게의 주인에만 값을 저장하고 주인이 아닌 쪽에는 값을 저장하지 않는 것이 맞을까?

객체 관점에서는 양쪽 방향에 모두 값을 입력해주는 것이 안전합니다.

객체 관점과 테이블 관점 양쪽 모두를 고려해서 작성하는 것이 좋습니다.

 

JPA를 사용하지 않는 순수한 객체 관점에서 봤을 때, 양쪽 방향에 모두 값을 입력해주지 않으면 Member -> Team 단방향 연관관계 매핑처럼 보입니다.

Team team1 = new Team("team1","팀1");
em.persist(team1);

Member member1 = new Member("member1", "회원1");
member1.setTeam(team1);
em.persist(member1);

List<Member> list = team1.getMembers();
System.out.println("size = " + list.size()); // expected : 1
                                        // result : 0

 

결론적으로 양방향 연관관계에서는 객체까지 고려하여 양쪽 모두 관계를 맺어줍시다.

// 팀1 설정 
Team team1 = new Team("team1", "팀1");
em.persist(team1); // 저장

// 회원1 설정
Member member1 = new Member("member1", "회원1");
member1.setTeam(team1); // 연관관계 설정 Member->Team
team1.getMembers().add(member1); // 연관관계 설정 Team->Member

em.persist(member1); // 저장

 

양방향 매핑임을 더 가시적으로 리펙토링 해봅시다.

// Members Entity
public void setTeam(Team team){

	// 기존 팀이 있을 경우 제거
    if(this.team != null){
    	this.team.getMembers().remove(this);
    }
    
    this.team = team;
    team.getMembers().add(this);
}

// 팀1 설정 
Team team1 = new Team("team1", "팀1");
em.persist(team1); // 저장

// 회원1 설정
Member member1 = new Member("member1", "회원1");
member1.setTeam(team1); // 연관관계 설정 Member->Team
// team1.getMembers().add(member1); // 연관관계 설정 Team->Member

em.persist(member1); // 저장

• 기존 팀이 있을 경우 해당 team에서 해당 member 객체를 지워주고 양방향으로 연관관계를 매핑하였습니다.
  • 사실 기존 팀이 있을 경우 기존 팀에서 해당 멤버를 제거하지 않아도 Team이 연관관계의 주인이 아니기 때문에 외래키를 변경하는 데에는 문제가 없습니다.  

member1 -> team1 에서 member1 -> team2 로 변경해봅시다.

try
{
    // 팀1 설정
    Team team1 = new Team("team1", "팀1");
    em.persist(team1); // 저장

    Team team2 = new Team("team2", "팀2");
    em.persist(team2); // 저장
    
    // 회원1 설정
    Member member1 = new Member("member1", "회원1");
    member1.setTeam(team1); // 연관관계 설정 Member -> Team
    member1.setTeam(team2); // 연관관계 변경 Member -> Team (team2)
    em.persist(member1); // 저장

    for (Member member : team1.getMembers()) {
        System.out.println("member.getUsername() = " + member.getUsername());
    }
    
    tx.commit();
} catch (Exception e) {
    tx.rollback();
}finally {
    em.close();
}

• member1->team1 에서 member1->team2로 바꾼 후 team1의 getMembers()로 team1에 속한 회원 확인

출력 결과

member.getUsername() = 회원1

새로운 영속성 컨텍스트에서는 team1에서 members를 조회해도 데이터베이스 외래 키에는 관계가 끊어져 있으므로 아무것도 조회되지 않지만(마찬가지로 member1에서도 team을 조회할 수 없음),

문제는 관계를 변경하고 영속성 컨텍스트가 살아있는 상태에서 teamA의 getMembers()를 호출하면 member1이 리턴된다는 점입니다. 따라서 변경된 연관관계에서는 관계를 제거하는 것이 안전합니다.

 

만약 영속성 컨텍스트가 종료된다면, 이 공간에 보관되어 있는 엔티티 객체들은 준영속 상태로 전환됩니다.
준영속 상태의 엔티티 객체는 영속성 컨텍스트에서 분리되어서 독립적으로 존재하게 됩니다.

이때 외래키 관계도 함께 끊어지게 됩니다.

즉, 데이터베이스에서 관리하는 테이블의 외래키는 데이터베이스 내에서만 유효한 것이며, 영속성 컨텍스트의 관리를 받는 엔티티 객체가 준영속 상태가 되면 영속성 컨텍스트와의 관계가 끊어지기 때문에, 해당 엔티티 객체와 관련된 데이터베이스 테이블의 외래키 관계도 끊어지게 됩니다.

 

새로운 영속성 컨텍스트에서 team1의 members 조회

try
{
    Team team1 = em.find(Team.class, "team1");

    for (Member member : team1.getMembers()) {
        System.out.println("member.getUsername() = " + member.getUsername());
    }
    
    tx.commit();
} catch (Exception e) {
    tx.rollback();
}finally {
    em.close();
}

• 출력 결과 X

---

<정리>

• 단뱡항 매핑에 비해 양방향 매핑은 조금 복잡했습니다.
  • 연관관계의 주인도 정해야 하고, 두 단방향 연관관계를 양방향으로 관리하기 위해 로직도 잘 관리해야 합니다.
• 단방향 매핑에서는 가리키는 쪽이 언제나 연관관계의 주인, 외래키 관리자가 됩니다.
• 양방향 연관관계의 장점은 반대방향으로 객체그래프 탐색이 가능하다는 점입니다.
• 비즈니스 로직에 따라 다르겠지만 단방향을 우선으로 하고 반대쪽 객체 그래프 탐색이 필요한 경우 양방향 매핑을 추가하도록 합시다.
• 연관관계의 주인은 비즈니스 중요도와 관계가 없습니다. 무조건 외래키를 갖고있는 쪽을 주인으로 설정하고 반대쪽은 mappedBy 속성을 추가해 주도록 합시다.
  • + Tip : @ManyToOne 에서는 항상 Many쪽이 연관관계의 주인.

<참고자료>

• 자바 ORM 표준 JPA 프로그래밍, 김영한