So implementieren Sie mit Swoole einen leistungsstarken JSONRPC-Dienst

In der Netzwerkentwicklung ist RPC (Remote Procedure Call) ein gängiges Kommunikationsprotokoll, das es entfernten Programmen ermöglicht, sich gegenseitig aufzurufen, um verteilte Anwendungen zu implementieren. Da die Entwicklung des PHP-Ökosystems in den letzten Jahren weiter ausgereift ist, ist die Notwendigkeit, Hochleistungs-RPC in der PHP-Sprache zu implementieren, immer größer geworden. Als PHP-Erweiterung bietet Swoole ein asynchrones, gleichzeitiges und leistungsstarkes Netzwerk Kommunikationsfähigkeiten und hat sich zu einer leistungsstarken RPC-Implementierung entwickelt.

In diesem Artikel konzentrieren wir uns darauf, wie man mit Swoole leistungsstarke JSONRPC-Dienste implementiert, um die Anwendungsleistung und den Durchsatz zu verbessern.

1. Einführung in das JSONRPC-Protokoll

JSONRPC (JavaScript Object Notation Remote Procedure Call) ist ein leichtes Remote-Aufrufprotokoll, das auf dem JSON-Format basiert. Es definiert einen einheitlichen Satz von Schnittstellenspezifikationen, damit verschiedene Anwendungen problemlos kommunizieren können. Im JSONRPC-Protokoll ist jede Anfrage und Antwort ein JSON-Objekt und beide enthalten ein ID-Feld, um die entsprechende Beziehung zwischen der Anfrage und der Antwort zu identifizieren.

Anfragebeispiel:

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

Antwortbeispiel:

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

Im JSONRPC-Protokoll ruft der Anforderer von anderen Anwendungen bereitgestellte Remote-Dienste auf, indem er eine Anfrage mit Methoden- und Parameterfeldern sendet, und der Anbieter gibt eine A-Antwort mit einem Ergebnisfeld zurück Gibt das Anrufergebnis zurück. Das JSONRPC-Protokoll unterstützt Batch-Anfragen und Batch-Antworten, wodurch der Overhead der Netzwerkkommunikation effektiv reduziert werden kann.

2. Verwenden Sie Swoole, um den JSONRPC-Dienst zu implementieren.

1. Swoole installieren. Bevor wir beginnen, müssen wir zuerst die Swoole-Erweiterung installieren. Sie können zum Installieren den folgenden Befehl verwenden:

pecl install swoole

Sie können der zu installierenden php.ini-Datei auch die folgende Zeile hinzufügen:

extension=swoole.so

Nach Abschluss der Installation können Sie mit dem Befehl php -m überprüfen, ob die Swoole Erweiterung wurde erfolgreich installiert.

Implementieren des JSONRPC-Servers

2. Lassen Sie uns einen einfachen JSONRPC-Server implementieren. Der spezifische Code lautet wie folgt:

<?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();

Der obige Code implementiert einen JSONRPC-Server, der die Anmelde- und Registrierungsmethoden verarbeiten kann, indem er den Anforderungstext analysiert Daten, rufen Sie die entsprechende Methode zur Verarbeitung auf und geben Sie schließlich die Verarbeitungsergebnisse im JSON-Format zurück.

JSONRPC-Client implementieren

3. Um die Funktionen des JSONRPC-Servers zu testen, müssen wir auch einen JSONRPC-Client implementieren. Der spezifische Code lautet wie folgt:

<?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();
}

Der obige Code implementiert eine Anfrage, die an gesendet werden kann den JSONRPC-Server und erhält das Antwortergebnis. Durch Aufrufen der Sendemethode und Übergeben der Methoden- und Parameterparameter können Sie eine Anfrage an den JSONRPC-Server senden und das Antwortergebnis erhalten. Wenn die Anfrage fehlschlägt oder eine Fehlermeldung zurückgibt, wird eine Ausnahme ausgelöst.

3. Leistungstest des Swoole-basierten JSONRPC-Dienstes

Um die Leistungsvorteile des Swoole-basierten JSONRPC-Dienstes zu überprüfen, können wir einen einfachen Leistungstest durchführen. Das Folgende ist die Konfiguration der Testumgebung:

CPU: Intel(R) Core(TM) i7-7700HQ CPU mit 2,80 GHz

Speicher: 16 GB
• Betriebssystem: Ubuntu 20.04.2 LTS
• PHP-Version: 7.4 .22
Swoole-Version: 4.7.1
• Testmethode:

Verwenden Sie den oben implementierten JSONRPC-Server- und Client-Code;

Führen Sie den ab-Befehl aus, simulieren Sie 1000 gleichzeitige Anfragen und senden Sie jede Anfrage 400 Mal;
1. Zeichnen Sie die Ergebnisse auf, testen Sie sie und vergleichen Sie sie.
3. Die Testergebnisse lauten wie folgt:

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

Aus den Testergebnissen geht hervor, dass der auf Swoole basierende JSONRPC-Dienst eine extrem hohe Leistung aufweist. Bei 1000 gleichzeitigen Anfragen beträgt die durchschnittliche Verarbeitungszeit jeder Anfrage nur 42,527 ms Der Anforderungsdurchsatz erreichte 235242,03 Mal/Sekunde.

4. Zusammenfassung

Dieser Artikel stellt vor, wie Swoole zur Implementierung leistungsstarker JSONRPC-Dienste verwendet wird, und beweist seine Leistungsvorteile durch Leistungstests. In tatsächlichen Anwendungen können wir je nach Bedarf komplexe RPC-Dienste implementieren und durch die asynchronen, parallelen und leistungsstarken Funktionen von Swoole eine bessere Leistung und Benutzererfahrung für Anwendungen erzielen.

Das obige ist der detaillierte Inhalt vonSo implementieren Sie mit Swoole einen leistungsstarken JSONRPC-Dienst. Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!