# Spring Boot YAML vs Properties: So Sánh Cấu Hình và Câu Hỏi Phỏng Vấn 2026

> Hướng dẫn toàn diện so sánh định dạng cấu hình YAML và Properties trong Spring Boot, bao gồm các thực hành tốt nhất và câu hỏi phỏng vấn thường gặp.

- 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 hỗ trợ hai định dạng cấu hình chính: YAML (`application.yml`) và Properties (`application.properties`). Cả hai định dạng đều phục vụ cùng một mục đích, nhưng khác nhau về cú pháp, khả năng đọc và các trường hợp sử dụng cụ thể. Bài viết này phân tích sự khác biệt thực tế giữa chúng và các câu hỏi phỏng vấn liên quan đến externalized configuration trong Spring Boot.

> **Hướng Dẫn Lựa Chọn Nhanh**
>
> Sử dụng YAML cho các dự án có cấu hình lồng nhau sâu hoặc nhiều profile. Sử dụng Properties cho cấu hình đơn giản hoặc khi làm việc với team chưa quen với cú pháp YAML.

## So Sánh Cú Pháp Giữa YAML và Properties

Sự khác biệt rõ ràng nhất nằm ở cách mỗi định dạng biểu diễn dữ liệu phân cấp. File Properties sử dụng ký hiệu dấu chấm trên mỗi dòng, trong khi YAML sử dụng thụt lề để thể hiện cấu trúc lồng nhau.

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

Cấu hình YAML tương đương nhóm các thiết lập liên quan một cách trực quan:

```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 giảm sự lặp lại khi nhiều thuộc tính có chung prefix. Trong file properties, `spring.datasource` xuất hiện ba lần, trong khi YAML chỉ khai báo một lần.

## Quản Lý Profile trong Cấu Hình Spring Boot

Spring Boot profile cho phép cấu hình khác nhau cho môi trường development, staging và production. Cả hai định dạng đều hỗ trợ profile, nhưng YAML xử lý chúng một cách thanh lịch hơn.

Với file properties, cần tạo file riêng cho mỗi profile:

```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 hỗ trợ cú pháp multi-document trong một file duy nhất sử dụng dấu phân cách `---`:

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

Từ Spring Boot 2.4, thuộc tính `spring.config.activate.on-profile` thay thế cú pháp `spring.profiles` cũ. Tài liệu Spring Boot trình bày chi tiết về kích hoạt profile.

## Danh Sách và Cấu Trúc Dữ Liệu Phức Tạp

YAML vượt trội trong việc biểu diễn danh sách và cấu trúc lồng nhau. Điều này quan trọng cho các cấu hình như quy tắc bảo mật, ánh xạ CORS, hoặc bean tùy chỉnh.

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

Định dạng properties tương đương yêu cầu ký hiệu chỉ số:

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

Thêm một origin mới vào file YAML chỉ cần thêm một dòng. Với properties, mỗi chỉ số hiện có phải giữ nguyên, và mục mới cần số chỉ số tiếp theo.

## Cấu Hình Type-Safe với @ConfigurationProperties

Cả hai định dạng hoạt động giống hệt với cấu hình type-safe của Spring Boot. Lớp cấu hình ánh xạ các thuộc tính sang đối tượng Java có kiểu mạnh.

```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 và setter
    }

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

    // getter và setter
}
```

Kích hoạt lớp cấu hình với `@EnableConfigurationProperties`:

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

## Cấu Hình Biến Môi Trường

Cả hai định dạng hỗ trợ thay thế biến môi trường sử dụng cú pháp `${VAR_NAME}` hoặc `${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 cũng hỗ trợ binding biến môi trường linh hoạt. Biến môi trường `SPRING_DATASOURCE_URL` tự động ánh xạ sang `spring.datasource.url`.

## Câu Hỏi Phỏng Vấn về Cấu Hình Spring Boot

Dưới đây là các câu hỏi phổ biến trong phỏng vấn kỹ thuật:

### Sự khác biệt chính giữa application.yml và application.properties là gì?

YAML sử dụng thụt lề cho cấu trúc phân cấp và hỗ trợ multi-document trong một file. Properties sử dụng ký hiệu dấu chấm phẳng và yêu cầu file riêng cho mỗi profile. YAML dễ đọc hơn cho cấu hình lồng nhau, trong khi Properties đơn giản hơn cho thiết lập phẳng.

### Spring Boot tải file cấu hình như thế nào?

Spring Boot tải cấu hình theo thứ tự cụ thể với mức độ ưu tiên tăng dần:

1. Giá trị mặc định được đóng gói trong JAR
2. `application.properties` hoặc `application.yml` tại classpath root
3. File theo profile (`application-{profile}.properties`)
4. File cấu hình bên ngoài trong thư mục hiện tại
5. Biến môi trường
6. Tham số dòng lệnh

### Có thể sử dụng cả hai cùng lúc không?

Có, Spring Boot tải cả hai nếu tồn tại. Properties có độ ưu tiên cao hơn YAML khi cùng một thuộc tính được định nghĩa ở cả hai file. Tuy nhiên, việc kết hợp cả hai có thể gây nhầm lẫn và nên tránh.

### Làm thế nào để ghi đè cấu hình cho testing?

Sử dụng `@TestPropertySource` hoặc `@SpringBootTest` với thuộc tính properties:

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

Hoặc tạo `application-test.yml` trong `src/test/resources` và kích hoạt với `@ActiveProfiles("test")`.

### Relaxed binding là gì?

Relaxed binding cho phép các biến thể trong tên thuộc tính. `app.databaseUrl`, `app.database-url`, `app.database_url`, và `APP_DATABASE_URL` đều ánh xạ đến cùng một field. Điều này làm cho cấu hình linh hoạt qua các môi trường khác nhau.

## Cân Nhắc về Hiệu Năng

Parsing YAML yêu cầu thư viện SnakeYAML, đã được bao gồm trong Spring Boot starter. Thời gian parsing lâu hơn một chút so với properties, nhưng sự khác biệt không đáng kể vì cấu hình chỉ được phân tích khi khởi động.

Đối với production, cả hai định dạng có hiệu năng runtime giống hệt nhau vì chúng được chuyển đổi sang cùng một cấu trúc nội bộ sau khi tải.

## Thực Hành Tốt Nhất cho Việc Chọn Định Dạng

Xem xét các yếu tố sau:

**Chọn YAML khi:**
- Dự án có nhiều profile cần quản lý
- Cấu hình có cấu trúc lồng nhau sâu
- Team quen thuộc với cú pháp YAML
- Cần danh sách và đối tượng phức tạp

**Chọn Properties khi:**
- Cấu hình chủ yếu phẳng
- Tích hợp với công cụ cũ chỉ hỗ trợ properties
- Team thoải mái hơn với định dạng key-value đơn giản
- Dự án nhỏ với cấu hình tối thiểu

## Chuyển Đổi Giữa Các Định Dạng

Việc chuyển đổi giữa các định dạng khá trực tiếp. Mỗi ký hiệu dấu chấm trong properties trở thành một cấp thụt lề trong 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
```

Nhiều IDE cung cấp chuyển đổi tự động. IntelliJ IDEA và VS Code có plugin chuyển đổi file cấu hình giữa các định dạng.

## Lỗi Thường Gặp Cần Tránh

Một số lỗi thường xảy ra khi làm việc với cấu hình Spring Boot:

**Lỗi thụt lề YAML**: YAML nhạy cảm với khoảng trắng. Trộn lẫn tab và space gây ra lỗi parsing.

**Giá trị boolean trong YAML**: Các giá trị như `yes`, `no`, `on`, `off` được hiểu là boolean. Sử dụng dấu ngoặc kép cho giá trị chuỗi: `enabled: "yes"`.

**Ký tự đặc biệt trong Properties**: Các ký tự như `=` và `:` trong giá trị cần escape hoặc dấu ngoặc kép.

```properties
# Đúng
app.url=https\://example.com\?param\=value
# Hoặc sử dụng dấu ngoặc kép trong YAML
```

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

## Kết Luận

YAML và Properties đều là định dạng cấu hình hợp lệ trong Spring Boot. YAML mang lại khả năng đọc tốt hơn cho cấu hình phức tạp và quản lý profile trong một file. Properties cung cấp sự đơn giản cho thiết lập phẳng và khả năng tương thích rộng hơn với các công cụ. Việc lựa chọn phụ thuộc vào độ phức tạp của dự án, sở thích của team và yêu cầu tích hợp. Hiểu cả hai định dạng giúp developer đưa ra quyết định đúng đắn và sẵn sàng cho các câu hỏi phỏng vấn liên quan đến cấu hình Spring Boot.

---

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