Java反射机制详解(3) -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框架提供