Java动态程序设计：反射介绍

蘑菇 — Mon, 26 Sep 2005 02:22:00 GMT

Java动态程序设计：反射介绍
muzi_li 翻译版本：1.0

Java动态程序设计：反射介绍
使用运行的类的信息使你的程序设计更加灵活

反射授予了你的代码访问装载进JVM内的Java类的内部信息的权限，并且允许你编写在程序执行期间与所选择的类的一同工作的代码，而不是在源代码中。这种机制使得反射成为创建灵活的应用程序的强大工具，但是要小心的是，如果使用不恰当，反射会带来很大的副作用。在这篇文章中，软件咨询顾问Dennis Sosnoski 介绍了反射的使用，同时还介绍了一些使用反射所要付出的代价。在这里，你可以找到Java反射API是如何在运行时让你钩入对象的。

在第一部分，我向你介绍了Java程序设计的类以及类的装载。那篇文章中描述了很多出现在Java二进制类格式中的信息，现在我来介绍在运行时使用反射API访问和使用这些信息的基础。为了使那些已经了解反射基础的开发人员对这些事情感兴趣，我还会介绍一些反射与直接访问的在性能方面的比较。

使用反射与和metadata(描述其它数据的数据)一些工作的Java程序设计是不同的。通过Java语言反射来访问的元数据的特殊类型是在JVM内部的类和对象的描述。反射使你可以在运行时访问各种类信息，它甚至可以你让在运行时读写属性字段、调用所选择的类的方法。

反射是一个强大的工具，它让你建立灵活能够在运行时组装的代码，而不需要连接组件间的源代码。反射的一些特征也带来一些问题。在这章中，我将会探究在应用程序中不打算使用反射的原因，以为什么使用它的原因。在你了解到这些利弊之后，你就会在好处大于缺点的时候做出决定。

初识class
使用反射的起点总时一个java.lang.Class类的实例。如果你与一个预先确定的类一同工作，Java语言为直接获得Class类的实例提供了一个简单的快捷方式。例如：
Class clas = MyClass.class;

当你使用这项技术的时候，所有与装载类有关的工作都发生在幕后。如果你需要在运行时从外部的资源中读取类名，使用上面这种方法是不会达到目的的，相反你需要使用类装载器来查找类的信息，方法如下所示：
// "name" is the class name to load
Class clas = null;
try {
  clas = Class.forName(name);
} catch (ClassNotFoundException ex) {
  // handle exception case
}
// use the loaded class

如果类已经装载，你将会找到当前在在的类的信息。如果类还没有被装载，那么类装载器将会装载它，并且返回最近创建的类的实例。

关于类的反射

Class对象给予你了所有的用于反射访问类的元数据的基本钩子。这些元数据包括有关类的自身信息，例如象类的包和子类，还有这个类所实现的接口，还包括这个类所定义的构造器、属性字段以及方法的详细信息。后面的这些项是我们在程序设计过种经常使用的，因此在这一节的后面我会给出一些用这些信息来工作的例子。

对于类的构造中的每一种类型（构造器、属性字段、方法），java.lang.Class提供了四种独立的反射调用以不的方式来访问类的信息。下面列出了这四种调用的标准形式，它是一组用于查找构造器的调用。

Constructor getConstructor(Class[] params)   使用指定的参数类型来获得公共的构造器；
Constructor[] getConstructors()    获得这个类的所有构造器；
Constructor getDeclaredConstructor(Class[] params) 使用指定的参数类型来获得构造器（忽略访问的级别）
Constructor[] getDeclaredConstructors()  获得这个类的所有的构造器（忽略访问的级别）

上述的每一种方法都返回一或多个java.lang.reflect.Constructor的实例。Constructor类定义了一个需要一个对象数据做为唯一参数的newInstance方法，然后返回一个最近创建的原始类的实例。对象数组是在构造器调用时所使用的参数值。例如，假设你有一个带有一对String 类型做为参数的构造器的TwoString类，代码如下所示：
public class TwoString {
    private String m_s1, m_s2;
    public TwoString(String s1, String s2) {
        m_s1 = s1;
        m_s2 = s2;
    }
}

下面的代码显示如何获得TwoString类的构造器，并使用字符串“a”和“b”来创建一个实例：
Class[] types = new Class[] { String.class, String.class };
    Constructor cons = TwoString.class.getConstructor(types);
    Object[] args = new Object[] { "a", "b" };
    TwoString ts = cons.newInstance(args);

上面的代码忽略了几种可能的被不同的反射方法抛出的异常检查的类型。这些异常在Javadoc　API中有详细的描述，因此为简便起见，我会在所有的代码中忽略它们。

在我涉及到构造器这个主题时，Java语言也定义了一个特殊的没有参数的（或默认）构造器快捷方法，你能使用它来创建一个类的实例。这个快捷方法象下面的代码这样被嵌入到类的自定义中：
Object newInstance() ?使用默认的构造器创建新的实例。

尽管这种方法只让你使用一个特殊的构造器，但是如果你需要的话，它是非常便利的快捷方式。这项技术在使用JavaBeans工作的时候尤其有用，因为JavaBeans需要定义一个公共的、没有参数的构造器。

通过反射来查找属性字段

Class类反射调用访问属性字段信息与那些用于访问构造器的方法类似，在有数组类型的参数的使用属性字段名来替代：使用方法如下所示：
Field getField(String name)  --获得由name指定的具有public级别的属性字段
Field getFields() ?获得一个类的所有具有public级别的属性字段
Field getDeclaredField(String name) ?获得由name指定的被类声明的属性字段
Field getDeclaredFields() ?获得由类定义的所有的属性字段

尽管与构造器的调用很相似，但是在提到属性字段的时候，有一个重要的差别：前两个方法返回能过类来访问的公共（public）属性字段的信息（包括那些来自于超类的属性字段），后两个方法返回由类直接声明的所有的属性字段（忽略了属性字段的访问类型）。

Java.lang.reflect.Field的实例通过调用定义好的getXXX和setXXX方法来返回所有的原始的数据类型，就像普通的与对象引用一起工作的get和set方法一样。尽管getXXX方法会自动地处理数据类型转换（例如使用getInt方法来获取一个byte类型的值），但使用一个适当基于实际的属性字段类型的方法是应该优先考虑的。

下面的代码显示了如何使用属性字段的反射方法，通过指定属性字段名，找到一个对象的int类型的属性字段，并给这个属性字段值加1。
public int incrementField(String name, Object obj) throws... {
    Field field = obj.getClass().getDeclaredField(name);
    int value = field.getInt(obj) + 1;
    field.setInt(obj, value);
    return value;
}

这个方法开始展现一些使用反射所可能带来的灵活性，它优于与一个特定的类一同工作，incrementField方法把要查找的类信息的对象传递给getClass方法，然后直接在那个类中查找命名的属性字段。

通过反射来查找方法
Class反射调用访问方法的信息与访问构造器和字段属性的方法非常相似：
    Method getMethod(String name,Class[] params)  --使用指定的参数类型获得由name参数指定的public类型的方法。
Mehtod[] getMethods()?获得一个类的所有的public类型的方法
Mehtod getDeclaredMethod(String name, Class[] params)?使用指定的参数类型获得由name参数所指定的由这个类声明的方法。
Method[] getDeclaredMethods() ?获得这个类所声明的所有的方法

与属性字段的调用一样，前两个方法返回通过这个类的实例可以访问的public类型的方法?包括那些继承于超类的方法。后两个方法返回由这个类直接声明的方法的信息，而不管方法的访问类型。

通过调用返回的Java.lang.reflect.Mehtod实例定义了一个invoke方法，你可以使用它来调用定义类的有关实例。这个invoke方法需要两个参数，一个是提供这个方法的类的实例，一个是调用这个方法所需要的参数值的数组。

下面给出了比属性字段的例子更加深入的例子，它显示了一个的方法反射的例子，这个方法使用get和set方法来给JavaBean定义的int类型的属性做增量操作。例如，如果对象为一个整数类型count属性定义了getCount和setCount方法，那么为了给这个属性做增量运算，你就可以把“count”做为参数名传递给调用的这个方法中。示例代码如下：
public int incrementProperty(String name, Object obj) {
    String prop = Character.toUpperCase(name.charAt(0)) +
        name.substring(1);
    String mname = "get" + prop;
    Class[] types = new Class[] {};
    Method method = obj.getClass().getMethod(mname, types);
    Object result = method.invoke(obj, new Object[0]);
    int value = ((Integer)result).intValue() + 1;
    mname = "set" + prop;
    types = new Class[] { int.class };
    method = obj.getClass().getMethod(mname, types);
    method.invoke(obj, new Object[] { new Integer(value) });
    return value;
}

根据JavaBeans的规范，我把属性名的第一个字母转换为大写，然后在前面加上“get”来建立读取属性值的方法名，在属性名前加上“set”来建立设置属性值的方法名。JavaBeans的读方法只返回属性值，写方法只需要要写入的值做为参数，因此我指定了与这个方法相匹配的参数类型。最后规范规定这两个方法应该是public类型的，因此我使用了查找相关类的public类型方法的调用形式。

这个例子我首先使用反射传递一个原始类型的值，因此让我们来看一下它是怎样工作的。基本的原理是简单的：无论什么时候，你需要传递一个原始类型的值，你只要替换相应的封装原始类型的（在java.lang 包中定义的）的类的实例就可以了。这种方法可应用于调用和返回。因此在我的例子中调用get方法时，我预期的结果是一个由java.lang.Integer类所封装的实际的int类型的属性值。

反射数组

在Java语言中数组是对象，象其它所有的对象一样，它有一些类。如果你有一个数组，你可以和其它任何对象一样使用标准的getClass方法来获得这个数组的类，但是你获得的这个类与其它的对象类型相比，不同之处在它没有一个现存的工作实例。即使你有了一个数组类之后，你也不能够直接用它来做任何事情，因为通过反射为普通的类所提供的构造器访问不能为数组工作，并且数组没有任何可访问的属性字段，只有基本的为数组对象定义的java.lang.Object类型的方法。

数组特殊处理要使用java.lang.reflect.Array类提供的一个静态方法的集合，这个类中的方法可以让你创建新的数组，获得一个数组对象的长度，以及读写一个数组对象的索引值。

下面的代码显示了有效调整一个现存数组的尺寸的方法。它使用反射来创建一个相同类型的新数组，然后在返回这个新数组之前把原数组中的所有的数据复制到新的数组中。
public Object growArray(Object array, int size) {
    Class type = array.getClass().getComponentType();
    Object grown = Array.newInstance(type, size);
    System.arraycopy(array, 0, grown, 0,
        Math.min(Array.getLength(array), size));
    return grown;
}

安全与反射

在处理反射的时候，安全是一个复杂的问题。反射正常被框架类型的代码使用，并因为这样，你可能会经常要求框架不关心普通的访问限制来完全访问你的代码。然而，自由的访问可能会在其它的一些实例中产生一些风险，例如在代码在一个不被信任的代码共享环境中被执行的时候。

因为这些冲突的需要，Java语言定义了一个多级方法来处理反射安全。基本的模式是在反射请求源码访问的时候强制使用如下相同的约束限制：
访问这个类中来自任何地方的public组件；
不访问这个类本身外部的private组件；
限制访问protected和package(默认访问)组件。

围绕这些限制有一个简单的方法，我在前面的例子中所使用的所有构造器、属性字段、以及类的方法都扩展于一个共同的基类???java.lang.reflect.AccessibleObject类。这个类定义了一个setAccessible方法，这个方法可以让你打开或关闭这些对类的实例的访问检查。如果安全管理器被设置为关闭访问检查，那么就允许你访问，否则不允许，安全管理器会抛出一个异常。

下面是一个使用反向来演示这种行为的TwoString类的实例。
public class ReflectSecurity {
    public static void main(String[] args) {
        try {
            TwoString ts = new TwoString("a", "b");
            Field field = clas.getDeclaredField("m_s1");
//          field.setAccessible(true);
            System.out.println("Retrieved value is " +
                field.get(inst));
        } catch (Exception ex) {
            ex.printStackTrace(System.out);
        }
    }
}

如果你编译这段代码并且直接使用不带任何参数的命令行命令来运行这个程序，它会抛出一个关于field.get(inst)调用的IllegalAccessException异常，如果你去掉上面代码中field.setAccessible(true)行的注释，然后编译并重新运行代码，它就会成功执行。最后，如果你在命令行给JVM添加一个Djava.security.manager参数，使得安全管理器可用，那么它又会失败，除非你为ReflectSecurity类定义安全许可。

反射性能
反射是一个强大的工具，但是也会带一些缺点。主要缺点之一就是对性能的影响。使用反射是基本的解释性操作，你告诉JVM你要做什么，它就会为你做什么。这种操作类型总是比直接做同样的操作要慢。为了演示使用反射所要付出的性能代价，我为这篇文章准备了一套基准程序（可以从资源中下载）。

下面列出一段来自于属性字段的访问性能测试的摘要，它包括基本的测试方法。每个方法测试一种访问属性字段的形式，accessSame方法和本对象的成员字段一起工作，accessReference方法直接使用另外的对象属性字段来存取，accessReflection通过反射使用另一个对象的属性字段来存取，每个方法都使用相同的计算???在循环中简单的加/乘运算。
public int accessSame(int loops) {
    m_value = 0;
    for (int index = 0; index < loops; index++) {
        m_value = (m_value + ADDITIVE_VALUE) *
            MULTIPLIER_VALUE;
    }
    return m_value;
}

public int accessReference(int loops) {
    TimingClass timing = new TimingClass();
    for (int index = 0; index < loops; index++) {
        timing.m_value = (timing.m_value + ADDITIVE_VALUE) *
            MULTIPLIER_VALUE;
    }
    return timing.m_value;
}

public int accessReflection(int loops) throws Exception {
    TimingClass timing = new TimingClass();
    try {
        Field field = TimingClass.class.
            getDeclaredField("m_value");
        for (int index = 0; index < loops; index++) {
            int value = (field.getInt(timing) +
                ADDITIVE_VALUE) * MULTIPLIER_VALUE;
            field.setInt(timing, value);
        }
        return timing.m_value;
    } catch (Exception ex) {
        System.out.println("Error using reflection");
        throw ex;
    }
}

测试程序在一个大循环中反复的调用每个方法，在调用结束后计算平均时间。每个方法的第一次调用不包括在平均值中，因些初始化时间不是影响结果的因素。为这篇文章所做的测试运行，我为每个调用使用了10000000的循环计数，代码运行在1GHz　PIII系统上。并且分别使用了三个不同的Linux　JVM，对于每个JVM都使用了默认设置，测试结果如下图所示：

上面的图表的刻度可以显示整个测试范围，但是那样的话就会减少差别的显示效果。这个图表中的前两个是用SUN的JVM的进行测试的结果图，使用反射的执行时间比使用直接访问的时间要超过1000多倍。最后一个图是用IBM的JVM所做的测试，通过比较要SUN的JVM执行效率要高一些，但是使用反射的方法依然要比其它方法超出700多倍。虽然IBM的JVM要比SUN的JVM几乎要快两倍，但是在使用反射之外的两种方法之间，对于任何的JVM在执行效率上没有太大的差别。最大的可能是，这种差别反映了通过Sun Hot Spot JVMs在简化基准方面所做的专门优化很少。

除了属性字段访问时间的测试以外，我对方法做了同样的测试。对于方法的调用，我偿试了与属性字段访问测试一样的三种方式，用额外使用了没有参数的方法的变量与传递并返回一个值的方法调用相对比。下面的代码显示了使用传递并返回值的调用方式进行测试的三种方法。
public int callDirectArgs(int loops) {
    int value = 0;
    for (int index = 0; index < loops; index++) {
        value = step(value);
    }
    return value;
}

public int callReferenceArgs(int loops) {
    TimingClass timing = new TimingClass();
    int value = 0;
    for (int index = 0; index < loops; index++) {
        value = timing.step(value);
    }
    return value;
}

public int callReflectArgs(int loops) throws Exception {
    TimingClass timing = new TimingClass();
    try {
        Method method = TimingClass.class.getMethod
            ("step", new Class [] { int.class });
        Object[] args = new Object[1];
        Object value = new Integer(0);
        for (int index = 0; index < loops; index++) {
            args[0] = value;
            value = method.invoke(timing, args);
        }
        return ((Integer)value).intValue();
    } catch (Exception ex) {
        System.out.println("Error using reflection");
        throw ex;
    }
}

下图显示我使用这些方法的测试结果，这里再一次显示了反射要比其它的直接访问要慢很多。虽然对于无参数的案例，执行效率从SUN1.3.1JVM的慢几百倍到IBM的JVM慢不到30倍，与属性字段访问案例相比，差别不是很大，这种情况的部分原因是因为java.lang.Integer的包装器需要传递和返回int类型的值。因为Intergers是不变的，因此就需要为每个方法的返回生成一个新值，这就增加了相当大的系统开销。

反射的性能是SUN在开发1.4JVM时重点关注的一个领域，从上图可以看到改善的结果。Sun1.4.1JVM对于这种类型的操作比1.3.1版有了很大的提高，要我的测试中要快大约7倍。IBM的1.4.0JVM对于这种测试提供了更好的性能，它的运行效率要比Sun1.4.1JVM快两到三倍。

我还为使用反射创建对象编写了一个类似的效率测试程序。虽然这个例子与属性字段和方法调用相比差别不是很大，但是在Sun1.3.1JVM上调用newInstance（）方法创建一个简单的java.lang.Object大约比直接使用new Object()方法长12倍的时间，在IBM1.4.0JVM上大约要长4倍的时间，在Sun1.4.1JVM上大约要长2倍的时间。对于任何用于测试的JVM，使用Array.newInstance(Type,size)方法创建一个数组所需要的时间比使用new tye[size]所花费的时间大约要长两倍，随着数组民尺寸的增长，这两种方法的差别的将随之减少。

反射概要总结

Java 语言的反射机制提供了一种非常通用的动态连接程序组件的方法。它允许你的程序创建和维护任何类的对象（服从安全限制），而不需要提前对目标类进行硬编码。这些特征使得反射在创建与对象一同工作的类库中的通用方法方面非常有用。例如，反射经常被用于那些数据库，XML、或者其它的外部的持久化对象的框架中。

反射还有两个缺点，一个是性能问题。在使用属性字段和方法访问的时候，反射要比直接的代码访问要慢很多。至于对影响的程度，依赖于在程序中怎样使用反射。如果它被用作一个相关的很少发生的程序操作中，那么就不必关心降低的性能，即使在我的测试中所展示的最耗时的反射操作的图形中也只是几微秒的时间。如果要在执行应用程序的核心逻辑中使用反射，性能问题才成为一个要严肃对象的问题。

对于很多应用中的存在的缺点是使用反射可以使你的实际的代码内部逻辑变得模糊不清。程序员都希望在源代码中看到一个程序的逻辑以及象绕过源代码的反射所可能产生的维护问题这样的一些技术。反射代码也比相应的直接代码要复杂一些，就像在性能比较的代码实例看到那样。处理这些问题的最好方法是尽可能少使用反射，只有在一些增加灵活性的地方来使用它。

在下一篇文章中，我将给出一个更加详细的如何使用反射的例子。这个例子提供了一个用于处理传递给一个Java应用程序的命令行参数的API。在避免弱点的同时，它也显示了反射的强大的功能，反射能够使用的你的命令处理变得的简单吗？你可以在Java 动态程序设计的第三部分中找到答案。

蘑菇 2005-09-26 10:22 发表评论

java实现笛卡儿公式

蘑菇 — Mon, 01 Aug 2005 09:09:00 GMT

//program: 笛卡尔数学公式
//files: Heart.java

import java.applet.*;
import java.awt.*;

public class Heart extends Applet
{
    int AppletWidth,AppletHeight;
    Image OffScreen;
    Graphics drawOffScreen;

    public void init()
    {
        setBackground(Color.black);

        //取得显示区域
        AppletWidth = getSize().width;
        AppletHeight = getSize().height;

        //建立次画面
        OffScreen = createImage(AppletWidth,AppletHeight);
        drawOffScreen = OffScreen.getGraphics();
    }

    public void paint(Graphics g)
    {
        drawOffScreen.clearRect(0,0,AppletWidth,AppletHeight);
        drawOffScreen.setColor(Color.white);

        int i,j;
        double x,y,r;

        for(i = 0;i <= 90;i++)
            for(j = 0;j <= 90;j++)
            {
                //转换为直角坐标
                r = Math.PI/45*i*(1-Math.sin(Math.PI/45*j))*18;
                x = r*Math.cos(Math.PI/45*j)*Math.sin(Math.PI/45*i)+AppletWidth/2;
                y = -r*Math.sin(Math.PI/45*j)+AppletHeight/4;

                //投影到xz平面
                drawOffScreen.fillOval((int)x,(int)y,2,2);
             }
         g.drawImage(OffScreen,0,0,this);
     }
}

蘑菇 2005-08-01 17:09 发表评论

BlogJava-夏天到了-文章分类-JAVA

Java动态程序设计：反射介绍

java实现笛卡儿公式