JPA: Memperkenalkan Teknologi

Dunia perkembangan modern penuh dengan berbagai spesifikasi yang dirancang untuk membuat hidup lebih mudah. Mengetahui alatnya, Anda dapat memilih yang tepat. Tanpa Anda sadari, Anda bisa membuat hidup Anda semakin sulit. Tinjauan ini akan membuka tabir kerahasiaan konsep JPA - Java Persistence API. Saya harap setelah membaca Anda ingin menyelami lebih dalam lagi ke dunia misterius ini.

• Perkenalan
• Membuat Proyek
• Menambahkan JPA
• Entitas
• Pemetaan
• JPQL
• API Kriteria
• Kesimpulan

Perkenalan

Seperti kita ketahui, salah satu tugas utama program adalah menyimpan dan mengolah data. Di masa lalu, orang hanya menyimpan data dalam file. Namun begitu akses baca dan edit secara bersamaan diperlukan, ketika ada beban (yaitu, beberapa permintaan datang pada waktu yang sama), menyimpan data hanya dalam file menjadi masalah. Untuk informasi lebih lanjut tentang masalah apa yang dipecahkan oleh database dan bagaimana caranya, saya menyarankan Anda untuk membaca artikel “ Bagaimana database disusun .” Ini berarti kami memutuskan untuk menyimpan data kami dalam database. Sejak lama, Java telah mampu bekerja dengan database menggunakan JDBC API (The Java Database Connectivity). Anda dapat membaca lebih lanjut tentang JDBC di sini: “ JDBC atau di mana semuanya dimulai .” Namun waktu berlalu dan pengembang setiap kali menghadapi kebutuhan untuk menulis kode “pemeliharaan” yang sama dan tidak diperlukan (yang disebut kode Boilerplate) untuk operasi sepele menyimpan objek Java ke dalam database dan sebaliknya, membuat objek Java menggunakan data dari basis data. Dan kemudian, untuk mengatasi masalah tersebut, lahirlah konsep ORM. ORM - Pemetaan Relasional Objek atau diterjemahkan ke dalam pemetaan relasional objek Rusia. Ini adalah teknologi pemrograman yang menghubungkan database dengan konsep bahasa pemrograman berorientasi objek. Untuk menyederhanakan, ORM adalah hubungan antara objek Java dan catatan dalam database: ORM pada dasarnya adalah konsep bahwa objek Java dapat direpresentasikan sebagai data dalam database (dan sebaliknya). Itu diwujudkan dalam bentuk spesifikasi JPA - Java Persistence API. Spesifikasi sudah merupakan deskripsi dari Java API yang mengungkapkan konsep ini. Spesifikasi tersebut memberi tahu kita alat apa yang harus kita sediakan (yaitu antarmuka apa yang dapat kita gunakan) agar dapat bekerja sesuai dengan konsep ORM. Dan bagaimana cara menggunakan dana tersebut. Spesifikasi tidak menjelaskan implementasi alat tersebut. Hal ini memungkinkan untuk menggunakan implementasi yang berbeda untuk satu spesifikasi. Anda dapat menyederhanakannya dan mengatakan bahwa spesifikasi adalah deskripsi API. Teks spesifikasi JPA dapat ditemukan di situs web Oracle: " JSR 338: JavaTM Persistence API ". Oleh karena itu, untuk menggunakan JPA, kita memerlukan beberapa implementasi yang akan kita gunakan teknologinya. Implementasi JPA juga disebut Penyedia JPA. Salah satu implementasi JPA yang paling menonjol adalah Hibernate . Oleh karena itu, saya mengusulkan untuk mempertimbangkannya.

Membuat Proyek

Karena JPA adalah tentang Java, kita memerlukan proyek Java. Kita dapat membuat sendiri struktur direktori secara manual dan menambahkan sendiri perpustakaan yang diperlukan. Tetapi jauh lebih nyaman dan benar untuk menggunakan sistem untuk mengotomatisasi perakitan proyek (yaitu, pada dasarnya, ini hanyalah sebuah program yang akan mengelola perakitan proyek untuk kita. Buat direktori, tambahkan perpustakaan yang diperlukan ke classpath, dll. .). Salah satu sistem tersebut adalah Gradle. Anda dapat membaca lebih lanjut tentang Gradle di sini: " Pengantar Singkat tentang Gradle ". Seperti yang kita ketahui, fungsionalitas Gradle (yaitu hal-hal yang dapat dilakukannya) diimplementasikan menggunakan berbagai Plugin Gradle. Mari gunakan Gradle dan plugin " Gradle Build Init Plugin ". Mari kita jalankan perintah:

gradle init --type java-application

Gradle akan mengerjakan struktur direktori yang diperlukan untuk kita dan membuat deskripsi deklaratif dasar proyek dalam skrip build build.gradle. Jadi, kami punya aplikasi. Kita perlu memikirkan apa yang ingin kita gambarkan atau modelkan dengan aplikasi kita. Mari kita gunakan beberapa alat pemodelan, misalnya: app.quickdatabasediagrams.com Di sini perlu dikatakan bahwa apa yang telah kami jelaskan adalah “model domain” kami. Domain adalah “bidang subjek”. Secara umum, domain adalah “kepemilikan” dalam bahasa Latin. Pada Abad Pertengahan, ini adalah nama yang diberikan untuk wilayah yang dimiliki oleh raja atau tuan tanah feodal. Dan dalam bahasa Perancis menjadi kata "domaine", yang secara sederhana diterjemahkan sebagai "area". Jadi kami menggambarkan "model domain" = "model subjek" kami. Setiap elemen model ini adalah semacam “esensi”, sesuatu dari kehidupan nyata. Dalam kasus kami, ini adalah entitas: Kategori ( Category), Subjek ( Topic). Mari kita buat paket terpisah untuk entitas, misalnya dengan nama model. Dan mari tambahkan kelas Java di sana yang mendeskripsikan entitas. Dalam kode Java, entitas tersebut adalah POJO biasa , yang mungkin terlihat seperti ini:

public class Category {
    private Long id;
    private String title;

    public String getTitle() {
        return title;
    }

    public void setTitle(String title) {
        this.title = title;
    }
}

Mari salin isi kelas dan buat kelas dengan analogi Topic. Dia hanya akan berbeda dalam apa yang dia ketahui tentang kategori di mana dia berada. Oleh karena itu, mari tambahkan Topicbidang kategori dan metode untuk mengerjakannya ke kelas:

private Category category;

public Category getCategory() {
	return category;
}

public void setCategory(Category category) {
	this.category = category;
}

Sekarang kami memiliki aplikasi Java yang memiliki model domainnya sendiri. Sekarang saatnya untuk mulai menghubungkan ke proyek JPA.

Menambahkan JPA

Jadi seingat kita JPA artinya kita akan menyimpan sesuatu ke dalam database. Oleh karena itu, kita memerlukan database. Untuk menggunakan koneksi database dalam proyek kita, kita perlu menambahkan perpustakaan ketergantungan untuk terhubung ke database. Seingat kami, kami menggunakan Gradle, yang membuat skrip build untuk kami build.gradle. Di dalamnya kami akan menjelaskan dependensi yang dibutuhkan proyek kami. Dependensi adalah pustaka yang tanpanya kode kita tidak dapat berfungsi. Mari kita mulai dengan deskripsi ketergantungan pada koneksi ke database. Kami melakukan ini dengan cara yang sama jika kami hanya bekerja dengan JDBC:

dependencies {
	implementation 'com.h2database:h2:1.4.199'

Sekarang kami memiliki database. Sekarang kita dapat menambahkan lapisan ke aplikasi kita yang bertanggung jawab untuk memetakan objek Java ke dalam konsep database (dari Java ke SQL). Seingat kami, kami akan menggunakan implementasi spesifikasi JPA yang disebut Hibernate untuk ini:

dependencies {
	implementation 'com.h2database:h2:1.4.199'
	implementation 'org.hibernate:hibernate-core:5.4.2.Final'

Sekarang kita perlu mengkonfigurasi JPA. Jika kita membaca spesifikasi dan bagian "8.1 Persistence Unit", kita akan mengetahui bahwa Persistence Unit adalah semacam kombinasi konfigurasi, metadata, dan entitas. Dan agar JPA berfungsi, Anda perlu menjelaskan setidaknya satu Unit Persistensi dalam file konfigurasi, yang disebut persistence.xml. Lokasinya dijelaskan dalam bab spesifikasi "8.2 Pengemasan Unit Persistensi". Menurut bagian ini, jika kita memiliki lingkungan Java SE, maka kita harus meletakkannya di root direktori META-INF. Mari kita salin konten dari contoh yang diberikan dalam spesifikasi JPA di 8.2.1 persistence.xml filebab " ":

<persistence>
	<persistence-unit name="JavaRush">
        <description>Persistence Unit For test</description>
        <class>hibernate.model.Category</class>
        <class>hibernate.model.Topic</class>
    </persistence-unit>
</persistence>

Tapi ini tidak cukup. Kita perlu memberi tahu siapa Penyedia JPA kita, mis. orang yang mengimplementasikan spesifikasi JPA:

<provider>org.hibernate.jpa.HibernatePersistenceProvider</provider>

Sekarang mari tambahkan pengaturan ( properties). Beberapa di antaranya (dimulai dengan javax.persistence) adalah konfigurasi JPA standar dan dijelaskan dalam spesifikasi JPA di bagian "properti 8.2.1.9". Beberapa konfigurasi bersifat khusus penyedia (dalam kasus kami, konfigurasi tersebut memengaruhi Hibernate sebagai Penyedia Jpa. Blok pengaturan kami akan terlihat seperti ini:

<properties>
    <property name="javax.persistence.jdbc.driver" value="org.h2.Driver" />
    <property name="javax.persistence.jdbc.url" value="jdbc:h2:mem:db1;DB_CLOSE_DELAY=-1;MVCC=TRUE" />
    <property name="javax.persistence.jdbc.user" value="sa" />
    <property name="javax.persistence.jdbc.password" value="" />
    <property name="hibernate.show_sql" value="true" />
    <property name="hibernate.hbm2ddl.auto" value="create" />
</properties>

Sekarang kita memiliki konfigurasi yang kompatibel dengan JPA persistence.xml, ada penyedia JPA Hibernate dan ada database H2, dan juga ada 2 kelas yang menjadi model domain kita. Akhirnya mari kita buat ini semua berhasil. Di katalog /test/java, Gradle kami dengan baik hati membuat templat untuk pengujian Unit dan menyebutnya AppTest. Mari kita gunakan. Sebagaimana dinyatakan dalam bab "7.1 Konteks Persistensi" pada spesifikasi JPA, entitas di dunia JPA hidup dalam ruang yang disebut Konteks Persistensi. Namun kami tidak bekerja secara langsung dengan Konteks Persistensi. Untuk ini kami menggunakan Entity Manageratau "manajer entitas". Dialah yang mengetahui konteks dan entitas apa yang tinggal di sana. Kami berinteraksi dengan Entity Manager'om. Lalu yang tersisa hanyalah memahami dari mana kita bisa mendapatkan yang satu ini Entity Manager? Menurut bab "7.2.2 Mendapatkan Manajer Entitas yang Dikelola Aplikasi" dari spesifikasi JPA, kita harus menggunakan EntityManagerFactory. Oleh karena itu, mari mempersenjatai diri dengan spesifikasi JPA dan mengambil contoh dari bab “7.3.2 Memperoleh Pabrik Manajer Entitas di Lingkungan Java SE” dan memformatnya dalam bentuk pengujian Unit sederhana:

@Test
public void shouldStartHibernate() {
	EntityManagerFactory emf = Persistence.createEntityManagerFactory( "JavaRush" );
	EntityManager entityManager = emf.createEntityManager();
}

Tes ini sudah menunjukkan kesalahan "Persistensi JPA tidak dikenal.xml versi XSD". Alasannya adalah persistence.xmlAnda perlu menentukan skema yang akan digunakan dengan benar, sebagaimana dinyatakan dalam spesifikasi JPA di bagian "8.3 persistence.xml Schema":

<persistence xmlns="http://xmlns.jcp.org/xml/ns/persistence"
             xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
             xsi:schemaLocation="http://xmlns.jcp.org/xml/ns/persistence
             http://xmlns.jcp.org/xml/ns/persistence/persistence_2_2.xsd"
             version="2.2">

Selain itu, urutan elemen juga penting. Oleh karena itu, providerharus ditentukan sebelum membuat daftar kelas. Setelah itu, pengujian akan berhasil dijalankan. Kami telah menyelesaikan koneksi JPA langsung. Sebelum kita melanjutkan, mari kita pikirkan tes yang tersisa. Setiap pengujian kami memerlukan EntityManager. Mari kita pastikan bahwa setiap pengujian memiliki pengujiannya sendiri EntityManagerdi awal eksekusi. Selain itu, kami ingin database selalu baru. Karena kita menggunakan inmemoryopsi, cukup close EntityManagerFactory. Penciptaan Factoryadalah operasi yang mahal. Tapi untuk tes itu dibenarkan. JUnit memungkinkan Anda menentukan metode yang akan dieksekusi sebelum (Sebelum) dan setelah (Setelah) pelaksanaan setiap pengujian:

public class AppTest {
    private EntityManager em;

    @Before
    public void init() {
        EntityManagerFactory emf = Persistence.createEntityManagerFactory( "JavaRush" );
        em = emf.createEntityManager();
    }

    @After
    public void close() {
        em.getEntityManagerFactory().close();
        em.close();
    }

Sekarang, sebelum menjalankan pengujian apa pun, pengujian baru akan dibuat EntityManagerFactory, yang memerlukan pembuatan database baru, karena hibernate.hbm2ddl.automemiliki arti create. Dan dari pabrik baru kita akan mendapat yang baru EntityManager.

Entitas

Seingat kami, sebelumnya kami membuat kelas yang mendeskripsikan model domain kami. Kami telah mengatakan bahwa ini adalah “esensi” kami. Ini adalah Entitas yang akan kami kelola menggunakan EntityManager. Mari kita menulis tes sederhana untuk menyimpan inti dari suatu kategori:

@Test
public void shouldPersistCategory() {
	Category cat = new Category();
	cat.setTitle("new category");
	// JUnit обеспечит тест свежим EntityManager'ом
	em.persist(cat);
}

Namun tes ini tidak akan langsung berhasil, karena... kita akan menerima berbagai kesalahan yang akan membantu kita memahami apa itu entitas:

• Unknown entity: hibernate.model.Category
  Mengapa Hibernate tidak mengerti apa Categoryini entity? Masalahnya adalah entitas harus dijelaskan sesuai dengan standar JPA.
  Kelas entitas harus dianotasi dengan anotasi @Entity, sebagaimana dinyatakan dalam bab "2.1 Kelas Entitas" pada spesifikasi JPA.

• No identifier specified for entity: hibernate.model.Category
  Entitas harus memiliki pengenal unik yang dapat digunakan untuk membedakan satu record dengan record lainnya.
  Menurut bab "2.4 Kunci Utama dan Identitas Entitas" dari spesifikasi JPA, "Setiap entitas harus memiliki kunci utama", yaitu. Setiap entitas harus memiliki "kunci utama". Kunci utama tersebut harus ditentukan oleh anotasi@Id

• ids for this class must be manually assigned before calling save()
  ID-nya harus berasal dari suatu tempat. Itu dapat ditentukan secara manual, atau dapat diperoleh secara otomatis.
  Oleh karena itu, seperti yang ditunjukkan dalam bab "11.2.3.3 GeneratedValue" dan "11.1.20 GeneratedValue Annotation", kita dapat menentukan anotasinya @GeneratedValue.

Jadi agar kelas kategori menjadi suatu entitas kita harus melakukan perubahan berikut:

@Entity
public class Category {
    @Id
    @GeneratedValue
    private Long id;

Selain itu, anotasi @Idmenunjukkan mana yang akan digunakan Access Type. Anda dapat membaca lebih lanjut tentang tipe akses di spesifikasi JPA, di bagian "2.3 Tipe Akses". Singkatnya, karena... kita tentukan @Iddi atas bidang ( field), maka jenis aksesnya akan menjadi default field-based, bukan property-based. Oleh karena itu, penyedia JPA akan membaca dan menyimpan nilai langsung dari kolom. Jika kita menempatkannya @Iddi atas pengambil, maka property-basedakses akan digunakan, mis. melalui pengambil dan penyetel. Saat menjalankan pengujian, kami juga melihat permintaan apa yang dikirim ke database (berkat opsi hibernate.show_sql). Namun saat menyimpan, kami tidak melihat satu pun insert. Ternyata sebenarnya kita tidak menyimpan apa pun? JPA memungkinkan Anda untuk menyinkronkan konteks persistensi dan database menggunakan metode flush:

entityManager.flush();

Namun jika kita mengeksekusinya sekarang, kita akan mendapatkan error: tidak ada transaksi yang sedang berlangsung . Dan sekarang saatnya mempelajari bagaimana JPA menggunakan transaksi.

Transaksi JPA

Seperti yang kita ingat, JPA didasarkan pada konsep konteks persistensi. Ini adalah tempat dimana entitas tinggal. Dan kami mengelola entitas melalui EntityManager. Saat kami menjalankan perintah persist, kami menempatkan entitas dalam konteksnya. Lebih tepatnya, kami memberi tahu EntityManagerAnda bahwa hal ini perlu dilakukan. Namun konteks ini hanyalah semacam tempat penyimpanan. Bahkan kadang-kadang disebut "cache tingkat pertama". Tapi itu perlu terhubung ke database. Perintah flush, yang sebelumnya gagal karena kesalahan, menyinkronkan data dari konteks persistensi dengan database. Tapi ini memerlukan transportasi dan transportasi ini adalah sebuah transaksi. Transaksi di JPA dijelaskan di bagian "7.5 Transaksi Pengendalian" pada spesifikasi. Ada API khusus untuk menggunakan transaksi di JPA:

entityManager.getTransaction().begin();
entityManager.getTransaction().commit();

Kita perlu menambahkan manajemen transaksi ke kode kita, yang dijalankan sebelum dan sesudah pengujian:

@Before
public void init() {
	EntityManagerFactory emf = Persistence.createEntityManagerFactory( "JavaRush" );
	em = emf.createEntityManager();
	em.getTransaction().begin();
}
@After
public void close() {
	if (em.getTransaction().isActive()) {
		em.getTransaction().commit();
        }
	em.getEntityManagerFactory().close();
	em.close();
}

Setelah menambahkan, kita akan melihat di log penyisipan ekspresi dalam SQL yang sebelumnya tidak ada: Perubahan yang terakumulasi dalam EntityManagertransaksi dilakukan (dikonfirmasi dan disimpan) dalam database. Sekarang mari kita coba menemukan esensi kita. Mari buat pengujian untuk mencari entitas berdasarkan ID-nya:

@Test
public void shouldFindCategory() {
	Category cat = new Category();
	cat.setTitle("test");
	em.persist(cat);
	Category result = em.find(Category.class, 1L);
	assertNotNull(result);
}

Dalam hal ini, kami akan menerima entitas yang kami simpan sebelumnya, tetapi kami tidak akan melihat kueri SELECT di log. Dan semuanya didasarkan pada apa yang kami katakan: “Manajer Entitas, tolong temukan saya entitas Kategori dengan ID=1.” Dan manajer entitas pertama-tama melihat konteksnya (menggunakan semacam cache), dan hanya jika tidak menemukannya, ia akan mencari di database. Sebaiknya ubah ID menjadi 2 (tidak ada hal seperti itu, kami hanya menyimpan 1 instance), dan kami akan melihat SELECTpermintaan tersebut muncul. Karena tidak ada entitas yang ditemukan dalam konteks dan EntityManagerdatabase mencoba mencari entitas, ada beberapa perintah berbeda yang dapat kita gunakan untuk mengontrol status entitas dalam konteks. Peralihan suatu entitas dari satu keadaan ke keadaan lain disebut siklus hidup suatu entitas - lifecycle.

Siklus Hidup Entitas

Siklus hidup entitas dijelaskan dalam spesifikasi JPA di bab "3.2 Siklus Hidup Instans Entitas". Karena entitas hidup dalam konteks dan dikendalikan oleh EntityManager, maka mereka mengatakan bahwa entitas dikendalikan, yaitu. dikelola. Mari kita lihat tahapan kehidupan suatu entitas:

// 1. New or Transient (временный)
Category cat = new Category();
cat.setTitle("new category");
// 2. Managed or Persistent
entityManager.persist(cat);
// 3. Транзакция завершена, все сущности в контексте detached
entityManager.getTransaction().begin();
entityManager.getTransaction().commit();
// 4. Сущность изымаем из контекста, она становится detached
entityManager.detach(cat);
// 5. Сущность из detached можно снова сделать managed
Category managed = entityManager.merge(cat);
// 6. И можно сделать Removed. Интересно, что cat всё равно detached
entityManager.remove(managed);

Dan berikut diagram untuk mengkonsolidasikannya:

Pemetaan

Di JPA kita bisa menggambarkan hubungan entitas antara satu sama lain. Ingatlah bahwa kita telah melihat hubungan entitas antara satu sama lain ketika kita menangani model domain kita. Kemudian kami menggunakan sumber quickdatabasediagrams.com : Membangun hubungan antar entitas disebut pemetaan atau asosiasi (Association Mappings). Jenis-jenis perkumpulan yang dapat didirikan dengan menggunakan JPA disajikan di bawah ini: Mari kita lihat entitas Topicyang mendeskripsikan suatu topik. Apa yang bisa kita katakan tentang sikap Topicterhadap Category? Banyak Topicyang akan termasuk dalam satu kategori. Oleh karena itu, kita memerlukan perkumpulan ManyToOne. Mari kita ekspresikan hubungan ini di JPA:

@ManyToOne
@JoinColumn(name = "category_id")
private Category category;

Untuk mengingat anotasi mana yang harus dimasukkan, Anda dapat mengingat bahwa bagian terakhir bertanggung jawab atas bidang di mana anotasi tersebut ditunjukkan. ToOne- contoh spesifik. ToMany- koleksi. Sekarang hubungan kami bersifat satu arah. Mari kita jadikan komunikasi dua arah. Mari menambah Categorypengetahuan tentang semua orang Topicyang termasuk dalam kategori ini. Harus diakhiri dengan ToMany, karena kita punya daftarnya Topic. Artinya, sikap “Kepada banyak” topik. Pertanyaannya tetap - OneToManyatau ManyToMany: Jawaban yang bagus untuk topik yang sama dapat dibaca di sini: " Jelaskan hubungan ORM oneToMany, manyToMany seperti saya berlima ". Jika suatu kategori mempunyai hubungan dengan ToManytopik, maka masing-masing topik tersebut hanya boleh mempunyai satu kategori, maka akan menjadi One, sebaliknya Many. Jadi Categorydaftar semua topik akan terlihat seperti ini:

@OneToMany(cascade = CascadeType.ALL)
@JoinColumn(name = "topic_id")
private Set<Topic> topics = new HashSet<>();

Dan jangan lupa untuk Categorymenulis pengambil untuk mendapatkan daftar semua topik:

public Set<Topic> getTopics() {
	return this.topics;
}

Hubungan dua arah adalah hal yang sangat sulit dilacak secara otomatis. Oleh karena itu, JPA mengalihkan tanggung jawab ini kepada pengembang. Artinya bagi kami adalah ketika kami membangun Topichubungan entitas dengan Category, kami sendiri harus memastikan konsistensi data. Ini dilakukan secara sederhana:

public void setCategory(Category category) {
	category.getTopics().add(this);
	this.category = category;
}

Mari kita tulis tes sederhana untuk memeriksanya:

@Test
public void shouldPersistCategoryAndTopics() {
	Category cat = new Category();
	cat.setTitle("test");
	Topic topic = new Topic();
	topic.setTitle("topic");
	topic.setCategory(cat);
 	em.persist(cat);
}

Pemetaan adalah topik yang terpisah. Tujuan dari tinjauan ini adalah untuk memahami cara-cara yang digunakan untuk mencapai hal ini. Anda dapat membaca lebih lanjut tentang pemetaan di sini:

• " Panduan Utama – Pemetaan Asosiasi dengan JPA dan Hibernate ".
• " JPA dan hubungan antar objek "
• " Entitas Terkait di Hibernate "

JPQL

JPA memperkenalkan alat yang menarik - kueri dalam Java Persistence Query Language. Bahasa ini mirip dengan SQL, tetapi menggunakan model objek Java, bukan tabel SQL. Mari kita lihat sebuah contoh:

@Test
public void shouldPerformQuery() {
	Category cat = new Category();
	cat.setTitle("query");
	em.persist(cat);
	Query query = em.createQuery("SELECT c from Category c WHERE c.title = 'query'");
 	assertNotNull(query.getSingleResult());
}

Seperti yang bisa kita lihat, dalam kueri kita menggunakan referensi ke suatu entitas Categorydan bukan tabel. Dan juga di bidang entitas ini title. JPQL menyediakan banyak fitur berguna dan layak mendapat artikel tersendiri. Lebih jelasnya dapat ditemukan di ulasan:

• " Panduan Utama untuk Kueri JPQL dengan JPA dan Hibernate "

API Kriteria

Dan terakhir, saya ingin menyentuh API Kriteria. JPA memperkenalkan alat pembuatan kueri dinamis. Contoh penggunaan API Kriteria:

@Test
public void shouldFindWithCriteriaAPI() {
	Category cat = new Category();
	em.persist(cat);
	CriteriaBuilder cb = em.getCriteriaBuilder();
	CriteriaQuery<Category> query = cb.createQuery(Category.class);
	Root<Category> c = query.from(Category.class);
	query.select(c);
	List<Category> resultList = em.createQuery(query).getResultList();
	assertEquals(1, resultList.size());
}

Contoh ini setara dengan mengeksekusi permintaan " SELECT c FROM Category c". API Kriteria adalah alat yang ampuh. Anda dapat membaca lebih lanjut tentangnya di sini:

• Kueri API Kriteria JPA
• Kriteria JPA
• Kueri Tipe Aman Dinamis di JPA 2.0

Kesimpulan

Seperti yang bisa kita lihat, JPA menyediakan banyak sekali fitur dan alat. Masing-masing membutuhkan pengalaman dan pengetahuan. Bahkan dalam kerangka tinjauan JPA, tidak mungkin untuk menyebutkan semuanya, apalagi penjelasan rinci. Namun saya berharap setelah membacanya menjadi jelas apa itu ORM dan JPA, cara kerjanya dan apa yang bisa dilakukan dengannya. Nah, untuk snack saya menawarkan berbagai bahan:

• JPA - Pendahuluan
• Pemikiran Tentang Java - Hibernasi Pemula
• Pemikiran Tentang Java - Tips Hibernasi
• Topik JPA Tingkat Lanjut

#Viacheslav