retentionpolicy - Configuración de procesamiento de anotaciones Java 6 con Ant

para que sirven las anotaciones

Question

Tengo una anotación personalizada y es procesador y procesadorFactory. ¿Cómo configuro mi archivo de compilación Ant tal que:

1. El procesador de anotaciones se aplica a las clases anotadas y genera archivos de origen dentro de la carpeta "gen"

2. Los archivos de origen generados (del proceso de anotación) podrían ser utilizados por otros archivos de origen en el proyecto.

Answer 1

Así es como lo hice en eclipse / hormiga:

<javac destdir="bin"
  debug="true"
  debuglevel="${debuglevel}"
  compiler="javac1.6"
  srcdir="${src}">
       <include name="**/*.java"/> <!-- I just do it this way -->
 <classpath refid="classpath_ref_id"/>
 <compilerarg value="-processor" />
 <compilerarg value="${processor}" />
 <compilerarg value="-s" />
 <compilerarg value="${gen_src_target}" />
</javac>

Notas

• La ruta del procesador se incluye en el * classpath_ref_id *
• Ejecute su procesador antes de compilar el código real (con o sin el código generado).

Answer 2

Encontré algunos de los otros ejemplos un poco confusos debido a que algunos de los bits clave son variables inexplicables. Esto es lo que terminé con:

para construir el tarro del procesador:

<target name="build-aux">
    <mkdir dir="${build.dir}" />
    <mkdir dir="${build.classes}" />
    <javac destdir="${build.classes}" source="1.6" target="1.6">
        <src path="${src.java}" />
        <include name="com/acme/cli/Program.java" />
        <include name="com/acme/cli/ProgramProcessor.java" />
    </javac>

    <jar jarfile="acme-aux.jar" update="true">
        <manifest>
            <attribute name="Main-Class" value="${main.class}" />
            <attribute name="Implementation-Title" value="acme-aux" />
            <attribute name="Implementation-Version" value="${version}" />
            <attribute name="Implementation-Vendor" value="ACME, Inc" />
            <attribute name="Built-By" value="${user.name}" />
            <attribute name="Build-Date" value="${TODAY}" />
        </manifest>
        <fileset dir="${build.classes}">
            <!-- the annotation -->
            <include name="com/acme/cli/Program.class" />
            <!-- the annotation processor -->
            <include name="com/acme/cli/ProgramProcessor.class" />
        </fileset>
        <service type="javax.annotation.processing.Processor"
            provider="com.acme.cli.ProgramProcessor" />
    </jar>
</target>

luego, para compilar el código y ejecutar el procesador:

<target name="compile" depends="generate,build-aux">
    <mkdir dir="${build.dir}" />
    <mkdir dir="${build.classes}" />
    <javac destdir="${build.classes}" source="1.6" target="1.6">
        <src path="${src.java}" />
        <include name="com/acme/**/*.java" />
        <!-- ensure that "acme-aux.jar" is in this classpath -->
        <classpath refid="compile.class.path"/>
         <!-- pass option to annotation processor -->
        <compilerarg value="-Aacme.version=${version}" />
    </javac>
</target>

Answer 3

Esto no es bonito, pero es lo que hago. ( Página de javac ant task de javac ant task ) Al usar el atributo compilerarg puedo pasar los argumentos relacionados con el procesamiento de anotaciones que no son compatibles directamente con la tarea ant de javac.

<javac srcdir="${src}" destdir="${classes}" ... > 
     ....
     <compilerarg line="-processorpath ${processorpath}"/>
     <compilerarg line="-processor ${processor}"/>
     <compilerarg line="-s ${whereToPutGeneratedClassFiles}"/>
</javac>

No uso la herramienta APT porque la documentación dice

Tenga en cuenta que la herramienta Apt parece ser una parte inestable del marco JDK, por lo que puede cambiar radicalmente en versiones futuras. En particular, es probable que esté obsoleto en JDK 6, que puede ejecutar procesadores de anotación como parte de javac.

Si realmente no te interesan los argumentos del compilador, puedes manipular los procesadores de anotación de esta manera

<jar destfile="${annotationprocessorjar}" ... >
     ...
     <service type="javax.annotation.processing.Processor" provider="${your.annotation.processor.fully.qualified.name}"/>
</jar>

Entonces puedes hacer

 <javac ... make sure ${annotationprocessorjar} is in classpath>
 </javac>

Answer 4

Puede echar un vistazo a la herramienta de procesamiento de anotaciones , que compila automáticamente los archivos de origen generados.

// EDITAR // En respuesta a tu comentario:

Puedes usar apt en combinación con la tarea apt ant

Pero a partir de jdk6, la herramienta javac proporciona soporte directo para el procesamiento de anotaciones , por lo que debería poder usar la tarea ant de javac con el atributo del compilador especificado como "javac1.6"