Controller

• Einführung
• Basis-Controller
  • Definitions-Controller
  • Controller & Namespace
  • Single Behavior Controller
• Controller Middleware
• Ressourcencontroller
  • Teilweises Ressourcen-Routing
  • Benanntes Ressourcen-Routing
  • Benannte Ressourcen-Routing-Parameter
  • Lokalisierte Ressourcen URIs
  • Supplementary Resource Controllers
• Dependency Injection & Controller
• Routen-Cache

Einführung

Um die gesamte Anforderungsverarbeitungslogik zu ersetzen, die in Form von Abschlüssen in der Routing-Datei definiert ist, Möglicherweise möchten Sie Kontrollklassen verwenden, um diese Verhaltensweisen zu organisieren. Controller können zugehörige Logik zur Anforderungsverarbeitung in einer separaten Klasse gruppieren. Controller werden im Verzeichnis app/Http/Controllers gespeichert.

Basis-Controller

Controller definieren

Das Folgende ist ein Beispiel für eine grundlegende Controller-Klasse. Es ist zu beachten, dass dieser Controller den integrierten Basisklassen-Controller von Laravel erbt. Dieser Basisklassen-Controller bietet einige praktische Methoden, wie z. B. die Methode middleware, mit der Middleware zum Controller-Verhalten hinzugefügt werden kann:

    <?php  
      namespace App\Http\Controllers;   
      use App\User;    
      use App\Http\Controllers\Controller;    
      class UserController extends Controller   
       {       
        /**
         * 显示给定用户的概要文件.
         *
         * @param  int  $id
         * @return View
         */        
       public function show($id)       
        {           
         return view('user.profile', ['user' => User::findOrFail($id)]);      
         }   
        }

Sie können eine Route definieren, die auf das Controller-Verhalten wie folgt zeigt:

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

Wenn nun eine Anfrage mit dem URI der angegebenen Route übereinstimmt, wird die UserController-Methode im show-Controller ausgeführt. An diese Methode werden auch Routenparameter übergeben.

{tip} Controller müssen nicht von der Basisklasse erben. Wenn der Controller jedoch nicht von der Basisklasse erbt, können Sie einige praktische Funktionen wie die Methoden middleware, validate und dispatch nicht verwenden.

Controller & Namespace

Es ist wichtig darauf hinzuweisen, dass wir bei der Definition von Controller-Routen nicht den vollständigen Controller-Namespace angeben müssen. Da RouteServiceProvider die Routing-Datei in eine Routing-Gruppe lädt, die den Namespace enthält, müssen wir nur den Teil des Klassennamens nach dem Namespace AppHttpControllers angeben.

Wenn Sie den Controller in einem Verzeichnis tiefer als AppHttpControllers platzieren möchten, müssen Sie den angegebenen Klassennamen relativ zu AppHttpControllers als Root-Namespace verwenden. Wenn Ihr vollständiger Controller-Klassenname daher AppHttpControllersPhotosAdminController lautet, sollten Sie ihn wie folgt in der Route registrieren:

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

Single Behavior Controller

Wenn Sie einen Controller definieren möchten, der nur ein einzelnes Verhalten verarbeitet, können Sie einen platzieren __invokeMethode:

    <?php   
       namespace App\Http\Controllers;    
       use App\User;    
       use App\Http\Controllers\Controller;    
       class ShowProfile extends Controller   
        {        
        /**
         * 展示给定用户的资料.
         *
         * @param  int  $id
         * @return View
         */      
        public function __invoke($id)      
          {          
            return view('user.profile', ['user' => User::findOrFail($id)]);      
           }   
         }

Beim Registrieren einer Route für einen einzelnen Verhaltenscontroller ist es nicht erforderlich, die Methode anzugeben:

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

Sie können make:controller im Befehl --invokable übergeben im Artisan-Befehlstool Optionen zum Generieren eines aufrufbaren Controllers:

    php artisan make:controller ShowProfile --invokable

Controller Middleware

Middleware finden Sie in der Routendatei Die Route dem Controller zugeordnet.

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

Es ist jedoch bequemer, die Middleware im Konstruktor des Controllers anzugeben. Mittels der Methode middleware im Konstruktor des Controllers kann Middleware einfach einer Aktion eines Controllers zugewiesen werden. Sie können 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');    
     }
  }

Gleichzeitig ermöglicht der Controller auch die Registrierung von Middleware mithilfe eines Abschlusses. Dies bietet eine bequeme Möglichkeit, Middleware für einen einzelnen Controller zu definieren, ohne die gesamte Middleware-Klasse zu definieren:

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

{tip} Sie können Controller-Aktionen eine Middleware zuweisen. Dies kann jedoch darauf hinweisen, dass Ihr Controller wird sehr groß. Es wird empfohlen, den Controller in mehrere kleinere Controller aufzuteilen.

Ressourcencontroller

Laravel-Ressourcenrouting weist Controllern mit einer einzigen Codezeile typische „CURD (Erstellen, Löschen, Ändern, Überprüfen)“-Routen zu. Sie möchten beispielsweise einen Controller erstellen, der alle HTTP-Anfragen für von Ihrer App gespeicherte „Fotos“ verarbeitet. Mit dem Artisan-Befehl make:controller können wir schnell einen Controller wie diesen erstellen:

php artisan make:controller PhotoController --resource

Dieser Befehl generiert einen Controller app/Http/Controllers/PhotoController.php. Dazu gehören Methoden für jeden verfügbaren Ressourcenvorgang.

Als nächstes können Sie eine Ressourcenroute beim Controller registrieren:

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

Diese einzelne Routendeklaration erstellt mehrere Routen, um verschiedene Verhaltensweisen auf der Ressource zu verarbeiten. Der generierte Controller behält Methoden für jede Aktion bei, einschließlich deklarativer Anmerkungen für die Verarbeitung von HTTP-Verben und URLs.

Sie können mehrere Ressourcencontroller gleichzeitig erstellen, indem Sie Array-Parameter an die resources-Methode übergeben:

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

Betriebsverarbeitung des Ressourcencontrollers

Ressourcenmodell angeben

Wenn Sie die Routenmodellbindung verwenden und Typhinweise in Ressourcencontrollermethoden verwenden möchten, können Sie --model Optionen:

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

Gefälschte Formularmethode

Weil HTML Formulare können keine PUT-, PATCH- und DELETE-Anfragen generieren, daher müssen Sie ein verstecktes _method-Feld hinzufügen, um HTTP-Aktionen zu fälschen. Dieser Blade-Befehl @method Dieses Feld kann für Sie erstellt werden:

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

Partial Resource Routing

Statement Beim Weiterleiten von Ressourcen können Sie einige Verhaltensweisen angeben, die der Controller anstelle aller Standardverhaltensweisen verarbeiten soll:

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

API Ressourcenrouten

Beim Deklarieren von Ressourcenrouten für APIs ist es häufig erforderlich, Routen auszuschließen, die HTML-Vorlagen anzeigen, wie z. B. create und edit. Der Einfachheit halber können Sie die Methode apiResource verwenden, um diese beiden Routen automatisch auszuschließen:

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

Sie können mehrere API-Ressourcencontroller gleichzeitig registrieren, indem Sie ein Array an die Methode apiResources übergeben:

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

Um schnell einen API-Ressourcencontroller zu generieren, der keine create- und edit-Methoden enthält, können Sie ihn ausführen Fügen Sie die Option make:controller zum Befehl --api hinzu:

php artisan make:controller API/PhotoController --api

Benannte Ressourcenroute

Standardmäßig ist Alle Ressourcencontroller-Operationen haben einen Routennamen; dies kann jedoch durch die Übergabe eines names erfolgen Array zum Überschreiben dieser Namen:

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

Benannte Ressourcenroutenparameter

Standardmäßig basiert Route::resource on Die „Singular“-Form des Ressourcennamens erstellt Routing-Parameter für Ressourcenrouten. Sie können jede Ressource einfach überschreiben, indem Sie den Parameter parameters im Optionsarray übergeben. Das parameters-Array sollte ein assoziatives Array von Ressourcennamen und Parameternamen sein:

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

Die obige Liste generiert die folgende URL für die show-Route der Ressource:

/users/{admin_user}

Lokalisierte Ressourcen-URIs

Standardmäßig verwendet Route::resource englische Verben, um Ressourcen-URIs zu erstellen. Wenn Sie die Aktionsnamen create und edit lokalisieren müssen, können Sie die Methode AppServiceProvider in der Methode boot von Route::resourceVerbs verwenden.

use Illuminate\Support\Facades\Route;
/**
 * 初始化任何应用服务
 *
 * @return void
 */
 public function boot(){ 
    Route::resourceVerbs([      
      'create' => 'crear',        
      'edit' => 'editar',    
    ]);
  }

Sobald die Aktion angepasst ist, generieren Ressourcenrouten, die wie Route::resource('fotos', 'PhotoController') registriert sind, Folgendes URI:

/fotos/crear/fotos/{foto}/editar

Supplementary Resource Controller

Wenn Sie einen anderen Ressourcencontroller als die Standardroute For hinzufügen müssen Für zusätzliche Routen sollten Sie Route::resource aufrufen, bevor Sie diese Routen definieren. Andernfalls rufen Sie resource auf Methodendefinierte Routen können unbeabsichtigt Vorrang vor Routen haben, die Sie hinzufügen:

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

{tip} Denken Sie daran, die Controller spezifisch zu halten. Wenn Sie häufig Methoden außerhalb typischer Ressourcenoperationen benötigen, sollten Sie die Aufteilung Ihres Controllers in kleinere Controller in Betracht ziehen.

Abhängigkeitsinjektion und -steuerung

Konstruktorinjektion

Der Laravel-Servicecontainer löst alle Controller auf. Daher können Sie im Konstruktor Ihres Controllers Typhinweise für Abhängigkeiten verwenden, die Sie möglicherweise benötigen. Die Abhängigkeitsdeklaration wird automatisch aufgelöst und in die Controller-Instanz eingefügt:

<?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;   
      }
    }

Natürlich können Sie jeden Laravel-Vertrag eingeben, solange der Container ihn auflösen kann. Abhängig von Ihrer Anwendung führt das Einfügen Ihrer Typhinweise in den Controller zu einer besseren Testbarkeit.

Methodeninjektion

verwaltet die Konstruktorinjektion und Sie können auch Abhängigkeiten in Controller-Methoden mit Typhinweisen versehen. Der häufigste Anwendungsfall für die Methodeninjektion besteht darin, eine Instanz von IlluminateHttpRequest in eine Controller-Methode einzufügen:

<?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 Ihr Controller auch Eingaben in Routenparameter benötigt, platzieren Sie die Routenparameter nach diesen Abhängigkeiten. Ihre Routendefinition sieht beispielsweise so aus:

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

Sie können weiterhin den IlluminateHttpRequest-Typhinweis eingeben und auf die id-Parameter zugreifen, indem Sie die folgende Definition in Ihrer Controller-Methode verwenden:

<?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)   
    {       
     //   
     }
 }

Routen-Caching

{note} Schließungsbasierte Routen können nicht zwischengespeichert werden. Verwenden Sie Routen-Caching. Sie müssen alle Schließungsrouten in Controller-Routen umwandeln.

Wenn Ihre Anwendung nur Controller-basiertes Routing verwendet, sollten Sie die Vorteile des Routen-Caching nutzen. Durch die Verwendung von Routen-Caching wird die zum Registrieren aller Anwendungsrouten erforderliche Zeit erheblich verkürzt. In einigen Fällen ist die Routenregistrierung sogar 100-mal schneller. Um einen Routen-Cache zu generieren, führen Sie einfach route:cache aus:

php artisan route:cache

Nachdem Sie diesen Befehl ausgeführt haben, wird die zwischengespeicherte Routendatei bei jeder Anfrage geladen. Denken Sie daran: Wenn Sie neue Routen hinzufügen, müssen Sie einen neuen Routen-Cache erstellen. Daher sollten Sie den Befehl route:cache nur während der Projektbereitstellung ausführen.

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

php artisan route:clear