Java Academy · Lektion

Annotation-Processor zur Compile-Zeit

Schreiben Sie einen AbstractProcessor, um Quelldateien zu generieren oder Code zur Compile-Zeit zu validieren.

Annotation-Processor zur Compile-Zeit ist eine kostenlose Java Academy-Lektion auf CoddyKit. Dies ist Lektion 4 von 4. Du kannst die komplette Lektion unten kostenlos lesen – dann übst du sie direkt im Browser mit einem integrierten Code-Editor und einem KI-Tutor rund um die Uhr. Sie ist Teil des Java Academy-Lernpfads, und dein Fortschritt wird über Web und CoddyKit-App synchronisiert. Der Java Academy-Kurs umfasst insgesamt 4 Lektionen.

Was sind Annotation-Prozessoren?

Annotation-Prozessoren (APT – Annotation Processing Tool) werden während der Kompilierung ausgeführt. Sie untersuchen Annotationen im Quellcode und können neue Quelldateien, Ressourcendateien oder Compilerfehler und -warnungen erzeugen.

AbstractProcessor: Die Basisklasse

Erweitern Sie javax.annotation.processing.AbstractProcessor. Überschreiben Sie process(), um annotierte Elemente zu verarbeiten. Deklarieren Sie die unterstützten Annotationen und die Java-Quellversion.

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

Den Prozessor registrieren

Registrieren Sie den Prozessor in META-INF/services/javax.annotation.processing.Processor mit dem vollständig qualifizierten Klassennamen. Build-Tools (Maven, Gradle) erkennen ihn automatisch.

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

Quelldateien generieren

Verwenden Sie processingEnv.getFiler().createSourceFile(), um eine neue .java-Datei zu schreiben. Der Compiler kompiliert die generierte Datei anschließend in derselben oder der nächsten 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");
}

Das Elementmodell untersuchen

Annotation-Prozessoren arbeiten mit Elements (nicht mit Classes, da der Quellcode noch nicht kompiliert ist). Verwenden Sie TypeElement, VariableElement und 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());

Compilerfehler ausgeben

Rufen Sie processingEnv.getMessager().printMessage() auf, um Fehler, Warnungen oder Hinweise auszugeben. So melden benutzerdefinierte Constraint-Annotationen Verstöße zur Kompilierzeit.

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

Verarbeitung in mehreren Runden

Die Annotation-Verarbeitung erfolgt in Runden. Wenn Sie eine Datei generieren, die Annotationen enthält, wird der Prozessor möglicherweise in der nächsten Runde erneut ausgeführt. roundEnv.processingOver() signalisiert die letzte Runde.

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

Lombok unter der Haube

Lombok verwendet eine nicht standardkonforme APT-Erweiterung, die den AST vorhandener Klassen verändert (was laut Spezifikation nicht erlaubt ist). Seine Annotationen wie @Data, @Builder und @Getter generieren Methoden direkt in der kompilierten Klasse.

MapStruct-Codegenerierung

MapStruct generiert typsichere Mapper-Implementierungen zur Kompilierzeit. Es liest mit @Mapper annotierte Interfaces und schreibt Implementierungen als reguläre Java-Klassen – ohne Reflection zur Laufzeit.

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

Annotation-Prozessoren testen

Verwenden Sie google/compile-testing oder Kapt (für Kotlin), um Prozessoren per Unit-Test zu testen. Übergeben Sie Quellcode-Strings und prüfen Sie die generierten Dateien oder Compilerfehler.

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

Prozessoren paketieren

Paketieren Sie den Prozessor in einem separaten Maven-Modul. Das Annotation-Modul (nur Annotationen) ist eine compile-Abhängigkeit; das Prozessor-Modul hat den Bereich annotationProcessor und darf niemals eine Laufzeitabhängigkeit sein.

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

Kurzer Test

Wo registrieren Sie einen Annotation-Prozessor zur automatischen Erkennung?

Zusammenfassung

Erweitern Sie AbstractProcessor, registrieren Sie ihn in META-INF/services, generieren Sie Quellcode mit Filer und geben Sie Fehler mit Messager aus. Paketieren Sie Prozessoren separat. Verwenden Sie compile-testing für Unit-Tests. Dadurch entfällt der Reflection-Overhead zur Laufzeit.

Häufig gestellte Fragen

Ist die Lektion „Annotation-Processor zur Compile-Zeit“ kostenlos?

Ja — der vollständige Text von „Annotation-Processor zur Compile-Zeit“ ist hier im Web kostenlos zu lesen. Um sie interaktiv zu üben (integrierter Code-Editor und 24/7 KI-Tutor) und den Rest des Java Academy-Kurses freizuschalten, upgrade auf CoddyKit PRO. Der Java Academy-Kurs umfasst insgesamt 4 Lektionen.

Was lerne ich in „Annotation-Processor zur Compile-Zeit“?

Schreiben Sie einen AbstractProcessor, um Quelldateien zu generieren oder Code zur Compile-Zeit zu validieren. Du übst Java Academy mit praktischem Code, den du direkt im Browser ausführst, und ein 24/7 KI-Tutor beantwortet deine Fragen während du die Lektion bearbeitest.

Brauche ich Erfahrung, um Java Academy zu starten?

Keine Vorkenntnisse erforderlich. Java Academy auf CoddyKit ist für Anfänger bis fortgeschrittene Lernende strukturiert, sodass du hier starten oder von Anfang an beginnen und in deinem eigenen Tempo voranschreiten kannst. Dies ist Lektion 4 von 4.

Wie lange dauert die Lektion „Annotation-Processor zur Compile-Zeit“?

Die meisten CoddyKit-Lektionen dauern etwa 5–10 Minuten. Jede ist kompakt und interaktiv, sodass du stetig Fortschritte machst und genau dort weitermachst, wo du aufgehört hast – im Web und in der App.

Kann ich in dieser Java Academy-Lektion Code schreiben und ausführen?

Ja. Jede Java Academy-Lektion enthält einen integrierten Code-Editor, sodass du echten Code direkt in deinem Browser schreibst und ausführst und sofort KI-Feedback erhältst — ohne lokale Einrichtung erforderlich.

Alle Lektionen in diesem Kurs

Annotationen definieren: Elemente und Standardwerte
Retention-Richtlinien und Zieltypen
Annotationen zur Laufzeit verarbeiten
Annotation-Processor zur Compile-Zeit

← Zurück zu Java Academy