Comment lire toutes les classes d'un package Java dans le chemin de classe?

J'ai besoin de lire les classes contenues dans un package Java. Ces classes sont dans classpath. Je dois effectuer cette tâche directement à partir d'un programme Java. Connaissez-vous une façon simple de faire?

List<Class> classes = readClassesFrom("my.package")

Si vous avez Spring dans votre classpath, ce qui suit le fera.

Recherchez toutes les classes d'un package annotées avec XmlRootElement:

private List<Class> findMyTypes(String basePackage) throws IOException, ClassNotFoundException
{
    ResourcePatternResolver resourcePatternResolver = new PathMatchingResourcePatternResolver();
    MetadataReaderFactory metadataReaderFactory = new CachingMetadataReaderFactory(resourcePatternResolver);

    List<Class> candidates = new ArrayList<Class>();
    String packageSearchPath = ResourcePatternResolver.CLASSPATH_ALL_URL_PREFIX +
                               resolveBasePackage(basePackage) + "/" + "**/*.class";
    Resource[] resources = resourcePatternResolver.getResources(packageSearchPath);
    for (Resource resource : resources) {
        if (resource.isReadable()) {
            MetadataReader metadataReader = metadataReaderFactory.getMetadataReader(resource);
            if (isCandidate(metadataReader)) {
                candidates.add(Class.forName(metadataReader.getClassMetadata().getClassName()));
            }
        }
    }
    return candidates;
}

private String resolveBasePackage(String basePackage) {
    return ClassUtils.convertClassNameToResourcePath(SystemPropertyUtils.resolvePlaceholders(basePackage));
}

private boolean isCandidate(MetadataReader metadataReader) throws ClassNotFoundException
{
    try {
        Class c = Class.forName(metadataReader.getClassMetadata().getClassName());
        if (c.getAnnotation(XmlRootElement.class) != null) {
            return true;
        }
    }
    catch(Throwable e){
    }
    return false;
}

Vous pouvez utiliser le projet Reflections décrit ici

C'est assez complet et facile à utiliser.

Brève description du site Web ci-dessus:

Reflections analyse votre chemin de classe, indexe les métadonnées, vous permet de l'interroger lors de l'exécution et peut enregistrer et collecter ces informations pour de nombreux modules de votre projet.

Exemple:

Reflections reflections = new Reflections(
    new ConfigurationBuilder()
        .setUrls(ClasspathHelper.forJavaClassPath())
);
Set<Class<?>> types = reflections.getTypesAnnotatedWith(Scannable.class);

J'utilise celui-ci, il fonctionne avec des fichiers ou des archives jar

public static ArrayList<String>getClassNamesFromPackage(String packageName) throws IOException{
    ClassLoader classLoader = Thread.currentThread().getContextClassLoader();
    URL packageURL;
    ArrayList<String> names = new ArrayList<String>();;

    packageName = packageName.replace(".", "/");
    packageURL = classLoader.getResource(packageName);

    if(packageURL.getProtocol().equals("jar")){
        String jarFileName;
        JarFile jf ;
        Enumeration<JarEntry> jarEntries;
        String entryName;

        // build jar file name, then loop through zipped entries
        jarFileName = URLDecoder.decode(packageURL.getFile(), "UTF-8");
        jarFileName = jarFileName.substring(5,jarFileName.indexOf("!"));
        System.out.println(">"+jarFileName);
        jf = new JarFile(jarFileName);
        jarEntries = jf.entries();
        while(jarEntries.hasMoreElements()){
            entryName = jarEntries.nextElement().getName();
            if(entryName.startsWith(packageName) && entryName.length()>packageName.length()+5){
                entryName = entryName.substring(packageName.length(),entryName.lastIndexOf('.'));
                names.add(entryName);
            }
        }

    // loop through files in classpath
    }else{
    URI uri = new URI(packageURL.toString());
    File folder = new File(uri.getPath());
        // won't work with path which contains blank (%20)
        // File folder = new File(packageURL.getFile()); 
        File[] contenuti = folder.listFiles();
        String entryName;
        for(File actual: contenuti){
            entryName = actual.getName();
            entryName = entryName.substring(0, entryName.lastIndexOf('.'));
            names.add(entryName);
        }
    }
    return names;
}

Spring a implémenté une excellente fonction de recherche de chemin de classe dans le PathMatchingResourcePatternResolver. Si vous utilisez le classpath*préfixe:, vous pouvez trouver toutes les ressources, y compris les classes dans une hiérarchie donnée, et même les filtrer si vous le souhaitez. Ensuite , vous pouvez utiliser les enfants AbstractTypeHierarchyTraversingFilter, AnnotationTypeFilteret AssignableTypeFilterde filtrer ces ressources soit sur les annotations au niveau de la classe ou sur les interfaces qu'ils mettent en œuvre.

Java 1.6.0_24:

public static File[] getPackageContent(String packageName) throws IOException{
    ArrayList<File> list = new ArrayList<File>();
    Enumeration<URL> urls = Thread.currentThread().getContextClassLoader()
                            .getResources(packageName);
    while (urls.hasMoreElements()) {
        URL url = urls.nextElement();
        File dir = new File(url.getFile());
        for (File f : dir.listFiles()) {
            list.add(f);
        }
    }
    return list.toArray(new File[]{});
}

Cette solution a été testée dans l' environnement EJB .

La numérotation et les réflexions utilisent une approche d'analyse de chemin de classe:

Reflections reflections = new Reflections("my.package");
Set<Class<? extends Object>> classes = reflections.getSubTypesOf(Object.class);

Une autre approche consiste à utiliser l' API Java Pluggable Annotation Processing pour écrire un processeur d'annotations qui collectera toutes les classes annotées au moment de la compilation et construira le fichier d'index pour une utilisation à l'exécution. Ce mécanisme est implémenté dans la bibliothèque ClassIndex :

Iterable<Class> classes = ClassIndex.getPackageClasses("my.package");

Cette fonctionnalité est toujours suspicieusement absente de l'API de réflexion Java pour autant que je sache. Vous pouvez obtenir un objet package en faisant simplement ceci:

Package packageObj = Package.getPackage("my.package");

Mais comme vous l'avez probablement remarqué, cela ne vous permettra pas de lister les classes dans ce package. Pour le moment, vous devez adopter une sorte d'approche plus orientée système de fichiers.

J'ai trouvé quelques exemples d'implémentations dans cet article

Je ne suis pas sûr à 100% que ces méthodes fonctionneront lorsque vos classes seront enterrées dans des fichiers JAR, mais j'espère que l'une d'elles le fera pour vous.

Je suis d'accord avec @skaffman ... si vous avez une autre façon de procéder, je vous recommande de le faire à la place.

Le mécanisme le plus robuste pour lister toutes les classes dans un package donné est actuellement ClassGraph , car il gère le plus large éventail possible de mécanismes de spécification de chemin de classe, y compris le nouveau système de modules JPMS. (Je suis l'auteur.)

List<String> classNames;
try (ScanResult scanResult = new ClassGraph().whitelistPackages("my.package")
        .enableClassInfo().scan()) {
    classNames = scanResult.getAllClasses().getNames();
}

eXtcos semble prometteur. Imaginez que vous vouliez trouver toutes les classes qui:

1. Étendez la classe "Component" et stockez-les
2. Sont annotés avec "MyComponent", et
3. Sont dans le package «commun».

Avec eXtcos, c'est aussi simple que

ClasspathScanner scanner = new ClasspathScanner();
final Set<Class> classStore = new ArraySet<Class>();

Set<Class> classes = scanner.getClasses(new ClassQuery() {
    protected void query() {
        select().
        from(“common”).
        andStore(thoseExtending(Component.class).into(classStore)).
        returning(allAnnotatedWith(MyComponent.class));
    }
});

1. Bill Burke a écrit un (bel article sur la numérisation de classe), puis il a écrit Scannotation .

2. Hibernate a déjà écrit ceci:

   • org.hibernate.ejb.packaging.Scanner
   • org.hibernate.ejb.packaging.NativeScanner

3. CDI pourrait résoudre ce problème, mais je ne sais pas - n'a pas encore étudié complètement

.

@Inject Instance< MyClass> x;
...
x.iterator() 

Aussi pour les annotations:

abstract class MyAnnotationQualifier
extends AnnotationLiteral<Entity> implements Entity {}

Je l'ai implémenté et cela fonctionne dans la plupart des cas. Comme il est long, je le mets dans un fichier ici .

L'idée est de trouver l'emplacement du fichier source de classe qui est disponible dans la plupart des cas (une exception connue sont les fichiers de classe JVM - pour autant que j'ai testé). Si le code se trouve dans un répertoire, parcourez tous les fichiers et repérez uniquement les fichiers de classe. Si le code se trouve dans un fichier JAR, analysez toutes les entrées.

Cette méthode ne peut être utilisée que lorsque:

1. Vous avez une classe qui se trouve dans le même package que vous souhaitez découvrir. Cette classe s'appelle une SeedClass. Par exemple, si vous souhaitez lister toutes les classes dans «java.io», la classe de départ peut être java.io.File.

2. Vos classes sont dans un répertoire ou dans un fichier JAR, il contient des informations sur le fichier source (pas un fichier de code source, mais juste un fichier source). Autant que j'ai essayé, cela fonctionne presque à 100% sauf la classe JVM (ces classes sont livrées avec la JVM).

3. Votre programme doit avoir l'autorisation d'accéder à ProtectionDomain de ces classes. Si votre programme est chargé localement, il ne devrait y avoir aucun problème.

J'ai testé le programme uniquement pour mon utilisation régulière, il peut donc toujours avoir des problèmes.

J'espère que ça aide.

Voici une autre option, légère modification d'une autre réponse ci-dessus / ci-dessous:

Reflections reflections = new Reflections("com.example.project.package", 
    new SubTypesScanner(false));
Set<Class<? extends Object>> allClasses = 
    reflections.getSubTypesOf(Object.class);

À l'époque où les applets étaient monnaie courante, on pouvait avoir une URL sur le chemin de classe. Lorsque le chargeur de classe a besoin d'une classe, il recherche tous les emplacements sur le chemin de classe, y compris les ressources http. Parce que vous pouvez avoir des choses comme des URL et des répertoires sur le chemin de classe, il n'y a pas de moyen facile d'obtenir une liste définitive des classes.

Cependant, vous pouvez vous en approcher assez. Certaines des bibliothèques Spring le font maintenant. Vous pouvez obtenir tous les fichiers JAR sur le chemin de classe et les ouvrir comme des fichiers. Vous pouvez ensuite prendre cette liste de fichiers, et créer une structure de données contenant vos classes.

utiliser la dépendance maven:

groupId: net.sf.extcos
artifactId: extcos
version: 0.4b

puis utilisez ce code:

ComponentScanner scanner = new ComponentScanner();
        Set classes = scanner.getClasses(new ComponentQuery() {
            @Override
            protected void query() {
                select().from("com.leyton").returning(allExtending(DynamicForm.class));
            }
        });

Brent - la raison pour laquelle l'association est à sens unique a à voir avec le fait que n'importe quelle classe sur n'importe quel composant de votre CLASSPATH peut se déclarer dans n'importe quel package (sauf pour java / javax). Ainsi, il n'y a tout simplement pas de mappage de TOUTES les classes dans un "package" donné parce que personne ne sait ni ne peut le savoir. Vous pouvez mettre à jour un fichier jar demain et supprimer ou ajouter des classes. C'est comme essayer d'obtenir une liste de toutes les personnes nommées John / Jon / Johan dans tous les pays du monde - aucun de nous n'est omniscient, donc aucun de nous n'aura jamais la bonne réponse.