JPA - คู่มือฉบับย่อ

แอปพลิเคชันขององค์กรใด ๆ ดำเนินการฐานข้อมูลโดยการจัดเก็บและดึงข้อมูลจำนวนมหาศาล แม้จะมีเทคโนโลยีทั้งหมดสำหรับการจัดการสตอเรจ แต่โดยปกติแล้วนักพัฒนาแอปพลิเคชันจะพยายามดำเนินการฐานข้อมูลอย่างมีประสิทธิภาพ

โดยทั่วไปนักพัฒนา Java จะใช้โค้ดจำนวนมากหรือใช้เฟรมเวิร์กที่เป็นกรรมสิทธิ์เพื่อโต้ตอบกับฐานข้อมูลในขณะที่การใช้ JPA ภาระในการโต้ตอบกับฐานข้อมูลจะลดลงอย่างมาก สร้างสะพานเชื่อมระหว่างโมเดลวัตถุ (โปรแกรม Java) และโมเดลเชิงสัมพันธ์ (โปรแกรมฐานข้อมูล)

ไม่ตรงกันระหว่างโมเดลเชิงสัมพันธ์และแบบจำลองวัตถุ

วัตถุเชิงสัมพันธ์จะแสดงในรูปแบบตารางในขณะที่แบบจำลองวัตถุจะแสดงในรูปแบบกราฟที่เชื่อมต่อกัน ในขณะที่จัดเก็บและดึงโมเดลอ็อบเจ็กต์จากฐานข้อมูลเชิงสัมพันธ์ความไม่ตรงกันบางอย่างเกิดขึ้นเนื่องจากสาเหตุต่อไปนี้:

Granularity : แบบจำลองวัตถุมีความละเอียดมากกว่าแบบจำลองเชิงสัมพันธ์
Subtypes : ชนิดย่อย (หมายถึงการสืบทอด) ไม่ได้รับการสนับสนุนโดยฐานข้อมูลเชิงสัมพันธ์ทุกประเภท
Identity : เช่นเดียวกับโมเดลวัตถุโมเดลเชิงสัมพันธ์จะไม่เปิดเผยตัวตนในขณะที่เขียนความเท่าเทียมกัน
Associations : แบบจำลองเชิงสัมพันธ์ไม่สามารถกำหนดความสัมพันธ์ที่หลากหลายได้ในขณะที่มองหาโมเดลโดเมนออบเจ็กต์
Data navigation : การนำทางข้อมูลระหว่างอ็อบเจ็กต์ในเครือข่ายอ็อบเจ็กต์แตกต่างกันในทั้งสองรุ่น

JPA คืออะไร?

Java Persistence API คือชุดของคลาสและวิธีการในการจัดเก็บข้อมูลจำนวนมหาศาลอย่างต่อเนื่องลงในฐานข้อมูลที่ Oracle Corporation จัดเตรียมไว้ให้

จะใช้ JPA ได้ที่ไหน?

เพื่อลดภาระในการเขียนโค้ดสำหรับการจัดการอ็อบเจ็กต์เชิงสัมพันธ์โปรแกรมเมอร์จะปฏิบัติตามกรอบ 'ผู้ให้บริการ JPA' ซึ่งช่วยให้โต้ตอบกับอินสแตนซ์ฐานข้อมูลได้ง่าย ที่นี่กรอบที่ต้องการถูกยึดครองโดย JPA

ประวัติ JPA

เวอร์ชันก่อนหน้าของ EJB เลเยอร์การคงอยู่ที่กำหนดไว้รวมกับเลเยอร์ตรรกะทางธุรกิจโดยใช้อินเทอร์เฟซ javax.ejb.EntityBean

ในขณะที่แนะนำ EJB 3.0 เลเยอร์การคงอยู่ถูกแยกออกและระบุเป็น JPA 1.0 (Java Persistence API) ข้อมูลจำเพาะของ API นี้เผยแพร่พร้อมกับข้อกำหนดของ JAVA EE5 เมื่อวันที่ 11 พฤษภาคม 2549 โดยใช้ JSR 220
JPA 2.0 เปิดตัวพร้อมข้อกำหนดของ JAVA EE6 เมื่อวันที่ 10 ธันวาคม 2552 โดยเป็นส่วนหนึ่งของ Java Community Process JSR 317
JPA 2.1 เปิดตัวพร้อมข้อมูลจำเพาะของ JAVA EE7 เมื่อวันที่ 22 เมษายน 2013 โดยใช้ JSR 338

ผู้ให้บริการ JPA

JPA เป็น API แบบโอเพ่นซอร์สดังนั้นผู้จำหน่ายระดับองค์กรต่างๆเช่น Oracle, Redhat, Eclipse และอื่น ๆ จึงจัดหาผลิตภัณฑ์ใหม่โดยเพิ่มรสชาติความคงอยู่ของ JPA ในผลิตภัณฑ์เหล่านี้ ผลิตภัณฑ์เหล่านี้บางส่วน ได้แก่ :

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

Java Persistence API เป็นแหล่งที่เก็บเอนทิตีทางธุรกิจเป็นเอนทิตีเชิงสัมพันธ์ มันแสดงวิธีการกำหนดวัตถุ JAVA แบบเก่า (POJO) เป็นเอนทิตีและวิธีจัดการเอนทิตีที่มีความสัมพันธ์

สถาปัตยกรรมระดับชั้นเรียน

ภาพต่อไปนี้แสดงสถาปัตยกรรมระดับชั้นเรียนของ JPA แสดงคลาสหลักและอินเทอร์เฟซของ JPA

ตารางต่อไปนี้อธิบายแต่ละหน่วยที่แสดงในสถาปัตยกรรมข้างต้น

หน่วย	คำอธิบาย
EntityManagerFactory	นี่คือคลาสโรงงานของ EntityManager สร้างและจัดการอินสแตนซ์ EntityManager หลายรายการ
EntityManager	เป็นอินเทอร์เฟซที่จัดการการดำเนินการคงอยู่บนวัตถุ ทำงานเหมือนโรงงานสำหรับอินสแตนซ์ Query
Entity	เอนทิตีเป็นวัตถุคงอยู่จัดเก็บเป็นระเบียนในฐานข้อมูล
EntityTransaction	มีความสัมพันธ์แบบหนึ่งต่อหนึ่งกับ EntityManager สำหรับแต่ละ EntityManager การดำเนินการจะถูกดูแลโดยคลาส EntityTransaction
Persistence	คลาสนี้มีเมธอดแบบคงที่เพื่อขอรับอินสแตนซ์ EntityManagerFactory
Query	อินเทอร์เฟซนี้ถูกนำไปใช้โดยผู้ขาย JPA แต่ละรายเพื่อรับอ็อบเจ็กต์เชิงสัมพันธ์ที่ตรงตามเกณฑ์

คลาสและอินเทอร์เฟซข้างต้นใช้สำหรับการจัดเก็บเอนทิตีลงในฐานข้อมูลเป็นบันทึก พวกเขาช่วยโปรแกรมเมอร์โดยลดความพยายามในการเขียนโค้ดสำหรับจัดเก็บข้อมูลลงในฐานข้อมูลเพื่อให้พวกเขาสามารถมุ่งเน้นไปที่กิจกรรมที่สำคัญมากขึ้นเช่นการเขียนโค้ดสำหรับการแมปคลาสกับตารางฐานข้อมูล

ความสัมพันธ์ระดับ JPA

ในสถาปัตยกรรมข้างต้นความสัมพันธ์ระหว่างคลาสและอินเทอร์เฟซเป็นของแพ็คเกจ javax.persistence แผนภาพต่อไปนี้แสดงความสัมพันธ์ระหว่างกัน

ความสัมพันธ์ระหว่าง EntityManagerFactory และ EntityManager คือ one-to-many. เป็นคลาสโรงงานสำหรับอินสแตนซ์ EntityManager
ความสัมพันธ์ระหว่าง EntityManager และ EntityTransaction คือ one-to-one. สำหรับแต่ละการดำเนินการของ EntityManager จะมีอินสแตนซ์ EntityTransaction
ความสัมพันธ์ระหว่าง EntityManager และ Query คือ one-to-many. แบบสอบถามจำนวนมากสามารถดำเนินการโดยใช้อินสแตนซ์ EntityManager เดียว
ความสัมพันธ์ระหว่าง EntityManager และ Entity คือ one-to-many. อินสแตนซ์ EntityManager หนึ่งรายการสามารถจัดการเอนทิตีได้หลายรายการ

แอปพลิเคชันร่วมสมัยส่วนใหญ่ใช้ฐานข้อมูลเชิงสัมพันธ์ในการจัดเก็บข้อมูล เมื่อเร็ว ๆ นี้ผู้ขายจำนวนมากเปลี่ยนมาใช้ฐานข้อมูลออบเจ็กต์เพื่อลดภาระในการดูแลรักษาข้อมูล หมายความว่าฐานข้อมูลวัตถุหรือเทคโนโลยีเชิงสัมพันธ์ของวัตถุกำลังดูแลการจัดเก็บการเรียกใช้การอัปเดตและการดูแลรักษาข้อมูล ส่วนหลักของเทคโนโลยีเชิงสัมพันธ์ออบเจ็กต์นี้คือการแมปไฟล์ orm.xml เนื่องจาก xml ไม่ต้องการการคอมไพล์เราจึงสามารถทำการเปลี่ยนแปลงแหล่งข้อมูลหลายแหล่งได้อย่างง่ายดายโดยมีการดูแลน้อยลง

การแม็ปเชิงสัมพันธ์ของวัตถุ

Object Relational Mapping (ORM) จะบอกคุณสั้น ๆ เกี่ยวกับ ORM คืออะไรและทำงานอย่างไร ORM คือความสามารถในการเขียนโปรแกรมเพื่อปกปิดข้อมูลจากประเภทออบเจ็กต์เป็นประเภทเชิงสัมพันธ์และในทางกลับกัน

คุณสมบัติหลักของ ORM คือการแมปหรือผูกวัตถุเข้ากับข้อมูลในฐานข้อมูล ในขณะที่ทำแผนที่เราต้องพิจารณาข้อมูลประเภทของข้อมูลและความสัมพันธ์กับเอนทิตีตนเองหรือเอนทิตีในตารางอื่น ๆ

คุณสมบัติขั้นสูง

Idiomatic persistence : ช่วยให้คุณสามารถเขียนคลาสการคงอยู่โดยใช้คลาสเชิงวัตถุ
High Performance : มันมีเทคนิคการดึงข้อมูลมากมายและเทคนิคการล็อกแบบหวังผล
Reliable : มีความเสถียรสูงและถูกใช้โดยโปรแกรมเมอร์มืออาชีพจำนวนมาก

สถาปัตยกรรม ORM

สถาปัตยกรรม ORM มีลักษณะดังนี้

สถาปัตยกรรมข้างต้นอธิบายถึงวิธีการจัดเก็บข้อมูลวัตถุในฐานข้อมูลเชิงสัมพันธ์ในสามขั้นตอน

ขั้นตอนที่ 1

ระยะแรกมีชื่อว่า object data phaseมีคลาส POJO อินเตอร์เฟสบริการและคลาส เป็นเลเยอร์องค์ประกอบทางธุรกิจหลักซึ่งมีการดำเนินการทางตรรกะและคุณลักษณะทางธุรกิจ

ตัวอย่างเช่นให้เราใช้ฐานข้อมูลพนักงานเป็นสคีมา

คลาส POJO ของพนักงานประกอบด้วยแอตทริบิวต์เช่น ID ชื่อเงินเดือนและการกำหนด นอกจากนี้ยังมีวิธีการเช่น setter และ getter ของแอตทริบิวต์เหล่านั้น
คลาส DAO / บริการของพนักงานประกอบด้วยวิธีการบริการเช่นสร้างพนักงานค้นหาพนักงานและลบพนักงาน

ระยะที่ 2

ระยะที่สองมีชื่อว่า mapping หรือ persistence phase, มีผู้ให้บริการ JPA, ไฟล์การแมป (ORM.xml), JPA Loader และ Object Grid

JPA Provider: เป็นผลิตภัณฑ์ของผู้ขายที่มีรส JPA (javax.persistence) ตัวอย่างเช่น Eclipselink, Toplink, Hibernate เป็นต้น
Mapping file : ไฟล์การแมป (ORM.xml) มีคอนฟิกูเรชันการแม็พระหว่างข้อมูลในคลาส POJO และข้อมูลในฐานข้อมูลเชิงสัมพันธ์
JPA Loader: ตัวโหลด JPA ทำงานเหมือนหน่วยความจำแคช สามารถโหลดข้อมูลกริดเชิงสัมพันธ์ ทำงานเหมือนสำเนาของฐานข้อมูลเพื่อโต้ตอบกับคลาสบริการสำหรับข้อมูล POJO (แอตทริบิวต์ของคลาส POJO)
Object Grid: เป็นตำแหน่งชั่วคราวที่สามารถจัดเก็บสำเนาของข้อมูลเชิงสัมพันธ์เช่นหน่วยความจำแคช การสอบถามทั้งหมดกับฐานข้อมูลจะมีผลกับข้อมูลในตารางวัตถุก่อน หลังจากมีการคอมมิตแล้วจะมีผลกับฐานข้อมูลหลัก

ระยะที่ 3

ระยะที่สามคือ relational data phase. ประกอบด้วยข้อมูลเชิงสัมพันธ์ที่เชื่อมต่อกับองค์ประกอบทางธุรกิจอย่างมีเหตุผล ดังที่ได้กล่าวไว้ข้างต้นเฉพาะเมื่อองค์ประกอบทางธุรกิจยอมรับข้อมูลเท่านั้นข้อมูลจะถูกจัดเก็บไว้ในฐานข้อมูลทางกายภาพ ในระหว่างนี้ข้อมูลที่แก้ไขจะถูกเก็บไว้ในหน่วยความจำแคชเป็นรูปแบบกริด ขั้นตอนการรับข้อมูลนั้นเหมือนกับการจัดเก็บข้อมูล

กลไกของการโต้ตอบแบบเป็นโปรแกรมของสามขั้นตอนข้างต้นเรียกว่าเป็น object relational mapping.

Mapping.xml

ไฟล์ mapping.xml คือการสั่งให้ผู้จำหน่าย JPA แมปคลาสเอนทิตีกับตารางฐานข้อมูล

ให้เรายกตัวอย่างเอนทิตีพนักงานซึ่งมีคุณสมบัติสี่ประการ คลาส POJO ของเอนทิตีพนักงานชื่อEmployee.java มีดังนี้:

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

รหัสด้านบนคือคลาส POJO เอนทิตีของพนักงาน ประกอบด้วยสี่คุณลักษณะeid, ename, salaryและ deg. พิจารณาแอตทริบิวต์เหล่านี้เป็นช่องตารางในตารางและeidเป็นคีย์หลักของตารางนี้ ตอนนี้เราต้องออกแบบไฟล์การแมปไฮเบอร์เนตให้มัน ไฟล์การแมปชื่อmapping.xml มีดังนี้:

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

สคริปต์ด้านบนใช้สำหรับการแมปคลาสเอนทิตีกับตารางฐานข้อมูล ในไฟล์นี้

<entity-mappings> : tag กำหนดข้อกำหนด schema เพื่ออนุญาตให้แท็กเอนทิตีลงในไฟล์ xml
<description> : tag ให้คำอธิบายเกี่ยวกับแอปพลิเคชัน
<entity>: tag กำหนดคลาสเอนทิตีที่คุณต้องการแปลงเป็นตารางในฐานข้อมูล คลาสแอตทริบิวต์กำหนดชื่อคลาสเอนทิตี POJO
<table>: tag กำหนดชื่อตาราง หากคุณต้องการมีชื่อที่เหมือนกันสำหรับทั้งคลาสและตารางก็ไม่จำเป็นต้องใช้แท็กนี้
<attributes> : tag กำหนดแอตทริบิวต์ (ฟิลด์ในตาราง)
<id>: tag กำหนดคีย์หลักของตาราง <generated-value> แท็กกำหนดวิธีการกำหนดค่าคีย์หลักเช่น Automatic, Manualหรือนำมาจาก Sequence.
<basic> : tag ใช้สำหรับกำหนดแอตทริบิวต์ที่เหลือสำหรับตาราง
<column-name> : tag ใช้เพื่อกำหนดชื่อฟิลด์ตารางที่ผู้ใช้กำหนดเองในตาราง

คำอธิบายประกอบ

โดยทั่วไปแล้วไฟล์ xml จะใช้เพื่อกำหนดค่าคอมโพเนนต์เฉพาะหรือการแม็พคุณสมบัติที่แตกต่างกันสองอย่างของส่วนประกอบ ในกรณีของเราเราต้องดูแลไฟล์ xml แยกกันในกรอบ นั่นหมายความว่าในขณะที่เขียนไฟล์ xml การแมปเราจำเป็นต้องเปรียบเทียบแอตทริบิวต์คลาส POJO กับแท็กเอนทิตีในไฟล์ mapping.xml

นี่คือวิธีแก้ปัญหา ในนิยามคลาสเราสามารถเขียนส่วนการกำหนดค่าโดยใช้คำอธิบายประกอบ คำอธิบายประกอบใช้สำหรับคลาสคุณสมบัติและวิธีการ คำอธิบายประกอบขึ้นต้นด้วยสัญลักษณ์ "@" คำอธิบายประกอบถูกประกาศก่อนคลาสคุณสมบัติหรือวิธีการ คำอธิบายประกอบทั้งหมดของ JPA ถูกกำหนดไว้ในไฟล์javax.persistence แพ็คเกจ

รายการคำอธิบายประกอบที่ใช้ในตัวอย่างของเรามีดังต่อไปนี้

คำอธิบายประกอบ	คำอธิบาย
@ เอนทิตี้	ประกาศคลาสเป็นเอนทิตีหรือตาราง
@ตาราง	ประกาศชื่อตาราง
@ขั้นพื้นฐาน	ระบุฟิลด์ที่ไม่ จำกัด อย่างชัดเจน
@ ฝัง	ระบุคุณสมบัติของคลาสหรือเอนทิตีที่มีค่าเป็นอินสแตนซ์ของคลาสที่ฝังได้
@Id	ระบุคุณสมบัติใช้สำหรับเอกลักษณ์ (คีย์หลักของตาราง) ของคลาส
@GeneratedValue	ระบุวิธีการเริ่มต้นแอ็ตทริบิวต์เอกลักษณ์เช่นอัตโนมัติแมนนวลหรือค่าที่นำมาจากตารางลำดับ
@ชั่วคราว	ระบุคุณสมบัติที่ไม่คงอยู่นั่นคือค่าจะไม่ถูกเก็บไว้ในฐานข้อมูล
@คอลัมน์	ระบุแอตทริบิวต์คอลัมน์สำหรับคุณสมบัติการคงอยู่
@SequenceGenerator	ระบุค่าสำหรับคุณสมบัติที่ระบุในหมายเหตุประกอบ @GeneratedValue มันสร้างลำดับ
@TableGenerator	ระบุตัวสร้างค่าสำหรับคุณสมบัติที่ระบุในหมายเหตุประกอบ @GeneratedValue สร้างตารางสำหรับการสร้างมูลค่า
@AccessType	คำอธิบายประกอบประเภทนี้ใช้เพื่อตั้งค่าประเภทการเข้าถึง หากคุณตั้งค่า @AccessType (FIELD) การเข้าถึงจะเกิดขึ้นในฟิลด์ที่ชาญฉลาด หากคุณตั้งค่า @AccessType (PROPERTY) การเข้าถึงจะเกิดขึ้นกับคุณสมบัติที่ชาญฉลาด
@JoinColumn	ระบุการเชื่อมโยงเอนทิตีหรือการรวบรวมเอนทิตี สิ่งนี้ใช้ในการเชื่อมโยงแบบกลุ่มต่อหนึ่งและแบบหนึ่งต่อหลาย
@UniqueConstraint	ระบุฟิลด์และข้อ จำกัด เฉพาะสำหรับตารางหลักหรือตารางรอง
@ColumnResult	อ้างอิงชื่อของคอลัมน์ในแบบสอบถาม SQL โดยใช้ส่วนคำสั่งเลือก
@ManyToMany	กำหนดความสัมพันธ์แบบกลุ่มต่อกลุ่มระหว่างตารางการเข้าร่วม
@ManyToOne	กำหนดความสัมพันธ์แบบกลุ่มต่อกลุ่มระหว่างตารางการเข้าร่วม
@OneToMany	กำหนดความสัมพันธ์แบบหนึ่งต่อกลุ่มระหว่างตารางการเข้าร่วม
@หนึ่งต่อหนึ่ง	กำหนดความสัมพันธ์แบบหนึ่งต่อกลุ่มระหว่างตารางการเข้าร่วม
@NamedQueries	ระบุรายการแบบสอบถามที่ตั้งชื่อ
@NamedQuery	ระบุแบบสอบถามโดยใช้ชื่อแบบคงที่

มาตรฐาน Java Bean

คลาส Java ห่อหุ้มค่าอินสแตนซ์และพฤติกรรมไว้ในหน่วยเดียวที่เรียกว่าอ็อบเจ็กต์ Java Bean เป็นหน่วยเก็บข้อมูลชั่วคราวและส่วนประกอบที่ใช้ซ้ำได้หรือวัตถุ เป็นคลาสที่ทำให้เป็นอนุกรมได้ซึ่งมีตัวสร้างเริ่มต้นและเมธอด getter และ setter เพื่อเริ่มต้นแอ็ตทริบิวต์อินสแตนซ์ทีละรายการ

อนุสัญญาถั่ว

Bean มีตัวสร้างเริ่มต้นหรือไฟล์ที่มีอินสแตนซ์แบบอนุกรม ดังนั้นถั่วสามารถสร้างอินสแตนซ์ถั่วอื่นได้
คุณสมบัติของถั่วสามารถแยกออกเป็นคุณสมบัติบูลีนหรือคุณสมบัติที่ไม่ใช่บูลีน
คุณสมบัติที่ไม่ใช่บูลีนประกอบด้วย getter และ setter วิธีการ
คุณสมบัติบูลีนประกอบด้วย setter และ is วิธี.
Getter วิธีการของคุณสมบัติใด ๆ ควรเริ่มต้นด้วยตัวอักษรขนาดเล็ก get(java method convention) และต่อด้วยชื่อฟิลด์ที่ขึ้นต้นด้วยอักษรตัวใหญ่ ตัวอย่างเช่นชื่อฟิลด์คือsalary ดังนั้นวิธีการ getter ของฟิลด์นี้คือ getSalary ().
Setter วิธีการของคุณสมบัติใด ๆ ควรเริ่มต้นด้วยตัวอักษรขนาดเล็ก set (java method convention) ต่อด้วยชื่อฟิลด์ที่ขึ้นต้นด้วยอักษรตัวใหญ่และ argument valueเพื่อตั้งค่าเป็นฟิลด์ ตัวอย่างเช่นชื่อฟิลด์คือsalary ดังนั้นวิธีการ setter ของฟิลด์นี้คือ setSalary ( double sal ).
สำหรับคุณสมบัติบูลีน isวิธีตรวจสอบว่าจริงหรือเท็จ ตัวอย่างเช่นคุณสมบัติบูลีนempty, is วิธีการของฟิลด์นี้คือ isEmpty ().

บทนี้จะนำคุณเข้าสู่ขั้นตอนการตั้งค่า JPA บนระบบที่ใช้ Windows และ Linux JPA สามารถติดตั้งและรวมเข้ากับสภาพแวดล้อม Java ปัจจุบันของคุณได้อย่างง่ายดายโดยทำตามขั้นตอนง่ายๆไม่กี่ขั้นตอนโดยไม่ต้องมีขั้นตอนการตั้งค่าที่ซับซ้อน จำเป็นต้องมีการดูแลระบบผู้ใช้ขณะติดตั้ง

ความต้องการของระบบ

JDK	Java SE 2 JDK 1.5 ขึ้นไป
หน่วยความจำ	RAM 1 GB (แนะนำ)
พื้นที่ดิสก์	ไม่มีข้อกำหนดขั้นต่ำ
เวอร์ชันระบบปฏิบัติการ	Windows XP ขึ้นไปลินุกซ์

ให้เราดำเนินการตามขั้นตอนเพื่อติดตั้ง JPA

ขั้นตอนที่ 1: ตรวจสอบการติดตั้ง Java ของคุณ

ก่อนอื่นคุณต้องติดตั้ง Java Software Development Kit (SDK) ในระบบของคุณ ในการตรวจสอบสิ่งนี้ให้ดำเนินการสองคำสั่งต่อไปนี้ขึ้นอยู่กับแพลตฟอร์มที่คุณกำลังทำงานอยู่

หากการติดตั้ง Java ทำได้อย่างถูกต้องการติดตั้งจะแสดงเวอร์ชันปัจจุบันและข้อมูลจำเพาะของการติดตั้ง Java ของคุณ ตัวอย่างผลลัพธ์จะได้รับในตารางต่อไปนี้

แพลตฟอร์ม	คำสั่ง	ตัวอย่างผลลัพธ์
Windows	เปิดคอนโซลคำสั่งและพิมพ์: \>java –version	เวอร์ชัน Java "1.7.0_60" Java (TM) SE Run Time Environment (บิวด์ 1.7.0_60-b19) Java Hotspot (TM) 64-bit Server VM (build 24.60-b09, mixed mode)
ลินุกซ์	เปิดเทอร์มินัลคำสั่งและพิมพ์: $java –version	เวอร์ชัน java "1.7.0_25" เปิด JDK Runtime Environment (rhel-2.3.10.4.el6_4-x86_64) เปิด JDK 64-Bit Server VM (สร้าง 23.7-b01 โหมดผสม)

เราถือว่าผู้อ่านบทช่วยสอนนี้ติดตั้ง Java SDK เวอร์ชัน 1.7.0_60 ในระบบของตน
ในกรณีที่คุณไม่มี Java SDK ให้ดาวน์โหลดเวอร์ชันปัจจุบันจากไฟล์ http://www.oracle.com/technetwork/java/javase/downloads/index.html และติดตั้ง

ขั้นตอนที่ 2: ตั้งค่าสภาพแวดล้อม Java ของคุณ

ตั้งค่าตัวแปรสภาพแวดล้อม JAVA_HOME ให้ชี้ไปยังตำแหน่งไดเร็กทอรีฐานที่ติดตั้ง Java บนเครื่องของคุณ ตัวอย่างเช่น,

แพลตฟอร์ม	คำอธิบาย
Windows	ตั้งค่า JAVA_HOME เป็น C: \ ProgramFiles \ java \ jdk1.7.0_60
ลินุกซ์	ส่งออก JAVA_HOME = / usr / local / java-current

ผนวกพา ธ แบบเต็มของตำแหน่งคอมไพเลอร์ Java เข้ากับ System Path

แพลตฟอร์ม	คำอธิบาย
Windows	ต่อท้าย String "C: \ Program Files \ Java \ jdk1.7.0_60 \ bin" ต่อท้ายตัวแปรระบบ PATH
ลินุกซ์	ส่งออกเส้นทาง = $ PATH: $ JAVA_HOME / bin /

ดำเนินการคำสั่ง java -version จากพรอมต์คำสั่งตามที่อธิบายไว้ข้างต้น

ขั้นตอนที่ 3: การติดตั้ง JPA

คุณสามารถดำเนินการติดตั้ง JPA ได้โดยใช้ผู้ให้บริการ JPA จากบทช่วยสอนนี้เช่น Eclipselink, Hibernate ให้เราติดตามการติดตั้ง JPA โดยใช้ Eclipselink สำหรับการเขียนโปรแกรม JPA เราจำเป็นต้องปฏิบัติตามกรอบโฟลเดอร์เฉพาะดังนั้นจึงควรใช้ IDE

ดาวน์โหลดแบบฟอร์ม Eclipse IDE ตามลิงค์ https://www.eclipse.org/downloads/ เลือก EclipseIDE สำหรับนักพัฒนา JavaEE ที่เป็น Eclipse indigo.

แตกไฟล์ zip Eclipse ในไดรฟ์ C เปิด Eclipse IDE

การติดตั้ง JPA โดยใช้ Eclipselink

Eclipselink เป็นไลบรารีดังนั้นเราจึงไม่สามารถเพิ่มลงใน Eclipse IDE ได้โดยตรง สำหรับการติดตั้ง JPA โดยใช้ Eclipselink คุณต้องทำตามขั้นตอนด้านล่าง

สร้างโครงการ JPA ใหม่โดยเลือก File->New->JPA Project ใน Eclipse IDE ดังต่อไปนี้:
คุณจะได้รับกล่องโต้ตอบชื่อ New JPA Project. ป้อนชื่อโครงการtutorialspoint_JPA_Eclipselinkตรวจสอบไฟล์ jre เวอร์ชั่นแล้วคลิกถัดไป:
คลิกที่ดาวน์โหลดไลบรารี (หากคุณไม่มีไลบรารี) ในส่วนไลบรารีผู้ใช้
เลือกเวอร์ชันล่าสุดของไลบรารี Eclipselink ในกล่องโต้ตอบดาวน์โหลดไลบรารีและคลิกถัดไปดังนี้:
ยอมรับเงื่อนไขการอนุญาตและคลิกเสร็จสิ้นเพื่อดาวน์โหลดไลบรารี
6. การดาวน์โหลดจะเริ่มขึ้นตามที่แสดงในภาพหน้าจอต่อไปนี้
หลังจากดาวน์โหลดแล้วให้เลือกไลบรารีที่ดาวน์โหลดมาในส่วนไลบรารีผู้ใช้แล้วคลิกเสร็จสิ้น
ในที่สุดคุณจะได้รับไฟล์โครงการในรูปแบบ Package Explorerใน Eclipse IDE แตกไฟล์ทั้งหมดคุณจะได้โฟลเดอร์และลำดับชั้นของไฟล์ดังนี้:

การเพิ่มตัวเชื่อมต่อ MySQL ไปยัง Project

ตัวอย่างใด ๆ ที่เราพูดถึงที่นี่ต้องการการเชื่อมต่อฐานข้อมูล ให้เราพิจารณาฐานข้อมูล MySQL สำหรับการดำเนินการฐานข้อมูล ต้องใช้ jar mysql-connector เพื่อโต้ตอบกับโปรแกรม Java

ทำตามขั้นตอนเพื่อกำหนดค่า jar ฐานข้อมูลในโครงการของคุณ

ไปที่คุณสมบัติโครงการ ->Java Build Path โดยคลิกขวาที่มัน คุณจะได้รับกล่องโต้ตอบดังที่แสดงในภาพหน้าจอต่อไปนี้ คลิกที่ Add External Jars
ไปที่ตำแหน่ง jar ในหน่วยความจำระบบของคุณเลือกไฟล์และคลิกที่เปิด
คลิกตกลงในกล่องโต้ตอบคุณสมบัติ คุณจะได้รับ MySQL-connector Jar ในโครงการของคุณ ตอนนี้คุณสามารถดำเนินการฐานข้อมูลโดยใช้ MySQL

บทนี้ใช้ตัวอย่างง่ายๆเพื่อแสดงให้เห็นว่า JPA ทำงานอย่างไร ให้เราพิจารณาการจัดการพนักงานเป็นตัวอย่าง สมมติว่าฝ่ายจัดการพนักงานสร้างอัปเดตค้นหาและลบบันทึกของพนักงาน ดังที่ได้กล่าวไปแล้วเรากำลังใช้ฐานข้อมูล MySQL สำหรับการทำงานของฐานข้อมูล

โมดูลหลักสำหรับตัวอย่างนี้มีดังนี้:

Model or POJO

Employee.java
Persistence

Persistence.xml
Service

CreatingEmployee.java

UpdatingEmployee.java

FindingEmployee.java

DeletingEmployee.java

ให้เราใช้ลำดับชั้นของแพ็คเกจที่เราใช้ในการติดตั้ง JPA ด้วย Eclipselink ทำตามลำดับชั้นสำหรับตัวอย่างนี้ดังที่แสดงด้านล่าง:

การสร้างเอนทิตี

เอนทิตีไม่ใช่อะไรนอกจากถั่วหรือแบบจำลอง ในตัวอย่างนี้เราจะใช้Employee เป็นเอนทิตี eid, ename, salaryและ degเป็นแอตทริบิวต์ของเอนทิตีนี้ ประกอบด้วยตัวสร้างเริ่มต้นเช่นเดียวกับวิธีการ setter และ getter ของแอตทริบิวต์เหล่านั้น

ในลำดับชั้นที่แสดงด้านบนให้สร้างแพ็คเกจชื่อ ‘com.tutorialspoint.eclipselink.entity’ภายใต้ ‘src’(ที่มา) แพ็คเกจ สร้างคลาสชื่อEmployee.java ภายใต้แพ็คเกจที่กำหนดดังนี้:

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

ในโค้ดด้านบนเราได้ใช้คำอธิบายประกอบ @Entity เพื่อทำให้คลาส POJO นี้เป็นเอนทิตี

ก่อนที่จะไปที่โมดูลถัดไปเราต้องสร้างฐานข้อมูลสำหรับเอนทิตีเชิงสัมพันธ์ซึ่งจะลงทะเบียนฐานข้อมูลใน persistence.xmlไฟล์. เปิด MySQL workbench แล้วพิมพ์ hte ต่อไปนี้เคียวรี

create database jpadb
use jpadb

Persistence.xml

โมดูลนี้มีบทบาทสำคัญในแนวคิดของ JPA ในไฟล์ xml นี้เราจะลงทะเบียนฐานข้อมูลและระบุคลาสเอนทิตี

ในลำดับชั้นของแพ็กเกจที่แสดงด้านบน persistence.xml ภายใต้แพ็คเกจเนื้อหา JPA มีดังต่อไปนี้:

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

ใน xml ข้างต้น <persistence-unit> แท็กถูกกำหนดด้วยชื่อเฉพาะสำหรับการคงอยู่ของ JPA <class>แท็กกำหนดคลาสเอนทิตีด้วยชื่อแพ็กเกจ <properties> แท็กกำหนดคุณสมบัติทั้งหมดและ <property>แท็กกำหนดคุณสมบัติแต่ละอย่างเช่นการลงทะเบียนฐานข้อมูลข้อกำหนด URL ชื่อผู้ใช้และรหัสผ่าน นี่คือคุณสมบัติ Eclipselink ไฟล์นี้จะกำหนดค่าฐานข้อมูล

การดำเนินการต่อเนื่อง

การดำเนินการต่อเนื่องใช้สำหรับการโต้ตอบกับฐานข้อมูลและเป็น load และ storeการดำเนินงาน ในองค์ประกอบทางธุรกิจการดำเนินการต่อเนื่องทั้งหมดอยู่ภายใต้คลาสการบริการ

ในลำดับชั้นของแพ็กเกจที่แสดงด้านบนให้สร้างแพ็กเกจชื่อ ‘com.tutorialspoint.eclipselink.service’ภายใต้ ‘src’(แหล่งที่มา) แพ็คเกจ คลาสบริการทั้งหมดที่มีชื่อว่า CreateEmloyee.java, UpdateEmployee.java, FindEmployee.java และ DeleteEmployee.java มาภายใต้แพ็คเกจที่กำหนดดังนี้:

สร้างพนักงาน

ส่วนรหัสต่อไปนี้แสดงวิธีสร้างคลาสพนักงานที่ชื่อ 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( );
	}
}

ในรหัสด้านบนไฟล์ createEntityManagerFactory ()สร้างหน่วยการคงอยู่โดยระบุชื่อเฉพาะเดียวกันกับที่เราจัดเตรียมไว้สำหรับหน่วยการคงอยู่ในไฟล์ persistent.xml entitymanagerfactory วัตถุจะสร้างไฟล์ entitymanger อินสแตนซ์โดยใช้ createEntityManager ()วิธี. entitymanager สร้างวัตถุ entitytransactionอินสแตนซ์สำหรับการจัดการธุรกรรม โดยใช้entitymanager วัตถุเราสามารถคงเอนทิตีไว้ในฐานข้อมูล

หลังจากคอมไพล์และเรียกใช้โปรแกรมข้างต้นคุณจะได้รับการแจ้งเตือนจากไลบรารี eclipselink บนแผงคอนโซลของ eclipse IDE

ด้วยเหตุนี้ให้เปิดโต๊ะทำงาน MySQL และพิมพ์คำค้นหาต่อไปนี้

use jpadb
select * from employee

ชื่อตารางฐานข้อมูลที่ได้รับผลกระทบ employee จะแสดงในรูปแบบตารางดังนี้:

Eid	Ename	เงินเดือน	องศา
1201	โกปาล	40000	ผู้จัดการฝ่ายเทคนิค

อัปเดตพนักงาน

ในการอัปเดตบันทึกของพนักงานเราจำเป็นต้องดึงข้อมูลที่มีอยู่ออกจากฐานข้อมูลทำการเปลี่ยนแปลงและสุดท้ายส่งไปยังฐานข้อมูล ชั้นเรียนชื่อUpdateEmployee.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 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();
	}
}

หลังจากคอมไพล์และเรียกใช้โปรแกรมข้างต้นคุณจะได้รับการแจ้งเตือนจากไลบรารี Eclipselink บนแผงคอนโซลของ eclipse IDE

ด้วยเหตุนี้ให้เปิดโต๊ะทำงาน MySQL และพิมพ์คำค้นหาต่อไปนี้

use jpadb
select * from employee

ชื่อตารางฐานข้อมูลที่ได้รับผลกระทบ employee จะแสดงในรูปแบบตารางดังนี้:

Eid	Ename	เงินเดือน	องศา
1201	โกปาล	46000	ผู้จัดการฝ่ายเทคนิค

เงินเดือนของพนักงาน 1201 อัปเดตเป็น 46000

ค้นหาพนักงาน

ในการค้นหาบันทึกของพนักงานเราจะต้องดึงข้อมูลที่มีอยู่จากฐานข้อมูลและแสดง ในการดำเนินการนี้ EntityTransaction จะไม่ถูกนำไปใช้ในขณะที่เรียกข้อมูลเรกคอร์ด

ชั้นเรียนชื่อ FindEmployee.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 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( ));
	}
}

หลังจากคอมไพล์และรันโปรแกรมข้างต้นคุณจะได้รับผลลัพธ์ต่อไปนี้จากไลบรารี Eclipselink บนแผงคอนโซลของ eclipse IDE

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

กำลังลบพนักงาน

ในการลบบันทึกของพนักงานก่อนอื่นเราจะค้นหาระเบียนที่มีอยู่แล้วจึงลบออก ที่นี่ EntityTransaction มีบทบาทสำคัญ

ชั้นเรียนชื่อ DeleteEmployee.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 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( );
	}
}

ด้วยเหตุนี้ให้เปิดโต๊ะทำงาน MySQL และพิมพ์คำค้นหาต่อไปนี้

use jpadb
select * from employee

ฐานข้อมูลที่ได้รับผลกระทบชื่อ employee จะมีระเบียนว่าง

หลังจากเสร็จสิ้นโมดูลทั้งหมดในตัวอย่างนี้แล้วลำดับชั้นของแพ็กเกจและไฟล์จะมีลักษณะดังนี้:

บทนี้จะอธิบายเกี่ยวกับ JPQL และวิธีการทำงานกับหน่วยการคงอยู่ ในบทนี้ตัวอย่างที่ให้มาจะเป็นไปตามลำดับชั้นของแพ็กเกจเดียวกันซึ่งเราใช้ในบทที่แล้ว

ภาษา Java Persistence Query

JPQL ย่อมาจาก Java Persistence Query Language ใช้เพื่อสร้างแบบสอบถามกับเอนทิตีเพื่อจัดเก็บในฐานข้อมูลเชิงสัมพันธ์ JPQL ได้รับการพัฒนาโดยใช้ไวยากรณ์ SQL แต่จะไม่ส่งผลกระทบต่อฐานข้อมูลโดยตรง

JPQL สามารถดึงข้อมูลโดยใช้คำสั่ง SELECT สามารถทำการอัปเดตจำนวนมากโดยใช้ UPDATE clause และ DELETE clause

โครงสร้างแบบสอบถาม

ไวยากรณ์ของ JPQL นั้นคล้ายกับไวยากรณ์ของ SQL มาก การมี SQL เหมือนกับไวยากรณ์เป็นข้อได้เปรียบเนื่องจาก SQL นั้นเรียบง่ายและมีการใช้กันอย่างแพร่หลาย SQL ทำงานโดยตรงกับตารางฐานข้อมูลเชิงสัมพันธ์ระเบียนและฟิลด์ในขณะที่ JPQL ทำงานร่วมกับคลาสและอินสแตนซ์ Java

ตัวอย่างเช่นแบบสอบถาม JPQL สามารถดึงวัตถุเอนทิตีแทนที่จะเป็นผลลัพธ์ของฟิลด์ที่กำหนดจากฐานข้อมูลเช่นเดียวกับ SQL โครงสร้างแบบสอบถาม JPQL ดังต่อไปนี้

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

โครงสร้างของแบบสอบถาม JPQL DELETE และ UPDATE มีดังนี้

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

ฟังก์ชั่น Scalar และ Aggregate

ฟังก์ชันสเกลาร์จะส่งคืนค่าผลลัพธ์ตามค่าอินพุต ฟังก์ชันการรวมจะส่งคืนค่าผลลัพธ์โดยการคำนวณค่าอินพุต

เราจะใช้ตัวอย่างการจัดการพนักงานเช่นเดียวกับในบทที่แล้ว ในที่นี้เราจะเข้าสู่คลาสบริการโดยใช้ฟังก์ชันสเกลาร์และฟังก์ชันรวมของ JPQL

ให้เราถือว่า jpadb.employee ตารางประกอบด้วยบันทึกต่อไปนี้

Eid	Ename	เงินเดือน	องศา
1201	โกปาล	40000	ผู้จัดการฝ่ายเทคนิค
1202	มานิชา	40000	เครื่องอ่านหลักฐาน
1203	Masthanvali	40000	นักเขียนด้านเทคนิค
1204	Satish	30000	นักเขียนด้านเทคนิค
1205	กฤษณะ	30000	นักเขียนด้านเทคนิค
1206	Kiran	35000	เครื่องอ่านหลักฐาน

สร้างคลาสชื่อ ScalarandAggregateFunctions.java ภายใต้ com.tutorialspoint.eclipselink.service แพคเกจดังนี้

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

หลังจากคอมไพล์และเรียกใช้โปรแกรมข้างต้นคุณจะได้ผลลัพธ์ต่อไปนี้บนแผงคอนโซลของ 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

ระหว่างและเช่นเดียวกับคำหลัก

Between, Andและ Likeคือคีย์เวิร์ดหลักของ JPQL คำหลักเหล่านี้ถูกใช้หลังจากWhere clause ในแบบสอบถาม

สร้างคลาสชื่อ BetweenAndLikeFunctions.java ภายใต้ com.tutorialspoint.eclipselink.service แพคเกจดังนี้:

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

หลังจากคอมไพล์และรันโปรแกรมข้างต้นคุณจะได้รับเอาต์พุตต่อไปนี้ในแผงคอนโซลของ Eclipse IDE

Employee ID :1201	 Employee salary :40000.0
Employee ID :1202	 Employee salary :40000.0
Employee ID :1203	 Employee salary :40000.0
Employee ID :1204	 Employee salary :30000.0
Employee ID :1205	 Employee salary :30000.0
Employee ID :1206	 Employee salary :35000.0

Employee ID :1202	 Employee name :Manisha
Employee ID :1203	 Employee name :Masthanvali

การสั่งซื้อ

ในการสั่งซื้อระเบียนใน JPQL เราใช้คำสั่ง ORDER BY การใช้คำสั่งนี้เหมือนกับใน SQL แต่เกี่ยวข้องกับเอนทิตี ตัวอย่างต่อไปนี้แสดงวิธีการใช้คำสั่ง ORDER BY

สร้างชั้นเรียน Ordering.java ภายใต้ com.tutorialspoint.eclipselink.service แพคเกจดังนี้:

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

การรวบรวมและดำเนินการโปรแกรมข้างต้นคุณจะสร้างเอาต์พุตต่อไปนี้ในแผงคอนโซลของ Eclipse IDE

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

แบบสอบถามที่มีชื่อ

คำอธิบายประกอบ @NamedQuery ถูกกำหนดให้เป็นแบบสอบถามที่มีสตริงการสืบค้นที่กำหนดไว้ล่วงหน้าซึ่งไม่สามารถเปลี่ยนแปลงได้ ในทางตรงกันข้ามกับแบบสอบถามแบบไดนามิกแบบสอบถามที่มีชื่ออาจปรับปรุงการจัดระเบียบรหัสโดยการแยกสตริงแบบสอบถาม JPQL ออกจาก POJO นอกจากนี้ยังส่งผ่านพารามิเตอร์การสืบค้นแทนที่จะฝังตัวอักษรแบบไดนามิกลงในสตริงการสืบค้นดังนั้นจึงสร้างการสืบค้นที่มีประสิทธิภาพมากขึ้น

ก่อนอื่นให้เพิ่มคำอธิบายประกอบ @NamedQuery ในคลาสเอนทิตีพนักงานที่ชื่อ Employee.java ภายใต้ com.tutorialspoint.eclipselink.entity แพคเกจดังนี้:

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

สร้างคลาสชื่อ NamedQueries.java ภายใต้ com.tutorialspoint.eclipselink.service แพคเกจดังนี้:

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

หลังจากคอมไพล์และรันโปรแกรมข้างต้นแล้วคุณจะได้ผลลัพธ์ต่อไปนี้ในแผงคอนโซลของ Eclipse IDE

Employee ID :1204	 Employee Name :Satish

หลังจากเพิ่มคลาสข้างต้นทั้งหมดแล้วลำดับชั้นของแพ็กเกจจะมีลักษณะดังนี้:

กระตือรือร้นและขี้เกียจดึง

แนวคิดที่สำคัญที่สุดของ JPA คือการสร้างสำเนาฐานข้อมูลซ้ำในหน่วยความจำแคช ในขณะที่ทำธุรกรรมกับฐานข้อมูล JPA จะสร้างชุดข้อมูลที่ซ้ำกันก่อนและเมื่อมีการตกลงโดยใช้ตัวจัดการเอนทิตีเท่านั้นการเปลี่ยนแปลงจะมีผลกับฐานข้อมูล

มีสองวิธีในการดึงข้อมูลจากฐานข้อมูล

ดึงข้อมูลอย่างกระตือรือร้น

ในการดึงข้อมูลอย่างกระตือรือร้นออบเจ็กต์ลูกที่เกี่ยวข้องจะถูกอัปโหลดโดยอัตโนมัติในขณะที่ดึงข้อมูลบันทึกเฉพาะ

ขี้เกียจดึง

ในการดึงข้อมูลโดยอัตโนมัติวัตถุที่เกี่ยวข้องจะไม่ถูกอัปโหลดโดยอัตโนมัติเว้นแต่คุณจะร้องขอเป็นพิเศษ ก่อนอื่นจะตรวจสอบความพร้อมใช้งานของวัตถุที่เกี่ยวข้องและแจ้งให้ทราบ ในภายหลังหากคุณเรียกเมธอด getter ใด ๆ ของเอนทิตีนั้นระบบจะดึงข้อมูลทั้งหมด

Lazy fetch เป็นไปได้เมื่อคุณพยายามดึงข้อมูลเป็นครั้งแรก ด้วยวิธีนี้สำเนาของระเบียนทั้งหมดจะถูกเก็บไว้ในหน่วยความจำแคชแล้ว ควรใช้การดึงข้อมูลที่มีประสิทธิภาพและขี้เกียจ

JPA เป็นไลบรารีที่เผยแพร่พร้อมข้อกำหนด Java ดังนั้นจึงสนับสนุนแนวคิดเชิงวัตถุทั้งหมดสำหรับการคงอยู่ของเอนทิตี จนถึงตอนนี้เราได้ทำพื้นฐานของการทำแผนที่เชิงสัมพันธ์กันเรียบร้อยแล้ว บทนี้จะนำคุณไปสู่การแมปขั้นสูงระหว่างอ็อบเจ็กต์และเอนทิตีเชิงสัมพันธ์

กลยุทธ์การสืบทอด

การสืบทอดเป็นแนวคิดหลักของภาษาเชิงวัตถุใด ๆ ดังนั้นเราสามารถใช้ความสัมพันธ์หรือกลยุทธ์การสืบทอดระหว่างเอนทิตี JPA รองรับกลยุทธ์การสืบทอดสามประเภท: SINGLE_TABLE, JOINED_TABLE และ TABLE_PER_CONCRETE_CLASS

ให้เราพิจารณาตัวอย่าง แผนภาพต่อไปนี้แสดงสามคลาส ได้แก่ เจ้าหน้าที่ TeachingStaff และ NonTeachingStaff และความสัมพันธ์ของพวกเขา

ในแผนภาพด้านบน Staff คือเอนทิตีในขณะที่ TeachingStaff และ NonTeachingStaff เป็นเอนทิตีย่อยของ Staff ในที่นี้เราจะใช้ตัวอย่างข้างต้นเพื่อสาธิตกลยุทธ์การสืบทอดทั้งสามประการ

กลยุทธ์ตารางเดียว

กลยุทธ์ตารางเดียวจะใช้ฟิลด์ของคลาสทั้งหมด (ทั้งคลาสระดับสูงและคลาสย่อย) และแมปลงในตารางเดียวที่เรียกว่ากลยุทธ์ SINGLE_TABLE ที่นี่ค่าตัวเลือกมีบทบาทสำคัญในการแยกแยะค่าของสามเอนทิตีในตารางเดียว

ให้เราพิจารณาตัวอย่างข้างต้น TeachingStaff และ NonTeachingStaff เป็นคลาสย่อยของ Staff ตามแนวคิดของการสืบทอดคลาสย่อยจะสืบทอดคุณสมบัติของซูเปอร์คลาส ดังนั้น sid และ sname จึงเป็นฟิลด์ที่เป็นของทั้ง TeachingStaff และ NonTeachingStaff สร้างโครงการ JPA โมดูลทั้งหมดของโครงการนี้มีดังนี้:

การสร้างเอนทิตี

สร้างแพ็คเกจชื่อ ‘com.tutorialspoint.eclipselink.entity’ ภายใต้ ‘src’แพ็คเกจ สร้างคลาส java ใหม่ชื่อStaff.javaภายใต้แพ็คเกจที่กำหนด คลาสเอนทิตีพนักงานแสดงดังนี้:

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

ในรหัสด้านบน @DescriminatorColumn ระบุชื่อฟิลด์ (type) และค่าจะแสดงฟิลด์ (Teaching and NonTeachingStaff) ที่เหลือ

สร้างคลาสย่อย (คลาส) ไปยังคลาส Staff ที่ชื่อ TeachingStaff.java ภายใต้ com.tutorialspoint.eclipselink.entityแพ็คเกจ คลาส TeachingStaff Entity แสดงดังนี้:

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

สร้างคลาสย่อย (คลาส) ไปยังคลาส Staff ที่ชื่อ NonTeachingStaff.java ภายใต้ com.tutorialspoint.eclipselink.entityแพ็คเกจ คลาส NonTeachingStaff Entity แสดงดังนี้:

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 มีข้อมูลคอนฟิกูเรชันของฐานข้อมูลและข้อมูลการลงทะเบียนของคลาสเอนทิตี ไฟล์ xml จะแสดงดังนี้:

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

ชั้นบริการ

คลาสบริการเป็นส่วนหนึ่งของการดำเนินการขององค์ประกอบทางธุรกิจ สร้างแพ็คเกจภายใต้‘src’ ชื่อแพ็คเกจ ‘com.tutorialspoint.eclipselink.service’.

สร้างคลาสชื่อ SaveClient.javaภายใต้แพ็คเกจที่กำหนดเพื่อจัดเก็บฟิลด์คลาส Staff, TeachingStaff และ NonTeachingStaff คลาส SaveClient แสดงดังนี้:

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

หลังจากคอมไพล์และรันโปรแกรมข้างต้นแล้วคุณจะได้รับการแจ้งเตือนบนแผงคอนโซลของ Eclipse IDE ตรวจสอบ MySQL workbench สำหรับเอาต์พุต ผลลัพธ์ในรูปแบบตารางจะแสดงดังนี้:

ซิด	ประเภท	Sname	Areaexpertise	คุณสมบัติ	เรื่องความเชี่ยวชาญ
1	TS	โกปาล		MSC MED	คณิตศาสตร์
2	TS	มานิชา		บีเอสซีเบด	ภาษาอังกฤษ
3	NS	Satish	บัญชี
4	NS	กฤษณะ	ผู้ดูแลระบบสำนักงาน

ในที่สุดคุณจะได้รับตารางเดียวที่มีเขตข้อมูลของทั้งสามชั้นเรียนที่มีคอลัมน์ผู้แยกแยะชื่อ Type (สนาม).

เข้าร่วมกลยุทธ์ตาราง

กลยุทธ์ตารางที่เข้าร่วมคือการแชร์คอลัมน์ที่อ้างอิงซึ่งมีค่าเฉพาะเพื่อเข้าร่วมตารางและทำธุรกรรมได้ง่าย ให้เราพิจารณาตัวอย่างเดียวกับด้านบน

สร้างโครงการ JPA โมดูลโครงการทั้งหมดแสดงอยู่ด้านล่าง

การสร้างเอนทิตี

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

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

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

ไฟล์ Persistence.xml มีข้อมูลคอนฟิกูเรชันของฐานข้อมูลและข้อมูลการลงทะเบียนของคลาสเอนทิตี ไฟล์ xml จะแสดงดังนี้:

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

ชั้นบริการ

สร้างคลาสชื่อ SaveClient.javaภายใต้แพ็คเกจที่กำหนดเพื่อจัดเก็บสาขาของ Staff, TeachingStaff และ NonTeachingStaff class จากนั้นคลาส SaveClient จะแสดงดังนี้:

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

หลังจากคอมไพล์และรันโปรแกรมข้างต้นคุณจะได้รับการแจ้งเตือนในแผงคอนโซลของ Eclipse IDE สำหรับผลลัพธ์ให้ตรวจสอบ MySQL workbench

ที่นี่สามตารางถูกสร้างขึ้นและผลลัพธ์ของ staff ตารางจะแสดงในรูปแบบตาราง

ซิด	Dtype	Sname
1	การสอน	โกปาล
2	การสอน	มานิชา
3	NonTeachingStaff	Satish
4	NonTeachingStaff	กฤษณะ

ผลของ TeachingStaff ตารางจะแสดงดังนี้:

ซิด	คุณสมบัติ	เรื่องความเชี่ยวชาญ
1	MSC MED	คณิตศาสตร์
2	บีเอสซีเบด	ภาษาอังกฤษ

ในตารางด้านบนคือคีย์ต่างประเทศ (ตารางเจ้าหน้าที่ฟอร์มฟิลด์อ้างอิง) ผลลัพธ์ของ NonTeachingStaff ตารางจะแสดงดังนี้:

ซิด	Areaexpertise
3	บัญชี
4	ผู้ดูแลระบบสำนักงาน

ในที่สุดตารางทั้งสามจะถูกสร้างขึ้นโดยใช้ฟิลด์ตามลำดับและฟิลด์ SID จะใช้ร่วมกันโดยทั้งสามตาราง ในตาราง Staff SID คือคีย์หลัก ในสองตารางที่เหลือ (TeachingStaff และ NonTeachingStaff) SID คือคีย์ต่างประเทศ

ตารางต่อชั้นเรียน

กลยุทธ์ตารางต่อคลาสคือการสร้างตารางสำหรับแต่ละเอนทิตีย่อย ตาราง Staff จะถูกสร้างขึ้น แต่จะมีค่า null ค่าฟิลด์ของตาราง Staff ต้องแชร์ทั้งตาราง TeachingStaff และ NonTeachingStaff

ให้เราพิจารณาตัวอย่างเดียวกับด้านบน

การสร้างเอนทิตี

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

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

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

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

ชั้นบริการ

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

หลังจากรวบรวมและเรียกใช้โปรแกรมข้างต้นคุณจะได้รับการแจ้งเตือนบนแผงคอนโซลของ Eclipse IDE สำหรับผลลัพธ์ให้ตรวจสอบ MySQL workbench

ที่นี่มีการสร้างตารางสามตารางและไฟล์ Staff ตารางมีระเบียนว่าง

ผลของ TeachingStaff จะแสดงดังนี้:

ซิด	คุณสมบัติ	Sname	เรื่องความเชี่ยวชาญ
1	MSC MED	โกปาล	คณิตศาสตร์
2	บีเอสซีเบด	มานิชา	ภาษาอังกฤษ

ตารางด้านบน TeachingStaff ประกอบด้วยฟิลด์ของทั้ง Staff และ TeachingStaff Entities

ผลของ NonTeachingStaff จะแสดงดังนี้:

ซิด	Areaexpertise	Sname
3	บัญชี	Satish
4	ผู้ดูแลระบบสำนักงาน	กฤษณะ

ตารางด้านบน NonTeachingStaff ประกอบด้วยฟิลด์ของทั้ง Staff และ NonTeachingStaff Entities

บทนี้จะนำคุณไปสู่ความสัมพันธ์ระหว่างเอนทิตี โดยทั่วไปความสัมพันธ์จะมีประสิทธิภาพมากกว่าระหว่างตารางในฐานข้อมูล ที่นี่คลาสเอนทิตีจะถือว่าเป็นตารางเชิงสัมพันธ์ (แนวคิดของ JPA) ดังนั้นความสัมพันธ์ระหว่างคลาสเอนทิตีจึงเป็นดังนี้:

@ManyToOne สัมพันธ์
@OneToMany สัมพันธ์
@OneToOne สัมพันธ์
@ManyToMany สัมพันธ์

@ManyToOne สัมพันธ์

ความสัมพันธ์แบบหลายต่อหนึ่งระหว่างเอนทิตีมีอยู่โดยที่เอนทิตีหนึ่ง (คอลัมน์หรือชุดของคอลัมน์) ถูกอ้างอิงกับเอนทิตีอื่น (คอลัมน์หรือชุดของคอลัมน์) ที่มีค่าที่ไม่ซ้ำกัน ในฐานข้อมูลเชิงสัมพันธ์ความสัมพันธ์เหล่านี้จะถูกนำไปใช้โดยใช้คีย์ต่างประเทศ / คีย์หลักระหว่างตาราง

ให้เราพิจารณาตัวอย่างของความสัมพันธ์ระหว่างหน่วยงานของพนักงานและแผนก ในลักษณะทิศทางเดียวกล่าวคือจากพนักงานไปยังแผนกความสัมพันธ์แบบหลายต่อหนึ่งสามารถใช้ได้ นั่นหมายถึงประวัติของพนักงานแต่ละคนจะมีรหัสแผนกหนึ่งรหัสซึ่งควรเป็นคีย์หลักในตารางแผนก ในตารางพนักงานรหัสแผนกคือคีย์ต่างประเทศ

แผนภาพต่อไปนี้แสดงความสัมพันธ์แบบกลุ่มต่อหนึ่งระหว่างสองตาราง

สร้างโปรเจ็กต์ JPA ใน eclipse IDE ที่ชื่อ JPA_Eclipselink_MTO. โมดูลทั้งหมดของโครงการนี้จะกล่าวถึงด้านล่าง

การสร้างเอนทิตี

ทำตามแผนภาพด้านบนเพื่อสร้างเอนทิตี สร้างแพ็คเกจชื่อ‘com.tutorialspoin.eclipselink.entity’ ภายใต้ ‘src’แพ็คเกจ สร้างคลาสชื่อDepartment.javaภายใต้แพ็คเกจที่กำหนด เอนทิตีแผนกคลาสจะแสดงดังต่อไปนี้:

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

สร้างเอนทิตีที่สองในความสัมพันธ์นี้ - คลาสเอนทิตีพนักงานชื่อ Employee.java ภายใต้ ‘com.tutorialspoint.eclipselink.entity’แพ็คเกจ คลาสเอนทิตีพนักงานแสดงดังนี้:

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

ไฟล์ Persistence.xml จำเป็นในการกำหนดค่าฐานข้อมูลและการลงทะเบียนคลาสเอนทิตี

Persitence.xml จะถูกสร้างโดย eclipse IDE ในขณะที่สร้างโครงการ JPA รายละเอียดการกำหนดค่าเป็นข้อกำหนดของผู้ใช้ ไฟล์ persistence.xml จะแสดงดังนี้:

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

ชั้นเรียนบริการ

โมดูลนี้มีคลาสเซอร์วิสซึ่งใช้ส่วนเชิงสัมพันธ์โดยใช้การเริ่มต้นแอ็ตทริบิวต์ สร้างแพ็คเกจภายใต้‘src’ ชื่อแพ็คเกจ ‘com.tutorialspoint.eclipselink.service’. ชื่อคลาส DAOManyToOne.javaถูกสร้างขึ้นภายใต้แพ็คเกจที่กำหนด คลาส DAO จะแสดงดังนี้:

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

หลังจากรวบรวมและเรียกใช้โปรแกรมข้างต้นคุณจะได้รับการแจ้งเตือนบนแผงคอนโซลของ Eclipse IDE สำหรับผลลัพธ์ให้ตรวจสอบ MySQL workbench ในตัวอย่างนี้มีการสร้างตารางสองตาราง

ส่งแบบสอบถามต่อไปนี้ในอินเทอร์เฟซ MySQL และผลลัพธ์ของ Department ตารางจะแสดงดังนี้:

Select * from department

ID	ชื่อ
101	การพัฒนา

ส่งแบบสอบถามต่อไปนี้ในอินเทอร์เฟซ MySQL และผลลัพธ์ของ Employee ตารางจะแสดงดังนี้

Select * from employee

Eid	องศา	Ename	เงินเดือน	Department_Id
102	นักเขียนด้านเทคนิค	Satish	45000	101
103	นักเขียนด้านเทคนิค	กฤษณะ	45000	101
104	นักเขียนด้านเทคนิค	Masthanwali	50000	101

ในตารางด้านบน Deparment_Id คือ Foreign Key (ฟิลด์อ้างอิง) จากตาราง Department

@OneToMany สัมพันธ์

ในความสัมพันธ์นี้แต่ละแถวของเอนทิตีหนึ่งถูกอ้างถึงกับเรกคอร์ดชายน์จำนวนมากในเอนทิตีอื่น สิ่งสำคัญคือประวัติเด็กไม่สามารถมีพ่อแม่หลายคนได้ ในความสัมพันธ์แบบหนึ่งต่อกลุ่มระหว่างตาราง A และตาราง B แต่ละแถวในตาราง A สามารถเชื่อมโยงกับหนึ่งหรือหลายแถวในตาราง B

ให้เราพิจารณาตัวอย่างข้างต้น สมมติว่าตารางพนักงานและแผนกในตัวอย่างข้างต้นเชื่อมต่อกันในลักษณะทิศทางเดียวย้อนกลับจากนั้นความสัมพันธ์จะกลายเป็นความสัมพันธ์แบบหนึ่งต่อกลุ่ม สร้างโปรเจ็กต์ JPA ใน eclipse IDE ที่ชื่อJPA_Eclipselink_OTM. โมดูลทั้งหมดของโครงการนี้จะกล่าวถึงด้านล่าง

การสร้างเอนทิตี

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

สร้างเอนทิตีที่สองในคลาสเอนทิตี -Employee ความสัมพันธ์นี้ชื่อ Employee.java ภายใต้ ‘com.tutorialspoint.eclipselink.entity’แพ็คเกจ คลาสเอนทิตีพนักงานแสดงดังนี้:

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

ไฟล์ persistence.xml มีดังนี้:

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

ชั้นเรียนบริการ

โมดูลนี้มีคลาสเซอร์วิสซึ่งใช้ส่วนเชิงสัมพันธ์โดยใช้การเริ่มต้นแอ็ตทริบิวต์ สร้างแพ็คเกจภายใต้‘src’ ชื่อแพ็คเกจ ‘com.tutorialspoint.eclipselink.service’. ชื่อคลาส DAOOneToMany.javaถูกสร้างขึ้นภายใต้แพ็คเกจที่กำหนด คลาส DAO จะแสดงดังนี้:

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

หลังจากรวบรวมและดำเนินการโปรแกรมข้างต้นคุณจะได้รับการแจ้งเตือนในแผงคอนโซลของ Eclipse IDE สำหรับผลลัพธ์ตรวจสอบ MySQL workbench ดังต่อไปนี้

ในโครงการนี้มีการสร้างตารางสามตาราง ส่งแบบสอบถามต่อไปนี้ในอินเทอร์เฟซ MySQL และผลลัพธ์ของตาราง department_employee จะแสดงดังนี้:

Select * from department_Id;

Department_ID	Employee_Eid
254	251
254	252
254	253

ในตารางด้านบน deparment_id และ employee_id คือคีย์ต่างประเทศ (ฟิลด์อ้างอิง) จากแผนกและตารางพนักงาน

ส่งแบบสอบถามต่อไปนี้ในอินเทอร์เฟซ MySQL และผลลัพธ์ของตารางแผนกจะแสดงในรูปแบบตารางดังนี้

Select * from department;

ID	ชื่อ
254	การพัฒนา

ส่งแบบสอบถามต่อไปนี้ในอินเทอร์เฟซ MySQL และผลลัพธ์ของตารางพนักงานจะแสดงดังนี้:

Select * from employee;

Eid	องศา	Ename	เงินเดือน
251	นักเขียนด้านเทคนิค	Satish	45000
252	นักเขียนด้านเทคนิค	กฤษณะ	45000
253	นักเขียนด้านเทคนิค	Masthanwali	50000

@OneToOne สัมพันธ์

ในความสัมพันธ์แบบหนึ่งต่อหนึ่งรายการหนึ่งสามารถเชื่อมโยงกับรายการอื่นได้เพียงรายการเดียว หมายความว่าแต่ละแถวของเอนทิตีหนึ่งถูกอ้างถึงหนึ่งแถวของเอนทิตีอื่นเท่านั้น

ให้เราพิจารณาตัวอย่างข้างต้น Employee และ Departmentในลักษณะกลับทิศทางเดียวความสัมพันธ์คือความสัมพันธ์แบบหนึ่งต่อหนึ่ง หมายความว่าพนักงานแต่ละคนอยู่ในแผนกเดียวเท่านั้น สร้างโปรเจ็กต์ JPA ใน eclipse IDE ที่ชื่อJPA_Eclipselink_OTO. โมดูลทั้งหมดของโครงการนี้จะกล่าวถึงด้านล่าง

การสร้างเอนทิตี

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

package com.tutorialspoint.eclipselink.entity;

import javax.persistence.Entity;
import javax.persistence.GeneratedValue;
import javax.persistence.GenerationType;
import javax.persistence.Id;
import javax.persistence.OneToOne;

@Entity
public class Employee 
{
	@Id
	@GeneratedValue( strategy= GenerationType.AUTO ) 	
	private int eid;
	private String ename;
	private double salary;
	private String deg;
	
	@OneToOne
	private Department department;
		
	public Employee(int eid, 
			String ename, double salary, String deg) 
	{
		super( );
		this.eid = eid;
		this.ename = ename;
		this.salary = salary;
		this.deg = deg;
	}
	
	public Employee( ) 
	{
		super();
	}
	
	public int getEid( ) 
	{
		return eid;
	}
	public void setEid(int eid)  
	{
		this.eid = eid;
	}
	
	public String getEname( ) 
	{
		return ename;
	}
	public void setEname(String ename) 
	{
		this.ename = ename;
	}
	
	public double getSalary( ) 
	{
		return salary;
	}
	public void setSalary(double salary) 
	{
		this.salary = salary;
	}
	
	public String getDeg( ) 
	{
		return deg;
	}
	public void setDeg(String deg) 
	{
		this.deg = deg;
	}

	public Department getDepartment() 
	{
		return department;
	}

	public void setDepartment(Department department) 
	{
		this.department = department;
	}	
}

Persistence.xml

ไฟล์ Persistence.xml ดังนี้:

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

ชั้นเรียนบริการ

สร้างแพ็คเกจภายใต้ ‘src’ ชื่อแพ็คเกจ ‘com.tutorialspoint.eclipselink.service’. ชื่อคลาส DAOOneToOne.javaถูกสร้างขึ้นภายใต้แพ็คเกจที่กำหนด คลาส DAO จะแสดงดังนี้:

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

หลังจากรวบรวมและดำเนินการโปรแกรมข้างต้นคุณจะได้รับการแจ้งเตือนในแผงคอนโซลของ Eclipse IDE สำหรับเอาต์พุตให้ตรวจสอบ MySQL workbench ดังต่อไปนี้

ในตัวอย่างข้างต้นมีการสร้างตารางสองตาราง ส่งแบบสอบถามต่อไปนี้ในอินเทอร์เฟซ MySQL และผลลัพธ์ของตารางแผนกจะแสดงดังนี้:

Select * from department

ID	ชื่อ
301	การพัฒนา

ส่งแบบสอบถามต่อไปนี้ในอินเทอร์เฟซ MySQL และผลลัพธ์ของ employee ตารางจะแสดงดังนี้:

Select * from employee

Eid	องศา	Ename	เงินเดือน	Department_id
302	นักเขียนด้านเทคนิค	Satish	45000	301

@ManyToMany สัมพันธ์

ความสัมพันธ์แบบกลุ่มต่อกลุ่มคือการที่แถวอย่างน้อยหนึ่งแถวจากเอนทิตีหนึ่งเชื่อมโยงกับมากกว่าหนึ่งแถวในเอนทิตีอื่น

ให้เราพิจารณาตัวอย่างของความสัมพันธ์ระหว่างสองเอนทิตี: Class และ Teacher. ในลักษณะสองทิศทางทั้งชั้นเรียนและครูมีความสัมพันธ์แบบหลายต่อหนึ่ง นั่นหมายความว่าแต่ละระเบียนของชั้นเรียนจะอ้างอิงโดยชุดครู (รหัสครู) ซึ่งควรเป็นคีย์หลักในตารางครูและเก็บไว้ในตาราง Teacher_Class และในทางกลับกัน ที่นี่ตาราง Teachers_Class มีทั้งฟิลด์คีย์ต่างประเทศ สร้างโปรเจ็กต์ JPA ใน eclipse IDE ที่ชื่อJPA_Eclipselink_MTM. โมดูลทั้งหมดของโครงการนี้จะกล่าวถึงด้านล่าง

การสร้างเอนทิตี

สร้างเอนทิตีโดยทำตามสคีมาที่แสดงในแผนภาพด้านบน สร้างแพ็คเกจชื่อ‘com.tutorialspoin.eclipselink.entity’ ภายใต้ ‘src’แพ็คเกจ สร้างคลาสชื่อClas.javaภายใต้แพ็คเกจที่กำหนด เอนทิตีแผนกคลาสจะแสดงดังต่อไปนี้:

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

สร้างเอนทิตีที่สองในคลาสเอนทิตี -Employee ความสัมพันธ์นี้ชื่อ Teacher.java ภายใต้ ‘com.tutorialspoint.eclipselink.entity’แพ็คเกจ คลาสเอนทิตีพนักงานแสดงดังนี้:

package com.tutorialspoint.eclipselink.entity;

import java.util.Set;
import javax.persistence.Entity;
import javax.persistence.GeneratedValue;
import javax.persistence.GenerationType;
import javax.persistence.Id;
import javax.persistence.ManyToMany;

@Entity
public class Teacher 
{
	@Id
	@GeneratedValue( strategy = GenerationType.AUTO )
	private int tid;
	private String tname;
	private String subject;
	
	@ManyToMany(targetEntity=Clas.class)
	private Set clasSet;
	
	public Teacher() 
	{
		super();
	}
	public Teacher(int tid, String tname, String subject, 
			Set clasSet) 
	{
		super();
		this.tid = tid;
		this.tname = tname;
		this.subject = subject;
		this.clasSet = clasSet;
	}
	public int getTid() 
	{
		return tid;
	}
	public void setTid(int tid) 
	{
		this.tid = tid;
	}
	public String getTname() 
	{
		return tname;
	}
	public void setTname(String tname) 
	{
		this.tname = tname;
	}
	public String getSubject() 
	{
		return subject;
	}
	public void setSubject(String subject) 
	{
		this.subject = subject;
	}
	public Set getClasSet() 
	{
		return clasSet;
	}
	public void setClasSet(Set clasSet) 
	{
		this.clasSet = clasSet;
	}
}

Persistence.xml

ไฟล์ Persistence.xml ดังนี้:

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

ชั้นเรียนบริการ

สร้างแพ็คเกจภายใต้ ‘src’ ชื่อแพ็คเกจ ‘com.tutorialspoint.eclipselink.service’. ชื่อคลาส DAOManyToMany.javaถูกสร้างขึ้นภายใต้แพ็คเกจที่กำหนด คลาส DAO จะแสดงดังนี้:

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

ในโครงการตัวอย่างนี้มีการสร้างตารางสามตาราง ส่งแบบสอบถามต่อไปนี้ในอินเทอร์เฟซ MySQL และผลลัพธ์ของตาราง teacher_clas จะแสดงดังนี้:

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

ในตารางด้านบน teacher_tid เป็นคีย์ต่างประเทศจากตารางครูและ classet_cidเป็นคีย์ต่างประเทศจากตารางคลาส ดังนั้นครูที่แตกต่างกันจึงถูกจัดสรรให้อยู่ในชั้นเรียนที่แตกต่างกัน

ส่งแบบสอบถามต่อไปนี้ในอินเทอร์เฟซ MySQL และผลลัพธ์ของตารางครูจะแสดงดังนี้:

Select * from teacher

ติ๊ด	เรื่อง	ชื่อ
354	Java	Satish
355	Adv Java	กฤษณะ
356	DB2	Masthanvali

ส่งแบบสอบถามต่อไปนี้ในอินเทอร์เฟซ MySQL และผลลัพธ์ของ clas ตารางจะแสดงดังนี้:

Select * from clas

Cid	Cname
351	ที่ 1
352	ครั้งที่ 2
353	วันที่ 3

Criteria คือ API ที่กำหนดไว้ล่วงหน้าซึ่งใช้เพื่อกำหนดการสืบค้นสำหรับเอนทิตี เป็นอีกทางเลือกหนึ่งในการกำหนดแบบสอบถาม JPQL ข้อความค้นหาเหล่านี้เป็นประเภทที่ปลอดภัยพกพาได้และง่ายต่อการแก้ไขโดยการเปลี่ยนไวยากรณ์ คล้ายกับ JPQL เป็นไปตามสคีมานามธรรม (แก้ไขสคีมาได้ง่าย) และวัตถุฝังตัว API ข้อมูลเมตาถูกผสมผสานกับ API เกณฑ์เพื่อสร้างแบบจำลองเอนทิตีถาวรสำหรับเคียวรีเกณฑ์

ข้อได้เปรียบที่สำคัญของ Criteria API คือสามารถตรวจพบข้อผิดพลาดได้ก่อนหน้านี้ในช่วงเวลาคอมไพล์ แบบสอบถาม JPQL ที่ใช้สตริงและการสืบค้นตามเกณฑ์ JPA นั้นมีประสิทธิภาพและประสิทธิผลเหมือนกัน

ประวัติของเกณฑ์ API

เกณฑ์จะรวมอยู่ใน JPA ทุกเวอร์ชันดังนั้นแต่ละขั้นตอนของเกณฑ์จะได้รับแจ้งในข้อกำหนดของ JPA

ใน JPA 2.0 จะมีการพัฒนา API เคียวรีเกณฑ์มาตรฐานของคิวรี
ใน JPA 2.1 จะมีการอัปเดตและลบเกณฑ์ (อัปเดตและลบจำนวนมาก)

โครงสร้างแบบสอบถามเกณฑ์

เกณฑ์และ JPQL มีความสัมพันธ์กันอย่างใกล้ชิดและได้รับอนุญาตให้ออกแบบโดยใช้ตัวดำเนินการที่คล้ายกันในการสืบค้น มันเป็นไปตามjavax.persistence.criteriaแพคเกจเพื่อออกแบบแบบสอบถาม โครงสร้างคิวรีหมายถึงคิวรีเกณฑ์ไวยากรณ์

แบบสอบถามเกณฑ์อย่างง่ายต่อไปนี้ส่งคืนอินสแตนซ์ทั้งหมดของคลาสเอนทิตีในแหล่งข้อมูล

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

แบบสอบถามแสดงขั้นตอนพื้นฐานในการสร้างเกณฑ์

EntityManager อินสแตนซ์ถูกใช้เพื่อสร้างวัตถุ CriteriaBuilder
CriteriaQueryอินสแตนซ์ถูกใช้เพื่อสร้างวัตถุแบบสอบถาม แอตทริบิวต์ของวัตถุการค้นหานี้จะถูกแก้ไขพร้อมกับรายละเอียดของแบบสอบถาม
CriteriaQuery.form เรียกวิธีการตั้งค่ารากของแบบสอบถาม
CriteriaQuery.select ถูกเรียกเพื่อตั้งค่าประเภทรายการผลลัพธ์
TypedQuery<T> อินสแตนซ์ใช้ในการจัดเตรียมแบบสอบถามสำหรับการดำเนินการและระบุประเภทของผลลัพธ์คิวรี
getResultListวิธีการบนวัตถุ TypedQuery <T> เพื่อเรียกใช้แบบสอบถาม แบบสอบถามนี้ส่งคืนคอลเล็กชันของเอนทิตีผลลัพธ์จะถูกเก็บไว้ในรายการ

ตัวอย่างเกณฑ์ API

ให้เราพิจารณาตัวอย่างของฐานข้อมูลพนักงาน ให้เราถือว่าตาราง jpadb.employee มีบันทึกต่อไปนี้:

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

สร้างโครงการ JPA ใน eclipse IDE ที่ชื่อ JPA_Eclipselink_Criteria. โมดูลทั้งหมดของโครงการนี้มีการกล่าวถึงด้านล่าง:

การสร้างเอนทิตี

สร้างแพ็คเกจชื่อ com.tutorialspoint.eclipselink.entity ภายใต้ ‘src’

สร้างคลาสชื่อ Employee.javaภายใต้แพ็คเกจที่กำหนด เอนทิตีพนักงานคลาสจะแสดงดังนี้:

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

ไฟล์ Persistence.xml มีดังนี้:

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

คลาสบริการ

โมดูลนี้มีคลาสเซอร์วิสซึ่งใช้ส่วนเคียวรี Criteria โดยใช้การเริ่มต้น MetaData API สร้างแพ็คเกจชื่อ‘com.tutorialspoint.eclipselink.service’. ชั้นเรียนชื่อCriteriaAPI.javaถูกสร้างขึ้นภายใต้แพ็คเกจที่กำหนด คลาส DAO จะแสดงดังนี้:

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

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