Alright, let's tackle how to list all DataSource instances in your Spring Boot application—whether they're auto-configured via your pom.xml's DB driver dependencies, or set up using Spring Cloud Config. Here are a few reliable approaches:

Spring manages all beans (including DataSources) in its application context, so you can directly retrieve all beans of type DataSource with this approach. It works for both auto-configured and Spring Cloud Config-provisioned DataSources, since both end up as Spring-managed beans.

Here's a quick component to implement this:

import org.springframework.context.ApplicationContext;
import org.springframework.stereotype.Component;
import javax.sql.DataSource;
import java.util.Map;

@Component
public class DataSourceLister {
    private final ApplicationContext context;

    // Constructor injection (preferred over @Autowired)
    public DataSourceLister(ApplicationContext context) {
        this.context = context;
    }

    public void listAllDataSources() {
        Map<String, DataSource> dataSourceMap = context.getBeansOfType(DataSource.class);
        
        if (dataSourceMap.isEmpty()) {
            System.out.println("No DataSource beans found in the application context.");
            return;
        }

        dataSourceMap.forEach((beanName, dataSource) -> {
            System.out.println("=== DataSource Details ===");
            System.out.println("Bean Name: " + beanName);
            System.out.println("Implementation Class: " + dataSource.getClass().getName());
            
            // Optional: Fetch connection metadata to confirm config
            try {
                var connection = dataSource.getConnection();
                var metaData = connection.getMetaData();
                System.out.println("DB URL: " + metaData.getURL());
                System.out.println("DB Username: " + metaData.getUserName());
                connection.close();
            } catch (Exception e) {
                System.out.println("Failed to retrieve connection details: " + e.getMessage());
            }
            System.out.println("-------------------------");
        });
    }
}

You can call the listAllDataSources() method anywhere in your app (like a controller or startup event listener) to print out all DataSources.

If you want a no-code way to inspect all beans (including DataSources), Spring Boot Actuator's /beans endpoint is perfect. It lists every bean in the context, along with their origin (e.g., auto-config classes or external config sources).

First, add the Actuator dependency to your pom.xml:

<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-actuator</artifactId>
</dependency>

Then expose the beans endpoint in your application.properties or application.yml:

management.endpoints.web.exposure.include=beans

Start your app and visit http://localhost:8080/actuator/beans (adjust port if needed). Search for "DataSource" in the response—you'll see all DataSource beans, their types, and even which configuration class created them (useful for confirming auto-config vs. custom/config-driven setup).

If you want to monitor DataSources as they're initialized (instead of fetching them later), a BeanPostProcessor lets you intercept bean creation. This is great for debugging or logging when DataSources are loaded.

import org.springframework.beans.BeansException;
import org.springframework.beans.factory.config.BeanPostProcessor;
import org.springframework.stereotype.Component;
import javax.sql.DataSource;

@Component
public class DataSourceTracker implements BeanPostProcessor {
    @Override
    public Object postProcessBeforeInitialization(Object bean, String beanName) throws BeansException {
        if (bean instanceof DataSource) {
            System.out.println("[BEFORE INIT] Found DataSource bean: " + beanName);
            System.out.println("Class: " + bean.getClass().getSimpleName());
        }
        return bean;
    }

    @Override
    public Object postProcessAfterInitialization(Object bean, String beanName) throws BeansException {
        if (bean instanceof DataSource) {
            System.out.println("[AFTER INIT] DataSource bean ready: " + beanName);
            // Add extra checks or logging here if needed
        }
        return bean;
    }
}

This will print logs as soon as any DataSource bean is being initialized and after it's ready—including those set up via Spring Cloud Config.

If you specifically want to confirm that a DataSource's config comes from Spring Cloud Config, you can check the property sources in the Spring Environment:

import org.springframework.core.env.ConfigurableEnvironment;
import org.springframework.core.env.Environment;
import org.springframework.stereotype.Component;

@Component
public class ConfigSourceVerifier {
    private final Environment environment;

    public ConfigSourceVerifier(Environment environment) {
        this.environment = environment;
    }

    public void checkDataSourceConfigOrigin() {
        if (!(environment instanceof ConfigurableEnvironment)) {
            System.out.println("Cannot access property sources.");
            return;
        }

        ConfigurableEnvironment env = (ConfigurableEnvironment) environment;
        String targetProperty = "spring.datasource.url";

        env.getPropertySources().forEach(source -> {
            if (source.containsProperty(targetProperty)) {
                System.out.println("Property '" + targetProperty + "' loaded from: " + source.getName());
            }
        });
    }
}

For Spring Cloud Config, you'll see a property source named something like configserver: followed by your config repo details, confirming the config is pulled remotely.

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