Hibernate（13） Hibernate的一级缓存是什么？

Victor3562025-12-31 20:19

Hibernate的一级缓存（First-Level Cache）是Hibernate Session范围内的缓存，默认情况下是启用的。一级缓存只在当前的Session范围内生效，并且无法跨Session共享。一级缓存的主要作用是减少数据库的访问次数，提高应用程序的性能。

主要特点

  1. Session范围内：一级缓存仅在当前Session范围内有效，Session关闭后缓存失效。
  2. 自动启用：一级缓存默认启用，开发者无需额外配置。
  3. 缓存实体：在同一个Session中，多次访问相同的实体时，Hibernate会从缓存中读取，而不是每次都访问数据库。
  4. 事务一致性：一级缓存保证在同一个Session和事务中的数据一致性。

示例项目结构

为了深入理解一级缓存，下面是一个完整的示例，包括如何配置Hibernate文件、定义实体类、以及演示一级缓存的行为。

配置文件 hibernate.cfg.xml

xml 复制代码 
<!DOCTYPE hibernate-configuration PUBLIC
        "-//Hibernate/Hibernate Configuration DTD 3.0//EN"
        "http://hibernate.sourceforge.net/hibernate-configuration-3.0.dtd">
<hibernate-configuration>
    <session-factory>
        <!-- 数据库连接配置 -->
        <property name="hibernate.connection.driver_class">com.mysql.cj.jdbc.Driver</property>
        <property name="hibernate.connection.url">jdbc:mysql://localhost:3306/your_database</property>
        <property name="hibernate.connection.username">your_username</property>
        <property name="hibernate.connection.password">your_password</property>

        <!-- Hibernate 属性配置 -->
        <property name="hibernate.dialect">org.hibernate.dialect.MySQLDialect</property>
        <property name="hibernate.show_sql">true</property>
        <property name="hibernate.format_sql">true</property>
        <property name="hibernate.hbm2ddl.auto">update</property>

        <!-- 映射类配置 -->
        <mapping class="com.example.domain.Student"/>
    </session-factory>
</hibernate-configuration>

HibernateUtil 类

java 复制代码 
import org.hibernate.SessionFactory;
import org.hibernate.cfg.Configuration;

public class HibernateUtil {
    private static final SessionFactory sessionFactory;

    static {
        try {
            // 从配置文件创建SessionFactory
            sessionFactory = new Configuration().configure("hibernate.cfg.xml").buildSessionFactory();
        } catch (Throwable ex) {
            // 记录启动失败的错误
            System.err.println("Initial SessionFactory creation failed." + ex);
            throw new ExceptionInInitializerError(ex);
        }
    }

    public static SessionFactory getSessionFactory() {
        return sessionFactory;
    }
}

实体类 Student

java 复制代码 
package com.example.domain;

import javax.persistence.Entity;
import javax.persistence.GeneratedValue;
import javax.persistence.GenerationType;
import javax.persistence.Id;

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

    public Student() {}

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

    // getters 和 setters
    public Long getId() {
        return id;
    }

    public void setId(Long id) {
        this.id = id;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public int getAge() {
        return age;
    }

    public void setAge(int age) {
        this.age = age;
    }
}

一级缓存示例代码

下面的示例展示了一级缓存的基本行为，包括如何在同一个Session中多次访问同一个实体，以及在不同Session中访问同一个实体。

java 复制代码 
import org.hibernate.Session;
import org.hibernate.SessionFactory;
import org.hibernate.Transaction;

public class HibernateFirstLevelCacheExample {
    public static void main(String[] args) {
        // 获取SessionFactory
        SessionFactory sessionFactory = HibernateUtil.getSessionFactory();
        Session session = null;
        Transaction transaction = null;

        // 向数据库添加一个测试对象
        try {
            session = sessionFactory.openSession();
            transaction = session.beginTransaction();

            Student student = new Student("John Doe", 20);
            session.save(student);

            transaction.commit();
        } catch (Exception e) {
            if (transaction != null) {
                transaction.rollback();
            }
            e.printStackTrace();
        } finally {
            if (session != null) {
                session.close();
            }
        }

        // 演示一级缓存的行为
        try {
            session = sessionFactory.openSession();
            transaction = session.beginTransaction();

            // 第一次查询，发出SQL语句
            Student student = session.get(Student.class, 1L);
            System.out.println("First Query: " + student.getName() + ", Age: " + student.getAge());

            // 第二次查询，从一级缓存中读取，不发出SQL语句
            Student sameStudent = session.get(Student.class, 1L);
            System.out.println("Second Query: " + sameStudent.getName() + ", Age: " + sameStudent.getAge());

            transaction.commit();
        } catch (Exception e) {
            if (transaction != null) {
                transaction.rollback();
            }
            e.printStackTrace();
        } finally {
            if (session != null) {
                session.close();
            }
        }

        // 不同Session中访问同一个实体，发出SQL语句
        try {
            session = sessionFactory.openSession();
            transaction = session.beginTransaction();

            // 新的Session中查询，发出SQL语句
            Student student = session.get(Student.class, 1L);
            System.out.println("New Session Query: " + student.getName() + ", Age: " + student.getAge());

            transaction.commit();
        } catch (Exception e) {
            if (transaction != null) {
                transaction.rollback();
            }
            e.printStackTrace();
        } finally {
            if (session != null) {
                session.close();
            }
        }

        // 关闭SessionFactory
        sessionFactory.close();
    }
}

详细解释

  1. 第一次查询：在同一个Session中，第一次查询会发出SQL语句，从数据库中读取数据。

    java 复制代码 
    // 第一次查询，发出SQL语句
Student student = session.get(Student.class, 1L);
System.out.println("First Query: " + student.getName() + ", Age: " + student.getAge());

  2. 第二次查询：在同一个Session中，第二次查询相同的实体时，Hibernate会从一级缓存中读取数据，不会发出SQL语句。

    java 复制代码 
    // 第二次查询，从一级缓存中读取，不发出SQL语句
Student sameStudent = session.get(Student.class, 1L);
System.out.println("Second Query: " + sameStudent.getName() + ", Age: " + sameStudent.getAge());

  3. 不同Session中的查询：在不同的Session中查询同一个实体时，Hibernate会再次发出SQL语句，因为一级缓存只在当前Session范围内有效。

    java 复制代码 
    // 新的Session中查询，发出SQL语句
Student student = session.get(Student.class, 1L);
System.out.println("New Session Query: " + student.getName() + ", Age: " + student.getAge());

事务管理

在进行数据库操作时，需要开启事务，并在操作完成后提交事务。如果操作失败，则回滚事务以确保数据一致性。

java 复制代码 
Transaction transaction = session.beginTransaction();
try {
    // 持久化操作
    transaction.commit();
} catch (Exception e) {
    if (transaction != null) {
        transaction.rollback();
    }
    e.printStackTrace();
}

总结

Hibernate的一级缓存是Session范围内的缓存，默认情况下是启用的。它通过在同一个Session中缓存实体对象，减少了对数据库的访问，提高了应用程序的性能。通过实际的代码示例，可以看到一级缓存如何在同一个Session中有效地缓存和读取实体对象。理解Hibernate的一级缓存概念，对于优化数据访问和提高应用程序性能具有重要意义。

相关推荐
毕设源码-赖学姐2 小时前
【开题答辩全过程】以 基于SpringBoot的健身房管理系统的设计与实现为例，包含答辩的问题和答案
java·spring boot·后端
Victor3562 小时前
Hibernate（14）什么是Hibernate的二级缓存？
后端
czlczl200209252 小时前
SpringBoot自动配置AutoConfiguration原理与实践
开发语言·spring boot·后端
heartbeat..3 小时前
Servlet 全面解析（JavaWeb 核心）
java·网络·后端·servlet
vx_bisheyuange3 小时前
基于SpringBoot的疗养院管理系统
java·spring boot·后端
京东零售技术3 小时前
2025京东零售技术年度精选 | 技术干货篇（内含福利）
前端·javascript·后端
布列瑟农的星空3 小时前
2025年度总结——认真生活，快乐工作
前端·后端
sunnyday04263 小时前
Spring Boot 项目中使用 Dynamic Datasource 实现多数据源管理
android·spring boot·后端
晴虹4 小时前
lecen：一个更好的开源可视化系统搭建项目--页面设计器(表单设计器)--全低代码|所见即所得|利用可视化设计器构建你的应用系统-做一个懂你的人
前端·后端·低代码
热门推荐
01GitHub 镜像站点02从快手“12·22”直播攻击事件看：一次教科书式的业务层饱和攻击03Linux下V2Ray安装配置指南04Claude Code Skills 实用使用手册05jdk21下载、安装（Windows、Linux、macOS）06UV安装并设置国内源07电脑检测软件—图吧工具箱082025 最新教程：注册并切换到美区 Apple ID09Google Antigravity Agent 编辑器操作教程10【踩坑笔记】50系显卡适配的 PyTorch 安装