Comment utiliser Swoole pour implémenter un service JSONRPC hautes performances

Dans le développement de réseaux, RPC (Remote Procedure Call) est un protocole de communication courant qui permet aux programmes distants de s'appeler pour implémenter des applications distribuées. Ces dernières années, alors que le développement de l'écosystème PHP continue de mûrir, le besoin d'implémenter un RPC hautes performances dans le langage PHP est devenu de plus en plus intense. En tant qu'extension PHP, Swoole fournit un réseau asynchrone, simultané et hautes performances. capacités de communication et est devenu une implémentation RPC hautes performances. Le meilleur choix pour les performances RPC.

Dans cet article, nous nous concentrerons sur la façon d'utiliser Swoole pour implémenter des services JSONRPC hautes performances, améliorant ainsi les performances et le débit des applications.

1. Introduction au protocole JSONRPC

JSONRPC (JavaScript Object Notation Remote Procedure Call) est un protocole d'appel à distance léger basé sur le format JSON. Il définit un ensemble unifié de spécifications d'interface afin que diverses applications puissent communiquer sans tracas. Dans le protocole JSONRPC, chaque demande et réponse est un objet JSON et toutes deux contiennent un champ d'identification pour identifier la relation correspondante entre la demande et la réponse.

Exemple de requête :

{
    "jsonrpc": "2.0",
    "method": "login",
    "params": {
        "username": "user",
        "password": "pass"
    },
    "id": 1
}

Exemple de réponse :

{
    "jsonrpc": "2.0",
    "result": true,
    "id": 1
}

Dans le protocole JSONRPC, le demandeur appelle les services distants fournis par d'autres applications en envoyant une requête avec les champs méthode et paramètres et le fournisseur renvoie une réponse A avec un champ de résultat à ; renvoie le résultat de l'appel. Le protocole JSONRPC prend en charge les requêtes et les réponses par lots, ce qui peut réduire efficacement la surcharge de communication réseau.

2. Utilisez Swoole pour implémenter le service JSONRPC

1. Installez Swoole

Avant de commencer, nous devons d'abord installer l'extension Swoole. Vous pouvez utiliser la commande suivante pour installer :

pecl install swoole

Vous pouvez également ajouter la ligne suivante au fichier php.ini pour installer :

extension=swoole.so

Une fois l'installation terminée, vous pouvez utiliser la commande php -m pour vérifier si le swoole L'extension a été installée avec succès.

2. Implémentation du serveur JSONRPC

Implémentons un simple serveur JSONRPC. Le code spécifique est le suivant :

<?php

require_once __DIR__ . '/vendor/autoload.php';

use SwooleHttpServer;
use SwooleHttpRequest;
use SwooleHttpResponse;

$server = new Server('0.0.0.0', 8080);

$server->on('Request', function (Request $request, Response $response) {
    $data = $request->rawContent();
    $arr = json_decode($data, true);
    if (isset($arr['method'])) {
        switch ($arr['method']) {
            case 'login':
                $result = login($arr['params']['username'], $arr['params']['password']);
                break;
            case 'register':
                $result = register($arr['params']['username'], $arr['params']['password']);
                break;
            default:
                $result = ['error' => 'Method not found'];
                break;
        }
    } else {
        $result = ['error' => 'Invalid request'];
    }
    $response->header('Content-Type', 'application/json');
    $response->end(json_encode([
        'jsonrpc' => '2.0',
        'result' => $result,
        'id' => $arr['id']
    ]));
});

function login($username, $password)
{
    // do login
    return true;
}

function register($username, $password)
{
    // do register
    return true;
}

$server->start();

Le code ci-dessus implémente un serveur JSONRPC qui peut gérer les méthodes de connexion et d'enregistrement, en analysant le corps de la requête. Les données contenues dans il est traité en appelant la méthode correspondante, et le résultat du traitement est finalement renvoyé au format JSON.

3. Implémenter le client JSONRPC

Afin de tester les fonctions du serveur JSONRPC, nous devons également implémenter un client JSONRPC. Le code spécifique est le suivant :

<?php

class JsonRpcClient
{
    private $host;
    private $port;
    private $id;

    public function __construct($host, $port)
    {
        $this->host = $host;
        $this->port = $port;
        $this->id = 0;
    }

    public function send($method, $params)
    {
        $client = new SwooleClient(SWOOLE_SOCK_TCP);
        if (!$client->connect($this->host, $this->port, 0.5)) {
            throw new Exception('Connect failed');
        }
        $client->send(json_encode([
            'jsonrpc' => '2.0',
            'method' => $method,
            'params' => $params,
            'id' => ++$this->id,
        ]));
        $data = $client->recv();
        if (!$data) {
            throw new Exception('Recv failed');
        }
        $client->close();
        $response = json_decode($data, true);
        if (isset($response['error'])) {
            throw new Exception($response['error']['message']);
        }
        return $response['result'];
    }
}

$client = new JsonRpcClient('127.0.0.1', 8080);

try {
    $result = $client->send('login', ['username' => 'user', 'password' => 'pass']);
    var_dump($result);
} catch (Exception $e) {
    echo $e->getMessage();
}

Le code ci-dessus implémente une requête qui peut être envoyée à. le serveur JSONRPC et obtient le résultat de la réponse du client JSONRPC. En appelant la méthode send et en transmettant les paramètres method et params, vous pouvez envoyer une requête au serveur JSONRPC et obtenir le résultat de la réponse. Si la demande échoue ou renvoie un message d'erreur, une exception est levée.

3. Test de performances du service JSONRPC basé sur Swoole

Afin de vérifier les avantages en termes de performances du service JSONRPC basé sur Swoole, nous pouvons effectuer un simple test de performances. Voici la configuration de l'environnement de test :

• CPU : Intel(R) Core(TM) i7-7700HQ CPU à 2,80 GHz
• Mémoire : 16 Go
• OS : Ubuntu 20.04.2 LTS
• Version PHP : 7.4 .22
• Version Swoole : 4.7.1

Méthode de test :

1. Utilisez le code serveur et client JSONRPC implémenté ci-dessus
2. Exécutez la commande ab, simulez 1000 requêtes simultanées et envoyez chaque requête 400 fois ; Enregistrer Testez les résultats et comparez-les.
Les résultats des tests sont les suivants :

Concurrency Level:      1000
Time taken for tests:   1.701 seconds
Complete requests:      400000
Failed requests:        0
Total transferred:      78800000 bytes
Requests per second:    235242.03 [#/sec] (mean)
Time per request:       42.527 [ms] (mean)
Time per request:       0.043 [ms] (mean, across all concurrent requests)
Transfer rate:          45388.31 [Kbytes/sec] received

À en juger par les résultats des tests, le service JSONRPC basé sur Swoole a des performances extrêmement élevées. Dans le cas de 1 000 requêtes simultanées, le temps de traitement moyen de chaque requête n'est que de 42,527 ms, et le débit des requêtes a atteint 235 242,03 fois/seconde.

4. Résumé

Cet article présente comment utiliser Swoole pour implémenter des services JSONRPC hautes performances et prouve ses avantages en termes de performances grâce à des tests de performances. Dans les applications réelles, nous pouvons implémenter des services RPC complexes en fonction des besoins et apporter de meilleures performances et une meilleure expérience utilisateur aux applications grâce aux fonctionnalités asynchrones, de concurrence et hautes performances de Swoole.

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!