【Laravel】引数でタイプヒントしただけでインスタンスがもらえるのはなぜ？Laravelの魔法を解明してみる。

# はじめに
Laravelを使ってアプリケーションを実装するうえで、
最も便利だと感じる機能が、「コンストラクターインジェクション」です。
[Laravel 6.x コントローラ：コンストラクターインジェクション](https://readouble.com/laravel/6.x/ja/controllers.html#dependency-injection-and-controllers)

クラスのコンストラクタの引数で、特定のクラスを型宣言しておくだけで、
自動的に引数としてそのクラスのインスタンスを渡してくれるという機能です。

これには、
サービスコンテナの「依存解決」という機能が利用されています。

サービスコンテナとは何なのか？
依存解決とは何なのか？
についてはこちらの記事で解説しています。
[【Laravel】サービスコンテナとは？２つの強力な武器を持ったインスタンス化マシーン。簡単に解説。](https://qiita.com/minato-naka/items/afa4b930a2afac23261b)

先にこちらの記事を読んで、サービスコンテナの概要について理解してから
本記事を読むことをお勧めします。


今回は、そのサービスコンテナの「依存解決」機能の内部で
具体的にどのような処理を行っているのかを解説していきます。


# 依存解決とは
まずは、サービスコンテナの「依存解決」とは何なのか、
ざっくり確認しておきます。

このような、ClassAがあったとします。
コンストラクタの引数で、ClassBを受け取っています。

```php:ClassA.php
class ClassA
{
    private $classB;

    public function __construct(ClassB $classB)
    {
        $this->classB = $classB;
    }
}
```
　
　
このClassAをインスタンス化するとき、
普通ならこのように
まずClassBをインスタンス化し、それを引数としてClassAをインスタンス化しますね。

```php:Main.php
$classB = new ClassB();
$classA = new ClassA($classB);
```
　
　
引数を無視していきなり
ClassAをnewでインスタンス化しようとすると、
もちろんエラーが発生します。

```php:Main.php
$classA = new ClassA();

// laravel.log
// local.ERROR: Too few arguments to function ClassA::__construct()
```
　
　
サービスコンテナの`make()`メソッドを利用すると
この様にすることができます。

```php:Main.php
$classA = app()->make(ClassA::class);
```

事前にClassBをインスタンス化せずに、
いきなりClassAを`make()`しましたが、
エラーは発生しませんし
ちゃんとClassAの中でClassBがインスタンス化されています。

ClassBがさらにClassC、D、Eと階層的に依存していたとしても、
再帰的にすべて依存解決してくれます。　
　
　
これが、サービスコンテナの依存解決という機能です。

この`make()`メソッドの内部ではいったいどのような処理をして
依存解決しているのか、具体的に解説していきます。



# リフレクションとは
PHPには「リフレクション」という機能があり、
サービスコンテナの`make()`メソッドでは
この「リフレクション」を活用して依存解決を行っています。

依存解決の仕組みを知るうえで
「リフレクション」というものが何なのかを知っておく必要があるので
簡単に見ていきます。

[wiki：リフレクション (情報工学)](https://ja.wikipedia.org/wiki/%E3%83%AA%E3%83%95%E3%83%AC%E3%82%AF%E3%82%B7%E3%83%A7%E3%83%B3_%28%E6%83%85%E5%A0%B1%E5%B7%A5%E5%AD%A6%29)

ウィキペディアによると、
>情報工学においてリフレクション (reflection) とは、プログラムの実行過程でプログラム自身の構造を読み取ったり書き換えたりする技術のことを指す。

とあります。

重要なのはここ
「プログラム自身の構造を読み取ったり書き換えたりする技術」
です。

さらに、
「プログラム自身の構造を読み取ったり書き換えたりする技術」
これを今回のPHPの例でわかりやすく具体的に言うと、
「クラスの中身を読み取って、
どんなプロパティを持っているか？
どんなメソッドを持っているか？
メソッドの引数は何か？
アクセス修飾子は何か？
などいろいろと調べることができる機能」
という感じ。

実際にリフレクション機能を使ってコードを書いてみます。

この様なクラスがあったとします。

```php:SampleClass.php
class SampleClass
{
    private $classA;
    private $classB;

    public function __construct(ClassA $classA, ClassB $classB)
    {
        $this->classA = $classA;
        $this->classB = $classB;
    }

    public function method1(int $int)
    {
    }

    private function method2()
    {
    }
}
```
　
　
そのSampleClassの内部を調べるコードを
Main.phpのほうに書いていきます。

```php:Main.php
$reflectionClass = new \ReflectionClass(SampleClass::class);
```

この様に、`new \ReflectionClass()`にクラス名を文字列で与えることで、
リフレクションクラスを作成します。

そしてこのリフレクションクラスに対して様々なメソッドを実行することで
クラスの内部構造をいろいろ読み取ることができます。

例えば、クラスの持つプロパティ一覧を取得してみたり。

```php:Main.php
$reflectionClass = new \ReflectionClass(SampleClass::class);
$properties = $reflectionClass->getProperties(); // クラスの持つプロパティ一覧を取得する

dd($properties);
// array:2 [▼
//   0 => ReflectionProperty {#360 ▼
//     +name: "classA"
//     +class: "App\Sample\SampleClass"
//     modifiers: "private"
//   }
//   1 => ReflectionProperty {#361 ▼
//     +name: "classB"
//     +class: "App\Sample\SampleClass"
//     modifiers: "private"
//   }
// ]
```
　
　
クラスの持つメソッド一覧を取得してみたり。

```php:Main.php
$reflectionClass = new \ReflectionClass(SampleClass::class);
$methods = $reflectionClass->getMethods(); // クラスの持つメソッド一覧を取得する

dd($methods);
// array:3 [▼
//   0 => ReflectionMethod {#360 ▼
//     +name: "__construct"
//     +class: "App\Sample\SampleClass"
//     parameters: {▼
//       $classA: ReflectionParameter {#373 ▶}
//       $classB: ReflectionParameter {#372 ▶}
//     }
//     modifiers: "public"
//   }
//   1 => ReflectionMethod {#361 ▼
//     +name: "method1"
//     +class: "App\Sample\SampleClass"
//     parameters: {▼
//       $int: ReflectionParameter {#374 ▶}
//     }
//     modifiers: "public"
//   }
//   2 => ReflectionMethod {#363 ▼
//     +name: "method2"
//     +class: "App\Sample\SampleClass"
//     modifiers: "private"
//   }
// ]
```

メソッド名や、そのアクセス修飾子、パラメータなども丸見えですね。

他にもいろいろとできることがあるので、
よかったら公式マニュアルで確認してみてください。
[PHP: リフレクション - Manual](https://www.php.net/manual/ja/book.reflection.php)

リフレクションは、
ユニットテストでプライベートメソッドのテストを実行したいときに、
メソッドのアクセス修飾子をpublicに書き換えて実行。
とかやったりするときに使ったりしますね。（それ以外では使ったことない）
　
　
　
そして、もう多少想像できてきているかもしれませんが、
サービスコンテナの`make()`では
このリフレクションを利用して、
・クラスのコンストラクタはあるか？
・コンストラクタの引数はあるか？
・その引数は型宣言されているか？
・その宣言されている型はクラスか？
みたいなことをやって、依存解決を実現させています。

それではリフレクションの説明は終わりにして、
`make()`の仕組みを見ていきます。


# make()の仕組み
今回は、サービスコンテナの`make()`メソッドの仕組みを説明するにあたり、
`make()`メソッドの簡易版を自作していきたいと思います。

想像以上に簡単なので、安心して読み進めてください。

### １階層のみの依存解決
まずは簡単に、１階層のみ依存解決できるコードを作ってみます。

#### 対象クラス作成
依存解決の対象となるクラスはこの様な形にします。

![Untitled Diagram-Copy of Page-1.png](https://qiita-image-store.s3.ap-northeast-1.amazonaws.com/0/297693/55a041b7-5bdc-229a-6bc9-2c25cfc9dc62.png)

ClassAがあり、
そのコンストラクタ引数としてClassBに依存している状態です。

```php:ClassA
class ClassA
{
    public function __construct(ClassB $classB)
    {
        \Log::info('ClassAインスタンス化完了');
    }
}
```

```php:ClassB
class ClassB
{
    public function __construct()
    {
        \Log::info('ClassBインスタンス化完了');
    }
}
```

それぞれインスタンス化されたことが分かるように
コンストラクタでログを出すようにしています。
　
　
それでは次に、
このクラスの依存解決をしてくれる`make()`メソッドを作っていきます。


#### クラス名を文字列で受け取る
`make()`を呼び出す側は、
この様な形で`make()`を実行します。

```php:Main.php
$classA = $this->make(ClassA::class);
```

※この`ClassA::class`は、`"App\Sample\ClassA"`のように名前空間を含むクラスの完全修飾名を文字列で出しています。

なので、まず`make()`では引数としてクラス名を文字列で受け取りましょう。

```php:Main.php
public function make(string $className)
{
}
```

いまこの`$className`には`"App\Sample\ClassA"`という文字列が渡されている状態ですね。


#### リフレクションクラス作成
次に、受け取ったクラス名からリフレクションクラスを作成します。

```php:Main.php
public function make(string $className)
{
    $reflectionClass = new \ReflectionClass($className);
}
```

いまこの`$reflectionClass`には、ClassAのリフレクションクラスが入っている状態です。

#### コンストラクタ取得
次に、このリフレクションクラスからコンストラクタを取得します。

```php:Main.php
public function make(string $className)
{
    $reflectionClass = new \ReflectionClass($className);
    $constructor = $reflectionClass->getConstructor();
}
```

これで、`$constructor`にはClassAのコンストラクタの情報が入っている状態です。

#### コンストラクタの引数取得
次に、このコンストラクタの引数を取得します。

```php:Main.php
public function make(string $className)
{
    $reflectionClass = new \ReflectionClass($className);
    $constructor = $reflectionClass->getConstructor();
    $parameters = $constructor->getParameters();
}
```

これで、`$parameters`にはClassAのコンストラクタの引数の一覧が配列で入ってる状態です。


今回の例では、ClassBで型宣言された`$classB`という引数の情報が１つ入っているだけですね。
簡易版なので、コンストラクタの引数が複数あるケースを無視して１つだけの場合で進めちゃいます。

```php:Main.php
public function make(string $className)
{
    $reflectionClass = new \ReflectionClass($className);
    $constructor = $reflectionClass->getConstructor();
    $parameters = $constructor->getParameters();
    $parameter = $parameters[0];
}
```

> `$parameter = $parameters[0];`

この様に、先ほど取得したパラメータ一覧の最初の要素を取っておきます。

これで、`$parameter`には
ClassBで型宣言された`$classB`という引数の情報が入っている状態ですね。

#### 引数で型宣言されたクラス名取得
取得したパラメータ情報から、
型宣言されているクラスの名前を取得します。

```php:Main.php
public function make(string $className)
{
    $reflectionClass = new \ReflectionClass($className);
    $constructor = $reflectionClass->getConstructor();
    $parameters = $constructor->getParameters();
    $parameter = $parameters[0];
    $parameterClassName = $parameter->getClass()->name;

    dd($parameterClassName);
    // "App\Sample\ClassB"
}
```

> `$parameterClassName = $parameter->getClass()->name;`

先ほどの`$parameter`に`->getClass()`することで、型宣言されているクラスが取得できます。
さらにそのクラスから`->name`とするとクラス名を取得することができます。

ddでちゃんと`"App\Sample\ClassB"`というクラス名が文字列で取得できていますね。

#### 型宣言されているクラスをインスタンス化する
コンストラクタの引数で型宣言されているクラスのクラス名
`"App\Sample\ClassB"`を取得できたので、
このクラスをインスタンス化します。

```php:Main.php
public function make(string $className)
{
    $reflectionClass = new \ReflectionClass($className);
    $constructor = $reflectionClass->getConstructor();
    $parameters = $constructor->getParameters();
    $parameter = $parameters[0];
    $parameterClassName = $parameter->getClass()->name;
    $parameterInstance = new $parameterClassName;

    // laravel.log
    // local.INFO: ClassBインスタンス化完了  
}
```

クラス名文字列を使って`new`しているので、
これで`$parameterInstance`にはClassBのインスタンスが入っている状態です。

クラスがインスタンス化されたときに、
ログを出力するようにしているので
この時点でlaravel.logには`ClassBインスタンス化完了`
とログ出力されているはずです。


#### 作成したインスタンスを引数に渡して、対象クラスをインスタンス化する
最後に、インスタンス化したクラス（ClassB）を引数にして、
対象クラス（ClassA）をインスタンス化して返却しましょう。

```php:Main.php
public function make(string $className)
{
    $reflectionClass = new \ReflectionClass($className);
    $constructor = $reflectionClass->getConstructor();
    $parameters = $constructor->getParameters();
    $parameter = $parameters[0];
    $parameterClassName = $parameter->getClass()->name;
    $parameterInstance = new $parameterClassName;

    return new $className($parameterInstance);
}
```

`$className`にはClassAのクラス名が入っていて、
`$parameterInstance`にはClassBのインスタンスが入っている状態なので、
これで無事にClassAをインスタンス化することができました。


改めて、この自作`make()`メソッドを実行してみましょう。

```php:Main.php
$classA = $this->make(ClassA::class);

// laravel.log
// local.INFO: ClassBインスタンス化完了  
// local.INFO: ClassAインスタンス化完了  
```

これで、`make()`内部では

* ClassAのリフレクションクラス作成
* ClassAのコンストラクタ取得
* コンストラクタの引数取得
* 引数で型宣言されているクラス名を取得
* そのクラス（ClassB）をインスタンス化
* そのClassBインスタンスを引数にしてClassAをインスタンス化

という処理が行われたわけです。

laravel.logにもちゃんと

> // local.INFO: ClassBインスタンス化完了  
// local.INFO: ClassAインスタンス化完了  

と出力されています。


これにて、一番簡単な形での依存解決を自力で実装することができました。
ただし、現状は１階層のみの依存解決しかできていません。

ClassBのコンストラクタ引数でさらにClassCが渡されていたりしたら、
この`make()`メソッドでは依存解決することができないですね。

なので、次は多階層の依存解決ができるように
自作`make()`メソッドをもう少し進化させてみましょう。


### 多階層の依存解決

#### 対象クラス作成
まずは依存解決対象のクラスたちを作るところから。

次はこのようなクラスの形にします。

![Untitled Diagram-Copy of Page-1 (1).png](https://qiita-image-store.s3.ap-northeast-1.amazonaws.com/0/297693/39267dd1-92f3-9938-2eed-6de2e2f81294.png)

先ほどのものからさらに、
ClassBのコンストラクタ引数としてClassCに依存している形ですね。


```php.ClassA.php
class ClassA
{
    public function __construct(ClassB $classB)
    {
        \Log::info('ClassAインスタンス化完了');
    }
}
```

ClassAはさっきと同じ状態です。
　
　

```php.ClassB.php
class ClassB
{
    public function __construct(ClassC $classC)
    {
        \Log::info('ClassBインスタンス化完了');
    }
}
```

ClassBではコンストラクタ引数としてClassCを型宣言しておきます。
　
　

```php:ClassC.php
class ClassC
{
    public function __construct()
    {
        \Log::info('ClassCインスタンス化完了');
    }
}
```
ClassCは依存なし。

　

#### 現状の問題点
現状の`make()`メソッドの状態のままで
このClassAの依存解決をしようとしたらどうなるでしょうか。

```php:Main.php
$classA = $this->make(ClassA::class);
```

すると、
`Too few arguments to function App\Sample\ClassB::__construct()`
のエラーが発生します。

どこでエラーが発生したのか、
`make()`の中を見てみましょう。

```php:Main.php
public function make(string $className)
{
    $reflectionClass = new \ReflectionClass($className); // ClassAのリフレクションクラス作成
    $constructor = $reflectionClass->getConstructor();   // ClassAのコンストラクタ取得
    $parameters = $constructor->getParameters();         // コンストラクタの引数取得
    $parameter = $parameters[0];
    $parameterClassName = $parameter->getClass()->name;  // 引数で型宣言されているクラス名（ClassB）を取得
    $parameterInstance = new $parameterClassName;        // そのクラス（ClassB）をインスタンス化

    return new $className($parameterInstance);
}
```

エラーが発生したのはここですね。
`$parameterInstance = new $parameterClassName;        // そのクラス（ClassB）をインスタンス化`

ここで、ClassBのコンストラクタ引数としてClassCのインスタンスを渡さないといけないのに、
何も渡さずにnewしているのでエラーが発生しています。

ここを解消していきます。

#### 再帰的に`make()`させる
この問題を解消するのは簡単で、
`$parameterInstance = new $parameterClassName;`
ここで、型宣言されているクラスを`new`でインスタンス化していますが、
これを`make()`でインスタンス化すればいいだけです。


```php
$parameterInstance = new $parameterClassName;
// ↓↓変更
$parameterInstance = $this->make($parameterClassName);
```

この様にするだけです。

そうすることで、
ClassBもまた`make()`メソッドに投げられ、
引数であるClassCを依存解決したうえでインスタンス化して返ってきてくれます。

ただし、このままだとまだ１つ問題があるのでそこも修正しておきます。

再帰的に`make()`にクラスを渡すようにすると、
依存関係の最後にあたるClassCも`make()`メソッドに投げられることになります。

その時、ClassCにはコンストラクタの引数が何も指定されていない状態ですので、

```php
$parameters = $constructor->getParameters();
$parameter = $parameters[0];
```

この辺でパラメータが取得できないまま次の処理に行こうとして、
エラーが発生してしまいます。

なのでコンストラクタの引数がない場合は
そのまま対象クラスをインスタンス化して返却するようにしましょう。

```php:Main.php
public function make(string $className)
{
    $reflectionClass = new \ReflectionClass($className);
    $constructor = $reflectionClass->getConstructor();
    $parameters = $constructor->getParameters();
    // コンストラクタの引数がない場合はそのままインスタンス化して返却
    if (empty($parameters)) {
        return new $className;
    }
    $parameter = $parameters[0];
    $parameterClassName = $parameter->getClass()->name;
    $parameterInstance = $this->make($parameterClassName); // ここでnewではなくmake()する

    return new $className($parameterInstance);
}
```

これでエラーにならずに多階層の依存解決ができる状態になりました。

改めて、この自作`make()`メソッドを実行してみましょう。

```php:Main.php
$classA = $this->make(ClassA::class);

// laravel.log
// local.INFO: ClassCインスタンス化完了  
// local.INFO: ClassBインスタンス化完了  
// local.INFO: ClassAインスタンス化完了  
```

エラーが発生せず、
laravel.logにはちゃんとClassC→B→Aのインスタンスが作成されたログが出力されています。


`make()`内部では

* ClassAのリフレクションクラス作成
* ClassAのコンストラクタ取得
* コンストラクタの引数取得
* 引数で型宣言されているクラス名を取得
* そのクラス（ClassB）を`make()`に渡す
 * ClassBのリフレクションクラス作成
 * ClassBのコンストラクタ取得
 * コンストラクタの引数取得
 * 引数で型宣言されているクラス名を取得
 * そのクラス（ClassC）を`make()`に渡す
     * ClassCのリフレクションクラス作成
     * ClassCのコンストラクタ取得
     * コンストラクタの引数取得
     * 引数がないので、ClassCをインスタンス化して返却
 * そのClassCインスタンスを引数にしてClassBをインスタンス化
 * ClassBインスタンスを返却
* そのClassBインスタンスを引数にしてClassAをインスタンス化
* ClassAインスタンスを返却

という処理が行われたわけです。
　
　
これで、多階層の依存解決ができる`make()`メソッドを自作することができました。

# 本物の`make()`メソッド
多階層の依存解決ができる`make()`メソッドを自作しましたが、
本物の`make()`メソッドと比べるとまだまだたくさん足りない機能があります。

簡単なところで言うと
・引数が複数あった場合に対応していない
・引数にクラス以外があった場合に対応していない
など。

さらに複雑な機能で言うと
・bindでカスタマイズされたインスタンス化方法に対応していない
・クラス名ではなくインターフェース名を渡された場合に対応していない
などがありますね。

ただ、基本としてはこれまで解説したような仕組みが
本物の`make()`でも利用されています。

そのうえでさらに、上記のような様々なパターンに対応するための
複雑な条件分岐や処理がいろいろ追加されているイメージです。

これをきっかけに、本物の`make()`メソッドの
ソースコードを読み込んでみるとさらにLaravelへの理解が深まると思います。


# おわりに
サービスコンテナがどのように依存解決を行っているのか、
簡易版`make()`メソッドを自作することで確認してみました。

Laravelのソースコードでは、この`make()`メソッドがたくさん登場するので、
ぜひ読んでみてください。

そして、最初に話した「コンストラクターインジェクション」

>Laravelを使ってアプリケーションを実装するうえで、
最も便利だと感じる機能が、「コンストラクターインジェクション」です。

>クラスのコンストラクタの引数で、特定のクラスを型宣言しておくだけで、
自動的に引数としてそのクラスのインスタンスを渡してくれるという機能です。

いつもコントローラのコンストラクタ引数にクラス名を指定するだけで
勝手にインスタンスが取得できるという
あの便利な機能は、
サービスコンテナの`make()`メソッドが内部的に利用されていて、
その`make()`メソッドでは今回解説したリフレクション機能を利用して
実現されていたわけですね。


この
コントローラクラスを`make()`で依存解決している場所
を見てみたい場合は、
こちらの記事で解説しています。
[魔法のようなLaravelも素のPHPに始まり素のPHPに終わる。Laravelのライフサイクルを簡単に解説。](https://qiita.com/minato-naka/items/f05b023950ce544a8bec)

WEBサーバにリクエストが届いてから
コントローラクラスを`make()`する瞬間までの流れを見ることができるので、
本記事の後に読むと結構楽しいんじゃないかと思います。

Laravelのちょっと深いところを理解していきたいと思っている方、
これらの記事もおすすめですので是非読んでみてください。
（次に進む前に、LGTMしてもらえるとうれしいです）
[魔法のようなLaravelも素のPHPに始まり素のPHPに終わる。Laravelのライフサイクルを簡単に解説。](https://qiita.com/minato-naka/items/f05b023950ce544a8bec)
[【Laravel】サービスコンテナとは？２つの強力な武器を持ったインスタンス化マシーン。簡単に解説。](https://qiita.com/minato-naka/items/afa4b930a2afac23261b)
[【Laravel】引数でタイプヒントしただけでインスタンスがもらえるのはなぜ？Laravelの魔法を解明してみる。](https://qiita.com/minato-naka/items/a4531797af611688db97)
[【Laravel】ファサードとは？何が便利か？どういう仕組みか？](https://qiita.com/minato-naka/items/095f2a1beec1d09f423e)

# 参考
[【Laravel】サービスコンテナとは？２つの強力な武器を持ったインスタンス化マシーン。簡単に解説。](https://qiita.com/minato-naka/items/afa4b930a2afac23261b)
[魔法のようなLaravelも素のPHPに始まり素のPHPに終わる。Laravelのライフサイクルを簡単に解説。](https://qiita.com/minato-naka/items/f05b023950ce544a8bec)
https://blog.asial.co.jp/751
https://codezine.jp/article/detail/2011
https://www.php.net/manual/ja/book.reflection.php