利用Java的反射与代理机制实现IOC

在 Java中，其反射和动态代理机制极其强大，我们可以通过其反射机制在运行时获取信息。而代理是一种基本的设计模式，它是一种为了提供额外的或不同的操作而插入到真实对象中的某个对象。而 Java的动态代理在代理上更进一步，既能动态的创建代理对象，又能动态的调用代理方法。 Java的反射和动态代理机制，使 Java变得更加强大。

       Spring框架这几年风头正劲，虽然使用者众多，但真正了解其内部实现原理的朋友却并不是很多。其实，了解它的内部实现机制和设计思想是很有必要的大家都知道， Spring框架的 IOC和 AOP部分功能强大，很值得我们学习。那么让我们在这两篇文章中分别详细的学习 IOC和 AOP的实现吧。

在本文中，主要讲述的是用 Java的反射机制实现 IOC。下面，让我们开始 IOC之旅吧！

一．             Java 反射机制概述与初探

Java的反射机制是 Java语言的一个重要特性， Java具有的比较突出的动态机制就是反射（ reflection）。通过它，我们可以获取如下信息：

1） 在运行时判断任意一个对象所属的类；

2） 在运行时获取类的对象；

3） 在运行时获得类所具有的成员变量和方法等。

下面让我们通过调用一个 Java Reflection API的演示实例来见识一下反射机制的强大。

首先在 IDE中建立名为 reflection_proxy的 Java工程，并建立存放源文件的目录 src，并在 src目录下分别建立 org.amigo. reflection目录和 org.amigo.proxy目录来分别存放代理和反射的实例。我们在 reflection目录下建立 ReflectionTest.java文件，在该文件中编写代码来演示 Java Reflection API的使用。该类的代码如下所示：

package  org.amigo.reflection;

import  java.awt.Button;
import  java.lang.reflect.Method;
import  java.util.Hashtable;

/** */ /**
 *初探Java的反射机制.   
 * @author <a href="mailto:xiexingxing1121@126.com">AmigoXie</a>
 *Creationdate:2007-10-2-上午10:13:48
  */
publicclass ReflectionTest  {

     /** */ /**
     *@paramargs
      */
    publicstaticvoid main(String[] args)  throws  Exception  {
        ReflectionTest reflection  =   new  ReflectionTest();
        reflection.getNameTest();
        System.out.println( "" );
        reflection.getMethodTest();
    }

     /** */ /**
     *Class的getName()方法测试.
     *@throwsException
      */
    publicvoid getNameTest()  throws  Exception  {
        System.out.println( " ===========begin getNameTest============ " );
        String name  =   " 阿蜜果 " ;
        Class cls  =  name.getClass();
        System.out.println( " String类名:  "   +  cls.getName());
        Button btn  =   new  Button();
        Class btnClass  =  btn.getClass();
        System.out.println( " Button类名:  "   +  btnClass.getName());
        Class superBtnClass  =  btnClass.getSuperclass();
        System.out.println( " Button的父类名:  "   +  superBtnClass.getName());
        Class clsTest  =  Class.forName( " java.awt.Button " );
        System.out.println( " clsTest name:  "   +  clsTest.getName());
        System.out.println( " ===========end getNameTest============ " );
    }
    
     /** */ /**
     *Class的getMethod()方法测试.
     *@throwsException
      */
    publicvoid getMethodTest()  throws  Exception  {
        System.out.println( " ===========begin getMethodTest========== " );
        Class cls  =  Class.forName( " org.amigo.reflection.ReflectionTest " );
        Class ptypes[]  =   new  Class[ 2 ];
        ptypes[ 0 ]  =  Class.forName( " java.lang.String " );
        ptypes[ 1 ]  =  Class.forName( " java.util.Hashtable " );
        Method method  =  cls.getMethod( " testMethod " , ptypes);
        Object args[]  =   new  Object[ 2 ];
        args[ 0 ]  =   " hello, my dear! " ;
        Hashtable < String, String >  ht  =   new  Hashtable < String, String > ();
        ht.put( " name " ,  " 阿蜜果 " );
        args[ 1 ]  =  ht;

        String returnStr  =  (String) method.invoke( new  ReflectionTest(), args);
        System.out.println( " returnStr=  "   +  returnStr);
        System.out.println( " ===========end getMethodTest========== " );
    }

     public  String testMethod(String str, Hashtable ht)  throws  Exception  {
        String returnStr  =   " 返回值 " ;
        System.out.println( " 测试testMethod()方法调用 " );
        System.out.println( " str=  "   +  str);
        System.out.println( " 名字=  "   +  (String) ht.get( " name " ));
        System.out.println( " 结束testMethod()方法调用 " );
         return  returnStr;
}
}

     运行该例，可在控制台看到如下内容：

===========begin getNameTest============

String 类名 : java.lang.String

Button 类名 : java.awt.Button

Button 的父类名 : java.awt.Component

clsTest name: java.awt.Button

===========end getNameTest============

===========begin getMethodTest==========

测试 testMethod() 方法调用

str= hello, my dear!

名字 = 阿蜜果

结束 testMethod() 方法调用

returnStr= 返回值

===========end getMethodTest==========

    分析运行结果，我们可以发现， Java 的反射机制使得我们在运行时能够判断一个对象所属的类，获取对象的方法并得其进行调用，并获取方法的返回结果等功能。

二．             IOC 使用的背景

在我们日常的设计中，类与类之间存在着千丝万缕的关系，如果两个类存在着强耦合关系，那么在维护时，一个类的修改很可能会牵动另一个类的关联修改，从而使得我们的维护工作步履维艰。下面让我们来看这样的一个强耦合反面例子。

首先我们建立一个 Chinese.java类，该类的 sayHelloWorld(String name)方法，用中文对名为 name的人问好，其内容如下：

package  org.amigo.reflection;

/** */ /**
 *中国人类.   
 * @author <a href="mailto:xiexingxing1121@126.com">AmigoXie</a>
 *Creationdate:2007-10-2-上午10:37:17
  */
publicclass Chinese  {

     /** */ /**
     *用中文对某人问好.
     *@paramname姓名
      */
    publicvoid sayHelloWorld(String name)  {
       String helloWorld  =   " 你好， "   +  name;
       System.out.println(helloWorld);
    }
}

 

下面我们接着建立一个 American.java 类， 该类的 sayHelloWorld(String name)方法，用英文对名为 name的人问好，其内容如下：

package  org.amigo.reflection;

/** */ /**
 *美国人类.   
 * @author <a href="mailto:xiexingxing1121@126.com">AmigoXie</a>
 *@version1.0
 *Creationdate:2007-10-2-上午10:41:27

  */
publicclass American  {

     /** */ /**
     *用英文对某人问好.
     *@paramname姓名
      */
    publicvoid sayHelloWorld(String name)  {
       String helloWorld  =   " Hello， "   +  name;
       System.out.println(helloWorld);
    }
}

 

    最后我们编写一个测试类对这两个类的 sayHelloWorld(String name) 方法进行测试，下面是该类的内容：

package  org.amigo.reflection;

/** */ /**
 *HelloWorld测试.
 * @author <a href="mailto:xiexingxing1121@126.com">AmigoXie</a>
 *Creationdate:2007-10-2-上午10:45:13
  */
publicclass HelloWorldTest  {

     /** */ /**
     *测试Chinese和American的sayHelloWorld()方法.
     *@paramargs
     * @author <a href="mailto:xiexingxing1121@126.com">AmigoXie</a>
     *Creationdate:2007-10-2-上午10:43:51
      */
    publicstaticvoid main(String[] args)  {
       Chinese chinese  =   new  Chinese();
       chinese.sayHelloWorld( " 阿蜜果 " );
       
       American american  =   new  American();
       american.sayHelloWorld( " Amigo " );
    }
}

 

    观察 HelloWorldTest 我们可以很清楚的看到，该类与 Chinese.java 类和 American.java 类都存在强耦合关系。

上面的例子让我们想到的是在 N 年以前，当我们需要某个东西时，我们一般是自己制造。但是当发展到了一定的阶段后，工厂出现了，我们可以工厂中购买我们需要的东西，这极大的方便了我们。在上例中，我们都是通过 new 来创建新的对象，在开发中，这种强耦合关系是我们所不提倡的，那么我们应该如何来实现这个例子的解耦呢？我们接着想到了使用工厂模式，我们需要新建一个工厂类来完成对象的创建，并采用依赖接口的方式，此时需要对代码进行如下修改：

首先建立接口类 Human.java ，其内容如下：

package  org.amigo.reflection;

/** */ /**
 * 人类接口类.    
 *  @author  <a href="mailto:xiexingxing1121@126.com">AmigoXie</a>
 * Creation date: 2007-10-2 - 上午11:04:56
  */
public   interface  Human  {

     /** */ /**
     * 对某人问好.
     *  @param  name 姓名
      */
     public   void  sayHelloWorld(String name);
}

 

并将 American.java类和 Chinese.java类改为实现该接口，即类头分别改成： public class American implements Human和 public class Chinese implements Human。

接着编写 HumanFactory.java工厂类，其内容为 ：

package  org.amigo.reflection;

/** */ /**
 * 工厂类.    
 *  @author  <a href="mailto:xiexingxing1121@126.com">AmigoXie</a>
 * Creation date: 2007-10-2 - 上午11:09:30
  */
public   class  HumanFactory  {

        /** */ /**
        * 通过类型字段获取人的相应实例
        *  @param  type 类型
        *  @return  返回相应实例
         */
        public  Human getHuman(String type)  {
               if  ( " chinese " .equals(type))  {
                      return   new  Chinese();
              }   else   {
                      return   new  American();
              }
       }
}

 

最后我们还需要修改测试类 HelloWorld.java类，修改后的内容如下：

package  org.amigo.reflection;

/** */ /**
 * HelloWorld测试.
 *  @author  <a href="mailto:xiexingxing1121@126.com">AmigoXie</a>
 * Creation date: 2007-10-2 - 上午10:45:13
  */
public   class  HelloWorldTest  {

        /** */ /**
        * 测试sayHelloWorld()方法.
        *  @param  args
        *  @author  <a href="mailto:xiexingxing1121@126.com">AmigoXie</a>
        * Creation date: 2007-10-2 - 上午10:43:51
         */
        public   static   void  main(String[] args)  {
              HumanFactory factory  =   new  HumanFactory();
              Human human1  =  factory.getHuman( " chinese " );
              human1.sayHelloWorld( " 阿蜜果 " );

              Human human2  =  factory.getHuman( " american " );
              human2.sayHelloWorld( " Amigo " );
              }
}

观察此例我们可以看到，该类不再与具体的实现类 Chinese和 American存在耦合关系，而只是与它们的接口类 Human存在耦合关系，具体对象的获取只是通过传入字符串来获取，很大程度上降低了类与类之间的耦合性。

但是我们还是不太满足，因为还需要通过 chinese和 american在类中获取实例，那么当我们需要修改时实现时，我们还需要在类中修改这些字符串，那么还有没有更好的办法呢？让我们在下节中进行继续探讨。

三．             IOC 粉墨登场

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工厂类.    
 *  @author  <a href="mailto:xiexingxing1121@126.com">AmigoXie</a>
 * Creation date: 2007-10-6 - 上午10:04:41
  */
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
        *  @author  <a href="mailto:xiexingxing1121@126.com">AmigoXie</a>
        * Creation date: 2007-10-6 - 上午11:21:14
         */
        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，用于测试   
 *  @author  <a href="mailto:xiexingxing1121@126.com">AmigoXie</a>
 * Creation date: 2007-10-6 - 上午11:24:30
  */
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框架提供方案，有兴趣的朋友可以通过 Spring的源码进行 IOC的进一步的学习。