Java Academy · Lektion

Bearbeta annoteringar under körning

Läs annoteringar under körning med reflection för att implementera validerings-, routnings- eller injektionslogik.

Lektion 3 av 413 steg

Bearbeta annoteringar under körning är en gratis lektion i Java Academy på CoddyKit. Detta är lektion 3 av 4. Ni kan läsa hela lektionen gratis nedan och sedan öva praktiskt i webbläsaren med en inbyggd kodredigerare och en AI-handledare som är tillgänglig dygnet runt. Den ingår i lärvägen för Java Academy, och Era framsteg synkroniseras mellan webben och CoddyKit-appen. Kursen i Java Academy innehåller totalt 4 lektioner.

Läsa annotationer på klassnivå

Hämta annotationer från en klass med Class.getAnnotation() (en annotation) eller getAnnotations() (alla). null returneras om annotationen saknas.

@Service
@RequestMapping("/api")
public class UserController {}

RequestMapping rm = UserController.class.getAnnotation(RequestMapping.class);
if (rm != null) System.out.println(Arrays.toString(rm.value())); // ["/api"]

Läsa metodannotationer

Hämta metodannotationer via method.getAnnotation(). Iterera över getDeclaredMethods() för att söka igenom alla metoder i en klass.

for (Method m : UserController.class.getDeclaredMethods()) {
    GetMapping gm = m.getAnnotation(GetMapping.class);
    if (gm != null) System.out.println(m.getName() + " -> " + Arrays.toString(gm.value()));
}

Läsa fältannotationer

Fältannotationer används av validerings- och ORM-ramverk. Iterera över getDeclaredFields() och kontrollera varje relevant annotation.

for (Field f : User.class.getDeclaredFields()) {
    Column col = f.getAnnotation(Column.class);
    if (col != null) System.out.println(f.getName() + " -> column: " + col.name());
}

Läsa parameterannotationer

Parameterannotationer är tillgängliga via method.getParameterAnnotations() – en tvådimensionell array (en rad per parameter och ett element per annotation).

Method m = UserController.class.getDeclaredMethod("create", UserDto.class);
Annotation[][] pa = m.getParameterAnnotations();
for (Annotation a : pa[0]) System.out.println(a.annotationType().getSimpleName()); // e.g. Valid

isAnnotationPresent

Använd isAnnotationPresent(AnnotationType.class) som en snabb null-säker kontroll innan ni läser annotationens värde.

if (m.isAnnotationPresent(Transactional.class)) {
    beginTransaction();
    m.invoke(target, args);
    commitTransaction();
}

Bygga en enkel behållare för beroendeinjektion

Sök igenom ett paket efter klasser som är annoterade med @Component, instansiera dem via reflektion och lagra dem i en map – en förenklad Spring-behållare.

Map<Class<?>, Object> beans = new HashMap<>();
for (Class<?> cls : scanPackage("com.example")) {
    if (cls.isAnnotationPresent(Component.class)) {
        beans.put(cls, cls.getDeclaredConstructor().newInstance());
    }
}

Injicera fält som är annoterade med @Inject

Efter att bönorna har skapats söker ni efter fält annoterade med @Inject och sätter dem med hjälp av reflektion – en efterlikning av fältinjektion.

for (Object bean : beans.values()) {
    for (Field f : bean.getClass().getDeclaredFields()) {
        if (f.isAnnotationPresent(Inject.class)) {
            f.setAccessible(true);
            f.set(bean, beans.get(f.getType()));
        }
    }
}

Validering vid körning med annotationsvärden

Läs värden från constraint-annotationer (som @Range(min=1, max=100)) och validera fältvärdet mot dem vid körning.

for (Field f : dto.getClass().getDeclaredFields()) {
    Range range = f.getAnnotation(Range.class);
    if (range != null) {
        f.setAccessible(true);
        int val = (int) f.get(dto);
        if (val < range.min() || val > range.max())
            throw new ValidationException(f.getName() + " out of range");
    }
}

Läsa repeterbara annotationer

För @Repeatable-annotationer använder ni getAnnotationsByType() för att transparent hämta alla instanser från behållarannotationen.

Tag[] tags = MyClass.class.getAnnotationsByType(Tag.class);
for (Tag t : tags) System.out.println(t.value());

Söka igenom ett paket med ClassPath-bibliotek

Standards Java-reflektion kan inte lista alla klasser i ett paket. Använd bibliotek som Reflections, ClassGraph eller Springs ClassPathScanningCandidateComponentProvider för att söka igenom classpath-poster.

Reflections reflections = new Reflections("com.example.service");
Set<Class<?>> services = reflections.getTypesAnnotatedWith(Service.class);
services.forEach(System.out::println);

Bearbetning av annotationer vid körning: sammanfattning

Bearbetning av annotationer vid körning möjliggör beroendeinjektion, validering, routing och ORM. Det är arbete vid initiering – bearbeta annotationer en gång vid uppstart, cacha resultaten och undvik reflektion i sökvägar som körs per begäran.

Snabb kontroll

Vilken metod hämtar alla instanser av en @Repeatable-annotation?

Sammanfattning

Använd getAnnotation/isAnnotationPresent för enskilda annotationer. Sök igenom metoder och fält med getDeclared*. Använd getAnnotationsByType för repeterbara annotationer. Bearbeta dem vid uppstart och cacha resultaten.

Gratis att börja

Lär dig Java med en AI-lärare – gratis

Skriv och kör riktig kod i webbläsaren, få omedelbar hjälp av en AI-lärare dygnet runt och fortsätt där du slutade – på webben eller i appen.

Kurser
104
Lektioner
374

Vanliga frågor

Är lektionen ”Bearbeta annoteringar under körning” gratis?

Ja – hela texten till ”Bearbeta annoteringar under körning” kan läsas gratis här på webben. Om Ni vill öva interaktivt med en inbyggd kodredigerare och en AI-handledare som är tillgänglig dygnet runt och låsa upp resten av kursen i Java Academy, kan Ni uppgradera till CoddyKit PRO. Kursen i Java Academy innehåller totalt 4 lektioner.

Vad lär jag mig i ”Bearbeta annoteringar under körning”?

Läs annoteringar under körning med reflection för att implementera validerings-, routnings- eller injektionslogik. Ni övar på Java Academy med praktisk kod som körs direkt i webbläsaren, medan en AI-handledare som är tillgänglig dygnet runt svarar på Era frågor under lektionen.

Behöver jag någon erfarenhet för att börja lära mig Java Academy?

Du behöver inga förkunskaper. Utbildningen i Java Academy på CoddyKit är upplagd för allt från nybörjare till avancerade elever, så att du kan börja här eller från början och gå fram i din egen takt. Detta är lektion 3 av 4.

Hur lång tid tar lektionen ”Bearbeta annoteringar under körning”?

De flesta CoddyKit-lektioner tar cirka 5–10 minuter. Varje lektion är kort och interaktiv, så att du gör stadiga framsteg och kan fortsätta precis där du slutade – på webben eller i appen.

Kan jag skriva och köra kod i den här Java Academy-lektionen?

Ja. Varje Java Academy-lektion innehåller en inbyggd kodredigerare, så att du kan skriva och köra riktig kod direkt i webbläsaren och få omedelbar AI-feedback – utan lokal installation.

Alla lektioner i den här kursen

  1. Definiera annoteringar: element och standardvärden
  2. Bevarandepolicyer och måltyper
  3. Bearbeta annoteringar under körning
  4. Annoteringsprocessorer vid kompilering
← Tillbaka till Java Academy