Spring Boot bietet zwei primäre Formate für die Anwendungskonfiguration: YAML und Properties. Beide Formate erfüllen denselben Zweck, unterscheiden sich jedoch erheblich in Syntax, Lesbarkeit und Anwendungsfällen. Dieser Artikel untersucht beide Ansätze im Detail und bereitet Entwickler auf technische Interviews vor.

Spring Boot 3.4+ unterstützt sowohl application.yml als auch application.properties. Die Wahl zwischen beiden hängt von den Projektanforderungen, der Teamvertrautheit und der Konfigurationskomplexität ab.

Grundlegende Syntaxunterschiede

Der fundamentale Unterschied liegt in der Strukturierung der Konfigurationswerte. Properties-Dateien verwenden eine flache Schlüssel-Wert-Struktur, während YAML hierarchische Daten mit Einrückung darstellt.

Properties-Format

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=secret
spring.datasource.driver-class-name=org.postgresql.Driver

spring.jpa.hibernate.ddl-auto=update
spring.jpa.show-sql=true
spring.jpa.properties.hibernate.dialect=org.hibernate.dialect.PostgreSQLDialect

YAML-Format

yaml

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

spring:
  datasource:
    url: jdbc:postgresql://localhost:5432/mydb
    username: admin
    password: secret
    driver-class-name: org.postgresql.Driver
  jpa:
    hibernate:
      ddl-auto: update
    show-sql: true
    properties:
      hibernate:
        dialect: org.hibernate.dialect.PostgreSQLDialect

Vorteile von YAML-Konfiguration

YAML bietet mehrere Vorteile für komplexe Konfigurationen. Die hierarchische Struktur reduziert Redundanz und verbessert die Lesbarkeit erheblich.

yaml

# Mehrere Profile in einer Datei
spring:
  profiles:
    active: development

---
spring:
  config:
    activate:
      on-profile: development
  datasource:
    url: jdbc:h2:mem:devdb
    driver-class-name: org.h2.Driver

logging:
  level:
    root: DEBUG
    com.example: TRACE

---
spring:
  config:
    activate:
      on-profile: production
  datasource:
    url: jdbc:postgresql://prod-server:5432/proddb
    driver-class-name: org.postgresql.Driver

logging:
  level:
    root: WARN
    com.example: INFO

Die Dokumententrennung mit --- ermöglicht die Definition mehrerer Profile in einer einzigen Datei. Diese Konsolidierung vereinfacht die Verwaltung umgebungsspezifischer Einstellungen.

Listen und komplexe Datenstrukturen

YAML behandelt Listen und verschachtelte Strukturen natürlicher als Properties-Dateien.

yaml

# Liste von Servern
application:
  servers:
    - host: server1.example.com
      port: 8080
      ssl: true
    - host: server2.example.com
      port: 8081
      ssl: false

  allowed-origins:
    - https://example.com
    - https://app.example.com
    - https://admin.example.com

  features:
    authentication:
      enabled: true
      providers:
        - oauth2
        - ldap
    caching:
      enabled: true
      ttl: 3600

Das entsprechende Properties-Format erfordert indexierte Notation:

properties

# Gleiche Konfiguration in Properties
application.servers[0].host=server1.example.com
application.servers[0].port=8080
application.servers[0].ssl=true
application.servers[1].host=server2.example.com
application.servers[1].port=8081
application.servers[1].ssl=false

application.allowed-origins[0]=https://example.com
application.allowed-origins[1]=https://app.example.com
application.allowed-origins[2]=https://admin.example.com

application.features.authentication.enabled=true
application.features.authentication.providers[0]=oauth2
application.features.authentication.providers[1]=ldap
application.features.caching.enabled=true
application.features.caching.ttl=3600

Configuration Properties Binding

Spring Boot ermöglicht typsichere Konfigurationsbindung mit der @ConfigurationProperties-Annotation:

java

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

@Component
@ConfigurationProperties(prefix = "application")
public class ApplicationConfig {
    
    private List<ServerConfig> servers;
    private List<String> allowedOrigins;
    private FeaturesConfig features;
    
    // Getters and setters
    
    public static class ServerConfig {
        private String host;
        private int port;
        private boolean ssl;
        
        // Getters and setters
    }
    
    public static class FeaturesConfig {
        private AuthConfig authentication;
        private CacheConfig caching;
        
        // Getters and setters
    }
    
    public static class AuthConfig {
        private boolean enabled;
        private List<String> providers;
        
        // Getters and setters
    }
    
    public static class CacheConfig {
        private boolean enabled;
        private int ttl;
        
        // Getters and setters
    }
}

Umgebungsvariablen und Externalisierung

Beide Formate unterstützen die Überschreibung durch Umgebungsvariablen. Spring Boot konvertiert automatisch zwischen den Formaten:

bash

# Überschreiben von Konfigurationswerten
export SPRING_DATASOURCE_URL=jdbc:postgresql://prod:5432/db
export SPRING_DATASOURCE_USERNAME=produser
export SERVER_PORT=9090

# Listen können durch Kommas getrennt werden
export APPLICATION_ALLOWED_ORIGINS=https://a.com,https://b.com

yaml

# Referenzierung von Umgebungsvariablen in YAML
spring:
  datasource:
    url: ${DB_URL:jdbc:h2:mem:default}
    username: ${DB_USER:sa}
    password: ${DB_PASSWORD:}

application:
  api-key: ${API_KEY}
  secret: ${APP_SECRET:default-secret}

Validation mit Bean Validation

Konfigurationseigenschaften können mit Jakarta Bean Validation validiert werden:

java

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

@Validated
@ConfigurationProperties(prefix = "application.security")
public class SecurityConfig {
    
    @NotBlank(message = "JWT secret is required")
    private String jwtSecret;
    
    @Min(value = 300, message = "Token expiration must be at least 5 minutes")
    @Max(value = 86400, message = "Token expiration cannot exceed 24 hours")
    private int tokenExpiration = 3600;
    
    @NotEmpty(message = "At least one allowed origin is required")
    private List<@URL String> allowedOrigins;
    
    @Email
    private String adminEmail;
    
    // Getters and setters
}

Profilspezifische Konfiguration

Spring Boot unterstützt profilspezifische Konfigurationsdateien für beide Formate:

text

src/main/resources/
├── application.yml              # Gemeinsame Konfiguration
├── application-dev.yml          # Entwicklungsumgebung
├── application-staging.yml      # Staging-Umgebung
├── application-prod.yml         # Produktionsumgebung
└── application-test.yml         # Testumgebung

yaml

# application-prod.yml
spring:
  datasource:
    hikari:
      maximum-pool-size: 20
      minimum-idle: 5
      connection-timeout: 30000

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

management:
  endpoints:
    web:
      exposure:
        include: health,info,metrics

Bereit für deine Spring Boot-Interviews?

Übe mit unseren interaktiven Simulatoren, Flashcards und technischen Tests.

Spring Boot erkunden

Häufige Interview-Fragen

Frage 1: Wann sollte YAML gegenüber Properties bevorzugt werden?

YAML eignet sich besser für komplexe, hierarchische Konfigurationen mit verschachtelten Eigenschaften, Listen und mehreren Profilen. Properties-Dateien sind vorzuziehen für einfache Konfigurationen, Legacy-Systeme oder wenn Team-Mitglieder mit YAML-Syntax nicht vertraut sind.

Frage 2: Wie werden mehrere Konfigurationsdateien geladen?

java

import org.springframework.context.annotation.Configuration;
import org.springframework.context.annotation.PropertySource;

@Configuration
@PropertySource({
    "classpath:database.properties",
    "classpath:messaging.properties"
})
public class AdditionalConfig {
}

Für YAML muss ein PropertySourceFactory verwendet werden:

java

import org.springframework.beans.factory.config.YamlPropertiesFactoryBean;
import org.springframework.core.env.PropertiesPropertySource;
import org.springframework.core.io.support.EncodedResource;
import org.springframework.core.io.support.PropertySourceFactory;

import java.util.Properties;

public class YamlPropertySourceFactory implements PropertySourceFactory {
    
    @Override
    public org.springframework.core.env.PropertySource<?> createPropertySource(
            String name, EncodedResource resource) {
        YamlPropertiesFactoryBean factory = new YamlPropertiesFactoryBean();
        factory.setResources(resource.getResource());
        Properties properties = factory.getObject();
        String sourceName = name != null ? name : resource.getResource().getFilename();
        return new PropertiesPropertySource(sourceName, properties);
    }
}

Frage 3: Was ist die Prioritätsreihenfolge der Konfigurationsquellen?

Spring Boot lädt Konfigurationen in dieser Reihenfolge (höhere überschreiben niedrigere):

Kommandozeilenargumente
SPRING_APPLICATION_JSON (inline JSON)
Servlet-Parameter
JNDI-Attribute
Java System Properties
OS-Umgebungsvariablen
Profilspezifische Dateien (application-.yml)
Anwendungskonfiguration (application.yml)
@PropertySource-Annotationen
Standardwerte

Frage 4: Wie werden Secrets sicher verwaltet?

yaml

# Verwendung von Spring Cloud Config Server oder Vault
spring:
  cloud:
    vault:
      uri: https://vault.example.com
      token: ${VAULT_TOKEN}
      kv:
        enabled: true
        backend: secret

  config:
    import:
      - vault://secret/application
      - vault://secret/database

Frage 5: Wie funktioniert Relaxed Binding?

Spring Boot unterstützt verschiedene Schreibweisen für dieselbe Eigenschaft:

yaml

# Alle diese Formen sind äquivalent
application:
  apiKey: value      # Camel Case
  api-key: value     # Kebab Case (empfohlen)
  api_key: value     # Underscore
  API_KEY: value     # Uppercase (für Umgebungsvariablen)

Best Practices für Produktionsumgebungen

yaml

# application-prod.yml mit bewährten Praktiken
spring:
  datasource:
    url: ${DATABASE_URL}
    username: ${DATABASE_USERNAME}
    password: ${DATABASE_PASSWORD}
    hikari:
      maximum-pool-size: ${DB_POOL_SIZE:10}
      leak-detection-threshold: 60000

  jpa:
    open-in-view: false
    properties:
      hibernate:
        jdbc:
          batch_size: 50
        order_inserts: true
        order_updates: true

server:
  shutdown: graceful
  tomcat:
    accept-count: 100
    max-connections: 10000
    threads:
      max: 200
      min-spare: 10

management:
  server:
    port: 8081
  endpoints:
    web:
      exposure:
        include: health,info,prometheus
  endpoint:
    health:
      show-details: when_authorized
      probes:
        enabled: true

logging:
  pattern:
    console: "%d{ISO8601} [%thread] %-5level %logger{36} - %msg%n"
  level:
    root: INFO
    org.springframework.web: WARN
    org.hibernate.SQL: WARN

Zusammenfassung

Die Wahl zwischen YAML und Properties hängt von den spezifischen Projektanforderungen ab. YAML bietet bessere Lesbarkeit und Struktur für komplexe Konfigurationen, während Properties-Dateien Einfachheit und breite Tool-Unterstützung bieten. Moderne Spring-Boot-Anwendungen tendieren zu YAML aufgrund der natürlichen Darstellung hierarchischer Daten und der Möglichkeit, mehrere Profile in einer Datei zu definieren. Unabhängig vom gewählten Format sollten sensible Daten immer über Umgebungsvariablen oder externe Konfigurationsdienste wie HashiCorp Vault oder Spring Cloud Config Server bereitgestellt werden.

Spring Boot YAML vs Properties: Konfigurationsvergleich und Interview-Fragen 2026

Grundlegende Syntaxunterschiede

Properties-Format

YAML-Format

Vorteile von YAML-Konfiguration

Listen und komplexe Datenstrukturen

Configuration Properties Binding

Umgebungsvariablen und Externalisierung

Validation mit Bean Validation

Profilspezifische Konfiguration

Bereit für deine Spring Boot-Interviews?

Häufige Interview-Fragen

Frage 1: Wann sollte YAML gegenüber Properties bevorzugt werden?

Frage 2: Wie werden mehrere Konfigurationsdateien geladen?

Frage 3: Was ist die Prioritätsreihenfolge der Konfigurationsquellen?

Frage 4: Wie werden Secrets sicher verwaltet?

Frage 5: Wie funktioniert Relaxed Binding?

Best Practices für Produktionsumgebungen

Zusammenfassung

Findest du den Bug in Spring Boot?

Verwandte Artikel

Spring Boot Interview: Transaktions-Propagation erklärt

30 Spring Boot Interviewfragen: Vollständiger Leitfaden für Java-Entwickler

Spring GraphQL Interview: Resolver, DataLoader und Lösungen für das N+1-Problem