Spring Tutorial de Introducción

El principal componente del framework Spring es el contenedor de inversión de control (IoC) este contenedor es el encargado de administrar los beans, un beans es un objeto Java que es administrado por Spring, es decir, la tarea de instanciar, inicializar y destruir objetos será delegada a este contenedor, el mismo también realiza otras tareas como la inyección de dependencias (DI).

Antes de poder utilizar el contenedor Spring debemos configurarlo, tradicionalmente esta configuración se hace mediante un archivo XML, pero, esta no es la única manera, también es posible utilizar anotaciones y código Java, tengamos presente que siempre podemos combinar los distintos métodos según nos convenga.

Spring ApplicationContext

El contenedor Spring esta representado por las interfaces BeanFactory y ApplicationContext, la primera contiene las funcionalidades básicas de IoC y la segunda es la opción preferida para crear aplicaciones empresariales, extiende las funcionalidades de la primera para brindar servicios adicionales.

Contamos con diferentes clases que implementan ApplicationContext, estas clase ubican la configuración y crean el respectivo contenedor, entre ellas tenemos:

• ClassPathXmlApplicationContext: crear un contenedor Spring a partir del archivo de configuración XML almacenado en el classpath de nuestro proyecto.
• FileSystemXmlApplicationContext: igual que el anterior, salvo que podemos indicar la ruta completa del archivo de configuración XML e indicar si está en el classpath o el sistema de archivos, ejemplo: "file:///c:/spring/configuracion.xml".
• XmlWebApplicationContext: crea un contenedor para aplicaciones web a partir del archivo XML ubicado en el directorio web, ejm: "WEB-INF/configuracion.xml".
• AnnotationConfigApplicationContext: crea una contenedor IoC Spring usando la configuración basada en anotaciones o código Java.
• AnnotationConfigWebApplicationContext: igual que el anterior salvo que este será un contenedor para aplicaciones web.

Crear una aplicación Spring con NetBeans

Para crear aplicaciones con Spring Framework no requerimos un IDE en especial, usaremos NetBeans 8, primero agregamos un nuevo proyecto, Maven / Java Application. 

Una vez tenemos el proyecto Maven preparado debemos agregar la librería Spring, para ello abrimos el archivo pom.xml, en NetBeans 8, en la pestaña Projects hacemos clic derecho sobre el proyecto y presionamos Open POM.

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

Agregando esta dependencia tendremos todo lo necesario para crear una aplicación simple.

Para la programación de nuestro primer programa, el clásico hola mundo, vamos a añadir una interface y una clase la que implemente, la implementación es sencilla, solo muestra el mensaje en la consola de salida.

public interface HelloService {
    void saludar();
}

public class HelloServiceIpml implements HelloService {
    @Override
    public void saludar() {
        System.out.println("Hello Spring Framework");
    }
}

Spring no impone el trabajo con interfaces, pero es una buena practica.

Configuración Spring con XML

NetBeans nos brinda un asistente para crear al archivo de configuración XML, en la pestaña Projects hacemos clic derecho sobre el proyecto y presionamos New / Other… esto abre la ventana que vemos abajo, seleccionamos Other / SpringXMLConfig y presionamos Next >.

En la siguiente ventana debemos indicar el nombre y la ubicación del archivo XML, para nuestro propósito el nombre es springXMLConfig y se ubica en src/main/resources.

Al presionar Next se abrirá otra ventana donde podemos seleccionar los namespace que vamos a utilizar, de momento no los requerimos así que solo finalizamos.

Si abrimos el archivo springXMLConfig.xml veremos como definir un Spring Bean usando <bean /> donde id establece el identificador y class el tipo del bean, que obviamente es la clase creada previamente, en próximos tutoriales veremos más detalladamente el proceso de creación y configuración de beans.

<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-4.3.xsd">

    <bean id="saludaService" class="carmelo.spring.introduccion.HelloServiceImpl"/>
    
</beans>

Con esto ya solo nos hace falta crear el contenedor Spring usando esta configuración, para ello haremos uso de la clase ClassPathXmlApplicationContext, es su constructor indicamos el archivo XML.

import org.springframework.context.support.AbstractApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;

public class Introduccion {

    public static void main(String[] args) {

        AbstractApplicationContext ctx = new ClassPathXmlApplicationContext("springXMLConfig.xml");
        
        HelloService saluda = ctx.getBean("saludaService", HelloService.class);
        saluda.saludar();
        
        ctx.close();
    }
}

Para obtener un bean usaremos el método getBean en este ejemplo indicamos su nombre y el tipo, vemos como podemos trabajar perfectamente con interfaces aunque no es estrictamente necesario.

Al invocar el método saluda.saludar() veremos en la ventana de salida el mensaje: “Hello Spring Framework“, al finalizar usamos ctx.close() para terminar la ejecución de el ApplicationContext.

Configuración Spring con Java sin XML

Para finalizar veamos como realizar la configuración usando código Java eliminando por completo el uso de XML, para hacerlo debemos crear una clase y añadirle la anotación @Configuration para crear bean desde código Java usaremos la anotación @Bean.

import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;

@Configuration
public class SpringConfiguration {
    
    @Bean
    public HelloService saludaService(){
        return new HelloServiceImpl();
    }
}

Esta configuración es equivalente a la anterior, el nombre del bean esta determinado por el nombre del método, aunque podemos indicarlo manualmente, mientras que el tipo lo establece el valor de retorno, en el siguiente tutorial detallaremos este tipo de configuración.  

AbstractApplicationContext ctx = new AnnotationConfigApplicationContext(SpringConfiguration.class);

HelloService saluda = ctx.getBean("saludaService", HelloService.class);
saluda.saludar();

ctx.close();

Podemos observar que el único cambio necesario para usar esta configuración es que ahora utilizamos la clase AnnotationConfigApplicationContext para instanciar el  ApplicationContext en su constructor indicamos la clase usada para configurar, todo lo demás permanece igual.

Configuración Spring usando anotaciones

Para utilizar este tipo de configuración haremos uso de las anotaciones: @Component, @Controller, @Service, @Repository, el contenedor Spring analizará el proyecto en busca de clases que contengan estas anotaciones, de encontrarla procederá a crear los beans correspondientes al tipo de anotación, más adelante veremos en detalles cada una de estas anotaciones.

Necesitamos modificar la clase HelloServiceImpl creada previamente, le añadimos la anotación @Service("saludaService")indicando el id o nombre del bean, si no lo indicamos este será igual al nombre de la clase con la letra inicial en minúscula.

import org.springframework.stereotype.Service;

@Service("saludaService")
public class HelloServiceImpl implements HelloService {

    @Override
    public void saludar() {
        System.out.println("\n--- Hello Spring Framework ---\n");
    }
}

Cuando Spring encuentre esta clase creará un bean llamado saludaService, el tipo es el mismo de la clase anotada, antes de terminar hay que indicarle al contenedor Spring cual es el paquete que debe escanear en busca de las anotaciones.

Si el contenedor Spring lo creamos o configuramos  mediante código Java con la clase AnnotationConfigApplicationContext, usamos la anotación @ComponentScan("carmelo.spring.introduccion") sobre la clase de configuración, debemos indicarle cual es el paquete que debe escanear.

import org.springframework.context.annotation.ComponentScan;
import org.springframework.context.annotation.Configuration;

@Configuration
@ComponentScan("carmelo.spring.introduccion")
public class SpringConfiguration {
    
}

Si la configuración del contenedor Spring se hace usando un archivo XML con la clase ClassPathXmlApplicationContext primero agregamos el namespace xmlns:context="http://www.springframework.org/schema/context" para poder utilizar la etiqueta XML  <context:component-scan /> donde usamos base-package para indicar cual es el paquete a escanear.

<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.3.xsd
       http://www.springframework.org/schema/context http://www.springframework.org/schema/context/spring-context-4.2.xsd">

    <context:component-scan base-package="carmelo.spring.introduccion"/>
    
</beans>

En ambos casos ya no necesitamos definir el bean saludaService usando @Bean o <bean /> ya que el mismo será creado automáticamente al detectar la clase con la anotación @Service que es usada para definir los beans de la capa de servicios de la aplicación.

Ver en GitHub: Tutoriales Spring Framework