[내일배움캠프_Spring Boot 입문주차] Spring Data JPA

Spring Boot 환경에서의 JPA

Spring Boot 환경에서는 EntityManagerFactory랑 EntityManager를 자동으로 생성해줌

• application.properties에 데이터베이스 관련 정보를 주면, 정보를 바탕으로 자동으로 EntityManagerFactory 만들어줌
• Spring Boot에서 자동으로 생성해주는 EntityManager를 주입받아 오고 싶을 때는 @PersistenceContext 어노테이션 사용

메모장 프로젝트에 JPA 적용하기

1. build.gradle 파일 내 JPA 설정 추가

// JPA 설정
implementation 'org.springframework.boot:spring-boot-starter-data-jpa'

• spring-book-starter-data-jpa 설정하면 자동으로 Hibernate Core를 당겨옴

dependencies {
    // JPA 설정
    implementation 'org.springframework.boot:spring-boot-starter-data-jpa'
    // MySQL
    implementation 'mysql:mysql-connector-java:8.0.28'
    // jdbc 삭제

    implementation 'org.springframework.boot:spring-boot-starter-thymeleaf'
    implementation 'org.springframework.boot:spring-boot-starter-webmvc'
    compileOnly 'org.projectlombok:lombok'
    annotationProcessor 'org.projectlombok:lombok'
    testImplementation 'org.springframework.boot:spring-boot-starter-thymeleaf-test'
    testImplementation 'org.springframework.boot:spring-boot-starter-webmvc-test'
    testCompileOnly 'org.projectlombok:lombok'
    testRuntimeOnly 'org.junit.platform:junit-platform-launcher'
    testAnnotationProcessor 'org.projectlombok:lombok'
}

 

2. application.properties 내 Hibernate 설정 추가

# ddl-auto 옵션
# 1. create: 기존 테이블 삭제 후 다시 생성(drop+create)
# 2. create-drop: create와 비슷하지만, 종료 시점에 table drop
# 3. update: 변경된 부분만 반영(테이블이 있으면 생성 X, 없으면 생성)
# 4. validate: 엔티티와 테이블이 정상적으로 매핑되어있는지만 확인
# 5. none: 아무것도 하지 않음
spring.jpa.hibernate.ddl-auto=update

# show_sql, format_sql, use_sql_comments는
# Hibernate가 자동으로 만들어주는 SQL을 보기 좋게 만들어줌
spring.jpa.properties.hibernate.show_sql=true
spring.jpa.properties.hibernate.format_sql=true
spring.jpa.properties.hibernate.use_sql_comments=true

 

3. Memo Entity 만들기

package com.sparta.memo.entity;

import com.sparta.memo.dto.MemoRequestDto;
import jakarta.persistence.*;
import lombok.Getter;
import lombok.NoArgsConstructor;
import lombok.Setter;

@Entity // JPA가 관리할 수 있는 Entity 클래스 지정
@Getter
@Setter
@Table(name = "memo") // 매핑할 테이블의 이름을 지정
@NoArgsConstructor
public class Memo {
    @Id
    @GeneratedValue(strategy = GenerationType.IDENTITY)
    private Long id;
    @Column(name = "username", nullable = false)
    private String username;
    @Column(name = "contents", nullable = false, length = 500)
    private String contents;

    public Memo(MemoRequestDto requestDto) {
        this.username = requestDto.getUsername();
        this.contents = requestDto.getContents();
    }

    public void update(MemoRequestDto requestDto) {
        this.username = requestDto.getUsername();
        this.contents = requestDto.getContents();
    }
}

---

Spring Boot 트랜잭션

• Java 환경에서 JPA를 사용할 때는 EntityManager에서 Entity 트랜잭션을 가져와서 트랜잭션 환경을 만들었음
• Spring Boot 환경에서는 손쉽게 트랜잭션 환경을 만드는 방법 제공함 → @Transactional 어노테이션 이용
• 클래스 상단에 @Transactional을 걸던가, 아니면 method 자체에 걸어서 트랜잭션 환경이 설정됨
• method 자체에 트랜잭션을 걸면, 해당 method 내에서 수행되는 모든 데이터베이스 연산 내용들을 하나의 트랜잭션으로 묶음
• 이때, 해당 method에서 코드가 전부 정상적으로 수행이 되면 마지막에 끝날 때 Commit하고, 아니면 예외가 발생함
• 왼쪽 이미지에서 @Transactional(readOnly=true)는 클래스 내부에 있는 모든 method에 해당 트랜잭션의 readOnly이 부여됨
  • readOnly 옵션: 트랜잭션에서 데이터를 읽기만 할 때 사용됨
  • 읽기 작업에 대한 최적화 수행 가능
  • 만약 readOnly = true 걸어놓은 상태에서 데이터를 수정하려고 하면 예외가 발생함
• save 메서드처럼 @Transactional이 다시 걸려있는 경우, readOnly = false 옵션으로 적용됨

@Transactional 어노테이션 적용

트랜잭션 테스트

1) 메모 생성 성공 테스트

package com.sparta.memo;

import com.sparta.memo.entity.Memo;
import jakarta.persistence.EntityManager;
import jakarta.persistence.PersistenceContext;
import org.junit.jupiter.api.DisplayName;
import org.junit.jupiter.api.Test;
import org.springframework.boot.test.context.SpringBootTest;
import org.springframework.test.annotation.Rollback;
import org.springframework.transaction.annotation.Transactional;

@SpringBootTest
public class TransactionTest {

    @PersistenceContext
    EntityManager em;

    @Test
    @Transactional
    @Rollback(value = false) // 테스트 코드에서 @Transactional을 사용하면 테스트가 완료된 후 롤백하기 때문에 false 옵션 추가
    @DisplayName("메모 생성 성공")
    void test1() {
        Memo memo = new Memo();
        memo.setUsername("Robbert");
        memo.setContents("@Transactional 테스트 중!");

        em.persist(memo); // 영속성 컨텍스트에 메모 Entity 객체 저장
    }
}

트랜잭션 실행 결과

데이터베이스 내 반영

2) 메모 생성 실패 테스트

@Test
@DisplayName("메모 생성 실패")
void test2() {
    Memo memo = new Memo();
    memo.setUsername("Robbie");
    memo.setContents("@Transactional 테스트 중!");

    em.persist(memo);  // 영속성 컨텍스트에 메모 Entity 객체를 저장합니다.
}

트랜잭션 실패 결과

• Transaction을 사용할 수 없기 때문에 EntityManager 사용할 수 없다는 에러 발생 → Transaction이 적용되어 있지 않다는 에러
• Insert, Update, Delete와 같이 데이터를 수정할 때는 트랜잭션 환경이 반드시 필요함!
• @Disabled 추가하면 오류가 나는 테스트라도 테스트가 아예 수행이 되지 않음

@Test
@Disabled // 더 이상 테스트 수행 안하겠다는 뜻
@DisplayName("메모 생성 실패")
void test2() {
...

---

영속성 컨텍스트와 트랜잭션의 생명주기

Spring 내 영속성 컨텍스트와 트랜잭션의 생명주기

Spring 컨테이너 환경에서는 영속성 컨텍스트와 트랜잭션의 생명주기가 일치함

• 트랜잭션이 유지되는 동안은 영속성 컨텍스트도 계속 유지되기 때문에 영속성 컨텍스트 기능을 사용할 수 있음
• Spring에서는 트랜잭션 전파 기능을 제공하기 때문에 Service부터 Repository까지 Transaction을 유지할 수 있음

---

트랜잭션 전파

// MemoRepository 내에 코드 추가
@Transactional
public Memo createMemo(EntityManager em) {
    Memo memo = em.find(Memo.class, 1);
    memo.setUsername("Robbie");
    memo.setContents("@Transactional 전파 테스트 중!");

    System.out.println("createMemo 메서드 종료");
    return memo;
}

package com.sparta.memo;

import com.sparta.memo.entity.Memo;
import com.sparta.memo.repository.MemoRepository;
import jakarta.persistence.EntityManager;
import jakarta.persistence.PersistenceContext;
import org.junit.jupiter.api.Disabled;
import org.junit.jupiter.api.DisplayName;
import org.junit.jupiter.api.Test;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.test.context.SpringBootTest;
import org.springframework.test.annotation.Rollback;
import org.springframework.transaction.annotation.Transactional;

@SpringBootTest
public class TransactionTest {

    @PersistenceContext
    EntityManager em;

    @Autowired
    MemoRepository memoRepository;

    @Test
    @Transactional
    @Rollback(value = false) // 테스트 코드에서 @Transactional 를 사용하면 테스트가 완료된 후 롤백하기 때문에 false 옵션 추가
    @DisplayName("메모 생성 성공")
    void test1() {
        Memo memo = new Memo();
        memo.setUsername("Robbert");
        memo.setContents("@Transactional 테스트 중!");

        em.persist(memo);  // 영속성 컨텍스트에 메모 Entity 객체를 저장합니다.
    }

    @Test
    @Disabled
    @DisplayName("메모 생성 실패")
    void test2() {
        Memo memo = new Memo();
        memo.setUsername("Robbie");
        memo.setContents("@Transactional 테스트 중!");

        em.persist(memo);  // 영속성 컨텍스트에 메모 Entity 객체를 저장합니다.
    }

    @Test
    @Transactional
    @Rollback(value = false)
    @DisplayName("트랜잭션 전파 테스트")
    void test3() {
        memoRepository.createMemo(em);
        System.out.println("테스트 test3 메서드 종료");
    }
}

• test3() 메서드가 부모 메서드이고, createMemo()가 자식 메서드임

결과

• 즉, 자식 메서드의 트랜잭션이 부모 메서드의 트랜잭션에 합쳐짐
• @Transactional에는 propagation이라는 옵션이 존재함

@Transactional의 propagation 옵션

REQUIRED: 부모 메서드에 Transactional이 존재한다면, 자식 메서드의 트랜잭션은 부모 메서드의 트랜잭션에 합류하게 됨(default 옵션)

@Transactional(propagation = Propagation.REQUIRED)

 

만약, 부모 메서드에 Transactional이 존재하지 않는다면, 자식 메서드 트랜잭션 종료 후 끝남

@Test
// @Transactional()
// @Rollback(value = false)
@DisplayName("트랜잭션 전파 테스트")
void test3() {
    memoRepository.createMemo(em);
    System.out.println("테스트 test3 메서드 종료");
}

부모 메서드에 Transactional이 없는 경우

---

Spring Data JPA

Spring Data JPA는 JPA를 쉽게 사용할 수 있게 만들어놓은 하나의 모듈

Spring Data JPA

• JPA를 추상화시킨 Repository 인터페이스 제공함
• Repository 인터페이스는 Hibernate와 같은 JPA 구현체를 사용해서 구현한 클래스를 통해 사용됨
  • 개발자들은 Repository 인터페이스를 통해 JPA를 간편하게 사용할 수 있게 됨

Spring Data JPA의 SimpleJpaRepository

• Spring Data JPA에서는 JpaRepository 인터페이스를 구현하는 클래스를 자동으로 생성해줌
  • Spring 서버가 뜰 때 JpaRepository 인터페이스를 상속받은 인터페이스가 자동으로 스캔이 되면, 해당 인터페이스의 정보를 토대로 자동으로 SimpleJpaRepository 클래스를 생성해주고, 이 클래스를 Spring Bean으로 등록함
• 따라서 인터페이스의 구현 클래스를 직접 작성하지 않아도 JpaRepository 인터페이스를 통해 JPA의 기능을 사용할 수 있음

public interface MemoRepository extends JpaRepository<Memo, Long> {

}

• JpaRepository<"@Entity 클래스", "@Id의 데이터 타입">를 상속받는 interface로 선언함
  • Spring Data JPA에 의해 자동으로 Bean 등록 됨
  • 제네릭스의 @Entity 클래스 위치에 Memo Entity를 추가했기 때문에 해당 MemoRepository는 DB의 memo 테이블과 연결되어 CRUD 작업을 처리하는 인터페이스가 됨

메모장 프로젝트에 Spring Data JPA 적용하기

package com.sparta.memo.repository;

import com.sparta.memo.entity.Memo;
import org.springframework.data.jpa.repository.JpaRepository;
import org.springframework.stereotype.Repository;

// SimpleJpaRepository에 @Repository 어노테이션이 존재하기 때문
// interface에 따로 @Repository 달아주지 않아도 됨!
// @Repository
public interface MemoRepository extends JpaRepository<Memo, Long> {

}

package com.sparta.memo.service;


import com.sparta.memo.dto.MemoRequestDto;
import com.sparta.memo.dto.MemoResponseDto;
import com.sparta.memo.entity.Memo;
import com.sparta.memo.repository.MemoRepository;
import jakarta.transaction.Transactional;
import org.springframework.stereotype.Service;

import java.util.List;

@Service
public class MemoService {

    private final MemoRepository memoRepository;

    // MemoService가 생성이 될 때, 파라미터로 JdbcTemplate 받아오고
    // 딱 한 번만 MemoRepository를 만듦기
    public MemoService(MemoRepository memoRepository) {
        this.memoRepository = memoRepository;
    }

    public MemoResponseDto createMemo(MemoRequestDto requestDto) {
        // RequestDto -> Entity
        Memo memo = new Memo(requestDto);

        // DB 저장
        Memo saveMemo = memoRepository.save(memo);

        // Entity -> ResponseDto
        MemoResponseDto memoResponseDto = new MemoResponseDto(memo);

        return memoResponseDto;
    }

    public List<MemoResponseDto> getMemos() {
        // DB 조회
        return memoRepository.findAll().stream().map(MemoResponseDto::new).toList();
    }

    @Transactional
    public Long updateMemo(Long id, MemoRequestDto requestDto) {
        // 해당 메모가 DB에 존재하는지 확인
        Memo memo = findMemo(id);

        // memo 내용 수정
        memo.update(requestDto);

        return id;
    }

    public Long deleteMemo(Long id) {
        // 해당 메모가 DB에 존재하는지 확인
        Memo memo = findMemo(id);

        // memo 삭제
        memoRepository.delete(memo);

        return id;
    }

    private Memo findMemo(Long id) {
        // 해당 메모가 DB에 존재하는지 확인
        return memoRepository.findById(id).orElseThrow(() ->
                new IllegalArgumentException("선택한 메모는 존재하지 않습니다.")
        );
    }
}

---

JPA Auditing 적용하기

• 데이터가 저장될 때마다 저장된 시간 혹은 수정된 시간을 저장하고 보여주고 싶을 경우, 코드를 직접 작성하는 것을 시간도 걸리고 로직도 변경해야 함
• 또한, 여러 엔티티에 생성 시간과 수정 시간을 추가하고 싶을 경우, 모든 엔티티 클래스를 순회하면서 직접 넣어주어야 함

Spring Data JPA는 시간에 대해서 자동으로 값을 넣어주는 기능인 JPA Auditing 제공하고 있음

package com.sparta.memo.entity;

import jakarta.persistence.*;
import lombok.Getter;
import org.springframework.data.annotation.CreatedDate;
import org.springframework.data.annotation.LastModifiedDate;
import org.springframework.data.jpa.domain.support.AuditingEntityListener;

import java.time.LocalDateTime;

@Getter
// @MappedSuperclass 어노테이션
// JPA Entity Class들이 해당 출생 Class를 상속할 경우,
// 추상 클래스(abstract class)에서 선언한 멤버 변수(즉, 여기서는 createdAt, modifiedAt)를 컬럼으로 인식해줌
@MappedSuperclass
// @EntityListeners(AuditingEntityListener.class) 어노테이션
// 해당 클래스 즉 Timestamped 클래스의 Auditing 기능 포함시켜줌
// 이 어노테이션을 달아줘야지 자동으로 시간을 넣어주는 기능이 수행됨
@EntityListeners(AuditingEntityListener.class)
public abstract class Timestamped {

    @CreatedDate // Entity 객체가 생성되어 저장될 때 시간 값이 자동으로 저장됨
    @Column(updatable = false) // 최초 시간만 저장되고, 수정 시간은 저장되게 하지 않기 위해 updatable = false 옵션 추가
    @Temporal(TemporalType.TIMESTAMP) // Java의 Date Type 혹은 Calender 같은 날짜 데이터를 매핑할 때 사용
    // DATE: 20xx-01-01
    // TIME: 20:21:13
    // TIMESTAMP: 20xx-01-01 20:21:13.33333
    private LocalDateTime createdAt;

    @LastModifiedDate // 조회한 Entity 객체 값을 변경할 때, 변경된 시간이 자동으로 저장됨
    @Column
    @Temporal(TemporalType.TIMESTAMP)
    private LocalDateTime modifiedAt;
}

@EnableJpaAuditing // JPA Auditing 기능을 사용하기 위해서 알려줘야함
@SpringBootApplication
public class MemoApplication {

    public static void main(String[] args) {
        SpringApplication.run(MemoApplication.class, args);
    }

}

@Entity // JPA가 관리할 수 있는 Entity 클래스 지정
@Getter
@Setter
@Table(name = "memo") // 매핑할 테이블의 이름을 지정
@NoArgsConstructor
public class Memo extends Timestamped{
    @Id
    @GeneratedValue(strategy = GenerationType.IDENTITY)
    private Long id;
    ...

package com.sparta.memo.dto;

import com.sparta.memo.entity.Memo;
import lombok.Getter;

import java.time.LocalDateTime;

@Getter
public class MemoResponseDto {
    private Long id;
    private String username;
    private String contents;
    private LocalDateTime createdAt;
    private LocalDateTime modifiedAt;

    public MemoResponseDto(Memo memo) {
        this.id = memo.getId();
        this.username = memo.getUsername();
        this.contents = memo.getContents();
        this.createdAt = memo.getCreatedAt();
        this.modifiedAt = memo.getModifiedAt();
    }
}

JPA Auditing 추가

---

Query Methods란?

Spring Data JPA에서는 method 이름으로 SQL을 생성할 수 있는 Query Methods 기능을 제공하고 있음

public interface MemoRepository extends JpaRepository<Memo, Long> {
    // ModifiedAt 필드 데이터 기준으로 내림차순으로 정렬해서 전체 데이터를 내보냄
    List<Memo> findAllByOrderByModifiedAtDesc();
}

• 위의 예시처럼 이미 정의되어 있는 규칙에 맞게끔 method를 선언하면, 해당 method 이름을 분석한 후 SimpleJpaRepository에서 구현됨

결과

public interface MemoRepository extends JpaRepository<Memo, Long> {
    ...

    // 특정 username을 가진 사람의 Memo 데이터 가져옴
    List<Memo> findAllByUsername(String username);
}