Projects [SHOW]

Controller definieren

Nachfolgend sehen Sie ein Beispiel für eine grundlegende Controller-Klasse. Beachten Sie, dass der Controller die mit Laravel mitgelieferte Basiscontrollerklasse erweitert. Die Basisklasse bietet einige Komfortmethoden wie die Middleware-Methode, mit der die Middleware an Controller-Aktionen angehängt werden kann:

<?php

namespace App\Http\Controllers;

use App\User;
use App\Http\Controllers\Controller;

class UserController extends Controller
{
    /**
     * Show the profile for the given user.
     *
     * @param  int  $id
     * @return View
     */
    public function show($id)
    {
        return view('user.profile', ['user' => User::findOrFail($id)]);
    }
}

Sie können auf diese Weise eine Route zu dieser Controller-Aktion definieren:

Route::get('user/{id}', 'UserController@show');

Wenn nun eine Anforderung mit der angegebenen Routen-URI übereinstimmt, wird die Show-Methode der UserController-Klasse ausgeführt. Die Routenparameter werden ebenfalls an die Methode übergeben.

Controllers & Namespaces

Es ist sehr wichtig zu beachten, dass wir bei der Definition der Controller-Route nicht den gesamten Controller-Namensraum angeben mussten. Da der RouteServiceProvider Ihre Routendateien innerhalb einer Routengruppe lädt, die den Namensraum enthält, haben wir nur den Teil des Klassennamens angegeben, der nach dem Teil App\Http\Controllers des Namensraums liegt.

Wenn Sie Ihre Controller tiefer in das Verzeichnis App\Http\Controllers verschachteln möchten, verwenden Sie den spezifischen Klassennamen in Bezug auf den Root-Namensraum von App\Http\Controllers. Wenn also Ihre vollständige Controller-Klasse App\Http\Controllers\Photos\AdminController ist, sollten Sie Routen zum Controller so registrieren:

Route::get('foo', 'Photos\AdminController@method');

Single Action Controllers

Wenn Sie einen Controller definieren möchten, der nur eine einzige Aktion verarbeitet, können Sie eine einzige __invoke-Methode auf dem Controller platzieren:

<?php

namespace App\Http\Controllers;

use App\User;
use App\Http\Controllers\Controller;

class ShowProfile extends Controller
{
    /**
     * Show the profile for the given user.
     *
     * @param  int  $id
     * @return View
     */
    public function __invoke($id)
    {
        return view('user.profile', ['user' => User::findOrFail($id)]);
    }
}

Bei der Registrierung von Routen für Single-Action-Controller müssen Sie keine Methode angeben:

Route::get('user/{id}', 'ShowProfile');

Sie können einen aufrufbaren Controller erzeugen, indem Sie die Option --invokable des Befehls make:controller Artisan verwenden:

php artisan make:controller ShowProfile --invokable

Controller Middleware

Die Middleware kann den Routen der Steuerung in Ihren Routendateien zugeordnet werden:

Route::get('profile', 'UserController@show')->middleware('auth');

Es ist jedoch bequemer, die Middleware im Konstruktor Ihres Controllers anzugeben. Mit der Middleware-Methode aus dem Konstruktor Ihres Controllers können Sie die Middleware ganz einfach der Aktion des Controllers zuordnen. Sie können die Middleware sogar auf bestimmte Methoden der Controller-Klasse beschränken:

class UserController extends Controller
{
    /**
     * Instantiate a new controller instance.
     *
     * @return void
     */
    public function __construct()
    {
        $this->middleware('auth');

        $this->middleware('log')->only('index');

        $this->middleware('subscribed')->except('store');
    }
}

Controller ermöglichen es Ihnen auch, Middleware mit einem Closure zu registrieren. Dies bietet eine komfortable Möglichkeit, eine Middleware für eine einzelne Steuerung zu definieren, ohne eine gesamte Middleware-Klasse zu definieren:

$this->middleware(function ($request, $next) {
    // ...

    return $next($request);
});

Resource Controllers

Laravel Resource Routing weist die typischen "CRUD"-Routen einer Steuerung mit einer einzigen Codezeile zu. Beispielsweise können Sie einen Controller erstellen, der alle HTTP-Anfragen für "Fotos", die von Ihrer Anwendung gespeichert werden, verarbeitet. Mit dem Befehl make:controller Artisan können wir einen solchen Controller schnell erstellen:

php artisan make:controller PhotoController --resource

Dieser Befehl erzeugt einen Controller unter app/Http/Controllers/PhotoController.php. Der Controller enthält für jede der verfügbaren Ressourcenoperationen eine Methode.

Als nächstes können Sie eine findige Route zum Controller registrieren:

Route::resource('photos', 'PhotoController');

Diese Single-Route-Deklaration erstellt mehrere Routen, um eine Vielzahl von Aktionen auf der Ressource durchzuführen. Der generierte Controller wird bereits Methoden für jede dieser Aktionen haben, einschließlich Notizen, die Sie über die HTTP-Verben und URIs informieren, die sie behandeln.

Sie können mehrere Ressourcen-Controller auf einmal registrieren, indem Sie ein Array an die Ressource-Methode übergeben:

Route::resources([
    'photos' => 'PhotoController',
    'posts' => 'PostController'
]);

Aktionen, die vom Ressourcencontroller ausgeführt werden.

Specifying The Resource Model

Wenn Sie die Route-Modell-Bindung verwenden und möchten, dass die Methoden des Ressourcen-Controllers einen Typ-Hinweis auf eine Modellinstanz geben, können Sie beim Erzeugen des Controllers die Option --model verwenden:

php artisan make:controller PhotoController --resource --model=Photo

Spoofing Form Methods

Da HTML-Formulare keine PUT-, PATCH- oder DELETE-Anfragen stellen können, müssen Sie ein verstecktes _method Feld hinzufügen, um diese HTTP-Verben zu manipulieren. Die @method Blade Direktive kann dieses Feld für Sie erstellen:

<form action="/foo/bar" method="POST">
    @method('PUT')
</form>

Partial Resource Routes

Wenn Sie eine Ressourcenroute deklarieren, können Sie eine Teilmenge von Aktionen angeben, die der Controller anstelle des vollständigen Satzes von Standardaktionen ausführen soll:

Route::resource('photos', 'PhotoController')->only([
    'index', 'show'
]);

Route::resource('photos', 'PhotoController')->except([
    'create', 'store', 'update', 'destroy'
]);

API Resource Routes

Wenn Sie Ressourcenrouten deklarieren, die von APIs verwendet werden, sollten Sie häufig Routen ausschließen, die HTML-Templates präsentieren, wie z.B. Erstellen (Create) und Bearbeiten (Edit). Sie können die apiResource-Methode verwenden, um diese beiden Routen automatisch auszuschließen:

Route::apiResource('photos', 'PhotoController');

Sie können mehrere API-Ressourcen-Controller auf einmal registrieren, indem Sie ein Array an die apiResources-Methode übergeben:

Route::apiResources([
    'photos' => 'PhotoController',
    'posts' => 'PostController'
]);

To quickly generate an API resource controller that does not include the create or edit methods, use the --api switch when executing the make:controller command:

php artisan make:controller API/PhotoController --api

Naming Resource Routes

Standardmäßig haben alle Aktionen des Ressourcencontrollers einen Routennamen; Sie können diese Namen jedoch überschreiben, indem Sie ein Namensfeld (names array) mit Ihren Optionen übergeben:

Route::resource('photos', 'PhotoController')->names([
    'create' => 'photos.build'
]);

Naming Resource Route Parameters

Standardmäßig erstellt Route::resource die Routenparameter für Ihre Ressourcenrouten basierend auf der "singularisierten" Version des Ressourcennamens. Sie können dies auf einer ressourcenbezogenen Basis mit Hilfe der Parameter-Methode leicht überschreiben. Das Array, das an die Parameter-Methode übergeben wird, sollte ein assoziatives Array aus Ressourcennamen und Parameternamen sein:

Route::resource('users', 'AdminUserController')->parameters([
    'users' => 'admin_user'
]);

Das obige Beispiel erzeugt die folgenden URIs für die Show-Route der Ressource:

/users/{admin_user}

Localizing Resource URIs

Standardmäßig erstellt Route::resource Ressourcen-URIs mit englischen Verben. Wenn Sie die Aktionsverben erstellen (create) und bearbeiten (edit) müssen, können Sie die Methode Route::resourceVerbs verwenden. Dies kann in der Boot-Methode Ihres AppServiceProviders erfolgen:

use Illuminate\Support\Facades\Route;

/**
 * Bootstrap any application services.
 *
 * @return void
 */
public function boot()
{
    Route::resourceVerbs([
        'create' => 'crear',
        'edit' => 'editar',
    ]);
}

Sobald die Verben angepasst wurden, erzeugt eine Ressourcenroutenregistrierung wie Route::resource('fotos','PhotoController') die folgenden URIs:

/fotos/crear

/fotos/{foto}/editar

Supplementing Resource Controllers

Wenn Sie einem Ressourcencontroller zusätzliche Routen hinzufügen müssen, die über den Standardsatz von Ressourcenrouten hinausgehen, sollten Sie diese Routen vor Ihrem Aufruf von Route::resource definieren; andernfalls können die von der Ressourcen-Methode definierten Routen unbeabsichtigt Vorrang vor Ihren zusätzlichen Routen haben:

Route::get('photos/popular', 'PhotoController@method');

Route::resource('photos', 'PhotoController');

Dependency Injection & Controllers

Constructor Injection

Der Laravel-Service-Container wird verwendet, um alle Laravel-Controller aufzulösen. Dadurch können Sie auf Abhängigkeiten hinweisen, die Ihr Controller in seinem Konstruktor benötigt. Die deklarierten Abhängigkeiten werden automatisch aufgelöst und in die Controller-Instanz injiziert:

<?php

namespace App\Http\Controllers;

use App\Repositories\UserRepository;

class UserController extends Controller
{
    /**
     * The user repository instance.
     */
    protected $users;

    /**
     * Create a new controller instance.
     *
     * @param  UserRepository  $users
     * @return void
     */
    public function __construct(UserRepository $users)
    {
        $this->users = $users;
    }
}

Sie können auch einen Tipp (type-hint) auf einen Laravel contract geben. Wenn der Container ihn auflösen kann, können Sie ihn mit einem Tipp (type-hint) versehen. Abhängig von Ihrer Anwendung kann das Einbringen Ihrer Abhängigkeiten in Ihren Controller eine bessere Testbarkeit bieten.

Verfahren Injektion

Zusätzlich zur Konstrukteureinspritzung können Sie auch Abhängigkeiten von den Methoden Ihres Controllers angeben. Ein gängiger Anwendungsfall für die Methodeninjektion ist das Einfügen der Illuminate\Http\Request-Instanz in Ihre Steuermethoden:

<?php

namespace App\Http\Controllers;

use Illuminate\Http\Request;

class UserController extends Controller
{
    /**
     * Store a new user.
     *
     * @param  Request  $request
     * @return Response
     */
    public function store(Request $request)
    {
        $name = $request->name;

        //
    }
}

Wenn Ihre Steuermethode auch Eingaben von einem Routenparameter erwartet, listen Sie Ihre Routenargumente hinter Ihren anderen Abhängigkeiten auf. Zum Beispiel, wenn Ihre Route so definiert ist:

Route::put('user/{id}', 'UserController@update');

Sie können immer noch den Hinweis auf die Illuminate\Http\Request eingeben und auf Ihren id-Parameter zugreifen, indem Sie Ihre Controller-Methode wie folgt definieren:

<?php

namespace App\Http\Controllers;

use Illuminate\Http\Request;

class UserController extends Controller
{
    /**
     * Update the given user.
     *
     * @param  Request  $request
     * @param  string  $id
     * @return Response
     */
    public function update(Request $request, $id)
    {
        //
    }
}

Route Caching

Wenn Ihre Anwendung ausschließlich Controller-basierte Routen verwendet, sollten Sie den Routen-Cache von Laravel nutzen. Die Verwendung des Routen-Cache reduziert die Zeit, die für die Registrierung aller Routen Ihrer Anwendung benötigt wird, drastisch. In einigen Fällen kann Ihre Routenregistrierung sogar bis zu 100-mal schneller sein. Um einen Routen-Cache zu erzeugen, führen Sie einfach den Befehl route:cache mit Artisan aus:

php artisan route:cache

Nachdem Sie diesen Befehl ausgeführt haben, wird Ihre zwischengespeicherte Routen-Datei bei jeder Anforderung geladen. Denken Sie daran, wenn Sie neue Routen hinzufügen, müssen Sie einen neuen Routen-Cache erzeugen. Aus diesem Grund sollten Sie den Befehl route:cache nur während der Bereitstellung Ihres Projekts ausführen.

Sie können den Befehl route:clear verwenden, um den Routen-Cache zu leeren:

php artisan route:clear