JPA — Desmistificando os principais conceitos— Parte 1
Sumário
- Use a estratégia correta para gerar seu id.
- Trabalhando com herança— (Em Breve).
- Estendendo os relacionamentos — (Em Breve).
- Entendendo como funciona o Cascade e o OrphanRemoval — (Em Breve).
- Como trabalhar com Lazy e Eager Loading corretamente — (Em Breve).
- Não deixe os resultados da consulta em memória — (Em Breve).
- Operações em larga escala — Bulk Operations — (Em Breve).
- Tratando a concorrência — (Em Breve).
Introdução
Fala galera, estou começando hoje uma série de artigos sobre alguns temas que são de extrema importância mas que muitas vezes passa em branco na hora do desenvolvimento.
Antes de começar, todos os exemplos foram desenvolvidos com spring boot e hibernate. Para a criação do projeto utilizei o https://start.spring.io/. Então, chega de enrolação e vamos ao que interessa!
Use a estratégia correta para gerar seu id
Existem 4 maneiras de gerar o ID de uma entidade automaticamente: AUTO, IDENTITY, SEQUENCE e TABLEGENERATOR. Você precisará escolher uma dessas maneiras para gerar seu ID automaticamente e para fazer isso basta colocar a anotação @GeneretedValue, e no atributo strategy você colocar a estratégia que melhor se encaixa com sua regra de negocio.
Se seu projeto utilizar vários bancos, a escolha de qual estratégia é um ponto muito importante, e pode impactar inclusive na performance do seu software.
Estratégia AUTO:
A estratégia AUTO é a mais simples de todas onde o próprio JPA ficar responsável pela escolha da estratégia a ser utilizada de acordo com cada banco de dados. Esse é o valor padrão da anotação @GeneretedValue
Estratégia IDENTITY:
Quando utilizamos essa estratégia estamos dizendo para o provedor de persistência que será utilizado o famoso “auto-incremento”. Isso permite que o banco de dados gere um novo valor para cada operação de inserção.
Estratégia SEQUENCE:
Bancos como POSTGRES e ORACLE utilizam essa estratégia como padrão. Para a geração do ID automático é usado uma rotina configurado no seu banco de dados que ao ser chamada devolve automaticamente o próximo ID sem nenhum tipo de problema com concorrência.
A classe Student está com a anotação de @SequenceGenerator isso significa que essa entidade vai usar uma SEQUENCE que ficará dentro do nosso banco de dados.
Para a utilização dessa anotação temos que setar alguns atributos, como o name que será o nome da nossa sequência dentro da aplicação; sequenceName seria o nome da nossa SEQUENCE dentro do banco de dados.
E também mais dois atributos: o initialValue, que seria em qual valor minha sequência vai começar, no exemplo coloquei 1000 então no primeiro registro que for salvo nessa tabela ficaria com o id 1001; e por ultimo o atributo allocationSize, que seria para ele alocar alguns valores de id em cache.
No meu exemplo coloquei o valor de 50, nesse caso ele irá buscar os próximos 50 valores da sequência e deixará armazenado em cache para não precisar em todo evento de salvar um registro ele fazer uma busca para saber qual será o próximo valor da sequência nesse caso ele usar os 50 ids alocados em cache ele vai no banco e busca mais 50 assim tendo um ganho em performance.
Mapeando chave composta
Em algum momento mapear um único campo como chave primaria não é o suficiente para isso temos que usar chave composta onde mais de um campo será chave primaria da tabela. Vamos imaginar um cenário onde um usuário tem uma empresa e os campos id e empresa são chaves primaria da tabela.
Vendo o exemplo acima, parece que o problema está resolvido, mas não!
Para resolver esse problema temos algumas opções que o hibernate nos proporciona como @IdClass e @Embeddable. Nesse momento, vamos trabalhar com o @Embeddable, que confesso que é minha opção preferida.
Usando @Embeddable
Essa é uma das opções para você trabalhar com chave composta. O primeiro passo a ser feito é criar uma Classe com a @Embeddable onde essa classe vai ter os ids que precisamos como atributos, segue um exemplo abaixo:
Após criar a classe que vai conter as chaves primarias basta referenciar essa classe na classe principal com a anotação de @EmbeddedId como no exemplo abaixo:
Após ter mapeado a chave composta conforme as regras, se você subir a aplicação e verificar as tabelas no banco de dados você irá perceber que a tabela de user tem duas chaves primarias como tínhamos mapeados na classe UserId.
Conclusão
Bom, se você gostou do artigo e quer que continue com a série, deixe seu feedback nos comentários, que vou lançar pelo menos a cada duas semanas um artigo novo!
No próximo artigo, vou abordar qual é a maneira correta para se trabalhar com herança dentro do JPA.
Forte abraço!
