vimeo.com/.../1123921673

Vamos organizar agora
o nosso projeto.

A gente precisa que as pastas,
que a estrutura de diretórios do

projeto,
esteja adequado com uma arquitetura

que a gente
vai utilizar.

Então a gente está trabalhando
aqui com o MVC, não é isso?

Então a gente vai ter o módulo,
que são as regras de negócio.

A gente já viu ali o controller,
que é onde a gente

vai ter as classes que vão
receber as requisições,

oriundas lá do nosso cliente web.

E a gente vai ter
mais algumas coisinhas.

Então a gente vai organizar
agora uma estrutura de pastas, de

diretórios, os packages aqui
no contexto Java, para que a gente

organize melhor as nossas classes,
tá bom?

Então vamos codificar
mais um pouquinho.

Bom pessoal, então a gente já tem
aqui o package controller, só que

além disso a gente vai
precisar de mais alguns.

Então a gente vai precisar aqui,
olha, então botar um direito aqui,

new package, a gente vai ter um

pacote chamado model.

E lembra
que o package model

é para a gente
colocar as classes que

modelam os objetos de domínio
da nossa aplicação.

Então vou dar um return aqui.

Então já está ali
o pacotinho model criado.

Além disso,
a gente vai também criar.

um outro package chamado repository.

repository, esse pacote vai ser
utilizado para a gente colocar as

classes de repositório
da nossa aplicação.

Bom gente,
e aí falando de repositório,

vamos entender
mais um conceito aqui,

né?

Um repositório é onde
a gente tem algo guardado.

Então, por exemplo, uma caixa d'água

é um repositório de água, né?

Então, se eu preciso de água, eu vou
buscar água ali na caixa d'água.

Legal.

Aqui no nosso caso,
o que é o repositório?

Ele representa
a nossa fonte de dados.

Então,
sempre que eu quiser,

por exemplo,
acessar o banco de dados, é

no repositório
que eu estou pensando.

Legal?

Então, o que a gente vai
ter nesse pacote repository?

As classes que representam
os dados lá no banco de dados.

Legal?

E além disso,

a gente vai ter um outro package,
né?

Que vai organizar
as classes de serviço.

O nosso controlador, ele até pode

obter os dados acessando
diretamente o repositório.

Mas isso não é uma boa prática.

O interessante é que aconteça
da seguinte forma.

O controlador,
ele vai utilizar

um serviço que vai
consumir os dados.

Ou seja, a gente vai ter uma classe

que vai ser a classe de negócio,
que vai manipular os dados, né?

Ou seja, o repositório devolve
os dados para o serviço.

A camada de serviço pode manipular
esses dados, trabalhar esses dados

de alguma forma e aí
entregar para o controlador,

que vai devolver para o cliente,
tá bom?

Então, percebe que a gente está
criando aqui uma arquitetura, né?

A gente está tentando organizar

a nossa aplicação
em várias camadinhas.

Então, a gente tem a camada
de modelo de negócio,

a gente tem a camadinha
de controller, a camada

de repositório
e a camada de serviço,

tá?

Então, tudo muito bem organizado,

muito bem segmentado, né?

Para que a gente possa reutilizar
o código depois com mais facilidade,

para que a gente
possa fazer manutenção

de uma forma mais tranquila,
né?

Então,
isso tudo é feito

para facilitar
o nosso trabalho aqui.

Então, vamos lá criar
mais essas pastinhas aí.

Legal.

Então, só para finalizar, né?

Mais uma pastinha, mais um package,
que vai ser o service.

Legal.

Bom,
gente, vamos começar criando, então.

..

Deixa eu recolher aqui o controller.

Então,
a gente vai começar pelo model, né?

Então, aqui a gente vai modelar
o nosso objeto produto, tá?

Então, a gente vai começar
criando uma classe.

Então, vou dar um botão
direito aqui no model.

Vou criar uma classe Java.

Vou chamar essa classe de produto.

Qual é uma classe?

Letra maiúscula, certo, gente?

Então, vou dar aqui um return.

E vamos definir aqui
algumas coisinhas.

Então, nossa classe produto,
ela vai ter, né?

Um atributo, né?

Que vai ser do tipo long,
que a gente vai chamar de ID, tá?

Então, esse campo,
ele é o identificador, né?

Do nosso produto.

Cada produto vai
ter um ID diferente.

A gente vai ter também um nome.

Então, eu quero saber qual
é o nome do nosso produto.

A gente vai ter também o valor, né?

Ou preço, né?

Do produto.

Vou chamar aqui de valor.

Então, qual é o valor desse produto?

E a gente vai colocar também aqui

a quantidade que a gente
tem em estoque.

Então, vai ser aqui int, quantidade.

E a gente vai finalizar aqui, né?

Com um atributo
que é a data de fabricação.

Então, vai ser aqui um local date,

né?

E vai ser aqui a data fabricação,
tá bom?

Então, esses são os atributos, né?

E cada objeto,
produto que a gente criar, vai ter.

Então, cada produto vai ter
o identificador do tipo inteiro, né?

Longo.

Vai ter um nome,
que é do tipo string.

O valor, que é do tipo double.

Quantidade, que é do tipo int, né?

Quantas unidades desse produto
a gente tem em estoque.

E a gente vai ter um local date

aqui, que é a data
de fabricação desse produto.

Tá bom?

Legal.

Como a gente está criando
aqui uma classe, né?

Utilizando as boas práticas e tal.

Então, a gente definiu todos
os atributos como privados.

Então, a gente não vai ter acesso.

a esses atributos.

Eles estão encapsulados, né?

Então, a gente vai criar aqui
os métodos de acesso, né?

Os famosos getters e setters.

Aqui no IntelliJ, a gente tem um

atalho para fazer isso, né?

Então, se você está usando o Mac OS,

você vai pressionar
Command mais a letra N.

E aí vai aparecer esse
menuzinho aqui para a gente, né?

Se você estiver usando o Windows
ou o Linux, você vai apertar a tecla

Alt mais a tecla Insert, tá?

Alt, Insert.

Vai aparecer esse mesmo
menuzinho aqui, tá?

E aí a gente vai escolher aqui,
olha, a opção Getter e Setter.

Tá ok?

Vamos pressionar Return.

O IntelliJ já vai sugerir
para a gente aqui, ó,

criar Getter e Setter
para todos os atributos.

Eu vou fazer isso, então vou
selecionar todo mundo aqui, né?

Só segurar o Shift, tá, gente?

E ir movimentando
a setinha para baixo.

Ou clicou aqui no primeiro,
segura o Shift e clica

aqui no último,
que ele já seleciona todo mundo, né?

Dá um OK e prontinho, olha só.

Estão aqui criados todos
os métodos Get e Set, né?

Utilizando aqui aquele princípio do

encapsulamento, né?

Na orientação a objeto.

Bacana.

Agora a gente vai ter que fazer
as configurações aqui, né?

De mapeamento.

Agora a gente vai fazer aqui
uma coisa muito legal, né?

Quando a gente está
trabalhando com o Spring.

O que acontece?

A classe produto, ela precisa ter

uma tabela equivalente, né?

Lá no banco de dados.

Então imagina assim,
eu vou mandar um produto, né?

Aqui de lá do cliente,
por exemplo, vai vir um produto.

A minha aplicação, o back-end aqui,
ela vai receber esse produto.

E eu vou ter que mandar esse
produto para o banco de dados.

Então o que acontece?

Eu tenho o objeto do lado
da aplicação, só que lá

no banco de dados eu tenho a tabela,
a entidade.

Apesar de elas se parecerem, elas
não são a mesma coisa, não é mesmo?

Então o que a gente vai fazer?

A gente vai criar um mapeamento
objeto relacional.

O famoso ORM.

Que no caso do Spring JPA,
que é o que vai

fazer isso aqui para a gente,
é o Hibernate.

O Hibernate, ele é a biblioteca que,
de fato, implementa a especificação

JPA, que diz como que deve
ser feito esse mapeamento.

Então a JPA, ela diz como que esse
mapeamento deve ser feito.

E a gente tem a implementação,
de fato,

que é o Hibernate,
que o Spring JPA utiliza.

Para fazer isso,
gente, é bastante simples, tá?

Então o que a gente
vai ter que fazer?

A gente vai ter que colocar algumas
anotações ali na nossa classe.

para que o Spring saiba que ele vai

ter que localizar
lá do lado

do banco de dados,
no caso do Oracle,

uma tabela que vai ser utilizada

tanto para guardar o objeto, quanto

para criar de volta o objeto
na nossa aplicação, tá bom?

Então vai fazer esse caminho,
tanto de ida dos dados para o banco,

quanto depois a reconstrução
do objeto, de fato,

aqui do lado da aplicação,
para depois ainda ser

entregue em um outro
formato lá para o cliente.

Beleza?

Parece complicado, mas não é não.

Vamos ver como é que isso
funciona na prática.

Bom, gente,
então vamos fazer esse mapeamento.

Então, primeira coisa, a classe

produto, ela tem que ser
uma entidade lá no banco de dados.

Como a gente está usando Spring,

a gente vai fazer uma anotação aqui,

arroba entity,
que é de entidade, tá bom?

Opa, não é enable, é entity, do

pacote Jacarta Persistence,
tá bom, gente?

Então, olha só, entity.

Então, a gente já disse que a classe
produto, ela deve ser uma entidade

lá no banco de dados, tá bom?

Então, beleza, além disso, eu vou
colocar mais uma anotação aqui, que

vai ser a anotação table, e eu vou
passar um parâmetro aqui, que vai

ser o name,
e vou dizer que essa tabela,

ela se chama
lá no banco de

dados,
ela vai se chamar TBL produto.

Então,
essa anotação, ela está

dizendo o seguinte
aqui para o Spring.

Olha,
Spring, a classe produto, ela tem

uma tabela no banco
de dados equivalente, né?

E vai ser a TBL produto.

Então, essa TBL produto, ela vai
estar preparada para receber esses

atributos aqui, ó.

O ID, o nome, o valor,
a quantidade e a data de fabricação.

Então,
isso aqui que a gente está fazendo,

a gente chama de mapeamento,
tá, gente?

Eu estou dizendo que a classe
produto, ela tem uma entidade no

banco de dados,
que é a TBL produto, beleza?

Bom,
ele está reclamando aqui

com a gente,
pessoal, que é o seguinte,

toda tabela tem que ter
uma chave primária, né?

Isso é uma boa prática lá
na criação de bancos de dados.

Então, ele está querendo saber,

cara, qual desses atributos
é a chave primária,

é equivalente à chave
primária lá no banco de dados,

corresponde à chave primária
lá no banco de dados.

É o ID, né?

Então, eu vou até separar ele aqui,

ó, vou deixar ele em destaque aqui
em relação aos outros atributos,

porque a gente vai fazer
algumas anotações aqui nele.

Então, a primeira coisa que eu vou
fazer, ó, vou colocar aqui um arroba

ID, já me sugeriu ali,
ó, do jacarta Persistence.

Então, quando eu faço isso, percebe
que ele até já parou de reclamar,

né?

Então, o arroba ID está
dizendo que o atributo

que está com essa anotação
é a chave primária, ou

corresponde, né, a chave
primária lá no banco de dados.

Tá bom?

Fora isso, eu vou colocar também

esse Generated Value.

Porque assim, gente, como que esse

valor vai ser gerado
lá no banco de dados?

Como a gente está trabalhando, né?

Se fosse, por exemplo, o MySQL,
isso aqui já seria suficiente, tá?

Então, ele sabe que o campo ID,
lá na tabela,

ela vai ser gerado de forma
auto-incremental, tá bom?

Mas, como a gente está trabalhando

com Oracle, no Oracle,
isso aqui não vai funcionar.

A gente vai precisar
usar uma sequência.

Lembra que no Oracle,
eu preciso criar uma sequência,

né, que é um objeto lá
do banco de dados Oracle,

que guarda uma sequência numérica,

né?

E a gente usa essa sequência
para definir um atributo

que vai ser numerado
automaticamente na tabela.

E a gente costuma fazer
uma sequência para cada tabela.

Então,
por exemplo, se eu vou ter a tabela

produto, então a gente
cria a sequência produto.

E a gente diz, olha, cada produto
que eu inseri vai ser numerado.

sequencialmente de um em um.

Então, a gente diz lá na sequência,

olha, começa no um E vai
ser incrementado de 1.

E aí na hora de fazer um insert
na tabela, a gente diz que o ID vai

verificar qual
é a sequência

que está disponível,
qual é a próxima

sequência disponível e vai atribuir
esse valor para o registro que

a gente estiver inserindo
naquele momento.

Então,

é isso que a gente
está fazendo aqui.

Então,
a gente está dizendo para o Spring,

para o JPA, para o Hibernate,
olha, a forma como você.

vai criar esse ID lá no banco
vai ser através de uma sequência.

E agora a gente tem que dizer
quem é essa sequência, tá bom?

Então, vamos continuar, tem mais

algumas coisinhas ali nesse ID,
vamos lá.

Aí,
além disso, o que mais que a gente

vai ter
que falar aqui?

A gente já falou que a estratégia
vai ser a sequência.

Aí eu vou quebrar essa linha,
tá gente?

Para a gente ter um pouquinho
mais espaço aqui.

Então, eu vou fazer o seguinte, eu

vou jogar essas parênteses
aqui para baixo.

Deixa eu colocar
aqui o ID coladinho.

Então,
além da sequência,

a gente vai colocar
aqui uma vírgula.

E aí,
a gente vai precisar do Generator.

Esse atributo aqui, ó, Generator.

E aí, a gente vai colocar
aqui qual é o nome

do gerador de sequências
lá do banco de dados, tá?

Então, eu vou chamar aqui,
ó, de SecProdutos.

Então, lá no Oracle, a gente vai ter

que criar uma sequência
com esse nome aqui, beleza?

Legal.

Além disso,
a gente vai colocar aqui, olha,

uma outra anotação
que é o Sequence Generator.

Eu tenho que falar aqui para o

Spring como que essa sequência
vai ser gerada.

E aí,
eu vou colocar aqui uma informação.

Esse name que eu vou
colocar aqui

vai ser usado pelo Spring,
tá, gente?

Eu vou usar o mesmo nome que eu vou
dar para a minha sequência, né?

Lá no Oracle, beleza?

A gente ainda não criou
isso lá no Oracle.

A gente vai criar isso
num momento posterior.

Mas, a gente já está
planejando isso tudo aqui.

Então, vamos lá.

Então, eu disse aqui que o valor vai
ser gerado usando uma sequência e

que a sequência vai
se chamar SecProdutos.

Aí, eu preciso dizer para o Spring

como é essa sequência,
esse gerador de sequência.

Então,
eu vou ter essa anotação aqui.

Eu estou dando um name.

Esse name vai ser usado pelo Spring,
tá, gente?

E, além disso,
né, do name, eu vou precisar

fornecer mais uma coisa
que é o Sequence Name.

Esse Sequence Name, ele tem que ser
o nome, de fato, lá do Oracle.

Que é esse nome aqui, ó.

Então, eu até vou dar
um copiar e colar nele aqui

para ter certeza que eu não
vou escrever nada diferente.

Tá, ó.

Vou colocar assim.

Esse nome aqui,
gente, ele não precisa ser o mesmo.

Porque isso aqui vai ser usado

internamente pelo Spring Boot, tá?

Pelo Spring aqui na aplicação, tá?

Esse cara aqui é o nome
da sequência lá no Oracle.

E o Sequence Name é o nome
da sequência lá no Oracle.

Então, esse nome que a gente
está colocando aqui tem que ser

exatamente o nome
que a gente vai criar

a sequência depois,
lá no Oracle Database.

Beleza?

E eu vou colocar aqui o Allocation
Size, que é um por padrão, tá bom?

O tamanho da alocação
lá da sequência.

Então, olha só.

Parece que é bastante coisa,
mas não é.

Isso aqui é bastante simples, né?

Vamos entender aqui
o que a gente Fez.

Então,
a gente disse que o ID, ele vai ser

o identificador lá na tabela,
lá no banco de dados.

Ou seja,
ele vai ser a chave primária.

Como que vai ser gerado o valor?

Usando uma sequência.

Quem vai ser o gerador
dessa sequência?

Uma sequência chamada SecProducts.

Legal.

E aí eu vou passar mais essa

informação,
que vai ser de uso do Spring, né?

Estou falando para ele,
cara, quem é o Sequence Generator?

É o SecProducts.

Então, esse nome aqui
é do que a gente vai usar no Spring.

Então,
esse nome pode ser qualquer nome.

Não precisa ser o nome
da sequência que está lá no banco.

Beleza?

O Sequence Name.

Aí eu tenho que falar qual é,
de fato,

o nome da sequência
lá no banco.

E aí vai ser o mesmo nome
que a gente colocou aqui.

Legal?

E o Allocation Size, que vai ser um.

Legal.

para essa fabricação.

Aqui a gente está
usando o Camel Case, né?

Camel Case que é aquele formato, né?

Padrão de nomear variável, né?

Classe e método, que é...

Primeira letra minúscula,
porque esse cara é um atributo.

Então, por regra, né?

Por boa prática, né?

Por design pattern,
começa com letra minúscula.

Como são duas palavrinhas, a gente

começa a outra palavra
com letra maiúscula.

Só que isso aqui não é bem
o padrão lá no banco de dados, né?

Lá no banco de dados a gente costuma

colocar data,
underscore, fabricação.

Então, eu quero que, apesar de que

aqui no Java seja assim, eu quero

que lá no banco seja usando
a nomenclatura do banco.

E a gente vai criar lá no banco

usando a boa prática do banco.

Então, a gente vai colocar aqui,
ó, um arroba, column, tá?

Um arroba, column.

Esse carinha aqui,
ó, do Jakarta Persistence.

E aqui eu vou poder
definir algumas coisinhas.

Por exemplo, qual vai ser
o name que esse campo vai ter?

Então, o name dele lá no banco vai
ser data, underscore, fabricação.

Então, percebe que, de novo,
eu estou fazendo um mapeamento, né?

Eu estou dizendo, cara, olha só.

Spring, lá no banco é data,

underscore, fabricação.

Então,
quem for esse nome lá

no banco equivale ao data,
fabricação

aqui no objeto, aqui na classe, tá?

Isso aqui vai garantir
esse mapeamento.

Ele sabe que lá é data,
underscore, fabricação.

E aqui é data,

fabricação,
usando o QMLCase, tá bom?

Legal.

Aqui no nome, a gente pode colocar,

né, por exemplo,

aqui também,
olha, um arroba, column.

Aí eu posso colocar aqui,
por exemplo, um length, né?

Dizendo que esse campo ele vai ter,

no máximo, lá no banco de dados,
ó, tamanho 100, né?

E eu posso dizer também
que ele não pode ser nulo.

Ou seja, o nome é obrigatório.

Então, qual é o tamanho
do campo nome lá no banco?

Tamanho 100, né?

E eu estou dizendo
que ele não pode ser nulo.

Então, percebe que eu estou
definindo aqui os metadados do

atributo,
ou do campo, lá no banco de dados.

Legal, pessoal.

Agora, a gente vai fazer o seguinte,

a gente vai executar
nossa aplicação,

né?

Para ver se tudo continua aqui
funcionando normalmente, tá?

Então,
depois que a gente faz algumas

implementações,
é legal a gente executar, né?

Para ter certeza que está
tudo funcionando ainda.

Então, olha,
a minha aplicação está parada, né?

Vou dar aqui
um run e vamos ver

o que ele vai falar
aqui para a gente.

Então, percebe,

olha só,
que não tivemos nenhum erro.

A aplicação inicializou normalmente.

Então, isso é bom sinal.

Indica que as nossas configurações

aqui na entidade produto,
aqui nessa classe, né?

Nessa entity class que a gente criou

o produto,
está tudo configurado direitinho.

Muito bom, gente.

Então, é assim que a gente
faz o mapeamento ORM, né?

O mapeamento objeto relacional.

Então, lembra que o banco de dados,

ele trabalha com estrutura
relacional, né?

De entidades, né?

Tabelas.

E aqui do lado do Java,
a gente trabalha com classes, né?

Com objetos.

Apesar deles se parecerem,
eles não são exatamente o mesmo, né?

Então, a gente precisa
fazer esse mapeamento.

Olha, aqui do lado do Java,
a classe se chama produto.

Lá no banco, é o TBL produto.

Olha, aqui na classe produto,
o campo data fabricação,

ele é o data underscore fabricação,
lá no banco.

E o Spring vai conseguir
automatizar o processo, né?

De pegar o objeto, montar
uma instrução SQL, por exemplo, de

insert da forma correta
e mandar pro banco.

Sem a gente ter
que escrever esse SQL.

Por quê?

Porque a gente mapeou
aqui bonitinho.

Entenderam?

Então, o Hibernate, né?

Essa especificação JPA, né?

Essa implementação JPA,
que é o Hibernate, vai

fazer esse trabalho pra
gente automaticamente.

Tá bom?

Então, percebe que o Spring,
ele tá facilitando nossa vida.

Muita coisa que a gente faria

manualmente, a gente tá fazendo de

forma automática através
das anotações, né?

E ganhando tempo, né?

E melhorando o nosso projeto
e mantendo ele padronizado, né?

E garantindo que ele tenha ali
as boas práticas de implementação.