Java EE - Un esempio su come usare EJB e componenti web

Java EE - Un esempio su come usare EJB e componenti web 
G.Morreale

Introduzione:

Lo scopo di questo articolo è quello di creare un applicazione enterprise in grado di sfruttare le seguenti tecnologie

  • Entity Bean
  • Session Bean
  • Servlet 
  • JSP

Java EE è una piattaforma molto vasta e riuscire a spiegare solo piccole parti di esse richiederebbe molto di più che un semplice articolo.
Nonostante ciò il tentativo è quello di dare un input al programmatore per stimolarne l'interesse e indurlo ad approfondire le singole tecnologie chiamate in ballo in questo esempio.

Al fine di velocizzare l'approccio a Java EE verrà utilizzato Netbeans e di conseguenza tutta la serie di wizard che l'IDE mette a disposizione.
Si cercherà inoltre di inserire nell'articolo dei link per approfondire circa i singoli passi eseguiti.

Cosa sarà in grado di fare l'esempio:

Il progettino che si creerà sarà in grado di estrarre i dati da un tabella di un dbms(mysql in questo caso) e stamparli tramite pagina web a video.

Cosa devo installare per realizzare l'esempio:


nota: Gli ultimi due non strettamente necessari, infatti è possibile effettuare operazioni analoghe con un altro dbms o rinunciare la tool grafico per le query.

I Passi per la realizzazione dell'esempio:

  1. Il Database
    1. Creare lo schema
    2. Creare una tabella
    3. Popolare la tabella
  2. Creazione Progetto Enterprise
  3. EJB
    1. Creare un datasource JDBC
    2. Creare un persistence unit
    3. Creare l'entity bean
    4. Creare un session facade per l'entity bean
  4. Modulo WEB
    1. Creare una servlet
    2. Creare una jsp

1. Il Database

Aprire il Mysql query browser loggandosi su localhost, si inserisca un nuovo DB chiamato EsempioDB con la seguente istruzione sql:

CREATE DATABASE `EsempioDB`;

Si crei la tabella:

CREATE TABLE `esempiodb`.`EsempioTable` (
  `id` INTEGER UNSIGNED NOT NULL AUTO_INCREMENT,
  `testo` VARCHAR(45) NOT NULL,
  PRIMARY KEY (`id`)
)
ENGINE = InnoDB;

E si popoli con le seguenti INSERT:

INSERT INTO EsempioTable VALUES(1,'TESTO 1');
INSERT INTO EsempioTable VALUES(2,'TESTO 2');
INSERT INTO EsempioTable VALUES(3,'TESTO 3');


2. Creazione Progetto "Vuoto"

Adesso si crei un nuovo progetto Enterprise selezionando "New Project" all'interno del file menu di netbeans.


Si scelga un nome, ad esempio, "Esempio" e si lascino inalterate tutte le opzioni richieste fino alla fine del wizard.
Ciò consente a netbeans di creare un progetto EJB, un progetto WEB e un progetto EAR in grado di inglobare EJB e WEB all'interno di unico archivio.

Come è possibile notare nella lista dei progetti saranno presenti i seguenti 3 progetti:

  • Esempio
  • Esempio-ejb
  • Esempio-war

nota:
Facendo un breve cenno al design pattern MVC gli ultimi due progetti conterranno rispettivamente il model(ejb) e controller/view(war).

3. EJB

Risorsa JDBC e PERSISTENCE UNIT

Adesso bisogna creare all'interno dell'application server una risorsa jdbc, ovvero una risorsa in grado di comunicare con il dbms e db creato.

nota:
Tale risorsa normalmente viene creata attraverso dei comandi propri dell'application server (es. in glassfish asadmin add-resources sun-resources.xml) o attraverso la console di amministrazione del server stesso, è quindi un operazione non di programmazione ma di amministrazione del container.
Nel caso di glassfish la risorsa jdbc viene creata attraverso un file xml nel quale si indicano una serie di parametri tra i quali username e password del database, numero di connesioni del pool etc.

Esempio di file xml:
<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE resources PUBLIC "-//Sun Microsystems, Inc.//DTD Application Server 9.0 Resource Definitions //EN" "http://www.sun.com/software/appserver/dtds/sun-resources_1_3.dtd">
<resources>
  <jdbc-resource enabled="true" jndi-name="esempioJNDI" object-type="user" pool-name="mysqlPool"/>
  <jdbc-connection-pool allow-non-component-callers="false" associate-with-thread="false" connection-creation-retry-attempts="0" connection-creation-retry-interval-in-seconds="10" connection-leak-reclaim="false" connection-leak-timeout-in-seconds="0" connection-validation-method="auto-commit" datasource-classname="com.mysql.jdbc.jdbc2.optional.MysqlDataSource" fail-all-connections="false" idle-timeout-in-seconds="300" is-connection-validation-required="false" is-isolation-level-guaranteed="true" lazy-connection-association="false" lazy-connection-enlistment="false" match-connections="false" max-connection-usage-count="0" max-pool-size="32" max-wait-time-in-millis="60000" name="mysqlPool" non-transactional-connections="false" pool-resize-quantity="2" res-type="javax.sql.DataSource" statement-timeout-in-seconds="-1" steady-pool-size="8" validate-atmost-once-period-in-seconds="0" wrap-jdbc-objects="false">
    <property name="serverName" value="localhost"/>
    <property name="portNumber" value="3306"/>
    <property name="databaseName" value="esempioDB"/>
    <property name="User" value="root"/>
    <property name="Password" value="123456"/>
    <property name="URL" value="jdbc:mysql://localhost:3306/esempioDB"/>
    <property name="driverClass" value="com.mysql.jdbc.Driver"/>
  </jdbc-connection-pool>
</resources>

Netbeans in automatico genera tale file xml e si occupa di comunicare a glassfish il deploy di tale risorsa.

Per far ciò si può passare direttamente a creare il persistence unit(sarebbe il passo successivo) e selezionare sulla combobox DataSource "New Data Source"
(Per ottenere tale finestra cliccare con il tasto destro sul progetto ejb e scegliere all'interno della categoria persistence: persistence unit.)

Cliccando su New Data Source si abbandona per un attimo la creazione del persistence unit e si passa alla creazione della risorsa per la comunicazione con il db.
Inizialmente verrà chiesto un nome JNDI e un URL jdbc.
Riguardo al primo è possibile scegliere un nome arbitrario,es. esempioJNDI

nota
Il nome jndi serve a identificare la risorsa all'interno del container, tale percorso però non verrà utilizzato direttamente nel codice in quando usando la dependency injection sarà il container stesso a trovare la risorsa (usando il percorso JNDI)

Riguardo la Database Connection, procedere scegliendo l'opzione "New Database Connection", apparirà un'altra finestra nella quale bisognerà indicare il tipo di driver jdbc da usare (mysql!) e i parametri di connessione.


Configurare il tutto correttamente in modo da ritornare alla finestra "New persistence Unit".

Sulla finestra "New persistence Unit" bisogna operare con le seguenti opzioni:

  • Persistence Unit Name: è il nome della configurazione del persistence unit

  • Persistence Provider: Indica quale librerie usare per gestire il mapping tra il database e la sua rappresentazione ad oggetti
(di default viene proposto toplink, ma ci sono altre valide alternative, personalmente preferisco hibernate ma per l'esempio si lasci toplink come opzione)

  • DataSource: è il nome del Datasource appena creato
  • Use Java Transaction API: Indica se far gestire alle JTA le transazioni o meno. (lasciare checked)

  • Table generation Strategy:Indica al persistence provider se creare o meno le tabelle nel caso in cui esistano gli entity e non le corrispettive tabelle. (in questo esempio le tabelle sono state create, ma si poteva direttamente creare gli entity che rappresentano le tabelle e lasciare che il persistence provider le generasse in automatico)

In definitiva scelto il nome del persistence unit (ad esempio - Esempio-ejbPU) è possibile proseguire cliccando su Finish lasciando tutte le opzioni inalterate.

Netbeans ha creato in automatico due file

  • sun-resources.xml - necessario alla creazione della risorsa jdbc sul server
  • persistence.xml - necessaria a indicare una serie di opzioni circa la gestione della persistenza (mapping O/R) etc.

Entity Bean

Cos'è un entity bean? E' un oggetto pojo in grado di rappresentare attraverso la notazione ad oggetti un tabella.
La corrispondenza tra entity bean e tabelle è gestista dal persistence provider (una serie di librerie).
Nel passo precedente è stato scelto TopLink come provider(le sue librerie sono installate di default).

nota:
Ne esistono di due tipi 

BMP - entity Bean Managed Persistence
CMP - entity Container Managed Persistence

I primi prevedono che il programmatore di occupi della logica di mapping tra gli entity e il database relazionale, i secondi si appoggiano al persistence provider. Nell'esempio si creerano degli entity CMP.

Tali bean possono essere creati in automatico attraverso l'ennesimo wizard di netbeans.

Tasto destro sul progetto ejb + Entity Classes From Databases..Scegliere il datasource "esempioJNDI" e scegliere le tabelle da sottoporre al wizard (1 sola in questo caso). 

Cliccare su next, indicare un package che contenga gli entity, ad esempio entities, cliccare su finish.

nota:
L'opzione "Generated named query annotation ..." serve a generare in automatico delle query all'interno dell'entity, tali query hanno il vantaggio di essere precompilate e quindi leggermente più performanti. In questo esempio comunque non ne viene fatto uso, per cui l'opzione è tralasciabile.

All'interno del package entities è possibile trovare l'entity bean, attraverso le annotations (@Table, @Column etc.) si indica al persistence provider come effettuare il mapping tra i dati del db e quelli nell'entity.

Session Bean

Cos'è un Session bean? E' un componente che gestisce la logica applicativa, nel classico esempio della banca si occuperà di effettuare le operazioni di bonifico, lista movimenti etc.

Ha un particolare ciclo di vita gestito dal container(attraverso pooling) e di solito vengono usati per la gestione del modello richiesta-risposta.

nota:
Esistono due tipi di session bean: Stateless e Stateful, la differenza consiste nel mantenimento delle informazioni tra client e server, solo i secondi infatti sono in grado di conservare tali dati.

Il session bean è composto dalla sua interfaccia e dalla relativa implementazione

nota:
Le interfaccie possono essere di due tipi, Locali e Remote, le prime si usano quando il modulo ejb e il modulo web risiedono all'interno della stessa applicazione enterprise (EAR), ovviamente sono più efficenti. Le seconde vengono usate qualora i moduli ejb e il modulo web(o altri moduli ejb) risiedono su applicazioni diverse o container diversi.

Si ricorre nuovamente al wizard di netbeans per creare in automatico un session bean in grado di implementare ed esporre attraverso interfaccia locale i più comuni metodi (inserimento, edit, cancellazione etc.) di interazione con l'entity appena creato.

Tasto destro sul progetto ejb - Session Bean For Entity Classes - scegliere l'entity - scegliere un package (es. session) -> Finish!!

All'interno del package session è stata creato il session bean e la relativa interfaccia.
L'interfaccia espone i metodi utilizzabili dall'esterno (es. modulo web:servlet)

Si dia uno sguardo all'implementazione del session bean

@Stateless
public class EsempiotableFacade implements EsempiotableFacadeLocal {

    @PersistenceContext
    private EntityManager em;

    public void create(Esempiotable esempiotable)
    {
        em.persist(esempiotable);
    }

    public void edit(Esempiotable esempiotable)
    {
        em.merge(esempiotable);
    }

    public void remove(Esempiotable esempiotable)
    {
        em.remove(em.merge(esempiotable));
    }

    public Esempiotable find(Object id)
    {
        return em.find(entities.Esempiotable.class, id);
    }

    public List<Esempiotable> findAll()
    {
        return em.createQuery("select object(o) from Esempiotable as o").getResultList();
    }

}

@Stateless indica banalmente il tipo di bean.

@PersistenceContext
private EntityManager em;

Serve a inizializzare l'EntityManager, ovvero quell'oggetto che si occupa del mapping fra entity e tabelle.
L'EntityManager è una delle classi chiave del persistence provider.
l'annotation @PersistenceContext permette al container di inizializzare la variabile em considerando le informazioni immesse all'interno del file persistence.xml (Si ricordi il persistence unit!!).
L'inizializzazione avviene attraverso il meccanismo della dependency injection (vedi mio articolo precedente).

i metodi "em.find, em.remove, em.merge, em. persist"
sono propri dell'entity manager e servono rispettivamente per le seguenti operazioni di base

  • em.find - > ricerca tramite id di un entity (corrisponde ad una SELECT ... WHERE id = :id)
  • em.remove -> eliminazione tramite id (corrisponde a DELETE .. WHERE id = :id
  • em.merge -> inserimento o update (INSERT o UPDATE) (serve anche a recuperare entity detached...)
  • em. persist -> inserimento dell'entity sul db (corrisponde alla INSERT)

Per realizzare delle operazioni specifiche attraverso delle query ad hoc si ricorre, come nell'ultimo metodo (findAll()), alla generazione di una query attraverso il metodo "createQuery"

Le query da sottoporre all'entitymanager devono essere scritte in EJB-QL, ovvero uno specifico linguaggio in grado di effettuare query sugli entity e non sulle tabelle. EJB-QL contribuisce a garantire la portabilità delle query attraverso dbms diversi (la query scritta infatti prescinde da mysql!).
Per approfondire su ejb-ql clicca qui.

Ovviamente bisogna imparare a scrivere i propri session bean ma l'esempio intende giusto a dare una panoramica..


Modulo WEB

Si è realizzata la logica di business, l'ejb è in grado di estrarre i dati dal db e comunicarli attraverso una struttura dati (List<Esempiotable>)

Adesso è possibile procedere creando una servlet in grado di richiamare il session bean.(Secondo il pattern MVC la servlet fungerà da controller).

Tasto destro sul modulo war -> New Servlet -> Servlet class name = test -> package = servlet -> Finish

Si svuoti il metodo processRequest   in modo che sia uguale alla porzione di codice seguente 

protected void processRequest(HttpServletRequest request, HttpServletResponse response)
    throws ServletException, IOException
{
    //clicca qui con il tasto dx.

Adesso si procede con l'inizializzazione (ancora una volta operata attraverso dependency injection) del componente ejb da richiamare.


Dove c'è il commento premere Tasto destro -> Insert code -> Call Enterprise Bean

(Ver Netbeans 6.0 "Dove c'è il commento cliccare con il tasto dx -> Enterprise Resources -> Call Enterprise Bean -> Scegliere Esempio-ejb -> EsempioTableFacade -> Finish")



In quest'ultimo caso il wizard è servito per inserire una sola riga di codice:

 @EJB
 private EsempiotableFacadeLocal esempiotableFacade;

Ovvero quella per l'inizializzazione del session bean.
Tale variabile non necessita ulteriori inizializzazioni (grazie all'annotation ci ha già pensato il container!), è quindi pronta all'uso.

All'interno di processRequest è quindi possibile digitare il seguente codice al fine di estrarre il contenuto della tabella.

List<Esempiotable> list =  esempiotableFacade.findAll();
//(non dimenticare di fare un fix delle import!)

Bene, già da subito si potrebbe nella servlet stessa stampare il contenuto della List attarverso un PrintWriter o similiari partendo dall'oggetto response.
Ma volendo rispettare il paradigma MVC e predisporre l'esempio per un uso più strutturato si decide di passare i dati a una view (una pagina JSP).

Al fine di passare i dati tra la servlet e la pagina jsp si usa la tecnica del forward attraverso un RequestDispatcher.

Il dispatcher può essere inizializzato nel seguente modo:

String arg = "/" + this.getServletName() + ".jsp";
RequestDispatcher dispatcher = this.getServletContext().getRequestDispatcher(arg);

il forwarding avviene attraverso l'istruzione

dispatcher.forward(request, response);

Tale tecnica non genera un redirect verso la pagina jsp, ma serve a indicare al container che il flusso viene passato dalla servlet alla jsp mantenendo inalterato lo stato dell'oggetto request e response.
In tal modo è quindi possibile comunicare i dati contenuti nella "list" alla jsp settandoli all'interno dell'oggetto request operando nel seguente modo:

request.setAttribute("lista", list);

quindi in definitiva il codice di processRequest sarà il seguente:

protected void processRequest(HttpServletRequest request, HttpServletResponse response)
    throws ServletException, IOException  {
        
            List<Esempiotable> list =  esempiotableFacade.findAll();
  
            request.setAttribute("lista", list);
            
            String arg = "/" + this.getServletName() + ".jsp";
            RequestDispatcher dispatcher = this.getServletContext().getRequestDispatcher(arg);
            dispatcher.forward(request, response);
            
    } 

Adesso si crei una jsp con lo stesso nome della servlet (test.jsp) (Secondo MVC stiamo realizzando una view)

Il codice della jsp è il seguente:

<%@page contentType="text/html"%>
<%@page pageEncoding="UTF-8"%>
<%@page import="entities.Esempiotable"%>
<%@page import="java.util.List"%>
<%
List<Esempiotable> list = (List<Esempiotable>)request.getAttribute("lista");
%>
<!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>
    <h1>Contenuto Tabella EsempioTable</h1>
    <% if (list != null) 
        { for (Esempiotable e: list)
              { out.println(e.getId() + " " + e.getTesto() + "<br/>"); }
        }           
    %>    
    </body>
</html>

Il codice è banale, si estrae dall'oggetto request l'attributo lista e successivamente all'interno del codice html si effettua un ciclo for attraverso la lista al fine di stampare il contenuto dei vari entity.

Cliccando su Run sull'Enterprise Application Esempio e digitando sul browser
http://localhost/Esempio-war/test

L'output ottenuto sarà simile alla seguente immagine:




Conclusione:

Questo articolo è solo un introduzione al mondo java EE, di cose da spiegare ed esplorare ce no sono veramente tante.. Questo è solo l'inizio!



22 comments:

Giuseppe Morreale said...

Datemi un feedback sull'esempio.. siete riusciti a seguirlo e completarlo?

davideb said...

Ciao,

complimenti per gli articoli che stai scrivendo, veramente belli! In questo contesto, come faccio ad inserire grizzly? Quale struttura mi consigli?

Giuseppe Morreale said...

Grizzly è un framework sviluppato per realizzare dei server scalabili e performanti avvalendosi della tecnologia NIO.
https://grizzly.dev.java.net/
Premesso questo in chè senso vuoi inserire tale tecnologia in questo contesto? Prova a spiegarti diversamente, vediamo se riesco a darti una risposta!

davideb said...

Ciao,

hai ragione...ho visto il tuo articolo e spiega un esempio (molto ben fatto) su come utilizzare gli EJB-serlet-JSP.
Ora io vorrei creare un sito completamente web2.0 e vorrei utilizzare grizzly vista la sua scalabilità e la sua capacità di creare comet application.
Mi chiedevo ora come strutturare un'applicazione in un contesto Java Enterprise, che ruolo dare ai vari elementi...hai un'idea? o un eempio?

Giuseppe Morreale said...

http://dlc.sun.com/pdf/820-4496/820-4496.pdf
PAG 84.
Riguardo grizzly posso dirti che non lo usi direttamente tu, ma lo trovi all'interno dell'application server (Es. glassfish), grizzly ha la caratteristica di riuscire ad aprire diverse connessioni per ogni singolo thread(basandosi sui file-descriptor) quindi si presta a framework come comet che si basano su web2.0 e quindi hanno bisogno di divese connessioni aperte.
Per ciò che concerne comet non ho mai usato questa tecnologia, quindi parliamo di un argomento per me nuovo.
Ho provato a dare un occhiata sulla home ufficiale e sembra un tecnologia interessante che spero di trattare sul blog non appena potrò!
Nel frattempo posso dirti che
http://dlc.sun.com/pdf/820-4496/820-4496.pdf In questo pdf a pag. 84 trovi un esempio su come usare le comet api.

Anonymous said...

Ciao,
ho appena completato il tuo esempio... Davvero ottimo ti ringrazio!!!
Un saluto Giuliana

Giuseppe Morreale said...

Grazie per il feedback! ;)

ianaz said...

Ciao, ho completato l'esempio e funziona correttamente, grazie :-)

L'unica cosa forse da aggiornare é qui:

Dove c'è il commento cliccare con il tasto dx -> Enterprise Resources -> Call Enterprise Bean -> Scegliere Esempio-ejb -> EsempioTableFacade -> Finish

che sulla netbeans 6.5 non esiste.
In NetBeans 6.5 sarebbe: Tasto destro -> Insert code -> Call Enterprise Bean

Bella guida, Silvio

Giuseppe Morreale said...

Hai ragione nella versione 6.5 hanno spostato l'accesso al wizard.
Ho già apportato la correzione da te suggerita!

Grazie!

Bako said...

ciao.
ho un problema:
se devo inserire una nuova tupla come faccio?

create(esempiotable), giusto?

esempiotable devo crearlo io, il testo lo ho, ma l'ID?

come diavolo lo recupero?
di solito si hanno tutti i campi tranne l'id, come faccio a crearlo da 0 e ad averlo inserito?

e una volta inserito, come recupero il suo id?
grazie.

Giuseppe Morreale said...

l'id se autoincrement lo genera hibernate.

In alternativa puoi settarlo a tuo piacimento.

se vuoi recuperarlo puoi usare entity = em.merge(entity)

all'interno di entity dovresti trovare il valore id autogenerato.

B&B viamercanti76 said...

Ho un problema nel deploy dell'EAR, ma non ho capito qual'è??

Deploying application in domain failed; Error loading deployment descriptors for module [Esempio-ejb] Line 6 Column 54 -- Deployment descriptor file META-INF/persistence.xml in archive [jar]. cvc-complex-type.2.4.a: Invalid content was found starting with element 'property'. One of '{"http://java.sun.com/xml/ns/persistence":properties}' is expected.
C:\Users\Sergio\Documents\NetBeansProjects\Esempio\Esempio-ejb\nbproject\build-impl.xml:455: The module has not been deployed.
BUILD FAILED (total time: 0 seconds)

Aspetto qualcuno che possa darmi una mano :)

Giuseppe Morreale said...

come riportato nel messaggio di errore il problema è nel file persistence.xml.

guarda nella linea 6 del file xml.

se non risolvi prova a incollare il contenuto del file persistence.xml

lux said...

Salve ragazzi.Anche io ho seguito l'esempio. Tuttavia mi dà questo errore che non so come risolvere.
Deploying application in domain failed; Error loading deployment descriptors for module [Applicazione-war] -- Cannot resolve reference Unresolved Ejb-Ref servlet.Test/esempiotableFacade@jndi: @null@session.EsempiotableFacadeLocal@Session@null
C:\netBeansProjects\Applicazione\Applicazione-war\nbproject\build-impl.xml:556: The module has not been deployed.
BUILD FAILED (total time: 10 seconds)

Spero sinceramente in un vostro aiuto. Grazie

lux said...

Risolto.l'ejb va dichiarato Remote e non Local.Un grazie a Francesco

Giuseppe Morreale said...

Sicuramente, come dici, hai risolto.
Ma presta bene attenzione usare interfacce remote è ben diverso da usarle locali.

Potrebbe essere successo che il wizard non ha aggiunto nel file web.xml i riferimenti all'ejb usato.

Passando alle interfacce remote si è sbloccata la situazione.

puoi verificare se adesso tornando alla versione locale continua a funzionare tutto, e verificare anche se adesso nel web.xml ci sono delle righe del tipo ejb-remote-ref o ejb-local-ref. (oppure vedi il tab references -> ejb references)

lux said...

Grazie per la sua risposta.
Ho provato a rifare il tutto in locale, tuttavia ho lo stesso problema. Purtroppo sono nuovo verso questa programmazione e sto incontrando moltissime difficoltà con molto molto tempo a capire gli errori che l'ide mi visualizza.
Purtroppo non mi fa postare il codice xml.
Però le righe di remote o local reference non ci sono.
Però se uso remote anziche local il programma viene doployato correttamente.
Ho controllato anche reference -> ejb reference ma risulta vuoto.
Davvero non riesco a capire la causa di questo errore.
Grazie a tutti per una eventuale risposta

antonio said...

Ciao,ho un applicazione cosi composta:

PRESENTATION LAYER: IceFaces
BUSINESS LAYER: SPRING 2.5
PERSISTENCE LAYER: Hibernate 3.* (mySql)

Se volevi migrare a EJB? Sai consigliarmi qualce link da guardare?
Poi vorrei chiederti se questo passaggio si può giustificare e se si in quali termini(scalabilità??)

Ciao grazie!

Giuseppe Morreale said...

ciao antonio,
purtroppo non ho mai usato i framework da te menzionati a parte hibernate.

ho però l'impressione che spring e icefaces sono degli ottimi e ben supportati framework.

il fatto che tu usi framework diversi e adatti per ogni layer del progetto è già la scelta giusta.
Io sono per la buona progettazione più che per la lotta tra framework, linguaggi etc.

quindi penso che se hai già un progetto ben strutturato nel modo che mi hai descritto forse è da valutare bene il dispendio di energie necessarie al passaggio.

più che altro può rilanciare questa tua valutazione per nuovi progetti.

riguardo ice faces penso che puoi continuare ad usarli sia con spring che con ejb sottostante.

riguardo invece spring vs ejb l'unica cosa che posso dirti è che ejb è una tecnologia direttante supportata da sun.. per il resto non saprei.

Ciummo said...

Per deformazione "universitaria" ho sempre usato JBoss + Tomcat... un delirio! Ora provo Glassfish e ti dico; intanto complimenti perché una guida così in italiano credo di non averla mai trovata!

vincenzo33kr said...

Ciao, ti premetto che io sono un neofita di J2EE.
Non mi è chiaro cosa è esempiotable e su come crearla.Puoi aiutarmi?

Grazie
Vincenzo C.

vincenzo33kr said...

Salve, vorrei sapere cosa è esempiotable nel ejb session; non mi è chiara su come crearla ...mi potresti aiutare?

Grazie
Vincenzo C.