Exemple de chargement en veille prolongée

Hibernate Session fournit différentes méthodes pour récupérer les données (ou un seul enregistrement) de la base de données. Deux d'entre eux sont - get() et load() . La fonctionnalité est similaire mais il y a une différence entre les façons dont ils fonctionnent. Dans ce tutoriel, nous allons démontrer l'utilisation de load() méthode dans Hibernate en utilisant la configuration basée sur les annotations.

1. Présentation

1.1 Hiberner

• Le mappage objet-relationnel ou ORM est la technique de programmation permettant de mapper les objets du modèle de domaine d'application aux tables de la base de données relationnelle
• Hibernate est un outil ORM basé sur Java qui fournit un cadre pour mapper les objets du domaine d'application aux tables de la base de données relationnelle et vice versa. Il fournit une implémentation de référence de l'API Java Persistence qui en fait un excellent choix en tant qu'outil ORM avec les avantages d'un couplage lâche
• Un framework qui a la possibilité de mapper d'anciens objets Java simples sur les tables de base de données traditionnelles à l'aide d'annotations JPA ainsi que de XML configuration basée

Fig. 1 :Présentation de l'hibernation

1.2 Annotations d'hibernation

• Les annotations Hibernate sont la nouvelle façon de définir des mappages sans utiliser de XML fichier
• Les développeurs utilisent des annotations pour fournir la configuration des métadonnées avec le code Java. Ainsi, rendre le code facile à comprendre
• XML offre la possibilité de modifier la configuration sans générer le projet. Ainsi, les annotations sont moins puissantes que le XML configuration et ne doit être utilisé que pour les mappages de tables et de colonnes
• Les annotations sont préconfigurées avec des valeurs par défaut raisonnables, ce qui réduit la quantité de codage requise. Par ex. Le nom de la classe est par défaut le nom de la table et les noms des champs sont par défaut les noms des colonnes

1.2.1 Guide de référence sur les annotations Hibernate

Les annotations Hibernate sont basées sur la spécification JPA 2. Toutes les annotations JPA sont définies dans le javax.persistence.* forfait. Les annotations JPA de base d'Hibernate pouvant être utilisées dans une entité sont celles ci-dessous.

Annotation	Modificateur	Description
@Entity		Marque une classe comme une entité Hibernate (classe mappée)
@Table	Nom	Mappe cette classe avec une table de base de données spécifiée par nom modificateur. Si le nom n'est pas fourni, il mappe la classe avec une table portant le même nom que la classe.
@Id		Marque ce champ de classe comme colonne de clé primaire.
@GeneratedValue		Demande à la base de données de générer automatiquement une valeur pour ce champ.
@Column	Nom	Mappe ce champ avec la colonne de table spécifiée par nom et utilise le nom du champ si nom le modificateur est absent.

1.3 Interface de session d'hibernation

Dans Hibernate, une entité (ou un seul enregistrement) peut être obtenue à partir de la base de données en utilisant le Session suivant méthodes d'interface :

• Session.get() :Cette méthode renvoie un objet de persistance de la classe donnée avec l'identifiant donné. Il retournera null s'il n'y a pas d'objet de persistance
• Session.load() :Cette méthode renvoie un objet de persistance de la classe donnée avec l'identifiant donné. Il lancera une exception ObjectNotFoundException , si une entité n'existe pas dans la base de données. Le load() la méthode peut renvoyer un objet proxy au lieu d'un véritable objet de persistance
• Session.byId() :Cette méthode permet d'obtenir un objet de persistance par son identifiant primaire

1.3.1 Méthode Session Load()

Hibernate Session l'interface fournit plusieurs load() méthodes de chargement des entités à partir de la base de données. Chaque load() requiert la clé primaire de l'objet comme identifiant obligatoire. En plus du id , Hibernate a également besoin de savoir quelle classe ou quel nom d'entité doit être utilisé pour trouver l'objet avec ce id . Regardons les différentes saveurs du load() méthode disponible dans la session Hibernate :

• public Object load(Class classObj, Serializable id) throws HibernateException  :Cette méthode a besoin du type de classe comme argument que les développeurs aimeraient charger avec l'unique id et renvoie l'objet entité rempli que les développeurs convertiront au type souhaité
• public Object load(String entityName, Serializable id) throws HibernateException :Cette méthode demande le nom de l'entité et l'unique id . La méthode renvoie l'objet entité rempli que les développeurs convertiront dans le type souhaité
• public void load(Object obj, Serializable id) throws HibernateException :Cette méthode prend un objet comme argument qui doit être la classe que les développeurs souhaitent charger et l'objet doit être vide. Hibernate remplira cet objet avec l'objet demandé par les développeurs

Session.load() renvoie un objet proxy sans toucher à la base de données. Un objet proxy est un objet temporaire auquel aucune valeur n'est affectée à l'exception de la clé primaire ou de la valeur de l'identifiant . Si aucune ligne (ou enregistrement) correspondant à l'identifiant demandé n'existe, alors il lancera le ObjectNotFoundException exception.

Fig. 2 :Diagramme de flux de travail de la méthode Hibernate Load()

1.3.2 Méthode Get() contre Load()

Voici quelques différences entre get() et load() méthode dans Hibernate :

Session.get()	Session.load()
Ne renvoie jamais un objet proxy.	Renvoie toujours l'objet proxy.
Renvoie null lorsque l'enregistrement correspondant n'est pas trouvé mais que l'exécution continue.	Lance ObjectNotFoundException exception lorsque l'enregistrement correspondant n'est pas trouvé et l'exécution se termine.
Eager Loading, car il atteint immédiatement la base de données et renvoie l'objet d'origine.	Lazy Loading, car il n'atteint la base de données que lorsqu'il essaie de récupérer d'autres propriétés de l'objet.
Couramment utilisé pour récupérer les données, c'est-à-dire SELECT operation.	Couramment utilisé pour DELETE et UPDATE opérations.

1.4 Télécharger et installer Hibernate

Vous pouvez lire ce tutoriel afin de télécharger et d'installer Hibernate dans l'IDE Eclipse.

1.5 Télécharger et installer MySQL

Vous pouvez regarder cette vidéo afin de télécharger et d'installer la base de données MySQL sur votre système d'exploitation Windows.

Maintenant, ouvrez l'IDE Eclipse et voyons comment implémenter le Session.load() méthode dans Hibernate en utilisant Annotation!

2. Exemple de chargement d'hibernation

2.1 Outils utilisés

Nous utilisons Eclipse Kepler SR2, JDK 8, la base de données MySQL et Maven. Cela dit, nous avons testé le code par rapport à JDK 1.7 et cela fonctionne bien.

2.2 Structure du projet

Tout d'abord, passons en revue la structure finale du projet, au cas où vous seriez confus quant à l'endroit où vous devriez créer les fichiers ou dossiers correspondants plus tard !

Fig. 3 :Structure du projet d'application Hibernate Load

2.3 Création de projet

Cette section montrera comment créer un projet Maven basé sur Java avec Eclipse. Dans Eclipse IDE, accédez à File -> New -> Maven Project .

Fig. 4 :Créer un projet Maven

Dans la fenêtre Nouveau projet Maven, il vous sera demandé de sélectionner l'emplacement du projet. Par défaut, "Utiliser l'emplacement de l'espace de travail par défaut" sera sélectionné. Cochez la case "Créer un projet simple (ignorer la sélection de l'archétype)" et cliquez simplement sur le bouton suivant pour continuer.

Fig. 5 :Détails du projet

Il vous demandera de "Entrez le groupe et l'identifiant de l'artefact pour le projet". Nous entrerons les détails comme indiqué dans l'image ci-dessous. Le numéro de version sera par défaut :0.0.1-SNAPSHOT .

Fig. 6 :Paramètres de l'archétype

Cliquez sur Terminer et la création d'un projet maven est terminée. Si vous observez, il a téléchargé les dépendances maven et un pom.xml fichier sera créé. Il aura le code suivant :

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 http://maven.apache.org/xsd/maven-4.0.0.xsd">
	<modelVersion>4.0.0</modelVersion>
	<groupId>HibernateLoad</groupId>
	<artifactId>HibernateLoad </artifactId>
	<version>0.0.1-SNAPSHOT</version>
</project>

Nous pouvons commencer à ajouter les dépendances que les développeurs veulent comme Hibernate, MySQL, etc. Commençons à construire l'application !

3. Création d'applications

Voici les étapes impliquées dans le développement de cette application.

3.1 Création de bases de données et de tables

Le script MySQL suivant est utilisé pour créer une base de données appelée tutorialDb avec tableau :employee . Ouvrez le terminal MySQL ou le terminal Workbench et exécutez le SQL script.

CREATE DATABASE IF NOT EXISTS tutorialDb;

USE tutorialDb;

DROP TABLE IF EXISTS employee;

CREATE TABLE employee (
	emp_id INT(50) NOT NULL AUTO_INCREMENT, 
	emp_fname VARCHAR(200) DEFAULT NULL, 
	emp_lname VARCHAR(200) DEFAULT NULL,
	emp_age INT(50) DEFAULT NULL,
	emp_education VARCHAR(200) DEFAULT NULL,
	emp_salary INT(100) DEFAULT NULL, 
	PRIMARY KEY (emp_id)
);

INSERT INTO employee (emp_id, emp_fname, emp_lname, emp_age, emp_education, emp_salary) VALUES (1, 'Harry', 'Potter', 23, 'Bachelor Of Technology', 2500);

INSERT INTO employee (emp_id, emp_fname, emp_lname, emp_age, emp_education, emp_salary) VALUES (2, 'Java', 'Geek', 25, 'Master Of Technology', 6500);

INSERT INTO employee (emp_id, emp_fname, emp_lname, emp_age, emp_education, emp_salary) VALUES (3, 'Daniel', 'Atlas', 32, 'Business Administration', 4500);

Si tout se passe bien, le tableau sera affiché dans MySQL Workbench.

Fig. 7 : Création de la base de données et de la table

3.2 Dépendances Maven

Ici, nous ne spécifions que deux dépendances pour Hibernate Core et MySQL Connector. Les autres dépendances seront automatiquement résolues par Maven, comme Hibernate JPA et Hibernate Commons Annotations. Le mis à jour le fichier aura le code suivant :

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 http://maven.apache.org/xsd/maven-4.0.0.xsd">
	<modelVersion>4.0.0</modelVersion>
	<groupId>HibernateLoad</groupId>
	<artifactId>HibernateLoad</artifactId>
	<version>0.0.1-SNAPSHOT</version>
	<packaging>jar</packaging>
	<dependencies>
		<!-- Hibernate 4.3.6 Final -->
		<dependency>
			<groupId>org.hibernate</groupId>
			<artifactId>hibernate-core</artifactId>
			<version>4.3.6.Final</version>
		</dependency>
		<!-- Mysql Connector -->
		<dependency>
			<groupId>mysql</groupId>
			<artifactId>mysql-connector-java</artifactId>
			<version>5.1.21</version>
		</dependency>
	</dependencies>
	<build>
		<finalName>${project.artifactId}</finalName>
	</build>
</project>

3.3 Création de classes Java

Créons les fichiers Java requis. Faites un clic droit sur src/main/java dossier, New -> Package .

Fig. 8 : Création d'un package Java

Une nouvelle fenêtre contextuelle s'ouvrira dans laquelle nous saisirons le nom du package :com.jcg.hibernate.load .

Fig. 9 :nom du package Java (com.jcg.hibernate.load)

Une fois le package créé dans l'application, nous devrons créer le modèle et les classes d'implémentation. Faites un clic droit sur le package nouvellement créé :New -> Class .

Fig. 10 : Création d'une classe Java

Une nouvelle fenêtre contextuelle s'ouvrira et saisira le nom du fichier sous la forme :Employee . La classe de modèle sera créée dans le package :com.jcg.hibernate.load .

Fig. 11 :Classe Java (Employee.java)

Répétez l'étape (c'est-à-dire Fig. 10) et entrez le nom du fichier sous la forme :AppMain . La classe d'implémentation sera créée dans le package :com.jcg.hibernate.load .

Fig. 12 :Classe Java (AppMain.java)

3.3.1 Implémentation de la classe Model

Cette classe est utilisée pour mapper les attributs du modèle avec le SQL noms de colonnes. Ajoutez-y le code suivant :

Employé.java

package com.jcg.hibernate.load;

import javax.persistence.Column;
import javax.persistence.Entity;
import javax.persistence.GeneratedValue;
import javax.persistence.GenerationType;
import javax.persistence.Id;
import javax.persistence.Table;

@Entity
@Table(name="employee")
public class Employee {

	@Id
	@Column(name = "emp_id")
	@GeneratedValue(strategy = GenerationType.AUTO)
	private int employeeId;

	@Column(name = "emp_fname")
	private String firstName;

	@Column(name = "emp_lname")
	private String lastName;

	@Column(name = "emp_age")
	private int age;

	@Column(name = "emp_education")
	private String education;

	@Column(name = "emp_salary")
	private int salary;

	public int getEmployeeId() {
		return employeeId;
	}

	public void setEmployeeId(int employeeId) {
		this.employeeId = employeeId;
	}

	public String getFirstName() {
		return firstName;
	}

	public void setFirstName(String firstName) {
		this.firstName = firstName;
	}

	public String getLastName() {
		return lastName;
	}

	public void setLastName(String lastName) {
		this.lastName = lastName;
	}

	public int getAge() {
		return age;
	}

	public void setAge(int age) {
		this.age = age;
	}

	public String getEducation() {
		return education;
	}

	public void setEducation(String education) {
		this.education = education;
	}

	public int getSalary() {
		return salary;
	}

	public void setSalary(int salary) {
		this.salary = salary;
	}

	public String toString() {
		return "\nId: " + employeeId + ", Name: " + firstName + " " + lastName + ", Age: " + age + ", Education: " + education + ", Salary:" + salary + "$\n";
	}
}

3.3.2 Implémentation de la classe utilitaire

Cette classe aide à créer le SessionFactory objet du fichier de configuration Hibernate et interagit avec la base de données pour effectuer le SELECT opération. Ajoutez-y le code suivant :

AppMain.java

package com.jcg.hibernate.load;

import org.hibernate.Session;
import org.hibernate.SessionFactory;
import org.hibernate.boot.registry.StandardServiceRegistryBuilder;
import org.hibernate.cfg.Configuration;
import org.hibernate.service.ServiceRegistry;

public class AppMain {

	static Session sessionObj;
	static SessionFactory sessionFactoryObj;

	// This Method Is Used To Create The Hibernate's SessionFactory Object
	private static SessionFactory buildSessionFactory() {
		// Creating Configuration Instance & Passing Hibernate Configuration File
		Configuration configObj = new Configuration();
		configObj.configure("hibernate.cfg.xml");

		// Since Hibernate Version 4.x, ServiceRegistry Is Being Used
		ServiceRegistry serviceRegistryObj = new StandardServiceRegistryBuilder().applySettings(configObj.getProperties()).build(); 

		// Creating Hibernate SessionFactory Instance
		sessionFactoryObj = configObj.buildSessionFactory(serviceRegistryObj);
		return sessionFactoryObj;
	}

	// This Method Is Used To Display The Records From The Database Table (i.e. Assuming The Records Are Already Present In The Database Table)
	public static void displayRecords() {
		Employee empObj;

		// Opening The Hibernate's Session Object To Start The Database Transaction
		sessionObj = buildSessionFactory().openSession();

		// Load The Employee Details Whose Emp Id is '2'
		int emp_id1 =2;
		empObj = (Employee)sessionObj.load(Employee.class, new Integer(emp_id1));
		if(empObj != null) {
			System.out.println(empObj.toString());
		}

		// Load The Employee Details Whose Emp Id is '10'. This Will Throw The 'ObjectNotFoundException' As Record Doesn't Exist In The Database
		int emp_id2 = 10;
		empObj = (Employee)sessionObj.load(Employee.class, new Integer(emp_id2));
		if(empObj != null) {
			System.out.println(empObj.toString());
		}
	}

	public static void main(String[] args) {
		displayRecords();		
	}
}

3.4. Fichier de configuration d'hibernation

Pour configurer le framework Hibernate, nous devons implémenter un fichier de configuration, c'est-à-dire hiberncate.cfg.xml . Faites un clic droit sur src/main/resources dossier, New -> Other .

Fig. 13 : Création d'un fichier XML

Une nouvelle fenêtre contextuelle s'ouvrira et sélectionnera l'assistant en tant que XML dossier.

Fig. 14 :Sélection de l'assistant

Encore une fois, une fenêtre pop-up s'ouvrira. Vérifiez l'emplacement du dossier parent en tant que HibernateLoad/src/main/resources et saisissez le nom du fichier :hibernate.cfg.xml . Cliquez sur Terminer.

Fig. 15 :hibernate.cfg.xml

Une fois le fichier créé, nous inclurons la configuration de la base de données et les détails de la classe de mappage. Ajoutez-y le code suivant :

hibernate.cfg.xml

<?xml version='1.0' encoding='UTF-8'?>
<!DOCTYPE hibernate-configuration PUBLIC
        "-//Hibernate/Hibernate Configuration DTD 3.0//EN"
        "http://www.hibernate.org/dtd/hibernate-configuration-3.0.dtd">

<hibernate-configuration>
	<session-factory>
		<!-- SQL Dialect -->
		<property name="hibernate.dialect">org.hibernate.dialect.MySQLDialect</property>

		<!-- Database Connection Settings -->
		<property name="hibernate.connection.driver_class">com.mysql.jdbc.Driver</property>
		<property name="hibernate.connection.url">jdbc:mysql://localhost:3306/tutorialDb</property>
		<property name="hibernate.connection.username">root</property>
		<property name="hibernate.connection.password"></property>

		<!-- Echo All Executed SQL To Console -->
		<property name="show_sql">true</property>		

		<!-- Specifying Session Context -->
		<property name="hibernate.current_session_context_class">org.hibernate.context.internal.ThreadLocalSessionContext</property>

		<!-- Mapping With Model Class Containing Annotations -->
		<mapping class="com.jcg.hibernate.load.Employee" />
	</session-factory>
</hibernate-configuration>

Examinons quelques détails de base :

• Ici, nous avons demandé à Hibernate de se connecter à une base de données MySQL nommée tutorialDb et les Mapping classes à charger
• Nous avons également demandé au framework Hibernate d'utiliser MySQLDialect c'est-à-dire qu'Hibernate optimisera les instructions SQL générées pour MySQL
• Cette configuration sera utilisée pour créer un Hibernate SessionFactory objet
• show_sql la balise demandera au framework Hibernate de consigner tous les SQL déclarations sur la console

4. Exécutez l'application

Pour exécuter l'application Hibernate, faites un clic droit sur le AppMain classe -> Run As -> Java Application . Les développeurs peuvent déboguer l'exemple et voir ce qui se passe après chaque étape !

Fig. 16 :Exécuter l'application

5. Démo du projet

Le code affiche l'état suivant en sortie.

Fig. 17 :Opération Load()

C'est tout pour ce post. Bon apprentissage!!

6. Conclusion

Dans le code ci-dessus, nous avons utilisé le Session.load() méthode pour récupérer l'Employé avec l'id :2 . Hibernate a renvoyé l'entité de la base de données. Dans le cas de l'identifiant :10 , Hibernate a renvoyé ObjectNotFoundException car le dossier de l'employé n'est pas présent dans la base de données.

C'est tout pour le tutoriel Hibernate Load et j'espère que cet article vous a servi tout ce que vous cherchiez.

7. Télécharger le projet Eclipse

Ceci était un exemple de session Hibernate Load.hibernate JBoss Hibernate