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

Spring/JPA

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

느리지만 꾸준하게 2022. 5. 8. 15:06

아래 코드를 보게 되면 member에서 Team으로는 갈 수 있다.

반대로 team에서 getMember()는 안된다. 일단 왔다갔다 참조는 할 수 있다. => 양방향 연관관계

// ex1-hello-jpa / hellojpa / JpaMain

// 저장
Team team =  new Team();
team.setName("TeamA");
em.persist(team);

Member member = new Member();
member.setUsername("member1");
// 이렇게 해주면 JPA가 알아서 PK값을 team에서 꺼내서 FK값에 insert해준다.
member.setTeam(team);
em.persist(member);

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

Member findMember = em.find(Member.class, member.getId());

Team findTeam = findMember.getItem();

// team에서 getMember는 안된다.
// findTeam.getMember()

System.out.println("findTeam = " + findTeam.getName());

//
Team newTeam = em.find(Team.class, 100L);
findMember.setTeam(newTeam);

Team에는 아무거도 없다.

// Team


@Entity
public class Team extends BaseEntity{

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

외래키 하나만 넣어주면 양쪽으로 다 테이블을 볼 수 있게 된다.

Member Class를 보게되면 team과의 관계가 다대일이다.

그럼 Team은 OneToMany가 되겠다.

// Member Class

package hellojpa;

import javax.persistence.*;

@Entity
public class Member {

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

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

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

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

mappedBy를 붙여주자.

// Team Class

@Entity
public class Team extends BaseEntity{

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

    // arrayList로 초기화
    @OneToMany(mappedBy = "team")
    private List<Member> members = new ArrayList<>();

    public Long getId() {
        return id;
    }

// JpaMain Class

package hellojpa;

import javax.management.relation.Role;
import javax.persistence.EntityManager;
import javax.persistence.EntityManagerFactory;
import javax.persistence.EntityTransaction;
import javax.persistence.Persistence;
import java.util.List;

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);

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

            Member findMember = em.find(Member.class, member.getId());
            List<Member> members = findMember.getTeam().getMembers();

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

            tx.commit();
        } catch (Exception e) {
            tx.rollback();
        } finally {
            em.close();
        }

        emf.close();
    }
}

Hibernate: 
    select
        members0_.TEAM_ID as TEAM_ID3_0_0_,
        members0_.MEMBER_ID as MEMBER_I1_0_0_,
        members0_.MEMBER_ID as MEMBER_I1_0_1_,
        members0_.TEAM_ID as TEAM_ID3_0_1_,
        members0_.USERNAME as USERNAME2_0_1_ 
    from
        Member members0_ 
    where
        members0_.TEAM_ID=?
m = member1

연관관계의 주인과 mappedBy

객체와 테이블간에 연관관계를 맺는 차이를 이해해야 한다.

객체 연관관계 = 2개

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

테이블 연관관계 = 1개

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

=> 즉 객체의 양방향 관계는 사실 양방향 관계가 아니라 서로 다른 단방향 관계 2개다.

객체를 양방향으로 참조하려면 단방향 연관관계를 2개 만들어야 한다.
A -> B(a.getB())
B ->A(b.getA())

양방향 매핑규칙을 보게되면

객체의 두 관계중 하나를 연관관계의 주인으로 지정

연관관계의 주인만이 외래 키를 관리(등록, 수정)

주인이 아닌쪽은 읽기만 가능

주인은 mappedBy 속성 사용 x

주인이 아니면 mappedBy 속성으로 주인 지정

그리고 연관관계(mappedBy)의 주인은 누구로 해야할까라는 고민이 생긴다.

먼저 외래 키가 있는 곳을 주인으로 정해야 한다.(N:1에서 N으로 지정)
여기서 Member.team이 연관관계의 주인

양방향 매핑시 가장 많이 하는 실수의 예시를 보자.

package hellojpa;

import javax.management.relation.Role;
import javax.persistence.EntityManager;
import javax.persistence.EntityManagerFactory;
import javax.persistence.EntityTransaction;
import javax.persistence.Persistence;
import java.util.List;

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);

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

            tx.commit();
        } catch (Exception e) {
            tx.rollback();
        } finally {
            em.close();
        }

        emf.close();
    }
}

insert 쿼리는 두번 나왔다.

Hibernate: 
    /* insert hellojpa.Member
        */ insert 
        into
            Member
            (TEAM_ID, USERNAME, MEMBER_ID) 
        values
            (?, ?, ?)
Hibernate: 
    /* insert hellojpa.Team
        */ insert 
        into
            Team
            (name, TEAM_ID) 
        values
            (?, ?)

USERNAME은 나와있는데 TEAM_ID는 null이다.

연관관계의 주인 member에만 값을 넣어보고 돌려보면 제대로 들어가 있다.

package hellojpa;

import javax.management.relation.Role;
import javax.persistence.EntityManager;
import javax.persistence.EntityManagerFactory;
import javax.persistence.EntityTransaction;
import javax.persistence.Persistence;
import java.util.List;

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");
//            team.getMembers().add(member);
            em.persist(team);

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

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

            tx.commit();
        } catch (Exception e) {
            tx.rollback();
        } finally {
            em.close();
        }

        emf.close();
    }
}

둘 다 넣어 보자. 똑같이 잘 나오게 된다.

package hellojpa;

import javax.management.relation.Role;
import javax.persistence.EntityManager;
import javax.persistence.EntityManagerFactory;
import javax.persistence.EntityTransaction;
import javax.persistence.Persistence;
import java.util.List;

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);

            team.getMembers().add(member);

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

            tx.commit();
        } catch (Exception e) {
            tx.rollback();
        } finally {
            em.close();
        }

        emf.close();
    }
}

아래 부분을 꼭 넣어주어야 하는데

team.getMembers().add(member);

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

없으면 1차 캐시에 있는 부분이 그대로 들어가서 db에서는 select 쿼리가 안나가게 된다.

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

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

            team.getMembers().add(member);

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

            Team findTeam = em.find(Team.class, team.getId()); // 1차 캐시
            List<Member> members = findTeam.getMembers();

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

Hibernate: 
    
    create table Team (
       TEAM_ID bigint not null,
        name varchar(255),
        primary key (TEAM_ID)
    )
Hibernate: 
    
    alter table Member 
       add constraint FKl7wsny760hjy6x19kqnduasbm 
       foreign key (TEAM_ID) 
       references Team
Hibernate: 
    call next value for hibernate_sequence
Hibernate: 
    call next value for hibernate_sequence
m = member1
Hibernate: 
    /* insert hellojpa.Team
        */ insert 
        into
            Team
            (name, TEAM_ID) 
        values
            (?, ?)
Hibernate: 
    /* insert hellojpa.Member
        */ insert 
        into
            Member
            (TEAM_ID, USERNAME, MEMBER_ID) 
        values
            (?, ?, ?)

만약에 아래 구문을 주석처리하고 돌리게 되면 m = member1이 빌드창에 안나오고 ====== 사이에는 아무거도 없게된다.

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

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

//            team.getMembers().add(member);

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

            Team findTeam = em.find(Team.class, team.getId()); // 1차 캐시
            List<Member> members = findTeam.getMembers();


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

            System.out.println("============================");

            tx.commit();

Hibernate: 
    call next value for hibernate_sequence
Hibernate: 
    call next value for hibernate_sequence
============================
============================
Hibernate: 
    /* insert hellojpa.Team
        */ insert 
        into
            Team
            (name, TEAM_ID) 
        values
            (?, ?)
Hibernate: 
    /* insert hellojpa.Member
        */ insert 
        into
            Member
            (TEAM_ID, USERNAME, MEMBER_ID) 
        values
            (?, ?, ?)

즉 양방향 연관관계에서는 양쪽에다 값을 다 세팅해줘야 한다.

package hellojpa;

import javax.management.relation.Role;
import javax.persistence.EntityManager;
import javax.persistence.EntityManagerFactory;
import javax.persistence.EntityTransaction;
import javax.persistence.Persistence;
import java.util.List;

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);

            team.getMembers().add(member);

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

            Team findTeam = em.find(Team.class, team.getId());
            List<Member> members = findTeam.getMembers();

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

            tx.commit();
        } catch (Exception e) {
            tx.rollback();
        } finally {
            em.close();
        }

        emf.close();
    }
}

m = member1

// ** 부분이 헷갈릴 수가 있는데

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

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

            team.getMembers().add(member); // **

Member class에서 이렇게 설정해주고

package hellojpa;

import javax.persistence.*;

@Entity
public class Member {

// ~~

    public Team getTeam() {
        return team;
    }

    public void setTeam(Team team) {
        this.team = team;

        // member 나 자신의 instance를 넣어주고
        // JpaMain에 있는 team.getMembers().add(member); // **를 지워준다.
        team.getMembers().add(this);
    }
}

JpaMain에서는 //** 부분을 삭제해주면 양쪽으로 세팅이 다 들어가게 된다.

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

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

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

            Team findTeam = em.find(Team.class, team.getId()); // 1차 캐시
            List<Member> members = findTeam.getMembers();


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

            System.out.println("============================");

            tx.commit();
        } catch (Exception e) {
            tx.rollback();
        } finally {
            em.close();
        }

그리고 아래의 setTeam 부분을 changeTeam으로 바꿔서 중요한 역할을 한다고 강조해주면 좋다.

public void setTeam(Team team) {
        this.team = team;

        // member 나 자신의 instance를 넣어주고
        // JpaMain에 있는 team.getMembers().add(member); // **를 지워준다.
        team.getMembers().add(this);
    }

public void changeTeam(Team team) {
        this.team = team;

        // member 나 자신의 instance를 넣어주고
        // JpaMain에 있는 team.getMembers().add(member); // **를 지워준다.
        team.getMembers().add(this);
    }

JpaMain에도 changeTeam으로 바꿔준다.

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

            Member member = new Member();
            member.setUsername("member1");
            member.changeTeam(team); // **
            em.persist(member);

member class에 setteam으로 넣어주고

public void setTeam(Team team) {
        this.team = team;
    }

team class에 아래구문을 추가해준다.

public void addMember(Member member) {
        member.setTeam(this);
        members.add(member);
    }

그리고 member class에 있는 changeTeam을 지워준다. JpaMain에 있는것과 겹치면 문제가 되기 때문이다.

// 지워줌

public void changeTeam(Team team) {
        this.team = team;
        // member 나 자신의 instance를 넣어주고
        // JpaMain에 있는 team.getMembers().add(member); // **를 지워준다.
        team.getMembers().add(this);
    }

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

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

양방향 연관관계 주의 - 실습

순수 객체 상태를 고려해서 항상 양쪽에 값을 설정해준다.

연관관계 편의 메소드를 생성

양방향 매핑시에 무한 루프를 조심하자. ex) toString(), lombok, JSON 생성 라이브러리

member의 toString

@Override
    public String toString() {
        return "Member{" +
                "id=" + id +
                ", username='" + username + '\'' +
                ", team=" + team +
                '}';
    }

team의 toString

@Override
    public String toString() {
        return "Team{" +
                "id=" + id +
                ", name='" + name + '\'' +
                ", members=" + members +
                '}';
    }

JpaMain에서 findTeam을 찍어보자.

System.out.println("============================");
System.out.println("findTeam = " + findTeam);
System.out.println("============================");

양쪽으로 계속 호출을 해서 stop되게 된다.

stackoverflow가 일어나야 하는데 빌드창에 뜨지않는다.. 나중에 한번 다시보자.

============================
5월 25, 2022 12:01:16 오후 org.hibernate.engine.jdbc.connections.internal.DriverManagerConnectionProviderImpl stop
INFO: HHH10001008: Cleaning up connection pool [jdbc:h2:tcp://localhost/~/test]

양방향 매핑 정리

단방향 매핑만으로도 이미 연관관계 매핑은 완료

양방향 매핑은 반대 방향으로 조회(객체 그래프 탐색) 기능이 추가된 것 뿐이다.

JPQL에서 역방향으로 탐색할 일이 많음

단방향 매핑을 잘 하고 양방향은 필요할 때 추가해도 되고(테이블에 영향을 주지 않음)

그리고 중요하게 비즈니스 로직을 기준으로 연관관계의 주인을 선택하면 안된다.

연관관계의 주인은 외래 키의 위치를 기준으로 정해야 한다.

<출처 김영한: 자바 ORM 표준 JPA 프로그래밍 - 기본편 >

https://www.inflearn.com/course/ORM-JPA-Basic/dashboard

자바 ORM 표준 JPA 프로그래밍 - 기본편 - 인프런 | 강의

JPA를 처음 접하거나, 실무에서 JPA를 사용하지만 기본 이론이 부족하신 분들이 JPA의 기본 이론을 탄탄하게 학습해서 초보자도 실무에서 자신있게 JPA를 사용할 수 있습니다., - 강의 소개 | 인프런

www.inflearn.com

'Spring > JPA' 카테고리의 다른 글

다대일 N:1 / 일대다 1:N (0)	2022.05.25
예제 - 연관관계 매핑 시작 (0)	2022.05.25
연관관계 매핑 기초 - 단방향 연관관계 (0)	2022.04.16
실전 예제 1 - 요구사항 분석과 기본 매핑 (0)	2022.04.14
기본 키 매핑 (0)	2022.04.14

현재글양방향 연관관계와 연관관계의 주인

Jay

transaction, jdbc, ORM, Spring, AWS, javascript, JPA, Post, http, thymeleaf, 항해플러스, SpringDataJpa, servlet, springboot, SpringDB, API, querydsl, ec2, SpringMVC, MVC,

Today :
Yesterday :

일	월	화	수	목	금	토
					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

Jay