Spring/spring-boot
1
0
Fork 0
Code Issues Packages Projects Releases Wiki Activity

Remove remaining code that was deprecated in 2.5

Browse Source 
Closes gh-30442
This commit is contained in:
Andy Wilkinson
2022-04-13 18:09:39 +01:00
parent 631b876165
commit 5e76671859
12 changed files with 86 additions and 948 deletions
Download Patch File Download Diff File Expand all files Collapse all files

5
spring-boot-project/spring-boot-autoconfigure/src/main/java/org/springframework/boot/autoconfigure/jdbc/DataSourceAutoConfiguration.java
View File

@@ -52,14 +52,11 @@ import org.springframework.util.StringUtils;
* @author Kazuki Shimizu
* @since 1.0.0
*/
@SuppressWarnings("deprecation")
@AutoConfiguration(before = SqlInitializationAutoConfiguration.class)
@ConditionalOnClass({ DataSource.class, EmbeddedDatabaseType.class })
@ConditionalOnMissingBean(type = "io.r2dbc.spi.ConnectionFactory")
@EnableConfigurationProperties(DataSourceProperties.class)
@Import({ DataSourcePoolMetadataProvidersConfiguration.class,
DataSourceInitializationConfiguration.InitializationSpecificCredentialsDataSourceInitializationConfiguration.class,
DataSourceInitializationConfiguration.SharedCredentialsDataSourceInitializationConfiguration.class })
@Import(DataSourcePoolMetadataProvidersConfiguration.class)
public class DataSourceAutoConfiguration {
@Configuration(proxyBeanMethods = false)

200
spring-boot-project/spring-boot-autoconfigure/src/main/java/org/springframework/boot/autoconfigure/jdbc/DataSourceInitializationConfiguration.java
View File

@@ -1,200 +0,0 @@
/*
* Copyright 2012-2021 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 java.util.ArrayList;
import java.util.Arrays;
import java.util.Collections;
import java.util.HashSet;
import java.util.List;
import java.util.Set;
import java.util.function.Supplier;
import java.util.stream.Collectors;
import javax.sql.DataSource;
import org.springframework.beans.factory.ObjectProvider;
import org.springframework.boot.autoconfigure.condition.AnyNestedCondition;
import org.springframework.boot.autoconfigure.condition.ConditionMessage;
import org.springframework.boot.autoconfigure.condition.ConditionOutcome;
import org.springframework.boot.autoconfigure.condition.ConditionalOnMissingBean;
import org.springframework.boot.autoconfigure.condition.ConditionalOnProperty;
import org.springframework.boot.autoconfigure.condition.ConditionalOnSingleCandidate;
import org.springframework.boot.autoconfigure.condition.SpringBootCondition;
import org.springframework.boot.autoconfigure.jdbc.DataSourceInitializationConfiguration.InitializationSpecificCredentialsDataSourceInitializationConfiguration.DifferentCredentialsCondition;
import org.springframework.boot.autoconfigure.jdbc.DataSourceInitializationConfiguration.SharedCredentialsDataSourceInitializationConfiguration.DataSourceInitializationCondition;
import org.springframework.boot.autoconfigure.sql.init.SqlDataSourceScriptDatabaseInitializer;
import org.springframework.boot.jdbc.DataSourceBuilder;
import org.springframework.boot.jdbc.init.DataSourceScriptDatabaseInitializer;
import org.springframework.boot.sql.init.DatabaseInitializationMode;
import org.springframework.boot.sql.init.DatabaseInitializationSettings;
import org.springframework.boot.sql.init.dependency.DatabaseInitializationDependencyConfigurer;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.ConditionContext;
import org.springframework.context.annotation.DependsOn;
import org.springframework.core.env.Environment;
import org.springframework.core.type.AnnotatedTypeMetadata;
import org.springframework.jdbc.datasource.SimpleDriverDataSource;
import org.springframework.util.StringUtils;
/**
* Configuration for {@link DataSource} initialization using a
* {@link DataSourceScriptDatabaseInitializer} with DDL and DML scripts.
*
* @author Andy Wilkinson
*/
@Deprecated
class DataSourceInitializationConfiguration {
private static DataSource determineDataSource(Supplier<DataSource> dataSource, String username, String password) {
if (StringUtils.hasText(username) && StringUtils.hasText(password)) {
return DataSourceBuilder.derivedFrom(dataSource.get()).type(SimpleDriverDataSource.class).username(username)
.password(password).build();
}
return dataSource.get();
}
private static List<String> scriptLocations(List<String> locations, String fallback, String platform) {
if (locations != null) {
return locations;
}
List<String> fallbackLocations = new ArrayList<>();
fallbackLocations.add("optional:classpath*:" + fallback + "-" + platform + ".sql");
fallbackLocations.add("optional:classpath*:" + fallback + ".sql");
return fallbackLocations;
}
private static DatabaseInitializationMode mapMode(org.springframework.boot.jdbc.DataSourceInitializationMode mode) {
switch (mode) {
case ALWAYS:
return DatabaseInitializationMode.ALWAYS;
case EMBEDDED:
return DatabaseInitializationMode.EMBEDDED;
case NEVER:
return DatabaseInitializationMode.NEVER;
default:
throw new IllegalStateException("Unexpected initialization mode '" + mode + "'");
}
}
// Fully-qualified to work around javac bug in JDK 1.8
@org.springframework.context.annotation.Configuration(proxyBeanMethods = false)
@org.springframework.context.annotation.Conditional(DifferentCredentialsCondition.class)
@org.springframework.context.annotation.Import(DatabaseInitializationDependencyConfigurer.class)
@ConditionalOnSingleCandidate(DataSource.class)
@ConditionalOnMissingBean(DataSourceScriptDatabaseInitializer.class)
static class InitializationSpecificCredentialsDataSourceInitializationConfiguration {
@Bean
SqlDataSourceScriptDatabaseInitializer ddlOnlyScriptDataSourceInitializer(ObjectProvider<DataSource> dataSource,
DataSourceProperties properties) {
DatabaseInitializationSettings settings = new DatabaseInitializationSettings();
settings.setSchemaLocations(scriptLocations(properties.getSchema(), "schema", properties.getPlatform()));
settings.setContinueOnError(properties.isContinueOnError());
settings.setSeparator(properties.getSeparator());
settings.setEncoding(properties.getSqlScriptEncoding());
settings.setMode(mapMode(properties.getInitializationMode()));
DataSource initializationDataSource = determineDataSource(dataSource::getObject,
properties.getSchemaUsername(), properties.getSchemaPassword());
return new SqlDataSourceScriptDatabaseInitializer(initializationDataSource, settings);
}
@Bean
@DependsOn("ddlOnlyScriptDataSourceInitializer")
SqlDataSourceScriptDatabaseInitializer dmlOnlyScriptDataSourceInitializer(ObjectProvider<DataSource> dataSource,
DataSourceProperties properties) {
DatabaseInitializationSettings settings = new DatabaseInitializationSettings();
settings.setDataLocations(scriptLocations(properties.getData(), "data", properties.getPlatform()));
settings.setContinueOnError(properties.isContinueOnError());
settings.setSeparator(properties.getSeparator());
settings.setEncoding(properties.getSqlScriptEncoding());
settings.setMode(mapMode(properties.getInitializationMode()));
DataSource initializationDataSource = determineDataSource(dataSource::getObject,
properties.getDataUsername(), properties.getDataPassword());
return new SqlDataSourceScriptDatabaseInitializer(initializationDataSource, settings);
}
static class DifferentCredentialsCondition extends AnyNestedCondition {
DifferentCredentialsCondition() {
super(ConfigurationPhase.PARSE_CONFIGURATION);
}
@ConditionalOnProperty(prefix = "spring.datasource", name = "schema-username")
static class SchemaCredentials {
}
@ConditionalOnProperty(prefix = "spring.datasource", name = "data-username")
static class DataCredentials {
}
}
}
// Fully-qualified to work around javac bug in JDK 1.8
@org.springframework.context.annotation.Configuration(proxyBeanMethods = false)
@org.springframework.context.annotation.Import(DatabaseInitializationDependencyConfigurer.class)
@org.springframework.context.annotation.Conditional(DataSourceInitializationCondition.class)
@ConditionalOnSingleCandidate(DataSource.class)
@ConditionalOnMissingBean(DataSourceScriptDatabaseInitializer.class)
static class SharedCredentialsDataSourceInitializationConfiguration {
@Bean
SqlDataSourceScriptDatabaseInitializer scriptDataSourceInitializer(DataSource dataSource,
DataSourceProperties properties) {
DatabaseInitializationSettings settings = new DatabaseInitializationSettings();
settings.setSchemaLocations(scriptLocations(properties.getSchema(), "schema", properties.getPlatform()));
settings.setDataLocations(scriptLocations(properties.getData(), "data", properties.getPlatform()));
settings.setContinueOnError(properties.isContinueOnError());
settings.setSeparator(properties.getSeparator());
settings.setEncoding(properties.getSqlScriptEncoding());
settings.setMode(mapMode(properties.getInitializationMode()));
return new SqlDataSourceScriptDatabaseInitializer(dataSource, settings);
}
static class DataSourceInitializationCondition extends SpringBootCondition {
private static final Set<String> INITIALIZATION_PROPERTIES = Collections
.unmodifiableSet(new HashSet<>(Arrays.asList("spring.datasource.initialization-mode",
"spring.datasource.platform", "spring.datasource.schema", "spring.datasource.schema[0]",
"spring.datasource.schema-username", "spring.datasource.schema-password",
"spring.datasource.data", "spring.datasource.data[0]", "spring.datasource.data-username",
"spring.datasource.data-password", "spring.datasource.continue-on-error",
"spring.datasource.separator", "spring.datasource.sql-script-encoding")));
@Override
public ConditionOutcome getMatchOutcome(ConditionContext context, AnnotatedTypeMetadata metadata) {
ConditionMessage.Builder message = ConditionMessage.forCondition("DataSource Initialization");
Environment environment = context.getEnvironment();
Set<String> configuredProperties = INITIALIZATION_PROPERTIES.stream()
.filter(environment::containsProperty).collect(Collectors.toSet());
if (configuredProperties.isEmpty()) {
return ConditionOutcome
.noMatch(message.didNotFind("configured properties").items(INITIALIZATION_PROPERTIES));
}
return ConditionOutcome.match(
message.found("configured property", "configured properties").items(configuredProperties));
}
}
}
}

191
spring-boot-project/spring-boot-autoconfigure/src/main/java/org/springframework/boot/autoconfigure/jdbc/DataSourceProperties.java
View File

@@ -16,9 +16,7 @@
package org.springframework.boot.autoconfigure.jdbc;
import java.nio.charset.Charset;
import java.util.LinkedHashMap;
import java.util.List;
import java.util.Map;
import java.util.UUID;
@@ -28,7 +26,6 @@ import org.springframework.beans.factory.BeanClassLoaderAware;
import org.springframework.beans.factory.BeanCreationException;
import org.springframework.beans.factory.InitializingBean;
import org.springframework.boot.context.properties.ConfigurationProperties;
import org.springframework.boot.context.properties.DeprecatedConfigurationProperty;
import org.springframework.boot.jdbc.DataSourceBuilder;
import org.springframework.boot.jdbc.DatabaseDriver;
import org.springframework.boot.jdbc.EmbeddedDatabaseConnection;
@@ -95,73 +92,6 @@ public class DataSourceProperties implements BeanClassLoaderAware, InitializingB
*/
private String jndiName;
/**
* Mode to apply when determining if DataSource initialization should be performed
* using the available DDL and DML scripts.
*/
@Deprecated
private org.springframework.boot.jdbc.DataSourceInitializationMode initializationMode = org.springframework.boot.jdbc.DataSourceInitializationMode.EMBEDDED;
/**
* Platform to use in the DDL or DML scripts (such as schema-${platform}.sql or
* data-${platform}.sql).
*/
@Deprecated
private String platform = "all";
/**
* Schema (DDL) script resource references.
*/
private List<String> schema;
/**
* Username of the database to execute DDL scripts (if different).
*/
@Deprecated
private String schemaUsername;
/**
* Password of the database to execute DDL scripts (if different).
*/
@Deprecated
private String schemaPassword;
/**
* Data (DML) script resource references.
*/
@Deprecated
private List<String> data;
/**
* Username of the database to execute DML scripts (if different).
*/
@Deprecated
private String dataUsername;
/**
* Password of the database to execute DML scripts (if different).
*/
@Deprecated
private String dataPassword;
/**
* Whether to stop if an error occurs while initializing the database.
*/
@Deprecated
private boolean continueOnError = false;
/**
* Statement separator in SQL initialization scripts.
*/
@Deprecated
private String separator = ";";
/**
* SQL scripts encoding.
*/
@Deprecated
private Charset sqlScriptEncoding;
/**
* Connection details for an embedded database. Defaults to the most suitable embedded
* database that is available on the classpath.
@@ -391,127 +321,6 @@ public class DataSourceProperties implements BeanClassLoaderAware, InitializingB
this.jndiName = jndiName;
}
@Deprecated
@DeprecatedConfigurationProperty(replacement = "spring.sql.init.mode")
public org.springframework.boot.jdbc.DataSourceInitializationMode getInitializationMode() {
return this.initializationMode;
}
@Deprecated
public void setInitializationMode(org.springframework.boot.jdbc.DataSourceInitializationMode initializationMode) {
this.initializationMode = initializationMode;
}
@Deprecated
@DeprecatedConfigurationProperty(replacement = "spring.sql.init.platform")
public String getPlatform() {
return this.platform;
}
@Deprecated
public void setPlatform(String platform) {
this.platform = platform;
}
@Deprecated
@DeprecatedConfigurationProperty(replacement = "spring.sql.init.schema-locations")
public List<String> getSchema() {
return this.schema;
}
@Deprecated
public void setSchema(List<String> schema) {
this.schema = schema;
}
@Deprecated
@DeprecatedConfigurationProperty(replacement = "spring.sql.init.username")
public String getSchemaUsername() {
return this.schemaUsername;
}
@Deprecated
public void setSchemaUsername(String schemaUsername) {
this.schemaUsername = schemaUsername;
}
@Deprecated
@DeprecatedConfigurationProperty(replacement = "spring.sql.init.password")
public String getSchemaPassword() {
return this.schemaPassword;
}
@Deprecated
public void setSchemaPassword(String schemaPassword) {
this.schemaPassword = schemaPassword;
}
@Deprecated
@DeprecatedConfigurationProperty(replacement = "spring.sql.init.data-locations")
public List<String> getData() {
return this.data;
}
@Deprecated
public void setData(List<String> data) {
this.data = data;
}
@Deprecated
@DeprecatedConfigurationProperty(replacement = "spring.sql.init.username")
public String getDataUsername() {
return this.dataUsername;
}
@Deprecated
public void setDataUsername(String dataUsername) {
this.dataUsername = dataUsername;
}
@Deprecated
@DeprecatedConfigurationProperty(replacement = "spring.sql.init.password")
public String getDataPassword() {
return this.dataPassword;
}
@Deprecated
public void setDataPassword(String dataPassword) {
this.dataPassword = dataPassword;
}
@Deprecated
@DeprecatedConfigurationProperty(replacement = "spring.sql.init.continue-on-error")
public boolean isContinueOnError() {
return this.continueOnError;
}
@Deprecated
public void setContinueOnError(boolean continueOnError) {
this.continueOnError = continueOnError;
}
@Deprecated
@DeprecatedConfigurationProperty(replacement = "spring.sql.init.separator")
public String getSeparator() {
return this.separator;
}
@Deprecated
public void setSeparator(String separator) {
this.separator = separator;
}
@Deprecated
@DeprecatedConfigurationProperty(replacement = "spring.sql.init.encoding")
public Charset getSqlScriptEncoding() {
return this.sqlScriptEncoding;
}
@Deprecated
public void setSqlScriptEncoding(Charset sqlScriptEncoding) {
this.sqlScriptEncoding = sqlScriptEncoding;
}
public EmbeddedDatabaseConnection getEmbeddedDatabaseConnection() {
return this.embeddedDatabaseConnection;
}

84
spring-boot-project/spring-boot-autoconfigure/src/main/resources/META-INF/additional-spring-configuration-metadata.json
View File

@@ -792,10 +792,41 @@
"defaultValue": "default"
},
{
"name": "spring.datasource.initialization-mode",
"defaultValue": "embedded"
},
{
"name" : "spring.datasource.continue-on-error",
"type" : "java.lang.Boolean",
"deprecation" : {
"level" : "error",
"replacement": "spring.sql.init.continue-on-error"
}
}, {
"name" : "spring.datasource.data",
"type" : "java.util.List<java.lang.String>",
"deprecation" : {
"level" : "error",
"replacement": "spring.sql.init.data-locations"
}
}, {
"name" : "spring.datasource.data-password",
"type" : "java.lang.String",
"deprecation" : {
"level" : "error",
"replacement": "spring.sql.init.password"
}
}, {
"name" : "spring.datasource.data-username",
"type" : "java.lang.String",
"deprecation" : {
"level" : "error",
"replacement": "spring.sql.init.username"
}
}, {
"name" : "spring.datasource.initialization-mode",
"type" : "org.springframework.boot.jdbc.DataSourceInitializationMode",
"deprecation" : {
"level" : "error",
"replacement": "spring.sql.init.mode"
}
}, {
"name": "spring.datasource.jmx-enabled",
"type": "java.lang.Boolean",
"description": "Whether to enable JMX support (if provided by the underlying pool).",
@@ -804,8 +835,49 @@
"level": "error",
"replacement": "spring.datasource.tomcat.jmx-enabled"
}
},
{
}, {
"name" : "spring.datasource.platform",
"type" : "java.lang.String",
"deprecation" : {
"level" : "error",
"replacement": "spring.sql.init.platform"
}
}, {
"name" : "spring.datasource.schema",
"type" : "java.util.List<java.lang.String>",
"deprecation" : {
"level" : "error",
"replacement": "spring.sql.init.schema-locations"
}
}, {
"name" : "spring.datasource.schema-password",
"type" : "java.lang.String",
"deprecation" : {
"level" : "error",
"replacement": "spring.sql.init.password"
}
}, {
"name" : "spring.datasource.schema-username",
"type" : "java.lang.String",
"deprecation" : {
"level" : "error",
"replacement": "spring.sql.init.username"
}
}, {
"name" : "spring.datasource.separator",
"type" : "java.lang.String",
"deprecation" : {
"level" : "error",
"replacement": "spring.sql.init.separator"
}
}, {
"name" : "spring.datasource.sql-script-encoding",
"type" : "java.nio.charset.Charset",
"deprecation" : {
"level" : "error",
"replacement": "spring.sql.init.encoding"
}
}, {
"name": "spring.elasticsearch.jest.connection-timeout",
"type": "java.time.Duration",
"description": "Connection timeout.",

10
spring-boot-project/spring-boot-autoconfigure/src/test/java/org/springframework/boot/autoconfigure/jdbc/DataSourceAutoConfigurationTests.java
View File

@@ -235,16 +235,6 @@ class DataSourceAutoConfigurationTests {
.run((context) -> assertThat(context).getBean(DataSource.class).isInstanceOf(EmbeddedDatabase.class));
}
@Test
@Deprecated
void testDataSourceIsInitializedEarly() {
this.contextRunner.withUserConfiguration(TestInitializedDataSourceConfiguration.class)
.withPropertyValues("spring.datasource.initialization-mode=always").run((context) -> {
assertThat(context).hasSingleBean(DataSourceScriptDatabaseInitializer.class);
assertThat(context.getBean(TestInitializedDataSourceConfiguration.class).called).isTrue();
});
}
@Test
void whenNoInitializationRelatedSpringDataSourcePropertiesAreConfiguredThenInitializationBacksOff() {
this.contextRunner

440
spring-boot-project/spring-boot-autoconfigure/src/test/java/org/springframework/boot/autoconfigure/jdbc/DataSourceInitializationIntegrationTests.java
View File

@@ -1,440 +0,0 @@
/*
* Copyright 2012-2021 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 java.io.IOException;
import java.io.PrintWriter;
import java.sql.Connection;
import java.sql.SQLException;
import java.sql.SQLFeatureNotSupportedException;
import java.util.Arrays;
import java.util.Comparator;
import java.util.Random;
import java.util.UUID;
import java.util.concurrent.atomic.AtomicInteger;
import java.util.logging.Logger;
import javax.sql.DataSource;
import com.zaxxer.hikari.HikariDataSource;
import org.junit.jupiter.api.Test;
import org.springframework.beans.factory.BeanCreationException;
import org.springframework.beans.factory.config.BeanFactoryPostProcessor;
import org.springframework.beans.factory.config.BeanPostProcessor;
import org.springframework.boot.autoconfigure.AutoConfigurations;
import org.springframework.boot.autoconfigure.orm.jpa.HibernateJpaAutoConfiguration;
import org.springframework.boot.test.context.assertj.AssertableApplicationContext;
import org.springframework.boot.test.context.runner.ApplicationContextRunner;
import org.springframework.boot.test.context.runner.ContextConsumer;
import org.springframework.context.annotation.AnnotationConfigApplicationContext;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.context.annotation.Scope;
import org.springframework.context.support.SimpleThreadScope;
import org.springframework.core.io.DefaultResourceLoader;
import org.springframework.core.io.Resource;
import org.springframework.core.io.ResourceLoader;
import org.springframework.core.io.support.ResourcePatternResolver;
import org.springframework.core.io.support.ResourcePatternUtils;
import org.springframework.jdbc.BadSqlGrammarException;
import org.springframework.jdbc.core.JdbcOperations;
import org.springframework.jdbc.core.JdbcTemplate;
import org.springframework.util.ClassUtils;
import static org.assertj.core.api.Assertions.assertThat;
import static org.assertj.core.api.Assertions.assertThatExceptionOfType;
/**
* Integration tests for DataSource initialization.
*
* @author Dave Syer
* @author Stephane Nicoll
*/
@Deprecated
class DataSourceInitializationIntegrationTests {
private final ApplicationContextRunner contextRunner = new ApplicationContextRunner()
.withConfiguration(AutoConfigurations.of(DataSourceAutoConfiguration.class))
.withPropertyValues("spring.datasource.initialization-mode=never",
"spring.datasource.url:jdbc:hsqldb:mem:init-" + UUID.randomUUID());
@Test
void dataSourceInitialized() {
this.contextRunner.withPropertyValues("spring.datasource.initialization-mode:always").run((context) -> {
assertThat(context).hasSingleBean(DataSource.class);
DataSource dataSource = context.getBean(DataSource.class);
assertThat(dataSource).isInstanceOf(HikariDataSource.class);
assertDataSourceIsInitialized(dataSource);
});
}
@Test
void initializationAppliesToCustomDataSource() {
this.contextRunner.withUserConfiguration(OneDataSource.class)
.withPropertyValues("spring.datasource.initialization-mode:always").run((context) -> {
assertThat(context).hasSingleBean(DataSource.class);
assertDataSourceIsInitialized(context.getBean(DataSource.class));
});
}
@Test
void initializationWithUsernameAndPasswordAppliesToCustomDataSource() {
this.contextRunner.withUserConfiguration(OneDataSource.class)
.withPropertyValues("spring.datasource.initialization-mode:always",
"spring.datasource.schema-username=test", "spring.datasource.schema-password=secret")
.run((context) -> {
assertThat(context).hasSingleBean(DataSource.class);
assertDataSourceIsInitialized(context.getBean(DataSource.class));
});
}
private void assertDataSourceIsInitialized(DataSource dataSource) {
JdbcOperations template = new JdbcTemplate(dataSource);
assertThat(template.queryForObject("SELECT COUNT(*) from BAR", Integer.class)).isEqualTo(1);
}
@Test
void dataSourceInitializedWithExplicitScript() {
this.contextRunner.withPropertyValues("spring.datasource.initialization-mode:always",
"spring.datasource.schema:" + getRelativeLocationFor("schema.sql"),
"spring.datasource.data:" + getRelativeLocationFor("data.sql")).run((context) -> {
DataSource dataSource = context.getBean(DataSource.class);
assertThat(dataSource).isInstanceOf(HikariDataSource.class);
assertThat(dataSource).isNotNull();
JdbcOperations template = new JdbcTemplate(dataSource);
assertThat(template.queryForObject("SELECT COUNT(*) from FOO", Integer.class)).isEqualTo(1);
});
}
@Test
void dataSourceInitializedWithMultipleScripts() {
this.contextRunner.withPropertyValues("spring.datasource.initialization-mode:always",
"spring.datasource.schema:" + getRelativeLocationFor("schema.sql") + ","
+ getRelativeLocationFor("another.sql"),
"spring.datasource.data:" + getRelativeLocationFor("data.sql")).run((context) -> {
DataSource dataSource = context.getBean(DataSource.class);
assertThat(dataSource).isInstanceOf(HikariDataSource.class);
assertThat(dataSource).isNotNull();
JdbcOperations template = new JdbcTemplate(dataSource);
assertThat(template.queryForObject("SELECT COUNT(*) from FOO", Integer.class)).isEqualTo(1);
assertThat(template.queryForObject("SELECT COUNT(*) from SPAM", Integer.class)).isEqualTo(0);
});
}
@Test
void dataSourceInitializedWithExplicitSqlScriptEncoding() {
this.contextRunner.withPropertyValues("spring.datasource.initialization-mode:always",
"spring.datasource.sqlScriptEncoding:UTF-8",
"spring.datasource.schema:" + getRelativeLocationFor("encoding-schema.sql"),
"spring.datasource.data:" + getRelativeLocationFor("encoding-data.sql")).run((context) -> {
DataSource dataSource = context.getBean(DataSource.class);
assertThat(dataSource).isInstanceOf(HikariDataSource.class);
assertThat(dataSource).isNotNull();
JdbcOperations template = new JdbcTemplate(dataSource);
assertThat(template.queryForObject("SELECT COUNT(*) from BAR", Integer.class)).isEqualTo(2);
assertThat(template.queryForObject("SELECT name from BAR WHERE id=1", String.class))
.isEqualTo("bar");
assertThat(template.queryForObject("SELECT name from BAR WHERE id=2", String.class))
.isEqualTo("ばー");
});
}
@Test
void initializationDisabled() {
this.contextRunner.run(assertInitializationIsDisabled());
}
@Test
void initializationDoesNotApplyWithSeveralDataSources() {
this.contextRunner.withUserConfiguration(TwoDataSources.class)
.withPropertyValues("spring.datasource.initialization-mode:always").run((context) -> {
assertThat(context.getBeanNamesForType(DataSource.class)).hasSize(2);
assertDataSourceNotInitialized(context.getBean("oneDataSource", DataSource.class));
assertDataSourceNotInitialized(context.getBean("twoDataSource", DataSource.class));
});
}
private ContextConsumer<AssertableApplicationContext> assertInitializationIsDisabled() {
return (context) -> {
assertThat(context).hasSingleBean(DataSource.class);
DataSource dataSource = context.getBean(DataSource.class);
assertDataSourceNotInitialized(dataSource);
};
}
private void assertDataSourceNotInitialized(DataSource dataSource) {
JdbcOperations template = new JdbcTemplate(dataSource);
assertThatExceptionOfType(BadSqlGrammarException.class)
.isThrownBy(() -> template.queryForObject("SELECT COUNT(*) from BAR", Integer.class))
.satisfies((ex) -> {
SQLException sqlException = ex.getSQLException();
int expectedCode = -5501; // user lacks privilege or object not found
assertThat(sqlException.getErrorCode()).isEqualTo(expectedCode);
});
}
@Test
void dataSourceInitializedWithSchemaCredentials() {
this.contextRunner
.withPropertyValues("spring.datasource.initialization-mode:always",
"spring.datasource.sqlScriptEncoding:UTF-8",
"spring.datasource.schema:" + getRelativeLocationFor("encoding-schema.sql"),
"spring.datasource.data:" + getRelativeLocationFor("encoding-data.sql"),
"spring.datasource.schema-username:admin", "spring.datasource.schema-password:admin")
.run((context) -> {
assertThat(context).hasFailed();
assertThat(context.getStartupFailure()).isInstanceOf(BeanCreationException.class)
.hasMessageContaining("invalid authorization specification");
context.getStartupFailure().printStackTrace();
});
}
@Test
void dataSourceInitializedWithDataCredentials() {
this.contextRunner
.withPropertyValues("spring.datasource.initialization-mode:always",
"spring.datasource.sqlScriptEncoding:UTF-8",
"spring.datasource.schema:" + getRelativeLocationFor("encoding-schema.sql"),
"spring.datasource.data:" + getRelativeLocationFor("encoding-data.sql"),
"spring.datasource.data-username:admin", "spring.datasource.data-password:admin")
.run((context) -> {
assertThat(context).hasFailed();
assertThat(context.getStartupFailure()).isInstanceOf(BeanCreationException.class)
.hasMessageContaining("invalid authorization specification");
});
}
@Test
void multipleScriptsAppliedInLexicalOrder() {
new ApplicationContextRunner(() -> {
AnnotationConfigApplicationContext context = new AnnotationConfigApplicationContext();
context.setResourceLoader(new ReverseOrderResourceLoader(new DefaultResourceLoader()));
return context;
}).withConfiguration(AutoConfigurations.of(DataSourceAutoConfiguration.class))
.withPropertyValues("spring.datasource.initialization-mode=always",
"spring.datasource.url:jdbc:hsqldb:mem:testdb-" + new Random().nextInt(),
"spring.datasource.schema:classpath*:" + getRelativeLocationFor("lexical-schema-*.sql"),
"spring.datasource.data:classpath*:" + getRelativeLocationFor("data.sql"))
.run((context) -> {
DataSource dataSource = context.getBean(DataSource.class);
assertThat(dataSource).isInstanceOf(HikariDataSource.class);
assertThat(dataSource).isNotNull();
JdbcOperations template = new JdbcTemplate(dataSource);
assertThat(template.queryForObject("SELECT COUNT(*) from FOO", Integer.class)).isEqualTo(1);
});
}
@Test
void testDataSourceInitializedWithInvalidSchemaResource() {
this.contextRunner.withPropertyValues("spring.datasource.initialization-mode:always",
"spring.datasource.schema:classpath:does/not/exist.sql").run((context) -> {
assertThat(context).hasFailed();
assertThat(context.getStartupFailure()).isInstanceOf(BeanCreationException.class);
assertThat(context.getStartupFailure())
.hasMessageContaining("No schema scripts found at location 'classpath:does/not/exist.sql'");
});
}
@Test
void dataSourceInitializedWithInvalidDataResource() {
this.contextRunner.withPropertyValues("spring.datasource.initialization-mode:always",
"spring.datasource.schema:" + getRelativeLocationFor("schema.sql"),
"spring.datasource.data:classpath:does/not/exist.sql").run((context) -> {
assertThat(context).hasFailed();
assertThat(context.getStartupFailure()).isInstanceOf(BeanCreationException.class);
assertThat(context.getStartupFailure())
.hasMessageContaining("No data scripts found at location 'classpath:does/not/exist.sql'");
});
}
@Test
void whenDataSourceIsProxiedByABeanPostProcessorThenDataSourceInitializationUsesTheProxy() {
this.contextRunner.withPropertyValues("spring.datasource.initialization-mode:always")
.withUserConfiguration(DataSourceProxyConfiguration.class).run((context) -> {
assertThat(context).hasSingleBean(DataSource.class);
DataSource dataSource = context.getBean(DataSource.class);
assertThat(dataSource).isInstanceOf(DataSourceProxy.class);
assertThat(((DataSourceProxy) dataSource).connectionsRetrieved).hasPositiveValue();
assertDataSourceIsInitialized(dataSource);
});
}
@Test
// gh-13042
void whenDataSourceIsScopedAndJpaIsInvolvedThenInitializationCompletesSuccessfully() {
this.contextRunner.withPropertyValues("spring.datasource.initialization-mode:always")
.withConfiguration(AutoConfigurations.of(HibernateJpaAutoConfiguration.class))
.withUserConfiguration(ScopedDataSourceConfiguration.class).run((context) -> {
assertThat(context).hasSingleBean(DataSource.class);
DataSource dataSource = context.getBean(DataSource.class);
assertThat(dataSource).isInstanceOf(HikariDataSource.class);
assertDataSourceIsInitialized(dataSource);
});
}
private String getRelativeLocationFor(String resource) {
return ClassUtils.addResourcePathToPackagePath(getClass(), resource);
}
@Configuration(proxyBeanMethods = false)
static class OneDataSource {
@Bean
DataSource oneDataSource() {
return new TestDataSource(true);
}
}
@Configuration(proxyBeanMethods = false)
static class TwoDataSources extends OneDataSource {
@Bean
DataSource twoDataSource() {
return new TestDataSource(true);
}
}
/**
* {@link ResourcePatternResolver} used to ensure consistently wrong resource
* ordering.
*/
static class ReverseOrderResourceLoader implements ResourcePatternResolver {
private final ResourcePatternResolver resolver;
ReverseOrderResourceLoader(ResourceLoader loader) {
this.resolver = ResourcePatternUtils.getResourcePatternResolver(loader);
}
@Override
public Resource getResource(String location) {
return this.resolver.getResource(location);
}
@Override
public ClassLoader getClassLoader() {
return this.resolver.getClassLoader();
}
@Override
public Resource[] getResources(String locationPattern) throws IOException {
Resource[] resources = this.resolver.getResources(locationPattern);
Arrays.sort(resources, Comparator.comparing(Resource::getFilename).reversed());
return resources;
}
}
@Configuration(proxyBeanMethods = true)
static class DataSourceProxyConfiguration {
@Bean
static BeanPostProcessor dataSourceProxy() {
return new BeanPostProcessor() {
@Override
public Object postProcessAfterInitialization(Object bean, String beanName) {
if (bean instanceof DataSource) {
return new DataSourceProxy((DataSource) bean);
}
return bean;
}
};
}
}
static class DataSourceProxy implements DataSource {
private final AtomicInteger connectionsRetrieved = new AtomicInteger();
private final DataSource delegate;
DataSourceProxy(DataSource delegate) {
this.delegate = delegate;
}
@Override
public PrintWriter getLogWriter() throws SQLException {
return this.delegate.getLogWriter();
}
@Override
public void setLogWriter(PrintWriter out) throws SQLException {
this.delegate.setLogWriter(out);
}
@Override
public boolean isWrapperFor(Class<?> iface) throws SQLException {
return this.delegate.isWrapperFor(iface);
}
@Override
public <T> T unwrap(Class<T> iface) throws SQLException {
return this.delegate.unwrap(iface);
}
@Override
public Connection getConnection() throws SQLException {
this.connectionsRetrieved.incrementAndGet();
return this.delegate.getConnection();
}
@Override
public Connection getConnection(String username, String password) throws SQLException {
this.connectionsRetrieved.incrementAndGet();
return this.delegate.getConnection(username, password);
}
@Override
public int getLoginTimeout() throws SQLException {
return this.delegate.getLoginTimeout();
}
@Override
public void setLoginTimeout(int seconds) throws SQLException {
this.delegate.setLoginTimeout(seconds);
}
@Override
public Logger getParentLogger() throws SQLFeatureNotSupportedException {
return this.delegate.getParentLogger();
}
}
@Configuration(proxyBeanMethods = false)
static class ScopedDataSourceConfiguration {
@Bean
static BeanFactoryPostProcessor fooScope() {
return (beanFactory) -> beanFactory.registerScope("test", new SimpleThreadScope());
}
@Bean
@Scope("test")
HikariDataSource dataSource(DataSourceProperties properties) {
return properties.initializeDataSourceBuilder().type(HikariDataSource.class).build();
}
}
}

20
spring-boot-project/spring-boot-autoconfigure/src/test/java/org/springframework/boot/autoconfigure/jdbc/DataSourcePropertiesTests.java
View File

@@ -178,24 +178,4 @@ class DataSourcePropertiesTests {
assertThat(properties.determinePassword()).isNull();
}
@Test
@Deprecated
void determineCredentialsForSchemaScripts() {
DataSourceProperties properties = new DataSourceProperties();
properties.setSchemaUsername("foo");
properties.setSchemaPassword("bar");
assertThat(properties.getSchemaUsername()).isEqualTo("foo");
assertThat(properties.getSchemaPassword()).isEqualTo("bar");
}
@Test
@Deprecated
void determineCredentialsForDataScripts() {
DataSourceProperties properties = new DataSourceProperties();
properties.setDataUsername("foo");
properties.setDataPassword("bar");
assertThat(properties.getDataUsername()).isEqualTo("foo");
assertThat(properties.getDataPassword()).isEqualTo("bar");
}
}

10
spring-boot-project/spring-boot-autoconfigure/src/test/java/org/springframework/boot/autoconfigure/jdbc/JdbcTemplateAutoConfigurationTests.java
View File

@@ -145,16 +145,6 @@ class JdbcTemplateAutoConfigurationTests {
});
}
@Test
@Deprecated
void testDependencyToDeprecatedDataSourceInitialization() {
this.contextRunner.withUserConfiguration(DataSourceInitializationValidator.class)
.withPropertyValues("spring.datasource.initialization-mode=always").run((context) -> {
assertThat(context).hasNotFailed();
assertThat(context.getBean(DataSourceInitializationValidator.class).count).isEqualTo(1);
});
}
@Test
void testDependencyToScriptBasedDataSourceInitialization() {
this.contextRunner.withConfiguration(AutoConfigurations.of(SqlInitializationAutoConfiguration.class))

11
spring-boot-project/spring-boot-autoconfigure/src/test/java/org/springframework/boot/autoconfigure/orm/jpa/CustomHibernateJpaAutoConfigurationTests.java
View File

@@ -96,12 +96,11 @@ class CustomHibernateJpaAutoConfigurationTests {
@Test
void defaultDatabaseIsSet() {
this.contextRunner.withPropertyValues("spring.datasource.url:jdbc:h2:mem:testdb",
"spring.datasource.initialization-mode:never").run((context) -> {
HibernateJpaVendorAdapter bean = context.getBean(HibernateJpaVendorAdapter.class);
Database database = (Database) ReflectionTestUtils.getField(bean, "database");
assertThat(database).isEqualTo(Database.DEFAULT);
});
this.contextRunner.withPropertyValues("spring.datasource.url:jdbc:h2:mem:testdb").run((context) -> {
HibernateJpaVendorAdapter bean = context.getBean(HibernateJpaVendorAdapter.class);
Database database = (Database) ReflectionTestUtils.getField(bean, "database");
assertThat(database).isEqualTo(Database.DEFAULT);
});
}
@Configuration(proxyBeanMethods = false)

6
spring-boot-project/spring-boot-autoconfigure/src/test/java/org/springframework/boot/autoconfigure/orm/jpa/HibernateDefaultDdlAutoProviderTests.java
View File

@@ -39,10 +39,8 @@ import static org.mockito.Mockito.mock;
*/
class HibernateDefaultDdlAutoProviderTests {
private final ApplicationContextRunner contextRunner = new ApplicationContextRunner()
.withConfiguration(
AutoConfigurations.of(DataSourceAutoConfiguration.class, HibernateJpaAutoConfiguration.class))
.withPropertyValues("spring.datasource.initialization-mode:never");
private final ApplicationContextRunner contextRunner = new ApplicationContextRunner().withConfiguration(
AutoConfigurations.of(DataSourceAutoConfiguration.class, HibernateJpaAutoConfiguration.class));
@Test
void defaultDDlAutoForEmbedded() {

31
spring-boot-project/spring-boot-autoconfigure/src/test/java/org/springframework/boot/autoconfigure/orm/jpa/HibernateJpaAutoConfigurationTests.java
View File

@@ -97,17 +97,6 @@ class HibernateJpaAutoConfigurationTests extends AbstractJpaAutoConfigurationTes
super(HibernateJpaAutoConfiguration.class);
}
@Test
@Deprecated
void testDataScriptWithDeprecatedMissingDdl() {
contextRunner().withPropertyValues("spring.datasource.data:classpath:/city.sql",
// Missing:
"spring.datasource.schema:classpath:/ddl.sql").run((context) -> {
assertThat(context).hasFailed();
assertThat(context.getStartupFailure()).hasMessageContaining("ddl.sql");
});
}
@Test
void testDmlScriptWithMissingDdl() {
contextRunner().withPropertyValues("spring.sql.init.data-locations:classpath:/city.sql",
@@ -118,16 +107,6 @@ class HibernateJpaAutoConfigurationTests extends AbstractJpaAutoConfigurationTes
});
}
@Test
void testDataScript() {
// This can't succeed because the data SQL is executed immediately after the
// schema and Hibernate hasn't initialized yet at that point
contextRunner().withPropertyValues("spring.datasource.data:classpath:/city.sql").run((context) -> {
assertThat(context).hasFailed();
assertThat(context.getStartupFailure()).isInstanceOf(BeanCreationException.class);
});
}
@Test
void testDmlScript() {
// This can't succeed because the data SQL is executed immediately after the
@@ -138,16 +117,6 @@ class HibernateJpaAutoConfigurationTests extends AbstractJpaAutoConfigurationTes
});
}
@Test
@Deprecated
void testDataScriptRunsEarly() {
contextRunner().withUserConfiguration(TestInitializedJpaConfiguration.class)
.withClassLoader(new HideDataScriptClassLoader())
.withPropertyValues("spring.jpa.show-sql=true", "spring.jpa.hibernate.ddl-auto:create-drop",
"spring.datasource.data:classpath:/city.sql", "spring.jpa.defer-datasource-initialization=true")
.run((context) -> assertThat(context.getBean(TestInitializedJpaConfiguration.class).called).isTrue());
}
@Test
void testDmlScriptRunsEarly() {
contextRunner().withUserConfiguration(TestInitializedJpaConfiguration.class)

26
spring-boot-project/spring-boot-autoconfigure/src/test/java/org/springframework/boot/autoconfigure/sql/init/SqlInitializationAutoConfigurationTests.java
View File

@@ -67,14 +67,6 @@ class SqlInitializationAutoConfigurationTests {
.run((context) -> assertThat(context).hasSingleBean(R2dbcScriptDatabaseInitializer.class));
}
@Test
@Deprecated
void whenConnectionFactoryIsAvailableAndInitializationIsDisabledThenInitializerIsNotAutoConfigured() {
this.contextRunner.withConfiguration(AutoConfigurations.of(R2dbcAutoConfiguration.class))
.withPropertyValues("spring.sql.init.enabled:false")
.run((context) -> assertThat(context).doesNotHaveBean(AbstractScriptDatabaseInitializer.class));
}
@Test
void whenConnectionFactoryIsAvailableAndModeIsNeverThenInitializerIsNotAutoConfigured() {
this.contextRunner.withConfiguration(AutoConfigurations.of(R2dbcAutoConfiguration.class))
@@ -89,14 +81,6 @@ class SqlInitializationAutoConfigurationTests {
.run((context) -> assertThat(context).hasSingleBean(DataSourceScriptDatabaseInitializer.class));
}
@Test
@Deprecated
void whenDataSourceIsAvailableAndInitializationIsDisabledThenInitializerIsNotAutoConfigured() {
this.contextRunner.withConfiguration(AutoConfigurations.of(DataSourceAutoConfiguration.class))
.withPropertyValues("spring.sql.init.enabled:false")
.run((context) -> assertThat(context).doesNotHaveBean(AbstractScriptDatabaseInitializer.class));
}
@Test
void whenDataSourceIsAvailableAndModeIsNeverThenThenInitializerIsNotAutoConfigured() {
this.contextRunner.withConfiguration(AutoConfigurations.of(DataSourceAutoConfiguration.class))
@@ -170,16 +154,6 @@ class SqlInitializationAutoConfigurationTests {
});
}
@Test
void whenDataSourceAutoConfigurationHasDefinedAnInitializerThenAutoConfigurationBacksOff() {
this.contextRunner.withConfiguration(AutoConfigurations.of(DataSourceAutoConfiguration.class))
.withPropertyValues("spring.datasource.schema=classpath:schema.sql")
.withInitializer(new ConditionEvaluationReportLoggingListener(LogLevel.INFO)).run((context) -> {
assertThat(context).hasSingleBean(SqlDataSourceScriptDatabaseInitializer.class);
assertThat(context).hasBean("scriptDataSourceInitializer");
});
}
@Configuration(proxyBeanMethods = false)
static class SqlDatabaseInitializerConfiguration {