001: /*
002: * Copyright 2002-2007 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: * http://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:
017: package org.springframework.orm.jpa;
018:
019: import javax.persistence.EntityManagerFactory;
020: import javax.persistence.Persistence;
021: import javax.persistence.PersistenceException;
022: import 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 org.springframework.orm.jpa.LocalContainerEntityManagerFactoryBean}
032: * definition is just a matter of configuration!
033: *
034: * <p>Configuration settings are usually read from a <code>META-INF/persistence.xml</code>
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 5
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: * @author Juergen Hoeller
056: * @author Rod Johnson
057: * @since 2.0
058: * @see #setJpaProperties
059: * @see #setJpaVendorAdapter
060: * @see JpaTemplate#setEntityManagerFactory
061: * @see JpaTransactionManager#setEntityManagerFactory
062: * @see LocalContainerEntityManagerFactoryBean
063: * @see org.springframework.jndi.JndiObjectFactoryBean
064: * @see org.springframework.orm.jpa.support.SharedEntityManagerBean
065: * @see javax.persistence.Persistence#createEntityManagerFactory
066: * @see javax.persistence.spi.PersistenceProvider#createEntityManagerFactory
067: */
068: public class LocalEntityManagerFactoryBean extends
069: AbstractEntityManagerFactoryBean {
070:
071: /**
072: * Initialize the EntityManagerFactory for the given configuration.
073: * @throws javax.persistence.PersistenceException in case of JPA initialization errors
074: */
075: protected EntityManagerFactory createNativeEntityManagerFactory()
076: throws PersistenceException {
077: if (logger.isInfoEnabled()) {
078: logger
079: .info("Building JPA EntityManagerFactory for persistence unit '"
080: + getPersistenceUnitName() + "'");
081: }
082: PersistenceProvider provider = getPersistenceProvider();
083: if (provider != null) {
084: // Create EntityManagerFactory directly through PersistenceProvider.
085: EntityManagerFactory emf = provider
086: .createEntityManagerFactory(
087: getPersistenceUnitName(),
088: getJpaPropertyMap());
089: if (emf == null) {
090: throw new IllegalStateException(
091: "PersistenceProvider ["
092: + provider
093: + "] did not return an EntityManagerFactory for name '"
094: + getPersistenceUnitName() + "'");
095: }
096: return emf;
097: } else {
098: // Let JPA perform its standard PersistenceProvider autodetection.
099: return Persistence.createEntityManagerFactory(
100: getPersistenceUnitName(), getJpaPropertyMap());
101: }
102: }
103:
104: }
|