JPA - Guida rapida

Qualsiasi applicazione aziendale esegue operazioni di database archiviando e recuperando grandi quantità di dati. Nonostante tutte le tecnologie disponibili per la gestione dello storage, gli sviluppatori di applicazioni normalmente hanno difficoltà a eseguire le operazioni del database in modo efficiente.

In genere, gli sviluppatori Java utilizzano molto codice o utilizzano il framework proprietario per interagire con il database, mentre utilizzando JPA, il carico di interazione con il database si riduce in modo significativo. Costituisce un ponte tra i modelli a oggetti (programma Java) e i modelli relazionali (programma database).

Mancate corrispondenze tra modelli relazionali e modelli a oggetti

Gli oggetti relazionali sono rappresentati in un formato tabulare, mentre i modelli a oggetti sono rappresentati in un grafico interconnesso di formato oggetto. Durante la memorizzazione e il recupero di un modello a oggetti da un database relazionale, si verifica una mancata corrispondenza dovuta ai seguenti motivi:

  • Granularity : Il modello a oggetti ha una maggiore granularità rispetto al modello relazionale.

  • Subtypes : I sottotipi (significa ereditarietà) non sono supportati da tutti i tipi di database relazionali.

  • Identity : Come il modello a oggetti, il modello relazionale non espone l'identità durante la scrittura dell'uguaglianza.

  • Associations : I modelli relazionali non possono determinare più relazioni mentre esaminano il modello di dominio degli oggetti.

  • Data navigation : La navigazione dei dati tra gli oggetti in una rete di oggetti è diversa in entrambi i modelli.

Cos'è JPA?

Java Persistence API è una raccolta di classi e metodi per archiviare in modo persistente grandi quantità di dati in un database fornito da Oracle Corporation.

Dove usare JPA?

Per ridurre l'onere di scrivere codici per la gestione degli oggetti relazionali, un programmatore segue il framework "JPA Provider", che consente una facile interazione con l'istanza del database. Qui il quadro richiesto è ripreso da JPA.

Storia JPA

Versioni precedenti di EJB, livello di persistenza definito combinato con livello di logica aziendale utilizzando l'interfaccia javax.ejb.EntityBean.

  • Durante l'introduzione di EJB 3.0, il livello di persistenza è stato separato e specificato come JPA 1.0 (Java Persistence API). Le specifiche di questa API sono state rilasciate insieme alle specifiche di JAVA EE5 l'11 maggio 2006 utilizzando JSR 220.

  • JPA 2.0 è stato rilasciato con le specifiche di JAVA EE6 il 10 dicembre 2009 come parte del Java Community Process JSR 317.

  • JPA 2.1 è stato rilasciato con la specifica di JAVA EE7 il 22 aprile 2013 utilizzando JSR 338.

Fornitori di JPA

JPA è un'API open source, quindi vari fornitori aziendali come Oracle, Redhat, Eclipse, ecc. Forniscono nuovi prodotti aggiungendo loro il sapore di persistenza JPA. Alcuni di questi prodotti includono:

Hibernate, Eclipselink, Toplink, Spring Data JPA, etc.

Java Persistence API è un'origine per archiviare entità aziendali come entità relazionali. Mostra come definire un PLAIN OLD JAVA OBJECT (POJO) come entità e come gestire entità con relazioni.

Architettura a livello di classe

L'immagine seguente mostra l'architettura a livello di classe di JPA. Mostra le classi e le interfacce principali di JPA.

La tabella seguente descrive ciascuna delle unità mostrate nell'architettura sopra.

Unità Descrizione
EntityManagerFactory Questa è una classe factory di EntityManager. Crea e gestisce più istanze di EntityManager.
EntityManager È un'interfaccia, gestisce le operazioni di persistenza sugli oggetti. Funziona come factory per l'istanza di Query.
Entity Le entità sono gli oggetti di persistenza, archiviati come record nel database.
EntityTransaction Ha una relazione uno a uno con EntityManager. Per ogni EntityManager, le operazioni vengono gestite dalla classe EntityTransaction.
Persistence Questa classe contiene metodi statici per ottenere l'istanza di EntityManagerFactory.
Query Questa interfaccia viene implementata da ciascun fornitore JPA per ottenere oggetti relazionali che soddisfano i criteri.

Le classi e le interfacce di cui sopra vengono utilizzate per memorizzare le entità in un database come record. Aiutano i programmatori riducendo i loro sforzi per scrivere codici per memorizzare dati in un database in modo che possano concentrarsi su attività più importanti come la scrittura di codici per mappare le classi con le tabelle del database.

Relazioni di classe JPA

Nell'architettura di cui sopra, le relazioni tra le classi e le interfacce appartengono al pacchetto javax.persistence. Il diagramma seguente mostra la relazione tra di loro.

  • La relazione tra EntityManagerFactory e EntityManager è one-to-many. È una classe factory per le istanze di EntityManager.

  • La relazione tra EntityManager e EntityTransaction è one-to-one. Per ogni operazione EntityManager, esiste un'istanza EntityTransaction.

  • La relazione tra EntityManager e Query è one-to-many. Molti numeri di query possono essere eseguiti utilizzando un'istanza di EntityManager.

  • La relazione tra EntityManager ed Entity è one-to-many. Un'istanza di EntityManager può gestire più entità.

La maggior parte delle applicazioni contemporanee utilizza database relazionali per archiviare i dati. Recentemente, molti fornitori sono passati al database degli oggetti per ridurre il loro carico di manutenzione dei dati. Significa che il database degli oggetti o le tecnologie relazionali degli oggetti si occupano di archiviare, recuperare, aggiornare e mantenere i dati. La parte centrale di questa tecnologia relazionale a oggetti è la mappatura dei file orm.xml. Poiché xml non richiede la compilazione, possiamo facilmente apportare modifiche a più origini dati con meno amministrazione.

Mappatura relazionale degli oggetti

Object Relational Mapping (ORM) ti dice brevemente cosa è ORM e come funziona. ORM è una capacità di programmazione per convertire i dati dal tipo di oggetto al tipo relazionale e viceversa.

La caratteristica principale di ORM è la mappatura o l'associazione di un oggetto ai suoi dati nel database. Durante la mappatura, dobbiamo considerare i dati, il tipo di dati e le sue relazioni con l'entità o le entità in qualsiasi altra tabella.

Funzionalità avanzate

  • Idiomatic persistence : Consente di scrivere le classi di persistenza utilizzando classi orientate agli oggetti.

  • High Performance : Ha molte tecniche di recupero e tecniche di blocco promettenti.

  • Reliable : È altamente stabile e utilizzato da molti programmatori professionisti.

Architettura ORM

L'architettura ORM appare come segue.

L'architettura di cui sopra spiega come i dati degli oggetti vengono archiviati nel database relazionale in tre fasi.

Fase 1

La prima fase, denominata object data phase, contiene classi POJO, interfacce di servizio e classi. È il livello del componente aziendale principale, che dispone di operazioni e attributi della logica aziendale.

Ad esempio, prendiamo un database dei dipendenti come schema.

  • La classe POJO dipendente contiene attributi come ID, nome, stipendio e designazione. Contiene anche metodi come setter e getter di questi attributi.

  • Le classi DAO / servizio dei dipendenti contengono metodi di servizio come crea dipendente, trova dipendente ed elimina dipendente.

Fase 2

La seconda fase, denominata come mapping o persistence phase, contiene provider JPA, file di mapping (ORM.xml), JPA Loader e Object Grid.

  • JPA Provider: È il prodotto del fornitore che contiene il sapore JPA (javax.persistence). Ad esempio Eclipselink, Toplink, Hibernate, ecc.

  • Mapping file : Il file di mappatura (ORM.xml) contiene la configurazione di mappatura tra i dati in una classe POJO e i dati in un database relazionale.

  • JPA Loader: Il caricatore JPA funziona come una memoria cache. Può caricare i dati della griglia relazionale. Funziona come una copia del database per interagire con le classi di servizio per i dati POJO (attributi della classe POJO).

  • Object Grid: È una posizione temporanea che può memorizzare una copia di dati relazionali, come una memoria cache. Tutte le query sul database vengono prima effettuate sui dati nella griglia degli oggetti. Solo dopo che è stato eseguito il commit, influisce sul database principale.

Fase 3

La terza fase è il relational data phase. Contiene i dati relazionali che sono collegati logicamente al componente aziendale. Come discusso in precedenza, solo quando il componente aziendale esegue il commit dei dati, vengono archiviati fisicamente nel database. Fino ad allora, i dati modificati vengono archiviati in una memoria cache come formato griglia. Il processo per ottenere i dati è identico a quello per la memorizzazione dei dati.

Il meccanismo dell'interazione programmatica delle tre fasi precedenti è chiamato come object relational mapping.

Mapping.xml

Il file mapping.xml serve a istruire il fornitore JPA di mappare le classi Entity con le tabelle del database.

Prendiamo un esempio di entità Employee che contiene quattro attributi. La classe POJO dell'entità Employee denominataEmployee.java è come segue:

public class Employee 
{
	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;
	}
}

Il codice sopra è la classe POJO dell'entità Employee. Contiene quattro attributieid, ename, salary, e deg. Considera questi attributi come i campi della tabella in una tabella eeidcome chiave primaria di questa tabella. Ora dobbiamo progettare il file di mappatura di ibernazione per esso. Il file di mapping denominatomapping.xml è come segue:

<? xml version="1.0" encoding="UTF-8" ?>
<entity-mappings xmlns="http://java.sun.com/xml/ns/persistence/orm"
    xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
    xsi:schemaLocation="http://java.sun.com/xml/ns/persistence/orm    
                        http://java.sun.com/xml/ns/persistence/orm_1_0.xsd"
                        version="1.0">
    <description> XML Mapping file</description>
    <entity class="Employee">        
        <table name="EMPLOYEETABLE"/>
        <attributes>
            <id name="eid">
                <generated-value strategy="TABLE"/>
            </id>
            <basic name="ename">
                <column name="EMP_NAME" length="100"/>
            </basic>
            <basic name="salary">
            </basic>
            <basic name="deg">
            </basic>
        </attributes>
    </entity>
</entity-mappings>

Lo script precedente viene utilizzato per mappare la classe entità con la tabella del database. In questo file

  • <entity-mappings> : tag definisce la definizione dello schema per consentire i tag di entità nel file xml.

  • <description> : tag fornisce una descrizione dell'applicazione.

  • <entity>: tag definisce la classe di entità che si desidera convertire in tabella in un database. La classe di attributi definisce il nome della classe di entità POJO.

  • <table>: tag definisce il nome della tabella. Se vuoi avere nomi identici sia per la classe che per la tabella, questo tag non è necessario.

  • <attributes> : tag definisce gli attributi (campi in una tabella).

  • <id>: tag definisce la chiave primaria della tabella. Il<generated-value> tag definisce come assegnare il valore della chiave primaria come Automatic, Manualo preso da Sequence.

  • <basic> : tag viene utilizzato per definire gli attributi rimanenti per la tabella.

  • <column-name> : tag viene utilizzato per definire i nomi dei campi della tabella definiti dall'utente nella tabella.

Annotazioni

In genere i file xml vengono utilizzati per configurare componenti specifici o mappare due diverse specifiche di componenti. Nel nostro caso, dobbiamo mantenere i file xml separatamente in un framework. Ciò significa che durante la scrittura di un file xml di mappatura, dobbiamo confrontare gli attributi della classe POJO con i tag di entità nel file mapping.xml.

Ecco la soluzione. Nella definizione della classe, possiamo scrivere la parte di configurazione utilizzando le annotazioni. Le annotazioni vengono utilizzate per classi, proprietà e metodi. Le annotazioni iniziano con il simbolo "@". Le annotazioni vengono dichiarate prima di una classe, una proprietà o un metodo. Tutte le annotazioni di JPA sono definite nel filejavax.persistence pacchetto.

Di seguito viene fornito un elenco delle annotazioni utilizzate nei nostri esempi.

Annotazione Descrizione
@Entità Dichiara la classe come entità o tabella.
@Tavolo Dichiara il nome della tabella.
@Di base Specifica esplicitamente i campi senza vincoli.
@Incorporato Specifica le proprietà della classe o di un'entità il cui valore è un'istanza di una classe incorporabile.
@Id Specifica la proprietà, utilizzare per l'identità (chiave primaria di una tabella) della classe.
@GeneratedValue Specifica come può essere inizializzato l'attributo di identità, ad esempio automatico, manuale o valore preso da una tabella di sequenza.
@Transient Specifica la proprietà che non è persistente, ovvero il valore non viene mai memorizzato nel database.
@Colonna Specifica l'attributo della colonna per la proprietà di persistenza.
@SequenceGenerator Specifica il valore per la proprietà specificata nell'annotazione @GeneratedValue. Crea una sequenza.
@TableGenerator Specifica il generatore di valori per la proprietà specificata nell'annotazione @GeneratedValue. Crea una tabella per la generazione di valore.
@AccessType Questo tipo di annotazione viene utilizzato per impostare il tipo di accesso. Se si imposta @AccessType (FIELD), l'accesso avviene in base al campo. Se si imposta @AccessType (PROPERTY), l'accesso avviene in base alle proprietà.
@JoinColumn Specifica un'associazione di entità o una raccolta di entità. Viene utilizzato nelle associazioni molti-a-uno e uno-a-molti.
@UniqueConstraint Specifica i campi e i vincoli univoci per la tabella primaria o secondaria.
@ColumnResult Fa riferimento al nome di una colonna nella query SQL utilizzando la clausola select.
@ManyToMany Definisce una relazione molti-a-molti tra le tabelle di join.
@ManyToOne Definisce una relazione molti-a-uno tra le tabelle di join.
@OneToMany Definisce una relazione uno-a-molti tra le tabelle di join.
@Uno a uno Definisce una relazione uno a uno tra le tabelle di join.
@NamedQueries specifica un elenco di query con nome.
@NamedQuery Specifica una query utilizzando un nome statico.

Java Bean Standard

La classe Java incapsula i valori dell'istanza e i loro comportamenti in una singola unità chiamata oggetto. Java Bean è una memoria temporanea e un componente riutilizzabile o un oggetto. È una classe serializzabile che ha un costruttore predefinito e metodi getter e setter per inizializzare individualmente gli attributi dell'istanza.

Convenzioni sui fagioli

  • Bean contiene il suo costruttore predefinito o un file che contiene un'istanza serializzata. Pertanto, un fagiolo può istanziare un altro fagiolo.

  • Le proprietà di un bean possono essere separate in proprietà booleane o proprietà non booleane.

  • La proprietà non booleana contiene getter e setter metodi.

  • La proprietà booleana contiene setter e is metodo.

  • Getter metodo di qualsiasi proprietà dovrebbe iniziare con lettere minuscole get(convenzione del metodo java) e ha continuato con un nome di campo che inizia con una lettera maiuscola. Ad esempio, il nome del campo èsalary quindi il metodo getter di questo campo è getSalary ().

  • Setter metodo di qualsiasi proprietà dovrebbe iniziare con lettere minuscole set (convenzione del metodo java), ha continuato con un nome di campo che inizia con una lettera maiuscola e il argument valueper impostare sul campo. Ad esempio, il nome del campo èsalary quindi il metodo setter di questo campo è setSalary ( double sal ).

  • Per la proprietà booleana, ismetodo per verificare se è vero o falso. Ad esempio la proprietà booleanaempty, il is metodo di questo campo è isEmpty ().

Questo capitolo illustra il processo di configurazione di JPA su sistemi basati su Windows e Linux. JPA può essere facilmente installato e integrato con il tuo attuale ambiente Java seguendo pochi semplici passaggi senza complesse procedure di configurazione. Durante l'installazione è richiesta l'amministrazione degli utenti.

Requisiti di sistema

JDK Java SE 2 JDK 1.5 o successivo
Memoria 1 GB di RAM (consigliato)
Spazio sul disco Nessun requisito minimo
Versione del sistema operativo Windows XP o successivo, Linux

Procediamo ora con i passaggi per installare JPA.

Passaggio 1: verifica l'installazione di Java

Prima di tutto, devi avere Java Software Development Kit (SDK) installato sul tuo sistema. Per verificarlo, esegui uno dei seguenti due comandi a seconda della piattaforma su cui stai lavorando.

Se l'installazione di Java è stata eseguita correttamente, verranno visualizzate la versione corrente e le specifiche dell'installazione di Java. Un output di esempio è fornito nella tabella seguente.

piattaforma Comando Output di esempio
finestre

Apri la console dei comandi e digita:

\>java –version

Versione Java "1.7.0_60"

Java (TM) SE Run Time Environment (build 1.7.0_60-b19)

VM server Java Hotspot (TM) a 64 bit (build 24.60-b09, modalità mista)

Linux

Apri il terminale di comando e digita:

$java –version

versione java "1.7.0_25"

Aprire JDK Runtime Environment (rhel-2.3.10.4.el6_4-x86_64)

Apri la VM server JDK a 64 bit (build 23.7-b01, modalità mista)

Passaggio 2: imposta il tuo ambiente Java

Impostare la variabile d'ambiente JAVA_HOME in modo che punti alla posizione della directory di base in cui Java è installato sulla macchina. Per esempio,

piattaforma Descrizione
finestre Imposta JAVA_HOME su C: \ ProgramFiles \ java \ jdk1.7.0_60
Linux Esporta JAVA_HOME = / usr / local / java-current

Aggiungi il percorso completo della posizione del compilatore Java al percorso di sistema.

piattaforma Descrizione
finestre Aggiungi la stringa "C: \ Program Files \ Java \ jdk1.7.0_60 \ bin" alla fine della variabile di sistema PATH.
Linux Esporta PATH = $ PATH: $ JAVA_HOME / bin /

Esegui il comando java -version dal prompt dei comandi come spiegato sopra.

Passaggio 3: installazione di JPA

È possibile eseguire l'installazione di JPA utilizzando uno qualsiasi dei provider JPA da questo tutorial, ad esempio Eclipselink, Hibernate. Seguiamo l'installazione di JPA utilizzando Eclipselink. Per la programmazione JPA, è necessario seguire il framework delle cartelle specifico, quindi è meglio utilizzare IDE.

Scarica il modulo IDE Eclipse seguendo il link https://www.eclipse.org/downloads/ Scegli lo sviluppatore EclipseIDE per JavaEE che è Eclipse indigo.

Decomprimere il file zip Eclipse nell'unità C. Apri Eclipse IDE.

Installazione di JPA utilizzando Eclipselink

Eclipselink è una libreria quindi non possiamo aggiungerla direttamente a Eclipse IDE. Per installare JPA utilizzando Eclipselink è necessario seguire i passaggi indicati di seguito.

  • Crea un nuovo progetto JPA selezionando File->New->JPA Project nell'IDE Eclipse come segue:

  • Otterrai una finestra di dialogo denominata New JPA Project. Inserisci il nome del progettotutorialspoint_JPA_Eclipselink, controlla il jre versione e fare clic su Avanti:

  • Fare clic su scarica libreria (se non si dispone della libreria) nella sezione libreria utente.

  • Selezionare l'ultima versione della libreria Eclipselink nella finestra di dialogo Scarica libreria e fare clic su Avanti come segue:

  • Accetta i termini della licenza e fai clic su Fine per scaricare la libreria.

  • 6. Il download inizia come mostrato nella seguente schermata.

  • Dopo il download, seleziona la libreria scaricata nella sezione libreria utente e fai clic su Fine.

  • Finalmente ottieni il file di progetto nel Package Explorerin Eclipse IDE. Estrai tutti i file, otterrai la cartella e la gerarchia dei file come segue:

Aggiunta del connettore MySQL a Project

Qualsiasi esempio di cui discutiamo qui richiede la connettività del database. Consideriamo il database MySQL per le operazioni di database. Richiede mysql-connector jar per interagire con un programma Java.

Segui i passaggi per configurare il file jar del database nel tuo progetto.

  • Vai alle proprietà del progetto ->Java Build Path facendo clic con il tasto destro su di esso. Si aprirà una finestra di dialogo come mostrato nella seguente schermata. Fare clic su Aggiungi vasi esterni.

  • Vai alla posizione del jar nella memoria di sistema, seleziona il file e fai clic su Apri.

  • Fare clic su ok nella finestra di dialogo delle proprietà. Otterrai il connettore MySQL Jar nel tuo progetto. Ora sei in grado di eseguire operazioni sul database utilizzando MySQL.

Questo capitolo utilizza un semplice esempio per dimostrare come funziona JPA. Consideriamo la gestione dei dipendenti come un esempio. Supponiamo che la gestione dei dipendenti crei, aggiorni, trovi ed elimini i record di un dipendente. Come accennato, stiamo utilizzando il database MySQL per le operazioni di database.

I moduli principali per questo esempio sono i seguenti:

  • Model or POJO

    Employee.java

  • Persistence

    Persistence.xml

  • Service

    CreatingEmployee.java

    UpdatingEmployee.java

    FindingEmployee.java

    DeletingEmployee.java

Prendiamo la gerarchia dei pacchetti che abbiamo utilizzato nell'installazione di JPA con Eclipselink. Segui la gerarchia per questo esempio come mostrato di seguito:

Creazione di entità

Le entità non sono altro che fagioli o modelli. In questo esempio, useremoEmployee come entità. eid, ename, salary, e degsono gli attributi di questa entità. Contiene un costruttore predefinito così come i metodi setter e getter di questi attributi.

Nella gerarchia mostrata sopra, crea un pacchetto denominato ‘com.tutorialspoint.eclipselink.entity’, sotto ‘src’Pacchetto (sorgente). Crea una classe denominataEmployee.java sotto dato pacchetto come segue:

package com.tutorialspoint.eclipselink.entity;

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

@Entity
@Table
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 + "]";
	}
}

Nel codice precedente, abbiamo utilizzato l'annotazione @Entity per rendere questa classe POJO un'entità.

Prima di passare al modulo successivo, dobbiamo creare un database per l'entità relazionale, che registrerà il database in persistence.xmlfile. Apri il workbench MySQL e digita hte dopo la query.

create database jpadb
use jpadb

Persistence.xml

Questo modulo gioca un ruolo cruciale nel concetto di JPA. In questo file xml registreremo il database e specificheremo la classe di entità.

Nella gerarchia del pacchetto mostrata sopra, persistence.xml in Pacchetto contenuto JPA è il seguente:

<?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>

Nell'xml sopra, <persistence-unit> tag è definito con un nome specifico per la persistenza JPA. Il<class>tag definisce la classe di entità con il nome del pacchetto. Il<properties> tag definisce tutte le proprietà e <property>tag definisce ogni proprietà come la registrazione del database, la specifica dell'URL, il nome utente e la password. Queste sono le proprietà di Eclipselink. Questo file configurerà il database.

Operazioni di persistenza

Le operazioni di persistenza vengono utilizzate per interagire con un database e lo sono load e storeoperazioni. In un componente aziendale, tutte le operazioni di persistenza rientrano nelle classi di servizio.

Nella gerarchia dei pacchetti mostrata sopra, creare un pacchetto denominato ‘com.tutorialspoint.eclipselink.service’, sotto ‘src’pacchetto (sorgente). Tutte le classi di servizio denominate CreateEmloyee.java, UpdateEmployee.java, FindEmployee.java e DeleteEmployee.java. rientra nel pacchetto fornito come segue:

Crea dipendente

Il seguente segmento di codice mostra come creare una classe Employee denominata CreateEmployee.java.

package com.tutorialspoint.eclipselink.service;

import javax.persistence.EntityManager;
import javax.persistence.EntityManagerFactory;
import javax.persistence.Persistence;
import com.tutorialspoint.eclipselink.entity.Employee;

public class CreateEmployee 
{
	public static void main( String[ ] args ) 
	{
		EntityManagerFactory emfactory = Persistence.
				createEntityManagerFactory( "Eclipselink_JPA" );
		EntityManager entitymanager = emfactory.
				createEntityManager( );
		entitymanager.getTransaction( ).begin( );
		
		Employee employee = new Employee( ); 
		employee.setEid( 1201 );
		employee.setEname( "Gopal" );
		employee.setSalary( 40000 );
		employee.setDeg( "Technical Manager" );
		entitymanager.persist( employee );
		entitymanager.getTransaction( ).commit( );
		
		entitymanager.close( );
		emfactory.close( );
	}
}

Nel codice sopra il file createEntityManagerFactory ()crea un'unità di persistenza fornendo lo stesso nome univoco che forniamo per unità di persistenza nel file persistent.xml. Ilentitymanagerfactory oggetto creerà il file entitymanger istanza utilizzando createEntityManager ()metodo. Ilentitymanager oggetto crea entitytransactionistanza per la gestione delle transazioni. Usandoentitymanager oggetto, possiamo rendere persistenti le entità nel database.

Dopo la compilazione e l'esecuzione del programma sopra, riceverai le notifiche dalla libreria eclipselink sul pannello della console di eclipse IDE.

Per il risultato, apri il workbench MySQL e digita le seguenti query.

use jpadb
select * from employee

La tabella del database interessata denominata employee sarà mostrato in un formato tabulare come segue:

Eid Ename Stipendio Deg
1201 Gopal 40000 Responsabile tecnico

Aggiorna dipendente

Per aggiornare i record di un dipendente, è necessario recuperare i record esistenti dal database, apportare modifiche e infine eseguire il commit nel database. La classe denominataUpdateEmployee.java è mostrato come segue:

package com.tutorialspoint.eclipselink.service;

import javax.persistence.EntityManager;
import javax.persistence.EntityManagerFactory;
import javax.persistence.Persistence;
import com.tutorialspoint.eclipselink.entity.Employee;

public class UpdateEmployee 
{
	public static void main( String[ ] args ) 
	{
		EntityManagerFactory emfactory = Persistence.
				createEntityManagerFactory( "Eclipselink_JPA" );
		EntityManager entitymanager = emfactory.
				createEntityManager( );
				entitymanager.getTransaction( ).begin( );
		Employee employee=entitymanager.
				find( Employee.class, 1201 );
		//before update
		System.out.println( employee );
		employee.setSalary( 46000 );
		entitymanager.getTransaction( ).commit( );
        //after update
		System.out.println( employee );
		entitymanager.close();
		emfactory.close();
	}
}

Dopo la compilazione e l'esecuzione del programma sopra, riceverai le notifiche dalla libreria Eclipselink sul pannello della console di eclipse IDE.

Per il risultato, apri il workbench MySQL e digita le seguenti query.

use jpadb
select * from employee

La tabella del database interessata denominata employee sarà mostrato in un formato tabulare come segue:

Eid Ename Stipendio Deg
1201 Gopal 46000 Responsabile tecnico

Lo stipendio del dipendente, 1201 viene aggiornato a 46000.

Trova dipendente

Per trovare i record di un dipendente, dovremo recuperare i dati esistenti dal database e visualizzarli. In questa operazione, EntityTransaction non viene applicato durante il recupero di un record.

La classe denominata FindEmployee.java come segue.

package com.tutorialspoint.eclipselink.service;

import javax.persistence.EntityManager;
import javax.persistence.EntityManagerFactory;
import javax.persistence.Persistence;
import com.tutorialspoint.eclipselink.entity.Employee;

public class FindEmployee 
{
	public static void main( String[ ] args ) 
	{
		EntityManagerFactory emfactory = Persistence
				.createEntityManagerFactory( "Eclipselink_JPA" );
		EntityManager entitymanager = emfactory.
				createEntityManager();
		Employee employee = entitymanager.
				find( Employee.class, 1201 );
		
		System.out.println("employee ID = "+employee.getEid( ));
		System.out.println("employee NAME = "+employee.getEname( ));
		System.out.println("employee SALARY = "+employee.getSalary( ));
		System.out.println("employee DESIGNATION = "+employee.getDeg( ));
	}
}

Dopo aver compilato ed eseguito il programma di cui sopra, otterrai il seguente output dalla libreria Eclipselink sul pannello della console di eclipse IDE.

employee ID = 1201
employee NAME = Gopal
employee SALARY = 46000.0
employee DESIGNATION = Technical Manager

Eliminazione del dipendente

Per eliminare i record di un dipendente, prima troveremo i record esistenti e poi li elimineremo. Qui EntityTransaction gioca un ruolo importante.

La classe denominata DeleteEmployee.java come segue:

package com.tutorialspoint.eclipselink.service;

import javax.persistence.EntityManager;
import javax.persistence.EntityManagerFactory;
import javax.persistence.Persistence;
import com.tutorialspoint.eclipselink.entity.Employee;

public class DeleteEmployee 
{
	public static void main( String[ ] args ) 
	{
		EntityManagerFactory emfactory = Persistence.
				createEntityManagerFactory( "Eclipselink_JPA" );
		EntityManager entitymanager = emfactory.
				createEntityManager( );
		entitymanager.getTransaction( ).begin( );
		Employee employee=entitymanager.
				find( Employee.class, 1201 );
		entitymanager.remove( employee );
		entitymanager.getTransaction( ).commit( );
		entitymanager.close( );
		emfactory.close( );
	}
}

Dopo la compilazione e l'esecuzione del programma sopra, riceverai le notifiche dalla libreria Eclipselink sul pannello della console di eclipse IDE.

Per il risultato, apri il workbench MySQL e digita le seguenti query.

use jpadb
select * from employee

Il database effettuato denominato employee avrà record nulli.

Dopo il completamento di tutti i moduli in questo esempio, il pacchetto e la gerarchia dei file appariranno come segue:

Questo capitolo descrive JPQL e come funziona con le unità di persistenza. In questo capitolo, gli esempi forniti seguono la stessa gerarchia dei pacchetti, che abbiamo usato nel capitolo precedente.

Linguaggio Java Persistence Query

JPQL è l'acronimo di Java Persistence Query Language. Viene utilizzato per creare query su entità da archiviare in un database relazionale. JPQL è sviluppato sulla base della sintassi SQL. Ma non influenzerà direttamente il database.

JPQL può recuperare i dati utilizzando la clausola SELECT, può eseguire aggiornamenti in blocco utilizzando la clausola UPDATE e la clausola DELETE.

Struttura della query

La sintassi JPQL è molto simile alla sintassi di SQL. Avere una sintassi simile a SQL è un vantaggio perché SQL è semplice e ampiamente utilizzato. SQL funziona direttamente con tabelle, record e campi di database relazionali, mentre JPQL funziona con classi e istanze Java.

Ad esempio, una query JPQL può recuperare un oggetto entità anziché un set di risultati di campo da un database, come con SQL. La struttura della query JPQL come segue.

SELECT ... FROM ...
[WHERE ...]
[GROUP BY ... [HAVING ...]]
[ORDER BY ...]

La struttura delle query JPQL DELETE e UPDATE è la seguente.

DELETE FROM ... [WHERE ...]
 
UPDATE ... SET ... [WHERE ...]

Funzioni scalari e aggregate

Le funzioni scalari restituiscono i valori risultanti in base ai valori di input. Le funzioni aggregate restituiscono i valori risultanti calcolando i valori di input.

Useremo lo stesso esempio di Gestione dei dipendenti del capitolo precedente. Qui esamineremo le classi di servizio utilizzando funzioni scalari e aggregate di JPQL.

Supponiamo che il file jpadb.employee tabella contiene i seguenti record.

Eid Ename Stipendio Deg
1201 Gopal 40000 Responsabile tecnico
1202 Manisha 40000 Lettore di bozze
1203 Masthanvali 40000 Scrittore tecnico
1204 Satish 30000 Scrittore tecnico
1205 Krishna 30000 Scrittore tecnico
1206 Kiran 35000 Lettore di bozze

Crea una classe denominata ScalarandAggregateFunctions.java sotto com.tutorialspoint.eclipselink.service pacchetto 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.Query;

public class ScalarandAggregateFunctions 
{
	public static void main( String[ ] args ) 
	{
		EntityManagerFactory emfactory = Persistence.
				createEntityManagerFactory( "Eclipselink_JPA" );
		EntityManager entitymanager = emfactory.
				createEntityManager();
		//Scalar function
		Query query = entitymanager.
		createQuery("Select UPPER(e.ename) from Employee e");
		List<String> list=query.getResultList();
		
		for(String e:list)
		{
			System.out.println("Employee NAME :"+e);
		}
		//Aggregate function
		Query query1 = entitymanager.
				createQuery("Select MAX(e.salary) from Employee e");
		Double result=(Double) query1.getSingleResult();
		System.out.println("Max Employee Salary :"+result);
	}
}

Dopo la compilazione e l'esecuzione del programma di cui sopra si otterrà il seguente output sul pannello della console di Eclipse IDE.

Employee NAME :GOPAL
Employee NAME :MANISHA
Employee NAME :MASTHANVALI
Employee NAME :SATISH
Employee NAME :KRISHNA
Employee NAME :KIRAN
ax Employee Salary :40000.0

Tra e, come parole chiave

Between, And, e Likesono le principali parole chiave di JPQL. Queste parole chiave vengono utilizzate dopoWhere clause in una query.

Crea una classe denominata BetweenAndLikeFunctions.java sotto com.tutorialspoint.eclipselink.service pacchetto 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.Query;
import com.tutorialspoint.eclipselink.entity.Employee;

public class BetweenAndLikeFunctions 
{
	public static void main( String[ ] args ) 
	{
		EntityManagerFactory emfactory = Persistence.
			createEntityManagerFactory( "Eclipselink_JPA" );
		EntityManager entitymanager = emfactory.
			createEntityManager();
		//Between
		Query query = entitymanager.
			createQuery( "Select e " +
					     "from Employee e " +
					     "where e.salary " +
					     "Between 30000 and 40000" )
		List<Employee> list=(List<Employee>)query.getResultList( );
		 
		for( Employee e:list )
		{
			System.out.print("Employee ID :"+e.getEid( ));
			System.out.println("\t Employee salary :"+e.getSalary( ));
		}
		
		//Like
		Query query1 = entitymanager.
			createQuery("Select e " +
					    "from Employee e " +
					    "where e.ename LIKE 'M%'");
		List<Employee> list1=(List<Employee>)query1.getResultList( );
		for( Employee e:list1 )
		{
			System.out.print("Employee ID :"+e.getEid( ));
			System.out.println("\t Employee name :"+e.getEname( ));
		}
	}
}

Dopo aver compilato ed eseguito il programma sopra, otterrai il seguente output nel pannello della console di Eclipse IDE.

Employee ID :1201	 Employee salary :40000.0
Employee ID :1202	 Employee salary :40000.0
Employee ID :1203	 Employee salary :40000.0
Employee ID :1204	 Employee salary :30000.0
Employee ID :1205	 Employee salary :30000.0
Employee ID :1206	 Employee salary :35000.0

Employee ID :1202	 Employee name :Manisha
Employee ID :1203	 Employee name :Masthanvali

Ordinazione

Per ordinare i record in JPQL, utilizziamo la clausola ORDER BY. L'utilizzo di questa clausola è lo stesso di SQL, ma riguarda le entità. L'esempio seguente mostra come utilizzare la clausola ORDER BY.

Crea un corso Ordering.java sotto com.tutorialspoint.eclipselink.service pacchetto 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.Query;
import com.tutorialspoint.eclipselink.entity.Employee;

public class Ordering 
{
	public static void main( String[ ] args ) 
	{
		EntityManagerFactory emfactory = Persistence.
			createEntityManagerFactory( "Eclipselink_JPA" );
		EntityManager entitymanager = emfactory.
			createEntityManager();
		//Between
		Query query = entitymanager.
			createQuery( "Select e " +
					     "from Employee e " +
					     "ORDER BY e.ename ASC" );
		List<Employee> list=(List<Employee>)query.getResultList( );
		 
		for( Employee e:list )
		{
			System.out.print("Employee ID :"+e.getEid( ));
			System.out.println("\t Employee Name :"+e.getEname( ));
		}
	}
}

compilando ed eseguendo il programma sopra, si produrrà il seguente output nel pannello della console dell'IDE di Eclipse.

Employee ID :1201	 Employee Name :Gopal
Employee ID :1206	 Employee Name :Kiran
Employee ID :1205	 Employee Name :Krishna
Employee ID :1202	 Employee Name :Manisha
Employee ID :1203	 Employee Name :Masthanvali
Employee ID :1204	 Employee Name :Satish

Query con nome

Un'annotazione @NamedQuery è definita come una query con una stringa di query predefinita che non può essere modificata. A differenza delle query dinamiche, le query con nome possono migliorare l'organizzazione del codice separando le stringhe di query JPQL da POJO. Passa anche i parametri di query anziché incorporare dinamicamente i letterali nella stringa di query e quindi produce query più efficienti.

Prima di tutto, aggiungi l'annotazione @NamedQuery alla classe di entità Employee denominata Employee.java sotto com.tutorialspoint.eclipselink.entity pacchetto come segue:

package com.tutorialspoint.eclipselink.entity;

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

@Entity
@Table
@NamedQuery(query = "Select e from Employee e where e.eid = :id", 
		name = "find employee by id")
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 + "]";
	}
}

Crea una classe denominata NamedQueries.java sotto com.tutorialspoint.eclipselink.service pacchetto 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.Query;
import com.tutorialspoint.eclipselink.entity.Employee;

public class NamedQueries 
{
	public static void main( String[ ] args ) 
	{
		EntityManagerFactory emfactory = Persistence.
			createEntityManagerFactory( "Eclipselink_JPA" );
		EntityManager entitymanager = emfactory.
			createEntityManager();
		Query query = entitymanager.createNamedQuery(
			"find employee by id");
		query.setParameter("id", 1204);
		List<Employee> list = query.getResultList( );
		for( Employee e:list )
		{
			System.out.print("Employee ID :"+e.getEid( ));
			System.out.println("\t Employee Name :"+e.getEname( ));
		}
	}
}

Dopo la compilazione e l'esecuzione del programma precedente, otterrai il seguente output nel pannello della console di Eclipse IDE.

Employee ID :1204	 Employee Name :Satish

Dopo aver aggiunto tutte le classi precedenti, la gerarchia dei pacchetti appare come segue:

Recupero desideroso e pigro

Il concetto più importante di JPA è creare una copia duplicata del database nella memoria cache. Durante le transazioni con un database, l'APP crea innanzitutto un set di dati duplicato e solo quando viene eseguito il commit utilizzando un gestore entità, le modifiche vengono effettuate nel database.

Esistono due modi per recuperare i record dal database.

Desideroso di recupero

Nel recupero desideroso, gli oggetti figlio correlati vengono caricati automaticamente durante il recupero di un particolare record.

Recupero pigro

Nella lettura lenta, gli oggetti correlati non vengono caricati automaticamente a meno che tu non li richieda specificamente. Prima di tutto, controlla la disponibilità degli oggetti correlati e notifica. Successivamente, se chiami uno dei metodi getter di quell'entità, vengono recuperati tutti i record.

Il recupero lento è possibile quando si tenta di recuperare i record per la prima volta. In questo modo, una copia dell'intero record è già archiviata nella memoria cache. Dal punto di vista delle prestazioni, è preferibile un recupero pigro.

JPA è una libreria rilasciata con specifiche Java. Pertanto, supporta tutti i concetti orientati agli oggetti per la persistenza dell'entità. Fino ad ora, abbiamo finito con le basi della mappatura relazionale degli oggetti. Questo capitolo ti guida attraverso le mappature avanzate tra oggetti ed entità relazionali.

Strategie di ereditarietà

L'ereditarietà è il concetto centrale di qualsiasi linguaggio orientato agli oggetti, quindi possiamo usare relazioni o strategie di ereditarietà tra entità. JPA supporta tre tipi di strategie di ereditarietà: SINGLE_TABLE, JOINED_TABLE e TABLE_PER_CONCRETE_CLASS.

Prendiamo in considerazione un esempio. Il diagramma seguente mostra tre classi, vale a dire. Staff, TeachingStaff e NonTeachingStaff e loro relazioni.

Nel diagramma sopra, Staff è un'entità, mentre TeachingStaff e NonTeachingStaff sono le sottoentità di Staff. Qui useremo l'esempio sopra per dimostrare tutte e tre le strategie di ereditarietà.

Strategia a tavolo unico

La strategia a tabella singola prende tutti i campi delle classi (sia super che sottoclassi) e li mappa in un'unica tabella nota come strategia SINGLE_TABLE. Qui il valore discriminatore gioca un ruolo chiave nel differenziare i valori di tre entità in una tabella.

Consideriamo l'esempio sopra. TeachingStaff e NonTeachingStaff sono le sottoclassi di Staff. Secondo il concetto di ereditarietà, una sottoclasse eredita le proprietà della sua superclasse. Quindi sid e sname sono i campi che appartengono sia a TeachingStaff che a NonTeachingStaff. Crea un progetto JPA. Tutti i moduli di questo progetto sono i seguenti:

Creazione di entità

Crea un pacchetto denominato ‘com.tutorialspoint.eclipselink.entity’ sotto ‘src’pacchetto. Crea una nuova classe java denominataStaff.javasotto dato pacchetto. La classe dell'entità Staff viene mostrata come segue:

package com.tutorialspoint.eclipselink.entity;

import java.io.Serializable;
import javax.persistence.DiscriminatorColumn;
import javax.persistence.Entity;
import javax.persistence.GeneratedValue;
import javax.persistence.GenerationType;
import javax.persistence.Id;
import javax.persistence.Inheritance;
import javax.persistence.InheritanceType;
import javax.persistence.Table;
@Entity
@Table
@Inheritance( strategy = InheritanceType.SINGLE_TABLE )
@DiscriminatorColumn( name="type" )
public class Staff implements Serializable 
{
	@Id
	@GeneratedValue( strategy = GenerationType.AUTO )
	private int sid;
	private String sname;
	public Staff( int sid, String sname ) 
	{
		super( );
		this.sid = sid;
		this.sname = sname;
	}
	public Staff( ) 
	{
		super( );
	}
	public int getSid( ) 
	{
		return sid;
	}
	public void setSid( int sid ) 
	{
		this.sid = sid;
	}
	public String getSname( ) 
	{
		return sname;
	}
	public void setSname( String sname ) 
	{
		this.sname = sname;
	}
}

Nel codice sopra @DescriminatorColumn specifica il nome del campo (type) ei suoi valori mostrano i campi rimanenti (Teaching e NonTeachingStaff).

Crea una sottoclasse (classe) alla classe Staff denominata TeachingStaff.java sotto il com.tutorialspoint.eclipselink.entitypacchetto. La classe TeachingStaff Entity è mostrata come segue:

package com.tutorialspoint.eclipselink.entity;

import javax.persistence.DiscriminatorValue;
import javax.persistence.Entity;

@Entity
@DiscriminatorValue( value="TS" )
public class TeachingStaff extends Staff 
{
	private String qualification;
	private String subjectexpertise;
	
	public TeachingStaff( int sid, String sname, 
			String qualification,String subjectexpertise ) 
	{
		super( sid, sname );
		this.qualification = qualification;
		this.subjectexpertise = subjectexpertise;
	}
	
	public TeachingStaff( ) 
	{
		super( );
	}

	public String getQualification( )
	{
		return qualification;
	}

	public void setQualification( String qualification )
	{
		this.qualification = qualification;
	}

	public String getSubjectexpertise( ) 
	{
		return subjectexpertise;
	}

	public void setSubjectexpertise( String subjectexpertise )
	{
		this.subjectexpertise = subjectexpertise;
	}
}

Crea una sottoclasse (classe) alla classe Staff denominata NonTeachingStaff.java sotto il com.tutorialspoint.eclipselink.entitypacchetto. La classe Entità NonTeachingStaff è mostrata come segue:

package com.tutorialspoint.eclipselink.entity;

import javax.persistence.DiscriminatorValue;
import javax.persistence.Entity;

@Entity
@DiscriminatorValue( value = "NS" )
public class NonTeachingStaff extends Staff 
{
	private String areaexpertise;

	public NonTeachingStaff( int sid, String sname, 
			String areaexpertise ) 
	{
		super( sid, sname );
		this.areaexpertise = areaexpertise;
	}

	public NonTeachingStaff( ) 
	{
		super( );
	}

	public String getAreaexpertise( ) 
	{
		return areaexpertise;
	}

	public void setAreaexpertise( String areaexpertise )
	{
		this.areaexpertise = areaexpertise;
	}
}

Persistence.xml

Persistence.xml contiene le informazioni di configurazione del database e le informazioni di registrazione delle classi di entità. Il file xml è 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.Staff</class>
		<class>com.tutorialspoint.eclipselink.entity.NonTeachingStaff</class>
		<class>com.tutorialspoint.eclipselink.entity.TeachingStaff</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>

Classe di servizio

Le classi di servizio sono la parte di implementazione del componente aziendale. Crea un pacchetto in‘src’ pacchetto denominato ‘com.tutorialspoint.eclipselink.service’.

Crea una classe denominata SaveClient.javanel pacchetto specificato per archiviare i campi delle classi Staff, TeachingStaff e NonTeachingStaff. La classe SaveClient è mostrata come segue:

package com.tutorialspoint.eclipselink.service;

import javax.persistence.EntityManager;
import javax.persistence.EntityManagerFactory;
import javax.persistence.Persistence;
import com.tutorialspoint.eclipselink.entity.NonTeachingStaff;
import com.tutorialspoint.eclipselink.entity.TeachingStaff;

public class SaveClient 
{
	public static void main( String[ ] args ) 
	{
		EntityManagerFactory emfactory = Persistence.
				createEntityManagerFactory( "Eclipselink_JPA" );
		EntityManager entitymanager = emfactory.
				createEntityManager( );
		entitymanager.getTransaction( ).begin( );
		
		//Teaching staff entity 
		TeachingStaff ts1=new TeachingStaff(
				1,"Gopal","MSc MEd","Maths");
		TeachingStaff ts2=new TeachingStaff(
				2, "Manisha", "BSc BEd", "English");
		//Non-Teaching Staff entity
		NonTeachingStaff nts1=new NonTeachingStaff(
				3, "Satish", "Accounts");
		NonTeachingStaff nts2=new NonTeachingStaff(
				4, "Krishna", "Office Admin");
		
		//storing all entities
		entitymanager.persist(ts1);
		entitymanager.persist(ts2);
		entitymanager.persist(nts1);
		entitymanager.persist(nts2);
		entitymanager.getTransaction().commit();
		entitymanager.close();
		emfactory.close();
	}
}

Dopo aver compilato ed eseguito il programma sopra riportato, riceverai le notifiche sul pannello della console di Eclipse IDE. Controlla il workbench di MySQL per l'output. L'output in formato tabulare è mostrato come segue:

Sid genere Sname Areaexpertise Qualificazione Competenza soggettiva
1 TS Gopal MSC MED Matematica
2 TS Manisha LETTO BSC Inglese
3 NS Satish Conti
4 NS Krishna Amministratore di Office

Finalmente otterrai una singola tabella contenente il campo di tutte e tre le classi con una colonna discriminatore denominata Type (campo).

Strategia tavolo unito

La strategia della tabella unita consiste nel condividere la colonna di riferimento che contiene valori univoci per unirsi alla tabella ed effettuare transazioni facili. Consideriamo lo stesso esempio di cui sopra.

Crea un progetto JPA. Di seguito sono riportati tutti i moduli del progetto.

Creazione di entità

Crea un pacchetto denominato ‘com.tutorialspoint.eclipselink.entity’ sotto ‘src’pacchetto. Crea una nuova classe java denominataStaff.javasotto dato pacchetto. La classe dell'entità Staff viene mostrata come segue:

package com.tutorialspoint.eclipselink.entity;

import java.io.Serializable;
import javax.persistence.Entity;
import javax.persistence.GeneratedValue;
import javax.persistence.GenerationType;
import javax.persistence.Id;
import javax.persistence.Inheritance;
import javax.persistence.InheritanceType;
import javax.persistence.Table;

@Entity
@Table
@Inheritance( strategy = InheritanceType.JOINED )
public class Staff implements Serializable 
{
	@Id
	@GeneratedValue( strategy = GenerationType.AUTO )
	private int sid;
	private String sname;
	public Staff( int sid, String sname ) 
	{
		super( );
		this.sid = sid;
		this.sname = sname;
	}
	public Staff( ) 
	{
		super( );
	}
	public int getSid( ) 
	{
		return sid;
	}
	public void setSid( int sid ) 
	{
		this.sid = sid;
	}
	public String getSname( ) 
	{
		return sname;
	}
	public void setSname( String sname ) 
	{
		this.sname = sname;
	}
}

Crea una sottoclasse (classe) alla classe Staff denominata TeachingStaff.java sotto il com.tutorialspoint.eclipselink.entitypacchetto. La classe TeachingStaff Entity è mostrata come segue:

package com.tutorialspoint.eclipselink.entity;

import javax.persistence.DiscriminatorValue;
import javax.persistence.Entity;

@Entity
@PrimaryKeyJoinColumn(referencedColumnName="sid")
public class TeachingStaff extends Staff 
{
	private String qualification;
	private String subjectexpertise;
	
	public TeachingStaff( int sid, String sname, 
			String qualification,String subjectexpertise ) 
	{
		super( sid, sname );
		this.qualification = qualification;
		this.subjectexpertise = subjectexpertise;
	}
	
	public TeachingStaff( ) 
	{
		super( );
		
	}

	public String getQualification( )
	{
		return qualification;
	}

	public void setQualification( String qualification )
	{
		this.qualification = qualification;
	}

	public String getSubjectexpertise( ) 
	{
		return subjectexpertise;
	}

	public void setSubjectexpertise( String subjectexpertise )
	{
		this.subjectexpertise = subjectexpertise;
	}
}

Crea una sottoclasse (classe) alla classe Staff denominata NonTeachingStaff.java sotto il com.tutorialspoint.eclipselink.entitypacchetto. La classe Entità NonTeachingStaff è mostrata come segue:

package com.tutorialspoint.eclipselink.entity;

import javax.persistence.DiscriminatorValue;
import javax.persistence.Entity;

@Entity
@PrimaryKeyJoinColumn(referencedColumnName="sid")
public class NonTeachingStaff extends Staff 
{
	private String areaexpertise;

	public NonTeachingStaff( int sid, String sname, 
			String areaexpertise ) 
	{
		super( sid, sname );
		this.areaexpertise = areaexpertise;
	}

	public NonTeachingStaff( ) 
	{
		super( );
	}

	public String getAreaexpertise( ) 
	{
		return areaexpertise;
	}

	public void setAreaexpertise( String areaexpertise )
	{
		this.areaexpertise = areaexpertise;
	}
}

Persistence.xml

Il file Persistence.xml contiene le informazioni di configurazione del database e le informazioni di registrazione delle classi di entità. Il file xml è 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.Staff</class>
	<class>com.tutorialspoint.eclipselink.entity.NonTeachingStaff</class>
	<class>com.tutorialspoint.eclipselink.entity.TeachingStaff</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>

Classe di servizio

Le classi di servizio sono la parte di implementazione del componente aziendale. Crea un pacchetto in‘src’ pacchetto denominato ‘com.tutorialspoint.eclipselink.service’.

Crea una classe denominata SaveClient.javasotto il pacchetto fornito per memorizzare i campi della classe Staff, TeachingStaff e NonTeachingStaff. Quindi la classe SaveClient viene mostrata come segue:

package com.tutorialspoint.eclipselink.service;

import javax.persistence.EntityManager;
import javax.persistence.EntityManagerFactory;
import javax.persistence.Persistence;
import com.tutorialspoint.eclipselink.entity.NonTeachingStaff;
import com.tutorialspoint.eclipselink.entity.TeachingStaff;

public class SaveClient 
{
	public static void main( String[ ] args ) 
	{
		EntityManagerFactory emfactory = Persistence.
				createEntityManagerFactory( "Eclipselink_JPA" );
		EntityManager entitymanager = emfactory.
				createEntityManager( );
		entitymanager.getTransaction( ).begin( );
		
		//Teaching staff entity 
		TeachingStaff ts1=new TeachingStaff(
				1,"Gopal","MSc MEd","Maths");
		TeachingStaff ts2=new TeachingStaff(
				2, "Manisha", "BSc BEd", "English");
		//Non-Teaching Staff entity
		NonTeachingStaff nts1=new NonTeachingStaff(
				3, "Satish", "Accounts");
		NonTeachingStaff nts2=new NonTeachingStaff(
		4, "Krishna", "Office Admin");
		
		//storing all entities
		entitymanager.persist(ts1);
		entitymanager.persist(ts2);
		entitymanager.persist(nts1);
		entitymanager.persist(nts2);
		
		entitymanager.getTransaction().commit();
		entitymanager.close();
		emfactory.close();
	}
}

Dopo aver compilato ed eseguito il programma sopra, riceverai notifiche nel pannello della console di Eclipse IDE. Per l'output, controlla MySQL workbench.

Qui vengono create tre tabelle e il risultato di staff tabella viene visualizzata in formato tabulare.

Sid Dtype Sname
1 Personale docente Gopal
2 Personale docente Manisha
3 NonTeachingStaff Satish
4 NonTeachingStaff Krishna

Il risultato di TeachingStaff la tabella viene visualizzata come segue:

Sid Qualificazione Competenza soggettiva
1 MSC MED Matematica
2 LETTO BSC Inglese

Nella tabella sopra sid è la chiave esterna (tabella del personale del modulo di campo di riferimento) Il risultato di NonTeachingStaff la tabella viene visualizzata come segue:

Sid Areaexpertise
3 Conti
4 Amministratore di Office

Infine, le tre tabelle vengono create utilizzando i rispettivi campi e il campo SID è condiviso da tutte e tre le tabelle. Nella tabella Staff, SID è la chiave primaria. Nelle restanti due tabelle (TeachingStaff e NonTeachingStaff), SID è la chiave esterna.

Tabella per strategia di classe

La strategia Tabella per classe consiste nel creare una tabella per ogni sottoentità. La tabella Staff verrà creata, ma conterrà valori nulli. I valori dei campi della tabella Staff devono essere condivisi dalle tabelle TeachingStaff e NonTeachingStaff.

Consideriamo lo stesso esempio di cui sopra.

Creazione di entità

Crea un pacchetto denominato ‘com.tutorialspoint.eclipselink.entity’ sotto ‘src’pacchetto. Crea una nuova classe java denominataStaff.javasotto dato pacchetto. La classe dell'entità Staff viene mostrata come segue:

package com.tutorialspoint.eclipselink.entity;

import java.io.Serializable;
import javax.persistence.Entity;
import javax.persistence.GeneratedValue;
import javax.persistence.GenerationType;
import javax.persistence.Id;
import javax.persistence.Inheritance;
import javax.persistence.InheritanceType;
import javax.persistence.Table;

@Entity
@Table
@Inheritance( strategy = InheritanceType.TABLE_PER_CLASS )
public class Staff implements Serializable 
{
	@Id
	@GeneratedValue( strategy = GenerationType.AUTO )
	private int sid;
	private String sname;
	public Staff( int sid, String sname ) 
	{
		super( );
		this.sid = sid;
		this.sname = sname;
	}
	public Staff( ) 
	{
		super( );
	}
	public int getSid( ) 
	{
		return sid;
	}
	public void setSid( int sid ) 
	{
		this.sid = sid;
	}
	public String getSname( ) 
	{
		return sname;
	}
	public void setSname( String sname ) 
	{
		this.sname = sname;
	}
}

Crea una sottoclasse (classe) alla classe Staff denominata TeachingStaff.java sotto il com.tutorialspoint.eclipselink.entitypacchetto. La classe TeachingStaff Entity è mostrata come segue:

package com.tutorialspoint.eclipselink.entity;

import javax.persistence.DiscriminatorValue;
import javax.persistence.Entity;

@Entity
public class TeachingStaff extends Staff 
{
	private String qualification;
	private String subjectexpertise;
	
	public TeachingStaff( int sid, String sname, 
			String qualification,String subjectexpertise ) 
	{
		super( sid, sname );
		this.qualification = qualification;
		this.subjectexpertise = subjectexpertise;
	}
	
	public TeachingStaff( ) 
	{
		super( );
		
	}

	public String getQualification( )
	{
		return qualification;
	}
	public void setQualification( String qualification )
	{
		this.qualification = qualification;
	}

	public String getSubjectexpertise( ) 
	{
		return subjectexpertise;
	}

	public void setSubjectexpertise( String subjectexpertise )
	{
		this.subjectexpertise = subjectexpertise;
	}
}

Crea una sottoclasse (classe) alla classe Staff denominata NonTeachingStaff.java sotto il com.tutorialspoint.eclipselink.entitypacchetto. La classe Entità NonTeachingStaff è mostrata come segue:

package com.tutorialspoint.eclipselink.entity;

import javax.persistence.DiscriminatorValue;
import javax.persistence.Entity;

@Entity
public class NonTeachingStaff extends Staff 
{
	private String areaexpertise;

	public NonTeachingStaff( int sid, String sname, 
			String areaexpertise )
			{
		super( sid, sname );
		this.areaexpertise = areaexpertise;
	}

	public NonTeachingStaff( ) 
	{
		super( );
	}

	public String getAreaexpertise( ) 
	{
		return areaexpertise;
	}

	public void setAreaexpertise( String areaexpertise )
	{
		this.areaexpertise = areaexpertise;
	}
}

Persistence.xml

Il file Persistence.xml contiene le informazioni di configurazione del database e le informazioni di registrazione delle classi di entità. Il file xml è 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.Staff</class>
	<class>com.tutorialspoint.eclipselink.entity.NonTeachingStaff</class>
	<class>com.tutorialspoint.eclipselink.entity.TeachingStaff</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>

Classe di servizio

Le classi di servizio sono la parte di implementazione del componente aziendale. Crea un pacchetto in‘src’ pacchetto denominato ‘com.tutorialspoint.eclipselink.service’.

Crea una classe denominata SaveClient.javanel pacchetto specificato per archiviare i campi delle classi Staff, TeachingStaff e NonTeachingStaff. La classe SaveClient è mostrata come segue:

package com.tutorialspoint.eclipselink.service;

import javax.persistence.EntityManager;
import javax.persistence.EntityManagerFactory;
import javax.persistence.Persistence;
import com.tutorialspoint.eclipselink.entity.NonTeachingStaff;
import com.tutorialspoint.eclipselink.entity.TeachingStaff;
public class SaveClient 
{
	public static void main( String[ ] args ) 
	{
		EntityManagerFactory emfactory = Persistence.
				createEntityManagerFactory( "Eclipselink_JPA" );
		EntityManager entitymanager = emfactory.
				createEntityManager( );
		entitymanager.getTransaction( ).begin( );
		
		//Teaching staff entity 
		TeachingStaff ts1=new TeachingStaff(
				1,"Gopal","MSc MEd","Maths");
		TeachingStaff ts2=new TeachingStaff(
				2, "Manisha", "BSc BEd", "English");
		//Non-Teaching Staff entity
		NonTeachingStaff nts1=new NonTeachingStaff(
				3, "Satish", "Accounts");
		NonTeachingStaff nts2=new NonTeachingStaff(
				4, "Krishna", "Office Admin");
		
		//storing all entities
		entitymanager.persist(ts1);
		entitymanager.persist(ts2);
		entitymanager.persist(nts1);
		entitymanager.persist(nts2);
		
		entitymanager.getTransaction().commit();
		entitymanager.close();
		emfactory.close();
	}
}

Dopo aver compilato ed eseguito il programma sopra, riceverai notifiche sul pannello della console di Eclipse IDE. Per l'output, controlla MySQL workbench.

Qui vengono create le tre tabelle e il file Staff tabella contiene record nulli.

Il risultato di TeachingStaff viene visualizzato come segue:

Sid Qualificazione Sname Competenza soggettiva
1 MSC MED Gopal Matematica
2 LETTO BSC Manisha Inglese

La tabella sopra TeachingStaff contiene i campi delle entità Staff e TeachingStaff.

Il risultato di NonTeachingStaff viene visualizzato come segue:

Sid Areaexpertise Sname
3 Conti Satish
4 Amministratore di Office Krishna

La tabella precedente NonTeachingStaff contiene i campi delle entità Staff e NonTeachingStaff.

Questo capitolo ti guida attraverso le relazioni tra le entità. Generalmente le relazioni sono più efficaci tra le tabelle nel database. Qui le classi di entità sono trattate come tabelle relazionali (concetto di JPA), quindi le relazioni tra le classi di entità sono le seguenti:

  • @ManyToOne Relation
  • @OneToMany Relation
  • @OneToOne Relation
  • @ManyToMany Relation

@ManyToOne Relation

Esiste una relazione molti-a-uno tra entità in cui si fa riferimento a un'entità (colonna o insieme di colonne) con un'altra entità (colonna o insieme di colonne) contenente valori univoci. Nei database relazionali, queste relazioni vengono applicate utilizzando la chiave esterna / chiave primaria tra le tabelle.

Consideriamo un esempio di relazione tra le entità Dipendente e Dipartimento. In modo unidirezionale, cioè da dipendente a reparto, è applicabile la relazione molti a uno. Ciò significa che ogni record di dipendente contiene un ID reparto, che dovrebbe essere una chiave primaria nella tabella Dipartimento. Qui nella tabella Employee, l'ID reparto è la chiave esterna.

Il diagramma seguente mostra la relazione molti-a-uno tra le due tabelle.

Crea un progetto JPA in eclipse IDE denominato JPA_Eclipselink_MTO. Tutti i moduli di questo progetto sono discussi di seguito.

Creazione di entità

Segui il diagramma sopra indicato per creare entità. Crea un pacchetto denominato‘com.tutorialspoin.eclipselink.entity’ sotto ‘src’pacchetto. Crea una classe denominataDepartment.javasotto dato pacchetto. L'entità Department della classe viene visualizzata 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 Department 
{
    @Id 
    @GeneratedValue( strategy=GenerationType.AUTO )
    private int id;
    private String name;

    public int getId() 
    {
    	return id;
    }
    
    public void setId(int id) 
    {
    	this.id = id;
    }
    
    public String getName( )
    {
    	return name;
    }
    
    public void setName( String deptName )
    {
    	this.name = deptName;
    }
}

Crea la seconda entità in questa relazione: la classe di entità Employee denominata Employee.java sotto ‘com.tutorialspoint.eclipselink.entity’pacchetto. La classe di entità 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;
import javax.persistence.ManyToOne;

@Entity
public class Employee 
{
	@Id
	@GeneratedValue( strategy= GenerationType.AUTO ) 	
	private int eid;
	private String ename;
	private double salary;
	private String deg;
	@ManyToOne
	private Department department;
	
	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;
	}
		
	public Department getDepartment() {
		return department;
	}

	public void setDepartment(Department department) {
		this.department = department;
	}
}

Persistence.xml

Il file Persistence.xml è necessario per configurare il database e la registrazione delle classi di entità.

Persitence.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>
	<class>com.tutorialspoint.eclipselink.entity.Department</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 relazionale utilizzando l'inizializzazione dell'attributo. Crea un pacchetto in‘src’ pacchetto denominato ‘com.tutorialspoint.eclipselink.service’. La classe DAO denominataManyToOne.javaviene creato in un determinato pacchetto. La classe DAO è mostrata come segue:

package com.tutorialspointeclipselink.service;

import javax.persistence.EntityManager;
import javax.persistence.EntityManagerFactory;
import javax.persistence.Persistence;
import com.tutorialspoint.eclipselink.entity.Department;
import com.tutorialspoint.eclipselink.entity.Employee;

public class ManyToOne 
{
	public static void main( String[ ] args ) 
	{
		EntityManagerFactory emfactory = Persistence.
				createEntityManagerFactory( "Eclipselink_JPA" );
		EntityManager entitymanager = emfactory.
				createEntityManager( );
		entitymanager.getTransaction( ).begin( );
		
		//Create Department Entity
		Department department = new Department();
		department.setName("Development");
		//Store Department
		entitymanager.persist(department);
		
		//Create Employee1 Entity
		Employee employee1 = new Employee();
		employee1.setEname("Satish");
		employee1.setSalary(45000.0);
		employee1.setDeg("Technical Writer");
		employee1.setDepartment(department);

		//Create Employee2 Entity
		Employee employee2 = new Employee();
		employee2.setEname("Krishna");
		employee2.setSalary(45000.0);
		employee2.setDeg("Technical Writer");
		employee2.setDepartment(department);

		//Create Employee3 Entity
		Employee employee3 = new Employee();
		employee3.setEname("Masthanvali");
		employee3.setSalary(50000.0);
		employee3.setDeg("Technical Writer");
		employee3.setDepartment(department);
		
		//Store Employees
		entitymanager.persist(employee1);
		entitymanager.persist(employee2);
		entitymanager.persist(employee3);
				
		entitymanager.getTransaction().commit();
		entitymanager.close();
		emfactory.close();
	}
}

Dopo aver compilato ed eseguito il programma sopra, riceverai notifiche sul pannello della console di Eclipse IDE. Per l'output, controlla MySQL workbench. In questo esempio, vengono create due tabelle.

Passa la seguente query nell'interfaccia MySQL e il risultato di Department la tabella verrà visualizzata come segue:

Select * from department
ID Nome
101 Sviluppo

Passa la seguente query nell'interfaccia MySQL e il risultato di Employee la tabella verrà visualizzata come segue.

Select * from employee
Eid Deg Ename Stipendio Department_Id
102 Scrittore tecnico Satish 45000 101
103 Scrittore tecnico Krishna 45000 101
104 Scrittore tecnico Masthanwali 50000 101

Nella tabella precedente Deparment_Id è la chiave esterna (campo di riferimento) dalla tabella Department.

@OneToMany Relation

In questa relazione, ogni riga di un'entità fa riferimento a molti record figlio in un'altra entità. La cosa importante è che i record figlio non possono avere più genitori. In una relazione uno-a-molti tra la tabella A e la tabella B, ogni riga nella tabella A può essere collegata a una o più righe nella tabella B.

Consideriamo l'esempio sopra. Supponiamo che le tabelle Employee e Department nell'esempio precedente siano collegate in modo unidirezionale inverso, quindi la relazione diventa una relazione uno-a-molti. Crea un progetto JPA in eclipse IDE denominatoJPA_Eclipselink_OTM. Tutti i moduli di questo progetto sono discussi di seguito.

Creazione di entità

Segui il diagramma sopra indicato per creare entità. Crea un pacchetto denominato‘com.tutorialspoin.eclipselink.entity’ sotto ‘src’pacchetto. Crea una classe denominataDepartment.javasotto dato pacchetto. L'entità Department della classe viene visualizzata come segue:

package com.tutorialspoint.eclipselink.entity;

import java.util.List;
import javax.persistence.Entity;
import javax.persistence.GeneratedValue;
import javax.persistence.GenerationType;
import javax.persistence.Id;
import javax.persistence.OneToMany;

@Entity
public class Department 
{
    @Id 
    @GeneratedValue( strategy=GenerationType.AUTO )
    private int id;
    private String name;
    
    @OneToMany( targetEntity=Employee.class )
    private List employeelist;

    public int getId() 
    {
    	return id;
    }
    
    public void setId(int id) 
    {
    	this.id = id;
    }
    
    public String getName( )
    {
    	return name;
    }
    
    public void setName( String deptName )
    {
    	this.name = deptName;
    }

    public List getEmployeelist() 
    {
	return employeelist;
    }

    public void setEmployeelist(List employeelist) 
    {
	this.employeelist = employeelist;
    }
}

Crea la seconda entità in questa relazione - Classe entità dipendente, denominata Employee.java sotto ‘com.tutorialspoint.eclipselink.entity’pacchetto. La classe di entità 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;
	}	
}

Persistence.xml

Il file persistence.xml è il seguente:

<?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>
	<class>com.tutorialspoint.eclipselink.entity.Department</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 relazionale utilizzando l'inizializzazione dell'attributo. Crea un pacchetto in‘src’ pacchetto denominato ‘com.tutorialspoint.eclipselink.service’. La classe DAO denominataOneToMany.javaviene creato in un determinato pacchetto. La classe DAO è mostrata come segue:

package com.tutorialspointeclipselink.service;

import java.util.List;
import java.util.ArrayList;
import javax.persistence.EntityManager;
import javax.persistence.EntityManagerFactory;
import javax.persistence.Persistence;
import com.tutorialspoint.eclipselink.entity.Department;
import com.tutorialspoint.eclipselink.entity.Employee;

public class OneToMany 
{
	public static void main(String[] args) 
	{
		EntityManagerFactory emfactory = Persistence.
				createEntityManagerFactory( "Eclipselink_JPA" );
		EntityManager entitymanager = emfactory.
				createEntityManager( );
		entitymanager.getTransaction( ).begin( );
		
		//Create Employee1 Entity
		Employee employee1 = new Employee();
		employee1.setEname("Satish");
		employee1.setSalary(45000.0);
		employee1.setDeg("Technical Writer");
								
		//Create Employee2 Entity
		Employee employee2 = new Employee();
		employee2.setEname("Krishna");
		employee2.setSalary(45000.0);
		employee2.setDeg("Technical Writer");
								
		//Create Employee3 Entity
		Employee employee3 = new Employee();
		employee3.setEname("Masthanvali");
		employee3.setSalary(50000.0);
		employee3.setDeg("Technical Writer");
		
		//Store Employee
		entitymanager.persist(employee1);
		entitymanager.persist(employee2);
		entitymanager.persist(employee3);
		
		//Create Employeelist
		List<Employee> emplist = new ArrayList();
		emplist.add(employee1);
		emplist.add(employee2);
		emplist.add(employee3);
		
		//Create Department Entity
		Department department= new Department();
		department.setName("Development");
		department.setEmployeelist(emplist);
				
		//Store Department
		entitymanager.persist(department);
		
		entitymanager.getTransaction().commit();
		entitymanager.close();
		emfactory.close();
	}
}

Dopo la compilazione e l'esecuzione del programma di cui sopra riceverai le notifiche nel pannello della console di Eclipse IDE. Per l'output controllare il workbench MySQL come segue.

In questo progetto vengono create tre tabelle. Passa la seguente query nell'interfaccia MySQL e il risultato della tabella department_employee verrà visualizzato come segue:

Select * from department_Id;
Department_ID Employee_Eid
254 251
254 252
254 253

Nella tabella sopra, deparment_id e employee_id sono le chiavi esterne (campi di riferimento) dalle tabelle di reparto e dipendente.

Passa la seguente query nell'interfaccia MySQL e il risultato della tabella di reparto verrà visualizzato in un formato tabulare come segue.

Select * from department;
ID Nome
254 Sviluppo

Passa la seguente query nell'interfaccia MySQL e il risultato della tabella dei dipendenti verrà visualizzato come segue:

Select * from employee;
Eid Deg Ename Stipendio
251 Scrittore tecnico Satish 45000
252 Scrittore tecnico Krishna 45000
253 Scrittore tecnico Masthanwali 50000

@OneToOne Relation

Nella relazione uno a uno, un elemento può essere collegato solo a un altro elemento. Significa che ogni riga di un'entità è riferita a una e solo una riga di un'altra entità.

Consideriamo l'esempio sopra. Employee e Departmentin modo unidirezionale inverso, la relazione è una relazione uno-a-uno. Significa che ogni dipendente appartiene a un solo dipartimento. Crea un progetto JPA in eclipse IDE denominatoJPA_Eclipselink_OTO. Tutti i moduli di questo progetto sono discussi di seguito.

Creazione di entità

Segui il diagramma sopra indicato per creare entità. Crea un pacchetto denominato‘com.tutorialspoin.eclipselink.entity’ sotto ‘src’pacchetto. Crea una classe denominataDepartment.javasotto dato pacchetto. L'entità Department della classe viene visualizzata 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 Department 
{
    @Id 
    @GeneratedValue( strategy=GenerationType.AUTO )
    private int id;
    private String name;
   
    public int getId() 
    {
    	return id;
    }
    
    public void setId(int id) 
    {
    	this.id = id;
    }
    
    public String getName( )
    {
    	return name;
    }
    
    public void setName( String deptName )
    {
    	this.name = deptName;
    }
}

Crea la seconda entità in questa relazione - Classe entità dipendente, denominata Employee.java sotto ‘com.tutorialspoint.eclipselink.entity’pacchetto. La classe di entità 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;
import javax.persistence.OneToOne;

@Entity
public class Employee 
{
	@Id
	@GeneratedValue( strategy= GenerationType.AUTO ) 	
	private int eid;
	private String ename;
	private double salary;
	private String deg;
	
	@OneToOne
	private Department department;
		
	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;
	}

	public Department getDepartment() 
	{
		return department;
	}

	public void setDepartment(Department department) 
	{
		this.department = department;
	}	
}

Persistence.xml

Persistence.xml 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>
	<class>com.tutorialspoint.eclipselink.entity.Department</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

Crea un pacchetto in ‘src’ pacchetto denominato ‘com.tutorialspoint.eclipselink.service’. La classe DAO denominataOneToOne.javaviene creato nel pacchetto specificato. La classe DAO è mostrata come segue:

package com.tutorialspointeclipselink.service;

import javax.persistence.EntityManager;
import javax.persistence.EntityManagerFactory;
import javax.persistence.Persistence;
import com.tutorialspoint.eclipselink.entity.Department;
import com.tutorialspoint.eclipselink.entity.Employee;

public class OneToOne 
{
	public static void main(String[] args) 
	{
		EntityManagerFactory emfactory = Persistence.
				createEntityManagerFactory( "Eclipselink_JPA" );
		EntityManager entitymanager = emfactory.
				createEntityManager( );
		entitymanager.getTransaction( ).begin( );
		
		//Create Department Entity
		Department department = new Department();
		department.setName("Development");
		
		//Store Department
		entitymanager.persist(department);
		
		//Create Employee Entity
		Employee employee = new Employee();
		employee.setEname("Satish");
		employee.setSalary(45000.0);
		employee.setDeg("Technical Writer");
		employee.setDepartment(department);
		
		//Store Employee
		entitymanager.persist(employee);
		
		entitymanager.getTransaction().commit();
		entitymanager.close();
		emfactory.close();
	}
}

Dopo la compilazione e l'esecuzione del programma di cui sopra riceverai le notifiche nel pannello della console di Eclipse IDE. Per l'output, controlla il workbench MySQL come segue.

Nell'esempio precedente, vengono create due tabelle. Passa la seguente query nell'interfaccia MySQL e il risultato della tabella del reparto verrà visualizzato come segue:

Select * from department
ID Nome
301 Sviluppo

Passa la seguente query nell'interfaccia MySQL e il risultato di employee la tabella verrà visualizzata come segue:

Select * from employee
Eid Deg Ename Stipendio Department_id
302 Scrittore tecnico Satish 45000 301

@ManyToMany Relation

La relazione molti-a-molti è il punto in cui una o più righe di un'entità sono associate a più righe di un'altra entità.

Consideriamo un esempio di relazione tra due entità: Class e Teacher. In modo bidirezionale, sia la classe che l'insegnante hanno una relazione molti-a-uno. Ciò significa che ogni record di Classe viene indicato dal set Insegnante (ID insegnante), che dovrebbe essere chiavi primarie nella tabella Insegnante e memorizzato nella tabella Insegnante_Classe e viceversa. Qui, la tabella Teachers_Class contiene entrambi i campi della chiave esterna. Crea un progetto JPA in eclipse IDE denominatoJPA_Eclipselink_MTM. Tutti i moduli di questo progetto sono discussi di seguito.

Creazione di entità

Crea entità seguendo lo schema mostrato nel diagramma sopra. Crea un pacchetto denominato‘com.tutorialspoin.eclipselink.entity’ sotto ‘src’pacchetto. Crea una classe denominataClas.javasotto dato pacchetto. L'entità Department della classe viene visualizzata come segue:

package com.tutorialspoint.eclipselink.entity;

import java.util.Set;
import javax.persistence.Entity;
import javax.persistence.GeneratedValue;
import javax.persistence.GenerationType;
import javax.persistence.Id;
import javax.persistence.ManyToMany;

@Entity
public class Clas 
{
	@Id
	@GeneratedValue( strategy = GenerationType.AUTO )
	private int cid;
	private String cname;
	
	@ManyToMany(targetEntity=Teacher.class)
	private Set teacherSet;
	
	public Clas() 
	{
		super();
	}
	public Clas(int cid, 
			String cname, Set teacherSet) 
	{
		super();
		this.cid = cid;
		this.cname = cname;
		this.teacherSet = teacherSet;
	}
	public int getCid() 
	{
		return cid;
	}
	public void setCid(int cid) 
	{
		this.cid = cid;
	}
	public String getCname() 
	{
		return cname;
	}
	public void setCname(String cname) 
	{
		this.cname = cname;
	}
	public Set getTeacherSet() 
	{
		return teacherSet;
	}
	public void setTeacherSet(Set teacherSet) 
	{
		this.teacherSet = teacherSet;
	}	  
}

Crea la seconda entità in questa relazione - Classe entità dipendente, denominata Teacher.java sotto ‘com.tutorialspoint.eclipselink.entity’pacchetto. La classe di entità Employee viene mostrata come segue:

package com.tutorialspoint.eclipselink.entity;

import java.util.Set;
import javax.persistence.Entity;
import javax.persistence.GeneratedValue;
import javax.persistence.GenerationType;
import javax.persistence.Id;
import javax.persistence.ManyToMany;

@Entity
public class Teacher 
{
	@Id
	@GeneratedValue( strategy = GenerationType.AUTO )
	private int tid;
	private String tname;
	private String subject;
	
	@ManyToMany(targetEntity=Clas.class)
	private Set clasSet;
	
	public Teacher() 
	{
		super();
	}
	public Teacher(int tid, String tname, String subject, 
			Set clasSet) 
	{
		super();
		this.tid = tid;
		this.tname = tname;
		this.subject = subject;
		this.clasSet = clasSet;
	}
	public int getTid() 
	{
		return tid;
	}
	public void setTid(int tid) 
	{
		this.tid = tid;
	}
	public String getTname() 
	{
		return tname;
	}
	public void setTname(String tname) 
	{
		this.tname = tname;
	}
	public String getSubject() 
	{
		return subject;
	}
	public void setSubject(String subject) 
	{
		this.subject = subject;
	}
	public Set getClasSet() 
	{
		return clasSet;
	}
	public void setClasSet(Set clasSet) 
	{
		this.clasSet = clasSet;
	}
}

Persistence.xml

Persistence.xml 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>
	<class>com.tutorialspoint.eclipselink.entity.Department</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

Crea un pacchetto in ‘src’ pacchetto denominato ‘com.tutorialspoint.eclipselink.service’. La classe DAO denominataManyToMany.javaviene creato in un determinato pacchetto. La classe DAO è mostrata come segue:

package com.tutorialspoint.eclipselink.service;

import java.util.HashSet;
import java.util.Set;
import javax.persistence.EntityManager;
import javax.persistence.EntityManagerFactory;
import javax.persistence.Persistence;
import com.tutorialspoint.eclipselink.entity.Clas;
import com.tutorialspoint.eclipselink.entity.Teacher;

public class ManyToMany 
{
	public static void main(String[] args) 
	{
		EntityManagerFactory emfactory = Persistence.
				createEntityManagerFactory( "Eclipselink_JPA" );
		EntityManager entitymanager = emfactory.
				createEntityManager( );
		entitymanager.getTransaction( ).begin( );
		
		//Create Clas Entity
		Clas clas1=new Clas(0,"1st",null);
		Clas clas2=new Clas(0,"2nd",null);
		Clas clas3=new Clas(0,"3rd",null);
		
		//Store Clas
		entitymanager.persist(clas1);
		entitymanager.persist(clas2);
		entitymanager.persist(clas3);
		
		//Create Clas Set1
		Set<Clas> classSet1 = new HashSet();
		classSet1.add(clas1);
		classSet1.add(clas2);
		classSet1.add(clas3);
		
		//Create Clas Set2
		Set<Clas> classSet2 = new HashSet();
		classSet2.add(clas3);
		classSet2.add(clas1);
		classSet2.add(clas2);
				
		//Create Clas Set3
		Set<Clas> classSet3 = new HashSet();
		classSet3.add(clas2);
		classSet3.add(clas3);
		classSet3.add(clas1);
		
		//Create Teacher Entity
		Teacher teacher1 = new Teacher(0,
				"Satish","Java",classSet1);
		Teacher teacher2 = new Teacher(0,
				"Krishna","Adv Java",classSet2);
		Teacher teacher3 = new Teacher(0,
				"Masthanvali","DB2",classSet3);
		
		//Store Teacher
		entitymanager.persist(teacher1);
		entitymanager.persist(teacher2);
		entitymanager.persist(teacher3);
		
		entitymanager.getTransaction( ).commit( );
		entitymanager.close( );
		emfactory.close( );
	}
}

In questo progetto di esempio vengono create tre tabelle. Passa la seguente query nell'interfaccia MySQL e il risultato della tabella teacher_clas verrà visualizzato come segue:

Select * form teacher_clas
Teacher_tid Classet_cid
354 351
355 351
356 351
354 352
355 352
356 352
354 353
355 353
356 353

Nella tabella sopra teacher_tid è la chiave esterna dalla tabella insegnante e classet_cidè la chiave esterna dalla tabella di classe. Pertanto, diversi insegnanti sono assegnati a classi diverse.

Passa la seguente query nell'interfaccia MySQL e il risultato della tabella insegnante verrà visualizzato come segue:

Select * from teacher
Tid Soggetto Tname
354 Giava Satish
355 Adv Java Krishna
356 DB2 Masthanvali

Passa la seguente query nell'interfaccia MySQL e il risultato di clas la tabella verrà visualizzata come segue:

Select * from clas
Cid Cname
351 1 °
352 2 °
353 3 °

Criteria è un'API predefinita utilizzata per definire le query per le entità. È un 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 di Criteria API è che gli errori possono essere rilevati prima durante la fase di 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

I criteri sono inclusi in tutte le versioni dell'APP, pertanto ogni fase dei criteri viene notificata nelle specifiche dell'APP.

  • 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

I criteri e il JPQL sono strettamente correlati e possono essere progettati utilizzando operatori simili nelle loro query. Seguejavax.persistence.criteriapacchetto 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.

  • EntityManager istanza viene utilizzata per creare un oggetto CriteriaBuilder.

  • CriteriaQueryistanza viene utilizzata per creare un oggetto query. Gli attributi di questo oggetto query verranno modificati con i dettagli della query.

  • CriteriaQuery.form viene chiamato il metodo per impostare la radice della query.

  • CriteriaQuery.select viene chiamato per impostare il tipo di elenco dei risultati.

  • TypedQuery<T> istanza viene utilizzata per preparare una query per l'esecuzione e specificare il tipo di risultato della query.

  • getResultListsull'oggetto TypedQuery <T> 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 reader

Crea un progetto JPA nell'IDE di eclipse denominato JPA_Eclipselink_Criteria. Tutti i moduli di questo progetto sono discussi di seguito:

Creazione di entità

Crea un pacchetto denominato com.tutorialspoint.eclipselink.entity sotto ‘src’

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 è il seguente:

<?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 =criteriaQuery.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 aver compilato ed eseguito il programma precedente, otterrai il seguente output nel pannello della console di Eclipse IDE.

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