From 4cdfa2eecc4984fbe712f334e41e43ddb6cfffab Mon Sep 17 00:00:00 2001 From: Andy Wilkinson Date: Fri, 14 Mar 2025 17:42:06 +0000 Subject: [PATCH] Separate R2DBC and JDBC database initialization Co-authored-by: Phillip Webb --- ...urcePoolMetricsAutoConfigurationTests.java | 6 +- ...ibernateMetricsAutoConfigurationTests.java | 4 +- ...nDataSourceScriptDatabaseInitializer.java} | 35 ++-- .../jdbc/DataSourceAutoConfiguration.java | 3 +- ...ourceInitializationAutoConfiguration.java} | 32 +++- ...cationR2dbcScriptDatabaseInitializer.java} | 33 ++-- .../r2dbc/R2dbcAutoConfiguration.java | 5 +- ...R2dbcInitializationAutoConfiguration.java} | 30 ++-- .../ApplicationScriptDatabaseInitializer.java | 45 ++++++ .../init/ConditionalOnSqlInitialization.java | 40 +++++ .../init/OnSqlInitializationCondition.java | 33 ++++ .../SqlInitializationAutoConfiguration.java | 57 ------- ...ot.autoconfigure.AutoConfiguration.imports | 3 +- ...dbcRepositoriesAutoConfigurationTests.java | 6 +- ...eInitializationAutoConfigurationTests.java | 152 ++++++++++++++++++ ...iverConfigurationFailureAnalyzerTests.java | 3 +- .../JdbcTemplateAutoConfigurationTests.java | 3 +- .../AbstractJpaAutoConfigurationTests.java | 4 +- ...InitializationAutoConfigurationTests.java} | 94 +++-------- ...itional-spring-configuration-metadata.json | 10 ++ ...re.data.jdbc.AutoConfigureDataJdbc.imports | 2 +- ....data.r2dbc.AutoConfigureDataR2dbc.imports | 2 +- ...toconfigure.jdbc.AutoConfigureJdbc.imports | 2 +- ...toconfigure.jooq.AutoConfigureJooq.imports | 2 +- ...igure.orm.jpa.AutoConfigureDataJpa.imports | 2 +- 25 files changed, 392 insertions(+), 216 deletions(-) rename spring-boot-project/spring-boot-autoconfigure-all/src/main/java/org/springframework/boot/autoconfigure/{sql/init/SqlDataSourceScriptDatabaseInitializer.java => jdbc/ApplicationDataSourceScriptDatabaseInitializer.java} (50%) rename spring-boot-project/spring-boot-autoconfigure-all/src/main/java/org/springframework/boot/autoconfigure/{sql/init/DataSourceInitializationConfiguration.java => jdbc/DataSourceInitializationAutoConfiguration.java} (57%) rename spring-boot-project/spring-boot-autoconfigure-all/src/main/java/org/springframework/boot/autoconfigure/{sql/init/SqlR2dbcScriptDatabaseInitializer.java => r2dbc/ApplicationR2dbcScriptDatabaseInitializer.java} (54%) rename spring-boot-project/spring-boot-autoconfigure-all/src/main/java/org/springframework/boot/autoconfigure/{sql/init/R2dbcInitializationConfiguration.java => r2dbc/R2dbcInitializationAutoConfiguration.java} (57%) create mode 100644 spring-boot-project/spring-boot-autoconfigure-all/src/main/java/org/springframework/boot/autoconfigure/sql/init/ApplicationScriptDatabaseInitializer.java create mode 100644 spring-boot-project/spring-boot-autoconfigure-all/src/main/java/org/springframework/boot/autoconfigure/sql/init/ConditionalOnSqlInitialization.java create mode 100644 spring-boot-project/spring-boot-autoconfigure-all/src/main/java/org/springframework/boot/autoconfigure/sql/init/OnSqlInitializationCondition.java delete mode 100644 spring-boot-project/spring-boot-autoconfigure-all/src/main/java/org/springframework/boot/autoconfigure/sql/init/SqlInitializationAutoConfiguration.java create mode 100644 spring-boot-project/spring-boot-autoconfigure-all/src/test/java/org/springframework/boot/autoconfigure/jdbc/DataSourceInitializationAutoConfigurationTests.java rename spring-boot-project/spring-boot-autoconfigure-all/src/test/java/org/springframework/boot/autoconfigure/{sql/init/SqlInitializationAutoConfigurationTests.java => r2dbc/R2dbcInitializationAutoConfigurationTests.java} (58%) diff --git a/spring-boot-project/spring-boot-actuator-autoconfigure/src/test/java/org/springframework/boot/actuate/autoconfigure/metrics/jdbc/DataSourcePoolMetricsAutoConfigurationTests.java b/spring-boot-project/spring-boot-actuator-autoconfigure/src/test/java/org/springframework/boot/actuate/autoconfigure/metrics/jdbc/DataSourcePoolMetricsAutoConfigurationTests.java index 7f43cc4fb8..592594ac2b 100644 --- a/spring-boot-project/spring-boot-actuator-autoconfigure/src/test/java/org/springframework/boot/actuate/autoconfigure/metrics/jdbc/DataSourcePoolMetricsAutoConfigurationTests.java +++ b/spring-boot-project/spring-boot-actuator-autoconfigure/src/test/java/org/springframework/boot/actuate/autoconfigure/metrics/jdbc/DataSourcePoolMetricsAutoConfigurationTests.java @@ -34,7 +34,7 @@ import org.springframework.boot.LazyInitializationBeanFactoryPostProcessor; import org.springframework.boot.actuate.autoconfigure.metrics.test.MetricsRun; import org.springframework.boot.autoconfigure.AutoConfigurations; import org.springframework.boot.autoconfigure.jdbc.DataSourceAutoConfiguration; -import org.springframework.boot.autoconfigure.sql.init.SqlInitializationAutoConfiguration; +import org.springframework.boot.autoconfigure.jdbc.DataSourceInitializationAutoConfiguration; import org.springframework.boot.jdbc.DataSourceBuilder; import org.springframework.boot.jdbc.metadata.DataSourcePoolMetadataProvider; import org.springframework.boot.test.context.runner.ApplicationContextRunner; @@ -125,8 +125,8 @@ class DataSourcePoolMetricsAutoConfigurationTests { @Test void autoConfiguredHikariDataSourceIsInstrumentedWhenUsingDataSourceInitialization() { this.contextRunner.withPropertyValues("spring.sql.init.schema:db/create-custom-schema.sql") - .withConfiguration( - AutoConfigurations.of(DataSourceAutoConfiguration.class, SqlInitializationAutoConfiguration.class)) + .withConfiguration(AutoConfigurations.of(DataSourceAutoConfiguration.class, + DataSourceInitializationAutoConfiguration.class)) .run((context) -> { context.getBean(DataSource.class).getConnection(); MeterRegistry registry = context.getBean(MeterRegistry.class); diff --git a/spring-boot-project/spring-boot-actuator-autoconfigure/src/test/java/org/springframework/boot/actuate/autoconfigure/metrics/orm/jpa/HibernateMetricsAutoConfigurationTests.java b/spring-boot-project/spring-boot-actuator-autoconfigure/src/test/java/org/springframework/boot/actuate/autoconfigure/metrics/orm/jpa/HibernateMetricsAutoConfigurationTests.java index fcbeb3adc6..23422d419e 100644 --- a/spring-boot-project/spring-boot-actuator-autoconfigure/src/test/java/org/springframework/boot/actuate/autoconfigure/metrics/orm/jpa/HibernateMetricsAutoConfigurationTests.java +++ b/spring-boot-project/spring-boot-actuator-autoconfigure/src/test/java/org/springframework/boot/actuate/autoconfigure/metrics/orm/jpa/HibernateMetricsAutoConfigurationTests.java @@ -35,9 +35,9 @@ import org.mockito.ArgumentMatchers; import org.springframework.boot.actuate.autoconfigure.metrics.test.MetricsRun; import org.springframework.boot.autoconfigure.AutoConfigurations; import org.springframework.boot.autoconfigure.jdbc.DataSourceAutoConfiguration; +import org.springframework.boot.autoconfigure.jdbc.DataSourceInitializationAutoConfiguration; import org.springframework.boot.autoconfigure.orm.jpa.EntityManagerFactoryBuilderCustomizer; import org.springframework.boot.autoconfigure.orm.jpa.HibernateJpaAutoConfiguration; -import org.springframework.boot.autoconfigure.sql.init.SqlInitializationAutoConfiguration; import org.springframework.boot.orm.jpa.EntityManagerFactoryBuilder; import org.springframework.boot.test.context.FilteredClassLoader; import org.springframework.boot.test.context.runner.ApplicationContextRunner; @@ -154,7 +154,7 @@ class HibernateMetricsAutoConfigurationTests { this.contextRunner .withPropertyValues("spring.jpa.properties.hibernate.generate_statistics:true", "spring.sql.init.schema-locations:city-schema.sql", "spring.sql.init.data-locations=city-data.sql") - .withConfiguration(AutoConfigurations.of(SqlInitializationAutoConfiguration.class)) + .withConfiguration(AutoConfigurations.of(DataSourceInitializationAutoConfiguration.class)) .withBean(EntityManagerFactoryBuilderCustomizer.class, () -> (builder) -> builder.setBootstrapExecutor(new SimpleAsyncTaskExecutor())) .run((context) -> { diff --git a/spring-boot-project/spring-boot-autoconfigure-all/src/main/java/org/springframework/boot/autoconfigure/sql/init/SqlDataSourceScriptDatabaseInitializer.java b/spring-boot-project/spring-boot-autoconfigure-all/src/main/java/org/springframework/boot/autoconfigure/jdbc/ApplicationDataSourceScriptDatabaseInitializer.java similarity index 50% rename from spring-boot-project/spring-boot-autoconfigure-all/src/main/java/org/springframework/boot/autoconfigure/sql/init/SqlDataSourceScriptDatabaseInitializer.java rename to spring-boot-project/spring-boot-autoconfigure-all/src/main/java/org/springframework/boot/autoconfigure/jdbc/ApplicationDataSourceScriptDatabaseInitializer.java index 107dbc94aa..c73737a2a6 100644 --- a/spring-boot-project/spring-boot-autoconfigure-all/src/main/java/org/springframework/boot/autoconfigure/sql/init/SqlDataSourceScriptDatabaseInitializer.java +++ b/spring-boot-project/spring-boot-autoconfigure-all/src/main/java/org/springframework/boot/autoconfigure/jdbc/ApplicationDataSourceScriptDatabaseInitializer.java @@ -14,13 +14,14 @@ * limitations under the License. */ -package org.springframework.boot.autoconfigure.sql.init; +package org.springframework.boot.autoconfigure.jdbc; import javax.sql.DataSource; +import org.springframework.boot.autoconfigure.sql.init.ApplicationScriptDatabaseInitializer; +import org.springframework.boot.autoconfigure.sql.init.SqlInitializationProperties; import org.springframework.boot.jdbc.init.DataSourceScriptDatabaseInitializer; import org.springframework.boot.sql.init.DatabaseInitializationSettings; -import org.springframework.context.annotation.ImportRuntimeHints; /** * {@link DataSourceScriptDatabaseInitializer} for the primary SQL database. May be @@ -30,39 +31,27 @@ import org.springframework.context.annotation.ImportRuntimeHints; * @author Phillip Webb * @since 2.6.0 */ -@ImportRuntimeHints(SqlInitializationScriptsRuntimeHints.class) -public class SqlDataSourceScriptDatabaseInitializer extends DataSourceScriptDatabaseInitializer { +public class ApplicationDataSourceScriptDatabaseInitializer extends DataSourceScriptDatabaseInitializer + implements ApplicationScriptDatabaseInitializer { /** - * Create a new {@link SqlDataSourceScriptDatabaseInitializer} instance. + * Create a new {@link ApplicationDataSourceScriptDatabaseInitializer} instance. * @param dataSource the primary SQL data source * @param properties the SQL initialization properties - * @see #getSettings */ - public SqlDataSourceScriptDatabaseInitializer(DataSource dataSource, SqlInitializationProperties properties) { - this(dataSource, getSettings(properties)); + public ApplicationDataSourceScriptDatabaseInitializer(DataSource dataSource, + SqlInitializationProperties properties) { + this(dataSource, ApplicationScriptDatabaseInitializer.getSettings(properties)); } /** - * Create a new {@link SqlDataSourceScriptDatabaseInitializer} instance. + * Create a new {@link ApplicationDataSourceScriptDatabaseInitializer} instance. * @param dataSource the primary SQL data source * @param settings the database initialization settings - * @see #getSettings */ - public SqlDataSourceScriptDatabaseInitializer(DataSource dataSource, DatabaseInitializationSettings settings) { + public ApplicationDataSourceScriptDatabaseInitializer(DataSource dataSource, + DatabaseInitializationSettings settings) { super(dataSource, settings); } - /** - * Adapts {@link SqlInitializationProperties SQL initialization properties} to - * {@link DatabaseInitializationSettings}. - * @param properties the SQL initialization properties - * @return a new {@link DatabaseInitializationSettings} instance - * @see #SqlDataSourceScriptDatabaseInitializer(DataSource, - * DatabaseInitializationSettings) - */ - public static DatabaseInitializationSettings getSettings(SqlInitializationProperties properties) { - return SettingsCreator.createFrom(properties); - } - } diff --git a/spring-boot-project/spring-boot-autoconfigure-all/src/main/java/org/springframework/boot/autoconfigure/jdbc/DataSourceAutoConfiguration.java b/spring-boot-project/spring-boot-autoconfigure-all/src/main/java/org/springframework/boot/autoconfigure/jdbc/DataSourceAutoConfiguration.java index 5fd4bda9e3..193e55e705 100644 --- a/spring-boot-project/spring-boot-autoconfigure-all/src/main/java/org/springframework/boot/autoconfigure/jdbc/DataSourceAutoConfiguration.java +++ b/spring-boot-project/spring-boot-autoconfigure-all/src/main/java/org/springframework/boot/autoconfigure/jdbc/DataSourceAutoConfiguration.java @@ -30,7 +30,6 @@ 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.metadata.DataSourcePoolMetadataProvidersConfiguration; -import org.springframework.boot.autoconfigure.sql.init.SqlInitializationAutoConfiguration; import org.springframework.boot.context.properties.EnableConfigurationProperties; import org.springframework.boot.jdbc.DataSourceBuilder; import org.springframework.boot.jdbc.EmbeddedDatabaseConnection; @@ -56,7 +55,7 @@ import org.springframework.util.StringUtils; * @author Olga Maciaszek-Sharma * @since 1.0.0 */ -@AutoConfiguration(before = SqlInitializationAutoConfiguration.class) +@AutoConfiguration(before = DataSourceInitializationAutoConfiguration.class) @ConditionalOnClass({ DataSource.class, EmbeddedDatabaseType.class }) @ConditionalOnMissingBean(type = "io.r2dbc.spi.ConnectionFactory") @EnableConfigurationProperties(DataSourceProperties.class) diff --git a/spring-boot-project/spring-boot-autoconfigure-all/src/main/java/org/springframework/boot/autoconfigure/sql/init/DataSourceInitializationConfiguration.java b/spring-boot-project/spring-boot-autoconfigure-all/src/main/java/org/springframework/boot/autoconfigure/jdbc/DataSourceInitializationAutoConfiguration.java similarity index 57% rename from spring-boot-project/spring-boot-autoconfigure-all/src/main/java/org/springframework/boot/autoconfigure/sql/init/DataSourceInitializationConfiguration.java rename to spring-boot-project/spring-boot-autoconfigure-all/src/main/java/org/springframework/boot/autoconfigure/jdbc/DataSourceInitializationAutoConfiguration.java index 511f8e6d04..b8302c3443 100644 --- a/spring-boot-project/spring-boot-autoconfigure-all/src/main/java/org/springframework/boot/autoconfigure/sql/init/DataSourceInitializationConfiguration.java +++ b/spring-boot-project/spring-boot-autoconfigure-all/src/main/java/org/springframework/boot/autoconfigure/jdbc/DataSourceInitializationAutoConfiguration.java @@ -1,5 +1,5 @@ /* - * Copyright 2012-2023 the original author or authors. + * Copyright 2012-2025 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. @@ -14,30 +14,46 @@ * limitations under the License. */ -package org.springframework.boot.autoconfigure.sql.init; +package org.springframework.boot.autoconfigure.jdbc; import javax.sql.DataSource; +import org.springframework.boot.autoconfigure.AutoConfiguration; import org.springframework.boot.autoconfigure.condition.ConditionalOnClass; import org.springframework.boot.autoconfigure.condition.ConditionalOnMissingBean; import org.springframework.boot.autoconfigure.condition.ConditionalOnSingleCandidate; +import org.springframework.boot.autoconfigure.sql.init.ApplicationScriptDatabaseInitializer; +import org.springframework.boot.autoconfigure.sql.init.ConditionalOnSqlInitialization; +import org.springframework.boot.autoconfigure.sql.init.SqlInitializationProperties; +import org.springframework.boot.context.properties.EnableConfigurationProperties; import org.springframework.boot.jdbc.DataSourceBuilder; +import org.springframework.boot.sql.init.dependency.DatabaseInitializationDependencyConfigurer; import org.springframework.context.annotation.Bean; -import org.springframework.context.annotation.Configuration; +import org.springframework.context.annotation.Import; import org.springframework.jdbc.datasource.SimpleDriverDataSource; import org.springframework.jdbc.datasource.init.DatabasePopulator; import org.springframework.util.StringUtils; -@Configuration(proxyBeanMethods = false) -@ConditionalOnMissingBean({ SqlDataSourceScriptDatabaseInitializer.class, SqlR2dbcScriptDatabaseInitializer.class }) +/** + * Auto-configuration for {@link DataSource} initialization. + * + * @author Andy Wilkinson + * @author Phillip Webb + * @since 4.0.0 + */ +@AutoConfiguration +@ConditionalOnMissingBean(ApplicationScriptDatabaseInitializer.class) @ConditionalOnSingleCandidate(DataSource.class) @ConditionalOnClass(DatabasePopulator.class) -class DataSourceInitializationConfiguration { +@Import(DatabaseInitializationDependencyConfigurer.class) +@EnableConfigurationProperties(SqlInitializationProperties.class) +@ConditionalOnSqlInitialization +public class DataSourceInitializationAutoConfiguration { @Bean - SqlDataSourceScriptDatabaseInitializer dataSourceScriptDatabaseInitializer(DataSource dataSource, + ApplicationDataSourceScriptDatabaseInitializer dataSourceScriptDatabaseInitializer(DataSource dataSource, SqlInitializationProperties properties) { - return new SqlDataSourceScriptDatabaseInitializer( + return new ApplicationDataSourceScriptDatabaseInitializer( determineDataSource(dataSource, properties.getUsername(), properties.getPassword()), properties); } diff --git a/spring-boot-project/spring-boot-autoconfigure-all/src/main/java/org/springframework/boot/autoconfigure/sql/init/SqlR2dbcScriptDatabaseInitializer.java b/spring-boot-project/spring-boot-autoconfigure-all/src/main/java/org/springframework/boot/autoconfigure/r2dbc/ApplicationR2dbcScriptDatabaseInitializer.java similarity index 54% rename from spring-boot-project/spring-boot-autoconfigure-all/src/main/java/org/springframework/boot/autoconfigure/sql/init/SqlR2dbcScriptDatabaseInitializer.java rename to spring-boot-project/spring-boot-autoconfigure-all/src/main/java/org/springframework/boot/autoconfigure/r2dbc/ApplicationR2dbcScriptDatabaseInitializer.java index 7779bb72d4..6213c338aa 100644 --- a/spring-boot-project/spring-boot-autoconfigure-all/src/main/java/org/springframework/boot/autoconfigure/sql/init/SqlR2dbcScriptDatabaseInitializer.java +++ b/spring-boot-project/spring-boot-autoconfigure-all/src/main/java/org/springframework/boot/autoconfigure/r2dbc/ApplicationR2dbcScriptDatabaseInitializer.java @@ -14,13 +14,14 @@ * limitations under the License. */ -package org.springframework.boot.autoconfigure.sql.init; +package org.springframework.boot.autoconfigure.r2dbc; import io.r2dbc.spi.ConnectionFactory; +import org.springframework.boot.autoconfigure.sql.init.ApplicationScriptDatabaseInitializer; +import org.springframework.boot.autoconfigure.sql.init.SqlInitializationProperties; import org.springframework.boot.r2dbc.init.R2dbcScriptDatabaseInitializer; import org.springframework.boot.sql.init.DatabaseInitializationSettings; -import org.springframework.context.annotation.ImportRuntimeHints; /** * {@link R2dbcScriptDatabaseInitializer} for the primary SQL database. May be registered @@ -30,41 +31,27 @@ import org.springframework.context.annotation.ImportRuntimeHints; * @author Phillip Webb * @since 2.6.0 */ -@ImportRuntimeHints(SqlInitializationScriptsRuntimeHints.class) -public class SqlR2dbcScriptDatabaseInitializer extends R2dbcScriptDatabaseInitializer { +public class ApplicationR2dbcScriptDatabaseInitializer extends R2dbcScriptDatabaseInitializer + implements ApplicationScriptDatabaseInitializer { /** - * Create a new {@code SqlR2dbcScriptDatabaseInitializer} instance. + * Create a new {@code ApplicationR2dbcScriptDatabaseInitializer} instance. * @param connectionFactory the primary SQL connection factory * @param properties the SQL initialization properties - * @see #getSettings */ - public SqlR2dbcScriptDatabaseInitializer(ConnectionFactory connectionFactory, + public ApplicationR2dbcScriptDatabaseInitializer(ConnectionFactory connectionFactory, SqlInitializationProperties properties) { - super(connectionFactory, getSettings(properties)); + super(connectionFactory, ApplicationScriptDatabaseInitializer.getSettings(properties)); } /** - * Create a new {@code SqlR2dbcScriptDatabaseInitializer} instance. + * Create a new {@code ApplicationR2dbcScriptDatabaseInitializer} instance. * @param connectionFactory the primary SQL connection factory * @param settings the database initialization settings - * @see #getSettings */ - public SqlR2dbcScriptDatabaseInitializer(ConnectionFactory connectionFactory, + public ApplicationR2dbcScriptDatabaseInitializer(ConnectionFactory connectionFactory, DatabaseInitializationSettings settings) { super(connectionFactory, settings); } - /** - * Adapts {@link SqlInitializationProperties SQL initialization properties} to - * {@link DatabaseInitializationSettings}. - * @param properties the SQL initialization properties - * @return a new {@link DatabaseInitializationSettings} instance - * @see #SqlR2dbcScriptDatabaseInitializer(ConnectionFactory, - * DatabaseInitializationSettings) - */ - public static DatabaseInitializationSettings getSettings(SqlInitializationProperties properties) { - return SettingsCreator.createFrom(properties); - } - } diff --git a/spring-boot-project/spring-boot-autoconfigure-all/src/main/java/org/springframework/boot/autoconfigure/r2dbc/R2dbcAutoConfiguration.java b/spring-boot-project/spring-boot-autoconfigure-all/src/main/java/org/springframework/boot/autoconfigure/r2dbc/R2dbcAutoConfiguration.java index 7dc72964c7..81b1fc413e 100644 --- a/spring-boot-project/spring-boot-autoconfigure-all/src/main/java/org/springframework/boot/autoconfigure/r2dbc/R2dbcAutoConfiguration.java +++ b/spring-boot-project/spring-boot-autoconfigure-all/src/main/java/org/springframework/boot/autoconfigure/r2dbc/R2dbcAutoConfiguration.java @@ -1,5 +1,5 @@ /* - * Copyright 2012-2023 the original author or authors. + * Copyright 2012-2025 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. @@ -31,7 +31,6 @@ import org.springframework.boot.autoconfigure.condition.ConditionalOnMissingBean import org.springframework.boot.autoconfigure.condition.ConditionalOnProperty; import org.springframework.boot.autoconfigure.condition.ConditionalOnResource; import org.springframework.boot.autoconfigure.jdbc.DataSourceAutoConfiguration; -import org.springframework.boot.autoconfigure.sql.init.SqlInitializationAutoConfiguration; import org.springframework.boot.context.properties.EnableConfigurationProperties; import org.springframework.context.annotation.Bean; import org.springframework.context.annotation.Import; @@ -44,7 +43,7 @@ import org.springframework.util.StringUtils; * @author Stephane Nicoll * @since 2.3.0 */ -@AutoConfiguration(before = { DataSourceAutoConfiguration.class, SqlInitializationAutoConfiguration.class }) +@AutoConfiguration(before = { DataSourceAutoConfiguration.class, R2dbcInitializationAutoConfiguration.class }) @ConditionalOnClass(ConnectionFactory.class) @ConditionalOnResource(resources = "classpath:META-INF/services/io.r2dbc.spi.ConnectionFactoryProvider") @EnableConfigurationProperties(R2dbcProperties.class) diff --git a/spring-boot-project/spring-boot-autoconfigure-all/src/main/java/org/springframework/boot/autoconfigure/sql/init/R2dbcInitializationConfiguration.java b/spring-boot-project/spring-boot-autoconfigure-all/src/main/java/org/springframework/boot/autoconfigure/r2dbc/R2dbcInitializationAutoConfiguration.java similarity index 57% rename from spring-boot-project/spring-boot-autoconfigure-all/src/main/java/org/springframework/boot/autoconfigure/sql/init/R2dbcInitializationConfiguration.java rename to spring-boot-project/spring-boot-autoconfigure-all/src/main/java/org/springframework/boot/autoconfigure/r2dbc/R2dbcInitializationAutoConfiguration.java index f84166cd73..453204d616 100644 --- a/spring-boot-project/spring-boot-autoconfigure-all/src/main/java/org/springframework/boot/autoconfigure/sql/init/R2dbcInitializationConfiguration.java +++ b/spring-boot-project/spring-boot-autoconfigure-all/src/main/java/org/springframework/boot/autoconfigure/r2dbc/R2dbcInitializationAutoConfiguration.java @@ -1,5 +1,5 @@ /* - * Copyright 2012-2023 the original author or authors. + * Copyright 2012-2025 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. @@ -14,35 +14,47 @@ * limitations under the License. */ -package org.springframework.boot.autoconfigure.sql.init; +package org.springframework.boot.autoconfigure.r2dbc; import io.r2dbc.spi.ConnectionFactory; +import org.springframework.boot.autoconfigure.AutoConfiguration; import org.springframework.boot.autoconfigure.condition.ConditionalOnClass; import org.springframework.boot.autoconfigure.condition.ConditionalOnMissingBean; import org.springframework.boot.autoconfigure.condition.ConditionalOnSingleCandidate; +import org.springframework.boot.autoconfigure.jdbc.ApplicationDataSourceScriptDatabaseInitializer; +import org.springframework.boot.autoconfigure.sql.init.ConditionalOnSqlInitialization; +import org.springframework.boot.autoconfigure.sql.init.SqlInitializationProperties; +import org.springframework.boot.context.properties.EnableConfigurationProperties; import org.springframework.boot.r2dbc.ConnectionFactoryBuilder; +import org.springframework.boot.sql.init.dependency.DatabaseInitializationDependencyConfigurer; import org.springframework.context.annotation.Bean; -import org.springframework.context.annotation.Configuration; +import org.springframework.context.annotation.Import; import org.springframework.r2dbc.connection.init.DatabasePopulator; import org.springframework.util.StringUtils; /** - * Configuration for initializing an SQL database accessed through an R2DBC + * Auto-configuration for initializing an SQL database accessed through an R2DBC * {@link ConnectionFactory}. * * @author Andy Wilkinson + * @author Phillip Webb + * @since 4.0.0 */ -@Configuration(proxyBeanMethods = false) +@AutoConfiguration @ConditionalOnClass({ ConnectionFactory.class, DatabasePopulator.class }) @ConditionalOnSingleCandidate(ConnectionFactory.class) -@ConditionalOnMissingBean({ SqlR2dbcScriptDatabaseInitializer.class, SqlDataSourceScriptDatabaseInitializer.class }) -class R2dbcInitializationConfiguration { +@ConditionalOnMissingBean({ ApplicationR2dbcScriptDatabaseInitializer.class, + ApplicationDataSourceScriptDatabaseInitializer.class }) +@ConditionalOnSqlInitialization +@Import(DatabaseInitializationDependencyConfigurer.class) +@EnableConfigurationProperties(SqlInitializationProperties.class) +public class R2dbcInitializationAutoConfiguration { @Bean - SqlR2dbcScriptDatabaseInitializer r2dbcScriptDatabaseInitializer(ConnectionFactory connectionFactory, + ApplicationR2dbcScriptDatabaseInitializer r2dbcScriptDatabaseInitializer(ConnectionFactory connectionFactory, SqlInitializationProperties properties) { - return new SqlR2dbcScriptDatabaseInitializer( + return new ApplicationR2dbcScriptDatabaseInitializer( determineConnectionFactory(connectionFactory, properties.getUsername(), properties.getPassword()), properties); } diff --git a/spring-boot-project/spring-boot-autoconfigure-all/src/main/java/org/springframework/boot/autoconfigure/sql/init/ApplicationScriptDatabaseInitializer.java b/spring-boot-project/spring-boot-autoconfigure-all/src/main/java/org/springframework/boot/autoconfigure/sql/init/ApplicationScriptDatabaseInitializer.java new file mode 100644 index 0000000000..de7f732d7e --- /dev/null +++ b/spring-boot-project/spring-boot-autoconfigure-all/src/main/java/org/springframework/boot/autoconfigure/sql/init/ApplicationScriptDatabaseInitializer.java @@ -0,0 +1,45 @@ +/* + * Copyright 2012-2025 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.boot.autoconfigure.sql.init; + +import org.springframework.boot.sql.init.AbstractScriptDatabaseInitializer; +import org.springframework.boot.sql.init.DatabaseInitializationSettings; +import org.springframework.context.annotation.ImportRuntimeHints; + +/** + * Marker interface for a script-based database initializer that initializes the + * application's database. + * + * @author Andy Wilkinson + * @author Phillip Webb + * @since 4.0.0 + * @see AbstractScriptDatabaseInitializer + */ +@ImportRuntimeHints(SqlInitializationScriptsRuntimeHints.class) +public interface ApplicationScriptDatabaseInitializer { + + /** + * Adapts {@link SqlInitializationProperties} to + * {@link DatabaseInitializationSettings}. + * @param properties the properties to adapt + * @return the settings + */ + static DatabaseInitializationSettings getSettings(SqlInitializationProperties properties) { + return SettingsCreator.createFrom(properties); + } + +} diff --git a/spring-boot-project/spring-boot-autoconfigure-all/src/main/java/org/springframework/boot/autoconfigure/sql/init/ConditionalOnSqlInitialization.java b/spring-boot-project/spring-boot-autoconfigure-all/src/main/java/org/springframework/boot/autoconfigure/sql/init/ConditionalOnSqlInitialization.java new file mode 100644 index 0000000000..ed53f650ae --- /dev/null +++ b/spring-boot-project/spring-boot-autoconfigure-all/src/main/java/org/springframework/boot/autoconfigure/sql/init/ConditionalOnSqlInitialization.java @@ -0,0 +1,40 @@ +/* + * Copyright 2012-2025 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.boot.autoconfigure.sql.init; + +import java.lang.annotation.ElementType; +import java.lang.annotation.Retention; +import java.lang.annotation.RetentionPolicy; +import java.lang.annotation.Target; + +import org.springframework.boot.sql.init.DatabaseInitializationMode; +import org.springframework.context.annotation.Conditional; + +/** + * Condition that matches when {@code spring.sql.init.mode} is set to a value other than + * {@link DatabaseInitializationMode#NEVER}. + * + * @author Andy Wilkinson + * @author Phillip Webb + * @since 4.0.0 + */ +@Retention(RetentionPolicy.RUNTIME) +@Target({ ElementType.TYPE, ElementType.METHOD }) +@Conditional(OnSqlInitializationCondition.class) +public @interface ConditionalOnSqlInitialization { + +} diff --git a/spring-boot-project/spring-boot-autoconfigure-all/src/main/java/org/springframework/boot/autoconfigure/sql/init/OnSqlInitializationCondition.java b/spring-boot-project/spring-boot-autoconfigure-all/src/main/java/org/springframework/boot/autoconfigure/sql/init/OnSqlInitializationCondition.java new file mode 100644 index 0000000000..3ea2cdb2db --- /dev/null +++ b/spring-boot-project/spring-boot-autoconfigure-all/src/main/java/org/springframework/boot/autoconfigure/sql/init/OnSqlInitializationCondition.java @@ -0,0 +1,33 @@ +/* + * Copyright 2012-2025 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.boot.autoconfigure.sql.init; + +import org.springframework.context.annotation.Condition; + +/** + * {@link Condition} implementation for {@link ConditionalOnSqlInitialization}. + * + * @author Andy Wilkinson + * @author Phillip Webb + */ +class OnSqlInitializationCondition extends OnDatabaseInitializationCondition { + + OnSqlInitializationCondition() { + super("SQL Initialization", "spring.sql.init.mode"); + } + +} diff --git a/spring-boot-project/spring-boot-autoconfigure-all/src/main/java/org/springframework/boot/autoconfigure/sql/init/SqlInitializationAutoConfiguration.java b/spring-boot-project/spring-boot-autoconfigure-all/src/main/java/org/springframework/boot/autoconfigure/sql/init/SqlInitializationAutoConfiguration.java deleted file mode 100644 index c249a581cc..0000000000 --- a/spring-boot-project/spring-boot-autoconfigure-all/src/main/java/org/springframework/boot/autoconfigure/sql/init/SqlInitializationAutoConfiguration.java +++ /dev/null @@ -1,57 +0,0 @@ -/* - * Copyright 2012-2025 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.boot.autoconfigure.sql.init; - -import org.springframework.boot.autoconfigure.AutoConfiguration; -import org.springframework.boot.autoconfigure.EnableAutoConfiguration; -import org.springframework.boot.autoconfigure.condition.ConditionalOnBooleanProperty; -import org.springframework.boot.autoconfigure.condition.ConditionalOnProperty; -import org.springframework.boot.autoconfigure.condition.NoneNestedConditions; -import org.springframework.boot.autoconfigure.sql.init.SqlInitializationAutoConfiguration.SqlInitializationModeCondition; -import org.springframework.boot.context.properties.EnableConfigurationProperties; -import org.springframework.boot.sql.init.dependency.DatabaseInitializationDependencyConfigurer; -import org.springframework.context.annotation.Conditional; -import org.springframework.context.annotation.Import; - -/** - * {@link EnableAutoConfiguration Auto-configuration} for initializing an SQL database. - * - * @author Andy Wilkinson - * @since 2.5.0 - */ -@AutoConfiguration -@EnableConfigurationProperties(SqlInitializationProperties.class) -@Import({ DatabaseInitializationDependencyConfigurer.class, R2dbcInitializationConfiguration.class, - DataSourceInitializationConfiguration.class }) -@ConditionalOnBooleanProperty(name = "spring.sql.init.enabled", matchIfMissing = true) -@Conditional(SqlInitializationModeCondition.class) -public class SqlInitializationAutoConfiguration { - - static class SqlInitializationModeCondition extends NoneNestedConditions { - - SqlInitializationModeCondition() { - super(ConfigurationPhase.PARSE_CONFIGURATION); - } - - @ConditionalOnProperty(name = "spring.sql.init.mode", havingValue = "never") - static class ModeIsNever { - - } - - } - -} diff --git a/spring-boot-project/spring-boot-autoconfigure-all/src/main/resources/META-INF/spring/org.springframework.boot.autoconfigure.AutoConfiguration.imports b/spring-boot-project/spring-boot-autoconfigure-all/src/main/resources/META-INF/spring/org.springframework.boot.autoconfigure.AutoConfiguration.imports index aae925013a..231db352ed 100644 --- a/spring-boot-project/spring-boot-autoconfigure-all/src/main/resources/META-INF/spring/org.springframework.boot.autoconfigure.AutoConfiguration.imports +++ b/spring-boot-project/spring-boot-autoconfigure-all/src/main/resources/META-INF/spring/org.springframework.boot.autoconfigure.AutoConfiguration.imports @@ -64,6 +64,7 @@ org.springframework.boot.autoconfigure.http.codec.CodecsAutoConfiguration org.springframework.boot.autoconfigure.integration.IntegrationAutoConfiguration org.springframework.boot.autoconfigure.jackson.JacksonAutoConfiguration org.springframework.boot.autoconfigure.jdbc.DataSourceAutoConfiguration +org.springframework.boot.autoconfigure.jdbc.DataSourceInitializationAutoConfiguration org.springframework.boot.autoconfigure.jdbc.JdbcClientAutoConfiguration org.springframework.boot.autoconfigure.jdbc.JdbcTemplateAutoConfiguration org.springframework.boot.autoconfigure.jdbc.JndiDataSourceAutoConfiguration @@ -92,6 +93,7 @@ org.springframework.boot.autoconfigure.pulsar.PulsarAutoConfiguration org.springframework.boot.autoconfigure.pulsar.PulsarReactiveAutoConfiguration org.springframework.boot.autoconfigure.quartz.QuartzAutoConfiguration org.springframework.boot.autoconfigure.r2dbc.R2dbcAutoConfiguration +org.springframework.boot.autoconfigure.r2dbc.R2dbcInitializationAutoConfiguration org.springframework.boot.autoconfigure.r2dbc.R2dbcProxyAutoConfiguration org.springframework.boot.autoconfigure.r2dbc.R2dbcTransactionManagerAutoConfiguration org.springframework.boot.autoconfigure.reactor.ReactorAutoConfiguration @@ -116,7 +118,6 @@ org.springframework.boot.autoconfigure.security.oauth2.server.servlet.OAuth2Auth org.springframework.boot.autoconfigure.security.oauth2.server.servlet.OAuth2AuthorizationServerJwtAutoConfiguration org.springframework.boot.autoconfigure.sendgrid.SendGridAutoConfiguration org.springframework.boot.autoconfigure.session.SessionAutoConfiguration -org.springframework.boot.autoconfigure.sql.init.SqlInitializationAutoConfiguration org.springframework.boot.autoconfigure.thymeleaf.ThymeleafAutoConfiguration org.springframework.boot.autoconfigure.transaction.TransactionAutoConfiguration org.springframework.boot.autoconfigure.transaction.TransactionManagerCustomizationAutoConfiguration diff --git a/spring-boot-project/spring-boot-autoconfigure-all/src/test/java/org/springframework/boot/autoconfigure/data/jdbc/JdbcRepositoriesAutoConfigurationTests.java b/spring-boot-project/spring-boot-autoconfigure-all/src/test/java/org/springframework/boot/autoconfigure/data/jdbc/JdbcRepositoriesAutoConfigurationTests.java index 0c251b578f..b11b3c04ad 100644 --- a/spring-boot-project/spring-boot-autoconfigure-all/src/test/java/org/springframework/boot/autoconfigure/data/jdbc/JdbcRepositoriesAutoConfigurationTests.java +++ b/spring-boot-project/spring-boot-autoconfigure-all/src/test/java/org/springframework/boot/autoconfigure/data/jdbc/JdbcRepositoriesAutoConfigurationTests.java @@ -29,9 +29,9 @@ import org.springframework.boot.autoconfigure.data.empty.EmptyDataPackage; import org.springframework.boot.autoconfigure.data.jdbc.city.City; import org.springframework.boot.autoconfigure.data.jdbc.city.CityRepository; import org.springframework.boot.autoconfigure.jdbc.DataSourceAutoConfiguration; +import org.springframework.boot.autoconfigure.jdbc.DataSourceInitializationAutoConfiguration; import org.springframework.boot.autoconfigure.jdbc.DataSourceTransactionManagerAutoConfiguration; import org.springframework.boot.autoconfigure.jdbc.JdbcTemplateAutoConfiguration; -import org.springframework.boot.autoconfigure.sql.init.SqlInitializationAutoConfiguration; import org.springframework.boot.test.context.runner.ApplicationContextRunner; import org.springframework.boot.testsupport.classpath.resources.WithResource; import org.springframework.context.annotation.Bean; @@ -218,8 +218,8 @@ class JdbcRepositoriesAutoConfigurationTests { private Function database() { return (runner) -> runner - .withConfiguration( - AutoConfigurations.of(DataSourceAutoConfiguration.class, SqlInitializationAutoConfiguration.class)) + .withConfiguration(AutoConfigurations.of(DataSourceAutoConfiguration.class, + DataSourceInitializationAutoConfiguration.class)) .withPropertyValues("spring.sql.init.schema-locations=classpath:schema.sql", "spring.sql.init.data-locations=classpath:data.sql", "spring.datasource.generate-unique-name:true"); } diff --git a/spring-boot-project/spring-boot-autoconfigure-all/src/test/java/org/springframework/boot/autoconfigure/jdbc/DataSourceInitializationAutoConfigurationTests.java b/spring-boot-project/spring-boot-autoconfigure-all/src/test/java/org/springframework/boot/autoconfigure/jdbc/DataSourceInitializationAutoConfigurationTests.java new file mode 100644 index 0000000000..a944fd412f --- /dev/null +++ b/spring-boot-project/spring-boot-autoconfigure-all/src/test/java/org/springframework/boot/autoconfigure/jdbc/DataSourceInitializationAutoConfigurationTests.java @@ -0,0 +1,152 @@ +/* + * Copyright 2012-2025 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.boot.autoconfigure.jdbc; + +import javax.sql.DataSource; + +import org.junit.jupiter.api.Test; + +import org.springframework.beans.factory.config.BeanDefinition; +import org.springframework.beans.factory.config.ConfigurableListableBeanFactory; +import org.springframework.boot.autoconfigure.AutoConfigurations; +import org.springframework.boot.autoconfigure.sql.init.ApplicationScriptDatabaseInitializer; +import org.springframework.boot.jdbc.init.DataSourceScriptDatabaseInitializer; +import org.springframework.boot.sql.init.AbstractScriptDatabaseInitializer; +import org.springframework.boot.sql.init.DatabaseInitializationSettings; +import org.springframework.boot.sql.init.dependency.DependsOnDatabaseInitialization; +import org.springframework.boot.test.context.FilteredClassLoader; +import org.springframework.boot.test.context.runner.ApplicationContextRunner; +import org.springframework.context.annotation.Bean; +import org.springframework.context.annotation.Configuration; +import org.springframework.jdbc.datasource.init.DatabasePopulator; + +import static org.assertj.core.api.Assertions.assertThat; +import static org.mockito.Mockito.mock; + +/** + * Tests for {@link DataSourceInitializationAutoConfiguration}. + * + * @author Andy Wilkinson + * @author Phillip Webb + */ +class DataSourceInitializationAutoConfigurationTests { + + private final ApplicationContextRunner contextRunner = new ApplicationContextRunner() + .withConfiguration(AutoConfigurations.of(DataSourceInitializationAutoConfiguration.class)) + .withPropertyValues("spring.datasource.generate-unique-name:true"); + + @Test + void whenNoDataSourceIsAvailableThenAutoConfigurationBacksOff() { + this.contextRunner + .run((context) -> assertThat(context).doesNotHaveBean(AbstractScriptDatabaseInitializer.class)); + } + + @Test + void whenDataSourceIsAvailableThenDataSourceInitializerIsAutoConfigured() { + this.contextRunner.withConfiguration(AutoConfigurations.of(DataSourceAutoConfiguration.class)) + .run((context) -> assertThat(context).hasSingleBean(DataSourceScriptDatabaseInitializer.class)); + } + + @Test + void whenDataSourceIsAvailableAndModeIsNeverThenInitializerIsNotAutoConfigured() { + this.contextRunner.withConfiguration(AutoConfigurations.of(DataSourceAutoConfiguration.class)) + .withPropertyValues("spring.sql.init.mode:never") + .run((context) -> assertThat(context).doesNotHaveBean(AbstractScriptDatabaseInitializer.class)); + } + + @Test + void whenAnApplicationInitializerIsDefinedThenInitializerIsNotAutoConfigured() { + this.contextRunner.withConfiguration(AutoConfigurations.of(DataSourceAutoConfiguration.class)) + .withUserConfiguration(ApplicationDatabaseInitializerConfiguration.class) + .run((context) -> assertThat(context).hasSingleBean(ApplicationScriptDatabaseInitializer.class) + .hasBean("customInitializer")); + } + + @Test + void whenAnInitializerIsDefinedThenApplicationInitializerIsStillAutoConfigured() { + this.contextRunner.withConfiguration(AutoConfigurations.of(DataSourceAutoConfiguration.class)) + .withUserConfiguration(DatabaseInitializerConfiguration.class) + .run((context) -> assertThat(context).hasSingleBean(ApplicationDataSourceScriptDatabaseInitializer.class) + .hasBean("customInitializer")); + } + + @Test + void whenBeanIsAnnotatedAsDependingOnDatabaseInitializationThenItDependsOnDataSourceScriptDatabaseInitializer() { + this.contextRunner.withConfiguration(AutoConfigurations.of(DataSourceAutoConfiguration.class)) + .withUserConfiguration(DependsOnInitializedDatabaseConfiguration.class) + .run((context) -> { + ConfigurableListableBeanFactory beanFactory = context.getBeanFactory(); + BeanDefinition beanDefinition = beanFactory.getBeanDefinition( + "dataSourceInitializationAutoConfigurationTests.DependsOnInitializedDatabaseConfiguration"); + assertThat(beanDefinition.getDependsOn()) + .containsExactlyInAnyOrder("dataSourceScriptDatabaseInitializer"); + }); + } + + @Test + void whenADataSourceIsAvailableAndSpringJdbcIsNotThenAutoConfigurationBacksOff() { + this.contextRunner.withConfiguration(AutoConfigurations.of(DataSourceAutoConfiguration.class)) + .withClassLoader(new FilteredClassLoader(DatabasePopulator.class)) + .run((context) -> { + assertThat(context).hasSingleBean(DataSource.class); + assertThat(context).doesNotHaveBean(AbstractScriptDatabaseInitializer.class); + }); + } + + @Configuration(proxyBeanMethods = false) + static class ApplicationDatabaseInitializerConfiguration { + + @Bean + ApplicationScriptDatabaseInitializer customInitializer() { + return mock(ApplicationScriptDatabaseInitializer.class); + } + + } + + @Configuration(proxyBeanMethods = false) + static class DatabaseInitializerConfiguration { + + @Bean + DataSourceScriptDatabaseInitializer customInitializer() { + return new DataSourceScriptDatabaseInitializer(null, new DatabaseInitializationSettings()) { + + @Override + protected void runScripts(Scripts scripts) { + // No-op + } + + @Override + protected boolean isEmbeddedDatabase() { + return true; + } + + }; + } + + } + + @Configuration(proxyBeanMethods = false) + @DependsOnDatabaseInitialization + static class DependsOnInitializedDatabaseConfiguration { + + DependsOnInitializedDatabaseConfiguration() { + + } + + } + +} diff --git a/spring-boot-project/spring-boot-autoconfigure-all/src/test/java/org/springframework/boot/autoconfigure/jdbc/HikariDriverConfigurationFailureAnalyzerTests.java b/spring-boot-project/spring-boot-autoconfigure-all/src/test/java/org/springframework/boot/autoconfigure/jdbc/HikariDriverConfigurationFailureAnalyzerTests.java index c9030edae2..0e54f65386 100644 --- a/spring-boot-project/spring-boot-autoconfigure-all/src/test/java/org/springframework/boot/autoconfigure/jdbc/HikariDriverConfigurationFailureAnalyzerTests.java +++ b/spring-boot-project/spring-boot-autoconfigure-all/src/test/java/org/springframework/boot/autoconfigure/jdbc/HikariDriverConfigurationFailureAnalyzerTests.java @@ -21,7 +21,6 @@ import org.junit.jupiter.api.Test; import org.springframework.beans.factory.BeanCreationException; import org.springframework.boot.autoconfigure.ImportAutoConfiguration; -import org.springframework.boot.autoconfigure.sql.init.SqlInitializationAutoConfiguration; import org.springframework.boot.diagnostics.FailureAnalysis; import org.springframework.boot.test.util.TestPropertyValues; import org.springframework.boot.testsupport.classpath.resources.WithResource; @@ -78,7 +77,7 @@ class HikariDriverConfigurationFailureAnalyzerTests { } @Configuration(proxyBeanMethods = false) - @ImportAutoConfiguration({ DataSourceAutoConfiguration.class, SqlInitializationAutoConfiguration.class }) + @ImportAutoConfiguration({ DataSourceAutoConfiguration.class, DataSourceInitializationAutoConfiguration.class }) static class TestConfiguration { } diff --git a/spring-boot-project/spring-boot-autoconfigure-all/src/test/java/org/springframework/boot/autoconfigure/jdbc/JdbcTemplateAutoConfigurationTests.java b/spring-boot-project/spring-boot-autoconfigure-all/src/test/java/org/springframework/boot/autoconfigure/jdbc/JdbcTemplateAutoConfigurationTests.java index 30fd043d07..0e94162320 100644 --- a/spring-boot-project/spring-boot-autoconfigure-all/src/test/java/org/springframework/boot/autoconfigure/jdbc/JdbcTemplateAutoConfigurationTests.java +++ b/spring-boot-project/spring-boot-autoconfigure-all/src/test/java/org/springframework/boot/autoconfigure/jdbc/JdbcTemplateAutoConfigurationTests.java @@ -29,7 +29,6 @@ import org.junit.jupiter.api.Test; import org.springframework.boot.autoconfigure.AutoConfigurations; import org.springframework.boot.autoconfigure.flyway.FlywayAutoConfiguration; import org.springframework.boot.autoconfigure.liquibase.LiquibaseAutoConfiguration; -import org.springframework.boot.autoconfigure.sql.init.SqlInitializationAutoConfiguration; import org.springframework.boot.test.context.runner.ApplicationContextRunner; import org.springframework.boot.testsupport.classpath.resources.WithResource; import org.springframework.context.annotation.Bean; @@ -175,7 +174,7 @@ class JdbcTemplateAutoConfigurationTests { """) @WithResource(name = "data.sql", content = "INSERT INTO BAR VALUES (1, 'Andy');") void testDependencyToScriptBasedDataSourceInitialization() { - this.contextRunner.withConfiguration(AutoConfigurations.of(SqlInitializationAutoConfiguration.class)) + this.contextRunner.withConfiguration(AutoConfigurations.of(DataSourceInitializationAutoConfiguration.class)) .withUserConfiguration(DataSourceInitializationValidator.class) .run((context) -> { assertThat(context).hasNotFailed(); diff --git a/spring-boot-project/spring-boot-autoconfigure-all/src/test/java/org/springframework/boot/autoconfigure/orm/jpa/AbstractJpaAutoConfigurationTests.java b/spring-boot-project/spring-boot-autoconfigure-all/src/test/java/org/springframework/boot/autoconfigure/orm/jpa/AbstractJpaAutoConfigurationTests.java index cc672e2f6a..ebbcf1428d 100644 --- a/spring-boot-project/spring-boot-autoconfigure-all/src/test/java/org/springframework/boot/autoconfigure/orm/jpa/AbstractJpaAutoConfigurationTests.java +++ b/spring-boot-project/spring-boot-autoconfigure-all/src/test/java/org/springframework/boot/autoconfigure/orm/jpa/AbstractJpaAutoConfigurationTests.java @@ -39,9 +39,9 @@ import org.springframework.boot.autoconfigure.AutoConfigurations; import org.springframework.boot.autoconfigure.TestAutoConfigurationPackage; import org.springframework.boot.autoconfigure.data.jpa.country.Country; import org.springframework.boot.autoconfigure.jdbc.DataSourceAutoConfiguration; +import org.springframework.boot.autoconfigure.jdbc.DataSourceInitializationAutoConfiguration; import org.springframework.boot.autoconfigure.jdbc.DataSourceTransactionManagerAutoConfiguration; import org.springframework.boot.autoconfigure.orm.jpa.test.City; -import org.springframework.boot.autoconfigure.sql.init.SqlInitializationAutoConfiguration; import org.springframework.boot.autoconfigure.transaction.TransactionAutoConfiguration; import org.springframework.boot.autoconfigure.transaction.TransactionManagerCustomizationAutoConfiguration; import org.springframework.boot.jdbc.DataSourceBuilder; @@ -92,7 +92,7 @@ abstract class AbstractJpaAutoConfigurationTests { .withUserConfiguration(TestConfiguration.class) .withConfiguration(AutoConfigurations.of(DataSourceAutoConfiguration.class, TransactionAutoConfiguration.class, TransactionManagerCustomizationAutoConfiguration.class, - SqlInitializationAutoConfiguration.class, autoConfiguredClass)); + DataSourceInitializationAutoConfiguration.class, autoConfiguredClass)); } protected ApplicationContextRunner contextRunner() { diff --git a/spring-boot-project/spring-boot-autoconfigure-all/src/test/java/org/springframework/boot/autoconfigure/sql/init/SqlInitializationAutoConfigurationTests.java b/spring-boot-project/spring-boot-autoconfigure-all/src/test/java/org/springframework/boot/autoconfigure/r2dbc/R2dbcInitializationAutoConfigurationTests.java similarity index 58% rename from spring-boot-project/spring-boot-autoconfigure-all/src/test/java/org/springframework/boot/autoconfigure/sql/init/SqlInitializationAutoConfigurationTests.java rename to spring-boot-project/spring-boot-autoconfigure-all/src/test/java/org/springframework/boot/autoconfigure/r2dbc/R2dbcInitializationAutoConfigurationTests.java index c86db20c3b..c18ae071f1 100644 --- a/spring-boot-project/spring-boot-autoconfigure-all/src/test/java/org/springframework/boot/autoconfigure/sql/init/SqlInitializationAutoConfigurationTests.java +++ b/spring-boot-project/spring-boot-autoconfigure-all/src/test/java/org/springframework/boot/autoconfigure/r2dbc/R2dbcInitializationAutoConfigurationTests.java @@ -1,5 +1,5 @@ /* - * Copyright 2012-2024 the original author or authors. + * Copyright 2012-2025 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. @@ -14,9 +14,7 @@ * limitations under the License. */ -package org.springframework.boot.autoconfigure.sql.init; - -import javax.sql.DataSource; +package org.springframework.boot.autoconfigure.r2dbc; import io.r2dbc.spi.ConnectionFactory; import org.junit.jupiter.api.Test; @@ -24,9 +22,7 @@ import org.junit.jupiter.api.Test; import org.springframework.beans.factory.config.BeanDefinition; import org.springframework.beans.factory.config.ConfigurableListableBeanFactory; import org.springframework.boot.autoconfigure.AutoConfigurations; -import org.springframework.boot.autoconfigure.jdbc.DataSourceAutoConfiguration; -import org.springframework.boot.autoconfigure.r2dbc.R2dbcAutoConfiguration; -import org.springframework.boot.jdbc.init.DataSourceScriptDatabaseInitializer; +import org.springframework.boot.autoconfigure.sql.init.ApplicationScriptDatabaseInitializer; import org.springframework.boot.r2dbc.init.R2dbcScriptDatabaseInitializer; import org.springframework.boot.sql.init.AbstractScriptDatabaseInitializer; import org.springframework.boot.sql.init.DatabaseInitializationSettings; @@ -35,23 +31,25 @@ import org.springframework.boot.test.context.FilteredClassLoader; import org.springframework.boot.test.context.runner.ApplicationContextRunner; import org.springframework.context.annotation.Bean; import org.springframework.context.annotation.Configuration; -import org.springframework.jdbc.datasource.init.DatabasePopulator; +import org.springframework.r2dbc.connection.init.DatabasePopulator; import static org.assertj.core.api.Assertions.assertThat; +import static org.mockito.Mockito.mock; /** - * Tests for {@link SqlInitializationAutoConfiguration}. + * Tests for {@link R2dbcInitializationAutoConfiguration}. * * @author Andy Wilkinson + * @author Phillip Webb */ -class SqlInitializationAutoConfigurationTests { +class R2dbcInitializationAutoConfigurationTests { private final ApplicationContextRunner contextRunner = new ApplicationContextRunner() - .withConfiguration(AutoConfigurations.of(SqlInitializationAutoConfiguration.class)) - .withPropertyValues("spring.datasource.generate-unique-name:true", "spring.r2dbc.generate-unique-name:true"); + .withConfiguration(AutoConfigurations.of(R2dbcInitializationAutoConfiguration.class)) + .withPropertyValues("spring.r2dbc.generate-unique-name:true"); @Test - void whenNoDataSourceOrConnectionFactoryIsAvailableThenAutoConfigurationBacksOff() { + void whenNoConnectionFactoryIsAvailableThenAutoConfigurationBacksOff() { this.contextRunner .run((context) -> assertThat(context).doesNotHaveBean(AbstractScriptDatabaseInitializer.class)); } @@ -69,42 +67,19 @@ class SqlInitializationAutoConfigurationTests { .run((context) -> assertThat(context).doesNotHaveBean(AbstractScriptDatabaseInitializer.class)); } - @Test - void whenDataSourceIsAvailableThenDataSourceInitializerIsAutoConfigured() { - this.contextRunner.withConfiguration(AutoConfigurations.of(DataSourceAutoConfiguration.class)) - .run((context) -> assertThat(context).hasSingleBean(DataSourceScriptDatabaseInitializer.class)); - } - - @Test - void whenDataSourceIsAvailableAndModeIsNeverThenThenInitializerIsNotAutoConfigured() { - this.contextRunner.withConfiguration(AutoConfigurations.of(DataSourceAutoConfiguration.class)) - .withPropertyValues("spring.sql.init.mode:never") - .run((context) -> assertThat(context).doesNotHaveBean(AbstractScriptDatabaseInitializer.class)); - } - - @Test - void whenDataSourceAndConnectionFactoryAreAvailableThenOnlyR2dbcInitializerIsAutoConfigured() { - this.contextRunner.withConfiguration(AutoConfigurations.of(R2dbcAutoConfiguration.class)) - .withUserConfiguration(DataSourceAutoConfiguration.class) - .run((context) -> assertThat(context).hasSingleBean(ConnectionFactory.class) - .hasSingleBean(DataSource.class) - .hasSingleBean(R2dbcScriptDatabaseInitializer.class) - .doesNotHaveBean(DataSourceScriptDatabaseInitializer.class)); - } - @Test void whenAnSqlInitializerIsDefinedThenInitializerIsNotAutoConfigured() { this.contextRunner.withConfiguration(AutoConfigurations.of(R2dbcAutoConfiguration.class)) - .withUserConfiguration(DataSourceAutoConfiguration.class, SqlDatabaseInitializerConfiguration.class) + .withUserConfiguration(SqlDatabaseInitializerConfiguration.class) .run((context) -> assertThat(context).hasSingleBean(AbstractScriptDatabaseInitializer.class) .hasBean("customInitializer")); } @Test void whenAnInitializerIsDefinedThenSqlInitializerIsStillAutoConfigured() { - this.contextRunner.withConfiguration(AutoConfigurations.of(DataSourceAutoConfiguration.class)) + this.contextRunner.withConfiguration(AutoConfigurations.of(R2dbcAutoConfiguration.class)) .withUserConfiguration(DatabaseInitializerConfiguration.class) - .run((context) -> assertThat(context).hasSingleBean(SqlDataSourceScriptDatabaseInitializer.class) + .run((context) -> assertThat(context).hasSingleBean(ApplicationScriptDatabaseInitializer.class) .hasBean("customInitializer")); } @@ -115,38 +90,27 @@ class SqlInitializationAutoConfigurationTests { .run((context) -> { ConfigurableListableBeanFactory beanFactory = context.getBeanFactory(); BeanDefinition beanDefinition = beanFactory.getBeanDefinition( - "sqlInitializationAutoConfigurationTests.DependsOnInitializedDatabaseConfiguration"); + "r2dbcInitializationAutoConfigurationTests.DependsOnInitializedDatabaseConfiguration"); assertThat(beanDefinition.getDependsOn()).containsExactlyInAnyOrder("r2dbcScriptDatabaseInitializer"); }); } @Test void whenBeanIsAnnotatedAsDependingOnDatabaseInitializationThenItDependsOnDataSourceScriptDatabaseInitializer() { - this.contextRunner.withConfiguration(AutoConfigurations.of(DataSourceAutoConfiguration.class)) + this.contextRunner.withConfiguration(AutoConfigurations.of(R2dbcAutoConfiguration.class)) .withUserConfiguration(DependsOnInitializedDatabaseConfiguration.class) .run((context) -> { ConfigurableListableBeanFactory beanFactory = context.getBeanFactory(); BeanDefinition beanDefinition = beanFactory.getBeanDefinition( - "sqlInitializationAutoConfigurationTests.DependsOnInitializedDatabaseConfiguration"); - assertThat(beanDefinition.getDependsOn()) - .containsExactlyInAnyOrder("dataSourceScriptDatabaseInitializer"); - }); - } - - @Test - void whenADataSourceIsAvailableAndSpringJdbcIsNotThenAutoConfigurationBacksOff() { - this.contextRunner.withConfiguration(AutoConfigurations.of(DataSourceAutoConfiguration.class)) - .withClassLoader(new FilteredClassLoader(DatabasePopulator.class)) - .run((context) -> { - assertThat(context).hasSingleBean(DataSource.class); - assertThat(context).doesNotHaveBean(AbstractScriptDatabaseInitializer.class); + "r2dbcInitializationAutoConfigurationTests.DependsOnInitializedDatabaseConfiguration"); + assertThat(beanDefinition.getDependsOn()).containsExactlyInAnyOrder("r2dbcScriptDatabaseInitializer"); }); } @Test void whenAConnectionFactoryIsAvailableAndSpringR2dbcIsNotThenAutoConfigurationBacksOff() { this.contextRunner.withConfiguration(AutoConfigurations.of(R2dbcAutoConfiguration.class)) - .withClassLoader(new FilteredClassLoader(org.springframework.r2dbc.connection.init.DatabasePopulator.class)) + .withClassLoader(new FilteredClassLoader(DatabasePopulator.class)) .run((context) -> { assertThat(context).hasSingleBean(ConnectionFactory.class); assertThat(context).doesNotHaveBean(AbstractScriptDatabaseInitializer.class); @@ -157,20 +121,8 @@ class SqlInitializationAutoConfigurationTests { static class SqlDatabaseInitializerConfiguration { @Bean - SqlDataSourceScriptDatabaseInitializer customInitializer() { - return new SqlDataSourceScriptDatabaseInitializer(null, new DatabaseInitializationSettings()) { - - @Override - protected void runScripts(Scripts scripts) { - // No-op - } - - @Override - protected boolean isEmbeddedDatabase() { - return true; - } - - }; + ApplicationScriptDatabaseInitializer customInitializer() { + return mock(ApplicationScriptDatabaseInitializer.class); } } @@ -179,8 +131,8 @@ class SqlInitializationAutoConfigurationTests { static class DatabaseInitializerConfiguration { @Bean - DataSourceScriptDatabaseInitializer customInitializer() { - return new DataSourceScriptDatabaseInitializer(null, new DatabaseInitializationSettings()) { + R2dbcScriptDatabaseInitializer customInitializer() { + return new R2dbcScriptDatabaseInitializer(null, new DatabaseInitializationSettings()) { @Override protected void runScripts(Scripts scripts) { diff --git a/spring-boot-project/spring-boot-autoconfigure/src/main/resources/META-INF/additional-spring-configuration-metadata.json b/spring-boot-project/spring-boot-autoconfigure/src/main/resources/META-INF/additional-spring-configuration-metadata.json index bc01e232d6..bb9f722b63 100644 --- a/spring-boot-project/spring-boot-autoconfigure/src/main/resources/META-INF/additional-spring-configuration-metadata.json +++ b/spring-boot-project/spring-boot-autoconfigure/src/main/resources/META-INF/additional-spring-configuration-metadata.json @@ -327,6 +327,16 @@ "messages" ] }, + { + "name": "spring.sql.init.enabled", + "type": "java.lang.Boolean", + "description": "Whether basic script-based initialization of an SQL database is enabled.", + "defaultValue": true, + "deprecation": { + "replacement": "spring.sql.init.mode", + "level": "warning" + } + }, { "name": "spring.threads.virtual.enabled", "type": "java.lang.Boolean", diff --git a/spring-boot-project/spring-boot-test-autoconfigure/src/main/resources/META-INF/spring/org.springframework.boot.test.autoconfigure.data.jdbc.AutoConfigureDataJdbc.imports b/spring-boot-project/spring-boot-test-autoconfigure/src/main/resources/META-INF/spring/org.springframework.boot.test.autoconfigure.data.jdbc.AutoConfigureDataJdbc.imports index eb4b3faada..f9fa837a14 100644 --- a/spring-boot-project/spring-boot-test-autoconfigure/src/main/resources/META-INF/spring/org.springframework.boot.test.autoconfigure.data.jdbc.AutoConfigureDataJdbc.imports +++ b/spring-boot-project/spring-boot-test-autoconfigure/src/main/resources/META-INF/spring/org.springframework.boot.test.autoconfigure.data.jdbc.AutoConfigureDataJdbc.imports @@ -2,10 +2,10 @@ org.springframework.boot.autoconfigure.data.jdbc.JdbcRepositoriesAutoConfiguration org.springframework.boot.autoconfigure.flyway.FlywayAutoConfiguration org.springframework.boot.autoconfigure.jdbc.DataSourceAutoConfiguration +org.springframework.boot.autoconfigure.jdbc.DataSourceInitializationAutoConfiguration org.springframework.boot.autoconfigure.jdbc.DataSourceTransactionManagerAutoConfiguration org.springframework.boot.autoconfigure.jdbc.JdbcClientAutoConfiguration org.springframework.boot.autoconfigure.jdbc.JdbcTemplateAutoConfiguration org.springframework.boot.autoconfigure.liquibase.LiquibaseAutoConfiguration -org.springframework.boot.autoconfigure.sql.init.SqlInitializationAutoConfiguration org.springframework.boot.autoconfigure.transaction.TransactionAutoConfiguration optional:org.springframework.boot.testcontainers.service.connection.ServiceConnectionAutoConfiguration diff --git a/spring-boot-project/spring-boot-test-autoconfigure/src/main/resources/META-INF/spring/org.springframework.boot.test.autoconfigure.data.r2dbc.AutoConfigureDataR2dbc.imports b/spring-boot-project/spring-boot-test-autoconfigure/src/main/resources/META-INF/spring/org.springframework.boot.test.autoconfigure.data.r2dbc.AutoConfigureDataR2dbc.imports index 678494ab91..0b6ad52ba9 100644 --- a/spring-boot-project/spring-boot-test-autoconfigure/src/main/resources/META-INF/spring/org.springframework.boot.test.autoconfigure.data.r2dbc.AutoConfigureDataR2dbc.imports +++ b/spring-boot-project/spring-boot-test-autoconfigure/src/main/resources/META-INF/spring/org.springframework.boot.test.autoconfigure.data.r2dbc.AutoConfigureDataR2dbc.imports @@ -4,7 +4,7 @@ org.springframework.boot.autoconfigure.data.r2dbc.R2dbcDataAutoConfiguration org.springframework.boot.autoconfigure.flyway.FlywayAutoConfiguration org.springframework.boot.autoconfigure.liquibase.LiquibaseAutoConfiguration org.springframework.boot.autoconfigure.r2dbc.R2dbcAutoConfiguration +org.springframework.boot.autoconfigure.r2dbc.R2dbcInitializationAutoConfiguration org.springframework.boot.autoconfigure.r2dbc.R2dbcTransactionManagerAutoConfiguration -org.springframework.boot.autoconfigure.sql.init.SqlInitializationAutoConfiguration org.springframework.boot.autoconfigure.transaction.TransactionAutoConfiguration optional:org.springframework.boot.testcontainers.service.connection.ServiceConnectionAutoConfiguration diff --git a/spring-boot-project/spring-boot-test-autoconfigure/src/main/resources/META-INF/spring/org.springframework.boot.test.autoconfigure.jdbc.AutoConfigureJdbc.imports b/spring-boot-project/spring-boot-test-autoconfigure/src/main/resources/META-INF/spring/org.springframework.boot.test.autoconfigure.jdbc.AutoConfigureJdbc.imports index 480dcff0e7..7ec0d45459 100644 --- a/spring-boot-project/spring-boot-test-autoconfigure/src/main/resources/META-INF/spring/org.springframework.boot.test.autoconfigure.jdbc.AutoConfigureJdbc.imports +++ b/spring-boot-project/spring-boot-test-autoconfigure/src/main/resources/META-INF/spring/org.springframework.boot.test.autoconfigure.jdbc.AutoConfigureJdbc.imports @@ -1,10 +1,10 @@ # AutoConfigureJdbc auto-configuration imports org.springframework.boot.autoconfigure.flyway.FlywayAutoConfiguration org.springframework.boot.autoconfigure.jdbc.DataSourceAutoConfiguration +org.springframework.boot.autoconfigure.jdbc.DataSourceInitializationAutoConfiguration org.springframework.boot.autoconfigure.jdbc.DataSourceTransactionManagerAutoConfiguration org.springframework.boot.autoconfigure.jdbc.JdbcClientAutoConfiguration org.springframework.boot.autoconfigure.jdbc.JdbcTemplateAutoConfiguration org.springframework.boot.autoconfigure.liquibase.LiquibaseAutoConfiguration -org.springframework.boot.autoconfigure.sql.init.SqlInitializationAutoConfiguration org.springframework.boot.autoconfigure.transaction.TransactionAutoConfiguration optional:org.springframework.boot.testcontainers.service.connection.ServiceConnectionAutoConfiguration diff --git a/spring-boot-project/spring-boot-test-autoconfigure/src/main/resources/META-INF/spring/org.springframework.boot.test.autoconfigure.jooq.AutoConfigureJooq.imports b/spring-boot-project/spring-boot-test-autoconfigure/src/main/resources/META-INF/spring/org.springframework.boot.test.autoconfigure.jooq.AutoConfigureJooq.imports index 1e042e2c08..e2dc4a29f9 100644 --- a/spring-boot-project/spring-boot-test-autoconfigure/src/main/resources/META-INF/spring/org.springframework.boot.test.autoconfigure.jooq.AutoConfigureJooq.imports +++ b/spring-boot-project/spring-boot-test-autoconfigure/src/main/resources/META-INF/spring/org.springframework.boot.test.autoconfigure.jooq.AutoConfigureJooq.imports @@ -1,9 +1,9 @@ # AutoConfigureJooq auto-configuration imports org.springframework.boot.autoconfigure.flyway.FlywayAutoConfiguration org.springframework.boot.autoconfigure.jdbc.DataSourceAutoConfiguration +org.springframework.boot.autoconfigure.jdbc.DataSourceInitializationAutoConfiguration org.springframework.boot.autoconfigure.jdbc.DataSourceTransactionManagerAutoConfiguration org.springframework.boot.autoconfigure.jooq.JooqAutoConfiguration org.springframework.boot.autoconfigure.liquibase.LiquibaseAutoConfiguration -org.springframework.boot.autoconfigure.sql.init.SqlInitializationAutoConfiguration org.springframework.boot.autoconfigure.transaction.TransactionAutoConfiguration optional:org.springframework.boot.testcontainers.service.connection.ServiceConnectionAutoConfiguration diff --git a/spring-boot-project/spring-boot-test-autoconfigure/src/main/resources/META-INF/spring/org.springframework.boot.test.autoconfigure.orm.jpa.AutoConfigureDataJpa.imports b/spring-boot-project/spring-boot-test-autoconfigure/src/main/resources/META-INF/spring/org.springframework.boot.test.autoconfigure.orm.jpa.AutoConfigureDataJpa.imports index 83465fdeba..4db26e5f10 100644 --- a/spring-boot-project/spring-boot-test-autoconfigure/src/main/resources/META-INF/spring/org.springframework.boot.test.autoconfigure.orm.jpa.AutoConfigureDataJpa.imports +++ b/spring-boot-project/spring-boot-test-autoconfigure/src/main/resources/META-INF/spring/org.springframework.boot.test.autoconfigure.orm.jpa.AutoConfigureDataJpa.imports @@ -2,11 +2,11 @@ org.springframework.boot.autoconfigure.data.jpa.JpaRepositoriesAutoConfiguration org.springframework.boot.autoconfigure.flyway.FlywayAutoConfiguration org.springframework.boot.autoconfigure.jdbc.DataSourceAutoConfiguration +org.springframework.boot.autoconfigure.jdbc.DataSourceInitializationAutoConfiguration org.springframework.boot.autoconfigure.jdbc.DataSourceTransactionManagerAutoConfiguration org.springframework.boot.autoconfigure.jdbc.JdbcClientAutoConfiguration org.springframework.boot.autoconfigure.jdbc.JdbcTemplateAutoConfiguration org.springframework.boot.autoconfigure.liquibase.LiquibaseAutoConfiguration org.springframework.boot.autoconfigure.orm.jpa.HibernateJpaAutoConfiguration -org.springframework.boot.autoconfigure.sql.init.SqlInitializationAutoConfiguration org.springframework.boot.autoconfigure.transaction.TransactionAutoConfiguration optional:org.springframework.boot.testcontainers.service.connection.ServiceConnectionAutoConfiguration