- 일대다 양방향 연관관계 매핑
- Customer : OrderHeader
Customer Entity, Customer Dto
- Customer Entity
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
@Entity
@Getter
@Table(name = "customer")
@NoArgsConstructor(access = AccessLevel.PROTECTED)
public class Customer {
@Id
@Column(name = "id", nullable = false, updatable = false, unique = true)
@GeneratedValue(strategy = GenerationType.IDENTITY)
private Long id;
@Column(name = "customer_email", nullable = false, updatable = false, unique = true)
private String customerEmail;
@Column(name = "first_name", nullable = false)
private String firstName;
@Column(name = "last_name", nullable = false)
private String lastName;
@Column(name = "address", nullable = false)
private String address;
@Setter
@Column(name = "phone", nullable = false)
private String phone;
@OneToMany(mappedBy = "customer")
private List<OrderHeader> orderHeaders = new ArrayList<>();
@Builder
public Customer(String customerEmail, String firstName, String lastName, String address, String phone) {
this.customerEmail = customerEmail;
this.firstName = firstName;
this.lastName = lastName;
this.address = address;
this.phone = phone;
}
public CustomerDto toDto() {
return CustomerDto.builder()
.customerEmail(customerEmail)
.firstName(firstName)
.lastName(lastName)
.address(address)
.phone(phone)
.build();
}
}
- Customer Dto
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
@Getter
@Setter
@Builder
@ToString
@NoArgsConstructor
@AllArgsConstructor
public class CustomerDto {
@NotEmpty
@NotNullEmail
@IdDuplicateCheck(tableName = "customer", columnName = "customer_email")
private String customerEmail;
@NotBlank
private String firstName;
@NotBlank
private String lastName;
@NotBlank
private String address;
@NotBlank
private String phone;
public Customer toEntity() {
return Customer.builder()
.customerEmail(customerEmail)
.firstName(firstName)
.lastName(lastName)
.address(address)
.phone(phone)
.build();
}
}
OrderHeader Entity, OrderHeader Dto
- OrderHeader Entity
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
@Entity
@Getter
@Table(name = "order_header")
@NoArgsConstructor(access = AccessLevel.PROTECTED)
public class OrderHeader {
@Id
@Column(name = "id", nullable = false, updatable = false, unique = true)
@GeneratedValue(strategy = GenerationType.IDENTITY)
private Long id;
@Column(name = "order_date", nullable = false, updatable = false)
private LocalDateTime orderDate;
@ManyToOne
@JoinColumn(name = "customer_id", updatable = false)
private Customer customer;
@PrePersist
private void prePersist() {
orderDate = LocalDateTime.now();
} // entity 가 영구 저장되기 전에 생성되어서 insert 된다.
@Builder
public OrderHeader(Customer customer) {
this.customer = customer;
}
public OrderHeaderDto toDto() {
return OrderHeaderDto.builder()
.customer(customer)
.orderDate(orderDate)
.build();
}
}
- OrderHeader Dto
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
@Getter
@Setter
@ToString
@NoArgsConstructor
public class OrderHeaderDto {
private Customer customer;
private LocalDateTime orderDate;
@Builder
public OrderHeaderDto(Customer customer, LocalDateTime orderDate) {
this.customer = customer;
this.orderDate = orderDate;
}
public OrderHeader toEntity() {
return OrderHeader.builder()
.customer(customer)
.build();
}
}
테스트 코드
RepositorySetup: 저장소 테스트 기본 설정 클래스RepositoryTest: 실제로 테스트가 실행되는 클래스- RepositorySetup
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
@DataJpaTest
@TestMethodOrder(MethodOrderer.OrderAnnotation.class)
@AutoConfigureTestDatabase(replace = AutoConfigureTestDatabase.Replace.NONE)
public abstract class RepositorySetup {
@Autowired
protected CustomerRepository customerRepository;
@Autowired
protected OrderHeaderRepository orderHeaderRepository;
protected CustomerDto customerDto;
@BeforeEach
void beforeEach() {
customerDto =
CustomerDto.builder()
.customerEmail("johnDoe@gmail.com")
.firstName("john")
.lastName("doe")
.address("동작대로 xx길 xxx xx")
.phone("555-0101")
.build();
}
@AfterEach
void afterEach() {
customerDto =
CustomerDto.builder()
.customerEmail("johnDoe@gmail.com")
.firstName("john")
.lastName("doe")
.address("동작대로 xx길 xxx xx")
.phone("555-0101")
.build();
}
}
- RepositoryTest
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
@Slf4j
public class RepositoryTest extends RepositorySetup {
@Test
@Order(1)
void initializer() {
}
@Test
@Order(2)
void customer_save_OK() {
Customer saveCustomer = customer_save(customerDto.toEntity());
Assertions.assertEquals(customerDto.getCustomerEmail(), saveCustomer.getCustomerEmail());
Assertions.assertEquals(customerDto.getFirstName(), saveCustomer.getFirstName());
Assertions.assertEquals(customerDto.getLastName(), saveCustomer.getLastName());
Assertions.assertEquals(customerDto.getAddress(), saveCustomer.getAddress());
Assertions.assertEquals(customerDto.getPhone(), saveCustomer.getPhone());
}
@Test
@Order(3)
void order_header_save_OK() {
Customer saveCustomer = customer_save(customerDto.toEntity());
OrderHeader saveOrderHeader = orderHeaderRepository.save(order_header_dto(saveCustomer).toEntity());
Assertions.assertEquals(saveCustomer.getCustomerEmail(), saveOrderHeader.getCustomer().getCustomerEmail());
Assertions.assertEquals(saveCustomer.getFirstName(), saveOrderHeader.getCustomer().getFirstName());
Assertions.assertEquals(saveCustomer.getLastName(), saveOrderHeader.getCustomer().getLastName());
Assertions.assertEquals(saveCustomer.getAddress(), saveOrderHeader.getCustomer().getAddress());
Assertions.assertEquals(saveCustomer.getPhone(), saveOrderHeader.getCustomer().getPhone());
}
private Customer customer_save(Customer customer) {
Customer save = customerRepository.save(customer);
Assertions.assertNotNull(save);
return save;
}
private OrderHeaderDto order_header_dto(Customer customer) {
return OrderHeaderDto.builder()
.customer(customer)
.build();
}
}