Factory: la esencia de los patrones Factory Method y Abstract Factory

¿Qué es Factory: la esencia del patrón de creación de objetos?

Factory — un patrón de diseño creacional del catálogo GoF. La idea principal: mover la lógica de creación de objetos del código cliente a un método o clase separada. El cliente trabaja con una interfaz o clase abstracta, mientras que la implementación concreta es creada por la fábrica. Esto implementa el principio de Inversión de Dependencias: el cliente no depende de clases concretas, solo de abstracciones.

Dos variedades de Factory: Factory Method y Abstract Factory. Factory Method — un único método en una clase que las subclases sobrescriben para crear objetos. Abstract Factory — una interfaz con una familia de métodos de fábrica para crear grupos de objetos relacionados. Ambas variantes resuelven el mismo problema: el cliente no llama a new MyClass() directamente, sino que pide a la fábrica que cree un objeto según su tipo o parámetros.

Factory vs new() — la creación directa de objetos acopla firmemente el código a una implementación concreta. Factory añade una capa: cambiar la implementación requiere editar solo la fábrica, no todos los clientes. En el desarrollo móvil, Factory se utiliza activamente para crear ViewModel (ViewModelProvider.Factory), clientes de red (Retrofit.create()), adaptadores de lista y fábricas de serialización. Los contenedores DI (Dagger, Koin) generan fábricas automáticamente.

Factory Method: ejemplos en Swift y Kotlin

Factory Method — un método declarado en un protocolo o clase abstracta que devuelve un objeto de un tipo específico. Las subclases implementan el método, creando instancias concretas. En Swift, puede ser un método estático en un protocolo o un método en una clase base. En Kotlin — un companion object con un método de fábrica o open fun en una clase abstracta. El patrón se utiliza ampliamente para crear analizadores, fábricas de errores y constructores de consultas.

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

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

Versión Kotlin de Factory Method utiliza companion object o sealed class para limitar los tipos. Sealed class garantiza que la rama when cubra todos los tipos posibles — el compilador verifica la completitud. Esto es típico en proyectos Android donde la fábrica crea diferentes implementaciones de Repository o DataSource según el build flavour o la configuración.

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: familias de objetos relacionados

Abstract Factory — un patrón para crear familias de objetos relacionados o interdependientes sin especificar sus clases concretas. El cliente trabaja con la interfaz de la fábrica abstracta, que define métodos para crear cada producto de la familia. Una fábrica concreta implementa la interfaz y crea objetos de una variante específica. Por ejemplo, una fábrica de componentes UI para iOS crea UIButton, UILabel, UITableView, mientras que para Android — Button, TextView, RecyclerView.

Abstract Factory vs Factory Method — Factory Method crea un tipo de objeto mediante herencia, Abstract Factory crea una familia de objetos mediante composición. Factory Method se sobrescribe en subclases, Abstract Factory proporciona múltiples métodos de fábrica a través de un protocolo. Abstract Factory a menudo contiene varios Factory Method. En el desarrollo móvil, Abstract Factory se utiliza para componentes dependientes de plataforma, temas de diseño y fábricas de bases de datos.

Caso real de Abstract Factory en Android — implementación de diferentes tipos de bases de datos (SQLite vs Room) a través de una única interfaz DatabaseFactory. La fábrica crea objetos DAO, migraciones y pools de conexiones. En iOS — una fábrica de servicios para diferentes entornos (Development/Staging/Production). Abstract Factory rara vez se usa directamente — sus funciones son asumidas por contenedores DI (Dagger Module, Swinject Assembly).

Factory en iOS: protocolos y métodos estáticos

Swift Factory se implementa mediante protocolos y métodos estáticos. El protocolo Factory declara un método create() que devuelve un tipo abstracto. Una fábrica concreta implementa el protocolo y crea los objetos necesarios. Swift no requiere una clase de fábrica separada para casos simples — un método estático en un enum o struct es suficiente. Para escenarios complejos, se utiliza un protocolo Factory con inyección DI.

Factory en iOS SDK — muchas fábricas del sistema: UIStoryboard.instantiateViewController(withIdentifier:), NSKeyedUnarchiver.unarchivedObject(ofClass:from:), JSONDecoder().decode(_:from:). Los desarrolladores crean fábricas para ViewController (StoryboardFactory), para servicios (ServiceFactory) y para modelos de datos. Factory Method se utiliza activamente en las arquitecturas VIPER y Clean Swift para crear módulos de pantalla.

Factory + DI — una alternativa moderna: un contenedor DI (Swinject, Factory) genera automáticamente fábricas para tipos registrados. El contenedor almacena recetas de creación de objetos y resuelve dependencias. La librería Factory (github.com/hmlongco/Factory) usa @Injected(.service) para inyección automática. Las fábricas DI se prueban reemplazando un módulo completo con una sola línea: container.register { MockService() }.

Factory en Android: companion factory y módulos DI

Android Factory — un ejemplo clásico: ViewModelProvider.Factory para crear ViewModel con parámetros. Google recomienda usar Hilt para la generación automática de fábricas ViewModel — la anotación @HiltViewModel crea Factory automáticamente. Para objetos simples, se usa un companion object con método create() o invoke(). En Kotlin, el operador invoke permite llamar a la fábrica como una función: Factory(param).

Factory en Jetpack Compose — las fábricas se utilizan para crear estados y efectos. remember { Factory.create() } crea un objeto en el primer renderizado y lo conserva durante el ciclo de vida del composable. ViewModel en Compose se crea mediante viewModel() — esta es una fábrica gestionada por Hilt. En Compose, las fábricas son menos comunes explícitamente, ya que DI y Compose StateManager manejan la creación de objetos.

Factory vs Hilt — Dagger/Hilt genera automáticamente fábricas en tiempo de compilación. @Module + @Provides reemplaza Factory Method, @Binds reemplaza Abstract Factory. Las fábricas manuales siguen siendo relevantes para la selección dinámica de implementación en tiempo de ejecución (pruebas A/B, feature flags). Para dependencias estáticas, Hilt automatiza completamente la creación de objetos — el desarrollador solo escribe interfaces y anotaciones.