1. 程式人生 > >Hibernate樂觀鎖實現—Version

Hibernate樂觀鎖實現—Version

樂觀併發控制,可以有三種方式。

1,Version版本號

2,時間戳

3,自動版本控制。

這裡不建議在新的應用程式中定義沒有版本或者時間戳列的版本控制:它更慢,更復雜,如果你正在使用脫管物件,它則不會生效。

通過在表中及POJO中增加一個version欄位來表示記錄的版本,來達到多使用者同時更改一條資料的衝突

資料庫指令碼: 

createtable studentVersion (id varchar(32),name varchar(32),ver int);

POJO

package Version;

publicclass Student {
  
private
 String id;
  
private String name;
  
privateint version;
public String getId() {
    
return id;
}

publicvoid setId(String id) {
    
this.id = id;
}

public String getName() {
    
return name;
}

publicvoid setName(String name) {
    
this.name = name;
}

publicint getVersion() {
    
return version;
}

publicvoid setVersion(
int version) {
    
this.version = version;
}



}

Student.hbm.xml

<?xml version="1.0" encoding="utf-8"?>
<!DOCTYPE hibernate-mapping PUBLIC "-//Hibernate/Hibernate Mapping DTD 3.0//EN"
"http://hibernate.sourceforge.net/hibernate-mapping-3.0.dtd"
>
<!-- 
    Mapping file autogenerated by MyEclipse - Hibernate Tools
-->
<hibernate-mapping>
<class name="Version.Student" table="studentVersion">
    
<id name="id" unsaved-value="null">
      
<generator class="uuid.hex"></generator>
    
</id>
    
<!--version標籤必須跟在id標籤後面-->
    
<version name="version" column="ver" type="int"></version>
    
<property name="name" type="string" column="name"></property>  
</class>

</hibernate-mapping>

Hibernate.cfg.xml

<?xml version='1.0' encoding='UTF-8'?>
<!DOCTYPE hibernate-configuration PUBLIC
          "-//Hibernate/Hibernate Configuration DTD 3.0//EN"
          "http://hibernate.sourceforge.net/hibernate-configuration-3.0.dtd"
>

<!-- Generated by MyEclipse Hibernate Tools.                   -->
<hibernate-configuration>

<session-factory>
    
<property name="connection.username">root</property>
    
<property name="connection.url">
        jdbc:mysql://localhost:3306/schoolproject?characterEncoding=gb2312
&amp;useUnicode=true
    
</property>
    
<property name="dialect">
        org.hibernate.dialect.MySQLDialect
    
</property>
    
<property name="myeclipse.connection.profile">mysql</property>
    
<property name="connection.password">1234</property>
    
<property name="connection.driver_class">
        com.mysql.jdbc.Driver
    
</property>
    
<property name="hibernate.dialect">
        org.hibernate.dialect.MySQLDialect
    
</property>
    
<property name="hibernate.show_sql">true</property>
    
<property name="current_session_context_class">thread</property>
    
<property name="jdbc.batch_size">15</property>
    
<mapping resource="Version/Student.hbm.xml"/>




</session-factory>

</hibernate-configuration>

測試程式碼:

package Version;


import java.io.File;
import java.util.Iterator;
import java.util.Set;

import org.hibernate.Session;
import org.hibernate.SessionFactory;
import org.hibernate.Transaction;
import org.hibernate.cfg.Configuration;

publicclass Test {


    
publicstaticvoid main(String[] args) {

        String filePath
=System.getProperty("user.dir")+File.separator+"src/Version"+File.separator+"hibernate.cfg.xml";
        File file
=new File(filePath);
        System.out.println(filePath);
        SessionFactory sessionFactory
=new Configuration().configure(file).buildSessionFactory();
        Session session
=sessionFactory.openSession();
        Transaction t
=session.beginTransaction();
        
        Student stu
=new Student();
        stu.setName(
"tom11");
        session.save(stu);
        t.commit();
      
        
        
/*
         * 模擬多個session操作student資料表
         
*/

        
        Session session1
=sessionFactory.openSession();
        Session session2
=sessionFactory.openSession();
        Student stu1
=(Student)session1.createQuery("from Student s where s.name='tom11'").uniqueResult();
        Student stu2
=(Student)session2.createQuery("from Student s where s.name='tom11'").uniqueResult();
        
        
//這時候,兩個版本號是相同的
        System.out.println("v1="+stu1.getVersion()+"--v2="+stu2.getVersion());
        
        Transaction tx1
=session1.beginTransaction();
        stu1.setName(
"session1");
        tx1.commit();
        
//這時候,兩個版本號是不同的,其中一個的版本號遞增了
        System.out.println("v1="+stu1.getVersion()+"--v2="+stu2.getVersion());
        
        Transaction tx2
=session2.beginTransaction();
        stu2.setName(
"session2");
        tx2.commit();
        
        
        
    }


}

執行結果:

Hibernate: insert into studentVersion (ver, name, id) values (?, ?, ?)
Hibernate: select student0_.id as id0_, student0_.ver as ver0_, student0_.name as name0_ from studentVersion student0_ where student0_.name='tom11'
Hibernate: select student0_.id as id0_, student0_.ver as ver0_, student0_.name as name0_ from studentVersion student0_ where student0_.name='tom11'
v1=0--v2=0
Hibernate: update studentVersion set ver=?, name=? where id=? and ver=?
v1=1--v2=0
Hibernate: update studentVersion set ver=?, name=? where id=? and ver=?
Exception in thread "main" org.hibernate.StaleObjectStateException: Row was updated or deleted by another transaction (or unsaved-value mapping was incorrect):[Version.Student#4028818316cd6b460116cd6b50830001]

可以看到,第二個“使用者”session2修改資料時候,記錄的版本號已經被session1更新過了,所以丟擲了紅色的異常,我們可以在實際應用中處理這個異常,例如在處理中重新讀取資料庫中的資料,同時將目前的資料與資料庫中的資料展示出來,讓使用者有機會比較一下,或者設計程式自動讀取新的資料

注意:

    要注意的是,由於樂觀鎖定是使用系統中的程式來控制,而不是使用資料庫中的鎖定機制,因而如果有人特意自行更新版本訊息來越過檢查,則鎖定機制就會無效,例如在上例中自行更改stu的version屬性,使之與資料庫中的版本號相同的話就不會有錯誤,像這樣版本號被更改,或是由於資料是由外部系統而來,因而版本資訊不受控制時,鎖定機制將會有問題,設計時必須注意。

    如果手工設定stu.setVersion()自行更新版本以跳過檢查,則這種樂觀鎖就會失效,應對方法可以將Student.java的setVersion設定成private

相關推薦

Hibernate樂觀實現Version

樂觀併發控制,可以有三種方式。 1,Version版本號 2,時間戳 3,自動版本控制。 這裡不建議在新的應用程式中定義沒有版本或者時間戳列的版本控制:它更慢,更復雜,如果你正在使用脫管物件,它則不會生效。 通過在表中及POJO中增加一個version欄

Hibernate併發控制樂觀實現-Version

通過在表中及POJO中增加一個version欄位來表示記錄的版本,來達到多使用者同時更改一條資料的衝突 資料庫指令碼: createtable studentVersion (id varchar(32),name varchar(32),ver int); POJO package Versio

Hibernate 樂觀實現Version

通過在表中及POJO中增加一個Timestamp欄位來表示記錄的最後更新時間,來達到多使用者同時更改一條資料的衝突,這個timestamp由資料庫自動新增,無需人工干預 資料庫結構: package com.ematchina.test; import java.sql.Timestamp; imp

hibernate 樂觀與悲觀實現

Hibernate支援兩種鎖機制: 即通常所說的“悲觀鎖(Pessimistic Locking)”和 “樂觀鎖(OptimisticLocking)”。 悲觀鎖的實現,往往依靠資料庫提供的鎖機制(也只有資料庫層提供的鎖機制才能真正保證資料訪問的排他性,否則,即使在本系統中實

Hibernate 樂觀 version 欄位的型別不正確引起的異常

在持久化類中使用樂觀鎖optimistic-lock="version", private String rec_Ver;     /**      * @hibernate.version column="REC_VER"      * @return      */  

mysql樂觀實現

color new lan 什麽 clas 事務處理 帶來 解決 提交 一、為什麽需要鎖(並發控制)? 在多用戶環境中,在同一時間可能會有多個用戶更新相同的記錄,這會產生沖突。這就是著名的並發性問題。 典型的沖突有: 1.丟失更新:一

JAVA樂觀實現-CAS

sub 缺點 c語言 get get() fin mage 個數 接口實現 是什麽 全稱compare and swap,一個CPU原子指令,在硬件層面實現的機制,體現了樂觀鎖的思想。 JVM用C語言封裝了匯編調用。Java的基礎庫中有很多類就是基於JNI調用C接口實現了

Hibernate 樂觀和悲觀處理事物併發問題

一、5類事物併發問題 二、事物的隔離級別 三、處理第一類丟失更新和第二類丟失更新--使用鎖機制 資料庫的鎖機制: 在MYSQL中 ,為了避免第二類丟失更新出現,提供了悲觀鎖的機制; SELECT XXX FROM XXX    FOR UPDATE;

JPA事務併發(樂觀實現隔離機制)

事務(4個特性ACID) 原子性(atomic),事務必須是原子工作單元;對於其資料修改,要麼全都執行,要麼全都不執行 一致性(consistent),事務在完成時,必須使所有的資料都保持一致狀態。 隔離性(insulation),由事務併發所作的修改必須與任何其它併發事務所作的修改

mysql 樂觀實現

mysql 樂觀鎖實現 一、為什麼需要鎖(併發控制)?       在多使用者環境中,在同一時間可能會有多個使用者更新相同的記錄,這會產生衝突。這就是著名的併發性問題。       典型的衝突有:      

Hibernate 樂觀異常處理

最進在工作中遇到了hibernate 處理併發問題,總結了一下用到了遞迴處理迴圈遞迴嘗試,請大家多多指教 /** * 判斷產品額度是否可用 * @return */ public String isAvailableProductLimit(ProductLimit ccsProductLi

Hibernate 樂觀和悲觀處理事物併發問題

一、5類事物併發問題 二、事物的隔離級別 三、處理第一類丟失更新和第二類丟失更新--使用鎖機制 資料庫的鎖機制: 在MYSQL中 ,為了避免第二類丟失更新出現,提供了悲觀鎖的機制; SELECT XXX FROM XXX    FOR UPDATE; SELE

CAS和MySql樂觀實現下單

CAS和MySql樂觀鎖實現下單 準備 建表t_order: CREATE TABLE `t_order` ( `id` int(11) NOT NULL AUTO_INCREMENT, `version` int(255) DEFAULT NULL, `stock`

hibernate樂觀 StaleObjectStateException

你是否出現這個 ERROR SqlExceptionHelper Cannot add or update a child row: a foreign key constraint fails (`car_rental`.`zl_license`, CONSTRAINT `FK_Referen

秒殺---使用樂觀實現或cache實現

概念 秒殺系統的特點 新品上市 價格低廉 市場造勢 大幅推廣 指定時間開售 瞬時售空 讀多寫少 秒殺系統難點 高併發、負載壓力大 競爭資源是有限的 對其他業務的影響 提防“黃牛黨”

Hibernate樂觀

可以在hibernate的對映檔案中做下面的宣告:<class name="com.thoughtworks.sample.domain.Account" table="accounts" optimistic-lock="all" dynamic-update="tr

hibernate樂觀例子

1.在資料表中新建一個version欄位,可以是int或者是bigint 2.在javabean中增加個version欄位 package net.spring.model; import jav

java樂觀實現案例

簡單說說樂觀鎖。樂觀鎖是相對於悲觀鎖而言。悲觀鎖認為,這個執行緒,發生併發的可能性極大,執行緒衝突機率大,比較悲觀。一般用synchronized實現,保證每次操作資料不會衝突。樂觀鎖認為,執行緒衝突可能性小,比較樂觀,直接去操作資料,如果發現數據已經被更改(通過版本號控制)

mybatis 樂觀實現,解決併發問題。

https://blog.csdn.net/zhouzhiwengang/article/details/54973509轉載情景展示:銀行兩操作員同時操作同一賬戶就是典型的例子。比如A,B操作員同時讀取一餘額為1000元的賬戶,A操作員為該賬戶增加100元,B操作員同時為該

hibernate樂觀catch到異常後該如何處理

我通過hibernate的樂觀鎖來處理併發的問題,如果有併發問題出現的話,會丟擲org.hibernate.StaleObjectStateException這個異常,於是我在service層捕獲到了這個異常(這個異常在dao層是捕獲不到的),那麼問題來了,捕獲到這個異常以