스프링 데이터 JPA 확장 기능

사용자 정의 리포지토리 구현

스프링 데이터 JPA 리포지토리는 인터페이스만 정의하고 구현체는 스프링이 자동 생성한다.
메서드를 직접 구현하고 싶다면 어떻게 해야될까?
인터페이스를 상속받아서 직접 구현하려면 구현해야 하는 기능이 너무 많다.
이때 다음과 같이 사용자 정의 리포지토리를 구현할 수 있다.

  1. 먼저 사용자 정의 인터페이스를 만든다. 
     public interface MemberRepositoryCustom {
   List<Member> findMemberCustom();
 }
  2. 사용자 정의 인터페이스를 상속받은 구현 클래스를 만든다. 
     @RequiredArgsConstructor
 public class MemberRepositoryImpl implements MemberRepositoryCustom {

   private final EntityManager em;

   @Override
   public List<Member> findMemberCustom() {
       return em.createQuery("select m from Member m")
               .getResultList();
   }
 }
  3. 사용자 정의 인터페이스를 기존에 사용하던 JPA 리포지토리 인터페이스에 상속한다. 
     public interface MemberRepository extends JpaRepository<Member, Long> , MemberRepositoryCustom {
     ...
 }
  4. 사용자 정의 메서드를 호출해서 사용한다. 
     memberRepository.findMemberCustom();

Auditing

엔티티를 생성, 변경할 때 변경한 사람과 시간을 추적하고 싶다면?

순수 JPA Auditing

@Getter
@MappedSuperclass
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();
    }
}

스프링 데이터 JPA 사용

@EntityListeners(AuditingEntityListener.class)
@Getter
@MappedSuperclass
public class BaseEntity {

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

    @LastModifiedDate
    private LocalDateTime lastModifiedDate;

    @CreatedBy
    @Column(updatable = false)
    private String createdBy;

    @LastModifiedBy
    private String lastModifiedBy;
}

@EnableJpaAuditing
@SpringBootApplication
public class DataJpaApplication

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

등록시간, 수정시간만 필요한 경우가 있을 수 도 있기 때문에 다음과 같이 Base 타입을 분리하고, 원하는 타입을 선택해서 상속한다.

public class BaseTimeEntity {
   @CreatedDate
   @Column(updatable = false)
   private LocalDateTime createdDate;
   @LastModifiedDate
   private LocalDateTime lastModifiedDate;
}

public class BaseEntity extends BaseTimeEntity {
   @CreatedBy
   @Column(updatable = false)
   private String createdBy;
   @LastModifiedBy
   private String lastModifiedBy;
}

Web 확장 - 도메인 클래스 컨버터

HTTP 파라미터로 넘어온 엔티티의 아이디로 엔티티 객체를 찾아서 바인딩 해주는 기능

도메인 클래스 컨버터 사용 전

@GetMapping("members/{id}")
public String findMember(@PathVariable("id") Long id) {
    Member member = memberRepository.findById(id).get();
    return member.getUsername();
}

도메인 클래스 컨버터 사용 후

@GetMapping("members/{id}")
public String findMember(@PathVariable("id") Member member) {
    return member.getUsername();
}

Web 확장 - 페이징과 정렬

스프링 데이터가 제공하는 페이징과 정렬 기능을 스프링 MVC에서 편리하게 사용할 수 있게 해주는 기능

@GetMapping("members")
public Page<Member> list(Pageable pageable) {
    return memberRepository.findAll(pageable);
}

페이징 & 정렬 기본값 변경

스프링 데이터 JPA 구현체 분석

스프링 데이터 JPA 공통 인터페이스를 상속한 인터페이스가 동작하는 이유는
애플리케이션 실행 시점에 스프링 데이터 JPA가 구현체를 직접 생성해주기 때문이다.
그렇다면 실제 구현체는 무엇이고 어떻게 구현되어 있을까?

SimpleJpaRepository

@Repository
@Transactional(readOnly = true)
public class SimpleJpaRepository<T, ID> ...{

     @Transactional
     public <S extends T> S save(S entity) {
         if (entityInformation.isNew(entity)) {
             em.persist(entity);
             return entity;
         } else {
             return em.merge(entity);
         }
     }
     ...
}

새로운 엔티티를 구별하는 방법

스프링 데이터 JPA 공통 인터페이스의 save(S) 메서드는 새로운 엔티티면 저장 아니면 병합을 수행한다.
그렇다면 새로운 엔티티를 판단하는 기준은 무엇일까?

새로운 엔티티를 판단하는 기본 전략

참고
JPA 식별자 생성 전략이 @GenerateValue면 save 호출 시점에 식별자가 없으므로 새로운 엔티티로 인식해서 정상 동작한다.
하지만 식별자를 직접 할당하면 이미 식별자 값이 있는 상태로 save를 호출하기 때문에 merge가 호출된다.(비효율적)
따라서 Persistable를 사용해서 새로운 엔티티 확인 여부를 직접 구현하는게 효과적이다.

Peresistable 구현

@Entity
@NoArgsConstructor(access = AccessLevel.PROTECTED)
@EntityListeners(AuditingEntityListener.class)
public class Item implements Persistable<String> {

     @Id
     private String id;
     
     @CreatedDate
     private LocalDateTime createdDate;
     
     public Item(String id) {
     this.id = id;
     }
     
     @Override
     public String getId() {
       return id;
     }
     
     @Override
     public boolean isNew() {
       return createdDate == null;
     }
}

그외

Projections

DTO 직접 조회를 좀 더 편하게 사용할 수 있게 해주는 기능

인터페이스 기반 Closed Projections

public interface UsernameOnly {
    String getUsername();
}

public interface MemberRepository ... {
    List<UsernameOnly> findProjectionsByUsername(String username);
}

select m.username from member m where m.username = ?

인터페이스 기반 Open Projections

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

클래스 기반 Projection

인터페이스가 아닌 구체적인 DTO 형식도 가능

public class UsernameOnlyDto {

    private final String username;
    
    public UsernameOnlyDto(String username) {
        this.username = username;
    }
    
    public String getUsername() {
        return username;
    }
}

동적 Projections

Generic type을 줘서 동적으로 프로젝션 데이터 변경 가능

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

중첩 구조 처리

public interface NestedClosedProjection {
    
    String getUsername();
    TeamInfo getTeam();
    
    interface TeamInfo {
        String getName();
    }
}

select
   m.username as col_0_0_,
   t.teamid as col_1_0_,
   t.teamid as teamid1_2_,
   t.name as name2_2_
from
   member m
left outer join
   team t
      on m.teamid=t.teamid
where
   m.username=?

네이티브 쿼리

가급적 사용하지 않는게 좋다.

스프링 데이터 JPA 기반 네이티브 쿼리

기본 사용 예제

public interface MemberRepository extends JpaRepository<Member, Long> {
   @Query(value = "select * from member where username = ?", nativeQuery = true)
   Member findByNativeQuery(String username);
}

네이티브 SQL DTO로 변환

여러 방법이 있지만 복잡하고 최근에 지원하기 시작한 Projections를 사용하는게 좋다.

public interface MemberProjection {
    Long getId();
    String getUsername();
    String getTeamName();
}

@Query(value = "SELECT m.member_id as id, m.username, t.name as teamName FROM member m left join team t",
       countQuery = "SELECT count(*) from member",
      nativeQuery = true)
Page<MemberProjection> findByNativeProjection(Pageable pageable);

네이티브 SQL을 DTO로 조회할 때는 JdbcTemplate or myBatis 권장