Open Source Repository

Home /spring/spring-orm-3.0.5 | Repository Home



org/springframework/orm/jpa/LocalEntityManagerFactoryBean.java
/*
 * Copyright 2002-2007 the original author or authors.
 *
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.
 * You may obtain a copy of the License at
 *
 *      http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 */

package org.springframework.orm.jpa;

import javax.persistence.EntityManagerFactory;
import javax.persistence.Persistence;
import javax.persistence.PersistenceException;
import javax.persistence.spi.PersistenceProvider;

/**
 {@link org.springframework.beans.factory.FactoryBean} that creates a JPA
 {@link javax.persistence.EntityManagerFactory} according to JPA's standard
 <i>standalone</i> bootstrap contract. This is the simplest way to set up a
 * shared JPA EntityManagerFactory in a Spring application context; the
 * EntityManagerFactory can then be passed to JPA-based DAOs via
 * dependency injection. Note that switching to a JNDI lookup or to a
 {@link org.springframework.orm.jpa.LocalContainerEntityManagerFactoryBean}
 * definition is just a matter of configuration!
 *
 <p>Configuration settings are usually read from a <code>META-INF/persistence.xml</code>
 * config file, residing in the class path, according to the JPA standalone bootstrap
 * contract. Additionally, most JPA providers will require a special VM agent
 * (specified on JVM startup) that allows them to instrument application classes.
 * See the Java Persistence API specification and your provider documentation
 * for setup details.
 *
 <p>This EntityManagerFactory bootstrap is appropriate for standalone applications
 * which solely use JPA for data access. If you want to set up your persistence
 * provider for an external DataSource and/or for global transactions which span
 * multiple resources, you will need to either deploy it into a full Java EE 5
 * application server and access the deployed EntityManagerFactory via JNDI,
 * or use Spring's {@link LocalContainerEntityManagerFactoryBean} with appropriate
 * configuration for local setup according to JPA's container contract.
 *
 <p><b>Note:</b> This FactoryBean has limited configuration power in terms of
 * what configuration it is able to pass to the JPA provider. If you need more
 * flexible configuration, for example passing a Spring-managed JDBC DataSource
 * to the JPA provider, consider using Spring's more powerful
 {@link LocalContainerEntityManagerFactoryBean} instead.
 *
 @author Juergen Hoeller
 @author Rod Johnson
 @since 2.0
 @see #setJpaProperties
 @see #setJpaVendorAdapter
 @see JpaTemplate#setEntityManagerFactory
 @see JpaTransactionManager#setEntityManagerFactory
 @see LocalContainerEntityManagerFactoryBean
 @see org.springframework.jndi.JndiObjectFactoryBean
 @see org.springframework.orm.jpa.support.SharedEntityManagerBean
 @see javax.persistence.Persistence#createEntityManagerFactory
 @see javax.persistence.spi.PersistenceProvider#createEntityManagerFactory
 */
public class LocalEntityManagerFactoryBean extends AbstractEntityManagerFactoryBean {

  /**
   * Initialize the EntityManagerFactory for the given configuration.
   @throws javax.persistence.PersistenceException in case of JPA initialization errors
   */
  @Override
  protected EntityManagerFactory createNativeEntityManagerFactory() throws PersistenceException {
    if (logger.isInfoEnabled()) {
      logger.info("Building JPA EntityManagerFactory for persistence unit '" + getPersistenceUnitName() "'");
    }
    PersistenceProvider provider = getPersistenceProvider();
    if (provider != null) {
      // Create EntityManagerFactory directly through PersistenceProvider.
      EntityManagerFactory emf = provider.createEntityManagerFactory(getPersistenceUnitName(), getJpaPropertyMap());
      if (emf == null) {
        throw new IllegalStateException(
            "PersistenceProvider [" + provider + "] did not return an EntityManagerFactory for name '" +
            getPersistenceUnitName() "'");
      }
      return emf;
    }
    else {
      // Let JPA perform its standard PersistenceProvider autodetection.
      return Persistence.createEntityManagerFactory(getPersistenceUnitName(), getJpaPropertyMap());
    }
  }

}