How to use WebSocket in PHP?-PHP Tutorial-php.cn

How to use WebSocket in PHP?

WBOY

Release： 2023-05-12 09:28:02

Original

1595 people have browsed it

As web applications become more complex, real-time communication and data push are becoming more common. This is where WebSocket comes in. WebSocket is a protocol that allows servers and clients to establish persistent connections for two-way communication for real-time communication and data push. In this article, we will discuss how to use WebSocket in PHP.

Introduction to WebSocket Protocol

WebSocket is a full-duplex, TCP-based protocol that allows the server and client to communicate in real time after a connection is established. Unlike the HTTP request-response model, a WebSocket connection always remains open after the connection is established, so multiple HTTP handshakes are not required.

WebSocket is a binary protocol that supports multiple data types, including text, binary, JSON, XML, etc. This makes WebSocket ideal for real-time communication and data pushing.

Install WebSocket library

Using WebSocket in PHP requires the use of a library. In this article, we will use the Ratchet library. To install Ratchet, you can run the following command through Composer:

composer require cboden/ratchet

Copy after login

After the installation is complete, we can start writing code to implement the WebSocket application.

Implementing WebSocket Service

The following is a simple example for implementing a WebSocket service that will receive a message from the client and send the message to All connected clients:

use RatchetServerIoServer;
use RatchetHttpHttpServer;
use RatchetWebSocketWsServer;
use RatchetMessageComponentInterface;
use RatchetConnectionInterface;

class Chat implements MessageComponentInterface {
    protected $clients;

    public function __construct() {
        $this->clients = new SplObjectStorage;
    }

    public function onOpen(ConnectionInterface $conn) {
        $this->clients->attach($conn);
        echo "New client connected: {$conn->resourceId}
";
    }

    public function onClose(ConnectionInterface $conn) {
        $this->clients->detach($conn);
        echo "Client disconnected: {$conn->resourceId}
";
    }

    public function onMessage(ConnectionInterface $from, $msg) {
        foreach ($this->clients as $client) {
            if ($client !== $from) {
                $client->send($msg);
            }
        }
    }

    public function onError(ConnectionInterface $conn, Exception $e) {
        echo "Error: {$e->getMessage()}
";
        $conn->close();
    }
}

$server = IoServer::factory(
    new HttpServer(
        new WsServer(
            new Chat()
        )
    ),
    8080
);

echo "Server started
";
$server->run();

Copy after login

In the above example, we defined a class called Chat, which implements the MessageComponentInterface interface. This class contains special methods for handling connections, disconnections, and messages from clients.

onOpen(ConnectionInterface $conn): This method is called when the client connects to the server. Here we add the connection to the client object.

onClose(ConnectionInterface $conn): This method is called when the client closes the connection. Here we delete the connection client object.

onMessage(ConnectionInterface $from, $msg): This method is called when the client sends a message. Here we send messages to other connected clients.

onError(ConnectionInterface $conn, Exception $e): This method is called when an error occurs. We close the connection here.

In the above example, we also created an HTTP server through the IoServer class, listening to port 8080, passing the request to the WebSocket server through HttpServer, and passing the request to the Chat class through WsServer.

Implementing the client

To connect to our WebSocket server, you need to implement a client. Here is a simple example for connecting to a server and sending messages to it:

<!DOCTYPE html>
<html>
<head>
    <title>WebSocket client</title>
    <script src="https://code.jquery.com/jquery-3.6.0.min.js"></script>
</head>
<body>
    <input type="text" id="message" placeholder="Enter your message">
    <button id="send">Send</button>

    <ul id="messages"></ul>

    <script>
        $(function () {
            var socket = new WebSocket('ws://localhost:8080');

            socket.onopen = function() {
                console.log('Connection opened');
            };

            socket.onclose = function() {
                console.log('Connection closed');
            };

            socket.onmessage = function(event) {
                var data = JSON.parse(event.data);
                $('#messages').append($('<li>').text(data.message));
            };

            $('#send').click(function() {
                var message = $('#message').val();
                socket.send(JSON.stringify({message: message}));
            });
        });
    </script>
</body>
</html>

Copy after login

In the above example, we create a new WebSocket connection using the WebSocket object. When a connection is opened or closed, the onopen and onclose events are triggered. When a WebSocket receives a message from the server, the onmessage event is triggered. We used the jQuery library to listen to the click event of the Send button, and when clicked, we sent the value of the text input box as a message to the server.

Summary

WebSocket is a powerful protocol that allows the server and client to establish a persistent connection for two-way communication in order to achieve real-time communication and data push. In this article, we implemented a simple WebSocket server using the Ratchet library. We also used a simple HTML page to demonstrate how to connect to the server and send messages. If you want to build a real-time, interactive web application, then WebSocket is an absolutely indispensable part.

The above is the detailed content of How to use WebSocket in PHP?. For more information, please follow other related articles on the PHP Chinese website!