说明：文章大部分来源于韩顺平老师的JAVA课程
2、一个需求引出反射
首先创建 Cat 类，并定义 hi 方法
package com.hspedu;
public class Cat {
private String name = "招财猫";
public int age = 10; //public的
public Cat() {} //无参构造器
public Cat(String name) {
this.name = name;
}
public void hi() { //常用方法
System.out.println("hi " + name);
}
}
创建 re.properties 文件
classfullpath=com.hspedu.Cat
method=hi
首先，尝试通过传统方式实现，根据配置文件re.properties中的指定信息，创建Cat对象并调用方法hi
先读取 re.properties 中的 classfullpath 和 method
//1. 使用Properties 类, 可以读写配置文件
Properties properties = new Properties();
properties.load(new FileInputStream("src\\re.properties"));
String classfullpath = properties.get("classfullpath").toString();//"com.hspedu.Cat"
String methodName = properties.get("method").toString();//"hi"
System.out.println("classfullpath=" + classfullpath);
System.out.println("method=" + methodName);
不可能通过 new classfullpath(); 实现，new 类名，而 classfullpath 不是类名，而是包名
//2. 创建对象 , 传统的方法，行不通 => 反射机制
//new classfullpath();
通过反射来解决上述问题：（后面会讲解其中细节）
package com.hspedu.reflection.question;
import com.hspedu.Cat;
import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.IOException;
import java.lang.reflect.Constructor;
import java.lang.reflect.Field;
import java.lang.reflect.InvocationTargetException;
import java.lang.reflect.Method;
import java.util.Properties;
/**
* @author 韩顺平
* @version 1.0
* 反射问题的引入
*/
@SuppressWarnings({"all"})
public class ReflectionQuestion {
public static void main(String[] args) throws IOException, ClassNotFoundException, IllegalAccessException, InstantiationException, NoSuchMethodException, InvocationTargetException, NoSuchFieldException {
//根据配置文件 re.properties 指定信息, 创建Cat对象并调用方法hi
//老韩回忆
//传统的方式 new 对象 -》 调用方法
// Cat cat = new Cat();
// cat.hi(); ===> cat.cry() 修改源码.
//我们尝试做一做 -> 明白反射
//1. 使用Properties 类, 可以读写配置文件
Properties properties = new Properties();
properties.load(new FileInputStream("src\\re.properties"));
String classfullpath = properties.get("classfullpath").toString();//"com.hspedu.Cat"
String methodName = properties.get("method").toString();//"hi"
System.out.println("classfullpath=" + classfullpath);
System.out.println("method=" + methodName);
//2. 创建对象 , 传统的方法，行不通 => 反射机制
//new classfullpath();
//3. 使用反射机制解决
//(1) 加载类, 返回Class类型的对象cls
Class cls = Class.forName(classfullpath);
//(2) 通过 cls 得到你加载的类 com.hspedu.Cat 的对象实例
Object o = cls.newInstance();
System.out.println("o的运行类型=" + o.getClass()); //运行类型
//(3) 通过 cls 得到你加载的类 com.hspedu.Cat 的 methodName"hi" 的方法对象
// 即：在反射中，可以把方法视为对象（万物皆对象）
Method method1 = cls.getMethod(methodName);
//(4) 通过method1 调用方法: 即通过方法对象来实现调用方法
System.out.println("=============================");
method1.invoke(o); //传统方法 对象.方法() , 反射机制 方法.invoke(对象)
}
}
上述我们使用 Method method1 = cls.getMethod(methodName); method1.invoke(o); 来执行的其中的 hi 方法，而实际上可以通过强制类型转换，直接 .hi() 调用 hi 方法：
Class cls = Class.forName(classfullpath);
Object o = cls.newInstance();
Cat cat = (Cat) o;
cat.hi();
但是这种方法无疑是愚蠢的，当 re.properties 文件中的 method 改为 cry 方法，那么，你就需要去改源代码，cat.cry(); 这是不可取的，而 Method method1 = cls.getMethod(methodName); method1.invoke(o); 是不需要更改源代码就可以直接运行读取新的方法
在 Cat 类中新增一个 cry 方法
package com.hspedu;
public class Cat {
private String name = "招财猫";
public int age = 10; //public的
public Cat() {} //无参构造器
public Cat(String name) {
this.name = name;
}
public void hi() { //常用方法
System.out.println("hi " + name);
}
public void cry() { //常用方法
System.out.println(name + " 喵喵叫..");
}
}
更改 re.properties 中的 method=cry，然后执行，成功，得到如下结果：并不需要去更改源码，只需要更改配置文件
3、反射机制
3.1 Java Reflection
- 反射机制允许程序在执行期间借助于Reflection API取得任何类的内部信息（比如：成员变量，构造器，成员方法等），并能操作对象的属性及方法。反射在设计模式和框架的底层都会用到
- 加载完类之后，在堆内存中就产生了一个Class类型的对象（一个类只有一个Class对象），这个对象包含了类的完整结构信息。通过这个对象得到类的结构。这个Class对象就像一面镜子，透过这个镜子看到类的结构，所以形象称之为：反射
3.2 反射机制原理图
3.2.1 类的生命周期
类在内存中完整的生命周期：加载 → \to → 使用 → \to → 卸载。其中加载过程又分为：装载、链接、初始化三个阶段。
1. 加载阶段（Loading）
装载、链接、初始化 这三个阶段，实际上与我之前提到的 加载、验证、准备、解析、初始化 过程是相对应的，只不过它们在不同的描述方式中有所差异。
★★★★★ (1) 装载（Loading）：下述部分在描述加载过程时，没有特别说明，实际上就是在描述装载这一过程
装载阶段是类加载的第一步，通常指的是从类的二进制文件（.class文件）中将类的字节码读取到内存中，并生成 Class 对象。在这个过程中，JVM会根据类加载器加载类，并将其放入方法区（JVM的内存区域之一）。 （将类的 class 文件读入内存，并为之创建一个java.lang.Class 对象。此过程由类加载器完成）
(2) 链接（Linking） = 验证、准备、解析
链接阶段是将类中的符号引用解析为实际内存地址的过程。链接可以进一步分为三个子过程：
- 验证（Verification）：确保类文件的字节码符合JVM规范，不会有不合法的代码，防止恶意代码执行。
- 准备（Preparation）：为类变量分配内存并设置默认值（如0、null等）。这个阶段主要是为静态字段和常量的分配内存，并进行初始化。
- 解析（Resolution）：将类中的符号引用（如类、方法、字段的引用）解析为实际的内存地址或指针。在这个过程中，JVM会把类中的符号引用转换成真实的内存地址，以便在运行时能够快速访问。
(3) 初始化（Initialization） = 初始化
初始化是类加载过程的最后阶段。此时，类的静态初始化块和静态变量的赋值语句将被执行。只有在类的第一次使用时，JVM才会执行这个阶段的内容。这也就是为什么静态初始化块和静态变量初始化只会在类首次加载时执行一次的原因。
(1) 加载或装载（Loading）过程的核心：类加载器（classloader)
类加载器的作用
将class文件字节码内容加载到内存中，并将这些静态数据转换成方法区的运行时数据结构，然后在堆中生成一个代表这个类的 java.lang.Class 对象，作为方法区中类数据的访问入口。
类缓存：标准的JavaSE类加载器可以按要求查找类，但一旦某个类被加载到类加载器中，它将维持加载（缓存）一段时间。不过JVM垃圾回收机制可以回收这些Class对象。
一个通过类加载器加载的类在 JVM 中只会有一个Class实例
通过上述内容大致了解了类加载器和 class 对象后，进一步了解 JAVA 程序运行的三个阶段：编译成字节码阶段(.class 文件) 、类加载阶段和运行阶段
编译阶段： 比如我们编写了一个cat类，它的属性、构造器、方法、这些 ，源代码就会通过 javac 被编译成字节码文件 cat.class
字节码文件里面有什么呢？
属性、构造器、成员变量、泛型、注解这些
加载阶段：new 一个对象的时候会触发类的加载，之后类加载器把字节码文件加载到堆中生成一个 Class 类对象 ，通过反射在底层会把成员变量、成员方法，构造器这些当成一种对象来对待：
- 类加载器会将字节码加载到内存，并生成一个 Class 类型的对象。这个 Class 对象表示一个类，并包含类的所有元数据（如字段、方法、构造器等）。在 Java 中，Class 对象本身也是一个类，所以它也可以通过反射操作。
Runtime运行阶段 ：new一个对象的时候会触发类的加载，类加载完就生成一个对象了，对象在堆里面，该对象知道它是属于哪个Class对象的，得到 Class 对象后，可以创建对象以及调用对象方法，操作它的属性等，如下：
3.2.2 什么是反射？
反射（Reflection）是指在程序运行时，能够动态地获取关于对象、类、方法等的信息，并对其进行操作的能力。换句话说，反射允许程序在运行时自我检查其结构（例如类名、方法、字段等），并在运行时根据这些信息做出决策或修改程序行为。
反射通常是通过获取由类加载器（ClassLoader）加载的Class对象来完成的。类加载器负责将类的字节码文件加载到JVM中，并生成相应的Class对象，反射机制正是基于这些Class对象来访问类的元数据（如方法、字段、构造函数等）并执行相关操作。（后面会详细讲解 class 对象的使用）
3.3 反射机制可以完成的功能
- 在运行时，判断任意一个对象所属的类
- 在运行时，创建任意一个类的对象
- 在运行时，得到任意一个类所具有的成员变量和方法
- 在运行时，调用任意一个对象的成员变量和方法
- 生成动态代理
3.4 反射相关的主要类
这些类在 java.lang.reflection 包下：
- java.lang.Class：代表一个类，Class对象表示某个类加载后在堆内存中的对象
- java.lang.reflect.Method：代表类的方法，Method对象表示某个类的方法
- java.lang.reflect.Field：代表类的成员变量，Field对象表示某个类的成员变量
- java.lang.reflect.Constructor：代表类的构造方法，Constructor对象表示构造器
测试 Field 和 Constructor
Cat 类
package com.hspedu;
public class Cat {
private String name = "招财猫";
public int age = 10; //public 的
public Cat() {} //无参构造器
public Cat(String name) {
this.name = name;
}
public void hi() { //常用方法
System.out.println("hi " + name);
}
}
注意 getField 不能得到私有的属性，因此 Cat 类中添加公有属性
public int age = 10; // public 的
先获取 Cat 类在类加载器加载过后的 class 对象
// 1. 获取 Cat 类的 Class 对象
Class<?> cls = Cat.class; // 也可以用 Class.forName("com.example.Cat") 来获取
获取成员变量的方式
- 传统写法：对象.成员变量；
- 反射：成员变量对象.get(对象)
//java.lang.reflect.Field: 代表类的成员变量, Field对象表示某个类的成员变量
// getField不能得到私有的属性
Field nameField = cls.getField("age");
Cat o = new Cat("Tom", 5); // 这里的 o 是 Cat 类的一个实例
// Object o = cls.newInstance();
System.out.println(nameField.get(o)); // 反射:成员变量对象.get(对象)
//java.lang.reflect.Constructor: 代表类的构造方法, Constructor对象表示构造器
Constructor constructor = cls.getConstructor(); //()中可以指定构造器参数类型, 不指定则返回无参构造器
System.out.println(constructor);//Cat()
Constructor constructor2 = cls.getConstructor(String.class); //这里传入的 String.class 就是 String 类的 Class 对象
System.out.println(constructor2); // Cat(String name)
cls.getConstructor(); //()中可以指定构造器参数类型, 不指定则返回无参构造器- o 是 Cat 类的一个实例对象。在这里，o 是通过 new Cat(“Tom”, 5) 创建的 Cat 类的一个对象。nameField.get(o) 会从 o 对象中提取 age 字段的值（5），并输出。
- o 是 Cat 类的一个实例，它提供了访问实例字段的上下文。在反射中，通过 Field.get(Object obj) 方法，可以动态地获取该实例对象 o 的字段值。
- 上述是通过 Cat o = new Cat(“Tom”, 5); 得到 Cat 的实例，是非常不正确的获取方式，应该通过 cls 得到加载的类 com.hspedu.Cat 的对象实例 Object o = cls.newInstance();
创建一个 Reflection01 类
有一个 re.properties 文件：
classfullpath = com.hspedu.Cat
method = hi
利用反射机制，通过读取 re.properties 文件执行实例的方法等
package com.hspedu.reflection;
import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.lang.reflect.Constructor;
import java.lang.reflect.Field;
import java.lang.reflect.Method;
import java.util.Properties;
public class Reflection01 {
public static void main(String[] args) throws Exception {
//1. 使用Properties 类, 可以读写配置文件
Properties properties = new Properties();
properties.load(new FileInputStream("src\\re.properties"));
String classfullpath = properties.get("classfullpath").toString();//"com.hspedu.Cat"
String methodName = properties.get("method").toString();//"hi"
//2. 使用反射机制解决
//(1) 加载类, 返回Class类型的对象cls
Class cls = Class.forName(classfullpath);
//(2) 通过 cls 得到你加载的类 com.hspedu.Cat 的对象实例
Object o = cls.newInstance();
System.out.println("o的运行类型=" + o.getClass()); //运行类型
//(3) 通过 cls 得到你加载的类 com.hspedu.Cat 的 methodName"hi" 的方法对象
// 即：在反射中，可以把方法视为对象（万物皆对象）
Method method1 = cls.getMethod(methodName);
//(4) 通过method1 调用方法: 即通过方法对象来实现调用方法
System.out.println("=============================");
method1.invoke(o); //传统方法 对象.方法() , 反射机制 方法.invoke(对象)
//java.lang.reflect.Field: 代表类的成员变量, Field对象表示某个类的成员变量
//getField不能得到私有的属性
Field nameField = cls.getField("age"); //
System.out.println(nameField.get(o)); // 传统写法：对象.成员变量；反射:成员变量对象.get(对象)
//java.lang.reflect.Constructor: 代表类的构造方法, Constructor对象表示构造器
Constructor constructor = cls.getConstructor(); //()中可以指定构造器参数类型, 返回无参构造器
System.out.println(constructor);//Cat()
Constructor constructor2 = cls.getConstructor(String.class); //这里传入的 String.class 就是 String 类的 Class 对象
System.out.println(constructor2); //Cat(String name)
}
}
3.5 反射优点和缺点
- 优点：可以动态的创建和使用对象（就是框架底层核心），使用灵活，没有反射机制，框架技术就失去底层支撑。
- 缺点：使用反射基本是解释执行，对执行速度有影响
通过调用 Cat 中的方法来测试执行的速度，先将 Cat 中的 hi 方法内打印注释掉，不需要真正打印任何东西
public void hi() { //常用方法
// System.out.println("hi " + name);
}
package com.hspedu.reflection;
import com.hspedu.Cat;
import java.io.FileInputStream;
import java.lang.reflect.Constructor;
import java.lang.reflect.Field;
import java.lang.reflect.InvocationTargetException;
import java.lang.reflect.Method;
public class Reflection02 {
public static void main(String[] args) throws ClassNotFoundException, NoSuchMethodException, InvocationTargetException, InstantiationException, IllegalAccessException {
//Field
//Method
//Constructor
m1();
m2();
}
//传统方法来调用hi
public static void m1() {
Cat cat = new Cat();
long start = System.currentTimeMillis();
for (int i = 0; i < 900000000; i++) {
cat.hi();
}
long end = System.currentTimeMillis();
System.out.println("m1() 耗时=" + (end - start));
}
//反射机制调用方法hi
public static void m2() throws ClassNotFoundException, IllegalAccessException, InstantiationException, NoSuchMethodException, InvocationTargetException {
Class cls = Class.forName("com.hspedu.Cat");
Object o = cls.newInstance();
Method hi = cls.getMethod("hi");
long start = System.currentTimeMillis();
for (int i = 0; i < 900000000; i++) {
hi.invoke(o);//反射调用方法
}
long end = System.currentTimeMillis();
System.out.println("m2() 耗时=" + (end - start));
}
}
执行传统方法基本不耗时，而反射方式 。。。
3.6 反射调用优化——关闭访问检查
- Method、Field、Constructor 对象都有 setAccessible() 方法
- setAccessible() 作用是启动和禁用访问安全检查开关
- 参数为 true 表示：反射的对象在使用时取消访问检查，提高反射的效率。参数为 false 表示：反射的对象执行访问检查
进入 Field 查看继承关系（java.lang.reflect.Field 包下），右键，选择 Diagrams
有一个 AccessibleObject 
再看一下 Method （java.lang.reflect.Method 包下）
再看一下 Constructor （java.lang.reflect.Constructor 包下）
.setAccessible(true) 后会有一点优化，但是不会太多
public static void m3() throws ClassNotFoundException, IllegalAccessException, InstantiationException, NoSuchMethodException, InvocationTargetException {
Class cls = Class.forName("com.hspedu.Cat");
Object o = cls.newInstance();
Method hi = cls.getMethod("hi");
hi.setAccessible(true);//在反射调用方法时，取消访问检查
long start = System.currentTimeMillis();
for (int i = 0; i < 900000000; i++) {
hi.invoke(o);//反射调用方法
}
long end = System.currentTimeMillis();
System.out.println("m3() 耗时=" + (end - start));
}
package com.hspedu.reflection;
import com.hspedu.Cat;
import java.io.FileInputStream;
import java.lang.reflect.Constructor;
import java.lang.reflect.Field;
import java.lang.reflect.InvocationTargetException;
import java.lang.reflect.Method;
public class Reflection02 {
public static void main(String[] args) throws ClassNotFoundException, NoSuchMethodException, InvocationTargetException, InstantiationException, IllegalAccessException {
// Field
// Method
// Constructor
m1();
m2();
m3();
}
//传统方法来调用hi
public static void m1() {
Cat cat = new Cat();
long start = System.currentTimeMillis();
for (int i = 0; i < 900000000; i++) {
cat.hi();
}
long end = System.currentTimeMillis();
System.out.println("m1() 耗时=" + (end - start));
}
//反射机制调用方法hi
public static void m2() throws ClassNotFoundException, IllegalAccessException, InstantiationException, NoSuchMethodException, InvocationTargetException {
Class cls = Class.forName("com.hspedu.Cat");
Object o = cls.newInstance();
Method hi = cls.getMethod("hi");
long start = System.currentTimeMillis();
for (int i = 0; i < 900000000; i++) {
hi.invoke(o);//反射调用方法
}
long end = System.currentTimeMillis();
System.out.println("m2() 耗时=" + (end - start));
}
//反射调用优化 + 关闭访问检查
public static void m3() throws ClassNotFoundException, IllegalAccessException, InstantiationException, NoSuchMethodException, InvocationTargetException {
Class cls = Class.forName("com.hspedu.Cat");
Object o = cls.newInstance();
Method hi = cls.getMethod("hi");
hi.setAccessible(true);//在反射调用方法时，取消访问检查
long start = System.currentTimeMillis();
for (int i = 0; i < 900000000; i++) {
hi.invoke(o);//反射调用方法
}
long end = System.currentTimeMillis();
System.out.println("m3() 耗时=" + (end - start));
}
}
4、Class 类
4.1 基本介绍
- Class也是类，因此也继承Object类
- Class类对象不是new出来的，而是系统创建的
- 对于某个类的Class类对象，在内存中只有一份，因为类只加载一次
- 每个类的实例都会记得自己是由哪个Class实例生成
- 通过Class对象可以完整地得到一个类的完整结构，通过一系列API
- Class对象存放在堆内存中
- 类的字节码二进制数据存放在方法区中，有的地方称为类的元数据（包括：方法，变量名，方法名，访问权限等）
先看下传统 new 实例的方式
package com.hspedu.reflection.class_;
import com.hspedu.Cat;
import java.util.ArrayList;
public class Class01 {
public static void main(String[] args) throws ClassNotFoundException {
//看看Class类图
//1. Class也是类，因此也继承Object类
//Class
//2. Class类对象不是new出来的，而是系统创建的
//(1) 传统 new 对象
/* ClassLoader 类
public Class<?>
loadClass(String name) throws ClassNotFoundException {
return loadClass(name, false);
}
*/
// Cat cat = new Cat();
// (2) 反射方式, 刚才没有 debug 到 ClassLoader 类的 loadClass, 原因是，我没有注销 Cat cat = new Cat();
/*
ClassLoader 类, 仍然是通过 ClassLoader 类加载 Cat 类的 Class 对象
public Class<?> loadClass(String name) throws ClassNotFoundException {
return loadClass(name, false);
}
*/
Class cls1 = Class.forName("com.hspedu.Cat");
}
}
Debug 上述代码
ClassLoader类, 仍然是通过 ClassLoader 类加载 Cat 类的 Class 对象。
对于某个类的Class类对象，在内存中只有一份，因为类只加载一次，下面我们测试一下：
package com.hspedu.reflection.class_;
import com.hspedu.Cat;
import java.util.ArrayList;
public class Class01 {
public static void main(String[] args) throws ClassNotFoundException {
//看看Class类图
//1. Class也是类，因此也继承Object类
//Class
//2. Class类对象不是new出来的，而是系统创建的
//(1) 传统new对象
/* ClassLoader类
public Class<?> loadClass(String name) throws ClassNotFoundException {
return loadClass(name, false);
}
*/
// Cat cat = new Cat();
//(2) 反射方式, 刚才没有debug到 ClassLoader类的 loadClass, 原因是，我没有注销 Cat cat = new Cat();
/*
ClassLoader类, 仍然是通过 ClassLoader 类加载 Cat 类的 Class 对象
public Class<?> loadClass(String name) throws ClassNotFoundException {
return loadClass(name, false);
}
*/
Class cls1 = Class.forName("com.hspedu.Cat");
//3. 对于某个类的Class类对象，在内存中只有一份，因为类只加载一次
Class cls2 = Class.forName("com.hspedu.Cat");
System.out.println(cls1.hashCode());
System.out.println(cls2.hashCode());
}
}
相同的！hashCode一样，说明这两个类是一样的，hashCode不一样，说明加载的类不一样
但是如果类是不同的则加载的类对象也是不同的
先创建一个 Dog 类
package com.hspedu;
public class Dog {
}
然后测试
package com.hspedu.reflection.class_;
import com.hspedu.Cat;
import java.util.ArrayList;
public class Class01 {
public static void main(String[] args) throws ClassNotFoundException {
//看看Class类图
//1. Class也是类，因此也继承Object类
//Class
//2. Class类对象不是new出来的，而是系统创建的
//(1) 传统new对象
/* ClassLoader类
public Class<?> loadClass(String name) throws ClassNotFoundException {
return loadClass(name, false);
}
*/
// Cat cat = new Cat();
//(2) 反射方式, 刚才没有debug到 ClassLoader类的 loadClass, 原因是，我没有注销 Cat cat = new Cat();
/*
ClassLoader类, 仍然是通过 ClassLoader 类加载 Cat 类的 Class 对象
public Class<?> loadClass(String name) throws ClassNotFoundException {
return loadClass(name, false);
}
*/
Class cls1 = Class.forName("com.hspedu.Cat");
//3. 对于某个类的Class类对象，在内存中只有一份，因为类只加载一次
Class cls2 = Class.forName("com.hspedu.Cat");
System.out.println(cls1.hashCode());
System.out.println(cls2.hashCode());
Class cls3 = Class.forName("com.hspedu.Dog");
System.out.println(cls3.hashCode());
}
}
我们添加一个Dog类进行测试，发现打印出来的hashCode不一样，说明堆内存中同样加载了一个Dog的Class类对象，且只加载一次
4.2 Class类的常用方法
| 方法名 | 功能说明 |
|---|---|
| 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 |
类的字节码二进制数据，是放在方法区的，有的地方称为类的元数据(包括方法代码,变量名，方法名，访问权限等等)
可以理解为类在加载的时候，会在堆中创建该类的Class类对象，同时在方法区生成字节码的二进制数据
Class 常用方法
创建 car 类
package com.hspedu;
public class Car {
public String brand = "宝马";//品牌
public int price = 500000;
public String color = "白色";
@Override
public String toString() {
return "Car{" +
"brand='" + brand + '\'' +
", price=" + price +
", color='" + color + '\'' +
'}';
}
}
创建 Class02 类进行测试
package com.hspedu.reflection.class_;
import com.hspedu.Car;
import java.lang.reflect.Field;
/**
* 演示Class类的常用方法
*/
public class Class02 {
public static void main(String[] args) throws ClassNotFoundException, IllegalAccessException, InstantiationException, NoSuchFieldException {
String classAllPath = "com.hspedu.Car";
//1 . 获取到Car类 对应的 Class对象
//<?> 表示不确定的Java类型
Class<?> cls = Class.forName(classAllPath);
//2. 输出cls
System.out.println(cls); //显示cls对象, 是哪个类的Class对象 com.hspedu.Car
System.out.println(cls.getClass());//输出cls运行类型 java.lang.Class
//3. 得到包名
System.out.println(cls.getPackage().getName());//包名
//4. 得到全类名
System.out.println(cls.getName());
//5. 通过cls创建对象实例
Car car = (Car) cls.newInstance();
System.out.println(car);//car.toString()
//6. 通过反射获取属性 brand
Field brand = cls.getField("brand");
System.out.println(brand.get(car));//宝马
//7. 通过反射给属性赋值
brand.set(car, "奔驰");
System.out.println(brand.get(car));//奔驰
//8 得到所有的属性(字段)
System.out.println("=======所有的字段属性====");
Field[] fields = cls.getFields();
for (Field f : fields) {
System.out.println(f.getName());//名称
}
}
}
5. 获取 Class 类对象的六种方式
下面这个图的意思是在哪个阶段可以使用哪种获得Class类对象的方法
- 比如在编译阶段可以使用Class.forName获得Class类对象
- 在类加载阶段可以通过类.class获得Class类对象
- 在Runtime运行阶段可以通过对象.getClass()的方式获得Class类对象（因为这个时候已经有对象实例了）
- 也可以通过获得类加载器来获取Class类对象
package com.hspedu.reflection.class_;
import com.hspedu.Car;
/**
* @author 韩顺平
* @version 1.0
* 演示得到Class对象的各种方式(6)
*/
public class GetClass_ {
public static void main(String[] args) throws ClassNotFoundException {
//1. Class.forName
String classAllPath = "com.hspedu.Car"; //通过读取配置文件获取
Class<?> cls1 = Class.forName(classAllPath);
System.out.println(cls1);
//2. 类名.class （类加载阶段）, 应用场景: 用于参数传递
Class cls2 = Car.class;
System.out.println(cls2);
//3. 对象.getClass()（运行时阶段）, 应用场景，有对象实例
Car car = new Car();
Class cls3 = car.getClass();
System.out.println(cls3);
//4. 通过类加载器【4种】来获取到类的Class对象
//(1)先得到类加载器 car
ClassLoader classLoader = car.getClass().getClassLoader();
//(2)通过类加载器得到Class对象
Class cls4 = classLoader.loadClass(classAllPath);
System.out.println(cls4);
//cls1 , cls2 , cls3 , cls4 其实是同一个对象
System.out.println(cls1.hashCode());
System.out.println(cls2.hashCode());
System.out.println(cls3.hashCode());
System.out.println(cls4.hashCode());
//5. 基本数据(int, char,boolean,float,double,byte,long,short) 按如下方式得到Class类对象
Class<Integer> integerClass = int.class;
Class<Character> characterClass = char.class;
Class<Boolean> booleanClass = boolean.class;
System.out.println(integerClass);//int
//6. 基本数据类型对应的包装类，可以通过 .TYPE 得到Class类对象
Class<Integer> type1 = Integer.TYPE;
Class<Character> type2 = Character.TYPE; //其它包装类BOOLEAN, DOUBLE, LONG,BYTE等待
System.out.println(type1);
// int.class 与 Integer.TYPE 得到的是同一个 Class 对象
System.out.println(integerClass.hashCode());//?
System.out.println(type1.hashCode());//?
}
}
6、哪些类型有Class对象
package com.hspedu.reflection.class_;
import java.io.Serializable;
public class AllTypeClass {
public static void main(String[] args) {
Class<String> cls1 = String.class;//外部类
Class<Serializable> cls2 = Serializable.class;//接口
Class<Integer[]> cls3 = Integer[].class;//数组
Class<float[][]> cls4 = float[][].class;//二维数组
Class<Deprecated> cls5 = Deprecated.class;//注解
//枚举
Class<Thread.State> cls6 = Thread.State.class;
Class<Long> cls7 = long.class;//基本数据类型
Class<Void> cls8 = void.class;//void数据类型
Class<Class> cls9 = Class.class;//
System.out.println(cls1);
System.out.println(cls2);
System.out.println(cls3);
System.out.println(cls4);
System.out.println(cls5);
System.out.println(cls6);
System.out.println(cls7);
System.out.println(cls8);
System.out.println(cls9);
}
}
[[F 表示数组
7、类加载
7.1 基本说明
反射机制是Java实现动态语言的关键，也就是通过反射实现类的动态加载。
- 静态加载：编译时加载相关的类，如果没有则报错，依赖性太强
比如下面代码：首先我们不定义 Dog 类，而是当 key 为 1 的时候，再使用。但是运行会报错，不存在 Dog 类，如果我们输入 2 或 不输出，都不会走 Dog 类里面，但是还是报错了，说明再编译时就加载了类，这种就是静态加载
- 动态加载：运行时加载需要的类，如果运行时不用该类，即使不存在该类，也不报错，降低了依赖性
如果将上述代码中 case 1 部分注释掉，并在 case 2 中使用反射进行动态加载 Person 类（Person 类并不存在），此时编译就可以通过，不会报错。如下，只能当我们输入 2，走 case 2 时会动态加载 Person 类，此时才会报错
总结：
- 因为 new Dog() 是静态加载，因为必须编写 Dog 类
- Person 类是动态加载，所以，没有编写 Person 类也不会报错，只有当要执行反射代码动态加载该类时，才会报错
7.2 类加载时机
- 当创建对象时（new）——静态加载
- 当子类被加载时，父类也加载——静态加载
- 调用类中的静态成员时——静态加载
- 通过反射——动态加载
7.3 类加载过程图
验证阶段主要是验证格式，源数据，字节码，符号等是否正确。 准备阶段主要是分配内存；解析阶段主要是虚拟机将常量池中的符号引用替换直接为引用。
后面会进行初始化阶段，此时才会真正的去执行 java 代码
字节码文件会以二进制数据的形式放入到内存中的方法区
7.4 类加载三个阶段完成任务
解析过程会将符号引用解析为直接引用
7.4.1 加载阶段
7.4.2 连接阶段——验证
fost 断点会进入如下，有一个 SecurityManager，会进行各种验证
7.4.3 连接阶段——准备
package com.hspedu.reflection.classload_;
/**
说明一个类加载的链接阶段-准备
*/
public class ClassLoad02 {
public static void main(String[] args) {
}
}
class A {
//属性-成员变量-字段
//老韩分析类加载的链接阶段-准备 属性是如何处理
//1. n1 是实例属性, 不是静态变量，因此在准备阶段，是不会分配内存
//2. n2 是静态变量，分配内存 n2 是默认初始化 0 ,而不是20
//3. n3 是static final 是常量, 他和静态变量不一样, 因为一旦赋值就不变 n3 = 30
public int n1 = 10;
public static int n2 = 20;
public static final int n3 = 30;
}
7.4.4 连接阶段——解析
虚拟机将常量池内的符号引用替换为直接引用的过程。
7.4.5 Initialization（初始化）
先执行如下代码：
package com.hspedu.reflection.classload_;
/**
* @author 韩顺平
* @version 1.0
* 演示类加载-初始化阶段
*/
public class ClassLoad03 {
public static void main(String[] args) throws ClassNotFoundException {
//1. 加载B类，并生成 B的class对象
//2. 链接：num = 0（静态变量已经加载进来）
//3. 初始化阶段
// 依次自动收集类中的所有静态变量的赋值动作和静态代码块中的语句,并合并
/* 注意时按照顺序收集
clinit() {
System.out.println("B 静态代码块被执行");
//num = 300;
num = 100;
}
合并: num = 100
*/
//new B();//类加载
System.out.println(B.num);//100, 如果直接使用类的静态属性，也会导致类的加载
//看看加载类的时候，是有同步机制控制
/*
protected Class<?> loadClass(String name, boolean resolve)
throws ClassNotFoundException
{
//正因为有这个机制，才能保证某个类在内存中, 只有一份Class对象
synchronized (getClassLoadingLock(name)) {
//....
}
}
*/
B b = new B();
}
}
class B {
static {
System.out.println("B 静态代码块被执行");
num = 300;
}
static int num = 100;
public B() {//构造器
System.out.println("B() 构造器被执行");
}
}
走 1， 2， 3 的流程，所以打印 B.num 为 100（这个时候没有执行构造器方法，要 new 对象才会执行构造器方法）
package com.hspedu.reflection.classload_;
/**
* @author 韩顺平
* @version 1.0
* 演示类加载-初始化阶段
*/
public class ClassLoad03 {
public static void main(String[] args) throws ClassNotFoundException {
//1. 加载B类，并生成 B的class对象
//2. 链接：num = 0（静态变量已经加载进来）
//3. 初始化阶段
// 依次自动收集类中的所有静态变量的赋值动作和静态代码块中的语句,并合并
/* 注意时按照顺序收集
clinit() {
System.out.println("B 静态代码块被执行");
//num = 300;
num = 100;
}
合并: num = 100
*/
new B();//类加载
System.out.println(B.num);//100, 如果直接使用类的静态属性，也会导致类的加载
//看看加载类的时候，是有同步机制控制
/*
protected Class<?> loadClass(String name, boolean resolve)
throws ClassNotFoundException
{
//正因为有这个机制，才能保证某个类在内存中, 只有一份Class对象
synchronized (getClassLoadingLock(name)) {
//....
}
}
*/
// B b = new B();
}
}
class B {
static {
System.out.println("B 静态代码块被执行");
num = 300;
}
static int num = 100;
public B() {//构造器
System.out.println("B() 构造器被执行");
}
}
8、通过反射获取类的结构信息
8.1 java.lang.Class类
4.2.1 相关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()
package com.hspedu.reflection;
import org.junit.jupiter.api.Test;
import java.lang.annotation.Annotation;
import java.lang.reflect.Constructor;
import java.lang.reflect.Field;
import java.lang.reflect.Method;
/**
* 演示如何通过反射获取类的结构信息
*/
public class ReflectionUtils {
public static void main(String[] args) {
}
//第一组方法API
@Test
public void api_01() throws ClassNotFoundException, NoSuchMethodException {
//得到Class对象
Class<?> personCls = Class.forName("com.hspedu.reflection.Person");
//getName:获取全类名
System.out.println(personCls.getName());//com.hspedu.reflection.Person
//getSimpleName:获取简单类名
System.out.println(personCls.getSimpleName());//Person
//getFields:获取所有public修饰的属性，包含本类以及父类的 （不包括私有属性）
Field[] fields = personCls.getFields();
for (Field field : fields) {//增强for
System.out.println("本类以及父类的属性=" + field.getName());
}
//getDeclaredFields:获取本类中所有属性（包括私有属性）
Field[] declaredFields = personCls.getDeclaredFields();
for (Field declaredField : declaredFields) {
System.out.println("本类中所有属性=" + declaredField.getName());
}
//getMethods:获取所有public修饰的方法，包含本类以及父类的
Method[] methods = personCls.getMethods();
for (Method method : methods) {
System.out.println("本类以及父类的方法=" + method.getName());
}
//getDeclaredMethods:获取本类中所有方法
Method[] declaredMethods = personCls.getDeclaredMethods();
for (Method declaredMethod : declaredMethods) {
System.out.println("本类中所有方法=" + declaredMethod.getName());
}
//getConstructors: 获取所有public修饰的构造器，包含本类
Constructor<?>[] constructors = personCls.getConstructors();
for (Constructor<?> constructor : constructors) {
System.out.println("本类的构造器=" + constructor.getName());
}
//getDeclaredConstructors:获取本类中所有构造器
Constructor<?>[] declaredConstructors = personCls.getDeclaredConstructors();
for (Constructor<?> declaredConstructor : declaredConstructors) {
System.out.println("本类中所有构造器=" + declaredConstructor.getName());//这里老师只是输出名
}
//getPackage:以Package形式返回 包信息
System.out.println(personCls.getPackage());//com.hspedu.reflection
//getSuperClass:以Class形式返回父类信息
Class<?> superclass = personCls.getSuperclass();
System.out.println("父类的class对象=" + superclass);//
//getInterfaces:以Class[]形式返回接口信息
Class<?>[] interfaces = personCls.getInterfaces();
for (Class<?> anInterface : interfaces) {
System.out.println("接口信息=" + anInterface);
}
//getAnnotations:以Annotation[] 形式返回注解信息
Annotation[] annotations = personCls.getAnnotations();
for (Annotation annotation : annotations) {
System.out.println("注解信息=" + annotation);//注解
}
}
}
class A {
public String hobby;
public void hi() {
}
public A() {
}
public A(String name) {
}
}
interface IA {
}
interface IB {
}
@Deprecated
class Person extends A implements IA, IB {
//属性
public String name;
protected static int age; // 4 + 8 = 12
String job;
private double sal;
//构造器
public Person() {
}
public Person(String name) {
}
//私有的
private Person(String name, int age) {
}
//方法
public void m1(String name, int age, double sal) {
}
protected String m2() {
return null;
}
void m3() {
}
private void m4() {
}
}
8.2 java.lang.reflect.Field类
@Test
public void api_02() throws ClassNotFoundException, NoSuchMethodException {
//得到Class对象
Class<?> personCls = Class.forName("com.hspedu.reflection.Person");
//getDeclaredFields:获取本类中所有属性
//规定 说明: 默认修饰符 是0 ， public 是1 ，private 是 2 ，protected 是 4 , static 是 8 ，final 是 16
Field[] declaredFields = personCls.getDeclaredFields();
for (Field declaredField : declaredFields) {
System.out.println("本类中所有属性=" + declaredField.getName()
+ " 该属性的修饰符值=" + declaredField.getModifiers()
+ " 该属性的类型=" + declaredField.getType());
}
}
8.3 java.lang.reflect.Method类
@Test
public void api_02() throws ClassNotFoundException, NoSuchMethodException {
//得到Class对象
Class<?> personCls = Class.forName("com.hspedu.reflection.Person");
//getDeclaredMethods:获取本类中所有方法
Method[] declaredMethods = personCls.getDeclaredMethods();
for (Method declaredMethod : declaredMethods) {
System.out.println("本类中所有方法=" + declaredMethod.getName()
+ " 该方法的访问修饰符值=" + declaredMethod.getModifiers()
+ " 该方法返回类型" + declaredMethod.getReturnType());
//输出当前这个方法的形参数组情况
Class<?>[] parameterTypes = declaredMethod.getParameterTypes();
for (Class<?> parameterType : parameterTypes) {
System.out.println("该方法的形参类型=" + parameterType);
}
}
}
8.4 java.lang.reflect.Constructor类
@Test
public void api_02() throws ClassNotFoundException, NoSuchMethodException {
//得到Class对象
Class<?> personCls = Class.forName("com.hspedu.reflection.Person");
//getDeclaredConstructors:获取本类中所有构造器
Constructor<?>[] declaredConstructors = personCls.getDeclaredConstructors();
for (Constructor<?> declaredConstructor : declaredConstructors) {
System.out.println("====================");
System.out.println("本类中所有构造器=" + declaredConstructor.getName());//这里老师只是输出名
Class<?>[] parameterTypes = declaredConstructor.getParameterTypes();
for (Class<?> parameterType : parameterTypes) {
System.out.println("该构造器的形参类型=" + parameterType);
}
}
}
9、通过反射创建对象
测试 1： 通过反射创建某类的对象，要求该类中必须有 public 的无参构造
测试 2： 通过调用某个特定构造器的方式，实现创建某类的对象
package com.hspedu.reflection;
import java.lang.reflect.Constructor;
import java.lang.reflect.InvocationTargetException;
/**
* @author 韩顺平
* @version 1.0
* 演示通过反射机制创建实例
*/
public class ReflecCreateInstance {
public static void main(String[] args) throws ClassNotFoundException, IllegalAccessException, InstantiationException, NoSuchMethodException, InvocationTargetException {
//1. 先获取到User类的Class对象
Class<?> userClass = Class.forName("com.hspedu.reflection.User");
//2. 通过public的无参构造器创建实例
Object o = userClass.newInstance();
System.out.println(o);
//3. 通过public的有参构造器创建实例
/*
constructor 对象就是
public User(String name) {//public的有参构造器
this.name = name;
}
*/
//3.1 先得到对应构造器
Constructor<?> constructor = userClass.getConstructor(String.class);
//3.2 创建实例，并传入实参
Object hsp = constructor.newInstance("hsp");
System.out.println("hsp=" + hsp);
//4. 通过非public的有参构造器创建实例
//4.1 得到private的构造器对象
Constructor<?> constructor1 = userClass.getDeclaredConstructor(int.class, String.class);
//4.2 创建实例
//暴破【暴力破解】 , 使用反射可以访问private构造器/方法/属性, 反射面前，都是纸老虎
constructor1.setAccessible(true);
Object user2 = constructor1.newInstance(100, "张三丰");
System.out.println("user2=" + user2);
}
}
class User { //User类
private int age = 10;
private String name = "青年有志";
public User() {//无参 public
}
public User(String name) {//public的有参构造器
this.name = name;
}
private User(int age, String name) {//private 有参构造器
this.age = age;
this.name = name;
}
public String toString() {
return "User [age=" + age + ", name=" + name + "]";
}
}
10、通过反射访问类中的成员
10.1 访问属性
package com.hspedu.reflection;
import java.lang.reflect.Field;
/**
* 演示反射操作属性
*/
public class ReflecAccessProperty {
public static void main(String[] args) throws ClassNotFoundException, IllegalAccessException, InstantiationException, NoSuchFieldException {
//1. 得到Student类对应的 Class对象
Class<?> stuClass = Class.forName("com.hspedu.reflection.Student");
//2. 创建对象
Object o = stuClass.newInstance();//o 的运行类型就是Student
System.out.println(o.getClass());//Student
//3. 使用反射得到age 属性对象
Field age = stuClass.getField("age");
age.set(o, 88);//通过反射来操作属性
System.out.println(o);//
System.out.println(age.get(o));//返回age属性的值
//4. 使用反射操作name 属性
Field name = stuClass.getDeclaredField("name");
//对name 进行暴破, 可以操作private 属性
name.setAccessible(true);
//name.set(o, "老韩");
name.set(null, "青年有志~");//因为name是static属性，因此 o 也可以写出null
System.out.println(o);
System.out.println(name.get(o)); //获取属性值
System.out.println(name.get(null));//获取属性值, 要求name是static
}
}
class Student {//类
public int age;
private static String name;
public Student() {//构造器
}
public String toString() {
return "Student [age=" + age + ", name=" + name + "]";
}
}
10.2 访问方法
package com.hspedu.reflection;
import java.lang.reflect.InvocationTargetException;
import java.lang.reflect.Method;
/**
* 演示通过反射调用方法
*/
public class ReflecAccessMethod {
public static void main(String[] args) throws ClassNotFoundException, NoSuchMethodException, IllegalAccessException, InstantiationException, InvocationTargetException {
//1. 得到Boss类对应的Class对象
Class<?> bossCls = Class.forName("com.hspedu.reflection.Boss");
//2. 创建对象
Object o = bossCls.newInstance();
//3. 调用public的hi方法
//Method hi = bossCls.getMethod("hi", String.class);//OK
//3.1 得到hi方法对象
Method hi = bossCls.getDeclaredMethod("hi", String.class);//OK
//3.2 调用
hi.invoke(o, "青年有志~");
//4. 调用private static 方法
//4.1 得到 say 方法对象
Method say = bossCls.getDeclaredMethod("say", int.class, String.class, char.class);
//4.2 因为say方法是private, 所以需要暴破，原理和前面讲的构造器和属性一样
say.setAccessible(true);
System.out.println(say.invoke(o, 100, "张三", '男'));
//4.3 因为say方法是static的，还可以这样调用 ，可以传入null
System.out.println(say.invoke(null, 200, "李四", '女'));
//5. 在反射中，如果方法有返回值，统一返回Object , 但是他运行类型和方法定义的返回类型一致
Object reVal = say.invoke(null, 300, "王五", '男');
System.out.println("reVal 的运行类型=" + reVal.getClass());//String
//在演示一个返回的案例
Method m1 = bossCls.getDeclaredMethod("m1");
Object reVal2 = m1.invoke(o);
System.out.println("reVal2的运行类型=" + reVal2.getClass());//Monster
}
}
class Monster {}
class Boss {//类
public int age;
private static String name;
public Boss() {//构造器
}
public Monster m1() {
return new Monster();
}
private static String say(int n, String s, char c) {//静态方法
return n + " " + s + " " + c;
}
public void hi(String s) {//普通public方法
System.out.println("hi " + s);
}
}
11. 应用4：读取注解信息
一个完整的注解应该包含三个部分：
（1）声明
（2）使用
（3）读取
11.1 基本方式
Java 反射机制是 Java 提供的一种强大功能，允许程序在运行时动态地访问、检测和修改类、方法、字段等信息。通过反射机制，我们可以访问和读取类的注解（Annotation）信息，进而实现一些动态化的功能，比如框架的设计（如 Spring、Hibernate）等。
1. 注解简介
注解（Annotation）是 Java 中的一种特殊类型，用于提供类、方法、字段、参数等的元数据。注解本身不会改变程序的行为，但它们可以在编译时或运行时通过工具（如反射）来读取，并影响程序的处理逻辑。常见的注解如 @Override、@Deprecated、@Entity 等。
2. 如何定义注解
注解是一个接口，用 @interface 关键字来定义。例如，定义一个简单的注解：
public @interface MyAnnotation {
String value() default "default value";
int count() default 0;
}
这个注解 MyAnnotation 有两个元素：value 和 count，并且为它们提供了默认值。
3. 使用注解
定义了注解之后，我们可以在类、方法或字段等地方使用它：
@MyAnnotation(value = "Hello", count = 5)
public class MyClass {
// 类定义
}
4. 通过反射读取注解
反射可以用来在运行时读取注解信息。以下是通过反射获取注解的步骤：
4.1 获取 Class 对象
首先，我们需要获取类的 Class 对象，它是反射操作的基础：
Class<?> clazz = MyClass.class; // 获取 MyClass 的 Class 对象
4.2 检查注解是否存在
可以使用 isAnnotationPresent() 方法检查该类是否有特定的注解：
if (clazz.isAnnotationPresent(MyAnnotation.class)) {
// 说明 MyClass 上有 MyAnnotation 注解
}
4.3 获取注解信息
如果注解存在，可以使用 getAnnotation() 方法获取注解的实例：
MyAnnotation annotation = clazz.getAnnotation(MyAnnotation.class);
一旦获得注解实例，我们就可以通过反射访问它的元素：
String value = annotation.value();
int count = annotation.count();
System.out.println("value: " + value + ", count: " + count);
5. 通过反射读取方法上的注解
不仅可以读取类上的注解，方法上的注解也可以通过反射来获取。假设我们有以下方法：
public class MyClass {
@MyAnnotation(value = "Method Annotation", count = 10)
public void myMethod() {
// 方法实现
}
}
获取方法上的注解：
Method method = clazz.getMethod("myMethod"); // 获取方法对象
if (method.isAnnotationPresent(MyAnnotation.class)) {
MyAnnotation methodAnnotation = method.getAnnotation(MyAnnotation.class);
System.out.println("Method Annotation - value: " + methodAnnotation.value());
}
6. 通过反射读取字段上的注解
字段上的注解也可以通过类似的方式获取。假设有以下类定义：
public class MyClass {
@MyAnnotation(value = "Field Annotation", count = 20)
private String field;
}
获取字段上的注解：
Field field = clazz.getDeclaredField("field"); // 获取字段对象
if (field.isAnnotationPresent(MyAnnotation.class)) {
MyAnnotation fieldAnnotation = field.getAnnotation(MyAnnotation.class);
System.out.println("Field Annotation - value: " + fieldAnnotation.value());
}
7. 注意事项
-
运行时保留注解：注解可以通过
@Retention注解指定保留策略。只有当注解的保留策略是RetentionPolicy.RUNTIME时，我们才能在运行时通过反射读取注解信息。示例如下：@Retention(RetentionPolicy.RUNTIME) @interface MyAnnotation { String value(); } -
访问修饰符：如果需要访问私有字段或方法上的注解，可以使用
setAccessible(true)来绕过 Java 的访问控制检查。例如，访问私有字段：field.setAccessible(true);
8. 总结
Java 反射机制提供了一种强大的方式来在运行时读取注解信息。通过使用反射，我们可以动态地检查和处理类、方法、字段等的注解信息，这为构建灵活、可扩展的框架和工具提供了基础。在实际应用中，反射机制常常用于依赖注入、AOP（面向切面编程）等高级编程范式中。
11.2 底层实现分析
Java 的反射机制是通过 java.lang.reflect 包来实现的，注解的读取和处理是其功能之一。要深入了解读取注解的底层源码实现，首先要了解注解的元数据存储方式、如何通过反射 API 访问这些数据，并分析 Java 如何实现对注解的支持。
1. 注解的元数据存储
Java 中的注解信息实际上是作为 元数据 存储在编译后的 .class 文件中。编译器会将类、方法、字段等的注解信息嵌入到字节码文件中。
RetentionPolicy
注解在 Java 中有三种不同的保留策略：
- SOURCE：注解仅在源码中存在，编译时会被丢弃。
- CLASS：注解在编译后的
.class文件中存在，但在运行时不会被加载。 - RUNTIME：注解在
.class文件中存在，并且会被 JVM 加载，在运行时可以通过反射获取。
只有当注解的 @Retention 策略是 RetentionPolicy.RUNTIME 时，才能在运行时通过反射机制访问注解信息。
2. 通过反射读取注解的实现
Java 反射读取注解的底层实现主要依赖于以下几个类和接口：
java.lang.Class：表示类的信息，并提供了获取类注解的方法。java.lang.reflect.Method：表示方法的信息，并提供了获取方法注解的方法。java.lang.reflect.Field：表示字段的信息，并提供了获取字段注解的方法。java.lang.annotation.Annotation：所有注解的父接口，包含了一些通用的 API，例如annotationType()，返回注解的类型。
我们可以通过 Class, Method, 或 Field 对象来获取注解信息，底层的实现会利用这些类提供的机制来查找和返回注解信息。
3. 底层实现分析
3.1 Class.getAnnotation(Class<T> annotationClass) 方法
该方法用于读取类上的注解。我们来看它的底层实现：
public <T extends Annotation> T getAnnotation(Class<T> annotationClass) {
if (annotationClass == null) {
throw new NullPointerException();
}
if (!annotationClass.isInterface()) {
throw new IllegalArgumentException("Annotation type " + annotationClass.getName() + " not an interface");
}
// This ensures that we can fetch annotations even when they are inherited
Annotation[] anns = getDeclaredAnnotations();
for (Annotation ann : anns) {
if (annotationClass.isInstance(ann)) {
return annotationClass.cast(ann);
}
}
return null;
}
getDeclaredAnnotations()：该方法返回所有直接声明的注解（包括本类上的注解）。注意，这个方法并不考虑父类或者接口上的注解。annotationClass.isInstance(ann)：检查返回的注解是否是期望的类型。
实际上，这个过程通过查找类的所有声明的注解，并逐一匹配给定的 annotationClass，如果找到了对应类型的注解，就返回该注解的实例。
3.2 Method.getAnnotation(Class<T> annotationClass) 方法
类似地，Method.getAnnotation() 用于获取方法上的注解，其实现逻辑也与 Class.getAnnotation() 类似。它会通过调用 getDeclaredAnnotations() 获取所有方法声明上的注解，并逐一匹配。
public <T extends Annotation> T getAnnotation(Class<T> annotationClass) {
if (annotationClass == null) {
throw new NullPointerException();
}
if (!annotationClass.isInterface()) {
throw new IllegalArgumentException("Annotation type " + annotationClass.getName() + " not an interface");
}
Annotation[] anns = getDeclaredAnnotations();
for (Annotation ann : anns) {
if (annotationClass.isInstance(ann)) {
return annotationClass.cast(ann);
}
}
return null;
}
3.3 Field.getAnnotation(Class<T> annotationClass) 方法
与 Method 和 Class 类似，Field.getAnnotation() 也会获取字段上的注解。其实现过程同样是通过 getDeclaredAnnotations() 获取字段声明的注解并与目标注解类型匹配。
public <T extends Annotation> T getAnnotation(Class<T> annotationClass) {
if (annotationClass == null) {
throw new NullPointerException();
}
if (!annotationClass.isInterface()) {
throw new IllegalArgumentException("Annotation type " + annotationClass.getName() + " not an interface");
}
Annotation[] anns = getDeclaredAnnotations();
for (Annotation ann : anns) {
if (annotationClass.isInstance(ann)) {
return annotationClass.cast(ann);
}
}
return null;
}
3.4 getDeclaredAnnotations() 的实现
getDeclaredAnnotations() 方法返回一个 Annotation[] 数组，它是所有声明的注解（包括 @Inherited 注解的注解和非 @Inherited 注解）。这会涉及到调用 JVM 提供的内部接口来访问 .class 文件中存储的注解信息。
在 JDK 的实现中，getDeclaredAnnotations() 方法可能会使用 sun.misc 或 sun.reflect 包中的方法，直接访问类文件的字节码元数据。这些方法通过 JNI (Java Native Interface) 来与底层的 JVM 交互，从而能够直接读取 .class 文件中的注解元数据。
Annotation[] getDeclaredAnnotations() {
// 调用底层 JNI 或特定的 JVM 实现来读取注解信息
return getAnnotationData();
}
4. JVM 中的注解存储
JVM 在运行时会将注解信息以一定的结构存储在内存中，这些数据通常是由 sun.reflect 等包中的本地方法（JNI）进行管理和读取的。对于 RetentionPolicy.RUNTIME 的注解，JVM 会在类加载时将注解信息加载到内存中，存储在 Class 对象中，并通过反射提供对这些信息的访问。
5. 性能优化
反射获取注解时，JVM 会进行一定的优化：
- 缓存注解信息：为了提高性能，JVM 通常会缓存注解信息（在
Class对象中缓存）。第一次读取时，JVM 会从.class文件中读取注解信息，后续访问会直接从内存中获取，避免多次读取文件。 - 注解代理：JVM 使用代理模式为每个注解类型创建一个代理对象，这些代理对象实现了注解类型的接口，允许通过该代理对象来访问注解的属性。
6. 总结
Java 反射读取注解的底层实现通过 java.lang.Class, java.lang.reflect.Method, java.lang.reflect.Field 等类来访问注解信息。注解信息会被存储在 .class 文件中，并由 JVM 在类加载时将 RetentionPolicy.RUNTIME 的注解加载到内存。通过反射访问时，JVM 会检查缓存并提供注解的具体实例。
5.1 声明自定义注解
package com.atguigu.annotation;
import java.lang.annotation.*;
@Inherited
@Target(ElementType.TYPE)
@Retention(RetentionPolicy.RUNTIME)
public @interface Table {
String value();
}
package com.atguigu.annotation;
import java.lang.annotation.*;
@Inherited
@Target(ElementType.FIELD)
@Retention(RetentionPolicy.RUNTIME)
public @interface Column {
String columnName();
String columnType();
}
- 自定义注解可以通过四个元注解@Retention,@Target，@Inherited,@Documented，分别说明它的声明周期，使用位置，是否被继承，是否被生成到API文档中。
- Annotation 的成员在 Annotation 定义中以无参数有返回值的抽象方法的形式来声明，我们又称为配置参数。返回值类型只能是八种基本数据类型、String类型、Class类型、enum类型、Annotation类型、以上所有类型的数组
- 可以使用 default 关键字为抽象方法指定默认返回值
- 如果定义的注解含有抽象方法，那么使用时必须指定返回值，除非它有默认值。格式是“方法名 = 返回值”，如果只有一个抽象方法需要赋值，且方法名为value，可以省略“value=”，所以如果注解只有一个抽象方法成员，建议使用方法名value。
5.2 使用自定义注解
package com.atguigu.annotation;
@Table("t_stu")
public class Student {
@Column(columnName = "sid",columnType = "int")
private int id;
@Column(columnName = "sname",columnType = "varchar(20)")
private String name;
public int getId() {
return id;
}
public void setId(int id) {
this.id = id;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
@Override
public String toString() {
return "Student{" +
"id=" + id +
", name='" + name + '\'' +
'}';
}
}
5.3 读取和处理自定义注解
自定义注解必须配上注解的信息处理流程才有意义。
我们自己定义的注解，只能使用反射的代码读取。所以自定义注解的声明周期必须是RetentionPolicy.RUNTIME。
package com.atguigu.annotation;
import java.lang.reflect.Field;
public class TestAnnotation {
public static void main(String[] args) {
Class studentClass = Student.class;
Table tableAnnotation = (Table) studentClass.getAnnotation(Table.class);
String tableName = "";
if(tableAnnotation != null){
tableName = tableAnnotation.value();
}
Field[] declaredFields = studentClass.getDeclaredFields();
String[] columns = new String[declaredFields.length];
int index = 0;
for (Field declaredField : declaredFields) {
Column column = declaredField.getAnnotation(Column.class);
if(column!= null) {
columns[index++] = column.columnName();
}
}
String sql = "select ";
for (int i=0; i<index; i++) {
sql += columns[i];
if(i<index-1){
sql += ",";
}
}
sql += " from " + tableName;
System.out.println("sql = " + sql);
}
}
12. 体会反射的动态性
体会1：
public class ReflectionTest {
//体会反射的动态性：动态的创建给定字符串对应的类的对象
public <T> T getInstance(String className) throws Exception {
Class clazz = Class.forName(className);
Constructor constructor = clazz.getDeclaredConstructor();
constructor.setAccessible(true);
return (T) constructor.newInstance();
}
@Test
public void test1() throws Exception {
String className = "com.atguigu.java1.Person";
Person p1 = getInstance(className);
System.out.println(p1);
}
}
体会2：
public class ReflectionTest {
//体会反射的动态性：动态的创建指定字符串对应类的对象，并调用指定的方法
public Object invoke(String className,String methodName) throws Exception {
Class clazz = Class.forName(className);
Constructor constructor = clazz.getDeclaredConstructor();
constructor.setAccessible(true);
//动态的创建指定字符串对应类的对象
Object obj = constructor.newInstance();
Method method = clazz.getDeclaredMethod(methodName);
method.setAccessible(true);
return method.invoke(obj);
}
@Test
public void test2() throws Exception {
String info = (String) invoke("com.atguigu.java1.Person", "show");
System.out.println("返回值为：" + info);
}
}
体会3：
public class ReflectionTest {
@Test
public void test1() throws Exception {
//1.加载配置文件，并获取指定的fruitName值
Properties pros = new Properties();
InputStream is = ClassLoader.getSystemClassLoader().getResourceAsStream("config.properties");
pros.load(is);
String fruitStr = pros.getProperty("fruitName");
//2.创建指定全类名对应类的实例
Class clazz = Class.forName(fruitStr);
Constructor constructor = clazz.getDeclaredConstructor();
constructor.setAccessible(true);
Fruit fruit = (Fruit) constructor.newInstance();
//3. 调用相关方法，进行测试
Juicer juicer = new Juicer();
juicer.run(fruit);
}
}
interface Fruit {
public void squeeze();
}
class Apple implements Fruit {
public void squeeze() {
System.out.println("榨出一杯苹果汁儿");
}
}
class Orange implements Fruit {
public void squeeze() {
System.out.println("榨出一杯桔子汁儿");
}
}
class Juicer {
public void run(Fruit f) {
f.squeeze();
}
}
其中，配置文件【config.properties】存放在当前Module的src下
com.atguigu.java1.Orange
13、练习案例
练习一
package com.hspedu.reflection.homework;
import java.lang.reflect.Field;
import java.lang.reflect.InvocationTargetException;
import java.lang.reflect.Method;
public class Homework01 {
public static void main(String[] args) throws IllegalAccessException, InstantiationException, NoSuchFieldException, NoSuchMethodException, InvocationTargetException {
/**
* 定义PrivateTest类，有私有name属性，并且属性值为hellokitty
* 提供getName的公有方法
* 创建PrivateTest的类，利用Class类得到私有的name属性，修改私有的name属性值，并调用getName()的方法打印name属性值
*/
//1. 得到 PrivateTest类对应的Class对象
Class<PrivateTest> privateTestClass = PrivateTest.class;
//2. 创建对象实例
PrivateTest privateTestObj = privateTestClass.newInstance();
//3. 得到name属性对象
Field name = privateTestClass.getDeclaredField("name");//name属性是private
//4. 暴破name
name.setAccessible(true);
name.set(privateTestObj, "天龙八部");
//5. 得到getName方法对象
Method getName = privateTestClass.getMethod("getName");
//6. 因为getName() 是public，所有直接调用
Object invoke = getName.invoke(privateTestObj);
System.out.println("name属性值=" + invoke);//天龙八部
}
}
class PrivateTest {
private String name = "hellokitty";
//默认无参构造器
public String getName() {
return name;
}
}
练习二
package com.hspedu.reflection.homework;
import java.lang.reflect.Constructor;
import java.lang.reflect.InvocationTargetException;
import java.lang.reflect.Method;
public class Homework02 {
public static void main(String[] args) throws ClassNotFoundException, NoSuchMethodException, IllegalAccessException, InvocationTargetException, InstantiationException {
/**
* 利用Class类的forName方法得到File类的class 对象
* 在控制台打印File类的所有构造器
* 通过newInstance的方法创建File对象，并创建E:\mynew.txt文件
*/
//1. Class类的forName方法得到File类的class 对象
Class<?> fileCls = Class.forName("java.io.File");
//2. 得到所有的构造器
Constructor<?>[] declaredConstructors = fileCls.getDeclaredConstructors();
//遍历输出
for (Constructor<?> declaredConstructor : declaredConstructors) {
System.out.println("File构造器=" + declaredConstructor);
}
//3. 指定的得到 public java.io.File(java.lang.String)
Constructor<?> declaredConstructor = fileCls.getDeclaredConstructor(String.class);
String fileAllPath = "d:\\mynew.txt";
Object file = declaredConstructor.newInstance(fileAllPath);//创建File对象
//4. 得到createNewFile 的方法对象
Method createNewFile = fileCls.getMethod("createNewFile");
createNewFile.invoke(file);//创建文件，调用的是 createNewFile
//file的运行类型就是File
System.out.println(file.getClass());
System.out.println("创建文件成功" + fileAllPath);
}
}
扫一扫
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
