Hibernate--day03

非本人總結(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語句的生成格式

說明
select 默認發(fā)送查詢語句
join 連接查詢,發(fā)送的是一條迫切左外連接,配置了join,lazy就失效了
subselect 子查詢,發(fā)送一條子查詢查詢其關(guān)聯(lián)對象,(必須使用list方法進行測試)

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

取值 說明
true 默認延遲
false 不延遲
extra 極其懶惰

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

name屬性值 數(shù)字值
Readuncommitted isolation 1
Readcommitted isolation 2
Repeatableread isolation 4
?Serializable isolation 8
<!-- 配置事務(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標簽下面

最后編輯于
?著作權(quán)歸作者所有,轉(zhuǎn)載或內(nèi)容合作請聯(lián)系作者
平臺聲明:文章內(nèi)容(如有圖片或視頻亦包括在內(nèi))由作者上傳并發(fā)布,文章內(nèi)容僅代表作者本人觀點,簡書系信息發(fā)布平臺,僅提供信息存儲服務(wù)。

推薦閱讀更多精彩內(nèi)容