JavaRush /Blog Java /Random-MS /JPA: Memperkenalkan Teknologi

Tahap

28 February 2021
50 views
0 comments

JPA: Memperkenalkan Teknologi

Dunia pembangunan moden penuh dengan pelbagai spesifikasi yang direka untuk memudahkan kehidupan. Mengetahui alat, anda boleh memilih yang betul. Tanpa sedar, anda boleh membuat hidup anda lebih sukar. Kajian semula ini akan membuka tabir kerahsiaan mengenai konsep JPA - Java Persistence API. Saya berharap bahawa selepas membaca anda akan mahu menyelam lebih dalam ke dunia misteri ini.

pengenalan

Seperti yang kita ketahui, salah satu tugas utama program ialah menyimpan dan memproses data. Pada zaman dahulu, orang hanya menyimpan data dalam fail. Tetapi sebaik sahaja akses baca dan edit serentak diperlukan, apabila terdapat beban (iaitu, beberapa permintaan tiba pada masa yang sama), menyimpan data hanya dalam fail menjadi masalah. Untuk mendapatkan maklumat lanjut tentang masalah yang diselesaikan oleh pangkalan data dan bagaimana, saya menasihati anda untuk membaca artikel " Bagaimana pangkalan data distrukturkan ." Ini bermakna kami memutuskan untuk menyimpan data kami dalam pangkalan data. Untuk masa yang lama, Java telah dapat bekerja dengan pangkalan data menggunakan API JDBC (The Java Database Connectivity). Anda boleh membaca lebih lanjut tentang JDBC di sini: “ JDBC atau tempat semuanya bermula .” Tetapi masa berlalu dan pembangun setiap kali menghadapi keperluan untuk menulis jenis yang sama dan kod "penyelenggaraan" yang tidak perlu (yang dipanggil kod Boilerplate) untuk operasi remeh menyimpan objek Java dalam pangkalan data dan sebaliknya, mencipta objek Java menggunakan data daripada pangkalan data. Dan kemudian, untuk menyelesaikan masalah ini, konsep seperti ORM dilahirkan. ORM - Pemetaan Hubungan Objek atau diterjemahkan ke dalam pemetaan hubungan objek Rusia. Ia adalah teknologi pengaturcaraan yang menghubungkan pangkalan data dengan konsep bahasa pengaturcaraan berorientasikan objek. Untuk memudahkan, ORM ialah sambungan antara objek Java dan rekod dalam pangkalan data: JPA: Pengenalan kepada Teknologi - 2

ORM pada asasnya ialah konsep bahawa objek Java boleh diwakili sebagai data dalam pangkalan data (dan sebaliknya). Ia diwujudkan dalam bentuk spesifikasi JPA - Java Persistence API. Spesifikasinya sudah pun merupakan perihalan API Java yang menyatakan konsep ini. Spesifikasi memberitahu kami alat yang mesti kami sediakan (iaitu, antara muka yang boleh kami kerjakan) untuk berfungsi mengikut konsep ORM. Dan bagaimana untuk menggunakan dana ini. Spesifikasi tidak menerangkan pelaksanaan alatan. Ini memungkinkan untuk menggunakan pelaksanaan yang berbeza untuk satu spesifikasi. Anda boleh memudahkannya dan mengatakan bahawa spesifikasi ialah perihalan API. Teks spesifikasi JPA boleh didapati di laman web Oracle: " JSR 338: JavaTM Persistence API ". Oleh itu, untuk menggunakan JPA, kita memerlukan beberapa pelaksanaan yang mana kita akan menggunakan teknologi tersebut. Pelaksanaan JPA juga dipanggil Penyedia JPA. Salah satu pelaksanaan JPA yang paling ketara ialah Hibernate . Oleh itu, saya mencadangkan untuk mempertimbangkannya.

Mencipta Projek

Oleh kerana JPA adalah mengenai Java, kami memerlukan projek Java. Kami boleh membuat sendiri struktur direktori secara manual dan menambah sendiri perpustakaan yang diperlukan. Tetapi adalah lebih mudah dan betul untuk menggunakan sistem untuk mengautomasikan pemasangan projek (iaitu, pada dasarnya, ini hanyalah program yang akan menguruskan pemasangan projek untuk kami. Cipta direktori, tambahkan perpustakaan yang diperlukan pada laluan kelas, dsb. .). Satu sistem sedemikian ialah Gradle. Anda boleh membaca lebih lanjut mengenai Gradle di sini: " Pengenalan Ringkas kepada Gradle ". Seperti yang kita ketahui, kefungsian Gradle (iaitu perkara yang boleh dilakukannya) dilaksanakan menggunakan pelbagai Pemalam Gradle. Mari gunakan Gradle dan pemalam " Gradle Build Init Plugin ". Mari jalankan arahan:


gradle init --type java-application

Gradle akan melakukan struktur direktori yang diperlukan untuk kami dan mencipta penerangan perisytiharan asas projek dalam skrip binaan build.gradle. Jadi, kami ada permohonan. Kita perlu memikirkan perkara yang ingin kita huraikan atau modelkan dengan aplikasi kita. Mari kita gunakan beberapa alat pemodelan, contohnya: app.quickdatabasediagrams.com JPA: Pengenalan kepada Teknologi - 4

Di sini patut dikatakan bahawa apa yang telah kami huraikan ialah "model domain" kami. Domain ialah "kawasan subjek". Secara umum, domain ialah "pemilikan" dalam bahasa Latin. Pada Zaman Pertengahan, ini adalah nama yang diberikan kepada kawasan yang dimiliki oleh raja atau tuan feudal. Dan dalam bahasa Perancis ia menjadi perkataan "domaine", yang hanya diterjemahkan sebagai "kawasan". Oleh itu, kami menerangkan "model domain" = "model subjek" kami. Setiap elemen model ini adalah sejenis "intipati", sesuatu dari kehidupan sebenar. Dalam kes kami, ini ialah entiti: Kategori ( Category), Subjek ( Topic). Mari buat pakej berasingan untuk entiti, contohnya dengan model nama. Dan mari tambah kelas Java di sana yang menerangkan entiti. Dalam kod Java, entiti tersebut ialah POJO biasa , yang mungkin kelihatan 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 kandungan kelas dan buat kelas dengan analogi Topic. Dia akan berbeza hanya dalam apa yang dia tahu tentang kategori yang dia tergolong. Oleh itu, mari tambah Topicmedan kategori dan kaedah untuk bekerja dengannya pada kelas:

private Category category;

public Category getCategory() {
	return category;
}

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

Kini kami mempunyai aplikasi Java yang mempunyai model domainnya sendiri. Kini tiba masanya untuk mula menyambung ke projek JPA.

Menambah JPA

Jadi, seperti yang kita ingat, JPA bermakna kita akan menyimpan sesuatu dalam pangkalan data. Oleh itu, kita memerlukan pangkalan data. Untuk menggunakan sambungan pangkalan data dalam projek kami, kami perlu menambah perpustakaan pergantungan untuk menyambung ke pangkalan data. Seperti yang kami ingat, kami menggunakan Gradle, yang mencipta skrip binaan untuk kami build.gradle. Di dalamnya kami akan menerangkan kebergantungan yang diperlukan oleh projek kami. Ketergantungan ialah perpustakaan yang tanpa kod kami tidak dapat berfungsi. Mari kita mulakan dengan penerangan tentang kebergantungan pada penyambungan ke pangkalan data. Kami melakukan ini dengan cara yang sama kami akan melakukannya jika kami hanya bekerja dengan JDBC:


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

Sekarang kita mempunyai pangkalan data. Kami kini boleh menambah lapisan pada aplikasi kami yang bertanggungjawab untuk memetakan objek Java kami ke dalam konsep pangkalan data (dari Java ke SQL). Seperti yang kita ingat, kita akan menggunakan pelaksanaan spesifikasi JPA yang dipanggil 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 bahagian "Unit Kegigihan 8.1", kita akan mengetahui bahawa Unit Kegigihan ialah sejenis gabungan konfigurasi, metadata dan entiti. Dan untuk JPA berfungsi, anda perlu menerangkan sekurang-kurangnya satu Unit Kegigihan dalam fail konfigurasi, yang dipanggil persistence.xml. Lokasinya diterangkan dalam bab spesifikasi "8.2 Pembungkusan Unit Kegigihan". Menurut bahagian ini, jika kita mempunyai persekitaran Java SE, maka kita mesti meletakkannya dalam akar direktori META-INF.

Mari salin kandungan daripada contoh yang diberikan dalam spesifikasi JPA dalam 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>

Tetapi ini tidak mencukupi. Kita perlu memberitahu siapa Pembekal JPA kita, i.e. seseorang yang melaksanakan spesifikasi JPA:

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

Sekarang mari tambah tetapan ( properties). Sebahagian daripadanya (bermula dengan javax.persistence) ialah konfigurasi JPA standard dan diterangkan dalam spesifikasi JPA dalam bahagian "sifat 8.2.1.9". Sesetengah konfigurasi adalah khusus pembekal (dalam kes kami, ia menjejaskan Hibernate sebagai Penyedia Jpa. Blok tetapan kami akan kelihatan 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>

Kini kami mempunyai konfigurasi serasi JPA persistence.xml, terdapat penyedia JPA Hibernate dan terdapat pangkalan data H2, dan terdapat juga 2 kelas yang merupakan model domain kami. Mari kita akhirnya membuat ini semua berfungsi. Dalam katalog /test/java, Gradle kami dengan hormatnya menjana templat untuk ujian Unit dan memanggilnya AppTest. Jom guna. Seperti yang dinyatakan dalam bab "7.1 Konteks Kegigihan" spesifikasi JPA, entiti dalam dunia JPA tinggal dalam ruang yang dipanggil Konteks Kegigihan. Tetapi kami tidak bekerja secara langsung dengan Konteks Kegigihan. Untuk ini kami menggunakan Entity Manageratau "pengurus entiti". Dialah yang tahu tentang konteks dan entiti yang tinggal di sana. Kami berinteraksi dengan Entity Manager'om. Kemudian yang tinggal hanyalah untuk memahami di mana kita boleh mendapatkan yang ini Entity Manager? Menurut bab "7.2.2 Mendapatkan Pengurus Entiti yang diuruskan oleh Aplikasi" spesifikasi JPA, kita mesti menggunakan EntityManagerFactory. Oleh itu, mari memperlengkapi diri dengan spesifikasi JPA dan ambil contoh daripada bab "7.3.2 Mendapatkan Kilang Pengurus Entiti dalam Persekitaran Java SE" dan formatkannya dalam bentuk ujian Unit mudah:

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

Ujian ini sudah pun menunjukkan ralat "Unrecognized JPA persistence.xml versi XSD". Sebabnya ialah persistence.xmlanda perlu menyatakan dengan betul skema untuk digunakan, seperti yang dinyatakan dalam spesifikasi JPA dalam bahagian "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">

Di samping itu, susunan elemen adalah penting. Oleh itu, provideria mesti dinyatakan sebelum menyenaraikan kelas. Selepas ini, ujian akan berjalan dengan jayanya. Kami telah menyelesaikan sambungan JPA terus. Sebelum kita meneruskan, mari kita fikirkan tentang ujian yang tinggal. Setiap ujian kami akan memerlukan EntityManager. Mari pastikan bahawa setiap ujian mempunyai sendiri EntityManagerpada permulaan pelaksanaan. Di samping itu, kami mahu pangkalan data sentiasa baharu. Disebabkan fakta bahawa kami menggunakan inmemorypilihan, ia sudah cukup untuk menutup EntityManagerFactory. Penciptaan Factoryadalah operasi yang mahal. Tetapi untuk ujian ia adalah wajar. JUnit membenarkan anda untuk menentukan kaedah yang akan dilaksanakan sebelum (Sebelum) dan selepas (Selepas) pelaksanaan setiap ujian:

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 melaksanakan sebarang ujian, ujian baharu akan dibuat EntityManagerFactory, yang memerlukan penciptaan pangkalan data baharu, kerana hibernate.hbm2ddl.automempunyai makna create. Dan dari kilang baru kita akan mendapat yang baru EntityManager.

Entiti

Seperti yang kita ingat, sebelum ini kami mencipta kelas yang menerangkan model domain kami. Kami telah mengatakan bahawa ini adalah "intipati" kami. Ini ialah Entiti yang akan kami uruskan menggunakan EntityManager. Mari kita tulis ujian mudah untuk menyimpan intipati kategori:

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

Tetapi ujian ini tidak akan berfungsi serta-merta, kerana... kami akan menerima pelbagai ralat yang akan membantu kami memahami entiti itu:

Unknown entity: hibernate.model.Category
Mengapa Hibernate tidak memahami apa Categoryini entity? Masalahnya ialah entiti mesti diterangkan mengikut piawaian JPA.
Kelas entiti mesti diberi anotasi dengan anotasi @Entity, seperti yang dinyatakan dalam bab "2.1 Kelas Entiti" spesifikasi JPA.
No identifier specified for entity: hibernate.model.Category
Entiti mesti mempunyai pengecam unik yang boleh digunakan untuk membezakan satu rekod daripada rekod yang lain.
Menurut bab "2.4 Kunci Utama dan Identiti Entiti" spesifikasi JPA, "Setiap entiti mesti mempunyai kunci utama", i.e. Setiap entiti mesti mempunyai "kunci utama". Kunci utama sedemikian mesti ditentukan oleh anotasi@Id
ids for this class must be manually assigned before calling save()
ID mesti datang dari suatu tempat. Ia boleh ditentukan secara manual, atau ia boleh diperoleh secara automatik.
Oleh itu, seperti yang dinyatakan dalam bab "11.2.3.3 GeneratedValue" dan "11.1.20 GeneratedValue Annotation", kita boleh menentukan anotasi @GeneratedValue.

Jadi untuk kelas kategori menjadi entiti kita mesti membuat perubahan berikut:

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

Selain itu, anotasi @Idmenunjukkan yang mana satu untuk digunakan Access Type. Anda boleh membaca lebih lanjut mengenai jenis akses dalam spesifikasi JPA, dalam bahagian "2.3 Jenis Akses". Secara ringkasnya, kerana... kami tentukan @Iddi atas medan ( field), maka jenis akses akan menjadi lalai field-based, bukan property-based. Oleh itu, pembekal JPA akan membaca dan menyimpan nilai terus dari medan. Jika kita meletakkan @Iddi atas pengambil, maka property-basedakses akan digunakan, i.e. melalui getter dan setter. Semasa menjalankan ujian, kami juga melihat permintaan yang dihantar ke pangkalan data (terima kasih kepada pilihan hibernate.show_sql). Tetapi apabila menyimpan, kita tidak nampak apa-apa insert. Ternyata kita sebenarnya tidak menyimpan apa-apa? JPA membolehkan anda menyegerakkan konteks kegigihan dan pangkalan data menggunakan kaedah flush:

entityManager.flush();

Tetapi jika kami melaksanakannya sekarang, kami akan mendapat ralat: tiada transaksi sedang dijalankan . Dan kini tiba masanya untuk mengetahui tentang cara JPA menggunakan transaksi.

Urus Niaga JPA

Seperti yang kita ingat, JPA adalah berdasarkan konsep konteks kegigihan. Ini ialah tempat tinggal entiti. Dan kami menguruskan entiti melalui EntityManager. Apabila kami melaksanakan arahan persist, kami meletakkan entiti dalam konteks. Lebih tepat lagi, kami memberitahu EntityManagerbahawa ini perlu dilakukan. Tetapi konteks ini hanyalah beberapa kawasan penyimpanan. Malah kadangkala dipanggil "cache peringkat pertama". Tetapi ia perlu disambungkan ke pangkalan data. Perintah flush, yang sebelum ini gagal dengan ralat, menyegerakkan data daripada konteks kegigihan dengan pangkalan data. Tetapi ini memerlukan pengangkutan dan pengangkutan ini adalah transaksi. Transaksi dalam JPA diterangkan dalam bahagian "7.5 Mengawal Transaksi" dalam spesifikasi. Terdapat API khas untuk menggunakan transaksi dalam JPA:

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

Kami perlu menambahkan pengurusan transaksi pada kod kami, yang dijalankan sebelum dan selepas ujian:

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

Selepas menambah, kita akan melihat dalam log sisipan ungkapan dalam SQL yang tidak ada sebelum ini:

Perubahan yang terkumpul dalam EntityManagertransaksi telah dilakukan (disahkan dan disimpan) dalam pangkalan data. Sekarang mari kita cuba mencari intipati kita. Mari buat ujian untuk mencari entiti mengikut IDnya:

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

Dalam kes ini, kami akan menerima entiti yang kami simpan sebelum ini, tetapi kami tidak akan melihat pertanyaan SELECT dalam log. Dan semuanya adalah berdasarkan apa yang kami katakan: "Pengurus Entiti, sila cari saya entiti Kategori dengan ID=1." Dan pengurus entiti mula-mula melihat dalam konteksnya (menggunakan sejenis cache), dan hanya jika ia tidak menemuinya, ia pergi untuk melihat dalam pangkalan data. Adalah wajar menukar ID kepada 2 (tidak ada perkara seperti itu, kami menyimpan hanya 1 contoh), dan kami akan melihat bahawa SELECTpermintaan itu muncul. Kerana tiada entiti ditemui dalam konteks dan EntityManagerpangkalan data sedang cuba mencari entiti. Terdapat perintah berbeza yang boleh kita gunakan untuk mengawal keadaan entiti dalam konteks. Peralihan entiti dari satu keadaan ke keadaan lain dipanggil kitaran hayat entiti - lifecycle.

Kitaran Hayat Entiti

Kitaran hayat entiti diterangkan dalam spesifikasi JPA dalam bab "3.2 Kitaran Hayat Instance Entiti". Kerana entiti hidup dalam konteks dan dikawal oleh EntityManager, kemudian mereka mengatakan bahawa entiti dikawal, i.e. terurus. Mari kita lihat peringkat kehidupan entiti:

// 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 ialah rajah untuk menyatukannya:

Pemetaan

Dalam JPA kita boleh menerangkan hubungan entiti antara satu sama lain. Mari kita ingat bahawa kita telah melihat hubungan entiti antara satu sama lain apabila kita berurusan dengan model domain kita. Kemudian kami menggunakan sumber quickdatabasediagrams.com :

Mewujudkan hubungan antara entiti dipanggil pemetaan atau persatuan (Pemetaan Persatuan). Jenis persatuan yang boleh ditubuhkan menggunakan JPA dibentangkan di bawah:

Mari lihat entiti Topicyang menerangkan topik. Apa yang boleh kita katakan tentang sikap Topicterhadap Category? Ramai Topicakan tergolong dalam satu kategori. Oleh itu, kita memerlukan persatuan ManyToOne. Mari nyatakan hubungan ini dalam JPA:

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

Untuk mengingati anotasi yang hendak diletakkan, anda boleh ingat bahawa bahagian terakhir bertanggungjawab untuk medan di atas yang ditunjukkan anotasi. ToOne- contoh khusus. ToMany- koleksi. Sekarang sambungan kami adalah sehala. Mari jadikan komunikasi dua hala. Mari tambah Categorypengetahuan tentang semua orang Topicyang termasuk dalam kategori ini. Ia mesti berakhir dengan ToMany, kerana kami mempunyai senarai Topic. Iaitu, sikap "Kepada banyak" topik. Persoalannya kekal - OneToManyatau ManyToMany:

Jawapan yang baik mengenai topik yang sama boleh dibaca di sini: " Jelaskan hubungan ORM oneToMany, manyToMany seperti saya lima orang ". Jika kategori mempunyai kaitan dengan ToManytopik, maka setiap topik ini hanya boleh mempunyai satu kategori, maka ia akan menjadi One, sebaliknya Many. Jadi Categorysenarai semua topik akan kelihatan seperti ini:

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

Dan jangan lupa pada dasarnya Categorymenulis pengambil untuk mendapatkan senarai semua topik:

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

Hubungan dua hala adalah perkara yang sangat sukar untuk dikesan secara automatik. Oleh itu, JPA mengalihkan tanggungjawab ini kepada pemaju. Maksudnya bagi kami ialah apabila kami mewujudkan Topichubungan entiti dengan Category, kami mesti memastikan konsistensi data sendiri. Ini dilakukan secara ringkas:

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

Mari kita tulis ujian mudah untuk menyemak:

@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 satu topik yang berasingan. Tujuan kajian semula ini adalah untuk memahami cara untuk mencapai matlamat ini. Anda boleh membaca lebih lanjut mengenai pemetaan di sini:

JPQL

JPA memperkenalkan alat yang menarik - pertanyaan dalam Bahasa Pertanyaan Kegigihan Java. Bahasa ini serupa dengan SQL, tetapi menggunakan model objek Java dan bukannya jadual SQL. Mari lihat 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 kita dapat lihat, dalam pertanyaan kami menggunakan rujukan kepada entiti Categorydan bukan jadual. Dan juga pada bidang entiti ini title. JPQL menyediakan banyak ciri berguna dan berhak mendapat artikelnya sendiri. Butiran lanjut boleh didapati dalam ulasan:

" Panduan Terbaik untuk Pertanyaan JPQL dengan JPA dan Hibernate "

API Kriteria

Dan akhirnya, saya ingin menyentuh tentang API Kriteria. JPA memperkenalkan alat binaan pertanyaan dinamik. 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 bersamaan dengan melaksanakan permintaan " SELECT c FROM Category c". API Kriteria ialah alat yang berkuasa. Anda boleh membaca lebih lanjut mengenainya di sini:

Kesimpulan

Seperti yang kita lihat, JPA menyediakan sejumlah besar ciri dan alatan. Setiap daripada mereka memerlukan pengalaman dan pengetahuan. Malah dalam rangka semakan JPA, tidak mungkin untuk menyebut semuanya, apatah lagi menyelam terperinci. Tetapi saya berharap selepas membacanya, ia menjadi lebih jelas apa itu ORM dan JPA, bagaimana ia berfungsi dan apa yang boleh dilakukan dengannya. Nah, untuk snek saya menawarkan pelbagai bahan:

#Viacheslav

Komen

TO VIEW ALL COMMENTS OR TO MAKE A COMMENT,
GO TO FULL VERSION