Java反射

小德 2021-12-02 12:57:59
Categories： Tags：

JAVA反射

什么是java反射？

反射就是在运行时才知道要操作的类是什么，并且可以在运行时获取类的完整构造，并调用对应的方法。

一、java的核心机制

java有两种核心机制:java虚拟机(JavaVirtual Machine)与垃圾收集机制(Garbagecollection):
1、Java虚拟机:是运行所有Java程序的抽象计算机，是Java语言的运行环境，在其上面运行Java代码编译后的字节码程序，java虚拟机实现了平台无关性。
2、Java垃圾回收(Garbage Collection)︰自动释放不用对象内存空间，在java程序运行过程中自动进行，垃圾收集机制可大大缩短编程时间，保护程序的完整性，是Java语言安全性策略的一个重要部份。

二. java虚拟机及其结构

java垃圾回收不需要程序员手动操作，我们经常需要关注的是java虚拟机，java虚拟机承载着程序从源码到运行的全部工作。
Java虚拟机是可运行Java代码的假想计算机，有自己想象中的硬件，如处理器、堆栈、寄存器等，还具有相应的指令系统，可以执行Java的字节码程序。Java语言的一个非常重要的特点就是与平台的无关性。而使用Java虚拟机是实现这一特点的关键。Java语言使用模式Java虚拟机屏蔽了与具体平台相关的信息，使得Java语言编译程序只需生成在Java虚拟机上运行的目标代码（字节码)，就可以在多种平台上不加修改地运行。Java虚拟机在执行字节码时，把字节码解释成具体平台上的机器指令执行。
对于JVM的基本结构，我们可以从下图可以大致了解:

fs1

fs1

三、程序的运行过程

从源文件创建到程序运行，Java程序要经过两大步骤:编译，运行; 1、源文件由编译器编译成字节码(ByteCode)2、字节码由java虚拟机解释运行。
1、第一步(编译):创建完源文件之后，程序会被编译器编译为.class文件。Java编译一个类时，如果这个类所依赖的类还没有被编译，编译器就会先编译这个被依赖的类，然后引用，否则直接引用。。编译后的字节码文件格式主要分为两部分:常量池和方法字节码。
2、第二步(运行) : java类运行的过程大概可分为两个过程:1、类的加载2、执行。

四、类的加载

类加载过程
java程序经过编译后形成.class文件。通过类加载器将字节码(.class)加载入JVM的内存中。JVM将类加载过程分成加载，连接，初始化三个阶段，其中连接阶段又可分为验证，准备，解析三个阶段。
JVM的类加载是通过ClassLoader及其子类来完成的，类的层次关系和加载顺序可以由下图来描述:

fs2

1、Bootstrap ClassLoader启动类加载器

负责加载$JAVA_HOME中jre/lib/里所有的class(JDK代表JDK的安装目录，下同)，或被-Xbootclasspath参数指定的路径中的，并且能被虚拟机识别的类库(如rt.jar，所有的java.*开头的类均被Bootstrap ClassLoader加载)。启动类加载器由C+＋实现，不是
ClassLoader子类。无法被Java程序直接引用的。

2、Extension ClassLoader扩展类加载器

该加载器由sun.misc.LauncherExtClassLoader实现，负责加载Java平台中扩展功能的一些jar包，包括ExtClassLoader实现，负责加载Java平台中扩展功能的一些jar包，包括
JAVA_HOME中jre/lib/.jar或-Djava.ext.dirs指定目录下的jar包。即JDKjrelibext目录中，或者由java.ext.dirs系统变量指定的路径中的所有类库(如javax.开头的类)，开发者可以直接使用扩展类加载器

3、App ClassLoader应用程序类加载器

该类加载器由sun.misc.LauncherSAppClassLoader 来实现，负责记载classpath 中指定的jar包及目录中class，开发者可以直接使用该类加载器，如果应用程序中没有自定义过自己的类加载器，—般情况下这个就是程序中默认的类加载器。
启动类加载器:它使用C+＋实现(这里仅限于Hotspot，也就是JDK1.5之后默认的虚拟机，有很多其他的虚拟机是用Java语言实现的)，是虚拟机自身的一部分。
所有其他的类加载器:这些类加载器都由Java语言实现，独立于虚拟机之外，并且全部继承自抽象类java.lang.ClassLoader，这些类加载器需要由启动类加载器加载到内存中之后才能去加载其他的类。
应用程序都是由这三种类加载器互相配合进行加载的，我们还可以加入自定义的类加载器。

加载
加载时类加载过程的第一个阶段，在加载阶段，虚拟机需要完成以下三件事情:

1、通过一个类的全限定名来获取其定义的二进制字节流。

2、将这个字节流所代表的静态存储结构转化为方法区的运行时数据结构。

3、在Java堆中生成一个代表这个类的java.lang.Class对象，作为对方法区中这些数据的访问入口。

注意，这里第1条中的二进制字节流并不只是单纯地从Class文件中获取，比如它还可以从Jar包中获取、从网络中获取（最典型的应用便是Applet)、由其他文件生成(JSP应用)等。

相对于类加载的其他阶段而言，加载阶段（准确地说，是加载阶段获取类的二进制字节流的动作)是可控性最强的阶段，因为开发人员既可以使用系统提供的类加载器来完成加载，也可以自定义自己的类加载器来完成加载。
(JVM主要在程序第一次主动使用类的时候，才会去加载该类。也就是说，JVM并不是在一开始就把一个程序就所有的类都加载到内存中，而是到用的时候才把它加载进来，而且只加载一次。)

加载过程中会先检查类是否被已加载，检查顺序是自底向上，从 Custom ClassLoader到BootStrap ClassLoader逐层检查，只要某个Classloader已加载就视为已加载此类，保证此类只所有ClassLoade r加载一次。而加载的顺序是自顶向下，也就是由上层来逐层尝试加载此类。
这几种类加载器的层次关系如下图所示:

fs3

这种层次关系称为类加载器的双亲委派模型。双亲委派模型的工作流程是:
如果一个类加载器收到了类加载的请求，它首先不会自己去尝试加载这个类，而是把请求委托给父加载器去完成，依次向上，因此，所有的类加载请求最终都应该被传递到顶层的启动类加载器中，只有当父加载器在它的搜索范围中没有找到所需的类时，即无法完成该加载，子加载器才会尝试自己去加载该类。

验证
验证的目的是为了确保Class文件中的字节流包含的信息符合当前虚拟机的要求，而且不会危害虚拟机自身的安全。不同的虚拟机对类验证的实现可能会有所不同，但大致都会完成以下四个阶段的验证:文件格式的验证、元数据的验证、字节码验证和符号引用验证。

准备
准备阶段是正式为类变量分配内存并设置类变量初始值的阶段，这些内存都将在方法区中分配。对于该阶段有以下几点需要注意:
1、这时候进行内存分配的仅包括类变量(static)，而不包括实例变量，实例变量会在对象实例化时随着对象—块分配在Java堆中。
2、这里所设置的初始值通常情况下是数据类型默认的零值(如0、OL、null、false等)，而不是被在Java 代码中被显式地赋予的值。

解析
解析阶段是虚拟机将常量池中的符号引用转化为直接引用的过程。
解析动作主要针对类或接口、字段、类方法、接口方法四类符号引用进行，分别对应于常量池中的CONSTANT_Class_info、CONSTANT_Fieldref_info、CONSTANT_Methodref_info,CONSTANT_InterfaceMethodref_info四种常量类型。1、类或接口的解析:判断所要转化成的直接引用是对数组类型，还是普通的对象类型的引用，从而进行不同的解析。
2、字段解析:对字段进行解析时，会先在本类中查找是否包含有简单名称和字段描述符都与目标相匹配的字段，如果有，则查找结束;如果没有，则会按照继承关系从上往下递归搜索该类所实现的各个接口和它们的父接口，还没有，则按照继承关系从上往下递归搜索其父类，直至查找结束。

初始化
类初始化是类加载过程的最后一个阶段，到初始化阶段，才真正开始执行类中的Java程序代码。虚拟机规范严格规定了有且只有四种情况必须立即对类进行初始化:
1、遇到new、getstatic、putstatic、invokestatic这四条字节码指令时，如果类还没有进行过初始化，则需要先触发其初始化。生成这四条指令最常见的Java 代码场景是:使用new关键字实例化对象时、读取或设置一个类的静态字段(static)时（被static修饰又被final修饰的，已在编译期把结果放入常量池的静态字段除外)、以及调用一个类的静态方法时。
2、使用Java.lang.refect包的方法对类进行反射调用时，如果类还没有进行过初始化，则需要先触发其初始化。
3、当初始化一个类的时候，如果发现其父类还没有进行初始化，则需要先触发其父类的初始化。
4、当虚拟机启动时，用户需要指定一个要执行的主类，虚拟机会先执行该主类。

虚拟机规定只有这四种情况才会触发类的初始化，称为对一个类进行主动引用，除此之外所有引用类的方式都不会触发其初始化，称为被动引用。

五、静态加载和动态加载

Java初始化一个类的时候可以用new操作符来初始化,也可通过Class.forName的方式来得到一个Class类型的实例,然后通过这个Class类型的实例的newInstance来初始化.我们把前者叫做JAVA的静态加载,把后者叫做动态加载.。
有时候我们说某个语言具有很强的动态性，有时候我们会区分动态和静态的不同技术与作法。我们朗朗上口动态绑定(dynamic binding)、动态链接（dynamic linking)、动态加载(dynamic loading）等。然而“动态”一词其实没有绝对而普遍适用的严格定义，有时候甚至像面向对象当初被导入编程领域—样，—人一把号，各吹各的调。
一般而言，开发者社群说到动态语言，大致认同的一个定义是:“程序运行时，允许改变程序结构或变量类型，这种语言称为动态语言”。从这个观点看，Perl，Python，Ruby是动态语言，C++， Java，C#不是动态语言。
尽管在这样的定义与分类下Java不是动态语言，它却有着一个非常突出的动态相关机制:Reflection。Java程序可以加载一个运行时才得知名称的class，获悉其完整构造（但不包括methods定义)，并生成其对象实体、或对其fields设值、或唤起其methods.

1、静态加载的时候如果在运行环境中找不到要初始化的类,抛出的是NoClassDefFoundError,它在JAVA的异常体系中是一个Error.
2、动态态加载的时候如果在运行环境中找不到要初始化的类,抛出的是
ClassNotFoundException,它在JAVA的异常体系中是一个checked异常,在写代码的时候就需要catch.

六、反射

JAVA反射机制:
在运行状态中，对于任意一个类，都能够知道这个类的所有属性和方法;对于任意一个对象，都能够调用它的任意一个方法和属性;这种动态获取的信息以及动态调用对象的方法的功能称为java语言的反射机制。

Java反射机制主要提供了以下功能:
在运行时判断任意一个对象所属的类;在运行时构造任意一个类的对象;在运行时判断任意一个类所具有的成员变量和方法;在运行时调用任意一个对象的方法;生成动态代理。

Java有个Object类，是所有Java类的继承根源，其内声明了数个应该在所有Java类中被改写的方法: hashCode()、equals()、clone()、toString().getClass()等。其中getClass()返回—个Class对象。

【Class类十分特殊。它和一般类—样继承自Object，其实体用以表达Java程序运行时的classes和interfaces，也用来表达enum、array、primitive Java types (boolean, byte,char, short, int, long, float, double)）以及关键词void。当一个class被加载，或当加载器(class loader)的defineClass()被JVM调用，JVM便自动产生一个Class对象。】

如果您想借由“修改Java标准库源码”来观察Class对象的实际生成时机（例如在Class的constructor内添加一个println(0)，这样是行不通的!因为Class并没有public constructor.

Class是Reflection故事起源。针对任何您想探勘的类，唯有先为它产生一个Class对象，接下来才能经由后者唤起为数十多个的Reflection APls。Reflection机制允许程序在正在执行的过程中，利用Reflection APls取得任何已知名称的类的内部信息，包括: package、 type
parameters、superclass、implemented interfaces、inner classes、outer classes,fields、constructors、methods、modifiers等，并可以在执行的过程中，动态生成instances、变更fields内容或唤起methods。

七、反射的使用

1.获取Class对象

1
2
3
4
5
6
7
8
9
// 怎么获取某一个类对应的 字节码的类
    // 1 种方法 通过类名直接获取
    Class cz = Student.class;
    // 2 种方法 用一个对象获取
    Student s1 = new Student();
    Class cz1 = s1.getClass();
    // 3 通过Class.forName 加载全路径获取
    Class cz2 = Class.forName("com.xmx.pojo.Student");
    System.out.println(cz2);

2.Class对象内容

1
2
3
4
5
6
Class cz = Student.class;
System.out.println(cz.getName()); // 得到类型的名称
System.out.println(cz.getSimpleName()); // 字符串简写名称
System.out.println(cz.getPackage()); // 得到该类型所在的包
System.out.println(cz.getSuperclass()); // 得到你的父类的 class文件
System.out.println(cz.getInterfaces()); // 得到所有的接口

3.获取Class对象所有成员变量的名字、类型

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
Class cz = Student.class;
// Field 表示一个字段 成员变量  拿到所有公有的字段
Field[] fields = cz.getFields();
for (Field f : fields) {
    System.out.println(f);
    System.out.println(f.getType()); // 得到字段的类型
    System.out.println(f.getName()); // 得到字段的名字
}
// 拿到所有的字段 不区分 公有和私有
Field[] declaredFields = cz.getDeclaredFields();
for (Field f : declaredFields) {
    System.out.println(f);
    System.out.println(f.getType()); // 得到字段的类型
    System.out.println(f.getName()); // 得到字段的名字
    // 拿到访问修饰符?
}

单个成员变量的名字、类型、访问修饰符

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
Class cz = Student.class;
// 所有字段的 名称 类型
Field sname = cz.getDeclaredField("age");// 拿到不区分访问修饰符的字段
System.out.println(sname.getName());
System.out.println(sname.getType());
// 得到访问修饰符  返回一个int值 表示访问修饰符
int modifier = ((Field) sname).getModifiers();
// 用 单位 & 两个数 做&  二进制的&
if ((modifier & Modifier.STATIC) == Modifier.STATIC) {
    System.out.println("Static");
}
if ((modifier & Modifier.FINAL) == Modifier.FINAL) {
    System.out.println("FINAL");
}
if ((modifier & Modifier.PUBLIC) == Modifier.PUBLIC) {
    System.out.println("PUBLIC");
}
if ((modifier & Modifier.PRIVATE) == Modifier.PRIVATE) {
    System.out.println("PRIVATE");
}

4.获取Class对象的所有构造函数

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
Class cz = Student.class;
//拿到所有公有构造方法
Constructor[] constructors = cz.getConstructors();
for (Constructor c : constructors) {
    System.out.println(c);
    Class[] pts = c.getParameterTypes();
    for (Class pt : pts) {
        System.out.println(pt);
    }
}
//拿到不管访问修饰符的构造方法
Constructor[] dconstructors = cz.getDeclaredConstructors();
for (Constructor c : dconstructors) {
    System.out.println(c);
}

5.用公有的构造函数创建对象

1
2
3
4
Class cz = Student.class;
Constructor constructor = cz.getConstructor();
Student student = (Student) constructor.newInstance();
System.out.println(student);

6.用公有的有参构造函数创建对象

1
2
3
4
Class cz = Student.class;
Constructor constructor = cz.getConstructor();
Student student = (Student) constructor.newInstance(1,"as");
System.out.println(student);

7.用私有的构造函数创建对象

1
2
3
4
5
Class cz = Teacher.class;
Constructor declaredConstructor = cz.getDeclaredConstructor();
declaredConstructor.setAccessible(true);
Teacher teacher = (Teacher) declaredConstructor.newInstance();
System.out.println(teacher);

8.用私有的有参构造函数创建对象

1
2
3
4
5
Class cz = Teacher.class;
Constructor declaredConstructor = cz.getDeclaredConstructor(int.class,String.class);
declaredConstructor.setAccessible(true);
Teacher teacher = (Teacher) declaredConstructor.newInstance(1,"as");
System.out.println(teacher);

9.获取Class所有的方法

1
2
3
4
5
6
Class cz = Teacher.class;
Method[] methods = cz.getDeclaredMethods();
for (Method m:methods){
    System.out.println(m);
    System.out.println(m.getName());
}

10.执行Class的方法

1
2
3
4
5
6
7
Class cz = Teacher.class;
Constructor declaredConstructor = cz.getDeclaredConstructor();
declaredConstructor.setAccessible(true);
Teacher teacher = (Teacher) declaredConstructor.newInstance();
Method method = cz.getDeclaredMethod("say");
method.setAccessible(true);
method.invoke(teacher);
Java注解
设计模式