Mauro Rocco programming zone » Java Enterprise 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’ 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 .
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’ Netbeans 6.5.

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

@(name = "Users.like", = "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 , 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 prepariamo un metodo per richiamarla in un session , utilizziamo sempre lo stesso chiamato “UserServeBean” e creiamo un metodo UsersLike così scritto.

public List UsersLike(String value){
EntityManager em=emf.createEntityManager();
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 creiamo una che invocherà il metodo, chiamiamola UsersLike, essa rivecerà un parametro in POST e lo passerà al metodo restituendo la lista dei risultati.

package ;
import entity.Users;
import .io.IOException;
import .io.PrintWriter;
import .util.List;
import .util.ListIterator;
import javax..;
import javax..ServletException;
import javax..http.HttpServlet;
import javax..http.HttpServletRequest;
import javax..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> 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 .
Per creare una pagina JSP è sufficiente fare click destro nel WAR 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 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 Java Enterprise Tutorial – Introduzione alle Named Query http://www.rmhomepages.com/blog/2009/05/java-enterprise-tutorial-introduzione-alle-named-query/ http://www.rmhomepages.com/blog/2009/05/java-enterprise-tutorial-introduzione-alle-named-query/#comments Fri, 29 May 2009 22:01:31 +0000 Mauro Rocco http://www.rmhomepages.com/blog/?p=88 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 del db usato nei tutorial che potete scaricare cliccando qui.

Nel seguente tutorial affronteremo come “eseguire delle query” in un contesto 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 , saranno create direttamente dall’IDE, di seguito potete vederne un’esempio.

namedquery1

La classica namedquery che troverete di sicuro in un 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 questa 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.. :-)

import_query

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.

remote_method1

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 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<Users> list=userServeBean.UserList();
ListIterator<Users> it=list.listIterator();
out.println("<html>");
out.println("<head>");
out.println("<title>Servlet UserList</title>");
out.println("</head>");
out.println("<body>");
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();
}
}

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.

lista

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.

]]> http://www.rmhomepages.com/blog/2009/05/java-enterprise-tutorial-introduzione-alle-named-query/feed/ 0 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 (commit) 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 EJB,  di un JMS messages e naturalmente di un’entity EJB.

La propagazione delle transazioni attraverso gli EJB è silente e automatica. Ogni avrà un identificatore oltre ad altre informazioni allegate.
Un metodo chiamato su un EJB trasferirà automaticamente le informazioni di da un EJB 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 EJB 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 EJB 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 BEAN.
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 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 .
Ora creiamo il nostro primo session , 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 .
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 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 WAR che invochi il metodo CreateUser.
Spostiamoci sul progetto WAR 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 JSP, difatti si suppone che l’utente  dovrebbe già averne una conoscenza sufficiente per affrontare l’apprendimento della tecnologia .
Ora facciamo click destro all’interno della classe e andiamo su InsertCode->Call , 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 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 netbeans 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 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 netbeans 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
http://java.sun.com/javase/downloads/index.jsp

Ed ora possiamo scaricare il nostro 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

dump

Ora apriamo Netbeans 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 Glassfish 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

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 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 BEAN è quella di fornire al nostro ambiente di sviluppo e al nostro 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.
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 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 persistence unit ovvero un’ unità inglobata nell’ 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->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’ 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 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 Java Enterprise Edition JEE http://www.rmhomepages.com/blog/2009/04/3/ http://www.rmhomepages.com/blog/2009/04/3/#comments Sun, 19 Apr 2009 21:12:19 +0000 Mauro Rocco http://www.rmhomepages.com/blog/?p=3 Citando letteralmente wikipedia

“J2EE (dall’inglese 2 Edition) è la versione della piattaforma . Essa è costituita da un insieme di specifiche che definiscono le caratteristiche e le interfacce di un insieme di tecnologie pensate per la realizzazione di applicazioni di tipo e mission critical. Chiunque può realizzare una implementazione di tali specifiche e produrre application server compatibili con le specifiche J2EE“.

Io aggiungo che, come giustamente dice il sito SUN, la tecnologia è pensata esclusivamente per lo sviluppo di applicazioni server-centric e multitier.

Ad esempio, per creare il nostro software server-side non dovremmo più preocupparci di scrivere il nostro “server” in utilizzando magari le RMI, questa parte viene totalmente lasciata ad un “Application Server” che si occuperà proprio della comunicazione dei dati tra l’applicazione client e il server.
Inoltre esso si occuperà anche dell’interfacciamento con un generico database rendendo l’applicazione completamente indipendente dal tipo di DBMS utilizzato.

Parlando di tecnologia dobbiamo naturalmente citare l’effettiva implementazione ovvero il “Bean”.
I beans sono i componenti che implementano il lato server, ovvero logica di business nell’architettura j2ee.
Sono sempre degli oggetti ma devono essere sviluppati seguendo rigidamente delle specifiche che serviranno poi a comunicare all’application server come gestire l’oggetto.

Copiamo un altro pò da wikipedia, precisando che di seguito il termine “contenitore” specifica una particolare parte dell’application server.
“Esistono tre tipi di :

– di Entità (Entity ): il suo scopo è di inglobare gli oggetti sul lato server che memorizzano i dati. Gli entity bean forniscono la caratteristica della persistenza dei dati:
o Persistenza gestita dal contenitore (CMP): il contenitore si incarica della memorizzazione e del recupero dei dati relativi a un oggetto utilizzando una tabella di una base di dati.
o Persistenza gestita dal bean (BMP): in questo caso è il bean a occuparsi del salvataggio e recupero dei dati a cui fa riferimento, il salvataggio può avvenire in una base di dati o con qualsiasi altro meccanismo perché è il programmatore che si incarica di realizzare il meccanismo della persistenza dei dati.
- di sessione (Session ): gestiscono l’elaborazione delle informazioni sul server. Generalmente sono una interfaccia tra i client e i servizi offerti dai componenti disponibili sul server. Ne esistono di due tipi:
o con stato (stateful). I bean di sessione con stato sono oggetti distribuiti che posseggono uno stato. Lo stato non è persistente, però l’accesso al bean è limitato ad un unico client.
o senza stato (stateless). I bean di sessione senza stato sono oggetti distribuiti senza uno stato associato, questa carattestistica permette un accesso concorrente alle funzionalità offerte dal bean. Non è garantito che il contenuto delle variabili di istanza si conservi tra diverse chiamate ai metodi del bean.
- guidati da messaggi (Message driven EJBs): sono gli unici bean con funzionamento asincrono. Tramite il Message Service (JMS), si iscrivono a un argomento (topic) o a una coda (queue) e si attivano alla ricezione di un messaggio inviato all’argomento o alla coda a cui sono iscritti. Non richiedono una istanziazione da parte dei client“.

Il tutto, anche se siete dei profondi conoscitori della OOP, potrebbe sembrarvi un pò aleatorio, ma addentrandosi nella tecnologia e provando ad utilizzarla molti concetti si chiariranno rendendo evidenti le potenzialità della stessa.

Questo è in realtà solo la punta dell’iceberg, tutto ciò che è “nodo critico” di un’applicazione distribuita viene lasciata il più possibile alla gestione dell’Application Server limitando l’intervento del programmatore, questo potrebbe sembrare una mancanza di libertà ma in realtà è sempre possibile prendersi i propri rischi e “mettere le mani in pasta”.
Il tutto serve effettivamente ad “Aggiungere capacità che provvedono ad una completa,stabile,sicura e veloce applicazione per l’impresa“.

Ma ora provo a rispondere ad una domanda dal così detto milione di dollari!
Quando effettivamente è necessarrio utilizzare una tecnologia simile?

A mio modesto parere la sconsiglierei vivamente se la nostra unica interfaccia deve essere il WEB, ovvero anche se abbiamo il nostro megaportale con tanti megaservizi il cui unico canale di interfaccia è il WEB la J2EE è effettivamente “Sprecata” o per meglio dire “Inadeguata”, ci sono molte altre tecnologie che offrono comunque costi in termini di “tempo di sviluppo” sicuramente minori e sopratutto offrono un’automazione in quelle fasi critiche dei sistemi web come templating system ed admin area.

Deve essere effettivamente utilizzata quando il nostro sistema avrà utilizzatori con diverse necessità e con diverse interfacce, un esempio lampante che rende davvero l’idea è quello utilizzato nel libro “ JavaBeans” di Monson-Haefel Richard in cui tutto il testo è incentrato su una grande compagnia di crociera immaginaria, la Titan, che attraverso la tecnologia J2EE riesce a gestire i sistemi di approvvigionamento, manutenzione e addirittura il sito web per le prenotazioni delle cabine, utilizzando lo stesso software server e massimizzando il riutilizzo di moduli ed oggetti comuni alle diverse interfacce ed utilizzatori.
Ad oggi non consiglio comunque il libro che si rifà alle specifiche 2.0 che sono davvero ostiche e di non semplice utilizzo; dalle 2.0 in poi, invece, il costo di apprendimento penso sia devvero giustificato dal quadagno effettivo in termini di semplicità e velocità di sviluppo.

Infine volevo specificare che l’”Application server”, che deve necessariamente far parte della tecnologia, può variare e ne possono essere usati di diversi (NewtWeaver di SAP, JEUS 6 di TmaxSoft)
Io consiglio comunque l’utilizzo dell’application server open source di casa sun chiamato davvero di facile uso e configurazione e come se non bastasse con una splendida integrazione tra quest’ultimo e l’amato IDE “”, sempre prodotto SUN.

]]> http://www.rmhomepages.com/blog/2009/04/3/feed/ 4