[:es]Desarrollo de aplicaciones Web con Spring Boot[:]

[:es]Desarrollo de aplicaciones Web con Spring Boot[:]

agosto 14, 2017 Jorge Aguilar 0 Comments

[:es]Según el sitio oficial del proyecto, se puede definir Spring Boot de la siguiente manera: «Es una solución para crear aplicaciones basadas en Spring de una manera rápida, autónoma y con características deseables para producción».

Al momento, resulta de mucho interés contar con herramientas que apoyen al desarrollo rápido de aplicaciones. Y ésta es la motivación principal para presentar esta primera entrada sobre el tema.

Entre las principales características de Spring Boot se encuentran:

Contenedores Java embebidos: Tomcat o Jetty
Soporte para la automatización con Maven y Gradle
Configuración sugerida para iniciar rápidamente con un proyecto (Starters)
Configura automáticamente Spring, cuando sea posible
Características listas para producción: métricas, seguridad, verificación del estatus, externalización de configuración, etc.
No genera código y no requiere configuración XML

Alcance

En este proyecto se creará un servicio REST de consulta de productos que retorne la respuesta en formato JSON utilizando Maven como herramienta de automatización de tareas.

Herramientas Utilizadas

Se requieren instaladas y disponibles las siguientes herramientas:

Java 8
Maven 3.2 o superior

Procedimiento

A continuación se detallan los pasos a seguir para conseguir el objetivo planteado. Si se desea acceder al proyecto terminado, ya sea para ejecutarlo directamente o para resolver alguna duda, éste está disponible en:

https://github.com/softwareevolutivo/springboot-gs

1. Configuración inicial del proyecto utilizando Maven

Lo primero que se deberá realizar es crear el directorio del proyecto. En este caso se lo ha nombrado springboot-gs.
Dentro de este directorio crear el archivo POM (pom.xml) inicial, el cual deberá tener la siguiente definición.

<?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>ec.com.softwareevolutivo.demos</groupId>
    <artifactId>springbootgs</artifactId>
    <version>0.0.1-SNAPSHOT</version>
    <name>springbootgs</name>
    <description>Spring Boot Getting Started</description>

    <parent>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-parent</artifactId>
        <version>1.5.2.RELEASE</version>
    </parent>

</project>

En este primer paso se ha creado la relación de nuestro proyecto con el proyecto padre spring-boot-starter-parent utilizando la versión 1.5.2.RELEASE. Esta simple definición permite a nuestro proyecto hacer ya uso de algunas funcionalidades de Spring Boot.

Estos grupos de funcionalidades son denominados Starters, más adelante se incorporará al proyecto un Starter adicional.

Para validar que todo está correctamente configurado ejecutamos un primer empaquetado utilizando Maven dentro del directorio del proyecto:

mvn package

El resultado de esta ejecución será la creación del directorio target, el cual deberá contener el archivo empaquetado del proyecto: springboot-gs-0.0.1-SNAPSHOT.jar

Para finalizar esta primera parte, procederemos a consultar las dependencias con las que cuenta el proyecto:

mvn dependency:tree

En la salida de este comando no se verá ninguna dependencia relacionado al proyecto:

... [INFO] [INFO] --- maven-dependency-plugin:2.10:tree (default-cli) @ springbootgs --- [INFO] ec.com.softwareevolutivo.demos:springbootgs:jar:0.0.1-SNAPSHOT [INFO] ------------------------------------------------------------------------ [INFO] BUILD SUCCESS ...

2. Dependencia Web

Como el objetivo de esta demo incluye la creación de un servicio REST será necesario incorporar las dependencias Web de Spring. Esto se lo consigue adicionando al archivo POM el Starter respectivo, en este caso spring-boot-starter-web después de la sección parent.

    ...
    </parent>

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

</project>

Ejecutamos nuevamente la consulta de dependencias del proyecto:

mvn dependency:tree

Y en esta ocasión ya podremos ver las dependencias incorporadas al proyecto por medio del Starter Web. Es importante resaltar el hecho de que las versiones de las librerías incorporadas por el Starter son resueltas de manera automática.
... [INFO] [INFO] --- maven-dependency-plugin:2.10:tree (default-cli) @ springbootgs --- [INFO] ec.com.softwareevolutivo.demos:springbootgs:jar:0.0.1-SNAPSHOT [INFO] \- org.springframework.boot:spring-boot-starter-web:jar:1.5.2.RELEASE:compile [INFO] +- org.springframework.boot:spring-boot-starter:jar:1.5.2.RELEASE:compile [INFO] | +- org.springframework.boot:spring-boot:jar:1.5.2.RELEASE:compile [INFO] | +- org.springframework.boot:spring-boot-autoconfigure:jar:1.5.2.RELEASE:compile [INFO] | +- org.springframework.boot:spring-boot-starter-logging:jar:1.5.2.RELEASE:compile [INFO] | | +- ch.qos.logback:logback-classic:jar:1.1.11:compile [INFO] | | | +- ch.qos.logback:logback-core:jar:1.1.11:compile [INFO] | | | \- org.slf4j:slf4j-api:jar:1.7.24:compile [INFO] | | +- org.slf4j:jcl-over-slf4j:jar:1.7.24:compile [INFO] | | +- org.slf4j:jul-to-slf4j:jar:1.7.24:compile [INFO] | | \- org.slf4j:log4j-over-slf4j:jar:1.7.24:compile [INFO] | +- org.springframework:spring-core:jar:4.3.7.RELEASE:compile [INFO] | \- org.yaml:snakeyaml:jar:1.17:runtime [INFO] +- org.springframework.boot:spring-boot-starter-tomcat:jar:1.5.2.RELEASE:compile [INFO] | +- org.apache.tomcat.embed:tomcat-embed-core:jar:8.5.11:compile [INFO] | +- org.apache.tomcat.embed:tomcat-embed-el:jar:8.5.11:compile [INFO] | \- org.apache.tomcat.embed:tomcat-embed-websocket:jar:8.5.11:compile [INFO] +- org.hibernate:hibernate-validator:jar:5.3.4.Final:compile [INFO] | +- javax.validation:validation-api:jar:1.1.0.Final:compile [INFO] | +- org.jboss.logging:jboss-logging:jar:3.3.0.Final:compile [INFO] | \- com.fasterxml:classmate:jar:1.3.3:compile [INFO] +- com.fasterxml.jackson.core:jackson-databind:jar:2.8.7:compile [INFO] | +- com.fasterxml.jackson.core:jackson-annotations:jar:2.8.0:compile [INFO] | \- com.fasterxml.jackson.core:jackson-core:jar:2.8.7:compile [INFO] +- org.springframework:spring-web:jar:4.3.7.RELEASE:compile [INFO] | +- org.springframework:spring-aop:jar:4.3.7.RELEASE:compile [INFO] | +- org.springframework:spring-beans:jar:4.3.7.RELEASE:compile [INFO] | \- org.springframework:spring-context:jar:4.3.7.RELEASE:compile [INFO] \- org.springframework:spring-webmvc:jar:4.3.7.RELEASE:compile [INFO] \- org.springframework:spring-expression:jar:4.3.7.RELEASE:compile [INFO] ------------------------------------------------------------------------ [INFO] BUILD SUCCESS

3. La aplicación Spring Boot

Para que la aplicación Spring Boot pueda ejecutarse desde la línea de comandos, se requiere la definición del conocido método main. Este método será utilizado por Spring Boot para iniciar la aplicación. Esto es esencial para que la aplicación se ejecute en modo stand-alone.

Esto se lo puede realizar creando una clase (Application en este caso) que implemente este método y que haga la llamada al método run de la clase SpringApplication.

Por convención, todas las clases Java deberán estar almacenadas en el directorio src/main/java dentro del directorio del proyecto. Hay que recordar que este archivo también debe residir dentro de un directorio correspondiente al paquete, en este caso ec/com/softwareevolutivo/demos/springbootgs

package ec.com.softwareevolutivo.demos.springbootgs;

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

@SpringBootApplication
public class Application {

    public static void main(String[] args) {
        SpringApplication.run(Application.class, args);
    }
    
}

En este punto ya se podrá ejecutar la aplicación a través de Maven desde el directorio principal del proyecto:

mvn spring-boot:run

Esta ejecución levanta un servidor Web que escucha en el puerto por defecto 8080. Se lo puede detener utilizando la combinación de teclas Control + C.

4. Clase del dominio

La clase Product será utilizada como parte del dominio del tipo DTO y tendrá la información correspondiente a cada producto de la lista que se desea retornar.

package ec.com.softwareevolutivo.demos.springbootgs.domain.dto;

public class Product {

    private Long id;
    private String name;
    private double price;

    public Long getId() {
        return id;
    }

    public void setId(Long id) {
        this.id = id;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public double getPrice() {
        return price;
    }

    public void setPrice(double price) {
        this.price = price;
    }

}

5. Servicio REST

En este punto se procederá a crear el servicio REST que retornará la lista de productos en formato JSON. La clase ProductRest será utilizada para retornar la lista de productos.

package ec.com.softwareevolutivo.demos.springbootgs.web.rest;

import java.util.ArrayList;
import java.util.List;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RestController;
import ec.com.softwareevolutivo.demos.springbootgs.domain.dto.Product;

@RestController
@RequestMapping("/api")
public class ProductRest {

      @GetMapping("/products")
      public List<Product> getAllProducts() {
        
          List<Product> productList = new ArrayList<Product>();
          
          Product product1 = new Product();
          product1.setId(1L);
          product1.setName("Product 1");
          product1.setPrice(22.99);
          productList.add(product1);
          
          Product product2 = new Product();
          product2.setId(2L);
          product2.setName("Product 2");
          product2.setPrice(3.49);
          productList.add(product2);
          
          return productList;
          
      }
}

Las anotaciones @RestController, @RequestMapping y @GetMapping pertenecen a Spring Web MVC y son utilizadas para crear el servicio REST.

Ejecutar nuevamente la aplicación y validar que el servicio REST esté operativo:

mvn spring-boot:run

Según lo establecido en la clase ProductRest parte del URL para acceder al servicio REST sería api/products y en este caso el servicio estaría disponible en http://localhost:8080/api/products.

Utilizando un navegador Web se podrá ver la respuesta del servicio REST:

[
   {
      "id": 1
      "name": "Product 1",
      "price": 22.99
   },
   {
      "id": 1,
      "name": "Product 2",
      "price": 3.49
   }
]

6. Crear el ejecutable

Para facilitar la transferencia de la aplicación en un solo empaquetado se puede convertir el archivo empaquetado jar en ejecutable. Esto se lo realiza por medio del plugin spring-boot-maven-plugin, el cual deberá ser adicionado a la configuración de maven.

    ...
    </dependencies>

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

</project>

Como ya se lo hizo inicialmente, proceder con creación del empaquetado:

mvn package

En el directorio target deberán existir dos archivos empaquetados del proyecto:

El archivo springbootgs-0.0.1-SNAPSHOT.jar.original solamente contiene las clases creadas para el proyecto y un par de archivos de metadata.
Por otro lado, el archivo springbootgs-0.0.1-SNAPSHOT.jar, de mayor tamaño, incluye todas las dependencias requeridas para ejecutar la aplicación en modo stand-alone.

La ejecución de la aplicación stand-alone se la puede realizar utilizando Java Standard Edition (SE):

java -jar target/springboot-gs-0.0.1-SNAPSHOT.jar

Resumen y conclusiones

Utilizando soluciones como Spring Boot se podría reducir considerablemente el tiempo de desarrollo de aplicaciones Web con servicios REST.
Spring Boot ha tenido un crecimiento importante en los últimos años. Generadores como JHipster la están usando ampliamente.
En esta entrega se ha presentado Spring Boot de tal manera que el lector pueda empezar en su uso. En próximas entregas se podrá tratar otras de las ventajas que presenta la herramienta.

Referencias

En el caso de presentarse dudas, comentarios, erratas 🙂 los animamos a comentar. Recordar que también se puede compartir esta entrada por las redes sociales.[:]