如何在Spring Boot 2中使用@Bean连接PostgreSQL并自定义数据源属性

Hey there! Let's get this set up properly. Since you want to use your custom my.db.* properties instead of Spring's default spring.datasource.* ones, we'll need to manually wire up the necessary beans for the database connection, entity management, and transactions. Here's a step-by-step breakdown:

1. Define Your Custom Properties in application.properties #

First, make sure your custom database settings are in place:

# Custom PostgreSQL connection details
my.db.url=jdbc:postgresql://localhost:5432/mydb
my.db.user=postgres
my.db.password=root
my.db.driver-class-name=org.postgresql.Driver

# Optional Hibernate configuration (for JPA)
my.db.hibernate.dialect=org.hibernate.dialect.PostgreSQLDialect
my.db.hibernate.show-sql=true
my.db.hibernate.format-sql=true

2. Create a Properties Binding Class (Cleaner Than @Value) #

To neatly bind all your my.db.* properties into a single class (instead of scattering @Value annotations everywhere), use Spring's @ConfigurationProperties:

import org.springframework.boot.context.properties.ConfigurationProperties;
import org.springframework.stereotype.Component;

@Component
@ConfigurationProperties(prefix = "my.db")
public class CustomDbProperties {
    private String url;
    private String user;
    private String password;
    private String driverClassName;
    private Hibernate hibernate;

    // Getters and Setters for all fields
    public static class Hibernate {
        private String dialect;
        private boolean showSql;
        private boolean formatSql;

        // Getters and Setters for Hibernate fields
    }
}

This class will automatically pull in all properties starting with my.db and map them to its fields.

3. Configure the Database Beans #

Create a configuration class to define the DataSource, EntityManagerFactory, and TransactionManager beans—these are the core components Spring Data JPA needs to interact with your PostgreSQL database:

import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.data.jpa.repository.config.EnableJpaRepositories;
import org.springframework.orm.jpa.JpaTransactionManager;
import org.springframework.orm.jpa.LocalContainerEntityManagerFactoryBean;
import org.springframework.orm.jpa.vendor.HibernateJpaVendorAdapter;
import org.springframework.transaction.PlatformTransactionManager;
import javax.sql.DataSource;
import com.zaxxer.hikari.HikariDataSource;

@Configuration
@EnableJpaRepositories(basePackages = "com.yourproject.repository") // Replace with your repo package path
public class CustomPostgresConfig {

    private final CustomDbProperties dbProperties;

    // Constructor injection (Spring 4.3+ doesn't require @Autowired here)
    public CustomPostgresConfig(CustomDbProperties dbProperties) {
        this.dbProperties = dbProperties;
    }

    @Bean
    public DataSource dataSource() {
        // Use HikariCP (Spring Boot's default connection pool)
        HikariDataSource dataSource = new HikariDataSource();
        dataSource.setJdbcUrl(dbProperties.getUrl());
        dataSource.setUsername(dbProperties.getUser());
        dataSource.setPassword(dbProperties.getPassword());
        dataSource.setDriverClassName(dbProperties.getDriverClassName());
        
        // Optional: Tune HikariCP settings if needed
        dataSource.setMaximumPoolSize(10);
        dataSource.setMinimumIdle(2);
        return dataSource;
    }

    @Bean
    public LocalContainerEntityManagerFactoryBean entityManagerFactory() {
        LocalContainerEntityManagerFactoryBean em = new LocalContainerEntityManagerFactoryBean();
        em.setDataSource(dataSource());
        em.setPackagesToScan("com.yourproject.entity"); // Replace with your entity package path
        em.setJpaVendorAdapter(new HibernateJpaVendorAdapter());

        // Apply Hibernate settings from your custom properties
        em.getJpaPropertyMap().put("hibernate.dialect", dbProperties.getHibernate().getDialect());
        em.getJpaPropertyMap().put("hibernate.show_sql", dbProperties.getHibernate().isShowSql());
        em.getJpaPropertyMap().put("hibernate.format_sql", dbProperties.getHibernate().isFormatSql());

        return em;
    }

    @Bean
    public PlatformTransactionManager transactionManager() {
        JpaTransactionManager transactionManager = new JpaTransactionManager();
        transactionManager.setEntityManagerFactory(entityManagerFactory().getObject());
        return transactionManager;
    }
}

Quick Notes on the Configuration: #

• @EnableJpaRepositories tells Spring where to find your repository interfaces (the ones extending JpaRepository).
• We're using HikariCP because it's the default, high-performance connection pool in Spring Boot.
• The EntityManagerFactory handles entity mapping and interactions with the database, while the TransactionManager manages database transactions.

4. Ensure Dependencies Are in Place #

Double-check your pom.xml (or build.gradle) includes the necessary dependencies for PostgreSQL and Spring Data JPA:
For Maven:

<dependencies>
    <!-- PostgreSQL JDBC Driver -->
    <dependency>
        <groupId>org.postgresql</groupId>
        <artifactId>postgresql</artifactId>
        <scope>runtime</scope>
    </dependency>
    <!-- Spring Data JPA (includes HikariCP and Hibernate) -->
    <dependency>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-data-jpa</artifactId>
    </dependency>
</dependencies>

Alternative: Using @Value Directly #

If you prefer not to use @ConfigurationProperties, you can inject individual properties directly into your configuration class with @Value:

@Value("${my.db.url}")
private String dbUrl;

@Value("${my.db.user}")
private String dbUser;

@Value("${my.db.password}")
private String dbPassword;

// Then use these values in the dataSource() method

But @ConfigurationProperties is more maintainable, especially if you have multiple properties.

That's it! With this setup, Spring Data JPA will use your custom my.db.* properties to connect to PostgreSQL, completely ignoring the default spring.datasource ones.

内容的提问来源于stack exchange，提问作者Anderson Rossi