使用 Hibernate OGM 将 Hibernate 与 MongoDB 集成

Mehvish Ashiq 2023年1月30日 2022年7月18日
  1. MongoDB 中的休眠 OGM
  2. 使用 Hibernate OGM 的重要性
  3. 使用 Hibernate OGM 将 Hibernate 与 MongoDB 集成
使用 Hibernate OGM 将 Hibernate 与 MongoDB 集成

在本文中,我们将了解 Hibernate Object/Grid Mapper (OGM) 的重要性,并使用它来集成 Hibernate 和 MongoDB。

MongoDB 中的休眠 OGM

Hibernate Object/Grid Mapper (OGM) 为我们提供了对 NoSQL 数据存储的 Java Persistence API (JPA) 支持。请记住,NoSQL 是涵盖所有子数据存储类型的父术语。

例如,它包括文档、键值、面向图形和面向列的数据存储。

使用 Hibernate OGM 的重要性

要了解它的重要性,你必须了解任何关系数据库、Hibernate 和 MongoDB 的基础知识。假设你具备所有基本知识(至少一个关系数据库、Hibernate 和 MongoDB)。

Hibernate 将 Java 对象(更准确地说是属性(也称为字段))映射到数据库表中的列。让我们举一个例子,一个 students 可以有多个 courses

在关系数据库中,我们可以通过包含一个 studentscourses 表来对此建模,其中 courses 表中的多个条目可以映射到 students 表中的一个学生。

create table students {
    id integer(10),
    name varchar(100),
    department varchar(100)
}

create table courses {
    id integer(10),
    course1 varchar(50),
    course2 varchar(50),
}

create table student_courses {
    student_id  integer(10),
    course_id  integer(10)
}

我们可以在 Java 中表示类似的关系,如下所示。

@OneToMany(cascade=CascadeType.ALL)
  @JoinTable(name="student_courses", joinColumns={@JoinColumn(name="student_id ", referencedColumnName="id")}
  , inverseJoinColumns={@JoinColumn(name="course_id", referencedColumnName="id")})
  private Set<CoursesEntity> courses;

虽然 MongoDB 是一个 NoSQL 数据库,但它通过键值对存储和访问数据。请记住,值部分以 JSON/XML 格式存储为文档。

如果我们存储前面的 studentscourses 示例,它将在 MongoDB 中如下所示。

{
    id: 1,
    name: "John",
    department: "Comptuer Science"
    courses: [
        {
            course1: "C Programming",
            course2: "Machine Learning"
        },
        {
            course1: "Recommender Systems",
            course2: "Data Science"
        }
   ]
}

正如我们所看到的,MongoDB 具有可以更深入的嵌套字段,我们不能通过遵循传统方法将 Java 字段/属性映射到文档来使用 Hibernate 和 MongoDB。

这就是我们需要对象/网格映射器(OGM)的地方。Hibernate 为我们提供了一个 OGM 引擎实现,它扩展了它的功能和特性以支持 NoSQL 数据存储,例如 MongoDB。

OGM 还通过使用我们特定 NoSQL 数据库语言的本机查询以及 Java 持久性查询语言 (JPQL)(也称为 Java 持久性 API (JPA))来提供查询数据的好处。

使用 OGM 的主要优势是 Java Persistence API 在 NoSQL 和关系数据存储之间的一致性。由于两个关键接口 GridDialectDatastoreProvider,Hibernate OGM 可以提供对各种 NoSQL 数据存储的抽象。

这就是为什么 Hibernate OGM 支持的每个新的 NoSQL 数据存储都带有 DatastoreProviderGridDialect 接口的实现。

截至今天,尽管 Hibernate OGM 不支持所有 NoSQL 数据存储,但能够与其中的许多数据一起工作,包括 Infinispan(键值)、Neo4j(图形)和 MongoDB(文档)。

使用 Hibernate OGM 将 Hibernate 与 MongoDB 集成

我们需要设置以下内容以使用 Hibernate OGM 将 Hibernate 与 MongoDB 集成。

  1. Java(我们使用的是 Java 18.0.1.1)。
  2. MongoDB 服务器(我们使用的是 MongoDB 5.0.8)。
  3. 代码编辑器或 Java IDE(我们使用 Apache NetBeans IDE 13)。
  4. 使用 Maven 或 Gradle 的依赖项(我们正在使用 Maven)。

在这里,我们将创建一个名为 Student 的类,该类将被视为 EntityStudent 类的属性将作为 MongoDB 中的 field 名称。我们使用注解将 Java 类映射到实体,将属性映射到字段。

让我们首先为此准备所需的文件。编写 pom.xml 文件(该文件包含所有必需的依赖项):

<?xml version="1.0" encoding="UTF-8"?>
<project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
    <modelVersion>4.0.0</modelVersion>
    <groupId>com.voidtesting.hibernatewithmongodbusingogm</groupId>
    <artifactId>HibernateWithMongoDBUsingOGM</artifactId>
    <version>1.0-SNAPSHOT</version>

    <properties>
        <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
        <maven.compiler.source>18</maven.compiler.source>
        <maven.compiler.target>18</maven.compiler.target>
        <exec.mainClass>
            <!--this name will be on single line, we are splitting it
            for readability purpose-->
            com.voidtesting.hibernatewithmongodbusingogm
            .HibernateWithMongoDBUsingOGM
        </exec.mainClass>
    </properties>

    <dependencies>

        <dependency>
            <groupId>org.hibernate</groupId>
            <artifactId>hibernate-core</artifactId>
            <version>5.3.6.Final</version>
        </dependency>

        <dependency>
            <groupId>org.hibernate.ogm</groupId>
            <artifactId>hibernate-ogm-mongodb</artifactId>
            <version>5.4.1.Final</version>
        </dependency>

        <dependency>
            <groupId>org.jboss.narayana.jta</groupId>
            <artifactId>narayana-jta</artifactId>
            <version>5.9.2.Final</version>
            <type>jar</type>
        </dependency>

        <dependency>
            <groupId>org.glassfish.jaxb</groupId>
            <artifactId>jaxb-runtime</artifactId>
            <version>2.3.2</version>
        </dependency>

        <dependency>
            <groupId>org.parboiled</groupId>
            <artifactId>parboiled-java</artifactId>
            <version>1.4.1</version>
        </dependency>

        <dependency>
            <groupId>org.jboss.jbossts</groupId>
            <artifactId>jbossjta</artifactId>
            <version>4.16.4.Final</version>
        </dependency>

        <dependency>
            <groupId>org.hibernate</groupId>
            <artifactId>hibernate-entitymanager</artifactId>
            <version>5.6.9.Final</version>
        </dependency>

    </dependencies>
</project>

编写 persistence.xml 文件(这里,我们配置给定的 JPA 持久单元):

<?xml version="1.0" encoding="UTF-8"?>
<persistence version="2.0" xmlns="http://java.sun.com/xml/ns/persistence" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:schemaLocation="http://java.sun.com/xml/ns/persistence http://java.sun.com/xml/ns/persistence/persistence_2_0.xsd">

    <persistence-unit name="ogmdemo" transaction-type="JTA">
        <!-- Use the Hibernate OGM provider: configuration will be transparent -->
        <provider>org.hibernate.ogm.jpa.HibernateOgmPersistence</provider>
        <class>com.voidtesting.hibernatewithmongodbusingogm.Student</class>
        <exclude-unlisted-classes>true</exclude-unlisted-classes>

        <properties>
           <property name="hibernate.transaction.jta.platform"
           value="org.hibernate.service.jta.platform.internal.JBossStandAloneJtaPlatform"
           />
           <!--
           Here you will pick which NoSQL technology to use, and configure it;
           in this example we use MongoDB.
           -->
           <property name="hibernate.ogm.datastore.provider" value="MONGODB"/>
           <!-- Define MongoDB access parameters here. -->
           <property name="hibernate.ogm.datastore.host" value="127.0.0.1"/>
           <property name="hibernate.ogm.datastore.port" value="27017"/>
           <property name="hibernate.ogm.datastore.create_database" value="true"/>
           <property name="hibernate.ogm.datastore.database"
                     value="HibernateMongoDBDemo"/>

     </properties>
  </persistence-unit>
</persistence>

确保在 src/main/resources/META-INF 目录中有 persistence.xml 文件。否则,你可能会遇到错误。

创建 Student.java 类(该类将映射为实体,其变量映射为 MongoDB 中的字段):

package com.voidtesting.hibernatewithmongodbusingogm;

import java.io.Serializable;
import javax.persistence.Entity;
import javax.persistence.Id;

@Entity
public class Student implements Serializable {
    @Id
    public int id;
    public String name;

    public Student(int id, String name) {
        this.id = id;
        this.name = name;
    }

    public Student() {
    }

    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;
    }
}

你可能注意到我们使用了注解@Entity@Id 来告诉 MongoDB 为这个类创建一个实体并将它命名为 Student,其中主键是 id。你可以在此处找到所有 JPA 注释。

创建 Java 主类:

package com.voidtesting.hibernatewithmongodbusingogm;

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

public class HibernateWithMongoDBUsingOGM {

    public static void main(String args[]) {

        EntityManagerFactory entityManagerFactory =
            Persistence.createEntityManagerFactory("ogmdemo");
        EntityManager entityManager = entityManagerFactory.
            createEntityManager();
        entityManager.getTransaction().begin();
       // perform operations here
       Student std = new Student(1, "Mehvish Ashiq");
       entityManager.persist(std);
       entityManager.getTransaction().commit();
       entityManager.close();
       entityManagerFactory.close();
    }
}

这是一个截图,用于了解 Java 项目中所有文件的正确位置。

使用 hibernate ogm 将 hibernate 与 mongodb 集成 - 所有文件

现在,执行程序。你可以观察以下输出以了解我们如何执行并确保一切正常。

输出:

使用 hibernate ogm 将 hibernate 与 mongodb 集成 - 最终输出

Mehvish Ashiq avatar Mehvish Ashiq avatar

Mehvish Ashiq is a former Java Programmer and a Data Science enthusiast who leverages her expertise to help others to learn and grow by creating interesting, useful, and reader-friendly content in Computer Programming, Data Science, and Technology.

LinkedIn GitHub Facebook