利用Java的反射与代理实现IOC模式

转载 2007年10月15日 11:11:00
    在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();
    }
   
    /**
     *ClassgetName()方法测试.
     *@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============");
    }
   
    /**
     *ClassgetMethod()方法测试.
     *@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 {
 
    /**
     *测试ChineseAmericansayHelloWorld()方法.
     *@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的进一步的学习。

IOC的实现原理—反射与工厂模式

反射机制概念 我们考虑一个场景,如果我们在程序运行时,一个对象想要检视自己所拥有的成员属性,该如何操作?再考虑另一个场景,如果我们想要在运行期获得某个类的Class信息如它的属性、构造方法、一般方法...
  • fuzhongmin05
  • fuzhongmin05
  • 2017年03月12日 10:37
  • 2331

Java动态代理的理解(知乎转发)

在知乎上看到一个很好的关于Java动态代理的回答,并且例子也很经典,留着今后复习用了。 Java动态代理相关 先来看静态代理模式代码: package test; public interface ...
  • donggua3694857
  • donggua3694857
  • 2016年09月29日 10:30
  • 1417

反射 实现工厂模式 和 spring IOC 实现原理

下面的程序是从魔乐科技java教程里面抄来的,感觉这几段程序说明了一些问题,所以就抄过来了。 下面是一个简单的工厂模式  [java] view plaincopy ...
  • JackieLiuLixi
  • JackieLiuLixi
  • 2014年09月11日 09:41
  • 1603

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

在上一篇文章中,我们讲述了利用Java的反射机制中实现Spring中的IOC,在本文中,我们将更进一步,讲述用Java的反射和动态代理机制来实现Spring的AOP。 一.AOP概述        A...
  • xybelieve1990
  • xybelieve1990
  • 2016年01月19日 17:10
  • 981

从代理模式到IOC/AOP

业务代理模式,也成为代理者模式。它的核心思想即使用一个通用接口包装一个功能接口,这样,外部访问此功能时,可以在通用接口的代理这里先预处理一部分内容,然后再去执行功能接口。 如果是一个通用接口对一个功...
  • qq_35082030
  • qq_35082030
  • 2016年07月17日 10:23
  • 819

利用Java的反射与代理实现IOC模式

在Java中,其反射和动态代理机制极其强大,我们可以通过其反 射机制在运行时获取信息。而代理是一种基本的设计模式,它是一种为了提供额外的或不同的操作而插入到真 实对象中的某个对象。而Java的动态代理...
  • myself_helper
  • myself_helper
  • 2014年03月14日 12:52
  • 558

利用反射简单模拟Spring的控制反转(Ioc)和依赖注入(DI)

利用反射简单模拟Spring的控制反转(Ioc)和依赖注入(DI) 1.配置文件(.properties)中配置要扫描的包: #扫描page对象的包 init.pageobj.Package = e...
  • wangxin1982314
  • wangxin1982314
  • 2015年12月08日 17:23
  • 1555

Spring IOC原理之Java反射机制

1、反射概念以及为什么要使用反射 我们考虑一个场景,如果我们在程序运行时,一个对象想要检视自己所拥有的成员属性,该如何操作? 那再考虑这样另一个场景,如果我们想要在运行期获得某个类Class的信息如它...
  • zhangliangzi
  • zhangliangzi
  • 2016年03月26日 10:17
  • 9620

java利用反射机制模拟spring IOC实现

第一步:定义服务的配置文件(指定服务名和服务路径) 原创不易,转载请注明出处:java利用反射机制模拟spring IOC实现 代码下载地址:ht...
  • yaerfeng
  • yaerfeng
  • 2014年03月27日 12:23
  • 4405

Java反射机制在Spring IOC中的应用

IOC:即“控制反转”,不是什么技术,而是一种思想。使用IOC意味着将你设计好的对象交给容器控制,而不是传统的在你的对象内部直接控制。 本篇文章主要讲解一下IOC底层实现的原理(反射),就不对IOC的...
  • mlc1218559742
  • mlc1218559742
  • 2016年10月10日 09:48
  • 4933
内容举报
返回顶部
收藏助手
不良信息举报
您举报文章:利用Java的反射与代理实现IOC模式
举报原因:
原因补充:

(最多只允许输入30个字)