Factory: a Factory Method és Abstract Factory minta lényege

Mi az a Factory: az objektumlétrehozási minta lényege?

Factory — egy létrehozási tervezési minta a GoF katalógusból. A fő ötlet: az objektumlétrehozás logikájának kiszervezése a klienskódból egy külön metódusba vagy osztályba. A kliens egy interfésszel vagy absztrakt osztállyal dolgozik, a konkrét megvalósítást pedig a gyár hozza létre. Ez megvalósítja a függőség megfordításának elvét (Dependency Inversion): a kliens nem függ konkrét osztályoktól, csak absztrakcióktól.

Két változata a Factory-nak: Factory Method és Abstract Factory. Factory Method — egy metódus az osztályban, amelyet az alosztályok felülírnak objektumok létrehozásához. Abstract Factory — egy interfész gyári metódusok családjával egymással összefüggő objektumcsoportok létrehozásához. Mindkét változat ugyanazt a problémát oldja meg: a kliens nem hívja közvetlenül a new MyClass()-t, hanem megkéri a gyárat, hogy hozzon létre egy objektumot a típusa vagy paraméterei alapján.

Factory vs new() — az objektumok közvetlen létrehozása szorosan a kódot egy konkrét megvalósításhoz köti. A Factory hozzáad egy közbenső réteget: a megvalósítás cseréje csak a gyárban igényel változtatást, nem az összes kliensben. A mobilfejlesztésben a Factory-t aktívan használják ViewModel (ViewModelProvider.Factory), hálózati kliensek (Retrofit.create()), listaadapterek és szerializációs gyárak létrehozására. A DI-konténerek (Dagger, Koin) automatikusan generálnak gyárakat.

Factory Method: Swift és Kotlin példák

Factory Method — egy protokollban vagy absztrakt osztályban deklarált metódus, amely egy adott típusú objektumot ad vissza. Az alosztályok implementálják ezt a metódust, konkrét példányokat hozva létre. Swiftben ez lehet static method egy protokollban vagy metódus egy alaposztályban. Kotlinban — companion object gyári metódussal vagy open fun egy absztrakt osztályban. A mintát széles körben használják elemzők, hibagyárak és lekérdezés-építők létrehozására.

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()
        }
    }
}

// Használat
let gateway = PaymentFactory.create(type: .stripe)

Kotlin verzió Factory Method companion object vagy sealed class használ a típusok korlátozására. A sealed class garantálja, hogy a when ág az összes lehetséges típust lefedi — a fordító ellenőrzi a teljességet. Ez jellemző az Android projektekre, ahol a gyár különböző Repository vagy DataSource megvalósításokat hoz létre a build flavour vagy konfiguráció függvényében.

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: egymással összefüggő objektumcsaládok

Abstract Factory — minta egymással összefüggő vagy egymástól függő objektumcsaládok létrehozására a konkrét osztályok megadása nélkül. A kliens az absztrakt gyár interfészével dolgozik, amely meghatározza a család egyes termékeinek létrehozási metódusait. A konkrét gyár implementálja az interfészt, és egy adott variáns objektumait hozza létre. Például egy UI-komponensek gyára iOS-hez UIButton, UILabel, UITableView objektumokat hoz létre, Androidhoz pedig — Button, TextView, RecyclerView objektumokat.

Abstract Factory vs Factory Method — a Factory Method egy típusú objektumot hoz létre öröklődéssel, az Abstract Factory objektumcsaládot hoz létre kompozícióval. A Factory Method-ot az alosztályok írják felül, az Abstract Factory több gyári metódust biztosít egy protokollon keresztül. Az Abstract Factory gyakran több Factory Method-ot tartalmaz. Mobilfejlesztésben az Abstract Factory-t platformfüggő komponensekhez, témákhoz és adatbázis-gyárakhoz használják.

Valós eset Abstract Factory Androidban — különböző adatbázistípusok (SQLite vs Room) implementálása egységes DatabaseFactory interfészen keresztül. A gyár DAO-objektumokat, migrációkat és kapcsolati poolokat hoz létre. iOS-ben — szolgáltatásgyár különböző környezetekhez (Development/Staging/Production). Az Abstract Factory-t ritkán használják közvetlenül — funkcióit a DI-konténerek (Dagger Module, Swinject Assembly) veszik át.

Factory iOS-ben: protokollok és statikus metódusok

Swift Factory protokollokon és statikus metódusokon keresztül valósul meg. A Factory protokoll deklarálja a create() metódust, amely egy absztrakt típust ad vissza. A konkrét gyár implementálja a protokollt, és létrehozza a szükséges objektumokat. A Swift nem igényel külön gyárosztályt egyszerű esetekben — elég egy statikus metódus egy enum-ban vagy struct-ban. Összetett forgatókönyvekhez a Factory protokollt használják DI-n keresztüli injektálással.

Factory az iOS SDK-ban — számos rendszergyár: UIStoryboard.instantiateViewController(withIdentifier:), NSKeyedUnarchiver.unarchivedObject(ofClass:from:), JSONDecoder().decode(_:from:). A fejlesztők gyárakat hoznak létre ViewController (StoryboardFactory), szolgáltatások (ServiceFactory) és adatmodellek számára. A Factory Method-ot aktívan használják a VIPER és Clean Swift architektúrákban képernyőmodulok létrehozására.

Factory + DI — modern alternatíva: a DI-konténer (Swinject, Factory) automatikusan generál gyárakat a regisztrált típusokhoz. A konténer tárolja az objektumlétrehozási recepteket és feloldja a függőségeket. A Factory könyvtár (github.com/hmlongco/Factory) a @Injected(.service) használja automatikus injektáláshoz. A DI-gyárakat a teljes modul egy sorral való cseréjével tesztelik: container.register { MockService() }.

Factory Androidban: companion factory és DI-modulok

Android Factory — klasszikus példa: ViewModelProvider.Factory ViewModel létrehozásához paraméterekkel. A Google a Hilt használatát javasolja a ViewModel-gyárak automatikus generálásához — a @HiltViewModel annotáció automatikusan létrehozza a Factory-t. Egyszerű objektumokhoz a companion object használatos a create() vagy invoke() metódussal. Kotlinban az invoke operátor lehetővé teszi a gyár függvényként való meghívását: Factory(param).

Factory a Jetpack Compose-ban — a gyárakat állapotok és effektusok létrehozására használják. A remember { Factory.create() } létrehoz egy objektumot az első rendereléskor, és megőrzi azt a composable élettartama alatt. A ViewModel Compose-ban a viewModel()-en keresztül jön létre — ez egy Hilt által kezelt gyár. A Compose-ban a gyárak ritkábban jelennek meg explicit módon, mivel a DI és a Compose StateManager veszi át az objektumlétrehozást.

Factory vs Hilt — a Dagger/Hilt automatikusan generál gyárakat a fordítási fázisban. A @Module + @Provides felváltja a Factory Method-ot, a @Binds felváltja az Abstract Factory-t. A kézi gyárak továbbra is relevánsak a dinamikus implementációválasztáshoz futásidőben (A/B tesztelés, feature flag-ek). Statikus függőségek esetén a Hilt teljesen automatizálja az objektumlétrehozást — a fejlesztő csak az interfészt és az annotációkat írja.