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 lá 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 vai fazer.

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,

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,
olha 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 olha, 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 que fica essa consulta?

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

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

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

chamado "Lastname".

E tem um outro atributo
chamado "Firstname".

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

eles 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,

último nome e o primeiro nome.

Ficaria como?

"findBy", ultimo nome, "and",
primeiro nome.

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ó.
"findBy", "Age".

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 o nome dessa palavra
aqui no meio,

ela 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,

dessas expressões aqui, beleza?

E aí eu recomendo pra 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.

Tá bom?
Então vamos fazer alguns testes

para ver como que isso aqui funciona.

Bom, então vocês viram que tem ali
todo 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 baseados

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 ai funciona.

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

mesmo ali na nossa aplicaçao.

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 queriamos
fazer isso,

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

Então como vamos fazer, né?

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

para vermos como que elas são similares.

Tá bom?
Então vamos lá.

Eu vou colocar aqui,
olha,

vou criar aqui
um "Optional"

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 que vai 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é?

Ela é, onde está nossa
classe Java?

Deixa eu abrir aqui.
Olha só, é nome, tá?

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

Então como ficará aqui, olha.

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

Isso aqui a JPA vai reconhecer
como sendo uma pesquisa,

uma consulta que ela vai ter
que construir.

"findBy" o quê?
Nome.

E observa que eu coloquei o nome
aqui, com N maiúsculo,

apesar de aqui estar com ele minúsculo.

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

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

e ele vai saber que o nome 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 vai ser a anatomia aqui,

a assinatura da classe
que teremos que criar.

E olha só.
Olha como é simples,

não precisaremos
nem escrever aqui a JPQL.

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

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

apenas 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 servço, né?

E iremos fazer essa consulta aqui.

Eu estou pensando
até em fazer o seguinte,

ao invés de fazer pelo nome,
eu vou fazer pelo email,

porque temos um email lá.

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

usando aqui na JPQL
e vamos ter uma por email, tá?

Eu vou fazer assim,
para termos até essa consulta

disponível aqui no nosso endpoint.

Então vamos lá.

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

só que eu vou buscar o contato pelo email.

Então vai ser fornecido o email
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.

Ele vai retornar o que?
O "ContatoExibicaoDto".

Vamos chamar
de "buscarContatoPeloEmail".

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é?

Quem chamar esse método
vai ter que me passar

uma string que vai representar
o meu email.

E aí vamos retornar
o "repository."

E temos ali olha,
o "findByEmail"

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

Vamos fornecer esse email aqui,
para quem chamar.

E lógico, aqui estamos falando
que ele vai retornar

o "ContatoExibicaoDto".

Só que lembra que o "findByEmail"
ele 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 retornar
para nós 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".

Nesse "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"
ele 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,
pode ser que tenha fornecido um email

que não existe o email errado,
então vamos lançar uma exceção

para dizer que esse esse usuário
esse contato

que está sendo buscado
ele não existe.

Então,
"UsuárioNaoEncontradoException"

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

e vamos finalizar aqui.

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

Então vou
"buscarContatoPeloEmail".

Ele precisa receber um email, né?

Ele vai retornar
o "ContatoExibicaoDto",

só que o nosso "findByEmail"
ele retorna

um "contatoOptional",
então colocamos aqui,

criamos um contato,
um objeto do tipo optional,

do tipo contato,
não 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 vai ser que um
"@GetMapping"

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

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

vamos passar um parâmetro
que vai ser o email, tá?

Então essa consulta
ela vai ficar desse jeito aqui.

Vai ficar "api/contatos",

passando o parâmetro Query string
aqui email que vai ser igual,

porque aí você vai colocar aqui
o email que você está querendo

consultar no banco.

Beleza, bacana.

Então vamos agora fazer aqui
o nosso método,

Então esse "public" vai retornar
o "ContatoExibicaoDto"

quando "bucarContatoPeloEmail",

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

Quem chamar
o "buscarContatoPeloEmail",

terá que passar o email
e esse email

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 tá vindo aqui,
que é o email,

será colocado no valor da variável
do argumento email

da função "buscarContatoPeloEmail".

E a implementação será simplesmente

um "return service.buscarContatoPeloEmail",

passando esse email que foi
enviado para nós

que envia parâmetro na URL.

Então olha lá.

Será uma pesquisa então
será uma requisição HTTP do tipo GET

Qual vai ser a requisição?

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

e vai ter um parâmetro email.

Carregando o email do contato
que está sendo buscado.

Esse email que será fornecido aqui,
vamos substituir aqui

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 email equivalente lá.

Então vamos restartar nossa aplicação
para fazermos essa consulta .

Pronto!

Então olha,
ela foi exportada com sucesso,

não tivemos nenhum problema.

Então agora vamos fazer
uma consulta por email.

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

Eu não tenho uma consulta pelo email.

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
essa URL.

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

Vou chamar aqui,
"/contatos,

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

e eu vou colocar o email da pessoa
que estou buscando.

Então eu não me lembro
dos emails cadastrados,

então vou pedir para listar
todo mundo aqui.

Vamos supor que eu quero procurar
alguém

que tem um email,
"[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

o contatos e vou passar aqui
o parâmetro email

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

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

Olha lá,
achou aqui o contato,

se eu pegar aqui por exemplo,
um ponto BR.

Esse email 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 a gente também
sabe como utilizar as consultas

utilizando ali
as consultas derivadas de método.

Então você pode utilizar aquelas palavras
chave naquelas keyword

que você tem
ali na documentação da tabela. JPG

para construir as suas consultas baseadas
no nome do método ali no repositório.

E aí você faz uma combinação
das kill words

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

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

consultas personalizadas
de uma forma bastante simples.