hibernateutil.java

学校的课程管理及选课系统

package org.wangsong.dao.hibernate;

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

 
public class HibernateUtil
{
	private static final SessionFactory sessionFactory;

	static
	{
		try
		{
			// Create the SessionFactory
			sessionFactory = new Configuration().configure()
					.buildSessionFactory();
		}
		catch (Throwable ex)
		{
			ex.printStackTrace();
			System.out.println("Initial SessionFactory creation failed.");
			throw new ExceptionInInitializerError(ex);
		}
	}
	
/*	对类 ThreadLocal 的介绍
	该类提供了线程局部变量。这些变量不同于它们的普通对应物，
	因为访问一个变量（通过其 get 或 set 方法）的每个线程都有自己的局部变量，
	它独立于变量的初始化副本。ThreadLocal 实例通常是类中的私有静态字段，
	它们希望将状态与某一个线程（例如，用户 ID 或事务 ID）相关联。 
	*/
	public static final ThreadLocal tLocalsess = new ThreadLocal();

	public static final ThreadLocal tLocaltx = new ThreadLocal();

	/*
	 * getting the thread-safe session for using
	 */
	public static Session currentSession()
	{
		Session session = (Session) tLocalsess.get();
	//	public T get() 返回此线程局部变量的当前线程副本中的值。如果这是线程第一次调用该方法，则创建并初始化此副本。 



		// open a new one, if none can be found.
		try
		{
			if (session == null || !session.isOpen())
			{
				session = openSession();
				tLocalsess.set(session);//将此线程局部变量的当前线程副本中的值设置为指定值
			}
		}
		catch (HibernateException e)
		{
			// throw new HibernateException(e);
			e.printStackTrace();
		}
		return session;
	}

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

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

		}
		catch (HibernateException e)
		{
			// throw new InfrastructureException(e);
		}
	}

	/*
	 * begin the transaction
	 */
	public static void beginTransaction()
	{
		System.out.println("begin tx");
		Transaction tx = (Transaction) tLocaltx.get();
		try
		{
			if (tx == null)
			{
				tx = currentSession().beginTransaction();
				tLocaltx.set(tx);
			}
		}
		catch (HibernateException e)
		{
			// throw new InfrastructureException(e);
		}
	}

	/*
	 * close the transaction
	 */
	public static void commitTransaction()
	{
		Transaction tx = (Transaction) tLocaltx.get();
		try
		{
			if (tx != null && !tx.wasCommitted() && !tx.wasRolledBack()) tx
					.commit();
			tLocaltx.set(null);
			System.out.println("commit tx");
		}
		catch (HibernateException e)
		{
			// throw new InfrastructureException(e);
		}
	}

	/*
	 * for rollbacking
	 */
	public static void rollbackTransaction()
	{
		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);
		}
	}

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

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