Hibernate : obtenir vs. charger

Dans Hibernate, il existe le concept de récupération de ligne unique. Afin d’obtenir une seule ligne dans la table de base de données respective, nous choisirons soit get() ou load().

get()

get() toujours interroge la base de données. 

Si l’identifiant sérialisable est trouvé, alors nous obtiendrons les détails correspondants.

Exemple

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

L’identifiant sérialisable est 1 (jerSeyNo) –> Clé primaire

Si l’identifiant sérialisable est non trouvé, alors nous obtiendrons le résultat comme null.load()

load() crée toujours un objet proxy.  Si l’identifiant sérialisable est trouvé, alors nous obtiendrons les détails respectifs.        

Exemple

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

System.out.println(swingBowlers);

Identifiant sérialisable est 1 (jerSeyNo) –> Clé primaire

Si l’identifiant sérialisable est introuvable, alors nous obtiendrons un résultat de org.hibernate.ObjectNotFoundException.  

Vérifiez s’il génère toujours une requête, même si nous utilisons la méthode load car nous essayons d’imprimer les détails de l’objet. [System.out.println(swingBowlers);]. Mais il provient uniquement de l’Objet Proxy[Objet Dummy].

Examinons-le de manière pratique.

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

        }

}

Explication : HibernateTutorialRun est une classe pour exécuter l’application HibernateTutorial, et nous l’utilisons sans serveur. Hibernate peut fonctionner avec un serveur et sans serveur. Nous avons créé la méthode principale, et à l’intérieur, nous avons simplement créé un objet pour la classe respective SwingBowlersDaoImpl. Ensuite, nous utilisons juste la référence de cet objet pour appeler la méthode respective.

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

        // utilisation de la méthode load

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

        System.out.println(swingBowlers);

    }

}

Explication :Nous venons de créer la classe SwingBowlersDaoImpl et l’avons mise en œuvre avec SwingBowlersDao , et nous allons surcharger la méthode respective. Nous essayons d’appeler la méthode de la classe HibernateUtil , à savoir la méthode getSessionFactory , nous obtiendrons l’objet SessionFactory , et avec la référence de l’objet SessionFactory , nous appelons la méthode openSession . Ensuite, nous obtiendrons l’objet Session .

Une fois que nous obtenons l’objet Session avec cette session, nous pouvons utiliser soit la méthode load soit la méthode get, et nous devons simplement convertir en la classe respective en raison de la méthode load ou get qui retourne Object. J’espère que vous connaissez le concept d’upcasting et de downcasting en 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 + "]";

    }

}

Explication :Puisque nous associons des champs aux colonnes de base de données. Si le nom du champ est le même que celui de la colonne dans la table de la base de données, il n’est pas nécessaire d’écrire la valeur du nom de colonne au niveau de l’annotation. De même, le nom de la table est le même que le nom de la classeSwingBowlersc’est pourquoi nous ne sommes pas annotés avec @Table. Pour en faire une classe de domaine, nous utilisons l’annotation @Entity au sommet de la classe respective.

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;

    }

}

Explication :Nous venons de créerSessionFactoryen tant que 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>

Explication :Dans celui-ci, nous avons trois sections :

1. Propriétés liées à la base de données
2. Propriétés liées à Hibernate
3. Classe de mapping

Comme vous le savez, nous n’utilisons pas un fichier XML de mapping Hibernate, c’est pourquoi nous avons simplement mentionné la classe de mapping.

dialecte:Il est utilisé pour la génération de requêtes en fonction de la base de données. Dans cette application, nous utilisons la base de données MySQL.

show_sql:Une fois les requêtes générées, nous devons les voir, donc nous devons les mentionner comme vrai.

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>

Explication :Nous venons de générer cette structure de projet Maven à travers l’IDE Eclipse en tant que projet Maven simple. Nous avons ajouté des dépendances telles quehibernate-core,mysql-connector-javaet utilisé Java 1.8 pour observer dans le pom.xml, dans la section des propriétés, la cible et la source.

Détails de la base de données

Conclusion

Si vous souhaitez récupérer (extraire) une seule ligne (un seul enregistrement), vous pouvez utiliser soit laméthode get[ou]méthode load.