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.

It's only fair to share...Share on FacebookShare on Google+Tweet about this on TwitterShare on LinkedIn

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