首页 > 编程语言 >深入探究Hibernate：优雅、强大的Java持久化框架（二）

深入探究Hibernate：优雅、强大的Java持久化框架（二）

时间：2024-04-05 15:32:38浏览次数：28  
标签：关系 实体类 缓存 Java 映射 关联 探究 Hibernate

本系列文章简介：

        作为一个优雅而强大的Java持久化框架，Hibernate为开发人员提供了一个简单且高效的方式来处理对象关系映射（ORM）。无论您是一个经验丰富的Hibernate开发者还是一个新手，本系列文章都将带您深入了解Hibernate的内部工作原理和使用技巧。

        Hibernate已经成为许多Java项目中不可或缺的一部分。它的强大功能和灵活性使得它成为许多大型企业级应用程序的首选。通过Hibernate，开发人员可以轻松地将Java对象映射到数据库表，从而实现数据的持久化和查询。

        本系列文章将从Hibernate的基本概念开始，介绍Hibernate的核心组件和配置文件。我们将深入探讨Hibernate的查询语言（HQL）和Criteria API，并展示如何利用它们来执行复杂的数据库操作。此外，我们还将介绍Hibernate的缓存机制和事务管理，以及如何优化性能和处理并发访问。

        本系列文章还将涵盖一些高级主题，如Hibernate的集成测试、数据导入和导出、多租户支持等。我们还将介绍Hibernate的扩展和插件机制，以及如何在Spring和其他框架中集成Hibernate。

        通过阅读本系列文章，您将学会如何使用Hibernate构建出色的Java应用程序，并充分发挥其强大的功能。不管您是一个想要更深入了解Hibernate的开发人员，还是一个有兴趣进一步提升技能的专业人士，本系列文章都将为您提供全面而详实的指导。

        欢迎大家订阅《Java技术栈高级攻略》专栏，一起学习，一起涨分！

目录

1、前言

2、Hibernate关系映射

2.1 一对一关系映射

2.2 一对多关系映射

2.3 多对一关系映射

2.4 多对多关系映射

3、Hibernate高级特性

3.1 缓存管理

3.2 延迟加载

3.3 乐观锁与悲观锁

3.4 批量处理

3.5 监听器

4、结语

1、前言

        Hibernate是一个开源的Java持久化框架，它提供了一种对象/关系映射（Object/Relational Mapping，简称ORM）的解决方案，用于将Java对象与关系型数据库之间进行映射。它可以使开发人员在操作数据库时，不需要编写任何SQL语句，而是通过简单的配置和对象操作来完成持久化操作。

        使用Hibernate可以极大地简化数据访问层的开发工作，提高开发效率。它支持事务管理、缓存机制、查询语言等功能，同时也提供了对多种数据库的支持。

        本文将跟随《深入探究Hibernate：优雅、强大的Java持久化框架（一）》的进度，继续介绍Hibernate。希望通过本系列文章的学习，您将能够更好地理解Hibernate的内部工作原理，掌握Hibernate的使用技巧，以及通过合理的设计完成最佳实践，充分发挥优化Hibernate的潜力，为系统的高效运行提供有力保障。

2、Hibernate关系映射

2.1 一对一关系映射

在Hibernate中，一对一关系映射指的是两个实体类之间存在着一对一的关系。例如，一个学生只能有一个身份证，一个身份证也只对应一个学生。

要实现一对一关系映射，需要在实体类中定义相应的关联关系和映射关系。

首先，我们定义两个实体类，一个是学生类(Student)，一个是身份证类(IdCard)。

@Entity
public class Student {
    @Id
    @GeneratedValue(strategy = GenerationType.IDENTITY)
    private Long id;

    private String name;

    @OneToOne(mappedBy = "student", cascade = CascadeType.ALL)
    private IdCard idCard;

    // getter and setter
}

@Entity
public class IdCard {
    @Id
    @GeneratedValue(strategy = GenerationType.IDENTITY)
    private Long id;

    private String number;

    @OneToOne
    @JoinColumn(name = "student_id")
    private Student student;

    // getter and setter
}

在学生类中，我们使用了@OneToOne注解来定义与身份证类之间的关联关系。mappedBy = "student"表示学生类是关系的被维护方，也就是说身份证类负责维护关联关系。

在身份证类中，我们使用了@OneToOne注解来定义与学生类之间的关联关系，同时使用了@JoinColumn注解来指定关联字段名为student_id。

接下来，我们可以使用Hibernate的API来操作这一对一的关系。

Student student = new Student();
student.setName("Tom");

IdCard idCard = new IdCard();
idCard.setNumber("1234567890");
idCard.setStudent(student);

student.setIdCard(idCard);

Session session = HibernateUtil.getSessionFactory().openSession();
session.beginTransaction();

session.save(student);

session.getTransaction().commit();
session.close();

以上代码演示了插入一条学生及其身份证的记录。首先创建一个学生对象和一个身份证对象，然后将身份证对象设置给学生对象，并将学生对象保存到数据库中。

可以看到，通过使用Hibernate的关联映射注解，我们可以很方便地实现一对一关系映射。

2.2 一对多关系映射

一对多关系映射是指在Hibernate中，一个实体类关联多个其他实体类的关系。在数据库中，通常使用外键来表示这种关系。

示例： 假设有两个实体类：Order（订单）和Product（产品）。一个订单可以包含多个产品，而一个产品只能属于一个订单。

在Order类中，需要使用@OneToMany注解来表示一对多关系映射：

@Entity
@Table(name = "orders")
public class Order {
    @Id
    @GeneratedValue(strategy = GenerationType.IDENTITY)
    private Long id;
    
    // 其他属性
    
    @OneToMany(mappedBy = "order")
    private List<Product> products;
    
    // getter和setter方法
}

在Product类中，需要使用@ManyToOne注解来表示多对一关系：

@Entity
@Table(name = "products")
public class Product {
    @Id
    @GeneratedValue(strategy = GenerationType.IDENTITY)
    private Long id;
    
    // 其他属性
    
    @ManyToOne
    @JoinColumn(name = "order_id")
    private Order order;
    
    // getter和setter方法
}

在以上例子中，Order类中使用@OneToMany注解来表示一对多关系映射，通过mappedBy属性指定了关联的属性名为"order"，即Product类中的order属性。而Product类中使用@ManyToOne注解来表示多对一关系，通过JoinColumn注解指定了外键列名为"order_id"。这样，一个Order对象可以关联多个Product对象，而一个Product对象只能关联一个Order对象。

在使用Hibernate进行一对多关系映射时，需要注意以下几点：

  • 需要在实体类中使用注解来表示关系映射。
  • 需要在一的一方（Order类）中使用@OneToMany注解，并指定关联的属性名。
  • 需要在多的一方（Product类）中使用@ManyToOne注解，并指定关联的外键列名。

以上就是Hibernate中一对多关系映射的基本使用方法。

2.3 多对一关系映射

Hibernate是一个开源的Java持久化框架，可以方便地进行对象与关系数据库的映射。多对一关系映射是Hibernate中的一种常见的关系映射方式。

多对一关系映射表示一个实体类的多个对象实例可以关联到另一个实体类的一个对象实例。在数据库中，多对一关系通常通过外键来实现。

在Hibernate中，多对一关系映射可以通过注解或者xml配置来实现。以下是一种常见的使用注解的多对一关系映射示例：

@Entity
@Table(name = "student")
public class Student {

    @Id
    @GeneratedValue(strategy = GenerationType.IDENTITY)
    @Column(name = "student_id")
    private int id;

    @Column(name = "name")
    private String name;

    // 多对一关系映射
    @ManyToOne
    @JoinColumn(name = "teacher_id")
    private Teacher teacher;

    // 省略getter和setter方法
}

@Entity
@Table(name = "teacher")
public class Teacher {

    @Id
    @GeneratedValue(strategy = GenerationType.IDENTITY)
    @Column(name = "teacher_id")
    private int id;

    @Column(name = "name")
    private String name;

    // 省略getter和setter方法
}

在上面的示例中，Student类和Teacher类之间建立了多对一的关系映射。在Student类中，使用@ManyToOne注解标注了teacher字段，表示该字段与Teacher类是多对一的关系。在Teacher类中，没有建立与Student类的关系映射，因为该示例只展示了多对一的关系。

在数据库中，student表和teacher表之间会通过外键建立关联，student表中的teacher_id字段引用了teacher表中的主键。当查询student表中的数据时，可以通过多对一关系映射，方便地获取对应的teacher对象。

通过Hibernate的多对一关系映射，可以简化开发人员操作数据库的工作，提高开发效率。

2.4 多对多关系映射

在Hibernate中，多对多关系是一种在两个实体类之间存在多对多关联关系的映射关系。多对多关系意味着一个实体对象可以与多个其他实体对象相关联，并且一个实体对象也可以与多个其他实体对象相关联。

在多对多关系中，通常需要创建一个中间表（也称为关联表）来存储两个实体类之间的关联关系。这个中间表通常包含两个外键，分别指向两个实体类的主键，以表示二者之间的关联关系。

要在Hibernate中实现多对多关系映射，需要进行以下步骤：

  1. 创建实体类：创建两个实体类，并在它们之间建立多对多关系的属性。
  2. 创建中间表：创建中间表，用于存储两个实体类之间的关联关系。中间表通常包含两个外键，分别指向两个实体类的主键。
  3. 配置映射文件：在实体类的映射文件中，配置多对多关系的映射关系。在映射文件中指定中间表的名称，并将中间表的外键与实体类的主键进行关联。
  4. 使用Hibernate进行操作：使用Hibernate的API进行数据库操作，包括保存、更新、查询等操作。

以下是一个示例，演示了如何在Hibernate中实现多对多关系映射：

实体类：Student.java

@Entity
public class Student {
    @Id
    private int id;
    private String name;
    
    @ManyToMany(cascade = CascadeType.ALL)
    @JoinTable(name = "student_course", 
        joinColumns = @JoinColumn(name = "student_id"), 
        inverseJoinColumns = @JoinColumn(name = "course_id"))
    private List<Course> courses;
    
    // getters and setters
}

实体类：Course.java

@Entity
public class Course {
    @Id
    private int id;
    private String name;
    
    @ManyToMany(mappedBy = "courses")
    private List<Student> students;
    
    // getters and setters
}

在上述代码中，Student和Course之间建立了多对多关系。通过在Student实体类中使用@ManyToMany注解，并指定中间表的名称和外键映射关系，完成了多对多关系的映射。同时，在Course实体类中使用@ManyToMany注解的mappedBy属性指定了关联字段的对应关系。

配置映射文件：student.hbm.xml和course.hbm.xml

<hibernate-mapping>
    <class name="Student">
        <id name="id" type="int">
            <generator class="assigned" />
        </id>
        <property name="name" type="string" />
        
        <list name="courses" cascade="all">
            <key column="student_id" />
            <index column="course_id" />
            <many-to-many class="Course" column="course_id" />
        </list>
    </class>
</hibernate-mapping>

<hibernate-mapping>
    <class name="Course">
        <id name="id" type="int">
            <generator class="assigned" />
        </id>
        <property name="name" type="string" />
        
        <list name="students" cascade="all" inverse="true">
            <key column="course_id" />
            <index column="student_id" />
            <many-to-many class="Student" column="student_id" />
        </list>
    </class>
</hibernate-mapping>

在映射文件中，使用<list>元素来映射多对多关系，并指定中间表的名称和外键映射关系。

使用Hibernate进行操作：

Student student1 = new Student();
student1.setId(1);
student1.setName("John");

Course course1 = new Course();
course1.setId(1);
course1.setName("Math");

Course course2 = new Course();
course2.setId(2);
course2.setName("English");

student1.getCourses().add(course1);
student1.getCourses().add(course2);

session.save(student1);

通过以上代码，可以将一个学生与多门课程关联起来，并将关联关系保存到数据库中。

3、Hibernate高级特性

3.1 缓存管理

Hibernate高级特性之缓存管理是指在Hibernate中对缓存进行管理和优化的一些技术和策略。

Hibernate中的缓存分为一级缓存和二级缓存。

一级缓存是指Hibernate默认的缓存机制，它是在Session级别上进行的缓存，即在同一个Session中多次查询同一个实体时，只会发送一条SQL查询语句，后续查询会直接从缓存中获取数据。一级缓存是Hibernate的默认缓存机制，不需要额外配置，但它的作用范围只限于同一个Session中。

二级缓存是指在SessionFactory级别上进行的缓存，它可以跨越多个Session，多个事务，甚至多个应用程序。二级缓存可以将查询结果缓存在内存中，以减少数据库的访问。二级缓存需要额外配置和开启。

在Hibernate中，可以通过以下的一些缓存管理技术和策略来对缓存进行管理和优化：

  1. 缓存策略：可以通过配置一些缓存策略来控制缓存的更新和失效策略。例如，可以设置缓存的过期时间、异步刷新缓存、缓存的读写策略等。

  2. 查询缓存：Hibernate提供了查询缓存的功能，可以缓存查询语句及其结果，以减少重复查询的开销。可以使用@javax.persistence.Cacheable和@org.hibernate.annotations.Cache注解来开启查询缓存。

  3. 二级缓存：可以使用二级缓存来缓存实体对象，以减少数据库的访问。可以使用缓存提供商（如Ehcache、Infinispan等）来配置和管理二级缓存。

  4. 事务管理：在多个事务中，可以通过合适的事务隔离级别来控制缓存的读写一致性。

  5. 缓存清理：当缓存中的数据被更新或删除时，需要及时清理缓存，以保证缓存中的数据与数据库的一致性。

  6. 缓存监控：可以通过一些监控工具或日志来监控缓存的使用情况和性能，以及及时发现和解决潜在的缓存问题。

总的来说，Hibernate提供了丰富的缓存管理技术和策略，可以根据实际应用的需求，选择和配置合适的缓存管理方案，以提高系统的性能和扩展性。

3.2 延迟加载

延迟加载是Hibernate的一项高级特性，它允许在需要时延迟加载对象的关联属性。这种延迟加载的机制可以提高Hibernate的性能，减少不必要的数据库查询。

在Hibernate中，当使用延迟加载时，只有在访问关联属性时才会加载相关的数据。这意味着在加载一个实体对象时，相关的关联对象不会被立即加载，只有在访问这些关联对象时才会被加载。

延迟加载的实现是通过使用代理对象来实现的。当加载一个实体对象时，Hibernate会在内存中创建一个代理对象来代替真正的对象。这个代理对象只包含关联属性的主键信息，当访问关联属性时，Hibernate会根据主键信息去数据库中加载真正的对象。

延迟加载可以提高查询的性能，因为它能够减少不必要的数据库查询。例如，如果一个实体类有一个关联属性，而在查询实体对象时并不需要加载该关联属性，那么使用延迟加载就可以避免加载该关联对象的数据。这样就可以节省数据库查询的时间和资源。

延迟加载也有一些注意事项。首先，延迟加载只在使用getter方法访问关联属性时才会生效，如果直接访问关联属性的成员变量，那么将立即加载关联对象的数据。其次，如果在延迟加载的关联属性上使用了级联操作（cascade），那么在访问关联属性之前，相关的关联对象可能已经被加载到内存中。

延迟加载是Hibernate框架的一个重要特性，它可以提高查询性能，减少数据库查询次数。但同时也需要注意延迟加载的使用方式和注意事项，以避免出现意外的行为。

3.3 乐观锁与悲观锁

在Hibernate中，乐观锁和悲观锁是用来处理并发访问下的数据一致性问题的两种不同策略。

  1. 乐观锁： 乐观锁假设并发访问的冲突很少发生，因此在读取数据时不对数据进行加锁，而是在数据更新时进行校验。乐观锁的实现方式通常是在数据表中添加一个版本号或时间戳字段，每次更新时检查版本号或时间戳是否与当前值匹配，若匹配则进行更新，否则表示冲突发生，需要处理冲突。

Hibernate中实现乐观锁的方式是通过在实体类中添加一个版本号属性，并使用@Version注解进行标注。当数据更新时，Hibernate会自动检查版本号，并在更新操作时校验版本号是否匹配。

        2. 悲观锁： 悲观锁假设并发访问的冲突经常发生，因此在读取数据时对数据进行加锁，避免其他线程同时访问。悲观锁的实现方式通常是在数据库层面进行加锁，例如使用SELECT FOR UPDATE语句对数据进行加锁，其他线程在访问被锁定的数据时会被阻塞。

Hibernate中实现悲观锁的方式是通过使用数据库的锁机制，例如使用LockMode.PESSIMISTIC_WRITE进行悲观写锁，或者使用LockMode.PESSIMISTIC_READ进行悲观读锁。在使用悲观锁时需要注意避免死锁和性能问题。

总结： 乐观锁适用于并发冲突较少的场景，可以提高并发性能，但需要处理冲突的情况。悲观锁适用于并发冲突较多的场景，可以保证数据的一致性，但会降低并发性能。在选择乐观锁或悲观锁时，需要根据实际情况进行权衡和选择。

3.4 批量处理

Hibernate提供了一些高级特性来支持批量处理操作，以提高性能和效率。以下是Hibernate的一些批量处理特性：

  1. 批量插入（Batch Insert）：Hibernate支持通过一次性插入多个对象来减少插入操作的次数，从而提高插入性能。可以通过设置hibernate.jdbc.batch_size属性来控制批量插入的数量。

  2. 批量更新（Batch Update）：Hibernate支持通过一次性更新多个对象来减少更新操作的次数，从而提高更新性能。可以通过设置hibernate.jdbc.batch_size属性来控制批量更新的数量。

  3. 批量删除（Batch Delete）：Hibernate支持通过一次性删除多个对象来减少删除操作的次数，从而提高删除性能。可以通过设置hibernate.jdbc.batch_size属性来控制批量删除的数量。

  4. 批量加载（Batch Fetch）：Hibernate支持通过一次性加载多个对象来减少查询数据库的次数，从而提高查询性能。可以使用Hibernate的Fetch策略来配置批量加载。

  5. 批量写入（Bulk Insert）：Hibernate提供了批量写入机制，可以通过使用JDBC的批处理机制来一次性插入或更新多个对象，从而提高写入性能。

总之，Hibernate的批量处理特性能够显著提高数据库操作的性能和效率，尤其是在需要处理大量数据时。通过合理地配置和使用这些特性，可以最大程度地减少与数据库的交互次数，从而提高应用程序的性能。

3.5 监听器

在Hibernate中，监听器是一种可以拦截和处理Hibernate事件的机制。通过监听器，我们可以在Hibernate执行某些操作时，插入自定义的代码逻辑。

Hibernate中的监听器一般分为实体监听器和自定义监听器两种类型。

  1. 实体监听器（Entity Listener）：实体监听器可以监听特定实体对象的生命周期事件，例如创建、更新、删除等操作。通过在实体类上添加注解（@EntityListeners）来指定实体监听器。

示例代码：

@EntityListeners(MyEntityListener.class)
public class MyEntity {
    // 实体属性
}

public class MyEntityListener {
    @PrePersist
    public void prePersist(MyEntity entity) {
        // 在实体持久化之前执行的操作
    }

    @PostPersist
    public void postPersist(MyEntity entity) {
        // 在实体持久化之后执行的操作
    }

    // 其他生命周期事件的监听方法
}

        2. 自定义监听器（Custom Listener）：自定义监听器可以监听Hibernate中的一些全局事件，例如SessionFactory的创建、Session的打开/关闭等。要创建自定义监听器，需要实现Hibernate提供的相应接口，并在Hibernate配置文件中进行配置。

示例代码：

public class MyListener implements PostLoadEventListener, PreUpdateEventListener {
    // 实现接口中的方法，处理相应事件
}

// 在Hibernate配置文件中进行配置
<event type="post-load">
    <listener class="com.example.MyListener" />
</event>

<event type="pre-update">
    <listener class="com.example.MyListener" />
</event>

通过使用Hibernate的监听器，我们可以灵活地插入自定义的代码逻辑，以满足特定的业务需求。

4、结语

        文章至此，已接近尾声！希望此文能够对大家有所启发和帮助。同时，感谢大家的耐心阅读和对本文档的信任。在未来的技术学习和工作中，期待与各位大佬共同进步，共同探索新的技术前沿。最后，再次感谢各位的支持和关注。您的支持是作者创作的最大动力，如果您觉得这篇文章对您有所帮助，请分享给身边的朋友和同事！

标签：关系,实体类,缓存,Java,映射,关联,探究,Hibernate
From： https://blog.csdn.net/weixin_42506246/article/details/137232485

相关文章

  • 简单讲讲你对 Java 中的异常的理解？
    Java中的异常都来自于java.lang.Throwable类，从异常类型上分，Java中的异常可以分为Exception和Error。Exception异常可以被程序本身处理，Error无法被程序处理。Exception异常又可以分为受检查异常和不受检查异常，所谓受检查异常是指那些在编程期间就需要把异常try/catc......
  • 【系统深入学习GO】Go 的并发机制-原理探究 线程实现模型
    在操作系统提供的内核线程之上，Go搭建了一个特有的两级线程模型。*两级线程模型：两级线程模型也称为多对多（M:N）的线程实现。与其他模型相比，两级线程模型提供了更求的灵活性。在此模型下，一个进程可以与多个KSE相关联，这与内核级线程模型相似。但与内核级线程模型不同的是，进程......
  • 二叉树计算【华为OD机试JAVA&Python&C++&JS题解】
    一.题目-二叉树计算给出一个二叉树如下图所示：6/79\/-26请由该二叉树生成一个新的二叉树，它满足其树中的每个节点将包含原始树中的左子树和右子树的和。20(7-2+9+6)/\-26\/......
  • 学生重新排队【华为OD机试JAVA&Python&C++&JS题解】
    一.题目-学生重新排队n个学生排成一排，学生编号分别是1到n，n为3的整倍数。老师随机抽签决定将所有学生分成m个3人的小组，n=3*m为了便于同组学生交流，老师决定将小组成员安排到一起，也就是同组成员彼此相连，同组任意两个成员输入描述：之间无其它组的成员。因此老师决定调整队伍，......
  • [附源码]JAVA计算机毕业设计二手球鞋交易（源码+开题）
    本系统（程序+源码）带文档lw万字以上 文末可获取一份本项目的java源码和数据库参考。系统程序文件列表开题报告内容研究背景随着近年来运动文化的兴起，球鞋文化逐渐成为了年轻人追求时尚与个性的重要标志。二手球鞋市场应运而生，并呈现出蓬勃发展的态势。然而，二手球鞋交易市场......
  • [附源码]JAVA计算机毕业设计二手汽车交易网站（源码+开题）
    本系统（程序+源码）带文档lw万字以上 文末可获取一份本项目的java源码和数据库参考。系统程序文件列表开题报告内容研究背景随着经济的持续发展和人们生活水平的提高，汽车已经从奢侈品转变为日常消费品，越来越多的人加入到购车大军中。然而，传统的汽车交易方式往往存在信息不对......
  • 用Java实现快速排序
    快速排序（QuickSort）是一种分治的排序算法。它的基本思想是：选择一个基准元素（本文选择第一个元素）。将数组中比基准小的元素放在基准的左边，比基准大的元素放在基准的右边。对基准左边和右边的子数组分别进行快速排序。快速排序的优点包括：高效性：平均时间复杂度为O(nlogn)。适......
  • JavaWeb学习笔记——第十五天
    Maven高级分模块设计与开发分模块设计就是将项目按照功能拆分成若干个子模块。优点：方便项目的管理维护、扩展，也方便模块间的相互调用，资源共享。分模块设计需要先针对模块功能进行设计，再进行编码实现。不会先将工程开发完毕，然后进行拆分。继承与聚合继承继承描述的是两个......
  • [附源码]JAVA计算机毕业设计二手母婴商品交易系统（源码+开题）
    本系统（程序+源码）带文档lw万字以上 文末可获取一份本项目的java源码和数据库参考。系统程序文件列表开题报告内容研究背景近年来，随着人们生活水平的提高和育儿观念的转变，母婴商品市场逐渐繁荣起来。然而，传统的母婴商品交易方式往往存在信息不对称、价格不透明等问题，给消费......
  • [附源码]JAVA计算机毕业设计二手交易网站（源码+开题）
    本系统（程序+源码）带文档lw万字以上 文末可获取一份本项目的java源码和数据库参考。系统程序文件列表开题报告内容研究背景随着互联网技术的快速发展和智能设备的普及，电子商务成为了现代人们购物的新宠。作为电子商务领域的一个细分市场，二手交易网站在近年来受到了广泛的关......

赞助商

阅读排行

网站主页关于我们联系我们网站地图

本网站内容转载自其他媒体，侵权联系[admin##ips99.com]。

Copyright © 2020-2023 IPS99 版权所有 IPS99