航

• BlogJava
• 首页
• 新随笔
• 联系
• 聚合
• 管理

公告

留言簿(2)

• 给我留言
• 查看公开留言
• 查看私人留言

随笔分类

• Eclipse IDE(2) (rss)
• ExtJS(5) (rss)
• JFreeChart(17) (rss)
• jQuery Flot(1) (rss)
• 在路上(16) (rss)
• 程序人生(35) (rss)
• 软件开发工程师(3) (rss)
• 软件测试工程师(4) (rss)
• 软件硬件接口技术(1) (rss)

随笔档案

• 2009年5月 (1)
• 2009年4月 (36)
• 2009年3月 (2)
• 2009年2月 (5)
• 2009年1月 (35)

文章档案

• 2009年5月 (1)

相册

• myImage

阅读排行榜

• 1. jfreechart应用_例题_生成饼状图(3D,不显示，只生成文件）_可以直接运行 (1879)
• 2.  遍历两个日期之间天数的算法(1615)
• 3. 生成两个日期间的以天为间隔的折线图(web方式和控制台方式)(1562)
• 4. jfreechart应用_例题_生成饼状图(不显示，只生成文件）_可以直接运行(1130)
• 5. jfreechart应用_例题_生成柱状图 (不显示，只生成文件)_可以直接运行(1124)

评论排行榜

• 1.  遍历两个日期之间天数的算法(10)
• 2. MyEclipse 7.0快捷键大全[转载] (3)
• 3. jfreechart应用_例题_生成饼状图(3D,不显示，只生成文件）_可以直接运行 (3)
• 4. 生成两个日期间的以天为间隔的折线图(web方式和控制台方式)(2)
• 5. 深入探究JFreeChart（1）[转载] (0)

常用链接

• 我的随笔
• 我的评论
• 我的参与
• 最新评论

统计

• 随笔 - 85
• 文章 - 0
• 评论 - 20
• 引用 - 0

最新评论 

• 1. re: MyEclipse 7.0快捷键大全[转载] [未登录]
• 是啊，很讨厌！！
• --dd
• 2. re: MyEclipse 7.0快捷键大全[转载] [未登录]
• 挂羊头卖狗肉，很另人讨厌的懂不，不懂就不要上传了啦！！上传英文的先，打开工具一个个照写的吧！！
• --dd
• 3. re: MyEclipse 7.0快捷键大全[转载] [未登录]
• 会不会啊，上传英文？
• --dd
• 4. re: 遍历两个日期之间天数的算法
• 建议波主仔细学习calendar 类，不要重新发明轮子!
• --娃娃
• 5. re: 遍历两个日期之间天数的算法
• -.-有这么复杂吗? 
  遍历是相当的占资源的。
• --rapihibernate缓存【转载】

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

       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文件,

true

3.指定缓存产品提供商

org.hibernate.cache.EhCacheProvider

4.指定那些实体类使用二级缓存（两种方法，推荐使用第二种）

第一种：在*.hbm.xml中，在之前加入

, 使用二级缓存

第二种：在hibernate.cfg.xml配置文件中,在后面加上：

二级缓存是缓存实体对象的

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

测试二级缓存：

一．开启两个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中加入：

true

  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”);

//启用查询缓存

query.setCacheable(true);

List names = query.list();

for(Iterator iter = names.terator();iter.hasNext();){

       String name = (String)iter.next();

       System.out.println(name);

}

session.close();

System.out.println(“------------------------------------------”);

………

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);

}

第二次没有去查询数据库，因为查询缓存生命周期与session生命周期无关

三．  开启查询缓存，关闭二级缓存，开启两个session，分别调用query.iterate （查询属性）

Query query = session.createQuery(“select s.name from Student s”);

//启用查询缓存

query.setCacheable(true);

for(Iterator iter =query.iterate();iter.hasNext();){

       String name = (String)iter.next();

       System.out.println(name);

}

session.close();

System.out.println(“------------------------------------------”);

………

Query query = session.createQuery(“select s.name from Student s”);

//启用查询缓存

query.setCacheable(true);

for(Iterator iter = query.iterate();iter.hasNext();){

       String name = (String)iter.next();

       System.out.println(name);

}

第二去查询数据库，因为查询缓存只对query.list()起作用，对query.iterate()不起作用,也就是说query.iterate()不使用查询缓存

四．  关闭查询缓存，关闭二级缓存，开启两个session，分别调用query.list （查询实体对象）

Query query = session.createQuery(“ from Student s”);

//query.setCacheable(true);

List students = query.list();

for(Iterator iter = students.iterate();iter.hasNext();){

       Student stu = (Student)iter.next();

       System.out.println(stu.getName());

}

session.close();

System.out.println(“------------------------------------------”);

………

Query query = session.createQuery(“ from Student s”);

//query.setCacheable(true);

List students = query.list();

for(Iterator iter = students.iterate();iter.hasNext();){

       Student stu = (Student)iter.next();

       System.out.println(stu.getName());

}

第二去查询数据库，因为list默认每次都会发出查询sql

五．  开启查询缓存，关闭二级缓存，开启两个session，分别调用query.list （查询实体对象）

Query query = session.createQuery(“ from Student s”);

query.setCacheable(true);

List students = query.list();

for(Iterator iter = students.iterate();iter.hasNext();){

       Student stu = (Student)iter.next();

       System.out.println(stu.getName());

}

session.close();

System.out.println(“------------------------------------------”);

………

Query query = session.createQuery(“ from Student s”);

query.setCacheable(true);

List students = query.list();

for(Iterator iter = students.iterate();iter.hasNext();){

       Student stu = (Student)iter.next();

       System.out.println(stu.getName());

} 

第二去查询数据库时，会发出N条sql语句，因为开启了查询缓存，关闭了二级缓存，那么查询缓存会缓存实体对象的id，所以hibernate会根据实体对象的id去查询相应的实体，如果缓存中不存在相应的实体，那么将发出根据实体id查询的sql语句，否则不会发出sql，使用缓存中的数据

六．  开启查询缓存，开启二级缓存，开启两个session，分别调用query.list （查询实体对象）

Query query = session.createQuery(“ from Student s”);

query.setCacheable(true);

List students = query.list();

for(Iterator iter = students.iterate();iter.hasNext();){

       Student stu = (Student)iter.next();

       System.out.println(stu.getName());

}

session.close();

System.out.println(“------------------------------------------”);

………

Query query = session.createQuery(“ from Student s”);

query.setCacheable(true);

List students = query.list();

for(Iterator iter = students.iterate();iter.hasNext();){

       Student stu = (Student)iter.next();

       System.out.println(stu.getName());

}

第二不会发出sql，因为开启了二级缓存和查询缓存，查询缓存缓存了实体对象的id列表，hibernate会根据实体对象的id列表到二级缓存中取得相应的数据

posted on 2009-04-08 17:08 liudecai_zan@126.com 阅读(226) 评论(0)  编辑  收藏 所属分类: 程序人生

• JIRA安装手记【转载】
• Web应用程序性能调优【转载】
• 开发一个WEB产品可能用到的技术【转载】
• 被裁员后，路该怎么走？【转载】
• 别让你的简历15秒后被扔掉的秘籍【转载】
• MySql常用命令总结【转载】
• Windows下的Apache+MySQL+PHP运行环境的搭建基础篇【转载】
• 2009年10个必须知道的软件架构主题【转载】
• 正则表达式【转载】
• JavaScript判断浏览器类型及版本【转载】

Powered by: 
BlogJava 
Copyright © liudecai_zan@126.com