反射

概述

我们知道，Java不是一种动态语言，它在运行中产生的一些新的东西是没办法控制的，如果某些类型或者接口是在我们编写程序时不存在的，我们对这种类型的内容一无所知，甚至是名字，所以我们并没有办法通过new一个对象来编写程序，那么我们怎么利用它里面的属性或者方法呢，这时候，就产生了反射机制。

反射机制是针对内存中运行的字节码文件进行操作的机制，当内存中产生了字节码，我们就可以根据这份字节码获取其对应的类、属性以及方法，了解了这些之后，我们就可以根据具体的内容编写程序了。

但反射机制只是对已有的字节码进行操作，而不能自己创造一份字节码出来，也就是说Class并没有支持的构造函数来干这个事，这让我疑惑不已。

Class类

Class 类的实例表示正在运行的 Java 应用程序中的类和接口。枚举是一种类，注释是一种接口。每个数组属于被映射为 Class 对象的一个类，所有具有相同元素类型和维数的数组都共享该 Class 对象。基本的 Java 类型（boolean、byte、char、short、int、long、float 和 double）和关键字 void 也表示为 Class 对象。

简单的说，Class类代表的就是运行中的一份类字节码

那么如何获取一个运行中的Class字节码对象呢？

1. 通过类名获得：类名.class
2. 通过对象获得：对象.getClass()
3. 通过字符串代表的类名获得：Class.forName(“完整的类名“）

//通过类名直接获得
System.out.println(Date.class);
//通过对象获得
System.out.println(new Date().getClass());
//通过一个字符串类名获得
//此处存在ClassNotFoundException异常
try {
    //这里注意：需要完整的类名
    System.out.println(Class.forName("java.util.Date"));
} catch (ClassNotFoundException e) {
    // TODO Auto-generated catch block
    e.printStackTrace();
}

打印结果：

class java.util.Date
class java.util.Date
class java.util.Date

由于是对未知的字节码文件进行操作，所以我们一般只能获得代表类名的字符串，所以一般采用第三种方式获取类的字节码对象

那么既然我们得到了类的字节码文件，类中的各个成员属性我们也就可以得到了

Method类代表类中的方法属性

Field类代表类中的各个字段

Constructor类代表类中的构造函数

下面我们分别介绍

这里提供一个ReflectPoint类用作测试

public class ReflectPoint {
    public int x = 1;
    private int y = 2;

    public ReflectPoint(){

    }

    public ReflectPoint(int x, int y) {
        super();
        this.x = x;
        this.y = y;
    }

    public void method(){
        System.out.println(x+":"+y);
    }

    @Override
    public String toString() {
        return "ReflectPoint ["+x+","+y+"]";
    }

}

Constructor类

public final class Constructor<T>

extends AccessibleObject

implements GenericDeclaration, Member

Constructor 提供关于类的单个构造方法的信息以及对它的访问权限。

通过反射实例化对象

public class ConstructorTest {

    /**
     * @param args
     * @throws NoSuchMethodException
     * @throws InvocationTargetException
     * @throws IllegalAccessException
     * @throws InstantiationException
     * @throws SecurityException
     * @throws IllegalArgumentException
     */
    public static void main(String[] args) throws ClassNotFoundException, IllegalArgumentException, SecurityException, InstantiationException, IllegalAccessException, InvocationTargetException, NoSuchMethodException {

        //获取类的字节码对象
        String className = "reflect.ReflectPoint";
        Class cls = Class.forName("reflect.ReflectPoint");

        //获取类中的所有的构造函数对象
        Constructor[] cons = cls.getConstructors();
        System.out.println("---------构造函数列表----------");
        for(Constructor con : cons){
            Class[] paramTypes = con.getParameterTypes();
            String consName = con.getName();
            System.out.println(consName + Arrays.toString(paramTypes));
        }
        System.out.println("-------------------------------");
        //获取无参的构造函数,并实例化对象
        Constructor conNoParam = cls.getConstructor();
        Object objNoParam = conNoParam.newInstance();
        System.out.println("无参实例对象："+objNoParam);

        //获取有参的构造函数,并实例化对象
        Constructor conParam = cls.getConstructor(int.class,int.class);
        Object objParam = conParam.newInstance(2,2);
        System.out.println("有参实例对象："+objParam);
        System.out.println("-------------------------------");

        //通过Class类直接实例对象,此方法只针对无参构造函数
        System.out.println("Class获取无参实例对象："+cls.newInstance());
    }
}

打印结果：

---------构造函数列表----------
reflect.ReflectPoint[]
reflect.ReflectPoint[int, int]
-------------------------------
无参实例对象：ReflectPoint [1,2]
有参实例对象：ReflectPoint [2,2]
-------------------------------
Class获取无参实例对象：ReflectPoint [1,2]

同样，我们也可以将获取对象的操作抽取成方法，以便以后使用

public class ConstructorTest2 {

    /**
     * @param args
     * @throws ClassNotFoundException
     */
    public static void main(String[] args) throws ClassNotFoundException {
        //获取类的字节码对象
        String className = "reflect.ReflectPoint";
        Class cls = Class.forName(className);

        //获取无参对象
        Object obj1 = getInstance(cls, null, null);
        System.out.println(obj1);

        //获取有参对象
        Class[] parameterTypes = new Class[]{int.class,int.class};
        Object[] initargs = new Object[]{2,2};
        Object obj2 = getInstance(cls, parameterTypes, initargs);
        System.out.println(obj2);

    }

    /**
     * 获取指定类指定构造函数的实例化对象
     *
     * @param target 目标类的字节码对象
     * @param parameterTypes 需要的构造函数参数类型
     * @param initargs 要传入的参数列表
     * @return 目标类的对象
     */
    private static Object getInstance(Class target,Class[] parameterTypes,Object[] initargs) {
        Object obj = null;
        try {
            Constructor con = target.getConstructor(parameterTypes);
            obj = con.newInstance(initargs);
        } catch (SecurityException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        } catch (IllegalArgumentException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        } catch (NoSuchMethodException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        } catch (InstantiationException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        } catch (IllegalAccessException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        } catch (InvocationTargetException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        }
        return obj;
    }
}

Field类

public final class Field

extends AccessibleObject

implements Member

Field 提供有关类或接口的单个字段的信息，以及对它的动态访问权限。反射的字段可能是一个类（静态）字段或实例字段。

以下代码通过反射实现获取和设置对象的属性值

public class FieldTest {

    /**
     * @param args
     * @throws ClassNotFoundException
     * @throws IllegalAccessException
     * @throws InstantiationException
     */
    public static void main(String[] args) throws ClassNotFoundException, InstantiationException, IllegalAccessException {

        //获取类的字节码对象并创建对象
        String className = "reflect.ReflectPoint";
        Class cls = Class.forName(className);
        Object obj = cls.newInstance();

        //获取x属性并修改x属性
        String fieldName = "x";
        System.out.println(getFieldValue(obj, fieldName));
        setFiledValue(obj, fieldName, 2);
        System.out.println(getFieldValue(obj, fieldName));

        //获取y属性并修改y属性,由于y是私有的，所以外部不可以设置
        /*fieldName = "y";
        System.out.println(getFieldValue(obj, fieldName));
        setFiledValue(obj, fieldName, 3);
        System.out.println(getFieldValue(obj, fieldName));*/



    }
    /**
     * 设置对象字段值
     * @param obj 需要设置的对象
     * @param fieldName 需要设置的字段名
     * @param value 需要设置的属性值
     */
    private static void setFiledValue(Object obj,String fieldName,Object value){
        Class cls = obj.getClass();
        try {
            //根据字段名获取字段
            Field field = cls.getField(fieldName);
            //设置字段属性
            field.set(obj, value);
        } catch (SecurityException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        } catch (IllegalArgumentException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        } catch (NoSuchFieldException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        } catch (IllegalAccessException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        }
    }

    /**
     * 获取对象字段值
     * @param obj 需要获取值的对象
     * @param fieldName 需要获取的属性名
     * @return
     */
    private static Object getFieldValue(Object obj,String fieldName){
        Class cls = obj.getClass();
        Object retVal = null;
        try {
            //根据字段名获取字段
            Field field = cls.getField(fieldName);
            //获取字段属性
            retVal = field.get(obj);
        } catch (SecurityException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        } catch (IllegalArgumentException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        } catch (NoSuchFieldException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        } catch (IllegalAccessException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        }
        return retVal;
    }
}

 

一个小例题，通过反射将任意对象中所有可读String字段中的”a”转成”b”

public class FieldTest2 {

    /**
     * @param args
     * @throws ClassNotFoundException
     * @throws IllegalAccessException
     * @throws InstantiationException
     */
    public static void main(String[] args) throws ClassNotFoundException, InstantiationException, IllegalAccessException {

        //获取类的字节码对象并创建对象
        String className = "reflect.Code";
        Class cls = Class.forName(className);
        Object obj = cls.newInstance();

        System.out.println(obj);
        changeStringValue(obj);
        System.out.println(obj);

    }

    /**
     * 通过反射方法将类中可读String字段中的”a“转为”b“
     * @param obj
     */
    private static void changeStringValue(Object obj){
        //获取类字节码对象
        Class cls = obj.getClass();
        //获取类中所有字段
        Field[] fields = cls.getFields();
        //遍历字段，找到String类型字段，并修改
        for(Field field : fields){
            if(field.getType() == String.class){
                try {
                    String s = (String)field.get(obj);
                    s = s.replaceAll("a", "b");
                    field.set(obj, s);
                } catch (IllegalArgumentException e) {
                    // TODO Auto-generated catch block
                    e.printStackTrace();
                } catch (IllegalAccessException e) {
                    // TODO Auto-generated catch block
                    e.printStackTrace();
                }
            }
        }
    }
}

Method类

public final class Method

extends AccessibleObject

implements GenericDeclaration, Member

Method 提供关于类或接口上单独某个方法（以及如何访问该方法）的信息。所反映的方法可能是类方法或实例方法（包括抽象方法）。

下面我们来看看如何使用方法反射

public class MethodTest {

    /**
     * @param args
     */
    public static void main(String[] args) {

        //通过反射执行String对象的charAt方法
        String str = "abcde";
        Object obj = runMethod(String.class,str,"charAt",new Class[]{int.class},new Object[]{1});
        System.out.println(obj);

        //通过反射执行Math的max方法
        obj = runMethod(Math.class,null,"max",new Class[]{double.class,double.class},new Object[]{1.0,2.0});
        System.out.println(obj);

    }
    /**
     * 执行任意对象的任意方法
     * @param cls 类字节码对象
     * @param obj 需要操作的对象
     * @param methodName 方法名
     * @param parameterTypes 方法参数列表类型
     * @param args 需要传入的自定义参数列表
     * @return
     */
    private static Object runMethod(Class cls,Object obj,String methodName,Class[] parameterTypes,Object[] args){
        Object retVal = null;
        try {
            //通过方法名和参数列表获取方法对象
            Method method = cls.getMethod(methodName, parameterTypes);
            //通过方法的invoke方法执行对应对象的方法，同时传入参数列表
            retVal = method.invoke(obj, args);
        } catch (SecurityException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        } catch (IllegalArgumentException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        } catch (NoSuchMethodException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        } catch (IllegalAccessException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        } catch (InvocationTargetException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        }
        return retVal;
    }
}

我们注意到，当Method的invoke方法传入的对象引用为空时，其实代表的是类中的静态方法，因为静态方法可以直接由类名调用

Array类

数组的反射

在Class类的API文档里我们发现，只要是数据类型和维度都相同的数组，是共用同一份字节码的，下面的例子说明了这一问题

public static void main(String[] args) {
    // TODO Auto-generated method stub
    int[] a = new int[2];
    int[] b = new int[3];
    double[][] c = new double[3][];
    double[][] d = new double[4][];

    //比较两份字节码是否相同
    System.out.println(a.getClass() == b.getClass());
    System.out.println(c.getClass() == d.getClass());

    //这句eclipse会自动判定编译错误
    //Incompatible operand types Class<capture#5-of ? extends int[]>
    //and Class<capture#6-of ? extends double[][]>
    System.out.println(a.getClass() == c.getClass());
}

打印结果：

true

true

Array类应用

public class ArrayReflectTest {

    /**
     * @param args
     */
    public static void main(String[] args) {

        print(new String[]{"1","2"});
        System.out.println();
        print(new int[][]{{1,2,3},{4,5,6}});
    }

    //打印对象，若为数组，则打印数组中元素
    private static void print(Object obj){
        Class cls = obj.getClass();
        //判断所属类是否为数组类型
        if(cls.isArray()){
            //Array获取数组长度
            int length = Array.getLength(obj);
            for(int i = 0 ; i < length ; i ++){
                //若元素仍为数组，即多维数组，则递归打印
                Object objTemp = Array.get(obj, i);
                if(objTemp.getClass().isArray())
                    print(objTemp);
                else
                    System.out.print(objTemp+" ");
            }
        }
        else{
            System.out.println(obj);
        }
    }
}

好了，既然方法类和数组类都知道了，来处理一个小问题：参数为数组的方法的反射

请看下面例子，调用其他类的main函数引出该问题

class MainMethod{
    public static void main(String[] args){
        for(int i = 0 ; i < args.length ; i ++){
            System.out.println(args[i]);
        }
    }
}

public class MainTest {

    /**
     * @param args
     * @throws ClassNotFoundException
     * @throws NoSuchMethodException
     * @throws SecurityException
     * @throws InvocationTargetException
     * @throws IllegalAccessException
     * @throws IllegalArgumentException
     */
    public static void main(String[] args) throws ClassNotFoundException, SecurityException, NoSuchMethodException, IllegalArgumentException, IllegalAccessException, InvocationTargetException {
        // TODO Auto-generated method stub
        Class cls = Class.forName("reflect.MainMethod");
        Method mainMethod = cls.getMethod("main", String[].class);
        mainMethod.invoke(null, new String[]{"1","2"});
    }
}

上面的例子，会报错

Exception in thread "main" java.lang.IllegalArgumentException: wrong number of arguments

之所以报错，是因为JDK1.5中Method的invoke方法接收的是可变参数Object… params，而JDK1.4中Method的invoke方法接收的是数组Object[] params，我们知道JDK1.5要向下兼容1.4的方法，所以当传入String类型数组时，JVM并不会将这个数组作为可变参数的第一个参数，而是按照JDK1.4的方法，将String数组转换成Object数组拆包，这样就相当于给main方法传递了两个参数”1”和”2”，而main方法只有一个String[]参数，所以出现了不合法的参数异常，那么既然知道了原因，修改方法也自然出来了

根据JDK1.4的修改方法：mainMethod.invoke(null, new Object[]{new String[]{"1","2"}});即为将参数列表封装成Object数组传递给invoke，令其拆包

根据JDK1.5的修改方法：mainMethod.invoke(null, (Object)new String[]{"1","2"});即为将参数列表的元素封装成Object对象，使可变参数接收

反射的意义

说了这么多反射的应用，但是究竟反射有何意义呢？

其实意义就在于它产生的原因，有了反射，就可以控制一些运行中不可见的因素，大大的提高了程序的扩展性，

今后的框架也是基于反射做的，开发框架的人在开发时并不知道需要调用哪些类，因为这些类都是使用者自己写的，他们根据反射将使用者将来写出的类做了分析，写出框架，而我们在使用框架的过程中只需要写自己的类，并将类的相关属性配置到框架的配置文件中即可

下面是一段模拟框架的小代码，包括框架代码和一个property配置文件

public class FrameTest {

    /**
     * @param args
     * @throws IOException
     * @throws ClassNotFoundException
     * @throws IllegalAccessException
     * @throws InstantiationException
     */
    public static void main(String[] args) throws IOException, InstantiationException, IllegalAccessException, ClassNotFoundException {

        //通过Properties与字节流配合获取配置文件信息
        InputStream ips = new FileInputStream("config.properties");
        Properties prop = new Properties();
        prop.load(ips);
        //得到className
        String className = prop.getProperty("className");

        //通过className创建对象，此处利用接口编程
        Collection col = (Collection) Class.forName("java.util.ArrayList").newInstance();
        col.add(1);
        col.add(2);
        col.add(3);

        System.out.println(col);
    }
}

配置文件为config.properties

里面内容为

className = java.util.ArrayList

这就是一个简单的框架，利用接口编程，当我们需要更改使用的集合类时，只需要在配置文件中更改即可，非常方便