Java Academy · Lektion

Annoteringsprocessorer vid kompilering

Skriv en AbstractProcessor för att generera källfiler eller validera kod vid kompilering.

Lektion 4 av 413 steg

Annoteringsprocessorer vid kompilering är en gratis lektion i Java Academy på CoddyKit. Detta är lektion 4 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.

Vad är annotationsprocessorer?

Annotationsprocessorer (APT – Annotation Processing Tool) körs under kompileringen. De inspekterar annotationer i källkoden och kan generera nya källfiler, resursfiler eller skapa kompilatorfel och varningar.

AbstractProcessor: basklassen

Utöka javax.annotation.processing.AbstractProcessor. Åsidosätt process() för att hantera annoterade element. Deklarera vilka annotationer som stöds och vilken Java-källkodsversion som används.

import javax.annotation.processing.*;
import javax.lang.model.SourceVersion;
import javax.lang.model.element.*;

@SupportedAnnotationTypes("com.example.GenerateBuilder")
@SupportedSourceVersion(SourceVersion.RELEASE_17)
public class BuilderProcessor extends AbstractProcessor {
    @Override
    public boolean process(Set<? extends TypeElement> annotations,
                           RoundEnvironment roundEnv) {
        for (Element e : roundEnv.getElementsAnnotatedWith(GenerateBuilder.class)) {
            generateBuilder((TypeElement) e);
        }
        return true;
    }
    private void generateBuilder(TypeElement cls) { /* generate source */ }
}

Registrera processorn

Registrera processorn i META-INF/services/javax.annotation.processing.Processor med det fullständigt kvalificerade klassnamnet. Byggverktyg (Maven, Gradle) hittar den automatiskt.

# META-INF/services/javax.annotation.processing.Processor
com.example.BuilderProcessor

Generera källfiler

Använd processingEnv.getFiler().createSourceFile() för att skriva en ny .java-fil. Kompilatorn kompilerar sedan den genererade filen i samma eller nästa omgång.

JavaFileObject file = processingEnv.getFiler()
    .createSourceFile("com.example.UserBuilder");
try (Writer w = file.openWriter()) {
    w.write("package com.example;\n");
    w.write("public class UserBuilder {\n");
    w.write("  // generated builder\n");
    w.write("}\n");
}

Inspektera elementmodellen

Annotationsprocessorer arbetar med Element-objekt (inte Class-objekt – källkoden har ännu inte kompilerats). Använd TypeElement, VariableElement och ExecutableElement.

TypeElement classElement = (TypeElement) element;
String className = classElement.getSimpleName().toString();
List<VariableElement> fields = classElement.getEnclosedElements().stream()
    .filter(e -> e.getKind() == ElementKind.FIELD)
    .map(e -> (VariableElement) e)
    .collect(Collectors.toList());

Skapa kompilatorfel

Anropa processingEnv.getMessager().printMessage() för att skapa fel, varningar eller meddelanden. Så signalerar anpassade constraint-annotationer överträdelser vid kompileringen.

processingEnv.getMessager().printMessage(
    Diagnostic.Kind.ERROR,
    "@GenerateBuilder requires at least one field",
    element
);

Bearbetning i flera omgångar

Annotationsbearbetning sker i omgångar. Om ni genererar en fil som innehåller annotationer kan processorn köras igen i nästa omgång. roundEnv.processingOver() signalerar den sista omgången.

if (roundEnv.processingOver()) {
    // last round — write summary files or do cleanup
}

Lombok bakom kulisserna

Lombok använder ett icke-standardiserat APT-tillägg som ändrar AST:t för befintliga klasser (vilket inte tillåts av specifikationen). Dess annotationer, till exempel @Data, @Builder och @Getter, genererar metoder direkt i den kompilerade klassen.

MapStruct-kodgenerering

MapStruct genererar typsäkra mapper-implementationer vid kompileringen. Det läser gränssnitt annoterade med @Mapper och skriver implementationer som vanliga Java-klasser – ingen reflektion vid körning.

@Mapper
public interface UserMapper {
    UserDto toDto(User user);
    User toEntity(UserDto dto);
}
// MapStruct generates: UserMapperImpl.java at compile time

Testa annotationsprocessorer

Använd google/compile-testing eller Kapt (för Kotlin) för att enhetstesta processorer. Skicka in källkodssträngar och kontrollera genererade filer eller kompilatorfel.

JavaFileObject src = JavaFileObjects.forSourceString("Test",
    "@GenerateBuilder public class Test { private String name; }");
Compilation c = Compiler.javac().withProcessors(new BuilderProcessor()).compile(src);
CompilationSubject.assertThat(c).succeeded();
CompilationSubject.assertThat(c).generatedSourceFile("TestBuilder");

Paketering av processorer

Paketerar processorn i en separat Maven-modul. Annotationsmodulen (endast annotationer) är ett compile-beroende; processormodulen har scopet annotationProcessor och ska aldrig vara ett körningsberoende.

// build.gradle:
dependencies {
    implementation "com.example:my-annotations:1.0"
    annotationProcessor "com.example:my-processor:1.0"
}

Snabb kontroll

Var registrerar ni en annotationsprocessor för automatisk upptäckt?

Besvara frågan i den interaktiva lektionen

Sammanfattning

Utöka AbstractProcessor, registrera processorn i META-INF/services, generera källkod med Filer och skapa fel med Messager. Paketera processorer separat. Använd compile-testing för enhetstester. Det eliminerar reflektionskostnader vid körning.

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

Börja lära dig gratis Visa hela kursen

Vanliga frågor

Är lektionen ”Annoteringsprocessorer vid kompilering” gratis?

Ja – hela texten till ”Annoteringsprocessorer vid kompilering” 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 ”Annoteringsprocessorer vid kompilering”?

Skriv en AbstractProcessor för att generera källfiler eller validera kod vid kompilering. 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 4 av 4.

Hur lång tid tar lektionen ”Annoteringsprocessorer vid kompilering”?

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

← Tillbaka till Java Academy