Java反射

java反射库(reflection library)提供了一个非常丰富且精心设计的工具集，以便编写能够动态操纵java代码的程序。这项功能被大量应用于JavaBeans中。

能够分析类能力的程序称为反射。反射机制作用：

1)运行时分析类的能力

2)运行时查看对象

3)实现通用的数组操作代码

4)利用Method对象，这个对象类似于c++函数指针。

Class类

程序运行期间，Java运行时系统始终为所有的对象维护一个被称为运行时的类型标识。这个信息跟踪着每个对象所属的类。虚拟机利用运行时类型信息选择相应方法执行。

常用相关方法：

static Class forName(String className)       //返回描述类名为className的Class对象

static String getClass(Class classString)    　//返回描述类名的String

Object newInstance()　　//返回这个类的新实例

Object newInstance(Object[] args)　　//构造一个这个构造器所属类的新实例，参数由args给出

利用反射分析类

反射机制最重要的内容－－检查类的结构

Class类中的相关方法：

Field[] getFields()　　//返回一个包含Field对象的数组，记录了这个类与其超类的公有域

Field[] getDeclaredFields()　　//返回一个包含Field对象的数组，记录了这个类的全部域

Method[] getMethods()　　//返回一个包含Method对象的数组，记录了所有的公有方法

Method[] get DeclareMethods()　　//返回一个包含Method对象的数组，记录了这个类所有或接口的所有方法

Constructor[] getConstructors()　　//返回一个包含Constructor对象的数组，记录了所有公有构造器

Constructor[] getDeclareConstructors()　　//返回一个包含Constructor对象的数组，记录了所有构造器

反射包中相关方法：

Class getDeclareClass()　　//返回一个用于描述类中定义的构造器，方法或域的对象

Class getExceptionTypes()　　//返回一个用于描述方法抛出异常类型的Class对象数组

int getModefiers()　　//返回一个用于描述构造器，方法或域的修饰符的整形数值。使用Modefier类中的这个方法可以分析这个值

String getName()　　//返回一个用于描述构造器，方法或域名的字符串

class[] getParrameterrTypes()　　//返回一个用于描述参数类型的Class对象数组

Class getReturnType()　　//返回一个用于描述返回类型的Class对象

static String toString(int modifiers)　　//返回对应modefiers中位设置的修饰符的字符串表示

static boolean isAbatract【或isFinal/isInterface.....所有修饰符】　(int modefiers) 　　//检测修饰符对应位　　

以下是一个测试用例：

输入一个类，打印所有构造器，方法和域，包括他们的修饰符以及构造器和方法的参数

package refleection.company;

import java.lang.reflect.*;
import java.util.Scanner;

public class ReflectionTest {

    public static void main(String[] args) {
        String name;
        if (args.length > 0) {
            name = args[0];
        } else {
            Scanner in = new Scanner(System.in);
            System.out.println("Enter class name(e.g. java.util.Date):");
            name = in.next();
        }

        try {
            Class c1 = Class.forName(name);//获取对应类名的Class对象
            Class superc1 = c1.getSuperclass();//获取超类对象
            String modifiers = Modifier.toString(c1.getModifiers());//获取修饰符
            if (modifiers.length() > 0) {
                System.out.print(modifiers + " ");
            }
            System.out.print("class " + name);
            if (superc1 != null && superc1 != Object.class) {
                //打印超类对象
                System.out.print("extends" + superc1.getName());
            }
            System.out.print("
{
");
            printConstructors(c1);
            System.out.println();
            printMethods(c1);
            System.out.println();
            printFields(c1);
            System.out.println("}");
        } catch (ClassNotFoundException e) {
            e.printStackTrace();
        }
        System.exit(0);
    }


    public static void printConstructors(Class c1) {
        Constructor[] constructors = c1.getDeclaredConstructors();//获取所有构造器，存于数组

        for (Constructor c : constructors) {
            String name = c.getName();
            System.out.print(" ");
            String modifiers = Modifier.toString(c.getModifiers());//getModifiers返回一个描述修饰符的整数值,转为字符串
            if (modifiers.length() > 0) {
                System.out.print(modifiers + " ");
            }
            System.out.print(name + "(");
            Class[] paramTypes = c.getParameterTypes();//获取描述参数类型的对象数组
            for (int j = 0; j < paramTypes.length; j++) {
                if (j > 0) {
                    System.out.print(", ");
                }
                System.out.print(paramTypes[j].getName());
            }
            System.out.print(");");
        }
    }

    public static void printMethods(Class c1) {
        Method[] methods = c1.getDeclaredMethods();//获取所有方法，存于数组

        for (Method m : methods) {
            Class retType = m.getReturnType();//获取描述返回类型的对象
            String name = m.getName();
            System.out.print(" ");
            String modifiers = Modifier.toString(m.getModifiers());//描述修饰符的字符串
            if (modifiers.length() > 0) {
                System.out.print(modifiers + " ");
            }
            System.out.print(retType.getName() + " " + name + "(");
            Class[] paramTypes = m.getParameterTypes();//获取描述参数类型的对象数组
            for (int j = 0; j < paramTypes.length; j++) {
                if (j > 0) {
                    System.out.print(", ");
                }
                System.out.print(paramTypes[j].getName());
            }
            System.out.println(");");
        }
    }

    public static void printFields(Class c1) {
        Field[] fields = c1.getDeclaredFields();

        for (Field f : fields) {
            Class type = f.getType();//域所属类型
            String name = f.getName();
            System.out.print(" ");
            String modifiers = Modifier.toString(f.getModifiers());//域修饰符
            if (modifiers.length() > 0) {
                System.out.print(modifiers + " ");
            }
            System.out.println(type.getName() + " " + name + ";");
        }
    }
}

输入java.util.Date得到下面结果

Enter class name(e.g. java.util.Date):
java.util.Date
public class java.util.Date
{
 public java.util.Date(int, int, int, int, int, int); public java.util.Date(); public java.util.Date(int, int, int, int, int); public java.util.Date(java.lang.String); public java.util.Date(long); public java.util.Date(int, int, int);
 public void setYear(int);
 public int getMonth();
 public void setMonth(int);
 public void setDate(int);
 public int getDay();
 public int getHours();
 public void setHours(int);
 public int getMinutes();
 public void setMinutes(int);
 public int getSeconds();
 public void setSeconds(int);
 private final long getTimeImpl();
 static final long getMillisOf(java.util.Date);
 private static final java.lang.StringBuilder convertToAbbr(java.lang.StringBuilder, java.lang.String);
 public java.lang.String toLocaleString();
 public java.lang.String toGMTString();
 public int getTimezoneOffset();
 private final sun.util.calendar.BaseCalendar$Date getCalendarDate();
 private static final sun.util.calendar.BaseCalendar getCalendarSystem(long);
 private static final sun.util.calendar.BaseCalendar getCalendarSystem(sun.util.calendar.BaseCalendar$Date);
 private static final sun.util.calendar.BaseCalendar getCalendarSystem(int);
 private static final synchronized sun.util.calendar.BaseCalendar getJulianCalendar();
 public java.time.Instant toInstant();
 public static long UTC(int, int, int, int, int, int);
 public int getYear();
 public boolean before(java.util.Date);
 public boolean after(java.util.Date);
 public void setTime(long);
 public long getTime();
 public int getDate();
 public boolean equals(java.lang.Object);
 public java.lang.String toString();
 public int hashCode();
 public java.lang.Object clone();
 public int compareTo(java.util.Date);
 public volatile int compareTo(java.lang.Object);
 public static java.util.Date from(java.time.Instant);
 private void readObject(java.io.ObjectInputStream);
 private void writeObject(java.io.ObjectOutputStream);
 private final sun.util.calendar.BaseCalendar$Date normalize();
 private final sun.util.calendar.BaseCalendar$Date normalize(sun.util.calendar.BaseCalendar$Date);
 public static long parse(java.lang.String);

 private static final sun.util.calendar.BaseCalendar gcal;
 private static sun.util.calendar.BaseCalendar jcal;
 private transient long fastTime;
 private transient sun.util.calendar.BaseCalendar$Date cdate;
 private static int defaultCenturyStart;
 private static final long serialVersionUID;
 private static final [Ljava.lang.String; wtb;
 private static final [I ttb;
}

在运行时使用反射分析对象

有时候希望可以看到数据域的实际数据而不只是类型，用反射同样可以做到。可能用到下列函数

Object get(Object obj)　　//返回obj对象中用Field对象表示的域值

void set(Object obj,Object newValue)　　//用一个新值设置obj对象中Field对象表示的域

Field getField(String)　　//获得指定名称的公有域

Field getDeclareField(String)　　//获得给定名称的域

假设有一个Employee的类，该类有一个name私有域，根据以上函数,尝试获取域值

Employee e = new Employee();
Class c1 = e.getClass();
Field f = c1.getDeclareField("name");
Object v = f.get(e)

看似可行，实际上时不可行的，它会抛出一个IllegalAccessException异常。name是私有域，java安全机制不允许没有访问权限的客户读取私有域的值，那么就要用到以下函数

void setAccessible(boolean flag)　　//为反射对象设置可访问标志

boolean isAccessible()　　//返回反射对象的可访问标志的值

static void setAccessible(AccessibleObject[] array,boolean flag)　　//设置对象数组可访问标志

那么上述例子增加一条语句，就不会抛出异常了。

f.setAccessable(true);

以下是一个实例，输入任意类，输出它的所有域以及相应的值

package objectAnalyzer;

import java.lang.reflect.AccessibleObject;
import java.lang.reflect.Array;
import java.lang.reflect.Field;
import java.lang.reflect.Modifier;
import java.util.ArrayList;

public class ObjectAnalyzer {
    private ArrayList<Object> visited = new ArrayList<>();

    public String toString(Object obj){
        if (obj==null){
            return "null";
        }
        if (visited.contains(obj)){
            return "...";
        }
        visited.add(obj);
        Class c1 = obj.getClass();//获取类名
        if (c1 == String.class){
            return (String)obj;
        }//若为String类型,直接返回String对象
        if (c1.isArray()){
            String r = c1.getComponentType()+"[]{";//getComponent返回表示数组元素类型的字符串
            for (int i = 0;i < Array.getLength(obj);i++){
                if (i>0){
                    r += ",";
                }//获取每个数值
                Object val = Array.get(obj,i);
                if (c1.getComponentType().isPrimitive()){//判断是否为基本类型
                    r += val;
                }
                else {
                    r += toString(val);
                }
            }
            return r + "}";
        }
        String r = c1.getName();//非空，非String，非array，其他类
        do {
            r += "[";
            Field[] fields = c1.getDeclaredFields();//获取所有域
            AccessibleObject.setAccessible(fields,true);//设置为可见
            for (Field f:fields){
                if (!Modifier.isStatic(f.getModifiers())){//非静态域
                    if(!r.endsWith("[")){
                        r += ",";
                    }
                    r += f.getName() + "=";//获取名称
                    try {
                        Class t = f.getType();
                        Object val = f.get(obj);
                        if (t.isPrimitive()){//判断是否为基本类型
                            r += val;
                        }
                        else {
                            r += toString(val);
                        }
                    }catch (Exception e){
                        e.printStackTrace();
                    }
                }
            }
            r += "]";
            c1 = c1.getSuperclass();
        } while (c1 != null);
        return r;
    }
}

package objectAnalyzer;

import java.util.ArrayList;

public class ObjectAnalyzerTest {
    public static void main(String[] args){
        ArrayList<Integer> squares = new ArrayList<>();
        for (int i = 1;i <= 5;i++){
            squares.add(i*i);
        }
        System.out.println(new ObjectAnalyzer().toString(squares));
    }

}

结果

java.util.ArrayList[elementData=class java.lang.Object[]{java.lang.Integer[value=1][][],java.lang.Integer[value=4][][],java.lang.Integer[value=9][][],java.lang.Integer[value=16][][],java.lang.Integer[value=25][][],null,null,null,null,null},size=5][modCount=5][][]

使用反射编写泛型数组代码

java反射包中的Array类允许动态地创建数组，将其拓展为更通用的方法，即可以拓展任意类型的数组。

public static Object goodCopyOf(Object a,int length){
    Class c1 = a.getClass();
    if(!c1.isarray()){
        return null;
    }
    Class componentType = c1.getComponentType();
    int length = Array.getLength(a);
    Object newArray = Array.newInstance(ComponentType, newLength);
    System.arraycopy(a,0,newArray,0,Math.min(length,newLength));
    return newArray;
}

Array类的一些方法

static Object get(Object array,int index)　//返回给定数组下标的内容

static xxx getXxx(Object array,int index)　//返回给定数组下标的内容，xxx是基本类型

static void set(Object array,int index,Object newValue)　　//设置指定下标内容

staticc int getLength(Object array)　　//返回数组长度

static Object newInstance(Class componentType,int length)　　//返回一个具有给定类型，维数的新数组

static Object newInstance(Class componentType,int[] length)

调用任意方法

Methods类中有一个invoke方法，允许调用包装在当前Method对象中的方法。如下:

public Object invoke(Object implicitParameter,Object[] explicitParamenters)　　//调用这个对象描述的方法，传递给定参数，返回方法的返回值。对于静态方法，把null作为隐式参数传递。