Spring Boot: tutorial para crear aplicaciones en Java
Equipo editorial de IONOS
Desde que se lanzó en 1995, Java se ha convertido en uno de los lenguajes de programación más utilizados. En especial, este lenguaje orientado a objetos despliega todo su potencial a la hora de desarrollar aplicaciones empresariales complejas (para uso online o sin conexión). En combinación con el Java Runtime Environment (JRE), se caracteriza por ser compatible con todos los sistemas operativos y, por lo tanto, accesible para un público muy extenso.
Con el fin de simplificar el trabajo con Java, en las últimas décadas se han ido creando diversos marcos estándar listos para usar, que sirven de base para desarrollar programas en Java. Uno de los más conocidos es el framework de código abierto Spring, publicado en 2003, que reduce notablemente la complejidad de la especificación estándar de Java (“J2EE” o “plataforma Java”), así como del modelo de componentes de los Enterprise JavaBeans (“EJB”). Desde que se lanzó el complemento Spring Boot, que agiliza todavía más la configuración de nuevos proyectos con Spring, el marco ha demostrado ser una opción excelente y fácil de utilizar en los casos en que no queremos comenzar a desarrollar una aplicación en Java desde cero.
En este tutorial de Spring Boot aprenderás cuáles son los requisitos previos para utilizarlo y empezarás a dar tus primeros pasos con este framework modular.
¿Qué es Spring Boot?
Spring Boot, publicado en 2012, es una solución para el framework Spring de Java que sigue el principio de “convención sobre configuración” y reduce la complejidad del desarrollo de nuevos proyectos basados en Spring. Para ello, Spring Boot proporciona la estructura básica configurada del proyecto, que incluye las pautas para usar el marco y todas las bibliotecas de terceros relevantes para la aplicación, lo que nos allana el camino para comenzar a desarrollarla lo más rápidamente posible. De esta manera se simplifica mucho la creación de aplicaciones independientes y reproducibles, por lo que la mayoría de las nuevas aplicaciones basadas en Spring se desarrollan con Spring Boot.
Las características de Spring Boot pueden resumirse de la siguiente manera:
- Incorporación directa de aplicaciones de servidores web/contenedores como Apache Tomcat o Jetty, eliminando la necesidad de incluir archivos WAR (Web Application Archive)
- Simplificación de la configuración de Maven gracias a los POM (Project Object Models) “starter”
- Configuración automática de Spring en la medida de lo posible
- Características no funcionales, como métricas o configuraciones externalizadas
La empresa desarrolladora Pivotal Software dio al framework de Spring, publicado ya en 2005, un enfoque moderno y con visión de futuro cuando lanzó Spring Boot. Para desarrollarlo, se recurrió a la sólida tecnología de base del framework de Spring, madurada durante años, que contribuyó mucho a su funcionalidad. Si te apetece saber más sobre este popular marco de código abierto (licencia Apache 2.0), no te pierdas nuestro completo artículo sobre el framework de Java.
Spring Boot: tutorial, requisitos e instalación
Desde que el uso de Spring se extendiera en todo el mundo debido a Spring Boot, esta solución creada por Pivotal Software ha sido reconocida como una de las mejores para desarrollar microservicios en Java. Gracias a los aproximadamente 20 módulos del marco básico (que puedes combinar como quieras) Spring Boot también es adecuado para muchos otros propósitos, aunque no acaba de encajar en la descripción de un framework para aplicaciones web ni de una solución clásica para aplicaciones de escritorio.
En primer lugar, antes de entrar en detalles sobre la creación y configuración de un nuevo proyecto, así como la estructura inicial de Spring Boot, el tutorial se centra en los requisitos técnicos y la configuración de los componentes necesarios.
¿Cuáles son los requisitos del sistema de Spring Boot?
En Spring Boot todo se hace con Java, por lo que Java Runtime Environment (plataforma Java) es el principal componente de software para que el marco funcione. Como esta aplicación no solo se ejecuta, sino que también se emplea para el desarrollo con Java, necesitas al menos la versión 8 (o 1.8) del llamado Java Development Kit (JDK). Este software, además del entorno de ejecución, contiene herramientas útiles para programar y testar aplicaciones Java y está disponible tanto para Linux como para Windows y macOS, por lo que nos permite elegir libremente el sistema operativo que queramos utilizar.
Obviamente, este complemento también requiere que tengamos la versión actual del framework Spring instalada en el sistema.
Como herramienta de compilación, podemos utilizar Maven (a partir de 3.3) o Gradle (a partir de 4.4).
Cabe la posibilidad de incorporar un objeto servlet que ejecute la aplicación Java sobre la base de un servidor web. Para hacerlo, puedes elegir entre tres soluciones: Apache Tomcat (a partir de 9.0), Jetty (a partir de 9.4) o Undertow (a partir de 2.0).
Cómo crear tu primer proyecto de Spring Boot
Al igual que en cualquier biblioteca Java estándar, en Spring Boot se incluyen los correspondientes archivos JAR (Java Archive) o WAR (Web Application Archive) en el Classpath. Java recurre a esta ruta del sistema de archivos para buscar los archivos ejecutables. Puedes crear los archivos de almacenamiento de Spring Boot de dos maneras distintas:
- Instala y utiliza Maven o Gradle para crear por tu cuenta todo el marco del proyecto, incluidas las dependencias necesarias.
- Utiliza el servicio web Spring Initializr para establecer la configuración de Spring Boot y, después, descárgala como plantilla de proyecto final.
Una característica de la segunda solución es que proporciona una interfaz web muy fácil de usar para crear los archivos JAR, lo que simplifica considerablemente el proceso. Como Initializr también emplea Maven o Gradle para generar los archivos, el resultado es el mismo que si lo haces de forma manual. En este tutorial de Spring Boot, nos hemos decantado por esta opción. En start.spring.io, puedes acceder a este servicio web.
Si deseas utilizar Spring Initializr, debes tener instalado Java, además de Maven o Gradle, para trabajar en la aplicación con Spring Boot.
Una vez abierto Spring Initializr, puedes establecer las propiedades de la aplicación que vas a desarrollar con Spring Boot. En primer lugar, indica el sistema de compilación, seleccionando “Maven Project” o “Gradle Project”. En la segunda línea, puedes optar por el lenguaje Java clásico o, si lo prefieres, por otro lenguaje de la familia de Java, como Kotlin o Groovy. A continuación, define la versión subyacente de Spring Boot y los metadatos del proyecto (incluida la versión de Java), así como todas las dependencias relevantes (bases de datos, características de seguridad, interfaces web, servicios en la nube, etc.). Finalmente, haz clic en “Generate Project” para crear los archivos del proyecto.
Si quieres crear un proyecto en Spring Boot con Maven o Gradle desde cero, puedes consultar las instrucciones de instalación que figuran en los manuales oficiales online.
Ejecutar el nuevo proyecto de Spring Boot
Spring Initializr te ofrecerá la opción de descargar los archivos de proyecto que se acaban de crear. Verás que se encuentran en un archivo ZIP, que deberás descomprimir antes de abrir. La carpeta descomprimida incluye, entre otros componentes, el archivo de configuración build.gradle si seleccionaste Gradle como sistema de compilación o pom.xml si se trata de un proyecto de Maven. En el último caso, que es en el que nos centramos en este tutorial de Spring Boot, el contenido del archivo de configuración debería ser similar a este:
Mediante el correspondiente software de compilación, vas a crear una aplicación Spring Boot ejecutable a partir de los archivos disponibles. Para ello, si utilizas Maven, abre el terminal o el símbolo del sistema e introduce el siguiente comando en la carpeta de destino (es decir, en la carpeta que contiene los archivos de Spring Boot):
mvn clean install
Para Gradle, el comando es el siguiente:
gradle clean buildEn ambos casos, si el comando se ejecuta correctamente, obtendrás el mensaje “BUILD SUCCESS” en cuanto se hayan creado los archivos de almacenamiento. El archivo ejecutable se guarda en la carpeta “target” (Maven) o “build/libs” (Gradle). En nuestro caso, el nombre de este archivo JAR es “demo-0.0.1-SNAPSHOT.jar”:
Para ejecutarlo con Java, introduce el siguiente comando:
java -jar demo-0.0.1-SNAPSHOT.jar
Si es necesario, sustituye el nombre del archivo JAR, que, en el ejemplo, hemos escrito en cursiva, por el que corresponda en tu caso. Cuando lo introduzcas, en función del output que muestre el símbolo del sistema, podrás saber si la aplicación configurada con Spring Boot se ha iniciado correctamente. Asimismo, si antes incorporaste alguno de los servidores web mencionados, como Tomcat, este también se iniciará. Puedes acceder a él con cualquier navegador introduciendo la siguiente dirección:
http://localhost:8080Conectar Spring Boot con la base de datos y la fuente de datos
Spring Boot proporciona un excelente soporte para crear e incorporar fuentes de datos en todas las bases de datos SQL o NoSQL que queramos. Por lo tanto, no necesitas escribir ningún código para crear una nueva fuente de datos, sino, simplemente, añadir las correspondientes dependencias y datos de configuración. Esto es posible gracias a la interfaz de base de datos unificada JDBC (Java Database Connectivity), para la cual primero tienes que crear una entrada de inicio en el archivo de configuración, a menos que ya hayas añadido la dependencia al crear el proyecto con Spring Initializr (lo mismo se aplica a otras dependencias ya mencionadas).
Los usuarios de Maven deben añadir las siguientes líneas a pom.xml:
<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-jdbc</artifactId>
</dependency>Los usuarios de Gradle, por su parte, deben escribir lo siguiente en el archivo build.gradle:
compile('org.springframework.boot:spring-boot-starter-jdbc')Puedes utilizar cualquier editor de código estándar para abrir el archivo de configuración. Lo importante es volver a guardarlo en formato XML o Gradle después de modificarlo.
El segundo paso consiste en extender el archivo de configuración de compilación correspondiente con la dependencia del sistema de administración de base de datos que quieras. En este tutorial vinculamos nuestra aplicación con una base de datos MySQL que queremos utilizar para la misma y que ya hemos instalado previamente.
Para ello, en el archivo pom.xml de Maven, introduce la siguiente entrada:
<dependency>
<groupId>mysql</groupId>
<artifactId>mysql-connector-java</artifactId>
</dependency>En el caso de Gradle, debes escribir la siguiente línea para vincular la aplicación con la base de datos MySQL:
compile('mysql:mysql-connector-java')A continuación, debes añadir algunas propiedades al archivo PROPERTIES “application”, que se encuentra en la ruta \src\main\resources, en la carpeta del proyecto de Spring Boot. Abre este archivo de texto e introduce los siguientes comandos de configuración:
spring.datasource.driverClassName = com.mysql.jdbc.Driver
spring.datasource.url = jdbc:mysql://localhost:3306/PRODUCTSERVICE?autoreconnect = true
spring.datasource.username = root
spring.datasource.password = root
spring.datasource.tomcat.testOnBorrow = true
spring.datasource.tomcat.testWhileIdle = true
spring.datasource.tomcat.timeBetweenEvictionRunsMillis = 60000
spring.datasource.tomcat.minEvictableIdleTimeMillis = 30000
spring.datasource.tomcat.validationQuery = SELECT 1
spring.datasource.tomcat.max-active = 15
spring.datasource.tomcat.max-idle = 10
spring.datasource.tomcat.max-wait = 8000Ya puedes utilizar MySQL como de costumbre para crear una base de datos que incluya las tablas de datos que quieras, si todavía no lo has hecho. Si no tienes claro cómo se hace, consulta nuestro completo tutorial de MySQL, donde aprenderás todo lo necesario sobre el uso de este sistema de administración de bases de datos relacionales.
Generar certificado SSL / TLS y habilitar HTTPS
De forma predeterminada, las aplicaciones creadas con Spring Boot utilizan un protocolo HTTP no seguro y el puerto TCP 8080 para conectarse al correspondiente servidor web. Si, en lugar de ello, quieres cambiar a HTTPS y al puerto TCP 443 como opción predeterminada, necesitas disponer de un certificado SSL/TLS, además de especificar las propiedades adecuadas en el archivo PROPERTIES “application”.
El primero se puede obtener de una autoridad de certificación o creando un certificado autofirmado mediante Java Runtime Environment. Este incorpora Management Utility Key Tool, una herramienta de línea de comandos con la que puedes generar fácilmente archivos PKCS12 (incluidos el certificado X.509 y la clave privada) para servidores como Tomcat, Exchange o IIS, entre otros. Por ejemplo, si utilizas un servidor Tomcat, escribe el siguiente comando en la consola para generar el archivo de certificado digital para la aplicación creada con Spring Boot:
keytool -genkeypair -alias tomcat -storetype PKCS12 -keyalg RSA -keysize 2048 -keystore keystore.p12 -validity 3650Finalmente, para personalizar el certificado, crea una contraseña individual e indica tus datos personales, los de tu empresa y tu ubicación. Si no conoces el código de tu país, puedes buscarlo en la lista de códigos de país según la ISO 3166 de la Agencia Tributaria.
El archivo de certificado digital se guarda automáticamente en el directorio en el que se ejecutó el comando (en este tutorial de Spring Boot, el propio directorio del usuario). Copia el archivo “keystore” en el directorio de la aplicación creada con Spring Boot y, a continuación, introduce los siguientes comandos en el archivo PROPERTIES “application” que ya editaste al integrar la base de datos:
server.port = 443
server.ssl.key-store = C:/demo/keystore.p12
server.ssl.key-store-password = springboot
server.ssl.key-store-type = PKCS12
server.ssl.key-alias = tomcatFinalmente, crea un nuevo archivo JAR ejecutable que se conecte a Tomcat por HTTPS, de acuerdo con la configuración, mediante el siguiente comando:
mvn -Dmaven.test.skip=true -DskipTests=true clean installSpring Cloud Sleuth y Zipkin: simplificar la depuración de la aplicación de Spring Boot
Una de las tareas más importantes en el desarrollo de software es supervisarlo constantemente, ya que solo así se logra localizar y corregir todos los errores de programación. Sin embargo, evaluar los logs o historiales de registro suele ser muy complejo, lo que a menudo conlleva que el proceso de depuración sea muy costoso, especialmente en el caso de los microservicios. Para acabar este tutorial de Spring Boot, vamos a hablar de las soluciones de rastreo Spring Cloud Sleuth y Zipkin, pues estas ayudan a supervisar a fondo las aplicaciones creadas con Spring Boot.
Con estas dos aplicaciones de seguimiento puedes supervisar fácilmente todas las solicitudes mediante un controlador REST y consultar el historial en todo momento.
Primer paso: añadir Spring Cloud Sleuth al proyecto
Primero, integra el módulo Sleuth en la aplicación desarrollada con Spring Boot, configurando la dependencia en el archivo de configuración de compilación. Para ello, si utilizas Maven, introduce el siguiente contenido en el archivo pom.xml:
<dependency>
<groupId>org.springframework.cloud</groupId>
<artifactId>spring-cloud-starter-sleuth</artifactId>
<version>${spring-cloud-sleuth.version}</version>
<type>pom</type>
<scope>import</scope>
</dependency>En los proyectos Gradle, escribe el siguiente comando en el archivo de configuración:
compile('org.springframework.cloud:spring-cloud-starter-sleuth')Segundo paso: incluye los logs de Sleuth en el archivo .class del controlador REST
En segundo lugar, debes configurar el controlador REST del proyecto de Spring Boot para que procese los logs de Sleuth según tus preferencias. Para ello, debes escribir el código que figura a continuación en el archivo .class del controlador. Ten en cuenta que el nombre del paquete (aquí, spring-boot-tutorial) se corresponde con el dominio de <groupId> en pom.xml:
package spring-boot-tutorial.sleuth;
import java.util.logging.Level;
import java.util.logging.Logger;
import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RestController;
@SpringBootApplication
@RestController
public class SleuthappApplication {
private static final Logger LOG = Logger.getLogger(SleuthappApplication.class.getName());
public static void main(String[] args) {
SpringApplication.run(SleuthappApplication.class, args);
}
@RequestMapping("/")
public String index() {
LOG.log(Level.INFO, "Index API is calling");
return "Sleuth: Spring-Boot-Tutorial-Test!";
}
}Tercer paso: anota el nombre de la aplicación creada con Spring en las propiedades
Para asegurarte de que el nombre del proyecto de Spring Boot se muestre correctamente en Zipkin, debes especificarlo en el archivo PROPERTIES “application”. Si guardas esta configuración en un servidor de configuración de Spring Cloud, haz lo mismo en el archivo PROPERTIES “bootstrap”:
spring.application.name = Spring-Boot-Tutorial-AppCuarto paso: añadir Zipkin al proyecto
El software de código abierto Zipkin, que ayuda a gestionar y supervisar los logs de Sleuth, consta de una interfaz de usuario y un componente de servidor. Para ambos, las dependencias se añaden en el archivo de configuración de compilación correspondiente. Los usuarios de Maven deben introducir el siguiente código en el archivo pom.xml:
<dependency>
<groupId>io.zipkin.java</groupId>
<artifactId>zipkin-server</artifactId>
</dependency>
<dependency>
<groupId>io.zipkin.java</groupId>
<artifactId>zipkin-autoconfigure-ui</artifactId>
<scope>runtime</scope>
</dependency>En cambio, al configurar Gradle, se deben añadir los siguientes comandos:
compile('io.zipkin.java:zipkin-autoconfigure-ui')
compile('io.zipkin.java:zipkin-server')Quinto paso: permitir que la aplicación actúe como servidor de Zipkin
El siguiente paso es asegurarse de que el proyecto de Spring Boot pueda actuar como servidor de Zipkin. Para ello, crea un archivo llamado zipkin.properties y escribe las siguientes líneas en él:
spring.application.name=zipkin
server.port=9411
logging.level.org.springframework.web=debugFinalmente, habilita el componente del servidor en el archivo Java del proyecto:
package spring-boot-tutorial.zipkin;
import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import zipkin.server.EnableZipkinServer;
@SpringBootApplication
@EnableZipkinServer
public class ZipkinappApplication {
public static void main(String[] args) {
SpringApplication.run(ZipkinappApplication.class, args);
}
}Si creas el archivo JAR ejecutable de la forma habitual y, luego, ejecutas la aplicación, podrás acceder al servidor Zipkin en la dirección 'http://localhost:9411/zipkin'.
Sexto paso: añadir la dependencia de Spring Cloud Zipkin
Añade una última dependencia en el archivo de configuración de compilación para vincular Sleuth y Zipkin.
En Maven:
<dependency>
<groupId>org.springframework.cloud</groupId>
<artifactId>spring-cloud-sleuth-zipkin</artifactId>
</dependency>En Gradle:
compile('org.springframework.cloud:spring-cloud-sleuth-zipkin')Séptimo paso: configurar la exportación de los logs de Sleuth al servidor de Zipkin
Extiende el archivo Java del proyecto de Spring Boot con el objeto AlwaysSampler (Bean) para activar la exportación automática de los logs de Sleuth al servidor de Zipkin:
@Bean
public AlwaysSampler defaultSampler() {
return new AlwaysSampler();
}Octavo paso: anotar el URL base del servidor de Zipkin en el archivo PROPERTIES “application”
Para acabar, especifica el URL base del servidor de Zipkin en las propiedades de la aplicación, abriendo una vez más el archivo PROPERTIES del proyecto de Spring Boot e introduciendo la siguiente línea:
spring.zipkin.baseUrl = http://localhost:9411/zipkin/
