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 versión java "1.8.0_102" Java(TM) SE Runtime Environment (compilación 1.8.0_102-b14) Java HotSpot(TM) VM de servidor de 64 bits (compilación 25.102-b14, modo mixto) 
$ mvn -v Apache Maven 3.5.4 (1edded0938998edf8bf061f1ceb3cfdeccf443fe; 2018-06-17T14:33:14-04:00) Inicio de Maven: /usr/local/Cellar /maven /3.3.9/libexec Versión de Java: 1.8.0_102, proveedor: Oracle Corporation
Este La muestra debe crearse en su propio directorio. Las siguientes instrucciones asumen que ya ha creado un directorio adecuado y que es su directorio actual.

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 versión="1.0" codificación="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.ejemplo</groupId> <artifactId>miproyecto</artifactId> <versión>0.0.1-INSTANTÁNEA</versión> <padre> <groupId>org.springframework.boot</groupId> <artifactId>spring-boot-starter-parent</artifactId> <versión>2.7.5</versión> </padre> <!-- Se agregarán líneas adicionales aquí... --> </project>

La lista anterior debería permitirle obtener una compilación funcional. Puedes probarlo ejecutando paquete mvn (puedes ignorar la advertencia "el frasco estará vacío - ¡falta contenido marcado para su inclusión!" por ahora).

En este punto, puede importar el proyecto al IDE (la mayoría de los IDE de Java modernos brindan soporte integrado para Maven). Para simplificar las cosas, continuaremos usando un editor de texto normal en este ejemplo.

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:

<dependencias> <dependencia> <groupId>org.springframework.boot</groupId> <artifactId>spring-boot-starter-web</artifactId> </dependencia> </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:

Java
importar org.springframework.boot .SpringAplicación; importar org.springframework.boot.autoconfigure.EnableAutoConfiguration; importar org.springframework.web.bind.annotation.RequestMapping; importar org.springframework.web.bind.annotation.RestController; @RestController @EnableAutoConfiguration public class MiAplicación { @RequestMapping("/") String home() { return "¡Hola mundo!"; } public static void main(String[] args) { SpringApplication.run(MyApplication.class, args); } } 
Kotlin
importar org.springframework.boot.autoconfigure.EnableAutoConfiguration importar org.springframework.boot.runApplication importar org.springframework.web.bind.annotation.RequestMapping importar org.springframework.web.bind.annotation.RestController @RestController @EnableAutoConfiguration class MiAplicación { @RequestMapping("/") fun home() = "¡Hola mundo!" } 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.

Paquetes de inicio y configuración automática

La configuración automática está diseñada para funcionar con "paquetes de inicio" , pero estos dos conceptos no están directamente relacionados. Eres libre de elegir dependencias jar fuera de los paquetes iniciales. Spring Boot seguirá haciendo todo lo posible para configurar automáticamente su aplicación.

El método "principal"

La parte final de nuestra aplicación es la método principal . 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:

$ mvn spring-boot:run . ____ _ __ _ _ /\\ / ___'_ __ _ _(_)_ __ __ _ \ \ \ \ ( ( )\___ | '_ | '_| | '_ \/ _` | \ \ \ \ \\/ ___)| |_)| | | | | || (_| | ) ) ) ) ' |____| .__|_| |_|_| |_\__, | / / / / =========|_|=============|___/=/_/_/_/ :: Spring Boot :: (v2. 7.5 ) ....... . . .
....... . . . (salida del registro aquí) ....... . . .
....... 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.

Archivos jar ejecutables y Java

Java no proporciona una forma estándar de cargar archivos jar adjuntos (archivos jar, que a su vez están contenidos dentro de archivos jar). Esto puede ser un problema si necesita distribuir una aplicación independiente.

Para resolver este problema, muchos desarrolladores utilizan archivos jar "uber". En el archivo uber jar, todas las clases de todas las dependencias de la aplicación están empaquetadas en un solo archivo. El problema con este enfoque es que resulta difícil entender qué bibliotecas hay en la aplicación. También puede ser un problema si se usa el mismo nombre de archivo (pero con contenido diferente) en varios archivos jar.

Spring Boot adopta un enfoque diferente y permite adjuntar archivos jar directamente.

Para crear un archivo jar ejecutable, necesitamos agregar spring-boot-maven-plugin a nuestro pom.xml. Para hacer esto, inserte las siguientes líneas justo debajo de la sección dependencias:

<build>
        <complementos> <complemento> <groupId>org.springframework.boot</groupId> <artifactId>spring-boot-maven-plugin</artifactId>
        </complemento> </complementos> </build>
Modelo POM spring-boot-starter-parent incluye la configuración <executions> para vincular el destino repackage. Si no está utilizando un POM principal, deberá declarar esta configuración usted mismo.

Guarde pom.xml y ejecute mvn package desde el comando línea de la siguiente manera:

$ paquete mvn [INFO] Buscando proyectos... [INFO] [INFO] ----------------------- ---- --------------------------------------- [ INFORMACIÓN] Construyendo mi proyecto 0.0.1-INSTANTÁNEA [INFO] -------------------------------------- ---- ------------------------------ [INFO] .... .. [INFO] --- experto -jar-plugin :2.4:jar (jar predeterminado) @ miproyecto --- [INFO] Construyendo jar: /Users/developer/example/spring-boot-example/target/myproject-0.0.1-SNAPSHOT.jar [INFO ] [INFO] --- spring-boot-maven-plugin:2.7.5:repackage (predeterminado) @ myproject --- [INFO] ------------------- ---- ---------------------------------------------- --- [INFORMACIÓN] ÉXITO DE LA CONSTRUCCIÓN [INFO] --------------------------------------- ---- -----------------------

Si buscas en el directorio target, deberías ver myproject-0.0.1-SNAPSHOT.jar allí. El tamaño del archivo debe ser de unos 10 MB. Si desea mirar dentro, puede usar jar tvf como se muestra a continuación:

$ jar tvf target/myproject-0.0.1-SNAPSHOT.jar

En el directorio target también debería haber un archivo mucho más pequeño llamado myproject-0.0.1-SNAPSHOT.jar.original. Este es el archivo jar original que Maven creó antes de que Spring Boot lo volviera a empaquetar.

Para ejecutar esta aplicación, use el comando java -jar como se muestra a continuación:

$ java -jar target/miproyecto-0.0.1-SNAPSHOT.jar. ____ _ __ _ _ /\\ / ___'_ __ _ _(_)_ __ __ _ \ \ \ \ ( ( )\___ | '_ | '_| | '_ \/ _` | \ \ \ \ \\/ ___)| |_)| | | | | || (_| | ) ) ) ) ' |____| .__|_| |_|_| |_\__, | / / / / =========|_|=============|___/=/_/_/_/ :: Spring Boot :: (v2. 7.5 ) ....... . . .
....... . . . (salida del registro aquí) ....... . . .
.......Inicié MyApplication en 2,536 segundos (JVM ejecutándose durante 2,864)

Como antes, para salir de la aplicación, presione ctrl -c.