JPA - Kurzanleitung

Jede Unternehmensanwendung führt Datenbankoperationen durch, indem sie große Datenmengen speichert und abruft. Trotz aller verfügbaren Technologien für das Speichermanagement haben Anwendungsentwickler normalerweise Schwierigkeiten, Datenbankoperationen effizient auszuführen.

Im Allgemeinen verwenden Java-Entwickler viel Code oder verwenden das proprietäre Framework für die Interaktion mit der Datenbank, während sich bei Verwendung von JPA die Belastung für die Interaktion mit der Datenbank erheblich verringert. Es bildet eine Brücke zwischen Objektmodellen (Java-Programm) und relationalen Modellen (Datenbankprogramm).

Nichtübereinstimmungen zwischen relationalen und Objektmodellen

Relationale Objekte werden in einem Tabellenformat dargestellt, während Objektmodelle in einem miteinander verbundenen Diagramm des Objektformats dargestellt werden. Beim Speichern und Abrufen eines Objektmodells aus einer relationalen Datenbank tritt aus folgenden Gründen eine gewisse Nichtübereinstimmung auf:

• Granularity : Das Objektmodell ist granularer als das relationale Modell.

• Subtypes : Subtypen (bedeutet Vererbung) werden nicht von allen Arten relationaler Datenbanken unterstützt.

• Identity : Wie das Objektmodell enthüllt das relationale Modell beim Schreiben von Gleichheit keine Identität.

• Associations : Relationale Modelle können beim Betrachten des Objektdomänenmodells nicht mehrere Beziehungen bestimmen.

• Data navigation : Die Datennavigation zwischen Objekten in einem Objektnetzwerk ist in beiden Modellen unterschiedlich.

Was ist JPA?

Die Java Persistence API ist eine Sammlung von Klassen und Methoden zum dauerhaften Speichern der großen Datenmengen in einer Datenbank, die von der Oracle Corporation bereitgestellt wird.

Wo kann man JPA verwenden?

Um die Last des Schreibens von Codes für die Verwaltung relationaler Objekte zu verringern, folgt ein Programmierer dem 'JPA Provider'-Framework, das eine einfache Interaktion mit der Datenbankinstanz ermöglicht. Hier wird das erforderliche Framework von JPA übernommen.

JPA-Geschichte

Frühere Versionen von EJB, definierte Persistenzschicht kombiniert mit Geschäftslogikschicht unter Verwendung der Schnittstelle javax.ejb.EntityBean.

• Bei der Einführung von EJB 3.0 wurde die Persistenzschicht getrennt und als JPA 1.0 (Java Persistence API) angegeben. Die Spezifikationen dieser API wurden zusammen mit den Spezifikationen von JAVA EE5 am 11. Mai 2006 unter Verwendung von JSR 220 veröffentlicht.

• JPA 2.0 wurde mit den Spezifikationen von JAVA EE6 am 10. Dezember 2009 als Teil von Java Community Process JSR 317 veröffentlicht.

• JPA 2.1 wurde am 22. April 2013 mit der Spezifikation JAVA EE7 unter Verwendung von JSR 338 veröffentlicht.

JPA-Anbieter

JPA ist eine Open-Source-API. Daher bieten verschiedene Unternehmensanbieter wie Oracle, Redhat, Eclipse usw. neue Produkte an, indem sie ihnen die JPA-Persistenz hinzufügen. Einige dieser Produkte umfassen:

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

Die Java Persistence API ist eine Quelle zum Speichern von Geschäftsentitäten als relationale Entitäten. Es zeigt, wie Sie ein PLAIN OLD JAVA OBJECT (POJO) als Entität definieren und Entitäten mit Beziehungen verwalten.

Architektur auf Klassenebene

Das folgende Bild zeigt die Architektur auf Klassenebene von JPA. Es zeigt die Kernklassen und Schnittstellen von JPA.

In der folgenden Tabelle werden die in der obigen Architektur gezeigten Einheiten beschrieben.

Einheiten	Beschreibung
EntityManagerFactory	Dies ist eine Factory-Klasse von EntityManager. Es erstellt und verwaltet mehrere EntityManager-Instanzen.
EntityManager	Es ist eine Schnittstelle, die die Persistenzoperationen für Objekte verwaltet. Es funktioniert wie Factory für die Abfrageinstanz.
Entity	Entitäten sind die Persistenzobjekte, die als Datensätze in der Datenbank gespeichert werden.
EntityTransaction	Es besteht eine Eins-zu-Eins-Beziehung zu EntityManager. Für jeden EntityManager werden Vorgänge von der EntityTransaction-Klasse verwaltet.
Persistence	Diese Klasse enthält statische Methoden zum Abrufen der EntityManagerFactory-Instanz.
Query	Diese Schnittstelle wird von jedem JPA-Anbieter implementiert, um relationale Objekte zu erhalten, die die Kriterien erfüllen.

Die obigen Klassen und Schnittstellen werden zum Speichern von Entitäten in einer Datenbank als Datensatz verwendet. Sie helfen Programmierern, indem sie weniger Anstrengungen unternehmen, um Codes zum Speichern von Daten in einer Datenbank zu schreiben, damit sie sich auf wichtigere Aktivitäten wie das Schreiben von Codes zum Zuordnen der Klassen zu Datenbanktabellen konzentrieren können.

JPA-Klassenbeziehungen

In der obigen Architektur gehören die Beziehungen zwischen den Klassen und Schnittstellen zum Paket javax.persistence. Das folgende Diagramm zeigt die Beziehung zwischen ihnen.

• Die Beziehung zwischen EntityManagerFactory und EntityManager ist one-to-many. Es ist eine Factory-Klasse für EntityManager-Instanzen.

• Die Beziehung zwischen EntityManager und EntityTransaction ist one-to-one. Für jede EntityManager-Operation gibt es eine EntityTransaction-Instanz.

• Die Beziehung zwischen EntityManager und Query ist one-to-many. Viele Abfragen können mit einer EntityManager-Instanz ausgeführt werden.

• Die Beziehung zwischen EntityManager und Entity ist one-to-many. Eine EntityManager-Instanz kann mehrere Entitäten verwalten.

Die meisten modernen Anwendungen verwenden relationale Datenbanken zum Speichern von Daten. In letzter Zeit haben viele Anbieter auf Objektdatenbanken umgestellt, um die Datenpflege zu entlasten. Dies bedeutet, dass Objektdatenbanken oder objektrelationale Technologien das Speichern, Abrufen, Aktualisieren und Verwalten von Daten übernehmen. Der Kern dieser objektrelationalen Technologie ist die Zuordnung von orm.xml-Dateien. Da für XML keine Kompilierung erforderlich ist, können wir mit weniger Verwaltungsaufwand problemlos Änderungen an mehreren Datenquellen vornehmen.

Objektrelationale Zuordnung

In Object Relational Mapping (ORM) erfahren Sie kurz, was ORM ist und wie es funktioniert. ORM ist eine Programmierfunktion zum Verdecken von Daten vom Objekttyp zum relationalen Typ und umgekehrt.

Das Hauptmerkmal von ORM ist das Zuordnen oder Binden eines Objekts an seine Daten in der Datenbank. Bei der Zuordnung müssen wir die Daten, den Datentyp und ihre Beziehungen zu Selbstentitäten oder Entitäten in einer anderen Tabelle berücksichtigen.

Erweiterte Funktionen

• Idiomatic persistence : Sie können die Persistenzklassen mit objektorientierten Klassen schreiben.

• High Performance : Es hat viele Abruftechniken und hoffnungsvolle Verriegelungstechniken.

• Reliable : Es ist sehr stabil und wird von vielen professionellen Programmierern verwendet.

ORM-Architektur

Die ORM-Architektur sieht wie folgt aus.

Die obige Architektur erklärt, wie Objektdaten in drei Phasen in einer relationalen Datenbank gespeichert werden.

Phase 1

Die erste Phase, benannt als object data phase, enthält POJO-Klassen, Dienstschnittstellen und Klassen. Es ist die Hauptschicht der Geschäftskomponenten, die Geschäftslogikoperationen und -attribute aufweist.

Nehmen wir zum Beispiel eine Mitarbeiterdatenbank als Schema.

• Die POJO-Klasse für Mitarbeiter enthält Attribute wie ID, Name, Gehalt und Bezeichnung. Es enthält auch Methoden wie Setter und Getter dieser Attribute.

• Mitarbeiter-DAO / Service-Klassen enthalten Servicemethoden wie Mitarbeiter erstellen, Mitarbeiter suchen und Mitarbeiter löschen.

Phase 2

Die zweite Phase mit dem Namen mapping oder persistence phase, enthält JPA-Provider, Mapping-Datei (ORM.xml), JPA Loader und Object Grid.

• JPA Provider: Es ist das Herstellerprodukt, das die JPA-Variante (javax.persistence) enthält. Zum Beispiel Eclipselink, Toplink, Hibernate usw.

• Mapping file : Die Zuordnungsdatei (ORM.xml) enthält die Zuordnungskonfiguration zwischen den Daten in einer POJO-Klasse und den Daten in einer relationalen Datenbank.

• JPA Loader: Der JPA-Loader funktioniert wie ein Cache-Speicher. Es kann die relationalen Gitterdaten laden. Es funktioniert wie eine Kopie der Datenbank, um mit Serviceklassen für POJO-Daten (Attribute der POJO-Klasse) zu interagieren.

• Object Grid: Dies ist ein temporärer Speicherort, an dem eine Kopie relationaler Daten wie ein Cache-Speicher gespeichert werden kann. Alle Abfragen für die Datenbank werden zuerst für die Daten im Objektraster ausgeführt. Erst nachdem es festgeschrieben wurde, wirkt es sich auf die Hauptdatenbank aus.

Phase 3

Die dritte Phase ist die relational data phase. Es enthält die relationalen Daten, die logisch mit der Geschäftskomponente verbunden sind. Wie oben erläutert, werden die Daten nur dann physisch in der Datenbank gespeichert, wenn die Geschäftskomponente die Daten festschreibt. Bis dahin werden die geänderten Daten als Grid-Format in einem Cache-Speicher gespeichert. Der Vorgang des Erhaltens der Daten ist identisch mit dem des Speicherns der Daten.

Der Mechanismus der programmatischen Wechselwirkung der obigen drei Phasen wird als bezeichnet object relational mapping.

Mapping.xml

Die Datei maps.xml soll den JPA-Anbieter anweisen, die Entitätsklassen den Datenbanktabellen zuzuordnen.

Nehmen wir ein Beispiel für eine Mitarbeiterentität, die vier Attribute enthält. Die POJO-Klasse der benannten Employee-EntitätEmployee.java ist wie folgt:

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

Der obige Code ist die POJO-Klasse der Employee-Entität. Es enthält vier Attributeeid, ename, salary, und deg. Betrachten Sie diese Attribute als Tabellenfelder in einer Tabelle undeidals Primärschlüssel dieser Tabelle. Jetzt müssen wir die Zuordnungsdatei für den Ruhezustand dafür entwerfen. Die Zuordnungsdatei mit dem Namenmapping.xml ist wie folgt:

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

Das obige Skript wird zum Zuordnen der Entitätsklasse zur Datenbanktabelle verwendet. In dieser Datei

• <entity-mappings> : tag definiert die Schemadefinition, um Entitäts-Tags in XML-Dateien zuzulassen.

• <description> : tag enthält eine Beschreibung der Anwendung.

• <entity>: tag definiert die Entitätsklasse, die Sie in eine Tabelle in einer Datenbank konvertieren möchten. Die Attributklasse definiert den Namen der POJO-Entitätsklasse.

• <table>: tag definiert den Tabellennamen. Wenn Sie identische Namen sowohl für die Klasse als auch für die Tabelle haben möchten, ist dieses Tag nicht erforderlich.

• <attributes> : tag definiert die Attribute (Felder in einer Tabelle).

• <id>: tag definiert den Primärschlüssel der Tabelle. Das<generated-value> Tag definiert, wie der Primärschlüsselwert zugewiesen wird, z Automatic, Manualoder entnommen aus Sequence.

• <basic> : Tag wird zum Definieren der verbleibenden Attribute für die Tabelle verwendet.

• <column-name> : tag wird verwendet, um benutzerdefinierte Tabellenfeldnamen in der Tabelle zu definieren.

Anmerkungen

Im Allgemeinen werden XML-Dateien verwendet, um bestimmte Komponenten zu konfigurieren oder zwei verschiedene Spezifikationen von Komponenten zuzuordnen. In unserem Fall müssen wir XML-Dateien separat in einem Framework verwalten. Das heißt, beim Schreiben einer Mapping-XML-Datei müssen die POJO-Klassenattribute mit Entitäts-Tags in der Mapping.xml-Datei verglichen werden.

Hier ist die Lösung. In der Klassendefinition können wir den Konfigurationsteil mithilfe von Anmerkungen schreiben. Anmerkungen werden für Klassen, Eigenschaften und Methoden verwendet. Anmerkungen beginnen mit dem Symbol '@'. Anmerkungen werden vor einer Klasse, Eigenschaft oder Methode deklariert. Alle Anmerkungen von JPA sind in der definiertjavax.persistence Paket.

Hier finden Sie eine Liste der in unseren Beispielen verwendeten Anmerkungen.

Anmerkung	Beschreibung
@Entität	Deklariert die Klasse als Entität oder Tabelle.
@Tabelle	Deklariert den Tabellennamen.
@Basic	Gibt explizit Felder ohne Einschränkungen an.
@Eingebettet	Gibt die Eigenschaften einer Klasse oder einer Entität an, deren Wert eine Instanz einer einbettbaren Klasse ist.
@Ich würde	Gibt die Eigenschaft an, die für die Identität (Primärschlüssel einer Tabelle) der Klasse verwendet wird.
@GeneratedValue	Gibt an, wie das Identitätsattribut initialisiert werden kann, z. B. automatisch, manuell oder aus einer Sequenztabelle.
@Transient	Gibt die Eigenschaft an, die nicht persistent ist, dh der Wert wird niemals in der Datenbank gespeichert.
@Säule	Gibt das Spaltenattribut für die Persistenz-Eigenschaft an.
@SequenceGenerator	Gibt den Wert für die Eigenschaft an, die in der Annotation @GeneratedValue angegeben ist. Es wird eine Sequenz erstellt.
@ TableGenerator	Gibt den Wertgenerator für die in der Annotation @GeneratedValue angegebene Eigenschaft an. Es wird eine Tabelle zur Wertschöpfung erstellt.
@Zugangsart	Diese Art von Anmerkung wird verwendet, um den Zugriffstyp festzulegen. Wenn Sie @AccessType (FIELD) festlegen, erfolgt der Zugriff vor Ort. Wenn Sie @AccessType (PROPERTY) festlegen, erfolgt der Zugriff eigenschaftsbezogen.
@ JoinColumn	Gibt eine Entitätszuordnung oder Entitätssammlung an. Dies wird in vielen-zu-eins- und eins-zu-vielen-Assoziationen verwendet.
@Einzigartige Beschränkung	Gibt die Felder und die eindeutigen Einschränkungen für die primäre oder die sekundäre Tabelle an.
@ColumnResult	Verweist mit der select-Klausel auf den Namen einer Spalte in der SQL-Abfrage.
@Viel zu viel	Definiert eine Viele-zu-Viele-Beziehung zwischen den Verknüpfungstabellen.
@ManyToOne	Definiert eine Viele-zu-Eins-Beziehung zwischen den Verknüpfungstabellen.
@ OneToMany	Definiert eine Eins-zu-Viele-Beziehung zwischen den Verknüpfungstabellen.
@Eins zu eins	Definiert eine Eins-zu-Eins-Beziehung zwischen den Verknüpfungstabellen.
@NamedQueries	Gibt eine Liste der benannten Abfragen an.
@NamedQuery	Gibt eine Abfrage mit statischem Namen an.

Java Bean Standard

Die Java-Klasse kapselt die Instanzwerte und ihr Verhalten in einer einzigen Einheit namens Objekt. Java Bean ist eine temporäre Speicher- und wiederverwendbare Komponente oder ein Objekt. Es ist eine serialisierbare Klasse, die über einen Standardkonstruktor sowie Getter- und Setter-Methoden verfügt, um die Instanzattribute einzeln zu initialisieren.

Bohnenkonventionen

• Bean enthält seinen Standardkonstruktor oder eine Datei, die eine serialisierte Instanz enthält. Daher kann eine Bohne eine andere Bohne instanziieren.

• Die Eigenschaften einer Bean können in boolesche oder nicht-boolesche Eigenschaften unterteilt werden.

• Nicht-Boolesche Eigenschaft enthält getter und setter Methoden.

• Boolesche Eigenschaft enthalten setter und is Methode.

• Getter Die Methode einer Eigenschaft sollte mit einem kleinen Buchstaben beginnen get(Java-Methodenkonvention) und wird mit einem Feldnamen fortgesetzt, der mit einem Großbuchstaben beginnt. Der Feldname lautet beispielsweisesalary daher ist die Getter-Methode dieses Feldes getSalary ().

• Setter Die Methode einer Eigenschaft sollte mit einem kleinen Buchstaben beginnen set (Java-Methodenkonvention), Fortsetzung mit einem Feldnamen, der mit dem Großbuchstaben und dem beginnt argument valueauf Feld setzen. Der Feldname lautet beispielsweisesalary daher ist die Setter-Methode dieses Feldes setSalary ( double sal ).

• Für die Boolesche Eigenschaft isMethode, um zu überprüfen, ob es wahr oder falsch ist. Zum Beispiel die Boolesche Eigenschaftempty, das is Methode dieses Feldes ist isEmpty ().

Dieses Kapitel führt Sie durch die Einrichtung von JPA auf Windows- und Linux-basierten Systemen. JPA kann in wenigen einfachen Schritten ohne komplexe Einrichtungsverfahren einfach installiert und in Ihre aktuelle Java-Umgebung integriert werden. Während der Installation ist eine Benutzerverwaltung erforderlich.

System Anforderungen

JDK	Java SE 2 JDK 1.5 oder höher
Erinnerung	1 GB RAM (empfohlen)
Festplattenplatz	Keine Mindestanforderung
Betriebssystemversion	Windows XP oder höher, Linux

Fahren wir nun mit den Schritten zur Installation von JPA fort.

Schritt 1: Überprüfen Sie Ihre Java-Installation

Zunächst muss das Java Software Development Kit (SDK) auf Ihrem System installiert sein. Um dies zu überprüfen, führen Sie je nach Plattform, auf der Sie arbeiten, einen der beiden folgenden Befehle aus.

Wenn die Java-Installation ordnungsgemäß durchgeführt wurde, werden die aktuelle Version und die Spezifikation Ihrer Java-Installation angezeigt. Eine Beispielausgabe ist in der folgenden Tabelle angegeben.

Plattform	Befehl	Beispielausgabe
Windows	Öffnen Sie die Befehlskonsole und geben Sie Folgendes ein: \>java –version	Java-Version "1.7.0_60" Java (TM) SE-Laufzeitumgebung (Build 1.7.0_60-b19) Java Hotspot (TM) 64-Bit-Server-VM (Build 24.60-b09, gemischter Modus)
Linux	Öffnen Sie das Befehlsterminal und geben Sie Folgendes ein: $java –version	Java-Version "1.7.0_25" Öffnen Sie die JDK-Laufzeitumgebung (rhel-2.3.10.4.el6_4-x86_64). Öffnen Sie die JDK 64-Bit-Server-VM (Build 23.7-b01, gemischter Modus).

• Wir gehen davon aus, dass die Leser dieses Tutorials Java SDK Version 1.7.0_60 auf ihrem System installiert haben.

• Falls Sie kein Java SDK haben, laden Sie die aktuelle Version von herunter http://www.oracle.com/technetwork/java/javase/downloads/index.html und habe es installiert.

Schritt 2: Legen Sie Ihre Java-Umgebung fest

Stellen Sie die Umgebungsvariable JAVA_HOME so ein, dass sie auf den Speicherort des Basisverzeichnisses verweist, in dem Java auf Ihrem Computer installiert ist. Zum Beispiel,

Plattform	Beschreibung
Windows	Setzen Sie JAVA_HOME auf C: \ ProgramFiles \ java \ jdk1.7.0_60
Linux	Exportieren Sie JAVA_HOME = / usr / local / java-current

Hängen Sie den vollständigen Pfad des Java-Compiler-Speicherorts an den Systempfad an.

Plattform	Beschreibung
Windows	Fügen Sie die Zeichenfolge "C: \ Programme \ Java \ jdk1.7.0_60 \ bin" an das Ende der Systemvariablen PATH an.
Linux	Export PATH = $ PATH: $ JAVA_HOME / bin /

Führen Sie den Befehl aus java -version an der Eingabeaufforderung wie oben erläutert.

Schritt 3: JPA installieren

Sie können die JPA-Installation mit einem der JPA-Anbieter aus diesem Lernprogramm durchführen, z. B. Eclipselink, Hibernate. Lassen Sie uns die JPA-Installation mit Eclipselink verfolgen. Für die JPA-Programmierung müssen wir das spezifische Ordner-Framework befolgen, daher ist es besser, IDE zu verwenden.

Laden Sie das Eclipse IDE-Formular über den folgenden Link herunter https://www.eclipse.org/downloads/ Wählen Sie den EclipseIDE für JavaEE-Entwickler Eclipse indigo.

Entpacken Sie die Eclipse-Zip-Datei im Laufwerk C. Öffnen Sie die Eclipse-IDE.

JPA mit Eclipselink installieren

Eclipselink ist eine Bibliothek, daher können wir sie nicht direkt zur Eclipse-IDE hinzufügen. Um JPA mit Eclipselink zu installieren, müssen Sie die folgenden Schritte ausführen.

• Erstellen Sie ein neues JPA-Projekt, indem Sie auswählen File->New->JPA Project in der Eclipse-IDE wie folgt:

  

• Sie erhalten ein Dialogfeld mit dem Namen New JPA Project. Geben Sie den Projektnamen eintutorialspoint_JPA_Eclipselink, Überprüf den jre Version und klicken Sie auf Weiter:

  

• Klicken Sie im Bereich Benutzerbibliothek auf Bibliothek herunterladen (falls Sie nicht über die Bibliothek verfügen).

  

• Wählen Sie im Dialogfeld Bibliothek herunterladen die neueste Version der Eclipselink-Bibliothek aus und klicken Sie wie folgt auf Weiter:

  

• Akzeptieren Sie die Lizenzbedingungen und klicken Sie auf Fertig stellen, um die Bibliothek herunterzuladen.

  

• 6. Der Download beginnt wie im folgenden Screenshot gezeigt.

  

• Wählen Sie nach dem Herunterladen die heruntergeladene Bibliothek im Abschnitt Benutzerbibliothek aus und klicken Sie auf Fertig stellen.

  

• Schließlich erhalten Sie die Projektdatei in der Package Explorerin der Eclipse-IDE. Wenn Sie alle Dateien extrahieren, erhalten Sie die Ordner- und Dateihierarchie wie folgt:

  

Hinzufügen eines MySQL-Connectors zu Project

Jedes Beispiel, das wir hier diskutieren, erfordert Datenbankkonnektivität. Betrachten wir die MySQL-Datenbank für Datenbankoperationen. Für die Interaktion mit einem Java-Programm ist mysql-connector jar erforderlich.

Befolgen Sie die Schritte, um die Datenbank-JAR in Ihrem Projekt zu konfigurieren.

• Gehen Sie zu Projekteigenschaften ->Java Build Path durch Klicken mit der rechten Maustaste. Sie erhalten ein Dialogfeld, wie im folgenden Screenshot gezeigt. Klicken Sie auf Externe Gläser hinzufügen.

  

• Gehen Sie zum JAR-Speicherort in Ihrem Systemspeicher, wählen Sie die Datei aus und klicken Sie auf Öffnen.

  

• Klicken Sie im Eigenschaftendialog auf OK. Sie erhalten das MySQL-Connector Jar in Ihr Projekt. Jetzt können Sie Datenbankoperationen mit MySQL ausführen.

In diesem Kapitel wird anhand eines einfachen Beispiels die Funktionsweise von JPA veranschaulicht. Betrachten wir als Beispiel das Employee Management. Angenommen, die Mitarbeiterverwaltung erstellt, aktualisiert, findet und löscht die Datensätze eines Mitarbeiters. Wie bereits 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. Befolgen Sie die Hierarchie für dieses Beispiel wie unten gezeigt:

Entitäten erstellen

Entitäten sind nichts als Bohnen oder Modelle. In diesem Beispiel werden wir verwendenEmployee als Einheit. eid, ename, salary, und degsind die Attribute dieser Entität. Es enthält einen Standardkonstruktor sowie die Setter- und Getter-Methoden 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 zu einer Entität zu machen.

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 folgende Abfrage 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 <persistence-unit> Das Tag wird mit einem bestimmten Namen für die JPA-Persistenz definiert. Das<class>Tag definiert die Entitätsklasse mit dem Paketnamen. Das<properties> Tag definiert alle Eigenschaften und <property>Tag definiert jede Eigenschaft wie Datenbankregistrierung, URL-Angabe, Benutzername und Passwort. Dies sind die Eclipselink-Eigenschaften. Diese Datei konfiguriert die Datenbank.

Persistenzoperationen

Persistenzoperationen werden für die Interaktion mit einer 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

Das folgende Codesegment zeigt, wie Sie eine Employee-Klasse mit dem Namen erstellen 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( );
	}
}

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. Dasentitymanagerfactory Objekt erstellt die entitymanger Instanz mit createEntityManager ()Methode. Dasentitymanager Objekt erstellt entitytransactionInstanz für das Transaktionsmanagement. Durch die Nutzungentitymanager Objekt können wir Entitäten in der Datenbank beibehalten.

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 die Datensätze eines Mitarbeiters zu aktualisieren, müssen wir die vorhandenen Datensätze aus der Datenbank abrufen, Änderungen vornehmen und sie schließlich in die Datenbank übernehmen. 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 die Aufzeichnungen eines Mitarbeiters zu finden, müssen wir die vorhandenen Daten aus der Datenbank abrufen und anzeigen. In diesem Vorgang wird EntityTransaction beim Abrufen eines Datensatzes nicht 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 folgende Ausgabe aus der Eclipselink-Bibliothek im Konsolenfenster der Eclipse-IDE.

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

Mitarbeiter löschen

Um die Datensätze eines Mitarbeiters zu löschen, suchen wir zuerst die vorhandenen Datensätze und löschen sie 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 sieht die Paket- und Dateihierarchie wie folgt aus:

In diesem Kapitel wird JPQL beschrieben und wie es mit Persistenzeinheiten funktioniert. In diesem Kapitel folgen die angegebenen Beispiele derselben Pakethierarchie, die wir im vorherigen Kapitel verwendet haben.

Java Persistence Query-Sprache

JPQL steht für Java Persistence Query Language. Es wird verwendet, um Abfragen für Entitäten zu erstellen, die in einer relationalen Datenbank gespeichert werden sollen. JPQL basiert auf der SQL-Syntax. Die Datenbank wird jedoch nicht direkt beeinflusst.

JPQL kann Daten mit der SELECT-Klausel abrufen, Massenaktualisierungen mit der UPDATE-Klausel und der DELETE-Klausel durchführen.

Abfragestruktur

Die JPQL-Syntax ist der SQL-Syntax sehr ähnlich. Eine SQL-ähnliche Syntax ist von Vorteil, da SQL einfach ist und weit verbreitet ist. SQL arbeitet direkt mit relationalen Datenbanktabellen, Datensätzen und Feldern, während JPQL mit Java-Klassen und -Instanzen arbeitet.

Beispielsweise kann eine JPQL-Abfrage wie bei SQL ein Entitätsobjekt anstelle einer Feldergebnismenge aus einer Datenbank abrufen. Die JPQL-Abfragestruktur lautet wie folgt.

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

Die Struktur von JPQL DELETE- und UPDATE-Abfragen ist wie folgt.

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

Skalar- und Aggregatfunktionen

Skalarfunktionen geben resultierende Werte basierend auf Eingabewerten zurück. Aggregatfunktionen geben die resultierenden Werte zurück, indem sie die Eingabewerte berechnen.

Wir werden das gleiche Beispiel für die Mitarbeiterverwaltung wie im vorherigen Kapitel verwenden. Hier werden wir die Serviceklassen mit skalaren und aggregierten Funktionen von JPQL durchgehen.

Nehmen wir das an jpadb.employee Tabelle enthält folgende Datensätze.

Eid	Ename	Gehalt	Deg
1201	Gopal	40000	Technischer Manager
1202	Manisha	40000	Proof Reader
1203	Masthanvali	40000	Technischer Schreiber
1204	Satish	30000	Technischer Schreiber
1205	Krishna	30000	Technischer Schreiber
1206	Kiran	35000	Proof Reader

Erstellen Sie eine Klasse mit dem Namen ScalarandAggregateFunctions.java unter com.tutorialspoint.eclipselink.service Paket wie folgt.

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

Nach dem Kompilieren und Ausführen des obigen Programms erhalten Sie die folgende Ausgabe im Konsolenfenster von 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

Zwischen und wie Schlüsselwörter

Between, And, und Likesind die Hauptschlüsselwörter von JPQL. Diese Schlüsselwörter werden nach verwendetWhere clause in einer Abfrage.

Erstellen Sie eine Klasse mit dem Namen BetweenAndLikeFunctions.java unter com.tutorialspoint.eclipselink.service Paket wie folgt:

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

Nach dem Kompilieren und Ausführen des obigen Programms erhalten Sie die folgende Ausgabe im Konsolenfenster von 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

Bestellung

Um die Datensätze in JPQL zu ordnen, verwenden wir die ORDER BY-Klausel. Die Verwendung dieser Klausel ist dieselbe wie in SQL, behandelt jedoch Entitäten. Das folgende Beispiel zeigt, wie die ORDER BY-Klausel verwendet wird.

Erstellen Sie eine Klasse Ordering.java unter com.tutorialspoint.eclipselink.service Paket wie folgt:

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

Wenn Sie das obige Programm kompilieren und ausführen, wird die folgende Ausgabe im Konsolenfenster von Eclipse IDE erzeugt.

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

Benannte Abfragen

Eine @ NamedQuery-Annotation ist als Abfrage mit einer vordefinierten Abfragezeichenfolge definiert, die nicht geändert werden kann. Im Gegensatz zu dynamischen Abfragen können benannte Abfragen die Codeorganisation verbessern, indem die JPQL-Abfragezeichenfolgen von POJO getrennt werden. Es übergibt auch die Abfrageparameter, anstatt die Literale dynamisch in die Abfragezeichenfolge einzubetten, und erzeugt daher effizientere Abfragen.

Fügen Sie zunächst der benannten Employee-Entitätsklasse die Annotation @NamedQuery hinzu Employee.java unter com.tutorialspoint.eclipselink.entity 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.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 + "]";
	}
}

Erstellen Sie eine Klasse mit dem Namen NamedQueries.java unter com.tutorialspoint.eclipselink.service Paket wie folgt:

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

Nach dem Kompilieren und Ausführen des obigen Programms erhalten Sie die folgende Ausgabe im Konsolenfenster von Eclipse IDE.

Employee ID :1204	 Employee Name :Satish

Nach dem Hinzufügen aller oben genannten Klassen sieht die Pakethierarchie wie folgt aus:

Eifriges und faules Holen

Das wichtigste Konzept von JPA besteht darin, eine Kopie der Datenbank im Cache-Speicher zu erstellen. Während der Transaktion mit einer Datenbank erstellt der JPA zunächst einen doppelten Datensatz. Erst wenn er mit einem Entitätsmanager festgeschrieben wird, werden die Änderungen in der Datenbank vorgenommen.

Es gibt zwei Möglichkeiten, Datensätze aus der Datenbank abzurufen.

Eifriger Abruf

Beim eifrigen Abrufen werden verwandte untergeordnete Objekte beim Abrufen eines bestimmten Datensatzes automatisch hochgeladen.

Fauler Abruf

Beim verzögerten Abrufen werden verwandte Objekte nicht automatisch hochgeladen, es sei denn, Sie fordern dies ausdrücklich an. Zunächst wird die Verfügbarkeit verwandter Objekte überprüft und benachrichtigt. Wenn Sie später eine der Getter-Methoden dieser Entität aufrufen, werden alle Datensätze abgerufen.

Lazy Fetch ist möglich, wenn Sie zum ersten Mal versuchen, die Datensätze abzurufen. Auf diese Weise wird bereits eine Kopie des gesamten Datensatzes im Cache-Speicher gespeichert. In Bezug auf die Leistung ist ein fauler Abruf vorzuziehen.

JPA ist eine Bibliothek, die mit Java-Spezifikationen veröffentlicht wird. Daher werden alle objektorientierten Konzepte für die Persistenz von Entitäten unterstützt. Bis jetzt sind wir mit den Grundlagen der objektrelationalen Zuordnung fertig. Dieses Kapitel führt Sie durch die erweiterten Zuordnungen zwischen Objekten und relationalen Entitäten.

Vererbungsstrategien

Vererbung ist das Kernkonzept jeder objektorientierten Sprache, daher können wir Vererbungsbeziehungen oder -strategien zwischen Entitäten verwenden. JPA unterstützt drei Arten von Vererbungsstrategien: SINGLE_TABLE, JOINED_TABLE und TABLE_PER_CONCRETE_CLASS.

Betrachten wir ein Beispiel. Das folgende Diagramm zeigt drei Klassen, nämlich. Mitarbeiter, TeachingStaff und NonTeachingStaff sowie deren Beziehungen.

In der obigen Abbildung ist Staff eine Entität, während TeachingStaff und NonTeachingStaff die Unterentitäten von Staff sind. Hier werden wir das obige Beispiel verwenden, um alle drei Vererbungsstrategien zu demonstrieren.

Single Table Strategie

Die Einzeltabellenstrategie nimmt alle Klassenfelder (sowohl Super- als auch Unterklassen) und ordnet sie einer einzelnen Tabelle zu, die als SINGLE_TABLE-Strategie bezeichnet wird. Hier spielt der Diskriminatorwert eine Schlüsselrolle bei der Unterscheidung der Werte von drei Entitäten in einer Tabelle.

Betrachten wir das obige Beispiel. TeachingStaff und NonTeachingStaff sind die Unterklassen der Mitarbeiter. Gemäß dem Konzept der Vererbung erbt eine Unterklasse die Eigenschaften ihrer Oberklasse. Daher sind Sid und Sname die Felder, die sowohl zu TeachingStaff als auch zu NonTeachingStaff gehören. Erstellen Sie ein JPA-Projekt. Alle Module dieses Projekts lauten wie folgt:

Entitäten erstellen

Erstellen Sie ein Paket mit dem Namen ‘com.tutorialspoint.eclipselink.entity’ unter ‘src’Paket. Erstellen Sie eine neue Java-Klasse mit dem NamenStaff.javaunter gegebenem Paket. Die Entitätsklasse Staff wird wie folgt angezeigt:

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

Im obigen Code @DescriminatorColumn Gibt den Feldnamen an (type) und seine Werte zeigen die verbleibenden Felder (Teaching und NonTeachingStaff).

Erstellen Sie eine Unterklasse (Klasse) für die Staff-Klasse mit dem Namen TeachingStaff.java unter dem com.tutorialspoint.eclipselink.entityPaket. Die TeachingStaff Entity-Klasse wird wie folgt angezeigt:

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

Erstellen Sie eine Unterklasse (Klasse) für die Staff-Klasse mit dem Namen NonTeachingStaff.java unter dem com.tutorialspoint.eclipselink.entityPaket. Die NonTeachingStaff-Entitätsklasse wird wie folgt angezeigt:

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 enthält die Konfigurationsinformationen der Datenbank und die Registrierungsinformationen der Entitätsklassen. Die XML-Datei wird wie folgt angezeigt:

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

Serviceklasse

Serviceklassen sind der Implementierungsteil der Geschäftskomponente. Erstellen Sie ein Paket unter‘src’ Paket benannt ‘com.tutorialspoint.eclipselink.service’.

Erstellen Sie eine Klasse mit dem Namen SaveClient.javaunter dem angegebenen Paket zum Speichern der Klassenfelder Staff, TeachingStaff und NonTeachingStaff. Die SaveClient-Klasse wird wie folgt angezeigt:

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

Nach dem Kompilieren und Ausführen des obigen Programms erhalten Sie Benachrichtigungen im Konsolenfenster der Eclipse IDE. Überprüfen Sie die MySQL-Workbench auf Ausgabe. Die Ausgabe in Tabellenform wird wie folgt angezeigt:

Sid	Art	Sname	Flächenexpertise	Qualifikation	Fachkompetenz
1	TS	Gopal		MSC MED	Mathe
2	TS	Manisha		BSC BETT	Englisch
3	NS	Satish	Konten
4	NS	Krishna	Büro admin

Schließlich erhalten Sie eine einzelne Tabelle, die das Feld aller drei Klassen mit einer Diskriminatorspalte mit dem Namen enthält Type (Feld).

Joined Table Strategie

Die Strategie für verbundene Tabellen besteht darin, die referenzierte Spalte, die eindeutige Werte enthält, gemeinsam zu nutzen, um der Tabelle beizutreten und einfache Transaktionen durchzuführen. Betrachten wir das gleiche Beispiel wie oben.

Erstellen Sie ein JPA-Projekt. Alle Projektmodule sind unten dargestellt.

Entitäten erstellen

Erstellen Sie ein Paket mit dem Namen ‘com.tutorialspoint.eclipselink.entity’ unter ‘src’Paket. Erstellen Sie eine neue Java-Klasse mit dem NamenStaff.javaunter gegebenem Paket. Die Entitätsklasse Staff wird wie folgt angezeigt:

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

Erstellen Sie eine Unterklasse (Klasse) für die Staff-Klasse mit dem Namen TeachingStaff.java unter dem com.tutorialspoint.eclipselink.entityPaket. Die TeachingStaff Entity-Klasse wird wie folgt angezeigt:

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

Erstellen Sie eine Unterklasse (Klasse) für die Staff-Klasse mit dem Namen NonTeachingStaff.java unter dem com.tutorialspoint.eclipselink.entityPaket. Die NonTeachingStaff-Entitätsklasse wird wie folgt angezeigt:

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

Die Datei Persistence.xml enthält die Konfigurationsinformationen der Datenbank und die Registrierungsinformationen der Entitätsklassen. Die XML-Datei wird wie folgt angezeigt:

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

Serviceklasse

Serviceklassen sind der Implementierungsteil der Geschäftskomponente. Erstellen Sie ein Paket unter‘src’ Paket benannt ‘com.tutorialspoint.eclipselink.service’.

Erstellen Sie eine Klasse mit dem Namen SaveClient.javaunter dem angegebenen Paket zum Speichern der Felder Staff, TeachingStaff und NonTeachingStaff. Dann wird die SaveClient-Klasse wie folgt angezeigt:

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

Nach dem Kompilieren und Ausführen des obigen Programms erhalten Sie Benachrichtigungen im Konsolenfenster von Eclipse IDE. Überprüfen Sie für die Ausgabe die MySQL-Workbench.

Hier werden drei Tabellen erstellt und das Ergebnis von staff Die Tabelle wird in Tabellenform angezeigt.

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

Das Ergebnis von TeachingStaff Tabelle wird wie folgt angezeigt:

Sid	Qualifikation	Fachkompetenz
1	MSC MED	Mathe
2	BSC BETT	Englisch

In der obigen Tabelle ist sid der Fremdschlüssel (Referenzfeld aus Personaltabelle). Das Ergebnis von NonTeachingStaff Tabelle wird wie folgt angezeigt:

Sid	Flächenexpertise
3	Konten
4	Büro admin

Schließlich werden die drei Tabellen unter Verwendung ihrer jeweiligen Felder erstellt und das SID-Feld wird von allen drei Tabellen gemeinsam genutzt. In der Staff-Tabelle ist SID der Primärschlüssel. In den verbleibenden zwei Tabellen (TeachingStaff und NonTeachingStaff) ist SID der Fremdschlüssel.

Tabelle pro Klassenstrategie

Die Strategie für eine Tabelle pro Klasse besteht darin, für jede Unterentität eine Tabelle zu erstellen. Die Staff-Tabelle wird erstellt, enthält jedoch Nullwerte. Die Feldwerte der Staff-Tabelle müssen von den Tabellen TeachingStaff und NonTeachingStaff gemeinsam genutzt werden.

Betrachten wir das gleiche Beispiel wie oben.

Entitäten erstellen

Erstellen Sie ein Paket mit dem Namen ‘com.tutorialspoint.eclipselink.entity’ unter ‘src’Paket. Erstellen Sie eine neue Java-Klasse mit dem NamenStaff.javaunter gegebenem Paket. Die Entitätsklasse Staff wird wie folgt angezeigt:

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

Erstellen Sie eine Unterklasse (Klasse) für die Staff-Klasse mit dem Namen TeachingStaff.java unter dem com.tutorialspoint.eclipselink.entityPaket. Die TeachingStaff Entity-Klasse wird wie folgt angezeigt:

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

Erstellen Sie eine Unterklasse (Klasse) für die Staff-Klasse mit dem Namen NonTeachingStaff.java unter dem com.tutorialspoint.eclipselink.entityPaket. Die NonTeachingStaff-Entitätsklasse wird wie folgt angezeigt:

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

Die Datei Persistence.xml enthält die Konfigurationsinformationen der Datenbank und die Registrierungsinformationen der Entitätsklassen. Die XML-Datei wird wie folgt angezeigt:

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

Serviceklasse

Serviceklassen sind der Implementierungsteil der Geschäftskomponente. Erstellen Sie ein Paket unter‘src’ Paket benannt ‘com.tutorialspoint.eclipselink.service’.

Erstellen Sie eine Klasse mit dem Namen SaveClient.javaunter dem angegebenen Paket zum Speichern der Klassenfelder Staff, TeachingStaff und NonTeachingStaff. Die SaveClient-Klasse wird wie folgt angezeigt:

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

Nach dem Kompilieren und Ausführen des obigen Programms erhalten Sie Benachrichtigungen im Konsolenbereich der Eclipse-IDE. Überprüfen Sie für die Ausgabe die MySQL-Workbench.

Hier werden die drei Tabellen erstellt und die Staff Tabelle enthält Nulldatensätze.

Das Ergebnis von TeachingStaff wird wie folgt angezeigt:

Sid	Qualifikation	Sname	Fachkompetenz
1	MSC MED	Gopal	Mathe
2	BSC BETT	Manisha	Englisch

Die obige Tabelle TeachingStaff enthält Felder sowohl für Mitarbeiter als auch für TeachingStaff-Einheiten.

Das Ergebnis von NonTeachingStaff wird wie folgt angezeigt:

Sid	Flächenexpertise	Sname
3	Konten	Satish
4	Büro admin	Krishna

Die obige Tabelle NonTeachingStaff enthält Felder von Mitarbeitern und NonTeachingStaff-Entitäten.

Dieses Kapitel führt Sie durch die Beziehungen zwischen Entitäten. Im Allgemeinen sind die Beziehungen zwischen Tabellen in der Datenbank effektiver. Hier werden die Entitätsklassen als relationale Tabellen behandelt (Konzept von JPA), daher sind die Beziehungen zwischen Entitätsklassen wie folgt:

• @ManyToOne Beziehung
• @ OneToMany Beziehung
• @ OneToOne-Beziehung
• @ManyToMany Beziehung

@ManyToOne Beziehung

Eine Viele-zu-Eins-Beziehung zwischen Entitäten besteht, wenn auf eine Entität (Spalte oder Satz von Spalten) mit einer anderen Entität (Spalte oder Satz von Spalten) verwiesen wird, die eindeutige Werte enthält. In relationalen Datenbanken werden diese Beziehungen mithilfe eines Fremdschlüssels / Primärschlüssels zwischen den Tabellen angewendet.

Betrachten wir ein Beispiel für eine Beziehung zwischen Mitarbeitern und Abteilungseinheiten. In unidirektionaler Weise, dh vom Mitarbeiter zur Abteilung, ist die Viele-zu-Eins-Beziehung anwendbar. Das bedeutet, dass jeder Datensatz eines Mitarbeiters eine Abteilungs-ID enthält, die ein Primärschlüssel in der Abteilungstabelle sein sollte. Hier in der Employee-Tabelle ist die Abteilungs-ID der Fremdschlüssel.

Das folgende Diagramm zeigt die Viele-zu-Eins-Beziehung zwischen den beiden Tabellen.

Erstellen Sie ein JPA-Projekt in der Eclipse-IDE mit dem Namen JPA_Eclipselink_MTO. Alle Module dieses Projekts werden unten diskutiert.

Entitäten erstellen

Befolgen Sie das oben angegebene Diagramm zum Erstellen von Entitäten. Erstellen Sie ein Paket mit dem Namen‘com.tutorialspoin.eclipselink.entity’ unter ‘src’Paket. Erstellen Sie eine Klasse mit dem NamenDepartment.javaunter gegebenem Paket. Die Entität der Klassenabteilung wird wie folgt angezeigt:

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

Erstellen Sie die zweite Entität in dieser Beziehung - Mitarbeiterentitätsklasse mit dem Namen Employee.java unter ‘com.tutorialspoint.eclipselink.entity’Paket. Die Entitätsklasse "Mitarbeiter" wird wie folgt angezeigt:

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

Die Datei Persistence.xml ist erforderlich, um die Datenbank und die Registrierung von Entitätsklassen zu konfigurieren.

Persitence.xml wird von der Eclipse-IDE beim Erstellen eines JPA-Projekts erstellt. Die Konfigurationsdetails sind Benutzerspezifikationen. Die Datei persistence.xml wird wie folgt angezeigt:

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

Serviceklassen

Dieses Modul enthält die Serviceklassen, die den relationalen Teil mithilfe der Attributinitialisierung implementieren. Erstellen Sie ein Paket unter‘src’ Paket benannt ‘com.tutorialspoint.eclipselink.service’. Die DAO-Klasse mit dem NamenManyToOne.javawird unter gegebenem Paket erstellt. Die DAO-Klasse wird wie folgt angezeigt:

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

Nach dem Kompilieren und Ausführen des obigen Programms erhalten Sie Benachrichtigungen im Konsolenbereich der Eclipse-IDE. Überprüfen Sie für die Ausgabe die MySQL-Workbench. In diesem Beispiel werden zwei Tabellen erstellt.

Übergeben Sie die folgende Abfrage in der MySQL-Oberfläche und das Ergebnis von Department Die Tabelle wird wie folgt angezeigt:

Select * from department

ICH WÜRDE	Name
101	Entwicklung

Übergeben Sie die folgende Abfrage in der MySQL-Oberfläche und das Ergebnis von Employee Tabelle wird wie folgt angezeigt.

Select * from employee

Eid	Deg	Ename	Gehalt	Department_Id
102	Technischer Schreiber	Satish	45000	101
103	Technischer Schreiber	Krishna	45000	101
104	Technischer Schreiber	Masthanwali	50000	101

In der obigen Tabelle ist Deparment_Id der Fremdschlüssel (Referenzfeld) aus der Abteilungstabelle.

@ OneToMany Beziehung

In dieser Beziehung wird jede Zeile einer Entität auf viele untergeordnete Datensätze in einer anderen Entität verwiesen. Wichtig ist, dass Kinderdatensätze nicht mehrere Eltern haben können. In einer Eins-zu-Viele-Beziehung zwischen Tabelle A und Tabelle B kann jede Zeile in Tabelle A mit einer oder mehreren Zeilen in Tabelle B verknüpft werden.

Betrachten wir das obige Beispiel. Angenommen, die Mitarbeiter- und Abteilungstabellen im obigen Beispiel sind in einer unidirektionalen umgekehrten Weise verbunden, dann wird die Beziehung zu einer Eins-zu-Viele-Beziehung. Erstellen Sie ein JPA-Projekt in der Eclipse-IDE mit dem NamenJPA_Eclipselink_OTM. Alle Module dieses Projekts werden unten diskutiert.

Entitäten erstellen

Befolgen Sie das oben angegebene Diagramm zum Erstellen von Entitäten. Erstellen Sie ein Paket mit dem Namen‘com.tutorialspoin.eclipselink.entity’ unter ‘src’Paket. Erstellen Sie eine Klasse mit dem NamenDepartment.javaunter gegebenem Paket. Die Entität der Klassenabteilung wird wie folgt angezeigt:

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

Erstellen Sie die zweite Entität in dieser Relation - Employee-Entitätsklasse mit dem Namen Employee.java unter ‘com.tutorialspoint.eclipselink.entity’Paket. Die Entitätsklasse "Mitarbeiter" wird wie folgt angezeigt:

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

Die Datei persistence.xml lautet 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>
	<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>

Serviceklassen

Dieses Modul enthält die Serviceklassen, die den relationalen Teil mithilfe der Attributinitialisierung implementieren. Erstellen Sie ein Paket unter‘src’ Paket benannt ‘com.tutorialspoint.eclipselink.service’. Die DAO-Klasse mit dem NamenOneToMany.javawird unter gegebenem Paket erstellt. Die DAO-Klasse wird wie folgt angezeigt:

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

Nach dem Kompilieren und Ausführen des obigen Programms erhalten Sie Benachrichtigungen im Konsolenfenster von Eclipse IDE. Überprüfen Sie für die Ausgabe die MySQL-Workbench wie folgt.

In diesem Projekt werden drei Tabellen erstellt. Übergeben Sie die folgende Abfrage in der MySQL-Oberfläche, und das Ergebnis der Tabelle abteilungsmitarbeiter wird wie folgt angezeigt:

Select * from department_Id;

Department_ID	Employee_Eid
254	251
254	252
254	253

In der obigen Tabelle ist deparment_id und employee_id sind die Fremdschlüssel (Referenzfelder) aus Abteilungs- und Mitarbeitertabellen.

Übergeben Sie die folgende Abfrage in der MySQL-Oberfläche, und das Ergebnis der Abteilungstabelle wird wie folgt in einem Tabellenformat angezeigt.

Select * from department;

ICH WÜRDE	Name
254	Entwicklung

Übergeben Sie die folgende Abfrage in der MySQL-Oberfläche und das Ergebnis der Mitarbeitertabelle wird wie folgt angezeigt:

Select * from employee;

Eid	Deg	Ename	Gehalt
251	Technischer Schreiber	Satish	45000
252	Technischer Schreiber	Krishna	45000
253	Technischer Schreiber	Masthanwali	50000

@ OneToOne-Beziehung

In einer Eins-zu-Eins-Beziehung kann ein Element nur mit einem anderen Element verknüpft werden. Dies bedeutet, dass jede Zeile einer Entität auf eine und nur eine Zeile einer anderen Entität bezogen wird.

Betrachten wir das obige Beispiel. Employee und Departmentin umgekehrter unidirektionaler Weise ist die Beziehung eine Eins-zu-Eins-Beziehung. Dies bedeutet, dass jeder Mitarbeiter nur einer Abteilung angehört. Erstellen Sie ein JPA-Projekt in der Eclipse-IDE mit dem NamenJPA_Eclipselink_OTO. Alle Module dieses Projekts werden unten diskutiert.

Entitäten erstellen

Befolgen Sie das oben angegebene Diagramm zum Erstellen von Entitäten. Erstellen Sie ein Paket mit dem Namen‘com.tutorialspoin.eclipselink.entity’ unter ‘src’Paket. Erstellen Sie eine Klasse mit dem NamenDepartment.javaunter gegebenem Paket. Die Entität der Klassenabteilung wird wie folgt angezeigt:

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

Erstellen Sie die zweite Entität in dieser Relation - Employee-Entitätsklasse mit dem Namen Employee.java unter ‘com.tutorialspoint.eclipselink.entity’Paket. Die Entitätsklasse "Mitarbeiter" wird wie folgt angezeigt:

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

Serviceklassen

Erstellen Sie ein Paket unter ‘src’ Paket benannt ‘com.tutorialspoint.eclipselink.service’. Die DAO-Klasse mit dem NamenOneToOne.javawird unter dem angegebenen Paket erstellt. Die DAO-Klasse wird wie folgt angezeigt:

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

Nach dem Kompilieren und Ausführen des obigen Programms erhalten Sie Benachrichtigungen im Konsolenfenster von Eclipse IDE. Überprüfen Sie für die Ausgabe die MySQL-Workbench wie folgt.

Im obigen Beispiel werden zwei Tabellen erstellt. Übergeben Sie die folgende Abfrage in der MySQL-Oberfläche und das Ergebnis der Abteilungstabelle wird wie folgt angezeigt:

Select * from department

ICH WÜRDE	Name
301	Entwicklung

Übergeben Sie die folgende Abfrage in der MySQL-Oberfläche und das Ergebnis von employee Die Tabelle wird wie folgt angezeigt:

Select * from employee

Eid	Deg	Ename	Gehalt	Department_id
302	Technischer Schreiber	Satish	45000	301

@ManyToMany Beziehung

In der Viele-zu-Viele-Beziehung werden eine oder mehrere Zeilen einer Entität mehr als einer Zeile in einer anderen Entität zugeordnet.

Betrachten wir ein Beispiel für eine Beziehung zwischen zwei Entitäten: Class und Teacher. In bidirektionaler Weise haben sowohl die Klasse als auch der Lehrer eine Viele-zu-Eins-Beziehung. Das bedeutet, dass jeder Datensatz der Klasse durch den Lehrersatz (Lehrer-IDs) referenziert wird, der Primärschlüssel in der Lehrertabelle sein und in der Teacher_Class-Tabelle gespeichert werden sollte und umgekehrt. Hier enthält die Tabelle Teachers_Class beide Fremdschlüsselfelder. Erstellen Sie ein JPA-Projekt in der Eclipse-IDE mit dem NamenJPA_Eclipselink_MTM. Alle Module dieses Projekts werden unten diskutiert.

Entitäten erstellen

Erstellen Sie Entitäten, indem Sie dem im obigen Diagramm gezeigten Schema folgen. Erstellen Sie ein Paket mit dem Namen‘com.tutorialspoin.eclipselink.entity’ unter ‘src’Paket. Erstellen Sie eine Klasse mit dem NamenClas.javaunter gegebenem Paket. Die Entität der Klassenabteilung wird wie folgt angezeigt:

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

Erstellen Sie die zweite Entität in dieser Relation - Employee-Entitätsklasse mit dem Namen Teacher.java unter ‘com.tutorialspoint.eclipselink.entity’Paket. Die Entitätsklasse "Mitarbeiter" wird wie folgt angezeigt:

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

Serviceklassen

Erstellen Sie ein Paket unter ‘src’ Paket benannt ‘com.tutorialspoint.eclipselink.service’. Die DAO-Klasse mit dem NamenManyToMany.javawird unter gegebenem Paket erstellt. Die DAO-Klasse wird wie folgt angezeigt:

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 diesem Beispielprojekt werden drei Tabellen erstellt. Übergeben Sie die folgende Abfrage in der MySQL-Oberfläche, und das Ergebnis der Tabelle Teacher_clas wird wie folgt angezeigt:

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

In der obigen Tabelle teacher_tid ist der Fremdschlüssel vom Lehrertisch und classet_cidist der Fremdschlüssel aus der Klassentabelle. Daher werden verschiedene Lehrer verschiedenen Klassen zugeordnet.

Übergeben Sie die folgende Abfrage in der MySQL-Oberfläche und das Ergebnis der Lehrertabelle wird wie folgt angezeigt:

Select * from teacher

Tid	Gegenstand	Tname
354	Java	Satish
355	Adv Java	Krishna
356	DB2	Masthanvali

Übergeben Sie die folgende Abfrage in der MySQL-Oberfläche und das Ergebnis von clas Die Tabelle wird wie folgt angezeigt:

Select * from clas

Cid	Cname
351	1
352	2 ..
353	3 ..

Kriterien ist eine vordefinierte API, mit der Abfragen für Entitäten definiert werden. Dies ist eine alternative Methode zum Definieren einer JPQL-Abfrage. Diese Abfragen sind typsicher, portabel und können durch Ändern der Syntax leicht geändert werden. Ähnlich wie bei JPQL folgt es einem abstrakten Schema (einfach zu bearbeitendes Schema) und eingebetteten Objekten. Die Metadaten-API wird mit der Kriterien-API gemischt, um persistente Entitäten für Kriterienabfragen zu modellieren.

Der Hauptvorteil der Kriterien-API besteht darin, dass Fehler früher während der Kompilierungszeit erkannt werden können. String-basierte JPQL-Abfragen und JPA-Kriterien-basierte Abfragen sind in Leistung und Effizienz gleich.

Verlauf der Kriterien API

Die Kriterien sind in allen Versionen von JPA enthalten, daher wird jeder Schritt der Kriterien in den Spezifikationen von JPA angegeben.

• In JPA 2.0, der Kriterienabfrage-API, wird die Standardisierung von Abfragen entwickelt.
• In JPA 2.1 sind Kriterienaktualisierung und -löschung (Massenaktualisierung und -löschung) enthalten.

Struktur der Kriterienabfrage

Die Kriterien und JPQL sind eng miteinander verbunden und dürfen in ihren Abfragen mit ähnlichen Operatoren entworfen werden. Es folgtjavax.persistence.criteriaPaket zum Entwerfen einer Abfrage. Die Abfragestruktur bedeutet die Abfrage der Syntaxkriterien.

Die folgende einfache Kriterienabfrage gibt alle Instanzen der Entitätsklasse in der Datenquelle zurück.

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

Die Abfrage zeigt die grundlegenden Schritte zum Erstellen eines Kriteriums.

• EntityManager Instanz wird verwendet, um ein CriteriaBuilder-Objekt zu erstellen.

• CriteriaQueryInstanz wird verwendet, um ein Abfrageobjekt zu erstellen. Die Attribute dieses Abfrageobjekts werden mit den Details der Abfrage geändert.

• CriteriaQuery.form Methode wird aufgerufen, um den Abfragestamm festzulegen.

• CriteriaQuery.select wird aufgerufen, um den Ergebnislistentyp festzulegen.

• TypedQuery<T> Instanz wird verwendet, um eine Abfrage für die Ausführung vorzubereiten und den Typ des Abfrageergebnisses anzugeben.

• getResultListMethode für das TypedQuery <T> -Objekt zum Ausführen einer Abfrage. Diese Abfrage gibt eine Sammlung von Entitäten zurück. Das Ergebnis wird in einer Liste gespeichert.

Beispiel für Kriterien-API

Betrachten wir das Beispiel einer Mitarbeiterdatenbank. Nehmen wir an, die Tabelle jpadb.employee enthält folgende Datensätze:

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

Erstellen Sie ein JPA-Projekt in der Eclipse-IDE mit dem Namen JPA_Eclipselink_Criteria. Alle Module dieses Projekts werden nachfolgend erläutert:

Entitäten erstellen

Erstellen Sie ein Paket mit dem Namen com.tutorialspoint.eclipselink.entity unter ‘src’

Erstellen Sie eine Klasse mit dem Namen Employee.javaunter gegebenem Paket. Die Entität class Employee wird wie folgt angezeigt:

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

Die Datei Persistence.xml lautet 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>

Serviceklassen

Dieses Modul enthält die Serviceklassen, die den Kriterienabfrageteil mithilfe der MetaData-API-Initialisierung implementieren. Erstellen Sie ein Paket mit dem Namen‘com.tutorialspoint.eclipselink.service’. Die benannte KlasseCriteriaAPI.javawird unter gegebenem Paket erstellt. Die DAO-Klasse wird wie folgt angezeigt:

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

Nach dem Kompilieren und Ausführen des obigen Programms erhalten Sie die folgende Ausgabe im Konsolenfenster von 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