HTTP server library in PHP8.0: React

With the development of the Internet, the importance of Web applications has attracted more and more attention. The HTTP server is one of the foundations of Web applications. In the field of PHP, React is an excellent HTTP server library, which provides us with a very convenient development method. This article will introduce the basic concepts and usage of React, and explain some of its features in detail.

React is a network library based on the event loop mechanism. It provides support for protocols such as HTTP and Websocket, and supports asynchronous IO. Unlike other PHP HTTP server libraries, React uses an asynchronous and non-blocking approach, allowing it to handle a large number of concurrent requests more efficiently.

Installing React is very simple, we can use Composer to install it, as shown below:

composer require react/http:^1.0

Next, we can write a simple HTTP server to test the basic functions of React. The code is as follows:

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
";

This code creates the simplest HTTP server based on React. It accepts all requests and returns a "Hello World" response. As you can see, this code uses two classes in the ReactHttp namespace: Response and Server. Among them, Response represents the HTTP response, and Server represents the HTTP server.

Let’s explain several features of React:

1. Asynchronous IO

React uses asynchronous IO to process requests. When a request comes in, React handles the request asynchronously and continues to handle other requests. This enables the server to handle multiple requests simultaneously, improving performance.

Asynchronous IO requires the use of event loop mechanism. React implements event loops through the ReactEventLoopLoop class. The following is a simple example:

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.
";

In this code, we use ReactEventLoopFactory::create() to create an event loop instance. Then, we use the $loop->addTimer() method to set a 2-second timer. Finally, we start the event loop using the $loop->run() method. After waiting for 2 seconds, the event loop will execute the timer's callback function and output a piece of text. When the callback function completes execution, the event loop will stop.

2. Routing

When creating an HTTP server, we may need to set some routing rules. React supports using FastRoute router. The following is an example:

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
";

In this code, we use the FastRoute router to set two routing rules for the HTTP server. When the requested URL is '/', "Hello World" is returned; when the requested URL is '/users/{id}', "User {id}" is returned. Among them, {id:d} means matching a number. We use $routeInfo[0] to obtain the route distribution results of FastRoute, and set the response according to different results.

3. Websocket

In addition to the HTTP protocol, React also supports the implementation of the Websocket protocol. The following is a simple example:

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();

In this code, we implement an EchoServer class as a Websocket server. It implements the MessageComponentInterface interface and overrides four of its methods. When the link is opened, the onOpen() method will be called; when the link is closed, the onClose() method will be called; when an error occurs on the link, the onError() method will be called; when data is received from the link, The onMessage() method will be called.

Finally, we pass the EchoServer instance to WSServer and create an HTTP server to listen for WebSocket requests. We use ReactSocketServer to listen on the IP address and port, and use the $loop->run() method to start the event loop.

Summary

React is an excellent PHP HTTP server library. It provides us with a very convenient development method and supports many features, such as asynchronous IO, routing, etc. Through the introduction of this article, you can have a deeper understanding of the features of React and start using React to develop your own web applications.

The above is the detailed content of HTTP server library in PHP8.0: React. For more information, please follow other related articles on the PHP Chinese website!