5장 내용정리

엔티티 연관관계를 매핑할 때 고려사항

다중성 (두 엔티티가 일대일 관계, 일대다 관계인지)
단방향, 양방지(두 엔티티 중 한쪽만 참조하는 단방향 관계인지 서로 참조하는 양방향 관계인지)
연관관계의 주인(양방향 연관관계일시 연관관계의 주인)

다중성

다대일(@ManyToOne)
일대다(@OneToMany)
일대일(@OneToOne)
다대다(@ManyToMany) 실무에서 거의 사용되지 않는다.

단방향 양방향

테이블은 외래 키 하나로 조인을 사용해서 양방향으로 쿼리가 가능
객체는 참조용 필드를 가지고 있는 객체만 연관된 객체를 조회할수 있음
객체 관계에서 한 쪽만 참조하는 것을 단방향 관계라 하고 양쪽이 서로 참조하는 것을 양방향 관계라 함

연관관계의 주인

데이터베이스는 외래 키 하나로 두 테이블이 연관관계를 맺는다.
엔티티를 양방향으로 매핑하면 2곳에서 서로를 참조한다.
JPA는 두 객체 연관관계 중 하나를 정해서 데이터베이스 외래 키를 관리하는데 이것을 연관관계의 주인이라 한다.
연관관계의 주인이 아니면 mappedBy 속성을 사용하고 연관관계의 주인 필드 이름을 입력해야 한다.

6장 다양한 연관관계 매핑

1. 다대일

다대일 관계의 반대 방향은 항상 일대다 관계고 일대다 관계의 반대방향은 항상 다대일 관계이다.
데이터베이스 테이블의 1 : N 관계에서 외래 키는 항상 다 쪽에 있다. 따라서 객체 양방향 관계에서 연관관계의 주인은 항상 다 쪽이다.

1.1 다대일 단방향[N:1]

// 회원 엔티티
@Entity
public class Member {
    @Id @GeneratedValue
    @Column(name = "MEMBER_ID")
    private Long id;

    private String username;

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

    // Getter, Setter ...
}

// 팀 엔티티
@Entity
public class Team {
    @Id @GeneratedValue
    @Column(name = "TEAM_ID")
    private Long id;

    private String name;

    // Getter, Setter ...
}

회원은 Member.team으로 Team 엔티티를 참조할 수 있지만 반대로 Team에는 회원을 참조하는 필드가 없다. 따라서 회원과 팀은 단방향 연관관계다.
@JoinColumn(name = "TEAM_ID")로 TEAM_ID 외래 키와 매핑했다. 따라서 Member.team 필드로 Team 테이블의 TEAM_ID 외래키를 관리한다.

1.2 다대일 양방향(N:1, 1:N)

// 회원 엔티티
@Entity
public class Member {
    @Id @GeneratedValue
    @Column(name = "MEMBER_ID")
    private Long id;

    private String username;

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

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

        // 무한루프에 빠지지 않도록 체크
        if(!team.getMembers().contains(this)){
            team.getMembers().add(this);
        }
    }
    // Getter, Setter ...
}

// 팀 엔티티
@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<Member>();

    public void addMember(Member member) {
        this.members.add(member);
        if(member.getTeam() != this) {
            // 무한루프에 빠지지 않도록 체크
            member.setTeam(this);
        }
    }
    // Getter, Setter ...
}

양방향 외래 키가 있는 쪽이 연관관계의 주인이다.
- 일대다와 다대일 연관관계에서 항상 외래키는 다 쪽에 있다.
- JPA는 외래 키를 관리할 때 연관관계의 주인만 사용한다.
- 주인이 아닌 곳에서는 조회를 위한 JPQL이나 객체 그래프를 탐색할 때 사용한다.
양방향 연관관계는 항상 서로를 참조해야 한다
- 항상 서로 참조하게 하려면 연관관계 편의 메소드를 작성하는 것이 좋은데 setTeam(), addMember() 메소드가 편의 메소드들이다.
- 양쪽에 다 작성하면 무한루프에 빠지므로 주의해야한다.

2. 일대다

일대다 관계는 다대일 관계의 반대방향이다.
일대다 관계는 엔티티를 하나 이상 참조할 수 있으므로 자바 컬렉션중 하나를 사용해야 한다.

2.1 일대다 단방향[1:N]

하나의 팀은 여러 회원을 참조할 수 있는데 이런 관계를 일대다 관계라 한다.
팀은 회원들을 참조하지만 반대로 회원은 팀을 참조하지지않으면 둘의 관계는 단방향이다.
일대다 단방향 관계는 약간 특이한데 팀 엔티티의 Team.members로 회원 테이블의 TEAM_ID 외래 키를 관리한다.
보통 자신이 매핑한 테이블의 외래 키를 관리하는데 이 매핑은 반대쪽 테이블에 있는 외래 키를 관리한다.

// 팀 엔티티
@Entity
public class Team {
    @Id @GeneratedValue
    @Column(name = "TEAM_ID")
    private Long id;

    private String name;

    @OneToMany
    @JoinColumn(name = "TEAM_ID")   // MEMBER 테이블의 TEAM_ID(FK)
    private List<Member> members = new ArrayList<Member>();

    // Getter, Setter ...
}

// 회원 엔티티
@Entity
public class Member {
    @Id @GeneratedValue
    @Column(name = "MEMBER_ID")
    private Long id;

    private String username;

    // Getter, Setter ...
}

일대다 단방향 관계를 매핑할 때는 @JoinColumn을 명시해야 한다.
JPA 연결 테이블을 중간에 두고 연관관계를 관리하는 조인 테이블(Join Table) 전략을 기본으로 사용해서 매핑한다.
Join Table 전략은 다음장에 자세한 설명이 나와있다.

일대다 단방향 매핑의 단점

본인테이블에 외래 키가 있으면 엔티티의 저장과 연관관계 처리를 INSERT SQL 한 번으로 끝낼 수 있지만, 다른 테이블에 외래 키가 있으면 연관관계 처리를 위한 UPDATE SQL을 추가로 실행해야 한다.

// 일대다 단방향 매핑의 단점
public void testSave() {
    Member member1 = new Member("member1");
    Member member2 = new Member("member2");

    Team team1 = new Team("team1");
    team1.getMembers().add(member1);
    team1.getMembers().add(memeber2);

    em.persist(member1);    // INSERT-member1
    em.persist(member2);    // INSERT-member2
    em.persist(team1);      // INSERT-team1, UPDATE-member.fk, UPDATE-member2.fk

    transaction.commit();
}

insert into Member (MEMBER_ID, username) values (null, ?)
insert into Member (MEMBER_ID, username) values (null, ?)
insert into Team (TEAM_ID, name) values (null, ?)
update Member set TEAM_ID=? where MEMBER_ID=?
update Member set TEAM_ID=? where MEMBER_ID=?

Member 엔티티는 Team 엔티티를 모른다. 그리고 연관관계에 대한 정보는 Team 엔티티의 members가 관리한다.
Member 엔티티를 저장할 때는 MEMBER 테이블의 TEAM_ID 외래 키에 아무 값도 저장되지 않는다. 대신 Team 엔티티를 저장할 때 Team.members의 참조 값을 확인해서 회원 테이블에 있는 TEAM_ID 외래 키를 업데이트 한다.

일대다 단방향 매핑보다는 다대일 양방향 매핑을 사용하자

일대다 단방향 매핑을 사용하면 엔티티를 매핑한 테이블이 아닌 다른 테이블의 외래키를 관리해야 한다.
성능의 문제, 관리상의 문제가 있다.
문제를 해결하는 좋은 방법은 일대다 단방향 매핑 대신에 다대일 양방향 매핑을 사용하는 것이다.
두 매핑의 테이블 모양은 완전히 같으므로 엔티티만 약간 수정하면 된다.

2.2 일대다 양방향[1:N, N:1]

일대다 양방향 매핑은 존재하지 않는다. 대신 다대일 양방향 매핑을 사용해야 한다.
정확히 말하자면 양방향 매핑에서 @OneToMany는 연관관계의 주인이 될 수 없는데 관계형 데이터 베이스의 특성상 일대다, 다대일 관계는 항상 다 쪽에 외래키가 있기 때문이다.
@OneToMany, @ManyToOne 둘 중에 연관관계의 주인은 항상 다 쪽인 @ManyToOne을 사용한 곳이다. 이런 이유로 @ManyToOne에는 mappedBy 속성이 없다.

// 일대다 양방향 팀 엔티티
@Entity
public class Team {
    @Id @GeneratedValue
    @Column(name = "TEAM_ID")
    private Long id;

    private String name;

    @OneToMany
    @JoinColumn(name = "TEAM_ID")
    private List<Member> members = new ArrayList<Member>();

    // Getter, Setter ...
}

// 일대다 양방향 회원 엔티티
@Entity
public class Member {
    @Id @GeneratedValue
    @Column(name = "MEMBER_ID")
    private Long id;
    private String username;

    @ManyToOne
    @JoinColumn(name = "TEAM_ID", insertable = false, updatable = false)
    private Team team;

    // Getter, Setter
}

일대다 단뱡향 매핑과 같은 TEAM_ID 외래 키 컬럼을 매핑했다. 이렇게 되면 둘 다 같은 키를 관리하므로 문제가 생길 수 있다. 따라서 반대편인 다대일 쪽은 insertable = false, updatable = false로 설정해서 읽기만 가능하게 했다.
이방법은 일대다 양방향 매핑이라기보다는 일대다 단방향 매핑 반대편에 다대일 단방향 매핑을 읽기 전용으로 추가해서 일다대 양방향처럼 보이도록 하는 방법이다. 될 수 있으면 다대일 양방향 매핑을 사용하자.

3. 일대일[1:1]

일대일 관계는 양쪽이 서로 하나의 관계만 가진다.
일대일 관계는 그 반대도 일대일 관계다. 따라서 일대일 관계는 주 테이블이나 대상 테이블 중에 누가 외래 키를 가질지 선택해야 한다.

주 테이블에 외래키

주 객체가 대상 객체를 참조하는 것처럼 주 테이블에 외래 키를 두고 대상 테이블을 참조한다.
외래 키를 객체 참조와 비슷하게 사용할 수 있어서 객체지향 개발자들이 선호한다.
장점은 주 테이블이 외래 키를 가지고 있으므로 주 테이블만 확인해도 대상 테이블과 연관관계가 있는지 알 수 있다.

대상 테이블에 외래키

전통적인 데이터베이스 개발자들은 보통 대상 테이블에 외래 키를 두는 것을 선호한다.
장점은 테이블 관계를 일대일에서 일대다로 변경할 때 테이블 구조를 그대로 유지할 수 있다.

3.1 주 테이블에 외래키

단방향

// 일대일 주 테이블에 외래 키, 단방향 예제 코드
@Entity
public class Member {
    @Id @GeneratedValue
    @Column(name = "MEMBER_ID")
    private Long id;

    private String username;

    @OneToOne
    @JoinColumn(name = "LOCKER_ID")
    private Locker locker;
    ...
}

@Entity
public class Locker {
    @Id @GeneratedValue
    @Column(name = "LOCKER_ID")
    private Long id;

    private String naame;
    ...
}

일대일 관계이므로 객체 매핑에 @OneToOne을을사용고고 데이터베이스에는 LOCKER_ID 외래 키에 유니크 제약 조건(UNIQUE)을 추가 했다.
이 관계는 다대일 단방향(@ManyToOne)과 거의 비슷하다.

양방향

// 일대일 주 테이블에 외래 키, 양방향 예제 코드
@Entity
public class Member {
    @Id @GeneratedValue
    @Column(name = "MEMBER_ID")
    private Long id;

    private String username;

    @OneToOne
    @JoinColumn(name = "LOCKER_ID")
    private Locker locker;
    ...
}

@Entity
public class Locker {
    @Id @GeneratedValue
    @Column(name = "LOCKER_ID")
    private Long id;

    private String naame;

    @OneToOne(mappedBy = "locker")
    private Member member;
    ...
}

양방향이므로 연관관계의 주인을 정해야 한다.
MEMBER 테이블이 외래 키를 가지고 있으므로 Member 엔티티에 있는 Member.locker가 연관관계의 주인이다. 따라서 반대 매핑인 사물함의 Locker.member는 mappedBy를 선언해 연관관계의 주인이 아니라고 설정한다.

3.2 대상 테이블에 외래키

단방향

일대일 관계 중 대상 테이블에 외래 키가 있는 단방향 관계는 JPA에서 지원하지 않는다.

양방향

// 일대일 주 테이블에 외래 키, 단방향 예제 코드
@Entity
public class Member {
    @Id @GeneratedValue
    @Column(name = "MEMBER_ID")
    private Long id;

    private String username;

    @OneToOne(mappedBy = "member")
    private Locker locker;
    ...
}

@Entity
public class Locker {
    @Id @GeneratedValue
    @Column(name = "LOCKER_ID")
    private Long id;

    private String naame;

    @OneToOne
    @JoinColumn(name = "MEMBER_ID")
    private Member member;
    ...
}

프록시와 지연 로딩..

4. 다대다[N:N]

관계형 데이터베이스는 다대다 관계를 표현할 수 없다. 그래서 보통 다대다 관계를 일대다, 다대일 관계로 풀어내는 연결 테이블을 사용한다
객체는 테이블과 다르고 객체 2개로 다대다 관계를 만들 수 있다. @ManyToMany를 사용하면 이런 다대다 관계를 편리하게 매핑할 수 있다.

4.1 다대다: 단방향

// 다대다 단방향 회원
@Entity
public class Member {
    @Id @Column(name = "MEMBER_ID")
    private String id;

    private String username;

    @ManyToMany
    @JoinTable(name = "MEMBER_PRODUCT"
                ,joinColumns = @JoinColumn(name = "MEMBER_ID")
                ,inverseJoinColumns = @JoinColumn(name = "PRODUCT_ID"))
    private List<Product> products = new ArrayList<Product>();
    ...
}

// 다대다 단방향 상품
@Entity
public class Product {
    @Id @Column(name = "PRODUCT_ID")
    private String id;

    private String name;
    ...
}

회원 엔티티와 상품 엔티티를 @ManyToMany로 매핑했다.
@ManyToMany와 @JoinTable을 사용해서 연결 테이블을 바로 매핑하여 회원과 상품을 연결하는 회원_상품(Member_Product) 엔티티 없이 매핑을 완료할수 있다.

연결 테이블을 매핑하는 @JoinTable 속성 정리

@JoinTable.name : 연결테이블을 지정한다. MEMBER_PRODUCT 테이블을 선택
@JoinTable.joinColumns : 현재 방향인 회원과 매핑할 조인 컬럼 정보를 지정한다. MEMBER_ID로 지정
@JoinTable.inverseJoinColumns : 반대 방향인 상품과 매핑할 조인 컬럼 정보를 지정한다. PRODUCT_ID로 지정

// 저장
public void save() {
    Product productA = new Product();
    productA.setId("productA");
    productA.setName("상품A");
    em.persist(productA);

    Member member1 = new Member();
    member1.setId("member1");
    member1.setUsername("회원1");
    member1.getProducts().add(ProductA);    // 연관관계 설정
    em.persist(member1);
}

회원1과 상품A의 연관관계를 설정했으므로 회원1을 저장할 때 연결 테이블에도 값이 저장된다.

INSERT INTO PRODUCT ...
INSERT INTO MEMBER ...
INSERT INTO MEMBER_PRODUCT ...

// 탐색
public void find() {
    Member member = em.find(Member.class, "member1");
    List<Product> products = member.getProducts();  // 객체 그래프 탐색
    for(Product product : products) {
        System.out.println("product.name = " + product.getName());
    }
}

-- member.getProducts()를 호출해서 상품 이름을 출력 SQL

SELECT * FROM MEMBER_PRODUCT MP
INNER JOIN PRODUCT P ON MP.PRODUCT_ID=P.PRODUCT_ID
WHERE MP.MEMBER_ID=?

4.2 다대다: 양방향

다대다 매핑이므로 역방향도 @ManyToMany를 사용한다.
양쪽 중 원하는 곳에 mappedBy로 연관관계의 주인을 지정ㅎ나다.

// 역방향 추가
@Entity
public class Product {
    @Id
    private String id;

    @ManyToMany(mappedBy = "products")  // 역방향 추가
    private List<Member> members;
    ...
}

다대다의 양방향 연관관계 설정

member.getProducts().add(product);
product.getMembers().add(member);

양방향 연관관계 편의 메소드 추가

public void addProduct(Product product) {
    ...
    products.add(product);
    product.getmembers().add(this);
}

양방향 연관관계로 설정후 역방향으로 객체 그래프 탐색

// 역방향 탐색
public void findInverse() {
    Products product = em.find(Product.class, "productA");
    List<Member> members = products.getMembers();
    for(Member member : members) {
        System.out.println("member = " + member.getUsername());
    }
}

4.3 다대다: 매핑의 한게와 극복, 연결 엔티티 사용

@ManyToMany를 사용하면 연결 테이블을 자동으로 처리해주므로 편리하지만 실무에서 사용하기에는 한계가 있다.
보통은 연결 테이블에 주문 날짜나 주문수량 컬럼이 더 필요하다.
컬럼을 추가하면 더는 @ManyToMany를 사용할 수 없다.
엔티티 간의 관계도 테이블 관계처럼 다대다에서 일대다, 다대일 관계로 풀어야 한다.

// 회원 코드
@Entity
public class Member {
    @Id @Column(name = "MEMBER_ID")
    private String id;

    // 역방향
    @OneToMany(mappedBy = "member")
    private List<MemberProduct> memberProducts;
    ...
}

// 상품 코드(객체 그래프 탐색이 필요하지 않다고 판단해 연관관계를 만들지 않음)
@Entity
public class Product {
    @Id @Column(name = "PRODUCT_ID")
    private String id;

    private String name;
    ...
}

// 회원상품 엔티티 코드
@Entity
@IdClass(MemberProductId.class)
public class MemberProduct {
    @Id
    @ManyToOne
    @JoinColumn(name = "MEMBER_ID")
    private Member member;  // MemberProductId.member와 연결

    @Id
    @ManyToOne
    @JoinColumn(name = "PRODUCT_ID")
    private Product product;    // MemberProductsId.product와 연결

    private int orderAmount;
    ...
}

// 회원상품 식별자 클래스
public class MemberProductId implements Serializable {
    private String member;  // MemberProduct.member와 연결
    private String product; // MemberProduct.product와 연결

    // hashCode and equals

    @Override
    public boolean equals(Object o) {...}

    @Override
    public int hasCode() {...}
}

회원상품(MemberProduct) 엔티티를 보면 기본키를 매핑하는 @Id와 외래키를 매핑하는 @JoinColumn을 동시에 사용해서 기본키 + 외래키를 한번에 매핑했다. 그리고 @IdClass를 사용해서 복합 기본키를 매핑했다.

복합 기본키

회원상품 엔티티는 기본키가 MEMBER_ID와 PRODUCT_ID로 이루어진 복합 기본키다.
JPA에서 복합키를 사용하려면 별도의 식별자 클래스를 만들어야 한다. 그리고 엔티티에 @IdClass를 사용해서 식별자 클래스를 지정하면 된다.
여기서는 MemberProductId 클래스를 복합 키를 위한 식별자 클래스로 사용한다.
복합키를 위한 식별자 클래스는 다음과 같은 특징이 있다.
- 복합 키는 별도의 식별자 클래스로 만들어야 한다.
- Serializable을 구현해야 한다.
- equals와 hashCode 메소드를 구현해야 한다.
- 기본 생성자가 있어야 한다.
- 식별자 클래스는 public이어야 한다.
- @IdClass를 사용하는 방법 외에 @EmbeddedId를 사용하는 방법도 있다.

식별관계

회원상품은 회원과 상품의 기본 키를 받아서 자신의 기본키로 사용한다.
부모 테이블의 기본키를 받아서 자신의 기본키 + 외래키로 사용하는 것을 데이터베이스 용어로 식별관계(Identifying Relationship)라 한다.
회원상품(MemberProduct)은 회원의 기본키를 받아서 자신의 기본키로 사용함과 동시에 회원과의 관계를 위한 외래키로 사용한다. 그리고 상품의 기본키도 받아서 자신의 기본키로 사용함과 동시에 상품과의 관계를 위한 외래키로 사용한다.
MemberProductId 식별자 클래스로 두 기본키를 묶어서 복합 기본키로 사용한다.

// 저장하는 코드
public void save() {
    // 회원저장
    Member member1 = new Member();
    member1.setId("member1");
    member1.setUsername("회원1");
    em.persist(member1);

    //상품저장
    Product productA = new Product();
    productA.setId("productA");
    productA.setName("상품1");
    em.persist(productA);

    //회원상품 저장
    MemberProduct memberProduct = new MemberProduct();
    memberProduct.setMember(member1);   // 주문 회원 - 연관관계 설정
    memberProduct.setProduct(productA); // 주문 상품 - 연관관계 설정
    memberProduct.setOrderAmount(2);    // 주문수량
    em.persist(memberProduct);
}

회원상품 엔티티를 만들면서 연관된 회원 엔티티와 상품 엔티티를 설정했다.
회원상품 엔티티는 데이터베이스에 저장될 떄 연관된 회원의 식별자와 상품의 식별자를 가져와서 자신의 기본키 값으로 사용한다.

// 조회코드
public void find() {
    // 기본키 값 생성
    MemberProductId memberProductId = new MemberProductId();
    memberProductId.setMember("member1");
    memberProductId.setProduct("productA");

    MemberProduct memberProduct = em.find(MemberProduct.class, memberProductId);

    Member member = memberProduct.getMember();
    Product product = memberProduct.getProduct();

    System.out.println("member = " + member.getUsername());
    System.out.println("product = " + product.getName());
    System.out.println("orderAmount = " + memberProduct.getOrderAmount());
}

복합키는 항상 식별자 클래스를 만들어야 한다. em.find()를 보면 생성한 식별자 클래스로 엔티티를 조회한다.
복합키를 사용하는 방법은 복잡하다. 단순히 컬럼 하남나 기본 키로 사용하는 것과 비교해서 복합 키를 사용하면 ORM 매핑에서 처리할 일이 상당히 많아진다.
- 복합키를 위한 식별자 클래스를 만들어야한다.
- @IdClass 또는 @EmbeddedId를 사용해야 한다.
- 식별자 클래스에 equals, hashCode도 구현해야 한다.

4.4 다대다 : 새로운 기본키 사용

복합키를 사용하지 않고 간단히 다대다 관계를 구성하는 방법은 새로운 기본키를 사용하는 것이다.
추천하는 기본키 생성 전략은 데이터베이스에서 자동으로 생성해주는 대리키를 Long 값으로 사용하는 것이다.
장점으론 영구히 쓸 수 있으며 비지니스에 의존하지 않고 ORM 매핑시 복합키를 만들지 않아도 되므로 간단히 매핑을 완성할 수 있다.

// 주문코드
@Entity
public class Order {
    @Id @GeneratedValue
    @Column(name = "ORDER_ID")
    private Long id;

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

    @ManyToOne
    @JoinColumn(name = "PRODUCT_ID")
    private Product product;

    private int orderAmount;
    ...
}

ORDER_ID라는 새로운 키본키를 만들고 MEBER_ID, PRODUCT_ID 컬럼은 외래키로만 사용한다.
대리키를 사용함으로써 이전에 보았던 식별 관계에 복합키를 사용하는 것보다 매핑이 단순하고 이해하기 쉽다.
회원 엔티티와 상품 엔티티는 변경사항이 없다.

// 저장 코드
public void save() {
    // 회원 저장
    Member member1 = new Member();
    member1.setId("member1");
    member1.setUsername("회원1");
    em.persist(member1);

    // 상품 저장
    Product productA = new Product();
    productA.setId("productA");
    productA.setName("상품1");
    em.persist(productA);

    // 주문 저장
    Order order = new Order();
    order.setMember(member1);   // 주문 회원 - 연관관계 설정
    order.setProduct(productA); // 주문 상품 - 연관관계 설정
    order.setOrderAmount(2);    // 주문 수량
    em.persist(order);
}

// 조회 코드
public void find() {
    Long orderId = 1L;
    Order order = em.find(Order.class, orderId);

    Member member = order.getMember();
    Product Product = order.getProduct();

    System.out.println("member = " + member.getUsername());
    System.out.println("product = " + product.getName());
    System.out.println("orderAmount = " + order.getOrderAmount());
}

4.5 다대다 연관관계 정리

다대다 연관계를 일대다 다대일 관계로 풀어내기 위해 연결 테이블을 만들 때 식별자를 어떻게 구성할지 선택해야 한다.
1. 식별관계 : 받아온 식별자를 기본키 + 외래키로 사용한다
2. 비식별 관계 : 받아온 식별자는 외래키로만 사용하고 새로운 식별자를 추가한다.
1번처럼 부모테이블의 기본키를 받아서 자식 테이블의 기본키 + 외래키로 사용하는 것을 식별 관계라 한다.
2번처럼 단순히 외래키로만 사용하는 것을 비식별 관계라 한다.

beadss / jpa-study

6장 요약 #14

5장 내용정리

엔티티 연관관계를 매핑할 때 고려사항

다중성

단방향 양방향

연관관계의 주인

6장 다양한 연관관계 매핑

1. 다대일

1.1 다대일 단방향[N:1]

1.2 다대일 양방향(N:1, 1:N)

2. 일대다

2.1 일대다 단방향[1:N]

일대다 단방향 매핑의 단점

일대다 단방향 매핑보다는 다대일 양방향 매핑을 사용하자

2.2 일대다 양방향[1:N, N:1]

3. 일대일[1:1]

주 테이블에 외래키

대상 테이블에 외래키

3.1 주 테이블에 외래키

단방향

양방향

3.2 대상 테이블에 외래키

단방향

양방향

4. 다대다[N:N]

4.1 다대다: 단방향

연결 테이블을 매핑하는 @JoinTable 속성 정리

4.2 다대다: 양방향

다대다의 양방향 연관관계 설정

양방향 연관관계 편의 메소드 추가

양방향 연관관계로 설정후 역방향으로 객체 그래프 탐색

4.3 다대다: 매핑의 한게와 극복, 연결 엔티티 사용

복합 기본키

식별관계

4.4 다대다 : 새로운 기본키 사용

4.5 다대다 연관관계 정리