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) |
Si presume che i lettori di questo tutorial abbiano Java SDK versione 1.7.0_60 installato sul proprio sistema.
Se non disponi di Java SDK, scarica la versione corrente da http://www.oracle.com/technetwork/java/javase/downloads/index.html e averlo installato.
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