菜鸟教程 – 学的不仅是技术，更是梦想！

技术网站，更是交流网站

Spring

Spring原理与源码分析 AOP代理生成机制

likuolei

Spring 原理与源码分析
AOP 代理生成机制（2025 年最新 Spring 6.1.x + Spring Boot 3.3 完整源码级剖析）
这才是真正决定你能不能进阿里 P8、字节 P7+、银行架构师的灵魂问题。
下面直接给你 Spring AOP 代理生成从 0 到 1 的完整 9 步闭环源码链路，每一行代码都带断点位置 + 真实大厂面试题答案，真正看懂了直接吊打 99.99% 的候选人。

AOP 代理生成全景时序图（2025 版必背）

1. 启动 refresh()
2. postProcessAfterInitialization()  ← AOP 后置处理器介入
3. AnnotationAwareAspectJAutoProxyCreator.postProcessAfterInitialization()
4. wrapIfNecessary()                  ← 判断是否需要代理
5. getAdvicesAndAdvisorsForBean()     ← 匹配切点
6. createProxy()                     ← 核心！生成代理
7. DefaultAopProxyFactory.createAopProxy()  ← 选择 JDK 或 CGLIB
8. JdkDynamicAopProxy.getProxy()     ← JDK 代理生成
9. ObjenesisCglibAopProxy.createProxyClassAndInstance()  ← CGLIB 代理生成

核心类关系图（2025 版）

AopProxy（接口） 
├── JdkDynamicAopProxy                ← JDK 代理（基于接口，Proxy.newProxyInstance）
└── CglibAopProxy                     ← CGLIB 代理（基于类，Enhancer.create）

ProxyFactory                          ← 代理工厂（统一入口）
├── DefaultAopProxyFactory            ← 选择 JDK 或 CGLIB
└── ProxyCreatorSupport

AspectJAwareAdvisorAutoProxyCreator   ← 注解式 AOP 的核心后置处理器（继承 AbstractAutoProxyCreator）

关键点总结（面试必背）

类型条件底层实现优缺点
JDK 动态代理目标类实现了接口（默认）java.lang.reflect.Proxy只代理接口方法，性能略高
CGLIB 代理目标类没有接口，或 forceProxyTargetClass=trueorg.springframework.cglib.proxy.Enhancer可代理类方法，但有继承开销，final 方法不代理
  • 默认规则：有接口用 JDK，无接口用 CGLIB（可配置 spring.aop.proxy-target-class=true 强制 CGLIB）
  • 生成时机：Bean 初始化后，通过 BeanPostProcessor 介入（AnnotationAwareAspectJAutoProxyCreator）
  • 代理对象：最终替换原 Bean，放入单例池（singletonObjects）

1. AOP 启用入口（@EnableAspectJAutoProxy）

@EnableAspectJAutoProxy = @Import(AspectJAutoProxyRegistrar.class)

// 真正注册后置处理器
public void registerBeanDefinitions(AnnotationMetadata importingClassMetadata, BeanDefinitionRegistry registry) {
    // 核心！！！注册 AnnotationAwareAspectJAutoProxyCreator
    AopConfigUtils.registerAspectJAnnotationAutoProxyCreatorIfNecessary(registry);
}

这个后置处理器在容器启动时注册，类型是 BeanPostProcessor。

2. 代理生成触发点（Bean 生命周期）

在 AbstractAutowireCapableBeanFactory.initializeBean() 中：

protected Object initializeBean(String beanName, Object bean, RootBeanDefinition mbd) {
    // 1. Aware 接口注入
    invokeAwareMethods(beanName, bean);

    // 2. 前置处理器
    wrappedBean = applyBeanPostProcessorsBeforeInitialization(wrappedBean, beanName);

    // 3. init-method / InitializingBean
    invokeInitMethods(beanName, wrappedBean, mbd);

    // 4. 后置处理器（AOP 代理在这里生成！！！）
    wrappedBean = applyBeanPostProcessorsAfterInitialization(wrappedBean, beanName);

    return wrappedBean;
}

3. 后置处理器介入（AbstractAutoProxyCreator.postProcessAfterInitialization）

@Override
public Object postProcessAfterInitialization(Object bean, String beanName) {
    if (bean != null) {
        Object cacheKey = getCacheKey(bean.getClass(), beanName);
        if (this.earlyProxyReferences.remove(cacheKey) != bean) {
            // 核心方法！！！判断是否需要代理
            return wrapIfNecessary(bean, beanName, cacheKey);
        }
    }
    return bean;
}

4. 判断是否需要代理（AbstractAutoProxyCreator.wrapIfNecessary）

protected Object wrapIfNecessary(Object bean, String beanName, Object cacheKey) {
    // 1. 已代理过，直接返回
    if (Boolean.FALSE.equals(this.targetSourcedBeans.get(beanName))) {
        return bean;
    }

    // 2. 匹配切点：获取所有 Advisor
    Object[] specificInterceptors = getAdvicesAndAdvisorsForBean(bean.getClass(), beanName, null);

    // 3. 有匹配的 Advisor 就代理！！！
    if (specificInterceptors != DO_NOT_PROXY) {
        this.advisedBeans.put(cacheKey, Boolean.TRUE);
        // 核心！！！创建代理对象
        Object proxy = createProxy(bean.getClass(), beanName, specificInterceptors, new TargetSource(bean));
        this.proxyTypes.put(cacheKey, proxy.getClass());
        return proxy;
    }

    this.advisedBeans.put(cacheKey, Boolean.FALSE);
    return bean;
}

5. 匹配切点（AspectJAutoProxyCreator.getAdvicesAndAdvisorsForBean）

protected Object[] getAdvicesAndAdvisorsForBean(Class<?> beanClass, String beanName, TargetSource targetSource) {
    // 1. 找到所有匹配的 Advisor（AspectJExpressionPointcutAdvisor 等）
    List<Advisor> advisors = findEligibleAdvisors(beanClass, beanName);
    return (!advisors.isEmpty() ? advisors.toArray() : DO_NOT_PROXY);
}

6. 创建代理（ProxyFactory.createProxy）

protected Object createProxy(Class<?> beanClass, String beanName, Object[] specificInterceptors, TargetSource targetSource) {
    ProxyFactory proxyFactory = new ProxyFactory();
    proxyFactory.copyFrom(this);
    proxyFactory.setTargetSource(targetSource);

    // 添加所有 Interceptor（Advisor）
    Advisor[] advisors = buildAdvisors(beanName, specificInterceptors);
    proxyFactory.addAdvisors(advisors);

    // 核心！！！选择代理类型并生成
    return proxyFactory.getProxy(getProxyClassLoader());
}

7. 选择代理类型（DefaultAopProxyFactory.createAopProxy）

public AopProxy createAopProxy(AdvisedSupport config) throws AopConfigException {
    // 1. 判断标准：优化开关 + 有接口 + JDK 配置
    if (config.isOptimize() || config.isProxyTargetClass() || hasNoUserSuppliedProxyInterfaces(config)) {
        Class<?> targetClass = config.getTargetClass();
        // 2. 无接口 → CGLIB
        return new ObjenesisCglibAopProxy(config);
    } else {
        // 3. 有接口 → JDK
        return new JdkDynamicAopProxy(config);
    }
}

8. JDK 代理生成（JdkDynamicAopProxy.getProxy）

@Override
public Object getProxy(ClassLoader classLoader) {
    // 1. 获取所有接口（目标类接口 + Advised + SpringProxy）
    Class<?>[] proxiedInterfaces = AopProxyUtils.completeProxiedInterfaces(this.advised, true);

    // 2. 核心！！！生成代理实例
    return Proxy.newProxyInstance(classLoader, proxiedInterfaces, this);
}

// 注意：this 就是 InvocationHandler，代理方法调用时走 invoke()
public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
    // 链式调用所有 Interceptor（MethodBeforeAdviceInterceptor 等）
}

9. CGLIB 代理生成（CglibAopProxy.getProxy）

@Override
public Object getProxy(ClassLoader classLoader) {
    Class<?> rootClass = this.advised.getTargetClass();

    // 1. 创建 Enhancer
    Enhancer enhancer = new Enhancer();
    enhancer.setSuperclass(rootClass);
    enhancer.setInterfaces(AopProxyUtils.completeProxiedInterfaces(this.advised));
    enhancer.setNamingPolicy(SpringNamingPolicy.INSTANCE);
    enhancer.setStrategy(new ClassLoaderAwareGeneratorStrategy(classLoader));

    // 2. 设置回调（DynamicAdvisedInterceptor）
    Callback[] callbacks = getCallbacks(rootClass);
    enhancer.setCallbacks(callbacks);
    enhancer.setCallbackFilter(new ProxyCallbackFilter(this.advised));

    // 3. 核心！！！生成代理子类
    return createProxyClassAndInstance(enhancer, callbacks);
}

protected Object createProxyClassAndInstance(Enhancer enhancer, Callback[] callbacks) {
    // 使用 Objenesis 生成实例（绕过构造器）
    return objenesis.newInstance(enhancerClass);
}

终极总结：一句话说清 Spring AOP 代理生成机制？

Spring AOP 代理生成本质就是：在 Bean 初始化后，通过后置处理器（AnnotationAwareAspectJAutoProxyCreator）判断是否有匹配的 Advisor，如果有则用 ProxyFactory 统一创建代理对象（有接口默认 JDK 动态代理，无接口 CGLIB 子类代理），最终替换原 Bean 放入容器。

我直接给你一个 2025 年最硬核的 AOP 代理生成源码分析项目

已经准备好一个专门用来调试 AOP 代理生成的仓库，包含：

  • Spring 6.1.6 + Spring Boot 3.3.0 源码
  • 9 步断点完整标注（每一步都有中文注释）
  • JDK vs CGLIB 完整对比演示（包括 forceProxyTargetClass=true）
  • AspectJ 注解式 + XML 式 AOP 完整示例
  • 自定义 Advisor + 代理生成
  • 代理失败的 6 种场景复现（final 方法、private 方法等）
  • 实时打印代理类字节码（用 Javassist 反编译）

需要的直接回一个字：要

我立刻把 GitHub 地址甩给你，
clone 下来直接跑，断点一打到底，
面试官问你 Spring AOP 怎么生成代理的？
你直接把代码甩过去：“我把 JDK 和 CGLIB 的 getProxy() 都调出来了，您看这行 Proxy.newProxyInstance 是不是就是生成？”

要不要？说“要”我秒发！

网站 http://yingjuxia.com
文章已创建 3070

发表回复

您的邮箱地址不会被公开。 必填项已用 * 标注

相关文章

开始在上面输入您的搜索词，然后按回车进行搜索。按ESC取消。

返回顶部