Méthodes de déduplication des messages de file d'attente et de traitement de l'idempotence des messages dans PHP et MySQL

Méthodes de déduplication des messages en file d'attente et de traitement de l'idempotence des messages en PHP et MySQL

Dans le développement réel, nous utilisons souvent des files d'attente de messages pour traiter des tâches asynchrones afin d'améliorer les performances et la fiabilité du système. Cependant, lors de l’utilisation de files d’attente, nous rencontrons souvent des problèmes de déduplication des messages et de traitement idempotent. Cet article présentera quelques méthodes courantes de gestion de la déduplication des messages et de l'idempotence des messages dans PHP et MySQL, et donnera des exemples de code spécifiques.

1. Méthode de traitement de la déduplication des messages

La déduplication des messages signifie que si le même message existe déjà dans la file d'attente des messages, il ne sera pas traité à plusieurs reprises. Il existe plusieurs manières de gérer la déduplication des messages. Voici une méthode de traitement de déduplication basée sur Redis :

a) Utilisation de l'ensemble ordonné Redis ZADD

Tout d'abord, nous pouvons utiliser l'ensemble ordonné de Redis pour effectuer le traitement de déduplication des messages. Nous utilisons l'identifiant unique du message en tant que membre de l'ensemble ordonné, et l'horodatage du message comme score de l'ensemble ordonné. Lorsqu'un nouveau message est reçu, nous pouvons utiliser la commande ZADD pour ajouter l'identifiant unique et l'horodatage du message à la collection commandée. Ensuite, nous pouvons utiliser la commande ZSCORE pour interroger l'horodatage du message. Si l'horodatage se situe dans une certaine plage de seuil, le message est considéré comme existant et ne sera plus traité.

Ce qui suit est un exemple de code de déduplication de message basé sur Redis :

connect('127.0.0.1', 6379); function processMessage($message) { $messageId = generateUniqueId($message); $timestamp = time(); // 判断消息是否已经存在 $existingTimestamp = $redis->zscore('message:deduplication', $messageId); // 如果消息存在并且时间戳在一定范围内，则不进行处理 if ($existingTimestamp && $timestamp - $existingTimestamp <= 60) { return; } // 处理消息 // ... // 将消息的唯一标识和时间戳添加到有序集合中 $redis->zadd('message:deduplication', $timestamp, $messageId); } function generateUniqueId($message) { // 生成消息的唯一标识 // ... return $uniqueId; }

Dans le code ci-dessus, nous générons d'abord l'identifiant unique du message via la fonctiongenerateUniqueId. Ensuite, utilisez la commandezscorepour interroger l'horodatage du message afin de déterminer si le message existe déjà et si l'horodatage se situe dans une certaine plage. Si le message existe déjà, aucun traitement n'est effectué. Sinon, le message est traité et l'identifiant unique et l'horodatage du message sont ajoutés à l'ensemble ordonné.generateUniqueId函数生成消息的唯一标识。然后，通过zscore命令查询消息的时间戳，判断消息是否已经存在，并且时间戳在一定范围内。如果消息已经存在，则不进行处理，否则，进行消息的处理，并将消息的唯一标识和时间戳添加到有序集合中。

b) 使用MySQL表的唯一索引

除了Redis，我们还可以利用MySQL表的唯一索引来进行消息的去重处理。我们可以创建一个消息表，表中包含一个唯一索引字段，用来存储消息的唯一标识。当收到一条新消息时，我们尝试向消息表中插入一条记录，如果插入失败，则说明消息已经存在，不再进行处理。否则，进行消息的处理。

下面是一个基于MySQL的消息去重处理的代码示例：

query($sql)) { // 插入成功，处理消息 // ... } else { // 消息已经存在，不再处理 } } function generateUniqueId($message) { // 生成消息的唯一标识 // ... return $uniqueId; }

在上面的代码中，我们通过generateUniqueId函数生成消息的唯一标识。然后，尝试向message_deduplication表中插入一条记录，使用INSERT IGNORE语句避免插入重复的记录。如果插入成功，则说明消息不存在，进行消息的处理；否则，说明消息已经存在，不再进行处理。

2. 消息幂等性处理方法

消息幂等性是指对于同一条消息的多次处理，只会产生一次业务影响。处理消息幂等性的方法有多种。下面给出一种基于数据库的幂等性处理方法：

a) 在处理消息前查询数据库状态

在处理消息时，我们可以在数据库中创建一个状态表，用来记录消息的处理状态。当收到一条新消息时，首先查询状态表，判断消息是否已经处理。如果消息已经处理，则不进行处理；否则，进行消息的处理，并将消息的处理状态更新到状态表中。

下面是一个基于MySQL的消息幂等性处理的代码示例：

query($sql); if ($result && $result->num_rows > 0) { $row = $result->fetch_assoc(); $status = $row['status']; // 如果处理状态为已处理，则不再处理 if ($status == 1) { return; } } // 处理消息 // ... // 更新处理状态 $sql = "INSERT INTO message_processing (message_id, status) VALUES ('$messageId', 1) ON DUPLICATE KEY UPDATE status = 1"; $mysqli->query($sql); } function generateUniqueId($message) { // 生成消息的唯一标识 // ... return $uniqueId; }

在上面的代码中，我们首先通过generateUniqueId函数生成消息的唯一标识。然后，通过查询message_processing

Méthode de traitement de l'idempotence des messagesL'idempotence des messages signifie que le traitement multiple du même message n'aura qu'un seul impact commercial. Il existe plusieurs façons de gérer l’idempotence des messages. Ce qui suit est une méthode de traitement idempotent basée sur une base de données : a) Interroger l'état de la base de données avant de traiter le message Lors du traitement du message, nous pouvons créer une table d'état dans la base de données pour enregistrer l'état de traitement du message. Lorsqu'un nouveau message est reçu, la table d'état est d'abord interrogée pour déterminer si le message a été traité. Si le message a été traité, aucun traitement n'est effectué ; sinon, le message est traité et l'état de traitement du message est mis à jour dans la table d'état. Ce qui suit est un exemple de code de traitement de l'idempotence de message basé sur MySQL : rrreeeDans le code ci-dessus, nous générons d'abord l'identifiant unique du message via la fonction generateUniqueId. Ensuite, déterminez l'état de traitement du message en interrogeant la table message_processing. Si le statut de traitement est traité, aucun autre traitement ne sera effectué. Si le statut de traitement est non traité, le message sera traité et le statut de traitement sera mis à jour sur traité. Résumé : Voici quelques méthodes courantes pour gérer la déduplication des messages et l'idempotence des messages en PHP et MySQL. Dans le développement réel, nous pouvons choisir la méthode appropriée en fonction des besoins spécifiques et de l'architecture du système. Qu'il s'agisse d'un traitement de déduplication basé sur Redis ou d'un traitement idempotent basé sur MySQL, ils peuvent nous aider à mieux traiter les messages dans la file d'attente et à améliorer la fiabilité et les performances du système.

Ce qui précède est le contenu détaillé de. pour plus d'informations, suivez d'autres articles connexes sur le site Web de PHP en chinois!