非本人總結(jié)的筆記，抄點筆記復習復習。感謝傳智博客及黑馬程序猿

記筆記啊記筆記

Hibernate的查詢操作

Hibernate的查詢方式概述

（1）導航對象圖檢索方式

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

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

（2）OID檢索方式

? 按照對象的OID來檢索對象

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

（3）HQL檢索方式

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

（4）QBC檢索方式

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

（5）本地SQL檢索方式

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

導航對象圖檢索方式

查詢出一個用戶，查詢這個用戶的所有訂單，直接得到用戶的訂單集合

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

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

HQL VS SQL

HQL查詢語句（操作實體類）

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

SQL查詢語句

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

HQL語句創(chuàng)建Query對象
調(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;

/**
 * 實現(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對象
            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對象
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對象
//c.cid 不是表字段名稱，而是實體類屬性名稱
Query query = session.createQuery("from Customer c where c.cid = 1");

排序查詢

asc 升序 desc降序

//對Customer表里面的數(shù)據(jù)，按照cid進行升序排序
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ù)

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

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

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

唯一對象查詢

根據(jù)對象查詢這條記錄。

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

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

//使用對象接收返回數(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ù)
//第一個參數(shù)：？位置，從0開始
//第二個參數(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ù)
//第一個參數(shù)：后面的名稱
//第二個參數(shù)：值
query.setParameter("ccid", 2);
query.setParameter("ccname", "郭靖");

代碼實現(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有兩個參數(shù)
            //第一個參數(shù)  冒號:后面的名稱
            //第二個參數(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兩個參數(shù)  
            //******第一個參數(shù)：？位置，開始位置從 0 開始
            //第二個參數(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.唯一對象查詢
    @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");
            //使用對象接收返回數(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();
            
            //對customer表里面的數(shù)據(jù)，按照cid進行升序排列
            //Query query = session.createQuery("from Customer c order by c.cid asc");
            //對customer表里面的數(shù)據(jù)，按照cid進行降序排列
            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對象   c是別名
            //c.cid ： 不是表字段名稱，而是實體類屬性名稱 
            //建議實體類屬性名稱與表字段名一致
            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對象   from后面是實體類名稱
            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查詢方式（會用）

圖一

簡單查詢

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ù)是實體類屬性名稱

//降序
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)連接：兩個表關(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)連接

查詢兩個表關(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集合每部分是對象形式

圖三

左外連接

左邊所有和關(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集合對象

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

返回list集合中，每部分是對象形式

圖五

右外連接

右邊所有和關(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ù)

投影查詢

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

第一個操作

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

第二個操作

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();

代碼實現(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();
            //可以查詢一個字段也可以查詢多個字段,多個字段逗號隔開
            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)是對象
            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)用方法的時候馬上發(fā)送語句查詢數(shù)據(jù)庫 get

延遲檢索

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

Hibernate中延遲檢索分為兩部分

類級別延遲

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

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

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

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

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

比如查詢出一個用戶，再查詢這個用戶的所有的訂單

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

在用戶那一端，有set標簽

在訂單那一端，有many-to-one標簽

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

在set標簽上面有兩個屬性fetch和lazy

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

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

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

默認值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>

要進行延遲

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

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

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

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

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

進行延遲

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

不進行延遲

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

極其延遲

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

有兩個屬性fetch和lazy

fetch有兩個值join、select

lazy常用兩個值false、proxy

默認值fetch是select、lazy是proxy

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

做左外連接操作

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

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

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

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

Hibernate的事物

概念

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

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

在Hibernate核心配置文件中配置

hibernate.connection.isolation = 4

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

丟失更新

什么是丟失更新

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

有兩個事務(wù)同時對一個記錄進行操作

第一種情況：

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

第二種情況：

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

解決丟失更新

第一種方式：使用悲觀鎖

一個事務(wù)在操作事務(wù)的時候，對這條記錄加鎖，其他事務(wù)不能操作這條記錄了，只有當前事務(wù)提交之后，其他事務(wù)才可以操作，效率低下。

第二種方式：使用樂觀鎖

使用版本號控制，有兩個事務(wù)同時操作同一條記錄。在記錄里面添加版本號信息，默認是0。

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

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

Hibernate解決丟失更新

實現(xiàn)步驟：

第一步：

在實體類中添加屬性，作為版本號的屬性

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

第二步：

在實體類的映射文件中配置

<id name="cid" column="CID">
    <generator class="native"></generator>
</id>
<!-- 版本號 -->
<version name="version"></version>

version標簽要在id標簽下面