Memindai anotasi Java saat runtime [ditutup]

Apa cara terbaik mencari seluruh kelas untuk kelas beranotasi?

Saya sedang melakukan perpustakaan dan saya ingin memungkinkan pengguna untuk membubuhi keterangan kelas mereka, jadi ketika aplikasi Web dimulai saya perlu memindai seluruh classpath untuk anotasi tertentu.

Apakah Anda tahu perpustakaan atau fasilitas Java untuk melakukan ini?

Sunting: Saya sedang memikirkan sesuatu seperti fungsi baru untuk Layanan Web Java EE 5 atau EJB. Anda membubuhi keterangan kelas Anda dengan @WebServiceatau @EJBdan sistem menemukan kelas-kelas ini saat memuat sehingga mereka dapat diakses dari jarak jauh.

Gunakan org.springframework.context.annotation.ClassPathScanningCandidateComponentProvider

API

Penyedia komponen yang memindai classpath dari paket dasar. Ini kemudian berlaku kecualikan dan sertakan filter ke kelas yang dihasilkan untuk menemukan kandidat.

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());

Dan solusi lain adalah refleksi Google .

Ulasan cepat:

• Solusi pegas adalah cara untuk pergi jika Anda menggunakan Pegas. Kalau tidak, itu adalah ketergantungan besar.
• Menggunakan ASM secara langsung agak rumit.
• Menggunakan Java Assist secara langsung juga kikuk.
• Annovention sangat ringan dan nyaman. Belum ada integrasi pakar.
• Refleksi Google menarik koleksi Google. Mengindeks semuanya dan kemudian super cepat.

Anda dapat menemukan kelas dengan penjelasan apa pun yang diberikan dengan ClassGraph , serta mencari kriteria menarik lainnya, misalnya kelas yang mengimplementasikan antarmuka yang diberikan. (Penafian, saya adalah penulis dari ClassGraph.) ClassGraph dapat membangun representasi abstrak dari seluruh grafik kelas (semua kelas, penjelasan, metode, parameter metode, dan bidang) dalam memori, untuk semua kelas di classpath, atau untuk kelas di paket yang masuk daftar putih, dan Anda dapat meminta grafik kelas itu sesuai keinginan. ClassGraph mendukung lebih banyak mekanisme spesifikasi classpath dan classloader daripada pemindai lain, dan juga bekerja dengan mulus dengan sistem modul JPMS baru, jadi jika Anda mendasarkan kode Anda pada ClassGraph, kode Anda akan portabel secara maksimal. Lihat API di sini.

Jika Anda menginginkan bobot yang sangat ringan (tanpa dependensi, API sederhana, file jar 15 kb) dan solusi yang sangat cepat , lihat annotation-detectordi https://github.com/rmuller/infomas-asl

Penafian: Saya penulis.

Anda dapat menggunakan Java Pluggable Annotation Processing API untuk menulis prosesor anotasi yang akan dieksekusi selama proses kompilasi dan akan mengumpulkan semua kelas beranotasi dan membuat file indeks untuk penggunaan runtime.

Ini adalah cara tercepat untuk melakukan penemuan kelas beranotasi karena Anda tidak perlu memindai classpath Anda saat runtime, yang biasanya operasi sangat lambat. Juga pendekatan ini berfungsi dengan classloader apa pun dan tidak hanya dengan URLClassLoaders yang biasanya didukung oleh pemindai runtime.

Mekanisme di atas sudah diterapkan di perpustakaan ClassIndex .

Untuk menggunakannya, beri anotasi anotasi khusus dengan meta-anotasi @IndexAnnotated . Ini akan membuat pada waktu kompilasi suatu file indeks: META-INF / annotations / com / test / YourCustomAnnotation daftar semua kelas yang dijelaskan. Anda dapat mengakses indeks saat runtime dengan menjalankan:

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

Apakah sudah terlambat untuk menjawab. Saya akan mengatakan, lebih baik menggunakan Libraries seperti ClassPathScanningCandidateComponentProvider atau seperti Scannotations

Tetapi bahkan setelah seseorang ingin mencobanya dengan classLoader, saya telah menulis sendiri untuk mencetak anotasi dari kelas dalam satu paket:

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;

}
}

Dan dalam File config, Anda meletakkan nama paket dan menghapusnya ke kelas.

Dengan Spring Anda juga bisa menulis berikut ini menggunakan kelas AnnotationUtils. yaitu:

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

Untuk detail lebih lanjut dan semua metode yang berbeda, periksa dokumen resmi: https://docs.spring.io/spring/docs/current/javadoc-api/org/springframework/core/annotation/AnnotationUtils.html

Ada komentar yang bagus dari zapp yang memenuhi semua jawaban itu:

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

Classloader API tidak memiliki metode "enumerate", karena pemuatan kelas adalah aktivitas "sesuai permintaan" - Anda biasanya memiliki ribuan kelas di classpath Anda, hanya sebagian kecil yang akan diperlukan (rt.jar sendiri adalah 48MB saat ini!).

Jadi, bahkan jika Anda dapat menghitung semua kelas, ini akan sangat memakan waktu dan memori.

Pendekatan sederhananya adalah dengan mendaftarkan kelas-kelas yang bersangkutan dalam file setup (xml atau apa pun yang sesuai dengan keinginan Anda); jika Anda ingin melakukan ini secara otomatis, batasi diri Anda pada satu JAR atau satu direktori kelas.

Google Reflection jika Anda ingin menemukan antarmuka juga.

Spring ClassPathScanningCandidateComponentProvidertidak menemukan antarmuka.

Google Refleksi tampaknya jauh lebih cepat daripada Spring. Menemukan permintaan fitur ini yang mengatasi perbedaan ini: http://www.opensaga.org/jira/browse/OS-738

Ini adalah alasan untuk menggunakan Refleksi karena waktu startup aplikasi saya sangat penting selama pengembangan. Refleksi tampaknya juga sangat mudah digunakan untuk kasus penggunaan saya (temukan semua pelaksana antarmuka).

Jika Anda mencari alternatif untuk refleksi, saya ingin merekomendasikan Panda Utilities - AnnotationsScanner . Ini adalah pemindai yang bebas-Jambu (memiliki ~ 3 MB, Panda Utilities memiliki ~ 200kb) berdasarkan kode sumber perpustakaan refleksi.

Ini juga didedikasikan untuk pencarian berbasis masa depan. Jika Anda ingin memindai beberapa kali menyertakan sumber atau bahkan menyediakan API, yang memungkinkan seseorang memindai classpath saat ini, AnnotationsScannerProcesssemua cache diambil ClassFiles, sehingga sangat cepat.

Contoh AnnotationsScannerpenggunaan sederhana :

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

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

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

Musim semi memiliki sesuatu yang disebut AnnotatedTypeScannerkelas.
Kelas ini digunakan secara internal

ClassPathScanningCandidateComponentProvider

Kelas ini memiliki kode untuk pemindaian aktual sumber daya classpath . Ini dilakukan dengan menggunakan metadata kelas yang tersedia saat runtime.

Seseorang dapat dengan mudah memperluas kelas ini atau menggunakan kelas yang sama untuk pemindaian. Di bawah ini adalah definisi konstruktor.

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