Versuchen Sie, die Laravel-Version in die Swoole-Version zu ändern

Dieser Artikel vermittelt Ihnen relevantes Wissen über Laravel und Swoole. Der Hauptinhalt besteht darin, Ihnen beizubringen, wie Sie Laravel auf die Swoole-Version umstellen (versuchen Sie es zu lernen, es wird nicht empfohlen, das vorhandene Projekt zu ändern). Ich hoffe, es wird für alle hilfreich sein!

Forword

not für die Produktionsumgebung empfohlen

Schalten Sie ein neues Laravel Project

rrree

change Laravel zu, um eine Datei der SWOOLE -Version zu erhalten. / Kopieren Sie den Code in index.php [Empfohlenes Lernen: Laravel-Video-Tutorial

]

laravel new swoole-laravel

Der erste Schritt besteht darin, die Framework-Datei zu laden. Sie sollte im Hauptprozess geladen werden, ohne dass Unterprozesse oder Unterprozesse erforderlich sind Die Coroutine wird erneut geladen werden. Daher müssen die oben genannten Anforderungen nicht berührt werden.

Der zweite Schritt besteht darin, einen HTTP-Swoole-Dienst zu starten. Dies wurde bereits oft erwähnt. Beachten Sie, dass wir in onRequest den $kernel-bezogenen Code einfügen sollten.

<?php
use Illuminate\Contracts\Http\Kernel;
use Illuminate\Http\Request;
define(&#39;LARAVEL_START&#39;, microtime(true));
require __DIR__.&#39;/../vendor/autoload.php&#39;;
$app = require_once __DIR__.&#39;/../bootstrap/app.php&#39;;
$kernel = $app->make(Kernel::class);
$response = $kernel->handle(
    $request = Request::capture()
)->send();
$kernel->terminate($request, $response);

Ist das genug? Warum probieren Sie es nicht erst einmal aus? Unter normalen Umständen können Sie möglicherweise keine Ein- oder Ausgabe erhalten. Warum ist das so?

Der dritte Schritt besteht darin, das Eingabeproblem zu lösen. Tatsächlich funktionieren superglobale Variablen in Swoole nicht, sodass Variablen wie $_GET ungültig werden und anforderungsbezogene Objekte in Laravel keine Daten abrufen können. Was zu tun? Wir erhalten diese Daten einfach aus den Parametern von onRequest und fügen sie dann wieder in $_GET in der aktuellen Prozess-Coroutine ein.

$http = new Swoole\Http\Server('0.0.0.0', 9501);
$http->on('Request', function ($req, $res) use($app) {
    try {
        $kernel = $app->make(Kernel::class);
        $response = $kernel->handle(
            $request = Request::capture()
        )->send();
        $kernel->terminate($request, $response);
    }catch(\Exception $e){
        print_r($e->getMessage());
    }
});
echo "服务启动", PHP_EOL;
$http->start();

Die oben genannten drei Codeteile lösen jeweils die Probleme von $_SERVER, $_GET und $_POST. Wenn Sie es nun erneut versuchen, können die Parameter empfangen werden, aber warum wird die Ausgabe auf der Konsole gedruckt?

Der vierte Schritt besteht darin, das Ausgabeproblem zu lösen, die gesamte Ausgabe im Frame in den Ausgabepuffer zu legen und dann die Antwort von Swoole für die Rückkehr zu verwenden.

$http->on('Request', function ($req, $res) use($app) {
    $_SERVER = [];
    if(isset($req->server)){
        foreach($req->server as $k => $v){
            $_SERVER[strtoupper($k)] = $v;
        }
    }
    $_GET = [];
    if(isset($req->get)){
        foreach ($req->get as $k => $v){
            $_GET[$k] = $v;
        }
    }
    $_POST = [];
    if(isset($req->post)){
        foreach ($req->post as $k => $v){
            $_POST[$k] = $v;
        }
    }
    try {
        $kernel = $app->make(Kernel::class);
        $response = $kernel->handle(
            $request = Request::capture()
        )->send();
        $kernel->terminate($request, $response);
    }catch(\Exception $e){
        print_r($e->getMessage());
    }
});

Der letzte ob_start()-Inhalt ist auch das, was wir zuvor studiert haben, daher werden wir ihn nicht weiter erklären.

Alle Codes

$http->on('Request', function ($req, $res) use($app) {
    $_SERVER = [];
    if(isset($req->server)){
        foreach($req->server as $k => $v){
            $_SERVER[strtoupper($k)] = $v;
        }
    }
    $_GET = [];
    if(isset($req->get)){
        foreach ($req->get as $k => $v){
            $_GET[$k] = $v;
        }
    }
    $_POST = [];
    if(isset($req->post)){
        foreach ($req->post as $k => $v){
            $_POST[$k] = $v;
        }
    }
    //把返回放到一个缓冲区里
    ob_start();
    try {
        $kernel = $app->make(Kernel::class);
        $response = $kernel->handle(
            $request = Request::capture()
        )->send();
        $kernel->terminate($request, $response);
    }catch(\Exception $e){
        print_r($e->getMessage());
    }
    $ob = ob_get_contents();
    ob_end_clean();
    $res->end($ob);
});

An diesem Punkt ist unsere einfachste Framework-Transformation abgeschlossen. Probieren wir den Effekt schnell aus.

Run

start();

Besuchen Sie

php swoole_server.php

Probieren Sie den Coroutine-Effekt aus

Definieren Sie zunächst eine Route. Oder wir können die Standardroute direkt ändern.

http://47.113.xxx.xx:9501/

Eine Menge Dinge gedruckt, aber sie sollten alle bekannt sein. Die ersten beiden sind die Ausgabe der Coroutine-ID und der Coroutine-Informationen. Dann geben wir 10 Sekunden lang SwooleCoroutine::sleep () aus und geben dann die Prozess-ID aus.

Dann öffnen wir den Browser und bereiten den gemeinsamen Zugriff auf die beiden Registerkarten vor.

Route::get('/', function () {
    echo Swoole\Coroutine::getCid(), "<br/>";
    print_r(Swoole\Coroutine::stats());
    Swoole\Coroutine::sleep(10);
    echo "<br/>";
    echo getmypid(), "<br/>";
//    return view(&#39;welcome&#39;);
});

Hast du es gesehen? Jedes onRequest-Ereignis öffnet tatsächlich eine neue Coroutine, um die Anfrage zu bearbeiten, daher sind ihre Coroutine-IDs unterschiedlich. Gleichzeitig wartet die zweite Anfrage nicht bis zur Rückkehr 20 Sekunden, da die erste Anfrage blockiert ist. Schließlich sehen wir im Coroutine-Status auch, dass in der zweiten Anfrage zwei coroutine_nums angezeigt werden, was darauf hinweist, dass derzeit zwei Coroutinen Aufgaben verarbeiten. Letztendlich sind die Prozesse die gleichen, sie folgen alle dem gleichen Prozess.

Probieren Sie den Multiprozesseffekt aus

Standardmäßig ist der obige Code ein Hauptprozess und ein Worker-Prozess und verwendet dann die Coroutine-Funktion. Tatsächlich kann dieser Effekt den gewöhnlichen PHP-FPM-Effekt sofort zerstören. Aber wir müssen die Leistung von Multi-Core-Maschinen voll ausnutzen, das heißt, wir ermöglichen mehrere Prozesse und nutzen den superstarken Verarbeitungsmodus von Multi-Prozess + Multi-Coroutine. Der einfachste Weg besteht darin, die Anzahl der Prozessarbeiter für den HTTP-Dienst direkt festzulegen.

// 第一个访问的页面
1
Array
(
    [event_num] => 2
    [signal_listener_num] => 0
    [aio_task_num] => 0
    [aio_worker_num] => 0
    [aio_queue_size] => 0
    [c_stack_size] => 2097152
    [coroutine_num] => 1
    [coroutine_peak_num] => 1
    [coroutine_last_cid] => 1
)
1468
// 第二个访问的页面
2
Array
(
    [event_num] => 2
    [signal_listener_num] => 0
    [aio_task_num] => 0
    [aio_worker_num] => 0
    [aio_queue_size] => 0
    [c_stack_size] => 2097152
    [coroutine_num] => 2
    [coroutine_peak_num] => 2
    [coroutine_last_cid] => 2
)
1468

Starten Sie nun den Server und Sie können einige weitere Prozesse sehen. Dann erstellen wir eine neue Testroute

$http->set(array(
    'worker_num' => 4,
      // 'worker_num' => 1,单进程
));

Besuchen Sie nun noch einmal die Homepage und diese /eine Seite.

Route::get('/a', function () {
    echo Swoole\Coroutine::getCid(), "<br/>";
    print_r(Swoole\Coroutine::stats());
    echo "<br/>";
    echo getmypid(), "<br/>";
});

Nein, ihre Prozess-IDs sind auch unterschiedlich, wenn keine Blockierung vorliegt, wird der Prozess zuerst umgeschaltet. Wenn alle Prozesse blockiert sind, werden Coroutinen in einer Schleife für die prozessinterne Verarbeitung erstellt.

Das obige ist der detaillierte Inhalt vonVersuchen Sie, die Laravel-Version in die Swoole-Version zu ändern. Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!