Abstract Factory — Implementando o Padrão de Projeto com ASP.NET 5 WEB API
Published: 2021-09-10 15:16:11

Olá pessoal, hoje vamos abordar um assunto bem legal dentro do mundo de programação. Vou colocar aqui e também em meu canal no [youtube](https://www.youtube.com/channel/UC0Vo6yL26XaraIjak87jDww) uma série de artigos e vídeos sobre **Padrões de Projeto ou Design Patterns.**

Neste artigo vamos abordar como implementar o Padrão de Projeto **“Abstract Factory”** em uma API Rest utilizando o C# como linguagem de programação.

Antes de mais nada, é super importante que vocês estejam confortáveis com os conceitos do paradigma de **Programação Orientada a Objetos e SOLID.**

Caso queiram entender e praticar os conceitos de SOLID, podem assistir esse vídeo [aqui](https://www.eduardopires.net.br/2015/01/solid-teoria-e-pratica/) do Eduardo Pires.

Bom pessoal, sem mais delongas, vamos lá!

O que é o padrão de projeto **Abstract Factory?**

O Abstract Factory faz parte da família de padrões [“criacionais”](https://refactoring.guru/pt-br/design-patterns/creational-patterns). Um padrão de projeto criacional nos permite fazer uso de mecanismos para a criação de objetos, aumentando a flexibilidade e reutilização do nosso código, nos ajuda também a alcançar uma alta coesão e baixo acoplamento.

Em termos técnicos o Abstract Factory nos permite criar familias de objetos relacionados ou dependentes, sem a necessidade de especificar suas classes concretas.

Calma, para alguns pode ser um pouco confuso entender o que exatamente esse padrão de projeto faz, mas vamos aos poucos. O Abstract Factory possui alguns participantes, vamos entender cada um deles e suas responsabilidades.

Os participantes são:

**Abstract Factory:** Conhecido como “Fábrica de produtos abstratos”, este é responsável por criar classes/produtos abstratos. Ou seja, dentro dessa classe criaremos métodos abstratos que retornam para quem o chama uma classe/produto abstrato.

**Concrete Factory:** Conhecido como “Fábrica de produtos concretos”, este é responsável por criar classes/produtos concretos. Ou seja, dentro dessa classe implementaremos os métodos herdados da nossa fábrica abstrata, mas ao invés de retornar uma classe/produto abstrato, retornaremos uma classe/produto concreto.

**Abstract product:** Conhecido como “Produto abstrato”, este é apenas uma classe/produto abstrata que definimos para exemplificar alguma coisa do mundo real.

**Concrete product:** Conhecido como “Produto concreto”, este é apenas uma classe/produto concreto, onde implementamos uma classe/produto abstrata.

**Client:** Este entendemos como consumidor, porém, essa classe apenas consome os produtos abstratos gerados a partir de nossas fabricas abstratas. O Client não é obrigado a saber como as coisas estão sendo implementadas, por isso ele consome apenas a fábrica abstrata e produtos abstratos.

Esses diagramas abaixo, são utilizados para exemplificar esses participantes, veja:
![Alt Text](https://dev-to-uploads.s3.amazonaws.com/uploads/articles/e3dmtwsa7gy9dp8p0omk.png)<center>[Referência](https://refactoring.guru/pt-br/design-patterns/abstract-factory)</center>

Temos também este aqui:

![Alt Text](https://dev-to-uploads.s3.amazonaws.com/uploads/articles/7fb1x5y6iwaz3otg51au.png)<center>[Referência](https://www.dofactory.com/net/abstract-factory-design-pattern)</center>

Bom, depois de toda essa teoria sobre o Abstract Factory, vocês devem estar se perguntando: “Tá, e ai? Como implementar isso na prática?”.

Eu criei uma demo de uma API utilizando ASP.NET 5 e C#.

Vamos lá!!!!

É importante termos instalado na máquina o [Visual Studio Community](https://visualstudio.microsoft.com/pt-br/vs/community/) e também o [SDK do .NET 5](https://dotnet.microsoft.com/download).

Vamos criar um novo projeto no Visual Studio do tipo ASP.NET Core Web API.

![Alt Text](https://dev-to-uploads.s3.amazonaws.com/uploads/articles/ihwbijzhaale8i21h2yb.png)

Escolha um nome para seu projeto e o local onde será salvo.

![Alt Text](https://dev-to-uploads.s3.amazonaws.com/uploads/articles/v9y2czztaolxjl3amn0a.png)

E por último e selecione a versão do .NET 5, caso vocês tenha outras versões.

![Alt Text](https://dev-to-uploads.s3.amazonaws.com/uploads/articles/y7527t2765t5ju4o4kqr.png)

Legal, com o nosso projeto criado podemos agora começar a implementar de fato o nosso padrão de projeto. Primeiramente vamos remover as classes que são criadas automaticamente para nós. Podemos excluir os arquivos “WeatherForecast.cs” e “WeatherForecastController.cs”.

Ótimo, agora podemos começar a criar os diretórios para separar a nossa aplicação em responsabilidades especificas. Vamos lá, no seu Visual Studio crie as seguintes pastas (Clients, Domain, Factories) conforme imagem:

![Alt Text](https://dev-to-uploads.s3.amazonaws.com/uploads/articles/dll90w1e6kdp9fi0drb4.png)

Agora de fato vamos começar a colocar a mão na massa e aplicar o padrão de projeto. Mas antes, gostaria apenas de explicar qual vai ser o nosso cenário.

Imaginem que vocês tem um cliente que possui uma loja de alimentos e esta loja é especialista na venda de alimentos/embalagens orgânicas e inorgânicas. A partir disso, o cliente pediu que fosse construida uma API Rest para retornar uma lista de produtos de acordo com o tipo que ele especificar na chamada HTTP, podendo ele ser “Orgânico” ou “Inorgânico”.

Ótimo, depois de entender a necessidade… bora meter a mão no código.

Vamos criar primeiramente os nossos produtos abstratos, pensando no contexto da nossa aplicação os nossos produtos inicialmente serão: “Food” e “Packing”.

![Alt Text](https://dev-to-uploads.s3.amazonaws.com/uploads/articles/u6druriwnh59ustjujrq.png)

Como esses caras vão ser nossos produtos abstratos, que serão herdados por produtos concretos e utilizados na nossa fábrica abstrata, criei uma pasta “Base” e coloquei as classes lá dentro.

Food e Packing vão ficar assim, respectivamente:

![Alt Text](https://dev-to-uploads.s3.amazonaws.com/uploads/articles/iaya0zkewpi2zgs6696a.png)

![Alt Text](https://dev-to-uploads.s3.amazonaws.com/uploads/articles/iwqal5nupyp9xkmecq5d.png)

Podemos criar também o enum “TypeProduct” que identifica qual o tipo de produto. A classe ficaria assim:

![Alt Text](https://dev-to-uploads.s3.amazonaws.com/uploads/articles/deaspaf02tvsvyb5776q.png)

![Alt Text](https://dev-to-uploads.s3.amazonaws.com/uploads/articles/8dossng73kl32wxbm1wl.png)

Vamos aproveitar e já criar também os nossos produtos concretos, ou seja, as classes que vão implementar nossos produtos abstratos. Se pararmos para pensar um pouco, os nossos produtos concretos vão ser: “FoodOrganic”, “FoodInorganic”, “PackingOrganic” e “PackingInorganic”. Bora implementar essas classes.

Primeiramente crie os arquivos na pasta Domain, dessa forma:

![Alt Text](https://dev-to-uploads.s3.amazonaws.com/uploads/articles/lguypdhrlu8qb5s7qoxh.png)

E agora as implementações das nossas classes/produtos concretos:

![Alt Text](https://dev-to-uploads.s3.amazonaws.com/uploads/articles/llzvqgqe776b7uc6la8o.png)

![Alt Text](https://dev-to-uploads.s3.amazonaws.com/uploads/articles/eob21y2lwq651eb9gr3s.png)

![Alt Text](https://dev-to-uploads.s3.amazonaws.com/uploads/articles/x0jrliuswu12rjd6ju40.png)

![Alt Text](https://dev-to-uploads.s3.amazonaws.com/uploads/articles/xsj7wtsgkj0pbe39ifka.png)

Depois de criarmos os nossos produtos abstratos e também os produtos concretos, podemos começar a pensar em como vai ficar a nossa fábrica abstrata. Temos em mente que a nossa fábrica é responsável por criar produtos abstratos, então, já sabemos que ela vai ser responsável por criar para nós os produtos Food e Packing.

Vamos a criação da classe, dentro do diretório Factories crie um outro diretório chamado “AbstractFactories” e dentro dele crie a classe “ProductFactory”, vamos criar nessa classe dois métodos abstratos responsáveis por criar nossos produtos abstratos Food e Packing.

Localização do arquivo nos diretórios:

![Alt Text](https://dev-to-uploads.s3.amazonaws.com/uploads/articles/klz3k4ntaw51btflc13v.png)

Nossa fábrica ficará assim:

![Alt Text](https://dev-to-uploads.s3.amazonaws.com/uploads/articles/lsb4vbl60tvetzpkfz8r.png)

Beleza pessoal, chegamos até aqui, não vamos desistir hein… Bom, depois criar nossas fábricas abstratas nos resta implementar nossas fábricas concretas, essas que serão responsáveis por criar nossos produtos concretos “FoodInorganic”, “FoodOrganic”, “PackingInorganic ”e “PackingOrganic”.

Vamos lá!

Dentro do diretório “Factories ” crie duas classes com os seguintes nomes: “ProductOrganicFactory” e “ProductInorganicFactory”. Não podemos esquecer de que nossas fábricas concretas vão herdar de nossa fábrica abstrata, com isso vamos ter a responsabilidade de implementar os métodos abstratos da nossa fábrica abstrata, ou seja, vamos especializar esses carinhas em nossas fábricas concretas.

Localização dos arquivos no diretório:

![Alt Text](https://dev-to-uploads.s3.amazonaws.com/uploads/articles/jd7ucgbwfrl8y207iy2s.png)

Nossas fábricas ficarão assim:

![Alt Text](https://dev-to-uploads.s3.amazonaws.com/uploads/articles/5pfvz36udyl8cxp7quah.png)

![Alt Text](https://dev-to-uploads.s3.amazonaws.com/uploads/articles/vxp4l6j17mlmvshgmobx.png)

Depois de implementar nossos produtos e fabricas, sendo eles abstratos e concretos só nos falta implementar nosso “Client”. Vamos nessa!

Dentro do diretório “Clients” crie a classe “ProductClient”, vou explicar a implementação do nosso client em partes para ficar mais fácil de apresentar o que foi feito.

![Alt Text](https://dev-to-uploads.s3.amazonaws.com/uploads/articles/w0nkzmstfv44bqg6f3vf.png)

Primeiramente criamos duas propriedades na nossa classes dos nossos produtos abstratos. Ficando assim:

![Alt Text](https://dev-to-uploads.s3.amazonaws.com/uploads/articles/9xfmg3izxx2o6zshtasr.png)

Depois criamos o nosso construtor:

![Alt Text](https://dev-to-uploads.s3.amazonaws.com/uploads/articles/szdyqh0hgkn4w80tklkl.png)

Repare que o nosso construtor esta um pouco diferente do que normalmente fazemos com a famosa injeção de dependência hahaha, mas calma, vamos entender o porque estamos fazendo assim.

Nós temos dentro da nossa classe “ProductClient” duas propriedades privadas somente leitura, essas propriedades representam os nossos produtos abstratos.

No nosso construtor estamos recebendo como parâmetro o “ProductFactory”, que nada mais é do que nossa fábrica abstrata e dentro do nosso método construtor estamos criando as instâncias para os nossos produtos.

*Mas porque não podemos dar um “new” logo em cada produto e já criar a instância que queremos?*

Porque se fizermos isso, vamos perder todos os poderes que esse padrão de projeto nos oferece (alta coesão, baixo acoplamento), entre outras coisas.

Lembre-se, o nosso cliente não tem a obrigação e nem deve saber como as coisas estão sendo implementadas, ele apenas consome os produtos e fábricas abstratas.

Continuando…

Para facilicar a criação de nossas fábricas concretas, vamos criar um método estático dentro da classe “ProductClient” que será responsável por retornar para nós uma instância do nosso client já com a fábrica concreta que precisamos.

O nosso método ficará dessa forma:

![Alt Text](https://dev-to-uploads.s3.amazonaws.com/uploads/articles/xgyhjcyfyjcjd8yrw4jp.png)

Ainda dentro da classe “ProductClient” vamos criar mais dois métodos que retornarão para nós uma lista de “Food” e “Packing”, já temos esses métodos criados dentro dos nossos produtos abstratos, vamos apenas dar um return nesses métodos das nossas classes.

![Alt Text](https://dev-to-uploads.s3.amazonaws.com/uploads/articles/s65iglhzhna6b191q4so.png)

Ótimo pessoal, já temos todo o padrão de projeto “Abstract Factory” implementado, só nos resta agora ver ele na prática, funcionando.

Como comentamos no começo desse artigo, a proposta era implementar esse padrão de projeto utilizando uma API, vamos fazer isso.

Dentro do diretório “Controllers” crie uma classe chamada “ProductsController”, ficando asssim:

![Alt Text](https://dev-to-uploads.s3.amazonaws.com/uploads/articles/cypeu0rqxclrqvbxwk7b.png)

![Alt Text](https://dev-to-uploads.s3.amazonaws.com/uploads/articles/fjsi3awkp5pngwbjarup.png)

Olha que legal pessoal, dentro da nossa controller vamos criar dois métodos, um para buscar “food”e outro para buscar “packing”, via [query params](https://en.wikipedia.org/wiki/Query_string) estamos recebendo o tipo de produto que queremos pesquisar, esse tipo é o mesmo dos nossos produtos abstratos.

Quando chamamos qualquer um desses métodos, a primeira ação que executamos é a chamada do método estático “CreateProductClient” e passamos o tipo que está vindo da nossa requisição.

Se o usuário passar para nosso método “SearchFood” o tipo “Organic”, será criada uma instância no nosso “ProductClient” e a fábrica concreta que será criada no construtor nesse caso é a “ProductOrganicFactory”.

Veja o exemplo em debug na imagem:

![Alt Text](https://dev-to-uploads.s3.amazonaws.com/uploads/articles/th4shuxxld8if4maft5e.png)

No nosso construtor a instancia que esta sendo passada é da nossa fábrica concreta “ProductOrganicFactory”, isso só é possível por conta da herança que realizamos da nossa fábrica abstrata “ProductFactory”.

![Alt Text](https://dev-to-uploads.s3.amazonaws.com/uploads/articles/5iisn0t1gbdng1f27vga.png)

Logo abaixo, chamamos o método “SearchFood” e se pararmos para analisar, nosso “client” está chamando esse método do nosso produto abstrato “Food” que declaramos no inicio da classe. E agora vem a pergunta:

*E como que a nossa aplicação sabe que ela tem que retornar uma lista de “Food” do tipo “Organic”?*

Simples, através da herança que utilizamos em nossas fabricas e produtos concretos(as).

Quando o método “SearchFood” ser acionado, a implementação dele vai estar no nosso produto concreto “ProductOrganic” porque a fábrica que criou o produto foi a fábrica concreta “ProductOrganicFactory”. As imagens a seguir mostram o fluxo da aplicação quando chamamos o método “SearchFood” da nossa controller.

Recebendo o tipo “Organic” no nosso método de buscar “foods”:

![Alt Text](https://dev-to-uploads.s3.amazonaws.com/uploads/articles/moeh2jjioqeb3pufs6sh.png)

Criando uma instância de “ProductClient” e passando no construtor uma instância da fábrica “ProductOrganicFactory” de acordo com o tipo recebido.

![Alt Text](https://dev-to-uploads.s3.amazonaws.com/uploads/articles/lrqkweapx72zxv6o3hfu.png)

No construtor de “ProductClient” estamos criando produtos concretos de “Food” e “Packing” através na nossa fábrica concreta “ProductOrganicFactory” recebida no construtor, ou seja, esta sendo criado instâncias de “FoodOrganic” e “PackingOrganic”.

![Alt Text](https://dev-to-uploads.s3.amazonaws.com/uploads/articles/3nsuwfst8g56dznve1ne.png)

![Alt Text](https://dev-to-uploads.s3.amazonaws.com/uploads/articles/g8ggk9j7dg8cmsn3b4b6.png)

Quando chamamos o método “SearchFood”, a lista que será retornada é uma lista do tipo “List<FoodOrganic>”, ou seja, a execução deste carinha esta ocorrendo dentro do nosso produto concreto “FoodOrganic”.

![Alt Text](https://dev-to-uploads.s3.amazonaws.com/uploads/articles/njlu43n2rhw0oy8c671k.png)

No nosso navegador vamos ter o seguinte retorno para o tipo que passamos:

![Alt Text](https://dev-to-uploads.s3.amazonaws.com/uploads/articles/856datpd4yyx4jm0mejd.png)

Se fosse solicitado o tipo “Inorganic”, seria este o retorno apresentado:

![Alt Text](https://dev-to-uploads.s3.amazonaws.com/uploads/articles/xi0mm5ypa3eu1nlo58jc.png)

Enfim, terminamos pessoal. Mas antes gostaria de fazer algumas observações.

Com a implementação desse padrão de projeto, conseguimos atender algumas das recomendações do SOLID, sendo elas:

SRP, onde cada classe tem a sua responsabilidade, não dependendo e nem implementando coisas que seriam responsabilidade de outras classes.

OCP, esse princípio é atendido quando criamos as classes abstratatas “Food” e “Packing”, que podem ser herdadas e especializadas. Se por um acaso, um dia surgir um novo tipo de produto como “Industrial”, podemos especializar essas classes como, “FoodIndustrial” e “PackingIndustrial” por exemplo.

LSP, quando criamos nossas abstrações de fábricas abstratas e fábricas concretas, estamos garantindo que este principio seja atendido.

Os outros dois princípios não foram implementados neste exemplo, mas fica aberto para discussão e melhorias caso localizem algo que poderia ser implementado.

O padrão de diretórios criado foi apenas um exemplo para demostrar como implementar este padrão de projeto, caso veja a necessidade de utilizar esse padrão, lembre-se de adequar a implementação a arquitetura que voce está utilizando.

Este exemplo não é uma receita de bolo que pode ser seguida e copiada sempre, busque abstrair o que foi passado aqui e implemente de acordo com com a necessidade e arquitetura do seu projeto.

Dessa vez é isso pessoal, muito obrigado pra quem chegou até aqui.

Curta e compartilhe com seus amigos que estão aprendendo sobre este padrão de projeto, é sempre bom ter uma visão diferente de como fazer as coisas.

Críticas construtivas são sempre bem vindas, caso localizem algo que possa ser melhorado, deixa ai nos comentários ou me mande uma mensagem.

Logo vou postar um vídeo no youtube mostrando o passo a passo da nossa demo. Pra quem curte conteúdo em vídeo, vai ser legal.

Links:

Projeto no github: [aqui](https://github.com/willianmenezes/abstract-factory-dy)
Vídeo no youtube: [aqui](https://www.youtube.com/watch?v=8FtfHvlxG5g)
Twitter: [aqui](https://twitter.com/wmscode)
youtube: [aqui](https://www.youtube.com/channel/UC0Vo6yL26XaraIjak87jDww)
polywork: [aqui](https://www.polywork.com/wmscode)