Dependencias Clave en Spring Boot

Introducción

Explicación de las dependencias esenciales para desarrollar con Spring Boot 3.3.5 excluyendo las dependencias de testing. También he incluido algunas librerías de mi preferencia que me ayudan en mi trabajo diario.

Todas las dependencias están en formato Maven, ya que considero que es más sencillo de entender para principiantes y tengo mayor experiencia con Maven que con Gradle.

Spring Web

Dependencia

<dependency>
  <groupId>org.springframework.boot</groupId>
  <artifactId>spring-boot-starter-web</artifactId>
</dependency>

Propósito

Para cualquier aplicación web o API REST esta es la base. Al arrancar la aplicación el servidor web Tomcat se levanta. Permite escuchar y responder peticiones HTTP. Traduce lo que llega en la petición HTTP y lo pasa al programa Java que sabe cómo gestionarlo.

Explicación

En el pasado configurar desde cero un servidor Tomcat podía llevar mucho tiempo. Con spring web todo viene ya por defecto para que hagas click al “play” en el IDE. Te va a permitir usar:

• @RestController para gestionar peticiones HTTP.
• @RequestMapping para mapear una petición HTTP a un método.
• @GetMapping para mapear una petición HTTP GET a un método.
• @RequestBody para leer el cuerpo de una petición HTTP.

¿Cómo funciona el flujo de información?

@RestController es quien se encarga de gestionar la petición HTTP que ha llegado a través de Tomcat. Al menos, sabe de un @RequestMapping específico. Todo lo que llegue en su @RequestMapping será delegado a un método que sabrá qué hacer con la petición.

Si llega una petición GET a /customers/600d3f72-d96e-4e4f-ac35-1b814b357ddf el método getCustomer(UUID id) sabrá qué hacer con la petición.

Debajo tienes un ejemplo de cómo se vería un código limpio:

import static com.test.crm.config.ApiConfig.API_BASE_PATH;

@RestController
@RequestMapping(API_BASE_PATH + "/customers")
public class CustomerController {
    private final CustomerService customerService;

    public CustomerController(CustomerService customerService) {
        this.customerService = customerService;
    }

    @GetMapping("/{id}")
    public CustomerDTO getCustomer(@PathVariable UUID id) {
        return customerService.getCustomer(id);
    }
}

Si quieres una explicación completa, puedes visitar Spring Boot Rest Controller con CRUD.

Spring Security

Dependencia

<dependency>
  <groupId>org.springframework.boot</groupId>
  <artifactId>spring-boot-starter-security</artifactId>
</dependency>

Propósito

Proporciona autenticación y autorización para las aplicaciones. Es la dependencia que te permitirá gestionar el acceso a la aplicación.

Explicación

Por la naturaleza complicada de la seguridad, es la dependencia que, en mi opinión, más cuesta entender. Empieza con basic authentication. Si tienes una clase User, implementa la interfaz UserDetails.

Para activar la seguridad, crea una clase y pega el siguiente código con debug. El debug te permitirá saber qué pasa. En el código de producción, hay que borrar el debug.

@Configuration
@EnableWebSecurity(debug = true)
public class SecurityConfig {
}

Finalmente sigue la guía oficial de Spring Boot para configurar la seguridad de tu aplicación con Basic Authentication.

Spring Data JPA

Dependencia

<dependency>
  <groupId>org.springframework.boot</groupId>
  <artifactId>spring-boot-starter-data-jpa</artifactId>
</dependency>

Propósito

Facilita la integración con bases de datos relacionales utilizando JPA. Simplifica las operaciones de base de datos con repositorios y consultas. JPA permite que los desarrolladores trabajen con objetos en lugar de trabajar con filas, columnas y tablas por separado.

Explicación

JPA es una especificación o contrato. Hibernate es un proveedor que cumple con lo que JPA dice que hay que cumplir. Al usar esta dependencia viene configurado por defecto con Hibernate.

Para activarlo debes crear una clase con al menos el siguiente código:

@Configuration
@EnableJpaRepositories
public class JpaConfig {
}

JPA te permite usar anotaciones para mapear tus clases a tablas de base de datos. Por ejemplo, si tienes una clase Customer, puedes mapearla a una tabla de la siguiente manera:

@Entity
@Table(name = "customers")
public class Customer {
    @Id
    @UuidGenerator(style = UuidGenerator.Style.AUTO)
    private UUID id;

    @Column(nullable = false)
    private String name;

    @Column(nullable = false)
    private String surname;

    @Column()
    private String image;

    @ManyToOne(fetch = FetchType.LAZY)
    @JoinColumn(
        name = "created_by",
        nullable = false,
        updatable = false
    )
    @CreatedBy
    private User createdBy;

    @ManyToOne(fetch = FetchType.LAZY)
    @JoinColumn(
        name = "last_updated_by",
        nullable = false
    )

    @LastModifiedBy
    private User lastUpdatedBy;
}

PostgreSQL

Dependencia

<dependency>
  <groupId>org.postgresql</groupId>
  <artifactId>postgresql</artifactId>
  <scope>runtime</scope>
</dependency>

Propósito

Proporciona el controlador JDBC para conectarse a bases de datos PostgreSQL. JDBC es un componente diseñado para que cualquier aplicación Java pueda hablar con bases de datos. Existen controladores JDBC para la mayoría de las bases de datos y hay 4 tipos de controladores JDBC. El más usado es el tipo 4 o también llamado JDBC puro.

Explicación

Para configurar la conexión a la base de datos, puedes añadir las siguientes líneas en tu archivo application.yaml:

spring:
  datasource:
    url: jdbc:postgresql://localhost:5432/testdb
    username: myuser
    password: mypassword

  jpa:
    hibernate:
      ddl-auto: create-drop
    show-sql: true
    defer-datasource-initialization: true
  sql:
    init:
      mode: always

Si quieres visualizar los datos de la base de datos te recomiendo que te instales el programa dbeaver en su versión escritorio. Es un programa gratuito y open source que te permite visualizar los datos de la base de datos.

Puedes descargar DBeaver desde su página oficial.

H2

Dependencia

<dependency>
  <groupId>com.h2database</groupId>
  <artifactId>h2</artifactId>
  <scope>runtime</scope>
</dependency>

Propósito

Proporciona una base de datos en memoria para pruebas y desarrollo rápido. H2 es una base de datos ligera y rápida que se ejecuta en memoria, lo que significa que no requiere configuración adicional ni instalación. Es ideal para realizar pruebas de concepto o desarrollos rápidos como pueden ser pruebas técnicas sencillas.

Además, H2 ofrece una consola web que facilita la visualización y manipulación de datos durante el desarrollo. Te evita tener que instalar una base de datos en tu máquina local.

Explicación

Para configurar la conexión a la base de datos, puedes añadir las siguientes líneas en tu archivo application.yaml:

spring:
  datasource:
    url: jdbc:h2:mem:testdb
    username: sa
    password: password
  h2:
    console:
      enabled: true
  jpa:
    hibernate:
      ddl-auto: update
    show-sql: true

Lo que ganas con H2 es evitarte conceptos de Docker o instalar una base de datos. Cuando estás aprendiendo o haciendo pruebas de concepto rápidas es genial.

Si tienes más conocimientos, opta por usar PostgreSQL en lugar de H2 para entornos de desarrollo más realistas.

Validation

Dependencia

<dependency>
  <groupId>org.springframework.boot</groupId>
  <artifactId>spring-boot-starter-validation</artifactId>
</dependency>

Propósito

Proporciona soporte para la validación de datos en aplicaciones Spring Boot. Asegurarse que los datos de entrada son válidos es imprescindible porque permite filtrar de forma controlada los datos que el backend espera. Nadie quiere un String cuando espera un Integer o un Boolan.

Explicación

Si vas a la guía de validación de Spring Boot, verás que se el equipo de Spring no te da mucha información. Te sueltan su rollo de JSR-303 implementation.

El equipo de Spring quieren decirte que para usar validaciones necesitas a alguien que implemente JSR-303. Hibernate implementa esa especificación, así que estamos de suerte porque recuerda que viene por defecto en Spring Boot.

Para ver qué validaciones existen, consulta la documentación de Hibernate Validator.

Para usar las validaciones, simplemente añade las anotaciones de Hibernate Validator a tus clases. Por ejemplo, si tienes una clase para crear un cliente puedes añadir las siguientes anotaciones:

public record CreateUserDTO(
    @NotBlank
    @Size(min = 3)
    @Pattern(regexp = "^[^0-9]*$") //Only letters accepted
    String username,
    @Email
    String email
) {
}

Contenedores con Docker

Dependencia

<dependency>
  <groupId>org.springframework.boot</groupId>
  <artifactId>spring-boot-docker-compose</artifactId>
  <scope>runtime</scope>
  <optional>true</optional>
</dependency>

Propósito

Facilita la creación y despliegue de aplicaciones en contenedores Docker. En la raíz se instala un fichero llamado compose.yaml

El archivo compose.yaml contiene la configuración básica para levantar un contenedor Docker con una base de datos. La magia viene del autoconfiguration de Spring que detecta el compose.yaml, levanta el contenedor, levanta la aplicación y la conecta a la base de datos.

Puedes encontrar una entrada completa para configurar un compose.yaml enConfigurar un proyecto Spring Boot para desarrollo.

Explicación

También puedes encontrar que se usa un archivo Dockerfile en la raíz del tipo siguiente:

Archivo Dockerfile:

FROM openjdk:17-jdk-slim
VOLUME /tmp
COPY target/*.jar example.jar
ENTRYPOINT ["java","-jar","/example.jar"]

Personalmente a día de hoy prefiero usar el compose.yaml con variables de entorno y definir las variables en un fichero .env.

DevTools

Dependencia

<dependency>
  <groupId>org.springframework.boot</groupId>
  <artifactId>spring-boot-devtools</artifactId>
  <scope>runtime</scope>
</dependency>

Propósito

Mejora la experiencia de desarrollo proporcionando características como recarga automática y configuraciones de desarrollo.

Explicación

DevTools guarda en caché y monitoriea los archivos. Si un archivo se modifica y está en el classpath del proyecto, la aplicación se reinicia automáticamente.

En mi día a día las uso a diario aunque no me de cuenta. La razón es que para desarrollo en Java uso IntelliJ IDEA. Me va muy bien para reiniciar la aplicación cuando desarrollo o hago debug. Muchas veces ni me acuerdo que las DevTools están activadas.

Para una guía detallada sobre la configuración de DevTools en Spring Boot, visita este enlace.

Springdoc OpenAPI

Dependencia

<dependency>
  <groupId>org.springdoc</groupId>
  <artifactId>springdoc-openapi-starter-webmvc-ui</artifactId>
</dependency>

Propósito

Facilita la generación de documentación OpenAPI. OpenAPI es una especificación en la industria para describir APIs RESTful y que permita entendernos entre desarrolladores. Si tienes una API RESTful, es imprescindible que tengas una documentación clara y precisa.

Explicación

Es muy útil para generar y mantener documentación de una API y proporciona una interfaz gráfica basada en Swagger UI que permite a los desarrolladores y a QA explorar y probar los endpoints de la API sin necesitar de Postman o Insomnia.

Si estás en un nivel de conocimiento técnico y funcional muy elevado el primer paso es diseñar la API. Un buen paso es usar OpenAPI para diseñar la API y luego implementarla. El enfoque es no tocar el código hasta que la API tenga una base inicial con cara y ojos.

Apache Commons Lang

Dependencia

<dependency>
  <groupId>org.apache.commons</groupId>
  <artifactId>commons-lang3</artifactId>
</dependency>

Propósito

Esta librería no es propia de Spring Boot. Proporciona utilidades adicionales para manipulación de cadenas.

Explicación

La utilidad que más uso es StringUtils.isBlank(). Es una forma segura de comprobar si una cadena es nula o vacía.

Lo más útil que tiene la librería es la posibilidad de sobrescribir los métodos hashCode y equals. En un trabajo que tuve, la usábamos de la siguiente manera y siempre lo uso así cuando no uso Lombok:

    @Override
    public boolean equals(Object object) {
        return EqualsBuilder.reflectionEquals(this, object);
    }
    @Override
    public int hashCode() {
        return HashCodeBuilder.reflectionHashCode(this);
    }

Por úlitmo, la librería tiene muchas utilidades que usan Reflection por en medio. No abuses de ella y si hace falta consulta la documentación oficial o con tu equipo de trabajo.

Siguientes pasos

Con estas dependencias ya puedes empezar a construir tu aplicación. Si quieres ver cómo implementarlas en un caso real, te recomiendo seguir la guía para crear una API REST CRUD con Spring Boot. También puedes aprender técnicas avanzadas de pruebas como cargar archivos JSON para tests unitarios.

boot-rest-controller-crud).