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><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框架的的核心就是IoC1.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><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><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><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><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><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><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四种依赖注入方式
百度百科 控制反转
7141
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
