Aspectos básicos de Spring Boot

Empiece a utilizar Spring Boot para escribir aplicaciones de Spring que

"simplemente se ejecutan"

J Steven Perry 11-5-2017

Descubra cómo utilizar los iniciadores, los criterios y la estructura de archivos ejecutable JAR
de Spring Boot para escribir rápidamente aplicaciones basadas en Spring que "simplemente se
ejecutan".

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:

•  JDK 8 para Windows, Mac y Linux.

•  Eclipse IDE para Windows, Mac y Linux.
•  Apache Maven para Windows, Mac y Linux.
•  Git para Windows, Mac y Linux.
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.

© 版权所有 IBM 公司 2017 商标
Aspectos básicos de Spring Boot 第 1 页，共 23
developerWorks® ibm.com/developerWorks/cn/

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.

Aspectos básicos de Spring Boot 第 2 页，共 23

ibm.com/developerWorks/cn/ developerWorks®

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:
Eche un vistazo: ponga en marcha su aplicación de Spring Boot con la opción --debug y en la
consola se generará un informe de configuración automática.

•  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

Aspectos básicos de Spring Boot 第 3 页，共 23

developerWorks® ibm.com/developerWorks/cn/

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.

Aspectos básicos de Spring Boot 第 4 页，共 23

ibm.com/developerWorks/cn/ developerWorks®

图 1. Cómo seleccionar un proyecto de 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.

Aspectos básicos de Spring Boot 第 5 页，共 23

developerWorks® ibm.com/developerWorks/cn/

图 2. Seleccionar el arquetipo de inicio rápido de Maven

Aspectos básicos de Spring Boot 第 6 页，共 23

ibm.com/developerWorks/cn/ developerWorks®

Haga clic en Siguiente.

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

图 3. Seleccionar los ajustes del artefacto de 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;

Aspectos básicos de Spring Boot 第 7 页，共 23

developerWorks® ibm.com/developerWorks/cn/

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.

清单 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>

Aspectos básicos de Spring Boot 第 8 页，共 23

ibm.com/developerWorks/cn/ developerWorks®

<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

Aspectos básicos de Spring Boot 第 9 页，共 23

developerWorks® ibm.com/developerWorks/cn/

•  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:
清单 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>

Verificar las dependencias: Si alguna vez necesitase ver exactamente cuáles son las dependencias
que está incorporando el iniciador de Spring Boot que usted está utilizando, visite la página de
referencia de iniciadores de Spring Boot.

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.

Aspectos básicos de Spring Boot 第 10 页，共 23

ibm.com/developerWorks/cn/ developerWorks®

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.

图 4. Desarrollar el JAR ejecutable en Eclipse

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

Aspectos básicos de Spring Boot 第 11 页，共 23

developerWorks® ibm.com/developerWorks/cn/

.
.
[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:

Aspectos básicos de Spring Boot 第 12 页，共 23

ibm.com/developerWorks/cn/ developerWorks®

$ 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

Aspectos básicos de Spring Boot 第 13 页，共 23

developerWorks® ibm.com/developerWorks/cn/

图 5. Hello, Spring Boot!

Aspectos básicos de Spring Boot 第 14 页，共 23

ibm.com/developerWorks/cn/ developerWorks®

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:

图 6. Dependencias iniciales 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 清
单 1):

Aspectos básicos de Spring Boot 第 15 页，共 23

developerWorks® ibm.com/developerWorks/cn/

清单 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).

图 7. Dependencias personalizadas para HelloSpringBoot

Aspectos básicos de Spring Boot 第 16 页，共 23

ibm.com/developerWorks/cn/ developerWorks®

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.

为了查看此视频, Recorrido por SpringBootDemo , 请访问这篇文章的在线版本。如果这篇文章已被

存档，视频也将不能访问。
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.

Aspectos básicos de Spring Boot 第 17 页，共 23

developerWorks® ibm.com/developerWorks/cn/

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í:

图 8. Importar Proyectos de 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.

Aspectos básicos de Spring Boot 第 18 页，共 23

ibm.com/developerWorks/cn/ developerWorks®

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 .

Nota: El proyecto odotCore contiene varias pruebas unitarias. Aunque siempre digo que nunca
(jamás) hay que saltarse las pruebas unitarias, es posible configurar la Configuración de Ejecución
que construye el proyecto odotCore en Eclipse para que se las salte (en el diálogo Configuración
de Ejecución existe un recuadro de selección para eso).

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.

Aspectos básicos de Spring Boot 第 19 页，共 23

developerWorks® ibm.com/developerWorks/cn/

图 9. Cómo acceder a SpringBootDemo a través de un navegador

Aspectos básicos de Spring Boot 第 20 页，共 23

ibm.com/developerWorks/cn/ developerWorks®

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.

表 1. Servicios y Métodos de oDoT (SpringBootDemo)

Servicio Método Método HTTP URL de ejemplo en
http://localhost:8080

Categoría FindAll GET /CategoryRestService/ Encuentra todos los objetos

FindAll de la categoría que están en
la BD.

Categoría FindById GET /CategoryRestService/ Encuentra Categoría por el

FindbyId/1 ID con valor 1.

Categoría FindById GET /CategoryRestService/ Encuentra Categoría

FindbyName/ por el nombre con valor
MI_CATEGORIA "MI_CATEGORIA".

Categoría Añadir PUT /CategoryRestService/Add Añ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ía Actualice POST /CategoryRestService/ Actualiza la Categoría

Update 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ía Borrar DELETE /CategoryRestService/Delete Borra 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ículo FindAll GET /ItemRestService/FindAll Encuentra todos los objetos

de la categoría que están en
la BD.

Artículo FindById GET /ItemRestService/FindbyId/1 Encuentra Categoría por el

ID con valor 1.

Artículo FindById GET /ItemRestService/ Encuentra el artículo

FindbyName/ por el nombre con valor
TODO_ITEM_1 "TODO_ITEM_1".

Artículo Añadir PUT /ItemRestService/Add Añ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).

Aspectos básicos de Spring Boot 第 21 页，共 23

developerWorks® ibm.com/developerWorks/cn/

Artículo Actualice POST /ItemRestService/Update Actualiza 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ículo Borrar DELETE /ItemRestService/Delete Borra 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í?

Regístrese para developerWorks Premium

Aspectos básicos de Spring Boot 第 22 页，共 23

ibm.com/developerWorks/cn/ developerWorks®

相关主题
•  ¿Qué es Spring Boot?
•  Cómo implementar una aplicación de Spring Boot en IBM Liberty y en WAS 8.5

© 版权所有 IBM 公司 2017
(www.ibm.com/legal/copytrade.shtml)
商标
(www.ibm.com/developerworks/cn/ibm/trademarks/)

Aspectos básicos de Spring Boot 第 23 页，共 23