spring之IOC控制反转和DI依赖注入

Ioc—Inversion of Control，即“控制反转”，是一种设计思想。

传统方式是需要什么对象就new什么对象，完全是由自己定义自己创建自己销毁的，控制权在自己手上。用了IOC之后，控制权发生了反转，由spring容器控制，自己写好的Javabean后，在applicationContext.xml中注册登记，然后由spring进行管理，需要用什么对象时，就调用spring的

ApplicationContext ac = new FileSystemXmlApplicationContext("classpath:beans.xml");
ApplicationContext ac = new ClassPathXmlApplicationContext("classpath:beans.xml");

FileSystemXmlApplicationContext()方法括号你可以写绝对路径，能访问绝对路径下的XML文件，

 

ClassPathXmlApplicationContext();方法只能访问src目录下的XML文件。

然后调用getBean()方法即可生成对象使用。

User的Javabean：

 

package springTest;

public class User {
	private String name;
	private String sex;
	private int age;
	public String getName() {
		return name;
	}
	public void setName(String name) {
		this.name = name;
	}
	public String getSex() {
		return sex;
	}
	public void setSex(String sex) {
		this.sex = sex;
	}
	public int getAge() {
		return age;
	}
	public void setAge(int age) {
		this.age = age;
	}
	public void print(){
		System.out.println(this.getName());
		System.out.println(this.getSex());
		System.out.println(this.getAge());
	}
}

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"  
    xsi:schemaLocation="http://www.springframework.org/schema/beans    
http://www.springframework.org/schema/beans/spring-beans-2.5.xsd">  

<bean name="user" class="springTest.User">

	<property name="name">
		<value>小明</value>
	</property>
	<property name="sex">
		<value>男</value>
	</property>
	<property name="age">
		<value>19</value>
	</property>

</bean>

</beans>

测试IOC类：

package springTest;

import org.apache.naming.factory.BeanFactory;
import org.springframework.beans.factory.xml.XmlBeanFactory;
import org.springframework.core.io.ClassPathResource;
import org.springframework.core.io.Resource;




public class test {

	public static void main(String[] args) {
		// TODO Auto-generated method stub
		Resource resourse = new ClassPathResource("applicationContext.xml");
		XmlBeanFactory factory = new XmlBeanFactory(resourse);
		User user = (User) factory.getBean("user");
		user.print();

		
	}

}

通俗的讲，所有的类都会在spring容器中登记，告诉spring你是个什么东西，你需要什么东西，然后spring会在系统运行到适当的时候，把你要的东西主动给你，同时也把你交给其他需要你的东西。所有的类的创建、销毁都由 spring来控制，也就是说控制对象生存周期的不再是引用它的对象，而是spring。对于某个具体的对象而言，以前是它控制其他对象，现在是所有对象都被spring控制，所以这叫控制反转。

DI—Dependency Injection，即“依赖注入”。IoC的一个重点是在系统运行中，动态的向某个对象提供它所需要的其他对象。这一点是通过DI（Dependency Injection，依赖注入）来实现的。比如对象A需要操作数据库，以前我们总是要在A中自己编写代码来获得一个Connection对象，有了 spring我们就只需要告诉spring，A中需要一个Connection，至于这个Connection怎么构造，何时构造，A不需要知道。在系统运行时，spring会在适当的时候制造一个Connection，然后像打针一样，注射到A当中，这样就完成了对各个对象之间关系的控制。A需要依赖 Connection才能正常运行，而这个Connection是由spring注入到A中的，依赖注入的名字就这么来的。那么DI是如何实现的呢？ Java 1.3之后一个重要特征是反射（reflection），它允许程序在运行的时候动态的生成对象、执行对象的方法、改变对象的属性，spring就是通过反射来实现注入的。

在平时的java应用开发中，我们要实现某一个功能或者说是完成某个业务逻辑时至少需要两个或以上的对象来协作完成，在没有使用Spring的时候，每个对象在需要使用他的合作对象时，自己均要使用像new object() 这样的语法来将合作对象创建出来，这个合作对象是由自己主动创建出来的，创建合作对象的主动权在自己手上，自己需要哪个合作对象，就主动去创建，创建合作对象的主动权和创建时机是由自己把控的，而这样就会使得对象间的耦合度高了，A对象需要使用合作对象B来共同完成一件事，A要使用B，那么A就对B产生了依赖，也就是A和B之间存在一种耦合关系，并且是紧密耦合在一起，而使用了Spring之后就不一样了，创建合作对象B的工作是由Spring来做的，Spring创建好B对象，然后存储到一个容器里面，当A对象需要使用B对象时，Spring就从存放对象的那个容器里面取出A要使用的那个B对象，然后交给A对象使用，至于Spring是如何创建那个对象，以及什么时候创建好对象的，A对象不需要关心这些细节问题(你是什么时候生的，怎么生出来的我可不关心，能帮我干活就行)，A得到Spring给我们的对象之后，两个人一起协作完成要完成的工作即可。

 

参考自：http://blog.csdn.net/qq_22654611/article/details/52606960