FinistJUG - Camel Presentation

FinistJug

versatile open-source integration framework

#FinistJUG

http://camel.apache.org/

Sommaire
●
Présentation
● EIP
●
Chevaucher le chameau
●
Dompter le chameau
● Les camélidés en quelques chiffres
●
Le matériel du chamelier
● Questions

21/03/13 Apache Camel 2

Présentation
● Le cloud computing est à la mode

● Mais pas dans nos entreprises

Présentation
● Nous on a le Jean-Cloud computing
On a acheté du MainFrame IBM parce que c'était ce
qu'on faisait de mieux. Puis on a rencontré des gars
d'Oracle et on leur a acheté leur produit. On a été à
une conférence Tibco et on leur a acheté des trucs,
ça paraissait bien sur leurs slides. Dernièrement, on
a développé des web-services SOAP, mis en place
un ActiveMQ, un WebSphère MQ, un CRM avec son
interface REST.

On est au top de la techno, mais c'est le bordel !


Présentation
● Pourquoi avons nous des problèmes
d'intégration ?
– Nos applications sont bâties avec différentes briques
techniques
– Nos briques utilisent différents protocoles d'échange
– L'intégration est critique pour notre business
● Pourquoi un framework ?
– Le framework fait le gros du boulot
– Nous pouvons nous concentrer sur le métier
– Nous n'avons pas besoin de réinventer la roue


Présentation
●
Approche SOA
●
Chaque service est lié par l’ESB
●
Séparation des responsabilités
●
Pas d’adhérence entre SI/applications

6

21 mars 2013 – DTI/Architectures et méthodes
appliquées

Présentation
●
L'ESB est une couche basée sur des messages permettant de connecter
différentes applications qui ne sont pas faites pour communiquer entre
elles.
●
Il s'appuie sur les principes suivants :
– L’orchestration des processus et services métiers.
– La distribution forte : les services sont distribués sur le réseau de l'entreprise ou sur
Internet.
– La communication par messages : JMS, Web Services …

7

appliquées

Présentation
● Framework java open source
● Permet d'intégrer des systèmes hétérogène
facilement
● Basé sur des échanges de messages
● Architecture événementielle et
transactionnelle
● DSL (Java, Spring XML et Scala)


Camel
● Integration framework
● Enterprise Integration Patterns (EIP) (50 implémentés nativement)
● Routage et médiation
● Domain Specific Language (DSL) (Java, XML et Scala)
Endpoints comme URIs
Concise
●

● Predicate et Expressions
Application
● Extensible et configurable
Messaging
● Pas de spécification lourde
Exchange
● Pas de dépendance à un conteneur
Language
● Agnostique de la nature des messages
● Connectable à un grand nombre de protocoles (134 à ce jour)
● 148 type converters
● Apache licensed

Sous le capot


EIP
● Enterprise Integration Patterns


EIP
● Enterprise Integration Patterns

21/03/13 Apache Camel http://camel.apache.org/eip 13

EIP
● Enterprise Integration Pattern :
http://camel.apache.org/enterprise-integration-patterns.h
tml
– Patron de conception ou typologie de routes. L’objectif est de :
● Modéliser l’architecture d’une sous-route, voire d’une route
● Maîtriser le processus de réalisation d'une sous-route voire d'une route
● Pouvoir associer une route à un pattern
● Pouvoir industrialiser la réalisation de plusieurs routes


EIP
● Exemple

Apache ActiveMQ WebSphereMQ


EIP
● Exemple

Filter pattern



● Exemple
A B
Filter pattern

isWidget = xpath("/quote/product = ‘widget’");
from(A).filter(isWidget).to(B);



● Code de cet exemple :
import org.apache.camel.builder.RouteBuilder;

public class FilterRoute extends RouteBuilder {

public void configure() throws Exception {
from("activemq:queue:quote")
.filter().xpath("/quote/product =‘widget’")
.to("mq:quote");
}
}

● Content based router


● Content based router (java DSL)
from("activemq:NewOrders")
.choice()
.when().xpath("/order/product = 'widget'")
.to("activemq:Orders.Widget")
.otherwise()
.to("activemq:Orders.Gadget");


● Content based router (XML DSL)
<camelContext>
<route>
<from uri="activemq:NewOrders"/>
<choice>
<when>
<xpath>/order/product = 'widget'</xpath>
<to uri="activemq:Orders.Widgets"/>
</when>
<otherwise>
<to uri="activemq:Orders.Gadgets"/>
</otherwise>
</choice>
</route>
</camelContext>


Polling Splitter Normalizer Service Aggregator Endpoint
Consumer Activator

1 2 3 4 5
● But :
– 1) Consommer un fichier XML contenant des ordres
– 2) Spliter le fichier en passages d'ordres
– 3) Normaliser et traiter l'ordre
– 4) Réassembler les ordres pour réaliser un compte rendu
– 5) Envoyer le compte rendu

from("file:inbox?move=.done")
.split().streaming().parallelProcessing()
.xpath("/order/line")
.aggregationStrategyRef("summaryService")
.to("bean:orderLineService")
.end()
.to("jms:topic:order.summary");

●
Streaming du fichier
public class SummaryService implements
AggregationStrategy {
●
Traitement concurrent de chaque
ordre
Exchange aggregate(Exchange
●
JAXB marshalling
oldExchange, Exchange newExchange) {
●
Utilisation d'un bean Spring comme
...
endpoint
}
}

Camel c'est cool


Connecteurs


Connecteurs
● En entrée (timer)
● En sortie (log)
● En entrée / sortie (JMS, File, CXF)
● Internes (Direct, SEDA, VM)


Connecteurs
● 134 à ce jour
ahc core-osgi groovy jaxb
amqp core-xml gson jclouds
apns couchdb guava-eventbus jcr
atom crypto guice jdbc
avro csv hawtdb jetty
aws cxf hazelcast jibx
bam cxf-transport hbase jing
bean-validator dns hdfs jms
beanio dozer hl7 jmx
bindy eclipse http josql
blueprint ejb http4 jpa
cache elasticsearch ibatis jsch
castor eventadmin irc jt400
cdi exec jackson juel
cmis flatpack jasypt jxpath
cometd fop javaspace kestrel
context freemarker http://camel.apache.org/components.html
21/03/13 ftp Apache Camel 28
gae

Connecteurs
● 134 à ce jour paxlogging sjms
printer smpp
syslog
tagsoup
krati test
ldap protobuf snmp test-blueprint
leveldb quartz soap test-spring
lucene quickfix solr testng
mail restlet spring twitter
mina rmi spring-batch velocity
mina2 routebox spring-integration web
mongodb rss spring-javaconfig web-standalone
mqtt ruby spring-security websocket
msv saxon spring-ws xmlbeans
mvel scala sql xmljson
mybatis script ssh xmlrpc
nagios servlet stax xmlsecurity
neo4j shiro stream xmpp
netty sip stringtemplate xstream
ognl zookeeper
http://camel.apache.org/components.html

Connecteurs
● Connectés au monde externe :
– CXF, HTTP, FTP, File, JMS, …
● Connecteurs internes
– Direct : sorte de GOTO
– Seda : pareil que direct mais avec un système
de queue paramétrable
– VM : Comme Seda mais en repassant par la
JVM (en cas de classloaders différents)


Connecteurs
● Exemple : copie de fichiers
from("file://inputdir/?recursive=true&delete=true").to("file://outputdir")

http://camel.apache.org/file2.html

Connecteurs
● Exemple : Web service SOAP
package org.giwi.camel.ws;

import javax.jws.WebParam;
import javax.jws.WebResult;

@javax.jws.WebService(name = "sayHelloService", targetNamespace = "http://giwi.free.fr")
public interface SayHelloService {
@WebResult(name = "status")
public String sayHello(@WebParam(name = "name") String name);

@WebResult(name = "status")
public String sayGoodby(@WebParam(name = "name") String name);
}

http://camel.apache.org/cxf.html

Connecteurs
<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
xmlns:context="http://www.springframework.org/schema/context" xmlns:cxf="http://camel.apache.org/schema/cxf"
xmlns:http="http://cxf.apache.org/transports/http/configuration" xmlns:sec="http://cxf.apache.org/configuration/security"
xsi:schemaLocation="
http://cxf.apache.org/configuration/security http://cxf.apache.org/schemas/configuration/security.xsd
http://cxf.apache.org/transports/http/configuration http://cxf.apache.org/schemas/configuration/http-conf.xsd
http://camel.apache.org/schema/cxf http://camel.apache.org/schema/cxf/camel-cxf.xsd
http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans-2.5.xsd
http://camel.apache.org/schema/spring http://camel.apache.org/schema/spring/camel-spring.xsd">


<import resource="classpath:META-INF/cxf/cxf.xml" />
<import resource="classpath:META-INF/cxf/cxf-extension-soap.xml" />

<import resource="classpath:META-INF/cxf/cxf-servlet.xml" />

<camelContext xmlns="http://camel.apache.org/schema/spring">
<package>org.giwi.camel.route</package>
</camelContext>
</beans>

Connecteurs
@Override
public void configure() throws Exception {
from("cxf:/helloBetterService?serviceClass=org.giwi.camel.ws.SayHelloService")
.recipientList(simple("direct:${header.operationName}"));

from("direct:sayHello").process(new Processor() {
@Override
public void process(Exchange ex) throws Exception {
ex.getOut().setBody("hello");
}
});

from("direct:sayGoodby").process(new Processor() {
@Override
public void process(Exchange ex) throws Exception {
ex.getOut().setBody("goodby");
}
});
}

Médiation
● Langages d'expression :
– Beanshell, Python, PHP, Javascript, EL,
Ruby, Groovy, Simple, SPEL, JSR233,
SQL, ONGL, XPATH, Mvel, Xquery, …
● Transformations de données
from("activemq:QueueWithJavaObjects”)
.marshal().jaxb()
.to("mq:QueueWithXmlMessages");

Un bean pour traduire
from("activemq:Incoming”).
beanRef("myBeanName", "someMethod").
to("activemq:Outgoing");
public class Foo {
public String someMethod(String name,
@XPath("/order/@id") String oid,
@Header("JMSCorrelationID") String cid) {
return “Hello “ + name;
}
}

Tests unitaires


Transactions
● Une erreur se produit

21/03/13 Apache Camel
X 38

Transactions
● Try ... Catch style

from("activemq:incoming")
.doTry()
.marshal().jaxb()
.to("mq:QueueWithXmlMessages")
.doCatch(Exception.class)
.to("activemq:error")
.end();

Transactions
● Dead Letter Channel EIP w/
Redelivery
errorHandler(
deadLetterChannel("activemq:error")
.maximumRedeliveries(5)
.redeliveryDelay(5000)
);

from("activemq:incoming")
.marshal().jaxb()
.to("mq:QueueWithXmlMessages");

Transactions
● Interceptors


Autres fonctionnalités
● Interceptors
● Transaction
● Compensation
● Pluggable Security Framework
– Apache Shiro
– Spring Security
● Event Notification
● Route Policy
● Thread Model
● Asynchronous Non-Blocking Routing Engine


En résumé
●
50 EIP patterns
● 134 Components
●
19 Data formats
● 15 Expression Languages
● DSL in multiple flavors (Java, XML, Scala, Groovy)
●
Automatic type conversion
● Strong bean support
●
Test Kit
● Management (JMX, REST)
●
Developer Web Console
●
Error Handling
● Non-blocking Routing Engine Camel c'est puissant


Pimp my Camel

● Camel est extensible
– On peut créer des composants
(connecteurs) très simplement
– http://camel.apache.org/writing-c
omponents.html


Dompter le chameau
● Paradigmes de déploiement
– Aucune dépendance à un conteneur
– Léger
– Encapsulable
● Possibilités de déploiement
– Standalone
– WAR
– Spring
– J2EE
– JBI
– OSGi
– Cloud
– Java Web Start
– Spring Application

Dompter le chameau
● Conteneurs
compatibles :
– Apache ServiceMix
– Apache ActiveMQ
– Apache Tomcat
– Jetty
– JBoss
– IBM WebSphere
– Oracle WebLogic
– Oracle OC4j
– Glassfish
– Google App Engine
– ...


Quelques chiffres
● Né en 2007
● 13677 commits on trunk
(37 different committers)

Quarterly visits on the Apache Camel website Number of commiters on the project

Yearly posts on Camel user mailing list Number of Camel components out of the box

Camel est sexy


Fuse IDE


Talend Open Studio



Yed / LibreOffice

Pourquoi utiliser Camel
● Masque la complexité
● Design de workflows métiers
complexes
●
Re-use des sous routes
● Interconnexions natives
● Événementiel et transactionnel
● Peu de lignes de code
C'est nouveau, mais c'est beau !
Jean-Cloud est content.


WTF
Mais, WTF !!!
La complexité maîtrisée est
remplacée par une complexité
non maîtrisée du
framework.


Bonus
● Il m'en reste un peu, je vous le rajoute ?
– Mapping avec Dozer
– http://dozer.sourceforge.net


Questions
@XavMarin
http://github.com/giwi
http://giwi.free.fr

« Si tout le monde a compris, c'est que je me suis mal exprimé »
Alan Greenspan

57

appliquées

FinistJUG - Camel Presentation

Contenu connexe

Tendances

En vedette

Similaire à FinistJUG - Camel Presentation

Plus de Xavier MARIN

FinistJUG - Camel Presentation