Spring responsabilidades y organización

En muchas ocasiones cuanto trabajamos con Spring  nos encontramos que el fichero de applicationContext.xml ha crecido de tamaño y estamos perdiendo el control sobre el . Tiene dado de alta un conjunto enorme de beans unas son servicios , otras DAO , otras temas de seguridad etc.

Este problema normalmente se puede mitigar  con el uso de anotaciones (@Service,@Repository) etc . Sin embargo siempre hay proyectos que necesitan mas flexibilidad ya que tienen muchos beans dados de alta. Es en estos proyectos en los que poder organizar los beans  y agruparlos por responsabilidad se convierte en algo obligatorio si queremos sobrevivir.

Vamos a mostrar un ejemplo sencillo de como organizar estos beans . Supongamos que nuestro fichero de applicationContext.xml tiene la siguiente estructura.

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
 xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
xmlns:context="http://www.springframework.com/schema/context"
 xsi:schemaLocation="http://www.springframework.org/schema/beans
 http://www.springframework.org/schema/beans/spring-beans-3.2.xsd
 http://www.springframework.org/schema/context
 http://www.springframework.org/schema/context/spring-context-3.2.xsd">
<bean id="servicioModulo1"
 class="com.arquitecturajava.contexto.ServicioModulo1">
</bean>
</beans>

En este caso tenemos dos clases de servicio ServicioModulo1y ServicioModulo2 .Aunque nuestro ejemplo es trivial y no necesitaría partir el fichero vamos a hacerlo para clarificar el concepto . Para ello nos vamos a crear dos nuevos ficheros modulo1.xml y modulo2.xml . Cada uno de los cuales contendrá uno de los beans.
Modulo1.xml

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
 xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
xmlns:context="http://www.springframework.com/schema/context"
 xsi:schemaLocation="http://www.springframework.org/schema/beans
 http://www.springframework.org/schema/beans/spring-beans-3.2.xsd
 http://www.springframework.org/schema/context
 http://www.springframework.org/schema/context/spring-context-3.2.xsd">
<bean id="servicioModulo1"
 class="com.arquitecturajava.contexto.ServicioModulo1">
</bean>
</beans>

Modulo2.xml

</pre>
<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
 xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
 xmlns:context="http://www.springframework.com/schema/context"
 xsi:schemaLocation="http://www.springframework.org/schema/beans
 http://www.springframework.org/schema/beans/spring-beans-3.2.xsd
 http://www.springframework.org/schema/context
 http://www.springframework.org/schema/context/spring-context-3.2.xsd">
 <bean id="servicioModulo2"
 class="com.arquitecturajava.contexto.ServicioModulo2">
 </bean>
</beans>
<pre>

Una vez que hemos configurado ambos ficheros tenemos que configurar el fichero principal de applicationContext.xml.Para ello usaremos las etiquetas <import> de Spring y añadiremos ambos módulos.

applicationContext.xml

</pre>
<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
 xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
 xmlns:context="http://www.springframework.com/schema/context"
 xsi:schemaLocation="http://www.springframework.org/schema/beans
 http://www.springframework.org/schema/beans/spring-beans-3.2.xsd
 http://www.springframework.org/schema/context
 http://www.springframework.org/schema/context/spring-context-3.2.xsd">

<import resource="modulo1.xml"/>
<import resource="modulo2.xml"/>

</beans>
<pre>

Realizadas estas modificaciones en nuestros ficheros de configuración el diseño será mas flexible y podremos organizarnos mejor.

About Cecilio Álvarez Caules

Cecilio Álvarez Caules Sun Certified Enterprise Architech (J2EE/JEE).

19 Responses to Spring responsabilidades y organización

  1. David 4 junio, 2013 at 9:00 #

    En efecto ésta es una práctica muy recomendable.
    Aún se puede ir un paso más allá: se puede usar una política de nombrado para los ficheros (en el ejemplo del post, pues que cada módulo será nombrado modulo[n].xml, donde n es un número).
    Una vez hecho esto, se podrían sustituir estas 2 líneas:

    por esta otra línea:

    Y así sería aún más claro y breve el código.
    Saludos!

    • Cecilio Álvarez Caules 6 junio, 2013 at 6:41 #

      Si ahi ya cada empresa decide como organizarlos hay gente que tiene nombres especificos para el acceso a datos o para la seguridad ,caches etc

  2. David 4 junio, 2013 at 9:03 #

    Creo que no se ve correctamente el contenido de mi comentario 🙁
    Quitaré los símbolos < y >

    Quería decir sustituir estas dos líneas:

    import resource=”modulo1.xml”
    import resource=”modulo2.xml”

    por esta otra:

    import resource=”modulo*.xml”

  3. David 5 junio, 2013 at 14:24 #

    Gracias por las anotaciones, explicación corta, clara y concisa. Lo pondré en práctica seguro, pues no conocía esa posibilidad, y quedarán los .xml de configuración mucho más ordenados y limpios.

    • Cecilio Álvarez Caules 6 junio, 2013 at 6:40 #

      Espero que te sea util 🙂

  4. German 8 agosto, 2013 at 6:51 #

    Hola tengo una gran inquietud acerca de este tema, si nuestra aplicacion tiene almacenados por ejemplo unos 1000 beans es bueno dejar esos bean en un mismo archivo?
    otra inquietud y es q en el ejemplo veo que se usan los imports en el archivo aplicationcontext, seria una mala practica usar un archivo diferente para cada tipo de bean sin enlazarlo al aplicationcontext??

    • Cecilio Álvarez Caules 9 agosto, 2013 at 8:29 #

      Cualquiera de las opciones es aceptable. Sin embargo el tener mas de 1000 beans en un fichero terminará por volvernos locos a la hora de localizar algo.No es problematico a nivel de rendimiento pero yo prefiero separarlo de alguna forma. En tu caso es probable que la aplicación este dividida en X grupos de funcionalidades por ejemplo Aplicacion Zona A ,Aplicacion Zona B. Organizarlo de esta forma ayudaría a los desarrolladores a tener los ficheros mas controlados y que el grupo A no tenga que modificar el del grupo B.

  5. Juan 13 septiembre, 2013 at 22:06 #

    Hola Cecilio

    Más que un comentario sobre el tema, es un reconocimiento por el trabajo que haces en este tu blog. Sé el esfuerzo que toma preparar entradas y publicarlas (más si involucran código), y en verdad se te agradece mucho por lo que estas haciendo (no muchos profesionales con tu preparación se tomarían la molestia).

    También vi tu perfil, me has motivado, y déjame decirte que a eso quiero llegar: un arquitecto java certificado (latino xD).

    Saludos

    • Cecilio Álvarez Caules 14 septiembre, 2013 at 8:51 #

      Muchas Gracias por el comentario juan .Se agradece 🙂

  6. David 11 abril, 2014 at 13:29 #

    Me encanta este blog. Tus ejemplos son siempre claros y directos al grano, y son cosas que nos son útiles en el trabajo.

    Thanks! 🙂

    • Cecilio Álvarez Caules 11 abril, 2014 at 15:22 #

      gracias 🙂

  7. Carlos 18 marzo, 2015 at 20:16 #

    Hola tengo una duda.. en cuanto a esto como. Tengo un grupo de beans definidos mediante anotaciones y otros quiero definirlo mediante un fichero xml. Como lo hago

    • Cecilio Álvarez Caules 20 marzo, 2015 at 8:07 #

      No deberías tener ningún problema mientras tengas activado el uso de anotaciones en spring . Los beans que se registren vía xml siempre están disponibles

Trackbacks/Pingbacks

  1. Enlaces interesantes #4 | David Herrera Bits - 15 junio, 2013

    […] Spring responsabilidades y organización En este post Cecilio Alvarez da un buen consejo sobre Spring y la organización de ficheros. Tal […]

  2. Spring Framework y aislamiento | Arquitectura JavaArquitectura Java - 28 julio, 2014

    […] Artículos relacionados: Spring y Responsabilidades , Spring […]

  3. Spring Anotaciones vs XML | Arquitectura JavaArquitectura Java - 18 agosto, 2014

    […] 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 […]

  4. Spring Singleton vs Prototype - Arquitectura Java - 14 abril, 2015

    […] artículos relacionados: Spring Organización ,Spring XML vs […]

  5. Spring @Inject CDI y standards - Arquitectura Java - 28 junio, 2015

    […] artículos relacionados:  JAX-RS , Spring Responsabilidades,  Spring […]

  6. Utilizando Spring Profiles - Arquitectura Java - 8 enero, 2017

    […] Otros artículos relacionados: Spring PropertyPlaceHoldersConfigurar, Spring responsabilidad y Organización […]

Deja un comentario

Uso de cookies

Este sitio web utiliza cookies para que usted tenga la mejor experiencia de usuario. Si continúa navegando está dando su consentimiento para la aceptación de las mencionadas cookies y la aceptación de nuestra política de cookies, pinche el enlace para mayor información.plugin cookies