Configuración mediante application.properties y application.yml

Vamos a profundizar en las configuraciones. Cada proyecto Spring Boot empieza con la pregunta: "¿Dónde guardar los ajustes?". Spring Boot responde de forma sencilla: usa application.properties o application.yml. Estos dos archivos son como el centro de control de vuelo para tu aplicación, donde cada línea puede decidir su destino: desde un despegue triunfal hasta una caída épica.

Spring Boot busca estos archivos en src/main/resources — el sitio estándar para todos los recursos del proyecto. Tiene sentido: la configuración también es un recurso, solo que especial —define cómo se comportará tu aplicación en distintas situaciones. Y créeme, una configuración correcta puede convertir incluso la app más simple en un servicio corporativo fiable.

¿Qué configuramos?

• Puerto del servidor: en qué puerto debe correr la aplicación.
• Base de datos: URL de conexión, usuario, contraseña, etc.
• Perfiles de la aplicación: distintas configuraciones para entorno de desarrollo, testing y producción.
• Parámetros de logging: nivel de logs, formato de salida, y demás.

Diferencias entre application.properties y application.yml

Seguro que ya te has topado con la pregunta "¿qué es mejor — JSON o XML?", ahora te esperan batallas similares entre application.properties y application.yml.

application.properties

Es el formato "clave-valor", familiar y claro para la mayoría de desarrolladores. Ejemplo:

server.port=8080
spring.datasource.url=jdbc:mysql://localhost:3306/mydb
spring.datasource.username=root
spring.datasource.password=secret

Ventajas:

• Sencillo y conciso.
• Fácil de leer y editar.

Desventajas:

• Para configuraciones complejas (por ejemplo, arrays) se vuelve engorroso.
• Carece de estructura visual, lo que puede complicar la lectura de archivos grandes.

application.yml

Si properties te parecen demasiado planos, conoce YAML (sí, es un acrónimo recursivo: "YAML Ain't Markup Language"). YAML hace la configuración más visual gracias a la indentación y estructura en árbol. Mira esto:

server:
  port: 8080

spring:
  datasource:
    url: jdbc:mysql://localhost:3306/mydb
    username: root
    password: secret

Ventajas:

• Soporta estructuras anidadas, lo que lo hace más legible.
• Ideal para configuraciones complejas.

Desventajas:

• Requiere cuidado con las indentaciones (si te equivocas en el nivel — hola, errores).

En realidad, la elección entre ambos depende de tu gusto y de la complejidad del proyecto. Pero para apps grandes, YAML suele ser preferible.

Gestión de perfiles en Spring Boot

Imagina que tu aplicación debe comportarse distinto según el entorno: desarrollo (dev), testing (test), producción (prod). Para eso, Spring Boot ofrece el mecanismo de perfiles.

¿Cómo configurar perfiles?

Muy fácil: añade al nombre del archivo de configuración el nombre del perfil. Por ejemplo:

• application-dev.properties o application-dev.yml
• application-prod.properties o application-prod.yml

Y en el archivo principal application.properties o application.yml indica el perfil activo:

spring.profiles.active=dev

O, si eres fan del YAML:

spring:
  profiles:
    active: dev

¿Cómo cambiar el perfil activo?

Puedes especificar el perfil también mediante:

1. Argumentos de la línea de comandos:

   
   java -jar myapplication.jar --spring.profiles.active=prod
   

2. Variables de entorno:

   
   export SPRING_PROFILES_ACTIVE=prod
   

Esta funcionalidad te permite cambiar entre perfiles sin dolor, como cambiar de pestaña en el navegador.

Tipos de parámetros de configuración

Configuración del servidor

Aquí todo es simple. ¿Quieres cambiar el puerto donde corre tu server embebido? Fácil:

server.port=8081

Configuración de la base de datos

Conectar con la base tampoco te llevará mucho tiempo:

spring.datasource.url=jdbc:mysql://localhost:3306/mydb
spring.datasource.username=root
spring.datasource.password=secret

spring:
  datasource:
    url: jdbc:mysql://localhost:3306/mydb
    username: root
    password: secret

Logging

Para ajustar el nivel de logging:

logging.level.org.springframework=INFO
logging.level.com.myapp=DEBUG

logging:
  level:
    org.springframework: INFO
    com.myapp: DEBUG

Recuerda, un buen logging es como un buen diagrama: explica mucho, pero sin sobrecargar con detalles.

Ventajas de usar YAML

Facilidad para trabajar con estructuras complejas

YAML te permite definir arrays y maps directamente en la estructura:

myapp:
  features:
    - feature1
    - feature2
    - feature3

Con properties tendrías que escribir algo como esto:

myapp.features[0]=feature1
myapp.features[1]=feature2
myapp.features[2]=feature3

Mejor legibilidad

YAML, con sus estructuras anidadas (y usando espacios en lugar de puntos), se lee con más facilidad:

server:
  port: 8080
spring:
  datasource:
    username: root
    password: secret

Aplicación práctica

Hagamos un ejemplo sencillo para afianzar lo visto. Crearemos una app simple que lea parámetros de configuración desde application.yml.

Paso 1: Creamos application.yml

server:
  port: 8080

app:
  title: "Spring Boot Config Demo"
  description: "Este es nuestro ejemplo de aplicación usando YAML."

author:
  name: "Iván Ivanov"
  email: "ivan@example.com"

Paso 2: Leer parámetros en el código

Spring ofrece la anotación @Value para obtener valores del archivo de configuración. Ejemplo:

import org.springframework.beans.factory.annotation.Value;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.RestController;

@RestController
public class ConfigController {

    @Value("${app.title}")
    private String appTitle;

    @Value("${app.description}")
    private String appDescription;

    @Value("${author.name}")
    private String authorName;

    @GetMapping("/config")
    public String getAppConfig() {
        return String.format("%s - %s (autor: %s)", appTitle, appDescription, authorName);
    }
}

Ahora, si arrancas la aplicación, puedes abrir en el navegador http://localhost:8080/config y ver el resultado.

Errores típicos al trabajar con configuraciones

1. Error con las indentaciones en YAML. Si el archivo no se parsea, asegúrate de usar espacios y no tabulaciones.
2. Espacios extra en application.properties. Espacios sobrantes en claves o valores pueden causar problemas inesperados.
3. Indicar incorrectamente el perfil. Si el perfil no está activo, sus configuraciones no se aplican.

En este punto deberías tener ya el control del mundo de las configuraciones en Spring Boot. Todo está en tus manos: por ejemplo, puedes configurar tu entorno de desarrollo, testing y producción para que funcionen como un reloj.