Hibernate Tutorial voor beginners

Handleidingen
Hibernate

Welkom bij de Hibernate tutorial voor beginners. Hibernate is een van de meest gebruikte Java ORM tools. De meeste applicaties gebruiken relationele databases om applicatie-informatie op te slaan en op een laag niveau gebruiken we JDBC API voor het verbinden met databases en het uitvoeren van CRUD-operaties.

Hibernate Tutorial voor Beginners

Als je naar de JDBC-code kijkt, is er zoveel boilerplate-code en er zijn kansen op lekkage van bronnen en inconsistentie van gegevens omdat al het werk door de ontwikkelaar moet worden gedaan. Dit is waar een ORM-tool handig is. Object-relationele mapping of ORM is de programmeertechniek om applicatie-domeinmodel-objecten naar de relationele databasetabellen te mappen. Hibernate is een op java gebaseerde ORM-tool die een raamwerk biedt voor het mappen van applicatie-domeinmodel-objecten naar de relationele databasetabellen en vice versa. Enkele van de voordelen van het gebruik van Hibernate als ORM-tool zijn:

  1. Hibernate ondersteunt het mappen van java-klassen naar databasetabellen en vice versa. Het biedt functies om CRUD-operaties uit te voeren over alle belangrijke relationele databases.
  2. Hibernate elimineert alle standaardcode die bij JDBC wordt geleverd en zorgt voor het beheren van resources, zodat we ons kunnen richten op zakelijke use cases in plaats van ervoor te zorgen dat databasebewerkingen geen resourcelekken veroorzaken.
  3. Hibernate ondersteunt transactiebeheer en zorgt ervoor dat er geen inconsistente gegevens in het systeem aanwezig zijn.
  4. Doordat we XML, eigenschappenbestanden of annotaties gebruiken voor het toewijzen van Java-klassen aan database tabellen, biedt het een abstractielaag tussen de applicatie en de database.
  5. Hibernate helpt ons bij het toewijzen van joins, collecties, overerving objecten en we kunnen gemakkelijk visualiseren hoe onze modelklassen database tabellen vertegenwoordigen.
  6. Hibernate biedt een krachtige querytaal (HQL) die vergelijkbaar is met SQL. HQL is echter volledig objectgeoriënteerd en begrijpt concepten zoals overerving, polymorfisme en associatie.
  7. Hibernate biedt ook integratie met enkele externe modules. Bijvoorbeeld Hibernate Validator is de referentie-implementatie van Bean Validation (JSR 303).
  8. Hibernate is een open source project van de Red Hat Community en wordt wereldwijd gebruikt. Dit maakt het een betere keuze dan anderen omdat de leercurve klein is en er tal van online documentatie beschikbaar is en hulp gemakkelijk beschikbaar is in forums.
  9. Hibernate is eenvoudig te integreren met andere Java EE-frameworks, het is zo populair dat Spring Framework ingebouwde ondersteuning biedt voor integratie van hibernate met Spring-applicaties.

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.

Hibernate Architectuur

Onderstaande afbeelding toont de Hibernate-architectuur en hoe het werkt als een abstractielaag tussen applicatieklassen en JDBC/JTA-API’s voor databasebewerkingen. Het is duidelijk dat Hibernate is gebouwd bovenop JDBC- en JTA-API’s. Laten we eens kijken naar de kerncomponenten van de Hibernate-architectuur, één voor één.

  • SessionFactory (org.hibernate.SessionFactory): SessionFactory is een onveranderlijke, thread-safe cache van gecompileerde mappings voor een enkele database. We kunnen een instantie van org.hibernate.Session verkrijgen met behulp van SessionFactory.
  • Session (org.hibernate.Session): Session is een single-threaded, kortlevend object dat een gesprek tussen de applicatie en de persistente opslag vertegenwoordigt. Het omhult JDBC java.sql.Connection en fungeert als een fabriek voor org.hibernate.Transaction.
  • Persistent objecten: Persistent objecten zijn kortlevende, single-threaded objecten die persistente staat en bedrijfsfunctie bevatten. Dit kunnen gewone JavaBeans/POJO’s zijn. Ze zijn geassocieerd met precies één org.hibernate.Session.
  • Vluchtige objecten: Vluchtige objecten zijn instanties van persistente klassen die momenteel niet zijn gekoppeld aan een org.hibernate.Session. Ze kunnen zijn geïnstantieerd door de toepassing en nog niet zijn opgeslagen, of ze kunnen zijn geïnstantieerd door een gesloten org.hibernate.Session.
  • Transactie (org.hibernate.Transaction): Een transactie is een single-threaded, kortstondig object dat door de toepassing wordt gebruikt om atomaire eenheden van werk aan te geven. Het abstracteert de toepassing van de onderliggende JDBC- of JTA-transactie. Een org.hibernate.Session kan in sommige gevallen meerdere org.hibernate.Transaction omvatten.
  • ConnectionProvider (org.hibernate.connection.ConnectionProvider): ConnectionProvider is een fabriek voor JDBC-verbindingen. Het biedt abstractie tussen de toepassing en de onderliggende javax.sql.DataSource of java.sql.DriverManager. Het wordt niet blootgesteld aan de toepassing, maar kan worden uitgebreid door de ontwikkelaar.
  • TransactionFactory (org.hibernate.TransactionFactory): Een fabriek voor instanties van org.hibernate.Transaction.

Hibernate en Java Persistence API (JPA)

Hibernate biedt implementatie van Java Persistence API, zodat we JPA-annotaties kunnen gebruiken met model beans en hibernate zal ervoor zorgen dat dit geconfigureerd wordt voor CRUD-operaties. We zullen hier naar kijken aan de hand van een voorbeeld met annotaties.

Hibernate Voorbeeld

Bij het ontwikkelen van hibernate-applicaties moeten we twee sets configuratiegegevens verstrekken. De eerste set configuratiegegevens bevat database-specifieke eigenschappen die worden gebruikt om databaseverbindingen en sessie-objecten te maken. De tweede set configuratiegegevens bevat de mapping tussen modelklassen en databasetabellen. We kunnen XML-gebaseerde of eigenschappen-gebaseerde configuraties gebruiken voor configuraties met betrekking tot databaseverbindingen. We kunnen XML-gebaseerde of op annotaties gebaseerde configuraties gebruiken om modelklassen en databasetabellen te mappen. We zullen JPA-annotaties gebruiken van javax.persistence voor annotatiegebaseerde mappings. Ons uiteindelijke project zal eruitzien zoals op onderstaande afbeelding. Maak een Maven-project in Eclipse of je favoriete IDE, je kunt elke naam naar keuze gebruiken. Voordat we verder gaan met de verschillende onderdelen van het project, moeten we de databaseconfiguratie instellen.

Database Tabel Opzet

Voor mijn voorbeeld gebruik ik een MySQL-database en de onderstaande script wordt gebruikt om de benodigde tabel te maken.

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;

Merk op dat de kolom “id” van de Employee-tabel automatisch wordt gegenereerd door MySQL, dus we hoeven deze niet in te voegen.

Hibernate Project Afhankelijkheden

Ons uiteindelijke pom.xml-bestand ziet er als volgt uit.

<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>

hibernate-core artefact bevat alle kernhibernateklassen, dus we krijgen alle benodigde functies door het op te nemen in het project. Let op dat ik de nieuwste versie van Hibernate (4.3.5.Final) gebruik voor mijn voorbeeldproject en Hibernate nog steeds evolueert en ik heb gemerkt dat er veel kernklassen veranderen tussen elke grote release. Dus als je een andere versie gebruikt, bestaat er een kleine kans dat je de Hibernate-configuraties moet aanpassen om het te laten werken. Ik ben er echter zeker van dat het prima zal werken voor alle 4.x.x-releases. Hibernate 4 gebruikt JBoss-logging, maar oudere versies gebruiken slf4j voor loggingdoeleinden, dus heb ik het slf4j-simple artefact in mijn project opgenomen, hoewel dat niet nodig is omdat ik Hibernate 4 gebruik. mysql-connector-java is de MySQL-driver voor het verbinden met MySQL-databases. Als je een andere database gebruikt, voeg dan het overeenkomstige driver-artefact toe.

Domeinmodelklassen

Zoals je kunt zien in bovenstaande afbeelding hebben we twee modelklassen, Employee en Employee1. Employee is een eenvoudige Java Bean-klasse en we zullen XML-gebaseerde configuratie gebruiken om de toewijzingsdetails ervan te verstrekken. Employee1 is een Java Bean waarbij velden zijn geannoteerd met JPA-annotaties, zodat we geen toewijzing in een apart XML-bestand hoeven te verstrekken.

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;
	}
	
}

Employee-klasse is een eenvoudige Java Bean, er is hier niets specifieks te bespreken.

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;
	}
}

javax.persistence.Entity-annotatie wordt gebruikt om een klasse als Entity Bean te markeren die door Hibernate kan worden opgeslagen, aangezien Hibernate een JPA-implementatie biedt. javax.persistence.Table-annotatie wordt gebruikt om de tabeltoewijzing en unieke beperkingen voor de kolommen te definiëren. javax.persistence.Id-annotatie wordt gebruikt om de primaire sleutel voor de tabel te definiëren. javax.persistence.GeneratedValue wordt gebruikt om te definiëren dat het veld automatisch wordt gegenereerd en GenerationType.IDENTITY-strategie wordt gebruikt zodat de gegenereerde “id”-waarde wordt toegewezen aan de bean en kan worden opgehaald in het Java-programma. javax.persistence.Column wordt gebruikt om het veld te koppelen aan de tabelkolom, we kunnen ook lengte, nullable en uniciteit specificeren voor de bean-eigenschappen.

Hibernate Mapping XML-configuratie

Zoals hierboven vermeld, zullen we XML-gebaseerde configuratie gebruiken voor het in kaart brengen van de Employee-klasse. We kunnen elke naam kiezen, maar het is goed om er een te kiezen die duidelijkheid biedt met betrekking tot de tabel- of javabean-naam. Ons hibernate-mappingbestand voor de Employee-bean ziet er als volgt uit. 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>

De XML-configuratie is eenvoudig en doet hetzelfde als de annotatiegebaseerde configuratie.

Hibernate-configuratiebestanden

We zullen twee hibernate-configuratie-XML-bestanden maken – een voor XML-gebaseerde configuratie en een andere voor annotatiegebaseerde configuratie. 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>

De meeste eigenschappen hebben betrekking op databaseconfiguraties, andere eigenschapsdetails worden gegeven in de opmerking. Let op de configuratie voor het hibernate-mappingbestand; we kunnen meerdere hibernate-mappingbestanden definiëren en ze hier configureren. Merk ook op dat de mapping specifiek is voor de 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>

De meeste configuratie is hetzelfde als XML-gebaseerde configuratie, het enige verschil is de mappingconfiguratie. We kunnen mappingconfiguratie opgeven voor klassen evenals pakketten.

Hibernate SessionFactory

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 {

	//XML-gebaseerde configuratie
	private static SessionFactory sessionFactory;
	
	//Configuratie op basis van annotaties
	private static SessionFactory sessionAnnotationFactory;
	
	//Configuratie op basis van eigenschappen
	private static SessionFactory sessionJavaConfigFactory;

    private static SessionFactory buildSessionFactory() {
        try {
            // Maak de SessionFactory aan vanuit 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) {
            // Zorg ervoor dat je de uitzondering logt, want deze kan worden genegeerd
            System.err.println("Initial SessionFactory creation failed." + ex);
            throw new ExceptionInInitializerError(ex);
        }
    }

    private static SessionFactory buildSessionAnnotationFactory() {
    	try {
            // Maak de SessionFactory aan vanuit 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) {
            // Zorg ervoor dat je de uitzondering logt, want deze kan worden genegeerd
            System.err.println("Initial SessionFactory creation failed." + ex);
            throw new ExceptionInInitializerError(ex);
        }
	}

    private static SessionFactory buildSessionJavaConfigFactory() {
    	try {
    	Configuration configuration = new Configuration();
		
		//Maak eigenschappen aan, deze kunnen ook worden gelezen uit eigenschappenbestanden
		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);
		
		//We kunnen mappingbestanden of klassen instellen met annotaties
		//addClass(Employee1.class) zal zoeken naar resource
		// com/journaldev/hibernate/model/Employee1.hbm.xml (niet goed)
		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;
    }
	
}

Het creëren van een SessionFactory voor XML-gebaseerde configuratie is hetzelfde, of de mapping nu XML-gebaseerd is of op annotaties is gebaseerd. Voor op eigenschappen gebaseerde configuratie moeten we de eigenschappen instellen in het Configuration-object en annotatieklassen toevoegen voordat we de SessionFactory aanmaken. Over het algemeen omvat het maken van een SessionFactory de volgende stappen:

  1. Het creëren van een Configuration-object en het configureren ervan
  2. Het creëren van een ServiceRegistry-object en configuratie-instellingen toepassen.
  3. Gebruik configuration.buildSessionFactory() door het ServiceRegistry-object door te geven als argument om het SessionFactory-object te verkrijgen.

Onze applicatie is bijna klaar, laten we wat testprogramma’s schrijven en ze uitvoeren.

Hibernate XML-configuratietest

Ons testprogramma ziet er als volgt uit. 

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());
		
		// Krijg sessie
		Session session = HibernateUtil.getSessionFactory().getCurrentSession();
		// Start transactie
		session.beginTransaction();
		// Sla het Model-object op
		session.save(emp);
		// Bevestig transactie
		session.getTransaction().commit();
		System.out.println("Employee ID="+emp.getId());
		
		// Beëindig de sessiefabriek, anders eindigt het programma niet
		HibernateUtil.getSessionFactory().close();
	}

}

Het programma is vanzelfsprekend, wanneer we het testprogramma uitvoeren, krijgen we de volgende uitvoer. 

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]

Let op dat het de gegenereerde werknemer-id afdrukt, u kunt de database-tabel controleren om dit te bevestigen.

Hibernate Annotation-configuratietest

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());
		
		// Krijg sessie
		SessionFactory sessionFactory = HibernateUtil.getSessionAnnotationFactory();
		Session session = sessionFactory.getCurrentSession();
		// Start transactie
		session.beginTransaction();
		// Sla het Model-object op
		session.save(emp);
		// Bevestig transactie
		session.getTransaction().commit();
		System.out.println("Employee ID="+emp.getId());
		
		// Beëindig de sessiefabriek, anders eindigt het programma niet
		sessionFactory.close();
	}

}

Wanneer we het bovenstaande programma uitvoeren, krijgen we de volgende uitvoer.

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]

Neem een kijkje naar de uitvoer en vergelijk het met de uitvoer van de op XML gebaseerde configuratie, je zult enkele verschillen opmerken. Bijvoorbeeld, we stellen de verbindingspoolgrootte niet in voor op annotaties gebaseerde configuratie, dus wordt deze ingesteld op de standaardwaarde 20.

Test van Hibernate Java-configuratie

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());
		
		// Ontvang Sessie
		SessionFactory sessionFactory = HibernateUtil.getSessionJavaConfigFactory();
		Session session = sessionFactory.getCurrentSession();
		// begin transactie
		session.beginTransaction();
		// Modelobject opslaan
		session.save(emp);
		// Commit transactie
		session.getTransaction().commit();
		System.out.println("Employee ID="+emp.getId());
		
		// sessiefabriek beëindigen, anders eindigt het programma niet
		sessionFactory.close();
	}

}

De uitvoer van het bovenstaande testprogramma is:

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]

Dat is alles voor de hibernate-zelfstudie voor beginners, ik hoop dat het genoeg zal zijn om je op weg te helpen. We zullen in toekomstige zelfstudies verschillende functies van het Hibernate-framework bekijken. Download het volledige project van onderstaande link en speel er mee om meer te leren.

Download Hibernate Beginners Project

Source:
https://www.digitalocean.com/community/tutorials/hibernate-tutorial-for-beginners