Panduan untuk Hibernate OGM

1. Gambaran keseluruhan

Dalam tutorial ini, kita akan membahas asas-asas Hibernate Object / Grid Mapper (OGM).

Hibernate OGM menyediakan sokongan Java Persistence API (JPA) untuk datastores NoSQL. NoSQL adalah istilah payung yang merangkumi pelbagai jenis penyimpanan data. Contohnya, ini termasuk nilai kunci, dokumen, berorientasikan lajur dan berorientasikan grafik.

2. Senibina Hibernate OGM

Hibernate secara tradisional menawarkan mesin Object Relational Mapping (ORM) untuk pangkalan data hubungan. Mesin Hibernate OGM memperluaskan fungsinya untuk menyokong datastores NoSQL. Manfaat utama menggunakannya adalah ketekalan antara muka JPA di seluruh datastore relasional dan NoSQL.

Hibernate OGM dapat memberikan pengabstrakan pada sejumlah datastores NoSQL kerana dua antara muka utama, DatastoreProvider dan GridDialect . Oleh itu, setiap datastore NoSQL baru yang disokongnya disertakan dengan pelaksanaan antara muka ini.

Sehingga hari ini, ia tidak menyokong semua datastore NoSQL, tetapi mampu bekerja dengan banyak dari mereka seperti Infinispan dan Ehcache (kunci-nilai), MongoDB dan CouchDB (dokumen), dan Neo4j (grafik).

Ia juga menyokong penuh transaksi dan dapat bekerja dengan penyedia JTA standard. Pertama, ini dapat disediakan melalui wadah Jakarta EE tanpa konfigurasi yang jelas. Lebih-lebih lagi, kita dapat menggunakan pengurus transaksi JTA yang berdiri sendiri seperti Narayana di lingkungan Java SE.

3. Persediaan

Untuk tutorial ini, kami akan menggunakan Maven untuk menarik kebergantungan yang diperlukan untuk bekerjasama dengan Hibernate OGM. Kami juga akan menggunakan MongoDB.

Untuk memperjelas, mari kita lihat cara menyiapkannya untuk tutorial.

3.1. Ketergantungan Maven

Mari lihat kebergantungan yang diperlukan untuk bekerjasama dengan Hibernate OGM dan MongoDB:

 org.hibernate.ogm hibernate-ogm-mongodb 5.4.0.Final   org.jboss.narayana.jta narayana-jta 5.9.2.Final 

Di sini kami menarik pergantungan yang diperlukan melalui Maven:

  • Dialek Hibernate OGM untuk MongoDB
  • Pengurus Transaksi Narayana (penyedia sebenar JTA)

3.2. Unit Kegigihan

Kita juga harus menentukan perincian datastore dalam Hibernate persistance.xml :

 org.hibernate.ogm.jpa.HibernateOgmPersistence      

Perhatikan definisi yang kami berikan di sini:

  • nilai jenis transaksi atribut sebagai "JTA" (ini menunjukkan bahawa kita mahukan pengurus entiti JTA dari EntityManagerFactory)
  • penyedia, yang HibernateOgmKetahanan untuk Hibernate OGM
  • beberapa butiran tambahan yang berkaitan dengan DB (ini biasanya berbeza antara sumber data yang berbeza)

Konfigurasi tersebut menganggap MongoDB berjalan dan dapat diakses secara lalai. Sekiranya ini tidak berlaku, kami selalu dapat memberikan butiran yang diperlukan. Salah satu artikel kami sebelumnya juga merangkumi penyediaan MongoDB secara terperinci.

4. Definisi Entiti

Sekarang setelah kita melalui asas-asasnya, mari kita tentukan beberapa entiti. Sekiranya sebelum ini kami bekerja dengan Hibernate ORM atau JPA, ini tidak perlu ditambah lagi . Ini adalah premis asas Hibernate OGM. Ini berjanji untuk membiarkan kami bekerja dengan kedai data NoSQL yang berbeza hanya dengan pengetahuan tentang JPA .

Untuk tutorial ini, kami akan menentukan model objek mudah:

Ini menentukan kelas Artikel , Pengarang dan Editor bersama dengan hubungan mereka.

Mari kita juga menentukannya di Java:

@Entity public class Article { @Id @GeneratedValue(generator = "uuid") @GenericGenerator(name = "uuid", strategy = "uuid2") private String articleId; private String articleTitle; @ManyToOne private Author author; // constructors, getters and setters... }
@Entity public class Author { @Id @GeneratedValue(generator = "uuid") @GenericGenerator(name = "uuid", strategy = "uuid2") private String authorId; private String authorName; @ManyToOne private Editor editor; @OneToMany(mappedBy = "author", cascade = CascadeType.PERSIST) private Set authoredArticles = new HashSet(); // constructors, getters and setters... }
@Entity public class Editor { @Id @GeneratedValue(generator = "uuid") @GenericGenerator(name = "uuid", strategy = "uuid2") private String editorId; private String editorName; @OneToMany(mappedBy = "editor", cascade = CascadeType.PERSIST) private Set assignedAuthors = new HashSet(); // constructors, getters and setters... }

Kami sekarang telah menentukan kelas entiti dan memberikannya anotasi standard JPA:

  • @Entiti untuk menjadikan mereka sebagai entiti JPA
  • @Id untuk menjana kunci utama untuk entiti yang mempunyai UUID
  • @OneToMany dan @ManyToOne untuk menjalin hubungan dua arah antara entiti

5. Operasi

Sekarang setelah kita membuat entiti, mari kita lihat sama ada kita dapat menjalankan beberapa operasi pada mereka. Sebagai langkah pertama, kita mesti menghasilkan beberapa data ujian. Di sini, kami akan membuat Editor , beberapa Pengarang , dan beberapa Artikel. Kami juga akan menjalin hubungan mereka.

Selepas itu, sebelum kita dapat melakukan operasi apa pun, kita memerlukan contoh EntityManagerFactory. Kita boleh menggunakannya untuk membuat EntityManager . Seiring dengan ini, kita perlu membuat TransactionManager untuk menangani had transaksi.

Mari kita lihat bagaimana kita dapat menggunakannya untuk bertahan dan mengambil entiti yang kita buat sebelumnya:

private void persistTestData(EntityManagerFactory entityManagerFactory, Editor editor) throws Exception { TransactionManager transactionManager = com.arjuna.ats.jta.TransactionManager.transactionManager(); transactionManager.begin(); EntityManager entityManager = entityManagerFactory.createEntityManager(); entityManager.persist(editor); entityManager.close(); transactionManager.commit(); }

Di sini, kami menggunakan EntityManager untuk meneruskan entiti root, yang merangkumi semua hubungannya. Kami juga melakukan operasi ini dalam batas transaksi yang ditentukan.

Sekarang kami bersedia memuat entiti yang baru kami buat dan mengesahkan kandungannya. Kami boleh menjalankan ujian untuk mengesahkan ini:

@Test public void givenMongoDB_WhenEntitiesCreated_thenCanBeRetrieved() throws Exception { EntityManagerFactory entityManagerFactory = Persistence.createEntityManagerFactory("ogm-mongodb"); Editor editor = generateTestData(); persistTestData(entityManagerFactory, editor); TransactionManager transactionManager = com.arjuna.ats.jta.TransactionManager.transactionManager(); transactionManager.begin(); EntityManager entityManager = entityManagerFactory.createEntityManager(); Editor loadedEditor = entityManager.find(Editor.class, editor.getEditorId()); assertThat(loadedEditor).isNotNull(); // Other assertions to verify the entities and relations }

Di sini, kami menggunakan EntityManager sekali lagi untuk mencari data dan melaksanakan penegasan standard di atasnya. Apabila kami menjalankan ujian ini, ini memberi instastore datastore, bertahan entiti, mengambilnya kembali, dan mengesahkan.

Again, we've just used JPA to persist the entities along with their relationship. Similarly, we use JPA to load the entities back and it all works fine, even when our database choice is MongoDB instead of a traditional relational database.

6. Switching Backend

We can also switch our backend. Let's find out now how difficult it'll be to do this.

We'll change our backend to Neo4j, which happens to be a popular graph-oriented datastore.

Firstly, let's add the Maven dependency for Neo4j:

 org.hibernate.ogm hibernate-ogm-neo4j 5.4.0.Final 

Next, we'll have to add the relevant persistence unit in our persistence.xml:

 org.hibernate.ogm.jpa.HibernateOgmPersistence      

In short, these are the very basic configurations required for Neo4j. This can be detailed further as required.

Itulah yang perlu dilakukan. Apabila kita menjalankan ujian yang sama dengan Neo4j dengan backast datastore, ia berfungsi dengan lancar.

Perhatikan bahawa kami telah menukar backend kami dari MongoDB, yang kebetulan merupakan datastore berorientasikan dokumen, ke Neo4j, yang merupakan datastore berorientasikan grafik. Dan kami melakukan semua ini dengan sedikit perubahan dan tanpa memerlukan perubahan dalam operasi kami .

7. Kesimpulannya

Dalam artikel ini, kami telah mempelajari asas-asas Hibernate OGM, termasuk senibina. Selepas itu, kami menerapkan model domain asas dan melakukan pelbagai operasi menggunakan pelbagai DB.

Seperti biasa, kod untuk contoh boleh didapati di GitHub.