Hibernate完成对象模型和基于SQL的关系模型的映射关系
 Hibernate较iBATIS更具有面向对象的特征
 Java EE 5抛弃了传统的Entity EJB, 改用JPA作为持久层解决方案
 JPA实体可以当作Hibernate PO使用
 低侵入 不要求PO继承Hibernate的某个超类或实现Hibernate的某个接口
 Hibernate使得Java EE应用的OOA OOD OOP三个过程一脉相承 成为一个整体
 编程语言和底层数据库发展不协调催生出了ORM框架（对象／关系数据库映射 一种规范）
 JPA规范未提供ORM实现 开发者面向JPA编程 应用程序底层可以在不同的ORM框架之间切换
 随着面向对象数据库的广泛发展 ORM工具会自动消亡
 面向对象程序设计优势（面向对象建模、操作 多态、继承 摈弃难以理解的过程 简单易用）
 关系数据库的优势（大量数据查找、排序 集合数据连接操作、映射 并发、事务 约束、隔离）
 操作持久化对象 （面向对象的操作转化为底层的SQL操作）
流行的ORM框架 
JPA（官方标准 jBPM未来都将会采用JPA作为持久层解决方案）
Hibernate（属于JBoss、Red Hat 优秀的性能 丰富的文档）
iBATIS SQL Mapping框架 允许直接编写SQL语句
TopLink Oracle公司产品
数据为中心的程序 使用存储过程实现商业逻辑 Hibernate不是好方案
中间件应用 采用面向对象的业务模型和商业逻辑 Hibernate是最有用的
类到表的映射（包括java数据类型到SQL数据类型的映射）
Hibernate优势 开源免费 轻量级 可扩展性 API开放 开发者活跃
Hibernate官网下载 zip包解压后 
documentation/ 参考文档和API文档 
lib/ 所依赖的第三方类库 required/子目录必须的第三方类库
project/ 源代码
hibernate3.jar 核心JAR包
hibernate3.jar lib/required lib/jpa子目录下所有jar 需要添加到类加载路径
如果是控制台编译 需要添加到环境变量CLASSPATH 否则可以使用Ant工具或者IDE工具管理
底层JDBC和MySQL的驱动也需要添加到类加载路径

Hibernate框架的概述
什么是框架？
框架指的是软件的半成品，已经完成了部分功能。
JavaEE开发的三层架构
了解框架的基本概念之后，我们就来看看Hibernate框架处于JavaEE开发的经典三层架构中的什么位置。



温馨提示：虽然Servlet+JSP+JavaBean+JDBC使用这套架构可以开发市面的所有应用（拥有它，你就能打天下），但是在企业中并不会使用（过于底层），这还有个屌用啊！企业中开发一般使用SSH（Struts2+Spring+Hibernate）和SSM（SpringMVC+Spring+MyBatis）。
Hibernate概述
什么是Hibernate？
我们可以从度娘上看到这样有关Hibernate的介绍：



从中，我们可以得出这样的结论：Hibernate是一个轻量级的JDBC封装，也就是说，我们可以使用Hibernate来完成原来我们使用JDBC完成的操作，也就是与数据库的交互操作。它是在Dao层去使用的。总而言之，Hibernate就是一个持久层的ORM框架。
什么是ORM？
使用传统的JDBC开发应用系统时，如果是小型应用系统，并不觉得有什么麻烦，但是对于大型应用系统的开发，使用JDBC就会显得力不从心。例如对几十、几百张包含几十个字段的表进行插入操作时，编写的SQL语句不但很长，而且繁琐，容易出错；在读取数据时，需要写多条getXxx语句从结果集中取出各个字段的信息，不但枯燥重复，并且工作量非常大。为了提高数据访问层的编程效率，Gavin King开发出了一个当今最流行的的ORM框架，它就是Hibernate框架。

所谓的ORM就是利用描述对象和数据库表之间映射的元数据，自动把Java应用程序中的对象，持久化到关系型数据库的表中。通过操作Java对象，就可以完成对数据库表的操作。可以把ORM理解为关系型数据和对象的一个纽带，开发人员只需要关注纽带一端映射的对象即可。ORM原理如下图所示。



说那么多，无非就是想说说ORM是个什么东西，对象关系映射（英语：Object Relation Mapping，简称ORM，或O/RM，或O/R mapping），指的是将一个Java中的对象与关系型数据库中的表建立一种映射关系，从而操作对象就可以操作数据库中的表。就这么简单，说那么多干嘛！
为什么要学习Hibernate框架？
与其它操作数据库的技术相比，Hibernate具有以下几点优势：

Hibernate对JDBC访问数据库的代码做了轻量级封装，大大简化了数据访问层繁琐的重复性代码，并且减少了内存消耗，加快了运行效率；
Hibernate是一个基于JDBC的主流持久化框架，是一个优秀的ORM实现，它很大程度的简化了DAO（Data Access Object，数据访问对象）层编码工作；
Hibernate的性能非常好，映射的灵活性很出色。它支持很多关系型数据库，从一对一到多对多的各种复杂关系；
可扩展性强，由于源代码的开源以及API的开放，当本身功能不够用时，可以自行编码进行扩展。

总结：Hibernate是企业级开发中的主流框架，映射的灵活性很出色，并且它支持很多关系型数据库。
Hiberate框架学习目标
由于之前学过Hiberate框架，所以这就等于是在复习了。对于Hiberate框架的学习重点，可以总结为：

掌握Hiberate的基本配置——即搭建Hiberate开发环境；
掌握Hiberate常用API——即如何使用Hiberate框架进行开发；
掌握Hiberate的关联映射——解决表与表之间存在的关系问题，有1:n(一对多)、 1:1(一对一)、m:n(多对多)关系；
掌握Hiberate的检索方式——即掌握Hiberate的查询；
掌握Hiberate的优化方式——即提高Hiberate的效率。

Hibernate快速入门
介绍完Hibernate框架之后，我们来快速入门Hibernate，对其有一个直观的了解。
下载Hibernate5
大家可去官网下载Hibernate，我下载的是



所以，之后有关Hibernate的系列文章都是以这个版本为蓝图展开的。下载解压缩之后，可以看到如下目录结构：


其中，在lib/required目录下，包含运行Hibernate项目所必须的jar包：


创建一个普通的Java项目，导入Hibernate框架相关依赖jar包
创建一个普通的Java项目，例如hibernate_demo01，然后导入Hibernate框架相关依赖jar包。


首先导入Hibernate开发必须的jar包，即lib/required目录下所有的jar包：




再导入MySQL数据库的驱动jar包：




最后导入日志记录相关的jar包：



导入完日志相关的jar包之后，我们还要导入日志记录文件，日志记录文件咱也是第一次接触，不知道咋写啊？没关系，找到project/etc/log4j.properties文件，很明显，它就是日志记录文件，将它拷贝复制到我们项目的src目录下，打开它，这里面的内容有点多啊！而且我们现在也不知道是什么意思，咋办？先跟着我将其内容精简为下面这样，后面我再来为大家做一点解释。
### direct log messages to stdout ###
log4j.appender.stdout=org.apache.log4j.ConsoleAppender
log4j.appender.stdout.Target=System.err
log4j.appender.stdout.layout=org.apache.log4j.PatternLayout
log4j.appender.stdout.layout.ConversionPattern=%d{ABSOLUTE} %5p %c{1}:%L - %m%n

### direct messages to file mylog.log ###
log4j.appender.file=org.apache.log4j.FileAppender
log4j.appender.file.File=c\:mylog.log
log4j.appender.file.layout=org.apache.log4j.PatternLayout
log4j.appender.file.layout.ConversionPattern=%d{ABSOLUTE} %5p %c{1}:%L - %m%n

### set log levels - for more verbose logging change 'info' to 'debug' ###
# error warn info debug trace
log4j.rootLogger= info, stdout



这样工程的整个结构就变成：


创建数据库与表
正如前面所说，Hibernate是一个轻量级的JDBC封装，也就是说，我们可以使用Hibernate来完成原来我们使用JDBC完成的操作，也就是与数据库的交互操作。所以我们首先要创建数据库与表，这里我使用的数据库是MySQL。
create database hibernate_demo01;
use hibernate_demo01;
CREATE TABLE `cst_customer` (
	`cust_id` bigint(32) NOT NULL AUTO_INCREMENT COMMENT '客户编号(主键)',
	`cust_name` varchar(32) NOT NULL COMMENT '客户名称(公司名称)',
	`cust_source` varchar(32) DEFAULT NULL COMMENT '客户信息来源',
	`cust_industry` varchar(32) DEFAULT NULL COMMENT '客户所属行业',
	`cust_level` varchar(32) DEFAULT NULL COMMENT '客户级别',
	`cust_phone` varchar(64) DEFAULT NULL COMMENT '固定电话',
	`cust_mobile` varchar(16) DEFAULT NULL COMMENT '移动电话',
	PRIMARY KEY (`cust_id`)
) ENGINE=InnoDB AUTO_INCREMENT=1 DEFAULT CHARSET=utf8;

创建实体类
我们在com.meimeixia.hibernate.demo01包中创建一个实体类——Customer.java，如下：
package com.meimeixia.hibernate.demo01;

public class Customer {

	private Long cust_id;
	private String cust_name;
	private String cust_source;
	private String cust_industry;
	private String cust_level;
	private String cust_phone;
	private String cust_mobile;
	
	public Long getCust_id() {
		return cust_id;
	}
	public void setCust_id(Long cust_id) {
		this.cust_id = cust_id;
	}
	public String getCust_name() {
		return cust_name;
	}
	public void setCust_name(String cust_name) {
		this.cust_name = cust_name;
	}
	public String getCust_source() {
		return cust_source;
	}
	public void setCust_source(String cust_source) {
		this.cust_source = cust_source;
	}
	public String getCust_industry() {
		return cust_industry;
	}
	public void setCust_industry(String cust_industry) {
		this.cust_industry = cust_industry;
	}
	public String getCust_level() {
		return cust_level;
	}
	public void setCust_level(String cust_level) {
		this.cust_level = cust_level;
	}
	public String getCust_phone() {
		return cust_phone;
	}
	public void setCust_phone(String cust_phone) {
		this.cust_phone = cust_phone;
	}
	public String getCust_mobile() {
		return cust_mobile;
	}
	public void setCust_mobile(String cust_mobile) {
		this.cust_mobile = cust_mobile;
	}
	@Override
	public String toString() {
		return "Customer [cust_id=" + cust_id + ", cust_name=" + cust_name + ", cust_source=" + cust_source
				+ ", cust_industry=" + cust_industry + ", cust_level=" + cust_level + ", cust_phone=" + cust_phone
				+ ", cust_mobile=" + cust_mobile + "]";
	}
	
}

创建Hibernate的相关配置文件
准备好以上工作之后，我们终于要踏入Hibernate的学习中了。首先我们要编写Hibernate的相关配置文件，Hibernate的相关配置文件分为两种：

Xxx.hbm.xml：它主要是用于描述类与数据库中的表的映射关系；
hibernate.cfg.xml：它是Hibernate框架的核心配置文件。

有关这两个配置文件的详细介绍，我后面会给大家讲解，如果就在这里弄的话，违背了我的初衷了，本文只是在教初学者怎样快速入门Hibernate。
创建映射配置文件
首先我们要学会如何编写映射配置文件，大家要知道编写完的映射配置文件应与实体类在同一个包下，并且名称应是类名.hbm.xml，所以我们要在com.meimeixia.hibernate.demo01包下创建一个Customer.hbm.xml文件，但是它的约束应该怎么写呢？可以在Hibernate的核心jar包——hibernate-core-5.0.7.Final.jar的org.hibernate包下查找到hibernate-mapping-3.0.dtd文件，打开该文件，找到如下内容：



然后复制黏贴到Customer.hbm.xml文件中即可。这里我先给出Customer.hbm.xml文件的内容，但内容不做过多介绍：
<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE hibernate-mapping PUBLIC 
    "-//Hibernate/Hibernate Mapping DTD 3.0//EN"
    "http://www.hibernate.org/dtd/hibernate-mapping-3.0.dtd">
    
<hibernate-mapping>
	<!-- 建立类与表的映射 -->
	<class name="com.meimeixia.hibernate.demo01.Customer" table="cst_customer">
		<!-- 建立类中的属性与表中的主键相对应 -->
		<id name="cust_id" column="cust_id">
			<!-- 主键的生成策略，后面会讲，现在使用的是本地生成策略 -->
			<generator class="native" />
		</id>
		
		<!-- 建立类中的普通属性和表中的字段相对应 -->
		<property name="cust_name" column="cust_name" />
		<property name="cust_source" column="cust_source" />
		<property name="cust_industry" column="cust_industry" />
		<property name="cust_level" column="cust_level" />
		<property name="cust_phone" column="cust_phone" />
		<property name="cust_mobile" column="cust_mobile" />
	</class>
</hibernate-mapping>

创建核心配置文件
核心配置文件主要是Hibernate框架所使用的，它主要包含了连接数据库的相关信息和Hibernate的相关配置等。现在我们要学会如何编写Hibernate的核心配置文件，大家也要知道编写完的核心配置文件应在src目录下，并且名称应是hibernate.cfg.xml，所以我们要在src目录下创建一个hibernate.cfg.xml文件，但是它的约束又应该怎么写呢？同样可以在Hibernate的核心jar包——hibernate-core-5.0.7.Final.jar的org.hibernate包下查找到hibernate-configuration-3.0.dtd文件，打开该文件，找到如下内容：



然后复制黏贴到hibernate.cfg.xml文件中即可。在这个文件中到底该如何配置呢？我们可以参考hibernate-release-5.0.7.Final\project\etc\hibernate.properties文件。这里我先给出hibernate.cfg.xml文件的内容，但内容不做过多介绍：
<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE hibernate-configuration PUBLIC
	"-//Hibernate/Hibernate Configuration DTD 3.0//EN"
	"http://www.hibernate.org/dtd/hibernate-configuration-3.0.dtd">
	
<hibernate-configuration>
	<session-factory>
		<!-- 下面是三个必须要有的配置 -->
		<!-- 配置连接MySQL数据库的基本参数 -->
		<property name="hibernate.connection.driver_class">com.mysql.jdbc.Driver</property>
		<property name="hibernate.connection.url">jdbc:mysql:///hibernate_demo01</property>
		<property name="hibernate.connection.username">root</property>
		<property name="hibernate.connection.password">liayun</property>
		
		<!-- 配置Hibernate的方言 -->
		<property name="hibernate.dialect">org.hibernate.dialect.MySQLDialect</property>
		
		<!-- 下面两个是可选的配置哟！ -->
		<!-- 打印sql语句 -->
		<property name="hibernate.show_sql">true</property>
		<!-- 格式化sql语句 -->
		<property name="hibernate.format_sql">true</property>
		
		<!-- 告诉Hibernate的核心配置文件加载哪个映射文件 -->
		<mapping resource="com/meimeixia/hibernate/demo01/Customer.hbm.xml"/>
	</session-factory>
</hibernate-configuration>

Hibernate快速入门开发测试
在com.meimeixia.hibernate.demo01包下创建一个单元测试类——HibernateDemo1.java。
package com.meimeixia.hibernate.demo01;

import org.hibernate.Session;
import org.hibernate.SessionFactory;
import org.hibernate.Transaction;
import org.hibernate.cfg.Configuration;
import org.junit.Test;

/**
 * Hibernate的入门案例
 * @author liayun
 *
 */
public class HibernateDemo1 {
	
	//保存用户的案例
	@Test
	public void demo1() {
		//1. 加载Hibernate的核心配置文件
		Configuration configuration = new Configuration().configure();
		//如果在Hibernate的核心配置文件没有设置加载哪个映射文件，则可手动加载映射文件
		//configuration.addResource("com/meimeixia/hibernate/demo01/Customer.hbm.xml");
		
		//2. 创建SessionFactory对象，类似于JDBC中的连接池
		SessionFactory sessionFactory = configuration.buildSessionFactory();
		
		//3. 通过SessionFactory获取到Session对象，类似于JDBC中的Connection
		Session session = sessionFactory.openSession();
		
		//4. 手动开启事务，（最好是手动开启事务）
		Transaction transaction = session.beginTransaction();
		
		//5. 编写代码
		Customer customer = new Customer();
		customer.setCust_name("张小敬aaa");
		
		session.save(customer);//保存一个用户
		
		//6. 事务提交
		transaction.commit();
		
		//7. 释放资源
		session.close();
		sessionFactory.close();
	}
	
}

测试如若都无任何问题，则我们就算入门Hibernate了。
Hibernate执行原理总结
可从度娘上看到如下文字：



码字不易，希望大家能够喜欢！

Hibernate06_配置文件详解
dynamic-insert=“true” 动态添加
dynamic-update=“true” 动态更新
where=“id = 1” 附加查询条件
inverse=“true” 放弃关系维护权
cascade=“true” 设置级联操作

dynamic-insert=“true” 动态添加
测试：
People people  =new People();
people.setName("李四");
session.save(people);
session.beginTransaction().commit();
session.close();

结果：
Hibernate: 
    insert 
    into
        people
        (name, money) 
    values
        (?, ?)



修改People.hbm.xml，设置 dynamic-insert="true"
<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE hibernate-mapping PUBLIC "-//Hibernate/Hibernate Mapping DTD 3.0//EN"
		"http://hibernate.sourceforge.net/hibernate-mapping-3.0.dtd">
<hibernate-mapping>
	<class name="com.blu.entity.People" table="people" dynamic-insert="true">
		<id name="id" type="java.lang.Integer">
			<column name="id"></column>
			<generator class="identity"></generator>
		</id>
		<property name="name" type="java.lang.String">
			<column name="name"></column>
		</property>
		<property name="money" type="java.lang.Double">
			<column name="money"></column>
		</property>
	</class>

</hibernate-mapping>

再次测试的结果：
Hibernate: 
    insert 
    into
        people
        (name) 
    values
        (?)



dynamic-update=“true” 动态更新
测试：
People people = session.get(People.class, 2);
people.setMoney(2000.0);
session.update(people);
session.beginTransaction().commit();
session.close();

结果：
Hibernate: 
    select
        people0_.id as id1_3_0_,
        people0_.name as name2_3_0_,
        people0_.money as money3_3_0_ 
    from
        people people0_ 
    where
        people0_.id=?
Hibernate: 
    update
        people 
    set
        name=?,
        money=? 
    where
        id=?


修改People.hbm.xml，设置 dynamic-update="true"
配置文件略

再次测试：
People people = session.get(People.class, 3);
people.setMoney(3000.0);
session.update(people);
session.beginTransaction().commit();
session.close();

结果：
Hibernate: 
    select
        people0_.id as id1_3_0_,
        people0_.name as name2_3_0_,
        people0_.money as money3_3_0_ 
    from
        people people0_ 
    where
        people0_.id=?
Hibernate: 
    update
        people 
    set
        money=? 
    where
        id=?

总结：使用 dynamic-insert=“true” 和 dynamic-update=“true” 后，SQL语句被优化，执行效率提高，提升了系统性能！

where=“id = 1” 附加查询条件
测试
String hql = "from People";
Query query = session.createQuery(hql);
List<People> list = query.list();
for(People people : list) {
	System.out.println(people);
}
session.beginTransaction().commit();
session.close();

结果：
Hibernate: 
    select
        people0_.id as id1_3_,
        people0_.name as name2_3_,
        people0_.money as money3_3_ 
    from
        people people0_
People(id=1, name=张三, money=1000.0)
People(id=2, name=李四, money=2000.0)
People(id=3, name=王五, money=3000.0)

修改People.hbm.xml，设置 where="id = 1"
配置文件略

再次测试的结果：
Hibernate: 
    select
        people0_.id as id1_3_,
        people0_.name as name2_3_,
        people0_.money as money3_3_ 
    from
        people people0_ 
    where
        (
            people0_.id = 1
        )
People(id=1, name=张三, money=1000.0)


inverse="true" 放弃关系维护权
测试：
Customer customer = new Customer();
customer.setName("李四");
		
Orders order1 = new Orders();
order1.setName("订单a");
order1.setCustomer(customer);
		
Orders order2 = new Orders();
order2.setName("订单b");
order2.setCustomer(customer);
		
Set<Orders> orders = new HashSet<Orders>();
orders.add(order1);
orders.add(order2);
customer.setOrders(orders);

session.save(customer);	
session.save(order1);
session.save(order2);
session.beginTransaction().commit();
session.close();

结果执行了5条SQL（如果先保存订单后保存客户，则会执行七条SQL）：
Hibernate: 
    insert 
    into
        customer
        (name) 
    values
        (?)
Hibernate: 
    insert 
    into
        orders
        (name, cid) 
    values
        (?, ?)
Hibernate: 
    insert 
    into
        orders
        (name, cid) 
    values
        (?, ?)
Hibernate: 
    update
        orders 
    set
        cid=? 
    where
        id=?
Hibernate: 
    update
        orders 
    set
        cid=? 
    where
        id=?





原因是Customer和Orders都在维护一对多关系，所以会重复设置主外键约束关系。
解决方法1：去掉一方维护关系的代码
Customer customer = new Customer();
customer.setName("李四");
		
Orders order1 = new Orders();
order1.setName("订单a");
order1.setCustomer(customer);
		
Orders order2 = new Orders();
order2.setName("订单b");
order2.setCustomer(customer);

session.save(customer);
session.save(order1);
session.save(order2);
session.beginTransaction().commit();
session.close();

结果：
Hibernate: 
    insert 
    into
        customer
        (name) 
    values
        (?)
Hibernate: 
    insert 
    into
        orders
        (name, cid) 
    values
        (?, ?)
Hibernate: 
    insert 
    into
        orders
        (name, cid) 
    values
        (?, ?)

解决方法2：通过配置 inverse="true" 让Customer放弃关系维护权
<set name="orders" table="orders" lazy="extra" inverse="true">
	<key column="cid"></key>
	<one-to-many class="com.blu.entity.Orders"></one-to-many>
</set>


cascade="true" 设置级联操作
测试：
Customer customer = session.get(Customer.class, 10);
session.delete(customer);
session.beginTransaction().commit();
session.close();

删除报错，原因：外键约束

解决方法1：先删除所有的orders，再删除customer
Customer customer = session.get(Customer.class, 10);
Iterator<Orders> iterator = customer.getOrders().iterator();
while(iterator.hasNext()) {
	session.delete(iterator.next());
}
session.delete(customer);
session.beginTransaction().commit();
session.close();

结果：
Hibernate: 
    select
        customer0_.id as id1_1_0_,
        customer0_.name as name2_1_0_ 
    from
        customer customer0_ 
    where
        customer0_.id=?
Hibernate: 
    select
        orders0_.cid as cid3_2_0_,
        orders0_.id as id1_2_0_,
        orders0_.id as id1_2_1_,
        orders0_.name as name2_2_1_,
        orders0_.cid as cid3_2_1_ 
    from
        orders orders0_ 
    where
        orders0_.cid=?
Hibernate: 
    delete 
    from
        orders 
    where
        id=?
Hibernate: 
    delete 
    from
        orders 
    where
        id=?
Hibernate: 
    delete 
    from
        customer 
    where
        id=?

解决方法2： 通过配置 cascade="delete" 开启级联删除操作
<set name="orders" table="orders" lazy="extra" inverse="true" cascade="delete">
	<key column="cid"></key>
	<one-to-many class="com.blu.entity.Orders"></one-to-many>
</set>

测试：
Customer customer = session.get(Customer.class, 11);
session.delete(customer);
session.beginTransaction().commit();
session.close();

结果：
Hibernate: 
    select
        customer0_.id as id1_1_0_,
        customer0_.name as name2_1_0_ 
    from
        customer customer0_ 
    where
        customer0_.id=?
Hibernate: 
    select
        orders0_.cid as cid3_2_0_,
        orders0_.id as id1_2_0_,
        orders0_.id as id1_2_1_,
        orders0_.name as name2_2_1_,
        orders0_.cid as cid3_2_1_ 
    from
        orders orders0_ 
    where
        orders0_.cid=?
Hibernate: 
    delete 
    from
        orders 
    where
        id=?
Hibernate: 
    delete 
    from
        customer 
    where
        id=?

最近做了一个Hibernate与MyBatis的对比总结，希望大家指出不对之处。
第一章     Hibernate与MyBatis

Hibernate 是当前最流行的O/R mapping框架，它出身于sf.net，现在已经成为Jboss的一部分。 Mybatis 是另外一种优秀的O/R
 mapping框架。目前属于apache的一个子项目。

MyBatis 参考资料官网：http://www.mybatis.org/core/zh/index.html  

Hibernate参考资料： http://docs.jboss.org/hibernate/core/3.6/reference/zh-CN/html_single/
1.1 Hibernate 简介

Hibernate对数据库结构提供了较为完整的封装，Hibernate的O/R
 Mapping实现了POJO 和数据库表之间的映射，以及SQL 的自动生成和执行。程序员往往只需定义好了POJO 到数据库表的映射关系，即可通过Hibernate 提供的方法完成持久层操作。程序员甚至不需要对SQL 的熟练掌握， Hibernate/OJB 会根据制定的存储逻辑，自动生成对应的SQL 并调用JDBC 接口加以执行。
1.2 MyBatis简介

iBATIS 的着力点，则在于POJO 与SQL之间的映射关系。然后通过映射配置文件，将SQL所需的参数，以及返回的结果字段映射到指定POJO。
 相对Hibernate“O/R”而言，iBATIS 是一种“Sql
 Mapping”的ORM实现。
第二章 开发对比
开发速度

Hibernate的真正掌握要比Mybatis来得难些。Mybatis框架相对简单很容易上手，但也相对简陋些。个人觉得要用好Mybatis还是首先要先理解好Hibernate。
开发社区

Hibernate 与Mybatis都是流行的持久层开发框架，但Hibernate开发社区相对多热闹些，支持的工具也多，更新也快，当前最高版本4.1.8。而Mybatis相对平静，工具较少，当前最高版本3.2。
开发工作量

Hibernate和MyBatis都有相应的代码生成工具。可以生成简单基本的DAO层方法。

针对高级查询，Mybatis需要手动编写SQL语句，以及ResultMap。而Hibernate有良好的映射机制，开发者无需关心SQL的生成与结果映射，可以更专注于业务流程。
第三章 系统调优对比
Hibernate的调优方案
制定合理的缓存策略；
尽量使用延迟加载特性；
采用合理的Session管理机制；
使用批量抓取，设定合理的批处理参数（batch_size）;
进行合理的O/R映射设计
Mybatis调优方案

MyBatis在Session方面和Hibernate的Session生命周期是一致的，同样需要合理的Session管理机制。MyBatis同样具有二级缓存机制。 MyBatis可以进行详细的SQL优化设计。
SQL优化方面

Hibernate的查询会将表中的所有字段查询出来，这一点会有性能消耗。Hibernate也可以自己写SQL来指定需要查询的字段，但这样就破坏了Hibernate开发的简洁性。而Mybatis的SQL是手动编写的，所以可以按需求指定查询的字段。

Hibernate HQL语句的调优需要将SQL打印出来，而Hibernate的SQL被很多人嫌弃因为太丑了。MyBatis的SQL是自己手动写的所以调整方便。但Hibernate具有自己的日志统计。Mybatis本身不带日志统计，使用Log4j进行日志记录。
扩展性方面

Hibernate与具体数据库的关联只需在XML文件中配置即可，所有的HQL语句与具体使用的数据库无关，移植性很好。MyBatis项目中所有的SQL语句都是依赖所用的数据库的，所以不同数据库类型的支持不好。
第四章 对象管理与抓取策略
对象管理

Hibernate 是完整的对象/关系映射解决方案，它提供了对象状态管理（state
 management）的功能，使开发者不再需要理会底层数据库系统的细节。也就是说，相对于常见的 JDBC/SQL 持久层方案中需要管理 SQL 语句，Hibernate采用了更自然的面向对象的视角来持久化 Java 应用中的数据。

换句话说，使用 Hibernate 的开发者应该总是关注对象的状态（state），不必考虑 SQL 语句的执行。这部分细节已经由 Hibernate 掌管妥当，只有开发者在进行系统性能调优的时候才需要进行了解。

而MyBatis在这一块没有文档说明，用户需要对对象自己进行详细的管理。
抓取策略

Hibernate对实体关联对象的抓取有着良好的机制。对于每一个关联关系都可以详细地设置是否延迟加载，并且提供关联抓取、查询抓取、子查询抓取、批量抓取四种模式。 它是详细配置和处理的。

而Mybatis的延迟加载是全局配置的。
第五章 缓存机制对比
Hibernate缓存

Hibernate一级缓存是Session缓存，利用好一级缓存就需要对Session的生命周期进行管理好。建议在一个Action操作中使用一个Session。一级缓存需要对Session进行严格管理。

Hibernate二级缓存是SessionFactory级的缓存。 SessionFactory的缓存分为内置缓存和外置缓存。内置缓存中存放的是SessionFactory对象的一些集合属性包含的数据(映射元素据及预定SQL语句等),对于应用程序来说,它是只读的。外置缓存中存放的是数据库数据的副本,其作用和一级缓存类似.二级缓存除了以内存作为存储介质外,还可以选用硬盘等外部存储设备。二级缓存称为进程级缓存或SessionFactory级缓存，它可以被所有session共享，它的生命周期伴随着SessionFactory的生命周期存在和消亡。
MyBatis缓存

MyBatis 包含一个非常强大的查询缓存特性,它可以非常方便地配置和定制。MyBatis
 3 中的缓存实现的很多改进都已经实现了,使得它更加强大而且易于配置。

默认情况下是没有开启缓存的,除了局部的 session 缓存,可以增强变现而且处理循环
 依赖也是必须的。要开启二级缓存,你需要在你的 SQL 映射文件中添加一行: 
 <cache/>

字面上看就是这样。这个简单语句的效果如下:
映射语句文件中的所有 select 语句将会被缓存。
映射语句文件中的所有 insert,update 和 delete 语句会刷新缓存。
缓存会使用 Least Recently Used(LRU,最近最少使用的)算法来收回。
根据时间表(比如 no
 Flush Interval,没有刷新间隔), 缓存不会以任何时间顺序
 来刷新。
缓存会存储列表集合或对象(无论查询方法返回什么)的 1024 个引用。
缓存会被视为是 read/write(可读/可写)的缓存,意味着对象检索不是共享的,而
 且可以安全地被调用者修改,而不干扰其他调用者或线程所做的潜在修改。

所有的这些属性都可以通过缓存元素的属性来修改。

比如: <cache  eviction="FIFO"  flushInterval="60000"  size="512"  readOnly="true"/>

这个更高级的配置创建了一个 FIFO 缓存,并每隔 60 秒刷新,存数结果对象或列表的 512 个引用,而且返回的对象被认为是只读的,因此在不同线程中的调用者之间修改它们会
 导致冲突。可用的收回策略有, 默认的是 LRU:
LRU – 最近最少使用的:移除最长时间不被使用的对象。
FIFO – 先进先出:按对象进入缓存的顺序来移除它们。
SOFT – 软引用:移除基于垃圾回收器状态和软引用规则的对象。
WEAK – 弱引用:更积极地移除基于垃圾收集器状态和弱引用规则的对象。

flushInterval(刷新间隔)可以被设置为任意的正整数,而且它们代表一个合理的毫秒
 形式的时间段。默认情况是不设置,也就是没有刷新间隔,缓存仅仅调用语句时刷新。

size(引用数目)可以被设置为任意正整数,要记住你缓存的对象数目和你运行环境的
 可用内存资源数目。默认值是1024。

readOnly(只读)属性可以被设置为 true 或 false。只读的缓存会给所有调用者返回缓
 存对象的相同实例。因此这些对象不能被修改。这提供了很重要的性能优势。可读写的缓存 会返回缓存对象的拷贝(通过序列化) 。这会慢一些,但是安全,因此默认是 false。
相同点

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