3장: JPA로 데이터베이스 다루기 (2)

Table of Contents

 

 

API 만들기

API를 만들어보며 구조 이해하기

필요한 클래스

- Request 데이터 받을 Dto

- API 요청 받을 Controller

- 트랜잭션, 도메인 기능 간 순서를 보장하는 Service (비지니스 로직을 처리하지는 않음)

Spring 웹 계층

Web Layer

- 컨트롤러와 JSP등의 뷰 템플릿 영역

- Filter, 인터셉트, ControllerAdvice 등 외부 요청과 응답에 대한 전반적인 영역

 

Service Layer

- @Service에 사용되는 영역

- Controller와 Dao 중간에서 사용됨

- @Transactional이 사용되어야 함

 

Repository Layer

- 데이터 저장소에 접근하는 영역

 

DTOs

- Data Transfer Object

- 계층 간 데이터 교환을 위한 객체 DTO의 영역

- 뷰 템플릿 엔진에서 사용되거나 Repository Later에서 결과로 넘어온 객체들이 해당됨

 

Domain Model

- @Entity가 사용된 영역

- VO(값 객체)도 이 영역에 해당되므로, 무조건 데이터베이스의 테이블과 관계있지는 않음

 

💡 서비스와 도메인의 역할 분담은 어떻게 하는가?

서비스 클래스 내부에서 로직을 처리하는 것보다는

도메인 모델 내에서 로직을 처리하고 서비스 메소드는 트랜잭션과 도메인 간의 순서만 보장하도록 구성

 

- 서비스 메소드 예제

@Transactional
public Order cancelOrder(int orderId){
    Orders order = ordersRepository.findById(orderId);
    Billing billing = billingRepository.findById(orderId);
    Delivery delivery = deliveryRepository.findById(orderId);

    delivery.cancel();
    order.cancel();
    billing.cancel();

    return order;
}

각 도메인 모델이 취소 이벤트 처리를 하고 서비스 메소드는 트랜잭션과 도메인 간의 순서만 보장

 

Bean을 주입받는 방식

1. 생성자

• @Autowired와 동일한 효과를 가짐
• @RequiredArgsConstructor에서 final이 선언된 모든 필드를 인자값으로 하는 생성자를 생성해주므로, 클래스의 의존성 관계가 변경되어도 직접 코드를 수정하지 않아도 됨
• 가장 권장하는 방식임

2. setter

3. @Autowired

클래스 생성해서 CRUD 구현하기

Controller 클래스 구현

@RequiredArgsConstructor
@RestController
public class PostsApiController {

    private final PostsService postsService;

    @PostMapping("/api/v1/posts")
    public Long save(@RequestBody PostsSaveRequestDto requestDto){
        return postsService.save(requestDto);
    }

    @PutMapping("/api/v1/posts/{id}")
    public Long update(@PathVariable Long id, @RequestBody PostsUpdateRequestDto requestDto){
        return postsService.update(id, requestDto);
    }

    @GetMapping("/api/v1/posts/{id}")
    public PostsResponseDto findById(@PathVariable Long id){
        return postsService.findById(id);
    }

    @DeleteMapping("/api/v1/posts/{id}")
    public Long delete(@PathVariable Long id){
        postsService.delete(id);
        return id;
    }
}

Service 클래스 구현

- update 서비스 메소드

• id와 일치하는 Posts 객체가 있는지 확인 후 불러옴
• PostsUpdateRequestDto에 title과 content를 담아온 후 도메인 객체(Posts)의 update 메소드에 PostsUpdateRequestDto 전달

@RequiredArgsConstructor
@Service
public class PostsService {
    private final PostsRepository postsRepository;

    @Transactional
    public Long save(PostsSaveRequestDto requestDto){
        return postsRepository.save(requestDto.toEntity()).getId();
    }

    @Transactional
    public Long update(Long id, PostsUpdateRequestDto requestDto){
        Posts posts=postsRepository.findById(id)
                .orElseThrow(()-> new IllegalArgumentException("해당 게시글이 없습니다. id="+ id));
        posts.update(requestDto.getTitle(), requestDto.getContent());

        return id;
    }

    public PostsResponseDto findById(Long id){
        Posts entity=postsRepository.findById(id)
                .orElseThrow(()->new IllegalArgumentException("해당 게시글이 없습니다. id="+ id));
        return new PostsResponseDto(entity);
    }

    @Transactional(readOnly = true)
    public List<PostsListResponseDto> findAllDesc(){
        return postsRepository.findAllDesc().stream()
                .map(PostsListResponseDto::new)
                .collect(Collectors.toList());
    }

    @Transactional
    public void delete(Long id){
        Posts posts=postsRepository.findById(id)
                .orElseThrow(()->new IllegalArgumentException("해당 게시글이 없습니다. id= "+id));
        postsRepository.delete(posts);
    }

}

영속성 컨텍스트

- 엔티티를 영구 저장하는 환경

- Spring Data JPA를 사용할 경우, 트랜잭션 안에서 데이터베이스의 데이터를 가져오면 해당 데이터는 영속성 컨텍스트가 유지된 상태임

- 데이터 값을 변경 시 트랜잭션이 끝나는 시점에 해당 테이블에 변경분을 반영하여 데이터베이스에 쿼리를 날릴 필요가 없음(Dirty Checking)

 

DTO 클래스 구현

DTO 클래스를 사용하는 이유

Entity 클래스를 기준으로 테이블 생성, 스키마 변경이 수행됨

하지만 Request/Response용 DTO는 View를 위한 클래스이므로 자주 변경되어야 함 

따라서 Entity 클래스를 절대 Request/Response 클래스로 사용하면 안됨

실제로 Controller에서 결괏값으로 여러 테이블을 조인해 반환해야 하는 경우가 많음

View Layer의 DTO클래스와 DB Layer의 Entity 클래스로 나누어 철저한 역할 분리 필요

 

- PostsSaveRequestDto

title, content, author를 파라미터로 입력 받아 엔티티로 만듦

@Getter
@NoArgsConstructor
public class PostsSaveRequestDto {
    private String title;
    private String content;
    private String author;

    @Builder
    public PostsSaveRequestDto(String title, String content, String author){
        this.title=title;
        this.content=content;
        this.author=author;
    }

    public Posts toEntity(){
        return Posts.builder()
                .title(title)
                .content(content)
                .author(author)
                .build();
    }
}

 

- PostsResponseDto

모든 필드를 가진 생성자가 필요하지 않으므로 생성자로 Entity를 받아 필드에 값 입력

@Getter
public class PostsResponseDto {
    private Long id;
    private String title;
    private String content;
    private String author;

    public PostsResponseDto(Posts entity) {
        this.id = entity.getId();
        this.title = entity.getTitle();
        this.content = entity.getContent();
        this.author = entity.getAuthor();
    }
}

 

테스트 메소드 구현

@Test
public void edit_Posts() throws Exception{
    //given
    Posts savedPosts=postsRepository.save(Posts.builder()
            .title("title")
            .content("content")
            .author("me")
            .build());

    Long updateId=savedPosts.getId();
    String expectedTitle="title2";
    String expectedContent="content2";

    PostsUpdateRequestDto requestDto=PostsUpdateRequestDto.builder()
            .title(expectedTitle)
            .content(expectedContent)
            .build();
    String url="http://localhost:"+port+"api/v1/posts/"+updateId;

    HttpEntity<PostsUpdateRequestDto> requestEntity=new HttpEntity<>(requestDto);

    //when
    ResponseEntity<Long> responseEntity=restTemplate.exchange(url, HttpMethod.PUT, requestEntity, Long.class);

    //then
    assertThat(responseEntity.getStatusCode()).isEqualTo(HttpStatus.OK);
    assertThat(responseEntity.getBody()).isGreaterThan(0L);

    List<Posts> all = postsRepository.findAll();
    assertThat(all.get(0).getTitle()).isEqualTo(expectedTitle);
    assertThat(all.get(0).getContent()).isEqualTo(expectedContent);
}

 

JPA Auditing으로 생성시간/수정시간 자동화

데이터의 생성 시간과 수정 시간을 모든 테이블과 서비스 메소드에 포함할 수 있도록 하는 방법

 

BaseTimeEntity 클래스 구현

@Getter
@MappedSuperclass
@EntityListeners(AuditingEntityListener.class)
public abstract class BaseTimeEntity {

    @CreatedDate
    private LocalDateTime createdDate;

    @LastModifiedDate
    private LocalDateTime modifiedDate;
}

모든 Entity의 상위 클래스가 되어 Entity들의 createdDate, modifiedDate를 자동으로 관리

@MappedSuperclass: JPA Entity 클래스들이 해당 클래스를 상속할 경우 BaseTimeEntity의 필드들도 칼럼으로 인식하도록 함

Entity 클래스에 상속 표시

public class Posts extends BaseTimeEntity {
...
}

Application 클래스에 활성화 어노테이션 추가

@EnableJpaAuditing
@SpringBootApplication
public class Application {
...
}