Messaggistica con Spring AMQP

1. Panoramica

In questo tutorial, esploreremo la comunicazione basata su messaggi su AMQP utilizzando il framework Spring AMQP. Innanzitutto, tratteremo alcuni dei concetti chiave della messaggistica. Quindi, passeremo a un esempio pratico.

2. Comunicazione basata su messaggi

La messaggistica è una tecnica per la comunicazione tra le applicazioni. Si basa sul passaggio di messaggi asincrono invece che su un'architettura basata sulla risposta alla richiesta sincrona. Produttori e consumatori di messaggi vengono separati da un livello di messaggistica intermedio noto come broker di messaggi . Un broker di messaggi fornisce funzionalità come l'archiviazione persistente dei messaggi, il filtro dei messaggi e la trasformazione dei messaggi.

In un caso di messaggistica tra applicazioni scritte in Java, viene comunemente utilizzata l'API JMS (Java Message Service). Per l'interoperabilità tra diversi fornitori e piattaforme, non saremo in grado di utilizzare client e broker JMS. È qui che AMQP torna utile .

3. AMQP - Advanced Message Queuing Protocol

AMQP è una specifica cablata standard aperta per la comunicazione di messaggi asincroni. Fornisce una descrizione di come dovrebbe essere costruito un messaggio.

3.1. In che modo Amqp è diverso da Jms

Poiché AMQP è uno standard di protocollo binario indipendente dalla piattaforma, le librerie possono essere scritte in diversi linguaggi di programmazione ed essere eseguite su ambienti diversi.

Non esiste alcun blocco di protocollo basato sul fornitore, come nel caso della migrazione da un broker JMS a un altro. Per maggiori dettagli, fare riferimento a JMS vs AMQP e Understanding AMQP. Alcuni dei broker AMQP ampiamente utilizzati sono RabbitMQ , OpenAMQ e StormMQ.

3.2. Entità AMQP

In breve, AMQP è composto da scambi, code e associazioni:

  • Gli scambi sono come gli uffici postali o le cassette postali e i clienti pubblicano un messaggio in uno scambio AMQP. Ci sono quattro tipi di scambio integrati
    • Scambio diretto: instrada i messaggi a una coda facendo corrispondere una chiave di instradamento completa
    • Fanout Exchange: instrada i messaggi a tutte le code ad esso associate
    • Scambio di argomenti: instrada i messaggi a più code facendo corrispondere una chiave di instradamento a un modello
    • Headers Exchange: instrada i messaggi in base alle intestazioni dei messaggi
  • Le code sono associate a uno scambio utilizzando una chiave di instradamento
  • I messaggi vengono inviati a uno scambio con una chiave di instradamento. Lo scambio quindi distribuisce copie dei messaggi alle code

Per maggiori dettagli, dai un'occhiata ai concetti di AMQP e alle topologie di routing.

3.3. Primavera AMQP

Spring AMQP comprende due moduli: spring-amqp e spring-rabbit . Insieme, questi moduli forniscono astrazioni per:

  • Entità AMQP: creiamo entità con le classi Message, Queue, Binding e Exchange

  • Gestione della connessione: ci colleghiamo al nostro broker RabbitMQ utilizzando una CachingConnectionFactory
  • Pubblicazione dei messaggi: utilizziamo un RabbitTemplate per inviare messaggi
  • Consumo di messaggi: utilizziamo un @RabbitListener per leggere i messaggi da una coda

4. Imposta un broker Rabbitmq

Abbiamo bisogno di un broker RabbitMQ disponibile a cui connetterci. Il modo più semplice per farlo è utilizzare Docker per recuperare ed eseguire un'immagine RabbitMQ per noi:

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

Esponiamo la porta 5672 in modo che la nostra applicazione possa connettersi a RabbitMQ.

Inoltre, esponiamo la porta 15672 in modo da poter vedere cosa sta facendo il nostro broker RabbitMQ tramite l'interfaccia utente di gestione: // localhost: 15672 o l'API HTTP: //localhost:15672/api/index.html .

5. Creazione della nostra applicazione Spring Amqp

Quindi, ora creiamo la nostra applicazione per inviare e ricevere un semplice "Hello, world!" messaggio utilizzando Spring AMQP.

5.1. Dipendenze di Maven

Per aggiungere i moduli spring-amqp e spring-rabbit al nostro progetto, aggiungiamo la dipendenza spring-boot-starter-amqp al nostro pom.xml :

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

Possiamo trovare l'ultima versione su Maven Central.

5.2. Connessione al nostro broker Rabbitmq

Useremo la configurazione automatica di primavera di avvio per creare i nostri ConnectionFactory , RabbitTemplate e RabbitAdmin fagioli . Di conseguenza, otteniamo una connessione al nostro broker RabbitMQ sulla porta 5672 utilizzando il nome utente e la password predefiniti di "guest". Quindi, annotiamo la nostra applicazione con @SpringBootApplication :

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

5.3. Crea la nostra coda

Per creare la nostra coda, definiamo semplicemente un bean di tipo Queue . RabbitAdmin lo troverà e lo legherà allo scambio predefinito con una chiave di instradamento di "myQueue":

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

Impostiamo la coda in modo che non sia durevole in modo che la coda e tutti i messaggi su di essa vengano rimossi quando RabbitMQ viene arrestato. Nota, tuttavia, che il riavvio della nostra applicazione non avrà alcun effetto sulla coda.

5.4. Invia il nostro messaggio

Usiamo il RabbitTemplate per inviare il nostro "Hello, world!" Messaggio:

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

5.5. Consuma il nostro messaggio

Implementeremo un consumer di messaggi annotando un metodo con @RabbitListener :

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

6. Esecuzione della nostra applicazione

Innanzitutto, avviamo il broker RabbitMQ:

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

Quindi, eseguiamo l'applicazione di avvio primaverile eseguendo HelloWorldMessage.java , eseguendo il metodo main () :

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

Mentre l'applicazione è in esecuzione vedremo che:

  • L'applicazione invia un messaggio allo scambio predefinito con "myQueue" come chiave di instradamento
  • Quindi, la coda "myQueue" riceve il messaggio
  • Infine, il metodo di ascolto consuma il messaggio da "myQueue" e lo stampa sulla console

Possiamo anche usare la pagina di gestione RabbitMQ su // localhost: 15672 per vedere che il nostro messaggio è stato inviato e consumato.

7. Conclusione

In questo tutorial, abbiamo trattato l'architettura basata sulla messaggistica sul protocollo AMQP utilizzando Spring AMQP per la comunicazione tra le applicazioni.

Il codice sorgente completo e tutti i frammenti di codice per questo tutorial sono disponibili nel progetto GitHub.