Mauro Rocco programming zone » jee tutorial

Java Enterprise Tutorial – Introduzione alle Named Query

Mauro Rocco — Fri, 29 May 2009 22:01:31 +0000

Questo tutorial è il naturale proseguimento di “Getting Started 2a parte” si basa sullo stesso progetto e ne andrà ad arricchire il contenuto.
Se non avete seguito i tutorial precedenti potete farlo, oppure scaricare semplicemente il progetto base risultato del tutorial Getting started.
Correlato al progetto vi è anche un dump mysql del db usato nei tutorial che potete scaricare cliccando qui.

Nel seguente tutorial affronteremo come “eseguire delle query” in un contesto enterprise e quindi come ottenere degli elenchi di entità.

Un entity beans può contenere delle query già scritte che possono essere chiamate sull’oggetto tramite un nome univoco all’interno del contesto del container.
Quest’ultime, se generate un’entity class da un db tramite un’IDE come Netbeans, saranno create direttamente dall’IDE, di seguito potete vederne un’esempio.

La classica namedquery che troverete di sicuro in un entity bean appena generato sarà la classica “NomeTabella.findAll” che come potete immagginare farà una semplice query estraendo tutto il contenuto della tabella.
Ora vediamo come chiamare da un session bean questa named query e restituirne il risultato.
E’ gia presente nel progetto la classe UserServeBean nella quale avevamo creato il metodo che creava l’utente, ora andremo a creare un metodo che ci restituirà una lista di tutti gli utenti e naturalmente non possiamo che chiamarlo UserList che ritornerà un ogetto di tipo List.
Come prima cosa all’interno del metodo dobbiamo inizializzare un EntityManager utilizzando la Factory, successivamente inizializziamo un oggetto di tipo Query attraverso l’Em nel modo seguente.
public List UserList(){ EntityManager em=emf.createEntityManager(); Query q=em.createNamedQuery("Users.findAll");
Facciamo atenzione ad importare l’oggetto query del package Persistence altrimenti potreste scervellarvi e pensare che il vostro ide ami troppo le sottolineature rosse..

Ora non dobbiamo fare altro che chiedere all’ogetto query appena creato di eseguire l’interrogazione e ritornarci la lista dei risultati.

public List UserList(){ EntityManager em=emf.createEntityManager(); Query q=em.createNamedQuery("Users.findAll"); List l=q.getResultList(); return l; }

Attenzione! Una volta completato il metodo non dimenticatevi di esporlo sull’interfaccia utile, in questo caso sulla remota.

A questo punto possiamo spostarci sul progetto war e creare una servlet che ci stampi a video la lista ritornata dal metodo.
Tasto destro sul package servlet del progetto Create new->Servlet e nella finestra di dialogo diamo il nome UsersList alla servlet, mi raccomando cliccate su next e ,se non lo è, selezionate la casella che vi dice di aggiungere la servlet al descriptor.
Ora nel corpo della select richiamiamo il nostro session bean facendo tasto destro->InsertCode->callEnterpriseBean selezionando l’interfaccia remota.
A questo punto inizializziamo un oggetto list chiamando il metodo sul SessionBean che abbiamo creato precedentemente.

List lista=userServeBean.UserList();

A questo punto possiamo processare la lista con un ciclo e stampare l’output a video ricordando che la nostra lista è fatta di ogetti di tipo Users e come tali vanno trattati.

protected void processRequest(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException { response.setContentType("text/html;charset=UTF-8"); PrintWriter out = response.getWriter(); try { List list=userServeBean.UserList(); ListIterator it=list.listIterator(); out.println(""); out.println(""); out.println("<a href="http://www.rmhomepages.com/blog/tag/servlet/" class="st_tag internal_tag" rel="tag" title="Post marcati con servlet">Servlet</a> UserList"); out.println(""); out.println(""); while(it.hasNext()){ Users temp=it.next(); out.println(" -Nome: "+temp.getName()+" -Cognome: "+temp.getSurname()+" -Email: "+temp.getEmail()); out.println(" ------------------------------------------------------- "); } out.println(""); out.println("");

} finally {
out.close();
}
}

Ora facciamo un clean and build e poi deployamo il tutto, andiamo all’indirizzo contenente la servlet nel mio caso /UsersList
e se tutto è andato bene dovremmo vedere una pagina come questa.

Potete scaricare l’esempio completo delle aggiunte di questo tutorial qui

Nel prossimo tutorial affronterò il passaggio di parametri alle namedQuery e il modo corretto di crearne di nuove.

Segnala presso:

Java Enterprise Tutorial – Getting Started – Parte 2

Mauro Rocco — Sun, 26 Apr 2009 18:14:40 +0000

Ora creiamo un package nel nostro modulo EJB facendo click destro su source Packages e poi su New->Package e chiamiamolo entity; successivamente, facendo click destro sul package appena creato, selezioniamo create new entity class from databases.
Nella finestra di dialogo selezioniamo la tabella user e clicchiamo su add e poi next, a questo punto ci viene chiesto come vogliamo chiamare la classe e in quale package posizionarla, lasciamo tutto di default e clicchiamo su finish.
Questa che è stata creata non è altro che una classe java che rispecchia la nostra tabella Users del DB, è per questo motivo che questi tipi di classi vengono chiamate Entity Bean proprio perchè rappresentano entità, ovvero copie in memoria di dati persistenti in una struttura dati.
Analizzando il codice potrete vedere che, a differenza di una normale classe java, sono presenti delle annotazioni precedute dalla @: queste servono a comunicare all’application server, e di conseguenza al gestore della persistenza, il legame tra l’oggetto e la relativa tabella del db.

Non possiamo entrare nel dettaglio delle annotazioni altrimenti ci dilungheremmo troppo: chiunque volesse soddisfare la propria curiosità si può rifare alla specifiche sun.
Ora creiamo il nostro primo session Bean, creiamo un nuovo package cliccando con il tasto destro su source->packages e chiamiamolo session, facciamo click destro su quest’ultimo e selezioniamo New->Session Bean.
Chiamiamo il nostro bean UserServe, lasciamo la spunta su stateless, spuntiamo entrambe le voci Remote e Local e clicchiamo su finish.
Abbiamo appena creato un session less bean ovvero un bean che non mantiene nessun valore in memoria e può essere usato contemporaneamente da più bean senza avere un rapporto uno ad uno con questi ultimi.
Noterete che sono stati creati tre file, uno è UserServeBean, l’oggetto vero e proprio in cui implementeremo i nostri metodi, e gli altri due sono le sue interfacce, una per accessi locali, ovvero dall’interno dello stesso modulo EJB, e uno per accessi remoti, ovvero dall’esterno del modulo.
Ora posizioniamoci con il mouse all’interno della classe appena creata e noteremo un commento
// Add business logic below. (Right-click in editor and choose
// “Insert Code > Add Business Method” or “Web Service > Add Operation”)
Seguiamo la prima indicazione, ovvero aggiungiamo un business method, in realtà possiamo scrivere il nostro metodo a mano, ma poi dovremmo riportarlo nelle due interfacce: usando questo tool, invece, esso verrà riportato nelle interfacce automaticamente.
Nella finestra di dialogo creiamo un metodo chiamato createUser passandogli come parametri i dati di un utente, esclusa la chiave, come tipo di ritorno settiamo boolean: ricordiamoci di spuntare il radio button in basso “Remote” e clicchiamo su finish.

Ora che abbiamo creato lo scheletro del nostro primo metodo bisognerà implementare l’effettiva scrittura: trattandosi di strumenti enterprise non dovremmo scrivere nessuna query, il tutto verrà demandato all’unità di persistenza.
Prepariamoci ad utilizzare l’EntityManager importando i seguenti pckages:

import javax.persistence.EntityManager;
import javax.persistence.EntityManagerFactory;
import javax.persistence.PersistenceUnit;

Ora diciamo al nostro bean come si chiama la persistence unit, prepariamo una variabile di tipo EntityManagerFactory e all’interno del nostro metodo inizializziamo una variabile di tipo EntityManager utilizzando la factory definita in precedenza.

Ora non resta altro che creare un oggetto di tipo Users con i parametri che ci vengono passati.
Ricordiamo di importare entity.Users ed utilizziamo il costruttore del nostro entity bean per creare l’oggetto.
Successivamente chiamiamo il metodo persist sull’oggetto EntityManager passandogli l’oggetto users appena creato.

Come potete notare il metodo persist è void ovvero non ci fornisce nessun ritorno di tipo boolean: per sapere se l’operazione è andata a buon fine bisogna intercettare le quattro possibili eccezioni che possono generarsi in questo tipo di contesto

EntityExistsException
IllegalStateException
IllegalArgumentException
TransactionRequiredException
Catturiamo le eccezioni con un try catch e all’interno dei vari catch valorizziamo una variabile booleana a false in modo da avere un ritorno negativo se si verifica una qualsiasi delle quattro eccezioni.
Di seguito potete vedere lo screenshot del metodo completo.

Ora possiamo dire che abbiamo creato il nostro primo modulo EJB funzionante, non ci resta che creare un Servlet sul progetto WAR che invochi il metodo CreateUser.
Spostiamoci sul progetto WAR e creiamo un nuovo package nella cartella source packages chiamandolo servlet, facendo clic destro su quest’ultimo selezioniamo New->Servlet, nella finestra di dialogo chiamiamo la nostra servlet doCreateUser, clicchiamo su next e nella finestra successiva lasciamo tutto com’è e clicchiamo su finish.
Abbiamo appena creato una servlet che sarà accessibile da browser con il nome /doCreateUser: non è lo scopo di questo tutorial spiegare cos’è una servlet o una pagina JSP, difatti si suppone che l’utente dovrebbe già averne una conoscenza sufficiente per affrontare l’apprendimento della tecnologia Enterprise.
Ora facciamo click destro all’interno della classe e andiamo su InsertCode->Call Enterprise Bean, nella finestra di dialogo selezioniamo il bean, spuntiamo il radio button remote e clicchiamo ok.
Ora ci viene resa disponibile una variabile chiamata userServeBean di tipo UserServeRemote sulla quale possiamo chiamare il metodo createUser ed intercettarne il ritorno per stamparne l’esito a video.
Di seguito ecco il codice completo del metodo processRequest della servlet.

Prima di eseguire un test, sopratutto se utilizzate windows, è probabile che il connector mysql non sia presente in glassfish; per ovviare alla mancanza è sufficiente copiare il JAR di cui abbiamo parlato all’inizio del tutorial nella cartella lib del dominio in uso appartenente a glassfish
(Percorso di esempio : C:/Programmi/GlassfishV2/domains/domain1/lib)
Ora possiamo cliccare con il tasto destro sul progetto principale e selezionare Deploy, a questo punto netbeans creerà i pacchetti necessari e ne farà il deploy automatico su glassfish che nel frattempo verrà avviato.
Nelle finestra output in basso è presente la tab GlassFishV2 che stampa l’output dell’application server, in caso di errore è in quest’ultima che potremo leggere i dettagli di eventuali eccezioni.
Se tutto è andato a buon fine dovrebbe apparire nella finestra output un BUILD SUCCESFULL:
ora possiamo lanciare il progetto cliccando sulla freccia verde in alto oppure con il tasto destro sul progetto principale MyFirstJEE e poi Run.
Si aprirà il browser di default del sistema mostrando una pagina Hello Word!
Ora che il nostro dominio web è avviato non dobbiamo far altro che richiamare la nostra servlet aggiungendo all’url “doCreateUser” sperando che la finestra che vi verrà mostrata sia questa:

Bene, siamo arrivati alla fine di questo primo tutorial, che spero vi sia servito a prendere dimestichezza con l’ambiente enterprise e che sopratutto sia stato un utile esercizio per cominciare a comprenderne le logiche.
Restano ancora da affrontare argomenti basilari come l’estrazione dei dati attraverso le NamedQuery o attraverso le NativeQuery e come utilizzare, e quando, un bean di tipo session full: ma questi saranno argomenti per un altro tutorial.
In caso di problemi postate pure un commento e sarò felice di aiutarvi!!
Vi ricordo che potete scaricare il progetto netbeans completo di questo tutorial cliccando qui!

Segnala presso:

Java Enterprise Tutorial – Getting Started – Parte 1

Mauro Rocco — Sun, 26 Apr 2009 18:04:40 +0000

Prima di iniziare bisogna attrezzarsi del necessario, innanzi tutto un DBMS, nel mio caso MySQL se non ne siete forniti scaricate il Server e magari anche il GUI Tool dal sito mysql.com.

MySQL community server
http://dev.mysql.com/downloads/mysql/

MySQL guiTools (interfaccia grafica per gestire i database)
http://dev.mysql.com/downloads/gui-tools

Ora forniamoci della JDK 6.0 o successive scaricandola dal sito sun
http://java.sun.com/javase/downloads/index.jsp

Ed ora possiamo scaricare il nostro IDE Netbeans dal sito ufficiale, mi raccomando bisogna scaricare le versioni con il Bundled server GlassFish v2, vi consiglio di scaricare la versione completa di tutti i supporti così da non avere problemi.
http://www.netbeans.org/downloads/index.html

Partiamo dal livello base.
Ogni sistema distribuito che si rispetti deve essere accessibile da una serie di utenti con diversi permessi e responsabilità, quindi quello che faremo è creare il nostro semplice database di utenti con il minimo indispensabile.
Qui potete scaricare il dump SQL da importare con MySQL Administrator oppure ricreare la struttura come illustrata di seguito:

dump

Ora apriamo Netbeans e andiamo su File->New Project, selezioniamo la cartella Java EE e nella finestra di destra selezioniamo la prima voce “Enterprise Application” e clicchiamo su next.
Ora diamo un nome al nostro progetto, nel mio caso “MyFirstJEE”, ignoriamo la voce “Use dedicated folder for storing libraries”, spuntiamo la casella “Set as main project” per lavorare più comodamente e clicchiamo next.
Lasciamo selezionato come application server Glassfish V2 e spuntiamo, se non lo sono già, le caselle “Create EJB Module” e “Create Web Application Module”.
Non spuntiamo la casella “Create Application client Module” in quanto la creazione di un client stand alone per applicazioni enterprise è un argomento che merita di essere approfondito in un tutorial dedicato.
Cliccando su finish dovremmo trovarci davanti ad una struttura come questa.

NetBeans ci mostra i componenti della nostra applicazione come progetti diversi come è giusto che sia, il primo con il triangolo rappresenta l’applicazione Enterprise vera e propria, cioè quella che contiente il modulo ejb e il modulo war, infatti espandendo il nodo Java EE Modules noterete proprio i due componenti come parti del progetto.
In realtà il modulo EJB come quello WAR potrebbero far parte di un’altra applicazione Enterprise o di altre 1000; naturalmente il loro riutilizzo dipende dalla generalità degli stessi che non è sempre scontata se non si pone la dovuta attenzione nello sviluppo.
Entrando più nel dettaglio possiamo vedere il modulo EJB come il core della nostra applicazione: è questo che si occupa di interfacciarsi con le strutture dati e che fornisce i principali metodi di controllo ed accesso definendo lo scheletro portante dell’intero sistema.
Il progetto WAR è un client web quindi possiamo vederlo come un classico sito web, l’unica reale differenza sta nel fatto che esso non accederà mai direttamente alle strutture dati ma potrà interrogare solo il modulo EJB lasciando a quest’ultimo il compito di gestire l’accesso condiviso alle strutture dati e di conseguenza la loro consistenza ed integrità.

La prima cosa da fare prima di scrivere il nostro primo BEAN è quella di fornire al nostro ambiente di sviluppo e al nostro Application Server la conoscenza della nostra struttura dati.
Nelle tab in altro a sinistra clicchiamo su Services, nell’elenco sottostante facciamo clic destro sul nodo Databases e clicchiamo su new connection.
In questa finestra dal menu a tendina Name selezioniamo MySQL, attenzione nel caso non sia disponibile sarà necessario installare il driver scaricandolo da sito mysql a questo indirizzo

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

Installatelo espandendo il nodo databases e cliccando con il tasto destro sul nodo drivers e poi su add driver, dalla finestra di dialogo selezionate il JAR del connector appena scaricato ed il gioco è fatto.

Ritorniamo alla finestra di dialogo, inseriamo tutti i parametri necessari alla connessione al DB, nel mio caso sono i seguenti:

Ora, se tutto è andato a buon fine e i parametri sono giusti, dovremmo poter vedere all’interno del nodo databases la nostra connessione con la relativa visualizzazione della tabella e dei campi.
Netbeans ci permette, inoltre, di visualizzare i dati presenti nel db cliccando semplicemente con il tasto destro sulla tabella in questione e poi sulla voce view data, verrà aperta una finestra con la query eseguita ed i relativi risultati.

Ora che la connessione è stata creata torniamo a visualizzare la lista dei progetti e clicchiamo con il tasto destro sul progetto MyFirstJee-ejb poi su New->Other.
Nella finestra di dialogo selezioniamo la categoria persistence e dalla finestra di destra la voce Database Schema.
Chiamiamo il nostro schema come preferiamo, nel mio caso mySchema, e clicchiamo su next, nella finestra successiva selezioniamo la connessione creata in precedenza ed andiamo avanti.
Ora vi verrà chiesto quali tabelle vogliamo aggiungere allo schema, nel nostro caso ne abbiamo solo una, selezioniamola, clicchiamo su add e quindi su finish.
Il file schema è stato creato nel nodo configuration files del nostro modulo ejb.
Il prossimo passo è la creazione di una persistence unit ovvero un’ unità inglobata nell’application server che si occuperà di gestire la persistenza dei dati sul db e l’accesso condiviso in maniera completamente automatica.
Clicchiamo con il tasto destro sul progetto MyFirstJee-ejb poi su New->Persistence Unit, nella finestra di dialogo lasciamo il nome e la libreria di defualt e settiamo la voce Table generation strategy a none, ovvero diciamo alla persistence unit di non creare le tabelle ogni volta che viene eseguita l’applicazione ma di non generare le tabelle visto che non ne abbiamo necessità.
Prima di finire dal menu a tendina DataSource clicchiamo su new data source e chiamiamolo myfirstjeeconnection scegliendo la connessione al nostro db.
Cliccando su finish noterete che quello che abbiamo fatto non è stato altro che scrivere un file XML di configurazione che servirà a dire all’application server come gestire le operazioni sul database e con quale libreria di persistenza, noterete in basso una spunta “Include all entities classes in …”: questa specifica che tutti gli Entity Beans che andremmo a creare saranno gestiti dall’unità di persistenza.

Vai alla seconda parte del tutorial ->

Segnala presso: