Integration camel

© OPITZ CONSULTING GmbH 2010 Seite 1Integration mit Apache Camel
Dr. Ralf Sigmund, Bereichsleiter
OPITZ CONSULTING Hamburg GmbH
Hamburg, 02.03.2011
Integration mit Apache Camel

Agenda
1. Enterprise Integration Patterns
2. Einführung in Apache Camel
3. Ein Beispiel
4. Weitere Patterns
5. Beans

1 Enterprise Integration Patterns

Enterprise Integration Patterns (EIP) (1)
 Bewährte Lösungsschablonen für Integrationsszenarien auf
Basis asynchronen Nachrichtenaustauschs
 Muster beschreiben Lösung von Problemen, die bei der
Integration heterogener Anwendungen auf
unterschiedlichen Plattformen auftreten.
 Definition einer grafischen Notation
Titel: Enterprise Integration Patterns
Autor: Gregor Hohpe, Bobby Woolf
Verlag: Addison-Wesley
ISBN: 0321200683

Enterprise Integration Patterns (2)
 Musterkatalog besteht aus 65 Integration Patterns
 Die Muster lassen sich in verschiedenen Kategorien
unterteilen
 Message Construction
 Message Endpoints
 Message Channels
 Message Routing
 Message Transformation
 System Management

2 Einführung in Apache Camel

Enterprise Integration mit Apache Camel
 Open Source Integrations Framework
 Subprojekt von ApacheMQ
 Umsetzung eines Großteils der Enterprise Integration
Patterns
 Ermöglicht die Definition von Routing- und
Konvertierungsregeln in Java oder Scala auf Basis
 einer domänenpezifischen Sprache (DSL) bzw.
 Spring basierter XML-Konfiguration
Titel: Camel In Action
Autor: Claus Ibsen, Jonathan Anstey
Verlag: Manning
ISBN: 9781935182368

Apache Camel (Architektur)
 Zentraler Punkt der Camel-Architektur: CamelContext
 Hier registrieren sich sämtliche Komponenten und erhalten
eine eindeutige Adresse in Form einer URI
Aus: Ibsen, Anstey: Camel in Action, Manning 2010

Apache Camel (Komponenten)
 Camel stellt eine Vielzahl an Komponenten zur Verfügung
(über 80), die unterschiedliche Transportprotokolle und –
formate sowie eine Reihe von Bindings anbieten
 http://camel.apache.org/components.html
 Beispiele für Komponenten:
 JMS-Komponente: erlaubt das Senden (bzw. Konsumieren) von Nachrichten
an eine JMS-Queue oder –Topic
 JDBC-Komponente: Verbindung mit Datenbanken via JDBC und Absetzen
von SQL-Statements
 JPA-Komponente: erlaubt das Speichern und Abfragen von Objekten (ORM)
 File-Komponente: ermöglicht das Laden und Speichern im Dateisystem
 FTP-Komponente: erlaubt den Zugriff auf entfernte Dateisysteme über FTP
 HTTP-Komponente: Http-Client für den Aufruf externer Server
 Direct-Komponente: direkter, synchroner Aufruf eines beliebigen Endpunktes

Apache Camel (Endpunkte)
 Endpunkte arbeiten wahlweise als Consumer (in-only) oder
Producer (out)
 Consumer nehmen Nachrichten entgegen
 Producer erzeugen Nachrichten
 es ist aber auch möglich beide Rollen einzunehmen (in-out)
 Endpunkte werden durch protokollspezifische Factories
erzeugt und im Laufzeit-Container registriert
(CamelContext).

Camel (Routenbildung)
 Routenbildung (Camel-Route) erfolgt über eine bestimmte
Anzahl von RouteBuildern, die dem CamelContext
hinzugefügt werden
 Zur Festlegung der Routen zwei Möglichkeiten:
 Definition über Java-basierte domänenspezifische Sprache (DSL)
 Spring basierte XML
 Bei der DSL handelt es sich um eine Inline DSL, der das
Builder-Pattern zugrunde liegt
 Durch Verkettung von Methoden wird eine Route
(Nachrichtenfluss) definiert.

3 Ein Beispiel

Beispielmuster: Message-Filter
 spezielle Art eines Routers
 es werden nur Nachrichten weitergeleitet, deren Inhalt
bestimmte Kriterien erfüllt
 hat nur einen output-Channel
Nachricht
Typ A
Nachricht
Typ A
Nachricht
Typ ANachricht
Typ A
Nachricht
Typ B
Message
Fiilter

Beispielmuster: Message Filter (Java)
 Java-Klassen müssen die Basisklasse
org.apache.camel.builder.RouteBuilder erweitern und die
Routenlogik in der configure-Methode bereitstellen
public class MyRouteBuilder extends RouteBuilder {
public void configure() throws Exception {
from("activemq:topic:Quotes").filter().
xpath("/quote/product='widget'")
.to("mqseries:WidgeQuotes");
}
}

Beispielmuster: Message Filter (Java)
 Endpunkt A nimmt eine Nachricht aus einer Queue
entgegen (from). Diese wird anschließend verarbeitet und an
den Endpunkt B weitergeleitet (to).
public class MyRouteBuilder extends RouteBuilder {
public void configure() throws Exception {
Endpoint A = endpoint("activemq:topic:Quotes");
Endpoint B = endpoint("mqseries:WidgeQuotes");
Predicate isWidget = xpath("/quote/product= 'widget'");
from(A).filter(isWidget).to(B);
}}

Beispielmuster: Message Filter
(Spring XML)
 Der CamelContext wird innerhalb des Beans-Tags in den
ApplicationContext eingtragen
 in der XML-Definition finden sich den Methoden der
Java-DSL entsprechende Tags wieder
<camelContext xmlns="http://camel.apache.org/schema/spring">
<route>
<from uri="activemq:topic:Quotes">
<filter>
<xpath>/quote/product='widget'</xpath>
</filter>
</from>
<to uri="mqseries:WidgeQuotes">
</to>
</route>
</camelContext>

Ausführung in einer Java-Anwendung
 CamelContext kann programmatisch erzeugt werden
 Keine zusätzlichen Bibliotheken / Frameworks notwendig
CamelContext context = new DefaultCamelContext();
context.addRoutes(new MyRouteBuilder());
context.start();

CamelContext in Spring
 Package-Tag: Package, in dem nach Route-Buildern gesucht
werden soll => Routendefinition in Java ist auch möglich,
wenn Spring genutzt wird
 PropertyPlaceholder-Tag: Verweis auf eine properties-Datei,
auf die in Routendefinitionen zugegriffen werden kann
<camelContext xmlns="http://camel.apache.org
/schema/spring">
<propertyPlaceholder id="properties"
location="classpath:camel-prod.properties"/>
<package>com.acme.quotes</package>
</camelContext>

4 Weitere Patterns

Content Based Router
 Untersuchen des Inhaltes der Nachricht
 Weiterleitung in verschiedene Kanäle in Abhängigkeit von
ihrem Inhalt
 Kann auf verschiedenen Kriterien basieren (z.B.
Vorhandensein bestimmter Felder, Inhalt von Feldern…)
Neuer
Auftrag
Router
Endpunkt A
Endpunkt B

 Abarbeiten eines Auftrags aus der Queue
 Überprüfen der Nachricht (XML) anhand eines XPath-
Ausdrucks
RouteBuilder builder = new RouteBuilder() {
public void configure() {
from("activemq:Auftraege").choice().when(
xpath("/order/product").isEqualTo("produktA")).
to("direct:A").when(xpath("/order/product")
.isEqualTo("produktB")).to("direct:B").otherwise()
.to("direct:C");
}
};

<route>
<from uri="activemq:Auftraege" />
<choice>
<when>
<xpath>/order/product = 'produktA'</xpath>
<to uri="direct:A" />
</when>
<when>
<xpath>/order/product = 'produktB'</xpath>
<to uri="direct:B" />
</when>
<otherwise>
<to uri="direct:C" />
</otherwise>
</choice>
</route>
</camelContext>

Splitter
 Empfängt eine Nachricht mit wiederkehrenden Elementen,
die separat verarbeitet werden können
 Für jedes Element (oder jede Teilmenge) der
Ursprungsnachricht wird eine neue Nachricht erzeugt
Neuer
Auftrag Splitter
Auftrags
position
1
Auftrags
position
2
Auftrags
position
3

Splitter
 Laden von Aufträgen aus dem Dateisystem
 Nachricht (als String) wird zeilenweise zerlegt
 Entstehende Nachrichten werden an eine Queue gesandt
from("file://Auftraege").
split(body(String.class).tokenize("n")).
to("activemq:Auftraege.Positionen");
}
};

Splitter
 Laden von Nachrichten aus dem Dateisystem
 Nachricht (XML-Format) wird anhand eines XPath-
Ausdrucks zerlegt
 Senden an eine Queue
<route>
<from uri="file://Auftraege" />
<split>
<xpath>/auftrag/positionen</xpath>
<to uri="activemq:Auftraege.Positionen />
</split>
</route>
</camelContext>

Message Translator
 Ermöglicht Kommunikation zwischen Systemen mit
verschiedenen Datenformaten
 Konvertiert eine Nachricht in das Format eines Partners
Eingehende
Nachricht
Umgeformte
NachrichtTranslator

Message Translator
 Transformation einer XML-Nachricht mithilfe eines XSL-
Templates
 XSLT-Komponente erhält als Parameter den Pfad zum XSL-
Template
from("file://Auftraege").to(
"xslt:com/acme/mytransform.xsl").to(
"activemq:Auftraege");
}
};

Message Translator
 Transformation kann alternativ durch (hier anonyme)
Implementierung eines Processors geschehen
 Durch Parameter exchange Zugriff auf eingehende (In) und
ausgehende (Out) Nachricht
 Beliebige Ausführung von Java-Code möglich
from("file://Auftraege").process(new Processor() {
public void process(Exchange exchange) {
Message in = exchange.getIn();
in.setBody(in.getBody(String.class) + " World!");
}
}).to("activemq:Auftraege");

Message Translator
 Anhängen von ‚extra data!‘ im transform-tag
 Statt Simple kann eine Vielzahl weiterer Expression
Languages genutzt werden, wie beispielsweise Java Script,
Groovy, EL, XPath
<route>
<from uri="file://Auftraege" />
<transform>
<simple>${in.body} extra data!</simple>
</transform>
<to uri="activemq:Auftraege" />
</route>
</camelContext>

5 Beans

Message Translator: Bean
 Nutzung einer Java Bean, falls komplexe Logik für
Transformation benötigt (z.B. DB-Zugriff, Schleifen)
 Vorteil: Routenbeschreibung bleibt übersichtlich und
deklarativ, Logik wird ausgelagert
 Bean-Komponente erhält als Parameter den Namen der
Bean und den Methodennamen
 Ist kein Methodenname angegeben oder wurde die Methode überladen, wird
versucht, anhand der Nachricht die richtige Methode zu ermitteln
 Bean muss im Spring-Context oder im JNDI-Context
registriert werden
from("file://Auftraege").to(
"bean:ConverterBean?method=convertOrder").to(
"activemq:Auftraege");

Die Bean
 Rückgabe der convertOrder-Methode wird an den Body der
Nachricht gebunden
 Mittels der @Header-Annotation wird der Header
‚headerName‘ an den Parameter header gebunden
 Mittels der @XPath-Annotation wird die Nachricht mit einem
XPath-Ausdruck ausgewertet und das Ergebnis an den
Parameter auftragsNummer gebunden
public class ConverterBean {
@Consume(uri = "activemq:Auftraege")
public String convertOrder(@Header(value = "headerName")
String header, @XPath(value = "/auftrag/nummer")
String auftragsNummer) {
return header + auftragsNummer;
}
}

Typ-Konvertierung
 Camel unterstützt eine ganze Reihe von Konvertierungen
„out of the box“
 Bei Bedarf können eigene Konverter implementiert werden
 Hinzufügen der @Converter-Annotation zur Klasse und Methode
 Eintragen der Packages mit Konverter-Klassen in META-
INF/services/org/apache/camel/TypeConverter
@Converter
public class IOConverter {
@Converter
public static InputStream toInputStream(File file)
throws FileNotFoundException {
return new BufferedInputStream(new
FileInputStream(file));
}
}

Beans an Endpunkte binden
 Eine einfache Alternative zur Definition einer kompletten
Route
 Durch die @Consume-Annotation wird die Methode an den
als Parameter übergebenen Endpunkt gebunden
 Beim Eintreffen einer neuen Nachricht wird die Methode mit
der Nachricht als Parameter aufgerufen
public class AuftragsBean {
@Consume(uri = "activemq:Auftraege")
public void pruefeAuftrag(String body) {
...
}
}

Nachrichten an Endpunkte senden
 Durch die @Produce-Annotation wird der Bean ein
Producer-Template injiziert, mit dessen Hilfe Nachrichten an
den jeweiligen Endpunkt gesendet werden können
 Weitere Methoden verfügbar (z.B. senden von Headern)
 (Nachteil: Aufrufer wird vom Camel-API abhängig; kann
durch ein Interface versteckt werden)
public class SenderBean {
@Produce(uri = "activemq:Auftraege")
ProducerTemplate template;
public void sendeNachricht() {
template.sendBody("Nachricht");
}
}

Testen
 Spezielle Komponente: Mock-Endpoints
 Abstrakte Klasse CamelTestSupport
 Formulieren von Erwartungen und Assertions für Mock-
Endpunkte
 Zugriff auf Nachrichten, die an Mock-Endpunkten
eingegangen sind

Testen: Testklasse
public class FilterTest extends CamelTestSupport {
@EndpointInject(uri = "mock:result")
protected MockEndpoint resultEndpoint;
@Produce(uri = "direct:start")
protected ProducerTemplate template;
@Override
protected RouteBuilder createRouteBuilder() {
return new RouteBuilder() {
from("direct:start").filter(
header("auftragsNummer").isEqualTo("1")).to(
"mock:result");
}
};
}
}

Testen: Testmethoden
public void testSendMatchingMessage() throws Exception {
String expectedBody = "<matched/>";
resultEndpoint.expectedBodiesReceived(expectedBody);
template.sendBodyAndHeader(expectedBody,
"auftragsNummer", "1");
resultEndpoint.assertIsSatisfied();
}
public void testSendNotMatchingMessage() throws Exception {
resultEndpoint.expectedMessageCount(0);
template.sendBodyAndHeader("<notMatched/>",
"auftragsNummer", "2");
resultEndpoint.assertIsSatisfied();
}

Quellen und weiterführende Links
 http://camel.apache.org/enterprise-integration-patterns.html
 http://www.enterpriseintegrationpatterns.com/
 http://camel.apache.org/components.html

Fragen und Antworten

Integration camel

Weitere ähnliche Inhalte

Ähnlich wie Integration camel (20)

Integration camel