发布于 由admin

JPA 2.x/3.x的Criteria API进阶：动态查询构建与类型安全优化

好的，下面是一篇关于JPA Criteria API进阶的文章，以讲座模式呈现，深入探讨动态查询构建和类型安全优化。

JPA Criteria API 进阶：动态查询构建与类型安全优化

大家好！今天我们深入探讨JPA Criteria API，重点关注如何构建动态查询以及如何通过类型安全的方式来优化查询。Criteria API 在构建复杂和动态的数据库查询方面提供了强大的功能，相较于 JPQL，它更具类型安全和编译时检查的优势。

一、 Criteria API 基础回顾

在深入进阶内容之前，我们先快速回顾一下 Criteria API 的基本概念。

  • EntityManager: JPA 的核心接口，用于管理持久化上下文。
  • CriteriaBuilder: 用于创建 CriteriaQuery、Predicate 等对象的工厂。
  • CriteriaQuery: 代表一个类型安全的查询。
  • Root: 代表查询的根实体，类似于 SQL 中的 FROM 子句。
  • Predicate: 代表查询的条件，类似于 SQL 中的 WHERE 子句。
  • TypedQuery: 执行 CriteriaQuery 并返回指定类型的查询结果。

一个简单的 Criteria 查询示例：

EntityManagerFactory emf = Persistence.createEntityManagerFactory("MyPersistenceUnit");
EntityManager em = emf.createEntityManager();
CriteriaBuilder cb = em.getCriteriaBuilder();
CriteriaQuery<MyEntity> cq = cb.createQuery(MyEntity.class);
Root<MyEntity> root = cq.from(MyEntity.class);
cq.select(root); // SELECT * FROM MyEntity
TypedQuery<MyEntity> query = em.createQuery(cq);
List<MyEntity> results = query.getResultList();
em.close();
emf.close();

二、 动态查询构建：灵活应对多变需求

动态查询是指根据运行时条件构建查询。传统的 JPQL 字符串拼接容易出错，且缺乏类型安全。Criteria API 提供了更优雅的方式来实现动态查询。

2.1 基于条件列表构建 Predicate

核心思想是创建一个 List<Predicate>，然后使用 CriteriaBuilder 将这些 Predicate 组合起来。

public List<MyEntity> findByCriteria(Map<String, Object> searchCriteria) {
    EntityManagerFactory emf = Persistence.createEntityManagerFactory("MyPersistenceUnit");
    EntityManager em = emf.createEntityManager();
    CriteriaBuilder cb = em.getCriteriaBuilder();
    CriteriaQuery<MyEntity> cq = cb.createQuery(MyEntity.class);
    Root<MyEntity> root = cq.from(MyEntity.class);

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

    if (searchCriteria.containsKey("name")) {
        predicates.add(cb.equal(root.get("name"), searchCriteria.get("name")));
    }

    if (searchCriteria.containsKey("age")) {
        predicates.add(cb.greaterThan(root.get("age"), (Integer) searchCriteria.get("age")));
    }

    if (searchCriteria.containsKey("city")) {
        predicates.add(cb.like(root.get("city"), "%" + searchCriteria.get("city") + "%"));
    }

    // 将所有 Predicate 使用 AND 连接起来
    if (!predicates.isEmpty()) {
        cq.where(cb.and(predicates.toArray(new Predicate[0])));
    }

    TypedQuery<MyEntity> query = em.createQuery(cq);
    List<MyEntity> results = query.getResultList();
    em.close();
    emf.close();
    return results;
}

在这个例子中，findByCriteria 方法接收一个 Map 作为搜索条件。根据 Map 中存在的 key，我们动态地添加相应的 Predicate 到列表中。最后，使用 cb.and() 将所有 Predicate 连接起来，形成最终的查询条件。

2.2 使用 CriteriaBuilder 的各种条件构建方法

CriteriaBuilder 提供了丰富的条件构建方法，涵盖了常见的 SQL 操作符：

方法 描述 示例
equal(x, y) 等于 cb.equal(root.get("status"), "ACTIVE")
notEqual(x, y) 不等于 cb.notEqual(root.get("status"), "INACTIVE")
greaterThan(x, y) 大于 cb.greaterThan(root.get("age"), 18)
greaterThanOrEqualTo(x, y) 大于等于 cb.greaterThanOrEqualTo(root.get("age"), 18)
lessThan(x, y) 小于 cb.lessThan(root.get("price"), 100)
lessThanOrEqualTo(x, y) 小于等于 cb.lessThanOrEqualTo(root.get("price"), 100)
like(x, pattern) 模糊匹配 (LIKE) cb.like(root.get("name"), "%John%")
in(x) 包含于 (IN) cb.in(root.get("status")).value("ACTIVE").value("PENDING")
isNull(x) 为空 (IS NULL) cb.isNull(root.get("description"))
isNotNull(x) 不为空 (IS NOT NULL) cb.isNotNull(root.get("description"))
between(x, y, z) 介于 (BETWEEN) cb.between(root.get("createDate"), startDate, endDate)
conjunction() AND 连接多个 Predicate (默认，如果 predicates 列表为空，则返回 true) cb.and(predicate1, predicate2)
disjunction() OR 连接多个 Predicate (如果 predicates 列表为空，则返回 false) cb.or(predicate1, predicate2)
not(x) 取反 (NOT) cb.not(cb.equal(root.get("status"), "DELETED"))
isEmpty(x) 判断集合是否为空 cb.isEmpty(root.get("orders"))
isNotEmpty(x) 判断集合是否不为空 cb.isNotEmpty(root.get("orders"))
isMember(element, collection) 判断元素是否是集合的成员 cb.isMember("admin", root.get("roles"))

2.3 处理可选条件：避免空指针异常

在动态查询中，某些条件可能是可选的。我们需要避免因为条件不存在而导致的空指针异常。

public List<MyEntity> findByOptionalCriteria(String name, Integer age) {
    EntityManagerFactory emf = Persistence.createEntityManagerFactory("MyPersistenceUnit");
    EntityManager em = emf.createEntityManager();
    CriteriaBuilder cb = em.getCriteriaBuilder();
    CriteriaQuery<MyEntity> cq = cb.createQuery(MyEntity.class);
    Root<MyEntity> root = cq.from(MyEntity.class);

    Predicate predicate = cb.conjunction(); // 初始条件为 true，方便后续添加条件

    if (name != null && !name.isEmpty()) {
        predicate = cb.and(predicate, cb.like(root.get("name"), "%" + name + "%"));
    }

    if (age != null) {
        predicate = cb.and(predicate, cb.greaterThan(root.get("age"), age));
    }

    cq.where(predicate);

    TypedQuery<MyEntity> query = em.createQuery(cq);
    List<MyEntity> results = query.getResultList();
    em.close();
    emf.close();
    return results;
}

这里，我们使用 cb.conjunction() 创建一个初始的 Predicate，它的值为 true。这样，即使没有添加任何条件，查询也不会出错。然后，只有当 name 和 age 不为 null 时，我们才添加相应的条件。

三、 类型安全优化：消除潜在的运行时错误

Criteria API 的一个主要优势是类型安全。我们可以利用它来避免在运行时出现类型转换错误。

3.1 使用 Metamodel 类

JPA Metamodel Generator 自动生成与实体类对应的 Metamodel 类。这些类包含了实体类的属性信息，并且是类型安全的。

首先，确保你的项目中包含了 JPA Metamodel Generator 的依赖。对于 Maven 项目，添加以下依赖：

<dependency>
    <groupId>org.hibernate</groupId>
    <artifactId>hibernate-jpamodelgen</artifactId>
    <scope>provided</scope>
</dependency>

对于 Gradle 项目，添加以下依赖：

dependencies {
    annotationProcessor "org.hibernate:hibernate-jpamodelgen"
    // 或者使用 javax.persistence:javax.persistence-api:2.2 (或其他 JPA 实现提供的 Metamodel Generator)
}

然后，在编译时，JPA Metamodel Generator 会自动生成 Metamodel 类。例如，对于实体类 MyEntity，会生成一个名为 MyEntity_ 的 Metamodel 类。

@Entity
public class MyEntity {

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

    private String name;

    private Integer age;

    private String city;

    // Getters and setters
}

生成的 MyEntity_ 类：

@StaticMetamodel(MyEntity.class)
public abstract class MyEntity_ {

    public static volatile SingularAttribute<MyEntity, Long> id;
    public static volatile SingularAttribute<MyEntity, String> name;
    public static volatile SingularAttribute<MyEntity, Integer> age;
    public static volatile SingularAttribute<MyEntity, String> city;

}

使用 Metamodel 类进行查询：

public List<MyEntity> findByNameAndAge(String name, Integer age) {
    EntityManagerFactory emf = Persistence.createEntityManagerFactory("MyPersistenceUnit");
    EntityManager em = emf.createEntityManager();
    CriteriaBuilder cb = em.getCriteriaBuilder();
    CriteriaQuery<MyEntity> cq = cb.createQuery(MyEntity.class);
    Root<MyEntity> root = cq.from(MyEntity.class);

    Predicate predicate = cb.conjunction();

    if (name != null && !name.isEmpty()) {
        predicate = cb.and(predicate, cb.like(root.get(MyEntity_.name), "%" + name + "%"));
    }

    if (age != null) {
        predicate = cb.and(predicate, cb.greaterThan(root.get(MyEntity_.age), age));
    }

    cq.where(predicate);

    TypedQuery<MyEntity> query = em.createQuery(cq);
    List<MyEntity> results = query.getResultList();
    em.close();
    emf.close();
    return results;
}

使用 MyEntity_.name 和 MyEntity_.age 代替字符串 "name" 和 "age"，可以避免拼写错误和类型错误，并且在编译时就能发现这些错误。

3.2 使用泛型进行类型转换

在动态查询中，我们可能需要进行类型转换。使用泛型可以确保类型安全。

public <T> List<MyEntity> findByProperty(String propertyName, T value) {
    EntityManagerFactory emf = Persistence.createEntityManagerFactory("MyPersistenceUnit");
    EntityManager em = emf.createEntityManager();
    CriteriaBuilder cb = em.getCriteriaBuilder();
    CriteriaQuery<MyEntity> cq = cb.createQuery(MyEntity.class);
    Root<MyEntity> root = cq.from(MyEntity.class);

    Predicate predicate = cb.equal(root.get(propertyName), value);

    cq.where(predicate);

    TypedQuery<MyEntity> query = em.createQuery(cq);
    List<MyEntity> results = query.getResultList();
    em.close();
    emf.close();
    return results;
}

在这个例子中，findByProperty 方法接收一个 propertyName 和一个泛型 value。 这样可以确保传入的 value 的类型与属性的类型匹配，避免类型转换错误。但是，这里没有使用 Metamodel，仍然存在字符串拼写错误的可能性。 结合 Metamodel，可以进一步提高类型安全性。

四、 关联查询与子查询

Criteria API 同样支持关联查询和子查询，可以构建更复杂的查询。

4.1 关联查询 (Join)

@Entity
public class Order {
    @Id
    @GeneratedValue(strategy = GenerationType.IDENTITY)
    private Long id;

    @ManyToOne
    private MyEntity customer;

    private String orderNumber;

    // Getters and setters
}
public List<Order> findOrdersByCustomerName(String customerName) {
    EntityManagerFactory emf = Persistence.createEntityManagerFactory("MyPersistenceUnit");
    EntityManager em = emf.createEntityManager();
    CriteriaBuilder cb = em.getCriteriaBuilder();
    CriteriaQuery<Order> cq = cb.createQuery(Order.class);
    Root<Order> root = cq.from(Order.class);

    Join<Order, MyEntity> customerJoin = root.join("customer"); // 使用字符串 "customer" 关联 Order 和 MyEntity

    Predicate predicate = cb.like(customerJoin.get("name"), "%" + customerName + "%");

    cq.where(predicate);

    TypedQuery<Order> query = em.createQuery(cq);
    List<Order> results = query.getResultList();
    em.close();
    emf.close();
    return results;
}

或者使用 Metamodel:

public List<Order> findOrdersByCustomerName(String customerName) {
    EntityManagerFactory emf = Persistence.createEntityManagerFactory("MyPersistenceUnit");
    EntityManager em = emf.createEntityManager();
    CriteriaBuilder cb = em.getCriteriaBuilder();
    CriteriaQuery<Order> cq = cb.createQuery(Order.class);
    Root<Order> root = cq.from(Order.class);

    Join<Order, MyEntity> customerJoin = root.join(Order_.customer); // 使用 Order_.customer 关联 Order 和 MyEntity

    Predicate predicate = cb.like(customerJoin.get(MyEntity_.name), "%" + customerName + "%");

    cq.where(predicate);

    TypedQuery<Order> query = em.createQuery(cq);
    List<Order> results = query.getResultList();
    em.close();
    emf.close();
    return results;
}

4.2 子查询 (Subquery)

public List<MyEntity> findEntitiesWithOrdersGreaterThan(int orderCount) {
    EntityManagerFactory emf = Persistence.createEntityManagerFactory("MyPersistenceUnit");
    EntityManager em = emf.createEntityManager();
    CriteriaBuilder cb = em.getCriteriaBuilder();
    CriteriaQuery<MyEntity> cq = cb.createQuery(MyEntity.class);
    Root<MyEntity> root = cq.from(MyEntity.class);

    Subquery<Long> subquery = cq.subquery(Long.class);
    Root<Order> orderRoot = subquery.from(Order.class);
    subquery.select(cb.count(orderRoot));
    subquery.where(cb.equal(orderRoot.get("customer"), root));

    cq.where(cb.greaterThan(subquery, (long)orderCount));

    TypedQuery<MyEntity> query = em.createQuery(cq);
    List<MyEntity> results = query.getResultList();
    em.close();
    emf.close();
    return results;
}

五、 最佳实践与注意事项

  • 始终使用 Metamodel 类: 尽可能使用 Metamodel 类来提高类型安全性和可维护性。
  • 避免字符串拼接: 不要使用字符串拼接来构建查询，这会导致 SQL 注入漏洞和难以调试的错误。
  • 合理使用缓存: 对于频繁执行的查询，可以考虑使用缓存来提高性能。
  • 注意性能问题: 复杂的 Criteria 查询可能会导致性能问题。 使用数据库 profiling 工具来分析查询性能，并进行优化。
  • 及时关闭 EntityManager: 确保在使用完 EntityManager 后及时关闭，以避免资源泄漏。
  • 处理异常: 在构建和执行查询时，要适当处理异常。

六、 CriteriaUpdate 和 CriteriaDelete

除了查询之外，Criteria API 也支持更新和删除操作。

6.1 CriteriaUpdate

public int updateAges(int increment, int ageThreshold) {
    EntityManagerFactory emf = Persistence.createEntityManagerFactory("MyPersistenceUnit");
    EntityManager em = emf.createEntityManager();
    CriteriaBuilder cb = em.getCriteriaBuilder();
    CriteriaUpdate<MyEntity> update = cb.createCriteriaUpdate(MyEntity.class);
    Root<MyEntity> root = update.from(MyEntity.class);

    update.set(MyEntity_.age, cb.sum(root.get(MyEntity_.age), increment));
    update.where(cb.greaterThan(root.get(MyEntity_.age), ageThreshold));

    em.getTransaction().begin();
    int rowsUpdated = em.createQuery(update).executeUpdate();
    em.getTransaction().commit();
    em.close();
    emf.close();

    return rowsUpdated;
}

6.2 CriteriaDelete

public int deleteOldEntities(int ageThreshold) {
    EntityManagerFactory emf = Persistence.createEntityManagerFactory("MyPersistenceUnit");
    EntityManager em = emf.createEntityManager();
    CriteriaBuilder cb = em.getCriteriaBuilder();
    CriteriaDelete<MyEntity> delete = cb.createCriteriaDelete(MyEntity.class);
    Root<MyEntity> root = delete.from(MyEntity.class);

    delete.where(cb.lessThan(root.get(MyEntity_.age), ageThreshold));

    em.getTransaction().begin();
    int rowsDeleted = em.createQuery(delete).executeUpdate();
    em.getTransaction().commit();
    em.close();
    emf.close();

    return rowsDeleted;
}

这两个例子展示了如何使用 CriteriaUpdate 和 CriteriaDelete 进行批量更新和删除操作。 同样，使用 Metamodel 能够保证类型安全。

七、Spring Data JPA 中的 Criteria API 支持

Spring Data JPA 提供了对 Criteria API 的良好支持，可以简化 Criteria 查询的构建。 可以使用 JpaSpecificationExecutor 接口，它允许使用 Specification 对象来定义查询条件。 Specification 可以看作是 Criteria API 查询的封装。

public interface MyEntityRepository extends JpaRepository<MyEntity, Long>, JpaSpecificationExecutor<MyEntity> {
}
public class MyEntitySpecifications {

    public static Specification<MyEntity> hasNameLike(String name) {
        return (root, query, criteriaBuilder) -> criteriaBuilder.like(root.get(MyEntity_.name), "%" + name + "%");
    }

    public static Specification<MyEntity> hasAgeGreaterThan(int age) {
        return (root, query, criteriaBuilder) -> criteriaBuilder.greaterThan(root.get(MyEntity_.age), age);
    }
}
@Autowired
private MyEntityRepository myEntityRepository;

public List<MyEntity> findBySpecifications(String name, Integer age) {
    Specification<MyEntity> spec = Specification.where(null); // 初始条件为空，相当于没有条件
    if (name != null && !name.isEmpty()) {
        spec = spec.and(MyEntitySpecifications.hasNameLike(name));
    }
    if (age != null) {
        spec = spec.and(MyEntitySpecifications.hasAgeGreaterThan(age));
    }
    return myEntityRepository.findAll(spec);
}

Spring Data JPA 的 Specification 提供了一种更简洁、更模块化的方式来构建复杂的 Criteria 查询。

八、 Criteria API的未来发展

随着JPA标准的不断演进，Criteria API也在持续发展。 我们可以期待在未来的版本中，看到更加强大和易用的功能。 例如，对JSON类型字段的原生支持，更简洁的子查询语法，以及更好的性能优化。

总结

掌握 Criteria API 对于构建灵活、类型安全的 JPA 查询至关重要。 通过合理利用 CriteriaBuilder 的各种方法、Metamodel 类以及 Spring Data JPA 的 Specification，我们可以编写出高效、可维护的数据库访问代码。 动态查询不再是难题，类型安全有了更可靠的保障。

发表回复

您的邮箱地址不会被公开。 必填项已用 * 标注