JPA - Componenti ORM

La maggior parte delle applicazioni contemporanee utilizza database relazionali per archiviare i dati. Recentemente, molti fornitori sono passati al database degli oggetti per ridurre il loro carico di manutenzione dei dati. Significa che il database degli oggetti o le tecnologie relazionali degli oggetti si occupano dell'archiviazione, del recupero, dell'aggiornamento e della manutenzione. La parte centrale di queste tecnologie relazionali a oggetti è la mappatura del file orm.xml. Poiché xml non richiede la compilazione, possiamo facilmente apportare modifiche a più origini dati con meno amministrazione.

Mappatura relazionale degli oggetti

Object Relational Mapping (ORM) ti dice brevemente cosa è ORM e come funziona. ORM è una capacità di programmazione per convertire i dati dal tipo di oggetto al tipo relazionale e viceversa.

La caratteristica principale di ORM è la mappatura o l'associazione di un oggetto ai suoi dati nel database. Durante la mappatura dobbiamo considerare i dati, il tipo di dati e le sue relazioni con la sua auto-entità o entità in qualsiasi altra tabella.

Funzionalità avanzate

  • Idiomatic persistence : Consente di scrivere le classi di persistenza utilizzando classi orientate agli oggetti.

  • High Performance : Ha molte tecniche di recupero e tecniche di blocco promettenti.

  • Reliable: È altamente stabile ed eminente. Utilizzato da molti programmatori industriali.

Architettura ORM

Di seguito l'architettura ORM.

L'architettura di cui sopra spiega come i dati degli oggetti vengono archiviati nel database relazionale in tre fasi.

Fase 1

La prima fase, denominata Object datafase contiene classi POJO, interfacce di servizio e classi. È il livello del componente aziendale principale, che dispone di operazioni e attributi della logica di business.

Ad esempio, prendiamo un database dei dipendenti come schema-

  • La classe POJO del dipendente contiene attributi come ID, nome, stipendio e designazione. E metodi come metodi setter e getter di questi attributi.

  • Dipendente DAO / classi di servizio contiene metodi di servizio come creare dipendente, trovare dipendente ed eliminare dipendente.

Fase 2

La seconda fase denominata come mapping o persistence fase che contiene provider JPA, file di mappatura (ORM.xml), JPA Loader e Object Grid.

  • JPA Provider: Il prodotto del fornitore che contiene il sapore JPA (javax.persistence). Ad esempio Eclipselink, Toplink, Hibernate, ecc.

  • Mapping file : Il file di mappatura (ORM.xml) contiene la configurazione di mappatura tra i dati in una classe POJO e i dati in un database relazionale.

  • JPA Loader: Il caricatore JPA funziona come la memoria cache, che può caricare i dati della griglia relazionale. Funziona come una copia del database per interagire con le classi di servizio per i dati POJO (attributi della classe POJO).

  • Object Grid: La griglia degli oggetti è una posizione temporanea che può memorizzare la copia dei dati relazionali, cioè come una memoria cache. Tutte le query sul database vengono prima effettuate sui dati nella griglia degli oggetti. Solo dopo che è stato eseguito il commit, effettua il database principale.

Fase 3

La terza fase è la fase dei dati relazionali. Contiene i dati relazionali che sono logicamente collegati alla componente aziendale. Come discusso in precedenza, solo quando il componente aziendale esegue il commit dei dati, viene archiviato fisicamente nel database. Fino ad allora i dati modificati vengono archiviati in una memoria cache come formato griglia. Lo stesso è il processo per ottenere i dati.

Il meccanismo dell'interazione programmatica delle tre fasi precedenti è chiamato mapping relazionale degli oggetti.

Mapping.xml

Il file mapping.xml serve a istruire il fornitore JPA per mappare le classi Entity con le tabelle del database.

Prendiamo un esempio di entità Employee che contiene quattro attributi. La classe POJO dell'entità Employee denominataEmployee.java è come segue:

public class Employee {

   private int eid;
   private String ename;
   private double salary;
   private String deg;

   public Employee(int eid, String ename, double salary, String deg) {
      super( );
      this.eid = eid;
      this.ename = ename;
      this.salary = salary;
      this.deg = deg;
   }

   public Employee( ) {
      super();
   }

   public int getEid( ) {
      return eid;
   }
   
   public void setEid(int eid) {
      this.eid = eid;
   }
   
   public String getEname( ) {
      return ename;
   }
   
   public void setEname(String ename) {
      this.ename = ename;
   }

   public double getSalary( ) {
      return salary;
   }
   
   public void setSalary(double salary) {
      this.salary = salary;
   }

   public String getDeg( ) {
      return deg;
   }
   
   public void setDeg(String deg) {
      this.deg = deg;
   }
}

Il codice sopra è la classe POJO dell'entità Employee. Contiene quattro attributi eid, ename, salary e deg. Considera che questi attributi sono i campi della tabella nel database e eid è la chiave primaria di questa tabella. Ora dobbiamo progettare il file di mappatura ibernato per questo. Il file di mapping denominatomapping.xml è come segue:

<? xml version="1.0" encoding="UTF-8" ?>

<entity-mappings xmlns="http://java.sun.com/xml/ns/persistence/orm"
   xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
   xsi:schemaLocation="http://java.sun.com/xml/ns/persistence/orm    
   http://java.sun.com/xml/ns/persistence/orm_1_0.xsd"
   version="1.0">
      
   <description> XML Mapping file</description>
      
   <entity class="Employee">        
      <table name="EMPLOYEETABLE"/>
      <attributes>
      
         <id name="eid">
            <generated-value strategy="TABLE"/>
         </id>

         <basic name="ename">
            <column name="EMP_NAME" length="100"/>
         </basic>
         
         <basic name="salary">
         </basic>
         
         <basic name="deg">
         </basic>
         
      </attributes>
   </entity>
   
</entity-mappings>

Lo script precedente per mappare la classe di entità con la tabella del database. In questo file

  • <entity-mappings> : tag definisce la definizione dello schema per consentire i tag di entità nel file xml.

  • <description> : tag definisce la descrizione dell'applicazione.

  • <entity>: tag definisce la classe di entità che si desidera convertire in tabella in un database. La classe di attributi definisce il nome della classe di entità POJO.

  • <table>: tag definisce il nome della tabella. Se si desidera mantenere il nome della classe come nome della tabella, questo tag non è necessario.

  • <attributes> : tag definisce gli attributi (campi in una tabella).

  • <id>: tag definisce la chiave primaria della tabella. Il<generated-value> tag definisce come assegnare il valore della chiave primaria come Automatico, Manuale o preso da Sequenza.

  • <basic> : tag viene utilizzato per definire gli attributi rimanenti per la tabella.

  • <column-name> : tag viene utilizzato per definire il nome del campo della tabella definito dall'utente.

Annotazioni

In genere i file Xml vengono utilizzati per configurare un componente specifico o mappare due diverse specifiche dei componenti. Nel nostro caso, dobbiamo mantenere xml separatamente in un framework. Ciò significa che durante la scrittura di un file xml di mappatura dobbiamo confrontare gli attributi della classe POJO con i tag di entità nel file mapping.xml.

Ecco la soluzione: nella definizione della classe, possiamo scrivere la parte di configurazione utilizzando le annotazioni. Le annotazioni vengono utilizzate per classi, proprietà e metodi. Le annotazioni iniziano con il simbolo "@". Le annotazioni vengono dichiarate prima della dichiarazione della classe, della proprietà o del metodo. Tutte le annotazioni di JPA sono definite nel pacchetto javax.persistence.

Di seguito l'elenco delle annotazioni utilizzate nei nostri esempi

Annotazione Descrizione
@Entità Questa annotazione specifica di dichiarare la classe come entità o tabella.
@Tavolo Questa annotazione specifica di dichiarare il nome della tabella.
@Di base Questa annotazione specifica esplicitamente i campi senza vincoli.
@Incorporato Questa annotazione specifica le proprietà della classe o di un'entità la cui istanza del valore di una classe incorporabile.
@Id Questa annotazione specifica la proprietà, utilizzare per l'identità (chiave primaria di una tabella) della classe.
@GeneratedValue Questa annotazione specifica come può essere inizializzato l'attributo di identità come Automatico, Manuale o valore preso dalla tabella di sequenza.
@Transient Questa annotazione specifica la proprietà che non è persistente, ovvero il valore non viene mai memorizzato nel database.
@Colonna Questa annotazione viene utilizzata per specificare la colonna o l'attributo per la proprietà di persistenza.
@SequenceGenerator Questa annotazione viene utilizzata per definire il valore per la proprietà che è specificato nell'annotazione @GeneratedValue. Crea una sequenza.
@TableGenerator Questa annotazione viene utilizzata per specificare il generatore di valori per la proprietà specificata nell'annotazione @GeneratedValue. Crea una tabella per la generazione di valore.
@AccessType Questo tipo di annotazione viene utilizzato per impostare il tipo di accesso. Se si imposta @AccessType (FIELD), si verificherà l'accesso in base al campo. Se si imposta @AccessType (PROPERTY), si verificherà una valutazione saggia della proprietà.
@JoinColumn Questa annotazione viene utilizzata per specificare un'associazione di entità o una raccolta di entità. Viene utilizzato nelle associazioni molti-a-uno e uno-a-molti.
@UniqueConstraint Questa annotazione viene utilizzata per specificare il campo, vincolo univoco per la tabella primaria o secondaria.
@ColumnResult Questa annotazione fa riferimento al nome di una colonna nella query SQL utilizzando la clausola select.
@ManyToMany Questa annotazione viene utilizzata per definire una relazione molti-a-molti tra le tabelle di join.
@ManyToOne Questa annotazione viene utilizzata per definire una relazione molti-a-uno tra le tabelle di join.
@OneToMany Questa annotazione viene utilizzata per definire una relazione uno-a-molti tra le tabelle di join.
@Uno a uno Questa annotazione viene utilizzata per definire una relazione uno a uno tra le tabelle di join.
@NamedQueries Questa annotazione viene utilizzata per specificare l'elenco di query denominate.
@NamedQuery Questa annotazione viene utilizzata per specificare una query utilizzando il nome statico.

Java Bean Standard

Classe Java, incapsula i valori e i comportamenti dell'istanza in un singolo oggetto richiamato dall'unità. Java Bean è una memoria temporanea e un componente riutilizzabile o un oggetto. È una classe serializzabile che dispone di un costruttore predefinito e di metodi getter e setter per inizializzare individualmente gli attributi dell'istanza.

Convenzioni sui fagioli

  • Bean contiene il costruttore predefinito o un file che contiene un'istanza serializzata. Pertanto, un bean può istanziare il bean.

  • Le proprietà di un bean possono essere suddivise in proprietà booleane e proprietà non booleane.

  • La proprietà non booleana contiene getter e setter metodi.

  • La proprietà booleana contiene setter e is metodo.

  • GetterIl metodo di qualsiasi proprietà deve iniziare con una lettera minuscola "get" (convenzione del metodo java) e continuare con un nome di campo che inizia con una lettera maiuscola. Ad esempio, il nome del campo è "salary", quindi il metodo getter di questo campo è "getSalary ()".

  • SetterIl metodo di qualsiasi proprietà deve iniziare con "set" minuscolo (convenzione del metodo java), continuato con un nome di campo che inizia con una lettera maiuscola e il valore dell'argomento da impostare su field. Ad esempio, il nome del campo è 'salary' quindi il metodo di setter di questo campo è 'setSalary (double sal)'.

  • Per la proprietà booleana, è il metodo per verificare se è vero o falso. Ad esempio, la proprietà booleana 'empty', il metodo is di questo campo è 'isEmpty ()'.