IoC 控制反转

IoC基本理解

IoC，Inversion Of Control 控制反转，是一种设计模式，主要用于降低程序之间的耦合性，提高代码质量。

简单说，IoC，就是将控制权由原来的代码转移到了容器，由外部容器提供需要的对象及组件，也就是控制反转了。

IoC分析

下面引用一个例子来说明一下

依赖

依赖就是有联系，程序之间当然存在着各种各样的联系，不然，就可以把它干掉了。
下面是例子：

<span style="font-family:Microsoft YaHei;font-size:14px;">/// 用户播放媒体文件    /// </summary>    public class OperationMain    {        public void PlayMedia()        {            MediaFile _mtype = new MediaFile();            Player _player = new Player();            _player.Play(_mtype);        }    }    /// <summary>    /// 播放器    /// </summary>    public class Player    {        public void Play(MediaFile file)        {            Console.WriteLine(file.FilePath);        }    }    /// <summary>    /// 媒体文件    /// </summary>    public class MediaFile    {        public string FilePath { get; set; }    }</span>

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

3.OperationMain依赖MediaFile

依赖倒置

当我们的需求变化后，要播放更多的广场舞，使用更多种类的大喇叭，这时显然我们的程序就不适用了，那咋办，只能更改代码了... 当然，是更改代码的设计，将各类广场舞及各式各样的大喇叭抽象出来就好，这样就不用担心到底是需要播放《小苹果》还是《最炫名族风》了，就算以后又出了一首神曲，也可以解决了，，等等，好像还解决不了。。暂时先解决已有神曲的问题吧。
依赖倒置遵循两个原则：
1.上次模块不依赖下层模块，依赖于抽象
2.抽象不依赖于具体，具体依赖于抽象
续上例，遵循规则，我们需要添加几个抽象借口
Player依赖MediaFile，好办，让Player和MediaFile都去依赖一个抽象IMediaFile
OperationMain依赖Player，好办，让OperationMain和Player都依赖一个抽象IPlayer
OperationMain依赖MediaFile，好办，让OperationMain和MediaFile都依赖一个抽象IMediaFile
IPlayer不能依赖具体MediaFile，应该依赖于具体MediaFile的抽象IMediaFile

<span style="font-family:Microsoft YaHei;font-size:14px;">    /// 用户播放媒体文件    /// </summary>    public class OperationMain    {        public void PlayMedia()        {            IMediaFile _mtype = new MediaFile();            IPlayer _player = new Player();            _player.Play(_mtype);        }    }    /// <summary>    /// 播放器    /// </summary>    public interface IPlayer    {        void Play(IMediaFile file);    }    /// <summary>    /// 默认播放器    /// </summary>    public class Player : IPlayer    {        public void Play(IMediaFile file)        {            Console.WriteLine(file.FilePath);        }    }    /// <summary>    /// 媒体文件    /// </summary>    public interface IMediaFile    {        string FilePath { get; set; }    }    /// <summary>    /// 默认媒体文件    /// </summary>    public class MediaFile : IMediaFile    {        public string FilePath { get; set; }    }</span>

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

控制反转

这时，我们就应该考虑一下，如果以后再出一些神曲，我们的播放器是否能够很快捷的适应它呢，要做到无论是何种曲目，要求使用哪种播放器，我们要有足够的控制权，实现控制的反转。
我们可以通过反射来创建，把具体的文件名写在配置文件里，这时候客户端代码也不用变了，只需要改配置文件就好了，稳定性又有了提高，如下：  

<span style="font-family:Microsoft YaHei;font-size:14px;">  {            IMediaFile _mtype = Assembly.Load(ConfigurationManager.AppSettings["AssemName"]).CreateInstance(ConfigurationManager.AppSettings["MediaName"]);            IPlayer _player = Assembly.Load(ConfigurationManager.AppSettings["AssemName"]).CreateInstance(ConfigurationManager.AppSettings["PlayerName"]);            _player.Play(_mtype);        }</span>

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

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

依赖注入

上面说到控制反转，是一个思想概念，但是也要具体实现的，上面的配置文件也是一种实现方式。依赖注入提出了具体的思想。
依赖注入DI是Dependency Injection缩写，它提出了“哪些东东的控制权被反转了，被转移了？”，它也给出了答案：“依赖对象的创建获得被反转”。
所谓依赖注入，就是由IoC容器在运行期间，动态地将某种依赖关系注入到对象之中。
上面的示例中，哪些要依赖注入，依赖对象需要获得实例的地方，即 PlayMedia方法，需要IPlayer具体对象和IMediaFile的具体对象，找到了地方就从这里下手，为了灵活的控制这两个对象，必须是外面能够控制着两个对象的实例化，提供对外的操作是必要的，可以是属性，可以是方法，可以是构造函数，总之别的地方可以控制它，下面将会使用Unity来注入，使用的是构造函数注入，代码如下：

<span style="font-family:Microsoft YaHei;font-size:14px;">/// 用户播放媒体文件    /// </summary>    public class OperationMain    {        IMediaFile _mtype;        IPlayer _player;        public OperationMain(IPlayer player, IMediaFile mtype)        {            _player = player;            _mtype = mtype;        }        public void PlayMedia()        {            _player.Play(_mtype);        }    }    /// <summary>    /// 播放器    /// </summary>    public interface IPlayer    {        void Play(IMediaFile file);    }    /// <summary>    /// 默认播放器    /// </summary>    public class Player : IPlayer    {        public void Play(IMediaFile file)        {            Console.WriteLine(file.FilePath);        }    }    /// <summary>    /// 媒体文件    /// </summary>    public interface IMediaFile    {        string FilePath { get; set; }    }    /// <summary>    /// 默认媒体文件    /// </summary>    public class MediaFile : IMediaFile    {        public string FilePath { get; set; }    }</span>

给 OperationMain类一个构造函数，因为Unity有一个构造函数注入，调用代码如下： 

<span style="font-family:Microsoft YaHei;font-size:14px;"> static void init()        {            container.RegisterType<IPlayer, Player>();            container.RegisterType<IMediaFile, MediaFile>();        }        static void Main(string[] args)        {            init();            OperationMain op1 = container.Resolve<OperationMain>();            op1.PlayMedia();            OperationMain op3 = container.Resolve<OperationMain>();            op3.PlayMedia();            //普通方式            OperationMain op2 = new OperationMain(new Player(), new MediaFile());            op2.PlayMedia();            Console.Read();        }</span>

IoC的实地应用

IoC在Spring中四种注入方式，Spring框架的的核心就是IoC

1.setter注入

是最简单的注入，刚学J2EE时就用过，但当时不理解Spring的编程思想...
现有一SpringAction类，类中需要实例化一个SpringDao对象，那么就可以定义一个private的SpringService成员变量，然后创建SpringDao的set方法（这是ioc的注入入口）：

<span style="font-family:Microsoft YaHei;font-size:14px;">public class SpringAction {          //注入对象springDao      private SpringDao springDao;          //一定要写被注入对象的set方法          public void setSpringDao(SpringDao springDao) {          this.springDao = springDao;      }            public void ok(){          springDao.ok();      }  }  </span>

随后编写spring的xml文件，<bean>中的name属性是class属性的一个别名，class属性指类的全名，因为在SpringAction中有一个公共属性Springdao，所以要在<bean>标签中创建一个<property>标签指定SpringDao。<property>标签中的name就是SpringAction类中的SpringDao属性名，ref指下面<bean name="springDao"...>，这样其实是spring将SpringDaoImpl对象实例化并且调用SpringAction的setSpringDao方法将SpringDao注入：   

<span style="font-family:Microsoft YaHei;font-size:14px;"><bean name="springAction" class="com.bless.springdemo.action.SpringAction">          <!--(1)依赖注入,配置当前类中相应的属性-->          <property name="springDao" ref="springDao"></property>      </bean>  <bean name="springDao" class="com.bless.springdemo.dao.impl.SpringDaoImpl"></bean>  </span>

2.构造器注入

这种方式的注入是指带有参数的构造函数注入，看下面的例子，我创建了两个成员变量SpringDao和User，但是并未设置对象的set方法，所以就不能支持第一种注入方式，这里的注入方式是在SpringAction的构造函数中注入，也就是说在创建SpringAction对象时要将SpringDao和User两个参数值传进来：    

<span style="font-family:Microsoft YaHei;font-size:14px;">//注入对象springDao      private SpringDao springDao;      private User user;            public SpringAction(SpringDao springDao,User user){          this.springDao = springDao;          this.user = user;          System.out.println("构造方法调用springDao和user");      }                    public void save(){          user.setName("卡卡");          springDao.save(user);      }  }  </span>

在XML文件中同样不用<property>的形式，而是使用<constructor-arg>标签，ref属性同样指向其它<bean>标签的name属性：   

<span style="font-family:Microsoft YaHei;font-size:14px;"><bean name="springAction" class="com.bless.springdemo.action.SpringAction">          <!--(2)创建构造器注入,如果主类有带参的构造方法则需添加此配置-->          <constructor-arg ref="springDao"></constructor-arg>          <constructor-arg ref="user"></constructor-arg>      </bean>          <bean name="springDao" class="com.bless.springdemo.dao.impl.SpringDaoImpl"></bean>           <bean name="user" class="com.bless.springdemo.vo.User"></bean>  解决构造方法参数的不确定性，你可能会遇到构造方法传入的两参数都是同类型的，为了分清哪个该赋对应值，则需要进行一些小处理：下面是设置index，就是参数位置：        <constructor-arg index="0" ref="springDao"></constructor-arg>          <constructor-arg index="1" ref="user"></constructor-arg>      </bean>  </span>

另一种是设置参数类型：

<constructor-arg type="java.lang.String" ref=""/> 

3.静态工厂的方法注入

静态工厂顾名思义，就是通过调用静态工厂的方法来获取自己需要的对象，为了让spring管理所有对象，我们不能直接通过"工程类.静态方法()"来获取对象，而是依然通过spring注入的形式获取：

<span style="font-family:Microsoft YaHei;font-size:14px;">import com.bless.springdemo.dao.FactoryDao;  import com.bless.springdemo.dao.impl.FactoryDaoImpl;  import com.bless.springdemo.dao.impl.StaticFacotryDaoImpl;    public class DaoFactory {      //静态工厂      public static final FactoryDao getStaticFactoryDaoImpl(){          return new StaticFacotryDaoImpl();      }  }  </span>

同样看关键类，这里我需要注入一个FactoryDao对象，这里看起来跟第一种注入一模一样，但是看随后的xml会发现有很大差别:   

<span style="font-family:Microsoft YaHei;font-size:14px;"> //注入对象      private FactoryDao staticFactoryDao;            public void staticFactoryOk(){          staticFactoryDao.saveFactory();      }      //注入对象的set方法      public void setStaticFactoryDao(FactoryDao staticFactoryDao) {          this.staticFactoryDao = staticFactoryDao;      }  }  </span>

Spring的IOC配置文件，注意看<bean name="staticFactoryDao">指向的class并不是FactoryDao的实现类，而是指向静态工厂DaoFactory，并且配置 factory-method="getStaticFactoryDaoImpl"指定调用哪个工厂方法：

<span style="font-family:Microsoft YaHei;font-size:14px;"><bean name="springAction" class="com.bless.springdemo.action.SpringAction" >          <!--(3)使用静态工厂的方法注入对象,对应下面的配置文件(3)-->          <property name="staticFactoryDao" ref="staticFactoryDao"></property>                  </property>      </bean>      <!--(3)此处获取对象的方式是从工厂类中获取静态方法-->      <bean name="staticFactoryDao" class="com.bless.springdemo.factory.DaoFactory" factory-method="getStaticFactoryDaoImpl"></bean> </span>

4.实例工厂的方法注入

实例工厂的意思是获取对象实例的方法不是静态的，所以你需要首先new工厂类，再调用普通的实例方法：  

<span style="font-family:Microsoft YaHei;font-size:14px;">//实例工厂      public FactoryDao getFactoryDaoImpl(){          return new FactoryDaoImpl();      }    </span>

那么下面这个类没什么说的，跟前面也很相似，但是我们需要通过实例工厂类创建FactoryDao对象：

<span style="font-family:Microsoft YaHei;font-size:14px;"> //注入对象      private FactoryDao factoryDao;            public void factoryOk(){          factoryDao.saveFactory();      }        public void setFactoryDao(FactoryDao factoryDao) {          this.factoryDao = factoryDao;      }  </span>

最后看spring配置文件：

<span style="font-family:Microsoft YaHei;font-size:14px;"><bean name="springAction" class="com.bless.springdemo.action.SpringAction">          <!--(4)使用实例工厂的方法注入对象,对应下面的配置文件(4)-->          <property name="factoryDao" ref="factoryDao"></property>      </bean>            <!--(4)此处获取对象的方式是从工厂类中获取实例方法-->      <bean name="daoFactory" class="com.bless.springdemo.factory.DaoFactory"></bean>      <bean name="factoryDao" factory-bean="daoFactory" factory-method="getFactoryDaoImpl"></bean>  </span>

-------------------------------------------

参考：
Qlin'S Blog博客 IoC模式
songliying001博客（转）spring四种依赖注入方式
百度百科 控制反转