Factory: kärnan i mönstret Factory Method och Abstract Factory

Vad är Factory: kärnan i mönstret för att skapa objekt?

Factory — ett skapande designmönster från GoF-katalogen. Huvudidén: flytta logiken för att skapa objekt från klientkoden till en separat metod eller klass. Klienten arbetar med ett gränssnitt eller en abstrakt klass, och den konkreta implementationen skapas av fabriken. Detta implementerar principen om beroendeinversion (Dependency Inversion): klienten är inte beroende av konkreta klasser, utan endast av abstraktioner.

Två varianter Factory: Factory Method och Abstract Factory. Factory Method — en metod i en klass som subklasser åsidosätter för att skapa objekt. Abstract Factory — ett gränssnitt med en familj av fabriksmetoder för att skapa grupper av sammanlänkade objekt. Båda varianterna löser samma problem: klienten anropar inte direkt new MyClass(), utan ber fabriken att skapa ett objekt baserat på dess typ eller parametrar.

Factory vs new() — direkt objektsskapande binder koden hårt till en konkret implementation. Factory lägger till ett mellanlager: ändring av implementation kräver ändring endast i fabriken, inte i alla klienter. Inom mobil utveckling används Factory aktivt för att skapa ViewModel (ViewModelProvider.Factory), nätverksklienter (Retrofit.create()), listadaptrar och serialiseringsfabriker. DI-containrar (Dagger, Koin) genererar automatiskt fabriker.

Factory Method: Swift och Kotlin exempel

Factory Method — en metod deklarerad i ett protokoll eller en abstrakt klass som returnerar ett objekt av en specifik typ. Subklasser implementerar denna metod och skapar konkreta instanser. I Swift kan detta vara en static method i ett protokoll eller en metod i en basklass. I Kotlin — companion object med en fabriksmetod eller open fun i en abstrakt klass. Mönstret används i stor utsträckning för att skapa parsers, feltfabriker och frågebyggare.

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

// Användning
let gateway = PaymentFactory.create(type: .stripe)

Kotlin-version Factory Method använder companion object eller sealed class för att begränsa typer. Sealed class garanterar att when-grenen täcker alla möjliga typer — kompilatorn kontrollerar fullständigheten. Detta är typiskt för Android-projekt, där fabriken skapar olika implementationer av Repository eller DataSource beroende på build flavour eller konfiguration.

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: familjer av sammanlänkade objekt

Abstract Factory — ett mönster för att skapa familjer av sammanlänkade eller ömsesidigt beroende objekt utan att specificera deras konkreta klasser. Klienten arbetar med gränssnittet för den abstrakta fabriken, som definierar metoder för att skapa varje produkt i familjen. Den konkreta fabriken implementerar gränssnittet och skapar objekt av en specifik variant. Till exempel skapar en fabrik av UI-komponenter för iOS UIButton, UILabel, UITableView, och för Android — Button, TextView, RecyclerView.

Abstract Factory vs Factory Method — Factory Method skapar en typ av objekt genom arv, Abstract Factory skapar en familj av objekt genom komposition. Factory Method åsidosätts i subklasser, Abstract Factory tillhandahåller flera fabriksmetoder genom ett protokoll. Abstract Factory innehåller ofta flera Factory Method. Inom mobil utveckling används Abstract Factory för plattformsberoende komponenter, teman och databasfabriker.

Verkligt fall Abstract Factory i Android — implementering av olika databastyper (SQLite vs Room) genom ett enhetligt DatabaseFactory-gränssnitt. Fabriken skapar DAO-objekt, migreringar och anslutningspooler. I iOS — en servicefabrik för olika miljöer (Development/Staging/Production). Abstract Factory används sällan direkt — dess funktioner övertas av DI-containrar (Dagger Module, Swinject Assembly).

Factory i iOS: protokoll och statiska metoder

Swift Factory implementeras genom protokoll och statiska metoder. Protokollet Factory deklarerar metoden create() som returnerar en abstrakt typ. Den konkreta fabriken implementerar protokollet och skapar nödvändiga objekt. Swift kräver ingen separat fabriksklass för enkla fall — en statisk metod i enum eller struct räcker. För komplexa scenarier används Factory-protokollet med injicering genom DI.

Factory i iOS SDK — många systemfabriker: UIStoryboard.instantiateViewController(withIdentifier:), NSKeyedUnarchiver.unarchivedObject(ofClass:from:), JSONDecoder().decode(_:from:). Utvecklare skapar fabriker för ViewController (StoryboardFactory), för tjänster (ServiceFactory) och för datamodeller. Factory Method används aktivt i VIPER och Clean Swift-arkitekturer för att skapa skärmmoduler.

Factory + DI — modernt alternativ: DI-container (Swinject, Factory) genererar automatiskt fabriker för registrerade typer. Containern lagrar recept för objektsskapande och löser beroenden. Factory-biblioteket (github.com/hmlongco/Factory) använder @Injected(.service) för automatisk injicering. DI-fabriker testas genom att ersätta hela modulen med en rad: container.register { MockService() }.

Factory i Android: companion factory och DI-moduler

Android Factory — klassiskt exempel: ViewModelProvider.Factory för att skapa ViewModel med parametrar. Google rekommenderar att använda Hilt för automatisk generering av ViewModel-fabriker — @HiltViewModel-annotationen skapar Factory automatiskt. För enkla objekt används companion object med metoden create() eller invoke(). I Kotlin tillåter operatorn invoke att anropa fabriken som en funktion: Factory(param).

Factory i Jetpack Compose — fabriker används för att skapa tillstånd och effekter. remember { Factory.create() } skapar ett objekt vid första renderingen och behåller det under composable-objektets livstid. ViewModel i Compose skapas via viewModel() — detta är en fabrik som hanteras av Hilt. I Compose förekommer fabriker mindre explicit eftersom DI och Compose StateManager tar över objektsskapande.

Factory vs Hilt — Dagger/Hilt genererar automatiskt fabriker under kompileringsfasen. @Module + @Providers ersätter Factory Method, @Binds ersätter Abstract Factory. Manuella fabriker förblir relevanta för dynamiskt implementationsval under körning (A/B-testning, feature flags). För statiska beroenden automatiserar Hilt helt objektsskapandet — utvecklaren skriver bara gränssnittet och annotationerna.