German (Deutsch) translation by Alex Grigorovich (you can also view the original English article)
Heutzutage ist es für Entwickler ganz normal, sich mit Konsolen und der Ausgabe grundlegender Befehle vertraut zu machen. Aber was wäre, wenn Sie Ihre eigenen benutzerdefinierten Befehle codieren könnten, um Ihren Workflow zu verbessern? Wenn wir auf Laravel 3 zurückblicken, werden Sie sich vielleicht daran erinnern, dass es Aufgaben bot. Aufgaben waren äußerst hilfreich, kamen aber für komplexere Operationen immer noch zu kurz. Zum Glück packt Laravel 4 einen aufgemotzten Artisan, der Ihnen das Leben als Entwickler so viel einfacher macht!
Was ist Handwerker?
Artisan ist das Befehlszeilenprogramm, das in Laravel 3 veröffentlicht wurde.
Wenn Sie mit Laravel nicht vertraut sind, kennen Sie Artisan möglicherweise nicht. Artisan ist das Befehlszeilenprogramm, das in Laravel 3 veröffentlicht wurde. Wenn Sie andere Frameworks verwendet haben, können Sie Artisan mit Oil in FuelPHP, ZFTool in Zend oder der Konsole in Symfony 2 vergleichen.
Artisan bietet viele nützliche Befehle, mit denen Sie verschiedene Aufgaben ausführen können, z. B. das Generieren von Migrationen oder das Veröffentlichen der Assets eines Pakets. Zusätzlich zu den integrierten Befehlen können Sie Artisan um Ihre eigenen Befehle erweitern.
Handwerker-Stiftungen
Hier schöpft Artisan seine Kraft.
In Laravel 3 wurde Artisan von Taylor Otwell (Laravels Schöpfer) von Grund auf neu geschrieben, daher war es ziemlich einfach (obwohl immer noch großartig). Jetzt, da Laravel 4 auf Composer basiert, kann es vorhandene Pakete verwenden, die von anderen brillanten Entwicklern entwickelt wurden. Daher hängt Laravel 4 jetzt von zahlreichen Paketen aus dem Symfony-Framework ab. Eines dieser Pakete ist die hervorragende Konsolenkomponente.
Wenn wir uns die Quelle der Artisan-Anwendung unter Illuminate\Console\Application ansehen, sehen wir, dass die Klasse selbst Symfony\Component\Console\Application erweitert. Hier schöpft Artisan seine Kraft. Obwohl Artisan die Konsolenkomponente von Symfony verwendet, wurden vielen gängigen Methoden flüssigere Laravel-ähnliche Aliase zugewiesen. Also mach dir keine Sorgen, es wird sich immer noch so anfühlen, als würdest du dich mit Laravel entwickeln!
Häufige Fragen
Beim Versuch, einen neuen Befehl zu entwickeln, werden normalerweise zwei Fragen angezeigt.
F Wo soll ich Befehle platzieren?
Wenn Sie eine Kopie von Laravel installieren, finden Sie unter app/command ein vordefiniertes Verzeichnis. Dieses Verzeichnis befindet sich standardmäßig auch in der classmap Ihrer composer.json. Dies bedeutet, dass Sie nach dem Erstellen eines Befehls den composer dump-autoload ausführen müssen, um eine aktualisierte Autoload-Datei zu generieren. Wenn Sie dies nicht tun, erhalten Sie Fehler und beschweren sich, dass Ihr Befehl nicht gefunden werden kann.
Wenn Sie ein Paket entwickeln, müssen Sie ein Verzeichnis in Ihrem Paket src/<vendor>/<package> erstellen, um Ihre Befehle zu speichern. In der gesamten Laravel 4-Codebasis heißt dieses Verzeichnis Console. Denken Sie daran, sicherzustellen, dass das Verzeichnis in Ihren Paketen composer.json automatisch geladen wird.
F Wie soll ich Befehle benennen?
In der gesamten Laravel 4-Codebasis werden alle Befehle mit dem Suffix Command versehen und nach der von ihnen ausgeführten Aufgabe benannt. Angenommen, Sie haben einen Befehl, der Ihren Cache löscht. Sie können diesen Befehl CacheClearCommand nennen.
Grundlagen eines Befehls
Ein Befehl sollte eine einzelne Aufgabe ausführen. Im weiteren Verlauf dieses Artikels werden wir einen Benutzergeneratorbefehl entwickeln. Lassen Sie uns die Grundlagen eines Befehls überprüfen.
1 |
// app/commands/UserGeneratorCommand.php |
2 |
|
3 |
<?php
|
4 |
|
5 |
use Illuminate\Console\Command; |
6 |
|
7 |
class UserGeneratorCommand extends Command { |
8 |
|
9 |
/**
|
10 |
* The console command name.
|
11 |
*
|
12 |
* @var string
|
13 |
*/
|
14 |
protected $name = 'user:generate'; |
15 |
|
16 |
/**
|
17 |
* The console command description.
|
18 |
*
|
19 |
* @var string
|
20 |
*/
|
21 |
protected $description = "Generate a new user"; |
22 |
|
23 |
/**
|
24 |
* Execute the console command.
|
25 |
*
|
26 |
* @return void
|
27 |
*/
|
28 |
public function fire() |
29 |
{
|
30 |
$this->line('Welcome to the user generator.'); |
31 |
}
|
32 |
|
33 |
}
|
Laravel kann diesen Boilerplate-Code für Sie generieren! Einfach ausführen:
1 |
$ php artisan command:make UserGeneratorCommand |
Dadurch wird ein Skelettbefehl erstellt, den Sie ändern können. Für die Zwecke dieses Lernprogramms werden wir jedoch einen Befehl von Grund auf neu erstellen, damit wir jeden Teil des Prozesses lernen können.
Befehlsname
Alle Befehle müssen einen Namen angeben. Dieser Name wird verwendet, um den Befehl von der Konsole aus auszuführen, und sollte die Aufgabe beschreiben, die der Befehl ausführt. Es gibt zwar keine Konvention für die Benennung Ihres Befehls, Sie können jedoch eine der folgenden Optionen in Betracht ziehen: namespace:group/command, namespace:command oder nur command.
Befehlsbeschreibung
Alle Befehle müssen eine Beschreibung enthalten. Die Beschreibung wird verwendet, wenn Sie eine Liste der verfügbaren Befehle von Artisan abrufen und die Hilfedokumente für einen Befehl anzeigen. Beschreibungen sollten kurz die Aufgabe beschreiben, die der Befehl ausführt.
Wenn wir unsere Konsole öffnen und eine Liste der verfügbaren Befehle abrufen, wird unser Befehl immer noch nicht aufgelistet.
1 |
$ php artisan list
|
2 |
Laravel Framework version 4.0.0 |
3 |
|
4 |
Usage: |
5 |
[options] command [arguments] |
6 |
|
7 |
Options: |
8 |
--help -h Display this help message. |
9 |
--quiet -q Do not output any message. |
10 |
--verbose -v Increase verbosity of messages. |
11 |
--version -V Display this application version. |
12 |
--ansi Force ANSI output.
|
13 |
--no-ansi Disable ANSI output.
|
14 |
--no-interaction -n Do not ask any interactive question. |
15 |
--env The environment the command should run under. |
16 |
|
17 |
Available commands: |
18 |
help Displays help for a command |
19 |
list Lists commands
|
20 |
migrate Run the database migrations |
21 |
serve Serve the application on the PHP development server |
22 |
tinker Interact with your application |
23 |
workbench Create a new package workbench |
24 |
asset |
25 |
asset:publish Publish a package's assets to the public directory
|
26 |
auth
|
27 |
auth:reminders Create a migration for the password reminders table
|
28 |
command
|
29 |
command:make Create a new Artisan command
|
30 |
config
|
31 |
config:publish Publish a package's configuration to the application
|
32 |
controller |
33 |
controller:make Create a new resourceful controller |
34 |
db |
35 |
db:seed Seed the database with records |
36 |
key |
37 |
key:generate Set the application key |
38 |
migrate |
39 |
migrate:install Create the migration repository |
40 |
migrate:make Create a new migration file |
41 |
migrate:refresh Reset and re-run all migrations |
42 |
migrate:reset Rollback all database migrations |
43 |
migrate:rollback Rollback the last database migration |
44 |
queue |
45 |
queue:listen Listen to a given queue |
46 |
queue:work Process the next job on a queue |
47 |
session |
48 |
session:table Create a migration for the session database table
|
Um unseren neuen Befehl zu registrieren, öffnen Sie app/start/artisan.php und lesen Sie schnell den Standardkommentarblock durch, der sich dort befindet. Wenn wir Artisan von der Konsole aus ausführen, ist diese Datei enthalten. Wir werden es verwenden, um unsere Befehle zu booten. In dieser Datei haben wir Zugriff auf eine $artisan-Variable, die vor dem Einfügen der Datei deklariert wurde. Erinnern Sie sich an die Artisan-Anwendungsklasse, die wir uns zuvor angesehen haben? Derjenige, der die Symfony Console-Komponente erweitert hat? Nun, $artisan ist eine Instanz dieser Klasse.
Fügen wir unseren Befehl hinzu, um ihn in der Konsole verfügbar zu machen.
1 |
$artisan->add(new UserGeneratorCommand); |
Oder wenn Sie die statische Syntax bevorzugen:
1 |
Artisan::add(new UserGeneratorCommand); |
Die add-Methode akzeptiert eine Befehlsinstanz. Sobald unser Befehl hinzugefügt wurde, können wir über die Konsole darauf zugreifen.
1 |
$ php artisan user:generate
|
2 |
Welcome to the user generator. |
Der Befehl sollte auch in den verfügbaren Befehlen sowie in den Hilfeinformationen aufgeführt sein.
1 |
$ php artisan list
|
1 |
$ php artisan user:generate --help |
2 |
Usage: |
3 |
user:generate |
4 |
|
5 |
Options: |
6 |
--help (-h) Display this help message. |
7 |
--quiet (-q) Do not output any message. |
8 |
--verbose (-v) Increase verbosity of messages. |
9 |
--version (-V) Display this application version. |
10 |
--ansi Force ANSI output.
|
11 |
--no-ansi Disable ANSI output.
|
12 |
--no-interaction (-n) Do not ask any interactive question. |
13 |
--env The environment the command should run under. |
Wenn Sie Fehler erhalten, stellen Sie sicher, dass Sie
composer dump autoloadvon Ihrem Anwendungsstamm aus ausführen, nachdem Sie den Befehl erstellt haben.
Farbige Ausgabe
Die Ausgabe von farbigem Text an die Konsole ist in Artisan ein Kinderspiel. Es gibt vier verschiedene Hilfsmethoden, um farbige ANSI-Ausgaben wiederzugeben.
1 |
$this->info("This is some information."); |
2 |
|
3 |
$this->comment("This is a comment."); |
4 |
|
5 |
$this->question("This is a question."); |
6 |
|
7 |
$this->error("This is an error."); |
Optionen und Argumente
Eine aufregende neue Funktion von Artisan ist die Möglichkeit, einem Befehl Optionen und Argumente bereitzustellen.
Argumente
Argumente sind Zeichenfolgen, die Sie an einen Befehl senden. Sie müssen einem Befehl in der Reihenfolge übergeben werden, in der sie definiert sind. Betrachten Sie den folgenden Befehl:
1 |
$ php artisan user:generate [name] [email] |
Das name-Argument muss vor dem email-Argument angegeben werden.
Argumente können als optional definiert werden.
Optionen
Optionen sind immer optional und werden, sofern vorhanden, mit zwei Bindestrichen versehen.
1 |
$ php artisan user:generate --admin |
Neben der Verwendung als boolesche Schalter kann eine Option so konfiguriert werden, dass sie einen Wert oder ein Array von Werten akzeptiert.
1 |
$ php artisan user:generate --name=Jason |
2 |
$ php artisan user:generate --role=user --role=editor |
Optionen und Argumente definieren
Bevor wir unsere Optionen und Argumente definieren, ist es am besten, die erforderlichen Symfony-Klassen zu importieren (sie sind lang und es wäre mühsam, sie ständig zu schreiben). Die beiden Klassen, die wir benötigen, sind Symfony\Component\Console\Input\InputOption und Symfony\Component\Console\Input\InputArgument.
Über unserer Klassendeklaration importieren wir beide Klassen.
1 |
// app/commands/UserGenerateCommand.php |
2 |
|
3 |
<?php
|
4 |
|
5 |
use Illuminate\Console\Command; |
6 |
use Symfony\Component\Console\Input\InputOption; |
7 |
use Symfony\Component\Console\Input\InputArgument; |
8 |
|
9 |
class UserGeneratorCommand extends Command { |
10 |
|
11 |
/**
|
12 |
* The console command name.
|
13 |
*
|
14 |
* @var string
|
15 |
*/
|
16 |
protected $name = 'user:generate'; |
17 |
|
18 |
/**
|
19 |
* The console command description.
|
20 |
*
|
21 |
* @var string
|
22 |
*/
|
23 |
protected $description = "Generate a new user"; |
24 |
|
25 |
/**
|
26 |
* Execute the console command.
|
27 |
*
|
28 |
* @return void
|
29 |
*/
|
30 |
public function fire() |
31 |
{
|
32 |
$this->line('Welcome to the user generator.'); |
33 |
}
|
34 |
|
35 |
}
|
Um die Optionen und Argumente zu definieren, müssen Sie zwei neue Methoden erstellen: getArguments und getOptions. Beide Methoden geben ein Array von Argumenten oder Optionen zurück. Lassen Sie unseren Befehl ein name-Argument und eine age-Option akzeptieren.
1 |
// app/commands/UserGenerateCommand.php |
2 |
|
3 |
<?php
|
4 |
|
5 |
use Illuminate\Console\Command; |
6 |
use Symfony\Component\Console\Input\InputOption; |
7 |
use Symfony\Component\Console\Input\InputArgument; |
8 |
|
9 |
class UserGeneratorCommand extends Command { |
10 |
|
11 |
/**
|
12 |
* The console command name.
|
13 |
*
|
14 |
* @var string
|
15 |
*/
|
16 |
protected $name = 'user:generate'; |
17 |
|
18 |
/**
|
19 |
* The console command description.
|
20 |
*
|
21 |
* @var string
|
22 |
*/
|
23 |
protected $description = "Generate a new user"; |
24 |
|
25 |
/**
|
26 |
* Execute the console command.
|
27 |
*
|
28 |
* @return void
|
29 |
*/
|
30 |
public function fire() |
31 |
{
|
32 |
$this->line('Welcome to the user generator.'); |
33 |
|
34 |
// Get the name arguments and the age option from the input instance.
|
35 |
$name = $this->argument('name'); |
36 |
|
37 |
$age = $this->option('age'); |
38 |
|
39 |
$this->line("{$name} is {$age} years old."); |
40 |
}
|
41 |
|
42 |
/**
|
43 |
* Get the console command arguments.
|
44 |
*
|
45 |
* @return array
|
46 |
*/
|
47 |
protected function getArguments() |
48 |
{
|
49 |
return array( |
50 |
array('name', InputArgument::REQUIRED, 'Name of the new user'), |
51 |
);
|
52 |
}
|
53 |
|
54 |
/**
|
55 |
* Get the console command options.
|
56 |
*
|
57 |
* @return array
|
58 |
*/
|
59 |
protected function getOptions() |
60 |
{
|
61 |
return array( |
62 |
array('age', null, InputOption::VALUE_REQUIRED, 'Age of the new user') |
63 |
);
|
64 |
}
|
65 |
|
66 |
}
|
Denken Sie daran: Laravel kann den gesamten Code für Sie generieren. Wir machen es einfach manuell, um jede Zeile in der Klasse zu überprüfen.
Jetzt können wir über unsere Konsole ein name-Argument und eine age-Option bereitstellen.
1 |
$ php artisan user:generate Jason --age=22 |
2 |
Jason is 22 years old. |
Sowohl Argumente als auch Optionen werden als mehrdimensionale Arrays definiert. Schauen wir uns die Definitionen für jede von ihnen genauer an.
Argumentdefinitionen
Die Array-Definition für ein Argument akzeptiert vier Schlüssel, wobei nur der erste (der Name des Arguments) erforderlich ist. Der zweite Schlüssel ist der Argumentationsmodus und sollte entweder InputArgument::OPTIONAL oder InputArgument::REQUIRED sein. Der dritte ist die Beschreibung und der vierte Schlüssel ist ein Standardwert, wenn der Modus auf InputArgument::OPTIONAL eingestellt ist.
Hier ist ein Argument, bei dem alle Array-Schlüssel verwendet werden.
1 |
array('name', InputArgument::OPTIONAL, 'Name of the new user', 'Jason') |
Optionsdefinitionen
Die Array-Definition für eine Option akzeptiert fünf Schlüssel, wobei nur der erste (der Optionsname) erforderlich ist. Die zweite Taste ist eine Verknüpfung für die Option (z. B. -a). Der dritte ist der Optionsmodus und kann einer der folgenden Werte sein: InputOption::VALUE_NONE, InputOption::VALUE_REQUIRED, InputOption::VALUE_OPTIONAL oder InputOption::VALUE_IS_ARRAY. Der vierte Schlüssel ist die Optionsbeschreibung, und der fünfte Schlüssel ist ein Standardwert, wenn der Modus nicht InputOption::VALUE_NONE oder InputOption::VALUE_REQUIRED ist.
Hier ist eine Option, bei der alle Array-Schlüssel verwendet werden.
1 |
array('age', 'a', InputOption::VALUE_OPTIONAL, 'Age of the new user', 22) |
Sie können den InputOption::VALUE_IS_ARRAY-Modus auch mit InputOption::VALUE_REQUIRED oder InputOption::VALUE_OPTIONAL kombinieren.
1 |
array('role', 'r', InputOption::VALUE_OPTIONAL | InputOption::VALUE_IS_ARRAY, 'Roles of the new user', 'user') |
Bestätigungen und Fragen
Eine weitere aufregende neue Funktion von Artisan ist die Möglichkeit, eine Bestätigung anzufordern oder dem Benutzer sogar eine Frage zu stellen. Dies macht die Entwicklung interaktiver Befehle so einfach wie möglich.
Bestätigungen
Mit confirm können wir einem Benutzer eine Frage stellen und ihn entweder mit "Ja" oder "Nein" bestätigen lassen. Lassen Sie uns bestätigen, dass der Benutzer sein Alter korrekt eingegeben hat.
1 |
// app/commands/UserGenerateCommand.php |
2 |
|
3 |
<?php
|
4 |
|
5 |
use Illuminate\Console\Command; |
6 |
use Symfony\Component\Console\Input\InputOption; |
7 |
use Symfony\Component\Console\Input\InputArgument; |
8 |
|
9 |
class UserGeneratorCommand extends Command { |
10 |
|
11 |
/**
|
12 |
* The console command name.
|
13 |
*
|
14 |
* @var string
|
15 |
*/
|
16 |
protected $name = 'user:generate'; |
17 |
|
18 |
/**
|
19 |
* The console command description.
|
20 |
*
|
21 |
* @var string
|
22 |
*/
|
23 |
protected $description = "Generate a new user"; |
24 |
|
25 |
/**
|
26 |
* Execute the console command.
|
27 |
*
|
28 |
* @return void
|
29 |
*/
|
30 |
public function fire() |
31 |
{
|
32 |
$this->line('Welcome to the user generator.'); |
33 |
|
34 |
// Get the name arguments and the age option from the input instance.
|
35 |
$name = $this->argument('name'); |
36 |
|
37 |
$age = $this->option('age'); |
38 |
|
39 |
if ( ! $this->confirm("Are you really {$age} years old? [yes|no]", true)) |
40 |
{
|
41 |
$this->comment('Then why did you say you were!?'); |
42 |
|
43 |
return; |
44 |
}
|
45 |
|
46 |
$this->comment("{$name} is {$age} years old."); |
47 |
}
|
48 |
|
49 |
/**
|
50 |
* Get the console command arguments.
|
51 |
*
|
52 |
* @return array
|
53 |
*/
|
54 |
protected function getArguments() |
55 |
{
|
56 |
return array( |
57 |
array('name', InputArgument::REQUIRED, 'Name of the new user'), |
58 |
);
|
59 |
}
|
60 |
|
61 |
/**
|
62 |
* Get the console command options.
|
63 |
*
|
64 |
* @return array
|
65 |
*/
|
66 |
protected function getOptions() |
67 |
{
|
68 |
return array( |
69 |
array('age', null, InputOption::VALUE_REQUIRED, 'Age of the new user', null) |
70 |
);
|
71 |
}
|
72 |
|
73 |
}
|
Der erste Parameter ist die Frage, die Sie stellen möchten, und der zweite ist der Standardwert, wenn ein Benutzer die Eingabetaste drückt, ohne etwas einzugeben.
Fragen
Mit ask können wir einem Benutzer eine Frage stellen und eine Antwort von ihm erwarten. Anstatt unseren Befehl zu beenden, wenn der Benutzer angibt, dass er sein Alter falsch eingegeben hat, bitten wir ihn stattdessen, es erneut einzugeben.
1 |
// app/commands/UserGenerateCommand.php |
2 |
|
3 |
<?php
|
4 |
|
5 |
use Illuminate\Console\Command; |
6 |
use Symfony\Component\Console\Input\InputOption; |
7 |
use Symfony\Component\Console\Input\InputArgument; |
8 |
|
9 |
class UserGeneratorCommand extends Command { |
10 |
|
11 |
/**
|
12 |
* The console command name.
|
13 |
*
|
14 |
* @var string
|
15 |
*/
|
16 |
protected $name = 'user:generate'; |
17 |
|
18 |
/**
|
19 |
* The console command description.
|
20 |
*
|
21 |
* @var string
|
22 |
*/
|
23 |
protected $description = "Generate a new user"; |
24 |
|
25 |
/**
|
26 |
* Execute the console command.
|
27 |
*
|
28 |
* @return void
|
29 |
*/
|
30 |
public function fire() |
31 |
{
|
32 |
$this->line('Welcome to the user generator.'); |
33 |
|
34 |
// Get the name arguments and the age option from the input instance.
|
35 |
$name = $this->argument('name'); |
36 |
|
37 |
$age = $this->option('age'); |
38 |
|
39 |
// Confirm the user entered their age correctly and if they haven't we'll
|
40 |
// ask them to enter it again.
|
41 |
if ( ! $this->confirm("Are you really {$age} years old? [yes|no]", true)) |
42 |
{
|
43 |
$age = $this->ask('So how old are you then?'); |
44 |
}
|
45 |
|
46 |
$this->comment("{$name} is {$age} years old."); |
47 |
}
|
48 |
|
49 |
/**
|
50 |
* Get the console command arguments.
|
51 |
*
|
52 |
* @return array
|
53 |
*/
|
54 |
protected function getArguments() |
55 |
{
|
56 |
return array( |
57 |
array('name', InputArgument::REQUIRED, 'Name of the new user'), |
58 |
);
|
59 |
}
|
60 |
|
61 |
/**
|
62 |
* Get the console command options.
|
63 |
*
|
64 |
* @return array
|
65 |
*/
|
66 |
protected function getOptions() |
67 |
{
|
68 |
return array( |
69 |
array('age', null, InputOption::VALUE_REQUIRED, 'Age of the new user', null) |
70 |
);
|
71 |
}
|
72 |
|
73 |
}
|
Befehlsabhängigkeiten
Die Abhängigkeitsinjektion ist ein wichtiger Schritt, um sicherzustellen, dass Ihr Code testbar und zukunftssicher ist. Gehen wir noch einen Schritt weiter, indem wir eine Modellinstanz einfügen, damit wir den Benutzer generieren können. Wir beginnen mit der Erstellung einer Benutzeroberfläche und eines Benutzermodells.
1 |
// app/models/UserInterface.php |
2 |
|
3 |
<?php
|
4 |
|
5 |
interface UserInterface { |
6 |
|
7 |
}
|
Unser
UserInterfacedefiniert eigentlich keine Methodenimplementierungen, da dies nur ein Beispiel ist. Für eine reale Anwendung definieren Sie die Methoden, die Sie für Ihr Modell erwarten.
1 |
// app/models/User.php |
2 |
|
3 |
<?php
|
4 |
|
5 |
class User extends Eloquent implements UserInterface { |
6 |
|
7 |
/**
|
8 |
* The database table used by the model.
|
9 |
*
|
10 |
* @var string
|
11 |
*/
|
12 |
protected $table = 'users'; |
13 |
|
14 |
}
|
Nachdem unser User-Modell unser UserInterface implementiert hat, können wir unsere Abhängigkeit in unserem Befehl weiter einrichten. Ich werde unserem Befehl "generate" etwas mehr hinzufügen und mit dem injizierten User-Modell interagieren.
1 |
// app/commands/UserGenerateCommand.php |
2 |
|
3 |
<?php
|
4 |
|
5 |
use Illuminate\Console\Command; |
6 |
use Symfony\Component\Console\Input\InputOption; |
7 |
use Symfony\Component\Console\Input\InputArgument; |
8 |
|
9 |
class UserGeneratorCommand extends Command { |
10 |
|
11 |
/**
|
12 |
* The console command name.
|
13 |
*
|
14 |
* @var string
|
15 |
*/
|
16 |
protected $name = 'user:generate'; |
17 |
|
18 |
/**
|
19 |
* The console command description.
|
20 |
*
|
21 |
* @var string
|
22 |
*/
|
23 |
protected $description = "Generate a new user"; |
24 |
|
25 |
/**
|
26 |
* User model instance.
|
27 |
*
|
28 |
* @var UserInterface
|
29 |
*/
|
30 |
protected $user; |
31 |
|
32 |
/**
|
33 |
* Create a new UserGeneratorCommand instance.
|
34 |
*
|
35 |
* @param UserInterface $user
|
36 |
* @return void
|
37 |
*/
|
38 |
public function __construct(UserInterface $user) |
39 |
{
|
40 |
$this->user = $user; |
41 |
}
|
42 |
|
43 |
/**
|
44 |
* Execute the console command.
|
45 |
*
|
46 |
* @return void
|
47 |
*/
|
48 |
public function fire() |
49 |
{
|
50 |
$this->line('Welcome to the user generator.'); |
51 |
|
52 |
// Get the name arguments and the age option from the input instance.
|
53 |
$this->user->name = $this->argument('name'); |
54 |
|
55 |
$this->user->age = $this->option('age'); |
56 |
|
57 |
// Confirm the user entered their age correctly and if they haven't we'll
|
58 |
// ask them to enter it again. We'll continue asking them until they are
|
59 |
// sure they've entered the right age.
|
60 |
$correctAge = false; |
61 |
|
62 |
while ( ! $correctAge) |
63 |
{
|
64 |
if ( ! $this->confirm("Are you really {$this->user->age} years old? [yes|no]", true)) |
65 |
{
|
66 |
$this->user->age = $this->ask('So how old are you then?'); |
67 |
}
|
68 |
else
|
69 |
{
|
70 |
$correctAge = true; |
71 |
}
|
72 |
}
|
73 |
|
74 |
$this->user->framework = $this->ask('What is your favorite framework?', 'Laravel'); |
75 |
|
76 |
$this->user->website = $this->ask('What is your website address?'); |
77 |
|
78 |
// Save the user to the database.
|
79 |
$this->user->save(); |
80 |
|
81 |
// Report that the user has been saved.
|
82 |
$this->info("{$this->user->name} has been generated and saved."); |
83 |
}
|
84 |
|
85 |
/**
|
86 |
* Get the console command arguments.
|
87 |
*
|
88 |
* @return array
|
89 |
*/
|
90 |
protected function getArguments() |
91 |
{
|
92 |
return array( |
93 |
array('name', InputArgument::REQUIRED, 'Name of the new user'), |
94 |
);
|
95 |
}
|
96 |
|
97 |
/**
|
98 |
* Get the console command options.
|
99 |
*
|
100 |
* @return array
|
101 |
*/
|
102 |
protected function getOptions() |
103 |
{
|
104 |
return array( |
105 |
array('age', null, InputOption::VALUE_REQUIRED, 'Age of the new user', null) |
106 |
);
|
107 |
}
|
108 |
|
109 |
}
|
Das erste, was Sie beachten sollten, ist, dass der Befehl jetzt einen Konstruktor hat. Dieser Konstruktor akzeptiert einen einzelnen Parameter und wir haben den Hinweis UserInterface eingegeben, sodass wir wissen, dass die Klasse, die wir erhalten, die auf der Schnittstelle definierten Methoden implementiert. Befehlskonstruktoren sollten auch den übergeordneten Konstruktor aufrufen.
In der fire-Methode des Befehls weisen wir die Eigenschaften der User-Modellinstanz direkt zu. Wir verwenden auch eine Schleife, um den Benutzer weiterhin zu fragen, ob er sein Alter korrekt eingegeben hat. Zuletzt wird der Benutzer in der Datenbank gespeichert und wir geben an die Konsole aus, dass der Benutzer generiert und gespeichert wurde.
Aber warte! Bevor wir den Befehl verwenden können, müssen wir eine Instanz unseres User-Modells einfügen.
1 |
// app/start/artisan.php
|
2 |
|
3 |
$user = new User; |
4 |
|
5 |
$artisan->add(new UserGeneratorCommand($user)); |
Wenn Sie eine Datenbank eingerichtet und korrekt konfiguriert haben, sollten Sie jetzt in der Lage sein, den Befehl auszuführen und einen neuen Benutzer in der Datenbank zu speichern!
Paketbefehle
Wenn Sie ein Paket in Laravel entwickeln, möchten Sie möglicherweise Befehle einfügen. Das Registrieren von Befehlen aus Paketen ist größtenteils der gleiche Vorgang, außer dass Sie den Befehl nicht in app/start/artisan.php hinzufügen (oder nicht hinzufügen können). Stattdessen lösen Sie sie mit Artisan von Ihrem Paketdienstleister aus.
1 |
// path/to/your/PackageServiceProvider.php
|
2 |
|
3 |
/**
|
4 |
* Register the service provider.
|
5 |
*
|
6 |
* @return void
|
7 |
*/
|
8 |
public function register() |
9 |
{
|
10 |
$this->app['command.package.command'] = $this->app->share(function($app) |
11 |
{
|
12 |
return new PackageCommand($app['dependency']); |
13 |
});
|
14 |
|
15 |
$this->commands('command.package.command'); |
16 |
}
|
Die commands-Methode kann eine beliebige Anzahl von Argumenten akzeptieren und löst den Befehl beim Start von Artisan aus dem Anwendungscontainer auf.
Abschluss
Wenn Sie Artisan in Laravel 4 mit seinem Gegenstück in Laravel 3 vergleichen, werden Sie schnell feststellen, dass die Verbesserungen monumental sind. Befehle können jetzt an den IoC-Container gebunden werden und die Abhängigkeitsinjektion umfassen, farbige ANSI-Ausgaben bereitstellen, Argumente und Optionen verwenden und Benutzerinteraktion anfordern.
Die Leistung von Artisan ist dank der Konsolenkomponente von Symfony unglaublich. Befehle werden eine große Rolle spielen, wenn wir vorwärts gehen - also steigen Sie früh ein!
By
