SrpingDruid数据源加密数据库密码的示例代码

首先我们需要明确什么是SpringDruid数据源，以及为什么需要加密数据库密码。

SpringDruid数据源是一种基于Spring框架和阿里巴巴德鲁伊连接池的数据源，它能够提高数据库的连接性能、可用性和稳定性。

在实际应用中，我们通常需要在配置文件中配置数据库连接信息，包括数据库用户名和密码。然而，这样做存在一定风险，因为配置文件可能会被非授权的人员获取到，导致数据库密码泄露。为了保障数据库的安全性，我们可以使用加密的方式来存储数据库密码，这样即使配置文件泄露，也无法直接获取到数据库密码。

接下来，我们介绍一下如何在SpringDruid数据源中加密数据库密码。

首先，我们需要在pom.xml文件中加入以下依赖：

<dependency>
    <groupId>com.alibaba</groupId>
    <artifactId>druid</artifactId>
    <version>${druid.version}</version>
</dependency>
<dependency>
    <groupId>org.apache.commons</groupId>
    <artifactId>commons-lang3</artifactId>
    <version>${commons.lang3.version}</version>
</dependency>
<dependency>
    <groupId>org.springframework.security</groupId>
    <artifactId>spring-security-crypto</artifactId>
    <version>${spring-security.version}</version>
</dependency>

其中，${druid.version}、${commons.lang3.version}和${spring-security.version}分别代表对应的版本号，需要根据实际情况进行修改。

然后，我们需要创建一个加密工具类，代码如下所示：

import org.apache.commons.lang3.StringUtils;
import org.springframework.security.crypto.codec.Hex;
import org.springframework.security.crypto.encrypt.Encryptors;
import org.springframework.security.crypto.encrypt.TextEncryptor;

public class PasswordEncryptor {

    private static final String SALT = "springdruid";

    private static final String PASSWORD = "密码加密密钥";

    public static String encrypt(String plaintext) {
        if (StringUtils.isBlank(plaintext)) {
            return plaintext;
        }
        TextEncryptor textEncryptor = Encryptors.text(PASSWORD, SALT);
        return new String(Hex.encode(textEncryptor.encrypt(plaintext).getBytes()));
    }

    public static String decrypt(String ciphertext) {
        if (StringUtils.isBlank(ciphertext)) {
            return ciphertext;
        }
        TextEncryptor textEncryptor = Encryptors.text(PASSWORD, SALT);
        return textEncryptor.decrypt(new String(Hex.decode(ciphertext.getBytes())));
    }
}

在加密工具类中，我们使用了Spring Security的加密工具类Encryptors和TextEncryptor，通过指定密钥和盐值，可以快速实现字符串的加密和解密。

接下来，我们需要修改数据源的配置，将密码加密后的值存储到配置文件中。示例如下所示：

# 数据源
spring.datasource.url=jdbc:mysql://localhost:3306/test?useUnicode=true&characterEncoding=UTF-8&autoReconnect=true&failOverReadOnly=false
spring.datasource.username=root
# 使用加密后的密码
spring.datasource.password=4a6a2d4168c69ecca076316d6f2a881c8fa3b481fb4f70160a380a04c319e02a5ab75a6e91bae0e5

注意，这里的密码已经是加密后的值，而不是明文。

最后，我们需要在应用启动时，调用PasswordEncryptor.decrypt()方法解密数据库密码，并将解密后的密码设置到数据源中。示例如下所示：

import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.boot.context.properties.ConfigurationProperties;
import org.springframework.boot.context.properties.EnableConfigurationProperties;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Primary;
import com.alibaba.druid.pool.DruidDataSource;

@SpringBootApplication
@EnableConfigurationProperties
public class Application {

    @Bean
    @ConfigurationProperties(prefix = "spring.datasource")
    public DruidDataSource druidDataSource() {
        DruidDataSource dataSource = new DruidDataSource();

        // 解密数据库密码
        String password = PasswordEncryptor.decrypt(dataSource.getPassword());
        dataSource.setPassword(password);

        return dataSource;
    }

    // 设置主数据源
    @Bean
    @Primary
    @ConfigurationProperties(prefix = "spring.datasource")
    public DataSource dataSource() {
        return druidDataSource();
    }

    public static void main(String[] args) {
        SpringApplication.run(Application.class, args);
    }
}

在应用启动时，通过@ConfigurationProperties注解将数据源配置文件中的属性注入到DruidDataSource对象中，再调用PasswordEncryptor.decrypt()方法解密数据库密码，并将解密后的密码设置到数据源中。最后，将DruidDataSource对象作为主数据源返回，供应用程序使用。

这样，就完成了SpringDruid数据源加密数据库密码的示例代码。

另外，如果您需要对多个数据源进行加密处理，可以参考下面的示例代码：

import lombok.Data;
import org.springframework.boot.context.properties.ConfigurationProperties;
import org.springframework.boot.context.properties.EnableConfigurationProperties;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.context.annotation.Primary;
import com.alibaba.druid.pool.DruidDataSource;

import javax.sql.DataSource;
import java.util.Map;

@Configuration
@EnableConfigurationProperties(MultiDataSourceProperties.class)
public class MultiDataSourceConfiguration {

    @Bean
    public DataSource dataSource(MultiDataSourceProperties properties) {
        Map<String, DataSourceProperties> multiDataSource = properties.getMultiDataSource();
        Map<String, DruidDataSource> druidDataSourceMap = Maps.newHashMapWithExpectedSize(multiDataSource.size());
        druidDataSourceMap.put(properties.getPrimary(), createDataSource(multiDataSource.get(properties.getPrimary())));

        multiDataSource.forEach((key, value) -> {
            if (StringUtils.equals(key, properties.getPrimary())) {
                return;
            }
            druidDataSourceMap.put(key, createDataSource(value));
        });

        Map<Object, Object> targetDataSources = Maps.newHashMapWithExpectedSize(druidDataSourceMap.size());
        targetDataSources.putAll(druidDataSourceMap);

        DynamicDataSource dynamicDataSource = new DynamicDataSource();
        dynamicDataSource.setTargetDataSources(targetDataSources);
        dynamicDataSource.setDefaultTargetDataSource(druidDataSourceMap.get(properties.getPrimary()));
        return dynamicDataSource;
    }

    private DruidDataSource createDataSource(DataSourceProperties properties) {
        DruidDataSource dataSource = new DruidDataSource();
        dataSource.setUrl(properties.getUrl());
        dataSource.setUsername(properties.getUsername());
        // 解密数据库密码
        dataSource.setPassword(PasswordEncryptor.decrypt(properties.getPassword()));
        dataSource.setDriverClassName(properties.getDriverClassName());
        return dataSource;
    }

    @Primary
    @Bean(name = "transactionManager")
    public DataSourceTransactionManager transactionManager(DataSource dataSource) {
        return new DataSourceTransactionManager(dataSource);
    }

    @Data
    @Configuration
    @ConfigurationProperties(prefix = "spring.datasource.multi")
    public static class MultiDataSourceProperties {
        private String primary;
        private Map<String, DataSourceProperties> multiDataSource;
    }

    @Data
    public static class DataSourceProperties {
        private String url;
        private String username;
        private String password;
        private String driverClassName;
    }

}

在这个示例中，我们将多个数据源的相关配置统一放在一个配置文件中，并在启动时通过MultiDataSourceConfiguration自动配置多个数据源。此处的加密方式和单数据源的加密方式类似，只需要在createDataSource()方法中进行解密操作即可。

希望这两个示例对您有所帮助，如有疑问，请随时提出。