hibernate是干什么用的

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

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

　　① 制定合理的缓存策略（二级缓存、查询缓存）。　　② 采用合理的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一共包括了 个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

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

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

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

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的缺点就是框架还是比较简陋，功能尚有缺失，虽然简化了数据绑定代码，但是整个底层数据库查询实际还是要自己写的，工作量也比较大，而且不太容易适应快速数据库修改。

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 版权声明：本文为博主原创文章，转载请附上博文链接！

最大的区别在于：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，上面的理由我想已经足够清楚了。

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

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

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

　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" →这句不写 在存身份证表的时候公民表不会更新/>

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

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。不需要考虑怎么建表

持久层

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

是想查询什么呢？

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

　　Hibernate的事件监听机制　　Hibernate中的事件监听机制可以对Session对象的动作进行监听，一旦发生了特殊的事件，Hibernate就会执行监听器中的事件处理方法　　在某些功能的设计中，我们即可以使用Hibernate的拦截器实现，也可以使用Hibernate的事件监听来实现　　Hibernate中事件与对应的监听器接口　　org.hibernate.event. EventListeners　　事件类型 监听器接口　　auto-flush---- -------------AutoFlushEventListener　　merge----------------------MergeEventListener　　create----------------------PersistEventListener　　delete----------------------DeleteEventListener　　dirty-check----------------DirtyCheckEventListener　　evict------------------------EvictEventListener　　flush------------------------FlushEventListener　　flush-entity----------------FlushEntityEventListener　　load-------------------------LoadEventListener　　load-collection-------------InitializeCollectionEventListener　　lock--------------------------LockEventListener　　refresh----------------------RefreshEventListener　　replicate--------------------ReplicateEventListener　　save-update---------------SaveOrUpdateEventListener　　save------------------------SaveOrUpdateEventListener　　update---------------------SaveOrUpdateEventListener　　pre-load-------------------PreLoadEventListener　　pre-update---------------PreUpdateEventListener　　pre-delete----------------PreDeleteEventListener　　pre-insert-----------------PreInsertEventListener　　post-load-----------------PostLoadEventListener　　post-update--------------PostUpdateEventListener　　post-delete---------------PostDeleteEventListener　　post-insert----------------PostInsertEventListener　　post-commit-update-----PostUpdateEventListener　　post-commit-delete------PostDeleteEventListener　　post-commit-insert-------PostInsertEventListener　　应用Hibernate事件监听器　　用户制定的事件监听器首先需要实现与所需要处理的事件对应的接口，或者继承实现这个接口的类　　通过使用Hibernate的配置文件(hibernate.cfg.xml)配置事件监听对象,或者使用Configuration对象注册这个定制的事件监听器对象　　LogPostLoadEventListener　　import org.hibernate.event.PostLoadEvent;　　import org.hibernate.event.PostLoadEventListener;　　public class LogPostLoadEventListener implements PostLoadEventListener {　　private static final long serialVersionUID = 404241098418965422L;　　public void onPostLoad(PostLoadEvent event) {　　System.out.println("Class:" + event.getEntity().getClass().getName() + ",id:"　　+ event.getId());　　}　　}　　修改Hibernate.cfg.xml文件　　<mapping resource="com/rbh/examples/Guestbook.hbm.xml" />　　<listener type="post-load" class="com.rbh.examples.LogPostLoadEventListener" />　　</session-factory>　　</hibernate-configuration>　　或者通过Configuration 对象注册这个监听器对象　　Configuration config = new Configuration();　　config.setListener("post-load", new LogPostLoadEventListener());　　config.configure();　　Session session = config.buildSessionFactory().getCurrentSession();　　编写、配置好监听器以后，当通过Session对象的load()、get()方法或者Query对象的list方法加载持久化对象之后，LogPostEventListener对象中的onPostLoad()方法就会被执行.　　使用监听器实现审计日志　　利用Hibernate的事件机制，不仅能够精确追踪到持久化对象的字段的修改，持久化对象关联关系的变更，还能记录更新前的数值和更新后的数值　　拦截器(Interceptor)　　org.hibernate.Interceptor接口定义了Hibernate中通用拦截机制　　创建Session对象的时候，所有的Session对象或者这个Session对象的所有持久化操作的动作都会被指定的拦截器进行拦截.　　Interceptor接口的方法　　afterTransactionBegin()　　当一个事务时候启动时，会立刻调用这个方法，这个方法可以改变这个事务的状态，例如：回滚事务　　instantiate()　　创建对象，如果返回null,则Hibernate将调用实体类的默认构造方法创建持久化对象　　getEntity()　　当一个持久化对象，通过标示符属性在Session对象的缓存中进行查找，并且没有找到时，会调用该方法　　getEntityName()　　当session对象获取持久化对象的名字时，会调用这个方法　　onLoad()　　该方法在持久化对象初始化之前加载，这个的持久化对象处于刚被创建的状态(对象的属性值都未赋值)　　findDirty()　　当调用Session对象的flush()方法时，讲调用该方法判断对象是否为脏数据，这是脏数据检查的另外拦截的实现方式　　isTransient()　　当调用Session对象的saveOrUpdate方法时，会调用该方法判断对象是否尚未保存　　onSave()　　在对象被保存之前调用，通过这个方法可以对要保持的对象的属性进行修改　　onDelete()　　该方法在持久化对象被删除之前调用　　preFlush()　　该方法当调用Session对象的flush()方法之前被调用　　onFlushDirty()　　当调用Session对象flush()方法进行脏数据检查时，如果发现持久化对象的状态发生了改变，会调用该方法　　postFlush()　　该方法调用Session对象的flush()方法之后被调用　　beforeTransactionCompletion()　　在完成一个事务之前，调用此方法，这个方法可以改变事务的状态，例如回滚事务　　afterTransactionCompletion()　　当完成一个事务之后，立刻调用此方法

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）

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

　　一 批量修改和删除 　　在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

　　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

说说我们的选择吧原因有： 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慢，而且难优化，而且使用不好有问题，这就是他最大的垃圾地方，楼主可以想一想，hibernate提出的什么面向对象操作数据库，这本身就是一个谎言，oracle，db2这些主流数据库本省就是关系数据库，为什么非要用面向对象思维去考虑他，弄不好就容易让人思维错乱。不是谁没有那个思维，也不是谁不懂那个东西，二是学会hibernate，要想学好，跟另学一门语言的难度没什么区别，他只是一个工具，这么难，有意义吗？我以前没用过其他的orm框架，也觉着hibernate好，但是当你用过好的简单的、容易上手的框架，如ibatis，你就会发现hibernate就是绕弯子走路，脱裤子放屁，真没啥用~~

hibernate 英["hau026abu0259neu026at]美[u02c8hau026abu025au02ccnet]vi. （某些动物）冬眠，蛰伏第三人称单数:hibernates;过去分词:hibernated;现在分词:hibernati...[例句]To cope , many species have learned to 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 [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 进行了轻量级的对象封装，使 Java 程序员可以随心所欲的使用对象编程思维来操纵数据库。它不仅提供了从 Java 类到数据表之间的映射，也提供了数据查询和恢复机制。相对于使用 JDBC 和 SQL 来手工操作数据库，Hibernate 可以大大减少操作数据库的工作量。 另外 Hibernate 可以利用代理模式来简化载入类的过程，这将大大减少利用 Hibernate QL 从数据库提取数据的代码的编写量，从而节约开发时间和开发成本 Hibernate 可以和多种Web 服务器或者应用服务器良好集成，如今已经支持几乎所有的流行的数据库服务器。

呵呵，是啊，一楼的回答最可爱:-)

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

1、jdbc的缺点1、代码太繁琐了2、不是面向对象的数据库操作3、资源关闭的代码也很繁琐，每次都得打开、关闭4、没有做到数据缓存5、移植性比较差优点：因为是最低层的操作，所以效率比较高2、hibernate1、代码比较精简了2、是面向对象的数据库操作3、只需要关闭一个对象就可以了session4、数据缓存 一级缓存 二级缓存 查询缓存5、移植性比较好缺点：1、程序员不能控制sql语句的生成hibernate中有一个hql2、如果一个项目对sql语句的优化要求特别高，不适合用hibernate3、如果一张表的数据量特别大，不适合用hibernate

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）

hibernate的特点 : 解决了直接用JDBC操作数据库的烦琐操作。屏蔽了各种数据库的实现细节。Hibernate和Mybatis它们的编码复杂度为O(n)，也就是说每操作一个DB的表，就要写一次dao。1) 编码复杂度C(n)=O(n)，即会随实体的增长，编码量呈线性增长。当n较大时，会增加许多工作量。2) 需要写很多的判断字段是否为空（null) ，是否是空字符串的语句；工作重复，乏味。3）实体Javabean与DB表的map映射文件太多；或者，实体Javabean文件注解用得太泛滥，太多注解难以记忆，增加开发人员负担。4) Hibernate的概念太复杂，学习成本高，更新会先查询再更新，n+1问题。一个十分钟即可学会的ORM框架--Bee , 编码复杂度是O(1). 编码复杂度是O(1)，就是说ORM框架只写一次就行了，没必要写n次。(想想数据结构中时间复杂度，空间复杂度从O(n)提升到O(1)对性能的影响有多大）。

Hibernate中Session是数据库的一个连接,一个session就是一个连接，相当于jdbc。connection。平时的session是用户的会话，记录用户的信息

LZ还是用JPA的注释吧，比XML方便多了。

hql & criteria

Gavin对于做事情的执着始于十一岁时，他最早的软件开发成果毁于极其糟糕、不稳定的Commodore 64磁带驱动。Gavin King曾在Monash大学攻读数学，2003年9月，Gavin King加入了JBoss，全面领导hibernate的开发，并给客户提供最好的服务和培训。目前，Gavin King在红帽公司负责JBoss Hibernate 和基于CMP 引擎的新Hibernate项目的开发。

Hibernate是一个开放源代码的对象关系映射框架，它对JDBC进行了非常轻量级的对象封装，它将POJO与数据库表建立映射关系，是一个全自动的orm框架，hibernate可以自动生成SQL语句，自动执行，使得Java程序员可以随心所欲的使用对象编程思维来操纵数据库。Hibernate可以应用在任何使用JDBC的场合，既可以在Java的客户端程序使用，也可以在Servlet/JSP的Web应用中使用，最具革命意义的是，Hibernate可以在应用EJB的J2EE架构中取代CMP，完成数据持久化的重任。Session:在计算机中，尤其是在网络应用中，称为"会话控制"。Session 对象存储特定用户会话所需的属性及配置信息。这样，当用户在应用程序的 Web 页之间跳转时，存储在 Session 对象中的变量将不会丢失，而是在整个用户会话中一直存在下去。当用户请求来自应用程序的 Web 页时，如果该用户还没有会话，则 Web 服务器将自动创建一个 Session 对象。当会话过期或被放弃后，服务器将终止该会话。Session 对象最常见的一个用法就是存储用户的首选项。例如，如果用户指明不喜欢查看图形，就可以将该信息存储在 Session 对象中。有关使用 Session 对象的详细信息，请参阅"ASP 应用程序"部分的"管理会话"。注意 会话状态仅在支持 cookie 的浏览器中保留。HIBERNATE是 自然水公司SESSION 是从自然水公司到你家里的管道。要用水，你必须先造一个管道。如果延迟加载的话，记得把水龙头开着。

hibernate相当于封住了一次jdbc,使hibernate不用考虑你是用的什么数据库，他的HQL语句都可以根据你不同数据库的方言编译成相对应的数据库sql语句，这是hibernate的一大优势，但是因为他的HQL语句都要经过编译才能成对应数据库可以执行的语句，所以用它做持久层他比ibatis稍慢。

spring和hibernate有什么区别？分别都是干什么的？ hibernate 是一个数据持久层的框架,只管 怎么去访问及操作数据库的数据. spring 是一个更加强大的框架,是为J2EE 应用程序开发提供集成的框架,体现在其简单性、可测试性和松耦合上,同时对面向切面编程也有支撑的. 再简单打个比方, hibernate 是 仓库的仓储管理人员,负责货物的仓储管理. spring 就是 管理层的核心领导,负责协调调度,以保障企业的良好运作. 以下机构分别都是干什么的？有什么区别？ 不同部门的纪律检查委员会是负责处理违犯党的纪律的情况下，以调查和处理党的领导干部和监督在公安机关负责调查违反纪律警方人员，该检察院国家法律监督，主要是负责国家工作有关的犯罪，及时发现和处理与犯罪审查逮捕和审查起诉职责，廉政公署（ICAC）调查违反的法律和纪律的官员， *** 机构的各级负责接受的请愿信访局，并协调处理的投诉。 ado 和 odbc有什么区别，分别是干什么的？ 界面在VC里面做，需要建立exe工程，使用ado或者odbc建立都行，这两者是连接数据库的两种不同方法，ODBC(Open Database Connectivity，开放数据库互连)是微软公司开放服务结构(WOSA，Windows Open Services Architecture)中有关数据库的一个组成部分，它建立了一组规范，并提供了一组对数据库访问的标准API（应用程序编程接口）。这些API利用SQL来完成其大部分任务。ODBC本身也提供了对SQL语言的支持，用户可以直接将SQL语句送给ODBC。 ADO (ActiveX Data Objects) 是一个用于存取数据源的COM组件。它提供了编程语言和统一数据访问方式OLE DB的一个中间层。允许开发人员编写访问数据的代码而不用关心数据库是如何实现的，而只用关心到数据库的连接。访问数据库的时候，关于SQL的知识不是必要的，但是特定数据库支持的SQL命令仍可以通过ADO中的命令对象来执行。 各自连接数据库和执行sql的方式有点不同，但都可以实现操作数据库。 cobol中batch和online有什么区别?都是干什么的? batch:指的是非人工操作，由计算机自动执行cobol编译好的可执行文件，类似于计划任务：到了 特定时间自动执行。执行时间一般在夜间。周期有，日次，周次，月次之分。 online：指的是人工操作。一般是操作由带有画面的程序，直接操作画面上的各个控件。进而操作数据库等等。 java web start和tomcat有什么区别？分别是干什么的？ java web start 是种技术,和tomcat没有什么关系,你可以百度下 tomcat是web容器,和asp中的iis一样 bank中的clerk和cashier分别是干什么的?有什么区别? clerk银行职员，普通员工 cashier收款员（商场等） 口袋怪兽龙牙和龙鳞有什么区别都是干什么的 龙牙不是能加龙系攻击，而是提升龙系招式威力10%，你去流星瀑布，有一个龙系训练师，不断变换场景，多与他打几次，他就会出宝宝龙，他的宝宝龙身上100%有龙牙，小偷即可。另，不嫌麻烦的话，在四大天王山洞入口处池塘，用高杆钓鱼，能钓到哈克龙，5%几率携带龙牙。野生的宝宝龙只有龙鳞啊。 龙鳞原是海刺龙进化道具，386里用水之石代替了，所以没用，卖了吧。

以前没怎么用过mybatis，只知道与hibernate一样是个orm数据库框架。随着使用熟练度的增加，发现它与hibernate区别是非常大的，结合至今为止的经验，总结出以下几点：1. hibernate是全自动，而mybatis是半自动。hibernate完全可以通过对象关系模型实现对数据库的操作，拥有完整的JavaBean对象与数据库的映射结构来自动生成sql。而mybatis仅有基本的字段映射，对象数据以及对象实际关系仍然需要通过手写sql来实现和管理。2. hibernate数据库移植性远大于mybatis。hibernate通过它强大的映射结构和hql语言，大大降低了对象与数据库（oracle、mysql等）的耦合性，而mybatis由于需要手写sql，因此与数据库的耦合性直接取决于程序员写sql的方法，如果sql不具通用性而用了很多某数据库特性的sql语句的话，移植性也会随之降低很多，成本很高。3. hibernate拥有完整的日志系统，mybatis则欠缺一些。hibernate日志系统非常健全，涉及广泛，包括：sql记录、关系异常、优化警告、缓存提示、脏数据警告等；而mybatis则除了基本记录功能外，功能薄弱很多。4. mybatis相比hibernate需要关心很多细节hibernate配置要比mybatis复杂的多，学习成本也比mybatis高。但也正因为mybatis使用简单，才导致它要比hibernate关心很多技术细节。mybatis由于不用考虑很多细节，开发模式上与传统jdbc区别很小，因此很容易上手并开发项目，但忽略细节会导致项目前期bug较多，因而开发出相对稳定的软件很慢，而开发出软件却很快。hibernate则正好与之相反。但是如果使用hibernate很熟练的话，实际上开发效率丝毫不差于甚至超越mybatis。5. sql直接优化上，mybatis要比hibernate方便很多由于mybatis的sql都是写在xml里，因此优化sql比hibernate方便很多。而hibernate的sql很多都是自动生成的，无法直接维护sql；虽有hql，但功能还是不及sql强大，见到报表等变态需求时，hql也歇菜，也就是说hql是有局限的；hibernate虽然也支持原生sql，但开发模式上却与orm不同，需要转换思维，因此使用上不是非常方便。总之写sql的灵活度上hibernate不及mybatis。总结：mybatis：小巧、方便、高效、简单、直接、半自动hibernate：强大、方便、高效、复杂、绕弯子、全自动mybatis：1. 入门简单，即学即用，提供了数据库查询的自动对象绑定功能，而且延续了很好的SQL使用经验，对于没有那么高的对象模型要求的项目来说，相当完美。2. 可以进行更为细致的SQL优化，可以减少查询字段。3. 缺点就是框架还是比较简陋，功能尚有缺失，虽然简化了数据绑定代码，但是整个底层数据库查询实际还是要自己写的，工作量也比较大，而且不太容易适应快速数据库修改。4. 二级缓存机制不佳。hibernate：1. 功能强大，数据库无关性好，O/R映射能力强，如果你对Hibernate相当精通，而且对Hibernate进行了适当的封装，那么你的项目整个持久层代码会相当简单，需要写的代码很少，开发速度很快，非常爽。2. 有更好的二级缓存机制，可以使用第三方缓存。3. 缺点就是学习门槛不低，要精通门槛更高，而且怎么设计O/R映射，在性能和对象模型之间如何权衡取得平衡，以及怎样用好Hibernate方面需要你的经验和能力都很强才行。举个形象的比喻：mybatis：机械工具，使用方便，拿来就用，但工作还是要自己来作，不过工具是活的，怎么使由我决定。ufeffufeffhibernate：智能机器人，但研发它（学习、熟练度）的成本很高，工作都可以摆脱他了，但仅限于它能做的事。ufeffufeff