非本人總結(jié)的筆記九串，抄點(diǎn)筆記復(fù)習(xí)復(fù)習(xí)重挑。感謝傳智博客及黑馬程序猿

記筆記啊記筆記

Hibernate的查詢操作

Hibernate的查詢方式概述

（1）導(dǎo)航對(duì)象圖檢索方式

? 根據(jù)已經(jīng)加載的對(duì)象導(dǎo)航到其他對(duì)象

以用戶和訂單為例：查詢出一個(gè)用戶，查詢這個(gè)用戶的所有訂單阱驾，直接得到用戶的訂單集合

（2）OID檢索方式

? 按照對(duì)象的OID來檢索對(duì)象

User user = (User) session.get(User.class, 2);

（3）HQL檢索方式

? 使用面向?qū)ο蟮腍QL查詢語言

（4）QBC檢索方式

? 使用QBC（Query By Criterial）API來檢索對(duì)象拘泞，這種API封裝了基于字符串形式的查詢語言，提供了更加面向?qū)ο蟮牟樵冋Z言叁扫。

（5）本地SQL檢索方式

? 使用本地?cái)?shù)據(jù)庫的SQL查詢語句

導(dǎo)航對(duì)象圖檢索方式

查詢出一個(gè)用戶三妈，查詢這個(gè)用戶的所有訂單，直接得到用戶的訂單集合

Customer customer = (Customer) session.get(Customer.class, 1);
Set<Orders> sets = customer.getSetOrders();
System.out.println(sets);

☆HQL檢索方式（查詢數(shù)據(jù)庫數(shù)據(jù)--重點(diǎn)）

HQL VS SQL

HQL查詢語句（操作實(shí)體類）

? 是面向?qū)ο蟮哪澹琀ibernate負(fù)責(zé)解析HQL語句畴蒲，然后根據(jù)對(duì)象-關(guān)系映射文件中的映射信息，把HQL查詢語句翻譯成相應(yīng)的SQL語句对室。HQL查詢語句中的主體是域?qū)ο笾械念惣邦惖膶傩浴?/p>

SQL查詢語句

? 是關(guān)系數(shù)據(jù)庫綁定在一起的模燥，SQL查詢語句中主體是數(shù)據(jù)庫表及表的字段

HQL語句創(chuàng)建Query對(duì)象
調(diào)用session里面的方法 createQuery(“HQL語句”)

package cn.itcast.hibernate.test;

import java.util.Arrays;
import java.util.List;

import org.hibernate.Query;
import org.hibernate.SQLQuery;
import org.hibernate.Session;
import org.hibernate.Transaction;
import org.junit.Test;

import cn.itcast.entity.User;
import cn.itcast.utils.HibernateUtils;

/**
 * 實(shí)現(xiàn)hibernate的crud的操作
 */
public class TestDemo2 {

    //hql查詢
    @Test
    public void testHQL() {
        Session session = null;
        Transaction tx = null;
        try {
            session = HibernateUtils.getSession();
            tx = session.beginTransaction();
            
            //創(chuàng)建query對(duì)象
            Query query = session.createQuery("from User");
            //調(diào)用query里面list方法返回list集合
            List<User> list = query.list();
            for (User user : list) {
                System.out.println(user);
            }
            
            tx.commit();
        }catch(Exception e) {
            tx.rollback();
        }finally {
            session.close();
        }   
    }
}

簡單查詢

查詢表中所有記錄

//使用Session創(chuàng)建Query對(duì)象
Query query = session.createQuery("from Customer");
//調(diào)用query里面的list方法
List<Customer> list = query.list();
for (Customer customer : list) {
    System.out.println(customer);
}

hql支持方法鏈編程

別名查詢

//使用Session創(chuàng)建Query對(duì)象
//c.cid 不是表字段名稱，而是實(shí)體類屬性名稱
Query query = session.createQuery("from Customer c where c.cid = 1");

排序查詢

asc 升序 desc降序

//對(duì)Customer表里面的數(shù)據(jù)掩宜，按照cid進(jìn)行升序排序
Query query = session.createQuery("from Customer c order by c.cid asc");
Query query = session.createQuery("from Customer c order by c.cid desc");

分頁查詢

查詢表里的幾條數(shù)據(jù)

select * from orders limit 0, 3;

0：記錄開始位置

3：獲取記錄數(shù)

開始位置 = （當(dāng)前頁 - 1） * 每頁記錄數(shù)

//查詢orders表里面的前四條記錄數(shù)
Query query = session.createQuery("from orders");

//設(shè)置開始位置
query.setFirstResult(0);
//設(shè)置獲取幾條記錄
query.setMaxResults(4);

唯一對(duì)象查詢

根據(jù)對(duì)象查詢這條記錄蔫骂。

比如根據(jù)cid查詢記錄，調(diào)用get方法實(shí)現(xiàn)牺汤，返回一條記錄辽旋，應(yīng)該是對(duì)象形式，使用對(duì)象接收數(shù)據(jù)

Query query = session.createQuery("from Customer c where c.cid = 2");

//使用對(duì)象接收返回?cái)?shù)據(jù)
Customer customer = query.uniqueResult();

條件查詢

第一種方式：根據(jù)參數(shù)位置傳遞參數(shù)值

Query query = session.createQuery("from Customer c where c.cid = ? and c.cname = ?");
//設(shè)置參數(shù)
//setParameter設(shè)置參數(shù)
//第一個(gè)參數(shù)：？位置补胚，從0開始
//第二個(gè)參數(shù)：參數(shù)值
query.setParameter(0, 1);
query.setParameter(1, "楊過");

第二種方式：根據(jù)參數(shù)的名稱傳遞參數(shù)值

Query query = session.createQuery("from Customer c where c.cid = :ccid and c.cname = :ccname");

//setParameter設(shè)置參數(shù)
//第一個(gè)參數(shù)：后面的名稱
//第二個(gè)參數(shù)：值
query.setParameter("ccid", 2);
query.setParameter("ccname", "郭靖");

代碼實(shí)現(xiàn)

package cn.itcast.hibernate.test;

import java.util.List;

import org.hibernate.Query;
import org.hibernate.Session;
import org.hibernate.Transaction;
import org.junit.Test;

import cn.itcast.onetomany.Customer;
import cn.itcast.onetomany.Orders;
import cn.itcast.utils.HibernateUtils;
/**
 * 演示hql操作
 */
public class HibernateHQLDemo1 {
    
    //6.(2)根據(jù)參數(shù)名稱傳遞參數(shù)值
    @Test
    public void testSelect7() {
        Session session = null;
        Transaction tx = null;
        try {
            //獲取到session
            session = HibernateUtils.getSession();
            //開啟事務(wù)
            tx = session.beginTransaction();
            
            //查詢cid=2并且cname=尹志平的記錄  
            Query query = 
                    session.createQuery("from Customer c where c.cid=:ccid and c.cname=:ccname");
            //設(shè)置參數(shù)值
            //setParameter有兩個(gè)參數(shù)
            //第一個(gè)參數(shù)  冒號(hào):后面的名稱
            //第二個(gè)參數(shù)  表里具體的值
            query.setParameter("ccid", 2);
            query.setParameter("ccname", "尹志平");
            
            List<Customer> list = query.list();
            System.out.println(list);
            //提交事務(wù)
            tx.commit();
        }catch(Exception e) {
            e.printStackTrace();
            tx.rollback();
        } finally {
            session.close();
        }
    }
    
    //6.(1)根據(jù)參數(shù)的位置傳遞參數(shù)值
    @Test
    public void testSelect6() {
        Session session = null;
        Transaction tx = null;
        try {
            //獲取到session
            session = HibernateUtils.getSession();
            //開啟事務(wù)
            tx = session.beginTransaction();
            
            //查詢cid=1 并且cname=楊過的記錄
            Query query = 
                    session.createQuery("from Customer c where c.cid=? and c.cname=?");
            //設(shè)置參數(shù)值
            //類型通用setParameter兩個(gè)參數(shù)  
            //******第一個(gè)參數(shù)：固该？位置，開始位置從 0 開始
            //第二個(gè)參數(shù)：具體的參數(shù)值   表里數(shù)據(jù)值
            query.setParameter(0, 1);
            query.setParameter(1, "楊過");
            
            List<Customer> list = query.list();
            System.out.println(list);
            //提交事務(wù)
            tx.commit();
        }catch(Exception e) {
            e.printStackTrace();
            tx.rollback();
        } finally {
            session.close();
        }
    }
    
    
    //5.唯一對(duì)象查詢
    @Test
    public void testSelect5() {
        Session session = null;
        Transaction tx = null;
        try {
            //獲取到session
            session = HibernateUtils.getSession();
            //開啟事務(wù)
            tx = session.beginTransaction();
            
            //查詢cid=2的記錄
            Query query = session.createQuery("from Customer c where c.cid=2");
            //使用對(duì)象接收返回?cái)?shù)據(jù)
            Customer c = (Customer) query.uniqueResult();
            
            System.out.println(c);
            //提交事務(wù)
            tx.commit();
        }catch(Exception e) {
            e.printStackTrace();
            tx.rollback();
        } finally {
            session.close();
        }
    }
        
    //4.分頁查詢
    @Test
    public void testSelect4() {
        Session session = null;
        Transaction tx = null;
        try {
            //獲取到session
            session = HibernateUtils.getSession();
            //開啟事務(wù)
            tx = session.beginTransaction();
            
            //查詢orders表里面前四條記錄
            Query query = session.createQuery("from Orders");
            
            //設(shè)置開始位置
            query.setFirstResult(4);
            //設(shè)置獲取幾條記錄
            query.setMaxResults(4);
            
            List<Orders> list = query.list();
            for (Orders orders : list) {
                System.out.println(orders);
            }
            //提交事務(wù)
            tx.commit();
        }catch(Exception e) {
            e.printStackTrace();
            tx.rollback();
        } finally {
            session.close();
        }
    }
    
    //3.排序查詢
    @Test
    public void testSelect3() {
        Session session = null;
        Transaction tx = null;
        try {
            //獲取到session
            session = HibernateUtils.getSession();
            //開啟事務(wù)
            tx = session.beginTransaction();
            
            //對(duì)customer表里面的數(shù)據(jù)糖儡，按照cid進(jìn)行升序排列
            //Query query = session.createQuery("from Customer c order by c.cid asc");
            //對(duì)customer表里面的數(shù)據(jù)伐坏，按照cid進(jìn)行降序排列
            Query query = session.createQuery("from Customer c order by c.cid desc");
            //調(diào)用query里面list方法
            List<Customer> list = query.list();
            for (Customer customer : list) {
                System.out.println(customer);
            }
            //提交事務(wù)
            tx.commit();
        }catch(Exception e) {
            e.printStackTrace();
            tx.rollback();
        } finally {
            session.close();
        }
    }
    
    //2.演示別名查詢
    @Test
    public void testSelect2() {
        Session session = null;
        Transaction tx = null;
        try {
            //獲取到session
            session = HibernateUtils.getSession();
            //開啟事務(wù)
            tx = session.beginTransaction();
            
            //使用session創(chuàng)建query對(duì)象   c是別名
            //c.cid ： 不是表字段名稱，而是實(shí)體類屬性名稱 
            //建議實(shí)體類屬性名稱與表字段名一致
            Query query = session.createQuery("from Customer c where c.cid=1");
            
            //調(diào)用query里面list方法
            List<Customer> list = query.list();
            for (Customer customer : list) {
                System.out.println(customer);
            }
            //提交事務(wù)
            tx.commit();
        }catch(Exception e) {
            e.printStackTrace();
            tx.rollback();
        } finally {
            session.close();
        }
    }
    
    
    //1.簡單查詢
    //查詢customer表里面的所有數(shù)據(jù)
    @Test
    public void testSelect1() {
        Session session = null;
        Transaction tx = null;
        try {
            //獲取到session
            session = HibernateUtils.getSession();
            //開啟事務(wù)
            tx = session.beginTransaction();
            
            //使用session創(chuàng)建query對(duì)象   from后面是實(shí)體類名稱
            Query query = session.createQuery("from Customer");
            //方法鏈編程
            List<Customer> list1 = session.createQuery("from Customer").list();
            
            //調(diào)用query里面list方法
            List<Customer> list = query.list();
            for (Customer customer : list) {
                System.out.println(customer);
            }
            //提交事務(wù)
            tx.commit();
        }catch(Exception e) {
            e.printStackTrace();
            tx.rollback();
        } finally {
            session.close();
        }
    }   
}

QBC查詢方式（會(huì)用）

圖一

簡單查詢

Criteria criteria = session.createCriteria(Customer.class);
//調(diào)用criteria的list方法
List<Customer> list = criteria.list();

排序查詢

//升序
Criteria criteria = session.createCriteria(Customer.class);
criteria.addOrder(Order.asc("cid"));
//Order類里面的方法asc握联，asc里面參數(shù)是實(shí)體類屬性名稱

//降序
criteria.addOrder(Order.desc("cid"));

分頁查詢

Criteria criteria = session.createCriteria(Customer.class);
//設(shè)置開始位置
criteria.setFirstResult(0);
//設(shè)置查詢記錄數(shù)
criteria.setMaxResults(3);

條件查詢

Criteria criteria = session.createCriteria(Customer.class);
//設(shè)置條件
criteria.add(Restrictions.gt("price", 3));

本地sql查詢

SQLQuery sqlQuery = session.createSQLQuery("select * from customer");
List<Object[]> list = sqlQuery.list();
for(Object[] objects : list) {
    System.out.println(Arrays.toString(objects));
}

☆HQL的多表查詢

多表查詢

內(nèi)連接：兩個(gè)表關(guān)聯(lián)的數(shù)據(jù)

范例：Select * from A inner joinB on A.id=B.id桦沉；Select * from A,B whereA.id=B.id

左外連接：左邊表所有的數(shù)據(jù)，右邊表查關(guān)聯(lián)數(shù)據(jù)

范例：Select * from A left outer join B on A.id=B.id

右外連接：右邊表所有的數(shù)據(jù)金闽，左邊表查關(guān)聯(lián)數(shù)據(jù)

范例：Select * from A right outer join B on A.id=B.id

Hibernate中使用HQL多表操作

連接查詢

內(nèi)連接：inner join

迫切內(nèi)連接：inner join fetch

左外連接：left outer join

迫切左外連接：left outer join fetch

右外連接 : right outer join

內(nèi)連接

查詢兩個(gè)表關(guān)聯(lián)數(shù)據(jù)纯露，返回是list集合數(shù)組

Query query = session.createQuery("from Customer c inner join c.setOrders");
List<Object[]> list = query.list();
for(Object[] objects : list) {
    System.out.println(Arrays.toString(objects));
}

返回list集合，每部分是數(shù)組的形式

圖二

迫切內(nèi)連接

Query query = session.createQuery("from Customer c inner join fetch c.setOrders");
List<Customer> list = query.list();

返回list集合每部分是對(duì)象形式

圖三

左外連接

左邊所有和關(guān)聯(lián)數(shù)據(jù)，返回是list集合數(shù)組

Query query = session.createQuery("from Customer c left outer join c.setOrders");
List<Object[]> list = query.list();

返回list集合中，每部分是數(shù)組形式

圖四

迫切左外連接

左邊所有和關(guān)聯(lián)數(shù)據(jù)切端，返回是list集合對(duì)象

Query query = session.createQuery("from Customer c left outer join fetch c.setOrders");
List<Customer> list = query.list();

返回list集合中，每部分是對(duì)象形式

圖五

右外連接

右邊所有和關(guān)聯(lián)數(shù)據(jù)钞速，返回是list集合數(shù)組

Query query = session.createQuery("from Customer c right outer join c.setOrders");
List<Cusomter[]> list = query.list();

HQL的投影查詢和聚合函數(shù)

投影查詢

查詢一部分?jǐn)?shù)據(jù)，字段下所有

第一個(gè)操作

Query query = session.createQuery("select cname from Customer");
List<Object> list = query.list();

第二個(gè)操作

Query query = session.createQuery("select cname, title from Customer");
List<Object[]> list = session.list();
for(Object[] objects : list) {
    System.out.println(Arrays.toString(objects));
}

聚合函數(shù)

Query query = session.createQuery("select count(*) from Customer");
Object obj = session.uniqueResult();
Long count = (Long) obj;
int sum = count.intValue();

代碼實(shí)現(xiàn)

package cn.itcast.hibernate.test;

import java.util.Arrays;
import java.util.List;

import org.hibernate.Criteria;
import org.hibernate.Query;
import org.hibernate.SQLQuery;
import org.hibernate.Session;
import org.hibernate.Transaction;
import org.hibernate.criterion.Order;
import org.hibernate.criterion.Restrictions;
import org.junit.Test;

import cn.itcast.onetomany.Customer;
import cn.itcast.onetomany.Orders;
import cn.itcast.utils.HibernateUtils;
/**
 * 演示hql多表查詢操作 
 */
public class HibernateManyTable {
    
    //6.(2)聚集函數(shù)使用
    @Test
    public void testSQL8() {
        Session session = null;
        Transaction tx = null;
        try {
            //獲取到session
            session = HibernateUtils.getSession();
            //開啟事務(wù)
            tx = session.beginTransaction();
            //count函數(shù)
            // count記錄  sum 求和 avg平均數(shù)  min最小值  max最大值
            Query query = session.createQuery("select count(*) from Customer");
            Object obj = query.uniqueResult();
           //可以獲取不同類型
            //變成long類型
            Long count = (Long) obj;
            //變成int類型
            int sum = count.intValue();
            System.out.println(sum);
            //提交事務(wù)
            tx.commit();
        }catch(Exception e) {
            e.printStackTrace();
            tx.rollback();
        } finally {
            session.close();
        }
    }
    
    //6.(1)投影查詢
    //查詢customer表里面所有cname和address的值
    @Test
    public void testSQL7() {
        Session session = null;
        Transaction tx = null;
        try {
            //獲取到session
            session = HibernateUtils.getSession();
            //開啟事務(wù)
            tx = session.beginTransaction();
            //可以查詢一個(gè)字段也可以查詢多個(gè)字段,多個(gè)字段逗號(hào)隔開
            Query query = session.createQuery("select cname,address from Customer");
            List<Object[]> list = query.list();
            for (Object[] objects : list) {
                System.out.println(Arrays.toString(objects));
            }
            //提交事務(wù)
            tx.commit();
        }catch(Exception e) {
            e.printStackTrace();
            tx.rollback();
        } finally {
            session.close();
        }
    }
    
    //投影查詢
    //查詢customer表里面所有cname的值
    @Test
    public void testSQL6() {
        Session session = null;
        Transaction tx = null;
        try {
            //獲取到session
            session = HibernateUtils.getSession();
            //開啟事務(wù)
            tx = session.beginTransaction();
            
            Query query = session.createQuery("select cname from Customer");
            List<Object> list = query.list();
            System.out.println(list);
            //提交事務(wù)
            tx.commit();
        }catch(Exception e) {
            e.printStackTrace();
            tx.rollback();
        } finally {
            session.close();
        }
    }
    
    //5.右外連接查詢
    @Test
    public void testSQL5() {
        Session session = null;
        Transaction tx = null;
        try {
            //獲取到session
            session = HibernateUtils.getSession();
            //開啟事務(wù)
            tx = session.beginTransaction();
            
            Query query = session.createQuery("from Customer c right outer join c.setOrders");
            List<Object[]> list = query.list();
            
            //提交事務(wù)
            tx.commit();
        }catch(Exception e) {
            e.printStackTrace();
            tx.rollback();
        } finally {
            session.close();
        }
    }
    
    //4.迫切左外連接查詢
    @Test
    public void testSQL4() {
        Session session = null;
        Transaction tx = null;
        try {
            //獲取到session
            session = HibernateUtils.getSession();
            //開啟事務(wù)
            tx = session.beginTransaction();
            
            Query query = session.createQuery("from Customer c left outer join fetch c.setOrders");
             //加入fetch   返回list集合每部分結(jié)構(gòu)是對(duì)象
            List list = query.list();
            
            //提交事務(wù)
            tx.commit();
        }catch(Exception e) {
            e.printStackTrace();
            tx.rollback();
        } finally {
            session.close();
        }
    }
    
    //3.左外連接查詢
    @Test
    public void testSQL3() {
        Session session = null;
        Transaction tx = null;
        try {
            //獲取到session
            session = HibernateUtils.getSession();
            //開啟事務(wù)
            tx = session.beginTransaction();
            
            Query query = session.createQuery("from Customer c left outer join c.setOrders");
            //返回list集合每部分結(jié)構(gòu)是數(shù)組
            List<Object[]> list = query.list();
            
            //提交事務(wù)
            tx.commit();
        }catch(Exception e) {
            e.printStackTrace();
            tx.rollback();
        } finally {
            session.close();
        }
    }
    
    //2.迫切內(nèi)連接查詢
    @Test
    public void testSQL2() {
        Session session = null;
        Transaction tx = null;
        try {
            //獲取到session
            session = HibernateUtils.getSession();
            //開啟事務(wù)
            tx = session.beginTransaction();
            //只是在代碼中加入fetch
            Query query = session.createQuery("from Customer c inner join fetch c.setOrders");
            
            List<Customer> list = query.list();
            
            
            //提交事務(wù)
            tx.commit();
        }catch(Exception e) {
            e.printStackTrace();
            tx.rollback();
        } finally {
            session.close();
        }
    }
    
    //1.內(nèi)連接查詢
    @Test
    public void testSQL1() {
        Session session = null;
        Transaction tx = null;
        try {
            //獲取到session
            session = HibernateUtils.getSession();
            //開啟事務(wù)
            tx = session.beginTransaction();
            //from Customer c inner join c.setOrders
            //Customer表與orders表關(guān)聯(lián)部分  后面是寫的Customer表的set集合名稱
            Query query = session.createQuery("from Customer c inner join c.setOrders");
            
            //返回list集合每部分是數(shù)組
            List<Object[]> list = query.list();
            
            for (Object[] objects : list) {
                System.out.println(Arrays.toString(objects));
            }
            //提交事務(wù)
            tx.commit();
        }catch(Exception e) {
            e.printStackTrace();
            tx.rollback();
        } finally {
            session.close();
        }
    }
}

Hibernate的檢索策略

概念

Hibernate的檢索策略分為兩部分

立即檢索

調(diào)用方法的時(shí)候馬上發(fā)送語句查詢數(shù)據(jù)庫 get

延遲檢索

調(diào)用方法的時(shí)候不會(huì)馬上發(fā)送語句查詢數(shù)據(jù)庫嫡秕，得到返回對(duì)象中的值時(shí)候才會(huì)查詢數(shù)據(jù)庫 load

Hibernate中延遲檢索分為兩部分

類級(jí)別延遲

如果根據(jù)oid查詢對(duì)象渴语，使用get方法立即查詢，但是load方法不會(huì)馬上查詢數(shù)據(jù)

Customer customer = (Customer) session.load(Customer.class, 1);//不會(huì)發(fā)送語句
System.out.println(customer.getCid());//不發(fā)送語句
System.out.println(customer.getCname());//發(fā)送語句

讓load方法執(zhí)行之后昆咽，也會(huì)立刻發(fā)送語句查詢數(shù)據(jù)庫驾凶，實(shí)現(xiàn)和ge相同的效果，class標(biāo)簽上面掷酗，屬性lazy默認(rèn)值是true

<class name="cn.xxx.Customer" table="Customer" lazy="false">
</class>

關(guān)聯(lián)級(jí)別延遲

比如查詢出一個(gè)用戶调违，再查詢這個(gè)用戶的所有的訂單

以用戶和訂單為例，演示關(guān)聯(lián)級(jí)別的延遲

在用戶那一端泻轰，有set標(biāo)簽

在訂單那一端技肩，有many-to-one標(biāo)簽

在set標(biāo)簽配置--關(guān)聯(lián)級(jí)別延遲

在set標(biāo)簽上面有兩個(gè)屬性fetch和lazy

fetch的取值：控制sql語句的生成格式

lazy的取值：查找關(guān)聯(lián)對(duì)象的時(shí)候是否采用延遲

fetch和lazy的值使用不同的組合實(shí)現(xiàn)不同的優(yōu)化方式

默認(rèn)值fetch是select，lazy是true

第一種情況：fetch值是join黄绩，lazy值是true羡洁、false、extra

如果fetch值是join爽丹，lazy無論值是什么筑煮，做的都是左外連接操作

<set name="setOrders" cascade="save-update" fetch="join" lazy="true"></set>

SQL語句

第二種情況：fetch值是select辛蚊，lazy值是true、false真仲、extra

<set name="setOrders" cascade="save-update" fetch="select" lazy="true"></set>

要進(jìn)行延遲

Customer customer = (Customer) session.get(Customer.class, 1);
Set<Orders> sets = customer.getSetOrders();
System.out.println(sets.size());

獲取到set集合的時(shí)候袋马，不會(huì)馬上發(fā)送sql語句，而得到集合的內(nèi)容時(shí)候才會(huì)發(fā)送sql語句

<set name="setOrders" cascade="save-update" fetch="select" lazy="false"></set>

一次性把所有的查詢操作都執(zhí)行秸应，不進(jìn)行延遲

<set name="setOrders" cascade="save-update" fetch="select" lazy="extra"></set>

把需要的數(shù)據(jù)返回虑凛，不需要的不給

sql語句

第三種情況：fetch值是subselect，lazy值是true软啼、false桑谍、extra

<set name="setOrders" cascade="save-update" fetch="subselect" lazy="true"></set>

進(jìn)行延遲

<set name="setOrders" cascade="save-update" fetch="subselect" lazy="false"></set>

不進(jìn)行延遲

<set name="setOrders" cascade="save-update" fetch="subselect" lazy="extra"></set>

極其延遲

在many-to-one配置--關(guān)聯(lián)級(jí)別延遲

有兩個(gè)屬性fetch和lazy

fetch有兩個(gè)值join、select

lazy常用兩個(gè)值false祸挪、proxy

默認(rèn)值fetch是select锣披、lazy是proxy

第一種情況：fetch值是join，lazy值是false和proxy

做左外連接操作

第二種情況：fetch值是select贿条，lazy值是false和proxy

一次性把所有數(shù)據(jù)都查出來

和對(duì)端配置有關(guān)聯(lián)雹仿，配置是否要延遲

<class name="cn.xx.Customer" table="Customer" lazy="false"></class>

Hibernate的事物

概念

1. Hibernate事務(wù)默認(rèn)不是自動(dòng)提交的
2. 事務(wù)四個(gè)特性：原子性、一致性整以、隔離性盅粪、持久性
3. 不考慮事務(wù)隔離性產(chǎn)生三個(gè)都問題
   1. 臟讀：一個(gè)事務(wù)讀到另一個(gè)事物沒有提交的數(shù)據(jù)
   2. 不可重復(fù)讀：一個(gè)事務(wù)讀到另一個(gè)事務(wù)update操作
   3. 虛讀：一個(gè)事務(wù)讀到另一個(gè)事務(wù)insert操作
4. 解決都問題：設(shè)置隔離級(jí)別
5. mysql默認(rèn)隔離級(jí)別：repeatable read
6. 不考慮事務(wù)隔離性產(chǎn)生一類問題，寫問題（丟失更新）

Hibernate配置事務(wù)隔離級(jí)別

在Hibernate核心配置文件中配置

hibernate.connection.isolation = 4

<!-- 配置事務(wù)隔離級(jí)別 -->
<property name="hibernate.connection.isolation">4</property>

丟失更新

什么是丟失更新

如果不考慮事務(wù)隔離性悄蕾，產(chǎn)生一類寫問題票顾，這類寫的問題成為丟失更新

有兩個(gè)事務(wù)同時(shí)對(duì)一個(gè)記錄進(jìn)行操作

第一種情況：

第一個(gè)事務(wù)修改了內(nèi)容之后提交了，第二個(gè)事務(wù)回滾操作帆调。一個(gè)事務(wù)回滾了另一個(gè)事務(wù)內(nèi)容

第二種情況：

第一個(gè)事務(wù)修改內(nèi)容提交了奠骄，第二個(gè)事務(wù)修改內(nèi)容，也提交了番刊。一個(gè)事務(wù)覆蓋另一個(gè)事務(wù)內(nèi)容

解決丟失更新

第一種方式：使用悲觀鎖

一個(gè)事務(wù)在操作事務(wù)的時(shí)候含鳞，對(duì)這條記錄加鎖，其他事務(wù)不能操作這條記錄了芹务，只有當(dāng)前事務(wù)提交之后蝉绷，其他事務(wù)才可以操作，效率低下枣抱。

第二種方式：使用樂觀鎖

使用版本號(hào)控制熔吗，有兩個(gè)事務(wù)同時(shí)操作同一條記錄。在記錄里面添加版本號(hào)信息佳晶，默認(rèn)是0桅狠。

如果a事務(wù)，修改數(shù)據(jù)，提交事務(wù)中跌，提交之前把記錄的版本號(hào)修改為1咨堤，完成提交

如果b事務(wù)，修改數(shù)據(jù)漩符，提交事務(wù)之前一喘，比較當(dāng)前數(shù)據(jù)的版本號(hào)和數(shù)據(jù)庫里面的最新的版本號(hào)是否一致，如果不相同不更新數(shù)據(jù)庫

Hibernate解決丟失更新

實(shí)現(xiàn)步驟：

第一步：

在實(shí)體類中添加屬性嗜暴，作為版本號(hào)的屬性

public class Customer {
    private Integer cid;
    private String cname;
    private String address;
    
    private Integer version;
    public Integer getVersion() {
        return version;
    }
    public void setVersion(Integer version) {
        this.version = version;
    }
}

第二步：

在實(shí)體類的映射文件中配置

<id name="cid" column="CID">
    <generator class="native"></generator>
</id>
<!-- 版本號(hào) -->
<version name="version"></version>

version標(biāo)簽要在id標(biāo)簽下面