Abstract Factory
Fábrica abstracta · Kit
Ofrece una interfaz para crear familias de objetos relacionados sin especificar sus clases concretas.
“Necesito crear varios objetos que deben combinar entre sí (misma familia).”
workEl caso real
Tu producto SaaS se vende en la nube y también instalado en el centro de datos del cliente (on-premise). En la nube usas almacenamiento de objetos, una cola gestionada y un gestor de secretos; on-premise usas un disco en red, RabbitMQ y Vault. Lo crítico es que los tres servicios de un mismo entorno vayan juntos: mezclar la cola de la nube con el almacenamiento local rompe permisos y redes.
warningEl problema sin el patrón
Cada módulo crea sus servicios con if (entorno === "nube"). Basta con que alguien olvide un if para que en producción convivan piezas de entornos distintos, y el error solo aparece en la instalación del cliente.
check_circleCómo lo resuelve el patrón
Una fábrica abstracta, Infraestructura, declara crearAlmacenamiento(), crearCola() y crearSecretos(). Hay una fábrica concreta por entorno. Al arrancar se elige una sola fábrica, y todo lo que crea pertenece, por construcción, a la misma familia.
schemaDiagrama de clases
Diagrama interactivo: puedes acercar, mover el lienzo y pasar el cursor sobre cada clase para ver su detalle.
codeEl código, antes y después
const almacenamiento = entorno === 'nube' ? new AlmacenamientoNube() : new DiscoEnRed();
const cola = entorno === 'nube' ? new ColaGestionada() : new ColaRabbit();
// En otro archivo, alguien olvidó el if:
const secretos = new SecretosNube(); // ❌ on-premise no tiene este serviciointerface Infraestructura {
crearAlmacenamiento(): Almacenamiento;
crearCola(): Cola;
crearSecretos(): Secretos;
}
class InfraNube implements Infraestructura {
crearAlmacenamiento() { return new AlmacenamientoNube(); }
crearCola() { return new ColaGestionada(); }
crearSecretos() { return new SecretosNube(); }
}
class InfraOnPremise implements Infraestructura {
crearAlmacenamiento() { return new DiscoEnRed(); }
crearCola() { return new ColaRabbit(); }
crearSecretos() { return new SecretosVault(); }
}
// Se elige UNA vez, al arrancar la aplicación
const infra: Infraestructura = entorno === 'nube' ? new InfraNube() : new InfraOnPremise();Ejemplos en TypeScript, simplificados para mostrar la idea: los tipos auxiliares (Pedido, Cliente…) se omiten.
thumb_upCuándo usarlo
- ✓Debes crear varios objetos que tienen que ser compatibles entre sí.
- ✓Tu producto existe en variantes (proveedor, plataforma, tema visual) que cambian varias piezas a la vez.
do_not_disturb_onCuándo no usarlo
- ✕Solo creas un tipo de objeto: un Factory Method o una inyección simple es suficiente.
- ✕Las familias cambian de productos a menudo: añadir un producto obliga a modificar la interfaz y todas las fábricas.
- ✕Solo existe una familia: las interfaces y clases adicionales no se justifican.
memoryPrincipios en juego
- •Inversión de dependencias: los módulos usan interfaces (Cola, Almacenamiento), nunca clases de un proveedor.
- •Consistencia: la fábrica garantiza que los productos de una familia se usan juntos.
hubPatrones relacionados
- •Factory Method: cada método de la fábrica abstracta suele ser un método fábrica.
- •Singleton: normalmente hay una sola fábrica concreta activa en toda la aplicación.
- •Facade: una fachada puede usar una fábrica abstracta para ocultar cómo se crean los objetos del subsistema.
- •Bridge: cuando ciertas abstracciones solo funcionan con ciertas implementaciones, una fábrica abstracta puede crear las parejas correctas y ocultar esa regla.
quizPon a prueba lo que leíste
Dos preguntas al azar sobre este patrón. Cada vez que las cambias salen otras.
code_blocksAbstract Factory en tu lenguaje
El mismo caso, implementado completo y de forma idiomática. Se puede copiar y ejecutar.
LO IDIOMÁTICO EN TYPESCRIPT: Las familias se describen con interfaces y cada fábrica devuelve objetos literales que cumplen esas interfaces. La fábrica se elige con un Record<Entorno, ...> tipado en lugar de un switch: si añades un entorno al tipo, el compilador te obliga a registrar su fábrica.
export interface Almacenamiento { subir(nombre: string): string }
export interface Cola { publicar(mensaje: string): string }
export interface Secretos { leer(clave: string): string }
export interface Infraestructura {
crearAlmacenamiento(): Almacenamiento;
crearCola(): Cola;
crearSecretos(): Secretos;
}
class InfraNube implements Infraestructura {
crearAlmacenamiento(): Almacenamiento {
return { subir: (nombre) => `objetos-nube://facturas/${nombre}` };
}
crearCola(): Cola {
return { publicar: (mensaje) => `cola gestionada ← ${mensaje}` };
}
crearSecretos(): Secretos {
return { leer: (clave) => `gestor-de-secretos:${clave}` };
}
}
class InfraOnPremise implements Infraestructura {
crearAlmacenamiento(): Almacenamiento {
return { subir: (nombre) => `/mnt/nas/facturas/${nombre}` };
}
crearCola(): Cola {
return { publicar: (mensaje) => `RabbitMQ ← ${mensaje}` };
}
crearSecretos(): Secretos {
return { leer: (clave) => `vault:${clave}` };
}
}
type Entorno = 'nube' | 'on-premise';
const fabricas: Record<Entorno, () => Infraestructura> = {
'nube': () => new InfraNube(),
'on-premise': () => new InfraOnPremise(),
};
export function arrancar(entorno: Entorno) {
const infra = fabricas[entorno](); // se elige UNA vez; todo lo demás es de la misma familia
console.log(`[${entorno}]`);
console.log(' ', infra.crearAlmacenamiento().subir('F-001.pdf'));
console.log(' ', infra.crearCola().publicar('factura-emitida'));
console.log(' ', infra.crearSecretos().leer('certificado-firma'));
}
// ── Uso ──
arrancar('nube');
arrancar('on-premise');LO IDIOMÁTICO EN C# / .NET: Interfaces para cada producto y para la fábrica, y una expresión switch para elegir la familia; el descarte _ => throw hace que un entorno desconocido falle de forma explícita. En una aplicación real, la fábrica elegida se registraría una sola vez en el contenedor de inyección de dependencias.
foreach (var entorno in new[] { "nube", "on-premise", "marte" })
{
try
{
Arrancar(entorno);
}
catch (ArgumentException error)
{
Console.WriteLine($"error: {error.Message}"); // error: Entorno desconocido: marte
}
}
static void Arrancar(string entorno)
{
IInfraestructura infra = entorno switch
{
"nube" => new InfraNube(),
"on-premise" => new InfraOnPremise(),
_ => throw new ArgumentException($"Entorno desconocido: {entorno}"),
};
Console.WriteLine($"[{entorno}]");
Console.WriteLine($" {infra.CrearAlmacenamiento().Subir("F-001.pdf")}");
Console.WriteLine($" {infra.CrearCola().Publicar("factura-emitida")}");
Console.WriteLine($" {infra.CrearSecretos().Leer("certificado-firma")}");
}
public interface IAlmacenamiento { string Subir(string nombre); }
public interface ICola { string Publicar(string mensaje); }
public interface ISecretos { string Leer(string clave); }
public interface IInfraestructura
{
IAlmacenamiento CrearAlmacenamiento();
ICola CrearCola();
ISecretos CrearSecretos();
}
// ── Familia: nube ──
public class AlmacenamientoNube : IAlmacenamiento { public string Subir(string nombre) => $"objetos-nube://facturas/{nombre}"; }
public class ColaGestionada : ICola { public string Publicar(string mensaje) => $"cola gestionada ← {mensaje}"; }
public class SecretosNube : ISecretos { public string Leer(string clave) => $"gestor-de-secretos:{clave}"; }
public class InfraNube : IInfraestructura
{
public IAlmacenamiento CrearAlmacenamiento() => new AlmacenamientoNube();
public ICola CrearCola() => new ColaGestionada();
public ISecretos CrearSecretos() => new SecretosNube();
}
// ── Familia: on-premise ──
public class DiscoEnRed : IAlmacenamiento { public string Subir(string nombre) => $"/mnt/nas/facturas/{nombre}"; }
public class ColaRabbit : ICola { public string Publicar(string mensaje) => $"RabbitMQ ← {mensaje}"; }
public class SecretosVault : ISecretos { public string Leer(string clave) => $"vault:{clave}"; }
public class InfraOnPremise : IInfraestructura
{
public IAlmacenamiento CrearAlmacenamiento() => new DiscoEnRed();
public ICola CrearCola() => new ColaRabbit();
public ISecretos CrearSecretos() => new SecretosVault();
}LO IDIOMÁTICO EN JAVA: Cada familia es una constante de un enum que implementa la interfaz de la fábrica: así el catálogo de familias es cerrado y no se puede crear una fábrica "a medias". Como cada producto tiene un solo método, sus interfaces son funcionales y se implementan con lambdas.
void main() {
for (var entorno : Entorno.values()) {
arrancar(entorno);
}
try {
Entorno.valueOf("MARTE");
} catch (IllegalArgumentException error) {
IO.println("error: entorno desconocido"); // valueOf falla con un nombre que no existe
}
}
void arrancar(Entorno entorno) {
Infraestructura infra = entorno; // se elige UNA vez; todo lo demás es de la misma familia
IO.println("[" + entorno + "]");
IO.println(" " + infra.crearAlmacenamiento().subir("F-001.pdf"));
IO.println(" " + infra.crearCola().publicar("factura-emitida"));
IO.println(" " + infra.crearSecretos().leer("certificado-firma"));
}
@FunctionalInterface
interface Almacenamiento { String subir(String nombre); }
@FunctionalInterface
interface Cola { String publicar(String mensaje); }
@FunctionalInterface
interface Secretos { String leer(String clave); }
interface Infraestructura {
Almacenamiento crearAlmacenamiento();
Cola crearCola();
Secretos crearSecretos();
}
enum Entorno implements Infraestructura {
NUBE {
@Override public Almacenamiento crearAlmacenamiento() { return nombre -> "objetos-nube://facturas/" + nombre; }
@Override public Cola crearCola() { return mensaje -> "cola gestionada ← " + mensaje; }
@Override public Secretos crearSecretos() { return clave -> "gestor-de-secretos:" + clave; }
},
ON_PREMISE {
@Override public Almacenamiento crearAlmacenamiento() { return nombre -> "/mnt/nas/facturas/" + nombre; }
@Override public Cola crearCola() { return mensaje -> "RabbitMQ ← " + mensaje; }
@Override public Secretos crearSecretos() { return clave -> "vault:" + clave; }
}
}LO IDIOMÁTICO EN JAVASCRIPT: Una fábrica puede ser un simple objeto con funciones que crean cada producto de la familia, sin clases. Object.freeze evita que alguien reemplace una pieza de la familia en tiempo de ejecución, y un objeto literal hace de catálogo de fábricas.
const infraNube = Object.freeze({
crearAlmacenamiento: () => ({ subir: (nombre) => `objetos-nube://facturas/${nombre}` }),
crearCola: () => ({ publicar: (mensaje) => `cola gestionada ← ${mensaje}` }),
crearSecretos: () => ({ leer: (clave) => `gestor-de-secretos:${clave}` }),
});
const infraOnPremise = Object.freeze({
crearAlmacenamiento: () => ({ subir: (nombre) => `/mnt/nas/facturas/${nombre}` }),
crearCola: () => ({ publicar: (mensaje) => `RabbitMQ ← ${mensaje}` }),
crearSecretos: () => ({ leer: (clave) => `vault:${clave}` }),
});
const fabricas = { 'nube': infraNube, 'on-premise': infraOnPremise };
export function arrancar(entorno) {
const infra = fabricas[entorno]; // se elige UNA vez
if (!infra) throw new Error(`Entorno desconocido: ${entorno}`);
console.log(`[${entorno}]`);
console.log(' ', infra.crearAlmacenamiento().subir('F-001.pdf'));
console.log(' ', infra.crearCola().publicar('factura-emitida'));
console.log(' ', infra.crearSecretos().leer('certificado-firma'));
}
// ── Uso ──
arrancar('nube');
arrancar('on-premise');
try {
arrancar('marte');
} catch (error) {
console.log(error.message); // Entorno desconocido: marte
}LO IDIOMÁTICO EN PYTHON: Productos y fábrica se describen con Protocol: cualquier clase con los métodos correctos sirve, sin herencia. Las clases se pueden usar directamente como fábricas (son "llamables"), así que el catálogo es un diccionario de clases, y el entorno se tipa con Literal.
from collections.abc import Callable
from typing import Literal, Protocol
class Almacenamiento(Protocol):
def subir(self, nombre: str) -> str: ...
class Cola(Protocol):
def publicar(self, mensaje: str) -> str: ...
class Secretos(Protocol):
def leer(self, clave: str) -> str: ...
class Infraestructura(Protocol):
def crear_almacenamiento(self) -> Almacenamiento: ...
def crear_cola(self) -> Cola: ...
def crear_secretos(self) -> Secretos: ...
# ── Familia: nube ──
class AlmacenamientoNube:
def subir(self, nombre: str) -> str:
return f"objetos-nube://facturas/{nombre}"
class ColaGestionada:
def publicar(self, mensaje: str) -> str:
return f"cola gestionada ← {mensaje}"
class SecretosNube:
def leer(self, clave: str) -> str:
return f"gestor-de-secretos:{clave}"
class InfraNube:
def crear_almacenamiento(self) -> Almacenamiento:
return AlmacenamientoNube()
def crear_cola(self) -> Cola:
return ColaGestionada()
def crear_secretos(self) -> Secretos:
return SecretosNube()
# ── Familia: on-premise ──
class DiscoEnRed:
def subir(self, nombre: str) -> str:
return f"/mnt/nas/facturas/{nombre}"
class ColaRabbit:
def publicar(self, mensaje: str) -> str:
return f"RabbitMQ ← {mensaje}"
class SecretosVault:
def leer(self, clave: str) -> str:
return f"vault:{clave}"
class InfraOnPremise:
def crear_almacenamiento(self) -> Almacenamiento:
return DiscoEnRed()
def crear_cola(self) -> Cola:
return ColaRabbit()
def crear_secretos(self) -> Secretos:
return SecretosVault()
Entorno = Literal["nube", "on-premise"]
FABRICAS: dict[str, Callable[[], Infraestructura]] = {
"nube": InfraNube,
"on-premise": InfraOnPremise,
}
def arrancar(entorno: Entorno) -> None:
infra = FABRICAS[entorno]() # se elige UNA vez; todo lo demás es de la misma familia
print(f"[{entorno}]")
print(" ", infra.crear_almacenamiento().subir("F-001.pdf"))
print(" ", infra.crear_cola().publicar("factura-emitida"))
print(" ", infra.crear_secretos().leer("certificado-firma"))
if __name__ == "__main__":
arrancar("nube")
arrancar("on-premise")LO IDIOMÁTICO EN GO: Las interfaces son implícitas y pequeñas: cada producto tiene un solo método. Las fábricas son structs vacíos que cumplen Infraestructura sin declararlo, y el catálogo es un mapa de funciones constructoras. Un entorno desconocido se devuelve como error.
package main
import "fmt"
type Almacenamiento interface{ Subir(nombre string) string }
type Cola interface{ Publicar(mensaje string) string }
type Secretos interface{ Leer(clave string) string }
type Infraestructura interface {
CrearAlmacenamiento() Almacenamiento
CrearCola() Cola
CrearSecretos() Secretos
}
// ── Familia: nube ──
type almacenamientoNube struct{}
type colaGestionada struct{}
type secretosNube struct{}
func (almacenamientoNube) Subir(nombre string) string { return "objetos-nube://facturas/" + nombre }
func (colaGestionada) Publicar(mensaje string) string { return "cola gestionada ← " + mensaje }
func (secretosNube) Leer(clave string) string { return "gestor-de-secretos:" + clave }
type infraNube struct{}
func (infraNube) CrearAlmacenamiento() Almacenamiento { return almacenamientoNube{} }
func (infraNube) CrearCola() Cola { return colaGestionada{} }
func (infraNube) CrearSecretos() Secretos { return secretosNube{} }
// ── Familia: on-premise ──
type discoEnRed struct{}
type colaRabbit struct{}
type secretosVault struct{}
func (discoEnRed) Subir(nombre string) string { return "/mnt/nas/facturas/" + nombre }
func (colaRabbit) Publicar(mensaje string) string { return "RabbitMQ ← " + mensaje }
func (secretosVault) Leer(clave string) string { return "vault:" + clave }
type infraOnPremise struct{}
func (infraOnPremise) CrearAlmacenamiento() Almacenamiento { return discoEnRed{} }
func (infraOnPremise) CrearCola() Cola { return colaRabbit{} }
func (infraOnPremise) CrearSecretos() Secretos { return secretosVault{} }
var fabricas = map[string]func() Infraestructura{
"nube": func() Infraestructura { return infraNube{} },
"on-premise": func() Infraestructura { return infraOnPremise{} },
}
func arrancar(entorno string) error {
nueva, existe := fabricas[entorno]
if !existe {
return fmt.Errorf("entorno desconocido: %s", entorno)
}
infra := nueva() // se elige UNA vez; todo lo demás es de la misma familia
fmt.Printf("[%s]\n", entorno)
fmt.Println(" ", infra.CrearAlmacenamiento().Subir("F-001.pdf"))
fmt.Println(" ", infra.CrearCola().Publicar("factura-emitida"))
fmt.Println(" ", infra.CrearSecretos().Leer("certificado-firma"))
return nil
}
func main() {
for _, entorno := range []string{"nube", "on-premise", "marte"} {
if err := arrancar(entorno); err != nil {
fmt.Println("error:", err) // error: entorno desconocido: marte
}
}
}LO IDIOMÁTICO EN RUST: La fábrica declara sus productos como tipos asociados (type Almacenamiento), así la consistencia de la familia la comprueba el compilador: con InfraNube es imposible obtener una cola de RabbitMQ. La función genérica arrancar se resuelve en compilación, sin objetos dinámicos (dyn).
trait Almacenamiento {
fn subir(&self, nombre: &str) -> String;
}
trait Cola {
fn publicar(&self, mensaje: &str) -> String;
}
trait Secretos {
fn leer(&self, clave: &str) -> String;
}
trait Infraestructura {
type Almacenamiento: Almacenamiento;
type Cola: Cola;
type Secretos: Secretos;
fn crear_almacenamiento(&self) -> Self::Almacenamiento;
fn crear_cola(&self) -> Self::Cola;
fn crear_secretos(&self) -> Self::Secretos;
}
// ── Familia: nube ──
struct AlmacenamientoNube;
struct ColaGestionada;
struct SecretosNube;
impl Almacenamiento for AlmacenamientoNube {
fn subir(&self, nombre: &str) -> String {
format!("objetos-nube://facturas/{nombre}")
}
}
impl Cola for ColaGestionada {
fn publicar(&self, mensaje: &str) -> String {
format!("cola gestionada ← {mensaje}")
}
}
impl Secretos for SecretosNube {
fn leer(&self, clave: &str) -> String {
format!("gestor-de-secretos:{clave}")
}
}
struct InfraNube;
impl Infraestructura for InfraNube {
type Almacenamiento = AlmacenamientoNube;
type Cola = ColaGestionada;
type Secretos = SecretosNube;
fn crear_almacenamiento(&self) -> AlmacenamientoNube {
AlmacenamientoNube
}
fn crear_cola(&self) -> ColaGestionada {
ColaGestionada
}
fn crear_secretos(&self) -> SecretosNube {
SecretosNube
}
}
// ── Familia: on-premise ──
struct DiscoEnRed;
struct ColaRabbit;
struct SecretosVault;
impl Almacenamiento for DiscoEnRed {
fn subir(&self, nombre: &str) -> String {
format!("/mnt/nas/facturas/{nombre}")
}
}
impl Cola for ColaRabbit {
fn publicar(&self, mensaje: &str) -> String {
format!("RabbitMQ ← {mensaje}")
}
}
impl Secretos for SecretosVault {
fn leer(&self, clave: &str) -> String {
format!("vault:{clave}")
}
}
struct InfraOnPremise;
impl Infraestructura for InfraOnPremise {
type Almacenamiento = DiscoEnRed;
type Cola = ColaRabbit;
type Secretos = SecretosVault;
fn crear_almacenamiento(&self) -> DiscoEnRed {
DiscoEnRed
}
fn crear_cola(&self) -> ColaRabbit {
ColaRabbit
}
fn crear_secretos(&self) -> SecretosVault {
SecretosVault
}
}
fn arrancar<I: Infraestructura>(nombre: &str, infra: &I) {
println!("[{nombre}]");
println!(" {}", infra.crear_almacenamiento().subir("F-001.pdf"));
println!(" {}", infra.crear_cola().publicar("factura-emitida"));
println!(" {}", infra.crear_secretos().leer("certificado-firma"));
}
fn main() {
// El entorno se elige UNA vez; a partir de ahí, todo es de la misma familia
for entorno in ["nube", "on-premise", "marte"] {
match entorno {
"nube" => arrancar(entorno, &InfraNube),
"on-premise" => arrancar(entorno, &InfraOnPremise),
otro => println!("error: entorno desconocido: {otro}"),
}
}
}LO IDIOMÁTICO EN PHP: Los entornos son un enum respaldado por texto: Entorno::from('nube') convierte la configuración en un caso válido o lanza ValueError. El método fabrica() usa match para devolver la fábrica concreta de cada familia.
<?php
declare(strict_types=1);
interface Almacenamiento { public function subir(string $nombre): string; }
interface Cola { public function publicar(string $mensaje): string; }
interface Secretos { public function leer(string $clave): string; }
interface Infraestructura
{
public function crearAlmacenamiento(): Almacenamiento;
public function crearCola(): Cola;
public function crearSecretos(): Secretos;
}
// ── Familia: nube ──
final class AlmacenamientoNube implements Almacenamiento { public function subir(string $nombre): string { return "objetos-nube://facturas/{$nombre}"; } }
final class ColaGestionada implements Cola { public function publicar(string $mensaje): string { return "cola gestionada ← {$mensaje}"; } }
final class SecretosNube implements Secretos { public function leer(string $clave): string { return "gestor-de-secretos:{$clave}"; } }
final class InfraNube implements Infraestructura
{
public function crearAlmacenamiento(): Almacenamiento { return new AlmacenamientoNube(); }
public function crearCola(): Cola { return new ColaGestionada(); }
public function crearSecretos(): Secretos { return new SecretosNube(); }
}
// ── Familia: on-premise ──
final class DiscoEnRed implements Almacenamiento { public function subir(string $nombre): string { return "/mnt/nas/facturas/{$nombre}"; } }
final class ColaRabbit implements Cola { public function publicar(string $mensaje): string { return "RabbitMQ ← {$mensaje}"; } }
final class SecretosVault implements Secretos { public function leer(string $clave): string { return "vault:{$clave}"; } }
final class InfraOnPremise implements Infraestructura
{
public function crearAlmacenamiento(): Almacenamiento { return new DiscoEnRed(); }
public function crearCola(): Cola { return new ColaRabbit(); }
public function crearSecretos(): Secretos { return new SecretosVault(); }
}
enum Entorno: string
{
case Nube = 'nube';
case OnPremise = 'on-premise';
public function fabrica(): Infraestructura
{
return match ($this) {
self::Nube => new InfraNube(),
self::OnPremise => new InfraOnPremise(),
};
}
}
foreach (['nube', 'on-premise', 'marte'] as $configuracion) {
try {
$infra = Entorno::from($configuracion)->fabrica(); // se elige UNA vez
echo "[{$configuracion}]\n";
echo ' ', $infra->crearAlmacenamiento()->subir('F-001.pdf'), "\n";
echo ' ', $infra->crearCola()->publicar('factura-emitida'), "\n";
echo ' ', $infra->crearSecretos()->leer('certificado-firma'), "\n";
} catch (ValueError) {
echo "error: entorno desconocido: {$configuracion}\n";
}
}