JAD CAP03 2024 VA08 CONSULTAS DERIVADAS DE METODO

Além da JPQL,
também podemos construir

as consultas através
de uma outra forma

que chamamos
de consultas baseadas em métodos.

Ou seja,
conseguimos utilizar os nomes

dos campos que temos na classe Java,
como parte do nome da função.

E claro, temos que seguir algumas
regras para conseguir fazer isso.

Então, o nome do método
que vamos criar

é o que vai determinar
que tipo de consulta a JPA fará.

Então, chamamos isso
de consultas derivadas de métodos.

Beleza?

Então vamos usar um nome
que é padronizado,

vamos utilizar algumas palavras
que a JPA nos indica.

E aí, com base nos nomes
dos atributos da nossa classe,

conseguimos fazer a consulta,
beleza?

Vamos dar uma olhada
nessa documentação,

para entendermos melhor
o que isso quer dizer.

Vamos lá.

Estou aqui na documentação
desses métodos, né?

Nessas consultas baseadas
em métodos.

Então,
o que acontece?

Olha só,
as pesquisas que vamos usar,

a forma que vamos escrever
os métodos,

os nomes dos métodos,
para poder fazer as pesquisas.

E aí temos aqui o padrão, tá?

Então,
por exemplo,

temos aqui nessa tabela,

a palavra-chave que vamos usar
e temos aqui um exemplo

de como ficaria o nome do método.

Então, por exemplo,
temos aqui o "And".

Então o "And" usamos para fazer
aquelas pesquisas,

onde combinamos dois campos,
por exemplo,

selecionar listagem de uma tabela
todos os registros,

onde a cidade seja, por exemplo,
São Paulo

e o nome do bairro,
seja, por exemplo,

Vila Mariana.

Então usamos dois ou mais atributos
para fazer a consulta.

Então, olha só,
como fica essa consulta?

É "findBy",
esse "findBy" é obrigatório.

Esse "Lastname",
é o nome de um atributo na classe.

Então imagine que você tenha
uma classe Java e lá tem um atributo

chamado "Lastname".

E tem um outro atributo
chamado "Firstname".

Então o "Lastname"
e o "Firstname"

são os nomes dos atributos na classe.

Agora o "findBy,"
é o nome de um método

padronizado pela JPA.

Eu tenho que usar esse "findBy".

Então imagina,
que ao invés do nome em inglês,

fosse em português,
o último nome e o primeiro nome.

Ficaria como?

"findBy", último nome, "And",
primeiro nome, tá bom?

Um outro exemplo.
Olha só o "Between" aqui.

O "Between", "findBy",
ai tem aqui,

a data inicial "Between", né?

Então vamos fazer ali uma busca, né?

Encontrar pela data inicial,
que esteja entre,

e aí passaremos as duas datas
que serão fornecidas para esse método.

Legal.
O "LessThan", por exemplo.

Eu quero buscar todo mundo,
todos os registros,

onde um determinado campo
seja menor que alguma coisa.

Olha só.
"findByAge".

Esse "Age" ele é o nome
do atributo lá na classe,

vamos supor que fosse idade
em português,

então ficaria "findBy",
idade, "LessThan".

Então essa palavra aqui no meio
tem que ser o nome do atributo

lá na classe.

Só que o "findBy" eu tenho que usar
e o "LessThan" também.

Ou seja,
a JPA vai entender que tipo

de consulta queremos implementar,
por conta dessas palavras aqui, tá?

Dessas expressões aqui, beleza?

E aí eu recomendo para vocês...

Vocês tem um link dessa
documentação no material escrito,

então eu recomendo que vocês
olhem essa documentação

para poder variar
bastante aqui as consultas de vocês.

Olha quanta coisa temos aqui.
Está bom?

Então,
vamos fazer alguns testes

para ver como isso funciona.

Bom, então vocês viram que tem ali
toda uma padronização?

Então teremos aquelas palavras
que são obrigatórias,

"findBy", "And",
"LessThan","Between".

Essas palavras irão compor
o nome da função e você vai combinar

com os nomes dos campos
no objeto Java,

na classe Java.

Isso conseguiremos fazer.

Dessa forma, conseguiremos fazer
as consultas baseadas

no nome dos métodos.

Olha que legal, né?

Essa é uma técnica bastante
interessante que a JPA

entrega para nós.

Vamos criar ali uma consulta,
por exemplo,

para fazer uma busca pelo nome,

só que usando o método,
o nome do método,

e não usando a query,
usando a JPQL.

Então vamos fazer um ajuste
ali nas nossas consultas

para vermos como isso funciona.

Vamos lá ver como isso fica
escrito em código mesmo

ali na nossa aplicação.

Vamos trabalhar um pouco.

Então olha só,
temos aqui

esse "BuscarContatoPeloNome, né?

Então temos já aqui uma consulta
usando a JPQL,

para fazer uma busca de contato
pelo nome.

Agora imagina que queremos
fazer isso,

só que usando a consulta
derivada de método,

a query derivada de método.

Então como vamos fazer, né?

Então eu vou fazer aqui mesmo,
aqui embaixo,

para vermos como elas são similares,
tá bom?

Então vamos lá.

Eu vou colocar aqui,
olha,

vou criar aqui
um "Optional" de contato.

Então,
o que essa função vai retornar?

Ela vai retornar o objeto "Optional"
do tipo "Contato".

Ela vai carregar um contato dentro dela.

E aí seguindo aquela regra,

como ficará aqui
o nome da consulta?

Eu sei que o meu campo
lá no banco de dados.

Na verdade,
no banco de dados não,

na classe, né?

Cadê a nossa classe Java?

Deixa eu abrir aqui o nosso modelo.

Olha só,
é nome, tá?

E está em português inclusive, né?
Bacana.

Então como ficará aqui:
"findBy".

Então esse "findBy" é obrigatório.

Isso aqui a JPA vai reconhecer
como sendo uma pesquisa,

uma consulta que ela terá
que construir.

"findBy" o quê?
Nome.

E observa que eu coloquei o "Nome"
com "N" maiúsculo,

apesar de aqui estar com "n" minúsculo.

Mas a JPA também
entende o que é meu case aqui.

Então ele sabe que esse "findBy"
é da JPA,

e ele saberá que o nome aqui,
apesar de estar com letra maiúscula,

ele sabe que está com letra maiúscula
por conta do que é meu case.

E aí vamos colocar aqui, né?

Qual é o valor que deve ser passado
para que essa consulta

possa acontecer?

Tá bom?

Então,
essa será a anatomia aqui,

a assinatura da classe
que teremos que criar.

E olha só como é simples,

não vamos precisar
nem escrever aqui a JPQL.

Então, se você precisar fazer
uma consulta e encontrar alguma coisa

que usará apenas um parâmetro,
apenas um campo,

uma propriedade do objeto,
então você faz dessa forma.

Você não precisa usar a JPQL.

Tá bom?
Legal.

Agora vamos construir um "service"
e vamos usar esse método aqui,

baseado em "Map",
essa consulta baseada

em nome de "Map".

Então, vamos lá agora
para o nosso serviço, né?

E iremos fazer essa consulta aqui.

Estou até pensando
em fazer o seguinte,

ao invés de fazer pelo nome,
eu vou fazer pelo e-mail,

porque temos um e-mail lá.

Eu acho que vai ficar mais legal,
porque vamos ter uma pelo nome,

usando aqui a JPQL
e vamos ter uma por e-mail, tá?

Eu vou fazer assim
para termos até essa consulta

também disponível aqui
no nosso endpoint.

Então vamos lá.

Então eu mudei aqui,
vou retornar um "Optional" de contato,

só que eu vou buscar
o contato pelo e-mail.

Então será fornecido o e-mail
para localizarmos o contato

na nossa base de dados.

Agora ficou legal.

Agora,
vamos criar lá no nosso "service",

um método para fazer isso,
para consumir esse serviço.

Vamos chamar aqui um "public",
vamos ter também aqui, né?

Ele vai retornar o quê?
O "ContatoExibicaoDto".

Vamos chamar
de "buscarContatoPeloEmail".

Estou usando um nome
em português mesmo,

aqui não tem problema.

Onde temos que usar
o "findBy" é no repositório,

lá no serviço não tem
problema nenhum,

eu posso usar
o nome que eu quiser, tá?

E vamos passar, né?

Aqui,
olha.

Quem chamar esse método
terá que me passar

uma string que vai representar
o meu e-mail.

E aí vamos retornar
o "repository.".

E temos ali
o "findByEmail",

que é essa última função
que criamos no nosso serviço.

Vamos fornecer esse e-mail aqui,
para quem chamar.

E lógico,
aqui estamos falando

que ele vai retornar
o "ContatoExibicaoDto".

Só que lembra que o "findByEmail"
vai retornar para nós

um "Optional".

Então, na verdade aqui,
o que vamos fazer, né?

Vamos criar aqui
o "Optional" do tipo contato.

Vamos chamar esse cara aqui
de "contatoOptional".

E vai receber o quê?
A resposta do nosso repositório, né?

Então esse cara aqui,
vai nos retornar

um objeto do tipo "Optional".

E aí, o que vamos fazer?

Vamos extrair esse contato
de dentro do objeto "Optional".

Então vamos verificar aqui,
se o "contatoOptional", né?

"contatoOptional.isPresent",
ou seja,

se tem um contato presente
nesse objeto "contatoOptional",

o que faremos?

Vamos retornar um "new",
"ContatoExibicaoDto",

passando esse
"contatoOptional.get.

Bacana.

Aí lembra que o nosso
"ContatoExibicaoDto"

tem um construtor
que recebe o contato

e retorna a instância
de um objeto "ContatoExibicaoDto".

Legal?

E esse "get",
ele está extraindo o objeto contato,

que está dentro
desse "contatoOptional".

Legal, né?

E, caso ele não encontre,
porque pode ser que tenha fornecido

um e-mail que não existe
ou o e-mail errado,

então vamos lançar uma exceção
para dizer que esse usuário,

esse contato
que está sendo buscado,

não existe.

Então,
"UsuárioNaoEncontradoException".

E vou passar aqui a frase,
"contato não encontrado".

Vamos finalizar aqui.

Então, pronto,
nosso serviço está aqui.

Então o "buscarContatoPeloEmail",

ele precisa receber um e-mail, né?

Ele vai retornar
o "ContatoExibicaoDto",

só que o nosso "findByEmail"
retorna um "contatoOptional".

Então colocamos aqui,
criamos um contato,

um objeto do tipo optional,

do tipo contato,
carregando um contato

e vamos verificar
se existe esse contato.

Se ele estiver presente,
retornamos o "ContatoExibicaoDto".

Extraímos o contato que está
dentro do "Optional",

para poder construir esse objeto
"ContatoExibicaoDto".

Se não lançamos aqui uma exceção
do tipo usuário não encontrado.

Agora precisamos criar o endpoint.

Então,
vamos chegar no nosso controlador

e vamos criar esse endpoint.

Então vamos lá.

Então,
será aqui um "@GetMapping"

e eu vou usar também
parâmetro aqui.

Então vamos chamar aqui
um "@GetMapping",

vamos chamar aqui
o "/contatos"

e vamos passar um "params"
que será o e-mail, tá?

Então essa consulta
ficará desse jeito aqui:

"//api/contatos?",

passando o parâmetro,
a Query string aqui "email",

que será igual,
aí você colocará aqui qual é o e-mail

que você está querendo
consultar no banco.

Beleza?
Bacana.

E vamos agora fazer aqui
o nosso método.

Então esse "public" retornará
o "ContatoExibicaoDto",

quando "bucarContatoPeloEmail",

nome da nossa função,
do nosso método.

Quem chamar
o "buscarContatoPeloEmail",

terá que passar o e-mail,
e esse e-mail

virá aqui pelo parâmetro da URL.

Então teremos aqui
um "@RequestParam".

E quem é esse parâmetro?
Vamos usar aqui.

Então, o parâmetro que está vindo aqui,
que é o e-mail,

será colocado no valor da variável,
do argumento e-mail

da função "buscarContatoPeloEmail".

E a implementação será simplesmente
"return service.buscarContatoPeloEmail"

passando esse e-mail
que foi enviado para nós

via parâmetro na URL.

Então olha lá.

Será uma pesquisa,
uma requisição HTTP do tipo GET.

Qual será a requisição?

"/contatos",
completando lá o "/api/contatos"

e terá um parâmetro "email".

Carregando o e-mail do contato
que está sendo buscado.

Esse e-mail que será fornecido aqui,
vamos substituir

no argumento aqui da nossa função,
tá bom?

E aí vamos passar isso
lá para o nosso serviço

e ele vai retornar se encontrar
o e-mail equivalente lá.

Então vamos restartar
a nossa aplicação,

para fazermos essa consulta.

Pronto!

Então olha,
ela foi startada com sucesso,

não tivemos nenhum problema.

Agora vamos fazer
uma consulta por e-mail.

Então vamos lá.
Eu vou pegar aqui.

Eu não tenho uma consulta pelo e-mail.

Então vou pegar essa consulta
aqui pelo nome.

Eu vou duplicar ela.

Vou dar o nome aqui,
"buscar pelo email".

"Create".
Vou clicar nela.

E vamos arrumar aqui esta URL.

Esta URL não será assim não.

Vou chamar aqui,
"/contatos,

como vamos usar parâmetros,
vamos colocar aqui "?email="

e vou colocar o e-mail da pessoa
que estou buscando.

Como eu não me lembro
dos e-mails cadastrados,

então vou pedir para listar
todo mundo aqui.

Vamos supor que eu quero
procurar alguém

que tenha o e-mail,
"[e-mail]".

É o registro número 8.
Deixa eu dar um control c aqui.

Vamos dar uma olhada.
Control v aqui.

Então olha só,
eu vou fazer uma busca nesse servidor

na porta 8080,
nesse recurso.

Eu quero os "contatos"
e vou passar aqui o parâmetro e-mail,

e o valor desse parâmetro
é "[e-mail]".

Vamos dar um "Send"
e ver se ele vai achar.

Olha lá,
achou aqui o contato.

Se eu pegar aqui por exemplo,
o ".br",

esse e-mail não existe.

Então se eu der um "Send",

ele não achou,
deu "404 Not Found".

Ou seja,
esse recurso que você está buscando

lá no servidor não tem,
não está lá.

Então é isso.

Agora também sabemos
como usar as consultas,

utilizando as consultas
derivadas de método.

Então, você pode utilizar
aquelas palavras-chave,

aquelas "keywords",
que você tem na documentação da JPA,

para construir as suas consultas
baseadas no nome do método

no repositório.

E aí você faz uma combinação
das "keywords",

com os nomes dos campos
que você tem lá na sua classe Java.

Então isso vai permitir
que você crie também,

consultas personalizadas
de uma forma bastante simples.