Spring Boot : Crear una Aplicación Web

Spring Boot es un sub-proyecto Spring que simplifica y agiliza el proceso de creación y desarrollo de aplicaciones web o de escritorio que utilicen el Framework Spring, la configuración requerida para iniciar una aplicación, de cualquier tipo, es mínima y automática, Spring Boot se auto-configura analizando el classpath, además se elimina por completo la necesidad de tener archivos de configuración XML, a pesar de ello el mecanismo de configuración se mantiene bastante flexible, permitiéndonos personalizar la configuración siempre que lo necesitemos.

Nos es necesario tener alguna herramienta especial para crear nuestras aplicaciones, es posible utilizar la mayoría de los IDEs como: NetBeans, Eclipse, IntelliJ, etc., tampoco es un requisito, pero si una buena opción utilizar una herramienta que nos facilite la administración de las dependencias, en este serie de cursos usaremos Maven, debe ser la versión 3.2 o superior, obviamente también requerimos el JDK la versión 1.6 en adelante. 

La manera mas sencilla de crear el proyecto inicial es dirigirse a la web: https://start.spring.io aquí seleccionarás el tipo de proyecto y le versión a utilizar, en la sección Project Metadata introduces la información correspondiente a tu proyecto, en la sección Dependencies deberás seleccionar las dependencias requeridas por tu proyecto, por ejemplo, para crear una aplicación web agregamos Web, para acceso a datos JPA, puedes agregar todos los que sean necesarios, para finalizar presiona Generate Project para descargar el proyecto en un archivo comprimido ZIP.

Presionando en el enlace que se encuentra en la parte inferior, que dice: “Switch to the full version”, expandirás la ventana y se mostrará más detalladamente las opciones de configuración.

Para abrir el proyecto con NetBeans 8 nos vamos al menú File | Open Project... y localizamos la carpeta descomprimida del proyecto que acabamos de generar.

Lo primero que debemos ver es el archivo pom.xml, lo abrimos, clic derecho sobre el proyecto y seleccionamos Open POM, veremos:

<parent>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-parent</artifactId>
    <version>1.5.1.RELEASE</version>
    <relativePath/> <!-- lookup parent from repository -->
</parent>

Con esto heredamos las funcionalidades que nos permitirán administrar las dependencias de nuestro proyecto de una manera fácil.

<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-jdbc</artifactId>
</dependency>
<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-thymeleaf</artifactId>
</dependency>
<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-web</artifactId>
</dependency>

Para iniciar un proyecto de manera rápida contamos con los spring-boot-starter-*, estos nos permiten administrar un grupo de dependencias para un proyecto en especifico, por ejemplo: spring-boot-started-web contiene todas las dependencias necesarias para crear una aplicación web MVC, spring-boot-starter-jdbc añade las dependencias requeridas para realizar el acceso a datos con la API JDBC, spring-boot-starter-thymeleaf nos proporciona las dependencias que requiere el motor de plantillas Thymeleaf el cual usaremos para generar nuestras vistas, existen muchos más, para todo tipo de proyectos.

<build>
    <plugins>
        <plugin>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-maven-plugin</artifactId>
        </plugin>
    </plugins>
</build>

Este plugin maven será el encargado de empaquetar la aplicación en el correspondiente archivo jar, este contiene todo los necesario para ejecutarse con el comando java -jar.

Esta es la estructura de nuestro proyecto inicial, si vemos la clase IntroduccionApplication encontraremos el método main(String[] args) este es el punto de inicio de nuestra aplicación, el método SpringApplication.run() es el encargado de iniciar la aplicación, como argumento le indicamos la clase de configuración y los argumentos de comandos, la clase de configuración es la propia clase IntroduccionApplication la misma usa la anotación @SpringBootApplication la cual es equivalente a utilizar las anotaciones: @Configuration, @EnableAutoConfiguration y @ComponentScan, estas anotaciones hacen lo siguiente:

• @Configuration: Indica que esta es una clase usada para configurar el contenedor Spring.
• @ComponentScan: Escanea los paquetes de nuestro proyecto en busca de los componentes que hayamos creado, ellos son,  las clases que utilizan las siguientes anotaciones: @Component, @Service, @Controller, @Repository.
• @EnableAutoConfiguration: Habilita la configuración automática, esta herramienta analiza el classpath y el archivo application.properties para configurar nuestra aplicación en base a las librerías y valores de configuración encontrados, por ejemplo: al encontrar el motor de bases de datos H2 la aplicación se configura para utilizar este motor de datos, al encontrar Thymeleaf se crearan los beans necesarios para utilizar este motor de plantillas para generar las vistas de nuestra aplicación web.

Si lo deseamos podemos personalizar la aplicación, para ello creamos una instancia de la clase SpringApplication y cambiamos el comportamiento deseado, por ejemplo, para deshabilitar el banner usamos Banner.Mode.OFF.

import org.springframework.boot.Banner;
import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;

@SpringBootApplication
public class IntroduccionApplication {

    public static void main(String[] args) {
        SpringApplication app = new SpringApplication(IntroduccionApplication.class);
        app.setBannerMode(Banner.Mode.OFF);
        app.run(args);
    }
}

En el constructor usamos indicamos la clase de configuración, con el método app.run(args) iniciamos ala ejecución de la aplicación.

Si deseas crea una aplicación de escritorio no web debes desactivar los componente web, lo hacen del siguiente modo: app.setWebEnvironment(false);

Nuestro primer controlador

Crearemos nuestro primer controlador que llamaremos HomeController y lo ubicaremos en el paquete carmelo.spring.web es importante que los controladores se ubiquen en un paquete dentro del paquete que contiene la clase principal para que puedan ser detectados correctamente.

package carmelo.springboot.web;

import org.springframework.stereotype.Controller;
import org.springframework.ui.Model;
import org.springframework.web.bind.annotation.RequestMapping;

@Controller
public class HelloController {
    
    @RequestMapping("/hello")
    public String showHello(Model model){
        model.addAttribute("saludo", "Mi primera aplicacion web Spring Boot");
        return "hello";
    }
}

Este controlador responde a la petición HTTP localhost:8080/hello, añade un atributo al modelo y retorna el nombre lógico de la vista, hello, para más detalles puedes ver: Spring MVC Controladores.

Las vistas será generadas con motor de plantillas Thymeleaf, según nuestro controlador requerimos el archivo src/main/resources/templates/hello.html.

<!DOCTYPE html>
<html xmlns:th="http://www.thymeleaf.org">
    <head>
        <meta charset="UTF-8"/>
        <title>Spring Boot</title>
    </head>
    <body>     
        <p th:text="${saludo}" />
    </body>
</html>

También vamos a añadir el archivo src/main/resources/static/index.html esta es la página que se muestra al agregar a localhost:8080/ de modo que en esta página solo añadiremos un enlace que nos lleve a localhost:8080/hello para ver nuestro controlador funcionando.

<!DOCTYPE html>
<html>
    <head>
        <title>Spring Boot</title>
        <meta charset="UTF-8">
    </head>
    <body>
        <a href="/hello">Go Home</a>
    </body>
</html>

Con esto tenemos nuestra primera aplicación web Spring Boot lista.

Si deseamos cambiar la ubicación y la extensión de las plantillas editamos el archivo de propiedades application.properties para agregar las siguientes configuraciones:

spring.thymeleaf.prefix=classpath:/views/
spring.thymeleaf.suffix=.html

La primera indica las carpetas donde se encuentran las plantillas y la segunda la extensión de las mismas, con este ejemplo nuestra vista será src/main/resources/views/hello.html.

Ejecutar una aplicación Spring Boot

Spring Boot trabaja con servidor integrado, por defecto Apache Tomcat, para ejecutar nuestra aplicación, en NetBeans IDE solo presionamos Run, si todo está correcto podemos ir al navegar y deberemos ver nuestra aplicación.

Una aplicación web Spring Boot puede ejecutarse desde la consola de comandos sin problemas, de la siguiente manera: java -jar target/introduccion-0.0.1-SNAPSHOT.jar

Nuestra aplicación en el navegador:

También es posible ejecutar una aplicación usando el Spring Boot Maven Plugin con el siguiente comando: mvn spring-boot:run

Debemos tener presente que si una instancia de la aplicación está ejecutándose e intentamos iniciar otra instancia se producirá un error ya que el puerto estará en uso, es posible cambiar el puerto mediante el archivo application.properties añadiendo server.port=8178 donde 8178 es el nuevo puerto.

En este tutorial hemos visto la simplicidad que nos aporta Spring Boot a la hora de crear aplicaciones web MVC, no requerimos configuración XML, el DispatcherServlet, ViewResolver, y todo los requerido para crear una aplicación web fue configurado de manera automática, no fue necesario desplegar la aplicación en un servidor externo, estos son algunos de los beneficios obtenidos al utilizar esta herramienta, en próximos tutoriales veremos mas características interesantes.

Más tutoriales: Programación Spring Framework