反射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;}@Overridepublic String toString() {return "Person [name=" + name + ", age=" + age + "]";} 
}

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

Java 反射机制提供的功能：

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

优点：

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

缺点：

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

4. 反射的应用

4.1 创建运行时类的对象

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

步骤：

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

要求：

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

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

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

步骤：

通过 Class 类的 getDeclaredConstructor(Class … parameterTypes)取得本类的指定形参类型的构造器
向构造器的形参中传递一个对象数组进去，里面包含了构造器中所需的各个参数。
通过 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