1.Hibernate工作原理及爲什麼要用？
原理：
1.讀取並解析配置文件
2.讀取並解析映射信息，創建SessionFactory
3.打開Sesssion
4.創建事務Transation
5.持久化操作
6.提交事務
7.關閉Session
8.關閉SesstionFactory
爲什麼要用：
1. 對JDBC訪問數據庫的代碼做了封裝，大大簡化了數據訪問層繁瑣的重複性代碼。
2. Hibernate是一個基於JDBC的主流持久化框架，是一個優秀的ORM實現。他很大程度的簡化DAO層的編碼工作
3. hibernate使用Java反射機制，而不是字節碼增強程序來實現透明性。
4. hibernate的性能非常好，因爲它是個輕量級框架。映射的靈活性很出色。它支持各種關係數據庫，從一對一到多對多的各種複雜關係。
2．Hibernate是如何延遲加載?
1. Hibernate2延遲加載實現：a)實體對象 b)集合（Collection）
2. Hibernate3 提供了屬性的延遲加載功能
當Hibernate在查詢數據的時候，數據並沒有存在與內存中，當程序真正對數據的操作時，對象才存在與內存中，就實現了延遲加載，他節省了服務器的內存開銷，從而提高了服務器的性能。
3．Hibernate中怎樣實現類之間的關係?(如：一對多、多對多的關係)
類與類之間的關係主要體現在表與表之間的關係進行操作，它們都市對對象進行操作，我們程序中把所有的表與類都映射在一起，它們通過配置文件中的many-to-one、one-to-many、many-to-many、
4．說下Hibernate的緩存機制
1. 內部緩存存在Hibernate中又叫一級緩存，屬於應用事物級緩存
2. 二級緩存：
a) 應用及緩存
b) 分佈式緩存
條件：數據不會被第三方修改、數據大小在可接受範圍、數據更新頻率低、同一數據被系統頻繁使用、非 關鍵數據
c) 第三方緩存的實現
5．Hibernate的查詢方式
Sql、Criteria,object comptosition
Hql：
1、 屬性查詢
2、 參數查詢、命名參數查詢
3、 關聯查詢
4、 分頁查詢
5、 統計函數
6．如何優化Hibernate？
1.使用雙向一對多關聯，不使用單向一對多
2.靈活使用單向一對多關聯
3.不用一對一，用多對一取代
4.配置對象緩存，不使用集合緩存
5.一對多集合使用Bag,多對多集合使用Set
6. 繼承類使用顯式多態
7. 表字段要少，表關聯不要怕多，有二級緩存撐腰
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
答案二：
hibernate工作原理：
1、通過Configuration().configure();讀取並解析hibernate.cfg.xml配置文件。
2、由hibernate.cfg.xml中的<mappingresource="com/xx/User.hbm.xml"/>讀取解析映射信息。
3、通過config.buildSessionFactory();//得到sessionFactory。
4、sessionFactory.openSession();//得到session。
5、session.beginTransaction();//開啓事務。
6、persistent operate;
6、session.getTransaction().commit();//提交事務
7、關閉session;
8、關閉sessionFactory;
hibernate優點：
1、封裝了jdbc，簡化了很多重複性代碼。
2、簡化了DAO層編碼工作，使開發更對象化了。
3、移植性好，支持各種數據庫，如果換個數據庫只要在配置文件中變換配置就可以了，不用改變hibernate代碼。
4、支持透明持久化，因爲hibernate操作的是純粹的（pojo）java類，沒有實現任何接口，沒有侵入性。所以說它是一個輕量級框架。
hibernate延遲加載：
get不支持延遲加載，load支持延遲加載。
1、hibernate2對 實體對象和集合 實現了延遲加載
2、hibernate3對 提供了屬性的延遲加載功能
hibernate延遲加載就是當使用session.load(User.class, 1)或者session.createQuery()查詢對象或者屬性的時候
這個對象或者屬性並沒有在內存中，只有當程序操作數據的時候，纔會存在內存中，這樣就實現延遲加載，節省了內存的開銷，從而提高了服務器的性能。
Hibernate的緩存機制
一級緩存：session級的緩存也叫事務級的緩存，只緩存實體，生命週期和session一致。不能對其進行管理。
不用顯示的調用。
二級緩存：sessionFactory緩存，也叫進程級的緩存，使用第3方插件實現的，也值緩存實體，生命週期和sessionFactory一致，可以進行管理。
首先配置第3放插件，我們用的是EHCache，在hibernate.cfg.xml文件中加入
<propertyname="hibernate.cache.user_second_level_cache">true</property>
在映射中也要顯示的調用，<cache usage="read-only"/>
二級緩存之查詢緩存：對普通屬性進行緩存。如果關聯的表發生了修改，那麼查詢緩存的生命週期也結束了。
在程序中必須手動啓用查詢緩存：query.setCacheable(true);
優化Hibernate
1、使用一對多的雙向關聯，儘量從多的一端維護。
2、不要使用一對一，儘量使用多對一。
3、配置對象緩存，不要使用集合緩存。
4、表字段要少，表關聯不要怕多，有二級緩存撐腰。
(1)一般情況下，關係數據模型與對象模型之間有哪些匹配關係（多選）
A)表對應類B)記錄對應對象C)表的字段對應類的屬性D)表之間的參考關係對應類之間的依賴關係
(2)以下關於SessionFactory的說法哪些正確？（多選）
A)對於每個數據庫事務，應該創建一個SessionFactory對象B)一個SessionFactory對象對應一個數據庫存儲源。C)SessionFactory是重量級的對象，不應該隨意創建。如果系統中只有一個數據庫存儲源，只需要創建一個。D)SessionFactory的load()方法用於加載持久化對象
(3)Customer類中有一個Set類型的orders屬性，用來存放Order訂單對象，在Customer.hbm.xml文件中，用哪個元素映射orders屬性？
A) B) C) D)<:property>
(4)元素有一個cascade屬性，如果希望Hibernate級聯保存集合中的對象，casecade屬性應該取什麼值？（單選）
A)noneB)saveC)deleteD)save-update
(5)以下哪些屬於Session的方法？
A)load()B)save()C)delete()D)update()E)open()F)close()
(6)以下程序的打印結果是什麼？（單選）
1. tx = session.beginTransaction();
2. Customer c1=(Customer)session.load(Customer.class,new Long(1));
3. Customer c2=(Customer)session.load(Customer.class,new Long(1));
4. System.out.println(c1==c2);
5. tx.commit();
6. session.close();
A)運行出錯，拋出異常B)打印falseC)打印true
(7)以下程序代碼對Customer的name屬性修改了兩次：
1. tx = session.beginTransaction();
2. Customer customer=(Customer)session.load(Customer.class,
3. new Long(1));
4. customer.setName(\"Jack\");
5. customer.setName(\"Mike\");
6. tx.commit();
執行以上程序，Hibernate需要向數據庫提交幾條update語句？（單選）
A)0 B)1 C)2 D)3
(8)在持久化層，對象分爲哪些狀態？（多選）
A)臨時狀態B)獨立狀態C)遊離狀態D)持久化狀態
(9)對於以下程序，Customer對象在第幾行變爲持久化狀態？（單選）
1. Customer customer=new Customer(); //line1
2. customer.setName(\"Tom\"); //line2
3. Session session1=sessionFactory.openSession(); //line3
4. Transaction tx1 = session1.beginTransaction(); //line4
5. session1.save(customer); //line4
6. tx1.commit(); //line5
7. session1.close(); //line6
A) line1 B)line2 C)line3 D)line4E)line5 F)line6
(10)對於以下程序，Customer對象在第幾行變爲遊離狀態？（單選）
1. Customer customer=new Customer(); //line1
2. customer.setName(\"Tom\"); //line2
3. Session session1=sessionFactory.openSession(); //line3
4. Transaction tx1 = session1.beginTransaction(); //line4
5. session1.save(customer); //line4
6. tx1.commit(); //line5
7. session1.close(); //line6
A) line1 B)line2 C)line3 D)line4E)line5 F)line6
(11)以下哪一種檢索策略利用了外連結查詢？（單選）
A)立即檢索 B)延遲檢索 C)迫切左外連結檢索
(12)假設對Customer類的orders集合採用延遲檢索策略，編譯或運行以下程序，會出現什麼情況（單選）
1. Session session=sessionFactory.openSession();
2. tx = session.beginTransaction();
3. Customer customer=(Customer)session.get(Customer.class,new Long(1));
4. tx.commit();
5. session.close();
6. Iterator orderIterator=customer.getOrders().iterator();
A)編譯出錯 B)編譯通過，並正常運行 C)編譯通過，但運行時拋出異常
(13)關於HQL與SQL，以下哪些說法正確？（多選）
A)HQL與SQL沒什麼差別B)HQL面向對象，而SQL操縱關係數據庫C)在HQL與SQL中，都包含select,insert,update,delete語句D)HQL僅用於查詢數據，不支持insert,update和delete語句
(14)事務隔離級別是由誰實現的？（單選）
A)Java應用程序 B)Hibernate C)數據庫系統 D)JDBC驅動程序
(15)悲觀鎖與樂觀鎖，哪個具有較好的併發性能？（單選）
A)悲觀鎖 B)樂觀鎖
答案：
(1)A,B,C (2)B,C (3)A (4)D(5)A,B,C,D,F (6)C (7)B (8)A,C,D (9)D (10)F (11)C (12)C (13)B,D(14)C (15)B
瞬時態(Transient)、 持久態(Persistent)、脫管態(Detached)。處於持久態的對象也稱爲PO(PersistenceObject)，瞬時對象和脫管對象也稱爲VO（Value Object）。
瞬時態
由new命令開闢內存空間的java對象，
eg. Person person = new Person(”amigo”, “女”);
如果沒有變量對該對象進行引用，它將被java虛擬機回收。
瞬時對象在內存孤立存在，它是攜帶信息的載體，不和數據庫的數據有任何關聯關係，在Hibernate中，可通過session的save()或 saveOrUpdate()方法將瞬時對象與數據庫相關聯，並將數據對應的插入數據庫中，此時該瞬時對象轉變成持久化對象。
持久態
處於該狀態的對象在數據庫中具有對應的記錄，並擁有一個持久化標識。如果是用hibernate的delete()方法，對應的持久對象就變成瞬時對象，因數據庫中的對應數據已被刪除，該對象不再與數據庫的記錄關聯。
當一個session執行close()或clear()、evict()之後，持久對象變成脫管對象，此時持久對象會變成脫管對象，此時該對象雖然具有數據庫識別值，但它已不在HIbernate持久層的管理之下。
持久對象具有如下特點：
1. 和session實例關聯；
2. 在數據庫中有與之關聯的記錄。
脫管態
當與某持久對象關聯的session被關閉後，該持久對象轉變爲脫管對象。當脫管對象被重新關聯到session上時，並再次轉變成持久對象。
脫管對象擁有數據庫的識別值，可通過update()、saveOrUpdate()等方法，轉變成持久對象。
脫管對象具有如下特點：
1. 本質上與瞬時對象相同，在沒有任何變量引用它時，JVM會在適當的時候將它回收；
2. 比瞬時對象多了一個數據庫記錄標識值。
Detached Object（遊離對象）可以傳遞到任何層直到表現層而不是用任何DTO(Data Transfer Objects). 然後你還可以重新把遊離對象賦給另外一個Session.
jdbc:手動
手動寫sql
delete、insert、update要將對象的值一個一個取出傳到sql中,不能直接傳入一個對象。
select:返回的是一個resultset，要從ResultSet中一行一行、一個字段一個字段的取出，然後封裝到一個對象中，不直接返回一個對象。
ibatis的特點:半自動化
sql要手動寫
delete、insert、update:直接傳入一個對象
select:直接返回一個對象
hibernate:全自動
不寫sql,自動封裝
delete、insert、update:直接傳入一個對象
select:直接返回一個對象
1、兩個表，子類重複父類的屬性。
2、一個表，子類父類共用一個表
<class name=”Users” table=”users”discriminator-value=”Users”>
<discriminator column=”DISCRIMINATOR_USERTYPE”type=”string”/>
<subclass name=”admin” discriminator-value=”admin”>
<propertyname=”adminRemark” column=”admin_remark” type=”string” />
</subclass>
</class>
3、兩個表，子類引用父類的主鍵，享用公共的字段或屬性。
<class name=”Users” table=”users”>
<id name=”userid” column=”USERID”type=”string”>
<generator class=”assigned”/>
</id>
<property name=”pwd” column=”pwd”type=”string” />
<joined-subclass name=”Guest” table=”guest”>
<key column=”USERID”/>
<propertyname=”guestRemark” column=”guest_remark” type=”string” />
</joined-subclass>
</class>
批量刪除
Query query=session.createQuery(”update”或”delete”);
query.executeUpdate();
1 個或多個屬性查詢:
Query query=session.createQuery(”select customername,customerid fromCustomer”)
List l=query.list();
For(int i=0;i<l.size();i++)
{
Obejct[] object=(Object[])l.get(i);
Object[0] object[1]
}
}
分組: “select count(*),productname from Product group by productname order byproductname”
取值與屬性一樣
配置的查詢,在*.hbm.xml中
<query name=”sql”>
<![CDATA[
from Product where productid=:productid
]]>
</query>
Query query=session.getNamedQuery(sql);
聯接1
”from Customer as customer join fetch customer.buySet”：將多的放到buySet屬性中，得出的結是Customer有一個，Buy有多個
聯接2
“from Customer as customer join customer.buySet”:得出的對象,customer與buy是1對1
子查詢:
”from Customer as customer where (select count(*) fromcustomer.buySet)>1″
Hibernate中Criteria 和DetachedCriteria的作用是什麼？
Criteriac=session.createCriteria(Customer.class);
//設置條件
c.add(Expression.ge(“字段名”,”值對象”))
ge:>=
gt:>
le:<=
lt:<
eq:=
//排序
c.addOrder(Order.asc(“字段名”))
//分頁
c.setFirstResult(1)//從第2行開始提取
c.setMaxResults(5)//返回5行
DetachedCriteria產生時不需要session
DetachedCriteria dc=DetachedCriteria.forClass(Customer.class)
Criteriac=Dc.getExecutableCriteria(session)
one-to-many
inverse:主控方，外鍵的關係有誰控制
inverse=false 是主控方，外鍵是由它控制的
inverse=true 是被控方，外鍵與它沒關係
要想實現主控方的控制必須將被控方作爲主控方的屬性
cascade:級聯
主表增從表增
主表修從表修
主表刪從表刪
lazy:延遲
lazy=false：一下將所有的內容取出，不延時(常用)
lazy=true：取出部分內容，其餘內容動態去取
通過get可以取出對方的所有內容
hibernate的核心類是什麼，它們的相互關係是什麼?重要的方法是什麼?
Configuration
SessionFactory
Session如下方法
Save
load
Update
Delete
Query q=CreateQuery(“from Customer wherecustomerName=:customerName”)
beginTransaction
close
Transaction
Commit()
在myeclipse加入hibernate環境的全過程是什麼?
1.Db-browers加入配置連接
2.新建工程
3.加入hibernate環境，指定*.hbm.xml及HibernateSessionFactory文件所在的位置
詳細內容參見以前寫的hibernate的第一個小例子
1.在數據庫中條件查詢速度很慢的時候,如何優化?
1.建索引
2.減少表之間的關聯
3.優化sql，儘量讓sql很快定位數據，不要讓sql做全表查詢，應該走索引,把數據量大的表排在前面
4.簡化查詢字段，沒用的字段不要，已經對返回結果的控制，儘量返回少量數據
[2.在hibernate中進行多表查詢,每個表中各取幾個字段,也就是說查詢出來的結果集並沒有一個實體類與之對應,如何解決這個問題?
解決方案一，按照Object[]數據取出數據，然後自己組bean
解決方案二，對每個表的bean寫構造函數，比如表一要查出field1,field2兩個字段，那麼有一個構造函數就是Bean(type1 filed1,type2 field2) ，然後在hql裏面就可以直接生成這個bean了。具體怎麼用請看相關文檔，我說的不是很清楚。
session.load()和session.get()的區別
Session.load/get方法均可以根據指定的實體類和id從數據庫讀取記錄，並返回與之對應的實體對象。其區別在於：
如果未能發現符合條件的記錄，get方法返回null，而load方法會拋出一個ObjectNotFoundException。
Load方法可返回實體的代理類實例，而get方法永遠直接返回實體類。
load方法可以充分利用內部緩存和二級緩存中的現有數據，而get方法則僅僅在內部緩存中進行數據查找，如沒有發現對應數據，將越過二級緩存，直接調用SQL完成數據讀取。
Session在加載實體對象時，將經過的過程：
首先，Hibernate中維持了兩級緩存。第一級緩存由Session實例維護，其中保持了Session當前所有關聯實體的數據，也稱爲內部緩存。而第二級緩存則存在於SessionFactory層次，由當前所有由本 SessionFactory構造的Session實例共享。出於性能考慮，避免無謂的數據庫訪問，Session在調用數據庫查詢功能之前，會先在緩存中進行查詢。首先在第一級緩存中，通過實體類型和id進行查找，如果第一級緩存查找命中，且數據狀態合法，則直接返回。
之後，Session會在當前“NonExists”記錄中進行查找，如果“NonExists”記錄中存在同樣的查詢條件，則返回null。 “NonExists”記錄了當前Session實例在之前所有查詢操作中，未能查詢到有效數據的查詢條件（相當於一個查詢黑名單列表）。如此一來，如果 Session中一個無效的查詢條件重複出現，即可迅速作出判斷，從而獲得最佳的性能表現。
對於load方法而言，如果內部緩存中未發現有效數據，則查詢第二級緩存，如果第二級緩存命中，則返回。
如在緩存中未發現有效數據，則發起數據庫查詢操作（Select SQL），如經過查詢未發現對應記錄，則將此次查詢的信息在“NonExists”中加以記錄，並返回null。
根據映射配置和Select SQL得到的ResultSet，創建對應的數據對象。
將其數據對象納入當前Session實體管理容器（一級緩存）。
執行Interceptor.onLoad方法（如果有對應的Interceptor）。
將數據對象納入二級緩存。
如果數據對象實現了LifeCycle接口，則調用數據對象的onLoad方法。
返回數據對象。
Hibernate的主鍵生成機制
1) assigned
主鍵由外部程序負責生成，無需Hibernate參與。
2) hilo
通過hi/lo 算法實現的主鍵生成機制，需要額外的數據庫表保存主鍵生成歷史狀態。
3) seqhilo
與hilo 類似，通過hi/lo算法實現的主鍵生成機制，只是主鍵歷史狀態保存在Sequence中，適用於支持Sequence的數據庫，如Oracle。
4) increment
主鍵按數值順序遞增。此方式的實現機制爲在當前應用實例中維持一個變量，以保存着當前的最大值，之後每次需要生成主鍵的時候將此值加1作爲主鍵。這種方式可能產生的問題是：如果當前有多個實例訪問同一個數據庫，那麼由於各個實例各自維護主鍵狀態，不同實例可能生成同樣的主鍵，從而造成主鍵重複異常。因此，如果同一數據庫有多個實例訪問，此方式必須避免使用。
5) identity
採用數據庫提供的主鍵生成機制。如DB2、SQL Server、MySQL中的主鍵生成機制。
6) sequence
採用數據庫提供的sequence 機制生成主鍵。如Oralce中的Sequence。
7) native
由Hibernate根據底層數據庫自行判斷採用identity、hilo、sequence其中一種作爲主鍵生成方式。
8) uuid.hex
由Hibernate基於128位唯一值產生算法生成16 進制數值（編碼後以長度32 的字符串表示）作爲主鍵。
9) uuid.string
與uuid.hex 類似，只是生成的主鍵未進行編碼（長度16）。在某些數據庫中可能出現問題（如PostgreSQL）。
10) foreign
使用外部表的字段作爲主鍵。一般而言，利用uuid.hex方式生成主鍵將提供最好的性能和數據庫平臺適應性。
這10中生成OID標識符的方法,increment 比較常用,把標識符生成的權力交給Hibernate處理.但是當同時多個Hibernate應用操作同一個數據庫,甚至同一張表的時候.就推薦使用identity 依賴底層數據庫實現,但是數據庫必須支持自動增長,當然針對不同的數據庫選擇不同的方法.如果你不能確定你使用的數據庫具體支持什麼的情況下.可以選擇用native 讓Hibernate來幫選擇identity,sequence,或hilo.
另外由於常用的數據庫，如Oracle、DB2、SQLServer、MySql 等，都提供了易用的主鍵生成機制（Auto-Increase 字段或者Sequence）。我們可以在數據庫提供的主鍵生成機制上，採用generator-class=native的主鍵生成方式。
不過值得注意的是，一些數據庫提供的主鍵生成機制在效率上未必最佳，大量併發insert數據時可能會引起表之間的互鎖。數據庫提供的主鍵生成機制，往往是通過在一個內部表中保存當前主鍵狀態（如對於自增型主鍵而言，此內部表中就維護着當前的最大值和遞增量），之後每次插入數據會讀取這個最大值，然後加上遞增量作爲新記錄的主鍵，之後再把這個新的最大值更新回內部表中，這樣，一次Insert操作可能導致數據庫內部多次表讀寫操作，同時伴隨的還有數據的加鎖解鎖操作，這對性能產生了較大影響。因此，對於併發Insert要求較高的系統，推薦採用uuid.hex 作爲主鍵生成機制
