JAVA 项目使用 JPA 时查询性能低？CriteriaQuery 优化指南 - 智猿学院-前后端，数据库，人工智能，云计算等领域前沿技术讲座

JPA CriteriaQuery 优化指南：告别性能瓶颈，提升查询效率

大家好，今天我们来聊聊Java项目中使用JPA时，如何利用CriteriaQuery进行性能优化。很多开发者在使用JPA时，特别是面对复杂查询场景，会发现性能瓶颈。CriteriaQuery作为JPA提供的一种类型安全、动态构建查询的方式，如果使用得当，可以显著提升查询效率。

1. CriteriaQuery 简介与优势

JPA（Java Persistence API）是Java EE标准中用于对象关系映射（ORM）的API。它提供了一种将Java对象映射到关系数据库表的方式。 CriteriaQuery是JPA提供的一种编程方式，用于构建类型安全的数据库查询。

优势：

类型安全： CriteriaQuery 使用 Java 代码来构建查询，而不是字符串，这可以在编译时捕获类型错误。
动态性： 可以根据运行时条件动态地构建查询，这对于处理复杂的查询需求非常有用。
可读性： 虽然初学时可能觉得代码冗长，但熟练后，CriteriaQuery 比 JPQL 更容易理解和维护，特别是对于复杂的连接查询。
性能潜力： 通过精细的控制，可以生成更优化的 SQL 查询。

与 JPQL 的比较:

特性	JPQL (Java Persistence Query Language)	CriteriaQuery
查询构建方式	字符串	Java 代码
类型安全	运行时检查	编译时检查
动态性	字符串拼接，易出错	灵活，易于动态构建
可读性	对于简单查询易读，复杂查询难以维护	稍显冗长，但结构清晰，复杂查询更易维护
性能	可能需要手动优化	具有更高的优化潜力，但需要开发者了解底层原理

2. CriteriaQuery 基础：构建简单查询

首先，我们来看一个简单的 CriteriaQuery 示例。假设我们有一个 Employee 实体类：

@Entity
@Table(name = "employees")
public class Employee {

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

    @Column(name = "first_name")
    private String firstName;

    @Column(name = "last_name")
    private String lastName;

    @Column(name = "salary")
    private Double salary;

    // Getters and setters...

    public Employee() {
    }

    public Employee(String firstName, String lastName, Double salary) {
        this.firstName = firstName;
        this.lastName = lastName;
        this.salary = salary;
    }

    public Long getId() {
        return id;
    }

    public void setId(Long id) {
        this.id = id;
    }

    public String getFirstName() {
        return firstName;
    }

    public void setFirstName(String firstName) {
        this.firstName = firstName;
    }

    public String getLastName() {
        return lastName;
    }

    public void setLastName(String lastName) {
        this.lastName = lastName;
    }

    public Double getSalary() {
        return salary;
    }

    public void setSalary(Double salary) {
        this.salary = salary;
    }
}

现在，我们要查询所有 salary 大于 50000 的员工。

import javax.persistence.*;
import javax.persistence.criteria.*;
import java.util.List;

public class CriteriaQueryExample {

    public static void main(String[] args) {
        EntityManagerFactory emf = Persistence.createEntityManagerFactory("MyPersistenceUnit"); // Replace with your persistence unit name
        EntityManager em = emf.createEntityManager();

        try {
            CriteriaBuilder cb = em.getCriteriaBuilder();
            CriteriaQuery<Employee> cq = cb.createQuery(Employee.class);
            Root<Employee> root = cq.from(Employee.class);

            // 构建查询条件
            Predicate salaryGreaterThan = cb.gt(root.get("salary"), 50000.0);
            cq.where(salaryGreaterThan);

            // 执行查询
            TypedQuery<Employee> query = em.createQuery(cq);
            List<Employee> employees = query.getResultList();

            // 输出结果
            for (Employee employee : employees) {
                System.out.println(employee.getFirstName() + " " + employee.getLastName() + ": " + employee.getSalary());
            }
        } finally {
            em.close();
            emf.close();
        }
    }
}

代码解释：

EntityManagerFactory 和 EntityManager: JPA 的入口点，用于创建和管理实体管理器。
CriteriaBuilder: 用于构建 CriteriaQuery 的工厂类。
CriteriaQuery<Employee>: 表示一个类型安全的查询，指定查询结果的类型为 Employee。
Root<Employee>: 表示查询的根实体，相当于 SQL 中的 FROM 子句。
cb.gt(root.get("salary"), 50000.0): 构建一个大于（greater than）的条件，相当于 SQL 中的 salary > 50000。 root.get("salary") 获取 Employee 实体中 salary 属性的路径。
cq.where(salaryGreaterThan): 将条件添加到查询中，相当于 SQL 中的 WHERE 子句。
em.createQuery(cq): 根据 CriteriaQuery 创建一个 TypedQuery，可以执行查询并获取结果。
query.getResultList(): 执行查询，返回一个 Employee 对象的列表。

3. CriteriaQuery 优化技巧：提升查询性能

掌握了 CriteriaQuery 的基本用法后，我们来看一些优化技巧，可以显著提升查询性能。

3.1. 选择合适的 FetchType

JPA 提供了两种 FetchType：LAZY（懒加载）和 EAGER（急加载）。默认情况下，ToOne 关系使用 EAGER， ToMany 关系使用 LAZY。

EAGER: 在加载实体时立即加载关联实体。
LAZY: 在需要访问关联实体时才加载。

优化建议：

避免过度使用 EAGER: EAGER 加载会导致加载不必要的关联数据，增加查询开销。尽量使用 LAZY 加载，并在需要时使用 JOIN FETCH 进行显式加载。
使用 JOIN FETCH: JOIN FETCH 是一种显式指定 EAGER 加载的方式，可以在 CriteriaQuery 中使用，避免 N+1 查询问题。

示例：

假设 Employee 实体有一个 Department 关联实体：

@Entity
@Table(name = "employees")
public class Employee {

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

    @Column(name = "first_name")
    private String firstName;

    @Column(name = "last_name")
    private String lastName;

    @Column(name = "salary")
    private Double salary;

    @ManyToOne(fetch = FetchType.LAZY) // 默认 LAZY, 可以显式指定
    @JoinColumn(name = "department_id")
    private Department department;

    // Getters and setters...
}

@Entity
@Table(name = "departments")
public class Department {
    @Id
    @GeneratedValue(strategy = GenerationType.IDENTITY)
    private Long id;
    private String name;

    // Getters and setters...
}

如果我们想要查询所有员工及其所属的部门，并避免 N+1 查询，可以使用 JOIN FETCH：

CriteriaBuilder cb = em.getCriteriaBuilder();
CriteriaQuery<Employee> cq = cb.createQuery(Employee.class);
Root<Employee> root = cq.from(Employee.class);

// 使用 JOIN FETCH 显式加载 department
root.fetch("department", JoinType.LEFT); // 可以使用 LEFT, INNER 等 JoinType

TypedQuery<Employee> query = em.createQuery(cq);
List<Employee> employees = query.getResultList();

for (Employee employee : employees) {
    System.out.println(employee.getFirstName() + " " + employee.getLastName() + " - " + employee.getDepartment().getName());
}

3.2. 使用 CriteriaBuilder 的函数

CriteriaBuilder 提供了许多函数，可以用于构建复杂的查询条件。合理使用这些函数可以简化代码，并可能提升性能。

常用函数：

cb.equal(x, y): 等于
cb.notEqual(x, y): 不等于
cb.greaterThan(x, y): 大于
cb.greaterThanOrEqualTo(x, y): 大于等于
cb.lessThan(x, y): 小于
cb.lessThanOrEqualTo(x, y): 小于等于
cb.like(x, pattern): 模糊匹配
cb.in(x): IN 子句
cb.isNull(x): 判断是否为 NULL
cb.isNotNull(x): 判断是否不为 NULL
cb.and(predicates...): AND 条件
cb.or(predicates...): OR 条件
cb.count(x): COUNT 函数
cb.avg(x): AVG 函数
cb.sum(x): SUM 函数
cb.min(x): MIN 函数
cb.max(x): MAX 函数

示例：

查询 firstName 以 "J" 开头，并且 salary 大于 60000 的员工：

CriteriaBuilder cb = em.getCriteriaBuilder();
CriteriaQuery<Employee> cq = cb.createQuery(Employee.class);
Root<Employee> root = cq.from(Employee.class);

Predicate firstNameLike = cb.like(root.get("firstName"), "J%");
Predicate salaryGreaterThan = cb.greaterThan(root.get("salary"), 60000.0);

// 使用 AND 连接两个条件
Predicate combinedPredicate = cb.and(firstNameLike, salaryGreaterThan);

cq.where(combinedPredicate);

TypedQuery<Employee> query = em.createQuery(cq);
List<Employee> employees = query.getResultList();

// 输出结果
for (Employee employee : employees) {
    System.out.println(employee.getFirstName() + " " + employee.getLastName() + ": " + employee.getSalary());
}

3.3. 使用 Predicate 数组动态构建查询条件

当查询条件非常复杂，并且需要根据运行时条件动态添加或删除条件时，可以使用 Predicate 数组。

示例：

根据用户输入动态构建查询条件，可以根据 firstName、lastName 或 salary 进行过滤：

String firstNameFilter = "J"; // 假设用户输入
String lastNameFilter = null; // 假设用户输入
Double salaryFilter = 70000.0; // 假设用户输入

CriteriaBuilder cb = em.getCriteriaBuilder();
CriteriaQuery<Employee> cq = cb.createQuery(Employee.class);
Root<Employee> root = cq.from(Employee.class);

List<Predicate> predicates = new ArrayList<>();

if (firstNameFilter != null && !firstNameFilter.isEmpty()) {
    predicates.add(cb.like(root.get("firstName"), firstNameFilter + "%"));
}

if (lastNameFilter != null && !lastNameFilter.isEmpty()) {
    predicates.add(cb.equal(root.get("lastName"), lastNameFilter));
}

if (salaryFilter != null) {
    predicates.add(cb.greaterThanOrEqualTo(root.get("salary"), salaryFilter));
}

// 将 Predicate 列表转换为数组
Predicate[] predicateArray = predicates.toArray(new Predicate[0]);

// 使用 AND 连接所有条件
cq.where(predicateArray);

TypedQuery<Employee> query = em.createQuery(cq);
List<Employee> employees = query.getResultList();

// 输出结果
for (Employee employee : employees) {
    System.out.println(employee.getFirstName() + " " + employee.getLastName() + ": " + employee.getSalary());
}

3.4. 使用 CriteriaUpdate 和 CriteriaDelete 进行批量更新和删除

JPA 提供了 CriteriaUpdate 和 CriteriaDelete 用于执行批量更新和删除操作，这比逐个加载实体再进行更新或删除效率更高。

示例：

批量更新所有 salary 小于 50000 的员工的 salary，将其增加 10%：

em.getTransaction().begin();

CriteriaBuilder cb = em.getCriteriaBuilder();
CriteriaUpdate<Employee> update = cb.createCriteriaUpdate(Employee.class);
Root<Employee> root = update.from(Employee.class);

// 设置更新字段
update.set(root.get("salary"), cb.prod(root.get("salary"), 1.1)); // salary * 1.1

// 设置更新条件
update.where(cb.lessThan(root.get("salary"), 50000.0));

// 执行更新
Query query = em.createQuery(update);
int updatedCount = query.executeUpdate();

em.getTransaction().commit();

System.out.println("Updated " + updatedCount + " employees.");

示例：

批量删除所有 salary 小于 30000 的员工：

em.getTransaction().begin();

CriteriaBuilder cb = em.getCriteriaBuilder();
CriteriaDelete<Employee> delete = cb.createCriteriaDelete(Employee.class);
Root<Employee> root = delete.from(Employee.class);

// 设置删除条件
delete.where(cb.lessThan(root.get("salary"), 30000.0));

// 执行删除
Query query = em.createQuery(delete);
int deletedCount = query.executeUpdate();

em.getTransaction().commit();

System.out.println("Deleted " + deletedCount + " employees.");

3.5. 使用 Query Hints

Query Hints 允许你向 JPA 提供额外的提示信息，以优化查询执行。这些提示信息会被传递给底层的数据库驱动，可以影响查询的执行计划。

常用 Query Hints：

org.hibernate.cacheable: 控制查询结果是否被缓存。
org.hibernate.readOnly: 将查询结果设置为只读，可以提高性能。
org.hibernate.fetchSize: 设置每次从数据库获取的记录数，可以避免一次性加载大量数据。
特定数据库的 Hints: 例如，MySQL 的 queryHints 可以用于设置查询超时时间。

示例：

设置查询结果为只读，并设置 fetchSize：

CriteriaBuilder cb = em.getCriteriaBuilder();
CriteriaQuery<Employee> cq = cb.createQuery(Employee.class);
Root<Employee> root = cq.from(Employee.class);

TypedQuery<Employee> query = em.createQuery(cq);

// 设置 Query Hints
query.setHint("org.hibernate.readOnly", true);
query.setHint("org.hibernate.fetchSize", 100);

List<Employee> employees = query.getResultList();

3.6. 避免 SELECT *，只选择需要的字段

虽然 CriteriaQuery 默认是类型安全的，返回的是实体对象，但我们仍然可以通过构造器表达式来只选择需要的字段，而不是加载整个实体。

示例:

只查询员工的 firstName 和 lastName：

CriteriaBuilder cb = em.getCriteriaBuilder();
CriteriaQuery<Object[]> cq = cb.createQuery(Object[].class); // 查询结果为 Object[]
Root<Employee> root = cq.from(Employee.class);

// 使用构造器表达式选择 firstName 和 lastName
cq.select(cb.array(root.get("firstName"), root.get("lastName")));

TypedQuery<Object[]> query = em.createQuery(cq);
List<Object[]> results = query.getResultList();

for (Object[] result : results) {
    String firstName = (String) result[0];
    String lastName = (String) result[1];
    System.out.println(firstName + " " + lastName);
}

或者，可以创建一个 DTO (Data Transfer Object) 来封装查询结果：

public class EmployeeName {
    private String firstName;
    private String lastName;

    public EmployeeName(String firstName, String lastName) {
        this.firstName = firstName;
        this.lastName = lastName;
    }

    // Getters...
}

查询代码：

CriteriaBuilder cb = em.getCriteriaBuilder();
CriteriaQuery<EmployeeName> cq = cb.createQuery(EmployeeName.class);
Root<Employee> root = cq.from(Employee.class);

// 使用构造器表达式选择 firstName 和 lastName，并映射到 EmployeeName DTO
cq.select(cb.construct(EmployeeName.class, root.get("firstName"), root.get("lastName")));

TypedQuery<EmployeeName> query = em.createQuery(cq);
List<EmployeeName> results = query.getResultList();

for (EmployeeName employeeName : results) {
    System.out.println(employeeName.getFirstName() + " " + employeeName.getLastName());
}

3.7 使用 EXISTS 和 NOT EXISTS

在子查询中，EXISTS 和 NOT EXISTS 通常比 IN 和 NOT IN 效率更高，尤其是在处理大量数据时。

示例:

查找至少有一个员工的部门:

CriteriaBuilder cb = em.getCriteriaBuilder();
CriteriaQuery<Department> cq = cb.createQuery(Department.class);
Root<Department> departmentRoot = cq.from(Department.class);

// 构建子查询
Subquery<Long> subquery = cq.subquery(Long.class);
Root<Employee> employeeRoot = subquery.from(Employee.class);
subquery.select(cb.count(employeeRoot));
subquery.where(cb.equal(employeeRoot.get("department"), departmentRoot));

// 使用 EXISTS
cq.where(cb.exists(subquery));

TypedQuery<Department> query = em.createQuery(cq);
List<Department> departments = query.getResultList();

for (Department department : departments) {
    System.out.println(department.getName());
}

4. 案例分析：复杂查询优化

我们来看一个更复杂的案例，假设我们需要查询所有满足以下条件的员工：

salary 大于某个值
firstName 包含某个字符串
属于某个部门
按照 salary 排序

public List<Employee> findEmployees(Double minSalary, String firstNameLike, Long departmentId, String sortField, boolean ascending) {
    CriteriaBuilder cb = em.getCriteriaBuilder();
    CriteriaQuery<Employee> cq = cb.createQuery(Employee.class);
    Root<Employee> root = cq.from(Employee.class);

    List<Predicate> predicates = new ArrayList<>();

    if (minSalary != null) {
        predicates.add(cb.greaterThanOrEqualTo(root.get("salary"), minSalary));
    }

    if (firstNameLike != null && !firstNameLike.isEmpty()) {
        predicates.add(cb.like(root.get("firstName"), "%" + firstNameLike + "%"));
    }

    if (departmentId != null) {
        Join<Employee, Department> departmentJoin = root.join("department", JoinType.INNER); // 假设 Employee 有 department 属性
        predicates.add(cb.equal(departmentJoin.get("id"), departmentId));
    }

    cq.where(predicates.toArray(new Predicate[0]));

    // 排序
    if (sortField != null && !sortField.isEmpty()) {
        if (ascending) {
            cq.orderBy(cb.asc(root.get(sortField)));
        } else {
            cq.orderBy(cb.desc(root.get(sortField)));
        }
    }

    TypedQuery<Employee> query = em.createQuery(cq);
    return query.getResultList();
}

优化点：

动态构建条件： 使用 Predicate 列表动态添加查询条件。
使用 JOIN： 使用 Join 进行关联查询，注意选择合适的 JoinType。
排序： 使用 orderBy 进行排序，可以指定升序或降序。
参数化查询： 避免字符串拼接，使用参数化查询防止 SQL 注入。

5. 注意事项

了解底层 SQL： 虽然 CriteriaQuery 提供了类型安全的查询构建方式，但了解生成的 SQL 语句仍然非常重要。可以通过配置 JPA 的日志级别来查看生成的 SQL。
使用性能分析工具： 使用性能分析工具（例如，JProfiler、YourKit）来分析查询性能，找出瓶颈。
数据库索引： 确保数据库表上建立了合适的索引，可以显著提升查询性能。
缓存： 合理使用 JPA 的二级缓存和查询缓存可以减少数据库访问次数。

CriteriaQuery 优化要点

优化 CriteriaQuery 的关键在于理解 JPA 的工作原理和底层数据库的执行计划。通过选择合适的 FetchType、使用 CriteriaBuilder 的函数、动态构建查询条件、使用 Query Hints 和避免 SELECT *，可以显著提升查询性能。

灵活运用 CriteriaQuery 提升查询效率

掌握 CriteriaQuery 的高级用法，例如 CriteriaUpdate、CriteriaDelete 和 EXISTS/NOT EXISTS，可以进一步优化批量操作和子查询。结合实际案例，灵活运用这些技巧，可以有效解决 JPA 项目中的性能瓶颈。

性能测试与持续优化

最后，不要忘记进行性能测试，验证优化效果，并根据实际情况进行持续优化。只有通过不断的实践和总结，才能真正掌握 CriteriaQuery 的优化技巧，提升项目的整体性能。

JPA CriteriaQuery 优化指南：告别性能瓶颈，提升查询效率

1. CriteriaQuery 简介与优势

2. CriteriaQuery 基础：构建简单查询

3. CriteriaQuery 优化技巧：提升查询性能

3.1. 选择合适的 FetchType

3.2. 使用 CriteriaBuilder 的函数

3.3. 使用 Predicate 数组动态构建查询条件

3.4. 使用 CriteriaUpdate 和 CriteriaDelete 进行批量更新和删除

3.5. 使用 Query Hints

3.6. 避免 SELECT *，只选择需要的字段

3.7 使用 EXISTS 和 NOT EXISTS

4. 案例分析：复杂查询优化

5. 注意事项

CriteriaQuery 优化要点

灵活运用 CriteriaQuery 提升查询效率

性能测试与持续优化

发表回复 取消回复

发表回复取消回复