중급자를 위해 준비한
[웹 개발, 백엔드] 강의입니다.
스프링 데이터 JPA는 기존의 한계를 넘어 마치 마법처럼 리포지토리에 구현 클래스 없이 인터페이스만으로 개발을 완료할 수 있습니다. 그리고 반복 개발해온 기본 CRUD 기능도 모두 제공합니다. 스프링 데이터 JPA 실무 노하우를 전해드립니다.
✍️
이런 걸
배워요!
스프링 데이터 JPA를 기초부터 실무 활용까지 한번에 배울 수 있습니다.
실무에서 실제 사용하는 기능 위주로 학습합니다.
단순한 기능 설명을 넘어 실무 활용 노하우를 배울 수 있습니다.
JPA와 스프링 데이터 JPA의 차이를 명확하게 이해할 수 있습니다.
강좌 : https://www.inflearn.com/course/스프링-데이터-JPA-실전#
수업자료 :
https://github.com/braverokmc79/jpa-basic-lecture-file2
소스 : https://github.com/braverokmc79/data-jpa
[4] 쿼리 메소드 기능
10. 메소드 이름으로 쿼리 생성
강의 :
https://www.inflearn.com/course/lecture?courseSlug=스프링-데이터-JPA-실전&unitId=28009&tab=curriculum
쿼리 메소드 기능
1) 메소드 이름으로 쿼리 생성
2) NamedQuery
3) @Query - 리파지토리 메소드에 쿼리 정의
4) 파라미터 바인딩
5) 반환 타입
6) 페이징과 정렬
7) 벌크성 수정 쿼리
8) @EntityGraph
스프링 데이터 JPA가 제공하는 마법 같은 기능
쿼리 메소드 기능 3가지
메소드 이름으로 쿼리 생성
메소드 이름으로 JPA NamedQuery 호출
@Query 어노테이션을 사용해서 리파지토리 인터페이스에 쿼리 직접 정의
메소드 이름으로 쿼리 생성
메소드 이름을 분석해서 JPQL 쿼리 실행
이름과 나이를 기준으로 회원을 조회하려면?
1) 순수 JPA 리포지토리
public List <Member> findByUsernameAndAgeGreaterThan(String username, int age) { return em.createQuery("select m from Member m where m.username = :username and m.age >: age ") .setParameter("username", username) .setParameter("age", age) .getResultList(); }
순수 JPA 테스트 코드
@Test public void findByUsernameAndAgeGreaterThan() { Member m1 = new Member("AAA", 10); Member m2 = new Member("AAA", 20); memberJpaRepository.save(m1); memberJpaRepository.save(m2); List < Member > result = memberJpaRepository.findByUsernameAndAgeGreaterThan("AAA", 15); assertThat(result.get(0).getUsername()).isEqualTo("AAA"); assertThat(result.get(0).getAge()).isEqualTo(20); assertThat(result.size()).isEqualTo(1); }
2 ) 스프링 데이터 JPA
public interface MemberRepository extends JpaRepository < Member, Long > { List <Member> findByUsernameAndAgeGreaterThan(String username, int age); }
스프링 데이터 JPA는 메소드 이름을 분석해서 JPQL을 생성하고 실행
1) https://docs.spring.io/spring-data/jpa/docs/current/reference/html/#jpa.query-methods.query-creation
3) https://docs.spring.io/spring-data/jpa/docs/current/reference/html/#repositories.limit-query-result
11. JPA NamedQuery (실무에서 사용하지 않는다.)
강의 :
https://www.inflearn.com/course/lecture?courseSlug=스프링-데이터-JPA-실전&unitId=28010&tab=curriculum
JPA NamedQuery
JPA의 NamedQuery를 호출할 수 있음
* @NamedQuery 어노테이션으로 Named 쿼리 정의*
@Entity @NamedQuery( name = "Member.findByUsername", query = "select m from Member m where m.username = :username") public class Member { ... }
JPA를 직접 사용해서 Named 쿼리 호출
public class MemberRepository { public List <Member> findByUsername(String username) { ... List <Member> resultList = em.createNamedQuery("Member.findByUsername", Member.class) .setParameter("username", username) .getResultList(); } }
스프링 데이터 JPA로 NamedQuery 사용
@Query(name = "Member.findByUsername") List <Member> findByUsername(@Param("username") String username);
@Query 를 생략하고 메서드 이름만으로 Named 쿼리를 호출할 수 있다.
스프링 데이터 JPA로 Named 쿼리 호출
public interface MemberRepository extends JpaRepository < Member, Long > { //** 여기 선언한 Member 도메인 클래스 List <Member> findByUsername(@Param("username") String username); }
스프링 데이터 JPA는 선언한 "도메인 클래스 + .(점) + 메서드 이름"으로 Named 쿼리를 찾아서 실행
만약 실행할 Named 쿼리가 없으면 메서드 이름으로 쿼리 생성 전략을 사용한다.
필요하면 전략을 변경할 수 있지만 권장하지 않는다.
참고: 스프링 데이터 JPA를 사용하면 실무에서 Named Query를 직접 등록해서 사용하는 일은 드물다.
대신 @Query 를 사용해서 리파지토리 메소드에 쿼리를 직접 정의한다.
12. @Query, 리포지토리 메소드에 쿼리 정의하기 (실무 주로 사용)
강의 :
https://www.inflearn.com/course/lecture?courseSlug=스프링-데이터-JPA-실전&unitId=28012&tab=curriculum
메서드에 JPQL 쿼리 작성
public interface MemberRepository extends JpaRepository < Member, Long > { @Query("select m from Member m where m.username= :username and m.age = :age") List <Member> findUser(@Param("username") String username, @Param("age") int age); }
@org.springframework.data.jpa.repository.Query 어노테이션을 사용
실행할 메서드에 정적 쿼리를 직접 작성하므로 이름 없는 Named 쿼리라 할 수 있음
JPA Named 쿼리처럼 애플리케이션 실행 시점에 문법 오류를 발견할 수 있음(매우 큰 장점!)
> 참고: 실무에서는 메소드 이름으로 쿼리 생성 기능은 파라미터가 증가하면 메서드 이름이 매우 지저분해진다. 따라서 @Query 기능을 자주 사용하게 된다
테스트
@Test public void testQuery(){ Member m1=new Member("AAA", 10); Member m2 =new Member("BBB", 20); memberRepository.save(m1); memberRepository.save(m2); List<Member> result =memberRepository.findUser("AAA", 10); Assertions.assertThat(result.get(0)).isEqualTo(m1); }
13. @Query, 값, DTO 조회하기
강의 :
https://www.inflearn.com/course/lecture?courseSlug=스프링-데이터-JPA-실전&unitId=28013&tab=curriculum
단순히 값 하나를 조회
@Query("select m.username from Member m") List<String> findUsernameList();
JPA 값 타입( @Embedded )도 이 방식으로 조회할 수 있다.
@Query("select new study.datajpa.repository.MemberDto(m.id, m.username, t.name ) " + " from Member m join m.team t") List<MemberDto> findMemberDto();
주의! DTO로 직접 조회 하려면 JPA의 new 명령어를 사용해야 한다. 그리고 다음과 같이 생성자가 맞는 DTO가 필요하다. (JPA와 사용방식이 동일하다.)
package study.datajpa.repository; import lombok.Data; import lombok.ToString; @Data @ToString public class MemberDto { private Long id; private String username; private String teamName; public MemberDto(Long id, String username, String teamName) { this.id = id; this.username = username; this.teamName = teamName; } }
테스트
@Test public void findUsernameList(){ Member m1=new Member("AAA",10); Member m2=new Member("BBB",20); memberRepository.save(m1); memberRepository.save(m2); List<String> usernameList=memberRepository.findUsernameList(); for(String s :usernameList){ System.out.println("s = " + s); } } @Test public void findMemberDtoTest(){ Team team =new Team("teamA"); teamRepository.save(team); Member m1=new Member("AAA",10); Member m2=new Member("BBB",20); m1.setTeam(team); m2.setTeam(team); memberRepository.save(m1); memberRepository.save(m2); List<MemberDto> memberDtos=memberRepository.findMemberDto(); for(MemberDto dto : memberDtos){ System.out.println("회원 출력 = " + dto.toString()); } }
14. 파라미터 바인딩
강의 :
https://www.inflearn.com/course/lecture?courseSlug=스프링-데이터-JPA-실전&unitId=28014&tab=curriculum
파라미터 바인딩
위치 기반
이름 기반
select m from Member m where m.username = ?0 //위치 기반 select m from Member m where m.username = :name //이름 기반
파라미터 바인딩
import org.springframework.data.repository.query.Param public interface MemberRepository extends JpaRepository < Member, Long > { @Query("select m from Member m where m.username = :name") Member findMembers(@Param("name") String username); }
> 참고: 코드 가독성과 유지보수를 위해 이름 기반 파라미터 바인딩을 사용하자 (위치기반은 순서 실수가 바꾸면…)
컬렉션 파라미터 바인딩
Collection 타입으로 in절 지원
@Query("select m from Member m where m.username in :names") List <Member> findByNames(@Param("names") List < String > names);
테스트
@Test public void findByNames() { Member m1=new Member("AAA",10); Member m2=new Member("BBB",20); memberRepository.save(m1); memberRepository.save(m2); List<Member> result=memberRepository.findByNames(Arrays.asList("AAA", "BBB")); for(Member member :result){ System.out.println("member = " + member); } }
15. 반환타입
강의 :
https://www.inflearn.com/course/lecture?courseSlug=스프링-데이터-JPA-실전&unitId=28015&tab=curriculum
스프링 데이터 JPA는 유연한 반환 타입 지원
List<Member> findListByUsername(String name); //컬렉션 Member findMemberByUsername(String name); //단건 Optional<Member> findOptionalByUsername(String name); //단건 Optional
List<Member> 반환시 null 값이 반환처리 되지 않는다. size 0 인 객체 반환 처리
스프링 데이터 JPA 공식 문서: https://docs.spring.io/spring-data/jpa/docs/current/reference/html/#repository-query-return-types
조회 결과가 많거나 없으면?
컬렉션
결과 없음: 빈 컬렉션 반환
단건 조회
결과 없음: null 반환
결과가 2건 이상: javax.persistence.NonUniqueResultException 예외 발생
> 참고: 단건으로 지정한 메서드를 호출하면 스프링 데이터 JPA는 내부에서 JPQL의
Query.getSingleResult() 메서드를 호출한다. 이 메서드를 호출했을 때 조회 결과가 없으면
javax.persistence.NoResultException 예외가 발생하는데 개발자 입장에서 다루기가 상당히 불편하다.
스프링 데이터 JPA는 단건을 조회할 때 이 예외가 발생하면 예외를 무시하고 대신에 null 을 반환한다.
★16. 순수 JPA 페이징과 정렬
강의 :
https://www.inflearn.com/course/lecture?courseSlug=스프링-데이터-JPA-실전&unitId=28016&tab=curriculum
JPA에서 페이징을 어떻게 할 것인가?
다음 조건으로 페이징과 정렬을 사용하는 예제 코드를 보자.
검색 조건: 나이가 10살
정렬 조건: 이름으로 내림차순
페이징 조건: 첫 번째 페이지, 페이지당 보여줄 데이터는 3건
JPA 페이징 리포지토리 코드
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.username desc ") .setParameter("age", age) .setFirstResult(offset) .setMaxResults(limit) .getResultList(); } public long totalCount(int age) { return em.createQuery("select count(m) from Member m where m.age = :age", Long.class) .setParameter("age", age) .getSingleResult(); }
JPA 페이징 테스트 코드
@Test public void paging() throws Exception { //given memberJpaRepository.save(new Member("member1", 10)); memberJpaRepository.save(new Member("member2", 10)); memberJpaRepository.save(new Member("member3", 10)); memberJpaRepository.save(new Member("member4", 10)); memberJpaRepository.save(new Member("member5", 10)); int age = 10; int offset = 0; int limit = 3; //when List <Member> members = memberJpaRepository.findByPage(age, offset, limit); long totalCount = memberJpaRepository.totalCount(age); //페이지 계산 공식 적용... // totalPage = totalCount / size ... // 마지막 페이지 ... // 최초 페이지 .. //then assertThat(members.size()).isEqualTo(3); assertThat(totalCount).isEqualTo(5); }
★★★17. 스프링 데이터 JPA 페이징과 정렬 ★★★
강의 :
https://www.inflearn.com/course/lecture?courseSlug=스프링-데이터-JPA-실전&unitId=28017&tab=curriculum
페이징과 정렬 파라미터
org.springframework.data.domain.Sort : 정렬 기능
org.springframework.data.domain.Pageable : 페이징 기능 (내부에 Sort 포함)
특별한 반환 타입
org.springframework.data.domain.Page : 추가 count 쿼리 결과를 포함하는 페이징
org.springframework.data.domain.Slice : 추가 count 쿼리 없이 다음 페이지만 확인 가능 (내부적으로 limit + 1조회)
List (자바 컬렉션): 추가 count 쿼리 없이 결과만 반환
페이징과 정렬 사용 예제
Page<Member> findPageByUsername(String name, Pageable pageable); //count 쿼리 사용 Slice<Member> findSliceByUsername(String name, Pageable pageable); //count 쿼리 사용 안함 List<Member> findByUsername(String name, Pageable pageable); //count 쿼리 사용 안함 List<Member> findByUsername(String name, Sort sort);
다음 조건으로 페이징과 정렬을 사용하는 예제 코드를 보자.
검색 조건: 나이가 10살
정렬 조건: 이름으로 내림차순
페이징 조건: 첫 번째 페이지, 페이지당 보여줄 데이터는 3건
Page 사용 예제 정의 코드
public interface MemberRepository extends Repository < Member, Long > { Page <Member> findByAge(int age, Pageable pageable); }
Page 사용 예제 실행 코드
//페이징 조건과 정렬 조건 설정 @Test public void page() throws Exception{ //given memberRepository.save(new Member("member1", 10)); memberRepository.save(new Member("member2", 10)); memberRepository.save(new Member("member3", 10)); memberRepository.save(new Member("member4", 10)); memberRepository.save(new Member("member5", 10)); //when PageRequest pageRequest =PageRequest.of(0, 3, Sort.by(Sort.Direction.DESC, "username")); Page<Member> page=memberRepository.findByAge(10,pageRequest); //then List<Member> content = page.getContent(); //조회된 데이터 Assertions.assertThat(content.size()).isEqualTo(3); //조회된 데이터 수 Assertions.assertThat(page.getTotalPages()).isEqualTo(2); //전체 페이지 번호 Assertions.assertThat(page.getTotalElements()).isEqualTo(5); //전체 데이터 수 Assertions.assertThat(page.isFirst()).isTrue(); //첫번째 항목인가? Assertions.assertThat(page.hasNext()).isTrue(); //다음 페이지가 있는가? Assertions.assertThat(page.getNumber()).isEqualTo(0); //페이지 번호 }
두 번째 파라미터로 받은 Pageable 은 인터페이스다. 따라서 실제 사용할 때는 해당 인터페이스를 구현한
org.springframework.data.domain.PageRequest 객체를 사용한다.
PageRequest 생성자의 첫 번째 파라미터에는 현재 페이지를, 두 번째 파라미터에는 조회할 데이터 수를 입력한다.
여기에 추가로 정렬 정보도 파라미터로 사용할 수 있다. 참고로 페이지는 0부터 시작한다.
> 주의: Page는 1부터 시작이 아니라 0부터 시작이다.
Page 인터페이스
public interface Page < T > extends Slice < T > { int getTotalPages(); //전체 페이지 수 long getTotalElements(); //전체 데이터 수 <U> Page <U> map(Function < ? super T, ? extends U > converter); //변환기 }
Slice 인터페이스
public interface Slice < T > extends Streamable < T > { 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); //변환기 }
★★★참고: count 쿼리를 다음과 같이 분리할 수 있음
@Query(value = “select m from Member m”, countQuery = “select count(m.username) from Member m”) Page <Member> findMemberAllCountBy(Pageable pageable);
Top, First 사용 참고
https://docs.spring.io/spring-data/jpa/docs/current/reference/html/#repositories.limit-query-result
List findTop3By();
★페이지를 유지하면서 엔티티를 DTO로 변환하기 ★
Page <Member> page = memberRepository.findByAge(10, pageRequest); Page <MemberDto> dtoPage = page.map(m -> new MemberDto());
실습
Page
Slice (count X) 추가로 limit + 1을 조회한다. 그래서 다음 페이지 여부 확인(최근 모바일 리스트 생각해보면 됨)
List (count X)
카운트 쿼리 분리(이건 복잡한 sql에서 사용, 데이터는 left join, 카운트는 left join 안해도 됨)
★실무에서 매우 중요!!!
★> 참고: 전체 count 쿼리는 매우 무겁다.
18. 벌크성 수정 쿼리
강의 :
https://www.inflearn.com/course/lecture?courseSlug=스프링-데이터-JPA-실전&unitId=28018&tab=curriculum
1) JPA를 사용한 벌크성 수정 쿼리
public int bulkAgePlus(int age){ int resultCount=em.createQuery("update Member m set m.age = m.age +1 " + " where m.age >= :age") .setParameter("age" , age) .executeUpdate(); return resultCount; }
JPA를 사용한 벌크성 수정 쿼리 테스트
@Test public void bulkUpdate() throws Exception { //given memberJpaRepository.save(new Member("member1", 10)); memberJpaRepository.save(new Member("member2", 19)); memberJpaRepository.save(new Member("member3", 20)); memberJpaRepository.save(new Member("member4", 21)); memberJpaRepository.save(new Member("member5", 40)); //when int resultCount = memberJpaRepository.bulkAgePlus(20); //then assertThat(resultCount).isEqualTo(3); }
2)스프링 데이터 JPA를 사용한 벌크성 수정 쿼리
@Modifying(clearAutomatically = true) @Query("update Member m set m.age =m.age +1 where m.age >=:age ") int bulkAgePlus(@Param("age") int age);
스프링 데이터 JPA를 사용한 벌크성 수정 쿼리 테스트
@Test public void bulkUpdate() throws Exception{ //given memberRepository.save(new Member("member1", 10)); memberRepository.save(new Member("member2", 19)); memberRepository.save(new Member("member3", 20)); memberRepository.save(new Member("member4", 21)); memberRepository.save(new Member("member5", 40)); //when int resultCount=memberRepository.bulkAgePlus(20); //then Assertions.assertThat(resultCount).isEqualTo(3); }
벌크성 수정, 삭제 쿼리는 @Modifying 어노테이션을 사용 사용하지 않으면 다음 예외 발생
org.hibernate.hql.internal.QueryExecutionRequestException: Not supported for DML operation
벌크성 쿼리를 실행하고 나서 영속성 컨텍스트 초기화: @Modifying(clearAutomatically = true)
참고: 벌크 연산은 영속성 컨텍스트를 무시하고 실행하기 때문에, 영속성 컨텍스트에 있는 엔티티의 상태와 DB에 엔티티 상태가 달라질 수 있다.
** 권장하는 방안
1. 영속성 컨텍스트에 엔티티가 없는 상태에서 벌크 연산을 먼저 실행한다.
2. 부득이하게 영속성 컨텍스트에 엔티티가 있으면 벌크 연산 직후 영속성 컨텍스트를 초기화 한다
19. @EntityGraph
강의 :
https://www.inflearn.com/course/lecture?courseSlug=스프링-데이터-JPA-실전&unitId=28019&tab=curriculum
#spring.jpa.properties.hibernate.default_batch_fetch_size=100
batch_fetch 를 사용하면 지연로딩에서 entityGraph 인 페치 조인을 사용안하면 in 으로 데이터를 한번에 가져온다.
앞 강의 확인 할것.
연관된 엔티티들을 SQL 한번에 조회하는 방법
member team은 지연로딩 관계이다. 따라서 다음과 같이 team의 데이터를 조회할 때 마다 쿼리가
실행된다. (N+1 문제 발생)
@Test public void findMemberLazy() throws Exception { //given //member1 -> teamA //member2 -> teamB Team teamA = new Team("teamA"); Team teamB = new Team("teamB"); teamRepository.save(teamA); teamRepository.save(teamB); memberRepository.save(new Member("member1", 10, teamA)); memberRepository.save(new Member("member2", 20, teamB)); em.flush(); em.clear(); //when List<Member> members = memberRepository.findAll(); //then for (Member member : members) { System.out.println("시작============================================================"); member.getTeam().getName(); // 다음과 같이 지연 로딩 여부를 확인할 수 있다 //Hibernate 기능으로 확인 Hibernate.initialize(member.getTeam()); //JPA 표준 방법으로 확인 PersistenceUnitUtil util = em.getEntityManagerFactory().getPersistenceUnitUtil(); System.out.println( "isLoaded : " + util.isLoaded(member.getTeam()) ); System.out.println("끝============================================================"); } }
참고: 다음과 같이 지연 로딩 여부를 확인할 수 있다.
//Hibernate 기능으로 확인 Hibernate.isInitialized(member.getTeam()) //JPA 표준 방법으로 확인 PersistenceUnitUtil util = em.getEntityManagerFactory().getPersistenceUnitUtil(); util.isLoaded(member.getTeam());
연관된 엔티티를 한번에 조회하려면 페치 조인이 필요하다.
JPQL 페치 조인
@Query("select m from Member m left join fetch m.team") List <Member> findMemberFetchJoin();
스프링 데이터 JPA는 JPA가 제공하는 엔티티 그래프 기능을 편리하게 사용하게 도와준다. 이 기능을
사용하면 JPQL 없이 페치 조인을 사용할 수 있다. (JPQL + 엔티티 그래프도 가능)
//공통 메시더 오버라이드 @Override @EntityGraph(attributePaths = {"team"}) List<Member> findAll(); //JPQL + 엔티티 그래프 @EntityGraph(attributePaths = {"team"}) @Query("select m from Member m") List<Member> findMemberEntityGraph(); @EntityGraph(attributePaths = {"team"}) List<Member> findEntityGraphByUsername(String username); }
EntityGraph 정리 사실상 페치 조인(FETCH JOIN)의 간편 버전 LEFT OUTER JOIN 사용
NamedEntityGraph 사용 방법
@NamedEntityGraph(name = "Member.all", attributeNodes = @NamedAttributeNode("team")) @Entity public class Member {} @EntityGraph("Member.all") @Query("select m from Member m") List <Member> findMemberEntityGraph();
20. JPA Hint & Lock ( 참고 : 별로 사용하지 않는다. )
강의 :
https://www.inflearn.com/course/lecture?courseSlug=스프링-데이터-JPA-실전&unitId=28020&tab=curriculum
JPA 쿼리 힌트(SQL 힌트가 아니라 JPA 구현체에게 제공하는 힌트)
쿼리 힌트 사용
@QueryHints(value = @QueryHint(name = "org.hibernate.readOnly", value = "true")) Member findReadOnlyByUsername(String username);
읽기만 가능하다. 중간에 더티체킹으로 인한 업데이트 처리가 안된다.
쿼리 힌트 사용 확인
@QueryHints(value = { @QueryHint(name = "org.hibernate.readOnly", value = "true")}, forCounting = true) Page<Member> findByUsername(String name, Pageable pageable);
org.springframework.data.jpa.repository.QueryHints 어노테이션을 사용
forCounting : 반환 타입으로 Page 인터페이스를 적용하면 추가로 호출하는 페이징을 위한 count 쿼리도 쿼리 힌트 적용(기본값 true )
Lock (금융권에서 주로 사용)
SELECT ~ FOR UPDATE 란
SELECT ~ FOR UPDATE 는 선택된 행들에 대해 배타적으로 LOCK을 거는 것이다.
즉 "데이터 수정하려고 SELECT 했어. 건드리지마 !" 와 같은 뜻입니다.
위와 같은 경우 동시제어가 필연적으로 필요하다.
은행의 예금 및 통장의 잔액 변경 시 일관성을 유지하기위해, 영화 및 공연장의 특정 좌석을 예약하기 위해 사용한다.
SELECT FOR UPDATE를 사용하지 않으면 다른 세션에서 업데이트를 하고 있어도 같은 행을 조회가능하며, COMMIT을 하기 전까지는 결과가 반영되지 않는다
@Lock(LockModeType.PESSIMISTIC_WRITE) List<Member> findByUsername(String name);
org.springframework.data.jpa.repository.Lock 어노테이션을 사용
JPA가 제공하는 락은 JPA 책 16.1 트랜잭션과 락 절을 참고
댓글 ( 4)
댓글 남기기