代理模式深度解析

发布于：2025-04-17 ⋅ 阅读:(28) ⋅ 点赞:(0)

目录

一 静态代理

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. 构造函数调用问题

六、应用场景

一 静态代理

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

1.1 优点

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

1.2 缺点

  1. 冗余代码：每个目标类都需要手动编写对应的代理类，代码量大。
  2. 灵活性差：代理关系在编译期固定，无法动态切换代理逻辑。
  3. 接口依赖：若目标类没有实现接口，则无法使用静态代理（需通过继承实现，类似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;
    }
}

网站公告

今日签到

点亮在社区的每一天
去签到

热门文章

最新发布