Guía Detallada: “Hello World” con Spring Framework

En este caso, usaremos la configuración XML para definir los componentes y el contexto de Spring. Esto es más tradicional y útil para quienes aún prefieren o necesitan trabajar con configuraciones basadas en XML.

Requisitos Previos

Asegúrate de tener los siguientes elementos listos:

Paso 1: Crear un Proyecto

Crea un proyecto Maven con la siguiente estructura:

hello-world-spring
├── src
│   ├── main
│   │   ├── java
│   │   │   └── com
│   │   │       └── ejemplo
│   │   │           └── helloworld
│   │   ├── resources
│   │   │   └── applicationContext.xml
├── pom.xml

Paso 2: Configuración de Maven

En tu archivo pom.xml, necesitas incluir las dependencias necesarias para Spring Framework. A continuación te dejo el archivo pom.xml básico para nuestro proyecto:

<?xml version="1.0" encoding="UTF-8"?>
<project xmlns="http://maven.apache.org/POM/4.0.0"
         xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
         xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
    <modelVersion>4.0.0</modelVersion>

    <groupId>com.ejemplo</groupId>
    <artifactId>hello-world-spring</artifactId>
    <version>1.0-SNAPSHOT</version>
    <packaging>jar</packaging>

    <dependencies>
        <!-- Spring Framework Core -->
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-core</artifactId>
            <version>5.3.23</version>
        </dependency>

        <!-- Spring Framework Web (para trabajar con aplicaciones web) -->
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-webmvc</artifactId>
            <version>5.3.23</version>
        </dependency>

        <!-- Spring Framework Beans (para la inyección de dependencias) -->
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-beans</artifactId>
            <version>5.3.23</version>
        </dependency>

        <!-- Log4j para los logs (opcional) -->
        <dependency>
            <groupId>org.apache.logging.log4j</groupId>
            <artifactId>log4j-api</artifactId>
            <version>2.17.1</version>
        </dependency>

        <!-- JUnit para las pruebas -->
        <dependency>
            <groupId>junit</groupId>
            <artifactId>junit</artifactId>
            <version>4.13.2</version>
            <scope>test</scope>
        </dependency>
    </dependencies>

    <build>
        <plugins>
            <!-- Maven Compiler Plugin -->
            <plugin>
                <groupId>org.apache.maven.plugins</groupId>
                <artifactId>maven-compiler-plugin</artifactId>
                <version>3.8.1</version>
                <configuration>
                    <source>1.8</source>
                    <target>1.8</target>
                </configuration>
            </plugin>
        </plugins>
    </build>
</project>

Este archivo configura las dependencias de Spring necesarias y otros elementos como el compilador de Maven.

Paso 3: Crear la Clase del Controlador

Ahora vamos a crear una clase Java que manejará las solicitudes HTTP. Crea un archivo llamado HelloWorldController.java en el paquete com.ejemplo.helloworld:

package com.ejemplo.helloworld;

public class HelloWorldController {

    private String message;

    // Getter y Setter para la propiedad 'message'
    public String getMessage() {
        return message;
    }

    public void setMessage(String message) {
        this.message = message;
    }

    // Método que devuelve el mensaje
    public void showMessage() {
        System.out.println(message);
    }
}

En este caso, tenemos una clase sencilla que tiene una propiedad message y un método showMessage que imprime ese mensaje en la consola.

Paso 4: Crear el Archivo de Configuración XML

A continuación, crearemos el archivo applicationContext.xml en la carpeta src/main/resources/. Este archivo es donde configuraremos el contexto de Spring y la inyección de dependencias.

Crea el archivo applicationContext.xml con el siguiente contenido:

<?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-5.3.xsd">

    <!-- Definir el bean de HelloWorldController -->
    <bean id="helloWorldController" class="com.ejemplo.helloworld.HelloWorldController">
        <property name="message" value="Hello, World! desde Spring Framework"/>
    </bean>

</beans>

Aquí estamos declarando un bean de tipo HelloWorldController y configurando su propiedad message para que contenga el texto "Hello, World! desde Spring Framework".

Paso 5: Crear la Clase Principal para Ejecutar la Aplicación

Ahora necesitamos una clase principal que cargue el contexto de Spring y ejecute el controlador. Crea un archivo llamado MainApp.java en el paquete com.ejemplo.helloworld:

package com.ejemplo.helloworld;

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

public class MainApp {

    public static void main(String[] args) {

        // Cargar el contexto de Spring desde el archivo XML
        ApplicationContext context = new ClassPathXmlApplicationContext("applicationContext.xml");

        // Obtener el bean HelloWorldController
        HelloWorldController controller = (HelloWorldController) context.getBean("helloWorldController");

        // Llamar al método showMessage para imprimir el mensaje
        controller.showMessage();
    }
}

En esta clase:

Paso 6: Ejecutar la Aplicación

Para ejecutar la aplicación, abre la terminal y usa Maven para compilar y ejecutar el proyecto:

  1. Compilar el proyecto:

    mvn clean install

  2. Ejecutar la aplicación:

    mvn exec:java -Dexec.mainClass="com.ejemplo.helloworld.MainApp"

Resultado Esperado

Al ejecutar la aplicación, deberías ver el siguiente mensaje en la consola:

Hello, World! desde Spring Framework

Esto indica que la configuración de Spring fue correcta y que el bean fue creado e inyectado con el valor que definimos en el archivo XML.

Resumen

En esta guía, hemos cubierto cómo crear una aplicación Hello World utilizando Spring Framework clásico con configuración XML. Los pasos que seguimos fueron:

  1. Crear el proyecto y configurar el pom.xml con las dependencias necesarias.
  2. Crear un controlador simple con un método que imprime un mensaje.
  3. Configurar un archivo applicationContext.xml para definir el bean y sus propiedades.
  4. Crear una clase principal para cargar el contexto y ejecutar la aplicación.

Este enfoque es más tradicional en Spring, y aunque Spring Boot ha ganado popularidad por su simplicidad, seguir trabajando con configuraciones XML sigue siendo útil en muchos casos.