[JPA] Spring Data JPA - 쿼리 메소드 기능

[Spring Data JPA] 스프링 데이터 JPA

Spring Data JPA는 스프링 프레임워크에서 JPA를 편리하게 사용할 수 있도록 지원하는 프로젝트입니다.

이 프로젝트는 데이터 접근 계층을 개발할 때 지루하게 반복되는 CRUD를 처리하기 위한 공통 인터페이스를 제공합니다.

따라서 구현 클래스 없이 인터페이스만 작성해도 리포지토리 계층을 개발할 수 있습니다.

 

이 전 포스팅에서 다뤘던 스프링 데이터 JPA의 기능을 깊게 알아봅시다.

 

기본적으로 공통 인터페이스 기능과 쿼리 메소드 기능을 지원하는 Spring Data JPA에서 쿼리 메소드 기능을 자세히 다뤄봅시다.

---

쿼리 메소드 기능

인터페이스에 Spring Data JPA 가 지원하는 형식의 메소드 이름을 적어두면, 메소드 이름을 분석해서 자동으로 쿼리를 만들고 실행해주는 기능. 

 

나눠보면 크게 세 가지 기능이 있습니다.

1.  메소드 이름으로 쿼리 생성
2.  메소드 이름으로 JPA NamedQuery 호출.
3. @Query 어노테이션으로 Repository 인터페이스에 쿼리 직접 정의

---

메소드 이름으로 쿼리 생성

: 메소드 이름을 분석해서 JPQL 쿼리 생성

 

Spring Data JPA를 사용하지 않은 순수 JPA 리포지토리 계층

@Repository
public class MemberJpaRepository {
    @PersistenceContext
    private EntityManager em;

    // C
    public Member save(Member member) {
        member.setName("KIM");
        em.persist(member);
        return member;
    }

    // R
    public Member find(Long id) {
        return em.find(Member.class, id);
    }

    // R
    public Optional<Member> findById(Long id) {
        Member member = em.find(Member.class, id);
        return Optional.ofNullable(member);
    }

    // R
    public List<Member> findAll() {
        return em.createQuery("select m from Member m",Member.class).getResultList();
    }

    public long count() {
        return em.createQuery("select count(m) from Member m", Long.class).getSingleResult();
    }

    // D
    public void delete(Member member) {
        em.remove(member);
    }


}

Spring Data JPA 리포지토리

public interface MemberRepository extends JpaRepository<Member, Long> {
}

스프링 데이터 JPA는 메소드 이름을 분석해서 JPQL을 생성하고 실행합니다.

• 조회(R) : find..By, read..By, query..By, get..By / Return 타입 Entity
• 삭제(D) : delete..By, remove..By / Return 타입 Long

자세한 공식 문서

 

Spring Data JPA - Reference Documentation

이 기능은 엔티티의 피륻명이 변경되면 인터페이스에 정의한 메소드 이름도 함께 변경해야 합니다.
변경하지 않으면 애플리케이션을 시작하는 시점에서 오류가 발생하는데, 로딩 시점에 사용자에게 오류를 인지할 수 있도록 해주는것 또한 Spring Data JPA의 큰 장점입니다.

---

JPA Named Query

스프링 데이터 JPA는 메소드 이름으로 JPA Named 쿼리를 호출하는 기능 또한 제공합니다.

 

기존 순수 JPA 정적 네임드 쿼리 방식 

[JPA] JPQL 문법 4 - 다형성 쿼리, 엔티티 직접사용, Named 쿼리

@Entity
@NoArgsConstructor(access = AccessLevel.PROTECTED) // 기본 생성자 막고싶은데, JPA 스펙상 protected로 열어두어야 함
@Getter @Setter
@ToString(of = {"id","name","age"}) // @ToString 사용 시 가급적 내부 필드만, 연관관계 필드는 X
@NamedQuery(
        name="Member.findByName",
        query="select m from Member m where m.name =: name"
)
public class Member {

public Member findByName() {
    return em.createNamedQuery("Member.findByName", Member.class).getSingleResult();
}

• 도메인에 네임드 쿼리 정의 및 리포지토리 계층에서 도메인에 설정한 네임드 쿼리 사용 

Spring Data JPA로 NamedQuery 사용

public interface MemberRepository extends JpaRepository<Member, Long> {
    
    @Query(name="Member.findByName")
    List<Member> findByName(@Param("name") String name);
}

• 인터페이스 리포지토리에 이렇게 네임드 쿼리를 @Query로 정의하고 쿼리 메소드 이름 기능으로 선언하기만 해주면 됩니다.

@Query를 생략하고 메소드 이름만으로 Named Query를 호출할 수도 있습니다.

public interface MemberRepository extends JpaRepository<Member, Long> {
	// 기본적으로 쿼리 이름 메소드 전략 사용    
    List<Member> findByName(@Param("name") String name);
}

스프링 데이터 JPA는 선언한 "도메인 클래스 + . + 메소드 이름"으로 Named 쿼리를 찾아서 실행합니다.
만약 실행할 Named 쿼리가 없으면 메소드 이름으로 쿼리 생성 전략을 사용합니다.

---

@Query에 쿼리 직접 정의 

실무에서 기존 순수 JPA 방식으로 Named Query를 직접 등록해서 사용하는 경우는 드물고, 대개 네임드 쿼리를 사용한다고 하면 @Query를 사용해서 리포지토리 메소드에 직접 쿼리를 정의합니다.

@Query에 JPQL 쿼리 직접 작성하여 쿼리 메소드 전략을 사용하지 않고 직접 사용자가 만든 쿼리 등록도 가능합니다.

public interface MemberRepository extends JpaRepository<Member, Long> {

    @Query("select m from Member m where m.name =: name and m.age = :age")
    List<Member> findUsers(@Param("name") String name, @Param("age") int age);
}

실무에서는 메소드 이름으로 쿼리 생성하는 기능은 파라미터가 증가하게 되면 메소드 이름이 매우 지저분해지기 때문에 이렇게 @Query에 직접 쿼리를 작성하기도 합니다.

---

@Query로 필드 값이나 DTO 조회

@Query로 엔티티 조회 뿐만 아니라 필드 값을 조회하거나 DTO로 조회하도록 설정 또한 가능합니다.

 

1. 필드 값 조회

@Query("select m.name from Member m")
List<String> findNameList();

2. DTO로 직접 조회

@Query("select new study.datajpa.dto.MemberDto(m.id, m.name, m.age, t.name) from Member m join m.team t")
List<MemberDto> findMembers();

+ MemberDto.java

@Data
public class MemberDto {
    private Long id;
    private String name;
    private int age;

    private String teamName;

    public MemberDto(Long id, String name, int age, String teamName) {
        this.id = id;
        this.name = name;
        this.age = age;
        this.teamName = teamName;
    }
}

---

@Query 파라미터 바인딩

기본적으로 위치기반보다 이름기반 파라미터 바인딩을 하는 것이 버그 잡기 쉽습니다.

위치기반 파라미터 바인딩 사용은 지양하도록 합시다.

 

위치 기반 파라미터 바인딩

@Query("select m from Member m where m.name = ?1 and m.age = ?2")
List<Member> findUsers(@Param("name") String name, @Param("age") int age);

이름 기반 파라미터 바인딩

@Query("select m from Member m where m.name =: name and m.age = :age")
List<Member> findUsers(@Param("name") String name, @Param("age") int age);

컬렉션 파라미터 바인딩에는 in 절 사용

@Query("select m from Member m where m.name in :names")
List<Member> findByNames(@Param("names") List<String> names);

---

반환 타입

Spring Data JPA는 유연한 리턴 타입을 지원합니다.

List<Member> findByName(String name); //컬렉션 
Member findByName(String name); // 단건
Optional<Member> findByName(); // 단건 Optional

• 단건 지정 메소드 호출 시 Query.getSingleResult() 호출 및 단건 엔티티 리턴.
• 컬렉션 지정 메소드 호출 시 Query.getResultList() 호출 및 엔티티 컬렉션 리턴  
• Spring Data JPA를 사용하지 않고 순수 JPQL + JPA를 사용했을 때, 만약 단건 지정 메소드 호출 시 결과가 없으면 NoResultException 예외가 발생하지만, Spring Data JPA를 사용하면 이 예외가 발생 시 예외를 무시하고 null을 리턴합니다. 

---

Spring Data JPA의 페이징, 정렬 기능

순수 JPA를 사용했을 때는 페이징은 메소드를 통해, 정렬은 JPQL을 통해 설정했었습니다.

 

순수 JPA를 사용한 Repostiory 계층에서 Paging 및 Sort 적용한 JPQL

public List<Member> findByPage(int age, int offset, int limit) {
    return em.createQuery("select m from Member m where m.age =: age order by m.name desc")
            .setParameter("age", age)
            .setFirstResult(offset)
            .setMaxResults(limit)
            .getResultList();
}

 

Spring Data JPA의 페이징과 정렬

• 정렬 기능만 사용하기 : Sort 사용
• 페이징 기능 : Pageable 사용 ( 내부에 Sort 포함 )
• 특별한 리턴 타입
  • Page : 검색된 전체 데이터 건수를 조회하는 count 쿼리를 추가로 호출지 하는 페이징 
  • Slice : 추가 count 쿼리 결과없이 다음 페이지만 확인 가능 ( 내부적으로 limit + 1 조회 )
  • List : 추가 count 쿼리 없이 결과만 리턴

Page<Member> findByName(String name, Pageable pageable); // 추가 count 쿼리 호출
Slice<Member> findByName(String name, Pageable pageable); // 추가 count 쿼리 호출 x
List<Member> findByUsername(String name, Pageable pageable); //count 쿼리 사용 안함
List<Member> findByUsername(String name, Sort sort); // 정렬 기능만 사용

 

ex) 나이가 10살인 멤버만, 이름으로 내림차순해서, 페이지당 3건 조회

Page<Member> findByAge(int age, Pageable pageable); // 추가 count 쿼리 호출

PageRequest pageRequest = PageRequest.of(0, 3, Sort.by(Sort.Direction.DESC, "name"));
Page<Member> page = memberRepository.findByAge(10, pageRequest);

• PageRequest 에 페이징 사이즈 설정 및 정렬 방식을 설정할 수 있습니다.
• 설정한 PageRequest를 Pageable 에 토스

페이징 관련 메소드

int getNumber(); // 현재 페이지
int getSize(); // 페이지 크기 
int getNumberOfElements(); //
List<T> getContent(); // 조회된 데이터 
boolean hasContent(); // 조회된 데이터 존재 여부 
Sort getSort(); // 정렬 정보 
boolean isFirst(); // 현재 페이지가 첫 페이지인지 여부 
boolean isLast(); // 현재 페이지가 마지막 페이지인지 여부 
boolean hasNext(); // // 다음 페이지 여부 
boolean hasPrevious(); // 이전 페이지 여부
Pageable getPageable(); // 페이지 요청 정보
Pageable nextPageable(); // 다음 페이지 객체 
Pageable previousPageable(); //이전 페이지 객체
<U> Slice<U> map(Function<? super T, ? extends U> converter); // 변환기

 

Page를 사용할 때 count 쿼리를 따로 분리할 수 있습니다.

@Query(value = “select m from Member m”,
         countQuery = “select count(m.username) from Member m”)
Page<Member> findMemberAllCountBy(Pageable pageable);

• 전체 count 하는 쿼리는 매우 무겁기 떄문에 Page 사용 시 카운트 쿼리는 위처럼 따로 분리해서 사용하는 것이 좋습니다.

TopN, FirstN  

User findFirstByOrderByLastnameAsc();

User findTopByOrderByAgeDesc();

Page<User> queryFirst10ByLastname(String lastname, Pageable pageable);

Slice<User> findTop3ByLastname(String lastname, Pageable pageable);

List<User> findFirst10ByLastname(String lastname, Sort sort);

List<User> findTop10ByLastname(String lastname, Pageable pageable);

• 쿼리 메소드 이름으로 TopN, FirstN을 사용해 정렬 결과에서 N개를 뽑아서 페이징하도록 설정할 수도 있습니다.

페이징 결과 DTO로 반환하기

Page<Member> page = memberRepository.findByAge(10, pageRequest);
Page<MemberDto> dtoPage = page.map(m -> new MemberDto());

• 페이징 결과에 map으로 Dto 생성 및 컬렉션으로 리턴

---

벌크성 수정 쿼리

벌크성 수정 쿼리는 한 번의 작업으로 여러 개의 레코드를 수정하는 쿼리를 말합니다.

 

순수 JPA를 사용한 벌크성 수정 쿼리

public int bulkAgePlus(int age) {
    return em.createQuery("update Member m set m.age = m.age + 1 where m.age >= :age")
            .setParameter("age", age)
            .executeUpdate();
}

 

Spring Data JPA를 사용한 벌크성 수정 쿼리

@Modifying
@Query("update Member m set m.age = m.age + 1 where m.age >= :age")
int bulkAgeUp(@Param("age") int age);

• Spring Data JPA를 사용하면 @Modifying 어노테이션을 사용해 벌크성 수정, 삭제를 할 수 있습니다.
  • Spring Data JPA에서 벌크성 쿼리에 @Modifying 어노테이션을 사용하지 않으면 예외가 발생.
• 벌크성 쿼리를 실행 후 영속성 컨텍스트 초기화 옵션 : @Modifying(clearAutomatically = true)
  

  • 이 옵션 없이 회원을 findById로 다시 조회하면 영속성 컨텍스트에 과거 값이 남아서 문제가 될 수 있다. 만약 다시 조회해야 하면 꼭 영속성 컨텍스트를 초기화 하자.

벌크 연산은 영속성 컨텍스트를 무시하고 실행하기 떄문에,
영속성 컨텍스트에 있는 엔티티의 상태와 DB의 엔티티 상태가 달라질 수 있음.

권장하는 방법
- 영속성 컨텍스트에 엔티티가 없는 상태에서 벌크 연산을 실행하도록 합시다.
- 부득이하게 영속성 컨텍스트에 엔티티가 있으면 벌크 연산 직후 영속성 컨텍스트를 초기화 합시다.

---

@EntityGraph를 이용한 연관 엔티티 조회

JPA에서는 JPQL에 페치조인으로 사용함으로써 N+1 문제를 해결할 수 있었습니다.

Spring Data JPA에서는 @EntityGraph를 사용해서 간편하게 JPQL의 페치조인을 사용할 수 있습니다.

 

Spring Data JPA는 JPA가 제공하는 엔티티 그래프 기능을 편리하게 사용하도록 도와줍니다.

public interface MemberRepository extends JpaRepository<Member, Long> {

    @Override
    @EntityGraph(attributePaths = {"team"})
    List<Member> findAll();

    //JPQL + 엔티티 그래프 
     @EntityGraph(attributePaths = {"team"})
     @Query("select m from Member m")
     List<Member> findMemberEntityGraph();

 

+ @NamedEntityGraph

• @EntityGraph에 이름을 붙여 정의할 수 있습니다. 
• attributeNodes 에는 함께 호출할 연관된 엔티티 작성.

@NamedEntityGraph(name = "Member.all", attributeNodes = @NamedAttributeNode("team"))
@Entity
public class Member {
	private Team team;
	...
}

@NamedEntityGraph 적용

@EntityGraph("Member.all")
@Query("select m from Member m")
List<Member> findMemberEntityGraph();

---

JPA Hing & Lock

Jpa Hint 적용

@QueryHints 어노테이션을 사용합니다. 

@QueryHints(value = @QueryHint(name = "org.hibernate.readOnly", value = "true"))
Member findReadOnlyByUsername(String username);

Member member = memberRepository.findReadOnlyByUsername("member1");
member.setUsername("member2");

em.flush(); //Update Query 실행X readOnly = true 설정

• @QueryHint에 readOnly 옵션이 true로 설정되어 있기 때문에 flush() 하더라도 update query가 실행되지 않습니다.

Jpa Lock

@Lock은 일부 데이터베이스 시스템에서 제공되는 기능으로, 데이터의 동시 액세스를 제어하기 위해 사용됩니다.

이 기능은 특정 데이터나 데이터베이스 리소스에 대한 잠금(lock)을 설정하고 관리하는 데 사용됩니다.

여러 개의 트랜잭션이 동시에 동일한 데이터를 수정하는 경우, 데이터 일관성을 유지하고 충돌을 방지하기 위해 잠금이 필요합니다.

 

주 사용 목적
1. 동시성 제어: 여러 개의 트랜잭션이 동시에 동일한 데이터를 수정하려는 경우 충돌이 발생할 수 있습니다.

2. 교착상태 방지: 교착상태(deadlock)는 두 개 이상의 트랜잭션이 서로가 가진 리소스를 기다리며 무한히 대기하는 상황을 말합니다. @Lock을 사용하여 트랜잭션이 필요한 리소스에 대한 잠금을 설정하면, 교착상태가 발생할 가능성을 줄일 수 있습니다.

3. 최적화 및 성능 개선: @Lock은 데이터 액세스를 통제하므로, 동시 액세스로 인한 성능 저하를 방지하고 최적화된 실행 계획을 수립할 수 있습니다. 특히 데이터의 일관성이나 무결성이 중요한 경우, 잠금을 사용하여 정확성을 보장할 수 있습니다.

쿼리 시 락을 걸려면 @Lock 어노테이션을 사용할 수 있습니다.

@Lock(LockModeType.PESSIMISTIC_WRITE)
  List<Member> findByUsername(String name);

---

<참고자료>

• 자바 ORM 표준 JPA 프로그래밍, 김영한