JPA @Basic Annotation

1. Panoramica

In questo breve tutorial, esploreremo l' annotazione JPA @Basic . Discuteremo anche la differenza tra le annotazioni JPA @Basic e @Column .

2. Tipi di base

JPA supporta vari tipi di dati Java come campi persistenti di un'entità, spesso noti come tipi di base.

Un tipo di base viene mappato direttamente a una colonna nel database. Questi includono le primitive Java e le loro classi wrapper, String , java.math.BigInteger e java.math.BigDecimal , varie classi data-ora disponibili, enumerazioni e qualsiasi altro tipo che implementa java.io.Serializable .

Hibernate, come qualsiasi altro fornitore ORM, mantiene un registro di tipi di base e lo utilizza per risolvere org.hibernate.type.Type specifico di una colonna .

3. Annotazione @Basic

Possiamo usare l' annotazione @Basic per contrassegnare una proprietà di tipo di base:

@Entity public class Course { @Basic @Id private int id; @Basic private String name; ... }

In altre parole, l' annotazione @Basic su un campo o una proprietà significa che è un tipo di base e Hibernate dovrebbe usare la mappatura standard per la sua persistenza.

Nota che è un'annotazione facoltativa. E così, possiamo riscrivere la nostra entità Course come:

@Entity public class Course { @Id private int id; private String name; ... }

Quando non specifichiamo l' annotazione @Basic per un attributo di tipo di base, viene implicitamente assunto e si applicano i valori predefiniti di questa annotazione.

4. Perché utilizzare l' annotazione @Basic ?

L' annotazione @Basic ha due attributi, opzionale e fetch . Diamo un'occhiata più da vicino a ciascuno di essi.

L' attributo facoltativo è un parametro booleano che definisce se il campo o la proprietà contrassegnati consente null . Il valore predefinito è true . Quindi, se il campo non è un tipo primitivo, si presume che la colonna sottostante sia nullable per impostazione predefinita.

L' attributo fetch accetta un membro dell'enumerazione Fetch , che specifica se il campo o la proprietà contrassegnati devono essere caricati pigramente o recuperati con impazienza. Il valore predefinito è FetchType.EAGER , ma possiamo consentire il caricamento lento impostandolo su FetchType.LAZY.

Il caricamento lento ha senso solo quando abbiamo un oggetto serializzabile di grandi dimensioni mappato come tipo di base, poiché in tal caso il costo di accesso al campo può essere significativo.

Abbiamo un tutorial dettagliato sul caricamento Eager / Lazy in Hibernate che approfondisce l'argomento.

Ora, diciamo che non vogliono consentire i null per il nostro Corso di 's nome e si desidera caricare pigramente che la proprietà pure. Quindi, definiremo la nostra entità Course come:

@Entity public class Course { @Id private int id; @Basic(optional = false, fetch = FetchType.LAZY) private String name; ... }

Dobbiamo utilizzare esplicitamente l' annotazione @Basic quando si desidera deviare dai valori predefiniti dei parametri opzionali e di recupero . Possiamo specificare uno o entrambi questi attributi, a seconda delle nostre esigenze.

5. JPA @Basic vs @Column

Diamo un'occhiata alle differenze tra le annotazioni @Basic e @Column :

  • Gli attributi dell'annotazione @Basic vengono applicati alle entità JPA, mentre gli attributi di @Column vengono applicati alle colonne del database
  • L' attributo opzionale dell'annotazione @Basic definisce se il campo dell'entità può essere nullo o meno; d'altra parte, l' attributo nullable dell'annotazione @Column specifica se la colonna del database corrispondente può essere nulla
  • Possiamo usare @Basic per indicare che un campo deve essere caricato pigramente
  • L' annotazione @Column ci consente di specificare il nome della colonna del database mappata

6. Conclusione

In questo articolo, abbiamo appreso quando e come utilizzare l' annotazione @Basic di JPA . Abbiamo anche parlato di come differisce dall'annotazione @Column .

Come al solito, gli esempi di codice sono disponibili su Github.