Swoole\Client — Klasse · PHP-Referenz

Signatur

class Swoole\Client

Beschreibung

Swoole\Client ist eine objektorientierte Wrapper-Klasse für TCP- und UDP-Netzwerkverbindungen. Im Gegensatz zum asynchronen Swoole\Async\Client blockiert dieser Client bei I/O-Operationen, bis diese abgeschlossen sind – das Verhalten entspricht also dem klassischen synchronen PHP-Networking (ähnlich wie fsockopen() oder stream_socket_client()), jedoch mit der komfortablen API von Swoole.

Typische Einsatzgebiete sind: Kommunikation mit TCP-Diensten (HTTP, Redis, Datenbanken), UDP-basierte Protokolle sowie das Testen von Swoole-Servern in Unit-Tests. Da der Client synchron arbeitet, eignet er sich auch für einfache CLI-Skripte ohne Event-Loop-Infrastruktur.

Protokollunterstützung: Der Client unterstützt SWOOLE_SOCK_TCP, SWOOLE_SOCK_TCP6, SWOOLE_SOCK_UDP und SWOOLE_SOCK_UDP6. Über den zweiten Konstruktorparameter lässt sich zudem die synchrone (SWOOLE_SOCK_SYNC) oder asynchrone Betriebsart wählen. SSL-Verbindungen werden durch Kombination mit SWOOLE_SSL ermöglicht.

Innerhalb von Swoole-Coroutinen sollte stattdessen der Coroutine-Client (Swoole\Coroutine\Client) verwendet werden, damit der Event-Loop nicht blockiert wird.

Parameter

Name	Typ	Default	Beschreibung
$type Pflicht	int		Socket-Typ der Verbindung. Mögliche Werte: `SWOOLE_SOCK_TCP`, `SWOOLE_SOCK_TCP6`, `SWOOLE_SOCK_UDP`, `SWOOLE_SOCK_UDP6`. Kann mit `SWOOLE_SSL` per bitweisem OR kombiniert werden, z. B. `SWOOLE_SOCK_TCP \| SWOOLE_SSL`.
$async	int	SWOOLE_SOCK_SYNC	Betriebsmodus: `SWOOLE_SOCK_SYNC` für synchronen (blockierenden) und `SWOOLE_SOCK_ASYNC` für asynchronen Betrieb. Für den asynchronen Einsatz wird jedoch empfohlen, stattdessen den dedizierten Async- oder Coroutine-Client zu verwenden.

Rückgabewert

Typ

Beispiele

Einfache TCP-Verbindung zu einem HTTP-Server

<?php
// Verbindung zu einem HTTP-Server herstellen und eine GET-Anfrage senden
$client = new Swoole\Client(SWOOLE_SOCK_TCP);

if (!$client->connect('httpbin.org', 80, 3.0)) {
    echo 'Verbindung fehlgeschlagen: ' . $client->errCode . PHP_EOL;
    exit(1);
}

$request = "GET /get HTTP/1.1\r\nHost: httpbin.org\r\nConnection: close\r\n\r\n";
$client->send($request);

$response = '';
while ($chunk = $client->recv()) {
    $response .= $chunk;
}

$client->close();

// Nur den HTTP-Status ausgeben
$firstLine = strtok($response, "\r\n");
echo $firstLine . PHP_EOL;

HTTP/1.1 200 OK

TCP-Verbindung zu einem Redis-Server (Inline-Protokoll)

<?php
// Direktes Ansprechen eines Redis-Servers über das Redis Inline Protocol
$client = new Swoole\Client(SWOOLE_SOCK_TCP);

if (!$client->connect('127.0.0.1', 6379, 2.0)) {
    echo 'Redis nicht erreichbar: Fehlercode ' . $client->errCode . PHP_EOL;
    exit(1);
}

// PING senden
$client->send("PING\r\n");
$pong = $client->recv();
echo 'Redis antwortet: ' . trim($pong) . PHP_EOL;

// Einen Wert setzen und lesen
$client->send("SET swoole_test Hallo\r\n");
$setResult = $client->recv();
echo 'SET Ergebnis: ' . trim($setResult) . PHP_EOL;

$client->send("GET swoole_test\r\n");
$value = $client->recv();
echo 'GET Ergebnis (Rohdaten): ' . $value;

$client->close();

Redis antwortet: +PONG SET Ergebnis: +OK GET Ergebnis (Rohdaten): $5 Hallo

SSL/TLS-gesicherte TCP-Verbindung

<?php
// Verbindung zu einem HTTPS-fähigen Dienst über SSL
$client = new Swoole\Client(SWOOLE_SOCK_TCP | SWOOLE_SSL);

$client->set([
    'ssl_verify_peer'  => true,
    'ssl_cafile'       => '/etc/ssl/certs/ca-certificates.crt',
    'ssl_host_name'    => 'example.com',
]);

if (!$client->connect('example.com', 443, 5.0)) {
    echo 'SSL-Verbindung fehlgeschlagen: ' . $client->errCode . PHP_EOL;
    exit(1);
}

$request = "GET / HTTP/1.1\r\nHost: example.com\r\nConnection: close\r\n\r\n";
$client->send($request);

$firstChunk = $client->recv();
$statusLine  = strtok($firstChunk, "\r\n");
echo 'Status: ' . $statusLine . PHP_EOL;

$client->close();

Status: HTTP/1.1 200 OK

// Wichtig · Fallstricke

Blockierendes Verhalten: Swoole\Client blockiert den aktuellen Prozess/Thread bei connect(), send() und recv(). In einem Swoole-Coroutine-Kontext (z. B. innerhalb eines Co\run()-Blocks oder eines HTTP-Server-Callbacks) sollte stattdessen Swoole\Coroutine\Client verwendet werden, um eine Blockierung des Event-Loops zu vermeiden.

Fehlerbehandlung: Schlägt eine Methode fehl, gibt sie false zurück. Der Fehlercode ist über $client->errCode und die Fehlermeldung über swoole_strerror($client->errCode) abrufbar.

SSL-Sicherheit: Bei SSL-Verbindungen sollte ssl_verify_peer auf true gesetzt und eine gültige CA-Datei angegeben werden, um Man-in-the-Middle-Angriffe zu verhindern. Das Deaktivieren der Peer-Verifikation ist nur für Entwicklungsumgebungen akzeptabel.

Konfiguration: Über die Methode set(array $settings) lassen sich erweiterte Optionen wie Puffergrößen (socket_buffer_size), Keep-Alive (open_tcp_keepalive), Paketlängenprüfung (open_length_check, package_max_length) und SSL-Parameter konfigurieren.

Siehe auch

Swoole\Coroutine\Client Swoole\Server Swoole\Http\Client fsockopen stream_socket_client