# Spring Boot YAML vs Properties: Comparacao de Configuracao e Perguntas de Entrevista 2026

> Comparacao detalhada entre YAML e Properties no Spring Boot. Sintaxe, gerenciamento de perfis, estruturas de dados e perguntas de entrevista tecnica.

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

---

O Spring Boot oferece suporte nativo a dois formatos de configuracao: YAML (`application.yml`) e Properties (`application.properties`). Ambos alcancam o mesmo objetivo, mas diferem em sintaxe, legibilidade e casos de uso especificos. Esta comparacao detalha as diferencas praticas e aborda as perguntas de entrevista que surgem sobre configuracao externalizada do Spring Boot.

> **Guia de Decisao Rapida**
>
> Utilizar YAML para projetos com configuracao profundamente aninhada ou multiplos perfis. Utilizar Properties para configuracoes planas simples ou quando a equipe nao esta familiarizada com a sintaxe YAML.

## Comparacao de Sintaxe Entre YAML e Properties

A diferenca mais visivel esta em como cada formato representa dados hierarquicos. Arquivos Properties usam notacao de ponto em cada linha, enquanto YAML usa indentacao para expressar aninhamento.

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

A configuracao YAML equivalente agrupa visualmente as configuracoes 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 reduz a repeticao quando multiplas propriedades compartilham o mesmo prefixo. No arquivo properties, `spring.datasource` aparece tres vezes, enquanto YAML o declara apenas uma vez.

## Gerenciamento de Perfis na Configuracao do Spring Boot

Os perfis do Spring Boot permitem diferentes configuracoes para ambientes de desenvolvimento, staging e producao. Ambos os formatos suportam perfis, mas YAML os gerencia de forma mais elegante.

Com arquivos properties, arquivos separados sao necessarios 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 suporta sintaxe multi-documento dentro de um unico arquivo usando o 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 o Spring Boot 2.4, a propriedade `spring.config.activate.on-profile` substituiu a sintaxe antiga `spring.profiles`. A [documentacao do Spring Boot](https://docs.spring.io/spring-boot/reference/features/external-config.html) detalha a ativacao de perfis.

## Listas e Estruturas de Dados Complexas

YAML se destaca na representacao de listas e estruturas aninhadas. Isso importa para configuracoes como regras de seguranca, mapeamentos CORS ou 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
```

O equivalente em properties requer notacao 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
```

Adicionar uma nova origem ao arquivo YAML significa simplesmente adicionar uma linha. Em properties, cada indice existente deve permanecer correto, e a nova entrada precisa do proximo numero de indice.

## Configuracao Type-Safe com @ConfigurationProperties

O Spring Boot 3.4 vincula valores de configuracao a classes Java atraves de `@ConfigurationProperties`. Ambos os formatos funcionam de forma identica com esta anotacao.

```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) {}
}
```

O binding relaxado do Spring Boot converte automaticamente entre diferentes convencoes de nomenclatura. A propriedade `app.security.allowed-origins` se vincula a `allowedOrigins` independentemente de a fonte ser YAML ou 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;
    }
    
    // Configuracao CORS usando securityProperties.cors().allowedMethods()
}
```

Para mais informacoes sobre padroes de configuracao do Spring Security, consultar o [modulo de fundamentos do Spring Security](/technologies/spring-boot/interview-questions/spring-security-basics).

## Perguntas Comuns de Entrevista sobre Configuracao do Spring Boot

A configuracao e um tema frequente nas [entrevistas de Spring Boot](/technologies/spring-boot). Os entrevistadores avaliam a compreensao da configuracao externalizada, configuracoes especificas de ambiente e binding de propriedades.

### Pergunta: Qual e a ordem de precedencia para as fontes de configuracao?

O Spring Boot carrega a configuracao de multiplas fontes em uma ordem especifica. Fontes de maior precedencia sobrescrevem as de menor:

1. Argumentos de linha de comando (`--server.port=9000`)
2. Propriedades do sistema Java (`-Dserver.port=9000`)
3. Variaveis de ambiente do sistema operacional (`SERVER_PORT=9000`)
4. Properties especificas do perfil (`application-{profile}.yml`)
5. Properties da aplicacao (`application.yml` ou `application.properties`)
6. Anotacoes `@PropertySource`
7. Propriedades padrao via `SpringApplication.setDefaultProperties`

Um candidato que conhece essa ordem demonstra compreensao de como o Spring Boot resolve valores conflitantes.

### Pergunta: Quando escolher properties em vez de YAML?

Arquivos properties tem vantagens em situacoes especificas:

- **Suporte de IDE**: Alguns IDEs mais antigos fornecem melhor autocompletacao para arquivos `.properties`
- **Familiaridade da equipe**: A sintaxe properties e mais simples para desenvolvedores novos no Spring Boot
- **Valores de uma unica linha**: Configuracoes planas sem aninhamento nao ganham nada com YAML
- **Integracao de ferramentas de build**: A filtragem de recursos do Maven e Gradle funciona diretamente com properties

YAML funciona melhor quando:

- A configuracao tem aninhamento profundo (tres ou mais niveis)
- Multiplos perfis pertencem a um unico arquivo
- Listas requerem modificacoes frequentes
- A legibilidade importa para configuracoes complexas

### Pergunta: Como lidar com valores de configuracao sensiveis?

Nunca fazer commit de segredos no controle de versao. O Spring Boot fornece varias abordagens:

```yaml
# application.yml - referencia variavel de ambiente
spring:
  datasource:
    password: ${DB_PASSWORD}
```

Para sistemas de producao, o Spring Cloud Config Server ou HashiCorp Vault fornecem gerenciamento centralizado de segredos. O [guia de monitoramento do Actuator](/blog/spring-boot/spring-boot-actuator-monitoring-micrometer-prometheus) aborda a seguranca de endpoints sensiveis.

## Validacao de Configuracao no Spring Boot 3.4

O Spring Boot valida classes `@ConfigurationProperties` na inicializacao quando combinadas com anotacoes do 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
) {}
```

Se `app.database.pool-size` estiver ausente ou for negativo, a aplicacao falha rapidamente durante a inicializacao com uma mensagem de erro clara. Essa validacao funciona de forma identica para fontes YAML e properties.

## Arquivos de Configuracao Especificos do Ambiente

O Spring Boot 3.4 suporta localizacoes de arquivos de configuracao adicionais alem do `src/main/resources` padrao. A propriedade `spring.config.import` carrega arquivos externos:

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

O prefixo `optional:` previne falha na inicializacao quando o arquivo nao existe. Esse padrao permite desenvolvimento local com valores padrao enquanto producao obtem a configuracao de um servidor central.

| Caracteristica | YAML | Properties |
|----------------|------|------------|
| Configuracao aninhada | Hierarquia nativa | Notacao de ponto |
| Multi-perfil em um arquivo | Suportado via `---` | Requer arquivos separados |
| Sintaxe de listas | Arrays YAML nativos | Notacao de indice `[0]`, `[1]` |
| Comentarios | `#` em qualquer linha | `#` ou `!` em qualquer linha |
| Autocompletacao de IDE | Boa no IntelliJ, VS Code | Excelente em todos os IDEs |
| Curva de aprendizado | Requer conhecimento YAML | Minima |

## Pontos-Chave para Configuracao do Spring Boot

- YAML reduz a repeticao para configuracoes com prefixos compartilhados e lida com listas de forma mais limpa
- Arquivos properties funcionam bem para configuracoes planas e equipes menos familiarizadas com a sintaxe YAML
- O Spring Boot 3.4 trata ambos os formatos igualmente para binding e validacao de `@ConfigurationProperties`
- O gerenciamento de perfis em YAML mantem ambientes relacionados em um unico arquivo, reduzindo a proliferacao de arquivos
- A precedencia de configuracao segue uma ordem definida: argumentos de linha de comando sobrescrevem variaveis de ambiente, que sobrescrevem configuracao baseada em arquivos
- Valores sensiveis pertencem a variaveis de ambiente ou sistemas de gerenciamento de segredos, nunca a arquivos sob controle de versao
- Utilizar `spring.config.import` para carregar configuracao de fontes externas em ambientes de producao

---

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