Cacher is the code snippet organizer for pro developers

<cloud:data-source id="testDataSource" service-name="test-db">
    <cloud:pool pool-size="20" max-wait-time="200"/>
  </cloud:data-source>
  
  <cloud:properties id="cloud-properties"/>
  <context:property-placeholder properties-ref="cloud-properties"/>

  <bean id="testDataSource" class="org.springframework.jdbc.datasource.DriverManagerDataSource">
    <property name="driverClassName" value="com.mysql.jdbc.Driver" />
    <property name="url" value="${cloud.services.test-db.connection.jdbcUrl}" />
    <property name="username" value="${cloud.services.test-db.connection.username}"/>
    <property name="password" value="${cloud.services.test-db.connection.password}"/>
  </bean>

#Follow http://cloud.spring.io/spring-cloud-connectors/spring-cloud-spring-service-connector.html
#and https://github.com/pivotalservices/spring-cloud-cloudfoundry-multidatasources-demo for cloud configuration
# Oracle DB - "foo"
spring.datasource.url=jdbc:oracle:thin:@//db-server-foo:1521/FOO
spring.datasource.username=fooadmin
spring.datasource.password=foo123
spring.datasource.driver-class-name=oracle.jdbc.OracleDriver
# PostgreSQL DB - "bar"
bar.datasource.url=jdbc:postgresql://db-server-bar:5432/bar
bar.datasource.username=baradmin
bar.datasource.password=bar123
bar.datasource.driver-class-name=org.postgresql.Driver

 @Bean(name = "barDataSource")
  @ConfigurationProperties(prefix = "bar.datasource")
  public DataSource dataSource() {
    return DataSourceBuilder.create().build();
  }
  
   @Primary
  @Bean(name = "dataSource")
  @ConfigurationProperties(prefix = "spring.datasource")
  public DataSource dataSource() {
    return DataSourceBuilder.create().build();
  }

@Bean
@Primary
@ConfigurationProperties(prefix="spring.datasource")
public DataSource primaryDataSource() {
    return DataSourceBuilder.create().build();
}

/**
 * use dbcp for fine grained control over jdbc connection properties
 * need to have configuration as below to avoid loosing connection after 8 hours in mySql
 */
@Bean
@ConfigurationProperties(prefix="spring.mySqlDatasource")
public DataSource mySqlDataSource() {
      @Value("${spring.datasource.username}")
    String username = "Unknown-Datasource-Username";

    @Value("${spring.datasource.password}")
    String password = "Unknown-Datasource-Password";

    @Value("${spring.datasource.url}")
    String url = "Unknown-DataSource-Url";

    @Value("${spring.datasource.driver-class-name}")
    String driverClassName = "Unknown-Datasource-DriverClassName";

    @Value("${ds.max.pool.size}")
    int maxActive = 20;

    @Value("${ds.min.pool.size}")
    int initialPoolSize = 5;

    @Value("${ds.validationQuery}")
    String validationQuery = "SELECT 1";

    @Bean
    @Primary
    public DataSource dataSource()
    {
        BasicDataSource ds = new BasicDataSource();

        ds.setDriverClassName(driverClassName);
        ds.setUsername(username);
        ds.setPassword(password);
        ds.setUrl(url);

        ds.setMaxActive(maxActive);
        ds.setInitialSize(initialPoolSize);

        ds.setTestWhileIdle(true);

        ds.setTestOnBorrow(true);
        ds.setValidationQuery(validationQuery);
        return ds;
    }
}

package org.espacecollectif.auth.config;

import org.springframework.beans.factory.annotation.Value;
import org.springframework.cloud.config.java.AbstractCloudConfig;
import org.springframework.cloud.service.PooledServiceConnectorConfig;
import org.springframework.cloud.service.relational.DataSourceConfig;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.context.annotation.Profile;
import org.springframework.jdbc.core.JdbcTemplate;

import javax.sql.DataSource;

@Configuration
@Profile("cloud")
public class DbCloudConfig extends AbstractCloudConfig {

    @Bean
    public JdbcTemplate jdbcTemplate(DataSource dataSource) {
        return new JdbcTemplate(dataSource);
    }

    @Bean
    public DataSource dataSource(@Value("${ds.min.pool.size}") int minPoolSize
            , @Value("${ds.max.pool.size}") int maxPoolSize
            , @Value("${ds.max.wait.time}") int maxWaitTime
            , @Value("${ds.connection-string}") String connectionString) {
        DataSourceConfig.ConnectionConfig connConfig = new DataSourceConfig.ConnectionConfig(connectionString);

        PooledServiceConnectorConfig.PoolConfig poolConfig
                = new PooledServiceConnectorConfig.PoolConfig(minPoolSize, maxPoolSize, maxWaitTime);

        DataSourceConfig dataSourceConfig = new DataSourceConfig(poolConfig, connConfig);

        DataSource dataSource = connectionFactory().dataSource(dataSourceConfig);
        return dataSource;
    }
}

import javax.sql.DataSource;

import org.springframework.beans.factory.annotation.Qualifier;
import org.springframework.cloud.Cloud;
import org.springframework.cloud.CloudFactory;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.context.annotation.Profile;
import org.springframework.jdbc.datasource.embedded.EmbeddedDatabaseBuilder;
import org.springframework.jdbc.datasource.embedded.EmbeddedDatabaseType;

@Configuration
public class CloudConfig {

	@Configuration
	@Profile("cloud")
	static class CloudConfiguration {

		@Bean
		public CloudFactory cloudFactory() {
			return new CloudFactory();
		}

		@Bean
		@Qualifier("inventoryDataSource")
		public DataSource inventoryDataSource(CloudFactory cloudFactory) {
			Cloud cloud = cloudFactory.getCloud();
			return cloud.getServiceConnector("inventory-db",
					EncryptedCredentialsBasicDataSource.class, null);
		}

		@Bean
		@Qualifier("productDataSource")
		public DataSource productDataSource(CloudFactory cloudFactory) {
			Cloud cloud = cloudFactory.getCloud();
			return cloud.getServiceConnector("product-db",
					EncryptedCredentialsBasicDataSource.class, null);
		}

	}

	@Configuration
	@Profile("default")
	static class LocalConfiguration {

		@Bean
		@Qualifier("inventoryDataSource")
		public DataSource inventoryDataSource() {
			return new EmbeddedDatabaseBuilder().setName("inventory")
					.setType(EmbeddedDatabaseType.H2).build();
		}

		@Bean
		@Qualifier("productDataSource")
		public DataSource productDataSource() {
			return new EmbeddedDatabaseBuilder().setName("product")
					.setType(EmbeddedDatabaseType.H2).build();
		}

	}

}