-
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 é a nossa classe Java.
-
Aqui deixo a minha que eu uso dela.
-
Olha só,
é nome lá e tá em português inclusive, né?
-
Bacana.
-
Então porque vai ficar aqui sim, de vai.
-
Então esse fim de vai é obrigatório
-
isso aqui a JPA vai reconhecer
como sendo uma pesquisa,
-
uma consulta que ela vai ter
que construir.
-
Sai de baixo o que esse nome
-
tá bom e observa que eu coloquei o nome
que olha com ele
-
maiúsculo,
apesar de aqui estar com ele minúsculo.
-
Mas a JPL também
entende o que é meu case aqui.
-
Tá bom interessado
que esse pai de pai e de ela da JPR
-
e ele vai saber que o nome aqui
apesar de tá com letra maiúscula,
-
ele sabe que está com letra maiúscula
por conta do que eu quis.
-
Bom, e aí a gente vai colocar aqui, né?
-
Qual é o valor que deve ser passado
-
pra que essa consulta possa acontecer?
-
Tá bom,
então essa vai ser a anatomia aqui,
-
a assinatura da classe
que a gente vai ter que criar.
-
Beleza. E olha só.
-
Olha como é simples, a gente não vai
nem precisar escrever aqui, já tá pequeno.
-
Então se você precisar fazer uma consulta
e encontrar alguma coisa
-
que vai usar apenas um,
-
um parâmetro, um apenas um campo,
-
apenas uma propriedade do objeto,
-
então você faz dessa forma que você
não precisa usar a JPA que é tá bom.
-
Legal.
-
Agora a gente vai construir um service
e vai usar esse.
-
Esse método aqui é baseado em map
-
e se essa consulta é baseada
em nome de método
-
é que a gente vai lá.
-
Então agora pro nosso serviço, né?
-
E a gente vai fazer essa consulta aqui.
-
Eu estou pensando eu tenho que fazer
o seguinte ao invés de fazer pelo nome,
-
eu vou fazer pelo meio,
porque a gente tem um email lá.
-
Eu acho que vai ficar mais legal
porque a gente vai ter uma pelo nome
-
usando aqui na PQP
e a gente vai ter aqui por email, tá?
-
Eu vou fazer assim
-
a gente até ter essa consulta disponível
aqui no nosso link de contato.
-
Então vamos lá.
-
Então eu mudei aqui eu vou retornar
-
um option de contato,
só que eu vou buscar o contato pelo email.
-
Então vai ser fornecido
-
o email para a gente localizar o contato
na nossa base de dados.
-
Agora ficou legal e agora a gente
vai criar então lá no nosso service
-
um método para fazer isso,
para conseguir esse serviço, aí
-
a gente vai chamar aqui
clicando que a gente vai ter também.
-
Aqui ele vai retornar o que?
-
O contato, exibição do teor
-
a gente vai chamar
-
de buscar contato pelo e-mail aqui.
-
Então, usando um nome em português mesmo,
aqui não tem problema aonde tem que usar
-
o fim de vai e no repositório da gente
lá no serviço não tem problema nenhum.
-
Eu posso usar o nome que eu quiser, tá?
-
E a gente vai passar aqui.
-
Olha, quem chamar esse método
vai ter que me passar
-
uma string e vai representar o meu email.
-
E aí a gente
vai retornar o Repository rico e o ponto.
-
E a gente tem agora
o fim de vai e meio que
-
última função
lá que a gente criou no nosso serviço
-
e a gente vai fornecer esse email
-
aqui pra quem chamar.
-
E lógico, olha aqui a gente está falando
que ele vai retornar o contato.
-
Exibição de teor, né?
-
Só que lembra que o fim de pai e mail
ele vai retornar para a gente
-
é um optional.
-
Então, na verdade, aqui
olha o que a gente vai fazer,
-
a gente vai criar aqui
o Optional é opcional,
-
do tipo contato.
-
Vamos chamar esse cara aqui
de contato opcional e vai receber o que?
-
A resposta do nosso repositório, né?
-
Então esse carinha aqui vai retornar
pra gente um objeto do tipo ótimo, beleza?
-
E aí, o que que a gente vai fazer
a gente vai extrair, né?
-
E se esse contato de dentro desse objeto
óptimo, a gente vai verificar que olha,
-
se o contato option nesse contato, ok,
o preço presente, ou seja,
-
se tem um contato presente nesse objeto,
contato ótimo, O que a gente vai fazer?
-
A gente vai retornar o meu contato.
-
Exibição de teor, passando esse contato.
-
Outro ponto gente bacana aí
lembra que o nosso contato
-
exibição de teor
ele tem um construtor que recebe o contato
-
e retorna a instância de um objeto contato
exibição.
-
BT O legal é esse GET.
-
Ele está extraindo o objeto.
-
O contato está dentro desse contato, ok?
-
Legal, né?
-
E caso ele não encontre,
que pode ser que tenha fornecido e-mail
-
que não existe o e-mail errado,
então a gente vai lançar uma exceção
-
para dizer que esse esse usuário
nesse contato está sendo buscado.
-
Ele não existe.
-
Então o usuário não encontrado Exception
e vou passar aqui a frase Olha, contato
-
não encontrado
-
legal e vamo finalizar aqui
então pronto, nosso serviço está aqui,
-
então vou buscar contato pelo email.
-
Ele precisa receber um e-mail né?
-
Ele vai retornar
o contato exibição de teor,
-
só que o nosso feed de vai email
ele retorna
-
um contato opcional,
então a gente colocou aqui.
-
Criamos um contato, um objeto do tipo opt,
-
do tipo contato, não carregando um contato
-
e a gente vai verificar
se existe esse contato.
-
Se ele estiver presente,
a gente retorna o contato.
-
Exibição de teor da gente extrai
o contato que está dentro do off
-
para poder construir esse objeto.
-
Contato, exibição.
-
BT Um sinal a gente lança aqui
uma exceção do tipo usuário.
-
Então tá legal.
-
Agora a gente precisa criar
-
o endpoint, né?
-
Então
a gente vai chegar no nosso controlador
-
e vamos criar esse point aqui.
-
Então vamos lá.
Então vai ser que um arroba
-
em get map
-
e eu vou usar também parâmetro
aqui tá gente?
-
Então vamos chamar aqui uma rua baguette
map, a gente vai chamar aqui o Contatos
-
e a gente vai passar um parâmetro
que vai ser o e mail, tá?
-
Então essa consulta
ela vai ficar desse jeito aqui.
-
Olha, vai ficar API para os contatos.
-
Passando o parâmetro quarry string
aqui meio que vai ser igual,
-
porque aí você vai tentar pingar aí
o email que você tá querendo
-
consultar no banco.
-
Beleza, bacana.
-
E a gente vai fazer.
-
Então agora o nosso método,
-
esse tudo isso, ele vai retornar
um contato execução de P.O.
-
Vamos buscar contato pelo e-mail,
-
nome do nosso, no nosso, da nossa função,
do nosso método.
-
Quem chamar o buscar
contato pelo email vai ter que passar
-
o email
-
e esse e-mail
ele vai vir aqui pelo parâmetro da url.
-
Então a gente vai ter que um arroba
-
20 West RD né?
-
E quem é esse parâmetro?
-
A gente vai usar aqui.
-
Então o parâmetro que tá vindo aqui,
que é o email, vai ser colocado
-
no valor da variável do argumento
e da função buscar pelo ENEM.
-
E a implementação
vai ser simplesmente um retornar.
-
E o nosso serve
nesse ponto buscar contato pelo email.
-
Passando esse email que foi enviado
-
para a gente
que envia parâmetro na URL bacaninha.
-
Então olha lá, vai ser uma pesquisa,
então vai ser um GET,
-
vai ser uma consulta,
vai ser uma requisição HTTP do tipo GET
-
e qual vai ser a requisição,
barra, contatos,
-
completando na barra de contatos
e vai ter um parâmetro e-mail
-
carregando o email do contato
que está sendo buscado.
-
É esse e mail que vai ser fornecido aqui.
-
A gente vai substituir aqui na nossa
-
na no argumento
aqui da nossa função, tá bom?
-
E aí a gente
vai passar isso lá pro nosso serviço
-
e ele vai retornar
assim, encontrar o email
-
equivalente lá.
-
Bacana, Então vamos restart
aquela aplicação
-
pra gente poder
-
fazer essa consulta.
-
Prontinho!
-
Então olha, ela foi exportada com sucesso,
não tivemos nenhum problema.
-
Então agora a gente vai fazer uma consulta
por e-mail.
-
Então vamos lá.
-
Então eu vou pegar aqui.
-
Olha,
eu não tenho aqui uma consulta pelo email,
-
então vou pegar essa consulta
aqui pelo nome.
-
Eu vou duplicar ela,
aí vou dar o nome que olha
-
e buscar pelo email
-
cliente vou clicar nela
e a gente vai arrumar aqui essa url
-
nessa url ela não vai ser assim,
não vou chamar que olha para contatos
-
como a gente vai usar parâmetro
que a gente vai colocar aqui.
-
A interrogação é meio igual
-
e aí eu vou colocar o email da pessoa
que eu estou buscando.
-
Então 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 olha que tem um e-mail.
-
João arroba meio ponto.
-
Olha o registro número oito.
-
Deixa eu dar um control c aqui.
-
Vamos dar uma olhadinha.
-
Vou problema aqui Então olha só,
eu vou fazer uma busca nesse servidor
-
na porta 80.
-
Nesse recurso eu quero o contatos
e vou passar aqui o parâmetro email
-
e o valor desse parâmetro e joão arroba
meio ponto com um send.
-
Vamos ver se ele vai achar.
-
Olha olha lá, achou aqui o contato,
se eu pegar aqui por exemplo
-
o ponto BR, esse email não existe,
então se eu der um send
-
ele não achou
1404 not found, ou seja, esse
-
esse recurso que você está buscando
lá no servidor
-
não tem não, não está.
-
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.
