Analyse des Lebenszyklus und der Prinzipien des Laravel-Frameworks

Dieser Artikel stellt hauptsächlich den Lebenszyklus und die Prinzipien des Laravel-Frameworks vor und analysiert den gesamten Betriebszyklus, den Prozess und die Prinzipien des Laravel-Frameworks als Reaktion auf Benutzeranfragen in Form von Beispielen zu diesem Artikel

Die Beispiele beschreiben den Lebenszyklus und die Prinzipien des Laravel-Frameworks. Teilen Sie es als Referenz mit allen. Die Einzelheiten lauten wie folgt:

Einführung:

Wenn Sie das Prinzip der Verwendung eines Werkzeugs gut kennen , dann sind Sie bei der Verwendung dieses Tools sicher!

Text:

Sobald der Benutzer (Browser) eine HTTP-Anfrage sendet, geht unser Apache oder Nginx normalerweise zu index.php, daher Die folgenden Schritte beginnen alle mit index.php. Schauen wir uns zunächst den Code dieser Datei an.

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

Der Autor sprach in den Kommentaren über die Rolle des Kernels. Der Kernel verarbeitet eingehende Anfragen und sendet entsprechende Antworten an den Browser des Benutzers zurück.

Hier handelt es sich wieder um ein App-Objekt, also ist das App-Objekt angehängt, also ist der Quellcode des App-Objekts angehängt. Dieser Quellcode ist 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;

Bitte beachten Sie, dass die App-Variable ein Objekt der Klasse IlluminateFoundationApplication ist, daher wird der Konstruktor dieser Klasse aufgerufen was genau es gemacht hat.

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

Der Konstruktor macht drei Dinge: Erstellen Sie einen Container und registrieren Sie einen ServiceProvider.

/**
 * 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));
}

Das Letzte ist, ein großes Array zu erstellen und eine große Anzahl von Aliasen zu definieren, was zeigt, dass Programmierer kluge, faule Leute sind.

/**
 * 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);
    }
  }
}

Hier erscheint eine Instanzfunktion. Tatsächlich handelt es sich hierbei nicht um eine Funktion der Application-Klasse, sondern um eine Funktion der Container-Klasse, der übergeordneten Klasse von die Application-Klasse

/**
 * 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 ist eine Unterklasse von Container, also ist $app nicht nur ein Objekt der Application-Klasse, sondern auch ein Objekt von Container, also das neue Singleton Wir können die Funktion in der Quellcodedatei der Container-Klasse überprüfen. In diesem Blogbeitrag erfahren Sie mehr über den Unterschied zwischen Bind-Funktion und Singleton.

SingletonBei dieser Funktion ist der erste Parameter der tatsächliche Klassenname und der zweite Parameter der „Alias“ der Klasse. Das

$app-Objekt deklariert drei Singleton-Modellobjekte, nämlich HttpKernel, ConsoleKernel und ExceptionHandler. Bitte beachten Sie, dass hier kein Objekt erstellt wird, sondern lediglich eine Deklaration und ein „Alias“ .

Ist Ihnen aufgefallen, dass es in index.php auch eine $kernel-Variable gibt, aber nur die von make erzeugte HttpKernel-Variable gespeichert wird, sodass in diesem Artikel nicht auf ConsoleKernel und ExceptionHandler eingegangen wird? . .

Suchen Sie weiterhin AppHttpKernel.php in dieser PHP-Datei. Sehen wir uns nun an, was aus diesem Code hervorgeht.

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

Es ist auf einen Blick klar, dass das Middleware-Array in HttpKernel definiert ist.

Nachdem, was getan werden muss, beginnt der Prozess von der Anfrage bis zur Antwort, siehe index.php

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

Zum Schluss alles abbrechen und freigeben Ressource.

/**
* 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();
}

Zusammenfassend lautet eine einfache Zusammenfassung des gesamten Prozesses:

1.index.php lädt bootstrapapp .php, erstellen Sie den Container im Konstruktor der Anwendungsklasse, registrieren Sie den ServiceProvider, definieren Sie das Alias-Array und verwenden Sie dann die App-Variable, um das vom Konstruktor erstellte Objekt zu speichern.

2. Verwenden Sie das App-Objekt, um ein Singleton-Modus-Objekt HttpKernel zu erstellen. Rufen Sie beim Erstellen von HttpKernel den Konstruktor auf, um die Middleware-Deklaration abzuschließen.

3. Die oben genannten Arbeiten sind abgeschlossen, bevor Sie einen Besuch anfordern. Warten Sie dann auf die Anfrage und gehen Sie dann wie folgt vor: Akzeptieren Sie die Anfrage-->Bearbeiten Sie die Anfrage -->Antwort senden-->App-Variable stoppen

Das Obige ist der gesamte Inhalt dieses Artikels. Ich hoffe, dass er zum Lernen aller beiträgt , mehr Verwandte Bitte achten Sie auf den Inhalt der chinesischen PHP-Website!

Verwandte Empfehlungen:

Das Laravel-Framework implementiert die Verwendung von Middleware für die Vorgangsprotokollierungsfunktion

Das Laravel-Framework implementiert die Verwendung von Listenern für SQL-Anweisungen Aufzeichnungsfunktion

Routing-Einstellungen des Laravel-Frameworks

Das obige ist der detaillierte Inhalt vonAnalyse des Lebenszyklus und der Prinzipien des Laravel-Frameworks. Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!