Java.Reflection

Written by with ♥ on in Java

Class对象

获取类的运行时结构

通过反射获取运行时类的完整结构，包括：

  • Interface：实现的全部接口
  • SuperClass：所继承的父类
  • Constructor：全部的构造器
  • Method；全部的方法
  • Field：全部的Field
  • Annotation：注解

代码实现：

User user = new User();
Class c1 = user.getClass();

// 获取类的名字
System.out.println(c1.getName());           // 包名 + 类名
System.out.println(c1.getSimpleName());     // 类名

// 获取类的属性
// getFields：只能获取到public修饰的属性
Field[] fields = c1.getFields();
for (Field field : fields) {
    System.out.println(field);
}
// getDeclaredFields：可以获取到所有属性
Field[] declaredFields = c1.getDeclaredFields();
for (Field declaredField : declaredFields) {
    System.out.println(declaredField);
}
// 通过属性名获取属性
Field public_age = c1.getField("public_age");
System.out.println(public_age);

// 获取类的方法
Method[] methods = c1.getMethods();         // 获得自己及父类的方法，不包含私有方法
for (Method method : methods) {
    System.out.println(method);
}
Method[] declaredMethods = c1.getDeclaredMethods();     // 只获得自己声明的方法，包含私有方法
for (Method declaredMethod : declaredMethods) {
    System.out.println(declaredMethod);
}
// 获取指定方法：需要提供方法名和参数类型，用于区分重载的方法
Method getName = c1.getMethod("getName", null);
Method setName = c1.getMethod("setName", String.class);
System.out.println(getName);
System.out.println(setName);

// 获取类的构造器
// 获取非私有的构造器
Constructor[] constructors = c1.getConstructors();
for (Constructor constructor : constructors) {
    System.out.println(constructor);
}
// 获取所有构造器
Constructor[] declaredConstructors = c1.getDeclaredConstructors();
for (Constructor declaredConstructor : declaredConstructors) {
    System.out.println(declaredConstructor);
}
// 获取指定的构造器：获取有参构造器需要提供参数类型
System.out.println(c1.getConstructor(null));
System.out.println(c1.getDeclaredConstructor(String.class, int.class, int.class));

使用Class对象

实例化

创建类对象：调用Class对象的newInstance()方法

  • 该类必须有无参构造器
  • 该类的构造器必须有足够的访问权限
Class<User> userClass = User.class;
User user = userClass.newInstance();    // 调用无参构造器

当类没有无参构造器时，要通过明确调用类中的构造器，传入参数，实现实例化：

  1. 通过Class类的getDeclaredConstructor()方法获取指定参数类型的构造器
  2. 向构造器中传入参数组合
  3. 通过Constructor调用newInstance()方法实例化对象
Constructor<User> constructor = userClass.getDeclaredConstructor(String.class, int.class, int.class);
User user1 = constructor.newInstance("Usr", 20, 2001);

通过反射调用类中的方法

  1. 通过Class类的getMethod()方法获得Method对象，并设置调用方法需要的参数类型
  2. 使用Object invoke(Object obj, Obeject[] args)进行调用，需要传如要操作的对象和参数

image.png

Method setAge = userClass.getMethod("setAge", int.class);
setAge.invoke(user1, 24);

关于Object invoke(Object obj, Obeject[] args)方法：

  • Object对应原方法的返回值，若原方法无返回值，则返回null
  • 原方法若为静态方法，obj参数可为null
  • 若原方法参数列表为空，则args为null
  • 若原方法为private修饰的私有方法，则在调用invoke()方法之前，要显式调用方法对象的setAccessible(true)方法，关闭安全检测

通过反射操作属性

通过字段的set()方法来操作字段。
对于私有的字段，修改前先调用setAccessible(true)方法，关闭安全检测。

// 通过反射操作属性
Field age = userClass.getDeclaredField("age");
// 对于private修饰的私有属性/方法，需要通过setAccessible()方法来关闭安全检测
age.setAccessible(true);
age.set(user1, 25);

setAccessible()

Method、Field、Constructor对象都有setAccessible()方法。
setAccessible()方法用于启动和禁用访问安全检查。

  • 参数值为true则表示反射的对象在使用时取消Java的访问检查
    • 提高反射的效率。如果代码中必须用反射，而该句代码需要频繁的被调用，那么设置为true。
    • 使得原本无法访问的私有成员也可以访问
  • 参数值为false则表示反射的对象实施Java的访问检查

setAccessible(true)可以提高反射的效率
编写代码对比不同方式调用方法的性能：

  1. 普通方法调用
public static void norm() {
    User user = new User();

    long startTime = System.currentTimeMillis();

    for (int i = 0; i < 1000_0000; i++) {
        user.getName();
    }

    long endTime = System.currentTimeMillis();
    System.out.println("普通方法花费时间：" + (endTime - startTime) + "ms");
}
  1. 反射方式调用
public static void ref() throws Exception {
    User user = new User();
    Class<? extends User> c1 = user.getClass();
    Method getName = c1.getDeclaredMethod("getName");

    long startTime = System.currentTimeMillis();

    for (int i = 0; i < 1000_0000; i++) {
        getName.invoke(user);
    }

    long endTime = System.currentTimeMillis();

    System.out.println("反射方式花费时间：" + (endTime - startTime) + "ms");
}
  1. 关闭安全检查后的反射方式调用
public static void ref_off() throws Exception{
    User user = new User();
    Class<? extends User> c1 = user.getClass();
    Method getName = c1.getDeclaredMethod("getName");
    getName.setAccessible(true);

    long startTime = System.currentTimeMillis();

    for (int i = 0; i < 1000_0000; i++) {
        getName.invoke(user);
    }

    long endTime = System.currentTimeMillis();

    System.out.println("关闭后反射花费时间：" + (endTime - startTime) + "ms");
}

三种方法的运行结果：

普通方法花费时间：3ms
反射方式花费时间：2024ms
关闭后反射花费时间：49ms

由此可见，setAccessible(true)方法可以提高反射机制的性能。但是普通的调用方法仍是最高效的。

反射操作泛型

  • Java采用泛型擦除的机制来引入泛型，Java中的泛型仅仅是给编译器Javac使用的，确保数据的安全性和免去强制类型转换问题，但是，一旦编译完成，所有和泛型有关的类型全部擦除
  • 为了通过反射操作这些类型，Java新增了ParameterizedType，GenericArrayType，TypeVariable和WildcardType几种类型来代表不能被归一到Class类中的类型但是又和原始类型齐名的类型
    • ParameterizedType:表示一种参数化类型，比如Collection
    • GenericArrayType:表示一种元素类型是参数化类型或者类型变量的数组类型
    • TypeVariable:是各种类型变量的公共父接口
    • WildcardType:代表一种通配符类型表达式

方法对象提供了获取泛型信息的方法，具体代码实现如下：

  1. 获取方法的泛型参数信息
Method test01 = Generic01.class.getMethod("test01", Map.class, List.class);
// 获取泛型的参数信息
Type[] genericParameterTypes = test01.getGenericParameterTypes();
for (Type genericParameterType : genericParameterTypes) {
    System.out.println("泛型参数类型：" + genericParameterType);
    if (genericParameterType instanceof ParameterizedType) {
        Type[] actualTypeArguments = ((ParameterizedType) genericParameterType).getActualTypeArguments();
        for (Type actualTypeArgument : actualTypeArguments) {
            System.out.println(actualTypeArgument);
        }
    }
}
  1. 获取方法的泛型返回信息
// 获取泛型的返回值信息
Method test02 = Generic01.class.getMethod("test02");
Type genericReturnType = test02.getGenericReturnType();
if (genericReturnType instanceof ParameterizedType) {
    Type[] actualTypeArguments = ((ParameterizedType) genericReturnType).getActualTypeArguments();
    for (Type actualTypeArgument : actualTypeArguments) {
        System.out.println("返回泛型参数类型" + actualTypeArgument);
    }
}

反射操作注解

了解ORM：Object relationship Mapping：对象关系映射
image.png

  • 类和表结构对应
  • 属性和字段对应
  • 对象和记录对应

利用注解和反射完成类和表结构的映射关系

  1. 利用类实现表结构
// 实体类
class Student {
    private int id;
    private int age;
    private String sex;
}
  1. 利用注解实现表及字段属性
    1. 自定义注解
    	// 类的注解
	@Target(ElementType.TYPE)
	@Retention(RetentionPolicy.RUNTIME)
	@interface Table {
	    String value();
	}

	// 属性的注解
	@Target(ElementType.FIELD)
	@Retention(RetentionPolicy.RUNTIME)
	@interface Fields {
	    String columnName();
	    String type();
	    int length();
	}
    1. 将注解添加到对应元素上
    	// 实体类，通过注解添加一些标识
	@Table("db_student")
	class Student {
	    @Fields(columnName = "db_id", type = "int", length = 12)
	   private int id;
	    @Fields(columnName = "db_age", type = "int", length = 2)
	    private int age;
	    @Fields(columnName = "db_sex", type = "String", length = 1)
	    private String sex;
	}
  2. 利用反射操作注解
Class<Student> studentClass = Student.class;
// 通过反射获得注解
Annotation[] annotations = studentClass.getAnnotations();
for (Annotation annotation : annotations) {
    System.out.println(annotation);
}

// 获取注解中value的值
Table annotation = studentClass.getAnnotation(Table.class);
System.out.println(annotation.value());

// 获取类指定的注解
Field id = studentClass.getDeclaredField("id");
Fields fieldAnnotation = id.getAnnotation(Fields.class);
System.out.println(fieldAnnotation.columnName());
System.out.println(fieldAnnotation.type());
System.out.println(fieldAnnotation.length());
tag(s): Java Reflection 
show comments · back · home