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

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

เปรียบเทียบไวยากรณ์ระหว่าง 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 แต่ YAML จัดการได้อย่างสวยงามกว่า

สำหรับไฟล์ properties จำเป็นต้องสร้างไฟล์แยกสำหรับแต่ละ 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

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

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

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

คำถามสัมภาษณ์เกี่ยวกับการตั้งค่า 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:

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

สรุป

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