Hibernate Get contro Load

In Hibernate, esiste il concetto di recupero di singola riga. Per ottenere una singola riga nella tabella del database corrispondente, optiamo per l’utilizzo di get() o load().

get()

get() colpisce sempre il database.

Se l’identificativo serializzabile viene trovato, allora otterremo i dettagli corrispondenti.

Esempio

SwingBowlers swingBowlers = (SwingBowlers) openSession.get(SwingBowlers.class,1);

L’identificativo serializzabile è 1 (jerSeyNo) –> Chiave Primaria

Se l’identificativo serializzabile è non trovato, allora otterremo come risultato null.load()

load() crea sempre un oggetto proxy.  Se l’identificativo serializzabile è trovato, allora otterremo i dettagli corrispondenti.        

Esempio

SwingBowlers swingBowlers = (SwingBowlers) openSession.get(SwingBowlers.class,1);

System.out.println(swingBowlers);

Identificativo serializzabile è 1 (jerSeyNo) –> Chiave Primaria

Se l’identificativo serializzabile è non trovato, allora otterremo un risultato di org.hibernate.ObjectNotFoundException.  

Verificare se genera ancora una query, anche se stiamo utilizzando il metodo load perché stiamo cercando di stampare i dettagli dell’oggetto. [System.out.println(swingBowlers);]. Ma proviene solo dal Proxy Object[Dummy Object].

Diamo un’occhiata praticamente.

HibernateTutorialRun.java

package com.blogspot.javacodebypj;

import com.blogspot.javacodebypj.dao.SwingBowlersDaoImpl;

public class HibernateTutorialRun {

    public static void main(String[] args) {

        SwingBowlersDaoImpl sbdi = new SwingBowlersDaoImpl();

        sbdi.getSwingBowlers();

        }

}

Spiegazione: HibernateTutorialRun è una classe per eseguire l’applicazione HibernateTutorial, e la stiamo utilizzando senza un server. Hibernate può funzionare con il server e anche senza. Abbiamo creato il metodo principale, e in quello, abbiamo appena creato un oggetto per la classe corrispondente SwingBowlersDaoImpl. Quindi stiamo semplicemente utilizzando quella referenza di oggetto chiamando il metodo corrispondente.

SwingBowlersDao.java

package com.blogspot.javacodebypj.dao;

import org.hibernate.Session;

import org.hibernate.SessionFactory;

import com.blogspot.javacodebypj.domain.SwingBowlers;

import com.blogspot.javacodebypj.util.HibernateUtil;



public class SwingBowlersDaoImpl implements SwingBowlersDao {

    @Override

    public void getSwingBowlers() {

        SessionFactory sessionFactory = HibernateUtil.getSessionFactory();

        Session openSession = sessionFactory.openSession();

       // utilizzando il metodo load

        SwingBowlers swingBowlers = (SwingBowlers) openSession.load(SwingBowlers.class, 1);

        System.out.println(swingBowlers);

    }

}

Spiegazione: Abbiamo appena creato SwingBowlersDaoImpl classe e l’abbiamo implementata con SwingBowlersDao e stiamo per sovrascrivere il metodo corrispondente. Stiamo cercando di chiamare HibernateUtil classe metodo, vale a dire, getSessionFactory metodo, otterremo SessionFactory oggetto, e con il SessionFactory oggetto riferimento, stiamo chiamando openSession metodo. Quindi otterremo Session oggetto. 

Una volta ottenuto Session l’oggetto con questa sessione, possiamo chiamare sia l’utilizzo del load metodo o get metodo, e basta effettuare il cast alla classe corrispondente a causa del load metodo o get metodo che restituisce Object. Spero che conosciate il concetto di upcasting e downcasting in Java.

SwingBowlers.java

package com.blogspot.javacodebypj.domain;

import javax.persistence.Column;

import javax.persistence.Entity;

import javax.persistence.Id;

@Entity

public class SwingBowlers {

    @Id

    @Column(length = 3)

    private int jerseyNo;

    @Column(length = 15)

    private String bowlerName;

    @Column(length = 10)

    private String country;

    public int getJerseyNo() {

        return jerseyNo;

    }

    public void setJerseyNo(int jerseyNo) {

        this.jerseyNo = jerseyNo;

    }

    public String getBowlerName() {

        return bowlerName;

    }

    public void setBowlerName(String bowlerName) {

        this.bowlerName = bowlerName;

    }

    public String getCountry() {

        return country;

    }

    public void setCountry(String country) {

        this.country = country;

    }

    @Override

    public String toString() {

        return "SwingBowlers [jerseyNo=" + jerseyNo + ", bowlerName=" + bowlerName + ", country=" + country + "]";

    }

}

Spiegazione:Dato che stiamo mappando campi su colonne del database. Se il nome del campo è lo stesso del nome della colonna nella tabella del database, non è necessario scrivere il valore del nome della colonna a livello di annotazione. Allo stesso modo, anche il nome della tabella è lo stesso del nome della classeSwingBowlersecco perché non abbiamo annotato con @Table. Per renderlo una classe del dominio, stiamo utilizzando l’annotazione @Entity in cima alla classe corrispondente.

HibernateUtil.java

package com.blogspot.javacodebypj.util;

import org.hibernate.SessionFactory;

import org.hibernate.cfg.Configuration;

public class HibernateUtil {

    private static SessionFactory sessionFactory;

    private HibernateUtil() {

    }

    public static SessionFactory getSessionFactory() {

        if (sessionFactory == null) {

            Configuration conf = new Configuration().configure();

            sessionFactory = conf.buildSessionFactory();

        }

        return sessionFactory;

    }

}

Spiegazione:Abbiamo appena creatoSessionFactory come classe singleton.

hibernate.cfg.xml

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

<!DOCTYPE hibernate-configuration PUBLIC

"-//Hibernate/Hibernate Configuration DTD 3.0//EN"

"http://hibernate.sourceforge.net/hibernate-configuration-3.0.dtd">



<hibernate-configuration>

    <session-factory>

        <property name="connection.driver_class">com.mysql.jdbc.Driver

        </property>

        <property name="connection.url">jdbc:mysql://localhost:3306/cricketer</property>

        <property name="connection.username">root</property>

        <property name="connection.password">myRoot4*</property>



        <property name="dialect">org.hibernate.dialect.MySQL8Dialect</property>

        <property name="show_sql">true</property>

        <property name="hbm2ddl.auto">update</property>



        <mapping class="com.blogspot.javacodebypj.domain.SwingBowlers" />



    </session-factory>

</hibernate-configuration>

Spiegazione:In questo, abbiamo tre sezioni:

1. Proprietà correlate al database
2. Proprietà correlate a Hibernate
3. Classe di mapping

Come sapete, non stiamo utilizzando un file XML di mapping di Hibernate, motivo per cui abbiamo solo menzionato la classe di mapping.

dialect: Viene utilizzato per la generazione delle query in relazione al database. In questa applicazione, stiamo utilizzando il database MySQL.

show_sql: Una volta generati i query, abbiamo bisogno di visualizzarli query, quindi dobbiamo menzionarli come true.

pom.xml

<project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 https://maven.apache.org/xsd/maven-4.0.0.xsd">

    <modelVersion>4.0.0</modelVersion>

    <groupId>com.blogspot.javacodebypj</groupId>

    <artifactId>HibernateTutorial</artifactId>

    <version>0.0.1-SNAPSHOT</version>

    <name>HibernateTutorial</name>

    <description>HibernateTutorial by Ponnam Jay</description>

    <properties>

        <maven.compiler.target>1.8</maven.compiler.target>

        <maven.compiler.source>1.8</maven.compiler.source>

    </properties>

    <dependencies>

        <!-- https://mvnrepository.com/artifact/org.hibernate/hibernate-core -->

        <dependency>

            <groupId>org.hibernate</groupId>

            <artifactId>hibernate-core</artifactId>

            <version>5.6.14.Final</version>



        </dependency>

        <!-- https://mvnrepository.com/artifact/mysql/mysql-connector-java -->

        <dependency>

            <groupId>mysql</groupId>

            <artifactId>mysql-connector-java</artifactId>

            <version>8.0.28</version>

        </dependency>



    </dependencies>

</project>

Spiegazione: Abbiamo appena generato questa struttura del progetto Maven attraverso l’IDE Eclipse come progetto Maven semplice. Abbiamo aggiunto dipendenze come hibernate-core, mysql-connector-java e usato Java 1.8 per osservare nel pom.xml nella sezione delle proprietà target e source.

Dettagli del Database

Conclusione 

Se desideri recuperare (estrarre) una singola riga (un singolo record), allora puoi utilizzare sia il get metodo [o]  load metodo.