E beviamo or su questo tavolo, la dove la notte ci fa compagnia, lontano dalle strade e dal rumore della vita quotidiana. Su questa vetta alta la dove tutti ci guardano e dove  tutti desiderano di essere.

Brindo a te amico mio… che con il passare del tempo hai dato alla tua vita un senso ed una via…

Brindo a te amico mio… che con la tua testardaggine hai superato ogni cosa…

Brindo a te amico mio… che con la tua fermezza sei arrivato a toccare la vita con mano fino in fondo…

Brindo a te amico mio… che quando ridi trasmetti forza e passione…

Brindo a te amico mio… che nel tuo giardino abbondano rose e fior e quel che sai fare è cercarne ancor…

Brindo a te amico mio… che in qualsiasi parte del mondo saremo, sarà sempre un giorno a dividerci…

Beviamo dai nostri bicchieri e mandiamo giù questa vita che ci riserva ancor sorprese e speranze…

E ridiamo delle nostre sofferenze e delle nostre paure perchè ancora una volta siamo sul tetto del mondo…

Allor non rimane che dirti

Grazie amico mio

Nel sezione precedente si sono eseguiti tutti i passi necessari per la preparazione dell’IDE di sviluppo Eclipse. L’ultima parte riguarda invece la scelta del DataBase relazionale da utilizzare e le configurazioni necessarie per l’utilizzo. Uno dei vantaggi nell’uso degli strumenti presentati sin d’ora, è quello di poter variare la base dati a cui si fa riferimento con delle semplici modifiche.
Nel nostro caso utilizzeremo mySQL come DB. Grazie all’utilizzo di Hibernate come livello intermedio tra l’applicazione creata e il DB, non saranno presenti problemi di compatibilità poichè Hibernate stesso si occuperà di tradurre il linguaggio sql scritto nel corrispondente dialetto della base di dati sottostante.

Comunicazione con un database sul web

Nelle più classiche applicazioni client-server, scritte in modo accurato, la connessione con il database non dovrebbe quasi mai generare problemi. Nel caso di applicazioni che viaggiano attraverso il web, gestire la chiusura di una connessione è una operazione molto più complessa. A differenza delle applicazioni classiche, infatti, la chiusura della connessione viene lasciata all’utente che, al termine della sua sessione di lavoro, dovrebbe esplicitamente effettuare un’operazione di logout dal database.
Esistono una serie di rischi collegati a questa metodologia di lavoro. Il rischio di timeouts, dovuti ad attese prolungate, che possono anche derivare da momenti di lentezza della rete o da una più bassa velocità di trasferimento, possono rivelarsi pericolosi, poichè non permetterebbero la corretta gestione delle risorse aperte.

La possibilità che un elevatissimo numero di utenti possano accedere alla stessa applicazione web in contemporanea può comunque rivelarsi problematico, soprattutto se il database ha un numero limitato di connessioni contemporanee possibili. Per risolvere e gestire questi problemi si fa ricorso ad un Connection Pool.

Connection pool

Il “Connection Pool” è come se fosse un oggetto che gestisce un insieme di connessioni, la cui logica di funzionamento è piuttosto semplice.

Quando viene istanziato, questo gestore si occupa di aprire una serie di connessioni verso il database. Ogni qualvolta altri oggetti necessitano di accedere al database, richiedono la connessione al gestore che ne fornisce una libera. Quando l’operazione sarà terminata l’oggetto restituirà la connessione al gestore che potrà quindi metterla a disposizione di altri oggetti che la richiederanno. In questo modo non vi sarà alcun degrado nelle prestazioni, in quanto le connessioni non saranno ricreate ogni volta, ma solamente in fase di attivazione dell’applicazione, così come non vi saranno rischi di connessioni inattive bloccate per lungo tempo, in quanto, una volta completata l’operazione, questa viene rilasciata ritornando nuovamente a disposizione.
Hibernate mette a disposizione la possibilità di utilizzare c3p0 come connection pool per la gestione delle connessioni. Più avanti verrà presentato il file necessario per la configurazione.

Integrazione MySQL

Per l’inserimento delle librerie necessarie utilizzeremo ancora una volta Maven.
Nel file pom.xml, sotto la voce dependencies, cliccando sul tasto add è possibile effettuare una ricerca diretta nel repository centrale.
La libreria da ricercare,necessaria alla comunicazione è la seguente:

• mysql-connector-java

Ad ogni DB corrisponde una specifica libreria, ad esempio se il database utilizzato fosse stato Hipersonic:

• org.hsqldb

• • Cliccare su salva e attendere il completamento del download.
  • Il successivo passo sarà quello di impostare i parametri di connessione e comunicazione al database nel file persistence.xml di Hibernate.  Solitamente le configurazione per la connessione vengono inserite in un file Hibernate.config ma in questo caso, utilizzando le JPA tutti i parametri vengono inseriti nel file sopra indicato. Il file deve essere inserito nella cartella META-INF accessibile all’applicazione durante l’esecuzione. Situata nel path /src/main/resources/META-INF, questa directory non viene creata durante l’inizializzazione del progetto è quindi necessario crearla.
  • Dopo le prime righe di intestazione si definiscono i primi parametri di creazione per il livello delle persistenze:
  • name
  • (Attributo) Nome dell’entity manager. Questo parametro viene utilizzato alla creazione dell’EntityManagerFactory al boot di Spring.
  • transaction-type
  • (Attributo) tipo di transazione utilizzato. O JTA o RESOURCE_LOCAL (di default viene utilizzato  JTA in un ambiente JavaEE e RESOURCE_LOCAL in un ambiente JavaSE). Quando viene utilizzato un JTA- datasource, di default viene settato JTA, altrimenti viene utilizzato per default il paramentro  RESOURCE_LOCAL.
  • provider
  • Va specificato il nome completo della classe che implementa il provider ejb. org.hibernate.ejb.HibernatePersistence è il provider di Hibernate che implementa le EJB3
    

    <persistence xmlns=”http://java.sun.com/xml/ns/persistence”xmlns:xsi=”http://www.w3.org/2001/XMLSchema-instance”  xsi:schemaLocation=”http://java.sun.com/xml/ns/persistence http://java.sun.com/xml/ns/persistence/persistence_2_0.xsd” version=”2.0″> <persistence-unit name=”MyPersistenceUnit” transaction-type=”RESOURCE_LOCAL”> <provider>org.hibernate.ejb.HibernatePersistence</provider>

    Nella parte <properties> vengono definite  tutte le proprietà riguardanti  la tipologia del DB, il dialetto utilizzato, l’indirizzo del server DB, e lo username e password per la connessione.

    <properties><property name=”hibernate.hbm2ddl.auto” value=”update” />  <property name=”hibernate.show_sql” value=”false” /> <property name=”hibernate.dialect” value=”org.hibernate.dialect.MySQLDialect” /> <property name=”hibernate.connection.driver_class” value=”com.mysql.jdbc.Driver” /> <property name=”hibernate.connection.url” value=”jdbc:mysql://localhost/commenti” /> <property name=”hibernate.connection.username” value=”root” /> <property name=”hibernate.connection.password” value=”" />

    inoltre viene definito il connection pool necessario all’applicazione per la comunicazione, in questo caso viene utilizzato il c3p0 e le sue voci principali settate di default sono::

    min_Size e max_Size

    dimensione minima e massime del pool di connessioni a seguito di aperture e chiusure successive.

    timeout

    tempo massimo prima che una connessione sia considerata scaduta e sia chiusa.

    max_statements

    abilita e disabilita la cache dei PreparedStatements

    <property name=”hibernate.c3p0.min_size” value=”5″ /><property name=”hibernate.c3p0.max_size” value=”20″ />  <property name=”hibernate.c3p0.timeout” value=”300″ /> <property name=”hibernate.c3p0.max_statements” value=”50″ /> <property name=”hibernate.c3p0.idle_test_period” value=”3000″ /> </properties> <persistence-unit> </persistence>

    Al termine delle configurazioni sopra indicate, la creazione di ogni servizio seguirà la seguente struttura di interfacce.

    SCHEMA COMPLETO

    RIFERIMENTI:

    http://community.jboss.org/wiki/HowToconfiguretheC3P0connectionpool
    http://www.mchange.com/projects/c3p0/index.html#appendix_d

For removing powered by Phoca guestbook,  we must delete return function called getPhocaId($id)  /components/com_phocaguestbook/helpers/phocaguestbook.php

Change return value :

return $output

with

return null

thanks to Elvi

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:

• Id : JBoss URL : http://repository.jboss.org/maven2/

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” > <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” xmlns:xsi=”http://www.w3.org/2001/XMLSchema-instance” xmlns:p=”http://www.springframework.org/schema/p” xmlns:aop=”http://www.springframework.org/schema/aop” xmlns:context=”http://www.springframework.org/schema/context” xmlns:jee=”http://www.springframework.org/schema/jee” xmlns:tx=”http://www.springframework.org/schema/tx” xmlns:task=”http://www.springframework.org/schema/task” 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”> <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

Con il termine RIA (Rich Internet Application) vengono indicate applicazioni capaci di fornire all’utente un’esperinza di navigazione accattivante, dinamica e in una sola parola: coinvolgenti.

“Le Rich Internet Application (RIA) sono applicazioni web che possiedono le caratteristiche e le funzionalità delle applicazioni desktop, senza però necessitare dell’installazione sul disco fisso.

Le RIA si caratterizzano per la dimensione interattiva, la multimedialità e per la velocità d’esecuzione. Infatti la parte dell’applicazione che elabora i dati è trasferita a livello client e fornisce una pronta risposta all’interfaccia utente, mentre la gran parte dei dati e dell’applicazione rimane sul server remoto, con notevole alleggerimento per il computer utente. Le RIA si fondano perciò su un’architettura di tipo distribuito.

Anche l’interazione con una RIA avviene in remoto, tramite un comune web browser.

In un certo senso le RIA rappresentano una generazione di applicazioni che permette un’interazione totalmente rinnovata, fondata sugli aspetti migliori delle caratteristiche funzionali e progettuali che finora erano prerogativa alternata del web o delle applicazioni desktop.

Inoltre le RIA, per il livello spinto di interattività che esse offrono, rappresentano uno dei canali migliori attraverso il quale si va imponendo il paradigma del Cloud Computing, che costituisce una nuova modalità di fruizione del software tramite architetture distribuite.” da wikipedia

L’idea è quella di vedere un social network come una rich internet application.  In questo si ha la possibilità di utilizzare gli strumenti e tecniche di sviluppo utilizzate per applicazioni web based e applicarle alla colonna portante del web 2.0.

Quali sono queste tecniche ? E soprattutto quali sono gli strumenti più adatti per raggiungere questo scopo?

Negli articoli successivi verranno presentate le tecnologie utilizzate per la realizzazione di una social RIA.

Integrazione Maven, Spring, Hibernate, Google web Toolkit

For removing powered by Phoca Documentation,  we must delete return function called getPhocaId($id)  /administrator/components/com_phocagallery/helpers/phocagallery.php

Change return value :

return $output

with

return null

Interessante la licenza sotto la quale il libro viene pre-pubblicato: Open Feedback Publishing System. Da quanto riportato sul sito della casa madre, questa nuovo licenza permette all’autore  di pubblicare la versione working-progress dei capitoli, fornendo agli utenti la possibilità di lasciare feedback sul lavoro compiuto, dare consigli e commentare le sessioni interessate. In questo modo l’utente ha la possibilità di partecipare in maniera attiva alla stesura dello scritto.

Programming Android

Questo “cane” non è tutto rosa e fiori come sembra. E’ bello, ha aspetto lupino, nelle sue vene scorre davvero sangue di lupo. Il problema è che del lupo ha conservato (e per certi versi esasperato) anche l’indole e il carattere.

Sono “tosti”, nel vero senso della parola, in modo non comparabile agli altri cani. Un cane di qualsiasi razza se sei bravo lo educhi, lo sottometti, poni dei limiti a quello che gli è consentito fare e finisce lì.

Questi no. Questi sono recidivi. Ti sfidano ogni giorno fin da quando aprono gli occhi sul mondo (vederti ringhiare contro una pulce di due mesi col pelo ritto e i canini scoperti fa impressione, vi assicuro), ti mettono alla prova per testare la tua abilità di capobranco. Ogni giorno aspettano solo un tuo piccolo errore per approfittarsi della tua momentanea debolezza e spodestarti. Non puoi concederti di abbassare la guardia. Continuano e tornano a sfidarti ciclicamente, spesso ringhiandoti contro, e non lo fanno per cattiveria. Lo fanno perchè la natura vuole che un branco abbia come leader il soggetto più valido e competente, natura vuole che ogni membro si assicuri che il branco è in buone mani, per il bene di tutti.

Sono molto dominanti, chi più e chi meno lo sono tutti, e non parlo di dominanza passiva. Guai a permettere ad un maschio di occupare abitudinariamente (o anche solo una volta, se è per questo) una posizione elevata, come il divano. Una cosa simile rafforzerà la sua sicurezza e lo porterà a sfidarti (spesso ho letto di clc che si sono rivoltati contro il padrone ringhiando e sì, anche minacciando il morso, se non provandoci, perchè non volevano scendere dal divano).

Sono distruttivi, al punto che nel 90% dei casi non possono essere lasciati soli in casa (pena la demolizione… ho letto di alcuni che hanno perfino fatto i buchi nelle pareti)
Non possono essere lasciati a se stessi. Il branco per loro è tutto, un’assenza anche breve del padrone per loro è straziante, se non sono stati abituati fin da cuccioli a restare soli almeno per alcune ore al giorno.

Saltano recinzioni di quasi tre metri, vi lascio immaginare in che razza di bunker occorre trasformare il proprio giardino.

Son coraggiosi nel senso che non hanno paura delle cose che solitamente spaventano i cani (tuoni, fuochi d’artificio, colpi di pistola, aspirapolvere… ho visto un video di un’allevatriche che quando fanno la muta li libera dal pelo morto con l’aspirapolvere  )
Però possono essere molto diffidenti nei confronti delle persone, al punto di non farsi neppure accarezzare, o nemmeno avvicinare. Se non vengono socializzati a fondo, ovvero abituati alla presenza costante dell’uomo e degli estranei, tendono ad averne paura, perchè per loro non sono un elemento naturale. Non fanno la guardia, generalmente, a meno che non siano almeno in due e non facciano branco tra loro. Come i lupi, se avvertono il pericolo, più che attaccare preferiscono scappare o nascondersi. O in casi estremi puo scattare il predatorio e allora l’intruso diventa una potenziale preda, per questo tentano di sorprenderla anzicchè rivelare la propria presenza abbaiando.

Guai ad accarezzare un CLC sulla testa. Per loro è un gesto di sfida, rischiereste di rimetterci la mano.

Ad una famiglia che aveva una casa con un grande terreno è capitata una cosa molto brutta. Con tanta campagna a disposizione il loro CLC si è reinselvatichito, in pratica è tornato selvatico, cacciava da solo galline, conigli, piccoli selvatici, non si faceva più avvicinare. Ora se non erro dovrebbe essere a lavoro con un comportamentalista per essere recuperato. E’ solo un esempio ma spero renda l’idea di come sono questi cani.

Difficilmente abbaiano (e comunque il loro abbaio è un suono gutturale abbastanza ridicolo) più che altro fanno tantissimi versi diversi, ululano tanto, ringhiano (anche solo per comunicare, non necessariamente per minacciare, a differenza dei cani), hanno una mimica è una gamma di segnali e di versi enorme, molto più sviluppata di quella di un cane, più vicina a quella di un lupo, tanto che spesso faticano a comunicare con i cani, a farsi capire dalle altre razze, sopratutto da quelle non lupoidi.

Dovrebbe essere un cane da utilità, è stato concepito per esserlo, ma in realtà non viene usato. Questo perchè sono difficilissimi da addestrare. Anche perchè ascoltano incondizionatamente il pardone solo dopo che questo si è veramente e incondizionatamente imposto (e potrebbero volerci anni!)

Tuttavia sono estremamente intelligenti. Basti pensare che il lupo ha un cervello che è 30% più grande di quello di un cane. Infatti i CLC fanno cose assurde, aprono le porte (ho letto di un clc che se la porta non si apre dalla maniglia, punta la chiave!), le portiere delle macchine, i frigoriferi, le porte dei box. Molti sono costretti a chiudere cassetti e credenze con dei chiavistelli per evitare che il lupo li apra. Il fatto che siano così intelligenti li rende ancora più difficili da gestire.

Non sono cani che vanno presi alla leggera, sono dei cicloni. Ci sono un sacco di CLC da adottare in giro perchè la gente li prende e poi quasi subito si rende conto di non riuscire a gestirli. Alcuni diventano mordaci e aggressivi perchè i padroni non riescono a dar loro una figura di capobranco (proprio ora ce n’è uno che attende di essere soppresso, perchè ha morso  ) Basti pensare che (a differenza di quanto dice lo standard) un maschio puù arrivare a 73 cm al garrese e pesare oltre 45 chili. Un maschio di queste dimensioni, incazzato perche si sente sfidato è concretamente pericoloso.