Mauro Rocco programming zone » bean http://www.rmhomepages.com/blog Solo un altro blog targato WordPress Sat, 24 Apr 2010 09:59:53 +0000 http://wordpress.org/?v=2.8.2 en hourly 1 Java Enterprise Tutorial – Named query parametriche http://www.rmhomepages.com/blog/2009/06/java-enterprise-tutorial-named-query-parametriche/ http://www.rmhomepages.com/blog/2009/06/java-enterprise-tutorial-named-query-parametriche/#comments Mon, 01 Jun 2009 08:11:51 +0000 Mauro Rocco http://www.rmhomepages.com/blog/?p=110 Nel seguente tutorial non porremo troppa attenzione sugli aspetti riguardandi l’IDE o la creazione di file e classi ma solo sugli aspetti più dettagliati del codice, di conseguenza si presume che il lettore dovrebbe già avere una conoscenza di base del contesto Enterprise.
Se volete un’infarinatura potete seguire il tutorial base sul mio blog.
Vi ricordo, inoltre, che il progetto di esempio e tutti i riferimenti all’ambiente di sviluppo sono da riverirsi a l’IDE Netbeans 6.5.

Dopo l’introduzione alle named query, vediamo più nel dettaglio il loro funzionamento.
Nel caso volessimo una classica query di selezione, discriminando in base ad uno o più valori, possiamo preparare una named query personalizzata che accetti i parametri necessari.
Facendo sempre riferimento al progetto oggetto del tutorial di introduzione alle named query modifichiamo l’ “Users” aggiungendo una named query per eseguire una LIKE sul campo name.
Sriviamo la query in questo modo aggiungendola alla lista delle altre named query ricordandoci che il separatore tra le named query è la virgola.

@NamedQuery(name = "Users.like", query = "SELECT u FROM Users u WHERE u.name LIKE :name")

Come si può notare la stringa :name verrà sostituita dal parametro che andremo a settare prima dell’esecuzione della query, utilizzando l’etichetta “name” potremo infatti assegnare un valore arbitrario.
Volendo avremmo anche potuto mettere al posto della stringa :name la stringa :1 utilizzando la notazione posizionale e quindi passare i parametri in ordine invece che in base ad un etichetta.

Una volta aggiunta la nostra named query prepariamo un metodo per richiamarla in un , utilizziamo sempre lo stesso bean chiamato “UserServeBean” e creiamo un metodo UsersLike così scritto.

public List UsersLike(String value){
EntityManager em=emf.createEntityManager();
Query q=em.createNamedQuery("Users.like");
q.setParameter("name", value);
List l=q.getResultList();
return l;
}

Poniamo la nostra attenzione sulla riga q.setParameter(”name”, value); in questo modo andiamo a settare all’etichetta “name” il valore passato al metodo identificato dalla variabile value.
Per verificare il corretto funzionamento della query creiamo una servlet che invocherà il metodo, chiamiamola UsersLike, essa rivecerà un parametro in POST e lo passerà al metodo restituendo la lista dei risultati.

package servlet;
import entity.Users;
import .io.IOException;
import .io.PrintWriter;
import .util.List;
import .util.ListIterator;
import javax..;
import javax.servlet.ServletException;
import javax.servlet.http.HttpServlet;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
import session.UserServeRemote;
/**
*
* @author Mauro the King
*/
public class UsersLike extends HttpServlet {
@
private UserServeRemote userServeBean;
protected void processRequest(HttpServletRequest request, HttpServletResponse response)
throws ServletException, IOException {
response.setContentType("text/html;charset=UTF-8");
PrintWriter out = response.getWriter();
String value = request.getParameter("value");
try {
List<Users> list = userServeBean.UsersLike(value+"%");
ListIterator<Users> it = list.listIterator();
out.println("<html>");
out.println("<head>");
out.println("<title>Servlet UserList</title>");
out.println("</head>");
out.println("<body>");
if (list.size() == 0) {
out.println("Nessun risultato");
} else {
while (it.hasNext()) {
Users temp = it.next();
out.println("<br>-Nome: " + temp.getName() + "<br>-Cognome: " + temp.getSurname() + "<br>-Email: " + temp.getEmail());
out.println("<br>----------------------------<br>");
}
}
out.println("</body>");
out.println("</html>");
} finally {
out.close();
}
}
@Override
protected void doGet(HttpServletRequest request, HttpServletResponse response)
throws ServletException, IOException {
processRequest(request, response);
}
@Override
protected void doPost(HttpServletRequest request, HttpServletResponse response)
throws ServletException, IOException {
processRequest(request, response);
}
@Override
public String getServletInfo() {
return "Short description";
}// </editor-fold>
}

Non ci resta che creare una pagina JSP con una bella form che invii in POST una variabile value alla servlet.
Per creare una pagina JSP è sufficiente fare click destro nel project sulla cartella Web Pages e poi ->Nuovo->JSP.
Chiamiamo la pagina searchUser e inseriamo un form con un campo di testo e un pulsante, in questo modo.


<%@page contentType="text/html" pageEncoding="UTF-8"%>
<!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>JSP Page</title>
</head>
<body>
<form action="UsersLike" method="POST">
<input type="text" name="value" size="20"><br>
<input type="submit" value="CERCA">
</form>
</body>
</html>

Ora non ci resta che provare, buildiamo e deployamo il tutto e proviamo a fare una ricerca spostandoci sulla pagina searchUser.jsp, inserite una stringa qualsiasi ricordando che la servlet aggiungerà alla stringa inserita il valore ‘%’ in modo da ottenere come risultato tutti gli utenti che hanno il nome che inizia per la chiave inserita.
Ricordate di scaricare il dump del database usato per questo tutorial ,se non lo avete già fatto, e di inserire qualche record all’interno del db :-) prima di effettuare il test.
Potete, come sempre, scaricare il progetto di esempio completo dei contenuti del seguente tutorial.

]]> http://www.rmhomepages.com/blog/2009/06/java-enterprise-tutorial-named-query-parametriche/feed/ 9 Transazioni in JEE – Concetti http://www.rmhomepages.com/blog/2009/04/transazioni-in-jee-concetti/ http://www.rmhomepages.com/blog/2009/04/transazioni-in-jee-concetti/#comments Wed, 29 Apr 2009 20:35:09 +0000 Mauro Rocco http://www.rmhomepages.com/blog/?p=60 Una è un’indivisibile unità di lavoro che deve completare con il successo di ogni singola operazione, se questo non avviene essa deve essere abbandonata e tutti gli elementi coinvolti devono tornare allo stato iniziale.

Normalmente, si parla di nel contesto dei dbms dove essa consiste in un insieme di istruzioni di update al database che vengono effettivamente eseguite tutte insieme () se nessuna di esse è fallita, in caso contrario il database viene riportato allo stato iniziale ().

Nel contesto , invece, le transazioni possono includere altre risorse dati, come una variabile di stato di uno stateful session ,  di un JMS messages e naturalmente di un’entity .

La propagazione delle transazioni attraverso gli è silente e automatica. Ogni avrà un identificatore oltre ad altre informazioni allegate.
Un metodo chiamato su un trasferirà automaticamente le informazioni di da un all’altro, ache se esso risiede in un altro container o addirittura su un altro server con supporto .
Il tutto è possibile grazie al protocollo (Internet Inter-ORB Protocol), ovvero un richiede un ogetto specificando un nome univoco a un altro server attraverso il protocollo CORBA, come di solito fa un client stand alone per richiamare un modulo su un server.

L’ ha un gestore delle transazioni (a volte chiamato monitor) che memorizza i dati di ogni oggetto coinvolto in una in modo da essere in grado di riportare tutto allo stato iniziale in caso di fallimento.

Attraverso l’ è possibile regolare vari livelli di isolamento delle transazioni a seconda del contesto in cui ci si trova, potrebbe infatti capitare di avere situazioni in cui più transazioni devono accedere agli stessi oggetti e in alcuni casi, se si è sicuri che questo non provochi inconsistenza, si può permettere l’accesso nonostante un’altra in corso.

Naturalmente le transazioni devono sempre rispettare le classiche e famose proprietà (Atomic,Consistent,Isolated,Durable) .

Come la persistenza anche le transazioni, in ,  possono essere gestite o dal container o dal .
Nel primo caso il programmatore non deve implementare manualmente il codice necessario alla gestione della ma essa viene definita dal descriptor xml e gestita dal server, nella maggior parte delle circostanze è utilizzabile questo tipo di .

In conclusione con la tecnologia Enterprise è possibile, grazie al completo controllo dell’, strutturare transazioni complesse e distribuite su tipi di dati diversi con un notevole risparmio in termini di complessità e tempo, sopratutto grazie all’utilizzo di IDE che automatizzano il building dei descrittori XML esonerando il programmatore da questa incombenza.

]]> http://www.rmhomepages.com/blog/2009/04/transazioni-in-jee-concetti/feed/ 0 Java Enterprise Tutorial – Getting Started – Parte 2 http://www.rmhomepages.com/blog/2009/04/java-enterprise-tutorial-getting-started-parte-2/ http://www.rmhomepages.com/blog/2009/04/java-enterprise-tutorial-getting-started-parte-2/#comments Sun, 26 Apr 2009 18:14:40 +0000 Mauro Rocco http://www.rmhomepages.com/blog/?p=28 Ora creiamo un package nel nostro modulo 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 che rispecchia la nostra tabella Users del DB, è per questo motivo che questi tipi di classi vengono chiamate Entity 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 , sono presenti delle annotazioni precedute dalla @: queste servono a comunicare all’, e di conseguenza al gestore della persistenza, il legame tra l’oggetto e la relativa tabella del db.

firstclass

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 , creiamo un nuovo package cliccando con il tasto destro su source->packages e chiamiamolo session, facciamo click destro su quest’ultimo e selezioniamo New->.
Chiamiamo il nostro UserServe, lasciamo la spunta su stateless,  spuntiamo entrambe le voci Remote e Local e clicchiamo su finish.
Abbiamo appena creato un session less ovvero un che non mantiene nessun valore in memoria e può essere usato contemporaneamente da più 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 , 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.

metodo

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 come si chiama la , prepariamo una variabile di tipo EntityManagerFactory e all’interno del nostro metodo inizializziamo una variabile di tipo EntityManager utilizzando la factory definita in precedenza.

emanager

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 per creare l’oggetto.
Successivamente chiamiamo il metodo persist sull’oggetto EntityManager passandogli l’oggetto users appena creato.

persist1

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.

classe_completa

Ora possiamo dire che abbiamo creato il nostro primo modulo funzionante, non ci resta che creare un sul progetto che invochi il metodo CreateUser.
Spostiamoci sul progetto e creiamo un nuovo package nella cartella source packages chiamandolo , facendo clic destro su quest’ultimo selezioniamo New->, nella finestra di dialogo chiamiamo la nostra doCreateUser, clicchiamo su next e nella finestra successiva lasciamo tutto com’è e clicchiamo su finish.
Abbiamo appena creato una che sarà accessibile da browser con il nome /doCreateUser: non è lo scopo di questo tutorial spiegare cos’è una o una pagina , 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 , nella finestra di dialogo selezioniamo il , 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 ; 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
(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 creerà i pacchetti necessari e ne farà il deploy automatico su che nel frattempo verrà avviato.
Nelle finestra output in basso è presente la tab GlassFishV2 che stampa l’output dell’, 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 aggiungendo all’url “doCreateUser” sperando che la finestra che vi verrà mostrata sia questa:

pagina

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 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 completo di questo tutorial cliccando qui!

]]> http://www.rmhomepages.com/blog/2009/04/java-enterprise-tutorial-getting-started-parte-2/feed/ 6 Java Enterprise Tutorial – Getting Started – Parte 1 http://www.rmhomepages.com/blog/2009/04/java-enterprise-tutorial-getting-started-parte-1/ http://www.rmhomepages.com/blog/2009/04/java-enterprise-tutorial-getting-started-parte-1/#comments Sun, 26 Apr 2009 18:04:40 +0000 Mauro Rocco http://www.rmhomepages.com/blog/?p=9 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 dal sito ufficiale, mi raccomando bisogna scaricare le versioni con il Bundled server 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

dump

Ora apriamo e andiamo su File->New Project, selezioniamo la cartella 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 V2 e spuntiamo, se non lo sono già, le caselle “Create 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.

schermata1

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 e il modulo , infatti espandendo il nodo EE Modules noterete proprio i due componenti come parti del progetto.
In realtà il modulo come quello 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 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 è 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 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 è 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:

parametri

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.
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.

select

Ora che la connessione è stata creata torniamo a visualizzare la lista dei progetti e clicchiamo con il tasto destro sul progetto MyFirstJee- 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 .
Il prossimo passo è la creazione di una 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- poi su New->, nella finestra di dialogo lasciamo il nome  e la libreria di defualt e settiamo la voce Table generation strategy a none, ovvero diciamo alla 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.

persistenceunit

Vai alla seconda parte del tutorial ->

]]> http://www.rmhomepages.com/blog/2009/04/java-enterprise-tutorial-getting-started-parte-1/feed/ 2