Vincent

								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
{
publicstaticfinal ThreadLocal tLocalsess = new ThreadLocal();

publicstaticfinal ThreadLocal tLocaltx = new ThreadLocal();

    /*
     * getting the thread-safe session for using
     */
publicstatic Session currentSession(){
        Session session = (Session) tLocalsess.get();

//open a new one, if none can be found.
try{
if (session == null){
                session = openSession();
                tLocalsess.set(session);
            }
        }catch (HibernateException e){
thrownew InfrastructureException(e);
        }
return session;
    }

    /*
     * closing the thread-safe session
     */
publicstatic void closeSession(){

        Session session = (Session) tLocalsess.get();
        tLocalsess.set(null);
try{
if (session != null && session.isOpen()){
                session.close();
            }

        }catch (HibernateException e){
thrownew InfrastructureException(e);
        }
    }

    /*
     * begin the transaction
     */
publicstatic void beginTransaction(){
        Transaction tx = (Transaction) tLocaltx.get();
try{
if (tx == null){
                tx = currentSession().beginTransaction();
                tLocaltx.set(tx);
            }
        }catch (HibernateException e){
thrownew InfrastructureException(e);
        }
    }

    /*
     * close the transaction
     */
publicstatic void commitTransaction(){
        Transaction tx = (Transaction) tLocaltx.get();
try{
if (tx != null && !tx.wasCommitted() && !tx.wasRolledBack())
                tx.commit();
            tLocaltx.set(null);
        }catch (HibernateException e){
thrownew InfrastructureException(e);
        }
    }

    /*
     * for rollbacking
     */
publicstatic void rollbackTransaction(){
        Transaction tx = (Transaction) tLocaltx.get();
try{
            tLocaltx.set(null);
if (tx != null && !tx.wasCommitted() && !tx.wasRolledBack()){
                tx.rollback();
            }
        }catch (HibernateException e){
thrownew InfrastructureException(e);
        }
    }

privatestatic Session openSession() throws HibernateException{
return getSessionFactory().openSession();
    }

privatestatic SessionFactory getSessionFactory() throws HibernateException{
return SingletonSessionFactory.getInstance();
    }
}

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

    }
}

HibernateSessionUtil.beginTransaction();
HibernateSessionUtil.currentSession();//取得Session