JPA - Auditing / JPA 구현체 분석 / Projections / NativeQuery

[yepdi]

Auditing

JPA 제공하는 Auditing 기능

@MappedSuperclass
open class JpaBaseEntity(
    @Column(updatable = false)
    var createdDate: LocalDateTime? = null,
    var updatedDate: LocalDateTime? = null
) {

    @PrePersist
    fun prePersist() {
        val now = LocalDateTime.now()
        createdDate = now
        updatedDate = now
    }

    @PreUpdate
    fun preUpdate() {
        updatedDate = LocalDateTime.now()
    }
}

• MappedSuperclass annotation을 꼭 추가해줘야 한다
• PrePersist PreUpdate annotation을 통해 생성(persist), 추가 될 때 자동으로 업데이트 해준다
• dataBase 내에도 table에 생성되어 동일하게 저장된다

  create table member (
  member_id bigint not null,
  created_date timestamp,
  updated_date timestamp,
  age integer,
  username varchar(255),
  team_id bigint,
  primary key (member_id)
  )

SpringDataJpa 에서 제공하는 Auditing 기능

@MappedSuperclass
@EntityListeners(AuditingEntityListener::class)
open class BaseEntity(
    @CreatedBy
    @Column(updatable = false)
    private var createdBy: String? = null,
    @LastModifiedBy
    private var modifiedBy: String? = null
): BaseTimeEntity()

@MappedSuperclass
@EntityListeners(AuditingEntityListener::class)
open class BaseTimeEntity (
    @CreatedDate
    @Column(updatable = false) private var createdDate: LocalDateTime? = null,
    @LastModifiedDate
    private var updatedDate: LocalDateTime? = null,
)

@EnableJpaAuditing(auditorAwareRef = "auditorProvider")
@SpringBootApplication
class DataJpaApplication {
    @Bean
    fun auditorProvider(): AuditorAware<String> {
        return AuditorAware { Optional.of(UUID.randomUUID().toString()) }
    }
}

• MappedSuperclass와 EntityListeners 어노테이션을 반드시 추가해줘야 동작한다
• 또한 AuditorAware 도 구현해 줘야한다
  • createdBy와 lastModifiedBy에 값을 assign할 때 어떤 값을 기준으로 넣는지 판단
  • 보통 Session에서 값을 꺼내서 할당한다
  • 참조 링크 : https://itecnote.com/tecnote/spring-boot-spring-boot-data-jpa-createdby-and-updatedby-not-populating-with-authenticating-with-oidc/

[yepdi]

JPA 구현체 분석

• SimpleJpaRepository 내에 위치

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

• 여기서 Spring framework 가 제공하는 동일한 exception으로 반환
  • 하부 기술이 JPA, JDBC로 바뀌어도 같은 exception 반환으로 인한 처리 mechanism 동일
• JpaRepository는 기본적으로 transactional annotation이 기본적으로 걸려 있다 (readOnly = true)
• @Repository 적용 : JPA 예외를 스프링이 추상화한 예외로 변환
• @Transactional 트랜잭션 적용
  • JPA의 모든 변경은 트랜잭션 안에서 동작
  • 스프링 데이터 JPA는 변경(등록, 수정, 삭제) 메서드를 트랜잭션 처리
  • 서비스 계층에서 트랜잭션을 시작하지 않으면 리파지토리에서 트랜잭션 시작
  • 서비스 계층에서 트랜잭션을 시작하면 리파지토리는 해당 트랜잭션을 전파 받아서 사용
  • 스프링 데이터 JPA를 사용할 때 트랜잭션이 없어도 데이터 등록, 변경이 가능
• @Transactional(readOnly = true)
  • transaction이 끝날 때 flush를 생략하여 성능 향상을 얻을 수 있음 (DB 데이터 보내지 않음)

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

@Transactional
@Override
public <S extends T> S save(S entity) {

    Assert.notNull(entity, "Entity must not be null.");

    if (entityInformation.isNew(entity)) {
        em.persist(entity);
        return entity;
    } else {
        return em.merge(entity);
    }
}

• 식별자가 객체일 때 null, 0인 경우 isNew 함수에서 true 값을 반환한다
• JPA 식별자 생성 전략이 @GenerateValue 면 Save 호출시점에서 식별자가 없으므로 새로운 엔티티로 인식해서 정상 동작한다.
• JPA 식별자 생성 전략이 @Id 만 사용 해서 직접 할당할 경우에는 이미 식별자가 있는 값 상태로 save를 호출하여 merge 호출
  • merge 함수는 db에 직접 select를 통해서 데이터를 가져온 후 데이터를 덮어씌운 후에 저장하는 과정
• Persistable을 사용하여 새로운 엔티티 확인 여부를 직접 구현하는 것이 효과적임. 또한, @CreateDate 를 조합하여 사용한다면 새로운 엔티티 여부를 알 수 있음

@Entity
@EntityListeners(AuditingEntityListener::class)
class Item(
    @Id
    val identifier: String,
    @CreatedDate
    private var createdDate: LocalDateTime? = null
): Persistable<String> {

    override fun getId(): String? = identifier

    override fun isNew(): Boolean {
        return createdDate == null
    }
}

• isNew 함수에 createdDate == null조건을 추가하여 새롭게 추가되었는지 아닌지를 판단한다

개인적인 경험으로는 로그 메시지를 쌓을 때 Persistable 을 사용하여 구현한 경험이 있다. database 내 해당 데이터가 없을 것이라고 확실하게 사용하는 경우에 사용하면 좋을 듯

[yepdi]

kotlin 관련

• static kotlin 에서 static object나 method는 companion object를 통해 사용할 수 있다

• JvmStatic @JvmStatic 은 object 선언이나 companion object 를 Java 에서 static method 로 보이도록 한다.

• lambda https://kotlinlang.org/docs/annotations.html#lambdas

companion object {
        fun teamName(teamName: String): Specification<Member> {
            return Specification<Member> { root: Root<Member>, criteriaQuery: CriteriaQuery<*>, criteriaBuilder: CriteriaBuilder ->
                if (teamName.isEmpty()) return@Specification null
                val t = root.join<String, JoinType> ("team", JoinType.INNER)
                val name: Path<Set<String>> = t.get("name")
                return@Specification criteriaBuilder.equal(name, teamName )
            }
        }

        fun userName(username: String): Specification<Member> {
            return Specification<Member> { root: Root<Member>, criteriaQuery: CriteriaQuery<*>, criteriaBuilder: CriteriaBuilder ->
                val usernames: Path<Set<String>> = root.get("username")
                return@Specification criteriaBuilder.equal(usernames, username)
            }
        }
    }

[yepdi]

Projections

• 프로젝션 대상이 root 엔티티면 JPQL SELECT 절 최적화 가능
• 프로젝션 대상이 root가 아니면 LEFT OUTER JOIN 처리, 모든 필드를 SELECT해서 엔티티로 조회한 다음에 계산
• 프로젝션 대상이 root entity면 유용. root entity를 넘어가면 JPQL SELECT 최적화가 안된다

interface 형식

interface UserNameOnly {
    // username과 age를 둘다 가져와서 넣을 수 있다 entity에 있는 내용을 다 가져온다 (open projection)
    @Value("#{target.username + ' ' + target.age}")
    fun getUsername(): String
    // 실제 구현체는 spring data jpa에서 만들어서 반환한다
}

fun findProjectionsByUsername(@Param("username") username: String): List<UserNameOnly>

• projection은 interface 정의를 통해 원하는 column을 가져올 수 있다
  • @Value annotation을 통해 가져오는 데이터를 조합할 수 있음

class 형식

class UsernameOnlyDto {
    val username: String

    constructor(username: String) {
        this.username = username
    }
}

fun findProjectionsDtoByUsername(@Param("username") username: String): List<UsernameOnlyDto>

• UsernameOnlyDto class를 통해 가져오고 싶은 column 을 설정할 수 있음

Nested Interface 형태

interface NestedClosedProjections {
    // username만 가져오지만
    fun getUsername(): String
    // 전체 entity를 가져온다
    fun getTeam(): TeamInfo

    interface TeamInfo {
        fun getName(): String
    }
}

fun findProjectionsNestedByUsername(@Param("username") username: String): List<NestedClosedProjections>

• interface 안에 새로운 interface를 정의할 수 있다.
• 허나 interface TeamInfo의 경우에는 getName을 정의했으나 entity 전체에 정의된 데이터를 가져온다

[yepdi]

NativeQuery

• 가급적 네이티브 쿼리를 사용하지 않는 것이 좋다

• 최근에는 Projections 와 같이 사용

• 페이징 지원

• 반환타입

  • Object [], Tuple, DTO 형태

• 제약

  • Sort 파라미터를 통한 정렬이 정상 동작하지 않을 수 있음
  • JPQL처럼 애플리케이션 로딩 시점에 문법 확인 불가
  • 동적 쿼리 불가

• Native SQL을 DTO로 조회할 때는 JdbcTemplate or myBatis 권장

Native + Projections 조합

interface MemberProjection {
    fun getId(): Long
    fun getUsername(): String
    fun getTeamName(): String
}

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

• Page를 사용하기 위해 CountQuery를 추가해주었다.
• Projection을 사용하여 원하는 데이터만 추출할 수 있도록 하였다