DEV Community

Yuri Peixinho
Yuri Peixinho

Posted on

Abstract Factory

Introdução

Imagine que temos um sistema em que há no código diversos new ClasseConcreta(). Essa prática, que é comum em aplicações criar dois tipos de problemas, que piora a medida que o sistema evolui.

O primeiro problema é o acoplamento direto entre classes concretas. Se um sistema escreve new BotaoWindows() diretamente, ele não funciona em outro contexto (Mac, Linux, tema escuro) sem ter que reescrever essas linhas. Viola o Princípio da Inversão de Dependência, que diz que módulos de alto nível não devem depender de detalhes de implementaçõa.

O segundo problema é mais sutil e é o que de fato motiva o Abstract Factory: nada garante que os objetos criados em pontos diferentes do código são compatíveis entre si. Se um botão "estilo Windows" é criado em um lugar e uma scrollbar "estilo Mac" é criada em outro, nada impede que os dois acabem compondo a mesma tela, um bug visual silencioso, que só aparece em produção.

O exemplo canônico do próprio catálogo GoF (1994) é exatamente esse: bibliotecas de interface gráfica que precisam renderizar os mesmos componentes como botão, checkbox e scrollbar com aparências diferentes por sistema operacional. É o caso mais didático porque a família de objetos é visualmente óbvia: ou tudo é Windows, ou tudo é Mac, nunca uma mistura.

Motivação prática

Uma dúvida natural nesse ponto: por que não resolver isso com um Factory Method, uma fábrica simples que cria o botão certo? A resposta é que Factory Method resolve a criação de um objeto por vez, mas não oferece nenhum mecanismo para garantir que vários objetos criados juntos pertencem à mesma variante.

Imagine três Factory Methods isolados: CriarBotao(), CriarCheckbox(), CriarScrollbar(), cada um decidindo individualmente se retorna a versão Windows ou Mac. Nada no código impede que, por um erro de configuração ou uma falha de propagação de contexto, um deles decida errado — o botão vem Windows e a scrollbar vem Mac, porque as três decisões são independentes entre si.

O Abstract Factory resolve isso amarrando as três decisões em um único objeto: a fábrica concreta. Ao obter a fábrica uma única vez, o código cliente tem a garantia estrutural de que qualquer componente que ele pedir dali em diante pertence à mesma família, porque todos vêm do mesmo objeto, que só sabe criar uma variante.

Definição formal e papéis

A definição do GoF: "Fornecer uma interface para criar famílias de objetos relacionados ou dependentes, sem especificar suas classes concretas."

O padrão define cinco papéis, e vale fixar o vocabulário exato — ele torna a comunicação em revisão de código muito mais precisa do que descrever o mecanismo por extenso:

Papel GoF Responsabilidade No exemplo da UI
AbstractFactory Interface que declara um método de criação por produto da família IUiComponentFactory
ConcreteFactory Implementa a interface, garantindo que todos os produtos retornados sejam da mesma variante WindowsUiFactory, MacUiFactory
AbstractProduct Interface de um dos produtos da família IBotao, ICheckbox, IScrollbar
ConcreteProduct Implementação concreta de um produto, pertencente a uma variante específica BotaoWindows, CheckboxMac
Client Código que usa apenas as interfaces abstratas, nunca referenciando um tipo concreto diretamente O código de renderização da tela

O ponto que mais gera confusão: o Client conhece a AbstractFactory e as interfaces de produto, mas nunca, em nenhuma circunstância, referencia uma ConcreteFactory ou um ConcreteProduct diretamente no código — essa referência existe só no ponto de composição, normalmente a configuração de injeção de dependência.

Estrutura

!image.png

O Client depende só da AbstractFactory; cada ConcreteFactory amarra a criação de três produtos (IBotao, ICheckbox, IScrollbar) em uma única família consistente, impedindo que um produto de uma variante seja misturado com o de outra.

Implementação em código

// Interfaces de produto (AbstractProduct)
public interface IBotao
{
    void Renderizar();
}

public interface ICheckbox
{
    void Renderizar();
}

public interface IScrollbar
{
    void Renderizar();
}

// Produtos concretos — variante Windows
public class BotaoWindows : IBotao
{
    public void Renderizar() => Console.WriteLine("Botão estilo Windows");
}

public class CheckboxWindows : ICheckbox
{
    public void Renderizar() => Console.WriteLine("Checkbox estilo Windows");
}

public class ScrollbarWindows : IScrollbar
{
    public void Renderizar() => Console.WriteLine("Scrollbar estilo Windows");
}

// Produtos concretos — variante Mac
public class BotaoMac : IBotao
{
    public void Renderizar() => Console.WriteLine("Botão estilo Mac");
}

public class CheckboxMac : ICheckbox
{
    public void Renderizar() => Console.WriteLine("Checkbox estilo Mac");
}

public class ScrollbarMac : IScrollbar
{
    public void Renderizar() => Console.WriteLine("Scrollbar estilo Mac");
}

// AbstractFactory
public interface IUiComponentFactory
{
    IBotao CriarBotao();
    ICheckbox CriarCheckbox();
    IScrollbar CriarScrollbar();
}

// ConcreteFactory — Windows
public class WindowsUiFactory : IUiComponentFactory
{
    public IBotao CriarBotao() => new BotaoWindows();
    public ICheckbox CriarCheckbox() => new CheckboxWindows();
    public IScrollbar CriarScrollbar() => new ScrollbarWindows();
}

// ConcreteFactory — Mac
public class MacUiFactory : IUiComponentFactory
{
    public IBotao CriarBotao() => new BotaoMac();
    public ICheckbox CriarCheckbox() => new CheckboxMac();
    public IScrollbar CriarScrollbar() => new ScrollbarMac();
}

// Client — nunca referencia um tipo concreto
public class Tela
{
    private readonly IUiComponentFactory _factory;

    public Tela(IUiComponentFactory factory) => _factory = factory;

    public void Renderizar()
    {
        _factory.CriarBotao().Renderizar();
        _factory.CriarCheckbox().Renderizar();
        _factory.CriarScrollbar().Renderizar();
    }
}
Enter fullscreen mode Exit fullscreen mode

Repare que Tela recebe a fábrica pronta — normalmente via injeção de dependência — e nunca decide sozinha qual variante usar. Trocar de Windows para Mac é uma troca de uma única linha de configuração, não uma mudança espalhada pelo código.

Abstract Factory vs. Factory Method

Esse é o ponto de confusão mais comum entre os dois padrões criacionais, e vale a pena fixar a diferença de uma vez.

Na prática, é comum uma Abstract Factory usar Factory Methods internamente, cada CriarBotao(), CriarCheckbox() dentro de uma ConcreteFactory é, isoladamente, um Factory Method. A diferença está em um nível acima: o Abstract Factory agrupa vários desses métodos em uma interface única, para que a escolha da variante seja feita uma vez só, não a cada chamada.

Factory Method Abstract Factory
O que cria Um único produto Uma família inteira de produtos relacionados
Mecanismo Herança/polimorfismo — uma subclasse sobrescreve o método de criação Composição — um objeto (a fábrica) agrupa vários métodos de criação
O que garante Que o tipo certo de produto seja criado Que vários produtos criados juntos sejam compatíveis entre si
Quando usar sozinho Uma única decisão de criação varia Mais de um produto varia junto, pela mesma razão (ex.: mesmo tema, mesma plataforma)

Quando usar e quando não usar

O critério de decisão central é: qual eixo de variação cresce mais rápido na prática?

  • Se novas famílias inteiras (novas plataformas, novos temas, novos fornecedores) aparecem com frequência, e o conjunto de produtos dentro de cada família é relativamente estável, o padrão compensa, adicionar uma família nova é uma classe nova, sem tocar nas existentes.
  • Se, ao contrário, novos tipos de produto dentro da família aparecem com frequência (um componente novo que toda variante precisa suportar), o padrão cobra um preço alto porque cada produto novo exige alterar todas as ConcreteFactory existentes, mesmo as que ainda não suportam aquele componente.

Na dúvida, comece sem o padrão. Introduza-o no momento em que adicionar uma segunda ou terceira variante exigiria trocar manualmente três ou mais classes em vários pontos do código — esse é o sinal concreto de que a indireção está pagando seu próprio custo.

Conclusão

Abstract Factory não é sobre criar objetos, é sobre garantir que um conjunto de objetos criados juntos permaneça consistente, movendo essa garantia de uma convenção implícita ("lembre de criar tudo da mesma variante") para uma estrutura que torna o erro mais difícil de acontecer. O preço dessa garantia é uma interface que cresce junto com cada novo tipo de produto da família e por isso a decisão de adotar o padrão é, na prática, uma aposta sobre qual eixo do seu sistema vai crescer mais: famílias novas, ou produtos novos dentro das famílias existentes.

Top comments (0)