showmessagedialog - mostrar mensaje de error en java

¿Cómo encontrar métodos anotados en un paquete dado?

Question

Tengo una anotación de marcador simple para los métodos (similar al primer ejemplo en el ítem 35 en Effective Java (2nd ed))

/**
 * Marker annotation for methods that are called from installer''s 
 * validation scripts etc. 
 */
@Retention(RetentionPolicy.RUNTIME)
@Target(ElementType.METHOD)
public @interface InstallerMethod {
}

Luego, en un paquete dado (por ejemplo, com.acme.installer ), que tiene algunos subpaquetes que contienen unas 20 clases, me gustaría encontrar todos los métodos que están anotados con él. (Porque me gustaría hacer algunas verificaciones con respecto a todos los métodos anotados en una prueba unitaria).

¿Cuál es la forma más fácil de hacer esto? Preferiblemente sin agregar nuevas bibliotecas o marcos de terceros.

Edición : para aclarar, obviamente method.isAnnotationPresent(InstallerMethod.class) será la forma de verificar si un método tiene la anotación, pero este problema incluye encontrar todos los métodos.

Answer 1

Probablemente debería echar un vistazo a la biblioteca de código abierto de Reflections . Con él puedes lograr fácilmente lo que quieres con pocas líneas de código:

Reflections reflections = new Reflections( 
    new ConfigurationBuilder().setUrls( 
    ClasspathHelper.forPackage( "com.acme.installer" ) ).setScanners(
    new MethodAnnotationsScanner() ) );
Set<Method> methods = reflections.getMethodsAnnotatedWith(InstallerMethod.class);

Answer 2

Si desea implementarlo usted mismo, estos métodos encontrarán todas las clases en un paquete dado:

/**
 * Scans all classes accessible from the context class loader which belong
 * to the given package and subpackages.
 * 
 * @param packageName
 *            The base package
 * @return The classes
 * @throws ClassNotFoundException
 * @throws IOException
 */
private Iterable<Class> getClasses(String packageName) throws ClassNotFoundException, IOException
{
    ClassLoader classLoader = Thread.currentThread().getContextClassLoader();
    String path = packageName.replace(''.'', ''/'');
    Enumeration<URL> resources = classLoader.getResources(path);
    List<File> dirs = new ArrayList<File>();
    while (resources.hasMoreElements())
    {
        URL resource = resources.nextElement();
        URI uri = new URI(resource.toString());
        dirs.add(new File(uri.getPath()));
    }
    List<Class> classes = new ArrayList<Class>();
    for (File directory : dirs)
    {
        classes.addAll(findClasses(directory, packageName));
    }

    return classes;
}

/**
 * Recursive method used to find all classes in a given directory and
 * subdirs.
 * 
 * @param directory
 *            The base directory
 * @param packageName
 *            The package name for classes found inside the base directory
 * @return The classes
 * @throws ClassNotFoundException
 */
private List<Class> findClasses(File directory, String packageName) throws ClassNotFoundException
{
    List<Class> classes = new ArrayList<Class>();
    if (!directory.exists())
    {
        return classes;
    }
    File[] files = directory.listFiles();
    for (File file : files)
    {
        if (file.isDirectory())
        {
            classes.addAll(findClasses(file, packageName + "." + file.getName()));
        }
        else if (file.getName().endsWith(".class"))
        {
            classes.add(Class.forName(packageName + ''.'' + file.getName().substring(0, file.getName().length() - 6)));
        }
    }
    return classes;
}

Entonces puedes filtrar en esas clases con la anotación dada:

for (Method method : testClass.getMethods())
{
    if (method.isAnnotationPresent(InstallerMethod.class))
    {
        // do something
    }
}

Answer 3

Si está contento de usar Spring, entonces eso es algo que se usa en este contexto: la funcionalidad de exploración de componentes, donde Spring explora las clases anotadas en un paquete determinado. Debajo de las portadas, es bastante espantoso, e implica buscar en el sistema de archivos y en los archivos JAR en busca de clases en el paquete.

Incluso si no puede usar Spring directamente, echar un vistazo a su código fuente puede darle algunas ideas.

Ciertamente, la reflexión APi de Java no es útil aquí, específicamente no proporciona un medio para obtener todas las clases en un paquete.