Erstellen Sie ein ESB-System mit Spring Boot und Apache ServiceMix

Da moderne Unternehmen immer mehr auf eine Vielzahl unterschiedlicher Anwendungen und Systeme angewiesen sind, wird die Unternehmensintegration noch wichtiger. Enterprise Service Bus (ESB) ist ein Integrationsarchitekturmodell, das verschiedene Systeme und Anwendungen miteinander verbindet, um gemeinsame Datenaustausch- und Nachrichtenroutingdienste bereitzustellen und eine Anwendungsintegration auf Unternehmensebene zu erreichen. Mit Spring Boot und Apache ServiceMix können wir ganz einfach ein ESB-System erstellen. In diesem Artikel wird die Implementierung vorgestellt.

Einführung in Spring Boot und Apache ServiceMix

Spring Boot

Spring Boot ist ein Framework zum Erstellen eigenständiger Java-basierter Anwendungen auf Produktionsebene basierend auf dem Spring-Framework. Es vereinfacht den Prozess der Erstellung und Konfiguration von Spring-Anwendungen, indem es einige gängige Konfigurationen und Voreinstellungen sofort bereitstellt. Spring Boot bietet außerdem viele weitere Funktionen, wie automatische Konfiguration, eingebettete Webserver und Unterstützung für verschiedene externe Dienste, mit denen verschiedene Arten von Anwendungen erstellt werden können, darunter Webanwendungen, Batch-Anwendungen und Microservices.

Apache ServiceMix

Apache ServiceMix ist ein Enterprise Service Bus (ESB), der auf Open Source Java basiert und eine Reihe grundlegender Dienste bereitstellt, darunter Nachrichtenrouting, Nachrichtentransformation, Transaktionsweitergabe und Sicherheit. ServiceMix unterstützt auch viele verschiedene Service-Bus-Standards, wie zum Beispiel Webservices und Java Message Service (JMS). Mit ServiceMix und seinen externen Komponenten können Entwickler problemlos unterschiedliche Systeme und Anwendungen für eine effiziente Nachrichtenweiterleitung und einen effizienten Datenaustausch integrieren.

Erstellen Sie ein ESB-System mit Spring Boot und ServiceMix.

Um ein ESB-System mit Spring Boot und ServiceMix zu erstellen, müssen wir zunächst die folgenden Schritte ausführen:

1. Installieren und konfigurieren Sie die Java-Umgebung.
2. Laden Sie Apache Maven und Apache ServiceMix herunter und installieren Sie es.
3. Erstellen Sie ein Spring Boot-Projekt mit dem Namen „esb-demo“.

Als nächstes werden wir verschiedene Teile des ESB-Systems Schritt für Schritt implementieren.

Definieren Sie das Nachrichtenformat des ESB-Systems

Der Kernbestandteil des ESB-Systems ist das Nachrichtenformat. In diesem Beispiel verwenden wir ein einfaches JSON-Format als Nachrichtenformat, das die folgenden Felder enthält:

• id: Die eindeutige Kennung der Nachricht.
• Quelle: Quelle.
• Ziel: Nachrichtenziel.
• Inhalt: Nachrichteninhalt.

Erstellen Sie die Grundkonfiguration von ServiceMix

Als nächstes müssen wir die Grundkonfiguration für ServiceMix definieren. Erstellen Sie dazu eine Datei mit dem Namen „esb.xml“ und fügen Sie den folgenden Inhalt hinzu:

<?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"
        xsi:schemaLocation="
            http://www.osgi.org/xmlns/blueprint/v1.0.0
            http://www.osgi.org/xmlns/blueprint/v1.0.0/blueprint.xsd">

    <camelContext id="camel" xmlns="http://camel.apache.org/schema/blueprint">
        <route>
            <from uri="jms:queue:incoming"/>
            <to uri="jms:queue:outgoing"/>
        </route>
    </camelContext>

    <bean id="jmsConnectionFactory" class="org.apache.activemq.ActiveMQConnectionFactory">
        <property name="brokerURL" value="tcp://localhost:61616"/>
    </bean>

    <bean id="pooledConnectionFactory" class="org.apache.activemq.pool.PooledConnectionFactory" destroy-method="stop">
        <property name="maxConnections" value="8"/>
        <property name="connectionFactory" ref="jmsConnectionFactory"/>
    </bean>

    <bean id="jmsConfig" class="org.apache.camel.component.jms.JmsConfiguration">
        <property name="connectionFactory" ref="pooledConnectionFactory"/>
    </bean>

    <bean id="jms" class="org.apache.camel.component.jms.JmsComponent" lazy-init="true">
        <property name="configuration" ref="jmsConfig"/>
    </bean>

</blueprint>

Diese Konfigurationsdatei definiert eine Camel-Route, die Nachrichten von einer JMS-Warteschlange mit dem Namen „incoming“ empfängt und sie an eine JMS-Warteschlange mit dem Namen „outgoing“ sendet ". Die Konfigurationsdatei definiert außerdem eine JMS-Verbindungsfabrik für die Verbindung mit ActiveMQ sowie eine gepoolte Verbindungsfabrik, die eine maximale Nutzung von JMS-Verbindungen ermöglicht, und eine JMS-Komponente zur gemeinsamen Integration von Camel und JMS.

REST-Endpunkt des ESB-Systems hinzufügen

Um ESB-Nachrichten zu empfangen und zu senden, müssen wir einen REST-Endpunkt für das Geschäftssystem erstellen. In diesem Artikel werden wir die folgenden zwei Endpunkte implementieren:

• POST /esb/incoming: ESB-Nachrichten von Geschäftssystemen empfangen.
• GET /esb/outgoing: Gibt die verarbeitete ESB-Nachricht zurück.

Um diese Endpunkte zu implementieren, erstellen Sie einen Spring Boot-Controller mit dem Namen „EsbController.java“ und fügen Sie Folgendes zu seinem Quellcode hinzu:

@RestController
public class EsbController {

    private final JmsTemplate jmsTemplate;

    public EsbController(JmsTemplate jmsTemplate) {
        this.jmsTemplate = jmsTemplate;
    }

    @PostMapping("/esb/incoming")
    public ResponseEntity<?> sendIncomingMessage(@RequestBody EsbMessage message) {
        jmsTemplate.convertAndSend("incoming", message.toMessage());
        return ResponseEntity.ok().build();
    }

    @GetMapping("/esb/outgoing")
    public ResponseEntity<List<EsbMessage>> getOutgoingMessages() {
        List<EsbMessage> messages = jmsTemplate.browse("outgoing", session -> {
            List<EsbMessage> result = new ArrayList<>();
            Enumeration<?> enumeration = session.getEnumeration();
            while (enumeration.hasMoreElements()) {
                Message message = (Message) enumeration.nextElement();
                result.add(EsbMessage.fromMessage(message));
            }
            return result;
        });
        return ResponseEntity.ok(messages);
    }

}

Diese Controller-Klasse verwendet JmsTemplate, um JSON aus dem Geschäftssystem zu konvertieren. Die Nachrichten werden in JMS-Nachrichten konvertiert und an die ESB-Warteschlange gesendet. Verwenden Sie JmsTemplate auch, um verarbeitete JSON-Nachrichten aus der ESB-Warteschlange abzurufen.

Starten Sie das ESB-System

Nach Abschluss der oben genannten Schritte haben wir die Infrastruktur eines ESB-Systems aufgebaut. Um es lokal auszuführen und zu testen, müssen wir die folgenden Schritte ausführen:

1. Wechseln Sie in das Stammverzeichnis des Projekts.
2. Führen Sie den Befehl „mvn clean install“ im Terminal aus, um die JAR-Datei des Projekts zu generieren.
3. Starten Sie Apache ServiceMix und führen Sie „bin/servicemix“ aus.
4. Installieren Sie die ESB-Konfigurationsdatei in der ServiceMix-Befehlszeilenkonsole und geben Sie „install esb.xml“ ein.
5. Installieren Sie das ESB-Projekt in der ServiceMix-Befehlszeilenkonsole und geben Sie „install -s mvn:com.example/esb-demo/0.0.1-SNAPSHOT“ ein.
6. Verwenden Sie eine POST-Anfrage, um eine ESB-Nachricht zu senden, zum Beispiel: "curl -X POST -H "Content-Type:application/json" -d '{"id":1,"source":"SystemA","destination" : „SystemB“, „content“: „Testnachricht“}‘ http://localhost:8080/esb/incoming“.
7. Verarbeitete ESB-Nachrichten mithilfe einer GET-Anfrage abrufen, zum Beispiel: „curl http://localhost:8080/esb/outgoing“.

Zusammenfassung

Mit Spring Boot und Apache ServiceMix können wir ganz einfach ein effizientes ESB-System aufbauen, um mehrere Systeme und Anwendungen zu verbinden und Datenaustausch und Nachrichtenweiterleitung zu implementieren. In diesem Artikel haben wir gesehen, wie man ein grundlegendes ESB-System einrichtet und REST-Endpunkte hinzufügt, um die Kommunikation mit Geschäftssystemen zu erleichtern. Obwohl es sich bei diesem Artikel nur um ein einfaches Beispiel handelt, bietet er einen guten Ausgangspunkt für den Aufbau komplexerer ESB-Systeme.

Das obige ist der detaillierte Inhalt vonErstellen Sie ein ESB-System mit Spring Boot und Apache ServiceMix. Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!