streamalism.org

1. Oversigt

I denne anden artikel fra serien, der udforsker Spring Data Redis, kigger vi på pub- / undermeddelelseskøerne.

I Redis er udgivere ikke programmeret til at sende deres beskeder til bestemte abonnenter. Snarere karakteriseres offentliggjorte meddelelser i kanaler uden viden om, hvilke (hvis nogen) abonnenter der kan være.

Tilsvarende udtrykker abonnenter interesse for et eller flere emner og modtager kun beskeder, der er af interesse, uden viden om hvilke (hvis nogen) udgivere der er.

Denne afkobling af udgivere og abonnenter kan muliggøre større skalerbarhed og en mere dynamisk netværkstopologi.

2. Redis-konfiguration

Lad os begynde at tilføje den konfiguration, der kræves til meddelelseskøerne.

Først definerer vi en MessageListenerAdapter bønne, som indeholder en brugerdefineret implementering af MessageListener grænseflade kaldes RedisMessageSubscriber. Denne bønne fungerer som abonnent i pub-sub-meddelelsesmodellen:

@Bean MessageListenerAdapter messageListener () {returner ny MessageListenerAdapter (ny RedisMessageSubscriber ()); }

RedisMessageListenerContainer er en klasse, der leveres af Spring Data Redis, som giver asynkron opførsel til Redis-beskedlyttere. Dette kaldes internt og ifølge Spring Data Redis-dokumentationen - "håndterer detaljerne på det lave niveau ved at lytte, konvertere og sende meddelelser."

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

Vi opretter også en bønne ved hjælp af en specialbygget MessagePublisher interface og en RedisMessagePublisher implementering. På denne måde kan vi have et generisk API til meddelelsesudgivelse og få Redis-implementeringen til at tage en redisTemplate og emne som konstruktørargumenter:

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

Endelig opretter vi et emne, som udgiveren sender meddelelser til, og abonnenten modtager dem:

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

3. Udgivelse af meddelelser

3.1. Definition af MessagePublisher Interface

Spring Data Redis giver ikke en MessagePublisher interface, der skal bruges til meddelelsesdistribution. Vi kan definere en brugerdefineret grænseflade, som skal bruges redisTemplate i implementering:

offentlig grænseflade MessagePublisher {ugyldig udgivelse (streng besked); }

3.2. RedisMessagePublisher Implementering

Vores næste trin er at give en implementering af MessagePublisher interface, tilføjelse af meddelelsespubliceringsoplysninger og brug af funktionerne i redisTemplate.

Skabelonen indeholder et meget rigt sæt funktioner til en lang række operationer - hvoraf convertAndSend er i stand til at sende en besked til en kø gennem et emne:

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

Som du kan se, er implementeringen af ​​udgiveren ligetil. Det bruger convertAndSend () metode til redisTemplate at formatere og udgive den givne besked til det konfigurerede emne.

Et emne implementerer udgivelse og abonnering af semantik: Når en meddelelse offentliggøres, går den til alle de abonnenter, der er registreret, for at lytte til dette emne.

4. Abonnere på meddelelser

RedisMessageSubscriber implementerer Spring Data Redis-leveret MessageListener grænseflade:

@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 ("Besked modtaget:" + besked.tilString ()); }}

Bemærk, at der er en anden parameter kaldet mønster, som vi ikke har brugt i dette eksempel. Spring Data Redis-dokumentationen siger, at denne parameter repræsenterer "mønster, der matcher kanalen (hvis det er specificeret)", men at det kan være nul.

5. Afsendelse og modtagelse af meddelelser

Nu sætter vi det hele sammen. Lad os oprette en besked og derefter offentliggøre den ved hjælp af RedisMessagePublisher:

String message = "Message" + UUID.randomUUID (); redisMessagePublisher.publish (besked);

Når vi ringer publicer (besked), indholdet sendes til Redis, hvor det dirigeres til det emne for meddelelseskø, der er defineret i vores udgiver. Derefter distribueres det til abonnenterne på dette emne.

Du har måske allerede bemærket det RedisMessageSubscriber er en lytter, der registrerer sig i køen til hentning af meddelelser.

Ved ankomsten af ​​meddelelsen abonnentens onMessage () metode defineret udløst.

I vores eksempel kan vi kontrollere, at vi har modtaget meddelelser, der er offentliggjort ved at kontrollere beskedliste i vores RedisMessageSubscriber:

RedisMessageSubscriber.messageList.get (0). Indeholder (meddelelse) 

6. Konklusion

I denne artikel undersøgte vi en implementering af kø / pub-meddelelseskø ved hjælp af Spring Data Redis.

Implementeringen af ​​ovenstående eksempel kan findes i et GitHub-projekt.