[JPA] 연관관계 매핑 기초

목표

• 객체와 테이블 연관관계의 차이를 이해
• 객체의 참조와 테이블의 외래키를 매핑
• 용어
  (1) 방향(Direction) : 단방향, 양방향
  (2) 다중성(Multiplicity) : 다대일(N:1), 일대다(1:N), 일대일(1:1), 다대다(N:M) 이해
  (3) 연관관계의 주인(Owner) : 객체 양방향 연관관계는 관리 주인이 필요

연관관계가 필요한 이유

예제 시나리오

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

객체를 테이블에 맞춰 모델링

연관관계가 없는 객체

객체에는 연관관계가 없다.

참조 대신 외래키 사용

(1) Member.java

@Entity
public class Member {

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

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

    @Column(name = "TEAM_ID")
    private Long teamId;  // 외래키 사용

    // getter, setter

}

(2) Team.java

@Entity
public class Team {
    
    @Id @GeneratedValue
    @Column(name = "TEAM_ID")
    private Long id;
    private String name;

    // getter, setter

}

외래키 식별자를 직접 다룸

- JpaMain.java

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.setTeamId(team.getId());
            em.persist(member);

            // 식별자로 다시 조회, 객체 지향적인 방법 아니다.
            // 조회
            Member findMember = em.find(Member.class, member.getId());
            // 연관관계가 없다
            Team findTeam = em.find(Team.class, findMember.getTeamId());
            
            tx.commit();
        } catch (Exception e) {
            tx.rollback();
        } finally {
            em.close();
        }

        emf.close();
    }
}

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

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

단방향 연관관계

객체 지향 모델링

객체 연관관계 사용

객체 연관관계에서 참조를 사용

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

- Member.java

@Entity
public class Member {

    @Id // DB PK
    @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;
    
    // getter, setter
}

@ManyToOne

• 다대일(N:1) 관계를 나타내는 매핑 정보

속성	설명	기본값
optional	객체 필수 여부	true
fetch	글로벌 패치 전략 설정	@ManyToOne = FetchType.EAGER @OneToMany = FetchType.LAZY
cascade	영속성 전이 기능 사용
targetEntity	연관된 엔티티의 타입 정보 설정

@JoinColumn

• 외래키 매핑 시 사용

속성	설명	기본값
name	매핑할 외래키 이름
referencedColumnName	외래키가 참조하는 대상 테이블의 컬럼명
foreignKey (DDL)	외래키 제약조건 지정 (테이블 생성시에만 사용)
unique nullable insertable / updatable columnDefinition table	@Column 의 속성과 동일

ORM 매핑

연관관계 저장 및 참조 사용

- JpaMain.java

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

            // 참조를 사용하여 연관관계 조회 (객체 그래프 탐색)
            Team findTeam = findMember.getTeam();
            System.out.println("findTeam = " + findTeam.getName());
            
            tx.commit();
        } catch (Exception e) {
            tx.rollback();
        } finally {
            em.close();
        }

        emf.close();
    }
}

※ 외래키를 객체에 저장하는 것이 아닌 연관관계에 있는 객체를 셋팅하여 참조를 저장하고 그 참조를 갖고 조회가 가능한 것이다.

 

연관관계 수정

연관관계 수정은 기존 객체 정보 변경과 동일하게 다른 정보를 가진 객체를 셋팅하면 된다.

// 회원 조회
Member findMember = em.find(Member.class, member.getId());
// 연관관계 수정
// (1) 다른 팀 객체를 조회
Team newTeam = em.find(Team.class, 10L);
// (2) 변경할 회원 객체해 팀 객체를 셋팅하면 수정
findMember.setTeam(newTeam);

연관관계 조회 실행

조회 쿼리가 조인이 되어 실행된다.

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

양방향 매핑

테이블의 연관관계는 외래키를 통해 양방향 연관관계를 갖지만 객체는 연관관계를 가진 객체의 참조를 가져야 양방향 연관관계를 가질 수 있다.

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

• 객체 연관관계 = 2개
  회원 -> 팀 연관관계 1개 (단방향)
  팀 -> 회원 연관관계 1개 (단방향)
• 테이블 연관관계 = 1개
  회원 <-> 팀 연관관계 1개 (양방향)

객체의 양방향 관계

• 객체의 양방향 관계는 사실 양방향 관계가 아니라 서로 다른 단방향 관계 2개 이다.
• 객체를 양방향으로 참조하려면 단방향 연관관계를 2개 만들어야 한다.

테이블의 양방향 관계

• 테이블은 외래키 하나로 두 테이블의 연관관계를 관리한다.
• 외래키 하나로 양쪽으로 조인할 수 있다.

객체와 테이블의 양방향 관계 차이에 따른 문제점

객체를 양방향 관계로 구성하였을 때 참조값을 가진 두 객체 중 어떠한 객체가 수정되었을 때 외래키 정보를 업데이트 해야 하는지 딜레마에 빠지게 된다. 따라서 둘 중 하나(두 객체 중 하나)로 외래키를 관리해야 한다.

Member와 Team 중 어디서 외래키를 관리해야 하는가?

연관관계의 주인 (Owner)

위 문제점을 해결하기 위한 규칙으로 양방향 매핑일때만 사용된다.

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

연관관계의 주인 선정

외래키가 있는 곳을 주인으로 설정해야 성능 이슈도 없고 설계도 깔끔하게 된다. 반대로 외래키가 없는 곳을 주인으로 설정할 경우 해당 값 수정 시 쿼리는 다른 테이블명으로 실행, 수정되기 때문에 혼란이 발생할 수 있다.

양방향 매핑 시 가장 많이 하는 실수 - 연관관계의 주인에 값을 입력하지 않음

소스

- Member.java

@Entity
public class Member {

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

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

    @ManyToOne  // 한 팀에 여러 멤버가 속한다
    @JoinColumn(name = "TEAM_ID")   // 테이블에서 조인할 컬럼
    private Team team;

    // getter, setter
}

- Team.java

@Entity
public class Team {
    
    @Id @GeneratedValue
    @Column(name = "TEAM_ID")
    private Long id;
    private String name;
    
    @OneToMany(mappedBy = "team")   // 일대다, team으로 매핑이 되어있다.
    private List<Member> members = new ArrayList<>();

    // getter, setter
}

- JpaMain.java

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 {
            // 4. 양방향 연관관계 매핑 시 가장 많이 하는 실수
            Team team = new Team();
            team.setName("TeamA");
            em.persist(team);
            
            Member member = new Member();
            member.setUsername("member1");
            
            team.getMembers().add(member);  // 역방향(주인이 아닌 방향)만 연관관계 설정
            
            em.persist(member);

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

        emf.close();
    }
}

결과

Team에 Member를 추가하였지만 주인이 아닌 방향에 데이터를 설정하였기 때문에 값이 저장되지 않았다.

양방향 연관관계 일때는 양쪽에 값을 다 셋팅 필요

• 객체지향 관점에서 보면 항상 양쪽 다 값을 셋팅하는 것이 맞다.
• EntityManager.flush(), clear() 가 실행되지 않고 로직이 진행될 경우 지연로딩 특징 때문에 아래 예제처럼 Team 객체를 조회할 경우 1차 캐시에 있는 값을 가져오기 때문에(DB에서 재조회 X) members 리스트에는 값이 없다.

소스

- JpaMain.java

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

            // 1. 객체지향적인 관점 때문에 필요
            // 2. flush(), clear() 가 실행되지 않을 경우 1차 캐시의 값을 사용하여 조회가 이뤄지기 때문에
            //    members 리스트에는 값이 존재하지 않는다.
            // team.getMembers().add(member);
            
            // 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 = " + m.getUsername());
            }
            System.out.println("==========");
            
            tx.commit();
        } catch (Exception e) {
            tx.rollback();
        } finally {
            em.close();
        }

        emf.close();
    }
}

결과

 

Team에 Member 정보가 없다.

양방향 연관관계 주의

• 순수객체 상태를 고려해서 항상 양쪽에 값을 설정
• 연관관계 편의 메소드를 생성
  연관관계 주인 객체의 참조 setter에 연관관계 객체의 참조 값 설정 로직 추가
  setter에 작성해도 되지만, 구분을 위해 별도의 메소드로 구성하는 것이 좋다. ex) changeXXX
• 양방향 매핑 시에 무한 루프 주의
  편의 메소드는 두 객체 중 한 곳에만 있어야 한다.
  ex) toString(), Lombok, JSON 생성 라이브러리
  참조 객체 내에도 toString(), JSON 생성 관련 함수가 있어 양쪽 번갈아가며 계속 호출하게 되어 무한루프에 빠지게 된다.

※ Lombok의 toString() 도 절대 사용하지 말아야 한다. 왜냐하면 기본 제공되는 toString()과 동일하기 때문에 같은 무한 루프 문제 발생하기 때문이다.

※ Controller에서 절대로 엔티티를 반환하지 말아야 한다. 왜냐하면 스프링을 이용하여 JSON으로 반환하게 되면 무한루프 발생할 수 있고 엔티티를 API로 반환하면 엔티티 변경 시 API 스펙이 변경되어 문제가 발생한다. 따라서 DTO로 변환하여 반환하는 것이 필요하다.

양방향 매핑 정리

• 단방향 매핑만으로도 이미 연관관계 매핑은 완료
  설계는 무조건 단방향만 이용하여 설계하는 것이 바람직하다.
• 양방향 매핑은 반대 방향으로 조회(객체 그래프 탐색) 기능이 추가된 것 뿐이다.
• JPQL에서 역방향으로 탐색할 일이 많다.
• 단방향 매핑을 잘 하고 양방향은 필요할 때 추가해도 된다. (테이블에 영향을 주지 않음)
  설계는 단방향으로 완료하고 개발 시 필요하면 양방향을 추가해도 늦지 않는다.

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

• 비즈니스 로직을 기준으로 연관관계의 주인을 선택하면 안되고 외래키의 위치를 기준으로 선택해야 한다.
• 설계시 주인이 아닌 객체에서 값 변경을 하려고 하면 연관관계 편의 메소드를 만들어 사용하면 된다.