IoC是Sprnig框架实现的一种代替程序员，管理Java类的模式。IoC全称为Inversion of Control,即控制反转。在Spring项目中，将Java类的控制权交给了Spring的IoC容器。类与类之间的泛化关系、依赖关系都能通过Spring的配置来实现，而不需要手动编写。
DI,全称为Dependency Injection,即依赖注入。在Spring通过配置文件配置了依赖关系之后，可以通过多种方式对对象进行注入，比如说Service实现类中的方法需要依赖dao实现类，我们就能通过Spring配置文件写好注入配置，在使用时，我们只需要定义好dao接口，而不需要去获取它的实例，由Spring为我们注入。
控制反转，能让spring容器为我们创建对象。简单来说，我们只需要准备好Object object Spring能帮我们实现余下的new Object()部分。在Spring中，每个被放入容器的类被成为bean，ApplicationContext代表了IoC容器，我们可以通过这个类来读取配置文件，根据配置文件实例化bean。下面看看如何通过配置实现控制反转
配置文件一般放在class目录下，即开发中的src目录。配置文件的主要结构如下：
<?xml version="1.0" encoding="UTF-8"?> <beans xmlns="http://www.springframework.org/schema/beans" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans-2.5.xsd"> <!-- beans 存放了很多个类 把一个类放入到spring容器中，该类就是bean --> <!-- 一个bean就是描述一个类 id就是标示符 命名规范：类的第一个字母变成小写，其他的字母保持不变 class为类的全名 --> <bean id="helloWorld" class="com.spring.ioc.HelloWorld"></bean> </beans>ApplicationContext在Spring中代表一个IoC容器，ApplicationContext只是一个接口，在这里我用ClassPathXmlApplicationContext这个实现类来直接获取配置文件。其中在容器中对象的创建又有三种方法：根据默认构造方法创建、静态工厂方法创建、实例工厂方法创建
springIoc容器默认情况下会根据bean的构造函数来实例化对象。所以在bean的配置中我们可以添加参数，参数可以是变量也可以是另一个bean的引用，如果是bean的引用，则使用ref=”bean_id”来关联。 配置方式applicationContext.xml
<bean id="helloWorld" class="com.spring.ioc.HelloWorld"></bean>HelloWorld.java
package com.spring.ioc; public class HelloWorld { public HelloWorld(){ System.out.println("create a HelloWorld!"); } public void hello(String name){ System.out.println("Hello," + name); } }IoCTest.java
package com.spring.ioc; import org.junit.Test; import org.springframework.context.ApplicationContext; import org.springframework.context.support.ClassPathXmlApplicationContext; public class IoCTest { @Test public void testIoC(){ //读取配置文件 ApplicationContext context = new ClassPathXmlApplicationContext("applicationContext.xml"); //通过getBean方法得到 HelloWorld helloWorld = (HelloWorld) context.getBean("helloWorld"); helloWorld.hello("Cindy"); } }可以在配置bean的时候可以配置使用静态工厂来实例化对象。Spring容器会在内部调用静态工厂的实例化方法来实例化对象。 配置方式：applicationContext.xml
<bean id="helloWorld" class="com.spring.ioc.HelloWorldFactory" factory-method="getInstance"> </bean>静态工厂HelloWorldFactory.java
package com.spring.ioc; public class HelloWorldFactory { public static HelloWorld getInstance(){ return new HelloWorld(); } }使用实例工厂方法实例化对象，在定义bean的时候使用factory-bean属性和factory-method属性，来指定实例工厂的实例方法。与静态工厂方法不同，这里是先实例化了一个工厂类，然后调用了实例化工厂方法，而静态工厂方法不实例化工厂类，直接调用其静态实例化方法。 配置方式：applicationContext.xml
<bean id="helloWorldFactory" class="com.spring.ioc.HelloWorldFactory2"></bean> <bean id="helloWorld" factory-method="getInstance" factory-bean="helloWorldFactory"></bean>实例工厂HelloWorldFactory2.java
package com.spring.ioc; public class HelloWorldFactory2 { public HelloWorldFactory2(){ System.out.println("create a HelloWorldFactory"); } public HelloWorld getInstance(){ return new HelloWorld(); } }①加载Spring容器，加载过程中，调用bean的构造函数为bean创建对象。 ②将bean的lazy-init属性，设置为true（默认为false），设置延迟加载，spring容器加载时不实例化，在getBean()的时候才实例化。 一般情况下使用第一种方式，因为在启动过程中就能检测出spring配置文件中包含的错误，更加安全。第二种在启动过程中发现不了配置文件错误。如果要加载的bean实在太消耗性能，再考虑使用第二种方法。
在配置bean的过程中，可以为其指定是否使用单例模式实例化对象，默认为单例模式，即只实例化一次，多次使用。设置的方法为： ① 多例模式：scope=prototype
<bean id="helloWorld" class="com.spring.ioc.HelloWorld" scope="prototype"></bean>②单例模式（defalut）: scope=singleton
<bean id="helloWorld" class="com.spring.ioc.HelloWorld" scope="singleton"></bean>在配置bean的时候，可以为其指定init()方法和destory()方法，分别在实例化和销毁的时候执行。其中在容器关闭时，bean销毁。 配置了之后整个流程可表示为：构造方法(创建对象)->init方法->其他方法->destory方法
*当scope=prototype的时候，spring容器不会执行destory方法
配制方法 applicationContext.xml ：
<bean id="helloWorld" class="com.spring.ioc.HelloWorld" init-method="init" destroy-method="destroy"></bean>HelloWorld.java
package com.spring.ioc; public class HelloWorld { public HelloWorld(){ System.out.println("create a HelloWorld!"); } public void hello(String name){ System.out.println("Hello," + name); } public void init(){ System.out.println("init HelloWorld"); } public void destroy(){ System.out.println("destroy HelloWorld"); } }在spring容器中使用parent属性指定父类，实现继承。例子：
package com.spring.xml.extend; public class Animal { public void walk(){ System.out.println("Animal walking"); } } package com.spring.xml.extend; public class Dog extends Animal { }配置：
<bean class="com.spring.xml.extend.Animal" id="animal"></bean> <bean class="com.spring.xml.extend.Dog" id="dog" parent="animal"></bean>配置bean的时候，我们可以在配置文件中指定实例化时，要注入的属性值。这些值可以是基本数据类型、引用类型、集合类型、或者Propertie，只要在bean的类定义中提供setter方法就能通过配置注入，配置的方法如下： applicationContext.xml
<bean id="person" class="com.spring.di.Person"> <!-- property描述的就是bean中的属性 name属性就是描述属性的名称 value就是值 如果是基本属性(String)，就用value赋值 ref 如果是引用类型，用ref赋值 --> <property name="pid" value="1"></property> <property name="name" value="Cindy"></property> <!-- 注入bean --> <property name="student" ref="student"></property> <property name="lists"> <list> <value>list1</value> <value>list2</value> <!-- list中存放一个student对象 --> <ref bean="student"/> </list> </property> <property name="objects"> <list> <value>obj1</value> <ref bean="student"/> </list> </property> <property name="sets"> <set> <value>set1</value> <ref bean="student"/> </set> </property> <property name="map"> <map> <entry key="m1"> <value>m1</value> </entry> <entry key="m2"> <ref bean="student"/> </entry> </map> </property> <property name="properties"> <props> <prop key="p1">p1</prop> <prop key="p2">p2</prop> </props> </property> </bean> <bean id="student" class="com.spring.di.Student" scope="prototype"></bean>Student.java
package com.spring.di; public class Student { public Student(){ System.out.println("student"); } public void say(){ System.out.println("student"); } }Person.java
public class Person { private Long pid; private String name; private Student student; private List lists; private Set sets; private Map map; private Object[] objects; private Properties properties; public Person(){ System.out.println("person"); } //... //省略setter方法 }除了调用setter方法注入，还能通过类的构造器来注入参数，同样是从配置文件中对bean进行配置。首先在类中定义好构造器方法，然后在配置文件中设置参数。 配置方法： applicationContext.xml
<bean id="person1" class="com.spring.di.Person1"> <constructor-arg value="Cindy" index="0"></constructor-arg> <constructor-arg ref="student" index="1"></constructor-arg> </bean>Person1.java
package com.spring.di; public class Person1 { private String name; private Student student; public Person1(String name, Student student) { this.name = name; this.student = student; } }让客户端实现完全面向接口编程，在编写客户端的时候，不用关心实现类为什么具体类型，只用接口类型来完成工作，接口需要具体为何种类型的实例，由配置文件决定。举个例子，在一个struts2的aciton中，用接口定义了一个service，而这个service通过spring注入，那么开发action的人员就不需要管service具体是如何实现的，把编写service的工作分离出去，方便团队开发，避免编写过程中的冲突。
了解Spring框架底层是如何实现控制反转和依赖注入，需要深入研究源码。因为我还没有深入研究过，只知道大概是使用了Java的反射机制，来操作类。有待自己深入研究。
