EIP with Apache Camel

Enterprise Integration Patternscon

Apache Camel

Andrea Torino Rodriguezmarzo 2013

[email protected]

http://creativecommons.org/licenses/by-sa/3.0/deed.it

Cosa vi racconto

• E.I.P., E.A.I. : di cosa parliamo

• Apache Camel architecture

• Apache Camel essentials

• Il mio Caso d’uso

• Riferimenti…

• Q & A

E.I.P., E.I.A. : di cosa parliamo

Enterprise Integration Patterns: “una collezione definita e riconosciuta di approcci risolutivi per casi di integrazione di sistemi software”

Enterprise Application Integration:“un (il) processo di integrazione di sistemi software, mediante l’uso di E.I.P.”…spesso anche

“la piattaforma utilizzata per attuare il processo di integrazione stesso (piattaforma E.A.I.)”

1/6


Enterprise Integration Patterns: Dal libro omonimo di Gregor Hohpe e Bobby

Woolf 65 pattern principali individuati Organizzati in “categorie”

Integration Styles (modalità di integrazione) Channel patterns (sistemi di messaging) Message construction patterns (forme, contenuti

dei msg.) Routing patterns (meccanismi di instradamento dei

msg.) Transformation patterns (editing dei contenuti dei

msg.) Endpoint patterns (comportamento dei client) System management patterns (manutenzione

sistemi e.i.)

2/6


Enterprise Integration Patterns:

+ +

=

3/6


La fonte di riferimento per Enterprise Integration Patterns: http://www.eaipatterns.com

Risorse, link, pubblicazioni, talk, downloads vari ed i contatti di Gregor

…si pronuncia “hoh-puh” !

4/6


Camel fornisce una serie di strumenti per poter facilmente supportare gli “Integration Styles”

5/6

File transferOgni applicazione produce Files contenenti informazioni che altre applicazioni hanno necessità di consumare.

Shared databaseIntegrare le applicazioni facendo in modo che salvino i propri dati in un Repository condiviso.


Camel fornisce una serie di strumenti per poter facilmente supportare gli “Integration Styles”

6/6

Remote procedure invocationPensare ogni applicazione come un componente avente dati incapsulati. Utilizzare Interfacce per permettere l’interazione con le altre applicazioni.

MessagingUsare Messaging per trasferire pacchetti di dati velocemente, frequentemente, in modo asincrono ed affidabile usando formati personalizzati.

Apache Camel architecture

E’ difficile definire cosa sia Camel …proviamoci, è stata definita come:

Lightweight Integration Framework Open-source lightweight

Integration Library Routing and mediation Engine E.I.P. implementation Library Open-source Integration

Framework based on E.I.P.

1/15


…Può far comodo definire cosa NON sia Camel:

Enterprise Service Bus (ESB) Container (ServiceMix/FuseESB,

OSGi, Tomcat, Jboss, Geronimo…) E.A.I. Platform (per alcuni lo è) Application server Commercial

2/15


La mia definizione preferita di Camel:

Può essere ospitato (istanziato, avviato…) in molti container, oppure può essere utilizzato stand-alone.

Implementa un potente DSL (Domain Specific Language) fruibile in Java, XML, Scala, Groovy

3/15

“una libreria open-source leggera che fornisce strumenti per integrare sistemi disparati che comunicano con protocolli e formati dati differenti fra loro”


Architettura di Camel: più in dettaglio

• Disegno d’insieme• Message model• Runtime: CamelContext• Route• Processor, Component• Endpoint• Producer, Consumer

4/15


Architettura di Camel: disegno d’insieme

5/15


Architettura di Camel: message model, due astrazioni org.apache.camel.Message

org.apache.camel.Exchange

6/15

entità base contenente i dati oggetto di trasporto e smistamento

astrazione corrispondente ad uno scambio di messaggi; contiene richiesta e risposta (in/out), esiste durante il routing


Architettura di Camel: il Runtime, CamelContext org.apache.camel.CamelContext

7/15

CamelContext inplementa l’interfaccia Service (come altri componenti di Camel), con lifecycle start/stop, suspend/resume

rappresenta il “runtime” di Camel, un’unica entità che mantiene il riferimento di tutti i servizi disponibili e ne permette l’inter-comunicazione.presenta analogie d’uso con lo Spring ApplicationContext, di cui mantiene anche riferimento (nel Registry) in caso di Spring DSL.


Architettura di Camel: Route org.apache.camel.Route

Può essere intesa come una “chain of processors” Disaccoppia Client e Server, Producer e Consumer:

• Decide dinamicamente quale server il client invocherà• Fornisce un metodo semplice per inserire extra elaborazioni• Permette lo sviluppo indipendente di Client e Server

8/15


Architettura di Camel: Processor org.apache.camel.Processor

interfaccia che rappresenta il concetto di “nodo” in grado di usare, creare o modificare un Exchange in ingresso

nell’implementazione a pipeline di Camel, durante il routing un Exchange fluisce da un Processor al successivo

molti dei Processor disponibili sono implementazioni E.I.P., ma si possono creare facilmente i propri

9/15


Architettura di Camel: Component org.apache.camel.Component

10/15

essenzialmente rappresentano una factory di Endpointsono usati per creare degli adapter a sistemi esistenti

in Camel sono già presenti più di 80 Component il cui uso varia dal data-transport, al DSL, al data-format…AHC, AMQP, APNS, Atom, AWS (Amazon), ActiveMQ, JMS, Gmail, HTTP, Bean, Cache, Jetty, Twitter, EJB, Drools, File, FTP, JPA, Spring Integration, Spring WS, JDBC, GAE, Jclouds, CXF, DNS, FOP, Exec, Event, JBI, IMAP …ecc


Architettura di Camel: Endpoint org.apache.camel.Endpoint

gli Endpoint vengono configurati tramite URI, con la sintassi: [schema]:[context-path]?[options]file:data/incoming?delay=5000

11/15

astrazione che modella l’estremo di un canale attraverso il quale un sistema può inviare o ricevere messaggi


Architettura di Camel: Producer org.apache.camel.Producer

12/15

astrazione che modella un entità in grado di creare ed inviare messaggi ad un Endpoint

in Camel, quando un messaggio deve essere inviato ad un Endpoint, un Producer sarà in grado di creare un Exchange e popolarlo con i dati compatibili con quel particolare Endpoint


Architettura di Camel: Consumer org.apache.camel.Consumer

13/15

é il servizio che riceve, attraverso un Endpoint, i messaggi prodotti da un Producer ed a sua volta li rende disponibili alla pipeline per essere processati

in Camel, esistono due tipi di Consumers:

Event-driven Consumers Polling Consumers


Architettura di Camel: Event-driven Consumer org.apache.camel.Consumer

14/15

il più comune Consumer, poiché spesso associato al paradigma client-server e web-service

rappresenta “asynchronous receiver” del mondo E.I.P.; sta in ascolto su un canale in attesa di un messaggio inviato dal client


Architettura di Camel: Polling Consumer org.apache.camel.Consumer

15/15

direttamente opposto al precedente, si comporta in maniera attiva, andando a prelevare i dati da una sorgente

rappresenta “synchronous receiver” del mondo E.I.P.; attende la fine dell’elaborazione di un messaggio prima di prelevarne un altro dalla sorgente

Apache Camel essentials

I fondamentali di Camel:

• Routing and mediation basato su regole• Configurazione con DSL (e codice)• Architettura modulare: pipes and filters• Componenti principali

1/25


Routing and mediation basato su regole– producer e/o consumer model per ogni endpoint– il default model é asincrono; può essere forzato

sincrono– la definizione delle route è basata su URIs

esempio:

file system message oriented middleware

2/25


Routing and mediation basato su regole


from A filter message send to B

3/25




from(A) filter(predicate) to(B)

4/25




from(A) .filter(isWidget) .to(B)

5/25



isWidget = xpath(“/quote/product=‘widget’”);

from(A).filter(isWidget).to(B);

6/25


Configurazione con DSL (e codice)isWidget = xpath(“/quote/product=‘widget’”);

(rule)– Java DSL:

from(“file:/tmp”).filter(isWidget).to(“jms:myQueue”);

– Spring DSL: <route> <from uri=“file:/tmp”/> <filter>

<simple>{$isWidget}</simple> <to uri=“jms:myQueue”/> </filter> </route>

7/25


Configurazione con DSL (e codice)– Scala DSL:

from “file:/tmp” -> when (isWidget) -> to “jms:myQueue”

– Java code: public class MyExampleRouteBuilder extends RouteBuilder {

@Override public void configure() throws Exception {

Predicate isWidget = xpath(“/quote/product=‘widget’”); from(“file:/tmp”).filter(isWidget).to(“jms:myQueue”);

}

}

8/25


Architettura modulare: pipes and filters– Camel può supportare E.I.P. “pipes and filters” in vari

modi

from(“direct:A”).to(“bean:B”).to(”direct:C”).to(”jms:outQ”);

from(“direct:A”).pipeline(“bean:B”, “direct:C”, ”jms:outQ”);

9/25



modi

10/25

<route> <from uri=“direct:A”/> <pipeline> <bean ref=“B” /> <to uri=“direct:C” /> <to uri=“jms:outQ” /> </pipeline></route>

<route> <from uri=“direct:A”/> <bean ref=“B” /> <to uri=“direct:C” /> <to uri=“jms:outQ” /></route>



modi– …decidendo comunque per ogni caso lo scenario

d’applicazione

11/25

<route> <from uri=“direct:A”/> <multicast> <pipeline> <bean ref=“B” /> <bean ref=“C?method=calculate” /> <to uri=“log:myOutputLog” /> </pipeline> <pipeline> <to uri=“direct:audit” /> <to uri=“jms:outQueue” /> </pipeline> </multicast></route>


Componenti principali

• File (camel-core)• Bean (camel-core) • Log (camel-core)• JMS (camel-jms)• CXF (camel-cxf)• Mock (camel-core)

http://refcardz.dzone.com/refcardz/essential-camel-components

12/25


Componenti principali: File (camel-core)• Re-inventiamo la ruota ?

– polling su location– leggi contenuto file– invia contenuto alla coda (ad es.)– ev. sposta in cartella processed

• o usiamo Camelfrom(“file:/location/path?move=.processed”).

to(“jms:outQ”);

13/25


Componenti principali: File (camel-core)• Qualche esempio

from(“file://inbox?preMove=.inprogress&move=.done”). to(“activemq:queue:myQueue”);

from(“direct:report”). to(“file://target/reports/?fileName=report.txt”);

from(“file://data?exclude=_.*”). to(“bean:handleData?method=processData”);

from(“file://data?sortBy=date:file:yyyyMMdd;file:name”).

to(“direct:sorted”);

14/25


Componenti principali: Bean (camel-core)• implementa EIP “service activator”• permette la connessione ed uso di Java

Bean/POJO logic a Route Camel• può ad es. invocare un metodo su un Java

Object per processare un messaggio

15/25


Componenti principali: Bean (camel-core)• Qualche esempio

public class CreditService { public int getScore(@Xpath(“/Borrower/id”) long id) {

// implementation }

}

<bean id=“enrichService” class=“com.ref.CreditService” />

from(“jms:inQueue”). to(“bean:enrichService?

method=getScore”) .to(“jms:outQueue”);

16/25


Componenti principali: Log (camel-core)• Camel usa SLF4J (Log4J, Logback, JDK Util …)• il Log Component può essere usato per

loggare un message Exchange e/o parti di esso– Headers– Body

• esiste anche il .log() DSL– può loggare custom expressions

Endpoint URI format: log:category[?options]

17/25


Componenti principali: Log (camel-core)• Qualche esempio

from(“direct:incoming”). to(“log:org.apache.camel?level=INFO”).

to(“ims:out”);

from(“direct:incoming”). to(“log:org.apache.camel?

level=INFO&showBody=false”). to(“ims:out”);

from(“direct:incoming”). log(LoggingLevel.INFO,”We recive a body: $

{body}”) . to(“ims:out”);

18/25


Componenti principali: JMS (camel-jms)• usato per connettere broker JMS eterogenei• é possibile indirizzare queue e topic; il default

è queue• può utilizzare più Consumer anche in manera

asincrona

Endpoint URI format: jms:[temp:][queue:][topic:]destination[?options]

19/25


Componenti principali: JMS (camel-jms)• Qualche esempio

from(“jms:incoming?concurrentConsumers=5”). bean(myBean). to(“ims:out”);

from(“jms:topic:in?clientId=1&durableSubscriptionName=foo”).

bean(myBean);

from(“direct:incoming”).inOut(). to(”jms:out”) .

to(“bean:myBean”);

20/25


Componenti principali: CXF (camel-cxf)• si integra con Apache CXF WS framework• i Consumers espongono il web-service• i Producers consumano il web-service• si può configurare tramite attributo

serviceClass (specificando l’interfaccia JAX-WS)

• usando le annotazioni JAX-WS, si possono omettere alcuni parametri della URI

Endpoint URI format: address style cxf:address[?options] bean style cxf:bean:beanName

21/25


Componenti principali: CXF (camel-cxf)• Qualche esempio

from(“cxf:http://localhost:9090/helloWorld?serviceClass=org.hello. HelloWorld&wsdlUrl=wsdl/HelloWorld.wsdl&serviceName=tns:Hell oService”).

bean(processWS);

from(“cxf:bean:HelloWorldWS”).bean(processWS);

<cxf:cxfEndpoint id=“HelloWorldWS” … > <cxf:properties>

<entry key=“dataFormat” value=“MESSAGE” /></cxf:properties>

</cxf:cxfEndpoint>

22/25


Componenti principali: Mock(camel-core)• ottimo strumento per testare le Route• usa i Mock • fornisce un meccanismo di test dichiarativo

Declare Test Assert

Endpoint URI format: mock:mockName[?options]

23/25


Componenti principali: Mock(camel-core)• Qualche esempio

from(“direct:incoming”). choice().

when(header(“loanNumber” ).isGreaterThan(12345).

to(“mock:specialLoan”).

when(header(“loanNumber” ).isLessThan(12345).to(“mock:regularLoan”).

to(“mock:outgoing”);

24/25


Componenti principali: Mock(camel-core)• Qualche esempio

// declare, lookup endpointMockEndpoint resultEndpoint = context.

resolveEndpoint(“mock:outgoing”, MockEndpoint.class);

// set expectationsresultEndpoint.expectedMessageCount(2);

// send some messages ...

// assert expectationsresultEndpoint.assertIsSatisfied();

25/25

Il mio Caso d’uso

“Migrazione” di un legacy system:

• Sistemi eterogenei già interoperanti• Shared Database integration style (non

proprio)• Confini architetturali piuttosto indefiniti• Contratti definiti non estendibili• Comportamenti non documentati• Periodo di funzionamento affiancato vecchio-

nuovo sistema• Data di consegna certa

1/9

Il mio Caso d’uso

Disegno architetturale dell’esistente

…hhhmmm… un tanto monolitico ?

2/9

ABC

Il mio Caso d’uso

Disegno architetturale dell’esistente: dettaglio ?

3/9

ABC

AB

Il mio Caso d’uso

…Emergono particolari “nascosti”

…e inquietanti ?!

4/9

TGC

AB

ABC DB

Il mio Caso d’uso

“Sulla carta” il disegno è completo…riusciamo così ad

individuare• Webservices in ingresso• Code JMS in ingresso• Code JMS in uscita• RPC con EJB• Store su RDBMS

…manca interoperatività• Tutti scrivono su DB… e poi ?• Trasformazione/estrazione con task

batch SQL• History e notify assenty

5/9

Il mio Caso d’uso

Cerchiamo un percorso di disaccoppiamentoragioniamo “event-driven”, con CQRS (Command Query Responsibility Segregation)

6/9

miglioriamo !• Tutti i “connettori“ in unico

Layer• Paradigma a comandi• Struttura persistenza

inalterata• History gratuito, sempre

attivo• Facilità integrazioni

successive

Camel a supporto di connettori e regole di comportamento (routing, mediation ….)

Il mio Caso d’uso

Camel nello strato “connettori” Sostituiamo un contratto alla volta Velocità di definizione dei WS con CXF

(wizard) Il sistema originale rimane in linea; una

opportuna Route continua ad alimentarlo Otteniamo la ricercata configurazione

“pluggable” senza dover investire su software che la supporti

Possiamo scalare orizzontalmente per ogni singolo contratto “da subito”

7/9

Il mio Caso d’uso

Camel nello strato “regole di comportamento” Semplice configurazione, con Spring XML

DSL, di routing e trasformazioni Variazione della configurazione a caldo Aggiunta, rimozione, stop/start di nuovi servizi

(prodotti) gestiti dal sistema a caldo Implementazione facile e rapida del ns. custom

component Command

8/9

Il mio Caso d’uso

Disegno finale layered

9/9

Camel

Riferimenti

Apache Camelhttp://camel.apache.org

http://refcardz.dzone.com/refcardz/essential-camel-componentshttp://refcardz.dzone.com/refcardz/apache-camel-updatehttp://www.manning.com/ibsen/ (it-ebooks.info)

E.I.P.http://www.eaipatterns.comhttp://refcardz.dzone.com/refcardz/enterprise-integration

Bloghttp://www.davsclaus.comhttp://www.christianposta.com/blog

http://camel.apache.org/



http://refcardz.dzone.com/refcardz/apache-camel-update

http://www.manning.com/ibsen/



http://www.eaipatterns.com/

http://refcardz.dzone.com/refcardz/enterprise-integration

http://www.davsclaus.com/

http://www.christianposta.com/blog

Fine

Q & A ?

EIP with Apache Camel

Technology

Transcript of EIP with Apache Camel