Group chat and private chat functions of real-time chat system based on PHP-PHP Tutorial-php.cn

Group chat and private chat functions of real-time chat system based on PHP

王林

Release： 2023-08-27 14:44:01

Original

974 people have browsed it

Group chat and private chat functions of real-time chat system based on PHP

With the development of the Internet, real-time chat systems have become more and more important in our daily lives. is becoming more and more important. Whether you are chatting with friends on social media platforms or communicating with colleagues at work, live chat systems play an important role. This article will introduce how to use PHP to develop a real-time chat-based system that supports group chat and private chat functions.

First, we need to set up a server to handle real-time chat requests. We use PHP and WebSocket to implement this functionality. WebSocket is a TCP-based protocol that allows full-duplex communication between the browser and the server. In PHP, we can use the Ratchet library to create a WebSocket server.

First, we need to install the Ratchet library. Run the following command in the terminal:

composer require cboden/ratchet

Copy after login

Once the installation is complete, we can create a file named server.php and write the following code in it:

<?php
require 'vendor/autoload.php';

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

class Chat implements MessageComponentInterface
{
    protected $clients;

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

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

    public function onMessage(ConnectionInterface $from, $msg)
    {
        // 处理客户端发送的消息
        $data = json_decode($msg);
        $type = $data->type;

        switch ($type) {
            case 'register':
                $from->username = $data->username;
                echo "User registered: " . $from->username . "
";
                break;
            case 'group':
                $message = $data->message;
                $this->broadcastMessage($from, $message);
                break;
            case 'private':
                $recipient = $data->recipient;
                $message = $data->message;
                $this->sendPrivateMessage($from, $recipient, $message);
                break;
        }
    }

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

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

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

    public function sendPrivateMessage($from, $recipient, $message)
    {
        foreach ($this->clients as $client) {
            if ($client->username == $recipient) {
                $client->send($message);
                $from->send($message);
                break;
            }
        }
    }
}

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

$server->run();

Copy after login

In the above code, we created a class named Chat to handle operations such as connecting, sending messages, and closing connections. In the onMessage method, we perform different operations based on the message type. If the type is register, it means there is a user registration connection; if the type is group, it means there is a user sending a group message; if the type is private, it means there is a user Send a private message. We use the broadcastMessage method to broadcast group messages and the sendPrivateMessage method to send private messages.

Next, we can create a file called index.html and write the following code in it:

<!DOCTYPE html>
<html>
<head>
    <title>Chat</title>
</head>
<body>
    <input type="text" id="username" placeholder="Username"><br>
    <input type="text" id="message" placeholder="Message"><br>
    <button onclick="register()">Register</button>
    <button onclick="sendGroupMessage()">Send Group Message</button>
    <button onclick="sendPrivateMessage()">Send Private Message</button>

    <script>
        var conn = new WebSocket('ws://localhost:8080');

        conn.onopen = function(e) {
            console.log("Connection established!");
        };

        conn.onmessage = function(e) {
            var chatbox = document.getElementById("chatbox");
            chatbox.innerHTML += e.data + "<br>";
        };

        function register() {
            var username = document.getElementById("username").value;
            var data = {
                type: 'register',
                username: username
            };
            conn.send(JSON.stringify(data));
        }

        function sendGroupMessage() {
            var message = document.getElementById("message").value;
            var data = {
                type: 'group',
                message: message
            };
            conn.send(JSON.stringify(data));
        }

        function sendPrivateMessage() {
            var recipient = document.getElementById("username").value;
            var message = document.getElementById("message").value;
            var data = {
                type: 'private',
                recipient: recipient,
                message: message
            };
            conn.send(JSON.stringify(data));
        }
    </script>
</body>
</html>

Copy after login

In the above code, we create a WebSocket connects and registers the connection callback function. In the register function we send the username to the server for registration. In the sendGroupMessage function, we send the group message to the server, and the server will broadcast the message to all users. In the sendPrivateMessage function, we send the private message to the specified user.

Now, we can run the php server.php command in the terminal to start the server. Then, we can open the index.html file in the browser, enter the user name and click the registration button. Next, we can enter a message and click the send button to have a group chat or private chat. The server broadcasts the corresponding message to other users or sends it to a specified user.

Summary:
This article introduces how to use PHP and WebSocket to develop a real-time chat system and implement group chat and private chat functions. By creating a WebSocket server and communicating with it, we are able to get and send messages from other users in real time. With a simple code example, we implemented a basic real-time chat system. By extending the code, we can implement more functions, such as adding user verification, chat record storage, etc.

The above is the detailed content of Group chat and private chat functions of real-time chat system based on PHP. For more information, please follow other related articles on the PHP Chinese website!