CURSO DE SPRING para INICIANTES | Tutorial Completo de Java Spring

Você quer aprender o firmw Spring mas não sabe por onde começar Esse vídeo foi feito para você no vídeo de hoje eu vou te explicar os principais conceitos que você precisa saber para começar a utilizar esse firmw para construir os seus projetos backend Então senta aí na cadeira e bora começar o vídeo Eu acho que o primeiro ponto que a gente precisa entender quando a gente tá falando do mundo do Spring é a diferença entre o Spring boot e o Spring Framework Então vamos começar entendendo o Spring boot o Spring boot é um Framework que

facilita a criação de aplicações javas baseadas no spring Framework então ao utilizar o Spring boot a gente vai conseguir criar aplicações Spring based né que a gente chama de uma forma muito mais simplificada e mais rápida sem precisar fazer configurações extensas na nossa aplicação e entrar no modo de Just Run né que eles chamam aqui que seria só fazer iniciar o projeto e só rodar que ele já vai est Prontinho e funcionando e agora que a gente já entendeu a diferença entre o Spring boot e o Spring Framework vamos inicializar a nossa primeira aplicação utilizando

o Spring boot E para isso a gente vai entrar num sitezinho que se chama Spring initializer então o Spring initializer ele é uma ferramenta online que permite que a gente crie rapidamente aplicações né projetos que utilizem o Spring boot a gente consegue acessar aqui na internet né através dessa URL start.spring.io E aí a gente vai fazer todas as configurações aqui das dependências iniciais que a gente quer colocar no nosso projeto certo vai definir o nome do nosso projeto e até qual o gestor de dependências que a gente quer utilizar Então vai fazer a geração do

projeto e vai fazer o download já vai tá pronto pra gente começar a utilizar então primeira coisa que a gente vai fazer aqui é escolher o nosso gestor de dependências No meu caso eu vou utilizar o maven porque é o gestor de dependências que eu tô acostumado a utilizar depois a gente pode escolher a versão do Spring boot que a gente quer usar eu vou deixar aqui na versão selecionada que é 3.3.2 certo que é a versão estável aqui do Spring no momento que eu tô gravando esse vídeo do Spring boot no caso a gente

pode escolher a linguagem também né então a gente não precisa somente utilizar o Java a gente pode construir aplicações Spring usando cotlin e Groove mas no nosso caso aqui vai ser o Java Então a gente vai definir aqui o nome do nosso projeto então aqui no artifact a gente vai mudar né esse artifact para dar o nome do nosso projeto no nosso caso aqui vai ser first Spring app né nossa primeira aplicação Spring e aqui no group a gente consegue alterar para colocar o domínio né da nossa aplicação domínio do nosso projeto o domínio aqui

no caso mesmo seria o domínio da nossa empresa por exemplo porque isso aqui depois vocês vão ver lá dentro da estrutura do do projeto quando eu mostrar para vocês que isso aqui vai ficar lá no nome da nossa pastinha principal então por exemplo se eu trabalho no na Globo né normalmente a galera coloca aqui Globo então todos os projetos Spring da Globo Tô só dando um exemplo certo vão ficar em com P Globo E aí o nome do projeto em si que vai definir ele mas aí o pessoal sempre usa o nome né o mesmo

group aqui para dizer que eles fazem parte né do mesmo domínio mesmo conglomerado ali beleza mas aqui pro nosso caso isso aqui não interfere tanto então vou colocar aqui no caso Kiper Mas vocês podem colocar o que vocês quiserem nesse momento Inicial aqui não vai interferir muito pra gente e a gente vai adicionar algumas dependências agora então a gente vai clicar nesse botão de ads dependes vamos selecionar algumas dependências que a gente vai vai querer utilizar nesse nosso primeiro projeto a primeira delas é o Spring boot Dev Tools essa dependência aqui vai nos fornecer algumas

funcionalidades certo de desenvolvimento aqui paraa nossa aplicação como Live Reload né o fresh Restart né o fast Restart no caso para fazer o Restart rápido das aplicações enfim e tudo isso a gente consegue configurar lá na nossa ide no caso o intelij que a gente vai usar hoje e ter ali um ambiente de desenvolvimento mais agradável com o Spring além disso a gente vai adicionar também o Spring web certo que é o módulo do Spring que nos permite construir aplicações web incluindo né aplicações restful que hoje é o que tá mais popular né no no

mundo do desenvolvimento web a galera constrói bastante apis rest ou restful e é o nosso caso aqui de hoje certo a gente vai ver como construir uma API rest certo utilizando Spring Então a gente tem que adicionar essa dependência Spring web E além disso eu vou adicionar uma última dependência quem não tem nada a ver com Spring mas é algo que eu gosto de usar no meu dia a dia de desenvolvimento que é o l boock o lombok é uma biblioteca para geração de código boiler plates certo que vai nos ajudar a escrever menos código

e criar algumas coisas ali automáticas pra gente da mesma forma que o Spring o Spring boot esconde várias configurações pra gente do Spring Framework e já faz algumas configurações padrões e geram os códigos boiler Plate para nós o lombok faz isso só que Ali pras nossas classes no Java certo então eu gosto bastante de utilizar o lombok E aí feit essas configuraçõe zinhas aqui a gente já pode clicar em generate e ele vai fazer o download aqui do projeto pra gente certo firsts Spring app.zip E aí a gente vai descompactar esse projeto e vamos abrir

o nosso intelij Então já tô com intellij aqui aberto né no nosso projeto Spring que a gente acabou de gerar lá no spring initializer e a primeira coisa que a gente vai fazer aqui dentro da nossa ideia é compreender a estrutura das pastas dentro de um projeto Spring porque isso aqui pode assustar também para quem tiver vendo pela primeira vez Então a gente vai entender certinho aqui como as coisas são organizadas dentro de um projeto Spring Então a primeira coisa de todas né o ponto inicial é o nosso P XML o p XML para quem

já trabalhou com maven né sabe que é o arquivo aqui onde a gente faz a listagem das nossas dependências e é o arquivo que o maven vai usar como base para fazer a instalação das nossas dependências certo pegar aqui a versão da dependência e qual é a dependência que a gente tá instalando Então esse arquivo aqui o p XML serve aqui paraas configurações a respeito das dependências do nosso projeto e se a gente der uma olhadinha aqui dentro dele a gente já vai ver dentro do objeto de dependencies a gente tem quatro dependências né que

foi o que a gente adicionou antes que é o Spring boot Starter web o Spring boot Dev Tools o l boock né e o Spring boot Starter test que a gente não adicionou mas ele veio por padrão aqui porque o Spring initializer já adiciona por padrão pra gente tá então a gente tem essas quatro dependências aqui o Starter web Dev Tools long boock e Starter Test e eu já explico aqui para vocês mais a fundo o que que cada um uma dessas dependências faz a gente tá primeiro dando um overview aqui na estrutura seguindo a

gente tem essa pasta maven né a pastinha pon mvn que é a pastinha do maven aqui a gente não precisa se preocupar nesse começo não precisamos mexer aqui mas basicamente saibam que aqui ficam as configurações do maven Então se a gente quiser alterar alguma coisa aqui no maven properties a gente vai vir aqui nessa pastinha e alterar esse arquivo mas por enquanto a gente não vai se preocupar com ela isso aqui são para coisas mais avançadas quando a gente vai criar um projeto mais robusto precisa fazer alguma configuração específica no maven daí a gente mexe

nessa pastinha certo seguindo a gente tem essa pastinha aqui que é a pastinha source basicamente o nosso trabalho vai se concentrar aqui dentro dessa pasta dentro da pasta sorce a gente tem duas subpastas que é a pasta Main e a pasta teste dentro da pasta teste como vocês já devem ter imaginado ficam os nossos testes unitários então tudo que a gente for escrever de classe que diz respeito a algum teste unitário vai ser dentro dessa pasta testes Então as nossas classes de teste a gente vai criar aqui dentro e por padrão o Spring boot já

traz aqui pra gente certo um teste Inicial que basicamente testa se a nossa classe principal do Spring tá inicializando com sucesso no caso aqui ele não testa nada né Ele só tem um método vazio que seria para fazer o context load que seria para rodar o contexto Inicial ali da aplicação Spring para ver se ela tá executando mas o teste tá vazio aqui é só pra gente usar como base Então dentro da pastinha test a gente tem os nossos testes unitários aí dentro da pasta Main a gente vai ter outras duas subpastas que vai ser

a nossa pasta Java e a pasta Resort dentro dessa pasta resources a gente coloca arquivos de configuração templates e arquivos estáticos como CSS né JS ou scripts SQL também então aqui dentro da nossa pasta resources vão ficar concentrados os arquivos de configuração da nossa aplicação Spring incluindo o application P properties que é o arquivo onde a gente vai fazer configurações específicas da nossa aplicação Spring e depois ao longo desse vídeo eu vou explicar algumas configurações aqui para vocês que vocês precisam saber que são antes certo e a gente tem essa pastinha aqui de templates para

colocar templates e também a pastinha estático para colocar arquivos estáticos como CSS HTML e até mesmo a gente pode criar Aqui as nossas pastas né das migrations aqui dentro da pastinha resources para colocar né os nossos scripts SQL E aí dentro da pasta Java por fim né a gente vai conter as nossas classes é onde vai est a lógica da nossa aplicação é onde a gente vai estar desenvolvendo o nosso código e dentro dessa pasta Java Vocês já vão ver que tem aqui certo uma classe que já vem por padrão que é essa classe aqui

que tem o nome do nosso projeto Então essa classe ela se chama first Spring app application Por que que ela tem esse nome certo ela tem o nome do meu projeto que eu dei lá né que eu nomeei no momento de gerar o projeto no spring initializer e ela vai ter sempre esse sufixo de application Então vai ser sempre o nome do nosso projeto seguido pelo sufixo de application essa classe aqui é o que a gente chama da classe principal a classe de entrada aqui do Spring certo então é essa classe que vai inicializar todo

o nosso projeto e fazer né o load ali de todo o contexto para inicializar o resto na nossa aplicação para quem já estudou Java e acho que vocês já devam ter estudado para est estudando Spring né sabe que quando a gente vai executar uma aplicação Java a gente né inicia uma aplicação Java chamando a execução de uma classe e normalmente dentro dessa classe tem o método Public static void m né que é esse método que vai inicializar o resto das outras classes né puxar alhe todo o resto para iniciar a execução e aqui no spring

não é diferente então a gente tem que ter uma classe de entrada no nosso caso aqui é essa classe e essa classe que vai né chamar o springapplication.run fazendo a execução aqui de toda a nossa aplicação e essa classe se vocês perceberem ela já é um pouquinho diferente porque ela tem essa anotação aqui em cima Então todo o Framework Spring né ele ele funciona em cima de anotações essas anotações são esses arras que a gente coloca em cima da das nossas classes certo para fazer configurações da nossa classe Então essas anotações elas abstraem configurações que

a gente tá colocando aqui na nossa classe que o Spring carrega essas configurações na classe ao a gente decorar ela com essas anotações isso aqui é um design pattern certo não é usado só pela Spring mas se popularizou bastante na comunidade certo por conta aqui do do Framework Claro esse design pattern já existia antes do Spring é muito usado em outros frameworks também em outros projetos tá o design pattern aqui de de de arrobas né de anotações mas no spring isso é muito forte e ficou bem popularizado por conta dele então quando a gente coloca

o arroba e alguma coisa aqui em cima a gente tá decorando essa classe com uma anotação e basicamente essa anotação vai fazer uma configuração pra gente nessa classe uma configuração que a gente não tá vendo que tá abstraída aqui por essa anotação certo e essa anotação aqui @springbootapplication basicamente é a anotação que define a porta de entrada do Spring boot certo então ela vai ser uma combinação de três anotações que a anota de @configuration anotação de @ enable autoconfiguration e anotação de component scem o que que são essas três anotações aqui do Spring tá @configuration

vai definir que a nossa classe né pode ter métodos que definem Beans depois a gente vai entender o que são os Beans o @ enable autoconfiguration ela é uma classe que vai ativar a autoconfiguração do Spring então lembra que o Spring boot tá abstraindo muitas coisas para nós e fazendo configurações padrões para que a gente não precise se preocupar com isso tá facilitando nossa vida então ele tá fazendo auto configurations então quando a gente tem quando a gente vai usar isso a gente precisa colocar essa anotação de @enableautoconfiguration para que o Spring Framework né saiba

que a gente tá fazendo né configurações automáticas aqui na nossa aplicação então o springboot ele condensa aqui nessa anotação @os springboot essas três anotações aqui porque é o que ele vai precisar utilizar E aí por fim tem essa anotação de @component scam que vai permitir que o Spring escanei todo o pacote aqui do nosso projeto né todo o pacote atual em busca dos componentes das classes de configuração das classes de service né dos controladores aqui espalhados pela nossa aplicação para que ele faça todo o gerenciamento de dependências dessas classes porque o Spring vai fazer a

injeção de dependência n nossas classes pra gente né e todo o gerenciamento do ciclo de vida desses componentes que a gente vai ver depois também como é que funciona então basicamente essa anotação aqui de @ springboot concentra essas outras três anotações que eu mostrei para vocês para fazer aqui o enab automático de dessas né três coisinhas que Eu mencionei Então essa aqui é a classe principal da nossa aplicação Spring boot certo e agora que a gente já entendeu isso vamos partir pra escrita das nossas primeiras classes dos nossos primeiros componentes começar a explorar alguns outros

recursos do Spring Então a primeira classe que a gente vai criar aqui dentro da nossa aplicação Spring vai ser uma classe que vai representar um Controller certo que é uma classe que vai receber requisições http aqui na nossa aplicação Então dentro aqui de com. Keeper PF Spring app né que foi o nome que a gente deu pra nossa aplicação a gente vai criar um novo package certo pra gente concentrar aqui os nossos controllers que eu vou chamar de Controller e aqui dentro de Controller eu vou criar o meu hello world Controller certo que vai ser

o nosso primeiro Controller aqui da nossa aplicação essa nossa classe para que o Spring identifique que ela é um controle e faça um Controller né e faça todas as configurações por baixo dos panos para que ela Receba as requisições e consiga fazer as respostas né montar as respostas http pros nossos clientes para quem fez as requisições paraa minha aplicação eu vou precisar decorar ela com algumas anotações também a primeira anotação que a gente vai precisar colocar é a anotação @restcontroller essa anotação aqui do @ rest Controller ela indica que essa classe é um Controller rest

o que que isso significa isso significa que ela tá combinando as anotações de @c Controller e anotação de @responsebody por quê Porque um Controller ele não necessariamente precisa retornar uma resposta direta como um Jason ou um XML o meu Controller ele poderia estar retornando também uma página certo renderizando uma página HTML isso né mais no passado ali da web era mais popular onde a gente construiu uma aplicação um servidor que além de fazer toda a parte lógica né aqui os serviços enfim da nossa aplicação conexão com banco de dados também tornava as nossas páginas a

gente não seguia ali uma metodologia de ter o front-end backend separado às vees poderiam ser juntos né então aqui a gente poderia construir um Controller que retornasse uma página Web um HTML não é o nosso caso a gente tá criando uma API né uma API que só tem ali os end points H que vão ser chamados pelo frontend para retornar as requisições Enfim uma API que vai lidar somente com a parte do backend em si né Toda a parte ali das regras de negócio a parte lógica e conexão com banco de D né E que

vai retornar somente respostas http através ali de um de um response body com um jz ou um XML Enfim então a gente tá construindo aqui uma pzinha e seguindo o padrão de rest que seria não manter não manter o status da requisição não manter né o status do cliente que tá fazendo essa requisição quando a gente tá fazendo falando de apis que não são rest né Elas mantém o estado de como aquele cliente está Então vou até explicar aqui para vocês vai além do conteúdo desse vídeo mas só para vocês entenderem a gente pode ter

apis que são stateless que é o caso de apis rest ou stateful o que que isso aqui significa quando a gente tá falando de uma API stateful ela vai manter dentro dela um o estado de cada cliente então por exemplo eu né Eu sou um cliente dessa api ó o estado de cada cliente é mantido no servidor eu vou fazer uma requisição assim que eu fizer uma requisição vou ter que me identificar né me identificar pode ser pro login sem até para o meu IP ele vai o servidor Ali vai ter alguma forma de me

identificar isso depende de como o programador fez E aí depois a partir do momento que eu fizer uma próxima requisição eu não vou precisar ficar enviando os dados novamente eu não vou às vezes precisar ficar enviando token nem nada do tipo porque ele já vai manter um estado ali se eu tô logado ou não do que que eu fiz anteriormente né se eu tô proibido de fazer alguma requisição ou não então ele mantém um estado ali né do do cliente no servidor quando a gente tá falando de uma API stateless a cada nova requisição né

eu recebo todas as informações que eu preciso para fazer né aquela funcionalidade que o cliente tá pedindo então quando a gente tá falando de uma ap R que é uma uma API que é stateless eu vou excluir algum dado eu vou excluir alguma algum Post meu no Facebook eu envio o meu token que eu já tô autorizada envio qual post que eu quero excluir e às vezes vou ter que enviar mais alguma informação se eu quero só excluir ou se eu quero arquivar se eu tivesse numa payk stateful eu já ia est logada certo e

eu já ia tá num contexto ali talvez eu precisasse enviar somente né Qual é o post que eu quero excluir Não é precisava mandar um token no caso aqui de uma API que é stateless eu vou ter que estar sempre enviando ou o meu login em senha em todas as requisições só que isso não é legal pro cliente né ele tá sempre mandando o login e senha dele então no caso a gente sempre manda um token que identifica que aquele cliente que aquele token foi gerado no momento que o cliente fez a autenticação né que

ele se autenticou E aí recebeu um token ali e aí ele usa sempre esse Token para se identificar mas aí em toda requisição ele precisa estar se identificando né né e mandando tudo que a ap precisa saber PR de quem ele é e também tudo que a pi precisa saber para conseguir aplicar aquela funcionalidade no caso do stateful não ele mantém o estado do cliente no servidor ele reconhece o cliente a cada requisição tá então quando a gente tá falando de uma pay rest a gente precisa utilizar esse @r Controller que vai concentrar essas duas

anotações aqui em uma anotação foi uma explicação mais extensa Mas é só para vocês entenderem o por vocês estão fazendo essas coisas certo eu sou muito do do método de de aprendizado acho que a gente precisa entender o porquê das coisas e não só replicar o que a outra pessoa tá fazendo eu podia vir aqui né num vídeo de 10 minutos e mostrar para vocês ó quer que é um Controller Coloca essa anotação essa outra aqui vai ter essa anotação e 10 minutos a gente fazia né mas aí vocês não I entender o porque vocês

estão fazendo isso então tendo esse conhecimento vocês vão em algum cenário diferente vão precisar construir uma aplicação diferente utilizando Spring Vocês já vão saber o que vocês precisam alterar porque vocês entendem as coisas que vocês estão fazendo aqui dentro né do projeto de vocês então beleza criamos a nossa classe aqui com a anotação @r Controller agora a gente quer criar um end Point a gente já tem uma classe que representa o meu Controller só que eu preciso né mapear os meus end points eu preciso mapear quais pefs ali né end points a minha essa minha

classe aqui em si vai estar ouvindo vai estar recebendo requisições e respondendo a elas então o que que eu vou precisar fazer vou precisar colocar aqui um @requestmapping para ela né uma anotação de @ requestmapping e se vocês perceberem aqui essa anotação já é um pouco diferente eu já tô passando um parâmetro para ela também por quê Porque além de adicionar a configuração de mapeamento de um request eu tô dizendo qual request eu quero mapear então tô adicionando um parâmetro para essa configuração Então esse meu Controller aqui ele é um rest Controller que escuta a

todas as requisições que chegarem no endp de barra hello world certo e agora eu posso declarar um método aqui dentro dele método público que vai retornar uma string por exemplo que vai ser o meu hello world E vai retornar um hello world beleza esse método retorno uma string Mas qual método http esse Meu método escuta né esse Meu método http pode responder no post pode responder no get pode responder no delete pode responder no no pet no options no Head qualquer um desses métodos http então preciso dizer pro Spring Qual método http esse método aqui

da minha classe especificamente é responsável por responder então a gente vai colocar mais uma anotação que vai ser uma anotação agora em cima do método que vai ser aqui um get mapping Então esse endp aqui esse método aqui escuta o endp http de bar hello world No método get certo então aqui basicamente o que a gente tá dizendo é que esse método aqui vai responder às requisições Get No endp bar hello world certo e se a gente quisesse adicionar mais uma um pef aqui na minha URL certo mais um PF aqui no meu end Point

eu poderia vir aqui passar um parâmetro e adicionar então bar hello world barget aí ele ouviria para bar hello world barget certo mudaria aqui o end Point que esse método aqui vai estar respondendo bem mas aqui no caso eu vou deixar somente como getmapping para responder aqui pra raiz de só barra hello world e agora a gente vai Executar a nossa aplicação pela primeira vez Então a gente vai entrar aqui no nosso first Spring app application né na nossa classe de entrada e aí o intelij já identifica que essa é uma classe que ele consegue

executar certo e a gente consegue clicar aqui no botãozinho Run o lombo vai perguntar se eu quero fazer o enable do processamento das anotações eu vou colocar o enable senão ele não vai conseguir fazer o l aqui das anotações do lbo a gente ainda não utilizou nenhuma mas né já é bom deixar enabled então aqui ele já iniciou a nossa aplicação Spring né já já logou aqui no terminal ó Spring e tal que ele inicializou se vocês derem uma olhada aqui ele nos indicou né que o tuncat Né o servidor tuncat startou na porta 8080

certo na porta http 8080 Então dessa forma as requisições que a gente fizer pra porta 8080 aqui na nossa máquina né no nosso local host vão ser recebidas aqui pela nossa aplicação E aí tudo que chegar no endpoint bar hello world vai ser direcionado aqui para esse nosso Controller Então vamos abrir aqui o navegador e vamos fazer o nosso primeiro teste e antes da gente continuar o vídeo eu queria aproveitar esse momento para falar rapidamente para vocês sobre a formação de Java lá na Rocket City para quem não conhece a Rocket tá oferecendo uma formação

voltada pro mundo de Java que vai fazer toda essa parte da introdução do Spring que a gente tá vendo no vídeo de hoje mas vai ir muito mais além e muito mais profundo passa comeando também pela parte de autenticação com Spring Security e jwt a parte de conexão com banco de dados utilizando o Spring data JPA a parte de Deploy da nossa aplicação Spring configuração com docker design patterns do Java e muito mais então para quem quiser se aprofundar no Java a formação da Rocket é o que você tá procurando E além disso se vocês

usarem o meu cupom kerd vocês vão ter 10% de desconto no plano de assinaturas do Rocket City One que não vai dar acesso somente a formação de Java mas sim todas as formações que a Rocket City disponibiliza como por exemplo Python csharp react node.js Inteligência Artificial devops e a nova trilha de GO e vários outros conteúdos que vocês vão encontrar por lá então eu vou deixar o link aqui na descrição do vídeo para quem quiser aproveitar esse desconto e bora continuar então aqui no nosso navegador a gente vai acessar né o nosso localhost porta Então

vou dar um enter aqui e quando a gente acessa a gente já consegue ver aqui né que ele nos retorna um hello world que foi justamente a string que a gente colocou lá no nosso Controller certo a gente colocou aqui o return hello world eu poderia vir aqui e mudar para Hello video certo então eu teri aqui que parar a execução da minha aplicação inicializar de novo porque a gente não tá com o Live Reload ainda ligado depois a gente vai fazer o enable dessa funcionalidade para vocês verem como é bom né como facilita a

nossa vida então dei o Reload aqui na nossa aplica aplicação dou um cont control R então ele mostra que Hello video Se eu tentar acessar um end Point que não existe então se eu tentar acessar a barra Fernanda Kiper certo ele vai me dar um erro né um erro aqui de uma página genérica White Label aqui do Spring dizendo né que teve uma exceção 404 not found certo não foi encontrado esse recurso aqui na nossa aplicação e a se a gente der uma olhada aqui no nosso terminal deixa eu ver aqui se ele não logou

Ele nem chegou a logar né mas ele loga aqui normalmente que um recurso que não existe foi acessado né e ele disparou ali a a página de erro genérico certo isso aqui a gente consegue tratar também depois então a gente consegue tratar essas exceções lá no nosso Spring né na nossa aplicação Spring capturar elas e retornar de uma forma mais amigável pro usuário Ou a gente pode deixar também essa forma aqui de padrão só que isso aqui não é legal porque ele expõe muito da parte interna da nossa aplicação né inclusive que o nome das

classes ó se a gente vê no final que ele mostra né no no Org ping Spring Framework web pserver l. Resort né mostrou aqui né Toda a stack Trace do Nosso Erro isso aqui não é muito legal certo mas isso aqui fica para assunto de outro vídeo inclusive já tem vídeo aqui no canal vou deixar aqui no card certo o link do vídeo onde eu mostro como fazer a padronização aqui da das exceções no spring como a gente fazer o tratamento dessas exceções de uma forma bem bacana né E para retornar de uma forma mais

amigável pro cliente da nossa api e também de uma forma mais segura tá então continuando aqui voltando pro nosso intelij se vocês né perceber vocês viram que a nossa aplicação começou na porta 8080 Tá e agora a gente vai entrar para algumas partes e configurações aqui do Spring também que eu falei que eu ia falar para vocês como é que a gente faz então essa porta 8080 é a porta padrão se a gente quiser alterar isso a gente pode e como é que a gente faz né alteração Dessa porta padrão bom lembra que eu falei

para vocês que lá dentro da pastinha resources era a pastinha onde a gente deixava as configurações da nossa aplicação Spring Então posso vir aqui nesse arquivo de configuração e colocar né o server pport e ao invés de colocar na porta 8080 eu boto na porta 3.000 aí eu venho aqui inicializo a minha aplicação E se a gente dar uma olhadinha no terminal ele vai dizer né que inicializou o nosso server agora na porta 3000 e não mais na porta 8080 então se eu vier aqui pro navegador e tentar enviar pra porta 8080 já vai dar

um erro se eu vier aqui e mandar agora pra porta 3.000 né ele vai me retornar à página de erro porque não tenho né esse end Point se eu vier aqui para hello world ele deve me retornar lá a nossa string do Hello V então a gente consegue fazer algumas configurações Gerais aqui da nossa aplicação nesse arquivo né application P properties inclusive é aqui depois que a gente vai fazer a configuração da URL do nosso banco de dados que o Spring vai ter que utilizar do username que ele vai ter que usar para logar no

nosso banco do da password enfim isso aqui tudo a gente faz aqui seria por exemplo nosso Spring p deir source.dll source ponto username password Enfim tudo isso aqui a gente coloca na nossa no nosso application pon properties E aí a gente pode colocar tanto dessa forma chumbada quanto através de variável de ambiente então eu posso vir aqui e pegar uma variável de ambiente certo usar aqui colocar né o ã DB host então eu posso escolher colocar DB host ou usar esse valor padrão aqui do meu local host e esse meu DB host ser uma variável

de ambiente e essa variável de ambiente é posso injetar no momento de inicializar a minha aplicação né ou talvez injetar lá no docker fazer quando o docker for Executar a aplicação ele passar via parâmetro aqui de linha de execução enfim né Aqui tem outras coisas mais avançadas que a gente pode fazer mas fiquem aí na cabeça de vocês que é nesse arquivo aqui que a gente vai fazer essas configurações inclusive o Spring tem uma coisa muito legal aqui que são os perfis de configuração então o Spring permite que a gente defina diferentes perfis de configuração

justamente para caso a nossa AP ap esteja rodando em diferentes ambientes então quando a gente tá falando de uma aplicação a nível Empresarial a gente pode na nossa empresa ter tanto ambiente de produção que é o ambiente final que vai responder às requisições reais do meu cliente quanto ambientes de teste que são ambientes que somente a minha equipe né o pessoal do meu time ou da empresa utiliza para testar a aplicação antes de disponibilizar ela pro cliente que é uma aplicação Deploy ela tá rodando lá na nuvem ou Enfim no meu servidor on premise mas

ela não tá disponibilizada pro cliente então não quero usar meu banco de dado dados real banco de dados com valores dos clientes eu uso outro banco de dados não quero usar as mesmas configurações aqui da aplicação talvez rodar numa porta diferente Enfim então eu posso criar esses diferentes perfis de configuração e a como é que eu posso fazer isso é só mudar o nome do meu application P properties então eu posso ter o meu application P properties comum mas eu posso vir aqui criar um novo arquivo que vai ser o meu application Dev né pon

properties E aí depois aqui no momento né de Executar a nossa aplicação Spring a gente consegue definir aqui o nosso profile certo profile que eu quero que ele use e ele pode usar o profile de Dev Então posso vir aqui no meu profile de Dev colocar o server port com 8080 E aí eu venho aqui no meu application P properties né e coloco uma outra configuração que é esse Spring profiles Active para dizer qual é o profile que deve estar ativo então quando eu coloco que é o profile de Dev ele vai utilizar esse arquivo

aqui que a gente criou E aí vai passar a utilizar a porta 8080 que a gente configura configurou aqui ao invés da porta 3 1000 que tá configurada nesse application P properties E aí esse valor aqui do Dev eu posso recuperar de uma variável de ambiente né então eu posso pegar o meu Active profile de uma variável de ambiente e aí Ele carrega por padrão o valor da variável de ambiente senão se ele não encontrar essa variável de ambiente ele usa o valor de Dev então eu posso fazer todas essas configurações aqui na minha aplicação

Spring né Para que eu consiga ter ela adaptada para diferentes ambientes onde eu for executar ela e aí se a gente vê aqui ó ele já passou a utilizar a porta 8080 ao invés de usar usar a porta 3000 que tá declarada aqui nesse arquivo porque eu falei que o profile que tá ativo é o profile de Dev ele tentou recuperar da variável de ambiente não encontrou então caiu aqui no meu fallback certo que é para usar o valor de Dev Então essa aqui são todas as configuraçõe zinhas que a gente pode fazer aqui no

spring certo tem várias outras isso aqui é muito extenso tem muitas coisas que a gente pode fazer mesmo inclusive aqui dentro do próprio intelij a gente pode vir aqui adicionar uma configuração pra execução da minha aplicação aí eu executar pegar aqui a minha classe principal certo que ele vai executar e passar variáveis de ambiente aqui então eu posso passar o meu à Active profile por aqui certo Active profile passando como default aqui e aí deixar assim vamos botar o apply acho que é só isso que eu preciso fazer Active profile aí quando ele for tem

que dar um nome aqui também né esqueci de dar um nome ficou unnamed Vou botar aqui o meu default certo e aí quando eu for rodar usando a configuração defold ele vai recuperar aquela variável de ambiente que eu declarei lá e aí já vai passar a utilizar né a porta 3000 porque ele tá usando o profile default que o application P properties então tem várias coisas bacanas aqui que a gente pode fazer utilizando esse application.on properties e integrado aqui com intelij também que fornece várias ferramentas pra gente né personalizar a nossa aplicação e fazer simulações

aqui de ambientes bem legal então fica aí essa dica para vocês se aprofundarem depois mas esse aqui é o básico que a gente precisa entender mesmo e agora que a gente já entendeu toda essa parte da da classe de configuração vamos partir para algumas outras anotações aqui do Spring certo que vão além aqui do meu rest Controller para vocês entenderem como é que ele faz o gerenciamento das dependências aqui nas nossas classes da aplicação como é que a gente pode fazer para definir aqui os nossos Servers para definir aqui o nosso Services para definir as

nossas classes de configuração e etc Então o que a gente vai fazer agora é criar a nossa primeira classe service certo a nossa primeira classe de serviço então a gente vai criar um New package aqui ao lado do nosso package Controller que a gente vai chamar de package service ou poderia ser Services também se a gente criar tudo no plural e aqui dentro eu vou criar o meu Hello Word service certo essa nossa classe service é uma classe que a gente chama de serviço mesmo no contexto de aplicação que geralmente são classes que contém a

lógica aqui da nossa aplicação as regras de negócio né Toda a parte ali da das regras definidas pelos nossos poos pelo nosso chefe de como deve funcionar as coisas normalmente a gente concentra isso em classes de service o Controller ele só recebe a requisição mas passa o processamento paraas classes de service para elas fazerem o trabalho pesado ali o trabalho lógico certo e a gente precisa decorar essas classes com a anotação @service essa anotação @service basicamente ela vai indicar pro Spring né que essa classe é uma classe de service e que tá sendo gerenciada aqui

pelo Spring então depois qualquer outra classe que pedir né uma Instância dessa minha classe aqui de service o Spring já vai conseguir gerenciar a injeção dessa dependência na outra classe que tiver uma dependência com essa classe aqui certo dentro dessa nossa classe de service que a gente vai fazer a gente vai criar um novo método que basicamente vai é vai retornar hello world hello vídeo tá poderia fazer uma lógica aqui enfim né aí vai de cada aplicação mas só para vocês entenderem a organização aqui das classes Então vai retornar o Hello vídeo aqui Ou hello

world mesmo hello world e vai receber uma string que vai ser o name certo e vai retornar hello world Plus name tá então vai retornar hello world Fernanda tá que foi vai ser o que a gente vai passar aqui então essa é minha classe de service Beleza então aqui a gente vai concentrar as nossas lógicas enfim os processamentos que a gente quer fazer os acessos aos nossos reposes também depois que são as classes que vão fazer a conexão com banco de dados etc vão ficar concentrados aqui no service tá então lá no nosso Controller agora

ao invés da gente fazer a lógica dentro do Controller o que a gente vai fazer é acessar a nossa classe de Service para que ela faça isso então como é que a gente vai fazer isso a gente precisa indicar aqui pro Spring que a gente precisa de uma estância da essa classe de hello world service como é que a gente pode fazer bom a gente pode fazer isso de duas formas a gente pode criar um Construtor aqui então o Construtor né tem que ser um método público com o mesmo nome da classe certo que aí

vai receber aqui por parâmetro um hello world service E aí o que que ele vai que vai ser aqui o meu hello world service e o que que ele vai fazer ele vai fazer o hello world service receber o meu dis P hello world service desculpa receber o nosso hello world service que eu recebi por parâmetro então eu posso fazer isso criando um Controller e aqui eu declaro que eu tenho um uma dependência privada que é o meu hello world service aqui eu vou chamar de hello world service eu atribuo ela ao parâmetro aqui que

eu recebi posso fazer isso certo e aí no momento aqui de execução o Spring já vai injetar esse hello world service para mim então aqui eu posso fazer um return ao invés de passar certo a string direta vou fazer return hello world service pon Hello Word passando meu nome tá então quando a gente executar aqui ó vocês vão ver que eu em nenhum momento eu criei o uma estância da classe hello world service na mão a gente não criou aqui ó eu não precisei vir aqui e fazer um New hello world service certo eu não

fiz eu não criei a Estância da classe eu só recebi por parâmetro aqui no meu Construtor e quem passou a Estância dessa classe para mim foi o Spring Quem fez a injeção da dependência foi o Spring vocês vão ver que aqui no spring a gente trabalha bastante com injeção de dependência então voltando lá pro nosso navegador eu venho aqui pro R Point hello world Olha já tá passando um hello world Keeper certo então essa é uma forma da gente fazer mas tem outra forma bem Popular também um pouco mais simples que é ao invés de

eu colocar o meu Construtor Eu só vou colocar aqui a dependência que eu quero certo ó tá aqui o atributo na classe que eu preciso dessa dependência e eu vou colocar um @autowired certo vou colocar essa anotação aqui essa anotação de @autowired vai indicar pro Spring que esse atributo aqui essa dependência ela tem que ser injetada ela é autowired automaticamente injetada na minha classe e aí se eu der aqui um restart na minha aplicação Vocês já vão ver certo que aqui ela vai continuar funcionando hello world Keeper ó não tá dando erro porque ele fez

a injeção de dependência para mim Então essa é uma forma que a gente pode trabalhar também com injeção de independência e essa é uma forma bem Popular tá vocês vão ver bastante isso quando forem mexer em aplicações Springs mas fiquem cientes que a gente pode seguir né esses dois essas duas abordagens E aí tem outra tipo de classe aqui que vocês vão ver bastante que a gente vai entender como é que elas funcionam que são as classes de configuration Então vou criar aqui um novo Packet certo aqui chamado de configuration e a gente vai criar

a nossa primeira classe de configuração Então vou chamar aqui de Hello configuration o que que são essas classes de configuração Tá o que que são a classe de configuração ela é basicamente utilizada aqui no spring pra gente definir ã bein certo e instâncias de classe no contexto de uma aplicação Spring pra gente fazer essa configuração porque assim ó o Spring ele consegue fazer o gerenciamento das classes que são componentes do Spring certo são aqui que foram criadas dentro da nossa aplicação que foram né mapeadas aqui diretamente mas às vezes a gente precisa que o Spring

faça a injeção de uma dependência para nós de uma classe externa que veio de outra biblioteca certo que uma biblioteca que não tá dentro do Spring por exemplo a biblioteca do SDK da Oracle quando a gente for conectar na Oracle Cloud ou SDK da WS enfim certo e às vezes eu quero usar o autard nessas classes também o Spring não vai saber mapear qual classe é essa que eu tô pedindo para que ele me injete se eu não faça a configuração então eu posso precisar criar uma classe de configuração onde essa classe de configuração vai

ter @ vai ter anotação @configuration que indica pro Spring que ele tem que usar essa classe aqui como base para configurações e aí dentro dessa classe de configuração normalmente eu defino métodos públicos que Retornam o tipo da classe que eu quero configurar por exemplo SDK aws né digamos Tô dando um exemplo tá SDK WS um tipo aqui e aí o nome do meu método vai ser SDK WS ele vai retornar um New stws E aí eu decoro esse método com @ Bin por qu o que que esse @ Bin Aqui tá dizendo certo a anotação

@ Bin ela é usada dentro das classes que tem anotação de @configuration para indicar pro Spring que ele deve gerenciar o retorno aqui desse método como um bim lá no contexto da minha aplicação certo que basicamente esses Bins aqui é criar instâncias de classe certo que não podem ser gerenciadas pelo Spring como eu falei para vocês então classes que vem de bibliotecas de terceiro ou que eu preciso de um de uma de um controle específico sobre a implementação dessa classe e aí quando o Spring for analisar essas classes de aroba configuration ele vai mapear todos

os métodos né que estão anotados com arabin e ele vai ter um mapinha lá de tipo ah se em algum momento alguém pedir um tipo aqui de né alguém pedir uma injeção de dependência do tipo de SDK WS ele sabe que ele tem que recuperar isso dessa classe aqui de configuração que tá criando a Estância para ele certo porque o Spring que não ten a inteligência de saber o que que é s dkws eu posso ter instalado a dependência aqui no meu P XML etc mas tá instalada essa dependência pode trazer diversas classes dentro dela

né então eu preciso fazer esse mapeamento direto aqui pro Spring E aí a gente usa as classes de configuração para isso certo e a gente vai ter isso mapeado e às vezes tem outro ponto Às vezes a gente tem umas classes que a gente tem assim ó o meu my service certo o meu serviço aqui eu vou chamar de my service o método só que normalmente esse tipo my service ele não é é gerado através de uma classe my service que nem a gente declarou aqui Ah hello world service para eu ter uma classe do

tipo hello world service é só eu dar um New hello world service às vezes não é assim que funciona às vezes a gente tem que chamar uma classe de ã my service implementation porque às vezes eu tenho a interface somente aqui no my service mas a implementação de fato tá em outra classe né ou preciso ah toda vez que alguém pedir um carro ou toda vez que alguém pedir alguma classe do tipo transporte ao invés de criar um novo Uma Nova Estância da classe transporte eu quero retornar uma estância da classe Car a classe Car

ela digamos aqui né bem coisa de herança aqui de de programação orientada objetos eu tenho a classe transporte né que é a minha interface só que a classe A classe Car é uma implementação da classe transporte certo implementação da classe transporte e ela é do tipo transporte também só que ela é uma implementação né a transporte aqui é interface e a a car é uma implementação enfim enfim aí toda vez que alguém pedir um transporte eu quero retornar na verdade um tipo caro o Spring não vai ser inteligente suficiente para dizer para mim se eu

quero um caro quero um ônibus Enfim eu posso ter diversas implementações da classe transporte Então eu preciso mapear isso diretamente aqui para ele também então eu faço isso através das classes de configuração E aí aqui o arabin serve pra gente indicar pro Spring ã a instâncias de classe para que ele consiga fazer o gerenciamento quando ele não consegue fazer automaticamente e aí uma coisa muito interessante do arbin é que por padrão as instâncias aqui geradas né com arabin são do scopo singleton então uma vez que ele gerou uma estância do car ele vai injetar a

mesma Estância do car para todas as classes que pedirem o Car então se eu tiver usando o carro aqui no meu hello world service e tiver usando o carro lá no meu 1 2 3 service vai ser o a mesma Instância do objeto carro certo o mesmo objeto carro vai ser a mesma Instância da classe carro então pro padrão ele funciona aqui como um singon então se eu fizer alguma anota se eu fizer alguma configuração que eu botar carro pname aqui nessa classe certo passar o name Aí lá na outra classe eu pego né o

carro lá no meu Controller por exemplo se eu tiver usando Tá tudo bagunçado aqui mas só para vocês entenderem tá vou aqui pego o meu carro Digamos que eu tenho a mesma Estância do carro exceto o pego o name né get name vai retornar o nome que eu setei lá na outra certo se aquilo tiver executado antes porque é a mesma distância sing eu posso alterar esse comportamento mas esse é o comportamento padrão aqui do Spring tá então entendemos aqui as principais a anotações certo do do Framework né as mais utilizadas aqui no dia a

dia por assim dizer certo e com isso aqui Vocês já vão ter bastante insumo para começar a construir as aplicações de vocês utilizando o Framework e agora a gente vai partir para uma última parte que vai ser bem rapidinha que é só algumas configurações específicas aqui do nosso Controller para vocês entenderem como é que a gente consegue receber alguns parâmetros né através da URL como é que a gente consegue fazer a configuração do nosso b e o mapeamento aqui de alguns outros métodos Então vamos entender isso agora então a gente vai criar agora um novo

método aqui dentro do nosso Controller que vai ser um método tipo post certo a gente vai mapear um um post então quando alguém enviar uma requisição de post pro nosso endp aqui de barra hello world E aí o nome desse nosso método vai ser vai ser um método público que vai retornar uma Spring que vai ser o meu uma string né Falei uma Spring vai retornar uma string que vai ser o nosso hello world post e aqui a gente vai fazer algumas configuraçõe zinhas que a gente ainda não viu a primeira delas que a gente

vai fazer é que normalmente no endp de post O que que a gente recebe certo normalmente a gente costuma receber um uns valores pelo Bore né pelo B da requisição a gente recebe um Jason ali contendo alguns valores porque o post é um método usado para criação de novos recursos na api né ou seja adicionar novos dados no nosso banco de dados ou em qualquer outro lugar que eu esteja utilizando para fazer o armazenamento desses dados então aqui nesse nosso método a gente vai ter que né receber essas esses valores que o nosso cliente mandou

pelo B na requisição então o que que a gente vai fazer a gente vai colocar aqui uma anotação de @ então aqui @requestbody então esse anotação @request a gente tá colocando na frente de um parâmetro que esse nosso método recebe então percebe aqui que ele tá indicando um erro não adianta só eu colocar isso eu preciso dizer né Qual é o parâmetro aqui que eu vou receber então vou ter aqui um parâmetro do tipo string que vai ser o meu Body E aí eu tô decorando o parâmetro com uma anotação então vocês já viram que

a gente consegue decorar a classe com uma anotação o método e também os parâmetros a gente consegue decorar com anotações aqui certo então aqui @request Body que eu tô indicando pro Spring que esse parâmetro aqui desse método é para ser injetado certo quem vai injetar esse parâmetro vai ser o Spring ele vai injetar aqui dentro o que ele receber pelo B lá na requisição certo então a gente tá dizendo pro Spring ó injeta nesse parâmetro aqui nesse parâmetro que eu tô chamando de body tudo que vier lá no request Body nessa requisição certo e aqui

não precisa ser só um tipo primitivo Então posso dar uma classe aqui eu vou criar uma nova uma um New package aqui que eu vou chamar de domain certo só o domínio da minha aplicação eu vou criar uma New Java Class que vai ser o meu user certo esse meu user eu vou decorar eu vou declarar aqui que ele vai ter um Private string name e Private string e-mail não vou declarar os getters e os setters eu vou usar o L boock para isso então vou tirar todos aqui os os construtores e tal que o

CoPilot aqui sugeriu para mim o que eu vou fazer eu botar @getter @setter e @allargsconstructor aqui do lombo ele já vai gerar para mim automaticamente os métodos getter setters e o Construtor eu não preciso escrever esse código né código boiler Plate né que seria só para que a classe funcionasse eu não preciso ele faz aqui para mim e fazendo isso eu recebo aqui via request Body esse meu user C tem mapeio aqui que é esse Body é do tipo user aí o Spring já vai mapear para essa classe aqui vai receber o name e o

e-mail E aí aqui o que eu consigo fazer é retornar hello world certo e aqui mais Body PG name retornando o nome da pessoa então aqui eu criei um end Point de post certo que recebe um usuário e já tô retornando aqui usando o valor que eu recebi no Body E aí a gente vai dar um restart aqui na nossa aplicação e vamos testar para vocês verem isso aqui funcionando então já tô aqui com insomne aberto certo peguei um um outro uma outra Collection que eu tinha aqui e vou enviar uma requisição pra Barra kttp

local host porta 3000 que é onde tá rodando a nossa aplicação barra hello world usando o método post vou enviar aqui ó ele vai me retornar um hello world Fernanda porque ele pegou o Fernanda aqui né do B posso mandar teste ele vai mandar hello world teste porque ele já tá pegando aquele valor criando uma Instância da classe user com essas informações e aí depois recuperando aqui né o através do getname certo então isso aqui é um parâmetro uma anotação que vocês vão usar bastante né @ requestbody e a última anotação que eu quero mostrar

para vocês é a anotação de pef verbal Então olha só que interessante a gente vai normalmente receber também através da URL a gente pode receber um ID por exemplo né normalmente o pessoal manda o ID pela URL então barra user barra e aí o ID desse usuário então normalmente a gente vai receber uma requisição nesse formato aqui aí como é que eu faço para indicar pro Spring que eu quero pegar esse valor que veio na URL bom a gente coloca aqui na URL ã essas chaves certo a gente coloca as chaves e o nome da

variável E aí aqui nos parâmetros da do nosso método o que que a gente vai fazer a gente vai declarar um novo parâmetro aqui no meu método que vai ser meu parâmetro ID certo que vai ser aqui uma string E aí eu vou indicar pro Spring que ele tem que injetar esse ID aqui que ele recebeu nesse meu parâmetro aqui do meu método certo e aqui eu coloco posso mapear se eu tiver mais de um parâmetro ele já vai saber que é aquele ali porque eu só tenho um mas eu posso mapear ó o idit

mapeia para esse parâmetro aí se eu tiver recebendo mais uma informação via pef verbo eu vou mapeando aqui e agora a gente consegue fazer Ó bora Body get name eu vou passar aqui também o ID no retorno para vocês verem que ele tá conseguindo recuperar então a gente volta lá pro insomnia passa aqui um ID através de pef verbal né de variável aqui de de URL E aí eu já vou receber ó hello world test E aí o o ID ali que eu passei certo então isso aqui são anotações que vocês tem que estar bem

acostumados a a entender bem elas porque vocês vão utilizar bastante Principalmente quando a gente tá construindo uma API certo então isso aqui são coisas que a gente utiliza bastante no nosso dia a dia e aí tem uma outra eu falei que era a última mas tem só mais uma que que a gente precisa ver né que são as o request perma então isso aqui o pef verbo a gente usou para extrair valores da nossa URL Mas a gente pode também utilizar o request perman para extrair parâmetros de consulta da URL porque normalmente a gente pode

receber uma requisição assim certo e no final receber parâmetros de consulta né que são os qu parms que a gente chama ah Filter E aí passar um filtro aqui né para filtrar pelo nome por exemplo filtrar pela data certo isso aqui são os query perms que vem depois aqui do ponto de interrogação a gente pode mapear isso aqui também através da anotação @ Então como é que a gente vai fazer a gente vai vir aqui ó no nosso método de novo e vamos colocar que ele recebe mais um parâmetro aí eu vou colocar aqui ó

que ele recebe o parâmetro que é do tipo request que é né anotado com request perm eu vou chamar aqui de um uma string certo que vai ser o meu meu Filter certo eu posso receber esse Filter aqui certo ele pode ter até um valor padrão então eu posso definir um valor padrão para ele aqui eu aqui na verdade eu tenho que colocar o value né Qual é o nome desse parâmetro que eu tô querendo mapear então aqui é o Filter né o nome dele lá porque pode vir vários desses parâmetros na URL e é

um default value um valor padrão e o Filter aqui pode ser sei lá nenhum nenhum filtro certo e aí vocês vão ver aqui ó que eu vou ter minha meu minha variável Filter e eu posso retornar aqui só hello world mais Filter E aí par aqui execução inicio novamente venho aqui no meu insônia e mando esse Filter e eu vou receber ó hello world Fernanda venho aqui e mudo o filtro mudo o filtro para vídeo hello world vídeo porque ele já tá pegando isso se eu mandar um que perm com outro nome que não seja

Filter ele não vai mais recuperar isso certo que eu mapei ali que o nome né do meu request perm é Filter certo então se eu mandar aqui uma outra coisa que seja sei lá Blue blue igual a vídeo ele usa o valor padrão que é o valor nenhum tá então tudo isso aqui são configurações que a gente pode ir fazendo né nos nossos métodos aqui que escutam requisições http tá então Esso aqui são os mais importantes em suma é isso aqui que vocês precisam saber para começar a construir as apis de vocês utilizando o Spring

Então galera para Esse vídeo foi isso e se você quer começar a criar aplicações mais completas e complexas com Spring Eu recomendo que você assista essa playlist vídeos aqui onde eu já resolvi de diversos desafios de programação real de empresa certo desafio de vagas e também a gente já construiu diversos projetos completos utilizando o Framework Spring se você gostou desse vídeo Não esqueça de deixar seu like se inscrever aqui no canal e eu gostaria de aproveitar esse momento para agradecer todos os membros aqui do canal por todo o carinho por todo o suporte e um

agradecimento especial a todos os membros seniors que você são muito especiais e moram no meu coração é isso galera e até o próximo vídeo [Música]