Bent u bekend met het ontwerp patroon Facade? Vertel…

Ja, ik ben bekend met het ontwerp patroon Facade. Het is een structureel patroon dat een eenduidige interface biedt aan een complex klassensysteem. Het doel is om het gebruik van het subsysteem te vereenvoudigen door de complexiteit ervan voor de client te verbergen.

Mijn ervaring met het Facade-patroon was bijvoorbeeld bij het werken met een multi-laag architectuur in een applicatie. Stel dat er een module was voor werken met het netwerk en de database. In plaats van dat de clientcode direct met de klassen van de netwerklaag (Retrofit, OkHttp), parsers, databaseklassen (Room, DAO) interageerde, werd een facade-klasse geïmplementeerd. Deze facade bood eenvoudige methoden, bijvoorbeeld getUser(userId) of saveUser(user), die intern de interactie met de bijbehorende subsysteem coördineerden: het uitvoeren van een netwerkverzoek, het parseren van gegevens, het opslaan in de database.

Voordelen van deze aanpak:

Vereenvoudiging van de clientcode: De client hoeft de interne structuur van het subsysteem niet te kennen.
Vermindering van koppeling: De facade scheidt de client van de specifieke implementaties van het subsysteem, wat hun vervanging vergemakkelijkt.
Verbetering van de structuur: Het subsysteem wordt beter beheersbaar en begrijpelijk.

Voorbeeld van een vereenvoudigde implementatie van een facade:

// Subsysteem voor API-werking
class ApiService {
    fun getUserFromApi(userId: Int): String {
        // Logica voor netwerkverzoek
        return "{\"id\":$userId, \"name\":\"John Doe\"}"
    }
}

// Subsysteem voor database-werking
class DatabaseService {
    fun saveUserToDb(userJson: String) {
        // Logica voor opslaan in de database
    }

    fun getUserFromDb(userId: Int): String {
        // Logica voor ophalen uit de database
        return "" // Placeholder
    }
}

// Facade
class UserFacade(
    private val apiService: ApiService,
    private val databaseService: DatabaseService
) {
    fun getUser(userId: Int): String {
        // Eerst proberen op te halen uit de database
        val userFromDb = databaseService.getUserFromDb(userId)
        if (userFromDb.isNotEmpty()) {
            return userFromDb
        }

        // Als niet in de database, ophalen uit API
        val userFromApi = apiService.getUserFromApi(userId)

        // Opslaan in de database voor caching
        databaseService.saveUserToDb(userFromApi)

        return userFromApi
    }
}

// Voorbeeld van gebruik van de facade in clientcode
fun main() {
    val apiService = ApiService()
    val databaseService = DatabaseService()
    val userFacade = UserFacade(apiService, databaseService)

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

In dit voorbeeld verbergt UserFacade de details van het ophalen van gebruikersgegevens uit de API en het opslaan in de database, en biedt het de client een eenvoudige methode getUser. De client hoeft niet te weten dat ApiService en DatabaseService bestaan.

Op deze manier helpt het Facade-patroon om schonere, begrijpelijkere en onderhoudsvriendelijkere code te maken, vooral bij het werken met complexe modules.

Bent u bekend met het ontwerp patroon Facade? Vertel over uw ervaring met het gebruik ervan.