Java学习——反射

Java学习——反射

摘要：本文主要讲述了什么是反射，使用反射有什么好处，以及如何使用反射。

部分内容来自以下博客：

https://www.cnblogs.com/tech-bird/p/3525336.html

https://www.cnblogs.com/jiaoyiping/p/6130355.html

什么是反射

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

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

Class类

Class类是什么

Class是用来描述类的类，封装了当前对象所对应的类的信息。

一个类中有属性，方法，构造器等，比如说有一个Person类，一个Order类，一个Book类，这些都是不同的类，现在需要一个类，用来描述类，这就是Class，它应该有类名，属性，方法，构造器等。

Class类是一个对象照镜子的结果，对象可以看到自己有哪些属性，方法，构造器，实现了哪些接口等等。

对于每个类而言，JRE都为其保留一个不变的Class类型的对象。一个Class对象包含了特定某个类的有关信息。

Class对象只能由系统建立对象，一个类（而不是一个对象）在JVM中只会有一个Class实例。

通过Class可以完整地得到一个类中的所有被加载的结构。

Class类是Reflection的根源，针对任何你想动态加载、运行的类，唯有先获得相应的Class对象。

Java中的哪些类型可以有Class类的实例

类，接口，枚举，注解，数组，基本数据类型，void。

常用方法

static Class<?> forName(String className)：返回指定类名的Class对象。

T newInstance()：返回该Class对象对应的类的一个实例。

Field[] getFields()：获取所有的公共属性。

Field[] getDeclaredFields()：获取所有的属性。

Field getField(String name)：获取指定名称的公共属性。

Field getDeclaredField(String name)：获取指定名称的属性。

Method[] getMethods()：获取所有的公共方法。

Method[] getDeclaredMethods()：获取所有的方法。

Method getMethod(String name, Class<?>... parameterTypes)：返回指定名称、参数列表的公共方法。

Method getDeclaredMethod(String name, Class<?>... parameterTypes)：返回指定名称、参数列表的方法。

Constructor<?>[] getConstructors()：获取所有的公共构造方法。

Constructor<?>[] getDeclaredConstructors()：获取所有的构造方法。

Constructor<T> getConstructor(Class<?>... parameterTypes)：获取指定参数列表的公共构造方法。

Constructor<T> getDeclaredConstructor(Class<?>... parameterTypes)：获取指定参数列表的构造方法。

<A extends Annotation> A getAnnotation(Class<A> annotationClass)：获取指定类型的公共注解。

<A extends Annotation> A getDeclaredAnnotation(Class<A> annotationClass)：获取指定类型的注解。

Annotation[] getAnnotations()：获取所有的公共注解。

Annotation[] getDeclaredAnnotations()：获取所有的注解。

Class<?>[] getInterfaces()：获取实现的所有接口。

Type[] getGenericInterfaces()：获取带泛型的接口。

Class<? super T> getSuperclass()：获取继承的父类。

Type getGenericSuperclass()：获取带泛型的父类。

String getName()：返回全类名。

Package getPackage()：返回包名。

int getModifiers()：返回修饰符。

ClassLoader getClassLoader()：返回类加载器。

InputStream getResourceAsStream(String name)：返回读取的文件流。

如何获取Class类的实例

Class没有公共构造方法。

Class对象是在加载类时由Java虚拟机以及通过调用类加载器中的defineClass方法自动构造的。

Java程序经过编译以后，生成关于类的字节码文件。在解释运行时，需要将类的字节码文件加载到内存中（通过JVM的类的加载器实现的加载）。此时加载到内存中的类，我们就称作运行时类，此类本身就充当了java.lang.Class的一个实例。

反过来讲：一个Class的实例就对应着一个加载到内存中的运行时类。

获取Class类的实例有四种方式：

1）直接调用运行时类的.class属性

Class clazz = String.class;

2）通过调用运行时类的对象的getClass()方法

Class clazz = "www.atguigu.com".getClass();

3）调用Class的静态方法forName()获取

Class clazz = Class.forName("refl.Person");

4）使用类的加载器

ClassLoader cl = this.getClass().getClassLoader();
Class clazz = cl.loadClass("refl.Person");

使用forName()和loadClass()的区别

相同：

使用Class的静态方法forName()和使用ClassLoader的成员方法loadClass()都能获取指定类的Class实例。

也都会进行类的加载，即将.class文件读取到JVM中。

不同：

在调用Class的静态方法forName()时，除了会进行类的加载（即将.class文件加载到JVM中）以外，还会进行类的初始化（即初始化静态成员变量和执行静态代码块）。但调用forName()方法并不会执行构造方法创建对象，只要在调用了成员方法newInstance()以后，才会调用空参的构造方法创建对象。

当调用ClassLoader的成员方法loadClass()时，只进行类的加载（即将.class文件加载到JVM中），不会进行类的初始化（即初始化静态成员变量和执行静态代码块），也不会执行构造方法。

ClassLoader类

类的加载过程

当程序主动使用了某个类时，该类还未被加载到内存中，那么系统会通过下面三个步骤对该类进行初始化。：

1）类的加载：将类的class文件读入内存，并为之创建一个Class对象。由类加载器完成。

2）类的连接：将类的二进制数据合并到JRE中。

3）类的初始化：JVM负责对类进行初始化。

何时会进行类的初始化

1）类的主动引用一定会发生类的初始化：

当虚拟机启动，先初始化main方法所在的类。

使用new关键字创建了一个类的对象。

调用类的静态成员（除了final常量）和静态方法。

使用java.lang.reflect包的方法对类进行反射调用。

当初始化一个类，如果其父类没有被初始化，则先会初始化它的父类。

2）类的被动引用不会发生类的初始化

当访问一个静态域时，只有真正声明这个域的类才会被初始化。

当通过子类引用父类的静态变量，不会导致子类初始化。

通过数组定义类引用，不会触发此类的初始化。

引用常量不会触发此类的初始化，常量在链接阶段就存入调用类的常量池中了。

类加载器的作用

将class文件字节码内容加载到内存中，并将这些静态数据转换成方法区的运行时数据结构，然后在堆中生成一个代表这个类的java.lang.Class对象，作为方法区中类数据的访问入口。

类加载器的分类

引导类加载器：用C++编写的，是JVM自带的类装载器，负责Java平台核心库，用来装载核心类库。无法直接获取。

扩展类加载器：负责jre/lib/ext目录下的JAR包或–D java.ext.dirs指定目录下的JAR包装入工作库。

系统类加载器：负责java –classpath或–D java.class.path所指的目录下的类与JAR包装入工作，最常用的加载器。

常用方法

Class<?> loadClass(String name)：将Class文件加载到内存时，并不会执行类的初始化。

static ClassLoader getSystemClassLoader()：获取系统类加载器。

ClassLoader getParent()：获取当前类加载器的上级类加载器。

static InputStream getSystemResourceAsStream(String name)：和getResourceAsStream用法类似。

InputStream getResourceAsStream(String name)：默认则是从ClassPath根下获取，path不能以'/'开头，最终是由ClassLoader获取资源。

如何获取类加载器

获取系统类加载器（可以获取）： ClassLoader.getSystemClassLoader(); 

获取扩展类加载器（可以获取）： ClassLoader.getSystemClassLoader().getParent(); 

获取引导类加载器（不可以获取）： ClassLoader.getSystemClassLoader().getParent().getParent(); 

测试类加载器

测试代码如下：

public static void main(String[] args) {
    // 获取系统类加载器
    ClassLoader appClassLoader = ClassLoader.getSystemClassLoader();
    System.out.println(appClassLoader);
    // 获取扩展类加载器
    ClassLoader extClassLoader = appClassLoader.getParent();
    System.out.println(extClassLoader);
    // 获取引导类加载器
    ClassLoader bootClassLoader = extClassLoader.getParent();
    System.out.println(bootClassLoader);
    // 自定义类使用的是系统类加载器
    System.out.println(ClassLoaderTest.class.getClassLoader());
    // JDK提供的类使用的是引导类加载器
    System.out.println(String.class.getClassLoader());
}

运行结果如下：

sun.misc.Launcher$AppClassLoader@18b4aac2
sun.misc.Launcher$ExtClassLoader@6d9c638
null
sun.misc.Launcher$AppClassLoader@18b4aac2
null

测试加载资源

测试代码如下：

// InputStream is1 = ClassLoader.getSystemClassLoader().getResourceAsStream("test.txt");// null
// InputStream is2 = ClassLoader.getSystemClassLoader().getResourceAsStream("/com/test/test.txt");// null
InputStream is3 = ClassLoader.getSystemClassLoader().getResourceAsStream("com/test/test.txt");
InputStream is4 = ClassLoader.getSystemResourceAsStream("com/test/test.txt");

使用反射

获取类的信息

// 根据类名获取类的Class实例
Class<?> cla = Class.forName("test.Student");
// 获取全类名
System.out.println("cla.getName() >>> " + cla.getName());// cla.getName() >>> test.Student
// 获取包名
System.out.println("cla.getPackage() >>> " + cla.getPackage());// cla.getPackage() >>> package test
// 获取访问修饰符
System.out.println("cla.getModifiers() >>> " + cla.getModifiers());// cla.getModifiers() >>> 0
// 获取翻译后的访问修饰符
System.out.println("cla.getModifiers() >>> " + Modifier.toString(cla.getModifiers()));// cla.getModifiers() >>> 
// 获取加载器
System.out.println("cla.getClassLoader() >>> " + cla.getClassLoader());// cla.getClassLoader() >>> sun.misc.Launcher$AppClassLoader@18b4aac2
// 获取父类
Class<?> superclass = cla.getSuperclass();
System.out.println("cla.getSuperclass() >>> " + superclass);// cla.getSuperclass() >>> class test.People
// 获取带泛型的父类
Type genericSuperclass = cla.getGenericSuperclass();
System.out.println("cla.getGenericSuperclass() >>> " + genericSuperclass);
// 获取带泛型的父类的泛型类型
ParameterizedType paramType = (ParameterizedType) genericSuperclass;
Type[] actualTypeArguments = paramType.getActualTypeArguments();
for (Type type : actualTypeArguments) {
    System.out.println("genericSuperclass.getActualTypeArguments() >>> " + type.getTypeName());
}
// 获取接口
Class<?>[] interfaces = cla.getInterfaces();
for (Class<?> interfaceClass : interfaces) {
    System.out.println("cla.getInterfaces() >>> " + interfaceClass);
    // cla.getInterfaces() >>> interface test.School
    // cla.getInterfaces() >>> interface test.Home
}
// 获取带泛型的接口
Type[] genericInterfaces = cla.getGenericInterfaces();
for (Type genericInterface : genericInterfaces) {
    System.out.println("cla.getGenericInterfaces() >>> " + genericInterface);
    // cla.getGenericInterfaces() >>> test.School<J>
    // cla.getGenericInterfaces() >>> test.Home<K>
}
// 使用反射创建类的实例
Student student = (Student) cla.newInstance();// >>> Student()
System.out.println("student.toString() >>> " + student);// student.toString() >>> [age:0][grade:0.0][sex:null]

获取类的属性

// 获取所有的公共属性，包括父类的公共属性
Field[] fields = cla.getFields();
for (Field field : fields) {
    System.out.println("cla.getFields() >>> " + field);
    // cla.getFields() >>> public int test.Student.age
    // cla.getFields() >>> public java.lang.String test.People.name
}
// 获取已声明的所有属性，包括非公共属性，但不包括父类的属性
Field[] declaredFields = cla.getDeclaredFields();
for (Field field : declaredFields) {
    System.out.println("cla.getDeclaredFields() >>> " + field);
    // cla.getDeclaredFields() >>> public int test.Student.age
    // cla.getDeclaredFields() >>> double test.Student.grade
    // cla.getDeclaredFields() >>> private java.lang.String test.Student.sex
}
// 获取指定名称的属性
// Field sex = cla.getField("sex");
Field sex = cla.getDeclaredField("sex");
System.out.println("cla.getDeclaredField() >>> " + sex);// cla.getDeclaredField() >>> private java.lang.String test.Student.sex
// 获取访问修饰符
System.out.println("sex.getModifiers() >>> " + Modifier.toString(sex.getModifiers()));// sex.getModifiers() >>> private
// 获取类型
System.out.println("sex.getType() >>> " + sex.getType().getName());// sex.getType() >>> java.lang.String
// 获取名称
System.out.println("sex.getName() >>> " + sex.getName());// sex.getName() >>> sex
// 获取和修改属性值，非公共属性需要执行setAccessible()方法
sex.setAccessible(true);
System.out.println("sex.get() >>> " + sex.get(student));// sex.get() >>> null
sex.set(student, "男");
System.out.println("student.getSex() >>> " + student.getSex());// student.getSex() >>> 男

获取类的方法

// 获取所有的公共方法，包括父类的公共方法和接口的公共方法
Method[] methods = cla.getMethods();
for (Method method : methods) {
    System.out.println("cla.getMethods() >>> " + method);
    // cla.getMethods() >>> public int test.Student.getAge()
    // cla.getMethods() >>> public void test.Student.setAge(int)
    // cla.getMethods() >>> public double test.Student.getGrade()
    // cla.getMethods() >>> public void test.Student.setGrade(double)
    // cla.getMethods() >>> public java.lang.String test.Student.getSex()
    // cla.getMethods() >>> public void test.Student.setSex(java.lang.String)
    // cla.getMethods() >>> public java.lang.String test.Student.toString()
    // cla.getMethods() >>> public void test.Student.showSchool(java.lang.Object)
    // cla.getMethods() >>> public void test.Student.showHome(java.lang.Object)
    // cla.getMethods() >>> public java.lang.String test.People.getName()
    // cla.getMethods() >>> public void test.People.setName(java.lang.String)
    // cla.getMethods() >>> public boolean java.lang.Object.equals(java.lang.Object)
    // cla.getMethods() >>> public native int java.lang.Object.hashCode()
    // cla.getMethods() >>> public final native java.lang.Class java.lang.Object.getClass()
    // cla.getMethods() >>> public final native void java.lang.Object.notify()
    // cla.getMethods() >>> public final native void java.lang.Object.notifyAll()
    // cla.getMethods() >>> public final void java.lang.Object.wait() throws java.lang.InterruptedException
    // cla.getMethods() >>> public final void java.lang.Object.wait(long,int) throws java.lang.InterruptedException
    // cla.getMethods() >>> public final native void java.lang.Object.wait(long) throws java.lang.InterruptedException
    // cla.getMethods() >>> public java.lang.String test.Student.testStudent(java.lang.String) throws java.lang.NullPointerException,java.lang.ArithmeticException
}
// 获取已声明的所有方法，包括非公共方法和重写的方法，但不包括父类的方法
Method[] declaredMethods = cla.getDeclaredMethods();
for (Method method : declaredMethods) {
    System.out.println("cla.getDeclaredMethods() >>> " + method);
    // cla.getDeclaredMethods() >>> public int test.Student.getAge()
    // cla.getDeclaredMethods() >>> public void test.Student.setAge(int)
    // cla.getDeclaredMethods() >>> public double test.Student.getGrade()
    // cla.getDeclaredMethods() >>> public void test.Student.setGrade(double)
    // cla.getDeclaredMethods() >>> public java.lang.String test.Student.getSex()
    // cla.getDeclaredMethods() >>> public void test.Student.setSex(java.lang.String)
    // cla.getDeclaredMethods() >>> public java.lang.String test.Student.toString()
    // cla.getDeclaredMethods() >>> public void test.Student.showSchool(java.lang.Object)
    // cla.getDeclaredMethods() >>> public void test.Student.showHome(java.lang.Object)
    // cla.getDeclaredMethods() >>> public java.lang.String test.Student.testStudent(java.lang.String) throws java.lang.NullPointerException,java.lang.ArithmeticException
    // cla.getDeclaredMethods() >>> private void test.Student.doTestStudent()
}
// 获取指定名称和参数类型的方法
// Method testStudent = cla.getMethod("testStudent", String.class);
Method testStudent = cla.getDeclaredMethod("testStudent", String.class);
System.out.println("cla.getDeclaredMethod() >>> " + testStudent);// cla.getDeclaredMethod() >>> public java.lang.String test.Student.testStudent(java.lang.String) throws java.lang.NullPointerException,java.lang.ArithmeticException
// 获取注解
Annotation[] annotations = testStudent.getAnnotations();
for (Annotation annotation : annotations) {
    System.out.println("testStudent.getAnnotations() >>> " + annotation);
    // testStudent.getAnnotations() >>> @java.lang.Deprecated()
}
// 获取访问修饰符
System.out.println("testStudent.getModifiers() >>> " + Modifier.toString(testStudent.getModifiers()));// testStudent.getModifiers() >>> public
// 获取返回值类型
System.out.println("testStudent.getReturnType() >>> " + testStudent.getReturnType().getName());// testStudent.getReturnType() >>> java.lang.String
// 获取名称
System.out.println("testStudent.getName() >>> " + testStudent.getName());// testStudent.getName() >>> testStudent
// 获取参数
Parameter[] parameters = testStudent.getParameters();
for (Parameter parameter : parameters) {
    System.out.println("testStudent.getParameters() >>> " + parameter.getName());
    // testStudent.getParameters() >>> name
}
// 获取参数列表
Class[] parameterTypes = testStudent.getParameterTypes();
for (Class parameterType : parameterTypes) {
    System.out.println("testStudent.getParameterTypes() >>> " + parameterType.getName());
    // testStudent.getParameterTypes() >>> java.lang.String
}
// 获取异常
Class[] exceptionTypes = testStudent.getExceptionTypes();
for (Class exceptionType : exceptionTypes) {
    System.out.println("testStudent.getExceptionTypes() >>> " + exceptionType.getName());
    // testStudent.getExceptionTypes() >>> java.lang.NullPointerException
    // testStudent.getExceptionTypes() >>> java.lang.ArithmeticException
}
// 调用方法，非公共属性需要执行setAccessible()方法
Object testStudentResult = testStudent.invoke(student, "abc");// >>> testStudent()
System.out.println("testStudent.invoke() >>> " + testStudentResult);// testStudent.invoke() >>> abc
Method doTestStudent = cla.getDeclaredMethod("doTestStudent");
// Object doTestStudentResult = doTestStudent.invoke(student);// java.lang.IllegalAccessException
doTestStudent.setAccessible(true);
Object doTestStudentResult = doTestStudent.invoke(student);// >>> doTestStudent()
System.out.println("doTestStudent.invoke() >>> " + doTestStudentResult);// doTestStudent.invoke() >>> null

获取类的构造方法

// 获取所有的公共构造方法
Constructor<?>[] constructors = cla.getConstructors();
for (Constructor<?> constructor : constructors) {
    System.out.println("cla.getConstructors() >>> " + constructor);
    // cla.getConstructors() >>> public test.Student()
    // cla.getConstructors() >>> public test.Student(java.lang.String)
}
// 获取所有的构造方法，包括非公共构造方法
Constructor<?>[] declaredConstructors = cla.getDeclaredConstructors();
for (Constructor<?> constructor : declaredConstructors) {
    System.out.println("cla.getDeclaredConstructors() >>> " + constructor);
    // cla.getDeclaredConstructors() >>> public test.Student()
    // cla.getDeclaredConstructors() >>> public test.Student(java.lang.String)
    // cla.getDeclaredConstructors() >>> private test.Student(int,double,java.lang.String)
}
// 获取参数类型的构造方法
// Constructor<?> peopleConstructor = cla.getConstructor(String.class);
Constructor<?> studentConstructor = cla.getDeclaredConstructor(int.class, double.class, String.class);
System.out.println("cla.getDeclaredConstructor() >>> " + studentConstructor);// cla.getDeclaredConstructor() >>> private test.Student(int,double,java.lang.String)
// 调用方法，非公共属性需要执行setAccessible()方法
// student = (Student) studentConstructor.newInstance(10, 3.5, "女");// java.lang.IllegalAccessException
studentConstructor.setAccessible(true);
student = (Student) studentConstructor.newInstance(10, 3.5, "女");
System.out.println("student.toString() >>> " + student);// student.toString() >>> [age:10][grade:3.5][sex:女]