注释一个Spring Boot引导类并在其他地方实现注释

Question

I want to do something like the following:-

@Retention(RetentionPolicy.RUNTIME)
@Target(ElementType.TYPE)
public @interface MyCustomAnnotation {
    public String field1();
    public String[] list1();
}

@SpringBootApplication
@MyCustomAnnotation(field1 = "value1", list1 = { "list value 1", "list value2" })
public class Application {
    public static void main(String[] args){
        SpringApplication.run(Application.class, args);
    }
}

public class AnnotationImplementationClass {
    // Inject field1 and list1 values from @MyCustomAnnotation into this class
    private String field1;
    private String[] list1;
}

I want to isolate the AnnotationImplementationClass from the annotated class so that I can package and distribute the custom annotation and its implementation, thus allowing developers to annotate their own spring boot application class with @MyCustomAnnotation.

The constraints are that I will not know the class name for the spring boot class (in this case Application.java) and obviously I will not have access to this class to alter it. I must somehow gain access at runtime so that I can use reflection to obtain the values within the custom annotation.

I have researched examples that attempt to demonstrate the use of BeanPostProcessor but I have been unable to locate the @MyCustomAnnotation when it is applied to the java class containing @SpringBootApplication.

Answer 1

Spring Boot Starter Classes contain "public static void main(String[] args)" method. you can refer the container class by reflection.

It would maybe help you.I don't know how can your goal be done. but your custom annotation should be scanned with highest priority.

Answer 2

I was finally able to resolve this myself. The following is my solution:-

@Retention(RetentionPolicy.RUNTIME)
@Target(ElementType.TYPE)
@Import(AnnotationImplementationClass.class)
public @interface MyCustomAnnotation {
    public String field1();
    public String[] list1();
}


@SpringBootApplication
@MyCustomAnnotation(field1 = "field1 value", list1 = { "list1 value 1", "list1 value 2" })
public class Application
{
    public static void main(String[] args)
    {
        SpringApplication.run(Application.class, args);
    }
}

public class AnnotationImplementationClass implements ApplicationContextAware
{
    private String field1;
    private String[] list1;

    @Override
    public void setApplicationContext(ApplicationContext applicationContext) throws BeansException
    {
        // Grab the beans from the app context that are annotated with my custom annotation
        Map<String, Object> beanMap = applicationContext.getBeansWithAnnotation(MyCustomAnnotation.class);
        Collection<Object> beans = beanMap.values();

        // There is a possibility that multiple beans are annotated with the annotation. I only annotated one bean
        // but I am using a "for" loop for illustration.
        for (Object bean : beans)
        {
            // Spring annotated classes are often proxied when Spring is initializing. I found that I was unable to get
            // the annotation and its parameter values from the proxy instance. I need to find the actual class that was
            // annotated using the the proxy as a start point. The following "if" clause illustrates the process.
            Class<? extends Object> annotatedClass = null;
            if (bean instanceof TargetClassAware)
            {
                annotatedClass = ((TargetClassAware) bean).getTargetClass();
            }
            else if (ClassUtils.isCglibProxy(bean))
            {
                annotatedClass = bean.getClass().getSuperclass();
            }
            else
            {
                annotatedClass = bean.getClass();
            }

            // Now I can get the annotation and its parameter values
            MyCustomAnnotation annotation = annotatedClass.getAnnotation(MyCustomAnnotation.class);
            field1 = annotation.field1();
            list1 = annotation.list1();

            // Since I only want one of the classes annotated by my custom annotation I break out of the loop
            break;
        }
    }
}

A couple of points to note:-

• The use of @Import on the custom annotation interface. This allowed me to hook the implementation class into the Spring context. Not sure if this is a correct use of @Import but it was key to my eventual solution.
• The use of "implements ApplicationContextAware" on the implementation class. This provided an entry point for me to take control during Spring initialization.

Hope this helps someone else.