Laravelの仕組み整理

class UserController extends Controller
{
 　public function create($param) {
      $repository = new UserRepository;
      $repository->save($param);
      ...
}
}

    /**
     * Register a shared binding in the container.
     *
     * @param  string  $abstract
     * @param  \Closure|string|null  $concrete
     * @return void
     */
    public function singleton($abstract, $concrete = null)
    {
        $this->bind($abstract, $concrete, true);
    }

    public function bind($abstract, $concrete = null, $shared = false)
    {
        $this->dropStaleInstances($abstract);

        // If no concrete type was given, we will simply set the concrete type to the
        // abstract type. After that, the concrete type to be registered as shared
        // without being forced to state their classes in both of the parameters.
        if (is_null($concrete)) {
            $concrete = $abstract;
        }

        // If the factory is not a Closure, it means it is just a class name which is
        // bound into this container to the abstract type and we will just wrap it
        // up inside its own Closure to give us more convenience when extending.
        if (! $concrete instanceof Closure) {
            if (! is_string($concrete)) {
                throw new TypeError(self::class.'::bind(): Argument #2 ($concrete) must be of type Closure|string|null');
            }

            $concrete = $this->getClosure($abstract, $concrete);
        }

        $this->bindings[$abstract] = compact('concrete', 'shared');

        // If the abstract type was already resolved in this container we'll fire the
        // rebound listener so that any objects which have already gotten resolved
        // can have their copy of the object updated via the listener callbacks.
        if ($this->resolved($abstract)) {
            $this->rebound($abstract);
        }
    }

    /**
     * The registered type aliases.
     *
     * @var string[]
     */
    protected $aliases = [];

    /**
     * The registered aliases keyed by the abstract name.
     *
     * @var array[]
     */
    protected $abstractAliases = [];

        $app = app();

        $reflection = new ReflectionClass($app);
        $property = $reflection->getProperty('abstractAliases');
        $property->setAccessible(true);

        dd($property->getValue($app)); // プロパティの値をダンプ

[
  "Illuminate\Foundation\Application" => "app"
  "Illuminate\Contracts\Container\Container" => "app"
  "Illuminate\Contracts\Foundation\Application" => "app"
  "Psr\Container\ContainerInterface" => "app"
  "Illuminate\Auth\AuthManager" => "auth"
  "Illuminate\Contracts\Auth\Factory" => "auth"
...
]

 "app" => [
    0 => "Illuminate\Foundation\Application"
    1 => "Illuminate\Contracts\Container\Container"
    2 => "Illuminate\Contracts\Foundation\Application"
    3 => "Psr\Container\ContainerInterface"
  ]
  "auth" => [
    0 => "Illuminate\Auth\AuthManager"
    1 => "Illuminate\Contracts\Auth\Factory"

    public function singleton($abstract, $concrete = null)
    {
        $this->bind($abstract, $concrete, true);
    }

    public function bind($abstract, $concrete = null, $shared = false)
    {
        $this->dropStaleInstances($abstract);

        // If no concrete type was given, we will simply set the concrete type to the
        // abstract type. After that, the concrete type to be registered as shared
        // without being forced to state their classes in both of the parameters.
        if (is_null($concrete)) {
            $concrete = $abstract;
        }

        // If the factory is not a Closure, it means it is just a class name which is
        // bound into this container to the abstract type and we will just wrap it
        // up inside its own Closure to give us more convenience when extending.
        if (! $concrete instanceof Closure) {
            if (! is_string($concrete)) {
                throw new TypeError(self::class.'::bind(): Argument #2 ($concrete) must be of type Closure|string|null');
            }

            $concrete = $this->getClosure($abstract, $concrete);
        }

        $this->bindings[$abstract] = compact('concrete', 'shared');

        // If the abstract type was already resolved in this container we'll fire the
        // rebound listener so that any objects which have already gotten resolved
        // can have their copy of the object updated via the listener callbacks.
        if ($this->resolved($abstract)) {
            $this->rebound($abstract);
        }
    }

$app = new Illuminate\Foundation\Application(
    $_ENV['APP_BASE_PATH'] ?? dirname(__DIR__)
);

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

$kernel = $app->make(Illuminate\Contracts\Console\Kernel::class);

$kernel = $app->make(Illuminate\Contracts\Console\Kernel::class);

$status = $kernel->handle(
    $input = new Symfony\Component\Console\Input\ArgvInput,
    new Symfony\Component\Console\Output\ConsoleOutput
);

    protected $bootstrappers = [
        \Illuminate\Foundation\Bootstrap\LoadEnvironmentVariables::class,
        \Illuminate\Foundation\Bootstrap\LoadConfiguration::class,
        \Illuminate\Foundation\Bootstrap\HandleExceptions::class,
        \Illuminate\Foundation\Bootstrap\RegisterFacades::class,
        \Illuminate\Foundation\Bootstrap\SetRequestForConsole::class,
        \Illuminate\Foundation\Bootstrap\RegisterProviders::class,
        \Illuminate\Foundation\Bootstrap\BootProviders::class,
    ];

...省略

    public function handle($input, $output = null)
    {
        $this->commandStartedAt = Carbon::now();

        try {
            if (in_array($input->getFirstArgument(), ['env:encrypt', 'env:decrypt'], true)) {
                $this->bootstrapWithoutBootingProviders();
            }

            $this->bootstrap();

            return $this->getArtisan()->run($input, $output);
        } catch (Throwable $e) {
            $this->reportException($e);

            $this->renderException($output, $e);

            return 1;
        }
    }

class RegisterProviders
{
    public function bootstrap(Application $app)
    {
        $app->registerConfiguredProviders();
    }
}

    public function registerConfiguredProviders()
    {
        $providers = Collection::make($this->make('config')->get('app.providers'))
                        ->partition(fn ($provider) => str_starts_with($provider, 'Illuminate\\'));

        $providers->splice(1, 0, [$this->make(PackageManifest::class)->providers()]);

        (new ProviderRepository($this, new Filesystem, $this->getCachedServicesPath()))
                    ->load($providers->collapse()->toArray());
    }

$kernel = $app->make(Illuminate\Contracts\Console\Kernel::class);

    protected function resolve($abstract, $parameters = [], $raiseEvents = true)
    {
// aliases => [
//    "Illuminate\Foundation\Application" => "app"
//      "Illuminate\Contracts\Container\Container" => "app"
//      "Illuminate\Contracts\Foundation\Application" => "app"
//      "Psr\Container\ContainerInterface" => "app"
//      "Illuminate\Auth\AuthManager" => "auth"
//...多いので省略
// ]
//
// 上記のaliasesに$abstractキーが存在すれば、そのaliasを返す。なければ$abstractをそのまま返す。
        $abstract = $this->getAlias($abstract);

// イベントハンドラ（raisEvents）が有効な場合に、解決のプロセスを行う前に実行が必要な関数を処理する。
// グローバルなものと、抽象ごとに設定されたものがある。
        if ($raiseEvents) {
            $this->fireBeforeResolvingCallbacks($abstract, $parameters);
        }

// サービスコンテナにコンテクストバインディングが存在すれば返す。
// 通常のバインディングと違って特定のコンテキクストのみで解決されるように定義されている。
        $concrete = $this->getContextualConcrete($abstract);

// ビルド（オブジェクトをインスタンス化したものを返却するプロセス）が必要であるかを判定
        $needsContextualBuild = ! empty($parameters) || ! is_null($concrete);

// インスタンス化されたものが存在してビルドの必要もない場合は、既存のインスタンスを返す。
// シングルトンオブジェクトの要求である場合はここで終了。
        if (isset($this->instances[$abstract]) && ! $needsContextualBuild) {
            return $this->instances[$abstract];
        }

// オブジェクトの解決時に必要なパラメータを格納しておく。
        $this->with[] = $parameters;

// コンテクストバインディングが解決されなかった場合に、通常のバインディングを解決。
// インスタンスを返す。
        if (is_null($concrete)) {
            $concrete = $this->getConcrete($abstract);
        }

// 具体がビルド可能であるかを判定（$concrete===$abstracctであるか※、$concreteがクロージャーである場合※）
// ビルド可能である場合はビルドを行う。
// 具体的には解決先オブジェクトのコンストラクタを参照し、引数にタイプ品ティングがある場合はコンストラクタインジェクションを済ませた状態でインスタンスを生成する。

        $object = $this->isBuildable($concrete, $abstract)
            ? $this->build($concrete)
            : $this->make($concrete);

        foreach ($this->getExtenders($abstract) as $extender) {
            $object = $extender($object, $this);
        }

// オブジェクトがシングルトンとして登録されている、かつ動的なコンテキストがない場合は$instancesにセットすることでキャッシュしておく。
// 再度要求された場合に新たにオブジェクトを生成せずに、キャッシュしたものを返す。
        if ($this->isShared($abstract) && ! $needsContextualBuild) {
            $this->instances[$abstract] = $object;
        }

// イベントハンドラ（raisEvents）が有効な場合に、実行が必要な関数を処理する。
        if ($raiseEvents) {
            $this->fireResolvingCallbacks($abstract, $object);
        }

// オブジェクトの解決が完了したことを示すためにフラグを立てる。
        $this->resolved[$abstract] = true;

// 配列の末尾を取り除くことで、先ほどオブジェクトの解決のためにセットしておいたパラメータを取り除く。
        array_pop($this->with);

        return $object;
    }

    public function build($concrete)
    {
// クロージャであれば先ほどの$this->withに格納したパラメータを渡してそのまま実行する。
        if ($concrete instanceof Closure) {
            return $concrete($this, $this->getLastParameterOverride());
        }

// ReflectionClassを使って解決するオブジェクトの情報を取得。
// 取得できない（そのクラスが存在しない）場合は例外をスロー
        try {
            $reflector = new ReflectionClass($concrete);
        } catch (ReflectionException $e) {
            throw new BindingResolutionException("Target class [$concrete] does not exist.", 0, $e);
        }

// オブジェクトがインスタンス化できない場合（※）はnotinstantiableメソッド経由で例外を投げる。
// 問題なければビルドスタックに突っ込む。
        if (! $reflector->isInstantiable()) {
            return $this->notInstantiable($concrete);
        }
        $this->buildStack[] = $concrete;

// コンストラクタの情報を取得
        $constructor = $reflector->getConstructor();

// コンストラクタが存在しない場合はそのままnewして返す。
        if (is_null($constructor)) {
            array_pop($this->buildStack);

            return new $concrete;
        }

// reflectionClassの機能を使ってコンストラクタのパタメータ情報を依存関係として取得
// この情報にはパタメータの名前や型が含まれている。
        $dependencies = $constructor->getParameters();

// 先ほどの依存関係を解決していく
        try {
            $instances = $this->resolveDependencies($dependencies);
        } catch (BindingResolutionException $e) {
            array_pop($this->buildStack);

            throw $e;
        }

        array_pop($this->buildStack);

// 依存性注入を行なったオブジェクトを返す
        return $reflector->newInstanceArgs($instances);
    }

    'providers' => ServiceProvider::defaultProviders()->merge([
        /*
         * Application Service Providers...
         */
        App\Providers\AppServiceProvider::class,
        App\Providers\AuthServiceProvider::class,
        // App\Providers\BroadcastServiceProvider::class,
        App\Providers\EventServiceProvider::class,
        App\Providers\RouteServiceProvider::class,
    ])->toArray(),

class AuthServiceProvider extends ServiceProvider
{
    public function register()
    {
        $this->registerAuthenticator();
        $this->registerUserResolver();
        $this->registerAccessGate();
        $this->registerRequirePassword();
        $this->registerRequestRebindHandler();
        $this->registerEventRebindHandler();
    }

    protected function registerAuthenticator()
    {
        $this->app->singleton('auth', fn ($app) => new AuthManager($app));

        $this->app->singleton('auth.driver', fn ($app) => $app['auth']->guard());
    }

... 省略
}

    public function registerCoreContainerAliases()
    {
        foreach ([
            'app' => [self::class, \Illuminate\Contracts\Container\Container::class, \Illuminate\Contracts\Foundation\Application::class, \Psr\Container\ContainerInterface::class],
            'auth' => [\Illuminate\Auth\AuthManager::class, \Illuminate\Contracts\Auth\Factory::class],
            'auth.driver' => [\Illuminate\Contracts\Auth\Guard::class],
// ...多すぎるので省略
        ] as $key => $aliases) {
            foreach ($aliases as $alias) {
                $this->alias($key, $alias);
            }
        }
    }