Connaissez-vous le motif de conception Facade…

Oui, je connais le patron de conception Facade. C'est un patron structurel qui fournit une interface unifiée à un sous-système complexe de classes. Son but est de simplifier l'utilisation du sous-système en cachant sa complexité au client.

Mon expérience avec le patron Facade a été, par exemple, lors de la travail avec une architecture en couches dans une application. Supposons qu'il y ait un module pour travailler avec le réseau et la base de données. Au lieu que le code client interagisse directement avec les classes de la couche réseau (Retrofit, OkHttp), les parsers, les classes de la base de données (Room, DAO), une classe façade a été implémentée. Cette façade fournit des méthodes simples, par exemple, getUser(userId) ou saveUser(user), qui coordonnent en interne l'interaction avec les sous-systèmes correspondants : effectuent une requête réseau, analysent les données, les stockent dans la base de données.

Avantages de cette approche :

Simplification du code client : Le client n'a pas besoin de connaître la structure interne du sous-système.
Réduction du couplage : La façade sépare le client des implémentations spécifiques du sous-système, ce qui facilite leur remplacement.
Amélioration de la structuration : Le sous-système devient plus gérable et compréhensible.

Exemple d'implémentation simplifiée d'une façade :

// Sous-système de travail avec l'API
class ApiService {
    fun getUserFromApi(userId: Int): String {
        // Logique de requête réseau
        return "{\"id\":$userId, \"name\":\"John Doe\"}"
    }
}

// Sous-système de travail avec la base de données
class DatabaseService {
    fun saveUserToDb(userJson: String) {
        // Logique de sauvegarde dans la base de données
    }

    fun getUserFromDb(userId: Int): String {
        // Logique de récupération depuis la base de données
        return "" // Placeholder
    }
}

// Façade
class UserFacade(
    private val apiService: ApiService,
    private val databaseService: DatabaseService
) {
    fun getUser(userId: Int): String {
        // Tente d'abord de récupérer depuis la base de données
        val userFromDb = databaseService.getUserFromDb(userId)
        if (userFromDb.isNotEmpty()) {
            return userFromDb
        }

        // Si pas dans la base, récupère depuis l'API
        val userFromApi = apiService.getUserFromApi(userId)

        // Stocke dans la base pour mise en cache
        databaseService.saveUserToDb(userFromApi)

        return userFromApi
    }
}

// Exemple d'utilisation de la façade dans le code client
fun main() {
    val apiService = ApiService()
    val databaseService = DatabaseService()
    val userFacade = UserFacade(apiService, databaseService)

    val userJson = userFacade.getUser(123)
    println(userJson)
}

Dans cet exemple, UserFacade cache les détails de récupération des données utilisateur depuis l'API et leur stockage dans la base de données, en fournissant au code client une méthode simple getUser. Le client n'a pas besoin de connaître l'existence de ApiService et DatabaseService.

Ainsi, Facade aide à créer un code plus propre, compréhensible et facile à maintenir, surtout lorsqu'on travaille avec des modules complexes.

Connaissez-vous le motif de conception Facade ? Parlez de votre expérience de son utilisation.