反射Reflection

1. 反射的出现背景

        Java 程序中，所有的对象都有两种类型：编译时类型和运行时类型，而很多时候对象的编译时类型和运行时类型不一致。 

        例如：某些变量或形参的声明类型是 Object 类型，但是程序却需要调用该对象运行时类型的方法，该方法不是 Object 中的方法，那么如何解决呢？

        解决这个问题，有两种方案：

        方案 1：在编译和运行时都完全知道类型的具体信息，在这种情况下，我们可以直接先使用 instanceof 运算符进行判断，再利用强制类型转换符将其转换成运行时类型的变量即可。

        方案 2：编译时根本无法预知该对象和类的真实信息，程序只能依靠运行时信息来发现该对象和类的真实信息，这就必须使用反射。

---

2. 反射概述

        Reflection（反射）是被视为动态语言的关键，反射机制允许程序在运行期间借助于 Reflection API 取得任何类的内部信息，并能直接操作任意对象的内部属性及方法。

        加载完类之后，在堆内存的方法区中就产生了一个 Class 类型的对象（一个类只有一个 Class 对象），这个对象就包含了完整的类的结构信息。我们可以通过这个对象看到类的结构。这个对象就像一面镜子，透过这个镜子看到类的结构， 所以，我们形象的称之为：反射。

         从内存加载上看反射：

public class Test1 {

    public static void main(String[] args) throws InstantiationException, IllegalAccessException, NoSuchFieldException, SecurityException, NoSuchMethodException, InvocationTargetException {
        
        // 反射
        // 创建实例
        Class<Person> clazz = Person.class;
        Person person2 = clazz.newInstance();
        System.out.println(person2);

        // 调用属性
        Field ageField = clazz.getField("age");
        ageField.set(person2, 10);
        System.out.println(ageField.get(person2));

        // 调用方法
        Method showMethod = clazz.getMethod("show");
        showMethod.invoke(person2);

        // 调用私有构造器
        Class<Person> clazz1 = Person.class;
        Constructor<Person> cons = clazz1.getDeclaredConstructor(String.class, int.class);
        cons.setAccessible(true);
        Person person3 = (Person) cons.newInstance("Tom", 22);
        System.out.println(person3);

        // 调用私有属性
        Field namField = clazz1.getDeclaredField("name");
        namField.setAccessible(true);
        namField.set(person3, "Jerry");
        System.out.println(person3);

    }

}

class Person {
    private String name;
    public int age;
    public static boolean sex = false;

    public Person() {
        System.out.println("Person()...");
    }
    

    @SuppressWarnings("unused")
    private Person(String name, int age) {
        System.out.println("Person()..." + name + age);
        this.name = name;
        this.age = age;
    }

    public void show() {
        System.out.println("Person.show()...");
    }

    private String m1(String name, int age) {
        System.out.println("m1()..." + name + "-" + age);
        return "m1()..." + name + "-" + age;
    }

    @Override
    public String toString() {
        return "Person [name=" + name + ", age=" + age + "]";
    } 
}

---

3. Java 反射机制功能及优缺点

Java 反射机制提供的功能：

• 在运行时判断任意一个对象所属的类
• 在运行时构造任意一个类的对象
• 在运行时判断任意一个类所具有的成员变量和方法
• 在运行时获取泛型信息
• 在运行时调用任意一个对象的成员变量和方法
• 在运行时处理注解
• 生成动态代理

优点：

• 提高了 Java 程序的灵活性和扩展性，降低了耦合性，提高自适应能力
• 允许程序创建和控制任何类的对象，无需提前硬编码目标类

缺点：

• 反射的性能较低，反射机制主要应用在对灵活性和扩展性要求很高的系统框架上
• 反射会模糊程序内部逻辑，可读性较差

---

4. 反射的应用

4.1 创建运行时类的对象

方式 1：直接调用 Class 对象的 newInstance() 方法

步骤：

1. 获取该类型的 Class 对象
2. 调用 Class 对象的 newInstance()方法创建对象

要求：

• 类必须有一个无参数的构造器
• 类的构造器的访问权限需要足够

Class<Person> clazz = Person.class;
Person p = clazz.newInstance();

方式 2：通过获取构造器对象来进行实例化

步骤：

1. 通过 Class 类的 getDeclaredConstructor(Class … parameterTypes)取得本类的指定形参类型的构造器
2. 向构造器的形参中传递一个对象数组进去，里面包含了构造器中所需的各个参数。
3. 通过 Constructor 实例化对象

如果构造器的权限修饰符修饰的范围不可见，可以调用 setAccessible(true)   

Class<Person> clazz1 = Person.class;
Constructor<Person> cons = clazz1.getDeclaredConstructor(String.class, int.class);
cons.setAccessible(true);
Person p1 = (Person) cons.newInstance("Tom", 22);

4.2 获取运行时类的完整结构

可以获取：包、修饰符、类型名、父类（包括泛型父类）、父接口（包括泛型父接口）、成员（属性、构造器、方法）、注解（类上的、方法上的、属性上的）。

相关API：

//1.实现的全部接口 
public Class<?>[] getInterfaces() 
//确定此对象所表示的类或接口实现的接口。 
 
//2.所继承的父类 
public Class<? Super T> getSuperclass() 
//返回表示此 Class 所表示的实体（类、接口、基本类型）的父类的 Class。 
  
//3.全部的构造器 
public Constructor<T>[] getConstructors() 
//返回此 Class 对象所表示的类的所有 public 构造方法。 
public Constructor<T>[] getDeclaredConstructors() 
//返回此 Class 对象表示的类声明的所有构造方法。 
 
//Constructor 类中： 
//取得修饰符: 
public int getModifiers(); 
//取得方法名称: 
public String getName(); 
//取得参数的类型： 
public Class<?>[] getParameterTypes(); 
 
//4.全部的方法 
public Method[] getDeclaredMethods() 
//返回此 Class 对象所表示的类或接口的全部方法 
public Method[] getMethods() 
//返回此 Class 对象所表示的类或接口的 public 的方法 
 
//Method 类中： 
public Class<?> getReturnType() 
//取得全部的返回值 
public Class<?>[] getParameterTypes() 
//取得全部的参数 
public int getModifiers() 
//取得修饰符 
public Class<?>[] getExceptionTypes() 
//取得异常信息 
 
//5.全部的 Field 
public Field[] getFields() 
//返回此 Class 对象所表示的类或接口的 public 的 Field。 
public Field[] getDeclaredFields() 
//返回此 Class 对象所表示的类或接口的全部 Field。 
 
//Field 方法中： 
public int getModifiers() 
//以整数形式返回此 Field 的修饰符 
public Class<?> getType() 
//得到 Field 的属性类型 
public String getName() 
//返回 Field 的名称。 
  
//6. Annotation 相关 
get Annotation(Class<T> annotationClass) 
getDeclaredAnnotations() 
 
//7.泛型相关 
//获取父类泛型类型： 
Type getGenericSuperclass() 
//泛型类型：ParameterizedType 
//获取实际的泛型类型参数数组： 
getActualTypeArguments() 
 
//8.类所在的包 
Package getPackage()

4.3 调用运行时类的指定结构

调用指定构造器

Class<Person> clazz1 = Person.class;
Constructor<Person> cons = clazz1.getDeclaredConstructor(String.class, int.class);
cons.setAccessible(true);
Person p1 = (Person) cons.newInstance("Tom", 22);

调用指定属性

（1）获取该类型的 Class 对象 Class clazz = Class.forName("包.类名")；

（2）获取属性对象 Field field = clazz.getDeclaredField("属性名")；

（3）如果属性的权限修饰符不是 public，那么需要设置属性可访问 field.setAccessible(true)；

（4）创建实例对象：如果操作的是非静态属性，需要创建实例对象 Object obj = clazz.newInstance()；有公共的无参构造 Object obj = 构造器对象.newInstance(实参...)；通过特定构造器对象创建实例对象。

（5）设置指定对象 obj 上此 Field 的属性内容 field.set(obj,"属性值")；如果操作静态变量，那么实例对象可以省略，用 null 该类型的 Class 对象表示。

（6）取得指定对象 obj 上此 Field 的属性内容 Object value = field.get(obj)；如果操作静态变量，那么实例对象可以省略，用 null 或该类型的 Class 对象表示。

// public 属性
Field ageField = clazz1.getField("age");
ageField.set(p1, 3);
System.out.println(ageField.get(p1));   // 3

// private 属性
Field namField = clazz1.getDeclaredField("name");
namField.setAccessible(true);
namField.set(p1, "xiaoLI");
System.out.println(namField.get(p1));   // xiaoLI

// static 属性
Field sexField = clazz1.getDeclaredField("sex");
sexField.set(clazz1, true);
System.out.println(sexField.get(clazz1));   // true

调用指定方法

（1）获取该类型的 Class 对象 Class clazz = Class.forName("包.类名")；

（2）获取方法对象 Method method = clazz.getDeclaredMethod("方法名",方法的形参类型列表)；

（3）创建实例对象 Object obj = clazz.newInstance()；

（4）调用方法 Object result = method.invoke(obj, 方法的实参值列表)；如果方法的权限修饰符修饰的范围不可见，也可以调用 setAccessible(true) 。如果方法是静态方法，实例对象也可以省略，用 null 代替。

// 方法
Method m1Method = clazz1.getDeclaredMethod("m1", String.class, int.class);
m1Method.setAccessible(true);
Object returnVal = m1Method.invoke(p1, "YY", 18);
System.out.println((String)returnVal);  // m1()...YY-18

读取注解信息

一个完整的注解应该包含三个部分： （1）声明 （2）使用 （3）读取

@Inherited 
@Target(ElementType.TYPE) 
@Retention(RetentionPolicy.RUNTIME) 
public @interface Anno {
    String value(); 
}


@Anno(value = "t_person")
class Person {
    ...
}

// 获取类上的注解
Anno an = clazz1.getDeclaredAnnotation(Anno.class);
System.out.println(an.value());     // t_person