hibernate二级缓存的实现
- 格式：pdf
- 大小：132.34 KB
- 文档页数：15
下载文档原格式
合集下载
hibernate框架的工作原理
hibernate框架的工作原理Hibernate框架的工作原理Hibernate是一个开源的ORM(Object-Relational Mapping)框架，它将Java对象映射到关系型数据库中。
它提供了一种简单的方式来处理数据持久化，同时也提供了一些高级特性来优化性能和可维护性。
1. Hibernate框架的基本概念在开始讲解Hibernate框架的工作原理之前，需要先了解一些基本概念：Session：Session是Hibernate与数据库交互的核心接口，它代表了一个会话，可以用来执行各种数据库操作。
SessionFactory：SessionFactory是一个线程安全的对象，它用于创建Session对象。
通常情况下，应用程序只需要创建一个SessionFactory对象。
Transaction：Transaction是对数据库操作进行事务管理的接口。
在Hibernate中，所有对数据库的操作都应该在事务中进行。
Mapping文件：Mapping文件用于描述Java类与数据库表之间的映射关系。
它定义了Java类属性与数据库表字段之间的对应关系。
2. Hibernate框架的工作流程Hibernate框架主要分为两个部分：持久化层和业务逻辑层。
其中，持久化层负责将Java对象映射到数据库中，并提供数据访问接口；业务逻辑层则负责处理业务逻辑，并调用持久化层进行数据访问。
Hibernate框架的工作流程如下：2.1 创建SessionFactory对象在应用程序启动时，需要创建一个SessionFactory对象。
SessionFactory是一个线程安全的对象，通常情况下只需要创建一个即可。
2.2 创建Session对象在业务逻辑层需要进行数据访问时，需要先创建一个Session对象。
Session是Hibernate与数据库交互的核心接口，它代表了一个会话，可以用来执行各种数据库操作。
2.3 执行数据库操作在获取了Session对象之后，就可以执行各种数据库操作了。
高等数学在线考试系统的设计与实现
高等数学在线考试系统的设计与实现摘要：在线考试系统作为一种新的考试方式已越来越多地被应用到各个领域和专业。
然而高等数学因其众多的公式，实现在线考试还存在着技术困难。
该文论述了一种高等数学在线考试系统的设计和实现过程。
它采用s2sh框架，并且使用了apache+tomcat的集群技术增加负载量。
填空题使用图片的形式作答，运用blob格式存储答案并应用识图功能对填空题进行自动阅卷。
关键词：高等数学；在线考试；集群技术；填空题；blob；自动阅卷中图分类号：tp311 文献标识码： a 文章编号：1009-3044（2013）13-3028-041 概述近年来，计算机和信息技术迅猛发展，传统的教学技术越来越多地融入了计算机的环节。
考试作为教育的检测手段，也在发生着巨大的变革。
和传统意义的考试相比，在线考试有着节省资源、时间和人力的优势。
如今，越来越多的专业和领域应用了在线考试系统。
然而，数学因为其自身科目的独特性，其在线考试系统与其他在线考试系统有着明显的区别。
数学需要用到许多的公式，而普通的文本格式显然不能满足其要求。
该文设计了一个高等数学的在线考试系统。
我们运用集群技术增加了系统负载量，并用图片格式和blob 格式存储题目和答案的公式，解决了高等数学在线考试系统实现的困难。
2 系统结构2.1 b/s模式本系统采用了流行的b/s模式。
b/s模式采用三层结构，第一层浏览器端发出http请求，第二层应用服务器响应请求并处理。
如果请求是存取数据的，则第二层与第三层的数据库服务器完成交互。
完成请求后应用服务器生成一串html代码返回给浏览器端，浏览器解析html代码后生成图文并茂的网页。
考生只要在客户端使用浏览器便可以进行在线考试。
这样，客户端无须再安装相应的应用程序，只要有浏览器即可。
这达成了瘦客户端的目的，有利于开放式的信息管理和设计，也降低了系统的开发和维护开销，并且有效地提高了考试数据的安全性。
2.2 s2sh框架本系统采用s2sh的构架，即struts2，spring，hibernate的构架。
SSH考试
一、填空（20分）1．Struts 2框架由___________和___________框架发展而来。
2．Struts 2以___________为核心，采用___________的机制来处理用户的请求。
3．构建Struts 2应用的最基础的几个类库是___________、___________、___________、___________以及___________。
4．Struts 2中的控制器类是一个普通的___________。
5．如果要在JSP页面中使用Struts 2提供的标签库，首先必须在页面中使用taglib编译指令导入标签库，其中taglib编译指令为___________。
6．在Struts 2表单标签库中，表单标签为___________。
7．ActionSupport类实现了___________接口和___________等接口。
8．通过控制器类中的___________方法来输出校验错误信息。
9. Struts 2以__________为核心控制器，它的初始化方法为__________。
10．Struts2的核心配置文件是___________。
11. ORM的中文名称是__________。
12.hibernate有两种配置文件形式，一种是XML默认为__________；一种是properties默认为__________。
13.spring的依赖注入有三种形式__________、__________、__________。
14.EJB有三种类型：会话Bean、__________、__________。
15. JPA的中文名称__________。
16. hibernate的核心是SessionFactory和Session,其中__________是线程安全的。
17.spring的核心技术有__________和__________。
18．Session Bean 分为__________和__________两种。
java二级缓存原理
java二级缓存原理Java二级缓存原理随着互联网的发展和应用程序的复杂化，对于数据的访问和处理速度要求也越来越高。
在Java中，缓存技术被广泛应用于提高系统的性能和响应速度。
其中，二级缓存是一种常用的缓存技术，可以有效地减少对数据库等资源的访问次数，提高系统的性能。
一、什么是二级缓存二级缓存是指在应用程序和数据库之间添加一层缓存，用于存储频繁访问的数据。
通常情况下，二级缓存会将数据存储在内存中，以提高数据的访问速度。
相比一级缓存（即应用内存中的缓存），二级缓存具有更大的容量和更高的性能。
二、为什么需要二级缓存在大多数应用程序中，对于频繁访问的数据，每次都直接从数据库中读取会导致较高的数据库负载和较慢的响应速度。
而通过使用二级缓存，可以将这些数据缓存在内存中，减少对数据库的访问次数，从而提高系统的性能和响应速度。
三、二级缓存的实现原理1. 缓存的数据结构二级缓存通常使用哈希表或者红黑树等数据结构来存储缓存数据。
这些数据结构具有快速的查找和插入操作，可以提高数据的访问效率。
2. 缓存的更新策略为了保证缓存数据的及时性和准确性，二级缓存需要实现一定的更新策略。
常见的更新策略有以下几种：- 缓存失效策略：当缓存中的数据过期或者被修改时，将其标记为失效状态，并在下次访问时更新缓存数据。
- 定时刷新策略：定期清理缓存中的失效数据，并从数据库中重新加载最新的数据。
- 主动更新策略：当数据库中的数据发生变化时，通过数据库触发器或者消息队列等机制，自动更新缓存中的数据。
3. 缓存的淘汰策略当缓存中的数据量超过一定的限制时，为了避免内存溢出，需要实现一定的淘汰策略。
常见的淘汰策略有以下几种：- 先进先出（FIFO）策略：将最早进入缓存的数据淘汰出去。
- 最少使用（LFU）策略：将最少被访问的数据淘汰出去。
- 最近最少使用（LRU）策略：将最近最少被访问的数据淘汰出去。
4. 缓存的一致性由于缓存数据是存储在内存中的，可能会出现缓存与数据库数据不一致的情况。
java中常用jar包
java中常⽤jar包commons-io.jar：可以看成是java.io的扩展，⽤来帮助进⾏IO功能开发．它包含三个主要的领域:Utilityclasses-提供⼀些静态⽅法来完成公共任务．Filters-提供⽂件过滤器的各种实现．Streams-提供实⽤的Stream，reader与writer实现．commons-beanutils.jar：提供对Java反射和⾃省API的包装，主要提供了对于 JavaBean进⾏各种操作。
commons-digester.jar:它能⽅便地将XML⽂档所定义的元素转化为JAVA对象，其实它的⽤法有点象栈(当然内在的原理就是那个古⽼的东西,只是提供了更⾼⼀层的封装)。
commons-lang.jar:它扩展了标准 ngAPI，增加了字符串操作⽅法、基本数值⽅法、对象反射、创建和串⾏化以及System属性。
它还包含⼀个可继承的enum类型、对多种嵌套的Exception类型的⽀持、对java.util.Date的增强以及⽤于构建⽅法的实⽤程序，例如⾃动⽣成 toString()的结果、⾃动实现hashCode()和equals()⽅法、数组操作、枚举、⽇期和时间的处理等等。
ArrayUtils–⽤于对数组的操作，如添加、查找、删除、⼦数组、倒序、元素类型转换等；BitField–⽤于操作位元，提供了⼀些⽅便⽽安全的⽅法；BooleanUtils–⽤于操作和转换boolean或者Boolean及相应的数组；CharEncoding–包含了Java环境⽀持的字符编码，提供是否⽀持某种编码的判断；CharRange–⽤于设定字符范围并做相应检查；CharSet–⽤于设定⼀组字符作为范围并做相应检查；CharSetUtils–⽤于操作CharSet；CharUtils–⽤于操作char值和Character对象；ClassUtils–⽤于对Java类的操作，不使⽤反射；ObjectUtils–⽤于操作Java对象，提供null安全的访问和其他⼀些功能；RandomStringUtils–⽤于⽣成随机的字符串；SerializationUtils–⽤于处理对象序列化，提供⽐⼀般Java序列化更⾼级的处理能⼒；StringEscapeUtils–⽤于正确处理转义字符，产⽣正确的Java、JavaScript、HTML、XML和SQL代码；StringUtils–处理String的核⼼类，提供了相当多的功能；SystemUtils–在ng.System基础上提供更⽅便的访问，如⽤户路径、Java版本、时区、操作系统等判断；Validate–提供验证的操作，有点类似assert断⾔；WordUtils–⽤于处理单词⼤⼩写、换⾏等。
hibernate配置文件说明
create：每次加载hibernate时都会删除上一次的生成的表，然后根据你的model类再重新来生成新表，哪怕两次没有任何改变也要这样执行。会导致数据库表数据丢失。
create-drop: 每次加载hibernate时根据model类生成表，但是sessionFactory一关闭,表就自动删除。
（2）hibernate.show_sql打印所有的SQL语句到控制台，可以通过设置org.hibernate.SQL类的日志策略到DEBUG级，实现同样的效果。取值 true|false。
（3）hibernate.format_sql 格式化SQL语句在打印到控制台或写入日志文件时。取值true|false。
hibernate.cache.provider_class=org.hibernate.cache.SingletonEhCacheProvider
hibernate.cache.provider_class=org.hibernate.cache.EhCacheProvider
# 二级缓存配置文件
#Batch Size越大，批量操作的向数据库发送sql的次数越少，速度就越快。
hibernate.jdbc.batch_size=50
#设置外连接抓取树的最大深度取值. 建议设置为0到3之间
#hibernate.max_fetch_depth
#是否显示最终执行的SQL(开发环境)
hibernate.show_sql=false
# 格式化显示的SQL
hibernate.format_sql=false
# 如果设置为true，Hiberante将为SQL产生注释，这样更利于调试。默认值为false。取值为true|false。
三 大 框 架
三大框架一．Struts2简介：Struts 2是Struts的下一代产品，是在 struts 1和WebWork的技术基础上进行了合并的全新的Struts 2框架。
其全新的Struts 2的体系结构与Struts 1的体系结构差别巨大。
Struts 2以WebWork为核心，采用拦截器的机制来处理用户的请求，这样的设计也使得业务逻辑控制器能够与Servlet API完全脱离开，所以Struts 2可以理解为WebWork的更新产品。
虽然从Struts 1到Struts 2有着太大的变化，但是相对于WebWork，Struts 2的变化很小。
拦截器：拦截器，在AOP（Aspect-Oriented Programming）中用于在某个方法或字段被访问之前，进行拦截然后在之前或之后加入某些操作。
拦截是AOP 的一种实现策略。
在Webwork的中文文档的解释为——拦截器是动态拦截Action调用的对象。
它提供了一种机制可以使开发者可以定义在一个action执行的前后执行的代码，也可以在一个action执行前阻止其执行。
同时也是提供了一种可以提取action中可重用的部分的方式。
谈到拦截器，还有一个词大家应该知道——拦截器链（Interceptor Chain，在Struts 2中称为拦截器栈Interceptor Stack）。
拦截器链就是将拦截器按一定的顺序联结成一条链。
在访问被拦截的方法或字段时，拦截器链中的拦截器就会按其之前定义的顺序被调用。
拦截器实现原理：大部分时候，拦截器方法都是通过代理的方式来调用的。
Struts 2的拦截器实现相对简单。
当请求到达Struts 2的ServletDispatcher 时，Struts 2会查找配置文件，并根据其配置实例化相对的拦截器对象，然后串成一个列表（list），最后一个一个地调用列表中的拦截器返回类型区别：struts2中关于result的返回类型一般我们是转发到一个jsp页面或者是html页面等，但是struts2中的result的返回类型还有redirect,redirectAction,chain。
jpa二级缓存设置专业资料
共 12 页
第 2 页
sheagle@
ehcache 缓存设置
缓存的软件实现 在 Hibernate 的 Session 的实现中包含了缓存的实现 由第三方提供， Hibernate 仅提供了缓存适配器(CacheProvider)。 用于把特定的缓存插件集成到 Hibernate 中。 启用缓存的方式 只要应用程序通过 Session 接口来执行保存、更新、删除、加载和查 询数据库数据的操作，Hibernate 就会启用第一级缓存，把数据库中的数据以对象的形式拷 贝到缓存中，对于批量更新和批量删除操作，如果不希望启用第一级缓存，可以绕过 Hibernate API，直接通过 JDBC API 来执行指操作。 用户可以在单个类或类的单个集合的 粒度上配置第二级缓存。 如果类的实例被经常读但很少被修改， 就可以考虑使用第二级缓存。 只有为某个类或集合配置了第二级 缓存，Hibernate 在运行时才会把它的实例加入到第二 级缓存中。 用户管理缓存的方式 第一级缓存的物理介质为内存，由于内存容量有限，必须通过恰 当的检索策略和检索方式来限制加载对象的数目。 Session 的 evit()方法可以显式清空缓存 中特定对象，但这种方法不值得推荐。 第二级缓存的物理介质可以是内存和硬盘，因此第 二级缓存可以存放大量的数据， 数据过期策略的 maxElementsInMemory 属性值可以控制内存 中 的对象数目。管理第二级缓存主要包括两个方面：选择需要使用第二级缓存的持久类， 设置合适的并发访问策略：选择缓存适配器，设置合适的数据过期策略。
2.3.5 配置二级缓存的主要步骤： 1) 选择需要使用二级缓存的持久化类，设置它的命名缓存的并发访问策略。这是最值 得认真考虑的步骤。 2) 选择合适的缓存插件，然后编辑该插件的配置文件。
Hibernate
有两种手动干预内部缓存的方法：
a. Session.evict
将某个特定对象从内部缓存中清楚
b. Session.clear
清空内部缓存
当批量插入数据时，会引发内存溢出，这就是由于内部缓存造成的。例如：
For(int i=0; i<1000000; i++){
For(int j=0; j<1000000; j++){
session.iterate(…)方法和session.find(…)方法的区别：session.find(…)方法并不读取ClassCache，它通过查询语句直接查询出结果数据，并将结果数据put进classCache；session.iterate(…)方法返回id序列，根据id读取ClassCache，如果没有命中在去DB中查询出对应数据。
User user = new User();
user.setUserName(“gaosong”);
user.setPassword(“123”);
session.save(user);
}
}
在每次循环时，都会有一个新的对象被纳入内部缓存中，所以大批量的插入数据会导致内存溢出。解决办法有两种：a 定量清除内部缓存 b 使用JDBC进行批量导入，绕过缓存机制。
user.setLoginName("jonny");
mit();
session2 .close();
这种方式，关联前后是否做修改很重要，关联前做的修改不会被更新到数据库，
比如关联前你修改了password，关联后修改了loginname，事务提交时执行的update语句只会把loginname更新到数据库
a. Session.evict
将某个特定对象从内部缓存中清楚
b. Session.clear
清空内部缓存
当批量插入数据时，会引发内存溢出，这就是由于内部缓存造成的。例如：
For(int i=0; i<1000000; i++){
For(int j=0; j<1000000; j++){
session.iterate(…)方法和session.find(…)方法的区别：session.find(…)方法并不读取ClassCache，它通过查询语句直接查询出结果数据，并将结果数据put进classCache；session.iterate(…)方法返回id序列，根据id读取ClassCache，如果没有命中在去DB中查询出对应数据。
User user = new User();
user.setUserName(“gaosong”);
user.setPassword(“123”);
session.save(user);
}
}
在每次循环时，都会有一个新的对象被纳入内部缓存中，所以大批量的插入数据会导致内存溢出。解决办法有两种：a 定量清除内部缓存 b 使用JDBC进行批量导入，绕过缓存机制。
user.setLoginName("jonny");
mit();
session2 .close();
这种方式，关联前后是否做修改很重要，关联前做的修改不会被更新到数据库，
比如关联前你修改了password，关联后修改了loginname，事务提交时执行的update语句只会把loginname更新到数据库
Java软件开发工程师笔试题(答案)
Java工程师笔试题一、填空题(本大题10小题,每空1分，共20分)。
1.Java语言的三大特性即是: 继承、封装、多态。
2.在Java中，char 型采用____unicode_______编码方案,这样，无论是中文字符还是英文字符,都是占用__2___个字节的内存空间。
3. 形式参数指的是方法被__定义____ 时的参数行，实际参数是方法被__调用___ 时所传递进去的变量或值。
4.JSP户专用的。
6.程序中实现多线程的方法有两种:继承Thread类和实现___Runable _ 接口。
8.面向对象编程的五大设计原则，分别是单一职责、开放封闭、里氏替换、依赖倒置、接口分离9.通过Ajax，客户端获取的数据主要有两种类型：文本型和xml10.Socket通常也称为套接字，用于描述__ ip 和_ _接口二、选择题(本大题20 小题，每小题2分.共40分)。
1.在JA V A中，如果父类中某些方法不包含任何逻辑，并且需要由子类重写.应该使用( )关键字来声明父类的这些方法:A) final B) static C) abstract D) void2.在JA V A中，已定义两个接口B和C,要定义一个实现这两个接口的类，以下语句正确的是（）。
A) interface A extend B,C B) interface A implements B,CC) class A implements B,C D) class A implements B, implements C3.在JA V A接口中可以定义( )。
A) 静态方法B) 常量C) 构造方法D) 抽象方法4.假设A有构造方法A (int a),则在类A的其他构造方法中调用该构造方法和语句格式应为（）。
A) A(X) B) this.A(x) C) this(x) D) super(x)5.设x = 1 ,y = 2 , z = 3, 则表达式y+=z--/++x 的值是( )。
- 1、下载文档前请自行甄别文档内容的完整性，平台不提供额外的编辑、内容补充、找答案等附加服务。
- 2、"仅部分预览"的文档,不可在线预览部分如存在完整性等问题,可反馈申请退款(可完整预览的文档不适用该条件!)。
- 3、如文档侵犯您的权益，请联系客服反馈,我们会尽快为您处理(人工客服工作时间：9:00-18:30)。
private Team team;//班级 public String getName() ...{ return name; }
public void setId(String id) ...{ this.id = id; }
public void setName(String stuName) ...{ = stuName; } public String getId() ...{ return id; } public Student() ...{ //无参的构造函数 }
缓存就是数据库数据在内存中的临时容器,包括数据库数据在内存中的临时拷贝,它位于数据 库与数据库访问层中间.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 ห้องสมุดไป่ตู้ession = HibernateSessionFactory.getSession(); TUser t = (TUser)session.get("hibernate.TUser", 2); System.out.println(t.getName()); session.close(); } }
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=? 说明进行了一次数据库的调用. 代码更改如下:
} } 测试 : 控制台只输出一条 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 支持事务型缓存. create table teamEH (id varchar(32),teamname varchar(32)); create table studentEH (id varchar(32),name varchar(32),team_id varchar(32)); POJO： package EHCache; public class Student ...{ private String id; //标识 id private String name; //学生姓名
再进行测试 : 进行了两次查询 , 控制台仍然只打出一条 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="e_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();