反射
什么是反射
在Java中，反射（Reflection）是Java语言的一个特性，它允许程序在运行时检查类、接口、字段和方法的信息。通过反射，Java代码能够动态地创建对象、调用方法、改变字段的值等，而无需在编译时知道这些类的详细信息。
Java反射主要提供了以下功能：
- 获取类的信息：通过反射，你可以获取一个类的Class对象，进而获取该类的名称、父类、实现的接口、声明的字段和方法等信息。
- 创建对象：使用反射，你可以在运行时动态地创建类的对象实例，而无需使用new关键字。
- 调用方法：通过反射，你可以获取类的方法信息，并动态地调用这些方法，包括私有方法。
- 访问和修改字段：反射允许你获取类的字段信息，并可以动态地读取和修改这些字段的值，包括私有字段。
- 注解处理：反射也常用于处理Java注解，读取注解信息并执行相应的逻辑。
反射的主要用途包括：
- 框架设计：许多Java框架（如Spring、Hibernate等）都大量使用了反射，以实现灵活的配置和扩展。
- 测试：在单元测试中，反射经常用于创建和操作测试对象。
- 插件机制：在需要支持插件的系统中，反射可以帮助系统在运行时加载和调用插件。
然而，反射也有一些缺点和注意事项：
- 性能开销：反射操作通常比直接操作慢，因为涉及了更多的动态解析和类型转换。
- 安全问题：通过反射，可以访问和修改类的私有成员，这可能导致安全问题。
- 代码可读性：过度使用反射可能导致代码难以理解和维护。
Class对象
Class对象是Java反射机制的核心，它封装了类的元数据(包含了关于类的结构信息，如类的名称、父类、实现的接口、字段、方法、注解等)，并提供了在运行时检查和操作这些信息的能力。
每个类在JVM中都有且只有一个与之对应的Class对象，这个对象在类被加载到JVM时由类加载器创建。
案例
UserDo.java
package demo1;
/**
* 定义UserDo用于测试反射
*
* @author Anna.
* @date 2024/4/3 23:06
*/
public class UserDo {
private String name;
private Integer age;
public String sex;
public UserDo() {
}
public UserDo(String name, Integer age, String sex) {
this.name = name;
this.age = age;
this.sex = sex;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public Integer getAge() {
return age;
}
public void setAge(Integer age) {
this.age = age;
}
public String getSex() {
return sex;
}
public void setSex(String sex) {
this.sex = sex;
}
/**
* 定义一个私有方法
*
* @param content
* @return void
* @author Anna.
* @date 2024/4/3 23:09
*/
private void sayHello(String content){System.out.printf("%s说%s%n",this.name,content);}
@Override
public String toString() {
return "UserDo{" +
"name='" + name + '\'' +
", age=" + age +
", sex='" + sex + '\'' +
'}';
}
}
测试代码：
package demo1;
/**
* 测试反射
* 获取Class的三种方式
*
* @author Anna.
* @date 2024/4/3 23:10
*/
public class ReflexDemo1 {
public static void main(String[] args) throws ClassNotFoundException {
// 通过.class获取
Class<UserDo> userDoClass1 = UserDo.class;
System.out.println(userDoClass1); // class demo1.UserDo
// 通过UserDo实例调用getClass()方法获取
Class<? extends UserDo> userDoClass2 = new UserDo().getClass();
System.out.println(userDoClass2 == userDoClass1); // true
// 通过Class.forName()获取
Class<UserDo> userDoClass3 = (Class<UserDo>) Class.forName("demo1.UserDo");
System.out.println(userDoClass3 == userDoClass2); // true
}
}
获取Class对象
- 使用.class语法：Class<?> clazz = String.class;
- 使用对象的getClass()方法：String s = “Hello”; Class<?> clazz = s.getClass();
- 使用Class.forName(包路径.类名)方法（需处理ClassNotFoundException）：Class<?> clazz = Class.forName(“java.lang.String”);
Class对象的作用
- 类实例化：使用newInstance()方法或反射API创建类的新实例（从Java 9开始，newInstance()方法已被弃用，应使用getDeclaredConstructor().newInstance()）。
- 反射操作：通过Class对象可以获取类的字段、方法、注解等信息，并可以动态地调用方法、访问和修改字段。
- 类型检查与转换：Class对象可以用于运行时类型检查（instanceof）和类型转换（cast）。
- 注解处理：通过Class对象可以读取类、方法、字段上的注解信息
泛型与Class对象
泛型在Java中引入了类型参数的概念，但在运行时，由于类型擦除（Type Erasure），泛型类型信息并不完全保留。因此，使用反射处理泛型时可能会遇到一些限制。不过，可以通过一些技巧（如使用类型令牌）来在运行时保留部分泛型类型信息。（通过反射处理注解逻辑时详述）
安全性与性能
使用反射进行类操作时需要注意安全性和性能问题。反射可以绕过编译时的类型检查，从而可能导致运行时错误或安全漏洞。此外，反射操作通常比直接操作慢，因为它们涉及更多的动态解析和类型转换。
反射常用API
反射案例
package demo2;
import demo1.UserDo;
import java.lang.reflect.Constructor;
import java.lang.reflect.Method;
/**
* 测试反射
* 1 通过反射创建UserDo对象，
* 2 调用默认构造器创建对象
* 3 调用公有方法设置name
* 4 调用公有方法获取私有字段name属性值
* 5 调用私有方法sayHello
*
* @author Anna.
* @date 2024/4/3 23:19
*/
public class ReflexDemo {
public static void main(String[] args) throws Exception {
// 通过Class.forName()获取Class
Class<?> clazz = Class.forName("demo1.UserDo");
// 获取构造方法
Constructor<?> declaredConstructor = clazz.getDeclaredConstructor(String.class, Integer.class, String.class);
// 调用newInstance()初始化UserDo
UserDo userDo = (UserDo) declaredConstructor.newInstance("张三", 20, "男");
System.out.printf("输出初始化后的UserDo对象：%s%n", userDo);
// 调用调用公有方法设置name
Method setNameMethod = clazz.getDeclaredMethod("setName", String.class);
// 方法调用前需要先初始化 否则会抛出 Exception in thread "main" java.lang.IllegalArgumentException: object is not an instance of declaring class
// 从Java 9开始，newInstance()方法已被弃用，应使用getDeclaredConstructor().newInstance()
UserDo userDo1 = (UserDo) clazz.getDeclaredConstructor().newInstance();
// 执行共育setNameMethod方法
setNameMethod.invoke(userDo1, "李四");
调用公有方法获取私有字段name属性值
Method getNameMethod = clazz.getMethod("getName");
System.out.printf("通过反射调用getName:%s%n", getNameMethod.invoke(userDo1));
// 因为已经拿到UserDo的实例也可以通过实例调用getName
System.out.printf("通过实例调用getName:%s%n", userDo1.getName());
// 通过反射调用私有方法sayHello
Method sayHelloMethod = clazz.getDeclaredMethod("sayHello", String.class);
// 调用私有方法需要设置为可访问 否则会抛出异常 Exception in thread "main" java.lang.IllegalAccessException: class demo2.ReflexDemo cannot access a member of class demo1.UserDo with modifiers "private
sayHelloMethod.setAccessible(true);
sayHelloMethod.invoke(userDo1, "通过反射调用私有方法sayHello说了你好啊");
}
}
比较反射与对象实例调用方法对比
package demo3;
import demo1.UserDo;
import java.lang.reflect.Method;
/**
* 比较反射与对象实例调用方法对比
*
* @author Anna.
* @date 2024/4/3 23:54
*/
public class ReflexDemo {
public static void main(String[] args) throws Exception {
test1();
test2();
test3();
}
/**
* 通过UserDo调用方法
*
* @author Anna.
* @date 2024/4/3 23:54
*/
public static void test1(){
UserDo userDo = new UserDo();
long start = System.currentTimeMillis();
for (long i = 0; i < 10000000000L; i++) {
userDo.getName();
}
long end = System.currentTimeMillis();
System.out.printf("通过UserDo调用getName()方法耗时(ms)：%s%n", end - start);
}
/**
* 通过反射调用getName方法，不设置跳过安全检查
*
* @author Anna.
* @date 2024/4/3 23:57
*/
public static void test2() throws Exception {
// 获取Class
Class<?> clazz = Class.forName("demo1.UserDo");
// 初始化对象
UserDo userDo = (UserDo) clazz.getDeclaredConstructor().newInstance();
// 获取setName()方法
Method getNameNameMethod = clazz.getMethod("getName");
long start = System.currentTimeMillis();
for (long i = 0; i < 10000000000L; i++) {
getNameNameMethod.invoke(userDo);
}
long end = System.currentTimeMillis();
System.out.printf("通过反射调用getName方法，不设置跳过安全检查(ms)：%s%n", end - start);
}
/**
* 通过反射调用getName方法，设置跳过安全检查
*
* @author Anna.
* @date 2024/4/3 23:57
*/
public static void test3() throws Exception {
// 获取Class
Class<?> clazz = Class.forName("demo1.UserDo");
// 初始化对象
UserDo userDo = (UserDo) clazz.getDeclaredConstructor().newInstance();
// 获取setName()方法
Method getNameNameMethod = clazz.getMethod("getName");
// 设置跳过安全检查
getNameNameMethod.setAccessible(true);
long start = System.currentTimeMillis();
for (long i = 0; i < 10000000000L; i++) {
getNameNameMethod.invoke(userDo);
}
long end = System.currentTimeMillis();
System.out.printf("通过反射调用getName方法，设置跳过安全检查(ms)：%s%n", end - start);
}
}
反射操作泛型
泛型在Java中引入了类型参数的概念，但在运行时，由于类型擦除（Type Erasure），泛型类型信息并不完全保留。
为了通过单设操作这些类型以配合实际开发的需要，Java新增了ParameterizedType,GenericArrayType,TypeVariable,WildcardType几种类型来代表不能为归一到Class类中的类型但是又和原始类型起名的类型。
- ParameterizedType ：表示一种参数化的类型，比如Collection
- GenericArrayType ：表示一种元素类型是参数化类型或者类型变量的数组类型
- TypeVariable ：是各种类型变量的公共接口
- WildcardType：代表一种通配符类型表达式，比如：?,? extends Number, ?super Integer
package demo4;
import demo1.UserDo;
import java.lang.reflect.Method;
import java.lang.reflect.ParameterizedType;
import java.lang.reflect.Type;
import java.util.List;
import java.util.Map;
/**
* 反射操作泛型
*
* @author Anna.
* @date 2024/4/4 0:48
*/
public class ReflexDemo {
public void test01(Map<String, UserDo> map, List<UserDo> userDoList) {
System.out.println("调用test01");
}
public Map<String, UserDo> test02() {
System.out.println("调用test02");
return null;
}
public static void main(String[] args) throws Exception {
// 获取制定法方法参数泛型信息
Method test01Method = ReflexDemo.class.getMethod("test01", Map.class, List.class);
// 获取方法的形式参数类型
Type[] genericParameterTypes = test01Method.getGenericParameterTypes();
for (Type genericParameter : genericParameterTypes) {
// 判断形式参数类型是否为参数化的类型
if (genericParameter instanceof ParameterizedType) {
// 获取实际的类型参数
Type[] actualTypeArguments = ((ParameterizedType) genericParameter).getActualTypeArguments();
for (Type actualTypeArgument : actualTypeArguments) {
System.out.printf("参数，泛型类型：%s%n", actualTypeArgument);
}
}
}
// 获取制定法方法返回值泛型信息
Method test02Method = ReflexDemo.class.getMethod("test02");
// 获取方法的形式参数类型
Type genericReturnType = test02Method.getGenericReturnType();
// 判断返回值 类型是否为参数化的类型
if (genericReturnType instanceof ParameterizedType) {
// 获取实际的类型参数
Type[] actualTypeArguments = ((ParameterizedType) genericReturnType).getActualTypeArguments();
for (Type actualTypeArgument : actualTypeArguments) {
System.out.printf("返回值，泛型类型：%s%n", actualTypeArgument);
}
}
}
}