Facade: dasar pola fasad dalam arsitektur seluler

Apa itu pola Facade?

Facade — pola struktural yang menyediakan antarmuka terpadu ke sekelompok antarmuka subsistem. Pola ini mendefinisikan antarmuka tingkat tinggi yang menyederhanakan penggunaan subsistem. Facade tidak menambah fungsionalitas baru — pola ini mengorkestrasi komponen yang ada, menyembunyikan kompleksitas interaksi mereka dari klien.

// Subsistem yang kompleks
class AuthApi {
    suspend fun login(email: String, pass: String): TokenResponse
}

class UserDao {
    suspend fun saveUser(user: UserEntity)
    suspend fun getUser(id: Long): UserEntity?
}

class AnalyticsTracker {
    fun track(event: String, params: Map)
}

// Facade — antarmuka sederhana untuk UI
class AuthService(
    private val api: AuthApi,
    private val dao: UserDao,
    private val analytics: AnalyticsTracker
) {
    suspend fun loginUser(email: String, password: String): Result {
        return runCatching {
            val token = api.login(email, password)
            val user = User(token.userId, email, token.accessToken)
            dao.saveUser(user.toEntity())
            analytics.track("login_success", mapOf("method" to "email"))
            user
        }
    }
}

AuthService — Facade yang menyembunyikan AuthApi, UserDao, dan AnalyticsTracker dari ViewModel. UI memanggil loginUser(email, password) alih-alih tiga permintaan terpisah ke API, basis data, dan analitik. Ini mengurangi keterikatan: jika besok AuthApi menjadi FirebaseAuth atau UserDao bermigrasi ke Room, hanya Facade yang berubah, bukan UI.

Facade dalam arsitektur seluler: Service Layer

Service Layer — implementasi Facade yang umum di aplikasi seluler. Layer ini meng-enkapsulasi logika bisnis dan koordinasi antar lapisan. Di Android, Service Layer sering diimplementasikan melalui UseCase (Clean Architecture), di iOS — melalui Manager atau protokol Service.

AuthService menggabungkan keempat komponen. ViewModel memanggil satu metode, tanpa mengetahui bahwa di balik layar terjadi permintaan jaringan, penulisan ke basis data, pelacakan, dan pemeriksaan jaringan. Saat menguji, AuthService dapat diganti dengan mock, memeriksa seluruh logika autentikasi tanpa integrasi dengan komponen nyata.

Facade vs Adapter vs Mediator

Facade, Adapter, dan Mediator — pola struktural, tetapi memecahkan masalah yang berbeda. Mereka sering tertukar, karena ketiganya memperkenalkan objek perantara. Mari kita bahas perbedaannya dengan contoh aplikasi seluler.

Facade tidak menyembunyikan subsistem — klien dapat mengakses AuthApi secara langsung jika diperlukan. Adapter secara wajib mengubah antarmuka Adaptee. Mediator mengoordinasi interaksi kompleks antara banyak objek yang mungkin tidak saling mengenal.

Implementasi Facade di Kotlin untuk Android

Implementasi Facade di Kotlin untuk Android dengan Clean Architecture menggunakan UseCase sebagai titik masuk untuk setiap skenario bisnis. UseCase adalah Facade yang menyembunyikan repository, mapper, dan dependensi lain dari lapisan UI.

// Repository — juga Facade, tetapi satu tingkat lebih rendah
class UserRepositoryImpl(
    private val local: UserLocalDataSource,
    private val remote: UserRemoteDataSource,
    private val mapper: UserMapper
) : UserRepository {
    override suspend fun getUserProfile(id: String): UserProfile {
        val cached = local.getUser(id)
        if (cached != null && !cached.isStale) {
            return mapper.toProfile(cached)
        }
        val dto = remote.fetchUser(id)
        val entity = mapper.toEntity(dto)
        local.saveUser(entity)
        return mapper.toProfile(entity)
    }
}

// UseCase — Facade untuk skenario bisnis
class LoadUserProfileUseCase(
    private val repo: UserRepository,
    private val analytics: AnalyticsTracker
) {
    suspend operator fun invoke(userId: String): Result {
        return runCatching {
            val profile = repo.getUserProfile(userId)
            analytics.track("profile_loaded", mapOf("user_id" to userId))
            profile
        }
    }
}

LoadUserProfileUseCase — Facade untuk skenario pemuatan profil. Pola ini menyembunyikan logika caching (local → remote), pemetaan DTO → Entity → Profile, dan pelacakan analitik. ViewModel memanggil invoke(userId) dan menerima UserProfile yang siap atau sebuah kesalahan. UseCase dapat diuji secara terisolasi dengan mengganti repository dengan objek mock.

Implementasi Facade di Swift untuk iOS

Facade di iOS sering diimplementasikan sebagai Manager atau Service. Berbeda dengan Android, iOS menggunakan protokol untuk mendefinisikan antarmuka Facade, yang memungkinkan penggantian implementasi dengan mudah dalam pengujian. Mari kita bahas Facade untuk bekerja dengan media — pemuatan, caching, dan penampilan.

protocol MediaServiceProtocol {
    func loadImage(from url: URL) async -> Result<UIImage, Error>
}

final class MediaService: MediaServiceProtocol {
    private let cache: ImageCache
    private let downloader: ImageDownloader
    private let decoder: ImageDecoder
    
    func loadImage(from url: URL) async -> Result<UIImage, Error> {
        // 1. Periksa cache
        if let cached = cache.image(for: url) {
            return .success(cached)
        }
        // 2. Muat data
        let result = await downloader.download(from: url)
        guard case let .success(data) = result else {
            return .failure(MediaError.downloadFailed)
        }
        // 3. Dekode
        guard let image = decoder.decode(data) else {
            return .failure(MediaError.decodeFailed)
        }
        // 4. Simpan ke cache
        cache.setImage(image, for: url)
        return .success(image)
    }
}

MediaService meng-enkapsulasi proses tiga langkah: cache → pemuatan → decoding. UI memanggil satu metode loadImage(from:) alih-alih mengelola ImageCache, URLSession, dan ImageDecoder. Saat menguji, MediaServiceProtocol dapat diganti dengan mock yang mengembalikan gambar yang telah ditentukan tanpa pemuatan nyata.

Kesalahan umum saat menggunakan Facade

Kesalahan dalam merancang Facade meniadakan keunggulannya: alih-alih penyederhanaan, muncul God Object yang membuat seluruh sistem bergantung padanya. Mari kita bahas tiga masalah utama.

God Facade — terlalu banyak tanggung jawab

Ketika satu Facade berisi metode untuk autentikasi, pemuatan profil, pengiriman pesan, dan sinkronisasi — ini adalah God Object. Tanda: lebih dari 15 metode publik dalam satu kelas. Solusi: membagi menjadi beberapa Facade khusus berdasarkan area tanggung jawab — AuthService, ProfileService, MessagingService.

Facade dengan kebocoran detail subsistem

Jika Facade mengembalikan tipe yang spesifik untuk subsistem (misalnya, FirebaseUser atau RealmObject), klien tetap terikat pada implementasi tertentu. Solusi: Facade harus mengembalikan hanya tipe miliknya sendiri (data class / struct), sepenuhnya mengabstraksi klien dari detail subsistem.

Facade sebagai satu-satunya titik masuk

Ketika Facade melarang akses langsung ke subsistem, Facade menjadi penghambat. Terkadang klien membutuhkan metode spesifik dari subsistem, dan memaksanya melewati Facade adalah berlebihan. Facade tidak boleh menjadi gatekeeper yang ketat: Facade menyediakan antarmuka yang nyaman, tetapi tidak memblokir akses langsung ke komponen.