Laravel生命周期与原理

Posted 2020-11-22 Raylove

一旦用户（浏览器）发送了一个HTTP请求，我们的apache或者nginx一般都转到index.php，因此，之后的一系列步骤都是从index.php开始的，我们先来看一看这个文件代码。

<?php
require __DIR__.‘/../bootstrap/autoload.php‘;
$app = require_once __DIR__.‘/../bootstrap/app.php‘;
/*
|--------------------------------------------------------------------------
| 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‘s browser allowing them to enjoy the creative
| and wonderful application we have prepared for them.
|
*/
$kernel = $app->make(IlluminateContractsHttpKernel::class);
$response = $kernel->handle(
  $request = IlluminateHttpRequest::capture()
);
$response->send();
$kernel->terminate($request, $response);

 

这里在注释里谈了kernel的作用，kernel处理来访的请求，并且发送相应返回给用户浏览器。

这里又涉及到了一个app对象，所以附上app对象的源码，这份源码是ootstrapapp.php

 1 <?php
 2 /*
 3 |--------------------------------------------------------------------------
 4 | Create The Application
 5 |--------------------------------------------------------------------------
 6 |
 7 | The first thing we will do is create a new Laravel application instance
 8 | which serves as the "glue" for all the components of Laravel, and is
 9 | the IoC container for the system binding all of the various parts.
10 |
11 */
12 $app = new IlluminateFoundationApplication(
13   realpath(__DIR__.‘/../‘)
14 );
15 /*
16 |--------------------------------------------------------------------------
17 | Bind Important Interfaces
18 |--------------------------------------------------------------------------
19 |
20 | Next, we need to bind some important interfaces into the container so
21 | we will be able to resolve them when needed. The kernels serve the
22 | incoming requests to this application from both the web and CLI.
23 |
24 */
25 $app->singleton(
26   IlluminateContractsHttpKernel::class,
27   AppHttpKernel::class
28 );
29 $app->singleton(
30   IlluminateContractsConsoleKernel::class,
31   AppConsoleKernel::class
32 );
33 $app->singleton(
34   IlluminateContractsDebugExceptionHandler::class,
35   AppExceptionsHandler::class
36 );
37 /*
38 |--------------------------------------------------------------------------
39 | Return The Application
40 |--------------------------------------------------------------------------
41 |
42 | This script returns the application instance. The instance is given to
43 | the calling script so we can separate the building of the instances
44 | from the actual running of the application and sending responses.
45 |
46 */
47 return $app;

 

 

请看app变量是IlluminateFoundationApplication类的对象，所以调用了这个类的构造函数，具体做了什么事，我们看源码。

1 public function __construct($basePath = null)
2 {
3   if ($basePath) {
4     $this->setBasePath($basePath);
5   }
6   $this->registerBaseBindings();
7   $this->registerBaseServiceProviders();
8   $this->registerCoreContainerAliases();
9 }

 

构造器做了3件事，前两件事很好理解，创建Container，注册了ServiceProvider，看代码

 1 /**
 2  * Register the basic bindings into the container.
 3  *
 4  * @return void
 5  */
 6 protected function registerBaseBindings()
 7 {
 8   static::setInstance($this);
 9   $this->instance(‘app‘, $this);
10   $this->instance(Container::class, $this);
11 }
12 /**
13  * Register all of the base service providers.
14  *
15  * @return void
16  */
17 protected function registerBaseServiceProviders()
18 {
19   $this->register(new EventServiceProvider($this));
20   $this->register(new LogServiceProvider($this));
21   $this->register(new RoutingServiceProvider($this));
22 }

 

最后一件事，是做了个很大的数组，定义了大量的别名，侧面体现程序员是聪明的懒人。

 1 /**
 2  * Register the core class aliases in the container.
 3  *
 4  * @return void
 5  */
 6 public function registerCoreContainerAliases()
 7 {
 8   $aliases = [
 9     ‘app‘         => [IlluminateFoundationApplication::class, IlluminateContractsContainerContainer::class, IlluminateContractsFoundationApplication::class],
10     ‘auth‘         => [IlluminateAuthAuthManager::class, IlluminateContractsAuthFactory::class],
11     ‘auth.driver‘     => [IlluminateContractsAuthGuard::class],
12     ‘blade.compiler‘    => [IlluminateViewCompilersBladeCompiler::class],
13     ‘cache‘        => [IlluminateCacheCacheManager::class, IlluminateContractsCacheFactory::class],
14     ‘cache.store‘     => [IlluminateCacheRepository::class, IlluminateContractsCacheRepository::class],
15     ‘config‘        => [IlluminateConfigRepository::class, IlluminateContractsConfigRepository::class],
16     ‘cookie‘        => [IlluminateCookieCookieJar::class, IlluminateContractsCookieFactory::class, IlluminateContractsCookieQueueingFactory::class],
17     ‘encrypter‘      => [IlluminateEncryptionEncrypter::class, IlluminateContractsEncryptionEncrypter::class],
18     ‘db‘          => [IlluminateDatabaseDatabaseManager::class],
19     ‘db.connection‘    => [IlluminateDatabaseConnection::class, IlluminateDatabaseConnectionInterface::class],
20     ‘events‘        => [IlluminateEventsDispatcher::class, IlluminateContractsEventsDispatcher::class],
21     ‘files‘        => [IlluminateFilesystemFilesystem::class],
22     ‘filesystem‘      => [IlluminateFilesystemFilesystemManager::class, IlluminateContractsFilesystemFactory::class],
23     ‘filesystem.disk‘   => [IlluminateContractsFilesystemFilesystem::class],
24     ‘filesystem.cloud‘   => [IlluminateContractsFilesystemCloud::class],
25     ‘hash‘         => [IlluminateContractsHashingHasher::class],
26     ‘translator‘      => [IlluminateTranslationTranslator::class, IlluminateContractsTranslationTranslator::class],
27     ‘log‘         => [IlluminateLogWriter::class, IlluminateContractsLoggingLog::class, PsrLogLoggerInterface::class],
28     ‘mailer‘        => [IlluminateMailMailer::class, IlluminateContractsMailMailer::class, IlluminateContractsMailMailQueue::class],
29     ‘auth.password‘    => [IlluminateAuthPasswordsPasswordBrokerManager::class, IlluminateContractsAuthPasswordBrokerFactory::class],
30     ‘auth.password.broker‘ => [IlluminateAuthPasswordsPasswordBroker::class, IlluminateContractsAuthPasswordBroker::class],
31     ‘queue‘        => [IlluminateQueueQueueManager::class, IlluminateContractsQueueFactory::class, IlluminateContractsQueueMonitor::class],
32     ‘queue.connection‘   => [IlluminateContractsQueueQueue::class],
33     ‘queue.failer‘     => [IlluminateQueueFailedFailedJobProviderInterface::class],
34     ‘redirect‘       => [IlluminateRoutingRedirector::class],
35     ‘redis‘        => [IlluminateRedisRedisManager::class, IlluminateContractsRedisFactory::class],
36     ‘request‘       => [IlluminateHttpRequest::class, SymfonyComponentHttpFoundationRequest::class],
37     ‘router‘        => [IlluminateRoutingRouter::class, IlluminateContractsRoutingRegistrar::class, IlluminateContractsRoutingBindingRegistrar::class],
38     ‘session‘       => [IlluminateSessionSessionManager::class],
39     ‘session.store‘    => [IlluminateSessionStore::class, IlluminateContractsSessionSession::class],
40     ‘url‘         => [IlluminateRoutingUrlGenerator::class, IlluminateContractsRoutingUrlGenerator::class],
41     ‘validator‘      => [IlluminateValidationFactory::class, IlluminateContractsValidationFactory::class],
42     ‘view‘         => [IlluminateViewFactory::class, IlluminateContractsViewFactory::class],
43   ];
44   foreach ($aliases as $key => $aliases) {
45     foreach ($aliases as $alias) {
46       $this->alias($key, $alias);
47     }
48   }
49 }

 

 

这里出现了一个instance函数，其实这并不是Application类的函数，而是Application类的父类Container类的函数

 1 /**
 2  * Register an existing instance as shared in the container.
 3  *
 4  * @param string $abstract
 5  * @param mixed  $instance
 6  * @return void
 7  */
 8 public function instance($abstract, $instance)
 9 {
10   $this->removeAbstractAlias($abstract);
11   unset($this->aliases[$abstract]);
12   // We‘ll check to determine if this type has been bound before, and if it has
13   // we will fire the rebound callbacks registered with the container and it
14   // can be updated with consuming classes that have gotten resolved here.
15   $this->instances[$abstract] = $instance;
16   if ($this->bound($abstract)) {
17     $this->rebound($abstract);
18   }
19 }

 

Application是Container的子类，所以$app不仅是Application类的对象，还是Container的对象，所以，新出现的singleton函数我们就可以到Container类的源代码文件里查。

singleton这个函数，前一个参数是实际类名，后一个参数是类的“别名”。

$app对象声明了3个单例模型对象，分别是HttpKernel，ConsoleKernel，ExceptionHandler。请注意，这里并没有创建对象，只是声明，也只是起了一个“别名”。

 

大家有没有发现，index.php中也有一个$kernel变量，但是只保存了make出来的HttpKernel变量，因此本文不再讨论，ConsoleKernel，ExceptionHandler。。。

继续在文件夹下找到AppHttpKernel.php，既然我们把实际的HttpKernel做的事情都写在这个php文件里，就从这份代码里看看究竟做了哪些事？

 1 <?php
 2 namespace AppHttp;
 3 use IlluminateFoundationHttpKernel as HttpKernel;
 4 class Kernel extends HttpKernel
 5 {
 6   /**
 7    * The application‘s global HTTP middleware stack.
 8    *
 9    * These middleware are run during every request to your application.
10    *
11    * @var array
12    */
13   protected $middleware = [
14     IlluminateFoundationHttpMiddlewareCheckForMaintenanceMode::class,
15     //AppHttpMiddlewareMyMiddleware::class,
16   ];
17   /**
18    * The application‘s route middleware groups.
19    *
20    * @var array
21    */
22   protected $middlewareGroups = [
23     ‘web‘ => [
24       AppHttpMiddlewareEncryptCookies::class,
25       IlluminateCookieMiddlewareAddQueuedCookiesToResponse::class,
26       IlluminateSessionMiddlewareStartSession::class,
27       IlluminateViewMiddlewareShareErrorsFromSession::class,
28       AppHttpMiddlewareVerifyCsrfToken::class,
29     ],
30     ‘api‘ => [
31       ‘throttle:60,1‘,
32     ],
33   ];
34   /**
35    * The application‘s route middleware.
36    *
37    * These middleware may be assigned to groups or used individually.
38    *
39    * @var array
40    */
41   protected $routeMiddleware = [
42     ‘auth‘ => AppHttpMiddlewareAuthenticate::class,
43     ‘auth.basic‘ => IlluminateAuthMiddlewareAuthenticateWithBasicAuth::class,
44     ‘guest‘ => AppHttpMiddlewareRedirectIfAuthenticated::class,
45     ‘throttle‘ => IlluminateRoutingMiddlewareThrottleRequests::class,
46   ‘mymiddleware‘=>AppHttpMiddlewareMyMiddleware::class,
47   ];
48 }

 

 

一目了然，HttpKernel里定义了中间件数组。

该做的做完了，就开始了请求到响应的过程，见index.php

1 $response = $kernel->handle(
2   $request = IlluminateHttpRequest::capture()
3 );
4 $response->send();

 

最后在中止，释放所有资源。

 1 /**
 2 * Call the terminate method on any terminable middleware.
 3 *
 4 * @param IlluminateHttpRequest $request
 5 * @param IlluminateHttpResponse $response
 6 * @return void
 7 */
 8 public function terminate($request, $response)
 9 {
10     $this->terminateMiddleware($request, $response);
11     $this->app->terminate();
12 }

 

总结一下，简单归纳整个过程就是：

1.index.php加载ootstrapapp.php，在Application类的构造函数中创建Container，注册了ServiceProvider，定义了别名数组，然后用app变量保存构造函数构造出来的对象。

2.使用app这个对象，创建1个单例模式的对象HttpKernel，在创建HttpKernel时调用了构造函数，完成了中间件的声明。

3.以上这些工作都是在请求来访之前完成的，接下来开始等待请求，然后就是：接受到请求-->处理请求-->发送响应-->中止app变量