Anwendungs-Integration mit Apache Camel, Vortrag auf dem Expertenkreis Java, GEDOPLAN, 30.10.2014, Hendrik Jungnitsch

1. Anwendungs-Integration mit Apache
Camel
Java Expertenkreis, 30.10.2014 Gedoplan
Hendrik Jungnitsch, GEDOPLAN GmbH

2. Anwendungs-Integration - Problemstellung
Integrationsszenarios
Anbindung von Fremdsystemen
Integrieren von Legacy-Systemen
Anwendungen als wiederverwendbare Komponenten
(Microservices)
Mögliche Lösungsansätze
ESB (Enterprise Service Bus)
SOAP
Routing-Engine (z. B. Camel oder Spring Integration)
2

3. Anwendungs-Integration – Typische
Probleme/Anforderungen
Verschiedene Transferprotokolle
Unterschiedliche Datenformate
Synchrone und asynchrone Kommunikation
Aufteilen und Zusammenführen von Daten
Parallelisierung
Logging / Monitoring
3

4. Enterprise Integration Patterns
Buch von Gregor Hohpe und Bobby Woolf (2004)
Beschreibt 65 Designmuster
Enterprise Integration Pattern (EIP)
Best-Practices für Lösung von Integrationsproblemen
Erleichtern Entwurf von Integrationsanwendungen
4

5. Apache Camel
Routing Engine
Implementiert in Java
Bietet technische Umsetzung der EIP
Apache License 2.0
Aktuelle Version: 2.14.0
5

6. Getting Started – Einbindung in Projekt
Core-Bibliothek besteht aus
Routing-Engine
Einigen grundlegenden Kommunikationsprotokollen
Weitere Module mit gleicher Version wie Core einbinden
6
<dependency>
<groupId>org.apache.camel</groupId>
<artifactId>camel-core</artifactId>
<version>2.14.0</version>
</dependency>

7. Getting Started - CamelContext
Laufzeitumgebung für Camel-Routen
Führt Registry über
Beans
Endpoints
DataTypes
Bietet Funktionen an wie:
Starten / Stoppen von Routen
Hinzufügen von RouteBuildern
…
7
CamelContext camelContext = new DefaultCamelContext();

8. Getting Started - RouteBuilder
Abstrakte Basisklasse
Erlaubt das Bauen von Routen mit Hilfe der Java DSL
8
public class MyRouteBuilder extends RouteBuilder {
public void configure() throws Exception {
from(“file://C:Tempimport”).to(“file://C:Tempexport”);
}
}

9. Getting Started – Erste Anwendung
9
public class MyCamelApplication {
public class MyRouteBuilder extends RouteBuilder {
public void configure() throws Exception {
from(“file://C:Tempimport”).to(“file://C:Tempexport”);
}
}
public static void main(String[] args) {
CamelContext camelContext = new DefaultCamelContext();
camelContext.addRoutes(new MyRouteBuilder());
camelContext.start();
. . .
camelContext.stop();
}
}

10. Routing
Umsetzung der EIP durch Routen
Routen beschreiben den Datenfluss
Bestehen aus Endpoints und Processors
Deklariert mit DSLs
Java
XML
Scala
. . .
10

11. Endpoint
Beschreibt Schnittstelle
physikalische und logische Adresse
Kommunikationsprotokoll
Weitere Einstellungen
Wird erzeugt von einer Factory genannt Component
Ansprechen in Route in der Regel über URI
f i l e : / / C : i m p o r t
11
Compone
nt
Endpoint
Konfiguration

12. Consumer
Endpoint für Konsumieren von Daten
Implementierung kapselt Code für das Empfangen
Immer am Anfang einer Route
In Java-DSL definiert mit: from(endpoint:uri)
12
from(“file://C:import“)
Polling
Consumer
Selective
Consumer
Event-Driven
Consumer

13. Producer
Endpoint für Produzieren von Daten
Implementierung kapselt Code für das Senden
Immer am Ende einer Route
In Java-DSL definiert mit: to(endpoint:uri)
13
to(“file://C:export“)

14. Components - Beispiele
14
JMS
FTP
Mail
Twitter
Facebook
JPA
XMPP
HTTP
CXF
Hazelcast
Vert.x
Websocket

15. Exchange von Messages
Message kapselt ausgetauschte Daten
ID
Header
Body (Payload)
Exchange speichert Informationen über den Austausch
In-Message
Out-Message
Exceptions
15

16. Processor
Routingbausteine
Bestimmen Daten-Fluss/Umwandlung zwischen Endpoints
Arbeiten mit dem Exchange-Objekt
Umsetzung von EIPs
Eigene Processors möglich
16

17. DataFormats
(Un-) Marshalling von Daten
Java Serialisierung
JAXB
CSV
. . .
Zusätzliche Formate müssen als Dependency hinzugefügt
werden
17
from(endpoint).unmarshall(new JaxbDataFormat()).someProcessing()
.marshall(new GsonDataFormat()).to(endpoint)

18. Camel - Überblick
18
Routing-Engine Processors
DataFormats
DSLs
(Java,XML,Scala,
…)
CamelContext
(Runtime)
XM
L
CS
V
Endpoints
SMT
P
Pop3 File FTP
Mail Components
JSO
N
Splitter
Router
Route Routendefinition

19. Routing-Elemente - Splitter
Aufteilen einer Message
Splitting der Payload
Produzieren neuer Messages mit Einzeldatensätzen
19
from(endpoint).split(stax(Veranstaltung.class).to(endpoint)

20. Routing-Elemente - Parallelisierung
Paralleles Weiterverarbeiten von Messages
Angeboten von einigen Routingbausteinen
Splitter
Multicast
Auch möglich durch entsprechende Endpoints
20
from(endpoint).split(…).parallelProcessing()
.executorService(pool).to(endpoint)

21. Routing-Elemente - Aggregator
Zusammenführen/Sammeln von Messages
Ergebnis der Aggregation wird neue Payload
Zusammenführen nach Inhalt möglich
Sammeln beenden nach
from(…).aggregate().constant(true).comple
tionTimeout(50000).to(…)
Zeitintervall
Anzahl Messages
Weiteren Bedingungen
21

22. Routing-Elemente - Bean Binding
Aufruf von Bean-Methoden aus einer Route heraus
Überreicht Payload als Parameter
Rückgabewert wird neue Payload
22
from(…).beanRef(“veranstaltungen“ , “create“)
from(…).beanRef(new Veranstaltungen(), “create“)
oder
public Veranstaltung create(Veranstaltung v) {…}

23. Routing-Elemente - WireTap
Abzweigen von Routen
Original Route unbeeinflusst
Weiterarbeiten auf Kopie der Payload möglich
23
from(…)
.wireTap(loggingendpoint).copy().end()
.to(originaldestination)

24. In-Memory Endpoints
Erlauben Verknüpfen von Routen
CamelContext intern
Seda
direct
Context übergreifend
vm
vm-direct
24
from(“direct:import“)
.split().beanRef(…)…
from(“file://C:import“)
.to(“direct:import“).
from(“ftp://import@server“)
.to(“direct:import“).

25. Routing-Elemente - Router
Weiterverteilen von Messages
Inhaltsbasierter Router
Feste Anzahl Regeln/Verzweigungen
Dynamischer Router
Dynamische Datenbasis für Routingregeln
25

26. Programmatisches Senden an Routen
Senden über ProducerTemplate
Synchrones Senden
Asynchrones Senden
26
ProducerTemplate template = camelContext.createProducerTemplate()
template.sendBody("direct:Import", payload);
Future<Exchange> future = template.asyncSend("direct:import", exchange);
Exchange result = future.get();

27. Typumwandlung
DataFormat
Für (De)-serialisieren
TypeConverter
Umwandeln der Zugriffsart
(File,byte[],String,InputStream)
Translator (Processor, Bean-Methode)
Mapping von Businessobjekten
27

28. Exception Handling
Try-Catch
Exception Clause
onException(Exception.class).to(endpoint)
Deadletter-Channel
28
from("direct:start")
.doTry()
.process(new ProcessorFail())
.to("mock:result")
.doCatch(IOException.class)
.to("mock:catch")
.doFinally()
.to("mock:finally")
.end();
errorHandler(deadLetterChannel(endpoint))

29. Logging
Problemstellung
Vielzahl Messages Parallel
In vielen Routen
Verarbeitet von unterschiedlichen Threads
Mapped-Diagnostic-Context (MDC)
Speichert Kontextinformationen (routenId, messageId,
usw…)
Informationen über Pattern in Log-Formatter
mitausgegeben
29

30. Monitoring
Camel sammelt statistische Daten für Endpoints
Daten werden per JMX bereitgestellt
Zusätzliche Daten mit neuem (2.14.0) Metrics Component
Empfehlung JMX-Konsole: HawtIO
Bietet Camel Modul
Übersicht Routen und Endpoints
Visualisierung von Routen
Debuggen von Routen
30

31. Monitoring - hawtio
31

32. CDI-Integration
Kann als Zusatzmodul eingebunden werden
Wenn Anwendung in CDI-Container läuft
CDI-Registry
Automatisches Registrieren von Routebuildern,
TypeConverters
Erlaubt Injection von CamelContext, Endpoints
Ansprechen von CDI-Beans aus Routen
32

33. Testing
Testlibraries für Junit und TestNG
Mock Endpoints
Senden an Routen über ProducerTemplate
NotifyBuilder für Testen von Bedingungen
AdviceWith Builder erlaubt Modifizieren bestehender
Routen
33

34. Setup Szenarios
Standalone JavaSE
JavaEE Applicationserver
Als Teil des Deployments (EAR/WAR)
Oder als Modul
OSGI-Runtime
z. B. Apache Karaf
Erlaubt dynamisches Hinzufügen von Endpoints und
Routen
34

35. Dokumentation
Dokumentation auf Apache-Projektseite
Konfigurationsmöglichkeiten für Endpunkte
Verwendung von Routingbausteinen
Viele Code Beispiele
DSLs
Gut geeignet zum Nachschlagen
Bücher
Tutorials
35

36. Fazit
Mächtig und Flexibel
Leichtgewichtig Dank Modularisierung
Vielzahl DSLs
Java-DSL Typsicher mit jeder gängigen IDE
Unterstützt Vielzahl von Deploymentszenarien
Integrationsthematik bedingte Komplexität
Entsprechende Einarbeitungszeit
36