hibernate(20170731)
1.導包：hibernate-distribution-3.5.6-Final/hibernate3.jar
hibernate-distribution-3.5.6-Final\lib\required里面所有的包必須的包
再導入log4j-1.2.16, slf4j-log4j12-1.6.1, mysql驅動的包
2.在做了國際化的說明文檔中找到hibernate.cfg.xml配置文件的相關內容，然后在src文件夾下面建立
hibernate.cfg.xml的總配置文件，然后復制相關內容并更改相關配置
3.創建實體類，并創建實體類與表的映射文件，并設置dtd約束
4.將映射文件配置到總配置文件（注意里面用的是斜杠）
5,如有需要創建hibernateUtil類，來獲得session工廠
對象的三種狀態瞬時態，持久態，托管態
對象被new出來，還沒有和session建立關系的時候，那么此時就是瞬時態，和session建立關系此時就是持久態，和session沒有建立關系，但是數據庫有相應的記錄，就是托管態
getCurrentSession()得到同一個session對象
openSession();每次都會創建一個session對象
load和get的區別;
load方式，類似懶加載，不會立即發送sql去查詢，只有查詢除了id以外的數據，才會發送sql語句，而get是全部查詢，
/get方式去取不存在的數據，會返回一個null
//load方式去取不存在的數據，會報錯
以下操作都要在事務中進行
添加操作
session.save(user); 返回的是剛添加進去的ID
刪除操作
User user=new User(); 需要先new對象再進行刪除
user.setId(5);
session.delete(user);
更新操作
User user=(User)session.get(User.class, 1); //獲得對象再進行修改
user.setName("強哥");
session.update(user);
User user=new User(); //new對象進行修改
user.setId(2);
user.setName("xiaohon");
session.update(user);
查詢操作：
單個查詢get或者load
查詢多個
Query query = session.createQuery("from User"); //HQL語句
List<User> list = query.list();
一對多（兩張表情況）：
[圖片上傳中。。。（1）]
[圖片上傳中。。。（2）]
配置過程：
1,從一開始，用set標簽，name為set對象的引用，里面加上key標簽，里面column屬性為外鍵，one-to-many的class為多的那一方類名
2。從多開始，直接配置many-to-one ，name為本類中一的一方的引用，里面的column標簽name屬性為外鍵
這樣存儲先把多放進一的set集合里面，無法直接將訂單依賴著客戶保存進入數據庫，那么這些對象都需要用session保存一次變為持久態，才能讓訂單依賴客戶保存進入數據庫，并且是這樣的執行流程，通過session先保存訂單，再保存客戶，保存完客戶再更新訂單的id，這樣的話sql語句較多，影響效率
inverse 管理關系由一的一方交給多的一方，不寫默認false由一的一方管理，由多的一方來管理后，就不需要打印后面的那兩句更新ID的語句了，效率提高了
那么此時的關系由多的一方來維護，那么此時要注意inverse加到哪里和測試類聯系起來
查詢的時候不會級聯查詢主要是為了資源和性能的考慮，采用的是懶加載，用到的時候才會去加載
save-update：一的一方保存，同時保存多的一方
delete：刪除一的一方，同時刪除多的一方
delete-orphan：孤兒刪除，解除一和多的關系，同時將多的一方刪除
如果需要配置多項，使用逗號分隔。<set cascade="save-update,delete">
all : save-update 和 delete 整合
all-delete-orphan : 三個整合
如果我們在刪除的時候，刪除一的一方時，由于級聯刪除的關系，會將多的一方也刪除，但是我們只想讓一的一方刪除，不想將多的一方刪除，那么此時可以通過一來查詢與之相關的多，然后將他們的外鍵設置為null，再將級聯刪除配置刪除才能進行刪除操作。
commit(); 提交事務；關閉session clear();清空session
多對多的表關系：
多對多不用在實體類表中添加外鍵字段，而是創建中間表來生成外鍵字段，并且多對多的配置兩邊都是相同的，用配置文件自動創建中間表的時候，可能會無法添加進入數據，要用原始的save方式，添加一次數據后才會能夠添加進入數據
[圖片上傳中。。。（3）]
抓取策略：
get和load的區別，都是從數據庫獲得數據后封裝成的對象
但是load是懶加載，get不是，load是要用到除了id以外的數據才會主動去加載，這樣有利于提高性能
抓取策略（要么加在類上面，要么加在set上面，默認true，關閉懶加載將其置為false即可）只能影響load，不能影響get ；
lazy="extra"，極其懶惰（延遲），先查詢客戶select， 如果只需要擁有的訂單數，使用聚合函數（不查詢詳情）
[圖片上傳中。。。（4）]
[圖片上傳中。。。（5）]
[圖片上傳中。。。（6）]
HQL查詢語句：
from entityname 查詢全部
只有jdbc比較特殊是從1開始的，其他的都是從0開始的
from entityname where id =? 查詢單個 uniqueResult();
綁定參數query.setinteger（0,5）；從0開始
from entityname where id =：id；
綁定參數query.setinteger（“id”,5）；從0開始
select c.name from entityanme c 查詢部分字段 返回字符串
select c.id,c.name from entityname c 查詢兩個字段，返回object數組
select new entity(c.name,c.id) from entityname c 和上面的一樣，要有對應得構造方法
from entityname c order by c.id; 排序
from entityname c order by c.id desc; 降序 排序
分頁
[圖片上傳中。。。（7）]
聚合函數：
總條數：select count(*) from entityname；
連接查詢：
from entityname1,entityname2; 笛卡爾積，用途不大
隱式內連接：
from Custom c,OrderInfo o where o.custom=c; 外鍵關聯
hibernate會參照映射文件查找數據庫
顯示內連接
from Customer c inner join c.orderSet
迫切內連接
from Customer c inner join fetch c.orderSet,返回對象不是數組
distinct c 去重復
左連接
QBC: 標準查詢
QBC運算符
含義
=
Restrictions.eq()
<>
Restrictions.ne()
Restrictions.gt()
=
Restrictions.ge()
<
Restrictions.lt()
<=
Restrictions.le()
is null
Restrictions.isnull()
is not null
Restrictions.isNotNull()
like
Restrictions.like()
and
Restrictions.and()
and
Restrictions.conjunction()
or
Restrictions.or()
or
Restrictions.disjunction()
not
Restrictions.not()
in(列表)
Restrictions.in()
[圖片上傳中。。。（8）]
@Test
public void qbc1() {
SessionFactory sessionFactory= HibernateUtil.getSessionFactory();
Session session=sessionFactory.getCurrentSession();
session.beginTransaction();
Criteria criteria=session.createCriteria(OrderInfo.class);
criteria.setFirstResult(0);
criteria.setMaxResults(2);
List<Customer> list=criteria.list();
System.out.println(list);
session.getTransaction().commit();
}
集合查詢：
Criteria criteria=session.createCriteria(Customer.class);
List<Customer> list=criteria.list();
System.out.println(list);
分頁查詢
Criteria criteria=session.createCriteria(OrderInfo.class);
criteria.setFirstResult(0);
criteria.setMaxResults(2);
List<Customer> list=criteria.list();
排序查詢
Criteria criteria=session.createCriteria(Customer.class);
criteria.addOrder(Order.desc("id")); asc也行
List<Customer> list=criteria.list();
條件/多條件組合查詢
Criteria criteria=session.createCriteria(OrderInfo.class);
//下面的條件可以組合起來求得交集的集合
criteria.add(Restrictions.eq("address", "南山"));//準確查詢
criteria.add(Restrictions.like("address", "%山"));//模糊查詢，%可以加在任何位置
criteria.add(Restrictions.gt("id",2)); //數字查詢
List<Customer> list=criteria.list();
采用集合的方式進行多條件組合查詢
Criteria criteria=session.createCriteria(OrderInfo.class);
//下面的條件可以組合起來求得交集的集合
HashMap<String,String> hashmap=new HashMap<>();
hashmap.put("detail", "訂單2");
hashmap.put("address","南山");
criteria=criteria.add(Restrictions.allEq(hashmap));
List<OrderInfo> list=criteria.list();
模糊查詢的一種模式：
Criteria criteria=session.createCriteria(OrderInfo.class);
criteria.add(Restrictions.ge("id",16));
criteria.add(Restrictions.like("address", "寶安", MatchMode.EXACT));
List<OrderInfo> list=criteria.list();
MatchMode.START：字符串在最前面的位置.相當于"like 'key%'"
MatchMode.END：字符串在最后面的位置.相當于"like '%key'"
MatchMode.ANYWHERE：字符串在中間匹配.相當于"like '%key%'"
MatchMode.EXACT：字符串精確匹配.相當于"like 'key'"
in的范圍查詢：
Criteria criteria=session.createCriteria(OrderInfo.class);
criteria.add(Restrictions.in("address",new String[]{"寶安","南山"}));
List<OrderInfo> list=criteria.list();
and查詢：
Criteria criteria=session.createCriteria(OrderInfo.class);
Criterion c1=Restrictions.like("address", "%山", MatchMode.END);
Criterion c2=Restrictions.gt("id", 16);
criteria.add(Restrictions.and(c1,c2));
List<OrderInfo> list=criteria.list();
or查詢：
Criteria criteria=session.createCriteria(OrderInfo.class);
Criterion c1=Restrictions.like("address", "安", MatchMode.ANYWHERE);
Criterion c2=Restrictions.eq("id", 15);
criteria.add(Restrictions.or(c1,c2));
List<OrderInfo> list=criteria.list();
聚合函數求總條數
Criteria criteria=session.createCriteria(OrderInfo.class);
ProjectionList project=Projections.projectionList();
project.add(Projections.rowCount());
criteria.setProjection(project);
Long a=(Long)criteria.uniqueResult();
System.out.println(a);
分組查詢：
Criteria criteria=session.createCriteria(OrderInfo.class);
ProjectionList project=Projections.projectionList();
project.add(Projections.groupProperty("address"));
criteria.setProjection(project);
List<OrderInfo> list=criteria.list();
去重查詢：
Criteria criteria=session.createCriteria(Customer.class);
criteria.createAlias("hashSet", "h");
criteria.setResultTransformer(criteria.DISTINCT_ROOT_ENTITY);
List<OrderInfo> list=criteria.list();
System.out.println(list);
左外連接
Criteria criteria=session.createCriteria(Customer.class);
criteria.createAlias("hashSet", "h", CriteriaSpecification.LEFT_JOIN);
criteria.setResultTransformer(criteria.DISTINCT_ROOT_ENTITY);
List<OrderInfo> list=criteria.list();
返回一個對象數組
Criteria criteria=session.createCriteria(Customer.class);
criteria.createAlias("hashSet", "h");
criteria.setResultTransformer(CriteriaSpecification.PROJECTION);
List<Object[]> list=criteria.list();
離線查詢：
離線查詢
- 就是在session還沒創建的時候，就先組裝好查詢的相關條件
- 然后再傳遞給dao層去執行
public void qbc10() {
DetachedCriteria detachedCriteria=DetachedCriteria.forClass(Customer.class);
detachedCriteria.createAlias("hashSet", "h");
detachedCriteria.setResultTransformer(CriteriaSpecification.PROJECTION);
SessionFactory sessionFactory=HibernateUtil.getSessionFactory();
Session session=sessionFactory.getCurrentSession();
session.beginTransaction();
Criteria criteria=detachedCriteria.getExecutableCriteria(session);
List<Object[]> list=criteria.list();
for (Object[] objects : list) {
System.out.println(objects[0]+":"+objects[1]);
}
session.getTransaction().commit();
}
二級緩存：
a) 一級緩存：session級別緩存，在一次請求中共享數據。
b) 二級緩存：sessionFactory級別緩存，整個應用程序共享一個會話工廠，共享一個二級緩存。
導入jar包：ehcache-1.5.0.jar/ commons-logging.jar/ backport-util-concurrent.jar開啟二級緩存確定二級緩存提供商確定需要緩存內容
1> 配置需要緩存的類
2> 配置需要緩存的集合
配置ehcache自定義配置文件
[圖片上傳中。。。（9）]
注意在設置需要緩存的內容和權限時要放在映射文件的下面這樣的順序
查詢二級緩存：
先配置<property name="hibernate.cache.use_query_cache">true</property>
public void query() {
SessionFactory sessionFactory=HibernateUtil.getSessionFactory();
Session session=sessionFactory.getCurrentSession();
session.beginTransaction();
Query query=session.createQuery("from Customer");
query.setCacheable(true); 每次使用時先開啟
List<Customer> l=query.list();
System.out.println(l);
session.getTransaction().commit();
Session session1=sessionFactory.getCurrentSession();
session1.beginTransaction();
Query query1=session1.createQuery("from Customer");
query1.setCacheable(true); 每次使用時先開啟
List<Customer> l1=query1.list();
System.out.println(l1);
session1.getTransaction().commit();
sessionFactory.close();
}
hihernate的批處理：
采用這樣的配置
[圖片上傳中。。。（10）]
那么程序就會采用in的方式進行這種范圍的查詢
但是hibernate還是建議我們使用jdbc api進行查詢，這樣速度比較快
采用實現work（）；接口來進行批處理，比hibernate自帶的批處理快
session.doWork(new Work() {
@Override
public void execute(Connection connection) throws SQLException {
PreparedStatement ps=connection.prepareStatement("insert into user(name)values(?)");
for(int i=0;i<10000;i++){
ps.setString(1, "小明"+i);
ps.addBatch();
if(i%500==0){
ps.executeBatch();
}}
}
});
session.getTransaction().commit();
long end=System.currentTimeMillis();
System.out.println(end-start);
}
hibernate采用c3p0連接池
1.導包C:\Users\Administrator\Desktop\hibernate-distribution-3.5.6-Final\lib\optional\c3p0
2.配置配置文件
<property name="hibernate.connection.provider_class">org.hibernate.connection.C3P0ConnectionProvider</property>
<property name="hibernate.c3p0.max_size">3</property>
<property name="hibernate.c3p0.mix_size">3</property>
<property name="hibernate.c3p0.timeout ">4000</property>
設置事務的隔離級別：
<property name="hibernate.connection.isolation">4</property>
事務的特性：
⑴ 原子性（Atomicity）
原子性是指事務包含的所有操作要么全部成功，要么全部失敗回滾，這和前面兩篇博客介紹事務的功能是一樣的概念，因此事務的操作如果成功就必須要完全應用到數據庫，如果操作失敗則不能對數據庫有任何影響。
⑵ 一致性（Consistency）
一致性是指事務必須使數據庫從一個一致性狀態變換到另一個一致性狀態，也就是說一個事務執行之前和執行之后都必須處于一致性狀態。
拿轉賬來說，假設用戶A和用戶B兩者的錢加起來一共是5000，那么不管A和B之間如何轉賬，轉幾次賬，事務結束后兩個用戶的錢相加起來應該還得是5000，這就是事務的一致性。
⑶ 隔離性（Isolation）
隔離性是當多個用戶并發訪問數據庫時，比如操作同一張表時，數據庫為每一個用戶開啟的事務，不能被其他事務的操作所干擾，多個并發事務之間要相互隔離。
即要達到這么一種效果：對于任意兩個并發的事務T1和T2，在事務T1看來，T2要么在T1開始之前就已經結束，要么在T1結束之后才開始，這樣每個事務都感覺不到有其他事務在并發地執行。
關于事務的隔離性數據庫提供了多種隔離級別，稍后會介紹到。
⑷ 持久性（Durability）
持久性是指一個事務一旦被提交了，那么對數據庫中的數據的改變就是永久性的，即便是在數據庫系統遇到故障的情況下也不會丟失提交事務的操作。
例如我們在使用JDBC操作數據庫時，在提交事務方法后，提示用戶事務操作完成，當我們程序執行完成直到看到提示后，就可以認定事務以及正確提交，即使這時候數據庫出現了問題，也必須要將我們的事務完全執行完成，否則就會造成我們看到提示事務處理完畢，但是數據庫因為故障而沒有執行事務的重大錯誤。
以上介紹完事務的四大特性(簡稱ACID)，現在重點來說明下事務的隔離性，當多個線程都開啟事務操作數據庫中的數據時，數據庫系統要能進行隔離操作，以保證各個線程獲取數據的準確性，在介紹數據庫提供的各種隔離級別之前，我們先看看如果不考慮事務的隔離性，會發生的幾種問題：
1，臟讀
臟讀是指在一個事務處理過程里讀取了另一個未提交的事務中的數據。
當一個事務正在多次修改某個數據，而在這個事務中這多次的修改都還未提交，這時一個并發的事務來訪問該數據，就會造成兩個事務得到的數據不一致。例如：用戶A向用戶B轉賬100元，對應SQL命令如下
update account set money=money+100 where name=’B’; (此時A通知B) update account set money=money - 100 where name=’A’;
當只執行第一條SQL時，A通知B查看賬戶，B發現確實錢已到賬（此時即發生了臟讀），而之后無論第二條SQL是否執行，只要該事務不提交，則所有操作都將回滾，那么當B以后再次查看賬戶時就會發現錢其實并沒有轉。
2，不可重復讀
不可重復讀是指在對于數據庫中的某個數據，一個事務范圍內多次查詢卻返回了不同的數據值，這是由于在查詢間隔，被另一個事務修改并提交了。
例如事務T1在讀取某一數據，而事務T2立馬修改了這個數據并且提交事務給數據庫，事務T1再次讀取該數據就得到了不同的結果，發送了不可重復讀。
不可重復讀和臟讀的區別是，臟讀是某一事務讀取了另一個事務未提交的臟數據，而不可重復讀則是讀取了前一事務提交的數據。
在某些情況下，不可重復讀并不是問題，比如我們多次查詢某個數據當然以最后查詢得到的結果為主。但在另一些情況下就有可能發生問題，例如對于同一個數據A和B依次查詢就可能不同，A和B就可能打起來了……
3，虛讀(幻讀)
幻讀是事務非獨立執行時發生的一種現象。例如事務T1對一個表中所有的行的某個數據項做了從“1”修改為“2”的操作，這時事務T2又對這個表中插入了一行數據項，而這個數據項的數值還是為“1”并且提交給數據庫。而操作事務T1的用戶如果再查看剛剛修改的數據，會發現還有一行沒有修改，其實這行是從事務T2中添加的，就好像產生幻覺一樣，這就是發生了幻讀。
幻讀和不可重復讀都是讀取了另一條已經提交的事務（這點就臟讀不同），所不同的是不可重復讀查詢的都是同一個數據項，而幻讀針對的是一批數據整體（比如數據的個數）。
現在來看看MySQL數據庫為我們提供的四種隔離級別：
① Serializable (串行化)：可避免臟讀、不可重復讀、幻讀的發生。
② Repeatable read (可重復讀)：可避免臟讀、不可重復讀的發生。
③ Read committed (讀已提交)：可避免臟讀的發生。
④ Read uncommitted (讀未提交)：最低級別，任何情況都無法保證。
以上四種隔離級別最高的是Serializable級別，最低的是Read uncommitted級別，當然級別越高，執行效率就越低。像Serializable這樣的級別，就是以鎖表的方式(類似于Java多線程中的鎖)使得其他的線程只能在鎖外等待，所以平時選用何種隔離級別應該根據實際情況。在MySQL數據庫中默認的隔離級別為Repeatable read (可重復讀)。
在MySQL數據庫中，支持上面四種隔離級別，默認的為Repeatable read (可重復讀)；而在Oracle數據庫中，只支持Serializable (串行化)級別和Read committed (讀已提交)這兩種級別，其中默認的為Read committed級別。
在MySQL數據庫中查看當前事務的隔離級別：
select @@tx_isolation;
在MySQL數據庫中設置事務的隔離 級別：
set [glogal | session] transaction isolation level 隔離級別名稱; set tx_isolation=’隔離級別名稱;’
例1：查看當前事務的隔離級別：
[圖片上傳中。。。（11）]
例2：將事務的隔離級別設置為Read uncommitted級別：
[圖片上傳中。。。（12）]
或：
[圖片上傳中。。。（13）]
記住：設置數據庫的隔離級別一定要是在開啟事務之前！
如果是使用JDBC對數據庫的事務設置隔離級別的話，也應該是在調用Connection對象的setAutoCommit(false)方法之前。調用Connection對象的setTransactionIsolation(level)即可設置當前鏈接的隔離級別，至于參數level，可以使用Connection對象的字段：
[圖片上傳中。。。（14）]
在JDBC中設置隔離級別的部分代碼：
[圖片上傳中。。。（15）]
后記：隔離級別的設置只對當前鏈接有效。對于使用MySQL命令窗口而言，一個窗口就相當于一個鏈接，當前窗口設置的隔離級別只對當前窗口中的事務有效；對于JDBC操作數據庫來說，一個Connection對象相當于一個鏈接，而對于Connection對象設置的隔離級別只對該Connection對象有效，與其他鏈接Connection對象無關。
樂觀鎖和悲觀鎖
a) 悲觀鎖(數據庫提供實現) . 悲觀的認為認為一定發生別人要修改我使用的數據. 那我就可以為我讀取的數據加鎖.
采用這樣的方式對正在操作的數據上鎖，在本線程提交事務之前，其他線程要想操作這個數據必須要等到當前線程操作完了并且提交事務時候才能操作那個數據
User user=(User) session.get(User.class, 20, LockOptions.UPGRADE); 給id為20的user的數據上鎖
b)樂觀鎖，樂觀鎖(Optimistic Lock), 顧名思義，就是很樂觀，每次去拿數據的時候都認為別人不會修改，所以不會上鎖，但是在更新的時候會判斷一下在此期間別人有沒有去更新這個數據，可以使用版本號等機制。
做法：在類里面添加一個Integer類型的version屬性，然后在配置文件里面添加一個version配置，對應的表也要添加一個version字段<version name="version" />,這個標簽必須加在id之后
它提交的時候主要是對比version的值，如果這個值和當時取出來的不一致就會提交失敗，如果能夠提交成功那么它就會將那個version的值加1。
在使用新版的hibernate的時候在獲得sessionfactory的時候推薦使用這個工具類，新版的沒有hibernate3.jar這個jar包，把必須的包導進去就行了
public class HibernateUtil {
private static final SessionFactory sessionFactory = buildSessionFactory();
private static SessionFactory buildSessionFactory() {
try {
Configuration cfg = new Configuration().configure();
StandardServiceRegistry serviceRegistry = new StandardServiceRegistryBuilder()
.applySettings(cfg.getProperties()).build();
SessionFactory sessionFactory = cfg.buildSessionFactory(serviceRegistry);
return sessionFactory;
}
catch (Throwable ex) {
// Make sure you log the exception, as it might be swallowed
System.err.println("Initial SessionFactory creation failed." + ex);
throw new ExceptionInInitializerError(ex);
}
}
public static SessionFactory getSessionFactory() {
return sessionFactory;
}
}
注解實現映射關系：
[圖片上傳中。。。（16）]
[圖片上傳中。。。（17）]
[圖片上傳中。。。（18）]
[圖片上傳中。。。（19）]
[圖片上傳中。。。（20）]
使用注解的時候需要更換獲得sessionFactory的方式，采用注解的方式
package com.qianfeng.forum.common;
import org.hibernate.SessionFactory;
import org.hibernate.cfg.AnnotationConfiguration;
public class HibnateUtils {
private static final SessionFactory sessionFactory = buildSessionFactory();
private static SessionFactory buildSessionFactory() {
try {
//return new Configuration().configure().buildSessionFactory();
return new AnnotationConfiguration().configure().buildSessionFactory();
}
catch (Throwable ex) {
System.err.println("Initial SessionFactory creation failed." + ex);
throw new ExceptionInInitializerError(ex);
}
}
public static SessionFactory getSessionFactory() {
return sessionFactory;
}
}
采用攔截器
作用：控制session的關閉時機，等頁面加載完數據之后再關閉session
@Override
public void doFilter(ServletRequest request, ServletResponse response, FilterChain chain)
throws IOException, ServletException {
SessionFactory factory = HibnateUtils.getSessionFactory();
Session session = factory.getCurrentSession();
Transaction transaction = null;
try {
transaction = session.beginTransaction();
// 放行
chain.doFilter(request, response);// action--index.jsp
//
transaction.commit();
} catch (Exception e) {
e.printStackTrace();
if (transaction != null) {
transaction.rollback();
}
}
}
