Konstruktor __construct
Beschreibung:
Worker::__construct([string $listen , array $context])
Initialisiert eine Worker-Container-Instanz, die einige Eigenschaften und Callback-Interfaces des Containers einstellen kann, um spezifische Funktionen zu erfüllen.
Parameter
$listen （optional, nicht angegeben bedeutet, dass kein Port abgehört wird）
Wenn der Parameter $listen gesetzt ist, wird ein Socket-Abhören ausgeführt.
Das Format von $listen ist ://<Abhöradresse>
kann eines der folgenden Formate sein:
tcp: zum Beispiel tcp://0.0.0.0:8686
udp: zum Beispiel udp://0.0.0.0:8686
unix: zum Beispiel unix:///tmp/my_file (benötigt Workerman>=3.2.7)
http: zum Beispiel http://0.0.0.0:80
websocket: zum Beispiel websocket://0.0.0.0:8686
text: zum Beispiel text://0.0.0.0:8686 (text ist das in Workerman integrierte Textprotokoll, das mit telnet kompatibel ist; näheres siehe Anhang Textprotokoll)
und andere benutzerdefinierte Protokolle, siehe den Abschnitt über benutzerdefinierte Kommunikationsprotokolle in diesem Handbuch.
<Abhöradresse> kann eines der folgenden Formate sein:
Wenn es sich um einen Unix-Socket handelt, ist die Adresse ein lokaler Pfad auf der Festplatte.
Für nicht-Unix-Sockets hat die Adresse das Format :.
kann als ```0.0.0.0``` angegeben werden, um alle Netzwerkadapter des lokalen Hosts abzuhören, einschließlich interner IPs, externer IPs und der lokalen Schleife 127.0.0.1.
, wenn es ```127.0.0.1``` ist, bedeutet, dass nur die lokale Schleife abgehört wird, sodass nur lokalistisch darauf zugegriffen werden kann und von außen nicht zugänglich ist.
Wenn eine interne IP ist, ähnlich wie ```192.168.xx.xx```, bedeutet dies, dass nur die interne IP abgehört wird, sodass externe Benutzer keinen Zugriff haben.
Wenn der festgelegte Wert für nicht zur lokalen IP gehört, kann das Abhören nicht ausgeführt werden, und es wird der Fehler ```Cannot assign requested address``` angezeigt.
**Hinweis:** darf nicht größer als 65535 sein. muss größer oder gleich 1024 sein, um abgehört zu werden, es sei denn, es werden Root-Rechte verwendet. Der abgehörte Port muss auf dem lokalen Host nicht belegt sein, sonst kann nicht abgehört werden und es wird der Fehler ```Address already in use``` angezeigt.
#### **``` $context ```**
Ein Array. Wird verwendet, um die Socket-Kontextoptionen zu übergeben, siehe [Socket-Kontextoptionen](https://php.net/manual/de/context.socket.php).
## Beispiele
Worker als http-Container, der http-Anfragen verarbeitet
```php
use Workerman\Worker;
use Workerman\Connection\TcpConnection;
use Workerman\Protocols\Http\Request;
require_once __DIR__ . '/vendor/autoload.php';
$worker = new Worker('http://0.0.0.0:8686');
$worker->onMessage = function(TcpConnection $connection, Request $request)
{
$connection->send("hello");
};
// Worker ausführen
Worker::runAll();
```
Worker als websocket-Container, der websocket-Anfragen verarbeitet
```php
use Workerman\Worker;
use Workerman\Connection\TcpConnection;
require_once __DIR__ . '/vendor/autoload.php';
$worker = new Worker('websocket://0.0.0.0:8686');
$worker->onMessage = function(TcpConnection $connection, $data)
{
$connection->send("hello");
};
// Worker ausführen
Worker::runAll();
```
Worker als tcp-Container, der tcp-Anfragen verarbeitet
```php
use Workerman\Worker;
use Workerman\Connection\TcpConnection;
require_once __DIR__ . '/vendor/autoload.php';
$worker = new Worker('tcp://0.0.0.0:8686');
$worker->onMessage = function(TcpConnection $connection, $data)
{
$connection->send("hello");
};
// Worker ausführen
Worker::runAll();
```
Worker als udp-Container, der udp-Anfragen verarbeitet
```php
use Workerman\Worker;
use Workerman\Connection\TcpConnection;
require_once __DIR__ . '/vendor/autoload.php';
$worker = new Worker('udp://0.0.0.0:8686');
$worker->onMessage = function(TcpConnection $connection, $data)
{
$connection->send("hello");
};
// Worker ausführen
Worker::runAll();
```
Worker, der einen Unix-Domain-Socket abgehört ```(benötigt Workerman Version>=3.2.7)```
```php
use Workerman\Worker;
use Workerman\Connection\TcpConnection;
require_once __DIR__ . '/vendor/autoload.php';
$worker = new Worker('unix:///tmp/my.sock');
$worker->onMessage = function(TcpConnection $connection, $data)
{
$connection->send("hello");
};
// Worker ausführen
Worker::runAll();
```
Worker-Container ohne Abhörung, um einige geplante Aufgaben zu verarbeiten
```php
use \Workerman\Worker;
use \Workerman\Timer;
require_once __DIR__ . '/vendor/autoload.php';
$task = new Worker();
$task->onWorkerStart = function($task)
{
// Alle 2,5 Sekunden ausführen
$time_interval = 2.5;
Timer::add($time_interval, function()
{
echo "task run\n";
});
};
// Worker ausführen
Worker::runAll();
```
**Worker, der einen benutzerdefinierten Protokollport abhorcht**
Endgültige Verzeichnisstruktur
```
├── Protocols // Dies ist das zu erstellende Protocols-Verzeichnis
│ └── MyTextProtocol.php // Dies ist die zu erstellende benutzerdefinierte Protokolldatei
├── test.php // Dies ist die zu erstellende Test-Skriptdatei
└── Workerman // Workerman Quellverzeichnis, der Code darin darf nicht verändert werden
```
1. Erstelle das Protocols-Verzeichnis und erstelle eine Protokolldatei.
Protocols/MyTextProtocol.php (gemäß der oben genannten Verzeichnisstruktur)
```php
// Der namespace für benutzerdefinierte Protokolle ist einheitlich Protocols
namespace Protocols;
// Einfaches Textprotokoll, das Protokollformat ist Text+Zeilenumbruch
class MyTextProtocol
{
// Splitting-Funktion, gibt die Länge des aktuellen Pakets zurück
public static function input($recv_buffer)
{
// Zeilenumbruch suchen
$pos = strpos($recv_buffer, "\n");
// Wurde kein Zeilenumbruch gefunden, handelt es sich nicht um ein vollständiges Paket, 0 zurückgeben und auf Daten warten
if($pos === false)
{
return 0;
}
// Zeilenumbruch gefunden, die Länge des aktuellen Pakets zurückgeben, einschließlich des Zeilenumbruchs
return $pos+1;
}
// Nach Erhalt eines vollständigen Pakets wird automatisch decodiert, hier wird nur der Zeilenumbruch entfernt
public static function decode($recv_buffer)
{
return trim($recv_buffer);
}
// Vor dem Senden von Daten an den Client wird sie automatisch codiert und dann an den Client gesendet, hier wird ein Zeilenumbruch hinzugefügt
public static function encode($data)
{
return $data."\n";
}
}
```
2. Verwenden Sie das MyTextProtocol-Protokoll, um Anfragen zu verarbeiten.
Erstellen Sie die Testdatei test.php gemäß der endgültigen Verzeichnisstruktur.
```php
use Workerman\Worker;
use Workerman\Connection\TcpConnection;
require_once __DIR__ . '/vendor/autoload.php';
// #### MyTextProtocol worker ####
$text_worker = new Worker("MyTextProtocol://0.0.0.0:5678");
/*
* Wenn vollständige Daten (geendet mit Zeilenumbruch) empfangen werden, wird automatisch MyTextProtocol::decode('empfangene Daten') ausgeführt.
* Das Ergebnis wird über $data an den onMessage-Callback übergeben.
*/
$text_worker->onMessage = function(TcpConnection $connection, $data)
{
var_dump($data);
/*
* Daten an den Client senden, MyTextProtocol::encode('hello world') wird automatisch für die Protokollcodierung aufgerufen
* und dann an den Client gesendet.
*/
$connection->send("hello world");
};
// Alle Worker ausführen
Worker::runAll();
```
3. Testen
Öffnen Sie das Terminal, gehen Sie zum Verzeichnis von test.php und führen Sie ```php test.php start``` aus.
```
php test.php start
Workerman[test.php] im DEBUG-Modus gestartet
----------------------- WORKERMAN -----------------------------
Workerman-Version:3.2.7 PHP-Version:5.4.37
------------------------ WORKERS -------------------------------
Benutzer Worker Abhören Prozesse Status
root none myTextProtocol://0.0.0.0:5678 1 [OK]
----------------------------------------------------------------
Drücken Sie Ctrl-C, um zu beenden. Start erfolgreich.
```
Öffnen Sie ein Terminal und testen Sie mit telnet (empfohlen wird telnet auf Linux-Systemen).
Angenommen, es handelt sich um einen lokalen Test,
im Terminal führen Sie telnet 127.0.0.1 5678 aus
und geben dann hi ein und drücken die Eingabetaste.
Es wird die Antwort hello world\n empfangen.
```
telnet 127.0.0.1 5678
Versuche 127.0.0.1...
Verbunden mit 127.0.0.1.
Fluchzeichen ist '^>'.
hi
hello world
```