Crear proyecto con Spring Initializr

Crear 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

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 dependencias
• src/main/java/.../Application.java: Clase principal con el método main
• 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.