JPA - Gestori di entità

Questo capitolo ti guida attraverso un semplice esempio con JPA. Consideriamo la gestione dei dipendenti come esempio. Significa che la gestione dei dipendenti crea, aggiorna, trova ed elimina un dipendente. Come accennato in precedenza, 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 di seguito:

Creazione di entità

Le entità non sono altro che bean o modelli, in questo esempio useremo Employee come entità. eid, ename, salary, e degsono gli attributi di questa entità. Contiene metodi predefiniti di costruttore, 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 sopra, abbiamo usato l'annotazione @Entity per rendere questa classe POJO come 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 query come segue:

create database jpadb
use jpadb

Persistence.xml

Questo modulo svolge 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 precedente, il tag <persistence-unit> è definito con un nome specifico per la persistenza JPA. Il tag <class> definisce la classe di entità con il nome del pacchetto. Il tag <properties> definisce tutte le proprietà e il tag <property> 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 contro il database e lo sono load e storeoperazioni. In una 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

Creazione di una classe Employee denominata come CreateEmployee.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 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. L'oggetto entitymanagerfactory creerà l'istanza entitymanger utilizzandocreateEntityManager ()metodo. L'oggetto entitymanager crea l'istanza entitytransaction per la gestione delle transazioni. Utilizzando l'oggetto entitymanager, 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 verrà mostrato in un formato tabulare come segue:

Eid	Ename	Stipendio	Deg
1201	Gopal	40000	Responsabile tecnico

Aggiorna dipendente

Per aggiornare un dipendente, dobbiamo ottenere il database del modulo di registrazione, apportare modifiche e infine eseguirne il commit. 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 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 verrà 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 un dipendente otterremo il record dal database e lo visualizzeremo. In questa operazione, EntityTransaction non è coinvolta nessuna transazione non viene applicata 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 la compilazione e l'esecuzione del programma precedente, otterrai l'output dalla libreria Eclipselink sul pannello della console dell'IDE di eclipse come segue:

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

Eliminazione del dipendente

Per eliminare un dipendente, prima troveremo il record e poi lo 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 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, la gerarchia del pacchetto e dei file viene mostrata come segue: