Criando Aplicações PHP de Alto Desempenho com Swoole
O que é Swoole?
Swoole é um framework de comunicação de rede de alto desempenho para PHP, que oferece funções assíncronas, multithread e corrotinas, permitindo que o PHP lide com tarefas de alta concorrência, semelhante ao Node.js. Ele suporta vários protocolos como TCP, UDP, UnixSocket, HTTP e WebSocket, sendo adequado para a construção de servidores web de alto desempenho, arquitetura de microsserviços, sistemas de comunicação em tempo real, entre outros.
Principais Recursos e Vantagens do Swoole
- Alto Desempenho: Swoole é escrito em C, oferecendo desempenho extremamente alto, suporte a I/O assíncrono e corrotinas, e a capacidade de lidar com solicitações altamente concorrentes.
- Rico em Funcionalidades: Suporta vários protocolos de rede, timers, gerenciamento de processos, gerenciamento de memória, entre outros recursos, atendendo a diversas necessidades de desenvolvimento.
- Fácil de Usar: Fornece uma API simplificada e documentação abrangente, ajudando os desenvolvedores a começarem rapidamente.
- Alta Extensibilidade: Suporta extensões e plugins personalizados, permitindo uma customização flexível conforme a necessidade.
Swoole é a escolha ideal para construir aplicativos web de alto desempenho e sistemas de comunicação em tempo real, sendo adequado para projetos pequenos e para grandes sistemas empresariais.
Instalando o Swoole
Neste artigo, vamos mostrar como instalar e usar o Swoole em um ambiente ServBay.
TIP
A ServBay recomenda que os desenvolvedores coloquem o site no diretório /Applications/ServBay/www
para facilitar o gerenciamento.
Passo 1: Instalar a extensão Swoole
Habilitando a Extensão Swoole
A ServBay já vem com a extensão Swoole embutida, os usuários precisam habilitá-la e reiniciar o PHP. Consulte o artigo Como habilitar o módulo Swoole embutido na ServBay para habilitar o módulo Swoole.
Passo 2: Criar o Diretório do Projeto
Crie o diretório do projeto e acesse-o:
cd /Applications/ServBay/www
mkdir servbay-swoole-app
cd servbay-swoole-app
2
3
Passo 3: Criar o Script do Servidor Swoole
Crie um arquivo server.php
no diretório do projeto para configurar um simples servidor HTTP Swoole:
<?php
use Swoole\Http\Server;
use Swoole\Http\Request;
use Swoole\Http\Response;
$server = new Server("0.0.0.0", 9501);
$server->on("start", function (Server $server) {
echo "Servidor HTTP Swoole iniciado em http://0.0.0.0:9501\n";
});
$server->on("request", function (Request $request, Response $response) {
$response->header("Content-Type", "text/plain");
$response->end("Olá, ServBay!");
});
$server->start();
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
Passo 4: Executar o Servidor Swoole
No terminal, execute o seguinte comando para iniciar o servidor Swoole:
php server.php
Você verá a seguinte saída:
Servidor HTTP Swoole iniciado em http://0.0.0.0:9501
Passo 5: Acessar o Servidor Swoole
Abra o navegador e acesse http://localhost:9501
. Você verá a página exibindo Olá, ServBay!
.
Construindo Aplicações Web com Swoole
Nesta parte, mostraremos como usar o Swoole para construir uma aplicação web simples.
Criar Controladores e Rotas
No diretório do projeto, crie um diretório app
e dentro dele crie os diretórios controllers
e routes
:
mkdir -p app/controllers
mkdir -p app/routes
2
Crie um arquivo HomeController.php
no diretório app/controllers
:
<?php
namespace App\Controllers;
class HomeController
{
public function index()
{
return "Bem-vindo ao ServBay!";
}
public function hello($name)
{
return "Olá, $name!";
}
}
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
Crie um arquivo web.php
no diretório app/routes
:
<?php
use App\Controllers\HomeController;
return [
'GET /' => [HomeController::class, 'index'],
'GET /hello/{name}' => [HomeController::class, 'hello'],
];
2
3
4
5
6
7
8
Atualizar o Script do Servidor Swoole
Atualize o arquivo server.php
para incluir o parsing de rotas e a lógica de chamada dos controladores:
<?php
use Swoole\Http\Server;
use Swoole\Http\Request;
use Swoole\Http\Response;
use FastRoute\RouteCollector;
use function FastRoute\simpleDispatcher;
require 'vendor/autoload.php';
$server = new Server("0.0.0.0", 9501);
$routes = require __DIR__ . '/app/routes/web.php';
$dispatcher = simpleDispatcher(function (RouteCollector $r) use ($routes) {
foreach ($routes como $route => $handler) {
[$method, $path] = explode(' ', $route);
$r->addRoute($method, $path, $handler);
}
});
$server->on("start", function (Server $server) {
echo "Servidor HTTP Swoole iniciado em http://0.0.0.0:9501\n";
});
$server->on("request", function (Request $request, Response $response) use ($dispatcher) {
$routeInfo = $dispatcher->dispatch($request->server['request_method'], $request->server['request_uri']);
switch ($routeInfo[0]) {
case \FastRoute\Dispatcher::NOT_FOUND:
$response->status(404);
$response->end('404 Não Encontrado');
break;
caso \FastRoute\Dispatcher::METHOD_NOT_ALLOWED:
$response->status(405);
$response->end('405 Método Não Permitido');
break;
caso \FastRoute\Dispatcher::FOUND:
$handler = $routeInfo[1];
$vars = $routeInfo[2];
[$class, $method] = $handler;
$response->header("Content-Type", "text/plain");
$response->end(call_user_func_array([new $class, $method], $vars));
break;
}
});
$server->start();
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
Instalar o FastRoute
No diretório raiz do projeto, execute o seguinte comando para instalar a biblioteca de roteamento FastRoute:
composer require nikic/fast-route
Executar o Servidor Swoole
No terminal, execute o seguinte comando para iniciar o servidor Swoole:
php server.php
Acessar a Aplicação Web
Abra o navegador e acesse as seguintes URLs:
http://localhost:9501/
: Você verá a página exibindoBem-vindo ao ServBay!
.http://localhost:9501/hello/ServBay
: Você verá a página exibindoOlá, ServBay!
.
Lidando com Conexões WebSocket com Swoole
O Swoole também suporta o protocolo WebSocket, podendo ser usado para construir aplicativos de comunicação em tempo real. Vamos mostrar como lidar com conexões WebSocket usando o Swoole.
Criar o Script do Servidor WebSocket
Crie um arquivo websocket_server.php
no diretório do projeto, para configurar um simples servidor WebSocket:
<?php
use Swoole\WebSocket\Server;
use Swoole\Http\Request;
use Swoole\WebSocket\Frame;
$server = new Server("0.0.0.0", 9502);
$server->on("start", function (Server $server) {
echo "Servidor WebSocket Swoole iniciado em ws://0.0.0.0:9502\n";
});
$server->on("open", function (Server $server, Request $request) {
echo "conexão aberta: {$request->fd}\n";
});
$server->on("message", function (Server $server, Frame $frame) {
echo "mensagem recebida: {$frame->data}\n";
$server->push($frame->fd, "Olá, {$frame->data}");
});
$server->on("close", function ($ser, $fd) {
echo "conexão fechada: {$fd}\n";
});
$server->start();
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
Executar o Servidor WebSocket
No terminal, execute o seguinte comando para iniciar o servidor WebSocket:
php websocket_server.php
Você verá a seguinte saída:
Servidor WebSocket Swoole iniciado em ws://0.0.0.0:9502
Conectar ao Servidor WebSocket
Você pode usar um cliente WebSocket no navegador ou outras ferramentas de cliente WebSocket (como wscat
) para se conectar ao servidor WebSocket.
Conectar usando wscat
Instale o
wscat
:bashnpm install -g wscat
1Conecte-se ao servidor WebSocket:
bashwscat -c ws://localhost:9502
1Envie uma mensagem:
bash> Olá ServBay
1
Você verá a mensagem retornada pelo servidor:
< Olá, Olá ServBay
Seguindo os passos acima, você terá criado e executado com sucesso um projeto Swoole, usando as funcionalidades do Swoole para lidar com solicitações HTTP e conexões WebSocket. O alto desempenho e funcionalidades ricas do Swoole fazem dele uma escolha ideal para construir aplicações de alta concorrência.