Falaaaaaa desenvolvedor, tudo bem? Eu estou super bem, e dessa vez estou aqui com o segundo artigo da série “A Fábrica de Arquitetos”, no qual eu vou abordar um padrão super eficiente para ser aplicado em aplicações de médio a grande porte, onde se necessita do controle dos acessos aos objetos.

Então, no artigo de hoje eu demonstrarei de forma simples e objetiva como aplicar o padrão PROXY.

Caso você não tenha visto o artigo anterior, eu demonstrei como aplicar o padrão FACADE, ficou bem explicativo e você pode ler clicando aqui.

…

O que é?

Frequência de uso: 4/5 - Médio Alto

O Proxy Pattern é um padrão de projeto estrutural, e o objetivo dele é controlar o acesso a um objeto, utilizando outro objeto, que implementa a mesma interface.

Então como o próprio nome já diz, ele funciona da mesma forma que um proxy, então a classe proxy que controla o acesso a classe real que deseja ser acessada, onde ambos implementam a mesma interface, parece complexo né? Mas vamos a uma analogia que vai ficar fácil.

Suponhamos que, você tem sua classe ManipularUsuarios e deseja acessar um método que carrega TODOS seus usuários, agora imagine que essa método é chamado e instanciado mais de 50 vezes durante a execução do programa, ficaria algo extremamente pesado, você teria 50 instâncias de classe e carregaria 50 vezes todos os seus usuários para a sua aplicação.

E esse um dos problemas que esse padrão resolve, agora imagine que você tem uma interface IUsuario e uma classe chamada UsuarioProxy, tanto essa classe e a ManipularUsuario implementam a mesma interface, agora quando você precisa carregar TODOS os seus usuários pode instanciar a classe UsuarioProxy, chamando o método de carregar usuários, ela irá verificar se os usuários já haviam sido carregados anteriormente, se sim, irá retornar eles, se não irá carregar.

Em resumo a classe Proxy, irá:

· Controlar o acesso a classe real ManipularUsuario.

· Carregar TODOS os usuários SOMENTE UMA VEZ, e irá deixar em memória os usuários já carregados.

· Aumenta a performance o sistema (menos requisições e objetos instanciados no projeto).

No UML acima demonstra exatamente o que acontece, então em resumo, a classe proxy, controla o acesso a classe real, onde ambos implementam a mesma interface.

Showwwww! Agora que você já entendeu para que esse padrão serve e o que ele faz, vem aquela pergunta em mente,
QUANDO EU DEVO UTILIZAR ESSE PADRÃO?

1. Quando se necessita carregar uma grande quantidade de dados muitas vezes
2. Aplicações que necessitam controlar o acesso as instâncias dos objetos
3. Muito utilizado em aplicações que necessitam utilizar cache de objetos ou dados
4. Aplicações que contém lazzy loading

…

Aplicando o pattern

Agora que já vimos como ele funciona e suas vantagens tá na hora de aplicar tudo isso em prática, vou utilizar como exemplo a analogia que eu fiz acima, um módulo que necessita carregar TODOS, os usuários muitas vezes (no caso só estarei carregando 2 vezes para demonstrar) e não deseja fazer muitas requisições ou criar muitas instâncias do mesmo objeto.

Para isso ele terá os seguintes elementos:

1. Usuario: classe que será uma entidade contendo o modelo de dados de um usuário.
2. UsuarioRepositorio: classe que terá os métodos para carregar e exibir os dados dos usuários
3. UsuarioProxy: classe que irá conceder acesso as instâncias a classe de repositório.
4. IUsuario: interface que será comum entre a classe proxy e a classe real e terá o método Exibir()

Então vamos lá, crie um projeto console utilizando C# .NET Framework ou .NET Core com a seguinte estrutura:

Na pasta Modelos crie a classe Usuario.cs com a seguinte estrutura:

Na pasta Interfaces crie a interface IUsuario.cs com a seguinte estrutura:

Com nossa classe de modelo e nossa interface já criadas, vamos agora criar nossa classe real para carregar os dados do usuário e nossa classe proxy para controlar o acesso as instâncias da classe real.

Na pasta Classes crie a classe UsuarioRepositorio.cs com a seguinte estrutura:

No método Carregar() eu atribuo a minha variável Usuarios uma lista do modelo Usuario, e no método Exibir() eu apenas mostro os usuários já carregados.

Agora vamos criar nossa classe proxy para poder controlar a chamada desses métodos.

Na pasta Classes crie a classe UsuarioProxy.cs com a seguinte estrutura:

Agora na Program.cs coloque o seguinte código:

Na primeira vez que ele chamar a função Exibir() ele irá instanciar a classe repositório, carregar e exibir os usuários, já na segunda chamada ele apenas irá apenas exibir os usuários já carregados pela instância anterior.

Em um código com muitas chamadas de classe, esse padrão evitaria o uso desnecessário de várias instâncias e carregar diversas vezes o mesmo conteúdo, e por isso esse padrão é um dos meus favoritos.

…

Conclusão

No segundo artigo dessa série eu apresentei o padrão Proxy, quando utilizar e suas vantagens, demonstrei de forma prática e clara como aplicar esse projeto utilizando um simples exemplo, porém esse padrão pode ser aplicado em diversos cenários. Pelo fato de ser um padrão estrutural, impacta bastante na construção de um sistema e PRINCIPALMENTE na performance.

Enfim, é isso, espero que tenha ficado claro, até breve e bons estudos!!!

Baixe o projeto completo clicando aqui.

Caso precise entrar em contato, me mande uma mensagem aqui.