java反射技术的应用

Posted 2020-08-08

tags:

篇首语：本文由小常识网(cha138.com)小编为大家整理，主要介绍了java反射技术的应用相关的知识，希望对你有一定的参考价值。

开发的时候有时候会碰到这样的情况，我们在写程序的时候并不知道需要调用某个对象的哪个方法，只有程序运行后，我们才能够知道。或许我们需要根据客户端传过来的某个String 参数的值来判断我们应该执行哪个方法。在这种情况下JAVA 的反射执行就可以帮上忙了。下面是我做的一个简单的测试代码，提供给大家做个参考。

import  java.lang.reflect.InvocationTargetException;
import  java.lang.reflect.Method;

/**
*  @author  Dong
*  测试 JAVA reflect 机制
*/
public   class  TestRef {
     /**
     *  @param  args
     */
     public   static   void  main(String[] args) {
            TestBean test =  new  TestBean();
            Method[] methods = test.getClass().getMethods();
            test.setAbc("---");
             for ( int  i=0;i<methods.length;i++) {
                 if (methods[i].getName().equalsIgnoreCase("getabc")) {
                     try   {
                        System.out.println(methods[i].invoke(test));
                    }  catch  (IllegalArgumentException e)  {
                        e.printStackTrace();
                    }  catch  (IllegalAccessException e)  {
                        e.printStackTrace();
                    }  catch  (InvocationTargetException e)  {
                        e.printStackTrace();
                    }
                }
            }
    }
}

JAVA 反射机制
    JAVA 反射机制是在运行状态中，对于任意一个类，都能够知道这个类的所有属性和方法；对于任意一个对象，都能够调用它的任意一个方法；这种动态获取的信息以及动态调用对象的方法的功能称为java 语言的反射机制。
Java 反射机制主要提供了以下功能：  在运行时判断任意一个对象所属的类；在运行时构造任意一个类的对象；在运行时判断任意一个类所具有的成员变量和方法；在运行时调用任意一个对象的方法；生成动态代理。
1.  得到某个对象的属性

1 public Object getProperty(Object owner, String fieldName) throws Exception {
2     Class ownerClass = owner.getClass();
3
4     Field field = ownerClass.getField(fieldName);
5
6     Object property = field.get(owner);
7
8     return property;
9 }
Class ownerClass = owner.getClass() ：得到该对象的Class 。

Field field = ownerClass.getField(fieldName) ：通过Class 得到类声明的属性。

Object property = field.get(owner) ：通过对象得到该属性的实例，如果这个属性是非公有的，这里会报IllegalAccessException 。

2.  得到某个类的静态属性

1 public Object getStaticProperty(String className, String fieldName)
2             throws Exception {
3     Class ownerClass = Class.forName(className);
4
5     Field field = ownerClass.getField(fieldName);
6
7     Object property = field.get(ownerClass);
8
9     return property;
10 }

Class ownerClass = Class.forName(className)  ：首先得到这个类的Class 。

Field field = ownerClass.getField(fieldName) ：和上面一样，通过Class 得到类声明的属性。

Object property = field.get(ownerClass)  ：这里和上面有些不同，因为该属性是静态的，所以直接从类的Class 里取。

3.  执行某对象的方法

1 public Object invokeMethod(Object owner, String methodName, Object[] args) throws Exception {
2
3     Class ownerClass = owner.getClass();
4
5     Class[] argsClass = new Class[args.length];
6
7     for (int i = 0, j = args.length; i < j; i++) {
8         argsClass[i] = args[i].getClass();
9     }
10
11     Method method = ownerClass.getMethod(methodName, argsClass);
12
13     return method.invoke(owner, args);
14 }
Class owner_class = owner.getClass()  ：首先还是必须得到这个对象的Class 。

5 ～9 行：配置参数的Class 数组，作为寻找Method 的条件。

Method method = ownerClass.getMethod(methodName, argsClass) ：通过Method 名和参数的Class 数组得到要执行的Method 。

method.invoke(owner, args) ：执行该Method ，invoke 方法的参数是执行这个方法的对象，和参数数组。返回值是Object ，也既是该方法的返回值。

4.  执行某个类的静态方法

1 public Object invokeStaticMethod(String className, String methodName,
2             Object[] args) throws Exception {
3     Class ownerClass = Class.forName(className);
4
5     Class[] argsClass = new Class[args.length];
6
7     for (int i = 0, j = args.length; i < j; i++) {
8         argsClass[i] = args[i].getClass();
9     }
10
11     Method method = ownerClass.getMethod(methodName, argsClass);
12
13     return method.invoke(null, args);
14 }

基本的原理和实例3 相同，不同点是最后一行，invoke 的一个参数是null ，因为这是静态方法，不需要借助实例运行。

5.  新建实例
1
2 public Object newInstance(String className, Object[] args) throws Exception {
3     Class newoneClass = Class.forName(className);
4
5     Class[] argsClass = new Class[args.length];
6
7     for (int i = 0, j = args.length; i < j; i++) {
8         argsClass[i] = args[i].getClass();
9     }
10
11     Constructor cons = newoneClass.getConstructor(argsClass);
12
13     return cons.newInstance(args);
14
15 }

这里说的方法是执行带参数的构造函数来新建实例的方法。如果不需要参数，可以直接使用newoneClass.newInstance() 来实现。

Class newoneClass = Class.forName(className) ：第一步，得到要构造的实例的Class 。

第5 ～第9 行：得到参数的Class 数组。

Constructor cons = newoneClass.getConstructor(argsClass) ：得到构造子。

cons.newInstance(args) ：新建实例。

6.  判断是否为某个类的实例

1 public boolean isInstance(Object obj, Class cls) {
2     return cls.isInstance(obj);
3 }

7.  得到数组中的某个元素
1 public Object getByArray(Object array, int index) {
2     return Array.get(array,index);
3 }

Java 反射机制深入研究

Java 反射是 Java 语言的一个很重要的特征，它使得 Java 具体了 “ 动态性 ” 。

在 Java 运行时环境中，对于任意一个类，能否知道这个类有哪些属性和方法？对于任意一个对象，能否调用它的任意一个方法？答案是肯定的。这种动态获取类的信息以及动态调用对象的方法的功能来自于 Java 语言的反射（ Reflection ）机制。

Java 反射机制主要提供了以下功能：

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

在运行时构造任意一个类的对象。

在运行时判断任意一个类所具有的成员变量和方法。

在运行时调用任意一个对象的方法。

Reflection 是 Java 被视为动态（或准动态）语言的一个关键性质。这个机制允许程序在运行时透过 Reflection APIs 取得任何一个已知名称的 class 的内部信息，包括其 modifiers （诸如 public, static 等等）、 superclass （例如 Object ）、实现之interfaces （例如 Serializable ），也包括 fields 和 methods 的所有信息，并可于运行时改变 fields 内容或调用 methods 。

一般而言，开发者社群说到动态语言，大致认同的一个定义是： “ 程序运行时，允许改变程序结构或变量类型，这种语言称为动态语言” 。从这个观点看， Perl ， Python ， Ruby 是动态语言， C++ ， Java ， C# 不是动态语言。

尽管在这样的定义与分类下 Java 不是动态语言，它却有着一个非常突出的动态相关机制： Reflection 。这个字的意思是 “ 反射、映象、倒影 ” ，用在 Java 身上指的是我们可以于运行时加载、探知、使用编译期间完全未知的 classes 。换句话说， Java 程序可以加载一个运行时才得知名称的 class ，获悉其完整构造（但不包括 methods 定义），并生成其对象实体、或对其 fields 设值、或唤起其 methods 。这种 “ 看透 class” 的能力（ the ability of the program to examine itself ）被称为 introspection （内省、内观、反省）。 Reflection 和 introspection 是常被并提的两个术语。

在 JDK 中，主要由以下类来实现 Java 反射机制，这些类都位于 java.lang.reflect 包中：

Class 类：代表一个类。

Field 类：代表类的成员变量（成员变量也称为类的属性）。

Method 类：代表类的方法。

Constructor 类：代表类的构造方法。

Array 类：提供了动态创建数组，以及访问数组的元素的静态方法。

下面给出几个例子看看 Reflection API 的实际运用：

一、通过 Class 类获取成员变量、成员方法、接口、超类、构造方法等

在 java.lang.Object 类中定义了 getClass() 方法，因此对于任意一个 Java 对象，都可以通过此方法获得对象的类型。 Class 类是Reflection API 中的核心类，它有以下方法

getName() ：获得类的完整名字。

getFields() ：获得类的 public 类型的属性。

getDeclaredFields() ：获得类的所有属性。

getMethods() ：获得类的 public 类型的方法。

getDeclaredMethods() ：获得类的所有方法。

getMethod(String name, Class[] parameterTypes) ：获得类的特定方法， name 参数指定方法的名字， parameterTypes 参数指定方法的参数类型。

getConstructors() ：获得类的 public 类型的构造方法。

getConstructor(Class[] parameterTypes) ：获得类的特定构造方法， parameterTypes 参数指定构造方法的参数类型。

newInstance() ：通过类的不带参数的构造方法创建这个类的一个对象。

下面给出一个综合运用的例子：

public class RefConstructor {

public static void main(String args[]) throws Exception {

RefConstructor ref = new RefConstructor();

ref.getConstructor();

}

public void getConstructor() throws Exception {

Class c = null;

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

Class cs[] = {java.lang.String.class};

System.out.println("/n-------------------------------/n");

Constructor cst1 = c.getConstructor(cs);

System.out.println("1 、通过参数获取指定 Class 对象的构造方法： ");

System.out.println(cst1.toString());

Constructor cst2 = c.getDeclaredConstructor(cs);

System.out.println("2 、通过参数获取指定 Class 对象所表示的类或接口的构造方法： ");

System.out.println(cst2.toString());

Constructor cst3 = c.getEnclosingConstructor();

System.out.println("3 、获取本地或匿名类 Constructor 对象，它表示基础类的立即封闭构造方法。 ");

if (cst3 != null) System.out.println(cst3.toString());

else System.out.println("-- 没有获取到任何构造方法！ ");

Constructor[] csts = c.getConstructors();

System.out.println("4 、获取指定 Class 对象的所有构造方法： ");

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

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

}

System.out.println("/n-------------------------------/n");

Type types1[] = c.getGenericInterfaces();

System.out.println("1 、返回直接实现的接口： ");

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

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

}

Type type1 = c.getGenericSuperclass();

System.out.println("2 、返回直接超类： ");

System.out.println(type1.toString());

Class[] cis = c.getClasses();

System.out.println("3 、返回超类和所有实现的接口： ");

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

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

}

Class cs1[] = c.getInterfaces();

System.out.println("4 、实现的接口 ");

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

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

}

System.out.println("/n-------------------------------/n");

Field fs1[] = c.getFields();

System.out.println("1 、类或接口的所有可访问公共字段： ");

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

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

}

Field f1 = c.getField("MIN_VALUE");

System.out.println("2 、类或接口的指定已声明指定公共成员字段： ");

System.out.println(f1.toString());

Field fs2[] = c.getDeclaredFields();

System.out.println("3 、类或接口所声明的所有字段： ");

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

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

}

Field f2 = c.getDeclaredField("serialVersionUID");

System.out.println("4 、类或接口的指定已声明指定字段： ");

System.out.println(f2.toString());

System.out.println("/n-------------------------------/n");

Method m1[] = c.getMethods();

System.out.println("1 、返回类所有的公共成员方法： ");

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

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

}

Method m2 = c.getMethod("longValue", new Class[]{});

System.out.println("2 、返回指定公共成员方法： ");

System.out.println(m2.toString());

}

输出结果：输出结果很长，这里不再给出。

二、运行时复制对象

例程 ReflectTester 类进一步演示了 Reflection API 的基本使用方法。 ReflectTester 类有一个 copy(Object object) 方法，这个方法能够创建一个和参数 object 同样类型的对象，然后把 object 对象中的所有属性拷贝到新建的对象中，并将它返回

这个例子只能复制简单的 JavaBean ，假定 JavaBean 的每个属性都有 public 类型的 getXXX() 和 setXXX() 方法。

public class ReflectTester {

public Object copy(Object object) throws Exception {

// 获得对象的类型

Class<?> classType = object.getClass();

System.out.println("Class:" + classType.getName());

// 通过默认构造方法创建一个新的对象

Object objectCopy = classType.getConstructor(new Class[]{}).newInstance(new Object[]{});

// 获得对象的所有属性

Field fields[] = classType.getDeclaredFields();

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

Field field = fields[i];

String fieldName = field.getName();

String firstLetter = fieldName.substring(0, 1).toUpperCase();

// 获得和属性对应的 getXXX() 方法的名字

String getMethodName = "get" + firstLetter + fieldName.substring(1);

// 获得和属性对应的 setXXX() 方法的名字

String setMethodName = "set" + firstLetter + fieldName.substring(1);

// 获得和属性对应的 getXXX() 方法

Method getMethod = classType.getMethod(getMethodName, new Class[]{});

// 获得和属性对应的 setXXX() 方法

Method setMethod = classType.getMethod(setMethodName, new Class[]{field.getType()});

// 调用原对象的 getXXX() 方法

Object value = getMethod.invoke(object, new Object[]{});

System.out.println(fieldName + ":" + value);

// 调用拷贝对象的 setXXX() 方法

setMethod.invoke(objectCopy, new Object[]{value});

}

return objectCopy;

}

public static void main(String[] args) throws Exception {

Customer customer = new Customer("Tom", 21);

customer.setId(new Long(1));

Customer customerCopy = (Customer) new ReflectTester().copy(customer);

System.out.println("Copy information:" + customerCopy.getId() + " " + customerCopy.getName() + " "

+ customerCopy.getAge());

}

class Customer {

private Long id;

private String name;

private int age;

public Customer() {

}

public Customer(String name, int age) {

this.name = name;

this.age = age;

}

public Long getId() {

return id;

}

public void setId(Long id) {

this.id = id;

}

public String getName() {

return name;

}

public void setName(String name) {

this.name = name;

}

public int getAge() {

return age;

}

public void setAge(int age) {

this.age = age;

}

输出结果：

Class:com.langsin.reflection.Customer

id:1

name:Tom

age:21

Copy information:1 Tom 21

Process finished with exit code 0

解说：

ReflectTester 类的 copy(Object object) 方法依次执行以下步骤

（ 1 ）获得对象的类型：

Class classType=object.getClass();

System.out.println("Class:"+classType.getName());

（ 2 ）通过默认构造方法创建一个新对象：

Object objectCopy=classType.getConstructor(new Class[]{}).newInstance(new Object[]{});

以上代码先调用 Class 类的 getConstructor() 方法获得一个 Constructor 对象，它代表默认的构造方法，然后调用 Constructor 对象的 newInstance() 方法构造一个实例。

3 ）获得对象的所有属性：

Field fields[]=classType.getDeclaredFields();

Class 类的 getDeclaredFields() 方法返回类的所有属性，包括 public 、 protected 、默认和 private 访问级别的属性

（ 4 ）获得每个属性相应的 getXXX() 和 setXXX() 方法，然后执行这些方法，把原来对象的属性拷贝到新的对象中

三、用反射机制调用对象的方法

public class InvokeTester {

public int add(int param1, int param2) {

return param1 + param2;

}

public String echo(String msg) {

return "echo: " + msg;

}

public static void main(String[] args) throws Exception {

Class<?> classType = InvokeTester.class;

Object invokeTester = classType.newInstance();

// Object invokeTester = classType.getConstructor(new

// Class[]{}).newInstance(new Object[]{});

// 获取 InvokeTester 类的 add() 方法

Method addMethod = classType.getMethod("add", new Class[]{int.class, int.class});

// 调用 invokeTester 对象上的 add() 方法

Object result = addMethod.invoke(invokeTester, new Object[]{new Integer(100), new Integer(200)});

System.out.println((Integer) result);

// 获取 InvokeTester 类的 echo() 方法

Method echoMethod = classType.getMethod("echo", new Class[]{String.class});

// 调用 invokeTester 对象的 echo() 方法

result = echoMethod.invoke(invokeTester, new Object[]{"Hello"});

System.out.println((String) result);

}

在例程 InvokeTester 类的 main() 方法中，运用反射机制调用一个 InvokeTester 对象的 add() 和 echo() 方法

add() 方法的两个参数为 int 类型，获得表示 add() 方法的 Method 对象的代码如下：

Method addMethod=classType.getMethod("add",new Class[]{int.class,int.class});

Method 类的 invoke(Object obj,Object args[]) 方法接收的参数必须为对象，如果参数为基本类型数据，必须转换为相应的包装类型的对象。 invoke() 方法的返回值总是对象，如果实际被调用的方法的返回类型是基本类型数据，那么 invoke() 方法会把它转换为相应的包装类型的对象，再将其返回。

在本例中，尽管 InvokeTester 类的 add() 方法的两个参数以及返回值都是 int 类型，调用 add Method 对象的 invoke() 方法时，只能传递 Integer 类型的参数，并且 invoke() 方法的返回类型也是 Integer 类型， Integer 类是 int 基本类型的包装类：

Object result=addMethod.invoke(invokeTester,

new Object[]{new Integer(100),new Integer(200)});

System.out.println((Integer)result); //result 为 Integer 类型

四、动态创建和访问数组

java.lang.Array 类提供了动态创建和访问数组元素的各种静态方法。

例程 ArrayTester1 类的 main() 方法创建了一个长度为 10 的字符串数组，接着把索引位置为 5 的元素设为 “hello” ，然后再读取索引位置为 5 的元素的值

public class ArrayTester1 {

public static void main(String args[]) throws Exception {

Class<?> classType = Class.forName("java.lang.String");

// 创建一个长度为 10 的字符串数组

Object array = Array.newInstance(classType, 10);

// 把索引位置为 5 的元素设为 "hello"

Array.set(array, 5, "hello");

// 获得索引位置为 5 的元素的值

String s = (String) Array.get(array, 5);

System.out.println(s);

}

例程 ArrayTester2 类的 main() 方法创建了一个 5 x 10 x 15 的整型数组，并把索引位置为 [3][5][10] 的元素的值为设 37 。

public class ArrayTester2 {

public static void main(String args[]) {

int[] dims = new int[]{5, 10, 15};

// 创建一个具有指定的组件类型和维度的新数组。

Object array = Array.newInstance(Integer.TYPE, dims);

Object arrayObj = Array.get(array, 3);

Class<?> cls = arrayObj.getClass().getComponentType();

System.out.println(cls);

arrayObj = Array.get(arrayObj, 5);

Array.setInt(arrayObj, 10, 37);

int arrayCast[][][] = (int[][][]) array;

System.out.println(arrayCast[3][5][10]);

}

深入认识 Class 类

众所周知 Java 有个 Object 类，是所有 Java 类的继承根源，其内声明了数个应该在所有 Java 类中被改写的方法： hashCode() 、equals() 、 clone() 、 toString() 、 getClass() 等。其中 getClass() 返回一个 Class 类的对象。

Class 类十分特殊。它和一般 classes 一样继承自 Object ，其实体用以表达 Java 程序运行时的 classes 和 interfaces ，也用来表达 enum 、 array 、 primitive Java types

（ boolean, byte, char, short, int, long, float, double ）以及关键词 void 。当一个 class 被加载，或当加载器（ class loader ）的 defineClass() 被 JVM 调用， JVM 便自动产生一个 Class object 。如果您想借由 “ 修改 Java 标准库源码 ” 来观察Class object 的实际生成时机（例如在 Class 的 constructor 内添加一个 println() ），不能够！因为 Class 并没有 public constructor

Class 是 Reflection 起源。针对任何您想探勘的 class ，唯有先为它产生一个 Class object ，接下来才能经由后者唤起为数十多个的 Reflection APIs

Java 允许我们从多种途径为一个 class 生成对应的 Class 对象。参看本人的《 深入研究 java.long.Class 类》一文。

欲生成对象实体，在 Reflection 动态机制中有两种作法，一个针对 “ 无自变量 ctor” ，一个针对 “ 带参数 ctor” 。如果欲调用的是 “带参数 ctor“ 就比较麻烦些，不再调用 Class 的 newInstance() ，而是调用 Constructor 的 newInstance() 。首先准备一个Class[] 做为 ctor 的参数类型（本例指定

为一个 double 和一个 int ），然后以此为自变量调用 getConstructor() ，获得一个专属 ctor 。接下来再准备一个 Object[] 做为ctor 实参值（本例指定 3.14159 和 125 ），调用上述专属 ctor 的 newInstance() 。

动态生成 “Class object 所对应之 class” 的对象实体；无自变量。

这个动作和上述调用 “ 带参数之 ctor” 相当类似。首先准备一个 Class[] 做为参数类型（本例指定其中一个是 String ，另一个是Hashtable ），然后以此为自变量调用 getMethod() ，获得特定的 Method object 。接下来准备一个 Object[] 放置自变量，然后调用上述所得之特定 Method object 的 invoke() 。

为什么获得 Method object 时不需指定回返类型？

因为 method overloading 机制要求 signature 必须唯一，而回返类型并非 signature 的一个成份。换句话说，只要指定了method 名称和参数列，就一定指出了一个独一无二的 method 。

四、运行时变更 field 内容

与先前两个动作相比， “ 变更 field 内容 ” 轻松多了，因为它不需要参数和自变量。首先调用 Class 的 getField() 并指定 field 名称。获得特定的 Field object 之后便可直接调用 Field 的 get() 和 set() 。

public class RefFiled {

public double x;

public Double y;

public static void main(String args[]) throws NoSuchFieldException, IllegalAccessException {

Class c = RefFiled.class;

Field xf = c.getField("x");

Field yf = c.getField("y");

RefFiled obj = new RefFiled();

System.out.println(" 变更前 x=" + xf.get(obj));

// 变更成员 x 值

xf.set(obj, 1.1);

System.out.println(" 变更后 x=" + xf.get(obj));

System.out.println(" 变更前 y=" + yf.get(obj));

// 变更成员 y 值

yf.set(obj, 2.1);

System.out.println(" 变更后 y=" + yf.get(obj));

}

运行结果：

变更前 x=0.0

变更后 x=1.1

变更前 y=null

变更后 y=2.1

Process finished with exit code 0

private static Object check(Object obj,String flag) throws Exception

{

Class ts=obj.getClass();

Field[] fs=ts.getDeclaredFields();

Method[] ms=ts.getDeclaredMethods();

StringBuffer fd=new StringBuffer();

Map<String,Object> getMethodMap=new HashMap<String,Object>();

Map<String,Method> setMethodMap=new HashMap<String,Method>();

String methodName="";

String value="";

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

{

if(java.lang.String.class!=fs[i].getType())

{

fd.append(fs[i].getName());

}

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

{

methodName=ms[i].getName().toLowerCase();

if(methodName.indexOf("get")!=-1)

{

getMethodMap.put(methodName.substring(3), ms[i].invoke(obj, null));

}

else

{

setMethodMap.put(methodName.substring(3), ms[i]);

}

Set keySet=getMethodMap.keySet();

Iterator it=keySet.iterator();

String key="";

while(it.hasNext())

{

key=it.next().toString();

if(fd.indexOf(key)==-1&&getMethodMap.get(key)!=null)

{

value=getMethodMap.get(key).toString().replaceAll(",", "").replaceAll(" ", "");

if("".equals(value)||flag.equals(value))

{

((Method) setMethodMap.get(key)).invoke(obj, new Object[]{null});

}

else

{

((Method) setMethodMap.get(key)).invoke(obj, new Object[]{value});

}

return obj;

}

以上是关于java反射技术的应用的主要内容，如果未能解决你的问题，请参考以下文章