package cn.hxex.exam.persistence;

import javax.naming.InitialContext;
import javax.naming.NamingException;

import org.apache.commons.logging.Log;
import org.apache.commons.logging.LogFactory;
import org.hibernate.Interceptor;
import org.hibernate.SessionFactory;
import org.hibernate.cfg.AnnotationConfiguration;
import org.hibernate.cfg.Configuration;
import org.hibernate.cfg.Environment;


/**
 * 基礎(chǔ)的Hibernate輔助類，用于Hibernate的配置和啟動。
 * <p>
 * 通過靜態(tài)的初始化代碼來讀取Hibernate啟動參數(shù)，并初始化
 * <tt>Configuration</tt>和<tt>SessionFactory</tt>對象。
 * <p>
 *
 * @author galaxy
 */
public class HibernateUtil 
{

    private static Log log = LogFactory.getLog(HibernateUtil.class);

    // 指定定義攔截器屬性名
    private static final String INTERCEPTOR_CLASS = "hibernate.util.interceptor_class";

    // 靜態(tài)Configuration和SessionFactory對象的實例（全局唯一的）
    private static Configuration configuration;
    private static SessionFactory sessionFactory;

    static 
    {
        // 從缺省的配置文件創(chuàng)建SessionFactory
        try 
        {
        	// 創(chuàng)建默認的Configuration對象的實例
        	// 如果你不使用JDK 5.0或者注釋請使用new Configuration()
        	// 來創(chuàng)建Configuration()對象的實例
            configuration = new AnnotationConfiguration();

            // 讀取hibernate.properties或者hibernate.cfg.xml文件
            configuration.configure();

            // 如果在配置文件中配置了攔截器，那么將其設(shè)置到configuration對象中
            String interceptorName = configuration.getProperty(INTERCEPTOR_CLASS);
            if (interceptorName != null) 
            {
                Class interceptorClass =
                        HibernateUtil.class.getClassLoader().loadClass(interceptorName);
                Interceptor interceptor = (Interceptor)interceptorClass.newInstance();
                configuration.setInterceptor(interceptor);
            }

            if (configuration.getProperty(Environment.SESSION_FACTORY_NAME) != null) 
            {
                // 讓Hibernate將SessionFacory綁定到JNDI
                configuration.buildSessionFactory();
            } 
            else 
            {
                // 使用靜態(tài)變量來保持SessioFactory對象的實例
                sessionFactory = configuration.buildSessionFactory();
            }

        } 
        catch (Throwable ex) 
        {
            // 輸出異常信息
            log.error("Building SessionFactory failed.", ex);
            ex.printStackTrace();
            throw new ExceptionInInitializerError(ex);
        }
    }

    /**
     * 返回原始的Configuration對象的實例
     *
     * @return Configuration
     */
    public static Configuration getConfiguration() 
    {
        return configuration;
    }

    /**
     * 返回全局的SessionFactory對象的實例
     *
     * @return SessionFactory
     */
    public static SessionFactory getSessionFactory() 
    {
        SessionFactory sf = null;
        String sfName = configuration.getProperty(Environment.SESSION_FACTORY_NAME);
        if ( sfName != null) 
        {
            log.debug("Looking up SessionFactory in JNDI.");
            try 
            {
                sf = (SessionFactory) new InitialContext().lookup(sfName);
            } 
            catch (NamingException ex) 
            {
                throw new RuntimeException(ex);
            }
        } 
        else 
        {
            sf = sessionFactory;
        }
        if (sf == null)
            throw new IllegalStateException( "SessionFactory not available." );
        return sf;
    }

    /**
     * 關(guān)閉當(dāng)前的SessionFactory并且釋放所有的資源
     */
    public static void shutdown() 
    {
        log.debug("Shutting down Hibernate.");
        // Close caches and connection pools
        getSessionFactory().close();

        // Clear static variables
        configuration = null;
        sessionFactory = null;
    }


    /**
     * 使用靜態(tài)的Configuration對象來重新構(gòu)建SessionFactory。
     */
     public static void rebuildSessionFactory() 
     {
        log.debug("Using current Configuration for rebuild.");
        rebuildSessionFactory(configuration);
     }

    /**
     * 使用指定的Configuration對象來重新構(gòu)建SessionFactory對象。
     *
     * @param cfg
     */
     public static void rebuildSessionFactory(Configuration cfg) 
     {
        log.debug("Rebuilding the SessionFactory from given Configuration.");
        synchronized(sessionFactory) 
        {
            if (sessionFactory != null && !sessionFactory.isClosed())
                sessionFactory.close();
            if (cfg.getProperty(Environment.SESSION_FACTORY_NAME) != null)
                cfg.buildSessionFactory();
            else
                sessionFactory = cfg.buildSessionFactory();
            configuration = cfg;
        }
     }

    /**
     * 在當(dāng)前SessionFactory中注冊一個攔截器
     */
    public static SessionFactory registerInterceptorAndRebuild(Interceptor interceptor) 
    {
        log.debug("Setting new global Hibernate interceptor and restarting.");
        configuration.setInterceptor(interceptor);
        rebuildSessionFactory();
        return getSessionFactory();
    }

    /**
     * 獲得攔截器對象
     * 
     * @return Interceptor
     */
    public static Interceptor getInterceptor() 
    {
        return configuration.getInterceptor();
    }

    /**
     * 提交當(dāng)前事務(wù)，并開始一個新的事務(wù)
     */
    public static void commitAndBeginTransaction()
    {
    	sessionFactory.getCurrentSession().getTransaction().commit();
    	sessionFactory.getCurrentSession().beginTransaction();
    }
}