Apache Camel ist ein sehr beliebtes Open Source Framework, um Anwendungsintegration in Java zu standardisieren. Es lässt sich leicht mit Spring Boot nutzen und unterstützt neben den Enterprise Integration Patterns viele Kommunikationsprotokolle und Technologien. In diesem Artikel geben wir eine Einführung in Apache Camel und zeigen anhand eines Codebeispiels die Mächtigkeit des Frameworks.

Für einen erfolgreichen Geschäftsbetrieb ist es wichtig, dass Anwendungen untereinander kommunizieren können. Was einfach klingt, stellt sich in heterogenen Systemlandschaften als eine echte Herausforderung dar. Unterschiedliche Anwendungen haben unterschiedliche Schnittstellen, Protokolle und Technologien. Sie erschweren die Integration. Was heute state-of-the-art ist, kann morgen veraltet sein.

Auf konzeptioneller Ebene stellt man fest, dass viele Integrationsprobleme wiederkehrend sind. Mit den Enterprise Integration Patterns (EIPs) [1] haben Gregor Hohpe und Bobby Woolf einen Katalog aus 65 Integrationsmustern zusammengestellt. Sie ermöglichen eine standardisierte Integration mit einem einheitlichen Vokabular. Genau auf diesem Fundament setzt Apache Camel [2] auf. Es ist ein beliebtes Integrationsframework, das Open Source ist und sich leicht in Java, Spring Boot, Quarkus, Scala und Groovy integrieren lässt. Das Framework implementiert die EIPs und unterstützt eine Vielzahl an Datenformaten, Kommunikationsprotokollen, SaaS- und Cloud Providern, wie z.B.  HTTP, SFTP, SCP, JMS, XML, LDAP, Confluence, GitHub, Azure, SNS, S3, Kinesis, Kafka, Kubernetes oder Docker.

Unsere Erfahrung zeigt, dass vielen Entwicklern EIPs und Camel nicht bekannt sind. Wir wollen mit diesem Artikel Apache Camel ein Stück weit näherbringen, damit nicht jedes Softwareprojekt für typische Integrationsaufgaben das Rad neu erfinden muss.

Apache Camel besteht im Wesentlichen aus Komponenten, Prozessoren und einer Routing Engine, siehe Abbildung 1. Mit der Routing Engine definieren Entwickler über eine domänen-spezifische Sprache (DSL) Routen, die Endpunkte miteinander verbinden. Endpunkte senden oder empfangen Nachrichten. Zwischen den Endpunkten einer Route können Prozessoren geschaltet werden. Diese dienen der Nachrichtentransformation oder Nachrichtenmediation. Um das besser zu verstehen, schauen wir uns ein Routing-Beispiel an.

public class MyRouteBuilder extends RouteBuilder {

  public void configure() {

    from("file:inbox/submissions?noop=true?includeExt=xml")

      .process(exchange -> {

         File f = exchange.getIn().getBody(File.class)

         /* Mit Prozessoren können Nachrichten transformiert und

          * angereichert werden, z.B. XML -> Java Objekt,

          * ANSI -> UTF8, XML um AddressBookUID anreichern/ergänzen

          */

      })

      .choice()

        .when(xpath("/PolicyHolder/Address/Country != DE"))

          .to("aws2-s3://myBucket?useDefaultCredentialsProvider=true")

        .otherwise()

          .to("ftp://server.local?username=a&password=b");

  }

}

Listing 2: Definition eines Content-Based-Routers in Camel mit dem RouteBuilder

Die Integrationsaufgabe in Listing 1 besteht darin, Neuanträge von Policen zu verarbeiten, die im Ordner inbox/submissions als XML-Dateien abgelegt sind. Wohnt der Versicherungsnehmer im Ausland, soll der Antrag in ein S3 Bucket kopiert werden, andernfalls dient ein FTP-Server als Zielort. Das Routing konsumiert dazu den File-Endpunkt inbox/submissions. Die noop Option weist Camel an, die Dateien unangetastet zu lassen. Ohne die Option löscht Camel die Dateien nach der Verarbeitung. Über den choice-when Syntax implementieren wir einen Content-Based-Router. Hierbei handelt es sich um ein EIP, dass abhängig vom Inhalt, die Daten zu unterschiedlichen Endpunkten routet.

In Camel ist jeder Endpunkt durch eine eindeutige URI definiert. Die URI bestimmt und konfiguriert die Camel Komponente. Unser Beispiel konsumiert die File-Komponente und erzeugt mit der FTP- und AWS2-S3-Komponente die Dateien am Zielort. Neben 27 Kernkomponenten gibt es aktuell über 325 Zusatzkomponenten, die vom Apache-Projekt gepflegt und gut dokumentiert werden [4]. Damit sollten sich die meisten Integrationsaufgaben vereinfachen lassen.

1. Durch den hohen Abstraktionsgrad und der domänenspezifischen Sprache ist es möglich unterschiedliche Fremdsysteme mit einem gemeinsamen Programmiermodell zu integrieren. Dank der umfangreichen Komponentensammlung brauchen sich Entwickler meist kein Detailwissen zu den Protokollen und Datenaustauschformaten aneignen. Bei der Integrationsaufgabe in Listing 1 entfällt die Einarbeitung in das AWS-SDK und in eine FTP-Library. Die Entwickler können sich auf das Wesentliche, die Fachlogik, konzentrieren und die Codebasis schlank halten.
2. Seit der ersten Version von Camel gibt es mit dem Test Kit umfangreiche Möglichkeiten seine Routen mit JUnit zu verifizieren. Ist ein Fremdsystem während der Entwicklung nicht verfügbar oder möchte man eine gewisse Fehlersituation nachstellen, kann sein Endpunkt einfach durch einen Mock ersetzt werden – Mockito [5] und andere Mocking-Framworks werden nicht vorausgesetzt.
3. Camel hat viele Komponenten, um sich mit SaaS Providern zu verbinden, z.B. Amazon AWS, Microsoft Azure, Braintree (z.B. PayPal, Apple, Android Pay), Dropbox, FaceBook, GitHub, Google Cloud, Salesforce, Jira, Confluence, Twitter und viele mehr.
4. Die Codebasis von Camel ist modular aufgebaut. Entwickler geben in Maven oder Gradle an, welche Komponenten sie verwenden wollen.
5. Camel ermöglicht die Entwicklung eigener Komponenten [6]. Gerade hier sehen wir Potential für Unternehmen. Beispielsweise könnte man eine Komponente für Bug-Tickets schreiben, die das Anlegen von Incidents über eine URI-Syntax unterstützt. Andere Unternehmensanwendungen können diese Komponente einbinden, um z.B. bei Problemen Bug-Tickets erzeugen. Wie das Bug-Ticket-System technisch unter der Haube funktioniert, wird von der Komponente gekapselt und braucht den Nutzer der Komponente nicht zu interessieren.

Wir finden, dass Camel zurecht als eine Art „Schweizer Taschenmesser“ für Integrationsaufgaben bezeichnet werden darf und hoffen bei dem einen oder anderen Leser Interesse geweckt zu haben. Das Hauptziel von Camel ist die Integration zu vereinfachen. Das gelingt dem Framework durch den hohen Abstraktionsgrad, der domänenspezifischen Sprache und der EIP Unterstützung. Sie sorgen für eine gewisse Standardisierung. Dank der Komponenten werden die technischen Details von Kommunikationsprotokollen, Schnittstellen und APIs gekapselt, so dass sich Entwickler auf die Fachlogik der Integrationsaufgabe konzentrieren können.

[1] Enterprise Integrations Patterns, Gregor Hohpe & Bobby Woolf, 2004, Addison-Wesley,
ISBN-13:  978-0-321-20068-6

[2] Apache Camel Webseite, https://camel.apache.org

[3] Camel in Action 2^nd Edition, Claus Insen & Jonathan Anstey, 2018, Manning
ISBN: 978-1-61729-293-4

[4] Camel 3.13 Components Overview, https://camel.apache.org/components/3.13.x/

[5] Mockito Mocking Framework, https://site.mockito.org/

[6] Writing Camel Components, https://camel.apache.org/manual/writing-components.html