Zusammenfassung der Lektüre der Laravel 5-Dokumentation

Laravel 5Projektstrukturanalyse und Zusammenfassung des Lesens chinesischer Dokumente

HTTPRoute1

Middleware5

Controller5

HTTPAnfrage7

HTTP Antwort8

Ansicht9

Service Anbieter11

Service Container12

Verträge13

Fassaden14

Lebenszyklus anfordern15

Anwendungsstruktur16

Zertifizierung20

Cache24

Sammeln26

Artisan-Konsole26

Erweiterungsrahmen *27

Laravel Elixier* 27

Verschlüsselung 27

Fehler und Protokolle 28

Veranstaltung 28

Dateisystem / Cloud-Speicher30

Hash31

Hilfsmethoden31

Lokalisierung*31

Mail*31

Erweiterungspaket-Entwicklung*31

Paginierung*31

Warteschlange*31

Sitzung32

KlingeVorlage33

Einheitentest*35

Datenvalidierung35

Grundlagen der Datenbanknutzung36

Query Builder38

Struktur Generator41

Migration und Datenauffüllung41

Eloquent ORM41

HTTP-Routing

Grundlegendes Routing

definiert Routen für verschiedene Http-Methode, wie zum Beispiel:

Route::get('/', function(){

Route::post('foo/bar', function(){

Route ::match(['get', 'post'], '/', function(){ # Mehrere Methoden

Route::any('foo', function(){ # Alle Methoden

Verwenden Sie die Methode url, um URL zu generieren: $url = url('foo');

CSRF Schutz

Laravel platziert automatisch zufällige Token in der Sitzung jedes Benutzers. VerifyCsrfToken Die Middleware speichert das angeforderte und eingegebene Token im Sitzung Paar um Token zu verifizieren. Zusätzlich zur Suche nach dem CSRF-Token als Parameter „POST“ sucht die Middleware auch nach X -XSRF-TOKENAnforderungsheader.

Fügen Sie CSRF-Token in das Formular ein:

wird vom Blade Vorlagen-Engine ：

Hinzufügen zu X-XSRF-TOKEN im Request-Header:

csrf_token() }}" />

$.ajaxSetup({

Header: {

'X-CSRF-TOKEN': $('meta[name="csrf-token"]') .attr('content')

}

});

...

# Auf diese Weise alleAjax Die Anfrage enthält diese Header-Informationen:

$.ajax({

URL: "/foo/bar",

})

Methodenbetrug

< ;input type ="hidden" name="_method" value="PUT">

Routenparameter

Route: :get( 'user/{id}', function($id){ # Grundlegende Parameter

Route::get('user/{name?}', function($name = null){ # Optionale Parameter

Route::get('user/{name?}', function($ name = 'John'){ # Parameter mit Standardwerten

Sie können den globalen Modus der Parameter in der boot-Methode von RouteServiceProvider definieren:

$router->pattern('id', '[0-9]+');

wird auf alle Routen angewendet, die diesen spezifischen Parameter verwenden:

Route:: get ('user/{id}', function($id)

if ($route->input('id') == 1){ # Parameter außerhalb der Route abrufen

Sie können Parameter auch durch Abhängigkeitsinjektion erhalten:

verwende IlluminateHttpRequest;

Route::get('user/{id } ', function(Request $request, $id){

if ($Anfrage->route('id')){

Routenname

Route::get('user/profile', ['as' => 'profile' , function(){

# Routen für Controller-Aktionen angeben Name

Route::get('user/profile', [        

'as' =>

'uses' = > 'UserController@showProfile'

]);

# Benannte Routen für die Umleitung verwenden

$url = route('profile');

$redirect = redirect()-> 🎜>Route('Profil');

# Gibt den Namen der aktuellen Routenanfrage zurück

$name = Route::currentRouteName ( ; Gemeinsame Attribute als Array behandeln als Route::groupErster Parameter:

# Gemeinsame Middleware

Route::Gruppe([

'middleware'

=> ['foo', 'bar']], function()

{

Route::get('/', function() {

// Hat Foo And Bar Middleware

});

Route::get('user/profile', function()

                                                        

});

# Im obigen Beispiel sind foo

und bar die Middleware-Schlüsselnamen.

Die Zuordnungsbeziehung zwischen Schlüsselnamen und Klassennamen angepasster Middleware muss in Kernel.php hinzugefügt werden.

#

Gemeinsamer Namespace

Route::group(['namespace' => 'Admin'], function(){ // Controller im Namespace „AppHttpControllersAdmin“

Route::group(['namespace'

=> 'User'], function() {

// Controller im Namespace „AppHttpControllersAdminUser“

});

});

Subdomainnamen-Routing

Route::group(['domain' => '

{account}.myapp.com'], function()

{

Route::get('user/{id}', function($account

, $id)

{ //

});

}); 🎜>

Routing-Präfix

Route ::group(['prefix'

=> 'admin'], function()

{

Route::get('users', function()

{

// Entspricht der URL „

/admin/users

“ });

});

# Parameter im Routenpräfix definieren

Route::group([ ' prefix' => 'accounts/{account_id}'], function()

{

Route::get('detail', function(

$account_id

)

{

//

});

});

Routing Modellbindung

Modellbindung bietet eine praktische Möglichkeit, Modellentitäten in Routen einzufügen : Im Vergleich zum Injizieren Benutzer-ID können Sie auswählen, Benutzer Klassenentitäten einzufügen, die mit der angegebenen ID übereinstimmen. Definieren Sie die Modellbindung in der Methode RouteServiceProvider::boot:

public function boot(Router $ router)

{

parent::boot($router);

$router->model('user', 'AppUser');

}

Dann definieren Sie eine Route mit {user} Parametern:

Route::get('profile/{user}', function(AppUser $user){

//

});

Anfrage an Profil/1 wird ID eingefügt ist die Benutzer-Entität von 1. Wenn die Entität nicht existiert, geben Sie 404 aus. Sie können einen Abschluss als dritten Parameter übergeben, um das Verhalten zu definieren, wenn er nicht gefunden wird.

Würfe404Fehler

Zwei Methoden:

abort(404); # Im Wesentlichen , wird eine SymfonyComponentHttpKernelExceptionHttpException mit einem bestimmten Statuscode ausgelöst.

Oder: manuell HttpException auslösen

Middleware

Erstellen Sie eine neue Middleware

php artisan make:middleware OldMiddleware # Erstellen Sie eine neue Middleware

Die Hauptfunktionen der Middleware sind in der Methode handle() implementiert:

Klasse OldMiddleware {

öffentliches Funktionshandle($request, Closure $next){

if (xxx){

return redirect('xx');

}

zurück $next( $request);

}

}

Wenn wir seine Struktur analysieren, können wir feststellen, dass es im Grunde genommen eine Beurteilung durchführt und dann umleitet oder vorwärts geht.

Globale Middleware

Wenn Sie möchten, dass die Middleware von allen HTTP -Anfragen ausgeführt wird, fügen Sie einfach die Middleware-Klasse zum app/Http/Kernel hinzu. phps $middleware-Eigenschaftsliste.

Middleware der Route zuweisen

Nachdem Sie die Middleware erstellt haben, gehen Sie zu $routeMiddleware in app/Http/Kernel.php Hinzufügen Stellen Sie die Zuordnungsbeziehung zwischen dem Middleware-Schlüsselnamen und dem Klassennamen her und verwenden Sie dann diesen Schlüsselnamen in der Route, um die Route zuzuweisen:

Route::get( ' admin/profile', ['middleware' => 'auth', function(){

Terminable Middleware

Terminable Middleware muss von TerminableMiddleware erben, und Implementieren Sie die Methode terminate(), die ausgeführt werden kann, nachdem die HTTP-Antwort an den Client gesendet wurde. Die Beendigungs-Middleware benötigt zur globalen Middleware-Liste von app/Http/Kernel.php hinzugefügt werden

Controller

Basis-Controller

Alle Controller sollten die Basis-Controller-Klasse erweitern

use AppHttpControllersController;

class UserController extends Controller { # InheritsController

öffentliche Funktion showProfile($id) # Aktion

 {

AppHttpControllersController ist wie folgt definiert:

namespace BorogadiHttpControllers;

use IlluminateFoundationBusDispatchesJobs; 🎜>IlluminateRoutingController as BaseController;

verwenden Sie IlluminateFoundationValidationValidatesRequests;

abstrakte Klasse Controller erweitert

BaseController

{

 

Verwenden Sie DispatchesJobs, ValidatesRequests;

}

Es ist ersichtlich, dass es letztendlich von geerbt wird

IlluminateRoutingController Klasse.

# Benannte Controller-Route

Route::get('foo', ['uses' => 'FooController@method', 'as' => 'name']);

# zeigt auf das

URL

$url = action('AppHttpControllersFooController@method');

Oder: URL::

setRootControllerNamespace ('AppHttpControllers');

$url = action('FooController@method') ;

# Den Controller-Aktionsnamen abrufen, der ausgeführt wird

$action = Route::currentRouteAction();

Controller-Middleware

Zwei Möglichkeiten, eine besteht darin, in der Controller-Route anzugeben:

Route::get('profile', [

 

' middleware' => 'auth',

'uses' => 'UserController@showProfile' ]);

Die andere Möglichkeit besteht darin, es direkt im Controller-Konstruktor anzugeben:

Klasse UserController erweitert Controller {

öffentliche Funktion __construct(){

 

$this->middleware('auth');

 $this->middleware('log', ['only' => ['fooAction', 'barAction']]);

Impliziter Controller

Die implizite Controller-Implementierung definiert a einzelne Route zur Verarbeitung jeder Aktion im Controller:

Definieren Sie eine Route:

Route::controller('users', 'UserController');

Definieren Sie die Implementierung der Controller-Klasse:

Klasse UserController erweitert BaseController {

öffentliche Funktion getIndex(){ #

Antwort

Benutzer

öffentliche Funktion postProfile( ){ # Reagieren Sie auf Beitrag

im

Benutzer/Profil öffentliche Funktion anyLogin(){ # Reagiert auf alle Methoden von Benutzer/Anmeldung

Sie können mehrere Wortcontroller-Verhaltensweisen unterstützen, indem Sie „-“ verwenden: public function getAdminProfile() {} # Antwort auf users/admin-profile, nicht auf user/admin-profile. Beachten Sie die Kamel-Kasten-Benennungsmethode, die im Aktionsnamen

RESTfulResource Controller verwendet wird

ist eigentlich eine spezifische Anwendung des impliziten Controllers.

Routen-Cache

Wenn Ihre Anwendung nur Controller-Routing verwendet, können Sie Routen-Caching verwenden, um die Leistung zu verbessern.

php artisan route:cache

Stattdessen wird die zwischengespeicherte Routendatei verwendet app/Http/routes.phpDatei

HTTP-Anfrage

Anfrage abrufen

Zwei Möglichkeiten, eine ist durch Request-Fassade:

use Request;

$name = Request::input('name');

Oder durch Abhängigkeitsinjektion: Verwenden Sie Typhinweise für die Klasse im Konstruktor oder die Methode im Controller . Die aktuell angeforderte Instanz wird automatisch vom Service-Container eingefügt :

verwende IlluminateHttpRequest;

verwende IlluminateRoutingController;

Klasse UserController erweitert Controller {

öffentlichen Funktionsspeicher(Anfrage $request){

$name = $request->input('name');

Wenn auch Daten über den Routing-Parameter , platzieren Sie einfach die Routing-Parameter nach anderen Abhängigkeiten:

public function update(Request $request, $id){

Eingabedaten abrufen

$name = Request::input('name'); # Spezifische Eingabedaten abrufen

$name = Request::input('name', 'Sally'); # Spezifische Eingabedaten abrufen, wenn nicht, dann Holen Sie sich den Standardwert

if (Request::has('name')){ # Bestätigen Sie, ob Eingabedaten vorhanden sind

$input = Request::all (); >nur('Benutzername', 'Passwort'); # Teil der Eingabedaten abrufen

$input = Request::exclusive('credit_card'); # Methode zum teilweisen Ausschluss von Eingabedaten abrufen

$input = Request::input('products.0.name'); 🎜># Daten in Array-Form abrufen

Alte Eingabedaten Anfrage::

flash

();

#

Speichern Sie die aktuellen Eingabedaten in Sitzung 中

Anfrage::FlashOnly('Benutzername', 'E-Mail') ; # Einige Daten in Sitzung

speichern Anfrage:: flashExcept('password'); # Teil der Daten als Sitzung, Eliminierungsmethode

Return Redirect('form')->withInput(); # leitet die aktuellen Eingabedaten zur Sitzung

um

Return Redirect('form')->withInput(Request::exclusive('password')); >Einen Teil der im aktuellen Zeitraum eingegebenen Daten in Sitzung$username = Request::

alt

('Benutzername'); # Holen Sie sich die einmalige Sitzung{{ old('username') }}

#

wird in der Vorlage Blade Alt angezeigt Eingabedaten

Cookies

Laravel Das von Laravel erstellte

Cookie wird verschlüsselt und authentifiziert. $value =

Request::cookie

('name'); 🎜># GetCookieWert

#

Cookies zur Antwort hinzufügen

$response = new IlluminateHttpResponse('Hello World' );

$response->withCookie

(cookie('name', 'value', $ Minuten));

$response->

withCookie

(cookie()->forever('name', 'value'));

# Ein dauerhaft gültiges Cookie hinzufügen

#

Cookie

im Warteschlangenmodus hinzufügen, d. h. im tatsächlichen Set CookieCookie::queue('name', 'value' bevor die Antwort gesendet wird);

Rückantwort('Hello World');

Datei hochladen

$file = Request::file('photo'); Hochgeladene Datei abrufen

if (Request::hasFile('photo')) # Bestätigen Sie, ob die Datei hochgeladen wurde

if (Request::file('photo')->isValid()) # Bestätigen Sie, ob die hochgeladene Datei gültig ist

Request::file('photo')->move($destinationPath); # Die hochgeladene Datei verschieben

Request::file('photo')->move($destinationPath, $fileName); # Die hochgeladene Datei verschieben und umbenennen

Weitere Anfrageinformationen

$uri = Anfrage: :path(); # Anfrage abrufen

URI

if (Request:: ajax()) # Bestimmen Sie, ob eine Anfrage

AJAX

verwendet #

Methode zur Ermittlung der Anfrage

$method = Anfrage: :method();

if (Request::isMethod('post'))

if (Request::is('admin/*'))

# Bestätigen Sie, ob der Anforderungspfad einem bestimmten Format entspricht

$url = Request::url(); # Anfrage abrufen

URL

HTTP-Antwort

Grundlegende Antwort

Route::get('/', function(){ # Return string

return 'Hello World';

#

Gibt die vollständigen

Antworten

zurück. Beispielsweise gibt es zwei Methoden

return AntwortenObjekt:

use IlluminateHttpResponse;

return ( new Response($content, $status))

         –> ;header ('Content-Type', $value);

oder verwenden Sie die Antwort Hilfsmethode:

Rückgabe Antwort($content, $status)->header('Content-Type', $value);

# Zurück zur Ansicht

return Response()->view('hello')->header('Content-Type', $type);

# HinzufügenCookies

return Response($content)->withCookie(cookie('name', 'value'));

Weiterleiten

zurück redirect('user/login'); # Verwenden Sie die redirectredirect-Methode

Return Redirect('user/login')->with('message', 'Login Failed'); Aktuelle Daten umleiten und speichern in Sitzung

return weitergeleitet()->

zurück(); Return Redirect()->Route('login'); # Weiterleiten zu a bestimmte Route

# Weiterleitung zu einer bestimmten Route mit Parametern

return restart()->route('profile', [1]); # Routen

URI ist: profile/{id}

return weitergeleitet()-> route('profile', [' user' => 1]); # Der geroutete URI ist: Profil/{Benutzer}

# Umleitung basierend auf Controller-Aktion

Return Redirect()->

Aktion

('AppHttpControllersHomeController@index');

return restart()->action('AppHttpControllersUserController@profile', ['user' => 1]);

#

mit Parametern

Andere Antworten# return

json

return Response()->

json

(['name' => 'Abigail', 'state' => 'CA']);

# Rückgabeantwort()->json([' name' => 'Abigail', 'state' => 'CA']) - ->

setCallback($request->input('callback'));

#

Datei-Download

return Response()->download($pathToFile, $name, $headers);

Antwortmakro

# Antwortmakros definieren werden normalerweise in der Boot

-Methode von

Anbieter

Antwort::makro

(

'caps' , function($value)

use

($response){ # PHPStandardmäßig können anonyme Funktionen die Kontextvariablen des nicht aufrufen Codeblock, in dem sie sich befinden, müssen jedoch das Schlüsselzeichen verwenden verwenden. use kopiert eine Variable in den Abschluss und unterstützt auch Referenzformen wie use ( &$rmb )

 return $response->make(strtoupper($value)); }); # Anrufantwortmakro

return Response()->Caps('foo');

Ansicht

Grundansicht

# Pfad und Dateiname der Ansichtsdefinitionsdatei: resources/views/greeting.php

 

           

Hallo, name; ?>

# Anruf ansehen

Route::get( '/', function()

{

return view(

'greeting', [

'name'

=> 'James']); # Pass Der Parameter der Ansicht ist ein Array von Schlüssel-Wert-Paaren

}); # Aufruf der Unterordneransicht Definitionsort:

Ressourcen/Ansichten/ admin/profile.php

return view('

admin.profile', $data);

# Andere Möglichkeiten, Daten an die Ansicht zu übergeben

$view = view('greeting')->

with

('name', 'Victoria');

# Traditionelle Methode

$view = view('greeting')->withName('Victoria '); # Magische Methode

$view = view('greetings ', $data); # Übergeben Sie das Array direkt $data ist ein Array von Schlüssel-Wert-Paaren

# Daten für alle Ansichten teilen

Passen Sie einen

Anbieter an oder fügen Sie ihn direkt im

BootAppServiceProvider

hinzu > Methode:

view()->share('data', [1, 2, 3]) ; Oder:

Ansehen::teilen( 'data', [1, 2, 3 ]);

#

Bestätigen Sie, ob die Ansicht existiert

if (view()->

exists('emails.customer' ))

# Ansicht aus einem Dateipfad generierenreturn view()->

file($pathToFile, $data);

View-KomponenteView-Komponente ist eine Abschluss- oder Klassenmethode das aufgerufen wird, bevor die Ansicht gerendert wird.

# Ansichtskomponente definieren

use View;use IlluminateSupportServiceProvider;

class ComposerServiceProvider erweitert ServiceProvider {

public function boot(){

View::

composer ('profile', 'AppHttpViewComposersProfileComposer'); #

Verwenden Sie Klassen, um Ansichtskomponenten anzugeben

Ansicht:: composer('dashboard', function($view){ # Verwenden Sie Abschlüsse, um Ansichtskomponenten anzugeben

... }); }

...

}

Verwenden Sie eine Klasse, um eine Ansichtskomponente anzugeben. Die Methode mit dem Namen

compose

der angegebenen Klasse wird aufgerufen, bevor die Ansicht gerendert wird. Wie im obigen Beispiel ist die Klasse ProfileComposer'

wie folgt definiert:

verwende IlluminateContractsViewView;

verwende IlluminateUsersRepository als UserRepository;

Klasse ProfileComposer {

protected $users;

öffentliche Funktion __construct(UserRepository $users){ # Service-Container analysiert automatisch die erforderlichen Parameter

<🎜 > >

öffentliche Funktion

compose

(View $view){ # compose Methode wird in einer Instanz von

View übergeben, wobei Parameter können an View

       $view->with('count', $this->users) übergeben werden ->count()); }}

# in view Verwenden Sie Platzhalter innerhalb der Komponente

View::composer('*', function($view){

# Entspricht der Definition aller Ansichten

# Ansichten gleichzeitig an mehrere Ansichten anhängen Komponente

View::composer(['profile', 'dashboard'], 'AppHttpViewComposersMyViewComposer');

#

Mehrere Ansichtskomponenten definieren

View::composers([

'AppHttpViewComposersAdminComposer' => => 'user',

'AppHttpViewComposersProductComposer' => ; 'product '

]);

Dienstleister

Jeder benutzerdefinierte Anbieter

muss von IlluminateSupport

ServiceProvider

und AnbieterArray

in

config/app.php Registrieren Sie sich in

. Der benutzerdefinierte Anbieter muss die

register()-Methode definieren, die zur Definition des Verhaltens bei der Registrierung verwendet wird. Darüber hinaus gibt es zwei optionale Methoden und ein optionales Attribut: boot()Methode in allen Provider Es wird sein wird nach dem Laden aufgerufen und die Methode provides() wird mit dem optionalen Attribut $defer arbeitet zusammen, um die Pufferfunktion bereitzustellen. Die Idee, Dienste über Dienstanbieter bereitzustellen: Implementieren Sie eine Klasse, die die eigentliche Arbeit abschließt, und definieren Sie einen Anbieter , und in der Methode register() von Provider die tatsächliche Arbeitsklasse beim Systemcontainer registrieren und die tatsächliche Arbeitsklasse abrufen Beispiel. Dann registrieren Sie diesen Anbieter in der Anwendungskonfiguration. Auf diese Weise wird bei der Initialisierung der Anwendung die Methode register() aller Provider aufgerufen, um indirekt einen Weg zu registrieren um die tatsächliche Instanz der Arbeiterklasse zu erhalten.

# Definieren Sie einen grundlegenden Anbieter use RiakConnection;

use IlluminateSupportServiceProvider;

Klasse RiakServiceProvider erweitert ServiceProvider {

öffentliche Funktion register

(){

#

Methoden zum Registrieren einer Klasse in einem Container und zum Abrufen ihrer Instanz

$this->app- >

Singleton

('RiakContractsConnection', function($app){

['config'][ 'riak']);

});

}

}

Servicecontainer

Grundlegende Verwendung

Im Anbieter können Sie $this->app, um auf den Service-Container zuzugreifen.

Es gibt zwei Hauptmethoden zum Registrieren von Abhängigkeiten: Callback-Schnittstellenmethode und Bindungsinstanzschnittstelle.

# Geschlossene Rückrufmethode

$this->app->bind('FooBar', function($app){

neue FooBar zurückgeben ($app['SomethingElse']);

});

# Registrieren Sie sich als Singleton, und nachfolgende Aufrufe geben dieselbe Instanz zurück

$ this->app->singleton('FooBar', function($app){

return new FooBar($app['SomethingElse ']) ;

});

# An eine vorhandene Instanz binden

$fooBar = new FooBar(new SomethingElse);

$this->app->instance('FooBar', $fooBar);

Es gibt zwei Möglichkeiten, Instanzen aus dem Container aufzulösen:

$fooBar = $this-> ;app-> make('FooBar'); # Verwenden Sie die Methode make() zum Parsen von

$fooBar = $this->app['FooBar']; # Weil der Container ArrayAccess implementiert Schnittstelle, sodass Sie das Array-Zugriffsformular verwenden können

Nach der Definition Mit den Registrierungs- und Analyseinformationen können Sie die erforderlichen Abhängigkeiten im Konstruktor der Klasse über type-hint direkt angeben, und der -Container fügt automatisch alle erforderlichen Abhängigkeiten ein Abhängigkeiten .

IlluminateRoutingController verwenden;

AppUsersRepository als UserRepository verwenden;

Klasse UserController erweitert Controller {

protected $users;

public function __construct(UserRepository $users){ # type-hint

        $this->users = $users;

                                                                                                             🎜> öffentliche Veranstaltung ($id){

}

}

Gebundene Schnittstelle

Schnittstelle EventPusher {

öffentliche Funktion push($event , array $data);

}

Klasse

PusherEventPusher implementiert

EventPusher {...

}

weilPusherEventPusher Die -Klasse implementiert den

EventPusher

Schnittstelle, sodass Sie diese Schnittstelle direkt registrieren und an eine Klasse binden können, die diese Schnittstelle implementiert: $this->app- >bind('AppContractsEventPusher', 'AppServicesPusherEventPusher');

Wenn eine Klasse das EventPusher Schnittstelle, teilt sie dem Container mit, dass er PusherEventPusher

injizieren soll. Kontextbindung

$this->app->

when('AppHandlersCommandsCreateOrderHandler')

- & gt; tag

$this->app->bind('SpeedReport', function(){

});

$this-> app->bind('MemoryReport' , function(){

});

$this->app->tag(['SpeedReport', 'MemoryReport'], 'reports');

# Geben Sie die in den beiden vorherigen Schritten registrierten Kurse in einen Tag „

Berichte“ ein

Sobald Dienste markiert sind, können sie einfach über die Methode tagged analysiert werden:

$this-> app->bind('ReportAggregator', function($app){ return new ReportAggregator( $app->tagged ('reports'));

});

Containerereignisse

Der Container wird ausgelöst ein Ereignis beim Parsen jedes Objekts. Sie können die Methode

resolving

verwenden, um auf dieses Ereignis zu warten (das analysierte Objekt wird an die Abschlussmethode übergeben): $this->app->resolving(function($object, $app){

# Wird aufgerufen, wenn der Container irgendeine Art von Abhängigkeit auflöst

...

});

$this->app->resolving(function(FooBar $fooBar, $app){ # Wenn der Container aufgelöst wird

'FooBar' wird aufgerufen, wenn Abhängigkeiten vom Typ

...

});

Verträge

Verträge

ist die Schnittstelle, die von allen Laravel Hauptkomponenten verwendet wird, siehe

Die Verzeichnisstruktur im Verzeichnis

Contracts ist dieselbe wie die in Illuminate

. Contracts ist die Schnittstellendefinition und

Illuminate ist die spezifische Implementierung. Jede konkret implementierte Klasse in

Illuminate erweitert ihre entsprechende Schnittstelle in Contracts

. Diese Trennung von Schnittstelle und Implementierung kann dazu führen, dass die Abhängigkeitsinjektion weniger gekoppelt ist . /laravel/framework/src

/Illuminate

/Auth

/Rundfunk

/Bus

...

/Verträge

/Auth

/Rundfunk

/Bus

...

FassadenGrundlegende Verwendung

FassadenStellen Sie eine statische Schnittstelle bereit gibt Klassen an, die im -Dienstcontainer der Anwendung verfügbar sind. (Eine Anwendung des „Dekorationsmodus“ im Designmodus verwendet hauptsächlich class_alias

, um einen Klassennamen zu erstellen, und verwendet außerdem __callStatic()

, um einen bereitzustellen Statischer Proxy, der letztendlich das PHP-Objekt simuliert und die Methode des Objekts aufruft)

Laravels Fassaden und alle benutzerdefinierten Fassaden, die Sie erstellen, erben von der Basisklasse Facade und muss nur eine Methode implementieren: getFacadeAccessor().

wie CachediesFassadeAufruf: $value = Cache::get('key');

Sehen Sie sich die Implementierung der Klasse an:

Klasse Cache extends Facade {

protected static function getFacadeAccessor() { return 'cache' } # Die Funktion dieser Methode besteht darin, den Namen der Service-Container-Bindung zurückzugeben

}

Wenn der Benutzer eine statische Methode auf der Fassade von Cache ausführt, Laravel löst den gebundenen Cache aus dem Service-Container auf und führt die angeforderte Methode aus das Objekt (In diesem Beispiel get)

Alle Fassaden existieren im globalen Namespace. Bei Verwendung in einem verschachtelten Namespace muss die Klasse Fassade importiert werden.

use Cache # importCache-Fassade

Klasse PhotosController erweitert Controller {

public function index(){

$photos = Cache::get('photos' ; 🎜>