兄弟，我太懂你这个痛点了！之前帮好几个做DevOps的朋友解决过Spring Boot下数据库密码低停机轮换的问题——毕竟Spring Boot默认的数据源初始化逻辑和你那套Python/Node的动态重试玩法确实不兼容，但咱们有好几个落地性极强的方案，我给你一步步拆解：

方案一：自定义多密码重试数据源（最贴近你的现有逻辑） #

这个方案完全对齐你在Python/Node里的思路，核心是给Spring Boot的数据源加一层“密码重试包装”，让它在获取连接时自动尝试多个候选密码。

具体步骤： #

1. 调整环境变量配置：把原来的单个密码环境变量改成逗号分隔的列表，比如DB_PASSWORDS=旧密码,新密码，然后在Spring Boot的配置文件里映射成List：

   spring.datasource.passwords=${DB_PASSWORDS:}
   

2. 实现多密码数据源包装类：自己写一个DataSource的包装类，在每次获取连接时轮训所有候选密码，成功后缓存有效密码提升性能。
3. 替换默认数据源：用自定义的包装类替换Spring Boot默认的Hikari数据源。

核心代码示例： #

配置类

@Configuration
public class MultiPasswordDataSourceConfig {

    @Value("${spring.datasource.url}")
    private String dbUrl;

    @Value("${spring.datasource.username}")
    private String dbUsername;

    @Value("#{'${spring.datasource.passwords}'.split(',')}")
    private List<String> dbPasswords;

    @Bean
    public DataSource dataSource() {
        return new MultiPasswordDataSourceWrapper(dbUrl, dbUsername, dbPasswords);
    }
}

数据源包装类

public class MultiPasswordDataSourceWrapper implements DataSource {

    private final String url;
    private final String username;
    private final List<String> passwords;
    private final AtomicReference<String> currentValidPassword = new AtomicReference<>();
    private final HikariDataSource fallbackDs = new HikariDataSource();

    public MultiPasswordDataSourceWrapper(String url, String username, List<String> passwords) {
        this.url = url;
        this.username = username;
        this.passwords = passwords;
        // 初始化基础数据源配置
        fallbackDs.setJdbcUrl(url);
        fallbackDs.setUsername(username);
        fallbackDs.setConnectionTimeout(3000); // 短连接超时，快速失败重试
    }

    @Override
    public Connection getConnection() throws SQLException {
        // 优先尝试缓存的有效密码
        if (currentValidPassword.get() != null) {
            try {
                fallbackDs.setPassword(currentValidPassword.get());
                Connection conn = fallbackDs.getConnection();
                validateConnection(conn); // 确保连接是活的
                return conn;
            } catch (SQLInvalidAuthorizationSpecException e) {
                currentValidPassword.set(null); // 缓存失效，清空重试
            }
        }

        // 轮训所有候选密码
        for (String pwd : passwords) {
            try {
                fallbackDs.setPassword(pwd);
                Connection conn = fallbackDs.getConnection();
                validateConnection(conn);
                currentValidPassword.set(pwd); // 缓存有效密码
                return conn;
            } catch (SQLInvalidAuthorizationSpecException ignored) {
                // 密码无效，跳过
            }
        }
        throw new SQLException("所有配置的数据库密码均无效");
    }

    // 验证连接有效性
    private void validateConnection(Connection conn) throws SQLException {
        if (!conn.isValid(1000)) {
            conn.close();
            throw new SQLException("连接无效");
        }
    }

    // 其他DataSource接口方法直接委托给fallbackDs
    @Override
    public Connection getConnection(String username, String password) throws SQLException {
        return getConnection();
    }

    @Override
    public <T> T unwrap(Class<T> iface) throws SQLException {
        return fallbackDs.unwrap(iface);
    }

    @Override
    public boolean isWrapperFor(Class<?> iface) throws SQLException {
        return fallbackDs.isWrapperFor(iface);
    }

    // 省略getLoginTimeout、setLoginTimeout等方法的委托实现
}

轮换流程（和你现有流程完全一致）： #

• 第一步：给环境变量的DB_PASSWORDS追加新密码（变成旧密码,新密码），重启或让服务加载新的环境变量（如果用K8s可以滚动更新Pod）
• 第二步：修改数据库的密码为新密码
• 第三步：等所有服务都稳定使用新密码后，可清理环境变量里的旧密码

方案二：结合配置中心的动态刷新（适合规模化服务） #

如果你的团队已经在用Spring Cloud Config、Nacos这类配置中心，这个方案会更优雅，不需要修改太多代码，核心是让数据源配置支持动态刷新。

具体步骤： #

1. 把数据库密码托管到配置中心：替换原来的环境变量配置，用配置中心的动态配置项存储密码
2. 开启Spring Boot的刷新能力：引入spring-boot-starter-actuator，开启refresh端点，给数据源配置加上@RefreshScope
3. 分批次轮换密码：
   • 先在配置中心把密码改成旧密码,新密码（或者直接替换成新密码，看你的刷新逻辑）
   • 分批给Spring Boot实例发送POST /actuator/refresh请求，让它们加载新密码
   • 等所有实例都加载新密码后，修改数据库密码为新密码
   • 最后可以在配置中心清理旧密码

注意点： #

• 用@RefreshScope的时候，要注意HikariCP的连接池重建问题，可以配置hikari.maxLifetime让旧连接自动过期，避免刷新时的连接中断
• 一定要分批刷新实例，比如先刷50%，确认正常后再刷剩下的，完全避免停机

方案三：数据库账号轮换（最稳定的长期方案） #

如果你的数据库支持多账号访问，这个方案比密码轮换更清晰，核心是用两个数据库账号（比如app_user1和app_user2），服务自动切换可用的账号。

具体步骤： #

1. 创建两个数据库账号：给两个账号都分配相同的数据库权限
2. 配置路由数据源：用Spring的AbstractRoutingDataSource实现路由数据源，让服务在获取连接时自动尝试两个账号
3. 轮换流程：
   • 第一步：修改其中一个账号的密码为新密码
   • 第二步：等所有服务都能用上这个新密码的账号后，再修改另一个账号的密码为新密码
   • 整个过程不需要动服务的配置，只要确保服务能自动切换到可用的账号

核心代码示例（路由数据源）： #

@Configuration
public class RoutingDataSourceConfig {

    @Value("${spring.datasource.url}")
    private String dbUrl;

    @Value("${spring.datasource.user1.name}")
    private String user1;

    @Value("${spring.datasource.user1.pass}")
    private String pass1;

    @Value("${spring.datasource.user2.name}")
    private String user2;

    @Value("${spring.datasource.user2.pass}")
    private String pass2;

    @Bean
    public DataSource routingDataSource() {
        AbstractRoutingDataSource routingDs = new AbstractRoutingDataSource() {
            private final AtomicReference<String> currentUserKey = new AtomicReference<>("user1");

            @Override
            protected Object determineCurrentLookupKey() {
                // 先试当前缓存的账号，失败了切换到另一个
                try {
                    DataSource ds = (DataSource) getResolvedDataSources().get(currentUserKey.get());
                    try (Connection conn = ds.getConnection()) {
                        if (conn.isValid(1000)) {
                            return currentUserKey.get();
                        }
                    }
                } catch (Exception ignored) {
                }
                // 切换到另一个账号
                String newKey = "user1".equals(currentUserKey.get()) ? "user2" : "user1";
                currentUserKey.set(newKey);
                return newKey;
            }
        };

        // 配置两个目标数据源
        Map<Object, Object> targetDs = new HashMap<>();
        targetDs.put("user1", createHikariDs(dbUrl, user1, pass1));
        targetDs.put("user2", createHikariDs(dbUrl, user2, pass2));

        routingDs.setTargetDataSources(targetDs);
        routingDs.setDefaultTargetDataSource(targetDs.get("user1"));
        return routingDs;
    }

    private HikariDataSource createHikariDs(String url, String user, String pass) {
        HikariDataSource ds = new HikariDataSource();
        ds.setJdbcUrl(url);
        ds.setUsername(user);
        ds.setPassword(pass);
        return ds;
    }
}

最后给你的选型建议 #

1. 如果想快速对齐现有Python/Node的流程，直接用方案一，改动最小，不需要额外依赖
2. 如果你的服务已经规模化，有配置中心体系，优先选方案二，运维更优雅
3. 如果数据库支持多账号，方案三是最稳定的长期方案，后续的密码轮换会更省心

另外，不管用哪个方案，一定要把轮换流程自动化！比如用你的CI/CD工具自动更新环境变量/配置中心，然后等待服务加载新配置，最后修改数据库密码，完全避免手动操作的风险。