Comment trouver des méthodes annotées dans un package donné?

J'ai un simple marqueur d'annotation pour les méthodes (similaire à la première exemple à l'Article 35 dans Efficace Java (2e éd)):

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

Puis, dans un package donné (disons com.acme.installer), qui a un peu sous-paquets contenant des 20 classes, je voudrais trouver toutes les méthodes annotées avec elle. (Parce que j'aimerais faire quelques vérifications concernant toutes les méthodes annotées dans un test unitaire.)

Quel est le moyen le plus facile de faire cela? De préférence sans l'ajout de nouveau 3ème partie les bibliothèques ou les cadres.

Modifier: pour clarifier, évidemment method.isAnnotationPresent(InstallerMethod.class) sera le moyen de vérifier si une méthode a l'annotation - mais ce problème consiste notamment à trouver toutes les méthodes.

  • Vérifier stackoverflow.com/questions/520328/...
  • Hmm, ouais, je suppose que cela revient à remettre en question (qui je l'ai demandé en février). 😛 Mais attendu que le droit de réponse a été "non, il ne peut être fait à l'aide de la réflexion", ici, la question est de savoir comment trouver annoté méthodes plus facilement, en utilisant tous les moyens...
  • Parce que la partie la plus difficile ici n'est pas vraiment liée à des annotations (mais de trouver des classes de colis), cette question n'est pas aussi pertinente que je ne le pensais. :/ Bon, peut-être que cela pourrait aider quelqu'un à interroger à propos de la même chose...
InformationsquelleAutor Jonik | 2009-05-14
  1. 50

    Si vous souhaitez mettre en place vous-même, ces méthodes trouverez toutes les classes dans un package donné:

    /**
* 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;
}

    Alors vous pouvez simplement le filtre sur ces classes d'annotation:

    for (Method method : testClass.getMethods())
{
if (method.isAnnotationPresent(InstallerMethod.class))
{
//do something
}
}
    • Merci! À l'aide de ce que j'étais capable de faire ce que je voulais. C'est à peu près le code, mais peut-être il n'est tout simplement pas un moyen plus simple (sans les libs externes), avec chargeur de classe de travail, la façon dont il le fait.
    • Il est intéressant de noter similaire à snippets.dzone.com/posts/show/4831
    • Merci pour le partage. J'ai utilisé ce code pour mon propre solution, bien que d'autres, doivent prendre note que plus de travail est nécessaire si vous êtes à la recherche pour les classes dans un fichier JAR.
    • Je suis intéressé exactement dans la recherche de classes à l'intérieur des fichiers jar. Pourriez-vous me donner des conseils sur le travail supplémentaire nécessaire?
    • Cette solution n'est pas de travail après l'exportation du projet exécutable jar....
    • L'extrait de code n'est plus à votre lien.

    InformationsquelleAutor parkr
  2. 35

    Vous devriez probablement prendre un coup d'oeil à l'open source Les réflexions de la bibliothèque. Avec elle, vous pouvez facilement obtenir ce que vous voulez avec quelques lignes de code:

    Reflections reflections = new Reflections( 
new ConfigurationBuilder().setUrls( 
ClasspathHelper.forPackage( "com.acme.installer" ) ).setScanners(
new MethodAnnotationsScanner() ) );
Set<Method> methods = reflections.getMethodsAnnotatedWith(InstallerMethod.class);
    • Êtes-vous sûr que cela fonctionne? L'essayer, je ne le pense pas. J'ai dû mettre le scanner dans les Réflexions constructeur de la classe pour le faire fonctionner, comme ceci: Reflections reflections = new Reflections( new ConfigurationBuilder().setUrls( ClasspathHelper.forPackage( "com.acme.installer" ) ).setScanners( new MethodAnnotationsScanner() ) );
    • Oh, vous avez raison, mon original de l'extrait de code n'a pas fonctionné. Merci de me le faire savoir!
    InformationsquelleAutor Aleksander Blomskøld
  3. 1

    Si vous êtes heureux d'utiliser le Printemps, alors que quelque chose le long de ces lignes à l'aide de son context:component-scan de la fonctionnalité, où le Printemps des scans pour annoté classes dans un package donné. Sous les couvertures, c'est assez horrible, et implique d'arrachage sur le système de fichiers et les fichiers JAR à la recherche pour les classes dans le package.

    Même si vous ne pouvez pas utiliser le Printemps directement, après avoir jeter un oeil par le biais de son code source peut vous donner quelques idées.

    Certes, la réflexion Java APi n'est d'aucune utilité ici, mais il ne fournit pas un moyen pour obtenir toutes les classes dans un package.

    • Merci. Hmm, tu dis "Printemps des scans pour annoté classes" - pouvez-vous utiliser dans ce cas où nous sommes à la recherche pour annoté méthode, même dans les classes sans annotations? Ou, alternativement, si vous souhaitez mettre en œuvre une méthode comme getClasses(String packageName) à partir de parkr de répondre, en faisant usage de Printemps, pourrait-il être fait beaucoup plus simple?
    • Le Printemps du code des looks pour toutes les classes de ce package, et puis regarde pour la classe et au niveau de la méthode des annotations. Vous pouvez être en mesure de faire plus simple dans certains environnements, mais pas énormement donc.
    InformationsquelleAutor skaffman