Laravel框架生命周期与原理分析

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

<?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 IlluminateFoundationApplication(
  realpath(__DIR__.'/../')
);
/*
|--------------------------------------------------------------------------
| 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(
  IlluminateContractsHttpKernel::class,
  AppHttpKernel::class
);
$app->singleton(
  IlluminateContractsConsoleKernel::class,
  AppConsoleKernel::class
);
$app->singleton(
  IlluminateContractsDebugExceptionHandler::class,
  AppExceptionsHandler::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;

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

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

/**
 * Register the core class aliases in the container.
 *
 * @return void
 */
public function registerCoreContainerAliases()
{
  $aliases = [
    'app'         => [IlluminateFoundationApplication::class, IlluminateContractsContainerContainer::class, IlluminateContractsFoundationApplication::class],
    'auth'         => [IlluminateAuthAuthManager::class, IlluminateContractsAuthFactory::class],
    'auth.driver'     => [IlluminateContractsAuthGuard::class],
    'blade.compiler'    => [IlluminateViewCompilersBladeCompiler::class],
    'cache'        => [IlluminateCacheCacheManager::class, IlluminateContractsCacheFactory::class],
    'cache.store'     => [IlluminateCacheRepository::class, IlluminateContractsCacheRepository::class],
    'config'        => [IlluminateConfigRepository::class, IlluminateContractsConfigRepository::class],
    'cookie'        => [IlluminateCookieCookieJar::class, IlluminateContractsCookieFactory::class, IlluminateContractsCookieQueueingFactory::class],
    'encrypter'      => [IlluminateEncryptionEncrypter::class, IlluminateContractsEncryptionEncrypter::class],
    'db'          => [IlluminateDatabaseDatabaseManager::class],
    'db.connection'    => [IlluminateDatabaseConnection::class, IlluminateDatabaseConnectionInterface::class],
    'events'        => [IlluminateEventsDispatcher::class, IlluminateContractsEventsDispatcher::class],
    'files'        => [IlluminateFilesystemFilesystem::class],
    'filesystem'      => [IlluminateFilesystemFilesystemManager::class, IlluminateContractsFilesystemFactory::class],
    'filesystem.disk'   => [IlluminateContractsFilesystemFilesystem::class],
    'filesystem.cloud'   => [IlluminateContractsFilesystemCloud::class],
    'hash'         => [IlluminateContractsHashingHasher::class],
    'translator'      => [IlluminateTranslationTranslator::class, IlluminateContractsTranslationTranslator::class],
    'log'         => [IlluminateLogWriter::class, IlluminateContractsLoggingLog::class, PsrLogLoggerInterface::class],
    'mailer'        => [IlluminateMailMailer::class, IlluminateContractsMailMailer::class, IlluminateContractsMailMailQueue::class],
    'auth.password'    => [IlluminateAuthPasswordsPasswordBrokerManager::class, IlluminateContractsAuthPasswordBrokerFactory::class],
    'auth.password.broker' => [IlluminateAuthPasswordsPasswordBroker::class, IlluminateContractsAuthPasswordBroker::class],
    'queue'        => [IlluminateQueueQueueManager::class, IlluminateContractsQueueFactory::class, IlluminateContractsQueueMonitor::class],
    'queue.connection'   => [IlluminateContractsQueueQueue::class],
    'queue.failer'     => [IlluminateQueueFailedFailedJobProviderInterface::class],
    'redirect'       => [IlluminateRoutingRedirector::class],
    'redis'        => [IlluminateRedisRedisManager::class, IlluminateContractsRedisFactory::class],
    'request'       => [IlluminateHttpRequest::class, SymfonyComponentHttpFoundationRequest::class],
    'router'        => [IlluminateRoutingRouter::class, IlluminateContractsRoutingRegistrar::class, IlluminateContractsRoutingBindingRegistrar::class],
    'session'       => [IlluminateSessionSessionManager::class],
    'session.store'    => [IlluminateSessionStore::class, IlluminateContractsSessionSession::class],
    'url'         => [IlluminateRoutingUrlGenerator::class, IlluminateContractsRoutingUrlGenerator::class],
    'validator'      => [IlluminateValidationFactory::class, IlluminateContractsValidationFactory::class],
    'view'         => [IlluminateViewFactory::class, IlluminateContractsViewFactory::class],
  ];
  foreach ($aliases as $key => $aliases) {
    foreach ($aliases as $alias) {
      $this->alias($key, $alias);
    }
  }
}

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

<?php
namespace AppHttp;
use IlluminateFoundationHttpKernel as HttpKernel;
class Kernel extends HttpKernel
{
  /**
   * The application's global HTTP middleware stack.
   *
   * These middleware are run during every request to your application.
   *
   * @var array
   */
  protected $middleware = [
    IlluminateFoundationHttpMiddlewareCheckForMaintenanceMode::class,
    //AppHttpMiddlewareMyMiddleware::class,
  ];
  /**
   * The application's route middleware groups.
   *
   * @var array
   */
  protected $middlewareGroups = [
    'web' => [
      AppHttpMiddlewareEncryptCookies::class,
      IlluminateCookieMiddlewareAddQueuedCookiesToResponse::class,
      IlluminateSessionMiddlewareStartSession::class,
      IlluminateViewMiddlewareShareErrorsFromSession::class,
      AppHttpMiddlewareVerifyCsrfToken::class,
    ],
    'api' => [
      'throttle:60,1',
    ],
  ];
  /**
   * The application's route middleware.
   *
   * These middleware may be assigned to groups or used individually.
   *
   * @var array
   */
  protected $routeMiddleware = [
    'auth' => AppHttpMiddlewareAuthenticate::class,
    'auth.basic' => IlluminateAuthMiddlewareAuthenticateWithBasicAuth::class,
    'guest' => AppHttpMiddlewareRedirectIfAuthenticated::class,
    'throttle' => IlluminateRoutingMiddlewareThrottleRequests::class,
  'mymiddleware'=>AppHttpMiddlewareMyMiddleware::class,
  ];
}

$response = $kernel->handle(
  $request = IlluminateHttpRequest::capture()
);
$response->send();

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