TOC

Messaging mit Spring AMQP

1. Überblick

In diesem Artikel werden wir die messagingbasierte Kommunikation über das AMQP-Protokoll unter Verwendung des Spring AMQP-Frameworks untersuchen. Zunächst werden einige der wichtigsten Konzepte von Messaging behandelt. In Abschnitt 5 werden praktische Beispiele beschrieben.

1.1. Abhängigkeiten von Maven

Um spring-amqp und spring-rabbit in Ihrem Projekt zu verwenden, fügen Sie einfach folgende Abhängigkeiten hinzu: 

<dependencies>
    <dependency>
        <groupId>org.springframework.amqp</groupId>
        <artifactId>spring-amqp</artifactId>
        <version>1.6.6.RELEASE</version>
    </dependency>
    <dependency>
        <groupId>org.springframework.amqp</groupId>
        <artifactId>spring-rabbit</artifactId>
        <version>1.6.6.RELEASE</version>
    </dependency>
</dependencies>

Die neuesten Versionen finden Sie unter https://search.maven.org/classic/#search%7Cga%7C1%7C(g%3A%22org.springframework.amqp%22%20AND%20a%3A%22spring-amqp % 22)% 20OR% 20 (g% 3A% 22org.springframework.amqp% 22% 20AND% 20a% 3A% 22spring-rabbit% 22)[Maven-Aufbewahrungsort].

** 2. Messaging-basierte Kommunikation____

__ **

Messaging ist eine Technik für die Kommunikation zwischen Anwendungen, bei der asynchrone Nachrichtenübermittlung anstelle einer auf Anforderungsantwort basierenden Architektur verwendet wird. Der Produzent und der Konsument von Nachrichten werden von einer zwischengeschalteten Nachrichtenschicht (Message-Broker) entkoppelt. Message Broker bietet Funktionen wie permanente Speicherung von Nachrichten, Nachrichtenfilterung, Nachrichtentransformation usw.

Bei einer Kommunikation zwischen Anwendungen, die in Java geschrieben sind, wird üblicherweise eine JMS-API (Java Message Service) zum Senden und Empfangen von Nachrichten verwendet. Für die Interoperabilität zwischen verschiedenen Anbietern und Plattformen können wir JMS-Clients und -Makler nicht verwenden. Hier kommt AMQP zum Einsatz.

** 3. AMQP - Erweitertes Message Queuing-Protokoll____

__ **

AMQP ist eine offene Standardspezifikation für asynchrone Messaging-basierte Kommunikation. Es enthält eine Beschreibung, wie eine Nachricht erstellt werden soll. Jedes Byte der übertragenen Daten wird angegeben.

3.1. Wie unterscheidet sich AMQP von JMS

Da AMQP ein plattformneutraler Binärprotokollstandard ist, können Bibliotheken in verschiedenen Programmiersprachen geschrieben und auf verschiedenen Betriebssystemen und CPU-Architekturen ausgeführt werden.

Es gibt keine herstellerbasierte Protokollsperre wie bei der Migration von einem JMS-Broker zu einem anderen. Weitere Informationen finden Sie unter JMS vs AMQP und https://spring.io/understanding/AMQP Einige der weit verbreiteten AMQP-Broker sind RabbitMQ, OpenAMQ und StormMQ.

** 3.2. AMQP-Entitäten____

__ **

  • AMQP-Entitäten umfassen Börsen, Warteschlangen und Bindungen

  • Börsen sind wie Postämter oder Briefkästen und Kunden immer

Eine Nachricht an eine AMQP-Börse veröffentlichen ** Warteschlangen werden mithilfe des Bindungsschlüssels ausgetauscht. Eine Bindung ist "Link"

dass Sie eine Warteschlange an eine Vermittlungsstelle binden ** Nachrichten werden mit einem Routing-Schlüssel an Message Broker/Exchange gesendet. Das

Exchange verteilt dann Kopien von Nachrichten an Warteschlangen. Exchange bietet die Abstraktion, um verschiedene Messaging-Routings wie Fanout, hierarchisches Routing usw. zu erreichen.

3.3. Austauscharten

  1. Es gibt vier eingebaute Austauscharten:

    • Direkter Austausch

    • Fanout-Austausch

    • Topic Exchange

    • Header austauschen

Weitere Informationen finden Sie unter AMQP Concepts und https://spring.io/blog/2011/04/01/routing-topologies- für Leistung und Skalierbarkeit mit rabbitmq/[Routingtopologien.]

** 4. Frühling AMQP____

__ **

Spring AMQP besteht aus zwei Modulen: Spring AmqP und Spring Rabbit, die jeweils durch ein Gefäß in der Verteilung dargestellt werden. Frühling-

Spring-Amqp ist die Basisabstraktion und Sie finden Klassen, die das AMQP-Kernmodell darstellen: Exchange, Queue und Binding.

In diesem Artikel werden wir die Besonderheiten von Frühling und Kaninchen behandeln.

** 4.1. spring-amqp Eigenschaften____

__ **

  • Template-basierte Abstraktion - Die AMQPTemplate-Schnittstelle definiert alle

Grundlegende Operationen zum Senden/Empfangen von Nachrichten mit RabbitTemplate als die Implementierung Unterstützung für Publisher-Bestätigungen/Consumer Acknowledgments

  • AmqpAdmin – tool zum Ausführen grundlegender Operationen

** 4.2. Frühlingskaninchen Features____

__ **

Das oben diskutierte AMQP-Modell und verwandte Entitäten sind generisch und auf alle Implementierungen anwendbar. Es gibt jedoch einige Funktionen, die für die Implementierung spezifisch sind. Ein paar dieser Feder-Kaninchen-Funktionen werden unten erklärt.

  • Connection Management Support ** - Die Schnittstelle org.springframework.amqp.rabbit.connection.ConnectionFactory ist die zentrale Komponente für die Verwaltung der Verbindungen zum RabbitMQ-Broker. Die CachingConnectionFactory -Implementierung der ConnectionFactory -Schnittstelle ist dafür verantwortlich, eine Instanz der org.springframework.amqp.rabbit.connection.Connection -Schnittstelle bereitzustellen.

Bitte beachten Sie, dass Spring-Rabbit die Connection -Schnittstelle als Wrapper über die RabbitMQ-Client- com.rabbitmq.client.Connection -Schnittstelle bereitstellt.

  • Asynchronous Message Consumption ** - Für den asynchronen Nachrichtenverbrauch sind zwei Schlüsselkonzepte ein Rückruf und ein Container. Der Rückruf ist der Ort, an dem Ihr Anwendungscode in das Messagingsystem integriert wird.

Eine Möglichkeit, einen Rückruf zu codieren, besteht darin, eine Implementierung der Schnittstelle MessageListener bereitzustellen: 

public interface MessageListener {
    void onMessage(Message message);
}

Um eine klare Trennung zwischen Anwendungscode und Messaging-API zu erreichen, stellt Spring AMQP auch MessageListenerAdapter bereit. Hier ist ein Spring Bean-Konfigurationsbeispiel für Listener-Container: 

MessageListenerAdapter listener = new MessageListenerAdapter(somePojo);
listener.setDefaultListenerMethod("myMethod");

Nachdem wir nun die verschiedenen Optionen für den Message-Listenback-Callback gesehen haben, können wir uns auf den Container konzentrieren. Grundsätzlich übernimmt der Container die "aktiven" Verantwortlichkeiten, so dass der Listener-Callback passiv bleiben kann. Der Container ist ein Beispiel für eine Lebenszykluskomponente. Es bietet Methoden zum Starten und Stoppen.

Beim Konfigurieren des Containers schließen Sie im Wesentlichen die Lücke zwischen einer AMQP-Warteschlange und der Instanz MessageListener . Standardmäßig startet der Listener-Container einen einzelnen Consumer, der Nachrichten von den Warteschlangen erhält.

** 5. Senden und Empfangen von Nachrichten mit Spring AMQP____

__ **

So senden und empfangen Sie eine Nachricht über Spring AMQP:

  1. Setup und Start RabbitMQ Broker - Die Installation und Einrichtung von RabbitMQ ist

Folgen Sie einfach den genannten Schritten hier . Java-Projekt einrichten - Erstellen Sie mit Maven ein Java-Projekt

oben genannten Abhängigkeiten . Implement Message Producer - Wir können RabbitTemplate verwenden, um eine

"Hallo Welt!" Nachricht:

+[Quelle, Java, Rinne:, wahr] 

AbstractApplicationContext ctx
  = new ClassPathXmlApplicationContext("beans.xml");
AmqpTemplate template = ctx.getBean(RabbitTemplate.class);
template.convertAndSend("Hello, world!");

  1. Implementiere Message Consumer - Wie bereits erwähnt, können wir implementieren

Nachrichtenverbraucher als POJO: 

public class Consumer {
    public void listen(String foo) {
        System.out.println(foo);
    }
}

  1. Wiring Abhängigkeiten - Wir werden folgende Spring Bean verwenden

Konfiguration für das Einrichten von Warteschlangen, den Austausch und andere Entitäten. Die meisten Einträge sind selbsterklärend. Die Warteschlange "myQueue" ist an Topic Exchange "myExchange" gebunden, wobei "foo. ** " Als Bindungsschlüssel verwendet wird.

RabbitTemplate wurde eingerichtet, um Nachrichten an den Austausch "myExchange" mit "foo.bar" als Standardrouting-Schlüssel zu senden. ListenerContainer gewährleistet eine asynchrone Übermittlung von Nachrichten aus der Warteschlange "myQueue" an die listen () -Methode der Foo -Klasse: 

<rabbit:connection-factory id="connectionFactory"
  host="localhost" username="guest" password="guest"/>

<rabbit:template id="amqpTemplate" connection-factory="connectionFactory"
    exchange="myExchange" routing-key="foo.bar"/>

<rabbit:admin connection-factory="connectionFactory"/>

<rabbit:queue name="myQueue"/>

<rabbit:topic-exchange name="myExchange">
    <rabbit:bindings>
        <rabbit:binding queue="myQueue" pattern="foo.** "/>
    </rabbit:bindings>
</rabbit:topic-exchange>

<rabbit:listener-container connection-factory="connectionFactory">
    <rabbit:listener ref="consumer" method="listen" queue-names="myQueue"/>
</rabbit:listener-container>

<bean id="consumer" class="com.baeldung.springamqp.consumer.Consumer"/>

  • Hinweis ** : Um sich mit der lokalen RabbitMQ-Instanz zu verbinden, verwenden Sie standardmäßig den Benutzernamen "guest" und das Passwort "guest".

    1. Führen Sie die Anwendung aus:

  • Der erste Schritt besteht darin, sicherzustellen, dass RabbitMQ ausgeführt wird, wobei der Standardport ist

  • Führen Sie die Anwendung aus, indem Sie Producer.java ausführen und main () ausführen.

Methode ** Producer sendet die Nachricht an "myExchange" mit "foo.bar" als

Routing-Schlüssel ** Gemäß dem Bindungsschlüssel von "myQueue" erhält er die Nachricht

  • Foo -Klasse, die Konsument von "myQueue" -Meldungen mit listen () ist

Methode, da der Rückruf die Nachricht empfängt und auf der Konsole ausgibt

6. Fazit

In diesem Artikel wurde die auf Messaging basierende Architektur über das AMQP-Protokoll mit Spring AMQP für die Kommunikation zwischen Anwendungen behandelt.

Den vollständigen Quellcode und alle Codeausschnitte für diesen Artikel finden Sie unter the GitHub[ .

Related