ogm session_带有Hibernate OGM的NoSQL –第一部分：持久化您的第一个实体

最新推荐文章于 2020-06-28 19:27:31 发布

dnc8371

最新推荐文章于 2020-06-28 19:27:31 发布

阅读量253

点赞数

文章标签：数据库 java python 大数据 hibernate

原文链接：https://www.javacodegeeks.com/2015/01/nosql-with-hibernate-ogm-part-one-persisting-your-first-entities.html

版权

ogm session

Hibernate OGM的第一个最终版本已经发布，团队从发布狂潮中恢复了一些。因此，他们考虑开设一系列教程风格的博客，使您有机会轻松地从Hibernate OGM重新开始。感谢Gunnar Morling（ @gunnarmorling ）创建了本教程。

介绍

不知道什么是Hibernate OGM？ Hibernate OGM是Hibernate下的最新项目，它允许您通过著名的JPA将实体模型持久保存在不同的NoSQL存储中。

我们将在接下来的几周内介绍这些主题：

坚持您的第一个实体（此批次）
查询数据
在WildFly上运行
在Java SE上使用CDI运行
将数据存储到同一应用程序中的两个不同存储中

如果您希望我们讨论任何其他主题，请告诉我们。只需在下面添加评论或向我们发送您的建议。

在本系列的第一部分中，我们将建立一个具有所需依赖项的Java项目，创建一些简单实体，然后将它们写入商店或从商店中读取。我们将从Neo4j图形数据库开始，然后仅需进行少量配置更改就切换到MongoDB文档存储。

项目设置

首先让我们创建一个具有所需依赖项的新Java项目。接下来，我们将使用Maven作为构建工具，但是Gradle或其他工具当然也可以很好地工作。

将此添加到pom.xml的dependencyManagement块中：

...
<dependencyManagement>
    <dependencies>
        ...
        <dependency>
            <groupId>org.hibernate.ogm</groupId>
            <artifactId>hibernate-ogm-bom</artifactId>
            <type>pom</type>
            <version>4.1.1.Final</version>
            <scope>import</scope>
        </dependency>
            ...
    </dependencies>
</dependencyManagement>
...

这将确保您使用的是匹配版本的Hibernate OGM模块及其依赖项。然后将以下内容添加到dependencies块：

...
<dependencies>
    ...
    <dependency>
        <groupId>org.hibernate.ogm</groupId>
        <artifactId>hibernate-ogm-neo4j</artifactId>
    </dependency>
    <dependency>
        <groupId>org.jboss.jbossts</groupId>
        <artifactId>jbossjta</artifactId>
    </dependency>
    ...
</dependencies>
...

依赖项是：

Hibernate OGM模块，用于处理嵌入式Neo4j数据库；这将引入所有其他必需的模块，例如Hibernate OGM内核和Neo4j驱动程序。使用MongoDB时，可以将其与hibernate-ogm-mongodb交换。
JBoss对Java Transaction API（JTA）的实现，当不在WildFly之类的Java EE容器中运行时需要此实现

领域模型

我们的示例域模型由三个类组成： Hike ， HikeSection和Person 。

之间存在组合关系Hike和HikeSection ，即上调包括几个部分，其生命周期是完全依赖于远足。远足部分列表已订购；坚持远足及其部分时，必须保持此顺序。

Hike与Person （充当远足组织者）之间的关联是双向的多对一/一对多关系：一个人可以组织零个或多个远足，而一个远足恰好有一个人充当组织者。

映射实体

现在，通过创建实体类并用所需的元数据注释它们来映射域模型。让我们从Person类开始：

@Entity
public class Person {

    @Id
    @GeneratedValue(generator = "uuid")
    @GenericGenerator(name = "uuid", strategy = "uuid2")
    private long id;

    private String firstName;
    private String lastName;

    @OneToMany(mappedBy = "organizer", cascade = CascadeType.PERSIST)
    private Set<Hike> organizedHikes = new HashSet<>();

    // constructors, getters and setters...
}

实体类型使用@Entity注释进行标记，而表示标识符的属性则使用@Id注释。

Hibernate OGM无需手动分配ID，而是可以解决此问题，它提供了几种ID生成策略，例如（模拟）序列，UUID等。通常，使用UUID生成器是一个不错的选择，因为它可以确保跨不同NoSQL数据存储的可移植性，并使ID生成快速且可扩展。但是根据您使用的商店，在MongoDB的情况下，您也可以使用特定的ID类型，例如对象ID（有关详细信息，请参阅参考指南）。

最后， @OneToMany将organizedHikes属性标记为实体之间的关联。由于它是双向实体，因此必须使用mappedBy属性来指定负责管理它的关联方。指定级联类型PERSIST可确保坚持一个人也将自动导致其关联的远足也被坚持。

接下来是Hike类：

@Entity
public class Hike {

    @Id
    @GeneratedValue(generator = "uuid")
    @GenericGenerator(name = "uuid", strategy = "uuid2")
    private String id;

    private String description;
    private Date date;
    private BigDecimal difficulty;

    @ManyToOne
    private Person organizer;

    @ElementCollection
    @OrderColumn(name = "sectionNo")
    private List<HikeSection> sections;

    // constructors, getters and setters...
}

在这里， @ManyToOne注释标记了Hike和Organizer之间的双向关联的另一面。由于HikeSection应该依赖于Hike，因此部分列表通过@ElementCollection映射。为了确保在数据存储区中保持节的顺序， @OrderColumn使用@OrderColumn 。这将在保留的记录中添加一个额外的“列”，其中包含每个部分的订单号。

最后， HikeSection类：

@Embeddable
public class HikeSection {

    private String start;
    private String end;

    // constructors, getters and setters...
}

与Person和Hike不同，它不是通过@Entity而是使用@Embeddable映射的。这意味着它始终是另一个实体（在本例中为Hike ）的一部分，因此本身也没有身份。因此，它不会声明任何@Id属性。

请注意，如果您将Hibernate ORM与关系数据存储一起使用，则这些映射看起来完全相同。的确，这就是Hibernate OGM的承诺之一：尽可能简化关系和NoSQL范例之间的迁移！

创建persistence.xml

有了实体类之后，JPA的persistence.xml描述符又丢失了一件事。在src / main / resources / META-INF / persistence.xml下创建它：

<?xml version="1.0" encoding="utf-8"?>

<persistence 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"
    version="2.0">

    <persistence-unit name="hikePu" transaction-type="RESOURCE_LOCAL">
        <provider>org.hibernate.ogm.jpa.HibernateOgmPersistence</provider>

        <properties>
            <property name="hibernate.ogm.datastore.provider" value="neo4j_embedded" />
            <property name="hibernate.ogm.datastore.database" value="HikeDB" />
            <property name="hibernate.ogm.neo4j.database_path" value="target/test_data_dir" />
        </properties>
    </persistence-unit>
</persistence>

如果您以前使用过JPA，那么对您来说，这个持久性单元定义应该看起来非常熟悉。与在关系数据库之上使用经典Hibernate ORM的主要区别在于，我们需要为Hibernate OGM指定特定的提供程序类： org.hibernate.ogm.jpa.HibernateOgmPersistence 。

此外，还定义了一些特定于Hibernate OGM和所选后端的属性来设置：

使用的后端（在这种情况下为嵌入式Neo4j图形数据库）
Neo4j数据库的名称
存储Neo4j数据库文件的目录

根据您的用法和后端，可能需要其他属性，例如，设置主机，用户名，密码等。您可以在名为<BACK END>Properties的类中找到所有可用的<BACK END>Properties ，例如Neo4jProperties ， MongoDBProperties等。。

保存和加载实体

所有这些位都准备就绪后，就可以保留（并加载）某些实体了。为此创建一个简单的JUnit测试外壳：

public class HikeTest {

    private static EntityManagerFactory entityManagerFactory;

    @BeforeClass
    public static void setUpEntityManagerFactory() {
        entityManagerFactory = Persistence.createEntityManagerFactory( "hikePu" );
    }

    @AfterClass
    public static void closeEntityManagerFactory() {
        entityManagerFactory.close();
    }
}

这两种方法为persistence.xml中定义的持久性单元管理实体管理器工厂。它保存在一个字段中，因此可以用于多种测试方法（请记住，实体管理器工厂的创建成本相当高，因此应将它们初始化一次并保留以备重用）。

然后创建一个持久保存并加载一些数据的测试方法：

@Test
public void canPersistAndLoadPersonAndHikes() {
    EntityManager entityManager = entityManagerFactory.createEntityManager();

    entityManager.getTransaction().begin();

    // create a Person
    Person bob = new Person( "Bob", "McRobb" );

    // and two hikes
    Hike cornwall = new Hike(
            "Visiting Land's End", new Date(), new BigDecimal( "5.5" ),
            new HikeSection( "Penzance", "Mousehole" ),
            new HikeSection( "Mousehole", "St. Levan" ),
            new HikeSection( "St. Levan", "Land's End" )
    );
    Hike isleOfWight = new Hike(
            "Exploring Carisbrooke Castle", new Date(), new BigDecimal( "7.5" ),
            new HikeSection( "Freshwater", "Calbourne" ),
            new HikeSection( "Calbourne", "Carisbrooke Castle" )
    );

    // let Bob organize the two hikes
    cornwall.setOrganizer( bob );
    bob.getOrganizedHikes().add( cornwall );

    isleOfWight.setOrganizer( bob );
    bob.getOrganizedHikes().add( isleOfWight );

    // persist organizer (will be cascaded to hikes)
    entityManager.persist( bob );

    entityManager.getTransaction().commit();

    // get a new EM to make sure data is actually retrieved from the store and not Hibernate's internal cache
    entityManager.close();
    entityManager = entityManagerFactory.createEntityManager();

    // load it back
    entityManager.getTransaction().begin();

    Person loadedPerson = entityManager.find( Person.class, bob.getId() );
    assertThat( loadedPerson ).isNotNull();
    assertThat( loadedPerson.getFirstName() ).isEqualTo( "Bob" );
    assertThat( loadedPerson.getOrganizedHikes() ).onProperty( "description" ).containsOnly( "Visiting Land's End", "Exploring Carisbrooke Castle" );

    entityManager.getTransaction().commit();

    entityManager.close();
}

注意这两个动作是如何在事务中发生的。 Neo4j是一个完全事务性的数据存储库，可以通过JPA的事务处理API很好地控制它。在实际的应用程序中，可能会使用一种较为冗长的方法来进行事务控制。根据所选的后端和应用程序运行的环境类型（例如Java EE容器，例如WildFly ），您可以利用通过CDI或EJB进行的声明式事务管理。但是，让我们再保存一次。

保留了一些数据之后，您可以使用Neo4j随附的漂亮的Web控制台对其进行检查。下面显示了测试保留的实体：

Hibernate OGM旨在为您要定位的数据存储提供最自然的映射。对于Neo4j作为图形数据存储的情况，这意味着任何实体都将映射到相应的节点。

实体属性被映射为节点属性（请参见描述黑名单节点之一的黑框）。任何不受本机支持的属性类型都将根据需要进行转换。例如， date属性就是这种情况，它作为ISO格式的字符串保留。此外，每个实体节点都有标签 ENTITY（以将其与其他类型的节点区分开）和指定其实体类型的标签（在这种情况下为远足）。

关联被映射为节点之间的关系，关联角色被映射为关系类型。

请注意，Neo4j没有嵌入式对象的概念。因此， HikeSection对象被映射为带有标签EMBEDDED的节点，并与拥有的Hike节点链接。节的顺序通过关系上的属性保留。

切换到MongoDB

Hibernate OGM的承诺之一是允许使用相同的API（即JPA）与不同的NoSQL存储一起使用。因此，让我们看一下它如何保存和利用MongoDB，它与Neo4j不同，它是一个文档数据存储区，并以类似JSON的表示形式保留数据。为此，请首先将Neo4j后端替换为以下内容：

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

然后使用可通过以下方式访问的属性更新persistence.xml中的配置，以将MongoDB作为后端使用
提供与您的环境匹配的主机名和凭据的MongoDBProperties （如果尚未安装MongoDB，则可以在此处下载）：

...
<properties>
    <property name="hibernate.ogm.datastore.provider" value="mongodb" />
    <property name="hibernate.ogm.datastore.database" value="HikeDB" />
    <property name="hibernate.ogm.datastore.host" value="mongodb.mycompany.com" />
    <property name="hibernate.ogm.datastore.username" value="db_user" />
    <property name="hibernate.ogm.datastore.password" value="top_secret!" />
</properties>
...

这就是将实体保留在MongoDB中而不是Neo4j中所需要做的全部工作。如果现在再次运行测试，您将在数据存储区中找到以下BSON文档：

# Collection "Person"
{
    "_id" : "50b62f9b-874f-4513-85aa-c2f59015a9d0",
    "firstName" : "Bob",
    "lastName" : "McRobb",
    "organizedHikes" : [
        "a78d731f-eff0-41f5-88d6-951f0206ee67",
        "32384eb4-717a-43dc-8c58-9aa4c4e505d1"
    ]
}

# Collection Hike
{
    "_id" : "a78d731f-eff0-41f5-88d6-951f0206ee67",
    "date" : ISODate("2015-01-16T11:59:48.928Z"),
    "description" : "Visiting Land's End",
    "difficulty" : "5.5",
    "organizer_id" : "50b62f9b-874f-4513-85aa-c2f59015a9d0",
    "sections" : [
        {
            "sectionNo" : 0,
            "start" : "Penzance",
            "end" : "Mousehole"
        },
        {
            "sectionNo" : 1,
            "start" : "Mousehole",
            "end" : "St. Levan"
        },
        {
            "sectionNo" : 2,
            "start" : "St. Levan",
            "end" : "Land's End"
        }
    ]
}
{
    "_id" : "32384eb4-717a-43dc-8c58-9aa4c4e505d1",
    "date" : ISODate("2015-01-16T11:59:48.928Z"),
    "description" : "Exploring Carisbrooke Castle",
    "difficulty" : "7.5",
    "organizer_id" : "50b62f9b-874f-4513-85aa-c2f59015a9d0",
    "sections" : [
        {
            "sectionNo" : 1,
            "start" : "Calbourne",
            "end" : "Carisbrooke Castle"
        },
        {
            "sectionNo" : 0,
            "start" : "Freshwater",
            "end" : "Calbourne"
        }
    ]
}

同样，映射是非常自然的，就像使用MongoDB这样的文档存储时所期望的那样。通过将参考ID存储在任意一侧，可以映射Person和Hike之间的双向一对多/多对一关联。当加载回数据时，Hibernate OGM将解析ID，并允许将关联从一个对象导航到另一个对象。

元素集合使用MongoDB存储分层结构的功能进行映射。在此，加息的各个部分映射到拥有加息的文档中的数组，并带有附加的字段sectionNo来维护收集顺序。这样可以通过一次往返数据存储的方式非常有效地加载实体及其嵌入式元素。

结语

在带有Hibernate OGM 101的NoSQL的第一部分中，您学习了如何设置具有所需依赖项的项目，映射某些实体和关联并将其持久化在Neo4j和MongoDB中。所有这些都是通过众所周知的JPA API进行的。因此，如果您过去在关系数据库之上使用过Hibernate ORM和JPA，那么深入NoSQL领域将变得异常简单。

同时，每个商店都针对某些用例，因此提供了特定的功能和配置选项。自然，这些不能通过通用API（例如JPA）公开。因此，Hibernate OGM允许您使用本机NoSQL查询，并允许通过其灵活的选项系统配置商店特定的设置。

您可以在GitHub上找到此博客文章的完整示例代码。只需叉子，然后随心所欲地玩就可以了。

当然，存储实体并通过其ID取回实体仅仅是开始。在任何实际的应用程序中，您都希望对数据运行查询，并且还可能希望利用所选NoSQL存储库的某些特定功能和设置。我们将在本系列的下一部分中谈到这一点，请继续关注！

翻译自: https://www.javacodegeeks.com/2015/01/nosql-with-hibernate-ogm-part-one-persisting-your-first-entities.html

ogm session

dnc8371

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
ogm session_带有Hibernate OGM的NoSQL –第一部分：持久化您的第一个实体

ogm session Hibernate OGM的第一个最终版本已经发布，团队从发布狂潮中恢复了一些。因此，他们考虑开设一系列教程风格的博客，使您有机会轻松地从Hibernate OGM重新开始。感谢Gunnar Morling（ @gunnarmorling ）创建了本教程。介绍不知道什么是Hibernate OGM？ Hibernate OGM是Hibernate下的最新项...
复制链接

扫一扫