Costruttore __construct
Descrizione:
Worker::__construct([string $listen , array $context])
Inizializza un'istanza del contenitore Worker, permettendo di impostare alcune proprietà e callback del contenitore per completare funzioni specifiche.
Parametri
$listen （parametro opzionale, omesso indica di non ascoltare alcuna porta）
Se è impostato il parametro di ascolto $listen, verrà eseguita l'ascolto del socket.
Il formato di $listen è ://
può essere nei seguenti formati:
tcp: ad esempio tcp://0.0.0.0:8686
udp: ad esempio udp://0.0.0.0:8686
unix: ad esempio unix:///tmp/my_file (richiede Workerman>=3.2.7)
http: ad esempio http://0.0.0.0:80
websocket: ad esempio websocket://0.0.0.0:8686
text: ad esempio text://0.0.0.0:8686 (text è il protocollo di testo integrato in Workerman, compatibile con telnet, vedi dettagli nella sezione appendice Protocollo Text)
e altri protocolli personalizzati, fare riferimento alla sezione di personalizzazione del protocollo di comunicazione di questo documento.
può essere nei seguenti formati:
Se è un socket unix, l'indirizzo è un percorso del disco locale.
Per i socket non unix, il formato dell'indirizzo è :
può essere ```0.0.0.0``` per ascoltare su tutte le interfacce di rete, inclusi ip privati e pubblici e l'interfaccia di loopback locale 127.0.0.1.
Se è ```127.0.0.1```, significa che ascolterà solo sull'interfaccia loopback locale, accessibile solo localmente, non da altre macchine.
Se è un ip privato, come ```192.168.xx.xx```, significa che ascolterà solo su quell'ip privato, e quindi gli utenti esterni non potranno accedervi.
Se il valore impostato su non appartiene all'ip della macchina, non sarà possibile eseguire l'ascolto, e verrà visualizzato l'errore ```Cannot assign requested address```.
**Nota:** non può essere maggiore di 65535. Se è minore di 1024 è necessaria l'autenticazione come root per ascoltare. La porta di ascolto deve essere una porta non occupata dalla macchina, altrimenti non sarà possibile ascoltare, e verrà visualizzato l'errore ```Address already in use```.
#### **``` $context ```**
Un array. Viene utilizzato per passare le opzioni di contesto del socket, vedere [opzioni di contesto del socket](https://php.net/manual/it/context.socket.php).
## Esempi
Worker come contenitore http per ascoltare e gestire richieste http
```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");
};
// Esegui worker
Worker::runAll();
```
Worker come contenitore websocket per ascoltare e gestire richieste websocket
```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");
};
// Esegui worker
Worker::runAll();
```
Worker come contenitore tcp per ascoltare e gestire richieste tcp
```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");
};
// Esegui worker
Worker::runAll();
```
Worker come contenitore udp per ascoltare e gestire richieste udp
```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");
};
// Esegui worker
Worker::runAll();
```
Worker che ascolta i socket di dominio unix ```(richiede Workerman >= 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");
};
// Esegui worker
Worker::runAll();
```
Worker che non esegue alcun ascolto, utilizzato per gestire alcuni compiti programmati
```php
use \Workerman\Worker;
use \Workerman\Timer;
require_once __DIR__ . '/vendor/autoload.php';
$task = new Worker();
$task->onWorkerStart = function($task)
{
// Esegui ogni 2.5 secondi
$time_interval = 2.5;
Timer::add($time_interval, function()
{
echo "task run\n";
});
};
// Esegui worker
Worker::runAll();
```
**Worker che ascolta le porte del protocollo personalizzato**
Struttura finale delle directory
```
├── Protocols // Questa è la directory Protocols da creare
│ └── MyTextProtocol.php // Questo è il file di protocollo personalizzato da creare
├── test.php // Questo è lo script test da creare
└── Workerman // Directory sorgente di Workerman, non modificare il codice interno
```
1. Creare la directory Protocols e creare un file di protocollo
Protocols/MyTextProtocol.php（fare riferimento alla struttura delle directory sopra）
```php
// Lo spazio dei nomi del protocollo personalizzato deve essere unificato con Protocols
namespace Protocols;
// Protocollo di testo semplice, il formato del protocollo è testo+nuova riga
class MyTextProtocol
{
// Funzione di frammentazione, restituisce la lunghezza del pacchetto attuale
public static function input($recv_buffer)
{
// Cerca il carattere di nuova riga
$pos = strpos($recv_buffer, "\n");
// Se non viene trovato, significa che non è un pacchetto completo, restituisce 0 e continua ad attendere dati
if($pos === false)
{
return 0;
}
// Se viene trovato il carattere di nuova riga, restituisce la lunghezza del pacchetto attuale, inclusa la nuova riga
return $pos+1;
}
// Dopo aver ricevuto un pacchetto completo, viene automaticamente decodificato tramite decode, qui viene solo rimosso il carattere di nuova riga
public static function decode($recv_buffer)
{
return trim($recv_buffer);
}
// Prima di inviare dati al client, verrà automaticamente codificato tramite encode e quindi inviato al client, qui viene aggiunta una nuova riga
public static function encode($data)
{
return $data."\n";
}
}
```
2. Usare il protocollo MyTextProtocol per ascoltare e gestire le richieste
Creare il file test.php secondo la struttura finale delle directory sopra
```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");
/*
* Dopo aver ricevuto un dato completo (con una nuova riga alla fine), viene eseguito automaticamente MyTextProtocol::decode('i dati ricevuti')
* Il risultato viene passato al callback onMessage attraverso $data
*/
$text_worker->onMessage = function(TcpConnection $connection, $data)
{
var_dump($data);
/*
* L'invio di dati al client chiamerà automaticamente MyTextProtocol::encode('hello world') per l codifica del protocollo,
* e poi lo invierà al client
*/
$connection->send("hello world");
};
// Esegui tutti i worker
Worker::runAll();
```
3. Test
Aprire un terminale, entrare nella directory in cui si trova test.php ed eseguire ```php test.php start```
```
php test.php start
Workerman[test.php] avviato in modalità DEBUG
----------------------- WORKERMAN -----------------------------
Versione Workerman:3.2.7 Versione PHP:5.4.37
------------------------ WORKERS -------------------------------
utente worker ascolto processi stato
root none myTextProtocol://0.0.0.0:5678 1 [OK]
----------------------------------------------------------------
Premere Ctrl-C per uscire. Avvio riuscito.
```
Aprire un terminale e testare con telnet (si consiglia di utilizzare telnet su sistemi linux)
Assumendo che sia un test locale,
Eseguire nel terminale telnet 127.0.0.1 5678
Quindi digitare hi e premere invio
Si riceverà il dato hello world\n
```
telnet 127.0.0.1 5678
Trying 127.0.0.1...
Connected to 127.0.0.1.
Escape character is '^]'.
hi
hello world
```