总结一下 Spring的IOC、DI

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

网友wm5920解释:

IOC控制反转:说的是创建对象实例的控制权从代码控制剥离到IOC容器控制,实际就是你在xml文件控制,侧重于原理。

DI依赖注入:说的是创建对象实例时,为这个对象注入属性值或其它对象实例,侧重于实现。

 

IOC、DI模式

1.依赖

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

[java]  view plain copy print ?
  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

总结一下 Spring的IOC、DI_第1张图片

结构很简单,于是代码大致如下:

 

[java]  view plain copy print ?
  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 print ?
  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 print ?
  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 print ?
  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 print ?
  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 print ?
  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 print ?
  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 print ?
  1. 播放 [Mp3] 格式的文件  
  2. 播放 [Mp4] 格式的文件  

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

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

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

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

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

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

[java]  view plain copy print ?
  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容器来建立它们之间的关系。

你可能感兴趣的:(总结一下 Spring的IOC、DI)