当前位置： 首页 > news >正文

设计模式——代理设计模式（结构型）

news 2025/6/3 23:57:01

摘要

本文详细介绍了代理设计模式，包括其定义、结构组成、实现方式、适用场景及实战示例。代理设计模式是一种结构型设计模式，通过代理对象控制对目标对象的访问，可增强功能或延迟加载等。文中通过类图、时序图、静态代理、JDK动态代理、CGLIB动态代理、Spring代理等方式阐述实现方式，并结合金融风控场景进行实战示例，最后对比分析了JDK动态代理和Spring-AOP实现方式。

1. 代理设计模式定义

代理设计模式（Proxy Pattern）是一种结构型设计模式，它为其他对象提供一种代理以控制对这个对象的访问。代理对象在客户端和目标对象之间起到中介作用，常用于控制对象访问、增强功能或延迟加载等场景。代理模式为某对象提供一个替身或占位符，以控制对这个对象的访问。

1.1.1. 📌 结构组成：

角色

说明

Subject

抽象主题，定义目标对象和代理的共同接口。

RealSubject

真实主题，实现实际业务逻辑。

Proxy

代理对象，控制对真实主题的访问，可添加额外行为。

2. 代理设计模式结构

代理模式包含如下角色：

  • Subject: 抽象主题角色
  • Proxy: 代理主题角色
  • RealSubject: 真实主题角色

2.1. 代理设计模式类图

2.2. 代理设计模式时序图

3. 代理设计模式实现方式

代理设计模式的实现方式有多种，主要分为 静态代理 和 动态代理（JDK 动态代理 & CGLIB 动态代理）。下面将依次介绍它们的实现方式及示例。

3.1. ✅ 静态代理（Static Proxy）

3.1.1. 🔧 实现步骤：

  1. 定义公共接口（抽象主题）
  2. 实现真实业务类（RealSubject）
  3. 编写代理类（Proxy），内部持有 RealSubject 对象，控制访问

3.1.2. 📦 示例：

// 抽象主题
public interface Service {void doWork();
}// 真实对象
public class RealService implements Service {public void doWork() {System.out.println("执行真实业务逻辑");}
}// 代理对象
public class ServiceProxy implements Service {private final RealService realService = new RealService();public void doWork() {System.out.println("前置日志记录");realService.doWork();System.out.println("后置监控统计");}
}

3.1.3. ✅ 使用：

Service service = new ServiceProxy();
service.doWork();

3.2. ✅ JDK 动态代理（基于接口）

3.2.1. 📌 要求：被代理的类必须实现接口。

3.2.2. 🔧 实现方式：

  1. 创建接口和实现类。
  2. 使用 InvocationHandler 实现增强逻辑。
  3. 通过 Proxy.newProxyInstance() 生成代理对象。

3.2.3. 📦 示例：

public interface Service {void doWork();
}public class RealService implements Service {public void doWork() {System.out.println("执行真实业务逻辑");}
}
public class LogInvocationHandler implements InvocationHandler {private final Object target;public LogInvocationHandler(Object target) {this.target = target;}public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {System.out.println("前置日志");Object result = method.invoke(target, args);System.out.println("后置日志");return result;}
}
Service proxy = (Service) Proxy.newProxyInstance(RealService.class.getClassLoader(),new Class[]{Service.class},new LogInvocationHandler(new RealService())
);
proxy.doWork();

3.3. ✅ CGLIB 动态代理（基于继承）

3.3.1. 📌 要求：目标类不能是 final 类，方法也不能是 final。

3.3.2. 🔧 实现方式：

使用第三方库 CGLIB（如 Spring AOP 默认使用） 生成目标类的子类实现代理。

3.3.3. 📦 示例（使用 cglib）：

public class RealService {public void doWork() {System.out.println("执行真实业务逻辑");}
}
public class CglibMethodInterceptor implements MethodInterceptor {public Object intercept(Object obj, Method method, Object[] args, MethodProxy proxy) throws Throwable {System.out.println("前置增强");Object result = proxy.invokeSuper(obj, args);System.out.println("后置增强");return result;}
}
Enhancer enhancer = new Enhancer();
enhancer.setSuperclass(RealService.class);
enhancer.setCallback(new CglibMethodInterceptor());
RealService proxy = (RealService) enhancer.create();
proxy.doWork();

3.4. ✅ Spring 中的代理（实际应用）

场景

使用方式

实现代理方式

AOP 切面增强

@Aspect + @Around

JDK 或 CGLIB

事务管理

@Transactional

JDK 或 CGLIB

缓存注解

@Cacheable

Spring AOP 代理

3.5. 📝 代理设计模式总结

实现方式

是否要求接口

是否可增强所有方法

是否支持 final 类

静态代理

✅

✅

✅

JDK 动态代理

✅

✅

❌

CGLIB 动态代理

❌

✅

❌

4. 代理设计模式适合场景

4.1. ✅ 适合使用代理模式的场景

场景

说明

权限控制

控制对敏感对象的访问，例如只有特定用户才能访问某些接口（安全代理）。

延迟加载

当对象创建成本高、初始化慢时，使用虚拟代理延迟加载资源（如图片、文件）。

远程代理（RPC）

客户端调用代理对象，本质是远程服务器的接口封装，例如 Dubbo、gRPC 等远程服务调用代理。

记录日志/监控行为

在调用真实对象前后执行附加操作（如日志、性能监控等），例如 AOP 的典型应用。

事务控制/缓存控制

拦截业务逻辑前后控制事务边界或缓存处理，常见于 Spring 中 @Transactional、@Cacheable。

SpringAOP实现原理

基于代理对 Bean 进行横切增强。

防止重复提交或频繁调用

通过代理封装防抖节流逻辑。

4.2. ❌ 不适合使用代理模式的场景

场景

原因

业务逻辑简单，不需增强行为

引入代理会增加结构复杂度，得不偿失。

不需要拦截/控制访问

如果只是调用普通方法，不涉及权限、监控等，直接使用原始对象更清晰高效。

频繁变动或高并发敏感场景

动态代理在高频调用下可能存在性能问题，不如直接调用来得高效。

需要访问类中 final

方法或类（JDK 动态代理）

JDK 动态代理只能基于接口，不能代理 final 方法或类；这时必须使用 CGLIB，但仍有限制。

不具备接口或无法继承的目标类

无法被 JDK/CGLIB 等动态代理机制支持（如某些第三方封闭类）。

4.3. 📌 代理模式的场景总结：

项目

使用代理适合

不适合使用代理

是否需要权限/日志控制

✅ 是

❌ 否

是否希望延迟创建

✅ 是

❌ 否

对象构造是否昂贵

✅ 是

❌ 否

是否必须 final 类或方法

❌ 否（JDK/CGLIB 限制）

✅ 是

是否对性能敏感

❌ 否（代理略有性能损耗）

✅ 是

项目是否小而简单

❌ 否

✅ 是（复杂结构不划算）

5. 代理设计模式实战示例

以下是一个在金融风控场景中，使用代理设计模式的 Spring Boot 实战示例。

5.1. 🧩 场景说明（金融风控）

系统中有一个核心接口：FraudChecker（欺诈检查器）。不同风控规则实现了它，比如：

  • 黑名单校验
  • 设备风险评分
  • IP 频次校验

你希望在调用真实校验逻辑前后增加：

  • 日志记录
  • 调用耗时监控
  • 异常捕获/报警等

这就适合使用代理模式来封装增强行为。

5.2. ✅ 实现目标

  • 使用 接口 + 真实实现类 + 代理类
  • 所有 Bean 交给 Spring 容器管理
  • 注入使用 @Autowired，不使用构造函数注入
  • 通过代理封装增强行为（记录日志 + 耗时统计）

5.3. 📁 项目结构如下：

com.example.riskcheck
├── FraudChecker.java               // 抽象主题
├── RealFraudChecker.java           // 真实对象
├── FraudCheckerProxy.java          // 代理对象
├── FraudCheckerRunner.java         // 启动测试类

5.4. 🔶 抽象接口 FraudChecker

public interface FraudChecker {void check(String userId);
}

5.5. 🔷 真实风控实现类 RealFraudChecker

@Component("realFraudChecker")
public class RealFraudChecker implements FraudChecker {@Overridepublic void check(String userId) {// 模拟业务逻辑System.out.println("执行真实的欺诈检查逻辑，用户ID: " + userId);// 可能抛出异常等}
}

5.6. 🔶 代理类 FraudCheckerProxy（代理增强）

@Component("fraudCheckerProxy")
public class FraudCheckerProxy implements FraudChecker {@Autowired@Qualifier("realFraudChecker") // 指定真实对象private FraudChecker realFraudChecker;@Overridepublic void check(String userId) {long start = System.currentTimeMillis();System.out.println("【日志】准备执行欺诈校验逻辑");try {realFraudChecker.check(userId);System.out.println("【日志】欺诈校验完成");} catch (Exception e) {System.err.println("【异常报警】欺诈检查出错：" + e.getMessage());} finally {long duration = System.currentTimeMillis() - start;System.out.println("【监控】欺诈检查耗时：" + duration + "ms");}}
}

5.7. ✅ 测试类（模拟调用）

@Component
public class FraudCheckerRunner implements CommandLineRunner {@Autowired@Qualifier("fraudCheckerProxy") // 使用代理对象代替真实对象private FraudChecker fraudChecker;@Overridepublic void run(String... args) {fraudChecker.check("USER_123456");}
}

5.8. 🧪 启动类 Application.java

@SpringBootApplication
public class RiskApp {public static void main(String[] args) {SpringApplication.run(RiskApp.class, args);}
}

5.9. ✅ 输出结果：

【日志】准备执行欺诈校验逻辑
执行真实的欺诈检查逻辑，用户ID: USER_123456
【日志】欺诈校验完成
【监控】欺诈检查耗时：5ms

5.10. 📝 总结

要素

内容

场景

金融风控系统中对核心逻辑（欺诈校验）进行代理增强

模式

代理模式（静态代理，封装行为）

优点

无需修改真实逻辑类，增强日志、监控、容错

Spring 集成

所有对象都由 Spring 管理，注解注入，无构造函数依赖

如需升级为 JDK 动态代理 或 Spring AOP 实现，可继续告诉我。也可以扩展为一组校验器链，支持责任链模式、组合增强等架构。

6. 原型设计模式思考

6.1. JDK 动态代理代理设计模式

目标：增强风控逻辑，例如记录日志、统计耗时、捕获异常等，不侵入真实业务代码。

6.1.1. 🔹 接口

public interface FraudChecker {void check(String userId);
}

6.1.2. 🔹 真实业务类（Spring 管理）

@Component
public class RealFraudChecker implements FraudChecker {@Overridepublic void check(String userId) {System.out.println("执行真实欺诈校验逻辑，用户ID: " + userId);}
}

6.1.3. 🔹 动态代理工厂类（Spring 管理）

@Component
public class FraudCheckerProxyFactory {@Autowiredprivate RealFraudChecker realFraudChecker;public FraudChecker getProxy() {return (FraudChecker) Proxy.newProxyInstance(FraudChecker.class.getClassLoader(),new Class[]{FraudChecker.class},(proxy, method, args) -> {long start = System.currentTimeMillis();System.out.println("【JDK代理】准备执行欺诈校验");try {return method.invoke(realFraudChecker, args);} catch (Exception e) {System.err.println("【JDK代理异常】" + e.getMessage());return null;} finally {System.out.println("【JDK代理】耗时：" + (System.currentTimeMillis() - start) + "ms");}});}
}

6.1.4. 🔹 测试调用类

@Component
public class ProxyRunner implements CommandLineRunner {@Autowiredprivate FraudCheckerProxyFactory proxyFactory;@Overridepublic void run(String... args) {FraudChecker proxy = proxyFactory.getProxy();proxy.check("USER_98765");}
}

6.2. Spring-AOP实现代理设计模式（推荐）

6.2.1. 🔹 业务接口 + 实现类（与上面一致）

public interface FraudChecker {void check(String userId);
}@Component
public class RealFraudChecker implements FraudChecker {@Overridepublic void check(String userId) {System.out.println("执行真实欺诈校验逻辑，用户ID: " + userId);}
}

6.2.2. 🔹 编写 AOP 切面类（增强逻辑）

@Aspect
@Component
public class FraudCheckerAspect {@Pointcut("execution(* com.example.riskcheck.FraudChecker.check(..))")public void checkPointcut() {}@Around("checkPointcut()")public Object aroundCheck(ProceedingJoinPoint pjp) throws Throwable {long start = System.currentTimeMillis();System.out.println("【AOP】开始风控校验");try {return pjp.proceed();} catch (Exception e) {System.err.println("【AOP异常】" + e.getMessage());throw e;} finally {long time = System.currentTimeMillis() - start;System.out.println("【AOP】校验耗时: " + time + "ms");}}
}

6.2.3. 🔹 测试调用类

@Component
public class AopRunner implements CommandLineRunner {@Autowiredprivate FraudChecker fraudChecker;@Overridepublic void run(String... args) {fraudChecker.check("USER_54321");}
}

6.2.4. 🔹 开启 AOP 支持（在启动类上）

@SpringBootApplication
@EnableAspectJAutoProxy
public class RiskApp {public static void main(String[] args) {SpringApplication.run(RiskApp.class, args);}
}

6.3. ✅ 输出示例（AOP方式）

【AOP】开始风控校验
执行真实欺诈校验逻辑，用户ID: USER_54321
【AOP】校验耗时: 7ms

博文参考

  • 6. 代理模式 — Graphic Design Patterns
  • 代理设计模式
http://www.xdnf.cn/news/758089.html

相关文章：

  • android stdio 的布局属性
  • 鸿蒙ArkTS | Badge 信息标记组件自学指南
  • MyBatis03——SpringBoot整合MyBatis
  • Kubernetes（K8s）核心架构解析与实用命令大全
  • Go 语言 select 语句详解
  • JMeter 性能测试
  • DDR5 ECC详细原理介绍与基于协议讲解
  • 3D Gaussian splatting 05: 代码阅读-训练整体流程
  • 【计算机网络】第3章：传输层—面向连接的传输：TCP
  • Spring Boot中Excel处理完全指南：从基础到高级实践
  • telnet 基本用法
  • Java并发编程中任务调度与线程池的配置优化
  • 大规模真实场景 WiFi 感知基准数据集
  • SSL/TLS 协议详解：安全通信的基石
  • C++修炼：位图和布隆过滤器
  • 布隆筛选详解
  • Ansible自动化运维工具全面指南：从安装到实战应用
  • 【Go语言生态】
  • Vue初始化脚手架
  • 数据库，Spring Boot，数据源
  • 第13讲、Odoo 18 配置文件（odoo.conf）详细解读
  • 6.1 英语复习笔记 3
  • 如何利用大语言模型生成特定格式文风的报告类文章
  • Redis分布式锁实现指南
  • 《P3959 [NOIP 2017 提高组] 宝藏》
  • 继承与多态
  • 篇章七 数据结构——栈和队列
  • 查看make命令执行后涉及的预编译宏定义的值
  • Python数学可视化——环境搭建与基础绘图
  • 力扣刷题（第四十四天）