Overview | Package | Class | Use | Tree | Deprecated | Index | Help
PREV CLASS NEXT CLASS | FRAMES NO FRAMES
SUMMARY: NESTED | FIELD | CONSTR | METHOD | DETAIL: FIELD | CONSTR | METHOD

## com.opensymphony.xwork2.util
Class ResolverUtil<T>

    java.lang.Object
      com.opensymphony.xwork2.util.ResolverUtil<T>

    public class ResolverUtil<T>

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(com.opensymphony.xwork2.util.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<ActionBean> resolver = new ResolverUtil<ActionBean>();
    resolver.findImplementation(ActionBean.class, pkg1, pkg2);
    resolver.find(new CustomTest(), pkg1);
    resolver.find(new CustomTest(), pkg2);
    Collection<ActionBean> beans = resolver.getClasses();

This class was copied from Stripes - http://stripes.mc4j.org/confluence/display/stripes/Home

Author:
  Tim Fennell

Nested Class Summary
`static class` | `ResolverUtil.AnnotatedWith` A Test that checks to see if each class is annotated with a specific annotation.
`static class` | `ResolverUtil.IsA` A Test that checks to see if each class is assignable to the provided class.
`static class` | `ResolverUtil.NameEndsWith` A Test that checks to see if each class name ends with the provided suffix.
`static interface` | `ResolverUtil.Test` A simple interface that specifies how to test classes to determine if they are to be included in the results produced by the ResolverUtil.

Field Summary
`private ClassLoader` | `classloader` The ClassLoader to use when looking for classes.
`private static Log` | `log` An instance of Log to use for logging in this class.
`private Set<Class<? extends T>>` | `matches` The set of matches being accumulated.

Constructor Summary
`ResolverUtil()`

Method Summary
`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.
`void` | `find(ResolverUtil.Test test, String... packageNames)` Attempts to discover classes that pass the test.
`void` | `findAnnotated(Class<? extends Annotation> annotation, String... packageNames)` Attempts to discover classes that are annotated with to the annotation.
`void` | `findImplementations(Class parent, String... packageNames)` Attempts to discover classes that are assignable to the type provided.
`void` | `findInPackage(ResolverUtil.Test test, String packageName)` Scans for classes starting at the package provided and descending into subpackages.
`void` | `findSuffix(String suffix, String... packageNames)` Attempts to discover classes who's name ends with the provided suffix.
`Set<Class<? extends T>>` | `getClasses()` Provides access to the classes discovered so far.
`ClassLoader` | `getClassLoader()` Returns the classloader that will be used for scanning for classes.
`private void` | `loadImplementationsInDirectory(ResolverUtil.Test test, String parent, File location)` Finds matches in a physical directory on a filesystem.
`private void` | `loadImplementationsInJar(ResolverUtil.Test test, String parent, File jarfile)` Finds matching classes within a jar files that contains a folder structure matching the package structure.
`void` | `setClassLoader(ClassLoader classloader)` Sets an explicit ClassLoader that should be used when scanning for classes.

Methods inherited from class java.lang.Object
`clone, equals, finalize, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait`

Field Detail

### log

    private static final Log log

  An instance of Log to use for logging in this class.

### matches

    private Set<Class<? extends T>> matches

  The set of matches being accumulated.

### classloader

    private ClassLoader classloader

  The ClassLoader to use when looking for classes. If null then the ClassLoader returned by Thread.currentThread().getContextClassLoader() will be used.

Constructor Detail

### ResolverUtil

    public ResolverUtil()

Method Detail

### getClasses

    public Set<Class<? extends T>> 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.

  Returns:
    the set of classes that have been discovered.

### 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.

  Returns:
    the ClassLoader that will be used to scan for classes

### setClassLoader

    public void setClassLoader(ClassLoader classloader)

  Sets an explicit ClassLoader that should be used when scanning for classes. If none is set then the context classloader will be used.

  Parameters:
    `classloader` - a ClassLoader to use when scanning for classes

### findImplementations

    public void findImplementations(Class parent,
                                    String... packageNames)

  Attempts to discover classes that are assignable to the type provided. In the case that an interface is provided this method will collect implementations. In the case of a non-interface class, subclasses will be collected. Accumulated classes can be accessed by calling `getClasses()`.

  Parameters:
    `parent` - the class of interface to find subclasses or implementations of
    `packageNames` - one or more package names to scan (including subpackages) for classes

### findSuffix

    public void findSuffix(String suffix,
                           String... packageNames)

  Attempts to discover classes who's name ends with the provided suffix. Accumulated classes can be accessed by calling `getClasses()`.

  Parameters:
    `suffix` - The class name suffix to match
    `packageNames` - one or more package names to scan (including subpackages) for classes

### findAnnotated

    public void findAnnotated(Class<? extends Annotation> annotation,
                              String... packageNames)

  Attempts to discover classes that are annotated with to the annotation. Accumulated classes can be accessed by calling `getClasses()`.

  Parameters:
    `annotation` - the annotation that should be present on matching classes
    `packageNames` - one or more package names to scan (including subpackages) 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()`.

  Parameters:
    `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()`.

  Parameters:
    `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`

### loadImplementationsInDirectory

    private void loadImplementationsInDirectory(ResolverUtil.Test test,
                                                String parent,
                                                File location)

  Finds matches in a physical directory on a filesystem. Examines all files within a directory - if the File object is not a directory, and ends with .class the file is loaded and tested to see if it is acceptable according to the Test. Operates recursively to find classes within a folder structure matching the package structure.

  Parameters:
    `test` - a Test used to filter the classes that are discovered
    `parent` - the package name up to this directory in the package hierarchy. E.g. if /classes is in the classpath and we wish to examine files in /classes/org/apache then the values of parent would be org/apache
    `location` - a File object representing a directory

### loadImplementationsInJar

    private void loadImplementationsInJar(ResolverUtil.Test test,
                                          String parent,
                                          File jarfile)

  Finds matching classes within a jar files that contains a folder structure matching the package structure. If the File is not a JarFile or does not exist a warning will be logged, but no error will be raised.

  Parameters:
    `test` - a Test used to filter the classes that are discovered
    `parent` - the parent package under which classes must be in order to be considered
    `jarfile` - the jar file to be examined for classes

### 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.

  Parameters:
    `test` - the test used to determine if the class matches
    `fqn` - the fully qualified name of a class

Overview | Package | Class | Use | Tree | Deprecated | Index | Help
PREV CLASS NEXT CLASS | FRAMES NO FRAMES
SUMMARY: NESTED | FIELD | CONSTR | METHOD | DETAIL: FIELD | CONSTR | METHOD

Copyright © 2007 OpenSymphony. All Rights Reserved.