Hibernate Get vs. Load

In Hibernate gibt es das Konzept der Einzelzeilenabfrage. Um eine einzelne Zeile in der entsprechenden Datenbanktabelle abzurufen, wählen wir entweder get() oder load().

get()

get() betrifft immer die Datenbank. 

Wenn die serialisierbare ID gefunden wird, erhalten wir die entsprechenden Details.

Beispiel

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

Die serialisierbare ID ist 1 (jerSeyNo) –> Primärschlüssel

Wenn die serielle ID nicht gefunden wird, erhalten wir das Ergebnis als null.load()

load() erzeugt immer ein Proxy-Objekt.Wenn die serielle ID gefunden wird, erhalten wir die entsprechenden Details.        

Beispiel

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

System.out.println(swingBowlers);

Serielle ID ist 1 (jerSeyNo) –> Primärschlüssel

Wenn die serialisierbare ID nicht gefunden wird, erhalten wir ein Ergebnis von org.hibernate.ObjectNotFoundException.

Überprüfen Sie, ob es trotz der Verwendung der Load-Methode, da wir versuchen, Objektdetails auszugeben, immer noch eine Abfrage erzeugt. [System.out.println(swingBowlers);]. Aber es kommt nur von Proxy Object[Dummy Object].

Schauen wir es uns praktisch an.

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

        }

}

Erläuterung:  HibernateTutorialRun ist eine Klasse zum Starten der HibernateTutorial-Anwendung, und wir verwenden sie ohne einen Server. Hibernate kann sowohl mit als auch ohne Server betrieben werden. Wir haben die main-Methode erstellt, und darin erstellen wir lediglich ein Objekt für die entsprechende Klasse SwingBowlersDaoImpl. Anschließend verwenden wir einfach die Objektreferenz, um die entsprechende Methode aufzurufen.

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

        // Verwendung der load-Methode

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

        System.out.println(swingBowlers);

    }

}

Erklärung: Wir haben gerade die SwingBowlersDaoImpl Klasse erstellt und sie mit der SwingBowlersDao implementiert, und wir werden die entsprechenden Methoden überschreiben. Wir versuchen, die Methode der HibernateUtil Klasse aufzurufen, also die getSessionFactory Methode, wir erhalten ein SessionFactory Objekt, und mit dem SessionFactory Objektverweis rufen wir die openSession Methode auf. Dann erhalten wir ein Session Objekt. 

Sobald wir Session Objekt mit dieser Sitzung erhalten, können wir entweder die load Methode oder die get Methode verwenden, und wir müssen einfach zur jeweiligen Klasse casten, weil die load Methode oder die get Methode ein Object zurückgibt. Ich hoffe, Sie verstehen das Konzept von Upcasting und 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 + "]";

    }

}

Erklärung: Da wir Felder auf Datenbankspalten abbilden. Wenn der Feldname identisch ist mit dem Spaltennamen in der Datenbanktabelle, dann ist es nicht notwendig, den Spaltennamenwert auf der Anmerkungsebene zu schreiben. Ebenso gilt das für den Tabellennamen, der dem Klassennamen entspricht SwingBowlersweshalb wir nicht mit @Table annotiert sind. Um es zu einer Domänenklasse zu machen, verwenden wir die @Entity-Anmerkung oben in der jeweiligen Klasse.

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;

    }

}

Erklärung: Wir haben lediglich SessionFactory als Singleton-Klasse erstellt. 

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>

Erklärung: In diesem liegen drei Abschnitte: 

1. Datenbankbezogene Eigenschaften
2. Hibernate-bezogene Eigenschaften
3. Zuordnungsklasse

Wie Sie wissen, verwenden wir kein Hibernate-Zuordnungs-XML-Datei, deshalb haben wir nur die Zuordnungsklasse erwähnt.

Dialekt: Es wird zur Abfrageerzeugung im Hinblick auf die Datenbank verwendet. In dieser Anwendung verwenden wir die MySQL-Datenbank.

show_sql: Nachdem Abfragen erzeugt wurden, müssen wir diese Abfragen sehen, deshalb müssen wir sie als true angeben.

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>

Erklärung: Wir haben diese Maven-Projektstruktur gerade über die Eclipse IDE als einfaches Maven-Projekt erstellt. Wir haben Abhängigkeiten hinzugefügt wie hibernate-core, mysql-connector-java und haben Java 1.8 verwendet, um im pom.xml in der Eigenschaftssektion Ziel und Quelle zu beobachten.

Datenbankdetails

Schlussfolgerung 

Wenn Sie eine einzelne Zeile (einzelnes Datensatz) abrufen (abrufen) möchten, können Sie entweder die get Methode [oder]  load Methode verwenden.