Hibernate二级缓存步骤
Hibernate常见面试题汇总
一. H ibern ate工作使用步骤？1.读取并解析配置文件2. 读取并解析映射信息，创建Ses sionF actor y3.打开Sess sion4. 创建事务Tran satio n5.持久化操作6. 提交事务7.关闭Sess ion 8. 关闭Se sstio nFact ory 二．Hib ernat e的查询方式有几种?(1)导航对象图检索方式。
根据已经加载的对象，导航到其他对象。
(2)OID查询方式。
根据对象的O ID来查询对象。
Se ssion的get()和loa d()方法。
（3）HQL查询方式。
HQ L是面向对象的查询语言，ses sion的find()方法用于执行HQL查询语句。
可以利用Q uery接口。
Q ueryquery = se ssion.crea teQue ry(“f rom C ustom er as c wh ere c.name=: c ustom erNam e”);quer y.set Strin g(“cu stome rName”,”张三”);Listresul tList = qu ery.l ist();（4）QBC查询方式。
这种API封装了基于字符串形式的查询语句。
Crit eriacrite ria = sess ion.c reate Crite ria(U ser.c lass);Cr iteri on cr iteri on1 = Expe ssion.like(“nam e”,”T%”);Crite rioncrite rion2 = Ex pessi on.eq(age,new I ntege r(30));cr iteri a =crite ria.a dd(cr iteri on1);crit eria = cr iteri a.add(crit erion2);L ist r esult List= cri teria.list();这种查询方式使用的较少，主要是在查询中需要用户输入一系列的查询条件，如果采用HQL查询代码会比较烦。
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对象之后，就可以执行各种数据库操作了。
Hibernate查询详解
Hibernate查询首先介绍get()和load()方法的区别:get()方法和load()方法的区别主要在于对二级缓存的使用上。
load()方法会使用二级缓存，而get()方法在一级缓存没有找到会直接查询数据库，不会去二级缓存中查找。
get():如果在数据库中没有记录会返回空，get()无论如何都会返回数据.load():如果数据库中没有记录会抛出异常，如果有数据返回的是一个代理对象。
list和iterator()方法之间的区别：(N+1?)list()方法在执行时，直接运行查询结果所需要的查询语句。
iterator()方法则是先执行得到对象ID的查询，然后在根据每个ID值去取得所要查询的对象。
因此：对于list()方式的查询通常只会执行一个SQL语句，而对于iterator()方法的查询则可能需要执行N+1条SQL语句(N为结果集中的记录数).结果集的处理方法不同:list()方法会一次活的所有的结果集对象，而且他会依据查询的结果初始化所有的结果集对象。
如果在结果集非常庞大的时候会占据非常多的内存，甚至会造成内存溢出的情况发生。
iterator()方法在执行时不会一次初始化所有的对象，而是根据对结果集的访问情况来初始化对象。
一次在访问中可以控制缓存中对象的数量，以避免占用过多的缓存，导致内存溢出情况的发生。
HQL:HQL是一种面向对象的查询语言，HQL的操作对象是类、实例和属性等。
SQL:sql的操作对象是数据表和列等数据对象。
Hql是完全面向对象的查询语言，因此可以支持继承和多条等特征。
HQL查询依赖于Query类，每个Query实例对应一个查询对象。
定参数的功能，Query 接口才是真正的HQL查询接口。
//创建一个Query 对象Java代码1Query query = session.createQuery ("from Customer as c where=:customerName and c.age=:customerAge");//动态绑定参数Java代码2query.setString("customerName","Tom");3query.setInteger("customerAge",21);//执行查询语句，返回结果Java代码4List result = query.list();HQL查询步骤:1:获取Hibernate Session对象。
三大框架
Hibernate1.Hibernate 的初始化.读取Hibernate 的配置信息-〉创建Session Factory1)创建Configeration类的实例。
它的构造方法：将配置信息(Hibernate config.xml)读入到内存。
一个Configeration 实例代表Hibernate 所有Java类到Sql数据库映射的集合。
2)创建SessionFactory实例把Configeration 对象中的所有配置信息拷贝到SessionFactory的缓存中。
SessionFactory的实例代表一个数据库存储员源，创建后不再与Configeration 对象关联。
缓存(cache):指Java对象的属性(通常是一些集合类型的属性－－占用内存空间。
SessionFactory的缓存中：Hibernate 配置信息。
OR映射元数据。
缓存－大：重量级对象小：轻量级对象3)调用SessionFactory创建Session的方法1】用户自行提供JDBC连接。
Connection con=dataSource.getConnection(); Session s=sessionFactory.openSession(con);2】让SessionFactory提供连接Session s=sessionFactory.openSession();4)通过Session 接口提供的各种方法来操纵数据库访问。
Hibernate 的缓存体系一级缓存：Session 有一个内置的缓存，其中存放了被当前工作单元加载的对象。
每个Session 都有自己独立的缓存，且只能被当前工作单元访问。
二级缓存：SessionFactory的外置的可插拔的缓存插件。
其中的数据可被多个Session共享访问。
SessionFactory的内置缓存：存放了映射元数据，预定义的Sql语句。
Hibernate 中Java对象的状态1.临时状态(transient)特征：1】不处于Session 缓存中2】数据库中没有对象记录Java如何进入临时状态1】通过new语句刚创建一个对象时2】当调用Session 的delete()方法，从Session 缓存中删除一个对象时。
二级缓存
二级缓存1.二级缓存相关介绍①缓存好处：将数据库或者硬盘数据，保存在内存中，减少数据库查询次数，减少硬盘交互，提高检索效率hibernate 共有两个级别的缓存* 一级缓存，保存Session中，事务范围的缓存* 二级缓存，保存SessionFactory ，进程范围的缓存SessionFacoty 两部分缓存内置：Hibernate 自带的, 不可卸载. 通常在Hibernate 的初始化阶段, Hibernate 会把映射元数据和预定义的SQL 语句放到SessionFactory 的缓存中, 映射元数据是映射文件中数据的复制, 而预定义SQL 语句时Hibernate 根据映射元数据推到出来的. 该内置缓存是只读的.外置：一个可配置的缓存插件. 在默认情况下, SessionFactory 不会启用这个缓存插件. 外置缓存中的数据是数据库数据的复制, 外置缓存的物理介质可以是内存或硬盘，必须引入第三方缓存插件才能使用。
2.二级缓存内部结构学习* 类缓存区域* 集合缓存区域* 更新时间戳区域* 查询缓存区域3.二级缓存并发策略transactional ：提供Repeatable Read事务隔离级别，缓存支持事务，发生异常的时候，缓存也能够回滚read-write ：提供Read Committed事务隔离级别，更新缓存的时候会锁定缓存中的数据nonstrict-read-write ：导致脏读，很少使用read-only ：数据不允许修改，只能查询* 很少被修改，不是很重要，允许偶尔的并发问题，适合放入二级缓存。
考虑因素（二级缓存的监控【后面学习】，它是是否采用二级缓存主要参考指标）4.hibernate 支持二级缓存技术* EHCache (主要学习，支持本地缓存，支持分布式缓存)可作为进程范围内的缓存, 存放数据的物理介质可以是内存或硬盘, 对Hibernate 的查询缓存提供了支持。
Hibernate数据缓存技术
Ｈ ｉ ｂ ｅ ｒ ｎ ａ ｔ ｅ缓存 是 位 于 应 用 程 序 与 物 理 数 据 源 之
间， 用 于 临时存 放复 制数 据 的 内存 区域 ， 目的是 为 了减 少 应用 程序 对物 理 数据 源访 问 的次 数 ， 从 而 提 高 应 用 程 序 的性能 。Ｈ ｉ ｂ ｅ ｒ ｎ ａ ｔ ｅ在 查 询数 据 时 ， 首 先 到 缓 存 中 去 查找 ， 如果 找 到就 直接 使用 ， 找 不到 的时 候就 会从 物 理 数据 源 中检索 ， 所以 ， 把 频 繁使 用 的数 据 加载 到缓 存
张雄 彪
（ 湖 北 大学 数 学与计 算机 科 学学 院 ， 武汉 ４ ３ ０ ０ ６ ２ ）
摘 要： Ｈ ｉ ｂ ｅ ｒ ｎ ａ ｔ ｅ是一种 面向 Ｊ ａ ｖ ａ编程环境 的关 系数据 库映射工具 。本 文 系统地 分析 了 Ｈ ｉ ｂ ｅ ｎａ ｒ ｔ ｅ的缓存 分类 ， 并描述
了一级缓存 与二级缓存 的缓存策略 ， Ｈ ｉ ｂ ｅ ｒ ｎ ａ ｔ ｅ如何 应 用缓 存查找 对 象和 对缓存 的 管理 ， Ｈ ｉ ｂ ｅ ｒ ｎ ａ ｔ ｅ查询缓存 以及性 能优
化策略 。
关键词 ： Ｈ ｉ ｂ ｅ ｒ ｎ ａ ｔ ｅ ； 缓存 ； 优 化 策 略
中图分类号 ： Ｔ Ｐ ３ １ ６ ７ ４ — ３ ４ ４ Ｘ（ ２ ０ １ ３ ） ８ － ０ ０ ６ ９ － ０ ２
作者简介 ： 张雄 彪（ １ ９ ８ ７一） ， 男， 硕 士研 究生 ， 研 究方向为人 工智能与知识 工程 。
生， 或者 你 正处理 大 量 对 象 、 需要 对有 效 管 理 内存 时 ，
你 可 以调用 ｅ ｖ ｉ ｃ ｔ （ ） 方法 ， 从 一 级缓 存 中去 掉这 些对 象
hibernate缓存机制详细分析（一级、二级、查询缓存，非常清晰明白）
hibernate缓存机制详细分析（⼀级、⼆级、查询缓存，⾮常清晰明⽩）您可以通过点击右下⾓的按钮来对⽂章内容作出评价, 也可以通过左下⽅的关注按钮来关注我的博客的最新动态。
如果⽂章内容对您有帮助, 不要忘记点击右下⾓的推荐按钮来⽀持⼀下哦如果您对⽂章内容有任何疑问, 可以通过评论或发邮件的⽅式联系我:****************/**********************如果需要转载，请注明出处，谢谢！！在本篇随笔⾥将会分析⼀下hibernate的缓存机制，包括⼀级缓存(session级别)、⼆级缓存(sessionFactory级别)以及查询缓存，当然还要讨论下我们的N+1的问题。
随笔虽长，但我相信看完的朋友绝对能对hibernate的 N+1问题以及缓存有更深的了解。
⼀、N+1问题⾸先我们来探讨⼀下N+1的问题，我们先通过⼀个例⼦来看⼀下，什么是N+1问题：list()获得对象： /** * 此时会发出⼀条sql，将30个学⽣全部查询出来*/ List<Student> ls = (List<Student>)session.createQuery("from Student").setFirstResult(0).setMaxResults(30).list();Iterator<Student> stus = ls.iterator();for(;stus.hasNext();){Student stu = (Student)stus.next();System.out.println(stu.getName());}如果通过list()⽅法来获得对象，毫⽆疑问，hibernate会发出⼀条sql语句，将所有的对象查询出来，这点相信⼤家都能理解Hibernate: select student0_.id as id2_, student0_.name as name2_, student0_.rid as rid2_, student0_.sex as sex2_ from t_student student0_ limit ?那么，我们再来看看iterator()这种情况iterator()获得对象 /** * 如果使⽤iterator⽅法返回列表，对于hibernate⽽⾔，它仅仅只是发出取id列表的sql* 在查询相应的具体的某个学⽣信息时，会发出相应的SQL去取学⽣信息* 这就是典型的N+1问题* 存在iterator的原因是，有可能会在⼀个session中查询两次数据，如果使⽤list每⼀次都会把所有的对象查询上来* ⽽是要iterator仅仅只会查询id，此时所有的对象已经存储在⼀级缓存(session的缓存)中，可以直接获取*/ Iterator<Student> stus = (Iterator<Student>)session.createQuery("from Student").setFirstResult(0).setMaxResults(30).iterate();for(;stus.hasNext();){Student stu = (Student)stus.next();System.out.println(stu.getName());}在执⾏完上述的测试⽤例后，我们来看看控制台的输出，看会发出多少条 sql 语句：Hibernate: select student0_.id as col_0_0_ from t_student student0_ limit ?Hibernate: select student0_.id as id2_0_, student0_.name as name2_0_, student0_.rid as rid2_0_, student0_.sex as sex2_0_ from t_student student0_ where student0_.id=?沈凡Hibernate: select student0_.id as id2_0_, student0_.name as name2_0_, student0_.rid as rid2_0_, student0_.sex as sex2_0_ from t_student student0_ where student0_.id=?王志名Hibernate: select student0_.id as id2_0_, student0_.name as name2_0_, student0_.rid as rid2_0_, student0_.sex as sex2_0_ from t_student student0_ where student0_.id=?叶敦.........我们看到，当如果通过iterator()⽅法来获得我们对象的时候，hibernate⾸先会发出1条sql去查询出所有对象的 id 值，当我们如果需要查询到某个对象的具体信息的时候，hibernate此时会根据查询出来的 id 值再发sql语那么这种 N+1 问题我们如何解决呢，其实我们只需要使⽤ list() ⽅法来获得对象即可。
SSH框架面试题(自己+别人的试题)
(问答题+选择题（在55页）)Java工程师（程序员）面题Struts,Spring,Hibernate三大框架1.Hibernate工作原理及为什么要用？原理：1.读取并解析配置文件 2.读取并解析映射信息，创建SessionFactory 3.打开Session 4.创建事务Transation 5.持久化操作6.提交事务7.关闭Session 8.关闭SesstionFactory为什么要用：1. 对JDBC访问数据库的代码做了封装，大大简化了数据访问层繁琐的重复性代码。
2. Hibernate是一个基于JDBC的主流持久化框架，是一个优秀的ORM实现。
他很大程度的简化DAO层的编码工作3. hibernate使用Java反射机制，而不是字节码增强程序来实现透明性。
4. hibernate的性能非常好，因为它是个轻量级框架。
映射的灵活性很出色。
它支持各种关系数据库，从一对一到多对多的各种复杂关系。
2．Hibernate是如何延迟加载?1. Hibernate2延迟加载实现：a)实体对象b)集合（Collection）2. Hibernate3 提供了属性的延迟加载功能当Hibernate在查询数据的时候，数据并没有存在与内存中，当程序真正对数据的操作时，对象才存在与内存中，就实现了延迟加载，他节省了服务器的内存开销，从而提高了服务器的性能。
3．Hibernate中怎样实现类之间的关系?(如：一对多、多对多的关系)类与类之间的关系主要体现在表与表之间的关系进行操作，它们都是对对象进行操作，我们程序中把所有的表与类都映射在一起，它们通过配置文件中的many-to-one、one-to-many、many-to-many4.Struts1流程：1、客户端浏览器发出HTTP请求。
2、根据web.xml配置，该请求被ActionServlet接收。
3、根据struts-config.xml配置，ActionServlet先将请求中的参数填充到ActionForm中，然后ActionServlet再将请求发送到Action 进行处理。
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。
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更新到数据库
hibernate高级用法
hibernate高级用法Hibernate是一种Java持久化框架，用于将对象转换为数据库中的数据。
除了基本的用法，Hibernate还提供了一些高级的用法，以下是一些常见的Hibernate高级用法：1、继承Hibernate支持类继承，可以让子类继承父类的属性和方法。
在数据库中，可以使用表与表之间的关系来实现继承，例如使用一对一、一对多、多对一等关系。
使用继承可以让代码更加简洁、易于维护。
2、聚合Hibernate支持聚合，可以将多个对象组合成一个对象。
例如，一个订单对象可以包含多个订单行对象。
在数据库中，可以使用外键来实现聚合关系。
使用聚合可以让代码更加简洁、易于维护。
3、关联Hibernate支持关联，可以让对象之间建立关联关系。
例如，一个订单对象可以关联一个客户对象。
在数据库中，可以使用外键来实现关联关系。
使用关联可以让代码更加简洁、易于维护。
4、延迟加载Hibernate支持延迟加载，可以在需要时才加载对象。
延迟加载可以减少数据库的负担，提高性能。
Hibernate提供了多种延迟加载的策略，例如按需加载、懒惰加载等。
5、事务Hibernate支持事务，可以确保数据库的一致性。
事务是一组数据库操作，要么全部成功，要么全部失败。
Hibernate提供了事务管理的方法，例如开始事务、提交事务、回滚事务等。
6、缓存Hibernate支持缓存，可以减少对数据库的访问次数，提高性能。
Hibernate提供了多种缓存策略，例如一级缓存、二级缓存等。
使用缓存需要注意缓存的一致性和更新问题。
7、HQL查询语言Hibernate提供了HQL查询语言，可以让开发人员使用面向对象的查询方式来查询数据库。
HQL查询语言类似于SQL查询语言，但是使用的是Java类和属性名，而不是表名和列名。
HQL查询语言可以更加灵活、易于维护。
以上是一些常见的Hibernate高级用法，它们可以帮助开发人员更加高效地使用Hibernate进行开发。
hibernate的flush方法
hibernate的flush方法Hibernate是一个开源的对象关系映射工具，提供了数据库操作的抽象层，使开发者可以使用面向对象的方式进行数据库操作。
Hibernate的flush方法是用于将Hibernate会话中的变化同步到数据库的操作。
在Hibernate中，会话（Session）是表示开发者与数据库之间的一次连接。
开发者可以通过向会话中添加、修改和删除对象来操作数据库。
而flush方法则是将这些变化同步到数据库。
在什么情况下需要使用flush方法呢？1. 当开发者需要保证数据的完整性时，可以使用flush方法。
当开发者添加、修改或删除了对象之后，调用flush方法会立即将这些变化同步到数据库。
2. 当开发者需要检查数据是否已经被持久化时，可以使用flush方法。
在调用flush方法之后，数据将被立即同步到数据库，可以通过查询数据库来验证数据是否已经被保存。
3. 当开发者需要在事务之外使用最新的数据时，可以使用flush方法。
在Hibernate中，默认情况下，事务提交之前，所有的数据变化只是在会话缓存中进行维护，而不会立即同步到数据库。
但是，如果开发者需要在事务之外查询到最新的数据，可以在查询之前调用flush方法，确保数据已经更新到数据库中。
4. 当开发者需要将数据库操作的异常抛出时，可以使用flush方法。
在执行数据库操作过程中，如果发生了异常，Hibernate会自动回滚事务，但不会抛出异常。
如果开发者希望在发生异常时得到通知，可以在执行数据库操作之前调用flush方法，如果操作失败，会抛出异常。
实际上，flush方法执行的操作如下：1.将会话中的持久化对象的状态同步到数据库。
持久化对象的状态包括新增、修改和删除。
2.将会话中的变化同步到数据库的操作也会级联到关联对象。
如果一些持久化对象发生了变化，与之关联的其他对象也会受到影响。
3. 执行flush操作不会结束当前事务，会话仍然处于打开状态，可以继续进行操作。
hibernate学习笔记
Hibernate 学习笔记2010年7月9日星期五1目录1.学习纲要2.学习目的3.达标标准4.名词解释5.学习时间：两天又3小时(16~19pm)2具体内容2.1学习纲要2.1.1什么是hibernate?它是连接JAVA应用程序和关系数据库的中间件它对JDBC API进行了封装，负责JAVA对象的持久化在分层的软件架构中它位于持久化层，封装了所有数据访问细节，使业务逻辑层可以专注于实现业务逻辑。
它是一种ORM映射工具，能够建立面向对象的域模型和关系数据模型之间的映射2.1.2HIBERNATE原理依赖的技术有：JAVA反射机制（在org.hibernate.property中得到较多应用，通过INVORK()方法调用POJO对象的setter,getter方法设置和获取属性的值）i.Class类ii.getMethods方法得到Method类iii.Method类iv.invoke方法用来调用被反射类的方法CGLIB（用于对持久化类进行延迟加载时生成代理类）i.以asm项目为基础，对asm的功能进行封装和扩展，实现并扩展了JAVA的反射功能，可以在运行时状态下实现JAVA接口，扩展JAVA类ii.Asm项目是一个简洁的字节码工具，能够在运行的状态下动态的修改编译完成的JAVA类JAVASSIST（同CGLIB，是另一套解决方案，可以通过修改org.hibernate.cfg.Environment.java原码进行设置）i.是一个执行字节码操作的强有力的驱动代码库。
它允许开发者在代码被JAVA虚拟机载入之前定义一个新类或者修改类的的原代码。
XML技术（DOM4J）i.用来解析XML配置文件Antlr（another tool for language recognition）i.它是一个开源的工具，利用后缀为“.g”的文件来定义语法规则ii.Hibernate提供的语法规则有iii.Hql.giv.Hql-sql.gv.Sql-gen.gvi.Hibernate通过调用这些生成的解析类完成把HQL语句转为SQL语句的工作2.1.3HIBERNATE方法的内部实现略2.1.4Hibernate能做什么？2.1.5hibernate应用在哪些方面2.1.6Hibernate关联关系1.一对多关联<many-to-one name=”customer”column=”CUSTOMER_ID”class=”mypack.Customer”lazy=”false” not-null=”true”/>此种情况下不会加载关联的临时对象。
Hibernate学习总结
一．对象语言和操作数据库不匹配：模型不匹配（阻抗不匹配）①．可以使用JDBC手动转换；sql参数和jdbc中用对象赋值②．使用ORM（Object Relation Mapping对象关系映射）框架：hibernate 二．Hibernate安装配置①．配置文件Hibernate.cfg.xml和Hibernate.properties②．映射文件xxx.hbm.xml：对象模型和关系模型的映射三．开发流程1.由Domain Object -> mapping -> db2.有DB开始，用工具生成mapping和Domain Object3.由配置文件开始四．Domain Object限制1.默认的构造方法（必须的）2.有无意义的标示符id(主键) 可选3.非final的，对懒加载有影响可选Configuration SessionFactory Session Transaction Query CriteriaConfiguration类Configuration类负责配置并启动Hibernate，创建SessionFactory对象。
在Hibernate的启动的过程中，Configuration类的实例首先定位映射文档位置、读取配置，然后创建SessionFactory 对象。
SessionFactory接口SessionFactory接口负责初始化Hibernate。
它充当数据存储源的代理，并负责创建Session对象。
这里用到了工厂模式。
需要注意的是SessionFactory并不是轻量级的，因为一般情况下，一个项目通常只需要一个SessionFactory就够，当需要操作多个数据库时，可以为每个数据库指定一个SessionFactory。
Session接口Session接口负责执行被持久化对象的CRUD操作(CRUD的任务是完成与数据库的交流，包含了很多常见的SQL语句。
NHibernate中文文档
第1章NHibernate体系结构总览对NHibernate体系结构的非常高层的概览:这幅图展示了NHibernate使用数据库和配置文件数据来为应用程序提供持久化服务（和持久化的对象）。
我们试图显示更多NHibernate运行时体系结构的细节。
但挺不幸的，NHibernate是比较灵活的并且提供了好几种不同的运行方式。
我们展示一下两种极端情况。
轻型体系中，应用程序自己提供连接，并且自行管理事务。
这种方式使用了NHibernate API的一个最小子集。
全面解决体系中，对于应用程序来说，所有的底层 API都被抽象了，NHibernate会替你照管所有的细节。
下面是图中一些对象的定义：SessionFactory (NHibernate.ISessionFactory) 对属于单一数据库的编译过的映射文件的一个线程安全的，不可变的缓存快照。
它是Session的工厂，是ConnectionProvider的客户。
可以持有一个可选的（第二级）数据缓存，可以在进程级别或集群级别保存可以在事物中重用的数据。
会话Session (NHibernate.ISession) 单线程，生命期短促的对象，代表应用程序和持久化层之间的一次对话。
封装了一个连接。
也是Transaction的工厂。
保存有必需的（第一级）持久化对象的缓存，用于遍历对象图，或者通过标识符查找对象。
持久化对象(Persistent)及其集合(Collections) 生命期短促的单线程的对象，包含了持久化状态和商业功能。
它们可能是普通的对象，唯一特别的是他们现在从属于且仅从属于一个Session。
一旦Session被关闭，他们都将从Session中取消联系，可以在任何程序层自由使用（比如，直接作为传送到表现层的DTO,数据传输对象）。
临时对象(Transient Object)及其集合（Collection）目前没有从属于一个Session的持久化类的实例。
Hibernate缓存技术研究
缎 适 器（８ｅ０ ｅ 存 配 ｃｈｒｉｒ ｃＰｖ ） ｄ 缓实 存现
圈 １ Ｈｉｅ ｎ ｔ 存 结 构 ｂ ｒ ａｅ缓
第 一级 是 Ｓ ｓｉｎ缓存 ， ｅｓ ｏ 由于 Ｓ ｓｉｎ对象 的生命 周期 ｅｓ ｏ 通 常对应 一个 数据 库事务 或者 一个应 用 事务 ， 因此它 的缓存是 事 务范 围的缓存 。第 一级缓 存 是必需 的 ，不 允 许而且 事 实上也 无法卸 除 。在第 一级缓 存 中 ，持 久 化 类 的每个 实 例都 具 有 唯一 的 ＯＩ Ｄ。在 每个 Ｓ ｓｉｎ ｅｓ ｏ
缓 存 。第 二级对 象有 可能 出现并 发 问题 ，因此 需要采
牛河 南 省 科 技 攻 关项 目 （６ ４ ６ ３ ） ０ ２ ２ ０ ３ 收稿 日期 ：２ ０ —５１ ｉ修 回 日期 ２ ０ —６２ ０ ７０ —４ ０ ７０ —５ 作 者 简介 ： 田辉 （９ ０） 女 ． ｉ ８一 ， 河南 西 平 人 ． 教 ， 士 。 助 硕
Ｈｉｅｎ ｔ ｂ ｒ ａｅ缓存 技 术研 究
田 辉 ，王 栋 ，韩 晓 宏
（ 南 农 业 大 学 机 电工 程 学 院 ，河 南 郑 州 河 ４ ００ ） ５０ ２
摘 要 ：Ｈｉｅｎ ｔ 一 种 面 向 Ｊｖ 环 境 的 ＯＲ 工 具 。系统 地 分析 了 Ｈｉｅｎ ｔ ｂ ｒａｅ是 ａａ Ｍ ｂｒａｅ的缓 存 结 构 。并 描 述 了 二级 缓 存 的 查 询过 程 、缓 存 策 略 ｝ 同时 总结 了二 级 缓 存 使 用 中 的一 些 限 制 。以及 使 用 二级 缓 存 的优 化 策 略 。
系模 型数 据库 结构 中 。Ｈｉｅｎ ｔ 不 仅仅 管 理 Ｊ ｖ ｂ ｒ ａｅ ａ ａ类
Ｈｂ ｎｔ ｉｒ ｅ ｅ ａ 一级缓存
关于Hibernate缓存机制的研究
关于Hibernate缓存机制的研究摘要：Hibernate是一个开源的对象关系框架，它对JDBC进行了封装，java程序员可以通过Hibernate框架用对象编程的方式操纵数据库。
而使用Hibernate缓存，减少了项目当中应用程序与数据库的交互，从一定程度上提高了项目运行的效率。
主要探讨Hibernate框架的缓存实现机制与相关的应用策略。
关键词：Hibernate；Session缓存；SessionFactory缓存；持久层1 Hibernate的缓存机制缓存是用于存放数据的内存区域，当应用系统与数据库交互时，把交互过的数据保存到缓存中，当应用系统再次从数据库中读取相同的数据时，就可以从缓存中直接取出数据，而不用再次同数据库交互，从而减少了与数据库交互的次数，提高了应用系统的运行效率，当数据库中的数据被修改或被删除时，那缓存中与之对应的数据也会被修改或被删除，这样可以将缓存中的数据与数据库中的数据同步，保证缓存数据的有效性。
1.1 Hibernate一级缓存Hibernate一级缓存也称为Session缓存，通过将数据存放在Session对象中实现，Session缓存不能通过应用程序或者相关配制人为取消，因此Hibernate一级缓存是事务级别缓存，当session所存在的事务结束时，缓存中的所有数据都会丢失。
一级缓存是Session对象维护一个Key-value型的Map对象，当通过Session存储实体对象时，Session会将实体对象的类型或标识存储到Map对象的key中，将实体对象存储到Map对象的Value 中，当通过Session读取实体对象数据时，Session会跟据实体对象的类型或标识到Map对象中查找，查看是否已存储过这个对象，如果找到则返回这个实体对象，找不到则从数据库中查询。
Hibernate一级缓存是全自动的，不能人为对其干预，但可以通过Session中的方法对它进行管理，包括以下两种：①使用evict()方法从缓存中移除缓存对象，当缓存对象被移出时，该对象的状态会从持久化状态变为托管状态；②使用clear()将缓存中的所有对象全部清除。
使用缓存数据PPT课件
}
7
15.2 一级缓存
3．在一个Session中先save，再执行load查询
@Tes在t 测试类HibernateTest中添加testSessionCache_3()方
法pu，bl并ic 使vo用id@tTeessttSe注ss解io加nCa以ch修e_3饰()，{ 在一个session中先执行save
@Test 1．一个session中发出两次get查询 public将vo项id目tehsitbSeesrsniaotneCa-c1h0e复_1(制){并命名为“hibernate-11”，
User u1=(User)session.get(User.class, 1);
再导入Sys到teMm.yoEuctl.ipprisnet开ln(发"用环户境名中："。+u在1.g项et目LoghiinbNearmen(a)t)e;-10的测试 类HibUeserrnaut2e=(TUessetr)中se添ssi加ont.egestt(SUessers.icolnaCssa,ch1e)_;1()方法，并使用 @}TestS注yst解em加.ou以t.修pr饰int，ln在("用同户一名个：s"e+sus2.igoent中Log发in出Na两me(次))g;et查询。
要经缓常到存数和据外库置里缓查询存，。那就没有必要用缓存了。
务的生Se(命s1s周) i事期on，务的当范事围缓务：存结缓束存是时只内，能缓被置存当的也前，就事结务不束访能生问命。被周缓卸期存。的载在生，此命范周也围期被下依，赖称缓于为存事 的介H质i是be内rn存a。te的第一级缓存。SessionFactory的缓存又被称为