Java tutorial
/* * Copyright 2002-2016 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 * * http://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 com.baomidou.hibernateplus; import java.io.File; import java.io.IOException; import java.util.Properties; import javax.sql.DataSource; import org.hibernate.Interceptor; import org.hibernate.SessionFactory; import org.hibernate.boot.MetadataSources; import org.hibernate.boot.model.naming.ImplicitNamingStrategy; import org.hibernate.boot.model.naming.PhysicalNamingStrategy; import org.hibernate.boot.registry.BootstrapServiceRegistryBuilder; import org.hibernate.cfg.Configuration; import org.hibernate.context.spi.CurrentTenantIdentifierResolver; import org.hibernate.engine.jdbc.connections.spi.MultiTenantConnectionProvider; import org.springframework.beans.factory.DisposableBean; import org.springframework.beans.factory.FactoryBean; import org.springframework.beans.factory.InitializingBean; import org.springframework.context.ResourceLoaderAware; import org.springframework.core.io.ClassPathResource; import org.springframework.core.io.Resource; import org.springframework.core.io.ResourceLoader; import org.springframework.core.io.support.PathMatchingResourcePatternResolver; import org.springframework.core.io.support.ResourcePatternResolver; import org.springframework.core.io.support.ResourcePatternUtils; import org.springframework.core.task.AsyncTaskExecutor; import org.springframework.core.type.filter.TypeFilter; import org.springframework.orm.hibernate5.HibernateExceptionTranslator; import org.springframework.util.Assert; import com.baomidou.hibernateplus.enums.Setting; import com.baomidou.hibernateplus.utils.EntityInfoUtils; /** * {@link FactoryBean} that creates a Hibernate {@link SessionFactory}. This is * the usual way to set up a shared Hibernate SessionFactory in a Spring * application context; the SessionFactory can then be passed to Hibernate-based * data access objects via dependency injection. * <p> * <p> * Compatible with Hibernate 5.0/5.1 as well as 5.2, as of Spring 4.3. Copy * LocalSpringSessionFactoryBean * * @author Juergen Hoeller * @see #setDataSource * @see #setPackagesToScan * @see HibernateSpringSessionFactoryBuilder * @since 4.2 */ public class HibernateSpringSessionFactoryBean extends HibernateExceptionTranslator implements FactoryBean<SessionFactory>, ResourceLoaderAware, InitializingBean, DisposableBean { private DataSource dataSource; private Resource[] configLocations; private String[] mappingResources; private Resource[] mappingLocations; private Resource[] cacheableMappingLocations; private Resource[] mappingJarLocations; private Resource[] mappingDirectoryLocations; private Interceptor entityInterceptor; private ImplicitNamingStrategy implicitNamingStrategy; private PhysicalNamingStrategy physicalNamingStrategy; private Object jtaTransactionManager; private MultiTenantConnectionProvider multiTenantConnectionProvider; private CurrentTenantIdentifierResolver currentTenantIdentifierResolver; private TypeFilter[] entityTypeFilters; private Properties hibernateProperties; private Class<?>[] annotatedClasses; private String[] annotatedPackages; private String[] packagesToScan; private AsyncTaskExecutor bootstrapExecutor; private MetadataSources metadataSources; private ResourcePatternResolver resourcePatternResolver; private Configuration configuration; private SessionFactory sessionFactory; private Setting setting; public void setType(String type) { this.setting = Setting.getSetting(type); } /** * Set the DataSource to be used by the SessionFactory. If set, this will * override corresponding settings in Hibernate properties. * <p> * If this is set, the Hibernate settings should not define a connection * provider to avoid meaningless double configuration. */ public void setDataSource(DataSource dataSource) { this.dataSource = dataSource; } /** * Set the location of a single Hibernate XML config file, for example as * classpath resource "classpath:hibernate.cfg.xml". * <p> * Note: Can be omitted when all necessary properties and mapping resources * are specified locally via this bean. * * @see Configuration#configure(java.net.URL) */ public void setConfigLocation(Resource configLocation) { this.configLocations = new Resource[] { configLocation }; } /** * Set the locations of multiple Hibernate XML config files, for example as * classpath resources * "classpath:hibernate.cfg.xml,classpath:extension.cfg.xml". * <p> * Note: Can be omitted when all necessary properties and mapping resources * are specified locally via this bean. * * @see Configuration#configure(java.net.URL) */ public void setConfigLocations(Resource... configLocations) { this.configLocations = configLocations; } /** * Set Hibernate mapping resources to be found in the class path, like * "example.hbm.xml" or "mypackage/example.hbm.xml". Analogous to mapping * entries in a Hibernate XML config file. Alternative to the more generic * setMappingLocations method. * <p> * Can be used to add to mappings from a Hibernate XML config file, or to * specify all mappings locally. * * @see #setMappingLocations * @see Configuration#addResource */ public void setMappingResources(String... mappingResources) { this.mappingResources = mappingResources; } /** * Set locations of Hibernate mapping files, for example as classpath * resource "classpath:example.hbm.xml". Supports any resource location via * Spring's resource abstraction, for example relative paths like * "WEB-INF/mappings/example.hbm.xml" when running in an application * context. * <p> * Can be used to add to mappings from a Hibernate XML config file, or to * specify all mappings locally. * * @see Configuration#addInputStream */ public void setMappingLocations(Resource... mappingLocations) { this.mappingLocations = mappingLocations; } /** * Set locations of cacheable Hibernate mapping files, for example as web * app resource "/WEB-INF/mapping/example.hbm.xml". Supports any resource * location via Spring's resource abstraction, as long as the resource can * be resolved in the file system. * <p> * Can be used to add to mappings from a Hibernate XML config file, or to * specify all mappings locally. * * @see Configuration#addCacheableFile(File) */ public void setCacheableMappingLocations(Resource... cacheableMappingLocations) { this.cacheableMappingLocations = cacheableMappingLocations; } /** * Set locations of jar files that contain Hibernate mapping resources, like * "WEB-INF/lib/example.hbm.jar". * <p> * Can be used to add to mappings from a Hibernate XML config file, or to * specify all mappings locally. * * @see Configuration#addJar(File) */ public void setMappingJarLocations(Resource... mappingJarLocations) { this.mappingJarLocations = mappingJarLocations; } /** * Set locations of directories that contain Hibernate mapping resources, * like "WEB-INF/mappings". * <p> * Can be used to add to mappings from a Hibernate XML config file, or to * specify all mappings locally. * * @see Configuration#addDirectory(File) */ public void setMappingDirectoryLocations(Resource... mappingDirectoryLocations) { this.mappingDirectoryLocations = mappingDirectoryLocations; } /** * Set a Hibernate entity interceptor that allows to inspect and change * property values before writing to and reading from the database. Will get * applied to any new Session created by this factory. * * @see Configuration#setInterceptor */ public void setEntityInterceptor(Interceptor entityInterceptor) { this.entityInterceptor = entityInterceptor; } /** * Set a Hibernate 5.0 ImplicitNamingStrategy for the SessionFactory. * * @see Configuration#setImplicitNamingStrategy */ public void setImplicitNamingStrategy(ImplicitNamingStrategy implicitNamingStrategy) { this.implicitNamingStrategy = implicitNamingStrategy; } /** * Set a Hibernate 5.0 PhysicalNamingStrategy for the SessionFactory. * * @see Configuration#setPhysicalNamingStrategy */ public void setPhysicalNamingStrategy(PhysicalNamingStrategy physicalNamingStrategy) { this.physicalNamingStrategy = physicalNamingStrategy; } /** * Set the Spring * {@link org.springframework.transaction.jta.JtaTransactionManager} or the * JTA {@link javax.transaction.TransactionManager} to be used with * Hibernate, if any. Implicitly sets up {@code JtaPlatform}. * * @see HibernateSpringSessionFactoryBuilder#setJtaTransactionManager */ public void setJtaTransactionManager(Object jtaTransactionManager) { this.jtaTransactionManager = jtaTransactionManager; } /** * Set a {@link MultiTenantConnectionProvider} to be passed on to the * SessionFactory. * * @see HibernateSpringSessionFactoryBuilder#setMultiTenantConnectionProvider * @since 4.3 */ public void setMultiTenantConnectionProvider(MultiTenantConnectionProvider multiTenantConnectionProvider) { this.multiTenantConnectionProvider = multiTenantConnectionProvider; } /** * Set a {@link CurrentTenantIdentifierResolver} to be passed on to the * SessionFactory. * * @see HibernateSpringSessionFactoryBuilder#setCurrentTenantIdentifierResolver */ public void setCurrentTenantIdentifierResolver( CurrentTenantIdentifierResolver currentTenantIdentifierResolver) { this.currentTenantIdentifierResolver = currentTenantIdentifierResolver; } /** * Specify custom type filters for Spring-based scanning for entity classes. * <p> * Default is to search all specified packages for classes annotated with * {@code @javax.persistence.Entity}, {@code @javax.persistence.Embeddable} * or {@code @javax.persistence.MappedSuperclass}. * * @see #setPackagesToScan */ public void setEntityTypeFilters(TypeFilter... entityTypeFilters) { this.entityTypeFilters = entityTypeFilters; } /** * Return the Hibernate properties, if any. Mainly available for * configuration through property paths that specify individual keys. */ public Properties getHibernateProperties() { if (this.hibernateProperties == null) { this.hibernateProperties = new Properties(); } return this.hibernateProperties; } /** * Set Hibernate properties, such as "hibernate.dialect". * <p> * Note: Do not specify a transaction provider here when using Spring-driven * transactions. It is also advisable to omit connection provider settings * and use a Spring-set DataSource instead. * * @see #setDataSource */ public void setHibernateProperties(Properties hibernateProperties) { this.hibernateProperties = hibernateProperties; } /** * Specify annotated entity classes to register with this Hibernate * SessionFactory. * * @see Configuration#addAnnotatedClass(Class) */ public void setAnnotatedClasses(Class<?>... annotatedClasses) { this.annotatedClasses = annotatedClasses; } /** * Specify the names of annotated packages, for which package-level * annotation metadata will be read. * * @see Configuration#addPackage(String) */ public void setAnnotatedPackages(String... annotatedPackages) { this.annotatedPackages = annotatedPackages; } /** * Specify packages to search for autodetection of your entity classes in * the classpath. This is analogous to Spring's component-scan feature ( * {@link org.springframework.context.annotation.ClassPathBeanDefinitionScanner} * ). */ public void setPackagesToScan(String... packagesToScan) { this.packagesToScan = packagesToScan; } /** * Specify an asynchronous executor for background bootstrapping, e.g. a * {@link org.springframework.core.task.SimpleAsyncTaskExecutor}. * <p> * {@code SessionFactory} initialization will then switch into background * bootstrap mode, with a {@code SessionFactory} proxy immediately returned * for injection purposes instead of waiting for Hibernate's bootstrapping * to complete. However, note that the first actual call to a * {@code SessionFactory} method will then block until Hibernate's * bootstrapping completed, if not ready by then. For maximum benefit, make * sure to avoid early {@code SessionFactory} calls in init methods of * related beans, even for metadata introspection purposes. * * @see HibernateSpringSessionFactoryBuilder#buildSessionFactory(AsyncTaskExecutor) * @since 4.3 */ public void setBootstrapExecutor(AsyncTaskExecutor bootstrapExecutor) { this.bootstrapExecutor = bootstrapExecutor; } /** * Determine the Hibernate {@link MetadataSources} to use. * <p> * Can also be externally called to initialize and pre-populate a * {@link MetadataSources} instance which is then going to be used for * {@link SessionFactory} building. * * @return the MetadataSources to use (never {@code null}) * @see HibernateSpringSessionFactoryBuilder#HibernateSpringSessionFactoryBuilder(DataSource, * ResourceLoader, MetadataSources) * @since 4.3 */ public MetadataSources getMetadataSources() { if (this.metadataSources == null) { BootstrapServiceRegistryBuilder builder = new BootstrapServiceRegistryBuilder(); if (this.resourcePatternResolver != null) { builder = builder.applyClassLoader(this.resourcePatternResolver.getClassLoader()); } this.metadataSources = new MetadataSources(builder.build()); } return this.metadataSources; } /** * Specify a Hibernate {@link MetadataSources} service to use (e.g. reusing * an existing one), potentially populated with a custom Hibernate bootstrap * {@link org.hibernate.service.ServiceRegistry} as well. * * @since 4.3 */ public void setMetadataSources(MetadataSources metadataSources) { Assert.notNull(metadataSources, "MetadataSources must not be null"); this.metadataSources = metadataSources; } /** * Determine the Spring {@link ResourceLoader} to use for Hibernate * metadata. * * @return the ResourceLoader to use (never {@code null}) * @since 4.3 */ public ResourceLoader getResourceLoader() { if (this.resourcePatternResolver == null) { this.resourcePatternResolver = new PathMatchingResourcePatternResolver(); } return this.resourcePatternResolver; } /** * Specify a Spring {@link ResourceLoader} to use for Hibernate metadata. * * @param resourceLoader the ResourceLoader to use (never {@code null}) */ @Override public void setResourceLoader(ResourceLoader resourceLoader) { this.resourcePatternResolver = ResourcePatternUtils.getResourcePatternResolver(resourceLoader); } @Override public void afterPropertiesSet() throws IOException { HibernateSpringSessionFactoryBuilder sfb = new HibernateSpringSessionFactoryBuilder(this.dataSource, getResourceLoader(), getMetadataSources()); if (this.configLocations != null) { for (Resource resource : this.configLocations) { // Load Hibernate configuration from given location. sfb.configure(resource.getURL()); } } if (this.mappingResources != null) { // Register given Hibernate mapping definitions, contained in // resource files. for (String mapping : this.mappingResources) { Resource mr = new ClassPathResource(mapping.trim(), this.resourcePatternResolver.getClassLoader()); sfb.addInputStream(mr.getInputStream()); } } if (this.mappingLocations != null) { // Register given Hibernate mapping definitions, contained in // resource files. for (Resource resource : this.mappingLocations) { sfb.addInputStream(resource.getInputStream()); } } if (this.cacheableMappingLocations != null) { // Register given cacheable Hibernate mapping definitions, read from // the file system. for (Resource resource : this.cacheableMappingLocations) { sfb.addCacheableFile(resource.getFile()); } } if (this.mappingJarLocations != null) { // Register given Hibernate mapping definitions, contained in jar // files. for (Resource resource : this.mappingJarLocations) { sfb.addJar(resource.getFile()); } } if (this.mappingDirectoryLocations != null) { // Register all Hibernate mapping definitions in the given // directories. for (Resource resource : this.mappingDirectoryLocations) { File file = resource.getFile(); if (!file.isDirectory()) { throw new IllegalArgumentException( "Mapping directory location [" + resource + "] does not denote a directory"); } sfb.addDirectory(file); } } if (this.entityInterceptor != null) { sfb.setInterceptor(this.entityInterceptor); } if (this.implicitNamingStrategy != null) { sfb.setImplicitNamingStrategy(this.implicitNamingStrategy); } if (this.physicalNamingStrategy != null) { sfb.setPhysicalNamingStrategy(this.physicalNamingStrategy); } if (this.jtaTransactionManager != null) { sfb.setJtaTransactionManager(this.jtaTransactionManager); } if (this.multiTenantConnectionProvider != null) { sfb.setMultiTenantConnectionProvider(this.multiTenantConnectionProvider); } if (this.currentTenantIdentifierResolver != null) { sfb.setCurrentTenantIdentifierResolver(this.currentTenantIdentifierResolver); } if (this.entityTypeFilters != null) { sfb.setEntityTypeFilters(this.entityTypeFilters); } if (this.hibernateProperties != null) { sfb.addProperties(this.hibernateProperties); } if (this.annotatedClasses != null) { sfb.addAnnotatedClasses(this.annotatedClasses); } if (this.annotatedPackages != null) { sfb.addPackages(this.annotatedPackages); } if (this.packagesToScan != null) { sfb.scanPackages(this.packagesToScan); } // Build SessionFactory instance. this.configuration = sfb; this.sessionFactory = buildSessionFactory(sfb); // TODO Caratacus sessionFactory EntityInfoUtils.initSession(sessionFactory, setting); } /** * Subclasses can override this method to perform custom initialization of * the SessionFactory instance, creating it via the given Configuration * object that got prepared by this LocalSessionFactoryBean. * <p> * The default implementation invokes LocalSessionFactoryBuilder's * buildSessionFactory. A custom implementation could prepare the instance * in a specific way (e.g. applying a custom ServiceRegistry) or use a * custom SessionFactoryImpl subclass. * * @param sfb LocalSessionFactoryBuilder prepared by this * LocalSessionFactoryBean * @return the SessionFactory instance * @see HibernateSpringSessionFactoryBuilder#buildSessionFactory */ protected SessionFactory buildSessionFactory(HibernateSpringSessionFactoryBuilder sfb) { return (this.bootstrapExecutor != null ? sfb.buildSessionFactory(this.bootstrapExecutor) : sfb.buildSessionFactory()); } /** * Return the Hibernate Configuration object used to build the * SessionFactory. Allows for access to configuration metadata stored there * (rarely needed). * * @throws IllegalStateException if the Configuration object has not been initialized yet */ public final Configuration getConfiguration() { if (this.configuration == null) { throw new IllegalStateException("Configuration not initialized yet"); } return this.configuration; } @Override public SessionFactory getObject() { return this.sessionFactory; } @Override public Class<?> getObjectType() { return (this.sessionFactory != null ? this.sessionFactory.getClass() : SessionFactory.class); } @Override public boolean isSingleton() { return true; } @Override public void destroy() { this.sessionFactory.close(); } }