Installazione hibernate
Più che installazione, bisogna parlare di importazione delle librerie (jar) che contengono la logica di middleware. Dal sito ufficiale potete raggiungere la pagina di download e scaricare il materiale necessario ad iniziare. Come dicevo nel precedente paragrafo, la tecnologia è particolarmente complessa (e interessante) nelle sue funzionalità avanzate e nel sito troverete tutto il materiale di cui avrete bisogno per approfondimenti. Per iniziare è sufficiente scaricare la tecnologia (core), arrivata, al momento in cui scrivo, alla versione 3.2.5.
Una volta scaricati i file, importate le librerie jar sotto il vostro progetto oppure rendetele visibili al classpath. Tutte le classi necessarie le trovate nel package hibernate3.jar, quindi sarà sufficiente importare quest'ultimo.
Esempio pratico
Quello che vogliamo realizzare è la creazione di un'associazione tra una tabella di un database e un Javabean attraverso il quale poter rappresentare i dati.
Prendiamo il caso della persistenza di informazioni di persone, presenti in un database. Immaginiamo il database abbia diverse informazioni registrate tra cui un identificativo, il nome e l'indirizzo email.
Iniziamo a sviluppare il Javabean associato, che chiameremo Persona. Ovviamente si tratta di una classe con i suddetti attributi di istanza (privati), i metodi getter e setter pubblici ed il costruttore di default (unici vincoli di un javabean).
Listato 1. Javabean che contiene informazioni su una persona
package it.html.hibernate;
public class Persona {
//Variabili di istanza
private int id;
private String nome;
private String email;
//Costruttore pubblico
public Persona(){}
public String getEmail() {
return email;
}
//Metodi getter / setter
public void setEmail(String email) {
this.email = email;
}
public int getId() {
return id;
}
public void setId(int id) {
this.id = id;
}
public String getNome() {
return nome;
}
public void setNome(String nome) {
this.nome = nome;
}
}Come potete vedere, non c'è niente di particolarmente rilevante: nessuna estensione o implementazione, il che rende possibile fare evolvere la classe da altre e così via. Ma procediamo con quello che è il ponte tra il javabean e Hibernate: il descrittore xml.
Il descrittore ha il compito di definire l'associazione tra l'oggetto appena scritto ed il database. Immaginiamo che la tabella del database si chiami AnagraficaCliente e che abbia una serie di campi tra cui: ANAG_ID, nome, cognome, CLI_EMAIL e CLI_TEL.
Listato 2. Descrittore
<?xml version="1.0"?>
<hibernate-mapping>
<class name="it.html.hibernate.Persona" table="AnagraficaCliente">
<id name="id" column="ANAG_ID">
<generator class="native"/>
</id>
<property name="email" column="CLI_EMAIL"/>
<property name="nome"/>
</class>
</hibernate-mapping>Il descrittore, dovendo associare la classe alla tabella, si presenta molto semplicemente. Il tag class, racchiude l'associazione vera e propria già nei sui due attributi name e table. Già noi in questo modo associamo il javabean alla tabella.
Successivamente, sempre all'interno dello stesso tag definiamo le altre informazioni di supporto (relative alle proprietà del bean). Il tag id definisce l'identificativo della tabella (la chiave), mentre i tag property definiscono l'associazione tra la proprietà del javabean (attributo name) e la colonna del database (attributo column). Quando l'attributo column manca è implicito che il nome della colonna sarà quello definito dall'attributo name.
Questo file, per convenzione, viene inserito a livello del sorgente java e si chiamerà (sempre per convenzione) Persona.hbm.xml.
A completare il quadro mancano però alcune componenti essenziali. Come sappiamo, per poter interrogare una base di dati abbiamo bisogno dei bridge JDBC che sono dei driver dipendenti dall'implementazione del DBMS usato. Dovremo infatti creare un altro file che definisca le informazioni su database (indirizzo) e driver (classe da usare).
Listato 3. Definisce le informazioni per la connessione al DB
<?xml version='1.0' encoding='utf-8'?>
<!DOCTYPE hibernate-configuration PUBLIC
"-//Hibernate/Hibernate Configuration DTD 3.0//EN"
"http://hibernate.sourceforge.net/hibernate-configuration-3.0.dtd">
<hibernate-configuration>
<session-factory>
<!-- Database connection settings -->
<property name="connection.driver_class">org.hsqldb.jdbcDriver</property>
<property name="connection.url">jdbc:hsqldb:hsql://localhost</property>
<property name="connection.username">root</property>
<property name="connection.password">****</property>
<property name="connection.pool_size">1</property>
<property name="dialect">org.hibernate.dialect.HSQLDialect</property>
<property name="current_session_context_class">thread</property>
<property name="cache.provider_class">org.hibernate.cache.NoCacheProvider</property>
<property name="show_sql">true</property>
<property name="hbm2ddl.auto">create</property>
<mapping resource="it/html/hibernate/Persona.hbm.xml"/>
</session-factory>
</hibernate-configuration>Il file di configurazione (hibernate.cfg.xml) indica i driver necessari alla connessione. Per questo semplice esempio utilizzeremo un database HSQL (un DBMS realizzato in java). Due sono le possibilità per definire la connessione al database: il file di configurazione (xml) oppure un file proprietà. Rimaniamo concentrati sul listato sopra. Le proprietà definiscono il driver da utilizzare (connection.driver_class) e l'url (connection.url) di connessione al database più altri parametri opzionali. Utilizzando altri database bisogna fare attenzione a portare i driver JDBC a livello di visibilità del classpath.
Altro parametro a cui bisogna fare attenzione è il tag mapping, nella cui proprietà resource viene indicato il path dove recuperare lo schema di persistenza che avevamo scritto in precedenza (più eventualmente altri presenti).
Quello che ci rimane è creare il middleware vero e proprio. Si tratta di una classe di controllo, che, una volta istanziata, si occuperà di effettuare le operazioni CRUD, convertendole in operazioni SQL e quindi in operazioni di persistenza sulla base di dati.
Listato 4. Classe usata per testare la persistenza del javabean Persona
package it.html.hibernate;
import org.hibernate.Session;
import org.hibernate.SessionFactory;
import org.hibernate.cfg.Configuration;
public class PersonaUnitTest {
public static void main(String[] args) {
System.out.println(“Persona Unit Test”);
// Recupero la sessione: attenzione, questa operazione
// può essere gestita come un Singleton lungo tutta l’applicazione
Session session=new Configuration().configure().buildSessionFactory().getCurrentSession();
//Creo una nuova persona
Persona p=new Persona();
p.setId(101);
p.setNome(“Pasquale Congiustì”);
p.setEmail(“p.congiusti@html.it”);
//Utilizziamo un modello transazionale dichiarativo
session.beginTransaction();
//Chiedo al middleware di salvare questo oggetto nel database
session.save(p);
//fine della transazione: salviamo tramite commit()
session.getTransaction().commit();
}
}Il listato ci mostra una classe main. Nella realtà, probabilmente, codificheremo l'operazione di controllo sul controllore (una servlet, nel paradigma MVC). L'oggetto che si occupa di tutto è l'oggetto Session, il cui ciclo di vita può essere ottimizzato condividendo lo stesso oggetto tra più richieste. L'operazione di salvataggio vera e propria è rappresentata dal metodo save, che si aspetta come parametro un oggetto generico (nel nostro caso una Persona).
Sarà quel metodo ad effettuare una richiesta SQL (una insert, presumibilmente) verso la base di dati, recuperando le informazioni proprio dal descrittore e dal javabean.
Analogamente bisognerà fare con le operazioni load, update e delete. La conversione verrà curata dal framework in tutto e per tutto.
La programmazione orientata agli oggetti, come abbiamo visto nei precedenti articoli, ci garantisce delle opportunità di sviluppo peculiari di questo paradigma di programmazione. In particolare la possibilità di astrarre dei concetti generali, ed applicarli a diversi contesti in maniera praticamente automatizzata consente il rapido sviluppo basato su servizi già creati.
Nei precedenti due articoli abbiamo presentato un principio generale applicato ad un contesto particolare (lo sviluppo di una piattaforma per automatizzare le procedure di salvataggio su base di dati e la reflection in java) per mostrare con un esempio concreto come sia possibile realizzare l'astrazione.
Esistono tuttavia in commercio piattaforme più evolute che estendono proprio i concetti di astrazione e riusabilità portandoli a diventare basi portanti per progetti di più ampio respiro. è il caso di Hibernate, che presentiamo in questo articolo, le cui peculiarità sono la base della piattaforma di middleware per la persistenza forse più interessante in commercio (nonché la base dell'application server JBoss per la persistenza degli entity java bean).
Hibernate Java: tutorial
Hibernate è uno strato di middleware che consente allo sviluppatore di automatizzare le procedure per le operazioni cosiddette CRUD (Create, Read, Update, Delete) dei database.
In ambito di sistemi informativi, in particolar modo applicati al web, questo tipo di operazioni sono quelle che più di altre portano lavoro: di codifica, di test e di debug. In particolare l'eterogeneità tra il linguaggio di programmazione utilizzato per la logica applicativa (nel nostro caso Java, ma in generale anche gli altri linguaggi) e quello utilizzato per interrogare le basi di dati relazionali (SQL, standard o dialetti derivati dalle implementazioni del database) è all'origine della difficoltà di produrre in tempi brevi prodotti affidabili.
Le pratiche di programmazione più comuni, hanno portato, nel tempo, a modelli di sviluppo che prevedono l'utilizzo dei Javabean, in particolare in ambiente web application, come oggetti contenitore di informazioni residenti su base di dati. Oggetti, che tra le altre cose ben si prestano ad essere rappresentati in fase di visualizzazione grazie ai tag delle pagine JSP.
Il successivo passo è quindi quello di avere uno strato di programmazione che si interpone tra la pagina JSP ed il database, occupandosi di popolare con le informazioni corrette proprio i javabean.
Hibernate nasce con questo scopo e si evolve fino a diventare forse la più robusta piattaforma di middleware per la persistenza attualmente presente. Il progetto, opensource da sempre, è sotto l'elgida Red Hat, che qualche tempo fa ha acquisito il progetto JBoss (di cui Hibernate è ormai colonna portante).
L'idea è quella di indicare al middleware in maniera dichiarativa (con dei descrittori testuali, xml) l'associazione tra la classe del javabean e la tabella in cui risiedono i dati. Una volta definite queste associazioni, l'infrastruttura che utilizzeremo si occuperà di recuperare dinamicamente le informazioni associate (leggendo i descrittori) e creare automaticamente le query necessarie (in base all'operazione che utilizzeremo).
A differenza degli entity java bean (che pure hanno una logica similare), qui dovremo chiedere esplicitamente l'operazione da svolgere (salvataggio, update, cancellazione, ecc). In realtà, la piattaforma consente di fare molto di più. Lo scopo di questo articolo è però quello di illustrare i primi passi per poter utilizzare la tecnologia, quindi vediamo come poter incominciare da subito ad utilizzare la piattaforma.
