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

> Comparacion detallada entre YAML y Properties en Spring Boot. Sintaxis, gestion de perfiles, estructuras de datos y preguntas de entrevista tecnica.

- Published: 2026-08-26
- Updated: 2026-08-26
- Author: Anthony Fillion-Maillet
- Reading time: 5 min

---

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.

> **Guia de Decision Rapida**
>
> Usar YAML para proyectos con configuracion profundamente anidada o multiples perfiles. Usar Properties para configuraciones planas simples o cuando el equipo no esta familiarizado con la sintaxis YAML.

## 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.

```properties
# 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:

```yaml
# 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:

```properties
# 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 `---`:

```yaml
# 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](https://docs.spring.io/spring-boot/reference/features/external-config.html) 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.

```yaml
# 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:

```properties
# 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.

```java
// AppSecurityProperties.java
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.

```java
// SecurityConfig.java
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](/technologies/spring-boot/interview-questions/spring-security-basics).

## Preguntas Comunes de Entrevista sobre Configuracion de Spring Boot

La configuracion es un tema frecuente en las [entrevistas de Spring Boot](/technologies/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:

```yaml
# 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](/blog/spring-boot/spring-boot-actuator-monitoring-micrometer-prometheus) 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.

```java
// DatabaseProperties.java
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:

```yaml
# 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.

| Caracteristica | YAML | Properties |
|----------------|------|------------|
| Configuracion anidada | Jerarquia nativa | Notacion de puntos |
| Multi-perfil en un archivo | Soportado via `---` | Requiere archivos separados |
| Sintaxis de listas | Arrays YAML nativos | Notacion de indice `[0]`, `[1]` |
| Comentarios | `#` en cualquier linea | `#` o `!` en cualquier linea |
| Autocompletado IDE | Bueno en IntelliJ, VS Code | Excelente en todos los IDE |
| Curva de aprendizaje | Requiere conocimiento YAML | Minima |

## 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

---

Source: SharpSkill (https://sharpskill.dev), tech interview preparation for your real stack.
HTML version of this page: https://sharpskill.dev/es/blog/spring-boot/spring-boot-yaml-vs-properties-configuration-comparison