Stracciafabrizio’s Weblog

Just another WordPress.com weblog

Strumenti per la realizzazione di Rich Internet Application: Mashup Maven, Spring, Hibernate, Google web Toolkit

with 3 comments

Gli strumenti individuati per la realizzazione di questo tipo di applicazioni :

  1. MAVEN: strumento per la gestione, manutenzione e divulgazione di progetti sviluppati in linguaggio Java.
  2. SPRING: framework utilizzato per lo sviluppo di applicazioni web-based, ridefinendole tramite l’utilizzo dell’inversion of Control e Dependency Injection
  3. HIBERNATE & JPA : ORM utilizzato per la gestione delle entità, delle transazioni di quest’ultime e relativo aggiornamento sul Database.
  4. GWT: framework utilizzato per la creazione di pagine web basate su JavaScript, tramite la scrittura di codice Java.

L’obiettivo di questo articolo sarà quello di riuscire a far interagire tra loro gli strumenti sopra indicati, in maniera tale da poterli utilizzare per lo sviluppo di applicazioni di tipo RIA. Si partirà dalla costruzione dell’ambiente di sviluppo,  fino ad arrivare alla creazione di una semplice applicazione d’esempio. Le metodologie di integrazione elencate nelle sezioni successive, non sono da riternersi le uniche possibili.

IDE ECLIPSE

Come ambiente di sviluppo è stato scelto Eclipse, poichè la sua grande disponibilità di plugin e componenti aggiuntivi, rendono questo strumento poliedrico e il più utilizzato in ambienti di sviluppo Java e non.

Come primo passo,scaricare la versione di Eclipse direttamente dal  sito:

http://www.eclipse.org/downloads/

ed   Installarlo sulla propria macchina.

 

GOOGLE WEB TOOLKIT

Per integrare all’interno di eclipse il framework GWT, è sufficiente scaricare il plugin corrispondente all’indirizzo:

–  http://code.google.com/intl/it-IT/webtoolkit/download.html

per l’installzione seguire la procedura indicata in “Passi per l’istallazione” di Maven nel paragrafo successivo.

A processo ultimato compariranno tra i tasti dell’ IDE le seguenti opzioni:

Rispettivamente partendo da sinistra, il tasto per la creazioni di applicazioni GWT, il tasto per la compilazione e il tasto per la pubblicazione sul Google Engine.

MAVEN

per l’integrazione dello strumento Maven all’interno del nostro IDE, è necessario installare il plugin corrispondente m2eclipse reperibile al sito:

http://m2eclipse.sonatype.org/sites/m2e

Passi per l’installazione:

  1. Selezionare Help > Install New Software dal menu di Eclipse, così facendo si aprirà una finestra di dialogo con dei campi da inserire.
  2. Inserire il link sopra elencato nell’apposita casella “Work with:” and press invio. Dopo la pressione del tasto verranno visualizzati i plugin corrispondenti e i relativi aggiornamenti.
  3. Scegliere il componente elencato sotto m2eclipse: “Maven Integration for Eclipse (Required)”.
  4. Click su Next. Eclipse effettuerà un test per verificare la buona riuscita dell’installazione.
  5. Click su Next e accettare la Eclipse Public License v1.0.

Dopo aver riavviato l’IDE potremmo aprire un nuovo progetto Maven tramite File->New->Other… Maven Project

Da questo momento in poi per la gestione delle dipendenze, utilizzerò sempre il repository centrale messo a disposizione da Maven, così facendo non dovremo occuparci di ricercare ed inserire in apposite cartelle i .jar necessari alle nostre applicazioni. Per la gestione di tale strumento, viene creato un file denominato pom.xml, dove all’interno sono definite tutte le dipendenze con rispettivi nomi e versioni. Per la modifica del file è possibile utilizzare una maschera grafica (form-based) la quale si apre automaticamente una volta cliccato sul file.

All’interno del pom non vengono definite solo le dipendenze, ma è possibile assegnare un nome all’applicazione, la versione attuale e molto altro.

Di seguito uno screen-shot contenente una parte delle funzionalità disponibili una volta creato un progetto con Maven:

Inoltre Maven mette a disposizione una serie di Archetipi già esistenti che permettono la creazione di strutture scheletro ben definite che rispettano pattern architetturali, a seconda del progetto da creare. E’ possibile inoltre una volta preso dimestichezza con il mezzo, difinire dei propri archetipi per progetti futuri.

Una volta integrati Eclipse e Maven tra loro rimangono i framework GWT, Spring e Hibernate.

Sfruttiamo ora la funzionalità di Maven riguardante la creazione di nuovi progetti tramite l’utilizzo di archetipi .

Creiamo un nuovo progetto con Maven, come archetipo scegliamo gwt-maven-plugin creato dalla org.codehaus.mojo. In questo modo maven crea la struttura necessaria per la gestione di un’applicazione GWT e nel file pom.xml inserisce le dipendenze necessarie per l’utilizzo del framework.

frammento dic codice  file pom.xml

[...] 
<!--  GWT dependencies (from central repo) -->
<dependency>
<groupId>com.google.gwt</groupId>
<artifactId>gwt-servlet</artifactId>
<version>${gwt.version}</version>
<scope>runtime</scope>
</dependency>
<dependency>
<groupId>com.google.gwt</groupId>
<artifactId>gwt-user</artifactId>
<version>${gwt.version}</version>
<scope>provided</scope>
</dependency>
[...]

Struttura creata dall’archetipo:

  1. /src/main/java cartella contenente i sorgenti che costituiscono la parte dinamica dell’applicazione
    • {main_package}.client sub-package contiene i sorgenti disponibili solo dal lato client
    • {main_package}.server sub-package contiene i file riservati alla parte server (questo sub-package non viene creato automaticamente alla creazione del progetto)
    • {main_package}.shared sub-package contiene i file destinati alla comunicazione tra client e server (questo sub-package non viene creato automaticamente con l’utilizzo dell’archetipo)
  2. /src/main/resources contiene le risorse statiche dell’applicazione per esempio pagine html  file di risorse riservate all’applicazione o file css
  3. /src/test/java cartella utilizzata per contenere i file di test dell’applicazione
  4. /src/main/webapp cartella contenente i file necessari per la creazione di una web-application java es: „web.xml“
  5. /target contiene i file compilati da distribuire
  6. /war cartella utilizzata per la procedura di compilazione del progetto
  7. File pom.xml viene inserito nella root della cartella del progetto, il file contiene tutte le configurazioni necessarie al progetto per funzionare.

Come indicato nella sezione del capitolo 4 “La comunicazione RPC con il server” la struttura di ogni servizio deve seguire un determinato pattern:

  1. Una Classe interfaccia  <NomeServizio> che estende la classe RemoteService
  2. Una Classe interfaccia <NomeServizioAsync>
  3. Una Classe <NomeServizioImpl> che estende la RemoteServiceServlet, la quale implementa la logica del servizio

L’utilizzo di Maven per il processo di compilazione, permette la possibilità di autocreare il codice della classe interfaccia asincrona <NomeServizioAsync> durante la compilazione.. Questa funzionalità può essere individuata all’interno del file pom del progetto:

<<plugins> 

<plugin>

<groupId>org.codehaus.mojo</groupId>

<artifactId>gwt-maven-plugin</artifactId>

<version>1.2</version>

<executions>

<execution>

<goals>

<goal>compile</goal>

<goal>generateAsync</goal>

<goal>test</goal>

</goals>

</execution>

</executions>

– <configuration>

<runTarget>com.provamaven.app.Application/Application.html</runTarget>

</configuration>

</plugin>

Nell’ IDE Eclipse all’interno della classe che utilizzerà il servizio implementato, verrà presentato un errore dovuto alla mancanza di tale classe. Ciò non toglie il corretto funzionameto dell’applicazione dopo la compilazione. E’ possibile disabilitare questa opzione, sarà necessario poi scrivere l’interfaccia asincrona.

Il passo successivo è l’integrazione con Spring e Hibernate, questa volta si sfrutterà la gestione delle dipendeze di Maven per l’integrazione. Aprendo il file pom con l’editor grafico:

Sotto la voce overview è possibile definire delle properties, così da semplificare il processo di aggiornamento a nuove versioni degli strumenti. Si definisce quindi il nome della proprietà e il corrispondente numero di versione. Per integrare Spring e Hibernate definiamo anticipatamente le proprietà corrispondenti ai due strumenti:

– Creare una proprietà nominata  org.springframework.version con valore  3.0.1.RELEASE

– Creare una proprietà nominata  org.hibernate.version con valore  3.5.1-Final

Una volta definite le proprietà sotto la voce Dependencies è necessario inserire le dipendenze, quest’ultime possono essere inserite effettuando una ricerca dal repository centrale tramite il tasto Add, Oppure creandole con il tasto Create. Per definire una dipendenza è necessario riempire i campi GroupId, Artifact Id e Version nella form Dependency Details

Dipendenze da definire:

    Dipendenze necessarie per Spring

  • Group Id : org.springframework Artifact Id : spring-orm Version :${org.springframework.version}
  • Group Id : org.springframework Artifact Id : spring-web Version :${org.springframework.version}

    Dipendeze necessarie per Hibernate

  • Group Id : org.hibernate Artifact Id : hibernate-core Version : ${org.hibernate.version}
  • Group Id : org.hibernate Artifact Id : hibernate-annotations Version :${org.hibernate.version}
  • Group Id : org.hibernate Artifact Id : hibernate-entitymanager Version :${org.hibernate.version}
  • Group Id : org.hibernate.javax.persistence Artifact Id : hibernate-jpa-2.0-api Version :1.0.0.Final
  • Group Id : org.slf4j Artifact Id : slf4j-log4j12 Version : 1.5.8
  • Group Id : c3p0 Artifact Id : c3p0 Version : 0.9.1.2 (spiegato più avanti)
  • Una volta inserite le dipendenze è necessario aggiungere un nuovo repository in aggiunta a quello di default, poichè Hibernate è disponibile nel repository della casa madre JBoss. Per inserirla è necessario cliccare la voce Show Advanced Tabs situata nell’angolo destro della form e selezionare la voce Repositories. Qui va inserito il seguente link:

Una volta eseguite tutte le modificare cliccare sul tasto salva ed attendere. Maven si occuperà di effettuare il download delle dipendenze indicate dai repository e le inserirà all’interno  delle proprie librerie, rendendole disponibili a tutta l’applicazione. Viene creata una cartella locale, solitamente situata sotto  {user_home}/.m2  dove vengono scaricate le librerie indicate. Per completare l’integrazione tra GWT e Spring è necessario effettuare il download separato di una libreria che lavorerà da punto di collegamento tra le servlet Spring e le chiamate Rpc di Gwt. Quest’operazione risulta indispensabile poichè la libreria non è diponibile nei repository pubblici utilizzati da Maven.

La libreria in questione è la spring4gwt  reperibile all’indirizzo:
–    http://code.google.com/p/spring4gwt/
Una volta effettuato il download è necessario creare una cartella denominata „lib“ sotto il path /src/main/webapp/WEB-INF  e posizionare il file  „spring4gwt-0.0.1.jar“ all’interno. La stessa procedura dovrà essere utilizzata nel caso di utilizzo di librerie personali o comunque non presenti nel repository centrale.

Configurare il container Spring

Il file web.xml

Dopo aver effettuato l’integrazione tra le diverse tecnologie, il passo successivo è la configurazione dei vari componenti all’avvio dell’applicazione. Il progetto creato tramite l’archetipo GWT crea una vera e propria applicazione J2EE. Il file web.xml# è il file di configurazione delle applicazioni enterprise, nel nostro caso dovremo inserire alcuni parametri per il corretto riconoscimento e avvio delle tecnologie usate.
In primis va indicato il file di configurazione necessario per il caricamento del contesto di Spring applicationContext.xml (trattato più avanti).  Inoltre va indicata la classe di Spring utilizzata per il caricamento dell’application context, la org.springframework.web.context.ContextLoaderListener, passandogli come parametro la posizione del file sopra indicato.

<!DOCTYPE web-app PUBLIC
“-//Sun Microsystems, Inc.//DTD Web Application 2.3//EN”
http://java.sun.com/dtd/web-app_2_3.dtd&#8221; >
<web-app>
<display-name>GWT-Maven-Archetype</display-name>
<context-param>
<param-name>contextConfigLocation</param-name>
<param-value>/WEB-INF/applicationContext.xml </param-value>
</context-param>
<listener>
<listener-class>org.springframework.web.context.ContextLoaderListener</listener-class>
</listener>

Successivamente viene definita la servlet di gestione per le chiamate remote effettuate da GWT verso il server,che viene lanciata e associata alla nostra applicazione al momento dell’avvio del web container. A questo punto entra in gioco la libreria spring4gwt tramite la classe org.spring4gwt.server.SpringGwtRemoteServiceServlet che si occupa di intercettare le chiamate GWT.
Successivamente nella servlet-mapping vengono definiti tutti gli url a cui la servlet definita sopra dovrà intervenire ogni volta che veranno richiesti. Tramite l’utilizzo dell’asterisco verranno serviti tutti gli url che comincieranno con <nome-applicazione>/springGwtServices/. Da specificare che non deve esistere un corrispondente file fisico html, jps, o di qualsiasi altra estensione, per eseguire la servlet.
Infine troviamo il file della pagina principale:

<servlet>
<servlet-name>springGwtRemoteServiceServlet</servlet-name>
<servlet-class>org.spring4gwt.server.SpringGwtRemoteServiceServlet
</servlet-class>
</servlet>
<servlet-mapping>
<servlet-name>springGwtRemoteServiceServlet</servlet-name>
< url-pattern>/com.provamaven.app.applicazione.Application/springGwtServices/*</url-pattern>
</servlet-mapping>
<welcome-file-list>
<welcome-file>index.html</welcome-file>
</welcome-file-list>
</web-app>

Il file applicationContext.xml

Il file restante è l’applicationContext.xml responsabile del’inizializzazione del contesto operativo. E’ necessario crearlo all’interno della cartella /src/main/webapp/WEB-INF.
La prima riga da analizzare è la seguente:

  • <context:component-scan base-package=”com.provamaven.app.applicazione” />
  • Grazie a questa configurazione Spring eseguirà all’avvio uno scan all’interno del pacchetto indicato, localizzando tutte le annotazioni del tipo:

    • @Component
    • @Repository
    • @Service

    e si occuperà di instanziare le classi annotate ed iniettarle nel contesto di Spring. In questo modo non è necessario scrivere alcun tag xml per la definizione dei beans. Un esempio pratico è la scrittura di un servizio GWT: Quando viene definita l’interfaccia del servizio e la rispettiva implementazione lato server,  viene posta l’annotazione @Service nella classe <nomeServizio>Impl.java. In questo modo all’avvio Spring inserirà automaticamente il servizio con l’id fornito, all’interno del suo contesto.

    Per integrare Spring con Hibernate è necessario definire all’interno dell’ applicationContext l’ EntityManager per la gestione delle persistenze. Va definito quindi il bean chiamato entityManagerFactory tramite la classe org.springframework.orm.jpa.LocalEntityManagerFactoryBean e come proprietà va inserito il nome del nostro assegnato all’interno del file persistence.xml (trattato più avanti). l’entityManagerFactory si occuperà quindi di gestire il datasource.

      <bean id=”entityManagerFactory”>
      <property name=”persistenceUnitName” value=”MyPersistenceUnit” />
      </bean>

    Successivamente viene definito il transactionMenager passandogli come riferimento la factory sopra creata, in questo modo viene creata il meccanismo per l’esecuzione delle transazioni JPA. La classe incaricata è la org.springframework.orm.jpa.JpaTransactionManager

    <bean id=”transactionManager”>
    <property name=”entityManagerFactory” ref=”entityManagerFactory” />
    </bean>

    esempio di file completo applicationContext.xml

    <beans xmlns=”http://www.springframework.org/schema/beans&#8221;
    xmlns:xsi=”http://www.w3.org/2001/XMLSchema-instance&#8221; xmlns:p=”http://www.springframework.org/schema/p&#8221;
    xmlns:aop=”http://www.springframework.org/schema/aop&#8221; xmlns:context=”http://www.springframework.org/schema/context&#8221;
    xmlns:jee=”http://www.springframework.org/schema/jee&#8221; xmlns:tx=”http://www.springframework.org/schema/tx&#8221;
    xmlns:task=”http://www.springframework.org/schema/task&#8221;
    xsi:schemaLocation=”
    http://www.springframework.org/schema/aop http://www.springframework.org/schema/aop/spring-aop-3.0.xsd
    http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans-3.0.xsd
    http://www.springframework.org/schema/context http://www.springframework.org/schema/context/spring-context-3.0.xsd
    http://www.springframework.org/schema/jee http://www.springframework.org/schema/jee/spring-jee-3.0.xsd
    http://www.springframework.org/schema/tx http://www.springframework.org/schema/tx/spring-tx-3.0.xsd
    http://www.springframework.org/schema/task http://www.springframework.org/schema/task/spring-task-3.0.xsd”&gt;
    <context:annotation-config/>
    <context:component-scan base-package=”com.provamaven.app.applicazione” />
    <tx:annotation-driven />
    <bean id=”entityManagerFactory”>
    <property name=”persistenceUnitName” value=”MyPersistenceUnit” />
    </bean>
    <bean id=”transactionManager”>
    <property name=”entityManagerFactory” ref=”entityManagerFactory” />
    </bean>
    </beans>

    Al termine di questa procedura avremo tutti gli strumenti integrati tra loro e pronti all’utilizzo, nel prossimo articolo vedremo le configurazioni necessarie per la comunicazione con un database d’esempio.

    Passo 2 Integrazione con un database MySql

    Written by stracciafabrizio

    March 1, 2011 at 5:39 pm

    3 Responses

    Subscribe to comments with RSS.

    1. […] Integrazione Maven, Spring, Hibernate, Google web Toolkit […]

    2. i want to get one

      visit us

      March 16, 2011 at 9:53 am

    3. […] Articolo precedente mashup Gwt Spring Hibernate […]


    Leave a Reply

    Fill in your details below or click an icon to log in:

    WordPress.com Logo

    You are commenting using your WordPress.com account. Log Out / Change )

    Twitter picture

    You are commenting using your Twitter account. Log Out / Change )

    Facebook photo

    You are commenting using your Facebook account. Log Out / Change )

    Google+ photo

    You are commenting using your Google+ account. Log Out / Change )

    Connecting to %s

    %d bloggers like this: