JBoss Fuse - Kurzanleitung

In diesem Kapitel beginnen wir mit den Grundlagen von Enterprise Service Bus. Im Folgenden finden Sie eine ausführliche Erläuterung zu ESB mit seinen Vor- und Nachteilen sowie einige Diagramme zum leichteren Verständnis.

Was ist ESB?

ESB steht für Enterprise Service Bus. ESB ist in seiner einfachsten Form eine Middleware, die als Informationsautobahn fungiert und die Kommunikation mehrerer Anwendungen unterstützt.

In der Unternehmenswelt entwickeln wir Lösungen für viele Dinge. Diese Lösungen können unterschiedliche Technologien und Datenformate verwenden. Die gemeinsame Verwendung dieser Lösungen wird aufgrund der Kompatibilitätsabweichung der Kommunikation oder des Datenformats in diesen Technologien umständlich. Deshalb brauchen wir eine Technologie, die es ermöglichtloosely coupled integration zwischen diesen verschiedenen Lösungen.

ESB zielt darauf ab, dieses Integrationsproblem zu vereinfachen, indem es zu einem "HUB" wird, der sich in der Mitte all Ihrer Anwendungen befindet und das Weiterleiten von Nachrichten zwischen ihnen erleichtert. ESB fungiert als Vermittler, fungiert als Informationsautobahn, kümmert sich um das Routing der Datentransformation und überlässt es dem Codierer oder dem Entwickler, sich auf seine eigene Anwendungslogik zu konzentrieren.

Das Verständnis von ESB wird sehr einfach, wenn wir das Problem verstehen, für das es speziell entwickelt wurde, und die Lösung einfach wird. Man sollte ein klares Verständnis dafür haben, wie man viele unterschiedliche Systeme ermöglicht, die in verschiedenen Sprachen geschrieben sind und auf verschiedenen Computern mit unterschiedlichen Datenformaten ausgeführt werden, um Informationen auszutauschen und eine integrierte Geschäftsplattform zu bilden.

Das Integrationsproblem

Auf der Unternehmensplattform arbeiten häufig mehrere Anwendungen zusammen und stellen Geschäftsfunktionen als Ganzes bereit. Die Integration dieser Anwendungen ist jedoch das häufigste Problem. Mit der Zeit wird es sogar schwierig, wenn die Anwendungen wachsen.

Jede Anwendung kann Daten in ihrem eigenen Format eingeben und ausgeben. Dieser Ansatz funktioniert gut, wenn die Anzahl der Anwendungen geringer ist. Mit zunehmender Anzahl der Anwendungen müssen jedoch auch die Integrationsräder mit einem besseren Ansatz umgestellt werden. Wenn beispielsweise eine bestimmte Anwendung für ein Unternehmen geändert werden muss, ist das Ausgabe- oder Eingabedatenformat für alle Anwendungen, die von dieser Master-Anwendung abhängig sind, betroffen.

Ein solcher Ansatz ist die größte Hürde für die Integration, die eine eng gekoppelte Architektur erwartet. Hier kommt ESB ins Spiel. Jede Anwendung muss nicht direkt mit einer anderen Anwendung kommunizieren. Stattdessen kommunizieren alle Anwendungen mit dem ESB und der ESB übernimmt das Routing von Informationen und die Konvertierung des internen Datenformats.

Warum ESB?

Im Folgenden finden Sie einige Punkte, die erklären, warum Enterprise Service Bus unerlässlich ist.

ESB soll das Problem der Integration in variantenkompatible Anwendungen vereinfachen.
Es fungiert als Middleware, die als Vermittler aller Ihrer Anwendungen dient und das Weiterleiten von Nachrichten zwischen ihnen erleichtert.
Anstatt dass jede Anwendung direkt mit jeder anderen Anwendung verbunden ist, verfügt jede Anwendung nur noch über eine Schnittstelle zum ESB.
Der ESB ist dafür verantwortlich, Nachrichten in ein / aus einem gemeinsamen Format zu übersetzen und an ihre Ziele weiterzuleiten.
Die größte Einsparung bei diesem Ansatz ist ein Segen, wenn Sie eine Ihrer vorhandenen Anwendungen ersetzen müssen. Anstatt eine ganze Reihe neuer Schnittstellen zu schreiben, müssen Sie sich nur noch um eine Schnittstelle kümmern (zwischen Ihrer Anwendung und dem ESB).

SOA & ESB?

SOA und ESB werden üblicherweise synonym verwendet, sind jedoch völlig unterschiedlich.

SOA ist ein Entwurfsmuster, mit dem die Anwendung ihre Funktionen als Dienst über das Netzwerk über Kommunikationsprotokolle verfügbar machen kann, während ESB ein Modell ist, das die Kommunikation zwischen unterschiedlichen Systemen erleichtert. ESB kann jedoch als Backbone bei der Implementierung von SOA verwendet werden.

JBoss Fuse ist eine Open Source ESB-Lösung von Redhat. Es handelt sich um eine Unternehmenslösung, die auf dem Community-Projekt Apache Servicemix basiert.

Integration in die Sicherung

JBoss Fuse ist eine leichte und flexible Integrationsplattform, die eine schnelle Integration von Unternehmensanwendungen ermöglicht.

Fuse wurde ursprünglich von Progressive Software Inc. entwickelt, die 2012 von Redhat übernommen wurde. JBoss Fuse 6.1.0.redhat-379 GA ist eine stabile Version von Fuse, die von der offiziellen Website heruntergeladen werden kann.

Die Architektur

Fuse kombiniert verschiedene Technologien zu einem einzigen Produkt.

Komponenten

Apache CXF

Apache CXF ist ein Open Source-Framework für die Entwicklung von Webdiensten, das auch die Entwicklung von SOAP & Rest-Webdiensten unterstützt.

Apache Kamel

Apache Camel ist ein EIP-basiertes Integrationsframework. EIP- oder Enterprise-Integrationsmuster sind identifizierte Lösungen für die wiederkehrenden Probleme bei der Enterprise-Integration. Eine vollständige Integrationslösung kann meteorisch mit Kombinationen dieser vordefinierten Standardmuster erreicht werden.

Es ermöglicht das Schreiben von Routing-Logik in mehreren domänenspezifischen Sprachen wie Java, Spring DSL und Scala usw.

Apache AMQ

Apache AMQ ist ein JMS, das ein zuverlässiges Messaging-System gemäß JMS-Standards bietet. Es unterstützt nicht nur die JMS-Spezifikation, sondern bietet auch einige aufregende und nützliche Funktionen, die nicht in den JMS-Spezifikationen enthalten sind.

Apache Karaf

Apache Karaf ist ein leichter OSGi-Container, der als Laufzeit für die Artefakte dient. Apache Karaf ist im Vergleich zu JVM dynamischer. Es ermöglicht die Installation oder Deinstallation von Modulen zur Laufzeit. Alle Artefakte in Fuse werden in Karaf eingesetzt.

Stoff

Fabric bietet eine einfache Möglichkeit, die Bereitstellung von Artefakten in einer großen und verteilten Umgebung zu verwalten. Es bietet eine zentralisierte Verwaltung für alle Instanzen mit mehreren Sicherungen.

Sicherung installieren

Die Installation von Fuse ist recht einfach. Wie andere JBoss-Produkte wird Fuse als Zip-Datei geliefert, die extrahiert und nach einigen geringfügigen Konfigurationsänderungen direkt gestartet werden kann.

Die Installation der Sicherung erfolgt in vier Schritten.

Herunterladen

Laden Sie Fuse 6.1.0 GA über den folgenden Link herunter. http://www.jboss.org/

Entpacken

Wie alle anderen JBoss-Produkte ist auch Fuse ein plattformunabhängiger Reißverschluss.

Entpacken Sie die heruntergeladene Datei in das Zielverzeichnis, das Sie als Fuse-Installationsverzeichnis verwenden möchten. Wählen Sie dieses Verzeichnis mit Bedacht aus, da dies über die Lebensdauer der Fuse-Instanz gleich bleiben sollte.

Note - Obwohl Fuse wie andere JBoss-Produkte entpackt und gestartet wird, wird nicht empfohlen, die Fuse-Installation nach Abschluss der Installation von einem Ort an einen anderen zu verschieben.

Konfigurieren

Nachdem Sie Fuse entpackt haben, finden Sie die folgenden Verzeichnisse im extrahierten Verzeichnis:

bin
etc
deploy
lib
licenses
extras
quickstarts

Von denen werden wir nur zwei Verzeichnisse verwenden bin & etc.

Praktisch nach dem Extrahieren von Fuse sollten wir in der Lage sein, die Sicherung direkt zu starten. Dadurch wird Fuse jedoch mit allen Standardkonfigurationen gestartet, was für die Produktionsumgebung nicht ratsam ist. Es wird dringend empfohlen, vor dem Starten von Fuse die folgenden Änderungen vorzunehmen.

Umgebungsvariablen festlegen

Legen Sie die folgenden Umgebungsvariablen fest: JAVA_HOME
Die Variable sollte auf das Java-Installationsverzeichnis verweisen - M2_HOME
Die Variable sollte auf das Maven-Installationsverzeichnis verweisen - PATH
Stellen Sie die Pfadvariable so ein, dass sie ausführbare Java & Maven-Dateien enthält.

Windows

Unter Windows können Einstellungen vorgenommen werden, indem die folgenden Anweisungen befolgt werden:

Start → Arbeitsplatz → Rechtsklick → Eigenschaften → Erweiterte Systemeinstellungen → Umgebungsvariablen.

UNIX & Klone

Für jeden Benutzer gibt es ein Bash-Profil in der *nixBetriebssysteme. Wir können die vorhandene Systemvariable hinzufügen oder bearbeiten, indem wir diese Datei ändern.

$ vi ~/.bash_proflle

Note- Alle Änderungen in dieser Datei sind dauerhaft. Es wird dringend empfohlen, vor dem Ändern des Originals eine Sicherungskopie der vorhandenen Datei zu erstellen.

Basiseinstellung

Wir werden über die Grundkonfiguration von JBoss Fuse diskutieren und dafür müssen wir mit dem folgenden Befehl beginnen Edit $FUSE_INSTALLATION_DIR/etc/

Im user.properties

#admin=admin,admin
Dies muss entsprechend dem ersten Administrator mit dem gewünschten Benutzernamen, dem zweiten Administrator mit dem Kennwort und dem dritten Administrator geändert werden, da dies auf eine Rolle hinweist und nicht vergessen wird, # zu entfernen
Zum Beispiel - FuseAdmin = FusePAss, admin

Im System.properties
- karafName = root
  - Dies gibt den Namen an, den Sie der Karaf-Instanz geben möchten.
  - Wir können es wie Cont1 nennen.
  - Stellen Sie sicher, dass dieser Name ein eindeutiger Name ist und nicht bereits von einer anderen Instanz von Fuse verwendet wird.
Im org.ops4j.pax.web.cfg
- Org.osgi.service.http.port = 8181
- Diese Eigenschaft gibt den Port an, der für den Zugriff auf die von Fuse bereitgestellte browserbasierte Schnittstelle HAWTIO verwendet werden soll
- HAWTIO ist eine integrierte Browser-Oberfläche für Fuse, die ab 6.0 verfügbar ist
Im org.ops4j.pax.url.mvn.cfg
- org.ops4j.pax.url.mvn.localRepository = D: / repository
- Diese Eigenschaft gibt den Pfad zum lokalen Archiv unseres Maven an, von dem aus Fuse seine Artefakte installiert.
- org.ops4j.pax.url.mvn.settings = D: /Maven/conf/settings.xml
- Diese Eigenschaft gibt settings.xml an, mit der Fuse Artefakte von Maven abrufen soll.

Maven konfigurieren

Maven ist eine Voraussetzung für die Installation von Fuse. Wenn Sie nicht wissen, was Maven ist, beziehen Sie sich bitte aufhttp://www.tutorialspoint.com/maven/

Maven ist ein erstelltes Tool zum Erstellen von Sicherungsartefakten. Fuse sucht zuerst im lokalen Maven-Repository nach Artefakten, wenn der Befehl zum Installieren von Artefakten ausgegeben wird. Wir müssen Fuse also mitteilen, wo Maven installiert ist und welchen Pfad das lokale Repository von Maven hat.

Bearbeiten Sie $ FUSE_INSTALLATION_DIR / etc /org.ops4j.paxurl.mvn.cfg

Aktualisieren Sie die folgenden zwei Eigenschaften:

org.ops4j.pax.url.mvn.settings = $ M2_HOME / conf /settings.xml
org.ops4j.pax.url.mvn.localRepository = $ local_repo

Note - Bitte ändern $local_repo mit dem tatsächlichen Pfad Ihres lokalen Repositorys, der in Mavens settings.xml angegeben ist.

Lauf

Nach grundlegenden Konfigurationsänderungen können wir nun Fuse starten. Alle Binärdateien für die Arbeit mit Fuse befinden sich in$FUSE_INSTALLATION_DIR.

Es gibt zwei Möglichkeiten, um Fuse zu starten:

Verwenden von ./fuse
- Auf diese Weise können Sie alle Fortschritte und Protokolle in demselben Fenster anzeigen, in dem Sie Fuse gestartet haben.
- Sie erhalten eine Karaf-Konsole im selben Terminal wie unten gezeigt.

Note- Dadurch wird die Sicherung im Konsolenmodus gestartet. Dies bedeutet, dass der Sicherungsprozess auch gestoppt wird, wenn sich der Benutzer von der Sitzung abmeldet oder das Terminal schließt, was im Produktions- oder Entwicklungsszenario nicht wünschenswert ist. Dieses Skript sollte nur zum Debuggen von Fuse verwendet werden.

Verwenden von ./start
- Dies zeigt keine Protokolle auf dem Bildschirm an, nicht einmal den Fortschritt, aber dies startet die Sicherung im Hintergrund und der Sicherungsdienst wird nicht gestoppt, wenn der Benutzer die Sitzung beendet oder das Terminal schließt.
- In der realen Anwendung ist diese Art von Verhalten erwünscht. Die Sicherung sollte im Hintergrund laufen, auch wenn wir das Terminal schließen.
- Wenn Sie eine Verbindung zu Fuse herstellen möchten, die im Hintergrund ausgeführt wird, können Sie verwenden client Skript, das sich im selben Ordner befindet.
- Sie sollten die Anzeige wie im folgenden Screenshot gezeigt erhalten.
- Durch das Beenden des Client-Skripts wird der Sicherungsdienst nicht gestoppt. Es wird nur die Sicherungskonsole geschlossen.

HAWTIO

Fuse bietet auch einen vollständigen GUI-Zugriff über FMC (Fuse Management Console). Sie finden die GUI unter der folgenden URLhttp://localhost:8181.

Alles, was wir durch Ausführen von Befehlen getan haben, kann auch durch Zugriff auf diese browserbasierte Benutzeroberfläche erfolgen. Es ist äußerst hilfreich, wenn wir mehr als einen Container haben und in einer Fabric-Umgebung ausgeführt werden.

In diesem Kapitel werden wir über Apache Karaf und warum es als leichter OSGi-Container bezeichnet wird, sowie über seine Vorteile und andere wichtige Funktionen sprechen.

Das JVM-Problem

Die virtuelle JVM- oder Java-Maschine fungiert nicht als tatsächliche virtuelle Maschine. Eine Maschine, mit der Sie Komponenten, die in ihr ausgeführt werden, im laufenden Betrieb stoppen, starten oder neu starten können. Es kann manchmal Hot-Bereitstellungen auf Klassenebene zulassen, aber es gibt keine Möglichkeit, eine Komponente Ihrer Anwendung in Ihrer virtuellen Maschine bereitzustellen oder die Bereitstellung aufzuheben, ohne sie neu zu starten.

Um dieses Problem zu lösen und Modularität in Java-Anwendungen zu ermöglichen, verwendet Fuse eine OSGi-basierte Laufzeit, die als Apache Karaf bekannt ist.

OSGi

Die OSGi-Technologie besteht aus einer Reihe von Spezifikationen, die ein dynamisches Komponentensystem für Java definieren. Diese Spezifikationen ermöglichen ein Entwicklungsmodell, bei dem Anwendungen (dynamisch) aus vielen verschiedenen (wiederverwendbaren) Komponenten bestehen.

Vorteile von OSGi

Reduced Complexity - Die Anwendung besteht aus zusammenarbeitenden Komponenten, die ihre Implementierungsdetails voreinander verbergen, was zu einer geringeren Komplexität führt.
Reusability - Viele Komponenten können dieselbe in einem Container bereitgestellte Komponente nutzen.
Deployment - OSGi bietet Unterstützung für das schnelle Starten, Stoppen und Aktualisieren von Komponenten mit seinen Lifecycle-Management-APIs ohne Neustart des Containers.

Bundles Vs Features

Es folgt der Vergleich zwischen Bundles und Features.

Bündel

Bundles entsprechen OSGi, Jars sind JVM. Bundles sind Artefakte, die in einem OSGi-Container bereitgestellt werden können. Die Bundles sind Komponenten, die zusammenarbeiten oder unabhängig voneinander eine Anwendung bilden.

Diese Bundles können zur Laufzeit installiert, deinstalliert, aktualisiert, gestartet oder gestoppt werden, ohne den Container neu zu starten.

Eigenschaften

Mit Funktionen können mehrere Bundles zusammen bereitgestellt werden. Manchmal ist es sinnvoller, Bundles in Gruppen bereitzustellen. Mithilfe von Funktionen können wir eine Gruppe von Bundles mit nur einem Befehl bereitstellen.

Warum noch ein Container?

Apache Karaf ist eine OSGi-basierte Laufzeit. Hier werden unsere Anwendungspakete ausgeführt. Fuse verwendet Apache Karaf als Laufzeit, in der Bundles ausgeführt werden und zusammenarbeiten, um Geschäftsfunktionen bereitzustellen.

Karaf basiert auf Felix und Equinox, die OSGi Frameworks sind.

Karaf Architektur

Apache Karaf fügt der grundlegenden OSGi-Laufzeit die folgenden zusätzlichen Funktionen hinzu.

Hot Deployment

Karaf unterstützt Hot Deployment. Es enthält ein Hot-Deployment-Verzeichnis. Alles, was in diesem Verzeichnis abgelegt wird, wird automatisch bereitgestellt und in Karaf als Bundle installiert.

Protokollierung

Karaf bietet eine zentralisierte Protokollierung, indem Protokolle für alle Bundles in erstellt werden $Fuse_home/data/log. Wir können die Logger-Konfiguration in bearbeitenorg.ops4j.pax.logging.cfg im $Fuse_home/etc directory.

Admin-Konsole

Karaf bietet eine ausgeklügelte und übersichtliche Admin-Konsole für die Interaktion mit der laufenden Sicherungsinstanz. Es enthält auch einen vorinstallierten Befehlssatz, mit dem Komponenten (Bundle) zur Laufzeit verwaltet und überwacht werden können. Diese Konsole ist erweiterbar, sodass wir der Konsole neue Befehle hinzufügen können, indem wir der Konsole neue Bundles hinzufügen.

SSH-Zugriff

Karaf ermöglicht den Remotezugriff auf diese Admin-Konsole mit SSH. Jeder mit gültigen Anmeldeinformationen kann über das SSH-Terminal eine Verbindung zur Karaf-Administratorkonsole herstellen.

In diesem Kapitel werden wir anhand einiger Beispiele erläutern, was Apache Camel ist und wie Daten effektiv zwischen Endpunkten weitergeleitet werden.

Was ist Apache Camel?

Apache Camel ist ein Open Source-Integrationsframework, das Anfang 2007 gestartet wurde.

Es handelt sich um einen EIP-basierten Ansatz (Enterprise Integration Pattern), der mehrere sofort einsatzbereite Musterimplementierungen bietet, mit denen Probleme bei der Unternehmensintegration gelöst werden können. EIP sind nichts anderes als bewährte Lösungen für die gut dokumentierten und wiederkehrenden Probleme bei der Unternehmensintegration.

Camel wird auch als Routing- und Mediations-Engine bezeichnet, da es Daten effektiv zwischen Endpunkten weiterleitet und gleichzeitig eine hohe Belastung wie die Transformation von Datenformaten, Endpunktkonnektivität und vieles mehr erfordert.

Grundlegendes Beispiel

Die Voraussetzungen für die Verwendung von Apache Camel sind:

Java
Maven
Redhat JBoss-Sicherung 6.1-GA-379

Erstellen Sie das Grundgerüst der Anwendung

mvn:archetype generate 
–DgroupId = com.tutorialpoint.app 
–DartifactId = camel-first-app 
–DarchetypeGroupId = org.apache.camel.archetypes
–DarchetypeArtifactId = camel-archetype-spring 
–DinteractiveMode = false -X

Dies sollte die folgende Verzeichnisstruktur erzeugen.

Dies ist ein Grundgerüst unserer generierten Camel-Anwendung.

Bearbeiten Sie camel-context.xml

Bearbeiten camel-first-app → src → main → resources → META-INF\spring\camel-context.xml passend wie unten

<?xml version = "1.0" encoding = "UTF-8"?>
<!-- Configures the Camel Context-->
<beans xmlns = "http://www.springframework.org/schema/beans"
   xmlns:xsi = "http://www.w3.org/2001/XMLSchema-instance"
   xsi:schemaLocation = "http://www.springframework.org/schema/beans
   http://www.springframework.org/schema/beans/spring-beans.xsd
   http://camel.apache.org/schema/spring
   http://camel.apache.org/schema/spring/camel-spring.xsd">

   <camelContext xmlns = "http://camel.apache.org/schema/spring">
      <!-- here is a sample which processes the input file
         (leaving them in place - see the 'noop' flag) 
         then performs content based routing on the message using XPath -->
			
      <route>
         <from uri = "file:///d:/src/data?noop=false"/>
         <choice>
            <when>
               <xpath>/person/city = 'London'</xpath>
               <log message = "UK message"/>
               <to uri = "file:///d:/target/messages/uk"/>
            </when>
				
            <otherwise>
               <log message = "Other message"/>
               <to uri = "file:///d:/target/messages/others"/>
            </otherwise>
				
         </choice>
			
      </route>
   </camelContext>
</beans>

Bearbeiten Sie pom.xml

Fügen Sie den folgenden Code in <plugins> </ plugins> ein

<plugin>
   <groupId>org.apache.felix</groupId>
   <artifactId>maven-bundle-plugin</artifactId>
   <version>2.3.4</version>
   <extensions>true</extensions>
	
   <configuration>
      <instructions>
         <Bundle-SymbolicName>
            ${project.artifactId}
         </Bundle-SymbolicName>
         <Import-Package>*</Import-Package>
      </instructions>
   </configuration>
	
</plugin>

Verpackungsart ändern von jar → bundle.

<packaging>bundle</packaging>

Erstellen Sie das Projekt mit dem folgenden Befehl:

mvn clean install

Installieren Sie das Projekt in der Sicherung

Starten Sie die Sicherung mit Fuse.bat/start.bat. Wenn Sie Fuse mit startenstart.bat, verwenden client.batan die Sicherung anschließen. Sie sollten die Benutzeroberfläche wie im folgenden Screenshot gezeigt erhalten.

Dies ist die CLI für den Zugriff auf Karaf- und Fuse-Befehle.

install –s mvn:com.tutorialpoint.app/camel-firt-app/1.0-SNAPSHOT

Testen Sie, ob Ihr Projekt ausgeführt wird

Jetzt sollte Ihre Anwendung in Fuse installiert sein. Kopieren Sie das Datenverzeichnis nach innencamel-first-app und legen Sie es in D:/src/ und es sollte eine Nachricht mit city = London kopieren D:/target/merssages/uk.

Platzieren Sie die Eingabedatei in D:/src/data

Input

Message1.xml

<?xml version = "1.0" encoding = "UTF-8"?>
<person user = "james">
   <firstName>James</firstName>
   <lastName>Strachan</lastName>
   <city>London</city>
</person>

Message2.xml

<?xml version = "1.0" encoding = "UTF-8"?>
<person user = "hiram">
   <firstName>Hiram</firstName>
   <lastName>Chirino</lastName>
   <city>Tampa</city>
</person>

Output

In D: / target / messages / uk

<?xml version = "1.0" encoding = "UTF-8"?>
<person user = "james">
   <firstName>James</firstName>
   <lastName>Strachan</lastName>
   <city>London</city>
</person>

In D: / target / messages / Others

<?xml version = "1.0" encoding = "UTF-8"?>
<person user = "hiram">
   <firstName>Hiram</firstName>
   <lastName>Chirino</lastName>
   <city>Tampa</city>
</person>

In diesem Kapitel werden wir die verschiedenen Kamelkonzepte verstehen. Beginnen wir mit einem einfachen Beispiel, um zunächst die Kernkonzepte zu verstehen.

CamelContext

Jede Kamelanwendung hat mindestens einen CamelContext. Dies ist der Ort, an dem wir Kamelrouten hinzufügen. Es ist ähnlich wieApplicationContext des Frühlings.

Der Kamelkontext kann als ein Behälter betrachtet werden, der alle Dinge zusammenhält. Ein Kamelkontext kann mehrere Routen enthalten.

Routen

CamelContext kann eine oder mehrere Routen enthalten. Routen sind die Integrationslogik, die definiert, wie Daten im Kamelkontext von einem Endpunkt zum anderen fließen.

Endpunkt

Endpunkt ist das Ende des Kanals, über den das System Nachrichten senden oder empfangen kann. Dies nennen wir in der Kommunikationssprache Ziel oder Quelle.

Komponenten

Komponenten sind Erweiterungspunkte in Camel. Komponenten können eine Schnittstelle zu Technologie, Datenformat, Transformatoren usw. sein. Sie können auch als Factory für Endpunkte dienen.

EIP

EIP steht für Enterprise Integration Pattern. Dies sind identifizierte und bekannte Lösungen für ein wiederkehrendes Problem. Camel unterstützt die meisten Enterprise-Integrationsmuster.

Inhaltsbasierter Router

Mit CBR-Mustern können wir Daten gemäß dem Inhalt der Eingabedatei weiterleiten.

Dieses Muster wird verwendet, wenn Werte in Abhängigkeit vom Inhalt des Eingabekörpers weitergeleitet werden müssen.

Das folgende Beispiel liest Daten aus D:/data/inputVerzeichnis. Nach dem Lesen wird innerhalb des Daten-Tags nach Wert-Tags gesucht. Wenn das Wertetag enthältvalue1wird es an gesendet D:/value1, Wenn es enthält value2wird es an gesendet D:/value2 und wenn keines von beiden, dann wird es an andere gesendet.

<CamelContext xmlns = "http://camel.apache.org/schema/spring">
   <route>
      <from uri = "file:///D:/data/input"/>
      <choice>
         <when>
            <xpath>/data/value = 'value1'</xpath>
            <to uri = "file:///D:/value1"/>
         </when> 
         <when>
            <xpath>/data/value = 'value2'</xpath>
            <to uri = "file:///D:/value2"/>
         </when>  
			
         <otherwise>
            <to uri = "file:///D:/others "/>
         </otherwise>
			
      </choice>
   </route>
</camelContext>

Input

D: /data/input/message1.xml

<data>
   <value>value1</value>
</data>

D: /data/input/message2.xml

<data>
   <value>value2</value>
</data>

Output

D: / value1 /

<data>
   <value>value1</value>
</data>

D: / value2 /

<data>
   <value>value2</value>
</data>

Splitter

Ein Splitter-Muster wird verwendet, um Eingabedaten in kleinere Blöcke aufzuteilen.

Dieses Muster wird meistens bei großen Dateneingaben verwendet, die in Blöcke aufgeteilt werden müssen, damit es verarbeitbar wird. Die Eingabe wird basierend auf der Eingabe-Token-Zeichenfolge in kleinere Fragmente unterteilt.

<CamelContext xmlns = "http://camel.apache.org/schema/spring">
   <route>
      <from uri = "file:///D:/inbox"/>
      <split streaming = "true">
         <tokenize token = "order" xml = "true"/>
         <to uri = "activemq:queue:order"/>
      </split>
   </route>
</CamelContext>

Input

D: /inbox/message.xml

<order>
   <data>
      <value>value1</value>
   </data>
</order>

<order>
   <data>
      <value>value2</value>
   </data>
</order>

<order>
   <data>
      <value>value3</value>
   </data>
</order>

Output

Wenn Sie AMQ aktivieren, werden 3 Nachrichten veröffentlicht.

<order>
   <data>
      <value>value4</value>
   </data>
</order>

Empfängerliste

Ein Empfängerlistenmuster wird verwendet, wenn eine Empfängerliste aus dem Nachrichtentext selbst abgerufen werden muss.

Im folgenden Beispiel wird eine Nachricht an alle Empfänger gesendet, die im Kunden-Tag als durch Kommas getrennte Liste von Zeichenfolgen aufgeführt sind.

<CamelContext xmlns = "http://camel.apache.org/schema/spring">
   <route>
      <from uri = "jms:xmlOrders" />
      <recipientList>
         <xpath>/order/customer</xpath>
      </recipientList>
   </route>
</camelContext>

Andere EIPs

Camel unterstützt fast alle identifizierten EIPs. Einige der häufig verwendeten EIP sind wie unten erwähnt.

Log - Um eine vollständige Nachricht oder einen Teil davon zu protokollieren
Message Filter - Filtern von Nachrichteninhalten
Re-Sequencer - Um alle Token nacheinander zu erhalten
Wiretap - Um Fahrnachrichten zu überprüfen

Die vollständige Liste der EIP und ihrer Verwendung finden Sie in der offiziellen Dokumentation von Camel http://camel.apache.org/eip.html

Ausnahmebehandlung bei Kamelen

Using Error Handler - Dies ist der einfachste Weg, um Ausnahmen bei Kamelen zu behandeln.

Um dies zu verwenden, müssen wir die Error Handler Class Bean konfigurieren und als Referenz auf bereitstellen CamelContext errorHandlerRef Attribut.

<bean id = "loggingErrorHandler" class = "org.apache.camel.builder.LoggingErrorHandler">
   <property name = "logName" value = "mylogger.name"/>
   <property name = "level" value = "DEBUG"/>
</bean>

<camelContext errorHandlerRef = ” loggingErrorHandler” >
   …
</camelContext>

Verwenden von Try Catch Endlich

Camel unterstützt auch den Java-Stil Try Catch Finally block zur Fehlerbehandlung.

Genau wie Java hat es die folgenden drei Blöcke -

doTry Block enthält Code, der eine Ausnahme erzeugen kann.
doCatch Block enthält Code, der im Ausnahmefall ausgeführt werden muss.
doFinallyBlock hat Code, der unabhängig von der Ausnahme ausgeführt werden muss. Es wird immer ausgeführt, egal ob eine Ausnahme ausgelöst wurde oder nicht.

Note- Mock ist eine Testkomponente und wird für andere Zwecke nicht empfohlen. Es ist die Komponente in Camel, die zum Testen verwendet wird, genau wie die jMOck-Komponente in der testgetriebenen Entwicklung.

<route>
   <from uri = "direct:start"/>
   <doTry>
      <process ref = "someProcesorThatmayFail"/>
      <to uri = "mock:result"/>
		
      <doCatch>
         <exception>java.io.IOException</exception>
         <exception>java.lang.IllegalStateException</exception>
         <to uri = "mock:catch"/>
      </doCatch>
		
      <doFinally>
         <to uri = "mock:finally"/>
      </doFinally>
		
   </doTry>
</route>

Im obigen Beispiel können wir eine Liste von Ausnahmen angeben, die vom catch-Block behandelt werden müssen.

Bundle in Fuse bereitstellen

Starten Sie die Sicherung mit Fuse.bat/start.bat.

Wenn Sie Fuse mit start.bat starten, verwenden Sie client.bat, um eine Verbindung zu Fuse herzustellen. Sie sollten die Benutzeroberfläche wie im folgenden Screenshot gezeigt erhalten.

Dies ist die CLI für den Zugriff auf Karaf- und Fuse-Befehle.

install –s mvn:group.id /artifact.id/version 
e.g. install –s mvn:com.tutorialpoint.app/camel-firt-app/1.0-SNAPSHOT

Lassen Sie uns in diesem Kapitel erläutern, was Apache CXF ist und wie es bei der Entwicklung von SOAP- und Rest-Webdiensten hilfreich sein kann.

Was ist Apache CXF?

Apache CXF ist ein Framework zur Entwicklung von Webdiensten, mit dem SOAP- und Rest-Webdienste entwickelt werden können. CXF ist vollständig kompatibelJAX-RS and JAX-Ws Standard.

Es ist derzeit das am weitesten verbreitete Framework für die Entwicklung von Webdiensten. CXF hat gegenüber Axis2 gelernt und verbessert, das nun schrittweise durch CXF ersetzt wird.

CXF vs Axis2

	CXF	Achse2
Verbesserungen	CXF ist derzeit das am häufigsten verwendete Framework. Es hat viele Verbesserungen gegenüber Axis2	Achse2 wird schrittweise durch CXf ersetzt. Im Vergleich zu CXF ist mehr Code erforderlich
Code erforderlich	CXF benötigt im Vergleich zu Axis2 weniger Code	Axis2 benötigt vergleichsweise mehr Code
Standardkonformität	CSF ist vollständig kompatibel mit JAX-RS und JAX-WS	Axis2 ist nicht vollständig kompatibel mit JAX-RS und JAX-WS
Kompatibel mit Feder	Ja	Nein
Trennung der Frontends	Saubere Trennung des Frontends vom JAX-WS-Code	Es ist keine saubere Trennung vorgesehen

SEIFE

SOAP steht für Simple Object Access Protocol. Es ist ein Protokoll zum Austausch strukturierter Informationen über Webdienste zwischen zwei Systemen. Es basiert hauptsächlich auf XML zur Strukturierung von Daten und verwendet HTTP oder SMTP für die Aushandlung und Übertragung von Nachrichten.

Es gibt zwei Ansätze zur Entwicklung von SOAP-Webdiensten:

Code first - Bei diesem Ansatz wird WSDL aus Code generiert.
Contract first - Im Vertrag wird zuerst Code aus WSDL generiert.

SOAP-Entwicklung mit CXF

Konfigurieren Sie Maven

Fügen Sie das folgende Profil zu Ihrer settings.xml von Maven hinzu.

<profiles>
   <profile>
      <id>Jboss-Fuse</id>
		
      <activation>
         <activeByDefault>true</activeByDefault>
      </activation>
		
      <repositories>
         <repository>
            <id>fusesource</id>
            <url>http://repo.fusesource.com/nexus/content/groups/public/</url>
            <snapshots>
               <enabled>false</enabled>
            </snapshots>
            <releases>
               <enabled>true</enabled>
            </releases>
         </repository>
      </repositories>
		
   </profile>
</profiles>

Skelett erstellen

mvn archetype:generate
-DarchetypeGroupId = org.apache.servicemix.tooling 
-DarchetypeArtifactId = servicemix-cxf-code-first-osgi-bundle 
-DarchetypeVersion=2012.01.0.redhat-60024 
-DgroupId = org.fusesource.example 
-DartifactId = cxf-basic 
-Dversion = 1.0-SNAPSHOT

Build Web Service Project.

mvn clean install

Install web-service into Fuse using the following command.

JBossFuse:karaf@root>install -s mvn:org.fusesource.example/cxf-basic/1.0-SNAPSH

Check if bundle has registered SOQP web-service

Öffne URL http://localhost:8181/cxf

Der Webdienst sollte wie folgt aufgeführt sein.

Testing Web-Service

mvn -Pclient

INFO - Service erstellen {http://ws.totorials.com/} PersonService aus der Klasse com.to.

torials.ws.Person
Invoking getPerson...
getPerson._getPerson_personId = Guillaume
getPerson._getPerson_ssn = 000-000-0000
getPerson._getPerson_name = Guillaume
[INFO] ------------------------------------------------------------------------
[INFO] BUILD SUCCESS
[INFO] ------------------------------------------------------------------------
[INFO] Total time: 30.668 s
[INFO] Finished at: 2016-02-15T21:01:20+05:30
[INFO] Final Memory: 10M/37M
[INFO] ------------------------------------------------------------------------

Zunächst steht REST für Representational State Transfer. Auf diese Weise können Webdienste auf der Grundlage eines zustandslosen, zwischenspeicherbaren Client-Server-Protokolls entwickelt werden, bei dem es sich in den meisten Fällen um HTTP handelt.

REST-Webdienste verwenden HTTP-Anforderungen, um Daten aus dem Netzwerk zu veröffentlichen, abzurufen und zu löschen.

REST-Entwicklung mit CXF

Erstellen Sie ein einfaches Maven-Schnellstartprojekt

mvn archetype:generate 
-DgroupId = com.tuts.abhinav 
-DartifactId = rest-service
-DarchetypeArtifactId = maven-archetype-quickstart 
-DinteractiveMode = false

Abhängigkeiten hinzufügen

<dependency>
   <groupId>org.apache.servicemix.specs</groupId>
   <artifactId>org.apache.servicemix.specs.jsr311-api-1.1.1</artifactId>
   <version>1.9.0</version>
   <scope>provided</scope>
</dependency>

<dependency>
   <groupId>org.apache.servicemix</groupId>
   <artifactId>servicemix-http</artifactId>
   <version>2013.01</version>
</dependency>

<dependency>
   <groupId>log4j</groupId>
   <artifactId>log4j</artifactId>
   <version>1.2.16</version>
</dependency>

Build-Anweisung hinzufügen

<build>
   <defaultGoal>install</defaultGoal>
   <plugins>
      <plugin>
         <groupId>org.apache.felix</groupId>
         <artifalctId>maven-bundle-plugin</artifactId>
         <version>2.3.4</version>
         <extensions>true</extensions>
			
         <configuration>
            <instructions>
               <Bundle-SymbolicName>rest-example-database-post-method
                  </Bundle-SymbolicName>
               <Import-Package>* </Import-Package>
            </instructions>
         </configuration>
			
      </plugin>
   </plugins>
</build>

Hinzufügen von Sicherungs-Plugin-Repositorys

<pluginRepositories>
   <pluginRepository>
      <id>fusesource.m2</id>
      <name>FuseSource Community Release Repository</name>
      <url>http://repo.fusesource.com/nexus/content/repositories/releases</url>
      <snapshots>
         <enabled>false</enabled>
      </snapshots>
		
      <releases>
         <enabled>true</enabled>
      </releases>
   </pluginRepository>
<pluginRepositories>

Repositorys hinzufügen

<repositories>
   <repository>
      <id>fusesource.m2</id>
      <name>FuseSource Community Release Repository</name>
      <url>http://repo.fusesource.com/nexus/content/repositories/releases</url>
      <snapshots>
         <enabled>false</enabled>
      </snapshots>
		
      <releases>
         <enabled>true</enabled>
      </releases>
		
   </repository>
	
   <repository>
      <id>fusesource.ea</id>
      <name>FuseSource Community Early Access Release Repository</name>
      <url>http://repo.fusesource.com/nexus/content/groups/ea</url>
      <snapshots>
         <enabled>false</enabled>
      </snapshots>
      <releases>
         <enabled>true</enabled>
      </releases>
   </repository>
	
</repositories>

Serviceklasse erstellen

Erstellen Sie die Klasse UserService.java unter com / tuts /

package com.tuts;

import javax.ws.rs.GET;
import javax.ws.rs.Path;
import javax.ws.rs.Produces;
import javax.ws.rs.core.MediaType;

@Path("/UserService_1")
public class UserService {
   @GET
   @Path("/get_data")
   @Produces(MediaType.APPLICATION_JSON)
	
   public String getUser() {
      String reponse = "This is standard response from REST";
      return reponse;
   }
}

Erstellen Sie Blueprint.xml

Erstellen Sie die Datei blueprint.xml unter / src / main / resources / OSGI-INF / blueprint blueprint.xml

<?xml version = "1.0" encoding = "UTF-8"?>
<blueprint xmlns = "http://www.osgi.org/xmlns/blueprint/v1.0.0"
   xmlns:xsi = "http://www.w3.org/2001/XMLSchema-instance" 
   xmlns:jaxrs = "http://cxf.apache.org/blueprint/jaxrs"
   xsi:schemaLocation = "http://www.osgi.org/xmlns/blueprint/v1.0.0 
   http://www.osgi.org/xmlns/blueprint/v1.0.0/blueprint.xsd
   http://cxf.apache.org/blueprint/jaxrs 
   http://cxf.apache.org/schemas/blueprint/jaxrs.xsd">
	
   <jaxrs:server id = "service" address = "/users">
      <jaxrs:serviceBeans>
         <ref component-id = "userService" />
      </jaxrs:serviceBeans>
   </jaxrs:server>
	
   <bean id = "userService" class = "com.tuts.UserService" />
</blueprint>

Installieren Sie den Rest-Service in Fuse

install -s mvn:com.tuts.abhinav/rest-service/1.0-SNAPSHOT

Überprüfen Sie, ob das Bundle über einen registrierten Webdienst verfügt

Öffne URL http://localhost:8181/cxf

Testen Sie den Webdienst

Öffne URL http://localhost:8181/cxf/users12/UserService_1/get_data

In diesem Kapitel lernen wir ActiveMQ kennen und erfahren, wie es als Vermittler von Nachrichten fungiert, damit Anwendungen miteinander kommunizieren können.

Was ist AMQ?

ActiveMQ ist ein in Java geschriebener Open Source-Nachrichtenbroker. Es entspricht vollständig den JMS 1.1-Standards.

JMS ist eine Spezifikation, die die Entwicklung eines nachrichtenbasierten Systems ermöglicht. ActiveMQ fungiert als Makler für Nachrichten, die sich zwischen Anwendungen befinden und eine asynchrone und zuverlässige Kommunikation ermöglichen.

Arten von Nachrichten

Zum besseren Verständnis werden im Folgenden zwei Arten von Messaging-Optionen erläutert.

Punkt zu Punkt

Bei dieser Art der Kommunikation sendet der Broker Nachrichten nur an einen Verbraucher, während die anderen Verbraucher warten, bis sie die Nachrichten vom Broker erhalten. Kein Verbraucher erhält die gleiche Nachricht.

Wenn keine Verbraucher vorhanden sind, speichert der Broker die Nachrichten, bis er einen Verbraucher erhält. Diese Art der Kommunikation wird auch als bezeichnetQueue based communicationDabei sendet der Produzent Nachrichten an eine Warteschlange und nur ein Verbraucher erhält eine Nachricht aus der Warteschlange. Wenn es mehr als einen Verbraucher gibt, erhalten sie möglicherweise die nächste Nachricht, aber nicht die gleiche Nachricht wie der andere Verbraucher.

Veröffentlichen / Abonnieren

Bei dieser Art der Kommunikation sendet der Broker dieselbe Kopie der Nachrichten an alle aktiven Verbraucher. Diese Art der Kommunikation wird auch als bezeichnetTopic based communicationDabei sendet der Broker dieselbe Nachricht an alle aktiven Verbraucher, die ein bestimmtes Thema abonniert haben. Dieses Modell unterstützt die Einwegkommunikation, bei der keine Überprüfung der übertragenen Nachrichten erwartet wird.

Warteschlange und Themen erstellen

Die Sicherung wird mit ActiveMQ geliefert. Wir können über die FMC-Konsole (die browserbasierte Oberfläche für die Arbeit mit AMQ) auf ActiveMQ zugreifen.

Melden Sie sich bei FMC mit an localhost:8181 und auswählen ActiveMQ Tab.

Klicken Sie auf + Erstellen
Geben Sie den Namen der Warteschlange / des Themas ein
Wählen Sie im Optionsfeld Warteschlange / Thema aus
Klicken Sie auf Warteschlange erstellen / Thema erstellen

Jetzt sollten Sie das sehen können TestQ erstellt unter root → Queue →

Um das erstellte Thema zu überprüfen, folgen Sie root → Topic.

Durchsuchen / Löschen von Inhalten der Warteschlange

Melden Sie sich bei FMC mit an localhost:8181
Wählen Sie die Registerkarte ActiveMQ
Stamm → Warteschlange → TestQ <Warteschlange auswählen, die Sie durchsuchen möchten> → Durchsuchen

Um den Inhalt dieser Nachricht zu überprüfen, klicken Sie auf diese bestimmte Nachricht.

Sie können eine bestimmte Nachricht löschen, indem Sie auf die Schaltfläche Löschen in der oberen rechten Ecke klicken

In diesem Kapitel lernen wir die Grundlagen der Funktionsweise von ActiveMQ mit Camel kennen.

Konfiguration zur ActiveMQ-Komponente

Bevor wir die ActiveMQ-Warteschlange oder das Thema in unserem Code verwenden können, müssen wir ActiveMQComponent konfigurieren. Die minimale Konfiguration von ActiveMQComponent kann wie im folgenden Programm gezeigt erfolgen:

<bean id = "activemq" class = "org.apache.activemq.camel.component.ActiveMQComponent">
   <property name = "brokerURL" value = "tcp://localhost:61616"/>
   <property name = "userName" value = "admin"/>
   <property name = "password" value = "admin"/>
</bean>

brokerURL - Gibt Host und Port für AMQ Broker an.
username - Gibt den Benutzernamen an, der für die Verbindung mit AMQ Broker verwendet werden soll.
password - Gibt das Passwort für die Verbindung mit AMQ Broker an.

Verbindung zur Warteschlange herstellen

Nachdem wir ActiveMQComponent konfiguriert haben, können wir es in unserem CamelContext als Endpunkt verwenden.

Wir werden den AMQ-Endpunkt im folgenden Format verwenden:

Activemq:[queue|topic]:[queueName|topicName]

Schreiben von Nachrichten an AMQ

<?xml version = "1.0" encoding="UTF-8"?>
<!-- Configures the Camel Context-->
<beans xmlns = "http://www.springframework.org/schema/beans"
   xmlns:xsi = "http://www.w3.org/2001/XMLSchema-instance"
   xsi:schemaLocation = "http://www.springframework.org/schema/beans
   http://www.springframework.org/schema/beans/spring-beans.xsd
   http://camel.apache.org/schema/spring
   http://camel.apache.org/schema/spring/camel-spring.xsd">

Nach der Bereitstellung dieses Bundles im Sicherungscontainer sollten Sie in der Lage sein, an AMQ gesendete Nachrichten anzuzeigen, die als Dateien in abgelegt wurden D:/src/data.

Input

D: /src/data/input.txt

Test me

Output

Lesen von AMQ

<?xml version = "1.0" encoding = "UTF-8"?>
<!-- Configures the Camel Context-->

<beans xmlns = "http://www.springframework.org/schema/beans"
   xmlns:xsi = "http://www.w3.org/2001/XMLSchema-instance"
   xsi:schemaLocation = "
   http://www.springframework.org/schema/beans
   http://www.springframework.org/schema/beans/spring-beans.xsd
   http://camel.apache.org/schema/spring
   http://camel.apache.org/schema/spring/camel-spring.xsd">
	
   <camelContext xmlns = "http://camel.apache.org/schema/spring">
      <!-- here is a sample which processes the input files
         (leaving them in place - see the 'noop' flag)
          then performs content based routing on the message using XPath -->
			 
      <route>
         <from uri = "activemq:queue:TestQ"/>
         <to uri = "file:///d:/src"/>
      </route>
   </camelContext>
	
   <bean id = "activemq" class = "org.apache.activemq.camel.component.ActiveMQComponent">
      <property name = "brokerURL" value = "tcp://localhost:61616"/>
      <property name = "userName" value = "admin"/>
      <property name = "password" value = "admin"/>
   </bean>
	
</beans>

Input

Nach der Bereitstellung dieses Bundles sollte in D: / src eine Datei generiert und Nachrichten verbraucht werden. Auch Consumer sollte für diese Warteschlange angezeigt werden.

Output

D: / src

Test me

Schreiben zum Thema

<?xml version = "1.0" encoding = "UTF-8"?>
<!-- Configures the Camel Context-->
<beans xmlns = "http://www.springframework.org/schema/beans"
   xmlns:xsi = "http://www.w3.org/2001/XMLSchema-instance"
   xsi:schemaLocation = "http://www.springframework.org/schema/beans 
   http://www.springframework.org/schema/beans/spring-beans.xsd
   http://camel.apache.org/schema/spring 
   http://camel.apache.org/schema/spring/camel-spring.xsd">
	
   <camelContext xmlns = "http://camel.apache.org/schema/spring">
      <!-- here is a sample which processes the input files
         (leaving them in place - see the 'noop' flag)
          then performs content based routing on the message using XPath -->
			 
      <route>
         <from uri = "file:///d:/src"/>
         <to uri = "activemq:topic:TestTopic” />
      </route>
   </camelContext>
	
   <bean id = "activemq" class = "org.apache.activemq.camel.component.ActiveMQComponent">
      <property name = "brokerURL" value = "tcp://localhost:61616"/>
      <property name = "userName" value = "admin"/>
      <property name = "password" value = "admin"/>
   </bean>
	
</beans>

Lesen vom Thema

<?xml version = "1.0" encoding = "UTF-8"?>
<!-- Configures the Camel Context-->
<beans xmlns = "http://www.springframework.org/schema/beans"
   xmlns:xsi = "http://www.w3.org/2001/XMLSchema-instance"
   xsi:schemaLocation = "
   http://www.springframework.org/schema/beans 
   http://www.springframework.org/schema/beans/spring-beans.xsd
   http://camel.apache.org/schema/spring 
   http://camel.apache.org/schema/spring/camel-spring.xsd">
	
   <camelContext xmlns = "http://camel.apache.org/schema/spring">
      <!-- here is a sample which processes the input files
         (leaving them in place - see the 'noop' flag)
         then performs content based routing on the message using XPath -->
			
      <route>
         <from uri = "activemq:topic:TestTopic"/>
         <to uri = "file:///d:/src2"/>
      </route>
   </camelContext>
	
   <bean id = "activemq" class = "org.apache.activemq.camel.component.ActiveMQComponent">
      <property name = "brokerURL" value="tcp://localhost:61616"/>
      <property name = "userName" value = "admin"/>
      <property name = "password" value = "admin"/>
   </bean>
	
</beans>

Input

D: /src/file1.xml

<order>
   <data>
      <value>value1</value>
   </data>
</order>

<order>
   <data>
      <value>value2</value>
   </data>
</order>

<order>
   <data>
      <value>value3</value>
   </data>
</order>

Output

D: / src /

<order>
   <data>
      <value>value1</value>
   </data>
</order>

<order>
   <data>
      <value>value2</value>
   </data>
</order>

<order>
   <data>
      <value>value3</value>
   </data>
</order>

Was ist Stoff?

Fabric bietet Verwaltungs- und Orchestrierungsfunktionen für mehrere Fuse-Instanzen. Mit Fabric können wir alle damit verbundenen Fuse-Instanzen von einem einzigen Punkt aus steuern. Ein normaler Sicherungsbehälter kann in einen Stoff umgewandelt werden. Fabric enthält eine Fabric-Registrierung, die als Datenspeicher dient und alle Informationen zu den von ihr verwalteten Containern enthält.

Warum Stoff?

Fabric verfügt über die folgenden besonderen Fähigkeiten, die es zu einem idealen Kandidaten für die Verwendung in verteilten Umgebungen machen.

Überwachung des Zustands aller Behälter im Stoff.
Starten und Stoppen von Remote-Containern.
Stellt Remote-Container zum Ausführen einer bestimmten Anwendung bereit.
Aktualisieren von Anwendungen und Ausrollen von Patches im Live-System.
Schnelles Starten und Bereitstellen neuer Container, um beispielsweise die erhöhte Systemlast zu bewältigen.

Fabric-Setup

Stoff erstellen

Der normale Sicherungscontainer kann mit dem folgenden Befehl in Fabric konvertiert werden

fabric: create --clean --zookeeper-password myZooPass

Anderen Container mit Stoff verbinden -

fabric:join --zookeeper-password myZooPass <fabric_host>:2181 Cont1

Note - Bitte ersetzen Sie <fabric_host> durch den tatsächlichen Hostnamen, auf dem Fabric ausgeführt wird.

Wenn Sie sich über Ihren Browser mit bei der Fuse Management Console anmelden localhost:8181sollten Sie in der Lage sein, zwei Container zu sehen, wie im folgenden Screenshot gezeigt. Der Stoffbehälter ist durch ein kleines Wolkensymbol gekennzeichnet.

Profile

Ein Profil enthält die folgenden Informationen:

Zu installierende Bundles
Zu installierende Funktionen
Zu verwendende Konfigurationen

Ein Profil bietet in der Fabric-Umgebung die Möglichkeit, dieselben Bundles, Funktionen und Konfigurationen auf mehreren Servern zu installieren.

Wenn dasselbe Profil auf mehrere Container angewendet wird und wir Änderungen an diesem Profil von einem Container aus vornehmen, werden ähnliche Änderungen automatisch für die verbleibenden Container bereitgestellt, auf die es angewendet wird.

Profile erstellen

Melden Sie sich bei FMC an localhost:8181
Laufzeit → Verwalten
Klicken Sie auf der linken Seite im Menü Profil auf +

Geben Sie den Namen ein, den Sie dem Profil geben möchten, und klicken Sie auf Erstellen.

Danach sollte das Profil erstellt werden.

Profil auf Container anwenden

Laufzeit → Container → root (wählen Sie den gewünschten Container aus)

Klicken AddDies führt zu einem Popup-Fenster. Suchen Sie nach dem gewünschten Profil und klicken Sie erneutAdd.

Das Profil sollte in der Liste angezeigt werden, wie im folgenden Screenshot gezeigt.

Bereitstellen eines Bundles

Verwenden Sie den folgenden Pfad, um ein Bundle bereitzustellen:

Laufzeit → Container → root (wählen Sie den gewünschten Container aus) → First_profile (Profil auswählen)

Klicken Sie auf die Registerkarte Bundles. Legen Sie den Bundle-Pfad im folgenden Format fest und klicken Sie dann auf+.

mvn:group.id/artifact.id/version

Zum Beispiel: mvn:com.tutorialpoint.app/camel-firt-app/1.0-SNAPSHOT

Ein Bundle wird dem Profil hinzugefügt und auf allen Containern bereitgestellt, denen das Profil zugewiesen ist.

Bereitstellung eines Bundles aufheben

Verwenden Sie den folgenden Pfad, um die Bereitstellung eines Bundles aufzuheben:

Laufzeit → Container → root (gewünschten Container auswählen) → First_profile (Profil auswählen)

Klicken Sie auf die Registerkarte Bundles, suchen Sie nach dem Bundle, das Sie löschen möchten, und klicken Sie dann auf X. Das Bundle wird aus allen Containern gelöscht, auf die das Profil angewendet wird.

Ein untergeordneter Container bietet die einfachste Möglichkeit, die zunehmende Last zu verwalten. Wenn das System plötzlich im Verkehr ausgelastet ist und ein einzelner Container die Last nicht bewältigen kann, können wir problemlos eine Reihe von untergeordneten Containern erstellen und die Last auf diese verteilen, anstatt einen vollständig neuen Container zu erstellen.

Erstellen eines untergeordneten Containers

Melden Sie sich bei FMC mit an localhost:8181

Folgen Sie nun dem Pfad: Laufzeit → Container → + Erstellen (Schaltfläche auf der rechten Seite)

Geben Sie Details wie den untergeordneten Namen, den übergeordneten Container, die Anzahl der Instanzen usw. ein.

Klicken Create And Start Container

Verwalten eines untergeordneten Containers

Ein untergeordneter Container fungiert nur als normaler Container.

Unterhalten eines untergeordneten Containers

Folgen Sie dem Pfad, um einen untergeordneten Container zu stoppen: Laufzeit → Container → Untergeordnet1

Klicken Sie auf Stopp, um den untergeordneten Container zu stoppen.

Starten eines untergeordneten Containers

Folgen Sie dem Pfad, um einen untergeordneten Container zu starten: Laufzeit → Container → Child1

Klicken Sie auf Start, um den untergeordneten Container zu starten.

In diesem Kapitel werden einige bekannte Probleme erläutert, die bei der Arbeit mit Fuse auftreten können. Wir werden auch diskutieren, wie Sie diese Probleme lösen können.

Codeänderungen werden nicht berücksichtigt

Stellen Sie mithilfe eines Client-Skripts eine Verbindung zur Fuse-Instanz her. Durchsuchen Sie das Bundle, für das Sie ein Problem haben, mit dem folgenden Befehl.

JBossFuse:karaf@root > list|grep <Bundle Description>
For Example:
JBossFuse:karaf@root > list|grep Camel
[ 255] [Active ] [ ] [ ] [ 60] Fabric8 :: Camel Component (1.0.0.redhat-379)
[ 266] [Active ] [ ] [Started] [ 60] A Camel Spring Route (1.0.0.SNAPSHOT)

Note - Bundle-ID für das Bundle aus der Ausgabe des obigen Befehls und Verwendung des folgenden Befehls.

JBossFuse:karaf@root > update <bundle id>
JBossFuse:karaf@root > update 266

Bundle wird nicht heruntergeladen

Dies kann aus den folgenden zwei Gründen geschehen:

Maven-Repository nicht angegeben
Bundle nicht im Repository vorhanden

Maven Repository nicht angegeben

Bearbeiten Sie $ FUSE_INSTALLATION_DIR / etc /org.ops4j.paxurl.mvn.cfg

Aktualisieren Sie die folgenden zwei Eigenschaften:

org.ops4j.pax.url.mvn.settings = $ M2_HOME / conf /settings.xml
org.ops4j.pax.url.mvn.localRepository = $ local_repo

Note - Bitte ändern Sie $ local_repo mit dem tatsächlichen Pfad Ihres lokalen Repositorys, der in Mavens settings.xml angegeben ist

Bundle nicht im Repository vorhanden

Wenn die Maven-Einstellungen vorhanden sind, Sie jedoch beim Herunterladen des Bundles auf Probleme stoßen, stellen Sie sicher, dass die Bundles vorhanden sind JAR ist an der richtigen Stelle im Maven Repository vorhanden.

Zum Beispiel, wenn das folgende Bundle beim Herunterladen Fehler auslöst -

mvn:com.tutorialpoint.app/camel-first-app/1.0-SNAPSHOT

Wir müssen $ M2_REPO / com / tutorialpoint / app / camel-first-app / 1.0-SNAPSHOT einchecken, wenn tatsächlich JAR vorhanden ist.

Note - $ M2_REPO muss durch den tatsächlichen Pfad des Maven-Repositorys ersetzt werden, für dessen Verwendung Fuse konfiguriert ist.

Kann sich nicht bei FMC anmelden (Browser-basierte GUI)

Users not Created - Wenn Sie die folgende Benutzeroberfläche erhalten, sich jedoch nicht mit der Meldung "Anmeldung fehlgeschlagen, verboten" anmelden können.

Überprüfen Sie, ob Sie Benutzer hinzugefügt haben $FUSE_INSTALLATION_HOME/etc/users.properties

Das richtige Format zum Hinzufügen von Benutzern ist -

Username = Password,Role

HAWTIO Port ist anders

Wenn Sie nicht einmal in der Lage sind, die Benutzeroberfläche unter localhost: 8181 im Browser abzurufen, überprüfen Sie, ob Sie den richtigen Port in der URL angegeben haben.

$FUSE_INSTALLATION_HOME/etc/org.ops4j.pax.web.cfg

Bearbeiten Sie die folgende Eigenschaft in der Datei, um den Port zu verwenden, auf den Sie zugreifen möchten.

org.osgi.service.http.port=8181

AMQ Broker funktioniert nicht

Stellen Sie sicher, dass der 61616-Port geöffnet ist und derzeit nicht von einem anderen Port verwendet wird. Wenn Sie den Standard-61616-Port für denselben ändern möchten, können Sie ihn in bearbeiten$FUSE_INSTALLATION_HOME/etc/System.properties

activemq.port = 61616