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

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

ภาพรวม Spring Boot Properties vs YAML

บน Spring Boot 4.1 ซึ่งเป็นสายรุ่นปัจจุบัน ทั้งสองรูปแบบป้อนค่าเข้าสู่ Environment ตัวเดียวกันและ bind ค่าเหมือนกันทุกประการ ความแตกต่างอยู่ที่ไวยากรณ์ กฎการโหลดบางข้อ และสิ่งที่เกิดขึ้นเมื่อมีทั้งสองไฟล์อยู่พร้อมกัน

สองแถวสุดท้ายคือจุดที่ผู้สมัครมักมองข้าม เอกสารอ้างอิง external configuration ของ Spring Boot ระบุว่าไฟล์ YAML ไม่สามารถโหลดผ่าน @PropertySource หรือ @TestPropertySource ได้ และเมื่อ application.properties กับ application.yml อยู่ข้างกัน ค่าจาก .properties จะเป็นฝ่ายชนะ คำแนะนำอย่างเป็นทางการคือเลือกใช้รูปแบบเดียวทั้งแอปพลิเคชัน

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

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

# 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 ที่เทียบเท่าจะจัดกลุ่มการตั้งค่าที่เกี่ยวข้องกันในเชิงภาพ:

# 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 และไฟล์แบบ multi-document

แนวทางดั้งเดิมใช้หนึ่งไฟล์ต่อหนึ่ง profile:

# 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 ในไฟล์เดียวโดยใช้ตัวคั่น ---:

# 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

ไฟล์ properties รองรับโครงสร้าง multi-document แบบเดียวกัน บรรทัดที่มีเพียง #--- (หรือ !---) จะแบ่งไฟล์ออกเป็นหลาย document:

# 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

ตัวคั่นต้องไม่มีช่องว่างนำหน้าและต้องมีขีดกลางสามตัวพอดี ตั้งแต่ Spring Boot 2.4 property spring.config.activate.on-profile แทนที่ไวยากรณ์ spring.profiles แบบเก่าในทั้งสองรูปแบบ

การเปิดใช้งาน profile, profile group และ bean ที่มี @Profile มีให้ฝึกใน โมดูลสัมภาษณ์เรื่อง profile และ environment

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

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

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

# 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 ที่เข้มงวด

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

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

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

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

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

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

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

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

ลำดับความสำคัญของแหล่งการตั้งค่าใน Spring Boot เป็นอย่างไร?

Spring Boot โหลดการตั้งค่าจากหลายแหล่งตามลำดับที่กำหนดไว้ แหล่งที่มีลำดับความสำคัญสูงกว่าจะเขียนทับแหล่งที่ต่ำกว่า (ย่อมาจากรายการทางการ ซึ่งยังครอบคลุม JNDI, servlet parameter และ annotation สำหรับการทดสอบ):

1. อาร์กิวเมนต์บรรทัดคำสั่ง (--server.port=9000)
2. SPRING_APPLICATION_JSON (JSON แบบ inline ในตัวแปรสภาพแวดล้อมหรือ system property)
3. Java system properties (-Dserver.port=9000)
4. ตัวแปรสภาพแวดล้อมของระบบปฏิบัติการ (SERVER_PORT=9000)
5. ไฟล์ config data (application.yml, application.properties และไฟล์ตาม profile)
6. annotation @PropertySource
7. ค่าเริ่มต้นผ่าน SpringApplication.setDefaultProperties

ภายในขั้นที่ 5 ยังมีลำดับชั้นที่สอง: ไฟล์ตาม profile เขียนทับไฟล์ทั่วไป และไฟล์ที่อยู่นอก jar เขียนทับไฟล์ที่อยู่ใน jar ภายในตำแหน่งเดียวกัน .properties เขียนทับ .yml ผู้สมัครที่อธิบายได้ว่าทำไมค่าใน application.yml ถูกเพิกเฉยโดยไม่มีข้อความแจ้งใดๆ (เพราะมี application.properties ที่หลงเหลืออยู่ข้างกัน) แสดงให้เห็นประสบการณ์ debug จริง

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

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

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

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

@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") ไฟล์เพิ่มเติมที่โหลดผ่านแอตทริบิวต์ locations ของ @TestPropertySource ต้องเป็น .properties เพราะ annotation นี้โหลด YAML ไม่ได้

Relaxed binding คืออะไร?

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

Jasypt คืออะไร และเข้ารหัส property ของ Spring Boot อย่างไร?

Jasypt Spring Boot ถอดรหัสค่าที่ห่อด้วย ENC(...) ขณะสร้าง Environment ทำให้ secret ที่เข้ารหัสแล้วเก็บไว้ใน application.yml หรือ application.properties ได้ และยังถูก bind เหมือนค่าปกติ:

# 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 เป็น property บังคับเพียงตัวเดียว และอัลกอริทึมเริ่มต้นคือ PBEWITHHMACSHA512ANDAES_256 รูปแบบไฟล์ไม่มีผล: ค่า ENC(...) เดียวกันใช้ได้ทั้งใน YAML และ properties

คำตอบที่แยกผู้สมัครระดับ senior ออกมา: Jasypt ไม่ได้กำจัด secret แต่เพียงย้ายมันไปที่อื่น ผู้ที่ถือ master password สามารถถอดรหัสทุกค่าใน repository ได้ และการหมุนเวียน master password หมายถึงต้องเข้ารหัสทุกค่าใหม่ทั้งหมด Vault หรือ secret manager ของผู้ให้บริการคลาวด์มีการควบคุมสิทธิ์ การ audit และการหมุนเวียน secret ซึ่ง Jasypt ไม่มี

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

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

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

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

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

เลือก YAML เมื่อ:

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

เลือก Properties เมื่อ:

• การตั้งค่าส่วนใหญ่เป็นแบบแบน
• ผสานรวมกับเครื่องมือเก่าที่รองรับเฉพาะ properties
• โหลดไฟล์เพิ่มเติมผ่าน @PropertySource ซึ่งไม่รองรับ YAML
• ทีมสะดวกกับรูปแบบ key-value ง่ายๆ
• โปรเจกต์เล็กที่มีการตั้งค่าน้อย

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

การแปลงระหว่างรูปแบบค่อนข้างตรงไปตรงมา สัญกรณ์จุดแต่ละตัวใน properties กลายเป็นระดับการเยื้องใน YAML:

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

# 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 หรือใช้เครื่องหมายอัญประกาศ

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

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

แหล่งอ้างอิง

• เอกสารอ้างอิง Spring Boot: Externalized Configuration: ลำดับของ property source, ไฟล์ properties แบบ multi-document ด้วย #---, .properties มีลำดับความสำคัญเหนือ YAML, @PropertySource ไม่รองรับ YAML
• รุ่นที่เผยแพร่ของ Spring Boot: 4.1.2 คือรุ่น GA ปัจจุบัน (ตุลาคม 2026)
• README ของ Jasypt Spring Boot: ไวยากรณ์ ENC(...), อัลกอริทึมเริ่มต้น, ข้อกำหนด Spring Boot 3.5+

เลือกระหว่าง YAML และ Properties ใน Spring Boot 4.1

YAML และ Properties เป็นรูปแบบการตั้งค่าที่ถูกต้องทั้งคู่ใน Spring Boot YAML ให้ความสามารถในการอ่านที่ดีกว่าสำหรับการตั้งค่าที่ซับซ้อนและรายการ Properties ให้ความเรียบง่ายสำหรับการตั้งค่าแบบแบนและความเข้ากันได้ที่กว้างกว่ากับเครื่องมือต่างๆ ทั้งสองรูปแบบรองรับหลาย profile ในไฟล์เดียว: --- ใน YAML และ #--- ใน properties เมื่อทั้งสองไฟล์อยู่ในตำแหน่งเดียวกัน .properties จะเป็นฝ่ายชนะ และมีเพียงไฟล์ properties ที่โหลดด้วย @PropertySource ได้ ค่า ENC(...) ของ Jasypt เพียงย้าย secret ไปไว้ที่ master password การเลือกขึ้นอยู่กับความซับซ้อนของโปรเจกต์ ความชอบของทีม และข้อกำหนดการผสานรวม การเข้าใจทั้งสองรูปแบบช่วยให้นักพัฒนาตัดสินใจได้ถูกต้องและพร้อมสำหรับคำถามสัมภาษณ์ที่เกี่ยวข้องกับการตั้งค่า Spring Boot