Factory: Factory Method और Abstract Factory पैटर्न का सार

Factory क्या है: ऑब्जेक्ट निर्माण पैटर्न का सार?

Factory — GoF कैटलॉग से एक सृजनात्मक डिज़ाइन पैटर्न। मुख्य विचार: ऑब्जेक्ट निर्माण लॉजिक को क्लाइंट कोड से एक अलग विधि या वर्ग में स्थानांतरित करना। क्लाइंट एक इंटरफ़ेस या अमूर्त वर्ग के साथ काम करता है, जबकि ठोस कार्यान्वयन फ़ैक्टरी द्वारा बनाया जाता है। यह डिपेंडेंसी इन्वर्ज़न सिद्धांत को लागू करता है: क्लाइंट ठोस वर्गों पर निर्भर नहीं करता, केवल अब्स्ट्रैक्शन पर।

दो किस्में Factory की: Factory Method और Abstract Factory। Factory Method — एक वर्ग में एक विधि जिसे उपवर्ग ऑब्जेक्ट बनाने के लिए ओवरराइड करते हैं। Abstract Factory — परस्पर संबंधित ऑब्जेक्ट्स के समूह बनाने के लिए फ़ैक्टरी विधियों के परिवार वाला एक इंटरफ़ेस। दोनों वेरिएंट एक ही समस्या हल करते हैं: क्लाइंट सीधे new MyClass() नहीं कहता, बल्कि फ़ैक्टरी से उसके प्रकार या पैरामीटर के आधार पर ऑब्जेक्ट बनाने के लिए कहता है।

Factory vs new() — सीधा ऑब्जेक्ट निर्माण कोड को एक ठोस कार्यान्वयन से मजबूती से जोड़ता है। Factory एक परत जोड़ता है: कार्यान्वयन बदलने के लिए केवल फ़ैक्टरी में संपादन की आवश्यकता होती है, सभी क्लाइंट में नहीं। मोबाइल डेवलपमेंट में, Factory का सक्रिय रूप से ViewModel (ViewModelProvider.Factory), नेटवर्क क्लाइंट (Retrofit.create()), सूची एडेप्टर और सीरियलाइज़ेशन फ़ैक्टरियाँ बनाने के लिए उपयोग किया जाता है। DI कंटेनर (Dagger, Koin) स्वचालित रूप से फ़ैक्टरियाँ उत्पन्न करते हैं।

Factory Method: Swift और Kotlin उदाहरण

Factory Method — एक प्रोटोकॉल या अमूर्त वर्ग में घोषित विधि जो एक विशिष्ट प्रकार की ऑब्जेक्ट लौटाती है। उपवर्ग विधि को लागू करते हैं, ठोस इंस्टेंस बनाते हैं। Swift में, यह प्रोटोकॉल में स्थैतिक विधि या आधार वर्ग में विधि हो सकती है। Kotlin में — फ़ैक्टरी विधि वाला companion object या अमूर्त वर्ग में open fun। पैटर्न का व्यापक रूप से पार्सर, त्रुटि फ़ैक्टरियाँ और क्वेरी बिल्डर बनाने के लिए उपयोग किया जाता है।

protocol PaymentGateway {
    func processPayment(amount: Decimal) async throws -> PaymentResult
}

final class StripeGateway: PaymentGateway { /* ... */ }
final class ApplePayGateway: PaymentGateway { /* ... */ }

enum PaymentType { case stripe, applePay }

final class PaymentFactory {
    // Factory Method
    static func create(type: PaymentType) -> PaymentGateway {
        switch type {
        case .stripe: return StripeGateway()
        case .applePay: return ApplePayGateway()
        }
    }
}

// उपयोग
let gateway = PaymentFactory.create(type: .stripe)

Kotlin संस्करण Factory Method प्रकारों को सीमित करने के लिए companion object या sealed class का उपयोग करता है। Sealed class गारंटी देती है कि when शाखा सभी संभावित प्रकारों को कवर करती है — कंपाइलर पूर्णता की जाँच करता है। यह Android प्रोजेक्ट्स के लिए विशिष्ट है जहाँ फ़ैक्टरी build flavour या कॉन्फ़िगरेशन के आधार पर अलग-अलग Repository या DataSource कार्यान्वयन बनाती है।

sealed class PaymentType {
    object Stripe : PaymentType()
    object ApplePay : PaymentType()
}

interface PaymentGateway {
    suspend fun processPayment(amount: BigDecimal): PaymentResult
}

class PaymentFactory {
    companion object {
        fun create(type: PaymentType): PaymentGateway = when (type) {
            PaymentType.Stripe -> StripeGateway()
            PaymentType.ApplePay -> ApplePayGateway()
        }
    }
}

Abstract Factory: परस्पर संबंधित ऑब्जेक्ट्स के परिवार

Abstract Factory — उनके ठोस वर्गों को निर्दिष्ट किए बिना परस्पर संबंधित या अन्योन्याश्रित ऑब्जेक्ट्स के परिवार बनाने के लिए एक पैटर्न। क्लाइंट अमूर्त फ़ैक्टरी इंटरफ़ेस के साथ काम करता है, जो परिवार के प्रत्येक उत्पाद को बनाने के लिए विधियाँ परिभाषित करता है। एक ठोस फ़ैक्टरी इंटरफ़ेस लागू करती है और एक विशिष्ट वेरिएंट की ऑब्जेक्ट बनाती है। उदाहरण के लिए, iOS के लिए UI घटक फ़ैक्टरी UIButton, UILabel, UITableView बनाती है, जबकि Android के लिए — Button, TextView, RecyclerView.

Abstract Factory vs Factory Method — Factory Method विरासत के माध्यम से एक प्रकार की ऑब्जेक्ट बनाता है, Abstract Factory कम्पोज़ीशन के माध्यम से ऑब्जेक्ट्स का परिवार बनाता है। Factory Method उपवर्गों में ओवरराइड किया जाता है, Abstract Factory एक प्रोटोकॉल के माध्यम से कई फ़ैक्टरी विधियाँ प्रदान करता है। Abstract Factory में अक्सर कई Factory Method होते हैं। मोबाइल डेवलपमेंट में, Abstract Factory का उपयोग प्लेटफ़ॉर्म-निर्भर घटकों, थीम डिज़ाइन और डेटाबेस फ़ैक्टरियों के लिए किया जाता है।

वास्तविक मामला Android में Abstract Factory — एकल DatabaseFactory इंटरफ़ेस के माध्यम से विभिन्न डेटाबेस प्रकारों (SQLite vs Room) का कार्यान्वयन। फ़ैक्टरी DAO ऑब्जेक्ट, माइग्रेशन और कनेक्शन पूल बनाती है। iOS में — विभिन्न वातावरणों (Development/Staging/Production) के लिए सेवा फ़ैक्टरी। Abstract Factory का सीधे शायद ही कभी उपयोग किया जाता है — इसके कार्य DI कंटेनर (Dagger Module, Swinject Assembly) ले लेते हैं।

iOS में Factory: प्रोटोकॉल और स्थैतिक विधियाँ

Swift Factory प्रोटोकॉल और स्थैतिक विधियों के माध्यम से कार्यान्वित किया जाता है। Factory प्रोटोकॉल एक create() विधि घोषित करता है जो एक अमूर्त प्रकार लौटाती है। एक ठोस फ़ैक्टरी प्रोटोकॉल लागू करती है और आवश्यक ऑब्जेक्ट बनाती है। Swift को सरल मामलों के लिए अलग फ़ैक्टरी वर्ग की आवश्यकता नहीं होती — enum या struct में एक स्थैतिक विधि पर्याप्त है। जटिल परिदृश्यों के लिए, DI इंजेक्शन के साथ Factory प्रोटोकॉल का उपयोग किया जाता है।

iOS SDK में Factory — कई सिस्टम फ़ैक्टरियाँ: UIStoryboard.instantiateViewController(withIdentifier:), NSKeyedUnarchiver.unarchivedObject(ofClass:from:), JSONDecoder().decode(_:from:)। डेवलपर ViewController (StoryboardFactory), सेवाओं (ServiceFactory) और डेटा मॉडल के लिए फ़ैक्टरियाँ बनाते हैं। Factory Method का सक्रिय रूप से VIPER और Clean Swift आर्किटेक्चर में स्क्रीन मॉड्यूल बनाने के लिए उपयोग किया जाता है।

Factory + DI — एक आधुनिक विकल्प: DI कंटेनर (Swinject, Factory) पंजीकृत प्रकारों के लिए स्वचालित रूप से फ़ैक्टरियाँ उत्पन्न करता है। कंटेनर ऑब्जेक्ट निर्माण रेसिपी संग्रहीत करता है और निर्भरताएँ हल करता है। Factory लाइब्रेरी (github.com/hmlongco/Factory) स्वचालित इंजेक्शन के लिए @Injected(.service) का उपयोग करती है। DI फ़ैक्टरियाँ एक पंक्ति से पूरे मॉड्यूल को बदलकर परीक्षण की जाती हैं: container.register { MockService() }.

Android में Factory: companion factory और DI मॉड्यूल

Android Factory — एक क्लासिक उदाहरण: पैरामीटर के साथ ViewModel बनाने के लिए ViewModelProvider.Factory। Google स्वचालित ViewModel फ़ैक्टरी जनरेशन के लिए Hilt का उपयोग करने की सलाह देता है — @HiltViewModel एनोटेशन स्वचालित रूप से Factory बनाता है। सरल ऑब्जेक्ट के लिए, create() या invoke() विधि वाले companion object का उपयोग किया जाता है। Kotlin में, invoke ऑपरेटर फ़ैक्टरी को फ़ंक्शन की तरह कॉल करने की अनुमति देता है: Factory(param).

Jetpack Compose में Factory — फ़ैक्टरियों का उपयोग राज्य और प्रभाव बनाने के लिए किया जाता है। remember { Factory.create() } पहले रेंडर पर एक ऑब्जेक्ट बनाता है और composable के जीवनकाल में इसे संरक्षित करता है। Compose में ViewModel viewModel() के माध्यम से बनाया जाता है — यह Hilt द्वारा प्रबंधित फ़ैक्टरी है। Compose में, फ़ैक्टरियाँ स्पष्ट रूप से कम आम हैं, क्योंकि DI और Compose StateManager ऑब्जेक्ट निर्माण संभालते हैं।

Factory vs Hilt — Dagger/Hilt कंपाइल समय पर स्वचालित रूप से फ़ैक्टरियाँ उत्पन्न करता है। @Module + @Provides Factory Method को बदलता है, @Binds Abstract Factory को बदलता है। मैन्युअल फ़ैक्टरियाँ रनटाइम में गतिशील कार्यान्वयन चयन (A/B परीक्षण, फ़ीचर फ़्लैग) के लिए प्रासंगिक बनी रहती हैं। स्थैतिक निर्भरताओं के लिए, Hilt ऑब्जेक्ट निर्माण को पूरी तरह से स्वचालित करता है — डेवलपर केवल इंटरफ़ेस और एनोटेशन लिखता है।