摘要：Java 动态代理是一种强大的编程技术，它允许在运行时动态创建代理类并拦截方法调用，从而实现灵活的业务逻辑扩展、权限控制、日志记录等功能。
Java 动态代理是一种强大的编程技术，它允许在运行时动态创建代理类并拦截方法调用，从而实现灵活的业务逻辑扩展、权限控制、日志记录等功能。
在日常开发中，我们经常需要为某些功能添加通用逻辑，例如方法调用的日志记录、权限校验或事务管理。这种需求通常需要修改原始代码或增加重复性代码。有没有一种方法，可以在不改动原始代码的情况下，动态地为其添加所需的功能呢？Java 动态代理正是为了解决这样的需求而诞生的，它以优雅的方式实现了功能的解耦和代码的简化。
1. 什么是 Java 动态代理
Java 动态代理是一种设计模式，允许在运行时动态生成实现某些接口的代理类，并通过代理对象拦截对接口方法的调用。代理对象本质上是原始对象的中介，它可以在调用原始方法前后执行额外的逻辑。
1.1 静态代理与动态代理的区别
在学习动态代理之前，我们先看一下静态代理。静态代理要求我们提前定义代理类，而动态代理则是在运行时通过 Java 反射机制动态生成代理类。
静态代理的特点：
代理类需要手动定义，增加了代码量。
当接口发生变化时，需要修改代理类。
动态代理的特点：
代理类在运行时动态生成，无需事先定义。
更加灵活，适合处理大量接口。
以下是静态代理与动态代理的对比代码：
// 静态代理
interface Service {
void execute;
}
class RealService implements Service {
public void execute {
System.out.println("执行实际服务逻辑");
}
}
class StaticProxy implements Service {
private Service realService;
public StaticProxy(Service realService) {
this.realService = realService;
}
@Override
System.out.println("执行前的操作...");
realService.execute;
System.out.println("执行后的操作...");
}
}
public class StaticProxyDemo {
public static void main(String args) {
Service realService = new RealService;
Service proxy = new StaticProxy(realService);
proxy.execute;
}
}
动态代理代码示例：
import java.lang.reflect.InvocationHandler;
import java.lang.reflect.Method;
import java.lang.reflect.Proxy;
// 定义接口
interface Service {
void execute;
}
// 实现实际服务
}
}
// 动态代理处理器
class DynamicProxyHandler implements InvocationHandler {
private Object target;
public DynamicProxyHandler(Object target) {
this.target = target;
}
@Override
public Object invoke(Object proxy, Method method, Object args) throws Throwable {
Object result = method.invoke(target, args);
return result;
}
}
public class DynamicProxyDemo {
Service proxy = (Service) Proxy.newProxyInstance(
realService.getClass.getClassLoader,
realService.getClass.getInterfaces,
new DynamicProxyHandler(realService)
);
proxy.execute;
}
}
2. 动态代理的作用
2.1 解耦逻辑
动态代理可以将通用功能（如日志记录、事务管理）从业务逻辑中分离出来，提高代码的可维护性。
2.2 灵活性和扩展性
动态代理在运行时生成代理类，适应变化频繁的业务需求。例如，当需要为多个方法添加权限校验时，可以通过动态代理避免冗余代码。
2.3 面向切面编程（AOP）支持
动态代理是实现 AOP 的核心技术之一。例如，在 Spring 框架中，AOP 大量依赖 Java 动态代理来实现方法拦截。
以下代码展示了通过动态代理实现简单的权限校验：
interface PaymentService {
void processPayment(double amount);
}
class PaymentServiceImpl implements PaymentService {
public void processPayment(double amount) {
System.out.println("处理支付: " + amount + " 元");
}
}
class AuthorizationHandler implements InvocationHandler {
private Object target;
public AuthorizationHandler(Object target) {
this.target = target;
}
@Override
public Object invoke(Object proxy, Method method, Object args) throws Throwable {
if (checkAuthorization) {
return method.invoke(target, args);
} else {
throw new SecurityException("权限不足");
}
}
private boolean checkAuthorization {
// 模拟权限校验
return Math.random > 0.5;
}
}
public class AuthorizationDemo {
public static void main(String args) {
PaymentService realService = new PaymentServiceImpl;
PaymentService proxy = (PaymentService) Proxy.newProxyInstance(
realService.getClass.getClassLoader,
realService.getClass.getInterfaces,
new AuthorizationHandler(realService)
);
try {
proxy.processPayment(100.0);
} catch (SecurityException e) {
System.out.println("权限校验失败: " + e.getMessage);
}
}
}
3. 动态代理的实现原理
3.1 Proxy 类
Java 提供了 java.lang.reflect.Proxy 类，通过该类可以动态生成代理对象。
3.2 InvocationHandler 接口
InvocationHandler 是一个回调接口，用于处理代理对象的方法调用。每次调用代理对象的方法时，都会调用 invoke 方法。
4. 实际开发中的应用场景
4.1 日志记录
动态代理可以拦截方法调用，自动记录输入参数和返回值。
4.2 权限校验
在方法调用前检查用户是否有权限执行该操作。
4.3 缓存
拦截方法调用，将结果存入缓存，以提高系统性能。
4.4 远程调用
动态代理可以封装远程服务的调用逻辑。
总结
Java 动态代理通过反射机制，在运行时动态生成代理类，使得我们能够以更优雅的方式实现业务逻辑的扩展与通用功能的抽离。它是设计模式中的一个重要工具，也是实现 AOP 的核心技术之一。通过动态代理，我们可以大幅提高代码的复用性和灵活性，同时降低维护成本。
#Java#
来源：刺猬科技圈
