hibernate一级缓存详解

最新推荐文章于 2023-04-11 11:52:47 发布
最新推荐文章于 2023-04-11 11:52:47 发布
阅读量3k 收藏 2
点赞数
分类专栏： JPA/Hibernate 文章标签： hibernate 一级缓存
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/zmx729618/article/details/51280219
版权

一级缓存的生命周期和session的生命周期一致，当前sessioin一旦关闭，一级缓存就消失，session间不能共享一级缓存的数据，因此一级缓存也叫session级的缓存或事务级缓存。一级缓存只存实体对象的 ，它不会缓存一般的对象属性（查询缓存可以），即当获得对象后，就将该对象的缓存起来，如果在同一session中如果再去获取这个对象时，它会先判断缓存中有没有该对象的id，如果有就直接从缓存中取出，反之则去数据库中取，取的同时将该对象的缓存起来，有以下方法可以支持一级缓存：
•get()
•save()
•load()
•iterate（查询实体对象）

Query和Criteria的list()和uniqueResult()只会写缓存，但不会从缓存中读取（除非结合查询缓存）。一级缓存无法取消，但可以管理，可以使用session.clear()、session.evict()清除或驱逐。

 

以下对hibernate的一级缓存进行代码测试：hibernate.cfg.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.url"> jdbc:mysql://localhost/hibernate_testcache </property>
    <property name="hibernate.connection.driver_class"> com.mysql.jdbc.Driver</property> 
    <property name="hibernate.connection.username">root</property>
    <property name="hibernate.connection.password">root</property> 
    <property name="hibernate.dialect"> org.hibernate.dialect.MySQLDialect </property> 
    <property name="hibernate.show_sql">true</property> 
    <mapping resource="com/sunyzc/hibernate/testcache/User.hbm.xml"/>
  </session-factory>
</hibernate-configuration>

实体Bean：User.java
package

com.sunyzc.hibernate.testcache; 
 

public class User {

  private int id;
 
  private String name;

 
  //getters、setters


}

User.hbm.xml
 
<?xml version="1.0"?>
 
<!DOCTYPE hibernate-mapping PUBLIC "-//Hibernate/Hibernate Mapping DTD 3.0//EN"  "http://hibernate.sourceforge.net/hibernate-mapping-3.0.dtd">

<hibernate-mapping>

  <class name="com.sunyzc.hibernate.testcache.User" table="t_user">

    <id name="id">
 
      <generator class="native"/>

    </id>

    <property name="name" column="name" type="java.lang.String"/>
 
  </class>

 
</hibernate-mapping>

创建表的工具：ExportDB.java


package com.sunyzc.hibernate.testcache;

 
import org.hibernate.cfg.Configuration;
 
import org.hibernate.tool.hbm2ddl.SchemaExport;


public class ExportDB {


 
  public static  void main(String[] args) {


    //读取hibernate.cfg.xml文件

    Configuration cfg = new Configuration().configure();
 
    SchemaExportexport = new SchemaExport(cfg);

    export.create(true,true); 
  }
 
}

HibernateUtils.java


 
package com.sunyzc.hibernate.testcache;


 
import org.hibernate.Session;
 
import org.hibernate.SessionFactory;
 
import org.hibernate.cfg.Configuration;


 
public class HibernateUtils {
 
  private static SessionFactory factory;


  static{
 
    try{
 
      factory = new Configuration().configure().buildSessionFactory();
 
    }catch(Exception e) {
 
      e.printStackTrace(); 
    } 
  }


 
  public static Session getSession() {

    return factory.openSession(); 
  }


 
  public static void closeSession(Session session) {
 
    if(session != null&& session.isOpen()) { 
      session.close(); 
    }
  }
}

 

测试1：在同一个session中发出两次load查询


public void testCache1() {

  Session session = null;
 
  try{
 
    session= HibernateUtils.getSession();
    session.beginTransaction();
    User user = (User) session.load(User.class,1);
    System.out.println("user.name="+ user.getName());

    //不会发出sql，因为load使用缓存 
    user= (User) session.load(User.class,1);
 
    System.out.println("user.name="+ user.getName());
 
    session.getTransaction().commit(); 
  }catch(Exception e) {
 
    e.printStackTrace(); 
    session.getTransaction().rollback(); 
  }
finally

{ 
    HibernateUtils.closeSession(session);
 
  }
 
}

输出结果：


Hibernate: select user0_.id as id0_0_, user0_.name as name0_0_ from t_user user0_ where user0_.id=?
 user.name=user0
 user.name=user0


测试2：在同一个session中发出两次get查询

 

public void testCache2() {
 
  Session session = null; 
  try{
    session= HibernateUtils.getSession();
 
    session.beginTransaction();
 
    User user = (User) session.get(User.class,1);
 
    System.out.println("user.name="+ user.getName());

    //不会发出sql，因为get使用缓存
 
    user = (User) session.get(User.class,1);
 
    System.out.println("user.name="+ user.getName());
 
    session.getTransaction().commit();
 
  }catch(Exception e) {
 
    e.printStackTrace();
 
    session.getTransaction().rollback(); 
  }finally{
 
    HibernateUtils.closeSession(session);

  }
 
}

输出结果：


Hibernate: select user0_.id as id0_0_, user0_.name as name0_0_ from t_user user0_ where user0_.id=?
 user.name=user0
 user.name=user0

 

测试3：在同一个session中发出两次iterate查询实体对象

public void testCache3() {
 
  Session session = null; 
  try{
    session= HibernateUtils.getSession();
    session.beginTransaction(); 
    String hql = "from User u where u.id=1"; 
    User user = (User) session.createQuery(hql).iterate().next(); 
    System.out.println("user.name="+ user.getName());

    //会发出查询id的sql，不会发出查询实体对象的sql，因为iterate使用缓存

    user= (User) session.createQuery(hql).iterate().next();

    System.out.println("user.name="+ user.getName());
 
    session.getTransaction().commit(); 
  }catch(Exception e) {
 
    e.printStackTrace();

    session.getTransaction().rollback(); 
  }finally{
 
    HibernateUtils.closeSession(session);
 
  }
 
}

输出结果：


 Hibernate: select user0_.id as col_0_0_ from t_user user0_ where user0_.id=1
 Hibernate: select user0_.id as id0_0_, user0_.name as name0_0_ from t_user user0_ where user0_.id=?
 user.name=user0
 Hibernate: select user0_.id as col_0_0_ from t_user user0_ where user0_.id=1
 user.name=user0

 

测试4：在通一个session中发出两次uniqueResult查询实体对象不会缓存，如果第一次用uniqueResult 第二次用iterate查询是会缓存的


 
public void testCache4() {
 
  Session session = null;
 
  try{
    session = HibernateUtils.getSession();
 
    session.beginTransaction();
 
    String hql = "from User u where u.id=1";
 
    User user = (User) session.createQuery(hql).uniqueResult();
 
    System.out.println("user.name="+ user.getName());
 
    user= (User) session.createQuery(hql).uniqueResult();
 
    System.out.println("user.name="+ user.getName());
 
    session.getTransaction().commit();
 
  }catch(Exception e) {

    e.printStackTrace();
    session.getTransaction().rollback(); 
  }finally{

    HibernateUtils.closeSession(session);
 
  }


18
}

输出结果：


 Hibernate: select user0_.id as id0_, user0_.name as name0_ from t_user user0_ where user0_.id=1
 user.name=user0
 Hibernate: select user0_.id as id0_, user0_.name as name0_ from t_user user0_ where user0_.id=1
 user.name=user0

 

测试5：在同一个session中发出两次list查询实体对象不会缓存


public void testCache4() {
 
  Session session = null; 
  try{ 
    session= HibernateUtils.getSession(); 
    session.beginTransaction();
    List list = session.createQuery("from User u").list();
 
    System.out.println("user.name="+ list.get(0).getName());
 
    list= session.createQuery("from User u").list();
 
    System.out.println("user.name="+ list.get(0).getName()); 
    session.getTransaction().commit();
 
  }catch(Exception e) {
 
    e.printStackTrace(); 
    session.getTransaction().rollback(); 
  }finally{

    HibernateUtils.closeSession(session);
 
  }
 
}

输出结果：


 Hibernate: select user0_.id as id0_, user0_.name as name0_ from t_user user0_
 user.name=user0
 Hibernate: select user0_.id as id0_, user0_.name as name0_ from t_user user0_
 user.name=user0

 

测试6：在同一个session中发出两次iterate查询普通属性不会缓存

 
public void testCache4() {

  Session session = null;
 
  try{ 
    session= HibernateUtils.getSession();

    session.beginTransaction();
 
    String hql = "select u.name from User u where u.id=1";
 
    String name = (String) session.createQuery(hql).iterate().next();

    System.out.println("user.name="+ name);
 
    //iterate查询普通属性，一级缓存不会缓存，所以发出sql
 
    //一级缓存是缓存实体对象的
 
    name = (String) session.createQuery(hql).iterate().next();
 
    System.out.println("user.name="+ name);
 
    session.getTransaction().commit(); 
  }catch(Exception e) {
 
    e.printStackTrace();
 
    session.getTransaction().rollback();
 
  }finally{
 
    HibernateUtils.closeSession(session);
 
  }
 
}

输出结果：


 Hibernate: select user0_.name as col_0_0_ from t_user user0_ where user0_.id=1
 user.name=user0
 Hibernate: select user0_.name as col_0_0_ from t_user user0_ where user0_.id=1
 user.name=user0


 

测试7：开启两个session中发出load查询
 
public void testCache7() {
 
  Session session1 = null; 
  Session session2 = null; 
  try{
 
    session1 = HibernateUtils.getSession();
 
    session2 = HibernateUtils.getSession();
 
    session1.beginTransaction();

    session2.beginTransaction();
  
    User user1 = (User) session1.load(User.class,1);
 
    System.out.println("user1.name="+ user1.getName());
 
    //会发出查询语句，session间不能共享一级缓存的数据
 
    //因为它会伴随session的生命周期存在和消亡
 
    User user2 = (User) session2.load(User.class,1);

    System.out.println("user2.name="+ user2.getName());
 
    session1.getTransaction().commit();
 
    session2.getTransaction().commit(); 
  }catch(Exception e) {
    e.printStackTrace();
    session1.getTransaction().rollback();
    session2.getTransaction().rollback();
  }finally{
 
    HibernateUtils.closeSession(session1);
 
    HibernateUtils.closeSession(session2);
 
  }
 
}

输出结果：


 Hibernate: select user0_.id as id0_0_, user0_.name as name0_0_ from t_user user0_ where user0_.id=?
 user1.name=user0
 Hibernate: select user0_.id as id0_0_, user0_.name as name0_0_ from t_user user0_ where user0_.id=?
 user2.name=user0

 

测试8：在同一个session中先save，再发出load查询save过的数据

 
public void testCache8() {
 
  Session session = null; 
  try{ 
    session= HibernateUtils.getSession();
    session.beginTransaction(); 
    User u = new User(); 
    u.setName("张三"); 
    Serializable id = session.save(u); 
    //不会发出sql，因为save是使用缓存的 
    User user = (User) session.load(User.class,id);
    System.out.println("user.name="+ user.getName());
    session.getTransaction().commit(); 
  }catch(Exception e) { 
    e.printStackTrace(); 
    session.getTransaction().rollback(); 
  }finally{
 
    HibernateUtils.closeSession(session);

  } 
}

输出结果：

 Hibernate: insert into t_user (name) values (?)
 user.name=张三

 

如何避免一次性大量的实体数据入库导致内存溢出？

先flush()，再clear()。 save方法会将save的对象放入一级缓存中，如果要save大批对象，则应该要及时清空一级缓存，可以采用Session的clear()方法。若不清理缓存，可发现javaw进程占用内存持续增长，到一定程度会内存溢出的。如果数据量特别大，考虑采用jdbc实现，如果jdbc也不能满足要求可以考虑采用数据本身的特定导入工具。

 

测试9：向数据库中批量加入1000条数据

 
public void testCache9() {

Session session = null;
 
  try{ 
    session = HibernateUtils.getSession(); 
    session.beginTransaction();

    for(int i = 0;i < 1000; i++) {
 
      User user = new User();
 
      user.setName("user"+ i);

      session.save(user);

      //每20条数据就强制session将数据持久化
 
      //同时清除缓存，避免大量数据造成内存溢出
 
      if(i % 20== 0){
        session.flush();
        session.clear();
      }
 
    } 
    session.getTransaction().commit(); 
  }catch(Exception e) {

    e.printStackTrace(); 
    session.getTransaction().rollback(); 
  }finally{
 
    HibernateUtils.closeSession(session);
 
  }
 
}
 
 
 

 

零度anngle
关注
  • 0
    点赞
  • 踩
  • 2
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
Hibernate的一级缓存
李阿昀的博客
04-12 7880
Hibernate的一级缓存Hibernate的一级缓存就是指Session缓存。通过查看Session接口的实现类——SessionImpl.java的源码可发现有如下两个类： actionQueue它是一个行动队列，它主要记录crud操作的相关信息。 persistenceContext它是持久化上下文，它其实才是真正的缓存。 在Session中定义了一系列的集合来存储数据，它们构成了Sessi
Hibernate一级缓存详解
weixin_34319111的博客
10-31 138
1.Session级别的缓存，它同session邦定。它的生命周期和session相同。Session消毁，它也同时消毁；管理一级缓存，一级缓存无法取消，用两个方法管理，clear(),evict()2.两个session不能共享一级缓存，因它会伴随session的生命周期的创建和消毁；3.Session缓存是实体级别的缓存，就是只有在查询对象级别的时候才使用，如果使用H...
hibernate的一级缓存
weixin_41298572的博客
03-06 249
一级缓存：又称为session级别的缓存。当获得一次会话（session），hibernate在session中创建多个集合（map），用于存放操作数据（PO对象），为程序优化服务，如果之后需要相应的数据，hibernate优先从session缓存中获取，如果有就使用；如果没有再查询数据库。当session关闭时，一级缓存销毁。 2.2、证明一级缓存 2.3、移除缓存 2.4、一级缓...
Hibernate一级缓存和二级缓存详解
08-26
Hibernate一级缓存和二级缓存详解 Hibernate是一种流行的基于Java的持久化框架，它提供了两种缓存机制：一级缓存和二级缓存。了解这两种缓存机制是非常重要的，因为它们可以极大地提高应用程序的性能。 一级缓存 ...
java中hibernate二级缓存详解
08-30
Hibernate 二级缓存详解 Hibernate 中的二级缓存是 SessionFactory 级别的缓存，它是属于进程范围的缓存。二级缓存是可配置的缓存插件，默认情况下，SessionFactory 不会启用这个缓存插件。二级缓存中的数据是...
hibernate一级缓存
07-27
**hibernate一级缓存详解** 在Java的持久化框架Hibernate中，一级缓存是其核心特性之一，它为提高数据库操作效率、减少对数据库的访问提供了重要支持。一级缓存，也称为session缓存，是每个Hibernate Session内部...
hibernate 二级缓存详解
04-17
Hibernate 二级缓存是针对SessionFactory级别的全局缓存，与一级缓存（Session级别）不同，一级缓存只在单个Session生命周期内有效。二级缓存则允许不同Session之间共享数据，提高了数据访问效率，减少了对数据库的...
Hibernate缓存详解
08-31
Hibernate缓存详解 在数据库系统中，缓存是一种重要的优化手段，它能够在应用程序与物理数据源之间建立一个中间层，存储常用数据，以减少对数据库的直接访问，从而提高系统性能。本文将深入探讨Hibernate中的缓存...
hibernate 缓存禁用
01-23
避免项目麻烦，禁用 hibernate 缓存
hibernate一级缓存的移除
bruobuqi的博客
01-04 2490
方法 //清除 1.session.clear(); 2.session.evict(user); 不多说直接代码 @Test //一级缓存的移除 public void TestDemo2(){ Session session= HibernateUtils.openSession(); //开始事物 Transac
Hibernate一级缓存机制
u011190106的博客
02-22 459
虽然一直用的SSH框架开发，但是公司项目问题，几乎没怎么深入了解Hibernate的缓存机制，一直对Hibernate的缓存机制不怎么了解。知道在发现缓存机制是非常重要，然后就找资料熟悉了一遍，就先由Hibernate的一级缓存说起。1、先从N+1问题说起，什么是Hibernate的N+1问题？当用到Hibernate处理一对多的问题时，查询一方时同时也会将多方（n条）查出来，然后我们可以看到后台
hibernate教程--一级缓存详解
好好学java
04-19 822
1.1Hibernate的一级缓存 1.1.1Hibernate的一级缓存: 什么是缓存: 缓存将数据库/硬盘上文件中数据,放入到缓存中(就是内存中一块空间).当再次使用的使用,可以直接从内存中获取. 缓存的好处: * 提升程序运行的效率.缓存技术是Hibernate的一个优化的手段. Hibernate分成两个基本的缓存: * 一级缓存:Session级别的缓存.一
Hibernate的一级缓存机制
zzuli_来治猩猩的你的博客
06-15 190
Hibernate的一级缓存机制 Hibernate建立一级缓存机制是为了减少对数据库的访问次数，从而提升Hibernate的执行效率。每当执行一次查询操作时，再进行第二次查询操作是会检查缓存中是否有数据，如果有数据不再访问数据库，而直接访问缓存区域。 Hibernate的特点 Hibernate的一级缓存是默认打开的，只在session范围内有效，作用时间短，从session创建到session关闭，在hibernate的一级缓存中，存储数据一定是持久态数据。 验证一级缓存的存在 根据uid=5查询对象，
Hibernate第四节(inverse关键字、Hibernate对象的状态、Hibernate的一级缓存、session关闭后懒加载数据使用、组件映射)
qq_24233653的博客
04-27 220
1&gt;:inverse关键字的使用     inverse关键字的作用:这个关键字的作用是反转（这个反转指的是当前的对象有没有维护对方的一个权力）            如果当前对象有维护对方的权利的话那么通过级联就可以正确的维护两个对象之间的关联关系            如果当前的对象没有权利维护对象的话那么即使你设置了级联那么两个对象之间的关联关系也是没有办法去维护的     inver...
Hibernate的一级缓存是什么?具有哪些特点?
最新发布
Blue92120的博客
04-11 573
Hibernate中的缓存分为一级缓存和二级缓存，这两个级别的缓存都位于持久化层，并且存储的都是数据库数据的备份。图1-6为Hibernate提供的两种缓存，两者区别如下：1.一级缓存：一级缓存本质上是自带的不可卸载的，一级缓存的生命周期与session是一致的，一级缓存称为session级别的缓存。2.二级缓存：默认没有开启，是需要手动配置才可以使用的。二级缓存的优势在于可以在多个session中共享数据，二级缓存称为是sessionFactory级别的缓存。一级缓存其实就是Session缓存。
深入理解Hibernate：一级二级缓存详解
4. **一级缓存和二级缓存**：Hibernate的一级缓存是Session级别的，它是默认开启的，用于存储Session内的所有对象。二级缓存则是SessionFactory级别的，可以跨Session共享，但需要额外配置和第三方库支持，如EhCache...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值