java反射机制学习

最新推荐文章于 2024-10-13 23:27:44 发布

fengwa

最新推荐文章于 2024-10-13 23:27:44 发布

阅读量331

点赞数 1

文章标签： java constructor class string integer object

反射机制:所谓的反射机制就是java语言在运行时拥有一项自观的能力。通过这种能力可以彻底的了解自身的情况为下一步的动作做准备。下面具体介绍一下java 的反射机制。这里你将颠覆原来对java的理解。

Java的反射机制的实现要借助于4个类：class，Constructor，Field，Method；其中class代表的时类对象，Constructor－类的构造器对象，Field－类的属性对象，Method－类的方法对象。通过这四个对象我们可以粗略的看到一个类的各个组成部分。

Class：程序运行时，java运行时系统会对所有的对象进行运行时类型的处理。这项信息记录了每个对象所属的类，虚拟机通常使用运行时类型信息选择正确的方法来执行（摘自：白皮书）。但是这些信息我们怎么得到啊，就要借助于class类对象了啊。在Object类中定义了getClass()方法。我们可以通过这个方法获得指定对象的类对象。然后我们通过分析这个对象就可以得到我们要的信息了。

Reflection 是 Java 程序开发语言的特征之一，它允许运行中的 Java 程序对自身进行检查，或者说“自审”，并能直接操作程序的内部属性。Java 的这一能力在实际应用中也许用得不是很多，但是个人认为要想对java有个更加深入的了解还是应该掌握的。

reflection的工作机制：

package TestReflect;

import java.lang.reflect.*;

public class DumpMethods {

   public static void main(String args[]) {

        try {

            Class c = Class.forName("java.util.ArrayList");

            Method m[] = c.getDeclaredMethods();

            for (int i = 0; i < m.length; i++)

                System.out.println(m[i].toString());

        } catch (Throwable e) {

            System.err.println(e);

        }

   }

}

Java类反射中的主要方法:

对于以下三类组件中的任何一类来说 -- 构造函数、字段和方法 -- java.lang.Class 提供四种独立的反射调用，以不同的方式来获得信息。调用都遵循一种标准格式。以下是用于查找构造函数的一组反射调用：

Constructor getConstructor(Class[] params) -- 获得使用特殊的参数类型的公共构造函数，

Constructor[] getConstructors() -- 获得类的所有公共构造函数

Constructor getDeclaredConstructor(Class[] params) -- 获得使用特定参数类型的构造函数(与接入级别无关)

Constructor[] getDeclaredConstructors() -- 获得类的所有构造函数(与接入级别无关)

获得字段信息的Class 反射调用不同于那些用于接入构造函数的调用，在参数类型数组中使用了字段名：

Field getField(String name) -- 获得命名的公共字段

Field[] getFields() -- 获得类的所有公共字段

Field getDeclaredField(String name) -- 获得类声明的命名的字段

Field[] getDeclaredFields() -- 获得类声明的所有字段

用于获得方法信息函数：

Method getMethod(String name, Class[] params) -- 使用特定的参数类型，获得命名的公共方法

Method[] getMethods() -- 获得类的所有公共方法

Method getDeclaredMethod(String name, Class[] params) -- 使用特写的参数类型，获得类声明的命名的方法

Method[] getDeclaredMethods() -- 获得类声明的所有方法

使用 Reflection：

用于 reflection 的类，如 Method，可以在 java.lang.relfect 包中找到。使用这些类的时候必须要遵循三个步骤：第一步是获得你想操作的类的 java.lang.Class 对象。在运行中的 Java 程序中，用 java.lang.Class 类来描述类和接口等。

下面就是获得一个 Class 对象的方法之一：

Class c = Class.forName("java.lang.String");

这条语句得到一个 String 类的类对象。还有另一种方法，如下面的语句：

Class c = int.class;

或者

Class c = Integer.TYPE;

它们可获得基本类型的类信息。其中后一种方法中访问的是基本类型的封装类 (如 Intege ) 中预先定义好的 TYPE 字段。

第二步是调用诸如 getDeclaredMethods 的方法，以取得该类中定义的所有方法的列表。

一旦取得这个信息，就可以进行第三步了——使用 reflection API 来操作这些信息，如下面这段代码：

Class c = Class.forName("java.lang.String");

Method m[] = c.getDeclaredMethods();

System.out.println(m[0].toString());

它将以文本方式打印出 String 中定义的第一个方法的原型。

处理对象：

a.创建一个Class对象

b.通过getField 创建一个Field对象

c.调用Field.getXXX(Object)方法(XXX是Int,Float等，如果是对象就省略；Object是指实例).

例如：

package TestReflect;

import java.lang.reflect.*;

import java.awt.*;

public class SampleGet {

   public static void main(String[] args) {
       Rectangle r = new Rectangle(100, 325);
       printHeight(r);
   }
   static void printHeight(Rectangle r) {
       Field heightField;
       Integer heightValue;
       Class c = r.getClass();
       try {
           heightField = c.getField("height");
           heightValue = (Integer) heightField.get(r);
           System.out.println("Height: " + heightValue.toString());
       } catch (NoSuchFieldException e) {
           System.out.println(e);
       } catch (SecurityException e) {
           System.out.println(e);
       } catch (IllegalAccessException e) {
           System.out.println(e);
       }
   }

}
以上我们对java的反射机制就有个初步的了解，下面就是比较深入的东东了当然是对于初学者来说。

安全性和反射：

在处理反射时安全性是一个较复杂的问题。反射经常由框架型代码使用，由于这一点，我们可能希望框架能够全面接入代码，无需考虑常规的接入限制。但是，在其它情况下，不受控制的接入会带来严重的安全性风险，例如当代码在不值得信任的代码共享的环境中运行时。

由于这些互相矛盾的需求，Java编程语言定义一种多级别方法来处理反射的安全性。基本模式是对反射实施与应用于源代码接入相同的限制：

从任意位置到类公共组件的接入

类自身外部无任何到私有组件的接入

受保护和打包（缺省接入）组件的有限接入

不过至少有些时候，围绕这些限制还有一种简单的方法。我们可以在我们所写的类中，扩展一个普通的基本类 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类的许可权限。

总结：

Java语言反射提供一种动态链接程序组件的多功能方法。它允许程序创建和控制任何类的对象(根据安全性限制)，无需提前硬编码目标类。这些特性使得反射特别适用于创建以非常普通的方式与对象协作的库。例如，反射经常在持续存储对象为数据库、XML或其它外部格式的框架中使用。Java reflection 非常有用，它使类和数据结构能按名称动态检索相关信息，并允许在运行着的程序中操作这些信息。Java 的这一特性非常强大，并且是其它一些常用语言，如 C、C++、Fortran 或者 Pascal 等都不具备的。

但反射有两个缺点。第一个是性能问题。用于字段和方法接入时反射要远慢于直接代码。性能问题的程度取决于程序中是如何使用反射的。如果它作为程序运行中相对很少涉及的部分，缓慢的性能将不会是一个问题。即使测试中最坏情况下的计时图显示的反射操作只耗用几微秒。仅反射在性能关键的应用的核心逻辑中使用时性能问题才变得至关重要。

许多应用中更严重的一个缺点是使用反射会模糊程序内部实际要发生的事情。程序人员希望在源代码中看到程序的逻辑，反射等绕过了源代码的技术会带来维护问题。反射代码比相应的直接代码更复杂，正如性能比较的代码实例中看到的一样。解决这些问题的最佳方案是保守地使用反射——仅在它可以真正增加灵活性的地方 ——记录其在目标类中的使用。

具体的应用：

1、模仿instanceof 运算符号

package TestReflect;
class A {
}
public class instance1 {
   public static void main(String args[])
   {
       try {
           Class cls = Class.forName("TestReflect.A");
           boolean b1= cls.isInstance(new Integer(37));
           System.out.println(b1);
           boolean b2 = cls.isInstance(new A());
           System.out.println(b2);
       }
       catch (Throwable e) {
            System.err.println(e);
       }
   }
}
当然它的输出结果为：

false
true

在类中寻找指定的方法，同时获取该方法的参数列表，异常和返回值

package TestReflect;

import java.lang.reflect.*;

public class Method1 {

    private int f1(Object p, int x) throws NullPointerException
    {
        if (p == null)throw new NullPointerException();
        return x;
    }
    public static void main(String args[])
    {
        try {
            //第一步是获得类的 java.lang.Class 对象。
            Class cls = Class.forName("TestReflect.Method1");
            //取得所有类声明的方法
            Method methlist[]= cls.getDeclaredMethods();
            //遍历类中每一个方法的名称，参数类型，和返回值类型，和抛出的异常类型
            for (int i = 0; i < methlist.length; i++) {
                Method m = methlist[i];
                System.out.println("name=" + m.getName());
                System.out.println("decl class = "+m.getDeclaringClass());
                Class pvec[] = m.getParameterTypes();
                for (int j = 0; j < pvec.length; j++)
                    System.out.println("param #" + j + " " + pvec[j]);
                Class evec[] = m.getExceptionTypes();
                for (int j = 0; j < evec.length; j++)
                    System.out.println("exc #" + j
                    + " " + evec[j]);
                System.out.println("return type = " +m.getReturnType());
                System.out.println("-----");
            }
        }
        catch (Throwable e) {
            System.err.println(e);
        }
    }
}

3、获取类的构造函数信息，基本上与获取方法的方式相同

package TestReflect;

import java.lang.reflect.*;

public class Constructor1 {

    public Constructor1(){

    }
    protected Constructor1(int i, double d){
    }
    public static void main(String args[]){
        try {
            Class cls = Class.forName("TestReflect.Constructor1");
            Constructor ctorlist[]= cls.getDeclaredConstructors();
            for (int i = 0; i < ctorlist.length; i++) {
                Constructor ct = ctorlist[i];
                System.out.println("name= " + ct.getName());
                System.out.println("decl class = " +
                ct.getDeclaringClass());
                Class pvec[] = ct.getParameterTypes();
                for (int j = 0; j < pvec.length; j++)
                    System.out.println("param #"+ j + " " + pvec[j]);
                Class evec[] = ct.getExceptionTypes();
                for (int j = 0; j < evec.length; j++)
                    System.out.println("exc #" + j + " " + evec[j]);
                System.out.println("-----");
            }
        }
        catch (Throwable e) {
            System.err.println(e);
        }
    }
}
4. 获取类中的各个数据成员对象，包括名称。类型和访问修饰符号

package TestReflect;
import java.lang.reflect.*;
public class Field1 {
    private double d;
    public static final int i =1;
    String str = "test";
    public static void main(String args[])
    {
        try {
            Class cls = Class.forName("TestReflect.Field1");
            Field fieldlist[]= cls.getDeclaredFields();
            for (int i=0; i< fieldlist.length; i++) {
                Field fld = fieldlist[i];
                System.out.println("name= " + fld.getName());
                System.out.println("decl class = " +fld.getDeclaringClass());
                System.out.println("type= " + fld.getType());
                int mod = fld.getModifiers();
                System.out.println("modifiers = " +    Modifier.toString(mod));
                System.out.println("-----");
            }
        }
        catch (Throwable e) {
            System.err.println(e);
        }
    }
}