samengestelde primaire sleutels in JPA

Inleiding

in deze tutorial zullen we meer leren over samengestelde primaire sleutels en de bijbehorende annotaties in JPA.

samengestelde primaire sleutels

een samengestelde primaire sleutel – ook wel een samengestelde sleutel genoemd-is een combinatie van twee of meer kolommen om een primaire sleutel voor een tabel te vormen.

in JPA hebben we twee opties om de samengestelde sleutels te definiëren: de @IdClass en @ EmbeddedId annotaties.

om de samengestelde primaire sleutels te definiëren, moeten we enkele regels volgen:

• de samengestelde primaire sleutel klasse moet openbaar zijn
• het moet een no-arg constructor
• het moet gelijk() en hashCode() methoden
• definiëren Het moet serialiseerbaar zijn

de Idclass annotatie

stel dat we een tabel genaamd Account hebben en het heeft twee kolommen – rekeningnummer, rekeningtype – die de samengestelde sleutel. Nu moeten we het in kaart brengen in JPA.

volgens de JPA-specificatie, laten we een AccountId-klasse maken met deze primaire sleutelvelden:

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

laten we vervolgens de klasse AccountId associëren met de entiteitsrekening.

om dat te doen, moeten we de entiteit annoteren met de @IdClass annotatie. We moeten ook de velden van de Accounttid klasse in de entiteitsrekening declareren en ze annoteren met @Id:

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

de EmbeddedId annotatie

@EmbeddedId is een alternatief voor de @IdClass annotatie.

laten we eens kijken naar een ander voorbeeld waar we wat informatie van een boek met titel en taal als de primaire sleutel velden moeten aanhouden.

in dit geval moet de primaire sleutelklasse BookId worden geannoteerd met @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}

dan moeten we deze klasse insluiten in het boek entiteit met behulp van @EmbeddedId:

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

@IdClass vs @EmbeddedId

zoals we net zagen, is het verschil op het oppervlak tussen deze twee dat we met @IdClass de kolommen twee keer moesten specificeren-één keer in AccountId en opnieuw in Account. Maar met @EmbeddedId hebben we dat niet gedaan.

er zijn echter enkele andere afwegingen.

bijvoorbeeld, deze verschillende structuren beïnvloeden de jpql queries die we schrijven.

bijvoorbeeld, met @IdClass is de query een beetje eenvoudiger:

SELECT account.accountNumber FROM Account account

met @EmbeddedId, moeten we een extra traversal doen:

SELECT book.bookId.title FROM Book book

ook kan @IdClass heel nuttig zijn op plaatsen waar we een composite key class gebruiken die we niet kunnen wijzigen.

ten slotte, als we delen van de samengestelde sleutel individueel gaan benaderen, kunnen we gebruik maken van @IdClass, maar op plaatsen waar we vaak de volledige identifier als object gebruiken, heeft @EmbeddedId de voorkeur.

conclusie

in dit snelle artikel onderzoeken we samengestelde primaire sleutels in JPA.

Zoals altijd is de volledige code voor dit artikel te vinden op Github.