（转） 控制反转（IOC）/依赖注入（DI）

[java] view plain copy print ?

1. ///<summary>
2. ///用户播放媒体文件
3. ///</summary>
4. publicclassOperationMain
5. {
7. publicvoidplayMedia()
8. {
9. MediaFile_mtype=newMediaFile();
10. Player_player=newPlayer();
12. _player.play(_mtype);
13. }
14. }
15. ///播放器
16. publicclassPlayer
17. publicvoidplay(MediaFilefile){}
18. ///<summary>
19. ///媒体文件
20. ///</summary>
21. publicclassMediaFile
22. {}

上面是一个用户用播放器播放文件简单示例，用户操作是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

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

?

packageioc;
1. /**
2. *@author:特种兵—AK47
3. *@创建时间：2012-10-9上午09:59:56
4. *
5. *@类说明：用户播放媒体文件
6. */
7. publicclassOperationMain{
8. publicvoidplayMedia(IPlayeriplayer,IMediaFileimediaFile){
9. iplayer.play(imediaFile);
10. }

?

*@创建时间：2012-10-9上午10:03:23
1. *@类说明：要播放的媒体文件
2. publicinterfaceIMediaFile{
3. publicvoidgetSetPath();
4. }

?

*@创建时间：2012-10-9上午10:03:39
1. *@类说明：
2. publicclassMp3FileimplementsIMediaFile{
3. @Override
4. publicvoidgetSetPath(){
5. //TODOAuto-generatedmethodstub
6. System.out.println("播放[Mp3]格式的文件");
7. }

?

publicclassMp4FileimplementsIMediaFile{
1. System.out.println("播放[Mp4]格式的文件");
2. ?
   *@创建时间：2012-10-9上午10:02:41
   1. *@类说明：播放组件的抽象类
   2. publicinterfaceIPlayer{
   3. publicvoidplay(IMediaFileimediaFile);
   4. ?
      *@创建时间：2012-10-9上午10:02:59
      1. publicclassPlayerimplementsIPlayer{
      2. publicvoidplay(IMediaFileimediaFile){
      3. imediaFile.getSetPath();
      4. }

      测试程序：

      ?
      importorg.junit.Test;
      1. *@创建时间：2012-10-9上午10:08:25
      2. publicclassIocTest{
      3. @Test
      4. publicvoidtestIoc(){
      5. OperationMainopmn=newOperationMain();
      6. opmn.playMedia(newPlayer(),newMp3File());
      7. opmn.playMedia(newPlayer(),newMp4File());
      8. }

      运行一下：

      [html] ?
      播放[Mp3]格式的文件
      1. 播放[Mp4]格式的文件

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

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

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

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

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

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

      ?
      publicvoidPlayMedia(){
      1. IMediaFile_mtype=Assembly.Load(ConfigurationManager.AppSettings["AssemName"]).CreateInstance(ConfigurationManager.AppSettings["MediaName"]);
      2. IPlayer_player=Assembly.Load(ConfigurationManager.AppSettings["AssemName"]).CreateInstance(ConfigurationManager.AppSettings["PlayerName"]);
      3. _player.Play(_mtype);
      4. }

      
      

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

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

      
      

      
      

      原文：

      （编辑：安卓应用网）

      【声明】本站内容均来自网络，其相关言论仅代表作者个人观点，不代表本站立场。若无意侵犯到您的权利，请及时与联系站长删除相关内容!