Si recién estás comenzando con Spring Boot o "Spring" en general, comienza leyendo esta sección. Dará respuestas a las preguntas básicas "¿qué?", "¿cómo?" ¿y para qué?". Esta sección contiene una introducción a Spring Boot junto con instrucciones de instalación. Luego lo guiaremos en la creación de su primera aplicación Spring Boot, cubriendo algunos conceptos básicos a lo largo del camino.
Introducción a Spring Boot
Spring Boot lo ayuda a crear aplicaciones independientes basadas en Spring que luego podrás cumplir. Tomamos una visión subjetiva de la plataforma Spring y de las bibliotecas de terceros para que pueda comenzar con el mínimo esfuerzo. La mayoría de las aplicaciones Spring Boot no requieren una configuración detallada de Spring.
Puede usar Spring Boot para
crear aplicaciones Java que se pueden ejecutar usando el comando java-jar o métodos de implementación
más tradicionales, a través de archivos de guerra. También proporcionamos una herramienta de línea de comandos que
ejecuta "scripts de Spring".
Nuestros principales objetivos son:
Proporcionar una experiencia de arranque radicalmente más rápida y ampliamente accesible para cualquier Desarrollo de primavera.
Ofrece tu propia opinión desde el principio, pero cede si los requisitos comienzan a diferir de los estándar.
Proporciona una serie de características no funcionales que son comunes a grandes tipos de proyectos (como servidores integrados, seguridad, métricas, comprobaciones de estado y configuración externa).
Absolutamente sin requisitos de generación de código ni configuración XML.
Desarrollar su primera aplicación usando Spring Boot
Esta sección describe el desarrollo de una pequeña aplicación web "Hola ¡Mundo!", que demuestra algunas de las características clave de Spring Boot. Estamos utilizando Maven para construir este proyecto ya que la mayoría de los IDE lo admiten.
Sitio web spring.io contiene muchas guías sobre "empezar" que utilizan Spring Bota. Si necesita resolver un problema específico, busque allí primero.
Puede omitir los pasos siguientes yendo a inicie .spring.io y seleccione el paquete de inicio web en el buscador de dependencias. Esto creará una nueva estructura de proyecto para que pueda comenzar a escribir código de inmediato.p>
Antes de comenzar, abra una terminal y ejecute los siguientes comandos para asegurarse de que tiene versiones válidas de Java y Maven:
$ java -version
java version "1.8.0_102"
Java(TM) SE Runtime Environment (build 1.8.0_102-b14)
Java HotSpot(TM) 64-Bit Server VM (build 25.102-b14, mixed mode)
$ mvn -v
Apache Maven 3.5.4 (1edded0938998edf8bf061f1ceb3cfdeccf443fe; 2018-06-17T14:33:14-04:00)
Maven home: /usr/local/Cellar/maven/3.3.9/libexec
Java version: 1.8.0_102, vendor: Oracle Corporation
Creación de un POM
Debe comenzar creando un pom.xml archivo para Maven.
pom.xml es un conjunto de reglas que se utiliza para construir el proyecto. Abra su editor de texto
favorito y agregue lo siguiente:
<?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 https://maven.apache.org/xsd/maven-4.0.0.xsd">
<modelVersion>4.0.0</modelVersion>
<groupId>com.example</groupId>
<artifactId>myproject</artifactId>
<version>0.0.1-SNAPSHOT</version>
<parent>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-parent</artifactId>
<version>2.7.5</version>
</parent>
<!-- Se agregarán líneas adicionales aquí... -->
</project>La lista anterior debería permitirle obtener una compilación funcional. Puedes probarlo ejecutando mvn package (puedes ignorar la advertencia "el frasco estará vacío - ¡falta contenido marcado para su inclusión!" por
ahora).
Agregar dependencias desde la ruta de clases
Spring Boot proporciona una serie de "paquetes de inicio" que
permiten que agregue archivos jar al classpath. Nuestras aplicaciones de prueba de humo utilizan spring-boot-starter-parent
en la sección parent del POM. spring-boot-starter-parent es un paquete de inicio especial
que proporciona los parámetros predeterminados de Maven para usar. También proporciona una sección administración
de dependencias para que las etiquetas version se puedan omitir para las dependencias
"favoritas".
Otros "paquetes iniciales" proporcionan dependencias que, Es más probable que se necesite al
desarrollar ciertos tipos de aplicaciones. Como estamos desarrollando una aplicación web, agregamos una dependencia
en spring-boot-starter-web. Antes de eso, puedes echar un vistazo a lo que tenemos hasta ahora
ejecutando el siguiente comando:
$ mvn dependency:tree
[INFO] com.example:myproject:jar:0.0.1-SNAPSHOT
El comando mvn dependency:tree muestra una vista de árbol de las dependencias del proyecto. Como
puede ver, spring-boot-starter-parent en sí no proporciona ninguna dependencia. Para agregar las
dependencias requeridas, edite su pom.xml y agregue la dependencia spring-boot-starter-web
justo debajo de la sección parent:
<dependencies>
<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-web</artifactId>
</dependency>
</dependencies>
Si ejecuta mvn dependency:tree nuevamente, verá que ahora hay varias dependencias adicionales,
incluido el servidor web Tomcat y el propio Spring Boot.
Escribir el código
Para completar la
aplicación, necesitamos crear un archivo Java. De forma predeterminada, Maven compila fuentes del directorio src/main/java,
por lo que debe crear esta estructura de directorio y luego agregar un archivo llamado src/main/java/MyApplication.java.
que contendrá el siguiente código:
import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.EnableAutoConfiguration;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RestController;
@RestController
@EnableAutoConfiguration
public class MyApplication {
@RequestMapping("/")
String home() {
return "Hello World!";
}
public static void main(String[] args) {
SpringApplication.run(MyApplication.class, args);
}
}import org.springframework.boot.autoconfigure.EnableAutoConfiguration
import org.springframework.boot.runApplication
import org.springframework.web.bind.annotation.RequestMapping
import org.springframework.web.bind.annotation.RestController
@RestController
@EnableAutoConfiguration
class MyApplication {
@RequestMapping("/")
fun home() = "Hello World!"
}
fun main(args: Array<String>) {
runApplication<MyApplication>(*args)
}Aunque no hay mucho código mucho, pero pasan muchas cosas. Veamos los elementos importantes en las siguientes secciones.
Las anotaciones @RestController y @RequestMapping
La primera anotación para nuestra clase
MyApplication es @RestController. Se le conoce como un resumen estereotípico.
Esta anotación sirve como una pista para las personas que leen el código y para Spring de que la clase desempeña
un papel. En este caso, nuestra clase es un @Controller para la web, por lo que Spring lo tiene en
cuenta al procesar las solicitudes web entrantes.
El @RequestMapping La anotación transmite
información sobre el "enrutamiento". Le dice a Spring que cualquier solicitud HTTP con la ruta / debe
asignarse al método home. La anotación @RestController le dice a Spring que imprima la
cadena resultante directamente a la persona que llama.
@RestController anotaciones y @RequestMapping son
anotaciones Spring MVC (no son específicas de Spring Boot).
La anotación @EnableAutoConfiguration
La segunda clase- La anotación de nivel es @EnableAutoConfiguration. Esta anotación le dice a Spring
Boot que "adivine" cómo se debe configurar Spring en función de las dependencias jar que ha agregado. Debido a que
spring-boot-starter-web agregó Tomcat y Spring MVC, la herramienta de configuración automática asume
que está desarrollando una aplicación web y configura Spring en consecuencia.
El método "main"
La parte final de nuestra aplicación es la método main.
Este es un método estándar que sigue el estándar Java para el punto de entrada de la aplicación. Nuestro método
principal delega autoridad a la clase SpringApplication para Spring Boot llamando a run.
SpringApplication arranca nuestra aplicación iniciando Spring, que a su vez inicia un servidor web
Tomcat configurado automáticamente. Necesitamos pasar MyApplication.class como argumento al método
run para decirle a SpringApplication cuál Spring Bean es el principal. La matriz args
también se pasa para abrir cualquier argumento de la línea de comando.
Ejecutando el ejemplo
En este
punto, la aplicación ya debería estar ejecutándose. Dado que usó un POM con spring-boot-starter-parent,
tiene un destino run que puede usarse para iniciar la aplicación. Ingrese mvn
spring-boot:run desde el directorio raíz del proyecto para ejecutar la aplicación. Debería ver un
resultado similar al siguiente:
. ____ _ __ _ _
/\\ / ___'_ __ _ _(_)_ __ __ _ \ \ \ \
( ( )\___ | '_ | '_| | '_ \/ _` | \ \ \ \
\\/ ___)| |_)| | | | | || (_| | ) ) ) )
' |____| .__|_| |_|_| |_\__, | / / / /
=========|_|==============|___/=/_/_/_/
:: Spring Boot :: (v2.7.5)
....... . . .
....... . . . (log output here)
....... . . .
....... Inicié MyApplication en 2.222 segundos (JVM ejecutándose para 6.514)Si abre un navegador web en localhost:8080, verá el siguiente mensaje:
¡Hola mundo!
Para salir de la aplicación paso a paso paso, haga clic en ctrl-c.
Creación de un archivo jar ejecutable
Completamos nuestro ejemplo creando un archivo jar ejecutable completamente autónomo que se puede ejecutado en un entorno de producción. Los archivos jar ejecutables (a veces llamados "frascos gordos") son archivos que contienen clases compiladas junto con todas las dependencias de archivos jar que el código necesita para ejecutarse.