Configuración Contenedor Sprin IoC

Vamos a configurar el contenedor de Inversión de control (IoC) de Spring Framework, el contenedor se encarga de crear, configurar y ensamblar los beans de la aplicación.  Un  bean es  un objeto Java que es administrado por el contenedor Spring.

Si no has revisado la entrada sobre el contenedor Spring , te recomiendo que lo hagas.

Contenido

• Metadatos de configuración
• Manejo contenedor Spring
• Crear Proyecto

Metadatos de configuración

Para utilizar el contenedor de Spring, debemos configurarlo a traves de metadatos, los metadatos de configuración respresentan cómo usted como desarrollador le dice al contenedor Spring que cree instancias, configure y ensamble los objetos en su aplicación. Podemos configurar los metados de tres formas:

• Archivo XML: forma tradicional de configuración
• Anotaciones:  a partir de la versión 2.5  de Spring
• Codigo Java:  a partir de la version 3.0 de Spring 

Manejo del Contenedor Spring

Las interfaces BeanFactory y ApplicationContext representan al contenedor Spring, la primera provee  una configuración basica, la segunda extiende las funcionalidades de BeanFactoty e implementa una configuración más especifica para el contenedor.

Por lo general, ApplicationContext es utilizada para representar al contenedor Spring, tenemos varias implementaciones de ApplicationContext, veamos algúnas de ellas:

Las implementaciones de color verde, comúnmente  son utilizadas para crear una instancia del contenedor Spring,  cada una de ellas se acopla a un tipo de metadatos de configuración, veamos algunos detalles:

• ClassPathApplicationContext: crea el contendor Spring a partir de la configuración del archivo XML ubicado en el classpath del proyecto.
• FileSystemXmlApplicationContext: crea el contenedor Spring a partir de la configuración del archivo XML, ubicado en el classPath del proyecto o en otra ruta, se debe especificar una ruta absoluta.
• AnnotationConfigApplicationContext: crear el contenedor Spring a partir de la configuración basada en código Java o anotaciones.

Podemos combinar los tipos de metadatos configuración, depende del proyecto que vas a desarrollar, que configuración se adapte mejor.

Crear Proyecto Spring

Creamos un proyecto con Maven que muestre el típico mensaje Hola Mundo. 

Agregamos la dependencia de spring-context en archivo pom.xml, spring-context nos provee todo lo necesario para configurar el contenedor Spring 

<dependencies> 
	<dependency> 	
        	<groupId>org.springframework</groupId>
            	<artifactId>spring-context</artifactId>
            	<version>5.3.15</version>
	</dependency > 

</dependencies> 

Interface Saludo

package com.curso.spring;

public interface Saludo {
	
	void saludar();
}

Clase SaludoImpl

Implementamos la interface Saludo y sobrescribimos el metodo saludar()

package com.curso.spring;

public class SaludoImpl implements Saludo{
	
   	 @Override
	public void saludar(){
    	System.out.println("Hola Mundo");  
    }
}

Configurar contenedor Spring mediante XML

Creamos el archivo applicationContext.xml dentro de src/main/resources/META-INF/ para los metadatos de configuración

<?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
    			 https://www.springframework.org/schema/beans/spring-beans.xsd">

	
	<bean id="miSaludo" class="com.curso.spring.SaludoImpl"</bean> 
</beans>

Entre las etiquetas <beans> se define los distintos <bean> de la aplicación, cada uno de ellos requiere de almenos dos atributos:

• id: define un identificador único para el <bean>
• class: define el tipo del <bean> y utiliza el nombre de clase completo.

Instanciar Contenedor Spring

Para probar el programa, tenemos que crear una instancia del contenedor Spring, utilizamos  ClassPathXmlApplicationContext

package com.curso.spring;
import org.springframework.context.support.ClassPathXmlApplicationContext;
public class Test {

	public static void main(String [] args){
    	
        ClassPathXmlApplicationContext context = new ClassPathXmlApplicationContext("META-INF/applicationContext.xml");

	Saludo saludo =  (Saludo)context.getBean("miSaludo");

	saludo.saludar();
		
	context.close();  
    }
}

Para ClassPathXmlApplicationContext(archivoConfi) se debe pasar como argumento del constructor, el archivo XML que contiene los metados de configuración, para nuestro ejemplo es applicationContext.xml

A través del objeto context  accedemos a los <bean> definidos en el Contenedor Spring, utilizamos el metodo getBean("miSaludo"), pasando como argumento el id del bean a recupear.

El metodo  context.close(), cierra el flujo del contenedor Spring, no se podrá  obtener  mas <bean> del contenedor Spring.

Si te fijas, la clase principal Test nunca crea el objeto miSaludo, sino, que es el contenedor Spring quien crea ese objeto, a esto llamamos inversión de control.

Salida Consola

 Hola Mundo Spring

¡Hasta pronto 👋👍!