Berichten verzenden met Spring AMQP

1. Overzicht

In deze zelfstudie onderzoeken we berichtgebaseerde communicatie via AMQP met behulp van het Spring AMQP-framework. Eerst behandelen we enkele van de belangrijkste concepten van berichtenuitwisseling. Daarna gaan we verder met een praktisch voorbeeld.

2. Op berichten gebaseerde communicatie

Messaging is een techniek om tussen applicaties te communiceren. Het is gebaseerd op het asynchroon doorgeven van berichten in plaats van op een architectuur op basis van synchrone verzoeken. Producenten en consumenten van berichten worden ontkoppeld door een tussenliggende berichtenlaag die bekend staat als een berichtenmakelaar. Een Message Broker biedt functies zoals permanente opslag van berichten, berichtfiltering en berichttransformatie.

In het geval van berichtenuitwisseling tussen applicaties die in Java zijn geschreven, wordt doorgaans de JMS-API (Java Message Service) gebruikt. Voor interoperabiliteit tussen verschillende leveranciers en platforms kunnen we geen JMS-clients en -makelaars gebruiken. Dit is waar AMQP van pas komt.

3. AMQP - Advanced Message Queuing Protocol

AMQP is een open standaard draadspecificatie voor asynchrone berichtcommunicatie. Het geeft een beschrijving van hoe een bericht moet worden opgebouwd.

3.1. Hoe Amqp verschilt van Jms

Omdat AMQP een platformneutrale binaire protocolstandaard is, kunnen bibliotheken in verschillende programmeertalen worden geschreven en in verschillende omgevingen worden uitgevoerd.

Er is geen protocolvergrendeling op basis van een leverancier, zoals het geval is bij het migreren van de ene JMS-broker naar de andere. Raadpleeg voor meer details JMS versus AMQP en AMQP begrijpen. Enkele van de meest gebruikte AMQP-makelaars zijn RabbitMQ, OpenAMQ en StormMQ.

3.2. AMQP-entiteiten

In het kort bestaat AMQP uit uitwisselingen, wachtrijen en bindingen:

  • Uitwisselingen zijn als postkantoren of mailboxen en klanten publiceren een bericht naar een AMQP-centrale. Er zijn vier ingebouwde uitwisseltypes
    • Directe uitwisseling - Routeert berichten naar een wachtrij door een volledige routingsleutel te matchen
    • Fanout Exchange - Routeert berichten naar alle wachtrijen die eraan zijn gebonden
    • Onderwerpuitwisseling - Routeert berichten naar meerdere wachtrijen door een routeringssleutel aan een patroon te koppelen
    • Headers Exchange - Routeert berichten op basis van berichtkoppen
  • Wachtrijen zijn gebonden aan een centrale met behulp van een routingsleutel
  • Berichten worden met een routingsleutel naar een centrale gestuurd. De centrale distribueert vervolgens kopieën van berichten naar wachtrijen

Bekijk voor meer details AMQP-concepten en routeringstopologieën.

3.3. Lente AMQP

Spring AMQP bestaat uit twee modules: lente-amqp en lente-konijn. Samen bieden deze modules abstracties voor:

  • AMQP-entiteiten - we maken entiteiten met de Bericht, wachtrij, binding en uitwisseling klassen

  • Verbindingsbeheer - we maken verbinding met onze RabbitMQ-makelaar door een CachingConnectionFactory
  • Message Publishing - we gebruiken een KonijnTemplate om berichten te verzenden
  • Berichtconsumptie - we gebruiken een @RabbitListener om berichten uit een wachtrij te lezen

4. Stel een Rabbitmq-makelaar in

We hebben een RabbitMQ-makelaar nodig waarmee we verbinding kunnen maken. De eenvoudigste manier om dit te doen is door Docker te gebruiken om een ​​RabbitMQ-image voor ons op te halen en uit te voeren:

havenarbeider run -d -p 5672: 5672 -p 15672: 15672 --naam mijn-konijn konijnmq: 3-beheer

We stellen poort 5672 bloot zodat onze applicatie verbinding kan maken met RabbitMQ.

En we stellen poort 15672 bloot zodat we kunnen zien wat onze RabbitMQ-makelaar doet via de beheerinterface: // localhost: 15672 of de HTTP API: //localhost:15672/api/index.html.

5. Het maken van onze Spring Amqp-applicatie

Dus laten we nu onze applicatie maken om een ​​simpele "Hallo wereld!" bericht met behulp van Spring AMQP.

5.1. Afhankelijkheden van Maven

Om het lente-amqp en lente-konijn modules aan ons project toevoegen, voegen we de spring-boot-starter-amqp afhankelijkheid van onze pom.xml:

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

We kunnen de nieuwste versie vinden op Maven Central.

5.2. Verbinding maken met onze Rabbitmq-makelaar

We gebruiken de automatische configuratie van Spring Boot om onze ConnectionFactory, KonijnTemplate, en RabbitAdmin bonen. Als resultaat krijgen we een verbinding met onze RabbitMQ-makelaar op poort 5672 met behulp van de standaard gebruikersnaam en wachtwoord van "guest". Dus we annoteren onze applicatie gewoon met @SpringBootApplication:

@SpringBootApplication openbare klasse HelloWorldMessageApp {// ...}

5.3. Maak onze wachtrij

Om onze wachtrij te creëren, definiëren we eenvoudig een soort bean Wachtrij.RabbitAdmin zal dit vinden en het aan de standaarduitwisseling binden met de routingsleutel "myQueue":

@Bean openbare wachtrij myQueue () {retourneer nieuwe wachtrij ("myQueue", false); }

We stellen de wachtrij in op niet-duurzaam, zodat de wachtrij en eventuele berichten erop worden verwijderd wanneer RabbitMQ wordt gestopt. Merk echter op dat het herstarten van onze applicatie geen effect heeft op de wachtrij.

5.4. Stuur ons bericht

Laten we gebruik de KonijnTemplate versturen onze "Hallo wereld!" bericht:

rabbitTemplate.convertAndSend ("myQueue", "Hallo wereld!");

5.5. Consumeer onze boodschap

We implementeren een berichtconsument door een methode te annoteren met @RabbitListener:

@RabbitListener (queues = "myQueue") public void listen (String in) {System.out.println ("Bericht gelezen van myQueue:" + in); }

6. Onze applicatie uitvoeren

Eerst starten we de RabbitMQ-makelaar:

havenarbeider run -d -p 5672: 5672 -p 15672: 15672 --naam mijn-konijn konijnmq: 3-beheer

Vervolgens voeren we de Spring Boot-applicatie uit door te draaien HelloWorldMessage.java, het uitvoeren van het hoofd() methode:

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

Terwijl de applicatie draait, zullen we zien dat:

  • De applicatie stuurt een bericht naar de standaardcentrale met “myQueue” als de routingsleutel
  • Vervolgens ontvangt de wachtrij "myQueue" het bericht
  • eindelijk, de luister methode verbruikt het bericht van "myQueue" en drukt het af op de console

We kunnen ook de RabbitMQ-beheerpagina gebruiken op // localhost: 15672 om te zien dat ons bericht is verzonden en verbruikt.

7. Conclusie

In deze zelfstudie hebben we de op berichten gebaseerde architectuur via het AMQP-protocol behandeld met Spring AMQP voor communicatie tussen applicaties.

De volledige broncode en alle codefragmenten voor deze tutorial zijn beschikbaar op het GitHub-project.