Panduan untuk Hibernasi OGM

1. Ikhtisar

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

Hibernate OGM menyediakan dukungan Java Persistence API (JPA) untuk datastore NoSQL. NoSQL adalah istilah umum yang mencakup berbagai macam penyimpanan data. Misalnya, ini termasuk datastore nilai-kunci, dokumen, berorientasi kolom dan berorientasi grafik.

2. Arsitektur Hibernate OGM

Hibernate secara tradisional menawarkan mesin Pemetaan Relasional Objek (ORM) untuk database relasional. Mesin Hibernate OGM memperluas fungsinya untuk mendukung datastore NoSQL. Manfaat utama menggunakannya adalah konsistensi antarmuka JPA di seluruh datastore relasional dan NoSQL.

Hibernate OGM mampu menyediakan abstraksi atas sejumlah datastore NoSQL karena dua antarmuka utama, DatastoreProvider dan GridDialect . Oleh karena itu, setiap datastore NoSQL baru yang didukungnya dilengkapi dengan implementasi antarmuka ini.

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

Ini juga sepenuhnya mendukung transaksi dan dapat bekerja dengan penyedia JTA standar. Pertama, ini dapat disediakan melalui container Jakarta EE tanpa konfigurasi eksplisit apa pun. Selain itu, kami dapat menggunakan manajer transaksi JTA mandiri seperti Narayana di lingkungan Java SE.

3. Penyiapan

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

Untuk memperjelas, mari kita lihat cara menyiapkannya untuk tutorial.

3.1. Dependensi Maven

Mari kita lihat dependensi yang diperlukan untuk bekerja 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 dependensi yang diperlukan melalui Maven:

  • Dialek Hibernasi OGM untuk MongoDB
  • Manajer Transaksi Narayana (penyedia sebenarnya dari JTA)

3.2. Unit Kegigihan

Kami juga harus menentukan detail datastore di Hibernate persistance.xml :

 org.hibernate.ogm.jpa.HibernateOgmPersistence      

Perhatikan definisi yang kami berikan di sini:

  • nilai atribut jenis transaksi sebagai "JTA" (ini menyiratkan bahwa kita menginginkan pengelola entitas JTA dari EntityManagerFactory)
  • penyedia, yaitu HibernateOgmPersistence untuk Hibernate OGM
  • beberapa detail tambahan terkait dengan DB (ini biasanya bervariasi antara sumber data yang berbeda)

Konfigurasi tersebut mengasumsikan MongoDB sedang berjalan dan dapat diakses secara default. Jika tidak demikian, kami selalu dapat memberikan detail yang diperlukan. Salah satu artikel kami sebelumnya juga membahas pengaturan MongoDB secara detail.

4. Definisi Entitas

Sekarang kita telah mempelajari dasar-dasarnya, mari kita definisikan beberapa entitas. Jika sebelumnya kami bekerja dengan Hibernate ORM atau JPA, tidak ada lagi yang bisa ditambahkan . Ini adalah premis fundamental dari Hibernate OGM. Itu menjanjikan untuk membiarkan kita bekerja dengan datastore NoSQL yang berbeda hanya dengan pengetahuan JPA .

Untuk tutorial ini, kami akan mendefinisikan model objek sederhana:

Ini mendefinisikan kelas Artikel , Penulis dan Editor bersama dengan hubungannya.

Mari kita tentukan juga 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... }

Sekarang kami telah menentukan kelas entitas dan memberinya anotasi dengan anotasi standar JPA:

  • @ Entity untuk menetapkannya sebagai entitas JPA
  • @Id untuk menghasilkan kunci utama untuk entitas dengan UUID
  • @OneToMany dan @ManyToOne untuk membangun hubungan dua arah antara entitas

5. Operasi

Sekarang setelah kita membuat entitas kita, mari kita lihat apakah kita dapat melakukan beberapa operasi padanya. Sebagai langkah pertama, kita harus membuat beberapa data uji. Di sini, kami akan membuat Editor , beberapa Penulis , dan beberapa Artikel. Kami juga akan membangun hubungan mereka.

Setelah itu, sebelum kita dapat melakukan operasi apa pun, kita membutuhkan sebuah instance EntityManagerFactory. Kita bisa menggunakan ini untuk membuat EntityManager . Bersamaan dengan ini, kita perlu membuat TransactionManager untuk menangani batasan transaksi.

Mari kita lihat bagaimana kita bisa menggunakan ini untuk bertahan dan mengambil entitas 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 mempertahankan entitas root, yang mengalir ke semua relasinya. Kami juga melakukan operasi ini dalam batas transaksi yang ditentukan.

Sekarang kami siap memuat entitas yang baru saja kami pertahankan dan memverifikasi isinya. Kami dapat menjalankan tes untuk memverifikasi 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 lagi untuk menemukan data dan melakukan pernyataan standar padanya. Ketika kami menjalankan tes ini, itu membuat instantiate datastore, mempertahankan entitas, mengambilnya kembali, dan memverifikasi.

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.

Nah, itulah yang perlu dilakukan. Saat kami menjalankan pengujian yang sama dengan Neo4j sebagai datastore backend, ini bekerja dengan cukup mulus.

Perhatikan bahwa kami telah mengalihkan backend kami dari MongoDB, yang kebetulan merupakan datastore berorientasi dokumen, ke Neo4j, yang merupakan datastore berorientasi grafik. Dan kami melakukan semua ini dengan sedikit perubahan dan tanpa memerlukan perubahan apa pun dalam operasi kami .

7. Kesimpulan

Dalam artikel ini, kita telah membahas dasar-dasar Hibernate OGM, termasuk arsitekturnya. Selanjutnya, kami menerapkan model domain dasar dan melakukan berbagai operasi menggunakan berbagai DB.

Seperti biasa, kode untuk contoh tersedia di GitHub.