1. 反射是什么
反射是 Java 中的一个强大特性，允许程序在运行时检查和操作类、方法、字段等信息。它是一种动态机制，可以在运行时解析类，获取类的成员变量、方法、构造器等，并对它们进行操作。
2. 为什么使用反射
灵活性：反射可以在运行时动态地操作类，而不需要在编译时知道类的具体信息。
可扩展性：通过反射，可以编写通用的代码，支持多种不同的类和对象。
框架和工具：许多框架和工具（如 Spring、Hibernate 等）都广泛使用反射来实现功能，如依赖注入、对象关系映射等。
3. 反射的基本用法
3.1 获取 Class 对象
在 Java 中，每个类都有一个对应的 Class 对象，它是反射的入口。可以通过以下方式获取 Class 对象：
使用类的 .class 属性：Class clazz = Person.class;
使用对象的 .getClass() 方法：Class clazz = personInstance.getClass();
使用类加载器：Class clazz = Class.forName("com.example.Person");
3.2 获取类的信息
一旦获取了 Class 对象，就可以通过它获取类的各种信息，如：
获取类名：clazz.getName();
获取构造器：clazz.getConstructors(); 或 clazz.getConstructor(Class... parameterTypes);
获取方法：clazz.getMethods(); 或 clazz.getMethod(String name, Class... parameterTypes);
获取字段：clazz.getFields(); 或 clazz.getField(String name);
3.3 操作对象
通过反射，可以动态地创建对象、调用方法、访问字段等。
动态创建对象：
Person person = (Person) clazz.newInstance(); // 已过时，推荐使用 Constructor
或者：
Constructor constructor = clazz.getConstructor(String.class, int.class);
Person person = (Person) constructor.newInstance("John", 25);
动态调用方法：
Method method = person.getClass().getMethod("sayHello", String.class);
method.invoke(person, "World");
动态访问字段：
Field field = person.getClass().getField("name");
field.set(person, "Alice");
4. 反射的实际应用
4.1 动态加载和运行代码
例如，在一个插件系统中，可以通过反射动态加载并运行插件的代码：
Class pluginClass = Class.forName("com.example.Plugin");
Object plugin = pluginClass.newInstance();
Method executeMethod = pluginClass.getMethod("execute");
executeMethod.invoke(plugin);
4.2 Java Bean 操作
通过反射可以动态地操作 Java Bean 的属性，如：
Person person = new Person("John", 30);
Field ageField = person.getClass().getField("age");
ageField.set(person, 35);
4.3 测试框架
许多测试框架（如 JUnit）都使用反射来运行测试方法：
TestRunner runner = new TestRunner(MyTest.class);
runner.run();
框架通过反射找到测试类中的测试方法，并调用它们。
4.4 ORM 框架
ORM 框架（如 Hibernate）使用反射将数据库表映射到 Java 类：
Session session = sessionFactory.openSession();
session.save(person);
Hibernate 通过反射操作 Person 类的字段，将其数据存储到数据库中。
5. 反射的优缺点
优点
灵活性：可以在运行时动态地操作类。
可扩展性：支持编写通用代码，适用于多种类和对象。
框架和工具：许多现代框架和工具都依赖反射来实现核心功能。
缺点
性能开销：反射操作的性能比直接调用稍差，因为它需要解析类信息。
安全性问题：可能破坏封装性，访问或修改私有成员。
复杂性：使用反射会使代码变得复杂，难以阅读和维护。
6. 示例代码
以下是个简单的反射示例，展示如何动态创建对象并调用方法：
import java.lang.reflect.Constructor;
import java.lang.reflect.Method;
public class ReflectionExample {
public static void main(String[] args) {
try {
// 获取类
Class clazz = Class.forName("com.example.Person");
// 创建对象
Constructor constructor = clazz.getConstructor(String.class, int.class);
Person person = (Person) constructor.newInstance("John", 30);
// 调用方法
Method sayHelloMethod = person.getClass().getMethod("sayHello", String.class);
sayHelloMethod.invoke(person, "World");
// 访问字段
Field ageField = person.getClass().getField("age");
System.out.println("Age: " + ageField.get(person));
} catch (Exception e) {
e.printStackTrace();
}
}
}
类Person如下：
public class Person {
public String name;
public int age;
public Person(String name, int age) {
this.name = name;
this.age = age;
}
public void sayHello(String target) {
System.out.println("Hello, " + target + "! My name is " + this.name);
}
}
在黑马Java下部中，反射通常的俩中作用：
6.1：保存任意对象数据
6.2：创建对象并运行方法
7.Skyakeout 中的应用
/**
* 功能字段自动填充切面
*/
@Component
@Aspect
@Slf4j
public class AutoFillAspect {
/**
* 切入点
*/
@Pointcut("execution(public * com.sky.mapper.*.*(..))&&@annotation(com.sky.annotation.AutoFill)")
public void autoFillPointCut(){}
/**
* 前置通知,公共字段自动填充
*/
@Before("autoFillPointCut()")
public void autoFill(JoinPoint joinPoint){
//通过 JoinPoint 获取方法参数和上下文信息。
log.info("开始公共字段自动填充...");
//获取当前被拦截的方法上的数据库操作类型
MethodSignature signature = (MethodSignature) joinPoint.getSignature();//方法签名对象
AutoFill autoFill = signature.getMethod().getAnnotation(AutoFill.class);//获得方法上的注解对象
OperationType operationType = autoFill.value();//获得注解中的数据库操作类型
//获取当前被拦截的方法上的——实体对象
Object[] args = joinPoint.getArgs();//获得方法的参数
if(args.length == 0||args == null){
return;
}
Object entity = args[0];//获得实体对象
//准备赋值的数据
LocalDateTime now = LocalDateTime.now();
Long currentId = BaseContext.getCurrentId();
//根据不同的操作类型，通过反射赋予不同的值
if(operationType == OperationType.INSERT){
//为3个公共字段赋值
try {
//使用反射动态调用实体对象的 setter 方法。
Method setCreateTime = entity.getClass().getDeclaredMethod("setCreateTime",LocalDateTime.class);
Method setCreateUser = entity.getClass().getDeclaredMethod("setCreateUser",Long.class);
Method setUpdateTime = entity.getClass().getDeclaredMethod("setUpdateTime",LocalDateTime.class);
Method setUpdateUser = entity.getClass().getDeclaredMethod("setUpdateUser", Long.class);
//通过反射设置值
//invoke 是 Java 反射机制中的一个核心方法，用于动态调用对象的方法。
//invoke 方法允许你在运行时调用一个对象的任意方法
setCreateTime.invoke(entity,now);
setCreateUser.invoke(entity,currentId);
setUpdateTime.invoke(entity,now);
setUpdateUser.invoke(entity,currentId);
} catch (Exception e) {
throw new RuntimeException(e);
}
}
if(operationType == OperationType.UPDATE){
//为2个公共字段赋值
try {
Method setUpdateTime = entity.getClass().getDeclaredMethod(AutoFillConstant.SET_UPDATE_TIME,LocalDateTime.class);
Method setUpdateUser = entity.getClass().getDeclaredMethod(AutoFillConstant.SET_UPDATE_USER, Long.class);
//通过反射设置值
setUpdateTime.invoke(entity,now);
setUpdateUser.invoke(entity,currentId);
} catch (Exception e) {
throw new RuntimeException(e);
}
}
}
}