Tutorial Hibernate pour débutants

Bienvenue dans le tutoriel Hibernate pour débutants. Hibernate est l’un des outils ORM Java les plus largement utilisés. La plupart des applications utilisent des bases de données relationnelles pour stocker les informations de l’application et au niveau bas, nous utilisons l’API JDBC pour se connecter aux bases de données et effectuer des opérations CRUD.

Tutoriel Hibernate pour débutants

Si vous regardez le code JDBC, il y a tellement de code de base et il y a des chances de fuites de ressources et d’incohérences de données car tout le travail doit être fait par le développeur. C’est là qu’un outil ORM est utile. La correspondance objet-relationnel ou ORM est la technique de programmation permettant de mapper les objets du modèle de domaine de l’application aux tables de base de données relationnelles. Hibernate est un outil ORM basé sur Java qui fournit un framework pour mapper les objets du domaine de l’application aux tables de base de données relationnelles et vice versa. Certains des avantages de l’utilisation de Hibernate comme outil ORM sont :

1. Hibernate prend en charge le mappage des classes Java vers les tables de base de données et vice versa. Il offre des fonctionnalités pour effectuer des opérations CRUD sur toutes les principales bases de données relationnelles.
2. Hibernate élimine tout le code redondant qui accompagne JDBC et prend en charge la gestion des ressources, nous permettant de nous concentrer sur les cas d’utilisation métier plutôt que de nous assurer que les opérations de base de données ne provoquent pas de fuites de ressources.
3. Hibernate prend en charge la gestion des transactions et veille à ce qu’il n’y ait pas de données incohérentes dans le système.
4. Étant donné que nous utilisons XML, des fichiers de propriétés ou des annotations pour mapper les classes Java aux tables de base de données, Hibernate fournit une couche d’abstraction entre l’application et la base de données.
5. Hibernate nous aide à mapper des jointures, des collections, des objets d’héritage et nous permet de visualiser facilement comment nos classes de modèle représentent les tables de la base de données.
6. Hibernate fournit un puissant langage de requête (HQL) similaire à SQL. Cependant, HQL est entièrement orienté objet et comprend des concepts tels que l’héritage, le polymorphisme et l’association.
7. Hibernate offre également une intégration avec certains modules externes. Par exemple, Hibernate Validator est l’implémentation de référence de la validation des beans (JSR 303).
8. Hibernate est un projet open source de la communauté Red Hat et est utilisé dans le monde entier. Cela en fait un meilleur choix que les autres car la courbe d’apprentissage est faible et il existe de nombreuses documentations en ligne et une aide facilement disponible dans les forums.
9. Hibernate est facile à intégrer avec d’autres frameworks Java EE, il est si populaire que Spring Framework offre une prise en charge intégrée de l’intégration de Hibernate avec les applications Spring.

I hope all the above benefits will convince you that Hibernate is the best choice for your application object-relational mapping requirements. Let’s look at the Hibernate Framework architecture now and then we will jump into sample project where we will look into different ways to configure Hibernate in standalone java application and use it.

Architecture Hibernate

L’image ci-dessous montre l’architecture Hibernate et comment elle fonctionne comme une couche d’abstraction entre les classes d’application et les API JDBC/JTA pour les opérations de base de données. Il est clair que Hibernate est construit au-dessus des API JDBC et JTA. Examinons les composants principaux de l’architecture Hibernate un par un.

• SessionFactory (org.hibernate.SessionFactory) : SessionFactory est un cache immuable thread-safe de mappages compilés pour une seule base de données. Nous pouvons obtenir une instance de org.hibernate.Session en utilisant SessionFactory.
• Session (org.hibernate.Session) : Session est un objet éphémère, mono-thread, représentant une conversation entre l’application et le magasin persistant. Il enveloppe java.sql.Connection JDBC et fonctionne comme une usine pour org.hibernate.Transaction.
• Objets persistants : Les objets persistants sont des objets éphémères, mono-thread, qui contiennent un état persistant et une fonction d’entreprise. Ceux-ci peuvent être de simples JavaBeans/POJOs. Ils sont associés à exactement une org.hibernate.Session.
• Objets transitoires: Les objets transitoires sont des instances de classes persistantes qui ne sont actuellement associées à aucune org.hibernate.Session. Ils peuvent avoir été instanciés par l’application et ne pas encore être persistés, ou ils peuvent avoir été instanciés par une org.hibernate.Session fermée.
• Transaction (org.hibernate.Transaction): Une transaction est un objet à durée de vie courte et monoprocessus utilisé par l’application pour spécifier des unités de travail atomiques. Elle abstrait l’application de la transaction sous-jacente JDBC ou JTA. Une org.hibernate.Session peut parfois englober plusieurs org.hibernate.Transaction.
• ConnectionProvider (org.hibernate.connection.ConnectionProvider): ConnectionProvider est une fabrique de connexions JDBC. Il fournit une abstraction entre l’application et la javax.sql.DataSource ou java.sql.DriverManager sous-jacente. Il n’est pas exposé à l’application, mais peut être étendu par le développeur.
• TransactionFactory (org.hibernate.TransactionFactory): Une fabrique d’instances de org.hibernate.Transaction.

Hibernate et Java Persistence API (JPA)

Hibernate fournit une implémentation de l’API Java Persistence, nous pouvons donc utiliser des annotations JPA avec les beans de modèle et Hibernate se chargera de les configurer pour les opérations CRUD. Nous allons examiner cela avec un exemple d’annotations.

Exemple Hibernate

Lors du développement d’applications Hibernate, nous devons fournir deux ensembles de configurations. Le premier ensemble de configurations contient des propriétés spécifiques à la base de données qui seront utilisées pour créer des connexions et des objets de session. Le deuxième ensemble de configurations contient la correspondance entre les classes de modèle et les tables de base de données. Nous pouvons utiliser une configuration basée sur XML ou basée sur des propriétés pour les configurations relatives à la connexion à la base de données. Nous pouvons utiliser une configuration basée sur XML ou des annotations pour fournir des classes de modèle et une correspondance avec les tables de base de données. Nous utiliserons les annotations JPA de javax.persistence pour les mappages basés sur les annotations. Notre projet final ressemblera à l’image ci-dessous. Créez un projet Maven dans Eclipse ou votre IDE préféré, vous pouvez lui donner n’importe quel nom de votre choix. Avant de passer aux différents composants du projet, nous devrons configurer la base de données.

Configuration de la table de base de données

Pour mon exemple, j’utilise la base de données MySQL et le script ci-dessous est utilisé pour créer la table nécessaire.

CREATE TABLE `Employee` (
  `id` int(11) unsigned NOT NULL AUTO_INCREMENT,
  `name` varchar(20) DEFAULT NULL,
  `role` varchar(20) DEFAULT NULL,
  `insert_time` datetime DEFAULT NULL,
  PRIMARY KEY (`id`)
) ENGINE=InnoDB AUTO_INCREMENT=19 DEFAULT CHARSET=utf8;

Remarquez que la colonne « id » de la table Employee est automatiquement générée par MySQL, donc nous n’avons pas besoin de l’insérer.

Dépendances du projet Hibernate

Notre fichier pom.xml final ressemble à ce qui suit.

<project xmlns="https://maven.apache.org/POM/4.0.0" xmlns:xsi="https://www.w3.org/2001/XMLSchema-instance" xsi:schemaLocation="https://maven.apache.org/POM/4.0.0 https://maven.apache.org/xsd/maven-4.0.0.xsd">
  <modelVersion>4.0.0</modelVersion>
  <groupId>com.journaldev.hibernate</groupId>
  <artifactId>HibernateExample</artifactId>
  <version>0.0.1-SNAPSHOT</version>
  <name>HibernateExample</name>
  
  <dependencies>
  	<dependency>
  		<groupId>org.hibernate</groupId>
  		<artifactId>hibernate-core</artifactId>
  		<version>4.3.5.Final</version>
  	</dependency>
  	<!-- Hibernate 4 uses Jboss logging, but older versions slf4j for logging -->
        <dependency>
            <groupId>org.slf4j</groupId>
            <artifactId>slf4j-simple</artifactId>
            <version>1.7.5</version>
        </dependency>
        <dependency>
        	<groupId>mysql</groupId>
        	<artifactId>mysql-connector-java</artifactId>
        	<version>5.0.5</version>
        </dependency>
  </dependencies>
  
  <build>
  	<finalName>${project.artifactId}</finalName>
  </build>
</project>

L’artefact hibernate-core contient toutes les classes principales d’Hibernate, donc nous obtiendrons toutes les fonctionnalités nécessaires en l’incluant dans le projet. Notez que j’utilise la dernière version d’Hibernate (4.3.5.Final) pour mon projet d’exemple et qu’Hibernate est encore en évolution et j’ai constaté que de nombreuses classes principales changent entre chaque version majeure. Donc, si vous utilisez une autre version, il y a une petite chance que vous deviez modifier les configurations Hibernate pour que cela fonctionne. Cependant, je suis sûr que cela fonctionnera bien pour toutes les versions 4.x.x. Hibernate 4 utilise le journal de bord de JBoss, mais les anciennes versions utilisent slf4j à des fins de journalisation, donc j’ai inclus l’artefact slf4j-simple dans mon projet, bien que cela ne soit pas nécessaire car j’utilise Hibernate 4. mysql-connector-java est le pilote MySQL pour se connecter aux bases de données MySQL, si vous utilisez une autre base de données, ajoutez alors l’artefact du pilote correspondant.

Classes du Modèle de Domaine

Comme vous pouvez le voir dans l’image ci-dessus, nous avons deux classes de modèle, Employee et Employee1. Employee est une classe Java Bean simple et nous utiliserons une configuration basée sur XML pour fournir les détails de mappage. Employee1 est une classe Java Bean où les champs sont annotés avec des annotations JPA, de sorte que nous n’avons pas besoin de fournir de mappage dans un fichier XML séparé.

package com.journaldev.hibernate.model;

import java.util.Date;

public class Employee {

	private int id;
	private String name;
	private String role;
	private Date insertTime;
	
	public int getId() {
		return id;
	}
	public void setId(int id) {
		this.id = id;
	}
	public String getName() {
		return name;
	}
	public void setName(String name) {
		this.name = name;
	}
	public String getRole() {
		return role;
	}
	public void setRole(String role) {
		this.role = role;
	}
	public Date getInsertTime() {
		return insertTime;
	}
	public void setInsertTime(Date insertTime) {
		this.insertTime = insertTime;
	}
	
}

La classe Employee est une classe Java Bean simple, il n’y a rien de spécifique à discuter ici.

package com.journaldev.hibernate.model;

import java.util.Date;

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

@Entity
@Table(name="Employee", 
	   uniqueConstraints={@UniqueConstraint(columnNames={"ID"})})
public class Employee1 {

	@Id
	@GeneratedValue(strategy=GenerationType.IDENTITY)
	@Column(name="ID", nullable=false, unique=true, length=11)
	private int id;
	
	@Column(name="NAME", length=20, nullable=true)
	private String name;
	
	@Column(name="ROLE", length=20, nullable=true)
	private String role;
	
	@Column(name="insert_time", nullable=true)
	private Date insertTime;
	
	public int getId() {
		return id;
	}
	public void setId(int id) {
		this.id = id;
	}
	public String getName() {
		return name;
	}
	public void setName(String name) {
		this.name = name;
	}
	public String getRole() {
		return role;
	}
	public void setRole(String role) {
		this.role = role;
	}
	public Date getInsertTime() {
		return insertTime;
	}
	public void setInsertTime(Date insertTime) {
		this.insertTime = insertTime;
	}
}

L’annotation javax.persistence.Entity est utilisée pour marquer une classe comme bean Entity qui peut être persisté par Hibernate, car Hibernate fournit une implémentation JPA. L’annotation javax.persistence.Table est utilisée pour définir le mappage de table et les contraintes uniques pour les colonnes. L’annotation javax.persistence.Id est utilisée pour définir la clé primaire de la table. javax.persistence.GeneratedValue est utilisé pour définir que le champ sera auto-généré et la stratégie GenerationType.IDENTITY est utilisée pour que la valeur « id » générée soit associée au bean et puisse être récupérée dans le programme Java. javax.persistence.Column est utilisé pour mapper le champ avec la colonne de la table, nous pouvons également spécifier la longueur, la possibilité de null et l’unicité pour les propriétés du bean.

Configuration XML de Mappage Hibernate

Comme indiqué ci-dessus, nous utiliserons une configuration basée sur XML pour le mappage de la classe Employee. Nous pouvons choisir n’importe quel nom, mais il est bon de choisir un nom en rapport avec la table ou la classe Java pour plus de clarté. Notre fichier de mappage Hibernate pour la classe Employee ressemble à ce qui suit. employee.hbm.xml

<?xml version="1.0"?>
<!DOCTYPE hibernate-mapping PUBLIC "-//Hibernate/Hibernate Mapping DTD 3.0//EN"
"https://hibernate.org/dtd/hibernate-mapping-3.0.dtd">

<hibernate-mapping>
	<class name="com.journaldev.hibernate.model.Employee" table="EMPLOYEE">
        <id name="id" type="int">
            <column name="ID" />
            <generator class="increment" />
        </id>
        <property name="name" type="java.lang.String">
            <column name="NAME" />
        </property>
        <property name="role" type="java.lang.String">
            <column name="ROLE" />
        </property>
        <property name="insertTime" type="timestamp">
        	<column name="insert_time" />
        </property>
    </class>
</hibernate-mapping>

La configuration XML est simple et fait la même chose que la configuration basée sur les annotations.

Fichiers de Configuration Hibernate

Nous allons créer deux fichiers de configuration XML Hibernate – l’un pour la configuration basée sur XML et l’autre pour la configuration basée sur les annotations. hibernate.cfg.xml

<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE hibernate-configuration PUBLIC
		"-//Hibernate/Hibernate Configuration DTD 3.0//EN"
		"https://hibernate.org/dtd/hibernate-configuration-3.0.dtd">
<hibernate-configuration>
	<session-factory>
		<!-- Database connection properties - Driver, URL, user, password -->
		<property name="hibernate.connection.driver_class">com.mysql.jdbc.Driver</property>
		<property name="hibernate.connection.url">jdbc:mysql://localhost/TestDB</property>
		<property name="hibernate.connection.username">pankaj</property>
		<property name="hibernate.connection.password">pankaj123</property>
		<!-- Connection Pool Size -->
		<property name="hibernate.connection.pool_size">1</property>
		
		<!-- org.hibernate.HibernateException: No CurrentSessionContext configured! -->
		<property name="hibernate.current_session_context_class">thread</property>
		
		<!-- Outputs the SQL queries, should be disabled in Production -->
		<property name="hibernate.show_sql">true</property>
		
		<!-- Dialect is required to let Hibernate know the Database Type, MySQL, Oracle etc
			Hibernate 4 automatically figure out Dialect from Database Connection Metadata -->
		<property name="hibernate.dialect">org.hibernate.dialect.MySQLDialect</property> 

		<!-- mapping file, we can use Bean annotations too --> 
		<mapping resource="employee.hbm.xml" />
	</session-factory>
</hibernate-configuration>

La plupart des propriétés sont liées à la configuration de la base de données, les détails des autres propriétés sont donnés en commentaire. Notez la configuration du fichier de mappage Hibernate, nous pouvons définir plusieurs fichiers de mappage Hibernate et les configurer ici. Notez également que le mappage est spécifique à la session factory. hibernate-annotation.cfg.xml

<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE hibernate-configuration PUBLIC
		"-//Hibernate/Hibernate Configuration DTD 3.0//EN"
		"https://hibernate.org/dtd/hibernate-configuration-3.0.dtd">
<hibernate-configuration>
	<session-factory>
		<!-- Database connection properties - Driver, URL, user, password -->
		<property name="hibernate.connection.driver_class">com.mysql.jdbc.Driver</property>
		<property name="hibernate.connection.url">jdbc:mysql://localhost/TestDB</property>
		<property name="hibernate.connection.username">pankaj</property>
		<property name="hibernate.connection.password">pankaj123</property>
		
		<!-- org.hibernate.HibernateException: No CurrentSessionContext configured! -->
		<property name="hibernate.current_session_context_class">thread</property>
		
		<!-- Mapping with model class containing annotations -->
		<mapping class="com.journaldev.hibernate.model.Employee1"/>
	</session-factory>
</hibernate-configuration>

La plupart de la configuration est la même que la configuration basée sur XML, la seule différence est la configuration du mappage. Nous pouvons fournir une configuration de mappage pour les classes ainsi que pour les packages.

SessionFactory Hibernate

I have created a utility class where I am creating SessionFactory from XML based configuration as well as property based configuration. For property based configuration, we could have a property file and read it in the class, but for simplicity I am creating Properties instance in the class itself.

package com.journaldev.hibernate.util;

import java.util.Properties;

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

import com.journaldev.hibernate.model.Employee1;

public class HibernateUtil {

	//Configuration basée sur XML
	private static SessionFactory sessionFactory;
	
	//Configuration basée sur les annotations
	private static SessionFactory sessionAnnotationFactory;
	
	//Configuration basée sur les propriétés
	private static SessionFactory sessionJavaConfigFactory;

    private static SessionFactory buildSessionFactory() {
        try {
            // Créer la SessionFactory à partir de hibernate.cfg.xml
        	Configuration configuration = new Configuration();
        	configuration.configure("hibernate.cfg.xml");
        	System.out.println("Hibernate Configuration loaded");
        	
        	ServiceRegistry serviceRegistry = new StandardServiceRegistryBuilder().applySettings(configuration.getProperties()).build();
        	System.out.println("Hibernate serviceRegistry created");
        	
        	SessionFactory sessionFactory = configuration.buildSessionFactory(serviceRegistry);
        	
            return sessionFactory;
        }
        catch (Throwable ex) {
            // Assurez-vous de journaliser l'exception, car elle pourrait être ignorée
            System.err.println("Initial SessionFactory creation failed." + ex);
            throw new ExceptionInInitializerError(ex);
        }
    }

    private static SessionFactory buildSessionAnnotationFactory() {
    	try {
            // Créer la SessionFactory à partir de hibernate.cfg.xml
        	Configuration configuration = new Configuration();
        	configuration.configure("hibernate-annotation.cfg.xml");
        	System.out.println("Hibernate Annotation Configuration loaded");
        	
        	ServiceRegistry serviceRegistry = new StandardServiceRegistryBuilder().applySettings(configuration.getProperties()).build();
        	System.out.println("Hibernate Annotation serviceRegistry created");
        	
        	SessionFactory sessionFactory = configuration.buildSessionFactory(serviceRegistry);
        	
            return sessionFactory;
        }
        catch (Throwable ex) {
            // Assurez-vous de journaliser l'exception, car elle pourrait être ignorée
            System.err.println("Initial SessionFactory creation failed." + ex);
            throw new ExceptionInInitializerError(ex);
        }
	}

    private static SessionFactory buildSessionJavaConfigFactory() {
    	try {
    	Configuration configuration = new Configuration();
		
		//Créer des propriétés, qui peuvent également être lues à partir de fichiers de propriétés
		Properties props = new Properties();
		props.put("hibernate.connection.driver_class", "com.mysql.jdbc.Driver");
		props.put("hibernate.connection.url", "jdbc:mysql://localhost/TestDB");
		props.put("hibernate.connection.username", "pankaj");
		props.put("hibernate.connection.password", "pankaj123");
		props.put("hibernate.current_session_context_class", "thread");
		
		configuration.setProperties(props);
		
		//Nous pouvons définir un fichier de mappage ou une classe avec des annotations
		//addClass(Employee1.class) cherchera la ressource
		// com/journaldev/hibernate/model/Employee1.hbm.xml (pas bon)
		configuration.addAnnotatedClass(Employee1.class);
		
		ServiceRegistry serviceRegistry = new StandardServiceRegistryBuilder().applySettings(configuration.getProperties()).build();
    	System.out.println("Hibernate Java Config serviceRegistry created");
    	
    	SessionFactory sessionFactory = configuration.buildSessionFactory(serviceRegistry);
    	
        return sessionFactory;
    	}
        catch (Throwable ex) {
            System.err.println("Initial SessionFactory creation failed." + ex);
            throw new ExceptionInInitializerError(ex);
        }
	}
    
	public static SessionFactory getSessionFactory() {
		if(sessionFactory == null) sessionFactory = buildSessionFactory();
        return sessionFactory;
    }
	
	public static SessionFactory getSessionAnnotationFactory() {
		if(sessionAnnotationFactory == null) sessionAnnotationFactory = buildSessionAnnotationFactory();
        return sessionAnnotationFactory;
    }
	
	public static SessionFactory getSessionJavaConfigFactory() {
		if(sessionJavaConfigFactory == null) sessionJavaConfigFactory = buildSessionJavaConfigFactory();
        return sessionJavaConfigFactory;
    }
	
}

La création de SessionFactory pour une configuration basée sur XML est la même que la configuration soit basée sur XML ou sur les annotations. Pour une configuration basée sur les propriétés, nous devons définir les propriétés dans l’objet Configuration et ajouter les classes d’annotations avant de créer la SessionFactory. Globalement, la création de SessionFactory comprend les étapes suivantes:

1. Création de l’objet Configuration et configuration
2. Création de l’objet ServiceRegistry et application des paramètres de configuration.
3. Utiliser configuration.buildSessionFactory() en passant l’objet ServiceRegistry en argument pour obtenir l’objet SessionFactory.

Notre application est presque prête maintenant, écrivons quelques programmes de test et exécutons-les.

Test de configuration XML Hibernate

Notre programme de test ressemble à ceci.

package com.journaldev.hibernate.main;

import java.util.Date;

import org.hibernate.Session;

import com.journaldev.hibernate.model.Employee;
import com.journaldev.hibernate.util.HibernateUtil;

public class HibernateMain {

	public static void main(String[] args) {
		Employee emp = new Employee();
		emp.setName("Pankaj");
		emp.setRole("CEO");
		emp.setInsertTime(new Date());
		
		// Obtenir la session
		Session session = HibernateUtil.getSessionFactory().getCurrentSession();
		// démarrer la transaction
		session.beginTransaction();
		// Enregistrer l'objet modèle
		session.save(emp);
		// Valider la transaction
		session.getTransaction().commit();
		System.out.println("Employee ID="+emp.getId());
		
		// Terminer la fabrique de sessions, sinon le programme ne se terminera pas
		HibernateUtil.getSessionFactory().close();
	}

}

Le programme est auto-explicatif, lorsque nous exécutons le programme de test, nous obtenons la sortie suivante.

May 06, 2014 12:40:06 AM org.hibernate.annotations.common.reflection.java.JavaReflectionManager <clinit>
INFO: HCANN000001: Hibernate Commons Annotations {4.0.4.Final}
May 06, 2014 12:40:06 AM org.hibernate.Version logVersion
INFO: HHH000412: Hibernate Core {4.3.5.Final}
May 06, 2014 12:40:06 AM org.hibernate.cfg.Environment <clinit>
INFO: HHH000206: hibernate.properties not found
May 06, 2014 12:40:06 AM org.hibernate.cfg.Environment buildBytecodeProvider
INFO: HHH000021: Bytecode provider name : javassist
May 06, 2014 12:40:06 AM org.hibernate.cfg.Configuration configure
INFO: HHH000043: Configuring from resource: hibernate.cfg.xml
May 06, 2014 12:40:06 AM org.hibernate.cfg.Configuration getConfigurationInputStream
INFO: HHH000040: Configuration resource: hibernate.cfg.xml
May 06, 2014 12:40:07 AM org.hibernate.cfg.Configuration addResource
INFO: HHH000221: Reading mappings from resource: employee.hbm.xml
May 06, 2014 12:40:08 AM org.hibernate.cfg.Configuration doConfigure
INFO: HHH000041: Configured SessionFactory: null
Hibernate Configuration loaded
Hibernate serviceRegistry created
May 06, 2014 12:40:08 AM org.hibernate.engine.jdbc.connections.internal.DriverManagerConnectionProviderImpl configure
WARN: HHH000402: Using Hibernate built-in connection pool (not for production use!)
May 06, 2014 12:40:08 AM org.hibernate.engine.jdbc.connections.internal.DriverManagerConnectionProviderImpl buildCreator
INFO: HHH000401: using driver [com.mysql.jdbc.Driver] at URL [jdbc:mysql://localhost/TestDB]
May 06, 2014 12:40:08 AM org.hibernate.engine.jdbc.connections.internal.DriverManagerConnectionProviderImpl buildCreator
INFO: HHH000046: Connection properties: {user=pankaj, password=****}
May 06, 2014 12:40:08 AM org.hibernate.engine.jdbc.connections.internal.DriverManagerConnectionProviderImpl buildCreator
INFO: HHH000006: Autocommit mode: false
May 06, 2014 12:40:08 AM org.hibernate.engine.jdbc.connections.internal.DriverManagerConnectionProviderImpl configure
INFO: HHH000115: Hibernate connection pool size: 1 (min=1)
May 06, 2014 12:40:08 AM org.hibernate.dialect.Dialect <init>
INFO: HHH000400: Using dialect: org.hibernate.dialect.MySQLDialect
May 06, 2014 12:40:08 AM org.hibernate.engine.jdbc.internal.LobCreatorBuilder useContextualLobCreation
INFO: HHH000423: Disabling contextual LOB creation as JDBC driver reported JDBC version [3] less than 4
May 06, 2014 12:40:08 AM org.hibernate.engine.transaction.internal.TransactionFactoryInitiator initiateService
INFO: HHH000399: Using default transaction strategy (direct JDBC transactions)
May 06, 2014 12:40:08 AM org.hibernate.hql.internal.ast.ASTQueryTranslatorFactory <init>
INFO: HHH000397: Using ASTQueryTranslatorFactory
Hibernate: select max(ID) from EMPLOYEE
Hibernate: insert into EMPLOYEE (NAME, ROLE, insert_time, ID) values (?, ?, ?, ?)
Employee ID=19
May 06, 2014 12:40:08 AM org.hibernate.engine.jdbc.connections.internal.DriverManagerConnectionProviderImpl stop
INFO: HHH000030: Cleaning up connection pool [jdbc:mysql://localhost/TestDB]

Remarquez qu’il imprime l’identifiant d’employé généré, vous pouvez vérifier la table de la base de données pour le confirmer.

Test de configuration d’annotation Hibernate

package com.journaldev.hibernate.main;

import java.util.Date;

import org.hibernate.Session;
import org.hibernate.SessionFactory;

import com.journaldev.hibernate.model.Employee1;
import com.journaldev.hibernate.util.HibernateUtil;

public class HibernateAnnotationMain {

	public static void main(String[] args) {
		Employee1 emp = new Employee1();
		emp.setName("David");
		emp.setRole("Developer");
		emp.setInsertTime(new Date());
		
		// Obtenir la session
		SessionFactory sessionFactory = HibernateUtil.getSessionAnnotationFactory();
		Session session = sessionFactory.getCurrentSession();
		// démarrer la transaction
		session.beginTransaction();
		// Enregistrer l'objet modèle
		session.save(emp);
		// Valider la transaction
		session.getTransaction().commit();
		System.out.println("Employee ID="+emp.getId());
		
		// Terminer la fabrique de sessions, sinon le programme ne se terminera pas
		sessionFactory.close();
	}

}

Lorsque nous exécutons le programme ci-dessus, nous obtenons la sortie suivante.

May 06, 2014 12:42:22 AM org.hibernate.annotations.common.reflection.java.JavaReflectionManager <clinit>
INFO: HCANN000001: Hibernate Commons Annotations {4.0.4.Final}
May 06, 2014 12:42:22 AM org.hibernate.Version logVersion
INFO: HHH000412: Hibernate Core {4.3.5.Final}
May 06, 2014 12:42:22 AM org.hibernate.cfg.Environment <clinit>
INFO: HHH000206: hibernate.properties not found
May 06, 2014 12:42:22 AM org.hibernate.cfg.Environment buildBytecodeProvider
INFO: HHH000021: Bytecode provider name : javassist
May 06, 2014 12:42:22 AM org.hibernate.cfg.Configuration configure
INFO: HHH000043: Configuring from resource: hibernate-annotation.cfg.xml
May 06, 2014 12:42:22 AM org.hibernate.cfg.Configuration getConfigurationInputStream
INFO: HHH000040: Configuration resource: hibernate-annotation.cfg.xml
May 06, 2014 12:42:23 AM org.hibernate.cfg.Configuration doConfigure
INFO: HHH000041: Configured SessionFactory: null
Hibernate Annotation Configuration loaded
Hibernate Annotation serviceRegistry created
May 06, 2014 12:42:23 AM org.hibernate.engine.jdbc.connections.internal.DriverManagerConnectionProviderImpl configure
WARN: HHH000402: Using Hibernate built-in connection pool (not for production use!)
May 06, 2014 12:42:23 AM org.hibernate.engine.jdbc.connections.internal.DriverManagerConnectionProviderImpl buildCreator
INFO: HHH000401: using driver [com.mysql.jdbc.Driver] at URL [jdbc:mysql://localhost/TestDB]
May 06, 2014 12:42:23 AM org.hibernate.engine.jdbc.connections.internal.DriverManagerConnectionProviderImpl buildCreator
INFO: HHH000046: Connection properties: {user=pankaj, password=****}
May 06, 2014 12:42:23 AM org.hibernate.engine.jdbc.connections.internal.DriverManagerConnectionProviderImpl buildCreator
INFO: HHH000006: Autocommit mode: false
May 06, 2014 12:42:23 AM org.hibernate.engine.jdbc.connections.internal.DriverManagerConnectionProviderImpl configure
INFO: HHH000115: Hibernate connection pool size: 20 (min=1)
May 06, 2014 12:42:23 AM org.hibernate.dialect.Dialect <init>
INFO: HHH000400: Using dialect: org.hibernate.dialect.MySQL5Dialect
May 06, 2014 12:42:23 AM org.hibernate.engine.jdbc.internal.LobCreatorBuilder useContextualLobCreation
INFO: HHH000423: Disabling contextual LOB creation as JDBC driver reported JDBC version [3] less than 4
May 06, 2014 12:42:23 AM org.hibernate.engine.transaction.internal.TransactionFactoryInitiator initiateService
INFO: HHH000399: Using default transaction strategy (direct JDBC transactions)
May 06, 2014 12:42:23 AM org.hibernate.hql.internal.ast.ASTQueryTranslatorFactory <init>
INFO: HHH000397: Using ASTQueryTranslatorFactory
Employee ID=20
May 06, 2014 12:42:23 AM org.hibernate.engine.jdbc.connections.internal.DriverManagerConnectionProviderImpl stop
INFO: HHH000030: Cleaning up connection pool [jdbc:mysql://localhost/TestDB]

Jetez un œil à la sortie et comparez-la avec la configuration basée sur XML, vous remarquerez quelques différences. Par exemple, nous ne définissons pas la taille du pool de connexions pour la configuration basée sur les annotations, elle est donc réglée sur la valeur par défaut 20.

Test de configuration Hibernate Java

package com.journaldev.hibernate.main;

import java.util.Date;

import org.hibernate.Session;
import org.hibernate.SessionFactory;

import com.journaldev.hibernate.model.Employee1;
import com.journaldev.hibernate.util.HibernateUtil;

public class HibernateJavaConfigMain {

	public static void main(String[] args) {
		Employee1 emp = new Employee1();
		emp.setName("Lisa");
		emp.setRole("Manager");
		emp.setInsertTime(new Date());
		
		// Obtenir la session
		SessionFactory sessionFactory = HibernateUtil.getSessionJavaConfigFactory();
		Session session = sessionFactory.getCurrentSession();
		// Démarrer la transaction
		session.beginTransaction();
		// Enregistrer l'objet modèle
		session.save(emp);
		// Valider la transaction
		session.getTransaction().commit();
		System.out.println("Employee ID="+emp.getId());
		
		// Fermer la session factory, sinon le programme ne se terminera pas
		sessionFactory.close();
	}

}

La sortie du programme de test ci-dessus est :

May 06, 2014 12:45:09 AM org.hibernate.annotations.common.reflection.java.JavaReflectionManager <clinit>
INFO: HCANN000001: Hibernate Commons Annotations {4.0.4.Final}
May 06, 2014 12:45:09 AM org.hibernate.Version logVersion
INFO: HHH000412: Hibernate Core {4.3.5.Final}
May 06, 2014 12:45:09 AM org.hibernate.cfg.Environment <clinit>
INFO: HHH000206: hibernate.properties not found
May 06, 2014 12:45:09 AM org.hibernate.cfg.Environment buildBytecodeProvider
INFO: HHH000021: Bytecode provider name : javassist
Hibernate Java Config serviceRegistry created
May 06, 2014 12:45:09 AM org.hibernate.engine.jdbc.connections.internal.DriverManagerConnectionProviderImpl configure
WARN: HHH000402: Using Hibernate built-in connection pool (not for production use!)
May 06, 2014 12:45:09 AM org.hibernate.engine.jdbc.connections.internal.DriverManagerConnectionProviderImpl buildCreator
INFO: HHH000401: using driver [com.mysql.jdbc.Driver] at URL [jdbc:mysql://localhost/TestDB]
May 06, 2014 12:45:09 AM org.hibernate.engine.jdbc.connections.internal.DriverManagerConnectionProviderImpl buildCreator
INFO: HHH000046: Connection properties: {user=pankaj, password=****}
May 06, 2014 12:45:09 AM org.hibernate.engine.jdbc.connections.internal.DriverManagerConnectionProviderImpl buildCreator
INFO: HHH000006: Autocommit mode: false
May 06, 2014 12:45:09 AM org.hibernate.engine.jdbc.connections.internal.DriverManagerConnectionProviderImpl configure
INFO: HHH000115: Hibernate connection pool size: 20 (min=1)
May 06, 2014 12:45:10 AM org.hibernate.dialect.Dialect <init>
INFO: HHH000400: Using dialect: org.hibernate.dialect.MySQL5Dialect
May 06, 2014 12:45:10 AM org.hibernate.engine.jdbc.internal.LobCreatorBuilder useContextualLobCreation
INFO: HHH000423: Disabling contextual LOB creation as JDBC driver reported JDBC version [3] less than 4
May 06, 2014 12:45:10 AM org.hibernate.engine.transaction.internal.TransactionFactoryInitiator initiateService
INFO: HHH000399: Using default transaction strategy (direct JDBC transactions)
May 06, 2014 12:45:10 AM org.hibernate.hql.internal.ast.ASTQueryTranslatorFactory <init>
INFO: HHH000397: Using ASTQueryTranslatorFactory
Employee ID=21
May 06, 2014 12:45:10 AM org.hibernate.engine.jdbc.connections.internal.DriverManagerConnectionProviderImpl stop
INFO: HHH000030: Cleaning up connection pool [jdbc:mysql://localhost/TestDB]

C’est tout pour le tutoriel Hibernate pour les débutants, j’espère que cela sera suffisant pour vous lancer. Nous explorerons différentes fonctionnalités du framework Hibernate dans des tutoriels futurs. Téléchargez le projet complet via le lien ci-dessous et explorez-le pour en apprendre davantage.

Télécharger le projet Hibernate pour débutants