Bearbeta annoteringar under körning
Läs annoteringar under körning med reflection för att implementera validerings-, routnings- eller injektionslogik.
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. ValidisAnnotationPresent
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.
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
- Definiera annoteringar: element och standardvärden
- Bevarandepolicyer och måltyper
- Bearbeta annoteringar under körning
- Annoteringsprocessorer vid kompilering