Facade: mobil arxitekturada fasad namunasi asoslari

Facade namunasi nima?

Facade — quyi tizim interfeyslari guruhiga yagona interfeys taqdim etadigan strukturaviy namuna. U quyi tizimdan foydalanishni soddalashtiradigan yuqori darajadagi interfeysni belgilaydi. Facade yangi funksionallik qo'shmaydi — u mavjud komponentlarni orkestrlashadi va ularning o'zaro ta'siri murakkabligini mijozdan yashiradi.

// Murakkab quyi tizim
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 — UI uchun oddiy interfeys
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 — AuthApi, UserDao va AnalyticsTracker'ni ViewModel'dan yashiradigan Facade. UI API, ma'lumotlar bazasi va analitikaga uchta alohida so'rov o'rniga loginUser(email, password) ni chaqiradi. Bu bog'lanishni kamaytiradi: ertaga AuthApi FirebaseAuth bo'lib qolsa yoki UserDao Room'ga migratsiya qilsa, faqat Facade o'zgaradi, UI emas.

Mobil arxitekturada Facade: Service Layer

Service Layer — mobil ilovalarda Facade'ning keng tarqalgan amalga oshirilishi. U biznes mantiqini va qatlamlar o'rtasidagi koordinatsiyani inkapsulyatsiya qiladi. Android'da Service Layer ko'pincha UseCase (Clean Architecture) orqali, iOS'da esa — Manager yoki Service protokollari orqali amalga oshiriladi.

AuthService barcha to'rt komponentni birlashtiradi. ViewModel bitta metodni chaqiradi va uning ostida tarmoq so'rovi, ma'lumotlar bazasiga yozish, kuzatish va tarmoqni tekshirish sodir bo'layotganini bilmaydi. Test paytida AuthService'ni mock bilan almashtirish mumkin va real komponentlar bilan integratsiya qilmasdan butun avtorizatsiya mantiqini tekshirish mumkin.

Facade vs Adapter vs Mediator

Facade, Adapter va Mediator — strukturaviy namunalar, ammo turli vazifalarni hal qiladi. Ular ko'pincha aralashtiriladi, chunki uchalasi ham vositachi ob'ektni kiritadi. Farqlarni mobil ilova misolida ko'rib chiqamiz.

Facade quyi tizimni yashirmaydi — mijoz kerak bo'lganda AuthApi'ga to'g'ridan-to'g'ri murojaat qilishi mumkin. Adapter majburiy ravishda Adaptee interfeysini o'zgartiradi. Mediator bir-biridan bexabar bo'lishi mumkin bo'lgan ko'plab ob'ektlar o'rtasidagi murakkab o'zaro ta'sirlarni koordinatsiya qiladi.

Android uchun Kotlin'da Facade amalga oshirilishi

Facade amalga oshirilishi Clean Architecture bilan Android uchun Kotlin'da har bir biznes ssenariy uchun kirish nuqtasi sifatida UseCase'dan foydalanadi. UseCase — bu repozitoriy, mapper va boshqa bog'liqliklarni UI qatlamidan yashiradigan Facade.

// Repository — ham Facade, lekin bir daraja pastroq
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 — biznes ssenariy uchun Facade
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 — profil yuklash ssenariysi uchun Facade. U keshlash mantiqini (local → remote), DTO → Entity → Profile map qilishni va analitika kuzatishini yashiradi. ViewModel invoke(userId) ni chaqiradi va tayyor UserProfile yoki xatoni oladi. UseCase'ni repozitoriyani mock ob'ekt bilan almashtirib, izolyatsiya qilingan holda test qilish mumkin.

iOS uchun Swift'da Facade amalga oshirilishi

iOS'da Facade ko'pincha Manager yoki Service sifatida amalga oshiriladi. Android'dan farqli o'laroq, iOS Facade interfeysini aniqlash uchun protokollardan foydalanadi, bu esa testlarda amalga oshirishlarni oson almashtirishga imkon beradi. Media bilan ishlash uchun Facade'ni ko'rib chiqamiz — yuklash, keshlash va ko'rsatish.

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. Keshni tekshirish
        if let cached = cache.image(for: url) {
            return .success(cached)
        }
        // 2. Ma'lumotlarni yuklash
        let result = await downloader.download(from: url)
        guard case let .success(data) = result else {
            return .failure(MediaError.downloadFailed)
        }
        // 3. Dekodlash
        guard let image = decoder.decode(data) else {
            return .failure(MediaError.decodeFailed)
        }
        // 4. Keshlash
        cache.setImage(image, for: url)
        return .success(image)
    }
}

MediaService uch bosqichli jarayonni inkapsulyatsiya qiladi: kesh → yuklash → dekodlash. UI ImageCache, URLSession va ImageDecoder'ni boshqarish o'rniga bitta loadImage(from:) metodini chaqiradi. Test paytida MediaServiceProtocol'ni real yuklashsiz oldindan tayyorlangan rasmlarni qaytaradigan mock bilan almashtirish mumkin.

Facade'dan foydalanishdagi odatiy xatolar

Xatolar Facade'ni loyihalashda uning afzalliklarini yo'q qiladi: soddalashtirish o'rniga butun tizim bog'liq bo'lgan God Object paydo bo'ladi. Uchta asosiy muammoni ko'rib chiqamiz.

God Facade — haddan tashqari mas'uliyat

Bitta Facade avtorizatsiya, profil yuklash, xabar yuborish va sinxronizatsiya uchun metodlarni o'z ichiga olganida — bu God Objectdir. Belgisi: bitta sinfda 15+ ochiq metod. Yechim: mas'uliyat sohalari bo'yicha bir nechta ixtisoslashgan Facade'ga bo'lish — AuthService, ProfileService, MessagingService.

Quyi tizim detallari oqadigan Facade

Agar Facade quyi tizimga xos turlarni qaytarsa (masalan, FirebaseUser yoki RealmObject), mijoz baribir aniq amalga oshirishga bog'liq bo'ladi. Yechim: Facade faqat o'z turlarini (data class / struct) qaytarishi va mijozni quyi tizim detallaridan to'liq abstraksiya qilishi kerak.

Facade yagona kirish nuqtasi sifatida

Facade quyi tizimga to'g'ridan-to'g'ri kirishni taqiqlaganda, u tor bo'yinga aylanadi. Ba'zan mijozga quyi tizimning maxsus metodi kerak bo'ladi va uni Facade orqali o'tishga majburlash ortiqcha. Facade qattiq gatekeeper bo'lmasligi kerak: u qulay interfeys taqdim etadi, lekin komponentlarga to'g'ridan-to'g'ri kirishni bloklamaydi.