Erste Schritte mit Mule ESB

1. Übersicht

Mule ESB ist ein leichter Java-basierter Enterprise Service Bus. Entwickler können mehrere Anwendungen miteinander verbinden, indem sie Daten in verschiedenen Formaten austauschen. Es trägt Daten in Form einer Nachricht.

ESBs bieten leistungsstarke Funktionen, indem sie eine Reihe von Diensten bereitstellen, z.

  • Serviceerstellung und Hosting
  • Dienstvermittlung
  • Nachrichtenweiterleitung
  • Datentransformation

Wir werden ESBs nützlich finden, wenn wir mehrere Anwendungen zusammen integrieren müssen oder wenn wir den Gedanken haben, in Zukunft weitere Anwendungen hinzuzufügen.

ESB wird auch verwendet, um mit mehr als einer Art von Kommunikationsprotokoll umzugehen und wenn Nachrichtenroutingfunktionen erforderlich sind.

Erstellen wir ein Beispielprojekt in Abschnitt 5 mit AnyPoint Studio, das hier zum Download zur Verfügung steht.

2. Mule-Nachrichtenstruktur

Einfach ausgedrückt besteht der Hauptzweck eines ESB darin, zwischen Diensten zu vermitteln und Nachrichten an verschiedene Endpunkte weiterzuleiten. Es muss also mit verschiedenen Arten von Inhalten oder Nutzdaten umgehen.

Die Nachrichtenstruktur ist in zwei Teile unterteilt:

  • Der Header, derenthält Nachrichtenmetadaten
  • Die Nutzlast, die geschäftsspezifische Daten enthält

Die Nachricht ist in ein Nachrichtenobjekt eingebettet. Wir können das Nachrichtenobjekt aus dem Kontext abrufen. Wir können seine Eigenschaften und Nutzdaten mithilfe von benutzerdefinierten Java-Komponenten und -Transformatoren in einem Mule-Flow ändern.

Jede Anwendung besteht aus einem oder mehreren Flows.

In einem Flow können wir Komponenten verwenden, um auf eine Nachricht und ihre verschiedenen Eigenschaften zuzugreifen, sie zu filtern oder zu ändern.

Zum Beispiel können wir eine Instanz einer Nachricht mit einer Java-Komponente erhalten. Diese Komponentenklasse implementiert eine Callable- Schnittstelle aus dem Paket org.mule.api.lifecycle :

public Object onCall(MuleEventContext eventContext) throws Exception { MuleMessage message = eventContext.getMessage(); message.setPayload("Message payload is changed here."); return message; }

3. Eigenschaften und Variablen

Nachrichtenmetadaten bestehen aus Eigenschaften. Variablen repräsentieren Daten zu einer Nachricht. Wie Eigenschaften und Variablen über den gesamten Lebenszyklus der Nachricht angewendet werden, wird durch ihre Bereiche definiert. Es gibt zwei Arten von Eigenschaften, je nach Umfang: eingehend und ausgehend.

Eingehende Eigenschaften enthalten Metadaten, die verhindern, dass Nachrichten beim Durchlaufen von Flows verschlüsselt werden. Eingehende Eigenschaften sind unveränderlich und können vom Benutzer nicht geändert werden. Sie sind nur für die Dauer des Flusses vorhanden. Sobald die Nachricht den Fluss verlässt, sind eingehende Eigenschaften nicht mehr vorhanden.

Ausgehende Eigenschaften können von Mule automatisch festgelegt werden, oder ein Benutzer kann sie über die Flow-Konfiguration festlegen. Diese Eigenschaften sind veränderlich. Sie werden zu eingehenden Eigenschaften, wenn eine Nachricht nach dem Überqueren von Transportbarrieren in einen anderen Fluss eintritt.

Wir können ausgehende und eingehende Eigenschaften festlegen und abrufen, indem wir die zugehörigen Setter- und Getter-Methoden in ihren jeweiligen Bereichen aufrufen:

message.setProperty( "outboundKey", "outboundpropertyvalue", PropertyScope.OUTBOUND); String inboundProp = (String) message.getInboundProperty("outboundKey");

In Anwendungen können zwei Arten von Variablen deklariert werden.

Eine ist die Flussvariable, die lokal für einen Mule-Fluss ist und über den Fluss, die Unterflüsse und die privaten Flüsse verfügbar ist.

Einmal deklarierte Sitzungsvariablen werden für die gesamte Anwendung verfügbar.

4. Transportbarrieren und Durchflussref

Transportbarrieren sind HTTP-Konnektoren, VMs, JMS oder ähnliche Konnektoren, für die Pfade oder Endpunkte erforderlich sind, damit Nachrichten weitergeleitet werden können. Flussvariablen sind nicht über Transportbarrieren hinweg verfügbar, aber Sitzungsvariablen sind projektübergreifend in allen Flüssen verfügbar.

Wenn wir einen Unterfluss oder einen privaten Fluss erstellen müssen, können wir mithilfe der Komponente flow-ref auf den Fluss von einem übergeordneten oder einem anderen Fluss verweisen . Sowohl Flussvariablen als auch Sitzungsvariablen sind in Unterflüssen und privaten Flüssen verfügbar, auf die mit flow-ref verwiesen wird .

5. Beispielprojekt

Erstellen wir in Anypoint Studio eine Anwendung, die mehrere Flows enthält, die über eingehende und ausgehende Connectors miteinander kommunizieren.

Schauen wir uns den ersten Fluss an:

Wir können einen HTTP-Listener wie folgt konfigurieren:

Durchflusskomponenten müssen sich in a befinden Etikett. Ein Beispiel für einen Ablauf mit mehreren Komponenten lautet also:

Innerhalb des Ablaufs stellen wir einen Verweis auf einen konfigurierten HTTP-Listener bereit. Dann führen wir einen Logger, um die Nutzdaten zu protokollieren, die der HTTP-Listener über die POST-Methode empfängt.

Danach wird eine benutzerdefinierte Java-Transformatorklasse platziert, die die Nutzdaten nach dem Empfang der Nachricht transformiert:

public Object transformMessage( MuleMessage message, String outputEncoding) throws TransformerException { message.setPayload("Payload is transferred here."); message.setProperty( "outboundKey", "outboundpropertyvalue", PropertyScope.OUTBOUND); return message; }

Die Transformatorklasse muss AbstractMessageTransformer erweitern . Wir legen auch eine ausgehende Eigenschaft innerhalb der Klasse fest.

Jetzt haben wir die Nutzdaten bereits in das Nachrichtenobjekt konvertiert und diese mit dem Logger in der Konsole protokolliert. Wir legen eine Flussvariable und eine Sitzungsvariable fest.

Finally, we are sending our payload through outbound VM connector. The path in VM connector determines the receiving endpoint:

The message carried and transformed by the initial flow reaches Flow1 through an inbound VM endpoint.

The Java component retrieves outbound properties set by the first flow and returns the object which becomes the message payload.

The transformMessage() method for this task:

public Object transformMessage( MuleMessage message, String outputEncoding) throws TransformerException { return (String) message.getInboundProperty("outboundKey"); }

Then, flow and session variables are set to the second flow. After that, we've got a reference to Flow2 using flow-ref component.

In Flow2, we've transformed the message using Java component class and logged it in the console. We've also set a flow variable F3.

After calling Flow2 using flow-ref, Flow1 will wait for the message to be processed in Flow2.

Any flow variable set in Flow1 and Flow2 will be available in both flows since these flows aren't separated by any transport barriers.

Finally, the message is sent back to the HTTP requester through VMs. We configured all VMs as request-response.

We can invoke this application from any REST client by posting any JSON data in the body. The URL will be localhost:8081 as configured in HTTP listener.

6. Maven Archetype

We can build a Mule ESB project using Mulesoft's Maven archetype.

In Maven's settings.xml file, we first need to add the org.mule.tools plugin group:

 org.mule.tools 

Then, we need to add a profile tag that says where Maven should look for Mulesoft artifacts:

 Mule Org  true    mulesoft-releases MuleSoft Repository //repository-master.mulesoft.org/releases/ default   

Finally, we can create the project using mule-project-archetype:create:

mvn mule-project-archetype:create -DartifactId=muleesb -DmuleVersion=3.9.0

After configuring our project, we can create a deployable archive using mvn package.

After that, we'd deploy the archive into the apps folder of any standalone Mule server.

7. A Standalone Mule Server via MuleSoft's Maven Repository

As just noted, the project we just created requires a standalone Mule server.

If we don't already have one, we can edit our pom.xml to pull one from MuleSoft's Maven repository:

 org.mule.tools.maven mule-maven-plugin 2.2.1  standalone 3.9.0    deploy deploy  deploy    

8. Conclusion

In this article, we've gone through different necessary concepts of building as ESB application in Mule. We've created a sample project illustrating all the described concepts.

We can now start creating ESB application using Anypoint Studio to meet our various needs.

As usual, the complete project can be found over on GitHub.

1. Overview

Mule ESB is a lightweight Java-based Enterprise Service Bus. It allows developers to connect multiple applications together by exchanging data in different formats. It carries data in the form of a message.

ESBs offer powerful capabilities by providing a number of services, such as:

  • Service creation and hosting
  • Service mediation
  • Message routing
  • Data transformation

We'll find ESBs useful if we need to integrate multiple applications together, or if we have the notion of adding more applications in the future.

ESB is also used for dealing with more than one type of communication protocol and when message routing capabilities are required.

Let's create a sample project in Section 5 using AnyPoint Studio which is available for download here.

2. Mule Message Structure

Simply put, the primary purpose of an ESB is to mediate between services and route messages to various endpoints. So it needs to deal with different types of content or payload.

The message structure is divided into two parts:

  • The header, whichcontains message metadata
  • The payload, which contains business-specific data

The message is embedded within a message object. We can retrieve the message object from the context. We can change its properties and payload using custom Java components and transformers inside a Mule flow.

Each application consists of one or more flows.

In a flow, we can use components to access, filter or alter a message and its different properties.

For example, we can obtain an instance of a message using Java component. This component class implements a Callable interface from org.mule.api.lifecycle package:

public Object onCall(MuleEventContext eventContext) throws Exception { MuleMessage message = eventContext.getMessage(); message.setPayload("Message payload is changed here."); return message; }

3. Properties and Variables

Message metadata consists of properties. Variables represent data about a message. How properties and variables are applied across the message's life-cycle is defined by their scopes. Properties can be of two types, based on their scope: inbound and outbound.

Inbound properties contain metadata that prevents messages to become scrambled while traversing across flows. Inbound properties are immutable and cannot be altered by the user. They're present only for the duration of the flow – once the message exits the flow, inbound properties are no longer there.

Outbound properties can be set automatically by Mule, or a user can set them through flow configuration. These properties are mutable. They become inbound properties when a message enters another flow after crossing transport-barriers.

We can set and get outbound and inbound properties respectively by calling associated setter and getter methods in their respective scopes:

message.setProperty( "outboundKey", "outboundpropertyvalue", PropertyScope.OUTBOUND); String inboundProp = (String) message.getInboundProperty("outboundKey");

There are two types of variables available to declare in applications.

One is flow variable which is local to a Mule flow and available across the flow, sub-flows and private flows.

Session variables once declared become available across the entire application.

4. Transport Barriers and flow-ref

Transport barriers are HTTP-connectors, VMs, JMS or similar connectors that require paths or endpoints for messages to be routed. Flow variables aren't available across transport barriers, but session variables are available across the project in all flows.

When we need to create sub-flow or private flow, we can refer to the flow from a parent or another flow using flow-ref component. Both flow variables and session variables are available in sub-flows and private flows referred to using flow-ref.

5. Example Project

Let's create an application in Anypoint Studio that contains multiple flows, which communicate between themselves through inbound and outbound connectors.

Let's look at the first flow:

We can configure an HTTP listener as:

Flow components must be inside a tag. So, an example flow with multiple components is:

Inside the flow, we're providing a reference to a configured HTTP listener. Then we're keeping a logger to log the payload that HTTP listener is receiving through POST method.

After that, a custom Java transformer class is placed, that transforms the payload after receiving the message:

public Object transformMessage( MuleMessage message, String outputEncoding) throws TransformerException { message.setPayload("Payload is transferred here."); message.setProperty( "outboundKey", "outboundpropertyvalue", PropertyScope.OUTBOUND); return message; }

The transformer class must extend AbstractMessageTransformer. We're also setting an outbound property inside the class.

Now, we have already converted payload inside the message object, and have logged that in the console using logger. We're setting a flow variable and a session variable.

Finally, we are sending our payload through outbound VM connector. The path in VM connector determines the receiving endpoint:

The message carried and transformed by the initial flow reaches Flow1 through an inbound VM endpoint.

The Java component retrieves outbound properties set by the first flow and returns the object which becomes the message payload.

The transformMessage() method for this task:

public Object transformMessage( MuleMessage message, String outputEncoding) throws TransformerException { return (String) message.getInboundProperty("outboundKey"); }

Then, flow and session variables are set to the second flow. After that, we've got a reference to Flow2 using flow-ref component.

In Flow2, we've transformed the message using Java component class and logged it in the console. We've also set a flow variable F3.

After calling Flow2 using flow-ref, Flow1 will wait for the message to be processed in Flow2.

Any flow variable set in Flow1 and Flow2 will be available in both flows since these flows aren't separated by any transport barriers.

Finally, the message is sent back to the HTTP requester through VMs. We configured all VMs as request-response.

We can invoke this application from any REST client by posting any JSON data in the body. The URL will be localhost:8081 as configured in HTTP listener.

6. Maven Archetype

We can build a Mule ESB project using Mulesoft's Maven archetype.

In Maven's settings.xml file, we first need to add the org.mule.tools plugin group:

 org.mule.tools 

Then, we need to add a profile tag that says where Maven should look for Mulesoft artifacts:

 Mule Org  true    mulesoft-releases MuleSoft Repository //repository-master.mulesoft.org/releases/ default   

Finally, we can create the project using mule-project-archetype:create:

mvn mule-project-archetype:create -DartifactId=muleesb -DmuleVersion=3.9.0

After configuring our project, we can create a deployable archive using mvn package.

After that, we'd deploy the archive into the apps folder of any standalone Mule server.

7. A Standalone Mule Server via MuleSoft's Maven Repository

As just noted, the project we just created requires a standalone Mule server.

Wenn wir noch keine haben, können wir unsere pom.xml bearbeiten , um eine aus dem MavenSoft-Maven-Repository abzurufen:

 org.mule.tools.maven mule-maven-plugin 2.2.1  standalone 3.9.0    deploy deploy  deploy    

8. Fazit

In diesem Artikel haben wir verschiedene notwendige Konzepte zum Erstellen als ESB-Anwendung in Mule durchgearbeitet. Wir haben ein Beispielprojekt erstellt, das alle beschriebenen Konzepte veranschaulicht.

Wir können jetzt mit der Erstellung einer ESB-Anwendung mit Anypoint Studio beginnen, um unsere verschiedenen Anforderungen zu erfüllen.

Das komplette Projekt finden Sie wie gewohnt auf GitHub.