Java 反射与动态代理的核心概念及实现。反射允许程序在运行时检查类结构、动态创建对象及调用方法，涉及 Class、Method、Field 等核心 API。动态代理分为 JDK 动态代理（基于接口）和 CGLIB 动态代理（基于类），用于在不修改源代码的情况下增强方法功能。文章详细讲解了两者 API 用法、实现步骤及对比，并结合 Spring AOP、JUnit 及事务管理等场景说明了实际应用价值。
在 Java 生态中，反射与动态代理是支撑框架设计的基石，无论是 Spring 中的 AOP，还是 Mybatis 的 Mapper 接口，都离不开这两项技术。在学习之前先了解反射和动态代理分别可以做什么，简单说反射赋予程序'看清类结构'的功能，通过反射可以知道类中构造方法，成员方法，成员变量等信息；动态代理则实现了'无侵入式增强'，二者相辅相成，让代码具备灵活性与扩展性。
在 Java 中，反射（Reflection）是一种强大的机制，允许程序在运行时检查或修改其自身的结构和行为。通过反射，你可以查询类的元数据（如类名、方法、字段、注解等），动态地进行创建对象，调用方法，访问字段等操作。
Java 反射的核心操作集中在 java.lang.reflect 包中，其中关键类包括 Class、Method、Field、Constructor，核心操作分为'获取 Class 对象''操作类成员'两步
首先在这里定义一个 User 类
public class User {
private String name;
public Integer age;
public User() {}
private User(String name) {
this.name = name;
}
public String getName() {
return name;
}
private void setAge(Integer age) {
this.age = age;
}
}
获取类对象有三种方式分别是：类名.class，对象.getClass()，Class.forName('全类名')
// 1. 类名.class(编译时确定，最高效)
Class<?> class1 = User.class;
System.out.println(class1); // class User
// 2. 对象.getClass() (运行时获取，需要实例化)
User user = new User();
Class<?> class2 = user.getClass();
System.out.println(class2); // class User
// 3. Class.forName("全类名") (运行时加载，最灵活)
Class<?> class3 = Class.forName("User");
System.out.println(class3); // class User
// 判断上面三种方法获取的是否是同一个对象
System.out.println(class1.equals(class2)); // true
得到类成员后就可以利用反射操作类的构造方法，成员方法，成员变量等元数据，核心 API 也很易懂
示例 1. 构造器
// 1. 获取类
Class<User> userClass = User.class;
// 2. 获取构造器
// 2.1 获取公共构造器
Constructor<?>[] publicConstructors = userClass.getConstructors();
System.out.println(Arrays.toString(publicConstructors)); // [public User()]
// 2.2 获取所有构造器
Constructor<?>[] declaredConstructors = userClass.getDeclaredConstructors();
System.out.println(Arrays.toString(declaredConstructors)); // [public User(), private User(java.lang.String)]
// 2.3 获取一个公共构造器 (可以传递参数，参数是构造器中的形参类)
Constructor<User> constructor = userClass.getConstructor();
System.out.println(constructor); // public User()
// 2.4 获取一个构造器 (可以传递参数，参数是构造器中的形参类)
Constructor<User> declaredConstructor = userClass.getDeclaredConstructor(String.class);
System.out.println(declaredConstructor); // private User(java.lang.String)
然后可以对获得的构造器进行操作:
// 2.4 获取一个构造器
Constructor<User> declaredConstructor = userClass.getDeclaredConstructor(String.class);
System.out.println(declaredConstructor); // private User(java.lang.String)
// 3. Constructor 类常用方法
// 3.1 获取构造器的权限修饰符
int modifiers = declaredConstructor.getModifiers();
System.out.println(declaredConstructor + "的构造方法的修饰符为" + modifiers); // private User(java.lang.String) 的构造方法的修饰符为 2(对应 private)
// 3.2 获取构造器的形参类型
Class<?>[] types = declaredConstructor.getParameterTypes();
System.out.println(declaredConstructor + "的形参类型有" + Arrays.toString(types)); // private User(java.lang.String) 的形参类型有 [class java.lang.String]
// 3.3 通过 Constructor 实例化对象
// 因为获取的是私有方法，所以需要暴力反射
declaredConstructor.setAccessible(true); // 将私有构造器设置为可访问状态
User user = declaredConstructor.newInstance("test");
System.out.println(user.getName()); // test
在 Java 中，java.lang.reflect.Constructor 类的 getModifiers() 方法返回一个整数，该整数是构造器修饰符的位掩码（Bitmask）。每个修饰符对应一个二进制位，不同修饰符通过按位或（OR）组合成最终的整数值。
获取字段，方法等 API 与获取构造器类似，演示一下通过反射操作私有成员
// 1. 获取类
Class<User> userClass = User.class;
// 2. 实例私有构造器
Constructor<User> privateConstructor = userClass.getDeclaredConstructor(String.class);
privateConstructor.setAccessible(true);
User user = privateConstructor.newInstance("test");
// 3. 调用私有化方法 setAge
Method setAge = userClass.getDeclaredMethod("setAge", Integer.class);
setAge.setAccessible(true);
setAge.invoke(user, 18);
System.out.println(user.getName() + "的年龄为" + user.getAge()); // test 的年龄为 18
// 4. 获取私有属性 name
Field nameField = userClass.getDeclaredField("name");
nameField.setAccessible(true);
String name = (String) nameField.get(user);
System.out.println("利用反射获取的私有属性" + name); // 利用反射获取的私有属性 test
Method 类中 invoke() 方法比较常用，传递的参数表示 1:调用方法的对象，2:调用方法传递的参数；返回值就是原方法返回值
动态代理是一种设计模式，允许程序在运行时动态生成代理类，代理类会包裹目标对象，在不修改目标代码的情况下，对目标方法进行增强。Java 中动态代理主要分为两种JDK 动态代理和 CGLIB 动态代理。
定义接口：目标类需实现接口
// 目标接口
public interface UserService {
void addUser(String name);
void deleteUser(Integer id);
}
// 目标实现类
public class UserServiceImpl implements UserService {
@Override
public void addUser(String name) {
System.out.println("执行添加姓名为 : " + name + " 用户的操作");
}
@Override
public void deleteUser(Integer id) {
System.out.println("执行删除 id 为 : " + id + " 用户的操作");
}
}
实现 InvocationHandler：处理方法调用逻辑
public class LogInvocationHandler implements InvocationHandler {
private Object target; // 目标对象
public LogInvocationHandler(Object target) {
this.target = target;
}
/**
*
* @param proxy 代理对象
* @param method 目标方法
* @param args 方法参数
* @return 方法返回值
* @throws Throwable
*/
@Override
public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
// 前置日志，记录日志
System.out.println("【日志】开始调用方法 : " + method.getName() + ",方法参数为 : " + Arrays.toString(args));
// 调用目标方法
Object result = method.invoke(target, args);
// 后置日志，记录方法完成
System.out.println("【日志】方法调用结束 : " + method.getName());
return result;
}
}
生成代理对象：通过 Proxy.newProxyInstance() 创建代理
public static void main(String[] args) {
// 1. 创建目标对象
UserServiceImpl target = new UserServiceImpl();
// 2. 创建 InvocationHandler 实例
LogInvocationHandler handler = new LogInvocationHandler(target);
// 3. 生成动态代理对象
UserService proxy = (UserService) Proxy.newProxyInstance(
target.getClass().getClassLoader(), // 类加载器
target.getClass().getInterfaces(), // 目标实现的接口
handler
);
// 4. 调用代理对象的方法
proxy.addUser("test");
proxy.deleteUser(1001);
}
最后控制台输出结果
【日志】开始调用方法 : addUser,方法参数为 :[test] 执行添加姓名为 : test 用户的操作 【日志】方法调用结束 : addUser 【日志】开始调用方法 : deleteUser,方法参数为 :[1001] 执行删除 id 为 :1001 用户的操作 【日志】方法调用结束 : deleteUser
至此就完成了一个简单的日志增强效果
引入 CGLIB 依赖 (maven)
<dependency>
<groupId>cglib</groupId>
<artifactId>cglib</artifactId>
<version>3.3.0</version>
</dependency>
public class OrderService {
// 模拟创建订单方法
public void createOrder(String orderNo) {
System.out.println("创建订单，订单号为 : " + orderNo);
}
}
自定义类实现 MethodInterceptor，处理方法调用逻辑
public class TransactionMethodInterceptor implements MethodInterceptor {
/**
*
* @param o 目标对象
* @param method 目标方法
* @param objects 方法参数
* @param methodProxy 方法代理对象
* @return 方法返回值
* @throws Throwable
*/
@Override
public Object intercept(Object o, Method method, Object[] objects, MethodProxy methodProxy) throws Throwable {
// 前置增强：开启事务
System.out.println("【事务】开启数据事务");
// 调用目标方法 (通过 methodProxy 提高性能)
Object result = methodProxy.invokeSuper(o, objects);
// 后置增强：提交事务
System.out.println("【事务】提交数据事务");
return result;
}
}
通过 Enhancer.create() 生成代理对象
public class CglibProxyDemo {
public static void main(String[] args) {
// 1. 创建 Enhancer 实例 (CGLIB 核心)
Enhancer enhancer = new Enhancer();
enhancer.setSuperclass(OrderService.class); // 设置目标类
enhancer.setCallback(new TransactionMethodInterceptor()); // 设置增强器
// 2. 生成动态代理对象
OrderService proxy = (OrderService) enhancer.create();
// 3. 调用代理对象方法
proxy.createOrder("order_112233");
}
}
最终输出结果:
【事务】开启数据事务 创建订单，订单号为 : order_112233 【事务】提交数据事务
| 组件 | JDK 动态代理 | CGLIB 动态代理 |
|---|---|---|
| 接口 | InvocationHandler | MethodInterceptor |
| 生成代理方式 | Proxy.newProxyInstance | Enhancer.create() |
| 目标类型 | 接口 | 类 |
| 调用目标方法 | method.invoke(target, args) | proxy.invokSuper(obj, args) |
通过上面的例子可以初步了解反射与动态代理，想要深度学习的话可以多看看框架中的源码，学习优秀的代码风格以及设计模式。
微信公众号「极客日志」，在微信中扫描左侧二维码关注。展示文案：极客日志 zeeklog
查找任何按下的键的javascript键代码、代码、位置和修饰符。 在线工具，Keycode 信息在线工具，online
JavaScript 字符串转义/反转义；Java 风格 \uXXXX（Native2Ascii）编码与解码。 在线工具，Escape 与 Native 编解码在线工具，online
使用 Prettier 在浏览器内格式化 JavaScript 或 HTML 片段。 在线工具，JavaScript / HTML 格式化在线工具，online
Terser 压缩、变量名混淆，或 javascript-obfuscator 高强度混淆（体积会增大）。 在线工具，JavaScript 压缩与混淆在线工具，online
将字符串编码和解码为其 Base64 格式表示形式即可。 在线工具，Base64 字符串编码/解码在线工具，online
将字符串、文件或图像转换为其 Base64 表示形式。 在线工具，Base64 文件转换器在线工具，online