Hibernate框架中的缓存技术详解

 更新时间:2016年03月24日 09:46:56   作者:TKD03072010  
这篇文章主要介绍了Hibernate框架中的缓存技术,结合实例形式详细分析了Hibernate框架缓存机制的原理与具体使用技巧,需要的朋友可以参考下

本文实例讲述了Hibernate框架中的缓存技术。分享给大家供大家参考,具体如下:

Hibernate框架的缓存分为Session的缓存、SessionFactory的缓存,也称为一级缓存和二级缓存。

一级缓存:

一级缓存是Session级的缓存,其生命周期很短,与Session相互对应,由Hibernate进行管理,属于事务范围的缓存。当程序调用 Session的load()方法、get()方法、save()方法、saveOrUpdate()方法、update()方法或查询接口方法时,Hibernate会对实体对象进行缓存;当通过load()方法或get()方法查询实体对象时,Hibernate会首先到缓存中查询,在找不到实体对像的情况下,Hibernate才会发出SQL语句到数据库中查询,从而提高了Hibernate的使用效率。

举个例子来说吧:

package com.xqh.util;
import org.hibernate.Session;
import com.xqh.model.User;
public class Test {
public static void main(String[] args) {
Session session = null;
try {
session = HibernateUtil.getSession(); // 获取session
session.beginTransaction(); //开启事务
System.out.println("第一次查询:");
User user = (User)session.get(User.class, new Integer(1));
System.out.println("用户名:" + user.getName());
System.out.println("第二次查询:");
User user1 = (User)session.get(User.class, 1);
System.out.println("用户名:" + user1.getName());
session.getTransaction().commit();
} catch (Exception e) {
e.printStackTrace();
// 出错将回滚事务
session.getTransaction().rollback();
} finally {
// 关闭Session对象
HibernateUtil.closeSession(session);
}
}
}

当程序通过get()方法第一次查用户对象时,Hibernate会发出一条SQL语句进行查询,此时Hibernate对其用户对象进行了一级缓存;当再次通过get()方法查询时,Hibernate就不会发出SQL语句了,因为用户名已经存在于一级缓存中。程序运行结果:

第一次查询:
Hibernate: 
select
user0_.id as id0_0_,
user0_.name as name0_0_,
user0_.sex as sex0_0_ 
from
tb_user_info user0_ 
where
user0_.id=?
用户名:xqh
第二次查询:
用户名:xqh

注意:一级缓存的生命周期与Session相对应,它并不会在Session之间共享,在不同的Session中不能得到其他Session中缓存的实体对象

二级缓存:

二级缓存是SessionFactory级的缓存,其生命周期与SessionFactory一致。二级缓存可在多个Session间共享,属于进程范围或群集范围的缓存。

二级缓存是一个可插拔的缓存插件,它的使用需要第三方缓存产品的支持。在Hibernate框架中,通过Hibernate配置文件配置二级缓存的使用策略。

1.加入缓存配置文件ehcache.xml

<ehcache>
<!-- Sets the path to the directory where cache .data files are created.
If the path is a Java System Property it is replaced by
its value in the running VM.
The following properties are translated:
user.home - User's home directory
user.dir - User's current working directory
java.io.tmpdir - Default temp file path -->
<diskStore path="java.io.tmpdir"/>
<!--Default Cache configuration. These will applied to caches programmatically created through
the CacheManager.
The following attributes are required for defaultCache:
maxInMemory - Sets the maximum number of objects that will be created in memory
eternal - Sets whether elements are eternal. If eternal, timeouts are ignored and the element
is never expired.
timeToIdleSeconds - Sets the time to idle for an element before it expires. Is only used
if the element is not eternal. Idle time is now - last accessed time
timeToLiveSeconds - Sets the time to live for an element before it expires. Is only used
if the element is not eternal. TTL is now - creation time
overflowToDisk - Sets whether elements can overflow to disk when the in-memory cache
has reached the maxInMemory limit.
-->
<defaultCache
maxElementsInMemory="10000"
eternal="false"
timeToIdleSeconds="120"
timeToLiveSeconds="120"
overflowToDisk="true"
/>
<!--Predefined caches. Add your cache configuration settings here.
If you do not have a configuration for your cache a WARNING will be issued when the
CacheManager starts
The following attributes are required for defaultCache:
name - Sets the name of the cache. This is used to identify the cache. It must be unique.
maxInMemory - Sets the maximum number of objects that will be created in memory
eternal - Sets whether elements are eternal. If eternal, timeouts are ignored and the element
is never expired.
timeToIdleSeconds - Sets the time to idle for an element before it expires. Is only used
if the element is not eternal. Idle time is now - last accessed time
timeToLiveSeconds - Sets the time to live for an element before it expires. Is only used
if the element is not eternal. TTL is now - creation time
overflowToDisk - Sets whether elements can overflow to disk when the in-memory cache
has reached the maxInMemory limit.
-->
<!-- Sample cache named sampleCache1
This cache contains a maximum in memory of 10000 elements, and will expire
an element if it is idle for more than 5 minutes and lives for more than
10 minutes.
If there are more than 10000 elements it will overflow to the
disk cache, which in this configuration will go to wherever java.io.tmp is
defined on your system. On a standard Linux system this will be /tmp"
-->
<cache name="sampleCache1"
maxElementsInMemory="10000"
eternal="false"
timeToIdleSeconds="300"
timeToLiveSeconds="600"
overflowToDisk="true"
/>
<!-- Sample cache named sampleCache2
This cache contains 1000 elements. Elements will always be held in memory.
They are not expired. -->
<cache name="sampleCache2"
maxElementsInMemory="1000"
eternal="true"
timeToIdleSeconds="0"
timeToLiveSeconds="0"
overflowToDisk="false"
/> -->
<!-- Place configuration for your caches following -->
</ehcache>

2.设置Hibernate配置文件。

<!-- 开启二级缓存 -->
<property name="hibernate.cache.use_second_level_cache">true</property>
<!-- 指定缓存产品提供商 -->
<property name="hibernate.cache.provider_class">org.hibernate.cache.EhCacheProvider</property>
<!-- 指定二级缓存应用到的实体对象 -->
<class-cache class="com.xqh.model.User" usage="read-only"></class-cache>

例:

package com.xqh.util;
import org.hibernate.Session;
import com.xqh.model.User;
public class Test {
public static void main(String[] args) {
Session session = null; // 第一个Session
try {
session = HibernateUtil.getSession();
session.beginTransaction();
System.out.println("第一次查询:");
User user = (User)session.get(User.class, 1);
System.out.println("用户名:" + user.getName());
session.getTransaction().commit();
} catch (Exception e) {
e.printStackTrace();
// 出错将回滚事务
session.getTransaction().rollback();
} finally {
// 关闭Session对象
HibernateUtil.closeSession(session);
}
try {
session = HibernateUtil.getSession(); // 开启第二个缓存
session.beginTransaction();
System.out.println("第二次查询:");
User user = (User)session.get(User.class, 1);
System.out.println("用户名:" + user.getName());
session.getTransaction().commit();
} catch (Exception e) {
e.printStackTrace();
// 出错将回滚事务
session.getTransaction().rollback();
} finally {
// 关闭Session对象
HibernateUtil.closeSession(session);
}
}
}

二级缓存在Session之间是共享的,因此可在不同Session中加载同一个对象,Hibernate将只发出一条SQL语句,当第二次加载对象时,Hibernate将从缓存中获取此对象。

程序结果:

第一次查询:
Hibernate: 
select
user0_.id as id0_0_,
user0_.name as name0_0_,
user0_.sex as sex0_0_ 
from
tb_user_info user0_ 
where
user0_.id=?
用户名:xqh
第二次查询:
用户名:xqh

对于二级缓存,可以使用一些不经常更新的数据或参考的数据,此时其性能会得到明显的提升。但如果经常变化的数据应用二级缓存,则性能方面会造成一定问题。

希望本文所述对大家基于Hibernate框架的Java程序设计有所帮助。

相关文章

  • springBoot 过滤器去除请求参数前后空格实例详解

    springBoot 过滤器去除请求参数前后空格实例详解

    这篇文章主要为大家介绍了springBoot 过滤器去除请求参数前后空格实例详解,有需要的朋友可以借鉴参考下,希望能够有所帮助,祝大家多多进步,早日升职加薪
    2022-11-11
  • Java 二叉树遍历特别篇之Morris遍历

    Java 二叉树遍历特别篇之Morris遍历

    二叉树的遍历(traversing binary tree)是指从根结点出发,按照某种次序依次访问二叉树中所有的结点,使得每个结点被访问依次且仅被访问一次。四种遍历方式分别为:先序遍历、中序遍历、后序遍历、层序遍历
    2021-11-11
  • java:程序包org.junit不存在解决办法详析

    java:程序包org.junit不存在解决办法详析

    这篇文章主要给大家介绍了关于java:程序包org.junit不存在解决办法的相关资料,这个错误通常发生在使用JUnit测试时,因为缺少JUnit库的依赖,文中通过图文介绍的非常详细,需要的朋友可以参考下
    2023-11-11
  • java实现快速排序算法

    java实现快速排序算法

    快速排序算法是基于分治策略的另一个排序算法。其基本思想是:对输入的子数组a[p:r],按以下三个步骤进行排序。 1) 分解(Divide)(2) 递归求解(Conquer) (3) 合并(Merge)
    2015-04-04
  • Java中Thread和Runnable创建线程的方式对比

    Java中Thread和Runnable创建线程的方式对比

    本文主要介绍了Java中Thread和Runnable创建线程的方式对比,文中通过示例代码介绍的非常详细,对大家的学习或者工作具有一定的参考学习价值,需要的朋友们下面随着小编来一起学习学习吧
    2022-07-07
  • Java多态的全面系统解析

    Java多态的全面系统解析

    多态就是指程序中定义的引用变量所指向的具体类型和通过该引用变量发出的方法调用在编程时并不确定,而是在程序运行期间才确定,即一个引用变量到底会指向哪个类的实例对象,该引用变量发出的方法调用到底是哪个类中实现的方法,必须在由程序运行期间才能决定
    2022-03-03
  • SpringBoot实现简单文件上传功能

    SpringBoot实现简单文件上传功能

    这篇文章主要为大家详细介绍了SpringBoot实现简单文件上传功能,文中示例代码介绍的非常详细,具有一定的参考价值,感兴趣的小伙伴们可以参考一下
    2022-08-08
  • Java中Synchronized锁的使用和原理详解

    Java中Synchronized锁的使用和原理详解

    这篇文章主要介绍了Java中Synchronized锁的使用和原理详解,synchronized是 Java 内置的关键字,它提供了一种独占的加锁方式,synchronized的获取和释放锁由JVM实现,用户不需要显示的释放锁,非常方便,需要的朋友可以参考下
    2023-07-07
  • 在SpringBoot中添加Redis及配置方法

    在SpringBoot中添加Redis及配置方法

    这篇文章主要介绍了在SpringBoot中添加Redis及配置redis的代码,需要的朋友可以参考下
    2018-10-10
  • springboot如何实现自动装配源码解读

    springboot如何实现自动装配源码解读

    这篇文章主要介绍了springboot如何实现自动装配源码赏析,本文通过实例代码给大家介绍的非常详细,对大家的学习或工作具有一定的参考借鉴价值,需要的朋友可以参考下
    2020-12-12

最新评论