Depuis quelques jours, je teste Apache Camel pour la mise en œuvre de médiations.
Apache Camel est un framework assez ancien. Il est similaire à Spring Intégration et permet l’ implémentation de patterns d’intégration.
Les patterns d’intégration
Qu’est-ce qu’un pattern d’intégration allez-vous me dire ? C’est une solution d’architecture ou plus simplement une recette de cuisine permettant d’avoir une solution toute prête à une problématique d’intégration donnée. L’ensemble de ces patterns est décrit sur ce site ( ne vous attardez pas sur le look des années 90 … ).
Exemple :
Camel permet simplement de gérer l’intégration via un DSL.
Choix d’implémentations
On peut faire pas mal de choses avec ce FRAMEWORK et de plusieurs manières. J’ai fait les choix d’implémentation suivants :
- Tout se fera avec SPRING … et pas en XML 🙂
- Il faut que toutes les médiations soient testables
- J’exécute le code dans un FATJAR ( pourquoi avec springboot )
Configuration de la route
Apache Camel définit les médiations dans des routes. Elles se définissent assez rapidement .
Les routes commencent par une instruction from et se terminent par une ou plusieurs instructions to.
Pour mon exemple, j’extrais les données d’une table et les stocke dans un fichier.
Tout se configure par des URLs. La première permet d’extraire les données via JPA/HIBERNATE. Une entité Address permet le requêtage. La seconde permet le stockage dans un fichier texte JSON.
Elles sont externalisées dans des fichiers de configuration pour faciliter les tests et accessibles via SPRING.
| consumer.url=jpa://samples.camel.model.Address?consumeDelete=false | |
| producer.url=file:target/test?allowNullBody=true&fileExist=append |
| @Component | |
| public class DbRouteBuilder extends RouteBuilder { | |
| @Value("${consumer.url}") | |
| private String consumerUrl; | |
| @Value("${producer.url}") | |
| private String producerUrl; | |
| @Override | |
| public void configure() throws Exception { | |
| from(consumerUrl) | |
| .log(LoggingLevel.TRACE, "Processing ${id}") | |
| //.bean(new AddressBean(), "log") | |
| .marshal().json() | |
| .to(producerUrl); | |
| } | |
| } |
| consumer.url=jpa://samples.camel.model.Address?consumeDelete=false | |
| producer.url=file:target/test?allowNullBody=true&fileExist=append |
| @Component | |
| public class DbRouteBuilder extends RouteBuilder { | |
| @Value("${consumer.url}") | |
| private String consumerUrl; | |
| @Value("${producer.url}") | |
| private String producerUrl; | |
| @Override | |
| public void configure() throws Exception { | |
| from(consumerUrl) | |
| .log(LoggingLevel.TRACE, "Processing ${id}") | |
| //.bean(new AddressBean(), "log") | |
| .marshal().json() | |
| .to(producerUrl); | |
| } | |
| } |
Lancement de la route
Le lancement de la route se fait dans une méthode main() :
| @Component | |
| public class DbApplication { | |
| public static void main(String[] args) { | |
| try { | |
| ApplicationContext applicationContext = new AnnotationConfigApplicationContext(ApplicationConfig.class); | |
| Main main = new Main(); | |
| main.addRouteBuilder(applicationContext.getBean(DbRouteBuilder.class)); | |
| main.run(); | |
| } catch (Exception e) { | |
| e.printStackTrace(); | |
| } | |
| } | |
| } |
Tests
Camel fournit une API de test assez bien fournie. Elle permet notamment de mocker des endpoints existants (ex. : le fichier de sortie de mon cas de test).
Dans mon cas, j’ai décidé de remplacer la base de données que j’interroge en input par une base HSQLDB chargée en mémoire. Le fichier de sortie est, lui, remplacé dynamiquement par un mock. Pour ce faire, j’ai utilisé les « adviceWith »
| public class DbRouterBuilderTest extends CamelSpringTestSupport { | |
| @Override | |
| @Before | |
| public void setUp() throws Exception { | |
| super.setUp(); | |
| Class.forName("org.hsqldb.jdbcDriver"); | |
| context().getRouteDefinitions().get(0).adviceWith(context(), new AdviceWithRouteBuilder() { | |
| @Override | |
| public void configure() throws Exception { | |
| mockEndpoints("file*"); | |
| } | |
| }); | |
| } | |
| @Override | |
| protected AbstractApplicationContext createApplicationContext() { | |
| AnnotationConfigApplicationContext annotationConfigApplicationContext = new AnnotationConfigApplicationContext(); | |
| annotationConfigApplicationContext.register(ApplicationConfig.class); | |
| return annotationConfigApplicationContext; | |
| } | |
| @Test | |
| public void it_should_receive_an_address() throws Exception { | |
| Address address = new Address("John Doe", "john@doe.com"); | |
| MockEndpoint mockEndpoint = getMockEndpoint("mock:file:target/test"); | |
| mockEndpoint.setExpectedCount(1); | |
| mockEndpoint.allMessages().body().convertToString().contains("john@doe.com"); | |
| template.sendBody("jpa://samples.camel.model.Address?consumeDelete=false", address); | |
| assertMockEndpointsSatisfied(); | |
| } | |
| } |
Pour aller plus loin
Il y a pas mal d’exemples sur le GITHUB de CAMEL. Vous pouvez également acheter le livre « Camel In Action ». Ca ne vaut pas Effective Java 🙂 , mais vu qu’il est écrit par le principal développeur, c’est une très bonne référence.
