Spring Framework - Lo básico

Spring es un framework con muchos años de vida, robusto y muy utilizado para ejecutar aplicaciones web.

Esta formado de numerosos módulos como se ve en la figura:



Spring 5 parte como base del JDK 8 y Jakarta EE 7 con lo que no funcionara en entornos anteriores.

La parte más fundamental de Spring (Core) es un contenedor (llamado IoC Container) con objetos que serán suministrados cuando se necesite un objeto que cumpla con unas condiciones determinadas (por ejemplo implementar una interface). Este patrón se conoce como Inyección de Dependencias (DI). Vamos a ver cómo se añaden esos objetos a ese contenedor y cómo se solicitan después.

Los objetos que se añaden al contenedor reciben el nombre de beans. Hay tres formas de añadir beans al contenedor:

1. Mediante ficheros XML utilizando la etiqueta
2. Usando Configuración Java, con la anotación @Bean
3. Por Anotaciones, utilizando la anotación @Component entre otras

Las dos primeras se conocen como configuraciones explicitas mientras que las anotaciones se conocen como implícitas. Este esquema lo muestra de forma gráfica:

¿Entonces cuál de las tres formas es mejor?

Aunque todas pueden usarse con sus diferentes pros y contras, a lo largo del curso voy a centrarme bastante en la declaración por ficheros XML. Escojo esta forma por los siguientes motivos:

1. Es la más flexible ya que desacopla completamente la configuración del código. Simplemente reemplazando nuestro fichero XML la aplicación funcionaría con la nueva configuración sin recompilar.
2. Al desacoplar el código de la configuración no hace falta tener acceso a él o modificarlo. Esto no sería posible con las anotaciones ya que se deben modificar los miembros anotados.
3. Hay escasa documentación, así que voy a explicar la dispersa información que he recopilado. ¡Y encima en español!

No obstante habrá ejemplos para todas las formas para saber elegirlas en función de las ventajas e inconvenientes en cada caso.

¿Cómo cargar una dependencia por XML?

Lo primero que debemos hacer es cargar el contenedor con los beans que necesitemos. En esta ocasión vamos a comentar el código relacionado con SpringBoot para cargar beans sin él. Posteriormente se verá la diferencia usándolo. La configuración para la creación del contenedor puede estar repartida en varios ficheros XML como en este ejemplo:

ApplicationContext context = 
    new ClassPathXmlApplicationContext(
                   new String[]{"configfile1.xml",
                                "configfile2.xml"});

Vamos a declarar por XML nuestro primer bean poniendo el siguiente código en un fichero llamado config.xml que pondremos en nuestra carpeta src/main/resources:

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

    <!-- bean definitions here -->
    <bean class="es.lanyu.Test" id="test" init-method="init">
        <property name="testString" value="¡He sido inyectada por XML!"></property>
    </bean>

</beans>

Una vez que está en el contenedor ya podemos recuperarlo buscándolo en el contexto de la aplicación por su nombre o clase con este código genérico:

UsefulClass usefulClass =  (UsefulClass) context.getBean("myBeanName");
UsefulClass usefulClass = context.getBean(UsefulClass.class);

En nuestro caso vamos a recuperarlo usando la clase Test y llamamos al método init.

De todas formas, no se recomienda solicitar los beans de esta forma cuando se necesitan sino inyectarlos, como veremos más adelante, con otros mecanismos que tiene Spring. En este ejemplo lo usamos para probar que el bean se ha creado y nuestro contenedor nos lo suministra.

En GitHub puedes ver un ejemplo de todos los pasos hasta aquí y ver el video del webinar.

En la siguiente entrada vamos a ver las otras formas de crear un bean.