How to scan for a particular annotation of java classes loaded at runtime as a bytecode?

Question

1. If a java class loaded at runtime as a bytecode (e.g. via ASM library or other mechanism), is it on a classpath of java? I don't see it.
2. How to scan all annotations of classes loaded this way, if it's not on the java classpath?

I use google reflections and a custom classloader of a 3-rd party library.

Scanning for classes works as follows:

            Reflections reflections = new Reflections(ClasspathHelper.forPackage("com.mypackage",
                    MyCustomClassLoader),
                    new SubTypesScanner(), new TypeAnnotationsScanner());
Set<Class<?>> myClasses = reflections.getTypesAnnotatedWith(MyAnnotation.class);

MyAnnotation - is marked as @Retention(RetentionPolicy.RUNTIME). The above (in a class) is loaded dynamically at runtime by JVM.

As can be seen, behind the scenes, Reflections tries to get all URLs to be scanned using 2 classloaders by default static and context.

Reflection.scan()

Update: I have found an answer Can you find all classes in a package using reflection? saying that "If there are classes that get generated, or delivered remotely, you will not be able to discover those classes." But there is no proof, however. Can please anybody give more details on this and confirm?

Answer 1

Dynamically instantiating classes at run time does not change the classpath that your JVM is using. What happens is that some ClassLoader class fetches bytecode from somewhere; and makes it "available" to you. But that does in no way change the "search order" for loading classes (and that is basically what the classpath is about: it only tells the JVM where and in which order to look for classes to load).

Meaning: any "loading" of a class results in some object of class java.lang.Class.

If you want to query the structure of any loaded class; you "just" need to get to the corresponding Class object. Class provides methods like getAnnotation(). It also provides methods to retrieve other objects that represent the methods and fields of the specific Class; and those objects can be queried for annotations in similar ways.

Update, regarding the updates in the question: there are situations where you don't have access to the file system where classes are coming from. You can load classes, when you know their name, but you have no way looking into the "place" where these classes live. And that basically breaks your ability to use reflection as intended.

There is no need to "prove" that, it is simply a consequence of the fact that Java allows you to load classes when you know there name, but "hides" the exact content of "where" those classes are coming from.