Java 使用反射(Reflection) 和内省技术

1,042 阅读8分钟

反射(Reflection)是程序的自我分析能力,通过反射可以确定类有哪些方法、有哪些构造方法以及有哪些成员变量。Java语言提供了反射机制,通过反射机制能够动态读取一个类的信息;能够在运行时动态加载类,而不是在编译期。反射可以应用于框架开发,它能够从配置文件中读取配置信息动态加载类、创建对象,以及调用方法和成员变量。

Java反射机制API

Java反射机制API主要是 java.lang.Class 类和 java.lang.reflect 包。

java.lang.Class类

java.lang.Class类是实现反射的关键所在,Class类的一个实例表示Java的一种数据类型,包括类、接口、枚举、注解(Annotation)、数组、基本数据类型和void,void是“无类型”,主要用于方法返回值类型声明,表示不需要返回值。Class没有公有的构造方法,Class实例是由JVM在类加载时自动创建的

方法1:调用Object类的getClass()方法。
方法2:使用Class类的forName()方法。
方法3:如果T是一个Java类型,那么T.class就代表了与该类型匹配的Class对象。

    public static void main( String[] args ) throws ClassNotFoundException {
        // 1.通过类型class静态变量
        Class clazz;
        clazz = int.class;
        print(clazz);

        String[] array = new String[1];
        // 2.通过对象的getClass()方法
        clazz = array.getClass();
        print(clazz);

        clazz = Class.forName("java.lang.Override");
        print(clazz);
    }

    private static void print(Class clazz) {
        System.out.println("ClassName = " + clazz.getName());
        System.out.println("isAnnotation = " + clazz.isAnnotation());
        System.out.println("isArray = " + clazz.isArray());
        System.out.println("isPrimitive = " + clazz.isPrimitive());
        System.out.println("isEnum = " + clazz.isEnum());
        System.out.println("isInterface = " + clazz.isInterface());
        System.out.println("---------------------");
    }

每一种类型包括类和接口等,都有一个class静态变量可以获得Class实例。另外,每一个对象都有getClass()方法可以获得Class实例,该方法是由Object类提供的实例方法。

是否为接口: isInterface() 是否为数组对象: isArray() 是否是基本类型: isPrimitive() 获得父类: class: getSuperclass()

###java.lang.reflect包 java.lang.reflect包提供了反射中用到类,主要的类说明如下:

  • Constructor类:提供类的构造方法信息。
  • Field类:提供类或接口中成员变量信息。
  • Method类:提供类或接口成员方法信息。
  • Array类:提供了动态创建和访问Java数组的方法。
  • Modifier类:提供类和成员访问修饰符信息。

示例代码如下:

    public static void main(String[] args) {

        try {
            // 动态加载xx类的运行时对象
            Class c = Class.forName("java.lang.String");      
            // 获取成员方法集合
            Method[] methods = c.getDeclaredMethods();        
            // 遍历成员方法集合
            for (Method method : methods) {                   
                // 打印权限修饰符,如public、protected、private
                System.out.print(Modifier.toString(method.getModifiers()));        
                // 打印返回值类型名称
                System.out.print(" " + method.getReturnType().getName() + " ");    
                // 打印方法名称
                System.out.println(method.getName() + "();");                      
            }
        } catch (ClassNotFoundException e) {                                       
            System.out.println("找不到指定类");
        }
    }
  • 通过Class的静态方法forName(String)创建某个类的运行时对象,其中的参数是类全名字符串,如果在类路径中找不到这个类则抛出ClassNotFoundException异常。
  • 通过Class的实例方法getDeclaredMethods()返回某个类的成员方法对象数组。
  • method.getModifiers()方法返回访问权限修饰符常量代码,是int类型,例如1代表public,这些数字代表的含义可以通过Modifier.toString(int)方法转换为字符串。
  • 通过Method的getReturnType()方法获得方法返回值类型,然后再调用getName()方法返回该类型的名称。
  • method.getName()返回方法名称。

创建对象

反射机制提供了另外一种创建对象方法,Class类提供了一个实例方法newInstance(),通过该方法可以创建对象。

下面两条语句实现了创建字符串String对象。

Class clz = Class.forName("java.lang.String");
String str = (String) clz.newInstance();

这两条语句相当于String str = new String()语句。另外,需要注意newInstance()方法有可以会抛出

  • InstantiationException表示不能实例化异常
  • IllegalAccessException是不能访问构造方法异常。

调用构造方法

调用方法newInstance()创建对象,这个过程中需要调用构造方法,上面的代码只是调用了String的默认构造方法。如果想要调用非默认构造方法,需要使用Constructor对象,它对应着一个构造方法,获得Constructor对象需要使用Class类的如下方法:

  • Constructor[] getConstructors():返回所有公有构造方法Constructor对象数组。
  • Constructor[] getDeclaredConstructors():返回所有构造方法Constructor对象数组。
  • Constructor getConstructor(Class... parameterTypes):根据参数列表返回一个公有Constructor对象。参数parameterTypes是Class数组,指定构造方法的参数列表。
  • Constructor getDeclaredConstructor(Class... parameterTypes):根据参数列表返回一个Constructor对象。参数parameterTypes同上。
private static void printConstructor() throws Exception {
        Class clazz = String.class;
        System.out.println(clazz.newInstance());

        Class<?> [] parameterTypes = {String.class};
        final Constructor constructor = clazz.getConstructor(parameterTypes);
        Object[] initArgs = {"666"};
        String str = (String) constructor.newInstance(initArgs);
        System.out.println(str);
    }

Java反射机制能够在运行时动态加载类,而不是在编译期。在一些框架开发中经常将要实例化的类名保存到配置文件中,在运行时从配置文件中读取类名字符串,然后动态创建对象,建立依赖关系。采用new创建对象依赖关系是在编译期建立的,反射机制能够将依赖关系推迟到运行时建立,这种依赖关系动态注入进来称为依赖注入。

调用方法

通过反射机制还可以调用方法,这与调用构造方法类似。调用方法需要使用Method对象,它对应着一个方法,获得Method对象需要使用Class类的如下方法:

  • Method[] getMethods():返回所有公有方法Method对象数组。
  • Method[] getDeclaredMethods():返回所有方法Method对象数组。
  • Method getMethod(String name, Class... parameterTypes):通过方法名和参数类型返回公有方法Method对象。参数parameterTypes是Class数组,指定方法的参数列表。
  • Method getDeclaredMethod(String name, Class... parameterTypes):通过方法名和参数类型返回方法Method对象。参数parameterTypes同上。
private static void testMethods() throws Exception {
        // 正常实现
        final LocalDate now = LocalDate.now();
        System.out.println(now);

        final LocalDate date = LocalDate.of(2020, 1, 2);
        System.out.println(date);

        System.out.println(date.getYear());

        // 使用 method 方式
        final Class<LocalDate> clazz = LocalDate.class;
        // 调用静态方法
        Object obj = clazz.getMethod("now").invoke(null);
        LocalDate localDate  = (LocalDate) obj;
        System.out.println(obj);
        // 调用静态方法的有参方法
        Class<?> [] parameterTypes = {int.class, int.class, int.class};
        Object[] args = {2002, 1, 2};
        obj = clazz.getMethod("of", parameterTypes).invoke(null, args);
        System.out.println(obj);
        // 调用实例的无参方法
        obj = clazz.getMethod("getYear").invoke(localDate);
        System.out.println(obj);
    }

调用成员变量

通过反射机制还可以调用成员变量,调用方法需要使用Field对象,它对应着一个方法,获得Field对象需要使用Class类的如下方法:

  • Field[] getFields():返回所有公有成员变量Field对象数组。
  • Field[] getDeclaredFields():返回所有成员变量Field对象数组。
  • Field getField(String name):通过指定公共成员变量名返回Field对象。
  • Field getDeclaredField(String name):通过指定成员变量名返回Field对象。
private static void testFiled() throws Exception {
        // 已知 Exception 有一个成员变量 private String detailMessage;
        Throwable exception = new Throwable("hello");
        System.out.println(exception.getMessage());

        final Class<? extends Throwable> aClass = exception.getClass();
        // 获取非静态方法的字段
        final Field detailMessageField = aClass.getDeclaredField("detailMessage");
        detailMessageField.setAccessible(true);
        // 非静态的 get
        final Object obj = detailMessageField.get(exception);
        System.out.println(obj);
        // 非静态的 set
        detailMessageField.set(exception, "new value");
        System.out.println(exception.getMessage());

        // 获取静态字段的值
        // private static final long serialVersionUID = -3042686055658047285L;
        final Field serialVersionUIDField = aClass.getDeclaredField("serialVersionUID");
        serialVersionUIDField.setAccessible(true);
        System.out.println(serialVersionUIDField.get(null));
    }

输出

hello
hello
new value
-3042686055658047285

设置成员变量accessible标志为true,accessible是可访问性标志,值为 true 则指示反射的对象在使用时应该取消Java语言访问检查。值为false则指示反射的对象应该实施Java语言访问检查。不仅是成员变量,方法和构造方法也可以通过setAccessible(true)设置,实现对私有方法和构造方法的访问

拓展

1.Type[] java.lang.Class.getGenericInterfaces() 2.Class<?>[] java.lang.Class.getInterfaces()

  • 获取类的接口实现信息 1.返回实现接口信息的Type数组,包含泛型信息 2.返回实现接口信息的Class数组,不包含泛型信息

细看一下,就会发现其中端倪,当你的实现接口中不包含泛型时,同样调用1方法,其返回的接口信息必然不带泛型信息的,也就是1中包含2。

如何拿到接口中定义的泛型Person?

	public static void main(String[] args) {
		Class clz = new MyInterface<Person>() {
			@Override
			public Person get() {
				return null;
			}
		}.getClass();
		// 如何拿到接口中定义的泛型Person
		System.out.println(((ParameterizedType) clz.getGenericInterfaces()[0]).getActualTypeArguments()[0]);
		
		clz = new MyAbstractClass<Person>() {
			@Override
			public Person get() {
				return null;
			}
		}.getClass();
		// 如何拿到抽象类中定义的泛型Person
		System.out.println(((ParameterizedType) clz.getGenericSuperclass()).getActualTypeArguments()[0]);
		
		
	}

	static interface MyInterface<T> {
		T get();
	}
	
	static abstract class MyAbstractClass<T> {
		abstract T get();
	}

内省技术

PropertyDescriptor类表示JavaBean类通过存储器导出一个属性。主要方法:

1、getPropertyType(),获得属性的Class对象。 2、getReadMethod(),获得用于读取属性值的方法;getWriteMethod(),获得用于写入属性值的方法。 3、hashCode(),获取对象的哈希值。 4、setReadMethod(Method readMethod),设置用于读取属性值的方法;setWriteMethod(Method writeMethod),设置用于写入属性值的方法; 将JavaBean中的属性封装起来进行操作。在程序把一个类当做JavaBean来看,就是调用Introspector.getBeanInfo()方法,得到的BeanInfo对象封装了把这个类当做JavaBean看的结果信息,即属性的信息。需要导包java.beans.*。

private static void testPropertyDescriptor() throws Exception {
        // 使用内省
        final Class<App> appClass = App.class;
        App app = appClass.newInstance();
        PropertyDescriptor propertyDescriptor = new PropertyDescriptor("sss", appClass);
        Method writeMethod = propertyDescriptor.getWriteMethod();
        writeMethod.invoke(app, "11111");
        System.out.println(propertyDescriptor.getReadMethod().invoke(app));

        BeanInfo beanInfo = Introspector.getBeanInfo(appClass);
        PropertyDescriptor[] pds = beanInfo.getPropertyDescriptors();
        for (PropertyDescriptor pd : pds) {
            System.out.println(pd);
        }
    }