JPA - Entity Manager

Dieses Kapitel führt Sie durch ein einfaches Beispiel mit JPA. Betrachten wir als Beispiel die Mitarbeiterführung. Dies bedeutet, dass die Mitarbeiterverwaltung einen Mitarbeiter erstellt, aktualisiert, findet und löscht. Wie oben erwähnt, verwenden wir die MySQL-Datenbank für Datenbankoperationen.

Die Hauptmodule für dieses Beispiel lauten wie folgt:

• Model or POJO

  Employee.java

• Persistence

  Persistence.xml

• Service

  CreatingEmployee.java

  UpdatingEmployee.java

  FindingEmployee.java

  DeletingEmployee.java

Nehmen wir die Pakethierarchie, die wir in der JPA-Installation mit Eclipselink verwendet haben. Folgen Sie der Hierarchie für dieses Beispiel wie folgt:

Entitäten erstellen

Entitäten sind nichts anderes als Beans oder Models. In diesem Beispiel werden wir verwenden Employee als Einheit. eid, ename, salary, und degsind die Attribute dieser Entität. Es enthält Standardmethoden für Konstruktor, Setter und Getter dieser Attribute.

Erstellen Sie in der oben gezeigten Hierarchie ein Paket mit dem Namen ‘com.tutorialspoint.eclipselink.entity’unter ‘src’(Quell-) Paket. Erstellen Sie eine Klasse mit dem NamenEmployee.java unter gegebenem Paket wie folgt:

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

Im obigen Code haben wir die Annotation @Entity verwendet, um diese POJO-Klasse als Entität zu erstellen.

Bevor wir zum nächsten Modul gehen, müssen wir eine Datenbank für eine relationale Entität erstellen, in der die Datenbank registriert wird persistence.xmlDatei. Öffnen Sie die MySQL-Workbench und geben Sie die Abfrage wie folgt ein:

create database jpadb
use jpadb

Persistence.xml

Dieses Modul spielt eine entscheidende Rolle im Konzept der JPA. In dieser XML-Datei registrieren wir die Datenbank und geben die Entitätsklasse an.

In der oben gezeigten Pakethierarchie lautet persistence.xml unter JPA Content package wie folgt:

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

In der obigen XML-Datei wird das Tag <persistence-unit> mit einem bestimmten Namen für die JPA-Persistenz definiert. Das <class> -Tag definiert die Entitätsklasse mit dem Paketnamen. Das Tag <properties> definiert alle Eigenschaften, und das Tag <property> definiert jede Eigenschaft wie Datenbankregistrierung, URL-Angabe, Benutzername und Kennwort. Dies sind die Eclipselink-Eigenschaften. Diese Datei konfiguriert die Datenbank.

Persistenzoperationen

Persistenzoperationen werden für die Datenbank verwendet und sind es auch load und storeOperationen. In einer Geschäftskomponente fallen alle Persistenzvorgänge unter Serviceklassen.

Erstellen Sie in der oben gezeigten Pakethierarchie ein Paket mit dem Namen ‘com.tutorialspoint.eclipselink.service’unter ‘src’(Quell-) Paket. Alle Serviceklassen mit den Namen CreateEmloyee.java, UpdateEmployee.java, FindEmployee.java und DeleteEmployee.java. fällt unter das angegebene Paket wie folgt:

Mitarbeiter erstellen

Erstellen einer Mitarbeiterklasse mit dem Namen CreateEmployee.java wie folgt:

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( );
   }
}

Im obigen Code ist die createEntityManagerFactory ()Erstellt eine Persistenz-Einheit, indem derselbe eindeutige Name angegeben wird, den wir für die Persistenz-Einheit in der Datei persistent.xml angeben. Das entitymanagerfactory-Objekt erstellt die entitymanger-Instanz mithilfe voncreateEntityManager ()Methode. Das Entitymanager-Objekt erstellt eine Entity-Transaktionsinstanz für die Transaktionsverwaltung. Durch die Verwendung des Entitymanager-Objekts können Entitäten in der Datenbank beibehalten werden.

Nach dem Kompilieren und Ausführen des obigen Programms erhalten Sie Benachrichtigungen von der Eclipselink-Bibliothek im Konsolenfenster der Eclipse-IDE.

Öffnen Sie als Ergebnis die MySQL-Workbench und geben Sie die folgenden Abfragen ein.

use jpadb
select * from employee

Die betroffene Datenbanktabelle mit dem Namen employee wird in tabellarischer Form wie folgt angezeigt:

Eid	Ename	Gehalt	Deg
1201	Gopal	40000	Technischer Manager

Mitarbeiter aktualisieren

Um einen Mitarbeiter zu aktualisieren, müssen wir die Datensatzformulardatenbank abrufen, Änderungen vornehmen und sie schließlich festschreiben. Die benannte KlasseUpdateEmployee.java wird wie folgt gezeigt:

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();
   }
}

Nach dem Kompilieren und Ausführen des obigen Programms erhalten Sie Benachrichtigungen von der Eclipselink-Bibliothek im Konsolenfenster der Eclipse-IDE.

Öffnen Sie als Ergebnis die MySQL-Workbench und geben Sie die folgenden Abfragen ein.

use jpadb
select * from employee

Die betroffene Datenbanktabelle mit dem Namen employee wird in tabellarischer Form wie folgt angezeigt:

Eid	Ename	Gehalt	Deg
1201	Gopal	46000	Technischer Manager

Das Gehalt des Mitarbeiters 1201 wird auf 46000 aktualisiert.

Mitarbeiter finden

Um einen Mitarbeiter zu finden, erhalten wir einen Datensatz aus der Datenbank und zeigen ihn an. Bei diesem Vorgang ist EntityTransaction nicht beteiligt. Beim Abrufen eines Datensatzes wird keine Transaktion angewendet.

Die benannte Klasse FindEmployee.java wie folgt.

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( ));
   }
}

Nach dem Kompilieren und Ausführen des obigen Programms erhalten Sie die Ausgabe der Eclipselink-Bibliothek auf dem Konsolenfeld der Eclipse-IDE wie folgt:

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

Mitarbeiter löschen

Um einen Mitarbeiter zu löschen, suchen wir zuerst den Datensatz und löschen ihn dann. Hier spielt EntityTransaction eine wichtige Rolle.

Die benannte Klasse DeleteEmployee.java wie folgt:

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( );
   }
}

Nach dem Kompilieren und Ausführen des obigen Programms erhalten Sie Benachrichtigungen von der Eclipselink-Bibliothek im Konsolenfenster der Eclipse-IDE.

Öffnen Sie als Ergebnis die MySQL-Workbench und geben Sie die folgenden Abfragen ein.

use jpadb
select * from employee

Die betroffene Datenbank mit dem Namen employee wird null Datensätze haben.

Nach Abschluss aller Module in diesem Beispiel wird die Paket- und Dateihierarchie wie folgt angezeigt: