Guide du débutant sur les bases de la programmation réseau Swoole

Avec le développement et la vulgarisation continus d'Internet, la technologie de programmation réseau est devenue l'une des compétences nécessaires pour de nombreux programmeurs. Dans ce domaine, Swoole est un très excellent framework de communication réseau. Swoole est un module d'extension de PHP qui fournit de puissantes fonctions de programmation réseau telles que les E/S asynchrones, le multi-processus et la coroutine, et peut bien résoudre des problèmes tels qu'une concurrence élevée et des performances élevées. Cet article vous présentera le guide d'introduction de base de Swoole à la programmation réseau.

1. Installation et configuration de Swoole

L'installation de Swoole nécessite une version PHP supérieure à 7.0, et phpize et php-config doivent être installés. Vous pouvez l'installer via la commande suivante :

$ git clone https://github.com/swoole/swoole-src.git
$ cd swoole-src
$ phpize
$ ./configure
$ make && make install

Une fois l'installation terminée. , ajoutez ce qui suit à la configuration php.ini :

extension=swoole.so

2. Utilisation de base de Swoole

1 Créer un serveur TCP

Swoole peut créer un serveur TCP via le code suivant et écouter le port local 9501 :

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

. 2. Écoutez les événements

Le serveur doit écouter les événements du client tels que la connexion du terminal, la réception de données, la fermeture de la connexion, etc. Vous pouvez écouter via le code suivant :

$server->on('connect', function ($serv, $fd) {
    echo "Client: connect.
";
});

$server->on('receive', function ($serv, $fd, $from_id, $data) {
    $serv->send($fd, "Server: ".$data);
});

$server->on('close', function ($serv, $fd) {
    echo "Client: close.
";
});

Dans le code ci-dessus, la méthode on est utilisée pour lier le nom de l'événement et la fonction de rappel.

3. Démarrez le serveur

Après avoir terminé la surveillance des événements, vous devez exécuter le code suivant pour démarrer le serveur :

$server->start();

À ce stade, un serveur TCP a été créé avec succès. Il peut être testé via des outils tels que telnet.

3. Créer un serveur UDP

Swoole peut également créer un serveur UDP, et son utilisation est similaire à celle d'un serveur TCP. Voici un exemple de code pour créer un serveur UDP :

$server = new SwooleServer("0.0.0.0", 9502, SWOOLE_PROCESS, SWOOLE_SOCK_UDP);

$server->on('Packet', function ($server, $data, $clientInfo) {
    $server->sendto($clientInfo['address'], $clientInfo['port'], "Server ".$data);
});

$server->start();

Dans le code ci-dessus, un serveur UDP est créé pour écouter le port 9502 de la machine locale. Lorsque les données sont envoyées au serveur, l'événement Packet est déclenché et les données sont renvoyées au client.

4. Créer un serveur WebSocket

Swoole peut également créer un serveur WebSocket. WebSocket est un protocole de communication full-duplex basé sur le protocole TCP. Voici un exemple de code pour créer un serveur WebSocket :

$server = new SwooleWebSocketServer("0.0.0.0", 9503);

$server->on('open', function (SwooleWebSocketServer $server, $request) {
    echo "server: handshake success with fd{$request->fd}
";
});

$server->on('message', function (SwooleWebSocketServer $server, $frame) {
    echo "receive from {$frame->fd}:{$frame->data},opcode:{$frame->opcode},fin:{$frame->finish}
";
    $server->push($frame->fd, "this is server");
});

$server->on('close', function ($ser, $fd) {
    echo "client {$fd} closed
";
});

$server->start();

Dans le code ci-dessus, un serveur WebSocket est créé pour écouter le port 9503 de la machine locale. Lorsqu'un client se connecte, l'événement open est déclenché. Lorsqu'un client envoie un message, l'événement de message est déclenché et le message est renvoyé tel quel au client. Lorsqu'un client ferme la connexion, l'événement close est déclenché.

3. Utilisation avancée de Swoole

1. Utiliser la tâche asynchrone Task

La fonction Task fournie par Swoole peut traiter de manière asynchrone une logique métier fastidieuse sans bloquer l'exécution du processus principal. Voici l'exemple de code de la tâche :

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

$server->on('receive', function ($serv, $fd, $from_id, $data) {
    $task_id = $serv->task($data); //投递异步任务
    echo "Dispath AsyncTask: id=$task_id
";
});

$server->on('task', function ($serv, $task_id, $from_id, $data) {
    echo "New AsyncTask[id=$task_id]".PHP_EOL;
    // 处理异步任务
    $serv->finish("$data -> OK");
});

$server->on('finish', function ($serv, $task_id, $data) {
    echo "AsyncTask[$task_id] Finish: $data".PHP_EOL;
});

$server->start();

Dans l'exemple de code ci-dessus, lorsqu'un client envoie des données au serveur, la tâche sera publiée dans la file d'attente des tâches et la tâche asynchrone sera traitée dans l'événement onTask. Une fois le traitement de la tâche terminé, l'événement onFinish sera appelé pour renvoyer les résultats du traitement au client.

2. Utiliser des coroutines

Les coroutines sont une méthode de programmation simultanée fournie par Swoole, qui peut atteindre des dizaines de millions de niveaux de traitement simultané dans un seul thread. Voici un exemple de code pour utiliser la coroutine :

Coun(function () {
    $client = new SwooleCoroutineClient(SWOOLE_SOCK_TCP);

    if (!$client->connect('127.0.0.1', 9501, 0.5)) {
        echo "connect failed. Error: {$client->errCode}
";
    }

    $client->send("hello swoole");

    $res = $client->recv();
    echo $res;

    $client->close();
});

Dans l'exemple de code ci-dessus, une tâche de coroutine est créée à l'aide de Coun, un client TCP est créé via SwooleCoroutineClient et la méthode de connexion est utilisée pour se connecter. Lorsque la connexion est établie avec succès, utilisez la méthode send pour envoyer un message et utilisez la méthode recv pour recevoir le résultat de retour. Enfin, utilisez la méthode close pour fermer la connexion.

IV. Résumé

Cet article présente l'utilisation de base du cadre de programmation réseau Swoole et démontre l'utilisation du serveur TCP, du serveur UDP, du serveur WebSocket, des tâches asynchrones, des coroutines et d'autres fonctions via un exemple de code. Swoole est flexible et performant et peut obtenir d'excellents résultats dans de nombreux scénarios. Cependant, les développeurs doivent également posséder certaines connaissances sous-jacentes et une réflexion en matière de programmation ciblée. Je pense que les lecteurs peuvent avoir une compréhension et une application préliminaires de Swoole grâce à l'introduction de cet article.

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!