EJB3 e Flex 2: Creare un progetto Ejb3 - Parte 2
(scritto da , il giorno 17-03-2007 00:00)
In questo secondo articolo vediamo come creare un progetto Java per cominciare finalmente a sviluppare il nostro primo Enterprise Java Bean, ad eseguire il deploy "a caldo" sul server JBoss installato nell'articolo scorso ed a sviluppare un test case client che ne testi il funzionamento remoto.
Grazie ad Eclipse siamo in grado di creare un progetto Java nel quale implementeremo il backend della nostra applicazione. Per creare il nostro progetto Java da Eclipse è sufficiente:
- creare un progetto Java
- dargli il nome Ejb3Sample
- selezionare l'opzione "Create separate source and output folders" per tenere distinti sorgenti dai compilati
- premere Finish
- jboss-aop-jdk50-client.jar
- jboss-aspect-jdk-client.jar
- jboss-ejb3x.jar
- jboss-ejb3-client.jar
- jbossws-client.jar
- jbossall-client.jar
- jbossjmx-ant.jar
- log4j.jar
Creazione di uno Stateless Session Bean
Uno Stateless Session Bean è il più semplice degli Ejb: come dice la parola stessa questo bean rappresenta un componente bean il cui ciclo vita è legato alla durata di utilizzo da parte del client che lo attiva e che non conserva lo stato tra una chiamata e l'altra. Questo significa che una volta recuperato il componente remoto, ogni operazione invocata deve portare con se tutti i parametri che ne permettano l'esecuzione.Mentre con le specifiche precedenti lo sviluppo di un Ejb richiedeva l'implementazione di diverse classi e file di configurazione, negli Ejb3 è sufficiente creare un'interfaccia con i metodi di accesso ed una classe di implementazione che rappresenterà il nostro bean. Durante la fase di deploy per far capire all'application server, che queste classi rappresentano un Ejb, è sufficiente descrivere l'interfaccia e la classe con semplici annotazioni.
Creiamo il package "com.aminoweb.ejb3sample.business" dove risiederà tutta la logica del nostro backend.
Creiamo l'interfaccia "com.aminoweb.ejb3sample.business.IService" nel modo seguente:
/**
* Interfaccia di accesso al servizio
*/
package com.aminoweb.ejb3sample.business;
import javax.ejb.Local;
import javax.ejb.Remote;
/**
* @author Roberto Tassi (roberto.tassi@aminoweb.com)
*/
@Local
@Remote
public interface IService {
/**
* Metodo che restituisce il prodotto tra il parametro a e b
* @param pA
* @param pB
* @return il risultato del prodotto
*/
int multiply(int pA, int pB);
}
L'annotazione @Local indica che l'interfaccia sarà utilizzata localmente da classi che risiedono nella stessa Java Virtual Machine del servizio, per cui i parametri d'ingresso e di uscita saranno passati per riferimento.
L'annotazione @Remote indica che l'interfaccia sarà utilizzata in remoto da classi che possono risiedere in Java Virtual Machine diverse dal servizio e anche fisicamente su computer diversi, e che quindi i parametri d'ingresso ed il risultato del metodo saranno passati per valore quindi per serializzazione (più onerosa in termini di performance).
Creiamo la classe d'implementazione "com.aminoweb.ejb3sample.business.ServiceBean" nel modo seguente:
/**
* Implementazione della logica del servizio
*/
package com.aminoweb.ejb3sample.business;
import javax.ejb.Stateless;
import org.apache.log4j.Logger;
/**
* @author Roberto Tassi (roberto.tassi@aminoweb.com)
*/
@Stateless
public class ServiceBean implements IService {
/**
* Variabile statica utile per eseguire dei log di informazione
*/
private static Logger LOGGER = Logger.getLogger(ServiceBean.class);
/**
* Costruttore sel servizio
*/
public ServiceBean() {
LOGGER.info("**** ServiceBean()");
}
/**
* Implementazione della logica del metodo di business
* @see com.aminoweb.ejb3sample.business.IService#multiply(int, int)
*/
public int multiply(int pA, int pB) {
LOGGER.info("---> ServiceBean.multiply(" + pA + ", " + pB + ")");
return pA * pB;
}
}
Come potete vedere è sufficiente utilizzare l'annotazione @Stateless per identificare la classe come Stateless Session Bean.
Deploy "a caldo" su JBoss utilizzando Ant
Una volta implementate le classi non ci resta che creare un jar che le contenga, copiarlo nella directory JBOSS_HOME/server/default/deploy e, se già in esecuzione, JBoss si accorgerà della nuova applicazione Ejb ed installerà correttamente il nostro servizio.In realtà in fase di sviluppo è possibile accelerare il deploy dell'applicazione, sfruttando alcune caratteristiche di JBoss:
- Deploy di applicazioni come directory aperte (come avevamo fatto con il flex.war)
- Deploy di applicazioni utilizzando il componente MainDeployer MBean di JBoss attraverso un task Ant
Ant è un tool che permette di definire delle macro in XML per eseguire operazioni comuni di preparazione, configurazione, compilazione e distribuzione dei progetti. Questo tool è molto famoso ed utilizzato perchè molto semplice e portabile tra piattaforme Windows, Linux, ..., inoltre può essere lanciato a linea di comando oppure direttamente da Eclipse poichè perfettamente integrato.
Creiamo una cartella "ant" sotto il progetto principale e creiamo il seguente file "build.xml":
<codice Flex 2/Actionscript 3>
La struttura di un file di build di Ant è caratterizzata da delle operazioni, i task, e dalle dipendenze tra questi. Il task di default "deploy" è infatti dipendente da quello di "init" e quello di "compile" per cui Ant prima di lanciare la parte di deploy si assicurerà che sia stati lanciati i task da cui dipende.
Dando una rapida occhiata al nostro script possiamo notare che nel task "compile" per semplicità, e soprattutto per velocizzare al massimo il deploy, sfruttiamo direttamente il compilato di Eclipse senza rieseguire la compilazione delle classi Java.
Inoltre l'applicazione non è stata archiviata in un Jar ma è stata tenuta aperta poichè JBoss è perfettamente in grado di eseguirne il deploy che viene eseguito non per copia sulla cartella di auto deploy ma attraverso l'uso del task di cui abbiamo parlato prima. Questo task interaqgisce direttamente con i componenti di amministrazione di JBoss chiedendogli direttamente di pubblicare la nostra applicazione.
Per lanciare Ant da Eclipse è sufficiente attivare con il tasto destro sul file build.xml, il menù contestuale e selezionare la voce >Run As >Ant Build ed Eclipse lancierà il task di default "deploy".
Dopo aver lanciato il deploy se esaminiamo la console di Eclipse dovrebbe essere comparso il messaggio:
 |
 |
Notare come il metodo di deploy tramite il task di Ant è immediato, a differenza del metodo di copia nella cartella di deploy automatico, infatti al termine del task il nostro servizio è già pronto.
Client di prova utilizzando un test case con JUnit 4
Non ci resta che creare un client con Java per accedere velocemente al nostro servizio e verificarne il corretto funzionamento. Approfitto della vostra pazienza per creare come client introducendo i test case utilizzando le nuove specifiche di JUnit 4 pienamente supportate all'interno di Eclipse 3.2.I test case non sono altro che classi che contengono tanti metodi ognuno dei qualche simula uno scenario di utilizzo del componente in esame, verificandone le risposte.
Prima di creare il test case per il nostro servizio con Eclipse è necessario aggiungere la libreria di JUnit già disponibile da Eclipse. E' sufficiente attivare il menù contestuale con il tasto destro sul progetto Ejb3Sample e selezionare la voce >Build Path >Add Libraries..., poi scegliere JUnit come libreria e successivamente JUnit 4 come versione della libreria.
Per tenere i sorgenti dei test separati da quelli del nostro servizio creiamo una nuova "Source Folder" di nome "test_src" dentro al progetto.
Creiamo il file "jndi.properties" dentro a "test_src":
java.naming.factory.initial=org.jnp.interfaces.NamingContextFactory
java.naming.factory.url.pkgs=org.jboss.naming:org.jnp.interfaces
java.naming.provider.url=localhost
Questo file di configurazione serve al nostro test case per poter per accedere al servizio dei nomi di JBoss (vedi JNDI) e recuperare l'Ejb che abbiamo creato precedentemente.
Creiamo sotto "test_src" il package "com.aminoweb.ejb3sample.test".
Creiamo il test case con una classe "com.aminoweb.ejb3sample.test.ServiceTestCase" implementata come segue:
/**
* Implementazione del test case del servizio Ejb Service
*/
package com.aminoweb.ejb3sample.test;
import static org.junit.Assert.assertEquals;
import javax.naming.Context;
import javax.naming.InitialContext;
import javax.naming.NamingException;
import javax.rmi.PortableRemoteObject;
import org.junit.Test;
import com.aminoweb.ejb3sample.business.IService;
/**
* @author Roberto Tassi (roberto.tassi@aminoweb.com)
*/
public class ServiceTestCase {
/**
* Test del metodo multiply() del servizio remoto Service
* @throws NamingException
*/
@Test
public void testMultiply() throws NamingException {
/* recuperiamo il servizio remoto */
Context ctx = new InitialContext();
Object object = ctx.lookup("ServiceBean/remote");
IService service = (IService) PortableRemoteObject.narrow(object, IService.class);
/* lanciamo il metodo con dati di test */
int a = 12;
int b = 13;
int total = service.multiply(a, b);
/* verifichiamo il risultato */
assertEquals(a * b, total);
}
}
Come possiamo vedere dall'esempio una volta recuperato il componente attraverso il servizio di nomi JNDI possiamo utilizzarlo come se fosse locale al nostro client.
Per lanciare JUnit da Eclipse è sufficiente attivare con il tasto destro sulla classe del test case ServiceTestCase, il menù contestuale e selezionare la voce >Run As >JUnit Test ed Eclipse lancierà il test case. Eclipse riconosce l'annotazione @Test sul metodo testMultiply() ed eseguirà il metodo di test. Eclipse dispone di un cruscotto con l'esito di tutti i test:
 |
 |
In questo articolo abbiamo visto come con le specifiche Ejb3 e le annotazioni introdotte nella Java 5, sia semplice creare ed eseguire il deploy di un Session Bean su JBoss. Nel prossimo articolo finalmente ci occuperemo di Flex e di come si accede agli Ejb.
Materiale
Progetto Ejb3Sample completo: download
Riferimenti
Ejb3 e Flex2: Installare il server JBoss - Parte 1: http://www.augitaly.com/flexgala/index.php?cmd=newsreader&id=76Sito ufficiale su Ejb: http://java.sun.com/products/ejb/
Sito JBoss implementazione Ejb3: http://labs.jboss.com/portal/jbossejb3
Sito Log4j: http://logging.apache.org/log4j/docs/
Sito Ant: http://ant.apache.org/
Sito JUnit: http://www.junit.org
Note sull'autore
Roberto Tassi (roberto.tassi@aminoweb.com) è un consulente Sun Certificated Java Programmer & Developer, che da 8 anni si occupa di sviluppo di applicazioni web-oriented su piattaforma Java. La sua esperienza web è partita da Cold Fusion, per poi consolidarsi su Java fino ad approdare al fantastico mondo di Flex.Commenti (0)
Registrati ed esegui il login se vuoi lasciare un commento
Scarica o stampa l'articolo "EJB3 e Flex 2: Creare un progetto Ejb3 - Parte 2" in formato PDF
Torna indietro
