Spring框架之IOC&DI

前言：

经过一系列被鄙视后，终于拿到一份还算满意的小offer，以后的日子就是不断学习的过程了，加油。

 

最近开始学习Spring框架，现将自己目前的学习状况以及自己的一部分理解总结一下。

 

Spring框架提供给用户的有两个大的主要功能：控制反转(IOC)或依赖注入(DI)和面向切面编程(AOP)，当然还提供了其他的比如操作数据库的模板化以及事务管理、web开发中的Spring MVC等，这些以后会单独总结，但是最主要的还是依赖注入和面向切面编程。

一、Spring IOC以及DI的必要性

本篇文章总结控制反转(IOC)和依赖注入(DI)，两者共同解决一个问题：对象耦合问题。下面举例说明。

 

在我们访问数据库时会写DAO，假设现在需要针对不同的数据库(mysql或oracle数据库)来写DAO，于是会有一个DAO接口类，并且会有针对不同数据库的相应的实现类(MysqlDaoImpl 和 OracleDaoImpl)，如下所示：

DAO接口类：

 

package com.springframework.ioc;

public interface MyDao{
	//添加
	public void addUser();
}

 mysql实现类：

 

 

package com.springframework.ioc;

public class MysqlDaoImpl implements MyDao{
	
	@Override
	public void addUser(){
		System.out.println("mysql add user...");
	}
}

 oracle实现类：

 

 

package com.springframework.ioc;

public class OracleDaoImpl implements MyDao{
	
	@Override
	public void addUser(){
		System.out.println("oracle add user...");
	}
}

 这时上层service层要调用DAO，假设我的写法如下：

 

 

package com.springframework.ioc;

public class MyService{
	
	private MyDao myDao;
	
	public MyService(){
		myDao = new MysqlDaoImpl();
	}
	
	public void addUser(){
		myDao.addUser();
	}
}

<constructor-arg ref = "oracle"/>

 这种写法的缺点就是当我要换用作oracle数据库时需要修改MyService类，将myDao的创建改为

myDao = new OracleDaoImpl();

 不符合开放-封闭原则， 于是我修改我的代码如下：

 

 

package com.springframework.ioc;

public class MyService{
	
	private MyDao myDao;
	
	public MyService(MyDao myDao){
		this.myDao = myDao;
	}
	
	public void addUser(){
		myDao.addUser();
	}
}

 这样第三方在调用service层的addUser方法时的代码如下：

 

 

package com.springframework.ioc;

public class Test{
	public static void main(String[] args){

		MyService myService = new MyService(new MysqlDaoImpl());
		myService.addUser();	
	}
}

 这样当第三方需要的是oracle数据库的操作时，只需要将自己本身的代码修改为：

 

 

MyService myService = new MyService(new OracleDaoImpl());

 

 

将myDao对象的具体创建控制权交给第三方，而另外两房不需要关心，这就叫做控制反转。

 

以上是传统的编程做法，其实Spring框架也同样为我们解决了以上问题，使用的方式就是依赖注入方式。下面采用Spring框架来实现两个对象之间的解耦。

 

在Spring框架中，每一个类对象叫做一个bean，每一个bean有一个bean id和具体的实现类，Spring的IOC容器就是对这些bean进行管理和配置，将bean与bean之间的依赖通过配置文件或者注解的方式表现出来。

 

还是以以上的例子为例，为在xml文件中配置bean并将bean和bean之间的依赖进行配置如下：

 

<?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:context="http://www.springframework.org/schema/context"
		
		xsi:schemaLocation="
			http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans-2.5.xsd
			http://www.springframework.org/schema/context http://www.springframework.org/schema/context/spring-context-2.5.xsd"
			default-lazy-init="true">
			
			<!-- beans declare go here -->
			<!-- 通过默认构造器注入 -->
			<bean id="mysql" class="com.springframework.ioc.MysqlDaoImpl"/>
			<bean id="oracle" class="com.springframework.ioc.OracleDaoImpl"/>
			<!-- 通过含参构造器注入 -->
			<bean id = "myservice" class="com.springframework.ioc.MyService">
				<constructor-arg ref = "mysql"/>
			</bean>
	</beans>

 这样就将每个类作为bean注入到spring 的IOC容器中，然后第三方就可以获取bean并实例化bean，并调用其方法。如下所示：

 

 

package com.springframework.ioc;

import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;

public class Test{
	public static void main(String[] args){

		//传统做法
		/*MyService myService = new MyService(new OracleDaoImpl());
		myService.addUser();	*/
		
		//使用spring后的做法
		ApplicationContext context = new ClassPathXmlApplicationContext("ioc.xml");
		MyService myService = (MyService)context.getBean("myservice");
		myService.addUser();
	}
}

 第三方如果想要调用的是oracle，则只需修改xml配置文件将

 

 

<constructor-arg ref = "mysql"/>

 修改为：

 

<constructor-arg ref = "oracle"/>

 即可。

将一个类通过xml配置文件的形式注入到另一个类中，实现了两个类之间的依赖，并且实现了解耦。两个类只需要关注自己的业务逻辑实现，无需管理其它类的实现。

 

二、Spring IOC&DI的实现原理

 

Spring管理bean和bean之间的依赖管理分别对应于对象的控制反转和依赖注入，控制反转即spring将xml文件进行解析，包括bean的id、class名字、别名、property属性等，解析为一个个的bean注册到IOC容器中；依赖注入即将bean通过反射的方式实例化bean，并通过三种注入方式将其他的bean注入进来，然后返回给第三方。

 

比如对于一个简单配置的spring 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:context="http://www.springframework.org/schema/context"
		
		xsi:schemaLocation="
			http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans-2.5.xsd
			http://www.springframework.org/schema/context http://www.springframework.org/schema/context/spring-context-2.5.xsd">
			
			<!-- beans declare go here -->
			<!-- 通过默认构造器注入 -->
			<bean id="mysql" class="com.springframework.ioc.MysqlDaoImpl"/>
			<bean id="oracle" class="com.springframework.ioc.OracleDaoImpl"/>
	</beans>

 当Spring框架启动时，会对xml文件进行解析，按照节点首先解析的是

<bean id="mysql" class="com.springframework.ioc.MysqlDaoImpl"/>

在Spring框架中维护一个BeanDefinition来存储每一个bean节点的属性，如id、classname、propertity、autowire mode、initmethod name 、destroymethod name 等。

如下所示：

class BeanDefinition{
	//bean 的id
	private String id;
	
	//bean 的classname
	private String className;
	//bean 的init method name
        private String initMethodName;
        //等等...
}

 每有一个BeanDefinition即有一个相应的对象，内部装载着以上介绍的bean的各种属性(id、className等)，然后将这些BeanDefinition对象装载到IOC容器中，内部为键值为nbeanName，值为BeanDefinition的map表，如下所示：

/** Map of bean definition objects, keyed by bean name */
	private final Map<String, BeanDefinition> beanDefinitionMap = 
                                          new ConcurrentHashMap<String, BeanDefinition>(64);

这就完成了对xml文件的解析以及对BeanDefinition实例的注册。

当调用

		MyService myService = (MyService)context.getBean("myservice");

 时，

即为从map表中根据键值beanname(即bean的id)取出BeanDefinition实例，然后通过工厂方式或者构造函数反射机制创建bean实例，然后对beandefinition中的property属性进行解析，并通过set方法或者默认构造函数实现其他bean实例的注入。

这样就将每一个类以及类与类之间的依赖以bean的形式交给Spring的IOC容器来管理。

详细的IOC&DI的源代码解析或者原理解析可以参考这篇文章 http://www.cnblogs.com/ITtangtang/p/3978349.html。

 

参考：
http://www.importnew.com/13619.html

http://www.cnblogs.com/xdp-gacl/p/4249939.html

www.cnblogs.com/ITtangtang/p/3978349.html