设为首页收藏本站
开启辅助访问

在路上

 找回密码
 立即注册
在路上 › 站点首页 ›学习 › 查看内容

Hibernate框架中的缓存技术详解

2016-8-29 13:22| 发布者: zhangjf| 查看: 617| 评论: 0

摘要: 本文实例讲述了Hibernate框架中的缓存技术。分享给大家供大家参考，具体如下： Hibernate框架的缓存分为Session的缓存、SessionFactory的缓存，也称为一级缓存和二级缓存。 一级缓存： 一级缓存是Session级的缓存， ...

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

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

一级缓存：

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

举个例子来说吧：

  2. package com.xqh.util;
  3. import org.hibernate.Session;
  4. import com.xqh.model.User;
  5. public class Test {
  6. public static void main(String[] args) {
  7. Session session = null;
  8. try {
  9. session = HibernateUtil.getSession(); // 获取session
  10. session.beginTransaction(); //开启事务
  11. System.out.println("第一次查询：");
  12. User user = (User)session.get(User.class, new Integer(1));
  13. System.out.println("用户名：" + user.getName());
  14. System.out.println("第二次查询：");
  15. User user1 = (User)session.get(User.class, 1);
  16. System.out.println("用户名：" + user1.getName());
  17. session.getTransaction().commit();
  18. } catch (Exception e) {
  19. e.printStackTrace();
  20. // 出错将回滚事务
  21. session.getTransaction().rollback();
  22. } finally {
  23. // 关闭Session对象
  24. HibernateUtil.closeSession(session);
  25. }
  26. }
  27. }
复制代码

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

  2. 第一次查询：
  3. Hibernate:
  4. select
  5. user0_.id as id0_0_,
  6. user0_.name as name0_0_,
  7. user0_.sex as sex0_0_
  8. from
  9. tb_user_info user0_
  10. where
  11. user0_.id=?
  12. 用户名：xqh
  13. 第二次查询：
  14. 用户名：xqh
复制代码

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

二级缓存：

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

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

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

  2. <ehcache>
  3. <!-- Sets the path to the directory where cache .data files are created.
  4. If the path is a Java System Property it is replaced by
  5. its value in the running VM.
  6. The following properties are translated:
  7. user.home - User's home directory
  8. user.dir - User's current working directory
  9. java.io.tmpdir - Default temp file path -->
  10. <diskStore path="java.io.tmpdir"/>
  11. <!--Default Cache configuration. These will applied to caches programmatically created through
  12. the CacheManager.
  13. The following attributes are required for defaultCache:
  14. maxInMemory - Sets the maximum number of objects that will be created in memory
  15. eternal - Sets whether elements are eternal. If eternal, timeouts are ignored and the element
  16. is never expired.
  17. timeToIdleSeconds - Sets the time to idle for an element before it expires. Is only used
  18. if the element is not eternal. Idle time is now - last accessed time
  19. timeToLiveSeconds - Sets the time to live for an element before it expires. Is only used
  20. if the element is not eternal. TTL is now - creation time
  21. overflowToDisk - Sets whether elements can overflow to disk when the in-memory cache
  22. has reached the maxInMemory limit.
  23. -->
  24. <defaultCache
  25. maxElementsInMemory="10000"
  26. eternal="false"
  27. timeToIdleSeconds="120"
  28. timeToLiveSeconds="120"
  29. overflowToDisk="true"
  30. />
  31. <!--Predefined caches. Add your cache configuration settings here.
  32. If you do not have a configuration for your cache a WARNING will be issued when the
  33. CacheManager starts
  34. The following attributes are required for defaultCache:
  35. name - Sets the name of the cache. This is used to identify the cache. It must be unique.
  36. maxInMemory - Sets the maximum number of objects that will be created in memory
  37. eternal - Sets whether elements are eternal. If eternal, timeouts are ignored and the element
  38. is never expired.
  39. timeToIdleSeconds - Sets the time to idle for an element before it expires. Is only used
  40. if the element is not eternal. Idle time is now - last accessed time
  41. timeToLiveSeconds - Sets the time to live for an element before it expires. Is only used
  42. if the element is not eternal. TTL is now - creation time
  43. overflowToDisk - Sets whether elements can overflow to disk when the in-memory cache
  44. has reached the maxInMemory limit.
  45. -->
  46. <!-- Sample cache named sampleCache1
  47. This cache contains a maximum in memory of 10000 elements, and will expire
  48. an element if it is idle for more than 5 minutes and lives for more than
  49. 10 minutes.
  50. If there are more than 10000 elements it will overflow to the
  51. disk cache, which in this configuration will go to wherever java.io.tmp is
  52. defined on your system. On a standard Linux system this will be /tmp"
  53. -->
  54. <cache name="sampleCache1"
  55. maxElementsInMemory="10000"
  56. eternal="false"
  57. timeToIdleSeconds="300"
  58. timeToLiveSeconds="600"
  59. overflowToDisk="true"
  60. />
  61. <!-- Sample cache named sampleCache2
  62. This cache contains 1000 elements. Elements will always be held in memory.
  63. They are not expired. -->
  64. <cache name="sampleCache2"
  65. maxElementsInMemory="1000"
  66. eternal="true"
  67. timeToIdleSeconds="0"
  68. timeToLiveSeconds="0"
  69. overflowToDisk="false"
  70. /> -->
  71. <!-- Place configuration for your caches following -->
  72. </ehcache>
复制代码

2.设置Hibernate配置文件。

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

例：

  2. package com.xqh.util;
  3. import org.hibernate.Session;
  4. import com.xqh.model.User;
  5. public class Test {
  6. public static void main(String[] args) {
  7. Session session = null; // 第一个Session
  8. try {
  9. session = HibernateUtil.getSession();
  10. session.beginTransaction();
  11. System.out.println("第一次查询:");
  12. User user = (User)session.get(User.class, 1);
  13. System.out.println("用户名：" + user.getName());
  14. session.getTransaction().commit();
  15. } catch (Exception e) {
  16. e.printStackTrace();
  17. // 出错将回滚事务
  18. session.getTransaction().rollback();
  19. } finally {
  20. // 关闭Session对象
  21. HibernateUtil.closeSession(session);
  22. }
  23. try {
  24. session = HibernateUtil.getSession(); // 开启第二个缓存
  25. session.beginTransaction();
  26. System.out.println("第二次查询:");
  27. User user = (User)session.get(User.class, 1);
  28. System.out.println("用户名：" + user.getName());
  29. session.getTransaction().commit();
  30. } catch (Exception e) {
  31. e.printStackTrace();
  32. // 出错将回滚事务
  33. session.getTransaction().rollback();
  34. } finally {
  35. // 关闭Session对象
  36. HibernateUtil.closeSession(session);
  37. }
  38. }
  39. }
复制代码

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

程序结果：

  2. 第一次查询:
  3. Hibernate:
  4. select
  5. user0_.id as id0_0_,
  6. user0_.name as name0_0_,
  7. user0_.sex as sex0_0_
  8. from
  9. tb_user_info user0_
  10. where
  11. user0_.id=?
  12. 用户名：xqh
  13. 第二次查询:
  14. 用户名：xqh
复制代码

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

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

收藏 邀请
上一篇：Hibernate实现批量添加数据的方法下一篇：Java中字符编码格式详解

最新评论

相关分类

小黑屋|在路上 ( 蜀ICP备15035742号-1 )  

;

GMT+8, 2025-7-7 01:40

Copyright 2015-2025 djqfx

返回顶部