Cunoașteți pattern-ul de proiectare Facade? Povestiți…

Da, sunt familiarizat cu pattern-ul de proiectare Facade. Este un pattern structural care oferă o interfață unificată către un subsistem complex de clase. Scopul său este de a simplifica utilizarea subsistemului, ascunzând complexitatea sa față de client.

Experiența mea cu pattern-ul Facade a fost, de exemplu, atunci când am lucrat cu o arhitectură pe mai multe niveluri într-o aplicație. Să presupunem că exista un modul pentru lucrul cu rețeaua și baza de date. În loc ca codul client să interacționeze direct cu clasele de pe stratul de rețea (Retrofit, OkHttp), parsere, clase de bază de date (Room, DAO), s-a implementat o clasă facade. Această facade oferea metode simple, de exemplu, getUser(userId) sau saveUser(user), care coordonau intern interacțiunea cu subsistemele corespunzătoare: efectuau o solicitare de rețea, analizau datele, le stocau în baza de date.

Avantajele acestei abordări:

Simplificarea codului client: Clientul nu trebuie să cunoască structura internă a subsistemului.
Reducerea cuplajului: Facade separă clientul de implementările specifice ale subsistemului, facilitând înlocuirea acestora.
Îmbunătățirea structurii: Subsistemul devine mai gestionabil și mai ușor de înțeles.

Exemplu de implementare simplificată a unei facade:

// Subsistem pentru lucrul cu API-ul
class ApiService {
    fun getUserFromApi(userId: Int): String {
        // Logica solicitării de rețea
        return "{\"id\":$userId, \"name\":\"John Doe\"}"
    }
}

// Subsistem pentru lucrul cu baza de date
class DatabaseService {
    fun saveUserToDb(userJson: String) {
        // Logica de salvare în baza de date
    }

    fun getUserFromDb(userId: Int): String {
        // Logica de preluare din baza de date
        return "" // Placeholder
    }
}

// Facade
class UserFacade(
    private val apiService: ApiService,
    private val databaseService: DatabaseService
) {
    fun getUser(userId: Int): String {
        // Întâi încercăm să preluăm din baza de date
        val userFromDb = databaseService.getUserFromDb(userId)
        if (userFromDb.isNotEmpty()) {
            return userFromDb
        }

        // Dacă nu există în bază, preluăm din API
        val userFromApi = apiService.getUserFromApi(userId)

        // Salvăm în bază pentru cache
        databaseService.saveUserToDb(userFromApi)

        return userFromApi
    }
}

// Exemplu de utilizare a facade-ului în codul client
fun main() {
    val apiService = ApiService()
    val databaseService = DatabaseService()
    val userFacade = UserFacade(apiService, databaseService)

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

În acest exemplu, UserFacade ascunde detaliile de preluare a datelor utilizatorului din API și de salvare în bază, oferind codului client metoda simplă getUser. Clientul nu trebuie să știe despre existența ApiService și DatabaseService.

Astfel, pattern-ul Facade ajută la crearea unui cod mai curat, mai ușor de înțeles și mai ușor de întreținut, mai ales când se lucrează cu module complexe.

Cunoașteți pattern-ul de proiectare Facade? Povestiți despre experiența dvs. în utilizarea sa.