guide - java code conventions 2018
Argumentos contra anotaciones (10)
Al principio también era escéptico sobre las anotaciones, pero al verlas en uso, pueden ser una gran cosa. También pueden ser usados en exceso.
Lo principal para recordar acerca de las anotaciones es que son estáticas. No pueden cambiar en tiempo de ejecución. Cualquier otro método de configuración (xml, autodescripción en el código, lo que sea) no sufre de esto. He visto personas aquí en SO que tienen problemas con Spring en cuanto a tener un entorno de prueba para inyectar configuraciones de prueba, y tener que desplegarlo en XML para hacerlo.
XML tampoco es polimórfico, heredado o cualquier otra cosa, por lo que no es un paso atrás en ese sentido.
La ventaja de las anotaciones es que puede proporcionarle más control estático de su configuración y puede evitar muchas dificultades de verbosidad y coordinación en las configuraciones XML (básicamente, mantener las cosas en SECO).
Al igual que XML was, Annotations puede ser usado en exceso. El punto principal es equilibrar las necesidades y ventajas de cada uno. Las anotaciones, en la medida en que le den menos código detallado y DRYer, son una herramienta que debe aprovecharse.
EDITAR: Con respecto al comentario sobre una anotación que reemplaza una interfaz o clase abstracta, creo que puede ser razonable en el límite del marco. En un marco diseñado para ser utilizado por cientos, si no miles de proyectos, tener una interfaz o clase base realmente puede arruinar las cosas (especialmente una clase base, aunque si puedes hacerlo con anotaciones, no hay ninguna razón por la que no puedas hacer con una interfaz regular.
Considera JUnit4. Antes, tenías que extender una clase base que tenía un método de configuración y derribar. En mi opinión, realmente no importa si esos han estado en una interfaz o en una clase base. Ahora tengo un proyecto completamente separado con su propia jerarquía de herencia, y todos deben respetar este método. En primer lugar, no pueden tener sus propios nombres de métodos conflictivos (no es un gran problema en un marco de prueba, pero entiendes mi punto). En segundo lugar, tienes la cadena de llamadas súper baja, porque todos los métodos deben estar acoplados.
Ahora con JUnit4, puede tener diferentes métodos @Before en diferentes clases en la jerarquía y pueden ser independientes el uno del otro. No hay una manera igualmente SECA de lograr esto sin anotaciones.
Desde el punto de vista de los desarrolladores de JUnit, es un desastre. Es mucho mejor tener un tipo definido al que puedas llamar setUp y desmontaje. Pero no existe un marco para la conveniencia del desarrollador del framework, existe para la conveniencia del usuario del framework.
Todo esto se aplica si su código no necesita preocuparse por el tipo (es decir, en su ejemplo, de todos modos, nada usaría realmente un tipo de controlador). Entonces, incluso podría decirse que la implementación de la interfaz del marco es más permeable que la colocación de una anotación.
Sin embargo, si vas a escribir código para leer esa anotación en tu propio proyecto, corre lejos.
Mi equipo se está moviendo a Spring 3.0 y hay algunas personas que quieren comenzar a mover todo en Anotaciones. Acabo de tener una muy mala sensación en mi instinto (¿olor a código?) Cuando veo una clase que tiene métodos como este: (solo un ejemplo, no todas las anotaciones reales)
@Transaction
@Method("GET")
@PathElement("time")
@PathElement("date")
@Autowired
@Secure("ROLE_ADMIN")
public void manage(@Qualifier(''time'')int time) {
...
}
¿Estoy detrás de los tiempos, o todo esto parece una idea horrible para alguien más? En lugar de usar conceptos OO como herencia y polimorfismo, todo es ahora por convención o mediante anotaciones. Simplemente no me gusta. Tener que recompilar todo el código para cambiar las cosas que la configuración de IMO parece incorrecta. Pero parece ser la forma en que todo (especialmente la primavera) se desarrolla. ¿Debería simplemente "superarlo" o debería retroceder y tratar de mantener nuestro código libre de anotaciones?
Como muchas cosas, hay pros y contras. En mi opinión, algunas anotaciones son correctas, aunque a veces parece que hay una tendencia a abusar de las anotaciones cuando un enfoque simple de llamada a la función puede ser superior y, como conjunto, esto puede aumentar involuntariamente la carga cognitiva porque aumenta el número de maneras de "hacer cosas".
Dejame explicar. Por ejemplo, me alegra que hayas mencionado la anotación @Transactional. La mayoría de los desarrolladores de Spring probablemente conocerán y usarán @Transactional. ¿Pero cuántos de esos desarrolladores saben cómo funciona realmente @Transactional? ¿Y sabrían de primera mano cómo crear y administrar una transacción sin usar la anotación @Transactional? El uso de @Transactional me facilita el uso de las transacciones en la mayoría de los casos, pero en casos particulares cuando necesito un control más preciso sobre una transacción, me oculta esos detalles. Entonces, en cierto modo, es una espada de doble filo.
Otro ejemplo es @Profile in Spring config classes. En el caso general, facilita la especificación de los perfiles en los que desea que se cargue un componente de Spring. Sin embargo, si necesita una lógica más poderosa que solo especificar una lista de perfiles para los que desea cargar el componente, debería obtener el entorno se objeta a sí mismo y escribe una función para hacer esto. De nuevo, la mayoría de los desarrolladores de Spring probablemente estarían familiarizados con @Profile, pero el efecto secundario es que se familiarizan menos con los detalles de cómo funciona, como la función Environment.acceptsProfiles (String ... profiles), por ejemplo.
Finalmente, cuando las anotaciones no funcionan, puede ser más difícil entender por qué y no se puede simplemente poner un punto de interrupción en la anotación. (Por ejemplo, si olvidó @EnableTransactionManagement en su configuración, ¿qué pasaría?). Debe encontrar el procesador de anotación y eliminarlo. Con un enfoque de llamada de función, puede, por supuesto, poner un punto de interrupción en la función.
Creo que depende en cierta medida de cuándo comenzó a programar. Personalmente, creo que son horribles. Principalmente porque tienen algo de cuasi ''significado'' que no comprenderá a menos que esté al tanto de la anotación en cuestión. Como tales, forman un nuevo lenguaje de programación por sí mismos y lo alejan aún más de los POJO. Comparado con (por ejemplo) código OO antiguo simple. Segundo motivo: pueden evitar que el compilador haga su trabajo por usted. Si tengo una gran base de código y quiero refacturar algo o renombrar algo, lo ideal es que el compilador arroje todo lo que necesita cambiarse, o tanto como sea posible. Una anotación debería ser eso. Una anotación No es central para el comportamiento de tu código. Fueron diseñados originalmente para ser opcionalmente omitidos en la compilación, que le dice todo lo que necesita saber.
Y sí, soy consciente de que XML config sufre de la misma manera. Eso no lo empeora, igual de mal. Al menos puedo fingir ignorar eso, sin embargo, no me mira a la cara en todos los métodos o declaraciones de parámetros.
Dada la elección, preferiría las horribles y antiguas interfaces J2EE remotas / hogareñas, etc. (tan criticadas originalmente por la gente de Spring) como mínimo eso me da una idea de lo que está pasando sin tener que investigar @CoolAidFrameworkThingy y sus debilidades. Uno de los problemas con la gente del marco es que deben vincularlo a su marco para que toda la empresa sea financieramente viable. Esto está en desacuerdo con el diseño de un marco de trabajo bien (es decir, para que sea tan independiente y extraíble de su código como sea posible).
Desafortunadamente, sin embargo, las anotaciones están de moda. Por lo tanto, tendrá dificultades para evitar que su equipo los use a menos que esté interesado en la revisión de códigos / estándares y cosas por el estilo (¡también pasan de moda!)
Leí que Stroustup dejó anotaciones fuera de C ++ ya que temía que fueran mal usadas. A veces las cosas van en la dirección incorrecta durante décadas, pero puedes esperar que las cosas se cierren en el tiempo.
Creo que las anotaciones son buenas si se usan con medida. Las anotaciones como @WebService hacen mucho trabajo en la implementación y el tiempo de ejecución, pero no interfieren en la clase. @Cachexxx o @Transactional claramente interfieren al crear proxies y muchos artefactos, pero creo que están bajo control.
La cosa comienza a ensuciar cuando se usa Hibernate o JPA con anotaciones y CDI. Las anotaciones crecen mucho.
IMO @Service y @Repository son interferencias de Spring en su código de aplicación. Hacen que su aplicación sea dependiente de Spring y solo para el uso de Spring.
El caso de Spring Data Graph es otra historia. @NodeEntity, por ejemplo, agrega métodos a la clase en tiempo de compilación para guardar el objeto de dominio. A menos que tenga el plugin de Eclipse y Spring, tendrá errores porque esos métodos no existen en el código fuente.
La configuración cerca del objeto tiene sus ventajas, pero también un único punto de configuración. Las anotaciones son buenas con la medida, pero no son buenas para todo, y definitivamente malas cuando hay tantas líneas de anotación como líneas de código fuente.
Creo que el camino que está tomando Spring es incorrecto; principalmente porque en algunos casos no hay otra manera de hacer cosas tan divertidas. Es como si Spring quisiera hacer una codificación de xtreme, y al mismo tiempo bloquean a los desarrolladores en el marco de Spring. Probablemente, el lenguaje Java necesita otra forma de hacer algunas cosas.
De hecho, creo que la mala sensación en tu intestino tiene más que ver con Anotaciones como esta configuración de mezcla con código.
Personalmente, me siento de la misma manera que tú, preferiría dejar la configuración (como las definiciones de transacción, los elementos de ruta, las direcciones URL a las que debe asignarse un controlador, etc.) fuera de la base de código y en los archivos de contexto Spring XML externos. .
Sin embargo, creo que el enfoque correcto depende de la opinión y del método que prefiera; podría predecir que la mitad de la comunidad estaría de acuerdo con el enfoque de las anotaciones y la otra mitad estaría de acuerdo con el enfoque de configuración externa.
Las anotaciones a menudo introducen dependencias donde esas dependencias no pertenecen.
Tengo una clase que por casualidad tiene propiedades que se asemejan a los atributos de una tabla en un esquema RDBMS. La clase fue creada con este mapeo en mente. Claramente, existe una relación entre la clase y la mesa, pero me complace mantener la clase libre de cualquier metadato que declare esa relación. ¿Es correcto que esta clase haga una referencia a una tabla y sus columnas en un sistema completamente diferente? Ciertamente no me opongo a los metadatos externos que los asocian y deja a cada uno libre de una comprensión del otro. ¿Qué gané? No es como si los metadatos en el código fuente proporcionaran seguridad de tipo o conformidad de mapeo. Cualquier herramienta de verificación que pueda analizar las anotaciones JPA también podría analizar los archivos de mapeo hibernate. Las anotaciones no ayudaron.
En un contrato, había creado un módulo maven con un paquete de implementaciones de interfaces de un paquete existente. Es desafortunado que este nuevo paquete haya sido uno de muchos directorios dentro de una compilación monolítica; Lo vi como algo separado del otro código. No obstante, el equipo usaba el escaneo classpath, así que tuve que usar anotaciones para conectar mi componente al sistema. Aquí no deseaba una configuración centralizada; Simplemente quería una configuración externa. La configuración XML no era perfecta porque combinaba el cableado de dependencia con la instanciación de componentes. Dado que Rod Johnson no creía en el desarrollo basado en componentes, esto fue justo. No obstante, sentí una vez más que las anotaciones no me ayudaron.
Comparemos esto con algo que no me molesta: las pruebas TestNG y JUnit. Utilizo anotaciones aquí porque escribo esta prueba sabiendo que estoy usando TestNG o JUnit. Si reemplazo uno por otro, entiendo que tendré que realizar una transición costosa que se acercará a una reescritura de las pruebas.
Por alguna razón, acepto que TestNG, JUnit, QUnit, unittest y NUnit son mis clases de prueba. Bajo ninguna circunstancia, JPA o Hibernate poseen esas clases de dominio que se asignan a las tablas. Bajo ninguna circunstancia, Spring es dueño de mis servicios. Controlo mi empaque lógico y físico para aislar unidades que dependen de cualquiera. Quiero asegurarme de que un alejamiento de uno no me deje lisiado debido a todas las dependencias que dejó atrás. Decir adiós siempre es más fácil que irse. En algún punto, dejar es necesario.
Las anotaciones deben usarse con moderación. Son buenos para algunos, pero no para todos. Al menos el enfoque de configuración xml mantiene la configuración en un archivo (o múltiple) en lugar de extenderse por todo el lugar. Eso introduciría (como me gusta llamarlo) una organización de código repugnante. Nunca verá la imagen completa de la configuración si está distribuida en cientos de archivos.
Personalmente, creo que las anotaciones se han apropiado demasiado y se han desvanecido de su propósito original y súper útil (por ejemplo, cosas menores como indicar el método reemplazado) en esta loca herramienta de metaprogramación. No creo que el mecanismo JAva sea lo suficientemente robusto como para manejar estos grupos de anotaciones que preceden a cada método. Por ejemplo, estoy peleando con las anotaciones JUnit en estos días porque me restringen de una manera que no me gusta
Dicho esto, en mi experiencia, la configuración basada en XML tampoco es bonita. Así que para citar a South Park, eliges entre una ducha gigante y un * sándwich.
Creo que la decisión principal que tiene que tomar es si se siente más cómodo con una deslocalización de la configuración de primavera (es decir, mantiene dos archivos en lugar de uno) y si usa herramientas o complementos IDE que se benefician de las anotaciones. Otra pregunta importante es si los desarrolladores que usarán o mantendrán tu código realmente entienden las anotaciones.
Tal vez tengas un problema con las anotaciones redundantes que están en todo el código. Con las meta-annotations redundantes se pueden reemplazar y sus anotaciones son al menos SECAS.
Desde el blog de primavera:
@Service
@Scope("request")
@Transactional(rollbackFor=Exception.class)
@Retention(RetentionPolicy.RUNTIME)
public @interface MyService {
}
@MyService
public class RewardsService {
…
}
Debido a que Java evoluciona tan lentamente, las personas están poniendo más características que faltan en el lenguaje en anotaciones. Es bueno que Java se pueda extender de alguna forma y esto es algo malo, ya que la mayoría de las anotaciones son una solución y agregan complejidad.
Verifique estas respuestas a preguntas similares
Configuración Xml versus configuración basada en Anotación
Básicamente se reduce a: Use ambos. Ambos tienen fundas de uso. No use anotaciones para cosas que deberían permanecer configurables sin volver a compilar todo (especialmente cosas que quizás su usuario debería ser capaz de configurar sin necesidad de recompilarlo todo)