Hibernate 是一個優秀的持久層的ORM（物件關係對映）框架，對JDBC進行了輕量級的封裝，由於它可以自動生成sql語句自動執行，因此可以讓我們使用物件程式設計的思想來操作資料庫，簡化了資料操作的繁雜性。

• O: Object物件，面嚮物件語言領域，Java中的JavaBean

• R: 關係資料庫領域的Relational（資料庫中表的結構）

• M: 對映Mapping（XML的配置檔案）

使用Hibernate操作資料庫要配置Bean類的對映檔案和Hibernate的核心配置檔案

先來看一個Hibernate的核心配置檔案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>
<!-- hibernate的必配選項 -->
	<!-- 配置資料庫驅動 -->
		<property name="hibernate.connection.driver_class">com.mysql.jdbc.Driver</property>
	<!-- 配置資料庫url -->
		<property name="hibernate.connection.url">jdbc:mysql:///test</property>
	<!-- 配置資料庫使用者名稱 -->
		<property name="hibernate.connection.username">root</property>
	<!-- 配置資料密碼 -->
		<property name="hibernate.connection.password">123456</property>
	<!-- 配置資料庫方言 -->
		<property name="hibernate.dialect">org.hibernate.dialect.MySQLDialect</property>
<!-- hibernate的必配選項結束 -->
	
	
<!-- hibernate的可選配置項 -->
	<!-- 配置執行過程中的sql語句展示 -->
		<property name="hibernate.show_sql">true</property>
		
	<!-- 美化展示的sql語句 -->
		<property name="hibernate.format_sql">true</property>
		
	<!-- 使用第三方連線池 -->
		<property name="hibernate.connection.provider_class">org.hibernate.c3p0.internal.C3P0ConnectionProvider</property>
		
	<!-- 設定第三方連線池的屬性 -->
		<property name="hibernate.c3p0.max_size">20</property>
		<property name="hibernate.c3p0.min_size">5</property>
		<property name="hibernate.c3p0.timeout">5000</property>
	<!-- 配置DDL資料庫規則 -->
	<!-- 
		none:不用Hibernate自動生成表(預設)
		create-drop:每次都會建立一個新的表，執行程式結束後刪除這個表.
		create:每次都會建立一個新的表.
		update:有(表, 列)就使用, 沒有(表, 列)就建立
		validate:只會使用原有的表.對對映關係進行校驗.
	 -->
		<property name="hibernate.hbm2ddl.auto">update</property>
	<!-- 配置與本地執行緒繫結的Session物件（操作事務保證session的同一性） -->
		<property name="hibernate.current_session_context_class">thread</property>
		
	<!-- 配置對映檔案 -->
		<mapping resource="com/yanghao/bean/Actor.hbm.xml"/>
		
		<mapping resource="com/yanghao/bean/Category.hbm.xml"/>
		<mapping resource="com/yanghao/bean/Product.hbm.xml"/>
		
		<mapping resource="com/yanghao/bean/Student.hbm.xml"/>
		<mapping resource="com/yanghao/bean/Course.hbm.xml"/>
<!-- hibernate的可選配置項結束-->
	
	</session-factory>
</hibernate-configuration>
 

一個簡單的bean（Actor.java）的對映檔案Actor.hbm.xml：

類中的屬性：

private Integer aid;
private String name;
private String age;
private String birthday;
private String area;

<?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.yanghao.bean.Actor" table="actor" >
		<!-- 配置主鍵 -->
		<!-- 主鍵生成策略 -->
		<!-- 
			increment:檢索自增，會先查詢表中的最大的下標，然後下標加一作為下一個新插入的資料的主鍵，在多執行緒和叢集中有很大的問題，不推薦使用
			assigned(指定的、賦值的):自定義主鍵
			identity:自動增長，有索引的增長，Mysql的自動增長策略
			sequence:自動增長，有索引的增長，Oracle的自動增長策略
			native:本地策略，根據不同資料庫能進行不同的自動增長策略的選擇，如果是mysql，就用identity，如果是Oracle就用sequence
			
			uuid:隨機的字串策略，用於生成唯一的字串主鍵的策略
		 -->
		<id name="aid" column="aid">
			<generator class="native"></generator>
		</id>
		
		<!-- 配置對應表中的屬性 -->
		<property name="name" column="name"/>
		<property name="age" column="age"/>
		<property name="birthday" column="birthday"/>
		<property name="area" column="area"/>
	</class>
</hibernate-mapping>
 

將一個Actor的物件對映到資料庫中，獲取一個Session物件，使用其save方法儲存到資料庫

        @Test
	public void test() {
		//使用hibernate操作資料庫的步驟
		//讀取配置檔案,載入配置預設的配置檔案
		Configuration configuration = new Configuration();
		configuration.configure();
		
		//建立SessionFactory獲取Session物件
		SessionFactory sessionFactory = configuration.buildSessionFactory();
		Session session = sessionFactory.openSession();
		
		//開啟事務
		Transaction transaction = session.beginTransaction();
		
		//執行資料庫操作
		Actor actor = new Actor();
		actor.setName("黑妞");
		actor.setAge("2");
		actor.setBirthday("20000102");
		actor.setArea("繁榮山丘");
		session.save(actor);
		
		//提交事務
		transaction.commit();
	
		//關閉資源
		session.close();
		sessionFactory.close();
	}
 

為了使操作方便，把獲取session物件的操作封裝到工具類中

public class HibernateUtil {
	
	private static SessionFactory sessionFactory;
	private static Configuration configuration;
	
	static {
		configuration = new Configuration();
		configuration.configure();
		sessionFactory = configuration.buildSessionFactory();
	}
	
	//私有構造方法,不能通過構造方法建立物件
	private HibernateUtil(){
	}
		
	//獲取新的Session物件
	public static Session getSession(){
		Session session = sessionFactory.openSession();
		return session;
	}
	
	//獲取當前執行緒中唯一的Session物件
	public static Session getCurrentSession(){
		return sessionFactory.getCurrentSession();
	}		
}

持久化物件（持久化物件創建出來的）在Hibernate的管理中有三種狀態：（OID就是物件的ID）

1、瞬時態---沒有標識OID，沒有納入session的管理

2、持久態--有標識的OID，納入了session的管理-------------持久態的物件內容發生變化會把資料庫中對應的記錄修改

3、託管態--有標識的OID，沒有納入session的管理

三種狀態也可以互相轉換：

        @Test
	public void test3(){
		
		Session session = HibernateUtil.getSession();
		Transaction transaction = session.beginTransaction();
		Actor actor = new Actor();
		actor.setName("皮蛋");
		actor.setAge("3");
		actor.setBirthday("20000101");
		actor.setArea("繁榮山丘");
		session.save(actor);
		transaction.commit();
		
		Transaction transaction2 = session.beginTransaction(); //此處加了斷點，為了檢視資料的變化
		actor.setAge("6");
		actor.setName("蛋皮"); //此處加了斷點
	        //session.update(actor);//不需要更新或者儲存當前的物件就能更新資料庫裡面的值
		transaction2.commit();

		session.close();
	}

在斷點之前當我們檢視session裡面的內容時是這樣的

資料庫裡面是這樣的：

當我們執行到修改這個持久態物件的年齡和名字的時候快取區和快照區的內容發生了變化：

此時，資料庫裡面的資料也發生了更改，注意此時並沒有更新和儲存物件：

實現原理：當第一次儲存完該物件到資料庫的時候，這個物件已經納入了session的管理，物件此時是持久態的，此時Hibernate會把當前物件的狀態儲存一份到一級快取的快照區，當我們修改當前持久態物件的資料的時候，Hibernate會比對當前的快照區，如果發現數據不一致，就自動更新資料庫並重新儲存當前物件的新狀態到快照區.

前面都是操作單表的資料，就是一對一的關係，那麼如何關聯一對多、多對一、多對多和表之間的資料呢？---建立物件和表之間的對映。

一對多（分類和商品）Category.hbm.xml和Product.hbm.xml

 //分類屬性                                                                        //商品屬性
 private Integer cid;                                                               private Integer pid;
 private String cname;                                                              private String pname;
 private Set<Product> products;                                                     private String price;
                                                                                    private String number;
                                                                                    private Category category;

<?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.yanghao.bean.Category" table="category" >
		<!-- 配置主鍵 -->
		<!-- 主鍵生成策略 -->
		<!-- 
			increment:檢索自增，會先查詢表中的最大的下標，然後下標加一作為下一個新插入的資料的主鍵，在多執行緒和叢集中有很大的問題，不推薦使用
			assigned(指定的、賦值的):自定義主鍵
			identity:自動增長，有索引的增長，Mysql的自動增長策略
			sequence:自動增長，有索引的增長，Oracle的自動增長策略
			native:本地策略，根據不同資料庫能進行不同的自動增長策略的選擇，如果是mysql，就用identity，如果是Oracle就用sequence
		
			uuid:隨機的字串策略，用於生成唯一的字串主鍵的策略
		 -->
		<id name="cid" column="cid">
			<generator class="native"></generator>
		</id>
		
		<!-- 配置對應表中的屬性 -->
		<property name="cname" column="cname"/>
		
		<!-- key的column表示多的一方的外來鍵名,inverse=true讓一方級聯儲存多方時多方放棄外來鍵維護，因為外來鍵是屬於多的一方的，兩方都維護外來鍵會產生重複的sql操作-->
		<set name="products" cascade="delete" inverse="true">
			<key column="cid"/>
			<one-to-many class="com.yanghao.bean.Product"/>		
		</set>
	</class>
</hibernate-mapping>

<?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.yanghao.bean.Product" table="product" >
		<!-- 配置主鍵 -->
		<!-- 主鍵生成策略 -->
		<!-- 
			increment:檢索自增，會先查詢表中的最大的下標，然後下標加一作為下一個新插入的資料的主鍵，在多執行緒和叢集中有很大的問題，不推薦使用
			assigned(指定的、賦值的):自定義主鍵
			identity:自動增長，有索引的增長，Mysql的自動增長策略
			sequence:自動增長，有索引的增長，Oracle的自動增長策略
			native:本地策略，根據不同資料庫能進行不同的自動增長策略的選擇，如果是mysql，就用identity，如果是Oracle就用sequence
			
			uuid:隨機的字串策略，用於生成唯一的字串主鍵的策略
		 -->
		<id name="pid" column="pid">
			<generator class="native"></generator>
		</id>
		
		<!-- 配置對應表中的屬性 -->
		<property name="pname" column="pname"/>
		<property name="price" column="price"/>
		<property name="number" column="number"/>
		
		
		<many-to-one name="category" class="com.yanghao.bean.Category" column="cid" cascade="save-update"/>
	</class>
</hibernate-mapping>

多對多（學生和選課）Student.hbm.xml和Course.hbm.xml

//學生類屬性                                                                     //課程屬性
private Integer sid;                                                            private Integer cid;
private String sname;                                                           private String cname;
	
private Set<Course> courses = new HashSet<Course>();                            private Set<Student> students = new HashSet<Student>();

<?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.yanghao.bean.Student" table="student" >
		<!-- 配置主鍵 -->
		<!-- 主鍵生成策略 -->
		<!-- 
			increment:檢索自增，會先查詢表中的最大的下標，然後下標加一作為下一個新插入的資料的主鍵，在多執行緒和叢集中有很大的問題，不推薦使用
			assigned(指定的、賦值的):自定義主鍵
			identity:自動增長，有索引的增長，Mysql的自動增長策略
			sequence:自動增長，有索引的增長，Oracle的自動增長策略
			native:本地策略，根據不同資料庫能進行不同的自動增長策略的選擇，如果是mysql，就用identity，如果是Oracle就用sequence
			
			uuid:隨機的字串策略，用於生成唯一的字串主鍵的策略
		 -->
		<id name="sid" column="sid">
			<generator class="native"></generator>
		</id>
		
		<!-- 配置對應表中的屬性 -->
		<property name="sname" column="sname"/>
		
		<set name="courses" table="s_c_table">
			<key column="sid"/>
			<many-to-many column="cid" class="com.yanghao.bean.Course"/>
		</set>
	</class>
</hibernate-mapping>

<?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.yanghao.bean.Course" table="course" >
		<!-- 配置主鍵 -->
		<!-- 主鍵生成策略 -->
		<!-- 
			increment:檢索自增，會先查詢表中的最大的下標，然後下標加一作為下一個新插入的資料的主鍵，在多執行緒和叢集中有很大的問題，不推薦使用
			assigned(指定的、賦值的):自定義主鍵
			identity:自動增長，有索引的增長，Mysql的自動增長策略
			sequence:自動增長，有索引的增長，Oracle的自動增長策略
			native:本地策略，根據不同資料庫能進行不同的自動增長策略的選擇，如果是mysql，就用identity，如果是Oracle就用sequence
			
			uuid:隨機的字串策略，用於生成唯一的字串主鍵的策略
		 -->
		<id name="cid" column="cid">
			<generator class="native"></generator>
		</id>
		
		<!-- 配置對應表中的屬性 -->
		<property name="cname" column="cname"/>
		
		<!-- 雙向關聯，讓一方放棄外來鍵的維護，否則雙方生成中間表會產生一樣的sql語句，導致主鍵衝突 -->
		<set name="students" table="s_c_table" cascade="save-update" inverse="true">
			<key column="cid"></key><!-- 外來鍵名 -->
			<many-to-many column="sid" class="com.yanghao.bean.Student"/>
		</set>
	</class>
</hibernate-mapping>

Hibernate的查詢方式彙總：

OID檢索 （get  load  save  update  delete）

    get方法和load方法的區別

    get方法的特點

​ get方法採用的是立即檢索策略(查詢)：執行到這行的時候，馬上傳送SQL查詢

​ get方法查詢後返回的是真實物件的本身

load方法的特點

​ load方法採用的是延遲載入(懶載入lazy:什麼時候使用，才會去載入)的策略：執行到這行的時候，不會發送 SQL語句，什麼時候使用這個物件，才會傳送SQL語句。

​ load查詢後返回的是代理物件

物件導航檢索（通過一個物件獲得其關聯物件）

例如：

Category category = session.get(Category.class, 1);
Set<Product> products =   category.getProducts();

HQL檢索 (Hibernate查詢語言,與SQL類似,hql是面向物件的 )

語法: String hql =...

​ Query query = session.createQuery(hql);

• list(); 查詢多個

• uniqueResult();查詢一個

  原則: 把表名改成類名, 把資料庫的列改成Java裡面的屬性

QBC,Query By Criteria(條件查詢,更加面向物件的查詢方式)

語法：

//建立QBC條件查詢
Criteria criteria = session.createCriteria(Class);
//新增條件
criteria.add(Restrictions.api...);
//查詢多個
List list = criteria.list();
//或者查詢一個
Object object =  criteria.uniqueResult();