hibernate

Hibernate 是一个开放源代码的对象关系映射框架，它对 JDBC 进行了轻量级的对象封装，使 Java 程序员可以随心所欲的使用对象编程思维来操纵数据库。它不仅提供了从 Java 类到数据表之间的映射，也提供了数据查询和恢复机制。相对于使用 JDBC 和 SQL 来手工操作数据库，Hibernate 可以大大减少操作数据库的工作量。 另外 Hibernate 可以利用代理模式来简化载入类的过程，这将大大减少利用 Hibernate QL 从数据库提取数据的代码的编写量，从而节约开发时间和开发成本 Hibernate 可以和多种Web 服务器或者应用服务器良好集成，如今已经支持几乎所有的流行的数据库服务器。

hibernate [hi·ber·nate || "hau026abu0259(r)neu026at]v. 过冬, 避寒, 冬眠hibernate也是一个JAVA语言的ORM框架。与Mybatis一样的是，编码复杂度都是O(n),也就是说每操作一个DB的表，就要写一次dao。一个十分钟即可学会的ORM框架--Bee , 编码复杂度是O(1). (想想数据结构中时间复杂度，空间从O(n)提升到O(1)对性能的影响有多大）。https://blog.csdn.net/abckingaa/article/details/81176524

Hibernate是一个开放源代码的对象关系映射框架，它对JDBC进行了非常轻量级的对象封装，它将POJO与数据库表建立映射关系，是一个全自动的orm框架，hibernate可以自动生成SQL语句，自动执行，使得Java程序员可以随心所欲的使用对象编程思维来操纵数据库。Hibernate可以应用在任何使用JDBC的场合，既可以在Java的客户端程序使用，也可以在Servlet/JSP的Web应用中使用，最具革命意义的是，Hibernate可以在应用EJB的JaveEE架构中取代CMP，完成数据持久化的重任。扩展资料：发展历程2004年，整个Java社区开始从实体bean向Hibernate转移，特别是在Rod Johnson的著作《Expert One-on-One J2EE Development without EJB》出版后，由于这本书以扎实的理论、充分的论据和详实的论述否定了EJB，提出了轻量级敏捷开发理念之后，以Hibernate和Spring为代表的轻量级开源框架开始成为Java世界的主流和事实标准。在2004年Sun领导的J2EE5.0标准制定当中的持久化框架标准正式以Hibernate为蓝本。2006年，J2EE5.0标准正式发布以后，持久化框架标准Java Persistent API（简称JPA）基本上是参考Hibernate实现的，而Hibernate在3.2版本开始，已经完全兼容JPA标准。参考资料来源：百度百科-开放源代码参考资料来源：百度百科-Hibernate

hibernate 英["hau026abu0259neu026at]美[u02c8hau026abu025au02ccnet]vi. （某些动物）冬眠，蛰伏第三人称单数:hibernates;过去分词:hibernated;现在分词:hibernati...[例句]To cope , many species have learned to hibernate.为了应对严寒，很多物种学会了冬眠。

一种工具好与不好，主要方面应该体现在是否实用，是否易用，好多人说hibernate怎么怎么好用，是，这个不能否定，毕竟hibernate都出了这么多年了，该优化的早优化了，但是，正如有人说的，hibernate慢，而且难优化，而且使用不好有问题，这就是他最大的垃圾地方，楼主可以想一想，hibernate提出的什么面向对象操作数据库，这本身就是一个谎言，oracle，db2这些主流数据库本省就是关系数据库，为什么非要用面向对象思维去考虑他，弄不好就容易让人思维错乱。不是谁没有那个思维，也不是谁不懂那个东西，二是学会hibernate，要想学好，跟另学一门语言的难度没什么区别，他只是一个工具，这么难，有意义吗？我以前没用过其他的orm框架，也觉着hibernate好，但是当你用过好的简单的、容易上手的框架，如ibatis，你就会发现hibernate就是绕弯子走路，脱裤子放屁，真没啥用~~

说说我们的选择吧原因有： 1. 我们是做平台的，客户要求多种多样，我们是需要支持多个数据库的，Hibernate可以比较容易屏蔽数据库的差异； 2. Hibernate采用面向对象的方式来写SQL，也就是HQL和Criteria,在数据库和Dao之间多了一层，数据库的改动可以通过映射关系屏蔽部分影响。 3. 因为我们是要不断的增加功能，偶然要做做系统重构，快速快发尤其重要，Hibernate的代码量和改动量都要比其他框架来的少，起码经过我们的封装已经使得用起来是很简单了。 4. 对于性能有影响的地方和很难用Hibernate表达的地方我们会采用JdbcTemplate，或者采用View封装一次再map到Hibernate，采用Hibernate也不排斥其他持久层框架的存在。 5. 尽量少用One to many, Many to one等功能，可能这里不太OO，但是代码明了,不容易出问题。 6. 我们暂时还没有遇到几千万的数据量那么大的客户，要做到那么大数据量的时候也可以从数据库，系统，网络各个方面来优化。系统推到重来也不是什么问题。 7.Hibernate的一级缓存对于长Transaction的业务复杂的代码反而有好处，见上面的某些分析。 8. 采用缓存和静态页面可以消除部分性能影响，或者采用数据库特有功能，不过取消Hibernate的二级缓存，采用Spring的缓存或者自己搞缓存。 9. 文档多，容易解决问题，也是JPA标准的重要参考。 Hibernate不好的地方： 1. 多占内存，因为他需要把domain对应的configuration都load到内存里面去，多用内存是正常的，但是出现OutofMemerey肯定不是Hibernate的问题了，一般应用内存还是够的。 2. 性能问题。Hibernate或者Ibatis也好，最终都是通过反射把ResultSet变为对应的Domain Object,跟了一下Hibernate的内部代码，好像是用Method.invoke来调用get 和set方法的，用了Cglib或者动态代理方式，这个方式肯定是要比直接调用get和set方法要慢的。在JDK不断优化的今天，这个差距应该会缩小。 但是Ibatais应该也是通过这个方式来做，没有看过不太肯定。Hibernate多了一个将HQL或者Domain Object转化为SQL的过程，这个过程也会消耗一些性能，例如字符串拼接，记录Domain Object的关系等。 经过以上分析，可能Hibernate会给我带来一定的性能损失，但是我可以通过其他办法来弥补，内存就更不是问题了。但是他确实带来了比较好的地方，因此我们会继续用Hibernate。 所以说Hibernate适合做企业级应用，对于那种内存和性能要求都很高或者本来就用Ibatis的情况，其实可以选择Ibatias或者JdbcTemplate的。就性能而言， JdbcTemplate > Ibatis < Hibernate 除了缓存的作用外只说DB操作，纯JDBC是最快的，因为那样没有任何负担，但是代码搞得很难看，你会这么选择吗？

　　Hibernate批量处理其实从性能上考虑 它是很不可取的 浪费了很大的内存 从它的机制上讲 Hibernate它是先把符合条件的数据查出来 放到内存当中 然后再进行操作 实际使用下来性能非常不理想 在笔者的实际使用中采用下面的第三种优化方案的数据是 条数据插入数据库 主流台式机的配置 需要约 分钟 呵呵 晕倒 　　总结下来有三种来处理以解决性能问题 　　 绕过Hibernate API 直接通过 JDBC API 来做 这个方法性能上是比较好的 也是最快的 　　 运用存储过程 　　 还是用Hibernate API 来进行常规的批量处理 可以也有变 变就变在 我们可以在查找出一定的量的时候 及时的将这些数据做完操作就 　　删掉 session flush（） session evict（XX对象集） 这样也可以挽救一点性能损失 这个 一定的量 要就要根据实际情况做定量参考了 一般为 左右 但效果仍然不理想 　　 绕过Hibernate API 直接通过 JDBC API 来做 这个方法性能上是比较好的 也是最快的 （实例为 更新操作） 　　Transaction tx=session beginTransaction（） //注意用的是hibernate事务处理边界 　　Connection conn=nnection（） 　　PreparedStatement stmt=conn preparedStatement（ update CUSTOMER as C set C sarlary=c sarlary+ where c sarlary> ） 　　stmt excuteUpdate（） 　　mit（） //注意用的是hibernate事务处理边界 　　这小程序中 采用的是直接调用JDBC 的API 来访问数据库 效率很高 避免了Hibernate 先查询出来加载到内存 再进行操作引发的性能问题 　　 　　 运用存储过程 但这种方式考虑到易植和程序部署的方便性 不建议使用 （实例为 更新操作） 　　如果底层数据库（如Oracle）支持存储过程 也可以通过存储过程来执行批量更新 存储过程直接在数据库中运行 速度更加快 在Oracle数 　　据库中可以定义一个名为batchUpdateCustomer（）的存储过程 代码如下 　　代码内容create or replace procedure batchUpdateCustomer（p_age in number） as begin update CUSTOMERS set AGE=AGE+ where AGE>p_age end 　　以上存储过程有一个参数p_age 代表客户的年龄 应用程序可按照以下方式调用存储过程 　　代码内容 　　tx = session beginTransaction（） 　　Connection con=nnection（） 　　String procedure = {call batchUpdateCustomer（？） } 　　CallableStatement cstmt = con prepareCall（procedure） 　　cstmt setInt（ ） //把年龄参数设为 　　cstmt executeUpdate（） 　　mit（） 　　从上面程序看出 应用程序也必须绕过Hibernate API 直接通过JDBC API来调用存储过程 　　 还是用Hibernate API 来进行常规的批量处理 可以也有变 变就变在 我们可以在查找出一定的量的时候 及时的将这些数据做完操作就 　　删掉 session flush（） session evict（XX对象集） 这样也可以挽救一点性能损失 这个 一定的量 要就要根据实际情况做定量参考了…… 　　（实例为 保存操作） 　　业务逻辑为 我们要想数据库插入 条数据 　　tx=session beginTransaction（） 　　for（int i= i< i++） 　　{ 　　Customer custom=new Customer（） 　　custom setName（ user +i） 　　session save（custom） 　　if（i% == ） // 以每 个数据作为一个处理单元 也就是我上面说的 一定的量 这个量是要酌情考虑的 　　{ 　　session flush（） 　　session clear（） 　　} 　　} 　　这样可以把系统维持在一个稳定的范围…… 　　在项目的开发过程之中 由于项目需求 我们常常需要把大批量的数据插入到数据库 数量级有万级 十万级 百万级 甚至千万级别的 如此数量级别的数据用Hibernate做插入操作 就可能会发生异常 常见的异常是OutOfMemoryError（内存溢出异常） 　　首先 我们简单来回顾一下Hibernate插入操作的机制 Hibernate要对它内部缓存进行维护 当我们执行插入操作时 就会把要操作的对象全部放到自身的内部缓存来进行管理 　　谈到Hibernate的缓存 Hibernate有内部缓存与二级缓存之说 由于Hibernate对这两种缓存有着不同的管理机制 对于二级缓存 我们可以对它的大小进行相关配置 而对于内部缓存 Hibernate就采取了 放任自流 的态度了 对它的容量并没有限制 现在症结找到了 我们做海量数据插入的时候 生成这么多的对象就会被纳入内部缓存（内部缓存是在内存中做缓存的） 这样你的系统内存就会一点一点的被蚕食 如果最后系统被挤 炸 了 也就在情理之中了 　　我们想想如何较好的处理这个问题呢？有的开发条件又必须使用Hibernate来处理 当然有的项目比较灵活 可以去寻求其他的方法 　　笔者在这里推荐两种方法 （ ） 优化Hibernate 程序上采用分段插入及时清除缓存的方法 　　（ ） 绕过Hibernate API 直接通过 JDBC API 来做批量插入 这个方法性能上是最 好的 也是最快的 　　对于上述中的方法 其基本是思路为 优化Hibernate 在配置文件中设置hibernate jdbc batch_size参数 来指定每次提交SQL的数量 程序上采用分段插入及时清除缓存的方法（Session实现了异步write behind 它允许Hibernate显式地写操作的批处理） 也就是每插入一定量的数据后及时的把它们从内部缓存中清除掉 释放占用的内存 　　设置hibernate jdbc batch_size参数 可参考如下配置 　　<hibernate configuration> <session factory>…… 　　<property name= hibernate jdbc batch_size > </property>…… 　　<session factory> <hibernate configuration> 　　配置hibernate jdbc batch_size参数的原因就是尽量少读数据库 hibernate jdbc batch_size参数值越大 读数据库的次数越少 速度越快 从上面的配置可以看出 Hibernate是等到程序积累到了 个SQL之后再批量提交 　　笔者也在想 hibernate jdbc batch_size参数值也可能不是设置得越大越好 从性能角度上讲还有待商榷 这要考虑实际情况 酌情设置 一般情形设置 就可以满足需求了 　　程序实现方面 笔者以插入 条数据为例子 如 　　Session session=HibernateUtil currentSession（） 　　Transatcion tx=session beginTransaction（） 　　for（int i= i< i++） 　　{ 　　Student st=new Student（） 　　st setName（ feifei ） 　　session save（st） 　　if（i% == ） //以每 个数据作为一个处理单元 　　{ 　　session flush（） //保持与数据库数据的同步 　　session clear（） //清除内部缓存的全部数据 及时释放出占用的内存 　　} 　　} 　　mit（） 　　…… 　　在一定的数据规模下 这种做法可以把系统内存资源维持在一个相对稳定的范围 　　注意 前面提到二级缓存 笔者在这里有必要再提一下 如果启用了二级缓存 从机制上讲Hibernate为了维护二级缓存 我们在做插入 更新 删除操作时 Hibernate都会往二级缓存充入相应的数据 性能上就会有很大损失 所以笔者建议在批处理情况下禁用二级缓存 　　对于方法 采用传统的JDBC的批处理 使用JDBC API来处理 　　些方法请参照java 批处理自执行SQL 　　看看上面的代码 是不是总觉得有不妥的地方？对 没发现么！这还是JDBC的传统编程 没有一点Hibernate味道 　　可以对以上的代码修改成下面这样 　　Transaction tx=session beginTransaction（） //使用Hibernate事务处理 　　边界Connection conn=nnection（） 　　PrepareStatement stmt=conn prepareStatement（ insert into T_STUDENT（name） values（？） ） 　　for（int j= j++ j< ）{ 　　for（int i= i++ j< ） 　　{ 　　stmt setString（ feifei ） 　　} 　　} 　　stmt executeUpdate（） 　　mit（） //使用 Hibernate事务处理边界 　　…… 　　这样改动就很有Hibernate的味道了 笔者经过测试 采用JDBC API来做批量处理 性能上比使用Hibernate API要高将近 倍 性能上JDBC 占优这是无疑的 　　 批量更新与删除 　　Hibernate 中 对于批量更新操作 Hibernate是将符合要求的数据查出来 然后再做更新操作 批量删除也是这样 先把符合条件的数据查出来 然后再做删除操作 　　这样有两个大缺点 （ ） 占用大量的内存 　　（ ） 处理海量数据的时候 执行update/delete语句就是海量了 而且一条update/delete语句只能操作一个对象 这样频繁的操作数据库 性能低下应该是可想而知的了 　　Hibernate 发布后 对批量更新/删除操作引入了bulk update/delete 其原理就是通过一条HQL语句完成批量更新/删除操作 很类似JDBC的批量更新/删除操作 在性能上 比Hibernate 的批量更新/删除有很大的提升 　　Transaction tx=session beginSession（） 　　String HQL= delete STUDENT 　　Query query=session createQuery（HQL） 　　int size=query executeUpdate（） 　　mit（） 　　…… 　　控制台输出了也就一条删除语句Hibernate delete from T_STUDENT 语句执行少了 性能上也与使用JDBC相差无几 是一个提升性能很好的方法 当然为了有更好的性能 笔者建议批量更新与删除操作还是使用JDBC 方法以及基本的知识点与上面的批量插入方法 基本相同 这里就不在冗述 　　笔者这里再提供一个方法 就是从数据库端来考虑提升性能 在Hibernate程序端调用存储过程 存储过程在数据库端运行 速度更快 以批量更新为例 给出参考代码 　　首先在数据库端建立名为batchUpdateStudent存储过程 　　create or replace produre batchUpdateStudent（a in number） as 　　begin 　　update STUDENT set AGE=AGE+ where AGE>a 　　end 　　调用代码如下 　　Transaction tx=session beginSession（） 　　Connection conn=nnection（） 　　String pd= ……{call batchUpdateStudent（？）} 　　CallableStatement cstmt=conn PrepareCall（pd） 　　cstmt setInt（ ） //把年龄这个参数设为 　　mit（） 　　观察上面的代码 也是绕过Hibernate API 使用 JDBC API来调用存储过程 使用的还是Hibernate的事务边界 存储过程无疑是提高批量处理性能的一个好方法 直接运行与数据库端 某种程度上讲把批处理的压力转接给了数据库 　　 三 编后语 　　本文探讨了Hibernate的批处理操作 出发点都是在提高性能上考虑了 也只是提供了提升性能的一个小方面 lishixinzhi/Article/program/Java/ky/201311/28885

　　一 批量修改和删除 　　在Hibernate 中 如果需要对任何数据进行修改和删除操作 都需要先执行查询操作 在得到要修改或者删除的数据后 再对该数据进行相应的操作处理 在数据量少的情况下采用这种处理方式没有问题 但需要处理大量数据的时候就可能存在以下的问题 　　占用大量的内存 　　需要多次执行update/delete语句 而每次执行只能处理一条数据 　　以上两个问题的出现会严重影响系统的性能 因此 在Hibernate 中引入了用于批量更新或者删除数据的HQL语句 这样 开发人员就可以一次更新或者删除多条记录 而不用每次都一个一个地修改或者删除记录了 　　如果要删除所有的User对象(也就是User对象所对应表中的记录) 则可以直接使用下面的HQL语句 　　delete User 　　而在执行这个HQL语句时 需要调用Query对象的executeUpdate()方法 具体的实例如下所示 　　String HQL= delete User ; 　　Query query=session createQuery(HQL); 　　int size=query executeUpdate(); 　　采用这种方式进行数据的修改和删除时与直接使用JDBC的方式在性能上相差无几 是推荐使用的正确方法 　　如果不能采用HQL语句进行大量数据的修改 也就是说只能使用取出再修改的方式时 也会遇到批量插入时的内存溢出问题 所以也要采用上面所提供的处理方法来进行类似的处理 　　二 使用SQL执行批量操作 　　在进行批量插入 修改和删除操作时 直接使用JDBC来执行原生态的SQL语句无疑会获得最佳的性能 这是因为在处理的过程中省略或者简化了以下处理内容 　　● HQL语句到SQL语句的转换 　　● Java对象的初始化 　　● Java对象的缓存处理 　　但是在直接使用JDBC执行SQL语句时 有一个最重要的问题就是要处理缓存中的Java对象 因为通过这种底层方式对数据的修改将不能通知缓存去进行相应的更新操作 以保证缓存中的对象与数据库中的数据是一致的 　　三 提升数据库查询的性能 　　数据库查询性能的提升也是涉及到开发中的各个阶段 在开发中选用正确的查询方法无疑是最基础也最简单的 　　 SQL语句的优化 　　使用正确的SQL语句可以在很大程度上提高系统的查询性能 获得同样数据而采用不同方式的SQL语句在性能上的差距可能是十分巨大的 　　由于Hibernate是对JDBC的封装 SQL语句的产生都是动态由Hibernate自动完成的 Hibernate产生SQL语句的方式有两种 一种是通过开发人员编写的HQL语句来生成 另一种是依据开发人员对关联对象的访问来自动生成相应的SQL语句 　　至于使用什么样的SQL语句可以获得更好的性能要依据数据库的结构以及所要获取数据的具体情况来进行处理 在确定了所要执行的SQL语句后 可以通过以下三个方面来影响Hibernate所生成的SQL语句 　　HQL语句的书写方法 　　查询时所使用的查询方法 　　对象关联时所使用的抓取策略 　　 使用正确的查询方法 　　在前面已经介绍过 执行数据查询功能的基本方法有两种 一种是得到单个持久化对象的get()方法和load()方法 另一种是Query对象的list()方法和iterator()方法 在开发中应该依据不同的情况选用正确的方法 　　get()方法和load()方法的区别在于对二级缓存的使用上 load()方法会使用二级缓存 而get()方法在一级缓存没有找到的情况下会直接查询数据库 不会去二级缓存中查找 在使用中 对使用了二级缓存的对象进行查询时最好使用load()方法 以充分利用二级缓存来提高检索的效率 　　list()方法和iterator()方法之间的区别可以从以下几个方面来进行比较 　　执行的查询不同 　　list()方法在执行时 是直接运行查询结果所需要的查询语句 而iterator()方法则是先执行得到对象ID的查询 然后再根据每个ID值去取得所要查询的对象 因此 对于list()方式的查询通常只会执行一个SQL语句 而对于iterator()方法的查询则可能需要执行N+ 条SQL语句(N为结果集中的记录数) 　　iterator()方法只是可能执行N+ 条数据 具体执行SQL语句的数量取决于缓存的情况以及对结果集的访问情况 　　缓存的使用 　　list()方法只能使用二级缓存中的查询缓存 而无法使用二级缓存对单个对象的缓存(但是会把查询出的对象放入二级缓存中) 所以 除非重复执行相同的查询操作 否则无法利用缓存的机制来提高查询的效率 　　iterator()方法则可以充分利用二级缓存 在根据ID检索对象的时候会首先到缓存中查找 只有在找不到的情况下才会执行相应的查询语句 所以 缓存中对象的存在与否会影响到SQL语句的执行数量 　　对于结果集的处理方法不同 　　list()方法会一次获得所有的结果集对象 而且它会依据查询的结果初始化所有的结果集对象 这在结果集非常大的时候必然会占据非常多的内存 甚至会造成内存溢出情况的发生 　　iterator()方法在执行时不会一次初始化所有的对象 而是根据对结果集的访问情况来初始化对象 因此在访问中可以控制缓存中对象的数量 以避免占用过多缓存 导致内存溢出情况的发生 使用iterator()方法的另外一个好处是 如果只需要结果集中的部分记录 那么没有被用到的结果对象根本不会被初始化 所以 对结果集的访问情况也是调用iterator()方法时执行数据库SQL语句多少的一个因素 　　所以 在使用Query对象执行数据查询时应该从以上几个方面去考虑使用何种方法来执行数据库的查询操作 　　四 使用正确的抓取策略 　　所谓抓取策略(fetching strategy)是指当应用程序需要利用关联关系进行对象获取的时候 Hibernate获取关联对象的策略 抓取策略可以在O/R映射的元数据中声明 也可以在特定的HQL或条件查询中声明 　　Hibernate 定义了以下几种抓取策略 　　连接抓取(Join fetching) 　　连接抓取是指Hibernate在获得关联对象时会在SELECT语句中使用外连接的方式来获得关联对象 　　查询抓取(Select fetching) 　　查询抓取是指Hibernate通过另外一条SELECT语句来抓取当前对象的关联对象的方式 这也是通过外键的方式来执行数据库的查询 与连接抓取的区别在于 通常情况下这个SELECT语句不是立即执行的 而是在访问到关联对象的时候才会执行 　　子查询抓取(Subselect fetching) 　　子查询抓取也是指Hibernate通过另外一条SELECT语句来抓取当前对象的关联对象的方式 与查询抓取的区别在于它所采用的SELECT语句的方式为子查询 而不是通过外连接 　　批量抓取(Batch fetching) 　　批量抓取是对查询抓取的优化 它会依据主键或者外键的列表来通过单条SELECT语句实现管理对象的批量抓取 　　以上介绍的是Hibernate 所提供的抓取策略 也就是抓取关联对象的手段 为了提升系统的性能 在抓取关联对象的时机上 还有以下一些选择 　　立即抓取(Immediate fetching) 　　立即抓取是指宿主对象被加载时 它所关联的对象也会被立即加载 　　延迟集合抓取(Lazy collection fetching) 　　延迟集合抓取是指在加载宿主对象时 并不立即加载它所关联的对象 而是到应用程序访问关联对象的时候才抓取关联对象 这是集合关联对象的默认行为 　　延迟代理抓取(Lazy proxy fetching) 　　延迟代理抓取是指在返回单值关联对象的情况下 并不在对其进行get操作时抓取 而是直到调用其某个方法的时候才会抓取这个对象 　　延迟属性加载(Lazy attribute fetching) 　　延迟属性加载是指在关联对象被访问的时候才进行关联对象的抓取 　　介绍了Hibernate所提供的关联对象的抓取方法和抓取时机 这两个方面的因素都会影响Hibernate的抓取行为 最重要的是要清楚这两方面的影响是不同的 不要将这两个因素混淆 在开发中要结合实际情况选用正确的抓取策略和合适的抓取时机 　　抓取时机的选择 　　在Hibernate 中 对于集合类型的关联在默认情况下会使用延迟集合加载的抓取时机 而对于返回单值类型的关联在默认情况下会使用延迟代理抓取的抓取时机 　　对于立即抓取在开发中很少被用到 因为这很可能会造成不必要的数据库操作 从而影响系统的性能 当宿主对象和关联对象总是被同时访问的时候才有可能会用到这种抓取时机 另外 使用立即连接抓取可以通过外连接来减少查询SQL语句的数量 所以 也会在某些特殊的情况下使用 　　然而 延迟加载又会面临另外一个问题 如果在Session关闭前关联对象没有被实例化 那么在访问关联对象的时候就会抛出异常 处理的方法就是在事务提交之前就完成对关联对象的访问 　　所以 在通常情况下都会使用延迟的方式来抓取关联的对象 因为每个立即抓取都会导致关联对象的立即实例化 太多的立即抓取关联会导致大量的对象被实例化 从而占用过多的内存资源 　　抓取策略的选取 　　对于抓取策略的选取将影响到抓取关联对象的方式 也就是抓取关联对象时所执行的SQL语句 这就要根据实际的业务需求 数据的数量以及数据库的结构来进行选择了 　　在这里需要注意的是 通常情况下都会在执行查询的时候针对每个查询来指定对其合适的抓取策略 指定抓取策略的方法如下所示 　　User user = (User) session createCriteria(User class) 　　 setFetchMode( permissions FetchMode JOIN) 　　 add( Restrictions idEq(userId) ) 　　 uniqueResult(); 　　五 查询性能提升小结 　　在本小节中介绍了查询性能提升的方法 关键是如何通过优化SQL语句来提升系统的查询性能 查询方法和抓取策略的影响也是通过执行查询方式和SQL语句的多少来改变系统的性能的 这些都属于开发人员所应该掌握的基本技能 避免由于开发不当而导致系统性能的低下 　　在性能调整中 除了前面介绍的执行SQL语句的因素外 对于缓存的使用也会影响系统的性能 通常来说 缓存的使用会增加系统查询的性能 而降低系统增加 修改和删除操作的性能(因为要进行缓存的同步处理) 所以 开发人员应该能够正确地使用有效的缓存来提高数据查询的性能 而要避免滥用缓存而导致的系统性能变低 在采用缓存的时候也应该注意调整自己的检索策略和查询方法 这三者配合起来才可以达到最优的性能 lishixinzhi/Article/program/Java/ky/201311/28720

简单地说就是通过让你调用一些它提供的方法操作来得知你想干什么，然后把你的操作翻译成sql语言去帮你操作数据库

1.Hibernate的优缺点： 优点：1、程序更加面向对象； 2、提高了生产率； 3、方便移植（修改配置文件）； 4、无侵入性。 缺点： 1、效率比JDBC略差； 2、不适合批量操作。2.Hibernate有四种查询方案： 1、get,load方法，根据id查找对象 2、HQL--hibernate query language（查询对象：Query) 3、Criteria--标准查询语言（查询对象：Criteria，查询条件：Criterion） 4、通过sql来查（查询对象：SQLQuery）

hibernateafter关闭，Hibernate中session的关闭问题实现一个修改客户信心的功能，分为两部分：一、点击修改，跳转到后台，然后执行根据id查询客户信息的操作，并将查询

是想查询什么呢？

hibernate 是不及物动词 汉语解释为：(某些动物)冬眠, 蛰伏例句：Some bears hibernate.有些熊冬眠。巧妙记忆方法：hi,(喂)ber(别)na(拿)te(它)。 喂，别拿它。（因为它在冬眠）。希望可以帮到您！

持久层

hibernate4.0版本和3.0版本的区别1.数据库方言设置<property name=”dialect”>org.hibernate.dialect.MySQL5Dialect</property>在3.3版本中连接MySQL数据库只需要指明MySQLDialect即可。在4.1版本中可以指出MySQL5Dialect2.buildSessionFactory4.1版本中buildSessionFactory()已经被buildSessionFactory(ServiceRegistry ServiceRegistry)取代解决办法：Configuration cfg = new Configuration();ServiceRegistry serviceRegistry =new ServiceRegistryBuilder().applySettings(cfg.getProperties()).buildServiceRegistry();SessionFactory sf= cfg.configure().buildSessionFactory(serviceRegistry);3.annotationorg.hibernate.cfg.AnnotationConfiguration;Deprecated. All functionality has been moved to Configuration这个注解读取配置的class已经废弃，现在读取配置不需要特别注明是注解，直接用Configuration cfg = new Configuration();就可以读取注解。Hibernate4.1版本中推荐使用annotation配置，所以在引进jar包时把requested里面的包全部引进来就已经包含了annotation必须包了4.Hibernate4.1已经可以自动建表，所以开发时只需要自己开发类然后配置好就OK。不需要考虑怎么建表

用JDBC操作数据库你烦不烦？把这些事扔给hibernate去做

　hibernate中实体关系表的配置，一对一关系：　　在关系型数据库中存在两种表示一对一关系的设计方式，分别是“主键约束”和“唯一外键约束”。针对这两种不同的设计，在hibernate中有两种配置方法：　　首先要明确，这两种设计的实体关系都可以表示为：你中有我，我中有你。也就是说对象关系是一样的　　①主键约束　　这种设计方式，是A表和B表都有一个相同的主键　　比如夫妻关系表，如下：　　class Hasband{　　private int id;　　private String name;　　private Wife myWife;　　getter和setter　　}　　以及　　class Wife{　　private int id;　　private String name;　　private Hasband myMan;　　getter和setter　　}　　注意设计表的时候，一定要有一个主键　　对应的表结构如下：　　table t_hasband　　t_id int　　t_name varchar　　以及　　table t_wife　　t_id int　　t_name varchar　　在hibernate中的配置则要注意两点，第一：两张表一定要建立级联操作，第二：其中一张表的主键必须有一个class=“foreign”，关键配置如下：　　实体A(丈夫)：　　<one-to-one name="myWife" class="...WifePo" cascade="all"→级联操作></one-to-one>　　实体B(妻子)：　　<id ...>　　<generator class="foreign"→表示这个表的主键依赖于另一张表的主键(主键约束)　　<para name="property">myMan</para>　　</generator>　　</id>　　<one-to-one name="myMan" class="...Hasband"></one-to=one>　　另外，我发现如果在使用MySQL时，在hibernate中设置主键自增时，设成native将会报错，最好使用increment。　　②唯一外键约束(注意唯一两字)　　对象关系不变　　表的建立不一样了，我们用公民与身份证的例子来说明，给公民一个唯一的表示身份证id的标识，，因为是唯一标识，所以建在那张表上没有区别　　表结构是:　　t_citizen　　t_id int primary key　　t_name String　　t_carId int　　以及　　t_card　　t_id int primary key　　t_name string　　至于hibernate配置，这种情况可以看做多对一的一种特例；　　对公民实体：　　<many-to-one name="CitizenPo" class="..." cascade="all"→这里是必须得，因为另一张表依赖于这张表，没有这条会报错。unique="true"→唯一的 column=""/>　　对于身份证而言：　　<one-to-one name="citizen" class="" property-ref="card"→表明这是通过外键加载　　cascade="all" →这句不写 在存身份证表的时候公民表不会更新/>

这两个型号是区别面试题，他们的类型和题目是不同的。

Power Options( 电源选项) Hibernate”休眠Select the Hibernate tab in the Power Options Properties dialog box. 在“电源管理”属性对话框里选择“休眠”选项卡。

正如一些传统的经典计算机文章大都会通过一个“hello,world”的例子开始讲解一样，我们也不例外，我们也将从一个相对简单的例子来阐述Hibernate的开发方法，但如果要真正阐述Hibernate的一些重要思想，仅仅靠在屏幕上打印一些字符是远远不够的，在我们的示例程序中，我们将创建一些对象，并将其保存在数据库中，然后对它们进行更新和查询。

最大的区别在于：ibatas的sql语句需要自己手动写，而hibernate能够在程序运行时自动生成。但是不要就这样以为hibernate比ibatas方便，其实二者熟悉之后的效率差不多。而hibernate还能够自动建表等等，这样的好处就在于你带着这个程序，无论到什么机器上，你都不需要数据库，应为它能自动为你完成，而ibatas就必须要有相应的数据库表才能进行移植Hibernate的特点：Hibernate功能强大，数据库无关性好，O/R（对象/关系）映射能力强，如果你对Hibernate相当精通，而且对Hibernate进行了适当的封装，那么你的项目整个持久层代码会相当简单，需要写的代码很少，开发速度很快，非常爽。Hibernate对数据库结构提供了较为完整的封装，Hibernate的O/R Mapping实现了POJO（实体类） 和数据库表之间的映射，以及SQL 的自动生成和执行。程序员往往只需定义好了POJO 到数据库表的映射关系，即可通过Hibernate 提供的方法完成持久层操作。程序员甚至不需要对SQL 的熟练掌握， Hibernate/OJB 会根据制定的存储逻辑，自动生成对应的SQL 并调用JDBC 接口加以执行。Hibernate的缺点就是学习门槛不低，要精通门槛更高，而且怎么设计O/R映射，在性能和对象模型之间如何权衡取得平衡，以及怎样用好Hibernate方面需要你的经验和能力都很强才行，但是Hibernate现在已经是主流O/R Mapping框架，从文档的丰富性，产品的完善性，版本的开发速度都要强于iBATIS。iBATIS的特点：iBATIS入门简单，即学即用，提供了数据库查询的自动对象绑定功能，而且延续了很好的SQL使用经验，对于没有那么高的对象模型要求的项目来说，相当完美。iBATIS的缺点就是框架还是比较简陋，功能尚有缺失，虽然简化了数据绑定代码，但是整个底层数据库查询实际还是要自己写的，工作量也比较大，而且不太容易适应快速数据库修改。当系统属于二次开发,无法对数据库结构做到控制和修改,那iBATIS的灵活性将比Hibernate更适合。系统数据处理量巨大，性能要求极为苛刻，这往往意味着我们必须通过经过高度优化的SQL语句（或存储过程）才能达到系统性能设计指标。在这种情况下iBATIS会有更好的可控性和表现。现在就市场来说，hibernate的需求要大于ibatas的需求，而hibernate对个人能力的要求更高，即使公司使用ibatas，你在hibernate的基础上也能快速掌握。在二者之间如果选择学习的话我建议hibernate，上面的理由我想已经足够清楚了。

1) 对于每个实体，需要写一个dao接口文件。编码复杂度C(n)=O(n)，即会随实体的增长，编码量呈线性增长。当n较大时，会增加许多人力物力消耗。2) 实体Javabean与DB表的map映射文件太多；或者，实体Javabean文件注解用得太泛滥，太多注解难以记忆，增加开发人员负担。Mybatis中实体对应的mapper文件，代码太多，虽然可以自动生成，但阅读性太差。编写和调试sql语句需要大量时间，降低开发效率。3) 实体操作默认的条件，一般以id作为条件，但开发时，一般不会提前知道id；若用其它条件作为查询等，需要在接口文件新定义方法。如一个实体有10个字段，2个字段组合一个查询方法，则有 =45个查询方法；若算上3个字段，4个字段的组合，则更多。4) 接口文件定义好后，若后期发现定义的方法不能满足需求，需要定义新的方法，又要修改接口文件；若是系统已经上线，还要需要重新开发、测试、发布等。5) 当一个表新增一个字段，删除一个字段，或修改一个字段时，Mybatis需要修改mapper映射文件，几乎其中的每个方法都要修改。修改字段，Mybatis在编译期不能自动发现错误。Hibernate通过xml文件或有注解的Javabean文件，同步DB的表结构时，也不能实现删除和更新。更新时，它是忽略原来的字段，然后新增一个字段，除非删除了表，重新再建一次。要是DB的表已保存了数据，不能删除，还是要手动去更改数据库。6) Hibernate想让ORM框架做完DB所有的事情，反而使框架变得太复杂，不易于使用。Hibernate的ORM模型不能查询一部分数据，即使用户没有使用到，也会将所有关联的数据都查询出来。7) Hibernate的概念太复杂，学习成本高，更新会先查询再更新，n+1问题。Mybatis即使进行单表的Suid操作也需要人工写sql或生成sql文件，需要维护的sql太多。8) 需要写很多的判断字段是否为空（null) ，是否是空字符串的语句；开发人员需要承担太多类似的重复，乏味的编程工作。--------------------- 原文：https://blog.csdn.net/abckingaa/article/details/84557336 版权声明：本文为博主原创文章，转载请附上博文链接！

Hibernate 与Mybatis都是流行的持久层开发框架，但Hibernate开发社区相对多热闹些，支持的工具也多，更新也快，当前最高版本4.1.8。而Mybatis相对平静，工具较少，当前最高版本3.2相同点Hibernate和Mybatis的二级缓存除了采用系统默认的缓存机制外，都可以通过实现你自己的缓存或为其他第三方缓存方案，创建适配器来完全覆盖缓存行为。不同点Hibernate的二级缓存配置在SessionFactory生成的配置文件中进行详细配置，然后再在具体的表-对象映射中配置是那种缓存。MyBatis的二级缓存配置都是在每个具体的表-对象映射中进行详细配置，这样针对不同的表可以自定义不同的缓存机制。并且Mybatis可以在命名空间中共享相同的缓存配置和实例，通过Cache-ref来实现。两者比较因为Hibernate对查询对象有着良好的管理机制，用户无需关心SQL。所以在使用二级缓存时如果出现脏数据，系统会报出错误并提示。而MyBatis在这一方面，使用二级缓存时需要特别小心。如果不能完全确定数据更新操作的波及范围，避免Cache的盲目使用。否则，脏数据的出现会给系统的正常运行带来很大的隐患。第六章 Hibernate与Mybatis对比总结两者相同点Hibernate与MyBatis都可以是通过SessionFactoryBuider由XML配置文件生成SessionFactory，然后由SessionFactory 生成Session，最后由Session来开启执行事务和SQL语句。其中SessionFactoryBuider，SessionFactory，Session的生命周期都是差不多的。Hibernate和MyBatis都支持JDBC和JTA事务处理。Mybatis优势MyBatis可以进行更为细致的SQL优化，可以减少查询字段。MyBatis容易掌握，而Hibernate门槛较高。Hibernate优势Hibernate的DAO层开发比MyBatis简单，Mybatis需要维护SQL和结果映射。Hibernate对对象的维护和缓存要比MyBatis好，对增删改查的对象的维护要方便。Hibernate数据库移植性很好，MyBatis的数据库移植性不好，不同的数据库需要写不同SQL。Hibernate有更好的二级缓存机制，可以使用第三方缓存。MyBatis本身提供的缓存机制不佳。他人总结Hibernate功能强大，数据库无关性好，O/R映射能力强，如果你对Hibernate相当精通，而且对Hibernate进行了适当的封装，那么你的项目整个持久层代码会相当简单，需要写的代码很少，开发速度很快，非常爽。 Hibernate的缺点就是学习门槛不低，要精通门槛更高，而且怎么设计O/R映射，在性能和对象模型之间如何权衡取得平衡，以及怎样用好Hibernate方面需要你的经验和能力都很强才行。 iBATIS入门简单，即学即用，提供了数据库查询的自动对象绑定功能，而且延续了很好的SQL使用经验，对于没有那么高的对象模型要求的项目来说，相当完美。iBATIS的缺点就是框架还是比较简陋，功能尚有缺失，虽然简化了数据绑定代码，但是整个底层数据库查询实际还是要自己写的，工作量也比较大，而且不太容易适应快速数据库修改。

hibernate 是一个数据持久层的框架,只管 怎么去访问及操作数据库的数据.spring 是一个更加强大的框架,是为J2EE 应用程序开发提供集成的框架,体现在其简单性、可测试性和松耦合上,同时对面向切面编程也有支撑的.再简单打个比方,hibernate 是 仓库的仓储管理人员,负责货物的仓储管理.spring 就是 管理层的核心领导,负责协调调度,以保障企业的良好运作.

你和ibatis作比较就知道hibernate的优缺点了！！！

我一直用SSH2做项目，所以我的体会最深的是，你不用去关心数据库里面表的字段了，因为Hibernate都可以跟你转成对象，所以我们操作数据库就像操作对象那样轻松，不知你是否懂，百度的专业术语太强，看的你头都疼！

　　Hibernate一共包括了 个jar包 令人眼花缭乱 本文将详细讲解Hibernate每个jar包的作用 便于你在应用中根据自己的需要进行取舍 　　下载Hibernate 例如 稳定版本 解压缩 可以看到一个hibernate jar和lib目录下有 个jar包 　　hibernate jar: 　　Hibernate的库 没有什么可说的 必须使用的jar包 　　cglib a *** jar: 　　CGLIB库 Hibernate用它来实现PO字节码的动态生成 非常核心的库 必须使用的jar包 　　dom j jar: 　　dom j是一个Java的XML API 类似于jdom 用来读写XML文件的 dom j是一个非常非常优秀的Java XML API 具有性能优异 功能强大和极端易用使用的特点 同时它也是一个开放源代码的软件 可以在SourceFe上找到它 在IBM developerWorks上面可以找到一篇文章 对主流的Java XML API进行的性能 功能和易用性的评测 dom j无论在那个方面都是非常出色的 我早在将近两年之前就开始使用dom j 直到现在 如今你可以看到越来越多的Java软件都在使用dom j来读写XML 特别值得一提的是连Sun的JAXM也在用dom j 这是必须使用的jar包 Hibernate用它来读写配置文件 　　odmg jar: 　　ODMG是一个ORM的规范 Hibernate实现了ODMG规范 这是一个核心的库 必须使用的jar包 　　mons collections jar 　　Apache Commons包中的一个 包含了一些Apache开发的集合类 功能比java util *强大 必须使用的jar包 　　mons beanutils jar 　　Apache Commons包中的一个 包含了一些Bean工具类类 必须使用的jar包 　　mons lang jar: 　　Apache Commons包中的一个 包含了一些数据类型工具类 是java lang *的扩展 必须使用的jar包 　　mons logging jar: 　　Apache Commons包中的一个 包含了日志功能 必须使用的jar包 这个包本身包含了一个Simple Logger 但是功能很弱 在运行的时候它会先在CLASSPATH找log j 如果有 就使用log j 如果没有 就找JDK 带的java util logging 如果也找不到就用Simple Logger mons logging jar的出现是一个历史的的遗留的遗憾 当初Apache极力游说Sun把log j加入JDK 然而JDK 项目小组已经接近发布JDK 产品的时间了 因此拒绝了Apache的要求 使用自己的java util logging 这个包的功能比log j差的很远 性能也一般 　　后来Apache就开发出来了mons logging jar用来兼容两个logger 因此用mons logging jar写的log程序 底层的Logger是可以切换的 你可以选择log j java util logging或者它自带的Simple Logger 不过我仍然强烈建议使用log j 因为log j性能很高 log输出信息时间几乎等于System out 而处理一条log平均只需要 us 你可以在Hibernate的src目录下找到Hibernate已经为你准备好了的log j的配置文件 你只需要到Apache 网站去下载log j就可以了 mons logging jar也是必须的jar包 　　使用Hibernate必须的jar包就是以上的这几个 剩下的都是可选的 　　ant jar: 　　Ant编译工具的jar包 用来编译Hibernate源代码的 如果你不准备修改和编译Hibernate源代码 那么就没有什么用 可选的jar包 　　optional jar 　　Ant的一个辅助包 　　c p jar 　　C PO是一个数据库连接池 Hibernate可以配置为使用C PO连接池 如果你准备用这个连接池 就需要这个jar包 　　proxool jar 　　也是一个连接池 同上 　　mons pool jar mons dbcp jar: 　　DBCP数据库连接池 Apache的Jakarta组织开发的 Tomcat 的连接池也是DBCP 　　实际上Hibernate自己也实现了一个非常非常简单的数据库连接池 加上上面 个 你实际上可以在Hibernate上选择 种不同的数据库连接池 选择哪一个看个人的偏好 不过DBCP可能更通用一些 另外强调一点 如果在EJB中使用Hibernate 一定要用App Server的连接池 不要用以上 种连接池 否则容器管理事务不起作用 　　connector jar: 　　JCA 规范 如果你在App Server上把Hibernate配置为Connector的话 就需要这个jar 不过实际上一般App Server肯定会带上这个包 所以实际上是多余的包 　　jaas jar: 　　JAAS是用来进行权限验证的 已经包含在JDK 里面了 所以实际上是多余的包 　　jcs jar 　　如果你准备在Hibernate中使用JCS的话 那么必须包括它 否则就不用 　　jdbc _ stdext jar: 　　JDBC 的扩展包 一般来说数据库连接池会用上它 不过App Server都会带上 所以也是多余的 　　jta jar 　　JTA规范 当Hibernate使用JTA的时候需要 不过App Server都会带上 所以也是多余的 　　junit jar: 　　Junit包 当你运行Hibernate自带的测试代码的时候需要 否则就不用 　　xalan jar xerces jar xml apis jar: lishixinzhi/Article/program/Java/ky/201311/28745

　　① 制定合理的缓存策略（二级缓存、查询缓存）。　　② 采用合理的Session管理机制。　　③ 尽量使用延迟加载特性。　　④ 设定合理的批处理参数。　　⑤ 如果可以，选用UUID作为主键生成器。　　⑥ 如果可以，选用基于版本号的乐观锁替代悲观锁。　　⑦ 在开发过程中, 开启hibernate.show_sql选项查看生成的SQL，从而了解底层的状况；开发完成后关闭此选项。　　⑧ 考虑数据库本身的优化，合理的索引、恰当的数据分区策略等都会对持久层的性能带来可观的提升，但这些需要专业的DBA（数据库管理员）提供支持。　　Hibernate的悲观锁和乐观锁机制。　　有些业务逻辑在执行过程中要求对数据进行排他性的访问，于是需要通过一些机制保证在此过程中数据被锁住不会被外界修改，这就是所谓的锁机制。　　Hibernate支持悲观锁和乐观锁两种锁机制。悲观锁，顾名思义悲观的认为在数据处理过程中极有可能存在修改数据的并发事务（包括本系统的其他事务或来自外部系统的事务），于是将处理的数据设置为锁定状态。悲观锁必须依赖数据库本身的锁机制才能真正保证数据访问的排他性，关于数据库的锁机制和事务隔离级别在《Java面试题大全（上）》中已经讨论过了。乐观锁，顾名思义，对并发事务持乐观态度（认为对数据的并发操作不会经常性的发生），通过更加宽松的锁机制来解决由于悲观锁排他性的数据访问对系统性能造成的严重影响。最常见的乐观锁是通过数据版本标识来实现的，读取数据时获得数据的版本号，更新数据时将此版本号加1，然后和数据库表对应记录的当前版本号进行比较，如果提交的数据版本号大于数据库中此记录的当前版本号则更新数据，否则认为是过期数据无法更新。Hibernate中通过Session的get()和load()方法从数据库中加载对象时可以通过参数指定使用悲观锁；而乐观锁可以通过给实体类加整型的版本字段再通过XML或@Version注解进行配置。　　提示：使用乐观锁会增加了一个版本字段，很明显这需要额外的空间来存储这个版本字段，浪费了空间，但是乐观锁会让系统具有更好的并发性，这是对时间的节省。因此乐观锁也是典型的空间换时间的策略。　　Hibernate的延迟加载机制。　　延迟加载就是并不是在读取的时候就把数据加载进来，而是等到使用时再加载。Hibernate使用了虚拟代理机制实现延迟加载，我们使用Session的load()方法加载数据或者一对多关联映射在使用延迟加载的情况下从一的一方加载多的一方，得到的都是虚拟代理，简单的说返回给用户的并不是实体本身，而是实体对象的代理。代理对象在用户调用getter方法时才会去数据库加载数据。但加载数据就需要数据库连接。而当我们把会话关闭时，数据库连接就同时关闭了。　　延迟加载与session关闭的矛盾一般可以这样处理：　　① 关闭延迟加载特性。这种方式操作起来比较简单，因为Hibernate的延迟加载特性是可以通过映射文件或者注解进行配置的，但这种解决方案存在明显的缺陷。首先，出现"no session or session was closed"通常说明系统中已经存在主外键关联，如果去掉延迟加载的话，每次查询的开销都会变得很大。　　② 在session关闭之前先获取需要查询的数据，可以使用工具方法Hibernate.isInitialized()判断对象是否被加载，如果没有被加载则可以使用Hibernate.initialize()方法加载对象。　　③ 使用拦截器或过滤器延长Session的生命周期直到视图获得数据。Spring整合Hibernate提供的OpenSessionInViewFilter和OpenSessionInViewInterceptor就是这种做法。　　Hibernate的一级缓存、二级缓存和查询缓存　　Hibernate的Session提供了一级缓存的功能，默认总是有效的，当应用程序保存持久化实体、修改持久化实体时，Session并不会立即把这种改变提交到数据库，而是缓存在当前的Session中，除非显示调用了Session的flush()方法或通过close()方法关闭Session。通过一级缓存，可以减少程序与数据库的交互，从而提高数据库访问性能。　　SessionFactory级别的二级缓存是全局性的，所有的Session可以共享这个二级缓存。不过二级缓存默认是关闭的，需要显示开启并指定需要使用哪种二级缓存实现类（可以使用第三方提供的实现）。一旦开启了二级缓存并设置了需要使用二级缓存的实体类，SessionFactory就会缓存访问过的该实体类的每个对象，除非缓存的数据超出了指定的缓存空间。　　一级缓存和二级缓存都是对整个实体进行缓存，不会缓存普通属性，如果希望对普通属性进行缓存，可以使用查询缓存。查询缓存是将HQL或SQL语句以及它们的查询结果作为键值对进行缓存，对于同样的查询可以直接从缓存中获取数据。查询缓存默认也是关闭的，需要显示开启。

hibernate 简介：hibernate是一个开源框架，它是对象关联关系映射的框架，它对JDBC做了轻量级的封装，而我们java程序员可以使用面向对象的思想来操纵数据库。hibernate核心接口session：负责被持久化对象CRUD操作sessionFactory:负责初始化hibernate，创建session对象configuration:负责配置并启动hibernate，创建SessionFactoryTransaction:负责事物相关的操作Query和Criteria接口：负责执行各种数据库查询hibernate工作原理：1.通过Configuration config = new Configuration().configure();//读取并解析hibernate.cfg.xml配置文件2.由hibernate.cfg.xml中的<mapping resource="com/xx/User.hbm.xml"/>读取并解析映射信息3.通过SessionFactory sf = config.buildSessionFactory();//创建SessionFactory4.Session session = sf.openSession();//打开Sesssion5.Transaction tx = session.beginTransaction();//创建并启动事务Transation6.persistent operate操作数据，持久化操作7.tx.commit();//提交事务8.关闭Session9.关闭SesstionFactory为什么要用hibernate：1. 对JDBC访问数据库的代码做了封装，大大简化了数据访问层繁琐的重复性代码。2. Hibernate是一个基于JDBC的主流持久化框架，是一个优秀的ORM实现。他很大程度的简化DAO层的编码工作3. hibernate使用Java反射机制，而不是字节码增强程序来实现透明性。4. hibernate的性能非常好，因为它是个轻量级框架。映射的灵活性很出色。它支持各种关系数据库，从一对一到多对多的各种复杂关系。Hibernate是如何延迟加载?get与load的区别1. 对于Hibernate get方法，Hibernate会确认一下该id对应的数据是否存在，首先在session缓存中查找，然后在二级缓存中查找，还没有就查询数据库，数据 库中没有就返回null。这个相对比较简单，也没有太大的争议。主要要说明的一点就是在这个版本(bibernate3.2以上)中get方法也会查找二级缓存！2. Hibernate load方法加载实体对象的时候，根据映射文件上类级别的lazy属性的配置(默认为true)，分情况讨论： (1)若为true,则首先在Session缓存中查找，看看该id对应的对象是否存在，不存在则使用延迟加载，返回实体的代理类对象(该代理类为实体类的子类，由CGLIB动态生成)。等到具体使用该对象(除获取OID以外)的时候，再查询二级缓存和数据库，若仍没发现符合条件的记录，则会抛出一个ObjectNotFoundException。(2)若为false,就跟Hibernateget方法查找顺序一样，只是最终若没发现符合条件的记录，则会抛出一个ObjectNotFoundException。这里get和load有两个重要区别: 如果未能发现符合条件的记录，Hibernate get方法返回null，而load方法会抛出一个ObjectNotFoundException。load方法可返回没有加载实体数据的代 理类实例，而get方法永远返回有实体数据的对象。(对于load和get方法返回类型：好多书中都说：“get方法永远只返回实体类”，实际上并不正 确，get方法如果在session缓存中找到了该id对应的对象，如果刚好该对象前面是被代理过的，如被load方法使用过，或者被其他关联对象延迟加 载过，那么返回的还是原先的代理对象，而不是实体类对象，如果该代理对象还没有加载实体数据（就是id以外的其他属性数据），那么它会查询二级缓存或者数 据库来加载数据，但是返回的还是代理对象，只不过已经加载了实体数据。)总之对于get和load的根本区别，一句话，hibernate对于 load方法认为该数据在数据库中一定存在，可以放心的使用代理来延迟加载，如果在使用过程中发现了问题，只能抛异常；而对于get方 法，hibernate一定要获取到真实的数据，否则返回null。Hibernate中怎样实现类之间的关系?(如：一对多、多对多的关系)类与类之间的关系主要体现在表与表之间的关系进行操作，它们都市对对象进行操作，我们程序中把所有的表与类都映射在一起，它们通过配置文件中的many-to-one、one-to-many、many-to-many、说下Hibernate的缓存机制：Hibernate缓存的作用：Hibernate是一个持久层框架，经常访问物理数据库，为了降低应用程序对物理数据源访问的频次，从而提高应用程序的运行性能。缓存内的数据是对物理数据源中的数据的复制，应用程序在运行时从缓存读写数据，在特定的时刻或事件会同步缓存和物理数据源的数据Hibernate缓存分类：Hibernate缓存包括两大类：Hibernate一级缓存和Hibernate二级缓存Hibernate一级缓存又称为“Session的缓存”，它是内置的，意思就是说，只要你使用hibernate就必须使用session缓存。由于Session对象的生命周期通常对应一个数据库事务或者一个应用事务，因此它的缓存是事务范围的缓存。在第一级缓存中，持久化类的每个实例都具有唯一的OID。 Hibernate二级缓存又称为“SessionFactory的缓存”，由于SessionFactory对象的生命周期和应用程序的整个过程对应，因此Hibernate二级缓存是进程范围或者集群范围的缓存，有可能出现并发问题，因此需要采用适当的并发访问策略，该策略为被缓存的数据提供了事务隔离级别。第二级缓存是可选的，是一个可配置的插件，在默认情况下，SessionFactory不会启用这个插件。什么样的数据适合存放到第二级缓存中？ 　　1 很少被修改的数据 　　2 不是很重要的数据，允许出现偶尔并发的数据 　　3 不会被并发访问的数据 　　4 常量数据 　　不适合存放到第二级缓存的数据？ 　　1经常被修改的数据 　　2 .绝对不允许出现并发访问的数据，如财务数据，绝对不允许出现并发 　　3 与其他应用共享的数据。 Hibernate查找对象如何应用缓存？当Hibernate根据ID访问数据对象的时候，首先从Session一级缓存中查；查不到，如果配置了二级缓存，那么从二级缓存中查；如果都查不到，再查询数据库，把结果按照ID放入到缓存删除、更新、增加数据的时候，同时更新缓存Hibernate管理缓存实例无论何时，我们在管理Hibernate缓存（Managing the caches）时，当你给save()、update()或saveOrUpdate()方法传递一个对象时，或使用load()、 get()、list()、iterate() 或scroll()方法获得一个对象时, 该对象都将被加入到Session的内部缓存中。 当随后flush()方法被调用时，对象的状态会和数据库取得同步。 如果你不希望此同步操作发生，或者你正处理大量对象、需要对有效管理内存时，你可以调用evict() 方法，从一级缓存中去掉这些对象及其集合。 Hibernate的查询方式Sql、Criteria,object comptositionHql：1、 属性查询2、 参数查询、命名参数查询3、 关联查询4、 分页查询5、 统计函数如何优化Hibernate？1.使用双向一对多关联，不使用单向一对多2.灵活使用单向一对多关联3.不用一对一，用多对一取代4.配置对象缓存，不使用集合缓存5.一对多集合使用Bag,多对多集合使用Set6. 继承类使用显式多态7. 表字段要少，表关联不要怕多，有二级缓存撑腰hibernate的开发步骤：开发步骤1)搭建好环境引入hibernate最小的jar包准备Hibernate.cfg.xml启动配置文件2)写实体类(pojo)3)为实体类写映射文件"User.hbm.xml"在hibernate.cfg.xml添加映射的实体4)创建库表5)写测试类获得Configuration创建SessionFactory打开Session开启事务使用session操作数据提交事务关闭资源

　　Hibernate在解决性能问题方面做得非常好 有了它的缓存机制 使用第三方缓存和数据库连接池 就较好的解决的性能问题 但这些还不够 hibernate给了开发者足够的自由 让开发者自己去控制性能问题 　　学习了一段时间的ibatis 我觉得hibernate有着ibatis无法替代的优势 　　 开发者都知道 hibernate让我们以oo的方式操作数据库 这让我们看到了hibernate的强大之处 体验到操作数据的方便 但Gavin King说 hibernate最耀眼之处是hibernate的缓存机制 而不是以oo的方式操作数据库 Hibernate的缓存机制不外乎是一级缓存session 二级缓存sessionFactory 和第三方缓存如ehcache 也就是hibernate的最强大的地方是它的缓存 理解了这个才能真正的理解hibernate 缓存实在太难了 我至今未能真正理解 　　 可维护性 ibatis宣扬写sql语句 它将sql语句放进一个单独的xml文件 这种方式赢得了很多开发者的喜爱 一句话 方便维护 但hibernate同样具有这种功能 而且比ibatis更加强大 Hibernate的命名查询/命名参数查询 就是将hql语句放在一个单独的xml文件之中 它仍然让人们以面向对象的方式去操纵数据 这得到大量遵循oo方式开发者的喜爱 而不用在以oo的方式写着代码的同时 然后再转变思维 用面向关系的方式去写那些sql语句 但hibernate不仅做了这些 它的native sql查询方式 完全满足sql语句的偏爱者 它像ibatis一样 将sql语句放在配置文件之中 　　 性能 我坚信 hibernate性能问题不是问题 想想那么多大中小项目都在使用hibernate 你还怀疑hibernate的性能吗？spring整合hibernate之后 在真正性能瓶颈的地方 完全可以使用spring集成的jdbc 或直接写存储过程得了 但首先得确认 这实在是性能瓶颈的地方 我想 不应想当然的认为性能的问题 所谓的性能问题阻挠了很多人 　　我认为 性能的好坏无外是发送sql语句的多少而已 性能好 发送的sql语句少 性能差 就是发送大量的sql语句 Hibernate在解决性能问题方面做得非常好 　　有了它的缓存机制 使用第三方缓存和数据库连接池 就较好的解决的性能问题 　　但这些还不够 hibernate给了开发者足够的自由 让开发者自己去控制性能问题 　　我认为开发者可以在以下几个方面自行调优 　　a 在查询字符串中 应该总是使用jdbc的占位符？ 或使用使用命名参数 不要自查询中使用字符串值来代替非常量值 　　b Flush会影响性能 频繁刷新影响性能 尽量减少不必要的刷新 　　c Cascade策略 在几对几的关系 正确设置cascade策略 想清楚在操作对象A的同时是否需要级联操作对象B 比如在one to many的父子关系中 删除了父亲one 需级联删除子many 这时的one这端可设置cascade = delete 这样在删除one时 会自动删除子 但对子的操作不会影响父 Cascade还有其他的属性值 只要设置正确 可提升性能 　　d lazy策略 正确设置延迟加载策略同样会提升性能 在one to many或many to many中 通常总应该延迟加载many的一方的到内存 设置了lazy = true 首先发送sql语句 加载自己到内存 到需要时才加载级联对象 lazy= false 则会同时加载自己和级联对象到内存 　　e 另外还有集合的性能（set list map array） 都应正确设置 　　f 正确使用第三方缓存 在读操作频繁写操作不多的情况 使用第三方缓存可大幅度提升性能 如ehcache的缓存策略有 read only read write和notstrict read write 　　f 随着hibernate新版本的发布 和技术的发展 我相信hibernate的性能会越来越好 所有性能不是不使用hibernate的原因 　　 hibernate不仅仅作为持久层的orm框架存在 它除了dao层的持久化操作外 还有很多 　　在注解annotation已经走向主流的今天 hibernate 迅速响应 让xml部署描述符成为可选的 Hibernate annotation 对大字段的处理只是一个@Lob就搞定了 　　hibernate search对Lucene进行了轻量级的封装 全文检索变得非常简单 　　Hibernate validator被认为是最合理的验证方式 将验证策略直接附在贯穿各层的领域模型domain上 不再需要哪些web框架的xml方式的验证 代码中不再出现大量的非空/null的判断 　　 jbpm Jbpm业务流程引擎的持久层采用hibenrnate来实现 要想使用jbpm hibernate是必须的 我想 业务流程管理无比重要 在soa迅速发展的今天 如果实施soa项目 业务流程管理是必然和必须的 因为soa就是业务和it技术的融合 是业务流程管理和it基础架构的融合 在soa中 业务管理是第一位的 这需要相应的技术来实现该业务流程管理 开源领域的jbpm我想会是首选 所以 为了将来有可能实施soa项目 为了实现soa的业务流程管理 应该使用hibernate 　　 大家都知道 hibernate将ejb 时代的实体bean赶进了历史 而ejb 的jpa标准也只不过是hibernate的子集而已 jsr规范请求的威力是巨大的 没有各种jsr规范请求 就不会有各种应用程序框架 各种应用程序框架只是那些jsr规范请求的实现者 jpa作为持久层的规范标准 引导持久层orm框架的方向 jpa同样以面向对象的方式操作数据库 而不是写sql语句 规范标准都完全orm 不写sql了 你还有理由不跟着它吗？ 　　 Spring+hibernate+范型+可变参数 这是一个非常强大的组合 对应普通的crud操作 你不再需要重复写那些烦人的相似的dao层和manager层的代码 仅仅需要写一次 就完成了所有大量的crud操作 Ibatis尽管也支持范型 但始终没有hibernate支持的好 　　 Jboss hibernate是jboss的项目 jboss的所有项目的持久层都采用的hibernate 要知道 jsr规范组的专家们大多数是来自jboss的 在一定程度上说 jboo引领着java的发展方向 使用hibernate 跟着jboss 不偏离java的发展方向 　　 Gavin King 我最崇拜的偶像 他不仅发明了强大的hibernate 还搞出了同样强大且优雅的web 应用程序框架seam 他是ejb 专家组成员之一 是jpa规范请求的领导者 他java领域最有发言权 最权威的领袖人物之一 现在 他领导web bean的 jsr 的发展 web bean规范的制定 全球软件巨头如ibm oracle bea和apache没有一个反对 纷纷响应 Web bean 想象起来 实在太美好了 完全的松耦合和强类型 所有的应用组件生活在一个应用组件上下文context中 相互合作 那时将不再有各种各样的上下文环境 不再有struts 的ActionContext 不再有spring的ApplicationContext 不再有hibernate的session 不再有持久化上下文 不再有事务上下文 不再有安全上下文 所有组件生活在一个大家庭中 大家其乐融融 实现天下的大和平 　　 osgi 我认为现在最值得学习的一个技术 有了osgi 实现真正的多模块开发 改变传统的开发方式 现在 已经有了hibernate osgi spring dynamic modul（osgi） struts 同样实现了对osgi的支持 目前 eclipse是基于osgi开发的 ibm的websphere v bea的所有产品都重构在osgi上 spring的应用服务器同样基于osgi 在EclipseCon 上 osgi成为了主要的话题 Osgi受到如此的待遇 一点不奇怪 因为他具有无比强大的功能 改变传统的软件开发方式 Osgi采用树设计模式 将一个项目分成多个模块（bundle） 每个模块单独部署 单独运行 说白了 就是将一个工程分成许多的插件 每个插件单独开发 重复使用 实现完全的即插即用 太令人激动了 如果公司的软件开发基于osgi 将会有大量的重复使用的osgi bundles 公司将会积累大量的无形资产 软件开发将会越来越快 而ibatis现在还没见到对osgi的支持 　　 hibernate的社区非常繁荣 ibatis则相对平静 　　综述 hibernate还有很多优秀的特点 只是我们不知道 Hibernate与ibatis 就像大家闺秀对小家碧玉 大家闺秀不仅具有小家碧玉的全部 而且知名度更高 更受尊敬 更受人追捧 更有发展前途 小家碧玉尽管也很有魅力 但始终比上大家闺秀 　　Hibernate所做的不仅仅是dao层的持久化工作 而ibatis恰恰如此 　　选择hibernate 选择orm的王者 选择更全面的工作体验 选择更高效的工作方式 选择更多的利润 选择Gavin King 跟着领袖走 选择jboss 追随开源的潮流 不偏离java的发展方向 lishixinzhi/Article/program/Java/ky/201311/28357

　　在基于MVC设计模式的JAVA WEB应用中 Hibernate可以作为模型层/数据访问层 它通过配置文件(hibernate properties或hibernate cfg xml)和映射文件(*** hbm xml)把JAVA对象或PO(Persistent Object 持久化对象)映射到数据库中的数据库 然后通过操作PO 对数据表中的数据进行增 删 改 查等操作 　　除配置文件 映射文件和持久化类外 Hibernate的核心组件包括以下几部分 　　a)Configuration类 用来读取Hibernate配置文件 并生成SessionFactory对象 　　b)SessionFactory接口 产生Session实例工厂 　　c)Session接口 用来操作PO 它有get() load() save() update()和delete()等方法用来对PO进行加载 保存 更新及删除等操作 它是Hibernate的核心接口 　　d)Query接口 用来对PO进行查询操 它可以从Session的createQuery()方法生成 　　e)Transaction接口 用来管理Hibernate事务 它主要方法有mit()和rollback() 可以从Session的beginTrancation()方法生成 　　Persistent Object 　　持久化对象可以是普通的Javabeans 惟一特殊的是它们与(仅一个)Session相关联 JavaBeans在Hibernate中存在三种状态 　　 临时状态(transient):当一个JavaBean对象在内存中孤立存在 不与数据库中的数据有任何关联关系时 那么这个JavaBeans对象就称为临时对象(Transient Object) 　　 持久化状态(persistent):当一个JavaBean对象与一个Session相关联时 就变成持久化对象(Persistent Object) 　　 脱管状态(detached):在这个Session被关闭的同时 这个对象也会脱离持久化状态 就变成脱管状态(Detached Object) 可以被应用程序的任何层自由使用 例如可以做与表示层打交道的数据舆对象(Data Transfer Object) 　　Hibernate的运行过程 　　Hibernate的运行过程如下 　　A:应用程序先调用Configration类 该类读取Hibernate的配置文件及映射文件中的信息 并用这些信息生成一个SessionFactpry对象 　　B:然后从SessionFactory对象生成一个Session对象 并用Session对象生成Transaction对象;可通过Session对象的get() load() save() update() delete()和saveOrUpdate()等方法对PO进行加载 保存 更新 删除等操作;在查询的情况下 可通过Session对象生成一个Query对象 然后利用Query对象执行查询操作;如果没有异常 Transaction对象将提交这些操作结果到数据库中 　　Hibernate简单示例 　　数据 　　create table T_register 　　( 　　id int primary key 　　userName varchar( ) 　　userPwd varchar( ) 　　sex varchar( ) 　　age int 　　) 　　视图层 注册页面register jsp 　　用户名 　　密 码 　　性 别 　　年 龄 　　设计持久化类TRegister java 　　package hibernate PO; 　　/** 　　* 持久化类 　　*/ 　　public class TRegister implements java io Serializable { 　　// Fields 　　private Integer id; 　　private String userName; 　　private String userPwd; 　　private String sex; 　　private Integer age; 　　// Constructors 　　/** default constructor */ 　　public TRegister() { 　　} 　　/** minimal constructor */ 　　public TRegister(Integer id) { 　　this id = id; 　　} 　　/** full constructor */ 　　public TRegister(Integer id String userName String userPwd String sex Integer age) { 　　this id = id; 　　this userName = userName; 　　this userPwd = userPwd; 　　this sex = sex; 　　this age = age; 　　} 　　// Property accessors 　　public Integer getId() { 　　return this id; 　　} 　　public void setId(Integer id) { 　　this id = id; 　　} 　　public String getUserName() { 　　return this userName; 　　} 　　public void setUserName(String userName) { 　　this userName = userName; 　　} 　　public String getUserPwd() { 　　return this userPwd; 　　} 　　public void setUserPwd(String userPwd) { 　　this userPwd = userPwd; 　　} 　　public String getSex() { 　　return this sex; 　　} 　　public void setSex(String sex) { 　　this sex = sex; 　　} 　　public Integer getAge() { 　　return this age; 　　} 　　public void setAge(Integer age) { 　　this age = age; 　　} 　　} 　　设计Hibernate配置文件hibernate cfg xml 　　 //Hibernate/Hibernate Configuration DTD //EN 　　 configuration dtd > 　　root 　　jdbc:mysql://localhost: /study 　　 hibernate dialect MySQLDialect 　　MySQL 　　root 　　 gjt mm mysql Driver 　　true 　　设计映射文件TRegister hbm xml 　　 mapping dtd > 　　设计hibernate基础类HibernateUtil java 　　package hibernate; 　　/** 　　* hibernate 基础类 　　* @author fengyan 　　* date : 　　*/ 　　import hibernate HibernateException; 　　import hibernate Session; 　　import hibernate SessionFactory; 　　import hibernate cfg Configuration; 　　public class HibernateUtil { 　　private static final SessionFactory sessionFactory; 　　static 　　{ 　　try 　　{ 　　Configuration config = new Configuration(nfigure( /hibernate/hibernate cfg xml ); 　　sessionFactory = config buildSessionFactory(); 　　} 　　catch(Throwable e) 　　{ 　　throw new ExceptionInInitializerError(e); 　　} 　　} 　　public static final ThreadLocal session = new ThreadLocal(); 　　public static Session currentSession() throws HibernateException 　　{ 　　Session s = (Session)session get(); 　　//Open a new Session if this Thread has none yet 　　if(s == null || !s isOpen()) 　　{ 　　s = sessionFactory openSession(); 　　session set(s); 　　} 　　return s; 　　} 　　public static void closeSession() throws HibernateException 　　{ 　　Session s = (Session)session get(); 　　session set(null); 　　if(s != null) 　　s close(); 　　} 　　} 　　设计控制类 　　package hibernate servlet; 　　/** 　　* @author fengyan 　　* date : 　　* 设计Hibernate控制类 　　*/ 　　import hibernate HibernateUtil; 　　import hibernate PO TRegister; 　　import java io IOException; 　　import java io PrintWriter; 　　import javax servlet ServletException; 　　import javax servlet HttpServlet; 　　import javax servlet HttpServletRequest; 　　import javax servlet HttpServletResponse; 　　import hibernate HibernateException; 　　import hibernate Session; 　　import hibernate Transaction; 　　public class RegisterServlet extends HttpServlet { 　　private static final String CONTENT_TYPE = text/;charset=GBK ; 　　public void init() throws ServletException { 　　// Put your code here 　　} 　　public void destroy() { 　　super destroy(); // Just puts destroy string in log 　　// Put your code here 　　} 　　public void doGet(HttpServletRequest request HttpServletResponse response) 　　throws ServletException IOException { 　　response setContentType(CONTENT_TYPE); 　　request setCharacterEncoding( GBK ); 　　PrintWriter out = response getWriter(); 　　String userName = request getParameter( userName ); 　　String userPwd = request getParameter( userPwd ); 　　String sex = request getParameter( sex ); 　　int age = Integer parseInt(request getParameter( age )); 　　TRegister rg = new TRegister(); 　　rg setAge(age); 　　rg setSex(sex); 　　rg setUserName(userName); 　　rg setUserPwd(userPwd); 　　Session session = HibernateUtil currentSession();//生成Session实例 　　Transaction tx = session beginTransaction(); 　　try 　　{ 　　session save(rg); //保存持久类对象 　　mit(); //提交到数据库 　　session close(); 　　response sendRedirect( registerOK jsp ); 　　} 　　catch(HibernateException e) 　　{ 　　e printStackTrace(); 　　tx rollback(); 　　} 　　} 　　public void doPost(HttpServletRequest request HttpServletResponse response) 　　throws ServletException IOException { 　　doGet(request response); 　　} lishixinzhi/Article/program/Java/ky/201311/28144

Hibernate是一种ORM(Object Relation Mapping 对象关系映射)框架,是当前最流行的持久化的手段,由于当前的数据库几乎都是关系性的数据库,所以在进行数据库的CRUD操作时,就会涉及到多表联查,对于大型的应用这是一个相当麻烦的一个过程,在这种情况下,Hibernate等持久化框架,被人们开始重视,它是通过把SQL进行封装,然后通过关系映射来实现数据库的访问,其本质更符合面向对象的思想.他的映射策略说白了,就是数据库表格的PK和FK的体现,不过您说的"学生名,课程名,认课教师名"是表的字段,建立关系比较麻烦,我这么给你举例子吧,假如存在三张表stu_table,lession_table,teacher_table,一对一(1:1)比如说学生与学号之间就是一种1:1的关系;一对多(1:N)比如说一个学生可以选修一门(假设)课程,但同一门课程可以被多个同学选修多对多(N:N)比如说一个老师可以叫几门课程,而且每门课程可以有多个老师来教.另外,Hibernate不提倡使用多对多映射

一、Hibernate是JDBC的轻量级的对象封装，它是一个独立的对象持久层框架，和App Server，和EJB没有什么必然的联系。Hibernate可以用在任何JDBC可以使用的场合，例如Java应用程序的数据库访问代码，DAO接口的实现类，甚至可以是BMP里面的访问数据库的代码。从这个意义上来说，Hibernate和EB不是一个范畴的东西，也不存在非此即彼的关系。x0dx0ax0dx0a二、Hibernate是一个和JDBC密切关联的框架，所以Hibernate的兼容性和JDBC驱动，和数据库都有一定的关系，但是和使用它的Java程序，和App Server没有任何关系，也不存在兼容性问题。x0dx0ax0dx0a三、Hibernate不能用来直接和Entity Bean做对比，只有放在整个J2EE项目的框架中才能比较。并且即使是放在软件整体框架中来看，Hibernate也是做为JDBC的替代者出现的，而不是Entity Bean的替代者出现的，让我再列一次我已经列n次的框架结构：x0dx0ax0dx0a传统的架构：x0dx0a1) Session Bean <-> Entity Bean <-> DBx0dx0a为了解决性能障碍的替代架构：x0dx0a2) Session Bean <-> DAO <-> JDBC <-> DBx0dx0a使用Hibernate来提高上面架构的开发效率的架构：x0dx0a3) Session Bean <-> DAO <-> Hibernate <-> DB x0dx0ax0dx0a就上面3个架构来分析：x0dx0a1、内存消耗：采用JDBC的架构2无疑是最省内存的，Hibernate的架构3次之，EB的架构1最差。x0dx0ax0dx0a2、运行效率：如果JDBC的代码写的非常优化，那么JDBC架构运行效率最高，但是实际项目中，这一点几乎做不到，这需要程序员非常精通JDBC，运用Batch语句，调整PreapredStatement的Batch Size和Fetch Size等参数，以及在必要的情况下采用结果集cache等等。而一般情况下程序员是做不到这一点的。因此Hibernate架构表现出最快的运行效率。EB的架构效率会差的很远。x0dx0ax0dx0a3、开发效率：在有JBuilder的支持下以及简单的项目，EB架构开发效率最高，JDBC次之，Hibernate最差。但是在大的项目，特别是持久层关系映射很复杂的情况下，Hibernate效率高的惊人，JDBC次之，而EB架构很可能会失败。x0dx0ax0dx0a4、分布式，安全检查，集群，负载均衡的支持x0dx0a由于有SB做为Facade，3个架构没有区别。x0dx0ax0dx0a四、EB和Hibernate学习难度在哪里？x0dx0ax0dx0aEB的难度在哪里？不在复杂的XML配置文件上，而在于EB运用稍微不慎，就有严重的性能障碍。所以难在你需要学习很多EJB设计模式来避开性能问题，需要学习App Server和EB的配置来优化EB的运行效率。做EB的开发工作，程序员的大部分精力都被放到了EB的性能问题上了，反而没有更多的精力关注本身就主要投入精力去考虑的对象持久层的设计上来。x0dx0ax0dx0aHibernate难在哪里？不在Hibernate本身的复杂，实际上Hibernate非常的简单，难在Hibernate太灵活了。x0dx0ax0dx0a当你用EB来实现持久层的时候，你会发现EB实在是太笨拙了，笨拙到你根本没有什么可以选择的余地，所以你根本就不用花费精力去设计方案，去平衡方案的好坏，去费脑筋考虑选择哪个方案，因为只有唯一的方案摆在你面前，你只能这么做，没得选择。x0dx0ax0dx0aHibernate相反，它太灵活了，相同的问题，你至少可以设计出十几种方案来解决，所以特别的犯难，究竟用这个，还是用那个呢？这些方案之间到底有什么区别呢？他们的运行原理有什么不同？运行效率哪个比较好？光是主键生成，就有七八种方案供你选择，你为难不为难？集合属性可以用Set，可以用List，还可以用Bag，到底哪个效率高，你为难不为难？查询可以用iterator，可以用list，哪个好，有什么区别？你为难不为难？复合主键你可以直接在hbm里面配置，也可以自定义CustomerType，哪种比较好些？你为难不为难？对于一个表，你可以选择单一映射一个对象，也可以映射成父子对象，还可以映射成两个1:1的对象，在什么情况下用哪种方案比较好，你为难不为难？x0dx0ax0dx0a这个列表可以一直开列下去，直到你不想再看下去为止。当你面前摆着无数的眼花缭乱的方案的时候，你会觉得幸福呢？还是悲哀呢？如果你是一个负责的程序员，那么你一定会仔细研究每种方案的区别，每种方案的效率，每种方案的适用场合，你会觉得你已经陷入进去拔不出来了。如果是用EB，你第一秒种就已经做出了决定，根本没得选择，比如说集合属性，你只能用Collection，如果是Hibernate，你会在Bag，List和Set之间来回犹豫不决，甚至搞不清楚的话，程序都没有办法写。

hibernate : 解决了直接用JDBC操作数据库的烦琐操作。屏蔽了各种数据库的实现细节。现有ORM框架或ORM相关框架主要有Hibernate，Mybatis。这两个框架本来是为了解决直接用JDBC操作数据库带来的烦锁重复工作，但它们却引起了其它的问题。有人报怨Mybatis，很简单的操作，都要写sql语句；有人报怨当用户要用自定义sql的方式时Hibernate是如何的难用，要想熟悉Hibernate是如何的困难。从另一方面来说，Hibernate的流行，除了出现较早，《expert one-on-one J2EE Development without EJB》一书的推荐也功不可没，还有就是因为它操作单表时确实比直接用JDBC省事；而Mybatis的流行，也印证了贴近原生sql的方式很受欢迎(即使最近几年NOSQL产品很火爆)。但不管用这二者中的哪个，都让人有些缺失的遗憾，以致于有人想要同时使用这两个框架。除此之外，它们的编码复杂度为O(n)，也就是说每操作一个DB的表，就要写一次dao。-------------------1) 对于每个实体，需要写一个dao接口文件。编码复杂度C(n)=O(n)，即会随实体的增长，编码量呈线性增长。当n较大时，会增加许多人力物力消耗。2) 实体Javabean与DB表的map映射文件太多；或者，实体Javabean文件注解用得太泛滥，太多注解难以记忆，增加开发人员负担。Mybatis中实体对应的mapper文件，代码太多，虽然可以自动生成，但阅读性太差。编写和调试sql语句需要大量时间，降低开发效率。3) 实体操作默认的条件，一般以id作为条件，但开发时，一般不会提前知道id；若用其它条件作为查询等，需要在接口文件新定义方法。如一个实体有10个字段，2个字段组合一个查询方法，则有 =45个查询方法；若算上3个字段，4个字段的组合，则更多。4) 接口文件定义好后，若后期发现定义的方法不能满足需求，需要定义新的方法，又要修改接口文件；若是系统已经上线，还要需要重新开发、测试、发布等。5) 当一个表新增一个字段，删除一个字段，或修改一个字段时，Mybatis需要修改mapper映射文件，几乎其中的每个方法都要修改。修改字段，Mybatis在编译期不能自动发现错误。Hibernate通过xml文件或有注解的Javabean文件，同步DB的表结构时，也不能实现删除和更新。更新时，它是忽略原来的字段，然后新增一个字段，除非删除了表，重新再建一次。要是DB的表已保存了数据，不能删除，还是要手动去更改数据库。6) Hibernate想让ORM框架做完DB所有的事情，反而使框架变得太复杂，不易于使用。Hibernate的ORM模型不能查询一部分数据，即使用户没有使用到，也会将所有关联的数据都查询出来。7) Hibernate的概念太复杂，学习成本高，更新会先查询再更新，n+1问题。Mybatis即使进行单表的Suid操作也需要人工写sql或生成sql文件，需要维护的sql太多。8) 需要写很多的判断字段是否为空（null) ，是否是空字符串的语句；开发人员需要承担太多类似的重复，乏味的编程工作。--------------------- 来源：CSDN 原文：https://blog.csdn.net/abckingaa/article/details/84557336

hibernate怎么读为[ˈhaɪbəneɪt]，是冬眠的意思。相关内容如下：一、短语搭配：Hibernate Session传播；Hibernate EntityManager使用；Hibernate PC电脑休眠；ibernate voltage休眠电压；Hibernate Period过冬期；Hibernate Search激活；hibernate drugs冬眠药物；Oxios Hibernate内存整理软件；Hibernate Now休眠状态。二、双语例句：In the cold weather some of them hibernate.在寒冷的天气里，它们有的冬眠了。Some animals, including some bears, only half hibernate.有些动物，包括有些熊只是半冬眠。If emotions can hibernate, so we is it right? Not be injured.假如情绪可以冬眠，那么我们是不是不会在受伤。拓展知识：冬眠（又名‘冬蛰"）是一种状态，在这种状态中一种极端的但被调节的体温、代谢和其它生理活动的下降，作为对减少能量消耗的适应。冬眠的物种大致可分成两类即主动式冬眠动物和被动式冬眠动物，后者如仓鼠，外部因素，包括光周期，食物和外界温度对这种冬眠周期事件的定时起主要作用。冬眠（英语：Hibernation），也叫“冬蛰”。某些动物在冬季时生命活动处于极度降低的状态，是动物对冬季外界不良环境条件（如食物缺少、寒冷）的一种适应。蝙蝠、刺猬、极地松鼠等都有冬眠习惯。冬眠，是一些异温动物（一些冬眠哺乳类与鸟类）和变温动物在寒冷冬季时其体温可降低到接近环境温度（几乎到0℃），全身呈麻痹状态，在环境温度进一步降低或升高到一定程度，或其他刺激下，其体温可迅速恢复到正常水平。

hibernate 英["hau026abu0259neu026at]美[u02c8hau026abu025au02ccnet]vi. （某些动物）冬眠，蛰伏第三人称单数:hibernates;过去分词:hibernated;现在分词:hibernati...[例句]To cope , many species have learned to hibernate.为了应对严寒，很多物种学会了冬眠。

NoSuchFieldError，很明显啊，你的模型是不是没有这个字段在数据库中某个域，有可能是该域不get / set方法

你这是更新不是合并当然出错了啊

我收藏的一个文章，希望你先看看hibernate中object的各种状态，再看这个问题就知道原因了，不要只用不知其然。http://blog.csdn.net/sunhuwh/article/details/8871343你咋不看文章呢？new User(1,"zhangsan",new Role(1,"admin")这两个对象都是没有hibernate系统发生任何关系的游离对象，你直接往数据库merge，当然不行。试想一下，数据库有一个User， 1，“lisi”，你直接merge。岂不是数据库给搞错了，出现了不一致。hibernate显然不会让你这么鲁莽!

要看你什么时候需要用，merge（）的方法就是指新增的时候，没有就新增，有的话就更新

使用merge方法，如果数据库中有该记录，则更新该记录，如果不存在该记录，则进行insert操作。使用update的话，会无条件执行update，也就是说如果数据库中有该记录的话，merge和update是一样的，但是如果数据库中没有该记录，

就是先update 再sava

写个适配器器吧，传入数据库类型，输出拼接的sql。其实个人更建议你使用hibernate的Hql来作sql相关操作，首先它语法和通用Sql是近似的，不一样的地方在于 语句里写的是类名 不是表名，最后hibernate会根据Hql翻译成当前数据库可执行的sql来执行，这样你就不需要去判断究竟是什么数据库，写法支持不支持。当然，如果你的语句特复杂一定得用Sql server或者Oracle的特殊语法，那没办法，写个适配器吧以下是HQL相关资料HQL查询：Criteria查询对查询条件进行了面向对象封装，符合编程人员的思维方式，不过HQL(Hibernate Query Lanaguage)查询提供了更加丰富的和灵活的查询特性，因此Hibernate将HQL查询方式立为官方推荐的标准查询方式，HQL查询在涵盖Criteria查询的所有功能的前提下，提供了类似标准SQL语句的查询方式，同时也提供了更加面向对象的封装。完整的HQL语句形势如下：Select/update/delete…… from …… where …… group by …… having …… order by …… asc/desc其中的update/delete为Hibernate3中所新添加的功能，可见HQL查询非常类似于标准SQL查询。由于HQL查询在整个Hibernate实体操作体系中的核心地位，这一节我将专门围绕HQL操作的具体技术细节进行讲解。1、 实体查询：有关实体查询技术，其实我们在先前已经有多次涉及，比如下面的例子：String hql=”from User user ”;List list=session.CreateQuery(hql).list();上面的代码执行结果是，查询出User实体对象所对应的所有数据，而且将数据封装成User实体对象，并且放入List中返回。这里需要注意的是，Hibernate的实体查询存在着对继承关系的判定，比如我们前面讨论映射实体继承关系中的Employee实体对象，它有两个子类分别是HourlyEmployee，SalariedEmployee,如果有这样的HQL语句：“from Employee”,当执行检索时Hibernate会检索出所有Employee类型实体对象所对应的数据（包括它的子类HourlyEmployee，SalariedEmployee对应的数据）。因为HQL语句与标准SQL语句相似，所以我们也可以在HQL语句中使用where字句，并且可以在where字句中使用各种表达式，比较操作符以及使用“and”,”or”连接不同的查询条件的组合。看下面的一些简单的例子：from User user where user.age=20;from User user where user.age between 20 and 30;from User user where user.age in(20,30);from User user where user.name is null;from User user where user.name like ‘%zx%";from User user where (user.age%2)=1;from User user where user.age=20 and user.name like ‘%zx%";2、 实体的更新和删除： 在继续讲解HQL其他更为强大的查询功能前，我们先来讲解以下利用HQL进行实体更新和删除的技术。这项技术功能是Hibernate3的新加入的功能，在Hibernate2中是不具备的。比如在Hibernate2中，如果我们想将数据库中所有18岁的用户的年龄全部改为20岁，那么我们要首先将年龄在18岁的用户检索出来，然后将他们的年龄修改为20岁，最后调用Session.update()语句进行更新。在Hibernate3中对这个问题提供了更加灵活和更具效率的解决办法，如下面的代码：Transaction trans=session.beginTransaction();String hql=”update User user set user.age=20 where user.age=18”;Query queryupdate=session.createQuery(hql);int ret=queryupdate.executeUpdate();trans.commit();通过这种方式我们可以在Hibernate3中，一次性完成批量数据的更新，对性能的提高是相当的可观。同样也可以通过类似的方式来完成delete操作，如下面的代码：Transaction trans=session.beginTransaction();String hql=”delete from User user where user.age=18”;Query queryupdate=session.createQuery(hql);int ret=queryupdate.executeUpdate();trans.commit();如果你是逐个章节阅读的化，那么你一定会记起我在第二部分中有关批量数据操作的相关论述中，讨论过这种操作方式，这种操作方式在Hibernate3中称为bulkdelete/update，这种方式能够在很大程度上提高操作的灵活性和运行效率，但是采用这种方式极有可能引起缓存同步上的问题(请参考相关论述)。3、 属性查询： 很多时候我们在检索数据时，并不需要获得实体对象所对应的全部数据，而只需要检索实体对象的部分属性所对应的数据。这时候就可以利用HQL属性查询技术，如下面程序示例：List list=session.createQuery(“select user.name from User user ”).list();for(int i=0;i<list.size();i++){ System.out.println(list.get(i));}我们只检索了User实体的name属性对应的数据，此时返回的包含结果集的list中每个条目都是String类型的name属性对应的数据。我们也可以一次检索多个属性，如下面程序：List list=session.createQuery(“select user.name,user.age from User user ”).list();for(int i=0;i<list.size();i++){ Object[] obj=(Object[])list.get(i); System.out.println(obj[0]); System.out.println(obj[1]);}此时返回的结果集list中，所包含的每个条目都是一个Object[]类型，其中包含对应的属性数据值。作为当今我们这一代深受面向对象思想影响的开发人员，可能会觉得上面返回Object[]不够符合面向对象风格，这时我们可以利用HQL提供的动态构造实例的功能对这些平面数据进行封装，如下面的程序代码：List list=session.createQuery(“select new User(user.name,user.age) from User user ”).list();for(int i=0;i<list.size();i++){ User user=(User)list.get(i); System.out.println(user.getName()); System.out.println(user.getAge());}这里我们通过动态构造实例对象，对返回结果进行了封装，使我们的程序更加符合面向对象风格，但是这里有一个问题必须注意，那就是这时所返回的User对象，仅仅只是一个普通的Java对象而以，除了查询结果值之外，其它的属性值都为null（包括主键值id），也就是说不能通过Session对象对此对象执行持久化的更新操作。如下面的代码：List list=session.createQuery(“select new User(user.name,user.age) from User user ”).list();for(int i=0;i<list.size();i++){ User user=(User)list.get(i); user.setName(“gam”); session.saveOrUpdate(user);//这里将会实际执行一个save操作，而不会执行update操作，因为这个User对象的id属性为null，Hibernate会把它作为一个自由对象（请参考持久化对象状态部分的论述），因此会对它执行save操作。}4、 分组与排序A、Order by子句： 与SQL语句相似，HQL查询也可以通过order by子句对查询结果集进行排序，并且可以通过asc或者desc关键字指定排序方式，如下面的代码：from User user order by user.name asc,user.age desc;上面HQL查询语句，会以name属性进行升序排序，以age属性进行降序排序，而且与SQL语句一样，默认的排序方式为asc,即升序排序。B、Group by子句与统计查询：在HQL语句中同样支持使用group by子句分组查询，还支持group by子句结合聚集函数的分组统计查询，大部分标准的SQL聚集函数都可以在HQL语句中使用，比如：count(),sum(),max(),min(),avg()等。如下面的程序代码：String hql=”select count(user),user.age from User user group by user.age having count(user)>10 ”;List list=session.createQuery(hql).list();C、优化统计查询：假设我们现在有两张数据库表，分别是customer表和order表，它们的结构如下：customer ID varchar2(14) age number(10) name varchar2(20)order ID varchar2(14) order_number number(10) customer_ID varchar2(14)现在有两条HQL查询语句，分别如下：from Customer c inner join c.orders o group by c.age;(1)select c.ID,c.name,c.age,o.ID,o.order_number,o.customer_IDfrom Customer c inner join c.orders c group by c.age;(2)这两条语句使用了HQL语句的内连接查询（我们将在HQL语句的连接查询部分专门讨论），现在我们可以看出这两条查询语句最后所返回的结果是一样的，但是它们其实是有明显区别的，语句（1）检索的结果会返回Customer与Order持久化对象，而且它们会被置于Hibernate的Session缓存之中，并且Session会负责它们在缓存中的唯一性以及与后台数据库数据的同步，只有事务提交后它们才会从缓存中被清除；而语句（2）返回的是关系数据而并非是持久化对象，因此它们不会占用Hibernate的Session缓存，只要在检索之后应用程序不在访问它们，它们所占用的内存就有可能被JVM的垃圾回收器回收，而且Hibernate不会同步对它们的修改。在我们的系统开发中，尤其是Mis系统，不可避免的要进行统计查询的开发，这类功能有两个特点：第一数据量大；第二一般情况下都是只读操作而不会涉及到对统计数据进行修改，那么如果采用第一种查询方式，必然会导致大量持久化对象位于Hibernate的Session缓存中，而且Hibernate的Session缓存还要负责它们与数据库数据的同步。而如果采用第二种查询方式，显然就会提高查询性能，因为不需要Hibernate的Session缓存的管理开销，而且只要应用程序不在使用这些数据，它们所占用的内存空间就会被回收释放。因此在开发统计查询系统时，尽量使用通过select语句写出需要查询的属性的方式来返回关系数据，而避免使用第一种查询方式返回持久化对象（这种方式是在有修改需求时使用比较适合），这样可以提高运行效率并且减少内存消耗。㊣真正的高手并不是精通一切，而是精通在合适的场合使用合适的手段。5、 参数绑定：Hibernate中对动态查询参数绑定提供了丰富的支持，那么什么是查询参数动态绑定呢？其实如果我们熟悉传统JDBC编程的话，我们就不难理解查询参数动态绑定，如下代码传统JDBC的参数绑定：PrepareStatement pre=connection.prepare(“select * from User where user.name=?”);pre.setString(1,”zhaoxin”);ResultSet rs=pre.executeQuery();在Hibernate中也提供了类似这种的查询参数绑定功能，而且在Hibernate中对这个功能还提供了比传统JDBC操作丰富的多的特性，在Hibernate中共存在4种参数绑定的方式，下面我们将分别介绍：A、 按参数名称绑定： 在HQL语句中定义命名参数要用”:”开头，形式如下： Query query=session.createQuery(“from User user where user.name=:customername and user.customerage=:age ”); query.setString(“customername”,name); query.setInteger(“customerage”,age); 上面代码中用:customername和:customerage分别定义了命名参数customername和customerage，然后用Query接口的setXXX()方法设定名参数值，setXXX()方法包含两个参数，分别是命名参数名称和命名参数实际值。B、 按参数位置邦定： 在HQL查询语句中用”?”来定义参数位置，形式如下：Query query=session.createQuery(“from User user where user.name=? and user.age =? ”); query.setString(0,name); query.setInteger(1,age);同样使用setXXX()方法设定绑定参数，只不过这时setXXX()方法的第一个参数代表邦定参数在HQL语句中出现的位置编号（由0开始编号），第二个参数仍然代表参数实际值。注：在实际开发中，提倡使用按名称邦定命名参数，因为这不但可以提供非常好的程序可读性，而且也提高了程序的易维护性，因为当查询参数的位置发生改变时，按名称邦定名参数的方式中是不需要调整程序代码的。C、 setParameter()方法： 在Hibernate的HQL查询中可以通过setParameter()方法邦定任意类型的参数，如下代码： String hql=”from User user where user.name=:customername ”; Query query=session.createQuery(hql); query.setParameter(“customername”,name,Hibernate.STRING); 如上面代码所示，setParameter()方法包含三个参数，分别是命名参数名称，命名参数实际值，以及命名参数映射类型。对于某些参数类型setParameter()方法可以更具参数值的Java类型，猜测出对应的映射类型，因此这时不需要显示写出映射类型，像上面的例子，可以直接这样写：query.setParameter(“customername”,name);但是对于一些类型就必须写明映射类型，比如java.util.Date类型，因为它会对应Hibernate的多种映射类型，比如Hibernate.DATA或者Hibernate.TIMESTAMP。D、 setProperties()方法：在Hibernate中可以使用setProperties()方法，将命名参数与一个对象的属性值绑定在一起，如下程序代码：Customer customer=new Customer();customer.setName(“pansl”);customer.setAge(80);Query query=session.createQuery(“from Customer c where c.name=:name and c.age=:age ”);query.setProperties(customer);setProperties()方法会自动将customer对象实例的属性值匹配到命名参数上，但是要求命名参数名称必须要与实体对象相应的属性同名。这里还有一个特殊的setEntity()方法，它会把命名参数与一个持久化对象相关联，如下面代码所示：Customer customer=(Customer)session.load(Customer.class,”1”);Query query=session.createQuery(“from Order order where order.customer=:customer ”);query. setProperties(“customer”,customer);List list=query.list();上面的代码会生成类似如下的SQL语句：Select * from order where customer_ID="1";E、 使用绑定参数的优势： 我们为什么要使用绑定命名参数？任何一个事物的存在都是有其价值的，具体到绑定参数对于HQL查询来说，主要有以下两个主要优势：①、 可以利用数据库实施性能优化，因为对Hibernate来说在底层使用的是PrepareStatement来完成查询，因此对于语法相同参数不同的SQL语句，可以充分利用预编译SQL语句缓存，从而提升查询效率。②、 可以防止SQL Injection安全漏洞的产生：SQL Injection是一种专门针对SQL语句拼装的攻击方式，比如对于我们常见的用户登录，在登录界面上，用户输入用户名和口令，这时登录验证程序可能会生成如下的HQL语句：“from User user where user.name="”+name+”" and user.password="”+password+”" ”这个HQL语句从逻辑上来说是没有任何问题的，这个登录验证功能在一般情况下也是会正确完成的，但是如果在登录时在用户名中输入”zhaoxin or ‘x"="x”,这时如果使用简单的HQL语句的字符串拼装，就会生成如下的HQL语句：“from User user where user.name="zhaoxin" or ‘x"="x" and user.password="admin" ”;显然这条HQL语句的where字句将会永远为真，而使用户口令的作用失去意义，这就是SQL Injection攻击的基本原理。 而使用绑定参数方式，就可以妥善处理这问题,当使用绑定参数时，会得到下面的HQL语句：from User user where user.name=""zhaoxin"" or ‘"x=""x"" ‘ and user.password="admin";由此可见使用绑定参数会将用户名中输入的单引号解析成字符串（如果想在字符串中包含单引号，应使用重复单引号形式），所以参数绑定能够有效防止SQL Injection安全漏洞。

少了hibernate-commons-annotations.jar

hibernate validator是注解化囧言实体类字段格式的插件, 校验日期用正则表达式@Pattern,或者扩展注解@DateFormatCheckPattern

首先，在pom.xml中添加hibernate.validator的支持[html] view plaincopy<!-- hibernate.validator --> <dependency> <groupId>org.hibernate</groupId> <artifactId>hibernate-validator</artifactId> <version>4.3.1.Final</version> </dependency> 表单提交页面user_add.jsp[html] view plaincopy<%@ taglib uri="http://java.sun.com/jsp/jstl/core" prefix="c"%> <%@ taglib uri="http://www.springframework.org/tags/form" prefix="form"%> <%@ page language="java" contentType="text/html; charset=UTF-8" pageEncoding="UTF-8"%> <!DOCTYPE html PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN" "http://www.w3.org/TR/html4/loose.dtd"> <html> <head> <meta http-equiv="Content-Type" content="text/html; charset=UTF-8"> <title>add user</title> </head> <body> <form:form id="form" method="post" modelAttribute="validUserBean"> 添加用户 <form:label path="account">账号：</form:label> <form:input path="account" /> <form:errors path="account" /> <form:label path="password">密码：</form:label> <form:input path="password" /> <form:errors path="password" /> <button type="submit">添加</button> <button type="reset">重置</button> <c:out value="${show}"></c:out> </form:form> </body> </html>

native有天生的,本土的,也就是说生来就有的, 那也就是说自动生成,不需要人工来帮忙或者管控的. 而assigned是指指定的,分配的, 如果你不赋予他甚麼东西,那麼他是不能实现的. 需要人工,自己把某个东西赋予给它 所以是assigned 在用Hibernate的时候，当有表中的主键是库自动生成的时候将使用native。<generator class="native"></generator>而当是自己添加的时候则需要改为assigned。<generator class="assigned"></generator>否则将会出现异常！如果建表时,该表主键类型是integer,并设置成auto-increment,用native;该表主键类型是string类型的,用uuid.hex

native有天生的,本土的,也就是说生来就有的, 那也就是说自动生成,不需要人工来帮忙或者管控的. 而assigned是指指定的,分配的, 如果你不赋予他甚麼东西,那麼他是不能实现的. 需要人工,自己把某个东西赋予给它 所以是assigned 在用Hibernate的时候，当有表中的主键是库自动生成的时候将使用native。<generator class="native"></generator>而当是自己添加的时候则需要改为assigned。<generator class="assigned"></generator>否则将会出现异常！如果建表时,该表主键类型是integer,并设置成auto-increment,用native;该表主键类型是string类型的,用uuid.hex

junit的问题

你的限制了吗？

你为什么要判断query是否为空呢？你想要的不就是有没有在数据库查到对应的数据吗？那你为什么不直接判断all的大小呢，这样不是更直观嘛。

你没有使用spring的话 你要先创建事物 Session session = HibernateSessionFactory.getSession(); Transaction transaction = session.beginTransaction(); session.update(updatedMember);transaction.commit(); 在提交事物 不然话 hibernate 不会去改变数据库的 既然你使用的是spring 是不是在配置事物的时候出现了问题<!-- 配置事物管理 --> <bean id="transactionManager" class="org.springframework.orm.hibernate3.HibernateTransactionManager"> <property name="sessionFactory" ref="sessionFactory"></property> </bean> <!-- 配置实物传播特性 --> <tx:advice id="txadvice" transaction-manager="transactionManager"> <tx:attributes> <tx:method name="save*" propagation="REQUIRED"/> <tx:method name="add*" propagation="REQUIRED"/> <tx:method name="del*" propagation="REQUIRED"/> <tx:method name="update*" propagation="REQUIRED"/> <tx:method name="*" read-only="false"/> </tx:attributes> </tx:advice> <!-- 哪些类的那些方法参与 事物 --> <aop:config> <aop:pointcut id="allService" expression="execution(* com.tsinghua.service.*.*(..))"/> <aop:advisor pointcut-ref="allService" advice-ref="txadvice"/> </aop:config> 把你 <tx:method name="*" propagation="SUPPORTS" read-only="true" />这个read-only="true" 就是只读, 把它改为false 试试

finally{ session.close(); }

你的txAdvice没有配置正确哦，需要加上一句：rollback-for="Exception"，表示遇到异常就回滚

表的主键有问题吧，违反唯一性，一般都是表的问题，表里的主键id是唯一的，你是不是有重复的id值

注册DAO

按lz你的配置SaUserDAO userdao=(SaUserDAO)context.getBean("SaUserDAO")这句注入的是SaUserDAO而不是代理对象userDAOProxy

在SpringSide 3 中，白衣提供的预先配置好的环境非常有利于用户进行快速开发，但是同时也会为扩展带来一些困难。最直接的例子就是关于在项目中使用多个数据源的问题，似乎 很难搞。在上一篇中，我探讨了SpringSide 3 中的数据访问层，在这一篇中，我立志要解决多数据源配置的难题，我的思路是这样的：第一步、测试能否配置多个DataSource第二步、测试能否配置多个SessionFactory第三步、测试能否配置多个TransactionManager第四步、测试能否使用多个TransactionManager，也就是看能否配置多个基本上到第四步就应该走不通了，因为Spring中似乎不能配置多个，而且@transactional注解也无法让用户选择具体使用哪个TransactionManager。也就是说，在SpringSide的应用中，不能让不同的数据源分别属于不同的事务管理器，多数据源只能使用分布式事务管理器，那么测试思路继续如下进行：第五步、测试能否配置JTATransactionManager如果到这一步，项目还能顺利在Tomcat中运行的话，我们就算大功告成了。但我总认为事情不会那么顺利，我总觉得JTATransactionManager需要应用服务器的支持，而且需要和JNDI配合使用，具体是不是这样，那只有等测试后才知道。如果被我不幸言中，那么进行下一步：第六步、更换Tomcat为GlassFish，更换JDBC的DataSource为JNDI查找的DataSource，然后配置JTATransactionManager下面测试开始，先假设场景，还是继续用上一篇中提到的简单的文章发布系统，假设该系统运行一段时间后非常火爆，单靠一台服务器已经无法支持巨大的用户数， 这时候，站长想到了把数据进行水平划分，于是，需要建立一个索引数据库，该索引数据库需保存每一篇文章的Subject及其内容所在的Web服务器，而每 一个Web服务器上运行的项目，需要同时访问索引数据库和内容数据库。所以，需要创建索引数据库，如下：[java] view plain copy print?create database puretext_index; use puretext_index; create table articles( id int primary key auto_increment, subject varchar(256), webserver varchar(30) ); create database puretext_index;use puretext_index;create table articles(id int primary key auto_increment,subject varchar(256),webserver varchar(30));第一步测试，配置多个DataSource，配置文件如下：application.properties

今天我也遇到了nested exception is org.hibernate.exception.SQLGrammarException: Error accessing tables metadata，究其原因是数据库有问题，建议重新建立一个数据库database，然后对新的database进行操作。亲测有效。

映射关系配置不对 仔细看看

不需要了,如果在spring或者hibernate的配置文件里配置了,就不需要配置tomcat数据库连接池,并且在tomcat配置文件里配置连接池维护起来既麻烦性能又不好

1 连接到CDB和普通实例一样的连接。 指定ORACLE_SID 以后可以使用OS认证，也可以使用密码进行连接。[oracle@Ora12c /]$ echo $ORACLE_SIDcndba[oracle@Ora12c /]$ sqlplus / as sysdbaSQL*Plus: Release 12.1.0.1.0 Production onMon Apr 28 11:33:43 2014Copyright (c) 1982, 2013, Oracle. All rights reserved.Connected to:Oracle Database 12c Enterprise EditionRelease 12.1.0.1.0 - 64bit ProductionWith the Partitioning, OLAP, AdvancedAnalytics and Real Application Testing optionsSQL> conn system/oracleConnected.SQL>--查看CDB中可用的service：SQL> COLUMN name FORMAT A30SQL> SELECT name,pdb2 FROM v$services3 ORDER BY name;NAME PDB------------------------------------------------------------SYS$BACKGROUND CDB$ROOTSYS$USERS CDB$ROOTcndba CDB$ROOTcndbaXDB CDB$ROOTpcndba2 PCNDBA2pdbcndba PDBCNDBA6 rows selected.--通过lsnrctl 也可以判断：[oracle@Ora12c /]$ lsnrctl serviceLSNRCTL for Linux: Version 12.1.0.1.0 -Production on 28-APR-2014 11:35:31Copyright (c) 1991, 2013, Oracle. All rights reserved.Connecting to(DESCRIPTION=(ADDRESS=(PROTOCOL=IPC)(KEY=EXTPROC1521)))Services Summary...Service "cndba" has 1instance(s).Instance "cndba", status READY, has 1 handler(s) for thisservice...Handler(s):"DEDICATED" established:0 refused:0 state:readyLOCAL SERVERService "cndbaXDB" has 1instance(s).Instance "cndba", status READY, has 1 handler(s) for thisservice...Handler(s):"D000" established:0 refused:0 current:0 max:1022 state:readyDISPATCHER <machine: Ora12c, pid: 10085>(ADDRESS=(PROTOCOL=tcp)(HOST=Ora12c)(PORT=14696))Service "pcndba2" has 1instance(s).Instance "cndba", status READY, has 1 handler(s) for thisservice...Handler(s):"DEDICATED" established:0 refused:0 state:readyLOCAL SERVERService "pdbcndba" has 1instance(s).Instance "cndba", status READY, has 1 handler(s) for thisservice...Handler(s):"DEDICATED" established:0 refused:0 state:readyLOCAL SERVERThe command completed successfully[oracle@Ora12c /]$通过这些service，就可以远程连接CDB。--EZCONNECTC:UsersDave>sqlplussystem/oracle@192.168.1.10:1521/cndbaSQL*Plus: Release 11.2.0.1.0 Production on 星期三 4月 30 11:36:48 2014Copyright (c) 1982, 2010, Oracle. All rights reserved.连接到:Oracle Database 12c Enterprise EditionRelease 12.1.0.1.0 - 64bit ProductionWith the Partitioning, OLAP, AdvancedAnalytics and Real Application Testing optionsSQL>--通过TNSNAMES.ORA连接：在tnsnames.ora 中配置如下：cndba =(DESCRIPTION =(ADDRESS = (PROTOCOL = TCP)(HOST = 192.168.1.10)(PORT = 1521))(CONNECT_DATA =(SERVER = DEDICATED)(SERVICE_NAME = cndba)))--连接：C:UsersDave>sqlplussystem/oracle@cndbaSQL*Plus: Release 11.2.0.1.0 Production on 星期三 4月 30 11:40:01 2014Copyright (c) 1982, 2010, Oracle. All rights reserved.连接到:Oracle Database 12c Enterprise EditionRelease 12.1.0.1.0 - 64bit ProductionWith the Partitioning, OLAP, AdvancedAnalytics and Real Application Testing optionsSQL>2 在不同Container database中切换在12c的架构中，因为有CDB和 PDB的存在，所以会有很多不同的container，所以在连接到不同的container时，就需要进行切换。--查看当前的container：SQL> show con_nameCON_NAME------------------------------CDB$ROOTSQL> SELECT SYS_CONTEXT("USERENV","CON_NAME") FROM dual;SYS_CONTEXT("USERENV","CON_NAME")--------------------------------------------------------------------------------CDB$ROOTSQL> set lin 140SQL> select con_id, dbid,guid, name , open_mode from v$pdbs;CON_ID DBID GUID NAME OPEN_MODE---------- ------------------------------------------ ---------- ----------2 4088301206 F7C1E3C96BBF0585E0430A01A8C05459 PDB$SEED READ ONLY3 426143573F7C209EB1DFC0854E0430A01A8C0B787 PDBCNDBA READ WRITE4 1231796139 F812DE1B6A8F363AE0430A01A8C0C759 PCNDBA2 READ WRITE--切换container：SQL> alter session setcontainer=pcndba2;Session altered.SQL> show con_nameCON_NAME------------------------------PCNDBA23 连接到PDB--EZCONNECT:C:UsersDave>sqlplussystem/oracle@192.168.1.10:1521/pcndba2SQL*Plus: Release 11.2.0.1.0 Production on 星期三 4月 30 11:54:30 2014Copyright (c) 1982, 2010, Oracle. All rights reserved.连接到:Oracle Database 12c Enterprise EditionRelease 12.1.0.1.0 - 64bit ProductionWith the Partitioning, OLAP, AdvancedAnalytics and Real Application Testing optionsSQL>--TNSNAMES.ora在tnsnames.ora 中添加如下内容：pcndba =(DESCRIPTION =(ADDRESS = (PROTOCOL = TCP)(HOST = 192.168.1.10)(PORT = 1521))(CONNECT_DATA =(SERVER = DEDICATED)(SERVICE_NAME = pcndba2)))C:UsersDave>sqlplussystem/oracle@pcndbaSQL*Plus: Release 11.2.0.1.0 Production on 星期三 4月 30 11:55:50 2014Copyright (c) 1982, 2010, Oracle. All rights reserved.连接到:Oracle Database 12c Enterprise EditionRelease 12.1.0.1.0 - 64bit ProductionWith the Partitioning, OLAP, AdvancedAnalytics and Real Application Testing optionsSQL>

如果使用assign，必须给对象的id赋值，如果等于0，那么id等于mysql数据库维护的最大id+1，大于0时，id才是你设置特定id值。所以使用assign同时想使用特定id 就不要使用0来赋值了。

直接使用如Criteriacrit=session.createCriteria(User.class);//TwoCriteriaConditionCriterioncr1=Restrictions.eq("empName","Gyan3");Criterioncr2=Restrictions.gt("empId",newInteger(5));//OrCriteriaConditioncrit.add(Restrictions.or(cr1,cr2));

createQuery(querySql);querySql中好像不能使用*

hibernate对应的是类名

/** * 获取主键名称 * @return */ public String getPkname() { Field[] fields = this.entityClass.getDeclaredField(); for (Field field : fields) { field.isAnnotationPresent(Id.class); this.pkname=field.getName(); break; } return pkname; }

<property name="connection.url">jdbc:oracle:thin:@192.168.1.108:1521:orcl</property>

类和数据的映射

没明白你问的啥，做个小程序倒过去不就行了

　　year(), month(), concat() 是 mysql 特有的函数，其他数据库也有对应的函数，而 hibernate 存在的意义就是屏蔽这些数据库特有的东西，这样的话：　　如果数据库的 datetime/date 之类的字段并没有和 Java 的 Date 或 Calender 属性进行映射的话，无论你使用 HQL 还是Criteria 都无法实现对日期的操作，因为 HQL 和 Criteria 都是基于对象的查询方式。　　基于对象的查询，如下，先做映射　　@Entity　　@Table(name="PREFERRED_CUSTOMER")　　public PCustomer {　　@Column(name = "EXPIRATION_DATE")　　@Temporal(TemporalType.DATE)　　protected java.util.Date expirationDate; // only day, month, year　　}　　可以使用 HQL 这么查询：　　List<PCustomer> list = session　　.createQuery("from PCustomer pc where pc.expirationDate = :edate")　　.setParameter("edate", new java.util.Date(), TemporalType.DATE)　　.list();　　hibernate 屏蔽了数据库特有的东西，是为了方便移植，但有的老项目较多地使用了数据库特有的东西，如MSSQL 的 T-SQL，这时，就需要使用 hibernate 对 SQL 的原生支持，Session 提供了 createSQLQuery() 这样的方法，此时的 hibernate 就相当于一个简单的 mapper，只提供对象关系映射，当然，一旦你在代码中使用了对 SQL 的原生支持，移植性就不好了。　　此种方式可以使用你所说的 MySQL 函数

不写select返回的就可以转成bean。select了具体属性就只能转成数组了。你说不写select不能转成bean,我觉得你应该把hql和bean类也发出来让我们看看

一般来说。为了方便。比较简单的查询可以用query。在查询条件比较多的时候，可以用criteria

需要先转换格式你直接用会出现所以你最好转一下格式再来用

criteria.add(Restrictions.eq("code", emp.getCode()));重复了

第一个:Criteria criteria = hibernateTemplate.getSessionFactory().getCurrentSession().createCriteria(Dept.class);criteria.add(Restrictions.like("name", "%aa%"));第二个：Criteria criteria = hibernateTemplate.getSessionFactory().getCurrentSession().createCriteria(Dept.class);Criteria senduser = criteria.createCriteria("a");//这个小a是Dept中关联A.class的属性名criteria.add(Restrictions.like("name", "%AA%"));最后返回return criteria.list();

可以的，我也这样用的，没有遇见什么问题啊。只是当你输入的查询时间是2009-12-11到2009-12-11的日期（即当天）要注意一下，endDate可能要改为2009-12-11 23:59:59 ，否则查不出来

到了Hibernate3.0以后,关联关系的对象默认都是使用延迟加载,例如<one-to-many>时.但我在映射<one-to-one>,<many-to-one>关系时指定了lazy="true",但是在查询对象时,我只想查询一个对象,仍然会把这个对象所关联的<one-to-one>,<many-to-one>对象一起查询出来,这样造成了极大的性能浪费.在不指定lazy属性时,<many-to-one>所关联的对象反而会延迟加载,这让我大为困惑,还以为是Hibernate的bug. 在网上查找资料,说在为了延迟加载<one-to-one>,<many-to-one>所关联的对象,需要设置被关联的对象<class name="" lazy="true">,我也这样做了,但是仍然没有效果. 仔细阅读了Hibernate的手册,才发现原来要延迟加载<one-to-one>,<many-to-one>所关联的对象时,除了要指定lazy="true"外,还需要运行期字节码增强,而我省去了这一步,所以延迟加载没有效果.同时还发现在默认情况下,<one-to-one>,<many-to-one>的lazy属性是"proxy"而不是"true"!因此如果直接采用lazy的默认值,是可以延迟加载的. 总结一下: <many-to-one>默认的属性是lazy="proxy",此时默认是会延迟加载的.在指定了lazy="true"之后,必须要经过运行期字节码增加,延迟加载才有效果. 而<one-to-one>相对要复杂一点,延迟加载还要受到constrained属性的限制.constrained="false"时表明实体和被关联到的实体的约束不是强制的,即存在一个实体时,它通过<one-to-one>关联的实体可能存在,也可能不存在,这时在查询实体时,Hibernate总会发起一次查询检查<one-to-one>所关联的实体是否存在,而这时已经可以把one-to-one关联的实体查询出来了,因此在<one-to-one>关系中,如果constrained="false",总是会立即加载关联到的实体. 如果当constrained="true",且lazy="proxy"(默认),是可以延迟加载的. 如果当constrained="true",且lazy="true"时,需要经过运行期字节码增加,延迟加载才会奏效.使用hibernate后，观念应该转变过来， 一个对象应该是完整， 所以没法返回一个只包含某几个属性（字段) 的对象。 例如，一个人，就不能只返回一个头， 还是手什么的 如果数据量过大， 当然还是有这个必要. 也可以做到， 但是返回的不会是对象，而是字段数组. hibernate 管这叫投影 Criteria criteria=session.createCriteria(User.class); ProjectionList proList = Projections.projectionList();//设置投影集合 proList.add(Projections.groupProperty("userName")); proList.add(Projections.groupProperty("password")); criteria.setProjection(proList); 最后返回的List是 Object[] , [0] = userName, [1] = password 如果你真的只用来查 userName,password, 那就小题大做了 我想直接取出view(String userName,String password)的形式， 即hql:select new view(userName,password) from .... 两种方法 1 属性的延迟载入 在hbm.xml的属性上加 lazy=true 2 轻量设计 单独设计一个类, 只包含 userName 和password我的意思就是设计了一个类用来存放username和password，但是Criteria能返回这个bean类型的一个List吗？再写一个xml啊, 没人规定一张表只能映射一次 轻量的employee映射

使用Projections吧具体用法参见以下文章：http://blog.163.com/meihua_can/blog/static/185435292201173114248876/

这句话错了Student stu=(Student)list.get(0); 改成Integer max = (Integer) list.get(0);问题解决