sirven - ¿Los inconvenientes del procesamiento de anotaciones en Java?

notacion en java

Question

Estoy considerando comenzar un proyecto que se usa para generar código en Java usando anotaciones (no entraré en detalles, ya que no es realmente relevante). Me pregunto acerca de la validez y utilidad del proyecto, y algo que me llamó la atención es la dependencia de la Herramienta del Procesador de Anonaciones (apt).

Lo que me gustaría saber, ya que no puedo hablar por experiencia, ¿cuáles son los inconvenientes de usar el procesamiento de anotaciones en Java?

Estos podrían ser cualquier cosa, incluyendo los gustos de:

• Es difícil hacer TDD al escribir el procesador
• Es difícil incluir el procesamiento en un sistema de compilación.
• el procesamiento lleva mucho tiempo, y es muy difícil lograr que se ejecute rápidamente
• el uso de las anotaciones en un IDE requiere un complemento para cada una, para que se comporte de la misma manera cuando se reportan errores

Estos son solo ejemplos, no mi opinión. Estoy en el proceso de investigar si alguno de estos es verdadero (incluso hacer esta pregunta ;-))

Estoy seguro de que debe haber inconvenientes (por ejemplo, Qi4J específicamente no usar preprocesadores como una ventaja) pero no tengo la experiencia para decir cuáles son.

La única alternativa razonable al uso del procesamiento de anotaciones es probablemente crear complementos para que los IDE relevantes generen el código (sería algo vagamente similar a la función de métodos de anulación / implementación que generaría todas las firmas sin cuerpos de métodos). Sin embargo, ese paso debería repetirse cada vez que cambien partes relevantes del código, el procesamiento de las anotaciones no, por lo que puedo decir.

En lo que respecta al ejemplo dado con la cantidad invasiva de anotaciones, no me imagino que el uso deba ser algo así, tal vez un puñado para una clase determinada. Eso no evitaría que fuera abusado, por supuesto.

Answer 1

¿Una pregunta específica que sería útil para responder a la pregunta sería opuesta a qué? ¿No haces el proyecto, o no usas anotaciones? Y si no se usan anotaciones, ¿cuáles son las alternativas?

Personalmente, encuentro anotaciones excesivas ilegibles, y muchas veces demasiado inflexibles. Eche un vistazo a esto para un método en un servicio web para implementar un WSDL requerido por el proveedor:

    @WebMethod(action=QBWSBean.NS+"receiveResponseXML")
@WebResult(name="receiveResponseXML"+result,targetNamespace = QBWSBean.NS)
@TransactionAttribute(TransactionAttributeType.NOT_SUPPORTED)
public int receiveResponseXML(
        @WebParam(name = "ticket",targetNamespace = QBWSBean.NS) String ticket,
        @WebParam(name = "response",targetNamespace = QBWSBean.NS) String response,
        @WebParam(name = "hresult",targetNamespace = QBWSBean.NS) String hresult,
        @WebParam(name = "message",targetNamespace = QBWSBean.NS) String message) {

Encuentro ese código altamente ilegible. Sin embargo, una alternativa de configuración XML no es necesariamente mejor.

Answer 2

Creo que si el procesador de anotaciones definitivamente usa la versión Java 6 de la API. Ese es el que será apoyado en el futuro. La API de Java 5 todavía estaba en el espacio de nombres com.sun.xyz no oficial.

Creo que veremos muchos más usos de la API del procesador de anotaciones en un futuro próximo. Por ejemplo, Hibernate está desarrollando un procesador para la nueva funcionalidad de metamodelo estático relacionada con la consulta JPA 2. También están desarrollando un procesador para validar las anotaciones de Validación de Bean. Así que el proceso de anotación está aquí para quedarse.

La integración de herramientas está bien. Las últimas versiones de los IDE convencionales contienen opciones para configurar los procesadores de anotación e integrarlos en el proceso de compilación. Las herramientas de creación de la corriente principal también admiten el procesamiento de anotaciones donde el experto aún puede causar cierto dolor.

Pruebas me parece un gran problema sin embargo. Todas las pruebas son indirectas y de alguna manera verifican el resultado final del proceso de anotación. No puedo escribir ninguna prueba unitaria simple que solo haga valer métodos simples que funcionen en TypeMirrors u otras clases basadas en reflexión. El problema es que no se pueden crear instancias de este tipo de clases fuera del ciclo de compilación de los procesadores. No creo que Sun tuviera realmente la capacidad de prueba en mente al diseñar la API.

Answer 3

He creado un conjunto de anotaciones de JavaBean ( http://code.google.com/p/javadude/wiki/Annotations )

[Nota: estoy trabajando en una nueva versión en este momento, por lo que el código troncal no coincide con las descargas del sitio de actualización]

Pruebas

Probarlos puede ser bastante difícil ...

Por lo general, me acerco a él creando un proyecto en eclipse con el código de prueba y generándolo, luego hago una copia y desactivo el procesamiento de anotaciones.

Luego puedo usar Eclipse para comparar el proyecto de prueba "activo" con la copia "esperada" del proyecto.

Todavía no tengo demasiados casos de prueba (es muy tedioso generar tantas combinaciones de atributos), pero esto está ayudando.

Sistema de construcción

Usar anotaciones en un sistema de compilación es realmente muy fácil. Eche un vistazo a http://code.google.com/p/javadude/wiki/Annotations para ver un ejemplo de cómo se usa en un script ant, y usarlo en eclipse es solo una cuestión de hacer un complemento que especifique el procesador de anotaciones Extensión y activación del procesamiento de anotaciones en proyectos que quieran utilizarlo.

He utilizado el procesamiento de anotaciones en un entorno de compilación continua, compilando las anotaciones y el procesador y luego usándolo en el resto de la compilación. Es realmente bastante indoloro.

Tiempo de procesamiento

No he encontrado que esto sea un problema, tenga cuidado con lo que hace en los procesadores. Genero mucho código en el mío y funciona bien. Es un poco más lento en hormiga.

Tenga en cuenta que los procesadores Java6 pueden ejecutarse un poco más rápido porque son parte del proceso de compilación normal. Sin embargo, he tenido problemas para que funcionen correctamente en una capacidad de generación de código (creo que gran parte del problema es el soporte de eclipse y la ejecución de compilaciones de varias fases). Por ahora, me quedo con Java 5.

Procesamiento de errores

Esta es una de las cosas mejor pensadas en la API de anotación. La API tiene un objeto "mensajero" que maneja todos los errores. Cada IDE proporciona una implementación que convierte esto en mensajes de error apropiados en la ubicación correcta en el código.

Lo único que hice en el eclipse fue lanzar el objeto del entorno de procesamiento para poder verificar si se ejecutó como compilación o para la reconciliación del editor. Si edito, salgo. Finalmente, cambiaré esto para hacer solo una comprobación de errores en el momento de la edición para que pueda informar de los errores mientras escribe. Sin embargo, tenga cuidado: debe mantenerlo realmente rápido para su uso durante la conciliación o la edición se vuelve lenta.

Generación de Código Gotcha

[añadido un poco más por comentarios]

Las especificaciones del procesador de anotaciones indican que no se le permite modificar la clase que contiene la anotación. Sospecho que esto es para simplificar el procesamiento (otras rondas no tienen que incluir las clases anotadas, lo que evita infinitos bucles de actualización)

Sin embargo, puede generar otras clases, y ellos recomiendan ese enfoque.

Genero una superclase para todos los métodos get / set y cualquier otra cosa que necesite generar. También tengo el procesador para verificar que la clase anotada extiende la clase generada. Por ejemplo:

@Bean(...)
public class Foo extends FooGen

Genero una clase en el mismo paquete con el nombre de la clase anotada más "Gen" y verifico que la clase anotada está declarada para ampliarla.

He visto a alguien usar la api del árbol del compilador para modificar la clase anotada; esto va en contra de las especificaciones y sospecho que taparán ese agujero en algún momento para que no funcione.

Yo recomendaría generar una superclase.

En general

Estoy muy feliz de usar procesadores de anotación. Muy bien diseñado, especialmente mirando a IDE / independencia de compilación de línea de comandos.

Por ahora, recomendaría seguir con los procesadores de anotación Java5 si está realizando la generación de código. Debe ejecutar una herramienta separada llamada apt para procesarlos y luego hacer la compilación.

Tenga en cuenta que la API para los procesadores de anotación Java 5 y Java 6 es diferente. La API de procesamiento de Java 6 es MEJOR, pero aún no he tenido suerte con los procesadores java 6 que hacen lo que necesito todavía.

Cuando salga Java 7, le daré otra oportunidad al nuevo enfoque de procesamiento.

No dude en enviarme un correo electrónico si tiene preguntas. ([email protected])

¡Espero que esto ayude!