TIL Spring #3-3

 

Entity 연관관계

 

• 1:1
• N:1 
• 1:N
• N:M

 

---

 

 

 

실제로 테이블을 딱 한개만 사용하는 경우는 거의 없다.

DB table의 연관관계 Entity 객체의 연관관계 차이가 있을까? 있다면 어떻게 다를까?

 

예를 들어, 고객이 음식을 주문하는 프로그램을 작성한다고 가정해보자.

그렇다면 당연히 주문하는 고객 테이블 하나, 음식 테이블 하나 총 두개는 기본적으로 필요할 것이다.

그런데 고객이 음식을 주문했을 때 해당 주문건에 대한건 유저? 음식? 어느 테이블에 명시해줘야할까?

이를 유저나 음식 테이블에 넣게 되면 둘다 사용자, 음식 내용이 중복되는 이슈가 발생한다. 

 

 

이렇게 user_id 컬럼에 1번 2번 유저가 주문했다. 라는 표현 방식도 안될까?

일단 RDBMS 상에서는 불가능하다. 라고 이해하자.

 

 

- 2 row 로 표현이 되긴 한다! 그러나 음식의 이름이 불필요하게 중복된다!

 

 

 

<해결방안>

주문 정보를 넣을 중간 테이블을 따로 만들자!

 

 

정리해보면 고객도 음식 여러개를 주문할 수 있고 음식 또한 여러 고객에게 주문될 수 있다. -> N:M 관계!

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

 

<테이블의 방향?>

- DB 테이블 간 방향이 있을까? 

- 테이블에서는 원하는 정보를 고객, 음식 어딜 기준으로 하든 JOIN을 사용해 조회할 수 있으며

둘의 결과는 오차없이 똑같다. -> 방향의 개념 없음 

 

 

---

그렇다면 JPA Entity에서는?

 

결론적으로 Entity에서는 가능하다. 이것이 DB에 적용되는 것은 아니지만 

객체 형태에서는 참조를 단방향 양방향 두가지 모두 다 가능하다.

 

참고) 외래 키 주인만이 외래 키를 등록, 수정, 삭제할 수 있으며 주인이 아닌 쪽은 오직 읽기만 가능하다.

@JoinColumn 애너테이션으로 주인 지정

 

예제를 통해 해당 case별로 확인해보자. (일관성을 위해 음식 Entityd에만 주인 권한을 부여한다.)

 

 

 

<1:1>

 

# 1:1 관계 - 단방향

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

 

- 가장 간단하다 주인인 엔티티에 1:1 관계를 나타내는 @OneToOne 애너테이션 작성, 외래키의 주인임을 알려주는 @JoinColumn 애너테이션 작성해주면 된다.

 

# 1:1 관계 - 양방향

-외래키의 주인

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

 

- 외래키 주인 아닌 엔티티

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

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

 

- 양방향 관계에서는 주인이 아닌 엔티티에 하나 설정할 것이 있는데 바로 mappedBy 옵션이다.

 외래키의 주인을 지정해줄때 해당 옵션을 사용하며 지금 보이는 "user"라는 속성값은 User 클래스를 의미하는 것이 아닌

 외래키의 주인인 Food 엔티티의 필드명을 의미한다. (헷갈리지 않게 주의) 

 

- 디폴트 옵션 적용되기 때문에 생략이 가능하긴하나 모호한 경우 JPA에서 중간테이블을 생성할 수도 있기 때문에 반드시 명시해주는 것이 좋다.

 

<N:1>

 

# N:1 관계 - 단방향

- 이도 1:1 단방향 경우와 마찬가지로 주인 외래키 쪽에 애너테이션만 잘 작성해주면 된다.

 대신 OneToOne 대신 @ManyToOne 애너테이션을 사용한다.

 

 

# N:1 관계 - 양방향

- 이 경우도 1:1 양방향 경우와 비슷하다!

- 다만, 외래키의 주인이 아닌 클래스에 @OneToMany 라는 애너테이션 작성 필요.

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

    @ManyToOne //N:1 관계를 나타내는 애너테이션
    @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") //외래키의 주인을 알려줌.
    								//User 클래스 아니고
                                    //외래키의 주인인 Food 클래스의 필드인 user임!
    private List<Food> foodList = new ArrayList<>();
}

 

- 하나 알아 둘 것은 양방향 참조를 위해 고객 엔티티에서 자바 컬렉션을 사용하여 음식 엔티티를 참조한다! (음식을 하나만 주문할 것은 아니기에 여러개를 담아야한다.)

 

<1:N>

 

@OneToMany 애너테이션 사용

위에서 마찬가지로 외래키 주인을 음식으로 두자.

그런데 1:N 관계에서 N의 테이블이 외래키를 가질 수 있기 때문에 실제 외래키는 고객에 둔다.

 

-단방향

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

 

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

 

N 관계인 User에 잠시 외래키를 보관하고 음식에서 관리한다. 창고같은 느낌..

 

- 양방향 

해당 관계에서는 일반적으로 양방향 관계가 존재하지 않는다.

mappedBy 속성 또한 제공하지 않는다.

@JoinColumn에 insert/update에 false 값을 주어 양방향처럼 설정할 수는 있다. 

 

 

 

<N:M>

@ManyToMany 애너테이션 사용

 

글 앞머리에서 봤던 것처럼 해당 관계에서는 중간테이블을 만들어 사용한다. (orders)

 

- 단방향

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

 

- 해당 orders 테이블은 JPA에 의해 자동으로 만들어진다. PK 존재하지 않는다. 

 

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

 

 

- 양방향

 

- 외래키 주인이 아닌 고객의 코드만 변경된다.

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

 

# N:M 양방향 테스트 코드

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

 

- food.addUserList 메서드를 사용해 보다 객체지향적인 방법으로 외래키를 설정해준다.

 

<중간테이블을 직접 생성하여 작성해보기>

- order 테이블을 직접 생성해서 사용한다. -> 변경발생시 컨트롤하기 쉽기 때문에 확장성에 용이하다.

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

 

- 이제 외래키의 주인은 음식, 고객이 아닌 주문이 된다.