总结一下 Spring的IOC、DI

淡淡的烟草味﹌ 2022-08-26 04:53 136阅读 0赞

国庆节刚过，应一些朋友的提问，总结一下Spring中IOC也即DI的通俗理解。

网友[wm5920][]解释：

IOC控制反转：说的是创建对象实例的控制权从代码控制剥离到IOC容器控制，实际就是你在xml文件控制，侧重于原理。  
  
DI依赖注入：说的是创建对象实例时，为这个对象注入属性值或其它对象实例，侧重于实现。

## IOC、DI模式 ##

### 1.依赖 ###

依赖就是有联系，有地方使用到它就是有依赖它，一个系统不可能完全避免依赖。如果你的一个类或者模块在项目中没有用到它，恭喜你，可以从项目中剔除它或者排除它了，因为没有一个地方会依赖它。下面看一个简单的示例：

**\[java\]**  [view plain][] [copy][view plain] [print][view plain] [?][view plain]

1.  /// <summary>  
2.      /// 用户播放媒体文件  
3.      /// </summary>  
4.      **public** **class** OperationMain  
5.      \{  
6.    
7.          **public** **void** playMedia()  
8.          \{  
9.              MediaFile \_mtype = **new** MediaFile();  
10.             Player \_player = **new** Player();  
11.   
12.             \_player.play(\_mtype);  
13.         \}  
14.     \}  
15.     /// <summary>  
16.     /// 播放器  
17.     /// </summary>  
18.     **public** **class** Player  
19.     \{  
20.         **public** **void** play(MediaFile file)\{ \}  
21.     \}  
22.     /// <summary>  
23.     /// 媒体文件  
24.     /// </summary>  
25.     **public** **class** MediaFile  
26.     \{    \}

上面是一个用户用播放器播放文件简单示例，用户操作是OperationMain类中的playMedia方法，打开一个播放器，选择一个文件来播放。先看看他们之间的依赖关系，可以简单找到有3个依赖

1.  **Player依赖MediaFile**
2.  **OperationMain依赖Player**
3.  **OperationMain依赖MediaFile**

### 2.依赖倒置 ###

需求增加了，要用不同的播放器，播放不同的文件，我们要抽象出来，减少耦合。

耦合关系就是依赖关系，如果依赖关系相当繁杂，牵一发而动全身，很难维护；依赖关系越少，耦合关系就越低，系统就越稳定，所以我们要减少依赖。

幸亏Robert Martin大师提出了面向对象设计原则----依赖倒置原则：

*  **A. 上层模块不应该依赖于下层模块，它们共同依赖于一个抽象。 　**
 *  **B. 抽象不能依赖于具象，具象依赖于抽象。**

理解：A.上层是使用者，下层是被使用者，这就导致的结果是上层依赖下层了，下层变动了，自然就会影响到上层了，导致系统不稳定，甚至是牵一发而动全身。那怎么减少依赖呢？就是上层和下层都去依赖另一个抽象，这个抽象比较稳定，整个就来说就比较稳定了。

B.面向对象编程时面向抽象或者面向借口编程，抽象一般比较稳定，实现抽象的具体肯定是要依赖抽象的，抽象不应该去依赖别的具体，应该依赖抽象。

上面播放器的示例中，我们已经找到依赖关系了，现在我们要按照依赖倒置原则，来进行优化。

根据原则如下改动：

*  **Player依赖MediaFile，好办，让Player和MediaFile都去依赖一个抽象IMediaFile**
 *  **OperationMain依赖Player，好办，让OperationMain和Player都依赖一个抽象IPlayer**
 *  **OperationMain依赖MediaFile，好办，让OperationMain和MediaFile都依赖一个抽象IMediaFile**
 *  **IPlayer不能依赖具体MediaFile，应该依赖于具体MediaFile的抽象IMediaFile**

![1349775057_8108.jpg][]

结构很简单，于是代码大致如下：

**\[java\]**  [view plain][] [copy][view plain] [print][view plain] [?][view plain]

1.  **package** ioc;  
2.    
3.  /\*\* 
4.   \* @author: 特种兵—AK47 
5.   \* @创建时间：2012-10-9 上午09:59:56 
6.   \*  
7.   \* @类说明 ：用户播放媒体文件 
8.   \*/  
9.  **public** **class** OperationMain \{  
10.     **public** **void** playMedia(IPlayer iplayer, IMediaFile imediaFile) \{  
11.         iplayer.play(imediaFile);  
12.     \}  
13. \}

**\[java\]**  [view plain][] [copy][view plain] [print][view plain] [?][view plain]

1.  **package** ioc;  
2.    
3.  /\*\* 
4.   \* @author: 特种兵—AK47 
5.   \* @创建时间：2012-10-9 上午10:03:23 
6.   \*  
7.   \* @类说明 ：要播放的媒体文件 
8.   \*/  
9.  **public** **interface** IMediaFile \{  
10.   
11.     **public** **void** getSetPath();  
12.   
13. \}

**\[java\]**  [view plain][] [copy][view plain] [print][view plain] [?][view plain]

1.  **package** ioc;  
2.    
3.  /\*\* 
4.   \* @author: 特种兵—AK47 
5.   \* @创建时间：2012-10-9 上午10:03:39 
6.   \*  
7.   \* @类说明 ： 
8.   \*/  
9.  **public** **class** Mp3File **implements** IMediaFile \{  
10.   
11.     @Override  
12.     **public** **void** getSetPath() \{  
13.         // TODO Auto-generated method stub  
14.         System.out.println("播放 \[Mp3\] 格式的文件");  
15.     \}  
16.   
17. \}

**\[java\]**  [view plain][] [copy][view plain] [print][view plain] [?][view plain]

1.  **package** ioc;  
2.    
3.  /\*\* 
4.   \* @author: 特种兵—AK47 
5.   \* @创建时间：2012-10-9 上午10:03:39 
6.   \*  
7.   \* @类说明 ： 
8.   \*/  
9.  **public** **class** Mp4File **implements** IMediaFile \{  
10.   
11.     @Override  
12.     **public** **void** getSetPath() \{  
13.         // TODO Auto-generated method stub  
14.         System.out.println("播放 \[Mp4\] 格式的文件");  
15.     \}  
16.   
17. \}

**\[java\]**  [view plain][] [copy][view plain] [print][view plain] [?][view plain]

1.  **package** ioc;  
2.    
3.  /\*\* 
4.   \* @author: 特种兵—AK47 
5.   \* @创建时间：2012-10-9 上午10:02:41 
6.   \*  
7.   \* @类说明 ：播放组件的抽象类 
8.   \*/  
9.  **public** **interface** IPlayer \{  
10.   
11.     **public** **void** play(IMediaFile imediaFile);  
12.   
13. \}

**\[java\]**  [view plain][] [copy][view plain] [print][view plain] [?][view plain]

1.  **package** ioc;  
2.    
3.  /\*\* 
4.   \* @author: 特种兵—AK47 
5.   \* @创建时间：2012-10-9 上午10:02:59 
6.   \*  
7.   \* @类说明 ： 
8.   \*/  
9.  **public** **class** Player **implements** IPlayer \{  
10.   
11.     @Override  
12.     **public** **void** play(IMediaFile imediaFile) \{  
13.         imediaFile.getSetPath();  
14.     \}  
15.   
16. \}

测试程序：

**\[java\]**  [view plain][] [copy][view plain] [print][view plain] [?][view plain]

1.  **package** ioc;  
2.    
3.  **import** org.junit.Test;  
4.    
5.  /\*\* 
6.   \* @author: 特种兵—AK47 
7.   \* @创建时间：2012-10-9 上午10:08:25 
8.   \*  
9.   \* @类说明 ： 
10.  \*/  
11. **public** **class** IocTest \{  
12.   
13.     @Test  
14.     **public** **void** testIoc() \{  
15.         OperationMain opmn = **new** OperationMain();  
16.         opmn.playMedia(**new** Player(), **new** Mp3File());  
17.         opmn.playMedia(**new** Player(), **new** Mp4File());  
18.     \}  
19. \}

运行一下：

**\[html\]**  [view plain][] [copy][view plain] [print][view plain] [?][view plain]

1.  播放 \[Mp3\] 格式的文件  
2.  播放 \[Mp4\] 格式的文件

上面代码进行了抽象，可以看到，目的是减少了依赖，但是看上去依赖关系增加了，如用户PlayMedia方法，依赖还增加了依赖接口和具体的实现，但是接口是稳定的，可以不考虑，具体的实现才是变动的，这个依赖还是要的，要播放文件，必定要用到具体的播放器和具体文件。

### 3.控制反转(IoC)/依赖注入(DI) ###

强调一下，IOC跟DI要表达的是一个意思

现实生活中，是具体的播放器和具体的媒体文件没有关系，你给它一个Mp3文件他可以播放，给它一个Mp4文件它也可以播放，你删掉你的媒体文件，播放器照样在，具体什么播放器，播放什么文件，控制权全部是我们用户自己。

上面的示例中基本实现了隔离，具体的播放器跟具体的媒体隔离了，具体的播放器只跟媒体接口和播放器接口有关。但是PlayMedia的方法里面的具体对象，写死了，控制权非常小，如果我想用百度影音播放呢，我想换一首音乐呢，只能重新改代码，那控制怎么进行转移呢？

我们可以通过反射来创建，把具体的文件名写在配置文件里，这时候客户端代码也不用变了，只需要改配置文件就好了，稳定性又有了提高，如下：

**\[java\]**  [view plain][] [copy][view plain] [print][view plain] [?][view plain]

1.  **public** **void** PlayMedia() \{  
2.      IMediaFile \_mtype = Assembly.Load(ConfigurationManager.AppSettings\["AssemName"\]).CreateInstance(ConfigurationManager.AppSettings\["MediaName"\]);  
3.      IPlayer \_player = Assembly.Load(ConfigurationManager.AppSettings\["AssemName"\]).CreateInstance(ConfigurationManager.AppSettings\["PlayerName"\]);  
4.    
5.      \_player.Play(\_mtype);  
6.  \}

这个具对象是哪一个，全由配置文件来控制了，这个具体对象的控制权交给了配置文件了，这也是人们常说的控制反转。

控制反转IoC是Inversion of Control的缩写，是说对象的控制权进行转移，转移到第三方，比如转移交给了IoC容器，它就是一个创建工厂，你要什么对象，它就给你什么对象，有了IoC容器，依赖关系就变了，原先的依赖关系就没了，它们都依赖IoC容器了，通过IoC容器来建立它们之间的关系。

[wm5920]: http://blog.csdn.net/wm5920
[view plain]: http://blog.csdn.net/m13666368773/article/details/8053138#
[1349775057_8108.jpg]: https://img-my.csdn.net/uploads/201210/09/1349775057_8108.jpg