Spring Boot YAML vs Properties: Comparacion de Configuracion y Preguntas de Entrevista 2026

Spring Boot soporta dos formatos de configuracion nativos: YAML (application.yml) y Properties (application.properties). Ambos logran el mismo objetivo, pero difieren en sintaxis, legibilidad y casos de uso especificos. Esta comparacion desglosa las diferencias practicas y cubre las preguntas de entrevista que surgen sobre la configuracion externalizada de Spring Boot.

Comparacion de Sintaxis Entre YAML y Properties

La diferencia mas visible es como cada formato representa datos jerarquicos. Los archivos Properties usan notacion de puntos en cada linea, mientras que YAML usa indentacion para expresar anidamiento.

# application.properties
server.port=8080
server.servlet.context-path=/api
spring.datasource.url=jdbc:postgresql://localhost:5432/mydb
spring.datasource.username=admin
spring.datasource.password=${DB_PASSWORD}
spring.jpa.hibernate.ddl-auto=validate
spring.jpa.show-sql=false

La configuracion YAML equivalente agrupa visualmente las configuraciones relacionadas:

# application.yml
server:
  port: 8080
  servlet:
    context-path: /api

spring:
  datasource:
    url: jdbc:postgresql://localhost:5432/mydb
    username: admin
    password: ${DB_PASSWORD}
  jpa:
    hibernate:
      ddl-auto: validate
    show-sql: false

YAML reduce la repeticion cuando multiples propiedades comparten el mismo prefijo. En el archivo properties, spring.datasource aparece tres veces, mientras que YAML lo declara una sola vez.

Gestion de Perfiles en la Configuracion de Spring Boot

Los perfiles de Spring Boot permiten diferentes configuraciones para entornos de desarrollo, staging y produccion. Ambos formatos soportan perfiles, pero YAML los maneja de manera mas elegante.

Con archivos properties, se requieren archivos separados para cada perfil:

# application-dev.properties
server.port=8080
spring.datasource.url=jdbc:h2:mem:devdb
logging.level.root=DEBUG

# application-prod.properties
server.port=80
spring.datasource.url=jdbc:postgresql://prod-server:5432/proddb
logging.level.root=WARN

YAML soporta sintaxis multi-documento dentro de un solo archivo usando el separador ---:

# application.yml
spring:
  profiles:
    active: dev

---
spring:
  config:
    activate:
      on-profile: dev
server:
  port: 8080
logging:
  level:
    root: DEBUG

---
spring:
  config:
    activate:
      on-profile: prod
server:
  port: 80
logging:
  level:
    root: WARN

Desde Spring Boot 2.4, la propiedad spring.config.activate.on-profile reemplazo la sintaxis anterior spring.profiles. La documentacion de Spring Boot cubre la activacion de perfiles en detalle.

Listas y Estructuras de Datos Complejas

YAML sobresale en la representacion de listas y estructuras anidadas. Esto importa para configuraciones como reglas de seguridad, mapeos CORS o beans personalizados.

# application.yml
app:
  security:
    allowed-origins:
      - https://sharpskill.dev
      - https://api.sharpskill.dev
    cors:
      allowed-methods:
        - GET
        - POST
        - PUT
        - DELETE
    jwt:
      secret: ${JWT_SECRET}
      expiration-ms: 86400000

El equivalente en properties requiere notacion de indice:

# application.properties
app.security.allowed-origins[0]=https://sharpskill.dev
app.security.allowed-origins[1]=https://api.sharpskill.dev
app.security.cors.allowed-methods[0]=GET
app.security.cors.allowed-methods[1]=POST
app.security.cors.allowed-methods[2]=PUT
app.security.cors.allowed-methods[3]=DELETE
app.security.jwt.secret=${JWT_SECRET}
app.security.jwt.expiration-ms=86400000

Agregar un nuevo origen al archivo YAML significa simplemente agregar una linea. En properties, cada indice existente debe permanecer correcto, y la nueva entrada necesita el siguiente numero de indice.

Configuracion Type-Safe con @ConfigurationProperties

Spring Boot 3.4 vincula valores de configuracion a clases Java a traves de @ConfigurationProperties. Ambos formatos funcionan de manera identica con esta anotacion.

import org.springframework.boot.context.properties.ConfigurationProperties;
import java.util.List;

@ConfigurationProperties(prefix = "app.security")
public record AppSecurityProperties(
    List<String> allowedOrigins,
    CorsConfig cors,
    JwtConfig jwt
) {
    public record CorsConfig(List<String> allowedMethods) {}
    public record JwtConfig(String secret, long expirationMs) {}
}

El binding relajado de Spring Boot convierte automaticamente entre diferentes convenciones de nomenclatura. La propiedad app.security.allowed-origins se vincula a allowedOrigins independientemente de si la fuente es YAML o properties.

import org.springframework.context.annotation.Configuration;
import org.springframework.boot.context.properties.EnableConfigurationProperties;

@Configuration
@EnableConfigurationProperties(AppSecurityProperties.class)
public class SecurityConfig {
    
    private final AppSecurityProperties securityProperties;
    
    public SecurityConfig(AppSecurityProperties securityProperties) {
        this.securityProperties = securityProperties;
    }
    
    // Configuracion CORS usando securityProperties.cors().allowedMethods()
}

Para mas informacion sobre patrones de configuracion de Spring Security, consultar el modulo de fundamentos de Spring Security.

Preguntas Comunes de Entrevista sobre Configuracion de Spring Boot

La configuracion es un tema frecuente en las entrevistas de Spring Boot. Los entrevistadores evaluan la comprension de la configuracion externalizada, configuraciones especificas del entorno y binding de propiedades.

Pregunta: Cual es el orden de precedencia para las fuentes de configuracion?

Spring Boot carga la configuracion desde multiples fuentes en un orden especifico. Las fuentes de mayor precedencia sobrescriben las de menor:

1. Argumentos de linea de comandos (--server.port=9000)
2. Propiedades del sistema Java (-Dserver.port=9000)
3. Variables de entorno del sistema operativo (SERVER_PORT=9000)
4. Properties especificas del perfil (application-{profile}.yml)
5. Properties de la aplicacion (application.yml o application.properties)
6. Anotaciones @PropertySource
7. Propiedades por defecto via SpringApplication.setDefaultProperties

Un candidato que conoce este orden demuestra comprension de como Spring Boot resuelve valores conflictivos.

Pregunta: Cuando elegir properties sobre YAML?

Los archivos properties tienen ventajas en situaciones especificas:

• Soporte IDE: Algunos IDE antiguos proporcionan mejor autocompletado para archivos .properties
• Familiaridad del equipo: La sintaxis properties es mas simple para desarrolladores nuevos en Spring Boot
• Valores de una sola linea: Las configuraciones planas sin anidamiento no ganan nada con YAML
• Integracion de herramientas de build: El filtrado de recursos de Maven y Gradle funciona directamente con properties

YAML funciona mejor cuando:

• La configuracion tiene anidamiento profundo (tres o mas niveles)
• Multiples perfiles pertenecen a un solo archivo
• Las listas requieren modificaciones frecuentes
• La legibilidad importa para configuraciones complejas

Pregunta: Como manejar valores de configuracion sensibles?

Nunca hacer commit de secretos al control de versiones. Spring Boot proporciona varios enfoques:

# application.yml - referencia variable de entorno
spring:
  datasource:
    password: ${DB_PASSWORD}

Para sistemas de produccion, Spring Cloud Config Server o HashiCorp Vault proporcionan gestion centralizada de secretos. La guia de monitoreo de Actuator cubre la seguridad de endpoints sensibles.

Validacion de Configuracion en Spring Boot 3.4

Spring Boot valida las clases @ConfigurationProperties al inicio cuando se combinan con anotaciones de Jakarta Bean Validation.

import jakarta.validation.constraints.NotBlank;
import jakarta.validation.constraints.Positive;
import org.springframework.boot.context.properties.ConfigurationProperties;
import org.springframework.validation.annotation.Validated;

@Validated
@ConfigurationProperties(prefix = "app.database")
public record DatabaseProperties(
    @NotBlank String url,
    @NotBlank String username,
    @Positive int poolSize
) {}

Si app.database.pool-size falta o es negativo, la aplicacion falla rapidamente durante el inicio con un mensaje de error claro. Esta validacion funciona de manera identica para fuentes YAML y properties.

Archivos de Configuracion Especificos del Entorno

Spring Boot 3.4 soporta ubicaciones de archivos de configuracion adicionales mas alla del src/main/resources por defecto. La propiedad spring.config.import carga archivos externos:

# application.yml
spring:
  config:
    import:
      - optional:file:./config/
      - optional:configserver:http://config-server:8888

El prefijo optional: previene el fallo del inicio cuando el archivo no existe. Este patron habilita el desarrollo local con valores por defecto mientras produccion obtiene la configuracion desde un servidor central.

Puntos Clave para la Configuracion de Spring Boot

• YAML reduce la repeticion para configuraciones con prefijos compartidos y maneja listas de manera mas limpia
• Los archivos properties funcionan bien para configuraciones planas y equipos menos familiarizados con la sintaxis YAML
• Spring Boot 3.4 trata ambos formatos de manera igual para binding y validacion de @ConfigurationProperties
• La gestion de perfiles en YAML mantiene los entornos relacionados en un solo archivo, reduciendo la proliferacion de archivos
• La precedencia de configuracion sigue un orden definido: argumentos de linea de comandos sobrescriben variables de entorno, que sobrescriben configuracion basada en archivos
• Los valores sensibles pertenecen a variables de entorno o sistemas de gestion de secretos, nunca a archivos bajo control de versiones
• Usar spring.config.import para cargar configuracion desde fuentes externas en entornos de produccion