Dans notre premier exemple simple de mise en oeuvre du projet Apache Camel, nous allons créer une application Java capable d'envoyer toute une série de courriels comme messages de salutation vers un destinataire particulier.
Cette application fait intervenir les composants Camel Timer et Mail : une instance du composant Timer va générer à intervalle de temps régulier (1 s) des échanges de message qui, selon la route définie dans le contexte Camel, vont être transmis à une instance du composant Mail.
Dans notre application, après avoir créé un contexte d'exécution Camel (CamelContext), nous lui ajoutons une route qui est une implémentation de l'interface RouteBuilder, et dont la méthode configure permet de construire une route Camel.
Camel utilise un DSL, ou Domain Specific Language, implémenté en Java, pour définir l'ensemble des routes et des modèles d'intégration d'entreprise à appliquer lors de l'exécution du contexte. L'intérêt d'utiliser un DSL Java est que d'une part, nous utilisons un langage métier clair bien adapté au problème des définitions des routes entre composants, et que d'autre part, l'implémentation en Java de ce DSL permet à votre environnement de développement d'appliquer l'achèvement de code.
La seule route configurée dans notre exemple par :
utilise deux URIs (URI pour Uniform Resource Identifier, et Camel en fait un usage intensif) faisant référence à des terminaisons (qui correspondront à l'exécution des instances implémentant l'interface Endpoint).
Dans Camel, vous pouvez communiquer avec une terminaison, soit en lui envoyant des messages, soit en consommant des messages depuis celle-ci. Par exemple ici, nous consommons des messages depuis la terminaison timer pour les envoyer à la terminaison smtp.
Comme vous pouvez le remarquer, une URI dans Camel commence par un nom de protocole ou de pseudo-protocole. Chaque protocole est pris en charge par un composant particulier de Camel, certains composants en prenant plusieurs en charge comme le composant Mail pour l'envoi et la réception de courriels.
Pour revenir à notre exemple, les paramètres tels que le nom du serveur de messagerie et le destinataire des messages sont spécifiés dans l'URI : ici le serveur de messagerie est serveur_smtp, le nom de l'utilisateur et son mot de passe sont respectivement utilisateur et mot_de_passe, et pour finir, l'adresse e-mail du destinataire est destinataire@test.com.
Bien sûr, vous devez utiliser vos propres paramètres.
Dans la configuration de la route, entre les appels de méthode from et to, le corps du message, qui deviendra le corps du courriel, est défini par un appel à la méthode setBody.
Voici maintenant le code source de notre application :
import org.apache.camel.CamelContext;
import org.apache.camel.builder.RouteBuilder;
import org.apache.camel.impl.DefaultCamelContext;
public class Test {
public static void main(String[] args) throws Exception {
CamelContext camelContext = new DefaultCamelContext();
camelContext.addRoutes(new RouteBuilder() {
public void configure() {
from("timer:myTimerEvent?fixedRate=true&delay=0&period=1000")
.setBody(constant("Salut !")).to("smtp://utilisateur@serveur_smtp?password=mot_de_passe#destinataire@test.com");
}
});
camelContext.start(); // démarrer le contexte
Thread.sleep(3000); // attente de 3 s
camelContext.stop(); // arrêt du contexte
}
}
Cet exemple d'application a présenté quelques notions du projet Apache Camel, et aura démontré, nous l'espérons, la souplesse de la définition des routes avec un langage de type DSL basé sur Java.
Nul doute que nous allons poursuivre notre route avec Camel !