Workflow Automatisierung via Apache Camel

In den meisten Projekten erreicht man irgendwann den Punkt, bei dem es notwendig sein wird teilweise komplexe und immer wiederkehrende Arbeitsabläufe zu automatisieren. Dazu zählen z.B. Datenimports oder das Erstellen von monatlichen Auswertungen.  In der Softwareentwicklung sind solche Aufgaben meist mit hohem Entwicklungsaufwand verbunden, um Schnittstellen zu den unterschiedlichsten Systemen (wie z. B. diverse Datenbanken oder File-Server) zu implementieren. Entwickler von Apache Camel haben sich genau diesen Overhead zur Aufgabe gemacht.

Was ist Apache Camel

Apache Camel ist ein leistungsstarkes und sehr vielfältiges Integrations-Framework, welches die meisten bekannten Enterprise Integration Patterns (EIP) abbildet. Dabei beziehen sich die Entwickler auf das Buch Enterprise Integration Patterns: Designing, Building, and Deploying Messaging Solutions von Gregor Hohpe und Bobby Woolf.

Was ist EIP überhaupt?

Moderne Anwendungen werden immer mehr Teil eines komplexen Ökosystems von Systemen, welche ständig untereinander kommunizieren und Daten austauschen. Der Datenaustausch wird meist dadurch erschwert, dass die Systeme des Ökosystems meist unterschiedliche Sprachen sprechen. Genau hier setzen die EIP an. Hinter den Enterprise Integration Patterns verbirgt sich ein "Kochbuch" mit ungefähr 65 Rezepten, welche die Kommunikation von Systemen beschreiben.

Weitere Informationen unter:

• http://www.enterpriseintegrationpatterns.com/
• http://camel.apache.org/enterprise-integration-patterns.html

Konfiguration

Apache Camel verwendet unter Java, zum Definieren von Routen und EIP ( Enterprise Integration Patterns) die DSL (Domain Specific Language). Welche DSL's in Camel unterstützt werden kann unter folgendem Link nachgelesen werden http://camel.apache.org/dsl.html. Wir bevorzugen die Java DSL Schreibweise in Verbindung mit der Spring Annotation. Als Vorteil dieser Kombination sehen wir klar den übersichtlichen und strukturellen Aufbau des Projektes.

CamelContext:

Der CamelContext ist das Herz einer Camel-Applikation. Der Kontext enthält Informationen über die Anwendung z.B. welche Routen vorhanden sind, welche Konfigurationen wurden für welchen Endpoint hinterlegt (z.B. ActiveMQ, Twitter API Token) oder den aktuellen Status des Kontexts.

Routen

Routen werden dazu verwendet den Workflow zu definieren, welcher über den CamelContext der Route gesteuert werden kann (start, stop).

Aufsetzen von Apache Camel und Spring

In diesem Abschnitt zeigen wir auf, wie ein Apache Camel-Projekt in Verbindung mit Spring aufgesetzt wird. Als IDE verwenden wir in diesem Beispiel IntelliJ IDEA. Als Build-Management-Tool setzen wir Maven ein, um die Abhängigkeiten und Buildtools zu verwalten. Die Anwendung wird recht einfach gehalten und wird jede Sekunde die aktuelle Uhrzeit in die Konsole loggen. Bevor wir mit der Minimalanwendung beginnen können benötigen wir die Camel- und Spring-Packages.

Hier ein Auszug aus der pom.xml:

<dependencies>
    <dependency>
        <groupId>org.apache.camel</groupId>
        <artifactId>camel-core</artifactId>
        <version>2.17.1</version>
    </dependency>
    <dependency>
        <groupId>org.apache.camel</groupId>
        <artifactId>camel-spring-javaconfig</artifactId>
        <version>2.17.1</version>
    </dependency>
</dependencies> <build>
<plugins>
    <plugin>
        <groupId>org.apache.camel</groupId>
        <artifactId>camel-maven-plugin</artifactId>
        <version>2.17.1</version>
        <configuration>
            <basedPackages>de.avocado</basedPackages>
        </configuration>
    </plugin>
    <plugin>
        <groupId>org.apache.maven.plugins</groupId>
        <artifactId>maven-compiler-plugin</artifactId>
        <configuration>
            <source>1.8</source>
            <target>1.8</target>
        </configuration>
    </plugin>
</plugins>
</build>

Wie in jeder Java-Applikation benötigen wir eine Klasse mit einer main(...) Methode als Einstiegspunkt, in der zunächst einmal der Spring-Context initialisiert wird.

import org.apache.camel.spring.javaconfig.Main; 

public class Application{ 
    public static void main(String[] args) throws Exception { 
        new Main().run(args); 
    } 
}

Bevor wir den CamelContext verwenden können, muss dieser zunächst initialisiert werden. Dazu müssen wir von der Klasse CamelConfiguration erben und die Klasse mit der Spring Annotation @Configuration versehen.

@Configuration 
public class CamelConfig extends CamelConfiguration {}

Die @Configuration Annotation besagt, dass es sich um eine Konfigurationsklasse handelt. Diese Klasse wird bei der Initialisierung des Kontextes ausgeführt, um z.B. Verbindungseinstellungen aus Konfigurationsdateien zu laden. In unserem Fall ist die Standardkonfiguration der Klasse CamelConfiguration ausreichend, daher muss auch nichts angepasst werden.

Um die Basiskonfiguration von Apache Camel zu testen fehlt uns jetzt nur noch eine Route, die z.B. jede Sekunde die Uhrzeit in die Konsole schreibt.

@Component 
public class TestRoute extends RouteBuilder{ 
    @Override 
    public void configure() throws Exception{ 
        from("timer://foo?fixedRate=true&period=1000")
        .process(exchange -> { 
             System.out.println("Aktuelle Uhrzeit: " + 
                 LocalTime.now()); 
          }); 
      } 
}

Damit der CamelContext unsere Route finden kann muss folgendes beachtet werden:

• Die Klasse muss als Komponente (@Component) deklariert sein, damit sie von Spring initialisiert werden kann.
• Die Klasse muss vom RouteBuilder abgeleitet sein, damit der CamelContext diese verarbeiten kann.

Abschließend benötigen wir noch das ‘camel-maven-plugin’. In dessen Konfiguration geben wir das Root-Verzeichnis unseres Projektes an und überlassen Spring und Camel den Rest.

// Ausführung der Anwendung: 
mvn camel:run

// Ausgabe in der Konsole: 
…
Aktuelle Uhrzeit: 15:31:03.851 
Aktuelle Uhrzeit: 15:31:04.793 
...