IOC（Inverse of Control）可翻译为“控制反转”，但大多数人都习惯将它称为“依赖注入”。在Spring中，通过IOC可以将实现类 、参数信息等配置在其对应的配置文件中 ，那么当需要更改实现类或参数信息时，只需要修改配置文件即可，这种方法在上例的基础上更进一步的降低了类与类之间的耦合。我们还可以对某对象所需要的其它对象进行注入 ，这种注入都是在配置文件中做的，Spring的IOC的实现原理利用的就是Java的反射机制，Spring还充当了工厂的角色，我们不需要自己建立工厂类 。Spring的工厂类会帮我们完成配置文件的读取、利用反射机制注入对象等工作，我们可以通过bean的名称获取对应的对象。下面让我们看看如下的模拟Spring的bean工厂类：
1、BeanFactory.java
package com.yt.manager.spring;
import java.io.InputStream;
import java.lang.reflect.Method;
import java.util.HashMap;
import java.util.Iterator;
import java.util.Map;
import org.apache.log4j.Logger;
import org.dom4j.Attribute;
import org.dom4j.Document;
import org.dom4j.Element;
import org.dom4j.io.SAXReader;
/**
* @ClassName: BeanFactory
* @Project: base-info
* @Author: zxf
* @Date: 2011-5-19
*/
public class BeanFactory {
Logger log = Logger.getLogger(BeanFactory.class);
private Map<String, Object> beanMap = new HashMap<String, Object>();
/**
* bean工厂的初始化
*
* @param xml
*/
public void init(String xml) {
try {
//读取指定的配置文件
SAXReader reader = new SAXReader();
//从class目录下获取指定的配置文件
ClassLoader classLoader = Thread.currentThread().getContextClassLoader();
InputStream inputStream = classLoader.getResourceAsStream(xml);
//读取xml文件
Document document = reader.read(inputStream);
//获取跟节点
Element root = document.getRootElement();
//遍历bean节点
Element foo;
for(Iterator iteBean = root.elementIterator("bean");iteBean.hasNext();){
foo = (Element)iteBean.next();
//获取bean的属性id和class
Attribute id = foo.attribute("id");
Attribute cls = foo.attribute("class");
//利用java反射机制，通过class的名称获取Class对象
Class bean = Class.forName(cls.getText());
//获取对应class信息
java.beans.BeanInfo info = java.beans.Introspector.getBeanInfo(bean);
//获取其属性描述
java.beans.PropertyDescriptor pd[] = info.getPropertyDescriptors();
//设置值的方法
Method mSet = null;
//创建一个对象(创建此 Class 对象所表示的类的一个新实例。如同用一个带有一个空参数列表的 new 表达式实例化该类。如果该类尚未初始化，则初始化这个类。)
Object obj = bean.newInstance();
//遍历该bean的property属性
for(Iterator iteProperty = foo.elementIterator("property");iteProperty.hasNext();){
Element elementProperty = (Element)iteProperty.next();
//获取该property的name属性
Attribute name = elementProperty.attribute("name");
String value = null;
//获取该property的子元素value的值
for(Iterator iteValue = elementProperty.elementIterator("value");iteValue.hasNext();){
Element elementValue = (Element)iteValue.next();
value = elementValue.getText();
break;
}
for (int k = 0; k < pd.length; k++) {
log.info(pd[k].getName());
if (pd[k].getName().equalsIgnoreCase(name.getText())) {
mSet = pd[k].getWriteMethod();
//利用Java的反射机制调用对象的某个set方法，并将值设置进去
mSet.invoke(obj, value);
}
}
}
//将对象放入beanMap中，其中key为id值，value为对象
beanMap.put(id.getText(), obj);
}
} catch (Exception e) {
e.printStackTrace();
}
}
/**
* 通过bean的id获取bean的对象.
* @param beanName bean的id
* @return 返回对应对象
*/
public Object getBean(String beanName) {
Object obj = beanMap.get(beanName);
return obj;
}
public static void main(String[] args) {
BeanFactory factory = new BeanFactory();
factory.init("config.xml");
JavaBean javaBean = (JavaBean) factory.getBean("javaBean");
System.out.println("userName=" + javaBean.getUserName());
System.out.println("password=" + javaBean.getPassWord());
}
}
2、JavaBean.java
package com.yt.manager.spring;
/**
* @Description:
* @ClassName: JavaBean
* @Project: base-info
* @Author: zxf
* @Date: 2011-5-19
*/
public class JavaBean {
private String userName;
private String passWord;
public String getUserName() {
return userName;
}
public void setUserName(String userName) {
this.userName = userName;
}
public String getPassWord() {
return passWord;
}
public void setPassWord(String passWord) {
this.passWord = passWord;
}
}
3、config.xml
<?xml version="1.0" encoding="UTF-8"?> <beans> <bean id = "javaBean" class="com.yt.manager.spring.JavaBean"> <property name="userName"> <value>这是姓名</value> </property> <property name="passWord"> <value>这是密码</value> </property> </bean> </beans>
可以看到，虽然在main()方法中没有对属性赋值，但属性值已经被注入，在BeanFactory类中的Class bean = Class.forName(cls.getText()); 通过类名来获取对应的类，mSet.invoke(obj, value);通过invoke方法来调用特定对象的特定方法，实现的原理都是基于Java的反射机制，在此我们有一次见证了Java反射机制的强大。当然，这只是对IOC的一个简单演示，在Spring中，情况要复杂得多，例如，可以一个bean引用另一个bean，还可以有多个配置文件、通过多种方式载入配置文件等等。不过原理还是采用Java的反射机制来实现IOC的。
在本文中，笔者通过讲述Java反射机制概述与初探、IOC使用的背景、IOC粉墨登场等内容，演示了Java反射机制API的强大功能，并通过编写自己的简单的IOC框架，让读者更好的理解了IOC的实现原理。本文通过IOC的一个简要实现实例，模拟了Spring中IOC的实现，虽然只是完成了Spring中依赖注入的一小部分工作， 但是很好的展现了Java反射机制在Spring中的应用，能使我们能更好的从原理上了解IOC的实现，也能为我们实现自己的准Spring框架提供方案，有兴趣的朋友可以通过Spring的源码进行IOC的进一步的学习。
附：通过java反射机制获取指定类的属性和方法
package com.yt.manager.spring;
import java.beans.BeanInfo;
import java.beans.Introspector;
import java.beans.MethodDescriptor;
import java.beans.PropertyDescriptor;
/**
* @Description:java.beans包的使用
* @ClassName: JavaBeans
* @Project: base-info
* @Author: zxf
* @Date: 2011-5-19
*/
public class JavaBeans {
/**
* @param args
* @throws Exception
*/
@SuppressWarnings("rawtypes")
public static void main(String[] args) throws Exception {
// 返回与带有给定字符串名的类或接口相关联的 Class 对象
Class bean = Class.forName("com.yt.manager.spring.JavaBean");
// 获取指定类的信息
BeanInfo info = Introspector.getBeanInfo(bean);
// 遍历指定类的方法
MethodDescriptor[] methods = info.getMethodDescriptors();
for (int i = 0; i < methods.length; i++) {
System.out.println("方法："+methods[i].getDisplayName());
}
// 遍历指定类的属性
PropertyDescriptor[] propertys = info.getPropertyDescriptors();
for (int j = 0; j < propertys.length; j++) {
System.out.println("属性："+propertys[j].getName());
}
}
}
package com.yt.manager.spring;
import java.lang.reflect.Method;
/**
* @Description: java.lang.reflect.method类中invoke方法的使用
* @ClassName: MethodInvoke
* @Project: base-info
* @Author: zxf
* @Date: 2011-5-19
*/
public class MethodInvoke {
/**
* @param args
* @throws ClassNotFoundException
*/
public static void main(String[] args) throws Exception {
JavaBean javaBean = new JavaBean();
//获取指定类的指定方法，
Class c = Class.forName("com.yt.manager.spring.JavaBean");
Method method = c.getMethod("setUserName", new Class[] { String.class });
//对带有指定参数的指定对象调用由此 Method 对象表示的底层方法,调用对象javaBean的setuserName方法，参数为"testName"
method.invoke(javaBean, "testName");
System.out.println(javaBean.getUserName());
}
}