Buona Lettura!

Segnala presso:

Questo è il link.

Buon Android Event

Segnala presso:

Queste le principali novità di NetBeans 6.7

• supporto per il debugging remoto di Ruby On Rails;
• strumento di profiling DLight per progetti C++;
• supporto integrato per le librerie QT ed i relativi strumenti;
• integrazione ei servizi Hudson per i progetti Ant e Maven;
• librerie Struts migrate alla versione 1.3.8;
• distribuzione in bundle con Java Platform Micro Edition Software Development Kit 3.0;
• supporto per Java Card Platform 3.0;
• supporto completo per SVG Rich Components nel Visual Mobile Designer;
• miglioramenti all’ SVG Composer
• possibilità di creare progetti in hosting su Project Kenai direttamente dal’interno dell’IDE;
• gestire i progetti su Project Kenai e collaborare con gi altri sviluppatori;
• gestirei bug e le segnalazioni usando sia Jira che Bugzilla;
• integrazione completa con Project Kenai;
• visualizzazione del grafico delle dipendenze dele librerie di Maven;
• migliorato il plugin per il completamento del codice in Maven;
• supporto per Java EE e per la creazione ed il consumo di Web Services;
• supporto PHPUnit;
• completamento del codice SQL nell’editor PHP;
• istanza di Glassfish v3 Prelude con l’integrazione in Derby (Java DB) preconfigurata;
• supporto per il completamento del condice per Glassfish v3 Prelude;
• supporto Out-of-the-box per Grails 1.1;
• completamento del codice per Grails, Groovy e Grails;

Per saperne di più questa è la pagina dell’Annuncio Ufficiale e le Note di Rilascio

Segnala presso:

Usa anche un sistema di cache XML per evitare che si superino le 100 richieste in un ora, limite imposto da twitter per evitare il sovraccarico dei server.

Ne potete vedere una demo qui http://ptwix.toforge.com?p=demo

Scrivo questa guida all’installazione in italiano qui sul mio blog  in quanto il sito ufficiale ho deciso di lasciarlo solo in lingua inglese.

Bando alle ciance e partiamo!!!
Scaricate l’archivio che preferite all’indirizzo http://ptwix.toforge.com?p=download e posizionate la cartella ptwix ovunque volete sul vostro server.
Poniamo l’attenzione sulla cartella cache all’interno del package ptwix, questa è la cartella di default per contenere i file di cache, e naturalmente deve avere i permessi di scrittura.

Non dovete per forza usare questa cartella ma una qualsiasi sul vostro server e in qualsiasi posizione.
Ora aprite il file ptwix_reader.php che si trova nella cartella as e modificate le seguenti righe

$username="yourtwitterusername";
$password="yourtwitterpassword";
$url_path="http://www.mysite.com/ptwix/";
$cache_folder="/var/www/examplesite/ptwix/cache/";

I primi due parametri sono le credenziali di autenticazione del vostro account twitter, l’url path e la path url assoluta che punta alla cartella di installazione di ptwix e infine cache_folder rappresenta  la posizione della cartella in cui saranno scritti i file di cache che, come vi dicevo prima, dovranno avere i permessi di scrittura.

Fatto questo possiamo andare ad inserire ptwix nella pagina che desideriamo con i seguenti passi

Includiamo il file ptwix.php della cartella core

<? include "ptwix/core/PtwiX.php" ?>

Creiamo una nuova istanza dell’ogetto passandogli nell’ordine i seguenti parametri

Instance Name: Il mome dell’istanza dell’ogetto, a vostro piacere.
Username: L’username del tuo account twitter
Password: La password del tuo account twitter
Url path: La path url della cartella di installazione di ptwix  (http://www.mysite.com/ptwix/)
Cache folder path: La path assoluta della cartella di cache
Timeline type: (Optional) La timeline da visualizzare  (user timeline o friends timeline). Default friends timeline
Theme: (Optional) Il nome del tema da utilizzare, default gray-blue

Dopo di che bisogna inserire il foglio di stile relativo al tema, potete farlo manualmente oppure utilizzando il metodo printCss_Ref.
Ora resta da  stampare il box di ptwix ovunque vogliamo utilizzando il metodo printBox.

Per chiarirvi le idee ecco un bell’esempio completo

<? include "core/PtwiX.php";
$PtwiX=new PtwiX('second','user','pass','http://www.mysite.com/ptwix/','/var/www/ptwix/cache/',PtwiX::$FRIENDS_TIMELINE,'silver-red');
?>
<html>
<head>
<? $PtwiX->printCssRef(); ?>
</head›
<body›
<? $PtwiX->printBox(); ?>
</body>
</html>

Per completezza vi ricordo l’esistenza del metodo setDimension(larghezza,altezza) che chiamato sull’oggetto vi permette di impostare la dimensione a vostro piacimento.
Inoltre per chi ha un dominio in hosting e gli risulta impossibile installare curl e il relativo modulo PHP esiste anche un metodo disableCurl(boolean) che permette di disabilitare l’uso di curl, ma in questo caso potrete visualizzare solo la  timeline  del vostro utente  e non quella dei vostri amici.

Se avete particolari domande o problemi commentate pure e non dimenticate di seguire me e ptwix su twitter. 

Segnala presso:

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’entity bean “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 session bean, 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 java.io.IOException;
import java.io.PrintWriter;
import java.util.List;
import java.util.ListIterator;
import javax.ejb.EJB;
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 {
@EJB
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 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 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.

Segnala presso:

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

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:

Una nuova veste grafica che lo rende più accessibile e accattivante e una riorganizzazione dei contenuti anno reso il sito più fruibile agli utenti.

Visitate il portale italiano sulla fotografia naturalistica.

Segnala presso:

Normalmente, si parla di transazione 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 (rollback).

Nel contesto JEE, 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 transazione avrà un identificatore oltre ad altre informazioni allegate.
Un metodo chiamato su un EJB trasferirà automaticamente le informazioni di transazione da un EJB all’altro, ache se esso risiede in un altro container o addirittura su un altro server con supporto JEE.
Il tutto è possibile grazie al protocollo IIOP (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’application server ha un gestore delle transazioni (a volte chiamato monitor) che memorizza i dati di ogni oggetto coinvolto in una transazione in modo da essere in grado di riportare tutto allo stato iniziale in caso di fallimento.

Attraverso l’application server è 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 transazione in corso.

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

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

In conclusione con la tecnologia Enterprise è possibile, grazie al completo controllo dell’Application Server, 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.

Segnala presso:

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:

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: