Capítulo 3: Configuração com application.properties e application.yml

Introdução

A configuração é um aspecto fundamental de qualquer aplicação. O Spring Boot oferece um sistema de configuração poderoso e flexível que permite personalizar o comportamento da aplicação sem modificar o código.

Objetivos do Capítulo

Ao final deste capítulo, você será capaz de:

• Configurar uma aplicação com application.properties e application.yml
• Utilizar as propriedades pré-definidas do Spring Boot
• Criar propriedades personalizadas
• Gerenciar diferentes ambientes com profiles
• Externalizar a configuração

---

Arquivos de Configuração

Localização

O Spring Boot procura os arquivos de configuração nesta ordem:

Ordem de prioridade (da mais alta para a mais baixa):

1. file:./config/application.properties
2. file:./config/application.yml
3. file:./application.properties
4. file:./application.yml
5. classpath:/config/application.properties
6. classpath:/config/application.yml
7. classpath:/application.properties
8. classpath:/application.yml

Na prática: Coloque seus arquivos em src/main/resources/

---

Formato application.properties

Sintaxe Básica

Formato:

chave=valor

Características:

• Formato simples de chave-valor
• Sem indentação
• Comentários com #
• Repetição de prefixos

Exemplo Completo

# Configuração do servidor
server.port=8080
server.servlet.context-path=/api

# Nome da aplicação
spring.application.name=greeting-app

# Configuração do banco de dados
spring.datasource.url=jdbc:postgresql://localhost:5432/mydb
spring.datasource.username=postgres
spring.datasource.password=secret
spring.datasource.driver-class-name=org.postgresql.Driver

# Configuração JPA
spring.jpa.hibernate.ddl-auto=update
spring.jpa.show-sql=true
spring.jpa.properties.hibernate.format_sql=true
spring.jpa.properties.hibernate.dialect=org.hibernate.dialect.PostgreSQLDialect

# Configuração de logs
logging.level.root=INFO
logging.level.com.example=DEBUG
logging.level.org.springframework.web=DEBUG
logging.file.name=logs/application.log

# Configuração Jackson (JSON)
spring.jackson.date-format=yyyy-MM-dd HH:mm:ss
spring.jackson.time-zone=America/Montreal
spring.jackson.serialization.indent-output=true

Vantagens e Desvantagens

Vantagens:

• Formato simples e amplamente conhecido
• Compatível com Java Properties
• Nenhuma dependência externa

Desvantagens:

• Repetitivo para estruturas hierárquicas
• Menos legível para configurações complexas

---

Formato application.yml

Sintaxe Básica

Formato: YAML (YAML Ain't Markup Language)

Características:

• Formato hierárquico com indentação
• Indentação = 2 ou 4 espaços (NÃO usar tabs)
• Estrutura em árvore
• Mais conciso

Exemplo Completo

# Configuração do servidor
server:
  port: 8080
  servlet:
    context-path: /api

# Nome da aplicação
spring:
  application:
    name: greeting-app
  
  # Configuração do banco de dados
  datasource:
    url: jdbc:postgresql://localhost:5432/mydb
    username: postgres
    password: secret
    driver-class-name: org.postgresql.Driver
  
  # Configuração JPA
  jpa:
    hibernate:
      ddl-auto: update
    show-sql: true
    properties:
      hibernate:
        format_sql: true
        dialect: org.hibernate.dialect.PostgreSQLDialect
  
  # Configuração Jackson
  jackson:
    date-format: yyyy-MM-dd HH:mm:ss
    time-zone: America/Montreal
    serialization:
      indent-output: true

# Configuração de logs
logging:
  level:
    root: INFO
    com.example: DEBUG
    org.springframework.web: DEBUG
  file:
    name: logs/application.log

Vantagens e Desvantagens

Vantagens:

• Mais legível para estruturas complexas
• Menos repetição
• Suporte a listas e maps
• Formato moderno

Desvantagens:

• Sensível à indentação
• Erros de sintaxe mais frequentes
• Necessita da dependência SnakeYAML (inclusa por padrão)

---

Comparação properties vs yml

Mesma Configuração nos Dois Formatos

application.properties:

spring.datasource.url=jdbc:postgresql://localhost:5432/mydb
spring.datasource.username=postgres
spring.datasource.password=secret

application.yml:

spring:
  datasource:
    url: jdbc:postgresql://localhost:5432/mydb
    username: postgres
    password: secret

Tabela Comparativa

Critério	properties	yml
Legibilidade	⭐⭐⭐	⭐⭐⭐⭐⭐
Simplicidade	⭐⭐⭐⭐⭐	⭐⭐⭐
Estrutura	Plana	Hierárquica
Repetição	Muita	Pouca
Listas	Difícil	Fácil
Compatibilidade	Universal	Requer parser
Erros	Raros	Indentação

Recomendação: Use .yml para configurações complexas, .properties para configurações simples.

---

Propriedades Comuns do Spring Boot

1. Configuração do Servidor

server:
  port: 8080                          # Porta do servidor
  servlet:
    context-path: /api                # Caminho base
  compression:
    enabled: true                     # Compressão GZIP
  error:
    include-message: always           # Incluir mensagens de erro

2. Configuração do Banco de Dados

PostgreSQL

spring:
  datasource:
    url: jdbc:postgresql://localhost:5432/mydb
    username: postgres
    password: secret
    driver-class-name: org.postgresql.Driver

MySQL

spring:
  datasource:
    url: jdbc:mysql://localhost:3306/mydb
    username: root
    password: secret
    driver-class-name: com.mysql.cj.jdbc.Driver

H2 (Banco de dados em memória - Testes)

spring:
  datasource:
    url: jdbc:h2:mem:testdb
    driver-class-name: org.h2.Driver
  h2:
    console:
      enabled: true                   # Console H2 acessível
      path: /h2-console

3. Configuração JPA/Hibernate

spring:
  jpa:
    hibernate:
      ddl-auto: update                # none, validate, update, create, create-drop
    show-sql: true                    # Exibir queries SQL
    properties:
      hibernate:
        format_sql: true              # Formatar queries
        dialect: org.hibernate.dialect.PostgreSQLDialect
        use_sql_comments: true        # Comentar queries

Valores de ddl-auto:

Valor	Descrição	Uso
none	Nenhuma ação	Produção
validate	Apenas validar o schema	Produção
update	Atualizar o schema	Desenvolvimento
create	Criar o schema na inicialização	Testes
create-drop	Criar e depois remover	Testes

4. Configuração de Logs

logging:
  level:
    root: INFO                        # Nível global
    com.example: DEBUG                # Sua aplicação
    org.springframework.web: DEBUG    # Spring Web
    org.hibernate.SQL: DEBUG          # Queries SQL
    org.hibernate.type: TRACE         # Parâmetros SQL
  pattern:
    console: '%d{yyyy-MM-dd HH:mm:ss} - %msg%n'
  file:
    name: logs/application.log        # Arquivo de log
    max-size: 10MB                    # Tamanho máximo por arquivo

Níveis de log:

TRACE < DEBUG < INFO < WARN < ERROR < FATAL < OFF

5. Configuração Jackson (JSON)

spring:
  jackson:
    date-format: yyyy-MM-dd HH:mm:ss
    time-zone: America/Montreal
    serialization:
      indent-output: true             # JSON identado
      write-dates-as-timestamps: false
    deserialization:
      fail-on-unknown-properties: false

6. Configuração DevTools

spring:
  devtools:
    restart:
      enabled: true                   # Reinício automático
    livereload:
      enabled: true                   # Recarregamento do navegador

---

Propriedades Personalizadas

Criar Propriedades Personalizadas

application.yml:

app:
  name: Greeting Application
  version: 1.0.0
  admin:
    email: admin@example.com
    phone: +1-514-123-4567
  security:
    jwt-secret: mySecretKey123
    jwt-expiration: 86400000          # 24 horas em ms

Injeção com @Value

import org.springframework.beans.factory.annotation.Value;
import org.springframework.stereotype.Component;

@Component
public class AppConfig {

    @Value("${app.name}")
    private String appName;
    
    @Value("${app.version}")
    private String appVersion;
    
    @Value("${app.admin.email}")
    private String adminEmail;
    
    public void printConfig() {
        System.out.println("Application: " + appName);
        System.out.println("Version: " + appVersion);
        System.out.println("Admin Email: " + adminEmail);
    }
}

Classe de Configuração com @ConfigurationProperties

Abordagem recomendada para múltiplas propriedades:

application.yml:

app:
  security:
    jwt-secret: mySecretKey123
    jwt-expiration: 86400000
    allowed-origins:
      - http://localhost:3000
      - http://localhost:4200

Classe de configuração:

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

@Component
@ConfigurationProperties(prefix = "app.security")
public class SecurityProperties {

    private String jwtSecret;
    private Long jwtExpiration;
    private List<String> allowedOrigins;
    
    // Getters e Setters
    public String getJwtSecret() {
        return jwtSecret;
    }
    
    public void setJwtSecret(String jwtSecret) {
        this.jwtSecret = jwtSecret;
    }
    
    public Long getJwtExpiration() {
        return jwtExpiration;
    }
    
    public void setJwtExpiration(Long jwtExpiration) {
        this.jwtExpiration = jwtExpiration;
    }
    
    public List<String> getAllowedOrigins() {
        return allowedOrigins;
    }
    
    public void setAllowedOrigins(List<String> allowedOrigins) {
        this.allowedOrigins = allowedOrigins;
    }
}

Uso:

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;

@Service
public class AuthService {

    @Autowired
    private SecurityProperties securityProperties;
    
    public void generateToken() {
        String secret = securityProperties.getJwtSecret();
        Long expiration = securityProperties.getJwtExpiration();
        // Lógica de geração de token
    }
}

---

Gerenciamento de Profiles

Conceito de Profiles

Os profiles permitem ter configurações diferentes de acordo com o ambiente.

Criar Profiles

Estrutura dos arquivos:

src/main/resources/
├── application.yml                 # Configuração comum
├── application-dev.yml             # Desenvolvimento
├── application-test.yml            # Testes
└── application-prod.yml            # Produção

Configuração por Profile

application.yml (comum):

spring:
  application:
    name: greeting-app

app:
  name: Greeting Application

application-dev.yml:

server:
  port: 8080

spring:
  datasource:
    url: jdbc:h2:mem:testdb
  h2:
    console:
      enabled: true

logging:
  level:
    root: DEBUG

application-test.yml:

server:
  port: 8081

spring:
  datasource:
    url: jdbc:h2:mem:testdb

logging:
  level:
    root: INFO

application-prod.yml:

server:
  port: 80

spring:
  datasource:
    url: jdbc:postgresql://prod-db.example.com:5432/mydb
    username: ${DB_USERNAME}          # Variável de ambiente
    password: ${DB_PASSWORD}

logging:
  level:
    root: WARN
  file:
    name: /var/log/app/application.log

Ativar um Profile

Método 1: No application.yml

spring:
  profiles:
    active: dev

Método 2: Linha de comando

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

Método 3: Variável de ambiente

export SPRING_PROFILES_ACTIVE=prod
java -jar app.jar

Método 4: Na IDE

VS Code (launch.json):

{
  "configurations": [
    {
      "type": "java",
      "name": "Spring Boot App",
      "request": "launch",
      "mainClass": "com.example.greeting.GreetingApplication",
      "args": "--spring.profiles.active=dev"
    }
  ]
}

Profiles Múltiplos

Você pode ativar múltiplos profiles:

java -jar app.jar --spring.profiles.active=dev,local

Ordem de prioridade: O último profile tem prioridade

---

Variáveis de Ambiente

Utilização

O Spring Boot pode ler variáveis de ambiente:

application.yml:

spring:
  datasource:
    url: ${DATABASE_URL:jdbc:postgresql://localhost:5432/mydb}
    username: ${DATABASE_USER:postgres}
    password: ${DATABASE_PASSWORD:secret}

Sintaxe: ${NOME_VARIAVEL:valor_padrao}

Definir Variáveis

Windows (CMD):

set DATABASE_URL=jdbc:postgresql://prod-server:5432/mydb
set DATABASE_USER=admin
set DATABASE_PASSWORD=supersecret
java -jar app.jar

Windows (PowerShell):

$env:DATABASE_URL="jdbc:postgresql://prod-server:5432/mydb"
$env:DATABASE_USER="admin"
$env:DATABASE_PASSWORD="supersecret"
java -jar app.jar

Linux/macOS:

export DATABASE_URL=jdbc:postgresql://prod-server:5432/mydb
export DATABASE_USER=admin
export DATABASE_PASSWORD=supersecret
java -jar app.jar

---

Configuração Externalizada

Arquivo de Configuração Externo

O Spring Boot pode carregar arquivos de configuração externos:

Estrutura:

/opt/app/
├── app.jar
└── config/
    └── application.yml

Inicialização:

java -jar /opt/app/app.jar

O Spring Boot encontrará automaticamente /opt/app/config/application.yml

Especificar um Arquivo

java -jar app.jar --spring.config.location=file:/path/to/config/

---

Propriedades Sensíveis

Proteger Senhas

Má prática:

spring:
  datasource:
    password: supersecret123          # ❌ Senha em texto claro

Boas práticas:

1. Variáveis de ambiente:

spring:
  datasource:
    password: ${DATABASE_PASSWORD}    # ✅ Variável de ambiente

2. Spring Cloud Config Server:

• Centralizar a configuração
• Criptografia de propriedades sensíveis

3. HashiCorp Vault:

• Gerenciamento profissional de segredos

4. Arquivos .env (apenas para desenvolvimento):

DATABASE_PASSWORD=secret

Importante: Nunca faça commit de senhas no Git!

---

Exercícios Práticos

Exercício 1: Configuração Básica

Objetivo: Configurar a porta e o nome da aplicação

Instruções:

1. Crie um projeto Spring Boot
2. Em application.properties, configure:
   • Porta: 8081
   • Nome: "My Greeting App"
3. Inicie a aplicação
4. Verifique se o servidor inicia na porta 8081

Exercício 2: Conversão properties → yml

Objetivo: Converter um arquivo properties em yml

Arquivo properties fornecido:

server.port=8080
spring.application.name=user-service
spring.datasource.url=jdbc:postgresql://localhost:5432/users
spring.datasource.username=admin
spring.jpa.show-sql=true

A fazer: Converta para o formato YAML

Exercício 3: Propriedades Personalizadas

Objetivo: Criar e utilizar propriedades personalizadas

Instruções:

1. Adicione em application.yml:

   app:
     welcome-message: Bem-vindo!
     max-users: 100
2. Crie um controller que exiba esses valores
3. Teste

Exercício 4: Profiles

Objetivo: Criar profiles dev e prod

Instruções:

1. Crie application-dev.yml:
   • Porta: 8080
   • Logs: DEBUG
2. Crie application-prod.yml:
   • Porta: 80
   • Logs: WARN
3. Teste a ativação de cada profile

---

Perguntas de Revisão

1. Qual a diferença entre application.properties e application.yml?

2. Como ativar um profile no Spring Boot?

3. Qual é a ordem de prioridade dos arquivos de configuração?

4. Como injetar uma propriedade personalizada em uma classe?

5. Qual anotação usar para uma classe de configuração com várias propriedades?

6. Como usar uma variável de ambiente no application.yml?

7. Quais são os valores possíveis para spring.jpa.hibernate.ddl-auto?

8. Por que nunca fazer commit de senhas no application.properties?

---

Resumo do Capítulo

Pontos-Chave

• O Spring Boot suporta .properties e .yml
• .yml é mais legível para estruturas complexas
• Profiles permitem configurações por ambiente
• @Value para uma propriedade, @ConfigurationProperties para várias
• Use variáveis de ambiente para dados sensíveis
• Nunca faça commit de senhas

Boas Práticas

• Use profiles para cada ambiente
• Externalize configurações sensíveis
• Documente as propriedades personalizadas
• Forneça valores padrão
• Use nomes de propriedades descritivos
• Separe configuração comum e específica

---

Próximos Passos

No próximo capítulo, vamos estudar:

Capítulo 4: Anotações Básicas

• @SpringBootApplication
• @RestController vs @Controller
• @GetMapping, @PostMapping, etc.
• @Autowired e injeção de dependências
• @Component, @Service, @Repository

---

Voltar ao Módulo 2