JPA - Entity Managers


Advertisements

In diesem Kapitel verwendung wird ein einfaches Beispiel, um zu zeigen, wie JPA funktioniert. Betrachten wir Mitarbeitermanagement als Beispiel. Angenommen, das Mitarbeitermanagement erstellt, aktualisiert, findet und löscht die Datensätze eines Mitarbeiters. Wie bereits erwähnt, sind wir mit MySQL-Datenbank für Datenbankoperationen.

Die Hauptmodule für dieses Beispiel sind wie folgt:

  • Modell oder POJO

    Employee.java

  • Persistenz

    persistence.xml

  • Service

    CreatingEmployee.java

    UpdatingEmployee.java

    FindingEmployee.java

    DeletingEmployee.java

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

Pakethierarchie

Erstellen von Entitäten

Entities sind nichts als Bohnen oder Modellen. In diesem Beispiel werden wir zu verwenden. Mitarbeiter als Entität. eid, ename esalary und deg sind die Attribute dieser Entität. Es enthält eine Standard-Konstruktor ebenso gut wie Setter und Getter-Methoden dieser Attribute.

In der oben gezeigten Hierarchie, erstellen Sie ein Paket mit dem Namen 'com.tutorialspoint.eclipselink.entity' unter 'src' (Quelle)-Paket. Erstellen Sie eine Klasse mit dem Namen Employee.java unter gegebenen 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 + "]";
   }
}

In dem obigen Code, haben wir verwendet @Entity Annotation, um dieses POJO Klasse wie eine Entität zu machen.

Vor gehen dem nächsten Modul wir müssen zu schaffen Datenbank für relationale Entität welche registrieren wird die Datenbank in persistence.xml Datei .Öffnen MySQL Workbench und Art folgende Abfrage.

create database jpadb
use jpadb

Persistence.xml

Dieses Modul spielt eine entscheidende Rolle im Konzept des JPA. In dieser XML-Datei werden wir die Datenbank zu registrieren und die Entity-Klasse.

In der oben gezeigten Pakethierarchie ,persistence.xml unter JPA content paket ist 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>

Im obigen xml, & lt; Persistenz-Einheit & gt; -Tag wird mit einem bestimmten Namen für JPA Persistenz definiert. Die & lt; Klasse & gt; tag definiert Entity-Klasse mit Paketnamen. Die & lt; Eigenschaften & gt; tag definiert alle Eigenschaften und & lt; Eigenschaft & gt; tag definiert jede Eigenschaft wie Datenbank-Registrierung, URL-Spezifikation, Benutzername und Passwort. Dies sind die Eclipselink Eigenschaften. Diese Datei wird die Datenbank konfigurieren.

Persistenz Operationen

Persistenz Operationen werden für die Interaktion mit einer Datenbank verwendet und sie sind Last und Shop -Operationen. In einer Business-Komponente, fallen alle Persistenz Operationen unter Persistenz-Service-Klassen.

In der oben gezeigten Pakethierarchie, erstellen Sie ein Paket mit dem Namen 'com.tutorialspoint.eclipselink.service' unter 'src' (Quelle)-Paket. Alle Serviceklassen als CreateEmloyee.java, UpdateEmployee.java, FindEmployee.java und DeleteEmployee.java benannt. kommt unter den gegebenen Paket wie folgt:

Mitarbeiter anlegen

Das folgende Codesegment zeigt, wie ein Mitarbeiter-Klasse mit dem Namen CreateEmployee.java erstellen.

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

In dem obigen Code createEntityManagerFactory () erstellt eine Persistenzeinheit durch die Bereitstellung der gleichen eindeutigen Namen,welche wir liefern für Ausdauer-Einheit in persistent.xml Datei. DieEntityManagerFactory Objekt wird erstellt die entitymanger Beispiel durch unter Verwendung createEntityManager () -Methode. Die EntityManager -Objekt erstellt EntityTransaction -Instanz für das Transaktionsmanagement. Durch die Verwendung von EntityManager -Objekt, können wir Entitäten in die Datenbank fortbestehen.

Nach der Kompilierung und Ausführung des oben genannten Programms werden Sie Benachrichtigungen von Eclipselink Bibliothek auf dem Konsolenfeld von Eclipse IDE zu bekommen.

für Ergebnis, öffnen Sie die MySQL Workbench und typ Sie die folgenden Abfragen.

use jpadb
select * from employee

Die betroffen Datenbanktabelle mit dem Namen Mitarbeiter werden in einem Tabellenformat wie folgt dargestellt werden:

Eid Ename Salary Deg
1201 Gopal 40000 Technical Manager

Update Mitarbeiter

Um die Datensätze eines Mitarbeiters zu aktualisieren, müssen wir die vorhandenen Datensätze zu abzurufen, die Datenbank zu bilden, Änderungen vornehmen und schließlich begehen es in die Datenbank. Die Klasse mit dem Namen UpdateEmployee.java wird wie folgt dargestellt:

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 der Kompilierung und Ausführung des oben genannten Programms werden Sie Benachrichtigungen von Eclipselink Bibliothek auf dem Konsolenfeld von Eclipse IDE zu bekommen.

für Ergebnis, öffnen Sie die MySQL Workbench und geben Sie die folgenden Abfragen.

use jpadb
select * from employee

Die Datenbanktabelle erfolgt mit dem Namen Mitarbeiter werden in einem Tabellenformat wie folgt dargestellt werden:

Eid Ename Salary Deg
1201 Gopal 46000 Technical Manager

Die Gage der Mitarbeiter, 1201 ist auf 46000 aktualisiert.

Suchen Mitarbeiter

Um die Datensätze von einem Mitarbeiter zu finden, müssen wir die vorhandenen Daten aus der Datenbank abrufen und anzeigen. In diesem Betrieb wird EntityTransaction nicht während Abrufen eines Datensatzes angewendet.

Die Klasse mit dem Namen 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 der Kompilierung und Ausführung des oben genannten Programms werden Sie Benachrichtigungen von Eclipselink Bibliothek auf dem Konsolenfeld von Eclipse IDE zu bekommen.

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

Löschen Mitarbeiter

Um die Datensätze eines Mitarbeiters zu löschen, werden wir die bestehenden Datensätze zu finden und dann löschen. Hier EntityTransaction spielt eine wichtige Rolle.

Die Klasse mit dem Namen 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 der Kompilierung und Ausführung des oben genannten Programms werden Sie Benachrichtigungen von Eclipselink Bibliothek auf dem Konsolenfeld von Eclipse IDE zu bekommen.

für Ergebnis, öffnen Sie die MySQL Workbench und geben Sie die folgenden Abfragen.

use jpadb
select * from employee

Die betroffen Datenbank mit dem Namen Mitarbeiter wird haben null Datensätze.

Nach Abschluss aller Module in diesem Beispiel sieht wie folgt aus das Paket und Dateihierarchie:

Modules
Advertisements