Creare applicazioni PHP ad alte prestazioni con Swoole
Cos'è Swoole?
Swoole è un framework di comunicazione di rete ad alte prestazioni per PHP, che offre funzionalità asincrone, multithreading e coroutine, permettendo a PHP di gestire compiti ad alta concorrenza come fa Node.js. Supporta vari protocolli tra cui TCP, UDP, UnixSocket, HTTP, WebSocket ed è adatto per costruire server Web ad alte prestazioni, architetture di microservizi, sistemi di comunicazione in tempo reale, ecc.
Caratteristiche principali e vantaggi di Swoole
- Alte prestazioni: Swoole è scritto in linguaggio C, offre prestazioni eccellenti, supporta IO asincrono e coroutine, ed è in grado di gestire richieste ad alta concorrenza.
- Funzionalità ricche: Supporta vari protocolli di rete, timer, gestione dei processi, gestione della memoria, ecc., soddisfacendo diverse esigenze di sviluppo.
- Facile da usare: Offre un'API semplice e una ricca documentazione, aiutando gli sviluppatori a iniziare rapidamente.
- Alta estendibilità: Supporta estensioni e plugin personalizzati, consentendo una personalizzazione flessibile in base alle necessità.
Swoole è la scelta ideale per costruire applicazioni web ad alte prestazioni e sistemi di comunicazione in tempo reale, ed è adatta per progetti che vanno da piccole applicazioni a grandi sistemi aziendali.
Installazione di Swoole
In questo articolo, spiegheremo come installare e utilizzare Swoole nell'ambiente ServBay.
TIP
ServBay consiglia agli sviluppatori di posizionare il sito web nella directory /Applications/ServBay/www
per una gestione più semplice.
Passo 1: Installare l'estensione Swoole
Abilitare l'estensione Swoole
ServBay ha già incorporato l'estensione Swoole, l'utente deve prima abilitarla e riavviare PHP. Si prega di fare riferimento all'articolo Come abilitare il modulo Swoole incorporato in ServBay per abilitare il modulo Swoole.
Passo 2: Creare la directory del progetto
Creare e accedere alla directory del progetto:
cd /Applications/ServBay/www
mkdir servbay-swoole-app
cd servbay-swoole-app
2
3
Passo 3: Creare lo script del server Swoole
Nella directory del progetto, creare un file server.php
e scrivere un semplice server 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 "Swoole HTTP server is started at http://0.0.0.0:9501\n";
});
$server->on("request", function (Request $request, Response $response) {
$response->header("Content-Type", "text/plain");
$response->end("Hello ServBay!");
});
$server->start();
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
Passo 4: Eseguire il server Swoole
Nel terminale, eseguire il seguente comando per avviare il server Swoole:
php server.php
Vedrete l'output seguente:
Swoole HTTP server is started at http://0.0.0.0:9501
Passo 5: Accedere al server Swoole
Aprire il browser e accedere a http://localhost:9501
, vedrete la pagina che visualizza Hello ServBay!
.
Utilizzare Swoole per costruire applicazioni Web
In questa sezione, spiegheremo come usare Swoole per costruire una semplice applicazione Web.
Creare controller e route
Creare una directory app
nella directory del progetto, e al suo interno le directory controllers
e routes
:
mkdir -p app/controllers
mkdir -pa app/routes
2
Nella directory app/controllers
, creare un file HomeController.php
:
<?php
namespace App\Controllers;
class HomeController
{
public function index()
{
return "Welcome to ServBay!";
}
public function hello($name)
{
return "Hello, $name!";
}
}
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
Nella directory app/routes
, creare un file 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
Aggiornare lo script del server Swoole
Aggiornare il file server.php
aggiungendo la logica di parsing delle route e chiamata dei controller:
<?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 "Swoole HTTP server is started at 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
Installare FastRoute
Nella directory principale del progetto, eseguire il seguente comando per installare la libreria di routing FastRoute:
composer require nikic/fast-route
Eseguire il server Swoole
Nel terminale, eseguire il seguente comando per avviare il server Swoole:
php server.php
Accedere all'applicazione Web
Aprire il browser e accedere ai seguenti URL:
http://localhost:9501/
: vedrete la pagina visualizzareWelcome to ServBay!
.http://localhost:9501/hello/ServBay
: vedrete la pagina visualizzareHello, ServBay!
.
Gestione delle connessioni WebSocket con Swoole
Swoole supporta anche il protocollo WebSocket, che può essere utilizzato per costruire applicazioni di comunicazione in tempo reale. Spiegheremo come gestire le connessioni WebSocket con Swoole.
Creare lo script del server WebSocket
Nella directory del progetto, creare un file websocket_server.php
e scrivere un semplice server 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 "Swoole WebSocket server is started at ws://0.0.0.0:9502\n";
});
$server->on("open", function (Server $server, Request $request) {
echo "connection open: {$request->fd}\n";
});
$server->on("message", function (Server $server, Frame $frame) {
echo "received message: {$frame->data}\n";
$server->push($frame->fd, "Hello, {$frame->data}");
});
$server->on("close", function ($ser, $fd) {
echo "connection close: {$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
Eseguire il server WebSocket
Nel terminale, eseguire il seguente comando per avviare il server WebSocket:
php websocket_server.php
Vedrete l'output seguente:
Swoole WebSocket server is started at ws://0.0.0.0:9502
Collegarsi al server WebSocket
Si può utilizzare un client WebSocket nel browser o altri strumenti client WebSocket (ad esempio wscat
) per collegarsi al server WebSocket.
Utilizzare wscat
per collegarsi
Installare
wscat
:bashnpm install -g wscat
1Collegarsi al server WebSocket:
bashwscat -c ws://localhost:9502
1Inviare un messaggio:
bash> Hello ServBay
1
Vedrete che il server risponderà con il messaggio:
< Hello, Hello ServBay
Attraverso i passaggi sopra descritti, hai creato ed eseguito con successo un progetto Swoole, utilizzando le funzionalità di Swoole per gestire richieste HTTP e connessioni WebSocket. Le elevate prestazioni e le ricche funzionalità di Swoole lo rendono una scelta ideale per costruire applicazioni ad alta concorrenza.