前言
一直说自己会spring,其实只是会用而已。对它的原理及核心很多都不了解。IoC控制反转作为Spring的核心，只有不断慢慢的了解。
什么是IoC？ ？ ？
我们先来看一下比较官方的解释。
IoC，Inversion of Control的缩写，中文名称为控制反转，意思是将对象的控制权转移至第三方，例如IoC容器，即可由IoC容器来管理对象的生命周期、依赖关系等。
反正我没有看懂。_
举个例子
在传统的人员招聘模式中，流程一般都是这样：HR从多如海的应聘简历中挑选然后进行笔试、面试等等一系列筛选后发放offer。这一系列过程复杂而且费时，最关键的是结果还不理想，特别是针对某些特定的岗位很难通过这一模式物色到合适的人才资源。
后来逐渐出现了一些公司专门提供类似的人才寻访服务，这就是大名鼎鼎的猎头行业。猎头的兴起可以说很大程度上改变了人才招聘的模式，现在公司需要招聘某个职位的人才，只需要告诉猎头我要一个怎样的人干怎样的工作等等要求，猎头就会通过自己的渠道去物色人才，经过筛选后提供给客户，大大简化了招聘过程的繁琐，提高了招聘的质量和效率。
这其中一个很重要的变化就是公司HR将繁琐的招聘寻访人才的过程转移至了第三方，也就是猎头。相对比而言，IoC在这里充当了猎头的角色，开发者即公司HR，而对象的控制权就相当于人才寻访过程中的一系列工作。
IoC设计模式和IoC容器
回到我们所说的IoC，首先我们需要肯定的是 IoC并不是特指某种技术，而是指一种思想或者说一种设计模式。我们可以简单的理解为我们在进行程序业务逻辑的编程时通常需要大量的对象来协作完成，而这些对象都需要我们通过类似如下语句
Object object=new Object();//对象申请
object.setName("XXX");//对象属性初始化赋值
的方式申请和初始化，而这些就是所谓的对象的控制权，IoC设计模式的目的就是把这些对象的控制权转移至第三方，由第三方来进行和管理类似对象申请、初始化、销毁对象的控制权工作
对于开发者来说，对象的控制权的转移意味着我们编程将更加简便，不用再去关心如何申请、初始化对象，甚至是管理对象、销毁等复杂的过程，这些都将由第三方完成，只需要告诉第三方我需要怎样的对象使用即可。
这里还需要解释一个概念，所谓的IoC容器，就是实现了IoC设计模式的框架。
Spring IoC
Spring IoC实现了IoC设计模式，所以是IoC容器。所以，Spring IoC主要任务就是创建并且管理JavaBean的生命周期，即之前提到的对象的控制权。
那么对于Spring而言，JavaBean的生命周期包括哪些方面呢？这是我们需要了解的问题。
Spring IoC的JavaBean的生命周期
（1）实例化JavaBean：Spring IoC容器实例化JavaBean
（2）初始化JavaBean：Spring IoC容器对JavaBean通过注入依赖进行初始化
（3）使用JavaBean：基于Spring应用对JavaBean实例的使用
（4）销毁JavaBean：Spring IoC容器销毁JavaBean实例
举个例子
我们来看一个Spring IoC的例子。
编写一个动物接口，代码如下：
package com.demo;
public interface Animal {
void printWhoAmI();
}
编写一个老虎类实现动物接口，代码如下：
package com.demo;
public class Tiger implements Animal {
private String name;
private int age;
//省略属性的set和get方法
@Override
public void printWhoAmI() {
// TODO Auto-generated method stub
System.out.println("I am " + name);
System.out.println("I am " + age + " years old");
}
}
编写Spring配置文件applicationContext.xml，代码如下：
<?xml version="1.0" encoding="UTF-8" ?>
<beans xmlns="http://www.springframework.org/schema/beans" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns:p="http://www.springframework.org/schema/p" xsi:schemaLocation="http://www.springframework.org/schema/beans
http://www.springframework.org/schema/beans/spring-beans-3.0.xsd">
<bean id="tiger" class="com.demo.Tiger">
<property name="name">
<value>Tom</value>
</property>
<property name="age">
<value>3</value>
</property>
</bean>
</beans>
编写主测试类，代码如下：
package com.demo;
public class Test {
public static void main(String[] args) {
Resource resource = new ClassPathResource("applicationContext.xml");
BeanFactory beanFactory = new XmlBeanFactory(resource);
Animal tiger = (Tiger) beanFactory.getBean("tiger"); // 获取Tiger类对象tiger
tiger.printWhoAmI();
}
}
我们可以发现Spring通过配置文件完成了Tiger类对象tiger申请和初始化，我们在使用Tiger类对象tiger时不再通过
// 创建Tiger类对象tiger
Animal tiger = new Tiger();
// Tiger类对象tiger初始化
tiger.setName("Tom");
tiger.setAge(3);
这种方式，而是将所有的JavaBean的生命周期操作和管理托管至Spring IoC容器，对于开发者而言，我们只需要关心业务逻辑需要怎样的JavaBean对象，告诉容器，使用即可，这里再次体现了所谓的控制反转的思想。
依赖注入
我们可能会遇见这样的情况，Spring IoC容器管理的对象中可能会依赖其他对象，这是很常见的。这就意味着Spring IoC的一个重点是在系统运行中，动态的向某个对象提供它所需要的其他对象。这也是我们接下来要了解的依赖注入。
接着上述例子我们来看一下依赖注入的情况：
编写一个笼子接口，代码如下：
package com.demo;
public interface Cage {
void printInfo();
}
编写一个铁笼子类实现笼子接口，并且具有一个动物类型的属性，代码如下：
package com.demo;
public class IronCage implements Cage {
private String id;
private Animal animal;
//省略属性的set和get方法
@Override
public void printInfo() {
// TODO Auto-generated method stub
System.out.println("I am a IronCage");
System.out.println("My id is " + id);
System.out.println("There is the animal information");
animal.printWhoAmI();
}
}
将Spring配置文件applicationContext.xml改写如下：
<?xml version="1.0" encoding="UTF-8" ?>
<beans xmlns="http://www.springframework.org/schema/beans" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns:p="http://www.springframework.org/schema/p" xsi:schemaLocation="http://www.springframework.org/schema/beans
http://www.springframework.org/schema/beans/spring-beans-3.0.xsd">
<bean id="tiger" class="com.demo.Tiger">
<property name="name">
<value>Tom</value>
</property>
<property name="age">
<value>3</value>
</property>
</bean>
<bean id="ironCage" class="com.demo.IronCage">
<property name="id">
<value>001</value>
</property>
<property name="animal">
<ref bean="tiger" />
</property>
</bean>
</beans>
IronCage类对象ironCage中依赖Animal类型的animal属性，Spring IoC容器将Tiger类tiger对象注入作为animal的值，这就是依赖注入。
这里提一下，Spring支持多种属性赋值的情况，例如list、map：
<bean id="school" class="School">
<!--1.value 普通赋值-->
<property name="name">
<value>XX学校</value>
</property>
<!--2.ref 引用其他JavaBean实例对象赋值-->
<property name="student">
<ref bean="student1" />
</property>
<!--3.list 集合类或者数组赋值-->
<property name="studentList">
<list>
<ref bean="student1" />
<value>student2</value>
</list>
</property>
<!--4.map Map集合赋值-->
<property name="studentMap">
<map>
<entry key="student1">
<ref bean="student1" />
</entry>
<entry key="key2">
<value>student2</value>
</entry>
</map>
</property>
</bean>
Spring 如何实现IoC？
了解了Spring IoC的强大功能之后，我们可能都会好奇Spring究竟是如何做到这样？
Java一个很重要的特性就是支持反射（reflection）机制，它允许程序在运行的时候动态的生成对象、执行对象的方法、改变对象的属性，Spring就是通过反射来实现注入的。
简单的说，Spring首先会根据bean的XML配置文件，将一个bean的配置读入以HashMap的数据结构存储，在实例化一个类时，它通过反射调用类中set方法将事先保存在HashMap中的类属性注入到类中。
这里强烈建议大家看一篇文章，对于Spring IoC的原理解释的很清楚。 spring ioc原理（看完后大家可以自己写一个spring）
BeanFactory和ApplicationContext
Spring使用BeanFactory和ApplicationContext两个接口来定义IoC，它们是Spring针对不同应用领域的两个IoC容器。
首先它们两者的关系是，ApplicationContext继承BeanFactory。
BeanFactory处于Spring的核心，所以可以理解为Spring统一使用BeanFactory访问Spring IoC容器，主要用于开发Java应用，尤其是在物理资源（内存有限）受限的场合，这是因为在调用getBean()方法之前不会实例化任何对象，只有在需要创建JavaBean实例对象时，才会为其分配资源空间。
ApplicationContext在继承BeanFactory基础上增加了很多其他功能，如国际化支持、事件发布和监听等，非常适合J2EE的开发。
总结
对spring的反转控制有一定的理解了，但是还有很多不清楚的地方。
感谢
感谢Wwwwei作者的文章，长话短说Spring（1）之IoC控制反转对我有很大的启发。
