Chiavi primarie composite in JPA

1. Introduzione

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

2. Chiavi primarie composte

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 composte: Il @IdClass e EmbeddedId annotazioni.

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

  • La classe della chiave primaria composita deve essere pubblica
  • Deve avere un costruttore senza argomenti
  • Deve definire i metodi equals () e hashCode ()
  • Deve essere S erializzabile

3. L' annotazione IdClass

Supponiamo di avere una tabella chiamata Account e che abbia due colonne - accountNumber, accountType - che formano la chiave composta. Ora dobbiamo mapparlo in JPA.

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

Successivamente, associamo la classe AccountId all'entità Account .

Per fare ciò, dobbiamo annotare l'entità con l' annotazione @IdClass . Dobbiamo anche dichiarare i campi della classe AccountId nell'entità Account e annotarli con @Id :

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

4. L' annotazione EmbeddedId

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

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

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

@Embeddable public 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, dobbiamo incorporare questa classe nell'entità B ook usando @EmbeddedId :

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

5. @IdClass vs EmbeddedId

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

Tuttavia, ci sono altri compromessi.

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 ulteriore attraversamento:

SELECT book.bookId.title FROM Book book

Inoltre, @IdClass può essere molto utile in luoghi in cui stiamo utilizzando una classe di chiavi composte che non possiamo modificare.

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

6. Conclusione

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

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