代理模式深度解析

[一静态代理](#一静态代理)

[1.1 优点](#1.1 优点)

[1.2 缺点](#1.2 缺点)

[1.3 适用场景](#1.3 适用场景)

[二 JDK动态代理](#二 JDK动态代理)

[1 JDK动态代理的工作原理](#1 JDK动态代理的工作原理)

[1.1 创建代理类](#1.1 创建代理类)

[1.2 加载代理类](#1.2 加载代理类)

[1.3 实现方法调用](#1.3 实现方法调用)

[2. Proxy.newProxyInstance() 的核心工作流程](#2. Proxy.newProxyInstance() 的核心工作流程)

方法签名

工作步骤

[3. 代理类的生成与加载](#3. 代理类的生成与加载)

[3.1 代理类生成的关键方法](#3.1 代理类生成的关键方法)

Proxy.getProxyClass()

ProxyGenerator.generateProxyClass()

[3.2 代理类的加载](#3.2 代理类的加载)

代理类是如何加载的？

代理类加载的时机

[三 CGLIB动态代理](#三 CGLIB动态代理)

[1. 代理方式](#1. 代理方式)

[2. 核心组件](#2. 核心组件)

二、字节码生成

[1. 动态生成原理](#1. 动态生成原理)

[2. 性能优化](#2. 性能优化)

[3. 示例：生成的字节码文件（伪代码）](#3. 示例：生成的字节码文件（伪代码）)

三、类加载与代理对象创建

[1. 类加载流程](#1. 类加载流程)

[2. 突破限制](#2. 突破限制)

[四、与 JDK 动态代理的关键区别](#四、与 JDK 动态代理的关键区别)

五、典型限制与解决方案

[1. 无法代理 final 方法/类](#1. 无法代理 final 方法/类)

[2. 构造函数调用问题](#2. 构造函数调用问题)

六、应用场景

一静态代理

静态代理就是手动编写代理类，在编译期就确定代理关系，并让代理类和目标类实现相同的接口。代理类通过调用目标类的方法来完成任务，同时可以在调用前后添加一些额外的操作。

1.1 优点

简单直观：代码结构清晰，易于理解和实现。
无侵入性：无需修改目标类代码，通过代理类实现功能增强。
性能好：代理逻辑在编译期确定，没有动态生成的额外开销。

1.2 缺点

冗余代码：每个目标类都需要手动编写对应的代理类，代码量大。
灵活性差：代理关系在编译期固定，无法动态切换代理逻辑。
接口依赖：若目标类没有实现接口，则无法使用静态代理（需通过继承实现，类似CGLIB的思路，但需要手动编写）。

1.3 适用场景

需要代理的类数量较少。
代理逻辑简单且无需频繁变更。
对性能要求高，避免动态代理的开销。

复制代码

public interface BaseSimpleService {

    public void save(Object obj);

}

@Slf4j
public class BaseSimpleServiceImpl implements BaseSimpleService {

    @Override
    public void save(Object obj) {
        System.out.println("对象保存成功");
    }

}

/**
 * 对 BaseSimpleService类做一个增强，在不侵入原业务代码的基础上，实现日志记录
 */
@Slf4j
public class SimpleServiceProxy {

    private BaseSimpleService baseSimpleService;

    // 注入原对象
    public SimpleServiceProxy(BaseSimpleService baseSimpleService){
        this.baseSimpleService=baseSimpleService;
    }

    public void save(Object obj) {
        log.info("save obj:{}",obj);
        baseSimpleService.save(obj);
        log.info("保存: {}对象成功",obj);
    }
}

public class TestProxy {
    public static void main(String[] args) {
        // 基础实现
        BaseSimpleService baseService=new BaseSimpleServiceImpl();
        Object obj = new Object();
        baseService.save(obj);

        // 静态代理实现
        SimpleServiceProxy simpleServiceProxy=new SimpleServiceProxy(baseService);
        simpleServiceProxy.save(obj);
        // 原对象不受代理影响
        baseService.save(obj);
    }
}

二 JDK动态代理

JDK动态代理的实现基于反射和类加载器，通过 Proxy.newProxyInstance() 方法在运行时动态生成代理类，并将其加载到JVM中。

1 JDK动态代理的工作原理

Proxy.newProxyInstance()是JDK动态代理的核心方法，它会动态生成一个代理类，并返回该代理类的实例(即代理对象)。代理类的生成和加载涉及以下核心步骤

1.1 创建代理类

当调用 Proxy.newProxyInstance() 时，JVM 会动态生成一个代理类 ，该代理类继承自 java.lang.reflect.Proxy 并实现目标对象的接口。
代理类的名称是动态生成的，形如 com.sun.proxy.$Proxy0。$Proxy0 是 JDK 动态代理生成的代理类的默认命名规则。

1.2 加载代理类

生成的代理类会通过指定的类加载器（ClassLoader）加载到 JVM 中。
代理类的字节码在内存中生成，并不会保存为 .class 文件。

1.3 实现方法调用

代理类会实现目标接口的所有方法，但这些方法的逻辑会被重定向到 InvocationHandler 的 invoke() 方法。
代理类中，方法的实际调用行为是通过反射来完成的。

2. Proxy.newProxyInstance() 的核心工作流程

方法签名

复制代码

public static Object newProxyInstance(ClassLoader loader,
                                      Class<?>[] interfaces,
                                      InvocationHandler h)

工作步骤

1 校验参数：

- 检查 ClassLoader 是否为 null。
- 检查 interfaces 是否为空，并确保所有接口都是有效的（如不能是 final 接口）。
- 检查 InvocationHandler 是否为 null。

2 生成代理类：

- 调用 Proxy 类的私有方法 getProxyClass0()，动态生成代理类的字节码。
- 代理类的字节码是通过 sun.misc.ProxyGenerator 工具生成的。

3 加载代理类：

- 使用指定的 ClassLoader 将代理类的字节码加载到 JVM 中。

4 实例化代理类对象：

- 调用代理类的构造方法，传入 InvocationHandler 对象。
- 返回动态生成的代理类的实例（即代理对象 )，它继承自 java.lang.reflect.Proxy 并实现了 Service 接口。

3. 代理类的生成与加载

3.1 代理类生成的关键方法

Proxy.getProxyClass()

该方法通过目标接口数组生成代理类。
代理类的字节码由 sun.misc.ProxyGenerator 工具生成。
代理类继承自 java.lang.reflect.Proxy，并实现了目标接口。

Class<?> proxyClass = Proxy.getProxyClass(loader, interfaces);

ProxyGenerator.generateProxyClass()

生成代理类的字节码。
代理类的每个方法都会调用 InvocationHandler.invoke()。
字节码存储在内存中，并不会生成 .class 文件。

3.2 代理类的加载

代理类是如何加载的？

代理类的字节码通过 ClassLoader 加载到 JVM 中。
加载时会为代理类分配内存，并将其方法表注册到 JVM 的方法区中。

代理类加载的时机

代理类是在 Proxy.newProxyInstance() 调用时动态生成并加载的。

每次调用 newProxyInstance() 都会检查是否已存在对应接口的代理类。如果已存在，则直接加载；否则，重新生成代理类。

import lombok.extern.slf4j.Slf4j;

import java.lang.reflect.InvocationHandler;
import java.lang.reflect.Method;

// 目标接口
interface BaseSimpleService {

复制代码

  public void save(Object obj);

}

// 接口实现类
class BaseSimpleServiceImpl implements BaseSimpleService {

复制代码

  @Override
  public void save(Object obj) {
      System.out.println("对象保存成功");
  }

}

// 调用处理器不改变目标对象方法的基础上记录日志
@Slf4j
class JdkLoggingInvocationHandler implements InvocationHandler {

复制代码

  private Object target;

  public JdkLoggingInvocationHandler(Object target) {
      this.target = target;
  }

  @Override
  public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
      log.info("save obj:{}",args);
      Object result = method.invoke(target, args);
      log.info("保存: {}对象成功",args);
      return result;
  }

}

import java.lang.reflect.Proxy;

public class TestProxy {
public static void main(String[] args) {
BaseSimpleService baseSimpleService=new BaseSimpleServiceImpl();
JdkLoggingInvocationHandler handler=new JdkLoggingInvocationHandler(baseSimpleService);

复制代码

      // 该实例具有代理类的指定调用处理程序，该代理类由指定的类加载器定义并实现指定的接口
      // simpleServiceProxy代理类由指定的类加载器加载 并实现了BaseSimpleService的接口
      BaseSimpleService simpleServiceProxy = (BaseSimpleService) Proxy.newProxyInstance(
              baseSimpleService.getClass().getClassLoader(), 
              baseSimpleService.getClass().getInterfaces(),
              handler);

      simpleServiceProxy.save(new Object());
  }

}

三 CGLIB动态代理

CGLIB（Code Generation Library）是一个基于字节码生成的第三方库，用于在运行时动态生成Java类的子类，从而实现对目标类的代理。它主要用于代理没有实现接口的类，解决了JDK动态代理只能基于接口的局限性。其核心原理如下：

1. 代理方式

继承式代理 ：生成目标类的子类（如 UserService$$EnhancerByCGLIB$$123456），通过重写父类非 final 方法实现代理。
无需接口：直接代理普通类，弥补 JDK 动态代理的局限性。
代理类会重写目标方法，并在方法中插入拦截逻辑

2. 核心组件

Enhancer ：
负责生成代理类，配置代理策略（如回调方法、类加载器）。

复制代码

      // 创建 CGLIB 代理的 Enhancer对象
      Enhancer enhancer=new Enhancer();

      // 设置代理的目标类
      // CGLIB通过继承这个目标类来生成代理类
      enhancer.setSuperclass(BaseService.class);

      // 设置方法拦截器，代理会调用这个拦截器
      enhancer.setCallback(new CglibLoggingMethodInterceptor(baseService));

      // 创建代理对象 当前的代理对象不是原始对象了 而是通过继承目标类BaseService得到的新类
      BaseService baseServiceProxy = (BaseService) enhancer.create();

      baseServiceProxy.save(new Object());

MethodInterceptor ：
代理类的方法调用会被转发到MethodInterceptor接口的intercept方法中，实现增强逻辑。

/**
- obj: 代理对象本身
- method: 被拦截的方法(目标方法的反射对象)
- args: 方法参数
- proxy: 方法代理对象，用于调用父类(目标类)的原始方法
  */
  public Object intercept(Object obj, Method method, Object[] args, MethodProxy proxy)
  throws Throwable {
  // 前置增强（如日志）
  Object result = proxy.invokeSuper(obj, args); // 调用父类（目标类）原始方法
  // 后置增强（如事务提交）
  return result;
  }

二、字节码生成

1. 动态生成原理

基于 ASM ：直接操作字节码生成 .class 文件的二进制内容，避免源码编译。
方法重写 ：
生成子类时，为每个非 final 方法生成重写版本，插入拦截逻辑（调用 MethodInterceptor）。

2. 性能优化

FastClass 机制 ：
为代理类和目标类的方法建立索引，直接通过索引调用方法，绕过了反射的Method.invoke()，提升了性能。

// FastClass 通过索引调用方法（伪代码）
public Object invoke(int methodIndex, Object obj, Object[] args) {
switch (methodIndex) {
case 0: return ((TargetClass)obj).method1();
case 1: return ((TargetClass)obj).method2();
}
}

3. 示例：生成的字节码文件（伪代码）

生成的代理类可能如下（简化后的伪代码）：

复制代码

//
// Source code recreated from a .class file by IntelliJ IDEA
// (powered by Fernflower decompiler)
//
public class Cat$$EnhancerByCGLIB$$8ca2de8b extends Cat implements Factory {
    private boolean CGLIB$BOUND;
    public static Object CGLIB$FACTORY_DATA;
    private static final ThreadLocal CGLIB$THREAD_CALLBACKS;
    private static final Callback[] CGLIB$STATIC_CALLBACKS;
    private MethodInterceptor CGLIB$CALLBACK_0;
    private static Object CGLIB$CALLBACK_FILTER;
    private static final Method CGLIB$sleep$0$Method;
    private static final MethodProxy CGLIB$sleep$0$Proxy;
    private static final Object[] CGLIB$emptyArgs;
    private static final Method CGLIB$wakeup$1$Method;
    private static final MethodProxy CGLIB$wakeup$1$Proxy;
    private static final Method CGLIB$equals$2$Method;
    private static final MethodProxy CGLIB$equals$2$Proxy;
    private static final Method CGLIB$toString$3$Method;
    private static final MethodProxy CGLIB$toString$3$Proxy;
    private static final Method CGLIB$hashCode$4$Method;
    private static final MethodProxy CGLIB$hashCode$4$Proxy;
    private static final Method CGLIB$clone$5$Method;
    private static final MethodProxy CGLIB$clone$5$Proxy;

    static void CGLIB$STATICHOOK4() {
        CGLIB$THREAD_CALLBACKS = new ThreadLocal();
        CGLIB$emptyArgs = new Object[0];
        Class var0 = Class.forName("com.example.demo.cglibproxy.vo.Cat$$EnhancerByCGLIB$$8ca2de8b");
        Class var1;
        Method[] var10000 = ReflectUtils.findMethods(new String[]{"equals", "(Ljava/lang/Object;)Z", "toString", "()Ljava/lang/String;", "hashCode", "()I", "clone", "()Ljava/lang/Object;"}, (var1 = Class.forName("java.lang.Object")).getDeclaredMethods());
        CGLIB$equals$2$Method = var10000[0];
        CGLIB$equals$2$Proxy = MethodProxy.create(var1, var0, "(Ljava/lang/Object;)Z", "equals", "CGLIB$equals$2");
        CGLIB$toString$3$Method = var10000[1];
        CGLIB$toString$3$Proxy = MethodProxy.create(var1, var0, "()Ljava/lang/String;", "toString", "CGLIB$toString$3");
        CGLIB$hashCode$4$Method = var10000[2];
        CGLIB$hashCode$4$Proxy = MethodProxy.create(var1, var0, "()I", "hashCode", "CGLIB$hashCode$4");
        CGLIB$clone$5$Method = var10000[3];
        CGLIB$clone$5$Proxy = MethodProxy.create(var1, var0, "()Ljava/lang/Object;", "clone", "CGLIB$clone$5");
        var10000 = ReflectUtils.findMethods(new String[]{"sleep", "()V", "wakeup", "()V"}, (var1 = Class.forName("com.example.demo.cglibproxy.vo.Cat")).getDeclaredMethods());
        CGLIB$sleep$0$Method = var10000[0];
        CGLIB$sleep$0$Proxy = MethodProxy.create(var1, var0, "()V", "sleep", "CGLIB$sleep$0");
        CGLIB$wakeup$1$Method = var10000[1];
        CGLIB$wakeup$1$Proxy = MethodProxy.create(var1, var0, "()V", "wakeup", "CGLIB$wakeup$1");
    }

    final void CGLIB$sleep$0() {
        super.sleep();
    }

    public final void sleep() {
        MethodInterceptor var10000 = this.CGLIB$CALLBACK_0;
        if (this.CGLIB$CALLBACK_0 == null) {
            CGLIB$BIND_CALLBACKS(this);
            var10000 = this.CGLIB$CALLBACK_0;
        }

        if (var10000 != null) {
            var10000.intercept(this, CGLIB$sleep$0$Method, CGLIB$emptyArgs, CGLIB$sleep$0$Proxy);
        } else {
            super.sleep();
        }
    }

    final void CGLIB$wakeup$1() {
        super.wakeup();
    }

    public final void wakeup() {
        MethodInterceptor var10000 = this.CGLIB$CALLBACK_0;
        if (this.CGLIB$CALLBACK_0 == null) {
            CGLIB$BIND_CALLBACKS(this);
            var10000 = this.CGLIB$CALLBACK_0;
        }

        if (var10000 != null) {
            var10000.intercept(this, CGLIB$wakeup$1$Method, CGLIB$emptyArgs, CGLIB$wakeup$1$Proxy);
        } else {
            super.wakeup();
        }
    }

    public static MethodProxy CGLIB$findMethodProxy(Signature var0) {
        String var10000 = var0.toString();
        switch(var10000.hashCode()) {
        case -1385928386:
            if (var10000.equals("sleep()V")) {
                return CGLIB$sleep$0$Proxy;
            }
            break;
        case -508378822:
            if (var10000.equals("clone()Ljava/lang/Object;")) {
                return CGLIB$clone$5$Proxy;
            }
            break;
        case 391780310:
            if (var10000.equals("wakeup()V")) {
                return CGLIB$wakeup$1$Proxy;
            }
            break;
        case 1826985398:
            if (var10000.equals("equals(Ljava/lang/Object;)Z")) {
                return CGLIB$equals$2$Proxy;
            }
            break;
        case 1913648695:
            if (var10000.equals("toString()Ljava/lang/String;")) {
                return CGLIB$toString$3$Proxy;
            }
            break;
        case 1984935277:
            if (var10000.equals("hashCode()I")) {
                return CGLIB$hashCode$4$Proxy;
            }
        }

        return null;
    }

    public Cat$$EnhancerByCGLIB$$8ca2de8b() {
        CGLIB$BIND_CALLBACKS(this);
    }

    public Cat$$EnhancerByCGLIB$$8ca2de8b(String var1) {
        super(var1);
        CGLIB$BIND_CALLBACKS(this);
    }

    public static void CGLIB$SET_THREAD_CALLBACKS(Callback[] var0) {
        CGLIB$THREAD_CALLBACKS.set(var0);
    }

    public static void CGLIB$SET_STATIC_CALLBACKS(Callback[] var0) {
        CGLIB$STATIC_CALLBACKS = var0;
    }

    private static final void CGLIB$BIND_CALLBACKS(Object var0) {
        Cat$$EnhancerByCGLIB$$8ca2de8b var1 = (Cat$$EnhancerByCGLIB$$8ca2de8b)var0;
        if (!var1.CGLIB$BOUND) {
            var1.CGLIB$BOUND = true;
            Object var10000 = CGLIB$THREAD_CALLBACKS.get();
            if (var10000 == null) {
                var10000 = CGLIB$STATIC_CALLBACKS;
                if (CGLIB$STATIC_CALLBACKS == null) {
                    return;
                }
            }

            var1.CGLIB$CALLBACK_0 = (MethodInterceptor)((Callback[])var10000)[0];
        }

    }

    public Object newInstance(Callback[] var1) {
        CGLIB$SET_THREAD_CALLBACKS(var1);
        Cat$$EnhancerByCGLIB$$8ca2de8b var10000 = new Cat$$EnhancerByCGLIB$$8ca2de8b();
        CGLIB$SET_THREAD_CALLBACKS((Callback[])null);
        return var10000;
    }

    public Object newInstance(Callback var1) {
        CGLIB$SET_THREAD_CALLBACKS(new Callback[]{var1});
        Cat$$EnhancerByCGLIB$$8ca2de8b var10000 = new Cat$$EnhancerByCGLIB$$8ca2de8b();
        CGLIB$SET_THREAD_CALLBACKS((Callback[])null);
        return var10000;
    }

    public Object newInstance(Class[] var1, Object[] var2, Callback[] var3) {
        CGLIB$SET_THREAD_CALLBACKS(var3);
        Cat$$EnhancerByCGLIB$$8ca2de8b var10000 = new Cat$$EnhancerByCGLIB$$8ca2de8b;
        switch(var1.length) {
        case 0:
            var10000.<init>();
            break;
        case 1:
            if (var1[0].getName().equals("java.lang.String")) {
                var10000.<init>((String)var2[0]);
                break;
            }

            throw new IllegalArgumentException("Constructor not found");
        default:
            throw new IllegalArgumentException("Constructor not found");
        }

        CGLIB$SET_THREAD_CALLBACKS((Callback[])null);
        return var10000;
    }

    public Callback getCallback(int var1) {
        CGLIB$BIND_CALLBACKS(this);
        MethodInterceptor var10000;
        switch(var1) {
        case 0:
            var10000 = this.CGLIB$CALLBACK_0;
            break;
        default:
            var10000 = null;
        }

        return var10000;
    }

    public void setCallback(int var1, Callback var2) {
        switch(var1) {
        case 0:
            this.CGLIB$CALLBACK_0 = (MethodInterceptor)var2;
        default:
        }
    }

    public Callback[] getCallbacks() {
        CGLIB$BIND_CALLBACKS(this);
        return new Callback[]{this.CGLIB$CALLBACK_0};
    }

    public void setCallbacks(Callback[] var1) {
        this.CGLIB$CALLBACK_0 = (MethodInterceptor)var1[0];
    }

    static {
        CGLIB$STATICHOOK4();
    }
}

三、类加载与代理对象创建

1. 类加载流程

动态加载：生成的字节码通过类加载器（默认目标类的 ClassLoader）加载到 JVM。
缓存优化：已生成的代理类会被缓存，避免重复生成。

2. 突破限制

绕过构造函数 ：
使用 Objenesis 库直接实例化代理对象，无需调用父类构造函数（即使父类有无参构造）。

Objenesis objenesis = new ObjenesisStd();
TargetClass proxy = objenesis.newInstance(proxyClass); // 直接实例化

四、与 JDK 动态代理的关键区别

|--------|-------------------|--------------|
| 特性 | CGLIB | JDK 动态代理 |
| 代理方式 | 继承目标类生成子类 | 实现目标接口 |
| 目标要求 | 不能是 final 类/方法 | 必须实现接口 |
| 方法调用速度 | 快（FastClass 直接调用） | 慢（反射调用） |
| 内存消耗 | 较高（需生成子类） | 较低 |

五、典型限制与解决方案

1. 无法代理 final 方法/类

表现：若目标类或方法是 final，CGLIB 无法生成子类。
解决：重构代码移除 final 修饰，或改用 JDK 动态代理。

2. 构造函数调用问题

表现：代理类会调用父类构造函数，若父类没有无参构造函数会报错。
解决：使用 Objenesis 绕过构造函数（需添加依赖）。

六、应用场景

Spring AOP：默认对未实现接口的类使用 CGLIB 代理。
性能敏感场景：如高频调用的工具类增强。

历史代码扩展：无法修改原有类/接口时，直接代理实现功能增强。

import org.springframework.cglib.proxy.Enhancer;

public class TestProxy {
public static void main(String[] args) {
BaseService baseService=new BaseService();

复制代码

      // 创建 CGLIB 代理的 Enhancer对象
      Enhancer enhancer=new Enhancer();

      // 设置代理的目标类
      // CGLIB通过继承这个目标类来生成代理类
      enhancer.setSuperclass(BaseService.class);

      // 设置方法拦截器，代理会调用这个拦截器
      enhancer.setCallback(new CglibLoggingMethodInterceptor(baseService));

      // 创建代理对象 当前的代理对象不是原始对象了 而是通过继承目标类BaseService得到的新类
      BaseService baseServiceProxy = (BaseService) enhancer.create();

      baseServiceProxy.save(new Object());

  }

}

import lombok.extern.slf4j.Slf4j;
import org.springframework.cglib.proxy.MethodInterceptor;
import org.springframework.cglib.proxy.MethodProxy;
import java.lang.reflect.Method;

/**

目标类
*/
class BaseService {

public void save(Object obj) {
System.out.println("对象保存成功");
}

}

@Slf4j
public class CglibLoggingMethodInterceptor implements MethodInterceptor {

复制代码

  private Object target;

  public CglibLoggingMethodInterceptor(Object target) {
      this.target = target;
  }

  @Override
  public Object intercept(Object obj, Method method, Object[] args, MethodProxy proxy) throws Throwable {
      log.info("save obj:{}",args);
      // 调用父类方法
      Object result = proxy.invokeSuper(obj, args);
      log.info("保存: {}对象成功",args);
      return result;
  }

}

代理模式深度解析

一 静态代理

1.1 优点

1.2 缺点

1.3 适用场景

二 JDK动态代理

1 JDK动态代理的工作原理

1.1 创建代理类

1.2 加载代理类

1.3 实现方法调用

2. Proxy.newProxyInstance() 的核心工作流程

方法签名

工作步骤

3. 代理类的生成与加载

3.1 代理类生成的关键方法

Proxy.getProxyClass()

ProxyGenerator.generateProxyClass()

3.2 代理类的加载

代理类是如何加载的？

代理类加载的时机

三 CGLIB动态代理

1. 代理方式

2. 核心组件

二、字节码生成

1. 动态生成原理

2. 性能优化

3. 示例：生成的字节码文件（伪代码）

三、类加载与代理对象创建

1. 类加载流程

2. 突破限制

四、与 JDK 动态代理的关键区别

五、典型限制与解决方案

1. 无法代理 final 方法/类

2. 构造函数调用问题

六、应用场景

一静态代理