Anmerkungsprozessoren hinzufügen

Auf dieser Seite wird ausführlich beschrieben, wie Sie Vermerke hinzufügen und konfigurieren. Prozessoren als Projektabhängigkeiten. Weitere Informationen zu Annotationsprozessoren sehen Sie den Eintrag in Konfigurieren Sie Abhängigkeiten.

Wenn Sie Ihrem Compiler-Klassenpfad Annotationsprozessoren hinzufügen, sehen Sie erhalten Sie eine Fehlermeldung wie diese:

Error: Annotation processors must be explicitly declared now.

Fügen Sie Ihrem Projekt Annotationsprozessoren hinzu, um diesen Fehler zu beheben. Konfigurieren Sie dazu Ihre Abhängigkeit unter Verwendung von annotationProcessor, wie unten gezeigt:

Kotlin

dependencies {
    // Adds libraries defining annotations to only the compile classpath.
    compileOnly("com.google.dagger:dagger:version-number")
    // Adds the annotation processor dependency to the annotation processor classpath.
    annotationProcessor("com.google.dagger:dagger-compiler:version-number")
}

Cool

dependencies {
    // Adds libraries defining annotations to only the compile classpath.
    compileOnly 'com.google.dagger:dagger:version-number'
    // Adds the annotation processor dependency to the annotation processor classpath.
    annotationProcessor 'com.google.dagger:dagger-compiler:version-number'
}

Hinweis:Das Android-Plug-in für Gradle ab 3.0.0 wird nicht mehr unterstützt. unterstützt Plug-in android-apt.

Argumente an Annotationsprozessoren übergeben

Wenn Sie Argumente an einen Annotationsprozessor übergeben müssen, können Sie dies mit AnnotationProcessorOptions in der Build-Konfiguration des Moduls. Wenn Sie zum Beispiel primitive Datentypen als Schlüssel/Wert-Paare verwenden, können Sie das Attribut argument verwenden, wie unten dargestellt:

Kotlin

android {
    ...
    defaultConfig {
        ...
        javaCompileOptions {
            annotationProcessorOptions {
                arguments += mapOf("key1" to "value1",
                                   "key2" to "value2")
            }
        }
    }
}

Cool

android {
    ...
    defaultConfig {
        ...
        javaCompileOptions {
            annotationProcessorOptions {
                argument 'key1', 'value1'
                argument 'key2', 'value2'
            }
        }
    }
}

Wenn Sie jedoch das Android-Gradle-Plug-in 3.2.0 und höher verwenden, müssen Sie Prozessorargumente übergeben, die Dateien oder Verzeichnisse mithilfe der CommandLineArgumentProvider-Schnittstelle.

Mit CommandLineArgumentProvider können Sie oder die Verarbeiter für Anmerkungen, um die Richtigkeit und Leistung von Inkrementelle und im Cache gespeicherte bereinigte Builds durch Anwenden des Property-Typs "Inkrementeller Build" Anmerkungen mit jedem Argument verknüpfen.

Die folgende Klasse implementiert beispielsweise CommandLineArgumentProvider und annotiert jedes Argument für den Prozessor.

Kotlin

class MyArgsProvider(
    // Annotates each directory as either an input or output for the
    // annotation processor.
    @get:InputFiles
    // Using this annotation helps Gradle determine which part of the file path
    // should be considered during up-to-date checks.
    @get:PathSensitive(PathSensitivity.RELATIVE)
    val inputDir: FileCollection,

    @get:OutputDirectory
    val outputDir: File
) : CommandLineArgumentProvider {
    // Specifies each directory as a command line argument for the processor.
    // The Android plugin uses this method to pass the arguments to the
    // annotation processor.

    override fun asArguments(): Iterable<String> {
        // Use the form '-Akey[=value]' to pass your options to the Java compiler.
        return listOf("-AinputDir=${inputDir.singleFile.absolutePath}",
                      "-AoutputDir=${outputDir.absolutePath}")
    }
}

android {...}

Cool

class MyArgsProvider implements CommandLineArgumentProvider {

    // Annotates each directory as either an input or output for the
    // annotation processor.
    @InputFiles
    // Using this annotation helps Gradle determine which part of the file path
    // should be considered during up-to-date checks.
    @PathSensitive(PathSensitivity.RELATIVE)
    FileCollection inputDir

    @OutputDirectory
    File outputDir

    // The class constructor sets the paths for the input and output directories.
    MyArgsProvider(FileCollection input, File output) {
        inputDir = input
        outputDir = output
    }

    // Specifies each directory as a command line argument for the processor.
    // The Android plugin uses this method to pass the arguments to the
    // annotation processor.
    @Override
    Iterable<String> asArguments() {
        // Use the form '-Akey[=value]' to pass your options to the Java compiler.
        ["-AinputDir=${inputDir.singleFile.absolutePath}",
         "-AoutputDir=${outputDir.absolutePath}"]
    }
}

android {...}

Nachdem Sie eine Klasse definiert haben, die CommandLineArgumentProvider implementiert, benötigen Sie um eine Instanz zu erstellen und sie mithilfe der Methode annotationProcessorOptions.compilerArgumentProvider wie unten dargestellt.

Kotlin

// This is in your module's build.gradle file.
android {
    defaultConfig {
        javaCompileOptions {
            annotationProcessorOptions {
                // Creates a new MyArgsProvider object, specifies the input and
                // output paths for the constructor, and passes the object
                // to the Android plugin.
                compilerArgumentProvider(MyArgsProvider(files("input/path"),
                                                          file("output/path")))
            }
        }
    }
}

Cool

// This is in your module's build.gradle file.
android {
    defaultConfig {
        javaCompileOptions {
            annotationProcessorOptions {
                // Creates a new MyArgsProvider object, specifies the input and
                // output paths for the constructor, and passes the object
                // to the Android plugin.
                compilerArgumentProvider new MyArgsProvider(files("input/path"),
                                         new File("output/path"))
            }
        }
    }
}

Weitere Informationen dazu, wie die Implementierung von CommandLineArgumentProvider hilft Build-Leistung verbessern, lesen Java-Projekte im Cache speichern.

Fehlerprüfung für Annotationsprozessor deaktivieren

Wenn Sie Abhängigkeiten vom Kompilierungsklassenpfad haben, die Annotationen enthalten Prozessoren, die Sie nicht benötigen, können Sie die Fehlerprüfung deaktivieren, indem Sie Folgendes in Ihre build.gradle.kts-Datei einfügen. Hinweis: Die Anmerkung Prozessoren, die Sie dem Compiler-Klassenpfad hinzufügen, processor classpath.

Kotlin

android {
    ...
    defaultConfig {
        ...
        javaCompileOptions {
            annotationProcessorOptions {
                argument("includeCompileClasspath", "false")
            }
        }
    }
}

Cool

android {
    ...
    defaultConfig {
        ...
        javaCompileOptions {
            annotationProcessorOptions {
                includeCompileClasspath false
            }
        }
    }
}

Wenn Sie Kotlin und kapt verwenden:

Kotlin

android {
    ...
    defaultConfig {
        ...
        kapt {
            includeCompileClasspath = false
        }
    }
}

Cool

android {
    ...
    defaultConfig {
        ...
        kapt {
            includeCompileClasspath false
        }
    }
}

Wenn nach der Migration der Annotationsprozessoren des Projekts zu dem Prozessor-Klassenpfad, können Sie Annotationsprozessoren auf der Klassenpfad erstellt werden, indem Sie includeCompileClasspath auf true setzen. Wenn Sie diese Einstellung jedoch Property auf true wird nicht empfohlen und die entsprechende Option wird entfernt für ein zukünftiges Update des Android-Plug-ins.