Come leggo tutte le classi da un pacchetto Java nel classpath?

Ho bisogno di leggere le classi contenute in un pacchetto Java. Queste classi sono in classpath. Devo eseguire questa operazione direttamente da un programma Java. Conosci un modo semplice per farlo?

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

Se hai Spring nel tuo classpath, allora lo farà quanto segue.

Trova tutte le classi in un pacchetto annotate con 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;
}

Potresti usare il progetto Reflections descritto qui

È abbastanza completo e facile da usare.

Breve descrizione dal sito sopra:

Reflections esegue la scansione del percorso di classe, indicizza i metadati, consente di interrogarlo in fase di esecuzione e può salvare e raccogliere tali informazioni per molti moduli all'interno del progetto.

Esempio:

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

Io uso questo, funziona con file o archivi 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 ha implementato un'eccellente funzione di ricerca del percorso di classe in PathMatchingResourcePatternResolver . Se usi il classpath*prefisso:, puoi trovare tutte le risorse, comprese le classi in una data gerarchia, e persino filtrarle se vuoi. Quindi è possibile utilizzare i figli di AbstractTypeHierarchyTraversingFilter, AnnotationTypeFiltere AssignableTypeFilterper filtrare tali risorse sia a livello di classe annotazioni o su interfacce implementano.

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[]{});
}

Questa soluzione è stata testata all'interno dell'ambiente EJB .

Scannotation and Reflections utilizza l'approccio della scansione del percorso di classe:

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

Un altro approccio consiste nell'utilizzare l' API Java Pluggable Annotation Processing per scrivere un processore di annotazioni che raccoglierà tutte le classi annotate in fase di compilazione e creerà il file di indice per l'utilizzo in runtime. Questo meccanismo è implementato nella libreria ClassIndex :

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

Quella funzionalità è ancora sospettosamente mancante dall'API di riflessione Java, per quanto ne so. Puoi ottenere un oggetto pacchetto semplicemente facendo questo:

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

Ma come probabilmente avrai notato, questo non ti permetterà di elencare le classi in quel pacchetto. A partire da ora, devi adottare una sorta di approccio più orientato al filesystem.

Ho trovato alcune implementazioni di esempio in questo post

Non sono sicuro al 100% che questi metodi funzioneranno quando le tue classi saranno sepolte in file JAR, ma spero che uno di questi lo faccia per te.

Sono d'accordo con @skaffman ... se hai un altro modo per farlo, ti consiglio di farlo invece.

Il meccanismo più robusto per elencare tutte le classi in un dato pacchetto è attualmente ClassGraph , perché gestisce la più ampia gamma possibile di meccanismi di specificazione del percorso di classe , incluso il nuovo sistema di moduli JPMS. (Sono l'autore.)

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

eXtcos sembra promettente. Immagina di voler trovare tutte le classi che:

1. Estendi dalla classe "Component" e memorizzali
2. Sono annotati con "MyComponent" e
3. Sono nel pacchetto "comune".

Con eXtcos questo è semplice come

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 ha scritto un ( bell'articolo sulla scansione di classe] e poi ha scritto Scannotation .

2. Hibernate ha già scritto questo:

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

3. CDI potrebbe risolvere questo problema, ma non lo so - non ho ancora studiato a fondo

.

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

Anche per le annotazioni:

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

Mi è capitato di averlo implementato e funziona nella maggior parte dei casi. Dato che è lungo, lo metto in un file qui .

L'idea è di trovare la posizione del file di origine della classe che è disponibile nella maggior parte dei casi (un'eccezione nota sono i file di classe JVM, per quanto ho testato). Se il codice si trova in una directory, esamina tutti i file e individua solo i file di classe. Se il codice si trova in un file JAR, scansiona tutte le voci.

Questo metodo può essere utilizzato solo quando:

1. Hai una classe che si trova nello stesso pacchetto che vuoi scoprire, questa classe è chiamata SeedClass. Ad esempio, se desideri elencare tutte le classi in "java.io", la classe seed potrebbe essere java.io.File.

2. Le tue classi si trovano in una directory o in un file JAR che contiene informazioni sul file sorgente (non il file del codice sorgente, ma solo il file sorgente). Per quanto ho provato, funziona quasi al 100% tranne la classe JVM (quelle classi vengono con la JVM).

3. Il programma deve disporre dell'autorizzazione per accedere a ProtectionDomain di tali classi. Se il tuo programma è caricato localmente, non dovrebbero esserci problemi.

Ho testato il programma solo per il mio uso regolare, quindi potrebbe ancora avere problemi.

Spero che aiuti.

Ecco un'altra opzione, leggera modifica a un'altra risposta sopra / sotto:

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

Ai tempi in cui le applet erano un luogo comune, si poteva avere un URL sul classpath. Quando il programma di caricamento classi richiedeva una classe, cercava in tutte le posizioni sul percorso classi, comprese le risorse http. Poiché puoi avere cose come URL e directory sul classpath, non esiste un modo semplice per ottenere un elenco definitivo delle classi.

Tuttavia, puoi avvicinarti abbastanza. Alcune delle biblioteche di Spring lo stanno facendo adesso. Puoi ottenere tutti i jar sul classpath e aprirli come file. È quindi possibile prendere questo elenco di file e creare una struttura dati contenente le classi.

usa Esperto delle dipendenze:

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

quindi usa questo codice:

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

Brent: il motivo per cui l'associazione è unidirezionale ha a che fare con il fatto che qualsiasi classe su qualsiasi componente di CLASSPATH può dichiararsi in qualsiasi pacchetto (eccetto java / javax). Quindi non c'è semplicemente nessuna mappatura di TUTTE le classi in un dato "pacchetto" perché nessuno sa né può saperlo. Potresti aggiornare un file jar domani e rimuovere o aggiungere classi. È come cercare di ottenere un elenco di tutte le persone chiamate John / Jon / Johan in tutti i paesi del mondo - nessuno di noi è onnisciente, quindi nessuno di noi avrà mai la risposta corretta.