Développement backend Java : requête dynamique à l'aide de l'API de critères JPA

Dans le développement back-end Java, l'interrogation de données est une opération très courante, et l'utilisation de JPA (Java Persistence API) est une méthode très populaire. JPA offre un moyen flexible et réutilisable de récupérer et de manipuler des données dans une base de données. Cependant, pour les requêtes dynamiques (c'est-à-dire que la requête doit être ajustée en fonction de différents paramètres), il peut ne pas être pratique d'utiliser des instructions de requête statiques traditionnelles ou JPQL (Java Persistence Query Language). Dans ce cas, l’utilisation de l’API JPA Criteria peut être plus pratique et plus flexible.

JPA Criteria API est une méthode de requête orientée objet, qui est implémentée en assemblant des conditions de requête et en renvoyant les résultats via du code. Par rapport aux instructions de requête statiques traditionnelles ou JPQL, l'un de ses principaux avantages est qu'il peut regrouper dynamiquement différentes conditions de requête au cours du processus de requête et mieux répondre aux modifications du modèle de données. Cet article explique comment utiliser l'API JPA Criteria pour effectuer des requêtes dynamiques.

1. Entity Class

Tout d'abord, nous devons avoir une classe d'entité Supposons que nous ayons une classe d'entité User, qui a un identifiant, nom, âge, sexe et autres champs. Avant d'utiliser l'API JPA Criteria, nous devons d'abord définir cette classe d'entité.

@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

Avant d'utiliser l'API JPA Criteria, nous devons d'abord obtenir CriteriaBuilder. CriteriaBuilder est une classe d'usine utilisée pour créer divers CriteriaQuery, Predicate et Expression. Habituellement, nous pouvons obtenir CriteriaBuilder via EntityManager.

@PersistenceContext
private EntityManager entityManager;

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

3. CriteriaQuery

CriteriaQuery est utilisé pour les opérations de requête Nous pouvons l'utiliser pour définir les conditions de la requête et le type de résultats renvoyés. . Lors de la définition des conditions de requête, nous pouvons définir plusieurs restrictions via Predicate est un petit outil de l'API Criteria pour créer des conditions de requête.

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

Le code ci-dessus montre comment utiliser CriteriaBuilder pour créer CriteriaQuery. Tout d’abord, nous utilisons EntityManager pour obtenir le CriteriaBuilder. Ensuite, nous créons un objet de requête CriteriaQuery, spécifiant que le type de résultat de la requête est User. Utilisez Root pour créer des conditions de requête, où root représente l’objet User. Ensuite, nous pouvons utiliser CriteriaBuilder pour créer des objets Predicate et les ajouter à la liste. Enfin, définissez les conditions dans CriteriaQuery et exécutez la requête pour renvoyer les résultats.

4. Expression

L'expression est un autre concept utile dans l'API Criteria. Elle représente une expression d'opération qui peut être utilisée pour calculer et comparer des éléments complexes. types de données. Lors de l'utilisation d'Expression, nous pouvons effectuer un filtrage plus raffiné dans les conditions de requête d'origine. Par exemple, nous pouvons utiliser la méthode between pour interroger les utilisateurs dont l’âge se situe dans une certaine plage.

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

Le code ci-dessus interroge les utilisateurs dont l'âge est compris entre minAge et maxAge. Il convient de noter que nous utilisons ici Expression ageExpression, afin de permettre à l'API JPA Criteria de comprendre que le champ d'âge que nous souhaitons interroger est de type entier.

5. Requête de plusieurs tables

Dans certains scénarios, nous devons interroger plusieurs tables. À ce stade, nous devons utiliser Join, qui est le concept de base utilisé pour les requêtes multi-tables. Supposons que nous ayons une classe d'entité Task, qui comporte deux champs, id et userId, qui est associé au champ id dans la classe d'entité User.

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

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

    private Long userId;

    // 省略getter和setter方法
}

Nous pouvons associer deux classes d'entités via Join et interroger toutes les tâches sous un utilisateur spécifié.

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. Requête de pagination

Enfin, nous présentons comment implémenter une requête de pagination dans l'API JPA Criteria. Par rapport aux requêtes statiques, les requêtes de pagination sont également très courantes et sont particulièrement importantes pour les scénarios comportant des quantités de données relativement importantes. Dans l'API JPA Criteria, nous pouvons utiliser les méthodes setFirstResult et setMaxResults pour spécifier la position de départ de la requête et le nombre maximum de résultats renvoyés.

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

Le code ci-dessus montre comment définir les conditions de requête de pagination. Tout d'abord, nous calculons le décalage via pageNum et pageSize, définissons la position de départ, puis définissons le nombre maximum de résultats renvoyés via setMaxResults. Bien entendu, dans des applications pratiques, nous pouvons également effectuer des requêtes de pagination par d’autres moyens.

Conclusion

JPA Criteria API est un outil très flexible et puissant qui peut fournir un bon support dans les requêtes dynamiques. Bien sûr, dans les applications réelles, nous devons également prendre en compte les performances et d’autres problèmes, mais cela peut rendre notre code plus lisible, maintenable et évolutif. J'espère que cet article sera utile aux lecteurs qui utilisent JPA ou envisagent d'utiliser JPA.

Ce qui précède est le contenu détaillé de. pour plus d'informations, suivez d'autres articles connexes sur le site Web de PHP en chinois!