Spring Boot不使用@Value实现@Configuration注解配置注入方案咨询

核心需求是自定义@Configuration注解，无需${}包裹即可直接通过注解值注入对应配置，兼容现有JEE代码。以下是几种可落地的方案：

方案一：自定义注解处理器（贴近Spring原生@Value逻辑） #

通过扩展Spring的AutowiredAnnotationBeanPostProcessor，让它识别并处理@Configuration注解，直接从Environment中读取配置值注入。

步骤1：定义@Configuration注解 #

@Retention(RetentionPolicy.RUNTIME)
@Target({ElementType.FIELD, ElementType.METHOD, ElementType.PARAMETER})
public @interface Configuration {
    String value() default "";
    boolean required() default true; // 可选：配置是否必填
}

步骤2：实现自定义BeanPostProcessor #

@Component
public class ConfigurationAnnotationProcessor extends AutowiredAnnotationBeanPostProcessor {

    private final Environment environment;

    public ConfigurationAnnotationProcessor(Environment environment) {
        this.environment = environment;
        // 让处理器识别@Configuration注解
        this.autowiredAnnotationTypes.add(Configuration.class);
    }

    @Override
    protected InjectionMetadata buildAutowiringMetadata(Class<?> clazz) {
        InjectionMetadata metadata = super.buildAutowiringMetadata(clazz);
        List<InjectionMetadata.InjectedElement> processedElements = new ArrayList<>();

        for (InjectionMetadata.InjectedElement element : metadata.getInjectedElements()) {
            // 处理字段注入
            if (element instanceof AutowiredFieldElement) {
                Field field = (Field) ((AutowiredFieldElement) element).getMember();
                Configuration configAnno = field.getAnnotation(Configuration.class);
                if (configAnno != null) {
                    processedElements.add(new ConfigFieldInjector(field, configAnno));
                    continue;
                }
            }
            // 处理方法/构造函数参数注入
            else if (element instanceof AutowiredMethodElement) {
                Method method = (Method) ((AutowiredMethodElement) element).getMember();
                Parameter[] params = method.getParameters();
                for (int i = 0; i < params.length; i++) {
                    Configuration configAnno = params[i].getAnnotation(Configuration.class);
                    if (configAnno != null) {
                        processedElements.add(new ConfigParamInjector(method, i, configAnno));
                        break;
                    }
                }
                continue;
            }
            processedElements.add(element);
        }
        return new InjectionMetadata(clazz, processedElements);
    }

    // 字段注入逻辑
    private class ConfigFieldInjector extends InjectionMetadata.InjectedElement {
        private final Field field;
        private final Configuration configAnno;

        ConfigFieldInjector(Field field, Configuration configAnno) {
            super(field, null);
            this.field = field;
            this.configAnno = configAnno;
        }

        @Override
        protected void inject(Object bean, String beanName, PropertyValues pvs) throws Throwable {
            String configKey = configAnno.value();
            String rawValue = environment.getProperty(configKey);

            if (rawValue == null) {
                if (configAnno.required()) {
                    throw new IllegalArgumentException("Missing required config: " + configKey);
                }
                return;
            }

            // 类型转换（支持String/Integer/Boolean等基础类型）
            Object convertedValue = convertValue(rawValue, field.getType());
            ReflectionUtils.makeAccessible(field);
            field.set(bean, convertedValue);
        }
    }

    // 参数注入逻辑
    private class ConfigParamInjector extends InjectionMetadata.InjectedElement {
        private final Method method;
        private final int paramIndex;
        private final Configuration configAnno;

        ConfigParamInjector(Method method, int paramIndex, Configuration configAnno) {
            super(method, null);
            this.method = method;
            this.paramIndex = paramIndex;
            this.configAnno = configAnno;
        }

        @Override
        protected void inject(Object bean, String beanName, PropertyValues pvs) throws Throwable {
            String configKey = configAnno.value();
            String rawValue = environment.getProperty(configKey);

            if (rawValue == null) {
                if (configAnno.required()) {
                    throw new IllegalArgumentException("Missing required config: " + configKey);
                }
                return;
            }

            Object convertedValue = convertValue(rawValue, method.getParameterTypes()[paramIndex]);
            ReflectionUtils.makeAccessible(method);
            // 构造注入时需处理所有参数，此处简化为单参数示例，多参数需扩展
            method.invoke(bean, convertedValue);
        }
    }

    // 基础类型转换工具
    private Object convertValue(String rawValue, Class<?> targetType) {
        if (targetType == String.class) return rawValue;
        if (targetType == Integer.class || targetType == int.class) return Integer.parseInt(rawValue);
        if (targetType == Boolean.class || targetType == boolean.class) return Boolean.parseBoolean(rawValue);
        if (targetType == Long.class || targetType == long.class) return Long.parseLong(rawValue);
        // 如需支持更多类型，可引入Spring的ConversionService
        throw new IllegalArgumentException("Unsupported type: " + targetType.getName());
    }
}

方案二：结合@Qualifier与原型Bean生产者 #

让@Configuration继承@Qualifier，通过原型Bean的生产者方法动态解析配置值。

步骤1：修改@Configuration注解 #

@Retention(RetentionPolicy.RUNTIME)
@Target({ElementType.FIELD, ElementType.METHOD, ElementType.PARAMETER})
@Qualifier // 让Spring将其视为限定符
public @interface Configuration {
    String value() default "";
}

步骤2：实现配置生产者 #

@Configuration
public class ConfigProducer {

    private final Environment environment;

    public ConfigProducer(Environment environment) {
        this.environment = environment;
    }

    // String类型配置生产者
    @Bean
    @Scope(ConfigurableBeanFactory.SCOPE_PROTOTYPE)
    @Configuration
    public String stringConfig(InjectionPoint injectionPoint) {
        Configuration anno = getConfigAnnotation(injectionPoint);
        return environment.getProperty(anno.value());
    }

    // Integer类型配置生产者
    @Bean
    @Scope(ConfigurableBeanFactory.SCOPE_PROTOTYPE)
    @Configuration
    public Integer integerConfig(InjectionPoint injectionPoint) {
        Configuration anno = getConfigAnnotation(injectionPoint);
        String value = environment.getProperty(anno.value());
        return value != null ? Integer.parseInt(value) : null;
    }

    // 通用方法：获取注入点上的@Configuration注解
    private Configuration getConfigAnnotation(InjectionPoint injectionPoint) {
        // 先从注入元素本身获取
        Configuration anno = injectionPoint.getAnnotatedElement().getAnnotation(Configuration.class);
        if (anno != null) return anno;
        // 再从方法参数获取
        if (injectionPoint.getMethodParameter() != null) {
            return injectionPoint.getMethodParameter().getParameterAnnotation(Configuration.class);
        }
        // 最后从字段获取
        if (injectionPoint.getField() != null) {
            return injectionPoint.getField().getAnnotation(Configuration.class);
        }
        throw new IllegalArgumentException("No @Configuration annotation found on injection point");
    }
}

方案三：改进@Value别名（最简方案） #

如果只想让@Configuration作为@Value的别名自动补全${}，可以通过SpEL表达式实现：

@Retention(RetentionPolicy.RUNTIME)
@Target({ElementType.FIELD, ElementType.METHOD, ElementType.PARAMETER})
@Value("#{'${' + #value + '}'}")
public @interface Configuration {
    @AliasFor(annotation = Value.class, attribute = "value")
    String value() default "";
}

此方案无需额外处理器，直接利用Spring的SpEL解析能力，将注解值自动包装为${key}格式。

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