/**
    * Copyright By Grandsoft Company Limited.  
    * 2014年3月28日 下午5:59:32
    */
   package gboat2.base.dao.impl;
   
   import gboat2.base.dao.aspect.SessionFactoryHolder;
   
   import java.util.ArrayList;
  import java.util.Collections;
  import java.util.List;
  
  import org.hibernate.HibernateException;
  import org.hibernate.Session;
  import org.hibernate.SessionFactory;
  import org.springframework.dao.DataAccessResourceFailureException;
  import org.springframework.dao.support.DaoSupport;
  import org.springframework.orm.hibernate3.HibernateTemplate;
  import org.springframework.orm.hibernate3.SessionFactoryUtils;
  
  /**
   * 因为 {@link org.springframework.orm.hibernate3.support.HibernateDaoSupport} 的
   * {@link #getHibernateTemplate()} 等方法都是 final
   * 的，不能被重写，所以平台自定义一个 HibernateDaoSupport，以解决 Spring 内置的 HibernateDaoSupport 类的限制
   * 
   * @author <a href="mailto:[email protected]">何明旺</a>
   * @since 3.0
   * @date 2014年3月28日
   */
  public class GboatHibernateDaoSupport extends DaoSupport {
  
      private static List<HibernateTemplate> hibernateTemplates = Collections.synchronizedList(new ArrayList<HibernateTemplate>());
      private HibernateTemplate defaultHibernateTemplate;
  
      public void setDefaultSessionFactory(SessionFactory sessionFactory) {
          if (this.defaultHibernateTemplate == null || sessionFactory != this.defaultHibernateTemplate.getSessionFactory()) {
              this.defaultHibernateTemplate = createHibernateTemplate(sessionFactory);
          }
      }
      
      public SessionFactory getDefaultSessionFactory() {
          return getDefaultHibernateTemplate().getSessionFactory();
      }
  
      /**
       * Return the Hibernate SessionFactory used by this DAO.
       */
      public SessionFactory getSessionFactory() {
          HibernateTemplate hibernateTemplate = this.getHibernateTemplate();
          return (hibernateTemplate != null ? hibernateTemplate.getSessionFactory() : null);
      }
  
      public void addSessionFactory(SessionFactory sessionFactory) {
          for (HibernateTemplate template : hibernateTemplates) {
              if(template.getSessionFactory().equals(sessionFactory))
                  return;
          }
          
          HibernateTemplate template = createHibernateTemplate(sessionFactory);
          hibernateTemplates.add(template);
      }
  
      public void setDefaultHibernateTemplate(HibernateTemplate defaultHibernateTemplate) {
          this.defaultHibernateTemplate = defaultHibernateTemplate;
      }
  
      public HibernateTemplate getDefaultHibernateTemplate() {
          return defaultHibernateTemplate;
      }
  
      /**
       * Return the HibernateTemplate for this DAO,
       * pre-initialized with the SessionFactory or set explicitly.
       * <p><b>Note: The returned HibernateTemplate is a shared instance.</b>
       * You may introspect its configuration, but not modify the configuration
       * (other than from within an {@link #initDao} implementation).
       * Consider creating a custom HibernateTemplate instance via
       * {@code new HibernateTemplate(getSessionFactory())}, in which
       * case you're allowed to customize the settings on the resulting instance.
       */
      public HibernateTemplate getHibernateTemplate() {
          SessionFactory sessionFactory = SessionFactoryHolder.getSessionFactory();
          if(sessionFactory == null)
              return this.defaultHibernateTemplate;
          
          for (HibernateTemplate template : hibernateTemplates) {
              if(template.getSessionFactory().equals(sessionFactory))
                  return template;
          }
  
          throw new HibernateException("没有与当前 SessionFactory 相匹配的 HibernateTemplate 实例。");
      }
  
      /**
       * Create a HibernateTemplate for the given SessionFactory.
       * Only invoked if populating the DAO with a SessionFactory reference!
       * <p>Can be overridden in subclasses to provide a HibernateTemplate instance
       * with different configuration, or a custom HibernateTemplate subclass.
       * @param sessionFactory the Hibernate SessionFactory to create a HibernateTemplate for
      * @return the new HibernateTemplate instance
      * @see #setSessionFactory
      */
     protected HibernateTemplate createHibernateTemplate(SessionFactory sessionFactory) {
         return new HibernateTemplate(sessionFactory);
     }
 
     /**
      * Obtain a Hibernate Session, either from the current transaction or
      * a new one. The latter is only allowed if the
      * {@link org.springframework.orm.hibernate3.HibernateTemplate#setAllowCreate "allowCreate"}
      * setting of this bean's {@link #setHibernateTemplate HibernateTemplate} is "true".
      * <p><b>Note that this is not meant to be invoked from HibernateTemplate code
      * but rather just in plain Hibernate code.</b> Either rely on a thread-bound
      * Session or use it in combination with {@link #releaseSession}.
      * <p>In general, it is recommended to use HibernateTemplate, either with
      * the provided convenience operations or with a custom HibernateCallback
      * that provides you with a Session to work on. HibernateTemplate will care
      * for all resource management and for proper exception conversion.
      * @return the Hibernate Session
      * @throws DataAccessResourceFailureException if the Session couldn't be created
      * @throws IllegalStateException if no thread-bound Session found and allowCreate=false
      * @see org.springframework.orm.hibernate3.SessionFactoryUtils#getSession(SessionFactory, boolean)
      */
     protected Session getSession() throws DataAccessResourceFailureException, IllegalStateException {
         return getSession(this.getHibernateTemplate().isAllowCreate());
     }
 
     /**
      * Obtain a Hibernate Session, either from the current transaction or
      * a new one. The latter is only allowed if "allowCreate" is true.
      * <p><b>Note that this is not meant to be invoked from HibernateTemplate code
      * but rather just in plain Hibernate code.</b> Either rely on a thread-bound
      * Session or use it in combination with {@link #releaseSession}.
      * <p>In general, it is recommended to use
      * {@link #getHibernateTemplate() HibernateTemplate}, either with
      * the provided convenience operations or with a custom
      * {@link org.springframework.orm.hibernate3.HibernateCallback} that
      * provides you with a Session to work on. HibernateTemplate will care
      * for all resource management and for proper exception conversion.
      * @param allowCreate if a non-transactional Session should be created when no
      * transactional Session can be found for the current thread
      * @return the Hibernate Session
      * @throws DataAccessResourceFailureException if the Session couldn't be created
      * @throws IllegalStateException if no thread-bound Session found and allowCreate=false
      * @see org.springframework.orm.hibernate3.SessionFactoryUtils#getSession(SessionFactory, boolean)
      */
     protected Session getSession(boolean allowCreate) throws DataAccessResourceFailureException, IllegalStateException {
         HibernateTemplate hibernateTemplate = this.getHibernateTemplate();
         return (!allowCreate ?
             SessionFactoryUtils.getSession(getSessionFactory(), false) :
                 SessionFactoryUtils.getSession(
                         getSessionFactory(),
                         hibernateTemplate.getEntityInterceptor(),
                         hibernateTemplate.getJdbcExceptionTranslator()));
     }
     
     @Override
     protected void checkDaoConfig() throws IllegalArgumentException {
         if (this.defaultHibernateTemplate == null) {
             throw new IllegalArgumentException("'sessionFactory' or 'hibernateTemplate' is required");
         }
     }
 
 }