java 持久层框架Hibernate的（超详细总结）

2023年 5月 3日 168点热度 0人点赞 0条评论

1. Hibernate概念

ORM

ORM (Object Relational Mapping) 对象关系映射框架是一种程序设计技术，它将面向对象语言程序中的对象自动持久化到关系型数据库所使用的数据表中，实现用户对数据库的持久化操作。

在 Hibernate 中，ORM 是指将 Java 对象映射到关系数据库表中，使得开发者可以通过面向对象的方式来操作数据库，而不需要写原始的 SQL 语句。

SessionFactory

SessionFactory 是 Hibernate 的核心接口之一，它是创建 Session 对象的工厂，而且是线程安全的，一般在应用程序启动阶段进行创建，使用者可以随时从 SessionFactory 中获取 Session 对象。

Session

在 Hibernate 中，Session 是指在一个连接中进行一组持久化操作的 API，它提供了基本的 CRUD 操作、数据检索、对象映射、缓存管理等功能。

Transaction

在 Hibernate 中，事务是通过 Transaction 接口来实现的，用于确保一组操作以原子方式执行，同时保证数据一致性和完整性。

// 创建 SessionFactory
Configuration configuration = new Configuration().configure();
SessionFactory sessionFactory = configuration.buildSessionFactory();
// 获取 Session
Session session = sessionFactory.openSession();
// 获取事务对象
Transaction transaction = session.beginTransaction();
try {
    // 执行一些持久化操作
    ...
    // 提交事务
    transaction.commit();
} catch (Exception e) {
    // 回滚事务
    transaction.rollback();
} finally {
    // 关闭 Session
    session.close();
}

2. 对象映射

实体类映射

在 Hibernate 中，实体类是指与数据库表一一对应的 Java 类，它们之间的映射就是对象映射。Hibernate 将实体类中的属性映射为数据库表中的字段，从而可以实现持久化操作。

// 实体类 User 对应数据库表 user
@Entity
@Table(name = "user")
public class User {
    @Id
    @GeneratedValue(strategy = GenerationType.IDENTITY)
    private Long id;
    @Column(name = "username")
    private String username;
    @Column(name = "password")
    private String password;
    ...
}

数据库表映射

在 Hibernate 中，数据库表对象映射为 Java 实体对象，使用 JPA 标准注解来关联数据库表和实体类。

// 数据库表 user 表示用户信息
CREATE TABLE user (
  id BIGINT NOT NULL AUTO_INCREMENT,
  username VARCHAR(255) NOT NULL,
  password VARCHAR(255) NOT NULL,
  PRIMARY KEY (id)
)

属性映射

在 Hibernate 中，每个属性都应该映射到数据库表的一个字段中去，在实体类中使用 @Column 注解，指定对应的字段名称。

@Entity
@Table(name = "user")
public class User {
    ...
    @Column(name = "username")
    private String username;
    @Column(name = "password")
    private String password;
    ...
}

关联关系映射

在 Hibernate 中，不同实体类之间是存在多种关系的，比如一对多、多对一、一对一和多对多等。使用 Hibernate 编写应用程序时，需要在实体类中使用 @ManyToOne、@OneToMany、@OneToOne、@ManyToMany 注解来描述关联关系。

@Entity
@Table(name = "post")
public class Post {
    @Id
    @GeneratedValue(strategy = GenerationType.IDENTITY)
    private Long id;
    ...
    @OneToMany(mappedBy = "post")
    private List<Comment> comments;
    ...
}

@Entity
@Table(name = "comment")
public class Comment {
    @Id
    @GeneratedValue(strategy = GenerationType.IDENTITY)
    private Long id;
    ...
    @ManyToOne
    @JoinColumn(name = "post_id")
    private Post post;
    ...
}

3. HQL语言

HQL的基本语法

Hibernate Query Language（HQL）是用于执行查询和获取持久化对象的语言，它类似于 SQL，但它是面向对象的。

String hql = "FROM User u WHERE u.name = :name";
Query query = session.createQuery(hql);
query.setParameter("name", name);
List<User> users = query.list();

原生SQL查询

除了 HQL 语句之外，Hibernate 也支持原始的 SQL 查询。当需要使用数据库本身的一些特定功能时，可以使用原始的 SQL 查询，而不是 HQL。

String sql = "SELECT * FROM user WHERE name = :name";
Query query = session.createSQLQuery(sql);
query.setParameter("name", name);
List<Object[]> rows = query.list();

参数绑定

在 Hibernate 中，可以使用命名参数或者位参数的方式绑定查询参数，这样更加方便和清晰。

String hql = "FROM User u WHERE u.name = :name";
Query query = session.createQuery(hql);
query.setParameter("name", name);
List<User> users = query.list();

4. 缓存机制

一级缓存和二级缓存

Hibernate 提供了两种缓存机制：一级缓存和二级缓存。

一级缓存是由 Session 实现的，它存储了 Session 中所有持久化的对象，并且在一次 Session 中只有一个一级缓存。它可以通过 session.clear() 或 session.evict() 来清空。

二级缓存是由 SessionFactory 实现的，它是与 Session 无关的缓存，可以被多个 Session 共享。它可以通过配置文件或代码来启用，并且支持多种缓存提供者（如 EHCache、Redis 等）。

缓存策略

在 Hibernate 中，每个实体类都可以具有不同的缓存策略，包括读取、写入、更新和删除等。Hibernate 支持多种缓存策略，开发者可以根据自己的需求进行配置。

@Entity
@Table(name = "user")
@Cacheable
@Cache(usage = CacheConcurrencyStrategy.READ_WRITE)
public class User {
    @Id
    @GeneratedValue(strategy = GenerationType.IDENTITY)
    private Long id;
    ...
}

5. 事务管理

事务的概念

在 Hibernate 中，事务是数据库操作的一个原子单元体，确保所有操作都以一种原子方式执行，要么全部成功，要么全部失败，并且保持数据的完整性和一致性。

事务隔离级别

在 Hibernate 中，事务的隔离级别规定了不同事务之间的可见性程度，包括READ_COMMITTED、READ_UNCOMMITTED、REPEATABLE_READ和SERIALIZABLE等级别，每个隔离级别都有其自己的特点和应用场景。

事务处理的方式

在 Hibernate 中，事务处理有两种方式：编程式事务和声明式事务。编程式事务是通过编写编程代码来开启和管理事务，比较繁琐。而声明式事务是通过注解或配置文件来声明事务的方式，一般使用 Spring AOP 进行实现。

// 编程式事务处理
Transaction tx = null;
try {
    Session session = HibernateUtil.getSessionFactory().getCurrentSession();
    tx = session.beginTransaction();
    ...
    session.save(user);
    tx.commit();
} catch (Exception e) {
    if (tx != null) {
        tx.rollback();
    }
    e.printStackTrace();
}

// 声明式事务处理
@Transactional(rollbackFor = Exception.class)
public void save(User user) {
    ...
    sessionFactory.getCurrentSession().save(user);
    ...
}

6. 操作数据库

增删改查操作

在 Hibernate 中，可以使用 Session 对象提供的保存、更新、删除和查询方法来实现对数据库的增删改查操作。

// 创建 SessionFactory
Configuration configuration = new Configuration().configure();
SessionFactory sessionFactory = configuration.buildSessionFactory();
// 获取 Session
Session session = sessionFactory.openSession();

7.Hibernate和Spring的整合

Hibernate是一个开源的、高性能的ORM框架，而Spring是一个开源的、轻量级的框架。两者的结合，可以将Hibernate管理的对象融入到Spring容器中，轻松实现事物管理等功能。

Spring整合Hibernate有两种方式：

一种是使用HibernateTemplate的方式
另一种是使用注解或XML文件的方式

使用HibernateTemplate的方式：

public class UserDaoImpl extends HibernateDaoSupport implements UserDao {

   public User getById(int id) {

       return getHibernateTemplate().get(User.class, id);

   }
}

以上是一个使用HibernateTemplate的示例代码。这里的HibernateDaoSupport是Spring提供的一个工具类，用于将Hibernate管理的对象融入到Spring的容器中。

使用注解或XML文件的方式：

在Spring的配置文件中，通过配置SessionFactory和事务管理器来实现对Hibernate的整合。在DAO层中则可以使用注解或XML文件的方式定义Hibernate映射文件。例如：

<bean class="org.springframework.orm.hibernate5.LocalSessionFactoryBean">
    <property name="dataSource" ref="dataSource"/>
    <property name="mappingResources">
        <list>
            <value>user.hbm.xml</value>
        </list>
    </property>
    <property name="hibernateProperties">
        <props>
            <prop key="hibernate.dialect">org.hibernate.dialect.MySQL5Dialect</prop>
            <prop key="hibernate.show_sql">true</prop>
            <prop key="hibernate.format_sql">true</prop>
        </props>
    </property>
</bean>

以上是一个使用XML文件配置Hibernate的示例代码。

利用Spring管理Hibernate事务

在使用Spring整合Hibernate的过程中，我们可以利用Spring框架中提供的事务管理机制来管理Hibernate的事务。具体来说，需要使用Spring的Transactional注解或XML配置文件来开启和管理事务。例如：

@Transactional
public void save(User user) {
    Session session = sessionFactory.getCurrentSession()
    session.save(user);
}

8.Hibernate性能优化与调优

在使用Hibernate时，可能会遇到一些性能问题。下面介绍一些Hibernate性能优化和调优的方法：

监控Hibernate查询

可以通过hibernate.show_sql和hibernate.format_sql来开启Hibernate查询的日志信息，便于发现查询的性能问题和调试。

<property name="hibernate.show_sql">true</property>
<property name="hibernate.format_sql">true</property>

以上是一个使用XML文件配置Hibernate查询日志的示例代码。开启后，会在控制台输出Hibernate查询的SQL语句和查询时间等信息。

调整缓存机制

Hibernate提供了三种对象缓存机制：session缓存、二级缓存和查询缓存。可以根据实际情况选择合适的缓存机制，并调整缓存参数以达到最佳性能。例如：

<property name="hibernate.cache.use_second_level_cache">true</property>
<property name="hibernate.cache.region.factory_class">org.hibernate.cache.ehcache.EhCacheRegionFactory</property>

以上是一个使用Ehcache二级缓存的示例代码。这里开启了二级缓存，并配置了Ehcache的缓存工厂。

优化Hibernate查询

可以通过调整Hibernate查询的Fetch Mode、Batch Size和Fetch Join等方式优化查询性能。例如：

public List<User> findAll() {
    Session session = sessionFactory.getCurrentSession();
    Query query = session.createQuery("SELECT u FROM User u");
    query.setFetchMode("department", FetchMode.JOIN);
    query.setFirstResult(0);
    query.setMaxResults(50);
    return query.list();
}

以上是一个使用Hibernate的Fetch Join、Paging和Batch Fetch优化查询的示例代码。在该查询语句中，使用了Fetch Join来获取关联实体，并使用Paging和Batch Fetch限制每次查询的数量和批次大小，提高了查询性能。

本作品采用知识共享署名 4.0 国际许可协议进行许可