如何实现基于数据库内容的自定义Spring Boot ConfigurationProperties注解

核心思路 #

通过自定义注解标记需要注入的字段/参数，结合Spring的BeanPostProcessor扩展机制，在Bean初始化阶段从数据库读取配置值并完成注入。核心是利用Spring的Bean生命周期钩子，提前加载数据库配置并完成字段赋值。

具体实现步骤 #

1. 定义自定义注入注解

创建@DbValue注解，用于标记需要从数据库注入值的字段或方法参数，包含配置键的属性：

@Target({ElementType.FIELD, ElementType.PARAMETER})
@Retention(RetentionPolicy.RUNTIME)
public @interface DbValue {
    // 数据库配置表中的键名
    String key();
    // 可选：默认值，当数据库无对应键时使用
    String defaultValue() default "";
}

2. 实现数据库配置读取器

负责从数据库加载配置并缓存，需确保在其他Bean初始化前完成配置加载：

@Component
@Order(Ordered.HIGHEST_PRECEDENCE)
public class DbConfigReader {
    private final Map<String, String> configCache = new ConcurrentHashMap<>();

    // 注入Spring自动配置的数据源，确保数据源优先初始化
    public DbConfigReader(DataSource dataSource) {
        loadConfigs(dataSource);
    }

    private void loadConfigs(DataSource dataSource) {
        String sql = "SELECT config_key, config_value FROM sys_config";
        try (Connection conn = dataSource.getConnection();
             PreparedStatement stmt = conn.prepareStatement(sql);
             ResultSet rs = stmt.executeQuery()) {

            while (rs.next()) {
                configCache.put(rs.getString("config_key"), rs.getString("config_value"));
            }
        } catch (SQLException e) {
            throw new RuntimeException("Failed to load configs from database", e);
        }
    }

    public String getValue(String key, String defaultValue) {
        return configCache.getOrDefault(key, defaultValue);
    }
}

• 用@Order(Ordered.HIGHEST_PRECEDENCE)确保该Bean优先初始化，保证配置提前加载。
• 使用ConcurrentHashMap保证多线程下的缓存安全。

3. 实现Bean后置处理器完成注入

通过BeanPostProcessor拦截Bean初始化过程，扫描@DbValue注解并注入值：

@Component
public class DbValueInjector implements BeanPostProcessor {
    private final DbConfigReader configReader;

    public DbValueInjector(DbConfigReader configReader) {
        this.configReader = configReader;
    }

    @Override
    public Object postProcessBeforeInitialization(Object bean, String beanName) throws BeansException {
        // 处理字段注入
        processFields(bean);
        // 可选：处理方法参数注入（需结合Autowired等注解，此处省略）
        return bean;
    }

    private void processFields(Object bean) {
        Class<?> beanClass = bean.getClass();
        // 遍历所有字段，包括父类
        while (beanClass != Object.class) {
            Field[] fields = beanClass.getDeclaredFields();
            for (Field field : fields) {
                if (field.isAnnotationPresent(DbValue.class)) {
                    DbValue annotation = field.getAnnotation(DbValue.class);
                    String value = configReader.getValue(annotation.key(), annotation.defaultValue());
                    if (!value.isEmpty()) {
                        field.setAccessible(true);
                        try {
                            // 类型转换：String转目标类型
                            Object convertedValue = convertValue(value, field.getType());
                            field.set(bean, convertedValue);
                        } catch (IllegalAccessException | IllegalArgumentException e) {
                            throw new RuntimeException("Inject DbValue failed for field: " + field.getName(), e);
                        }
                    }
                }
            }
            beanClass = beanClass.getSuperclass();
        }
    }

    // 扩展支持常见类型转换
    private Object convertValue(String value, Class<?> targetType) {
        if (targetType == String.class) {
            return value;
        } else if (targetType == int.class || targetType == Integer.class) {
            return Integer.parseInt(value);
        } else if (targetType == boolean.class || targetType == Boolean.class) {
            return Boolean.parseBoolean(value);
        } else if (targetType == long.class || targetType == Long.class) {
            return Long.parseLong(value);
        }
        // 可扩展枚举、自定义对象（如JSON转对象）等类型
        throw new IllegalArgumentException("Unsupported target type: " + targetType.getName());
    }
}

4. 实际使用示例

在任意Spring Bean的字段上标记@DbValue即可完成注入：

@Component
public class OrderService {
    @DbValue(key = "order.pay.timeout", defaultValue = "300")
    private int payTimeout;

    @DbValue(key = "order.notify.url")
    private String notifyUrl;

    // 业务逻辑方法
    public void handleOrderPay() {
        System.out.println("支付超时时间：" + payTimeout);
        System.out.println("通知地址：" + notifyUrl);
    }
}

关键注意事项 #

1. 初始化顺序：通过@Order确保DbConfigReader和DbValueInjector优先于业务Bean初始化，避免注入时配置未加载。
2. 类型转换：需根据业务需求扩展类型转换逻辑，比如支持枚举、日期、JSON对象等。
3. 配置更新：若需动态更新配置，可在DbConfigReader中添加定时刷新缓存的逻辑，结合@Scheduled注解实现。
4. 异常处理：需处理数据库连接失败、配置键不存在、类型转换失败等场景，避免Spring启动失败。

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