hibernate 一级缓存：(缓存的是实体对象)
一级缓存很短和session的生命周期一致，一级缓存也叫session级的缓存或事务缓存
哪些方法支持一级缓存：
*get()
*load()
*iterate() (查询实体对象)
如何管理一级缓存：
* session.clear() session.evict()
如何避免一次性大量的实体数据入库导致内存溢出
*先flush，再clear
如果数据量特别大，考虑采用jdbc实现，如果jdbc也不能满足要求，可以考虑采用数据库本身的特定导入工具
一．Load测试: 在同一个session中发出两次load查询
Student sutdent = (Student)session.load(Student.class,1);
System.out.println(student.getName());
sutdent = (Student)session.load(Student.class,1);
System.out.println(student.getName());
在同一个session中发出两次load查询，第一次load的时候不会去查询数据库，因为他是LAZY的，当使用的时候才去查询数据库， 第二次load的时候也不会，当使用的时候也不会查询数据库，因为他在缓存里找到，不会发出sql
Load测试: 开启两个session中发出两次load查询
Student sutdent = (Student)session.load(Student.class,1);
System.out.println(student.getName());
sessioin.close();
………..
sutdent = (Student)session.load(Student.class,1);
System.out.println(student.getName());
开启两个session中发出两次load查询，第一次load的时候不会去查询数据库，因为他是LAZY的，当使用的时候才去查询数据库， 第二次load的时候也不会，当使用的时候查询数据库，因为session间不能共享一级缓存的数据,因为他会随session的生命周期存在和消亡
二．Get测试: 在同一个session中发出两次get查询
Student sutdent = (Student)session.get(Student.class,1);
System.out.println(student.getName());
sutdent = (Student)session.get(Student.class,1);
System.out.println(student.getName());
在同一个session中发出两次get查询， 第一次get的时候去查询数据库，第二次get的时候不会查询数据库，因为他在缓存里找到，不会发出sql
三．iterate测试: 在同一个session中发出两次iterator查询
Student student = (Student)session.createQuery(“from Student s where s.id=1”).iterate().next();
System.out.println(student.getName());
student = (Student)session.createQuery(“from Student s where s.id=1”).iterate().next();
System.out.println(student.getName());
在同一个session中发出两次iterator查询，第一次iterate().next()的时候会发出查询id的sql，使用的时候会发出相应的查询实体对象，第二次iterate().next()的时候会发出查询id的sql，不会发出查询实体对象的sql，因为iterate使用缓存，不会发出sql
四．Iterate查询属性测试: 同一个session中发出两次查询属性
String name = (String)session.createQuery(“select s.name from Student s where s.id=1”).iterate().next();
System.out.println(name);
String name = (String)session.createQuery(“select s.name from Student s where s.id=1”).iterate().next();
System.out.println(name);
在同一个session中发出两次查询属性， 第一次iterate().next()的时候会发出查询属性的sql，第二次iterate().next()的时候会发出查询属性的sql，iterate查询普通属性，一级缓存不会缓存，所以会发出sql
五．同一个session中先save，再发出load查询save过的数据
Student stu = new Student();
stu.setName(“王五”);
Serializable id = session.save(stu);
Student sutdent = (Student)session.load(Student.class,id);
System.out.println(student.getName());
save的时候，他会在缓存里放一份,不会发出sql，因为save是使用缓存的
六．同一个session中先调用load查询，然后执行sessio.clear()或session.evict()，再调用load查询
Student sutdent = (Student)session.load(Student.class,1);
System.out.println(student.getName());
session.clear();
Student sutdent = (Student)session.load(Student.class,1);
System.out.println(student.getName());
sessio.clear()或session.evict()可以管理一级缓存，一级缓存无法取消，但可以管理.
上面的语句都会发出sql 因为一级缓存中的实体被清除了
七．向数据库中批量加入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(hibernate中的)共享二级缓存的生命周期和SessionFactory的生命周期一致，SessionFactory可以管理二级缓存
二级缓存的配置和使用：
1.将echcache.xml文件拷贝到src下, 二级缓存hibernate默认是开启的，手动开启
2.开启二级缓存，修改hibernate.cfg.xml文件,
<property name=”hibernate.cache.user_second_level_cache”>true</property>
3.指定缓存产品提供商
<property name=”hibernate.cache.provider_calss”>org.hibernate.cache.EhCacheProvider</property>
4.指定那些实体类使用二级缓存（两种方法，推荐使用第二种）
第一种：在*.hbm.xml中，在<id>之前加入
<cache usage=”read-only” />, 使用二级缓存
第二种：在hibernate.cfg.xml配置文件中,在<mapping resource=”com/Studnet.hbm.xml” />后面加上：
<class-cache class=” com.Studnet” usage=”read-only” />
二级缓存是缓存实体对象的
了解一级缓存和二级缓存的交互
测试二级缓存：
一．开启两个session中发出两次load查询（get与load一样，同样不会查询数据库）,
Student sutdent = (Student)session.load(Student.class,1);
System.out.println(student.getName());
sessioin.close();
………..
sutdent = (Student)session.load(Student.class,1);
System.out.println(student.getName());
开启两个session中发出两次load查询，第一次load的时候不会去查询数据库，因为他是LAZY的，当使用的时候才去查询数据库， 第二次load的时候也不会，当使用的时候查询数据库，开启了二级缓存，也不会查询数据库。
二．开启两个session，分别调用load，再使用sessionFactory清楚二级缓存
Student sutdent = (Student)session.load(Student.class,1);
System.out.println(student.getName());
sessioin.close();
………..
SessionFactory factory = HibernateUtil.getSessionFactory();
//factory.evict(Student.class); //清除所有Student对象
Factory.evict(Student.class,1); //清除指定id=1 的对象
sutdent = (Student)session.load(Student.class,1);
System.out.println(student.getName());
开启两个session中发出两次load查询，第一次load的时候不会去查询数据库，因为他是LAZY的，当使用的时候才去查询数据库， 第二次load的时候也不会，当使用的时候查询数据库，它要查询数据库，因为二级缓存中被清除了
三．一级缓存和二级缓存的交互
session.setCacheMode(CacheMode.GET); //设置成 只是从二级缓存里读,不向二级缓存里写数据
Student sutdent = (Student)session.load(Student.class,1);
System.out.println(student.getName());
sessioin.close();
………..
SessionFactory factory = HibernateUtil.getSessionFactory();
//factory.evict(Student.class); //清除所有Student对象
Factory.evict(Student.class,1); //清除指定id=1 的对象
sutdent = (Student)session.load(Student.class,1);
System.out.println(student.getName());
开启两个session中发出两次load查询，第一次load的时候不会去查询数据库，因为他是LAZY的，当使用的时候才去查询数据库， 第二次load的时候也不会，当使用的时候查询数据库，它要查询数据库，因为 设置了CacheMode为GET,(load设置成不能往二级缓冲中写数据), 所以二级缓冲中没有数据
session.setCacheMode(CacheMode.PUT); //设置成只是向二级缓存里写数据，不读数据
Student sutdent = (Student)session.load(Student.class,1);
System.out.println(student.getName());
sessioin.close();
………..
SessionFactory factory = HibernateUtil.getSessionFactory();
//factory.evict(Student.class); //清除所有Student对象
Factory.evict(Student.class,1); //清除指定id=1 的对象
sutdent = (Student)session.load(Student.class,1);
System.out.println(student.getName());
开启两个session中发出两次load查询，第一次load的时候不会去查询数据库，因为他是LAZY的，当使用的时候才去查询数据库， 第二次load的时候也不会，当使用的时候查询数据库，它要查询数据库，因为设置了CacheMode为POST,(load设置成只是向二级缓存里写数据，不读数据)
====================================================================================
hibernate查询缓存(hibernate默认是关闭的)
查询缓存是针对普通属性结果集的缓存
对实体对象的结果集只缓存id
查询缓存的生命周期，当前关联的表发生修改，那么查询缓存生命周期结束
查询缓存的配置和使用：
1. 启用查询缓存：在hibernate.cfg.xml中加入：
<property name=”hibernate.cache.use_query_cache”>true</property>
2. 在程序中必须手动启用查询缓存，如：query.setCacheable(true);
测试查询缓存：
一． 开启查询缓存，关闭二级缓存，开启一个session，分别调用query.list （查询属性）
Query query = session.createQuery(“select s.name from Student s”);
//启用查询缓存
query.setCacheable(true);
List names = query.list();
for(Iterator iter = names.terator();iter.hasNext();){
String name = (String)iter.next();
System.out.println(name);
}
System.out.println(“------------------------------------------”);
query = session.createQuery(“select s.name from Student s”);
//启用查询缓存
query.setCacheable(true);
names = query.list();
for(Iterator iter = names.terator();iter.hasNext();){
String name = (String)iter.next();
System.out.println(name);
}
第二次没有去查询数据库，因为启用了查询缓存
二． 开启查询缓存，关闭二级缓存，开启两个session，分别调用query.list （查询属性）
Query query = session.createQuery(“select s.name from Student s”);
//启用查询
扫一扫
74
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
