Java-反射机制

一、反射(Reflection)的概念

1.1反射的出现背景

Java 程序中，所有的对象都有两种类型：编译时类型和运行时类型，而很多时候
对象的编译时类型和运行时类型不一致。 Object obj = new String(“hello”);

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

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

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

1.2 反射概述

Reflection（反射）是被视为动态语言的关键，反射机制允许程序在运行期间借助于 Reflection API 取得任何类的内部信息，并能直接操作任意对象的内部属性及方法。
加载完类之后，在堆内存的方法区中就产生了一个 Class 类型的对象（一个类只有一个 Class 对象），这个对象就包含了完整的类的结构信息。我们可以通过这个对象看到类的结构。这个对象就像一面镜子，透过这个镜子看到类的结构，所以，我们形象的称之为：反射。

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

1.4 反射的优缺点

优点：
• 提高了 Java 程序的灵活性和扩展性，降低了耦合性，提高自适应能力
• 允许程序创建和控制任何类的对象，无需提前硬编码目标类
缺点：
• 反射的性能较低。
– 反射机制主要应用在对灵活性和扩展性要求很高的系统框架上
• 反射会模糊程序内部逻辑，可读性较差。

二、Class类的理解与类的加载

2.1Class类的理解

针对于编写好的,java源文件进行编译(javac.exe)，生成一个或多个.class字节码文件。接着使用java.exe命令对指定的.class文件进行解释运行。
在这个解释运行的过程中，我们需要将.class字节码文件加载(类的加载器)到内存中,加载到内存中的.class文件对应的结构即为Class的一个运行时实例。

public final Class getClass()

以上的方法返回值的类型是一个 Class 类，此类是 Java 反射的源头，实际上所谓反射从程序的运行结果来看也很好理解，即：可以通过对象反射求出类的名称。

一个 Class 对象包含了特定某个结构的有关信息:
• Class 本身也是一个类
• Class 对象只能由系统建立对象
• 一个加载的类在 JVM 中只会有一个 Class 实例
• 一个 Class 对象对应的是一个加载到 JVM 中的一个.class 文件
• 每个类的实例都会记得自己是由哪个 Class 实例所生成
• 通过 Class 可以完整地得到一个类中的所有被加载的结构
• Class 类是 Reflection 的根源，任何你想动态加载、运行的类，唯有先获得相应的Class 对象

#调用运行时类的静态属性:class
Class clazz1 = User.class;
#调用运行时类的对象的getClass()
User u1 = new User();
Class clazz2 = u1.getClass()；
#调用Class的静态方法forName(String className)  （掌握,动态性好）
Class clazz3 = Class.forName(className);#className为类的全类名
#使用类的加载器(了解)
Class clazz4 = ClassLoader.getSystemClassLoader().loadClass(className)
System.out.println(clazz1 == clazz2)//true
System.out.println(clazz1 == clazz3)//true
System.out.println(clazz1 == clazz4)//true

注意:java中==比较的是两个对象存放在栈中的地址值

内存结构

2.2Class类的常用API

方法名	功能说明
static Class forName(String name)	返回指定类名 name 的 Class 对象
Object newInstance()	调用缺省构造函数，返回该 Class 对象的一个实例
getName()	返回此 Class 对象所表示的实体（类、接口、数组类、基本类型或 void）名称
Class getSuperClass()	返回当前 Class 对象的父类的 Class 对象
Class [] getInterfaces()	获取当前 Class 对象的接口
ClassLoader getClassLoader()	返回该类的类加载器
Class getSuperclass()	返回表示此 Class 所表示的实体的超类的Class
Constructor[] getConstructors()	返回一个包含某些 Constructor 对象的数组
Field[] getDeclaredFields()	返回 Field 对象的一个数组
Method getMethod(String name,Class … paramTypes)	返回一个 Method 对象，此对象的形参类型为 paramType

2.3 类的加载

类在内存中完整的生命周期：加载–>使用–>卸载。其中加载过程又分为：装载、链接、初始化三个阶段

当程序主动使用某个类时，如果该类还未被加载到内存中，系统会通过加载、链接、初始化三个步骤来对该类进行初始化。如果没有意外，JVM 将会连续完成这三个步骤，所以有时也把这三个步骤统称为类加载。

（1）装载（Loading）
将类的 class 文件读入内存，并为之创建一个 java.lang.Class 对象。此过程由类加载器完成
（2）链接（Linking）
①验证 Verify：确保加载的类信息符合 JVM 规范，例如：以 cafebabe 开头，没有安全方面的问题。
②准备 Prepare：正式为类变量（static）分配内存并设置类变量默认初始值的阶段，这些内存都将在方法区中进行分配。
③解析 Resolve：虚拟机常量池内的符号引用（常量名）替换为直接引用（地址）的过程。
（3）初始化（Initialization）
• 执行类构造器()方法的过程。类构造器()方法是由编译期自动收集类中所有类变量的赋值动作和静态代码块中的语句合并产生的。（类构造器是构造类信息的，不是构造该类对象的构造器）。
• 当初始化一个类的时候，如果发现其父类还没有进行初始化，则需要先触发其父类的初始化。
• 虚拟机会保证一个类的()方法在多线程环境中被正确加锁和同步。

类缓存：标准的 JavaSE 类加载器可以按要求查找类，但一旦某个类被加载到类加载器中，它将维持加载（缓存）一段时间。不过 JVM 垃圾回收机制可以回收这些 Class 对象。

2.4 类加载器的分类(JDK8)

JVM 支持两种类型的类加载器，分别为引导类加载器（Bootstrap ClassLoader）和自定义类加载器（User-Defined ClassLoader）。
从概念上来讲，自定义类加载器一般指的是程序中由开发人员自定义的一类类加载器，但是 Java 虚拟机规范却没有这么定义，而是将所有派生于抽象类ClassLoader 的类加载器都划分为自定义类加载器。无论类加载器的类型如何划分，在程序中我们最常见的类加载器结构主要是如下情况

（1）启动类加载器（引导类加载器，Bootstrap ClassLoader）
• 这个类加载使用 C/C++语言实现的，嵌套在 JVM 内部。获取它的对象时往往返回null
• 它用来加载 Java 的核心库（JAVA_HOME/jre/lib/rt.jar 或 sun.boot.class.path 路径下的内容）。用于提供 JVM 自身需要的类。
• 并不继承自 java.lang.ClassLoader，没有父加载器。
• 出于安全考虑，Bootstrap 启动类加载器只加载包名为 java、javax、sun 等开头的类
• 加载扩展类和应用程序类加载器，并指定为他们的父类加载器。

（2）扩展类加载器（Extension ClassLoader）
• Java 语言编写，由 sun.misc.Launcher$ExtClassLoader 实现。
• 继承于 ClassLoader 类
• 父类加载器为启动类加载器
• 从 java.ext.dirs 系统属性所指定的目录中加载类库，或从 JDK 的安装目录的 jre/lib/ext子目录下加载类库。如果用户创建的 JAR 放在此目录下，也会自动由扩展类加载器加载

（3）应用程序类加载器（系统类加载器，AppClassLoader）
• java 语言编写，由 sun.misc.Launcher$AppClassLoader 实现
• 继承于 ClassLoader 类
• 父类加载器为扩展类加载器
• 它负责加载环境变量 classpath 或系统属性 java.class.path 指定路径下的类库
• 应用程序中的类加载器默认是系统类加载器。
• 它是用户自定义类加载器的默认父加载器
• 通过 ClassLoader 的 getSystemClassLoader()方法可以获取到该类加载器

（4）用户自定义类加载器（了解）
• 在 Java 的日常应用程序开发中，类的加载几乎是由上述 3 种类加载器相互配合执行的。在必要时，我们还可以自定义类加载器，来定制类的加载方式。
• 体现 Java 语言强大生命力和巨大魅力的关键因素之一便是，Java 开发者可以自定义类加载器来实现类库的动态加载，加载源可以是本地的 JAR 包，也可以是网络上的远程资源。
• 同时，自定义加载器能够实现应用隔离，例如 Tomcat，Spring 等中间件和组件框架都在内部实现了自定义的加载器，并通过自定义加载器隔离不同的组件模块。这种机制比 C/C++程序要好太多，想不修改 C/C++程序就能为其新增功能，几乎是不可能的，仅仅一个兼容性便能阻挡住所有美好的设想。
• 自定义类加载器通常需要继承于 ClassLoader。

查看某个类的类加载器对象

（1）获取默认的系统类加载器
ClassLoader classloader = ClassLoader.getSystemClassLoader();
（2）查看某个类是哪个类加载器加载的
ClassLoader classloader = Class.forName("exer2.ClassloaderDemo").getClassLoader();
//如果是根加载器加载的类，则会得到 null
ClassLoader classloader1 = Class.forName("java.lang.Object").getClassLoader();
（3）获取某个类加载器的父加载器
ClassLoader parentClassloader = classloader.getParent();

使用ClassLoader加载properties文件

Properties pros = new Properties();
#使用ClassLoader默认的路径是在module的Src下
InputStream is = ClassLoader.getSystemClassLoader().getResourceAsStream(fileName)
pros.load(is);

三、反射的基本应用

应用 1：创建运行时类的对象

这是反射机制应用最多的地方。创建运行时类的对象有两种方式:
方式 1：直接调用 Class 对象的 newInstance()方法
要 求： 1）类必须有一个无参数的构造器。2）类的构造器的访问权限需要足够

Class clazz = Class.forName(Person类全类名);
Person per = clazz.newInstance();

方式 2：通过获取构造器对象来进行实例化
1）通过 Class 类的 getDeclaredConstructor(Class … parameterTypes)取得本类的
指定形参类型的构造器
2）向构造器的形参中传递一个对象数组进去，里面包含了构造器中所需的各个参数。
3）通过 Constructor 实例化对象。如果构造器的权限修饰符修饰的范围不可见，也可以调用setAccessible(true)

Constructor<?> constructor = clazz.getDeclaredConstructor(String.class,int.class);
Object obj = constructor.newInstance("javaflection",2022);

应用 2：获取运行时类的完整结构

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

//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()

举例:
Class clazz = Person.class;
Field[] declaredFields = clazz.getDeclaredFields();
for(Field f : declaredFields){
System.out.println(f);
}

应用 3：获取运行时类的指定结构

获取运行时类的指定属性

Class clazz = Person.class;
Person per = (Person) clazz.newInstance();
//获取运行时类指定名的属性  能够获取私有权限属性
Field ageField = clazz.getDeclaredField("age");
//设置语言访问检测
nameField.setAccessible(true);
//设置age属性值
ageField.set(per,2)
System.out.print(ageField.get(per))

获取运行时类的指定方法

Class clazz = Person.class;
//静态方法不需要创建实例对象
Person per = (Person) clazz.newInstance();
//获取运行时类的指定方法
Method showNationMethod = clazz.getDeclaredMethod("showNation",String.class,int.class);
showNationMethod .setAccessible(true);
Object returnValue= showNationMethod.invoke(per,"CHN",10);

获取运行时类的指定构造器

Class clazz = Person.class;

Constructor construct= clazz.getDeclaredConstructor(,String.class,int.class);
construct.setAccessible(true);
Person peron = (Person)construct.newInstance("tom",12);