Class inspection via reflection API. Use of custom annotations

Question

I have done my research before asking but no luck.

I have a StartUp Singleton bean. In this bean I have an @Inject @Any Instance. I loop all the implementations and try to check if the class is annotated with a custom annotation. All the implementations(all the classes that I want to inspect) are Stateful or Stateless beans. Sometime the class I want is found and I can perform getClass().isAnnotationPresent(ClassNameAnnotation.class)

Most of the times I get a proxy object and in this case I cannot perform the above check. I cannot find a way to get the real object. I have tried to get the SuperClass but not luck. I will attach some of the code so you can have a better idea.

@Singleton
@Startup
public class CacheLoader {

    @Inject
    @Any
    private Instance<ClassNameA> aClasses;

   .......

    @Lock(LockType.READ)
    public void evaluate() {

        if (!aClasses.isUnsatisfied()) {
            for (ClassNameA className : aClasses) {
                if (className.getClass().isAnnotationPresent(ClassNameAnnotation.class)) {
                    ....
                }
            }
        }
    }

}

I tried to use the SuperClass of the proxy object but it does not return what I want. I tried also via Proxy.getInvocationHandler(). Even when I check the methods Proxy.isProxyClass(getClass()) or isSynthetic() does not return that the object is a proxy.

Thank you!

Answer 1

I think you would be better served by using a CDI Portable Extension, rather than a Singleton EJB. A couple of reasons

• In CDI, everything is a proxy. So like some of the commenters have said, using reflection would be very fragile as it's not part of the spec. You're dealing with classes that are defined at runtime. It may work if you tie yourself to implementation-specific details, but it could break between releases of your CDI container.

• The CDI Container will do all of the annotation scanning for you:)

• A portable extension runs on startup, before other stuff starts flying around your app

A google search gave me this guide, but there are lots of them: https://www.baeldung.com/cdi-portable-extension

I think you would want to hook in processAnnotatedType() if you're modifying the bean declarations, or afterBeanDiscovery() if you're just documenting them as you said.

We actually have a CDI Portable Extension we use internally that does some config magic for environments. One of the config params is an annotation that is not a qualifier annotation, which sounds like what you want... the CDI container can get you the type, from which you can inspect the annotations.

Finally, this is not directed related to your question but may be useful: If your annotations drive configuration through fields of the annotations, selecting them can be quite complicated because of how the Java type and inheritance system works with annotations. You may benefit by using AnnotationLitreal in those cases. Read up here on this useful utility class here: http://www.kurtsparber.de/?p=387

EDIT: Another side note... even thought I think you should switch to a Portable Extension, you shouldn't need @EJB's Singleton Startup anymore: you can do this with pure CDI: https://rmannibucau.wordpress.com/2015/03/10/cdi-and-startup/