Chaves Primárias Compostas em JPA

Introdução

neste tutorial, vamos aprender sobre Chaves Primárias Compostas e as correspondentes anotações em JPA.

Chaves Primárias Compostas

Uma chave primária composta, também chamado de um composto – chave é uma combinação de duas ou mais colunas para formar uma chave primária para uma tabela.

na App, temos duas opções para definir as teclas compostas: as anotações @IdClass e @Embeddid.

a fim de definir as chaves primárias compósitas, devemos seguir algumas regras:

• chave primária composta da classe deve ser pública
• Ele deve ter um não-arg construtor
• Ele deve definir equals() e hashCode() métodos de
• deve ser Serializável

O IdClass Anotação

suponhamos que temos uma tabela chamada Conta e tem duas colunas – accountNumber, accountType, que formam a chave composta. Agora temos que mapeá-lo na App.

de acordo com a especificação da APP, vamos criar uma classe de conta com estes campos chave primários:

public class AccountId implements Serializable { private String accountNumber; private String accountType; // default constructor public AccountId(String accountNumber, String accountType) { this.accountNumber = accountNumber; this.accountType = accountType; } // equals() and hashCode()}

a seguir, vamos associar a classe contabilística à conta da entidade.

para fazer isso, precisamos anotar a entidade com a anotação @IdClass. Devemos também declarar os campos da classe Contid na conta da entidade e anotar com @Id:

@Entity@IdClass(AccountId.class)public class Account { @Id private String accountNumber; @Id private String accountType; // other fields, getters and setters}

a anotação Embeddid

@Embeddid é uma alternativa à anotação @IdClass.

vamos considerar outro exemplo onde temos de persistir algumas informações de um livro com título e linguagem como os principais campos-chave.

neste caso, a chave primária da classe, BookId, deve ser anotada com @Incorporável:

@Embeddablepublic class BookId implements Serializable { private String title; private String language; // default constructor public BookId(String title, String language) { this.title = title; this.language = language; } // getters, equals() and hashCode() methods}

em Seguida, precisamos incorporar essa classe no Livro de entidade de usar o @EmbeddedId:

@Entitypublic class Book { @EmbeddedId private BookId bookId; // constructors, other fields, getters and setters}

@IdClass vs @EmbeddedId

Como acabamos de ver, a diferença sobre a superfície entre esses dois é que com @IdClass, tivemos para especificar as colunas duas vezes – uma vez em AccountId e novamente na Conta. Mas, com @Embeddid nós não.

existem alguns outros tradeoffs, no entanto.

por exemplo, estas diferentes estruturas afetam as consultas JPQL que escrevemos.

Por exemplo, com @IdClass, a consulta é um pouco mais simples:

SELECT account.accountNumber FROM Account account

Com @EmbeddedId, temos que fazer um extra transversal:

SELECT book.bookId.title FROM Book book

Também, @IdClass pode ser muito útil em lugares onde nós estamos usando uma chave composta da classe que não podemos modificar.

finalmente, se vamos acessar partes da chave composta individualmente, podemos fazer uso de @IdClass, mas em lugares onde frequentemente usamos o identificador completo como um objeto, o @Embeddid é preferido.

Conclusion

In this quick article, we explore composite primary keys in JPA.

como sempre, o código completo para este artigo pode ser encontrado no Github.