Java Backend Development: Dynamic Query Using JPA Criteria API

In Java back-end development, querying data is a very common operation, and using JPA (Java Persistence API) is a very popular method. JPA provides a flexible, reusable way to retrieve and manipulate data in a database. However, for dynamic queries (that is, the query needs to be adjusted according to different parameters), it may not be convenient to use traditional static query statements or JPQL (Java Persistence Query Language). In this case, using the JPA Criteria API can be more convenient and flexible.

JPA Criteria API is an object-oriented query method, which is implemented by assembling query conditions and returning results through code. Compared with traditional static query statements or JPQL, one of its main advantages is that it can dynamically splice different query conditions during the query process, and can better respond to changes in the data model. This article will introduce how to use the JPA Criteria API to perform dynamic queries.

1. Entity Class

First, we need to have an entity class. Suppose we have a User entity class, which has fields such as id, name, age, gender, etc. Before using the JPA Criteria API, we need to define this entity class first.

@Entity
@Table(name = "user")
public class User {

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

    private String name;

    private Integer age;

    private Boolean gender;

    // 省略getter和setter方法
}

2. CriteriaBuilder

Before using the JPA Criteria API, we need to obtain the CriteriaBuilder first. CriteriaBuilder is a factory class used to create various CriteriaQuery, Predicate and Expression. Usually, we can get CriteriaBuilder through EntityManager.

@PersistenceContext
private EntityManager entityManager;

public List<User> getUsers() {
    CriteriaBuilder cb = entityManager.getCriteriaBuilder();
    // ... 继续后续操作
}

3. CriteriaQuery

CriteriaQuery is used for query operations. We can use it to set the conditions of the query and the type of returned results. When setting query conditions, we can set multiple restrictions through Predicate. Predicate is a small tool in the Criteria API for building query conditions.

public List<User> getUsers(String name, Integer age, Boolean gender) {
    CriteriaBuilder cb = entityManager.getCriteriaBuilder();
    CriteriaQuery<User> cq = cb.createQuery(User.class);
    Root<User> root = cq.from(User.class);

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

    if (name != null) {
        Predicate namePredicate = cb.equal(root.get("name"), name);
        predicates.add(namePredicate);
    }

    if (age != null) {
        Predicate agePredicate = cb.greaterThanOrEqualTo(root.get("age"), age);
        predicates.add(agePredicate);
    }

    if (gender != null) {
        Predicate genderPredicate = cb.equal(root.get("gender"), gender);
        predicates.add(genderPredicate);
    }

    cq.where(predicates.toArray(new Predicate[0]));
    return entityManager.createQuery(cq).getResultList();
}

The above code demonstrates how to use CriteriaBuilder to create CriteriaQuery. First, we use EntityManager to get the CriteriaBuilder. Then, we create a query object CriteriaQuery4c8e0c17c3bd7e0081bb17cc795e1984 cq, specifying that the result type of the query is User. Use Root4c8e0c17c3bd7e0081bb17cc795e1984 root to construct query conditions, where root represents the User object. Next, we can use CriteriaBuilder to create Predicate objects and add them to the list. Finally, set the conditions into the CriteriaQuery and execute the query to return the results.

4. Expression

Expression is another very useful concept in the Criteria API. It represents an operation expression that can be used to calculate and compare some complex data types. . When using Expression, we can perform more refined filtering under the original query conditions. For example, we can use the between method to query users whose age is within a certain range.

public List<User> getUsersInRange(Integer minAge, Integer maxAge) {
    CriteriaBuilder cb = entityManager.getCriteriaBuilder();
    CriteriaQuery<User> cq = cb.createQuery(User.class);
    Root<User> root = cq.from(User.class);

    Expression<Integer> ageExpression = root.get("age");

    Predicate agePredicate = cb.between(ageExpression, minAge, maxAge);
    cq.where(agePredicate);

    return entityManager.createQuery(cq).getResultList();
}

The above code queries users whose age is between minAge and maxAge. It should be noted that here we use Expressionc0f559cc8d56b43654fcbe4aa9df7b4a ageExpression, in order to let the JPA Criteria API understand that the age field we want to query is of integer type.

5. Multiple table query

In some scenarios, we need to query multiple tables. At this point we need to use Join, which is the core concept used for multi-table queries. Suppose we have a Task entity class, which has two fields, id and userId. UserId is associated with the id field in the User entity class.

@Entity
@Table(name = "task")
public class Task {

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

    private Long userId;

    // 省略getter和setter方法
}

We can associate two entity classes through Join and query all Tasks under the specified User.

public List<Task> getUserTasks(Long userId) {
    CriteriaBuilder cb = entityManager.getCriteriaBuilder();
    CriteriaQuery<Task> cq = cb.createQuery(Task.class);
    Root<Task> taskRoot = cq.from(Task.class);
    Join<Task, User> userJoin = taskRoot.join("user");

    Predicate predicate = cb.equal(userJoin.get("id"), userId);
    cq.where(predicate);

    return entityManager.createQuery(cq).getResultList();
}

6. Paging query

Finally, we introduce how to implement paging query in JPA Criteria API. Compared with static queries, paging queries are also very common, and are especially important for scenarios with relatively large amounts of data. In the JPA Criteria API, we can use the setFirstResult and setMaxResults methods to specify the starting position of the query and the maximum number of returned results.

public List<User> getUsers(Integer pageNum, Integer pageSize) {
    CriteriaBuilder cb = entityManager.getCriteriaBuilder();
    CriteriaQuery<User> cq = cb.createQuery(User.class);
    Root<User> root = cq.from(User.class);

    int offset = (pageNum - 1) * pageSize;
    entityManager.createQuery(cq).setFirstResult(offset).setMaxResults(pageSize);

    return entityManager.createQuery(cq).getResultList();
}

The above code demonstrates how to set the paging query conditions. First, we calculate the offset through pageNum and pageSize, set the starting position, and then set the maximum number of returned results through setMaxResults. Of course, in practical applications, we can also perform paging queries in other ways.

Conclusion

JPA Criteria API is a very flexible and powerful tool that can provide good support in dynamic queries. Of course, in actual applications, we also need to consider issues such as performance, but it can make our code more readable, maintainable and scalable. I hope this article will be helpful to readers who are using JPA or considering using JPA.

The above is the detailed content of Java Backend Development: Dynamic Query Using JPA Criteria API. For more information, please follow other related articles on the PHP Chinese website!