Konfigurieren Sie DataSource programmgesteuert in Spring Boot

Mit Spring Boot kann ich a JdbcTemplatemit folgendem instanziieren :

Code:

@Autowired
private JdbcTemplate jdbcTemplate;

Eigenschaften:

spring.datasource.url=jdbc:postgresql://my_url:my_port/my_other_stuff
spring.datasource.username=my_user_name
spring.datasource.password=my_password
spring.datasource.driver-class-name=org.postgresql.Driver

Dadurch wird eine DataSource der Klasse erstellt: org.apache.tomcat.jdbc.pool.DataSource

Wie setze ich den DataSource-Benutzernamen / das Passwort programmgesteuert?

Wir haben die Richtlinie, Anmeldeinformationen nicht im Klartext zu speichern, und ich muss einen bestimmten Anbieter für Anmeldeinformationen verwenden, bei dem ich arbeite.

Sie können verwenden, DataSourceBuilderwenn Sie jdbcStarter verwenden. Um die Standard-Bean für die automatische Konfiguration zu überschreiben, müssen Sie Ihre Bean als markieren@Primary

In meinem Fall habe ich Eigenschaften, die mit dem datasource.postgresPräfix beginnen.

Z.B

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

Wenn es für Sie nicht machbar ist, können Sie verwenden

@Bean
@Primary
public DataSource dataSource() {
    return DataSourceBuilder
        .create()
        .username("")
        .password("")
        .url("")
        .driverClassName("")
        .build();
}

Mein Projekt von Spring-Boot ist gemäß Ihrer Unterstützung normal gelaufen. Die Konfiguration der Yaml-Datenquelle lautet:

spring:
  # (DataSourceAutoConfiguration & DataSourceProperties)
  datasource:
    name: ds-h2
    url: jdbc:h2:D:/work/workspace/fdata;DATABASE_TO_UPPER=false
    username: h2
    password: h2
    driver-class: org.h2.Driver

Benutzerdefinierte DataSource

@Configuration
@Component
public class DataSourceBean {

    @ConfigurationProperties(prefix = "spring.datasource")
    @Bean
    @Primary
    public DataSource getDataSource() {
        return DataSourceBuilder
                .create()
//                .url("jdbc:h2:D:/work/workspace/fork/gs-serving-web-content/initial/data/fdata;DATABASE_TO_UPPER=false")
//                .username("h2")
//                .password("h2")
//                .driverClassName("org.h2.Driver")
                .build();
    }
}

Sie müssen lediglich eine Methode mit Anmerkungen versehen, die eine DataSource mit @Bean zurückgibt. Es folgt ein vollständiges Arbeitsbeispiel.

@Bean
public DataSource dataSource() {
    DataSourceBuilder dataSourceBuilder = DataSourceBuilder.create();
        dataSourceBuilder.url(dbUrl);
        dataSourceBuilder.username(username);
        dataSourceBuilder.password(password);
        return dataSourceBuilder.build();   
}

Wenn Sie den neuesten Spring Boot (mit JDBC-Starter und Hikari) verwenden, werden Sie auf Folgendes stoßen: java.lang.IllegalArgumentException: jdbcUrl is required with driverClassName. Um dies zu lösen:

1. In Ihren application.properties:

datasource.oracle.url=youroracleurl

2. In Ihrer Anwendung als Bean definieren ( @Primaryist obligatorisch! ):

@Bean
@Primary
@ConfigurationProperties("datasource.oracle")
public DataSourceProperties getDatasourceProperties() {
    return new DataSourceProperties();
}

@Bean
@ConfigurationProperties("datasource.oracle")
public DataSource getDatasource() {
    return getDatasourceProperties().initializeDataSourceBuilder()
           .username("username")
           .password("password")
           .build();
}

Wenn Sie mehr Datumsquellenkonfigurationen wünschen, z

spring.datasource.test-while-idle=true 
spring.datasource.time-between-eviction-runs-millis=30000
spring.datasource.validation-query=select 1

Sie können den folgenden Code verwenden

@Bean
public DataSource dataSource() {
    DataSource dataSource = new DataSource(); // org.apache.tomcat.jdbc.pool.DataSource;
    dataSource.setDriverClassName(driverClassName);
    dataSource.setUrl(url);
    dataSource.setUsername(username);
    dataSource.setPassword(password);
    dataSource.setTestWhileIdle(testWhileIdle);     
    dataSource.setTimeBetweenEvictionRunsMillis(timeBetweenEvictionRunsMills);
    dataSource.setValidationQuery(validationQuery);
    return dataSource;
}

Siehe : Spring Boot JDBC-Verbindung

Alternativ können Sie DriverManagerDataSource verwenden, z.

public DataSource getDataSource(DBInfo db) {

    DriverManagerDataSource dataSource = new DriverManagerDataSource();

    dataSource.setUsername(db.getUsername());
    dataSource.setPassword(db.getPassword());
    dataSource.setUrl(db.getUrl());
    dataSource.setDriverClassName(db.getDriverClassName());

    return dataSource;
}

Seien Sie jedoch vorsichtig bei der Verwendung, da:

HINWEIS: Diese Klasse ist kein tatsächlicher Verbindungspool. Verbindungen werden nicht zusammengefasst. Es dient lediglich als einfacher Ersatz für einen vollständigen Verbindungspool, der dieselbe Standardschnittstelle implementiert, aber bei jedem Anruf neue Verbindungen erstellt. Referenz

Für Springboot 2.1.7 scheint das Arbeiten mit URL nicht zu funktionieren. Ändern Sie stattdessen mit jdbcUrl.

In Eigenschaften:

security:
      datasource:
        jdbcUrl: jdbc:mysql://ip:3306/security
        username: user
        password: pass

In Java:

@ConfigurationProperties(prefix = "security.datasource")
@Bean("dataSource")
@Primary
public DataSource dataSource(){

    return DataSourceBuilder
            .create()
            .build();
}

Ich habe Tomcat DataSource in Spring-Boot 2 angepasst .

Abhängigkeitsversionen:

• Spring-Boot: 2.1.9.FREIGABE
• tomcat-jdbc: 9.0.20

Vielleicht ist es für jemanden nützlich.

application.yml

spring:
    datasource:
        driver-class-name: org.postgresql.Driver
        type: org.apache.tomcat.jdbc.pool.DataSource
        url: jdbc:postgresql://${spring.datasource.database.host}:${spring.datasource.database.port}/${spring.datasource.database.name}
        database:
            host: localhost
            port: 5432
            name: rostelecom
        username: postgres
        password: postgres
        tomcat:
            validation-query: SELECT 1
            validation-interval: 30000           
            test-on-borrow: true
            remove-abandoned: true
            remove-abandoned-timeout: 480
            test-while-idle: true
            time-between-eviction-runs-millis: 60000
            log-validation-errors: true
            log-abandoned: true

Java

@Bean
@Primary
@ConfigurationProperties("spring.datasource.tomcat")
public PoolConfiguration postgresDataSourceProperties() {
    return new PoolProperties();
}

@Bean(name = "primaryDataSource")
@Primary
@Qualifier("primaryDataSource")
@ConfigurationProperties(prefix = "spring.datasource")
public DataSource primaryDataSource() {
    PoolConfiguration properties = postgresDataSourceProperties();
    return new DataSource(properties);
}

Der Hauptgrund, warum dies getan wurde, sind mehrere DataSources in der Anwendung, von denen eine als @Primary markiert werden muss .