001/*
002 * Copyright 2002-2014 the original author or authors.
003 *
004 * Licensed under the Apache License, Version 2.0 (the "License");
005 * you may not use this file except in compliance with the License.
006 * You may obtain a copy of the License at
007 *
008 *      https://www.apache.org/licenses/LICENSE-2.0
009 *
010 * Unless required by applicable law or agreed to in writing, software
011 * distributed under the License is distributed on an "AS IS" BASIS,
012 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
013 * See the License for the specific language governing permissions and
014 * limitations under the License.
015 */
016
017package org.springframework.orm.jpa;
018
019import javax.persistence.EntityManagerFactory;
020import javax.persistence.Persistence;
021import javax.persistence.PersistenceException;
022import javax.persistence.spi.PersistenceProvider;
023
024/**
025 * {@link org.springframework.beans.factory.FactoryBean} that creates a JPA
026 * {@link javax.persistence.EntityManagerFactory} according to JPA's standard
027 * <i>standalone</i> bootstrap contract. This is the simplest way to set up a
028 * shared JPA EntityManagerFactory in a Spring application context; the
029 * EntityManagerFactory can then be passed to JPA-based DAOs via
030 * dependency injection. Note that switching to a JNDI lookup or to a
031 * {@link LocalContainerEntityManagerFactoryBean}
032 * definition is just a matter of configuration!
033 *
034 * <p>Configuration settings are usually read from a {@code META-INF/persistence.xml}
035 * config file, residing in the class path, according to the JPA standalone bootstrap
036 * contract. Additionally, most JPA providers will require a special VM agent
037 * (specified on JVM startup) that allows them to instrument application classes.
038 * See the Java Persistence API specification and your provider documentation
039 * for setup details.
040 *
041 * <p>This EntityManagerFactory bootstrap is appropriate for standalone applications
042 * which solely use JPA for data access. If you want to set up your persistence
043 * provider for an external DataSource and/or for global transactions which span
044 * multiple resources, you will need to either deploy it into a full Java EE
045 * application server and access the deployed EntityManagerFactory via JNDI,
046 * or use Spring's {@link LocalContainerEntityManagerFactoryBean} with appropriate
047 * configuration for local setup according to JPA's container contract.
048 *
049 * <p><b>Note:</b> This FactoryBean has limited configuration power in terms of
050 * what configuration it is able to pass to the JPA provider. If you need more
051 * flexible configuration, for example passing a Spring-managed JDBC DataSource
052 * to the JPA provider, consider using Spring's more powerful
053 * {@link LocalContainerEntityManagerFactoryBean} instead.
054 *
055 * <p><b>NOTE: Spring's JPA support requires JPA 2.0 or higher, as of Spring 4.0.</b>
056 * JPA 1.0 based applications are still supported; however, a JPA 2.0/2.1 compliant
057 * persistence provider is needed at runtime.
058 *
059 * @author Juergen Hoeller
060 * @author Rod Johnson
061 * @since 2.0
062 * @see #setJpaProperties
063 * @see #setJpaVendorAdapter
064 * @see JpaTransactionManager#setEntityManagerFactory
065 * @see LocalContainerEntityManagerFactoryBean
066 * @see org.springframework.jndi.JndiObjectFactoryBean
067 * @see org.springframework.orm.jpa.support.SharedEntityManagerBean
068 * @see javax.persistence.Persistence#createEntityManagerFactory
069 * @see javax.persistence.spi.PersistenceProvider#createEntityManagerFactory
070 */
071@SuppressWarnings("serial")
072public class LocalEntityManagerFactoryBean extends AbstractEntityManagerFactoryBean {
073
074        /**
075         * Initialize the EntityManagerFactory for the given configuration.
076         * @throws javax.persistence.PersistenceException in case of JPA initialization errors
077         */
078        @Override
079        protected EntityManagerFactory createNativeEntityManagerFactory() throws PersistenceException {
080                if (logger.isInfoEnabled()) {
081                        logger.info("Building JPA EntityManagerFactory for persistence unit '" + getPersistenceUnitName() + "'");
082                }
083                PersistenceProvider provider = getPersistenceProvider();
084                if (provider != null) {
085                        // Create EntityManagerFactory directly through PersistenceProvider.
086                        EntityManagerFactory emf = provider.createEntityManagerFactory(getPersistenceUnitName(), getJpaPropertyMap());
087                        if (emf == null) {
088                                throw new IllegalStateException(
089                                                "PersistenceProvider [" + provider + "] did not return an EntityManagerFactory for name '" +
090                                                getPersistenceUnitName() + "'");
091                        }
092                        return emf;
093                }
094                else {
095                        // Let JPA perform its standard PersistenceProvider autodetection.
096                        return Persistence.createEntityManagerFactory(getPersistenceUnitName(), getJpaPropertyMap());
097                }
098        }
099
100}