java的反射和代理实现IOC模式 模拟spring

转自http://blog.csdn.net/wwww1988600/article/details/7286887

      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);*/
            InputStream ins = BeanFactory.class.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框架提供


PS:
BeanFactory类中注释的代码
ClassLoader classLoader = Thread.currentThread().getContextClassLoader();
// 从class目录下获取指定的xml文件
InputStream ins = classLoader.getResourceAsStream(xml);

xml需要制定完整的包名
例如："com/jzk/reflection/config.xml"

InputStream ins = BeanFactory.class.getResourceAsStream(xml);
中的xml只需要指定相对路径即可"config.xml"

public class Test {
 
    public static void main(String[] args) {
         
        // 此时三个ClassLoader是同一个对象
        System.out.println(Thread.currentThread().getContextClassLoader()); // 当前线程的类加载器
        System.out.println(Test.class.getClassLoader()); // 当前类的类加载器
        System.out.println(ClassLoader.getSystemClassLoader()); // 系统初始的类加载器
         
    }
}

打个简单的比方，你一个WEB程序，发布到Tomcat里面运行。
首先是执行Tomcat org.apache.catalina.startup.Bootstrap类，这时候的类加载器是ClassLoader.getSystemClassLoader()。
而我们后面的WEB程序，里面的jar、resources都是由Tomcat内部来加载的，所以你在代码中动态加载jar、资源文件的时候，首先应该是使用Thread.currentThread().getContextClassLoader()。如果你使用Test.class.getClassLoader()，可能会导致和当前线程所运行的类加载器不一致（因为Java天生的多线程）。
Test.class.getClassLoader()一般用在getResource，因为你想要获取某个资源文件的时候，这个资源文件的位置是相对固定的。