Facade: मोबाइल आर्किटेक्चर में फ़ेसेड पैटर्न की मूल बातें

Facade पैटर्न क्या है?

Facade एक स्ट्रक्चरल पैटर्न है जो सबसिस्टम इंटरफ़ेस के समूह के लिए एक एकीकृत इंटरफ़ेस प्रदान करता है। यह एक उच्च-स्तरीय इंटरफ़ेस परिभाषित करता है जो सबसिस्टम के उपयोग को सरल बनाता है। Facade कोई नई कार्यक्षमता नहीं जोड़ता — यह मौजूदा घटकों को व्यवस्थित करता है, क्लाइंट से उनकी अंतःक्रिया की जटिलता को छिपाता है।

// जटिल सबसिस्टम
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 के लिए सरल इंटरफ़ेस
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 है जो AuthApi, UserDao और AnalyticsTracker को ViewModel से छिपाता है। UI API, डेटाबेस और एनालिटिक्स को तीन अलग-अलग अनुरोधों के बजाय loginUser(email, password) को कॉल करता है। यह कपलिंग को कम करता है: यदि कल AuthApi FirebaseAuth बन जाता है या UserDao Room में माइग्रेट हो जाता है, तो केवल Facade बदलता है, UI नहीं।

मोबाइल आर्किटेक्चर में Facade: Service Layer

Service Layer मोबाइल एप्लिकेशन में Facade का एक सामान्य कार्यान्वयन है। यह व्यावसायिक लॉजिक और परतों के बीच समन्वय को समाहित करता है। Android में, Service Layer को अक्सर UseCase (Clean Architecture) के माध्यम से लागू किया जाता है, और iOS में Manager या Service प्रोटोकॉल के माध्यम से।

AuthService सभी चार घटकों को जोड़ता है। ViewModel एक विधि को कॉल करता है, बिना यह जाने कि अंदर नेटवर्क अनुरोध, डेटाबेस लेखन, ट्रैकिंग और नेटवर्क जाँच हो रही है। परीक्षण करते समय, AuthService को mock से बदला जा सकता है, वास्तविक घटकों के साथ एकीकरण के बिना पूरे प्रमाणीकरण लॉजिक की पुष्टि करते हुए।

Facade बनाम Adapter बनाम Mediator

Facade, Adapter और Mediator स्ट्रक्चरल पैटर्न हैं, लेकिन अलग-अलग समस्याओं का समाधान करते हैं। उन्हें अक्सर भ्रमित किया जाता है, क्योंकि तीनों एक मध्यस्थ वस्तु का परिचय देते हैं। मोबाइल एप्लिकेशन के उदाहरण पर अंतरों को समझते हैं।

Facade सबसिस्टम को छिपाता नहीं है — क्लाइंट आवश्यकता पड़ने पर AuthApi तक सीधे पहुँच सकता है। Adapter अनिवार्य रूप से Adaptee के इंटरफ़ेस को बदलता है। Mediator कई वस्तुओं के बीच जटिल अंतःक्रियाओं का समन्वय करता है, जो एक-दूसरे के बारे में नहीं जान सकतीं।

Android के लिए Kotlin में Facade का कार्यान्वयन

Facade का कार्यान्वयन Kotlin में Android के लिए Clean Architecture के साथ प्रत्येक व्यावसायिक परिदृश्य के लिए प्रवेश बिंदु के रूप में UseCase का उपयोग करता है। UseCase एक Facade है जो रिपॉजिटरी, मैपर और अन्य निर्भरताओं को UI परत से छिपाता है।

// Repository भी एक Facade है, लेकिन निचले स्तर पर
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
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 है। यह कैशिंग लॉजिक (local → remote), DTO → Entity → Profile मैपिंग और एनालिटिक्स ट्रैकिंग को छिपाता है। ViewModel invoke(userId) को कॉल करता है और तैयार UserProfile या त्रुटि प्राप्त करता है। UseCase को रिपॉजिटरी को mock ऑब्जेक्ट से बदलकर अलग-थलग परीक्षण किया जा सकता है।

iOS के लिए Swift में Facade का कार्यान्वयन

iOS में Facade को अक्सर Manager या Service के रूप में लागू किया जाता है। Android के विपरीत, iOS Facade के इंटरफ़ेस को परिभाषित करने के लिए प्रोटोकॉल का उपयोग करता है, जिससे परीक्षणों में कार्यान्वयन को आसानी से बदला जा सकता है। मीडिया के साथ काम करने के लिए Facade पर विचार करें — लोडिंग, कैशिंग और प्रदर्शन।

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. कैश की जाँच करें
        if let cached = cache.image(for: url) {
            return .success(cached)
        }
        // 2. डेटा लोड करें
        let result = await downloader.download(from: url)
        guard case let .success(data) = result else {
            return .failure(MediaError.downloadFailed)
        }
        // 3. डिकोड करें
        guard let image = decoder.decode(data) else {
            return .failure(MediaError.decodeFailed)
        }
        // 4. कैश में सहेजें
        cache.setImage(image, for: url)
        return .success(image)
    }
}

MediaService तीन-चरणीय प्रक्रिया को समाहित करता है: कैश → लोड → डिकोड। UI ImageCache, URLSession और ImageDecoder को प्रबंधित करने के बजाय एक विधि loadImage(from:) को कॉल करता है। परीक्षण करते समय, MediaServiceProtocol को वास्तविक लोडिंग के बिना पूर्व निर्धारित छवियाँ लौटाने वाले mock से बदला जा सकता है।

Facade का उपयोग करते समय सामान्य गलतियाँ

गलतियाँ Facade के डिज़ाइन में उसके लाभों को समाप्त कर देती हैं: सरलीकरण के बजाय आपको God Object मिलता है, जिस पर पूरी प्रणाली निर्भर करती है। तीन मुख्य समस्याओं पर विचार करते हैं।

God Facade — बहुत अधिक जिम्मेदारी

जब एक Facade में प्रमाणीकरण, प्रोफ़ाइल लोडिंग, संदेश भेजने और सिंक्रोनाइज़ेशन की विधियाँ होती हैं — यह God Object है। संकेत: एक कक्षा में 15+ सार्वजनिक विधियाँ। समाधान: इसे जिम्मेदारी के क्षेत्रों के अनुसार कई विशेषज्ञ Facade में विभाजित करें — AuthService, ProfileService, MessagingService।

सबसिस्टम विवरण लीक करने वाला Facade

यदि Facade सबसिस्टम के लिए विशिष्ट प्रकार लौटाता है (उदाहरण के लिए, FirebaseUser या RealmObject), तो क्लाइंट अभी भी एक विशिष्ट कार्यान्वयन से बंधा रहता है। समाधान: Facade को केवल अपने प्रकार (data class / struct) लौटाने चाहिए, क्लाइंट को सबसिस्टम विवरणों से पूरी तरह अलग करते हुए।

एकमात्र प्रवेश बिंदु के रूप में Facade

जब Facade सबसिस्टम तक सीधी पहुँच प्रतिबंधित करता है, तो यह bottleneck बन जाता है। कभी-कभी क्लाइंट को सबसिस्टम की विशिष्ट विधि की आवश्यकता होती है, और उसे Facade के माध्यम से जाने के लिए मजबूर करना अनावश्यक है। Facade को सख्त गेटकीपर नहीं होना चाहिए: यह एक सुविधाजनक इंटरफ़ेस प्रदान करता है, लेकिन घटकों तक सीधी पहुँच को अवरुद्ध नहीं करता।