# Spring Boot YAML vs Properties: Perbandingan Konfigurasi dan Pertanyaan Interview 2026

> Panduan lengkap membandingkan format konfigurasi YAML dan Properties di Spring Boot, termasuk praktik terbaik dan pertanyaan interview yang sering muncul.

- Published: 2026-08-26
- Updated: 2026-08-26
- Author: Anthony Fillion-Maillet
- Tags: spring-boot, yaml, properties, configuration, java
- Reading time: 8 min

---

Spring Boot menyediakan dua format konfigurasi utama: YAML (`application.yml`) dan Properties (`application.properties`). Kedua format ini memiliki tujuan yang sama, namun berbeda dalam sintaks, keterbacaan, dan kasus penggunaan tertentu. Artikel ini membahas perbedaan praktis antara keduanya serta pertanyaan interview yang sering muncul terkait externalized configuration di Spring Boot.

> **Panduan Pemilihan Cepat**
>
> Gunakan YAML untuk proyek dengan konfigurasi bersarang dalam atau profil ganda. Gunakan Properties untuk konfigurasi sederhana atau ketika bekerja dengan tim yang belum familiar dengan sintaks YAML.

## Perbandingan Sintaks YAML dan Properties

Perbedaan paling mencolok terletak pada cara masing-masing format merepresentasikan data hierarkis. File Properties menggunakan notasi titik pada setiap baris, sedangkan YAML menggunakan indentasi untuk menunjukkan tingkatan.

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

Konfigurasi YAML yang setara mengelompokkan pengaturan terkait secara visual:

```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 mengurangi pengulangan ketika beberapa properti berbagi prefix yang sama. Dalam file properties, `spring.datasource` muncul tiga kali, sementara YAML mendeklarasikannya hanya sekali.

## Manajemen Profil dalam Konfigurasi Spring Boot

Profil Spring Boot memungkinkan konfigurasi berbeda untuk lingkungan development, staging, dan production. Kedua format mendukung profil, namun YAML menanganinya dengan lebih elegan.

Dengan file properties, diperlukan file terpisah untuk setiap profil:

```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 mendukung sintaks multi-dokumen dalam satu file menggunakan pemisah `---`:

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

Sejak Spring Boot 2.4, properti `spring.config.activate.on-profile` menggantikan sintaks `spring.profiles` yang lama. Dokumentasi Spring Boot mencakup aktivasi profil secara detail.

## Daftar dan Struktur Data Kompleks

YAML unggul dalam merepresentasikan daftar dan struktur bersarang. Hal ini penting untuk konfigurasi seperti aturan keamanan, mapping CORS, atau bean kustom.

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

Format properties yang setara memerlukan notasi indeks:

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

Menambahkan origin baru ke file YAML berarti menambahkan satu baris. Pada properties, setiap indeks yang ada harus tetap benar, dan entri baru memerlukan nomor indeks berikutnya.

## Konfigurasi Type-Safe dengan @ConfigurationProperties

Kedua format bekerja identik dengan konfigurasi type-safe milik Spring Boot. Kelas konfigurasi memetakan properti ke objek Java yang strongly-typed.

```java
@ConfigurationProperties(prefix = "app.security")
public class SecurityProperties {
    private List<String> allowedOrigins = new ArrayList<>();
    private Cors cors = new Cors();
    private Jwt jwt = new Jwt();

    public static class Cors {
        private List<String> allowedMethods = new ArrayList<>();
        // getter dan setter
    }

    public static class Jwt {
        private String secret;
        private long expirationMs;
        // getter dan setter
    }

    // getter dan setter
}
```

Aktifkan kelas konfigurasi dengan `@EnableConfigurationProperties`:

```java
@SpringBootApplication
@EnableConfigurationProperties(SecurityProperties.class)
public class Application {
    public static void main(String[] args) {
        SpringApplication.run(Application.class, args);
    }
}
```

## Konfigurasi Environment Variable

Kedua format mendukung substitusi environment variable menggunakan sintaks `${VAR_NAME}` atau `${VAR_NAME:default}`.

```yaml
# application.yml
spring:
  datasource:
    url: ${DATABASE_URL:jdbc:postgresql://localhost:5432/devdb}
    username: ${DATABASE_USER:postgres}
    password: ${DATABASE_PASSWORD}
```

```properties
# application.properties
spring.datasource.url=${DATABASE_URL:jdbc:postgresql://localhost:5432/devdb}
spring.datasource.username=${DATABASE_USER:postgres}
spring.datasource.password=${DATABASE_PASSWORD}
```

Spring Boot juga mendukung binding environment variable yang santai. Environment variable `SPRING_DATASOURCE_URL` secara otomatis dipetakan ke `spring.datasource.url`.

## Pertanyaan Interview tentang Konfigurasi Spring Boot

Berikut adalah pertanyaan umum yang muncul dalam interview teknis:

### Apa perbedaan utama antara application.yml dan application.properties?

YAML menggunakan indentasi untuk hierarki dan mendukung multi-dokumen dalam satu file. Properties menggunakan notasi titik flat dan memerlukan file terpisah untuk setiap profil. YAML lebih mudah dibaca untuk konfigurasi bersarang, sementara Properties lebih sederhana untuk pengaturan datar.

### Bagaimana Spring Boot memuat file konfigurasi?

Spring Boot memuat konfigurasi dalam urutan tertentu dengan prioritas yang meningkat:

1. Default aplikasi yang dikemas di dalam JAR
2. `application.properties` atau `application.yml` di classpath root
3. File khusus profil (`application-{profile}.properties`)
4. File konfigurasi eksternal di direktori saat ini
5. Environment variable
6. Argumen command line

### Bisakah keduanya digunakan bersamaan?

Ya, Spring Boot memuat keduanya jika ada. Properties memiliki prioritas lebih tinggi daripada YAML ketika properti yang sama didefinisikan di kedua file. Namun, mencampur keduanya dapat menyebabkan kebingungan dan harus dihindari.

### Bagaimana cara mengganti konfigurasi untuk testing?

Gunakan `@TestPropertySource` atau `@SpringBootTest` dengan atribut properties:

```java
@SpringBootTest
@TestPropertySource(properties = {
    "spring.datasource.url=jdbc:h2:mem:testdb",
    "app.feature.enabled=false"
})
class ApplicationTests {
    // test
}
```

Atau buat `application-test.yml` di `src/test/resources` dan aktifkan dengan `@ActiveProfiles("test")`.

### Apa itu relaxed binding?

Relaxed binding memungkinkan variasi dalam nama properti. `app.databaseUrl`, `app.database-url`, `app.database_url`, dan `APP_DATABASE_URL` semuanya dipetakan ke field yang sama. Ini membuat konfigurasi fleksibel di berbagai lingkungan.

## Pertimbangan Performa

Parsing YAML memerlukan library SnakeYAML, yang sudah disertakan dalam Spring Boot starter. Waktu parsing sedikit lebih lama dibandingkan properties, namun perbedaannya diabaikan karena konfigurasi hanya diurai saat startup.

Untuk produksi, kedua format memiliki performa runtime yang identik karena keduanya dikonversi ke struktur internal yang sama setelah dimuat.

## Praktik Terbaik untuk Pemilihan Format

Pertimbangkan faktor-faktor berikut:

**Pilih YAML ketika:**
- Proyek memiliki banyak profil yang dikelola
- Konfigurasi memiliki struktur bersarang dalam
- Tim familiar dengan sintaks YAML
- Daftar dan objek kompleks diperlukan

**Pilih Properties ketika:**
- Konfigurasi mayoritas datar
- Integrasi dengan tooling lama yang hanya mendukung properties
- Tim lebih nyaman dengan format key-value sederhana
- Proyek kecil dengan konfigurasi minimal

## Migrasi Antar Format

Konversi antara format bersifat langsung. Setiap notasi titik di properties menjadi tingkat indentasi di YAML:

```properties
# Properties
spring.application.name=myapp
spring.datasource.hikari.maximum-pool-size=10
```

```yaml
# YAML
spring:
  application:
    name: myapp
  datasource:
    hikari:
      maximum-pool-size: 10
```

Banyak IDE menyediakan konversi otomatis. IntelliJ IDEA dan VS Code memiliki plugin yang mengkonversi file konfigurasi antar format.

## Kesalahan Umum yang Harus Dihindari

Beberapa kesalahan sering terjadi saat bekerja dengan konfigurasi Spring Boot:

**Kesalahan indentasi YAML**: YAML sensitif terhadap spasi. Pencampuran tab dan spasi menyebabkan kesalahan parsing.

**Nilai boolean di YAML**: Nilai seperti `yes`, `no`, `on`, `off` ditafsirkan sebagai boolean. Gunakan tanda kutip untuk nilai string: `enabled: "yes"`.

**Karakter khusus di Properties**: Karakter seperti `=` dan `:` dalam nilai memerlukan escaping atau tanda kutip.

```properties
# Benar
app.url=https\://example.com\?param\=value
# Atau gunakan tanda kutip di YAML
```

```yaml
app:
  url: "https://example.com?param=value"
```

## Kesimpulan

YAML dan Properties sama-sama merupakan format konfigurasi yang valid di Spring Boot. YAML menawarkan keterbacaan lebih baik untuk konfigurasi kompleks dan manajemen profil dalam satu file. Properties menyediakan kesederhanaan untuk pengaturan datar dan kompatibilitas lebih luas dengan tooling. Pemilihan bergantung pada kompleksitas proyek, preferensi tim, dan persyaratan integrasi. Memahami kedua format membantu developer membuat keputusan yang tepat dan siap menghadapi pertanyaan interview terkait konfigurasi Spring Boot.

---

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