Аннотация интерфейса не принимает значение application.properties

Убедитесь, что аннотированный класс имеет аннотацию @Component вместе с @CustomAnnotation(foo = "${my.value}"), тогда Spring распознает этот класс как компонент Spring и сделает необходимые конфигурации для вставки значения.

Вы можете использовать ConfigurableBeanFactory.resolveEmbeddedValue для преобразования ${my.value} в значение в application.properties.

@CustomAnnotation(foo = "${my.value}")
@lombok.extern.slf4j.Slf4j
@Service
public class AnnotatedClass {

    @Autowired
    private ConfigurableBeanFactory beanFactory;

    public void foo()  {
        CustomAnnotation customAnnotation = AnnotatedClass.class.getAnnotation(CustomAnnotation.class);
        String fooValue = customAnnotation.foo().toString();
        String value = beanFactory.resolveEmbeddedValue(fooValue);
        log.info(value);
    }
}

Если вы также хотите разрешать выражения, вам следует рассмотреть возможность использования EmbeddedValueResolver.

    EmbeddedValueResolver resolver = new EmbeddedValueResolver(beanFactory);
    final String value = resolver.resolveStringValue(fooValue);

Вы не можете сделать что-то подобное напрямую как annotation attribute's value must be a constant expression.

Что вы можете сделать, так это передать значение foo в виде строки, такой как @CustomAnnotation(foo = "my.value"), и создать AOP совета для получения значения строки аннотации и поиска в свойствах приложения.

создайте АОП с @Pointcut, @AfterReturn или предоставленными другими для сопоставления @annotation, метода и т. д. и запишите свою логику в свойство поиска для соответствующей строки.

1. Настройте @EnableAspectJAutoProxy в основном приложении или настройте классом конфигурации.

2. Добавить зависимость aop: spring-boot-starter-aop

3. Создайте @Aspect с помощью pointcut.

   @Aspect
   public class CustomAnnotationAOP {
   
   
   @Pointcut("@annotation(it.federicogatti.annotationexample.annotationexample.annotation.CustomAnnotation)")
    //define your method with logic to lookup application.properties
   

Подробности смотрите в официальном руководстве: Аспектно-ориентированное программирование с помощью Spring

Подход на основе Spring Core

Прежде всего, я хочу показать вам автономное приложение, которое не использует возможности автоматической настройки Spring Boot. Надеюсь, вы оцените, как много делает для нас Spring.

Идея состоит в том, чтобы настроить ConfigurableBeanFactory с StringValueResolver, который будет знать наш контекст (в частности, свойства application.yaml).

class Application {

    public static void main(String[] args) {
        // read a placeholder from CustomAnnotation#foo
        // foo = "${my.value}"
        CustomAnnotation customAnnotation = AnnotatedClass.class.getAnnotation(CustomAnnotation.class);
        String foo = customAnnotation.foo();

        // create a placeholder configurer which also is a properties loader
        // load application.properties from the classpath
        PropertySourcesPlaceholderConfigurer configurer = new PropertySourcesPlaceholderConfigurer();
        configurer.setLocation(new ClassPathResource("application.properties"));

        // create a factory which is up to resolve embedded values
        // configure it with our placeholder configurer
        ConfigurableListableBeanFactory factory = new DefaultListableBeanFactory();
        configurer.postProcessBeanFactory(factory);

        // resolve the value and print it out
        String value = factory.resolveEmbeddedValue(foo);
        System.out.println(value);
    }

}

@Target(ElementType.TYPE)
@Retention(RetentionPolicy.RUNTIME)
@interface CustomAnnotation {

    String foo() default "foo";

}

@CustomAnnotation(foo = "${my.value}")
class AnnotatedClass {}

Подход на основе Spring Boot

Теперь я продемонстрирую, как это сделать в приложении Spring Boot.

Мы собираемся внедрить ConfigurableBeanFactory (который уже настроен) и разрешить значение аналогично предыдущему фрагменту.

@RestController
@RequestMapping("api")
public class MyController {

    // inject the factory by using the constructor
    private ConfigurableBeanFactory factory;

    public MyController(ConfigurableBeanFactory factory) {
        this.factory = factory;
    }

    @GetMapping(path = "/foo")
    public void foo() {
        CustomAnnotation customAnnotation = AnnotatedClass.class.getAnnotation(CustomAnnotation.class);
        String foo = customAnnotation.foo();

        // resolve the value and print it out
        String value = factory.resolveEmbeddedValue(foo);
        System.out.println(value);
    }

}

Мне не нравится смешивать низкоуровневые компоненты Spring, такие как BeanFactory, в коде бизнес-логики, поэтому я настоятельно рекомендую сузить тип до StringValueResolver и вместо этого внедрить его.

@Bean
public StringValueResolver getStringValueResolver(ConfigurableBeanFactory factory) {
    return new EmbeddedValueResolver(factory);
}

Вызываемый метод - resolveStringValue:

// ...
String value = resolver.resolveStringValue(foo);
System.out.println(value);

Подход на основе прокси

Мы могли бы написать метод, который генерирует прокси на основе типа интерфейса; его методы возвращали разрешенные значения.

Вот упрощенная версия сервиса.

@Service
class CustomAnnotationService {

    @Autowired
    private StringValueResolver resolver;

    public <T extends Annotation> T getAnnotationFromType(Class<T> annotation, Class<?> type) {
        return annotation.cast(Proxy.newProxyInstance(ClassLoader.getSystemClassLoader(), new Class<?>[]{annotation},
                ((proxy, method, args) -> {
                    T originalAnnotation = type.getAnnotation(annotation);
                    Object originalValue = method.invoke(originalAnnotation);

                    return resolver.resolveStringValue(originalValue.toString());
                })));
    }

}

Внедрите службу и используйте ее следующим образом:

CustomAnnotation customAnnotation = service.getAnnotationFromType(CustomAnnotation.class, AnnotatedClass.class);
System.out.println(customAnnotation.foo());

Вы можете посмотреть на Spring RequestMappingHandlerMapping, чтобы увидеть, как они это делают, который использует EmbeddedValueResolver. Вы можете внедрить bean-фабрику в любой компонент Spring, а затем использовать ее для создания собственного преобразователя:

@Autowired
public void setBeanFactory(ConfigurableBeanFactory beanFactory)
{
   this.embeddedValueResolver = new EmbeddedValueResolver(beanFactory);

   CustomAnnotation customAnnotation = AnnotatedClass.class.getAnnotation(CustomAnnotation.class);
   String fooValue = customAnnotation.foo();
   System.out.println("fooValue = " + fooValue);
   String resolvedValue = embeddedValueResolver.resolveStringValue(fooValue);
   System.out.println("resolvedValue = " + resolvedValue);
}

Предполагая, что вы установили foo.value=hello в своих свойствах, результат будет выглядеть примерно так:

fooValue = ${foo.value}
resolvedValue = hello

Я тестировал это с помощью Spring Boot 2.0.2, и он работал, как ожидалось.

Имейте в виду, что это минимальный пример. Вы хотели бы обрабатывать случаи ошибок, связанных с отсутствием аннотаций в классе и отсутствующим разрешенным значением (если значение не установлено и нет значения по умолчанию).

Чтобы прочитать свойство из application.propertie, нужно определить PropertyPlaceholderConfigurer и сопоставить его с файлом свойств.

Конфигурация на основе XML:

<bean class = "org.springframework.beans.factory.config.PropertyPlaceholderConfigurer">
  <property name = "ignoreUnresolvablePlaceholders" value = "true"/>
  <property name = "locations" value = "classpath:application.properties" />
</bean>

Для аннотаций: можно использовать, как показано ниже:

@Configuration
@PropertySource(  
value{"classpath:properties/application.properties"},ignoreResourceNotFound=true)
public class Config {

/**
 * Property placeholder configurer needed to process @Value annotations
 */
 @Bean
 public static PropertySourcesPlaceholderConfigurer propertyConfigurer() {
    return new PropertySourcesPlaceholderConfigurer();
 }
}