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}