protected EntityManagerFactory createNativeEntityManagerFactory() throws PersistenceException 
{
		PersistenceUnitManager managerToUse = this.persistenceUnitManager;
		if (this.persistenceUnitManager == null) {
			this.internalPersistenceUnitManager.afterPropertiesSet();
			managerToUse = this.internalPersistenceUnitManager;
		}
		this.persistenceUnitInfo = determinePersistenceUnitInfo(managerToUse);
		JpaVendorAdapter jpaVendorAdapter = getJpaVendorAdapter();
		if (jpaVendorAdapter != null && this.persistenceUnitInfo instanceof MutablePersistenceUnitInfo) {
			((MutablePersistenceUnitInfo) this.persistenceUnitInfo).setPersistenceProviderPackageName(
					jpaVendorAdapter.getPersistenceProviderRootPackage());
		}
		PersistenceProvider provider = getPersistenceProvider();
		if (provider == null) {
			String providerClassName = this.persistenceUnitInfo.getPersistenceProviderClassName();
			if (providerClassName == null) {
				throw new IllegalArgumentException(
						"No PersistenceProvider specified in EntityManagerFactory configuration, " +
						"and chosen PersistenceUnitInfo does not specify a provider class name either");
			}
			Class providerClass = ClassUtils.resolveClassName(providerClassName, getBeanClassLoader());
			provider = (PersistenceProvider) BeanUtils.instantiateClass(providerClass);
		}
		if (provider == null) {
			throw new IllegalStateException("Unable to determine persistence provider. " +
					"Please check configuration of " + getClass().getName() + "; " +
					"ideally specify the appropriate JpaVendorAdapter class for this provider.");
		}
		if (logger.isInfoEnabled()) {
			logger.info("Building JPA container EntityManagerFactory for persistence unit '" +
					this.persistenceUnitInfo.getPersistenceUnitName() + "'");
		}
		this.nativeEntityManagerFactory =
				provider.createContainerEntityManagerFactory(this.persistenceUnitInfo, getJpaPropertyMap());
		postProcessEntityManagerFactory(this.nativeEntityManagerFactory, this.persistenceUnitInfo);
		return this.nativeEntityManagerFactory;
}

 protected PersistenceUnitInfo determinePersistenceUnitInfo(PersistenceUnitManager persistenceUnitManager) 
{
		if (getPersistenceUnitName() != null) {
			return persistenceUnitManager.obtainPersistenceUnitInfo(getPersistenceUnitName());
		}
		else {
			return persistenceUnitManager.obtainDefaultPersistenceUnitInfo();
		}
}

Determine the PersistenceUnitInfo to use for the EntityManagerFactory created by this bean.

The default implementation reads in all persistence unit infos from persistence.xml, as defined in the JPA specification. If no entity manager name was specified, it takes the first info in the array as returned by the reader. Otherwise, it checks for a matching name.

 public DataSource getDataSource() 
{
		if (this.persistenceUnitInfo != null) {
			return this.persistenceUnitInfo.getNonJtaDataSource();
		}
		return this.internalPersistenceUnitManager.getDefaultDataSource();
}

 public PersistenceUnitInfo getPersistenceUnitInfo() 
{
		return this.persistenceUnitInfo;
}

 public String getPersistenceUnitName() 
{
		if (this.persistenceUnitInfo != null) {
			return this.persistenceUnitInfo.getPersistenceUnitName();
		}
		return super.getPersistenceUnitName();
}

 protected  void postProcessEntityManagerFactory(EntityManagerFactory emf,
    PersistenceUnitInfo pui) 
{

}

Hook method allowing subclasses to customize the EntityManagerFactory after its creation via the PersistenceProvider.

The default implementation is empty.

 public  void setDataSource(DataSource dataSource) 
{
		this.internalPersistenceUnitManager.setDataSourceLookup(new SingleDataSourceLookup(dataSource));
		this.internalPersistenceUnitManager.setDefaultDataSource(dataSource);
}

Specify the JDBC DataSource that the JPA persistence provider is supposed to use for accessing the database. This is an alternative to keeping the JDBC configuration in persistence.xml, passing in a Spring-managed DataSource instead.

In JPA speak, a DataSource passed in here will be used as "nonJtaDataSource" on the PersistenceUnitInfo passed to the PersistenceProvider, overriding data source configuration in persistence.xml (if any).

NOTE: Only applied if no external PersistenceUnitManager specified.

 public  void setLoadTimeWeaver(LoadTimeWeaver loadTimeWeaver) 
{
		this.internalPersistenceUnitManager.setLoadTimeWeaver(loadTimeWeaver);
}

Specify the Spring LoadTimeWeaver to use for class instrumentation according to the JPA class transformer contract.

It is a not required to specify a LoadTimeWeaver: Most providers will be able to provide a subset of their functionality without class instrumentation as well, or operate with their VM agent specified on JVM startup.

In terms of Spring-provided weaving options, the most important ones are InstrumentationLoadTimeWeaver, which requires a Spring-specific (but very general) VM agent specified on JVM startup, and ReflectiveLoadTimeWeaver, which interacts with an underlying ClassLoader based on specific extended methods being available on it (for example, interacting with Spring's TomcatInstrumentableClassLoader).

NOTE: As of Spring 2.5, the context's default LoadTimeWeaver (defined as bean with name "loadTimeWeaver") will be picked up automatically, if available, removing the need for LoadTimeWeaver configuration on each affected target bean. Consider using the context:load-time-weaver XML tag for creating such a shared LoadTimeWeaver (autodetecting the environment by default).

NOTE: Only applied if no external PersistenceUnitManager specified. Otherwise, the external PersistenceUnitManager is responsible for the weaving configuration.

 public  void setPersistenceUnitManager(PersistenceUnitManager persistenceUnitManager) 
{
	                                                                                                 	 
		this.persistenceUnitManager = persistenceUnitManager;
}

Set the PersistenceUnitManager to use for obtaining the JPA persistence unit that this FactoryBean is supposed to build an EntityManagerFactory for.

The default is to rely on the local settings specified on this FactoryBean, such as "persistenceXmlLocation", "dataSource" and "loadTimeWeaver".

For reuse of existing persistence unit configuration or more advanced forms of custom persistence unit handling, consider defining a separate PersistenceUnitManager bean (typically a DefaultPersistenceUnitManager instance) and linking it in here. persistence.xml location, DataSource configuration and LoadTimeWeaver will be defined on that separate DefaultPersistenceUnitManager bean in such a scenario.

 public  void setPersistenceUnitPostProcessors(PersistenceUnitPostProcessor[] postProcessors) 
{
		this.internalPersistenceUnitManager.setPersistenceUnitPostProcessors(postProcessors);
}

Set the PersistenceUnitPostProcessors to be applied to the PersistenceUnitInfo used for creating this EntityManagerFactory.

Such post-processors can, for example, register further entity classes and jar files, in addition to the metadata read in from persistence.xml.

NOTE: Only applied if no external PersistenceUnitManager specified.

 public  void setPersistenceXmlLocation(String persistenceXmlLocation) 
{
		this.internalPersistenceUnitManager.setPersistenceXmlLocations(new String[] {persistenceXmlLocation});
}

Set the location of the persistence.xml file we want to use. This is a Spring resource location.

Default is "classpath:META-INF/persistence.xml".

NOTE: Only applied if no external PersistenceUnitManager specified.

 public  void setResourceLoader(ResourceLoader resourceLoader) 
{
		this.internalPersistenceUnitManager.setResourceLoader(resourceLoader);
}