Hibernate4教程六:性能提升和二级缓存
Hibernate4教程六:性能提升和二级缓存
乐在克里特 发表于1年前
Hibernate4教程六:性能提升和二级缓存
  • 发表于 1年前
  • 阅读 8
  • 收藏 0
  • 点赞 0
  • 评论 0

移动开发云端新模式探索实践 >>>   

抓取策略(fetching strategy)是指:当应用程序需要在(Hibernate实体对象图的)关联关系间进行导航的时候,Hibernate如何获取关联对象的策略。抓取策略可以在O/R映射的元数据中声明,也可以在特定的HQL或条件查询(Criteria Query)中重载声明。 Hibernate4 定义了如下几种抓取策略:
1:连接抓取(Join fetching) - Hibernate通过 在SELECT语句使用OUTER JOIN(外连接)来 获得对象的关联实例或者关联集合。
2:查询抓取(Select fetching) - 另外发送一条 SELECT语句抓取当前对象的关联实体或集合。除非你显式的指定lazy="false"禁止 延迟抓取,否则只有当真正访问关联关系的时候,才会执行第二条select语句。
3:子查询抓取(Subselect fetching) - 另外发送一条SELECT语句抓取在前面查询到(或者抓取到)的所有实体对象的关联集合。除非你显式的指定lazy="false" 禁止延迟抓取否则只有当你真正访问关联关系的时候,才会执行第二条select语句。
4:批量抓取(Batch fetching) - 对查询抓取的优化方案, 通过指定一个主键或外键列表,Hibernate使用单条SELECT语句获取一批对象实例或集合。
映射文档中定义的抓取策略将会对以下列表条目产生影响:
(1)通过 get() 或 load() 方法取得数据。
(2)只有在关联之间进行导航时,才会隐式的取得数据。
(3)条件查询
(4)使用了subselect 抓取的 HQL 查询
通常情况下,我们并不使用映射文档进行抓取策略的定制。更多的是,保持其默认值,然后在特定的事务中, 使用 HQL 的左连接抓取(left join fetch) 对其进行重载。这将通知 Hibernate在第一次查询中使用外部关联(outer join),直接得到其关联数据。
条件查询API 中,应该调用 setFetchMode语句,例如:

java代码:
  1. User user = (User) session.createCriteria(User.class)  
  2. .setFetchMode("permissions", FetchMode.JOIN)  
  3. .add( Restrictions.idEq(userId) )  
  4. .uniqueResult();  
Hibernate会区分下列各种情况:
1:Immediate fetching,立即抓取  - 当宿主被加载时,关联、集合或属性被立即抓取。
2:Lazy collection fetching,延迟集合抓取- 直到应用程序对集合进行了一次操作时,集合才被抓取。(对集合而言这是默认行为。)
3:"Extra-lazy" collection fetching,"Extra-lazy"集合抓取  -对集合类中的每个元素而言,都是直到需要时才去访问数据库。除非绝对必要,Hibernate不会试图去把整个集合都抓取到内存里来(适用于非常大的集合)。
4:Proxy fetching,代理抓取  - 对返回单值的关联而言,当其某个方法被调用,而非对其关键字进行get操作时才抓取。
5:"No-proxy" fetching,非代理抓取  - 对返回单值的关联而言,当实例变量被访问的时候进行抓取。与上面的代理抓取相比,这种方法没有那么“延迟”得厉害(就算只访问标识符,也会导致关联抓取)但是更加透明,因为对应用程序来说,不再看到proxy。这种方法需要在编译期间进行字节码增强操作,因此很少需要用到。
6:Lazy attribute fetching,属性延迟加载  - 对属性或返回单值的关联而言,当其实例变量被访问的时候进行抓取。需要编译期字节码强化,因此这一方法很少用到。
何时实例化集合和代理
既然Hibernate会采取代理来延迟集合的实例化,那么何时实例化这个集合呢?因为如果session关闭了,再访问未初始化的集合活代理的话,将会抛出LazyInitializationException 异常。
常见的解决方法,如下:
在session打开期间去访问集合的数据
这是一种不好的做法,就是没有什么用的去访问集合的数据,触发其实例化
使用Hibernate.initialized()方法
静态方法 Hibernate.initialized() 为你的应用程序提供了一个便捷的途径来延迟加载集合或代理。 只要它的Session 处于open 状态,Hibernate.initialize(cat) 将会为cat 强制对代理实例化。同样,Hibernate.initialize(cat.getKittens())对kittens的集合具有同样的功能。
保持Session一直处于open状态,直到集合被实例化
通常又有两种方法:
Open Session in View模式
在一个基于Web的应用中,可以利用过滤器,在用户请求时打开Hibernate的session、页面生成结束时关闭 Session,示例如下:

java代码:
  1. public class HibernateSessionRequestFilter implements Filter {  
  2.     private SessionFactory sf;  
  3.     public void doFilter(...)throws...{  
  4.         sf.getCurrentSession().beginTransaction();  
  5.         chain.doFilter(request, response);  
  6.         sf.getCurrentSession().getTransaction().commit();  
  7.     }  
  8.     public void init(FilterConfig filterConfig) throws ServletException {  
  9.         sf = new Configuration().configure().buildSessionFactory();  
  10.     }  
  11.     public void destroy() {}  
  12. }  
在逻辑层为表现层准备数据的时候,在session打开的情况下,实例化好所有需要的数据。
 
要完全理解Hibernate各种集合的关系结构和性能特点,必须同时考虑“用于Hibernate更新或删除集合行数据的主键的结构”。 因此得到了如下的分类:
有序集合类、集合(sets)、包(bags): 可以重复且没有顺序的一种集合
 
所有的有序集合类(maps, lists, arrays)都拥有一个由<key>和<index>组成的主键。 这种情况下集合类的更新是非常高效的——主键已经被有效的索引,因此当Hibernate试图更新或删除一行时,可以迅速找到该行数据
集合(sets)的主键由<key>和其他元素组成。对于有些元素来说,这很低效,特别是组合元素,大文本或二进制数据。但是对于一对多或者多对多,set也可以达到同样的高效性能
Bag是最差的。因为bag允许重复的元素值,也没有索引字段,因此不可能定义主键。 Hibernate无法判断出重复的行。当这种集合被更改时,Hibernate将会先完整地移除 (通过一个(in a single DELETE))整个集合,然后再重新创建整个集合。 因此Bag是非常低效的。
Lists, maps 和sets用于更新效率最高
1:有序集合类型和大多数set都可以在增加、删除、修改元素中拥有最好的性能。
2:在多对多中,set性能不如有序集合类型
3:Hibernate中,set应该是最通用的集合类型
Bag和list是反向集合类(也就是指定了inverse=true的集合类)中效率最高的
在一种情况下,bag的性能(包括list)要比set高得多: 对于指明了inverse="true"的集合类(比如说,标准的双向的一对多关联), 我们可以在未初始化(fetch)包元素的情况下直接向bag或list添加新元素! 这是因为Collection.add())或者Collection.addAll() 方法 对bag或者List总是返回true(这点与与Set不同)。因此对于下面的相同代码来说,速度会快得多。

java代码:
  1. Parent p = (Parent) sess.load(Parent.class, id);  
  2. Child c = new Child();  
  3. c.setParent(p);  
  4. p.getChildren().add(c); //不用抓取集合  
  5. sess.flush();  
SessionFactory里面带着监测性能的数据,就是Statistics
首先需要在cfg.xml中打开统计功能,将 hibernate.generate_statistics 设置为 true。在运行期间,则可以可以通过 sf.getStatistics().setStatisticsEnabled(true) 或hibernateStatsBean.setStatisticsEnabled(true)来打开统计功能
 
所有的测量值都可以由 Statistics 接口 API 进行访问,主要分为三类:
1:使用 Session 的普通数据记录,例如打开的 Session 的个数、取得的 JDBC 的连接数等;
2:实体、集合、查询、缓存等内容的统一数据记录。
3:和具体实体、集合、查询、缓存相关的详细数据记录
 
Hibernate的Session在事务级别进行持久化数据的缓存操作,也就是前边所讲的一级缓存
当然,也可以分别为每个类(或集合),配置集群、或JVM级别(SessionFactory级别)的缓存(二级缓存)
在Hibernate4以前的版本:通过在hibernate.cache.provider_class属性中指定org.hibernate.cache.CacheProvider的某个实现的类名,你可以选择让Hibernate使用哪个缓存实现。注意,在3.2版本之前,默认使用EhCache 作为缓存实现,但从3.2起就不再这样了。如:<property name="cache.provider_class">org.hibernate.cache.EhCacheProvider</property>
在Hibernate4的版本中:通过在cache.region.factory_classs指定相应的缓存区域的实现,如:
java代码:
  1. <property name="cache.region.factory_class">org.hibernate.cache.EhCacheRegionFactory</property>  
  2.    
 
缓存映射,类或者集合映射的“<cache>元素”可以有下列形式:

java代码:
  1. <cache  
  2. usage="transactional|read-write|nonstrict-read-write|read-only" (1)  
  3. region="RegionName" (2)  
  4. include="all|non-lazy" (3) />  
(1)usage(必须)说明了缓存的策略: transactional、 read-write、 nonstrict-read-write或 read-only。
(2) region (可选, 默认为类或者集合的名字) 指定第二级缓存的区域名
(3) include (可选,默认为 all) non-lazy 当属性级延迟抓取打开时, 标记为lazy="true"的实体的属性可能无法被缓存
可以在hibernate.cfg.xml 中指定<class-cache>和<collection-cache>元素
策略:只读缓存
如果你的应用程序只需读取一个持久化类的实例,而无需对其修改, 那么就可以对其进行只读 缓存。这是最简单,也是实用性最好的方法。甚至在集群中,它也能完美地运作。示例如下:
 
java代码:
  1. <class name="eg.Immutable" mutable="false">  
  2. <cache usage="read-only"/>  
  3. ....  
  4. </class>  
策略:读写缓存
如果应用程序需要更新数据,那么使用读/写缓存 比较合适。 如果应用程序要求
“serializable”的隔离级别,那么就决不能使用这种缓存策略。 如果在JTA环境中使用缓
存,必须指定hibernate.transaction.manager_lookup_class属性的值, 通过它,Hibernate
才能知道该应用程序中JTA的TransactionManager的具体策略。 在其它环境中,你必须保证在
Session.close()、或Session.disconnect()调用前, 整个事务已经结束。 如果你想在集群
环境中使用此策略,你必须保证底层的缓存实现支持锁定(locking)。Hibernate内置的缓存策
略并不支持锁定功能。

java代码:
  1. <class name="eg.Cat" .... >  
  2. <cache usage="read-write"/>  
  3. <set name="kittens" ... >  
  4. <cache usage="read-write"/>  
  5. ....  
  6. </set>  
  7.     </class>  
策略:非严格读写缓存Strategy: nonstrict read/write)
如果应用程序只偶尔需要更新数据(也就是说,两个事务同时更新同一记录的情
况很不常见),也不需要十分严格的事务隔离, 那么比较适合使用非严格读/写缓
存策略。如果在JTA环境中使用该策略, 你必须为其指定
hibernate.transaction.manager_lookup_class属性的值, 在其它环境中,你必须
保证在Session.close()、或Session.disconnect()调用前, 整个事务已经结束
策略:事务缓存
Hibernate的事务缓存策略提供了全事务的缓存支持, 例如对JBoss TreeCache
的支持。这样的缓存只能用于JTA环境中,你必须指定 为其
hibernate.transaction.manager_lookup_class属性
 
管理缓存
1:无论何时,当你给save()、update()或 saveOrUpdate()方法传递一个对象时,或使用load()、 get()、list()、iterate() 或scroll()方法获得一个对象时, 该对象都将被加入到Session的内部缓存中。
2:当随后flush()方法被调用时,对象的状态会和数据库取得同步。如果你不希望此同步操作发生,或者你正处理大量对象、需要对有效管理内存时,你可以调用evict() 方法,从一级缓存中去掉这些对象及其集合,如下示例:
 
ScrollableResult cats = sess.createQuery(“from Cat as cat”).scroll(); //很大的结果集,可滚动的结果集
while ( cats.next() ) {
   Cat cat = (Cat) cats.get(0);
   doSomethingWithACat(cat);
   sess.evict(cat);
}
 
3:Session还提供了一个contains()方法,用来判断某个实例是否处于当前session的缓存中。
4:如若要把所有的对象从session缓存中彻底清除,则需要调用Session.clear()。
5:对于二级缓存来说,在SessionFactory中定义了许多方法,清除缓存中实例、整个类、集合实例或者整个集合。

java代码:
  1. sessionFactory.evict(Cat.class, catId); //evict a particular Cat  
  2. sessionFactory.evict(Cat.class); //evict all Cats  
  3. sessionFactory.evictCollection(“Cat.kittens”, catId); //evict a particular collection of kittens  
  4. sessionFactory.evictCollection(“Cat.kittens”); //evict all kitten  
 
6:collections CacheMode参数用于控制具体的Session如何与二级缓存进行交互。
(1)CacheMode.NORMAL - 从二级缓存中读、写数据。
(2)CacheMode.GET - 从二级缓存读取数据,仅在数据更新时对二级缓存写数据。
(3)CacheMode.PUT - 仅向二级缓存写数据,但不从二级缓存中读数据。
(4)CacheMode.REFRESH - 仅向二级缓存写数据,但不从二级缓存中读数据。通过hibernate.cache.use_minimal_puts的设置,强制二级缓存从数据库中读取数据,刷新缓存内容。
 
查询缓存:查询的结果集也可以被缓存。只有当经常使用同样的参数进行查询时,这才会有些用处
1:要使用查询缓存,首先你必须打开hibernate.cache.use_query_cache为true.
2:该设置将会创建两个缓存区域 - 一个用于保存查询结果集(org.hibernate.cache.StandardQueryCache); 另一个则用于保存最近查询的一系列表的时间戳(org.hibernate.cache.UpdateTimestampsCache)。 请注意:在查询缓存中,它并不缓存结果集中所包含的实体的确切状态;它只缓存这些实体的标识符属性的值、以及各值类型的结果。 所以查询缓存通常会和二级缓存一起使用。
3:绝大多数的查询并不能从查询缓存中受益,所以Hibernate默认是不进行查询缓存的。如若需要进行缓存,请调用 Query.setCacheable(true)方法。这个调用会让查询在执行过程中时先从缓存中查找结果,并将自己的结果集放到缓存中去
 
以EHCache为例来说明二级缓存的配置
第一步:配置ehcache.xml,放置到classpath下面,配置如下:

java代码:
  1. <?xml version="1.0" encoding="UTF-8"?>  
  2. <ehcache>  
  3. <diskStore path="java.io.tmpdir"/>  
  4. <defaultCache  
  5.         maxElementsInMemory="10000"  
  6.         eternal="false"  
  7.         timeToIdleSeconds="120"  
  8.         timeToLiveSeconds="120"  
  9.         overflowToDisk="true"  
  10.         />  
  11. </ehcache>  
配置说明:
maxElementsInMemory :缓存最大数目
eternal :缓存是否持久
overflowToDisk : 是否保存到磁盘,当系统当机时
timeToIdleSeconds :当缓存闲置n秒后销毁
timeToLiveSeconds :当缓存存活n秒后销毁
 
第二步:在hibernate.cfg.xml中设置:
Hibernate4以前的版本:

java代码:
  1. <property name="hibernate.cache.use_second_level_cache">true</property>  
  2. <property name="cache.provider_class">org.hibernate.cache.EhCacheProvider</property>  
  3. <property name="cache.use_query_cache">false</property>  
Hibernate4的版本:

java代码:
  1. <property name="cache.use_query_cache">false</property>  
  2. <property name="cache.use_second_level_cache">true</property>  
  3. <property name="cache.region.factory_class">org.hibernate.cache.EhCacheRegionFactory</property>  
第三步:在hibernate.cfg.xml中设置需要缓存的类,还有缓存策略.
<class-cache class="cn.javass.h3.hello.UserModel" usage="read-only"/>
在测试文件中,如下:

java代码:
  1. s = sf.openSession();  
  2. t = s.beginTransaction();  
  3. UserModel um1 = (UserModel)s.load(UserModel.class"1");  
  4. System.out.println("um1=="+um1);  
  5. t.commit();  
  6. s = sf.openSession();  
  7. t = s.beginTransaction();  
  8. UserModel um2 = (UserModel)s.load(UserModel.class"1");  
  9. System.out.println("um2=="+um2);  
  10. t.commit();  
  11. s = sf.openSession();  
  12. t = s.beginTransaction();  
  13. UserModel um3 = (UserModel)s.load(UserModel.class"1");  
  14. System.out.println("um3=="+um3);  
  15. t.commit();  
然后就可以运行测试文件,看看输出的sql语句,一共有多少条?一条查询语句才是正确的,因为缓存起了作用。尝试去掉缓存的配置,测试文件不动,再次运行,看看输出的sql语句,一共有多少条?应该是三条了。
说明:如果不设置“查询缓存”,那么hibernate只会缓存使用load()方法获得的单个持久化对象,如果想缓存使用findall()、list()、Iterator()、createCriteria()、createQuery()等方法获得的数据结果集的话,就需要设置hibernate.cache.use_query_cache true才行。
下面看看查询缓存的示例
第一步:配置ehcache.xml,跟前面相同
第二步:配置hibernate.cfg.xml,在前面配置的基础上,添加:
配置是否使用查询缓存为true
<property name="hibernate.cache.use_query_cache">true</property>
第三步:在写程序的时候,还要设置Query的setCacheable(   true);
测试文件如下,运行一下看看,然后再去掉缓存配置运行一下看看:

java代码:
  1. s = sf.openSession();  
  2. t = s.beginTransaction();  
  3. Query query1 =s.createQuery("select Object(o) from UserModel o");  
  4. query1.setCacheable(true);  
  5. List list1 = query1.list();  
  6. System.out.println("list1=="+list1);  
  7. t.commit();  
  8. s = sf.openSession();  
  9. t = s.beginTransaction();  
  10. Query query2 =s.createQuery("select Object(o) from UserModel o");  
  11. query2.setCacheable(true);  
  12. List list2 = query2.list();  
  13. System.out.println("list2=="+list2);  
  14. t.commit();  
  15. s = sf.openSession();  
  16. t = s.beginTransaction();  
  17. Query query3 =s.createQuery("select Object(o) from UserModel o");  
  18. query3.setCacheable(true);  
  19. List list3 = query3.list();  
  20. System.out.println("list3=="+list3);  
  21. t.commit();  
  22.    

http://sishuok.com/forum/blogPost/list/2482.html
关于检索方式的文章:(比较详细)
标签: hibernate cache
  • 打赏
  • 点赞
  • 收藏
  • 分享
共有 人打赏支持
粉丝 15
博文 265
码字总数 394729
×
乐在克里特
如果觉得我的文章对您有用,请随意打赏。您的支持将鼓励我继续创作!
* 金额(元)
¥1 ¥5 ¥10 ¥20 其他金额
打赏人
留言
* 支付类型
微信扫码支付
打赏金额:
已支付成功
打赏金额: