什么是hibernate？

Hibernate是一個開放源代碼的對象關系映射框架，它對JDBC進行了非常輕量級的對象封裝，它將POJO與數據庫表建立映射關系，是一個全自動的orm框架，hibernate可以自動生成SQL語句，自動執行，使得Java程序員可以隨心所欲的使用對象編程思維來操縱數據庫。 Hibernate可以應用在任何使用JDBC的場合，既可以在Java的客戶端程序使用，也可以在Servlet/JSP的Web應用中使用，最具革命意義的是，Hibernate可以在應用EJB的J2EE架構中取代CMP，完成數據持久化的重任。

 什么是ORM？

Object Relational Mapping，對象關系映射，為了解決傳統jdbc中對object的參數改變而引起的一系列修改的辦法。強調將java對象和關系型數據庫(如：MySQL) 建立一種關系，直接操作java對象就相當于操作表。

映射關系通過配置（XML）實現。

Hibernate環境搭建

版本：Hibernate3.x  Hibernate4.x（過渡版）  Hibernate5.x（最新版） 。

本學習筆記使用的是 hibernate-release-5.0.7.Final版本。

下載Hibernate的壓縮包

去官網~    下載完成后解壓  里面有一個required文件夾，這個文件夾里面的jar包是使用hibernate必須的jar包

創建一個項目，引入jar包

引入jar包清單：

數據庫驅動包

Hibernate開發必備的jar包

日志記錄包

完整清單如下：

創建表和實體類

CREATE DATABASE hibernate_day01;
SELECT Hibernate_day01;

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;

package com.aloha.hibernate.demo1;

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;
	}
	
}

表中的列名最好和實體類的成員變量名稱一致。

創建映射關系

映射關系通過配置文件xml來配置，這樣可以有利于我們后期對表結構修改的時候盡量少的動java代碼。

配置文件放在對應包目錄下，可以隨意命名，但是最好還是統一命名規范為： 類名.hbm.xml   。   下面是我寫的Customer.hbm.xml用來建立java類和表的關系，表主鍵與java類中對應成員變量的關系以及表中列與java類的對應成員變量的關系。

<?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.aloha.hibernate.demo1.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>

dtd約束怎么引入：hibernate-core-5.0.7.Final.jar/org.hibernate/hibernate-mapping-3.0.dtd

在這個文件里包含了引入映射dtd約束的語句，語句在上例中寫出了。這時就可以些hibernate-mapping的標簽了。

類表映射 中：主鍵映射、成員映射。

創建一個hibernate核心配置文件

核心配置文件位置是在src文件下，名稱固定為：hibernate.cfg.xml。主要配置jdbc，內容如下：

<?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>
		<!-- 連接數據庫的基本參數 -->
		<property name="hibernate.connection.driver_class">com.mysql.jdbc.Driver</property>
		<property name="hibernate.connection.url">jdbc:mysql://localhost:3306/hibernate_day01</property>
		<property name="hibernate.connection.username">root</property>
		<property name="hibernate.connection.password">root</property>
		<!-- 配置hibernate的方言 -->
		<property name="hibernate.dialect">org.hibernate.dialect.MySQLDialect</property>
		
		<!-- 可選配置：打印sql語句到控制臺上，格式化sql語句 -->
		<property name="hibernate.show_sql">true</property>
		<property name="hibernate.format_sql">true</property>

		<mapping resource="com/aloha/hibernate/demo1/Customer.hbm.xml"/>
		
	</session-factory>
</hibernate-configuration>

dtd約束怎么引入：hibernate-core-5.0.7.Final.jar/org.hibernate/hibernate-configuration-3.0.dtd

在這個文件里包含了引入核心配置dtd約束的語句，語句在上例中寫出了。這時就可以寫hibernate-configuration的標簽了。

 

Hibernate入門

搭建完成Hibernate環境，寫好配置文件后，我們就可以開始寫執行的java文件的，一個原生的寫入案例：

	@Test
	public void test1(){
		//1.加載核心配置文件
		Configuration configuration = new Configuration().configure();
		//2.創建SessionFactory對象：類似JDBC連接池
		SessionFactory sessionFactory = configuration.buildSessionFactory();
		//3.通過SessionFactory獲取Session對象：類似Connection
		Session session = sessionFactory.openSession();
		//4.手動開啟事務：hibernate5以后以可不用了，但是為了兼容性，還是寫著把
		Transaction transaction = session.beginTransaction();
		//5.編寫代碼
		
		Customer customer = new Customer();
		customer.setCust_name("aloha");
		
		session.save(customer);
		
		
		//6.事務提交
		transaction.commit();
		//7.資源釋放
		session.close();
	}

我們往數據庫中插入了一條cust_name為aloha的記錄，結果如下：

hibernate配置

1. 1. 1. Hibernate的映射的配置
         1. 映射的配置
2. 【class標簽的配置】
   1. 標簽用來建立類與表的映射關系
   2. 屬性：
      1. name                ：類的全路徑
      2. table                 ：表名（類名與表名一致，table可以省略）
      3. catalog             ：數據庫名
3. 【id標簽的配置】
   1. 標簽用來建立類中的屬性與表中的主鍵的對應關系
   2. 屬性：
      1. name                ：類中的屬性名
      2. column             ：表中的字段名（類中的屬性名和表中的字段名如果一致，column可以省略）
      3. length               ：長度
      4. type                   ：類型
4. 【property標簽的配置】
   1. 標簽用來建立類中的普通屬性與表的字段的對應關系
   2. 屬性：
      1. name                ：類中的屬性名
      2. column             ：表中的字段名
      3. length               ：長度
      4. type                   ：類型
      5. not-null            ：設置非空
      6. unique              ：設置唯一

1. 1. 1. Hibernate的核心的配置
         1. Hibernate的核心配置方式（了解）
2. 一種方式:屬性文件的方式
   1. hibernate.properties
      1. hibernate.connection.driver_class=com.mysql.jdbc.Driver
      2. …
      3. hibernate.show_sql=true
   2. 屬性文件的方式不能引入映射文件（手動編寫代碼加載映射文件）

 

1. 二種方式:XML文件的方式
   1. hibernate.cfg.xml
      1. 1. 核心的配置
2. 必須的配置
   1. 連接數據庫的基本的參數
      1. 驅動類
      2. url路徑
      3. 用戶名
      4. 密碼
   2. 方言
3. 可選的配置
   1. 顯示SQL          ：hibernate.show_sql
   2. 格式化SQL     ：hibernate.format_sql
   3. 自動建表        ：hibernate.hbm2ddl.auto
      1. none                 ：不使用hibernate的自動建表
      2. create               ：如果數據庫中已經有表，刪除原有表，重新創建，如果沒有表，新建表。（測試）
      3. create-drop     ：如果數據庫中已經有表，刪除原有表，執行操作，刪除這個表。如果沒有表，新建一個，使用完了刪除該表。（測試）
      4. update             ：如果數據庫中有表，使用原有表，如果沒有表，創建新表（更新表結構）
      5. validate            ：如果沒有表，不會創建表。只會使用數據庫中原有的表。（校驗映射和表結構）。
4. 映射文件的引入    
   1. 引入映射文件的位置

核心配置

1.

1. 必須的配置
   1. 連接數據庫的基本的參數
      1. 驅動類
      2. url路徑
      3. 用戶名
      4. 密碼
   2. 方言
2. 可選的配置
   1. 顯示SQL          ：hibernate.show_sql
   2. 格式化SQL     ：hibernate.format_sql
   3. 自動建表        ：hibernate.hbm2ddl.auto
      1. none                 ：不使用hibernate的自動建表
      2. create               ：如果數據庫中已經有表，刪除原有表，重新創建，如果沒有表，新建表。（測試）
      3. create-drop     ：如果數據庫中已經有表，刪除原有表，執行操作，刪除這個表。如果沒有表，新建一個，使用完了刪除該表。（測試）
      4. update             ：如果數據庫中有表，使用原有表，如果沒有表，創建新表（更新表結構）
      5. validate            ：如果沒有表，不會創建表。只會使用數據庫中原有的表。（校驗映射和表結構）。
3. 映射文件的引入    
   1. 引入映射文件的位置

Hibernate核心API

Configuration:Hibernate的配置對象

這個類的作用是對Hibernate 進行配置，以及對它進行啟動。在Hibernate的啟動過程中，Configuration類的實例首先定位映射文檔的位置，讀取這些配置，然后創建一個SessionFactory對象。雖然Configuration類在整個Hibernate項目中只扮演著一個很小的角色，但它是啟動Hibernate時所遇到的第一個對象。

作用：

加載核心配置文件

hibernate.properties 

Configuration cfg = new Configuration();

hibernate.cfg.xml

Configuration cfg = new Configuration().configure();

手動加載映射：

configuration.addResource("映射文件路徑");

SessionFactory: Session工廠

SessionFactory接口負責初始化Hibernate。它充當數據存儲源的代理，并負責創建Session對象。這里用到了工廠模式。需要注意的是SessionFactory并不是輕量級的，因為一般情況下，一個項目通常只需要一個SessionFactory就夠，當需要操作多個數據庫時，可以為每個數據庫指定一個SessionFactory。

內部維護了Hibernate的連接池和Hibernate的二級緩存。（企業里二級緩存用的時redis）。是線程安全的對象。

需要引入C3P0連接池時，我們可以在下載hibernate的hibernate-release-5.0.7.Final\lib\optional\c3p0路徑中的3個jar包導入項目中，將C3P0的配置代碼寫入hibernate.cfg.xml中：

<!-- 配置C3P0連接池 -->
		<property name="connection.provider_class">org.hibernate.connection.C3P0ConnectionProvider</property>
		<!--在連接池中可用的數據庫連接的最少數目 -->
		<property name="c3p0.min_size">5</property>
		<!--在連接池中所有數據庫連接的最大數目  -->
		<property name="c3p0.max_size">20</property>
		<!--設定數據庫連接的過期時間,以秒為單位,
		如果連接池中的某個數據庫連接處于空閑狀態的時間超過了timeout時間,就會從連接池中清除 -->
		<property name="c3p0.timeout">120</property>
		 <!--每3000秒檢查所有連接池中的空閑連接 以秒為單位-->
		<property name="c3p0.idle_test_period">3000</property>

這是一個重量級的對象，為了防止重復創建浪費資源，我們創建一個工具類：

package com.aloha.hibernate.utils;

import org.hibernate.Session;
import org.hibernate.SessionFactory;
import org.hibernate.cfg.Configuration;

/**
 * hibernate的工具類
 * @author malaganguo
 *
 */
public class HibernateUtils {

	public static final Configuration cfg;
	public static final SessionFactory sf;
	
	static{
		cfg = new Configuration().configure();
		sf = cfg.buildSessionFactory();
	}
	/**
	 * 獲取session對象
	 * @return 返回session對象
	 */
	public static Session openSession(){
		return sf.openSession();//這個openSession()方法來自SessionFactory
	}
}

Session:連接對象

類似Connection對象，Session接口負責執行被持久化對象的CRUD操作(CRUD的任務是完成與數據庫的交流，包含了很多常見的SQL語句)。但需要注意的是Session對象是非線程安全的。同時，Hibernate的session不同于JSP應用中的HttpSession。這里當使用session這個術語時，其實指的是Hibernate中的session，而以后會將HttpSession對象稱為用戶session。

Hibernate中的Session是Hibernate與數據庫鏈接的對象。是線程不安全的。是與數據庫交互的橋梁。

 

Session 中的API

 

保存方法： Serializable save(Object obj) ;  

查詢方法：(hibernate版本大于3.x才有的泛型) T find(Class c, Serializable id);                 T load(Class c, Serializable id);

查詢方法演示以及find，load方法的區別：

/**
	 * 查詢客戶
	 */
	@Test
	public void test2(){
		Session session =HibernateUtils.openSession();
		Transaction transaction = session.beginTransaction();
		
		//get方法查詢
		Customer customer = session.get(Customer.class, 1l);
		System.out.println(customer);
		
		//load方法查詢
		Customer customer1 = session.load(Customer.class, 1l);
		System.out.println(customer1);
		/**
		 * 兩種查詢方式的打印語句與查詢結果完全相同，區別是？
		 * get方法采用立即加載，執行到這行代碼時就會馬上進行查詢
		 * 		   查詢返回的是真實對象
		 * 		   查詢一個找不到的對象的時候返回null
		 * 
		 * load方法采用延遲（懶）加載，指執行到這行代碼時不會發送SQL語句，真正使用對象時才發送SQL語句，
		 * 	因為id已知，所以用id都不會發語句，也太懶了。
		 * 		  查詢返回的是代理對象，使用的是javassist.jar包技術產生的代理 
		 *       拋出一個ObjectNotFindException
		 */
		transaction.commit();
		session.close();
	}

修改方法：void update(Object obj);

	/**
	 * 修改客戶
	 */
	@Test
	public void test3(){
		Session session = HibernateUtils.openSession();
		Transaction transaction = session.beginTransaction();
		
/*		//直接創建對象進行修改（不推薦，因為不修改的會被賦null）
		Customer customer = new Customer();
		customer.setCust_id(4l);
		customer.setCust_name("王思聰");
		session.update(customer);*/
		
		
		//先查詢再修改（推薦，不會將沒有修改的內容賦為null）
		Customer customer = session.get(Customer.class, 4l);
		customer.setCust_name("王尼瑪");
		session.update(customer);
		
		transaction.commit();
		session.close();
	}

直接創建對象進行修改的結果：

我們現在將王思聰的來源依然改為小廣告，使用先查詢再修改的方式來看看修改的結果：

刪除方法： void delete(Object obj);

	/**
	 * 刪除客戶
	 */
	@Test
	public void test4(){
		Session session = HibernateUtils.openSession();
		Transaction transaction = session.beginTransaction();
		
		/*//直接創建對象刪除
		Customer customer = new Customer();
		customer.setCust_id(3l);
		session.delete(customer);*/
		
		//先查詢再刪除
		Customer customer = session.get(Customer.class, 2l);
		session.delete(customer);
		
		transaction.commit();
		session.close();
	}

結果：我們刪除了兩個id為2和3的客戶名為aloha的客戶記錄

保存或更新方法： void saveOrUpdate(Object obj);

	/**
	 * 保存或更新：不設置id——保存；設置id——更新。
	 */
	@Test
	public void test5(){
		Session session = HibernateUtils.openSession();
		Transaction transaction = session.beginTransaction();
		
		Customer customer = new Customer();
		/*customer.setCust_name("王九蛋");//保存王九蛋*/
		customer.setCust_id(6l);
		customer.setCust_name("伍佰");//更新id為6的的name為伍佰
		session.saveOrUpdate(customer);
		
		transaction.commit();
		session.close();
	}

查詢所有：

	/**
	 * 查詢所有:使用HQL或SQL查詢
	 */
	@Test
	public void test6(){
		Session session = HibernateUtils.openSession();
		Transaction transaction = session.beginTransaction();
		
		//接收：HQL對象
		//HQL:Hibernate Query Language是一種面向對象的查詢語言
		Query query = session.createQuery("from Customer");
		List<Customer> list = query.list();
		for (Customer customer : list) {
			System.out.println(customer);
		}
		
		//接收：SQL對象
		SQLQuery query2 = session.createSQLQuery("select * from cst_customer");
		List<Object[]> list2 = query2.list();
		for (Object[] objects : list2) {
			System.out.println(Arrays.toString(objects));
		}
		
		transaction.commit();
		session.close();
	}

HQL查詢：

SQL查詢：

Transaction:事務對象

常用的就是commit()和rollback()兩個方法。提交和回滾。在hibernate5在，如果沒有引入C3P0的話，開啟事務和提交事務是可以不寫的，因為C3P0內代碼是可以完成事務的開啟和提交的。