Le format YAML (YAML Ain't Markup Language) est devenu le standard pour la configuration des applications Spring Boot grâce à sa structure orientée données et sa lisibilité hiérarchique supérieure au format .properties classique.

Syntaxe fondamentale

La structure YAML repose sur des règles strictes pour garantir l'intégrité des données :

• Hiérarchie par indentation : Les niveaux sont définis par des espaces (généralement deux). Bien que la spécification interdise les tabulations, la plupart des IDE modernes les convertissent automatiquement.
• Sensibilité à la casse : Les clés serveur et Serveur sont considérées comme distinctes.
• Commentaires : Utilisez le caractère # pour documenter le fichier.
• Format Clé-Valeur : La structure suit le schéma cle: valeur (l'espace après les deux-points est obligatoire).

Représentation des types de données

YAML permet de structurer divers types de données Java de manière concise.

1. Valeurs scalaires (Littéraux)

Représente les types simples comme les chaînes de caractères, les entiers, les booléens ou les dates.

actif: true
version: 1.2
nom: "Application"

2. Objets et Maps

Les ensembles de paires clé-valeur peuvent être définis de deux façons :

# Style bloc
employe:
  nom: Martin
  poste: Developpeur

# Style fluide (JSON-like)
employe: {nom: Martin, poste: Developpeur}

3. Listes et Tableaux

# Style bloc
technologies:
  - Java
  - Spring
  - Docker

# Style fluide
technologies: [Java, Spring, Docker]

Liaison entre YAML et Java

Pour exploiter ces configurations, Spring Boot utilise l'annotation @ConfigurationProperties. Voici un exemple d'implémentation avec une structure de gestion d'équipe.

Modèle Java :

@Data
@Component
@ConfigurationProperties(prefix = "equipe")
public class MembreEquipe {
    private String nomUsage;
    private Boolean estManager;
    private Date dateRecrutement;
    private Integer niveau;
    private Materiel equipementPrincipal;
    private List<String> competences;
    private Map<String, Integer> evaluations;
    private Map<String, List<Materiel>> inventaireParProjet;
}

@Data
class Materiel {
    private String modele;
    private Double valeurAchat;
}

Fichier aplpication.yaml correspondant :

equipe:
  nomUsage: "Jean Dupont"
  estManager: false
  dateRecrutement: 2022/05/15
  niveau: 3
  competences:
    - Spring Boot
    - Kubernetes
  evaluations:
    technique: 90
    communication: 85
  equipementPrincipal:
    modele: "MacBook Pro"
    valeurAchat: 2500.0
  inventaireParProjet:
    "Projet Alpha":
      - {modele: "Ecran 4K", valeurAchat: 500}
      - {modele: "Clavier", valeurAchat: 150}
    "Projet Beta":
      - modele: "Tablette"
        valeurAchat: 800

Traitement des chaînes de caractères et guillemets

Le comportement des caractères d'échappeement varie selon l'utilisation des guillemets :

• Guillemets doubles ("") : Les caractères spéciaux sont interprétés. "Ligne 1 \n Ligne 2" produira un saut de ligne réel.
• Guillemets simples ('') : Les caractères sont traités littéralement. 'Ligne 1 \n Ligne 2' affichera le texte brut avec les caractères \n.
• Sans guillemets : Le comportement est identique aux guillemets simples par défaut.

Injection et usage

Une fois le bean configuré, il peut être injecté dans n'importe quel composant Spring (comme un Controller) pour accéder aux données formatées.

@RestController
public class ConfigController {
    @Autowired
    private MembreEquipe membre;

    @GetMapping("/profil")
    public MembreEquipe getProfil() {
        return membre;
    }
}

Optimisation de l'IDE

Pour bénéficier de l'autocomplétion et de la validation des clés personnalisées dans vos fichiers YAML, il est recommandé d'ajouter le processeur de configuration de Spring Boot dans votre fichier pom.xml :

<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-configuration-processor</artifactId>
    <optional>true</optional>
</dependency>