JPA - Criteri API
L'API dei criteri è un'API predefinita utilizzata per definire le query per le entità. È il modo alternativo per definire una query JPQL. Queste query sono indipendenti dai tipi, portabili e facili da modificare cambiando la sintassi. Simile a JPQL, segue uno schema astratto (schema facile da modificare) e oggetti incorporati. L'API dei metadati è mescolata con l'API dei criteri per modellare l'entità persistente per le query dei criteri.
Il vantaggio principale dell'API dei criteri è che gli errori possono essere rilevati prima durante la compilazione. Le query JPQL basate su stringa e le query basate su criteri JPA sono le stesse in termini di prestazioni ed efficienza.
Storia dei criteri API
L'API dei criteri è inclusa in tutte le versioni di JPA, pertanto ogni fase dell'API dei criteri viene notificata nelle specifiche di JPA.
- In JPA 2.0, l'API di query dei criteri, viene sviluppata la standardizzazione delle query.
- In JPA 2.1, sono inclusi l'aggiornamento e l'eliminazione dei criteri (aggiornamento in blocco ed eliminazione).
Struttura della query dei criteri
L'API Criteria e il JPQL sono strettamente correlati e possono progettare utilizzando operatori simili nelle loro query. Segue il pacchetto javax.persistence.criteria per progettare una query. La struttura della query indica la query dei criteri di sintassi.
La seguente query con criteri semplici restituisce tutte le istanze della classe di entità nell'origine dati.
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 query mostra i passaggi di base per creare un criterio.
- L' istanza di EntityManager viene utilizzata per creare un oggetto CriteriaBuilder .
- L' istanza CriteriaQuery viene utilizzata per creare un oggetto query. Gli attributi di questo oggetto query verranno modificati con i dettagli della query.
- Il metodo CriteriaQuery.from viene chiamato per impostare la radice della query.
- CriteriaQuery.select viene chiamato per impostare il tipo di elenco dei risultati.
- L'istanza di TypedQuery <T> viene utilizzata per preparare una query per l'esecuzione e per specificare il tipo di risultato della query.
- getResultList metodo sul <T> TypedQuery oggetto per eseguire una query. Questa query restituisce una raccolta di entità, il risultato viene archiviato in un elenco.
Esempio di criteri API
Consideriamo l'esempio del database dei dipendenti. Supponiamo che la tabella jpadb.employee contenga i seguenti record:
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 readerCrea un progetto JPA nell'IDE di eclipse denominato JPA_Eclipselink_Criteria. Tutti i moduli di questo progetto sono mostrati come segue:
Creazione di entità
Crea un pacchetto denominato com.tutorialspoint.eclipselink.entity sotto ‘src’ pacchetto.
Crea una classe denominata Employee.javasotto dato pacchetto. L'entità classe Employee viene mostrata come segue:
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
Il file Persistence.xml è necessario per configurare il database e la registrazione delle classi di entità.
Persistence.xml verrà creato dall'IDE eclipse durante la creazione di un progetto JPA. I dettagli di configurazione sono le specifiche dell'utente. Il file persistence.xml viene mostrato come segue:
<?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>Classi di servizio
Questo modulo contiene le classi di servizio, che implementa la parte della query Criteria utilizzando l'inizializzazione dell'API MetaData. Crea un pacchetto denominato‘com.tutorialspoint.eclipselink.service’. La classe denominataCriteriaAPI.javaviene creato in un determinato pacchetto. La classe DAO è mostrata come segue:
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( );
}
}Dopo la compilazione e l'esecuzione del programma di cui sopra, otterrai l'output nel pannello della console dell'IDE Eclipse come segue:
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