Chiavi primarie composite in JPA

Introduzione

In questo tutorial, impareremo a conoscere le chiavi primarie composite e le annotazioni corrispondenti in JPA.

Chiavi primarie composite

Una chiave primaria composita, chiamata anche chiave composita, è una combinazione di due o più colonne per formare una chiave primaria per una tabella.

In JPA, abbiamo due opzioni per definire le chiavi composite :Le annotazioni @ IdClass e @ EmbeddedId.

Per definire le chiavi primarie composite, dovremmo seguire alcune regole:

• chiave primaria composta classe deve essere pubblica
• deve avere un no-arg costruttore
• È necessario definire equals() e hashCode() metodi
• deve essere Serializzabile

Il IdClass Annotazione

supponiamo di avere una tabella denominata Account in due colonne – accountNumber, accountType – che formano la chiave composta. Ora dobbiamo mapparlo in JPA.

Come da specifica JPA, creiamo una classe AccountId con questi campi chiave primaria:

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()}

Quindi, associamo la classe AccountId all’account dell’entità.

Per fare ciò, dobbiamo annotare l’entità con l’annotazione @IdClass. Dobbiamo anche dichiarare i campi dalla classe AccountId nell’account dell’entità e annotarli con @ Id:

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

L’annotazione EmbeddedId

@EmbeddedId è un’alternativa all’annotazione @IdClass.

Consideriamo un altro esempio in cui dobbiamo mantenere alcune informazioni di un libro con titolo e lingua come campi chiave primari.

In questo caso, la chiave primaria classe, BookId, deve essere annotata con @Incorporabile:

@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}

Quindi, abbiamo bisogno di incorporare questa classe nel Libro entità @EmbeddedId:

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

@IdClass vs @EmbeddedId

Come abbiamo appena visto, la differenza di superficie tra questi due è che con @IdClass, abbiamo dovuto specificare le colonne due volte – una volta in AccountId e di nuovo in Considerazione. Ma, con @ EmbeddedId non l’abbiamo fatto.

Ci sono alcuni altri compromessi, però.

Ad esempio, queste diverse strutture influenzano le query JPQL che scriviamo.

Ad esempio, con @IdClass, la query è un po ‘ più semplice:

SELECT account.accountNumber FROM Account account

Con @ EmbeddedId, dobbiamo fare un attraversamento in più:

SELECT book.bookId.title FROM Book book

Inoltre, @ IdClass può essere abbastanza utile nei luoghi in cui stiamo usando una classe di chiavi composite che non possiamo modificare.

Infine, se accediamo individualmente a parti della chiave composita, possiamo utilizzare @IdClass, ma nei luoghi in cui usiamo frequentemente l’identificatore completo come oggetto, @EmbeddedId è preferito.

Conclusione

In questo breve articolo, esploriamo le chiavi primarie composite in JPA.

Come sempre, il codice completo per questo articolo può essere trovato su Github.