Introduction au framework Camel – Partie 1

La problématique d’intégration de systèmes

Dans un système d’information, nous avons généralement une multitude de systèmes hétérogènes qui ne se comprennent pas nativement (technologies différentes, protocoles de communication différents, etc.) Il est néanmoins indispensable de relier ces systèmes car des applications qui ne communiquent pas ne présentent qu’un intérêt métier limité.
Cela soulève beaucoup de problématiques telles que le format de données, le routage, le monitoring, etc.
Par exemple, comment fait-on pour connecter deux applications, où l’une manipule un fichier CSV alors que la seconde ne comprend que le XML sur JMS ?

Les Entreprise Integration Pattern

Apache Camel est un framework d’intégration, implémentant les EIP (Entreprise Integration Pattern) définis par Gregor Hohpe & Bobby Woolf. Les EIP sont des patterns d’intégration qui nous permettent de résoudre ces problématiques d’intégration avec des solutions éprouvées.
Le framework Camel en supporte environ une cinquantaine.

Les Endpoints

Les endpoints représentent des systèmes, des ressources physiques, des ressources virtuelles, etc. Nous avons par exemple des endpoints HTTP, JMS, FTP pour s’interfacer avec différents protocoles, mais aussi des endpoints Direct, Seda pour communiquer dans une même contexte Camel (nous y reviendrons).
Les endpoints peuvent être de 2 types :

• consumer
• provider

Exemples

Répertoire des factures du mois de mars 2010: file://factures/032010

File de messages de transit des factures: jms://zenika/factures

Les Routes

Une route (chemin entre 2 endpoints) peut être très simple, mais aussi très complexe (transformation de données, diffusion à plusieurs destinataires, filtrage de messages, etc).
Elles permettent d’acheminer le message d’origine jusqu’à leur destination finale.
Camel est capable de configurer des routes via 2 méthodes :

• configuration XML XBean
• utilisation du DSL (Domain Specific Language)

Par exemple, voici la lecture d’un fichier à partir d’un répertoire, puis l’écriture de ce même fichier dans un autre répertoire (nous définissons ici une route très simple) :

Méthode XML

1. <beans xmlns=“http://www.springframework.org/schema/beans&#8221;
2. xmlns:xsi=“http://www.w3.org/2001/XMLSchema-instance&#8221;
3. xsi:schemaLocation=“http://www.springframework.org/schema/bean
4. http://www.springframework.org/schema/beans/spring-beans.xsd
5. http://camel.apache.org/schema/spring http://camel.apache.org/schema/spring/camel-spring.xsd&#8221;>
7. <camelContext xmlns=“http://camel.apache.org/schema/spring&#8221;>
8. <route>
9. <from uri=“file://C://factures//in” />
10. <to uri=“file://C://factures//out” />
11. </route>
12. </camelContext>
13. </beans>

Méthode DSL

1. Déclaration des packages Java à scanner (fichier camel-context.xml)

1. <beans xmlns=“http://www.springframework.org/schema/beans&#8221;
2. xmlns:xsi=“http://www.w3.org/2001/XMLSchema-instance&#8221;
3. xsi:schemaLocation=“http://www.springframework.org/schema/beans
4. http://www.springframework.org/schema/beans/spring-beans.xsd
5. http://camel.apache.org/schema/spring http://camel.apache.org/schema/spring/camel-spring.xsd&#8221;>
7. <camelContext xmlns=“http://camel.apache.org/schema/spring&#8221;>
8. <packageScan>
9. <package>com.zenika.camel.routes</package>
10. </packageScan>
11. </camelContext>
12. </beans>

2. Écriture des routes

1. package com.zenika.camel.routes;
3. import org.apache.camel.builder.RouteBuilder;
5. public class FacturesRoute extends RouteBuilder {
7. @Override
8. public void configure() throws Exception {
9. from(“file://C://factures//in”).to(“file://C://factures//out”);
10. }
11. }

La méthode DSL est beaucoup moins verbeuse, et plus simple à maintenir
Il est simplement nécessaire de déclarer les packages Java à scanner, et d’écrire les routes en Java via le DSL.
Elle est également beaucoup plus sécurisée (type safe).
Il est en effet impossible de définir une opération non supportée.
De plus, l’intégralité de la syntaxe Camel est disponible en XML et via le DSL.

Le contexte Camel, cœur du framework

Afin de faire fonctionner cette route, nous avons besoin d’un contexte Camel. C’est ce contexte qui charge, configure et exécute les routes. Il s’agit véritablement du moteur du framework.
Le framework Camel n’a pas pour vocation d’être utiliser en mode standalone (excepté à des fins de tests). Camel doit être intégré à un conteneur (ServiceMix, ActiveMQ, CXF ou encore Tomcat).
Voici un exemple simple pour instancier notre contexte Camel :

1. package com.zenika.camel;
3. import org.apache.camel.CamelContext;
4. import org.springframework.beans.factory.BeanFactory;
5. import org.springframework.context.support.ClassPathXmlApplicationContext;
7. public class Testeur {
8. public static void main(String… args) throws Exception {
10. BeanFactory beanFactory = new ClassPathXmlApplicationContext(“classpath:/camel-context.xml”);
11. CamelContext camelContext = (CamelContext) beanFactory.getBean(“camelContext”);
13. camelContext.start();
14. Thread.sleep(2000); // pour avoir le temps d’exécuter la route
15. camelContext.stop();
16. }
17. }

Avec ces quelques lignes de code, nous avons très simplement mis en place une route qui copie tous les fichiers présents dans factures/in vers factures/out.
Nous verrons par la suite d’autres types de endpoints très utiles (comme le Direct), ainsi que des routes plus complexes avec des transformations de données et de la logique de routage.