Java学习之道：hibernate二级缓存的实现

向右看齐 2021-09-29 17:54 276阅读 0赞

对 于Hibernate 这类 ORM 而言, 缓 存 显 的尤 为 重要, 它 是持久 层 性能提升的 关键 . 简单来讲 Hibernate 就是 对 JDBC 进 行封装,以 实现内 部 状态 的管理,OR 关 系的映射等,但 随 之 带来 的就是 数 据 访问 效率的降低,和性能的下降,而 缓 存就是弥 补这 一缺点的重要方法.  
  
     缓 存就是 数 据 库数 据在 内 存中的 临时 容器,包括 数 据 库数 据在 内 存中的 临时 拷 贝 , 它 位于 数 据 库与数 据 库访问层 中 间 .ORM 在 查询数 据 时 首先 会 根据自身的 缓 存管理策略,在 缓 存中 查 找相 关数 据,如 发现 所需的 数 据, 则 直接 将 此 数 据作 为结 果加以利用, 从 而避免了 数 据 库调 用性能的 开销 . 而相 对内 存操作而言, 数 据 库调 用是一 个 代价高 昂 的 过 程.  
  
    一般 来讲 ORM 中的 缓 存分 为 以下几 类 :  
  
        1. 事 务级缓 存:即在 当 前事 务 范 围内 的 数 据 缓 存.就Hibernate 来讲 , 事 务级缓 存是基于Session的生命周期 实现 的,每 个 Session 内 部 会 存在一 个数 据 缓 存, 它随 着Session的 创 建而存在, 随 着Session的 销 毁而 灭 亡,因此也 称为 Session Level Cache.  
  
        2. 应 用 级缓 存:即在某 个应 用中或 应 用中某 个独 立 数 据 库访问 子集中的共享 缓 存,此 缓 存可由多 个 事 务 共享( 数 据 库 事 务 或 应 用事 务 ), 事 务 之 间 的 缓 存共享策略 与应 用的事 务 隔离机制密切相 关 . 在Hibernate中, 应 用 级缓 存由SessionFactory 实现 , 所有由一 个 SessionFactory 创 建的Session 实 例共享此 缓 存,因此也 称为 SessionFactory Level Cache.  
  
        3. 分布式 缓 存:即在多 个应 用 实 例,多 个 JVM 间 共享的 缓 存策略.分布式 缓 存由多 个应 用 级缓 存 实 例 组 成,通 过 某 种远 程机制(RMI,JMS) 实现 各 个缓 存 实 例 间 的 数 据同步,任何一 个实 例的 数 据修改, 将导 致整 个 集群 间 的 数 据 状态 同步.  
  
    Hibernate 数 据 缓 存:  
  
        1. 内 部 缓 存(Session Level Cache也 称 一 级缓 存):  
  
         举 例 说 明:  
  
java 代 码   
public class Test \{      
     
      public void get()\{       
     
            Session session = HibernateSessionFactory.getSession();      
            TUser t = (TUser)session.get("hibernate.TUser", 2);      
            System.out.println(t.getName());      
            session.close();      
            \}      
     
\}      
     
  
              进 行 测试 : 在控制台打印出一 条 SQL 语 句:Hibernate: select tuser0\_.id as id0\_0\_, tuser0\_.name as name0\_0\_, tuser0\_.\*\*\* as \*\*\*0\_0\_ from test.t\_user tuser0\_ where tuser0\_.id=?  说 明 进 行了一次 数 据 库 的 调 用.  
  
      代 码 更改如下:  
  
public class Test \{      
       
      public void get()\{      
     
            Session session = HibernateSessionFactory.getSession();      
            TUser t = (TUser)session.get("hibernate.TUser", 2);      
            System.out.println(t.getName());      
            TUser tt = (TUser)session.get("hibernate.TUser", 2);      
            System.out.println(tt.getName());      
            session.close();      
     
      \}      
     
\}      
     
  
       再 进 行 测试 : 进 行了 两 次 查询 , 控制台仍然只打出一 条 SQL 语 句:Hibernate: select tuser0\_.id as id0\_0\_, tuser0\_.name as name0\_0\_, tuser0\_.\*\*\* as \*\*\*0\_0\_ from test.t\_user tuser0\_ where tuser0\_.id=?   说 明 还 是只 进 行了一次 数 据 库 的 调 用.  
  
       再 将 代 码 更改如下:  
  
public class Test \{      
       
      public void get()\{       
     
            Session session = HibernateSessionFactory.getSession();      
            TUser t = (TUser)session.get("hibernate.TUser", 2);      
            System.out.println(t.getName());      
            session.close();      
            Session session1 = HibernateSessionFactory.getSession();      
            TUser tt = (TUser)session1.get("hibernate.TUser", 2);      
            System.out.println(tt.getName());      
            session1.close();      
     
      \}      
     
\}      
  
        继续测试 : 进 行 两 次 查询 控制台打印 两条 SQL 语 句:Hibernate: select tuser0\_.id as id0\_0\_, tuser0\_.name as name0\_0\_, tuser0\_.\*\*\* as \*\*\*0\_0\_ from test.t\_user tuser0\_ where tuser0\_.id=?  
Hibernate: select tuser0\_.id as id0\_0\_, tuser0\_.name as name0\_0\_, tuser0\_.\*\*\* as \*\*\*0\_0\_ from test.t\_user tuser0\_ where tuser0\_.id=?  
  
       结论 :Hibernate 进 行 查询时总 是先在 缓 存中 进 行 查询 , 如 缓 存中 没 有所需 数 据才 进 行 数 据 库 的 查询 .Hibernate 的 内 部 缓 存是基于Session的生命周期的,也就是 说 存在于每 个 Session 内 部, 它随 着Session的 创 建而存在, 随 着Session的 销 毁而 灭 亡, 内 部 缓 存一般由Hibernate自 动维护 , 不需要人 为 干 预 , 当 然我 们 也可以根据需要 进 行相 应 操作:Session.evict(Object)( 将 指定 对 象 从内 部 缓 存 清 除),Session.clear()( 清 空 内 部 缓 存).(如在 两 次 查询间 加入Session.clear() 将会清 空 内 部 缓 存,使得一 个 Sesion 内 部的 两 次相同的 查询 要 对数 据 库进 行 两 次操作).  
  
      2.二 级缓 存:(有 时称为 SessionFactory Level Cache)  
  
      Hibernate 本身 并 未提供二 级缓 存的 产 品化 实现 ( 只提供了一 个 基于HashTable的 简单缓 存以供 调试 ), 这 里我使用的是第三方 缓 存 组 件:EHcache.Hibernate的二 级缓 存 实现 需要 进 行以下配置(Hibernate3):  
  
      首先在hibernate.cfg.xml 内 添加:   
  
  
  
<property name="cache.provider\_class">org.hibernate.cache.EhCacheProvider</property>     
<property name="hibernate.cache.use\_query\_cache">true</property>     
  
然后在映射文件中添加:  
<cache usage="read-only"/>     
  
             测试 上面代 码 : 控制台 输 出多了 这样 一句\[ WARN\] (CacheFactory.java:43) - read-only cache configured for mutable class: hibernate.TUser,二 级缓 存 启 用成功!!         
  
java 代 码   
public class Test \{      
       
      public void executeQuery()\{      
        
            List list = new ArrayList();      
            Session session = HibernateSessionFactory.getSession();      
            Query query = session.createQuery("from TUser t");      
            query.setCacheable(true);// 激活 查询缓 存      
            list = query.list();      
            session.close();      
     
      \}      
      public void get()\{      
     
            Session session = HibernateSessionFactory.getSession();      
            TUser t = (TUser)session.get("hibernate.TUser", 2);      
            System.out.println(t.getName());      
            session.close();      
     
     \}      
     
\}      
  
       测试 : 控制台只 输 出一 条 SQL 语 句:Hibernate: select tuser0\_.id as id0\_, tuser0\_.name as name0\_, tuser0\_.\*\*\* as \*\*\*0\_ from test.t\_user tuser0\_(即Query query = session.createQuery("from TUser t") 这 句代 码 所 对应 的SQL).  executeQuery()方法 与 get() 方法使用的是不同的Session!!可是executeQuery()方法 与 get() 方法只 对数 据 库进 行了一次操作, 这 就是二 级缓 存在起作用了.     
  
       结论 :Hibernate 二 级缓 存是SessionFactory 级 的 缓 存, 它 允 许 多 个 Session 间 共享,使用 时 需要使用第三方的 缓 存 组 件,新版Hibernate 将 EHcache 作 为 默 认 的二 级缓 存 实现 .  
  
       缓 存同步策略: 缓 存同步策略 决 定了 数 据 对 象在 缓 存中的存取 规则 , 我 们 必 须为 每 个实 体 类 指定相 应 的 缓 存同步策略.Hibernate中提供了4 种 不同的 缓 存同步策略:( 暂时 只 记个概 念 吧 )  
  
      1.read-only: 只 读 . 对 于不 会发 生改 变 的 数 据可使用 （对数据只能查询，其他的增删改都会报错不关是1或2 缓存中 ） .  
  
      2.nonstrict-read-write: 如果程序 对并发访问 下的 数 据同步要求不 严 格,且 数 据更新 频 率 较 低,采用本 缓 存同步策略可 获 得 较 好性能. ( 不能在二级缓存进行 增删改都会报错 )   
  
      3.read-write: 严 格的 读写缓 存.基于 时间 戳判定机制, 实现 了"read committed"事 务 隔离等 级 . 用于 对数 据同步要求的情 况 , 但不支持分布式 缓 存, 实际应 用中使用最多的 缓 存同步策略. （都可以比较常用的）   
  
      4.transactional: 事 务 型 缓 存,必 须运 行在JTA事 务环 境中.此 缓 存中, 缓 存的相 关 操作被添加到事 务 中(此 缓 存 类 似于一 个内 存 数 据 库 ), 如事 务 失 败 , 则缓 冲池的 数 据 会 一同回 滚 到事 务 的 开 始之前的 状态 . 事 务 型 缓 存 实现 了"Repeatable read"事 务 隔离等 级 , 有效保 证 了 数 据的合法性,适 应 于 对关键数 据的 缓 存,Hibernate 内 置 缓 存中,只有JBossCache支持事 务 型 缓 存.

Hibernate 获 取 数 据的方式有不同的几 种 ，其 与缓 存 结 合使用的效果也不 尽 相同，而Hibernate中具体 怎么 使用 缓 存其 实 是我 们 很 关 心的一 个问题 ，直接涉及到性能方面。  
 缓 存在Hibernate中主要有三 个 方面：一 级缓 存、二 级缓 存和 查询缓 存；一 级缓 存在Hibernate中 对应 的即 为 session 范 围 的 缓 存，也就是 当  session 关闭时缓 存即被 清 除，一 级缓 存在Hibernate中是不可配置的部分；二 级缓 存在Hibernate中 对应 的即 为  SessionFactory 范 围 的 缓 存，通常 来讲 SessionFactory 的生命周期和 应 用的生命周期相同，所以可以看成是 进 程 缓 存或集群 缓 存，二 级缓 存在Hibernate中是可以配置的，可以通 过 class-cache 配置 类 粒度 级别 的 缓 存(class-cache在class中 数 据 发 生任何 变 化的情 况 下自 动 更新)，同 时 也可通 过 collection-cache 配置集合粒度 级别 的 缓 存(collection-cache 仅 在 collection中增加了元素或者 删 除了元素的情 况 下才自 动 更新，也就是 当 collection 中元素 发 生 值 的 变 化的情 况 下 它 是不 会 自 动 更新的)， 缓 存自然 会带来并发 的 访问问题 ， 这个时 候相 应 的就要根据 应 用 来设 置 缓 存所采用的事 务 隔离 级别 ，和 数 据 库 的事 务 隔离 级别概 念基本一 样 ， 没 什 么 多介 绍 的， ^\_^； 查询缓 存在Hibernate同 样 是可配置的，默 认 是 关闭 的，可以通 过设 置cache.use\_ query\_cache 为 true 来 打 开查询缓 存。根据 缓 存的通常 实现 策略，我 们 可以 来 理解Hibernate的 这 三 种缓 存， 缓 存的 实现 通 过 是通 过 key/value 的Map方式 来实现 ，在 Hibernate的一 级 、二 级 和 查询缓 存也同 样 如此，一 级 、二 级缓 存使用的key均 为 po 的主 键 ID ，value即 为 po 实 例 对 象， 查询缓 存使用的 则为查询 的 条 件、 查询 的 参数 、 查询 的 页数 ，value有 两种 情 况 ，如果采用的是select po.property 这样 的方式那 么 value 为 整 个结 果集，如采用的是from 这样 的方式那 么 value 为获 取的 结 果集中各po 对 象的主 键 ID ， 这样 的作用很明 显 ， 节 省 内 存，^\_^  
 简单 介 绍 完Hibernate的 缓 存后，再 结 合Hibernate的 获 取 数 据方式 来说 明 缓 存的具体使用方式，在Hibernate中 获 取 数 据常用的方式主要有四 种 ：Session.load、Session.get、Query.list、Query.iterator。  
1、Session.load  
      在 执 行session.load 时 ，Hibernate首先 从当 前session的一 级缓 存中 获 取id 对应 的 值 ，在 获 取不到的情 况 下， 将 根据 该对 象是否配置了二 级缓 存 来 做相 应 的 处 理，如配置了二 级缓 存， 则从 二 级缓 存中 获 取id 对应 的 值 ，如仍然 获 取不到 则还 需要根据是否配置了延 迟 加 载来决 定如何 执 行，如未配置延 迟 加 载则从数 据 库 中直接 获 取，在 从数 据 库获 取到 数 据的情 况 下，Hibernate 会 相 应 的 填 充一 级缓 存和二 级缓 存，如配置了延 迟 加 载则 直接返回一 个 代理 类 ，只有在 触发 代理 类 的 调 用 时 才 进 行 数 据 库查询 的操作。  
      在 这样 的情 况 下我 们 就可以看到，在session一直打 开 的情 况 下，要注意在适 当 的 时 候 对 一 级缓 存 进 行刷新操作，通常是在 该对 象具有 单 向 关联维护 的 时 候，在Hibernate中可以使用象session.clear、session.evict的方式 来 强制刷新一 级缓 存。  
      二 级缓 存 则 在 数 据 发 生任何 变 化(新增、更新、 删 除)的情 况 下都 会 自 动 的被更新。  
2、Session.get  
      在 执 行Session.get 时 ，和Session.load不同的就是在 当从缓 存中 获 取不到 时 ，直接 从数 据 库 中 获 取id 对应 的 值 。  
3、Query.list  
      在 执 行Query.list 时 ，Hibernate的做法是首先 检查 是否配置了 查询缓 存，如配置了 则从查询缓 存中 查 找key 为查询语 句+ 查询参数 \+ 分 页条 件的 值 ，如 获 取不到 则从数 据 库 中 进 行 获 取， 从数 据 库获 取到后Hibernate 将会 相 应 的 填 充一 级 、二 级 和 查询缓 存，如 获 取到的 为 直接的 结 果集， 则 直接返回，如 获 取到的 为 一堆id的 值 ， 则 再根据id 获 取相 应 的 值 (Session.load) ，最后形成 结 果集返回，可以看到，在 这样 的情 况 下，list也是有可能造成N次的 查询 的。  
       查询缓 存在 数 据 发 生任何 变 化的情 况 下都 会 被自 动 的 清 空。  
4、Query.iterator  
      在 执 行Query.iterator 时 ，和Query.list的不同的在于 从数 据 库获 取的 处 理上，Query.iterator向 数 据 库发 起的是 select id from 这样 的 语 句，也就是 它 是先 获 取符合 查询条 件的id，之后在 进 行iterator.next 调 用 时 才再次 发 起session.load的 调 用 获 取 实际 的 数 据。  
      可 见 ，在 拥 有二 级缓 存 并 且 查询参数 多 变 的情 况 下，Query.iterator 会 比Query.list更 为 高效。  
  
 这 四 种获 取 数 据的方式都各有适用的 场 合，要根据 实际 情 况 做相 应 的 决 定，^\_^，最好的方式无疑就是打 开 show\_sql 选项 看看 执 行的情 况来 做分析，系 统结构 上只用保 证这种调 整是容易 实现 的就好了，在cache 这个 方面的 调 整自然是非常的容易，只需要 调 整配置文件里的 设 置，而 查询 的方式 则 可 对 外部 进 行 屏 蔽， 这样 要根据 实际 情 况调 整也非常容易。

1 ． < hibernate-configuration >

< session-factory >

< property  name = "connection.username" > sa </ property >

< property  name = "connection.url" >

jdbc:microsoft:sqlserver://localhost:1433;databasename=pubs

</ property >

< property  name = "dialect" >

org.hibernate.dialect.SQLServerDialect

</ property >

< property  name = "myeclipse.connection.profile" > conn </ property >

< property  name = "connection.driver\_class" >

com.microsoft.jdbc.sqlserver.SQLServerDriver