1// routes/web.php
2Route::get('/hello', function (Request $request) {
3// Hello Laravel from hello
4return "Hello Laravel from {$request->path()}";
5});

1// routes/web.php
2Route::get('/hello', function (Request $request) {
3// Hello Laravel from hello
4return "Hello Laravel from {$request->path()}";
5});

1namespace Illuminate\Hashing;
2
3use Illuminate\Contracts\Support\DeferrableProvider;
4use Illuminate\Support\ServiceProvider;
5
6class HashServiceProvider extends ServiceProvider implements DeferrableProvider
7{
8    // register()にて、機能を実現するのに必要なオブジェクトを設定
9    /*
10     * Register the service provider.
11     *
12     * @return void
13     */
14    public function register()
15    {
16        // Service Containerに指示
17        // hashという名前のオブジェクトが要求されたら、HashManagerオブジェクトをつくって渡す
18        $this->app->singleton('hash', function ($app) {
19            return new HashManager($app);
20        });
21
22        $this->app->singleton('hash.driver', function ($app) {
23            return $app['hash']->driver();
24        });
25    }
26    // 中略...
27}

1// public/index.php
2/*
3|-----------------------------------------------------------------------
4| Register The Auto Loader 
5|-----------------------------------------------------------------------
6| 
7| Composer provides a convenient, automatically generated class loader for 
8| this application. We just need to utilize it! We'll simply require it 
9| into the script here so we don't need to manually load our classes. 
10| 
11*/ 
12require __DIR__.'/../vendor/autoload.php';

1/*
2|-----------------------------------------------------------------------
3| Run The Application 
4|-----------------------------------------------------------------------
5| 
6| Once we have the application, we can handle the incoming request using 
7| the application's HTTP kernel. Then, we will send the response back 
8| to this client's browser, allowing them to enjoy our application.
9| 
10*/ 
11$app = require_once __DIR__.'/../bootstrap/app.php';

1// bootstrap/app.php
2
3/*
4|-----------------------------------------------------------------------
5| Create The Application 
6|-----------------------------------------------------------------------
7| 
8| The first thing we will do is create a new Laravel application instance 
9| which serves as the "glue" for all the components of Laravel, and is 
10| the IoC container for the system binding all of the various parts. 
11| 
12*/ 
13$app = new Illuminate\Foundation\Application( $_ENV['APP_BASE_PATH'] ?? dirname(__DIR__) );

1// Illuminate/Foundation/Application.php
2class Application extends Container implements ApplicationContract, CachesConfiguration, CachesRoutes, HttpKernelInterface
3{
4    use Macroable;
5    
6    // 中略...
7
8    /*
9     * Create a new Illuminate application instance.
10     *
11     * @param  string|null  $basePath
12     * @return void
13     */
14    public function __construct($basePath = null)
15    {
16        // 中略...
17
18        $this->registerBaseBindings();
19        $this->registerBaseServiceProviders();
20        $this->registerCoreContainerAliases();
21    }
22    // 中略...
23}

1// bootstrap/app.php
2// これまで見てきたService Container生成処理
3$app = new Illuminate\Foundation\Application(
4    $_ENV['APP_BASE_PATH'] ?? dirname(__DIR__)
5);
6
7// 中略...
8// Service Containerを呼び出しているっぽい処理
9$app->singleton(
10    Illuminate\Contracts\Http\Kernel::class,
11    App\Http\Kernel::class
12);
13
14// 中略...
15/*
16|-----------------------------------------------------------------------
17| Return The Application
18|-----------------------------------------------------------------------
19| | 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. 
20| 
21*/
22 
23return $app;

1// public/index.php
2use Illuminate\Contracts\Http\Kernel;
3
4// 中略...
5$app = require_once __DIR__.'/../bootstrap/app.php';
6
7// Service Containerからオブジェクトを取り出しているっぽい処理
8$kernel = $app->make(Kernel::class);

1// オブジェクトをどうやって用意するのか規定
2$app->singleton(
3    Illuminate\Contracts\Http\Kernel::class,
4    App\Http\Kernel::class
5);
6// Service Containerからオブジェクトを取り出す
7// ここでのKernelは、Illuminate\Contracts\Http\Kernel Interfaceを指す
8$kernel = $app->make(Kernel::class);

1// なんちゃってService Container
2class ServiceContainer
3{
4    // オブジェクトのつくり方を格納
5    private array bindings[];
6    
7    // オブジェクトのつくり方を決める
8    public function set(string $abstract, string $concrete)
9    {
10        // キーに抽象的なクラス名を設定しておくことで、あとからキーでオブジェクトが取り出せるようになる
11        $this->bindings[$abstract] = $concrete;
12    }
13    
14    // つくり方に従い、オブジェクトを用意して返却
15    public function get(string $abstract)
16    {
17        return new $this->bindings[$abstract];
18    }
19}
20
21$app = new ServiceContainer();
22// KernelInterfaceという名前のオブジェクトを要求されたら、具体的なクラスからオブジェクトをつくって返すよう指示
23$app->set(KernelInteface::class, Kernel::class);
24// 要求をもとにオブジェクトを生成して返却
25$kernel = $app->get(KernelInterface::class);
26
27// 得られたオブジェクトでアプリケーションの処理を実行
28$kernel->handle();

1// bootstrap/app.php
2$app->singleton(
3    Illuminate\Contracts\Http\Kernel::class,
4    App\Http\Kernel::class
5);

1// Illuminate/Container/Container.php
2
3/*
4 * Register a shared binding in the container.
5 *
6 * @param  string  $abstract
7 * @param  \Closure|string|null  $concrete
8 * @return void
9 */
10public function singleton($abstract, $concrete = null)
11{
12    $this->bind($abstract, $concrete, true);
13}

1/*
2 * Register a binding with the container.
3 *
4 * @param  string  $abstract
5 * @param  \Closure|string|null  $concrete
6 * @param  bool  $shared
7 * @return void
8 *
9 * @throws \TypeError
10 */
11public function bind($abstract, $concrete = null, $shared = false)
12{
13    // 中略...
14    
15    // オブジェクトのつくり方が決まっていない場合、デフォルトの生成方法を取得
16    // If the factory is not a Closure, it means it is just a class name which is
17    // bound into this container to the abstract type and we will just wrap it
18    // up inside its own Closure to give us more convenience when extending.
19    if (! $concrete instanceof Closure) {
20        if (! is_string($concrete)) {
21            throw new TypeError(self::class.'::bind(): Argument #2 ($concrete) must be of type Closure|string|null');
22        }
23
24        $concrete = $this->getClosure($abstract, $concrete);
25    }
26
27    // オブジェクトの生成方法をbindingsプロパティへ保存しておく
28    $this->bindings[$abstract] = compact('concrete', 'shared');
29    
30    // 中略...
31}

1/*
2 * Get the Closure to be used when building a type.
3 *
4 * @param  string  $abstract
5 * @param  string  $concrete
6 * @return \Closure
7 */
8protected function getClosure($abstract, $concrete)
9{
10    // Container::resolve()を呼び出していると理解しておけばOK
11    return function ($container, $parameters = []) use ($abstract, $concrete) {
12        if ($abstract == $concrete) {
13            return $container->build($concrete);
14        }
15
16        return $container->resolve(
17            $concrete, $parameters, $raiseEvents = false
18        );
19    };
20}

1// オブジェクトの生成方法をbindingsプロパティへ保存しておく
2$this->bindings[$abstract] = compact('concrete', 'shared');

1$bindings = [
2    'Illuminate\Contracts\Http\Kernel::class' => [
3        'concrete' => 'Container::resolve()を呼び出すClosure',
4        'shared' => true
5    ]
6];

1// public/index.php
2$kernel = $app->make(Kernel::class);

1// Illuminate/Container/Container.php
2
3/*
4 * Resolve the given type from the container.
5 *
6 * @param  string|callable  $abstract
7 * @param  array  $parameters
8 * @return mixed
9 *
10 * @throws \Illuminate\Contracts\Container\BindingResolutionException
11 */
12public function make($abstract, array $parameters = [])
13{
14    return $this->resolve($abstract, $parameters);
15}

1/*
2 * Resolve the given type from the container.
3 *
4 * @param  string|callable  $abstract
5 * @param  array  $parameters
6 * @param  bool  $raiseEvents
7 * @return mixed
8 *
9 * @throws \Illuminate\Contracts\Container\BindingResolutionException
10 * @throws \Illuminate\Contracts\Container\CircularDependencyException
11 */
12protected function resolve($abstract, $parameters = [], $raiseEvents = true)
13{
14    // オブジェクトのつくり方を表すconcrete変数を設定
15    // 中略...
16    $concrete = $this->getContextualConcrete($abstract);
17    // 中略...
18    if (is_null($concrete)) {
19        $concrete = $this->getConcrete($abstract);
20    }
21
22    // concrete変数をもとにオブジェクトを生成
23    // We're ready to instantiate an instance of the concrete type registered for
24    // the binding. This will instantiate the types, as well as resolve any of
25    // its "nested" dependencies recursively until all have gotten resolved.
26    if ($this->isBuildable($concrete, $abstract)) {
27        $object = $this->build($concrete);
28    } else {
29        $object = $this->make($concrete);
30    }
31    
32    // Container::singleton()経由でオブジェクトをつくった場合、1つのオブジェクトを全体で共有できるよう設定
33    // If the requested type is registered as a singleton we'll want to cache off
34    // the instances in "memory" so we can return it later without creating an
35    // entirely new instance of an object on each subsequent request for it.
36    if ($this->isShared($abstract) && ! $needsContextualBuild) {
37        $this->instances[$abstract] = $object;
38    }
39    // 中略
40    
41    return $object;
42}

1/*
2 * Get the concrete type for a given abstract.
3 *
4 * @param  string|callable  $abstract
5 * @return mixed
6 */
7protected function getConcrete($abstract)
8{
9    // If we don't have a registered resolver or concrete for the type, we'll just
10    // assume each type is a concrete name and will attempt to resolve it as is
11    // since the container should be able to resolve concretes automatically.
12    if (isset($this->bindings[$abstract])) {
13        return $this->bindings[$abstract]['concrete'];
14    }
15
16    return $abstract;
17}

1// concreteはオブジェクトを生成するためのClosure
2// abstractはつくりたいオブジェクトと対応するクラス名を表す
3
4// We're ready to instantiate an instance of the concrete type registered for
5// the binding. This will instantiate the types, as well as resolve any of
6// its "nested" dependencies recursively until all have gotten resolved.
7if ($this->isBuildable($concrete, $abstract)) {
8    $object = $this->build($concrete);
9} else {
10    $object = $this->make($concrete);
11}

1/*
2 * Determine if the given concrete is buildable.
3 *
4 * @param  mixed  $concrete
5 * @param  string  $abstract
6 * @return bool
7 */
8protected function isBuildable($concrete, $abstract)
9{
10    return $concrete === $abstract || $concrete instanceof Closure;
11}

1/*
2 * Instantiate a concrete instance of the given type.
3 *
4 * @param  \Closure|string  $concrete
5 * @return mixed
6 *
7 * @throws \Illuminate\Contracts\Container\BindingResolutionException
8 * @throws \Illuminate\Contracts\Container\CircularDependencyException
9 */
10public function build($concrete)
11{
12    // If the concrete type is actually a Closure, we will just execute it and
13    // hand back the results of the functions, which allows functions to be
14    // used as resolvers for more fine-tuned resolution of these objects.
15    if ($concrete instanceof Closure) {
16        return $concrete($this, $this->getLastParameterOverride());
17    }
18    // 中略
19}

1// abstractはIlluminate\Contracts\Http\Kernel::class
2// concreteはApp\Http\Kernel::class
3protected function getClosure($abstract, $concrete)
4{
5    return function ($container, $parameters = []) use ($abstract, $concrete) {
6        // 中略
7        // ここでのconcreteは、クラス名App\Http\Kernel
8        return $container->resolve(
9            $concrete, $parameters, $raiseEvents = false
10        );
11    };
12}

1protected function getConcrete($abstract)
2{
3    // If we don't have a registered resolver or concrete for the type, we'll just
4    // assume each type is a concrete name and will attempt to resolve it as is
5    // since the container should be able to resolve concretes automatically.
6    if (isset($this->bindings[$abstract])) {
7        return $this->bindings[$abstract]['concrete'];
8    }
9
10    return $abstract;
11}

1// Container::resolve()の一部
2
3// concreteは文字列App\Console\Kernelとなる
4if (is_null($concrete)) {
5    $concrete = $this->getConcrete($abstract);
6}
7
8// Container::isBuildable()は、concreteとabstractが同一でもtrueを返す
9// よって、文字列App\Console\Kernelを引数にContainer::build()が呼ばれる
10// We're ready to instantiate an instance of the concrete type registered for
11// the binding. This will instantiate the types, as well as resolve any of
12// its "nested" dependencies recursively until all have gotten resolved.
13if ($this->isBuildable($concrete, $abstract)) {
14    $object = $this->build($concrete);
15} else {
16    $object = $this->make($concrete);
17}

1// abstractはIlluminate\Contracts\Http\Kernel::class
2// concreteはApp\Http\Kernel::class
3protected function getClosure($abstract, $concrete)
4{
5    return function ($container, $parameters = []) use ($abstract, $concrete) {
6        // 中略
7        // ここでのconcreteは、クラス名App\Http\Kernel
8        return $container->build($concrete);
9    };
10}

1// Container::bind()を抜粋
2
3// If the factory is not a Closure, it means it is just a class name which is
4// bound into this container to the abstract type and we will just wrap it
5// up inside its own Closure to give us more convenience when extending.
6
7// 変数concreteがClosureでないなら、それは抽象型に対する具象型である。
8// 「extending」にて利便性を確保するために、Closureで包んでおく
9if (! $concrete instanceof Closure) {
10    if (! is_string($concrete)) {
11        throw new TypeError(self::class.'::bind(): Argument #2 ($concrete) must be of type Closure|string|null');
12    }
13
14    $concrete = $this->getClosure($abstract, $concrete);
15}

1// Container::resolve()を抜粋
2
3// 既存のオブジェクトを得る
4// We're ready to instantiate an instance of the concrete type registered for
5// the binding. This will instantiate the types, as well as resolve any of
6// its "nested" dependencies recursively until all have gotten resolved.
7if ($this->isBuildable($concrete, $abstract)) {
8    $object = $this->build($concrete);
9} else {
10    $object = $this->make($concrete);
11}
12
13// 既存のオブジェクトを引数に、拡張したオブジェクト生成処理(Closure)を呼び出す
14// If we defined any extenders for this type, we'll need to spin through them
15// and apply them to the object being built. This allows for the extension
16// of services, such as changing configuration or decorating the object.
17foreach ($this->getExtenders($abstract) as $extender) {
18    $object = $extender($object, $this);
19}

1/*
2 * Instantiate a concrete instance of the given type.
3 *
4 * @param  \Closure|string  $concrete
5 * @return mixed
6 *
7 * @throws \Illuminate\Contracts\Container\BindingResolutionException
8 * @throws \Illuminate\Contracts\Container\CircularDependencyException
9 */
10public function build($concrete)
11{
12    // concreteは文字列「App\Console\Kernel」
13    // 文字列で動的にクラスを操作するReflectionと呼ばれる仕組みを使えるようにする
14    try {
15        $reflector = new ReflectionClass($concrete);
16    } catch (ReflectionException $e) {
17        throw new BindingResolutionException("Target class [$concrete] does not exist.", 0, $e);
18    }
19
20    // 対象のクラスのコンストラクタを取得
21    $constructor = $reflector->getConstructor();
22
23    // コンストラクタが無いのであれば、シンプルにオブジェクトをつくって返却
24    // If there are no constructors, that means there are no dependencies then
25    // we can just resolve the instances of the objects right away, without
26    // resolving any other types or dependencies out of these containers.
27    if (is_null($constructor)) {
28        array_pop($this->buildStack);
29
30        return new $concrete;
31    }
32
33    // コンストラクタの引数を解決
34    // 引数がクラスであれば再帰的に解決
35    $dependencies = $constructor->getParameters();
36
37    // Once we have all the constructor's parameters we can create each of the
38    // dependency instances and then use the reflection instances to make a
39    // new instance of this class, injecting the created dependencies in.
40    try {
41        $instances = $this->resolveDependencies($dependencies);
42    } catch (BindingResolutionException $e) {
43        array_pop($this->buildStack);
44
45        throw $e;
46    }
47
48    // 最終的に、コンストラクタを引数つきで呼び出し、得られたオブジェクトを返却
49    return $reflector->newInstanceArgs($instances);
50}

1// Container::resolve()抜粋
2
3// concrete変数をもとにオブジェクトを生成
4// 変数$objectにつくられたオブジェクトが格納される
5// We're ready to instantiate an instance of the concrete type registered for
6// the binding. This will instantiate the types, as well as resolve any of
7// its "nested" dependencies recursively until all have gotten resolved.
8if ($this->isBuildable($concrete, $abstract)) {
9    $object = $this->build($concrete);
10} else {
11    $object = $this->make($concrete);
12}
13
14// Container::singleton()経由でオブジェクトをつくった場合、1つのオブジェクトを全体で共有できるよう設定
15// If the requested type is registered as a singleton we'll want to cache off
16// the instances in "memory" so we can return it later without creating an
17// entirely new instance of an object on each subsequent request for it.
18if ($this->isShared($abstract) && ! $needsContextualBuild) {
19    $this->instances[$abstract] = $object;
20}
21// 中略
22
23return $object;

1// エントリーポイントであるpublic/index.phpにてapp.phpを読込
2$app = require_once __DIR__.'/../bootstrap/app.php';
3
4// app.phpにて、Service Containerを表すクラスのインスタンスを生成
5$app = new Illuminate\Foundation\Application(
6    $_ENV['APP_BASE_PATH'] ?? dirname(__DIR__)
7);

1// Illuminate/Foundation/Application.php
2// 先ほどまで見ていたContainerクラスを継承
3class Application extends Container implements ApplicationContract, CachesConfiguration, CachesRoutes, HttpKernelInterface
4{
5    use Macroable;
6
7    /*
8     * Create a new Illuminate application instance.
9     *
10     * @param  string|null  $basePath
11     * @return void
12     */
13    public function __construct($basePath = null)
14    {
15        if ($basePath) {
16            $this->setBasePath($basePath);
17        }
18
19        $this->registerBaseBindings();
20        $this->registerBaseServiceProviders();
21        $this->registerCoreContainerAliases();
22    }

1/*
2 * Register the basic bindings into the container.
3 *
4 * @return void
5 */
6protected function registerBaseBindings()
7{
8    static::setInstance($this);
9
10    // Container::instance()は、既存のインスタンスをinstancesプロパティへ設定し、Service Containerから参照できるようにする
11    $this->instance('app', $this);
12
13    $this->instance(Container::class, $this);
14    $this->singleton(Mix::class);
15
16    $this->singleton(PackageManifest::class, fn () => new PackageManifest(
17        new Filesystem, $this->basePath(), $this->getCachedPackagesPath()
18    ));
19}

1/*
2 * Register the core class aliases in the container.
3 *
4 * @return void
5 */
6public function registerCoreContainerAliases()
7{
8    // Interfaceや継承元クラス名でもオブジェクトを参照できるようエイリアス(別名)を登録しておく
9    foreach ([
10        'app' => [self::class, \Illuminate\Contracts\Container\Container::class, \Illuminate\Contracts\Foundation\Application::class, \Psr\Container\ContainerInterface::class],
11        // 中略...
12        'router' => [\Illuminate\Routing\Router::class, \Illuminate\Contracts\Routing\Registrar::class, \Illuminate\Contracts\Routing\BindingRegistrar::class],
13        'session' => [\Illuminate\Session\SessionManager::class],
14        'session.store' => [\Illuminate\Session\Store::class, \Illuminate\Contracts\Session\Session::class],
15        'url' => [\Illuminate\Routing\UrlGenerator::class, \Illuminate\Contracts\Routing\UrlGenerator::class],
16        'validator' => [\Illuminate\Validation\Factory::class, \Illuminate\Contracts\Validation\Factory::class],
17        'view' => [\Illuminate\View\Factory::class, \Illuminate\Contracts\View\Factory::class],
18    ] as $key => $aliases) {
19        foreach ($aliases as $alias) {
20            $this->alias($key, $alias);
21        }
22    }
23}

1// $appはService Containerを指す
2$container = $app->make(\Illuminate\Contracts\Container\Container::class);
3$containerInterface = $app->make(\Psr\Container\ContainerInterface::class);
4
5// いずれも同一のApplicationオブジェクトが返却される

1/*
2 * Register all of the base service providers.
3 *
4 * @return void
5 */
6protected function registerBaseServiceProviders()
7{
8    $this->register(new EventServiceProvider($this));
9    $this->register(new LogServiceProvider($this));
10    $this->register(new RoutingServiceProvider($this));
11}

1// なんちゃってService Provider
2class ServiceProvider
3{
4    // Service Containerを参照できるようにしておく
5    private Application $app;
6    public function __construct(Application $app) {
7        $this->app = $app;
8    }
9    
10    public function register()
11    {
12        // 必要なオブジェクトのつくり方をService Containerへ登録
13        $this->app->singleton(RouterInterface::class, Router::class);
14    }
15}
16
17$serviceProvider = new ServiceProvider($app);
18// ServiceProvider::register()を呼ぶことで、アプリケーションが動作するのに必要な機能がServiceContainerへ用意される
19$serviceProvider->register();

1// Illuminate/Foundation/Application.php
2
3/*
4 * Register a service provider with the application.
5 *
6 * @param  \Illuminate\Support\ServiceProvider|string  $provider
7 * @param  bool  $force
8 * @return \Illuminate\Support\ServiceProvider
9 */
10public function register($provider, $force = false)
11{
12    // 中略...
13
14    // Service Providerオブジェクトのregisterメソッドを呼び出す
15    $provider->register();
16    
17    // 中略...
18    
19    // Service Containerにて、後からboot処理(後述)を呼び出せるようService Providerを保持しておく
20    $this->markAsRegistered($provider);
21
22    // If the application has already booted, we will call this boot method on
23    // the provider class so it has an opportunity to do its boot logic and
24    // will be ready for any usage by this developer's application logic.
25    if ($this->isBooted()) {
26        $this->bootProvider($provider);
27    }
28
29    return $provider;
30}

1// Illuminate/Routing/RoutingServiceProvider.php
2
3class RoutingServiceProvider extends ServiceProvider
4{
5    /*
6     * Register the service provider.
7     *
8     * @return void
9     */
10    public function register()
11    {
12        $this->registerRouter();
13        $this->registerUrlGenerator();
14        $this->registerRedirector();
15        // 中略...
16    }
17    // 中略...
18}

1/*
2 * Register the router instance.
3 *
4 * @return void
5 */
6protected function registerRouter()
7{
8    $this->app->singleton('router', function ($app) {
9        return new Router($app['events'], $app);
10    });
11}

1// public/index.php
2
3use Illuminate\Contracts\Http\Kernel;
4
5require __DIR__.'/../vendor/autoload.php';
6
7$app = require_once __DIR__.'/../bootstrap/app.php';
8
9// Service Containerからオブジェクトを取り出す
10$kernel = $app->make(Kernel::class);
11
12// これから見ていく処理
13$response = $kernel->handle(
14    $request = Request::capture()
15)->send();

1// bootstrap/app.php
2
3// Service Containerを用意
4// このときに基本的な機能を表すオブジェクトがService Providerなどを通じてService Containerへ登録される
5$app = new Illuminate\Foundation\Application(
6    $_ENV['APP_BASE_PATH'] ?? dirname(__DIR__)
7);
8
9// Kernel Interfaceを実装したオブジェクトのつくり方を規定
10$app->singleton(
11    Illuminate\Contracts\Http\Kernel::class,
12    App\Http\Kernel::class
13);
14
15// Service Containerを読み込み元へ返却
16/*
17|-----------------------------------------------------------------------
18| Return The Application 
19|-----------------------------------------------------------------------
20| 
21| This script returns the application instance. The instance is given to 
22| the calling script so we can separate the building of the instances 
23| from the actual running of the application and sending responses. 
24| 
25*/ 
26return $app;

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

1// Illuminate/Http/Request.php
2
3/*
4 * Create a new Illuminate HTTP request from server variables.
5 *
6 * @return static
7 */
8public static function capture()
9{
10    static::enableHttpMethodParameterOverride();
11
12    return static::createFromBase(SymfonyRequest::createFromGlobals());
13}

1SymfonyRequest::createFromGlobals()

1// Symfony/Component/HttpFoundation/Request.php
2// ※ SymfonyRequestという名前は、Laravel側でSymfonyのRequestクラスを参照するときのエイリアス名
3/*
4 * Creates a new request with values from PHP's super globals.
5 */
6public static function createFromGlobals(): static
7{
8    $request = self::createRequestFromFactory($_GET, $_POST, [], $_COOKIE, $_FILES, $_SERVER);
9    
10    // 中略...
11
12    return $request;
13}

1public static function capture()
2{
3    static::enableHttpMethodParameterOverride();
4
5    // Symfony RequestオブジェクトをもとにRequest::createFromBase()を呼び出す
6    return static::createFromBase(SymfonyRequest::createFromGlobals());
7}

1    /*
2     * Create an Illuminate request from a Symfony instance.
3     *
4     * @param  \Symfony\Component\HttpFoundation\Request  $request
5     * @return static
6     */
7    public static function createFromBase(SymfonyRequest $request)
8    {
9        // Symfonyのリクエストオブジェクトをもとに、Illuminate\Http\Requestオブジェクトを作成
10        $newRequest = (new static)->duplicate(
11            $request->query->all(), $request->request->all(), $request->attributes->all(),
12            $request->cookies->all(), $request->files->all(), $request->server->all()
13        );
14        
15        // 中略...
16
17        return $newRequest;
18    }

1// public/index.php
2$response = $kernel->handle(
3    $request = Request::capture()
4)->send();

1// Illuminate/Foundation/Http/Kernel.php
2
3class Kernel implements KernelContract
4{
5    use InteractsWithTime;
6
7    // これらのプロパティはService Containerにて設定される
8    // Service Container
9    /*
10     * The application implementation.
11     *
12     * @var \Illuminate\Contracts\Foundation\Application
13     */
14    protected $app;
15
16    // URLと紐づく処理を探索するオブジェクト
17    /**
18     * The router instance.
19     *
20     * @var \Illuminate\Routing\Router
21     */
22    protected $router;
23
24    /**
25     * Handle an incoming HTTP request.
26     *
27     * @param  \Illuminate\Http\Request  $request
28     * @return \Illuminate\Http\Response
29     */
30    public function handle($request)
31    {
32        try {
33            $response = $this->sendRequestThroughRouter($request);
34        } catch (Throwable $e) {
35            $this->reportException($e);
36
37            $response = $this->renderException($request, $e);
38        }
39        
40        // 中略...
41
42        return $response;
43    }

1// routes/web.php
2Route::get('/hello', function (Request $request) {
3// Hello Laravel from hello
4return "Hello Laravel from {$request->path()}";
5});

1/*
2 * Send the given request through the middleware / router.
3 *
4 * @param  \Illuminate\Http\Request  $request
5 * @return \Illuminate\Http\Response
6 */
7protected function sendRequestThroughRouter($request)
8{
9    // リクエストオブジェクトをService Containerへ登録しておく
10    $this->app->instance('request', $request);
11    // 中略...
12    $this->bootstrap();
13
14    return (new Pipeline($this->app))
15                ->send($request)
16                ->through($this->app->shouldSkipMiddleware() ? [] : $this->middleware)
17                ->then($this->dispatchToRouter());
18}

1// Kernelクラスのプロパティ
2/*
3 * The bootstrap classes for the application.
4 *
5 * @var string[]
6 */
7protected $bootstrappers = [
8    \Illuminate\Foundation\Bootstrap\LoadEnvironmentVariables::class,
9    \Illuminate\Foundation\Bootstrap\LoadConfiguration::class,
10    \Illuminate\Foundation\Bootstrap\HandleExceptions::class,
11    \Illuminate\Foundation\Bootstrap\RegisterFacades::class,
12    \Illuminate\Foundation\Bootstrap\RegisterProviders::class,
13    \Illuminate\Foundation\Bootstrap\BootProviders::class,
14];

1// Illuminate/Foundation/Bootstrap/BootProviders.php
2
3namespace Illuminate\Foundation\Bootstrap;
4
5use Illuminate\Contracts\Foundation\Application;
6
7class BootProviders
8{
9    /*
10     * Bootstrap the given application.
11     *
12     * @param  \Illuminate\Contracts\Foundation\Application  $app
13     * @return void
14     */
15    public function bootstrap(Application $app)
16    {
17        $app->boot();
18    }
19}

1// Illuminate/Foundation/Application.php
2/*
3 * Boot the application's service providers.
4 *
5 * @return void
6 */
7public function boot()
8{
9    // 中略...
10    array_walk($this->serviceProviders, function ($p) {
11        $this->bootProvider($p);
12    });
13
14    $this->booted = true;
15    // 中略...
16}
17/**
18 * Boot the given service provider.
19 *
20 * @param  \Illuminate\Support\ServiceProvider  $provider
21 * @return void
22 */
23protected function bootProvider(ServiceProvider $provider)
24{
25    // 中略...
26    
27    if (method_exists($provider, 'boot')) {
28        // Container::call()は非常に複雑なので割愛
29        // Service Providerのbootメソッドをよしなに呼び出していると解釈してOK
30        $this->call([$provider, 'boot']);
31    }
32}

1return (new Pipeline($this->app))
2            ->send($request)
3            ->through($this->app->shouldSkipMiddleware() ? [] : $this->middleware)
4            ->then($this->dispatchToRouter());

1// なんちゃってPipelineクラス
2// ※ 実際の仕組みをかなり簡略化しているので、雰囲気を掴む程度に眺めてください
3class Pipeline
4{
5    private mixed $passable;
6    
7    // send()で共通の引数を設定
8    public function send(mixed $passable)
9    {
10        $this->passable = $passable;
11        return $this;
12    }
13    // 共通の引数で一連のメソッドを呼び出す
14    public function through(array $pipes)
15    {
16        foreach($pipes as $pipe) {
17            $pipe->handle($this->passable);
18        }
19        return $this;
20    }
21    // 後処理として、渡されたClosureを呼び出す
22    public function then(Closure $destination)
23    {
24        $destination($this->passable):
25    }
26}
27
28$pipeline = new Pipeline($this->app);
29$pipeline = $pipeline->send($request);
30$pipeline = $pipeline->through($this->middleware)
31$pipeline->then($this->dispatchToRouter());

1namespace App\Http;
2
3use Illuminate\Foundation\Http\Kernel as HttpKernel;
4
5class Kernel extends HttpKernel
6{
7    /*
8     * The application's global HTTP middleware stack.
9     *
10     * These middleware are run during every request to your application.
11     *
12     * @var array
13     */
14    protected $middleware = [
15        \App\Http\Middleware\TrustHosts::class,
16        \App\Http\Middleware\TrustProxies::class,
17        \Illuminate\Http\Middleware\HandleCors::class,
18        \App\Http\Middleware\PreventRequestsDuringMaintenance::class,
19        \Illuminate\Foundation\Http\Middleware\ValidatePostSize::class,
20        \App\Http\Middleware\TrimStrings::class,
21        \Illuminate\Foundation\Http\Middleware\ConvertEmptyStringsToNull::class,
22    ];
23    // 中略...
24}

1// ミドルウェア
2class ValidatePostSize
3{
4    /*
5     * Handle an incoming request.
6     *
7     * @param  \Illuminate\Http\Request  $request
8     * @param  \Closure  $next
9     * @return mixed
10     *
11     * @throws \Illuminate\Http\Exceptions\PostTooLargeException
12     */
13    public function handle($request, Closure $next)
14    {
15        // POSTリクエストのボディの最大サイズ
16        $max = $this->getPostMaxSize();
17
18        // POSTリクエストのボディが最大サイズを超過していたら処理を打ち止め
19        if ($max > 0 && $request->server('CONTENT_LENGTH') > $max) {
20            throw new PostTooLargeException;
21        }
22
23        // ※ 厳密にはPipelineにおける後続の処理は、オブジェクトのメソッドから呼び出されている
24        return $next($request);
25    }
26}

1// Illuminate/Foundation/Http/Kernel.php
2/*
3 * Get the route dispatcher callback.
4 *
5 * @return \Closure
6 */
7protected function dispatchToRouter()
8{
9    return function ($request) {
10        return $this->router->dispatch($request);
11    };
12}

1// Illuminate/Routing/Router.php
2
3/*
4 * Dispatch the request to the application.
5 *
6 * @param  \Illuminate\Http\Request  $request
7 * @return \Symfony\Component\HttpFoundation\Response
8 */
9public function dispatch(Request $request)
10{
11    $this->currentRequest = $request;
12
13    return $this->dispatchToRoute($request);
14}
15
16// 中略...
17
18/**
19 * Dispatch the request to a route and return the response.
20 *
21 * @param  \Illuminate\Http\Request  $request
22 * @return \Symfony\Component\HttpFoundation\Response
23 */
24public function dispatchToRoute(Request $request)
25{
26    return $this->runRoute($request, $this->findRoute($request));
27}

1/*
2 * Find the route matching a given request.
3 *
4 * @param  \Illuminate\Http\Request  $request
5 * @return \Illuminate\Routing\Route
6 */
7protected function findRoute($request)
8{
9    // 中略...
10    $this->current = $route = $this->routes->match($request);
11
12    return $route;
13}

1// routes/web.php
2Route::get('/hello', function (Request $request) {
3// Hello Laravel from hello
4return "Hello Laravel from {$request->path()}";
5});

1// Illuminate/Support/Facades/Route.php
2class Route extends Facade
3{
4    /*
5     * Get the registered name of the component.
6     *
7     * @return string
8     */
9    protected static function getFacadeAccessor()
10    {
11        return 'router';
12    }
13}

1/*
2 * Handle dynamic, static calls to the object.
3 *
4 * @param  string  $method
5 * @param  array  $args
6 * @return mixed
7 *
8 * @throws \RuntimeException
9 */
10public static function __callStatic($method, $args)
11{
12    $instance = static::getFacadeRoot();
13    // 中略...
14    return $instance->$method(...$args);
15}

1/*
2 * Get the root object behind the facade.
3 *
4 * @return mixed
5 */
6public static function getFacadeRoot()
7{
8    // getFacadeAccessorは子クラスに定義されている
9    // 今回の場合は、文字列routerへと評価される
10    return static::resolveFacadeInstance(static::getFacadeAccessor());
11}
12
13/**
14 * Resolve the facade root instance from the container.
15 *
16 * @param  string  $name
17 * @return mixed
18 */
19protected static function resolveFacadeInstance($name)
20{
21    // 中略...
22    // クラス変数appは、bootstrapperにてService Containerが設定されている
23    if (static::$app) {
24        // 中略...
25
26        return static::$app[$name];
27    }
28}