Explication détaillée du mode de publication et d'abonnement de messagerie de Redis, de la prise en main à la maîtrise [chapitre avancé]

0. Préface

Le modèle Publish-Subscribe (Publish-Subscribe Pattern) est un modèle de messagerie dont le principe de base est que l'expéditeur (éditeur) du message n'envoie pas directement le message à un destinataire spécifique (abonné), mais divise le message en différentes catégories ( canaux), puis envoyer des messages à tous les récepteurs abonnés à ces catégories. Le modèle de publication-abonnement est largement utilisé dans les systèmes distribués, tels que la diffusion de messages en temps réel, la collecte de journaux, etc.

Dans Redis, le modèle de publication-abonnement a deux rôles principaux : éditeur et abonné. L'éditeur envoie un message au canal spécifié via la commande PUBLISH, et l'abonné s'abonne/se désabonne du canal spécifié via la commande SUBSCRIBE, et reçoit le message envoyé par l'éditeur via l'écouteur (rappel).
La figure suivante montre le canal channel1 et la relation entre les trois clients abonnés à ce canal - client2, client5 et client1 :

Lorsqu'un nouveau message est envoyé au canal channel1 via la commande PUBLISH, ce message sera envoyé aux trois clients qui y sont abonnés :

1. Principes de base

La publication-abonnement Redis est un mode de communication de messages, par lequel plusieurs clients peuvent publier et s'abonner à des messages. Redis fournit les commandes suivantes pour implémenter les fonctions de publication et d'abonnement :

1. PUBLIER le message du canal : envoyez le message au canal de canal spécifié et la valeur de retour est le nombre d'abonnés qui ont reçu le message.
2. ABONNEZ-VOUS au canal [canal …] : abonnez-vous à un ou plusieurs canaux de canal, et chaque fois que de nouveaux messages sont publiés sur les canaux auxquels vous êtes abonné, les messages correspondants seront reçus.
3. UNSUBSCRIBE [canal [canal …]] : désabonnez-vous d'un ou plusieurs canaux, si aucun canal n'est spécifié, désabonnez-vous de tous les canaux.
4. Modèle PSUBSCRIBE [modèle ...] : abonnez-vous à un ou plusieurs canaux correspondant au modèle de modèle spécifié, et chaque fois qu'un nouveau message est publié sur un canal correspondant au modèle, le message correspondant sera reçu.
5. PUNSUBSCRIBE [motif [motif ...]] : désabonnez-vous d'un ou plusieurs canaux correspondant au modèle de modèle spécifié, si aucun modèle n'est spécifié, désabonnez-vous de tous les modèles.
6. Sous-commande PUBSUB [argument [argument …]] : Affichez l'état du système d'abonnement et de publication, qui peut être utilisé pour obtenir diverses informations sur le système d'abonnement et de publication, telles que le nombre d'abonnés, la liste des chaînes, etc. Parmi eux, la
   commande PUBLISH est utilisée pour publier des messages sur le canal spécifié, la commande SUBSCRIBE est utilisée pour s'abonner à un ou plusieurs canaux, la commande PSUBSCRIBE est utilisée pour
   s'abonner à un ou plusieurs canaux qui répondent au mode spécifié, et la commande PUBSUB La commande est utilisée pour afficher l'état du système d'abonnement et de publication.

1.1 Publication/abonnement par canal

Les chaînes dans Redis sont équivalentes à la classification des messages. Une chaîne peut avoir plusieurs abonnés, et un abonné peut également s'abonner à plusieurs chaînes. Dans Redis, envoyez un message au canal spécifié via la commande PUBLISH, et abonnez-vous/désabonnez-vous au canal spécifié via la commande SUBSCRIBE, et recevez le message envoyé par l'éditeur via l'écouteur.

Voici un exemple de pub/sub basé sur le canal dans l'interface de ligne de commande Redis :

# 订阅频道
127.0.0.1:6379> SUBSCRIBE news
Reading messages... (press Ctrl-C to quit)
1) "subscribe"
2) "news"
3) (integer) 1

# 发布消息
127.0.0.1:6379> PUBLISH news "Hello, world!"
(integer) 1

# 订阅者接收到消息
1) "message"
2) "news"
3) "Hello, world!"

Dans Redis, l'implémentation du mode publication/abonnement est basée sur le mécanisme d'événement Redis, c'est-à-dire que l'abonné ajoute son propre écouteur à la boucle d'événements du serveur Redis en exécutant la commande SUBSCRIBE. Lorsque l'éditeur envoie un message au canal spécifié via la commande PUBLIER, le serveur Redis enverra le message à tous les abonnés écoutant le canal.

Plus précisément, le serveur Redis maintient une boucle d'événements et y enregistre tous les écouteurs clients. Lorsqu'un client s'abonne à un canal via la commande SUBSCRIBE, le serveur Redis ajoute l'écouteur du client au gestionnaire d'événements associé au canal et enregistre le gestionnaire d'événements dans le looper d'événements. Lorsque l'éditeur envoie un message au canal spécifié via la commande PUBLISH, le serveur Redis enverra le message à tous les écouteurs du gestionnaire d'événements lié au canal, afin de réaliser la publication et l'abonnement du message.

1.2 Publication/abonnement basé sur des modèles

Redis prend également en charge Pub/Sub basé sur des modèles, qui sont des canaux spéciaux pouvant correspondre à un ou plusieurs canaux. Dans Redis, abonnez/désabonnez-vous aux canaux correspondant au modèle spécifié via la commande PSUBSCRIBE et recevez les messages envoyés par l'éditeur via l'écouteur.

Voici un exemple de pub/sub basé sur un schéma dans l'interface de ligne de commande Redis :

# 订阅模式
127.0.0.1:6379> PSUBSCRIBE news.*
Reading messages... (press Ctrl-C to quit)
1) "psubscribe"
2) "news.*"
3) (integer) 1

# 发布消息
127.0.0.1:6379> PUBLISH news.world "Hello, world!"
(integer) 1

# 订阅者接收到消息
1) "pmessage"
2) "news.*"
3) "news.world"
4) "Hello, world!"

La publication/l'abonnement basé sur un modèle est similaire à la publication/l'abonnement basé sur le canal, sauf que des caractères génériques (*) peuvent être utilisés pour faire correspondre plusieurs canaux lors de l'abonnement, afin d'obtenir un filtrage et un abonnement des messages plus flexibles.

Plus précisément, lorsqu'un client s'abonne à un modèle via la commande PSUBSCRIBE, le serveur Redis ajoute l'écouteur du client à tous les gestionnaires d'événements liés au canal correspondant au modèle et enregistre l'événement dans le processeur de boucle d'événements. Lorsque l'éditeur envoie un message au canal correspondant au modèle via la commande PUBLISH, le serveur Redis enverra le message à tous les écouteurs du gestionnaire d'événements lié au modèle, réalisant ainsi la publication et l'abonnement des messages basés sur le modèle.

2. Application pratique de la publication et de l'abonnement Redis

2.1 Sentinelle Redis

Redis Sentinel est une solution haute disponibilité pour Redis. En cas de défaillance du nœud maître, il peut automatiquement promouvoir le nœud esclave en nœud maître pour réaliser le basculement. Redis Sentinel utilise un mécanisme de publication-abonnement pour découvrir de nouveaux nœuds et échanger l'état entre les nœuds maîtres, et les clients peuvent également obtenir des informations sur l'état du basculement du nœud maître en s'abonnant à des canaux spécifiques.

Dans Redis Sentinel, chaque nœud Sentinel enverra périodiquement des messages au canal sentinelle :hello, et chaque nœud Sentinel s'abonnera également à ce canal, de sorte qu'une fois qu'un nœud envoie un message à ce canal, les autres nœuds peuvent recevoir le message immédiatement, et Ajoutez ce nœud à la liste des nœuds locaux. De plus, chaque fois qu'un message est envoyé à ce canal, il peut contenir les informations d'état du nœud, qui seront utilisées comme base pour l'élection ultérieure du leader Sentinel.

Pour le client, vous pouvez obtenir les informations d'état du basculement du nœud maître en vous abonnant au canal +switch-master. Une fois que Redis Sentinel a terminé le basculement du nœud maître, il publie le message du nœud maître, et le client peut recevoir le message et basculer vers le nouveau nœud maître à temps, garantissant ainsi la fiabilité et la disponibilité du système.

Le nœud Redis Sentinel utilise principalement le mécanisme de publication-abonnement pour réaliser la découverte de nouveaux nœuds et échanger le statut entre les nœuds maîtres. Comme le montre la figure ci-dessus, chaque nœud Sentinel enverra régulièrement des messages au canal sentinelle :hello, et chaque Sentinel s'abonnera à ce nœud. De cette façon, une fois qu'un nœud envoie un message à ce canal, les autres nœuds peuvent recevoir le message immédiatement.
De cette façon, une fois qu'un nouveau nœud se joint, il envoie un message à ce canal. Après que d'autres nœuds l'ont reçu, ils jugent que la liste locale n'a pas ce nœud, ils peuvent donc être ajoutés à la liste de nœuds locaux en tant que nouveau nœud. .

De plus, chaque fois qu'un message est envoyé à ce canal, le contenu des informations d'état du nœud peut être inclus, ce qui peut être utilisé comme base pour l'élection ultérieure du chef Sentinel.

Tout ce qui précède concerne le serveur Redis, et pour le client, nous pouvons également utiliser le mécanisme de publication-abonnement.
Lorsque Redis Sentinel effectue le basculement du nœud maître, chaque étape de ce processus sera fournie en externe via la publication et l'abonnement.
Pour notre client, nous sommes plus préoccupés par le nœud maître après la commutation, afin que nous puissions basculer la connexion du nœud maître à temps (l'ancien nœud est en panne à ce moment et ne peut plus accepter les instructions de fonctionnement), le client peut souscrire au canal +switch-master, une fois que
Redis Sentinel publiera le message du nœud maître après le basculement du nœud maître.

2.1 SpringBoot Redis publier/s'abonner

Dans Spring Boot, la fonction de publication/abonnement Redis peut être réalisée via les classes RedisMessageListenerContainer et RedisTemplate fournies par Spring Data Redis. Les étapes spécifiques sont les suivantes :

1. Ajoutez les dépendances Redis et Spring Data Redis :

<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-data-redis</artifactId>
</dependency>

2. Configurez les informations de connexion Redis :

spring.redis.host=localhost
spring.redis.port=6379

3. Créez des instances RedisMessageListenerContainer et RedisTemplate :

@Configuration
public class RedisConfig {
    
    
    
    @Autowired
    private RedisConnectionFactory redisConnectionFactory;

    @Bean
    public RedisMessageListenerContainer messageListenerContainer() {
    
    
        RedisMessageListenerContainer container = new RedisMessageListenerContainer();
        container.setConnectionFactory(redisConnectionFactory);
        return container;
    }

    @Bean
    public RedisTemplate<String, Object> redisTemplate() {
    
    
        RedisTemplate<String, Object> template = new RedisTemplate<>();
        template.setConnectionFactory(redisConnectionFactory);
        template.setDefaultSerializer(new StringRedisSerializer());
        return template;
    }
}

4. Créez un écouteur de message :

@Component
public class MessageListener implements MessageListenerAdapter {
    
    

    @Override
    public void onMessage(Message message, byte[] pattern) {
    
    
        String msg = (String) redisTemplate().getValueSerializer().deserialize(message.getBody());
        System.out.println("Received message: " + msg);
    }
}

5. Abonnez-vous aux nouvelles :

@Autowired
private RedisMessageListenerContainer container;

@Autowired
private MessageListener listener;

@PostConstruct
public void subscribe() {
    
    
    container.addMessageListener(listener, new PatternTopic("news.*"));
}

6. faire une annonce:

@Autowired
private RedisTemplate<String, Object> redisTemplate;

public void publish() {
    
    
    redisTemplate.convertAndSend("news.world", "Hello, world!");
}

Lors de l'utilisation du mode publication/abonnement Redis, des problèmes tels que les capacités de traitement simultané des abonnés, la sérialisation et la désérialisation des messages doivent être pris en compte pour garantir la fiabilité et les performances du système.

3. Redis de l'entrée à la série d'articles de compétence

"Redis de l'entrée à la compétence [avancé] : explication détaillée de l'AOF persistant"
"Redis de l'entrée à la compétence [avancé] : explication détaillée de la RDB persistante"
"Redis de l'entrée à la compétence [avancé] : le dictionnaire de structure de données sous-jacent (Dictionnaire) Explication détaillée"
"Redis de l'entrée à la compétence [articles de haut niveau] : explication détaillée de la structure de données sous-jacente QuickList" "
Redis de l'entrée à la compétence [articles avancés] explication détaillée de la structure de données sous-jacente Simple Dynamic String (SDS)"
" Redis de l'entrée à la maîtrise [chapitre avancé] explication détaillée de la liste de compression de la structure de données sous-jacente (ZipList)" "
Redis de l'entrée à la maîtrise [chapitre avancé] explication détaillée et exemples d'utilisation du type de données Stream"