Configuration des applications Kotlin : bibliothèques, approches et outils

Configuration des applications Kotlin : aperçu des bibliothèques et outils

La configuration est l'une des tâches clés lors du développement d'applications modernes. Une gestion correctement organisée des paramètres permet d'adapter facilement l'application à différents environnements (développement, test, production), simplifie le déploiement et améliore la sécurité (par exemple, en évitant de stocker les secrets dans le code). Dans l'écosystème Kotlin, il existe plusieurs approches et bibliothèques populaires pour résoudre ce problème. Dans cet article, nous examinerons les principaux outils, leurs avantages et des exemples d'utilisation.

1. Typesafe Config (HOCON)

HOCON (Human-Optimized Config Object Notation) est un format de fichiers de configuration et une bibliothèque développée pour la plateforme JVM. Elle est largement utilisée dans les projets Kotlin, notamment en combinaison avec des frameworks comme Akka, Play Framework ou Lagom. Principaux avantages : syntaxe concise, prise en charge de l'héritage, des références à d'autres valeurs et de l'inclusion de fichiers.

Installation

// build.gradle.ktsimplementation("com.typesafe:config:1.4.3")

Exemple de fichier de configuration (application.conf)

app {  name = "MyKotlinApp"  version = "1.0.0"  server {    host = "localhost"    port = 8080  }  database {    url = "jdbc:postgresql://${app.server.host}:5432/mydb"    user = "admin"    password = ${?DB_PASSWORD} // substitution depuis la variable d'environnement  }}

Lecture de la configuration en Kotlin

import com.typesafe.config.ConfigFactory

fun main() {    val config = ConfigFactory.load()    val appName = config.getString("app.name")    val port = config.getInt("app.server.port")    val dbUrl = config.getString("app.database.url")    println("App: $appName, Port: $port, DB URL: $dbUrl")}

La bibliothèque charge automatiquement application.conf depuis le classpath et prend en charge la redéfinition des paramètres via les variables d'environnement ou les paramètres JVM.

2. Koin — configuration via l'injection de dépendances

Koin est un framework DI léger pour Kotlin, qui peut également être utilisé pour gérer la configuration. Il permet de déclarer les paramètres comme des singletons ou des fabriques et de les injecter dans les composants de l'application.

Exemple avec Koin

// Définition du module avec la configurationval appModule = module {    single {        AppConfig(            name = "KoinApp",            version = "2.0",            port = 9090        )    }}

// Démarrage de KoinstartKoin {    modules(appModule)}

// Utilisationclass MyService(private val config: AppConfig) {    fun start() = println("Démarrage de ${config.name} sur le port ${config.port}")}

Koin est pratique pour les projets de petite et moyenne taille où l'on ne souhaite pas intégrer des frameworks lourds. La configuration reste dans le code, mais peut être externalisée dans des fichiers séparés ou chargée depuis des variables d'environnement.

3. Spring Boot et @ConfigurationProperties

Pour les projets utilisant Spring Boot, la configuration est intégrée au niveau du framework. Les classes de configuration sont annotées avec @ConfigurationProperties et les valeurs sont chargées depuis application.yml ou application.properties.

Exemple

// application.ymlapp:  name: SpringKotlinApp  server:    port: 8080  database:    url: jdbc:postgresql://localhost:5432/mydb

// Classe Kotlin@ConfigurationProperties(prefix = "app")data class AppProperties(    val name: String,    val server: ServerConfig,    val database: DatabaseConfig) {    data class ServerConfig(val port: Int)    data class DatabaseConfig(val url: String)}

// Utilisation dans un service@Serviceclass MyService(private val props: AppProperties) {    fun info() = "App: ${props.name}, Port: ${props.server.port}"}

Spring Boot prend en charge les profils