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

设计模式之房产中介——代理模式

news 来源：原创 2025/6/28 7:20:27

手撕设计模式之房产中介——代理模式

1.业务需求

​ 大家好，我是菠菜啊，好久不见，今天给大家带来的是——代理模式。老规矩，在介绍这期内容前，我们先来看看这样的需求：我们有一套房产需要出售，但是我们抽不开身去带客户看房对接而且获客方式有限，我们该怎么实现？

在这里插入图片描述

2.代码实现

Talk is cheap，show me your code.

初版实现思路：

​ 既然自己没时间、没客源，可以找个中间人不就行了，这个中间人就是房产代理。

初版代码如下：

//房屋售卖接口
public interface HouseSaleService {void saleHouse();
}

//房东类
public class HouseOwner implements HouseSaleService {@Overridepublic void saleHouse() {System.out.println("我是房东，我签订售房合同");System.out.println("我是房东，售出房源");}
}

//房产中介类
public class ProxyHouse implements HouseSaleService{private HouseSaleService houseSaleService;public ProxyHouse(HouseSaleService houseSaleService) {this.houseSaleService = houseSaleService;}@Overridepublic void saleHouse() {System.out.println("房产中介——开始带客户看房");houseSaleService.saleHouse();System.out.println("房产中介——房源售出，结束");}
}

public class Client {public static void main(String[] args) {HouseSaleService houseSaleService = new HouseOwner();HouseSaleService proxyHouse = new ProxyHouse(houseSaleService);proxyHouse.saleHouse();}
}

输出结果：

在这里插入图片描述

实现代码结构图：

在这里插入图片描述

这个实现过程其实就是代理设计模式，属于代理模式中的静态代理。

3.需求升级

我们现在不是房东了，我们现在是一个中介平台，平台上有千千万万个房东和中介，如果还是实现上述代理买房的需求，交易的流程是一样的，该怎么做呢？不会添加那么多房产代理人吧。

//售房调用处理器类
public class HouseSaleInvocationHandler implements InvocationHandler {//房东private Object target;public HouseSaleInvocationHandler(Object target){this.target = target;}//三个参数：代理对象实例、方法对象（Method）和参数数组@Overridepublic Object invoke(Object proxy, Method method, Object[] args) throws Throwable {System.out.println("动态生成房产中介代理——开始带客户看房");Object result =  method.invoke(target, args);System.out.println("动态生成房产中介代理——房源售出，结束");return result;}//创建动态代理对象public static Object newProxyInstance(Object target){//传入目标对象的类加载器，目标对象实现的接口，调用处理器return Proxy.newProxyInstance(target.getClass().getClassLoader(), target.getClass().getInterfaces(), new HouseSaleInvocationHandler(target));}
}

//客户端（动态代理）
public class Client2 {public static void main(String[] args) {HouseSaleService houseSaleService = (HouseSaleService)HouseSaleInvocationHandler.newProxyInstance(new HouseOwner());houseSaleService.saleHouse();}
}

​ 执行结果：

在这里插入图片描述

​ 上述代码可以实现一套代理流程动态为多个房东生成房产代理，无需手动一个个手动创建。有没有同学觉得很熟悉，看过jdk源码的同学应该很熟悉（详细实现过程见下方源码剖析部分），它是利用java.lang.reflect包下的Proxy和InvocationHandler核心类实现动态代理机制的，又称JDK的动态代理。实现原理：在运行代码时利用反射动态生成代理类，将目标方法的调用都转发到InvocationHandler的invoke方法，利用反射机制执行目标方法并插入增强逻辑。

核心流程如下：

在这里插入图片描述

思考：

​ 上述代码只能解决实现过售卖接口的房东需求，那些没通过实现售卖接口的个人房东好像满足不了他们的需求，所以又有另一种实现方式。

个人房东代码改造：

pom依赖：

<dependency><groupId>cglib</groupId><artifactId>cglib</artifactId><version>3.3.0</version>
</dependency>

//cglib代理类
public class CglibProxyHouse {//获取代理对象public static Object getInstance(Object target) {Enhancer enhancer = new Enhancer();enhancer.setSuperclass(target.getClass());// 设置目标类enhancer.setCallback(new CglibMethodInterceptor());// 设置方法拦截器return enhancer.create();}}

//cglib方法拦截增强类
public class CglibMethodInterceptor implements MethodInterceptor {@Overridepublic Object intercept(Object proxy, Method method, Object[] args, MethodProxy methodProxy) throws Throwable {System.out.println("动态生成房产中介代理———开始带客户看房-CglibProxyHouse");Object result=methodProxy.invokeSuper(proxy, args);// 调用父类（目标类）的方法System.out.println("动态生成房产中介代理———房源售出，结束-CglibProxyHouse");return result;}
}

//个人房东
public class OtherHouseOwner  {public  void saleHouse() {System.out.println("我是个人房东，我签订售房合同");System.out.println("我是个人房东，售出房源");}
}

//Cglib动态代理测试类
public class Client3 {public static void main(String[] args) {OtherHouseOwner houseOwner = (OtherHouseOwner)  CglibProxyHouse.getInstance(new OtherHouseOwner());houseOwner.saleHouse();}
}

运行结果：

在这里插入图片描述

​ 上述代码实现了个人房东动态代理卖房需求，个人房东无需实现响应接口。它利用net.sf.cglib.proxy包下的Enhancer和MethodInterceptor核心类实现动态代理机制的，又称CGLIB动态代理。CGLIB通过继承目标类并重写非final方法，在运行时使用ASM字节码技术动态生成代理子类，将方法调用委托给MethodInterceptor实现增强逻辑，并借助FastClass机制通过方法索引直接调用提升性能。

在这里插入图片描述

动态代理对比：

特性JDK动态代理CGLIB
代理方式实现接口继承目标类
性能反射调用，较慢FastClass调用，较快
依赖无第三方库需CGLIB库
目标类要求必须实现接口不能是final类/方法
初始化开销小大（生成两个FastClass）
方法调用模式通过InvocationHandler通过MethodInterceptor

4.定义

​ 代理设计模式是一种结构型设计模式，其核心思想是提供一个代理对象来控制对原始对象的访问。代理充当原始对象的中间层，允许在访问原始对象前后添加额外逻辑，而无需修改原始对象本身。

组成部分如下：

  1. 代理对象（Proxy）

    • 实现与原始对象相同的接口
    • 持有对原始对象的引用
    • 控制客户端对原始对象的访问

  2. 原始对象（Real Subject）

    • 实际执行业务逻辑的目标对象

  3. 抽象接口（Subject）

    • 定义代理和原始对象的共同接口，确保二者可互换使用

      在这里插入图片描述

5.应用场景

场景类型典型用途实例
虚拟代理延迟创建开销大的对象图片懒加载：代理先显示占位图，真正需要时才加载高清图片
远程代理隐藏远程调用的复杂性RPC框架：代理封装网络通信细节，客户端像调用本地对象一样调用远程服务
保护代理控制访问权限权限校验：代理验证用户权限后再允许访问敏感操作
缓存代理缓存昂贵操作的结果API请求缓存：代理缓存计算结果，重复请求直接返回结果，避免重复计算
日志代理记录访问日志审计系统：代理在方法调用前后记录日志和时间戳
智能引用代理管理对象生命周期自动释放资源：代理统计对象引用计数，引用归零时自动销毁对象

适用性总结

✅ 需要隔离客户端与复杂系统（如远程服务）
✅ 需要延迟初始化高开销对象
✅ 需添加访问控制或安全层
✅ 需透明添加日志、监控等横切关注点
✅ 需实现智能引用（如对象池、缓存）

典型场景：

​ Spring AOP 的底层机制完全基于代理模式实现，通过动态代理在运行时生成代理对象，将切面逻辑（如日志、事务等）织入目标方法中。其具体实现分为两种机制：JDK 动态代理和CGLIB 代理，由 Spring 根据目标类的特性自动选择或通过配置强制指定。目标类实现了接口，使用JDK 动态代理；目标类未实现接口，CGLIB 代理，也可强制指定。

源码剖析

1.JDK动态代理

1.1 Proxy.newProxyInstance() 入口方法
public static Object newProxyInstance(ClassLoader loader,Class<?>[] interfaces,InvocationHandler h) {// 1. 验证接口和处理器有效性Objects.requireNonNull(h);final Class<?>[] intfs = interfaces.clone();// 2. 获取或生成代理类Class<?> cl = getProxyClass0(loader, intfs);try {// 3. 获取代理类构造器final Constructor<?> cons = cl.getConstructor(constructorParams);// 4. 创建代理实例return cons.newInstance(new Object[]{h});} catch (IllegalAccessException|InstantiationException e) {// 异常处理...}
}
1.2 代理类生成机制（getProxyClass0）
private static Class<?> getProxyClass0(ClassLoader loader,Class<?>... interfaces) {// 1. 接口数量限制(最多65535个)if (interfaces.length > 65535) {throw new IllegalArgumentException("interface limit exceeded");}// 2. 从缓存获取或生成代理类return proxyClassCache.get(loader, interfaces);
}

代理类缓存使用WeakCache实现，核心逻辑在ProxyClassFactory中：

private static final class ProxyClassFactoryimplements BiFunction<ClassLoader, Class<?>[], Class<?>>
{@Overridepublic Class<?> apply(ClassLoader loader, Class<?>[] interfaces) {// 1. 生成唯一代理类名long num = nextUniqueNumber.getAndIncrement();String proxyName = proxyPkg + proxyClassNamePrefix + num;// 2. 生成代理类字节码byte[] proxyClassFile = ProxyGenerator.generateProxyClass(proxyName, interfaces, accessFlags);// 3. 定义代理类return defineClass0(loader, proxyName,proxyClassFile, 0, proxyClassFile.length);}
}
1.3 代理类字节码生成（ProxyGenerator）

generateProxyClass方法生成代理类的字节码，其核心逻辑如下：

public static byte[] generateProxyClass(final String name,Class<?>[] interfaces,int accessFlags) {ProxyGenerator gen = new ProxyGenerator(name, interfaces, accessFlags);// 真正生成字节码final byte[] classFile = gen.generateClassFile();// 可选项：保存生成的字节码到文件（调试用）if (saveGeneratedFiles) {java.security.AccessController.doPrivileged(new java.security.PrivilegedAction<Void>() {public Void run() {try {FileOutputStream file = new FileOutputStream(dotToSlash(name) + ".class");file.write(classFile);file.close();} catch (IOException e) { /* 忽略 */ }return null;}});}return classFile;
}
1.4 生成的代理类结构（反编译示例）

假设我们代理HouseSaleService接口，生成的$Proxy0.class反编译后：

public final class $Proxy0 extends Proxy implements HouseSaleService {private static Method m1;  // hashCode()private static Method m2;  // equals()private static Method m3;  // toString()private static Method m4;  // saleHouse()static {try {m1 = Class.forName("java.lang.Object").getMethod("hashCode");m2 = Class.forName("java.lang.Object").getMethod("equals", Class.forName("java.lang.Object"));m3 = Class.forName("java.lang.Object").getMethod("toString");m4 = Class.forName("com.example.HouseSaleService").getMethod("saleHouse");} catch (NoSuchMethodException e) { /* 处理异常 */ }}public $Proxy0(InvocationHandler h) {super(h);  // 调用Proxy的构造函数}public final void saleHouse() {try {// 关键：调用InvocationHandler的invoke方法super.h.invoke(this, m4, null);} catch (RuntimeException | Error e) {throw e;} catch (Throwable e) {throw new UndeclaredThrowableException(e);}}// 其他Object方法实现类似...
}

代理对象实现目标接口，方法调用里其实还是调用InvocationHandler的invoke方法。

2.CGLIB动态代理

2.1Enhancer 入口类

创建代理对象通常使用以下代码：

Enhancer enhancer = new Enhancer();
enhancer.setSuperclass(TargetClass.class); // 设置目标类
enhancer.setCallback(new MyMethodInterceptor()); // 设置回调（拦截器）
TargetClass proxy = (TargetClass) enhancer.create(); // 生成代理对象
2.2 enhancer.create() 方法调用链
// Enhancer.java
public Object create() {// 关键：不使用参数return createHelper();
}private Object createHelper() {// 1. 验证回调类型preValidate();// 2. 生成代理类Class<?> proxyClass = createClass();// 3. 创建代理实例return createUsingReflection(proxyClass);
}
2.3 代理类生成（createClass）
// AbstractClassGenerator.java
protected Class<?> createClass() {// 使用字节码生成器生成字节码byte[] b = strategy.generate(this);// 定义类return ReflectUtils.defineClass(getClassName(), b, loader);
}
2.4 字节码生成核心：Enhancer.generateClass

CGLIB通过ASM库直接操作字节码，关键逻辑在Enhancer.generateClass方法中：

// Enhancer.java
public void generateClass(ClassVisitor v) {// 1. 创建类结构ClassEmitter ce = new ClassEmitter(v);ce.begin_class(/* 版本号 */, ACC_PUBLIC, getClassName(), getSuperclass(), getInterfaces(), "<generated>");// 2. 添加字段ce.declare_field(ACC_PRIVATE, BOUND_FIELD, Type.BOOLEAN_TYPE, null);ce.declare_field(ACC_PRIVATE, THREAD_CALLBACKS_FIELD, THREAD_LOCAL, null);ce.declare_field(ACC_PRIVATE, STATIC_CALLBACKS_FIELD, CALLBACK_ARRAY, null);// 3. 生成构造函数generateConstructor(ce);// 4. 生成回调设置方法generateSetCallbacks(ce);generateSetCallback(ce);generateGetCallback(ce);// 5. 重写目标方法for (Method method : getMethods()) {generateMethod(ce, method);}ce.end_class();
}
2.5 方法生成逻辑（generateMethod）
// Enhancer.java
private void generateMethod(ClassEmitter ce, Method method) {// 1. 创建方法签名Signature sig = ReflectUtils.getSignature(method);// 2. 创建方法体CodeEmitter e = ce.begin_method(ACC_PUBLIC, sig, null);// 3. 获取回调e.load_this();e.getfield(CALLBACK_FIELD);// 4. 检查回调是否存在Label noCallback = e.make_label();e.dup();e.ifnull(noCallback);// 5. 准备调用参数e.push(method);e.create_arg_array();e.push(methodProxy);// 6. 调用拦截器e.invoke_interface(METHOD_INTERCEPTOR_TYPE, new Signature("intercept", Type.OBJECT, new Type[]{TYPE_OBJECT, TYPE_METHOD, TYPE_OBJECT_ARRAY, TYPE_METHOD_PROXY}));// 7. 结果处理e.unbox_or_zero(e.getReturnType());e.return_value();// 8. 没有回调时的处理e.mark(noCallback);e.pop();// 调用原始方法super.generateMethod(ce, method);e.return_value();e.end_method();
}
2.6 生成的代理类结构（反编译示例）

使用CGLIB代理后生成的代理类大致如下：

public class OtherHouseOwner$$EnhancerByCGLIB$$12345678 extends OtherHouseOwner implements Factory {private MethodInterceptor interceptor;private static final Method CGLIB$saleHouse$0$Method;private static final MethodProxy CGLIB$saleHouse$0$Proxy;static {// 初始化目标方法和代理方法CGLIB$saleHouse$0$Method = ReflectUtils.findMethods(new String[]{"saleHouse", "()V"}).get(0);CGLIB$saleHouse$0$Proxy = MethodProxy.create(OtherHouseOwner.class, OtherHouseOwner$$EnhancerByCGLIB$$12345678.class, "()V", "saleHouse", "CGLIB$saleHouse$0");}// 重写目标方法public final void saleHouse() {MethodInterceptor tmp = this.interceptor;if (tmp == null) {super.saleHouse(); // 如果未设置拦截器，直接调用父类方法} else {// 调用拦截器的intercept方法tmp.intercept(this, CGLIB$saleHouse$0$Method, new Object[0], CGLIB$saleHouse$0$Proxy);}}// 原始方法的直接调用（避免拦截）final void CGLIB$saleHouse$0() {super.saleHouse();}// 其他方法...
}

如果未设置拦截器，直接调用父类方法；如果有设置方法拦截器，直接回调拦截器方法。

2.7 MethodProxy 工作原理

MethodProxy是CGLIB高效调用的关键，它通过生成两个FastClass（目标类FastClass和代理类FastClass）实现快速方法调用。

// MethodProxy.java
public Object invoke(Object obj, Object[] args) throws Throwable {try {// 使用目标类的FastClass直接调用原始方法return fastClass.invoke(targetIndex, obj, args);} catch (InvocationTargetException e) {throw e.getTargetException();}
}public Object invokeSuper(Object obj, Object[] args) throws Throwable {try {// 使用代理类的FastClass调用代理类中的原始方法（即CGLIB$xxx方法）return fastClass.invoke(superIndex, obj, args);} catch (InvocationTargetException e) {throw e.getTargetException();}
}
2.8 FastClass 机制

FastClass为每个方法分配一个索引（index），通过索引直接调用方法，避免反射开销。

// 生成的TargetFastClass
public Object invoke(int index, Object obj, Object[] args) {OtherHouseOwner otherHouseOwner = (OtherHouseOwner) obj;switch (index) {case 0:otherHouseOwner.saleHouse();return null;// 其他方法...}
}// 生成的ProxyFastClass
public Object invoke(int index, Object obj, Object[] args) {OtherHouseOwner$$EnhancerByCGLIB proxy = (OtherHouseOwner$$EnhancerByCGLIB) obj;switch (index) {case 0:proxy.CGLIB$saleHouse$0();return null;// 其他方法...}
}

法，避免反射开销。

// 生成的TargetFastClass
public Object invoke(int index, Object obj, Object[] args) {OtherHouseOwner otherHouseOwner = (OtherHouseOwner) obj;switch (index) {case 0:otherHouseOwner.saleHouse();return null;// 其他方法...}
}// 生成的ProxyFastClass
public Object invoke(int index, Object obj, Object[] args) {OtherHouseOwner$$EnhancerByCGLIB proxy = (OtherHouseOwner$$EnhancerByCGLIB) obj;switch (index) {case 0:proxy.CGLIB$saleHouse$0();return null;// 其他方法...}
}

技术需要沉淀，同样生活也是~
个人链接：博客，欢迎一起交流

相关文章：

  • redisTemplate简单实现幂等性校验
  • 机器人 URDF学习笔记
  • 51单片机教程（十三）- 单片机串口通信
  • mac docker desktop 安装 oracle
  • 并发基础7（守护线程）
  • Python基础知识之文件
  • 快慢指针深度解析
  • NV025NV033美光固态闪存NV038NV040
  • 机器人领域EI论文写作突围指南：从创新点到技术落地的关键跨越
  • 工厂“智能指挥家”上线，富唯智能调度系统让机器人高效协作
  • 车载通信架构 --- ECU刷写与busoff原则
  • VSCode中创建和生成动态库项目
  • vue3+element-plus,实现两个表格同步滚动
  • RabbitMQ RPC模式Python示例
  • 基于[coze][dify]搭建一个智能体工作流，抓取热门视频数据，自动存入在线表格
  • 【C++特殊工具与技术】固有的不可移植的特性(3)::extern“C“
  • 《C++初阶之类和对象》【友元 + 内部类 + 匿名对象】
  • 【.net core】【sqlsugar】在where条件查询时使用原生SQL
  • 清理华为云服务器内存使用率
  • 2025-6-27-C++ 学习 模拟与高精度（7）