Avertissement obsolète

Lors de l'utilisation du traitement des annotations dans Gradle récent (mon environnement est 4.10.2), le message suivant apparaît.

> gradle compileJava
...

Deprecated Gradle features were used in this build, making it incompatible with Gradle 5.0.
Use '--warning-mode all' to show the individual deprecation warnings.
See https://docs.gradle.org/4.10.2/userguide/command_line_interface.html#sec:command_line_warnings

J'utilise une fonctionnalité incompatible avec Gradle 5.0, donc si vous voulez voir plus de détails, spécifiez l'option --warning-mode all.

Lorsqu'il est exécuté avec les options spécifiées, la sortie est la suivante.

> gradle compileJava --warning-mode all
...

Detecting annotation processors on the compile classpath has been deprecated.
Gradle 5.0 will ignore annotation processors on the compile classpath.
The following annotation processors were detected on the compile classpath: 
'combined.apt.CombinedProcessor' and 
'separated.apt.SeparatedProcessor'. 
Please add them to the annotation processor path instead.
If you did not intend to use annotation processors, you can use the '-proc:none' compiler argument to ignore them.

Il semble que Gradle 5.0 ne supporte plus la méthode d'obtention du processeur d'annotations à partir du chemin de classe au moment de la compilation. J'ai essayé de l'exécuter avec la version RC de 5.0 et cela a été définitivement ignoré.

À la place, spécifiez-le dans ʻannotation processor path. Ou, si votre projet n'utilise pas le traitement des annotations séparément, ajoutez -proc: none` aux options de compilation.

Gradle 5.0: Planned behaviour of ignoring jars with annotation processors not okay. · Issue #5056 · gradle/gradle

Selon les commentaires écrits dans ce numéro, il semble que la raison soit de prendre en charge les processeurs d'annotation incrémentiels (je ne suis pas sûr).

Comment répondre

Convenient declaration of annotation processor dependencies | Gradle 4.6 Release Notes

Depuis Gradle 4.6, si vous installez le plug-in Java, vous pouvez définir la configuration appelée ʻannotationProcessor`.

Dependency configurations | The Java Plugin

Les bibliothèques dépendantes qui fournissent le traitement des annotations doivent être spécifiées dans ʻannotationProcessor au lieu de ʻimplementation.

Au fait, ʻannotationProcessorest la configuration du code principal, donc si vous voulez appliquer le traitement des annotations au code de test, spécifiez-le danstestAnnotationProcessor`.

** Processeur d'annotation Android **

Lorsque j'ai cherché sur Google, [L'histoire de la migration vers le plugin Android pour Gradle 3.0.0](https://developer.android.com/studio/build/gradle-plugin-3-0-0-migration?hl=ja# annotationProcessor_config) donne également ʻannotationProcessor`, mais est-ce autre chose? (Pas familier avec les circonstances Android)

Au moins, JavaPlugin de Gradle inclut ʻannotationProcessor` comme un commit le 15 décembre 2017. Pour Android, la version 3.0.0 est comme en octobre 2017, donc Android vient en premier. ??

La méthode de correspondance change en fonction de la méthode de traitement des annotations (je pense)

En fait, j'ai essayé diverses choses et remarqué, mais même s'il ne s'agit que d'un traitement d'annotation, je pense que la méthode de spécification changera un peu en fonction de la méthode de fourniture (c'est une conclusion tirée à la suite d'essais et d'erreurs personnels, donc garantie d'exactitude Récit).

Une fois classés, je sens qu'ils sont divisés comme suit.

La bibliothèque elle-même et le traitement des annotations sont fournis dans des fichiers jar séparés
La bibliothèque elle-même et le traitement des annotations sont fournis dans le même fichier jar

Mise en œuvre pour vérification

`Structure des dossiers`


|-build.gradle
|-settings.gradle
|-combined/
| `-src/main/
|   |-java/
|   | `-combined/
|   |   |-apt/
|   |   | `-CombinedProcessor.java
|   |   `-core/
|   |     `-Combined.java
|   `-resources/
|     `-META-INF/services/
|       `-javax.annotation.processing.Processor
|
|-separated/
| |-apt/
| | `src/main/
| |  |-java/
| |  | `-separated/apt/
| |  |   `-SeparatedProcessor.java
| |  `-resources/
| |    `-META-INF/services/
| |      `-javax.annotation.processing.Processor
| `-core/
|   `-src/main/java/
|     `-separated/core/
|       `-Separated.java
|
`-main/
  `-src/
    |-main/java/
    | `-main/
    |   `-Foo.java
    `-test/java/
      `-main/
        `-FooTest.java

――Composé de 3 multi-projets - combined --Un projet qui fournit le corps principal et le traitement des annotations dans un seul pot - separated --Un projet qui fournit le corps principal et le traitement des annotations dans différents pots - main --Projets utilisant chaque processus d'annotation --CombinedProcessor.java et SeparateProcessor.java sont des classes qui implémentent respectivement le traitement des annotations. --Combined.java et Separated.java sont les annotations à traiter, respectivement. --Foo.java définit les deux annotations à traiter.

`Foo.java`


package main;

import combined.core.Combined;
import separated.core.Separated;

@Combined
@Separated
public class Foo {}

--build.gradle ressemble à ceci

`build.gradle`


subprojects {
    apply plugin: "java"
    sourceCompatibility = 11
    targetCompatibility = 11
    compileJava.options.encoding = "UTF-8"
}

project(":separated:apt") {
    dependencies {
        implementation project(":separated:core")
    }
}

project(":main") {
    dependencies {
        ... //Les paramètres ici seront décrits plus tard.
    }
}

Le corps de la bibliothèque et le traitement des annotations sont fournis dans des pots séparés

Dans ce cas, spécifiez le fichier jar du corps principal dans ʻimplementation [^ 1] et le fichier jar pour le traitement des annotations dans ʻannotationProcessor.

[^ 1]: défini sur compileOnly pour les bibliothèques qui ne sont nécessaires qu'au moment de la compilation

`build.gradle`


project(":main") {
    dependencies {
        implementation project(":separated:core")
        annotationProcessor project(":separated:apt")
    }
}

`Vérification`


> gradle :main:build --warning-mode all
...

> Task :main:compileJava
Mise en garde:SeparatedProcessor!!
Mise en garde:SeparatedProcessor!!

BUILD SUCCESSFUL in 4s

Complet sans avertissement.

CombinedProcessor a temporairement supprimé la dépendance et l'implémentation.

La bibliothèque qui correspond à ce modèle est Dagger introduite dans le document officiel.

La bibliothèque elle-même et le traitement des annotations sont fournis dans le même fichier jar

Dans ce cas, spécifiez la même dépendance pour ʻimplementation et ʻannotationProcessor.

`build.gradle`


project(":main") {
    dependencies {
        implementation project(":combined")
        annotationProcessor project(":combined")

        ...
    }
}

`Résultat d'exécution`


> gradle :main:build --warning-mode all
...

> Task :main:compileJava
Mise en garde:CombinedProcessor!!
Mise en garde:SeparatedProcessor!!
Mise en garde:CombinedProcessor!!
Mise en garde:SeparatedProcessor!!

> Task :main:compileTestJava
Detecting annotation processors on the compile classpath has been deprecated. Gradle 5.0 will ignore annotation processors on the compile cl
asspath. The following annotation processors were detected on the compile classpath: 'combined.apt.CombinedProcessor'.  Please add them to t
he annotation processor path instead. If you did not intend to use annotation processors, you can use the '-proc:none' compiler argument to
ignore them.

BUILD SUCCESSFUL in 4s

J'ai un avertissement. Si vous regardez attentivement, vous verrez un avertissement imprimé dans la tâche de compileTestJava ( compileJava se termine sans avertissement).

La documentation du plugin Java (https://docs.gradle.org/4.10.2/userguide/java_plugin.html#tab:configurations) illustre les dépendances de chaque configuration. En extrayant uniquement les parties pertinentes cette fois, c'est comme suit (le rouge est la configuration obsolète).

La dépendance spécifiée dans ʻimplementation est également utilisée dans testCompileClasspath` telle quelle. Par conséquent, il semble que le processus d'annotation soit détecté à partir du chemin de classe pendant le test et un avertissement est émis.

Que devrais-je faire?

Si nécessaire uniquement au moment de la compilation

Si vous n'avez besoin du fichier jar qu'au moment de la compilation, vous pouvez éviter l'avertissement en utilisant compileOnly au lieu de ʻimplementation` (ou plutôt, je pense que c'est le bon réglage). Par exemple, Lombok.

`build.gradle`


dependencies {
    compileOnly project(":combined")
    annotationProcessor project(":combined")

    ...
}

`Résultat d'exécution`


> gradle :main:build --warning-mode all
...

> Task :main:compileJava
Mise en garde:CombinedProcessor!!
Mise en garde:SeparatedProcessor!!
Mise en garde:CombinedProcessor!!
Mise en garde:SeparatedProcessor!!

BUILD SUCCESSFUL in 5s

Plus d'avertissements.

ignorer

Si votre code de test n'utilise pas le traitement des annotations, ignorer l'avertissement peut être une option. Après tout, s'il est ignoré à partir de 5.0, il n'y aura pas d'avertissement quand il sera élevé à 5.0, et je pense qu'il va s'installer dans un état où il n'y a pas de problème en termes de mouvement.

Lorsque je l'ai essayé avec la version RC de 5.0, l'avertissement a disparu et seul le processus d'annotation principal a fonctionné.

`5.Résultat de l'exécution avec 0RC`


> gradle --version
------------------------------------------------------------
Gradle 5.0-rc-1
------------------------------------------------------------

...

> gradle :main:build
...

> Task :main:compileJava
Mise en garde:CombinedProcessor!!
Mise en garde:SeparatedProcessor!!
Mise en garde:CombinedProcessor!!
Mise en garde:SeparatedProcessor!!

BUILD SUCCESSFUL in 4s

Si nécessaire au moment de l'exécution

La spécification compileOnly ne peut pas être utilisée si une dépendance est toujours requise à l'exécution. Par exemple, Doma2 correspond à cela.

Lorsque cela se produit, je pense qu'il est préférable d'ignorer les avertissements dans le code de test. Cependant, si vous ne pouvez pas l'ignorer, je pense que vous devrez ajouter une spécification pour désactiver le processeur d'annotation aux options de compilation dans le premier message d'avertissement.

`build.gradle`


dependencies {
    implementation project(":combined")
    annotationProcessor project(":combined")

    ...
}

compileTestJava {
    //Pour les options de compilation de test`-proc:none`Ajouter
    options.compilerArgs += ["-proc:none"]
}

`Résultat d'exécution`


> gradle :main:build --warning-mode all
...

> Task :main:compileJava
Mise en garde:CombinedProcessor!!
Mise en garde:SeparatedProcessor!!
Mise en garde:CombinedProcessor!!
Mise en garde:SeparatedProcessor!!

BUILD SUCCESSFUL in 5s

Il n'y a pas d'avertissement.

[JAVA] En savoir plus sur annotationProcessor for Gradle 5.0

Avertissement obsolète

Comment répondre

La méthode de correspondance change en fonction de la méthode de traitement des annotations (je pense)

Mise en œuvre pour vérification

Structure des dossiers

Foo.java

build.gradle

Le corps de la bibliothèque et le traitement des annotations sont fournis dans des pots séparés

build.gradle

Vérification

La bibliothèque elle-même et le traitement des annotations sont fournis dans le même fichier jar

build.gradle

Résultat d'exécution

Si nécessaire uniquement au moment de la compilation

build.gradle

Résultat d'exécution

ignorer

5.Résultat de l'exécution avec 0RC

Si nécessaire au moment de l'exécution

build.gradle

Résultat d'exécution

`Structure des dossiers`

`Foo.java`

`build.gradle`

`build.gradle`

`Vérification`

`build.gradle`

`Résultat d'exécution`

`build.gradle`

`Résultat d'exécution`

`5.Résultat de l'exécution avec 0RC`

`build.gradle`

`Résultat d'exécution`