Hibernate 基本操作、懒加载以及缓存

最新推荐文章于 2024-09-06 03:15:34 发布
最新推荐文章于 2024-09-06 03:15:34 发布
阅读量560 收藏
点赞数 1
文章标签： hibernate 缓存 java
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/BASK2311/article/details/130620304
版权

基本的 CRUD

以下代码均写在测试类 HibernateTest 中

插入操作

这个在上一篇已经演示过，这里便不再演示。

查询操作

查询有 2 种方式，通过 Session 对象的 get 方法 或者 load 方法来实现查询，主要将查询的数据结果封装到一个 Java 对象中。

  1. get 方法
    @Test
    public void queryByGet() {
        // 获取 Session 对象
        Session session = HibernateUtil.getSession();
        try {
            // 使用 get() 方法，第一个参数是持久化类的类型参数，第二个参数是主键标识参数，如果没有匹配的记录，那么会返回 null
            User user = session.get(User.class, new Integer("1"));
            System.out.println("用户ID：" + user.getId());
        } catch (Exception e) {
            System.out.println("查询User数据失败！");
            e.printStackTrace();
        } finally{
            // 关闭 Session 对象
            HibernateUtil.closeSession();
        }
    }
复制代码

控制台输出：可以看到，执行了查询 SQL，并打印了用户 ID。

INFO: HHH000400: Using dialect: org.hibernate.dialect.MySQLDialect
五月 08, 2023 11:38:59 下午 org.hibernate.engine.transaction.jta.platform.internal.JtaPlatformInitiator initiateService
INFO: HHH000490: Using JtaPlatform implementation: [org.hibernate.engine.transaction.jta.platform.internal.NoJtaPlatform]
Hibernate: 
    select
        user0_.id as id1_0_0_,
        user0_.name as name2_0_0_,
        user0_.password as password3_0_0_ 
    from
        user user0_ 
    where
        user0_.id=?
用户ID：1

复制代码
  1. load 方法
    @Test
    public void queryByLoad() {
        // 获取 Session 对象
        Session session = HibernateUtil.getSession();
        try {
            // 使用 load() 方法，它返回对象的代理，只有该代理被调用时，Hibernate 才会真正去执行 SQL 查询
            User user = session.load(User.class, new Integer("1"));
            // ID 是已知的，不用进行查询
            System.out.println("用户ID：" + user.getId());
            // 此时该代理被调用，就执行 SQL 语句，得到真正的数据记录
            System.out.println("用户名称：" + user.getName());
        } catch (Exception e) {
            System.out.println("查询User数据失败！");
            e.printStackTrace();
        } finally{
            // 关闭 Session 对象
            HibernateUtil.closeSession();
        }
    }
复制代码

控制台输出：

五月 08, 2023 11:40:13 下午 org.hibernate.dialect.Dialect <init>
INFO: HHH000400: Using dialect: org.hibernate.dialect.MySQLDialect
五月 08, 2023 11:40:14 下午 org.hibernate.engine.transaction.jta.platform.internal.JtaPlatformInitiator initiateService
INFO: HHH000490: Using JtaPlatform implementation: [org.hibernate.engine.transaction.jta.platform.internal.NoJtaPlatform]
用户ID：1
Hibernate: 
    select
        user0_.id as id1_0_0_,
        user0_.name as name2_0_0_,
        user0_.password as password3_0_0_ 
    from
        user user0_ 
    where
        user0_.id=?
用户名称：god23bin

复制代码

可以看到，是先打印用户ID的，这里还没有执行查询 SQL，直到下一条语句中的 user.getName() 的执行，查询的 SQL 语句才被 Hibernate 执行。

修改操作

想对某条数据进行修改操作，那么需要将它先查询出来，然后进行修改。这里就执行了两条 SQL，保险起见，开启事务，然后执行这两条 SQL，接着提交事务。当然，这两条 SQL，Hibernate 帮我们写的啦！

    @Test
    public void update() {
        // 获取 Session 对象
        Session session = HibernateUtil.getSession();
        try {
            // 开启事务
            session.beginTransaction();
            // 进行查询，将结果封装成 user 对象
            User user = session.get(User.class, new Integer("1"));
            // 对 user 对象进行修改
            user.setName("公众号：god23bin");
            user.setPassword("456789");
            // 提交事务
            session.getTransaction().commit();
        } catch (Exception e) {
            // 发生异常，则回滚事务
            session.getTransaction().rollback();
            System.out.println("修改User数据失败！");
            e.printStackTrace();
        } finally{
            // 关闭 Session 对象
            HibernateUtil.closeSession();
        }
    }
复制代码

控制台输出：

五月 09, 2023 12:00:16 上午 org.hibernate.dialect.Dialect <init>
INFO: HHH000400: Using dialect: org.hibernate.dialect.MySQLDialect
五月 09, 2023 12:00:17 上午 org.hibernate.engine.transaction.jta.platform.internal.JtaPlatformInitiator initiateService
INFO: HHH000490: Using JtaPlatform implementation: [org.hibernate.engine.transaction.jta.platform.internal.NoJtaPlatform]
Hibernate: 
    select
        user0_.id as id1_0_0_,
        user0_.name as name2_0_0_,
        user0_.password as password3_0_0_ 
    from
        user user0_ 
    where
        user0_.id=?
Hibernate: 
    update
        user 
    set
        name=?,
        password=? 
    where
        id=?
        
复制代码

可以看到运行前和运行后，数据的变化，如图：

如果屏幕前的小伙伴是按照我的步骤一步一步跟下来，那么你可能会遇到中文乱码的问题，此时需要在 hibernate.cfg.xml 配置文件中修改 URL，加上两个参数 useUnicode=true&characterEncoding=UTF-8，如下：

<property name="connection.url">jdbc:mysql://localhost:3306/demo_hibernate?useUnicode=true&amp;characterEncoding=UTF-8</property>

删除操作

删除操作需要先把数据查询出来，然后通过 Session 对象的 delete 方法将其删除。代码如下：

    @Test
    public void delete() {
        // 获取 Session 对象
        Session session = HibernateUtil.getSession();
        try {
            session.beginTransaction();
            User user = session.get(User.class, new Integer("1"));
            // 删除操作
            session.delete(user);
            session.getTransaction().commit();
        } catch (Exception e) {
            session.getTransaction().rollback();
            System.out.println("删除User数据失败！");
            e.printStackTrace();
        } finally{
            // 关闭 Session 对象
            HibernateUtil.closeSession();
        }
    }
复制代码

控制台输出：

五月 09, 2023 12:10:09 上午 org.hibernate.dialect.Dialect <init>
INFO: HHH000400: Using dialect: org.hibernate.dialect.MySQLDialect
五月 09, 2023 12:10:10 上午 org.hibernate.engine.transaction.jta.platform.internal.JtaPlatformInitiator initiateService
INFO: HHH000490: Using JtaPlatform implementation: [org.hibernate.engine.transaction.jta.platform.internal.NoJtaPlatform]
Hibernate: 
    select
        user0_.id as id1_0_0_,
        user0_.name as name2_0_0_,
        user0_.password as password3_0_0_ 
    from
        user user0_ 
    where
        user0_.id=?
Hibernate: 
    delete 
    from
        user 
    where
        id=?

复制代码

关于 Hibernate 中对象的状态

在Hibernate中，对象的状态有 4 种，分别为 Transient、Persistent、Detached、Removed，译名就比较多，方便起见，我选择 3 个字的译名：

  1. 瞬时态（Transient）：当一个对象被实例化后，它处于瞬时态，简单理解，就是 new 操作之后。瞬时态的对象没有与之关联的数据库记录，并且没有被 Hibernate 的 Session 管理。当将瞬时态的对象关联到持久态对象或通过 Session 对象的 save、persist 等方法进行持久化操作后，该对象的状态会发生变化，转成持久态。
  2. 持久态（Persistent）：当一个对象与 Hibernate 的 Session 关联后，它就处于持久态。持久态的对象有与之对应的数据库记录，并且被 Hibernate 的 Session 管理。对持久态对象的任何更改都会自动同步到数据库。持久态对象可以通过Session的 get、load 等方法从数据库中获取，或者通过 save、update、persist 等方法进行持久化操作。
  3. 游离态（Detached）：当一个持久态对象与 Hibernate 的 Session 分离后，它处于游离态。游离态的对象仍然有与之对应的数据库记录，但不再受 Hibernate 的 Session 管理。对游离态对象的更改不会自动同步到数据库。可以通过 Session 的 evict、clear 等方法将持久态对象转变为游离态对象，或者通过 Session 的 merge 方法将游离态对象重新关联到 Session 中。
  4. 删除态（Removed）：当一个持久态对象被从 Hibernate 的 Session中删除后，它处于删除态。删除态的对象仍然有与之对应的数据库记录，但即将被从数据库中删除。删除态对象可以通过 Session 的delete 方法进行删除操作。

Hibernate 通过跟踪对象的状态变化，实现了对象与数据库的同步。在 Hibernate 的事务管理中，对象的状态转换是自动进行的，我们无需手动操作，Hibernate 会根据对象的状态进行相应的数据库操作，保证对象与数据库的一致性。

需要注意的是，Hibernate 的对象状态与数据库的操作并不是一一对应的，Hibernate 提供了一系列的持久化方法和操作，我们可以根据具体的需求选择合适的方法来进行对象状态的转换和数据库操作。对于复杂的业务逻辑和数据处理，需要仔细理解和管理对象的状态，以避免数据不一致的问题。

懒加载

Hibernate 的懒加载（Lazy Loading）是一种延迟加载策略，它允许程序在需要访问相关数据时才从数据库中加载关联对象的属性或集合。

在 Hibernate 中，懒加载是通过使用代理对象来实现的。实际上，我们在演示 Session 对象的 load() 方法时，就是懒加载了，一开始返回的是代理对象，并没有直接查询数据库，而是直到该代理对象的属性或方法被调用时，Hibernate 会根据需要自动执行额外的数据库查询，从而延迟加载关联的数据。

这就是懒加载，等到需要的时候才去加载。

懒加载的主要优点是可以提高系统性能和减少不必要的数据库查询。如果一个对象关联的属性或集合在业务逻辑中很少被使用，懒加载可以避免不必要的数据库访问，减轻数据库负载。

除了 load 方法实现的懒加载，我们还可以通过设置映射文件中的 <property> 标签的 lazy 属性实现懒加载：

<property name="name" type="string" lazy="true" /> <!-- name 属性被设置成懒加载-->
复制代码

缓存

缓存是一种临时存储数据的方式，将数据保存在更快速的存储介质（如内存）中，以便将来能够快速访问和检索。

Hibernate 提供了缓存的技术，主要用于存储实体对象以及查询的结果集。缓存分为一级缓存（Session 缓存）和二级缓存（Session Factory 缓存）。

一级缓存

一级缓存是与 Session 相关联的缓存，它存储了从数据库中读取的实体对象。在同一个 Session 中，当多次查询相同的数据时，Session 首先会根据对应的持久化类和唯一性标识（一般指的是ID）去缓存中查找是否存在该数据。如果存在，则直接从缓存中获取，而不再访问数据库；如果不存在，则继续向二级缓存种查找。

一级缓存是默认开启的，可以提高读取性能。

示例：

    @Test
    public void testFirstLevelCache() {
        Session session = HibernateUtil.getSession();
        try {
            System.out.println("第一次查询：");
            User user = session.get(User.class, new Integer("2"));
            System.out.println("用户名：" + user.getName());
            
            System.out.println("第二次查询：");
            User user2 = session.get(User.class, new Integer("2"));
            System.out.println("用户名：" + user2.getName());
        } catch (Exception e) {
            System.out.println("查询User数据失败！");
            e.printStackTrace();
        } finally{
            // 关闭 Session 对象
            HibernateUtil.closeSession();
        }
    }
复制代码

控制台输出：

五月 09, 2023 9:35:31 下午 org.hibernate.dialect.Dialect <init>
INFO: HHH000400: Using dialect: org.hibernate.dialect.MySQLDialect
五月 09, 2023 9:35:32 下午 org.hibernate.engine.transaction.jta.platform.internal.JtaPlatformInitiator initiateService
INFO: HHH000490: Using JtaPlatform implementation: [org.hibernate.engine.transaction.jta.platform.internal.NoJtaPlatform]
第一次查询：
Hibernate: 
    select
        user0_.id as id1_0_0_,
        user0_.name as name2_0_0_,
        user0_.password as password3_0_0_ 
    from
        user user0_ 
    where
        user0_.id=?
用户名：god23bin
第二次查询：
用户名：god23bin

复制代码

可以看到，第二次查询是没有执行 SQL 的，直接从一级缓存中获取。

二级缓存

二级缓存是在 SessionFactory 级别上的缓存，用于缓存多个 Session 之间共享的数据。它可以减少对数据库的访问次数，提高性能和扩展性。二级缓存可以存储实体对象、集合对象以及查询结果集。

由于 Hibernate 本身并未提供二级缓存的具体实现，所以需要借助其他缓存插件或者说策略来实现二级缓存。比如 Ehcache、Redis 等。

我们这里直接使用 Ehcache。

  1. 引入依赖项
<dependency>
    <groupId>org.hibernate</groupId>
    <artifactId>hibernate-ehcache</artifactId>
    <version>5.6.14.Final</version>
</dependency>

<dependency>
    <groupId>net.sf.ehcache</groupId>
    <artifactId>ehcache</artifactId>
    <version>2.10.0</version>
</dependency>
复制代码
  1. 开启二级缓存

二级缓存默认是关闭的，我们需要手动开启。在 hibernate.cfg.xml 中开启二级缓存：

<?xml version="1.0" encoding="UTF-8"?>
        <!DOCTYPE hibernate-configuration PUBLIC "-//Hibernate/Hibernate Configuration DTD 3.0//EN"
                "http://www.hibernate.org/dtd/hibernate-configuration-3.0.dtd">
<hibernate-configuration>
    <session-factory>
		...
        <!-- 开启二级缓存 -->
        <property name="hibernate.cache.use_second_level_cache">true</property>
        <!-- 开启查询缓存 -->
        <property name="hibernate.cache.use_query_cache">true</property>
        <!-- 指定使用的缓存实现类 -->
        <property name="hibernate.cache.region.factory_class">org.hibernate.cache.ehcache.internal.SingletonEhcacheRegionFactory</property>
    </session-factory>
</hibernate-configuration>
复制代码
  1. 创建缓存配置文件

我们在 /src/main/resources 目录下创建缓存配置文件 ehcache.xml：

<?xml version="1.0" encoding="UTF-8"?>
<ehcache xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
         xsi:noNamespaceSchemaLocation="http://ehcache.org/ehcache.xsd"
         updateCheck="false">

    <!-- 硬盘存储：将缓存中暂时不使用的对象，持久化到硬盘 -->
    <!-- path 属性：指定在硬盘上存储对象的路径 -->
    <!-- java.io.tmpdir 是默认的临时文件路径。 可以通过右边的方式打印出具体的文件路径： System.out.println(System.getProperty("java.io.tmpdir")); -->
    <diskStore path="java.io.tmpdir"/>


    <!-- defaultCache：默认的缓存策略 -->
    <!-- eternal 属性：设定缓存的elements是否永远不过期。如果为true，则缓存的数据始终有效，如果为false那么还要根据timeToIdleSeconds，timeToLiveSeconds判断 -->
    <!-- maxElementsInMemory 属性：在内存中缓存的element的最大数目 -->
    <!-- overflowToDisk 属性：如果内存中数据超过内存限制，是否要缓存到硬盘上 -->
    <!-- diskPersistent 属性：是否在硬盘上持久化。指重启 JVM 后，数据是否有效。默认为false -->
    <!-- timeToIdleSeconds 属性：对象空闲时间(单位：秒)，指对象在多长时间没有被访问就会失效。只对eternal为false的有效。默认值0，表示一直可以访问 -->
    <!-- timeToLiveSeconds 属性：对象存活时间(单位：秒)，指对象从创建到失效所需要的时间。只对eternal为false的有效。默认值0，表示一直可以访问 -->
    <!-- memoryStoreEvictionPolicy 属性：缓存的 3 种清除策略，因为缓存区域是一定的，满了之后就需要清除不需要的数据 -->
    <!-- 1. FIFO：first in first out (先进先出). 先缓存的数据会先被清除-->
    <!-- 2. LFU：Less Frequently Used (最少使用).意思是一直以来最少被使用的。缓存的元素有一个 hit 属性，hit 值最小的将会被清除 -->
    <!-- 3. LRU：Least Recently Used(最近最少使用). (ehcache 默认值).缓存的元素有一个时间戳，当缓存容量满了，而又需要腾出地方来缓存新的元素的时候，那么现有缓存元素中时间戳离当前时间最远的元素将被清除 -->

    <defaultCache eternal="false"
                  maxElementsInMemory="1000"
                  overflowToDisk="false"
                  diskPersistent="false"
                  timeToIdleSeconds="0"
                  timeToLiveSeconds="600"
                  memoryStoreEvictionPolicy="LRU"/>

    <!-- name： Cache的名称，必须是唯一的(ehcache会把这个cache放到HashMap里)-->
    <cache name="userCache"
           eternal="false"
           maxElementsInMemory="100"
           overflowToDisk="false"
           diskPersistent="false"
           timeToIdleSeconds="0"
           timeToLiveSeconds="300"
           memoryStoreEvictionPolicy="LRU"/>
</ehcache>

复制代码
  1. 在持久化类的映射文件中指定缓存策略

User.hbm.xml：

<?xml version='1.0' encoding='utf-8'?>
<!DOCTYPE hibernate-mapping PUBLIC
        "-//Hibernate/Hibernate Mapping DTD 3.0//EN"
        "http://www.hibernate.org/dtd/hibernate-mapping-3.0.dtd">
<hibernate-mapping>
    <class name="cn.god23bin.demo.domain.entity.User" table="user">
        <!-- 指定缓存策略 -->
        <cache usage="read-only"/>
		...
    </class>
</hibernate-mapping>
复制代码

测试二级缓存：

    @Test
    public void testSecondLevelCache() {
        Session session1 = HibernateUtil.getSession();
        Session session2 = HibernateUtil.getSession();
        try {
            System.out.println("第一个 Session 去查询数据并封装成对象");
            User user1 = session1.get(User.class, new Integer("2"));
            System.out.println("用户名：" + user1.getName());

            System.out.println("第二个 Session 去查询同一数据并封装成对象");
            User user2 = session2.get(User.class, new Integer("2"));
            System.out.println("用户名：" + user1.getName());
        } catch (Exception e) {
            System.out.println("查询User数据失败！");
            e.printStackTrace();
        } finally{
            // 关闭 Session 对象
            HibernateUtil.closeSession();
        }
    }
复制代码

控制台输出：

五月 09, 2023 11:18:31 下午 org.hibernate.engine.transaction.jta.platform.internal.JtaPlatformInitiator initiateService
INFO: HHH000490: Using JtaPlatform implementation: [org.hibernate.engine.transaction.jta.platform.internal.NoJtaPlatform]
第一个 Session 去查询数据并封装成对象
Hibernate: 
    select
        user0_.id as id1_0_0_,
        user0_.name as name2_0_0_,
        user0_.password as password3_0_0_ 
    from
        user user0_ 
    where
        user0_.id=?
用户名：god23bin
第二个 Session 去查询同一数据并封装成对象
用户名：god23bin
复制代码

总结

本篇文章主要讲了基本的 CRUD 操作，都是通过 Session 去操作的，根据一个持久化类的类型以及一个唯一标识进行相关操作，然后讲了 Hibernate 中的对象的状态，有 4 种，分别是瞬时、持久、游离、删除。

接着说了 Hibernate 的懒加载，有利于降低数据库的开销，当然缓存也是，除了加快我们的访问速度，也降低了直接访问数据库的开销，缓存就两种，一级和二级，一级默认是开启的，二级需要引入相关的依赖项，然后进行配置，开启二级缓存，配置缓存策略。

这里附上整个项目的目录结构，便于对照：

以上，就是本篇的内容，这些都应该掌握。咱们下期再见。

最后的最后

希望各位屏幕前的靓仔靓女们给个三连！你轻轻地点了个赞，那将在我的心里世界增添一颗明亮而耀眼的星！

咱们下期再见！

作者：god23bin
链接：https://juejin.cn/post/7231519213893779514

「已注销」
关注
Hibernate二级缓存配置与分析
02-07
学习hibernate的必备，提供一个简易的流程图，方便记忆和查找
Hibernate一级缓存和二级缓存详解
08-26
只要应用程序通过Session接口来执行保存、更新、删除、加载和查询数据库数据的操作，Hibernate就会启用第一级缓存，把数据库中的数据以对象的形式拷贝到缓存中，对于批量更新和批量删除操作，如果不希望启用第一级...
hibernate懒加载
fyqcdbdx的专栏
11-14 398
所谓懒加载(lazy)就是延时加载，延迟加载。 什么时候用懒加载呢，我只能回答要用懒加载的时候就用懒加载。 至于为什么要用懒加载呢，就是当我们要访问的数据量过大时，明显用缓存不太合适， 因为内存容量有限 ，为了减少并发量，减少系统资源的消耗， 我们让数据在需要的时候才进行加载，这时我们就用到了懒加载。 比如部门ENTITY和员工ENTITY,部门与员工1对多，如果lazy设置为
fluentd 简介，日志收集并导入BigQuery
最新发布
nvd11的专栏
09-06 1169
Fluentd 是一个开源的数据收集器，旨在实现日志数据的统一收集、处理和转发。它支持多种数据源和数据格式，并具有灵活性和可扩展性，使得在大规模分布式系统中处理日志数据变得更加容易。以下是 Fluentd 的一些关键特点和优势：多源数据收集：Fluentd 支持从各种数据源收集数据，包括日志文件、系统日志、应用程序日志、传感器数据等。数据格式转换：Fluentd 可以将不同格式的数据转换为统一的格式，使其更容易进行处理和分析。
Hibernate缓存配置
iteye_9118的博客
01-15 133
Hibernate的缓存分为： 一级缓存：在Session级别的，在Session关闭的时候，一级缓存就失效了。 二级缓存：在SessionFactory级别的，它可以使用不同的缓存实现，如EhCache、JBossCache、OsCache等。 缓存的注释写法如下，加在Entity的java类上： @Cache(usage = CacheConcurrencyStra...
hibernate的懒加载
abcdefghwelcome的博客
11-03 1868
在之前的基础上测试懒加载与普通加载的区别冬眠的懒加载 对象的三种状态对于Hibernate而言，对象的状态分为3种： 1）暂时态当对象刚创建，和会话没有发生任何关系时，当程序运行完就立刻消失，被称为暂时态。 2）持久态当执行如下代码时，对象变为持久态Emp e = new Emp（）; session.save（）; 持久态的对象和会话发生了关系，如执行了保存，获取，查询等方法 Ses...
java-web hibernate中的懒加载问题
zhouguosen_always的专栏
08-18 2334
1.延迟加载机制 延迟加载机制是为了避免一些无谓的性能开销而提出来的，所谓延迟加载就是当在真正需要数据的时候，才真正执行数据加载操作。在Hibernate中提供了对实体对象的延迟加载以及对集合的延迟加载，另外在Hibernate3中还提供了对属性的延迟加载。 实体对象的延迟加载：如果想对实体对象使用延迟加载，必须要在实体的映射配置文件中进行相应的配置， 通过将class的la
集成spring的hibernate懒加载
03-22
7. **使用`@Transactional(readOnly = true)`**：对于只读操作，可以使用只读事务，这样即使在Session关闭后，仍能安全地访问懒加载属性，因为只读事务不会开启二级缓存。 在实际项目中，选择合适的策略需要综合...
浅析Java的Hibernate框架中的缓存和延迟加载机制
09-03
主要介绍了Java的Hibernate框架中的缓存和延迟加载机制,Hibernate是注明的Java下SSH三大web开发框架之一,需要的朋友可以参考下
Hibernate一级缓存、二级缓存以及查询缓存实例
12-07
本文将深入探讨Hibernate的一级缓存、二级缓存以及查询缓存，通过具体的实例来阐述它们的工作原理和使用方法。 首先，我们从一级缓存开始。一级缓存是Hibernate默认提供的缓存，它是每个Session级别的，也被称为...
hibernate 懒加载
Zzrdark_的博客
01-15 400
今天博主遇到了问题了~ 问题是这样的 我写了一个DepartmengDao的一个类，内部包装了一个HibernateTemplate  ，在DepartmengDao里写一个方法的时候，我要获取一个属性， xxx = hibernateTemplate.load(XXX.class,Serializable id); xxx.getName(); 博主当执行到第二句的时候就开始爆了一个错
hibernate处理懒加载实例
zz410675629的专栏
06-18 547
"http://hibernate.sourceforge.net/hibernate-mapping-3.0.dtd"> lazy="false"> --> lazy="false> lazy="false>
Hibernate 缓存配置
是大毛啊的博客
11-13 322
一级缓存 1.Hibernate默认开启一级缓存（session） 运行结果：（第一次查询后将数据存入一级缓存【session】------第二次查询先进入session查找有没有数据，有数据直接带回【没有数据才会去数据库拿数据】，所以这里只有出现一条sql语句） 2.清空一级缓存【session】中的数据 运行结果： 第一次查询后，将数据存入一级缓存【session...
hibernate缓存配置
lzy295481710的专栏
03-10 684
1.这种问题在面试中遇到过多次了，所以特意总结了一下。 hibernate缓存分为两种： 一级缓存： hibernate缓存由session提供，在session的生命周期内有效。 二级缓存： 二级缓存需要自己手动配置，我们需要再spring配置文件中配置： true《设置缓存机制为二级缓存》 true《启动查询缓存》 org.hibernate.cache.ehcache.EhC
hibernate 懒加载_Hibernate懒/急加载示例
最佳 Java 编程
06-03 244
hibernate 懒加载 这篇文章将重点讨论为什么以及如何在应用程序中使用称为LAZY和EAGER加载的概念，以及如何使用Spring的Hibernate模板以EAGER方式加载LAZY实体。 当然，正如标题本身所暗示的那样，我们将通过一个示例来说明这一点。 场景就是这样； 您是一个有很多玩具的孩子的父母。 但是当前的问题是，只要您打电话给他（我们假设您有一个男孩），他也会带着所有玩具...
Hibernate学习2 - 懒加载（延迟加载）、动态SQL参数、缓存
weixin_39651356的博客
06-17 854
Hibernate学习2 - 懒加载（延迟加载）、动态SQL参数、缓存
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值