Apa itu Teknologi JPA Java?

JPA (Anotasi Kegigihan Java ) adalah solusi standar Java untuk menjembatani kesenjangan antara model domain berorientasi objek dan sistem database relasional. Idenya adalah untuk memetakan kelas Java ke tabel relasional dan properti kelas tersebut ke baris dalam tabel. Ini mengubah semantik pengalaman keseluruhan pengkodean Java dengan mengolaborasikan dua teknologi berbeda secara mulus dalam paradigma pemrograman yang sama. Artikel ini memberikan gambaran umum dan implementasi pendukungnya di Java.

Ikhtisar

Basis data relasional mungkin yang paling stabil dari semua teknologi persistensi yang tersedia dalam komputasi daripada semua kerumitan yang terlibat dengannya. Itu karena hari ini, bahkan di zaman yang disebut "data besar", database relasional "NoSQL" terus diminati dan berkembang pesat. Basis data relasional adalah teknologi yang stabil bukan hanya dengan kata-kata tetapi dengan keberadaannya selama bertahun-tahun. NoSQL mungkin bagus untuk menangani sejumlah besar data terstruktur di perusahaan, tetapi banyak beban kerja transaksional lebih baik ditangani melalui database relasional. Selain itu, ada beberapa alat analisis hebat yang terkait dengan database relasional.

Untuk berkomunikasi dengan database relasional, ANSI telah menstandarisasi bahasa yang disebut SQL (Bahasa Kueri Terstruktur ). Pernyataan yang ditulis dalam bahasa ini dapat digunakan untuk mendefinisikan dan memanipulasi data. Namun, masalah SQL dalam menangani Java adalah bahwa mereka memiliki struktur sintaksis yang tidak cocok dan sangat berbeda pada intinya, artinya SQL bersifat prosedural sedangkan Java berorientasi objek. Jadi, dicari solusi kerja agar Java dapat berbicara dengan cara berorientasi objek dan basis data relasional masih dapat saling memahami. JPA adalah jawaban untuk panggilan itu dan menyediakan mekanisme untuk membangun solusi kerja di antara keduanya.

Relasional dengan Pemetaan Objek

Program Java berinteraksi dengan database relasional dengan menggunakan JDBC (Konektivitas Basis Data Java ) API. Driver JDBC adalah kunci untuk konektivitas dan memungkinkan program Java untuk memanipulasi database tersebut dengan menggunakan JDBC API. Setelah koneksi dibuat, program Java menjalankan kueri SQL dalam bentuk String s untuk berkomunikasi membuat, menyisipkan, memperbarui, dan menghapus operasi. Ini cukup untuk semua tujuan praktis, tetapi tidak nyaman dari sudut pandang programmer Java. Bagaimana jika struktur tabel relasional dapat diubah menjadi kelas Java murni dan kemudian Anda dapat menanganinya dengan cara berorientasi objek yang biasa? Struktur tabel relasional adalah representasi logis dari data dalam bentuk tabel. Tabel terdiri dari kolom yang menggambarkan atribut entitas dan baris adalah kumpulan entitas. Misalnya, tabel EMPLOYEE mungkin berisi entitas berikut dengan atributnya.

Baris unik dengan kunci utama (emp_number) dalam tabel; ini memungkinkan pencarian cepat. Sebuah tabel mungkin terkait dengan satu atau lebih tabel dengan beberapa kunci, seperti kunci asing (dept_no), yang terkait dengan baris yang setara di tabel lain.

Menurut spesifikasi Java Persistence 2.1, JPA menambahkan dukungan untuk pembuatan skema, metode konversi tipe, penggunaan grafik entitas dalam operasi kueri dan pencarian, konteks ketekunan yang tidak sinkron, permintaan prosedur tersimpan, dan injeksi ke kelas pendengar entitas. Ini juga mencakup penyempurnaan bahasa kueri Java Persistence, API Kriteria, dan pemetaan kueri asli.

Singkatnya, ia melakukan segalanya untuk memberikan ilusi bahwa tidak ada bagian prosedural dalam menangani database relasional dan semuanya berorientasi objek.

Implementasi JPA

JPA menjelaskan manajemen data relasional dalam aplikasi Java. Ini adalah spesifikasi dan ada sejumlah implementasinya. Beberapa implementasi populer adalah Hibernate, EclipseLink, dan Apache OpenJPA. JPA mendefinisikan metadata melalui anotasi di kelas Java atau melalui file konfigurasi XML. Namun, kita dapat menggunakan XML dan anotasi untuk mendeskripsikan metadata. Dalam kasus seperti itu, konfigurasi XML menimpa anotasi. Ini masuk akal karena anotasi ditulis dengan kode Java, sedangkan file konfigurasi XML berada di luar kode Java. Oleh karena itu, nanti, jika ada, perlu dilakukan perubahan pada metadata; dalam hal konfigurasi berbasis anotasi, memerlukan akses kode Java langsung. Ini mungkin selalu tidak mungkin. Dalam kasus seperti itu, kita dapat menulis konfigurasi metadata baru atau yang diubah dalam file XML tanpa sedikit pun perubahan dalam kode asli dan masih memiliki efek yang diinginkan. Ini adalah keuntungan menggunakan konfigurasi XML. Namun, konfigurasi berbasis anotasi lebih nyaman digunakan dan merupakan pilihan populer di kalangan programmer.

• Hibernasi adalah yang populer dan paling canggih di antara semua implementasi JPA karena Red Hat. Ini menggunakan tweak sendiri dan fitur tambahan yang dapat digunakan selain implementasi JPA-nya. Ini memiliki komunitas pengguna yang lebih besar dan didokumentasikan dengan baik. Beberapa fitur kepemilikan tambahan adalah dukungan untuk multi-tenancy, menggabungkan entitas yang tidak terkait dalam kueri, manajemen stempel waktu, dan sebagainya.
• EclipseLink didasarkan pada TopLink dan merupakan implementasi referensi dari versi JPA. Ini menyediakan fungsionalitas JPA standar selain dari beberapa fitur eksklusif yang menarik, seperti dukungan dari multi-tenancy, penanganan peristiwa perubahan basis data, dan sebagainya.

Menggunakan JPA dalam Program Java SE

Untuk menggunakan JPA dalam program Java, Anda memerlukan penyedia JPA seperti Hibernate atau EclipseLink, atau perpustakaan lainnya. Juga, Anda memerlukan driver JDBC yang terhubung ke database relasional tertentu. Misalnya, dalam kode berikut, kami telah menggunakan pustaka berikut:

• Penyedia: EclipseLink
• Pengemudi JDBC: Driver JDBC untuk MySQL (Konektor/J)

Kami akan membuat hubungan antara dua tabel—Karyawan dan Departemen—sebagai satu-ke-satu dan satu-ke-banyak, seperti yang digambarkan dalam diagram EER berikut (lihat Gambar 1).

Gambar 1: Hubungan tabel

karyawan tabel dipetakan ke kelas entitas menggunakan anotasi sebagai berikut:

package org.mano.jpademoapp;

import javax.persistence.*;

@Entity
@Table(name = "employee")
public class Employee {
   @Id
   private int id;
   private String name;
   private String phone;
   private String email;
   @OneToOne
   private Department department;
   public Employee() {
      super();
   }

   public Employee(int id, String name, String phone,
         String email) {
      super();
      this.id = id;
      this.name = name;
      this.phone = phone;
      this.email = email;
   }

   public int getId() {
      return id;
   }

   public void setId(int id) {
      this.id = id;
   }

   public String getName() {
      return name;
   }

   public void setName(String name) {
      this.name = name;
   }

   public String getPhone() {
      return phone;
   }

   public void setPhone(String phone) {
      this.phone = phone;
   }

   public String getEmail() {
      return email;
   }

   public void setEmail(String email) {
      this.email = email;
   }

   public Department getDepartment() {
      return department;
   }

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

Dan, departemen tabel dipetakan ke kelas entitas sebagai berikut:

package org.mano.jpademoapp;

import java.util.*;
import javax.persistence.*;

@Entity
@Table(name = "department")
public class Department {

   @Id
   private int id;
   private String location;
   @OneToMany
   private List<Employee> employees = new ArrayList<>();

   public Department() {
      super();
   }

   public Department(int id, String location) {
      super();
      this.id = id;
      this.location = location;
   }

   public int getId() {
      return id;
   }

   public void setId(int id) {
      this.id = id;
   }

   public String getLocation() {
      return location;
   }

   public void setLocation(String location) {
      this.location = location;
   }

   public List<Employee> getEmployees() {
      return employees;
   }

   public void setEmployees(List<Employee> employees) {
      this.employees = employees;
   }
}

File konfigurasi, persistence.xml , dibuat di META-INF direktori. File ini berisi konfigurasi koneksi, seperti driver JDBC yang digunakan, nama pengguna dan kata sandi untuk akses database, dan informasi relevan lainnya yang diperlukan oleh penyedia JPA untuk membuat koneksi database.

<?xml version="1.0" encoding="UTF-8"?>
<persistence version="2.1"
   
   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_1.xsd">
   <persistence-unit name="JPADemoProject"
      transaction-type="RESOURCE_LOCAL">
      <class>org.mano.jpademoapp.Employee</class>
      <class>org.mano.jpademoapp.Department</class>
      <properties>
         <property name="javax.persistence.jdbc.driver"
            value="com.mysql.jdbc.Driver" />
         <property name="javax.persistence.jdbc.url"
            value="jdbc:mysql://localhost:3306/testdb" />
         <property name="javax.persistence.jdbc.user"
            value="root" />
         <property name="javax.persistence.jdbc.password"
            value="secret" />
         <property name="javax.persistence.schema-generation
            .database.action"
            value="drop-and-create"/>
         <property name="javax.persistence.schema-generation
            .scripts.action"
            value="drop-and-create"/>
         <property name="eclipselink.ddl-generation"
            value="drop-and-create-tables"/>
      </properties>
   </persistence-unit>
</persistence>

Entitas tidak bertahan sendiri. Logika harus diterapkan untuk memanipulasi entitas untuk mengelola siklus hidup persistennya. Manajer Entitas antarmuka yang disediakan oleh JPA memungkinkan aplikasi mengelola dan mencari entitas dalam database relasional. Kami membuat objek kueri dengan bantuan EntityManager untuk berkomunikasi dengan database. Untuk mendapatkan EntityManager untuk database tertentu, kami akan menggunakan objek yang mengimplementasikan EntityManagerFactory antarmuka. Ada statis metode, yang disebut createEntityManagerFactory , di Kegigihan kelas yang mengembalikan EntityManagerFactory untuk unit persistensi yang ditentukan sebagai String argumen. Dalam implementasi dasar berikut, kami telah menerapkan logika.

package org.mano.jpademoapp;

import javax.persistence.EntityManager;
import javax.persistence.EntityManagerFactory;
import javax.persistence.Persistence;

public enum PersistenceManager {
   INSTANCE;
   private EntityManagerFactory emf;

   private PersistenceManager() {
      emf=Persistence.createEntityManagerFactory("JPADemoProject");
   }

   public EntityManager getEntityManager() {
      return emf.createEntityManager();
   }

   public void close() {
      emf.close();
   }
}

Sekarang, kita siap untuk pergi dan membuat antarmuka utama aplikasi. Di sini, kami hanya mengimplementasikan operasi penyisipan demi kesederhanaan dan batasan ruang.

package org.mano.jpademoapp;

import javax.persistence.EntityManager;

public class Main {

   public static void main(String[] args) {

      Department d1=new Department(11, "NY");
      Department d2=new Department(22, "LA");

      Employee e1=new Employee(111, "Peter",
         "9876543210", "[email protected]");
      Employee e2=new Employee(222, "Ronin",
         "993875630", "[email protected]");
      Employee e3=new Employee(333, "Kalpana",
         "9876927410", "[email protected]");
      Employee e4=new Employee(444, "Marc",
         "989374510", "[email protected]");
      Employee e5=new Employee(555, "Anik",
         "987738750", "[email protected]");
      d1.getEmployees().add(e1);
      d1.getEmployees().add(e3);
      d1.getEmployees().add(e4);
      d2.getEmployees().add(e2);
      d2.getEmployees().add(e5);

      EntityManager em=PersistenceManager
         .INSTANCE.getEntityManager();
      em.getTransaction().begin();
      em.persist(e1);
      em.persist(e2);
      em.persist(e3);
      em.persist(e4);
      em.persist(e5);
      em.persist(d1);
      em.persist(d2);
      em.getTransaction().commit();
      em.close();
      PersistenceManager.INSTANCE.close();
   }
}

Kesimpulan

Seperti yang sudah jelas, terminologi inti dari JPA dan konteks Persistence lebih luas daripada sekilas yang diberikan di sini, tetapi memulai dengan tinjauan singkat lebih baik daripada kode kotor panjang yang rumit dan detail konseptualnya. Jika Anda memiliki sedikit pengalaman pemrograman di inti JDBC, Anda pasti akan menghargai bagaimana JPA dapat membuat hidup Anda lebih sederhana. Kami akan mempelajari JPA lebih dalam secara bertahap saat kami melanjutkan di artikel yang akan datang.