Swoole implémente un serveur RPC hautes performances

Ces dernières années, avec le développement continu des applications réseau, de plus en plus d'applications doivent implémenter la fonction d'appel de procédure à distance (RPC). Les frameworks RPC traditionnels tels que Dubbo, Thrift, gRPC, etc. peuvent répondre à cette demande. Cependant, avec l'augmentation du nombre d'applications et d'entreprises, les problèmes de performances sont devenus de plus en plus évidents. Afin de résoudre ces problèmes, la communauté open source a lancé un serveur RPC hautes performances basé sur le langage PHP-Swoole.

Swoole est un framework de communication réseau asynchrone, parallèle et hautes performances développé sur la base du langage PHP, qui permet aux programmes PHP de traiter plus efficacement les requêtes réseau. Le serveur RPC est un composant de Swoole. Il fournit une méthode d'appel de procédure à distance basée sur le protocole TCP, prend en charge les E/S asynchrones, les coroutines, la gestion des processus et d'autres fonctionnalités, et peut facilement implémenter des services RPC hautes performances et à haute concurrence.

Ensuite, nous présenterons comment utiliser Swoole pour implémenter un serveur RPC hautes performances.

Installez l'extension Swoole

Avant de commencer, nous devons d'abord installer l'extension Swoole. Étant donné que Swoole s'appuie sur l'extension C sous-jacente de PHP, vous devez d'abord installer le compilateur C et les bibliothèques dépendantes de Swoole.

yum install -y gcc 
    automake 
    autoconf 
    libtool 
    make 
    php-devel 
    php-pear 
    pcre-devel 
    openssl-devel

Après avoir installé les bibliothèques dépendantes, nous pouvons utiliser la commande pecl pour installer l'extension Swoole :

pecl install swoole

Une fois l'installation terminée, nous devons ajouter les lignes suivantes au fichier php.ini pour activer l'extension Swoole :

extension=swoole.so

Implémentation du serveur RPC

Après avoir installé l'extension Swoole, nous pouvons commencer à implémenter le serveur RPC. Ici, nous utiliserons le mécanisme de réflexion de PHP pour implémenter l'enregistrement automatisé des services, et la coroutine de Swoole pour gérer les E/S asynchrones.

Créer une classe de service

Tout d'abord, nous devons créer une classe de service pour exposer les méthodes pour les appels à distance. Dans cette classe, nous pouvons définir plusieurs méthodes et utiliser le DocBlock de PHP pour marquer les paramètres et renvoyer les types de valeurs des méthodes afin de générer automatiquement de la documentation et des astuces de code.

/**
 * @method string hello(string $name)
 */
class MyService
{
    public function hello(string $name): string
    {
        return "Hello, $name!";
    }
}

Dans le code ci-dessus, nous définissons une classe MyService, qui contient une méthode nommée hello, qui reçoit un paramètre de type chaîne $name et renvoie des données de type chaîne.

Créer un serveur RPC

Ensuite, nous devons implémenter le serveur RPC pour recevoir la demande du client et appeler la méthode correspondante dans la classe de service pour gérer la demande.

$server = new SwooleServer('127.0.0.1', 9501, SWOOLE_PROCESS, SWOOLE_SOCK_TCP);

/**
 * 注册服务
 */
$server->set([
    'worker_num' => 1,
    'dispatch_mode' => 1,
]);
$myService = new MyService();
$methods = get_class_methods($myService);
$availableMethods = [];
foreach ($methods as $method) {
    // 忽略 __* 类型的方法，私有方法和构造方法
    if (!preg_match('/^__|^get[A-Z]/i', $method) && is_callable([$myService, $method])) {
        $availableMethods[] = $method;
    }
}
$server->on('WorkerStart', function () use ($availableMethods, $myService) {
    // 打开协程支持
    SwooleRuntime::enableCoroutine();
    $service = new HproseSwooleSocketService();
    foreach ($availableMethods as $method) {
        $service->addFunction([$myService, $method], $method);
    }
    $server = new HproseSwooleSocketServer('tcp://0.0.0.0:9501');

    //监听 RPC 请求
    $coroutine = new SwooleCoroutineHttpClient();
    $coroutine->setHeaders([
        'Content-Type' => 'text/plain',
    ]);

    while (true) {
        $socket = $server->accept();
        if ($socket !== false) {
            $socket->setOption(['open_length_check' => 1]);
            $socket->setOption(['package_length_type' => 'N']);
            $socket->setOption(['package_length_offset' => 0]);
            $socket->setOption(['package_body_offset' => 4]);
            $socket->start();
            $client = new SwooleCoroutineClient(SWOOLE_SOCK_TCP);
            $client->connect('127.0.0.1', 9502);
            $client->send($socket->recv());
            $out = $client->recv();
            $socket->send($out);
            $socket->close();
        }
    }
});
$server->start();

Dans le code ci-dessus, nous avons créé un objet $server qui écoute sur l'adresse et le port 127.0.0.1:9501, en utilisant le mode de processus SWOOLE_PROCESS et le protocole SWOOLE_SOCK_TCP.

Après le démarrage du serveur, nous utilisons le mécanisme de réflexion de PHP pour obtenir toutes les méthodes appelables dans la classe de service. Ensuite, nous utilisons la coroutine de Swoole pour écouter les requêtes RPC et traiter les requêtes en appelant les méthodes de la classe de service. Au cours du processus de mise en œuvre, nous avons utilisé la bibliothèque tierce Hprose, qui fournit un moyen simple et clair d'implémenter les services RPC et est très pratique à utiliser.

Créer un client

Enfin, nous devons créer un client pour demander le service RPC. Dans cet exemple, nous pouvons utiliser la classe Client fournie avec Hprose pour y parvenir.

$client = new HproseHttpClient('http://127.0.0.1:9501/', false);
echo $client->hello('Swoole');

Dans le code ci-dessus, nous créons un objet client HTTP Hprose et appelons la méthode hello dans la classe de service pour lancer une requête au serveur RPC.

Résumé

Swoole est un puissant framework de communication réseau qui fournit de nombreuses fonctionnalités asynchrones, parallèles et hautes performances qui peuvent considérablement améliorer les capacités de traitement des programmes PHP. En étudiant le contenu de cet article, nous pouvons implémenter un serveur RPC hautes performances et à haute concurrence et améliorer l'efficacité de traitement et de fonctionnement des programmes PHP.

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!