RDBMS를 사용시 하나의 테이블을 사용해서 애플리케이션의 모든 기능을 구현이 불가능합니다. 설계가 복잡해지면 각 도메인에 맞는 테이블을 설계하고 연관관계를 설정해서 조인(Join) 등의 기능을 활용합니다. JPA를 사용하는 애플리케이션에서도 테이블의 연관관계를 표현할 수는 업습니다. 이러한 제약을 보완하면서 연관관께를 매핑하고 사용하는 방법을 알아봅니다.
연관관계 매핑 종류와 방향
- One To One: 일대일(1:1)
- One To Many: 일대다(1:N)
- Many To One: 다대일(N:1)
- Many To Many: 다대다(N:N)
데이터베이스는 두 테이블의 연관관계를 설정하면 외래키를 통해 서로 조인을 하는데 JPA를 사용하는 객체지향 모델링은 엔티티 간 참조 방향을 설정할 수 있습니다. 데이터베이스와 관계를 일치시키기 위해 양방향으로 설정해도 무관하지만 비즈니스 로직에서 단방향 관계만 설정해도 해결되는 경우가 많습니다.
- 단방향: 두 엔티티의 관계에서 한쪽의 엔티티만 참조하는 형식입니다.
- 양방향: 두 엔티티의 관계에서 각 엔티티가 서로의 엔티티를 참조하는 형식입니다.
연관관계가 설정되면 한 테이블에서 다른 테이블의 기본값을 외래키로 갖게 됩니다. 주인(Owner) 개념을 사용합니다. 일반적으로 외래키를 가진 테이블이 그 관계의 주인이 되며, 주인은 외래키를 사용할 수 있으나 상대 엔티티는 읽는 작업만 수행할 수 있습니다.
프로젝트 생성
일대일 매핑
일대일 매핑을 만들어보면 (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;
}상품정보 엔티티를 작성하고 상품 번호에 매핑 하기위해 일대일 어노테이션으로 다른 엔티티 객체를 필드로 정의했을 때 일대일 연관관계 매핑하기 위해 사용됩니다. @JoinColumn 어노테이션을 사용해 매핑할 외래키를 설정합니다. 자동으로 기본값이 설정돼 있지만 의도한 이름이 들어가지 않아서 설정해 주는게 좋습니다.
@JoinColumn 어노테이션에서 사용할 수 있는 속성
- name: 매핑할 외래키의 이름을 설정합니다.
- referencedColumnName: 외래키가 참조할 상대 테이블의 칼럼명을 지정합니다.
- foreignKey: 외래키를 생성하면서 지정할 제약조건을 설정합니다(unique, nullable, insertable, updatable 등).
이렇게 엔티티 클래스를 생성하면 단방향 관계의 일대일 관계 매핑이 완성됩니다.
hibernate.ddl-auto의 값을 create로 설정한 후 애플리케이션을 실행하면
테이블이 자동으로 생성됩니다.
이제 생성된 상품정보 엔티티 객체들을 사용하기 위해 리포지토리 인터페이스를 생성합니다.
data/repository/ProductDetailRepository.java
public interface ProductDetailRepository extends JpaRepository<ProductDetail, Long> {
}이제 연관관계를 활용한 데이터 생성 및 조회 기능을 테스트코드로 작성합니다.
test/com.springboot.relationship/data/repository/ProductDetailRepositoryTest.java
@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());
}
}일단 테스트 코드 실행하기 위해 상품과 상품정보에 매핑된 리포지토리에 대해 의존성 주입을 받아야 합니다. 조회할 엔티티를 저장합니다. 그럼 여기서 ProductDetail 객체에서 Product 객체를 일대일 단방향 연관관계를 설정했기 때문에 ProductDetailRepository에서 ProductDetail 객체를 조회한 후 연관 매핑된 Product 객체를 조회할 수 있습니다.
하이버네이트로 실행하면
Hibernate:
insert
into
product
(created_at, updated_at, name, price, stock)
values
(?, ?, ?, ?, ?)
Hibernate:
insert
into
product_detail
(created_at, updated_at, description, product_number)
values
(?, ?, ?, ?)
Hibernate:
select
productdet0_.id as id1_1_0_,
productdet0_.created_at as created_2_1_0_,
productdet0_.updated_at as updated_3_1_0_,
productdet0_.description as descript4_1_0_,
productdet0_.product_number as product_5_1_0_,
product1_.number as number1_0_1_,
product1_.created_at as created_2_0_1_,
product1_.updated_at as updated_3_0_1_,
product1_.name as name4_0_1_,
product1_.price as price5_0_1_,
product1_.stock as stock6_0_1_
from
product_detail productdet0_
left outer join
product product1_
on productdet0_.product_number=product1_.number
where
productdet0_.id=?
savedProduct : Product(super=BaseEntity(createdAt=2023-08-09T14:31:26.686182, updatedAt=2023-08-09T14:31:26.686182), number=1, name=스프링 부트 JPA, price=5000, stock=500)
Hibernate:
select
productdet0_.id as id1_1_0_,
productdet0_.created_at as created_2_1_0_,
productdet0_.updated_at as updated_3_1_0_,
productdet0_.description as descript4_1_0_,
productdet0_.product_number as product_5_1_0_,
product1_.number as number1_0_1_,
product1_.created_at as created_2_0_1_,
product1_.updated_at as updated_3_0_1_,
product1_.name as name4_0_1_,
product1_.price as price5_0_1_,
product1_.stock as stock6_0_1_
from
product_detail productdet0_
left outer join
product product1_
on productdet0_.product_number=product1_.number
where
productdet0_.id=?
savedProductDetail : ProductDetail(super=BaseEntity(createdAt=2023-08-09T14:31:26.733157, updatedAt=2023-08-09T14:31:26.733157), id=1, description=스프링 부트와 JPA를 함께 볼 수 있는 책, product=Product(super=BaseEntity(createdAt=2023-08-09T14:31:26.686182, updatedAt=2023-08-09T14:31:26.686182), number=1, name=스프링 부트 JPA, price=5000, stock=500))
select 구문을 보면 ProductDetail 객체와 Product 객체가 함께 조회되는 것을 볼 수 있습니다. 이처럼 엔티티를 조회할 때 연관된 엔티티도 함께 조회하는 것을 '즉시 로딩' 이라고 합니다. left outer join 이 수행되는것이 보이는데 이것은 @OneToOne 어노테이션 때문입니다.
@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이라는 의미를 합니다.
반드시 값이 있어야 한다면
@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(optional = false)
@JoinColumn(name = "product_number")
private Product product;
}optional=false 속성을 설정하면 product가 null 인 값을 허용하지 않습니다.
create table product_detail (
id bigint not null auto_increment,
created_at datetime(6),
updated_at datetime(6),
description varchar(255),
product_number bigint not null,
primary key (id)
) engine=InnoDB이렇게 테이블 생성하는 쿼리에서 not null 이 설정되는것을 확인할 수 있습니다.
테스트 코드를 다시 실행하면 쿼리문이 바뀌는것을 확인할 수 있습니다.
select
productdet0_.id as id1_1_0_,
productdet0_.created_at as created_2_1_0_,
productdet0_.updated_at as updated_3_1_0_,
productdet0_.description as descript4_1_0_,
productdet0_.product_number as product_5_1_0_,
product1_.number as number1_0_1_,
product1_.created_at as created_2_0_1_,
product1_.updated_at as updated_3_0_1_,
product1_.name as name4_0_1_,
product1_.price as price5_0_1_,
product1_.stock as stock6_0_1_
from
product_detail productdet0_
inner join
product product1_
on productdet0_.product_number=product1_.number
where
productdet0_.id=?즉 @OneToOne 어노테이션에 optional = false를 설정하면 left outer join이 inner join으로 바뀌어 실행됩니다.
일단 다음 진행을 위해 optional false를 제거합니다.
일대일 양방향 매핑
양방향 개념은 양쪽에서 단방향으로 서로를 매핑하는 것을 의미합니다. 일대일 양방향 매핑을 위해서 product 엔티티에 OneToOne과 ProductDetail과 일대일 매핑 어노테이션을 추가합니다.
그럼 실행하면
product 테이블에도 칼럼이 생성되는것을 확인가능합니다.
테스트 코드를 다시 실행하면
select
productdet0_.id as id1_1_0_,
productdet0_.created_at as created_2_1_0_,
productdet0_.updated_at as updated_3_1_0_,
productdet0_.description as descript4_1_0_,
productdet0_.product_number as product_5_1_0_,
product1_.number as number1_0_1_,
product1_.created_at as created_2_0_1_,
product1_.updated_at as updated_3_0_1_,
product1_.name as name4_0_1_,
product1_.price as price5_0_1_,
product1_.product_detail_id as product_7_0_1_,
product1_.stock as stock6_0_1_,
productdet2_.id as id1_1_2_,
productdet2_.created_at as created_2_1_2_,
productdet2_.updated_at as updated_3_1_2_,
productdet2_.description as descript4_1_2_,
productdet2_.product_number as product_5_1_2_
from
product_detail productdet0_
left outer join
product product1_
on productdet0_.product_number=product1_.number
left outer join
product_detail productdet2_
on product1_.product_detail_id=productdet2_.id
where
productdet0_.id=?여러 테이블끼리 연관관계가 설정돼 있어 여러 left outer join이 설정되는 것은 괜찮으나 위와 같이 양쪽에서 외래키를 가지고 left outer join이 두번이나 수행되는 경우는 효율성이 떨어집니다. 실제 데이터베이스에서도 테이블 간 연관관계를 맺으면 한쪽 테이블이 외래키를 가지는 구조로 이뤄집니다. 바로 앞에서 언급한 주인 개념입니다.
JPA에서도 실제 데이터베이스의 연관관계를 반영해서 한쪽의 테이블에서만 외래키를 바꿀 수 있도록 정하는 것이 좋습니다. 이 경우 엔티티는 양방향으로 매핑하되 한쪽에게만 외래키를 줘야 하는데, 이때 사용되는 속성 값이 mappedBy입니다. mappedBy는 어떤 객체가 주인인지 표시하는 속성이라고 볼 수 있습니다.
Product 객체에 mappedBy 속성을 추가해 보겠습니다.
@Entity
@Getter
@Setter
@NoArgsConstructor
@EqualsAndHashCode(callSuper = true)
@ToString(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 엔티티의 주인이 되는 것입니다. 실행시키면
외래키가 사라진 것을 볼 수 있습니다.
다시 테스트 코드를 실행하면 stackoverflow 에러가 발생 합니다. 양방향으로 연관관계가 설저오디면 ToString을 사용할 때 순환참조가 발생하기 때문입니다. 그렇기 때문에 필요한 경우가 아니라면 대체로 단방향으로 연관관계를 설정하거나 양방향 설정이 필요한 경우에는 순환참조 제거를 위해 exclude를 사용해 ToString에서 제외 설정을 하는것이 좋습니다.
@OneToOne(mappedBy = "product")
@ToString.Exclude
private ProductDetail productDetail;정상적으로 실행이 됩니다.
다대일, 일대다 매핑
상품테이블과 공급업체 테이블은 상품 테이블의 입장에서 볼 경우에는 다대일, 공급업체 테이블의 입장에서 볼 경우에는 일대다 관계로 볼 수 있습니다. 이런 관계는 어떻게 구현해야 할지 직접 매핑하면서 알아봅니다.
공급업체 테이블에 매핑되는 엔티티 클래스를 만들겠습니다.
data/entity/Provider.java
@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;
}공급업체는 Provider라는 도메인을 사용해서 정의했습니다. 공급업체의 정보를 담는다면 더많은 칼럼이 필요하겠지만 간단한 실습을 위해 필드로는 id 와 name만 작성합니다. 여기에 BaseEntity를 통해 생성일자와 변경일자를 상속받습니다.
상품 엔티티에서는 공급업체의 번호를 받기 위해 엔티티 필드의 구성을 추가해야 합니다.
@Entity
@Getter
@Setter
@NoArgsConstructor
@EqualsAndHashCode(callSuper = true)
@ToString(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;
}공급업체 엔티티에 대한 다대일 연관관계를 설정합니다. 일반적으로 외래키를 갖는 쪽이 주인의 역할을 수행하기 때문에 이 경우 상품 엔티티가 공급업체 엔티티의 주인입니다.
애플리케이션을 가동하면
당장은 사용하지 않지만 이후 공급업체 엔티티를 활용할 수 있게 리포지토리를 생성합니다.
data/repository/ProviderRepoistory.java
public interface ProviderRepository extends JpaRepository<Provider, Long> {
}두 엔티티에서 주인은 Product 엔티티이기 때문에 ProductRepository를 활용해 테스트합니다.
test/com.springboot.relationship/data/repository/ProviderRepositoryTest.java
@SpringBootTest
public class ProviderRepositoryTest {
@Autowired
ProductRepository productRepository;
@Autowired
ProviderRepository providerRepository;
@Test
void relationshipTest1(){
//테스트 데이터 생성
Provider provider = new Provider();
provider.setName("삼성물산");
providerRepository.save(provider);
Product product = new Product();
product.setName("갤럭시");
product.setPrice(1300000);
product.setStock(112);
product.setProvider(provider);
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 객체를 product에 추가해서 product.setProvider(provider) 데이터베이스에 저장하는 코드입니다.
하이버네이트에 실행하면
Hibernate:
insert
into
product
(created_at, updated_at, name, price, provider_id, stock)
values
(?, ?, ?, ?, ?, ?)쿼리로 데이터를 저장할 때는 provider_id값만 들어가는 것을 볼 수 있습니다. 이렇게 product 테이블에는 @JoinColumn에 설정한 이름을 기반으로 자동으로 값을 선저앻서 추가하게 됩니다.
Product 엔티티에서 단방향으로 Provider 엔티티 연관관계를 맺고 있기 때문에 ProductRepository만으로도 Provider 객체도 조회가 가능합니다.
실행하면
select
product0_.number as number1_0_0_,
product0_.created_at as created_2_0_0_,
product0_.updated_at as updated_3_0_0_,
product0_.name as name4_0_0_,
product0_.price as price5_0_0_,
product0_.provider_id as provider7_0_0_,
product0_.stock as stock6_0_0_,
provider1_.id as id1_2_1_,
provider1_.created_at as created_2_2_1_,
provider1_.updated_at as updated_3_2_1_,
provider1_.name as name4_2_1_,
productdet2_.id as id1_1_2_,
productdet2_.created_at as created_2_1_2_,
productdet2_.updated_at as updated_3_1_2_,
productdet2_.description as descript4_1_2_,
productdet2_.product_number as product_5_1_2_
from
product product0_
left outer join
provider provider1_
on product0_.provider_id=provider1_.id
left outer join
product_detail productdet2_
on product0_.number=productdet2_.product_number
where
product0_.number=?출력된결과
product : Product(super=BaseEntity(createdAt=2023-08-09T17:14:59.018083,
updatedAt=2023-08-09T17:14:59.018083), number=1, name=갤럭시, price=1300000,
stock=112)
provider : Provider(super=BaseEntity(createdAt=2023-08-09T17:14:58.986118,
updatedAt=2023-08-09T17:14:58.986118), id=1, name=삼성물산)다대일 양방향 매핑
상품 엔티티와 공급업체 엔티티 사이에 다대일 단방향 연관관계를 설정했습니다. 이제 반대로 공급업체를 통해 등록된 상품을 조회하기 위한 일대다 연관관계를 설정해보겠습니다. 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(mappedBy = "provider", fetch = FetchType.EAGER)
@ToString.Exclude
private List<Product> productList = new ArrayList<>();
}일대다 연관관계의 경우 여러 상품 엔티티가 포함될 수 있어 컬렉션(Collection, List, Map) 형식으로 필드를 생성합니다. 이렇게 @OneToMany가 붙은 쪽에서 @JoinColumn 어노테이션을 사용하면 상대 엔티티에 외래키가 설정됩니다. 또한 롬복의 ToString에 의해 순환참조가 발생할 수 있어 따라서 ToString.Exclude로 순환참조 제외 처리 하는것이 좋습니다. fetch = FetchType.EAGER @OneToMany의 기본 fetch 전략이 Lazy이기 때문에 즉시 로딩으로 조정한 것입니다. 앞으로 진행할 테스트에서 지연 로딩 방식을 사용하면 no Session으로 에러가 발생하기 때문에 조정했습니다.
Provider 엔티티 클래스를 수정해도 애플리케이션을 가동해보면 칼럼은 변경되지 않습니다. mappedBy로 설정된 필드는 칼럼에 적용되지 않습니다. 즉, 양쪽에서 연관관계를 설정하고 있을때 RDBMS의 형식처럼 사용하기 위해 mappedBy를 통해 한쪽으로 외래키 관리를 위임한 것입니다.
지연로딩과 즉시로딩
JPA에서 지연로딩(lazy loading)은 중요한 개념입니다. 엔티티라는 객체의 개념으로 데이터베이스를 구현했기 때문에 연관관계를 가진 각 엔티티 클래스에는 연관관계가 있는 객체들이 필드에 존재하게됩니다.
연관관계와 상관없이 즉각 해당 엔티티의 값만 조회하고 싶거나 연관관계를 가진 테이블의 값도 조회하고 싶은 경우 등 여러조건들을 만족하기 위해 등장한 개념이 지연로딩과 즉시로딩입니다.
다시 본론으로 돌아와 수정된 공급업체 엔티티를 가지고 연관된 엔티티의 값을 가져올 수 있는지 테스트합니다.
@Test
void relatitonshipTest(){
//테스트 데이터 생성
Provider provider = new Provider();
provider.setName("무한상사");
providerRepository.save(provider);
Product product1 = new Product();
product1.setName("달력");
product1.setPrice(7900);
product1.setStock(100);
product1.setProvider(provider);
Product product2 = new Product();
product2.setName("펜");
product2.setPrice(1900);
product2.setStock(40);
product2.setProvider(provider);
Product product3 = new Product();
product3.setName("파우치");
product3.setPrice(12000);
product3.setStock(45);
product3.setProvider(provider);
productRepository.save(product1);
productRepository.save(product2);
productRepository.save(product3);
List<Product> products = providerRepository.findById(provider.getId()).get()
.getProductList();
for(Product product: products){
System.out.println(product);
}
}Provider 엔티티 클래스는 Product 엔티티와의 연관관계의 주인이 아니기 때문에 외래키를 관리할 수 없습니다. 그렇기 때문에 테스트 데이터를 생성하는 Provider를 등록한 후 각 Product에 객체를 설정하는 작업을 통해 데이터베이스에 저장합니다. 만약 데이터를 생성하는 방식이 아니라 Provider 엔티티에 정의한 productList 필드에 Product 엔티티를 추가하는 방식으로 데이터베으스에 레코드를 저장하게 되면 Provider 엔티티 클래스는 연관관계의 주인이 아니여서 해당 데이터는 데이터베이스에 반영되지 않습니다.
provider.getProductList.add(product1); // 무시
provider.getProductList.add(product2); // 무시
provider.getProductList.add(product3); // 무시위를 출력하면
select
provider0_.id as id1_2_0_,
provider0_.created_at as created_2_2_0_,
provider0_.updated_at as updated_3_2_0_,
provider0_.name as name4_2_0_,
productlis1_.provider_id as provider7_0_1_,
productlis1_.number as number1_0_1_,
productlis1_.number as number1_0_2_,
productlis1_.created_at as created_2_0_2_,
productlis1_.updated_at as updated_3_0_2_,
productlis1_.name as name4_0_2_,
productlis1_.price as price5_0_2_,
productlis1_.provider_id as provider7_0_2_,
productlis1_.stock as stock6_0_2_,
productdet2_.id as id1_1_3_,
productdet2_.created_at as created_2_1_3_,
productdet2_.updated_at as updated_3_1_3_,
productdet2_.description as descript4_1_3_,
productdet2_.product_number as product_5_1_3_
from
provider provider0_
left outer join
product productlis1_
on provider0_.id=productlis1_.provider_id
left outer join
product_detail productdet2_
on productlis1_.number=productdet2_.product_number
where
provider0_.id=?이렇게 출려됩니다.
일대다 단방향 매핑
앞에서는 다대일 연관관계에서의 단방향과 양방향 매핑을 살펴봤습니다. 이번에는 반대로 일대다 단방향 매핑 방법입니다. 여기서는 일대다 양방향을 다루지 않습니다.
그 이유는 @OneToMany를 사용하는 입장에서는 어느 엔티티 클래스도 연관관계의 주인이 될 수 없기 때문입니다.
주인이 될 수 없는 이유를 살펴보겠습니다.
새로운 엔티티인 상품분류 엔티티를 만듭니다.
@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<>();
}실행하면 상품 분류(category) 테이블이 생성되고 외래키가 추가되는 것을 확인할 수 있습니다.
상품 분류 엔티티에서 @OneToMany와 @JoinColumn을 사용하면 상품 엔티티에서 별도의 설정을 하지 않아도 일대다 단방향 연관관계가 매핑됩니다. 앞에서 언급한 것처럼 @JoinColumn 어노테이션은 필수 사항은 아닙니다. 이 어노테이션을 사용하지 않으면 중간 테이블로 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> products = categoryRepository.findById(1L).get().getProducts();
for(Product foundProduct: products){
System.out.println(foundProduct);
}
}
}
테스트 데이터 생성을 위해 ProductRepository의 의존성도 함께 주입받
겠습니다. Product 객체를 Category에서 생성한 리스트 객체에 추가해서 연관관계 설정합니다. 실행하면 쿼리문은
Hibernate:
insert
into
product
(created_at, updated_at, name, price, provider_id, stock)
values
(?, ?, ?, ?, ?, ?)
Hibernate:
insert
into
category
(code, name)
values
(?, ?)
Hibernate:
update작성됩니다.
일대다 연관관계에서는 위와 같이 연관관계를 설정을 위한 update 쿼리가 발생합니다. 이 같은 문제를 해결하기 위해서는 일대다 양방향 연관관계를 사용하기보다는 다대일 연관관계를 사용하는 것이 좋습니다. 테스트 데이터를 생성한 뒤에 CategoryRepository를 활용해 상품정보를 가져오는 테스트 코드를 생성하면
select
category0_.id as id1_0_0_,
category0_.code as code2_0_0_,
category0_.name as name3_0_0_,
products1_.category_id as category8_1_1_,
products1_.number as number1_1_1_,
products1_.number as number1_1_2_,
products1_.created_at as created_2_1_2_,
products1_.updated_at as updated_3_1_2_,
products1_.name as name4_1_2_,
products1_.price as price5_1_2_,
products1_.provider_id as provider7_1_2_,
products1_.stock as stock6_1_2_,
provider2_.id as id1_3_3_,
provider2_.created_at as created_2_3_3_,
provider2_.updated_at as updated_3_3_3_,
provider2_.name as name4_3_3_,
productdet3_.id as id1_2_4_,
productdet3_.created_at as created_2_2_4_,
productdet3_.updated_at as updated_3_2_4_,
productdet3_.description as descript4_2_4_,
productdet3_.product_number as product_5_2_4_
from
category category0_
left outer join
product products1_
on category0_.id=products1_.category_id
left outer join
provider provider2_
on products1_.provider_id=provider2_.id
left outer join
product_detail productdet3_
on products1_.number=productdet3_.product_number
where
category0_.id=?일대다 연관관게에서는 이처럼 category와 product의 조인이 발생하여 상품 데이터를 정삭적으로 가져옵니다.
다대다 매핑
다대다(M:N) 연관관계는 실무에서 거의 사용되지 않는 구성입니다. 다대다 연관관계를 상품과 생산업체의 예로 들자면 한 종류의 상품이 여러 생산업체를 통해 생산될 수 있고, 생산업체 한 곳이 여러 상품을 생산할 수도 있습니다.
다대다 연관관계에서는 각 엔티티에서 서로를 리스트로 가지는 구조가 만들어집니다. 교차 테이블이라는 중간 테이블을 생성해서 다대다 관계를 일대다 또는 다대일 관계로 해소합니다.
다대다 단방향 매핑
위에 사진과 같은 연관관계를 가진 생산업체 엔티티를 생성해봅니다.
data/entity/Producer.java
@Entity
@Getter
@Setter
@NoArgsConstructor
@EqualsAndHashCode(callSuper = true)
@ToString(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> products = new ArrayList<>();
public void addProduct(Product product){
products.add(product);
}
}
생산업체 테이블에는 별도의 외래키가 추가되지 않은 것을 볼 수 있습니다. 그리고 데이터베이스에 추가로 중간 테이블이 생성돼 있습니다.
별도의 설정을 하지 않았다면 테이블은 producer_products라는 이름으로 설정되며, 만약 테이블의 이름을 관리하고 싶다면 @ManyToMany 어노테이션 아래에 @JoinTable(name="이름")의 형식으로 어노테이션을 정의하면 됩니다.
producer_producs 테이블의 경우 상품 테이블과 생산업체 테이블에서 id값을 가져와 두 개의 외래키가 설정되는 것을 볼 수 있습니다. 이러한 연관관계를 테스트하기 위해 생산업체 엔티티에 대한 리포지토리를 생성합니다.
public interface ProducerRepository extends JpaRepository<Producer, Long> {
}리포지토리 생성하면 기본적인 데이터베이스 조작이 가능합니다. 이제 테스트 코드를 통해 연관관계가 정상적으로 동작하는지 확인 합니다.
@SpringBootTest
public class ProducerRepositoryTest {
@Autowired
ProducerRepository producerRepository;
@Autowired
ProductRepository productRepository;
@Test
void relationshipTest() {
Product product1 = saveProduct("동글펜", 500, 1000);
Product product2 = saveProduct("네모 공책", 100, 2000);
Product product3 = saveProduct("지우개", 152, 1234);
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().getProducts());
}
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 producerRepository.save(producer);
}
}가독성을 위해 리포지토리를 통해 테스트 데이터 생성하는 부분을 별도 메서드로 구현 했습니다. 이 경우 리포지토리를 사용하게 되면 매번 트랜잭션이 끊어져 생산업체 엔티티에서 상품 리스트를 가져오는 작업이 불가능합니다. 이 같은 문제를 해결하려면 테스트 메서드에 @Transactional 어노테이션을 지정해 트랜잭션이 유지되도록 구성해서 테스트를 진행합니다.
[Product(super=BaseEntity(createdAt=2023-08-10T14:08:37.737996, updatedAt=2023-08-10T14:08:37.737996), number=1, name=동글펜, price=500, stock=1000), Product(super=BaseEntity(createdAt=2023-08-10T14:08:37.766420, updatedAt=2023-08-10T14:08:37.766420), number=2, name=네모 공책, price=100, stock=2000)]이런식으로 상품 데이터 리스트들이 출력됩니다.
테스트를 통해 테스트 데이터를 생성하면 product 테이블과 producer 테이블에 레코드가 추가되지만 보여지는 내용만으로는 연관관계 설정 여부를 확인하기 어렵습니다. 그 이유는 다대다 연관관계 설정을 통해 생성된 중간 테이블에 연관관계 매핑이 돼 있기 때문입니다. 중간 테이블에 생성된 레코드를 확인하면
같습니다.
prdoucer_products라는 이름의 주강 테이블에는 producer1, producer2로 연관관계에 맞춰 양 테이블의 기본키를 매핑한 레코드가 생성됩니다.
다대다 양방향 매핑
상품 엔티티에 코드를 작성합니다.
@Entity
@Getter
@Setter
@NoArgsConstructor
@EqualsAndHashCode(callSuper = true)
@ToString(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 속성을 사용해 두 엔티티 간 연관관계의 주인을 설정할 수도 있습니다. 이렇게 설정하고 실행해도 테이블 구조는 변경되지 않는 이유는 중간 테이블이 연관관계를 설정하고 있기 때문입니다. 이제 테스트코드를 작성합니다.
@Test
@Transactional
void relationshipTest2() {
Product product1 = saveProduct("동글펜", 500, 1000);
Product product2 = saveProduct("네모 공책", 100, 2000);
Product product3 = saveProduct("지우개", 152, 1234);
Producer producer1 = saveProducer("flature");
Producer producer2 = saveProducer("wikibooks");
producer1.addProduct(product1);
producer1.addProduct(product2);
producer2.addProduct(product2);
producer2.addProduct(product3);
product1.addProducer(producer1);
product2.addProducer(producer1);
product2.addProducer(producer2);
product3.addProducer(producer2);
producerRepository.saveAll(Lists.newArrayList(producer1, producer2));
productRepository.saveAll(Lists.newArrayList(product1, product2, product3));
System.out.println("products : " + producerRepository.findById(1L).get().getProducts());
System.out.println("producers : " + productRepository.findById(2L).get().getProducers());
}products : [Product(super=BaseEntity(createdAt=2023-08-10T14:55:29.448228,
updatedAt=2023-08-10T14:55:29.448228), number=1, name=동글펜, price=500,
stock=1000), Product(super=BaseEntity(createdAt=2023-08-10T14:55:29.476869,
updatedAt=2023-08-10T14:55:29.476869), number=2, name=네모 공책, price=100,
stock=2000)]
producers : [Producer(super=BaseEntity(createdAt=2023-08-10T14:55:29.479229,
updatedAt=2023-08-10T14:55:29.479229), id=1, code=null, name=flature),
Producer(super=BaseEntity(createdAt=2023-08-10T14:55:29.481612,
updatedAt=2023-08-10T14:55:29.481612), id=2, code=null, name=wikibooks)]이렇게 다대다 연관관계를 설정하면 중간 테이블을 통해 연관된 엔티티의 값을 가져올 수 있습니다. 중간 테이블이 생성돼서 예기치 못한 쿼리가 생길 수 있습니다. 이뜻은 관리하기 힘든 포인트가 발생한다는 점입니다. 이걸 극복하기 위해서는 중간 테이블 대신 일대다 다대일로 연관관계를 맺을 수 있는 중간 엔티티로 승격시켜 JPA에서 관리할 수 있게 생성하는 것이 좋습니다.
영속성 전이
영속성 전이(cascade)란 특정 엔티티의 영속성 상태를 변경할 때 그 엔티티와 연관된 엔티티의 영속성에도 영향을 미쳐 영속성 상태를 변경하는 것을 의미합니다.
예) @OneToMany 어노테이션의 인터페이스를 보면
연관관계와 관련된 어노테이션을 보면 위와 같이 cascade()라는 요소를 볼 수 있습니다. 이 어노테이션은 영속성이 전이를 설정하는 데 활용됩니다. cascade() 요소와 함께 사용하는 영속성 전이 타입은
영속성 전이에 사용되는 타입은 엔티티 생명주기와 연관이 있습니다. cascade 요소의 값으로 주어진 영속 상태의 변경이 일어나면 매핑으로 연관된 엔티티에도 동일한 동작이 일어나도록 전이를 발생시키는 것입니다.
영속성 전이 적용
상품 엔티티와 공급업체 엔티티를 예를 들어, 한 가게가 새로운 공급업체와 계약하며 몇 가지 새 상품을 입고시키는 상황에 어떻게 영속성 전이가 적용되는지 살펴보겠습니다. 엔티티를 데이터베이스에 추가하는 경우로 영속성 전이 타입으로 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(mappedBy = "provider", cascade = CascadeType.PERSIST)
@ToString.Exclude
private List<Product> productList = new ArrayList<>();
}영속성 전이 타입을 설정하려면 @OneToMany 어노테이션의 속성을 활용합니다. 이제 테스트코드를 작성합니다.
@Test
void cascadeTest(){
Provider provider = savedProvider("새로운 공급업체");
Product product1 = savedProduct("상품1", 1000, 1000);
Product product2 = savedProduct("상품2", 500, 1500);
Product product3 = savedProduct("상품3", 750, 500);
//연관관계 설정
product1.setProvider(provider);
product2.setProvider(provider);
product3.setProvider(provider);
provider.getProductList().addAll(Lists.newArrayList(product1, product2, product3));
providerRepository.save(provider);
}
private Provider savedProvider(String name){
Provider provider = new Provider();
provider.setName(name);
return provider;
}
private Product savedProduct(String name, Integer price, Integer stock){
Product product = new Product();
product.setName(name);
product.setPrice(price);
product.setStock(stock);
return product;
}공급업체 하나와 상품 객체를 3개 생성합니다. 영속성 전이를 테스트하기 위해 객체에는 영속화 작업을 수행하지않고 연관관계만 설정합니다.
이제 실행해보면
Hibernate:
insert
into
provider
(created_at, updated_at, name)
values
(?, ?, ?)
Hibernate:
insert
into
product
(created_at, updated_at, name, price, provider_id, stock)
values
(?, ?, ?, ?, ?, ?)
Hibernate:
insert
into
product
(created_at, updated_at, name, price, provider_id, stock)
values
(?, ?, ?, ?, ?, ?)
Hibernate:
insert
into
product
(created_at, updated_at, name, price, provider_id, stock)
values
(?, ?, ?, ?, ?, ?)
데이터베이스에 저장하기 위해 엔티티를 저장하는 코들 짰지만, 영속성 전이를 사용하면 부모 엔티티가 되는 Provider 엔티티만 저장하면 코드에 작성돼 있는 Cascade.Persist에 맞춰 상품 엔티티도 함께 저장합니다.
특정 상황에 맞춰 영속성이 전이 타입을 설정하면 영속 상태의 변화에 따라 연관된 엔티티들의 동작도 함께 수행할 수 있어 개발의 생산성이 높아집니다. 다만 자동 설정으로 동작하는 코드들이 정확히 어떤 영향을 미치는지 파악할 필요가 있습니다. 예를 들어, Remove와 Remove를 포함하는 ALL 같은 타입을 무분별하게 사용하면 연관된 엔티티가 의도치 않게 모두 삭제될 수 있기 때문에 다른 타입보다 더욱 사이드 이펙트를 고려해서 사용해야합니다.
고아 객체
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;
@OneToMany(mappedBy = "provider", cascade = CascadeType.PERSIST, orphanRemoval = true)
@ToString.Exclude
private List<Product> productList = new ArrayList<>();
}고아 객체를 제거하는 기능을 추가했습니다. 테스트코드로 정상적으로 동작하는지 확인합니다.
@Test
@Transactional
void orphanRemovalTest(){
Provider provider = savedProvider("새로운 공급업체");
Product product1 = savedProduct("상품1", 1000, 1000);
Product product2 = savedProduct("상품2", 500, 1500);
Product product3 = savedProduct("상품3", 750, 500);
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));
Provider foundProvider = providerRepository.findById(1L).get();
foundProvider.getProductList().remove(0);
providerRepository.findAll().forEach(System.out::println);
productRepository.findAll().forEach(System.out::println);
}Product(super=BaseEntity(createdAt=2023-08-10T16:07:12.185233,
updatedAt=2023-08-10T16:07:12.185233), number=2, name=상품2, price=500,
stock=1500)
Product(super=BaseEntity(createdAt=2023-08-10T16:07:12.185810,
updatedAt=2023-08-10T16:07:12.185810), number=3, name=상품3, price=750,
stock=500)고아객체가 삭제된것을 확인 가능합니다.
Hibernate:
select
provider0_.id as id1_6_,
provider0_.created_at as created_2_6_,
provider0_.updated_at as updated_3_6_,
provider0_.name as name4_6_
from
provider provider0_
Provider(super=BaseEntity(createdAt=2023-08-10T16:07:12.155443, updatedAt=2023-08-10T16:07:12.155443), id=1, name=새로운 공급업체)
Hibernate:
delete
from
product
where
number=?
Hibernate:
select
product0_.number as number1_3_,
product0_.created_at as created_2_3_,
product0_.updated_at as updated_3_3_,
product0_.name as name4_3_,
product0_.price as price5_3_,
product0_.provider_id as provider7_3_,
product0_.stock as stock6_3_
from
product product0_remove(0) 첫번째 인덱스가 끊긴 상품이 제거된것을 확인이 가능합니다.
