public class ResolverUtil extends Object

ResolverUtil is used to locate classes that are available in the/a class path and meet arbitrary conditions. The two most common conditions are that a class implements/extends another class, or that is it annotated with a specific annotation. However, through the use of the ResolverUtil.Test class it is possible to search using arbitrary conditions.

A ClassLoader is used to locate all locations (directories and jar files) in the class path that contain classes within certain packages, and then to load those classes and check them. By default the ClassLoader returned by Thread.currentThread().getContextClassLoader() is used, but this can be overridden by calling setClassLoader(ClassLoader) prior to invoking any of the find() methods.

General searches are initiated by calling the find(ResolverUtil.Test, String...) method and supplying a package name and a Test instance. This will cause the named package and all sub-packages to be scanned for classes that meet the test. There are also utility methods for the common use cases of scanning multiple packages for extensions of particular classes, or classes annotated with a specific annotation.

The standard usage pattern for the ResolverUtil class is as follows:

 ResolverUtil resolver = new ResolverUtil();
 resolver.findInPackage(new CustomTest(), pkg1);
 resolver.find(new CustomTest(), pkg1);
 resolver.find(new CustomTest(), pkg1, pkg2);
 Set<Class<?>> beans = resolver.getClasses();

This class was copied and modified from Stripes -

  • Constructor Details

    • ResolverUtil

      public ResolverUtil()
  • Method Details

    • getClasses

      public Set<Class<?>> getClasses()
      Provides access to the classes discovered so far. If no calls have been made to any of the find() methods, this set will be empty.
      the set of classes that have been discovered.
    • getResources

      public Set<URI> getResources()
      Returns the matching resources.
      A Set of URIs that match the criteria.
    • getClassLoader

      public ClassLoader getClassLoader()
      Returns the ClassLoader that will be used for scanning for classes. If no explicit ClassLoader has been set by the calling, the context class loader will be used.
      the ClassLoader that will be used to scan for classes
    • setClassLoader

      public void setClassLoader(ClassLoader aClassloader)
      Sets an explicit ClassLoader that should be used when scanning for classes. If none is set then the context ClassLoader will be used.
      aClassloader - a ClassLoader to use when scanning for classes
    • find

      public void find(ResolverUtil.Test test, String... packageNames)
      Attempts to discover classes that pass the test. Accumulated classes can be accessed by calling getClasses().
      test - the test to determine matching classes
      packageNames - one or more package names to scan (including subpackages) for classes
    • findInPackage

      public void findInPackage(ResolverUtil.Test test, String packageName)
      Scans for classes starting at the package provided and descending into subpackages. Each class is offered up to the Test as it is discovered, and if the Test returns true the class is retained. Accumulated classes can be fetched by calling getClasses().
      test - an instance of ResolverUtil.Test that will be used to filter classes
      packageName - the name of the package from which to start scanning for classes, e.g. net.sourceforge.stripes
    • addIfMatching

      protected void addIfMatching(ResolverUtil.Test test, String fqn)
      Add the class designated by the fully qualified class name provided to the set of resolved classes if and only if it is approved by the Test supplied.
      test - the test used to determine if the class matches
      fqn - the fully qualified name of a class