注銷

import java.io.Serializable;
import net.sf.hibernate.HibernateException;
import net.sf.hibernate.Session;
import net.sf.hibernate.SessionFactory;
import net.sf.hibernate.Transaction;
public class HibernateSessionUtil implements Serializable
{

   　 //創建線程局部變量　tLocalsess 

    public static final ThreadLocal tLocalsess = new ThreadLocal();

　　　//創建線程局部變量　tLocaltx
public static final ThreadLocal tLocaltx = new ThreadLocal();
      //取得session

    public static Session currentSession(){

         //從線程變量tLocalsess中，取得當前session
Session session = (Session) tLocalsess.get();
//判斷session是否為空，如果為空，將創建一個session,并付給線程變量tLocalsess

    try{
if (session == null){
session = openSession();
tLocalsess.set(session);
}
}catch (HibernateException e){
throw new InfrastructureException(e);
}
return session;
}
//關閉當前session

    public static void closeSession(){

         //從線程變量tLocalsess中，取得當前session
Session session = (Session) tLocalsess.get();

         //設置線程變量tLocalsess為空
tLocalsess.set(null);
try{

            //關閉session
if (session != null && session.isOpen()){
session.close();
}
}catch (HibernateException e){
throw new InfrastructureException(e);
}
}
//事物處理

    public static void beginTransaction(){

      //從線程變量tLocaltx中取得事物管理對象Transaction

        Transaction tx = (Transaction) tLocaltx.get();
try{

            //如果為空就從session中創建一個tx
if (tx == null){
tx = currentSession().beginTransaction();
tLocaltx.set(tx);
}
}catch (HibernateException e){
throw new InfrastructureException(e);
}
}
//提交事物

    public static void commitTransaction(){

      //取得事物
Transaction tx = (Transaction) tLocaltx.get();
try{

            //如果不為空就提交
if (tx != null && !tx.wasCommitted() && !tx.wasRolledBack())
tx.commit();
tLocaltx.set(null);
}catch (HibernateException e){
throw new InfrastructureException(e);
}
}
    //事物回滾    

    public static void rollbackTransaction(){

         //取得tx事物
Transaction tx = (Transaction) tLocaltx.get();
try{

            //將變量清空
tLocaltx.set(null);
if (tx != null && !tx.wasCommitted() && !tx.wasRolledBack()){

                //事物回滾
tx.rollback();
}
}catch (HibernateException e){
throw new InfrastructureException(e);
}
}

   //取得session
private static Session openSession() throws HibernateException{
return getSessionFactory().openSession();
}

   //取得sessionFactory
private static SessionFactory getSessionFactory() throws HibernateException{
return SingletonSessionFactory.getInstance();
}
}

filter的代碼：

public class HibernateSessionCloser implements Filter{
protected FilterConfig filterConfig = null;
public void init(FilterConfig filterConfig)throws ServletException{
this.filterConfig = filterConfig;
}
public void destroy(){
this.filterConfig = null;
}
public void doFilter(ServletRequest request, ServletResponse response,
FilterChain chain)
throws IOException, ServletException {
try{
chain.doFilter(request, response);
}
finally{
try{
HibernateSessionUtil.commitTransaction();
}catch (InfrastructureException e){
HibernateSessionUtil.rollbackTransaction();
}finally{
HibernateSessionUtil.closeSession();
}
}
}
}

---------------------------------------------------------------------------------------

hibernate學習筆記(七)-----悲觀鎖和樂觀鎖 
      (1)、悲觀鎖定（Pessimistic Locking）一如其名稱所示，悲觀的認定每次資料存取時，其它的客戶端也會存取同一筆資料，因此對該筆資料進行鎖定，直到自己操作完成後解除鎖定。 

      悲觀鎖定通常透過系統或資料庫本身的功能來實現，依賴系統或資料庫本身提供的鎖定機制，Hibernate即是如此，可以利用Query或 Criteria的setLockMode()方法來設定要鎖定的表或列（Row）及其鎖定模式，可設定的鎖定模式有以下的幾個：

LockMode.WRITE：在insert或update時進行鎖定，Hibernate會在save()方法時自動獲得鎖定。 
LockMode.UPGRADE：利用SELECT ... FOR UPDATE進行鎖定。 
LockMode.UPGRADE_NOWAIT：利用SELECT ... FOR UPDATE NOWAIT進行鎖定，在Oracle環境下使用。 
LockMode.READ：在讀取記錄時Hibernate會自動獲得鎖定。 
LockMode.NONE：沒有鎖定。
      (2)、樂觀鎖定（Optimistic locking）則樂觀的認為資料的存取很少發生同時存取的問題，因而不作資料庫層次上的鎖定，為了維護正確的資料，樂觀鎖定使用應用程式上的邏輯實現版本控制的解決。 

      在不實行悲觀鎖定策略的情況下，資料不一致的情況一但發生，有幾個解決的方法，一種是先更新為主，一種是後更新的為主，比較複雜的就是檢查發生變動的資料來實現，或是檢查所有屬性來實現樂觀鎖定。
      要注意的是，由於樂觀鎖定是使用系統中的程式來控制，而不是使用資料庫中的鎖定機制，因而如果有人特意自行更新版本訊息來越過檢查，則鎖定機制就會無效，例如在上例中自行更改userV2的version屬性，使之與資料庫中的版本號相同的話就不會有錯誤，像這樣版本號被更改，或是由於資料是由外部系統而來，因而版本資訊不受控制時，鎖定機制將會有問題，設計時必須注意。