[Java/Spring] 연관관계 매핑 - Cascade, FetchType

개발을 하다 보면 PK, FK, 영속성 전이, ManyToOne, OneToMany 등등 이런 단어와 어노테이션들을 자주 사용하게 되는데, 정확한 개념을 모르는 경우가 있다.
앞으로 많이 사용하게 될테니 알아두자!

먼저 연관관계 매핑에 대해 알아보도록 하자.

연관관계 매핑이란?

연관관계 매핑이란, 데이터베이스에서 테이블 간의 관계를 정의하는 것이다.
즉, 객체(Entity) 간의 관계를 설정해 데이터를 효율적으로 저장하고 조회할 수 있도록 하는 과정이다.

연관관계 매핑을 설명하기 전 기본 개념인 PK와 FK에 대해 설명하도록 하겠다.

📌 PK(기본 키)와 FK(외래 키)

PK (Primary Key, 기본 키)

PK(기본 키)란 테이블에서 각 행(Row)을 유일하게 식별할 수 있는 값이다.
즉, 각 행을 구별하는 "주인공"이나 "대표주자" 역할을 한다고 생각하면 된다.

PK의 특징

• 유일함(Unique)
  : 한 테이블 내에서 같은 값이 중복될 수 없다.
• NULL이 될 수 없음
  : 반드시 값이 존재해야 함
• 한 테이블에 하나만 존재함 (복합키 제외)

Spring Boot JPA에서 PK 설정

import jakarta.persistence.*;

@Entity
public class User {
    @Id // PK 설정
    @GeneratedValue(strategy = GenerationType.IDENTITY) // 자동 증가 (Auto Increment)
    private Long id;

    private String name;
    private String email;
}

• @Id를 사용하여 id 필드를 기본 키(PK)로 설정한다.
• @GeneratedValue(strategy = GenerationType.IDENTITY)
  : 키 값이 자동 증가하도록 설정한다.

FK (Foreign Key, 외래 키)

FK(외래 키)란 다른 테이블의 PK를 참조하는 키이다.
즉, 두 테이블을 연결해주는 "다리" 역할을 한다고 보면 된다.

FK의 특징

• 한 테이블이 다른 테이블을 참조할 때 사용한다.
• PK의 값을 가져와서 사용한다.
• 연관된 데이터를 무결성 있게 관리할 수 있다.

Spring Boot JPA에서 FK 설정

import jakarta.persistence.*;

@Entity
public class Order {
    @Id
    @GeneratedValue(strategy = GenerationType.IDENTITY)
    private Long id;

    @ManyToOne // 다대일 관계 설정
    @JoinColumn(name = "user_id") // FK 컬럼명 지정
    private User user;

    private String product;
}

• @JoinColumn(name = "user_id")
  : FK 컬럼명을 user_id로 지정하는 것이다.

@ManyToOne이라는 어노테이션이 바로 연관관계 매핑 중 하나이다.

연관관계 매핑의 종류

1:1 (일대일)

• 하나의 엔티티가 다른 엔티티와 1:1로 연결하는 것이다
• 예) 사용자(User) - 프로필(Profile)

1:N (일대다)

• 하나의 엔티티가 여러 엔티티와 연결되는 것이다.
• 예) 사용자(User) - 주문(Order)

N:M (다대다)

• 여러 엔티티가 여러 엔티티와 연결되는 것이다.
• 예) 주문(Order) - 장바구니(Cart)

📍 1:1 (일대일) 관계

: 한 엔티티가 다른 엔티티와 1개의 관계만 가짐

User.java

@Entity
public class User {
    @Id @GeneratedValue(strategy = GenerationType.IDENTITY)
    private Long id;
    private String name;

    @OneToOne // 일대일 관계 설정
    @JoinColumn(name = "profile_id") // FK 설정
    private Profile profile;
}

• User 엔티티는 id(PK), name, profile(FK)를 멤버로 가진다.

Profile.java

@Entity
public class Profile {
    @Id @GeneratedValue(strategy = GenerationType.IDENTITY)
    private Long id;
    private String bio;
}

• Profile 엔티티는 id(PK), bio를 멤버로 가진다.

📍 1:N (일대다) 관계

User.java

@Entity
public class User {
    @Id @GeneratedValue(strategy = GenerationType.IDENTITY)
    private Long id;
    private String name;

    @OneToMany(mappedBy = "user") // 일대다 관계 설정
    private List<Order> orders = new ArrayList<>();
}

• User엔티티는 id(PK), name, orders를 멤버로 가진다.

Order.java

@Entity
public class Order {
    @Id @GeneratedValue(strategy = GenerationType.IDENTITY)
    private Long id;
    private String product;

    @ManyToOne
    @JoinColumn(name = "user_id") // FK 설정
    private User user;
}

• Order 엔티티는 id(PK), product, user(FK)를 멤버로 가진다.

여기서 FK는 @ManyToOne인 객체가 갖는 것이다.
mappedBy는 Order 테이블의 user 필드와 매핑한다는 뜻이다.

📍 N:M (다대다) 관계

다대다 관계에서는 중간 테이블을 생성하여 관리한다.
Student_Course라는 중간테이블에 id (PK), student_id(FK), course_id(FK) 이 세 멤버가 추가된다.

Student.java

@Entity
public class Student {
    @Id @GeneratedValue(strategy = GenerationType.IDENTITY)
    private Long id;
    private String name;

    @ManyToMany
    @JoinTable(
        name = "student_course",
        joinColumns = @JoinColumn(name = "student_id"),
        inverseJoinColumns = @JoinColumn(name = "course_id")
    ) // 중간 테이블 설정
    private List<Course> courses = new ArrayList<>();
}

Course.java

@Entity
public class Course {
    @Id @GeneratedValue(strategy = GenerationType.IDENTITY)
    private Long id;
    private String title;

    @ManyToMany(mappedBy = "courses")
    private List<Student> students = new ArrayList<>();
}

그러나 실무에서는 ManyToMany를 많이 사용하지 않는다.
추가적인 데이터 저장 불가능, 성능 문제, 데이터 변경 어려움 등의 이유라는데 일단 알아두기!

다음으로, 영속성 전이와 조회 방식에 대해 알아보자

Cascade (영속성 전이)

부모 엔티티의 변경이 자식 엔티티에도 영향을 미치도록 하는 설정

@OneToMany(mappedBy = "user", cascade = CascadeType.ALL)
private List<Order> orders = new ArrayList<>();

• CascadeType.ALL
  : User가 삭제되면 Order도 삭제됨
• CascadeType.PERSIST
  : User 저장 시 Order도 자동 저장
• CascadeType.REMOVE
  : User 삭제 시 Order도 삭제

FetchType (지연 로딩 vs 즉시 로딩)

연관된 엔티티를 조회할 때, 데이터를 즉시 가져올지(LAZY) 또는 필요할 때 가져올지(EAGER) 설정

@ManyToOne(fetch = FetchType.LAZY)
private User user;

• FetchType.LAZY
  : 필요할 때 데이터를 가져옴 (성능 최적화)
• FetchType.EAGER
  : 항상 데이터를 즉시 가져옴 (JOIN 실행됨, 성능 부담)

기본 설정

@OneToOne, @ManyToOne → 기본값 EAGER
@OneToMany, @ManyToMany → 기본값 LAZY