Benvenuti al tutorial di Hibernate per principianti. Hibernate è uno degli strumenti ORM più ampiamente utilizzati in Java. La maggior parte delle applicazioni utilizza database relazionali per archiviare le informazioni dell’applicazione e a un livello più basso utilizziamo l’API JDBC per connetterci ai database e eseguire operazioni CRUD.
Tutorial di Hibernate per principianti
Se si guarda al codice JDBC, c’è così tanto codice boilerplate e ci sono possibilità di perdita di risorse e inconsistenze dei dati perché tutto il lavoro deve essere svolto dallo sviluppatore. Questo è dove uno strumento ORM viene in aiuto. L’Object-relational mapping (ORM) è la tecnica di programmazione per mappare gli oggetti del modello di dominio dell’applicazione alle tabelle del database relazionale. Hibernate è uno strumento ORM basato su Java che fornisce un framework per il mapping degli oggetti del modello di dominio dell’applicazione alle tabelle del database relazionale e viceversa. Alcuni dei vantaggi nell’utilizzare Hibernate come strumento ORM sono:
- Hibernate supporta il mapping delle classi Java alle tabelle del database e viceversa. Fornisce funzionalità per eseguire operazioni CRUD su tutti i principali database relazionali.
- Hibernate elimina tutto il codice boiler-plate che viene fornito con JDBC e si occupa della gestione delle risorse, in modo che ci possiamo concentrare sui casi d’uso aziendali anziché assicurarci che le operazioni sul database non causino perdite di risorse.
- Hibernate supporta la gestione delle transazioni e si assicura che non ci siano dati inconsistenti nel sistema.
- Poiché utilizziamo XML, file di proprietà o annotazioni per il mapping delle classi Java alle tabelle del database, fornisce uno strato di astrazione tra l’applicazione e il database.
- Hibernate ci aiuta nel mapping di join, collezioni, oggetti di ereditarietà e possiamo facilmente visualizzare come le nostre classi di modello rappresentano le tabelle del database.
- Hibernate fornisce un potente linguaggio di query (HQL) simile a SQL. Tuttavia, HQL è completamente orientato agli oggetti e comprende concetti come l’ereditarietà, il polimorfismo e l’associazione.
- Hibernate offre anche l’integrazione con alcuni moduli esterni. Ad esempio, Hibernate Validator è l’implementazione di riferimento della Bean Validation (JSR 303).
- Hibernate è un progetto open source della comunità Red Hat e viene utilizzato in tutto il mondo. Questo lo rende una scelta migliore rispetto ad altri perché ha una curva di apprendimento ridotta e ci sono tonnellate di documentazione online e aiuto facilmente disponibile nei forum.
- Hibernate è facile da integrare con altri framework Java EE, è così popolare che Spring Framework offre un supporto integrato per l’integrazione di hibernate con le applicazioni 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.
Architettura di Hibernate
L’immagine seguente mostra l’architettura di Hibernate e come funziona come uno strato di astrazione tra le classi dell’applicazione e le API JDBC/JTA per le operazioni di database. È chiaro che Hibernate è costruito sopra le API JDBC e JTA. 
Esaminiamo i componenti principali dell’architettura di Hibernate uno per uno.
- SessionFactory (org.hibernate.SessionFactory): SessionFactory è una cache immutabile e thread-safe di mapping compilati per un singolo database. Possiamo ottenere un’istanza di
org.hibernate.SessionutilizzandoSessionFactory. - Session (org.hibernate.Session): Session è un oggetto a thread singolo e di breve durata che rappresenta una conversazione tra l’applicazione e il persistente. Avvolge
java.sql.Connectiondi JDBC e funziona come una factory perorg.hibernate.Transaction. - Oggetti persistenti: Gli oggetti persistenti sono oggetti a thread singolo e di breve durata che contengono stato persistente e funzioni di business. Possono essere JavaBeans/POJO ordinari. Sono associati esattamente a una
org.hibernate.Session. - Oggetti transitori: Gli oggetti transitori sono istanze di classi persistenti che attualmente non sono associate a una
org.hibernate.Session. Possono essere stati istanziati dall’applicazione e non ancora persistiti, oppure possono essere stati istanziati da unaorg.hibernate.Sessionchiusa. - Transazione (org.hibernate.Transaction): La transazione è un oggetto a thread singolo e a vita breve utilizzato dall’applicazione per specificare unità di lavoro atomiche. Astrae l’applicazione dalla transazione JDBC o JTA sottostante. Una
org.hibernate.Sessionpuò comprendere piùorg.hibernate.Transactionin alcuni casi. - ConnectionProvider (org.hibernate.connection.ConnectionProvider): ConnectionProvider è una fabbrica per le connessioni JDBC. Fornisce un’astrazione tra l’applicazione e il
javax.sql.DataSourceo iljava.sql.DriverManagersottostante. Non è esposto all’applicazione, ma può essere esteso dallo sviluppatore. - TransactionFactory (org.hibernate.TransactionFactory): Una fabbrica per le istanze di
org.hibernate.Transaction.
Hibernate e Java Persistence API (JPA)
Hibernate fornisce un’implementazione di Java Persistence API, quindi possiamo usare le annotazioni JPA con i bean del modello e hibernate si occuperà di configurarlo per essere utilizzato nelle operazioni CRUD. Esamineremo questo con un esempio di annotazioni.
Esempio Hibernate
Quando sviluppiamo applicazioni hibernate, dobbiamo fornire due set di configurazione. Il primo set di configurazione contiene proprietà specifiche del database che verranno utilizzate per creare connessioni al database e oggetti Session. Il secondo set di configurazioni contiene il mapping tra classi del modello e tabelle del database. Possiamo usare la configurazione basata su XML o proprietà per le configurazioni relative alla connessione al database. Possiamo usare configurazioni basate su XML o annotazioni per fornire il mapping tra classi del modello e tabelle del database. Utilizzeremo le annotazioni JPA da javax.persistence per i mapping basati su annotazioni. Il nostro progetto finale avrà l’aspetto dell’immagine sottostante. 
Crea un progetto Maven in Eclipse o nel tuo IDE preferito, puoi tenere qualsiasi nome a tua scelta. Prima di passare ai diversi componenti del progetto, dovremo fare l’installazione del database.
Configurazione della tabella del database
Per il mio esempio, sto utilizzando il database MySQL e lo script seguente viene utilizzato per creare la tabella necessaria.
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;
Si noti che la colonna “id” della tabella Employee viene generata automaticamente da MySQL, quindi non è necessario inserirla.
Dipendenze del progetto Hibernate
Il nostro file pom.xml finale è simile a quello riportato di seguito.
<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 contiene tutte le classi principali di Hibernate, quindi otterremo tutte le funzionalità necessarie includendolo nel progetto. Si noti che sto utilizzando l’ultima versione di Hibernate (4.3.5.Final) per il mio progetto di esempio e Hibernate è ancora in evoluzione e ho notato che molte classi principali cambiano in ogni versione principale. Quindi, se stai utilizzando un’altra versione, c’è una piccola possibilità che tu debba modificare le configurazioni di Hibernate perché funzioni. Tuttavia, sono sicuro che funzionerà correttamente per tutte le versioni 4.x.x. Hibernate 4 utilizza il sistema di registrazione JBoss, ma le versioni più vecchie utilizzano slf4j per scopi di registrazione, quindi ho incluso l’artefatto slf4j-simple nel mio progetto, anche se non è necessario perché sto usando Hibernate 4. mysql-connector-java è il driver MySQL per la connessione ai database MySQL, se stai utilizzando un altro database, aggiungi l’artefatto del driver corrispondente.
Classi del modello di dominio
Come puoi vedere nell’immagine sopra, abbiamo due classi del modello, Employee e Employee1. Employee è una semplice classe Java Bean e utilizzeremo la configurazione basata su XML per fornire i dettagli di mapping. Employee1 è un Java Bean in cui i campi sono annotati con annotazioni JPA, quindi non è necessario fornire un mapping in un file XML separato.
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 è un semplice Java Bean, non c’è nulla di specifico da discutere qui.
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’annotazione javax.persistence.Entity viene utilizzata per contrassegnare una classe come bean di entità che può essere persistito da Hibernate, poiché Hibernate fornisce l’implementazione JPA. L’annotazione javax.persistence.Table viene utilizzata per definire il mapping della tabella e i vincoli univoci per le colonne. L’annotazione javax.persistence.Id viene utilizzata per definire la chiave primaria per la tabella. javax.persistence.GeneratedValue viene utilizzato per definire che il campo verrà generato automaticamente e viene utilizzata la strategia GenerationType.IDENTITY in modo che il valore “id” generato venga mappato al bean e possa essere recuperato nel programma Java. javax.persistence.Column viene utilizzato per mappare il campo alla colonna della tabella, possiamo anche specificare lunghezza, nullabilità e unicità per le proprietà del bean.
Configurazione XML del mapping di Hibernate
Come indicato in precedenza, utilizzeremo la configurazione basata su XML per il mapping della classe Employee. Possiamo scegliere qualsiasi nome, ma è meglio scegliere un nome correlato alla tabella o al bean Java per maggiore chiarezza. Il nostro file di mapping di Hibernate per il bean Employee ha l’aspetto seguente. 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 configurazione XML è semplice e fa la stessa cosa della configurazione basata su annotazioni.
File di configurazione di Hibernate
Creeremo due file di configurazione XML di Hibernate: uno per la configurazione basata su XML e un altro per la configurazione basata su annotazioni. 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 maggior parte delle proprietà riguarda le configurazioni del database, altri dettagli sulle proprietà sono forniti in commento. Notare la configurazione per il file di mapping di Hibernate, possiamo definire più file di mapping di Hibernate e configurarli qui. Notare anche che il mapping è specifico per 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 maggior parte della configurazione è la stessa della configurazione basata su XML, l’unica differenza è la configurazione del mapping. Possiamo fornire la configurazione del mapping per le classi e anche per i pacchetti.
SessionFactory di 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 {
//Configurazione basata su XML
private static SessionFactory sessionFactory;
//Configurazione basata su annotazioni
private static SessionFactory sessionAnnotationFactory;
//Configurazione basata su proprietà
private static SessionFactory sessionJavaConfigFactory;
private static SessionFactory buildSessionFactory() {
try {
//Creare SessionFactory da 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) {
//Assicurarsi di registrare l'eccezione, potrebbe essere soppressa
System.err.println("Initial SessionFactory creation failed." + ex);
throw new ExceptionInInitializerError(ex);
}
}
private static SessionFactory buildSessionAnnotationFactory() {
try {
//Creare SessionFactory da 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) {
//Assicurarsi di registrare l'eccezione, potrebbe essere soppressa
System.err.println("Initial SessionFactory creation failed." + ex);
throw new ExceptionInInitializerError(ex);
}
}
private static SessionFactory buildSessionJavaConfigFactory() {
try {
Configuration configuration = new Configuration();
//Creare Properties, possono essere lette anche da file di proprietà
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);
//Possiamo impostare il file di mapping o la classe con annotazioni
//addClass(Employee1.class) cercherà la risorsa
//com/journaldev/hibernate/model/Employee1.hbm.xml (non è buono)
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 creazione della SessionFactory per la configurazione basata su XML è la stessa, che si tratti di una mappatura basata su XML o su annotazioni. Per la configurazione basata su proprietà, è necessario impostare le proprietà nell’oggetto Configuration e aggiungere le classi di annotazione prima di creare la SessionFactory. Nel complesso, la creazione della SessionFactory include i seguenti passaggi:
- Creazione dell’oggetto
Configuratione configurazione di esso - Creazione dell’oggetto
ServiceRegistrye applicazione delle impostazioni di configurazione. - Utilizzare
configuration.buildSessionFactory()passando l’oggettoServiceRegistrycome argomento per ottenere l’oggettoSessionFactory.
La nostra applicazione è quasi pronta ora, scriviamo alcuni programmi di test ed eseguiamoli.
Test di configurazione XML di Hibernate
Il nostro programma di test si presenta così.
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());
//Ottieni la sessione
Session session = HibernateUtil.getSessionFactory().getCurrentSession();
//Avvia la transazione
session.beginTransaction();
//Salva l'oggetto Model
session.save(emp);
//Conferma la transazione
session.getTransaction().commit();
System.out.println("Employee ID="+emp.getId());
//Termina la session factory, altrimenti il programma non terminerà
HibernateUtil.getSessionFactory().close();
}
}
Il programma si autocomprende, quando eseguiamo il programma di test, otteniamo il seguente output.
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]
Nota che viene stampato l’ID dell’impiegato generato, puoi controllare la tabella del database per confermarlo.
Test di configurazione tramite annotazioni di 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());
//Ottieni la sessione
SessionFactory sessionFactory = HibernateUtil.getSessionAnnotationFactory();
Session session = sessionFactory.getCurrentSession();
//Avvia la transazione
session.beginTransaction();
//Salva l'oggetto Model
session.save(emp);
//Conferma la transazione
session.getTransaction().commit();
System.out.println("Employee ID="+emp.getId());
//Termina la session factory, altrimenti il programma non terminerà
sessionFactory.close();
}
}
Quando eseguiamo il programma sopra, otteniamo il seguente output.
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]
Dai un’occhiata all’output e confrontalo con l’output della configurazione basata su XML, noterai alcune differenze. Ad esempio, non stiamo impostando la dimensione del pool di connessioni per la configurazione basata su annotazioni, quindi viene impostata al valore predefinito 20.
Test di configurazione di Hibernate in 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());
// Ottieni Sessione
SessionFactory sessionFactory = HibernateUtil.getSessionJavaConfigFactory();
Session session = sessionFactory.getCurrentSession();
// Inizia transazione
session.beginTransaction();
// Salva l'oggetto Model
session.save(emp);
// Conferma transazione
session.getTransaction().commit();
System.out.println("Employee ID="+emp.getId());
// Termina session factory, altrimenti il programma non terminerà
sessionFactory.close();
}
}
L’output del programma di test precedente è:
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]
E questo è tutto per il tutorial di Hibernate per principianti, spero che sia sufficiente per iniziare. Esamineremo diverse funzionalità del framework Hibernate in tutorial futuri. Scarica il progetto completo dal link sottostante e sperimenta con esso per imparare di più.
Source:
https://www.digitalocean.com/community/tutorials/hibernate-tutorial-for-beginners