https://github.com/spring-projects/spring-framework: Spring Object/Relational Mapping (Spring IO)
  • Juergen Hoeller 
/*
 * Copyright 2002-2020 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
 *
 *      https://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 java.util.Collections;
import java.util.Map;

import javax.persistence.EntityManager;
import javax.persistence.EntityManagerFactory;
import javax.persistence.spi.PersistenceProvider;
import javax.persistence.spi.PersistenceUnitInfo;

import org.springframework.lang.Nullable;


SPI interface that allows to plug in vendor-specific behavior
into Spring's EntityManagerFactory creators. Serves as single
configuration point for all vendor-specific properties.

Author:Juergen Hoeller, Rod Johnson
See Also:
Since:2.0
/**
 * SPI interface that allows to plug in vendor-specific behavior
 * into Spring's EntityManagerFactory creators. Serves as single
 * configuration point for all vendor-specific properties.
 *
 * @author Juergen Hoeller
 * @author Rod Johnson
 * @since 2.0
 * @see AbstractEntityManagerFactoryBean#setJpaVendorAdapter
 */
public interface JpaVendorAdapter {

	
Return the vendor-specific persistence provider.

/**
	 * Return the vendor-specific persistence provider.
	 */
	PersistenceProvider getPersistenceProvider();

	
Return the name of the persistence provider's root package
(e.g. "oracle.toplink.essentials"). Will be used for
excluding provider classes from temporary class overriding.

Since:2.5.2
/**
	 * Return the name of the persistence provider's root package
	 * (e.g. "oracle.toplink.essentials"). Will be used for
	 * excluding provider classes from temporary class overriding.
	 * @since 2.5.2
	 */
	@Nullable
	default String getPersistenceProviderRootPackage() {
		return null;
	}

	
Return a Map of vendor-specific JPA properties for the given persistence
unit, typically based on settings in this JpaVendorAdapter instance.

Note that there might be further JPA properties defined on the
EntityManagerFactory bean, which might potentially override individual
JPA property values specified here.

This implementation delegates to getJpaPropertyMap() for non-unit-dependent properties. Effectively, this PersistenceUnitInfo-based variant only needs to be implemented if there is an actual need to react to unit-specific characteristics such as the transaction type. 
NOTE: This variant will only be invoked in case of Java EE style container bootstrapping where a PersistenceUnitInfo is present (i.e. LocalContainerEntityManagerFactoryBean. In case of simple Java SE style bootstrapping via Persistence (i.e. LocalEntityManagerFactoryBean), the parameter-less getJpaPropertyMap() variant will be called directly. 
Params:
  • pui – the PersistenceUnitInfo for the current persistence unit
See Also:
  • getTransactionType.getTransactionType()
  • createContainerEntityManagerFactory.createContainerEntityManagerFactory(PersistenceUnitInfo, Map)
Returns:a Map of JPA properties, as accepted by the standard JPA bootstrap
facilities, or an empty Map if there are no properties to expose
Since:4.3.13
/**
	 * Return a Map of vendor-specific JPA properties for the given persistence
	 * unit, typically based on settings in this JpaVendorAdapter instance.
	 * <p>Note that there might be further JPA properties defined on the
	 * EntityManagerFactory bean, which might potentially override individual
	 * JPA property values specified here.
	 * <p>This implementation delegates to {@link #getJpaPropertyMap()} for
	 * non-unit-dependent properties. Effectively, this PersistenceUnitInfo-based
	 * variant only needs to be implemented if there is an actual need to react
	 * to unit-specific characteristics such as the transaction type.
	 * <p><b>NOTE:</b> This variant will only be invoked in case of Java EE style
	 * container bootstrapping where a {@link PersistenceUnitInfo} is present
	 * (i.e. {@link LocalContainerEntityManagerFactoryBean}. In case of simple
	 * Java SE style bootstrapping via {@link javax.persistence.Persistence}
	 * (i.e. {@link LocalEntityManagerFactoryBean}), the parameter-less
	 * {@link #getJpaPropertyMap()} variant will be called directly.
	 * @param pui the PersistenceUnitInfo for the current persistence unit
	 * @return a Map of JPA properties, as accepted by the standard JPA bootstrap
	 * facilities, or an empty Map if there are no properties to expose
	 * @since 4.3.13
	 * @see PersistenceUnitInfo#getTransactionType()
	 * @see javax.persistence.spi.PersistenceProvider#createContainerEntityManagerFactory(PersistenceUnitInfo, Map)
	 */
	default Map<String, ?> getJpaPropertyMap(PersistenceUnitInfo pui) {
		return getJpaPropertyMap();
	}

	
Return a Map of vendor-specific JPA properties,
typically based on settings in this JpaVendorAdapter instance.

Note that there might be further JPA properties defined on the
EntityManagerFactory bean, which might potentially override individual
JPA property values specified here.

See Also:
  • createEntityManagerFactory.createEntityManagerFactory(String, Map)
Returns:a Map of JPA properties, as accepted by the standard JPA bootstrap
facilities, or an empty Map if there are no properties to expose
/**
	 * Return a Map of vendor-specific JPA properties,
	 * typically based on settings in this JpaVendorAdapter instance.
	 * <p>Note that there might be further JPA properties defined on the
	 * EntityManagerFactory bean, which might potentially override individual
	 * JPA property values specified here.
	 * @return a Map of JPA properties, as accepted by the standard JPA bootstrap
	 * facilities, or an empty Map if there are no properties to expose
	 * @see javax.persistence.Persistence#createEntityManagerFactory(String, Map)
	 */
	default Map<String, ?> getJpaPropertyMap() {
		return Collections.emptyMap();
	}

	
Return the vendor-specific JpaDialect implementation for this provider, or null if there is none. 
/**
	 * Return the vendor-specific JpaDialect implementation for this
	 * provider, or {@code null} if there is none.
	 */
	@Nullable
	default JpaDialect getJpaDialect() {
		return null;
	}

	
Return the vendor-specific EntityManagerFactory interface
that the EntityManagerFactory proxy is supposed to implement.

If the provider does not offer any EntityManagerFactory extensions, the adapter should simply return the standard EntityManagerFactory class here. 
Since:2.5.2
/**
	 * Return the vendor-specific EntityManagerFactory interface
	 * that the EntityManagerFactory proxy is supposed to implement.
	 * <p>If the provider does not offer any EntityManagerFactory extensions,
	 * the adapter should simply return the standard
	 * {@link javax.persistence.EntityManagerFactory} class here.
	 * @since 2.5.2
	 */
	default Class<? extends EntityManagerFactory> getEntityManagerFactoryInterface() {
		return EntityManagerFactory.class;
	}

	
Return the vendor-specific EntityManager interface
that this provider's EntityManagers will implement.

If the provider does not offer any EntityManager extensions, the adapter should simply return the standard EntityManager class here. 
/**
	 * Return the vendor-specific EntityManager interface
	 * that this provider's EntityManagers will implement.
	 * <p>If the provider does not offer any EntityManager extensions,
	 * the adapter should simply return the standard
	 * {@link javax.persistence.EntityManager} class here.
	 */
	default Class<? extends EntityManager> getEntityManagerInterface() {
		return EntityManager.class;
	}

	
Optional callback for post-processing the native EntityManagerFactory
before active use.

This can be used for triggering vendor-specific initialization processes.
While this is not expected to be used for most providers, it is included
here as a general extension hook.

/**
	 * Optional callback for post-processing the native EntityManagerFactory
	 * before active use.
	 * <p>This can be used for triggering vendor-specific initialization processes.
	 * While this is not expected to be used for most providers, it is included
	 * here as a general extension hook.
	 */
	default void postProcessEntityManagerFactory(EntityManagerFactory emf) {
	}

	
Optional callback for post-processing the native EntityManager
before active use.

This can be used for setting vendor-specific parameters, e.g.
Hibernate filters, on every new EntityManager.

Since:5.3
/**
	 * Optional callback for post-processing the native EntityManager
	 * before active use.
	 * <p>This can be used for setting vendor-specific parameters, e.g.
	 * Hibernate filters, on every new EntityManager.
	 * @since 5.3
	 */
	default void postProcessEntityManager(EntityManager em) {
	}

}