This commit adds spring.datasource.lazy-connection property into

a DataSourceProperties class to enable a LazyConnectionDataSourceBeanPostProcessor.
BeanPostProcessor wraps an auto-configured DataSource in a LazyConnectionDataSourceProxy.
It will be added only if a spring.datasource.lazy-connection property has true
and a LazyConnectionDataSourceProxy class is present.
The default value of the spring.datasource.lazy-connection property is false,
which means a lazy-connection feature is disabled by default.

closes gh-15480

Author: nosan

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

@@ -1,5 +1,5 @@
 /*
- * Copyright 2012-2018 the original author or authors.
+ * Copyright 2012-2019 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.
@@ -57,7 +57,8 @@ public class DataSourceAutoConfiguration {
 	@Configuration
 	@Conditional(EmbeddedDatabaseCondition.class)
 	@ConditionalOnMissingBean({ DataSource.class, XADataSource.class })
-	@Import(EmbeddedDataSourceConfiguration.class)
+	@Import({ EmbeddedDataSourceConfiguration.class,
+			LazyConnectionDataSourceConfiguration.class })
 	protected static class EmbeddedDatabaseConfiguration {
 
 	}
@@ -67,7 +68,8 @@ protected static class EmbeddedDatabaseConfiguration {
 	@ConditionalOnMissingBean({ DataSource.class, XADataSource.class })
 	@Import({ DataSourceConfiguration.Hikari.class, DataSourceConfiguration.Tomcat.class,
 			DataSourceConfiguration.Dbcp2.class, DataSourceConfiguration.Generic.class,
-			DataSourceJmxConfiguration.class })
+			DataSourceJmxConfiguration.class,
+			LazyConnectionDataSourceConfiguration.class })
 	protected static class PooledDataSourceConfiguration {
 
 	}

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

@@ -1,5 +1,5 @@
 /*
- * Copyright 2012-2018 the original author or authors.
+ * Copyright 2012-2019 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.
@@ -149,6 +149,11 @@ public class DataSourceProperties implements BeanClassLoaderAware, InitializingB
 	 */
 	private Charset sqlScriptEncoding;
 
+	/**
+	 * Whether datasource must be wrapped in a LazyConnectionDataSourceProxy.
+	 */
+	private boolean lazyConnection = false;
+
 	private EmbeddedDatabaseConnection embeddedDatabaseConnection = EmbeddedDatabaseConnection.NONE;
 
 	private Xa xa = new Xa();
@@ -478,6 +483,14 @@ public void setXa(Xa xa) {
 		this.xa = xa;
 	}
 
+	public boolean getLazyConnection() {
+		return this.lazyConnection;
+	}
+
+	public void setLazyConnection(boolean lazyConnection) {
+		this.lazyConnection = lazyConnection;
+	}
+
 	/**
 	 * XA Specific datasource settings.
 	 */

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

@@ -0,0 +1,42 @@
+/*
+ * Copyright 2012-2019 the original author or authors.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package org.springframework.boot.autoconfigure.jdbc;
+
+import javax.sql.DataSource;
+
+import org.springframework.beans.BeansException;
+import org.springframework.beans.factory.config.BeanPostProcessor;
+import org.springframework.jdbc.datasource.LazyConnectionDataSourceProxy;
+
+/**
+ * {@link BeanPostProcessor} to wrap a {@link DataSource} with a
+ * {@link LazyConnectionDataSourceProxy}.
+ *
+ * @author Dmytro Nosan
+ */
+class LazyConnectionDataSourceBeanPostProcessor implements BeanPostProcessor {
+
+	@Override
+	public Object postProcessAfterInitialization(Object bean, String beanName)
+			throws BeansException {
+		if (bean instanceof DataSource) {
+			return new LazyConnectionDataSourceProxy((DataSource) bean);
+		}
+		return bean;
+	}
+
+}

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

@@ -0,0 +1,40 @@
+/*
+ * Copyright 2012-2019 the original author or authors.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+package org.springframework.boot.autoconfigure.jdbc;
+
+import org.springframework.boot.autoconfigure.condition.ConditionalOnClass;
+import org.springframework.boot.autoconfigure.condition.ConditionalOnProperty;
+import org.springframework.context.annotation.Bean;
+import org.springframework.context.annotation.Configuration;
+import org.springframework.jdbc.datasource.LazyConnectionDataSourceProxy;
+
+/**
+ * Configuration to register {@link LazyConnectionDataSourceBeanPostProcessor}, if
+ * a {@code spring.datasource.lazy-connection} property is present and value is {@code true}.
+ *
+ * @author Dmytro Nosan
+ */
+@Configuration
+@ConditionalOnClass(LazyConnectionDataSourceProxy.class)
+@ConditionalOnProperty(prefix = "spring.datasource", name = "lazy-connection", havingValue = "true")
+class LazyConnectionDataSourceConfiguration {
+
+	@Bean
+	public static LazyConnectionDataSourceBeanPostProcessor lazyConnectionDataSourceBeanPostProcessor() {
+		return new LazyConnectionDataSourceBeanPostProcessor();
+	}
+
+}

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

@@ -1,5 +1,5 @@
 /*
- * Copyright 2012-2018 the original author or authors.
+ * Copyright 2012-2019 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.
@@ -39,6 +39,7 @@
 import org.springframework.boot.jdbc.XADataSourceWrapper;
 import org.springframework.context.annotation.Bean;
 import org.springframework.context.annotation.Configuration;
+import org.springframework.context.annotation.Import;
 import org.springframework.jdbc.datasource.embedded.EmbeddedDatabaseType;
 import org.springframework.util.Assert;
 import org.springframework.util.ClassUtils;
@@ -59,6 +60,7 @@
 		EmbeddedDatabaseType.class })
 @ConditionalOnBean(XADataSourceWrapper.class)
 @ConditionalOnMissingBean(DataSource.class)
+@Import(LazyConnectionDataSourceConfiguration.class)
 public class XADataSourceAutoConfiguration implements BeanClassLoaderAware {
 
 	private final XADataSourceWrapper wrapper;

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

@@ -1,5 +1,5 @@
 /*
- * Copyright 2012-2018 the original author or authors.
+ * Copyright 2012-2019 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.
@@ -38,6 +38,7 @@
 import org.springframework.beans.factory.BeanCreationException;
 import org.springframework.beans.factory.annotation.Autowired;
 import org.springframework.boot.autoconfigure.AutoConfigurations;
+import org.springframework.boot.jdbc.DataSourceUnwrapper;
 import org.springframework.boot.jdbc.DatabaseDriver;
 import org.springframework.boot.jdbc.EmbeddedDatabaseConnection;
 import org.springframework.boot.test.context.FilteredClassLoader;
@@ -46,7 +47,9 @@
 import org.springframework.context.annotation.Bean;
 import org.springframework.context.annotation.Configuration;
 import org.springframework.jdbc.core.JdbcTemplate;
+import org.springframework.jdbc.datasource.LazyConnectionDataSourceProxy;
 import org.springframework.jdbc.datasource.SimpleDriverDataSource;
+import org.springframework.jdbc.datasource.embedded.EmbeddedDatabase;
 import org.springframework.util.StringUtils;
 
 import static org.assertj.core.api.Assertions.assertThat;
@@ -104,8 +107,8 @@ public void testBadDriverClass() {
 	public void hikariValidatesConnectionByDefault() {
 		assertDataSource(HikariDataSource.class,
 				Collections.singletonList("org.apache.tomcat"), (dataSource) ->
-				// Use Connection#isValid()
-				assertThat(dataSource.getConnectionTestQuery()).isNull());
+						// Use Connection#isValid()
+						assertThat(dataSource.getConnectionTestQuery()).isNull());
 	}
 
 	@Test
@@ -140,7 +143,7 @@ public void commonsDbcp2ValidatesConnectionByDefault() {
 				Arrays.asList("com.zaxxer.hikari", "org.apache.tomcat"), (dataSource) -> {
 					assertThat(dataSource.getTestOnBorrow()).isTrue();
 					assertThat(dataSource.getValidationQuery()).isNull(); // Use
-																			// Connection#isValid()
+					// Connection#isValid()
 				});
 	}
 
@@ -150,12 +153,12 @@ public void testEmbeddedTypeDefaultsUsername() {
 		this.contextRunner.withPropertyValues(
 				"spring.datasource.driverClassName:org.hsqldb.jdbcDriver",
 				"spring.datasource.url:jdbc:hsqldb:mem:testdb").run((context) -> {
-					DataSource bean = context.getBean(DataSource.class);
-					HikariDataSource pool = (HikariDataSource) bean;
-					assertThat(pool.getDriverClassName())
-							.isEqualTo("org.hsqldb.jdbcDriver");
-					assertThat(pool.getUsername()).isEqualTo("sa");
-				});
+			DataSource bean = context.getBean(DataSource.class);
+			HikariDataSource pool = (HikariDataSource) bean;
+			assertThat(pool.getDriverClassName())
+					.isEqualTo("org.hsqldb.jdbcDriver");
+			assertThat(pool.getUsername()).isEqualTo("sa");
+		});
 	}
 
 	/**
@@ -199,12 +202,12 @@ public void testExplicitDriverClassClearsUsername() {
 		this.contextRunner.withPropertyValues(
 				"spring.datasource.driverClassName:" + DatabaseTestDriver.class.getName(),
 				"spring.datasource.url:jdbc:foo://localhost").run((context) -> {
-					assertThat(context).hasSingleBean(DataSource.class);
-					HikariDataSource dataSource = context.getBean(HikariDataSource.class);
-					assertThat(dataSource.getDriverClassName())
-							.isEqualTo(DatabaseTestDriver.class.getName());
-					assertThat(dataSource.getUsername()).isNull();
-				});
+			assertThat(context).hasSingleBean(DataSource.class);
+			HikariDataSource dataSource = context.getBean(HikariDataSource.class);
+			assertThat(dataSource.getDriverClassName())
+					.isEqualTo(DatabaseTestDriver.class.getName());
+			assertThat(dataSource.getUsername()).isNull();
+		});
 	}
 
 	@Test
@@ -221,7 +224,65 @@ public void testDataSourceIsInitializedEarly() {
 				.withPropertyValues("spring.datasource.initialization-mode=always")
 				.run((context) -> assertThat(context
 						.getBean(TestInitializedDataSourceConfiguration.class).called)
-								.isTrue());
+						.isTrue());
+	}
+
+	@Test
+	public void ignoreLazyConnectionOverriddenDataSource() {
+		this.contextRunner.withPropertyValues("spring.datasource.lazy-connection=true")
+				.withUserConfiguration(TestDataSourceConfiguration.class)
+				.run((context) -> assertThat(context).getBean(DataSource.class)
+						.isInstanceOf(BasicDataSource.class));
+	}
+
+	@Test
+	public void lazyConnectionEmbeddedDataSource() {
+		assertLazyDataSource(EmbeddedDatabase.class,
+				Arrays.asList("com.zaxxer.hikari", "org.apache.tomcat",
+						"org.apache.commons.dbcp2"),
+				(dataSource) -> assertThat(DataSourceUnwrapper.unwrap(dataSource,
+						SimpleDriverDataSource.class)).isNotNull()
+						.extracting(SimpleDriverDataSource::getUrl).asString()
+						.startsWith("jdbc:h2:mem:testdb"));
+	}
+
+	@Test
+	public void lazyConnectionDefaultDataSource() {
+		assertLazyDataSource(HikariDataSource.class, Collections.emptyList(),
+				(dataSource) -> assertThat(dataSource.getJdbcUrl())
+						.startsWith("jdbc:hsqldb:mem:testdb"));
+	}
+
+	@Test
+	public void lazyConnectionTomcatIsFallback() {
+		assertLazyDataSource(org.apache.tomcat.jdbc.pool.DataSource.class,
+				Collections.singletonList("com.zaxxer.hikari"),
+				(dataSource) -> assertThat(dataSource.getUrl())
+						.startsWith("jdbc:hsqldb:mem:testdb"));
+	}
+
+	@Test
+	public void lazyConnectionCommonsDbcp2IsFallback() {
+		assertLazyDataSource(BasicDataSource.class,
+				Arrays.asList("com.zaxxer.hikari", "org.apache.tomcat"),
+				(dataSource) -> assertThat(dataSource.getUrl())
+						.startsWith("jdbc:hsqldb:mem:testdb"));
+	}
+
+	private <T extends DataSource> void assertLazyDataSource(Class<T> expectedType,
+			List<String> hiddenPackages, Consumer<T> consumer) {
+		FilteredClassLoader classLoader = new FilteredClassLoader(
+				StringUtils.toStringArray(hiddenPackages));
+		this.contextRunner.withPropertyValues("spring.datasource.lazy-connection=true")
+				.withClassLoader(classLoader).run((context) -> {
+			DataSource dataSource = context.getBean(DataSource.class);
+			assertThat(dataSource)
+					.isInstanceOf(LazyConnectionDataSourceProxy.class);
+			DataSource targetDataSource = ((LazyConnectionDataSourceProxy) dataSource)
+					.getTargetDataSource();
+			assertThat(targetDataSource).isInstanceOf(expectedType);
+			consumer.accept(expectedType.cast(targetDataSource));
+		});
 	}
 
 	private <T extends DataSource> void assertDataSource(Class<T> expectedType,

spring-boot-project/spring-boot-autoconfigure/src/test/java/org/springframework/boot/autoconfigure/jdbc/XADataSourceAutoConfigurationTests.java

@@ -1,5 +1,5 @@
 /*
- * Copyright 2012-2018 the original author or authors.
+ * Copyright 2012-2019 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.
@@ -16,6 +16,8 @@
 
 package org.springframework.boot.autoconfigure.jdbc;
 
+import java.sql.Connection;
+
 import javax.sql.DataSource;
 import javax.sql.XADataSource;
 
@@ -28,8 +30,10 @@
 import org.springframework.context.annotation.AnnotationConfigApplicationContext;
 import org.springframework.context.annotation.Bean;
 import org.springframework.context.annotation.Configuration;
+import org.springframework.jdbc.datasource.LazyConnectionDataSourceProxy;
 
 import static org.assertj.core.api.Assertions.assertThat;
+import static org.mockito.Mockito.doReturn;
 import static org.mockito.Mockito.mock;
 
 /**
@@ -39,6 +43,17 @@
  */
 public class XADataSourceAutoConfigurationTests {
 
+	@Test
+	public void lazyXaDataSource() {
+		ApplicationContext context = createContext(WrapExisting.class,
+				"spring.datasource.lazy-connection=true");
+		assertThat(context.getBean(DataSource.class))
+				.isInstanceOf(LazyConnectionDataSourceProxy.class);
+		XADataSource source = context.getBean(XADataSource.class);
+		MockXADataSourceWrapper wrapper = context.getBean(MockXADataSourceWrapper.class);
+		assertThat(wrapper.getXaDataSource()).isEqualTo(source);
+	}
+
 	@Test
 	public void wrapExistingXaDataSource() {
 		ApplicationContext context = createContext(WrapExisting.class);
@@ -111,9 +126,11 @@ private static class MockXADataSourceWrapper implements XADataSourceWrapper {
 		private XADataSource dataSource;
 
 		@Override
-		public DataSource wrapDataSource(XADataSource dataSource) {
+		public DataSource wrapDataSource(XADataSource dataSource) throws Exception {
 			this.dataSource = dataSource;
-			return mock(DataSource.class);
+			DataSource mockDataSource = mock(DataSource.class);
+			doReturn(mock(Connection.class)).when(mockDataSource).getConnection();
+			return mockDataSource;
 		}
 
 		public XADataSource getXaDataSource() {