Bibliothèque de serveur HTTP en PHP8.0 : React

Avec le développement d'Internet, l'importance des applications Web attire de plus en plus l'attention. Le serveur HTTP est l'un des fondements des applications Web. Dans le domaine de PHP, React est une excellente bibliothèque de serveur HTTP, qui nous offre une méthode de développement très pratique. Cet article présentera les concepts de base et l'utilisation de React, et expliquera certaines de ses fonctionnalités en détail.

React est une bibliothèque réseau basée sur le mécanisme de boucle d'événements. Il prend en charge des protocoles tels que HTTP et Websocket, ainsi que les E/S asynchrones. Contrairement aux autres bibliothèques de serveur HTTP PHP, React utilise une approche asynchrone et non bloquante, lui permettant de gérer plus efficacement un grand nombre de requêtes simultanées.

Installer React est très simple, nous pouvons utiliser Composer pour l'installer, comme indiqué ci-dessous :

composer require react/http:^1.0

Ensuite, nous pouvons écrire un simple serveur HTTP pour tester les bases de React Fonction. Le code est le suivant :

use ReactHttpResponse;
use ReactHttpServer;
use PsrHttpMessageServerRequestInterface;

require __DIR__ . '/vendor/autoload.php';

$server = new Server(function (ServerRequestInterface $request) {
    return new Response(
        200,
        array(
            'Content-Type' => 'text/plain'
        ),
        "Hello World!
"
    );
});

$socket = new ReactSocketServer('0.0.0.0:8080', $loop);
$server->listen($socket);

echo "Server running at http://127.0.0.1:8080
";

Ce code crée le serveur HTTP le plus simple basé sur React. Il accepte toutes les demandes et renvoie une réponse « Hello World ». Comme vous pouvez le voir, ce code utilise deux classes dans l'espace de noms ReactHttp : Response et Server. Parmi eux, Response représente la réponse HTTP et Server représente le serveur HTTP.

Expliquons plusieurs fonctionnalités de React :

1 IO asynchrone

React utilise des IO asynchrones pour traiter les requêtes. Lorsqu'une requête arrive, React gère la requête de manière asynchrone et continue de traiter les autres requêtes. Cela permet au serveur de gérer plusieurs requêtes simultanément, améliorant ainsi les performances.

Les E/S asynchrones doivent être utilisées en conjonction avec le mécanisme de boucle d'événements. React implémente des boucles d'événements via la classe ReactEventLoopLoop. Voici un exemple simple :

require __DIR__ . '/vendor/autoload.php';

$loop = ReactEventLoopFactory::create();

$loop->addTimer(2, function () {
    echo "This will be echoed after 2 seconds.
";
});

$loop->run();

echo "Event loop stopped.
";

Dans ce code, nous utilisons ReactEventLoopFactory::create() pour créer une instance de boucle d'événement. Ensuite, nous utilisons la méthode $loop->addTimer() pour définir un minuteur de 2 secondes. Enfin, nous démarrons la boucle d'événements en utilisant la méthode $loop->run(). Après avoir attendu 2 secondes, la boucle d'événements exécutera la fonction de rappel du minuteur et affichera un morceau de texte. Lorsque la fonction de rappel termine son exécution, la boucle d'événements s'arrête.

2. Routage

Lors de la création d'un serveur HTTP, nous devrons peut-être définir certaines règles de routage. React prend en charge l'utilisation du routeur FastRoute. Voici un exemple :

require __DIR__ . '/vendor/autoload.php';

$loop = ReactEventLoopFactory::create();

$router = FastRoutesimpleDispatcher(function(FastRouteRouteCollector $r) {
    $r->addRoute('GET', '/', function () {
        return new ReactHttpResponse(
            200,
            array(
                'Content-Type' => 'text/plain'
            ),
            "Hello World!
"
        );
    });
    $r->addRoute('GET', '/users/{id:d+}', function ($request) {
        $id = $request->getAttribute('id');
        return new ReactHttpResponse(
            200,
            array(
                'Content-Type' => 'text/plain'
            ),
            "User $id
"
        );
    });
});

$server = new ReactHttpServer(function ($request) use ($router) {
    $routeInfo = $router->dispatch($request->getMethod(), $request->getUri()->getPath());
    switch ($routeInfo[0]) {
        case FastRouteDispatcher::NOT_FOUND:
            return new ReactHttpResponse(404, array('Content-Type' => 'text/plain'), 'Not found');
        case FastRouteDispatcher::METHOD_NOT_ALLOWED:
            $allowedMethods = $routeInfo[1];
            return new ReactHttpResponse(405, array('Content-Type' => 'text/plain'), 'Method not allowed');
        case FastRouteDispatcher::FOUND:
            $handler = $routeInfo[1];
            $vars = $routeInfo[2];
            return $handler($request, ...array_values($vars));
    }
});

$socket = new ReactSocketServer('0.0.0.0:8080', $loop);
$server->listen($socket);

echo "Server running at http://127.0.0.1:8080
";

Dans ce code, nous utilisons le routeur FastRoute pour définir deux règles de routage pour le serveur HTTP. Lorsque l'URL demandée est « / », « Hello World » est renvoyé ; lorsque l'URL demandée est « /users/{id} », « Utilisateur {id} » est renvoyé. Parmi eux, {id:d+} signifie faire correspondre un nombre. Nous utilisons $routeInfo[0] pour obtenir les résultats de distribution de routes de FastRoute et définissons la réponse en fonction de différents résultats.

3. Websocket

En plus du protocole HTTP, React prend également en charge la mise en œuvre du protocole Websocket. Voici un exemple simple :

use ReactHttpResponse;
use ReactHttpServer;
use RatchetRFC6455MessagingMessageInterface;
use RatchetWebSocketMessageComponentInterface;
use RatchetWebSocketWsServer;

require __DIR__ . '/vendor/autoload.php';

class EchoServer implements MessageComponentInterface
{
    public function onOpen(ConnectionInterface $conn) {
        echo "Connection opened ({$conn->resourceId})
";
    }

    public function onClose(ConnectionInterface $conn) {
        echo "Connection closed ({$conn->resourceId})
";
    }

    public function onError(ConnectionInterface $conn, Exception $e) {
        echo "An error has occurred: {$e->getMessage()} ({$conn->resourceId})
";
        $conn->close();
    }

    public function onMessage(ConnectionInterface $from, MessageInterface $msg) {
        echo "Message received from ({$from->resourceId}): {$msg}
";
        $from->send($msg);
    }
}

$echo = new EchoServer();

$server = new Server(new WsServer($echo));

$socket = new ReactSocketServer('0.0.0.0:8080', $loop);
$server->listen($socket);

$loop->run();

Dans ce code, nous implémentons une classe EchoServer en tant que serveur Websocket. Il implémente l'interface MessageComponentInterface et remplace quatre de ses méthodes. Lorsque le lien est ouvert, la méthode onOpen() sera appelée ; lorsque le lien sera fermé, la méthode onClose() sera appelée ; lorsqu'une erreur se produit sur le lien, la méthode onError() sera appelée lorsque les données seront appelées ; reçu du lien, la méthode onMessage() sera appelée.

Enfin, nous transmettons l'instance EchoServer à WSServer et créons un serveur HTTP pour écouter les requêtes WebSocket. Nous utilisons ReactSocketServer pour écouter l'adresse IP et le port, et utilisons la méthode $loop->run() pour démarrer la boucle d'événements.

Summary

React est une excellente bibliothèque de serveur HTTP PHP. Elle nous offre une méthode de développement très pratique et prend en charge de nombreuses fonctionnalités, telles que les E/S asynchrones, le routage, etc. Grâce à l'introduction de cet article, vous pourrez mieux comprendre les fonctionnalités de React et commencer à utiliser React pour développer vos propres applications Web.

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!