연관관계 매핑 기초

 

단방향 연관관계

 

※ 목표

 

객체와 테이블 연관관계의 차이를 이해해야 한다.

객체의 참조와 테이블의 외래 키를 매핑해야 한다.

용어 이해

- 방향(Direction) : 단방향, 양방향

- 다중성(Multiplicity) : 다대일, 일대다, 일대일, 다대다 이해

- 연관관계의 주인(Owner) : 객체 양방향 연관관계는 관리 주인이 필요

 

 

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

 

예를 들어서 멤버와 팀이 다대일 관계일 때, 테이블 연관관계는 다음과 같다.

 

 

위 구조를 그대로 Member, Team 클래스를 생성한다면 다음과 같다.

@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;
    
    ...
}

@Entity
public class Team {

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

 

그 다음에 "TeamA" 팀에 속한 "member1" 멤버에 대한 정보를 저장하는 코드를 작성하면 다음과 같다.

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

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

emf.close();

 

 

식별자를 받아와서 세팅하거나 조회하는 방식으로 코드가 이뤄진다.

이런 방법은 객체 지향적인 방법이 아니다!

 

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

- 테이블은 외래 키로 조인을 사용해서 연관된 테이블을 찾는다.

- 객체는 참조를 사용해서 연관된 객체를 찾는다.

- 테이블과 객체 사이에는 이런 큰 간격이 있다.

 

 

※ 객체 지향 모델링

 

위에서 들었던 예를 객체 연관관계를 사용해서 나타낸다면 다음과 같다.

 

 

위 코드에 대한 Member 클래스를 다음과 같이 수정하면 객체를 세팅하거나 조회가 가능하다.

@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;
    
    ...
}

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

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

 

정상적으로 객체 삽입 및 조회가 된 것을 확인할 수 있다.

 

 

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

 

위에서 봤던 구조는 단방향 구조였다.

이번에는 양방향 구조에 대해서 살펴보도록 한다.

 

 

자유롭게 특정 멤버가 어느 팀에 소속하는지, 특정 팀에 어떤 멤버들이 존재하는지를 알 수 있도록 하려고 한다.

즉, Team 클래스에 멤버들을 담을 수 있는 무언가가 필요하다.

이를 해결하기 위해 List 를 생성하여 멤버들을 담을 수 있도록 해준다.

아래 코드를 살펴보도록 하자.

@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<>();
    
    ...
}

 

하나의 팀에는 여러 멤버가 존재하므로 일대다 관계이다.

따라서 @OneToMany 에다가 Member 클래스에 team 에 의해 매핑되어진다는 것을 추가해줘야 한다.

 

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

 

여기서 주목해야 할 부분은 findMember.getTeam().getMembers(); 인 것 같다.

예를 들어서 다음과 같이 멤버와 팀이 구성되어 있다고 해보자.

 

 

여기서 findMember 를 member1 이라고 해보자.

findMember.getTeam() 은 team1 이 되고 findMember.getTeam().getMembers() 는 

{member1, member2} 와 같은 리스트 형태가 된다.

즉, 특정 멤버 정보만으로 해당 멤버의 팀 뿐만 아니라 팀 내에 모든 멤버들에 대한 정보를

얻을 수 있게 된다!

 

 

※ 연관관계의 주인과 mappedBy

 

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

객체 연관관계가 2 개인 경우

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

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

 

객체 연관관계가 1 개인 경우

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

 

 

※ 객체의 양방향 관계

 

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

객체를 양방향으로 참조하려면 단방향 연관관계를 2개 만들어야 한다.

class A {
	B b;
}

class B {
	A a;
}

 

- A ~> B (a.getB())

- B ~> A (b.getA())

 

 

※ 테이블의 양방향 관계

 

테이블은 외래 키 하나로 두 테이블의 연관관계를 관리한다.

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

 

 

※ 둘 중 하나로 외래 키를 관리

 

 

mappedBy 를 누구에게 지정할 것인가에 대한 이슈가 존재한다.

team 으로 할 것인지, members 로 할 것인지 크게 상관이 없어 보이는데 아무렇게 해도 상관 없을까?

결국 둘 중 하나로 외래 키를 관리해야 한다. (즉, 둘 중 하나는 주인이 되야함)

 

 

※ 연관관계의 주인(Owner)

 

양방향 매핑 규칙

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

- 연관관계의 주인만이 외래키를 관리할 수 있다. (등록 및 수정)

- 주인이 아닌 쪽은 읽기만 가능해야 한다.

- 주인은 mappedBy 속성을 사용하지 않는다.

- 주인이 아니면 mappedBy 속성으로 주인을 지정한다.

 

그렇다면 누구를 주인으로 지정해야 할까?

외래 키가 있는 곳을 주인으로 정하면 된다.

여기서는 Member.team 이 연관관계의 주인이 된다.

보통 다(N) 쪽이 연관관계의 주인이 되면 된다!

 

 

 

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

 

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

연관관계 편의 메서드를 생성한다.

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

 

예를 들어 toString() 에 대한 경우를 살펴보도록 하자.

@Entity
public class Member {

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

@Entity
public class Team {

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

	...
}

 

위와 같이 toString 을 오버라이딩 했다.

그렇다면 아래와 같이 코드를 작성했을 때 문제가 발생한다.

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

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

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

    emf.close();
}

 

 

findTeam 에서 toString() 을 하게 될경우 members 에서 toString() 을 하게 되고,

그 다음에 다시 findTeam 에서 toString() 을 하고를 계속해서 반복한다.

즉, 이러한 무한 루프에 빠지게 될 경우 스택 오버플로우가 발생된다.

 

이번엔 순서를 고려하지 않고 데이터를 저장한 코드를 살펴보도록 하자.

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();
} finally {
    em.close();
}

emf.close();

 

이전에는 Team 을 생성하고 Member 을 생성하는 방식으로 수행했다.

그러나 Member 를 생성한 다음에 Team 을 생성하도록 하면 어떤 일이 일어날까?

 

 

멤버의 team_id 가 null 인 것을 확인할 수 있다.

그 말은 즉 멤버에서 team 필드를 설정해줘야 하는데 설정해주지 못해서 생긴 문제이다.

따라서 Team 을 생성한 다음에 Member 를 생성하는 방식으로 수행해야 한다.

가장 안전한 방법은 양쪽 전부 필드를 채울 수 있도록 하는 방법이다.

아래와 같이 양쪽 필드 전부를 채울 수 있다.

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.getMembers().add(member) 가 없을 경우, em.flush(), em.clear() 를 수행하지 않는다면

1차 캐시에는 존재하지만(영속 상태) 데이터베이스에 반영되지 않은 상태이다.

따라서 특정 팀을 가져와서 소속된 모든 멤버들을 조회할 때 데이터베이스에 Insert SQL 이 수행되지

않았기 때문에 의도하지 않은 결과가 나타날 수 있다.

 

 

※ 양방향 매핑 정리

 

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

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

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

단방향 매핑을 잘 하고 양방향은 필요할 때 추가하면 된다. (테이블에 영향 x)

 

 

실전 예제 - 2. 연관관계 매핑 시작

 

이전에 설계했던 테이블 구조는 다음과 같다.

 

 

테이블 구조를 참고하여 객체 구조로 참조를 사용할 수 있도록 변경해줘야 한다.즉, id 값으로 참조하는 방식이 아닌 객체 참조가 가능하도록 한다.

 

 

Member 클래스

@Entity
public class Member {

    @Id @GeneratedValue
    @Column(name = "MEMBER_ID")
    private Long id;
    private String name;
    private String city;
    private String street;
    private String zipcode;

    @OneToMany(mappedBy = "member")
    private List<Order> orders = new ArrayList<>();
    ...

 

Order 클래스

@Entity
@Table(name = "ORDERS")
public class Order {

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

    @ManyToOne
    @JoinColumn(name = "MEMBER_ID")
    private Member member;

    @OneToMany(mappedBy = "order")
    private List<OrderItem> orderItems = new ArrayList<>();

    private LocalDateTime orderDate;

    @Enumerated(EnumType.STRING)
    private OrderStatus status;
    ...

 

OrderItem 클래스

@Entity
public class OrderItem {

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

    @ManyToOne
    @JoinColumn(name = "ITEM_ID")
    private Item item;

    @ManyToOne
    @JoinColumn(name = "ORDER_ID")
    private Order order;

    private int orderPrice;
    private int count;
    ...

 

Item 클래스

@Entity
public class Item {

    @Id @GeneratedValue
    @Column(name = "ITEM_ID")
    private Long id;
    private String name;
    private int price;
    private int stockQuantity;
    ...

 

 

정상적으로 테이블이 생성되었다. (연관관계를 맺은 필드는 반영되지 않음)