Analyse du cycle de vie et principes du framework Laravel

Cet article présente principalement le cycle de vie et les principes du framework Laravel. Il résume et analyse le cycle de fonctionnement complet, le processus et les principes du framework Laravel en réponse aux demandes des utilisateurs sous forme d'exemples. à cet article

Les exemples décrivent le cycle de vie et les principes du framework Laravel. Partagez-le avec tout le monde pour votre référence, les détails sont les suivants :

Introduction :

Si vous connaissez bien le principe d'utilisation d'un outil , alors vous êtes confiant lorsque vous utilisez cet outil !

Texte :

Une fois que l'utilisateur (navigateur) envoie une requête HTTP, notre apache ou nginx accède généralement à index.php, donc, la série d'étapes suivante commence toutes à partir de index.php. Jetons d'abord un coup d'œil au code de ce fichier.

<?php
require __DIR__.&#39;/../bootstrap/autoload.php&#39;;
$app = require_once __DIR__.&#39;/../bootstrap/app.php&#39;;
/*
|--------------------------------------------------------------------------
| Run The Application
|--------------------------------------------------------------------------
|
| Once we have the application, we can handle the incoming request
| through the kernel, and send the associated response back to
| the client&#39;s browser allowing them to enjoy the creative
| and wonderful application we have prepared for them.
|
*/
$kernel = $app->make(Illuminate\Contracts\Http\Kernel::class);
$response = $kernel->handle(
  $request = Illuminate\Http\Request::capture()
);
$response->send();
$kernel->terminate($request, $response);

L'auteur parle du rôle du noyau dans les commentaires. Le noyau gère les requêtes entrantes et renvoie les réponses correspondantes au navigateur de l'utilisateur.

Un objet application est à nouveau impliqué ici, donc l'objet application est attaché, donc le code source de l'objet application est attaché. Ce code source est bootstrapapp.php

<🎜. >

<?php
/*
|--------------------------------------------------------------------------
| Create The Application
|--------------------------------------------------------------------------
|
| The first thing we will do is create a new Laravel application instance
| which serves as the "glue" for all the components of Laravel, and is
| the IoC container for the system binding all of the various parts.
|
*/
$app = new Illuminate\Foundation\Application(
  realpath(__DIR__.&#39;/../&#39;)
);
/*
|--------------------------------------------------------------------------
| Bind Important Interfaces
|--------------------------------------------------------------------------
|
| Next, we need to bind some important interfaces into the container so
| we will be able to resolve them when needed. The kernels serve the
| incoming requests to this application from both the web and CLI.
|
*/
$app->singleton(
  Illuminate\Contracts\Http\Kernel::class,
  App\Http\Kernel::class
);
$app->singleton(
  Illuminate\Contracts\Console\Kernel::class,
  App\Console\Kernel::class
);
$app->singleton(
  Illuminate\Contracts\Debug\ExceptionHandler::class,
  App\Exceptions\Handler::class
);
/*
|--------------------------------------------------------------------------
| Return The Application
|--------------------------------------------------------------------------
|
| This script returns the application instance. The instance is given to
| the calling script so we can separate the building of the instances
| from the actual running of the application and sending responses.
|
*/
return $app;

Veuillez voir que la variable app est un objet de la classe

IlluminateFoundationApplication, donc le constructeur de cette classe est appelé. code pour ce qu'il fait exactement.

public function __construct($basePath = null)
{
  if ($basePath) {
    $this->setBasePath($basePath);
  }
  $this->registerBaseBindings();
  $this->registerBaseServiceProviders();
  $this->registerCoreContainerAliases();
}

Le constructeur fait 3 choses. Les deux premières choses sont faciles à comprendre. Créez un conteneur et enregistrez un fournisseur de services.<🎜. >

/**
 * Register the basic bindings into the container.
 *
 * @return void
 */
protected function registerBaseBindings()
{
  static::setInstance($this);
  $this->instance('app', $this);
  $this->instance(Container::class, $this);
}
/**
 * Register all of the base service providers.
 *
 * @return void
 */
protected function registerBaseServiceProviders()
{
  $this->register(new EventServiceProvider($this));
  $this->register(new LogServiceProvider($this));
  $this->register(new RoutingServiceProvider($this));
}

La dernière chose est de créer un grand tableau et de définir un grand nombre d'alias, ce qui montre que les programmeurs sont des gens intelligents et paresseux.

/**
 * Register the core class aliases in the container.
 *
 * @return void
 */
public function registerCoreContainerAliases()
{
  $aliases = [
    'app'         => [\Illuminate\Foundation\Application::class, \Illuminate\Contracts\Container\Container::class, \Illuminate\Contracts\Foundation\Application::class],
    'auth'         => [\Illuminate\Auth\AuthManager::class, \Illuminate\Contracts\Auth\Factory::class],
    'auth.driver'     => [\Illuminate\Contracts\Auth\Guard::class],
    'blade.compiler'    => [\Illuminate\View\Compilers\BladeCompiler::class],
    'cache'        => [\Illuminate\Cache\CacheManager::class, \Illuminate\Contracts\Cache\Factory::class],
    'cache.store'     => [\Illuminate\Cache\Repository::class, \Illuminate\Contracts\Cache\Repository::class],
    'config'        => [\Illuminate\Config\Repository::class, \Illuminate\Contracts\Config\Repository::class],
    'cookie'        => [\Illuminate\Cookie\CookieJar::class, \Illuminate\Contracts\Cookie\Factory::class, \Illuminate\Contracts\Cookie\QueueingFactory::class],
    'encrypter'      => [\Illuminate\Encryption\Encrypter::class, \Illuminate\Contracts\Encryption\Encrypter::class],
    'db'          => [\Illuminate\Database\DatabaseManager::class],
    'db.connection'    => [\Illuminate\Database\Connection::class, \Illuminate\Database\ConnectionInterface::class],
    'events'        => [\Illuminate\Events\Dispatcher::class, \Illuminate\Contracts\Events\Dispatcher::class],
    'files'        => [\Illuminate\Filesystem\Filesystem::class],
    'filesystem'      => [\Illuminate\Filesystem\FilesystemManager::class, \Illuminate\Contracts\Filesystem\Factory::class],
    'filesystem.disk'   => [\Illuminate\Contracts\Filesystem\Filesystem::class],
    'filesystem.cloud'   => [\Illuminate\Contracts\Filesystem\Cloud::class],
    'hash'         => [\Illuminate\Contracts\Hashing\Hasher::class],
    'translator'      => [\Illuminate\Translation\Translator::class, \Illuminate\Contracts\Translation\Translator::class],
    'log'         => [\Illuminate\Log\Writer::class, \Illuminate\Contracts\Logging\Log::class, \Psr\Log\LoggerInterface::class],
    'mailer'        => [\Illuminate\Mail\Mailer::class, \Illuminate\Contracts\Mail\Mailer::class, \Illuminate\Contracts\Mail\MailQueue::class],
    'auth.password'    => [\Illuminate\Auth\Passwords\PasswordBrokerManager::class, \Illuminate\Contracts\Auth\PasswordBrokerFactory::class],
    'auth.password.broker' => [\Illuminate\Auth\Passwords\PasswordBroker::class, \Illuminate\Contracts\Auth\PasswordBroker::class],
    'queue'        => [\Illuminate\Queue\QueueManager::class, \Illuminate\Contracts\Queue\Factory::class, \Illuminate\Contracts\Queue\Monitor::class],
    'queue.connection'   => [\Illuminate\Contracts\Queue\Queue::class],
    'queue.failer'     => [\Illuminate\Queue\Failed\FailedJobProviderInterface::class],
    'redirect'       => [\Illuminate\Routing\Redirector::class],
    'redis'        => [\Illuminate\Redis\RedisManager::class, \Illuminate\Contracts\Redis\Factory::class],
    'request'       => [\Illuminate\Http\Request::class, \Symfony\Component\HttpFoundation\Request::class],
    'router'        => [\Illuminate\Routing\Router::class, \Illuminate\Contracts\Routing\Registrar::class, \Illuminate\Contracts\Routing\BindingRegistrar::class],
    'session'       => [\Illuminate\Session\SessionManager::class],
    'session.store'    => [\Illuminate\Session\Store::class, \Illuminate\Contracts\Session\Session::class],
    'url'         => [\Illuminate\Routing\UrlGenerator::class, \Illuminate\Contracts\Routing\UrlGenerator::class],
    'validator'      => [\Illuminate\Validation\Factory::class, \Illuminate\Contracts\Validation\Factory::class],
    'view'         => [\Illuminate\View\Factory::class, \Illuminate\Contracts\View\Factory::class],
  ];
  foreach ($aliases as $key => $aliases) {
    foreach ($aliases as $alias) {
      $this->alias($key, $alias);
    }
  }
}

Une fonction instance apparaît ici. En fait, ce n'est pas une fonction de la classe Application, mais une fonction de la classe Container, la parent. classe de la classe Application

/**
 * Register an existing instance as shared in the container.
 *
 * @param string $abstract
 * @param mixed  $instance
 * @return void
 */
public function instance($abstract, $instance)
{
  $this->removeAbstractAlias($abstract);
  unset($this->aliases[$abstract]);
  // We'll check to determine if this type has been bound before, and if it has
  // we will fire the rebound callbacks registered with the container and it
  // can be updated with consuming classes that have gotten resolved here.
  $this->instances[$abstract] = $instance;
  if ($this->bound($abstract)) {
    $this->rebound($abstract);
  }
}

Application est une sous-classe de Container, donc

n'est pas seulement un objet de la classe Application, mais aussi un objet de Container, donc le nouveau

On peut vérifier la fonction singleton$app dans le fichier de code source de la classe Container. Consultez cet article de blog pour connaître la différence entre la fonction de liaison et le singleton.

singleton

Cette fonction, le premier paramètre est le nom réel de la classe, et le dernier paramètre est "l'alias" de la classe. L'objet

déclare trois objets de modèle singleton, à savoir

HttpKernel$app, ConsoleKernel et ExceptionHandler. Veuillez noter que aucun objet n'est créé ici, c'est juste une déclaration et un "alias" . Avez-vous remarqué qu'il existe également une variable $kernel dans index.php, mais que seule la variable HttpKernel produite par make est enregistrée, cet article ne discutera donc pas de ConsoleKernel et d'ExceptionHandler. . .

Continuez à trouver

AppHttpKernel.php

dans le dossier Puisque nous avons écrit toutes les choses réelles faites par HttpKernel dans ce fichier php, voyons ce qui est fait à partir de ce code.

<?php
namespace App\Http;
use Illuminate\Foundation\Http\Kernel as HttpKernel;
class Kernel extends HttpKernel
{
  /**
   * The application&#39;s global HTTP middleware stack.
   *
   * These middleware are run during every request to your application.
   *
   * @var array
   */
  protected $middleware = [
    \Illuminate\Foundation\Http\Middleware\CheckForMaintenanceMode::class,
    //\App\Http\Middleware\MyMiddleware::class,
  ];
  /**
   * The application&#39;s route middleware groups.
   *
   * @var array
   */
  protected $middlewareGroups = [
    &#39;web&#39; => [
      \App\Http\Middleware\EncryptCookies::class,
      \Illuminate\Cookie\Middleware\AddQueuedCookiesToResponse::class,
      \Illuminate\Session\Middleware\StartSession::class,
      \Illuminate\View\Middleware\ShareErrorsFromSession::class,
      \App\Http\Middleware\VerifyCsrfToken::class,
    ],
    &#39;api&#39; => [
      &#39;throttle:60,1&#39;,
    ],
  ];
  /**
   * The application&#39;s route middleware.
   *
   * These middleware may be assigned to groups or used inpidually.
   *
   * @var array
   */
  protected $routeMiddleware = [
    &#39;auth&#39; => \App\Http\Middleware\Authenticate::class,
    &#39;auth.basic&#39; => \Illuminate\Auth\Middleware\AuthenticateWithBasicAuth::class,
    &#39;guest&#39; => \App\Http\Middleware\RedirectIfAuthenticated::class,
    &#39;throttle&#39; => \Illuminate\Routing\Middleware\ThrottleRequests::class,
  &#39;mymiddleware&#39;=>\App\Http\Middleware\MyMiddleware::class,
  ];
}

Il est clair en un coup d'œil que le tableau middleware est défini dans HttpKernel.

Après ce qui doit être fait, le processus de la demande à la réponse commence, voir index.php

$response = $kernel->handle(
  $request = Illuminate\Http\Request::capture()
);
$response->send();

Enfin, il s'arrête . Libérez toutes les ressources.

/**
* Call the terminate method on any terminable middleware.
*
* @param \Illuminate\Http\Request $request
* @param \Illuminate\Http\Response $response
* @return void
*/
public function terminate($request, $response)
{
    $this->terminateMiddleware($request, $response);
    $this->app->terminate();
}

Pour résumer, un simple résumé de l'ensemble du processus est :

1.index.php chargement

bootstrapapp.php

, créez le conteneur dans le constructeur de la classe Application, enregistrez le ServiceProvider, définissez le tableau d'alias, puis utilisez la variable app pour enregistrer l'objet construit par le constructeur. 2. Utilisez l'objet app pour créer un objet en mode singleton HttpKernel. Lors de la création de HttpKernel, le constructeur est appelé pour compléter la déclaration du middleware.

3. Le travail ci-dessus est terminé avant de demander une visite. Ensuite, attendez la demande, puis :

Acceptez la demande

-->Traitez la demande -->Envoyer la réponse-->Arrêter la variable de l'applicationCe qui précède est l'intégralité du contenu de cet article, j'espère qu'il sera utile à l'apprentissage de chacun , plus connexes Veuillez faire attention au contenu du site Web chinois PHP !

Recommandations associées :

Le framework Laravel implémente l'utilisation d'un middleware pour la fonction de journalisation des opérations

Le framework Laravel implémente l'utilisation d'écouteurs pour les instructions SQL Fonction d'enregistrement

Paramètres de routage du framework 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!