From ee73990a52f8b25d755f0ca4e8510e1760aa0955 Mon Sep 17 00:00:00 2001 From: Kazuki Shimizu Date: Mon, 25 Jul 2016 04:37:18 +0900 Subject: [PATCH] Support @ConditionalOnSingleCandidate on auto configuration of JdbcTemplate and DataSourceTransactionManager #6448 --- .../jdbc/DataSourceAutoConfiguration.java | 28 +-- ...ceTransactionManagerAutoConfiguration.java | 5 +- .../jdbc/JdbcTemplateAutoConfiguration.java | 66 ++++++ .../main/resources/META-INF/spring.factories | 1 + .../DataSourceAutoConfigurationTests.java | 31 --- .../jdbc/DataSourceInitializerTests.java | 6 +- ...nsactionManagerAutoConfigurationTests.java | 72 ++++++ .../JdbcTemplateAutoConfigurationTests.java | 209 ++++++++++++++++++ 8 files changed, 355 insertions(+), 63 deletions(-) create mode 100644 spring-boot-autoconfigure/src/main/java/org/springframework/boot/autoconfigure/jdbc/JdbcTemplateAutoConfiguration.java create mode 100644 spring-boot-autoconfigure/src/test/java/org/springframework/boot/autoconfigure/jdbc/JdbcTemplateAutoConfigurationTests.java diff --git a/spring-boot-autoconfigure/src/main/java/org/springframework/boot/autoconfigure/jdbc/DataSourceAutoConfiguration.java b/spring-boot-autoconfigure/src/main/java/org/springframework/boot/autoconfigure/jdbc/DataSourceAutoConfiguration.java index d909a62bb6ac..29e00b7ef372 100644 --- a/spring-boot-autoconfigure/src/main/java/org/springframework/boot/autoconfigure/jdbc/DataSourceAutoConfiguration.java +++ b/spring-boot-autoconfigure/src/main/java/org/springframework/boot/autoconfigure/jdbc/DataSourceAutoConfiguration.java @@ -47,10 +47,6 @@ import org.springframework.core.Ordered; import org.springframework.core.annotation.Order; import org.springframework.core.type.AnnotatedTypeMetadata; -import org.springframework.jdbc.core.JdbcOperations; -import org.springframework.jdbc.core.JdbcTemplate; -import org.springframework.jdbc.core.namedparam.NamedParameterJdbcOperations; -import org.springframework.jdbc.core.namedparam.NamedParameterJdbcTemplate; import org.springframework.jdbc.datasource.embedded.EmbeddedDatabaseType; /** @@ -59,6 +55,7 @@ * @author Dave Syer * @author Phillip Webb * @author Stephane Nicoll + * @author Kazuki Shimizu */ @Configuration @ConditionalOnClass({ DataSource.class, EmbeddedDatabaseType.class }) @@ -108,29 +105,6 @@ protected static class PooledDataSourceConfiguration { } - @Configuration - @Conditional(DataSourceAutoConfiguration.DataSourceAvailableCondition.class) - protected static class JdbcTemplateConfiguration { - - private final DataSource dataSource; - - public JdbcTemplateConfiguration(DataSource dataSource) { - this.dataSource = dataSource; - } - - @Bean - @ConditionalOnMissingBean(JdbcOperations.class) - public JdbcTemplate jdbcTemplate() { - return new JdbcTemplate(this.dataSource); - } - - @Bean - @ConditionalOnMissingBean(NamedParameterJdbcOperations.class) - public NamedParameterJdbcTemplate namedParameterJdbcTemplate() { - return new NamedParameterJdbcTemplate(this.dataSource); - } - } - @Configuration @ConditionalOnProperty(prefix = "spring.datasource", name = "jmx-enabled") @ConditionalOnClass(name = "org.apache.tomcat.jdbc.pool.DataSourceProxy") diff --git a/spring-boot-autoconfigure/src/main/java/org/springframework/boot/autoconfigure/jdbc/DataSourceTransactionManagerAutoConfiguration.java b/spring-boot-autoconfigure/src/main/java/org/springframework/boot/autoconfigure/jdbc/DataSourceTransactionManagerAutoConfiguration.java index bec6eef8e4a1..86497fbdf307 100644 --- a/spring-boot-autoconfigure/src/main/java/org/springframework/boot/autoconfigure/jdbc/DataSourceTransactionManagerAutoConfiguration.java +++ b/spring-boot-autoconfigure/src/main/java/org/springframework/boot/autoconfigure/jdbc/DataSourceTransactionManagerAutoConfiguration.java @@ -20,9 +20,9 @@ import org.springframework.boot.autoconfigure.AutoConfigureOrder; import org.springframework.boot.autoconfigure.EnableAutoConfiguration; -import org.springframework.boot.autoconfigure.condition.ConditionalOnBean; import org.springframework.boot.autoconfigure.condition.ConditionalOnClass; import org.springframework.boot.autoconfigure.condition.ConditionalOnMissingBean; +import org.springframework.boot.autoconfigure.condition.ConditionalOnSingleCandidate; import org.springframework.context.annotation.Bean; import org.springframework.context.annotation.Configuration; import org.springframework.core.Ordered; @@ -39,6 +39,7 @@ * @author Dave Syer * @author Stephane Nicoll * @author Andy Wilkinson + * @author Kazuki Shimizu */ @Configuration @ConditionalOnClass({ JdbcTemplate.class, PlatformTransactionManager.class }) @@ -46,7 +47,7 @@ public class DataSourceTransactionManagerAutoConfiguration { @Configuration - @ConditionalOnBean(DataSource.class) + @ConditionalOnSingleCandidate(DataSource.class) static class DataSourceTransactionManagerConfiguration { private final DataSource dataSource; diff --git a/spring-boot-autoconfigure/src/main/java/org/springframework/boot/autoconfigure/jdbc/JdbcTemplateAutoConfiguration.java b/spring-boot-autoconfigure/src/main/java/org/springframework/boot/autoconfigure/jdbc/JdbcTemplateAutoConfiguration.java new file mode 100644 index 000000000000..d70277847d11 --- /dev/null +++ b/spring-boot-autoconfigure/src/main/java/org/springframework/boot/autoconfigure/jdbc/JdbcTemplateAutoConfiguration.java @@ -0,0 +1,66 @@ +/* + * Copyright 2012-2016 the original author or authors. + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +package org.springframework.boot.autoconfigure.jdbc; + +import javax.sql.DataSource; + +import org.springframework.boot.autoconfigure.AutoConfigureAfter; +import org.springframework.boot.autoconfigure.EnableAutoConfiguration; +import org.springframework.boot.autoconfigure.condition.ConditionalOnClass; +import org.springframework.boot.autoconfigure.condition.ConditionalOnMissingBean; +import org.springframework.boot.autoconfigure.condition.ConditionalOnSingleCandidate; +import org.springframework.context.annotation.Bean; +import org.springframework.context.annotation.Configuration; +import org.springframework.jdbc.core.JdbcOperations; +import org.springframework.jdbc.core.JdbcTemplate; +import org.springframework.jdbc.core.namedparam.NamedParameterJdbcOperations; +import org.springframework.jdbc.core.namedparam.NamedParameterJdbcTemplate; + +/** + * {@link EnableAutoConfiguration Auto-configuration} for {@link JdbcTemplate} and {@link NamedParameterJdbcTemplate}. + * + * @author Dave Syer + * @author Phillip Webb + * @author Stephane Nicoll + * @author Kazuki Shimizu + * @since 1.4.0 + */ +@Configuration +@ConditionalOnClass(DataSource.class) +@ConditionalOnSingleCandidate(DataSource.class) +@AutoConfigureAfter(DataSourceAutoConfiguration.class) +public class JdbcTemplateAutoConfiguration { + + private final DataSource dataSource; + + JdbcTemplateAutoConfiguration(DataSource dataSource) { + this.dataSource = dataSource; + } + + @Bean + @ConditionalOnMissingBean(JdbcOperations.class) + public JdbcTemplate jdbcTemplate() { + return new JdbcTemplate(this.dataSource); + } + + @Bean + @ConditionalOnMissingBean(NamedParameterJdbcOperations.class) + public NamedParameterJdbcTemplate namedParameterJdbcTemplate() { + return new NamedParameterJdbcTemplate(this.dataSource); + } + +} diff --git a/spring-boot-autoconfigure/src/main/resources/META-INF/spring.factories b/spring-boot-autoconfigure/src/main/resources/META-INF/spring.factories index 5bf76dac0f24..729d7e824ace 100644 --- a/spring-boot-autoconfigure/src/main/resources/META-INF/spring.factories +++ b/spring-boot-autoconfigure/src/main/resources/META-INF/spring.factories @@ -51,6 +51,7 @@ org.springframework.boot.autoconfigure.jackson.JacksonAutoConfiguration,\ org.springframework.boot.autoconfigure.jdbc.DataSourceAutoConfiguration,\ org.springframework.boot.autoconfigure.jdbc.JndiDataSourceAutoConfiguration,\ org.springframework.boot.autoconfigure.jdbc.XADataSourceAutoConfiguration,\ +org.springframework.boot.autoconfigure.jdbc.JdbcTemplateAutoConfiguration,\ org.springframework.boot.autoconfigure.jdbc.DataSourceTransactionManagerAutoConfiguration,\ org.springframework.boot.autoconfigure.jms.JmsAutoConfiguration,\ org.springframework.boot.autoconfigure.jmx.JmxAutoConfiguration,\ diff --git a/spring-boot-autoconfigure/src/test/java/org/springframework/boot/autoconfigure/jdbc/DataSourceAutoConfigurationTests.java b/spring-boot-autoconfigure/src/test/java/org/springframework/boot/autoconfigure/jdbc/DataSourceAutoConfigurationTests.java index 3f398fded679..915da4743f0a 100644 --- a/spring-boot-autoconfigure/src/test/java/org/springframework/boot/autoconfigure/jdbc/DataSourceAutoConfigurationTests.java +++ b/spring-boot-autoconfigure/src/test/java/org/springframework/boot/autoconfigure/jdbc/DataSourceAutoConfigurationTests.java @@ -42,8 +42,6 @@ import org.springframework.context.annotation.AnnotationConfigApplicationContext; import org.springframework.context.annotation.Bean; import org.springframework.context.annotation.Configuration; -import org.springframework.jdbc.core.JdbcTemplate; -import org.springframework.jdbc.core.namedparam.NamedParameterJdbcOperations; import static org.assertj.core.api.Assertions.assertThat; import static org.mockito.Mockito.mock; @@ -228,35 +226,6 @@ public void testDefaultDataSourceCanBeOverridden() throws Exception { assertThat(dataSource).isInstanceOf(BasicDataSource.class); } - @Test - public void testJdbcTemplateExists() throws Exception { - this.context.register(DataSourceAutoConfiguration.class, - PropertyPlaceholderAutoConfiguration.class); - this.context.refresh(); - JdbcTemplate jdbcTemplate = this.context.getBean(JdbcTemplate.class); - assertThat(jdbcTemplate).isNotNull(); - assertThat(jdbcTemplate.getDataSource()).isNotNull(); - } - - @Test - public void testJdbcTemplateExistsWithCustomDataSource() throws Exception { - this.context.register(TestDataSourceConfiguration.class, - DataSourceAutoConfiguration.class, - PropertyPlaceholderAutoConfiguration.class); - this.context.refresh(); - JdbcTemplate jdbcTemplate = this.context.getBean(JdbcTemplate.class); - assertThat(jdbcTemplate).isNotNull(); - assertThat(jdbcTemplate.getDataSource() instanceof BasicDataSource).isTrue(); - } - - @Test - public void testNamedParameterJdbcTemplateExists() throws Exception { - this.context.register(DataSourceAutoConfiguration.class, - PropertyPlaceholderAutoConfiguration.class); - this.context.refresh(); - assertThat(this.context.getBean(NamedParameterJdbcOperations.class)).isNotNull(); - } - @SuppressWarnings("unchecked") private T autoConfigureDataSource(Class expectedType, final String... hiddenPackages) { diff --git a/spring-boot-autoconfigure/src/test/java/org/springframework/boot/autoconfigure/jdbc/DataSourceInitializerTests.java b/spring-boot-autoconfigure/src/test/java/org/springframework/boot/autoconfigure/jdbc/DataSourceInitializerTests.java index d8116efffe23..7d14b042f015 100644 --- a/spring-boot-autoconfigure/src/test/java/org/springframework/boot/autoconfigure/jdbc/DataSourceInitializerTests.java +++ b/spring-boot-autoconfigure/src/test/java/org/springframework/boot/autoconfigure/jdbc/DataSourceInitializerTests.java @@ -28,7 +28,7 @@ import org.junit.Before; import org.junit.Test; -import org.springframework.beans.factory.UnsatisfiedDependencyException; +import org.springframework.beans.factory.BeanCreationException; import org.springframework.boot.autoconfigure.PropertyPlaceholderAutoConfiguration; import org.springframework.boot.context.properties.ConfigurationProperties; import org.springframework.boot.context.properties.EnableConfigurationProperties; @@ -223,7 +223,7 @@ public void testDataSourceInitializedWithSchemaCredentials() { fail("User does not exist"); } catch (Exception ex) { - assertThat(ex).isInstanceOf(UnsatisfiedDependencyException.class); + assertThat(ex).isInstanceOf(BeanCreationException.class); } } @@ -245,7 +245,7 @@ public void testDataSourceInitializedWithDataCredentials() { fail("User does not exist"); } catch (Exception ex) { - assertThat(ex).isInstanceOf(UnsatisfiedDependencyException.class); + assertThat(ex).isInstanceOf(BeanCreationException.class); } } diff --git a/spring-boot-autoconfigure/src/test/java/org/springframework/boot/autoconfigure/jdbc/DataSourceTransactionManagerAutoConfigurationTests.java b/spring-boot-autoconfigure/src/test/java/org/springframework/boot/autoconfigure/jdbc/DataSourceTransactionManagerAutoConfigurationTests.java index cb62425febed..6b7875ee97a1 100644 --- a/spring-boot-autoconfigure/src/test/java/org/springframework/boot/autoconfigure/jdbc/DataSourceTransactionManagerAutoConfigurationTests.java +++ b/spring-boot-autoconfigure/src/test/java/org/springframework/boot/autoconfigure/jdbc/DataSourceTransactionManagerAutoConfigurationTests.java @@ -18,11 +18,13 @@ import javax.sql.DataSource; +import org.apache.commons.dbcp.BasicDataSource; import org.junit.Test; import org.springframework.context.annotation.AnnotationConfigApplicationContext; import org.springframework.context.annotation.Bean; import org.springframework.context.annotation.Configuration; +import org.springframework.context.annotation.Primary; import org.springframework.jdbc.datasource.DataSourceTransactionManager; import org.springframework.transaction.PlatformTransactionManager; import org.springframework.transaction.annotation.AbstractTransactionManagementConfiguration; @@ -36,6 +38,7 @@ * * @author Dave Syer * @author Stephane Nicoll + * @author Kazuki Shimizu */ public class DataSourceTransactionManagerAutoConfigurationTests { @@ -84,6 +87,27 @@ public void testExistingTransactionManager() { .isEqualTo(this.context.getBean("myTransactionManager")); } + @Test + public void testMultiDataSource() throws Exception { + this.context.register(TestMultiDataSourceConfiguration.class, + DataSourceTransactionManagerAutoConfiguration.class); + this.context.refresh(); + assertThat(this.context.getBeansOfType(PlatformTransactionManager.class)).isEmpty(); + assertThat(this.context.getBean(AbstractTransactionManagementConfiguration.class)) + .isNotNull(); + } + + @Test + public void testMultiDataSourceUsingPrimary() throws Exception { + this.context.register(TestMultiDataSourceUsingPrimaryConfiguration.class, + DataSourceTransactionManagerAutoConfiguration.class); + this.context.refresh(); + assertThat(this.context.getBean(DataSourceTransactionManager.class)).isNotNull(); + assertThat(this.context.getBean(AbstractTransactionManagementConfiguration.class)) + .isNotNull(); + } + + @EnableTransactionManagement protected static class SwitchTransactionsOn { @@ -99,4 +123,52 @@ public PlatformTransactionManager myTransactionManager() { } + + @Configuration + static class TestMultiDataSourceConfiguration { + + @Bean + public DataSource test1DataSource() { + BasicDataSource pool = new BasicDataSource(); + pool.setDriverClassName("org.hsqldb.jdbcDriver"); + pool.setUrl("jdbc:hsqldb:target/test1"); + pool.setUsername("sa"); + return pool; + } + + @Bean + public DataSource test2DataSource() { + BasicDataSource pool = new BasicDataSource(); + pool.setDriverClassName("org.hsqldb.jdbcDriver"); + pool.setUrl("jdbc:hsqldb:target/test2"); + pool.setUsername("sa"); + return pool; + } + + } + + @Configuration + static class TestMultiDataSourceUsingPrimaryConfiguration { + + @Bean + @Primary + public DataSource test1DataSource() { + BasicDataSource pool = new BasicDataSource(); + pool.setDriverClassName("org.hsqldb.jdbcDriver"); + pool.setUrl("jdbc:hsqldb:target/test1"); + pool.setUsername("sa"); + return pool; + } + + @Bean + public DataSource test2DataSource() { + BasicDataSource pool = new BasicDataSource(); + pool.setDriverClassName("org.hsqldb.jdbcDriver"); + pool.setUrl("jdbc:hsqldb:target/test2"); + pool.setUsername("sa"); + return pool; + } + + } + } diff --git a/spring-boot-autoconfigure/src/test/java/org/springframework/boot/autoconfigure/jdbc/JdbcTemplateAutoConfigurationTests.java b/spring-boot-autoconfigure/src/test/java/org/springframework/boot/autoconfigure/jdbc/JdbcTemplateAutoConfigurationTests.java new file mode 100644 index 000000000000..371ab4836342 --- /dev/null +++ b/spring-boot-autoconfigure/src/test/java/org/springframework/boot/autoconfigure/jdbc/JdbcTemplateAutoConfigurationTests.java @@ -0,0 +1,209 @@ +/* + * Copyright 2012-2016 the original author or authors. + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +package org.springframework.boot.autoconfigure.jdbc; + +import java.util.Random; + +import javax.sql.DataSource; + +import org.apache.commons.dbcp.BasicDataSource; +import org.junit.After; +import org.junit.Before; +import org.junit.Test; + +import org.springframework.boot.autoconfigure.PropertyPlaceholderAutoConfiguration; +import org.springframework.boot.test.util.EnvironmentTestUtils; +import org.springframework.context.annotation.AnnotationConfigApplicationContext; +import org.springframework.context.annotation.Bean; +import org.springframework.context.annotation.Configuration; +import org.springframework.context.annotation.Primary; +import org.springframework.jdbc.core.JdbcOperations; +import org.springframework.jdbc.core.JdbcTemplate; +import org.springframework.jdbc.core.namedparam.NamedParameterJdbcOperations; +import org.springframework.jdbc.core.namedparam.NamedParameterJdbcTemplate; + +import static org.assertj.core.api.Assertions.assertThat; + +/** + * Tests for {@link DataSourceAutoConfiguration}. + * + * @author Dave Syer + * @author Stephane Nicoll + * @author Kazuki Shimizu + * @since 1.4.0 + */ +public class JdbcTemplateAutoConfigurationTests { + + private final AnnotationConfigApplicationContext context = new AnnotationConfigApplicationContext(); + + @Before + public void init() { + EmbeddedDatabaseConnection.override = null; + EnvironmentTestUtils.addEnvironment(this.context, + "spring.datasource.initialize:false", + "spring.datasource.url:jdbc:hsqldb:mem:testdb-" + new Random().nextInt()); + } + + @After + public void restore() { + EmbeddedDatabaseConnection.override = null; + this.context.close(); + } + + @Test + public void testJdbcTemplateExists() throws Exception { + this.context.register(DataSourceAutoConfiguration.class, JdbcTemplateAutoConfiguration.class, + PropertyPlaceholderAutoConfiguration.class); + this.context.refresh(); + JdbcTemplate jdbcTemplate = this.context.getBean(JdbcTemplate.class); + assertThat(jdbcTemplate).isNotNull(); + assertThat(jdbcTemplate.getDataSource()).isNotNull(); + } + + @Test + public void testJdbcTemplateExistsWithCustomDataSource() throws Exception { + this.context.register(TestDataSourceConfiguration.class, + DataSourceAutoConfiguration.class, JdbcTemplateAutoConfiguration.class, + PropertyPlaceholderAutoConfiguration.class); + this.context.refresh(); + JdbcTemplate jdbcTemplate = this.context.getBean(JdbcTemplate.class); + assertThat(jdbcTemplate).isNotNull(); + assertThat(jdbcTemplate.getDataSource() instanceof BasicDataSource).isTrue(); + } + + @Test + public void testNamedParameterJdbcTemplateExists() throws Exception { + this.context.register(DataSourceAutoConfiguration.class, JdbcTemplateAutoConfiguration.class, + PropertyPlaceholderAutoConfiguration.class); + this.context.refresh(); + assertThat(this.context.getBean(NamedParameterJdbcOperations.class)).isNotNull(); + } + + @Test + public void testMultiDataSource() throws Exception { + this.context.register(TestMultiDataSourceConfiguration.class, + DataSourceAutoConfiguration.class, JdbcTemplateAutoConfiguration.class, + PropertyPlaceholderAutoConfiguration.class); + this.context.refresh(); + assertThat(this.context.getBeansOfType(JdbcOperations.class)).isEmpty(); + assertThat(this.context.getBeansOfType(NamedParameterJdbcOperations.class)).isEmpty(); + } + + @Test + public void testMultiDataSourceUsingPrimary() throws Exception { + this.context.register(TestMultiDataSourceUsingPrimaryConfiguration.class, + DataSourceAutoConfiguration.class, JdbcTemplateAutoConfiguration.class, + PropertyPlaceholderAutoConfiguration.class); + this.context.refresh(); + assertThat(this.context.getBean(JdbcOperations.class)).isNotNull(); + assertThat(this.context.getBean(NamedParameterJdbcOperations.class)).isNotNull(); + } + + @Test + public void testExistingCustomJdbcTemplate() throws Exception { + this.context.register(CustomConfiguration.class, DataSourceAutoConfiguration.class, + JdbcTemplateAutoConfiguration.class, PropertyPlaceholderAutoConfiguration.class); + this.context.refresh(); + assertThat(this.context.getBean(JdbcOperations.class)) + .isEqualTo(this.context.getBean("customJdbcOperations")); + } + + @Test + public void testExistingCustomNamedParameterJdbcTemplate() throws Exception { + this.context.register(CustomConfiguration.class, DataSourceAutoConfiguration.class, + JdbcTemplateAutoConfiguration.class, PropertyPlaceholderAutoConfiguration.class); + this.context.refresh(); + assertThat(this.context.getBean(NamedParameterJdbcOperations.class)) + .isEqualTo(this.context.getBean("customNamedParameterJdbcOperations")); + } + + @Configuration + static class CustomConfiguration { + @Bean + JdbcOperations customJdbcOperations(DataSource dataSource) { + return new JdbcTemplate(dataSource); + } + @Bean + NamedParameterJdbcOperations customNamedParameterJdbcOperations(DataSource dataSource) { + return new NamedParameterJdbcTemplate(dataSource); + } + } + + @Configuration + static class TestDataSourceConfiguration { + + private BasicDataSource pool; + + @Bean + public DataSource dataSource() { + this.pool = new BasicDataSource(); + this.pool.setDriverClassName("org.hsqldb.jdbcDriver"); + this.pool.setUrl("jdbc:hsqldb:target/overridedb"); + this.pool.setUsername("sa"); + return this.pool; + } + + } + + @Configuration + static class TestMultiDataSourceConfiguration { + + @Bean + public DataSource test1DataSource() { + BasicDataSource pool = new BasicDataSource(); + pool.setDriverClassName("org.hsqldb.jdbcDriver"); + pool.setUrl("jdbc:hsqldb:target/test1"); + pool.setUsername("sa"); + return pool; + } + + @Bean + public DataSource test2DataSource() { + BasicDataSource pool = new BasicDataSource(); + pool.setDriverClassName("org.hsqldb.jdbcDriver"); + pool.setUrl("jdbc:hsqldb:target/test2"); + pool.setUsername("sa"); + return pool; + } + + } + + @Configuration + static class TestMultiDataSourceUsingPrimaryConfiguration { + + @Bean + @Primary + public DataSource test1DataSource() { + BasicDataSource pool = new BasicDataSource(); + pool.setDriverClassName("org.hsqldb.jdbcDriver"); + pool.setUrl("jdbc:hsqldb:target/test1"); + pool.setUsername("sa"); + return pool; + } + + @Bean + public DataSource test2DataSource() { + BasicDataSource pool = new BasicDataSource(); + pool.setDriverClassName("org.hsqldb.jdbcDriver"); + pool.setUrl("jdbc:hsqldb:target/test2"); + pool.setUsername("sa"); + return pool; + } + + } + +}