스프링 데이터 JPA

@MappedSuperclass
@Getter
public class JpaBaseEntity {

    @Column(updatable = false)
    private LocalDateTime createdDate;
    private LocalDateTime updatedDate;

    @PrePersist
    public void prePersist() {
        LocalDateTime now = LocalDateTime.now();
        createdDate = now;
        updatedDate = now;
    }

    @PreUpdate
    public void preUpdate() {
        updatedDate = LocalDateTime.now();
    }

}

@Test
@DisplayName("Auditing - 순수 JPA")
void auditing() throws InterruptedException {
    Member userA = new Member("userA");
    jpaRepository.save(userA);  // @PrePersist

    Thread.sleep(200);
    userA.setUsername("userB");

    em.flush(); // @PreUpdate
    em.clear();

    Member foundUserA = jpaRepository.findById(userA.getId()).get();

    System.out.println("foundUserA.getCreatedDate() = " + foundUserA.getCreatedDate());
    System.out.println("foundUserA.getUpdatedDate() = " + foundUserA.getUpdatedDate());
}

스프링 데이터 JPA를 사용하는 경우

• 환경
  • @EnableJpaAuditing : 스프링 부트 구성 클래스에 적용
    • 저장 시 저장된 데이터만 입력하고 싶은 경우(update 열에 null 값 포함) @EnableJpaAuditing(modifyOnCreate = false)
  • @EntityListeners(AuditingEntityListener.class) : 엔티티에 적용

@EnableJpaAuditing
@SpringBootApplication
public class DataJpaApplication {

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

	@Bean
	public AuditorAware<String> auditorProvider() {
		return new AuditorAware<String>() {
			@Override
			public Optional<String> getCurrentAuditor() {
				return Optional.of(UUID.randomUUID().toString());
			}
		};
	}
}

• 주석 사용
  • @CreatedDate
  • @LastModifiedDate
  • @CreatedBy
  • @LastModifiedBy

@EntityListeners(AuditingEntityListener.class)
@MappedSuperclass
@Getter
public class BaseEntity extends BaseTimeEntity {
    @CreatedBy
    @Column(updatable = false)
    private String createdBy;

    @LastModifiedBy
    private String lastModifiedBy;
}

@EntityListeners(AuditingEntityListener.class)
@MappedSuperclass
@Getter
public class BaseTimeEntity {
    @CreatedDate
    @Column(updatable = false)
    private LocalDateTime createdDate;

    @LastModifiedDate
    private LocalDateTime lastModifiedDate;
}

웹 확장 - 도메인 클래스 변환기

HTTP 매개 변수로 전달된 엔터티의 ID로 엔터티 개체를 찾아 바인딩합니다.

• 도메인 클래스 변환기를 사용한 후 HTTP 요청은 구성원 ID를 수신하지만 도메인 클래스 변환기는 중간에서 작동하며 구성원 엔터티 개체를 반환합니다.하다.
• 도메인 클래스 변환기 결국 저장소를 사용하여 엔터티를 찾습니다.
• 엔터티가 도메인 클래스 변환기에 대한 매개 변수로 수신되면 이 엔터티는 단순 조회에만 사용해야한다.
  • 논트랜잭션 범위에서 엔터티를 조회하였기 때문에 엔터티가 변경되더라도 DB에 반영되지 않는다.

 // 도메인 클래스 컨버터 사용 전
@GetMapping("/members/before/{id}")
public String findMember1(@PathVariable("id") Long id) {
    Member member = memberRepository.findById(id).get();
    return member.getUsername();
}

// 도메인 클래스 컨버터 사용 후
@GetMapping("/members/after/{id}")
public String findMember2(@PathVariable("id") Member member) {
    return member.getUsername();
}

웹 확장 - 페이징 및 정렬

• Pageable을 매개변수로 받을 수 있습니다.
• 매개변수
  • 페이지 : 현재 페이지. (0부터 시작)
  • 크기: 한 페이지에 노출될 데이터의 개수
  • sort : 정렬 조건. (ASC/내림차순)

spring.data.web:
      pageable:
        default-page-size: 10 # 기본 페이지 사이즈
        max-page-size: 2000

// 페이징과 정렬 - 개별 설정 (@PageableDefault)
@GetMapping("/members_page")
public Page<Member> list2(@PageableDefault(size = 5, sort = "username", direction = Sort.Direction.DESC) Pageable pageable) {
    return memberRepository.findAll(pageable);
}

• 접두사
  • 페이징 정보가 둘 이상인 경우 접두사로 구분됩니다.
  • @Qualifier에 접두사를 추가합니다.
  • 기본값 : /members?member_page=0&order_page=1
• 페이지 콘텐츠를 DTO로 변환
  • 페이지는 DTO로 변환하기 위해 map()을 지원합니다.
• 1부터 페이지를 시작하는 방법
  1. Pageable 및 Page를 매개변수 및 응답 값으로 사용하는 대신 클래스를 직접 생성하고 처리합니다. 즉, PageRequest가 직접 생성되어 저장소로 전달되고, Page 대신 응답 값도 생성되어 제공됩니다.
  2. spring.data.web.pageable.one-indexed-parameters를 true로 설정합니다. 하지만 이 방식은 웹에서 매개변수 -1만 처리하기 때문에 응답 값인 모든 페이지에 대해 페이지 인덱스를 0으로 사용하는 데에는 한계가 있습니다.

사양(명세)

Domain Driven Design이라는 책에서는 사양의 개념을 소개합니다. 따라서 Spring Data JPA는 JPA Criteria를 활용하여 이 개념의 사용을 지원합니다.

술어 ( 술어 )

package org.springframework.data.jpa.domain;

public interface Specification<T> extends Serializable {

• 참 또는 거짓으로 평가합니다.
• AND, OR 등의 연산자를 조합하여 다양한 검색 조건을 손쉽게 생성할 수 있습니다. (복합 패턴)

사양 기능 사용 방법

1. JpaSpecificationExecutor 인터페이스를 상속합니다.
2. 사양은 매개변수로 받아 검색 조건으로 사용됩니다.
   • 사양은 사양을 구현하여 조립할 수 있습니다. -> where(), and(), or(), not() 제공

public interface MemberRepository extends JpaRepository<Member, Long>, MemberRepositoryCustom, JpaSpecificationExecutor<Member> {

• 사양을 정의하려면 사양 인터페이스를 구현해야 합니다.
  • 사양을 정의할 때 toPredicate 메서드만 구현하면 됩니다. 이때 JPA Criteria의 Root, CriteriaQuery, CriteriaBuilder 클래스를 파라미터로 제공한다.

public class MemberSpec {
    public static Specification<Member> teamName(final String teamName) {
        return (root, query, builder) -> {

            if (StringUtils.isEmpty(teamName)) {
                return null;
            }

            Join<Member, Team> t = root.join("team", JoinType.INNER);// 회원과 조인
            return builder.equal(t.get("teamName"), teamName);
        };
    }

    public static Specification<Member> username(final String username) {
        return (root, query, builder) -> builder.equal(root.get("username"), username);
    }
}

@Test
@DisplayName("명세 기능 사용")
void specification() {
    Team teamA = new Team("teamA");
    em.persist(teamA);

    Member user1 = new Member("user1", 10, teamA);
    Member user2 = new Member("user2", 20, teamA);
    em.persist(user1);
    em.persist(user2);

    em.flush();
    em.clear();

    Specification<Member> spec = MemberSpec.username("user1").and(MemberSpec.teamName("teamA"));
    List<Member> result = memberRepository.findAll(spec);

    assertThat(result.size()).isEqualTo(1);
    assertThat(result.get(0).getUsername()).isEqualTo("user1");
}

select m1_0.member_id,m1_0.age,m1_0.created_by,m1_0.created_date,m1_0.last_modified_by,m1_0.last_modified_date,m1_0.team_id,m1_0.username 
from member m1_0 
join team t1_0 
	on t1_0.team_id=m1_0.team_id 
where m1_0.username="user1" 
	and t1_0.team_name="teamA";

예를 통한 쿼리(예를 사용한 쿼리.)

• 엔터티 자체가 검색 조건이 됩니다.

@Test
@DisplayName("Query By Example")
void queryByExample() {
    Team teamA = new Team("teamA");
    em.persist(teamA);

    Member user1 = new Member("user1", 10, teamA);
    Member user2 = new Member("user2", 20, teamA);
    em.persist(user1);
    em.persist(user2);

    em.flush();
    em.clear();

    // Probe 생성
    Member member = new Member("user1");
    Team team = new Team("teamA");  // 내부조인으로 teamA 가능
    member.setTeam(team);

    // ExampleMatcher 생성
    // age property 는 무시
    ExampleMatcher matcher = ExampleMatcher.matching()
            .withIgnorePaths("age");

    Example<Member> example = Example.of(member, matcher);

    List<Member> result = memberRepository.findAll(example);

    assertThat(result.size()).isEqualTo(1);
    assertThat(result.get(0).getUsername()).isEqualTo("user1");
}

• 프로브: 필드에 데이터가 있는 실제 도메인 개체
• ExampleMatcher: 일치하는 특정 필드에 대한 자세한 정보를 제공합니다. (재사용 가능)
• 예 : 쿼리를 생성하는 데 사용됩니다. (Probe와 ExampleMatcher로 구성)

장점

• 동적 쿼리를 편리하게 처리할 수 있습니다.
• 도메인 개체를 있는 그대로 사용합니다.
• 데이터 저장소가 RDB에서 NoSQL로 변경되더라도 코드 변경이 없도록 추상화됩니다.
• Spring Data JPA - JpaRepository Interface에 이미 포함되어 있습니다.

불리

• 조인은 가능하지만 외부 조인이 아닌 내부 조인만 가능합니다.
• 중복 제약이 없습니다.
  • 이름 = ?0 또는 (이름 = ?1 및 성 = ?2)
• 매칭 조건은 매우 간단합니다.
  • 메시지
    • 시작하다
    • 포함
    • 끝
    • 정규식
  • 다른 속성은 일치만 지원합니다.
• 따라서 매칭 조건이 실무에서 사용하기에는 너무 단순하고, LEFT 조인이 불가능하다는 단점이 있다.

예측

엔터티 대신 DTO를 편리하게 쿼리하는 데 사용됩니다.

쿼리의 select 절에 있는 필드

• 프로젝션의 의미
  • 조회할 엔터티의 필드를 getter 형식으로 지정하면 해당 필드만 선택하여 조회할 수 있습니다.
  • Spring Data JPA에서 사용시 메소드 이름은 자유이며 반환형은 인식한다.

인터페이스 기반 Closed Projections

• 속성 유형(getter) 인터페이스가 제공되면 Spring Data JPA에서 구현을 제공합니다.

public interface UsernameOnly {
    String getUsername();
}

select
    m1_0.username 
from
    member m1_0 
where
    m1_0.username="user1";

인터페이스 기반 오픈 프로젝션

• SpEL 구문이 지원됩니다.
• 단, SpEL 구문을 사용하는 경우에는 DB에서 모든 엔터티 필드를 조회한 후 계산한다. 따라서 JPQL SELECT 절의 최적화가 불가능합니다.

public interface UsernameOnly {
    @Value("#{target.username + ' ' + target.age}")
    String getUsername();
}

select
    m1_0.member_id,
    m1_0.age,
    m1_0.created_by,
    m1_0.created_date,
    m1_0.last_modified_by,
    m1_0.last_modified_date,
    m1_0.team_id,
    m1_0.username 
from
    member m1_0 
where
    m1_0.username="user1";

클래스 기반 프로젝션

• 비 인터페이스 콘크리트 DTO 유형
• 생성자 매개변수 이름으로 일치

동적 프로젝션

Generic 유형이 제공되면 프로젝션 데이터를 동적으로 변경할 수 있습니다.

<T> List<T> findProjectionTByUsername(String username, Class<T> type);

List<UsernameOnly> result3 = memberRepository.findProjectionTByUsername("user1", UsernameOnly.class);

중첩 구조 처리

public interface NestedClosedProjection {
    String getUsername();

    Teaminfo getTeam();

    interface Teaminfo {
        String getTeamName();
    }
}

select
    m1_0.username,
    t1_0.team_id,
    t1_0.team_name 
from
    member m1_0 
left join
    team t1_0 
        on t1_0.team_id=m1_0.team_id 
where
    m1_0.username="user1"

• 프로젝션 대상이 루트 엔터티(여기서는 멤버)이면 JPQL SELECT 절 최적화가 가능합니다.
• 프로젝션 대상이 루트가 아닌 경우
  • 왼쪽 외부 조인을 처리해야 합니다.
  • 모든 필드가 선택되고 엔터티로 검색된 다음 계산됩니다.
• 정리하다
  • 프로젝션 대상이 루트 엔터티인 경우에 유용합니다.
  • 프로젝션 대상이 루트 엔터티를 벗어나면 JPQL 선택 최적화가 실패합니다.
  • 실제로 복잡한 경우 QueryDSL을 사용하십시오.

네이티브 쿼리

Spring Data JPA 기반 네이티브 쿼리

• 페이징을 지원합니다.
• 반환 유형
  • 물체()
  • 튜플
  • DTO(스프링 데이터 인터페이스 프로젝션 지원)
• 제한
  • Sort 매개변수를 통한 정렬이 정상적으로 작동하지 않을 수 있습니다.
  • JPQL과 마찬가지로 애플리케이션 로딩 시 문법 검사가 불가능하다.
  • 동적 쿼리는 불가능합니다.
• NativeSQL을 DTO로 쿼리할 때 JdbcTemplate 또는 MyBatis를 사용합니다.
• 프로젝션 활용(정적 쿼리의 경우 유용할 것 같음)

);