Messaging mit Spring AMQP

1. Übersicht

In diesem Tutorial untersuchen wir die nachrichtenbasierte Kommunikation über AMQP mithilfe des Spring AMQP-Frameworks. Zunächst werden einige der Schlüsselkonzepte des Messaging behandelt. Dann kommen wir zu einem praktischen Beispiel.

2. Nachrichtenbasierte Kommunikation

Messaging ist eine Technik zur Kommunikation zwischen Anwendungen. Es basiert auf asynchroner Nachrichtenübermittlung anstelle einer auf synchronen Anforderungsantworten basierenden Architektur. Produzenten und Konsumenten von Nachrichten werden durch eine Zwischennachrichtenschicht entkoppelt, die als Nachrichtenbroker bekannt ist . Ein Nachrichtenbroker bietet Funktionen wie die dauerhafte Speicherung von Nachrichten, die Nachrichtenfilterung und die Nachrichtentransformation.

Bei Nachrichten zwischen in Java geschriebenen Anwendungen wird häufig die JMS-API (Java Message Service) verwendet. Für die Interoperabilität zwischen verschiedenen Anbietern und Plattformen können wir keine JMS-Clients und -Makler verwenden. Hier bietet sich AMQP an .

3. AMQP - Advanced Message Queuing Protocol

AMQP ist eine offene Standarddrahtspezifikation für die asynchrone Nachrichtenkommunikation. Es enthält eine Beschreibung, wie eine Nachricht erstellt werden soll.

3.1. Wie sich Amqp von Jms unterscheidet

Da AMQP ein plattformneutraler Binärprotokollstandard ist, können Bibliotheken in verschiedenen Programmiersprachen geschrieben und in verschiedenen Umgebungen ausgeführt werden.

Es gibt keine herstellerbasierte Protokollsperre, wie dies bei der Migration von einem JMS-Broker zu einem anderen der Fall ist. Weitere Informationen finden Sie unter JMS vs AMQP und Grundlegendes zu AMQP. Einige der weit verbreiteten AMQP-Broker sind RabbitMQ , OpenAMQ und StormMQ.

3.2. AMQP-Einheiten

Kurz gesagt besteht AMQP aus Börsen, Warteschlangen und Bindungen:

  • Börsen sind wie Postämter oder Postfächer, und Kunden veröffentlichen eine Nachricht an eine AMQP-Vermittlungsstelle. Es gibt vier integrierte Austauschtypen
    • Direkter Austausch - Leitet Nachrichten an eine Warteschlange weiter, indem ein vollständiger Routing-Schlüssel abgeglichen wird
    • Fanout Exchange - Leitet Nachrichten an alle daran gebundenen Warteschlangen weiter
    • Topic Exchange - Leitet Nachrichten an mehrere Warteschlangen weiter, indem ein Routing-Schlüssel einem Muster zugeordnet wird
    • Headers Exchange - Leitet Nachrichten basierend auf Nachrichtenkopfzeilen weiter
  • Warteschlangen werden mithilfe eines Routing-Schlüssels an einen Austausch gebunden
  • Nachrichten werden mit einem Routing-Schlüssel an eine Vermittlungsstelle gesendet. Der Austausch verteilt dann Kopien von Nachrichten an Warteschlangen

Weitere Informationen finden Sie unter AMQP-Konzepte und Routing-Topologien.

3.3. Frühling AMQP

Spring AMQP besteht aus zwei Modulen: Spring-Amqp und Spring-Rabbit . Zusammen bieten diese Module Abstraktionen für:

  • AMQP-Entitäten - Wir erstellen Entitäten mit den Klassen Message, Queue, Binding und Exchange

  • Verbindungsmanagement - Wir stellen über eine CachingConnectionFactory eine Verbindung zu unserem RabbitMQ-Broker her
  • Nachrichtenveröffentlichung - Wir verwenden eine RabbitTemplate , um Nachrichten zu senden
  • Nachrichtenverbrauch - Wir verwenden einen @ RabbitListener , um Nachrichten aus einer Warteschlange zu lesen

4. Richten Sie einen Rabbitmq Broker ein

Wir benötigen einen RabbitMQ-Broker, mit dem wir eine Verbindung herstellen können. Der einfachste Weg, dies zu tun, besteht darin, mit Docker ein RabbitMQ-Image für uns abzurufen und auszuführen:

docker run -d -p 5672:5672 -p 15672:15672 --name my-rabbit rabbitmq:3-management

Wir legen Port 5672 offen, damit unsere Anwendung eine Verbindung zu RabbitMQ herstellen kann.

Außerdem stellen wir Port 15672 zur Verfügung, damit wir über die Verwaltungsoberfläche: // localhost: 15672 oder die HTTP-API: //localhost:15672/api/index.html sehen können, was unser RabbitMQ-Broker tut .

5. Erstellen unserer Spring Amqp-Anwendung

Lassen Sie uns nun unsere Anwendung erstellen, um ein einfaches „Hallo Welt!“ Zu senden und zu empfangen. Nachricht mit Spring AMQP.

5.1. Maven-Abhängigkeiten

Um die Module spring-amqp und spring-rabbit zu unserem Projekt hinzuzufügen, fügen wir unserer pom.xml die Abhängigkeit spring-boot-Starter-amqp hinzu :

  org.springframework.boot spring-boot-starter-amqp 2.2.2.RELEASE  

Die neueste Version finden Sie bei Maven Central.

5.2. Verbindung zu unserem Rabbitmq Broker herstellen

Wir werden die automatische Konfiguration von Spring Boot verwenden, um unsere ConnectionFactory- , RabbitTemplate- und RabbitAdmin- Beans zu erstellen . Als Ergebnis erhalten wir eine Verbindung zu unserem RabbitMQ-Broker über Port 5672 unter Verwendung des Standardbenutzernamens und -kennworts "Gast". Daher kommentieren wir unsere Anwendung einfach mit @SpringBootApplication :

@SpringBootApplication public class HelloWorldMessageApp { // ... }

5.3. Erstellen Sie unsere Warteschlange

Um unsere Warteschlange zu erstellen, definieren wir einfach eine Bean vom Typ Warteschlange . RabbitAdmin findet dies und bindet es mit dem Routing-Schlüssel "myQueue" an den Standardaustausch:

@Bean public Queue myQueue() { return new Queue("myQueue", false); }

Wir haben die Warteschlange als nicht dauerhaft festgelegt, damit die Warteschlange und alle darin enthaltenen Nachrichten entfernt werden, wenn RabbitMQ gestoppt wird. Beachten Sie jedoch, dass ein Neustart unserer Anwendung keine Auswirkungen auf die Warteschlange hat.

5.4. Senden Sie unsere Nachricht

Verwenden wir die RabbitTemplate , um unsere "Hallo Welt!" Botschaft:

rabbitTemplate.convertAndSend("myQueue", "Hello, world!");

5.5. Verbrauchen Sie unsere Botschaft

Wir implementieren einen Nachrichtenkonsumenten, indem wir eine Methode mit @RabbitListener kommentieren :

@RabbitListener(queues = "myQueue") public void listen(String in) { System.out.println("Message read from myQueue : " + in); }

6. Ausführen unserer Anwendung

Zuerst starten wir den RabbitMQ-Broker:

docker run -d -p 5672:5672 -p 15672:15672 --name my-rabbit rabbitmq:3-management

Anschließend führen wir die Spring-Boot-Anwendung aus, indem wir HelloWorldMessage.java ausführen und die main () -Methode ausführen :

mvn spring-boot:run -Dstart-class=com.baeldung.springamqp.simple.HelloWorldMessageApp

Während die Anwendung ausgeführt wird, werden wir Folgendes sehen:

  • Die Anwendung sendet eine Nachricht an die Standardbörse mit "myQueue" als Routing-Schlüssel
  • Dann empfängt die Warteschlange "myQueue" die Nachricht
  • Schließlich verwendet die Listen- Methode die Nachricht aus "myQueue" und druckt sie auf der Konsole aus

Wir können auch die RabbitMQ-Verwaltungsseite unter // localhost: 15672 verwenden , um festzustellen , ob unsere Nachricht gesendet und verarbeitet wurde.

7. Fazit

In diesem Tutorial haben wir die messagingbasierte Architektur über das AMQP-Protokoll unter Verwendung von Spring AMQP für die Kommunikation zwischen Anwendungen behandelt.

Der vollständige Quellcode und alle Codefragmente für dieses Tutorial sind im GitHub-Projekt verfügbar.