Muchas veces la gente me pregunta si es mejor usar Anotaciones o ficheros XML a nivel de framework Spring . En un primer momento es más que evidente que el uso de ficheros XML hace que a veces la propia aplicación sea un poco inmanejable. Esto es debido a que cada uno de los Beans que utilizamos debe registrarse en el fichero XML.
Cuantos más beans tengamos más inmanejable será el fichero ApplicatiónContext.xml .Imaginemonos que tenemos los siguientes Beans (ServicioA,ServicioB) a continuación se muestra el fichero ApplicationContext.xml.
<beans xmlns="http://www.springframework.org/schema/beans" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns:context="http://www.springframework.org/schema/context" xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans-4.0.xsd http://www.springframework.org/schema/context http://www.springframework.org/schema/context/spring-context.xsd"> <bean id="servicioA" class="com.arquitecturajava.ServicioA"> </bean> <bean id="servicioB" class="com.arquitecturajava.ServicioB"> </bean> </beans>
Acabamos de registrar dos Servicios y vamos a mostrar su código:
package com.arquitecturajava; public class ServicioA { public String mensaje() { return "hola servicio A"; } }
package com.arquitecturajava; public class ServicioB { public String mensaje() { return "hola servicio B"; } }
Como podemos ver ambos servicios simplemente devuelven un mensaje de “hola servicio X”. En estos momentos podemos configurar un programa sencillo con Spring para hacer uso de ellos.
package com.arquitecturajava; import org.springframework.context.ApplicationContext; import org.springframework.context.support.ClassPathXmlApplicationContext; public class Principal { public static void main(String[] args) { ApplicationContext contexto= new ClassPathXmlApplicationContext("ApplicationContext.xml"); ServicioA servicioA= (ServicioA) contexto.getBean("servicioA"); System.out.println(servicioA.mensaje()); ServicioB servicioB= (ServicioB) contexto.getBean("servicioB"); System.out.println(servicioB.mensaje()); } }
El programa imprimirá por pantalla lo siguiente :
Sin embargo tenemos el problema de que cada vez registraremos más y más servicios a nivel del fichero XML. Si queremos evitar esta situación podemos hacer uso de Anotaciones . En este caso de la anotación @Service que declararemos en cada una de nuestras clases servicio.
Vamos a verlo en código:
package com.arquitecturajava; import org.springframework.stereotype.Service; @Service public class ServicioA { public String mensaje() { return "hola servicio A"; } }
package com.arquitecturajava; import org.springframework.stereotype.Service; @Service public class ServicioB { public String mensaje() { return "hola servicio B"; } }
Realizada esta operación modificaremos el fichero XML para que cargue automaticamente todas las clases anotadas:
<beans xmlns="http://www.springframework.org/schema/beans" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns:context="http://www.springframework.org/schema/context" xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans-4.0.xsd http://www.springframework.org/schema/context http://www.springframework.org/schema/context/spring-context.xsd"> <context:annotation-config/> <context:component-scan base-package="com.arquitecturajava" /> </beans>
Para ello se usan dos etiquetas especiales “annotation-config” que se encarga de registrar todos los servicios anotados con @Service y component-scan que nos indica que package comprobar. Realizada esta operación el fichero XML queda practicamente vacío aunque existan cientos de servicios.
Spring anotaciones y flexibilidad
En un principio parece que es mucho mejor usar Anotaciones ya que nos ahorramos mucho código. Sin embargo a veces hay que dar una vuelta a nuestras conclusiones. Por ejemplo puede haber casos en que tengamos una serie de Servicios que siempre queramos trabajar con ellos de forma muy personalizada ya que han sido problemáticos o tenemos que tener en cuanta cosas a la hora de realizar migraciones. En este caso podemos realizar un enfoque mixto algo que mucha gente desconoce y tener una gran parte de los servicios con anotaciones y una pequeña parte a nivel de ficheros XML para recordarnos que eran especiales.
De esta forma Spring permite una gran flexibilidad a la hora de tratar los beans que manejamos .Recordemos ademas que Spring permite partir el fichero xml de configuración en varios. En nuestro caso podemos acabar configurando un servicio dentro de ApplicationContext.xml y el otro a traves de annotation-config.
<beans xmlns="http://www.springframework.org/schema/beans" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns:context="http://www.springframework.org/schema/context" xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans-4.0.xsd http://www.springframework.org/schema/context http://www.springframework.org/schema/context/spring-context.xsd"> <context:annotation-config/> <context:component-scan base-package="com.arquitecturajava" /> <bean id="servicioB" class="com.arquitecturajava.ServicioA"> </bean> </beans>
Otros Artículos relacionados:
[…] artículos relacionados: Spring vs EJB , Spring Anotaciones vs XML ,Spring Framework y […]
Tengo una con Xml vs. Anotaciones, se trata de la IoC, en el libro se introduce IoC y se explica patrones como “factory”, utiles para tal fin. Luego se introduce el framework de Spring y las fatorias son hechas a un lado se configura desde el xml, al final con las anotaciones se elimina la necesidad de confugurar vía xml.
Mi pregunta es: ?Donde queda la IoC? desde donde se hace?
La hoce automaticamente las anotaciones de autowired , son las que inyectan las dependencias
[…] Visto el fichero de Maven, vamos a configurar los beans necesarios para acceder a una base de datos. En este caso nos vamos a centrar en un enfoque orientado a anotaciones puro. […]
Buenas tardes Cecilio, permítame felicitarle por sus artículos. Estoy desarrollando un proyecto con spring + jpa (con hibernate) para publicar una serie de servicios web. Me gustaría que me dijese si las anotaciones que estoy utilizando son correctas o me estoy equivocando algo. – POJO a nivel de BD –> @Entity – DAO –> @Repository – Servicios web –>¿ @Services o @Controller? Soy de los que ponen el @Transactional en el servicio web por si en algún momento se tiene que comportar como un orquestador (para que la transacción sea el conjunto de operaciones que tenga que realizar el orquestador).… Read more »
[…] Otros artículos relacionados: Spring Organización ,Spring XML vs Anotaciones […]
Buenos días:
Felicidades por el website.
Le invito a que inserte un post sobre el testing de Spring… ya que no veo que esté suficientemente bien explicado en ningún sitio, y con su habilidad para explicar las cosas de forma accesible sería un gran acierto.
Un saludo y muchas gracias por su dedicación
gracias 🙂
Vale, ahora si lo entiendo. Voy a tener que hacer una recopilación y ordenación de tus artículos jajaja.
😉
Tengo entendido que hay una 3° forma (JavaConf) introducida a partir de Spring 3 con anotaciones como @Configuration por ejemplo, aunque no me termina de quedar claro.
https://www.arquitecturajava.com/spring-configuration/
Muy bien, como siempre, claro en las explicaciones.
Gracias (ya que tomas los temas de spring estaria bien si tienes tiempo, que pudieras explicar sobre AOP)
Me lo apunto como idea 🙂