[내일배움캠프_Spring Boot 숙련주차] JPA 한 걸음 더 나아가기(Entity 연관관계, 1대 1, N대 1, 1대 N, N대 M)

Entity 연관 관계

주문 APP DB table 설계

고객(users) 테이블

id	name
1	Robbie
2	Robbert

create table users
(
    id   bigint not null auto_increment,
    name varchar(255),
    primary key (id)
);

음식(food) 테이블

id	name	price
1	후라이드 치킨	15000
2	양념 치킨	20000
3	고구마 피자	30000
4	아보카도 피자	50000

create table food
(
    id    bigint not null auto_increment,
    name  varchar(255),
    price float(53) not null,
    primary key (id)
);

DB 테이블 간의 연관 관계

🚨 연관 관계 고민

[고객 테이블 입장]

한 명의 고객은 음식을 여러개 주문할 수 있음 → 고객과 음식은 1 대 N 관계

고객 테이블에 주문한 음식의 정보를 파악하기 위해 food_id 컬럼 추가

id	name	food_id
1	Robbie	1
2	Robbert	1
3	Robbie	2

Robbie 데이터를 보면 불필요하게 고객의 이름이 중복되는 문제 발생함

[음식 테이블 입장]

하나의 음식은 여러명의 고객에게 주문될 수 있음 → 음식과 고객은 1대 N 관계

음식 테이블에 주문한 고객의 정보를 파악하기 위해 user_id 컬럼 추가

id	name	price	user_id
1	후라이드 치킨	15000	1
2	후라이드 치킨	15000	2
3	양념 치킨	20000	1

후라이드 치킨을 여러 사람이 주문하게 되었을 때, 불필요하게 음식의 이름이 중복되는 문제 발생함

‼️ 위 문제 해결방법 ► 주문(Order) 테이블 생성

주문 테이블은 주문에 대한 정보 기록

create table orders
(
    id         bigint not null auto_increment,
    user_id    bigint,
    food_id    bigint,
    order_date date,
    primary key (id)
);

주문 테이블에서의 고객/음식 테이블 외래키 설정

alter table orders
    add constraint orders_user_fk
        foreign key (user_id)
            references users (id);

alter table orders
    add constraint orders_food_fk
        foreign key (food_id)
            references food (id);

INSERT 수행

INSERT INTO users (name) VALUES ('Robbie');
INSERT INTO users (name) VALUES ('Robbert');

INSERT INTO food (name, price) VALUES ('후라이드 치킨', 15000);
INSERT INTO food (name, price) VALUES ('양념 치킨', 20000);
INSERT INTO food (name, price) VALUES ('고구마 피자', 30000);
INSERT INTO food (name, price) VALUES ('아보카도 피자', 50000);

INSERT INTO orders (user_id, food_id, order_date) VALUES (1, 1, SYSDATE());
INSERT INTO orders (user_id, food_id, order_date) VALUES (2, 1, SYSDATE());
INSERT INTO orders (user_id, food_id, order_date) VALUES (2, 2, SYSDATE());
INSERT INTO orders (user_id, food_id, order_date) VALUES (1, 4, SYSDATE());
INSERT INTO orders (user_id, food_id, order_date) VALUES (2, 3, SYSDATE());

﹡중복 문제 해결됨!

고객 1명은 음식 N개를 주문할 수 있음 → 고객 : 음식 = 1 : N 관계
음식 1개는 고객 N명에게 주문될 수 있음 → 음식 : 고객 = 1 : N 관계
결론적으로 고객과 음식은 N : M 관계임 → 고객 : 음식 = N : M 관계

﹡N:M 관계인 테이블들의 연관 관계를 해결하기 위해 중간 테이블 사용할 수 있음

테이블 간의 방향

DB 테이블간의 관계에서 방향은 크게 단방향과 양방향이 존재할 수 있음

단방향: users 테이블에서만 food 테이블 참조할 수 있을 때
양방향: users 테이블과 food 테이블이 서로를 참조할 수 있을 때

ex) 고객 'Robbie'가 주문한 음식 정보를 users 테이블 기준으로 조회

SELECT u.name as username, f.name as foodname, o.order_date as orderdate
FROM users u
         INNER JOIN orders o on u.id = o.user_id
         INNER JOIN food f on o.food_id = f.id
WHERE o.user_id = 1;

ex) food 테이블 기준으로 'Robbie'가 주문한 음식 정보 조회

SELECT u.name as username, f.name as foodname, o.order_date as orderdate
FROM food f
         INNER JOIN orders o on f.id = o.food_id
         INNER JOIN users u on o.user_id = u.id
WHERE o.user_id = 1;

위 두 결과는 동일함! 즉, DB에서는 어떤 테이블을 기준으로 하든 원하는 정보를 JOIN을 사용해서 조회할 수 있음!

따라서, DB에서는 테이블 사이의 연관 관계를 FK(외래 키)로 맺을 수 있고, 방향 상관없이 조회가 가능(방향 개념 X)

Entity 간의 연관 관계

JPA Entity에서의 테이블간의 연관관계 표현 방식

[음식 : 고객 = N : 1 관계 표현]

// 음식 테이블
@Entity
@Table(name = "food")
public class Food {
    @Id
    @GeneratedValue(strategy = GenerationType.IDENTITY)
    private Long id;
    private String name;
    private double price;
    
    @ManyToOne
    @JoinColumn(name = "user_id")
    private User user;
}

// 고객 테이블
@Entity
@Table(name = "users")
public class User {
    @Id
    @GeneratedValue(strategy = GenerationType.IDENTITY)
    private Long id;
    private String name;
    
    @OneToMany(mappedBy = "user")
    private List<Food> foodList = new ArrayList<>();
}

한 명의 고객은 여러번 주문이 가능한 상황으로, 이를 Entity에서 여러번 가능함을 표현하기 위해 Java 컬렉션을 사용해 List 형식으로 표현
DB 테이블에서는 고객 테이블 기준으로 음식의 정보를 조회하려고 할 때 JOIN을 사용해 바로 조회가 가능하지만,
고객 Entity 입장에서는 음식 Entity 정보를 가지고 있지 않으면 음식의 정보를 조회할 방법이 없음!
따라서 DB 테이블에 실제 컬럼으로 존재하지 않지만 Entity 상태에서 다른 Entity를 참조하기 위해 위와 같은 방법 사용
현재 음식 Entity와 고객 Entity는 서로를 참조하고 있기 때문에, 이러한 관계를 양방향 관계라고 부름

[단방향 관계]

// 음식 테이블
@Entity
@Table(name = "food")
public class Food {
    @Id
    @GeneratedValue(strategy = GenerationType.IDENTITY)
    private Long id;
    private String name;
    private double price;
    
    @ManyToOne
    @JoinColumn(name = "user_id")
    private User user;
}

// 고객 테이블
@Entity
@Table(name = "users")
public class User {
    @Id
    @GeneratedValue(strategy = GenerationType.IDENTITY)
    private Long id;
    private String name;
}

음식 Entity에서만 고객 Entity 참조할 수 있음
고객 Entity에는 음식 Entity의 정보가 없기 때문에 음식 정보를 조회할 수 없음

즉, Entity에서는 상대 Entity를 참조해 Entity 사이의 연관관계를 맺을 수 있음! 따라서 Entity에서는 DB 테이블에는 없는 방향의 개념이 존재함

1 대 1 관계

@OneToOne 어노테이션은 1대 1 관계를 맺어주는 역할 수행

ex) 고객 Entity와 음식 Entity가 1대 1 관계라 가정하고 관계 맺어보기

단방향 관계

외래 키 주인 정하기

Entity에서 외래 키의 주인은 일반적으로 N(다)의 관계인 Entity 이지만, 1대 1 관계에서는 외래 키의 주인을 직접 지정해야함
외래 키 주인만이 외래 키를 등록, 수정, 삭제할 수 있으며, 주인이 아닌 쪽은 오직 외래 키를 읽기만 가능!
@JoinColumn()은 외래 키의 주인이 활용하는 애너테이션으로, 컬럼명, null 여부, unique 여부 등 지정 가능

1) 음식 Entity가 외래 키 주인인 경우

package com.sparta.jpaadvance.entity;

import jakarta.persistence.*;
import lombok.Getter;
import lombok.Setter;

@Entity
@Getter
@Setter
@Table(name = "food")
public class Food {
    @Id
    @GeneratedValue(strategy = GenerationType.IDENTITY)
    private Long id;
    private String name;
    private double price;

    @OneToOne
    @JoinColumn(name = "user_id")
    private User user;
}

package com.sparta.jpaadvance.entity;

import jakarta.persistence.*;
import lombok.Getter;
import lombok.Setter;

@Entity
@Getter
@Setter
@Table(name = "users")
public class User {
    @Id
    @GeneratedValue(strategy = GenerationType.IDENTITY)
    private Long id;
    private String name;
}

2) 고객 Entity가 외래 키 주인인 경우

단방향 관계 테스트

package com.sparta.jpaadvance.relation;

import com.sparta.jpaadvance.entity.Food;
import com.sparta.jpaadvance.entity.User;
import com.sparta.jpaadvance.repository.FoodRepository;
import com.sparta.jpaadvance.repository.UserRepository;
import org.junit.jupiter.api.DisplayName;
import org.junit.jupiter.api.Test;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.test.context.SpringBootTest;
import org.springframework.test.annotation.Rollback;
import org.springframework.transaction.annotation.Transactional;

@Transactional
@SpringBootTest
public class OneToOneTest {
    @Autowired
    FoodRepository foodRepository;
    @Autowired
    UserRepository userRepository;

    @Test
    @Rollback(value = false) // 테스트에서는 @Transactional 에 의해 자동 rollback 됨으로 false 설정해준다.
    @DisplayName("1대1 단방향 테스트")
    void test1() {

        User user = new User();
        user.setName("Robbie");

        // 외래 키의 주인인 Food Entity user 필드에 user 객체를 추가해 줍니다.
        Food food = new Food();
        food.setName("후라이드 치킨");
        food.setPrice(15000);
        food.setUser(user); // 외래 키(연관 관계) 설정

        userRepository.save(user);
        foodRepository.save(food);
    }
}

양방향 관계

양방향 관계에서 외래 키의 주인을 지정해 줄 때 mappedBy 옵션 사용함
- mappedBy의 속성값은 외래 키의 주인인 상대 Entity의 필드명을 의미
외래 키의 주인은 상대 Entity 타입의 필드를 가지면서 @JoinColumn()을 활용해 외래 키의 속성 설정
상대 Entity는 외래 키의 주인 Entity 타입의 필드를 가지면서 mappedBy 옵션을 사용해 속성 값으로 외래 키의 주인 Entity에 선언된 @JoinColumn()으로 설정되고 있는 필드명 넣어주면됨!

1) 음식 Entity가 외래 키 주인인 경우

package com.sparta.jpaadvance.entity;

import jakarta.persistence.*;
import lombok.Getter;
import lombok.Setter;

@Entity
@Getter
@Setter
@Table(name = "food")
public class Food {
    @Id
    @GeneratedValue(strategy = GenerationType.IDENTITY)
    private Long id;
    private String name;
    private double price;

    @OneToOne
    @JoinColumn(name = "user_id")
    private User user;
}

package com.sparta.jpaadvance.entity;

import jakarta.persistence.*;
import lombok.Getter;
import lombok.Setter;

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

    @OneToOne(mappedBy = "user")
    private Food food;

    public void addFood(Food food) {
        this.food = food;
        food.setUser(this);
    }
}

2) 고객 Entity가 외래 키 주인인 경우

양방향 관계 테스트 1

@Test
@Rollback(value = false)
@DisplayName("1대1 양방향 테스트 : 외래 키 저장 실패")
void test2() {
    Food food = new Food();
    food.setName("고구마 피자");
    food.setPrice(30000);

    // 외래 키의 주인이 아닌 User 에서 Food 를 저장해보겠습니다.
    User user = new User();
    user.setName("Robbie");
    user.setFood(food);

    userRepository.save(user);
    foodRepository.save(food);

    // 확인해 보시면 user_id 값이 들어가 있지 않은 것을 확인하실 수 있습니다.
}

► 외래 키의 주인만이 외래 키를 컨트롤할 수 있음!

양방향 관계 테스트 2

@Test
@Rollback(value = false)
@DisplayName("1대1 양방향 테스트 : 외래 키 저장 실패 -> 성공")
void test3() {
    Food food = new Food();
    food.setName("고구마 피자");
    food.setPrice(30000);

    // 외래 키의 주인이 아닌 User 에서 Food 를 저장하기 위해 addFood() 메서드 추가
    // 외래 키(연관 관계) 설정 food.setUser(this); 추가
    User user = new User();
    user.setName("Robbie");
    user.addFood(food);

    userRepository.save(user);
    foodRepository.save(food);
}

► 외래 키의 주인만이 외래 키를 컨트롤할 수 있음!

양방향 관계 테스트 3

@Test
@Rollback(value = false)
@DisplayName("1대1 양방향 테스트")
void test4() {
    User user = new User();
    user.setName("Robbert");

    Food food = new Food();
    food.setName("고구마 피자");
    food.setPrice(30000);
    food.setUser(user); // 외래 키(연관 관계) 설정

    userRepository.save(user);
    foodRepository.save(food);
}

⚠️ 주의

1. 외래 키의 주인 Entity에서 @JoinColumn() 어노테이션을 사용하지 않아도 default 옵션이 적용되기 때문에 생략 가능함!

다만, 1대 N 관계에서 외래 키의 주인 Entity가 @JoinColumn() 어노테이션을 생략한다면, JPA가 외래키를 저장할 컬럼을 파악할 수 없어서 의도하지 않은 중간 테이블 생성됨

2. 양방향 관계에서 mappedBy 옵션을 생략할 경우 JPA가 외래 키의 주인 Entity를 파악할 수 없어 의도하지 않은 중간 테이블 생성되기 때문에 반드시 설정해주는게 좋음!

N대 1 관계

@ManyToOne 어노테이션은 N 대 1 관계를 맺어주는 역할을 함

ex) 음식 Entity와 고객 Entity가 N 대 1 관계라 가정하고 관계를 맺어보기

단방향 관계

음식 Entity가 N의 관계로 외래 키의 주인인 경우

package com.sparta.jpaadvance.entity;

import jakarta.persistence.*;
import lombok.Getter;
import lombok.Setter;

@Entity
@Getter
@Setter
@Table(name = "food")
public class Food {
    @Id
    @GeneratedValue(strategy = GenerationType.IDENTITY)
    private Long id;
    private String name;
    private double price;

    @ManyToOne
    @JoinColumn(name = "user_id")
    private User user;
}

package com.sparta.jpaadvance.entity;

import jakarta.persistence.*;
import lombok.Getter;
import lombok.Setter;

@Entity
@Getter
@Setter
@Table(name = "users")
public class User {
    @Id
    @GeneratedValue(strategy = GenerationType.IDENTITY)
    private Long id;
    private String name;
}

단방향 관계 테스트

@Test
@Rollback(value = false)
@DisplayName("N대1 단방향 테스트")
void test1() {
    User user = new User();
    user.setName("Robbie");

    Food food = new Food();
    food.setName("후라이드 치킨");
    food.setPrice(15000);
    food.setUser(user); // 외래 키(연관 관계) 설정

    Food food2 = new Food();
    food2.setName("양념 치킨");
    food2.setPrice(20000);
    food2.setUser(user); // 외래 키(연관 관계) 설정

    userRepository.save(user);
    foodRepository.save(food);
    foodRepository.save(food2);
}

양방향 관계

양방향 참조를 위해 고객 Entity에서 Java 컬렉션을 사용해 음식 Entity 참조

package com.sparta.jpaadvance.entity;

import jakarta.persistence.*;
import lombok.Getter;
import lombok.Setter;

@Entity
@Getter
@Setter
@Table(name = "food")
public class Food {
    @Id
    @GeneratedValue(strategy = GenerationType.IDENTITY)
    private Long id;
    private String name;
    private double price;

    @ManyToOne
    @JoinColumn(name = "user_id")
    private User user;
}

package com.sparta.jpaadvance.entity;

import jakarta.persistence.*;
import lombok.Getter;
import lombok.Setter;

import java.util.ArrayList;
import java.util.List;

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

    @OneToMany(mappedBy = "user")
    private List<Food> foodList = new ArrayList<>();

    public void addFoodList(Food food) {
        this.foodList.add(food);
        food.setUser(this); // 외래 키(연관 관계) 설정
    }
}

양방향 관계 테스트 1

@Test
@Rollback(value = false)
@DisplayName("N대1 양방향 테스트 : 외래 키 저장 실패")
void test2() {

    Food food = new Food();
    food.setName("후라이드 치킨");
    food.setPrice(15000);

    Food food2 = new Food();
    food2.setName("양념 치킨");
    food2.setPrice(20000);

    // 외래 키의 주인이 아닌 User 에서 Food 를 저장해보겠습니다.
    User user = new User();
    user.setName("Robbie");
    user.getFoodList().add(food);
    user.getFoodList().add(food2);

    userRepository.save(user);
    foodRepository.save(food);
    foodRepository.save(food2);

    // 확인해 보시면 user_id 값이 들어가 있지 않은 것을 확인하실 수 있습니다.
}

양방향 관계 테스트 2

@Test
@Rollback(value = false)
@DisplayName("N대1 양방향 테스트 : 외래 키 저장 실패 -> 성공")
void test3() {

    Food food = new Food();
    food.setName("후라이드 치킨");
    food.setPrice(15000);

    Food food2 = new Food();
    food2.setName("양념 치킨");
    food2.setPrice(20000);

    // 외래 키의 주인이 아닌 User 에서 Food 를 쉽게 저장하기 위해 addFoodList() 메서드 생성하고
    // 해당 메서드에 외래 키(연관 관계) 설정 food.setUser(this); 추가
    User user = new User();
    user.setName("Robbie");
    user.addFoodList(food);
    user.addFoodList(food2);

    userRepository.save(user);
    foodRepository.save(food);
    foodRepository.save(food2);
}

양방향 관계 테스트 3

@Test
@Rollback(value = false)
@DisplayName("N대1 양방향 테스트")
void test4() {
    User user = new User();
    user.setName("Robbert");

    Food food = new Food();
    food.setName("고구마 피자");
    food.setPrice(30000);
    food.setUser(user); // 외래 키(연관 관계) 설정

    Food food2 = new Food();
    food2.setName("아보카도 피자");
    food2.setPrice(50000);
    food2.setUser(user); // 외래 키(연관 관계) 설정

    userRepository.save(user);
    foodRepository.save(food);
    foodRepository.save(food2);
}

1대 N 관계

@OneToMany 어노테이션은 1 대 다 관계를 맺어주는 역할을 함

ex) 음식 Entity와 고객 Entity가 1 대 다 관계라 가정하고 관계를 맺어보기

단방향 관계

외래 키를 관리하는 주인은 음식 Entity이지만 실제 외래 키는 고객 Entity가 가지고 있음
→ 1 : N에서 N 관계의 테이블이 외래 키를 가질 수 있기 때문에 외래 키는 N 관계인 users 테이블에 외래 키 컬럼을 만들어 추가하지만 외래 키의 주인인 음식 Entity를 통해 관리함

외래 키를 음식 Entity가 직접 가질 수 있다면 INSERT 발생 시 한번에 처리할 수 있지만 실제 DB에서 외래 키를 고객 테이블이 가지고 있기 때문에 추가적인 UPDATE가 발생한다는 단점이 존재함

package com.sparta.jpaadvance.entity;

import jakarta.persistence.*;
import lombok.Getter;
import lombok.Setter;

import java.util.ArrayList;
import java.util.List;

@Entity
@Getter
@Setter
@Table(name = "food")
public class Food {
    @Id
    @GeneratedValue(strategy = GenerationType.IDENTITY)
    private Long id;
    private String name;
    private double price;

    @OneToMany
    @JoinColumn(name = "food_id") // users 테이블에 food_id 컬럼
    private List<User> userList = new ArrayList<>();
}

package com.sparta.jpaadvance.entity;

import jakarta.persistence.*;
import lombok.Getter;
import lombok.Setter;

@Entity
@Getter
@Setter
@Table(name = "users")
public class User {
    @Id
    @GeneratedValue(strategy = GenerationType.IDENTITY)
    private Long id;
    private String name;
}

단방향 관계 테스트

@Test
@Rollback(value = false)
@DisplayName("1대N 단방향 테스트")
void test1() {
    User user = new User();
    user.setName("Robbie");

    User user2 = new User();
    user2.setName("Robbert");

    Food food = new Food();
    food.setName("후라이드 치킨");
    food.setPrice(15000);
    food.getUserList().add(user); // 외래 키(연관 관계) 설정
    food.getUserList().add(user2); // 외래 키(연관 관계) 설정

    userRepository.save(user);
    userRepository.save(user2);
    foodRepository.save(food);

    // 추가적인 UPDATE 쿼리 발생을 확인할 수 있습니다.
}

양방향 관계

1대 N 관계에서는 일반적으로 양방향 관계가 존재하지 않음
1대 N 관계에서 양방향 관계를 맺으려면 음식 Entity를 외래 키의 주인으로 정해주기 위해 고객 Entity에서 mappedBy 옵션을 사용해야 하지만 @ManyToOne 어노테이션은 mappedBy 속성을 제공하지 않음
N 관계의 Entity인 고객 Entity에서 @JoinColumn의 insertable과 updatable 옵션을 false로 설정해 양쪽으로 JOIN 설정을 하면 양방향처럼 설정할 수 있지만, 추천하지는 않음!

@Entity
@Table(name = "users")
public class User {
    @Id
    @GeneratedValue(strategy = GenerationType.IDENTITY)
    private Long id;
    private String name;
    
    @ManyToOne
    @JoinColumn(name = "food_id", insertable = false, updatable = false)
    private Food food;
}

N대 M 관계

@ManyToMany 어노테이션은 N 대 M 관계를 맺어주는 역할을 함

ex) 음식 Entity와 고객 Entity가 N 대 M 관계라 가정하고 관계를 맺어보기

N대 M관계를 위해 중간 테이블 생성해서 사용함

단방향 관계

음식 Entity가 외래 키의 주인인 경우

package com.sparta.jpaadvance.entity;

import jakarta.persistence.*;
import lombok.Getter;
import lombok.Setter;

import java.util.ArrayList;
import java.util.List;

@Entity
@Getter
@Setter
@Table(name = "food")
public class Food {
    @Id
    @GeneratedValue(strategy = GenerationType.IDENTITY)
    private Long id;
    private String name;
    private double price;

    @ManyToMany
    @JoinTable(name = "orders", // 중간 테이블 생성
            joinColumns = @JoinColumn(name = "food_id"), // 현재 위치인 Food Entity 에서 중간 테이블로 조인할 컬럼 설정
            inverseJoinColumns = @JoinColumn(name = "user_id")) // 반대 위치인 User Entity 에서 중간 테이블로 조인할 컬럼 설정
    private List<User> userList = new ArrayList<>();
}

package com.sparta.jpaadvance.entity;

import jakarta.persistence.*;
import lombok.Getter;
import lombok.Setter;

@Entity
@Getter
@Setter
@Table(name = "users")
public class User {
    @Id
    @GeneratedValue(strategy = GenerationType.IDENTITY)
    private Long id;
    private String name;
}

생성되는 중간 테이블은 PK가 존재하지 않음. 즉, 생성되는 중간 테이블을 컨트롤하기 어렵기 때문에 추후에 중간 테이블의 변경이 발생할 경우 문제가 발생할 가능성이 있음

단방향 관계 테스트

@Test
@Rollback(value = false)
@DisplayName("N대M 단방향 테스트")
void test1() {

    User user = new User();
    user.setName("Robbie");

    User user2 = new User();
    user2.setName("Robbert");

    Food food = new Food();
    food.setName("후라이드 치킨");
    food.setPrice(15000);
    food.getUserList().add(user);
    food.getUserList().add(user2);

    userRepository.save(user);
    userRepository.save(user2);
    foodRepository.save(food);

    // 자동으로 중간 테이블 orders 가 create 되고 insert 됨을 확인할 수 있습니다.
}

양방향 관계

음식 Entity가 외래 키의 주인인 경우

package com.sparta.jpaadvance.entity;

import jakarta.persistence.*;
import lombok.Getter;
import lombok.Setter;

import java.util.ArrayList;
import java.util.List;

@Entity
@Getter
@Setter
@Table(name = "food")
public class Food {
    @Id
    @GeneratedValue(strategy = GenerationType.IDENTITY)
    private Long id;
    private String name;
    private double price;

    @ManyToMany
    @JoinTable(name = "orders", // 중간 테이블 생성
            joinColumns = @JoinColumn(name = "food_id"), // 현재 위치인 Food Entity 에서 중간 테이블로 조인할 컬럼 설정
            inverseJoinColumns = @JoinColumn(name = "user_id")) // 반대 위치인 User Entity 에서 중간 테이블로 조인할 컬럼 설정
    private List<User> userList = new ArrayList<>();
}

package com.sparta.jpaadvance.entity;

import jakarta.persistence.*;
import lombok.Getter;
import lombok.Setter;

import java.util.ArrayList;
import java.util.List;

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

    @ManyToMany(mappedBy = "userList")
    private List<Food> foodList = new ArrayList<>();
}

반대 방향인 고객 Entity에 @ManyToMany로 음식 Entity로 연결하고 mappedBy 옵션을 설정해 외래 키의 주인을 설정하면 양방향 관계 맺음이 가능함

양방향 관계 테스트 1

@Test
@Rollback(value = false)
@DisplayName("N대M 양방향 테스트 : 외래 키 저장 실패")
void test2() {

    Food food = new Food();
    food.setName("후라이드 치킨");
    food.setPrice(15000);

    Food food2 = new Food();
    food2.setName("양념 치킨");
    food2.setPrice(20000);

    // 외래 키의 주인이 아닌 User 에서 Food 를 저장해보겠습니다.
    User user = new User();
    user.setName("Robbie");
    user.getFoodList().add(food);
    user.getFoodList().add(food2);

    userRepository.save(user);
    foodRepository.save(food);
    foodRepository.save(food2);

    // 확인해 보시면 orders 테이블에 food_id, user_id 값이 들어가 있지 않은 것을 확인하실 수 있습니다.
}

양방향 관계 테스트 2

@Test
@Rollback(value = false)
@DisplayName("N대M 양방향 테스트 : 외래 키 저장 실패 -> 성공")
void test3() {

    Food food = new Food();
    food.setName("후라이드 치킨");
    food.setPrice(15000);

    Food food2 = new Food();
    food2.setName("양념 치킨");
    food2.setPrice(20000);

    // 외래 키의 주인이 아닌 User 에서 Food 를 쉽게 저장하기 위해 addFoodList() 메서드를 생성해서 사용합니다.
    // 외래 키(연관 관계) 설정을 위해 Food 에서 userList 를 호출해 user 객체 자신을 add 합니다.
    User user = new User();
    user.setName("Robbie");
    user.addFoodList(food);
    user.addFoodList(food2);


    userRepository.save(user);
    foodRepository.save(food);
    foodRepository.save(food2);
}

양방향 관계 테스트 3

@Test
@Rollback(value = false)
@DisplayName("N대M 양방향 테스트")
void test4() {

    User user = new User();
    user.setName("Robbie");

    User user2 = new User();
    user2.setName("Robbert");


    Food food = new Food();
    food.setName("아보카도 피자");
    food.setPrice(50000);
    food.getUserList().add(user); // 외래 키(연관 관계) 설정
    food.getUserList().add(user2); // 외래 키(연관 관계) 설정

    Food food2 = new Food();
    food2.setName("고구마 피자");
    food2.setPrice(30000);
    food2.getUserList().add(user); // 외래 키(연관 관계) 설정

    userRepository.save(user);
    userRepository.save(user2);
    foodRepository.save(food);
    foodRepository.save(food2);

    // User 를 통해 food 의 정보 조회
    System.out.println("user.getName() = " + user.getName());

    List<Food> foodList = user.getFoodList();
    for (Food f : foodList) {
        System.out.println("f.getName() = " + f.getName());
        System.out.println("f.getPrice() = " + f.getPrice());
    }

    // 외래 키의 주인이 아닌 User 객체에 Food 의 정보를 넣어주지 않아도 DB 저장에는 문제가 없지만
    // 이처럼 User 를 사용하여 food 의 정보를 조회할 수는 없습니다.
}

외래 키의 주인이 아닌 User 객체에 Food 정보를 넣어주지 않았기 때문에 출력되지 않음
즉 양방향 관계일 때, 외래 키의 주인이 아닌 쪽에 데이터를 넣어주지 않으면 로직 수행 X

양방향 관계 테스트 4

@Test
@Rollback(value = false)
@DisplayName("N대M 양방향 테스트 : 객체와 양방향의 장점 활용")
void test5() {

    User user = new User();
    user.setName("Robbie");

    User user2 = new User();
    user2.setName("Robbert");


    // addUserList() 메서드를 생성해 user 정보를 추가하고
    // 해당 메서드에 객체 활용을 위해 user 객체에 food 정보를 추가하는 코드를 추가합니다. user.getFoodList().add(this);
    Food food = new Food();
    food.setName("아보카도 피자");
    food.setPrice(50000);
    food.addUserList(user);
    food.addUserList(user2);

    Food food2 = new Food();
    food2.setName("고구마 피자");
    food2.setPrice(30000);
    food2.addUserList(user);


    userRepository.save(user);
    userRepository.save(user2);
    foodRepository.save(food);
    foodRepository.save(food2);

    // User 를 통해 food 의 정보 조회
    System.out.println("user.getName() = " + user.getName());

    List<Food> foodList = user.getFoodList();
    for (Food f : foodList) {
        System.out.println("f.getName() = " + f.getName());
        System.out.println("f.getPrice() = " + f.getPrice());
    }
}

중간 테이블 만들기

위의 중간 테이블은 컨트롤하기 힘들기 때문에, 직접 중간 테이블을 생성해서 사용해 문제 해결하기

→ 외래 키의 주인이 Order Entity가 됨!

Order Entity(중간 테이블)

package com.sparta.jpaadvance.entity;

import jakarta.persistence.*;
import lombok.Getter;
import lombok.Setter;

@Entity
@Getter
@Setter
@Table(name = "orders")
public class Order {
    @Id
    @GeneratedValue(strategy = GenerationType.IDENTITY)
    private Long id;

    @ManyToOne
    @JoinColumn(name = "food_id")
    private Food food;

    @ManyToOne
    @JoinColumn(name = "user_id")
    private User user;
}

Food Entity

package com.sparta.jpaadvance.entity;

import jakarta.persistence.*;
import lombok.Getter;
import lombok.Setter;

import java.util.ArrayList;
import java.util.List;

@Entity
@Getter
@Setter
@Table(name = "food")
public class Food {
    @Id
    @GeneratedValue(strategy = GenerationType.IDENTITY)
    private Long id;
    private String name;
    private double price;

    @OneToMany(mappedBy = "food")
    private List<Order> orderList = new ArrayList<>();
}

User Entity

package com.sparta.jpaadvance.entity;

import jakarta.persistence.*;
import lombok.Getter;
import lombok.Setter;

import java.util.ArrayList;
import java.util.List;

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

    @OneToMany(mappedBy = "user")
    private List<Order> orderList = new ArrayList<>();
}

테스트 1

@Test
@Rollback(value = false)
@DisplayName("중간 테이블 Order Entity 테스트")
void test1() {

    User user = new User();
    user.setName("Robbie");

    Food food = new Food();
    food.setName("후라이드 치킨");
    food.setPrice(15000);

    // 주문 저장
    Order order = new Order();
    order.setUser(user); // 외래 키(연관 관계) 설정
    order.setFood(food); // 외래 키(연관 관계) 설정

    userRepository.save(user);
    foodRepository.save(food);
    orderRepository.save(order);
}

조회 테스트 2

@Test
@DisplayName("중간 테이블 Order Entity 조회")
void test2() {
    // 1번 주문 조회
    Order order = orderRepository.findById(1L).orElseThrow(NullPointerException::new);

    // order 객체를 사용하여 고객 정보 조회
    User user = order.getUser();
    System.out.println("user.getName() = " + user.getName());

    // order 객체를 사용하여 음식 정보 조회
    Food food = order.getFood();
    System.out.println("food.getName() = " + food.getName());
    System.out.println("food.getPrice() = " + food.getPrice());
}

'백엔드 > spring&springboot' 카테고리의 다른 글

[내일배움캠프_Spring Boot 숙련주차] My Select Shop(상품 검색, 관심 상품 등록, 관심 상품 희망 최저가 수정, 관심 상품 조회 API 구현, Scheduler 구현) (0)	2026.06.30
[내일배움캠프_Spring Boot 숙련주차] JPA 한 걸음 더 나아가기(지연 로딩과 즉시 로딩, 영속성 전이, 고아 Entity) (0)	2026.06.30
[내일배움캠프_Spring Boot 숙련주차] RestTemplate & Open API (0)	2026.06.30
[내일배움캠프_Spring Boot 숙련주차] 데이터 검증하기(Validation) (0)	2026.06.29
[내일배움캠프_Spring Boot 숙련주차] 사용자 관리하기(Spring Security, 접근 불가 페이지 만들기) (0)	2026.06.29

차곡차곡🐿️

[내일배움캠프_Spring Boot 숙련주차] JPA 한 걸음 더 나아가기(Entity 연관관계, 1대 1, N대 1, 1대 N, N대 M)

Entity 연관 관계

주문 APP DB table 설계

DB 테이블 간의 연관 관계

테이블 간의 방향

Entity 간의 연관 관계

1 대 1 관계

단방향 관계

양방향 관계

⚠️ 주의

N대 1 관계

단방향 관계

양방향 관계

1대 N 관계

단방향 관계

양방향 관계

N대 M 관계

단방향 관계

양방향 관계

중간 테이블 만들기

'백엔드 > spring&springboot' 카테고리의 다른 글

티스토리툴바

[내일배움캠프_Spring Boot 숙련주차] JPA 한 걸음 더 나아가기(Entity 연관관계, 1대 1, N대 1, 1대 N, N대 M)

Entity 연관 관계

주문 APP DB table 설계

DB 테이블 간의 연관 관계

테이블 간의 방향

Entity 간의 연관 관계

1 대 1 관계

단방향 관계

양방향 관계

⚠️ 주의

N대 1 관계

단방향 관계

양방향 관계

1대 N 관계

단방향 관계

양방향 관계

N대 M 관계

단방향 관계

양방향 관계

중간 테이블 만들기

'백엔드 > spring&springboot' 카테고리의 다른 글

관련글

티스토리툴바