提取配置文件的地址注解

可以使用以下正则表达式提取配置文件的地址注解：

^#\s*@config_file\s*=\s*(.+)$

该正则表达式匹配以`#`开头，后跟一个或多个空格，然后是`@config_file`，后面跟着一个或多个空格，再后面是配置文件的地址，该地址可以包含任何字符，直到行末。使用该正则表达式可以提取出配置文件的地址。

相关问题

Apache Shiro加解密spring配置文件value 示例

好的，下面是使用 Apache Shiro 加解密 Spring Boot 配置文件中的敏感信息的示例：

1. 在 pom.xml 文件中添加以下依赖：

<dependency>
    <groupId>org.apache.shiro</groupId>
    <artifactId>shiro-core</artifactId>
    <version>1.7.1</version>
</dependency>

2. 在 Spring Boot 的配置文件中添加以下配置：

# 加密盐，可以自己定义
shiro.encryptSalt: mySalt

# 需要加密的属性值
my.encrypted.property: ENC(7M9iu9qgMjG5+yMm5JLc3w==)

3. 新建一个加解密工具类，例如：

import org.apache.shiro.codec.Base64;
import org.apache.shiro.codec.Hex;
import org.apache.shiro.crypto.AesCipherService;
import org.apache.shiro.crypto.hash.Md5Hash;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.stereotype.Component;

import java.nio.charset.StandardCharsets;

@Component
public class ShiroEncryptUtils {

    private static final Logger LOGGER = LoggerFactory.getLogger(ShiroEncryptUtils.class);

    @Value("${shiro.encryptSalt}")
    private String encryptSalt;

    private final AesCipherService aesCipherService;

    @Autowired
    public ShiroEncryptUtils(AesCipherService aesCipherService) {
        this.aesCipherService = aesCipherService;
    }

    /**
     * 加密
     *
     * @param plaintext 明文
     * @return 密文
     */
    public String encrypt(String plaintext) {
        // 加密密钥
        byte[] key = new Md5Hash(encryptSalt.getBytes(StandardCharsets.UTF_8)).getBytes();
        // 生成随机向量
        byte[] iv = aesCipherService.generateNewInitializationVector();
        // 加密
        byte[] encrypted = aesCipherService.encrypt(plaintext.getBytes(StandardCharsets.UTF_8), key, iv);
        // 将向量和密文转换为十六进制字符串
        String ivHex = Hex.encodeToString(iv);
        String encryptedHex = Hex.encodeToString(encrypted);
        return "ENC(" + ivHex + encryptedHex + ")";
    }

    /**
     * 解密
     *
     * @param ciphertext 密文
     * @return 明文
     */
    public String decrypt(String ciphertext) {
        if (ciphertext == null || !ciphertext.startsWith("ENC(") || !ciphertext.endsWith(")")) {
            LOGGER.warn("Invalid ciphertext: {}", ciphertext);
            return "";
        }
        String encryptedString = ciphertext.substring(4, ciphertext.length() - 1);
        // 解密密钥
        byte[] key = new Md5Hash(encryptSalt.getBytes(StandardCharsets.UTF_8)).getBytes();
        // 从密文中提取向量和密文
        byte[] iv = Hex.decode(encryptedString.substring(0, 32));
        byte[] encrypted = Hex.decode(encryptedString.substring(32));
        // 解密
        byte[] decrypted = aesCipherService.decrypt(encrypted, key, iv);
        return new String(decrypted, StandardCharsets.UTF_8);
    }

    /**
     * Base64 编码
     *
     * @param plaintext 明文
     * @return Base64 编码后的字符串
     */
    public String encodeBase64(String plaintext) {
        return Base64.encodeToString(plaintext.getBytes(StandardCharsets.UTF_8));
    }

    /**
     * Base64 解码
     *
     * @param ciphertext Base64 编码后的字符串
     * @return 明文
     */
    public String decodeBase64(String ciphertext) {
        return new String(Base64.decode(ciphertext), StandardCharsets.UTF_8);
    }
}

4. 在需要解密的属性上添加 `@Value` 注解和 `@PostConstruct` 注解。例如：

@Component
public class MyComponent {

    @Value("${my.encrypted.property}")
    private String encryptedProperty;

    @Autowired
    private ShiroEncryptUtils shiroEncryptUtils;

    private String decryptedProperty;

    @PostConstruct
    public void init() {
        decryptedProperty = shiroEncryptUtils.decrypt(encryptedProperty);
    }

    // ...
}

通过以上代码，我们可以使用 Apache Shiro 安全地加解密 Spring Boot 配置文件中的敏感信息。

springboot 脱敏自定义注解

Spring Boot 中脱敏自定义注解通常用于保护敏感信息，比如数据库密码、API密钥等，在程序运行时隐藏这些数据的真实值。你可以创建一个自定义注解，例如 `@Sensitive` 或者 `@Masked`, 然后编写处理器 (HandlerMethodArgumentResolver 或 BeanPostProcessor) 来处理这个注解。

步骤如下：

1. 定义注解：在你的项目中创建一个名为 `SensitiveData.java` 的文件，定义一个新的注解，如：

import java.lang.annotation.ElementType;
import java.lang.annotation.Retention;
import java.lang.annotation.RetentionPolicy;
import java.lang.annotation.Target;

@Target(ElementType.FIELD)
@Retention(RetentionPolicy.RUNTIME)
public @interface Sensitive {
}

2. 创建处理器：创建一个实现了 `BeanPostProcessor` 或 `HandlerMethodArgumentResolver` 接口的类，这个类会检查带有 `@Sensitive` 注解的字段，并应用某种策略（如替换为星号(*)或其他占位符）对敏感数据进行处理。

@Component
public class SensitiveDataProcessor implements HandlerMethodArgumentResolver {

    // ... 实现解析逻辑 ...

    @Override
    public boolean supportsParameter(MethodParameter parameter) {
        return parameter.hasAnnotation(Sensitive.class);
    }

    // ... 提取并处理字段值的方法 ...
}

3. 配置应用：在 Spring Boot 的配置类中注册你的处理器：

@Configuration
public class AppConfig {
    @Autowired
    private SensitiveDataProcessor processor;

    @Bean
    public WebMvcConfigurer webConfigurer() {
        return new WebMvcConfigurer() {
            @Override
            public void addArgumentResolvers(List<HandlerMethodArgumentResolver> argumentResolvers) {
                argumentResolvers.add(processor);
            }
        };
    }
}

当你在 Controller 或其他地方使用了 `@Sensitive` 标记的数据时，它会被自动处理成脱敏后的形式。