AOP 代理创建与事务源码精读

概述

本文逐行精读 Spring AOP 代理创建与执行源码，以及声明式事务的实现机制。

一、AOP 代理创建流程

1.1 入口：@EnableAspectJAutoProxy

java

@Target(ElementType.TYPE)
@Retention(RetentionPolicy.RUNTIME)
@Documented
@Import(AspectJAutoProxyRegistrar.class)
public @interface EnableAspectJAutoProxy {
    boolean proxyTargetClass() default false;
    boolean exposeProxy() default false;
}

java

// AspectJAutoProxyRegistrar
class AspectJAutoProxyRegistrar implements ImportBeanDefinitionRegistrar {

    @Override
    public void registerBeanDefinitions(AnnotationMetadata importingClassMetadata,
                                          BeanDefinitionRegistry registry) {
        // 注册 AnnotationAwareAspectJAutoProxyCreator
        AopConfigUtils.registerAspectJAnnotationAutoProxyCreatorIfNecessary(registry);

        // 处理 proxyTargetClass 和 exposeProxy 属性
        // ...
    }
}

1.2 代理创建时机

AOP 代理在 Bean 初始化后置处理阶段创建：

java

// AbstractAutoProxyCreator（BeanPostProcessor 实现）
// 在 AbstractAutowireCapableBeanFactory.initializeBean() 的
// applyBeanPostProcessorsAfterInitialization() 中被调用

@Override
public Object postProcessAfterInitialization(@Nullable Object bean, String beanName) {
    if (bean != null) {
        // 缓存已创建的 Bean
        Object cacheKey = getCacheKey(bean.getClass(), beanName);
        if (this.earlyProxyReferences.remove(cacheKey) != bean) {
            // 关键方法：创建 AOP 代理
            return wrapIfNecessary(bean, beanName, cacheKey);
        }
    }
    return bean;
}

1.3 wrapIfNecessary() — 判断是否需要代理

java

protected Object wrapIfNecessary(Object bean, String beanName, Object cacheKey) {
    // 1. 跳过已创建的 Bean
    if (StringUtils.hasLength(beanName) && this.targetSourcedBeans.contains(beanName)) {
        return bean;
    }

    // 2. 从缓存获取是否不适用代理
    if (Boolean.FALSE.equals(this.advisedBeans.get(cacheKey))) {
        return bean;
    }

    // 3. 是否应该跳过（基础设施类、Aspect 自身等）
    if (isInfrastructureClass(bean.getClass()) || shouldSkip(bean.getClass(), beanName)) {
        this.advisedBeans.put(cacheKey, Boolean.FALSE);
        return bean;
    }

    // 4. 获取当前 Bean 匹配的 Advisors（核心！）
    Object[] specificInterceptors = getAdvicesAndAdvisorsForBean(bean.getClass(), beanName, null);
    if (specificInterceptors != DO_NOT_PROXY) {
        this.advisedBeans.put(cacheKey, Boolean.TRUE);
        // 5. 创建代理
        Object proxy = createProxy(
                bean.getClass(), beanName, specificInterceptors, new SingletonTargetSource(bean));
        this.proxyTypes.put(cacheKey, proxy.getClass());
        return proxy;
    }

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

1.4 获取匹配的 Advisor

java

// AbstractAdvisorAutoProxyCreator.getAdvicesAndAdvisorsForBean()
// 1. 从 BeanFactory 获取所有 Advisor
// 2. 逐一检查是否匹配当前 Bean
// 3. 排序后返回

protected Object[] getAdvicesAndAdvisorsForBean(
        Class<?> beanClass, String beanName, @Nullable TargetSource targetSource) {

    // 1. 找到所有匹配的 Advisor
    List<Advisor> advisors = findEligibleAdvisors(beanClass, beanName);
    if (advisors.isEmpty()) {
        return DO_NOT_PROXY;
    }
    return advisors.toArray();
}

protected List<Advisor> findEligibleAdvisors(Class<?> beanClass, String beanName) {
    // 1. 从 BeanFactory 获取所有 Advisor
    List<Advisor> candidateAdvisors = findCandidateAdvisors();

    // 2. 筛选匹配当前 Bean 的 Advisor
    List<Advisor> eligibleAdvisors = findAdvisorsThatCanApply(candidateAdvisors, beanClass, beanName);

    // 3. 扩展（默认添加 ExposeInvocationInterceptor）
    extendAdvisors(eligibleAdvisors);

    if (!eligibleAdvisors.isEmpty()) {
        // 4. 排序
        eligibleAdvisors = sortAdvisors(eligibleAdvisors);
    }
    return eligibleAdvisors;
}

1.5 createProxy() — 创建代理

java

protected Object createProxy(Class<?> beanClass, @Nullable String beanName,
                              @Nullable Object[] specificInterceptors, TargetSource targetSource) {

    // 创建 ProxyFactory
    ProxyFactory proxyFactory = new ProxyFactory();
    proxyFactory.copyFrom(this);

    // 设置代理目标
    proxyFactory.setTargetSource(targetSource);

    // 添加 Advisor
    for (Advisor advisor : specificInterceptors) {
        proxyFactory.addAdvisor(advisor);
    }

    // 决定代理方式
    // 1. proxyTargetClass=true → CGLIB
    // 2. 目标类实现了接口 → JDK 代理
    // 3. 目标类没有接口 → CGLIB
    return proxyFactory.getProxy(getProxyClassLoader());
}

// ProxyFactory.getProxy()
public Object getProxy(@Nullable ClassLoader classLoader) {
    // 创建 AopProxy（JdkDynamicAopProxy / CglibAopProxy）
    return createAopProxy().getProxy(classLoader);
}

二、AOP 代理执行

2.1 JDK 动态代理

java

// JdkDynamicAopProxy.invoke()
final class JdkDynamicAopProxy implements AopProxy, InvocationHandler {

    @Override
    @Nullable
    public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
        Object oldProxy = null;
        boolean setProxyContext = false;

        TargetSource targetSource = this.advised.targetSource;
        Object target = null;

        try {
            // 1. equals/hashCode 方法不拦截
            if (!this.equalsDefined && AopUtils.isEqualsMethod(method)) {
                return equals(args[0]);
            }
            if (!this.hashCodeDefined && AopUtils.isHashCodeMethod(method)) {
                return hashCode();
            }
            if (!this.advised.opaque && method.getDeclaringClass().isInterface() &&
                    method.getDeclaringClass().isAssignableFrom(Advised.class)) {
                return AopUtils.invokeJoinpointUsingReflection(this.advised, method, args);
            }

            // 2. 暴露代理对象（@EnableAspectJAutoProxy(exposeProxy=true)）
            if (this.advised.exposeProxy) {
                oldProxy = AopContext.setCurrentProxy(proxy);
                setProxyContext = true;
            }

            // 3. 获取目标对象
            target = targetSource.getTarget();
            Class<?> targetClass = (target != null ? target.getClass() : null);

            // 4. 获取方法匹配的拦截器链（核心！）
            List<Object> chain = this.advised.getInterceptorsAndDynamicInterceptionAdvice(method, targetClass);

            if (chain.isEmpty()) {
                // 无拦截器 → 直接反射调用目标方法
                return AopUtils.invokeJoinpointUsingReflection(target, method, args);
            } else {
                // 5. 创建 MethodInvocation 并执行拦截器链
                MethodInvocation invocation =
                        new ReflectiveMethodInvocation(proxy, target, method, args, targetClass, chain);
                return invocation.proceed();
            }
        } finally {
            if (target != null && !targetSource.isStatic()) {
                targetSource.releaseTarget(target);
            }
            if (setProxyContext) {
                AopContext.setCurrentProxy(oldProxy);
            }
        }
    }
}

2.2 拦截器链执行

java

// ReflectiveMethodInvocation.proceed()
// 责任链模式：逐一调用拦截器，直到最后一个调用目标方法

@Override
@Nullable
public Object proceed() throws Throwable {
    // 当前拦截器索引 >= 拦截器总数 → 调用目标方法
    if (this.currentInterceptorIndex == this.interceptorsAndDynamicMethodMatchers.size() - 1) {
        return invokeJoinpoint();
    }

    // 获取下一个拦截器
    Object interceptorOrInterceptionAdvice =
            this.interceptorsAndDynamicMethodMatchers.get(++this.currentInterceptorIndex);

    if (interceptorOrInterceptionAdvice instanceof InterceptorAndDynamicMethodMatcher) {
        // 动态方法匹配器
        InterceptorAndDynamicMethodMatcher dm =
                (InterceptorAndDynamicMethodMatcher) interceptorOrInterceptionAdvice;
        Class<?> targetClass = (this.targetClass != null ? this.targetClass : this.method.getDeclaringClass());
        if (dm.methodMatcher.matches(this.method, targetClass, this.arguments)) {
            return dm.interceptor.invoke(this);
        } else {
            // 不匹配 → 跳过此拦截器
            return proceed();
        }
    } else {
        // 调用拦截器（Around Advice / Before Advice / After Advice / Throws Advice）
        return ((MethodInterceptor) interceptorOrInterceptionAdvice).invoke(this);
    }
}

2.3 CGLIB 代理

java

// CglibAopProxy.DynamicAdvisedInterceptor.intercept()
private static class DynamicAdvisedInterceptor implements MethodInterceptor {

    @Override
    @Nullable
    public Object intercept(Object proxy, Method method, Object[] args, MethodProxy methodProxy) throws Throwable {
        Object oldProxy = null;
        boolean setProxyContext = false;
        Object target = null;

        try {
            if (this.advised.exposeProxy) {
                oldProxy = AopContext.setCurrentProxy(proxy);
                setProxyContext = true;
            }

            target = targetSource.getTarget();
            Class<?> targetClass = (target != null ? target.getClass() : null);

            // 获取拦截器链
            List<Object> chain = this.advised.getInterceptorsAndDynamicInterceptionAdvice(method, targetClass);

            if (chain.isEmpty() && Modifier.isPublic(method.getModifiers())) {
                // 无拦截器且 public → 直接 CGLIB 快速调用
                Object[] argsToUse = AopProxyUtils.adaptArgumentsIfNecessary(method, args);
                return methodProxy.invoke(target, argsToUse);
            } else {
                // 创建 CglibMethodInvocation 并执行链
                MethodInvocation invocation =
                        new CglibMethodInvocation(proxy, target, method, args, targetClass, chain);
                return invocation.proceed();
            }
        } finally {
            if (target != null && !targetSource.isStatic()) {
                targetSource.releaseTarget(target);
            }
            if (setProxyContext) {
                AopContext.setCurrentProxy(oldProxy);
            }
        }
    }
}

三、声明式事务源码

3.1 @EnableTransactionManagement

java

@Target(ElementType.TYPE)
@Retention(RetentionPolicy.RUNTIME)
@Documented
@Import(TransactionManagementConfigurationSelector.class)
public @interface EnableTransactionManagement {
    boolean proxyTargetClass() default false;
    AdviceMode mode() default AdviceMode.PROXY;
    int order() default Ordered.LOWEST_PRECEDENCE;
}

// TransactionManagementConfigurationSelector
public class TransactionManagementConfigurationSelector extends AdviceModeImportSelector<EnableTransactionManagement> {

    @Override
    protected String[] selectImports(AdviceMode adviceMode) {
        switch (adviceMode) {
            case PROXY:
                // 注册 AutoProxyRegistrar + ProxyTransactionManagementConfiguration
                return new String[] {
                    AutoProxyRegistrar.class.getName(),
                    ProxyTransactionManagementConfiguration.class.getName()
                };
            case ASPECTJ:
                return new String[] { TransactionManagementConfigUtils.TRANSACTION_ASPECT_CONFIGURATION_CLASS_NAME };
            default:
                return null;
        }
    }
}

3.2 TransactionInterceptor — 事务拦截器

java

// TransactionInterceptor（MethodInterceptor 实现）
// 在代理方法执行时被调用

@Override
@Nullable
public Object invoke(MethodInvocation invocation) throws Throwable {
    // 获取事务属性
    TransactionAttributeSource tas = getTransactionAttributeSource();
    TransactionAttribute txAttr = (tas != null ? tas.getTransactionAttribute(invocation.getMethod(), invocation.getThis().getClass()) : null);

    // 确定事务管理器
    PlatformTransactionManager tm = determineTransactionManager(txAttr);

    // 执行带事务的调用
    return invokeWithinTransaction(invocation.getMethod(), invocation.getThis().getClass(),
            invocation::proceed, txAttr, tm);
}

// 核心方法
@Nullable
protected Object invokeWithinTransaction(Method method, @Nullable Class<?> targetClass,
        final InvocationCallback invocation, @Nullable TransactionAttribute txAttr,
        PlatformTransactionManager tm) throws Throwable {

    // 1. 获取事务名称
    String joinpointIdentification = methodName;

    // 2. 声明式事务
    if (txAttr != null && tm instanceof CallbackPreferringPlatformTransactionManager) {
        // 回调式事务管理器
        // ...
    } else {
        // 标准声明式事务
        TransactionInfo txInfo = createTransactionIfNecessary(tm, txAttr, joinpointIdentification);

        Object retVal;
        try {
            // 3. 执行业务方法
            retVal = invocation.proceedWithInvocation();
        } catch (Throwable ex) {
            // 4. 异常时回滚
            completeTransactionAfterThrowing(txInfo, ex);
            throw ex;
        } finally {
            // 5. 清理事务信息
            cleanupTransactionInfo(txInfo);
        }

        // 6. 正常提交
        commitTransactionAfterReturning(txInfo);
        return retVal;
    }
}

3.3 事务创建

java

protected TransactionInfo createTransactionIfNecessary(
        PlatformTransactionManager tm, @Nullable TransactionAttribute txAttr, String joinpointIdentification) {

    if (txAttr != null) {
        // 获取新的或现有的事务
        Status status = tm.getTransaction(txAttr);
        // 创建事务信息
        return prepareTransactionInfo(tm, txAttr, joinpointIdentification, status);
    }
    return null;
}

3.4 事务提交

java

// AbstractPlatformTransactionManager.processCommit()
private void processCommit(DefaultTransactionStatus status) throws TransactionException {
    try {
        boolean beforeCompletionInvoked = false;

        try {
            boolean unexpectedRollback = false;

            // 1. 触发 beforeCommit 回调
            prepareForCommit(status);

            // 2. 触发 beforeCompletion 回调
            triggerBeforeCompletion(status);
            beforeCompletionInvoked = true;

            if (status.hasSavepoint()) {
                // 嵌套事务 → 释放保存点
                status.releaseHeldSavepoint();
            } else if (status.isNewTransaction()) {
                // 3. 真正提交（子类实现：DataSourceTransactionManager / JpaTransactionManager）
                // DataSourceTransactionManager 调用 connection.commit()
                doCommit(status);
            }

            // 4. 触发 afterCommit 回调
            triggerAfterCommit(status);
            // 5. 触发 afterCompletion 回调
            triggerAfterCompletion(status, TransactionStatus.STATUS_COMMITTED);

        } finally {
            if (!beforeCompletionInvoked) {
                triggerAfterCompletion(status, TransactionStatus.STATUS_UNKNOWN);
            }
        }
    } catch (TransactionException ex) {
        // 提交失败 → 强制回滚
        doRollbackOnCommitException(status, ex);
        throw ex;
    }
}

3.5 事务回滚

java

// AbstractPlatformTransactionManager.completeTransactionAfterThrowing()
protected void completeTransactionAfterThrowing(@Nullable TransactionInfo txInfo, Throwable ex) {
    if (txInfo != null && txInfo.getTransactionStatus() != null) {
        // 判断是否应该回滚（rollbackFor / noRollbackFor）
        if (txInfo.transactionAttribute != null && txInfo.transactionAttribute.rollbackOn(ex)) {
            // 应该回滚
            try {
                txInfo.getTransactionManager().rollback(txInfo.getTransactionStatus());
            } catch (TransactionException tex) {
                // ...
            }
        } else {
            // 不应该回滚 → 仍然提交
            try {
                txInfo.getTransactionManager().commit(txInfo.getTransactionStatus());
            } catch (TransactionException tex) {
                // ...
            }
        }
    }
}

3.6 传播行为实现

java

// AbstractPlatformTransactionManager.getTransaction()
@Override
public final TransactionStatus getTransaction(@Nullable TransactionDefinition definition) throws TransactionException {
    // 1. 获取当前事务
    Object transaction = doGetTransaction();

    // 2. 判断当前是否存在事务
    if (isExistingTransaction(transaction)) {
        // 已有事务 → 按传播行为处理
        return handleExistingTransaction(definition, transaction, debugEnabled);
    }

    // 3. 没有现有事务
    if (definition.getPropagationBehavior() == TransactionDefinition.PROPAGATION_MANDATORY) {
        throw new IllegalTransactionStateException("...");
    } else if (definition.getPropagationBehavior() == TransactionDefinition.PROPAGATION_REQUIRED ||
               definition.getPropagationBehavior() == TransactionDefinition.PROPAGATION_REQUIRES_NEW ||
               definition.getPropagationBehavior() == TransactionDefinition.PROPAGATION_NESTED) {
        // REQUIRED / REQUIRES_NEW / NESTED → 创建新事务
        return startTransaction(definition, transaction, debugEnabled);
    } else {
        // SUPPORTS / NOT_SUPPORTED / NEVER → 无事务运行
        // ...
    }
}

四、@TransactionalEventListener 事务事件

java

// 事务事件监听器：在事务提交后执行
@Component
public class OrderEventListener {

    @TransactionalEventListener(phase = TransactionPhase.AFTER_COMMIT)
    public void handleOrderCreated(OrderCreatedEvent event) {
        // 事务提交后才执行
        // 场景：发送短信通知、推送消息到 MQ
    }
}

// TransactionalEventListener 源码原理：
// 1. ApplicationListenerMethodTransactionalAdapter 包装监听器
// 2. 在事务同步器中注册回调
// 3. 当事务提交后，触发回调执行

五、总结

知识点	关键源码	触发时机
AOP 开启	`@EnableAspectJAutoProxy → AspectJAutoProxyRegistrar`	配置解析
代理创建	`AbstractAutoProxyCreator.wrapIfNecessary()`	Bean 初始化后置处理
匹配 Advisor	`findAdvisorsThatCanApply()`	创建代理时
JDK 代理执行	`JdkDynamicAopProxy.invoke()`	方法调用
CGLIB 代理执行	`DynamicAdvisedInterceptor.intercept()`	方法调用
事务开启	`@EnableTransactionManagement → TransactionInterceptor`	配置解析
事务提交	`AbstractPlatformTransactionManager.processCommit()`	方法正常返回
事务回滚	`completeTransactionAfterThrowing()`	方法异常
传播行为	`getTransaction() + handleExistingTransaction()`	事务创建

参考链接：
Spring AOP 源码
Spring 事务源码
Spring AOP 文档

AOP 代理创建与事务源码精读 ​

概述 ​

一、AOP 代理创建流程 ​

1.1 入口：@EnableAspectJAutoProxy ​

1.2 代理创建时机 ​

1.3 wrapIfNecessary() — 判断是否需要代理 ​

1.4 获取匹配的 Advisor ​

1.5 createProxy() — 创建代理 ​

二、AOP 代理执行 ​

2.1 JDK 动态代理 ​

2.2 拦截器链执行 ​

2.3 CGLIB 代理 ​

三、声明式事务源码 ​

3.1 @EnableTransactionManagement ​

3.2 TransactionInterceptor — 事务拦截器 ​

3.3 事务创建 ​

3.4 事务提交 ​

3.5 事务回滚 ​

3.6 传播行为实现 ​

四、@TransactionalEventListener 事务事件 ​

五、总结 ​

AOP 代理创建与事务源码精读

概述

一、AOP 代理创建流程

1.1 入口：@EnableAspectJAutoProxy

1.2 代理创建时机

1.3 wrapIfNecessary() — 判断是否需要代理

1.4 获取匹配的 Advisor

1.5 createProxy() — 创建代理

二、AOP 代理执行

2.1 JDK 动态代理

2.2 拦截器链执行

2.3 CGLIB 代理

三、声明式事务源码

3.1 @EnableTransactionManagement

3.2 TransactionInterceptor — 事务拦截器

3.3 事务创建

3.4 事务提交

3.5 事务回滚

3.6 传播行为实现

四、@TransactionalEventListener 事务事件

五、总结