Spring Boot：数据库密码验证失败时忽略连接并启动应用

嘿，我完全明白你的场景：你部署了两个用不同数据库密码的应用实例，但代码只需要访问其中一个。现在只要密码不对，启动时就会炸出password authentication错误直接把应用搞挂，你想要实现的是——如果这个数据库连接验证失败，就直接跳过它，让应用正常启动起来。

下面是我整理的具体实现方案，亲测可行：

1. 先把两个数据源的配置明确区分开 #

首先在你的application.properties里把两个数据源的配置拆分开，避免自动配置混淆：

# 主数据源（必须能正常访问的那个）
spring.datasource.main.url=jdbc:mysql://localhost:3306/your_main_db
spring.datasource.main.username=main_user
spring.datasource.main.password=main_pass
spring.datasource.main.driver-class-name=com.mysql.cj.jdbc.Driver

# 可选数据源（允许连接失败的那个）
spring.datasource.optional.url=jdbc:mysql://localhost:3306/your_optional_db
spring.datasource.optional.username=optional_user
spring.datasource.optional.password=optional_pass
spring.datasource.optional.driver-class-name=com.mysql.cj.jdbc.Driver

# 你的原有配置
spring.security.enabled=false
management.security.enabled=false
# 其他配置...

2. 自定义数据源配置类，加入容错逻辑 #

接下来写一个配置类，手动初始化这两个数据源，关键是在初始化可选数据源的时候捕获连接异常，不让它阻断应用启动：

import org.springframework.boot.context.properties.ConfigurationProperties;
import org.springframework.boot.jdbc.DataSourceBuilder;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.context.annotation.Primary;

import javax.sql.DataSource;
import java.sql.Connection;

@Configuration
public class DataSourceConfig {

    // 主数据源：标记为@Primary，保证业务代码优先注入这个
    @Primary
    @Bean(name = "mainDataSource")
    @ConfigurationProperties(prefix = "spring.datasource.main")
    public DataSource mainDataSource() {
        return DataSourceBuilder.create().build();
    }

    // 可选数据源：连接失败时返回一个空实现，不影响启动
    @Bean(name = "optionalDataSource")
    @ConfigurationProperties(prefix = "spring.datasource.optional")
    public DataSource optionalDataSource() {
        try {
            DataSource dataSource = DataSourceBuilder.create().build();
            // 主动发起连接测试，触发密码验证
            try (Connection conn = dataSource.getConnection()) {
                // 连接成功，直接返回数据源
                return dataSource;
            }
        } catch (Exception e) {
            // 捕获连接异常，打印日志但不抛出
            System.err.println("可选数据源连接失败，已自动跳过：" + e.getMessage());
            // 返回一个空的数据源实现，避免业务代码拿null报错
            return new EmptyDataSource();
        }
    }

    // 自定义空数据源实现，避免NPE
    private static class EmptyDataSource implements DataSource {
        @Override
        public Connection getConnection() {
            throw new UnsupportedOperationException("可选数据源不可用");
        }

        @Override
        public Connection getConnection(String username, String password) {
            throw new UnsupportedOperationException("可选数据源不可用");
        }

        @Override
        public <T> T unwrap(Class<T> iface) {
            return null;
        }

        @Override
        public boolean isWrapperFor(Class<?> iface) {
            return false;
        }

        // 实现其他DataSource接口方法，全部返回空或者抛出不支持异常
        @Override
        public java.sql.Driver getDriver() {
            return null;
        }

        @Override
        public void setDriver(java.sql.Driver driver) {}

        @Override
        public java.util.Properties getLoginTimeout() {
            return null;
        }

        @Override
        public void setLoginTimeout(int seconds) {}

        @Override
        public java.io.PrintWriter getLogWriter() {
            return null;
        }

        @Override
        public void setLogWriter(java.io.PrintWriter out) {}
    }
}

3. 业务代码中判断数据源是否可用 #

在你需要调用可选数据源的地方，先判断它是不是那个空实现，再执行逻辑：

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.beans.factory.annotation.Qualifier;
import org.springframework.stereotype.Service;

import javax.sql.DataSource;
import java.sql.Connection;
import java.sql.ResultSet;
import java.sql.Statement;

@Service
public class DataQueryService {

    @Autowired
    @Qualifier("mainDataSource")
    private DataSource mainDataSource;

    @Autowired
    @Qualifier("optionalDataSource")
    private DataSource optionalDataSource;

    // 主数据源查询：正常执行即可
    public void queryMainDatabase() {
        try (Connection conn = mainDataSource.getConnection();
             Statement stmt = conn.createStatement();
             ResultSet rs = stmt.executeQuery("SELECT * FROM your_main_table")) {
            // 处理查询结果
        } catch (Exception e) {
            // 这里可以加告警逻辑，因为主数据源应该是必须可用的
            e.printStackTrace();
        }
    }

    // 可选数据源查询：先判断是否可用
    public void queryOptionalDatabase() {
        if (optionalDataSource instanceof DataSourceConfig.EmptyDataSource) {
            System.out.println("可选数据源不可用，跳过查询");
            return;
        }
        try (Connection conn = optionalDataSource.getConnection();
             Statement stmt = conn.createStatement();
             ResultSet rs = stmt.executeQuery("SELECT * FROM your_optional_table")) {
            // 处理查询结果
        } catch (Exception e) {
            e.printStackTrace();
        }
    }
}

4. 关闭自动数据源初始化（关键！） #

Spring Boot默认会自动初始化数据源，如果不关掉，它可能会在你的自定义配置之前尝试连接数据源，导致启动失败。所以在application.properties里加上：

# Spring Boot 2.0-2.6版本用这个
spring.datasource.initialization-mode=never
# Spring Boot 2.7+版本用这个
spring.sql.init.mode=never

这样配置之后，当可选数据源的密码错误时，初始化过程会捕获异常，返回一个空数据源实现，不会影响应用启动；业务代码里也能清晰判断数据源状态，避免报错。

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