devkuma – JPA

Preparing to Use JPA

kc@example.com (kc kim) — Wed, 13 May 2020 11:53:59 +0900

JPA is a foundational database-access technology. This page explains JPA and prepares a project for using it.

What Is JPA?

JPA (Java Persistence API) is a framework for accessing relational databases. JDBC has long been the common database-access approach in Java SE.

More precisely, JPA provides data persistence: data remains after the program exits. With JPA, application code stores and retrieves Java objects without manually writing SQL for each operation or extracting and converting every field.

Internally, JPA accesses the database. From the application’s perspective, it stores and retrieves Java objects. ORM (Object-relational Mapping) maps Java objects to relational database records. JPA offers similar object-oriented persistence behavior.

JPA also provides JPQL, an SQL-like query language. A consistent query style works across databases, so changing databases usually requires configuration changes rather than rewriting application code.

Creating a JPA Project

Create a web application project with Apache Maven.

$ mvn archetype:generate -DarchetypeArtifactId=maven-archetype-webapp

Enter:

groupId: com.devkuma.jpa
artifactId: JavaApp
version: 1.0-SNAPSHOT
package: com.devkuma.jpa

Folder Structure

.
├── pom.xml
└── src
    └── main
        ├── resources
        └── webapp
            ├── WEB-INF
            │   └── web.xml
            └── index.jsp

The webapp folder contains publicly served web application files. The resources folder contains configuration files required by JPA.

Writing pom.xml

pom.xml defines Maven build settings and required libraries.

Web Application Libraries

Use Jetty as the servlet container.

<dependency>
    <groupId>org.eclipse.jetty</groupId>
    <artifactId>jetty-server</artifactId>
    <version>${jetty.version}</version>
</dependency>
<dependency>
    <groupId>org.eclipse.jetty</groupId>
    <artifactId>jetty-webapp</artifactId>
    <version>${jetty.version}</version>
</dependency>

Web Application Plugin

Add the Jetty Maven plugin to run the web application.

<plugin>
    <groupId>org.eclipse.jetty</groupId>
    <artifactId>jetty-maven-plugin</artifactId>
    <version>${jetty.version}</version>
</plugin>

Complete pom.xml

The complete project uses Jetty, H2, Eclipse Persistence JPA, and the Jetty Maven plugin.

<project xmlns="http://maven.apache.org/POM/4.0.0">
    <modelVersion>4.0.0</modelVersion>
    <groupId>com.devkuma.jpa</groupId>
    <artifactId>JavaApp</artifactId>
    <packaging>war</packaging>
    <version>1.0-SNAPSHOT</version>

    <properties>
        <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
        <jetty.version>9.4.7.v20170914</jetty.version>
    </properties>

    <dependencies>
        <dependency>
            <groupId>org.eclipse.jetty</groupId>
            <artifactId>jetty-server</artifactId>
            <version>${jetty.version}</version>
        </dependency>
        <dependency>
            <groupId>org.eclipse.jetty</groupId>
            <artifactId>jetty-webapp</artifactId>
            <version>${jetty.version}</version>
        </dependency>
        <dependency>
            <groupId>com.h2database</groupId>
            <artifactId>h2</artifactId>
            <version>1.4.196</version>
        </dependency>
        <dependency>
            <groupId>org.eclipse.persistence</groupId>
            <artifactId>javax.persistence</artifactId>
            <version>2.2.0</version>
        </dependency>
        <dependency>
            <groupId>org.eclipse.persistence</groupId>
            <artifactId>org.eclipse.persistence.jpa</artifactId>
            <version>2.7.0</version>
        </dependency>
    </dependencies>

    <build>
        <finalName>JavaApp</finalName>
        <plugins>
            <plugin>
                <groupId>org.eclipse.jetty</groupId>
                <artifactId>jetty-maven-plugin</artifactId>
                <version>${jetty.version}</version>
            </plugin>
        </plugins>
    </build>
</project>

JPA 쿼리 메서드(Query Method)

kc@example.com (kc kim) — Wed, 13 May 2020 11:53:59 +0900

Spring Data JPA는 Repository 인터페이스에 선언된 메소드를 그 이름에서 쿼리를 생성하고 자동으로 생성 해주는 것이 편리한 기능이 있다. 어떤 명명 규칙이 있는지에 대해서 알아보자.

구문

다음의 3가지 요소를 규칙에 따라 결합된 메소드 이름을 Repository 인터페이스에 선언하면 자동 구현이 가능하다.

접두사 (find ... By, read ... By, query ... By, count ... By, get ... By)
키워드
필드 이름

다음과 같은 엔티티를 예로 사용한다.

Employee.java

@Entity
public class Employee implements Serializable {

    private static final long serialVersionUID = 3453583737318640866L;
    @Id
    @GeneratedValue(strategy=GenerationType.IDENTITY)
    private Long id;
    private String firstname;
    private String lastname;
    private int age;
    @Temporal(TemporalType.DATE)
    private Date hiredAt;
    private Boolean active;
    @ManyToOne
    @JoinTable(
            name="department_employee",
            joinColumns=@JoinColumn(name="employee_id"),
            inverseJoinColumns=@JoinColumn(name="department_code")
        )
    private Department department;

    // 이하 Getter/Setter...

Department.java

@Entity
public class Department implements Serializable {

    private static final long serialVersionUID = -6771704436232452390L;
    @Id
    private String code;
    private String name;
    private boolean flg;
    @OneToMany(fetch=FetchType.LAZY, mappedBy="department")
    private transient List<Employee> employeeList;

    // 이하 Getter/Setter...

메소드 생성 키워드

Keyword	Sample	JPQL snippet
`Distinct`	`findDistinctByLastnameAndFirstname`	`select distinct ... where x.lastname = ?1 and x.firstname = ?2`
`And`	`findByLastnameAndFirstname`	`... where x.lastname = ?1 and x.firstname = ?2`
`Or`	`findByLastnameOrFirstname`	`... where x.lastname = ?1 or x.firstname = ?2`
`Is、Equals`	`findByFirstname`, `findByFirstnameIs`, `findByFirstnameEquals`	`... where x.firstname = ?1`
`Between`	`findByStartDateBetween`	`... where x.startDate between ?1 and ?2`
`LessThan`	`findByAgeLessThan`	`... where x.age < ?1`
`LessThanEqual`	`findByAgeLessThanEqual`	`... where x.age <= ?1`
`GreaterThan`	`findByAgeGreaterThan`	`... where x.age > ?1`
`GreaterThanEqual`	`findByAgeGreaterThanEqual`	`... where x.age >= ?1`
`After`	`findByStartDateAfter`	`... where x.startDate > ?1`
`Before`	`findByStartDateBefore`	`... where x.startDate < ?1`
`IsNull、Null`	`findByAge(Is)Null`	`... where x.age is null`
`IsNotNull、NotNull`	`findByAge(Is)NotNull`	`... where x.age not null`
`Like`	`findByFirstnameLike`	`... where x.firstname like ?1`
`NotLike`	`findByFirstnameNotLike`	`... where x.firstname not like ?1`
`StartingWith`	`findByFirstnameStartingWith`	`... where x.firstname like ?1` ( `%`가 뒤에 추가된 매개 변수)
`EndingWith`	`findByFirstnameEndingWith`	`... where x.firstname like ?1` ( `%`가 앞에 추가된 매개 변수)
`Containing`	`findByFirstnameContaining`	`... where x.firstname like ?1` ( `%`가 래핑된 매개 변수)
`OrderBy`	`findByAgeOrderByLastnameDesc`	`... where x.age = ?1 order by x.lastname desc`
`Not`	`findByLastnameNot`	`... where x.lastname <> ?1`
`In`	`findByAgeIn(Collection<Age> ages)`	`... where x.age in ?1`
`NotIn`	`findByAgeNotIn(Collection<Age> ages`	`... where x.age not in ?1`
`True`	`findByActiveTrue()`	`... where x.active = true`
`False`	`findByActiveFalse()`	`... where x.active = false`
`IgnoreCase`	`findByFirstnameIgnoreCase`	`... where UPPER(x.firstname) = UPPER(?1)`

예제

Is / Equals / Not

// SELECT e FROM Employee e
Employee findById(Long id);

// SELECT e FROM Employee e WHERE e.firstname = ?1 
List<Employee> findByFirstnameEquals(String firstname);

// SELECT e FROM Employee e WHERE e.age = ?1
List<Employee> findByAgeIs(int age);

// SELECT e FROM Employee e WHERE e.lastname != ?1
List<Employee> findByLastnameNot(String lastname);

// SELECT e FROM Employee e WHERE e.department = ?1
List<Employee> findByDepartment(Department department);

필드의 뒤에 Equals / Is를 붙이면 일치, Not를 넣으면 불일치 레코드를 검색한다. 대소문자를 구분되는지는 데이터베이스의 데이터 설정 등에 따라 달라진다.

LessThan / GreaterThan

등호 조건을 사용하려고 할 때, 사용하는 키워드는 LessThan, GreaterThan이다.

// SELECT e FROM Employee e WHERE e.age < ?1
List<Employee> findByAgeLessThan(int age);

// SELECT e FROM Employee e WHERE e.age > ?1
List<Employee> findByAgeGreaterThan(int age);

// SELECT e FROM Employee e WHERE e.hired_at > ?1
List<Employee> findByHiredAtGreaterThan(Date date);

경계 값을 포함하면 위의 키워드 Equal을 더하여 GreaterThanEqual, LessThanEqual으로 하면 된다. 또한, Between 키워드으로도 경계 값을 포함한 범위 검색이 가능하다.

// SELECT e FROM Employee WHERE e.age <= ?1
List<Employee> findByAgeLessThanEqual(int age);

// SELECT e FROM Employee WHERE e.age >= ?1
List<Employee> findByAgeGreaterThanEqual(int age);

// SELECT e FROM Employee WHERE e.hired_at BETWEEN ?1 AND ?2
List<Employee> findByHiredAtBetween(Date since, Date until);

추가로, findByFirstnameLessThan(String name)과 같이 String 형식의 필드에 LessThan, GreaterThan를 붙일 수도 있다. 다만, DBMS 종속되긴 하지만…

Like / NotLike / StartingWith / EndingWith / Containing

와일드 카드를 사용한 부분 일치 검색은Like, NotLike, StartingWith, EndingWith, Containing을 사용한다.

// SELECT e FROM Employee WHERE e.firstname LIKE ?1
List<Employee> findByFirstnameLike(int age);

// SELECT e FROM Employee WHERE e.firstname NOT LIKE ?1
List<Employee> findByFirstnameNotLike(String firstname);

// SELECT e FROM Employee WHERE e.lastname LIKE ?1 (앞에 일치)
List<Employee> findByLastnameStartingWith(String lastname);

// SELECT e FROM Employee WHERE e.lastname LIKE ?1 (뒤에 일치)
List<Employee> findByLastnameEndingWith(String lastname);

// SELECT e FROM Employee WHERE e.lastname LIKE ?1 (모두 일치)
List<Employee> findByLastnameContaining(String lastname);

이 중에 StartingWith, EndingWith, Containing 내용은 각각 순서대로 전방 일치, 후방 일치, 부분 일치를 의미한다. 임의의 위치에 와일드 카드를 삽입 한 경우 Like, NotLike을 사용하다.

Between

// SELECT e FROM Employee e WHERE e.age BETWEEN ?1 AND ?2
List<Employee> findByAgeBetween(int olderThan, int youngerThan);

// SELECT e FROM Employee e WHERE e.hiredAt BETWEEN ?1 AND ?2
List<Employee> findByHiredAtBetween(Date since, Date until);

IsNull / (Is)NotNull

// SELECT e FROM Employee WHERE e.hiredAt IS NULL
List<Employee> findByHiredAtIsNull();

// SELECT e FROM Employee WHERE e.hiredAt IS NOT NULL
List<Employee> findByHiredAtIsNotNull();

// SELECT e FROM Employee WHERE e.hiredAt IS NOT NULL
List<Employee> findByHiredAtNotNull();

True / False

// SELECT e FROM Employee WHERE e.active = true
List<Employee> findByActiveTrue();

// SELECT e FROM Employee WHERE e.active = false
List<Employee> findByActiveFalse();

IN

여러개의 값으로 검색하는 경우에는 SQL과 마찬가지로 In을 사용한다.

// SELECT e FROM Employee WHERE e.lastname in ?1
List<Employee> findByLastnameIn(List<String> lastname);

After / Before

날짜 비교는 LessThan(Equal), GreaterThan(Equal)를 사용할 수 있지만, After, Before에서도 표현할 수 있다.

// SELECT e FROM Employee WHERE e.lastname > ?1
List<Employee> findByHiredAtAfter(Date date);

// SELECT e FROM Employee WHERE e.lastname < ?1
List<Employee> findByHiredAtBefore(Date date);

OrderBy

조회 결과를 정렬하려면 OrderBy를 사용한다. 필드 이름은 OrderBy 뒤에 작성한다. 오름차순, 내림차순는 필드 이름 뒤에 작성한다. 그러면 OrderBy + 필드이름 + Asc(Desc)와 같은 형태가 된다.

// SELECT e FROM Employee e WHERE e.lastname = ?1 ORDER BY e.age
List<Employee> findByLastnameOrderByAge(String lastname);

// SELECT e FROM Employee e WHERE e.firstname = ?1 ORDER BY e.firstname ASC
List<Employee> findByFirstnameOrderByHiredAtAsc(String firstname);

여러 필드로 정렬하려면, Asc, Desc을 지정하여 아래와 같이 연결하면 된다.

// SELECT e FROM Employee e WHERE e.lastname = ?1 ORDER BY e.age ASC, e.firstname DESC
List<Employee> findByLastnameOrderByAgeAscFirstnameDesc(String lastname);

Top / First

find 이후에 First 또는 Top을 붙이는 것으로 조회 건수를 줄일 수 있다.

Employee findFirstByLastname(String lastname);

Employee findTopByLastname(String lastname);

List<Employee> findFirst3ByActiveTrueOrderByAgeDesc();

List<Employee> findTop5ByHiredAtIs(Date date);

키워드를 결합

And, Or으로 조건의 조합 수 있다.

// SELECT e FROM Employee e WHERE e.age = ?1, e.active = true
List<Employee> findByAgeIsAndActiveTrue(int age);

// SELECT e FROM Employee e WHERE e.lastname LIKE ?1 OR e.lastname LIKE ?2
List<Employee> findByLastnameStartingWithOrFirstnameEndingWith(String lastname, String firstname);

// SELECT e FROM Employee e WHERE e.age BETWEEN ?1 AND ?2 AND e.department = ?3
List<Employee> findByAgeBetweenAndDepartmentIs(int startAge, int endAge, Department department);

참조

Spring Data JPA - Reference Documentation

JPA Auditing

kc@example.com (kc kim) — Wed, 13 May 2020 11:53:59 +0900

What Is JPA Auditing?

When mapping domains to RDBMS tables with JPA, many domains have common fields or columns, such as:

Create date
Update date
Identifier

Repeating these fields in every domain causes duplicated code. Creation and modification dates are also important data for maintenance because they provide a record of when data was written or changed.

JPA provides auditing support to populate this information automatically. Instead of setting timestamps every time an entity is stored or updated in the persistence context, auditing maps them to database columns automatically.

Create a Project

Create a Spring Boot project with data-jpa, lombok, and h2 dependencies:

curl https://start.spring.io/starter.tgz  \
-d bootVersion=2.5.0 \
-d dependencies=data-jpa,lombok,h2 \
-d baseDir=spring-jpa-auditing \
-d artifactId=jpa-auditing \
-d packageName=com.devkuma.jpa.auditing \
-d applicationName=Application \
-d packaging=jar \
-d javaVersion=1.8 \
-d type=gradle-project | tar -xzvf -

Alternatively, open the following URL in a browser:

https://start.spring.io/#!type=gradle-project&language=java&platformVersion=2.5.0.RELEASE&packaging=jar&javaVersion=11&groupId=com.devkuma&artifactId=spring-jpa-auditing&name=spring-jpa-auditing&description=Demo%20project%20for%20Spring%20Boot&packageName=com.devkuma.jpa.auditing&dependencies=data-jpa,lombok,h2

Implement the Source Code

BaseTimeEntity class
Create BaseTimeEntity in the domain package:

package com.devkuma.jpa.auditing.domain;

import lombok.Getter;
import org.springframework.data.annotation.CreatedDate;
import org.springframework.data.annotation.LastModifiedDate;
import org.springframework.data.jpa.domain.support.AuditingEntityListener;

import javax.persistence.EntityListeners;
import javax.persistence.MappedSuperclass;
import java.time.LocalDateTime;

@Getter
@MappedSuperclass
@EntityListeners(AuditingEntityListener.class)
public abstract class BaseTimeEntity {

    @CreatedDate
    private LocalDateTime createdDate;

    @LastModifiedDate
    private LocalDateTime modifiedDate;
}

BaseTimeEntity is a parent class for entities and automatically manages their createdDate and modifiedDate values.

@MappedSuperclass: Treats inherited fields as columns in JPA entities.
@EntityListeners(AuditingEntityListener.class): Enables auditing behavior for the class.
@CreatedDate: Stores the time automatically when an entity is created and saved.
@LastModifiedDate: Stores the time automatically when an entity is updated.

Post class
Extend BaseTimeEntity from an entity:

package com.devkuma.jpa.auditing.domain;

import lombok.Builder;
import lombok.Getter;
import lombok.NoArgsConstructor;

import javax.persistence.*;

@Getter
@NoArgsConstructor
@Entity
public class Post extends BaseTimeEntity {

    @Id
    @GeneratedValue(strategy = GenerationType.IDENTITY)
    private Long id;

    @Column(length = 500, nullable = false)
    private String title;

    @Column(columnDefinition = "TEXT", nullable = false)
    private String content;

    private String author;

    @Builder
    public Post(String title, String content, String author) {
        this.title = title;
        this.content = content;
        this.author = author;
    }

    public void update(String title, String content) {
        this.title = title;
        this.content = content;
    }
}

@Entity: Marks a class linked to a table.
@Id: Marks the primary key field.

PostRepository class
Create a JPA repository:

package com.devkuma.jpa.auditing.repository;

import com.devkuma.jpa.auditing.domain.Post;
import org.springframework.data.jpa.repository.JpaRepository;

public interface PostRepository extends JpaRepository<Post, String> {
}

Application class
Add @EnableJpaAuditing to the main class:

package com.devkuma.jpa.auditing;

import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.data.jpa.repository.config.EnableJpaAuditing;

@EnableJpaAuditing
@SpringBootApplication
public class Application {

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

@EnableJpaAuditing: Activates JPA auditing annotations.

Test

Create the following test under the test source folder:

package com.devkuma.jpa.auditing;

import com.devkuma.jpa.auditing.domain.Post;
import com.devkuma.jpa.auditing.repository.PostRepository;

import org.junit.jupiter.api.Test;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.test.context.SpringBootTest;

import java.time.LocalDateTime;
import java.util.List;

import static org.assertj.core.api.AssertionsForClassTypes.assertThat;

@SpringBootTest
public class PostRepositoryTest {

    @Autowired
    PostRepository postRepository;

    @Test
    public void 게시글저장() {
        // given
        LocalDateTime now = LocalDateTime.of(2020, 8, 12, 0, 0, 0);
        postRepository.save(Post.builder()
                .title("title")
                .content("content")
                .author("author")
                .build());

        // when
        List<Post> postsList = postRepository.findAll();

        //then
        Post posts = postsList.get(0);

        System.out.println(">>>>>>> createdDate=" + posts.getCreatedDate() + ", modifiedDate=" + posts.getModifiedDate());

        assertThat(posts.getCreatedDate()).isAfter(now);
        assertThat(posts.getModifiedDate()).isAfter(now);
    }
}

Result

... omitted ...

2021-06-01 09:51:33.635  INFO 71886 --- [    Test worker] c.d.jpa.auditing.PostRepositoryTest      : Started PostRepositoryTest in 7.572 seconds (JVM running for 8.631)
>>>>>>> createdDate=2021-06-01T09:51:33.762582, modifiedDate=2021-06-01T09:51:33.762582
2021-06-01 09:51:34.006  INFO 71886 --- [extShutdownHook] j.LocalContainerEntityManagerFactoryBean : Closing JPA EntityManagerFactory for persistence unit 'default'

... omitted ...

The output confirms that createdDate and modifiedDate contain the current time.

Complete Code

The complete project is available here.

JPA Pagination and Sorting

kc@example.com (kc kim) — Wed, 13 May 2020 11:53:59 +0900

Page

Methods of the org.springframework.data.domain.Page<T> interface

Method	Description
`int getNumber();`	Current page number, starting at 0
`int getSize();`	Page size
`int getTotalPages();`	Total number of pages
`int getNumberOfElements();`	Number of elements on the current page
`long getTotalElements();`	Total number of elements
`boolean hasPreviousPage();`	Whether a previous page exists
`boolean isFirstPage();`	Whether this is the first page
`boolean hasNextPage();`	Whether a next page exists
`boolean isLastPage();`	Whether this is the last page
`Pageable nextPageable();`	Next page object, or null if none exists
`Pageable previousPageable();`	Previous page object, or null if none exists
`List<T> getContent();`	Retrieved data
`boolean hasContent();`	Whether retrieved data exists
`Sort getSort();`	Sorting information

Pageable

Spring Data JPA provides the Pageable interface for convenient pagination.

PageableHandlerMethodArgumentResolverCustomizer

Pages start at 0 by default. To change default settings for page, size, and sort, customize org.springframework.data.web.config.PageableHandlerMethodArgumentResolverCustomizer.

Starting Pages at 1

Set setOneIndexedParameters to true.

@Bean
public PageableHandlerMethodArgumentResolverCustomizer customize() {
	return p -> p.setOneIndexedParameters(true);
}

The returned Page::number still starts at 0, so it differs from the requested page by 1.

Setting the Default Page Size

Use setMaxPageSize to configure the page size.

@Bean
public PageableHandlerMethodArgumentResolverCustomizer customize() {
	return p -> {
		p.setMaxPageSize(10);		// size=10
	};
}

YAML Configuration

You can also configure it in a YAML file.

spring:
  data:
    web:
      pageable:
        default-page-size: 10
        one-indexed-parameters: true

Reference

Spring Reference::HandlerMethodArgumentResolvers for Pageable and Sort

Configuring JPA QueryDSL

kc@example.com (kc kim) — Wed, 13 May 2020 11:53:59 +0900

Gradle Configuration for QueryDSL 5.0

buildscript {
    ext {
        // Add QueryDSL
        queryDslVersion = "5.0.0"
    }
}

plugins {
    id 'org.springframework.boot' version '2.7.5'
    id 'io.spring.dependency-management' version '1.0.11.RELEASE'
    // QueryDSL
    id "com.ewerk.gradle.plugins.querydsl" version "1.0.10"
    id 'java'
}

group = 'com.devkuma'
version = '0.0.1-SNAPSHOT'
sourceCompatibility = '11'

configurations {
    compileOnly {
        extendsFrom annotationProcessor
    }
}

repositories {
    mavenCentral()
}

dependencies {
    // QueryDSL
    implementation "com.querydsl:querydsl-jpa:${queryDslVersion}"
    implementation "com.querydsl:querydsl-apt:${queryDslVersion}"
}

tasks.named('test') {
    useJUnitPlatform()
}

// Start of QueryDSL configuration
def querydslDir = "$buildDir/generated/querydsl"

querydsl {
    jpa = true
    querydslSourcesDir = querydslDir
}
sourceSets {
    main.java.srcDir querydslDir
}
compileQuerydsl{
    options.annotationProcessorPath = configurations.querydsl
}

configurations {
    compileOnly {
        extendsFrom annotationProcessor
    }
    querydsl.extendsFrom compileClasspath
}

Reference

Sharing Gradle Configuration for QueryDSL 5.0 (When TREATED_PATH Occurs)

Spring Data JPA

kc@example.com (kc kim) — Wed, 13 May 2020 11:53:59 +0900

This section explains the Java Persistence API (JPA), a widely used technology for accessing databases from Java.