Kennen Sie das Entwurfsmuster Facade? Erzählen Sie…

Ja, ich bin mit dem Entwurfsmuster Facade vertraut. Es ist ein strukturelles Muster, das eine einheitliche Schnittstelle zu einem komplexen Subsystem von Klassen bereitstellt. Es soll die Nutzung des Subsystems vereinfachen, indem es seine Komplexität vor dem Client verbirgt.

Meine Erfahrung mit dem Facade-Muster war zum Beispiel bei der Arbeit mit einer mehrschichtigen Architektur in einer Anwendung. Angenommen, es gibt ein Modul für die Arbeit mit Netzwerk und Datenbank. Anstatt dass der Client-Code direkt mit den Klassen der Netzwerkschicht (Retrofit, OkHttp), Parser, Datenbankklassen (Room, DAO) interagiert, wurde eine Fassade-Klasse implementiert. Diese Fassade stellt einfache Methoden bereit, z.B. getUser(userId) oder saveUser(user), die intern die Interaktion mit den entsprechenden Subsystemen koordinieren: eine Netzwerkanfrage durchführen, Daten parsen, in der Datenbank speichern.

Vorteile dieses Ansatzes:

Vereinfachung des Client-Codes: Der Client muss die interne Struktur des Subsystems nicht kennen.
Reduzierung der Kopplung: Die Fassade trennt den Client von den konkreten Implementierungen des Subsystems, was deren Austausch erleichtert.
Verbesserung der Strukturierung: Das Subsystem wird handhabbarer und verständlicher.

Beispiel für eine vereinfachte Implementierung der Fassade:

// Subsystem für API-Arbeit
class ApiService {
    fun getUserFromApi(userId: Int): String {
        // Netzwerklogik
        return "{\"id\":$userId, \"name\":\"John Doe\"}"
    }
}

// Subsystem für Datenbank
class DatabaseService {
    fun saveUserToDb(userJson: String) {
        // Logik zum Speichern in der DB
    }

    fun getUserFromDb(userId: Int): String {
        // Logik zum Abrufen aus der DB
        return "" // Platzhalter
    }
}

// Fassade
class UserFacade(
    private val apiService: ApiService,
    private val databaseService: DatabaseService
) {
    fun getUser(userId: Int): String {
        // Zuerst versuchen, aus der DB zu holen
        val userFromDb = databaseService.getUserFromDb(userId)
        if (userFromDb.isNotEmpty()) {
            return userFromDb
        }

        // Wenn nicht in der DB, aus der API holen
        val userFromApi = apiService.getUserFromApi(userId)

        // In der DB speichern für Caching
        databaseService.saveUserToDb(userFromApi)

        return userFromApi
    }
}

// Beispiel für die Nutzung der Fassade im Client-Code
fun main() {
    val apiService = ApiService()
    val databaseService = DatabaseService()
    val userFacade = UserFacade(apiService, databaseService)

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

In diesem Beispiel verbirgt UserFacade die Details der Datenbeschaffung vom API und der Speicherung in der Datenbank, indem es dem Client-Code eine einfache Methode getUser bereitstellt. Der Client muss nicht wissen, dass ApiService und DatabaseService existieren.

Auf diese Weise hilft das Facade-Muster, saubereren, verständlicheren und wartungsfreundlicheren Code zu erstellen, insbesondere bei der Arbeit mit komplexen Modulen.

Kennen Sie das Entwurfsmuster Facade? Erzählen Sie von Ihren Erfahrungen bei dessen Verwendung.