Explication détaillée du processus de chargement et du principe de Facade dans Laravel

Facade est en fait un proxy statique d'une classe dans le conteneur. Il vous permet d'appeler statiquement n'importe quelle méthode de n'importe quel objet stocké dans le conteneur. Cet article vous présente principalement le processus de chargement et le principe de Facade dans Laravel. informations, les amis dans le besoin peuvent s'y référer. J'espère que cela aide tout le monde.

Avant-propos

Cet article présente principalement le contenu pertinent sur le processus et les principes de chargement de façade dans Laravel, et le partage pour votre référence et votre étude. . Pas grand chose à dire ci-dessous, jetons un œil à l’introduction détaillée.

Introduction

Les façades (prononcé : /fəˈsäd/) fournissent une interface « statique ». Vous n'avez pas besoin d'utiliser de nombreux espaces de noms ou d'instancier l'objet pour accéder aux méthodes spécifiques de l'objet.

use Config;

class Test
{
 public function index()
 {
 return Config::get('app.name');
 }
}

Démarrage et enregistrement de façade

Le démarrage de démarrage de façade est enregistré dans IlluminateFoundationBootstrapRegisterFacades.

public function bootstrap(Application $app)
{
 Facade::clearResolvedInstances();
 Facade::setFacadeApplication($app);

 AliasLoader::getInstance(array_merge(
 $app->make('config')->get('app.aliases', []),
 $app->make(PackageManifest::class)->aliases()
 ))->register();
}

La configuration d'alias par défaut est lue à partir des alias sous le fichier de configuration de l'application. PackageManifest est une nouvelle règle de découverte automatique de package dans Laravel 5.5. Ici, nous ne considérons pas les alias fournis par le package PackageManifest pour le. le moment étant.

Parmi eux, array_merge renvoie un tableau au format suivant :

 "App" => "Illuminate\Support\Facades\App"
 "Artisan" => "Illuminate\Support\Facades\Artisan"
 "Auth" => "Illuminate\Support\Facades\Auth"
 "Blade" => "Illuminate\Support\Facades\Blade"
 ...

Le code ci-dessus enregistrera toutes les façades pour un chargement automatique via AliasLoader. Le noyau est spl_autoload_register de php.

 /**
 * Prepend the load method to the auto-loader stack.
 *
 * @return void
 */
 protected function register()
 {
 if (! $this->registered) {
  spl_autoload_register([$this, 'load'], true, true);

  $this->registered = true;
 }
 }

Une fois l'enregistrement terminé, toutes les classes d'utilisation ultérieures seront automatiquement chargées via la fonction de chargement.

Remarque : Lors de la définition de spl_autoload_register ici, le dernier paramètre passé est vrai. Lorsque ce paramètre est vrai, spl_autoload_register() ajoutera la fonction en tête de la file d'attente au lieu de la queue. (Le chargement automatique est effectué en premier via cette fonction)

En d'autres termes,

<?php

use Config;
use App\User;

class Test
{
 public function index()
 {
 Config::get(&#39;app.name&#39;);
 new User();
 }
}

Peu importe ce que nous utilisons, c'est une classe existante spécifique (AppUser) ou un alias (Config ), Le chargement automatique sera d'abord effectué via la fonction de chargement. Lorsque la fonction renvoie false, le chargement automatique sera complété par d'autres fonctions de chargement automatique (telles que composer psr-4).

Dans la méthode de chargement d'AliasLoader, la fonction class_alias est principalement utilisée pour implémenter le chargement automatique des alias.

public function load($alias)
{
 if (isset($this->aliases[$alias])) {
 return class_alias($this->aliases[$alias], $alias);
 }
}

À propos de class_alias, voici un exemple officiel :

class foo { }

class_alias('foo', 'bar');

$a = new foo;
$b = new bar;

// the objects are the same
var_dump($a == $b, $a === $b); //true
var_dump($a instanceof $b); //false

// the classes are the same
var_dump($a instanceof foo); //true
var_dump($a instanceof bar); //true

var_dump($b instanceof foo); //true
var_dump($b instanceof bar); //true

Chargement de façade

Lorsque nous utilisons Facade, comme :

<?php

use Config;

class Test
{
 public function index()
 {
 Config::get(&#39;app.name&#39;);
 }
}

charge en fait la classe IlluminateSupportFacadesConfig (car nous avons enregistré class_alias), ce qui équivaut à :

<?php

use Illuminate\Support\Facades\Config;

class Test
{
 public function index()
 {
  Config::get(&#39;app.name&#39;);
 }
}

Et toutes les façades hérite de la classe IlluminateSupportFacadesFacade, et une méthode __callStatic est définie dans cette classe de base, afin que nous puissions facilement utiliser Facade (sans instanciation).

<?php

public static function __callStatic($method, $args)
{
 $instance = static::getFacadeRoot();

 if (! $instance) {
  throw new RuntimeException(&#39;A facade root has not been set.&#39;);
 }

 return $instance->$method(...$args);
}

La méthode getFacadeRoot est utilisée pour obtenir la colonne d'instance spécifique de la classe alias Nous savons que toutes les classes Facade doivent définir une méthode getFacadeAccessor. Les valeurs de retour possibles de cette méthode sont :

• String type string (tel que config, db)

• String type string-like ( tels que Tels que AppServiceSomeService)

• Objet d'instanciation spécifique à un objet

• Fermeture de fermeture

tels que La méthode getFacadeAccessor de Config Facade est la suivante :

protected static function getFacadeAccessor()
{
 return 'config';
}

La méthode getFacadeRoot récupérera l'objet colonne réel correspondant du conteneur en fonction de la valeur de retour de getFacadeAccessor() .

public static function getFacadeRoot()
{
 $name = static::getFacadeAccessor();
 
 if (is_object($name)) {
  return $name;
 }

 if (isset(static::$resolvedInstance[$name])) {
  return static::$resolvedInstance[$name];
 }

 return static::$resolvedInstance[$name] = static::$app[$name];
}

Puisque la colonne d'instance de configuration

<?php
//Illuminate\Foundation\Bootstrap/LoadConfiguration

$app->instance(&#39;config&#39;, $config = new Repository($items));

a été enregistrée dans le conteneur APP, Config::get('app.name', 'dafault) accède en fait à la méthode get('app.name', 'default') de la colonne d'instance du référentiel.

Recommandations associées :

Explication détaillée de Laravel utilisant l'authentification salt et par mot de passe en modifiant Auth

Explication détaillée du module de localisation de Laravel

Explication détaillée de la façon de réécrire le routage des ressources dans Laravel

Ce qui précède est le contenu détaillé de. pour plus d'informations, suivez d'autres articles connexes sur le site Web de PHP en chinois!