# Spring Boot YAML vs Properties: เปรียบเทียบการตั้งค่าและคำถามสัมภาษณ์งาน 2026

> คู่มือฉบับสมบูรณ์เปรียบเทียบรูปแบบการตั้งค่า YAML และ Properties ใน Spring Boot รวมถึงแนวทางปฏิบัติที่ดีที่สุดและคำถามสัมภาษณ์ที่พบบ่อย

- 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 รองรับรูปแบบการตั้งค่าหลักสองรูปแบบ: YAML (`application.yml`) และ Properties (`application.properties`) รูปแบบทั้งสองมีจุดประสงค์เดียวกัน แต่แตกต่างกันในด้านไวยากรณ์ ความสามารถในการอ่าน และกรณีการใช้งานเฉพาะ บทความนี้วิเคราะห์ความแตกต่างในทางปฏิบัติระหว่างทั้งสองรูปแบบ และคำถามสัมภาษณ์ที่เกี่ยวข้องกับ externalized configuration ใน Spring Boot

> **คำแนะนำการเลือกอย่างรวดเร็ว**
>
> ใช้ YAML สำหรับโปรเจกต์ที่มีการตั้งค่าซ้อนกันลึกหรือมีหลาย profile ใช้ Properties สำหรับการตั้งค่าอย่างง่ายหรือเมื่อทำงานกับทีมที่ไม่คุ้นเคยกับไวยากรณ์ YAML

## เปรียบเทียบไวยากรณ์ระหว่าง YAML และ Properties

ความแตกต่างที่เห็นได้ชัดที่สุดอยู่ที่วิธีที่แต่ละรูปแบบแสดงข้อมูลแบบลำดับชั้น ไฟล์ Properties ใช้สัญกรณ์จุดในทุกบรรทัด ในขณะที่ YAML ใช้การเยื้องเพื่อแสดงโครงสร้างซ้อนกัน

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

การตั้งค่า YAML ที่เทียบเท่าจะจัดกลุ่มการตั้งค่าที่เกี่ยวข้องกันในเชิงภาพ:

```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 ลดการซ้ำซ้อนเมื่อหลาย property ใช้ prefix เดียวกัน ในไฟล์ properties `spring.datasource` ปรากฏสามครั้ง ในขณะที่ YAML ประกาศเพียงครั้งเดียว

## การจัดการ Profile ในการตั้งค่า Spring Boot

Spring Boot profile ช่วยให้สามารถตั้งค่าที่แตกต่างกันสำหรับสภาพแวดล้อม development, staging และ production ทั้งสองรูปแบบรองรับ profile แต่ YAML จัดการได้อย่างสวยงามกว่า

สำหรับไฟล์ properties จำเป็นต้องสร้างไฟล์แยกสำหรับแต่ละ 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 รองรับไวยากรณ์ multi-document ในไฟล์เดียวโดยใช้ตัวคั่น `---`:

```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 property `spring.config.activate.on-profile` แทนที่ไวยากรณ์ `spring.profiles` แบบเก่า เอกสาร Spring Boot อธิบายรายละเอียดเกี่ยวกับการเปิดใช้งาน profile

## รายการและโครงสร้างข้อมูลที่ซับซ้อน

YAML เป็นเลิศในการแสดงรายการและโครงสร้างซ้อนกัน ซึ่งสำคัญสำหรับการตั้งค่าเช่น กฎความปลอดภัย, การแมป CORS หรือ bean ที่กำหนดเอง

```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 ที่เทียบเท่าต้องใช้สัญกรณ์ดัชนี:

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

การเพิ่ม origin ใหม่ในไฟล์ YAML หมายถึงการเพิ่มเพียงบรรทัดเดียว ใน properties ทุกดัชนีที่มีอยู่ต้องคงอยู่ถูกต้อง และรายการใหม่ต้องการหมายเลขดัชนีถัดไป

## การตั้งค่าแบบ Type-Safe ด้วย @ConfigurationProperties

ทั้งสองรูปแบบทำงานเหมือนกันกับการตั้งค่า type-safe ของ Spring Boot คลาสการตั้งค่าแมป property ไปยังอ็อบเจกต์ Java ที่มี type ที่เข้มงวด

```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 และ setter
    }

    public static class Jwt {
        private String secret;
        private long expirationMs;
        // getter และ setter
    }

    // getter และ setter
}
```

เปิดใช้งานคลาสการตั้งค่าด้วย `@EnableConfigurationProperties`:

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

## การตั้งค่าตัวแปรสภาพแวดล้อม

ทั้งสองรูปแบบรองรับการแทนที่ตัวแปรสภาพแวดล้อมโดยใช้ไวยากรณ์ `${VAR_NAME}` หรือ `${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 ยังรองรับ binding ตัวแปรสภาพแวดล้อมแบบยืดหยุ่น ตัวแปรสภาพแวดล้อม `SPRING_DATASOURCE_URL` จะถูกแมปอัตโนมัติไปยัง `spring.datasource.url`

## คำถามสัมภาษณ์เกี่ยวกับการตั้งค่า Spring Boot

ต่อไปนี้คือคำถามที่พบบ่อยในการสัมภาษณ์ทางเทคนิค:

### ความแตกต่างหลักระหว่าง application.yml และ application.properties คืออะไร?

YAML ใช้การเยื้องสำหรับโครงสร้างลำดับชั้นและรองรับ multi-document ในไฟล์เดียว Properties ใช้สัญกรณ์จุดแบบแบนและต้องการไฟล์แยกสำหรับแต่ละ profile YAML อ่านง่ายกว่าสำหรับการตั้งค่าแบบซ้อนกัน ในขณะที่ Properties เรียบง่ายกว่าสำหรับการตั้งค่าแบบแบน

### Spring Boot โหลดไฟล์การตั้งค่าอย่างไร?

Spring Boot โหลดการตั้งค่าตามลำดับเฉพาะด้วยลำดับความสำคัญที่เพิ่มขึ้น:

1. ค่าเริ่มต้นที่บรรจุใน JAR
2. `application.properties` หรือ `application.yml` ที่ classpath root
3. ไฟล์ตาม profile (`application-{profile}.properties`)
4. ไฟล์การตั้งค่าภายนอกในไดเรกทอรีปัจจุบัน
5. ตัวแปรสภาพแวดล้อม
6. อาร์กิวเมนต์บรรทัดคำสั่ง

### สามารถใช้ทั้งสองพร้อมกันได้หรือไม่?

ได้ Spring Boot โหลดทั้งสองหากมีอยู่ Properties มีลำดับความสำคัญสูงกว่า YAML เมื่อ property เดียวกันถูกกำหนดในทั้งสองไฟล์ อย่างไรก็ตาม การผสมทั้งสองอาจทำให้สับสนและควรหลีกเลี่ยง

### จะ override การตั้งค่าสำหรับ testing ได้อย่างไร?

ใช้ `@TestPropertySource` หรือ `@SpringBootTest` พร้อมแอตทริบิวต์ properties:

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

หรือสร้าง `application-test.yml` ใน `src/test/resources` และเปิดใช้งานด้วย `@ActiveProfiles("test")`

### Relaxed binding คืออะไร?

Relaxed binding อนุญาตให้มีรูปแบบต่างๆ ในชื่อ property `app.databaseUrl`, `app.database-url`, `app.database_url` และ `APP_DATABASE_URL` ทั้งหมดแมปไปยัง field เดียวกัน ซึ่งทำให้การตั้งค่ายืดหยุ่นข้ามสภาพแวดล้อมต่างๆ

## ข้อพิจารณาด้านประสิทธิภาพ

การ parse YAML ต้องการไลบรารี SnakeYAML ซึ่งรวมอยู่ใน Spring Boot starter แล้ว เวลาในการ parse นานกว่า properties เล็กน้อย แต่ความแตกต่างนั้นไม่มีนัยสำคัญเนื่องจากการตั้งค่าถูก parse เฉพาะตอนเริ่มต้น

สำหรับ production ทั้งสองรูปแบบมีประสิทธิภาพ runtime เหมือนกันเนื่องจากถูกแปลงเป็นโครงสร้างภายในเดียวกันหลังจากโหลด

## แนวทางปฏิบัติที่ดีที่สุดสำหรับการเลือกรูปแบบ

พิจารณาปัจจัยต่อไปนี้:

**เลือก YAML เมื่อ:**
- โปรเจกต์มีหลาย profile ที่ต้องจัดการ
- การตั้งค่ามีโครงสร้างซ้อนกันลึก
- ทีมคุ้นเคยกับไวยากรณ์ YAML
- ต้องการรายการและอ็อบเจกต์ที่ซับซ้อน

**เลือก Properties เมื่อ:**
- การตั้งค่าส่วนใหญ่เป็นแบบแบน
- ผสานรวมกับเครื่องมือเก่าที่รองรับเฉพาะ properties
- ทีมสะดวกกับรูปแบบ key-value ง่ายๆ
- โปรเจกต์เล็กที่มีการตั้งค่าน้อย

## การย้ายระหว่างรูปแบบ

การแปลงระหว่างรูปแบบค่อนข้างตรงไปตรงมา สัญกรณ์จุดแต่ละตัวใน properties กลายเป็นระดับการเยื้องใน 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
```

IDE หลายตัวมีการแปลงอัตโนมัติ IntelliJ IDEA และ VS Code มี plugin ที่แปลงไฟล์การตั้งค่าระหว่างรูปแบบ

## ข้อผิดพลาดที่พบบ่อยที่ควรหลีกเลี่ยง

ข้อผิดพลาดบางอย่างเกิดขึ้นบ่อยเมื่อทำงานกับการตั้งค่า Spring Boot:

**ข้อผิดพลาดการเยื้อง YAML**: YAML ไวต่อช่องว่าง การผสม tab และ space ทำให้เกิดข้อผิดพลาดในการ parse

**ค่า boolean ใน YAML**: ค่าเช่น `yes`, `no`, `on`, `off` ถูกตีความเป็น boolean ใช้เครื่องหมายอัญประกาศสำหรับค่าสตริง: `enabled: "yes"`

**อักขระพิเศษใน Properties**: อักขระเช่น `=` และ `:` ในค่าต้อง escape หรือใช้เครื่องหมายอัญประกาศ

```properties
# ถูกต้อง
app.url=https\://example.com\?param\=value
# หรือใช้เครื่องหมายอัญประกาศใน YAML
```

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

## สรุป

YAML และ Properties เป็นรูปแบบการตั้งค่าที่ถูกต้องทั้งคู่ใน Spring Boot YAML ให้ความสามารถในการอ่านที่ดีกว่าสำหรับการตั้งค่าที่ซับซ้อนและการจัดการ profile ในไฟล์เดียว Properties ให้ความเรียบง่ายสำหรับการตั้งค่าแบบแบนและความเข้ากันได้ที่กว้างกว่ากับเครื่องมือต่างๆ การเลือกขึ้นอยู่กับความซับซ้อนของโปรเจกต์ ความชอบของทีม และข้อกำหนดการผสานรวม การเข้าใจทั้งสองรูปแบบช่วยให้นักพัฒนาตัดสินใจได้ถูกต้องและพร้อมสำหรับคำถามสัมภาษณ์ที่เกี่ยวข้องกับการตั้งค่า Spring Boot

---

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