# Spring Boot YAML vs Properties: Yapılandırma Karşılaştırması ve Mülakat Soruları 2026

> Spring Boot'ta YAML ve Properties yapılandırma formatlarının kapsamlı karşılaştırması. Sözdizimi, profil yönetimi, veri yapıları ve sık sorulan mülakat sorularının incelenmesi.

- Published: 2026-08-26
- Updated: 2026-08-26
- Author: Anthony Fillion-Maillet
- Tags: spring-boot, yapılandırma, yaml, properties, mülakat
- Reading time: 9 min

---

Spring Boot iki yapılandırma formatını destekler: YAML (`application.yml`) ve Properties (`application.properties`). Her ikisi de aynı amaca hizmet eder, ancak sözdizimi, okunabilirlik ve belirli kullanım senaryolarında farklılık gösterir. Bu karşılaştırma, pratik farklılıkları analiz eder ve Spring Boot harici yapılandırma konusunda mülakatlarda karşılaşılan soruları ele alır.

> **Hızlı Karar Rehberi**
>
> Derin iç içe yapılandırma veya birden fazla profil içeren projeler için YAML tercih edilmelidir. Basit düz yapılandırmalar veya YAML sözdizimine aşina olmayan ekiplerle çalışırken Properties kullanılmalıdır.

## YAML ve Properties Arasındaki Sözdizimi Karşılaştırması

En belirgin fark, her formatın hiyerarşik veriyi nasıl temsil ettiğidir. Properties dosyaları her satırda nokta gösterimi kullanırken, YAML iç içe geçmeyi ifade etmek için girintileme kullanır.

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

Eşdeğer YAML yapılandırması ilgili ayarları görsel olarak gruplar:

```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, birden fazla özellik aynı öneki paylaştığında tekrarı azaltır. Properties dosyasında `spring.datasource` üç kez görünürken, YAML bunu bir kez tanımlar.

## Spring Boot Yapılandırmasında Profil Yönetimi

Spring Boot profilleri, geliştirme, staging ve üretim ortamları için farklı yapılandırmalar sağlar. Her iki format da profilleri destekler, ancak YAML bunları daha zarif bir şekilde yönetir.

Properties dosyalarında her profil için ayrı dosyalar gerekir:

```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, `---` ayırıcısını kullanarak tek bir dosya içinde çoklu belge sözdizimini destekler:

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

Spring Boot 2.4'ten itibaren `spring.config.activate.on-profile` özelliği eski `spring.profiles` sözdiziminin yerini aldı. [Spring Boot dokümantasyonu](https://docs.spring.io/spring-boot/reference/features/external-config.html) profil aktivasyonunu detaylı olarak açıklar.

## Listeler ve Karmaşık Veri Yapıları

YAML, listeleri ve iç içe yapıları temsil etmede mükemmeldir. Bu durum güvenlik kuralları, CORS eşlemeleri veya özel bean yapılandırmaları için önem taşır.

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

Properties eşdeğeri indeks gösterimi gerektirir:

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

YAML dosyasına yeni bir origin eklemek bir satır eklemek anlamına gelir. Properties'te her mevcut indeks doğru kalmalı ve yeni giriş sıradaki indeks numarasını gerektirir.

## @ConfigurationProperties ile Tür Güvenli Yapılandırma

Spring Boot 3.4, yapılandırma değerlerini `@ConfigurationProperties` aracılığıyla Java sınıflarına bağlar. Her iki format da bu anotasyon ile aynı şekilde çalışır.

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

Spring Boot esnek bağlama, farklı adlandırma kuralları arasında otomatik olarak dönüştürme yapar. `app.security.allowed-origins` özelliği, kaynağın YAML veya properties olmasından bağımsız olarak `allowedOrigins`'e bağlanır.

```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;
    }
    
    // securityProperties.cors().allowedMethods() kullanan CORS yapılandırması
}
```

Spring Security yapılandırma kalıpları hakkında daha fazla bilgi için [Spring Security temelleri modülüne](/technologies/spring-boot/interview-questions/spring-security-basics) bakılabilir.

## Spring Boot Yapılandırması Hakkında Yaygın Mülakat Soruları

Yapılandırma, [Spring Boot mülakatlarında](/technologies/spring-boot) sık karşılaşılan bir konudur. Mülakatçılar harici yapılandırma, ortama özgü ayarlar ve özellik bağlama anlayışını değerlendirir.

### Soru: Yapılandırma kaynaklarının öncelik sırası nedir?

Spring Boot, yapılandırmayı belirli bir sırada birden fazla kaynaktan yükler. Daha yüksek öncelikli kaynaklar düşük öncelikli olanları geçersiz kılar:

1. Komut satırı argümanları (`--server.port=9000`)
2. Java sistem özellikleri (`-Dserver.port=9000`)
3. İşletim sistemi ortam değişkenleri (`SERVER_PORT=9000`)
4. Profile özgü özellikler (`application-{profile}.yml`)
5. Uygulama özellikleri (`application.yml` veya `application.properties`)
6. `@PropertySource` anotasyonları
7. `SpringApplication.setDefaultProperties` ile varsayılan özellikler

Bu sıralamayı bilen bir aday, Spring Boot'un çakışan değerleri nasıl çözdüğünü anladığını gösterir.

### Soru: YAML yerine properties ne zaman tercih edilmelidir?

Properties dosyalarının belirli durumlarda avantajları vardır:

- **IDE desteği**: Bazı eski IDE'ler `.properties` dosyaları için daha iyi otomatik tamamlama sağlar
- **Ekip aşinalığı**: Properties sözdizimi Spring Boot'a yeni başlayan geliştiriciler için daha basittir
- **Tek satırlık değerler**: İç içe geçme olmayan düz yapılandırmalar YAML'dan bir şey kazanmaz
- **Derleme aracı entegrasyonu**: Maven ve Gradle kaynak filtreleme doğrudan properties ile çalışır

YAML şu durumlarda daha iyi çalışır:

- Yapılandırma derin iç içe geçme içeriyorsa (üç veya daha fazla seviye)
- Birden fazla profil tek bir dosyada bulunacaksa
- Listeler sık değişiklik gerektiriyorsa
- Karmaşık yapılandırmalarda okunabilirlik önemliyse

### Soru: Hassas yapılandırma değerleri nasıl yönetilir?

Gizli bilgiler asla versiyon kontrolüne commit edilmemelidir. Spring Boot birkaç yaklaşım sunar:

```yaml
# application.yml - ortam değişkenine referans
spring:
  datasource:
    password: ${DB_PASSWORD}
```

Üretim sistemleri için Spring Cloud Config Server veya HashiCorp Vault merkezi gizli bilgi yönetimi sağlar. [Actuator izleme rehberi](/blog/spring-boot/spring-boot-actuator-monitoring-micrometer-prometheus) hassas uç noktaların güvenliğini ele alır.

## Spring Boot 3.4'te Yapılandırma Doğrulama

Spring Boot, `@ConfigurationProperties` sınıflarını Jakarta Bean Validation anotasyonları ile birleştirildiğinde başlangıçta doğrular.

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

`app.database.pool-size` eksik veya negatifse, uygulama başlangıçta net bir hata mesajı ile hızlı bir şekilde başarısız olur. Bu doğrulama YAML ve properties kaynakları için aynı şekilde çalışır.

## Ortama Özgü Yapılandırma Dosyaları

Spring Boot 3.4, varsayılan `src/main/resources` dışında ek yapılandırma dosyası konumlarını destekler. `spring.config.import` özelliği harici dosyaları yükler:

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

`optional:` öneki, dosya mevcut olmadığında başlangıç hatasını önler. Bu kalıp, üretim merkezi bir sunucudan yapılandırma çekerken varsayılan değerlerle yerel geliştirmeyi mümkün kılar.

| Özellik | YAML | Properties |
|---------|------|------------|
| İç içe yapılandırma | Doğal hiyerarşi | Nokta gösterimi |
| Tek dosyada çoklu profil | `---` ile desteklenir | Ayrı dosyalar gerektirir |
| Liste sözdizimi | Doğal YAML dizileri | İndeks gösterimi `[0]`, `[1]` |
| Yorumlar | Herhangi bir satırda `#` | Herhangi bir satırda `#` veya `!` |
| IDE otomatik tamamlama | IntelliJ, VS Code'da iyi | Tüm IDE'lerde mükemmel |
| Öğrenme eğrisi | YAML bilgisi gerektirir | Minimal |

## Spring Boot Yapılandırması için Temel Çıkarımlar

- YAML, paylaşılan öneklere sahip yapılandırmalar için tekrarı azaltır ve listeleri daha temiz bir şekilde yönetir
- Properties dosyaları düz yapılandırmalar ve YAML sözdizimine daha az aşina ekipler için iyi çalışır
- Spring Boot 3.4, `@ConfigurationProperties` bağlama ve doğrulama için her iki formatı eşit şekilde ele alır
- YAML'de profil yönetimi ilgili ortamları tek bir dosyada tutar ve dosya dağılmasını azaltır
- Yapılandırma önceliği belirli bir sıra izler: komut satırı argümanları ortam değişkenlerini, onlar da dosya tabanlı yapılandırmayı geçersiz kılar
- Hassas değerler ortam değişkenlerinde veya gizli bilgi yönetim sistemlerinde bulunmalı, asla versiyon kontrolündeki dosyalarda olmamalıdır
- Üretim ortamlarında harici kaynaklardan yapılandırma yüklemek için `spring.config.import` kullanılmalıdır

---

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