Liberamente adattato da “Using the Java Persistence API in Desktop Application” di John O'Conner, http://java.sun.com/developer/technicalArticles/J2SE/Desktop/persistenceapi/ e dal
volume “Java e Open Source” di Massimiliano Bigatti, Tecniche Nuove
J2EEL'applicazione web che presenteremo (PersistenceWebApp) si fonda sulla cosiddetta tecnologia J2EE (Java to Enterprise Edition), cioè la versione Java per le grandi aziende: questa piattaforma software è formata da un ampio insieme di tecnologie alcune di queste rappresentate sinteticamente in fig. 1.
Fig. 1 – Alcune tecnologie J2EE
Tutte comunque richiedono, diciamo a più basso livello, la piattaforma standard di Java, cioè la J2SE (Java Standard Edition).
EJBIl cuore della piattaforma J2EE è sicuramente la tecnologia EJB (Enterprise Java Bean) che definisce le specifiche per la realizzazione di componenti riutilizzabili (modellano la cosiddetta Logica di Business) per la grande azienda. Non confondiamo però le componenti EJB con i javabean (nati inizialmente per le interfacce utente e in seguito sfruttati per il supporto web e per le applicazioni standalone). In tutti e due i casi comunque è presente il concetto di componente cioè di una unità minima e indivisibile che implementa specifiche funzionalità. Nel caso degli EJB, questi componenti vivono all'interno di un application server, che fornisce loro servizi quali la persistenza, la transazionalità, il pooling, la denominazione (naming) e altri.Un application server è un prodotto software che implementa diversi servizi allo scopo di fornire un ambiente di esecuzione per i componenti J2EE. Solitamente sono presenti un Web Container, che si occupa di far girare componenti di presentazione implementati (come servlet o pagine JSP) con output HTML, e un EJB Container che esegue i componenti EJB. Tra gli application server open-source vi sono Jboss, Jonas, Orion e GlassFish (http://glassfish.dev.java.net). I prodotti commerciali più diffusi sono invece BEA WebLogic, WebSphere e Oracle AS.
La PersistenzaIl problema della registrazione delle informazioni su qualche forma di supporto di memoria è vecchio quanto l'informatica stessa. Nel corso degli anni, sono stati sviluppate diverse tecnologie ma la maggior parte delle volte si usano database relazionali. Le piattaforme orientate agli oggetti introducono un ulteriore elemento di complessità perchè con esse si ragiona a “oggetti” mentre con i database relazionali si ragiona sempre in termini di righe e di
colonne (tuple e attributi), organizzando le informazioni in strutture a griglia. Nei sistemi a oggetti, la struttura dei dati può essere più sofisticata e spesso non è riconducibile a un'organizzazione tabellare. Esiste dunque una impedenza tra database relazionali e sistemi a oggetti superabile se utilizziamo un componente intermedio che si occupi di migrare le informazioni da un formato all'altro. Un modello a oggetti necessita cioè di un livello di interfacciamento che ne adatti la forma, al fine di poter essere memorizzato in un database relazionale.
Fig. 2 – Object/relational Mapping
Questo strato intermedio è di solito sviluppato in due modi diversi:
1) Sviluppo manuale. Lo sviluppatore realizza una serie di oggetti di accesso ai dati, che attuano la corrispondenza tra le informazioni presenti negli oggetti e le tabelle della base di dati. Un approccio simile è di tipo manuale, dove ogni operazione di creazione, lettura, aggiornamento o cancellazione (CRUD, Create-Retrieve-Update-Delete) viene codificata nel programma.
2) Framework di persistenza. Il processo di realizzazione dello strato software relativo alla memorizzazione delle informazioni (persistenza) sono attività che richiedono una grande quantità di tempo. In tal caso, è preferibile utilizzare uno dei diversi framework di persistenza disponibili. Molti sono open-source ma ben testati e completi in termini di funzionalità (ad esempio Hybernate e TopLink della Oracle).
Il componente software che si occupa di eseguire le operazioni CRUD è chiamato motore di persistenza.Ci si riferisce spesso a questo componente anche come strumento di O/R mapping (obiect/relational mapping, mappatura oggetto-relazione).
Entità e Relazioni tra EntitàIl primo passo da compiere è definire le entità presenti nel sistema. Per esempio in un sistema di fatturazione, pensiamo alle entità Fattura, Prodotto, Cliente ecc. Ogni Entità sarà rappresentata da una classe java e poi resa persistente (parliamo di entità persistente o classe persistente) mediante un'operazione di “mappatura” della classe o “mapping” ad una tabella di un database relazionale. Ogni istanza della classe è una riga della tabella.Dal momento che le entità persistenti sono sostanzialmente classi java, parliamo anche di POJO (Plain Old Java Object).Come accade nel mondo reale, le entità ovviamente non lavorano da sole ma interagiscono con altre entità. Le classi possono avere i seguenti tipi di relazioni: uno-a-uno, uno-a-molti, molti-a-uno, molti-a-molti (la terminologia deriva infatti dal modello E-R adottato nella progettazione dei database). Trascuriamo per motivi di brevità la relazione uno-a-uno e molti-a-molti.Per la nostra applicazione, consideriamo l'entità Giocatore (di baseball), chiamiamola Player e l'entità Squadra (Team). Rappresentiamo le entità e la relazione tra le due entità con un diagramma UML:
Il rombo rappresenta un'aggregazione, mentre l'asterisco * si legge “molti” ed indica la molteplicità degli oggetti coinvolti nella relazione. Dal punto di vista del team, la relazione è di tipo “uno-a-molti”, mentre dal punto di vista del giocatore è di tipo “molti-a-uno”, cioè l'associazione è bidirezionale.
Le annotazioniDal punto di vista del codice java, ogni entità quindi deve essere preceduta dalla annotazione @Entity e deve implementare l'interfaccia Serializable in modo da consentire ad uno strumento esterno di salvarne lo stato. La classe persistente inoltre deve possedere un costruttore nullo (è possibile fare comunque l'overloading del costruttore) e una chiave primaria che può essere costituita da un solo campo o da più campi (annotazione @Id). I valori del campo chiave possono essere generati automaticamente (annotazione @GeneratedValue). La relazione Player->Team è di tipo “molti-a-uno” e richiede pertanto l'annotazione @ManyToOne. La classe Player deve possedere un reference alla classe Team il quale assume in tal modo il ruolo di chiave esterna. Usiamo inoltre l'annotazione @Transient per marcare proprietà transienti, cioè che non saranno memorizzate nel database.
/** * * @author maurizio */@Entitypublic class Player implements Serializable { private static final long serialVersionUID = 1L; private Long id; private String lastName; private String firstName; private int jerseyNumber; private String lastSpokenWords; private Team team; // reference al team
// costruttore senza argomenti obbligatorio public Player() { }
// costruttore con 4 argomenti public Player(String lName, String fName, int number, String words) { this.lastName = lName; this.firstName = fName; this.jerseyNumber = number; this.lastSpokenWords = words; }
// setter per l'id public void setId(Long id) { this.id = id; }
// l'annotazione @Id indica che il campo id rappresenta la chiave primaria obbligatoria // la proprietà strategy indica che i valori del campo id saranno generati automaticamente @Id @GeneratedValue(strategy = GenerationType.AUTO) public Long getId() { return id; }
@Override public int hashCode() { int hash = 0; hash += (id != null ? id.hashCode() : 0); return hash; }
@Override public boolean equals(Object object) { // TODO: Warning - this method won't work in the case the id fields are not set if (!(object instanceof Player)) { return false; } Player other = (Player) object; if ((this.id == null && other.id != null) || (this.id != null && !this.id.equals(other.id))) { return false; } return true; }
public String getFirstName() { return firstName; }
public void setFirstName(String firstName) { this.firstName = firstName; }
public int getJerseyNumber() { return jerseyNumber; } public void setJerseyNumber(int jerseyNumber) { this.jerseyNumber = jerseyNumber; }
@Transient public String getLastSpokenWords() { return lastSpokenWords; } public void setLastSpokenWords(String lastSpokenWords) { this.lastSpokenWords = lastSpokenWords; } // l'annotazione @ManyToOne denota una relazione "molti-a-uno" @ManyToOne public Team getTeam() { return team; }
public void setTeam(Team team) { this.team = team; }
} // fine Entità Player
La classe Team invece possiede un reference a una “collection” di oggetti di tipo Player. La collection sarà implementata concretamente mediante l'istanza di un oggetto di tipo HashSet. Gli elementi di una HashSet rappresentano un insieme ordinario di elementi unici, senza duplicati. La relazione Team->Player è di tipo “uno-a-molti” per cui usiamo l'annotazione @OneToMany(mappedBy = "team"), dove team è il reference inserito quale attributo nella classe Player. L'entità Team possiede inoltre due metodi per aggiungere e rimuovere oggetti di tipo Player.
/** * @author maurizio */@Entitypublic class Team implements Serializable { private static final long serialVersionUID = 1L; private Long id; private String teamName; private String league; private Collection<Player> players;
// costruttore senza argomenti public Team() { players = new HashSet(); } // overloading del costruttore public Team(String name, String league) { this.teamName = name; this.league = league; players = new HashSet(); } public void setId(Long id) { this.id = id; }
@Id @GeneratedValue(strategy = GenerationType.AUTO) public Long getId() { return id; }
@Override public int hashCode() { int hash = 0; hash += (id != null ? id.hashCode() : 0); return hash; }
@Override public boolean equals(Object object) { // TODO: Warning - this method won't work in the case the id fields are not set if (!(object instanceof Team)) { return false; } Team other = (Team) object; if ((this.id == null && other.id != null) || (this.id != null && !this.id.equals(other.id))) { return false; } return true; }
@Override public String toString() { //return "it.mauriziocozzetto.classi.Team[id=" + id + "]"; return "team"; }
public String getTeamName() { return teamName; }
public void setTeamName(String teamName) { this.teamName = teamName; }
public String getLeague() { return league; }
public void setLeague(String league) { this.league = league; }
@OneToMany(mappedBy = "team") public Collection<Player> getPlayers() { return players; }
public void setPlayers(Collection<Player> players) { this.players = players; } public void addPlayer(Player player) { players.add(player); } public boolean removePlayer(Player player) { return players.remove(player); }
} // fine Entità Team
Unità di persistenzaL'insieme delle entità in una applicazione è chiamato unità di persistenza (file XML persistence.xml). Il file ha molte funzioni ma principalmente serve ad assegnare il nome all'unità, a elencare tutte le entità coinvolte e a dichiarare il Provider di persistenza.
teamPU è l'unità di persistenza, mentre il Provider di Persistenza è TopLink Essentials (possiamo optare anche per un altro provider, ad esempio Hybernate). Il tipo di transazione è JTA (Java Transaction API).Vogliamo inoltre includere tutte le classi entità nella web application (valore del tag exclude-unlisted-classes), mentre il data-source è TeamJNDI (l'application server deve avere il supporto per JNDI). Create-tables denota invece la strategia di generazione delle tabelle.
JNDIDi JNDI (Java Naming and Directory Interface) e del Pool di connessioni abbiamo parlato nell'articolo “Approccio DAO”, categoria Java-Applicazioni web, file GuestBookDAO.pdf.
Riprendiamo qui il concetto di pool: un pool è un insieme di connessioni prestabilite che vengono lasciate in attesa di essere utilizzate. Quando il client ha bisogno di eseguire un'operazione, richiede una connessione al pool, esegue l'operazione e poi la ritorna al pool, occupando la risorsa solo per il tempo strettamente necessario. In tal modo il sistema risulta più efficiente. Dobbiamo indicare inoltre al sistema quale database utilizzare, indicando il nome del server, il nome del database, la porta, i driver, l'utente, la password ecc e come deve essere strutturato il Pool di connessioni. Il file XML sun-resources contiene queste informazioni.
Il database della nostra applicazione web, team_db, è stato creato precedentemente ed è in questa fase ancora vuoto. Ovviamente, perchè le cose funzionino, abbiamo bisogno del driver java di tipo 4 MySQL-J-Connector (http://www.mysql.com).
Entity ManagerPer rendere persistente una entità, abbiamo bisogno di un istanza di tipo EntityManager. Per farlo, dobbiamo prima creare un oggetto di tipo EntityManagerFactory. Successivamente dobbiamo ottenere una transazione, rendere persistente gli oggetti che ci interessano e successivamente chiudere le risorse allocate.
File index.jsp<%-- Document : index Created on : 24-mar-2008, 17.05.08 Author : maurizio--%>
<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN" "http://www.w3.org/TR/html4/loose.dtd">
<html> <head> <meta http-equiv="Content-Type" content="text/html; charset=UTF-8"> <title>Persistence Demo</title> </head> <body> <h3>Hello World!</h3> <% // allochiamo in memoria 3 istanze dei Dodgers players Player[] dodgersPlayers = new Player[] { new Player("Lowe", "Derek", 23, "You just can't touch that sinker."), new Player("Kent", "Jeff", 12, "I'm getting too old for this."), new Player("Garciaparra", "Nomar", 5, "No, I'm not superstitious at all.") }; // allochiamo 3 istanze dei Giant players Player[] giantsPlayers = new Player[] { new Player("Pettitte", "Andy", 46, null), new Player("Jeter", "Derek", 2, null), new Player("Rodriguez", "Alex", 13, null) }; // creiamo 4 squadre Team[] teams = new Team[] { new Team("Los Angeles Dodgers", "National"), new Team("San Francisco Giants", "National"), new Team("Anaheim Angels", "American"), new Team("Boston Red Sox", "American") };
// istanziamo un oggetto di tipo EntityManagerfactory EntityManagerFactory emf = Persistence.createEntityManagerFactory("teamPU"); // istanziamo un oggetto di tipo EntityManager EntityManager em = emf.createEntityManager(); // prepariamo la transazione em.getTransaction().begin();
Fig. 9 – La struttura degli indici della tabella Team
Fig. 10 – I dati della tabella Team
RicercaOra il database (che prima era vuoto) dispone di giocatori e di squadre. Se conosciamo il valore della chiave primaria, mediante il metodo find dell'oggetto EntityManager, possiamo ritrovare gli oggetti che ci interessano.
Fig. 11 – Ricerca di un particolare oggetto (chiave primaria 352)
// ricerca del record con chiave 352 long primaryKey = 352; out.println("Cerco il giocatore con chiave "+primaryKey+"<br/>"); // cerco l'oggetto con la chiave primaria specificata Player player = em.find(Player.class, primaryKey); if (player != null) out.println(player.toString()); else out.println("Il record con chiave "+primaryKey+" non è stato trovato"); // chiudo gli oggetti creati precedentemente em.close(); emf.close(); %> </body></html>
QuerySebbene il metodo find lavora bene, è possibile raggiungere una maggiore flessibilità effettuando delle vere e proprie interrogazioni sulle entità in maniera simile a quanto accade nei database relazionali, attraverso il linguaggio JPQL (Java Persistence Query Language). Il linguaggio è simile al linguaggio SQL ma ha dei benefici su SQL. Il JPQL opera su entità e relazioni piuttosto che sullo schema relazionale corrente. Questo rende le query più portabili nei confronti del database soggiacente.
<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN" "http://www.w3.org/TR/html4/loose.dtd"><html> <head> <meta http-equiv="Content-Type" content="text/html; charset=UTF-8"> <title>Query</title> </head> <body> <h3>Query</h3> <% // imposta una squadra String aTeamName = "Los Angeles Dodgers"; // Crea l'EntityManager EntityManagerFactory emf = Persistence.createEntityManagerFactory("teamPU"); EntityManager em = emf.createEntityManager(); // crea la query Query q = em.createQuery("select c from Player c where c.team.teamName = :name"); // imposta il parametro q.setParameter("name", aTeamName); // prepara una struttura dati di appoggio List<Player> playerList = q.getResultList();
// scorre la lista dei risultati for(Player p : playerList) { out.println(p.toString()+"<br/>"); }
// chiude l'Entity Manager e l'EntityManagerFactory em.close(); emf.close(); %> </body></html>
Aggiornamento e cancellazioneAllo stesso modo, possiamo effettuare delle operazioni di aggiornamento o di cancellazione scrivendo un codice simile a quello presentato precedentemente. Ad esempio possiamo incrementare di 1 il contenuto del campo JERSEYNUMBER usando il linguaggio JPQL.
File update.jsp<%-- Document : update.jsp Created on : 25-mar-2008, 19.10.17 Author : maurizio --%>
out.println("Effettuo l'aggiornamento di tutti i record del Team "+aTeamName+" aumentando di 1 il campo JERSEYNUMBER<br/>"); // Creiamo la query di aggiornamento Query q = em.createQuery("update Player p set p.jerseyNumber = (p.jerseyNumber+1) where p.team.teamName = :name"); // Fissiamo il nome del Team come parametro della query q.setParameter("name",aTeamName); // Inizio della transazione em.getTransaction().begin(); // Eseguiamo la query di aggiornamento q.executeUpdate(); // Commit della transazione em.getTransaction().commit(); out.println("Aggiornamento effettuato"); // Chiusura gli oggetti creati precedentemente em.close(); emf.close(); %> </body> </html>
Fig. 12 – Tutti i record sono stati aggiornati
Oppure possiamo cancellare un record nella tabella team.
<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN" "http://www.w3.org/TR/html4/loose.dtd">
<html> <head> <meta http-equiv="Content-Type" content="text/html; charset=UTF-8"> <title>Delete</title> </head> <body> <h3>Delete</h3> <% // Creiamo l'EntityManager EntityManagerFactory emf = Persistence.createEntityManagerFactory("teamPU"); EntityManager em = emf.createEntityManager(); // Fissiamo un team String aTeamName="Anaheim Angels"; out.println("Effettuo la cancellazione del Team "+aTeamName+"<br/>"); // Creiamo la query di cancellazione Query q = em.createQuery("delete from Team t where t.teamName = :name"); // Fissiamo il nome del Team come parametro della query q.setParameter("name",aTeamName); // Inizio della transazione em.getTransaction().begin(); // Eseguiamo la query di cancellazione q.executeUpdate(); // Commit della transazione em.getTransaction().commit(); out.println("Cancellazione effettuata"); // Chiusura gli oggetti creati precedentemente em.close(); emf.close(); %> </body> </html>
NetbeansNetBeans offre un IDE estremamente ricco di funzionalità per lo sviluppo di applicazioni J2EE. Ma perchè tutto funzioni correttamente è necessario predisporre l'ambiente in maniera opportuna. L'esempio è stato sviluppato con la versione 6.1 beta in ambiente Windows.
Fig. 14 – Prepariamo l'applicazione web (File > New Projects ...)
Fig. 15 – Scegliamo quale Server GlassFish e la versione J2EE 5. Poi confermiamo tutte le impostazioni proposte.
Fig. 16 – Per creare una Entity Class, clicchiamo col tasto destro del mouse sul nome del progetto e scegliamo New > Entity Class...Successivamente diamo un nome alla classe e al package e scegliamo il tipo della chiave primaria. Tuttavia non possiamo procedere oltre se prima non creiamo l'Unità di Persistenza (pulsante Create Persistence Unit...)
