Properties ↔ YAML Converter

Un outil pour convertir les fichiers application.properties et application.yml de Spring Boot. Essentiel pour la migration et le refactoring des fichiers de configuration !

📄 Properties → YAML

Input (Properties):

Output (YAML):

Output will appear here...

💡 Spring Boot Configuration Tips

Properties 장점:

• 간단하고 직관적
• 한 줄에 하나의 설정
• 검색하기 쉬움

YAML 장점:

• 계층 구조가 명확
• 중복 줄임
• 가독성 좋음

주의사항:

• YAML은 들여쓰기에 민감 (스페이스만 사용)
• Properties는 특수문자 이스케이프 필요
• Profile별 파일 분리 권장

Properties vs YAML

Format Properties

spring.datasource.url=jdbc:mysql://localhost:3306/mydb
spring.datasource.username=root
spring.datasource.password=secret
server.port=8080

Format YAML

spring:
  datasource:
    url: jdbc:mysql://localhost:3306/mydb
    username: root
    password: secret
server:
  port: 8080

Quand l'utiliser ?

Conversion Properties → YAML

• Lors de la migration de projets vers YAML
• Quand vous voulez voir clairement la structure hiérarchique
• Quand vous voulez réduire les préfixes dupliqués
• Quand vous voulez améliorer la lisibilité

Conversion YAML → Properties

• Compatibilité avec les systèmes hérités
• Préférence pour une configuration simple
• Recherche et grep plus faciles
• Meilleure auto-complétion IDE

Exemples pratiques

Configuration de base de données

Properties:

# Database Configuration
spring.datasource.url=jdbc:mysql://localhost:3306/mydb
spring.datasource.username=root
spring.datasource.password=secret123
spring.datasource.driver-class-name=com.mysql.cj.jdbc.Driver
spring.jpa.hibernate.ddl-auto=update
spring.jpa.show-sql=true

YAML:

# Database Configuration
spring:
  datasource:
    url: jdbc:mysql://localhost:3306/mydb
    username: root
    password: secret123
    driver-class-name: com.mysql.cj.jdbc.Driver
  jpa:
    hibernate:
      ddl-auto: update
    show-sql: true

Configuration serveur & logging

Properties:

server.port=8080
server.servlet.context-path=/api
server.compression.enabled=true

logging.level.root=INFO
logging.level.com.example=DEBUG
logging.file.name=logs/application.log
logging.pattern.console=%d{yyyy-MM-dd HH:mm:ss} - %msg%n

YAML:

server:
  port: 8080
  servlet:
    context-path: /api
  compression:
    enabled: true

logging:
  level:
    root: INFO
    com.example: DEBUG
  file:
    name: logs/application.log
  pattern:
    console: '%d{yyyy-MM-dd HH:mm:ss} - %msg%n'

Propriétés complexes

Properties:

spring.kafka.bootstrap-servers=localhost:9092
spring.kafka.consumer.group-id=my-group
spring.kafka.consumer.auto-offset-reset=earliest
spring.kafka.consumer.key-deserializer=org.apache.kafka.common.serialization.StringDeserializer
spring.kafka.consumer.value-deserializer=org.apache.kafka.common.serialization.StringDeserializer

YAML:

spring:
  kafka:
    bootstrap-servers: localhost:9092
    consumer:
      group-id: my-group
      auto-offset-reset: earliest
      key-deserializer: org.apache.kafka.common.serialization.StringDeserializer
      value-deserializer: org.apache.kafka.common.serialization.StringDeserializer

Comparaison Properties vs YAML

✅ Avantages de Properties

1. Simplicité: Un paramètre par ligne
2. Recherche facile: Facile à trouver avec grep
3. Familiarité: Ancien standard Java
4. Caractères spéciaux: Facile à échapper

✅ Avantages de YAML

1. Lisibilité: Structure hiérarchique claire
2. Réduction de duplication: Préfixes communs omis
3. Commentaires: Commentaires plus flexibles
4. Listes: Peut exprimer des tableaux

⚠️ Inconvénients de Properties

• Beaucoup de duplication
• Difficile de comprendre la structure hiérarchique
• Les configurations complexes deviennent longues

⚠️ Inconvénients de YAML

• Sensible à l'indentation
• Impossible d'utiliser des tabulations (espaces uniquement)
• Difficile de déboguer les erreurs d'analyse

Différences dans Spring Boot

Utilisation des profils

Properties:

# application.properties (commun)
app.name=MyApp

# application-dev.properties (développement)
spring.datasource.url=jdbc:mysql://localhost:3306/dev_db

# application-prod.properties (production)
spring.datasource.url=jdbc:mysql://prod-server:3306/prod_db

YAML (séparation des profils dans un fichier):

app:
  name: MyApp

---
spring:
  config:
    activate:
      on-profile: dev
  datasource:
    url: jdbc:mysql://localhost:3306/dev_db

---
spring:
  config:
    activate:
      on-profile: prod
  datasource:
    url: jdbc:mysql://prod-server:3306/prod_db

Expression de liste/tableau

Properties (utilisation d'index):

app.servers[0]=server1.example.com
app.servers[1]=server2.example.com
app.servers[2]=server3.example.com

YAML (tableau natif):

app:
  servers:
    - server1.example.com
    - server2.example.com
    - server3.example.com

Structure Map

Properties:

app.config.key1=value1
app.config.key2=value2
app.config.key3=value3

YAML:

app:
  config:
    key1: value1
    key2: value2
    key3: value3

Conseils d'utilisation

1. Migration progressive

# 1. Sauvegarder les properties existantes
cp application.properties application.properties.bak

# 2. Convertir en YAML
# (Utilisez cet outil)

# 3. Créer application.yml

# 4. Supprimer les properties après les tests

2. Séparation des profils

# application.yml (paramètres communs uniquement)
app:
  name: MyApp

# application-dev.yml (environnement de développement)
# application-prod.yml (environnement de production)

3. Variables d'environnement pour les informations sensibles

spring:
  datasource:
    password: ${DB_PASSWORD}  # Utiliser une variable d'environnement

4. Utiliser les plugins IDE

• IntelliJ IDEA: Support Spring Boot
• VS Code: Spring Boot Extension Pack
• Utiliser les fonctionnalités d'auto-complétion et de validation

Précautions

Lors de l'écriture de YAML

# ❌ Mauvais exemple (utilisation de tabulation)
spring:
	datasource:  # Utilisation de tabulation - Erreur!

# ✅ Bon exemple (utilisation d'espaces)
spring:
  datasource:  # 2 espaces

Traitement des caractères spéciaux

Properties:

# Échapper les caractères spéciaux avec un backslash
app.message=Hello\nWorld
app.path=C:\\Users\\Example

YAML:

# Entourer de guillemets
app:
  message: "Hello\nWorld"
  path: "C:\\Users\\Example"

Nombres et booléens

Properties:

server.port=8080
app.enabled=true

YAML (conversion de type automatique):

server:
  port: 8080        # Reconnu comme nombre
  port: "8080"      # Maintenu comme chaîne
app:
  enabled: true     # boolean
  enabled: "true"   # chaîne

Dépannage

Erreurs après conversion

1. Vérifier l'indentation YAML

   • Utiliser 2 espaces
   • Vérifier l'absence de caractères de tabulation

2. Vérifier les caractères spéciaux

   • Entourer :, #, @, etc. de guillemets

3. Vérifier les types

   • Vérifier que les nombres et booléens sont convertis comme prévu

4. Vérifier les paramètres de profil

   • Configuration spring.profiles.active

Outils connexes

• JSON Formatter - Formatage JSON
• CSV JSON Converter - Conversion CSV-JSON
• Text Diff - Comparer les fichiers de configuration

Ressources supplémentaires

• Spring Boot Documentation - Externalized Configuration
• YAML Specification
• Properties File Format

Meilleures pratiques

1. Séparer par environnement

application.yml          # Paramètres communs
application-dev.yml      # Environnement de développement
application-test.yml     # Environnement de test
application-prod.yml     # Environnement de production

2. Externaliser les informations sensibles

spring:
  datasource:
    password: ${DB_PASSWORD:defaultPassword}

3. Utiliser les commentaires

# Database Configuration
# Configuration séparée nécessaire en environnement de production
spring:
  datasource:
    url: jdbc:mysql://localhost:3306/mydb

4. Nommage cohérent

# Kebab case recommandé
spring:
  data-source:  # ✅
    driver-class-name: ...

# Éviter le camel case
spring:
  dataSource:  # ❌
    driverClassName: ...