JPA - szybki przewodnik

Każda aplikacja korporacyjna wykonuje operacje na bazach danych, przechowując i pobierając ogromne ilości danych. Pomimo wszystkich dostępnych technologii zarządzania pamięcią masową programiści aplikacji zwykle mają trudności z wydajnym wykonywaniem operacji na bazach danych.

Ogólnie rzecz biorąc, programiści Java używają dużej ilości kodu lub używają zastrzeżonej struktury do interakcji z bazą danych, podczas gdy przy użyciu JPA obciążenie interakcji z bazą danych znacznie się zmniejsza. Stanowi pomost między modelami obiektowymi (program Java) i modelami relacyjnymi (program bazodanowy).

Niedopasowania między modelami relacyjnymi i obiektowymi

Obiekty relacyjne są reprezentowane w formacie tabelarycznym, podczas gdy modele obiektów są reprezentowane na połączonym wykresie formatu obiektowego. Podczas przechowywania i pobierania modelu obiektowego z relacyjnej bazy danych występuje pewna niezgodność z następujących powodów:

• Granularity : Model obiektowy ma większą szczegółowość niż model relacyjny.

• Subtypes : Podtypy (czyli dziedziczenie) nie są obsługiwane przez wszystkie typy relacyjnych baz danych.

• Identity : Podobnie jak model obiektowy, model relacyjny nie ujawnia tożsamości podczas pisania równości.

• Associations : Modele relacyjne nie mogą określać wielu relacji podczas przeglądania modelu domeny obiektów.

• Data navigation : Nawigacja po danych między obiektami w sieci obiektów jest różna w obu modelach.

Co to jest JPA?

Java Persistence API to zbiór klas i metod do trwałego przechowywania ogromnych ilości danych w bazie danych dostarczanej przez Oracle Corporation.

Gdzie używać JPA?

Aby zmniejszyć obciążenie związane z pisaniem kodów do zarządzania obiektami relacyjnymi, programista stosuje strukturę „JPA Provider”, która umożliwia łatwą interakcję z instancją bazy danych. Tutaj wymagane ramy przejmuje JPA.

Historia WZP

Wcześniejsze wersje EJB, zdefiniowana warstwa trwałości połączona z warstwą logiki biznesowej przy użyciu interfejsu javax.ejb.EntityBean.

• Podczas wprowadzania EJB 3.0 warstwa trwałości została oddzielona i określona jako JPA 1.0 (Java Persistence API). Specyfikacje tego API zostały opublikowane wraz ze specyfikacjami JAVA EE5 11 maja 2006 przy użyciu JSR 220.

• JPA 2.0 został wydany ze specyfikacjami JAVA EE6 10 grudnia 2009 jako część Java Community Process JSR 317.

• JPA 2.1 został wydany ze specyfikacją JAVA EE7 22 kwietnia 2013 r. Przy użyciu JSR 338.

Dostawcy WZP

JPA jest interfejsem API typu open source, dlatego różni dostawcy dla przedsiębiorstw, tacy jak Oracle, Redhat, Eclipse itp., Oferują nowe produkty, dodając do nich smak trwałości JPA. Niektóre z tych produktów obejmują:

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

Java Persistence API jest źródłem do przechowywania jednostek biznesowych jako jednostek relacyjnych. Pokazuje, jak zdefiniować ZWYKŁY STARY OBIEKT JAVA (POJO) jako podmiot i jak zarządzać obiektami za pomocą relacji.

Architektura na poziomie klasy

Poniższy obraz przedstawia architekturę JPA na poziomie klasy. Pokazuje podstawowe klasy i interfejsy JPA.

Poniższa tabela opisuje każdą z jednostek przedstawionych w powyższej architekturze.

Jednostki	Opis
EntityManagerFactory	To jest klasa fabryczna EntityManager. Tworzy i zarządza wieloma instancjami EntityManager.
EntityManager	Jest to interfejs, zarządza operacjami trwałości na obiektach. Działa jak fabryka dla instancji Query.
Entity	Jednostki są obiektami trwałości przechowywanymi jako rekordy w bazie danych.
EntityTransaction	Ma relację jeden do jednego z EntityManager. Dla każdego EntityManager operacje są obsługiwane przez klasę EntityTransaction.
Persistence	Ta klasa zawiera metody statyczne do uzyskiwania wystąpienia EntityManagerFactory.
Query	Ten interfejs jest implementowany przez każdego dostawcę JPA w celu uzyskania obiektów relacyjnych, które spełniają kryteria.

Powyższe klasy i interfejsy służą do przechowywania jednostek w bazie danych jako rekord. Pomagają programistom, zmniejszając wysiłki związane z pisaniem kodów do przechowywania danych w bazie danych, dzięki czemu mogą skoncentrować się na ważniejszych czynnościach, takich jak pisanie kodów do mapowania klas za pomocą tabel bazy danych.

Relacje klas JPA

W powyższej architekturze relacje między klasami i interfejsami należą do pakietu javax.persistence. Poniższy diagram przedstawia relacje między nimi.

• Relacja między EntityManagerFactory i EntityManager to one-to-many. Jest to klasa fabryczna dla instancji EntityManager.

• Relacja między EntityManager i EntityTransaction to one-to-one. Dla każdej operacji EntityManager istnieje wystąpienie EntityTransaction.

• Relacja między EntityManager i Query to one-to-many. Wiele zapytań można wykonać przy użyciu jednej instancji EntityManager.

• Relacja między EntityManager i Entity to one-to-many. Jedna instancja EntityManager może zarządzać wieloma jednostkami.

Większość współczesnych aplikacji używa relacyjnych baz danych do przechowywania danych. Ostatnio wielu dostawców przeszło na obiektową bazę danych, aby zmniejszyć obciążenie związane z utrzymaniem danych. Oznacza to, że obiektowe bazy danych lub technologie obiektowo-relacyjne zajmują się przechowywaniem, pobieraniem, aktualizowaniem i utrzymywaniem danych. Rdzeniem tej technologii obiektowo-relacyjnej jest mapowanie plików orm.xml. Ponieważ XML nie wymaga kompilacji, możemy łatwo wprowadzać zmiany w wielu źródłach danych przy mniejszym administrowaniu.

Mapowanie obiektowo-relacyjne

Mapowanie obiektowo-relacyjne (ORM) w skrócie opisuje, czym jest ORM i jak to działa. ORM to zdolność programowania do ukrywania danych z typu obiektowego na relacyjny i odwrotnie.

Główną cechą ORM jest mapowanie lub wiązanie obiektu z jego danymi w bazie danych. Podczas mapowania musimy wziąć pod uwagę dane, rodzaj danych i ich relacje z jednostką własną lub jednostkami w dowolnej innej tabeli.

Zaawansowane funkcje

• Idiomatic persistence : Umożliwia pisanie klas trwałości przy użyciu klas obiektowych.

• High Performance : Ma wiele technik pobierania i obiecujących technik blokowania.

• Reliable : Jest bardzo stabilny i używany przez wielu profesjonalnych programistów.

Architektura ORM

Architektura ORM wygląda następująco.

Powyższa architektura wyjaśnia, w jaki sposób dane obiektowe są przechowywane w relacyjnej bazie danych w trzech fazach.

Faza 1

Pierwsza faza, nazwana jako object data phase, zawiera klasy POJO, interfejsy usług i klasy. Jest to główna warstwa komponentów biznesowych, która zawiera operacje i atrybuty logiki biznesowej.

Na przykład weźmy bazę danych pracowników jako schemat.

• Klasa POJO pracownika zawiera atrybuty, takie jak identyfikator, imię i nazwisko, wynagrodzenie i stanowisko. Zawiera również metody takie jak setter i getter tych atrybutów.

• Klasy Employee DAO / Service zawierają metody obsługi, takie jak tworzenie pracownika, znajdowanie pracownika i usuwanie pracownika.

Faza 2

Druga faza, nazwana jako mapping lub persistence phase, zawiera dostawcę JPA, plik mapowania (ORM.xml), moduł ładujący JPA i siatkę obiektów.

• JPA Provider: Jest to produkt dostawcy, który zawiera smak JPA (javax.persistence). Na przykład Eclipselink, Toplink, Hibernate itp.

• Mapping file : Plik odwzorowania (ORM.xml) zawiera konfigurację odwzorowania między danymi w klasie POJO a danymi w relacyjnej bazie danych.

• JPA Loader: Moduł ładujący JPA działa jak pamięć podręczna. Może załadować relacyjne dane siatki. Działa jak kopia bazy danych do interakcji z klasami usług dla danych POJO (atrybuty klasy POJO).

• Object Grid: Jest to tymczasowa lokalizacja, w której można przechowywać kopię danych relacyjnych, np. Pamięć podręczną. Wszystkie zapytania do bazy danych najpierw dotyczą danych w siatce obiektów. Dopiero po zatwierdzeniu wpływa na główną bazę danych.

Faza 3

Trzecia faza to relational data phase. Zawiera dane relacyjne, które są logicznie połączone z komponentem biznesowym. Jak wspomniano powyżej, tylko wtedy, gdy komponent biznesowy zatwierdza dane, są one fizycznie przechowywane w bazie danych. Do tego czasu zmodyfikowane dane są przechowywane w pamięci podręcznej w formacie siatki. Proces pozyskiwania danych jest identyczny z przechowywaniem danych.

Mechanizm programowej interakcji powyższych trzech faz nosi nazwę object relational mapping.

Mapping.xml

Plik mapping.xml ma poinstruować dostawcę JPA, aby zamapował klasy jednostki na tabele bazy danych.

Weźmy na przykład podmiot Pracownik, który zawiera cztery atrybuty. Klasa POJO jednostki Pracownik o nazwieEmployee.java następująco:

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

Powyższy kod to klasa POJO podmiotu pracowniczego. Zawiera cztery atrybutyeid, ename, salary, i deg. Rozważ te atrybuty jako pola tabeli w tabeli ieidjako klucz podstawowy tej tabeli. Teraz musimy zaprojektować dla niego plik mapowania hibernacji. Plik odwzorowania o nazwiemapping.xml następująco:

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

Powyższy skrypt służy do mapowania klasy jednostki z tabelą bazy danych. W tym pliku

• <entity-mappings> : tag definiuje definicję schematu, aby umożliwić umieszczanie znaczników encji w pliku xml.

• <description> : tag zawiera opis aplikacji.

• <entity>: tag definiuje klasę jednostki, którą chcesz przekonwertować na tabelę w bazie danych. Klasa atrybutu definiuje nazwę klasy jednostki POJO.

• <table>: tag definiuje nazwę tabeli. Jeśli chcesz mieć identyczne nazwy zarówno dla klasy, jak i tabeli, ten tag nie jest potrzebny.

• <attributes> : znacznik definiuje atrybuty (pola w tabeli).

• <id>: tag definiuje klucz podstawowy tabeli. Plik<generated-value> tag określa, jak przypisać wartość klucza podstawowego, taką jak Automatic, Manuallub zaczerpnięte z Sequence.

• <basic> : tag służy do definiowania pozostałych atrybutów tabeli.

• <column-name> : znacznik służy do definiowania nazw pól tabeli w tabeli zdefiniowanych przez użytkownika.

Adnotacje

Zwykle pliki xml służą do konfigurowania określonych składników lub odwzorowywania dwóch różnych specyfikacji składników. W naszym przypadku musimy oddzielnie utrzymywać pliki xml we frameworku. Oznacza to, że podczas pisania mapującego pliku xml musimy porównać atrybuty klasy POJO z tagami encji w pliku mapping.xml.

Oto rozwiązanie. W definicji klasy możemy zapisać część konfiguracyjną za pomocą adnotacji. Adnotacje są używane dla klas, właściwości i metod. Adnotacje zaczynają się od symbolu „@”. Adnotacje są deklarowane przed klasą, właściwością lub metodą. Wszystkie adnotacje JPA są zdefiniowane wjavax.persistence pakiet.

Poniżej znajduje się lista adnotacji użytych w naszych przykładach.

Adnotacja	Opis
@Jednostka	Deklaruje klasę jako jednostkę lub tabelę.
@Stół	Deklaruje nazwę tabeli.
@Podstawowy	Jawnie określa pola bez ograniczeń.
@Embedded	Określa właściwości klasy lub jednostki, której wartością jest wystąpienie klasy możliwej do osadzenia.
@ID	Określa właściwość używaną jako tożsamość (klucz podstawowy tabeli) klasy.
@GeneratedValue	Określa, jak można zainicjować atrybut tożsamości, na przykład automatycznie, ręcznie lub wartość pobrana z tabeli sekwencji.
@Przejściowy	Określa właściwość, która nie jest trwała, tj. Wartość nigdy nie jest przechowywana w bazie danych.
@Kolumna	Określa atrybut kolumny dla właściwości trwałości.
@SequenceGenerator	Określa wartość właściwości, która jest określona w adnotacji @GeneratedValue. Tworzy sekwencję.
@TableGenerator	Określa generator wartości dla właściwości określonej w adnotacji @GeneratedValue. Tworzy tabelę do generowania wartości.
@Typ dostępu	Ten typ adnotacji służy do ustawiania typu dostępu. Jeśli ustawisz @AccessType (FIELD), wtedy dostęp będzie miał miejsce z uwzględnieniem pola. Jeśli ustawisz @AccessType (PROPERTY), wtedy dostęp nastąpi z punktu widzenia właściwości.
@JoinColumn	Określa powiązanie jednostek lub kolekcję jednostek. Jest to używane w asocjacjach typu „wiele do jednego” i „jeden do wielu”.
@UniqueConstraint	Określa pola i unikatowe ograniczenia dla tabeli podstawowej lub dodatkowej.
@ColumnResult	Odwołuje się do nazwy kolumny w zapytaniu SQL za pomocą klauzuli select.
@ManyToMany	Definiuje relację wiele do wielu między tabelami łączenia.
@ManyToOne	Definiuje relację wiele do jednego między tabelami łączenia.
@Jeden za dużo	Definiuje relację jeden do wielu między tabelami łączenia.
@Jeden na jednego	Definiuje relację jeden do jednego między tabelami łączenia.
@NamedQueries	określa listę nazwanych zapytań.
@NamedQuery	Określa zapytanie przy użyciu nazwy statycznej.

Java Bean Standard

Klasa Java hermetyzuje wartości instancji i ich zachowania w pojedynczą jednostkę o nazwie obiekt. Java Bean jest składnikiem lub obiektem do tymczasowego przechowywania i wielokrotnego użytku. Jest to klasa możliwa do serializacji, która ma domyślny konstruktor oraz metody pobierające i ustawiające służące do indywidualnego inicjowania atrybutów instancji.

Konwencje fasoli

• Bean zawiera domyślny konstruktor lub plik zawierający zserializowane wystąpienie. Dlatego fasola może utworzyć instancję innej fasoli.

• Właściwości ziarna można podzielić na właściwości boolowskie lub inne niż boolowskie.

• Właściwość niebędąca wartością logiczną zawiera getter i setter metody.

• Właściwość logiczna zawiera setter i is metoda.

• Getter metoda każdej właściwości powinna zaczynać się małą literą get(konwencja metody Java) i kontynuowano z nazwą pola zaczynającą się od dużej litery. Na przykład nazwa pola tosalary dlatego metodą pobierającą tego pola jest getSalary ().

• Setter metoda każdej właściwości powinna zaczynać się małą literą set (konwencja metody java), kontynuowano z nazwą pola rozpoczynającą się wielką literą i rozszerzeniem argument valueustawić na pole. Na przykład nazwa pola tosalary dlatego metodą ustawiającą tego pola jest setSalary ( double sal ).

• Dla właściwości Boolean, ismetoda, aby sprawdzić, czy jest to prawda, czy fałsz. Na przykład właściwość Booleanempty, the is metoda tego pola to isEmpty ().

W tym rozdziale omówiono proces konfiguracji JPA w systemach opartych na systemach Windows i Linux. JPA można łatwo zainstalować i zintegrować z aktualnym środowiskiem Java, wykonując kilka prostych kroków bez żadnych skomplikowanych procedur konfiguracyjnych. Administracja użytkownikami jest wymagana podczas instalacji.

wymagania systemowe

JDK	Java SE 2 JDK 1.5 lub nowsza
Pamięć	1 GB RAM (zalecane)
Miejsca na dysku	Brak minimalnych wymagań
Wersja systemu operacyjnego	Windows XP lub nowszy, Linux

Przejdźmy teraz do kroków instalacji JPA.

Krok 1: Zweryfikuj instalację Java

Przede wszystkim musisz mieć zainstalowany pakiet Java Software Development Kit (SDK) w swoim systemie. Aby to sprawdzić, wykonaj dowolne z następujących dwóch poleceń w zależności od platformy, na której pracujesz.

Jeśli instalacja Java została wykonana poprawnie, wyświetli się aktualna wersja i specyfikacja instalacji Java. Przykładowe dane wyjściowe podano w poniższej tabeli.

Platforma	Komenda	Przykładowe wyjście
Windows	Otwórz konsolę poleceń i wpisz: \>java –version	Wersja Java „1.7.0_60” Środowisko wykonawcze Java (TM) SE (kompilacja 1.7.0_60-b19) Java Hotspot (TM) 64-bitowa maszyna wirtualna serwera (wersja 24.60-b09, tryb mieszany)
Linux	Otwórz terminal poleceń i wpisz: $java –version	wersja java „1.7.0_25” Otwórz środowisko wykonawcze JDK (rhel-2.3.10.4.el6_4-x86_64) Otwórz 64-bitową maszynę wirtualną serwera JDK (kompilacja 23.7-b01, tryb mieszany)

• Zakładamy, że czytelnicy tego samouczka mają zainstalowany pakiet Java SDK w wersji 1.7.0_60 w swoim systemie.

• Jeśli nie masz Java SDK, pobierz jego aktualną wersję z http://www.oracle.com/technetwork/java/javase/downloads/index.html i zainstaluj.

Krok 2: Skonfiguruj środowisko Java

Ustaw zmienną środowiskową JAVA_HOME tak, aby wskazywała lokalizację katalogu podstawowego, w którym na komputerze jest zainstalowana Java. Na przykład,

Platforma	Opis
Windows	Ustaw JAVA_HOME na C: \ ProgramFiles \ java \ jdk1.7.0_60
Linux	Eksportuj JAVA_HOME = / usr / local / java-current

Dołącz pełną ścieżkę lokalizacji kompilatora Java do ścieżki systemowej.

Platforma	Opis
Windows	Dołącz ciąg „C: \ Program Files \ Java \ jdk1.7.0_60 \ bin” na końcu zmiennej systemowej PATH.
Linux	ŚCIEŻKA eksportu = $ ŚCIEŻKA: $ JAVA_HOME / bin /

Wykonaj polecenie java -version z wiersza polecenia, jak wyjaśniono powyżej.

Krok 3: Instalacja JPA

Możesz przejść przez instalację JPA, używając dowolnego dostawcy JPA z tego samouczka, np. Eclipselink, Hibernate. Prześledźmy instalację JPA za pomocą Eclipselink. W przypadku programowania JPA wymagamy przestrzegania określonej struktury folderów, dlatego lepiej jest używać IDE.

Pobierz formularz Eclipse IDE, klikając łącze https://www.eclipse.org/downloads/ Wybierz EclipseIDE dla programisty JavaEE czyli Eclipse indigo.

Rozpakuj plik zip Eclipse na dysku C. Otwórz Eclipse IDE.

Instalowanie JPA za pomocą Eclipselink

Eclipselink jest biblioteką, dlatego nie możemy dodać go bezpośrednio do Eclipse IDE. Aby zainstalować JPA za pomocą Eclipselink, należy wykonać poniższe czynności.

• Utwórz nowy projekt JPA, wybierając File->New->JPA Project w środowisku Eclipse IDE w następujący sposób:

  

• Pojawi się okno dialogowe o nazwie New JPA Project. Wpisz nazwę projektututorialspoint_JPA_Eclipselink, Sprawdź jre wersja i kliknij dalej:

  

• Kliknij opcję pobierania biblioteki (jeśli nie masz biblioteki) w sekcji biblioteki użytkownika.

  

• Wybierz najnowszą wersję biblioteki Eclipselink w oknie dialogowym Pobierz bibliotekę i kliknij dalej w następujący sposób:

  

• Zaakceptuj warunki licencji i kliknij Zakończ, aby pobrać bibliotekę.

  

• 6. Pobieranie rozpocznie się tak, jak pokazano na poniższym zrzucie ekranu.

  

• Po pobraniu wybierz pobraną bibliotekę w sekcji biblioteki użytkownika i kliknij Zakończ.

  

• Na koniec otrzymasz plik projektu w formacie Package Explorerw Eclipse IDE. Wyodrębnij wszystkie pliki, otrzymasz folder i hierarchię plików w następujący sposób:

  

Dodawanie łącznika MySQL do projektu

Każdy przykład, który tutaj omawiamy, wymaga połączenia z bazą danych. Rozważmy bazę danych MySQL do operacji na bazach danych. Do interakcji z programem Java wymaga mysql-connector jar.

Postępuj zgodnie z instrukcjami, aby skonfigurować jar bazy danych w projekcie.

• Przejdź do właściwości projektu ->Ścieżkę budowania Java, klikając prawym przyciskiem myszy. Pojawi się okno dialogowe, jak pokazano na poniższym zrzucie ekranu. Kliknij Dodaj zewnętrzne słoiki.

  

• Przejdź do lokalizacji jar w pamięci systemowej, wybierz plik i kliknij Otwórz.

  

• Kliknij OK w oknie dialogowym właściwości. Otrzymasz Jar łącznika MySQL do swojego projektu. Teraz możesz wykonywać operacje na bazach danych za pomocą MySQL.

W tym rozdziale wykorzystano prosty przykład, aby zademonstrować, jak działa JPA. Jako przykład rozważmy zarządzanie pracownikami. Załóżmy, że kierownictwo pracowników tworzy, aktualizuje, wyszukuje i usuwa rekordy pracownika. Jak wspomniano, używamy bazy danych MySQL do operacji na bazach danych.

Główne moduły w tym przykładzie są następujące:

• Model or POJO

  Employee.java

• Persistence

  Persistence.xml

• Service

  CreatingEmployee.java

  UpdatingEmployee.java

  FindingEmployee.java

  DeletingEmployee.java

Weźmy hierarchię pakietów, której używaliśmy podczas instalacji JPA z Eclipselink. Postępuj zgodnie z hierarchią w tym przykładzie, jak pokazano poniżej:

Tworzenie jednostek

Byty to nic innego jak fasola lub modele. W tym przykładzie użyjemyEmployee jako całość. eid, ename, salary, i degsą atrybutami tej jednostki. Zawiera domyślny konstruktor oraz metody ustawiające i pobierające te atrybuty.

W powyższej hierarchii utwórz pakiet o nazwie ‘com.tutorialspoint.eclipselink.entity’, pod ‘src’Pakiet (źródło). Utwórz klasę o nazwieEmployee.java pod danym pakietem w następujący sposób:

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

W powyższym kodzie użyliśmy adnotacji @Entity, aby uczynić tę klasę POJO encją.

Przed przejściem do kolejnego modułu musimy stworzyć bazę danych dla encji relacyjnej, w której będzie rejestrowana baza danych persistence.xmlplik. Otwórz Środowisko pracy MySQL i wpisz hte po zapytaniu.

create database jpadb
use jpadb

Persistence.xml

Moduł ten odgrywa kluczową rolę w koncepcji JPA. W tym pliku xml zarejestrujemy bazę danych i określimy klasę jednostki.

W przedstawionej powyżej hierarchii pakietów, persistence.xml w pakiecie JPA Content wygląda następująco:

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

W powyższym pliku XML <persistence-unit> tag jest zdefiniowany z określoną nazwą dla trwałości JPA. Plik<class>tag definiuje klasę jednostki z nazwą pakietu. Plik<properties> tag definiuje wszystkie właściwości, a <property>tag definiuje każdą właściwość, taką jak rejestracja bazy danych, specyfikacja adresu URL, nazwa użytkownika i hasło. Oto właściwości Eclipselink. Ten plik skonfiguruje bazę danych.

Operacje trwałości

Operacje trwałości są używane do interakcji z bazą danych i są load i storeoperacje. W komponencie biznesowym wszystkie operacje trwałości należą do klas usług.

W powyższej hierarchii pakietów utwórz pakiet o nazwie ‘com.tutorialspoint.eclipselink.service’, pod ‘src’(źródłowy) pakiet. Wszystkie klasy usług o nazwach CreateEmloyee.java, UpdateEmployee.java, FindEmployee.java i DeleteEmployee.java. podlega podanemu pakietowi w następujący sposób:

Utwórz pracownika

Poniższy segment kodu przedstawia sposób tworzenia klasy Employee o nazwie 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( );
	}
}

W powyższym kodzie createEntityManagerFactory ()tworzy jednostkę trwałości, podając tę ​​samą unikalną nazwę, którą podajemy dla jednostki trwałości w pliku persistent.xml. Plikentitymanagerfactory obiekt utworzy plik entitymanger przykład za pomocą createEntityManager ()metoda. Plikentitymanager obiekt tworzy entitytransactionprzykład do zarządzania transakcjami. Używającentitymanager obiektu, możemy utrwalać jednostki w bazie danych.

Po skompilowaniu i wykonaniu powyższego programu otrzymasz powiadomienia z biblioteki eclipselink na panelu konsoli eclipse IDE.

Aby uzyskać wynik, otwórz Środowisko robocze MySQL i wpisz następujące zapytania.

use jpadb
select * from employee

Efektywna tabela bazy danych o nazwie employee zostanie wyświetlony w formie tabelarycznej w następujący sposób:

Eid	Ename	Wynagrodzenie	Deg
1201	Gopal	40000	Menedżer techniczny

Zaktualizuj pracownika

Aby zaktualizować rekordy pracownika, musimy pobrać istniejące rekordy z bazy danych, wprowadzić zmiany i ostatecznie zatwierdzić je do bazy danych. Klasa o nazwieUpdateEmployee.java przedstawia się następująco:

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

Po skompilowaniu i wykonaniu powyższego programu otrzymasz powiadomienia z biblioteki Eclipselink na panelu konsoli eclipse IDE.

Aby uzyskać wynik, otwórz Środowisko robocze MySQL i wpisz następujące zapytania.

use jpadb
select * from employee

Efektywna tabela bazy danych o nazwie employee zostanie wyświetlony w formie tabelarycznej w następujący sposób:

Eid	Ename	Wynagrodzenie	Deg
1201	Gopal	46000	Menedżer techniczny

Wynagrodzenie pracownika 1201 zostało zaktualizowane do 46000.

Znajdź pracownika

Aby znaleźć rekordy pracownika, będziemy musieli pobrać istniejące dane z bazy danych i wyświetlić je. W tej operacji EntityTransaction nie jest stosowana podczas pobierania rekordu.

Klasa o nazwie FindEmployee.java następująco.

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

Po skompilowaniu i wykonaniu powyższego programu, otrzymasz następujące dane wyjściowe z biblioteki Eclipselink na panelu konsoli eclipse IDE.

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

Usuwanie pracownika

Aby usunąć akta pracownika, najpierw znajdziemy istniejące zapisy, a następnie je usuniemy. Tutaj EntityTransaction odgrywa ważną rolę.

Klasa o nazwie DeleteEmployee.java następująco:

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

Po skompilowaniu i wykonaniu powyższego programu otrzymasz powiadomienia z biblioteki Eclipselink na panelu konsoli eclipse IDE.

Aby uzyskać wynik, otwórz Środowisko robocze MySQL i wpisz następujące zapytania.

use jpadb
select * from employee

Powstała baza danych o nazwie employee będą miały puste rekordy.

Po ukończeniu wszystkich modułów w tym przykładzie hierarchia pakietów i plików wygląda następująco:

W tym rozdziale opisano JPQL i sposób, w jaki działa z jednostkami trwałości. W tym rozdziale podane przykłady są zgodne z tą samą hierarchią pakietów, której używaliśmy w poprzednim rozdziale.

Język Java Persistence Query

JPQL to skrót od Java Persistence Query Language. Służy do tworzenia zapytań dotyczących jednostek do przechowywania w relacyjnej bazie danych. JPQL jest rozwijany w oparciu o składnię SQL. Ale nie wpłynie to bezpośrednio na bazę danych.

JPQL może pobierać dane za pomocą klauzuli SELECT, może wykonywać zbiorcze aktualizacje za pomocą klauzuli UPDATE i klauzuli DELETE.

Struktura zapytania

Składnia JPQL jest bardzo podobna do składni SQL. Posiadanie składni podobnej do SQL jest zaletą, ponieważ SQL jest prosty i szeroko stosowany. SQL działa bezpośrednio z tabelami, rekordami i polami relacyjnej bazy danych, podczas gdy JPQL działa z klasami i instancjami Java.

Na przykład zapytanie JPQL może pobrać obiekt jednostki, a nie zestaw wyników pola z bazy danych, jak w przypadku SQL. Struktura zapytania JPQL w następujący sposób.

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

Struktura zapytań JPQL DELETE i UPDATE jest następująca.

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

Funkcje skalarne i agregujące

Funkcje skalarne zwracają wynikowe wartości na podstawie wartości wejściowych. Funkcje agregujące zwracają wynikowe wartości, obliczając wartości wejściowe.

Posłużymy się tym samym przykładem zarządzania pracownikami, co w poprzednim rozdziale. Tutaj przejdziemy przez klasy usług z wykorzystaniem funkcji skalarnych i agregujących JPQL.

Załóżmy, że jpadb.employee tabela zawiera następujące rekordy.

Eid	Ename	Wynagrodzenie	Deg
1201	Gopal	40000	Menedżer techniczny
1202	Manisha	40000	Proof Reader
1203	Masthanvali	40000	Pisarz techniczny
1204	Satish	30000	Pisarz techniczny
1205	Kryszna	30000	Pisarz techniczny
1206	Kiran	35000	Proof Reader

Utwórz klasę o nazwie ScalarandAggregateFunctions.java pod com.tutorialspoint.eclipselink.service pakiet w następujący sposób.

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

Po skompilowaniu i wykonaniu powyższego programu otrzymasz następujące dane wyjściowe na panelu konsoli 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

Słowa kluczowe między, i, jak

Between, And, i Likesą głównymi słowami kluczowymi JPQL. Te słowa kluczowe są używane poWhere clause w zapytaniu.

Utwórz klasę o nazwie BetweenAndLikeFunctions.java pod com.tutorialspoint.eclipselink.service pakiet w następujący sposób:

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

Po skompilowaniu i wykonaniu powyższego programu w panelu konsoli Eclipse IDE otrzymasz następujące dane wyjściowe.

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

Zamawianie

Aby zamówić rekordy w JPQL, używamy klauzuli ORDER BY. Użycie tej klauzuli jest takie samo jak w SQL, ale dotyczy encji. Poniższy przykład pokazuje, jak używać klauzuli ORDER BY.

Utwórz zajęcia Ordering.java pod com.tutorialspoint.eclipselink.service pakiet w następujący sposób:

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

kompilując i wykonując powyższy program, w panelu konsoli środowiska Eclipse IDE otrzymasz następujący wynik.

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

Nazwane zapytania

Adnotacja @NamedQuery jest zdefiniowana jako zapytanie ze wstępnie zdefiniowanym ciągiem zapytania, którego nie można zmienić. W przeciwieństwie do zapytań dynamicznych, nazwane zapytania mogą poprawić organizację kodu, oddzielając ciągi zapytań JPQL od POJO. Przekazuje również parametry zapytania, zamiast dynamicznie osadzać literały w ciągu zapytania, a tym samym generuje bardziej wydajne zapytania.

Przede wszystkim dodaj adnotację @NamedQuery do klasy jednostki Employee o nazwie Employee.java pod com.tutorialspoint.eclipselink.entity pakiet w następujący sposób:

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

Utwórz klasę o nazwie NamedQueries.java pod com.tutorialspoint.eclipselink.service pakiet w następujący sposób:

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

Po skompilowaniu i wykonaniu powyższego programu otrzymasz następujące dane wyjściowe w panelu konsoli Eclipse IDE.

Employee ID :1204	 Employee Name :Satish

Po dodaniu wszystkich powyższych klas hierarchia pakietów wygląda następująco:

Chętne i leniwe pobieranie

Najważniejszą koncepcją JPA jest wykonanie zduplikowanej kopii bazy danych w pamięci podręcznej. Podczas transakcji z bazą danych JPA najpierw tworzy zduplikowany zestaw danych i dopiero po zatwierdzeniu za pomocą menedżera jednostek zmiany są wprowadzane do bazy danych.

Istnieją dwa sposoby pobierania rekordów z bazy danych.

Chętny aport

Podczas szybkiego pobierania powiązane obiekty potomne są przesyłane automatycznie podczas pobierania określonego rekordu.

Leniwe pobieranie

W przypadku pobierania z opóźnieniem powiązane obiekty nie są przesyłane automatycznie, chyba że wyraźnie o nie poprosisz. Przede wszystkim sprawdza dostępność powiązanych obiektów i powiadamia. Później, jeśli wywołasz dowolną metodę pobierającą tej jednostki, pobierze ona wszystkie rekordy.

Pobieranie z opóźnieniem jest możliwe, gdy próbujesz pobrać rekordy po raz pierwszy. W ten sposób kopia całego rekordu jest już przechowywana w pamięci podręcznej. Preferowane jest pobieranie z opóźnieniem pod względem wydajności.

JPA to biblioteka wydana ze specyfikacjami Java. Dlatego obsługuje wszystkie koncepcje zorientowane obiektowo na trwałość jednostek. Do tej pory skończyliśmy z podstawami mapowania obiektowo-relacyjnego. W tym rozdziale omówiono zaawansowane odwzorowania między obiektami i encjami relacyjnymi.

Strategie dziedziczenia

Dziedziczenie jest podstawową koncepcją każdego języka zorientowanego obiektowo, dlatego możemy używać relacji dziedziczenia lub strategii między bytami. WZP obsługują trzy rodzaje strategii dziedziczenia: SINGLE_TABLE, JOINED_TABLE i TABLE_PER_CONCRETE_CLASS.

Rozważmy przykład. Poniższy diagram przedstawia trzy klasy, a mianowicie. Staff, TeachingStaff i NonTeachingStaff oraz ich relacje.

Na powyższym diagramie Personel jest bytem, ​​podczas gdy TeachingStaff i NonTeachingStaff są pod-podmiotami Staff. Tutaj użyjemy powyższego przykładu, aby zademonstrować wszystkie trzy strategie dziedziczenia.

Strategia jednej tabeli

Strategia jednotabelowa bierze wszystkie pola klas (zarówno super, jak i podklasy) i mapuje je w pojedynczą tabelę znaną jako strategia SINGLE_TABLE. Tutaj wartość dyskryminatora odgrywa kluczową rolę w różnicowaniu wartości trzech jednostek w jednej tabeli.

Rozważmy powyższy przykład. TeachingStaff i NonTeachingStaff to podklasy Staff. Zgodnie z koncepcją dziedziczenia podklasa dziedziczy właściwości swojej nadklasy. Dlatego sid i sname to pola należące zarówno do TeachingStaff, jak i NonTeachingStaff. Utwórz projekt JPA. Wszystkie moduły tego projektu są następujące:

Tworzenie jednostek

Utwórz pakiet o nazwie ‘com.tutorialspoint.eclipselink.entity’ pod ‘src’pakiet. Utwórz nową klasę Java o nazwieStaff.javapod danym pakietem. Klasa jednostki Staff jest przedstawiona w następujący sposób:

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

W powyższym kodzie @DescriminatorColumn określa nazwę pola (type) a jego wartości pokazują pozostałe pola (Teaching i NonTeachingStaff).

Utwórz podklasę (klasę) do klasy Staff o nazwie TeachingStaff.java pod com.tutorialspoint.eclipselink.entitypakiet. Klasa TeachingStaff Entity jest przedstawiona w następujący sposób:

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

Utwórz podklasę (klasę) do klasy Staff o nazwie NonTeachingStaff.java pod com.tutorialspoint.eclipselink.entitypakiet. Klasa NonTeachingStaff Entity jest pokazana w następujący sposób:

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 zawiera informacje o konfiguracji bazy danych oraz informacje o rejestracji klas jednostek. Plik xml jest przedstawiony w następujący sposób:

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

Klasa usług

Klasy usług są częścią implementacyjną komponentu biznesowego. Utwórz pakiet pod‘src’ pakiet o nazwie ‘com.tutorialspoint.eclipselink.service’.

Utwórz klasę o nazwie SaveClient.javapod danym pakietem do przechowywania pól klas Staff, TeachingStaff i NonTeachingStaff. Klasa SaveClient jest pokazana w następujący sposób:

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

Po skompilowaniu i wykonaniu powyższego programu otrzymasz powiadomienia na panelu konsoli Eclipse IDE. Sprawdź dane wyjściowe w środowisku roboczym MySQL. Dane wyjściowe w formacie tabelarycznym przedstawiono w następujący sposób:

Sid	Rodzaj	Sname	AreaExpertise	Kwalifikacja	Przedmiot ekspertyzy
1	TS	Gopal		MSC MED	Matematyka
2	TS	Manisha		ŁÓŻKO BSC	język angielski
3	NS	Satish	Konta
4	NS	Kryszna	Office Admin

Ostatecznie otrzymasz pojedynczą tabelę zawierającą pola wszystkich trzech klas z kolumną dyskryminatora o nazwie Type (pole).

Dołączył do strategii przy stole

Strategia łączenia tabeli polega na współużytkowaniu kolumny, do której się odwołujemy, zawierającej unikatowe wartości w celu dołączenia do tabeli i dokonywania łatwych transakcji. Rozważmy ten sam przykład co powyżej.

Utwórz projekt JPA. Wszystkie moduły projektu przedstawiono poniżej.

Tworzenie jednostek

Utwórz pakiet o nazwie ‘com.tutorialspoint.eclipselink.entity’ pod ‘src’pakiet. Utwórz nową klasę Java o nazwieStaff.javapod danym pakietem. Klasa jednostki Staff jest przedstawiona w następujący sposób:

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

Utwórz podklasę (klasę) do klasy Staff o nazwie TeachingStaff.java pod com.tutorialspoint.eclipselink.entitypakiet. Klasa TeachingStaff Entity jest przedstawiona w następujący sposób:

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

Utwórz podklasę (klasę) do klasy Staff o nazwie NonTeachingStaff.java pod com.tutorialspoint.eclipselink.entitypakiet. Klasa NonTeachingStaff Entity jest pokazana w następujący sposób:

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

Plik Persistence.xml zawiera informacje o konfiguracji bazy danych i informacje o rejestracji klas jednostek. Plik xml jest przedstawiony w następujący sposób:

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

Klasa usług

Klasy usług są częścią implementacyjną komponentu biznesowego. Utwórz pakiet pod‘src’ pakiet o nazwie ‘com.tutorialspoint.eclipselink.service’.

Utwórz klasę o nazwie SaveClient.javaw ramach danego pakietu do przechowywania pól klasy Staff, TeachingStaff i NonTeachingStaff. Następnie klasa SaveClient jest wyświetlana w następujący sposób:

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

Po skompilowaniu i wykonaniu powyższego programu otrzymasz powiadomienia w panelu konsoli Eclipse IDE. Aby uzyskać dane wyjściowe, sprawdź Środowisko pracy MySQL.

Tutaj tworzone są trzy tabele i wynik staff tabela jest wyświetlana w formacie tabelarycznym.

Sid	Dtype	Sname
1	Kadra nauczycielska	Gopal
2	Kadra nauczycielska	Manisha
3	NonTeachingStaff	Satish
4	NonTeachingStaff	Kryszna

Wynik TeachingStaff tabela jest wyświetlana w następujący sposób:

Sid	Kwalifikacja	Przedmiot ekspertyzy
1	MSC MED	Matematyka
2	ŁÓŻKO BSC	język angielski

W powyższej tabeli sid jest kluczem obcym (pole odniesienia z tabeli personelu). Wynik NonTeachingStaff tabela jest wyświetlana w następujący sposób:

Sid	AreaExpertise
3	Konta
4	Office Admin

Na koniec trzy tabele są tworzone przy użyciu odpowiednich pól, a pole SID jest wspólne dla wszystkich trzech tabel. W tabeli Staff kluczem podstawowym jest identyfikator SID. W pozostałych dwóch tabelach (TeachingStaff i NonTeachingStaff) SID jest kluczem obcym.

Tabela według strategii klasowej

Strategia tabeli na klasę polega na utworzeniu tabeli dla każdego podelementu. Tabela Staff zostanie utworzona, ale będzie zawierać wartości null. Wartości pól tabeli Staff muszą być wspólne dla obu tabel TeachingStaff i NonTeachingStaff.

Rozważmy ten sam przykład co powyżej.

Tworzenie jednostek

Utwórz pakiet o nazwie ‘com.tutorialspoint.eclipselink.entity’ pod ‘src’pakiet. Utwórz nową klasę Java o nazwieStaff.javapod danym pakietem. Klasa jednostki Staff jest przedstawiona w następujący sposób:

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

Utwórz podklasę (klasę) do klasy Staff o nazwie TeachingStaff.java pod com.tutorialspoint.eclipselink.entitypakiet. Klasa TeachingStaff Entity jest przedstawiona w następujący sposób:

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

Utwórz podklasę (klasę) do klasy Staff o nazwie NonTeachingStaff.java pod com.tutorialspoint.eclipselink.entitypakiet. Klasa NonTeachingStaff Entity jest pokazana w następujący sposób:

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

Plik Persistence.xml zawiera informacje o konfiguracji bazy danych i informacje o rejestracji klas jednostek. Plik xml jest przedstawiony w następujący sposób:

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

Klasa usług

Klasy usług są częścią implementacyjną komponentu biznesowego. Utwórz pakiet pod‘src’ pakiet o nazwie ‘com.tutorialspoint.eclipselink.service’.

Utwórz klasę o nazwie SaveClient.javapod danym pakietem do przechowywania pól klas Staff, TeachingStaff i NonTeachingStaff. Klasa SaveClient jest pokazana w następujący sposób:

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

Po skompilowaniu i wykonaniu powyższego programu otrzymasz powiadomienia na panelu konsoli Eclipse IDE. Aby uzyskać dane wyjściowe, sprawdź Środowisko pracy MySQL.

Tutaj są tworzone trzy tabele i plik Staff tabela zawiera puste rekordy.

Wynik TeachingStaff jest wyświetlany w następujący sposób:

Sid	Kwalifikacja	Sname	Przedmiot ekspertyzy
1	MSC MED	Gopal	Matematyka
2	ŁÓŻKO BSC	Manisha	język angielski

Powyższa tabela TeachingStaff zawiera pola zarówno Staff, jak i TeachingStaff Entities.

Wynik NonTeachingStaff jest wyświetlany w następujący sposób:

Sid	AreaExpertise	Sname
3	Konta	Satish
4	Office Admin	Kryszna

Powyższa tabela NonTeachingStaff zawiera pola zarówno Staff, jak i NonTeachingStaff Entities.

Ten rozdział poprowadzi cię przez relacje między bytami. Generalnie relacje są bardziej efektywne między tabelami w bazie danych. Tutaj klasy encji są traktowane jako tabele relacyjne (koncepcja JPA), dlatego relacje między klasami jednostek są następujące:

• @ManyToOne Relation
• @OneToMany Relation
• @OneToOne Relacja
• @ManyToMany Relation

@ManyToOne Relation

Relacja wiele do jednego między jednostkami istnieje, gdy do jednej jednostki (kolumny lub zestawu kolumn) odwołuje się inna jednostka (kolumna lub zestaw kolumn) zawierająca unikatowe wartości. W relacyjnych bazach danych relacje te są stosowane przy użyciu klucza obcego / klucza podstawowego między tabelami.

Rozważmy przykład relacji między jednostkami Pracownik i Dział. W sposób jednokierunkowy, tj. Od pracownika do działu, ma zastosowanie relacja wiele do jednego. Oznacza to, że każdy rekord pracownika zawiera jeden identyfikator działu, który powinien być kluczem podstawowym w tabeli Dział. W tabeli Employee id działu to klucz obcy.

Poniższy diagram przedstawia relację wiele do jednego między dwiema tabelami.

Utwórz projekt JPA w środowisku Eclipse IDE o nazwie JPA_Eclipselink_MTO. Wszystkie moduły tego projektu zostały omówione poniżej.

Tworzenie jednostek

Postępuj zgodnie z powyższym schematem tworzenia jednostek. Utwórz pakiet o nazwie‘com.tutorialspoin.eclipselink.entity’ pod ‘src’pakiet. Utwórz klasę o nazwieDepartment.javapod danym pakietem. Jednostka klasy Dział jest pokazana w następujący sposób:

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

Utwórz drugą jednostkę w tej relacji - o nazwie Klasa jednostki pracownika Employee.java pod ‘com.tutorialspoint.eclipselink.entity’pakiet. Klasa jednostki Pracownik jest przedstawiona w następujący sposób:

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

Plik Persistence.xml jest wymagany do skonfigurowania bazy danych i rejestracji klas jednostek.

Persitence.xml zostanie utworzony przez eclipse IDE podczas tworzenia projektu JPA. Szczegóły konfiguracji są specyfikacjami użytkownika. Plik persistence.xml jest wyświetlany w następujący sposób:

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

Klasy usług

Ten moduł zawiera klasy usług, które implementują część relacyjną za pomocą inicjalizacji atrybutu. Utwórz pakiet pod‘src’ pakiet o nazwie ‘com.tutorialspoint.eclipselink.service’. Klasa DAO o nazwieManyToOne.javajest tworzony w ramach danego pakietu. Klasa DAO jest przedstawiona w następujący sposób:

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

Po skompilowaniu i wykonaniu powyższego programu otrzymasz powiadomienia na panelu konsoli Eclipse IDE. Aby uzyskać dane wyjściowe, sprawdź Środowisko pracy MySQL. W tym przykładzie tworzone są dwie tabele.

Przekaż następujące zapytanie w interfejsie MySQL i wynik Department tabela zostanie wyświetlona w następujący sposób:

Select * from department

ID	Nazwa
101	Rozwój

Przekaż następujące zapytanie w interfejsie MySQL i wynik Employee tabela zostanie wyświetlona w następujący sposób.

Select * from employee

Eid	Deg	Ename	Wynagrodzenie	Department_Id
102	Pisarz techniczny	Satish	45000	101
103	Pisarz techniczny	Kryszna	45000	101
104	Pisarz techniczny	Masthanwali	50000	101

W powyższej tabeli Deparment_Id jest kluczem obcym (polem referencyjnym) z tabeli Dział.

@OneToMany Relation

W tej relacji każdy wiersz jednej encji odwołuje się do wielu rekordów podrzędnych w innej encji. Ważne jest to, że rekordy podrzędne nie mogą mieć wielu rodziców. W relacji jeden do wielu między tabelą A i tabelą B każdy wiersz tabeli A można połączyć z jednym lub wieloma wierszami tabeli B.

Rozważmy powyższy przykład. Załóżmy, że tabele pracowników i działów w powyższym przykładzie są połączone w odwrotny sposób jednokierunkowo, a następnie relacja staje się relacją jeden do wielu. Utwórz projekt JPA w środowisku Eclipse IDE o nazwieJPA_Eclipselink_OTM. Wszystkie moduły tego projektu zostały omówione poniżej.

Tworzenie jednostek

Postępuj zgodnie z powyższym schematem tworzenia jednostek. Utwórz pakiet o nazwie‘com.tutorialspoin.eclipselink.entity’ pod ‘src’pakiet. Utwórz klasę o nazwieDepartment.javapod danym pakietem. Jednostka klasy Dział jest pokazana w następujący sposób:

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

Utwórz drugą jednostkę w tej relacji - klasa jednostki pracownika o nazwie Employee.java pod ‘com.tutorialspoint.eclipselink.entity’pakiet. Klasa jednostki Pracownik jest przedstawiona w następujący sposób:

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

Plik persistence.xml jest następujący:

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

Klasy usług

Ten moduł zawiera klasy usług, które implementują część relacyjną za pomocą inicjalizacji atrybutu. Utwórz pakiet pod‘src’ pakiet o nazwie ‘com.tutorialspoint.eclipselink.service’. Klasa DAO o nazwieOneToMany.javajest tworzony w ramach danego pakietu. Klasa DAO jest przedstawiona w następujący sposób:

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

Po skompilowaniu i wykonaniu powyższego programu otrzymasz powiadomienia w panelu konsoli Eclipse IDE. Aby uzyskać dane wyjściowe, sprawdź Środowisko pracy MySQL w następujący sposób.

W tym projekcie tworzone są trzy tabele. Przekaż następujące zapytanie w interfejsie MySQL, a wynik tabeli działu_mployee zostanie wyświetlony w następujący sposób:

Select * from department_Id;

Department_ID	Employee_Eid
254	251
254	252
254	253

W powyższej tabeli deparment_id i employee_id to klucze obce (pola referencyjne) z tabel działu i pracownika.

Przekaż następujące zapytanie w interfejsie MySQL, a wynik tabeli działu zostanie wyświetlony w formie tabelarycznej w następujący sposób.

Select * from department;

ID	Nazwa
254	Rozwój

Przekaż następujące zapytanie w interfejsie MySQL, a wynik tabeli pracowników zostanie wyświetlony w następujący sposób:

Select * from employee;

Eid	Deg	Ename	Wynagrodzenie
251	Pisarz techniczny	Satish	45000
252	Pisarz techniczny	Kryszna	45000
253	Pisarz techniczny	Masthanwali	50000

@OneToOne Relacja

W relacji jeden do jednego jeden element może być powiązany tylko z jednym innym elementem. Oznacza to, że każdy wiersz jednej jednostki odnosi się do jednego i tylko jednego wiersza innej jednostki.

Rozważmy powyższy przykład. Employee i Departmentw odwrotnym jednokierunkowym trybie relacja jest relacją jeden-do-jednego. Oznacza to, że każdy pracownik należy tylko do jednego działu. Utwórz projekt JPA w środowisku Eclipse IDE o nazwieJPA_Eclipselink_OTO. Wszystkie moduły tego projektu zostały omówione poniżej.

Tworzenie jednostek

Postępuj zgodnie z powyższym schematem tworzenia jednostek. Utwórz pakiet o nazwie‘com.tutorialspoin.eclipselink.entity’ pod ‘src’pakiet. Utwórz klasę o nazwieDepartment.javapod danym pakietem. Jednostka klasy Dział jest pokazana w następujący sposób:

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

Utwórz drugą jednostkę w tej relacji - klasa jednostki pracownika o nazwie Employee.java pod ‘com.tutorialspoint.eclipselink.entity’pakiet. Klasa jednostki Pracownik jest przedstawiona w następujący sposób:

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

Plik Persistence.xml w następujący sposób:

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

Klasy usług

Utwórz pakiet pod ‘src’ pakiet o nazwie ‘com.tutorialspoint.eclipselink.service’. Klasa DAO o nazwieOneToOne.javajest tworzony w ramach danego pakietu. Klasa DAO jest przedstawiona w następujący sposób:

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

Po skompilowaniu i wykonaniu powyższego programu otrzymasz powiadomienia w panelu konsoli Eclipse IDE. Aby uzyskać dane wyjściowe, sprawdź Środowisko robocze MySQL w następujący sposób.

W powyższym przykładzie tworzone są dwie tabele. Podaj poniższe zapytanie w interfejsie MySQL, a wynik tabeli działów zostanie wyświetlony w następujący sposób:

Select * from department

ID	Nazwa
301	Rozwój

Przekaż następujące zapytanie w interfejsie MySQL i wynik employee tabela zostanie wyświetlona w następujący sposób:

Select * from employee

Eid	Deg	Ename	Wynagrodzenie	Department_id
302	Pisarz techniczny	Satish	45000	301

@ManyToMany Relation

Relacja wiele do wielu występuje, gdy jeden lub więcej wierszy z jednej encji jest skojarzonych z więcej niż jednym wierszem w innej encji.

Rozważmy przykład relacji między dwoma podmiotami: Class i Teacher. W sposób dwukierunkowy zarówno klasa, jak i nauczyciel mają relację wiele do jednego. Oznacza to, że każdy rekord Klasy jest kierowany przez zestaw Nauczycieli (identyfikatory nauczycieli), który powinien być kluczem podstawowym w tabeli Nauczyciela i przechowywany w tabeli Nauczyciel_Klasa i odwrotnie. W tym przypadku tabela Teachers_Class zawiera oba pola kluczy obcych. Utwórz projekt JPA w środowisku Eclipse IDE o nazwieJPA_Eclipselink_MTM. Wszystkie moduły tego projektu zostały omówione poniżej.

Tworzenie jednostek

Utwórz jednostki, postępując zgodnie ze schematem przedstawionym na powyższym diagramie. Utwórz pakiet o nazwie‘com.tutorialspoin.eclipselink.entity’ pod ‘src’pakiet. Utwórz klasę o nazwieClas.javapod danym pakietem. Jednostka klasy Dział jest pokazana w następujący sposób:

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

Utwórz drugą jednostkę w tej relacji - klasa jednostki pracownika o nazwie Teacher.java pod ‘com.tutorialspoint.eclipselink.entity’pakiet. Klasa jednostki Pracownik jest przedstawiona w następujący sposób:

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

Plik Persistence.xml w następujący sposób:

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

Klasy usług

Utwórz pakiet pod ‘src’ pakiet o nazwie ‘com.tutorialspoint.eclipselink.service’. Klasa DAO o nazwieManyToMany.javajest tworzony w ramach danego pakietu. Klasa DAO jest przedstawiona w następujący sposób:

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

W tym przykładowym projekcie tworzone są trzy tabele. Przekaż następujące zapytanie w interfejsie MySQL, a wynik tabeli teacher_clas zostanie wyświetlony w następujący sposób:

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

W powyższej tabeli teacher_tid to klucz obcy z tabeli nauczyciela, a classet_cidto klucz obcy z tabeli klas. Dlatego różni nauczyciele są przydzielani do różnych klas.

Podaj następujące zapytanie w interfejsie MySQL, a wynik tabeli nauczyciela zostanie wyświetlony w następujący sposób:

Select * from teacher

Porządek	Przedmiot	Imię
354	Jawa	Satish
355	Adv Java	Kryszna
356	DB2	Masthanvali

Przekaż następujące zapytanie w interfejsie MySQL i wynik clas tabela zostanie wyświetlona w następujący sposób:

Select * from clas

Cid	Cname
351	1
352	2nd
353	3rd

Kryteria to predefiniowany interfejs API używany do definiowania zapytań dotyczących jednostek. Jest to alternatywny sposób definiowania zapytania JPQL. Te zapytania są bezpieczne dla typów, przenośne i łatwe do zmodyfikowania przez zmianę składni. Podobnie jak JPQL, jest zgodny z abstrakcyjnym schematem (schematem łatwym do edycji) i osadzonymi obiektami. Interfejs API metadanych jest połączony z interfejsem API kryteriów w celu modelowania trwałej jednostki dla zapytań kryterialnych.

Główną zaletą interfejsu Criteria API jest to, że błędy można wykryć wcześniej podczas kompilacji. Zapytania JPQL oparte na ciągach znaków i zapytania oparte na kryteriach JPA mają taką samą wydajność i efektywność.

Historia kryteriów API

Kryteria są zawarte we wszystkich wersjach WZP, dlatego każdy krok kryteriów jest zawarty w specyfikacjach WZP.

• W JPA 2.0 opracowano kryteria zapytań API, standaryzację zapytań.
• W JPA 2.1 uwzględniono aktualizację i usuwanie kryteriów (zbiorcza aktualizacja i usuwanie).

Kryteria Struktura zapytania

Kryteria i JPQL są ściśle powiązane i mogą projektować przy użyciu podobnych operatorów w swoich zapytaniach. Wynikajavax.persistence.criteriapakiet do projektowania zapytania. Struktura zapytania oznacza zapytanie z kryteriami składni.

Następujące zapytanie z prostymi kryteriami zwraca wszystkie wystąpienia klasy jednostki w źródle danych.

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

Zapytanie przedstawia podstawowe kroki tworzenia kryteriów.

• EntityManager instancja służy do tworzenia obiektu CriteriaBuilder.

• CriteriaQueryinstancja służy do tworzenia obiektu zapytania. Atrybuty tego obiektu zapytania zostaną zmodyfikowane szczegółami zapytania.

• CriteriaQuery.form jest wywoływana w celu ustawienia katalogu głównego zapytania.

• CriteriaQuery.select jest wywoływana w celu ustawienia typu listy wyników.

• TypedQuery<T> instancja służy do przygotowania zapytania do wykonania i określenia typu wyniku zapytania.

• getResultListna obiekcie TypedQuery <T>, aby wykonać zapytanie. Ta kwerenda zwraca kolekcję jednostek, wynik jest przechowywany na liście.

Przykład kryteriów API

Rozważmy przykład bazy danych pracowników. Załóżmy, że tabela jpadb.employee zawiera następujące rekordy:

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

Utwórz projekt JPA w środowisku Eclipse IDE o nazwie JPA_Eclipselink_Criteria. Wszystkie moduły tego projektu są omówione poniżej:

Tworzenie jednostek

Utwórz pakiet o nazwie com.tutorialspoint.eclipselink.entity pod ‘src’

Utwórz klasę o nazwie Employee.javapod danym pakietem. Klasa Jednostka Pracownik jest pokazana w następujący sposób:

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

Plik Persistence.xml jest następujący:

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

Klasy usług

Ten moduł zawiera klasy usług, które implementują część zapytania Criteria przy użyciu inicjalizacji interfejsu API MetaData. Utwórz pakiet o nazwie‘com.tutorialspoint.eclipselink.service’. Klasa o nazwieCriteriaAPI.javajest tworzony w ramach danego pakietu. Klasa DAO jest przedstawiona w następujący sposób:

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

Po skompilowaniu i wykonaniu powyższego programu otrzymasz następujące dane wyjściowe w panelu konsoli 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