JPA @Embedded And @Embeddable

1. Panoramica

In questo tutorial vedremo come possiamo mappare un'entità che contiene proprietà incorporate a una singola tabella di database.

Quindi, per questo scopo, useremo le @Embeddable e @Embedded annotazioni fornite dal Java Persistence API (JPA).

2. Contesto del modello di dati

Prima di tutto, definiamo una tabella chiamata azienda .

La tabella dell'azienda memorizzerà le informazioni di base come il nome dell'azienda, l'indirizzo e il telefono, nonché le informazioni di una persona di contatto:

public class Company { private Integer id; private String name; private String address; private String phone; private String contactFirstName; private String contactLastName; private String contactPhone; // standard getters, setters }

La persona di contatto, tuttavia, sembra che dovrebbe essere riassunta in una classe separata. Il problema è che non vogliamo creare una tabella separata per quei dettagli. Quindi, vediamo cosa possiamo fare.

3. @Embeddable

JPA fornisce l' annotazione @Embeddable per dichiarare che una classe verrà incorporata da altre entità.

Definiamo una classe per astrarre i dettagli della persona di contatto:

@Embeddable public class ContactPerson { private String firstName; private String lastName; private String phone; // standard getters, setters }

4. @Embedded

L'annotazione JPA @Embedded viene utilizzata per incorporare un tipo in un'altra entità.

Modifichiamo ora la nostra classe Company . Aggiungeremo le annotazioni JPA e cambieremo anche per utilizzare ContactPerson invece di campi separati:

@Entity public class Company { @Id @GeneratedValue private Integer id; private String name; private String address; private String phone; @Embedded private ContactPerson contactPerson; // standard getters, setters }

Di conseguenza, abbiamo la nostra entità Company , incorporando i dettagli della persona di contatto e mappandola in un'unica tabella di database.

Abbiamo ancora un altro problema, tuttavia, ed è così che JPA mapperà questi campi alle colonne del database.

5. Sostituzione degli attributi

Il fatto è che i nostri campi erano chiamati cose come contactFirstName nella nostra classe Company originale e ora firstName nella nostra classe ContactPerson . Quindi, JPA vorrà mapparli rispettivamente a contact_first_name e first_name .

Oltre ad essere tutt'altro che ideale, in realtà ci spezzerà con la nostra colonna telefonica ora duplicata .

Quindi, possiamo usare @AttributeOverrides e @AttibuteOverride per sovrascrivere le proprietà della colonna del nostro tipo incorporato.

Aggiungiamo questo al campo ContactPerson nella nostra entità Company :

@Embedded @AttributeOverrides({ @AttributeOverride( name = "firstName", column = @Column(name = "contact_first_name")), @AttributeOverride( name = "lastName", column = @Column(name = "contact_last_name")), @AttributeOverride( name = "phone", column = @Column(name = "contact_phone")) }) private ContactPerson contactPerson;

Nota che, poiché queste annotazioni vanno sul campo, possiamo avere sostituzioni diverse per ciascuna entità che lo racchiude.

6. Conclusione

In questo tutorial, abbiamo configurato un'entità con alcuni attributi incorporati e li abbiamo mappati alla stessa tabella di database dell'entità che lo racchiude. Per questo, abbiamo utilizzato i @Embedded , @Embeddable , @AttributeOverrides e @AttributeOverride annotazioni fornite dal Java Persistence API.

Come sempre, il codice sorgente dell'esempio è disponibile su GitHub.