什么是hibernate
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是什么？
Hibernate是一个开放源代码的对象关系映射框架，它对JDBC进行了非常轻量级的对象封装，使得Java程序员可以随心所欲的使用对象编程思维来操纵数据库。 Hibernate可以应用在任何使用JDBC的场合，既可以在Java的客户端程序使用，也可以在Servlet/JSP的Web应用中使用，最具革命意义的是，Hibernate可以在应用EJB的J2EE架构中取代CMP，完成数据持久化的重任。
Hibernate的核心类和接口一共有6个，分别为:Session、SessionFactory、
Transaction、Query、Criteria和Configuration。这6个核心类和接口在任何开发中都会用到。通过这些接口，不仅可以对持久化对象进行存取，还能够进行事务控制。
Session：
Session接口负责执行被持久化对象的CRUD操作(CRUD的任务是完成与数据库的交流，包含了很多常见的SQL语句)。但需要注意的是Session对象是非线程安全的。同时，Hibernate的session不同于JSP应用中的HttpSession。这里当使用session这个术语时，其实指的是Hibernate中的session，而以后会将HttpSession对象称为用户session。
SessionFactory：
SessionFactory接口负责初始化Hibernate。它充当数据存储源的代理，并负责创建Session对象。这里用到了工厂模式。需要注意的是SessionFactory并不是轻量级的，因为一般情况下，一个项目通常只需要一个SessionFactory就够，当需要操作多个数据库时，可以为每个数据库指定一个SessionFactory。
Transaction：
Transaction 接口是一个可选的API，可以选择不使用这个接口，取而代之的是Hibernate 的设计者自己写的底层事务处理代码。 Transaction 接口是对实际事务实现的一个抽象，这些实现包括JDBC的事务、JTA 中的UserTransaction、甚至可以是CORBA 事务。之所以这样设计是能让开发者能够使用一个统一事务的操作界面，使得自己的项目可以在不同的环境和容器之间方便地移植。
Query：
Query接口让使用者方便地对数据库及持久对象进行查询，它可以有两种表达方式：HQL语言或本地数据库的SQL语句。Query经常被用来绑定查询参数、限制查询记录数量，并最终执行查询操作。
Criteria：
Criteria接口与Query接口非常类似，允许创建并执行面向对象的标准化查询。值得注意的是Criteria接口也是轻量级的，它不能在Session之外使用。
Configuration：
Configuration 类的作用是对Hibernate 进行配置，以及对它进行启动。在Hibernate 的启动过程中，Configuration 类的实例首先定位映射文档的位置，读取这些配置，然后创建一个SessionFactory对象。虽然Configuration 类在整个Hibernate 项目中只扮演着一个很小的角色，但它是启动hibernate 时所遇到的第一个对象。
使用hibernate的11大优势
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
浅谈Hibernate框架简述
在基于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缓存何时使用和如何使用
关于hibernate缓存的问题 基本的缓存原理 Hibernate缓存分为二级 第一级存放于session中称为一级缓存 默认带有且不能卸载 第二级是由sessionFactory控制的进程级缓存 是全局共享的缓存 凡是会调用二级缓存的查询方法 都会从中受益 只有经正确的配置后二级缓存才会发挥作用 同时在进行条件查询时必须使用相应的方法才能从缓存中获取数据 比如erate()方法 load get方法等 必须注意的是session find方法永远是从数据库中获取数据 不会从二级缓存中获取数据 即便其中有其所需要的数据也是如此 查询时使用缓存的实现过程为 首先查询一级缓存中是否具有需要的数据 如果没有 查询二级缓存 如果二级缓存中也没有 此时再执行查询数据库的工作 要注意的是 此 种方式的查询速度是依次降低的 存在的问题 一级缓存的问题以及使用二级缓存的原因 因为Session的生命期往往很短 存在于Session内部的第一级最快缓存的生命期当然也很短 所以第一级缓存的命中率是很低的 其对系统性能的改善也是很有限的 当然 这个Session内部缓存的主要作用是保持Session内部数据状态同步 并非是hibernate为了大幅提高系统性能所提供的 为了提高使用hibernate的性能 除了常规的一些需要注意的方法比如 使用延迟加载 迫切外连接 查询过滤等以外 还需要配置hibernate的二级缓存 其对系统整体性能的改善往往具有立竿见影的效果！ （经过自己以前作项目的经验 一般会有 ~ 倍的性能提高） N+ 次查询的问题 什么时候会遇到 +N的问题？ 前提 Hibernate默认表与表的关联方法是fetch= select 不是fetch= join 这都是为了懒加载而准备的 ）一对多() 在 的这方 通过 条sql查找得到了 个对象 由于关联的存在 那么又需要将这个对象关联的集合取出 所以合集数量是n还要发出n条sql 于是本来的 条sql查询变成了 +n条 ）多对一 在多的这方 通过 条sql查询得到了n个对象 由于关联的存在 也会将这n个对象对应的 方的对象取出 于是本来的 条sql查询变成了 +n条 ）iterator 查询时 一定先去缓存中找（ 条sql查集合 只查出ID） 在没命中时 会再按ID到库中逐一查找 产生 +n条SQL 怎么解决 +N 问题？ ）lazy=true hibernate 开始已经默认是lazy=true了 lazy=true时不会立刻查询关联对象 只有当需要关联对象（访问其属性 非id字段）时才会发生查询动作 ）使用二级缓存 二级缓存的应用将不怕 +N 问题 因为即使第一次查询很慢（未命中） 以后查询直接缓存命中也是很快的 刚好又利用了 +N ) 当然你也可以设定fetch= join 一次关联表全查出来 但失去了懒加载的特性 执行条件查询时 iterate（）方法具有著名的 n+ 次查询的问题 也就是说在第一次查询时iterate方法会执行满足条件的查询结果数再加一次（n+ ）的查询 但是此问题只存在于第一次查询时 在后面执行相同查询时性能会得到极大的改善 此方法适合于查询数据量较大的业务数据 但是注意 当数据量特别大时（比如流水线数据等）需要针对此持久化对象配置其具体的缓存策略 比如设置其存在于缓存中的最大记录数 缓存存在的时间等参数 以避免系统将大量的数据同时装载入内存中引起内存资源的迅速耗尽 反而降低系统的性能！！！ 使用hibernate二级缓存的其他注意事项 关于数据的有效性 另外 hibernate会自行维护二级缓存中的数据 以保证缓存中的数据和数据库中的真实数据的一致性！无论何时 当你调用save() update()或 saveOrUpdate()方法传递一个对象时 或使用load() get() list() iterate() 或scroll()方法获得一个对象时 该对象都将被加入到Session的内部缓存中 当随后flush()方法被调用时 对象的状态会和数据库取得同步 也就是说删除 更新 增加数据的时候 同时更新缓存 当然这也包括二级缓存！ 只要是调用hibernate API执行数据库相关的工作 hibernate都会为你自动保证 缓存数据的有效性！！ 但是 如果你使用了JDBC绕过hibernate直接执行对数据库的操作 此时 Hibernate不会/也不可能自行感知到数据库被进行的变化改动 也就不能再保证缓存中数据的有效性！！ 这也是所有的ORM产品共同具有的问题 幸运的是 Hibernate为我们暴露了Cache的清除方法 这给我们提供了一个手动保证数据有效性的机会！！ 一级缓存 二级缓存都有相应的清除方法 其中二级缓存提供的清除方法为 按对象class清空缓存 按对象class和对象的主键id清空缓存 清空对象的集合中的缓存数据等 适合使用的情况 并非所有的情况都适合于使用二级缓存 需要根据具体情况来决定 同时可以针对某一个持久化对象配置其具体的缓存策略 适合于使用二级缓存的情况 数据不会被第三方修改 一般情况下 会被hibernate以外修改的数据最好不要配置二级缓存 以免引起不一致的数据 但是如果此数据因为性能的原因需要被缓存 同时又有可能被第 方比如SQL修改 也可以为其配置二级缓存 只是此时需要在sql执行修改后手动调用cache的清除方法 以保证数据的一致性 数据大小在可接收范围之内 如果数据表数据量特别巨大 此时不适合于二级缓存 原因是缓存的数据量过大可能会引起内存资源紧张 反而降低性能 如果数据表数据量特别巨大 但是经常使用的往往只是较新的那部分数据 此时 也可为其配置二级缓存 但是必须单独配置其持久化类的缓存策略 比如最大缓存数 缓存过期时间等 将这些参数降低至一个合理的范围（太高会引起内存资源紧张 太低了缓存的意义不大） 数据更新频率低 对于数据更新频率过高的数据 频繁同步缓存中数据的代价可能和 查询缓存中的数据从中获得的好处相当 坏处益处相抵消 此时缓存的意义也不大 非关键数据（不是财务数据等） 财务数据等是非常重要的数据 绝对不允许出现或使用无效的数据 所以此时为了安全起见最好不要使用二级缓存 因为此时 正确性 的重要性远远大于 高性能 的重要性 目前系统中使用hibernate缓存的建议 目前情况 一般系统中有三种情况会绕开hibernate执行数据库操作 多个应用系统同时访问一个数据库 此种情况使用hibernate二级缓存会不可避免的造成数据不一致的问题 此时要进行详细的设计 比如在设计上避免对同一数据表的同时的写入操作 使用数据库各种级别的锁定机制等 动态表相关 所谓 动态表 是指在系统运行时根据用户的操作系统自动建立的数据表 比如 自定义表单 等属于用户自定义扩展开发性质的功能模块 因为此时数据表是运行时建立的 所以不能进行hibernate的映射 因此对它的操作只能是绕开hibernate的直接数据库JDBC操作 如果此时动态表中的数据没有设计缓存 就不存在数据不一致的问题 如果此时自行设计了缓存机制 则调用自己的缓存同步方法即可 使用sql对hibernate持久化对象表进行批量删除时 此时执行批量删除后 缓存中会存在已被删除的数据 分析 当执行了第 条（sql批量删除）后 后续的查询只可能是以下三种方式 a session find（）方法 根据前面的总结 find方法不会查询二级缓存的数据 而是直接查询数据库 所以不存在数据有效性的问题 b 调用iterate方法执行条件查询时 根据iterate查询方法的执行方式 其每次都会到数据库中查询满足条件的id值 然后再根据此id 到缓存中获取数据 当缓存中没有此id的数据才会执行数据库查询 如果此记录已被sql直接删除 则iterate在执行id查询时不会将此id查询出来 所以 即便缓存中有此条记录也不会被客户获得 也就不存在不一致的情况 （此情况经过测试验证） c 用get或load方法按id执行查询 客观上此时会查询得到已过期的数据 但是又因为系统中执行sql批量删除一般是针对中间关联数据表 对于中间关联表的查询一般都是采用条件查询 按id来查询某一条关联关系的几率很低 所以此问题也不存在! 如果某个值对象确实需要按id查询一条关联关系 同时又因为数据量大使用 了sql执行批量删除 当满足此两个条件时 为了保证按id 的查询得到正确的结果 可以使用手动清楚二级缓存中此对象的数据的方法!!(此种情况出现的可能性较小) 建 议 建议不要使用sql直接执行数据持久化对象的数据的更新 但是可以执行 批量删除 （系统中需要批量更新的地方也较少） 如果必须使用sql执行数据的更新 必须清空此对象的缓存数据 调用 SessionFactory evict(class) SessionFactory evict(class id)等方法 在批量删除数据量不大的时候可以直接采用hibernate的批量删除 这样就不存在绕开hibernate执行sql产生的缓存数据一致性的问题 不推荐采用hibernate的批量删除方法来删除大批量的记录数据 原因是hibernate的批量删除会执行 条查询语句外加 满足条件的n条删除语句 而不是一次执行一条条件删除语句！！当待删除的数据很多时会有很大的性能瓶颈！！！如果批量删除数据量较大 比如超过 条 可以采用JDBC直接删除 这样作的好处是只执行一条sql删除语句 性能会有很大的改善 同时 缓存数据同步的问题 可以采用 hibernate清除二级缓存中的相关数据的方法 调 用 SessionFactory evict(class) ; SessionFactory evict(class id)等方法 所以说 对于一般的应用系统开发而言（不涉及到集群 分布式数据同步问题等） 因为只在中间关联表执行批量删除时调用了sql执行 同时中间关联表一般是执行条件查询不太可能执行按id查询 所以 此时可以直接执行sql删除 甚至不需要调用缓存的清除方法 这样做不会导致以后配置了二级缓存引起数据有效性的问题 退一步说 即使以后真的调用了按id查询中间表对象的方法 也可以通过调用清除缓存的方法来解决 具体的配置方法 根据我了解的很多hibernate的使用者在调用其相应方法时都迷信的相信 hibernate会自行为我们处理性能的问题 或者 hibernate 会自动为我们的所有操作调用缓存 实际的情况是hibernate虽然为我们提供了很好的缓存机制和扩展缓存框架的支持 但是必须经过正确的调用其才有可能发挥作用！！所以造成很多使用hibernate的系统的性能问题 实际上并不是hibernate不行或者不好 而是因为使用者没有正确的了解其使用方法造成的 相反 如果配置得当hibernate的性能表现会让你有相当 惊喜的 发现 下面我讲解具体的配置方法 ibernate提供了二级缓存的接口 net sf hibernate cache Provider 同时提供了一个默认的 实现net sf hibernate cache HashtableCacheProvider 也可以配置 其他的实现 比如ehcache jbosscache等 具体的配置位置位于hibernate cfg xml文件中 true net sf hibernate cache HashtableCacheProvider 很多的hibernate使用者在 配置到 这一步 就以为 完事了 注意 其实光这样配 根本就没有使用hibernate的二级缓存 同时因为他们在使用hibernate时大多时候是马上关闭session 所以 一级缓存也没有起到任何作用 结果就是没有使用任何缓存 所有的hibernate操作都是直接操作的数据库！！性能可以想见 正确的办法是除了以上的配置外还应该配置每一个vo对象的具体缓存策略 在影射文件中配置 例如 关键就是这个 其有几个选择read only read write transactional 等 然后在执行查询时 注意了 如果是条件查询 或者返回所有结果的查询 此时session find()方法 不会获取缓存中的数据 只有调用erate()方法时才会调缓存的数据 同时 get 和 load方法 是都会查询缓存中的数据 对于不同的缓存框架具体的配置方法会有不同 但是大体是以上的配置（另外 对于支持事务型 以及支持集群的环境的配置我会争取在后续的文章中中 发表出来） lishixinzhi/Article/program/Java/ky/201311/28715
Hibernate中一级缓存的作用有哪些?
Hibernate的一级缓存其实就是Session内置的一个Map，用来缓存它操作过的实体对象，对象的主关键字ID是Map的key，实体对\x0d\x0a象就是对应的值。所以，一级缓存是以实体对象为单位进行存储的，访问时也是以实体为单位的(直接访问属性是不能使用缓存的)，并且要求使用主关键字ID来\x0d\x0a进行访问。\x0d\x0a 一级缓存是由Session提供的，所以它只存在于Session的生命周期中，当程序调用\x0d\x0asave(),update(),saveorupdate()等方法以及调用查询接口list,filter,iterate时，如果session缓\x0d\x0a存中还不存在相应的对象，Hibernate会把该对象加入到一级缓存中，当Session关闭的时候该Session所管理的一级缓存也会立即被清除。\x0d\x0a当程序调用get()，load()，iterate(查询实体对象才支持一级缓存，查询普通属性则不支持一级缓存)时，Hibernate会先到缓存中\x0d\x0a去拿，如果缓存中已经存在目标对象，则直接拿来而不再查询数据库，否则，必须发出查询语句到数据库中查。\x0d\x0a 如果数据量特别大，我们一般考虑采用jdbc实现，因为它不用把大批量的数据事先加载到内存中，然后再进行更新与修改。所以不会消耗大量内存。如果jdbc也不能满足要求可以考虑采用数据本身的特定导入工具等其它办法。
为什么很多人不愿意用hibernate了
1、首先说一点，对于大部分人来讲框架上的选择就看周围人用的多不多，而周围人对于一个框架的选择，很重要的一点是看这个框架是否是上手快。
2、MyBatis和Hibernate相比各有各的优势，一个初学框架的程序员，宁愿会选一个简单易上手的框架开始选择，MyBatis就是很好的选择，Hibernate框架是一个集成度很高的框架，假如你在用hibernate，基本上业务层后端大部分的核心都是在用hibernate做的实现，spring框架的jpa实现实际上也是建立在hibernate对于jpa的实现的基础上的再封装，对于一个大型工程，hibernate的去SQL化也是可以提高你的开发效率的，当然，我承认hibernate的门槛确实对于初学框架的程序员，但我确信hibernate是java程序员值得去深入了解的一个开源框架。
3、我个人而言，还是比较喜欢hibernate框架的，毕竟对于SQL语句封装的够彻底（写SQL老是拼写出错- -），而且具有良好的二次封装的基因，加上spring boot（cloud）良好集成，有什么理由不用呢？
HIbernate 的工作原理是什么？
关于hibernte的工作原理，简单说一下个人浅见:
1.配置好hibernate的配置文件和与类对应的配置文件后，启动服务器
2.服务器通过实例化Configeration对象，读取hibernate.cfg.xml文件的配置内容，并根据相关的需求建好表或者和表建立好映射关系
3.通过实例化的Configeration对象就可以建立sessionFactory实例，进一步，通过sessionFactory实例可以创建session对象
4.得到session之后，便可以对数据库进行增删改查操作了，除了比较复杂的全文搜索外，简单的操作都可以通过hibernate封装好的session内置方法来实现
5.此外，还可以通过事物管理，表的关联来实现较为复杂的数据库设计
优点：hibernate相当于java类和数据库表之间沟通的桥梁，通过这座桥我们就可以做很多事情了
hibernate工作原理及为什么要用
Hibernate是一种ORM框架，主要作用是简化应用的数据持久层编程，不需要程序员编写大量SQL和JDBC说代码，也可以说成是对象持久化技术。所谓持久化对象（Persistent Object）即封装了数据库表记录的对象。程序中使用的对象是短暂的状态，当不使用时java的GC机制会自动释放不用的对象。而利用hibernate便可以实现对象的持久化，将对象保存到数据库中。
Hibernate映射文件（XML Mapping）：持久化对象（PO）与数据库表记录之间的映射关系
Hibernate配置文件（hibernate.properties）：配置相关的数据库访问信息，如数据库驱动类、连接串、访问数据库用户名和密码等
JAVA Hibernate工作原理及为什么要用
hibernate 简介：
hibernate是一个开源框架，它是对象关联关系映射的框架，它对JDBC做了轻量级的封装，而我们java程序员可以使用面向对象的思想来操纵数据库。
hibernate核心接口
session：负责被持久化对象CRUD操作
sessionFactory:负责初始化hibernate，创建session对象
configuration:负责配置并启动hibernate，创建SessionFactory
Transaction:负责事物相关的操作
Query和Criteria接口：负责执行各种数据库查询
hibernate工作原理：
1.通过Configuration config = new Configuration().configure();//读取并解析hibernate.cfg.xml配置文件
2.由hibernate.cfg.xml中的读取并解析映射信息
3.通过SessionFactory sf = config.buildSessionFactory();//创建SessionFactory
4.Session session = sf.openSession();//打开Sesssion
5.Transaction tx = session.beginTransaction();//创建并启动事务Transation
6.persistent operate操作数据，持久化操作
7.tx.commit();//提交事务
8.关闭Session
9.关闭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 comptosition
Hql：
1、 属性查询
2、 参数查询、命名参数查询
3、 关联查询
4、 分页查询
5、 统计函数
如何优化Hibernate？
1.使用双向一对多关联，不使用单向一对多
2.灵活使用单向一对多关联
3.不用一对一，用多对一取代
4.配置对象缓存，不使用集合缓存
5.一对多集合使用Bag,多对多集合使用Set
6. 继承类使用显式多态
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中的关系分为数据库表的关系和hibernate中对象的关系两个，缺一不可！
当你在创建对象的时候，如果你要保存这两个对象之间的关系，就要在对象中保存另外一个对象的引用。
如：
public class Person{
private String name;
private Address add;
}
public class Address{
private String street;
private String xiaoqu;
}
人对象中保存了地址这个对象的引用，就说明这两个对象存在关系。具体关系分好多种：
一对一、一对多、多对多关系
从方向上又可分：单向关联和双向关联。
上个例子就是单向一对一关联
数据库中你也要有相应的关系结构，这样配置了hibernate的级联关系属性后，hibernate就可以帮助你维护这种关系了。
具体的你可以看看孙卫琴的书。关于hibernate的！
当然hibernate的配置文件中也要配置！
多对多关系，就是两个对像相互保存对方引用。数据库表中有对方表的主键做外键。
请简述Hibernate工作原理？
Hibernate工作原理是Configuration读取Hibernate的配置文件和映射文件中的信息，即加载配置文件和映射文件，并通过Hibernate配置文件生成一个多线程的SessionFactory对象。然后，多线程SessionFactory对象生成一个线程Session 对象；Session对象生成Query对象或者Transaction对象；可通过Session对象的get()，load()，save()，update()，delete()和saveOrUpdate( )等方法对PO进行加载、保存、更新、删除等操作。在查询的情况下，可通过Session 对象生成一个Query对象，然后利用Query对象执行查询操作；如果没有异常，Transaction对象将提交这些操作结果到数据库中。扩展资料：Hibernate它对JDBC进行了非常轻量级的对象封装，它将POJO与数据库表建立映射关系，是一个全自动的orm框架，hibernate可以自动生成SQL语句，自动执行，使得Java程序员可以随心所欲的使用对象编程思维来操纵数据库。 Hibernate可以应用在任何使用JDBC的场合，既可以在Java的客户端程序使用，也可以在Servlet/JSP的Web应用中使用，最具革命意义的是，Hibernate可以在应用EJB的JaveEE架构中取代CMP，完成数据持久化的重任。
