反射
什么是反射
在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);}@Overridepublic 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
| 类型 | 接口 | 描述 |
|---|---|---|
| java.lang.Class类 | - | 反射的核心类，提供了获取类的元数据信息的方法。 |
| - | getClass() | 调用类或接口实例的方法以获取其Class对象。 |
| - | .class语法 | 直接通过类名获取其Class对象。 |
| - | Class.forName() | 通过类的全限定名获取其Class对象。 |
| - | getMethods() | 获取类的所有公共方法。 |
| - | getDeclaredMethods() | 获取类声明的所有方法，包括私有方法。 |
| - | getConstructors() | 获取类的所有公共构造方法。 |
| - | getDeclaredConstructors() | 获取类声明的所有构造方法，包括私有构造方法。 |
| - | getFields() | 获取类的所有公共字段。 |
| - | getDeclaredFields() | 获取类声明的所有字段，包括私有字段。 |
| - | getAnnotations() | 获取类上的所有注解。 |
| - | isAnnotationPresent() | 检查类上是否存在某个特定的注解。 |
| java.lang.reflect.Method类 | - | 用于表示类的方法。 |
| - | invoke(Object obj, Object… args) | 调用方法，第一个参数是方法所属的对象，后面的参数是方法的参数。调用私有方法（需要先设置为可访问,通过设置method.setAccessible(true);实现） |
| - | getParameterTypes() | 获取方法的参数类型数组。 |
| - | getReturnType() | 获取方法的返回类型。 |
| java.lang.reflect.Field类 | - | 用于表示类的字段。访问私有字段需要设置为可访问(通过设置field.setAccessible(true);实现) |
| - | get(Object obj) | 获取字段的值，第一个参数是字段所属的对象。 |
| - | set(Object obj) | 设置字段的值，第一个参数是字段所属的对象。 |
| - | getType() | 获取字段的类型。 |
| java.lang.reflect.Constructor类 | - | 用于表示类的构造方法。 |
| - | newInstance(Object… initargs) | 使用此Constructor对象表示的构造方法来创建该构造方法的声明类的新实例。从Java 9开始，newInstance()方法已被弃用，应使用getDeclaredConstructor().newInstance() |
| java.lang.reflect.Modifier类 | - | 用于获取和操作修饰符的工具类。 |
| - | isPublic(int modifiers) | 检查修饰符是否表示类、方法或字段是公共的。 |
| - | isPrivate(int modifiers) | 判断修饰符是否是private。 |
注意：
setAccessible(true) 可以用来访问私有字段和方法，但这样会破坏封装性，并且可能带来安全风险。
反射操作通常比直接访问慢，因为它们涉及到更多的动态解析和类型转换。
使用反射时应谨慎处理异常，特别是ClassNotFoundException、NoSuchMethodException、IllegalAccessException和InvocationTargetException等。
反射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()获取ClassClass<?> clazz = Class.forName("demo1.UserDo");// 获取构造方法Constructor<?> declaredConstructor = clazz.getDeclaredConstructor(String.class, Integer.class, String.class);// 调用newInstance()初始化UserDoUserDo userDo = (UserDo) declaredConstructor.newInstance("张三", 20, "男");System.out.printf("输出初始化后的UserDo对象：%s%n", userDo);// 调用调用公有方法设置nameMethod 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的实例也可以通过实例调用getNameSystem.out.printf("通过实例调用getName:%s%n", userDo1.getName());// 通过反射调用私有方法sayHelloMethod 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 "privatesayHelloMethod.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 {// 获取ClassClass<?> 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 {// 获取ClassClass<?> 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);}
}
执行结果：
结论：
从执行结果可以看出，反射在性能方面是有所损耗的，但是设置setAccessible(true)可以适当提升反射效率。
反射操作泛型
泛型在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);}}}
}
执行结果
gitee源码
git clone https://gitee.com/dchh/JavaStudyWorkSpaces.git
