Question

I’m attempting to implement a package-scanning feature, similar to Spring’s component-scan, for the Android framework I’m developing. Basically, I would like to be able to specify a base package, e.g. com.foo.bar and retrieve all Class instances that have a particular annotation. I don’t want to have to register every component with my framework as that would defeat the purpose of the auto scanning.

Based on my research, it seems that it’s not possible with Java to retrieve resources given a package name using reflection. However, I briefly looked into the Reflections framework, and I’m wondering if there is an Android-compatible equivalent. If not, perhaps there is a slightly less obvious way to accomplish what I want to do.

I looked into the Spring source a bit to see how they achieved this, but I don’t think what they are doing would work within the Dalvik runtime.

Update

Currently, the below code has been the best I can do to retrieve all classes that contain a specific annotation, but frankly it’s a pretty poor solution. It makes some really unsafe assumptions about the ClassLoader plus it scans (and loads) all application classes.

public Set<Class<?>> getClassesWithAnnotation(Class<? extends Annotation> annotation) {
    Set<Class<?>> classes = new HashSet<Class<?>>();
    Field dexField = PathClassLoader.class.getDeclaredField("mDexs");
    dexField.setAccessible(true);
    PathClassLoader classLoader = (PathClassLoader) Thread.currentThread().getContextClassLoader();
    DexFile[] dexs = (DexFile[]) dexField.get(classLoader);
    for (DexFile dex : dexs) {
        Enumeration<String> entries = dex.entries();
        while (entries.hasMoreElements()) {
            String entry = entries.nextElement();
            Class<?> entryClass = dex.loadClass(entry, classLoader);
            if (entryClass != null && entryClass.isAnnotationPresent(annotation)) {
                classes.add(entryClass);
            }
        }
    }
    return classes;
}

Answer 1

I share the opinion of Joop Eggen and find his approach a good one. In Android I try to avoid the usual web app features which lead to a long lasting application start. I do not use reflection or package scanning.

But if you want to …. if I understand it correctly you want to have an annotation for a class. Instead of using annotations you could also use marker interfaces (to just have more possibilites).

1) Look at

• Annotation: Java custom annotation and dynamic loading
  Has an implementation in the question which just answers your question.
• Annotation: Scanning Java annotations at runtime
• Interface: Find Java classes implementing an interface
• Interface: Is something similar to ServiceLoader in Java 1.5?
• Interface: How can I get a list of all the implementations of an interface programmatically in Java?
• Interface: Since the approach is expensive, maybe the ServiceLoader is a compromise between execution time and comfort, since it loads only the classes given in the services file. On the other hand if only classes with a certain interface are in your package then the ServiceLoader isn’t that faster.

2) AndroidAnnotations

I would prefer the way AndroidAnnotations work (maybe an integration in AndroidAnnotations is the preferable way): It automatically adds an extra compilation step that generates source code, using the standard Java Annotation Processing Tool. So instead of runtime scanning you execute code based on the annotations generated during compile time.

I think the Bean/EBean annotation could work for you (only single class): https://github.com/excilys/androidannotations/wiki/Enhance%20custom%20classes

A scan-feature is not available, see this thread

3) Writing your own annotation processor

• See APT (Annotation Processing Tool). The idea would be to generate a static function which returns a list of classes which are annotated, so that no class scanning is needed.
• A very good ressource is http://javadude.com/articles/annotations/index.html