JPA - API de critères

L'API Criteria est une API prédéfinie utilisée pour définir des requêtes pour les entités. C'est la manière alternative de définir une requête JPQL. Ces requêtes sont de type sécurisé, portables et faciles à modifier en modifiant la syntaxe. Semblable à JPQL, il suit un schéma abstrait (schéma facile à modifier) et des objets intégrés. L'API de métadonnées est mélangée à l'API de critères pour modéliser l'entité persistante pour les requêtes de critères.

Le principal avantage de l'API de critères est que les erreurs peuvent être détectées plus tôt lors de la compilation. Les requêtes JPQL basées sur des chaînes et les requêtes basées sur des critères JPA sont identiques en termes de performances et d'efficacité.

Historique de l'API des critères

L'API de critères est incluse dans toutes les versions de JPA, par conséquent chaque étape de l'API de critères est notifiée dans les spécifications de JPA.

Dans JPA 2.0, l'API de requête de critères, la standardisation des requêtes est développée.
Dans JPA 2.1, la mise à jour et la suppression des critères (mise à jour et suppression en bloc) sont incluses.

Structure de requête de critères

L'API Criteria et le JPQL sont étroitement liés et sont autorisés à concevoir en utilisant des opérateurs similaires dans leurs requêtes. Il suit le package javax.persistence.criteria pour concevoir une requête. La structure de la requête signifie la requête des critères de syntaxe.

La requête de critères simples suivante renvoie toutes les instances de la classe d'entité dans la source de données.

EntityManager em = ...;
CriteriaBuilder cb = em.getCriteriaBuilder();

CriteriaQuery<Entity class> cq = cb.createQuery(Entity.class);
Root<Entity> from = cq.from(Entity.class);

cq.select(Entity);
TypedQuery<Entity> q = em.createQuery(cq);
List<Entity> allitems = q.getResultList();

La requête montre les étapes de base pour créer un critère.

L' instance EntityManager est utilisée pour créer un objet CriteriaBuilder .
L' instance CriteriaQuery est utilisée pour créer un objet de requête. Les attributs de cet objet de requête seront modifiés avec les détails de la requête.
La méthode CriteriaQuery.from est appelée pour définir la racine de la requête.
CriteriaQuery.select est appelé pour définir le type de liste de résultats.
L'instance TypedQuery <T> est utilisée pour préparer une requête en vue de son exécution et en spécifiant le type du résultat de la requête.
getResultList sur l'objet TypedQuery <T> pour exécuter une requête. Cette requête renvoie une collection d'entités, le résultat est stocké dans une liste.

Exemple d'API de critères

Prenons l'exemple de la base de données des employés. Supposons que la table jpadb.employee contienne les enregistrements suivants:

Eid	Ename           Salary	Deg
401	Gopal	        40000	Technical Manager
402	Manisha	        40000	Proof reader
403	Masthanvali     35000	Technical Writer
404     Satish	        30000	Technical writer
405	Krishna	        30000	Technical Writer
406	Kiran	        35000	Proof reader

Créez un projet JPA dans l'EDI eclipse nommé JPA_Eclipselink_Criteria. Tous les modules de ce projet sont présentés comme suit:

Créer des entités

Créez un package nommé com.tutorialspoint.eclipselink.entity en dessous de ‘src’ paquet.

Créez une classe nommée Employee.javasous le paquet donné. L'entité de classe Employee est représentée comme suit:

package com.tutorialspoint.eclipselink.entity;

import javax.persistence.Entity;
import javax.persistence.GeneratedValue;
import javax.persistence.GenerationType;
import javax.persistence.Id;

@Entity
public class Employee {
   @Id
   @GeneratedValue(strategy= GenerationType.AUTO) 	
   
   private int eid;
   private String ename;
   private double salary;
   private String deg;
   
   public Employee(int eid, String ename, double salary, String deg) {
      super( );
      this.eid = eid;
      this.ename = ename;
      this.salary = salary;
      this.deg = deg;
   }

   public Employee( ) {
      super();
   }

   public int getEid( ) {
      return eid;
   }
   
   public void setEid(int eid) {
      this.eid = eid;
   }

   public String getEname( ) {
      return ename;
   }
   
   public void setEname(String ename) {
      this.ename = ename;
   }

   public double getSalary( ) {
      return salary;
   }
   
   public void setSalary(double salary) {
      this.salary = salary;
   }

   public String getDeg( ) {
      return deg;
   }
   
   public void setDeg(String deg) {
      this.deg = deg;
   }
   
   @Override
   public String toString() {
   return "Employee [eid = " + eid + ", ename = " + ename + ", salary = " + salary + ", deg = " + deg + "]";
   }
}

Persistence.xml

Le fichier Persistence.xml est requis pour configurer la base de données et l'enregistrement des classes d'entités.

Persistence.xml sera créé par l'EDI eclipse lors de la création d'un projet JPA. Les détails de configuration sont les spécifications de l'utilisateur. Le fichier persistence.xml est présenté comme suit:

<?xml version = "1.0" encoding = "UTF-8"?>
<persistence version="2.0" xmlns = "http://java.sun.com/xml/ns/persistence" 
   xmlns:xsi = "http://www.w3.org/2001/XMLSchema-instance" 
   xsi:schemaLocation = "http://java.sun.com/xml/ns/persistence 
   http://java.sun.com/xml/ns/persistence/persistence_2_0.xsd">
   
   <persistence-unit name = "Eclipselink_JPA" transaction-type = "RESOURCE_LOCAL">
      <class>com.tutorialspoint.eclipselink.entity.Employee</class>
      
      <properties>
         <property name = "javax.persistence.jdbc.url" value = "jdbc:mysql://localhost:3306/jpadb"/>
         <property name = "javax.persistence.jdbc.user" value = "root"/>
         <property name = "javax.persistence.jdbc.password" value = "root"/>
         <property name = "javax.persistence.jdbc.driver" 
         value="com.mysql.jdbc.Driver"/>
         <property name = "eclipselink.logging.level" value = "FINE"/>
         <property name = "eclipselink.ddl-generation" 
         value="create-tables"/>
      </properties>
      
   </persistence-unit>
</persistence>

Classes de service

Ce module contient les classes de service, qui implémentent la partie de requête Criteria à l'aide de l'initialisation de l'API MetaData. Créez un package nommé‘com.tutorialspoint.eclipselink.service’. La classe nomméeCriteriaAPI.javaest créé sous un package donné. La classe DAO est représentée comme suit:

package com.tutorialspoint.eclipselink.service;

import java.util.List;

import javax.persistence.EntityManager;
import javax.persistence.EntityManagerFactory;
import javax.persistence.Persistence;
import javax.persistence.TypedQuery;
import javax.persistence.criteria.CriteriaBuilder;
import javax.persistence.criteria.CriteriaQuery;
import javax.persistence.criteria.Root;

import com.tutorialspoint.eclipselink.entity.Employee;

public class CriteriaApi {
   public static void main(String[] args) {
   
   EntityManagerFactory emfactory = Persistence.createEntityManagerFactory( "Eclipselink_JPA" );
   EntityManager entitymanager = emfactory.createEntityManager( );
   CriteriaBuilder criteriaBuilder = entitymanager.getCriteriaBuilder();
   CriteriaQuery<Object> criteriaQuery = criteriaBuilder.createQuery();
   Root<Employee> from = criteriaQuery.from(Employee.class);

   //select all records
   System.out.println(“Select all records”);
   CriteriaQuery<Object> select = c riteriaQuery.select(from);
   TypedQuery<Object> typedQuery = entitymanager.createQuery(select);
   List<Object> resultlist = typedQuery.getResultList();

   for(Object o:resultlist) {
      Employee e = (Employee)o;
      System.out.println("EID : " + e.getEid() + " Ename : " + e.getEname());
   }

   //Ordering the records 
   System.out.println(“Select all records by follow ordering”);
   CriteriaQuery<Object> select1 = criteriaQuery.select(from);
   select1.orderBy(criteriaBuilder.asc(from.get("ename")));
   TypedQuery<Object> typedQuery1 = entitymanager.createQuery(select);
   List<Object> resultlist1 = typedQuery1.getResultList();

   for(Object o:resultlist1){
      Employee e=(Employee)o;
      System.out.println("EID : " + e.getEid() + " Ename : " + e.getEname());
   }

   entitymanager.close( );
   emfactory.close( );
   }
}

Après la compilation et l'exécution du programme ci-dessus, vous obtiendrez la sortie dans le panneau de la console d'Eclipse IDE comme suit:

Select All records
EID : 401 Ename : Gopal
EID : 402 Ename : Manisha
EID : 403 Ename : Masthanvali
EID : 404 Ename : Satish
EID : 405 Ename : Krishna
EID : 406 Ename : Kiran
Select All records by follow Ordering
EID : 401 Ename : Gopal
EID : 406 Ename : Kiran
EID : 405 Ename : Krishna
EID : 402 Ename : Manisha
EID : 403 Ename : Masthanvali
EID : 404 Ename : Satish

↰ Previous page Next page ↱