hibernate的缓存

2010-10-24

hibernate的缓存

文章分类:Java编程

hibernate一级缓存
 
一级缓存很短和session的生命周期一致，一级缓存也叫session级的缓存或事务级缓存

那些方法支持一级缓存：
 * get()
 * load()
 * iterate（查询实体对象）
 
如何管理一级缓存：
 * session.clear(),session.evict()
 
如何避免一次性大量的实体数据入库导致内存溢出
 * 先flush，再clear
 
如果数据量特别大，考虑采用jdbc实现，如果jdbc也不能满足要求可以考虑采用数据本身的特定导入工具

一级缓存代码

1. //在同一个session中发出两次load查询   
2. Student student = (Student)session.load(Student.class, 1);   
3. System.out.println("student.name=" + student.getName());   
4.   
5. //不会发出sql，因为load使用缓存   
6. student = (Student)session.load(Student.class, 1);   
7. System.out.println("student.name=" + student.getName());   
8.   
9. //在同一个session中发出两次get查询   
10. Student student = (Student)session.get(Student.class, 1);   
11. System.out.println("student.name=" + student.getName());   
12.   
13. //不会发出sql，因为get使用缓存   
14. student = (Student)session.get(Student.class, 1);   
15. System.out.println("student.name=" + student.getName());   
16.   
17. //在同一个session中发出两次iterate查询实体对象   
18. Student student = (Student)session.createQuery("from Student s where s.id=1").iterate().next();   
19. System.out.println("student.name=" + student.getName());   
20.   
21. //会发出查询id的sql，不会发出查询实体对象的sql，因为iterate使用缓存   
22. student = (Student)session.createQuery("from Student s where s.id=1").iterate().next();   
23. System.out.println("student.name=" + student.getName());   
24.   
25. //在同一个session中发出两次iterate查询实体对象   
26. String name = (String)session.createQuery("select s.name from Student s where s.id=1").iterate().next();   
27. System.out.println("student.name=" + name);   
28.   
29. //iterate查询普通属性，一级缓存不会缓存，所以发出sql   
30. //一级缓存是缓存实体对象的   
31. name = (String)session.createQuery("select s.name from Student s where s.id=1").iterate().next();   
32. System.out.println("student.name=" + name);   
33.   
34. //开启两个session中发出load查询   
35. try {   
36.      session = HibernateSessionFactory.getSession();   
37.      session.beginTransaction();   
38.         
39.      Student student = (Student)session.load(Student.class, 1);   
40.      System.out.println("student.name=" + student.getName());   
41.   
42.      session.getTransaction().commit();   
43.         }catch(Exception e) {   
44.      e.printStackTrace();   
45.      session.getTransaction().rollback();   
46.         }finally {   
47.      HibernateSessionFactory.closeSession(session);   
48.         }   
49.            
50. try {   
51.      session = HibernateSessionFactory.getSession();   
52.      session.beginTransaction();   
53.         
54.      //会发出查询语句，session间不能共享一级缓存的数据   
55.      //因为它会伴随session的生命周期存在和消亡   
56.      Student student = (Student)session.load(Student.class, 1);   
57.      System.out.println("student.name=" + student.getName());   
58. //在同一个session中先save，在发出load查询save过的数据   
59. Student stu = new Student();   
60. stu.setName("王五");   
61. Serializable id = session.save(stu);   
62.   
63. //不会发出sql，因为save是使用缓存的   
64. Student student = (Student)session.load(Student.class, id);   
65. System.out.println("student.name=" + student.getName());   
66. //向数据库中批量加入1000条数据   
67. for (int i=0; i<1000; i++) {   
68. Student student = new Student();   
69. student.setName("s_" + i);   
70. session.save(student);   
71. //每20条数据就强制session将数据持久化   
72. //同时清除缓存，避免大量数据造成内存溢出   
73. if ( i % 20 == 0) {   
74.     session.flush();   
75.     session.clear();   
76. }   
77. }  

//在同一个session中发出两次load查询Student student = (Student)session.load(Student.class, 1);System.out.println("student.name=" + student.getName());//不会发出sql，因为load使用缓存student = (Student)session.load(Student.class, 1);System.out.println("student.name=" + student.getName());//在同一个session中发出两次get查询Student student = (Student)session.get(Student.class, 1);System.out.println("student.name=" + student.getName());//不会发出sql，因为get使用缓存student = (Student)session.get(Student.class, 1);System.out.println("student.name=" + student.getName());//在同一个session中发出两次iterate查询实体对象Student student = (Student)session.createQuery("from Student s where s.id=1").iterate().next();System.out.println("student.name=" + student.getName());//会发出查询id的sql，不会发出查询实体对象的sql，因为iterate使用缓存student = (Student)session.createQuery("from Student s where s.id=1").iterate().next();System.out.println("student.name=" + student.getName());//在同一个session中发出两次iterate查询实体对象String name = (String)session.createQuery("select s.name from Student s where s.id=1").iterate().next();System.out.println("student.name=" + name);//iterate查询普通属性，一级缓存不会缓存，所以发出sql//一级缓存是缓存实体对象的name = (String)session.createQuery("select s.name from Student s where s.id=1").iterate().next();System.out.println("student.name=" + name);//开启两个session中发出load查询try {session = HibernateSessionFactory.getSession();session.beginTransaction();Student student = (Student)session.load(Student.class, 1);System.out.println("student.name=" + student.getName());session.getTransaction().commit();}catch(Exception e) {e.printStackTrace();session.getTransaction().rollback();}finally {HibernateSessionFactory.closeSession(session);}try {session = HibernateSessionFactory.getSession();session.beginTransaction();//会发出查询语句，session间不能共享一级缓存的数据//因为它会伴随session的生命周期存在和消亡Student student = (Student)session.load(Student.class, 1);System.out.println("student.name=" + student.getName());//在同一个session中先save，在发出load查询save过的数据Student stu = new Student();stu.setName("王五");Serializable id = session.save(stu);//不会发出sql，因为save是使用缓存的Student student = (Student)session.load(Student.class, id);System.out.println("student.name=" + student.getName());//向数据库中批量加入1000条数据for (int i=0; i<1000; i++) {Student student = new Student();student.setName("s_" + i);session.save(student);//每20条数据就强制session将数据持久化//同时清除缓存，避免大量数据造成内存溢出if ( i % 20 == 0) {session.flush();session.clear();}}

 hibernate二级缓存

二级缓存也称进程级的缓存或SessionFactory级的缓存，二级缓存可以被所有的session共享
二级缓存的生命周期和SessionFactory的生命周期一致，SessionFactory可以管理二级缓存

二级缓存的配置和使用：
 * 将echcache.xml文件拷贝到src下
 * 开启二级缓存，修改hibernate.cfg.xml文件
  <property name="hibernate.cache.use_second_level_cache">true</property>
 * 指定缓存产品提供商，修改hibernate.cfg.xml文件
  <property name="hibernate.cache.provider_class">org.hibernate.cache.EhCacheProvider</property>
 * 指定那些实体类使用二级缓存（两种方法）
  * 在映射文件中采用<cache>标签
  * 在hibernate.cfg.xml文件中，采用<class-cache>标签
  
二级缓存是缓存实体对象的

了解一级缓存和二级缓存的交互 

二级缓存代码

1. //开启两次session，使用load和get方法家在数据都在第二次加载数据不会出现hql语句，因为session共享二级缓存   
2. Student student = (Student)session.get(Student.class, 1);   
3. System.out.println("student.name=" + student.getName());   
4. //关了，又开了session   
5. //不会发出sql，因为开启了二级缓存，session是共享二级缓存的   
6. Student student = (Student)session.get(Student.class, 1);   
7. System.out.println("student.name=" + student.getName());   
8. // 开启两个session，分别调用load,在使用SessionFactory清除二级缓存   
9. Student student = (Student)session.load(Student.class, 1);   
10. System.out.println("student.name=" + student.getName());   
11. //管理二级缓存   
12. SessionFactory factory = HibernateSessionFactory.getSessionFactory();   
13. factory.evict(Student.class, 1);   
14. //关了，又开了session   
15. //会发出查询sql，因为二级缓存中的数据被清除了   
16. Student student = (Student)session.load(Student.class, 1);   
17. System.out.println("student.name=" + student.getName());   
18. //一级缓存和二级缓存的交互   
19. //仅向二级缓存读数据，而不向二级缓存写数据   
20. session.setCacheMode(CacheMode.GET);   
21. Student student = (Student)session.load(Student.class, 1);   
22. System.out.println("student.name=" + student.getName());   
23. //关了，又开了session   
24. //发出sql语句，因为session设置了CacheMode为GET，所以二级缓存中没有数据   
25. Student student = (Student)session.load(Student.class, 1);   
26. System.out.println("student.name=" + student.getName());   
27. //关了，又开了session   
28. //只向二级缓存写数据，而不从二级缓存读数据   
29. session.setCacheMode(CacheMode.PUT);   
30. //会发出查询sql，因为session将CacheMode设置成了PUT   
31. Student student = (Student)session.load(Student.class, 1);   
32. System.out.println("student.name=" + student.getName());  

//开启两次session，使用load和get方法家在数据都在第二次加载数据不会出现hql语句，因为session共享二级缓存Student student = (Student)session.get(Student.class, 1);System.out.println("student.name=" + student.getName());//关了，又开了session//不会发出sql，因为开启了二级缓存，session是共享二级缓存的Student student = (Student)session.get(Student.class, 1);System.out.println("student.name=" + student.getName());// 开启两个session，分别调用load,在使用SessionFactory清除二级缓存Student student = (Student)session.load(Student.class, 1);System.out.println("student.name=" + student.getName());//管理二级缓存SessionFactory factory = HibernateSessionFactory.getSessionFactory();factory.evict(Student.class, 1);//关了，又开了session//会发出查询sql，因为二级缓存中的数据被清除了Student student = (Student)session.load(Student.class, 1);System.out.println("student.name=" + student.getName());//一级缓存和二级缓存的交互//仅向二级缓存读数据，而不向二级缓存写数据session.setCacheMode(CacheMode.GET);Student student = (Student)session.load(Student.class, 1);System.out.println("student.name=" + student.getName());//关了，又开了session//发出sql语句，因为session设置了CacheMode为GET，所以二级缓存中没有数据Student student = (Student)session.load(Student.class, 1);System.out.println("student.name=" + student.getName());//关了，又开了session//只向二级缓存写数据，而不从二级缓存读数据session.setCacheMode(CacheMode.PUT);//会发出查询sql，因为session将CacheMode设置成了PUTStudent student = (Student)session.load(Student.class, 1);System.out.println("student.name=" + student.getName());

 hibernate查询缓存

查询缓存是针对普通属性结果集的缓存
对实体对象的结果集只缓存id

查询缓存的生命周期，当前关联的表发生修改，那么查询缓存生命周期结束

查询缓存的配置和使用：
 * 在hibernate.cfg.xml文件中启用查询缓存，如：
 <property name="hibernate.cache.use_query_cache">true</property>
 * 在程序中必须手动启用查询缓存，如：
 query.setCacheable(true);

查询缓存代码

1. Query query = session.createQuery("select s.name from Student s");   
2. //启用查询查询缓存   
3. query.setCacheable(true);   
4.   
5. List names = query.list();    
6. for (Iterator iter=names.iterator();iter.hasNext(); ) {   
7.     String name = (String)iter.next();   
8.     System.out.println(name);   
9. }   
10.   
11. System.out.println("-------------------------------------");   
12. query = session.createQuery("select s.name from Student s");   
13. //启用查询查询缓存   
14. query.setCacheable(true);   
15.   
16. //没有发出查询sql，因为启用了查询缓存   
17. names = query.list();    
18. for (Iterator iter=names.iterator();iter.hasNext(); ) {   
19.     String name = (String)iter.next();   
20.     System.out.println(name);   
21. }