Aufgaben in Laravel über Warteschlangen verschieben

() translation by (you can also view the original English article)

In diesem Artikel werden wir die Warteschlangen-API im Laravel-Web-Framework untersuchen. Es ermöglicht Ihnen, ressourcenintensive Aufgaben während der Skriptausführung zu verschieben, um die allgemeine Endbenutzererfahrung zu verbessern. Nachdem ich die grundlegende Terminologie vorgestellt habe, demonstriere ich sie anhand eines realen Beispiels.

Die Seitenladezeit ist ein wichtiger Aspekt jeder erfolgreichen Website, und man sollte nicht die Bedeutung dieser Website übersehen, da sie sich auf die SEO der Website und die allgemeine Endbenutzererfahrung auswirkt. In den meisten Fällen müssen Sie Webseiten mit langen Seitenladezeiten debuggen. Natürlich gibt es verschiedene Ansätze, die Sie verwenden könnten, um dieses Problem zu beheben.

Bei der Untersuchung stellen Sie häufig fest, dass bestimmte Code-Blöcke die Ausführung der Seite verzögern. Das nächste, was Sie versuchen könnten, ist das Identifizieren von Blöcken, die zur Verarbeitung zurückgestellt werden können und keinen wirklichen Einfluss auf das Endergebnis der aktuellen Seite haben. Das sollte die Gesamtgeschwindigkeit der Webseite wirklich verbessern, da wir Code-Blöcke eliminiert haben, die eine Verzögerung verursacht haben.

Heute werden wir ein ähnliches Konzept im Zusammenhang mit dem Laravel-Web-Framework untersuchen. In der Tat bietet Laravel bereits eine nützliche integrierte API, mit der wir die Verarbeitung von Aufgaben verzögern können - die Queue-API. Ohne viel Zeit zu verschwenden, werde ich die grundlegenden Elemente der Queue API besprechen.

Treiber, Verbindungen, Warteschlangen und Jobs

Der grundlegende Zweck der Warteschlangen-API besteht darin, Jobs auszuführen, die in einer Warteschlange hinzugefügt werden. Als nächstes könnte die Warteschlange zu einer bestimmten Verbindung gehören, und diese Verbindung könnte zu einem bestimmten Warteschlangentreiber gehören, der selbst mit dieser Verbindung konfiguriert ist. Versuchen wir kurz zu verstehen, was ich gerade gesagt habe.

Queue Drivers

Genauso wie Sie einen anderen Treiber für Ihre Datenbankverbindung verwendet hätten, könnten Sie auch aus einer Reihe verschiedener Warteschlangentreiber auswählen. Die Queue API unterstützt verschiedene Adapter wie database, beanstalkd, sqs und redis.

Der Warteschlangentreiber ist nur ein Ort, an dem Informationen zur Warteschlange gespeichert werden. Wenn Sie beispielsweise einen Datenbankwarteschlangentreiber verwenden, wird der neue Job in der Jobtabelle in der Datenbank hinzugefügt. Wenn Sie andererseits redis als Standardwarteschlangentreiber konfiguriert haben, wird der Job dem Redis-Server hinzugefügt.

Die Queue API bietet außerdem zwei spezielle Warteschlangentreiber für Testzwecke - sync und null. Der Synchronisierungswarteschlangentreiber wird verwendet, um einen Warteschlangenauftrag sofort auszuführen, während der Nullwarteschlangentreiber zum Überspringen eines Auftrags verwendet wird, sodass er überhaupt nicht ausgeführt wird.

Connections

Wenn Sie die Queue API zum ersten Mal konfigurieren, müssen Sie eine Standardverbindung angeben, die für die Verarbeitung der Standardwarteschlange verwendet werden soll. Zumindest wird erwartet, dass die Verbindung folgende Informationen liefert:

der Warteschlangentreiber, der verwendet wird
die spezifischen Konfigurationswerte des Warteschlangentreibers
Der Name der Standardwarteschlange, in der der Job hinzugefügt wird

Queues

Wenn Sie einen Job zu einer Warteschlange hinzufügen, wird er zur Standardwarteschlange hinzugefügt. In der Tat sollte das in den meisten Fällen in Ordnung sein, es sei denn, Sie haben Jobs, denen gegenüber anderen Jobs eine höhere Priorität eingeräumt werden muss. In diesem Fall könnten Sie eine Warteschlange mit dem Namen "hoch" erstellen und die Jobs mit der höheren Priorität in dieser bestimmten Warteschlange platzieren.

Wenn Sie einen Warteschlangen-Worker ausführen, der in der Warteschlange befindliche Jobs verarbeitet, können Sie optional den Parameter --queue übergeben, mit dem Sie Warteschlangennamen in der Reihenfolge auflisten können, in der sie verarbeitet werden müssen. Wenn Sie beispielsweise --queue=high,default, angeben, werden zuerst die Jobs in der hohen Warteschlange verarbeitet und nach Abschluss der Jobs werden Jobs in der Standardwarteschlange abgerufen.

Jobs

Ein Job in der Queue API ist eine Aufgabe, die vom Hauptausführungsfluss zurückgestellt wird. Wenn Sie beispielsweise ein Thumbnail erstellen möchten, während der Benutzer ein Bild vom Front-End hochlädt, können Sie einen neuen Job erstellen, der die Thumbnail-Verarbeitung verarbeitet. Auf diese Weise können Sie die Aufgabe der Miniaturbildverarbeitung aus dem Hauptausführungsfluss zurückstellen.

Das war eine grundlegende Einführung in die Queue API-Terminologie. Ab dem nächsten Abschnitt erfahren Sie, wie Sie einen benutzerdefinierten Warteschlangenauftrag erstellen und ihn mit einem Laravel-Warteschlangen-Worker ausführen.

Erstellen Sie Ihren ersten Warteschlangenauftrag

Jetzt sollten Sie sich über Warteschlangenaufträge sicher sein. Von diesem Abschnitt an werden wir ein reales Beispiel implementieren, das das Konzept von Warteschlangen-Jobs in Laravel demonstriert.

In den meisten Fällen landen Sie in der Situation, in der Sie verschiedene Miniaturversionen eines Bildes erstellen müssen, das von einem Benutzer hochgeladen wurde. In den meisten Fällen versucht der Entwickler, es in Echtzeit zu verarbeiten, sodass verschiedene Versionen von Bildern sofort erstellt werden, wenn der Benutzer ein Bild hochlädt.

Es scheint ein vernünftiger Ansatz zu sein, wenn Sie ein paar Versionen erstellen und es nicht zu viel Zeit in Anspruch nimmt. Auf der anderen Seite, wenn Sie mit einer Anwendung zu tun haben, die eine starke Verarbeitung erfordert und dadurch mehr Ressourcen verbraucht, könnte die Verarbeitung in Echtzeit zu einer schlechten Benutzererfahrung führen.

Die offensichtliche Option, die Ihnen zuerst in den Sinn kommt, ist, die Verarbeitung der Thumbnail-Generierung so spät wie möglich zu verschieben. Der einfachste Ansatz, den Sie in diesem speziellen Szenario implementieren könnten, besteht darin, einen Cron-Job festzulegen, der die Verarbeitung in regelmäßigen Intervallen auslöst, und Ihnen sollte nichts passieren.

Ein viel besserer Ansatz besteht dagegen darin, die Aufgabe aufzuschieben und in eine Warteschlange zu schieben, und sie von der Warteschlangenmitarbeiterin verarbeiten zu lassen, wenn sie dazu in der Lage ist. In einer Produktionsumgebung ist der Warteschlangen-Worker ein Daemon-Skript, das Aufgaben in einer Warteschlange ausführt und verarbeitet. Der offensichtliche Vorteil dieses Ansatzes ist eine viel bessere Endbenutzererfahrung, und Sie müssen nicht auf den Cron-Lauf warten, da der Job so schnell wie möglich verarbeitet wird.

Ich denke, das ist genug Theorie, um mit einer tatsächlichen Implementierung zu beginnen.

In unserem Fall werden wir den database -Warteschlangentreiber verwenden, und wir müssen die jobs-Tabelle in der Datenbank erstellen. Die jobs-Tabelle enthält alle jobs, die bei der nächsten Ausführung des Warteschlangen-Workers verarbeitet werden müssen.

Bevor wir fortfahren und die jobs -Tabelle erstellen, ändern wir die Standardwarteschlangenkonfiguration von syncin databasein der Datei config/queue.php.

...
...
/*
|--------------------------------------------------------------------------
| Default Queue Driver
|--------------------------------------------------------------------------
|
| Laravel's queue API supports an assortment of back-ends via a single
| API, giving you convenient access to each back-end using the same
| syntax for each one. Here you may set the default queue driver.
|
| Supported: "sync", "database", "beanstalkd", "sqs", "redis", "null"
|
*/

'default' => env('QUEUE_DRIVER', 'database'),
...
...

In der Tat bietet Laravel bereits einen handwerklichen Befehl, der uns hilft, die jobs-Tabelle zu erstellen. Führen Sie den folgenden Befehl im Stammverzeichnis Ihrer Laravel-Anwendung aus, und erstellen Sie die erforderliche Datenbankmigration, mit der die jobs-Tabelle erstellt wird.

1	$php artisan queue:table

Die Migrationsdatei, die in database/migrations/YYYY_MM_DD_HHMMSS_create_jobs_table.php generiert wird, sollte folgendermaßen aussehen:

<?php
use Illuminate\Support\Facades\Schema;
use Illuminate\Database\Schema\Blueprint;
use Illuminate\Database\Migrations\Migration;

class CreateJobsTable extends Migration
{
    /**
     * Run the migrations.
     *
     * @return void
     */
    public function up()
    {
        Schema::create('jobs', function (Blueprint $table) {
            $table->bigIncrements('id');
            $table->string('queue');
            $table->longText('payload');
            $table->unsignedTinyInteger('attempts');
            $table->unsignedInteger('reserved_at')->nullable();
            $table->unsignedInteger('available_at');
            $table->unsignedInteger('created_at');

            $table->index(['queue', 'reserved_at']);
        });
    }

    /**
     * Reverse the migrations.
     *
     * @return void
     */
    public function down()
    {
        Schema::dropIfExists('jobs');
    }
}

Als nächstes führen wir den migrate-Befehl aus, so dass er tatsächlich die jobs -Tabelle in einer Datenbank erstellt.

1	php artisan migrate

Soweit die jobs -Migration betroffen ist.

Als Nächstes erstellen wir das Image-Modell, mit dem die vom Endbenutzer hochgeladenen Bilder verwaltet werden. Das Image-Modell benötigt außerdem eine zugeordnete Datenbanktabelle. Daher verwenden wir beim Erstellen des Image-Modells die Option --migrate.

1	php artisan make:model Image --migration

Der obige Befehl sollte die Image-Modellklasse und eine zugehörige Datenbankmigration ebenfalls erstellen.

Die Image-Modellklasse sollte folgendermaßen aussehen:

<?php
// app/Image.php
namespace App;

use Illuminate\Database\Eloquent\Model;

class Image extends Model
{
    //
}

Die Datenbankmigrationsdatei sollte unter database/migrations/YYYY_MM_DD_HHMMSS_create_images_table.php erstellt werden. Wir möchten auch den ursprünglichen Pfad des vom Endbenutzer hochgeladenen Bildes speichern. Lassen Sie uns den Code der Image-Datenbankmigrationsdatei so ändern, dass er wie folgt aussieht.

<?php
// database/migrations/YYYY_MM_DD_HHMMSS_create_images_table.php
use Illuminate\Support\Facades\Schema;
use Illuminate\Database\Schema\Blueprint;
use Illuminate\Database\Migrations\Migration;

class CreateImagesTable extends Migration
{
    /**
     * Run the migrations.
     *
     * @return void
     */
    public function up()
    {
        Schema::create('images', function (Blueprint $table) {
            $table->increments('id');
            $table->timestamps();
            $table->string('org_path');
        });
    }

    /**
     * Reverse the migrations.
     *
     * @return void
     */
    public function down()
    {
        Schema::dropIfExists('images');
    }
}

Wie Sie sehen, haben wir die Spalte $table->string('org_path')hinzugefügt, um den Pfad des Originalbildes zu speichern. Als Nächstes müssen Sie nur den Befehl migrate ausführen, um diese Tabelle in der Datenbank zu erstellen.

1	$php artisan migrate

Und das ist es, was das Image-Modell angeht.

Erstellen Sie als Nächstes einen tatsächlichen Warteschlangenauftrag, der für die Verarbeitung von Miniaturbildern verantwortlich ist. Für die Miniaturbildverarbeitung verwenden wir eine sehr beliebte Bildverarbeitungsbibliothek - Interventionsbild.

Um die Intervention Image-Bibliothek zu installieren, führen Sie den folgenden Befehl im Stammverzeichnis Ihrer Anwendung aus.

1	$php composer.phar require intervention/image

Jetzt ist es an der Zeit, die Job-Klasse zu erstellen, und dazu verwenden wir einen Handwerkerbefehl.

1	$php artisan make:job ProcessImageThumbnails

Das sollte die Job-Klassenvorlage unter app/Jobs/ProcessImageThumbnails.php erstellen. Lassen Sie uns den Inhalt dieser Datei ersetzen

<?php
// app/Jobs/ProcessImageThumbnails.php
namespace App\Jobs;

use App\Image as ImageModel;
use Illuminate\Bus\Queueable;
use Illuminate\Queue\SerializesModels;
use Illuminate\Queue\InteractsWithQueue;
use Illuminate\Contracts\Queue\ShouldQueue;
use Illuminate\Foundation\Bus\Dispatchable;
use Illuminate\Support\Facades\DB;

class ProcessImageThumbnails implements ShouldQueue
{
    use Dispatchable, InteractsWithQueue, Queueable, SerializesModels;

    protected $image;

    /**
     * Create a new job instance.
     *
     * @return void
     */
    public function __construct(ImageModel $image)
    {
        $this->image = $image;
    }

    /**
     * Execute the job.
     *
     * @return void
     */
    public function handle()
    {
        // access the model in the queue for processing
        $image = $this->image;
        $full_image_path = public_path($image->org_path);
        $resized_image_path = public_path('thumbs' . DIRECTORY_SEPARATOR .  $image->org_path);

        // create image thumbs from the original image
        $img = \Image::make($full_image_path)->resize(300, 200);
        $img->save($resized_image_path);
    }
}

Wenn der Warteschlangen-Worker beginnt, einen Job zu verarbeiten, sucht er nach der Handle-Methode. Es ist also die Handle-Methode, die die Hauptlogik Ihres Jobs enthält.

In unserem Fall müssen wir ein Thumbnail eines Bildes erstellen, das vom Benutzer hochgeladen wurde. Der Code der handle-Methode ist ziemlich einfach: Wir rufen ein Image aus dem ImageModel-Modell ab und erstellen ein Thumbnail mithilfe der Interventions-Image-Bibliothek. Natürlich müssen wir das entsprechende Image-Modell übergeben, wenn wir unseren Job versenden, und wir werden es gleich sehen.

Um unseren neu erstellten Job zu testen, erstellen wir ein einfaches Upload-Formular, mit dem der Benutzer ein Bild hochladen kann. Natürlich werden wir keine Vorschaubilder erstellen. Wir verschieben diese Aufgabe, damit sie vom Warteschlangenarbeiter verarbeitet werden kann.

Lassen Sie uns eine Controller-Datei unter app/Http/Controllers/ImageController.php erstellen, wie unten gezeigt.

<?php
namespace App\Http\Controllers;

use App\Image;
use App\Jobs\ProcessImageThumbnails;
use Illuminate\Http\Request;
use Illuminate\Support\Facades\Redirect;
use App\Http\Controllers\Controller;
use Validator;

class ImageController extends Controller
{
    /**
     * Show Upload Form
     *
     * @param  Request  $request
     * @return Response
     */
    public function index(Request $request)
    {
        return view('upload_form');
    }

    /**
     * Upload Image
     *
     * @param  Request  $request
     * @return Response
     */
    public function upload(Request $request)
    {
        // upload image
        $this->validate($request, [
          'demo_image' => 'required|image|mimes:jpeg,png,jpg,gif,svg|max:2048',
        ]);
        $image = $request->file('demo_image');
        $input['demo_image'] = time().'.'.$image->getClientOriginalExtension();
        $destinationPath = public_path('/images');
        $image->move($destinationPath, $input['demo_image']);

        // make db entry of that image
        $image = new Image;
        $image->org_path = 'images' . DIRECTORY_SEPARATOR . $input['demo_image'];
        $image->save();

        // defer the processing of the image thumbnails
        ProcessImageThumbnails::dispatch($image);

        return Redirect::to('image/index')->with('message', 'Image uploaded successfully!');
    }
}

Lassen Sie uns eine zugehörige View-Datei unter resources/views/upload_form.blade.php erstellen.

<!DOCTYPE html>
<html lang="{{ config('app.locale') }}">
    <head>
        <meta charset="utf-8">
        <meta http-equiv="X-UA-Compatible" content="IE=edge">
        <meta name="viewport" content="width=device-width, initial-scale=1">
        <meta name="csrf-token" content="{{ csrf_token() }}" />
        <title>Laravel</title>

        <!-- Fonts -->
        <link href="https://fonts.googleapis.com/css?family=Raleway:100,600" rel="stylesheet" type="text/css">

        <!-- Styles -->
        <style>
            html, body {
                background-color: #fff;
                color: #636b6f;
                font-family: 'Raleway', sans-serif;
                font-weight: 100;
                height: 100vh;
                margin: 0;
            }

            .full-height {
                height: 100vh;
            }

            .flex-center {
                align-items: center;
                display: flex;
                justify-content: center;
            }

            .position-ref {
                position: relative;
            }

            .top-right {
                position: absolute;
                right: 10px;
                top: 18px;
            }

            .content {
                text-align: center;
            }

            .title {
                font-size: 84px;
            }

            .links > a {
                color: #636b6f;
                padding: 0 25px;
                font-size: 12px;
                font-weight: 600;
                letter-spacing: .1rem;
                text-decoration: none;
                text-transform: uppercase;
            }

            .m-b-md {
                margin-bottom: 30px;
            }
            
            .alert {
                color: red;
                font-weight: bold;
                margin: 10px;
            }
            .success {
                color: blue;
                font-weight: bold;
                margin: 10px;
            }
        </style>
    </head>
    <body>
        <div class="flex-center position-ref full-height">
            @if (Route::has('login'))
                <div class="top-right links">
                    @if (Auth::check())
                        <a href="{{ url('/home') }}">Home</a>
                    @else
                        <a href="{{ url('/login') }}">Login</a>
                        <a href="{{ url('/register') }}">Register</a>
                    @endif
                </div>
            @endif

            <div class="content">
                <div class="m-b-md">
                    <h1 class="title">Demo Upload Form</h1>
                    
                    @if ($errors->any())
                        <div class="alert alert-danger">
                            <ul>
                                @foreach ($errors->all() as $error)
                                    <li>{{ $error }}</li>
                                @endforeach
                            </ul>
                        </div>
                    @endif
                    
                    @if (session('message'))
                        <div class="success">
                            {{ session('message') }}
                        </div>
                    @endif
                    
                    <form method="post" action="{{ url('/image/upload') }}" enctype="multipart/form-data">
                      <div>
                        <input type="file" name="demo_image" />
                      </div>
                      <br/>
                      <div>
                        <input type="hidden" name="_token" value="{{ csrf_token() }}">
                        <input type="submit" value="Upload Image"/>
                      </div>
                    </form>
                </div>
            </div>
        </div>
    </body>
</html>

Abschließend fügen wir Routen für die Aktionen indexund upload in der Datei routes/web.php hinzu.

1	Route::get('image/index', 'ImageController@index');
2	Route::post('image/upload', 'ImageController@upload');

Im ImageController-Controller wird die index -Methode zum Rendern eines Upload-Formulars verwendet.

1	public function index(Request $request)
2	{
3	return view('upload_form');
4	}

Wenn der Benutzer ein Formular sendet, wird die Upload-Methode aufgerufen.

public function upload(Request $request)
{
    // upload image
    $this->validate($request, [
        'demo_image' => 'required|image|mimes:jpeg,png,jpg,gif,svg|max:2048',
    ]);
    $image = $request->file('demo_image');
    $input['demo_image'] = time().'.'.$image->getClientOriginalExtension();
    $destinationPath = public_path('/images');
    $image->move($destinationPath, $input['demo_image']);

    // make db entry of that image
    $image = new Image;
    $image->org_path = 'images' . DIRECTORY_SEPARATOR . $input['demo_image'];
    $image->save();

    // defer the processing of the image thumbnails
    ProcessImageThumbnails::dispatch($image);

    return Redirect::to('image/index')->with('message', 'Image uploaded successfully!');
}

Zu Beginn der upload-Methode werden Sie den üblichen Code zum Hochladen von Dateien bemerken, der die hochgeladene Datei in das public/images-Verzeichnis verschiebt. Als Nächstes fügen wir einen Datenbankeintrag mit dem App/Image-Modell ein.

Schließlich verwenden wir den Job ProcessImageThumbnails, um die Verarbeitung der Thumbnail-Verarbeitung zu verschieben. Es ist wichtig zu beachten, dass es die dispatch-Methode ist, die verwendet wird, um eine Aufgabe zu verschieben. Am Ende wird der Benutzer mit einer Erfolgsmeldung auf die Upload-Seite weitergeleitet.

Zu diesem Zeitpunkt wird der Job der jobs -Tabelle zur Verarbeitung hinzugefügt. Lassen Sie es uns bestätigen, indem Sie die folgende Abfrage ausführen.

mysql> select * FROM lvl_jobs;

|  1 | default | {"displayName":"App\\Jobs\\ProcessImageThumbnails","job":"Illuminate\\Queue\\CallQueuedHandler@call","maxTries":null,"timeout":null,"data":{"commandName":"App\\Jobs\\ProcessImageThumbnails","command":"O:31:\"App\\Jobs\\ProcessImageThumbnails\":5:{s:8:\"\u0000*\u0000image\";O:45:\"Illuminate\\Contracts\\Database\\ModelIdentifier\":2:{s:5:\"class\";s:9:\"App\\Image\";s:2:\"id\";i:2;}s:6:\"\u0000*\u0000job\";N;s:10:\"connection\";N;s:5:\"queue\";N;s:5:\"delay\";N;}"}} |        0 |        NULL |   1510219099 | 1510219099 |

Sie müssen sich fragen, was es braucht, um einen Job dann zu verarbeiten? Keine Sorge - darüber werden wir im nächsten Abschnitt sprechen.

Queue Worker

Die Aufgabe des Laravel-Warteschlangenarbeiters besteht darin, Jobs zu verarbeiten, die zur Verarbeitung in der Warteschlange stehen. In der Tat gibt es einen Handwerkerbefehl, der uns hilft, den Warteschlangen-Worker-Prozess zu starten.

1	$php artisan queue:work

Sobald Sie diesen Befehl ausführen, werden ausstehende Jobs verarbeitet. In unserem Fall sollte es den Job ProcessImageThumbnails verarbeiten, der in die Warteschlange gestellt wurde, als der Benutzer ein Bild früher hochgeladen hat.

1	$php artisan queue:work
2	[YYYY-MM-DD HHMMSS] Processing: App\Jobs\ProcessImageThumbnails
3	[YYYY-MM-DD HHMMSS] Processed: App\Jobs\ProcessImageThumbnails

Sie hätten bemerkt, dass wenn Sie einen Warteschlangen-Worker starten, dieser so lange ausgeführt wird, bis Sie ihn manuell beenden oder das Terminal schließen. Tatsächlich wartet es darauf, dass der nächste Job verarbeitet wird. Sobald sich ein neuer Job in der Warteschlange befindet, wird er sofort verarbeitet, wenn der Warteschlangen-Worker ausgeführt wird.

Natürlich können wir es nicht so laufen lassen, also müssen wir einen Weg finden, wie der Warteschlangenarbeiter permanent im Hintergrund läuft.

Zu unserer Rettung gibt es mehrere Tools zur Prozessverwaltung, aus denen Sie auswählen können. Um einige zu nennen, hier ist eine Liste:

Circus
daemontools
Monit
Supervisor
Upstart

Sie sollten ein Werkzeug wählen, mit dem Sie den Laravel Queue Worker verwalten können. Grundsätzlich möchten wir sicherstellen, dass der Warteschlangen-Worker unbegrenzt ausgeführt werden sollte, damit er in der Warteschlange befindliche Jobs sofort verarbeitet.

Das ist also die Queue API. Sie können es in Ihrer täglichen Entwicklung verwenden, um zeitraubende Aufgaben zur Verbesserung der Endbenutzererfahrung aufzuschieben.

Fazit

In diesem Artikel haben wir die Queue API in Laravel besprochen, was sehr hilfreich ist, wenn Sie die Verarbeitung von ressourcenintensiven Aufgaben verzögern möchten.

Wir begannen mit einer grundlegenden Einführung in die Queue API, die eine Diskussion über Verbindungen, Warteschlangen und Jobs beinhaltete. In der zweiten Hälfte des Artikels haben wir einen benutzerdefinierten Warteschlangenjob erstellt, der demonstriert, wie Sie die Queue API in der realen Welt verwenden können.

Für diejenigen unter Ihnen, die gerade mit Laravel anfangen oder Ihr Wissen, Ihre Website oder Ihre Anwendung mit Erweiterungen erweitern möchten, haben wir eine Vielzahl von Dingen, die Sie in Envato Market studieren können.

Fühlen Sie sich frei, das Feedback-Formular unten zu verwenden, um Ihre Fragen und Vorschläge zu posten.