Hibernate: realizziamo un esempio pratico di utilizzo delle API di base

In questo post vedremo con configurare Hibernate per un nostro Progetto Java all’interno di Eclipse e come utilizzare le api di base per salvare e reperire le informazioni da un database MySQL.

Procuriamoci le API Hibernate all’indirizzo:

http://sourceforge.net/projects/hibernate/files/hibernate3/

inoltre l’API di logging slf4j presente nel pacchetto che scarichiamo e richiesta da Hibernate ha bisogno di una ulteriore libreria di logging per il suo funzionamento, perciò rechiamoci all’indirizzo:

http://www.slf4j.org/download.html

e scarichiamo uno dei due pacchetti (tar o zip).

Infine dobbiamo avere il driver per la connessione a MySql, lo reperiamo all’indirizzo:

http://dev.mysql.com/downloads/connector/j/

Ora abbiamo tutto ciò che ci occorre per testare la nostra applicazione di esempio, lanciamo Eclipse e creiamo un nuovo progetto Java (facendo click sulla barra dei menu su File -> New -> Java Project).

Creiamo un folder di nome lib nella directory di base e vi copiamo le seguenti librerie che abbiamo scaricato:

• antlr-2.7.6.jar;
• commons-collections-3.1.jar;
• dom4j-1.6.1.jar;
• hibernate3.jar;
• hibernate-jpa-2.0-api-1.0.0.Final.jar;   lo troviamo nella cartella /lib/jpa/;
• javassist-3.12.0.GA.jar;
• jta-1.1.jar;
• slf4j-api-1.6.1.jar;
• slf4j-simple-1.6.1.jar; lo troviamo nel pacchetto scaricato dal sito di slf4j;

Creiamo a questo punto un file di configurazione di Hibernate chiamato hibernate.cfg.xml:

<?xml version='1.0' encoding='utf-8'?>
<!DOCTYPE hibernate-configuration PUBLIC
"-//Hibernate/Hibernate Configuration DTD 3.0//EN"
"http://www.hibernate.org/dtd/hibernate-configuration-3.0.dtd">
<hibernate-configuration>
<session-factory>
<!-- Database connection settings -->
<property name="connection.driver_class">com.mysql.jdbc.Driver</property>
<property name="connection.url">jdbc:mysql://localhost:3306/mydb</property>
<property name="connection.username">root</property>
<property name="connection.password">angeloonline</property>
<!-- JDBC connection pool (use the built-in) -->
<property name="connection.pool_size">1</property>
<!-- SQL dialect -->
<property name="dialect">org.hibernate.dialect.MySQLInnoDBDialect</property>
<!-- Disable the second-level cache  -->
<property name="cache.provider_class">org.hibernate.cache.NoCacheProvider</property>
<!-- Echo all executed SQL to stdout -->
<property name="show_sql">true</property>
<!-- Drop and re-create the database schema on startup -->
<property name="hbm2ddl.auto">create</property>
<mapping resource="it/appuntisoftware/hbm/Evento.hbm.xml"/>
</session-factory>
</hibernate-configuration>

Con questo file diciamo ad Hibernate qual è il database con cui stiamo lavorando (proprietà dialect) e quali sono i parametri per accedervi (sezione database connection); inoltre disabilitiamo la cache secondaria, ma vogliamo vedere nello Standard Output gli statement SQL generati. Infine la proprietà hbm2ddl.auto valorizzata con create fa sì che Hibernate crei ed esporti automaticamente lo schema DDL delle tabelle su DB appena viene creata la SessionFactory (in poche parole genera automaticamente le tabelle su DB), lo schema è creato in accordo con i mapping file passati tramite la proprietà mapping resource (in questo caso ce n’è uno solo). Se avessimo usato il valore create-drop le tabelle verrebbero cancellate quando la SessionFactory viene chiusa, nel nostro caso invece vengono create e mantenute anche dopo la sua chiusura.

Veniamo ora alla classe (POJO) che vogliamo persistere su DB, essa avrà delle proprietà e dei metodi getter e setter per accedervi in perfetto stile POJO):

package it.appuntisoftware;
import java.util.Date;
public class Evento {
private Long id;
private Date data;
private String titolo;
private String descrizione;
//costruttore vuoti di default
public Evento() {
}
public Evento(String titolo, String descrizione, Date data) {
this.titolo = titolo;
this.descrizione = descrizione;
this.data = data;
}
//metodi setter e getter
//...

non dimentichiamoci di creare un costruttore vuoto che è richiesto da Hibernate quando eseguiamo delle query di selezione (Select). Ora dobbiamo mappare il Pojo che abbiamo definito su di una tabella del Database, in realtà definiamo un mapping delle proprietà del Bean sui campi di una tabella che non andremo a definire ma sarà Hibernate a generarla poichè abbiamo utilizzato la proprietà hbm2dll.auto settandola su create.

Vediamo ora il Mapping file corrispondente al bean Evento (Evento.hbm.xml):

<?xml version="1.0"?>
<!DOCTYPE hibernate-mapping PUBLIC
"-//Hibernate/Hibernate Mapping DTD 3.0//EN"
"http://www.hibernate.org/dtd/hibernate-mapping-3.0.dtd">
<hibernate-mapping package="it.appuntisoftware">
<class name="Evento" table="Eventi">
<id name="id" column="Id_Evento">
<generator class="increment"/>
</id>
<property name="data" type="timestamp" column="data_evento"/>
<property name="titolo"/>
<property name="descrizione"/>
</class>
</hibernate-mapping>

la corrispondenza tra tabella del DB e bean è indicata nel tag class dove name è il bean mentre table è ovviamente il nome della tabella su DB. Per l’id abbiamo scelto un generator di tipo increment: questo indica che verrà generato un id incrementale (aumenta di uno ad ogni insert) ed unico solo se il processo che sta inserendo il record nel DB è unico, di conseguenza non deve essere usato se ci troviamo in un ambiete cluster (dove ci sono più processi che possono eseguire una insert). I valori possibili per l’attributo class del tag generator sono elencati a questo indirizzo :http://docs.jboss.org/hibernate/core/3.3/reference/en/html/mapping.html#mapping-declaration-id. I tag property, infine, mappano uno ad uno i campi del Bean sulle colonne della tabella del DB selezionato.

Vediamo ora una classe che inizializzi il contesto Hibernate (ottiene cioè una SessionFactory) ed inserisca e poi elenchi delle classi Evento:

package it.appuntisoftware;
import java.util.Date;
import java.util.List;
import org.hibernate.Session;
import org.hibernate.SessionFactory;
import org.hibernate.cfg.Configuration;
import it.appuntisoftware.Evento;
/**
* Test Hibernate API
*
* @author AppuntiSoftware.it
*/
public class TestHibernate{
private SessionFactory sessionFactory;
protected void setUp() throws Exception {
// Otteniamo una SessionFactory per la nostra applicazione
sessionFactory = new Configuration()
.configure() // configura la SessionFactory utilizzando l' hibernate.cfg.xml
.buildSessionFactory();
}
protected void shutDown() throws Exception {
if ( sessionFactory != null ) {
sessionFactory.close();
}
}
public void testBasicUsage() {
// creiamo ed inseriamo degli eventi
Session session = sessionFactory.openSession();
session.beginTransaction();
session.save( new Evento( "Il nostro primo Evento!","Il nostro primo evento che emozione!", new Date() ) );
session.save( new Evento( "Un Evento seguente", "",new Date() ) );
session.getTransaction().commit();
session.close();
// visualizziamo gli eventi memorizzati su db
session = sessionFactory.openSession();
session.beginTransaction();
List<Evento> result = session.createQuery( "from Evento" ).list();
for ( Evento event : (List<Evento>) result ) {
System.out.println( "Event (" + event.getData() + ") : " + event.getTitolo()+"  "+ event.getDescrizione() );
}
session.getTransaction().commit();
session.close();
}
public static void main (String arg[]) throws Exception{
TestHibernate test= new TestHibernate();
test.setUp();
test.testBasicUsage();
test.shutDown();
}
}

Col metodo setUp() inizializziamo la SessionFactory, mentre nel metodo testBasicUsage() abbiamo il codice che inserisce due Bean nel DB (utilizzando il metodo save di Session) e poi reperisce le due entità salvate costruendo una Query in linguaggio HQL (da notare la mancanza dell’operatore select rispetto allo standard SQL).