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

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. Perbandingan berikut menguraikan perbedaan praktis keduanya serta pertanyaan interview yang sering muncul terkait externalized configuration di Spring Boot.

Spring Boot Properties vs YAML Secara Ringkas

Di Spring Boot 4.1, lini rilis yang berlaku saat ini, kedua format mengisi Environment yang sama dan di-bind dengan cara yang identik. Perbedaannya terletak pada sintaks, beberapa aturan pemuatan, dan perilaku ketika kedua file ada bersamaan.

Dua baris terakhir paling sering terlewat oleh kandidat. Referensi external configuration Spring Boot menyatakan bahwa file YAML tidak dapat dimuat melalui @PropertySource maupun @TestPropertySource, dan ketika application.properties dan application.yml berada berdampingan, nilai dari .properties yang menang. Rekomendasi resminya adalah memilih satu format untuk seluruh aplikasi.

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.

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

# 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 file khusus profil maupun file multi-dokumen.

Pendekatan klasik menggunakan satu file per profil:

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

# 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

File properties mendukung tata letak multi-dokumen yang sama. Baris yang hanya berisi #--- (atau !---) memecah file menjadi beberapa dokumen:

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

Pemisah tersebut tidak boleh diawali spasi dan harus terdiri dari tepat tiga tanda hubung. Sejak Spring Boot 2.4, properti spring.config.activate.on-profile menggantikan sintaks spring.profiles yang lama, di kedua format.

Aktivasi profil, profile group, dan bean @Profile dilatih dalam modul interview profil dan environment.

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.

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

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

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

@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}.

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

# 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. Latihan soal tambahan seputar file ini tersedia di modul interview application.properties dan YAML.

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, sedangkan Properties menggunakan notasi titik yang datar. Keduanya mendukung beberapa profil dalam satu file: --- di YAML, #--- di properties. YAML lebih mudah dibaca untuk konfigurasi bersarang, sementara Properties lebih sederhana untuk pengaturan datar dan menjadi satu-satunya format yang dapat dimuat dengan @PropertySource.

Bagaimana urutan prioritas sumber konfigurasi di Spring Boot?

Spring Boot memuat konfigurasi dari banyak sumber dalam urutan tertentu. Sumber dengan prioritas lebih tinggi menimpa sumber yang lebih rendah (versi ringkas dari daftar resmi, yang juga mencakup JNDI, parameter servlet, dan anotasi test):

1. Argumen command line (--server.port=9000)
2. SPRING_APPLICATION_JSON (JSON inline dalam environment variable atau system property)
3. Java system properties (-Dserver.port=9000)
4. Environment variable OS (SERVER_PORT=9000)
5. File config data (application.yml, application.properties, beserta varian profilnya)
6. Anotasi @PropertySource
7. Properti default melalui SpringApplication.setDefaultProperties

Di dalam langkah 5 berlaku urutan kedua: file khusus profil menimpa file generik, dan file di luar jar yang dikemas menimpa file di dalamnya. Dalam satu lokasi yang sama, .properties menimpa .yml. Kandidat yang mampu menjelaskan mengapa nilai di application.yml diabaikan tanpa pesan apa pun (ada application.properties sisa di sebelahnya) menunjukkan pengalaman debugging yang nyata.

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, sehingga dokumentasi resmi merekomendasikan satu format untuk seluruh aplikasi.

Bagaimana cara mengganti konfigurasi untuk testing?

Gunakan @TestPropertySource atau @SpringBootTest dengan atribut properties:

@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"). File tambahan yang dimuat lewat atribut locations dari @TestPropertySource harus berformat .properties, karena anotasi ini tidak dapat memuat YAML.

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.

Apa itu Jasypt dan bagaimana Jasypt mengenkripsi properti Spring Boot?

Jasypt Spring Boot mendekripsi nilai yang dibungkus ENC(...) saat Environment dibangun, sehingga secret terenkripsi dapat disimpan di application.yml atau application.properties dan tetap di-bind seperti nilai biasa:

# application.properties
spring.datasource.password=ENC(nrmZtkF7T0kjG/VodDvBw93Ct8EgjCA+)

# The master password is supplied at runtime, never committed
java -Djasypt.encryptor.password=$JASYPT_MASTER_KEY -jar app.jar

jasypt.encryptor.password adalah satu-satunya properti wajib, dan algoritma default-nya adalah PBEWITHHMACSHA512ANDAES_256. Format file tidak berpengaruh: nilai ENC(...) yang sama berfungsi di YAML maupun properties.

Jawaban yang membedakan kandidat senior: Jasypt tidak menghilangkan secret, melainkan memindahkannya. Siapa pun yang memegang master password dapat mendekripsi setiap nilai di repository, dan rotasi berarti mengenkripsi ulang semuanya. Vault atau secret manager dari penyedia cloud menyediakan kontrol akses, audit, dan rotasi, yang tidak dimiliki Jasypt.

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
• File tambahan dimuat melalui @PropertySource, yang tidak mendukung YAML
• 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
spring.application.name=myapp
spring.datasource.hikari.maximum-pool-size=10

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

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

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

Sumber

• Referensi Spring Boot: Externalized Configuration: urutan property source, file properties multi-dokumen dengan #---, prioritas .properties atas YAML, YAML tidak didukung @PropertySource
• Rilis Spring Boot: 4.1.2 adalah rilis GA terbaru (Oktober 2026)
• README Jasypt Spring Boot: sintaks ENC(...), algoritma default, persyaratan Spring Boot 3.5+

Memilih antara YAML dan Properties di Spring Boot 4.1

YAML dan Properties sama-sama merupakan format konfigurasi yang valid di Spring Boot. YAML menawarkan keterbacaan lebih baik untuk konfigurasi kompleks dan daftar. Properties menyediakan kesederhanaan untuk pengaturan datar dan kompatibilitas lebih luas dengan tooling. Kedua format mendukung beberapa profil dalam satu file: --- di YAML, #--- di properties. Jika kedua file berada di lokasi yang sama, .properties yang menang, dan hanya file properties yang dapat dimuat dengan @PropertySource. Nilai ENC(...) dari Jasypt hanya memindahkan secret ke master password. 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.