Preface
Queue is a relatively common feature in laravel. The purpose of a queue is to delay processing time-consuming tasks, such as sending emails, thereby greatly shortening the time of web requests and responses. In this article, we will analyze the source code for queue creation and execution.
Creation of queue tasks
First create a Job class through the command. After success, the following file laravel-src/laravel/app/Jobs/ will be created.
> php artisan make:job DemoJob > Job created successfully.
Let’s analyze the specific generation process of the Job class.
implementphp artisan make:job DemoJobAfter that, the following method will be called.
laravel-src/laravel/vendor/laravel/framework/src/Illuminate/Foundation/Providers/
/**
* Register the command.
* [A] Methods triggered when make:job
* @return void
*/
protected function registerJobMakeCommand()
{
$this->app->singleton('', function ($app) {
return new JobMakeCommand($app['files']);
});
}Next, let’s take a look at the JobMakeCommand class. There is no too much processing logic in this class, and the processing method is in its parent class.
class JobMakeCommand extends GeneratorCommand
Let's look directly at the processing method in the parent class, GeneratorCommand->handle(). The following are the main methods in this method.
public function handle()
{
// Get the class name $name = $this->qualifyClass($this->getNameInput());
// Get the file path $path = $this->getPath($name);
// Create directories and files $this->makeDirectory($path);
// buildClass() gets the content of the new class file through the template $this->files->put($path, $this->buildClass($name));
// $this->type is defined in the subclass, for example, type = 'Job' in JobMakeCommand $this->info($this->type.' created successfully.');
}The method is to create corresponding class files through directories and files. As for the content of the new file, they are created based on the already set templates. The specific content is in the buildClass($name) method.
protected function buildClass($name)
{
// Get the class file template, getStub() is implemented in the subclass, see JobMakeCommand for details $stub = $this->files->get($this->getStub());
// Use the actual name to replace the content in the template, all keyword replacements return $this->replaceNamespace($stub, $name)->replaceClass($stub, $name);
}Get the template file
protected function getStub()
{
return $this->option('sync')
? __DIR__.'/stubs/'
: __DIR__.'/stubs/';
} <?php
/**
* Generation template for job class
*/
namespace DummyNamespace;
use Illuminate\Bus\Queueable;
use Illuminate\Foundation\Bus\Dispatchable;
class DummyClass
{
use Dispatchable, Queueable;
/**
* Create a new job instance.
*
* @return void
*/
public function __construct()
{
//
}
/**
* Execute the job.
*
* @return void
*/
public function handle()
{
//
}
}<?php
/**
* Generation template for job class
*/
namespace DummyNamespace;
use Illuminate\Bus\Queueable;
use Illuminate\Queue\SerializesModels;
use Illuminate\Queue\InteractsWithQueue;
use Illuminate\Contracts\Queue\ShouldQueue;
use Illuminate\Foundation\Bus\Dispatchable;
class DummyClass implements ShouldQueue
{
use Dispatchable, InteractsWithQueue, Queueable, SerializesModels;
/**
* Create a new job instance.
*
* @return void
*/
public function __construct()
{
//
}
/**
* Execute the job.
*
* @return void
*/
public function handle()
{
//
}
}Let’s take a look at a Job class we created earlier, which comes from the template.
<?php
/**
* Generation template for job class
*/
namespace App\Jobs;
use Illuminate\Bus\Queueable;
use Illuminate\Queue\SerializesModels;
use Illuminate\Queue\InteractsWithQueue;
use Illuminate\Contracts\Queue\ShouldQueue;
use Illuminate\Foundation\Bus\Dispatchable;
class DemoJob implements ShouldQueue
{
use Dispatchable, InteractsWithQueue, Queueable, SerializesModels;
/**
* Create a new job instance.
*
* @return void
*/
public function __construct()
{
//
}
/**
* Execute the job.
*
* @return void
*/
public function handle()
{
//
}
}At this point, we have roughly understood how the queue task class is created. Let’s analyze how it works effectively.
Distribution of queue tasks
After the task class is created, we can distribute tasks where we need it. The common methods are as follows:
DemoJob::dispatch(); // Task distributionDemoJob::dispatchNow(); // Synchronous scheduling, queue tasks will not be queued and will be carried out immediately in the current process
Let’s first analyze the distribution process using dispatch() as an example.
trait Dispatchable
{
public static function dispatch()
{
return new PendingDispatch(new static(...func_get_args()));
}
} class PendingDispatch
{
protected $job;
public function __construct($job)
{ echo '[Max] ' . 'PendingDispatch ' . '__construct' . PHP_EOL;
$this->job = $job;
}
public function __destruct()
{ echo '[Max] ' . 'PendingDispatch ' . '__destruct' . PHP_EOL;
app(Dispatcher::class)->dispatch($this->job);
}
}The focus is on the app(Dispatcher::class)->dispatch($this->job).
Let’s first analyze the previous part of the app (Dispatcher::class), which is injected into $app in the BusServiceProvider that comes with the laravel framework.
class BusServiceProvider extends ServiceProvider implements DeferrableProvider
{
public function register()
{
$this->app->singleton(Dispatcher::class, function ($app) {
return new Dispatcher($app, function ($connection = null) use ($app) {
return $app[QueueFactoryContract::class]->connection($connection);
});
});
}
}Take a look at the construction method of Dispatcher. So far, we already know how the first half of the app (Dispatcher::class) came from.
class Dispatcher implements QueueingDispatcher
{
protected $container;
protected $pipeline;
protected $queueResolver;
public function __construct(Container $container, Closure $queueResolver = null)
{
$this->container = $container;
/**
* Illuminate/Bus/->register()
* $queueResolver is passing in a closure
* function ($connection = null) use ($app) {
* return $app[QueueFactoryContract::class]->connection($connection);
* }
*/
$this->queueResolver = $queueResolver;
$this->pipeline = new Pipeline($container);
}
public function dispatch($command)
{
if ($this->queueResolver && $this->commandShouldBeQueued($command)) {
// Save $command to queue return $this->dispatchToQueue($command);
}
return $this->dispatchNow($command);
}
}Dispatcher::class is registered in BusServiceProvider, and then the call to app(Dispatcher::class)->dispatch($this->job) is Dispatcher->dispatch().
public function dispatchToQueue($command)
{
// Get the connection to which the task belongs $connection = $command->connection ?? null;
/*
* Get queue instance according to the configuration in config/
* Here we configure QUEUE_CONNECTION=redis as an example, then we get RedisQueue
* As for how to obtain queue through the configuration of QUEUE_CONNECTION, skip it here and we will analyze it in detail later in this article.
*/
$queue = call_user_func($this->queueResolver, $connection);
if (! $queue instanceof Queue) {
throw new RuntimeException('Queue resolver did not return a Queue implementation.');
}
// The DemoJob we created does not have a queue method and will not be called if (method_exists($command, 'queue')) {
return $command->queue($queue, $command);
}
// Put the job into the queue return $this->pushCommandToQueue($queue, $command);
}
protected function pushCommandToQueue($queue, $command)
{
// Different methods will be called when queue or delay are specified, basically the same if (isset($command->queue, $command->delay)) {
return $queue->laterOn($command->queue, $command->delay, $command);
}
if (isset($command->queue)) {
return $queue->pushOn($command->queue, $command);
}
if (isset($command->delay)) {
return $queue->later($command->delay, $command);
}
// Let's first look at the simplest case when there is no parameter, and call push() return $queue->push($command);
}The author's configuration is QUEUE_CONNECTION=redis. According to this analysis, the principles of other types are basically similar.
When redis is configured, $queue is a RedisQueue instance. Let's take a look at the contents of RedisQueue->push().
Illuminate/Queue/
public function push($job, $data = '', $queue = null)
{
/**
* Get the queue name
* var_dump($this->getQueue($queue));
* Create a unified payload and convert it to json
* var_dump($this->createPayload($job, $this->getQueue($queue), $data));
*/
// Save tasks and data into queue return $this->pushRaw($this->createPayload($job, $this->getQueue($queue), $data), $queue);
}
public function pushRaw($payload, $queue = null, array $options = [])
{
// Write to redis $this->getConnection()->eval(
LuaScripts::push(), 2, $this->getQueue($queue),
$this->getQueue($queue).':notify', $payload
);
// Return id return json_decode($payload, true)['id'] ?? null;
}At this point, we have analyzed how the task is added to the queue.
The above is the detailed content of the example of the laravel source code analysis queue Queue method. For more information about the laravel source code analysis queue Queue method, please pay attention to my other related articles!