chei primare compozite în JPA

Introducere

în acest tutorial, vom afla despre cheile primare compozite și adnotările corespunzătoare în JPA.

chei primare compozite

o cheie primară compozită – numită și cheie compozită – este o combinație de două sau mai multe coloane pentru a forma o cheie primară pentru un tabel.

în JPA, avem două opțiuni pentru a defini tastele compozite: adnotările @IdClass și @EmbeddedId.

pentru a defini cheile primare compozite, ar trebui să urmăm câteva reguli:

• clasa cheie primară compusă trebuie să fie publică
• trebuie să aibă un constructor no-arg
• trebuie să definească metode egale() și hashCode ()
• trebuie să fie Serializabil

adnotarea IdClass

să spunem că avem un tabel numit cont și are două coloane – AccountNumber, AccountType – care formează cheia compozită. Acum trebuie să-l mapăm în JPA.

Conform specificației JPA, să creăm o clasă AccountId cu aceste câmpuri cheie primară:

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

apoi, să asociem clasa AccountId cu contul de entitate.

pentru a face acest lucru, trebuie să adnotăm entitatea cu adnotarea @IdClass. De asemenea, trebuie să declarăm câmpurile din clasa AccountId din contul entității și să le adnotăm cu @Id:

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

adnotarea EmbeddedId

@EmbeddedId este o alternativă la adnotarea @IdClass.

să luăm în considerare un alt exemplu în care trebuie să persistăm unele informații ale unei cărți cu titlu și limbă ca câmpuri cheie primare.

în acest caz, clasa cheie primară, BookId, trebuie adnotată cu @ Embeddable:

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

apoi, trebuie să încorporăm această clasă în entitatea de carte folosind @ EmbeddedId:

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

@IdClass vs @ EmbeddedId

după cum tocmai am văzut, diferența de la suprafață dintre aceste două este că, cu @IdClass, a trebuit să specificăm coloanele de două ori – o dată în AccountId și din nou în cont. Dar, cu @EmbeddedId nu am făcut-o.

există totuși și alte compromisuri.

de exemplu, aceste structuri diferite afectează interogările JPQL pe care le scriem.

de exemplu ,cu @ IdClass, interogarea este un pic mai simplu:

SELECT account.accountNumber FROM Account account

cu @ EmbeddedId, trebuie să facem o traversare suplimentară:

SELECT book.bookId.title FROM Book book

de asemenea, @IdClass poate fi destul de util în locurile în care folosim o clasă cheie compusă pe care nu o putem modifica.

în cele din urmă, dacă vom accesa părți ale cheii compozite individual, putem folosi @IdClass, dar în locurile în care folosim frecvent identificatorul complet ca obiect, @EmbeddedId este preferat.

concluzie

în acest articol rapid, vom explora cheile primare compozite în JPA.

ca întotdeauna, codul complet pentru acest articol poate fi găsit pe Github.