在本篇文章里小编给大家分享的是一篇关于PHP依赖注入容器知识点内容，有兴趣的朋友们可以学习下。

依赖注入容器理解

耦合

一个好的代码结构设计一定是松耦合的，这也是很多通用设计模式的宗旨，就是把分散在各处的同一个功能的代码汇聚到一起，形成一个模块，然后在不同模块之间通过一些细小的、明确的渠道进行沟通。

在实践中，不同功能和模块之间的互相依赖是不可避免的，而如何处理好这些依赖之间的关系则是代码结构能否变得美好的关键。

1. <?php 
2.  
3. class User 
4.  
5. { 
6.  
7.   public function register($user) 
8.  
9.   { 
10.  
11.     // 注册操作 
12.  
13.     ... 
14.  
15.    
16.  
17.     // 发送确认邮件 
18.  
19.     $notify = new Notify(); 
20.  
21.     $notify->sendEmail('register', $user); 
22.  
23.   } 
24.  
25. } 
26.  
27.    
28.  
29. class Notify 
30.  
31. { 
32.  
33.   public function sendEmail($type, $data) 
34.  
35.   { 
36.  
37.     switch $type { 
38.  
39.       case 'register': 
40.  
41.         // 发送注册确认邮件 
42.  
43.         $email = new Email($type); 
44.  
45.         $email->send($data); 
46.  
47.       ... 
48.  
49.     } 
50.  
51.   } 
52.  
53. } 
54.  
55.    
56.  
57. class Email 
58.  
59. { 
60.  
61.   public function send($data) 
62.  
63.   { 
64.  
65.     // 发送邮件 
66.  
67.   } 
68.  
69. } 

上述代码中，三个类之间逐层依赖，三个类实例化的顺序是 User -> Notify -> Email

也就是说我先实例化User类，可能执行了一些代码之后再去实例化我需要的其他类，比如Notify，以此类推。

这种依赖会让我们不得不为了得到需要的依赖而去做的一些准备工作，有时候可能一个new操作还不够。而这部分工作就是所说的耦合，他会让一个独立功能的类不得不去关心一些和自己的主体功能没什么关系的操作。

解除一个类对其他类的依赖

要解决这个问题也很简单，我可以先实例化好Email类，然后再实例化Notify，然后把Email对象作为参数传给Notify，最后实例化User类，然后把Notify传进去。这就是所谓的依赖注入，可以看到这个过程中类实例化的顺序完全反过来了，先实例化被依赖的对象，而不是先实例化最终需要的对象，这是控制反转。

代码如下：

1. <?php 
2.  
3. $email = new Email(); 
4.  
5. $notify = new Notify($email); 
6.  
7. $user = new User($notify); 

可以通过构造函数来注入需要的依赖，也可以用一些其他的方法。

用容器托管依赖

那又有新的问题，例子中只有三个类还好，那如果这个User类依赖Notify来发邮件，依赖Model来存数据库，依赖redis来缓存，这样固然把依赖关系转移到了类的外部，但还是会导致我只想实例化一下User的时候，却要手动做很多的准备工作，会让代码混乱，所以这个时候需要一个容器。而这个容器的作用就是替我来管理这些依赖。

1. <?php 
2.  
3. // 容器 
4.  
5. class Container implements ArrayAccess 
6.  
7. { 
8.  
9.   protected $values = []; 
10.  
11.    
12.  
13.   public function offsetGet($offset)  
14.  
15.   { 
16.  
17.     return $this->values[$offset]($this); 
18.  
19.   } 
20.  
21.   public function offsetSet($offset, $value)  
22.  
23.   { 
24.  
25.     $this->values[$offset] = $value; 
26.  
27.   } 
28.  
29. } 

在程序启动的时候，我们可以在一个地方统一的注册好一系列的基础服务。

1. <?php 
2.  
3. $container = new Container(); 
4.  
5. $container['notify'] = function($c) { 
6.  
7.   return new Notify(); 
8.  
9. }; 
10.  
11. $container['email'] = function($c) { 
12.  
13.   return new Email(); 
14.  
15. }; 

就会变成这样

1. <?php 
2.  
3. class User 
4.  
5. { 
6.  
7.   public function register($user) 
8.  
9.   { 
10.  
11.     // 注册操作 
12.  
13.     ... 
14.  
15.    
16.  
17.     // 发送确认邮件 
18.  
19.     $container('notify')->sendEmail('register', $user); 
20.  
21.   } 
22.  
23. } 
24.  
25.    
26.  
27. class Notify 
28.  
29. { 
30.  
31.   public function sendEmail($type, $data) 
32.  
33.   { 
34.  
35.     switch $type { 
36.  
37.       case 'register': 
38.  
39.         // 发送注册确认邮件 
40.  
41.         $email = $container['email']; 
42.  
43.         $email->send($data); 
44.  
45.       ... 
46.  
47.     } 
48.  
49.   } 
50.  
51. } 
52.  
53.    
54.  
55. class Email 
56.  
57. { 
58.  
59.   public function send($data) 
60.  
61.   { 
62.  
63.     // 发送邮件 
64.  
65.   } 
66.  
67. } 

就是当User需要Notify的时候，会去向容器要这个类的对象，那至于Notify再依赖什么其他的东西，我就不用管了，因为Notify也会去向容器要它自己需要的依赖。所有这些依赖关系的处理就完全托管给容器了，我们既不需要去关心依赖之间的层次关系，也避免了依赖之间的耦合。

需要注意的是，依赖注入容器一般只接受一个匿名函数，而不是一个实例化好的对象，匿名函数会告诉容器怎样去获得一个对象，这样可以使得一个服务在被需要的时候才会去实例化。

Tags: PHP依赖注入 PHP容器

分享到：