Introduction à Apache Camel
1. Vue d'ensemble
Dans cet article, nous allonsintroduce Camel and explore one of its core concepts – message routing.
Nous commencerons par couvrir ces concepts et cette terminologie fondamentaux, puis nous présenterons deux options principales pour définir les routes: Java DSL et Spring DSL.
Nous allons également les démontrer sur un exemple - en définissant une route qui consomme les fichiers d'un dossier et les déplace vers un autre tandis queprependingest un horodatage vers chaque nom de fichier.
2. À propos d'Apache Camel
Apache Camel est un framework d'intégration open source conçu pour rendre l'intégration des systèmes simple et facile.
Il permet aux utilisateurs finaux d’intégrer différents systèmes à l’aide de la même API, en prenant en charge plusieurs protocoles et types de données, tout en étant extensible et en permettant l’introduction de protocoles personnalisés.
3. Dépendances Maven
Pour utiliser Camel, nous devons d’abord ajouter la dépendance Maven:
org.apache.camel
camel-core
2.18.0
La dernière version de l'artefact Camel peut être trouvéehere.
3. Langue spécifique au domaine
Les itinéraires et le moteur de routage constituent la partie centrale de Camel. Les itinéraires contiennent le flux et la logique d'intégration entre différents systèmes.
Afin de définir des itinéraires plus faciles et plus propres, Camel propose plusieurs langages spécifiques au domaine (DSL) pour des langages de programmation tels que Java ou Groovy. D'autre part, il fournit également des itinéraires de définition en XML avec Spring DSL.
Utiliser Java DSL ou Spring DSL est généralement une préférence de l'utilisateur, car la plupart des fonctionnalités sont disponibles dans les deux cas.
Java DSL offre un peu plus de fonctionnalités qui ne sont pas prises en charge dans Spring DSL. Cependant, Spring DSL est parfois plus avantageux, car XML peut être modifié sans avoir à recompiler le code.
4. Terminologie et architecture
Parlons maintenant de la terminologie et de l'architecture de base de Camel.
Tout d'abord, nous allons examiner les concepts de base de Camel ici:
-
Message contient des données en cours de transfert vers une route. Chaque message a un identifiant unique et est construit à partir d'un corps, d'en-têtes et de pièces jointes
-
Exchange est le conteneur d'un message et il est créé lorsqu'un message est reçu par un consommateur pendant le processus de routage. Exchange permet différents types d'interaction entre les systèmes - il peut définir un message unidirectionnel ou un message de requête-réponse
-
Endpoint est un canal par lequel le système peut recevoir ou envoyer un message. Il peut faire référence à un URI de service Web, une URI de file d'attente, un fichier, une adresse électronique, etc.
-
Component agit comme une fabrique de point final. Pour le dire simplement, les composants offrent une interface à différentes technologies en utilisant la même approche et la même syntaxe. Camel prend déjà en chargea lot of components dans ses DSL pour presque toutes les technologies possibles, mais il donne également la possibilité d'écrire des composants personnalisés
-
Processor est une interface Java simple qui est utilisée pour ajouter une logique d'intégration personnalisée à une route. Il contient une seule méthodeprocess utilisée pour préformer une logique métier personnalisée sur un message reçu par un consommateur
À un niveau élevé, l'architecture de Camel est simple. CamelContext représente le système d'exécution de Camel et il relie différents concepts tels que les itinéraires, les composants ou les points de terminaison.
Et en dessous, les processeurs gèrent le routage et les transformations entre les points finaux, tandis que les points finaux intègrent différents systèmes.
5. Définition d'un itinéraire
Les itinéraires peuvent être définis avec Java DSL ou Spring DSL.
Nous illustrerons les deux styles en définissant une route qui consomme les fichiers d'un dossier et les déplace dans un autre dossier tandis queprependingest un horodatage pour chaque nom de fichier.
5.1. Routage avec Java DSL
Pour définir une route avec Java DSL, nous devrons d'abord créer une instanceDefaultCamelContext. Après cela, nous devons étendre la classeRouteBuilder et implémenter la méthodeconfigure qui contiendra le flux d'itinéraire:
private static final long DURATION_MILIS = 10000;
private static final String SOURCE_FOLDER = "src/test/source-folder";
private static final String DESTINATION_FOLDER
= "src/test/destination-folder";
@Test
public void moveFolderContentJavaDSLTest() throws Exception {
CamelContext camelContext = new DefaultCamelContext();
camelContext.addRoutes(new RouteBuilder() {
@Override
public void configure() throws Exception {
from("file://" + SOURCE_FOLDER + "?delete=true").process(
new FileProcessor()).to("file://" + DESTINATION_FOLDER);
}
});
camelContext.start();
Thread.sleep(DURATION_MILIS);
camelContext.stop();
}La méthodeconfigure peut être lue comme ceci: lire les fichiers du dossier source, les traiter avecFileProcessor et envoyer le résultat vers un dossier de destination. Le paramètredelete=true signifie que le fichier sera supprimé du dossier source après avoir été traité avec succès.
Pour démarrer Camel, nous devons appeler la méthodestart surCamelContext. Thread.sleep est invoqué afin de laisser à Camel le temps nécessaire pour déplacer les fichiers d'un dossier à un autre.
FileProcessor implémente l'interfaceProcessor et contient une seule méthodeprocess qui contient la logique de modification des noms de fichiers:
public class FileProcessor implements Processor {
public void process(Exchange exchange) throws Exception {
String originalFileName = (String) exchange.getIn().getHeader(
Exchange.FILE_NAME, String.class);
Date date = new Date();
SimpleDateFormat dateFormat = new SimpleDateFormat(
"yyyy-MM-dd HH-mm-ss");
String changedFileName = dateFormat.format(date) + originalFileName;
exchange.getIn().setHeader(Exchange.FILE_NAME, changedFileName);
}
}Afin de récupérer le nom de fichier, nous devons récupérer un message entrant d'un échange et accéder à son en-tête. Comme pour cela, pour modifier le nom du fichier, nous devons mettre à jour l'en-tête du message.
5.2. Routage avec Spring DSL
Lors de la définition d'une route avec Spring DSL, nous utilisons un fichier XML pour configurer nos routes et nos processeurs. Cela nous permet de configurer des itinéraires sans code en utilisant Spring et nous donne l’avantage d’une inversion totale du contrôle.
Cela a déjà été couvert dansexisting article, nous allons donc nous concentrer sur l'utilisation à la fois de Spring DSL et de Java DSL, qui est généralement un moyen préféré de définir les routes.
Dans cet arrangement, CamelContext est défini dans un fichier XML Spring à l'aide de la syntaxe XML personnalisée de Camel, mais sans la définition de la route, comme dans le cas de Spring DSL «pur» utilisant XML:
De cette façon, nous disons à Camel d'utiliser la classeFileRouter qui contient la définition de notre route dans Java DSL:
public class FileRouter extends RouteBuilder {
private static final String SOURCE_FOLDER =
"src/test/source-folder";
private static final String DESTINATION_FOLDER =
"src/test/destination-folder";
@Override
public void configure() throws Exception {
from("file://" + SOURCE_FOLDER + "?delete=true").process(
new FileProcessor()).to("file://" + DESTINATION_FOLDER);
}
}Afin de tester cela, nous devons créer une instance deClassPathXmlApplicationContext qui chargera nosCamelContext au printemps:
@Test
public void moveFolderContentSpringDSLTest() throws InterruptedException {
ClassPathXmlApplicationContext applicationContext =
new ClassPathXmlApplicationContext("camel-context.xml");
Thread.sleep(DURATION_MILIS);
applicationContext.close();
}En utilisant cette approche, nous bénéficions d'une flexibilité et d'avantages supplémentaires fournis par Spring, ainsi que de toutes les possibilités du langage Java grâce à Java DSL.
6. Conclusion
Dans cet article rapide, nous avons présenté une introduction à Apache Camel et démontré les avantages de l’utilisation de Camel pour des tâches d’intégration telles que le routage des fichiers d’un dossier à un autre.
Dans notre exemple, nous avons vu que Camel vous permettait de vous concentrer sur la logique métier et réduisait la quantité de code passe-partout.
Le code de cet article peut être trouvéover on GitHub.