本文實例講述了Laravel實現構造函數自動依賴注入的方法。分享給大家供大家參考，具體如下：
在Laravel的構造函數中可以實現自動依賴注入，而不需要實例化之前先實例化需要的類，如代碼所示：
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
|
<?phpnamespace Lio\Http\Controllers\Forum;use Lio\Forum\Replies\ReplyRepository;use Lio\Forum\Threads\ThreadCreator;use Lio\Forum\Threads\ThreadCreatorListener;use Lio\Forum\Threads\ThreadDeleterListener;use Lio\Forum\Threads\ThreadForm;use Lio\Forum\Threads\ThreadRepository;use Lio\Forum\Threads\ThreadUpdaterListener;use Lio\Http\Controllers\Controller;use Lio\Tags\TagRepository;class ForumThreadsController extends Controller implements ThreadCreatorListener, ThreadUpdaterListener, ThreadDeleterListener{ protected $threads; protected $tags; protected $currentSection; protected $threadCreator; public function __construct( ThreadRepository $threads, ReplyRepository $replies, TagRepository $tags, ThreadCreator $threadCreator ) { $this->threads = $threads; $this->tags = $tags; $this->threadCreator = $threadCreator; $this->replies = $replies; }} |
注意構造函數中的幾個類型約束，其實并沒有地方實例化這個Controller并把這幾個類型的參數傳進去，Laravel會自動檢測類的構造函數中的類型約束參數，并自動識別是否初始化并傳入。
源碼vendor/illuminate/container/Container.php中的build方法：
|
1
2
|
$constructor = $reflector->getConstructor();dump($constructor); |
這里會解析類的構造函數，在這里打印看：
它會找出構造函數的參數，再看完整的build方法進行的操作：
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
|
public function build($concrete, array $parameters = []){ // If the concrete type is actually a Closure, we will just execute it and // hand back the results of the functions, which allows functions to be // used as resolvers for more fine-tuned resolution of these objects. if ($concrete instanceof Closure) { return $concrete($this, $parameters); } $reflector = new ReflectionClass($concrete); // If the type is not instantiable, the developer is attempting to resolve // an abstract type such as an Interface of Abstract Class and there is // no binding registered for the abstractions so we need to bail out. if (! $reflector->isInstantiable()) { $message = "Target [$concrete] is not instantiable."; throw new BindingResolutionContractException($message); } $this->buildStack[] = $concrete; $constructor = $reflector->getConstructor(); // If there are no constructors, that means there are no dependencies then // we can just resolve the instances of the objects right away, without // resolving any other types or dependencies out of these containers. if (is_null($constructor)) { array_pop($this->buildStack); return new $concrete; } $dependencies = $constructor->getParameters(); // Once we have all the constructor's parameters we can create each of the // dependency instances and then use the reflection instances to make a // new instance of this class, injecting the created dependencies in. $parameters = $this->keyParametersByArgument( $dependencies, $parameters ); $instances = $this->getDependencies( $dependencies, $parameters ); array_pop($this->buildStack); return $reflector->newInstanceArgs($instances);} |
具體從容器中獲取實例的方法：
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
|
protected function resolveClass(ReflectionParameter $parameter){ try { return $this->make($parameter->getClass()->name); } // If we can not resolve the class instance, we will check to see if the value // is optional, and if it is we will return the optional parameter value as // the value of the dependency, similarly to how we do this with scalars. catch (BindingResolutionContractException $e) { if ($parameter->isOptional()) { return $parameter->getDefaultValue(); } throw $e; }} |
框架底層通過Reflection反射為開發節省了很多細節，實現了自動依賴注入。這里不做繼續深入研究了。
寫了一個模擬這個過程的類測試：
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
|
<?phpclass kulou{ //}class junjun{ //}class tanteng{ private $kulou; private $junjun; public function __construct(kulou $kulou,junjun $junjun) { $this->kulou = $kulou; $this->junjun = $junjun; }}//$tanteng = new tanteng(new kulou(),new junjun());$reflector = new ReflectionClass('tanteng');$constructor = $reflector->getConstructor();$dependencies = $constructor->getParameters();print_r($dependencies);exit; |
原理是通過ReflectionClass類解析類的構造函數，并且取出構造函數的參數，從而判斷依賴關系，從容器中取，并自動注入。
轉自：小談博客 http://www.tantengvip.com/2016/01/laravel-construct-ioc/
希望本文所述對大家基于Laravel框架的PHP程序設計有所幫助。
