JAXenter.de

Das Portal für Java, Architektur, Cloud & Agile
X

W-JAX-Countdown heute: Stefan Zörner über zeitgemäße Architekten und Architekturen.

Erste Schritte

Apache Camel: Agile Enterprise-Integration

Alberto Mijares

Enterprise-Integrationsprojekte gehören zu den komplexesten in der IT-Welt. Damit unterschiedliche Applikationen auf eine zuverlässige und effiziente Weise zusammenarbeiten können, braucht es eine Integrations-Middleware, die nicht nur die technischen Anforderungen erfüllt, sondern auch die Agilität unterstützt und fördert. Apache Camel ist eines dieser Open-Source-Projekte, das auf diesem Gebiet nicht nur wegen der großen Anzahl an technischen Features brilliert, sondern sich auch wegen des einfachen Lösungsansatzes für die Enterprise-Integration bestens eignet.

Enterprise-Integrationsprojekte gehören zu den komplexesten in der IT-Welt. Damit unterschiedliche Applikationen auf eine zuverlässige und effiziente Weise zusammenarbeiten können, braucht es eine Integrations-Middleware, die nicht nur die technischen Anforderungen erfüllt, sondern auch die Agilität unterstützt und fördert. Apache Camel ist eines dieser Open-Source-Projekte, das auf diesem Gebiet nicht nur wegen der großen Anzahl an technischen Features brilliert, sondern sich auch wegen des einfachen Lösungsansatzes für die Enterprise-Integration bestens eignet.

Eines der Hauptthemen in den heutigen Enterprise-Informatikprojekten ist ihre inhärente Komplexität. Diese entsteht aus dem Bedürfnis, geschäftskritische Prozesse weltweit und zuverlässig umsetzen zu können. Während Skalierbarkeit und Betriebssicherheit durch programmatische Faktoren in den Applikationen modelliert werden können, ist die Modellierung oder gar die Beschreibung von effizienten Geschäftsprozessen nicht ganz so einfach. Meistens sind die Anforderungsanalyse und die effiziente Entwicklung von neuen Funktionen unproblematisch. Schwieriger ist es jedoch, bereits existierende Applikationen als einen eigenständigen Teil in ein Zielsystem zu integrieren. Mögliche Gründe für die Integration bestehender Systeme sind einerseits oft reiner Investitionsschutz oder aber fehlendes Know-how über den Nachbau eines funktionierenden Systems.

Das Zusammenführen von komplexen und heterogenen Systemen zu noch komplexeren Systemen wird allgemein als Integration bezeichnet. Damit mehrere Applikationen zusammen arbeiten können, müssen sie die "gleiche Sprache" sprechen oder aber über eine Middleware kommunizieren, die "sämtliche Sprachen" aller Applikationen kennt. Das Erste ist wirklich selten der Fall und erfordert Applikationen, die für eine gewisse zukünftige Integration schon so ausgelegt worden sind. Das Finden einer geeigneten Middleware ist eine zeitaufwändige Aufgabe, die üblicherweise einen detaillierten Evaluationsprozess von unterschiedlichen Produkten und Lösungsvorschlägen impliziert. Eine der Schwierigkeiten ist dabei, die richtigen Bewertungskriterien (meist technischer Natur) auszuwählen. Oft zeigt es sich, dass einige Faktoren in der Evaluationsphase als ausschlaggebend angesehen werden, die in der folgenden Implementationsphase nur mit der Effizienz der Applikation zur Middleware zu tun haben und nicht mit den eigentlichen technischen Features. Zu diesen Faktoren zählen Agilität, Leichtigkeit, adäquate Lernkurve und gute Wiederverwendbarkeit. Um zu veranschaulichen, wie diese abstrakten Konzepte wirklich in eine Middleware-Integration passen, wird gezeigt, was Apache Camel alles zu bieten hat.

Grundlagen

Die Grundzüge von Apache Camel können durch folgende Konzepte aufgeführt werden: dute Unterstützung der Enterprise Integration Patterns, Java-basierend, ausgezeichnete Spring-Integration und für Prototyping und Modularisierung konzipiert. Diese Eigenschaften plus der Tatsache, dass es auf Maven basiert, machen dieses Projekt sehr populär im Umfeld der Enterprise-Integration. Wie schon erwähnt, bietet Camel eine Java-Implementierung der Enterprise Integration Patterns an. Diese Muster sind im Buch von Gregor Hohpe und Bobby Woolf [1] zusammengestellt, gut beschrieben und im Grunde genommen Rezepte für einen Nachrichtenaustausch auf einem abstrakten Level. Sie zeigen, wie die Probleme des Datenaustauschs auf Applikationsebene effizient und zuverlässig gelöst werden können. Wie im Buch erklärt, ist ein Datenaustausch, der in unterschiedlichen Ausprägungen (in, out, in/out, asynchron und synchron) konfiguriert wird und die Kommunikationsanforderungen von Enterprise-Applikationen auf eine generische Weise implementiert, ein mächtiger Mechanismus.

Erste Schritte

Wegen des deklarativen Charakters von nachrichtengesteuerten Systemen besteht ein großer Teil einer Applikation mit Apache Camel im Konfigurieren von Nachrichtenflüssen (Message Flows). Camel bietet unterschiedliche Möglichkeiten an, dieses Problem zu lösen. Eine favorisierte und empfohlene Art ist die Anwendung von Camel Java DSL. Das erste Element, das instanziiert und konfiguriert werden muss, ist ein so genannter Camel Context. Sobald dieser gestartet ist, ist das System bereit, Meldungen entsprechend einem konfigurierten Nachrichtenfluss zu versenden oder zu empfangen. Listing 1 zeigt, wie eine minimale Apache-Camel-Applikation ausschaut. Dieses erste Beispiel erklärt, wie die Abhängigkeiten der Camel-Applikation unter Verwendung von Maven (Listing 2) konfiguriert werden und wie der Camel Context in Java instanziiert wird.

Listing 1
package com.example.camel; 
import org.apache.camel.impl.DefaultCamelContext;
 public class Example1 { public static void main(String[] args) throws Exception { DefaultCamelContext camelContext = new DefaultCamelContext(); camelContext.start(); Thread.sleep(10000); // Wait some time before stopping the context camelContext.stop(); } }
Listing 2
4.0.0com.exampleCamel1.0org.apache.camelcamel-core${camel.version}2.8.0

Um dieses Beispiel laufen lassen zu können, muss sichergestellt sein, dass Apache Maven im Ausführungspfad spezifiziert ist. In einer Konsole, die auf dem Verzeichnis mit den abgespeicherten Dateien geöffnet wurde, wird dann der folgende Befehl eingegeben: mvn compile exec:java -Dexec.mainClass="com.example.camel.Example1". Wie man sieht, führt diese Applikation überhaupt nichts aus, außer dass sie einen leeren Camel Context startet, einige Sekunden wartet und dann den Context stoppt. Wie sieht nun aber ein typisches Beispiel in Camel aus? Das folgende Schulbeispiel illustriert, wie ein Nachrichtenfluss (in Camel eine Route genannt) spezifiziert und zu diesem Nachrichtenfluss eine Meldung gesendet wird. Um Routen in einem Context zu erstellen, wird ein Route Builder (Listing 3) verwendet.

Listing 3
package com.example.camel; import org.apache.camel.builder.RouteBuilder;  public class Example2Routes extends RouteBuilder {     @Override     public void configure() throws Exception {         from("direct:say_hello")                 .setBody(constant("Hello ").append(body()))                 .to("stream:out");     } } 

Dazu muss die Applikation leicht geändert (Listing 4) und ein neues Modul von Camel (Listing 5) hinzugefügt werden.

Listing 4
public static void main(String[] args) throws Exception {     DefaultCamelContext camelContext = new DefaultCamelContext();     camelContext.addRoutes(new Example2Routes());     camelContext.start();      ProducerTemplate template = camelContext.createProducerTemplate();     template.sendBody("direct:say_hello", "Alberto");      Thread.sleep(1000);     camelContext.stop(); } 
Listing 5
org.apache.camelcamel-stream${camel.version}

In diesem Beispiel wurde ein erstes Camel Route eingeführt, das von einem einzigen Endpunkt (direct:say_hello) ausging. Es zeigt, wie der Inhalt der Nachricht mit Java DSL umgewandelt und an den Endpunkt gesendet wird und wie die Nachricht durch die Verwendung eines Producer Templates an einen Context weitergeleitet wird. Dieses Beispiel berücksichtigt folgende wichtige Konzepte:

  • Routen können innerhalb von Route Builders gepackt werden und es können sich beliebig viele auf einen Context beziehen, die die verlangte Funktion auf eine modulare Weise einrichten.
  • Dazu kann eine Applikation mehrere Contexts haben, die parallel mit einem passenden Isolationslevel arbeiten.
  • Die Funktion eines Endpunkts wird durch ein URI (stream:out) definiert, das aus einem Präfix (stream) und einem Suffix (out) besteht. Der Präfix identifiziert eine von mehreren Camel-Komponenten [2] und somit die Funktionalität. Das Suffix konfiguriert die Funktion mittels einer komponentenspezifischen Parametersyntax.
  • Einige Endpunkte funktionieren in einer passiven Weise (diese warten auf eingehende Meldungen), während andere aktiv unterschiedliche Arten von Ressourcen überwachen (z. B. durch festgelegte, zyklische Abfragen).
 

Kommentare

Ihr Kommentar zum Thema

Als Gast kommentieren:

Gastkommentare werden nach redaktioneller Prüfung freigegeben (bitte Policy beachten).