控制反转（Inversion of Control，缩写为IOC），它是把你设计好的对象交给spring控制，而不再需要你去手动 new Object(); 网上对于IOC的解释很多，对程序员而言，大篇文字的解释，不如代码举个例子：
汽车（Car ）、汽车车身 （CarBody） 、 汽车*（CarWheel ）
汽车 由 id + name + 车身 + * 组成
代码如下：
package com.wp;
public class Car {
private int id;
private String name;
private CarBody carbody;
private CarWheel carwheel;
// get set 方法省略。。。
}
package com.wp;
public class CarBody {
private int id;
private String name;
//get set 方法省略。。。
}
package com.wp;
public class CarWheel {
private int id;
private String name;
//get set 方法省略。。。
}
以往的方式：我们创建汽车对象是通过直接new Car(); 的方式去出动创建对象，也就是对象的创建是有我们程序去主动控制的。代码如下：
package com.wp.test;
import com.wp.Car;
public class TestSpring { public static void main(String[] args) {
Car car = new Car();
System.out.println(car); //输出 com.wp.Car@452b3a41
}
}
在Spring中，也可以让spring自动创建对象，代码如下：
首先在 applicationContext.xml 进行配置，配置class指向我们的Car 通过关键字c可以获取Car对象，并且会默认给Car对象的name属性赋值“小汽车”。
<bean name="c" class="com.wp.Car">
<property name="name" value="小汽车" />
</bean>
测试类使用spring自动创建对象，代码如下：
package com.wp.test;
import com.wp.Car;
import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext; public class TestSpring {
public static void main(String[] args) {
ApplicationContext context = new ClassPathXmlApplicationContext(new String[] { "applicationContext.xml" });
Car car = (Car) context.getBean("c");
System.out.println(car.getName()); //输出 小汽车
}
}
这种方式就是spring自动创建对象的方式，我们需要Car对象的时候，我们直接找Spring的IOC容器要就行了，我们不需要知道这个对象怎么创建的，我们需要就直接取。
通过上面的例子来解释一下 控制反转：
以往的时候，Car对象是我们程序创建，需要手动 new Car() 来创建Car对象，Car的创建是由我们控制的；
使用Spring 的IOC原理之后，Car对象由Spring 创建，我们需要的时候，直接去取，Car的创建由Spring 控制。
对象的创建由我们控制转变为Spring控制，这种设计思想，就叫控制反转。
依赖注入：
什么是依赖注入呢？简单点，程序员还是通过程序的方式来理解。
可以看到我们的 CarBody 和 CarWheel 还没派上用场，也就是我们在上面创建的小汽车的车身和*还都是空的，这个小汽车是无法使用的，为了让小汽车变的完整，我们要给小汽车创建车身和*组装上。还是通过以往的形式和依赖注入的形式来对比：
以往的方式：
我们会 new CarBody() ，然后通过Car的setCarBody() 把这对象放进去；
然后再 new CarWheel () ，然后通过Car的setCarWheel() 把这对象放进去。
一顿操作以后，我们的小汽车就完整了，代码如下：
package com.wp.test;
import com.wp.Car;
import com.wp.CarBody;
import com.wp.CarWheel; public class Test { public static void main(String[] args) {
Car car = new Car(); //创建小汽车
CarBody carbody = new CarBody(); //创建车身
CarWheel carwheel = new CarWheel(); //创建*
car.setCarbody(carbody); //给小汽车装上车身
car.setCarwheel(carwheel); //给小汽车装上*
System.out.println(car.getCarbody()); //输出 com.wp.CarBody@452b3a41
}
}
使用Spring 的依赖注入方式：
修改applicationContext.xml 配置文件，通过前门spring创建小汽车对象的方式，把小汽车的车身和车轮也交给spring创建，然后通过 ref ="cb" 和 ref = "cw"的方式把车身和*组装到小汽车上。注意：cb 和 cw 分别对应 车身 、* bean 的name
<bean name="c" class="com.wp.Car">
<property name="name" value="小汽车" />
<property name="carbody" ref="cb" />
<property name="carwheel" ref="cw" />
</bean>
<bean name="cb" class="com.wp.CarBody">
<property name="name" value="豪华车身" />
</bean>
<bean name="cw" class="com.wp.CarWheel">
<property name="name" value="豪华*" />
</bean>
测试类如下：
package com.wp.test;
import com.wp.Car;
import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext; public class TestSpring {
public static void main(String[] args) {
ApplicationContext context = new ClassPathXmlApplicationContext(new String[] { "applicationContext.xml" });
Car car = (Car) context.getBean("c"); System.out.println(car.getName()); //输出 小汽车
System.out.println(car.getCarbody().getName()); //输出 豪华车身
System.out.println(car.getCarwheel().getName()); //输出 豪华*
}
}
我们已经能够理解汽车是Spring创建的，通过 context.getBean("c") 可以直接获取汽车对象，也就是我们不需要创建对象，我们交给Spring去创建，我们需要用的时候，只管去向Spring容器要，Spring容器就会给我们一个创建好的对象。那么Spring 是如何把“车身”和“*”组装到“小汽车”上面呢，这就用到了依赖注入
依赖注入（Dependency Injection）也是Spring框架的核心之一，缩写 DI ，
在applicationContext.xml 配置文件中
<bean name="c" class="com.wp.Car">
<property name="name" value="小汽车" />
<property name="carbody" ref="cb" />
<property name="carwheel" ref="cw" />
</bean>
首先看下name的赋值方式，创建Car对象时，要给 name 属性赋值，赋值方式是直接指定一个value="小汽车" 也就是创建一个Car对象，直接把小汽车这个字符串赋到Car对象的name属性上，小汽车就有名字了。
然后看下 carbody 赋值方式，赋值方式是 ref = "cb" ，spring会自动去寻找name="cb"的 bean ,而这个bean 对应的实体类就是CarBody 类 ，在找到之后，Spring会创建CarBody 对象，然后把CarBody对象赋到 Car对象的carbody 属性上面， 小汽车就有车身了。
CarWheel 原理与CarBody一样。
Car 需要CarBody ，也就是Car 依赖CarBody ，Spring这种把 CarBody对象 注入到 Car 对象中的方式，就是依赖注入（DI）。
那么spring是如何实现依赖注入呢？
那就是反射（reflection） ， <property name="carbody" ref="cb" /> 中的ref 就是反射的缩写，这个由spring自动完成，我们不需要去进行任何操作。
使用IOC 和 DI 有什么好处？
以往的方式我们类里面主动创建对象，然后处理对象与对象的依赖，会导致类与类之间高耦合，使用IOC和DI 之后呢，我们把类的控制权交给Spring，Spring去进行创建对象并且进去对象依赖注入，我们只是在需要的时候去找Spring的IOC容器去取，可以让我们的系统结构更加灵活。
另外：
如果感觉配置文件写的不方便，也可以写成注解的方式：
applicationContext.xml
<context:annotation-config/>
Car 的属性上增加@Autowired注解
package com.wp;
import org.springframework.beans.factory.annotation.Autowired;
public class Car {
private int id;
private String name;
@Autowired
private CarBody carbody;
@Autowired
private CarWheel carwheel;
//get set 方法省略。。。
}
注解运行结果与配置文件运行结果一致。
加油！