Java Academy · Lektion

Annotation-processorer ved kompilering

Skriv en AbstractProcessor for at generere kildefiler eller validere kode under kompileringen.

Lektion 4 af 413 trin

Annotation-processorer ved kompilering er en gratis Java Academy-lektion på CoddyKit. Dette er lektion 4 af 4. Du kan læse hele lektionen gratis nedenfor — og derefter øve dig praktisk i browseren med en indbygget kodeeditor og en AI-vejleder, der er tilgængelig døgnet rundt. Den er en del af læringsforløbet i Java Academy, og dine fremskridt synkroniseres på tværs af nettet og CoddyKit-appen. Java Academy-kurset indeholder 4 lektioner i alt.

Hvad er annoteringsprocessorer?

Annoteringsprocessorer (APT — Annotation Processing Tool) kører under kompilering. De undersøger annoteringer i kildekode og kan generere nye kildekodefiler, ressourcefiler eller udløse compilerfejl og -advarsler.

AbstractProcessor: Basisklassen

Udvid javax.annotation.processing.AbstractProcessor. Tilsidesæt process() for at håndtere annoterede elementer. Angiv, hvilke annoteringer der understøttes, og Java-kildeversionen.

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

Registrering af processoren

Registrér processoren i META-INF/services/javax.annotation.processing.Processor med det fuldt kvalificerede klassenavn. Byggeværktøjer (Maven, Gradle) finder den automatisk.

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

Generering af kildekodefiler

Brug processingEnv.getFiler().createSourceFile() til at skrive en ny .java-fil. Compileren kompilerer derefter den genererede fil i samme (eller næste) runde.

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");
}

Undersøgelse af elementmodellen

Annoteringsprocessorer arbejder med Element-objekter (ikke Class-objekter – kildekoden er endnu ikke kompileret). Brug TypeElement, VariableElement og 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());

Udsendelse af compilerfejl

Kald processingEnv.getMessager().printMessage() for at udsende fejl, advarsler eller noter. Sådan markerer brugerdefinerede begrænsningsannoteringer overtrædelser under kompilering.

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

Behandling i flere runder

Annoteringsbehandling foregår i runder. Hvis du genererer en fil, der indeholder annoteringer, kan processoren køre igen i næste runde. roundEnv.processingOver() angiver den sidste runde.

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

Lombok under motorhjelmen

Lombok bruger en ikke-standardiseret APT-udvidelse, der ændrer AST'en for eksisterende klasser (hvilket specifikationen ikke tillader). Dets annoteringer som @Data, @Builder og @Getter genererer metoder direkte i den kompilerede klasse.

MapStruct-kodegenerering

MapStruct genererer typesikre mapper-implementeringer under kompilering. Det læser grænseflader annoteret med @Mapper og skriver implementeringer som almindelige Java-klasser – ingen reflection ved kørsel.

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

Test af annoteringsprocessorer

Brug google/compile-testing eller Kapt (til Kotlin) til at enhedsteste processorer. Giv dem kildekodestrenge, og kontrollér genererede filer eller compilerfejl.

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

Pakning af processoren

Pak processoren i et separat Maven-modul. Annoteringsmodulet (kun annoteringer) er en compile-afhængighed; processormodulet har området annotationProcessor og må aldrig være en kørselstidsafhængighed.

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

Hurtigt tjek

Hvor registrerer du en annoteringsprocessor, så den automatisk kan findes?

Besvar den i den interaktive lektion

Opsummering

Udvid AbstractProcessor, registrér den i META-INF/services, generér kildekode med Filer, og udsend fejl med Messager. Pak processorer separat. Brug compile-testing til enhedstests. Det eliminerer ekstraarbejde fra reflection ved kørsel.

Gratis at komme i gang

Lær Java med en AI-underviser — gratis

Skriv og kør rigtig kode i din browser, få øjeblikkelig hjælp fra en AI-underviser døgnet rundt, og fortsæt, hvor du slap, på web eller i appen.

Kurser: 104
Lektioner: 374

Start gratis Se hele kurset

Ofte stillede spørgsmål

Er lektionen “Annotation-processorer ved kompilering” gratis?

Ja — hele teksten til “Annotation-processorer ved kompilering” kan læses gratis her på nettet. Hvis du vil øve dig interaktivt med en indbygget kodeeditor og en AI-vejleder døgnet rundt og få adgang til resten af Java Academy-kurset, skal du opgradere til CoddyKit PRO. Java Academy-kurset indeholder 4 lektioner i alt.

Hvad lærer jeg i “Annotation-processorer ved kompilering”?

Skriv en AbstractProcessor for at generere kildefiler eller validere kode under kompileringen. Du øver dig i Java Academy med praktisk kode, som du kører direkte i browseren, og en AI-vejleder døgnet rundt besvarer dine spørgsmål, mens du arbejder dig gennem lektionen.

Skal jeg have erfaring for at begynde på Java Academy?

Der kræves ingen tidligere erfaring. Java Academy på CoddyKit er tilrettelagt for både begyndere og øvede, så du kan starte her eller fra begyndelsen og lære i dit eget tempo. Dette er lektion 4 af 4.

Hvor lang tid tager lektionen “Annotation-processorer ved kompilering”?

De fleste CoddyKit-lektioner tager cirka 5–10 minutter. Hver lektion er kort og interaktiv, så du gør løbende fremskridt og kan fortsætte, hvor du slap – på både web og app.

Kan jeg skrive og køre kode i denne Java Academy-lektion?

Ja. Alle Java Academy-lektioner har en indbygget kodeeditor, så du kan skrive og køre rigtig kode direkte i din browser og få øjeblikkelig feedback fra AI – uden lokal opsætning.

Alle lektioner i dette kursus

Definition af annotationer: elementer og standardværdier
Retention-politikker og target-typer
Annotation-behandling under kørsel
Annotation-processorer ved kompilering

← Tilbage til Java Academy