【设计模式】【结构型模式】代理模式（Proxy）

👋hi，我不是一名外包公司的员工，也不会偷吃茶水间的零食，我的梦想是能写高端CRUD
🔥 2025本人正在沉淀中… 博客更新速度++
👍 欢迎点赞、收藏、关注，跟上我的更新节奏
🎵 当你的天空突然下了大雨，那是我在为你炸乌云

文章目录

一、入门
什么是代理模式？
为什么要代理模式？
如何实现代理模式？
静态代理
JDK代理
CGLIB动态代理
三种代理模式对比

二、代理模式在框架源码中的运用
Spring Framework 中的 AOP 代理
MyBatis 中的 Mapper 接口代理

三、总结
代理模式的优点
代理模式的缺点
代理模式的适用场景

一、入门

什么是代理模式？

代理模式（Proxy Pattern）是一种结构型设计模式，允许你提供一个代理对象来控制对另一个对象的访问。
代理对象在客户端和目标对象之间起到中介作用，可以在不改变目标对象的情况下增加额外的功能或控制访问。

为什么要代理模式？

违反单一职责原则：
- 原始对象的核心职责是实现业务逻辑，但如果将额外的功能（如权限检查、日志记录等）直接写入原始对象，会导致对象的职责变得复杂，难以维护。
- 例如，一个UserService类如果既要处理用户登录逻辑，又要记录日志、检查权限，代码会变得臃肿。
代码重复：
- 如果多个地方需要对对象的访问进行相同的控制（如权限检查），开发者可能会在每个调用点重复编写相同的代码，导致代码冗余。
难以扩展：
- 如果需要在访问对象时增加新的功能（如缓存、延迟加载等），可能需要直接修改原始对象的代码，这会破坏开闭原则（对扩展开放，对修改关闭）。
性能问题：
- 某些场景下，对象的创建或初始化成本较高（如加载大文件、连接远程服务等）。如果没有代理模式，可能会在不需要时提前创建对象，导致资源浪费。
安全性问题：
- 如果没有代理模式，客户端可以直接访问敏感对象，可能会绕过必要的安全检查或权限控制。

如何实现代理模式？

Subject（抽象主题）：定义真实对象和代理对象的共同接口，客户端通过该接口与真实对象交互。
RealSubject（真实主题）：实现Subject接口，是代理对象所代表的真实对象。
Proxy（代理）：实现Subject接口，持有对RealSubject的引用，控制对RealSubject的访问，并可以在访问前后添加额外操作。

【案例】订单加强
网购订单处理：假设我们需要在用户下单时记录日志，但不想修改核心的订单处理逻辑。

静态代理

Subject（抽象主题）: OrderService接口，定义订单下达。

public interface OrderService {void createOrder(String product);
}

RealSubject（真实主题）：OrderServiceImpl类，实现下单逻辑。

public class OrderServiceImpl implements OrderService {@Overridepublic void createOrder(String product) {System.out.println("订单创建成功，商品：" + product);}
}

Proxy（代理）：OrderServiceStaticProxy（手动编写代理类，添加日志记录）

public class OrderServiceStaticProxy implements OrderService {private OrderService orderService;public OrderServiceStaticProxy(OrderService orderService) {this.orderService = orderService;}@Overridepublic void createOrder(String product) {System.out.println("[静态代理] 记录日志：开始下单");orderService.createOrder(product);System.out.println("[静态代理] 记录日志：下单完成");}
}

测试类

public class Client {public static void main(String[] args) {OrderService realService = new OrderServiceImpl();OrderService proxy = new OrderServiceStaticProxy(realService);proxy.createOrder("iPhone 15");}
}

输出

[静态代理] 记录日志：开始下单
订单创建成功，商品：iPhone 15
[静态代理] 记录日志：下单完成

JDK代理

通过JDK的InvocationHandler和Proxy类动态生成代理对象。
Subject（抽象主题）: OrderService接口，定义订单下达。

public interface OrderService {void createOrder(String product);
}

RealSubject（真实主题）：OrderServiceImpl类，实现下单逻辑。

public class OrderServiceImpl implements OrderService {@Overridepublic void createOrder(String product) {System.out.println("订单创建成功，商品：" + product);}
}

Proxy（代理）：InvocationHandler类，InvocationHandler接口。

public class LogInvocationHandler implements InvocationHandler {private Object target; // 真实对象public LogInvocationHandler(Object target) {this.target = target;}@Overridepublic Object invoke(Object proxy, Method method, Object[] args) throws Throwable {System.out.println("[JDK动态代理] 记录日志：开始执行方法 " + method.getName());Object result = method.invoke(target, args);System.out.println("[JDK动态代理] 记录日志：方法执行完成");return result;}
}

客户端调用

public class Client {public static void main(String[] args) {OrderService realService = new OrderServiceImpl();OrderService proxy = (OrderService) Proxy.newProxyInstance(realService.getClass().getClassLoader(),realService.getClass().getInterfaces(),new LogInvocationHandler(realService));proxy.createOrder("MacBook Pro");}
}

输出结果

[JDK动态代理] 记录日志：开始执行方法 createOrder
订单创建成功，商品：MacBook Pro
[JDK动态代理] 记录日志：方法执行完成

CGLIB动态代理

通过继承目标类生成子类来实现代理（无需接口）
RealSubject（真实主题）：OrderServiceImpl类，实现下单逻辑。（这个增强无需接口）

// 真实对象（无需接口）
public class OrderService {public void createOrder(String product) {System.out.println("订单创建成功，商品：" + product);}
}

Proxy（代理）：MethodInterceptor类

public class LogMethodInterceptor implements MethodInterceptor {@Overridepublic Object intercept(Object obj, Method method, Object[] args, MethodProxy proxy) throws Throwable {System.out.println("[CGLIB代理] 记录日志：开始执行方法 " + method.getName());Object result = proxy.invokeSuper(obj, args);System.out.println("[CGLIB代理] 记录日志：方法执行完成");return result;}
}

客户端

public class Client {public static void main(String[] args) {Enhancer enhancer = new Enhancer();enhancer.setSuperclass(OrderService.class); // 设置父类enhancer.setCallback(new LogMethodInterceptor()); // 设置回调OrderService proxy = (OrderService) enhancer.create(); // 创建代理对象proxy.createOrder("AirPods Pro");}
}

输出结果

[CGLIB代理] 记录日志：开始执行方法 createOrder
订单创建成功，商品：AirPods Pro
[CGLIB代理] 记录日志：方法执行完成

三种代理模式对比

代理类型	特点	适用场景
静态代理	手动编写代理类，直接调用目标对象。	代理逻辑简单，目标对象固定。
JDK动态代理	基于接口动态生成代理类，通过反射调用目标方法。	需要代理接口的实现类。
CGLIB代理	通过继承目标类生成子类代理，无需接口。性能较高，但生成代理类较慢。	需要代理没有实现接口的类。

适用场景

静态代理：适合代理逻辑简单且目标对象固定的场景。
JDK动态代理：适合基于接口的代理（如Spring AOP默认使用JDK代理）。
CGLIB代理：适合代理没有接口的类（如Spring AOP在类没有接口时自动切换为CGLIB）。

二、代理模式在框架源码中的运用

Spring Framework 中的 AOP 代理

Spring AOP 通过代理模式实现方法拦截（如事务管理、日志记录），核心类是 ProxyFactoryBean 和动态代理生成器。

核心角色与类:

Subject（抽象主题）：被代理的接口或类（如 UserService 接口）。
RealSubject（真实主题）：实际的目标对象（如 UserServiceImpl 类）。
Proxy（代理）：由 Spring 动态生成的代理对象，具体分为两类：
JDK 动态代理：通过 JdkDynamicAopProxy 类生成（代理接口）。
CGLIB 代理：通过 ObjenesisCglibAopProxy 类生成（代理类，无接口时使用）。

// Spring AOP 生成代理的核心逻辑（ProxyFactoryBean）
public class ProxyFactoryBean {private Object target;          // RealSubject（真实对象）private Class<?>[] interfaces;  // Subject（接口）private Advice advice;          // 增强逻辑（如事务、日志）public Object getObject() {// 根据配置选择生成 JDK 或 CGLIB 代理return createAopProxy().getProxy();}
}

执行流程:

客户端调用代理对象的方法（如userService.save()）。
代理对象拦截方法调用，执行增强逻辑（如开启事务）。
代理对象通过反射调用真实对象的方法（UserServiceImpl.save()）。
返回结果前，执行后置增强逻辑（如提交事务）。

MyBatis 中的 Mapper 接口代理

MyBatis 通过代理模式将 Mapper 接口的方法调用转换为 SQL 执行，核心类是 MapperProxy。

核心角色与类

Subject（抽象主题）：Mapper 接口（如 UserMapper）。
RealSubject（真实主题）：不存在真实实现类，由代理直接处理逻辑。
Proxy（代理）：MapperProxy 类，实现 InvocationHandler 接口，动态代理 Mapper 接口。

// MyBatis 的 Mapper 代理生成逻辑（MapperProxyFactory）
public class MapperProxyFactory<T> {private final Class<T> mapperInterface;public T newInstance(SqlSession sqlSession) {final MapperProxy<T> mapperProxy = new MapperProxy<>(sqlSession, mapperInterface);return (T) Proxy.newProxyInstance(mapperInterface.getClassLoader(), new Class[] { mapperInterface }, mapperProxy);}
}// MapperProxy 实现 InvocationHandler
public class MapperProxy<T> implements InvocationHandler {@Overridepublic Object invoke(Object proxy, Method method, Object[] args) throws Throwable {// 将方法调用转换为 SQL 执行（如执行 select * from user where id = ?）return execute(method, args);}
}