Anwendungs-Integration mit Apache Camel

Java Expertenkreis, 30.10.2014 Gedoplan

Hendrik Jungnitsch, GEDOPLAN GmbH

Anwendungs-Integration - Problemstellung

IntegrationsszenariosAnbindung von FremdsystemenIntegrieren von Legacy-SystemenAnwendungen als wiederverwendbare Komponenten (Microservices)

Mögliche LösungsansätzeESB (Enterprise Service Bus)SOAPRouting-Engine (z. B. Camel oder Spring Integration)

2

Anwendungs-Integration – Typische Probleme/Anforderungen

Verschiedene Transferprotokolle

Unterschiedliche Datenformate

Synchrone und asynchrone Kommunikation

Aufteilen und Zusammenführen von Daten

Parallelisierung

Logging / Monitoring

3

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

Apache Camel

Routing Engine

Implementiert in Java

Bietet technische Umsetzung der EIP

Apache License 2.0

Aktuelle Version: 2.14.0

5

Getting Started – Einbindung in Projekt

Core-Bibliothek besteht ausRouting-EngineEinigen 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>

Getting Started - CamelContext

Laufzeitumgebung für Camel-RoutenFührt Registry über

BeansEndpointsDataTypes

Bietet Funktionen an wie:Starten / Stoppen von RoutenHinzufügen von RouteBuildern…

7

CamelContext camelContext = new DefaultCamelContext();

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:\\Temp\import”).to(“file://C:\\Temp\export”); }}

Getting Started – Erste Anwendung

9

public class MyRouteBuilder extends RouteBuilder { public void configure() throws Exception { from(“file://C:\\Temp\import”).to(“file://C:\\Temp\export”); }}

public class MyCamelApplication { public static void main(String[] args) { CamelContext camelContext = new DefaultCamelContext();

camelContext.addRoutes(new MyRouteBuilder());camelContext.start();. . .camelContext.stop();

}}

Routing

Umsetzung der EIP durch Routen

Routen beschreiben den Datenfluss

Bestehen aus Endpoints und Processors

Deklariert mit DSLsJavaXMLScala. . .

10

Endpoint

Beschreibt Schnittstellephysikalische und logische AdresseKommunikationsprotokollWeitere Einstellungen

Wird erzeugt von einer Factory genannt Component

Ansprechen in Route in der Regel über URIf i l e : / / C : \ \ i m p o r t

11

Component

Endpoint Konfiguration

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

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“)

Components - Beispiele

14

JMS

FTP

Mail

Twitter

Facebook

XMPP

JPA

HTTPCXF

Hazelcast

Vert.x

Websocket

Exchange von Messages

Message kapselt ausgetauschte DatenIDHeaderBody (Payload)

Exchange speichert Informationen über den AustauschIn-MessageOut-MessageExceptions

15

Processor

Routingbausteine

Bestimmen Daten-Fluss/Umwandlung zwischen Endpoints

Arbeiten mit dem Exchange-Objekt

Umsetzung von EIPs

Eigene Processors möglich

16

DataFormats

(Un-) Marshalling von DatenJava SerialisierungJAXBCSV. . .

Zusätzliche Formate müssen als Dependency hinzugefügt werden

17

from(endpoint).unmarshall(new JaxbDataFormat()).someProcessing().marshall(new GsonDataFormat()).to(endpoint)

Camel - Überblick

18

Routing-Engine Processors

DataFormats

DSLs (Java,XML,Scala

,…)

CamelContext (Runtime)

Endpoints

ComponentsMail

SMTP

Pop3

File FTP

XML

CSV

JSON

Splitter

Router

Routendefinition

Route

Routing-Elemente - Splitter

Aufteilen einer Message

Splitting der Payload

Produzieren neuer Messages mit Einzeldatensätzen

19

from(endpoint).split(stax(Veranstaltung.class).to(endpoint)

Routing-Elemente - Parallelisierung

Paralleles Weiterverarbeiten von Messages

Angeboten von einigen RoutingbausteinenSplitterMulticast

Auch möglich durch entsprechende Endpoints

20

from(endpoint).split(…).parallelProcessing().executorService(pool).to(endpoint)

Routing-Elemente - Aggregator

Zusammenführen/Sammeln von Messages

Ergebnis der Aggregation wird neue Payload

Zusammenführen nach Inhalt möglich

Sammeln beenden nachZeitintervallAnzahl MessagesWeiteren Bedingungen

21

from(…).aggregate().constant(true).completionTimeout(50000).to(…)

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“)

public Veranstaltung create(Veranstaltung v) {…}

oder

Routing-Elemente - WireTap

Abzweigen von Routen

Original Route unbeeinflusst

Weiterarbeiten auf Kopie der Payload möglich

23

from(…) .wireTap(loggingendpoint).copy().end().to(originaldestination)

In-Memory Endpoints

Erlauben Verknüpfen von Routen

CamelContext internSedadirect

Context übergreifendvmvm-direct

24

from(“direct:import“).split().beanRef(…)…

from(“file://C:\\import“).to(“direct:import“).

from(“ftp://import@server“).to(“direct:import“).

Routing-Elemente - Router

Weiterverteilen von Messages

Inhaltsbasierter RouterFeste Anzahl Regeln/Verzweigungen

Dynamischer RouterDynamische Datenbasis für Routingregeln

25

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();

Typumwandlung

DataFormatFür (De)-serialisieren

TypeConverterUmwandeln der Zugriffsart

(File,byte[],String,InputStream)

Translator (Processor, Bean-Methode)Mapping von Businessobjekten

27

Exception Handling

Try-Catch

Exception Clause

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))

onException(Exception.class).to(endpoint)

Logging

ProblemstellungVielzahl Messages ParallelIn vielen RoutenVerarbeitet von unterschiedlichen Threads

Mapped-Diagnostic-Context (MDC)Speichert Kontextinformationen (routenId, messageId, usw…)Informationen über Pattern in Log-Formatter mitausgegeben

29

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: HawtIOBietet Camel ModulÜbersicht Routen und EndpointsVisualisierung von RoutenDebuggen von Routen

30

Monitoring - hawtio

31

CDI-Integration

Kann als Zusatzmodul eingebunden werdenWenn 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

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

Setup Szenarios

Standalone JavaSE

JavaEE ApplicationserverAls Teil des Deployments (EAR/WAR)Oder als Modul

OSGI-Runtimez. B. Apache KarafErlaubt dynamisches Hinzufügen von Endpoints und Routen

34

Dokumentation

Dokumentation auf Apache-ProjektseiteKonfigurationsmöglichkeiten für EndpunkteVerwendung von RoutingbausteinenViele Code BeispieleDSLsGut geeignet zum Nachschlagen

Bücher

Tutorials

35

Fazit

Mächtig und Flexibel

Leichtgewichtig Dank Modularisierung

Vielzahl DSLsJava-DSL Typsicher mit jeder gängigen IDE

Unterstützt Vielzahl von Deploymentszenarien

Integrationsthematik bedingte KomplexitätEntsprechende Einarbeitungszeit

36