Contenido


Aspectos básicos de Spring Boot

Empiece a utilizar Spring Boot para escribir aplicaciones de Spring que "simplemente se ejecutan"

Comments

Spring Boot es una infraestructura ligera que elimina la mayor parte del trabajo de configurar las aplicaciones basadas en Spring. En este tutorial, aprenderá cómo utilizar los iniciadores, los criterios y la estructura de archivos ejecutable JAR de Spring Boot para crear rápidamente aplicaciones basadas en Spring que "simplemente se ejecutan".

Después de una breve introducción a Spring Boot, le guiaré a través del proceso de configurar y ejecutar dos aplicaciones de Spring Boot: una sencilla aplicación "Hola, Mundo" y una aplicación de servicios web Spring MVC RESTful ligeramente más compleja. Observe que, para mis aplicaciones de ejemplo, utilizo la versión 1.5.2 de Spring Boot. Le recomiendo utilizar la versión 1.5.2 o superior, aunque, los ejemplos deberían funcionar para cualquier versión posterior a la 1.5.

Requisitos previos

Para sacar el máximo provecho del tutorial, se debe estar cómodo utilizando Java™ Development Kit, versión 8 (JDK 8). También será necesario estar familiarizado con Eclipse IDE, Maven y Git.

Para seguir con el tutorial, asegúrese de tener instalado este software:

Quiero hablar un poco acerca de Spring Boot antes de que entremos a fondo en el tutorial.

¿Qué es Spring Boot?

El objetivo de Spring Boot es proporcionar un conjunto de herramientas para construir rápidamente aplicaciones de Spring que sean fáciles de configurar.

El problema: ¡Configurar Spring es difícil!

Si usted ya ha escrito una aplicación basada en Spring, ya sabe que la mayor parte del trabajo consiste en configurarlo para solo decir "Hola, Mundo". Esto no es algo malo: Spring es un elegante conjunto de infraestructuras que, para funcionar correctamente, requieren una configuración cuidadosamente coordinada. Pero, esa elegancia conlleva el costo de la complejidad en la configuración (y ni siquiera quiero empezar con todo ese XML).

La solución: Spring Boot

Entre a Spring Boot. El sitio web de Spring Boot lo dice más sucintamente de lo que yo puedo:

Spring Boot facilita la creación de aplicaciones basadas en Spring, autónomas y del nivel de producción que "simplemente se ejecutan". Tomamos una visión dogmática de la plataforma de Spring y de las bibliotecas de terceros para que pueda empezarse con el mínimo revuelo.

Básicamente, esto significa que es posible poner en funcionamiento una aplicación de Spring con muy poca configuración. La poca configuración que se necesita está en forma de anotaciones, así que nada de XML.

Todo eso suena genial, ¿verdad? Pero, ¿cómo funciona exactamente Spring Boot?

Primero, es intuitivo

Spring Boot tiene criterios. Ésta es sólo otra forma de decir que Spring Boot tiene valores predeterminados razonables, para que usted pueda desarrollar una aplicación rápidamente a través de esos valores usados habitualmente.

Por ejemplo, Tomcat es un contenedor web muy popular. De forma predeterminada, una aplicación web de Spring Boot utiliza un contenedor Tomcat incorporado.

Segundo, es personalizable

Una infraestructura intuitiva no es de mucha utilidad si no es posible cambiar sus criterios. Es posible personalizar fácilmente una aplicación de Spring Boot para que coincida con sus gustos, tanto en la configuración inicial como, después, en el ciclo de desarrollo.

Por ejemplo, si usted prefiere Maven, puede cambiar fácilmente los valores de <dependencia> de su archivo POM para reemplazar el valor predeterminado de Spring Boot. Usted lo realizará más adelante en el tutorial.

Empiece a utilizar Spring Boot

Iniciadores

Los iniciadores son una gran parte de la magia de Spring Boot, se utilizan para limitar la cantidad de configuración manual de las dependencias que usted tiene que hacer. Si se va a utilizar Spring Boot efectivamente, se debe saber acerca de los iniciadores.

Un iniciador es esencialmente un conjunto de dependencias (como un Maven POM) que son específicas para el tipo de aplicación que el iniciador representa.

Todos los iniciadores utilizan la siguiente convención de nomenclatura: spring-boot-starter-XYZ, donde XYZ es el tipo de aplicación que se quiere desarrollar. Estos son algunos iniciadores populares de Spring Boot:

  • spring-boot-starter-web se utiliza para desarrollar servicios web de RESTful con Spring MVC y Tomcat como el contenedor de aplicaciones incorporado.
  • spring-boot-starter-jersey es una alternativa a spring-boot-starter-web que utiliza Apache Jersey en vez de Spring MVC.
  • spring-boot-starter-jdbc se utiliza para el agrupamiento de conexiones JDBC. Se basa en la implementación del grupo de conexiones JDBC de Tomcat.

La página de referencia de iniciadores de Spring Boot hace una lista con muchos más iniciadores. Eche un vistazo para ver el POM y las dependencias para cada iniciador.

Configuración automática

Si se lo permite, Spring Boot utilizará su anotación @EnableAutoConfiguration para configurar automáticamente su aplicación. La configuración automática se basa en el JARS de su ruta de clases y en cómo ha definido sus beans:

  • Spring Boot utiliza los JAR que se haya especificado que estén presentes en la CLASSPATH para formar una opinión acerca de cómo configurar un determinado comportamiento automático. Por ejemplo, si usted tiene el JAR de la base de datos H2 en su ruta de clases y no ha configurado otros beans de DataSource su aplicación se configurará automáticamente con una base de datos en memoria.
  • Spring Boot utiliza la manera en que usted define los beans para configurarse automáticamente. Por ejemplo, si usted anota sus beans de JPA con @Entity, Spring Boot configurará automáticamente el JPA de forma que no se necesite un archivo persistence.xml .

El über jar de Spring Boot

Spring Boot tiene el objetivo de ayudar a que los desarrolladores creen aplicaciones que "simplemente se ejecutan". Para ello, empaqueta la aplicación y sus dependencias en un JAR único y ejecutable. Para ejecutar la aplicación hay que iniciar Java de esta forma:

$ java -jar PATH_TO_EXECUTABLE_JAR/executableJar.jar

El über JAR de Spring Boot no es un concepto nuevo. Ya que Java no proporciona una forma estándar para cargar los JAR anidados, los desarrolladores llevan años utilizando herramientas como el plug-in Apache Maven Shade para desarrollar JAR "sombreados". Un JAR sombreado simplemente contiene los archivos .class de todos los JAR dependientes de la aplicación. Pero, a medida que la complejidad de las aplicaciones aumenta y las dependencias se incrementan, los JAR sombreados pueden presentar dos problemas:

  1. Colisiones de nombres, donde dos clases de JAR diferentes tienen el mismo nombre.
  2. Problemas con la versión de las dependencias, donde dos JAR utilizan diferentes versiones de la misma dependencia.

Spring Boot resuelve esos problemas definiendo un diseño especial del archivo JAR donde los propios JARs se anidan dentro del Über JAR. El soporte para herramientas de Spring (por ejemplo, el plug-in spring-boot-maven ) después desarrolla el über JAR ejecutable para seguir ese diseño (no sólo desempaqueta y reempaqueta los archivos .class , como con un JAR sombreado). Cuando se ejecuta el JAR ejecutable, Spring Boot utiliza un cargador de clases especial para manejar las clases que están dentro de los JARs anidados.

Diga ¡Hola, Mundo!

Ahora está listo para empezar a trabajar directamente por Spring Boot. Los ejemplos de esta sección se basan en una sencilla aplicación llamada HelloSpringBoot. Le animo a que trabaje conmigo en el ejemplo de desarrollo de la aplicación, pero, si quiere entrar directamente, es posible descargar el código de la aplicación desde Github.

¡Vamos a entrar directamente con este y vamos a crear un nuevo proyecto de Maven!

1

Cree el proyecto de Maven

En Eclipse, vaya a Archivo > Nuevo Proyecto y seleccione Maven > Proyecto de Maven, como se muestra en la Imagen 1.

Figura 1. Cómo seleccionar un proyecto de Maven
Captura de pantalla del diálogo Eclipse New Project para seleccionar un proyecto Maven.
Captura de pantalla del diálogo Eclipse New Project para seleccionar un proyecto Maven.

Haga clic en Siguiente, después, vuelva a hacer clic en Siguiente en el diálogo posterior (no se muestra).

Se le pedirá que elija el arquetipo de su nuevo proyecto de Maven. Seleccione maven-archetype-quickstart, como se muestra en la Figura 2.

Figura 2. Seleccionar el arquetipo de inicio rápido de Maven
Captura de pantalla del cuadro de diálogo Nuevo proyecto para seleccionar el arquetipo de inicio rápido de Maven.
Captura de pantalla del cuadro de diálogo Nuevo proyecto para seleccionar el arquetipo de inicio rápido de Maven.

Haga clic en Siguiente.

Finalmente, introduzca los ajustes del artefacto como se muestra en la Figura 3.

Figura 3. Seleccionar los ajustes del artefacto de Maven
Captura de pantalla del cuadro de diálogo Nuevo proyecto para seleccionar la configuración del arquetipo Maven.
Captura de pantalla del cuadro de diálogo Nuevo proyecto para seleccionar la configuración del arquetipo Maven.

Para la aplicación HelloSpringBoot estoy utilizando los siguientes ajustes:

  • ID de Grupo: com.makotojava.learn
  • ID de Artefacto: HelloSpringBoot
  • Versión: 1.0-SNAPSHOT
  • Paquete: com.makotojava.learn.hellospringboot

Para crear el proyecto, haga clic en Finalizar.

Ahora abra App.java en Eclipse y reemplace todo su contenido con lo siguiente:

        package com.makotojava.learn.hellospringboot;

        import java.util.Arrays;

        import org.slf4j.Logger;
        import org.slf4j.LoggerFactory;
        import org.springframework.boot.CommandLineRunner;
        import org.springframework.boot.SpringApplication;
        import org.springframework.boot.autoconfigure.SpringBootApplication;
        import org.springframework.context.ApplicationContext;
        import org.springframework.context.annotation.Bean;

        @SpringBootApplication
        public class App {

          private static final Logger log = LoggerFactory.getLogger(App.class);

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

          @Bean
          public CommandLineRunner commandLineRunner(ApplicationContext ctx) {
            return args -> {

              log.debug("Vamos a inspeccionar las semillas que Spring Boot ha proporcionado:");

              String[] beanNames = ctx.getBeanDefinitionNames();
              Arrays.sort(beanNames);
              for (String beanName : beanNames) {
                log.debug(beanName);
              }

            };
          }
        }

Después, cree una clase nueva llamada HelloRestController en el mismo paquete que Aplicación que se parezca a esto:

        package com.makotojava.learn.hellospringboot;

        import org.springframework.web.bind.annotation.RequestMapping;
        import org.springframework.web.bind.annotation.RestController;

        @RestController
        public class HelloRestController {

          @RequestMapping("/hola")
          public String hello() {
            return "Hello. All your base are belong to us.";
          }
        }
2

Cree el POM

Modifique el POM que ha creado por el asistente del Nuevo Proyecto para que se parezca al Listado 1.

Listado 1. El archivo POM para HelloSpringBoot
                <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.makotojava.learn</groupId>
                    <artifactId>HelloSpringBoot</artifactId>
                    <version>1.0-SNAPSHOT</version>
                    <packaging>jar</packaging>
                    <name>HelloSpringBoot</name>
                    <url>http://maven.apache.org</url>
                    <parent>
                    	<groupId>org.springframework.boot</groupId>
                    	<artifactId>spring-boot-starter-parent</artifactId>
                    	<version>1.5.2.RELEASE</version>
                    </parent>
                    <dependencies>
                    	<dependency>
                    		<groupId>org.springframework.boot</groupId>
                    		<artifactId>spring-boot-starter-web</artifactId>
                    	</dependency>
                    </dependencies>
                    <properties>
                    	<java.version>1.8</java.version>
                    </properties>
                    <build>
                    	<plugins>
                    		<plugin>
                    			<groupId>org.springframework.boot</groupId>
                    			<artifactId>spring-boot-maven-plugin</artifactId>
                    		</plugin>
                    	</plugins>
                    </build>
                </project>

Observe las líneas que están destacadas en el Listado 1:

Las líneas de 10 a 14 muestran el elemento <parent>, que específica el POW del objeto primario de Spring Boot y que contiene las definiciones para los componentes comunes. No es necesario configurar estos manualmente.

Las líneas de 16 a 19 muestran la <dependencia> en el iniciador spring-boot-starter-web de Spring Boot. Esto dice a Spring Boot que la aplicación es una aplicación web. Spring Boot formará sus criterios según eso.

Las líneas de 25 a 30 dicen a Maven que utilice el plug-in spring-boot-maven-plugin para generar la aplicación de Spring Boot.

No es tanta configuración, ¿verdad?Observe que no hay XML. Para la configuración que falta utilizaremos anotaciones de Java.

Más acerca de los criterios de Spring Boot

Antes de continuar, quiero hablar un poco acerca de los criterios de Spring Boot. En concreto, creo que es importante explicar cómo Spring Boot utiliza un iniciador como spring-boot-starter-web para formar sus criterios de configuración.

La aplicación de ejemplo, HelloSpringBoot, utiliza el iniciador de aplicaciones web de Spring Boot, spring-boot-starter-web. Basándose en este iniciador, Spring Boot ha formado los siguientes criterios acerca de la aplicación:

  • Contenedor de servicios web incorporados de Tomcat
  • Hibernate para el Mapeo Objeto-Relacional (ORM, por sus siglas en inglés)
  • Apache Jackson para JSON vinculante
  • Spring MVC para la infraestructura de REST

¡Hablemos acerca de la intuición! Aunque, en defensa de Spring Boot, estos son los valores predeterminados de las aplicaciones web más populares—al menos, las que yo conozco y utilizo todo el tiempo.

Pero, ¿recuerda que dije que Spring Boot es personalizable? Si se quiere utilizar una pila tecnológica diferente, puede sobrescribir fácilmente los valores predeterminados de Spring Boot.

Después veremos una personalización sencilla.

Perder el <parent>

¿Y si usted ya tuviera un elemento <parent> en su POM, o si simplemente no quisiera utilizarlo? ¿Spring Boot seguirá funcionando?

Sí, lo hará, pero usted tendrá que hacer dos cosas:

  1. Añadir manualmente las dependencias (lo que incluye las versiones)
  2. Añadir un fragmento de configuración a su spring-boot-maven-plugin, tal como se muestra en el Listado 2:
    Listado 2. Cómo especificar el objetivo reempaquetar cuando no se utiliza el elemento POM del <parent>
                	<build>
                		<plugins>
                			<plugin>
                				<groupId>org.springframework.boot</groupId>
                				<artifactId>spring-boot-maven-plugin</artifactId>
                				<version>1.5.2.RELEASE</version>
                				<executions>
                					<execution>
                						<goals>
                							<goal>repackage</goal>
                						</goals>
                					</execution>
                				</executions>
                			</plugin>
                		</plugins>
                	</build>

Es importante puntualizar que el elemento <parent> hace mucha magia genial de Maven, así que, si usted tiene una buena razón para no utilizarlo, proceda con precaución. Asegúrese de que añade la ejecución del objetivo de reempaquetar a spring-boot-maven-plugintal como se explica aquí.

El proyecto se configura y personaliza. Ahora, es el momento de desarrollar el ejecutable.

3

Desarrollar el JAR ejecutable

Con Maven hay dos opciones para desarrollar el JAR ejecutable:

  1. Ejecutar el desarrollo de Maven en Eclipse
  2. Ejecutar el desarrollo de Maven desde la línea de comando

Le mostraré cómo hacer ambas.

Desarrolar en Eclipse

Para ejecutar el desarrollo de Maven en Eclipse, haga clic derecho en el archivo POM y elija Ejecutar como > Desarrollo de Maven. En el campo de texto Objetivos, ingrese limpiar y empaquetar, después, haga clic en el botón Ejecutar.

Figura 4. Desarrollar el JAR ejecutable en Eclipse
Construye el JAR ejecutable en Eclipse
Construye el JAR ejecutable en Eclipse

En la vista de consola debería aparecer un mensaje indicando una desarrollo exitoso:

.
.
[INFO] ------------------------------------------------------------------------
[INFO] CONSTRUCCIÓN EXITOSA
[INFO] ------------------------------------------------------------------------
[INFO] Tiempo total: 2,440 s
[INFO] Acabada a las: 2017-04-16T10:17:21-05:00
[INFO] Memoria Final: 30M/331M
[INFO] ------------------------------------------------------------------------

Desarrollar desde la línea de comando

Para ejecutar el desarrollo de Maven desde la línea de comandos, abra una ventana terminal de Mac o un indicador de comandos de Windows, navegue hasta el directorio del proyecto HelloSpringBoot , y ejecute el comando:

mvn clean package

En la ventana de terminal o en la línea de comandos debería aparecer un mensaje indicando un desarrollo correcto:

                $ cd HelloSpringBoot
                $ pwd
                /Users/sperry/home/HelloSpringBoot
                $ mvn clean package
                .
                .
                [INFO] ------------------------------------------------------------------------
[INFO] CONSTRUCCIÓN EXITOSA
[INFO] ------------------------------------------------------------------------
[INFO] Tiempo total: 2,440 s
[INFO] Acabada a las: 2017-04-16T10:17:21-05:00
[INFO] Memoria Final: 30M/331M
[INFO] ------------------------------------------------------------------------ $

Ahora está listo para ejecutar el JAR ejecutable.

4

Ejecutar el JAR ejecutable

Para ejecutar el JAR que acaba de crear, abra una ventana terminal de Mac o un indicador de comandos de Windows, navegue hasta la carpeta del proyecto HelloSpringBoot , y ejecute:

java -jar target/HelloSpringBoot-1.0-SNAPSHOT.jar

donde objetivo es el directorio de salida predeterminado de la compilación. Si usted lo ha configurado de forma diferente, haga la sustitución adecuada en el comando anterior.

El resultado de Spring Boot contiene una "Pantalla de Bienvenida" basada en texto (líneas de 2 a 7) junto con otro resultado, que es similar al listado siguiente. Sólo muestro algunas líneas, para proporcionar una idea de lo que se debería ver cuando se ejecuta la aplicación:

$ java -jar target/HelloSpringBoot-1.0-SNAPSHOT.jar
  .   ____          _            __ _ _
 /\\ / ___'_ __ _ _(_)_ __  __ _ \ \ \ \
( ( )\___ | '_ | '_| | '_ \/ _` | \ \ \ \
 \\/  ___)| |_)| | | | | || (_| |  ) ) ) )
  '  |____| .__|_| |_|_| |_\__, | / / / /
 =========|_|==============|___/=/_/_/_/
 :: Spring Boot ::        (v1.5.2.RELEASE)
2017-04-15 17:46:12.919  INFO 20096 --- [           main] c.makotojava.learn.hellospringboot.App   : Starting App v1.0-SNAPSHOT on Ix.local with PID 20096 (/Users/sperry/home/projects/learn/HelloSpringBoot/target/HelloSpringBoot-1.0-SNAPSHOT.jar started by sperry in /Users/sperry/home/projects/learn/HelloSpringBoot)
2017-04-15 17:46:12.924 DEBUG 20096 --- [           main] c.makotojava.learn.hellospringboot.App   : Running with Spring Boot v1.5.2.RELEASE, Spring v4.3.7.RELEASE
.
.
2017-04-15 17:46:15.221  INFO 20096 --- [           main] c.makotojava.learn.hellospringboot.App   : Aplicación Iniciada en 17,677 segundos (JVM ejecutándose desde 18,555)

Si la aplicación se inicia correctamente, la última línea del resultado de Spring Boot contendrá las palabras "Aplicación Iniciada" (línea 13). Ahora, usted está listo para emplear su aplicación, que es lo siguiente que hará.

5

Emplear la aplicación

Es posible ejecutar el único método REST de HelloSpringBoot abriendo un navegador y presionando la siguiente URL:

http://localhost:8080/hello
Figura 5. Hello, Spring Boot!
Una captura de pantalla de la aplicación web HelloSpringBoot.
Una captura de pantalla de la aplicación web HelloSpringBoot.

Si usted ve el texto "Hello, All your base are belong to us" (una página de inicio para videojuego Zero Wing), ¡sabrá que la aplicación funciona!

Cómo cambiar las opiniones de Spring Boot

Las opiniones de Spring Boot se basan en los contenidos del POM, lo que incluye el iniciador de Spring Boot que usted especificó cuándo configuró inicialmente su aplicación. Después de formar una opinión acerca del tipo de aplicación que usted quiere construir, Spring Boot proporciona un conjunto de dependencias de Maven. La Figura 4 muestra algunas de las dependencias de Maven que Spring Boot ha establecido en Eclipse, basándose en los contenidos del POM y en el iniciador que se ha especificado para la aplicación HelloSpringBoot:

Figura 6. Dependencias iniciales para HelloSpringBoot
Configuración de dependencia predeterminada para HelloSpringBoot.
Configuración de dependencia predeterminada para HelloSpringBoot.

Observe que Tomcat es el contenedor predeterminado del servidor web incorporado. Ahora, vamos a suponer que en vez de Tomcat quiere utilizar Jetty. Todo lo que tiene que hacer es cambiar la sección <dependencias> del POM (sólo pegue las líneas 5 a 15 del Listado 3 sobre la línea 19 del cambio de Listado 1):

Listado 3. POM para utilizar Jetty en vez de Tomcat
            	<dependencies>
            		<dependency>
            			<groupId>org.springframework.boot</groupId>
            			<artifactId>spring-boot-starter-web</artifactId>
            			<exclusions>
            				<exclusion>
            					<groupId>org.springframework.boot</groupId>
            					<artifactId>spring-boot-starter-tomcat</artifactId>
            				</exclusion>
            			</exclusions>
            		</dependency>
            		<dependency>
            			<groupId>org.springframework.boot</groupId>
            			<artifactId>spring-boot-starter-jetty</artifactId>
            		</dependency>
            	</dependencies>

Observe a continuación que las dependencias de Maven para Tomcat ya no están (gracias a las líneas 5 a 10 del Listado 3), y se han reemplazado con las dependencias para Jetty (líneas de 12 a 15).

Figura 7. Dependencias personalizadas para HelloSpringBoot
Configuración de dependencia personalizada para HelloSpringBoot.
Configuración de dependencia personalizada para HelloSpringBoot.

De hecho, hay más dependencias de Jetty de las que entrarían en una única captura de pantalla, pero están todas ahí, y ya no están las dependencias de Tomcat. ¡Pruébelo y véalo por usted mismo!

Diga ¡Hola, Galaxy!

Los ejemplos sencillos son geniales, ¡pero Spring Boot es capaz de mucho más! En esta sección, le mostraré cómo hacer que Spring Boot muestre su potencial con una aplicación web de Spring MVC RESTful. Lo primero que hay que hacer es configurar la nueva aplicación de ejemplo, SpringBootDemo.

SpringBootDemo

SpringBootDemo es una clase envoltorio de Spring Boot que envuelve una sencilla aplicación POJO basada en Spring llamada oDoT. (Como ToDo al revés... ¿lo pilla?) La idea es recorrer el proceso de desarrollar una aplicación que sea más compleja que un sencillo Hola, Mundo. También aprenderá a envolver una aplicación existente con Spring Boot.

Para configurar y ejecutar SpringBootDemo hará tres cosas:

  1. Obtener el código de GitHub.
  2. Desarrollar y ejecutar el JAR ejecutable.
  3. Acceder a la aplicación a través de SoapUI.

He creado una videoguía de ayuda para cada paso de este proceso. Puede iniciar el video ahora.

1

Obtenga el código

Para empezar, tiene que clonar dos proyectos desde sus repositorios de GitHub. El primero, llamado odotCore, contiene la lógica empresarial de la aplicación, que está escrita como una aplicación de POJO basada en Spring. La otra, llamada SpringBootDemo, es una aplicación de envoltorio de Spring Boot que envuelve odotCore.

Para clonar el repositorio odotCore, abra una ventana terminal de Mac o una línea de comandos de Windows, navegue hasta carpeta raíz en la que quiere que el código resida y ejecute el comando:

git clone https://github.com/makotogo/odotCore

Para clonar el repositorio de SpringBootDemo, ejecute el comando:

git clone https://github.com/makotogo/SpringBootDemo

Observe que los dos proyectos se subordinan inmediatamente al directorio raíz de la aplicación. Después, usted importará el código a su área de trabajo.

2

Importe el código a Eclipse

Vaya a Archivo > Importar... y elija Maven > Proyectos Existentes de Maven.

En el siguiente diálogo, utilice el botón Examinar para buscar el directorio raíz. Los dos proyectos que se clonaron en el paso anterior deberían aparecer en el diálogo, tal como se muestra aquí:

Figura 8. Importar Proyectos de Maven
Captura de pantalla del diálogo: Importar proyectos Maven.
Captura de pantalla del diálogo: Importar proyectos Maven.

Haga clic en Finalizar para importar los proyectos a su área de trabajo de Eclipse. Después desarrollará el JAR ejecutable.

3

Construir el JAR ejecutable

El desarrollo de SpringBootDemo requiere que desarrolles ambos proyectos odotCore y SpringBootDemo. Es posible desarrollar los proyectos desde la línea de comando, tal como vio en la aplicación HelloSpringBoot. En este caso, le mostraré como hacerlo con Eclipse.

En Eclipse, haga clic derecho en el proyecto odotCore. Elija Ejecutar como > Compilación de Maven y especifique las metas limpiar e instalar . La meta instalar instalará el archivo JAR odotCore-1.0-SNAPSHOT.jar en su repositorio local de Maven. Desde ahí, estará disponible para ser obtenida como dependencia cuando se ejecute la compilación SpringBootDemo Maven.

Después de que la compilación odotCore Maven se ejecute correctamente, haga clic derecho en el proyecto SpringBootDemo, elija Ejecutar como > Compilación de Maven y especifique las metas limpiar y empaquetar .

Después de que la compilación de SpringBootDemo se haya ejecutado correctamente, podrá ejecutar el über JAR de SpringBootDemo desde la línea de comando.

4

Ejecutar el JAR ejecutable

Desde una ventana terminal de Mac o desde el indicador de comandos de Windows, navegue hasta el directorio SpringBootDemo. Suponiendo que el directorio de salida de la compilación se llama target (es lo predeterminado), ejecute el siguiente comando:

java -jar target/SpringBootDemo-1.0-SNAPSHOT.jar

Ahora, acomódese para asombrarse mientras Spring Boot ejecuta la aplicación. Cuando vea el texto "Aplicación Iniciada" estará listo para emplear la aplicación.

5

Emplear la aplicación

Como prueba rápida para asegurarnos de que la aplicación está funcionando correctamente, abra una ventana del navegador e ingrese el siguiente URL:

http://localhost:8080/CategoryRestService/FindAll

Esto accede al método FindAll de CategoryRestService y devuelve todos los objetos de la Categoría de la base de datos en formato JSON.

Figura 9. Cómo acceder a SpringBootDemo a través de un navegador
Accediendo a la aplicación SpringBootDemo a través de un navegador.
Accediendo a la aplicación SpringBootDemo a través de un navegador.

También se puede emplear la aplicación a través de SoapUI. Aquí no demostraré cómo hacerlo, pero, en el video de este tutorial oriento sobre el proceso.

La Tabla 1 muestra los servicios y los métodos que hay dentro de cada servicio para SpringBootDemo.

Tabla 1. Servicios y Métodos de oDoT (SpringBootDemo)
ServicioMétodoMétodo HTTPURL de ejemplo en http://localhost:8080
CategoríaFindAllGET/CategoryRestService/FindAllEncuentra todos los objetos de la categoría que están en la BD.
CategoríaFindByIdGET/CategoryRestService/FindbyId/1Encuentra Categoría por el ID con valor 1.
CategoríaFindByIdGET/CategoryRestService/FindbyName/MI_CATEGORIAEncuentra Categoría por el nombre con valor "MI_CATEGORIA".
CategoríaAñadirPUT/CategoryRestService/AddAñade la Categoría especificada (como carga útil de JSON en el cuerpo solicitado) a la BD. Devuelve: El objeto de la categoría que se añadió (como JSON en el cuerpo de la respuesta).
CategoríaActualicePOST/CategoryRestService/UpdateActualiza la Categoría especificada (como carga útil de JSON en el cuerpo solicitado) de la BD. Devuelve: Un mensaje con una cadena de caracteres que indica el estado de la actualización.
CategoríaBorrarDELETE/CategoryRestService/DeleteBorra la Categoría especificada (como carga útil de JSON en el cuerpo solicitado) de la BD. Devuelve: Un mensaje con una cadena de caracteres que indica el estado del borrado.
ArtículoFindAllGET/ItemRestService/FindAllEncuentra todos los objetos de la categoría que están en la BD.
ArtículoFindByIdGET/ItemRestService/FindbyId/1Encuentra Categoría por el ID con valor 1.
ArtículoFindByIdGET/ItemRestService/FindbyName/TODO_ITEM_1Encuentra el artículo por el nombre con valor "TODO_ITEM_1".
ArtículoAñadirPUT/ItemRestService/AddAñade el Artículo especificado (como carga útil de JSON en el cuerpo solicitado) a la BD. Devuelve: El objeto del Artículo que se añadió (como JSON en el cuerpo de la respuesta).
ArtículoActualicePOST/ItemRestService/UpdateActualiza el Artículo especificado (como carga útil de JSON en el cuerpo solicitado) de la BD. Devuelve: Un mensaje con una cadena de caracteres que indica el estado de la actualización.
ArtículoBorrarDELETE/ItemRestService/DeleteBorra el Artículo especificado (como carga útil de JSON en el cuerpo solicitado) de la BD. Devuelve: Un mensaje con una cadena de caracteres que indica el estado del borrado.

Le recomiendo que estudie el código, que juegue un poco con él y que tenga una mejor sensación de cómo funciona Spring Boot.

Conclusión

En este tutorial le he presentado los problemas que Spring Boot soluciona y un poco sobre cómo funciona. Después, he enseñado cómo configurar y ejecutar una sencilla aplicación de Spring Boot llamada HelloSpringBoot. Finalmente, he mostrado cómo se construye y emplea una aplicación de servicios web de Spring MVC RESTful con Spring Boot.

Así que, ¿qué va a hacer a partir de aquí?


Recursos para Descargar


Temas relacionados


Comentarios

Inicie Sesión o Regístrese para agregar comentarios.

static.content.url=http://www.ibm.com/developerworks/js/artrating/
SITE_ID=90
Zone=tecnologia Java
ArticleID=1062779
ArticleTitle=Aspectos básicos de Spring Boot
publish-date=05112017