Generating Commands
To create a new command, use the make:command
Artisan command. This command will create a new command class in the app/Console/Commands
directory. Don't worry if this directory does not exist in your application, since it will be created the first time you run the make:command
Artisan command. The generated command will include the default set of properties and methods that are present on all commands:
php artisan make:command SendEmails
Command Structure
After generating your command, you should fill in the signature
and description
properties of the class, which will be used when displaying your command on the list
screen. The handle
method will be called when your command is executed. You may place your command logic in this method.
For greater code reuse, it is good practice to keep your console commands light and let them defer to application services to accomplish their tasks. In the example below, note that we inject a service class to do the "heavy lifting" of sending the e-mails.
Let's take a look at an example command. Note that we are able to inject any dependencies we need into the command's handle
method. The Laravel service container will automatically inject all dependencies that are type-hinted in this method's signature:
<?php
namespace App\Console\Commands;
use App\DripEmailer;
use App\User;
use Illuminate\Console\Command;
class SendEmails extends Command
{
/**
* The name and signature of the console command.
*
* @var string
*/
protected $signature = 'email:send {user}';
/**
* The console command description.
*
* @var string
*/
protected $description = 'Send drip e-mails to a user';
/**
* Create a new command instance.
*
* @return void
*/
public function __construct()
{
parent::__construct();
}
/**
* Execute the console command.
*
* @param \App\DripEmailer $drip
* @return mixed
*/
public function handle(DripEmailer $drip)
{
$drip->send(User::find($this->argument('user')));
}
}
Closure Commands
Closure based commands provide an alternative to defining console commands as classes. In the same way that route Closures are an alternative to controllers, think of command Closures as an alternative to command classes. Within the commands
method of your app/Console/Kernel.php
file, Laravel loads the routes/console.php
file:
/**
* Register the Closure based commands for the application.
*
* @return void
*/
protected function commands()
{
require base_path('routes/console.php');
}
Even though this file does not define HTTP routes, it defines console based entry points (routes) into your application. Within this file, you may define all of your Closure based routes using the Artisan::command
method. The command
method accepts two arguments: the command signature and a Closure which receives the commands arguments and options:
Artisan::command('build {project}', function ($project) {
$this->info("Building {$project}!");
});
The Closure is bound to the underlying command instance, so you have full access to all of the helper methods you would typically be able to access on a full command class.
Type-Hinting Dependencies
In addition to receiving your command's arguments and options, command Closures may also type-hint additional dependencies that you would like resolved out of the service container:
use App\DripEmailer;
use App\User;
Artisan::command('email:send {user}', function (DripEmailer $drip, $user) {
$drip->send(User::find($user));
});
Closure Command Descriptions
When defining a Closure based command, you may use the describe
method to add a description to the command. This description will be displayed when you run the php artisan list
or php artisan help
commands:
Artisan::command('build {project}', function ($project) {
$this->info("Building {$project}!");
})->describe('Build the project');