Meldinger med våren AMQP

1. Oversikt

I denne opplæringen vil vi utforske meldingsbasert kommunikasjon over AMQP ved hjelp av Spring AMQP-rammeverket. Først skal vi dekke noen av nøkkelbegrepene for meldinger. Deretter går vi videre til et praktisk eksempel.

2. Meldingsbasert kommunikasjon

Meldinger er en teknikk for kommunikasjon mellom applikasjoner. Den er avhengig av asynkron overføring av meldinger i stedet for synkron forespørselsbasert arkitektur. Produsenter og forbrukere av meldinger blir frikoplet av et mellomliggende meldingslag kjent som en meldingsmegler. En meldingsmegler gir funksjoner som vedvarende lagring av meldinger, meldingsfiltrering og transformasjon av meldinger.

I tilfelle meldinger mellom applikasjoner skrevet i Java, brukes JMS (Java Message Service) API ofte. For interoperabilitet mellom forskjellige leverandører og plattformer, vil vi ikke kunne bruke JMS-klienter og meglere. Det er her AMQP kommer til nytte.

3. AMQP - Advanced Message Queuing Protocol

AMQP er en åpen standard ledningsspesifikasjon for asynkron kommunikasjon. Den gir en beskrivelse av hvordan en melding skal konstrueres.

3.1. Hvordan Amqp er forskjellig fra Jms

Siden AMQP er en plattformnøytral binær protokollstandard, kan biblioteker skrives på forskjellige programmeringsspråk og kjøres i forskjellige miljøer.

Det er ingen leverandørbasert protokollåsing, slik tilfellet er når du migrerer fra en JMS-megler til en annen. For mer informasjon, se JMS vs AMQP og Understanding AMQP. Noen av de mye brukte AMQP-meglerne er RabbitMQ, OpenAMQ og StormMQ.

3.2. AMQP-enheter

Kortfattet består AMQP av utvekslinger, køer og bindinger:

Børs er som postkontorer eller postkasser, og klienter publiserer en melding til en AMQP-sentral. Det er fire innebygde byttetyper
- Direkte utveksling - Ruter meldinger til en kø ved å matche en komplett rutingnøkkel
- Fanout Exchange - Ruter meldinger til alle køene som er knyttet til den
- Emneutveksling - Ruter meldinger til flere køer ved å matche en rutingnøkkel til et mønster
- Headers Exchange - Ruter meldinger basert på meldingsoverskrifter
Køer er bundet til en sentral ved hjelp av en rutingnøkkel
Meldinger blir sendt til en sentral med en rutingnøkkel. Sentralen distribuerer deretter kopier av meldinger til køer

For mer informasjon, ta en titt på AMQP Concepts and Routing Topologies.

3.3. Vår AMQP

Vår AMQP består av to moduler: vår-amqp og vår-kanin. Til sammen gir disse modulene abstraksjoner for:

AMQP-enheter - vi oppretter enheter med Melding, kø, innbinding og utveksling klasser
Connection Management - vi kobler til RabbitMQ-megleren vår ved å bruke en CachingConnectionFactory
Message Publishing - vi bruker en RabbitTemplate for å sende meldinger
Melding forbruk - vi bruker en @RabbitListener for å lese meldinger fra en kø

4. Sett opp en Rabbitmq megler

Vi trenger en RabbitMQ-megler tilgjengelig for oss å koble til. Den enkleste måten å gjøre dette på er å bruke Docker til å hente og kjøre et RabbitMQ-bilde for oss:

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

Vi avslører port 5672 slik at applikasjonen vår kan koble til RabbitMQ.

Og vi avslører port 15672 slik at vi kan se hva vår RabbitMQ-megler gjør via enten administrasjonsgrensesnittet: // lokal vert: 15672 eller HTTP API: //localhost:15672/api/index.html.

5. Opprette vår Amqp-applikasjon

Så la oss nå lage vår applikasjon for å sende og motta en enkel "Hei verden!" melding ved å bruke Spring AMQP.

5.1. Maven avhengigheter

For å legge til vår-amqp og vår-kanin moduler til prosjektet vårt, legger vi til spring-boot-starter-amqp avhengighet til vår pom.xml:

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

Vi finner den nyeste versjonen på Maven Central.

5.2. Koble til vår Rabbitmq megler

Vi bruker Spring Boots automatiske konfigurasjon for å lage vår ConnectionFactory, RabbitTemplate, og RabbitAdmin bønner. Som et resultat får vi en forbindelse til RabbitMQ-megleren vår på port 5672 ved å bruke standard brukernavn og passord til "gjest". Så vi bare kommenterer søknaden vår med @SpringBootApplication:

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

5.3. Lag vår kø

For å lage vår kø, definerer vi ganske enkelt en type bønne Kø.RabbitAdmin finner dette og binder det til standardutvekslingen med en rutingnøkkel på “myQueue”:

@Bean offentlig kø myQueue () {returner ny kø ("myQueue", falsk); }

Vi setter køen til ikke å være holdbar, slik at køen og eventuelle meldinger på den blir fjernet når RabbitMQ stoppes. Vær imidlertid oppmerksom på at omstart av applikasjonen ikke vil ha noen innvirkning på køen.

5.4. Send vår melding

La oss bruke RabbitTemplate å sende vår “Hei, verden!” beskjed:

rabbitTemplate.convertAndSend ("myQueue", "Hei, verden!");

5.5. Bruk vårt budskap

Vi implementerer en meldingsforbruker ved å kommentere en metode med @RabbitListener:

@RabbitListener (køer = "myQueue") offentlig ugyldig lytte (String in) {System.out.println ("Melding lest fra myQueue:" + inn); }

6. Kjører applikasjonen vår

Først starter vi RabbitMQ-megleren:

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

Deretter kjører vi vårstartprogrammet ved å kjøre HelloWorldMessage.java, utfører hoved() metode:

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

Mens applikasjonen kjører, ser vi at:

Applikasjonen sender en melding til standardutvekslingen med “myQueue” som rutingnøkkel
Deretter mottar køen “myQueue” meldingen
Til slutt, lytte metoden forbruker meldingen fra “myQueue” og skriver den ut på konsollen

Vi kan også bruke RabbitMQ-administrasjonssiden på // lokal vert: 15672 for å se at meldingen vår er sendt og fortært.

7. Konklusjon

I denne veiledningen dekket vi meldingsbasert arkitektur over AMQP-protokollen ved hjelp av Spring AMQP for kommunikasjon mellom applikasjoner.

Den komplette kildekoden og alle kodebitene for denne opplæringen er tilgjengelig på GitHub-prosjektet.

streamalism.org