devkuma – JPA

JPAを使用する準備

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

JPAはデータベースアクセスの基礎となる技術です。ここではJPAを説明し、使用するプロジェクトを準備します。

JPAとは？

JPA（Java Persistence API）は、リレーショナルデータベースへアクセスするフレームワークです。Java SEでは長い間JDBCが一般的でした。

正確には、JPAはデータの永続化を提供します。つまり、プログラム終了後もデータが残ります。JPAを使用すると、操作ごとにSQLを記述したり、フィールドを個別に取り出して変換したりせず、Javaオブジェクトを保存して取得できます。

内部ではJPAがデータベースへアクセスします。アプリケーション側ではJavaオブジェクトを保存して取得します。ORM（Object-relational Mapping）はJavaオブジェクトとリレーショナルデータベースのレコードを対応付けます。JPAも同様にオブジェクト指向で永続化を扱えます。

JPAにはSQLに似たJPQLもあります。データベースが変わっても一貫した形式でクエリを記述できるため、通常はアプリケーションコードではなく設定を変更します。

JPAプロジェクトを作成する

Apache MavenでWebアプリケーションプロジェクトを作成します。

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

次の値を入力します。

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

フォルダー構成

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

webappフォルダーにはWebアプリケーションとして公開するファイルを配置します。resourcesフォルダーにはJPAで必要な設定ファイルを配置します。

pom.xmlを作成する

pom.xmlへMavenのビルド設定と必要なライブラリを記述します。

Webアプリケーション用ライブラリ

サーブレットコンテナとしてJettyを使用します。

<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アプリケーション用プラグイン

Webアプリケーションを実行するため、Jetty Maven pluginを追加します。

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

完成したpom.xml

完成したプロジェクトでは、Jetty、H2、Eclipse Persistence JPA、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

JPA Auditingとは？

JPAでドメインをRDBMSのテーブルにマッピングすると、多くのドメインに共通するフィールドやカラムがあります。

作成日時
更新日時
識別子

これらを各ドメインに定義すると重複コードが増えます。また、作成日時や更新日時は、データがいつ記録または変更されたかを残すため、保守において重要な情報です。

JPAにはこの情報を自動で設定するAuditing機能があります。永続性コンテキストへの保存や更新のたびに日時を設定する代わりに、Auditingを使用してデータベースのカラムへ自動的にマッピングできます。

プロジェクトの作成

data-jpa、lombok、h2依存関係を含むSpring Bootプロジェクトを作成します。

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 -

または、次のURLをブラウザーで開きます。

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

ソースコードの実装

BaseTimeEntityクラス
domainパッケージにBaseTimeEntityを作成します。

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はすべてのEntityの親クラスであり、createdDateとmodifiedDateを自動的に管理します。

@MappedSuperclass: 継承したフィールドをJPA Entityのカラムとして認識させます。
@EntityListeners(AuditingEntityListener.class): クラスにAuditing機能を提供します。
@CreatedDate: Entityの作成および保存時に日時を自動保存します。
@LastModifiedDate: Entityの更新時に日時を自動保存します。

Postクラス
EntityでBaseTimeEntityを継承します。

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: テーブルに対応するクラスを指定します。
@Id: 主キーフィールドを指定します。

PostRepositoryクラス
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クラス
mainクラスに@EnableJpaAuditingを追加します。

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: JPA Auditingアノテーションを有効化します。

テスト

testソースフォルダーに次のテストを作成します。

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);
    }
}

結果

... 省略 ...

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'

... 省略 ...

createdDateとmodifiedDateに現在時刻が設定されていることを確認できます。

完成コード

完成したプロジェクトはこちらで確認できます。

JPAのページネーションとソート

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

Page

org.springframework.data.domain.Page<T>インターフェースのメソッド

メソッド	説明
`int getNumber();`	現在のページ番号。0から開始
`int getSize();`	ページサイズ
`int getTotalPages();`	総ページ数
`int getNumberOfElements();`	現在のページに含まれる要素数
`long getTotalElements();`	総要素数
`boolean hasPreviousPage();`	前のページがあるか
`boolean isFirstPage();`	最初のページか
`boolean hasNextPage();`	次のページがあるか
`boolean isLastPage();`	最後のページか
`Pageable nextPageable();`	次のページ。なければnull
`Pageable previousPageable();`	前のページ。なければnull
`List<T> getContent();`	取得したデータ
`boolean hasContent();`	取得したデータがあるか
`Sort getSort();`	ソート情報

Pageable

Spring Data JPAは、簡単にページネーションを行うためのPageableインターフェースを提供します。

PageableHandlerMethodArgumentResolverCustomizer

デフォルトではページ番号は0から始まります。page、size、sortのデフォルト設定を変更するには、org.springframework.data.web.config.PageableHandlerMethodArgumentResolverCustomizerをカスタマイズします。

ページ番号を1から開始する

setOneIndexedParametersをtrueに設定します。

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

返されるPage::numberは0から始まるため、リクエストのページ番号とは1ずれます。

デフォルトのページサイズを設定する

setMaxPageSizeでページサイズを設定します。

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

YAMLで設定する

YAMLファイルでも設定できます。

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

参考資料

Spring Reference::HandlerMethodArgumentResolvers for Pageable and Sort

JPA QueryDSLの設定

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

QueryDSL 5.0のGradle設定

buildscript {
    ext {
        // 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()
}

// QueryDSL設定の開始
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
}

参考資料

QueryDSL 5.0のGradle設定を共有します（TREATED_PATH発生時）

Spring Data JPA

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

Javaからデータベースを利用するために広く使われているJava Persistence API（JPA）について説明します。