Scansione delle annotazioni Java in fase di esecuzione [chiuso]

Qual è il modo migliore di cercare in tutto il percorso di classe una classe annotata?

Sto facendo una libreria e voglio consentire agli utenti di annotare le loro classi, quindi quando si avvia l'applicazione Web ho bisogno di scansionare l'intero percorso di classe per una certa annotazione.

Conosci una libreria o una struttura Java per farlo?

Modifica: sto pensando a qualcosa come la nuova funzionalità per Java EE 5 Web Services o EJB. Annoti la tua classe con @WebServiceoe @EJBil sistema trova queste classi durante il caricamento in modo che siano accessibili da remoto.

Usa org.springframework.context.annotation.ClassPathScanningCandidateComponentProvider

API

Un provider di componenti che analizza il percorso di classe da un pacchetto di base. Quindi applica exclude e include i filtri alle classi risultanti per trovare i candidati.

ClassPathScanningCandidateComponentProvider scanner =
new ClassPathScanningCandidateComponentProvider(<DO_YOU_WANT_TO_USE_DEFALT_FILTER>);

scanner.addIncludeFilter(new AnnotationTypeFilter(<TYPE_YOUR_ANNOTATION_HERE>.class));

for (BeanDefinition bd : scanner.findCandidateComponents(<TYPE_YOUR_BASE_PACKAGE_HERE>))
    System.out.println(bd.getBeanClassName());

E un'altra soluzione sono le riflessioni di Google .

Recensione veloce:

• La soluzione Spring è la strada da percorrere se stai usando Spring. Altrimenti è una grande dipendenza.
• L'uso diretto di ASM è un po 'complicato.
• Anche l'uso diretto di Java Assist è ingombrante.
• L'annuncio è super leggero e conveniente. Nessuna integrazione ancora.
• Le riflessioni di Google attirano le raccolte di Google. Indicizza tutto e poi è super veloce.

Puoi trovare le classi con qualsiasi annotazione data con ClassGraph , nonché cercare altri criteri di interesse, ad esempio le classi che implementano una determinata interfaccia. (Dichiarazione di non responsabilità, sono l'autore di ClassGraph.) ClassGraph può creare una rappresentazione astratta dell'intero grafico di classe (tutte le classi, annotazioni, metodi, parametri del metodo e campi) in memoria, per tutte le classi sul percorso di classe o per le classi in pacchetti autorizzati e puoi interrogare quel grafico di classe come preferisci. ClassGraph supporta più meccanismi di specifica del classpath e classloader rispetto a qualsiasi altro scanner e funziona perfettamente anche con il nuovo sistema di moduli JPMS, quindi se si basa il codice su ClassGraph, il codice sarà al massimo portatile. Vedi l'API qui.

Se vuoi una soluzione davvero leggera (senza dipendenze, semplice API, file jar da 15 kb) e una soluzione molto veloce , dai un'occhiata annotation-detectora https://github.com/rmuller/infomas-asl

Disclaimer: sono l'autore.

È possibile utilizzare l'API Java Pluggable Elaboration Annotation per scrivere un processore di annotazioni che verrà eseguito durante il processo di compilazione e raccoglierà tutte le classi annotate e creerà il file indice per l'uso in fase di runtime.

Questo è il modo più veloce possibile per eseguire il rilevamento di classi con annotazioni perché non è necessario eseguire la scansione del percorso di classe in fase di esecuzione, che di solito è un'operazione molto lenta. Anche questo approccio funziona con qualsiasi classloader e non solo con URLClassLoaders generalmente supportati dagli scanner di runtime.

Il meccanismo sopra è già implementato nella libreria ClassIndex .

Per usarlo annota la tua annotazione personalizzata con @IndexAnnotation meta-annotazione. Questo creerà in fase di compilazione un file indice: META-INF / annotations / com / test / YourCustomAnnotation che elenca tutte le classi annotate. È possibile accedere all'indice in fase di esecuzione eseguendo:

ClassIndex.getAnnotated(com.test.YourCustomAnnotation.class)

È troppo tardi per rispondere. Direi che è meglio andare da biblioteche come ClassPathScanningCandidateComponentProvider o come Scannotations

Ma anche dopo che qualcuno vuole provare alcune mani con classLoader, ne ho scritte alcune per conto mio per stampare le annotazioni dalle classi in un pacchetto:

public class ElementScanner {

public void scanElements(){
    try {
    //Get the package name from configuration file
    String packageName = readConfig();

    //Load the classLoader which loads this class.
    ClassLoader classLoader = getClass().getClassLoader();

    //Change the package structure to directory structure
    String packagePath  = packageName.replace('.', '/');
    URL urls = classLoader.getResource(packagePath);

    //Get all the class files in the specified URL Path.
    File folder = new File(urls.getPath());
    File[] classes = folder.listFiles();

    int size = classes.length;
    List<Class<?>> classList = new ArrayList<Class<?>>();

    for(int i=0;i<size;i++){
        int index = classes[i].getName().indexOf(".");
        String className = classes[i].getName().substring(0, index);
        String classNamePath = packageName+"."+className;
        Class<?> repoClass;
        repoClass = Class.forName(classNamePath);
        Annotation[] annotations = repoClass.getAnnotations();
        for(int j =0;j<annotations.length;j++){
            System.out.println("Annotation in class "+repoClass.getName()+ " is "+annotations[j].annotationType().getName());
        }
        classList.add(repoClass);
    }
    } catch (ClassNotFoundException e) {
        e.printStackTrace();
    }
}

/**
 * Unmarshall the configuration file
 * @return
 */
public String readConfig(){
    try{
        URL url = getClass().getClassLoader().getResource("WEB-INF/config.xml");
        JAXBContext jContext = JAXBContext.newInstance(RepositoryConfig.class);
         Unmarshaller um =  jContext.createUnmarshaller();
         RepositoryConfig rc = (RepositoryConfig) um.unmarshal(new File(url.getFile()));
         return rc.getRepository().getPackageName();
        }catch(Exception e){
            e.printStackTrace();
        }
    return null;

}
}

E in Config File, metti il ​​nome del pacchetto e lo scomponi in una classe.

Con Spring puoi anche semplicemente scrivere quanto segue usando la classe AnnotationUtils. vale a dire:

Class<?> clazz = AnnotationUtils.findAnnotationDeclaringClass(Target.class, null);

Per maggiori dettagli e tutti i diversi metodi consultare i documenti ufficiali: https://docs.spring.io/spring/docs/current/javadoc-api/org/springframework/core/annotation/AnnotationUtils.html

C'è un meraviglioso commento di zapp che affonda in tutte quelle risposte:

new Reflections("my.package").getTypesAnnotatedWith(MyAnnotation.class)

L'API Classloader non ha un metodo "enumerato", perché il caricamento delle classi è un'attività "su richiesta" - di solito ci sono migliaia di classi nel tuo percorso di classe, solo una parte delle quali sarà mai necessaria (il rt.jar al giorno d'oggi è solo 48 MB!).

Quindi, anche se potessi enumerare tutte le classi, ciò richiederebbe molto tempo e memoria.

L'approccio semplice è quello di elencare le classi interessate in un file di installazione (xml o qualunque cosa tu voglia); se vuoi farlo automaticamente, limitati a un JAR o una directory di classe.

Google Reflection se vuoi scoprire anche le interfacce.

La primavera ClassPathScanningCandidateComponentProvidernon sta scoprendo le interfacce.

Google Reflections sembra essere molto più veloce di Spring. Ho trovato questa richiesta di funzionalità che risolve questa differenza: http://www.opensaga.org/jira/browse/OS-738

Questo è un motivo per usare Reflections poiché il tempo di avvio della mia applicazione è molto importante durante lo sviluppo. Reflections sembra anche essere molto facile da usare per il mio caso d'uso (trova tutti gli implementatori di un'interfaccia).

Se stai cercando un'alternativa alle riflessioni, vorrei raccomandare Panda Utilities - AnnotationsScanner . È uno scanner privo di Guava (Guava ha ~ 3 MB, Panda Utilities ha ~ 200 kb) basato sul codice sorgente della libreria riflessioni.

È anche dedicato a ricerche future. Se desideri scansionare più volte fonti incluse o anche fornire un'API, che consente a qualcuno di scansionare il percorso di classe corrente, AnnotationsScannerProcesstutte le cache vengono recuperate ClassFiles, quindi è davvero veloce.

Semplice esempio di AnnotationsScannerutilizzo:

AnnotationsScanner scanner = AnnotationsScanner.createScanner()
        .includeSources(ExampleApplication.class)
        .build();

AnnotationsScannerProcess process = scanner.createWorker()
        .addDefaultProjectFilters("net.dzikoysk")
        .fetch();

Set<Class<?>> classes = process.createSelector()
        .selectTypesAnnotatedWith(AnnotationTest.class);

La primavera ha qualcosa chiamato una AnnotatedTypeScannerclasse.
Questa classe utilizza internamente

ClassPathScanningCandidateComponentProvider

Questa classe ha il codice per la scansione effettiva delle risorse del percorso di classe . Lo fa usando i metadati di classe disponibili in fase di esecuzione.

Si può semplicemente estendere questa classe o utilizzare la stessa classe per la scansione. Di seguito è la definizione del costruttore.

/**
     * Creates a new {@link AnnotatedTypeScanner} for the given annotation types.
     * 
     * @param considerInterfaces whether to consider interfaces as well.
     * @param annotationTypes the annotations to scan for.
     */
    public AnnotatedTypeScanner(boolean considerInterfaces, Class<? extends Annotation>... annotationTypes) {

        this.annotationTypess = Arrays.asList(annotationTypes);
        this.considerInterfaces = considerInterfaces;
    }