Mira la lección en vídeo
Accede al vídeo completo de esta lección y a más contenido exclusivo con el Plan Plus.
Desbloquear Plan PlusCrear proyecto en start.spring.io
Spring Initializr es una herramienta web que facilita la creación de proyectos Spring Boot con una configuración inicial personalizada. Esta plataforma permite seleccionar las dependencias necesarias para el proyecto y generar una estructura base lista para comenzar a desarrollar.
Para crear un nuevo proyecto Spring Boot utilizando Spring Initializr, se debe acceder a la página web oficial en start.spring.io.
Configuración del proyecto
En la sección Project se selecciona la herramienta de gestión de dependencias. Las opciones disponibles son:
- Maven: Sistema de gestión de dependencias y construcción de proyectos ampliamente utilizado.
- Gradle: Alternativa moderna a Maven con un DSL (Domain Specific Language) más flexible.
La elección entre Maven o Gradle depende de las preferencias personales o los requisitos del proyecto.
En la sección Language se elige el lenguaje de programación para el proyecto:
- Java: La opción más común y tradicional para proyectos Spring.
- Kotlin: Lenguaje moderno interoperable con Java.
- Groovy: Lenguaje dinámico para la JVM.
Para este ejemplo, se seleccionará Java como lenguaje de programación.
Metadatos del proyecto
Los metadatos del proyecto sirven para identificarlo:
- Group: Identificador de la organización, generalmente en formato de dominio invertido (ej.
com.miempresa
). - Artifact: Nombre del proyecto, que también será el nombre del archivo JAR/WAR generado.
- Name: Nombre descriptivo del proyecto.
- Description: Breve descripción del propósito del proyecto.
- Package name: Nombre del paquete base, generalmente se deriva del Group e Artifact.
Versión y configuración de Java
En la sección de Spring Boot se selecciona la versión a utilizar. Se recomienda usar la versión estable más reciente a menos que existan requisitos específicos para utilizar una versión anterior.
La versión de Java debe seleccionarse según los requisitos del proyecto y el entorno de despliegue. Spring Boot 3.x requiere como mínimo Java 17, mientras que versiones anteriores pueden funcionar con Java 8 o 11.
Selección de dependencias
La selección de dependencias es una de las partes más importantes al crear un proyecto con Spring Initializr. Estas dependencias son los módulos o bibliotecas que se incluirán en el proyecto. Se pueden agregar haciendo clic en el botón "Add Dependencies" o utilizando el campo de búsqueda.
Algunas dependencias comunes para comenzar un proyecto web son:
- Spring Web: Para crear aplicaciones web, incluyendo RESTful, utilizando Spring MVC.
- Spring Data JPA: Facilita la implementación de repositorios basados en JPA.
- H2 Database: Base de datos en memoria útil para desarrollo y pruebas.
- Lombok: Reduce el código repetitivo mediante anotaciones.
- Spring Boot DevTools: Proporciona reinicio automático y otras herramientas de desarrollo.
Opciones avanzadas
En la sección más opciones, se pueden configurar aspectos adicionales:
- Packaging: JAR (aplicación independiente) o WAR (para desplegar en servidores de aplicaciones).
- Java version: Versión específica de Java para el proyecto.
Para la mayoría de los proyectos modernos de Spring Boot, se recomienda el empaquetado JAR, ya que permite ejecutar la aplicación de forma independiente con un servidor embebido.
Generación del proyecto
Una vez configuradas todas las opciones, se procede a generar el proyecto haciendo clic en el botón "GENERATE". Esto descargará un archivo ZIP que contiene la estructura básica del proyecto con todas las dependencias seleccionadas.
El archivo ZIP descargado tendrá un nombre basado en el artifact especificado, por ejemplo: app.zip
.
Descargar proyecto y abrirlo con Visual Studio Code y ejecutarlo
Guarda tu progreso
Inicia sesión para no perder tu progreso y accede a miles de tutoriales, ejercicios prácticos y nuestro asistente de IA.
Más de 25.000 desarrolladores ya confían en CertiDevs
Una vez generado el proyecto en Spring Initializr, el siguiente paso es descargar, abrir y ejecutar la aplicación en un entorno de desarrollo.
Descargar y extraer el proyecto
Después de hacer clic en el botón GENERATE en start.spring.io, se descarga automáticamente un archivo ZIP con el nombre del proyecto. Para trabajar con este archivo:
1. Localiza el archivo ZIP en tu carpeta de descargas
2. Extrae el contenido en una ubicación de fácil acceso (por ejemplo, en una carpeta de proyectos)
3. Asegúrate de que la estructura de carpetas se haya extraído correctamente
Preparar Visual Studio Code
Antes de abrir el proyecto, es recomendable tener instaladas algunas extensiones que facilitan el trabajo con proyectos Java y Spring Boot:
- Extension Pack for Java: Proporciona soporte completo para desarrollo en Java
- Spring Boot Extension Pack: Añade herramientas específicas para Spring Boot
- Maven for Java: Mejora la integración con proyectos Maven
Para instalar estas extensiones:
1. Abre VS Code
2. Presiona Ctrl+Shift+X
(o Cmd+Shift+X
en macOS) para abrir el panel de extensiones
3. Busca cada extensión por su nombre y haz clic en "Install"
Abrir el proyecto en VS Code
Para abrir el proyecto en Visual Studio Code se sigue File > Open Folder... > Selecciona la carpeta del proyecto extraído.
Al abrir el proyecto por primera vez, VS Code puede mostrar notificaciones para configurar el proyecto Java. Se recomienda aceptar estas sugerencias para una mejor experiencia de desarrollo.
Explorar el proyecto
Una vez abierto el proyecto, se puede ver la estructura de archivos en el explorador de VS Code. Los archivos más importantes para comenzar son:
pom.xml
: Contiene la configuración del proyecto y sus dependenciassrc/main/java/.../Application.java
: Clase principal con el métodomain
src/main/resources/application.properties
: Archivo de configuración de la aplicación
VS Code proporciona una vista especial para proyectos Maven que facilita la visualización de dependencias. Para acceder a ella:
1. Busca el icono de Maven en la barra lateral (parece una "M")
2. Expande el proyecto para ver sus componentes
Ejecutar el proyecto
Existen varias formas de ejecutar un proyecto Spring Boot en VS Code:
Método 1: Usando Spring Boot Dashboard
1. Busca el icono de Spring Boot en la barra lateral (parece una hoja)
2. En el panel de Spring Boot Dashboard, localiza tu aplicación
3. Haz clic en el icono de reproducción (▶️) junto al nombre de la aplicación
Método 2: Desde la clase principal
1. Abre el archivo Application.java
(la clase con la anotación @SpringBootApplication
)
2. Busca el botón "Run" que aparece sobre el método main
3. Haz clic en "Run" o "Debug"
Verificar la ejecución
Cuando la aplicación se inicia correctamente, se muestra información en la consola similar a:
. ____ _ __ _ _
/\\ / ___'_ __ _ _(_)_ __ __ _ \ \ \ \
( ( )\___ | '_ | '_| | '_ \/ _` | \ \ \ \
\\/ ___)| |_)| | | | | || (_| | ) ) ) )
' |____| .__|_| |_|_| |_\__, | / / / /
=========|_|==============|___/=/_/_/_/
:: Spring Boot :: (v3.1.5)
[INFO] Started Application in 2.456 seconds (process running for 2.786)
La aplicación estará disponible en http://localhost:8080
por defecto. Si se accede a esta URL desde un navegador, es posible que se muestre un error 404 (Not Found) ya que aún no se han definido controladores.
Detener la aplicación
Para detener la aplicación en ejecución:
- Si se ejecutó desde el Spring Boot Dashboard: Haz clic en el icono de stop (■)
- Si se ejecutó desde la clase principal: Haz clic en el botón de stop en la consola de depuración
- Si se ejecutó desde la terminal: Presiona
Ctrl+C
Estructura de carpetas y archivos en Spring Boot
Spring Boot organiza los proyectos siguiendo una estructura convencional que facilita el desarrollo y mantenimiento de aplicaciones. Esta estructura predefinida implementa el principio de convención sobre configuración, reduciendo la necesidad de configuraciones explícitas y permitiendo centrarse en la lógica de negocio.
Al examinar un proyecto Spring Boot recién creado, se observa una organización jerárquica de directorios y archivos con propósitos específicos:
proyecto-spring-boot/
├── src/
│ ├── main/
│ │ ├── java/
│ │ │ └── com/
│ │ │ └── ejemplo/
│ │ │ └── proyecto/
│ │ │ ├── ProyectoApplication.java
│ │ │ ├── controller/
│ │ │ ├── model/
│ │ │ ├── repository/
│ │ │ └── service/
│ │ └── resources/
│ │ ├── static/
│ │ ├── templates/
│ │ └── application.properties
│ └── test/
│ └── java/
│ └── com/
│ └── ejemplo/
│ └── proyecto/
│ └── ProyectoApplicationTests.java
├── .gitignore
├── mvnw
├── mvnw.cmd
└── pom.xml
Directorio raíz
En la raíz del proyecto se encuentran varios archivos fundamentales:
- pom.xml: El archivo de configuración de Maven que define las dependencias del proyecto, la versión de Java, plugins y otras configuraciones de construcción. Este archivo es esencial para la gestión de dependencias y el ciclo de vida del proyecto.
- mvnw y mvnw.cmd: Scripts de Maven Wrapper que permiten ejecutar comandos Maven sin necesidad de tener Maven instalado en el sistema. El archivo
.cmd
es para Windows, mientras que el script sin extensión es para sistemas Unix. - .gitignore: Archivo que especifica qué archivos y directorios deben ser ignorados por Git, como archivos compilados, directorios de salida y archivos de configuración local.
Directorio src/main/java
Este directorio contiene todo el código fuente Java de la aplicación, organizado en paquetes. La estructura de paquetes suele seguir la convención de nombres de dominio invertidos (com.ejemplo.proyecto).
- ProyectoApplication.java: La clase principal que contiene el método
main
y la anotación@SpringBootApplication
. Esta clase es el punto de entrada de la aplicación y combina tres anotaciones: @Configuration
: Indica que la clase define beans de Spring@EnableAutoConfiguration
: Activa la configuración automática basada en dependencias@ComponentScan
: Escanea componentes en el paquete actual y subpaquetes
package com.ejemplo.proyecto;
import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
@SpringBootApplication
public class ProyectoApplication {
public static void main(String[] args) {
SpringApplication.run(ProyectoApplication.class, args);
}
}
Dentro del directorio src/main/java
se suelen crear varios paquetes para organizar el código según su responsabilidad:
- controller/: Contiene las clases controladoras que manejan las peticiones HTTP.
- model/: Alberga las clases de entidad que representan los objetos de dominio.
- repository/: Incluye las interfaces de repositorio para acceso a datos.
- service/: Contiene las clases de servicio que implementan la lógica de negocio.
- config/: Clases de configuración adicionales.
- exception/: Clases para el manejo personalizado de excepciones.
- util/: Clases utilitarias.
Esta organización por capas facilita la separación de responsabilidades y mejora la mantenibilidad del código.
Directorio src/main/resources
Este directorio contiene todos los recursos no Java necesarios para la aplicación:
- application.properties: Archivo principal de configuración donde se definen propiedades como la conexión a base de datos, puerto del servidor, niveles de logging, etc. También se puede usar
application.yml
para el mismo propósito con formato YAML.
# Ejemplo de application.properties
server.port=8080
spring.datasource.url=jdbc:h2:mem:testdb
spring.jpa.hibernate.ddl-auto=update
logging.level.org.springframework=INFO
- static/: Directorio para recursos estáticos como CSS, JavaScript, imágenes, etc. Estos archivos son accesibles directamente desde la raíz del servidor web.
- templates/: Contiene plantillas para generar contenido dinámico. Spring Boot soporta varios motores de plantillas como Thymeleaf, FreeMarker o Mustache.
- META-INF/: Directorio opcional que puede contener archivos de configuración adicionales como
additional-spring-configuration-metadata.json
para autocompletado de propiedades personalizadas.
Directorio src/test
Este directorio contiene el código de pruebas con una estructura de paquetes similar a la del código principal:
- ProyectoApplicationTests.java: Clase de prueba inicial que verifica que el contexto de Spring se carga correctamente.
package com.ejemplo.proyecto;
import org.junit.jupiter.api.Test;
import org.springframework.boot.test.context.SpringBootTest;
@SpringBootTest
class ProyectoApplicationTests {
@Test
void contextLoads() {
}
}
Directorios generados durante la construcción
Al compilar y ejecutar el proyecto, se generan automáticamente varios directorios:
- target/ (Maven) o build/ (Gradle): Contiene los archivos compilados, informes y el archivo JAR o WAR final.
- .mvn/: Directorio que contiene archivos de configuración para Maven Wrapper.
Aprendizajes de esta lección de SpringBoot
- Comprender el uso de Spring Initializr para crear proyectos.
- Configurar proyectos Spring Boot con dependencias iniciales.
- Ejecutar y probar proyectos Spring Boot en Visual Studio Code.
- Organizar la estructura de carpetas y archivos en Spring Boot.
- Personalizar configuraciones en proyectos Spring Boot.
Completa este curso de SpringBoot y certifícate
Únete a nuestra plataforma de cursos de programación y accede a miles de tutoriales, ejercicios prácticos, proyectos reales y nuestro asistente de IA personalizado para acelerar tu aprendizaje.
Asistente IA
Resuelve dudas al instante
Ejercicios
Practica con proyectos reales
Certificados
Valida tus conocimientos
Más de 25.000 desarrolladores ya se han certificado con CertiDevs