thinkphp 6.0 swoole étend l'utilisation de websocket

La colonne de didacticiel suivante du thinkphp framework vous présentera le didacticiel d'utilisation étendue du websocket thinkphp 6.0 swoole (think-swoole) (j'espère qu'il sera utile aux amis dans le besoin). !

Tutoriel d'utilisation étendue de Websocket Thinkphp 6.0 swoole (think-swoole)

Avant-propos

La dernière version de TP-SWOOLE a beaucoup changé, et la méthode fournie dans cet article ne peut plus être utilisé, vous pouvez vous référer à https://github.com/xavieryang007/think-swoole-demo/blob/master/doc/%E6%96%87%E6%A1%A3/4.1-websocket.md

Introduction

Le prochain tp6.0 a été adapté à swoole et think-swoole 3.0 a été lancé et est adapté à socketio par défaut. La méthode d'utilisation est légèrement différente de la version 2.0.

Websocket hérite de Http. Une requête HTTP est requise avant la connexion au websocket. Si l'adresse actuelle prend en charge le websocket, 101 sera renvoyé, puis la connexion sera établie. En d'autres termes, ce n'est pas qu'une fois que mon service prend en charge websocket, chaque adresse de connexion demandée puisse être connectée au websocket, mais elle doit être pré-adaptée avant de pouvoir être connectée.

Configuration des paramètres

Si vous souhaitez utiliser websocket, vous devez l'activer dans la configuration. Définissez l'activation sous websocket sur true

 'server'           => [
        'host'      => '0.0.0.0', // 监听地址
        'port'      => 808, // 监听端口
        'mode'      => SWOOLE_PROCESS, // 运行模式 默认为SWOOLE_PROCESS
        'sock_type' => SWOOLE_SOCK_TCP, // sock type 默认为SWOOLE_SOCK_TCP
        'options'   => [
            'pid_file'              => runtime_path() . 'swoole.pid',
            'log_file'              => runtime_path() . 'swoole.log',
            'daemonize'             => false,
            // Normally this value should be 1~4 times larger according to your cpu cores.
            'reactor_num'           => swoole_cpu_num(),
            'worker_num'            => swoole_cpu_num(),
            'task_worker_num'       => 4,//swoole_cpu_num(),
            'enable_static_handler' => true,
            'document_root'         => root_path('public'),
            'package_max_length'    => 20 * 1024 * 1024,
            'buffer_output_size'    => 10 * 1024 * 1024,
            'socket_buffer_size'    => 128 * 1024 * 1024,
            'max_request'           => 3000,
            'send_yield'            => true,
        ],
    ],
    'websocket'        => [
        'enabled'       => true,// 开启websocket
        'handler'       => Handler::class,  //自定义wbesocket绑定类
        'parser'        => Parser::class, //自定义解析类
        'route_file'    => base_path() . 'websocket.php',
        'ping_interval' => 25000,
        'ping_timeout'  => 60000,
        'room'          => [
            'type'        => TableRoom::class,
            'room_rows'   => 4096,
            'room_size'   => 2048,
            'client_rows' => 8192,
            'client_size' => 2048,
        ],
    ],
    'auto_reload'      => true,
    'enable_coroutine' => true,
    'resetters'        => [],
    'tables'           => [],

le gestionnaire et l'analyseur facilitent grandement la personnalisation de websocket. services. Le système par défaut intègre socketio.

Cet article présente principalement comment utiliser socketio. On suppose que tout le monde a une certaine compréhension et base d'utilisation de socketio.

socketIo ajoutera les paramètres correspondants après l'adresse de la requête par défaut

En même temps, socketio pensera http://url/socket.io par par défaut / est l'adresse qui prend en charge le service Websocket.

La demande d'adresse a été traitée en interne dans tp-swoole3.0

<?php namespace think\swoole\websocket\socketio;

use think\Config;
use think\Cookie;
use think\Request;

class Controller
{
    protected $transports = [&#39;polling&#39;, &#39;websocket&#39;];

    public function upgrade(Request $request, Config $config, Cookie $cookie)
    {
        if (!in_array($request->param('transport'), $this->transports)) {
            return json(
                [
                    'code'    => 0,
                    'message' => 'Transport unknown',
                ],
                400
            );
        }

        if ($request->has('sid')) {
            $response = response('1:6');
        } else {
            $sid     = base64_encode(uniqid());
            $payload = json_encode(
                [
                    'sid'          => $sid,
                    'upgrades'     => ['websocket'],
                    'pingInterval' => $config->get('swoole.websocket.ping_interval'),
                    'pingTimeout'  => $config->get('swoole.websocket.ping_timeout'),
                ]
            );
            $cookie->set('io', $sid);
            $response = response('97:0' . $payload . '2:40');
        }

        return $response->contentType('text/plain');
    }

    public function reject(Request $request)
    {
        return json(
            [
                'code'    => 3,
                'message' => 'Bad request',
            ],
            400
        );
    }
}

TP6.0, l'enregistrement du plug-in s'effectue en mode service Pour inscrivez-vous, vous pouvez afficher les informations d'enregistrement de l'itinéraire dans le fichier d'enregistrement du service tp-swoole. Si vous souhaitez personnaliser les règles de lien, vous pouvez remplacer l'itinéraire.

<?php // +----------------------------------------------------------------------
// | ThinkPHP [ WE CAN DO IT JUST THINK IT ]
// +----------------------------------------------------------------------
// | Copyright (c) 2006-2018 http://thinkphp.cn All rights reserved.
// +----------------------------------------------------------------------
// | Licensed ( http://www.apache.org/licenses/LICENSE-2.0 )
// +----------------------------------------------------------------------
// | Author: yunwuxin <448901948@qq.com>
// +----------------------------------------------------------------------

namespace think\swoole;

use Swoole\Http\Server as HttpServer;
use Swoole\Websocket\Server as WebsocketServer;
use think\App;
use think\Route;
use think\swoole\command\Server as ServerCommand;
use think\swoole\facade\Server;
use think\swoole\websocket\socketio\Controller;
use think\swoole\websocket\socketio\Middleware;

class Service extends \think\Service
{
    protected $isWebsocket = false;

    /**
     * @var HttpServer | WebsocketServer
     */
    protected static $server;

    public function register()
    {
        $this->isWebsocket = $this->app->config->get('swoole.websocket.enabled', false);

        $this->app->bind(Server::class, function () {
            if (is_null(static::$server)) {
                $this->createSwooleServer();
            }

            return static::$server;
        });

        $this->app->bind('swoole.server', Server::class);

        $this->app->bind(Swoole::class, function (App $app) {
            return new Swoole($app);
        });

        $this->app->bind('swoole', Swoole::class);
    }

    public function boot(Route $route)
    {
        $this->commands(ServerCommand::class);
        if ($this->isWebsocket) {
            $route->group(function () use ($route) {
                $route->get('socket.io/', '@upgrade');
                $route->post('socket.io/', '@reject');
            })->prefix(Controller::class)->middleware(Middleware::class);
        }
    }

    /**
     * Create swoole server.
     */
    protected function createSwooleServer()
    {
        $server     = $this->isWebsocket ? WebsocketServer::class : HttpServer::class;
        $config     = $this->app->config;
        $host       = $config->get('swoole.server.host');
        $port       = $config->get('swoole.server.port');
        $socketType = $config->get('swoole.server.socket_type', SWOOLE_SOCK_TCP);
        $mode       = $config->get('swoole.server.mode', SWOOLE_PROCESS);

        static::$server = new $server($host, $port, $mode, $socketType);

        $options = $config->get('swoole.server.options');

        static::$server->set($options);
    }
}

Socketio utilise la démo par défaut

nbsp;html>


    <meta>
    <title>Title</title>
    <script></script>


<script>
    const socket = io(&#39;http://localhost:808&#39;);
    socket.emit("test", "your message");
    socket.on("test",function(res){console.log(res)});
</script>

Méthode de configuration du routage Websocket

Créez un nouveau fichier websocket.php dans le répertoire de l'application. Notez qu'en raison de l'utilisation de la réflexion, paramètres de fermeture Le nom ne peut pas être défini arbitrairement, sinon il ne peut pas être injecté. Le premier paramètre est websocket, qui est l'objet serveur du websocket actuel, et le deuxième paramètre data est les données envoyées par le client. Le premier paramètre de socketio submit est le même que le premier paramètre de Websocket::on, qui est utilisé comme nom d'événement.

<?php /**
 * Author:Xavier Yang
 * Date:2019/6/5
 * Email:499873958@qq.com
 */

use \think\swoole\facade\Websocket;

Websocket::on("test", function (\think\swoole\Websocket $websocket, $data) {
    //var_dump($class);
    $websocket->emit("test", "asd");
});

Websocket::on("test1", function ($websocket, $data) {
    $websocket->emit("test", "asd");
});

Websocket::on("join", function (\think\swoole\Websocket $websocket, $data) {
    $websocket->join("1");
});

Référez-vous à la méthode ci-dessus pour utiliser le nouveau service websocket. Bien entendu, tp-swoole3.0 possède également de nombreuses autres nouvelles fonctionnalités que vous devez explorer et essayer.
Je partagerai également avec vous mon processus d'utilisation dans le prochain article.

Ce qui précède est le contenu détaillé de. pour plus d'informations, suivez d'autres articles connexes sur le site Web de PHP en chinois!