java反射机制（三）---java的反射和代理实现IOC模式 模拟spring

IOC（Inverse of Control）可翻译为“控制反转”，但大多数人都习惯将它称为“依赖注入”。在Spring中，通过IOC可以将实现类、参数信息等配置在其对应的配置文件中，那么当需要更改实现类或参数信息时，只需要修改配置文件即可，这种方法在上例的基础上更进一步的降低了类与类之间的耦合。我们还可以对某对象所需要的其它对象进行注入，这种注入都是在配置文件中做的，Spring的IOC的实现原理利用的就是Java的反射机制，
Spring还充当了工厂的角色，我们不需要自己建立工厂类。Spring的工厂类会帮我们完成配置文件的读取、利用反射机制注入对象等工作，我们可以通过bean的名称获取对应的对象。

下面让我们看看如下的模拟Spring的bean工厂类：

package org.amigo.reflection;

import java.io.InputStream;

import java.lang.reflect.Method;

import java.util.HashMap;

import java.util.Iterator;

import java.util.Map;

import org.dom4j.Attribute;

import org.dom4j.Document;

import org.dom4j.Element;

import org.dom4j.io.SAXReader;

/**

* bean工厂类.

*/

public class BeanFactory {

private Map<String, Object> beanMap = new HashMap<String, Object>();

/**

* bean工厂的初始化.

* @param xml xml配置文件

*/

public void init(String xml) {

try {

//读取指定的配置文件

SAXReader reader = new SAXReader();

ClassLoader classLoader = Thread.currentThread().getContextClassLoader();

//从class目录下获取指定的xml文件

InputStream ins = classLoader.getResourceAsStream(xml);

Document doc = reader.read(ins);

Element root = doc.getRootElement();

Element foo;

//遍历bean

for (Iterator i = root.elementIterator("bean"); i.hasNext();) {

foo = (Element) i.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;

//创建一个对象

Object obj = bean.newInstance();

//遍历该bean的property属性

for (Iterator ite = foo.elementIterator("property"); ite.hasNext();) {

Element foo2 = (Element) ite.next();

//获取该property的name属性

Attribute name = foo2.attribute("name");

String value = null;

//获取该property的子元素value的值

for(Iterator ite1 = foo2.elementIterator("value"); ite1.hasNext();) {

Element node = (Element) ite1.next();

value = node.getText();

break;

}

for (int k = 0; k < pd.length; k++) {

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) {

System.out.println(e.toString());

}

}

/**

* 通过bean的id获取bean的对象.

* @param beanName bean的id

* @return 返回对应对象

*/

public Object getBean(String beanName) {

Object obj = beanMap.get(beanName);

return obj;

}

/**

* 测试方法.

* @param args

*/

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());

}

}

该类的init(xml)方法，通过指定的xml来给对象注入属性，为了对该类进行测试，我还需要新建一个JavaBean和在src目录下新建一个名为config.xml的配置文件。JavaBean的内容如下：

package org.amigo.reflection;

/**

*

* 简单的bean，用于测试

*/

public class JavaBean {

private String userName;

private String password;

public String getPassword() {

return password;

}

public String getUserName() {

return userName;

}

public void setUserName(String userName) {

this.userName = userName;

}

public void setPassword(String password) {

this.password = password;

}

}

这个简单bean对象中有两个属性，分别为userName和password，下面我们在配置文件config.xml中对其属性注入对应的属性值。配置文件内容如下：

<?xml version="1.0" encoding="UTF-8"?>

<beans>

<bean id="javaBean" class="org.amigo.reflection.JavaBean">

<property name="userName">

<value>阿蜜果</value>

</property>

<property name="password">

<value>12345678</value>

</property>

</bean>

</beans>

类与配置文件都完成后，可以运行BeanFactory.java文件，控制台显示内容为：

userName=阿蜜果

password=12345678

可以看到，虽然在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框架提供