Sviluppare su OSGi con Camel e GWT

Sviluppare su OSGI
con Camel e GWT
Aperitivo tecnologico del GDG Firenze
http://www.gdg-firenze.info/
Cristiano Costantini - Giuseppe Gerla - Michele Ficarra - Sergio Ciampi - Stefano Cigheri

Chi Siamo

Michele
Sergio

Giuseppe

Stefano Cristiano

Aperitivo Osgi, Camel e GWT

3/108

Sommario
·
·
·
·
·

Introduzione ad OSGi e ServiceMix
Introduzione ad Apache Camel
Utilizzare GWT su ServiceMix
SensorMix: Architettura di esempio
Cool Facts: perchè ci piace questa architettura


4/108

Introduzione a OSGi e ServiceMix
Ovvero un approccio modulare per backend SOA

OSGi: questo sconosciuto
· OSGi: Open Service Gateway initiative
· OSGi Alliance: organizzazione fondata nel 1999 da Ericsson, IBM, Oracle e altri
· OSGi Framework: è un layer di modularità per la piattaforma Java
Il nucleo delle specifiche definisce la gestione del modello del ciclo di vita del
software, i moduli (chiamati bundles), un service registry e un ambiente di
esecuzione.


6/108

Una Metafora:
Pensate ai servizi di Windows o demoni Unix ma completamente Java


7/108

Perchè nasce OSGi
OSGi nasce con lo scopo di creare sistemi embedded per mercati residenziali,
automotive e M2M. In questi contesti è spesso necessario comunicare con i
devices attraverso protocolli differenti.
Il fine, quindi, era quello di fornire un modello di programmazione capace di
realizzare servizi end-to-end creando uno strato di astrazione che unificasse i
differenti protocolli.


8/108

Perchè si espande

“ We’ve all used development platforms in the past,

such as Java Enterprise Edition (JEE), and even
though there have been great advances in this
industry, we’re still building large complex systems,
which are hard to develop, maintain, and extend. ”
Alexandre de Castro Alves
OSGi in Depth - Manning,
pagina 1, riga 1


9/108

Implementazioni OSGi
Esistono diverse implementazioni di OSGi. Quelle più complete sono:
· Apache Felix
· Eclipse Equinox
· Knopflerfish


10/108

Come è fatto un framework OSGi
Il framework può essere rappresentato con tre
layer:
· Il module layer definisce il concetto di modulo
OSGi: il Bundle
· Il lifecycle layer definisce come i bundles sono
dinamicamente installati e gestiti nel
framework OSGi
· Il service layer supporta e promuove un
modello di sviluppo di applicazioni flessibile
che incapsula concetti resi di uso comune dal
service-oriented programming


Service
Lifecycle
Module

11/108

Il “Module layer”
Il cuore del module layer è il Bundle.
Un Bundle è un JAR che contiene metadati extra
(manifest).
A differenza dei JAR il bundle ha:
· un classpath “ristretto” al solo bundle
· un manifest più ricco
Grazie al manifest è possibile estendere la
visibilità del classpath dichiarando esplicitamente
le proprie dipendenze


12/108

Il manifest OSGi
Nel manifest viene specificato anche:
· L’identificazione e la descrizione
· Il classloading
· L’attivazione
Esempi:


13/108

Il manifest OSGi
Manifest di un semplice JAR compilato con maven
Mnfs-eso:10
aietVrin .
BidJk 1704
ul-d: .._0
BitB:ggfrne
ul-y d-iez
CetdB:Aah Mvn
rae-y pce ae


MNFS.F
AIETM

14/108

Il manifest OSGi
Manifest di un Bundle
Mnfs-eso:10
aietVrin .
BdLsMdfe:1870422
n-atoiid 365476
BidJk 1704
ul-d: .._0
BitB:ggfrne
ul-y d-iez
Bnl-aieteso:2
udeMnfsVrin
Bnl-ae GGFrne: Snomx: EapeBnl
udeNm: D iez : esri : xml ude
Bnl-yblcae eapebnl
udeSmoiNm: xml-ude
Bnl-edr GGFrne: SnomxTa
udeVno: D iez : esri em
Bnl-eso:100SASO
udeVrin ...NPHT
Bnl-ciao:cmgol.eeoesggiez.aaevc.ciao
udeAtvtr o.ogedvlpr.dfrnedtsrieAtvtr
CetdB:Aah MvnBnl Pui
rae-y pce ae ude lgn
Epr-akg:
xotPcae
cmgol.eeoesggiez.oe;eso=100SASO"
o.ogedvlpr.dfrnemdlvrin"...NPHT,
cmgol.eeoesggiez.sivrin"...NPHT,
o.ogedvlpr.dfrneog;eso=100SASO"
cmgol.eeoesggiez.evc;eso=100SASO"
o.ogedvlpr.dfrnesrievrin"...NPHT
Ipr-akg:
motPcae
jvxjsjvxjssa,aa.m.idantto,aa.m.s
aa.w,aa.w.opjvxxlbn.noainjvxxlw
To:Bd15.
ol n-.00


MNFS.F
AIETM

15/108

Il “Lifecycle layer”
Il lifecycle layer ha due scopi:
Esternamente gestisce il ciclo di vita del bundle.


16/108

Il “Lifecycle layer”
Il lifecycle layer ha due scopi:
Internamente definisce Bundle Activator

= public static void main(String[] args)


17/108

Il “Service layer”
L’OSGi service layer promuove l’approccio basato su interface ed in particolare
la separazione tra interfacce e implementazioni.
I Servizi OSGi sono interfacce Java che rappresentano un contratto tra il service
provider e i service clients.


18/108

OSGi: la Service Platform
L’OSGi definisce un set minimo di servizi per
agevolare lo sviluppo di applicazioni modulari
· Cofiguration Admin (hot configuration)
· Event Admin
· Console Admin
· Log Service
· Blueprint component framework


19/108

Karaf: un OSGi container
Karaf è un OSGi container in cui sono deployati bundles (e servizi) aggiuntivi per
fornire ulteriori funzionalità tra cui Hot deployment, Dynamic configuration,
Logging System, Extensible Shell console (SSH)
Karaf è un chiaro esempio di architettura basata su OSGi


20/108

ServiceMix: un ESB su OSGi
ServiceMix estende ulteriormente Karaf con funzionalità per
implementare un Enterprise Service Bus.
Le principali funzionalità di ServiceMix sono:
· reliable messaging with Apache ActiveMQ
· messaging, routing and Enterprise Integration Patterns with
Apache Camel
· WS-* and RESTful web services with Apache CXF
· OSGi-based server runtime powered by Apache Karaf
Altre funzionalità offerte da ServiceMix:
· loosely coupled integration between all the other components with Apache ServiceMix NMR including
rich Event, Messaging and Audit API
· complete WS-BPEL engine with Apache ODE


21/108

OSGi e Spring
Uso di Spring dentro a Karaf/ServiceMix
Lo springframework fornisce molte features interessanti (dependency injection, ORM, AOP,...)
Lo Spring Deployer riconosce i file Spring all'interno del folder META-INF/spring di un Jar, e ne istanzia i
bean che vi sono definiti, senza necessità di utilizzare le API OSGi
<xlvrin"."ecdn=UF8?
?m eso=10 noig"T-">
<en xls"tp/wwsrnfaeokogshm/en"
bas mn=ht:/w.pigrmwr.r/ceabas
xlscnet"tp/wwsrnfaeokogshm/otx"
mn:otx=ht:/w.pigrmwr.r/ceacnet
xlsxi"tp/www.r/01XLceaisac"
mn:s=ht:/w.3og20/MShm-ntne
xishmLcto=ht:/w.pigrmwr.r/ceabas
s:ceaoain"tp/wwsrnfaeokogshm/en
ht:/w.pigrmwr.r/ceabassrn-en-..s"
tp/wwsrnfaeokogshm/en/pigbas30xd>

SRN
PIG

<eni=cnue"cas"o.yplcto.elWrdosmr
ba d"osmr ls=cmmapiainHloolCnue"
dsrymto=ogDsry ii-ehd"sint/
eto-ehd"sieto" ntmto=ogIi">
<bas
/en>


22/108

OSGi e Spring
Spring DM
Spring DM permette di utilizzare servizi OSGi da Spring in modo trasparente.
<xlvrin"."ecdn=UF8?
?m eso=10 noig"T-">
bas mn=ht:/w.pigrmwr.r/ceabas
xlsxi"tp/www.r/01XLceaisac"
mn:s=ht:/w.3og20/MShm-ntne
xlsog=ht:/w.pigrmwr.r/ceaog"
mn:si"tp/wwsrnfaeokogshm/si
xlsui=ht:/w.pigrmwr.r/ceaui"
mn:tl"tp/wwsrnfaeokogshm/tl
xlscnet"tp/wwsrnfaeokogshm/otx"
mn:otx=ht:/w.pigrmwr.r/ceacnet
xishmLcto=ht:/w.pigrmwr.r/ceaog
s:ceaoain"tp/wwsrnfaeokogshm/si
ht:/w.pigrmwr.r/ceaog/pigog.s"
tp/wwsrnfaeokogshm/sisrn-sixd>

SRN D
PIG M

<sisrierf"vnSrie
og:evc e=eetevc"
itrae"o.yplcto.elWrdevc"/
nefc=cmmapiainHloolSrie >
<bas
/en>


23/108

Introduzione ad Apache Camel
Ovvero un modo agile per integrare sistemi eterogenei

“Integrare”
Cosa si intende quando parliamo di integrazione?
Trovare una soluzione al seguente problema:

“ Come posso far funzionare insieme molteplici
applicazioni attraverso lo scambio di
informazioni? ”


25/108

Enterprise Integration Patterns
Gli Enterprise Integration Patters offrono soluzioni per affrontare il precedente
problema.
Cosa sono gli EIP?


26/108

Un libro!

Gregor Hohpe and Bobby Woolf
Addison-Wesley 2003

EIP Importanti
Message Channel:
How does one application communicate with another using messaging?

Message:
How can two applications connected by a message channel exchange a piece of information?

Message Router:
How can you decouple individual processing steps so that messages can be passed to different filters depending on a set of conditions?

Message Translator:
How can systems using different data formats communicate with each other using messaging?

Message Endpoint:
How does an application connect to a messaging channel to send and receive messages?

Dead Letter Channel:
What will the messaging system do with a message it cannot deliver?

Message Bus:
What is an architecture that enables separate applications to work together, but in a decoupled fashion such that applications can be easily added or removed without affecting
the others?

Command Message:

How can messaging be used to invoke a procedure in another application?

Document Message:

How can messaging be used to transfer data between applications?

Event Message:

How can messaging be used to transmit events from one application to another?

Request-Reply:

When an application sends a message, how can it get a response from the receiver?

Canonical Data Model:

How can you minimize dependencies when integrating applications that use different data formats?


28/108

Come si può fare integrazione?
I principali metodi tramite cui avviene integrazione sono:
· Scambio di file
· Database condiviso
· Remote Procedure Invocation
· Messaging
Gli EIP si focalizzano sulla integrazione via “messaging” e definiscono una
notazione per rappresentare le soluzioni di integrazione.


29/108

Notazione EIP

http://www.eaipatterns.com/toc.html

Soluzioni con EIP


31/108

Soluzioni con EIP


32/108

Soluzioni con EIP

Attenti a questa qui!


33/108

Come implementare facilmente EIP?
(domanda retorica)
Integrare è però difficile perchè esiste una vasta eterogeneità di protocolli,
interfacce e formati.
Come si possono implementare su una piattaforma Java gli Enterprise
Integration Pattern?
con

“ Apache Camel ”
Concise Application Messaging Exchange Language


34/108

Apache Camel
Apache Camel è un framework di integrazione open-sorce versatile basato sugli
Enterprise Integration Patterns del libro di Hohpe e Woolf.
Include un vasto insieme di componenti per funzionare con molti protocolli di
trasporto e formati dati e permette di definire regole di instradamento e
intermediazione attraverso l’uso di domain-specific language.
...si presta talmente bene alla integrazione che ServiceMix, dalla versione 3 alla
4, ha abbandonato la tecnologia JBI per adottare un nuovo approccio alla
integrazione basato su Camel e OSGi.


35/108

Esempio: Content Based Router

from newOrder
choice
when isWidget to widget
otherwise to gadget


36/108

Content Based Router in Java DSL
from newOrder
choice
otherwise to gadget

pbi casMRueetnsRueule {
ulc ls yot xed otBidr

JV DL
AA S

pbi vi cniue)trw Ecpin{
ulc od ofgr( hos xeto
fo(atvm:uu:eOdr)
rm"cieqqeenwre"
.hie)
coc(
.hnxah"odrpout='igt")
we(pt(/re/rdc
wde')
.o"cieqqeewde"
t(atvm:uu:igt)
.tews(
ohrie)
.o"cieqqeegde"
t(atvm:uu:agt)
.n(;
ed)
}
}


37/108

Content Based Router in Spring XML
from newOrder
choice
otherwise to gadget

<aeCnetxls"tp/cmlaah.r/ceasrn"
cmlotx mn=ht:/ae.pceogshm/pig>
<ot>
rue
<rmui"cieqqeenwre">
fo r=atvm:uu:eOdr/
<hie
coc>
<hn
we>
<pt>odrpout='igt<xah
xah/re/rdc
wde'/pt>
<oui"cieqqeewde">
t r=atvm:uu:igt/
<we>
/hn
<tews>
ohrie
<oui"cieqqeegde">
t r=atvm:uu:agt/
<ohrie
/tews>
<coc>
/hie
<rue
/ot>
<cmlotx>
/aeCnet


SRN XL
PIG M

38/108

Una applicazione Camel completa:
ipr ogaah.ae.aeCnet
mot r.pcecmlCmlotx;
ipr ogaah.ae.ule.otBidr
mot r.pcecmlbidrRueule;
ipr ogaah.ae.mlDfutaeCnet
mot r.pcecmlip.ealCmlotx;

SRN XL
PIG M

pbi casCmlxml {
ulc ls aeEape
pbi sai vi mi(tig]ag)trw Ecpin{
ulc ttc od anSrn[ rs hos xeto
Cmlotx cnet=nwDfutaeCnet)
aeCnet otx
e ealCmlotx(;
cnetadotsnwRueule( {
otx.dRue(e otBidr)
pbi vi cniue){
ulc od ofgr(
fo(jtyht:/...:00tlMSmtig)
rm"et:tp/000088/eleoehn"
.rnfr(ipe"o sy$i.oy")
tasomsml(Yu a {nbd})
.o"eoiyrsos.m)
t(vlct:epnev";
}
};
)
cnetsat)
otx.tr(;
Sse.u.rnl(PesETRt ei";
ytmotpitn"rs NE o xt)
Sse.nra(;
ytmi.ed)
cnetso(;
otx.tp)
}
}


39/108

Camel in ServiceMix
Una volta attivati i bundle di Camel su Karaf-ServiceMix...


40/108

Camel in ServiceMix
...è possibile definire rotte direttamente nei file Spring XML, oppure utilizzare dei RouteBuilder in Java per
avviare delle applicazioni che usano Camel all’interno di ServiceMix.
<xlvrin"."ecdn=UF8?
?m eso=10 noig"T-">
bas mn=ht:/w.pigrmwr.r/ceabas>

SRN XL
PIG M

<aeCnetxls"tp/cmlaah.r/ceasrn"
cmlotx mn=ht:/ae.pceogshm/pig>
<ot>
rue
<rmui"et:tp/000088/eleoehn">
fo r=jtyht:/...:00tlMSmtig/
<ovrBdT tp=jv.agSrn">
cnetoyo ye"aaln.tig/
<rnfr>
tasom
<ipeYusy$i.oy<sml>
sml>o a {nbd}/ipe
<tasom
/rnfr>
<oui"eoiyrsos.m /
t r=vlct:epnev" >
<rue
/ot>
<cmlotx>
/aeCnet
<bas
/en>


41/108

Camel: componenti
162 componenti elencati su camel.apache.org/components.html
ActiveMQ

ActiveMQ
Broker

Activiti

AHC

AMQP

APNS

Atom

Avro

AWS-CW

AWS-DDB

AWS-S3

AWS-SDB

AWS-SES

AWS-SNS

AWS-SQS

Bean

Bean Validation

Browse

Cache

Class

CMIS

Cometd

Context

ControlBus

CouchDB

Crypto

CXF

CXF Bean

CXFRS

DataFormat

DataSet

Db4o

Direct

Direct-VM

Disruptor

DNS

EJB

ElasticSearch

Esper

EventAdmin

Exec

Facebook

File

Flatpack

FOP

FreeMarker

FTP

FTPS

GAuth

Geocoder

GHttp

GLogin

GMail

GTask

Guava
EventBus

Hazelcast

HBase

HDFS

Hibernate

HL7

HTTP

HTTP4

iBATIS

IMAP

IMAPS

Infinispan

IRC

JavaSpace

JBI

JCIFS

jclouds

JCR

JDBC

Jetty

JGroups

JMS

JMX

JPA

Jsch

JT/400

Kestrel

Krati

Language

LDAP

Log

Lucene

MINA

MINA2

Mock

MongoDB

MQTT

MSV

Mustache

MVEL

MyBatis

Nagios

Netty

Netty HTTP Osgi, Camel e GWT
NMR
Aperitivo

OptaPlanner

Pax-Logging

POP3

POP3S

Printer

42/108

Camel: data format
25+ data format elencati su camel.apache.org/data-format.html
Avro

Base64

BeanIO

Bindy

Castor

Crypto

CSV

EDI

Flatpack DataFormat

GZip data format

HL7 DataFormat

JAXB

JiBX

JSON

PGP

Protobuf

Serialization

SOAP

String

XmlBeans

XmlJson

XMLSecurity DataFormat

XStream

Zip DataFormat

Zip File DataFormat


43/108

Utilizzare GWT su ServiceMix
Ovvero un modo diverso per fare Web Application

SOA e SOFEA

http://raibledesigns.com/


45/108

Framework Web per SOFEA

http://raibledesigns.com/


46/108

ServiceMix e le Web Application
ServiceMix non nasce come Web Container ma permette lo stesso di deployare
delle web application.
In particolare risulta molto interessante qualora l’applicazione segua l’approccio
precedente.


47/108

La nostra SOFEA


48/108

Deploy di WAR sotto Karaf/ServiceMix
WAR Deployer
Il WAR Deployer è un bundle che si occupa del deploy di Web Application su
Karaf/ServiceMix

Cosa fa?
· Cerca il file /WEB-INF/web.xml
· Se lo trova, pubblica i file statici e le Servlet definite nel web.xml via HTTP

Ma basta?


49/108

Deploy di WAR sotto Karaf/ServiceMix
Il WAR ha bisogno di modifiche
· Deve avere un file /META-INF/MANIFEST.MF nella root del JAR
· Il MANIFEST.MF deve contenere:
- L'header W b C n e t a h(l'applicazione verrà pubblicata al context
e-otxPt
path specificato da questo header)
- L'header B n l - l s P t : . W B I F c a s s(informa
udeCasah ,E-N/lse
Karaf/ServiceMix dove sono i bytecode)
É raccomandato fare uno Skinny war e usare dipendenze di Bundle (usando il
maven-war-plugin e il maven-bundle-plugin)

Abbiamo Finito?


50/108

Applicazioni GWT sotto Karaf/ServiceMix

...anche gwt-servlet.jar ha bisogno di modifiche!
GWT non è predisposto per essere usato in OSGi.
Non è un bundle perchè al manifest della gwt-servlet.jar mancano gli header OSGi.

E allora?


51/108

Come usare GWT con OSGi
Quattro strade:
Ci sono 4 strade per ottenere un gwt-servlet.jar OSGi compliant e poterlo deployare su Karaf/ServiceMix.
Caso 1:
Compilarsi a mano il gwt-servlet.jar con gli header OSGi necessari
Caso 2:
Deployare il Jar non-OSGi configurandolo al momento della installazione su Karaf/ServiceMix
passando come parametro le informazioni che dovrebbero essere contenute nel MANIFEST.MF
Caso 3:
Aspettare che il ServiceMix Team rilasci il Bundle per GWT-Servlet con gli header OSGi per la
versione 2.6.0
Caso 4:
Sperare che il GWT Project Team accetti la patch, che abbiamo proposto, nella versione GWT
2.6.0 o successive.


52/108

Come usare GWT con OSGi
Che cosa significa?
Caso 1:
gtfthhts/gtgolsuc.o/w rf/hne/155/
i ec tp:/w.ogeorecmgt escags5/317
gtceku FTHHA
i hcot EC_ED
atds
n it
isal- mncmgol.w/w-eve/..
ntl s v:o.ogegtgtsrlt260

Caso 2:
isal- wa:v:o.ogegtgtsrlt260Bnl-aeGTSrltB
ntl s rpmncmgol.w/w-eve/..$udeNm=W-eve&u
nl-yblcaecmgol.w.w-eve&udeVrin260Epr-akg
deSmoiNm=o.ogegtgtsrltBnl-eso=..&xotPca
ecmgol.w.srcin.p.,r.ient.aiao.niecmgol.e
=o.ogegtue.letrc*oghbraevldtregn,o.ogew
bbneyrqetatr.mip.,jvxvldto,oghbraevldtr*
.idr.eusfcoyv.ml*!aa.aiain!r.ient.aiao.
,*cin.,*ip.,&motPcaejvxsrlt*jvxvldto;eou
!.let*!.ml**Ipr-akg=aa.eve.,aa.aiainrsl
to:otoa,r.snrslto:otoa,aa.aiain*rslto:ot
in=pinlogjo;eouin=pinljvxvldto.;eouin=p
inlogjo.;eouin=pinl!o.ogegt**rslto:otoa
oa,r.sn*rslto:otoa,cmgol.w.,;eouin=pinl

Caso 3:
isal- mnogaah.evcmxbnlsogaah.evcmxbnlsgtsrlt2601
ntl s v:r.pcesriei.ude/r.pcesriei.ude.w-eve/.._

Caso 4:
isal- mncmgol.w/w-eve/..
ntl s v:o.ogegtgtsrlt260


53/108

Esempi GWT su ServiceMix
Abbiamo adattato alcuni esempi della distribuzione GWT per funzionare su
Karaf/ServiceMix:
https://github.com/cristcost/gwt-karaf-examples
Tra poco faremo vedere un esempio che mette insieme tutte le tecnologie
raccontate fino ad ora.


54/108

SensorMix
Esempio di architettura basata su ServiceMix, Camel e GWT

Come è composto SensorMix
Architettura esterna


56/108

Come è composto SensorMix
Architettura interna


57/108

Demo

58/108

Data Model Bundle


59/108

Il Canonical Data Model EIP
Dal libro EIP:
“I am designing several applications to work together through Messaging. Each
application has its own internal data format.”
“How can you minimize dependencies when integrating applications that use
different data formats?”


60/108

Il Canonical Data Model EIP


61/108

Il nostro approccio al CDM
A noi piace l’approccio Java first:
· Modello dati: POJO
· Modello servizi: Interfacce Java
Usiamo annotazioni JaxB e JaxWS per generare dal nostro modello gli XML
Schema e WSDL.
Troviamo che cominciare dagli oggetti sia più naturale, lineare e agile:
· Lo XML Schema finale risulta più pulito
· Si può fare a meno della validazione XML
- eccezioni Java = XML non valido
· Lavorare sulle classi Java è più veloce (per noi che siamo sviluppatori)


62/108

Binding Java-XML Schema
@mAcsoTp(mAcsTp.IL)
XlcesryeXlcesyeFED
@mTp(ae="apeeot)
Xlyenm
SmlRpr"
pbi casSmlRpr ipeet Sraial {
ulc ls apeeot mlmns eilzbe

JV
AA

@mAtiuerqie =tu,nm ="esrd)
Xltrbt(eurd
re ae
snoI"
@mShmTp(ae="nUI)
Xlceayenm
ayR"
piaeSrn snoI;
rvt tig esrd
@mAtiuerqie =fle nm ="apeye)
Xltrbt(eurd
as, ae
smlTp"
piaeSrn smlTp;
rvt tig apeye
@mEeetrqie =fle nm ="alSmlRpr"
Xllmn(eurd
as, ae
diyapeeot)
piaeLs<alSmlRpr>diyapeeot;
rvt itDiyapeeot alSmlRprs

<scmlxyenm=SmlRpr"
x:opeTp ae"apeeot>
<satiuenm=snoI"tp=x:nUI ue"eurd/
x:trbt ae"esrd ye"sayR" s=rqie">
<satiuenm=smlTp"tp=x:tig/
x:trbt ae"apeye ye"ssrn">
<ssqec>
x:eune
<seeetnm=diyapeeot tp=tsDiyapeeot
x:lmn ae"alSmlRpr" ye"n:alSmlRpr"
mxcus"none"mncus""/
aOcr=ubudd iOcr=0 >
<x:eune
/ssqec>
<x:opeTp>
/scmlxye


XLSHM
M CEA

63/108

POJO annotati JaxB
@mAcsoTp(mAcsTp.IL)
XlcesryeXlcesyeFED
@mTp(ae="apeeot)
Xlyenm
SmlRpr"
pbi casSmlRpr ipeet Sraial {
ulc ls apeeot mlmns eilzbe

JV
AA

/*Tesno i.*
* h esr d /
@mAtiuerqie =tu,nm ="esrd)
Xltrbt(eurd
re ae
snoI"
@mShmTp(ae="nUI)
Xlceayenm
ayR"
piaeSrn snoI;
rvt tig esrd
/*Tesml tp.*
* h ape ye /
@mAtiuerqie =fle nm ="apeye)
Xltrbt(eurd
as, ae
smlTp"
piaeSrn smlTp;
rvt tig apeye
/*Tediysml rprs *
* h al ape eot. /
@mEeetrqie =fle nm ="alSmlRpr"
Xllmn(eurd
as, ae
diyapeeot)
piaeLs<alSmlRpr>diyapeeot;
rvt itDiyapeeot alSmlRprs
/ ..
/ .


64/108

Interfaccia annotata JaxWS
@eSrienm ="esriSrie,
Wbevc(ae
Snomxevc"
treNmsae="tp/dvlpr.ogecmggiez/ssrie)
agtaepc
ht:/eeoesgol.o/dfrnen/evc"
@OPidn(aaeeSye=Prmtrtl.RPE,sye=SyeDCMN,ue=UeLTRL
SABnigprmtrtl
aaeeSyeWAPD tl
tl.OUET s
s.IEA)
pbi itraeSnomxevc {
ulc nefc esriSrie

JV
AA

@eMto(cin="r:lsSnosd"
Wbehdato
un#itesrIs)
@eusWaprlclae="itesrIsn,
Rqetrpe(oaNm
lsSnosdI"
agtaepc
@epnerpe(oaNm ="itesrIsu"
RsosWaprlclae
lsSnosdOt,
agtaepc
@eRsl(ae="esrd)
Wbeutnm
snoI"
Ls<tig lsSnosd(;
itSrn> itesrIs)
@eMto(cin="r:lsSmlsye"
Wbehdato
un#itapeTps)
@eusWaprlclae="itapeTpsn,
Rqetrpe(oaNm
lsSmlsyeI"
agtaepc
@epnerpe(oaNm ="itapeTpsu"
RsosWaprlclae
lsSmlsyeOt,
agtaepc
@eRsl(ae="apeye)
Wbeutnm
smlTp"
Ls<tig lsSmlsye(;
itSrn> itapeTps)
/ ..
/ .


65/108

Utilizzo del CDM su GWT
Infine, se si vuole usare il data model anche dentro un progetto GWT, basta
aggiungere un modulo .gwt.xml:
GTXL
W M
<xlvrin"."ecdn=UF8?
?m eso=10 noig"T-">
<- We udtn yu vrino GT yusol as udt ti DDrfrne
!- hn paig or eso f W, o hud lo pae hs T eeec,
s ta yu apcntk avnaeo telts GTmdl cpblte.->
o ht or p a ae datg f h aet W oue aaiiis <DCYEmdl PBI "/Gol Ic/DDGol WbTokt251/N
!OTP oue ULC -/oge n./T oge e oli ../E"
"tp/gol-e-oli.ogeoecmsntg
ht:/ogewbtoktgolcd.o/v/as
/../itosuc/oescgtmdl.t"
251dsr-orecr/r/w-ouedd>
<oue
mdl>
<- Seiyteptsfrtasaal cd ->
!- pcf h ah o rnltbe oe <orept=mdl /
suc ah'oe' >
<orept=srie /
suc ah'evc' >
<mdl>
/oue


66/108

Data Service Bundle


67/108

Il bundle dataservice
Contiene un servizio che espone funzionalità di memorizzazione e recupero di
informazioni
Il servizio viene registrato in OSGi tramite Spring DM


68/108

La registrazione del servizio
<si:mpoete i=dtSucPoete"
ogxc-rpris d"aaorerpris
pritn-d"esri.p.essecui"
esseti=snomxjapritnent>
<rpky"esri_bdieCasae>r.slbjbDie<po>
po e=snomxd.rvrlsNm"oghqd.dcrvr/rp
<rpky"esri_bul>dchqd:e:esri_b/rp
po e=snomxd.r"jb:slbmmsnomxd<po>
<rpky"esri_buenm"s<po>
po e=snomxd.srae>a/rp
<rpky"esri_bpswr"<po>
po e=snomxd.asod>/rp
<ogxc-rpris
/si:mpoete>

SRN D
PIG M

<sisrierf"esriSrie>
og:evc e=snomxevc"
<siitrae>
og:nefcs
<au>o.ogedvlpr.dfrnesrieSnomxevc<vle
vlecmgol.eeoesggiez.evc.esriSrie/au>
<au>o.ogedvlpr.dfrneog.esriAmnnefc<vle
vlecmgol.eeoesggiez.siSnomxdiItrae/au>
<og:nefcs
/siitrae>
<og:evc>
/sisrie


69/108

Il servizio in java
pbi casSnomxevcJamlipeet Snomxevc,SnomxdiItrae{
ulc ls esriSriepIp mlmns esriSrie esriAmnnefc

JV
AA

piaeEttMngratr ettMngratr;
rvt niyaaeFcoy niyaaeFcoy
@vrie
Oerd
pbi Ls<tig lsSnosd( {
ulc itSrn> itesrIs)
Ls<tig rsl =nwAryitSrn>)
itSrn> eut
e raLs<tig(;
ty{
r
EttMngre =ettMngratr.raeniyaae(;
niyaae m
niyaaeFcoycetEttMngr)
Tpdur<tig q=e.raeur(SLC si FO Jaesrs,Srn.ls)
yeQeySrn>
mcetQey"EET .d RM pSno " tigcas;
rsl.dAlqgteutit);
eutadl(.eRslLs()
e.ls(;
mcoe)
}cth(xeto e {
ac Ecpin )
lge.o(ee.EEE "ro drn snosls rtivn" e;
ogrlgLvlSVR, Err uig esr it ereig, )
}
rtr rsl;
eun eut
}


70/108

Spring ORM
<eni=ef cas"r.pigrmwr.r.p.oaCnanrniyaaeFcoyen>
ba d"m" ls=ogsrnfaeokomjaLclotieEttMngratrBa"
<rprynm=pritnentae vle"esri_b /
poet ae"essecUiNm" au=snomxd" >
<rprynm=jaedrdpe"
poet ae"pVnoAatr>
<encas"r.pigrmwr.r.p.edrElpeikpVnoAatr>
ba ls=ogsrnfaeokomjavno.cisLnJaedrdpe"
<rprynm=soSl vle"re /
poet ae"hwq" au=tu" >
<ba>
/en
<poet>
/rpry
<rprynm=jarpris>
poet ae"pPoete"
<rp>
pos
<rpky"cisln.d-eeain>raetbe<po>
po e=elpeikdlgnrto"cet-als/rp
<rpky"cisln.ogn.ee"IF<po>
po e=elpeiklgiglvl>NO/rp
<rpky"cisln.evn"fle/rp
po e=elpeikwaig>as<po>
<rpky"aa.essec.dcdie"$snomxd.rvrlsNm}/rp
po e=jvxpritnejb.rvr>{esri_bdieCasae<po>
<rpky"aa.essec.dcul>{esri_bul<po>
po e=jvxpritnejb.r"$snomxd.r}/rp
<rpky"aa.essec.dcue"$snomxd.srae<po>
po e=jvxpritnejb.sr>{esri_buenm}/rp
<rpky"aa.essec.dcpswr"$snomxd.asod<po>
po e=jvxpritnejb.asod>{esri_bpswr}/rp
<pos
/rp>
<poet>
/rpry
<ba>
/en

SRN D
PIG M

<eni=snomxevc"
ba d"esriSrie
cas"o.ogedvlpr.dfrnedtsrieSnomxevcJaml>
ls=cmgol.eeoesggiez.aaevc.esriSriepIp"
<rprynm=ettMngratr"rf"m"/
poet ae"niyaaeFcoy e=ef >
<ba>
/en


71/108

Integration Bundle


72/108

Il bundle di integrazione
Definisce le rotte Camel per l'ingresso dei campioni da Android, Arduino e iOS
Utilizza quasi esclusivamente configurazione via Spring XML
Unica eccezione: la classe SampleAdapter che trasforma da protocol buffer al
nostro data model tramite codice java


73/108

Rivediamo le interfacce SensorMix


74/108

Le rotte di ingresso UDP e HTTP
Usate da Android e da Arduino
<ot>
rue
<rmui"ia:d:/...:08"/
fo r=mn2up/0000101 >
<oui"eajoEty /
t r=sd:snnr" >
<rue
/ot>

SRN XL
PIG M

<ot>
rue
<rmui"et:tp/0000100snomxapeEdon"/
fo r=jtyht:/...:08/esriSmlsnpit >
<oui"eajoEty /
t r=sd:snnr" >

SRN XL
PIG M

<eHae haeNm=CnetTp"
stedr edrae"otn-ye>
<osatapiainjo<cntn>
cntn>plcto/sn/osat
<stedr
/eHae>
<oui"eoiyv_epae/snrsos_epaev"/
t r=vlct:mtmltsjo_epnetmlt.m >
<rue
/ot>


75/108

La rotta di trasformazione del JSON
<ot>
rue
<rmui"eajoEty /
fo r=sd:snnr" >
<ovrBdT tp=jv.agSrn"/
cnetoyo ye"aaln.tig >

SRN XL
PIG M

<nasa>
umrhl
<mjo eeetae"tm aryae"it roNm=ro"/
xlsn lmnNm=ie" raNm=ls" otae"ot >
<umrhl
/nasa>
<oui"stxl_dpesrwcmaatrxl /
t r=xl:staatr/a2d_dpe.s" >
<nasa>
umrhl
<abcnetah"o.ogedvlpr.dfrnesrie /
jx otxPt=cmgol.eeoesggiez.evc" >
<umrhl
/nasa>
<oui"easrienr"/
t r=sd:evcEty >
<rue
/ot>


76/108

La rotta TCP + ProtoBuf
<ot>
rue
<rmui"et:c:/...:08/dcdr=lnt-eoe&m;ycfle /
fo r=ntytp/0000102?eoes#eghdcdrapsn=as" >
<nasa>
umrhl
<rtbfisacCas"o.ogedvlpr
poou ntnels=cmgol.eeoes
.dfrnepoou.esriPoo$apeesg"/
ggiez.rtbfSnomxrtsSmlMsae >
<umrhl
/nasa>
<enrf"apedpe"mto=tasom /
ba e=smlAatr ehd"rnfr" >
<oui"easrienr"/
t r=sd:evcEty >
<rue
/ot>

SRN XL
PIG M

<eni=smlAatr
ba d"apedpe"
cas"o.ogedvlpr.dfrneitgainSmlAatr /
ls=cmgol.eeoesggiez.nerto.apedpe" >

pcaecmgol.eeoesggiez.nerto;
akg o.ogedvlpr.dfrneitgain

JV
AA

pbi casSmlAatr{
ulc ls apedpe
pbi Smlsala tasomSmlMsaemsae {
ulc apePyod rnfr(apeesg esg)
Smlsala rt=nwSmlsala(;
apePyod e
e apePyod)
/ poes'apeesg'adrtr teaatd'apePyod
/ rcs SmlMsae n eun h dpe Smlsala'
rtr rt
eun e;
}
}


77/108

L'output verso il servizio OSGi
<sirfrnei=snomxevc"
og:eeec d"esriSrie
itrae"o.ogedvlpr.dfrnesrieSnomxevc"
nefc=cmgol.eeoesggiez.evc.esriSrie
tmot"00"criaiy".1 /
ieu=300 adnlt=1." >

SRN XL
PIG M

<ot>
rue
<rmui"easrienr"/
fo r=sd:evcEty >
<oui"ensnomxevc?ehdrcrSmls$bd.ape}"/
t r=ba:esriSriemto=eodape({oysmls) >
<rue
/ot>


78/108

Admin WebApp Bundle


79/108

SensorMix GWT Web Application
Abbiamo visto che per il deploy di una Web Application GWT su
Karaf/ServiceMix dobbiamo garantire che:
· Il WAR sia un bundle OSGi compliant
· Che gwt-servlet.jar sia stata correttamente installata come bundle.
Noi cosa abbiamo fatto?


80/108

Configuriamo il maven-bundle-plugin
<ntutos
isrcin>
<udeSmoiNm>{rjc.riatd<Bnl-yblcae
Bnl-yblcae$poetatfcI}/udeSmoiNm>
<udeDsrpin$poetdsrpin<Bnl-ecito>
Bnl-ecito>{rjc.ecito}/udeDsrpin

PMXL
O.M

<e-otxPt>$poetatfcI}/e-otxPt>
WbCnetah/{rjc.riatd<WbCnetah
<udeCasah.WBIFcass/udeCasah
Bnl-lsPt>,E-N/lse<Bnl-lsPt>
<motPcae
Ipr-akg>
cmgol.w.srcin.p.,
o.ogegtue.letrc*
cmgol.w.srcin.p.oecmgol.w.oesae,
o.ogegtue.letrccr.o.ogegtcr.hrd
cmgol.w.srcin.p.oejv.ag
o.ogegtue.letrccr.aaln,
cmgol.w.srcin.p.oejv.ah
o.ogegtue.letrccr.aamt,
cmgol.w.srcin.p.oejv.q,
o.ogegtue.letrccr.aasl
cmgol.w.srcin.p.oejv.tl
o.ogegtue.letrccr.aaui,
cmgol.w.srcin.p.oejv.tllgig
o.ogegtue.letrccr.aaui.ogn,
cmgol.w.srsre.p.oejv.ag
o.ogegtue.evrrccr.aaln,
cmgol.w.srsre.p.oejv.tl
o.ogegtue.evrrccr.aaui,
!o.ogegt*cin.,
cmgol.w..let*
*
<Ipr-akg>
/motPcae
<isrcin>
/ntutos


81/108

Configuriamo il maven-war-plugin
Ricordate lo skinny war?
Si tolgono le dipendenze dalla lib:
<akgnEcue>E-N/i/
pcaigxldsWBIFlb,
WBIFcassMT-N//akgnEcue>
E-N/lse/EAIF<pcaigxlds

PMXL
O.M

Si istruisce Maven di copiare il Manifest al posto giusto:
<rhv>
acie
<aietie
mnfsFl>
$poetbidotuDrcoy/EAIFMNFS.F
{rjc.ul.uptietr}MT-N/AIETM
<mnfsFl>
/aietie
<acie
/rhv>


PMXL
O.M

82/108

Importiamo il Canonical Data Model
Nel file SensormixAdminApp.gwt.xml:
<neisnm=cmgol.eeoesggiez.esri'/
ihrt ae'o.ogedvlpr.dfrneSnomx >

.W.M
GTXL

Nel pom.xml:
<eedny
dpnec>
<ruI>o.ogedvlpr.dfrne/ruI>
gopdcmgol.eeoesggiez<gopd
<riatdsnomxdtmdlai/riatd
atfcI>esri-aaoe-p<atfcI>
<eso>{rjc.eso}/eso>
vrin$poetvrin<vrin
<dpnec>
/eedny
<eedny
dpnec>
<ruI>o.ogedvlpr.dfrne/ruI>
gopdcmgol.eeoesggiez<gopd
<riatdsnomxdtmdlai/riatd
atfcI>esri-aaoe-p<atfcI>
<eso>{rjc.eso}/eso>
vrin$poetvrin<vrin
<lsiirsucs/lsiir
casfe>ore<casfe>
<dpnec>
/eedny


PMXL
O.M

83/108

GWT RPC Plumbing diagram
Siamo partiti da qui...


84/108

Sensormix RPC Plumbing diagram
...per arrivare qui


85/108

GWT RPC in Sensormix
Lato Client
Instanziare la service interface usando GWT.create():
GtesriSriesn snomxevc
wSnomxevcAyc esriSrie
=GTcet(wSnomxevc.ls)
W.raeGtesriSriecas;

JV
AA

Fare la chiamata al servizio:
snomxevc.itesrIsnwAycalak){
esriSrielsSnosd(e snClbc(
@vrie
Oerd
pbi vi oFiueTrwbecuh){
ulc od nalr(hoal agt
/ hnl terqetfiue
/ ade h eus alr
}

JV
AA

@vrie
Oerd
pbi vi oScesLs rsl){
ulc od nucs(it eut
/ hnl tersos fo tesrie
/ ade h epne rm h evc
}
};
)


86/108

GWT RPC in Sensormix
Lato Server
SensormixServiceProxy.java è un servizio GWT che usa un servizio OSGi. Nella inizializazione ottiene dei
riferimenti al servizio utilizzando le API del Framework.
pbi vi ii( trw Srltxeto {
ulc od nt) hos eveEcpin

JV
AA

fnlBnlCnetcnet=Faeoktlgtudeti.eCas).eBnlCnet)
ia udeotx otx
rmwrUi.eBnl(hsgtls()gtudeotx(;
takr=nwSrierce(otx,Snomxevc.ls.eNm(,nl)
rce
e evcTakrcnet esriSriecasgtae) ul;
takroe(;
rce.pn)
}

Come viene usata l’istanza del servizio OSGi?
piaeSnomxevc gtevc( {
rvt esriSrie eSrie)
rtr (esriSrie takrwiFrevc(00)
eun Snomxevc) rce.atoSrie100;
}

JV
AA

pbi Ls<tig lsSnosd( {
ulc itSrn> itesrIs)
rtr gtevc(.itesrIs)
eun eSrie)lsSnosd(;
}


87/108

Cool Facts
Ovvero perchè ci piace questa architettura

Integrazione di Arduino


89/108

Integrazione di Arduino


90/108

Integrazione di Android
JV
AA
HtPs htps =nwHtPs(r.otig);
tpot tpot
e tpotultSrn()
htps.eHae(Cnettp" "plcto/sn)
tpotstedr"otn-ye, apiainjo";
SrnEtt s =nwSrnEtt(oyoHtPsRqet;
tigniy e
e tigniybdFrtpoteus)
s.eCnetnoignwBscedrHT.OTN_YE
estotnEcdn(e aiHae(TPCNETTP,
"plcto/sn);
apiainjo")
htps.eEtt(e;
tpotstniys)
HtRsos rsos =htcin.xct(tpot;
tpepne epne
tpleteeuehtps)
Srn tm =EttUistSrn(epnegtniy);
tig ep
niytl.otigrsos.eEtt()
lge.no"SNps rsos:"+tm)
ogrif(JO ot epne
ep;


91/108

Integrazione di Android - NFC
JV
AA
Tgtg=gtnet)gtaclbexr(fAatrETATG;
a a
eItn(.ePrealEtaNcdpe.XR_A)
SrnBidri =nwSrnBidr)
tigule d
e tigule(;
bt[ dt =tggtd)
ye] aa
a.eI(;
fr(n i=0 i<dt.egh i+ {
o it
;
aalnt; +)
i.pedSrn.omt"0x,dt[])
dapn(tigfra(%2" aai);
i ( <dt.egh-1 {
f i
aalnt
)
i.ped"";
dapn(:)
}
}
JOOjc joSmlPce =nwJOOjc(;
SNbet snapeakt
e SNbet)
JOOjc oj=nwJOOjc(;
SNbet b
e SNbet)
joSmlPce.u(sml" oj;
snapeaktpt"ape, b)
ojpt"eiei" "h dvc i";
b.u(dvc_d, te eie d)
ojpt"ie,dtFra.omtnwDt();
b.u(tm" aeomtfra(e ae))
ojpt"f" i)
b.u(nc, d;
Itn itn =nwItn(hs DtSneSriecas;
net net
e netti, aaedrevc.ls)
itn.uEtaDtSneSrieITN_XR,
netptxr(aaedrevc.NETETA
joSmlPce.otig);
snapeakttSrn()
satevc(net;
trSrieitn)


92/108

Installiamo ServiceMix


93/108

Creare una distribuzione della applicazione


94/108

Le Karaf Features
<etrsnm=snomx100>
faue ae'esri-..'
<etr nm=snomxcr"vrin".."
faue ae"esri-oe eso=100>
<udemncmgol.eeoesggiez/esri-aaoe-p/..<bnl>
bnl>v:o.ogedvlpr.dfrnesnomxdtmdlai100/ude
<faue
/etr>

FAUE.M
ETRSXL

<etr nm=snomxdtsrie vrin".."
faue ae"esri-aaevc" eso=100>
<etr vrin".."snomxcr<faue
faue eso=100>esri-oe/etr>
<etr>pigom/etr>
fauesrn-r<faue
<- ..->
!- . <udemnmslmslcnetrjv/..6/ude
bnl>v:yq/yq-onco-aa512<bnl>
<udemnogaah.evcmxbnlsogaah.evcmxbnlscmosdc/._<bnl>
bnl>v:r.pcesriei.ude/r.pcesriei.ude.omn-bp143/ude
<udemnogaah.evcmxbnlsogaah.evcmxbnlsjvxijc/_<bnl>
bnl>v:r.pcesriei.ude/r.pcesriei.ude.aa-net12/ude
<udemnogelpepritnejvxpritne210/ude
bnl>v:r.cis.essec/aa.essec/..<bnl>
<udemnogelpepritneogelpepritneja250/ude
bnl>v:r.cis.essec/r.cis.essec.p/..<bnl>
<- ..->
!- . <udemncmgol.eeoesggiez/esri-aaevc-ude100/ude
bnl>v:o.ogedvlpr.dfrnesnomxdtsriebnl/..<bnl>
<faue
/etr>
<etr nm=snomx vrin".."
faue ae"esri" eso=100>
<etr vrin".."snomxdtsrie/etr>
faue eso=100>esri-aaevc<faue
<etr vrin".."snomxwbevc<faue
faue eso=100>esri-esrie/etr>
<faue
/etr>
<faue>
/etrs


95/108

Il Features Maven Plugin di Karaf
<lgn
pui>
<ruI>r.pcekrftoig/ruI>
gopdogaah.aa.oln<gopd
<riatdfaue-ae-lgn/riatd
atfcI>etrsmvnpui<atfcI>
<eso>{etrspui.eso}/eso>
vrin$faue.lgnvrin<vrin
<xctos
eeuin>
<xcto>
eeuin
<dadfaue-orp<i>
i>d-etrst-eo/d
<hs>akg<pae
paepcae/hs>
<ol>
gas
<oladfaue-orp<ga>
ga>d-etrst-eo/ol
<gas
/ol>
<ofgrto>
cniuain
<ecitr>
dsrpos
<ecitrcmgol.eeoesggiez
dsrpo>o.ogedvlpr.dfrne
/esri-elyfaue/../m/etrs/ecitr
snomxdpo-etrs100xlfaue<dsrpo>
<dsrpos
/ecitr>
<etrs
faue>
<etr>esri/..<faue
fauesnomx100/etr>
<faue>
/etrs
<eoioytre/oa-eo/eoioy
rpstr>agtlclrp<rpstr>
<cniuain
/ofgrto>
<eeuin
/xcto>
<eeuin>
/xctos
<pui>
/lgn


FAUE.M
ETRSXL

96/108

Installiamo SensorMix


97/108

Kryo e Benchmark
Si è scelto di utilizzare un’unica classe per tutti i sample (con un campo
b t [ che contiene la serializzazione (Kryo) del sample).
ye]
Sfruttando l’astrazione di JPA sono stati fatti benchmark di occupazione e
performance per supportare le scelte e validare la soluzione.


98/108

ServiceMix: Quanto overhead?
Il pacchetto ServiceMix occupa circa 65MB sul filesystem


99/108

Maven ed Eclipse
SensorMix è stato sviluppato in Team utilizzando Maven ed Eclipse.
In particolare:
· Sviluppo GWT integrato nello stesso Java IDE
· Distribuzione tramite Karaf's Features Maven Plugin
· Checkstyle e PMD per migliorare la cooperazione del Team


100/108

Conclusioni
Considerazioni finali e riferimenti bibliografici

Issue su GWT
Serve GWT 2.6.0 che sia reso OSGi ready:
· per favore aiutateci, votate lo issue sulla Osgify di GWT:
- http://goo.gl/GEuVBR
· oppure lo issue su Jira per avere il bundle rilasciato da ServiceMix il prima
possibile:
- http://goo.gl/jFsVcP

Materiali
Slides:
http://cristcost.github.io/sensormix/
Sensormix:
https://github.com/cristcost/sensormix/
Sensormix Android:
https://github.com/cristcost/sensormix-android/
Sensormix Arduino:
https://github.com/michelefi/sensormix-arduino/


103/108

Libri
Camel in Action
C. Ibsen, J. Anstey - Manning
Enterprise Integration Patterns
G. Hohpe, B. Woolf - Addison Wesley
Spring DM in Action
A. Cogoluègnes, T. Templier, A. Piper - Manning
OSGi in Action
R. S. Hall, K. Pauls, S. McCulloch, D. Savage - Manning
OSGi In depth
Alexandre de Castro Alves - Manning

Links
Apache Camel:
http://camel.apache.org/
Apache ServiceMix:
http://servicemix.apache.org/
Apache Karaf:
http://karaf.apache.org/
GWT:
http://www.gwtproject.org/


105/108

Q&A

106/108

<Thank You!>
Cristiano Costantini cristiano.costantini@gmail.com
Giuseppe Gerla giuseppe.gerla@gmail.com
Michele Ficarra miche.ficarra@gmail.com
Sergio Ciampi sergio.ciampi@gmail.com
Stefano Cigheri stefano.cigheri@gmail.com

Sviluppare su OSGi con Camel e GWT

Sviluppare su OSGi con Camel e GWT

Recommandé

Recommandé

Contenu connexe

Similaire à Sviluppare su OSGi con Camel e GWT

Similaire à Sviluppare su OSGi con Camel e GWT (20)

Sviluppare su OSGi con Camel e GWT