Unknown

Fala galera tudo bem com vocês iniciando mais uma live aqui no canal de cabelinho lavado como vocês já sabem e pronta para a gente falar de mais um assunto que vocês pediram bastante para eu falar sobre me digam se tá tudo OK com a câmera e com o microfone eu sempre pergunto voltou galera ultravou só porque eu fui falar só porque eu fui falar que outras vezes já aconteceu travou de novo me digam se Voltou se tá tudo certo eu troquei aqui de internet rapidão fui para o 5g porque é melhor eu tava no 2G

Boa noite galera vamos me confirmando só que tá tudo certo vou esperar mais algumas confirmações E aí a gente já começa a Live de hoje tá tá tudo certo agora pelo que o pessoal falou já já normalizou beleza perfeito Então galera Qual o objetivo da nossa Live aqui hoje nas últimas lives que a gente fez a gente já fez Live sobre Java Spring aqui no canal já fez Live sobre node Live sobre react e em algumas dessas lives principalmente nas lives onde a gente abordou mais o back end em algumas vezes Eu mencionei para vocês

alguns princípios e alguns padrões da arquitetura limpa e aí vários de vocês me mandaram mensagem lá no Insta então para quem não me segue lá no Insta Me segue por lá também que eu respondo vocês por lá Eu demoro um pouquinho porque são muitas mensagens mas quem me segue a um tempo sabe que depois de um tempinho eu respondo todo mundo tiro dúvidas e Tento conversar com todos vocês enfim vários de vocês me pediram para eu falar sobre arquitetura limpa para eu abordar um pouco mais desse assunto né e desmistificar um pouquinho explicar um pouco

mais Então o objetivo da nossa Live aqui hoje é justamente falar é o nosso foco é arquitetura limpa então eu vou explicar os conceitos os principais enfim os principais padrões que arquitetura limpa prega a gente vai discutir um pouquinho sobre eles e aí eu vou mostrar alguns exemplos de código porque às vezes só a teoria fica meio difícil de visualizar como aplicar aquilo né como aquilo ficaria em código então eu trouxe alguns exemplos de código também para a gente discutir e ver a aplicabilidade da arquitetura limpa Então vamos começar aqui eu vou compartilhar minha tela

E aí quando eu compartilhar a tela vai aparecer para vocês o notion um notion que eu criei para a gente usar aqui hoje nas últimas lives eu fiz essa essa esse formato de trazer um notion com anotações com algumas imagens e eu gostei bastante vocês gostaram também porque assim a gente não se perde durante a Live vai seguindo o foco aqui e é de estudo também que depois vocês podem utilizar Caso vocês queiram estudar um pouquinho mais sobre o assunto da Live depois então vou mandar aqui no chat da Live o link do notion para

quem quiser acessar e acompanhar e depois eu vou deixar salvo aqui na descrição da Live também para quem for assistir depois quem não puder assistir a Live agora o material vai ficar salvo só me confirme se vocês estão conseguindo acessar o notion acredito que sim eu liberei o acesso para todo mundo E aí vamos começar primeiro entendendo o que que é né arquitetura limpa tipo a gente escuta ah arquitetura limpa para falar que tem tudo limpa para cá eu vou fazer meu servidor com clina vou fazer meu microservice com Clear mas o que que é

a Clear arquitetura limpa é um padrão de arquitetura de software então quando a gente escuta sobre arquitetura limpa a gente escuta bastante também o termo DDD e são coisas diferentes DDD Dome design é algo que a gente usa para desenhar o nosso desenhar o nosso software por assim dizer a gente não vai falar sobre DDD hoje mas a gente tem que entender que arquitetura limpa e DDD são coisas diferentes Às vezes o pessoal acaba misturando então tipo tu pode aplicar DDD numa arquitetura limpa mas não necessariamente tu tem os dois tá são coisas diferentes então

a arquitetura limpa é um padrão de arquitetura de software que ele define como a gente vai implementar o código da nossa aplicação como a gente vai modularizar como a gente vai dividir as coisas mas arquitetura limpa ela não se refere diretamente a uma tecnologia então a arquitetura limpa ela pode ser aplicada em todas as linguagens em todos os frameworks em qualquer linguagem que a gente tiver programando não vou dizer todas né porque sempre pode ter uma sessão mas assim quase toda linguagem que a gente tiver programando a gente consegue aplicar arquitetura limpa assim como a

gente consegue aplicar princípios do Solid por exemplo eu sei que hoje eu fiz um post sobre Solid lá no meu Insta explicando os conceitos do solo de mas o sólido para quem não conhece são alguns princípios de design de código e o Solid mesmo sendo uma coisa mais focada para programação oriental do objetos tem alguns princípios do sólido que a gente pode aplicar em qualquer linguagem de programação por exemplo princípio da responsabilidade única não necessariamente o princípio da responsabilidade única a gente pode aplicar só para classes a gente pode ter funções com responsabilidade únicas também

então quando a gente tá falando da programação funcional para você durar por exemplo então a arquitetura limpa é parecido com o sólido por assim dizer a gente pode aplicar em todas as linguagens em todos os frameworks ele é uma padrão de arquitetura de software é um padrão para a gente desenhar e modularizar os componentes do nosso sistema só de clímax são usados juntos sim é bem comum tu ver princípios do sólido aplicado num sistema que tá desenhado com arquitetura limpa mas não novamente não são coisas iguais que nem o DDD e a clínica tector não

andam juntos o sólidos e o clima e a clina também não mas é bem comum tu ver aplicações que tem arquitetura limpa aplicaram os princípios do sódio até porque os princípios do sódio te ajudam a aplicar uma arquitetura limpa então é o sólide e DDD são coisas diferentes mas que são incrementais e fazem sentido juntos entendeu Como se várias pessoas tipo alguém veio com a ideia Inicial aí um cara pensando nessa ideia inicial da pessoa incrementou mais uma coisinha para ficar um pouquinho melhor aí o outro foi lá e pensar esse cara aqui propôs isso

nesse paper Nesse artigo propôs isso nesse livro Eu gostei dessa ideia dele mas talvez se adicionasse mais aqui ficasse um pouco melhor então a gente consegue ver Clear Solid DDD 3 dessas coisas como incrementações que diversos autores programadores foram fazendo e que a gente vê comumente sendo aplicados juntos mas são coisas diferentes mas normalmente Às vezes vem até da mesma base por exemplo aqui no arquitector ela se baseia em vários outros padrões de arquitetura então tu pode ver a mas esse padrão que quer é bem parecido com outro padrão que eu já tinha estudado sim

porque ela se baseia em outros padrões que na época que o que o ângulo Bob propôs ela né propôs a arquitetura limpa se baseou em padrões que já existiam no mercado e tentou melhorar um pouquinho eles reunir os pontos fortes desses padrões que já existiam então é aquilo né nada se cria tudo se copia e se transforma é basicamente isso mas nesse caso por exemplo só de arquitetura limpa tem objetivos diferentes Tá mas antes da gente começar a entender os princípios da arquite limpa né O que que ela define de fato a gente precisa entender

um princípio do sorte que a inversão de dependência a inversão de dependência corresponde a letra D do padrão sódio para quem não sabe de sólido é um acrônimo cada letrinha corresponde a um princípio e a letra D é a que corresponde ao princípio da inversão de dependência e traz as ideias que os nossos módulos devem depender de Abstrações e não de implementações que que isso quer dizer que módulos separados que são independentes eles não devem ter dependência direta entre eles então uma classe não deve conhecer implementação dos métodos de outra classe eu devo só conhecer

uma interface como se fosse um contrato e esse contrato seriam as coisas que eu sei só sei o alto nível só conheço abstração de outra classe entendeu eu não conheço a implementação de fato dos métodos dela se não eu tô totalmente daquela classe aquele módulo é a partir do momento que essa classe aqui que eu tô dependente muda eu vou ter que mudar também e isso é um grande problema arquitetural então a inversão de dependência é justamente traz isso os nossos módulos tem que depender de Abstrações não de implementações Diretas por exemplo vou dar um

exemplo bem mais esdrúxulo aqui bem maior mas só para vocês entenderem Isso quer dizer imagina que a minha classe lá dentro do meu código depende diretamente da implementação da epa e do Google Maps por exemplo aí toda vez que o Google Maps muda tipo assim Claro se usa em pé do Google Maps eu vou ter que mudar algumas coisas mas assim toda vez que o Google Maps muda eu vou ter que mudar o corda minha aplicação toda minha regra de negócio não isso não faz sentido a gente tem que ter um jeito de evitar ao

máximo eu tenho que mudar o corda minha aplicação então aí quando começa a entrar os conceitos do clima esse problema que ela vem resolver é diminuir essa dependência entre coisas é o desacoplamento que a clínica Tech orvisa ela avisa desacopular as coisas então aqui embaixo até trouxe aqui desacoplamento e regra da dependência que são a base da Clínica ou o Leo fala Leo tudo bem O Léo para quem não conhece o Léo ele tem um Insta também onde ele fala sobre conteúdos de programação e tecnologia ele acabou de mandar um super chat aqui no chat

Então fala Léo Boa noite para quem não conhece o Léo Procura lá o insta dele que é muito massa tem várias dicas em sites muito legais também só respondendo aqui o chat eu vi que o pessoal perguntou se a Live vai ficar salva sim a Live vai ficar salva e bom acho que foram essas perguntas eu vou mandar aqui também o link do notion de novo para quem entrou na Live agora e quiser acompanhar pelo novo bom então bora lá a gente já entendeu Aqui começou a entender um pouquinho essa questão né O problema que

aquele netector vem resolver e a gente chegou nessa palavra diz acoplamento Então essa imagem aqui que vocês estão vendo é uma imagem bem famosa quando a gente está falando de Clear for uma imagem acho que do primeiro livro do anple Bob do primeiro artigo que ele escreveu sobre a arquitetura limpa onde Ele propôs a ideia e que basicamente essa imagem aqui tá nos mostrando Ela nos mostra camadas que são círculos e algumas Flechas então agora vamos passar a entender o que que são essas camadas essas Flechas e começar a né a desmistificar arquitetura limpa então

o círculos como eu acabei de comentar são as camadas da nossa aplicação o que que são as camadas da minha aplicação seriam por exemplo os módulos da minha aplicação são as etapas que eu tenho dentro do meu software e aí aqui eu coloquei uma frasezinha ó as camadas mais internas não devem conhecer implementações das camadas mais externas ela a elas e essa aqui é um resumo da regra da dependência que o Bob propôs lá também no livro arquitetura limpa etc o que que isso quer dizer como assim a minhas camadas mais internas não devem conhecer

implementações das camadas mais externas bom lembra que a gente estava falando de inversão de dependência aqui o ancrobobi proposto uma estrutura em camadas de como a nossa aplicação deve ser dividida E aí vem essa regra da dependência as camadas mais internas seriam o Core o núcleo da nossa aplicação Onde fica as nossas entidades as nossas regras de negócio O que representa de fato o nosso software e o que ele faz quanto mais externo vai ficando as camadas são mais de de como eu posso dizer para você de ferramentas então é a parte ferramental da nossa

aplicação ela não é o cor do que do que a minha aplicação faz e sim são as ferramentas que possibilitam que a minha aplicação faça isso E aí ele dividiu justamente o software nessas camadas a camada interna é um núcleo como se fosse um núcleo da terra parte mais importante as camadas mais externas são ferramental e agora a gente vai entender o porquê dessa divisão então assim ó o usuário o cliente da nossa aplicação ele vai ele vai se conversar com a camada mais externa tá ele vai bater na camada mais externa na nossa aplicação

O que que tem na camada mais externa da nossa aplicação tenho o nosso banco de dados a nossa interface o serviço de terceiros aqui eu não tô dizendo que o meu cliente vai bater no banco de dados porque meu usuário vai usar o banco de dados não mas é que como se a nossa aplicação também fosse um cliente do banco de dados a gente tem que imaginar o banco de dados como um serviço diferente do nosso serviço porque o banco de dados ele é uma coisa externa a nossa aplicação tá a gente já vai entender

porque então o meu o meu cliente aqui no caso conversa com quem conversa com a interface Mas se eu for um cliente por exemplo de api ele vai conversar com meu controle por exemplo Mas seria a minha interface de comunicação ali com a minha aplicação E por que que serviços de terceiro também ficou aqui nessa última camada porque são serviços que a minha aplicação consome mas a minha aplicação não deve ocorre da minha aplicação de novo ela não deve ser dependente do de serviços externos eu não devo ter que mudar minhas regras de negócio por

exemplo para conseguir consumir serviços externos e agora Calma que a gente já vai entender o Quais são os problemas disso e o que que isso ocasiona bom aí na camada seguinte a gente tem interface detalhes então o que que são os interface adapteis é a camada que faz adaptação da camada mais externa então da camada de ferramental para camada mais interna Então ela essa camada de interface adepters ela faz uma adaptação de tudo que vem de fora cria uma interface onde o nosso núcleo pode consumir onde o nosso núcleo conhece então aqui essa camada de

interferência ela cria os contratos que a nossa aplicação conhece então aí aqui por exemplo fica o modo ouvir o controle o mvc fica aqui aqui ficam Nossos gatos ficam por tudo que vai ir para classe mais externa depois aí mais dentro a gente tem os views e cases a camada de casos de uso é a camada que contém as regras de negócio da minha aplicação então o que que são as regras de negócios de aplicação são as coisas que a minha aplicação façam tipo por exemplo se eu tenho um aplicativo de transferência de remessa internacional

até botei o exemplo ali como por exemplo a remessa online o PayPal Onde eu consigo transferir dinheiro aqui do Brasil lá para os Estados Unidos Esse é meu aplicativo uma das regras de negócio dessa minha aplicação desse meu produto é que um cliente deve poder transferir dinheiro do seu saldo para outro cliente da plataforma Isso é uma regra de negócio Então essa implementação dessa regra de negócio fica na camada de casos de uso casos de uso são literalmente os casos de uso da minha aplicação Em que casos a minha aplicação é usada para que ela

é usada o que ela faz e a gente vê isso em formato de código né Então essa camada aqui use cases ela não conhece detalhe das camadas mais mais externas ela ela só conhece Abstrações então aqui por exemplo eu tenho o meu minha classe que implementa a transferência de valor de um saldo de um cliente do saldo para outro cliente e aqui em algum momento eu tenho que salvar o dado no banco de dados nessa camada eu não vou escrever SQL nessa camada não vou fazer chamada no morro DB aqui eu como caso de uso

não me importa qual é o banco de dados que eu tô usando só sei que eu tenho que salvar esse dado eu tenho que deixar ele salvo e o que que eu conheço eu só conheço uma interface essa interface eu sei que ela tenha a implementação o método save savedera É só isso que eu sei que eu tenho método da Saideira que eu posso chamar ele e passar o dele que eu quero chamar eu não sei qual é o banco de dados ser relacional se não é relacional se ele é relacional não sei qual é

o de fato o banco aqui eu não sei nada só conheço Abstrações e calma que a gente já vai entender porque que isso é bom né E aí na camada mais interna de todas o núcleo são as entidades as entidades que são os objetos de negócio são os objetos do nosso negócio então voltando ali a nossas regras de negócio um cliente pode transferir o saldo para outro cliente dentro da plataforma aqui o cliente é um objeto de negócio e é isso aqui tudo é a regra de negócio é um caso de uso caso de uso

normalmente manipulam entidades que são os objetos de negócio da nossa aplicação Então os casos de uso eles orquestram o fluxo de dados entre as entidades Então as entidades seriam os seres e os casos de uso a nossa regra de negócio define como esses seres interagem entre si Quais são as coisas que eles performam né Então aí a gente tá na camada mais interna na nossa aplicação que são esses seres são os objetos do nosso negócio e as regras desses seres são as regras mais Gerais e de mais alto nível do nosso negócio o que que

isso quer dizer de mais de mais Gerais e de mais alto nível voltando aquele exemplo de transferência de remessa internacional eu preciso para o meu produto funcionar por exemplo é lei definição do meu modelo de negócio que o cliente cadastrado ele deve ter um CNPJ um número de conta no Brasil para poder depositar esse dinheiro para ele e um saldo e esse CNPJ tem que ser identificador único de cada cliente Isso aqui é uma regra de mais alto nível do meu negócio cliente tem CNPJ único cliente tem F único só que não muda e normalmente

essas regras aqui das entidades elas são as menos propensas a mudar quando algo externo Muda então o nosso objetivo aqui com a clinicta é proteger as nossas entidades a nossas regras de negócios que são o núcleo do nosso produto núcleo da nossa aplicação de alterações externas então aqui a gente consegue perceber que a medida que a gente avança para dentro né a gente vai avançando camadas de fora para dentro o software se torna mais abstrato encapsula as políticas de nível superior então quanto mais dentro a gente está então quando eu tô aqui na classe entidade

a classe entidade ela não conhece nada ela é uma classe que só depende de interfaces e que só define ali o contrato né define ele a forma os atributos que o cliente vai ter por exemplo os atributos que uma conta teria e só isso ela não tem implementação ela não conhece driver nenhum ela não conhece Framework nenhum esse é o núcleo da minha da minha aplicação do meu produto bom então agora que a gente já entendeu todas as camadas eu precisava explicar todas primeiro para a gente começar a falar um pouquinho sobre essas camadas aqui

digamos por exemplo que eu quero que eu implementei a minha aplicação usando o mais cinco tá é um banco de dados que eu tô usando mais que é mas sim se eu não usar arquitetura limpa então a gente está falando no mundo das coisas ruins se eu não usar arquitetura limpa e lá dentro onde eu faço regras de negócio eu rodo comandos SQL também se eu precisar mudar o meu banco de dados e detalhe gente isso não é uma coisa que não acontece com frequências isso acontece com frequência mudar banco de dados porque às vezes

a empresa quer reduzir custos quer migrar de banco de dados ó esse banco de dados aqui tá oferecendo benefícios melhores um valor menor o time de engenharia vai ter que se virar para trocar para esse novo banco de dados isso acontece isso está acontecendo no meu trabalho agora por exemplo a gente tá tendo que migrar de base aí imagina que lá imagina vamos para um caso extremo eu tô migrando de uma base daí que era ciclo que não faz sentido digamos ele não faria sentido criaram na época usando um banco de dados relacionados mas não

faz sentido e a gente vai migrar pelo não relacionar o que vai ter menos gastos vai ser mais rápido o nosso empregador que que a gente mude para esse banco de dados se lá dentro da minhas classes né onde eu faço as minhas regras de negócio faço as transferências salvo os dados do cliente etc tivesse ql para eu mudar de banco de dados eu vou ter que mudar quase toda minha aplicação vou ter que mexer em quase todas as classes né Ah tá não vou precisar mexer no controle vou ter que mexer só no Services

mas quando a gente tá falando uma aplicação enorme a gente tem certos para caramba então é um monte de coisa que a gente vai ter que mudar então aqui o ponto da Clear é que a nossa aplicação a nossas regras de negócio não devem depender de ferramentas não devem depender do ferramental e de firmware para que a gente consiga fazer essas trocas da forma mais fluida possível e da forma mais fácil possível claro uma coisa ou outra a gente vai ter que mudar mas a gente não tem que mudar tudo na nossa aplicação não tem

que mexer nas minhas regras de negócio para conseguir me adaptar o novo banco de dados que eu vou ter que mudar então esse é o problema que a arqu limpa vem resolver então deixa eu pegar outro exemplo aqui para vocês digamos Digamos que então eu tenho aplicado arquitetura limpa e a minha aplicação tá construída com Seguindo os princípios da arquitetura limpa aí eu tenho lá minha classe onde ela só implementa a regra de negócio uma classezinha Java por exemplo Digamos que o meu sistema tá em Java uma classezinha Java que tem lá minha conta ela

só implementa regra de negócio ela só conhece interfaces então eu só chamo ali métodos de interfaces Passos parâmetros que essa interface define só isso que eu faço eu preciso mudar o banco de dados a única coisa que eu tenho que mexer é migrar minha base obviamente né mas aí quem trabalha lá com banco de dados vai ter que fazer ou se é o deve mesmo que faz vai ter que migrar a base às vezes fazer um dump pegar todos os dados que tem dentro do banco de dados subindo o outro beleza aí a segunda coisa

que o cara vai ter que fazer a única coisa é criar um novo interface adepta o que que são os interface adepteis voltando aqui para nossa definição é a camada que faz adaptação da camada mais externa para camada mais interna então o que que esse interface adeptor vai fazer pô ele vai ver aqui ó o meu interferência adapta antes ele fazia um SQL que ele fazia um curry né select All frondeira base select All frontline para pegar tudo que tinha lá na tabela de clientes agora não agora vai ser longo bebê não vai ser mais

que ele esse meu interface adeptor ele vai ter que implementar a mesma interface que a minha classe lá da regra de negócio usa Então vai implementar e vai ter os mesmos métodos só que a implementação lá dentro vai mudar fica meio difícil quando a gente está falando só né sem ver código mas agora eu vou mostrar código vai ficar mais claro para vocês então depois de toda essa falação falando um monte de de palavrinhas o meu ponto aqui é querer mostrar para vocês que a Cleaner teacher é uma coisa muito mais simples do que parece

Na verdade o que que tem ela propõe para nós que a gente desacope nos nossos módulos que a gente não fica acoplado a frameworks que a gente não fica acoplado a bancos de dados e a gente não fica acoplado a nossa e Uai outro exemplo muito comum de de um problema estrutural é por exemplo eu vou ter que mudar a minha interface literalmente eu só vou ter que mudar algumas coisas da interface a regra de negócio e vai continuar a mesma tá regra de negócio continua a mesma cliente ainda pode fazer transferências mas não sei

o quê mas eu vou mudar uma tela de lugar lá no fluxo de cadastro numa nova conta do cliente vou ter que mudar agora eu quero primeiro que ele bote o e-mail e depois que ele bota o CPF só que E aí Digamos que eu não tô no mundo de arquitetura limpa onde o meu serviço o meu a minha pi foi criada diretamente para servir aquela you uai e a partir do momento que eu mudo uma tela de lugar fli pastelas a primeira eu vou mostrar essa e agora depois essa e eu tenho que alterar

lá minha pi isso não faz sentido Não faz sentido a minha o minha pi depender diretamente da minha e Uai mudanças de design não deveriam afetar a mudança de regras de negócio de funcionamento do meu serviço de funcionamento da minha aplicação Então esse é o ponto da de novo porque se a gente vê software legado aplicações mais antigas a gente vê isso acontecer bastante Eu já trabalhei com alguns softwares legados Eu já vi isso acontecer onde a gente queria mudar dois Campos de lugar no formulário e tinha que mudar lá o back end tinha que

mexer no backing de mexer coisa para caramba porque o beck que a gente tava todo mal estruturado depende totalmente isso aí é uma prova de que a arquitetura do meu sistema não está desenhada corretamente a minha interface é é como se ela fosse só um cliente da minha aplicação a gente tem que imaginar o meu back end como uma aplicação é a minha interface meu front como outra o meu front é só um cliente dessa minha aplicação o meu front não tem que mudar essa minha aplicação aqui meu front tem que só exibir os dados

para o cliente e permitir que um cliente Execute as regras de negócio da minha aplicação mas o meu Fronte não tem que mexer na minhas regras de negócio entendeu Esse é o ponto da klinexia Claro claro sempre tem exceções Às vezes tem um uma coisa que o front vai ter que mudar e aí eu vou ter que mudar o nome Beck sim isso acontece galera eu não tô dizendo que isso é Bala de Prata que sempre vai ser assim que a gente tem que sempre tentar assim mas o ponto é tentar cada vez menos ter

esse desacoplamento e cada vez mais ter coisas Independentes até porque tem alguns comentários que mais de um front mais de um cliente consome da mesma aplicação por exemplo lá no meu trabalho assim mais de um cliente mais de um fluxo fluxo diferentes que fazem coisas diferentes consomem numa mesma aplicação então não tem que existir esse acoplamento entre a minha aplicação e coisas externas entendeu Esse é o ponto da crina arquiteto eu vou dar uma olhada aqui no chat para ver se ficou alguma dúvida se você se vocês ficaram com alguma dúvida aí aqui em algum

dos pontos manda aqui no chat a Fê isso aqui não ficou muito legal tipo não entendi muito bem esse esse ponto aqui me manda aqui no chat que eu tento explicar novamente você prefere definir um ser um service como interface depois criar uma classe para implementá-la se eu prefiro ou se é no clinete por isso é seria assim ó eu criaria uma interface aí o meu caso de a minha entidade só conhece interface por exemplo e eu crio uma classe complementa essa interface e faz as coisas de fato vou dar um exemplo aqui prático para

vocês por exemplo eu preciso eu preciso consumir api do Google Maps que nem eu tava falando nisso eu preciso consumir api porque eu preciso pegar a latitude longitude porque eu tô desenvolvendo um aplicativo de delivery por exemplo eu preciso saber a latitude longitude o CEP é preciso saber tudo preciso consumir a peido Google Maps o que que eu faria tu cria uma interface a interface por exemplo get a interface Por exemplo advers essa interface advers ela vai ter Edward service melhor ela vai ter um método por exemplo get Latitude Longitude get late longe por exemplo

ou get CEP essa interface vai ter isso aí eu crio uma nova interface que é Google Maps service essa Google Maps implementa Implementos nada a ter os métodos get late longe get Latitude Longitude no caso e getsep ela é obrigada a implementar esses métodos porque ela tá implementando essa interface E aí ele dentro desses métodos no Body né no corpo daqueles métodos que eu vou fazer as coisas que são específicas do Google Maps porque porque eu tô na minha classe Google Maps service que implementa a classe Éder service aí eu vou implementar lá no corpo

vou chamar peido Gomes vou pegar os atributos que o Google Maps me retorna vou conhecer a forma como o Google Maps me retorna mas a minha classe lá por exemplo a minha classe delivery service que é da minha aplicação da minha regra de negócio lá do meu aplicativo de delivery a minha classe delivery service que precisa saber o endereço que precisa saber o CEP ela Ela depende só da interface address service e ela chama o método get CEP ela não sabe que o Google Map existe ela não sabe aí na hora que eu for distanciar

essa minha classe eu passo para ela uma uma estância do Google Maps aí eu passo a Instância do Google Map service que implementa ela interface mas a minha classe lá dentro dela no corpo nos métodos dela ela só conhece a interface e chama uma interface genérica que eu poderia muito bem trocar aquele Google map service pelo sei lá Uber e Uber map service Digamos que o Uber lance um aplicativo de mapa que nem o Google Maps e agora eu não quero mais usar o Google Maps quero usar o Uber eu só pego faço um adapta

ali para o meu Uber e a minha aplicação continua funcionando porque ela só depende do Éder service ela nem sabia que tinha Google map service lá entendeu Esse é o ponto das interfaces dos interface adeptos e da questão da minha da minhas regras de negócio eu não dependerem de implementações externas implementações terceiras Fê vai mostrar um exemplo de código Sim vou mostrar tá aqui embaixo já vou chegar lá gente só tô repassando os princípios aqui a parte mais teórica para a gente ver o código e é entender Ah tá agora entendi o que que a

Fê tava falando já vou mostrar para vocês vamos ver se tem mais alguma dúvida aqui desculpa se a pergunta for fora do escopo Mas qual a diferença entre anti e repostrie é um pouquinho fora do escopo mas eu vou explicar porque aparece bastante isso quando a gente está falando da construção da nossa aplicação também ente é a entidade Então são os objetos de negócio da minha aplicação e normalmente a minha entidade ela representa diretamente uma informação que eu salvo lá no meu banco de dados mas por exemplo a entidade seria o meu cliente aqui no

caso a entidade cliente Ela tem os atributos CNPJ ela tem o atributo conta e ela tem atributo saldo Essa é a minha entidade o meu objeto de negócio e são as coisas é o ser né desse nome ser que eu manipulo durante a minhas regras de negócio já o meu reposto o padrão reposto seria o cara que se comunica com o banco de dados de fato então o repouso e salva uma entidade no banco de dados o repouso e atualizam dado no banco de dados deleta uma entidade do banco de dados o reposto é o

cara que conhece o banco de dados em si então por exemplo se eu preciso trocar de bancos de dados provavelmente eu vou ter que adaptar o meu repouso para que ele saiba manipular esse novo banco de dados mas o resto da minha aplicação não vou precisar mudar porque a minha aplicação chama meu repouso tá ela chama o repouso para se comunicar com banco de dados por exemplo mas a minha aplicação não sabe de nada que o repouso te faz lá dentro Eu só conheço os métodos que ele me expõe ele me expõe o método Save

The Elite Evidente é isso que o que o repousor me expõe e o reposto e lá dentro dele ele faz a implementação de fato ele faz o esquele ou ele é um ou ele faz ou ele é o RM por exemplo né ele faz manipulamento direto com objeto enfim mas essa seria a diferença da entidade do reposto entendeu o reposto é o carinha lá do banco de dados né simplificando um pouco carinha lá da banco de dados que se comunica com ele faz as manipulações lá no banco de dados e entidade ou objeto do meu

negócio é o meu cliente né meu usuário é o meu produto se eu tô falando de como ser minha classe do meu núcleo das minhas regras de negócio são os objetos da minha das minhas regras de negócio A Entidade então é tipo o domínio é a entidade tipo domínio para quem sabe quem para quem conhece um pouco de DDD também driving design a gente tem os domínios da minha aplicação normalmente uma entidade representa um objeto do meu domínio basicamente isso tipo tá Às vezes tem algumas mudanças mas é assim é nesse sentido mesmo tá então

E se o repousor faz a manipulação com o RM então ele faz a manipulação com RM não tem problema mas é o reposto e que sabe que ele tá usando o RM entendeu a minha aplicação não faz ideia que o repouso está usando o RM que por exemplo não Java no Java Spring a gente tem o JPA aí a gente normalmente a cria a minha classe entidade diretamente acoplada com JPA Isso é um problema tipo facilita bastante a escrita de código enviava por exemplo Spring mas a gente acaba se acoplando ao JPA totalmente isso quer

mudar o JP precisa mudar todas as tuas classes anties e todos os teus repostos automaticamente porque tá tudo dependente do JPA então o ideal seria desafopular o máximo a minha entidade nem saber que eu tô manipulando a RM eu crio uma entidade um Midway que eu faria assim ó por exemplo o meu reposto manipula alguém manipula uma entidade meio termo e aí depois transforma essa entidade meio termo que o meu repouso de manipula pelo pelo o RM por exemplo na minha entidade de fato na minha classe da minha aplicação então eu teria ali um carinha

no meio para tentar fazer essa adaptação entre a entidade lá do RM e entidade de fato da minha regra de negócio da minha aplicação para essas duas serem distintas para eu não juntar elas não juntar a entidade do maior RM com a minha entidade na minha aplicação porque senão eu vou estar acoplando a minha aplicação a essa arquitetura de um RM Por exemplo essa forma que o RM funciona Bom vamos lá vamos continuar aqui eu trouxe um exemplo em reaft e um exemplo em note eu vou começar pelo exemplo em note que fica mais fácil

de visualizar esse exemplo aqui é um código que eu escrevi um tempo atrás e acredito que vocês contavam começando já escreveram um código assim também ou escrevem código assim não tô dizendo que ele tá tipo errado eu só tô querendo mostrar para vocês como a klinexper nos traria vantagens aqui então por exemplo eu tenho aqui uma classe que se chama user Controller é literalmente Controller da minha aplicação essa minha classe user Controller ela recebe no Construtora ou usel user Model tá no Construtor dessa classe aí dentro dessa minha classe eu tenho os métodos get de

Elite update etc já começa com um fato que essa é minha classe dentro do controle ela já tá fazendo algumas regras né isso aqui meu controle não era para fazer isso mas enfim aí olha só o ponto aqui Vocês conseguem ver que toda minha classe do controle ela é Totalmente Dependente do Framework que eu tô criando a minha aplicação porque porque essas minhas todos esses meus métodos aqui recebem requestion que são interfaces lá do Express então aqui no caso se eu quiser mudar do Express pro Fast Fly por exemplo não vou poder aproveitar nada daqui

vou ter que mudar tudo sim vou ter que mudar tudo porque porque lá no Fast Fry não é rack ponto e user por exemplo vou ter que fazer reck.org lá no Fast Fight responde ponto status é response e ponto não sei quê ponto sem de status eu vou ter que mudar tudo que é diferente do meu Interface para outra Vocês conseguem acoplamento aqui da minha classe Controller com Express tá totalmente acoplado toda a minha requisição eu tô dependendo das coisas que Express Me fornece e toda a minha Nossa eu tô montando baseado nos métodos que

o Express Me fornece também então aqui se eu quisesse mudar de forma work eu ia ter que adaptar toda essa minha classe todos esses meus métodos sem exceção eu teria que adaptar olha quanto trabalho eu ia ter e aqui eu tô mostrando um controle na nossa aplicação a gente tem às vezes chega até eu já vi aplicação com mais de 20 controles e com certeza alguns de vocês já podem ter visto a aplicação com mais controles E então é aí que vai morando o problema entendeu me diga que a nossa aplicação vai crescendo ela vai

se tornando Monstrinho se a gente não cuida da arquitetura do nosso código da arquitetura do nosso software a gente vai criando um monstro que vai que vai ficar mais difícil de sofrer atualizações de passar por mudanças por isso que a gente vê muito código legado porque porque os deves tem medo de mexer no código legado porque arquitetura do código legado tá zoada se eu tiver que mexer alguma coisa alguma coisinha que seja vou ter que mudar tudo porque a arquitetura tá zoada entendeu Então esse é o ponto que vem resolver simplificar as adaptações na nossa

aplicação e desacopar as coisas então se eu quiser atualizar um filme work eu vou conseguir atualizar com mais facilidade se eu quiser mudar um banco de dados eu vou conseguir mudar com mais facilidade a minha aplicação não fica acoplada essas coisas terceiras indicamos que o Express cai em desuso Express Para de ser usado sei lá que nem aconteceu como é que foi teve uma biblioteca de JS esses dias esses dias não faz um ano já dois anos que era super utilizada E aí do nada deu uma louca lá no cara que era dono dessa biblioteca

o cara que mantinha sobre biblioteca ele foi lá e simplesmente subir uma versão zuada no nojo no npm no caso era aquela biblioteca de testes eu me esqueci o nome era Faker fakers eu acho ele se cansou de dar suporte subiu uma versão que não tinha nada lá dentro todo mundo que usava o Faker não poderia mais atualizar sua versão do Faker porque a conversor uma versão zuada que não tinha nada dentro do código E aí imagina o Faker tion é uma biblioteca de teste mas imagina que fosse o Xpress da vida agora eu dispress

nunca mais vai receber atualização e a minha arquitetura tá toda acoplada no express todos os meus controles Eu tenho 20 controles que estão acoplados Eu tenho 20 arquivos de Roots eu tenho 300 não sei quê midwaysprofis que eu criei baseado na arquitetura do Express E se eu precisar mudar vou ter que mexer todos esses arquivos quem vai querer fazer essa refaturação que vai ter segurança de fazer essa refaturação é aí que mora o problema então de novo a karinactacture traz os princípios de acoplamento das regras de dependência deu só depender dentro né nas partes mais

internas eu não depender das partes internas eu só conhecer Abstrações e não implementações Justamente por isso bom então aqui já mostrei para vocês a minha classe de user Controller que ela faz ela implementa que os métodos de get dele Tipo dente aí como é onde essa minha classe é extensada bom eu tenho aqui um arquivo e userroutes onde eu uso o Xpress de novo então aqui eu tô usando userratter para mapear as regras de chamadas para o meu usuário e aí aqui no meu user.gate eu passo em tipo a gente onde se onde é a

chamada e qual é o controle que cuida disso e aqui diretamente eu pego a requisição e o response que vem aqui do Express e passo direto para o meu controle passo direto para o método do meu controle como parâmetro totalmente acoplado aqui eu pego a requisição do Expresso no formato do Express e passo para o meu controle o meu controle pega essa requisição novamente bom e como é que a gente poderia resolver isso né como é que eu poderia melhorar esse código eu trouxe aqui só uma explicaçãozinha tipo do porque que esse código aqui tem

problema mas é o que a gente tava falando agora se precisarmos em algum momento trocar o Express para outro filme work será necessário alterar todos os controles Isso significa que a camada de controle da minha aplicação depende diretamente da implementação do filme worker Express o que viola regra de dependência arquitetura limpa para evitar essa dependência direta a gente pode criar uma Interface para o Express e em seguida criar um adaptor que implementa o seu interface se comunica com Express então agora a gente vai ver o como é que a gente faz isso então a primeira

coisa que eu faria aqui é definir uma interface request que a gente pode ver que aqui o meu controle ele precisa mexer com esse request Ele precisa saber quais são os reders Ele precisa saber quais Qual é o body o meu o Roller que ele precisa saber essas coisas é da responsabilidade do controle então eu crio dentro da minha aplicação a minha interface request ela não tem nada a ver com o Express nada a ver com o fast Fly é a minha implementação E aí eu criei uma outra interface essa interface seria o meu contexto

http que vai ser o que o meu controle vai receber o meu controle recebe um contexto http dentro desse meu contexto http ele vai poder chamar a função Gate request que vai retornar para ele uma request Então vai ser desse tipo aqui deixa até alterar que vou abrir um notion aqui onde eu posso editar para mudar aqui para vocês então esse meu tipo ontem ele recebe ele é um tipo ele retorna um tipo request então aqui ele retorna tipo request entendeu ele Esse é o request que eu criei aqui para minha aplicação e ele esse

meu ex-típico contact ele tem também um método que acende seria para enviar a resposta Sei lá eu de qualquer aqui mas esse meu wait tive conta que a gente poderia ter vários outros métodos e várias outras vários outros atributos eu botei só alguns aqui para a gente conseguir ver mais rápido então tem um get request que retorna um equest que é desse tipo aqui que a gente criou que tem um Sandy que recebe um status e um deleira que vai ser mandado embora o dele eu coloquei como tipo N porque aqui Pode mandar nada pode

mandar um Jason pode mandar uma string qualquer coisa que quiser nesse caso aqui vejam que aqui não tem nada a ver com o Express nada a ver com infectify nada a ver com nada aqui é só da minha aplicação aí agora o meu eu vou criar um adapta uma interface adapta Então vou voltar aqui para o Google porque fica mais bonitinho com com o fundo o fundo tá então eu vou criar um adapta esse adapter essa camada aqui que eu tava falando para vocês a camada verdezinha que o interface adeptos eu vou criar um adapta

Então vou transformar os requestions que eu tenho lá no AliExpress nos requestrio response aqui da minha aplicação eu vou fazer essa transformação vou adaptar Então a gente vai criar uma classe Express adapter Essa é minha classe implementa o meu Então esse contexto que que eu criei E aí ela recebe essa minha classe Xpress adapta ela sim recebe por no Construtor um requestion do tipo do Express aqui eu posso receber porque isso aqui é uma data exclusivo para Express entendeu só Express E aí eu sou obrigada a implementar aqueles dois métodos que estão declarados lá na

minha interface porque eu tô implementando essa interface eu sou obrigada a declarar o método get request esse Meu método get request vai responder só disso ponto request mas aqui por exemplo eu poderia fazer várias adaptações eu poderia criar um objeto novo que eu poderia retornar por exemplo em vez de dias contraste poderia retornar por exemplo aqui ó como a gente falou que meu request tem um headers eu poderia que pegar o desconto request que aí é o do Express mesmo Ponto sei lá não sei não me lembro o método express.get headers Digamos que fosse assim

a forma do Express de pegar os headers aqui Eu transformo a forma de Express de pegar os headers na forma que a minha interface definiu então vou fazer essa adaptação toda Digamos que para no express para pegar o body eu tenho que fazer isso Ponto request. sei lá body assim eu estou só chutando que eu não me lembro exatamente como é que é do Express aí dessa forma aqui que eu pego o body no express então bom aqui eu tô adaptador adaptando tô pegando que tá lá no request do Express e tô botando aqui no

formato que eu tenho que retornar que ele retorna um request que é dessa interface aqui fiz essa adaptação entendeu aqui o user também para pegar o usuário que foi adicionado lá pela minha camada de autenticação por exemplo eu vou ter que fazer aqui um chamar outro método enfim aqui eu faço toda essa adaptação e aqui no send é a mesma coisa no meu método acende Eu uso o response do Express passa um status e passo o daira dentro do Jason do Express aí eu fiz adaptação da minha interface lá que eu tenho para como Express

funciona E aí o meu controle ele usa a minha interface Entendeu o meu controle agora nos métodos get por exemplo ele recebe um leite tipo contente ele recebe mais um equest umrespance do Express então aqui eu chamo meu e ti me conta esse ponto get request para pegar o usuário aqui eu chamo EDP acende para enviar É só isso que eu sei agora se eu quero trocar o Express pelo Fast Fly eu só vou criar uma nova classe eu vou criar classe Fast Fly adapta por exemplo entendeu Esse é o ponto não vou precisar mexer

mais em todo o meu controle meu controle continua exatamente como ele estava a única coisa que eu vou ter que mudar é criar um novo adapta o adapta do Fast Fly que vai implementar essa interface que eu defini lá que é que o meu controle consome de fato e vou ter que adaptar os métodos do Fast Fly para os métodos ali que a minha interface implementa Mas é só isso que eu vou ter que mudar o meu controle ele não tá acoplado ao filme work entendeu isso é muito muito legal aqui Claro um exemplo bem

menor mas quando a gente vai aplicando isso em todos os cantos da nossa aplicação é muito mágico de ver isso esse desacoplamento fica muito mais fácil de a nossa aplicação também porque eu não sei se vocês já tiveram que testar algum alguma aplicação assim normalmente aplicações maiores fica bem difícil de testar porque a nossa aplicação depende um monte de coisa ela depende lá do Driver do postres Ela depende do SDK do Google Maps Ela depende um monte de coisa eu vou ter que criar um monte de motos um monte de spa e um monte de

coisa para mocar aquelas aquelas coisas externas para passar para minha casa para eu conseguir testar ela e aí ficar triste de testar vou ter que injetar um monte de coisa na minha classe aqui não eu tô criando meus interfaces que são da minha aplicação e eu posso inclusive criar um adapter para o meu teste um adapter que implementa essa mesma interface só que ela adapter de teste aqui dentro eu faço sei lá o que eu quiser para conseguir injetar no meu teste fica muito mais fácil de eu fazer meu teste também não vou ter que

criar Instância de um monte de coisa para passar para minha classe para conseguir testar ela eu só vou criar eu crio já meu adapter de teste e aí eu uso esse adapter de teste para todo lugar na minha aplicação onde eu depender dessa mesma interface eu posso usar o mesmo adapter de teste ou caso eu quero mudar de cenário eu creio Sei lá uma lógica ali dentro do meu adapta de teste para retornar uma coisa retornar a outra mas esses apoplemento acaba auxiliando bastante também nas escritas dos Testes E agora como é que como é

que a gente conectaria esse controle com Express né Tá eu criei aqui mesmo interfaces eu criei meu adapter que adapta o Express para mim interface e mudei meu controle agora o meu controle só depende da minha interface Tá e agora como é que eu uso esse controle como é que né como é que ele vai receber essas informações lembra que lá o meu controle aqui eu tava usando direto e userrat router e aqui por exemplo pegava o requestria response passava para o meu controle a gente vai ter que mudar só uma coisa aqui ó a

gente vai ter que só criar um novo adapter passando requestres e aí em vez de eu passar o requestres bons para o meu controle eu passo essa Instância do adapta só isso claro aí mora outra outro problema quando a gente tem muitas estâncias a gente acaba tendo um problema tipo quando a nossa classe Depende de muitas coisas de muitas classes a gente acaba tendo um problema aqui para distanciar uma classe então para eu conseguir por exemplo usar esse user Controller eu tenho que distanciar 10 classes antes para eu ir injetando as dependências e criando novas

distâncias para conseguir passar todas as dependências que esse meu usa o controle precisa para enfim conseguir distanciar ele aí surgiu outro padrão que são as factors a Factor é literalmente uma função que tá ali para criar todas as instâncias necessárias fazer as injetar as dependências pegar as distâncias retornar etc eu vou até abrir o código aqui para mostrar para vocês o que que eu tô falando deixa eu abrir aqui o código do olha só aqui para conseguir distanciar o meu user Controller eu tive que distanciar essas coisas aqui antes essa essa aplicação aqui não tá

com 100% tá eu tava faz tempo que eu fiz ela muito tempo tipo uns dois anos e aí depois de um tempo eu tentei implementar aquele netector nela não deu muito certo mas olha só aqui é um pequeno controle usa o controle é bem pequenininho que faz poucas coisas e eu já tenho que antes de conseguir distanciar ele eu já preciso distanciar todos esses caras aqui aí imagina que fosse um controle bem grande faz várias coisas eu já vi arquivos inteiros assim tipo isso tudo só que de linha só distância querendo distância de classe para

conseguir distanciar uma única classe no final e aí para quem já ouviu as sobre factors é aí que vem as factors é para isso que elas servem para a gente conseguir ter uma Factor seria uma fábrica distâncias para conseguir distanciar esse objeto de forma mais fácil então aqui em vez de eu fazer todas essas estanciações para conseguir passar a dependência que essa minha classe que precisa eu chamaria só por exemplo aqui um youser factory e ele me retornaria o meu user control user Controller Factor entendeu Aí eu colocaria tudo isso aqui de criar as instâncias

digitais etc deu numa função para esse me auxiliar isso aqui não tem muito a ver com o cliente mas é só para explicar o outro padrão aqui para vocês que é o padrão de factors que vem para resolver esse problema de quando eu preciso distanciar muita coisa e para quem já viu as lives de spring ouvir os vídeos de javas Spring que tem aqui no canal Lembra que eu falei que aqueles autoriart que a gente tem nas nossas classes é muito bom porque a gente não precisa ficar criando as estâncias é justamente para esse problema

que o alto arde vem resolver então aqui no spring a gente em nenhum momento eu estanci as minhas classes nenhum momento eu estanci passa as dependências etc que nem eu fiz ali no node onde eu criei uma aplicação com Express aqui no spring que distancia tudo para mim eu Spring que faz a injeção de dependências então quando eu preciso indicar com uma classe precisa da dependência de outra eu boto esse autoire aqui em cima e em nenhum lugar do meu código eu tô distanciando esse produtor e criando a Instância do repous Vitor e passando para

ele o Spring fica responsável de tudo isso isso é bem legal mas enfim não tem muita a ver com Mas é só para mostrar para vocês outro problema e outro padrão que vem aí para resolver esse problema bom vou dar uma olhada aqui no chat para fazer um tempinho que eu não leio para ver se tem alguma dúvida de vocês aspectores do Design Peter isso as factors são um design Peter deixa eu ver se tem mais alguma dúvida ela é programadora Júnior imagina quando ela for Sênior vai trabalhar na gringa meu Deus quem diria quem

sonha né bom não sei galera se eu vou ganhar tudo isso em dólares mas é seria muito legal um sonho podem reenviar as perguntas se alguém tiver alguma pergunta que eu deixei porque eu fui ali eu me empolguei comecei a falar e acabei não lendo o chat Fê na próxima Live faz um projeto usando 100% Clint Factor boa posso fazer uma live sobre isso sim eu até um vídeo no canal para conseguir explorar com mais com mais detalhes porque às vezes nos vídeos aí eu faço roteirinho antes tô gravando aos poucos eu consigo explorar mais

coisas na Live comer tudo ao Vivace improvisado Às vezes eu não consigo tipo abordar todos os pontos às vezes acaba me esquecendo aí quando acaba a Live eu penso podia ter falado isso para o pessoal lá durante a Live mas O legal é que eu consigo interagir com vocês responder as perguntas Caso vocês não entenderam algum ponto eu explico de novo passo por ali de novo tenta usar outra analogia para explicar Face possível tenta falar um pouquinho sobre como usar o Type o RM do ponto de vista da arquitetura limpa deve-se utilizar os models do

próprio tapelvm criar as nossas classes já lidou com isso como eu mexi assim super pouco com typer RM eu mexi sei lá pouquinhos meses antes eu saí da outra empresa que eu tava Então eu não sei te dizer ao certo contar para o RM Como utilizar mas tenta sempre criar um adapter né uma interface no meio Onde as duas classes as tuas classes Onde fica tuas regras de negócio só consumam dessa interface e aí tu faz um adaptar do teu da tuas classes lá do typer RM para implementar os métodos dessa tua classe intermediária que

tu criou por exemplo e conseguir fazer essa adaptação para que a o ponto da Clínica é o maior ponto que Claro tem vários detalhezinhos vários pontinhos umas maior ponto é que as nossas regras de negócio lucro da minha aplicação os meus objetos de negócio não devem conhecer ferramentas foi works drivers etc devem só existir ali o código onde faz a regra de negócio mesmo e conhece só interface só Abstrações Então nesse ponto tenta criar Abstrações ao máximo que nem aqui no caso como a gente criou um adaptar bem pequenininho aqui para Express onde a gente

só abstraiu Express por Type RM acredito que dê para fazer algo bem parecido mas não consigo te dizer assim 100% ao certo porque eu trabalhei pouquíssimo com Tap RM faz tempo que eu não olho o código disso também eu tô Como você sabe que quem me acompanha sabe que agora eu tô trabalhando com Java então tô mais ali e meça não Java eu trabalhei com nojo de um tempo só que na época a gente nem usava o RM no nojo aí depois a gente começou a utilizar a gente tava fazendo até uma refaturação para conseguir

utilizar inclusive fazendo uma refaturação para implementar aquele né nos nossos serviços que não que não estavam com arquitetura limpa o próprio Spring não recomenda retirar o autor ar de usar injeção de dependência pelo constructor sim agora o Spring tá com essa recomendação de parar de usar o autowide e injetar a dependência pelo Construtor mas o ponto que eu quis mostrar ali seria só que tu não fica com arquivos enormes onde tu cria instâncias e vai criando as distâncias para conseguir criar um objeto no final e tu consegue ter essa facilidade onde o Spring injeta da

experiência para ti Foi só esse ponto que eu quis mostrar ali bom mais uma dúvida eu tenho um Model user esse tem uma lista de projetos um projeto tem um user como autor tá então chamaram na rota users retorna um Loop Infinito tem uma forma fácil de resolver eu não sei dizer porque que te retorna um grupo infinito mas por exemplo tem um projeto tem os usuários e tu tem os projetos os projetos tem autores que são usuários o teus projetos eles devem no máximo ter uma um ID do autor por exemplo dentro do teu

projeto tu não tem que ter uma Instância inteira do teu autor você tem que conhecer por exemplo só o ID do teu autor porque a gente não vai precisar muito mais que isso aí Caso tu precise do nome do autor para fazer alguma coisa daí tu usa a tua entidade autor que aí tu cria uma Instância a partir daquele aí que tu tem na tua classe Projeto pega a Estância do teu autor que é o autor desse projeto E aí pega o nome dele por exemplo mas o teu autor não tem que ficar dentro do

teu projeto são duas entidades diferentes parabéns Fernanda Na minha opinião já se porta e tem conhecimento de um deve pleno muito obrigada Inclusive eu tô imigração para virar uma deve plena Obrigada galera fico muito feliz com elogio de vocês e fico muito feliz de estar ajudando vocês também de estar deixando enfim ajudando a comunidade compartilhando esses conteúdos por aqui e deixando algumas coisas um pouco mais claras e desmistificando algumas coisas justamente trago pontos que às vezes que para mim no começo eram bem misteriosos que eu não entendia E aí depois conseguia entender com bastante estudo

com experiência etc então é justamente isso que eu quero trazer porque às vezes eu buscava quando eu tava estudando quando eu tava iniciando e encontrava poucos conteúdos em português Esse foi uma das coisas que me motivou a começar a criar conteúdo também encontrava poucos conteúdos em português mas conteúdos em inglês eu sei inglês Então para mim foi tranquilo mas às vezes tipo assim a gente não quer ver duas horas de aula em inglês às vezes eu queria ver um vídeo em português que às vezes até facilita o entendimento mesmo eu sabendo inglês conseguindo entender um

vídeo em inglês quando a pessoa tá te explicando em português às vezes parece até mais fácil de aprender porque quando ele tá falando inglês por exemplo tem que prestar muita atenção e eu sentia muita falta nesses conteúdos em português por exemplo de Java e de spring tem pouquíssimos conteúdos em português bom eu vi que a galera tá falando aqui dos salários da Gringa eu sei que tipo são comentário oftop aqui da Clinic tactor eu sei que tem uma galera que por exemplo que começa ganhando 40 50 60 mil dólares por ano tá aí tipo um

pouquinho mais perto do salário do Brasil Claro se for multiplicar para reais né Se for converter para reais o salário bem bem alto tipo salário Aqui no Brasil é o salário que os Júnior lá deles estão ganhando mas eu já vi vídeo também que a galera tipo ganha 150 mil dólares por ano 180 200 mil dólares por ano é tipo muito louco assim mas eu não vejo alguém que seja estrangeiro ganhar isso em dólares porque eu já vi uma galera falando em vídeos também falando no Twitter etc uma galera que trabalha para fora que quando

que as empresas sabem que brasileiro gosta de ganhar em dólar porque a gente faz a conversão e vem bem aqui para o nosso país né a gente converte $2000 para Reais dá r$ 10.000 então Normalmente eles oferecem um salário um pouquinho mais abaixo para quem é estrangeiro para quem é brasileiro como nós por exemplo porque a gente vai aceitar porque para nós na conversão sai um baita salário Mas eles lá por exemplo americanos ou na Europa etc que precisam custear um custo de vida em Euro em dólar aí para eles fica complicado que é como

se eles tivessem ganhando em reais para eles né dois mil euros lá para eles é como se fosse r$ 2.000 lá para nós o custo de vida lá é alto também comida é caro moradia é caro então eu já tipo não sei se vocês conhecem alguém mas eu já vi relatos tipo que que quando tu é estrangeiro e trabalha para uma empresa de fora ele assistiu oferece um pouquinho menos porque sabe que a gente vai aceitar né que a gente ganha na conversão é bem o salário acaba sendo bem mais alto do que as empresas

aqui do Brasil mas lá se for comparar salários que eles ganham eles ganham um pouco mais por causa do curso de vida lá que é que é mais alto mas enfim isso foi só bom vamos agora eu vou mostrar um exemplo de Cleaner tecture no front esse projeto aqui foi um projeto que eu fiz faz um tempão também é quando eu tava estudando eu acabei não terminando ele mas é legal para mostrar para vocês aqui a o desacoplamento entre o react tá esse projeto aqui é um front escrito em react então diz a complemento do

react com as regras de negócio que moram no meu Fronte tá então aqui por exemplo eu tenho a minha classe presentation da minha classe na minha pasta apresentation dentro da minha pasta presentation Eu tenho meus componentes componentes da minha aplicação né com estilização etc Então aqui tem um impulso Spinner o header tá tudo aqui dentro e a gente consegue ver que esses meus componentes aqui eles se vocês entrarem eu deixei lá no notion um link do repositório para vocês darem uma olhada Então tá lá no notion para quem quiser olhar também vocês vão conseguir ver

que esses meus componentes no react eles só implementam coisas de react só coisa de react então aqui eu só manipulo o estado e faça as coisas que são relacionadas a react quando chega no momento onde eu preciso executar alguma regra de negócio por exemplo uma regra de negócio seria aço meu token tá inválido eu tento fazer um refresh do Topo e na minha aplicação essas partes do refresh do Token por exemplo tá aqui dentro da minha classe domanda minha classe da minha classeideira então aqui dentro da minha classe dele eu tenho e use cases da

minha aplicação no caso de uso no caso de uso aqui por exemplo que eu tinha implementado só eu caso de uso de Alf de autorização aqui a gente consegue ver que essa minha classe alta ela recebe um parâmetro que é um AuthenticGames é que nem eu tava mostrando lá para vocês é uma interface um tipo aqui da minha aplicação ela não é de axios não é de directrewer não é de nada só que é da minha aplicação e aqui eu tenho a minha a minha a minha como é que eu passei a minha pasta infra

que a pasta que faz adaptação por exemplo do meu axios para o que para o que a minha classe lá de autenticação espera então aqui eu tenho por exemplo o meu Axis implementa a minha interface Clint Então quem precisar fazer uma requisição vai receber uma Instância da classe este pi post client E aí uma vai receber uma classe do tipo e aqui eu criei um adapter para fazer o meu axio se comportar de acordo com essa interface aqui que eu defini e aí se eu quiser mudar esse meu Axis para uma nova uma nova biblioteca

que surgiu de fé por aí sei lá Digamos que amanhã surge o factor sei lá uma nova biblioteca aí aqui eu não quero mais usar o axus quero usar o factor bom só cria um adapter do fetter para só cria um adapta do Factor para implementar também interface e o resto todo o meu front continua funcionando normalmente meu front continua funcionando como tava antes não preciso mudar lá meu minhas classes onde fazer um chamadas para http nem nada só preciso criar um adapter para essa minha nova biblioteca aí crio a Estância desse adapter injeto lá

nos lugares onde eu preciso mas a minhas outras lugares onde estavam fazendo chamadas http continuam funcionando normalmente eles nem sabem que mudou a biblioteca que eles estão usando entendeu Esse é o ponto lá os lugares onde eu faço chamada http por exemplo lá para fazer minha autenticação eu nem sei que mudou a biblioteca de 7 nem sei que eu mudei o ar pelo Factor só sei que eu tô recebendo uma Instância da classe mais distância Esse é o ponto aqui então eu deixei lá no notion o código aqui para vocês darem uma explorada para quem

quiser dar uma olhada o código o projeto não está completo não finalizar Mas é bem legal para dar uma olhada como ficaria a clinetector num front end porque a gente fala bastante aqui dector no back-end e é onde eu vejo ser mais aplicado mas o front a gente consegue aplicar também como voltando lá para o início da Live quando eu falei para vocês a clínica Texture é um padrão de arquitetura de software que a gente pode aplicar em qualquer linguagem em qualquer filme work então aqui não é necessariamente só para backend a gente consegue aplicar

no front também Acaba ficando um pouco mais diferente do que no back eu confesso para vocês não fica do mesmo formato mas a gente consegue aplicar Clínica tector no nosso front também e fazer o desacoplamento do nosso front com frame o desacopamento do nosso Fronte dos frameworks e das bibliotecas que a gente utiliza é bem legal assim bom ah outra coisa que eu queria mostrar para vocês vou fazer um jabazinho aqui também para aproveitar o momento quem quiser saber mais sobre clínicactor Claro tem um livro arquitetura limpa eu até deixei o link aqui para vocês

do livro para quem quiser comprar eu ainda não terminei de ler eu comecei a ler não terminei agora eu vou começar a reler desde o zero e vou terminar dessa vez vou terminar de ler mas eu recomendo bastante porque o livro explora cada um dos pontos cada uma das camadas então por exemplo aqui na internet apresenta quatro camadas mas não necessariamente a nossa aplicação vai ter só quatro camadas Só que não é regra tá não preciso ter só quatro camadas na minha aplicação normalmente a gente acaba tendo mais camadas também então lá no livro ele

explora esses pontos também como é que a gente pode fazer isso tipo ele mostra alguns exemplos alguns casos de uso etc é bem legal assim então eu difícil de falar isso no começo da Live não necessariamente a nossa aplicação tem só quatro camadas Tá bom a gente não precisa se preocupar com isso essas quatro camadas são só uma base para a gente entender a divisão das coisas no climatector que essas quatro camadas seriam o corpo a gente entender como dividir as coisas mas acaba quase sempre acontecendo da gente ter mais camadas aí e aí voltando

para o jabazinho que eu ia falar que eu falei para vocês que eu ia fazer para quem não conhece a Rocket City é uma escola de programação e ela é parceira aqui do meu perfil do canal e eles têm um curso que se chama Ignite que é um curso mais avançado assim eles tem um curso para quem tá iniciando na programação que se chama Explorer e um curso mais avançado que é o Ignite tem várias trilhas tem trilha de novo DJs dentro da trilha de no DJ s tem um módulo específico só para DDD e

Cleaner tector Eu até já assisti aqui ó tem os fundamentos do DDD Então hoje a gente não falou sobre DDD Então quem quiser saber mais tem aqui tem a criação de uma aplicação do zero inclinatector e DDD tem módulo sobre sólido também então é bem bacana eu recomendo vim fazer meu jabazinho aqui para vocês porque a gente tem link de desconto exclusivo aqui da comunidade então Quem segue aqui o perfil quem acompanha as lives etc sabe que eu sempre falo que a gente aqui tem um cupom de desconto exclusivo Então tá aqui na descrição da

Live também eu deixei para vocês porque por que que eu recomendo porque é um curso que eu fiz eu não gosto de recomendar coisas que eu não fiz o Ignite eu fiz essa trilha que já tá atualizada então eles estão sempre atualizando trilhas pode ver aqui ó trilha atualizada quando eu fiz era uma trilha mais antiga mas eu mantenho a minha assinatura porque volta e meia eu venho aqui dar uma estudada uma relembrada de uma coisas por exemplo falei para vocês que fazia tempo que eu não trabalhava com node aí às vezes eu quero relembrar

algumas coisas eu venho aqui dentro do Ignite e relembro e vejo da forma mais atualizada também porque eles estão sempre atualizando as trilhas com o lançamento de novas bibliotecas que estão ganhando força no mercado mostrando novos padrões e etc e aqui tem um módulo específico para sobre DDD Clínica tector Solid é bem completo muito legal também então para quem tipo prefere assistir em vídeo aula ver na prática eu acho melhor do que ler o livro mas eu recomendo ler o livro também tipo aí você vem que fica melhor para vocês o que que vocês preferem

se vocês preferem ler só o livro se você prefere fazer o curso enfim foi só uma recomendação bom eu vou dar uma olhadinha aqui no chat para ver se tem mais alguma dúvida e aí a gente vai se encaminhando já para o final da Live hoje foi uma live mais rapidinha foi para explicar os conceitos do kleinertector então a gente viu aqui a divisão de camadas a gente entendeu [Música] como fazer essa divisão e qual a responsabilidade de cada uma dessas camadas o que que elas representam e a gente vê uns exemplos de código também

então deixa eu ver as dúvidas aqui do chat tem Java na Rocket City não na Rocket não tem Java é a Rocket é mais focada nas tag de reacts Olha eu vi o pessoal aqui falando que aluno do Ignite e que gosta bastante bom Galera fui aluna do guinaste também para mim Eu gostei muito assim dos cursos que eu investi foi o melhor investimento que eu podia fazer e por isso que eu recomendo para vocês aqui porque é uma coisa que eu fiz gostei muito e aí eles entraram em contato comigo para vocês aluno para

a gente ter essa parceria aqui bom o Lucas perguntou não é uma pergunta mas eu peguei o King code que tava parado aqui uns três meses por causa de você você tem me inspirado muita voltar a estudar todo dia vou comprar depois Nossa que massa Lucas sério eu fico muito feliz de saber isso Parabéns parabéns pela iniciativa de ter voltado a ler começado a estudar mais sobre isso muito massa e com certeza tu vai colher ótimos frutos e muitas coisas boas vão ver disso porque tudo tem resultado a gente se dedica estuda e isso traz

resultado na nossa carreira depois traz reflexo nos nossos conhecimentos na forma como a gente se posiciona dentro da nossa empresa se a gente já tá trabalhando a gente ter mais conhecimento ajuda a se posicionar melhor ajudar nosso time a tomar decisões mais estratégicas isso é muito importante ter esses conhecimentos a gente acaba sendo um profissional mais completo isso é muito bacana parabéns pela iniciativa de voltar a estudar o Cícero perguntou o foco deles é para web certo isso eles têm um foco em web Mas eles têm a trilha de react Nate também que é para

Moble então o foco é mais nas tecnologias web Master trilha para Mobilete que aí a gente consegue aproveitar vários conceitos do próprio react também que é o react usado na web você indica algum curso de programação no momento estou no Guanabara bom eu talvez falando exatamente agora sobre curte programação Então como tu tá começando eu indico Explorer da Rocket City é um curso para quem tá começando Então pega desde os conceitos básicos do mundo da web e aborda vários conceitos sobre Frontier de backnde então é um curso foi steck e seria aqui conteúdos necessários para

tu ser um Júnior para ingressar como Júnior no mercado Júnior no desenvolvimento web e a gente tem cupom de desconto aqui quem é da comunidade é que perdeve@ Explorer a gente tem desconto em todos os cursos da Rocket então já que tu perguntou de curso já falei se alguém tem alguma dúvida mais sobre clinina vai mandando aí que a gente já tá encerrando a Live Então se alguém tiver alguma dúvida sobre os pontos aqui que eu abordei durante a Live a Live vai ficar gravada Então quem quiser assistir novamente depois não se preocupa vai ficar

aqui no canal sempre Deixo salvo para vocês conseguirem assistir de novo rever alguns pontos que eu falei Talvez não tenha entendido e quando assiste a segunda vez consegue entender consegue ficar mais claro o Henrique mandou aqui na Rocket Você domina o Java script e o tape script exato domina o JavaScript e o tabscript tanto para fonte quanto para noite Fê fala um pouco do significado dessas pastas o que geralmente se coloca na pasta domênia na pasta infra presentation etc boa Ótima pergunta então aqui eu tinha até botado no notion acabei pulando mas a pasta infra

seria a pasta onde ficam as coisas mais externas da minha aplicação então seria um serviços externos as bibliotecas etc Então dentro da minha pasta infra vocês viram lá que eu coloquei aqui no caso do meu front Opa deixa eu abrir aqui o Fronte pera aí aqui na pasta infra eu coloquei o adapter do meu axios por quê Porque o axus é uma biblioteca terceira ela não faz parte da minha aplicação só tô usando essa ferramenta né lembra que eu falei lá no Insta Live que a camada mais externa ia ferramental o access é uma ferramenta

só tô usando esse ferramental Então coloca ele na pasta infra que a infraria essas ferramentas que a nossa aplicação usa e aí a gente adapta essas ferramentas através para conseguir pegar suas ferramentas abstrair elas para que a nossa parte mais interna da aplicação só Conheça as Abstrações e não as ferramentas que estão por trás dessas Abstrações Então dentro da pasta infra a gente coloca esse tipo de coisa na pasta do mei a gente deixa o domínio da nossa aplicação por exemplo domínio da minha aplicação só as entidades por exemplo então a minha classe usuário fica

dentro da classe do amém ela faz parte do domínio da minha aplicação se eu tô falando de um e-commerce eu tenho uma classe produto que é classe produto tem no preço tem a imagem etc o meu produto a classe product fica dentro da pasta domínio ela faz parte do domínio na minha aplicação aí por exemplo a pastadeira ela é meio assim tem bem padrão definido tem gente que bota uma coisa tem gente que bota outra então nem vou falar porque pode acabar confundindo mas na pasta por exemplo no caso do front por exemplo eu coloquei

os componentes react os componentes react ficaram dentro já passa presente a apresentação da minha da minha aplicação se eu tô falando de um servidor por exemplo posso colocar na pasta presente a minhas a minhas classes que fazem a formatação no meu dado para enviar para o cliente porque se faz parte do presente a parte final que o usuário meu cliente vai receber então é mais ou menos essa divisão assim que a gente faz aí a gente normalmente cria pasta Services Ou use cases para deixar casos de uso mas o service ele tem um ponto que

às vezes a gente pode querer criar por exemplo um Google map service que nem eu tava falando para vocês mas o Google Maps Ele ficaria lá na pasta infra porque ele faz parte da camada mais externa então normalmente é melhor chamar a parte a pasta onde ficam as classes de regra de negócio de uso e cases mas eu já vi a galera chamar de Services também que eu posso criar por exemplo meu bem service que eu faço transferências enfim da minha aplicação que seria por exemplo da do aplicativo de transferência de remessa internacional eu posso

criar também o meu user service que faz algumas coisas do meu usuário e aí ali acaba às vezes morando regras de negócio mas aí a gente às vezes acaba com confundindo esses tipos de service Porque existe os servos também que nem eu comentei antes que seria o service por exemplo o Google Maps service que faz uma busca lá usar peido Google Maps etc então tipo seria bom dividir separar esses dois tipos de serviços diferentes aí chamar essa pasta de use cases em vez de service não sei se ficou um pouco mais claro Espero que sim

mas realmente essa questão de pastas de divisão é tipo não é 100% padronizado já tem projetos que fazem um pouquinho diferente outros um pouquinho assim mas quando a gente tá falando de crimes tem uma aplicação que aplica clinetector que vai abrir com certeza tu vai ver a pasta de do vento vai ver a pasta infra às vezes tu vai ver a pasta controllers também então isso assim tu sempre vê os controlos é a parte que lida quase requisições requisições do cliente então espero que tenha te deixado um pouco mais claro como fica o gerenciamento de

estado num front-endico continua por exemplo aqui eu continuo usando o estado do react continua usando os States etc para fazer o gerenciamento de estado porque esses dados de estado viram regras de negócio então eu tenho que usar interfaces aqui quando eu tô falando só de estados que são estados momentâneos Só para conseguir aplicar algumas coisas dinâmicas na minha tela isso não precisa se preocupar muito do react não tem problema porque isso aqui não tá falando de regra de negócio da replicação Mas a partir do momento que eu tô usando esses estados para implementar a regra

de negócio daí eu tenho que criar interfaces extrair essas regras de negócio lá para minhas classes de casos de uso né E aí aqui no meu no meu Fronte eu só fazer o que foram do front aqui nos meus componentes react só fazer foi o Direct mesmo por exemplo mostrar um ou mostrar outro de acordo com o valor abrir ou fechar modal esse tipo de estado a gente continua usando os estados do react aplicações que seguem Clínica pelo menos nos conceitos principais escalam com facilidade sim sim o ponto da Clínica é ter mais escalabilidade ser

mais fácil de realizar mudanças então e ter menos desacoplamento então sim tu acaba conseguindo escalar mais fácil até porque tu consegue te adaptar a mudança de forma mais fácil também a tor arquitetura te permite que tu faças adaptações na tua parte ferramental de forma mais fácil porque a tuas regras de negócio ali tem um núcleo não sabem da tua parte ferramental então tu acaba conseguindo escalar tua aplicação mais fácil também bom galera vamos se encaminhando para o final da Live daqui a pouco eu vou eu tenho um compromisso também eu espero que vocês tenham gostado

que eu tenha conseguido deixar um pouco mais claro para vocês esse conceito de plena tectter eu sei que em uma live Impossível a gente entender tudo é impossível a gente saber agora exatamente como dividir todas as coisas da minha aplicação mas o meu objetivo aqui é que ficasse um pouco mais claro para vocês essa questão da camada das camadas essa questão do desacompamento da inversão de dependência que é que os nossos módulos não dependem de implementações e sim de Abstrações Espero que tudo isso tenha ajudado vocês a entender mais um pouco um mundo da Clínica

e não se preocupe que eu vou trazer mais conteúdo sobre isso aqui no canal vou trazer um conteúdo Prático também pessoal aí comentou no chat para fazer um Live code eu vou ver se eu faço um Live code ou se eu faço um vídeo onde a gente implementa na prática que aí na prática sempre fica mais fácil de ver também mas eu espero que aqui com os exemplos tenha ficado mais fácil de entender esses conceitos principais Doctor bom galera é isso eu espero que vocês tenham gostado da Live se vocês gostaram coloquem aí no chat

que eu sempre fico muito feliz de ver os comentários de vocês vou mandar aqui o link do notion novamente para quem quiser dar uma estudadinha por aqui depois para quem quiser salvar para consultar depois enfim eu construo para vocês para ajudar aqui a nossa Live ajudar a gente estudar e é isso galera muito obrigada por todo mundo que participou e boa noite para vocês bom descanso e bora bora continuar estudando vai vir mais conteúdo sobre Kinect conteúdo sobre DDD aí no canal também então para quem gostou desse assunto para quem achou interessante para quem quer

saber mais já começa a estudar mas pode deixar que vai vir conteúdos mais conteúdos sobre isso aqui no canal E aí lembrando eu deixei o livro arquitetura limpa aqui no notion Então vou mandar até o link aqui para vocês Caso vocês queiram [Música] Caso vocês queiram comprar ou dar uma olhada como é que é o livro eu vou mandar o link aqui para vocês porque é um livro bem bom o meu tá guardado ali até na Minha estante e Vale super a pena e ajuda muito a entender mais esses conceitos é um livro de 300

400 páginas onde o cara passa todos os capítulos explicando cada uma dessas camadas como é que tu faz essas divisões essas quebras essas modulas ações então um livro super interessante muito enriquecedor para nós para nossa carreira como profissionais mas é indicado ler esse livro depois de ter um pouquinho mais de experiência de já tá construindo algumas aplicações a um tempo é um livro para galera que já tá um pouquinho mais avançada não é para quem tá totalmente No início tem de graça também é eu acho que tem mas eu não sei o link galera mas

se vocês encontrarem aí compartilhem porque eu sei que tem online também mas eu gosto do livro físico é bom de lei depois foi olhar eu anoto também com marcador é muito bom bom galera a Live vai se encerrando Obrigada novamente para todo mundo que participou no notion tem todos os links que eu falei aqui para vocês tem o link do HUB com aplicação Direct tem aqui o exemplo em node tem o livro tem até um artigo aqui Bob que é um artigo mais rápido sobre para quem quiser dar uma lida também tá em inglês mas

é bem legal para entender e é isso bom vamos indo lá encerrando a Live Valeu galera