HibernateSessionFactory.java

//$Id: HibernateSessionFactory.java 6143 2007-09-07 00:59:34Z gavin $
package org.jboss.seam.persistence;

import java.io.File;
import java.util.Hashtable;
import java.util.List;
import java.util.Map;
import java.util.Properties;

import org.hibernate.SessionFactory;
import org.hibernate.cfg.AnnotationConfiguration;
import org.hibernate.cfg.Environment;
import org.hibernate.cfg.NamingStrategy;
import org.hibernate.util.ReflectHelper;
import org.jboss.seam.ScopeType;
import org.jboss.seam.annotations.Create;
import org.jboss.seam.annotations.Destroy;
import org.jboss.seam.annotations.Scope;
import org.jboss.seam.annotations.Startup;
import org.jboss.seam.annotations.Unwrap;
import org.jboss.seam.annotations.intercept.BypassInterceptors;
import org.jboss.seam.security.HibernateSecurityInterceptor;
import org.jboss.seam.util.Naming;

/**
 * A Seam component that bootstraps a Hibernate SessionFactory
 * 
 * <p>
 * Loads Hibernate configuration options by checking:
 * <li>hibernate.properties in root of the classpath
 * <li>hibernate.cfg.xml in root of the classpath
 * <li>cfgResourceName as location of a cfg.xml file
 * <li>factory-supplied cfgProperties options
 * <p>
 * Note that this factory only supports cfg.xml files <b>or</b> programmatic
 * <tt>cfgProperties</tt> supplied to the factory. Any
 * <tt>hibernate.properties</tt> are always loaded from the classpath.
 * <p>
 * Mapping metadata can be supplied via
 * <li>mappingClasses: equivalent to <mapping class="..."/>
 * <li>mappingFiles: equivalent to <mapping file="..."/>
 * <li>mappingJars: equivalent to <mapping jar="..."/>
 * <li>mappingPackages: equivalent to <mapping package="..."/>
 * <li>mappingResources: equivalent to <mapping resource="..."/>
 * <p>
 * or via cfg.xml files.
 * <p>
 * The <tt>jndiProperties</tt> are convenience, the factory will automatically
 * prefix regular JNDI properties for use as Hibernate configuration properties.
 * 
 * @author Gavin King
 * @author Christian Bauer
 */
@Scope(ScopeType.APPLICATION)
@BypassInterceptors
@Startup
public class HibernateSessionFactory
{
   private SessionFactory sessionFactory;

   private String cfgResourceName;
   private Map<String, String> cfgProperties;
   private List<String> mappingClasses;
   private List<String> mappingFiles;
   private List<String> mappingJars;
   private List<String> mappingPackages;
   private List<String> mappingResources;
   private NamingStrategy namingStrategy;
   
   @Unwrap
   public SessionFactory getSessionFactory() throws Exception
   {
      return sessionFactory;
   }
   
   @Create
   public void startup() throws Exception
   {
      sessionFactory = createSessionFactory();
   }
   
   @Destroy
   public void shutdown()
   {
      if (sessionFactory!=null)
      {
         sessionFactory.close();
      }
   }

   protected SessionFactory createSessionFactory() throws ClassNotFoundException
   {
      AnnotationConfiguration configuration = new AnnotationConfiguration();
      
      // setup non-default naming strategy
      if (namingStrategy != null)
      {
         configuration.setNamingStrategy(namingStrategy);
      }
      
      // Programmatic configuration
      if (cfgProperties != null)
      {
         Properties props = new Properties();
         props.putAll(cfgProperties);
         configuration.setProperties(props);
      }
      Hashtable<String, String> jndiProperties = Naming.getInitialContextProperties();
      if ( jndiProperties!=null )
      {
         // Prefix regular JNDI properties for Hibernate
         for (Map.Entry<String, String> entry : jndiProperties.entrySet())
         {
            configuration.setProperty( Environment.JNDI_PREFIX + "." + entry.getKey(), entry.getValue() );
         }
      }
      // hibernate.cfg.xml configuration
      if (cfgProperties==null && cfgResourceName==null)
      {
         configuration.configure();
      } 
      else if (cfgProperties==null && cfgResourceName!=null)
      {
         configuration.configure(cfgResourceName);
      }
      // Mapping metadata
      if (mappingClasses!=null)
      {
         for (String className: mappingClasses) 
         {
            configuration.addAnnotatedClass(ReflectHelper.classForName(className));
         }
      }
      if (mappingFiles!=null)
      {
         for (String fileName: mappingFiles) 
         {
            configuration.addFile(fileName);
         }
      }
      if (mappingJars!=null)
      {
         for (String jarName: mappingJars) 
         {
            configuration.addJar(new File(jarName));
         }
      }
      if (mappingPackages!= null)
      {
         for (String packageName: mappingPackages) 
         {
            configuration.addPackage(packageName);
         }
      }
      if (mappingResources!= null)
      {
         for (String resourceName : mappingResources) 
         {
            configuration.addResource(resourceName);
         }
      }
      
      configuration.setInterceptor(new HibernateSecurityInterceptor(configuration.getInterceptor()));
      
      return configuration.buildSessionFactory();
   }
   
   public String getCfgResourceName()
   {
      return cfgResourceName;
   }
   
   public void setCfgResourceName(String cfgFileName)
   {
      this.cfgResourceName = cfgFileName;
   }
   
   public NamingStrategy getNamingStrategy()
   {
      return namingStrategy;
   }
   
   public void setNamingStrategy(NamingStrategy namingStrategy)
   {
      this.namingStrategy = namingStrategy;
   }
   
   public Map<String, String> getCfgProperties()
   {
      return cfgProperties;
   }
   
   public void setCfgProperties(Map<String, String> cfgProperties)
   {
      this.cfgProperties = cfgProperties;
   }
   
   public List<String> getMappingClasses()
   {
      return mappingClasses;
   }
   
   public void setMappingClasses(List<String> mappingClasses)
   {
      this.mappingClasses = mappingClasses;
   }
   
   public List<String> getMappingFiles()
   {
      return mappingFiles;
   }
   
   public void setMappingFiles(List<String> mappingFiles)
   {
      this.mappingFiles = mappingFiles;
   }
   
   public List<String> getMappingJars()
   {
      return mappingJars;
   }
   
   public void setMappingJars(List<String> mappingJars)
   {
      this.mappingJars = mappingJars;
   }
   
   public List<String> getMappingPackages()
   {
      return mappingPackages;
   }
   
   public void setMappingPackages(List<String> mappingPackages)
   {
      this.mappingPackages = mappingPackages;
   }
   
   public List<String> getMappingResources()
   {
      return mappingResources;
   }
   
   public void setMappingResources(List<String> mappingResources)
   {
      this.mappingResources = mappingResources;
   }
   
}