Java : loop on all the classes in the classpath [duplicate]

Answer 1

If you use spring-context in your project: Here a working example to enumerate all types with the desired annotation:

/**
 * Lists all types in the given package (recursive) which are annotated by the given annotation.
 * <p>
 * All types which match the criteria are returned, no further checks (interface, abstract, embedded, etc.
 * are performed.
 * <p>
 *
 * @param aAnnotation
 *        the desired annotation type
 * @param aRoot
 *        the package name where to start the search.
 * @return a list of found types
 */
private Collection<? extends Class<?>> findCandidatesByAnnotation( Class<? extends Annotation> aAnnotation,
                                                                   String aRoot )
{
    List<Class<?>> result = new ArrayList<Class<?>>();

    ClassPathScanningCandidateComponentProvider scanner =
            new ClassPathScanningCandidateComponentProvider( false )
    {
        @Override
        protected boolean isCandidateComponent(AnnotatedBeanDefinition beanDefinition)
        {
            return true;
        }
    };

    scanner.addIncludeFilter( new AnnotationTypeFilter( aAnnotation ) );
    Set<BeanDefinition> canditates = scanner.findCandidateComponents( aRoot );
    for ( BeanDefinition beanDefinition : canditates )
    {
        try
        {
            String classname = beanDefinition.getBeanClassName();
            Class<?> clazz = Class.forName( classname );
            result.add( clazz );
        }
        catch ( ClassNotFoundException t )
        {
            myLog.error( "Springs type scanner returns a class name whose class cannot be evaluated!!!", t );
        }
    }

    return result;
}

This code was tested against spring-context-4.1.1.RELEASE under java 8.

Answer 2

I'm not aware of a library that does this, but there are open source projects that do this for their own purposes. For example, Spring can iterate over classes in the classpath to find ones that have a certain annotation. You could take a look at how they do it to get some ideas. I'd start with the classes in the org.springframework.context.annotation package such as ClassPathScanningCandidateComponentProvider and CommonAnnotationBeanPostProcessor.

Answer 3

you can't without a custom classloader.

think for example about a case where you load your classes from a remote server that does not even offer directory listing. how can you possibly iterate over all the classes there?

the classloader interface does not provide such a function. but if you use your own classloader (or extend an existing classloader) you could add this function. in any case, it's not pretty.

Answer 4

The Reflections library helps deal with this problem. As others have stated, it isn't fully possible in all class loading situations, but if all you have are jars and files, this will do it reliably.

Answer 5

I think you'll have to inspect it manually:

String classpath = System.getProperty("java.class.path");
String[] locations = classpath.split(System.getProperty("path.separator"));
// inspect all jar's and class files in these locations, which is a pain in the b%tt

Or use some third party library that does this (I don't know of any).

Answer 6

You can't do this elegantly.

Basically a classloader can be asked to load a specific class name, but can't be asked for all the classes it could load. (In the case of something loading classes over the web, it may not be feasible to do so - you can't reliably ask the web server to tell you all the files under a particular directory.)

If your classpath only deals with the file system, you could painfully find all the jar files in extension directories, recurse down normal classpath directories, and look inside all explicitly specified jar files - but it'll be tricky and probably fragile too.