Swoole met en œuvre un système de publication et d'abonnement hautement fiable

Avec le développement d'Internet, de plus en plus d'applications doivent mettre en œuvre le push et l'abonnement aux messages en temps réel. Cela nécessite un système de publication et d'abonnement hautement fiable pour répondre à cette demande. Swoole, en tant que cadre de communication réseau hautes performances, peut bien répondre à cette demande.

Swoole est un module d'extension du langage PHP, qui peut fournir une communication réseau asynchrone, parallèle et hautes performances et des capacités de traitement simultané multi-processus. Les applications développées sur la base de Swoole peuvent prendre en charge une concurrence plus élevée et un temps de réponse plus court. Dans cet article, nous présenterons comment utiliser Swoole pour mettre en œuvre un système de publication et d'abonnement hautement fiable.

1. Concepts de base du système de publication-abonnement

Le système de publication-abonnement est un modèle de messagerie qui prend en charge la publication et l'abonnement de messages un à plusieurs. L'éditeur publie des messages sur un ou plusieurs sujets, et les abonnés peuvent s'abonner à ces sujets en fonction de leurs propres intérêts pour recevoir les messages correspondants.

Les systèmes de publication et d'abonnement se composent généralement de trois parties : les éditeurs, les abonnés et les courtiers de messages (Message Broker). Les éditeurs envoient des messages aux courtiers de messages et les abonnés s'abonnent aux messages des courtiers de messages. Les éditeurs et les abonnés ne communiquent pas directement. Le courtier de messages est responsable du routage des messages vers les abonnés correspondants.

2. Les concepts de base de Swoole

Avant de comprendre Swoole pour implémenter le système de publication et d'abonnement, nous devons comprendre certains concepts de base de Swoole.

1. Processus

Dans Swoole, un processus fait référence à un environnement d'exécution indépendant. Swoole fournit une prise en charge multi-processus et peut réaliser un traitement simultané en créant plusieurs processus.

2. Serveur

Le serveur est le module central du framework Swoole et peut créer un serveur TCP ou UDP. Lorsque le serveur démarre, il créera un processus principal et plusieurs sous-processus. Le processus principal est responsable de l'écoute sur le port et les sous-processus gèrent les requêtes spécifiques.

3. Timer

Swoole fournit une fonction de minuterie qui peut exécuter un morceau de code dans un intervalle de temps spécifié. Les minuteries peuvent être utilisées dans des scénarios tels que des tâches planifiées et des contrôles planifiés.

4. Coroutine

Coroutine est un thread léger qui peut exécuter plusieurs coroutines simultanément dans un seul thread. Les coroutines peuvent implémenter une programmation asynchrone et éviter la surcharge liée au changement de thread dans la programmation multithread traditionnelle. Swoole prend en charge les coroutines, qui peuvent être utilisées pour implémenter une programmation réseau à haute concurrence.

3. Étapes pour mettre en œuvre un système de publication et d'abonnement avec Swoole

Ensuite, nous présenterons comment utiliser Swoole pour mettre en œuvre un système de publication et d'abonnement. Afin de réduire la complexité du code, nous utiliserons l'interrogation active des abonnés pour implémenter la fonction d'abonnement.

1. Créer un courtier de messages

Nous devons d'abord créer un courtier de messages, qui est chargé de recevoir les messages et de les acheminer vers les abonnés correspondants. Nous pouvons utiliser le serveur TCP et les fonctions de gestion de processus fournies par Swoole pour implémenter des courtiers de messages.

$server = new SwooleServer('0.0.0.0', 8080, SWOOLE_PROCESS);
$server->set([
    'worker_num' => 2,
    'daemonize' => false,
]);
$server->on('WorkerStart', function($serv, $worker_id) {
    // 创建消息队列
    $queue_key = ftok(__FILE__, 'a');
    $queue = msg_get_queue($queue_key, 0666 | IPC_CREAT);
    // 将消息队列作为全局变量存放起来
    global $message_queue;
    $message_queue = $queue;
    // 启动消息处理进程
    if ($worker_id == 0) {
        $process = new SwooleProcess(function($process) {
            global $message_queue;
            while (true) {
                // 从消息队列中获取消息
                if (msg_receive($message_queue, 0, $msg_type, 1024, $msg, true, MSG_IPC_NOWAIT)) {
                    // 将消息发送给对应的订阅者
                    // TODO:实现发送消息的逻辑
                }
                // 隔一段时间循环一次
                usleep(100);
            }
        }, false, false);
        $process->start();
    }
});
$server->on('Connect', function($serv, $fd) {
    echo "Client[$fd]: Connect.
";
});
$server->on('Receive', function($serv, $fd, $from_id, $data) {
    global $message_queue;
    // 接收到消息，将消息存放到消息队列
    if (msg_send($message_queue, 1, $data, true, true)) {
        echo "Received message: $data
";
    } else {
        echo "Failed to send message to message queue.
";
    }
});
$server->on('Close', function($serv, $fd) {
    echo "Client[$fd]: Close.
";
});
$server->start();

Dans le code ci-dessus, nous avons créé un serveur TCP et mis en place 2 processus enfants. Lorsque chaque processus enfant démarre, nous créons une file d'attente de messages et la stockons dans la variable globale $message_queue. Dans le premier sous-processus, nous créons un processus de traitement de message, qui récupérera le message de la file d'attente des messages et l'enverra à l'abonné correspondant. Lors de la réception d'un message, nous stockons le message dans la file d'attente des messages via la fonction msg_send.

2. Implémenter la fonction d'abonnement

La fonction d'abonnement signifie que les abonnés peuvent choisir les sujets auxquels ils doivent s'abonner en fonction de leurs propres intérêts, recevant ainsi des messages pertinents. Nous pouvons implémenter la fonction d'abonnement via la coroutine de Swoole.

$client = new SwooleClient(SWOOLE_SOCK_TCP);
if (!$client->connect('127.0.0.1', 8080)) {
    echo "Failed to connect to server.
";
    exit(1);
}
// 订阅主题
if (!$client->send("subscribe:topic1")) {
    echo "Failed to send subscribe message.
";
    exit(1);
}
// 接收消息
while (true) {
    $data = $client->recv();
    if ($data === false) {
        echo "Failed to receive message.
";
        break;
    }
    if (empty($data)) {
        continue;
    }
    echo "Received message: $data
";
}
$client->close();

Dans le code ci-dessus, nous créons un client TCP et nous connectons au port du courtier de messages. Les messages d'abonnement sont envoyés via la fonction d'envoi et le sujet d'abonnement est topic1. Lors de la réception de messages, nous utilisons une boucle pour vérifier s'il y a de nouveaux messages et utilisons la fonction recv pour bloquer et attendre de nouveaux messages.

3. Implémenter la fonction de publication

La fonction de publication signifie que l'éditeur peut publier des messages sur le sujet spécifié. Nous pouvons utiliser le client TCP de Swoole pour implémenter la fonction de publication.

$client = new SwooleClient(SWOOLE_SOCK_TCP);
if (!$client->connect('127.0.0.1', 8080)) {
    echo "Failed to connect to server.
";
    exit(1);
}
// 发布消息
if (!$client->send("publish:topic1:message1")) {
    echo "Failed to send publish message.
";
    exit(1);
}
$client->close();

Dans le code ci-dessus, nous créons un client TCP et nous connectons au port du courtier de messages. Publiez des messages via la fonction d'envoi. Le sujet de publication est topic1 et le contenu du message est message1.

4. Résumé

Swoole est un puissant framework de programmation réseau qui peut nous aider à mettre en œuvre des applications réseau hautes performances et à haute concurrence. Cet article explique comment utiliser Swoole pour implémenter un système de publication et d'abonnement hautement fiable, qui comprend principalement la création d'un agent de message, la mise en œuvre de fonctions d'abonnement et de fonctions de publication. L'utilisation de Swoole pour implémenter un système de publication et d'abonnement peut améliorer les performances et la fiabilité du système et convient à divers scénarios d'application nécessitant des fonctions de messagerie.

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!