Utiliser Swoole pour créer des applications PHP haute performance
Qu'est-ce que Swoole ?
Swoole est un framework de communication réseau haute performance pour PHP, offrant des fonctionnalités telles que l'asynchronicité, le multi-threading et les coroutines, permettant à PHP de gérer des tâches à haute concurrence comme Node.js. Il prend en charge divers protocoles, notamment TCP, UDP, UnixSocket, HTTP, WebSocket, etc., et est adapté pour construire des serveurs Web haute performance, des architectures de microservices, des systèmes de communication en temps réel, etc.
Principales caractéristiques et avantages de Swoole
- Haute performance : Swoole est écrit en C, offrant une performance exceptionnelle, supportant l'E/S asynchrone et les coroutines, capable de traiter des demandes à haute concurrence.
- Fonctionnalités riches : Prend en charge divers protocoles réseau, des minuteurs, la gestion des processus, la gestion de la mémoire et bien d'autres fonctionnalités, répondant à divers besoins de développement.
- Facilité d'utilisation : Fournit une API simple et une documentation riche, aidant les développeurs à démarrer rapidement.
- Grande extensibilité : Prend en charge les extensions et plugins personnalisés, permettant une personnalisation flexible selon les besoins.
Swoole est un choix idéal pour construire des applications Web haute performance et des systèmes de communication en temps réel, adapté pour des projets allant des petites applications aux grands systèmes d'entreprise.
Installer Swoole
Dans cet article, nous présenterons comment installer et utiliser Swoole dans un environnement ServBay.
TIP
ServBay recommande aux développeurs de placer le site Web dans le répertoire /Applications/ServBay/www
pour une gestion facile.
Étape 1 : Installer l'extension Swoole
Activer l'extension Swoole
ServBay inclut déjà l'extension Swoole, les utilisateurs doivent l'activer et redémarrer PHP. Veuillez vous référer à l'article Comment activer le module Swoole fourni avec ServBay pour activer le module Swoole.
Étape 2 : Créer le répertoire du projet
Créez le répertoire du projet et accédez-y :
cd /Applications/ServBay/www
mkdir servbay-swoole-app
cd servbay-swoole-app
2
3
Étape 3 : Créer le script du serveur Swoole
Dans le répertoire du projet, créez un fichier server.php
et écrivez un simple serveur HTTP Swoole :
<?php
use Swoole\Http\Server;
use Swoole\Http\Request;
use Swoole\Http\Response;
$server = new Server("0.0.0.0", 9501);
$server->on("start", function (Server $server) {
echo "Le serveur HTTP Swoole a démarré à l'adresse http://0.0.0.0:9501\n";
});
$server->on("request", function (Request $request, Response $response) {
$response->header("Content-Type", "text/plain");
$response->end("Bonjour ServBay!");
});
$server->start();
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
Étape 4 : Exécuter le serveur Swoole
Dans le terminal, exécutez la commande suivante pour démarrer le serveur Swoole :
php server.php
Vous verrez la sortie suivante :
Le serveur HTTP Swoole a démarré à l'adresse http://0.0.0.0:9501
Étape 5 : Accéder au serveur Swoole
Ouvrez votre navigateur et accédez à http://localhost:9501
, vous verrez la sortie de la page Bonjour ServBay!
.
Utiliser Swoole pour construire une application Web
Dans cette section, nous montrerons comment utiliser Swoole pour construire une simple application Web.
Créer des contrôleurs et des routes
Dans le répertoire du projet, créez un répertoire app
et à l'intérieur, créez les répertoires controllers
et routes
:
mkdir -p app/controllers
mkdir -p app/routes
2
Dans le répertoire app/controllers
, créez un fichier HomeController.php
:
<?php
namespace App\Controllers;
class HomeController
{
public function index()
{
return "Bienvenue sur ServBay!";
}
public function hello($name)
{
return "Bonjour, $name!";
}
}
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
Dans le répertoire app/routes
, créez un fichier web.php
:
<?php
use App\Controllers\HomeController;
return [
'GET /' => [HomeController::class, 'index'],
'GET /hello/{name}' => [HomeController::class, 'hello'],
];
2
3
4
5
6
7
8
Mettre à jour le script du serveur Swoole
Mettez à jour le fichier server.php
pour ajouter la logique d'analyse des routes et d'appel des contrôleurs :
<?php
use Swoole\Http\Server;
use Swoole\Http\Request;
use Swoole\Http\Response;
use FastRoute\RouteCollector;
use function FastRoute\simpleDispatcher;
require 'vendor/autoload.php';
$server = new Server("0.0.0.0", 9501);
$routes = require __DIR__ . '/app/routes/web.php';
$dispatcher = simpleDispatcher(function (RouteCollector $r) use ($routes) {
foreach ($routes as $route => $handler) {
list($method, $path) = explode(' ', $route);
$r->addRoute($method, $path, $handler);
}
});
$server->on("start", function (Server $server) {
echo "Le serveur HTTP Swoole a démarré à l'adresse http://0.0.0.0:9501\n";
});
$server->on("request", function (Request $request, Response $response) use ($dispatcher) {
$routeInfo = $dispatcher->dispatch($request->server['request_method'], $request->server['request_uri']);
switch ($routeInfo[0]) {
case \FastRoute\Dispatcher::NOT_FOUND:
$response->status(404);
$response->end('404 Not Found');
break;
case \FastRoute\Dispatcher::METHOD_NOT_ALLOWED:
$response->status(405);
$response->end('405 Method Not Allowed');
break;
case \FastRoute\Dispatcher::FOUND:
$handler = $routeInfo[1];
$vars = $routeInfo[2];
list($class, $method) = $handler;
$response->header("Content-Type", "text/plain");
$response->end(call_user_func_array([new $class, $method], $vars));
break;
}
});
$server->start();
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
Installer FastRoute
Dans le répertoire racine du projet, exécutez la commande suivante pour installer la bibliothèque de routage FastRoute :
composer require nikic/fast-route
Exécuter le serveur Swoole
Dans le terminal, exécutez la commande suivante pour démarrer le serveur Swoole :
php server.php
Accéder à l'application Web
Ouvrez votre navigateur et accédez aux URL suivantes :
http://localhost:9501/
: vous verrez la sortie de la pageBienvenue sur ServBay!
.http://localhost:9501/hello/ServBay
: vous verrez la sortie de la pageBonjour, ServBay!
.
Utiliser Swoole pour gérer les connexions WebSocket
Swoole prend également en charge le protocole WebSocket, pouvant être utilisé pour construire des applications de communication en temps réel. Nous montrerons comment utiliser Swoole pour gérer les connexions WebSocket.
Créer un script de serveur WebSocket
Dans le répertoire du projet, créez un fichier websocket_server.php
et écrivez un simple serveur WebSocket :
<?php
use Swoole\WebSocket\Server;
use Swoole\Http\Request;
use Swoole\WebSocket\Frame;
$server = new Server("0.0.0.0", 9502);
$server->on("start", function (Server $server) {
echo "Le serveur WebSocket Swoole a démarré à ws://0.0.0.0:9502\n";
});
$server->on("open", function (Server $server, Request $request) {
echo "connexion ouverte: {$request->fd}\n";
});
$server->on("message", function (Server $server, Frame $frame) {
echo "message reçu: {$frame->data}\n";
$server->push($frame->fd, "Bonjour, {$frame->data}");
});
$server->on("close", function ($ser, $fd) {
echo "connexion fermée: {$fd}\n";
});
$server->start();
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
Exécuter le serveur WebSocket
Dans le terminal, exécutez la commande suivante pour démarrer le serveur WebSocket:
php websocket_server.php
Vous verrez la sortie suivante :
Le serveur WebSocket Swoole a démarré à ws://0.0.0.0:9502
Connecter le serveur WebSocket
Vous pouvez utiliser un client WebSocket dans le navigateur ou d'autres outils client WebSocket (par exemple wscat
) pour vous connecter au serveur WebSocket.
Utiliser wscat
pour se connecter
Installer
wscat
:bashnpm install -g wscat
1Se connecter au serveur WebSocket :
bashwscat -c ws://localhost:9502
1Envoyer un message:
bash> Bonjour ServBay
1
Vous verrez le message renvoyé par le serveur :
< Bonjour, Bonjour ServBay
Grâce à ces étapes, vous avez réussi à créer et exécuter un projet Swoole et à utiliser les fonctionnalités offertes par Swoole pour gérer les requêtes HTTP et les connexions WebSocket. Les performances et la richesse des fonctionnalités de Swoole en font un choix idéal pour construire des applications à haute concurrence.