Java Annotation Processing apprendre à se passer d'apt

Une des grosses nouveautés de la version 5 de Java était liée à la JSR-175 et la mise en place des annotations. Lors de la création d'une annotation vous devez définir à quel moment elle sera interprétée via l'annotation @Retention. Il existe plusieurs politiques 

• SOURCE : les annotations sont traitées par le compilateur
• CLASS : les annotations sont enregistrées au niveau du bytecode (.class) mais n'ont pas besoin d'être interprétées par la VM au Runtime. C'est le comportement par défaut 
• RUNTIME : les annotations sont enregistrées au niveau du bytecode (.class)  par le compilateur et ne seront interprétées par la VM qu'au Runtime.

Par exemple

@Target({METHOD, FIELD})
@Retention(RUNTIME)
public @interface ManyToOne {
    Class targetEntity() default void.class;
    CascadeType[] cascade() default {};
    FetchType fetch() default EAGER;
    boolean optional() default true;
}

Pour pouvoir interagir avec ces annotations la JSR-269 a fournit toute une API pour pouvoir faire des traitements sur ces annotations (Annotation Processing). L'API a changé entre les versions 5 et 6 de Java et les classes initialement présentes dans le package com.sun.mirror.apt ont été recrées dans les packages javax.annotation.processing et javax.lang.model.

Un petit exemple de processor est disponible sur cet ancien article que j'avais fait sur le sujet.

@SupportedAnnotationTypes({"com.javamind.annotations"})
@SupportedSourceVersion(SourceVersion.RELEASE_7)
@SupportedOptions({"skip"})
public class MyAnnotProcessor extends AbstractProcessor {
    private ProcessingEnvironment processingEnvironment;
    

    @Override
    public synchronized void init(ProcessingEnvironment processingEnv) {
        this.processingEnvironment=processingEnv;
    }

    @Override
    public boolean process(Set<? extends TypeElement> annotations, RoundEnvironment roundEnv) {
        if (Boolean.parseBoolean(

Objects.firstNonNull(processingEnvironment.getOptions().get("skip"), "false"))) {

           return true;
        }
        // Configuration Sommaire
        //...
        return true;
    }
}

L'ancien outil pour lancer l'instrumentation Annotation Processor Tool (apt situé dans le répertoire bin du JDK) est aujourd'hui déprécié (voir cet article). Si vous l'utilisez vous pouvez voir dans les logs des messages du style

[WARNING] warning: The apt tool and its associated API are planned to be
[WARNING] removed in the next major JDK release.  These features have been
[WARNING] superseded by javac and the standardized annotation processing API,
[WARNING] javax.annotation.processing and javax.lang.model.  Users are
[WARNING] recommended to migrate to the annotation processing features of
[WARNING] javac; see the javac man page for more information.
[WARNING] warning: Specified factory, 'com.boiron.tools.apt.domaine.processor.DomaineProcessor', is not an AnnotationProcessorFactory.
[WARNING] warning: No annotation processors found but annotations present.
[WARNING] Note: Some input files use or override a deprecated API.
[WARNING] Note: Recompile with -Xlint:deprecation for details.
[WARNING] 2 warnings

Comme le message l'indique, on sait qu'à terme l'outil sera supprimé donc autant ne plus l'utiliser. Depuis la version 6 de Java tout le processing est directement géré par le compilateur javac. Par défaut tous les classes sont analysées. Si vous ne le voulez pas vous pouvez le désactiver avec l'option -proc:none.

Le compilateur recherche dans le classpath si des fichier de configuration  META-INF/services/javax.annotation.processing.Processor sont présents.  Ces fichiers contiennent les noms des processors à utiliser.

Vous pouvez sinon indiquer les informations par vous même via les options -processorpath et -processor

Si vous êtes utilisateurs de Maven vous pouvez oublier le plugin apt-maven-plugin et n'utiliser que le plugin maven-compiler-plugin. 

Par exemple

<plugin>
       <groupId>org.apache.maven.plugins</groupId>
       <artifactId>maven-compiler-plugin</artifactId>
       <inherited>true</inherited>
       <configuration>
          <source>1.7</source>
          <target>1.7</target>
          <compilerArguments>
             <processor>com.javamind.MyAnnotProcessor</processor>
             <AmyAnnotProcsParam>myParamValue</AmyAnnotProcsParam>
</compilerArguments>
       </configuration>
</plugin>

Dans cet exemple j'utilise le plugin Maven de compilation et je précise quel processor utilisé. Je lui passe également un argument nommé myAnnotProcsParm (le A est important car les paramètres passés au compilateur sont sous la forme -AmyAnnotProcsParm=myParamValue).

Vous pouvez ne rien déclarer et rester sur le comportement normal si votre Processor ne prend aucun paramètre et que vous définissez un fichier javax.annotation.processing.Processor dans le répertoire META-INF/services contenant la ligne com.javamind.MyAnnotProcessor. C'est la solution adoptée par la plupart des librairies que vous utilisez dans vos projets.