Skanowanie adnotacji Java w czasie wykonywania [zamknięte]

Jaki jest najlepszy sposób przeszukiwania całej ścieżki klasy dla klasy z adnotacjami?

Robię bibliotekę i chcę pozwolić użytkownikom na dodawanie adnotacji do swoich klas, więc kiedy uruchomi się aplikacja sieci Web, muszę przeskanować całą ścieżkę klasy w poszukiwaniu określonych adnotacji.

Czy znasz bibliotekę lub narzędzie Java, aby to zrobić?

Edycja: Myślę o czymś takim, jak nowa funkcjonalność Java EE 5 Web Services lub EJB. Adnotujesz swoją klasę za pomocą @WebServicelub, @EJBa system znajduje te klasy podczas ładowania, aby były dostępne zdalnie.

Użyj org.springframework.context.annotation.ClassPathScanningCandidateComponentProvider

API

Dostawca komponentów, który skanuje ścieżkę klasy z pakietu podstawowego. Następnie stosuje filtry wykluczania i dołączania do klas wynikowych w celu znalezienia kandydatów.

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

Innym rozwiązaniem są odbicia Google .

Szybki przegląd:

• Rozwiązanie wiosenne jest dobrym rozwiązaniem, jeśli używasz Spring. W przeciwnym razie jest to duża zależność.
• Korzystanie bezpośrednio z ASM jest nieco kłopotliwe.
• Bezpośrednie używanie Java Assist również jest niezręczne.
• Annovention jest super lekki i wygodny. Nie ma jeszcze integracji z maven.
• Refleksje Google przyciągają kolekcje Google. Indeksuje wszystko, a następnie jest super szybki.

Możesz znaleźć klasy z dowolną adnotacją za pomocą ClassGraph , a także wyszukać inne kryteria zainteresowania, np. Klasy, które implementują dany interfejs. (Oświadczenie, jestem autorem ClassGraph.) ClassGraph może zbudować abstrakcyjną reprezentację całego wykresu klas (wszystkich klas, adnotacji, metod, parametrów metod i pól) w pamięci, dla wszystkich klas na ścieżce klas lub dla klas w pakiety umieszczone na białej liście i możesz wyszukiwać wykresy klas w dowolny sposób. ClassGraph obsługuje więcej mechanizmów specyfikacji ścieżek klas i programów ładujących klasy niż jakikolwiek inny skaner, a także bezproblemowo współpracuje z nowym systemem modułów JPMS, więc jeśli oprzesz swój kod na ClassGraph, Twój kod będzie maksymalnie przenośny. Zobacz API tutaj.

Jeśli chcesz naprawdę lekkiej wagi (brak zależności, prosty interfejs API, plik jar 15 kb) i bardzo szybkiego rozwiązania, spójrz annotation-detectorna stronę https://github.com/rmuller/infomas-asl

Oświadczenie: Jestem autorem.

Za pomocą interfejsu API Java Pluggable Annotation Processing API można napisać procesor adnotacji, który zostanie wykonany podczas procesu kompilacji i zgromadzi wszystkie klasy adnotacji i zbuduje plik indeksu na potrzeby środowiska wykonawczego.

Jest to najszybszy możliwy sposób na wykrycie klasy z adnotacjami, ponieważ nie trzeba skanować ścieżki klasy w czasie wykonywania, co zwykle jest bardzo powolne. To podejście działa również z dowolnym modułem ładującym klasy, a nie tylko z URLClassLoaders zwykle obsługiwanym przez skanery środowiska wykonawczego.

Powyższy mechanizm jest już zaimplementowany w bibliotece ClassIndex .

Aby z niego skorzystać, dodaj adnotację niestandardową za pomocą meta-adnotacji @IndexAnnotated . W czasie kompilacji zostanie utworzony plik indeksu: META-INF / annotations / com / test / YourCustomAnnotation zawierający wszystkie klasy z adnotacjami. Dostęp do indeksu można uzyskać w czasie wykonywania, wykonując:

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

Czy jest już za późno na odpowiedź? Powiedziałbym, że lepiej, aby przejść przez biblioteki jak ClassPathScanningCandidateComponentProvider lub jak Scannotations

Ale nawet po tym, jak ktoś chce spróbować z ClassLoaderem, napisałem sam, aby wydrukować adnotacje z zajęć w pakiecie:

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;

}
}

A w pliku konfiguracyjnym umieścisz nazwę pakietu i rozpakujesz go do klasy.

Za pomocą Spring możesz także napisać poniższe, używając klasy AnnotationUtils. to znaczy:

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

Aby uzyskać więcej informacji i wszystkie różne metody, sprawdź oficjalne dokumenty: https://docs.spring.io/spring/docs/current/javadoc-api/org/springframework/core/annotation/AnnotationUtils.html

Jest wspaniały komentarz zapp, który tonie we wszystkich tych odpowiedziach:

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

Interfejs API Classloader nie ma metody „wyliczania”, ponieważ ładowanie klas jest działaniem „na żądanie” - zwykle w ścieżce klasy znajdują się tysiące klas, z których tylko część będzie kiedykolwiek potrzebna (rt.jar sam jest obecnie 48 MB!).

Tak więc, nawet jeśli można wyliczyć wszystkie klasy, zajęłoby to dużo czasu i pamięci.

Proste podejście polega na wypisaniu odpowiednich klas w pliku instalacyjnym (xml lub cokolwiek, co pasuje do twoich upodobań); jeśli chcesz to zrobić automatycznie, ogranicz się do jednego katalogu JAR lub jednego katalogu klas.

Google Reflection, jeśli chcesz odkryć również interfejsy.

Wiosna ClassPathScanningCandidateComponentProvidernie odkrywa interfejsów.

Google Reflections wydaje się być znacznie szybszy niż Spring. Znaleziono to żądanie funkcji uwzględniające tę różnicę: http://www.opensaga.org/jira/browse/OS-738

Jest to powód, aby używać Reflections, ponieważ czas uruchamiania mojej aplikacji jest naprawdę ważny podczas programowania. Refleksje wydają się również bardzo łatwe w użyciu w moim przypadku użycia (znajdź wszystkich implementatorów interfejsu).

Jeśli szukasz alternatywy dla odbić , chciałbym polecić Panda Utilities - AnnotationsScanner . Jest to skaner bez Guawy (Guava ma ~ 3 MB, Panda Utilities ma ~ 200kb) skaner oparty na kodzie źródłowym biblioteki odbić.

Jest również dedykowany do wyszukiwania w przyszłości. Jeśli chcesz skanować wielokrotnie dołączone źródła lub nawet udostępnić interfejs API, który pozwala komuś skanować bieżącą ścieżkę klasy, AnnotationsScannerProcessbuforuje wszystkie pobrane pliki ClassFiles, więc jest to naprawdę szybkie.

Prosty przykład AnnotationsScannerużycia:

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

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

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

Wiosna ma coś, co nazywa się AnnotatedTypeScannerklasą.
Ta klasa używa wewnętrznie

ClassPathScanningCandidateComponentProvider

Ta klasa ma kod do rzeczywistego skanowania ścieżki klasy zasobów . Robi to za pomocą metadanych klasy dostępnych w czasie wykonywania.

Można po prostu rozszerzyć tę klasę lub użyć tej samej klasy do skanowania. Poniżej znajduje się definicja konstruktora.

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