sammansatta primära nycklar i JPA

introduktion

i denna handledning lär vi oss om sammansatta primära nycklar och motsvarande anteckningar i JPA.

sammansatta primärnycklar

en sammansatt primärnyckel – även kallad en sammansatt nyckel – är en kombination av två eller flera kolumner för att bilda en primärnyckel för en tabell.

i JPA har vi två alternativ för att definiera kompositnycklarna: anteckningarna @IdClass och @EmbeddedId.

för att definiera de sammansatta primärnycklarna bör vi följa vissa regler:

• den sammansatta primära nyckelklassen måste vara offentlig
• den måste ha en no-arg – konstruktör
• den måste definiera lika med() och hashCode() metoder
• den måste vara serialiserbar

IdClass – anteckningen

låt vi säger att vi har en tabell som heter konto och den har två kolumner-kontonummer, Accounttype-som utgör den sammansatta nyckeln. Nu måste vi kartlägga det i JPA.

enligt JPA-specifikationen, låt oss skapa en AccountId-klass med dessa primära nyckelfält:

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

låt oss sedan associera AccountId-klassen med entitetskontot.

för att göra det måste vi kommentera enheten med @IdClass-anteckningen. Vi måste också deklarera fälten Från AccountId-klassen i entitetskontot och kommentera dem med @Id:

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

EmbeddedId-anteckningen

@EmbeddedId är ett alternativ till @IdClass-anteckningen.

låt oss överväga ett annat exempel där vi måste fortsätta med viss information om en bok med titel och språk som primära nyckelfält.

i det här fallet måste primärnyckelklassen, BookId, kommenteras med @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}

sedan måste vi bädda in den här klassen i Bokenheten med @EmbeddedId:

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

@IdClass vs @EmbeddedId

som vi just såg är skillnaden på ytan mellan dessa två att med @IdClass var vi tvungna att ange kolumnerna två gånger – en gång i AccountId och igen i konto. Men med @EmbeddedId gjorde vi det inte.

det finns dock några andra kompromisser.

till exempel påverkar dessa olika strukturer JPQL-frågorna som vi skriver.

till exempel med @IdClass är frågan lite enklare:

SELECT account.accountNumber FROM Account account

med @EmbeddedId måste vi göra en extra traversal:

SELECT book.bookId.title FROM Book book

@IdClass kan också vara ganska användbart på platser där vi använder en sammansatt nyckelklass som vi inte kan ändra.

slutligen, om vi ska komma åt delar av kompositnyckeln individuellt, kan vi använda @IdClass, men på platser där vi ofta använder den fullständiga identifieraren som ett objekt föredras @EmbeddedId.

slutsats

i den här snabbartikeln utforskar vi sammansatta primärnycklar i JPA.

som alltid kan den fullständiga koden för den här artikeln hittas över på Github.