对于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_.sex as sex0_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_.sex as sex0_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_.sex as sex0_0_ from test.t_user tuser0_ where tuser0_.id=?
Hibernate: select tuser0_.id as id0_0_, tuser0_.name as name0_0_, tuser0_.sex as sex0_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_.sex as sex0_ 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
</property>
<property name="show_sql">true</property>
<!-- 添加2级缓存开始 -->
<property name="cache.provider_class">
org.hibernate.cache.EhCacheProvider
</property>
<property name="hibernate.cache.use_query_cache">true</property>
<!-- 结束 -->
<mapping resource="org/jw/po/Users.hbm.xml" />
</session-factory>
</hibernate-configuration>
2.
<hibernate-mapping>
<class name="org.jw.po.Users" table="users" schema="dbo" catalog="pubs">
<!--配置-->
<cache usage="read-only"></cache>
<id name="sid" type="java.lang.Integer">
<column name="sid" />
<generator class="identity" />
</id>
<property name="sname" type="java.lang.String">
<column name="sname" length="20" not-null="true" />
</property>
</class>
</hibernate-mapping>
hibernate缓存(二)
最新推荐文章于 2024-08-23 15:54:50 发布