Classpath scanning in OSGi

Question

My project has a set of custom defined annotations that could be present in any bundle deployed in the OSGi 4.3 framework. I want to find any class with these annotations in the classpath. I tried using BundleWiring.listResources(...) and Bundle.loadClass(...) for each class found. I have done some tests with an small set of bundles and it needs almost 200MB of Permanent Generation JVM memory space because all classes are loaded.

Is there a way to free loaded classes PermGen memory space when the program realizes that they does not have these annotations?

Is there a better way to look for annotated classes in an OSGi framework?

Answer 1

I think you should not do annotation scanning as it slows down startup and needs a lot of memory. JEE application servers do annotation scanning at startup to make lazy programmers happy and the result is very annoying (e.g. scan for JPA or EJB annotations).

I guess you are implementing a technology where you can define the rules. I suggest that you should define rules that are similar to these:

• Annotate your class
• Have a MANIFEST header where the annotated class must be listed.

An even better solution can be to use a custom capability namespace with specified attributes. E.g.:

Provide-Capability: myNamespace;classes=com.foo.myClass1,com.foo.myClass2

In your technology, you should write a BundleTracker that calls:

BundleWiring.getCapabilities("myNamespace");

If the namespace is present, you can find the classes that should be processed.

If you implemented the technology, you can consider an extension to Bnd to fill that MANIFEST header automatically. That extension can be used than when bnd is started from the command line or from build tools like maven.

Btw.: You can use ASM to parse the class bytecode or use the built in possibility of Java to build up AST. Although those could work to solve the memory issue, I still think that you should define the list of classes directly in the MANIFEST header as it makes things much more clear. You can read the MANIFEST headers, you can check the capabilities on webconsole but you cannot do the same with bytecode.

Answer 2

Usually, classpath scanning for annotations is a bad idea in an OSGi context, as the classpath is more like a graph. However, there are situations where this can be useful. Hence, OSGi encourages the usage of the Whiteboard Pattern.

What you could possibly do is register each of these classes as services in the OSGi registry. Then, create a separate bundle that just tracks these services and transforms/manipulates them in some way. For example, this project scans for all classes annotated with @Path and @Provider annotations, and transforms them into Jersey REST APIs.