Constructor __construct
Descripción:
Worker::__construct([string $listen , array $context])
Inicializa una instancia del contenedor Worker, y permite establecer algunas propiedades del contenedor y las interfaces de devolución de llamada para completar funciones específicas.
Parámetros
$listen (parámetro opcional, no especificar significa que no se escuchará ningún puerto)
Si se especifica el parámetro de escucha $listen, se ejecutará la escucha de sockets.
El formato de $listen es ://<dirección de escucha>
puede ser de los siguientes formatos:
tcp: por ejemplo tcp://0.0.0.0:8686
udp: por ejemplo udp://0.0.0.0:8686
unix: por ejemplo unix:///tmp/my_file (requiere Workerman>=3.2.7)
http: por ejemplo http://0.0.0.0:80
websocket: por ejemplo websocket://0.0.0.0:8686
text: por ejemplo text://0.0.0.0:8686 (text es el protocolo de texto integrado de Workerman, compatible con telnet, consulta la sección del protocolo Text en el apéndice)
Y otros protocolos personalizados, consulta la sección de protocolos de comunicación personalizados de este manual.
<dirección de escucha> puede ser de los siguientes formatos:
Si es un socket unix, la dirección es una ruta en el disco local.
Para sockets no unix, el formato de dirección es :<número de puerto>.
puede ser ```0.0.0.0``` para escuchar todas las interfaces de red de la máquina local, incluyendo IPs de red interna y externa, así como el bucle local 127.0.0.1.
si es ```127.0.0.1``` significa que solo se escuchará el bucle local, accesible solo desde la máquina local, no desde el exterior.
si es una IP de red interna, como ```192.168.xx.xx```, significa que solo se escucha la IP de la red interna, por lo que los usuarios externos no pueden acceder.
si el valor configurado no pertenece a las IPs de la máquina local, no se podrá ejecutar la escucha y se mostrará el error ```Cannot assign requested address```.
**Nota:** no puede ser mayor que 65535. si es menor que 1024 requiere permisos de root para poder escucharlo. El puerto escuchado debe ser uno no ocupado en la máquina local, de lo contrario no se podrá escuchar y se mostrará el error ```Address already in use```.
#### **``` $context ```**
Es un array. Se utiliza para pasar opciones de contexto de socket, consulta [opciones de contexto de socket](https://php.net/manual/zh/context.socket.php).
## Ejemplos
Worker como contenedor http para escuchar y manejar solicitudes 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");
};
// Ejecutar worker
Worker::runAll();
```
Worker como contenedor websocket para escuchar y manejar solicitudes 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");
};
// Ejecutar worker
Worker::runAll();
```
Worker como contenedor tcp para escuchar y manejar solicitudes 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");
};
// Ejecutar worker
Worker::runAll();
```
Worker como contenedor udp para escuchar y manejar solicitudes 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");
};
// Ejecutar worker
Worker::runAll();
```
Worker escucha un socket de dominio unix ```(requiere Workerman versión >=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");
};
// Ejecutar worker
Worker::runAll();
```
Contenedor Worker que no realiza ninguna escucha, utilizado para manejar algunas tareas programadas
```php
use \Workerman\Worker;
use \Workerman\Timer;
require_once __DIR__ . '/vendor/autoload.php';
$task = new Worker();
$task->onWorkerStart = function($task)
{
// Se ejecuta cada 2.5 segundos
$time_interval = 2.5;
Timer::add($time_interval, function()
{
echo "task run\n";
});
};
// Ejecutar worker
Worker::runAll();
```
**Worker escucha un puerto de protocolo personalizado**
Estructura de directorio final
```
├── Protocols // Este es el directorio Protocols a crear
│ └── MyTextProtocol.php // Este es el archivo de protocolo personalizado a crear
├── test.php // Este es el script de prueba a crear
└── Workerman // Directorio de código fuente de Workerman, no modificar el código dentro
```
1. Crear el directorio Protocols y crear un archivo de protocolo.
Protocols/MyTextProtocol.php (según la estructura de directorio anterior)
```php
// El espacio de nombres del protocolo personalizado del usuario se unifica a Protocols
namespace Protocols;
// Protocolo de texto simple, el formato del protocolo es texto + salto de línea
class MyTextProtocol
{
// Función de fragmentación, devuelve la longitud del paquete actual
public static function input($recv_buffer)
{
// Buscar el carácter de salto de línea
$pos = strpos($recv_buffer, "\n");
// No se encontró el salto de línea, significa que no es un paquete completo, devolver 0 y continuar esperando datos
if($pos === false)
{
return 0;
}
// Se encontró el salto de línea, devolver la longitud del paquete actual, incluyendo el salto de línea
return $pos+1;
}
// Al recibir un paquete completo, se decodifica automáticamente a través de decode, aquí solo se elimina el salto de línea
public static function decode($recv_buffer)
{
return trim($recv_buffer);
}
// Antes de enviar datos al cliente, se codificarán automáticamente a través de encode, y luego se enviarán al cliente, aquí se agrega un salto de línea
public static function encode($data)
{
return $data."\n";
}
}
```
2. Usar el protocolo MyTextProtocol para escuchar y manejar solicitudes.
Crear el archivo test.php según la estructura de directorio final anterior.
```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");
/*
* Al recibir datos completos (terminados en salto de línea), se ejecutará automáticamente MyTextProtocol::decode('datos recibidos')
* Los resultados se pasan a la devolución de llamada onMessage a través de $data
*/
$text_worker->onMessage = function(TcpConnection $connection, $data)
{
var_dump($data);
/*
* Al enviar datos al cliente, se llamará automáticamente a MyTextProtocol::encode('hello world') para realizar la codificación del protocolo,
* y luego se enviarán al cliente
*/
$connection->send("hello world");
};
// ejecutar todos los workers
Worker::runAll();
```
3. Prueba
Abre una terminal, navega al directorio donde se encuentra test.php, y ejecuta ```php test.php start```
```
php test.php start
Workerman[test.php] start en modo DEBUG
----------------------- WORKERMAN -----------------------------
Versión de Workerman:3.2.7 Versión de PHP:5.4.37
------------------------ WORKERS -------------------------------
usuario worker escuchar procesos estado
root none myTextProtocol://0.0.0.0:5678 1 [OK]
----------------------------------------------------------------
Presiona Ctrl-C para salir. Inicio exitoso.
```
Abre otra terminal y utiliza telnet para probar (se recomienda usar telnet en sistemas linux).
Supongamos que es una prueba en la máquina local,
en la terminal ejecuta telnet 127.0.0.1 5678
luego escribe hi y presiona enter
recibirás los datos hello world\n
```
telnet 127.0.0.1 5678
Intentando 127.0.0.1...
Conectado a 127.0.0.1.
El carácter de escape es '^>'.
hi
hello world
```