PHP依赖注入的详细介绍（附示例）

本篇文章给大家带来的内容是关于PHP依赖注入的详细介绍（附示例），有一定的参考价值，有需要的朋友可以参考一下，希望对你有所帮助。

依赖注入

传统的思路

应用程序用到一个Foo类,就会创建Foo类并调用Foo类的方法。

假如这个方法内需要一个Bar类,就会创建Bar类并调用Bar类的方法。

而这个方法内需要一个Bim类,就会创建Bim类,接着做些其它工作。

1. /** 
2.  
3. *  Foo 
4.  
5. */ 
6.  
7. class Foo  
8.  
9. { 
10.  
11.  
12.  
13.     public function doSomething($value='') 
14.  
15.     { 
16.  
17.         # code... 
18.  
19.         $Bar = new Bar(); 
20.  
21.         $Bar->doSomething(); 
22.  
23.         echo 'Foo doSomething','<br />' ; 
24.  
25.     } 
26.  
27. } 
28.  
29.  
30.  
31. /** 
32.  
33. *  Bar 
34.  
35. */ 
36.  
37. class Bar  
38.  
39. { 
40.  
41.       
42.  
43.  
44.  
45.     public function doSomething($value='') 
46.  
47.     { 
48.  
49.         # code... 
50.  
51.         $Bim = new Bim(); 
52.  
53.         $Bim->doSomething(); 
54.  
55.         echo 'Bar doSomething','<br />' ; 
56.  
57.     } 
58.  
59. } 
60.  
61.  
62.  
63. /** 
64.  
65. * Bim 
66.  
67. */ 
68.  
69. class Bim 
70.  
71. { 
72.  
73.       
74.  
75.  
76.  
77.     public function doSomething($value='') 
78.  
79.     { 
80.  
81.         # code... 
82.  
83.         echo 'Bim doSomething','<br />'  ; 
84.  
85.     } 
86.  
87. } 
88.  
89. //Vevb.com 
90.  
91. $doSomething = new Foo(); 
92.  
93. $doSomething->doSomething(); 

依赖注入

应用程序用到Foo类，Foo类需要Bar类，Bar类需要Bim类，那么先创建Bim类，再创建Bar类并把Bim注入，再创建Foo类，并把Bar类注入，再调用Foo方法，Foo调用Bar方法，接着做些其它工作。

1. /** 
2.  
3. * Bim2 
4.  
5. */ 
6.  
7. class Bim2  
8.  
9. { 
10.  
11.       
12.  
13.     public function doSomething($value='') 
14.  
15.     { 
16.  
17.         # code... 
18.  
19.         echo 'Bim2 doSomething','<br />' ; 
20.  
21.     } 
22.  
23.  
24.  
25. } 
26.  
27.  
28.  
29. /** 
30.  
31. *  Bar2 
32.  
33. */ 
34.  
35. class Bar2 
36.  
37. { 
38.  
39.  
40.  
41.     private $bim2 ; 
42.  
43.  
44.  
45.     public function __construct(Bim2 $bim2) 
46.  
47.     { 
48.  
49.         # code... 
50.  
51.         $this->bim2 = $bim2 ; 
52.  
53.     } 
54.  
55.  
56.  
57.     public function doSomething($value='') 
58.  
59.     { 
60.  
61.         # code... 
62.  
63.         $this->bim2->doSomething(); 
64.  
65.         echo "Bar2 doSomething",'<br />'; 
66.  
67.     } 
68.  
69. } 
70.  
71.  
72.  
73. /** 
74.  
75. * Foo 
76.  
77. */ 
78.  
79. class Foo2 
80.  
81. { 
82.  
83.       
84.  
85.     private $bar2 ; 
86.  
87.     public function __construct(Bar2 $bar2) 
88.  
89.     { 
90.  
91.         # code... 
92.  
93.         $this->bar2 = $bar2 ; 
94.  
95.     } 
96.  
97.  
98.  
99.     public function doSomething($value='') 
100.  
101.     { 
102.  
103.         # code... 
104.  
105.         $this->bar2->doSomething(); 
106.  
107.         echo "Foo2 doSomething",'<br />'; 
108.  
109.     } 
110.  
111. } 
112.  
113. //Vevb.com 
114.  
115. $doSomething2 = new Foo2(new Bar2(new Bim2())); 
116.  
117. $doSomething2->doSomething(); 

这就是控制反转模式。依赖关系的控制反转到调用链的起点。这样你可以完全控制依赖关系，通过调整不同的注入对象，来控制程序的行为。

例如Foo类用到了memcache，可以在不修改Foo类代码的情况下，改用redis。

使用依赖注入容器后的思路是应用程序需要到Foo类，就从容器内取得Foo类，容器创建Bim类，再创建Bar类并把Bim注入，再创建Foo类，并把Bar注入，应用程序调用Foo方法，Foo调用Bar方法，接着做些其它工作.

扩展:容器负责实例化，注入依赖，处理依赖关系等工作。