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

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.

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.

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

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

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

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

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

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

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.

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.

Perguntas Comuns de Entrevista sobre Configuracao do Spring Boot

A configuracao e um tema frequente nas entrevistas de 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:

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

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:

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

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