Swoole met en œuvre des fonctions sociales performantes

Avec le développement rapide des médias sociaux, de plus en plus d'entreprises et de particuliers doivent mettre en œuvre des fonctions sociales dans leurs sites Web ou applications pour mieux interagir et communiquer avec les utilisateurs. Afin d'obtenir des fonctions sociales à haute concurrence et à faible latence, les développeurs doivent choisir des outils et des frameworks hautes performances. Parmi eux, Swoole est un très bon choix.

Swoole est un framework de communication réseau asynchrone et hautes performances basé sur PHP. Il est conçu pour améliorer les performances des applications Web, en particulier lors du traitement de requêtes simultanées élevées. Swoole peut être intégré de manière transparente aux éléments de langage conventionnels de PHP. Il fournit également des API pour exploiter directement les coroutines sous-jacentes, TCP, UDP, les sockets Unix, HTTP, WebSocket et d'autres protocoles réseau, permettant aux développeurs de mettre en œuvre plus facilement diverses tâches hautes performances.

Explorons comment utiliser Swoole pour mettre en œuvre des fonctions sociales performantes.

1. Implémentation du service WebSocket

WebSocket est un protocole très important lors de la mise en œuvre de fonctions sociales. Il prend en charge la transmission de données bidirectionnelle en temps réel, permettant au serveur d'envoyer des messages au client en temps réel et permettant également au client d'interagir avec le serveur en temps réel. Dans Swoole, nous pouvons utiliser la classe swoole_websocket_server pour implémenter le service WebSocket.

Ce qui suit est un exemple simple :

$server = new swoole_websocket_server("0.0.0.0", 9501);

$server->on('open', function (swoole_websocket_server $server, $request) {
    echo "WebSocket客户端{$request->fd}已连接
";
});

$server->on('message', function (swoole_websocket_server $server, $frame) {
    echo "来自客户端{$frame->fd}的消息：{$frame->data}
";
    $server->push($frame->fd, "这是来自服务器的回复");
});

$server->on('close', function ($server, $fd) {
    echo "WebSocket客户端{$fd}已关闭
";
});

$server->start();

Dans cet exemple, nous créons un serveur WebSocket et écoutons le port 9501, imprimant des journaux lorsque le client se connecte ou se déconnecte des informations. Lors de la réception d'un message du client, le serveur imprime le contenu du message et répond par un message.

2. Utilisez des coroutines pour effectuer des requêtes HTTP et des messages push

Swoole prend en charge les coroutines, ce qui nous permet d'effectuer des requêtes HTTP plus facilement et de manière asynchrone tâches et autres opérations. Lors de la mise en œuvre de fonctions sociales, nous devons souvent effectuer des requêtes HTTP, telles que l'obtention des informations personnelles de l'utilisateur, de sa liste d'amis et d'autres informations. Voici un exemple d'utilisation du client HTTP coroutine Swoole :

co(function () {
    $cli = new SwooleCoroutineHttpClient('www.example.com', 80);
    $cli->set(['timeout' => 1]);
    $cli->setHeaders([
        'Host' => 'www.example.com',
        'User-Agent' => 'Chrome/49.0.2587.3',
        'Accept' => 'text/html,application/xhtml+xml,application/xml',
        'Accept-Encoding' => 'gzip',
    ]);
    $cli->get('/path/to/api');

    echo $cli->body;
});

Dans cet exemple, nous utilisons la classe SwooleCoroutineHttpClient pour effectuer des requêtes HTTP. Cette classe est un client coroutine qui peut implémenter des opérations de requête HTTP asynchrones. Avant d'envoyer une demande, nous pouvons définir le délai d'expiration de la demande et les informations d'en-tête de la demande. Après avoir exécuté la requête, nous pouvons obtenir le contenu de la réponse via $cli->body.

Ensuite, nous pouvons utiliser la requête HTTP coroutine adressée au client dans le serveur WebSocket pour obtenir des informations utilisateur et les transmettre au client. Par exemple, lors de l'obtention du profil de l'utilisateur, nous pouvons utiliser le code suivant :

$server->on('message', function (swoole_websocket_server $server, $frame) {
    $path = '/user/profile?id=' . $frame->data;
    $cli = new SwooleCoroutineHttpClient('www.example.com', 80);
    $cli->set(['timeout' => 1]);
    $cli->setHeaders([
        'Host' => 'www.example.com',
        'User-Agent' => 'Chrome/49.0.2587.3',
        'Accept' => 'text/html,application/xhtml+xml,application/xml',
        'Accept-Encoding' => 'gzip',
    ]);
    $cli->get($path);

    $profile = json_decode($cli->body, true);

    $server->push($frame->fd, json_encode($profile));
});

Dans cet exemple, nous avons reçu un message via le serveur WebSocket indiquant que nous souhaitons obtenir le profil de l'utilisateur. Nous utilisons la classe SwooleCoroutineHttpClient pour effectuer des requêtes HTTP et analyser les données JSON de réponse dans le tableau $profile. Enfin, le contenu de $profile est transmis au client via WebSocket.

3. Utilisez le client Swoole Redis pour la mise en cache

La mise en cache est une exigence très courante lors de la mise en œuvre de fonctions sociales. Afin d'améliorer l'efficacité de la lecture des données, nous devons souvent utiliser des outils de mise en cache tels que Redis pour mettre les données en cache. Dans Swoole, vous pouvez utiliser le client Swoole Redis pour interagir rapidement avec les instances Redis.

Ce qui suit est un exemple d'utilisation du client Swoole Redis :

$redis = new SwooleCoroutineRedis();
$redis->connect('127.0.0.1', 6379);
$redis->set('key', 'value');
$value = $redis->get('key');

Dans cet exemple, nous utilisons la classe SwooleCoroutineRedis pour implémenter les fonctions du client Redis, ce qui peut faire traitement des données très pratique Opérations de lecture et d'écriture.

Pour les scénarios d'application de mise en cache, par exemple, lors de l'obtention de la liste d'amis, nous pouvons mettre en cache les données dans Redis Lorsque l'utilisateur demande la liste d'amis, les données sont d'abord lues à partir de Redis. existent dans le cache, les données sont lues dans la base de données et mises en cache dans Redis. Cela peut réduire considérablement la charge sur la base de données et améliorer l'efficacité de la lecture des données.

4. Implémenter des fonctions de diffusion et de chat privé

Dans les applications sociales, les fonctions de diffusion et de chat privé sont également essentielles. La fonction de diffusion permet d'envoyer des messages à tous les utilisateurs en ligne en même temps, tandis que la fonction de chat privé permet une communication peer-to-peer en temps réel entre les utilisateurs. Dans Swoole, ces deux fonctions peuvent être réalisées via le serveur WebSocket.

Ce qui suit est une implémentation simple :

$server->on('message', function (swoole_websocket_server $server, $frame) {
    $data = json_decode($frame->data, true);
    switch ($data['command']) {
        case 'broadcast':
            $server->push('broadcast', $data['message']);
            break;
        case 'private':
            $server->push($data['id'], $data['message']);
            break;
    }
});

Dans cet exemple, nous effectuons des opérations de diffusion ou de chat privé en jugeant le type de message reçu. Si le type de message reçu est diffusé, le message sera transmis à tous les utilisateurs en ligne ; si le type de message reçu est privé, le message sera transmis à l'utilisateur spécifié.

Dans le client WebSocket, nous devons également effectuer quelques ajustements correspondants, comme rejoindre la salle de diffusion pour recevoir des messages diffusés :

let ws = new WebSocket('ws://localhost:9501');
ws.onopen = function () {
    // 加入broadcast房间
    ws.send(JSON.stringify({command: 'join', room: 'broadcast'}));
};
ws.onmessage = function (event) {
    let data = JSON.parse(event.data);
    // 处理广播消息
    if (data.room === 'broadcast') {
        console.log(data.message);
    }
};

Dans cet exemple, nous utilisons When the Le client WebSocket rejoint la salle de diffusion, il peut recevoir les messages diffusés par le serveur et les afficher dans la console.

Résumé

Grâce à la démonstration ci-dessus, nous pouvons voir que Swoole fournit des fonctions très puissantes et riches qui peuvent nous aider à atteindre des fonctions sociales à haute concurrence et à faible latence. Dans les applications pratiques, nous devons sélectionner des outils et des solutions appropriés en fonction de besoins et de scénarios spécifiques pour améliorer l'expérience utilisateur et la maintenabilité 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!