streamalism.org

1. Oversikt

I denne andre artikkelen fra serien som utforsker Spring Data Redis, ser vi på pub- / undermeldingskøene.

I Redis er ikke utgivere programmert til å sende meldinger til bestemte abonnenter. Snarere karakteriseres publiserte meldinger i kanaler, uten kjennskap til hvilke (om noen) abonnenter det kan være.

Tilsvarende uttrykker abonnenter interesse for ett eller flere emner og mottar bare meldinger som er av interesse, uten kunnskap om hvilke (om noen) utgivere det er.

Denne frakoblingen av utgivere og abonnenter kan gi større skalerbarhet og en mer dynamisk nettverkstopologi.

2. Redis-konfigurasjon

La oss begynne å legge til konfigurasjonen som kreves for meldingskøene.

Først definerer vi a MessageListenerAdapter bønne som inneholder en tilpasset implementering av MessageListener grensesnitt kalt RedisMessageSubscriber. Denne bønnen fungerer som abonnent i pub-sub-meldingsmodellen:

@Bean MessageListenerAdapter messageListener () {return new MessageListenerAdapter (new RedisMessageSubscriber ()); }

RedisMessageListenerContainer er en klasse levert av Spring Data Redis som gir asynkron oppførsel for Redis-meldingslyttere. Dette kalles internt, og ifølge Spring Data Redis-dokumentasjonen - "håndterer detaljer på lavt nivå om å lytte, konvertere og sende meldinger."

@Bean RedisMessageListenerContainer redisContainer () {RedisMessageListenerContainer container = ny RedisMessageListenerContainer (); container.setConnectionFactory (jedisConnectionFactory ()); container.addMessageListener (messageListener (), topic ()); returbeholder; }

Vi vil også lage en bønne ved hjelp av en spesialbygd MessagePublisher grensesnitt og en RedisMessagePublisher gjennomføring. På denne måten kan vi ha et generisk meldingspubliserings-API, og få Redis-implementeringen til å ta en redisTemplate og emne som konstruktørargumenter:

@Bean MessagePublisher redisPublisher () {returner ny RedisMessagePublisher (redisTemplate (), topic ()); }

Til slutt setter vi opp et emne som utgiveren vil sende meldinger til, og abonnenten vil motta dem:

@Bean ChannelTopic-emne () {returner nytt ChannelTopic ("messageQueue"); }

3. Publiseringsmeldinger

3.1. Definere MessagePublisher Grensesnitt

Spring Data Redis gir ikke en MessagePublisher grensesnitt som skal brukes til meldingsdistribusjon. Vi kan definere et tilpasset grensesnitt som skal brukes redisTemplate i implementering:

offentlig grensesnitt MessagePublisher {void publish (Strengmelding); }

3.2. RedisMessagePublisher Gjennomføring

Vårt neste trinn er å gi en implementering av MessagePublisher grensesnitt, legge til informasjon om publisering av meldinger og bruke funksjonene i redisTemplate.

Malen inneholder et veldig rikt sett med funksjoner for et bredt spekter av operasjoner - hvorav convertAndSend er i stand til å sende en melding til en kø gjennom et emne:

offentlig klasse RedisMessagePublisher implementerer MessagePublisher {@Autowired private RedisTemplate redisTemplate; @Autowired privat ChannelTopic emne; public RedisMessagePublisher () {} public RedisMessagePublisher (RedisTemplate redisTemplate, ChannelTopic topic) {this.redisTemplate = redisTemplate; this.topic = emne; } offentlig ugyldig publisering (streng melding) {redisTemplate.convertAndSend (topic.getTopic (), melding); }} 

Som du kan se, er implementeringen av utgiveren grei. Den bruker convertAndSend () metoden for redisTemplate for å formatere og publisere den gitte meldingen til det konfigurerte emnet.

Et emne implementerer publisering og abonnement på semantikk: når en melding blir publisert, går den til alle abonnentene som er registrert for å lytte til det emnet.

4. Abonnere på meldinger

RedisMessageSubscriber implementerer Spring Data Redis-levert MessageListener grensesnitt:

@Service offentlig klasse RedisMessageSubscriber implementerer MessageListener {public static List messageList = new ArrayList (); public void onMessage (Message message, byte [] pattern) {messageList.add (message.toString ()); System.out.println ("Melding mottatt:" + message.toString ()); }}

Merk at det er en andre parameter som heter mønster, som vi ikke har brukt i dette eksemplet. Spring Data Redis-dokumentasjonen sier at denne parameteren representerer "mønster som samsvarer med kanalen (hvis spesifisert)", men at den kan være null.

5. Sende og motta meldinger

Nå skal vi sette alt sammen. La oss opprette en melding og deretter publisere den ved hjelp av RedisMessagePublisher:

Strengmelding = "Melding" + UUID.randomUUID (); redisMessagePublisher.publish (melding);

Når vi ringer publiser (melding), innholdet sendes til Redis, der det blir dirigert til emnet for meldingskøen som er definert i utgiveren vår. Deretter distribueres den til abonnentene på det emnet.

Du har kanskje allerede lagt merke til det RedisMessageSubscriber er en lytter, som registrerer seg i køen for henting av meldinger.

Ved ankomst av meldingen, abonnentens onMessage () definert metode utløst.

I vårt eksempel kan vi bekrefte at vi har mottatt meldinger som er publisert ved å sjekke meldingsliste i vår RedisMessageSubscriber:

RedisMessageSubscriber.messageList.get (0) .contains (melding) 

6. Konklusjon

I denne artikkelen undersøkte vi en implementering av kø / undermeldingskø ved hjelp av Spring Data Redis.

Implementeringen av eksemplet ovenfor kan bli funnet i et GitHub-prosjekt.