Factory: die Essenz der Factory Method und Abstract Factory Muster

Was ist Factory: die Essenz des Objekterzeugungsmusters?

Factory — ein Erzeugungsmuster aus dem GoF-Katalog. Die Hauptidee: die Objekterstellungslogik aus dem Client-Code in eine separate Methode oder Klasse auslagern. Der Client arbeitet mit einer Schnittstelle oder abstrakten Klasse, während die konkrete Implementierung von der Fabrik erstellt wird. Dies implementiert das Prinzip der Abhängigkeitsumkehrung: Der Client ist nicht von konkreten Klassen abhängig, sondern nur von Abstraktionen.

Zwei Varianten von Factory: Factory Method und Abstract Factory. Factory Method — eine einzelne Methode in einer Klasse, die Subklassen überschreiben, um Objekte zu erstellen. Abstract Factory — eine Schnittstelle mit einer Familie von Fabrikmethoden zum Erstellen von Gruppen verwandter Objekte. Beide Varianten lösen dasselbe Problem: Der Client ruft nicht direkt new MyClass() auf, sondern bittet die Fabrik, ein Objekt nach seinem Typ oder Parametern zu erstellen.

Factory vs new() — die direkte Objekterstellung koppelt Code stark an eine konkrete Implementierung. Factory fügt eine Schicht hinzu: Eine Änderung der Implementierung erfordert nur eine Bearbeitung in der Fabrik, nicht bei allen Clients. In der mobilen Entwicklung wird Factory aktiv zum Erstellen von ViewModel (ViewModelProvider.Factory), Netzwerk-Clients (Retrofit.create()), Listenadaptern und Serialisierungsfabriken verwendet. DI-Container (Dagger, Koin) generieren automatisch Fabriken.

Factory Method: Swift und Kotlin Beispiele

Factory Method — eine Methode, die in einem Protokoll oder einer abstrakten Klasse deklariert ist und ein Objekt eines bestimmten Typs zurückgibt. Subklassen implementieren die Methode und erstellen konkrete Instanzen. In Swift kann dies eine statische Methode in einem Protokoll oder eine Methode in einer Basisklasse sein. In Kotlin — ein companion object mit einer Fabrikmethode oder open fun in einer abstrakten Klasse. Das Muster wird häufig zum Erstellen von Parsern, Fehlerfabriken und Abfragegeneratoren verwendet.

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

// Verwendung
let gateway = PaymentFactory.create(type: .stripe)

Kotlin-Version von Factory Method verwendet companion object oder sealed class, um Typen einzuschränken. Sealed class stellt sicher, dass der when-Zweig alle möglichen Typen abdeckt — der Compiler überprüft die Vollständigkeit. Dies ist typisch für Android-Projekte, bei denen die Fabrik je nach Build-Flavour oder Konfiguration unterschiedliche Repository- oder DataSource-Implementierungen erstellt.

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: Familien verwandter Objekte

Abstract Factory — ein Muster zum Erstellen von Familien verwandter oder voneinander abhängiger Objekte, ohne ihre konkreten Klassen anzugeben. Der Client arbeitet mit der abstrakten Fabrikschnittstelle, die Methoden zum Erstellen jedes Produkts der Familie definiert. Eine konkrete Fabrik implementiert die Schnittstelle und erstellt Objekte einer bestimmten Variante. Beispielsweise erstellt eine UI-Komponentenfabrik für iOS UIButton, UILabel, UITableView, während sie für Android — Button, TextView, RecyclerView erstellt.

Abstract Factory vs Factory Method — Factory Method erstellt einen Objekttyp durch Vererbung, Abstract Factory erstellt eine Familie von Objekten durch Komposition. Factory Method wird in Subklassen überschrieben, Abstract Factory bietet mehrere Fabrikmethoden über ein Protokoll. Abstract Factory enthält oft mehrere Factory Method. In der mobilen Entwicklung wird Abstract Factory für plattformabhängige Komponenten, Themen-Design und Datenbankfabriken verwendet.

Realwelt-Beispiel von Abstract Factory in Android — Implementierung verschiedener Datenbanktypen (SQLite vs Room) über eine einzige DatabaseFactory-Schnittstelle. Die Fabrik erstellt DAO-Objekte, Migrationen und Verbindungspools. In iOS — eine Service-Fabrik für verschiedene Umgebungen (Development/Staging/Production). Abstract Factory wird selten direkt verwendet — ihre Funktionen werden von DI-Containern (Dagger Module, Swinject Assembly) übernommen.

Factory in iOS: Protokolle und statische Methoden

Swift Factory wird über Protokolle und statische Methoden implementiert. Das Factory-Protokoll deklariert eine create()-Methode, die einen abstrakten Typ zurückgibt. Eine konkrete Fabrik implementiert das Protokoll und erstellt die benötigten Objekte. Swift benötigt für einfache Fälle keine separate Fabrikklasse — eine statische Methode in einem enum oder struct ist ausreichend. Für komplexe Szenarien wird ein Factory-Protokoll mit DI-Injektion verwendet.

Factory im iOS SDK — viele Systemfabriken: UIStoryboard.instantiateViewController(withIdentifier:), NSKeyedUnarchiver.unarchivedObject(ofClass:from:), JSONDecoder().decode(_:from:). Entwickler erstellen Fabriken für ViewController (StoryboardFactory), für Dienste (ServiceFactory) und für Datenmodelle. Factory Method wird aktiv in VIPER- und Clean-Swift-Architekturen zum Erstellen von Bildschirmmodulen verwendet.

Factory + DI — eine moderne Alternative: Ein DI-Container (Swinject, Factory) generiert automatisch Fabriken für registrierte Typen. Der Container speichert Objekterstellungsrezepte und löst Abhängigkeiten auf. Die Factory-Bibliothek (github.com/hmlongco/Factory) verwendet @Injected(.service) zur automatischen Injektion. DI-Fabriken werden getestet, indem ein ganzes Modul mit einer einzigen Zeile ersetzt wird: container.register { MockService() }.

Factory in Android: companion factory und DI-Module

Android Factory — ein klassisches Beispiel: ViewModelProvider.Factory zum Erstellen von ViewModel mit Parametern. Google empfiehlt die Verwendung von Hilt zur automatischen Generierung von ViewModel-Fabriken — die @HiltViewModel-Annotation erstellt Factory automatisch. Für einfache Objekte wird ein companion object mit create()- oder invoke()-Methode verwendet. In Kotlin erlaubt der invoke-Operator, die Fabrik wie eine Funktion aufzurufen: Factory(param).

Factory in Jetpack Compose — Fabriken werden zum Erstellen von Zuständen und Effekten verwendet. remember { Factory.create() } erstellt ein Objekt beim ersten Rendern und bewahrt es während der Lebensdauer des Composables. ViewModel in Compose wird über viewModel() erstellt — dies ist eine von Hilt verwaltete Fabrik. In Compose sind Fabriken explizit seltener, da DI und Compose StateManager die Objekterstellung übernehmen.

Factory vs Hilt — Dagger/Hilt generiert automatisch Fabriken zur Compile-Zeit. @Module + @Provides ersetzt Factory Method, @Binds ersetzt Abstract Factory. Manuelle Fabriken bleiben für die dynamische Laufzeit-Auswahl von Implementierungen relevant (A/B-Tests, Feature-Flags). Für statische Abhängigkeiten automatisiert Hilt die Objekterstellung vollständig — der Entwickler schreibt nur Schnittstellen und Annotationen.