High-performance WebSocket server development experience based on Swoole

Websocket is a full-duplex communication protocol based on TCP, which allows the client and server to interact with data in real time. The Websocket protocol is suitable for application scenarios such as real-time data transmission and online games. Unlike the HTTP protocol, the Websocket can maintain a long connection, avoiding the disadvantage of the HTTP protocol that requires the establishment of a TCP connection for each request. Therefore, more and more products use the Websocket protocol for data transmission.

In order to improve the performance of the Websocket server, we can use the Swoole extension for development. Swoole is a commonly used high-performance PHP network communication framework. It is based on the asynchronous event-driven model and implements coroutines commonly used in high-performance frameworks such as React and Node.js, which greatly improves the performance of PHP. In this article, we will introduce how to develop a high-performance Websocket server under Swoole and share some related experiences.

1. Start the Swoole service

Before starting the Swoole service, we first need to install the Swoole extension. Swoole supports common operating systems such as Windows, Linux, macOS, etc. We can use the pecl command to install extensions, or download the source code from the Swoole official website for compilation and installation. Here we take the pecl command installation as an example:

pecl install swoole

After the installation is completed, you can use the swoole_version() function in the PHP code to view the Swoole version information to ensure that the extension has been installed correctly.

1. Create a service instance

Before using Swoole to develop a Websocket server, you first need to create a service instance. We can use the SwooleWebSocketServer class provided by Swoole. To create, as follows:

$server = new SwooleWebSocketServer('0.0.0.0', 9501);

Among them, 0.0.0.0 means listening on all available IP addresses, and 9501 means the listening port number. After creating the instance, we can perform some configurations on the server, such as setting the number of worker processes, setting the operating mode, enabling the TCP protocol, etc. For details, please refer to the Swoole official documentation.

2. Register event callback function

The communication between the Websocket server and the client is achieved through the event callback function. We need to register the callback function in the service instance so that the service instance Able to respond to appropriate events. Swoole provides many callback functions (such as onMessage, onOpen, onClose, onRequest, onHandShake, etc.). When we develop a Websocket server, we usually need to register the following three callback functions:

//连接成功时触发
$server->on('open', function (SwooleWebSocketServer $server, $request) {
    //处理连接事件
});

//收到客户端消息时触发
$server->on('message', function (SwooleWebSocketServer $server, $frame) {
    //处理消息事件
});

//连接关闭时触发
$server->on('close', function (SwooleWebSocketServer $server, $fd) {
    //处理关闭事件
});

Among them, the open event is on the client After the connection is successfully established, the message event is triggered after the client sends the message, and the close event is triggered after the connection is closed. In Swoole, the $frame object represents the data body of the WebSocket message, and the specific content of the message can be obtained through $frame->data.

3. Start the service

After registering the callback function, we can start the service. The code is as follows:

$server->start();

When starting the service, it will be automatically created Worker processes and reactor threads are used to handle business processes such as client connections and message sending.

2. Websocket service development experience

When using Swoole to develop a Websocket server, you also need to pay attention to the following aspects:

1. Heartbeat mechanism

The Websocket protocol does not have clear requests and responses in the HTTP protocol, but uses message push for real-time data transmission. Since the Websocket server needs to monitor the client's connection and message transmission for a long time, it cannot send messages once the client disconnects. Therefore, we need to implement a heartbeat mechanism and send heartbeat requests to the client regularly to maintain the connection. In Swoole, we can use ping and pong messages to implement the heartbeat mechanism.

//心跳包
$server->tick(30000, function () use ($server) {
    foreach ($server->connections as $fd) {
        $server->push($fd, json_encode(['type' => 'ping']));
    }
});

//心跳响应
$server->on('message', function (SwooleWebSocketServer $server, $frame) {
    if ($frame->data == 'pong') {
        //处理心跳响应
    }
});

Among them, the tick function can send heartbeat requests to the client regularly, and the onMessage callback function can process the client’s heartbeat response to ensure that the client and the server are Stay connected.

2. Message broadcast

A very common scenario for Websocket servers is to broadcast messages to all clients, such as barrages, multiplayer games, etc. In Swoole, we can use the push method to broadcast messages.

//处理广播消息
$message = 'Hello, everyone!';
foreach ($server->connections as $fd) {
    $server->push($fd, $message);
}

In addition, you can also send targeted messages to specific clients based on the client’s connection information.

3. Data formatting

In the Websocket protocol, the data communicated between the client and the server may be transmitted in JSON, XML and other formats, so when processing the received data , we need to format the data, such as using json_decode to parse JSON format.

//处理消息事件
$server->on('message', function (SwooleWebSocketServer $server, $frame) {
    $data = json_decode($frame->data, true);
    //处理数据
});

4. Multi-process management

In the Websocket server, there will be a large number of client requests. In order to improve the server's processing capability, we can use Swoole's multi-process management characteristic. Swoole supports the Master process and multiple Worker processes. The Master process is used to manage the Worker process, and the Worker process is responsible for processing specific client requests. We can set the number of Worker processes when creating a service instance to adapt to request loads of different sizes.

$server->set([
    'worker_num' => 4,
]);

In a multi-process environment, you need to pay attention to data synchronization and sharing issues. You can use Process, Table, Atomic, Mutex and other components provided by Swoole to achieve inter-process communication and synchronization.

In short, using Swoole to develop a Websocket server can greatly improve the performance and stability of the server. It also requires us to be proficient in Swoole's related features and development skills. I hope this article can be helpful to developers and provide reference for better implementation of high-performance Websocket servers.

The above is the detailed content of High-performance WebSocket server development experience based on Swoole. For more information, please follow other related articles on the PHP Chinese website!