深入理解代理模式(Proxy)：静态代理、动态代理与AOP

1. 代理模式简介

代理模式是一种结构型设计模式，它允许我们提供一个代理来控制对其他对象的访问。代理模式在不改变原始类代码的情况下，通过引入代理类来给原始类附加功能。

代理模式的UML类图

代理模式的主要角色

Subject（抽象主题）：定义代理类和真实主题的共同接口
RealSubject（真实主题）：定义代理所代表的真实对象
Proxy（代理）：包含对真实主题的引用，从而可以操作真实主题

2. 静态代理

静态代理是最简单的代理模式实现方式。代理类在编译时就已经确定，在程序运行前就已经存在代理类的 .class 文件。

示例代码

java">// 抽象主题接口
public interface UserService {void addUser(String username);void deleteUser(String username);
}// 真实主题类
public class UserServiceImpl implements UserService {@Overridepublic void addUser(String username) {System.out.println("添加用户: " + username);}@Overridepublic void deleteUser(String username) {System.out.println("删除用户: " + username);}
}// 静态代理类
public class UserServiceProxy implements UserService {private UserService userService;public UserServiceProxy(UserService userService) {this.userService = userService;}@Overridepublic void addUser(String username) {System.out.println("开始添加用户...");long startTime = System.currentTimeMillis();userService.addUser(username);long endTime = System.currentTimeMillis();System.out.println("添加用户完成，耗时：" + (endTime - startTime) + "ms");}@Overridepublic void deleteUser(String username) {System.out.println("开始删除用户...");long startTime = System.currentTimeMillis();userService.deleteUser(username);long endTime = System.currentTimeMillis();System.out.println("删除用户完成，耗时：" + (endTime - startTime) + "ms");}
}

开始添加用户...
添加用户完成，耗时：1ms
开始删除用户...
删除用户完成，耗时：1ms

介绍：静态代理通过代理类为目标方法添加了额外的功能（如记录执行时间），并且不需要修改目标类的代码。上述输出表示在添加用户和删除用户时，代理类能够控制方法执行并统计耗时。

静态代理的优缺点

优点：

可以在不修改目标对象的前提下，实现对目标对象的功能扩展
实现简单，容易理解

缺点：

为每个服务都需要创建代理类，工作量大
不易维护，一旦接口增加方法，所有代理类都需要修改

3. 动态代理

动态代理是在程序运行时，通过反射机制动态创建代理类的代理模式实现方式。

3.1 JDK动态代理

JDK动态代理只能代理实现了接口的类。

java">import java.lang.reflect.InvocationHandler;
import java.lang.reflect.Method;
import java.lang.reflect.Proxy;// 动态代理处理器
public class LogHandler implements InvocationHandler {private Object target;public LogHandler(Object target) {this.target = target;}@Overridepublic Object invoke(Object proxy, Method method, Object[] args) throws Throwable {System.out.println("开始执行方法：" + method.getName());long startTime = System.currentTimeMillis();Object result = method.invoke(target, args);long endTime = System.currentTimeMillis();System.out.println("方法执行完成，耗时：" + (endTime - startTime) + "ms");return result;}// 获取代理对象public static Object getProxy(Object target) {return Proxy.newProxyInstance(target.getClass().getClassLoader(),target.getClass().getInterfaces(),new LogHandler(target));}
}// 使用示例
public class DynamicProxyDemo {public static void main(String[] args) {UserService userService = new UserServiceImpl();UserService proxy = (UserService) LogHandler.getProxy(userService);proxy.addUser("张三");proxy.deleteUser("张三");}
}

开始执行方法：addUser
方法执行完成，耗时：1ms
开始执行方法：deleteUser
方法执行完成，耗时：1ms

介绍：使用JDK动态代理，代理对象的行为由InvocationHandler接口的invoke方法决定。这里我们添加了日志记录功能，输出了执行方法的时间统计。

3.2 CGLIB动态代理

CGLIB可以代理没有实现接口的类，通过继承被代理类来实现代理。

java">import net.sf.cglib.proxy.Enhancer;
import net.sf.cglib.proxy.MethodInterceptor;
import net.sf.cglib.proxy.MethodProxy;public class CglibProxy implements MethodInterceptor {private Object target;public CglibProxy(Object target) {this.target = target;}public Object getProxy() {Enhancer enhancer = new Enhancer();enhancer.setSuperclass(target.getClass());enhancer.setCallback(this);return enhancer.create();}@Overridepublic Object intercept(Object obj, Method method, Object[] args, MethodProxy proxy) throws Throwable {System.out.println("开始执行方法：" + method.getName());long startTime = System.currentTimeMillis();Object result = proxy.invokeSuper(obj, args);long endTime = System.currentTimeMillis();System.out.println("方法执行完成，耗时：" + (endTime - startTime) + "ms");return result;}
}// 使用示例
public class CglibProxyDemo {public static void main(String[] args) {UserService userService = new UserServiceImpl();UserService proxy = (UserService) new CglibProxy(userService).getProxy();proxy.addUser("李四");proxy.deleteUser("李四");}
}

开始执行方法：addUser
方法执行完成，耗时：1ms
开始执行方法：deleteUser
方法执行完成，耗时：1ms

介绍：CGLIB动态代理通过继承目标类来生成代理类，它不要求目标类实现接口。类似于JDK动态代理，这里输出的日志同样记录了方法执行的时间。

4. 面向切面编程(AOP)

AOP是一种编程范式，它通过预编译方式和运行期动态代理实现程序功能的统一维护。

Spring AOP示例

java">import org.aspectj.lang.ProceedingJoinPoint;
import org.aspectj.lang.annotation.*;
import org.springframework.stereotype.Component;@Aspect
@Component
public class LoggingAspect {@Around("execution(com.example.service..(..))")public Object logExecutionTime(ProceedingJoinPoint joinPoint) throws Throwable {long startTime = System.currentTimeMillis();Object result = joinPoint.proceed();long endTime = System.currentTimeMillis();System.out.println(joinPoint.getSignature() + " 执行耗时：" + (endTime - startTime) + "ms");return result;}@Before("execution(com.example.service..(..))")public void logBefore() {System.out.println("方法执行前的处理...");}@After("execution(com.example.service..(..))")public void logAfter() {System.out.println("方法执行后的处理...");}
}

5. 实战示例

下面是一个完整的实战示例，展示如何使用代理模式实现方法执行时间统计和日志记录。

java">// 定义注解
@Retention(RetentionPolicy.RUNTIME)
@Target(ElementType.METHOD)
public @interface LogExecutionTime {
}// 切面类
@Aspect
@Component
public class MethodExecutionAspect {private static final Logger logger = LoggerFactory.getLogger(MethodExecutionAspect.class);@Around("@annotation(LogExecutionTime)")public Object logExecutionTime(ProceedingJoinPoint joinPoint) throws Throwable {long startTime = System.currentTimeMillis();Object result = joinPoint.proceed();long endTime = System.currentTimeMillis();logger.info("方法 [{}] 执行耗时：{}ms",joinPoint.getSignature().getName(), (endTime - startTime));return result;}
}// 使用示例
@Service
public class UserServiceImpl implements UserService {@LogExecutionTime@Overridepublic void addUser(String username) {// 业务逻辑}
}