Hacking

See spring-projectsgh-9528

spring-boot-autoconfigure/src/main/java/org/springframework/boot/autoconfigure/jdbc/DataSourceAutoConfiguration.java

@@ -19,9 +19,6 @@
 import javax.sql.DataSource;
 import javax.sql.XADataSource;
 
-import org.apache.commons.logging.Log;
-import org.apache.commons.logging.LogFactory;
-
 import org.springframework.beans.factory.BeanFactoryUtils;
 import org.springframework.beans.factory.NoSuchBeanDefinitionException;
 import org.springframework.beans.factory.config.BeanDefinition;
@@ -34,11 +31,8 @@
 import org.springframework.boot.autoconfigure.condition.ConditionalOnMissingBean;
 import org.springframework.boot.autoconfigure.condition.ConditionalOnProperty;
 import org.springframework.boot.autoconfigure.condition.SpringBootCondition;
-import org.springframework.boot.autoconfigure.jdbc.DataSourceInitializerPostProcessor.Registrar;
 import org.springframework.boot.autoconfigure.jdbc.metadata.DataSourcePoolMetadataProvidersConfiguration;
 import org.springframework.boot.context.properties.EnableConfigurationProperties;
-import org.springframework.context.ApplicationContext;
-import org.springframework.context.annotation.Bean;
 import org.springframework.context.annotation.Condition;
 import org.springframework.context.annotation.ConditionContext;
 import org.springframework.context.annotation.Conditional;
@@ -60,19 +54,9 @@
 @Configuration
 @ConditionalOnClass({ DataSource.class, EmbeddedDatabaseType.class })
 @EnableConfigurationProperties(DataSourceProperties.class)
-@Import({ Registrar.class, DataSourcePoolMetadataProvidersConfiguration.class })
+@Import(DataSourcePoolMetadataProvidersConfiguration.class)
 public class DataSourceAutoConfiguration {
 
-	private static final Log logger = LogFactory
-			.getLog(DataSourceAutoConfiguration.class);
-
-	@Bean
-	@ConditionalOnMissingBean
-	public DataSourceInitializer dataSourceInitializer(DataSourceProperties properties,
-			ApplicationContext applicationContext) {
-		return new DataSourceInitializer(properties, applicationContext);
-	}
-
 	/**
 	 * Determines if the {@code dataSource} being used by Spring was created from
 	 * {@link EmbeddedDataSourceConfiguration}.
@@ -94,7 +78,8 @@ public static boolean containsAutoConfiguredDataSource(
 	@Configuration
 	@Conditional(EmbeddedDatabaseCondition.class)
 	@ConditionalOnMissingBean({ DataSource.class, XADataSource.class })
-	@Import(EmbeddedDataSourceConfiguration.class)
+	@Import({ EmbeddedDataSourceConfiguration.class,
+			DataSourceInitializationConfiguration.class })
 	protected static class EmbeddedDatabaseConfiguration {
 
 	}
@@ -104,7 +89,8 @@ protected static class EmbeddedDatabaseConfiguration {
 	@ConditionalOnMissingBean({ DataSource.class, XADataSource.class })
 	@Import({ DataSourceConfiguration.Hikari.class, DataSourceConfiguration.Tomcat.class,
 			DataSourceConfiguration.Dbcp2.class, DataSourceConfiguration.Generic.class,
-			DataSourceJmxConfiguration.class })
+			DataSourceJmxConfiguration.class,
+			DataSourceInitializationConfiguration.class })
 	protected static class PooledDataSourceConfiguration {
 
 	}

spring-boot-autoconfigure/src/main/java/org/springframework/boot/autoconfigure/jdbc/DataSourceInitializationConfiguration.java

@@ -0,0 +1,63 @@
+/*
+ * Copyright 2012-2017 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 org.springframework.boot.autoconfigure.jdbc;
+
+import org.springframework.beans.factory.config.BeanDefinition;
+import org.springframework.beans.factory.support.BeanDefinitionRegistry;
+import org.springframework.beans.factory.support.GenericBeanDefinition;
+import org.springframework.context.annotation.Configuration;
+import org.springframework.context.annotation.Import;
+import org.springframework.context.annotation.ImportBeanDefinitionRegistrar;
+import org.springframework.core.type.AnnotationMetadata;
+
+/**
+ * Configures DataSource initialization.
+ *
+ * @author Stephane Nicoll
+ */
+@Configuration
+@Import({ DataSourceInitializationConfiguration.Registrar.class,
+		DataSourceInitializerInvoker.class })
+class DataSourceInitializationConfiguration {
+
+
+	/**
+	 * {@link ImportBeanDefinitionRegistrar} to register the
+	 * {@link DataSourceInitializerPostProcessor} without causing early bean instantiation
+	 * issues.
+	 */
+	static class Registrar implements ImportBeanDefinitionRegistrar {
+
+		private static final String BEAN_NAME = "dataSourceInitializerPostProcessor";
+
+		@Override
+		public void registerBeanDefinitions(AnnotationMetadata importingClassMetadata,
+				BeanDefinitionRegistry registry) {
+			if (!registry.containsBeanDefinition(BEAN_NAME)) {
+				GenericBeanDefinition beanDefinition = new GenericBeanDefinition();
+				beanDefinition.setBeanClass(DataSourceInitializerPostProcessor.class);
+				beanDefinition.setRole(BeanDefinition.ROLE_INFRASTRUCTURE);
+				// We don't need this one to be post processed otherwise it can cause a
+				// cascade of bean instantiation that we would rather avoid.
+				beanDefinition.setSynthetic(true);
+				registry.registerBeanDefinition(BEAN_NAME, beanDefinition);
+			}
+		}
+
+	}
+
+}

spring-boot-autoconfigure/src/main/java/org/springframework/boot/autoconfigure/jdbc/DataSourceInitializer.java

@@ -20,107 +20,89 @@
 import java.util.Collections;
 import java.util.List;
 
-import javax.annotation.PostConstruct;
 import javax.sql.DataSource;
 
 import org.apache.commons.logging.Log;
 import org.apache.commons.logging.LogFactory;
 
 import org.springframework.boot.context.config.ResourceNotFoundException;
-import org.springframework.context.ApplicationContext;
-import org.springframework.context.ApplicationListener;
+import org.springframework.core.io.DefaultResourceLoader;
 import org.springframework.core.io.Resource;
+import org.springframework.core.io.ResourceLoader;
 import org.springframework.jdbc.config.SortedResourcesFactoryBean;
 import org.springframework.jdbc.datasource.init.DatabasePopulatorUtils;
 import org.springframework.jdbc.datasource.init.ResourceDatabasePopulator;
 import org.springframework.util.StringUtils;
 
 /**
- * Bean to handle {@link DataSource} initialization by running {@literal schema-*.sql} on
- * {@link PostConstruct} and {@literal data-*.sql} SQL scripts on a
- * {@link DataSourceInitializedEvent}.
+ * Initialize a {@link DataSource} based on a matching {@link DataSourceProperties}
+ * config.
  *
- * @author Dave Syer
- * @author Phillip Webb
- * @author Eddú Meléndez
  * @author Stephane Nicoll
- * @author Kazuki Shimizu
- * @since 1.1.0
- * @see DataSourceAutoConfiguration
+ * @since 2.0.0
  */
-class DataSourceInitializer implements ApplicationListener<DataSourceInitializedEvent> {
+public class DataSourceInitializer {
 
 	private static final Log logger = LogFactory.getLog(DataSourceInitializer.class);
 
-	private final DataSourceProperties properties;
-
-	private final ApplicationContext applicationContext;
-
-	private DataSource dataSource;
+	private final DataSource dataSource;
 
-	private boolean initialized = false;
+	private final DataSourceProperties properties;
 
-	DataSourceInitializer(DataSourceProperties properties,
-			ApplicationContext applicationContext) {
+	private final ResourceLoader resourceLoader;
+
+	/**
+	 * Create a new instance with the {@link DataSource} to initialize and its matching
+	 * {@link DataSourceProperties configuration}.
+	 * @param dataSource the datasource to initialize
+	 * @param properties the matching configuration
+	 * @param resourceLoader the resource loader to use (can be null)
+	 */
+	public DataSourceInitializer(DataSource dataSource, DataSourceProperties properties,
+			ResourceLoader resourceLoader) {
+		this.dataSource = dataSource;
 		this.properties = properties;
-		this.applicationContext = applicationContext;
+		this.resourceLoader = (resourceLoader != null ? resourceLoader
+				: new DefaultResourceLoader());
 	}
 
-	@PostConstruct
-	public void init() {
+	/**
+	 * Create a new instance with the {@link DataSource} to initialize and its matching
+	 * {@link DataSourceProperties configuration}.
+	 * @param dataSource the datasource to initialize
+	 * @param properties the matching configuration
+	 */
+	public DataSourceInitializer(DataSource dataSource, DataSourceProperties properties) {
+		this(dataSource, properties, null);
+	}
+
+	/**
+	 * Create the schema if necessary.
+	 * @see DataSourceProperties#getSchema()
+	 */
+	public void createSchema() {
 		if (!this.properties.isInitialize()) {
 			logger.debug("Initialization disabled (not running DDL scripts)");
 			return;
 		}
-		if (this.applicationContext.getBeanNamesForType(DataSource.class, false,
-				false).length > 0) {
-			this.dataSource = this.applicationContext.getBean(DataSource.class);
-		}
-		if (this.dataSource == null) {
-			logger.debug("No DataSource found so not initializing");
-			return;
-		}
-		runSchemaScripts();
-	}
-
-	private void runSchemaScripts() {
 		List<Resource> scripts = getScripts("spring.datasource.schema",
 				this.properties.getSchema(), "schema");
 		if (!scripts.isEmpty()) {
 			String username = this.properties.getSchemaUsername();
 			String password = this.properties.getSchemaPassword();
 			runScripts(scripts, username, password);
-			try {
-				this.applicationContext
-						.publishEvent(new DataSourceInitializedEvent(this.dataSource));
-				// The listener might not be registered yet, so don't rely on it.
-				if (!this.initialized) {
-					runDataScripts();
-					this.initialized = true;
-				}
-			}
-			catch (IllegalStateException ex) {
-				logger.warn("Could not send event to complete DataSource initialization ("
-						+ ex.getMessage() + ")");
-			}
 		}
 	}
 
-	@Override
-	public void onApplicationEvent(DataSourceInitializedEvent event) {
+	/**
+	 * Initialize the schema if necessary.
+	 * @see DataSourceProperties#getData()
+	 */
+	public void initSchema() {
 		if (!this.properties.isInitialize()) {
 			logger.debug("Initialization disabled (not running data scripts)");
 			return;
 		}
-		// NOTE the event can happen more than once and
-		// the event datasource is not used here
-		if (!this.initialized) {
-			runDataScripts();
-			this.initialized = true;
-		}
-	}
-
-	private void runDataScripts() {
 		List<Resource> scripts = getScripts("spring.datasource.data",
 				this.properties.getData(), "data");
 		String username = this.properties.getDataUsername();
@@ -159,7 +141,7 @@ else if (validate) {
 	private Resource[] doGetResources(String location) {
 		try {
 			SortedResourcesFactoryBean factory = new SortedResourcesFactoryBean(
-					this.applicationContext, Collections.singletonList(location));
+					this.resourceLoader, Collections.singletonList(location));
 			factory.afterPropertiesSet();
 			return factory.getObject();
 		}

spring-boot-autoconfigure/src/main/java/org/springframework/boot/autoconfigure/jdbc/DataSourceInitializerInvoker.java

@@ -0,0 +1,60 @@
+/*
+ * Copyright 2012-2017 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 org.springframework.boot.autoconfigure.jdbc;
+
+import javax.annotation.PostConstruct;
+import javax.sql.DataSource;
+
+import org.springframework.beans.factory.InitializingBean;
+import org.springframework.beans.factory.ObjectProvider;
+import org.springframework.beans.factory.SmartInitializingSingleton;
+import org.springframework.context.ApplicationContext;
+
+/**
+ * Bean to handle {@link DataSource} initialization by running {@literal schema-*.sql} on
+ * {@link InitializingBean#afterPropertiesSet()} and {@literal data-*.sql} SQL scripts on
+ * a {@link SmartInitializingSingleton#afterSingletonsInstantiated()}.
+ *
+ * @author Dave Syer
+ * @author Phillip Webb
+ * @author Eddú Meléndez
+ * @author Stephane Nicoll
+ * @author Kazuki Shimizu
+ * @since 1.1.0
+ * @see DataSourceAutoConfiguration
+ */
+class DataSourceInitializerInvoker implements InitializingBean {
+
+	private final DataSourceInitializer dataSourceInitializer;
+
+	DataSourceInitializerInvoker(ObjectProvider<DataSource> dataSource,
+			DataSourceProperties properties,
+			ApplicationContext applicationContext) {
+		DataSource ds = dataSource.getIfAvailable();
+		this.dataSourceInitializer = ds != null
+				? new DataSourceInitializer(ds, properties, applicationContext) : null;
+	}
+
+	@Override
+	public void afterPropertiesSet() {
+		if (this.dataSourceInitializer != null) {
+			this.dataSourceInitializer.createSchema();
+			this.dataSourceInitializer.initSchema();
+		}
+	}
+
+}