QueryDSL 是一个用于构建类型安全查询的开源 Java ORM 框架。它提供了一种 Fluent 风格的 API 来构建和执行数据库查询，并提供了编译时类型检查，以避免常见的查询错误。QueryDSL 支持多种数据库，包括关系型数据库和 NoSQL 数据库，可以与多个持久化框架（如 JPA 、Hibernate 等）整合使用。它简化了查询的编写过程，使得查询代码更易于理解、维护和重用。

QueryDSL 在 Spring Boot 中通常配合 Spring Data JPA 使用，它会根据定义的 JPA Entity 类自动生成对应的查询类。通过查询类，除了可以快速地进行基本的 CRUD 操作外还支持 JOIN、GROUP、子查询等复杂的检索。而这一切都无需编写任何 SQL 语句，代码即 SQL。

本文将会带你了解如何在 Spring Boot 中整合 QueryDSL + Spring Data JPA，以及 QueryDSL 的常见用法。

示例项目 {#示例项目}

本文使用到的软件版本：

• Java：21
• Spring Boot：3.2.0
• MySQL：8.0.26

添加依赖 {#添加依赖}

创建 Spring Boot 应用，完整的 pom.xml 如下：

<?xml version="1.0" encoding="UTF-8"?>
<project xmlns="http://maven.apache.org/POM/4.0.0"
 xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
 xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 https://maven.apache.org/xsd/maven-4.0.0.xsd">
<modelVersion>4.0.0</modelVersion>
<parent>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-parent</artifactId>
<version>3.2.0</version>
<relativePath /> <!-- lookup parent from repository -->
</parent>
<groupId>springdoc</groupId>
<artifactId>springdoc-demo</artifactId>
<version>0.0.1-SNAPSHOT</version>
<name>springdoc-demo</name>
<description>Demo project for Spring Boot</description>
<properties>
<java.version>21</java.version>
</properties>
<repositories>
<repository>
<id>huaweicloud</id>
<url>https://mirrors.huaweicloud.com/repository/maven/</url>
<releases>
<enabled>true</enabled>
</releases>
<snapshots>
<enabled>true</enabled>
</snapshots>
</repository>
</repositories>
<dependencies>
<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-test</artifactId>
<scope>test</scope>
</dependency>
<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-web</artifactId>
</dependency>
<!-- MYSQL 驱动 -->
<dependency>
<groupId>com.mysql</groupId>
<artifactId>mysql-connector-j</artifactId>
</dependency>
<!-- JPA -->
<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-data-jpa</artifactId>
</dependency>
<!-- QueryDSL JPA  -->
<dependency>
<groupId>com.querydsl</groupId>
<artifactId>querydsl-jpa</artifactId>
<version>${querydsl.version}</version>
<classifier>jakarta</classifier>
</dependency>
<!-- QueryDSL APT  -->
<dependency>
<groupId>com.querydsl</groupId>
<artifactId>querydsl-apt</artifactId>
<version>${querydsl.version}</version>
<classifier>jakarta</classifier>
<scope>provided</scope>
</dependency>
</dependencies>
<build>
<plugins>
<plugin>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-maven-plugin</artifactId>
</plugin>
<plugin>
<groupId>com.mysema.maven</groupId>
<artifactId>apt-maven-plugin</artifactId>
<version>1.1.3</version>
<executions>
<execution>
<goals>
<goal>process</goal>
</goals>
<configuration>
<outputDirectory>target/generated-sources/java</outputDirectory>
<processor>com.querydsl.apt.jpa.JPAAnnotationProcessor</processor>
</configuration>
</execution>
</executions>
</plugin>
</plugins>
</build>
</project>

QueryDSL 的版本也受到 Spring Boot 的管理，因此在这里只需要将其版本号声明为 ${querydsl.version} 即可。

apt-maven-plugin Maven 插件的作用是根据 JPA Entity 生成查询类，其中 <outputDirectory> 节点指定了存放查询类的目录，而 <processor> 节点的配置则表示根据 JPA 注解生成查询类。

配置文件 {#配置文件}

在 application.yaml 中定义数据源和 JPA 等配置信息：

logging:
  level:
    "ROOT": INFO
    # 输出 SQL 绑定参数
    "org.hibernate.orm.jdbc.bind": TRACE
spring:
数据源
datasource:
type: com.zaxxer.hikari.HikariDataSource
driver-class-name: com.mysql.cj.jdbc.Driver
url: jdbc:mysql://127.0.0.1:3306/demo?useUnicode=true&characterEncoding=UTF-8&serverTimezone=GMT%2b8&allowMultiQueries=true
username: root
password: root
jpa:
# 输出 SQL
show-sql: true
properties:
# 格式化输出的 SQL
"hibernate.format_sql": true

如上，除了基本的数据源配置外。还配置了 org.hibernate.orm.jdbc.bind Logger 的日志级别为 TRACE，用于在日志中输出 SQL 绑定的参数。

Entity {#entity}

定义一个 User 类，表示用户：

package cn.springdoc.demo.entity;
import java.time.LocalDateTime;
import jakarta.persistence.Column;
import jakarta.persistence.Entity;
import jakarta.persistence.GeneratedValue;
import jakarta.persistence.GenerationType;
import jakarta.persistence.Id;
import jakarta.persistence.Table;
@Entity
@Table(name = "t_user")
public class User {
// ID
@Id
@Column
@GeneratedValue(strategy = GenerationType.IDENTITY)
private Integer id;
// 名称
@Column
private String name;
// 是否启用
@Column
private Boolean enabled;
// 创建时间
@Column
private LocalDateTime createAt;
// get、set、toString 方法省略
}

创建 Car 类，表示用户所拥有的汽车：

package cn.springdoc.demo.entity;
import jakarta.persistence.Column;
import jakarta.persistence.Entity;
import jakarta.persistence.GeneratedValue;
import jakarta.persistence.GenerationType;
import jakarta.persistence.Id;
import jakarta.persistence.Table;
@Entity
@Table(name = "t_car")
public class Car {
// ID
@Id
@Column
@GeneratedValue(strategy = GenerationType.IDENTITY)
private Integer id;
// 汽车名称
@Column
private String name;
// 用户 ID
@Column
private Integer userId;
// get、set、toString 方法省略
}

如上，使用 @Entity 注解表示该类是一个 JPA 实体类。该注解很重要，因为 QueryDSL 会根据此生成对应的查询类。

通过 @Table 注解指定表名称，通过 @Id 注解指定 ID 列，通过 @GeneratedValue 注解指定 ID 生成策略，这里使用的是 GenerationType.IDENTITY 即，使用数据库自增。通过 @Column 指定普通列。这都是很常见的 JPA 注解用法，这里不多解释。

一个 User 可以有多个 Car，这两个实体表示了一个一对多的关系。

对应的表结构如下：

-- User
CREATE TABLE `t_user` (
  `id` int unsigned NOT NULL AUTO_INCREMENT COMMENT 'ID',
  `create_at` timestamp NOT NULL DEFAULT CURRENT_TIMESTAMP COMMENT '创建时间',
  `enabled` tinyint unsigned NOT NULL COMMENT '是否启用。0：禁用，1：启用',
  `name` varchar(50) COLLATE utf8mb4_general_ci NOT NULL COMMENT '名字',
  PRIMARY KEY (`id`),
  UNIQUE KEY `name` (`name`)
) ENGINE=InnoDB DEFAULT CHARSET=utf8mb4 COLLATE=utf8mb4_general_ci COMMENT='用户';
-- Car
CREATE TABLE t_car (
id int unsigned NOT NULL AUTO_INCREMENT COMMENT 'ID',
name varchar(50) CHARACTER SET utf8mb4 COLLATE utf8mb4_general_ci NOT NULL COMMENT '汽车名称',
user_id int NOT NULL COMMENT '用户ID',
PRIMARY KEY (id)
) ENGINE=InnoDB DEFAULT CHARSET=utf8mb4 COLLATE=utf8mb4_general_ci COMMENT='汽车';

Repository {#repository}

定义实体对应的 Repository 接口。

UserRepository：

package cn.springdoc.demo.repository;
import org.springframework.data.jpa.repository.JpaRepository;
import org.springframework.data.jpa.repository.JpaSpecificationExecutor;
import org.springframework.data.querydsl.QuerydslPredicateExecutor;
import cn.springdoc.demo.entity.User;
public interface UserRepository extends JpaRepository<User, Integer>, JpaSpecificationExecutor <User>, QuerydslPredicateExecutor<User> {
}

CarRepository：

package cn.springdoc.demo.repository;
import org.springframework.data.jpa.repository.JpaRepository;
import org.springframework.data.jpa.repository.JpaSpecificationExecutor;
import org.springframework.data.querydsl.QuerydslPredicateExecutor;
import cn.springdoc.demo.entity.Car;
public interface CarRepository extends JpaRepository<Car, Integer>, JpaSpecificationExecutor <Car>, QuerydslPredicateExecutor<Car> {
}

除了基本的 JpaRepository 和 JpaSpecificationExecutor 接口外，Spring Data 还为 QueryDSL 提供了 QuerydslPredicateExecutor 接口，预定义了一些快捷的 CRUD 方法。

Application {#application}

最后，在 Application 类上添加 @EntityScan 和 @EnableJpaRepositories 注解，指定实体类和 Repository 接口所在的包。

package cn.springdoc.demo;
import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.boot.autoconfigure.domain.EntityScan;
import org.springframework.data.jpa.repository.config.EnableJpaRepositories;
@SpringBootApplication
@EntityScan("cn.springdoc.demo.entity")
@EnableJpaRepositories("cn.springdoc.demo.repository")
public class DemoApplication {
public static void main(String[] args) {
SpringApplication.run(DemoApplication.class, args);
}
}

至此，Spring Data JPA 和 QueryDSL 就整合完毕了。

你如果想了解整合 Spring Data JPA 的更多细节，你可以参考 这篇文章。

使用 QueryDSL {#使用-querydsl}

当你在项目中定义了实体类后，QueryDSL 其实已经偷偷为你生成了对应的查询类。

根据 pom.xml 中 apt-maven-plugin 插件的 <outputDirectory> 配置，查询类存放在 target/generated-sources/java 目录下。

本例中生成的查询类如下：

你可以看到，查询类以 Q 开头，名称对应实体类的名称。且包名和实体类所在包一样。最后打包的时候，这些查询类都会被打包到实体所在的包中。

在实际开发中，不建议修改自动生成的这些查询类。也不建议纳入版本控制，只要 Maven 配置正确，它们会自动生成。

自动生成的查询类，你不需要去研究太多。你只需要理解查询类中的每个字段，都对应了实体类以及数据表中的字段即可。

创建初始数据 {#创建初始数据}

QueyDSL 并未提供 INSERT 操作，我们需要依赖 Repository 的 save() 方法来保存实体。

插入测试数据：

package cn.springdoc.demo.test;
import java.time.LocalDateTime;
import org.junit.jupiter.api.Test;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.test.context.SpringBootTest;
import org.springframework.boot.test.context.SpringBootTest.WebEnvironment;
import org.springframework.test.annotation.Rollback;
import org.springframework.transaction.annotation.Transactional;
import cn.springdoc.demo.entity.Car;
import cn.springdoc.demo.entity.User;
import cn.springdoc.demo.repository.CarRepository;
import cn.springdoc.demo.repository.UserRepository;
@SpringBootTest(webEnvironment = WebEnvironment.RANDOM_PORT)
public class DemoApplicationTests {
static final Logger log = LoggerFactory.getLogger(DemoApplicationTests.class);
@Autowired
UserRepository userRepository;
@Autowired
CarRepository carRepository;
@Test
@Transactional
@Rollback(false)
public void test() throws Exception {
// 初始化 3 个用户
User u1 = new User(null, "刘备", Boolean.TRUE, LocalDateTime.now());
User u2 = new User(null, "张飞", Boolean.TRUE, LocalDateTime.now());
User u3 = new User(null, "关羽", Boolean.TRUE, LocalDateTime.now());
this.userRepository.save(u1);
this.userRepository.save(u2);
this.userRepository.save(u3);
// 给每个用户初始化 2 个 Car
this.carRepository.save(new Car(null, "宝马", u1.getId()));
this.carRepository.save(new Car(null, "奔驰", u1.getId()));
this.carRepository.save(new Car(null, "五菱", u2.getId()));
this.carRepository.save(new Car(null, "宝马", u2.getId()));
this.carRepository.save(new Car(null, "五菱", u3.getId()));
this.carRepository.save(new Car(null, "宝马", u3.getId()));
}
}

如上，创建了 3 个 User 对象，并给每个 User 创建了 2 个关联的 Car 对象。

执行测试。最终，数据表中的数据如下：

t_user：

| id | create_at | enabled | name | |----|---------------------|---------|------| | 1 | 2023-12-10 16:01:55 | 1 | 刘备 | | 2 | 2023-12-10 16:01:55 | 1 | 张飞 | | 3 | 2023-12-10 16:01:55 | 1 | 关羽 |

t_cat：

| id | name | user_id | |----|------|---------| | 1 | 宝马 | 1 | | 2 | 奔驰 | 1 | | 3 | 五菱 | 2 | | 4 | 宝马 | 2 | | 5 | 五菱 | 3 | | 6 | 宝马 | 4 |

基本的检索 {#基本的检索}

检索单条记录和检索记录列表：

 // 注入 EntityManager
 @PersistenceContext
 EntityManager entityManager;
@Test
@Transactional
@Rollback(false)
public void test() throws Exception {
// 通过 EntityManager 创建 JPAQueryFactory 实例
var query = new JPAQueryFactory(entityManager);
QUser USER = QUser.user;
// 根据 id 和 enabled 检索单条记录
User user = query.selectFrom(USER).where(USER.id.eq(1).and(USER.enabled.eq(true))).fetchOne();
log.info("user={}", user);
// 检索集合
List<User> users = query.selectFrom(USER).where(USER.enabled.eq(true)).fetch();
log.info("users={}", users);
}

输出日志如下：

Hibernate: 
    select
        u1_0.id,
        u1_0.create_at,
        u1_0.enabled,
        u1_0.name 
    from
        t_user u1_0 
    where
        u1_0.id=? 
        and u1_0.enabled=?
TRACE 7028 --- [           main] org.hibernate.orm.jdbc.bind              : binding parameter (1:INTEGER) <- [1]
TRACE 7028 --- [           main] org.hibernate.orm.jdbc.bind              : binding parameter (2:BOOLEAN) <- [true]
 INFO 7028 --- [           main] c.s.demo.test.DemoApplicationTests       : user=User [id=1, name=刘备, enabled=true, createAt=2023-12-10T16:01:55]
Hibernate: 
    select
        u1_0.id,
        u1_0.create_at,
        u1_0.enabled,
        u1_0.name 
    from
        t_user u1_0 
    where
        u1_0.enabled=?
TRACE 7028 --- [           main] org.hibernate.orm.jdbc.bind              : binding parameter (1:BOOLEAN) <- [true]
 INFO 7028 --- [           main] c.s.demo.test.DemoApplicationTests       : users=[User [id=1, name=刘备, enabled=true, createAt=2023-12-10T16:01:55], User [id=2, name=张飞, enabled=true, createAt=2023-12-10T16:01:55], User [id=3, name=关羽, enabled=true, createAt=2023-12-10T16:01:55]]

分页和排序 {#分页和排序}

 // 注入 EntityManager
 @PersistenceContext
 EntityManager entityManager;
@Test
@Transactional
@Rollback(false)
public void test() throws Exception {
// 通过 EntityManager 创建 JPAQueryFactory 实例
var query = new JPAQueryFactory(entityManager);
QUser USER = QUser.user;
// 总记录数量
Long count = query.select(USER.id.count()).from(USER).fetchOne();
log.info("count={}", count);
// 分页 & 排序
List<User> users = query.selectFrom(USER).offset(0).limit(2).orderBy(USER.createAt.desc(), USER.id.asc()).fetch();
log.info("users={}", users);
}

执行日志如下：

Hibernate: 
    select
        count(u1_0.id) 
    from
        t_user u1_0
 INFO 13836 --- [           main] c.s.demo.test.DemoApplicationTests       : count=3
Hibernate: 
    select
        u1_0.id,
        u1_0.create_at,
        u1_0.enabled,
        u1_0.name 
    from
        t_user u1_0 
    order by
        u1_0.create_at desc,
        u1_0.id 
    limit
        ?, ?
TRACE 13836 --- [           main] org.hibernate.orm.jdbc.bind              : binding parameter (1:INTEGER) <- [0]
TRACE 13836 --- [           main] org.hibernate.orm.jdbc.bind              : binding parameter (2:INTEGER) <- [2]
 INFO 13836 --- [           main] c.s.demo.test.DemoApplicationTests       : users=[User [id=1, name=刘备, enabled=true, createAt=2023-12-10T16:01:55], User [id=2, name=张飞, enabled=true, createAt=2023-12-10T16:01:55]]

投影查询 {#投影查询}

仅检索指定的列。

 // 注入 EntityManager
 @PersistenceContext
 EntityManager entityManager;
@Test
@Transactional
@Rollback(false)
public void test() throws Exception {
// 通过 EntityManager 创建 JPAQueryFactory 实例
var query = new JPAQueryFactory(entityManager);
QUser USER = QUser.user;
// 检索单列，单行
String name = query.select(USER.name).from(USER).where(USER.id.eq(1)).fetchOne();
log.info("name={}", name);
// 检索 id 和 name 列，封装结果为 Tuple
List<Tuple> tuples = query.select(USER.id, USER.name).from(USER).fetch();
tuples.stream().forEach(tuple -> {
log.info("id={}, name={}", tuple.get(USER.id), tuple.get(USER.name));
});
// 检索 id 和 enabled 列，通过 Setter 方法封装为实体
List<User> users = query.select(Projections.bean(User.class, USER.id, USER.enabled)).from(USER).fetch();
log.info("users={}", users);
}

执行测试，输出日志如下：

Hibernate: 
    select
        u1_0.name 
    from
        t_user u1_0 
    where
        u1_0.id=?
TRACE 576 --- [           main] org.hibernate.orm.jdbc.bind              : binding parameter (1:INTEGER) <- [1]
 INFO 576 --- [           main] c.s.demo.test.DemoApplicationTests       : name=刘备
Hibernate: 
    select
        u1_0.id,
        u1_0.name 
    from
        t_user u1_0
 INFO 576 --- [           main] c.s.demo.test.DemoApplicationTests       : id=3, name=关羽
 INFO 576 --- [           main] c.s.demo.test.DemoApplicationTests       : id=1, name=刘备
 INFO 576 --- [           main] c.s.demo.test.DemoApplicationTests       : id=2, name=张飞
Hibernate: 
    select
        u1_0.id,
        u1_0.enabled 
    from
        t_user u1_0
 INFO 576 --- [           main] c.s.demo.test.DemoApplicationTests       : users=[User [id=1, name=null, enabled=true, createAt=null], User [id=2, name=null, enabled=true, createAt=null], User [id=3, name=null, enabled=true, createAt=null]]

JOIN 查询 {#join-查询}

JOIN 检索关联记录。

 // 注入 EntityManager
 @PersistenceContext
 EntityManager entityManager;
@Test
@Transactional
@Rollback(false)
public void test() throws Exception {
// 通过 EntityManager 创建 JPAQueryFactory 实例
var query = new JPAQueryFactory(entityManager);
QUser USER = QUser.user;
QCar CAR = QCar.car;
// INNER JOIN
List<Tuple> tuples = query.select(USER.id, USER.name, CAR.name.as("carName"))
.from(USER)
.innerJoin(CAR).on(CAR.userId.eq(USER.id))
.where(USER.enabled.eq(true))
.fetch()
;
tuples.stream().forEach(tuple -> {
log.info("userId={}, name={}, carName={}", tuple.get(USER.id), tuple.get(USER.name), tuple.get(CAR.name.as("carName")));
});
}

执行测试，输出日志如下：

Hibernate: 
    select
        u1_0.id,
        u1_0.name,
        c1_0.name 
    from
        t_user u1_0 
    join
        t_car c1_0 
            on c1_0.user_id=u1_0.id 
    where
        u1_0.enabled=?
TRACE 16652 --- [           main] org.hibernate.orm.jdbc.bind              : binding parameter (1:BOOLEAN) <- [true]
 INFO 16652 --- [           main] c.s.demo.test.DemoApplicationTests       : userId=1, name=刘备, carName=宝马
 INFO 16652 --- [           main] c.s.demo.test.DemoApplicationTests       : userId=1, name=刘备, carName=奔驰
 INFO 16652 --- [           main] c.s.demo.test.DemoApplicationTests       : userId=2, name=张飞, carName=五菱
 INFO 16652 --- [           main] c.s.demo.test.DemoApplicationTests       : userId=2, name=张飞, carName=宝马
 INFO 16652 --- [           main] c.s.demo.test.DemoApplicationTests       : userId=3, name=关羽, carName=五菱
 INFO 16652 --- [           main] c.s.demo.test.DemoApplicationTests       : userId=3, name=关羽, carName=宝马

GROUP 查询 {#group-查询}

GROUP 聚合查询。

 // 注入 EntityManager
 @PersistenceContext
 EntityManager entityManager;
@Test
@Transactional
@Rollback(false)
public void test() throws Exception {
// 通过 EntityManager 创建 JPAQueryFactory 实例
var query = new JPAQueryFactory(entityManager);
QCar CAR = QCar.car;
// GROUP
List<Tuple> tuples = query.select(CAR.name, CAR.name.count())
.from(CAR)
.groupBy(CAR.name)
.fetch()
;
tuples.stream().forEach(tuple -> {
log.info("carName={}, count={}", tuple.get(CAR.name), tuple.get(CAR.name.count()));
});
}

执行测试，输出日志如下：

Hibernate: 
    select
        c1_0.name,
        count(c1_0.name) 
    from
        t_car c1_0 
    group by
        c1_0.name
 INFO 8104 --- [           main] c.s.demo.test.DemoApplicationTests       : carName=宝马, count=3
 INFO 8104 --- [           main] c.s.demo.test.DemoApplicationTests       : carName=奔驰, count=1
 INFO 8104 --- [           main] c.s.demo.test.DemoApplicationTests       : carName=五菱, count=2

子查询 {#子查询}

结果列子查询，以及条件语句中的子查询。

 // 注入 EntityManager
 @PersistenceContext
 EntityManager entityManager;
@Test
@Transactional
@Rollback(false)
public void test() throws Exception {
// 通过 EntityManager 创建 JPAQueryFactory 实例
var query = new JPAQueryFactory(entityManager);
QUser USER = QUser.user;
QCar CAR = QCar.car;
// 结果列子查询
List<Tuple> tuples = query.select(CAR.id, CAR.name,
JPAExpressions.select(USER.name).from(USER).where(USER.id.eq(CAR.userId)))
.from(CAR)
.fetch()
;
log.info("tuples={}", tuples);
// 条件子查询
List<User> users = query.selectFrom(USER)
.where(USER.id.in(JPAExpressions.select(CAR.userId).from(CAR).where(CAR.name.eq("宝马"))))
.fetch();
log.info("users={}", users);
}

执行测试，输出日志如下：

Hibernate: 
    select
        c1_0.id,
        c1_0.name,
        (select
            u1_0.name 
        from
            t_user u1_0 
        where
            u1_0.id=c1_0.user_id) 
    from
        t_car c1_0
 INFO 18848 --- [           main] c.s.demo.test.DemoApplicationTests       : tuples=[[1, 宝马, 刘备], [2, 奔驰, 刘备], [3, 五菱, 张飞], [4, 宝马, 张飞], [5, 五菱, 关羽], [6, 宝马, 关羽]]
Hibernate: 
    select
        u1_0.id,
        u1_0.create_at,
        u1_0.enabled,
        u1_0.name 
    from
        t_user u1_0 
    where
        u1_0.id in (select
            c1_0.user_id 
        from
            t_car c1_0 
        where
            c1_0.name=?)
TRACE 18848 --- [           main] org.hibernate.orm.jdbc.bind              : binding parameter (1:VARCHAR) <- [宝马]
 INFO 18848 --- [           main] c.s.demo.test.DemoApplicationTests       : users=[User [id=1, name=刘备, enabled=true, createAt=2023-12-10T16:01:55], User [id=2, name=张飞, enabled=true, createAt=2023-12-10T16:01:55], User [id=3, name=关羽, enabled=true, createAt=2023-12-10T16:01:55]]

结果集封装 {#结果集封装}

把结果集封装 Map，POJO 等。

 // 注入 EntityManager
 @PersistenceContext
 EntityManager entityManager;
@Test
@Transactional
@Rollback(false)
public void test() throws Exception {
// 通过 EntityManager 创建 JPAQueryFactory 实例
var query = new JPAQueryFactory(entityManager);
QUser USER = QUser.user;
QCar CAR = QCar.car;
// 结果集封装为 Map
List<Map<Expression<?>, ?>> ret = query.select(Projections.map(USER.id, USER.name, CAR.name)).from(USER)
.innerJoin(CAR).on(CAR.userId.eq(USER.id))
.fetch()
;
ret.stream().forEach(item -> {
log.info("userId={}, name={}, carName={}", item.get(USER.id), item.get(USER.name), item.get(CAR.name));
});
// 通过字段，封装为 Bean
List<User> users = query.select(Projections.fields(User.class, USER.id, USER.name)).from(USER)
.where(USER.id.in(1, 2))
.fetch()
;
log.info("users={}", users);
// 通过构造函数，封装为 Bean
User user = query.select(Projections.constructor(User.class, USER.id, USER.name, USER.enabled, USER.createAt)).from(USER)
.fetchFirst(); // fetchFirst 只检索结果集中的第一条记录
log.info("user={}", user);
}

执行测试，输出如下：

Hibernate: 
    select
        u1_0.id,
        u1_0.name,
        c1_0.name 
    from
        t_user u1_0 
    join
        t_car c1_0 
            on c1_0.user_id=u1_0.id
 INFO 17724 --- [           main] c.s.demo.test.DemoApplicationTests       : userId=1, name=刘备, carName=宝马
 INFO 17724 --- [           main] c.s.demo.test.DemoApplicationTests       : userId=1, name=刘备, carName=奔驰
 INFO 17724 --- [           main] c.s.demo.test.DemoApplicationTests       : userId=2, name=张飞, carName=五菱
 INFO 17724 --- [           main] c.s.demo.test.DemoApplicationTests       : userId=2, name=张飞, carName=宝马
 INFO 17724 --- [           main] c.s.demo.test.DemoApplicationTests       : userId=3, name=关羽, carName=五菱
 INFO 17724 --- [           main] c.s.demo.test.DemoApplicationTests       : userId=3, name=关羽, carName=宝马
Hibernate: 
    select
        u1_0.id,
        u1_0.name 
    from
        t_user u1_0 
    where
        u1_0.id in (?, ?)
TRACE 17724 --- [           main] org.hibernate.orm.jdbc.bind              : binding parameter (1:INTEGER) <- [1]
TRACE 17724 --- [           main] org.hibernate.orm.jdbc.bind              : binding parameter (2:INTEGER) <- [2]
 INFO 17724 --- [           main] c.s.demo.test.DemoApplicationTests       : users=[User [id=1, name=刘备, enabled=null, createAt=null], User [id=2, name=张飞, enabled=null, createAt=null]]
Hibernate: 
    select
        u1_0.id,
        u1_0.name,
        u1_0.enabled,
        u1_0.create_at 
    from
        t_user u1_0 
    limit
        ?
TRACE 17724 --- [           main] org.hibernate.orm.jdbc.bind              : binding parameter (1:INTEGER) <- [1]
 INFO 17724 --- [           main] c.s.demo.test.DemoApplicationTests       : user=User [id=1, name=刘备, enabled=true, createAt=2023-12-10T16:01:55]

更新数据 {#更新数据}

QueryDSL 提供了更新数据的 API。

 // 注入 EntityManager
 @PersistenceContext
 EntityManager entityManager;
@Test
@Transactional
@Rollback(false)
public void test() throws Exception {
// 通过 EntityManager 创建 JPAQueryFactory 实例
var query = new JPAQueryFactory(entityManager);
QUser USER = QUser.user;
QCar CAR = QCar.car;
// 更新字段
long ret = query.update(USER)
.set(USER.name, "刘皇叔")
.set(USER.enabled, false)
.where(USER.id.eq(1))
.execute()
;
log.info("ret={}", ret);
// 子查询
ret = query.update(USER)
.set(USER.name, JPAExpressions.select(CAR.name).from(CAR).where(CAR.id.eq(1)))
.set(USER.enabled, true)
.where(USER.id.eq(8))
.execute()
;
log.info("ret={}", ret);
// 自增
ret = query.update(USER)
.set(USER.id, USER.id.add(-1))
.set(USER.enabled, true)
.where(USER.id.eq(9))
.execute()
;
}

执行测试，输出如下：

Hibernate: 
    update
        t_user 
    set
        name=?,
        enabled=? 
    where
        id=?
TRACE 13392 --- [           main] org.hibernate.orm.jdbc.bind              : binding parameter (1:VARCHAR) <- [刘皇叔]
TRACE 13392 --- [           main] org.hibernate.orm.jdbc.bind              : binding parameter (2:BOOLEAN) <- [false]
TRACE 13392 --- [           main] org.hibernate.orm.jdbc.bind              : binding parameter (3:INTEGER) <- [1]
 INFO 13392 --- [           main] c.s.demo.test.DemoApplicationTests       : ret=1
Hibernate: 
    update
        t_user 
    set
        name=(select
            c1_0.name 
        from
            t_car c1_0 
        where
            c1_0.id=?),
        enabled=? 
    where
        id=?
TRACE 13392 --- [           main] org.hibernate.orm.jdbc.bind              : binding parameter (1:INTEGER) <- [1]
TRACE 13392 --- [           main] org.hibernate.orm.jdbc.bind              : binding parameter (2:BOOLEAN) <- [true]
TRACE 13392 --- [           main] org.hibernate.orm.jdbc.bind              : binding parameter (3:INTEGER) <- [8]
 INFO 13392 --- [           main] c.s.demo.test.DemoApplicationTests       : ret=0
Hibernate: 
    update
        t_user 
    set
        id=(id+?),
        enabled=? 
    where
        id=?
TRACE 13392 --- [           main] org.hibernate.orm.jdbc.bind              : binding parameter (1:INTEGER) <- [-1]
TRACE 13392 --- [           main] org.hibernate.orm.jdbc.bind              : binding parameter (2:BOOLEAN) <- [true]
TRACE 13392 --- [           main] org.hibernate.orm.jdbc.bind              : binding parameter (3:INTEGER) <- [9]

注意 ，本例中的 UPDATE 语句是不合理的（例如，ID 自增），这么写纯粹是为了演示 QueryDSL 的更新功能。

最后 {#最后}

QueryDSL 的用法总结：通过 EntityManager 创建 JPAQueryFactory 实例。然后使用查询类完成一系列的 CRUD 操作。

上述示例代码，基本上足够日常开发，但是如果业务中涉及的查询确实比较复杂，那么你可以考虑使用 Spring 6 中的 JdbcClient 来进行查询。

总结 {#总结}

本文介绍了如何在 Spring Boot 中整合 QueryDSL，以及 QueryDSL 的日常使用示例。

QueryDSL 是一款开发效率、灵活性、表达能力都非常高的 ORM。不用像 MyBatis 那样需要在 XML 中定义 SQL，再在 Mapper 接口中定义查询方法。