[스프링 2팀] 9장. 연관관계 매핑

 

 

연관관계 매핑 종류와 방향

 

연관관계를 맺는 두 엔티티 간에 생성할 수 있는 연관관계의 종류

• One To One : 일대일
• One To Many : 일대다
• Many To One: 다대일
• Many To Many: 다대다

데이터베이스에서는 두 테이블의 연관관계를 설정하면 "외래키"를 통해 서로 조인해서 참조하는 구조로 생성

 

JPA를 사용하는 객체지향 모델에서는 엔티티 간 참조 방향을 설정

 

데이터베이스와 관계를 일치시키기 위해 양방향으로 설정해도 무관하지만 비즈니스 로직의 관점에서 봤을 때 는 단방향 관계만 설정해도 해결되는 경우가 많음

• 단방향: 두 엔티티의 관계에서 한쪽의 엔티티만 참조하는 형식
• 양방향: 두 엔티티의 관계에서 각 엔티티가 서로의 엔티티를 참조하는 형식 

 

일대일 매핑

• Product 엔티티를 대상으로 상품 정보 테이블을 일대일 매핑하는 예제
• 하나의 상품에 하나의 상품정보만 매핑되는 일대일 관계

 

일대일 단방향 매핑

• entity 패키지 안에 상품 정보 ProductDetail  엔티티를 작성

@Entity
@Table(name = "product_detail")
@Getter
@Setter
@NoArgsConstructor
@ToString(callSuper = true)
@EqualsAndHashCode(callSuper = true)
public class ProductDetail extends BaseEntity  {

    @Id
    @GeneratedValue(strategy = GenerationType.IDENTITY)
    private Long id;

    private String description;

    @OneToOne
    @JoinColumn(name = "product_number")
    private Product product;
}

 

• @OneToOne 어노테이션: 다른 엔티티 객체를 필드로 정의했을 때 일대일 연관관계로 매핑하기 위해 사용
• @JoinColum 어노테이션: 매핑할 외래키를 설정
• @JoinColum 어노테이션은 기본값이 설정되어 있어 자동으로 이름을 매핑,
  그러나 의도한 이름이 들어가지 않기 때문에 name 속성을 사용해 원하는 칼럼명을 지정하는 것이 좋다.
• 간단하게 @JoinColum 어노테이션에서 사용할 수 있는 속성들
  • name: 매핑할 외래키의 이름을 설정
  • referencedColumnName: 외래키가 참조할 상대 테이블의 칼럼명을 지정
  • foreignkey: 외래키를 생성하면서 지정할 제약조건을 설정( unique. nullable, insertable. updatable 등).

 

• 생성된 상품정보 엔티티 객체들을 사용하기 위해 리포지토리 인터페이스를 생성

// data/repository/ProductDetailRepository.java
public interface ProductDetailRepository extends JpaRepository<ProductDetail, Long> {
}

 

• 연관 관계를 활용한 데이터 생성 및 조회 기능 테스트 코드

// test/com.springboot.relationship/data/repository/ProductDetailRepositoryTest.java
package com.springboot.relationship.data.repository;

import com.springboot.relationship.data.entity.Product;
import com.springboot.relationship.data.entity.ProductDetail;
import org.junit.jupiter.api.Test;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.test.context.SpringBootTest;

@SpringBootTest
public class ProductDetailRepositoryTest {

    // 상품과 상품 정보에 매핑된 리포지토리 의존성 주입
    @Autowired
    ProductDetailRepository productDetailRepository;
    
    @Autowired
    ProductRepository productRepository;
    
    @Test
    public void saveAndReadTest1(){
        Product product = new Product();
        product.setName("스프링부트 JPA");
        product.setPrice(5000);
        product.setStock(500);
        productRepository.save(product);

        ProductDetail productDetail = new ProductDetail();
        productDetail.setProduct(product);
        productDetail.setDescription("스프링 부트와 JPA를 함께 볼 수 있는 책");
        
        productDetailRepository.save(productDetail);
        
        // 생성한 데이터 조회
        System.out.println("savedProduct: " + productDetailRepository.findById(
                productDetail.getId()).get().getProduct());

        System.out.println("savedProductDetail: " + productDetailRepository.findById(
                productDetail.getId()).get());
        
    }
}

 

• 상품과 상품정보에 매핑된 리포지토리에 대해 의존성 주입
• ProductDeatil 객체에서 Product 객체를 일대일 단방향 연관관계를 설정했기 때문에 ProductDetailRepository에서 ProductDetail 객체를 조회한 후 연관관계 매핑된 Product 객체를 조회

 

• 테스트를 실행하고, select 구문을 보면 ProductDetail 객체와 Product 객체가 함께 조회
• 이처럼 엔티티를 조회할 때 연관된 엔티티도 함께 조회하는 것을 '즉시 로딩'이라 함.

 

• @OneToOne 어노테이션 인터페이스

public @interface OneToOne {
    Class targetEntity() default void.class;

    CascadeType[] cascade() default {};

    FetchType fetch() default FetchType.EAGER;

    boolean optional() default true;

    String mappedBy() default "";

    boolean orphanRemoval() default false;
}

 
 @ OneToOne 어노테이션은 기본 fetch 전략으로 EAGER(즉시 로딩) 전략이 채택

 

optional() 메서드는 기본값으로 true가 설정

 

기본값이 true인 상태는 매핑되는 값이 nullable이라는 것을 의미

 

@OneToOne 어노테이션에 'optional=false' 설정을 하면 product가 null인 값을 허용하지 않음

• 코드 변경 후 테스트 코드를 실행하면 left outer join이 inner join으로 바뀌어 실행되는 것을 확인

 

일대일 양방향 매핑

• 객체에서의 양 방향 개념은 양쪽에서 단방향으로 서로를 매핑하는 것을 의미

 

• Product 엔티티에 다음과 같이 추가

@Entity
// 생략..
public class Product extends BaseEntity  {

    @Id
    @GeneratedValue(strategy = GenerationType.IDENTITY)
    private Long number;

    @Column(nullable = false)
    private String name;

    @Column(nullable = false)
    private Integer price;

    @Column(nullable = false)
    private Integer stock;

    // 추가
    @OneToOne
    private ProductDetail productDetail;

}

 

• 테스트 코드를 실행하면 양쪽에서 외래키를 가지고 left outer join이 두 번이나 수행되어 효율성이 떨어짐
• 실제 데이터베이스에서도 테이블 간 연관관계를 맺으면 한쪽 테이블이 외래키를 가지는 구조 => '주인' 개념을 사용

 

• JPA에서도 데이터베이스의 연관관계를 반영해서 한 쪽의 테이블에서만 외래키를 바꿀 수 있도록 정하는 것이 좋음
• 이 경우 엔티티는 양방향으로 매핑하되 한쪽에게만 외래키를 줌
•  mappedBy : 어떤 객체가 주인인지 표시하는 속성

@Entity
@Getter
@Setter
@NoArgsConstructor
@ToString(callSuper = true)
@EqualsAndHashCode(callSuper = true)
@Table(name="product")
public class Product extends BaseEntity  {

    @Id
    @GeneratedValue(strategy = GenerationType.IDENTITY)
    private Long number;

    @Column(nullable = false)
    private String name;

    @Column(nullable = false)
    private Integer price;

    @Column(nullable = false)
    private Integer stock;

   
    @OneToOne(mappedBy = "product")
    private ProductDetail productDetail;

}

 

• mappedBy에 들어가는 값은 연관관계를 갖고 있는 상대 엔티티에 있는 연관관계 필드의 이름
• ProductDetail 엔티티가 Product 엔티티의 주인이 됨

테스트 코드를 실행하면 toString 실행 시점에서 StackOverflowError 발생 -> 양방향으로 연관관계가 설정되면 ToString을 사용할 때 순환 참조가 발생하기 때문

• 필요한 경우가 아니라면 대체로 단방향으로 연관관계를 설정하거나, 양방향 설정이 필요할 경우에는 순환참조 제거를 위해 exclude를 사용해 ToString에서 제외 설정해야함

// data/entity/Product.java
    @OneToOne(mappedBy = "product")
    @ToString.Exclude
    private ProductDetail productDetail;

 
 

다대일, 일대다 매핑

다대일 단방향 매핑

• Provider 엔티티 클래스 생성(공급업체 엔티티)

@Entity
@Getter
@Setter
@NoArgsConstructor
@ToString(callSuper = true)
@EqualsAndHashCode(callSuper = true)
@Table(name="provider")
public class Provider extends BaseEntity {

    @Id
    @GeneratedValue(strategy = GenerationType.IDENTITY)
    private Long id;


    private String name;
}

• BaseEntity를 통해 생성일자와 변경일자를 상속받음

 
 

• 상품 엔티티에 공급 업체 번호를 받기 위한 엔티티 필드 구성 추가

package com.springboot.relationship.data.entity;
// 생략..

public class Product extends BaseEntity  {

    // 생략..
    
    @ManyToOne
    @JoinColumn(name = "provider_id")
    @ToString.Exclude
    private Provider provider;
}

 

• 일반적으로 외래키를 갖는 쪽이 주인의 역할을 수행
• 이 경우 상품 엔티티가 공급업체 엔티티의 주인입니다. 

•  ProviderRepository를 생성

public interface ProviderRepository extends JpaRepository<Provider, Long> {
}

 
 

• ProductRepository를 활용한 테스트

package com.springboot.relationship.data.repository;

import com.springboot.relationship.data.entity.Product;
import com.springboot.relationship.data.entity.Provider;
import org.junit.jupiter.api.Test;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.test.context.SpringBootTest;

@SpringBootTest
public class ProviderRepositoryTest {
    // 의존성 주입
    @Autowired
    ProviderRepository providerRepository;
    
    @Autowired
    ProductRepository productRepository;
    
    @Test
    void relationshipTest1(){
        // 테스트 데이터 생산
        Provider provider = new Provider();
        provider.setName("Corner");
        
        providerRepository.save(provider);
        
        Product product = new Product();
        product.setName("가위");
        product.setPrice(5000);
        product.setStock(500);
        productRepository.save(product);

        // 테스트
        System.out.println("product: " + productRepository.findById(1L)
                .orElseThrow(RuntimeException::new));

        System.out.println("provider: " + productRepository.findById(1L)
                .orElseThrow(RuntimeException::new).getProvider());

    }
}

• 테스트 코드를 실행하면 쿼리로 데이터를 저장할 때 provider_id 값만 들어감
• product 테이블에 @JoinColum에 설정한 이름을 기반으로 자동으로 값을 선정해서 추가
• Product 엔티티에서 단방향으로 Provider 엔티티 연관관계를 맺고 있기 때문에 ProductRepository만으로 Provider 객체도 조회가 가능

 
 

 다대일 양방향 매핑

• 공급업체를 통해 등록된 상품을 조회하기 위한 일대다 연관관계를 설정
• JPA에서는 이처럼 양쪽에서 단방향으로 매핑하는 것이 양방향 매핑 방식

 

• 공급업체 엔티티에서만 연관관계를 설정

@Entity
@Getter
@Setter
@NoArgsConstructor
@ToString(callSuper = true)
@EqualsAndHashCode(callSuper = true)
@Table(name="provider")
public class Provider extends BaseEntity  {

    @Id
    @GeneratedValue(strategy = GenerationType.IDENTITY)
    private Long id;

    private String name;

    // @OneToMany의 기본 fetch 전략이 Lazy이기 때문에 즉시 로딩으로 조정
    @OneToMany(mappedBy = "provider", fetch = FetchType.EAGER)
    @ToString.Exclude
    private List<Product> productList = new ArrayList<>();
}

 

• 일대다 연관관계의 경우 여러 상품 엔티티가 포함될 수 있어 컬렉션(collection, List, Map) 형식으로 필드를 생성
• @OneToMany가 붙은 쪽에서 @JoinColum 어노테이션을 사용하면 상대 엔티티에 외래키가 설정
• 롬복의 ToString에 의해 순환참조가 발생할 수 있어 ToString에서 제외 처리를 하는 것이 좋음

 

• 공급업체 엔티티로 연관된 엔티티의 값을 가져올 수 있는지 테스트 코드 작성해 테스트

@SpringBootTest
public class ProviderRepositoryTest {
    @Autowired
    ProviderRepository providerRepository;

    @Autowired
    ProductRepository productRepository;

    @Test
    void relationshipTest(){
        // 테스트 데이터 생성
        Provider provider = new Provider();
        provider.setName("Corner");

        providerRepository.save(provider);

        Product product1 = new Product();
        product1.setName("펜");
        product1.setPrice(1000);
        product1.setStock(1000);
        product1.setProvider(provider);

        Product product2 = new Product();
        product2.setName("가방");
        product2.setPrice(5000);
        product2.setStock(300);
        product2.setProvider(provider);

        Product product3 = new Product();
        product3.setName("모자");
        product3.setPrice(500);
        product3.setStock(50);
        product3.setProvider(provider);

        productRepository.save(product1);
        productRepository.save(product2);
        productRepository.save(product3);

        List<Product> productList = providerRepository.findById(provider.getId()).get().getProductList();
    
        for(Product product: productList){
            System.out.println(product);
        }
    }
}

 

일대다 단방향 매핑

• 상품 분류 테이블 생성
• 상품 분류의 도메인 이름은 Category로 설정

 
상품 분류 엔티티와 레포지토리 생성

// data/entity/Category.java
@Entity
@Getter
@Setter
@NoArgsConstructor
@ToString
@EqualsAndHashCode
@Table(name="category")
public class Category {

    @Id
    @GeneratedValue(strategy = GenerationType.IDENTITY)
    private Long id;

    @Column(unique = true)
    private String code;

    private String name;

    @OneToMany(fetch = FetchType.EAGER)
    @JoinColumn(name = "category_id")
    private List<Product> products = new ArrayList<>();
}

 

• 코드를 실행하면 상품 분류 테이블이 생성되고 상품 테이블 외래키가 추가되는 것을 확인
• @OneToMany와 @JoinColum을 사용하면 상품 엔티티에서 별도의 설정 없이 일대다 단방향 연관관계가 매핑
• @JoinColum 어노테이션은 필수 사항은 아님
  이 어노테이션을 사용하지 않으면 중간 테이블로 Join 테이블이 생성되는 전략이 채택

 

• 지금 같은 일대다 단방향 관계의 단점은 매핑의 주체가 아닌 반대 테이블에 외래키가 추가된다는 점
• 이 방식은 다대일 구조와 다르게 외래키를 설정하기 위해 다른 테이블에 대한 update 쿼리를 발생
• 이를 확인하기 위해 저장할 레포지토리와 테스트 코드 작성

// data/repository/CategoryRepository.java
public interface CategoryRepository extends JpaRepository<Category, Long> {
}

 
 

// test/com.springboot.relationship/data/repository/CategoryRepositoryTest.java

@SpringBootTest
public class CategoryRepositoryTest {
    
    @Autowired
    ProductRepository productRepository;
    
    @Autowired
    CategoryRepository categoryRepository;
    
    
    @Test
    void relationshipTest(){
        // 테스트 데이터 생성
        Product product = new Product();
        product.setName("펜");
        product.setPrice(2000);
        product.setStock(100);
        productRepository.save(product);

        Category category = new Category();
        category.setCode("S1");
        category.setName("도서");
        category.getProducts().add(product);
        
        categoryRepository.save(category);

        // 테스트 코드
        List<Product> productList = categoryRepository.findById(1L).get().getProducts();

        for(Product foundProduct:productList){
            System.out.println(product);
        }
    }
    
}

 

• 테스트 코드를 실행시키면 일대다 연관관계에서는 연관관계 설정을 위한 update 쿼리가 발생
• 같은 문제를 해결하기 위해는 다대일 연관관계를 사용하는 것이 좋음
• 일대다 연관관계에서는 category와 product의 조인이 발생해서 상품 데이터를 정상적으로 가져옴

 

다대다 매핑

• 다대다(M:N) 연관관계는 실무에서 거의 사용되지 않는 구성
• 다대다 연관관계를 상품과 생산업체의 예로 들자면 한 종류의 상품이 여러 생산업체를 통해 생산될 수 있고, 생산업체 한 곳이 여러 상품을 생산할 수도 있음
• 다대다 연관관계에서는 각 엔티티에서 서로를 리스트로 가지는 구조
• 이런 경우에는 교차 엔티티라고 부르는 중간 테이블을 생성해서 다대다 관계를 일대다 또는 다대일 관계로 해소

 

@Entity
@Getter
@Setter
@NoArgsConstructor
@ToString(callSuper = true)
@EqualsAndHashCode(callSuper = true)
@Table(name="producer")
public class Producer extends BaseEntity  {
    
    @Id
    @GeneratedValue(strategy = GenerationType.IDENTITY)
    private Long id;
    
    private String code;
    
    private String name;
    
 
    @ManyToMany
    @ToString.Exclude
    private List<Product> productList = new ArrayList<>();
    
    public void addProduct(Product product){
        productList.add(product);
    }
}

 

• 다대다 연관관계는 @ManyToMany 어노테이션으로 설정
• 리스트로 필드를 가지는 객체에서는 외래키를 가지지 않기 때문에 별도의 @Joincolum은 설정하지 않아도 됨
• 엔티티를 생성하고 애플리케이션을 실행하면 생산업체 테이블이 생성되고 별도의 외래키가 추가되지 않음
• 중간 테이블을 별도의 이름으로 설정하고 싶다면 @ManyToMany 어노테이션 아래 @JoinTable(name = "이름")으로 어노테이션을 정의하면 됨

 

• 리포지토리를 통해 생산업체에 대한 기본적인 데이터베이스 조작이 가능함

public interface ProducerRepository extends JpaRepository<Producer, Long> {
}

public class ProducerRepositoryTest {
    
    @Autowired
    ProducerRepository producerRepository;
    
    @Autowired
    ProductRepository productRepository;
    
    @Test
    @Transactional
    void relationshipTest(){
        Product product1 = saveProduct("동글펜", 400, 1000);
        Product product2 = saveProduct("네모 공책", 200, 200);
        Product product3 = saveProduct("지우개", 300, 1400);
        
        Producer producer1 = saveProducer("flature");
        Producer producer2 = saveProducer("wikibooks");
        
        producer1.addProduct(product1);
        producer1.addProduct(product2);

        producer2.addProduct(product2);
        producer2.addProduct(product3);
    
        producerRepository.saveAll(Lists.newArrayList(producer1,producer2));

        System.out.println(producerRepository.findById(1L).get().getProductList());
    }
    
    private Product saveProduct(String name, Integer price, Integer stock){
        Product product = new Product();
        product.setName(name);
        product.setPrice(price);
        product.setStock(stock);

        return  productRepository.save(product);
    }

    private Producer saveProducer(String name){
        Producer producer = new Producer();
        producer.setName(name);

        return  productRepository.save(producer);
    }
}

 

• 가독성을 위해 리포지토리를 통해 테스트 데이터를 생성하는 부분을 별도 메서드로 구현
• 리포지토리를 사용하게 되면 매번 트랜잭션이 끊어져 생산업체 엔티티에서 상품 리스트를 가져오는 작업이 불가능
• 이 문제를 해소하기 위해 테스트 메서드에 @Transactional 어노테이션을 지정해 트랜잭션이 유지되도록 구성해서 테스트를 진행

 

• 연관관계를 설정했기 때문에 정상적으로 생산업체 엔티티에서 상품 리스트를 가져옴
• 앞의 테스트를 통해 테스트 데이터를 생성하면 product 테이블과 producer 테이블에 레코드가 추가되지만 보여지는 내용만으로는 연관관계 설정 여부를 확인하기 어려움
  • 그 이유는 다대다 연관관계 설정 을 통해 생성된 중간 테이블에 연관관계 매핑이 돼 있기 때문
  • 중간 테이블을 확인하면 앞서 설정한 연관관계에 맞춰 양 테이블의 기본키를 매핑한 레코드가 생성된 것을 볼 수 있음

  

다대다 양방향 매핑

@Entity
@Getter
@Setter
@NoArgsConstructor
@ToString(callSuper = true)
@EqualsAndHashCode(callSuper = true)
@Table(name="product")
public class Product extends BaseEntity  {

    @Id
    @GeneratedValue(strategy = GenerationType.IDENTITY)
    private Long number;

    @Column(nullable = false)
    private String name;

    @Column(nullable = false)
    private Integer price;

    @Column(nullable = false)
    private Integer stock;

    @OneToOne(mappedBy = "product")
    @ToString.Exclude
    private ProductDetail productDetail;

    @ManyToOne
    @JoinColumn(name = "provider_id")
    @ToString.Exclude
    private Provider provider;
    
    // 생산업체에 대한 다대다 연관관계 설정
    @ManyToMany
    @ToString.Exclude
    private List<Producer> producers = new ArrayList<>();
    
    public void addProducer(Producer producer){
        this.producers.add(producer);
    }
}

• 필요에 따라 mappedBy 속성을 사용해 두 엔티티 간 연관관계의 주인을 설정
• 중간 테이블이 연관관계를 설정하고 있기 때문에 데이터베이스의 테이블 구조는 변경되지 않음

 

• 테스트 코드 작성

Public class ProducerRepositoryTest {

    // 생략..
    @Test
    @Transactional
    void relationshipTest2(){
        Product product1 = saveProduct("동글펜", 400, 1000);
        Product product2 = saveProduct("네모 공책", 200, 200);
        Product product3 = saveProduct("지우개", 300, 1400);
        // 생략..

        // 양방향 연관관계 설정
        product1.addProducer(producer1);
        product2.addProducer(producer2);
        product2.addProducer(producer1);
        product3.addProducer(producer2);

        producerRepository.saveAll(Lists.newArrayList(producer1,producer2));
        productRepository.saveAll(Lists.newArrayList(product1, product2, product3));

        System.out.println(producerRepository.findById(1L).get().getProductList());
        System.out.println(productRepository.findById(2L).get().getProducers());

    }
    // 생략..
}

 

• 양방향 연관관계 설정을 위해 연관관계 설정 코드를 추가
• 연관관계를 설정하고 각 엔티티에 연관된 엔티티를 출력하면 정상적으로 출력됨

 

• 이렇게 다대다 연관관계를 설정하면 중간 테이블을 통해 연관된 엔티티의 값을 가져올 수 있음
• 다만 다대다 연관관계에서는 관리하기 힘든 중간 테이블이 생성되기 때문에 예기치 못한 쿼리가 생길 수 있음
• 이러한 다대다 연관관계의 한계를 극복하기 위해서는 중간 테이블을 생성하는 대신 일대다 다대일로 연관관계를 맺을 수 있는 중간 엔티티로 승격시켜 JPA에서 관리할 수 있게 생성하는 것이 좋음

 
 

영속성 전이

• 영속성 전이(cascade)란 특정 엔티티의 영속성 상태를 변경할 때 그 엔티티와 연관된 엔티티의 영속성에도 영향을 미쳐 영속성 상태를 변경하는 것
• 연관관계와 관련된 어노테이션을 보면 위와 같이 cascade()라는 영속성 전이를 설정하는 데 활용되는 요소 확인

 

cascade() 요소와 함께 사용하는 영속성 전이 타입

ALL	모든 영속 상태 변경에 대해 영속성 전이를 적용
PERSIST	엔티티가 영속화할 때 연관된 엔티티도 함께 영속화
MERGE	엔티티를 영속성 컨텍스트에 병합할 때 연관된 엔티티도 병합
REMOVE	엔티티를 제거할 때 연관된 엔티티도 제거
REFRESH	엔티티를 새로고침할 때 연관된 엔티티도 새로고침
DETACH	엔티티를 영속성 컨텍스트에서 제외하면 연관된 엔티티도 제외

 

영속성 전이 적용

• 상품 엔티티와 공급업체 엔티티를 사용해 영속성 전이를 적용
• 엔티티를 데이터베이스에 추가하는 경우로 영속성 전이 타입으로 PERSIST를 지정

@Entity
@Getter
@Setter
@NoArgsConstructor
@ToString(callSuper = true)
@EqualsAndHashCode(callSuper = true)
@Table(name="provider")
public class Provider extends BaseEntity{

    @Id
    @GeneratedValue(strategy = GenerationType.IDENTITY)
    private Long id;

    private String name;

    // 영속성 전이를 위한 @OneToMany 어노테이션
    @OneToMany(mappedBy = "provider", cascade = CascadeType.PERSIST)
    @ToString.Exclude
    private List<Product> productList = new ArrayList<>();
}

 
 

• 테스트 코드 작성

@SpringBootTest
public class ProviderRepositoryTest {
    @Autowired
    ProviderRepository providerRepository;

    @Autowired
    ProducerRepositoryTest productRepository;

    @Test
    void cascadeTest(){
        Provider provider = saveProvider("new provider");

        Product product1 = saveProduct("동글펜", 400, 1000);
        Product product2 = saveProduct("네모 공책", 200, 200);
        Product product3 = saveProduct("지우개", 300, 1400);
        
        // 연관관계 설정
        product1.setProvider(provider);
        product2.setProvider(provider);
        product3.setProvider(provider);
        
        provider.getProductList().addAll(Lists.newArrayList(product1, product2, product3));
        
        // 영속성 전이 수행
        providerRepository.save(provider);
    }

    private Product saveProduct(String name, Integer price, Integer stock){

        Product product = new Product();
        product.setName(name);
        product.setPrice(price);
        product.setStock(stock);

        return  product;
    }

    private Provider saveProvider(String name){
        Provider provider = new Provider();
        provider.setName(name);

        return  provider;
    }
}

 

• 영속성 전이를 테스트하기 위해 객체에는 영속화 작업을 수행하지 않고, 연관 관계만 설정
• 영속성 전이가 수행되는 부분

providerRepository.save(provider);

 

• 영속성 전이를 사용하면 부모 엔티티가 되는 Provider 엔티티만 저장하면 코드에 작성돼 있는 Cascade.PERSIST에 맞춰 상품 엔티티도 함께 저장
• 특정 상황에 맞춰 영속성 전이 타입을 설정하면 영속 상태의 변화에 따라 연관된 엔티티들의 동작도 함께 수행
• 다만 자동 설정으로 동작하는 코드들이 정확히 어떤 영향을 미치는지 파악할 필요가 있음

 

고아 객체

• JPA에서 고아(orphan)란 부모 엔티티와 연관관계가 끊어진 엔티티
• JPA에는 이러한 고아 객체를 자동으로 제거하는 기능이 있다
• 자식 엔티티가 다른 엔티티와 연관관계를 가지고 있다면 이 기능은 사용하지 않는 것이 좋음

 

• 고아 객체를 제거하는 기능을 사용하기 위해서는 공급업체 엔티티를 다음과 같이 작성

@Entity
@Getter
@Setter
@NoArgsConstructor
@ToString(callSuper = true)
@EqualsAndHashCode(callSuper = true)
@Table(name="provider")
public class Provider extends BaseEntity{

    @Id
    @GeneratedValue(strategy = GenerationType.IDENTITY)
    private Long id;

    private String name;

    // 'orphanRemoval = true'은 고아 객체를 제거하는 기능
    @OneToMany(mappedBy = "provider", cascade = CascadeType.PERSIST, orphanRemoval = true)
    @ToString.Exclude
    private List<Product> productList = new ArrayList<>();
}

 
 

• 테스트 코드를 작성

@SpringBootTest
public class ProviderRepositoryTest {

    // 생략...
    
        product1.setProvider(provider);
        product2.setProvider(provider);
        product3.setProvider(provider);

        provider.getProductList().addAll(Lists.newArrayList(product1, product2, product3));

        providerRepository.saveAndFlush(provider);
        
        // 엔티티 출력
        providerRepository.findAll().forEach(System.out::println);
        productRepository.findAll().forEach(System.out::println);
        
    // 생략...
}

 

• 먼저 테스트 데이터를 저장한 후, 연관관계 매핑을 수행
• 연관관계가 매핑된 각 엔티티들을 저장한 후 각 엔티티를 출력하면 공급업체 엔티티 1개, 상품 엔티티 3개가 출력
• 고아 객체를 생성하기 위해 공급업체 엔티티를 가져온 후 첫 번째로 매핑돼 있는 상품 엔티티의 연관관계를 제거
• 전체 조회 코드를 수행하면 연관관계가 끊긴 상품의 엔티티가 제거된 것을 확인

 

---

Q1. 문제 (드래그하여 답 확인해주세요.)

 

1. 데이터베이스에서는 두 테이블의 연관관계를 설정하면  (  외래키  )를 통해 서로 조인해서 참조하는 구조로 생성된다.

 

※ @JoinColum 어노테이션에서 사용할 수 있는 속성들을 작성하시오.(2~4번)

2. 매핑할 외래키의 이름을 설정 => (  name  )

 

3. 외래키가 참조할 상대 테이블의 칼럼명을 지정 => (  referencedColumnName   )

 

4. 외래키를 생성하면서 지정할 제약조건을 설정( unique. nullable, insertable. updatable 등).  => (  foreignkey  )

 

5. 엔티티를 조회할 때 연관된 엔티티도 함께 조회하는 것을 (  즉시 로딩  )이라 한다.

 

6. ( 영속성 전이 )란 특정 엔티티의 영속성 상태를 변경할 때 그 엔티티와 연관된 엔티티의 영속성에도 영향을 미쳐 영속성 상태를 변경하는 것이다.

 

7. JPA에서  ( 고아객체 )  란 부모 엔티티와 연관관계가 끊어진 엔티티고, 이러한 객체를 자동으로 제거하는 기능이 있다.

 

---

Q2. 코드 문제

 

다대일 양방향 매핑 코드의 빈 부분의 코드를 작성.

@Entity
@Getter
@Setter
@NoArgsConstructor
@ToString(callSuper = true)
@EqualsAndHashCode(callSuper = true)
@Table(name="provider")
public class Provider extends BaseEntity  {

    @Id
    @GeneratedValue(strategy = GenerationType.IDENTITY)
    private Long id;

    private String name;

    @OneToMany(mappedBy = "provider", fetch = ***1번***)
    @ToString.***2번***
    private List<Product> productList = new ArrayList<>();
}

 

1번:

FetchType.EAGER

 

2번:

Exclude

 

---

 

출처: 스프링부트 핵심 가이드

SPRING #2

Editor : dalpaeng4