Spring 源码分析(七)AOP 原理(上):代理的创建
本文基于 Spring Framework 6.2.x(Spring Boot 3.4.x 所对应版本)源码编写,源码为开源项目 spring-projects/spring-framework(Apache 2.0 协议),文中引用均为学习目的的片段摘录,版权归原项目作者所有。
上一篇我们分析了循环依赖与三级缓存,结尾留了一个钩子:三级缓存之所以存 ObjectFactory 工厂而不是对象,是为了让 AOP 代理可以在"提前暴露"那一刻按需生成------AbstractAutoProxyCreator 实现了 getEarlyBeanReference(),循环依赖场景下代理会提前诞生。再往前翻,(五)生命周期(下)里也埋过伏笔:正常流程下,代理是在 initializeBean() 最后一步 applyBeanPostProcessorsAfterInitialization() 的 BPP 后置钩子里生成的。这两处伏笔都指向同一个类,但它内部"什么时候建代理、怎么建、用 JDK 还是 CGLIB"的完整细节,当时只给了一句话结论。
本文我们正式展开 AOP 原理(上):代理的创建。
一、概述
先回顾一下 AOP 的三要素,这也是后面读源码的语言基础:
| 要素 | 对应接口 / 注解 | 一句话解释 |
|---|---|---|
| 切点 Pointcut | org.springframework.aop.Pointcut,@Pointcut("execution(...)") |
在哪织入:一组匹配规则(ClassFilter + MethodMatcher) |
| 通知 Advice | @Before / @After / @Around 等,aopalliance 的 MethodInterceptor |
织入什么:切点命中后执行的增强逻辑 |
| 织入 Weaving | @Aspect 类 + 容器的自动代理 |
什么时候织:把通知套到目标对象上生成代理 |
Spring AOP 的实现本质是运行时代理 :编译期不动你的字节码,也不改类加载过程,而是在 Bean 初始化完成后,检查这个 Bean 有没有命中的切面------有,就创建一个代理对象放回容器,代理内部持有目标对象和增强链;没有,原样返回。我们在容器里拿到的 userService 其实是代理,this 才是裸对象------这也是(四)里"@PostConstruct 方法里 this 不是代理对象"的根源。
再看位置。回顾(五)贴过的 doCreateBean() 主干:实例化 → 属性填充 → 初始化 → BPP 后置回调。AOP 代理就诞生在最后的 BPP 后置回调里,另有循环依赖场景下的一个"提前分支":

而完成这件事的 AbstractAutoProxyCreator,本身就是我们(三)讲过的 BeanPostProcessor 家族的一员------它实现了 SmartInstantiationAwareBeanPostProcessor,所以既能挂住初始化后的钩子,又能参与循环依赖的早期引用决策。整个 Spring AOP 的自动代理,就是"一个 BPP + 一套代理工厂"的组合拳。
二、代理的诞生
2.1 从 @EnableAspectJAutoProxy 说起
我们平时写 AOP,第一步是在配置类上标 @EnableAspectJAutoProxy。看注解定义:
java
@Target(ElementType.TYPE)
@Retention(RetentionPolicy.RUNTIME)
@Documented
@Import(AspectJAutoProxyRegistrar.class)
public @interface EnableAspectJAutoProxy {
/**
* Indicate whether subclass-based (CGLIB) proxies are to be created as opposed
* to standard Java interface-based proxies. The default is {@code false}.
*/
boolean proxyTargetClass() default false;
/**
* Indicate that the proxy should be exposed by the AOP framework as a {@code ThreadLocal}
* for retrieval via the {@link org.springframework.aop.framework.AopContext} class.
* Off by default, i.e. no guarantees that {@code AopContext} access will work.
* @since 4.3.1
*/
boolean exposeProxy() default false;
}
重点在 @Import(AspectJAutoProxyRegistrar.class)------又是熟悉的 import 回调套路(回顾(二)配置类解析里讲的 ImportBeanDefinitionRegistrar)。AspectJAutoProxyRegistrar 会调用 AopConfigUtils,向容器注册一个名为 org.springframework.aop.config.internalAutoProxyCreator 的 BeanDefinition,注册的工具方法如下:
java
@Nullable
public static BeanDefinition registerAspectJAnnotationAutoProxyCreatorIfNecessary(
BeanDefinitionRegistry registry, @Nullable Object source) {
return registerOrEscalateApcAsRequired(AnnotationAwareAspectJAutoProxyCreator.class, registry, source);
}
真正干活的是这个 registerOrEscalateApcAsRequired(),它是理解"注册链"的关键:
java
@Nullable
private static BeanDefinition registerOrEscalateApcAsRequired(
Class<?> cls, BeanDefinitionRegistry registry, @Nullable Object source) {
Assert.notNull(registry, "BeanDefinitionRegistry must not be null");
if (registry.containsBeanDefinition(AUTO_PROXY_CREATOR_BEAN_NAME)) {
BeanDefinition beanDefinition = registry.getBeanDefinition(AUTO_PROXY_CREATOR_BEAN_NAME);
if (!cls.getName().equals(beanDefinition.getBeanClassName())) {
int currentPriority = findPriorityForClass(beanDefinition.getBeanClassName());
int requiredPriority = findPriorityForClass(cls);
if (currentPriority < requiredPriority) {
beanDefinition.setBeanClassName(cls.getName());
}
}
return null;
}
RootBeanDefinition beanDefinition = new RootBeanDefinition(cls);
beanDefinition.setSource(source);
beanDefinition.setRole(BeanDefinition.ROLE_INFRASTRUCTURE);
beanDefinition.getPropertyValues().add("order", Ordered.HIGHEST_PRECEDENCE);
registry.registerBeanDefinition(AUTO_PROXY_CREATOR_BEAN_NAME, beanDefinition);
return beanDefinition;
}
"escalate(升级)"逻辑翻译一下:容器里可能已经有别的组件注册过自动代理创建者(比如 XML 时代的 <aop:config>、事务的 @EnableTransactionManagement),但这个固定 bean 名只允许存在一份。想再注册时先比较优先级:
java
/**
* Stores the auto proxy creator classes in escalation order.
*/
private static final List<Class<?>> APC_PRIORITY_LIST = new ArrayList<>(3);
static {
// Set up the escalation list...
APC_PRIORITY_LIST.add(InfrastructureAdvisorAutoProxyCreator.class);
APC_PRIORITY_LIST.add(AspectJAwareAdvisorAutoProxyCreator.class);
APC_PRIORITY_LIST.add(AnnotationAwareAspectJAutoProxyCreator.class);
}
列表按能力从弱到强排列:InfrastructureAdvisorAutoProxyCreator(只代理带配置角色的 Bean)→ AspectJAwareAdvisorAutoProxyCreator(XML 切面)→ AnnotationAwareAspectJAutoProxyCreator(注解切面)。后来者若优先级更高,就把已注册 BeanDefinition 的类名替换掉------所以最终容器里活下来的一定是能力最强的那个变体 。这也解释了一个经典现象:@EnableAspectJAutoProxy 和 @EnableTransactionManagement 同时存在时不会注册出两个 BPP,事务那个"弱一些"的注册请求会被升级成 AnnotationAwareAspectJAutoProxyCreator 统一处理。
注意注册时的两个细节:ROLE_INFRASTRUCTURE 标记为基础设施 Bean((四)里讲过,这类 Bean 不会被自家 BPP 再代理),order 设为最高优先级(保证这个 BPP 在 BPP 链的前部执行)。
2.2 代理创建的时机:后置钩子与提前分支
回顾完注册链,接下来看这个 BPP 的钩子方法。AbstractAutoProxyCreator 实现 postProcessAfterInitialization():
java
@Override
@Nullable
public Object postProcessAfterInitialization(@Nullable Object bean, String beanName) {
if (bean != null) {
Object cacheKey = getCacheKey(bean.getClass(), beanName);
if (this.earlyBeanReferences.remove(cacheKey) != bean) {
return wrapIfNecessary(bean, beanName, cacheKey);
}
}
return bean;
}
代码很短,但藏着一个(六)篇埋过的细节:this.earlyBeanReferences.remove(cacheKey) != bean 这个判断------如果这个 Bean 曾经被循环依赖提前暴露、代理已经在 getEarlyBeanReference() 里生成过了,这里就不再重复包装 ,直接返回。正常 Bean(没经历过提前暴露)才会走 wrapIfNecessary()。
再看提前分支本身:
java
@Override
public Object getEarlyBeanReference(Object bean, String beanName) {
Object cacheKey = getCacheKey(bean.getClass(), beanName);
this.earlyBeanReferences.put(cacheKey, bean);
return wrapIfNecessary(bean, beanName, cacheKey);
}
两个钩子殊途同归到 wrapIfNecessary(),只是时机不同:一个是初始化完成后(正常流程),一个是半成品被提前暴露前(循环依赖流程)。earlyBeanReferences 这个 Map 就是两个钩子之间的"防重复"记账本。
把整个代理创建体系画成类图(重点关注左边 Creator 继承链和右边 ProxyFactory 体系):

三、源码解析过程
3.1 wrapIfNecessary:要不要给这个 Bean 建代理
上一节两次出现的 wrapIfNecessary() 是代理创建的总入口,看它的全貌:
java
protected Object wrapIfNecessary(Object bean, String beanName, Object cacheKey) {
if (StringUtils.hasLength(beanName) && this.targetSourcedBeans.contains(beanName)) {
return bean;
}
if (Boolean.FALSE.equals(this.advisedBeans.get(cacheKey))) {
return bean;
}
if (isInfrastructureClass(bean.getClass()) || shouldSkip(bean.getClass(), beanName)) {
this.advisedBeans.put(cacheKey, Boolean.FALSE);
return bean;
}
// Create proxy if we have advice.
// 有匹配的通知才创建代理
Object[] specificInterceptors = getAdvicesAndAdvisorsForBean(bean.getClass(), beanName, null);
if (specificInterceptors != DO_NOT_PROXY) {
this.advisedBeans.put(cacheKey, Boolean.TRUE);
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;
}
前三道闸门都是"快速说不":
targetSourcedBeans:自定义TargetSource的 Bean 在实例化前就已经建过代理(postProcessBeforeInstantiation分支),跳过;advisedBeans缓存:之前判定过"不代理"的 Bean 直接跳过------这就是(五)里@Aspect切面类自己不会被代理的原因之一;isInfrastructureClass()/shouldSkip():Advice、Pointcut、Advisor、AopInfrastructureBean这些基础设施类型一律不代理。
真正的决策在 getAdvicesAndAdvisorsForBean(),它是抽象方法,注解切面场景下的实现链最终落在 AbstractAdvisorAutoProxyCreator:
java
@Override
@Nullable
protected Object[] getAdvicesAndAdvisorsForBean(
Class<?> beanClass, String beanName, @Nullable TargetSource targetSource) {
List<Advisor> advisors = findEligibleAdvisors(beanClass, beanName);
if (advisors.isEmpty()) {
return DO_NOT_PROXY;
}
return advisors.toArray();
}
找到了增强就返回数组,一个都没有就返回 DO_NOT_PROXY(即 null),wrapIfNecessary 据此决定建不建代理。核心方法是 findEligibleAdvisors(),四步走:
java
protected List<Advisor> findEligibleAdvisors(Class<?> beanClass, String beanName) {
List<Advisor> candidateAdvisors = findCandidateAdvisors();
List<Advisor> eligibleAdvisors = findAdvisorsThatCanApply(candidateAdvisors, beanClass, beanName);
extendAdvisors(eligibleAdvisors);
if (!eligibleAdvisors.isEmpty()) {
try {
eligibleAdvisors = sortAdvisors(eligibleAdvisors);
}
catch (BeanCreationException ex) {
throw new AopConfigException("Advisor sorting failed with unexpected bean creation, probably due " +
"to custom use of the Ordered interface. Consider using the @Order annotation instead.", ex);
}
}
return eligibleAdvisors;
}
第一步 findCandidateAdvisors:找候选 。默认实现只找容器里实现了 Advisor 接口的 Bean,而 AnnotationAwareAspectJAutoProxyCreator 重写了它,多了一步扫 @Aspect:
java
@Override
protected List<Advisor> findCandidateAdvisors() {
// Add all the Spring advisors found according to superclass rules.
// 先按父类规则收集容器中的 Advisor Bean
List<Advisor> advisors = super.findCandidateAdvisors();
// Build Advisors for all AspectJ aspects in the bean factory.
// 再为容器中所有 @Aspect 切面构建 Advisor
if (this.aspectJAdvisorsBuilder != null) {
advisors.addAll(this.aspectJAdvisorsBuilder.buildAspectJAdvisors());
}
return advisors;
}
@Aspect 类里的 @Before、@Around 方法之所以能被框架认识,就是 BeanFactoryAspectJAdvisorsBuilder#buildAspectJAdvisors() 干的活。它的主干(节选)如下:
java
public List<Advisor> buildAspectJAdvisors() {
List<String> aspectNames = this.aspectBeanNames;
if (aspectNames == null) {
synchronized (this) {
aspectNames = this.aspectBeanNames;
if (aspectNames == null) {
List<Advisor> advisors = new ArrayList<>();
aspectNames = new ArrayList<>();
String[] beanNames = BeanFactoryUtils.beanNamesForTypeIncludingAncestors(
this.beanFactory, Object.class, true, false);
for (String beanName : beanNames) {
// ...(略)isEligibleBean 过滤
// We must be careful not to instantiate beans eagerly as in this case they
// would be cached by the Spring container but would not have been weaved.
// 只取类型不实例化,避免 Bean 在未被织入前就被缓存
Class<?> beanType = this.beanFactory.getType(beanName, false);
if (beanType == null) {
continue;
}
if (this.advisorFactory.isAspect(beanType)) {
// ...(略)按 SINGLETON / prototype 两种实例化模型
// 用 ReflectiveAspectJAdvisorFactory.getAdvisors(factory)
// 把 @Aspect 类里的每个通知方法解析成 Advisor,并缓存
aspectNames.add(beanName);
}
}
this.aspectBeanNames = aspectNames;
return advisors;
}
}
}
// ...(略)非首次调用直接走 advisorsCache 缓存
}
三个要点:双重检查锁 + 缓存 保证切面解析全容器只做一次(aspectBeanNames 为 null 才真正扫描,之后直接读 advisorsCache);扫描时 getType(beanName, false) 只拿类型不实例化 (否则 Bean 会在未织入状态下被容器缓存,注释里专门强调了这一点);解析出的 aspectNames 后续还会被(八)篇的 BeanFactoryAspectJAdvisorsBuilderAdapter 关联逻辑用到。
第二步 findAdvisorsThatCanApply:找匹配 。委托给静态方法 AopUtils.findAdvisorsThatCanApply(),逐个调用 canApply() 判断 Advisor 的切点是否命中当前 Bean。canApply 的主干:
java
public static boolean canApply(Pointcut pc, Class<?> targetClass, boolean hasIntroductions) {
Assert.notNull(pc, "Pointcut must not be null");
// 类级别:ClassFilter 先过滤
if (!pc.getClassFilter().matches(targetClass)) {
return false;
}
MethodMatcher methodMatcher = pc.getMethodMatcher();
if (methodMatcher == MethodMatcher.TRUE) {
// No need to iterate the methods if we're matching any method anyway...
return true;
}
// ...(略)IntroductionAwareMethodMatcher 的准备
Set<Class<?>> classes = new LinkedHashSet<>();
if (!Proxy.isProxyClass(targetClass)) {
classes.add(ClassUtils.getUserClass(targetClass));
}
classes.addAll(ClassUtils.getAllInterfacesForClassAsSet(targetClass));
for (Class<?> clazz : classes) {
Method[] methods = ReflectionUtils.getAllDeclaredMethods(clazz);
for (Method method : methods) {
if (introductionAwareMethodMatcher != null ?
introductionAwareMethodMatcher.matches(method, targetClass, hasIntroductions) :
methodMatcher.matches(method, targetClass)) {
return true;
}
}
}
return false;
}
匹配是两级的 :先用 ClassFilter 过滤类,命中后再遍历目标类的全部方法(含接口方法)逐个问 MethodMatcher------我们写的 execution(* com.example.service..*.*(..)) 表达式就在这里被 AspectJExpressionPointcut 逐方法求值。只要有一个方法命中,这个 Advisor 就是"适用"的。注意这里只判断"类上能不能应用",某个方法最终会不会走增强链,要等(八)讲拦截器链时再看逐方法级别的精确匹配。
第三步 extendAdvisors 与第四步 sortAdvisors :extendAdvisors() 默认空实现(AspectJAwareAdvisorAutoProxyCreator 会在这里塞一个 ExposeInvocationInterceptor,留到(八));sortAdvisors() 用 AnnotationAwareOrderComparator 按 @Order / Ordered 排序------@Order 决定多个切面的执行顺序,就是在这里生效的 。异常分支也值得看一眼:如果切面用了 Ordered 接口且实现有误导致排序中触发 Bean 创建,会转成更友好的 AopConfigException,提示改用 @Order 注解。
3.2 createProxy:ProxyFactory 组装
确定了要代理、也拿到了 Advisor 列表,接下来看 createProxy()。6.2.x 里它只是个转发,真正的主干是 buildProxy():
java
protected Object createProxy(Class<?> beanClass, @Nullable String beanName,
@Nullable Object[] specificInterceptors, TargetSource targetSource) {
return buildProxy(beanClass, beanName, specificInterceptors, targetSource, false);
}
java
private Object buildProxy(Class<?> beanClass, @Nullable String beanName,
@Nullable Object[] specificInterceptors, TargetSource targetSource, boolean classOnly) {
if (this.beanFactory instanceof ConfigurableListableBeanFactory clbf) {
AutoProxyUtils.exposeTargetClass(clbf, beanName, beanClass);
}
ProxyFactory proxyFactory = new ProxyFactory();
proxyFactory.copyFrom(this);
if (proxyFactory.isProxyTargetClass()) {
// Explicit handling of JDK proxy targets and lambdas (for introduction advice scenarios)
if (Proxy.isProxyClass(beanClass) || ClassUtils.isLambdaClass(beanClass)) {
// Must allow for introductions; can't just set interfaces to the proxy's interfaces only.
for (Class<?> ifc : beanClass.getInterfaces()) {
proxyFactory.addInterface(ifc);
}
}
}
else {
// No proxyTargetClass flag enforced, let's apply our default checks...
// 未强制 proxyTargetClass 时做默认判断
if (shouldProxyTargetClass(beanClass, beanName)) {
proxyFactory.setProxyTargetClass(true);
}
else {
evaluateProxyInterfaces(beanClass, proxyFactory);
}
}
Advisor[] advisors = buildAdvisors(beanName, specificInterceptors);
proxyFactory.addAdvisors(advisors);
proxyFactory.setTargetSource(targetSource);
customizeProxyFactory(proxyFactory);
proxyFactory.setFrozen(this.freezeProxy);
if (advisorsPreFiltered()) {
proxyFactory.setPreFiltered(true);
}
// Use original ClassLoader if bean class not locally loaded in overriding class loader
ClassLoader classLoader = getProxyClassLoader();
if (classLoader instanceof SmartClassLoader smartClassLoader && classLoader != beanClass.getClassLoader()) {
classLoader = smartClassLoader.getOriginalClassLoader();
}
return (classOnly ? proxyFactory.getProxyClass(classLoader) : proxyFactory.getProxy(classLoader));
}
这段是"怎么建"的核心,逐块拆解:
copyFrom(this):把 Creator 自己的ProxyConfig配置(proxyTargetClass、optimize、exposeProxy、frozen等)复制到 ProxyFactory------@EnableAspectJAutoProxy(proxyTargetClass = true)就是经AopConfigUtils.forceAutoProxyCreatorToUseClassProxying()写进 Creator 的属性,再复制过来。- 接口评估分支 :没有强制类代理时,
evaluateProxyInterfaces()(父类ProxyProcessorSupport的方法)扫描目标类的接口,过滤掉配置回调接口(如InitializingBean、ApplicationContextAware)和内部语言接口后,存在"合理接口"就把它们注册给代理;一个合理接口都没有,直接回退setProxyTargetClass(true)------这就是无接口类必然走 CGLIB 的第一现场。 buildAdvisors():把匹配到的 Advisor(可能还包括全局interceptorNames指定的公共拦截器)统一用AdvisorAdapterRegistry#wrap()适配成Advisor[],加入 ProxyFactory。setTargetSource():目标对象包成SingletonTargetSource存入------代理被调用时真正执行逻辑的对象就是从这里取的(3.4 节会再次见到它)。classOnly参数 :结尾getProxyClass()与getProxy()二选一。这个参数是 6.x 的determineBeanType()传进来的------容器做类型预测(getBeanProvider、@Autowired按类型注入)时只需要代理的 Class 不需要实例,这是一个性能优化点。
ProxyFactory 拿到全部配置后,getProxy(classLoader) 的实现只有一行:
java
public Object getProxy(@Nullable ClassLoader classLoader) {
return createAopProxy().getProxy(classLoader);
}
createAopProxy() 在父类 ProxyCreatorSupport 里,同样是委托模式:
java
/**
* Subclasses should call this to get a new AOP proxy. They should <b>not</b>
* create an AOP proxy with {@code this} as an argument.
*/
protected final synchronized AopProxy createAopProxy() {
if (!this.active) {
activate();
}
return getAopProxyFactory().createAopProxy(this);
}
而 getAopProxyFactory() 默认返回的就是 DefaultAopProxyFactory.INSTANCE(构造器里初始化)------JDK 还是 CGLIB 的最终裁决权,交到了下一节这个工厂手上。
3.3 DefaultAopProxyFactory:JDK 还是 CGLIB
这是本文最重要的一个方法,全文只有十几行:
java
@Override
public AopProxy createAopProxy(AdvisedSupport config) throws AopConfigException {
if (config.isOptimize() || config.isProxyTargetClass() || !config.hasUserSuppliedInterfaces()) {
Class<?> targetClass = config.getTargetClass();
if (targetClass == null && config.getProxiedInterfaces().length == 0) {
throw new AopConfigException("TargetSource cannot determine target class: " +
"Either an interface or a target is required for proxy creation.");
}
if (targetClass == null || targetClass.isInterface() ||
Proxy.isProxyClass(targetClass) || ClassUtils.isLambdaClass(targetClass)) {
return new JdkDynamicAopProxy(config);
}
return new ObjenesisCglibAopProxy(config);
}
else {
return new JdkDynamicAopProxy(config);
}
}
外层 if 是"倾向 CGLIB"的三个条件,满足任意一个就进入 CGLIB 预选:
isOptimize():optimize开关,主动要求激进优化。JDK 代理每次调用都走反射,CGLIB 生成的字节码可以直接调用,历史上这个开关是给性能敏感场景留的(现在 JVM 对反射的优化已经很好,很少用);isProxyTargetClass():proxyTargetClass开关,即@EnableAspectJAutoProxy(proxyTargetClass = true)或 XML 的proxy-target-class="true"------显式要求按目标类代理;!hasUserSuppliedInterfaces():目标没有任何"用户供给"的接口 。注意是ProxyFactory里实际配置的接口列表------经过 3.2 节evaluateProxyInterfaces()的过滤,无接口类这里就是 false,取反后为 true,命中 CGLIB 预选。
进入预选后还有一个兜底判断 :即便三个条件都满足,如果目标是接口本身、JDK 代理类或 lambda(这些类型没法被子类化),仍然只能用 JDK 代理。剩下的才是真正的 ObjenesisCglibAopProxy。
外层 else 分支(三个条件都不满足:有用户接口、没开类代理、没开优化)直接走 JDK 代理。
结合 3.2 节的 evaluateProxyInterfaces(),可以整理出一张"什么场景用什么代理"的结论表:
| 场景 | proxyTargetClass | 目标类结构 | 最终代理 | 代理类名长相 |
|---|---|---|---|---|
| 显式要求类代理 | true |
任意普通类 | CGLIB | 目标类$$SpringCGLIB$$0 |
| 默认配置 | false(默认) |
无接口的类 | CGLIB(三条件之三命中) | 目标类$$SpringCGLIB$$0 |
| 默认配置 | false(默认) |
有合理接口的类 | JDK 动态代理 | jdk.proxyN.$Proxy数字 |
| 目标是接口 / JDK 代理类 / lambda | 任意 | 特殊类型 | JDK 动态代理(兜底) | jdk.proxyN.$Proxy数字 |
| Spring Boot 2.x 起默认 | true(Boot 的 AopAutoConfiguration 默认) |
任意普通类 | CGLIB | 目标类$$SpringCGLIB$$0 |
一句话结论:proxyTargetClass = true 一定 CGLIB;默认配置下有接口走 JDK、无接口走 CGLIB;Boot 从 2.0 起把默认改成 CGLIB(避免接口方法拦截不全的坑),需要 JDK 代理时要显式声明。第四节用 demo 逐行验证这张表。
3.4 两种代理的 getProxy 关键段
裁决完成,两条路线分别生成代理。
JDK 路线 :JdkDynamicAopProxy 同时实现了 AopProxy 和 JDK 的 InvocationHandler------代理类拦截到的所有方法调用都会回调它自己的 invoke()。先看生成:
java
@Override
public Object getProxy(@Nullable ClassLoader classLoader) {
if (logger.isTraceEnabled()) {
logger.trace("Creating JDK dynamic proxy: " + this.advised.getTargetSource());
}
return Proxy.newProxyInstance(determineClassLoader(classLoader), this.cache.proxiedInterfaces, this);
}
Proxy.newProxyInstance(classLoader, interfaces, invocationHandler) 是 JDK 的标准 API,生成的代理类实现 interfaces 里的全部接口($Proxy 命名),所有方法转发给第三个参数------也就是 this。这里的 this.cache 是 6.1.3 引入的 ProxiedInterfacesCache,除了缓存最终的接口数组,还预扫描了接口上有没有定义 equals / hashCode 方法(下面马上用到)。
invoke() 的完整逻辑属于(八)拦截器链的范畴,这里只看它开头的契约方法处理:
java
@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 {
if (!this.cache.equalsDefined && AopUtils.isEqualsMethod(method)) {
// The target does not implement the equals(Object) method itself.
return equals(args[0]);
}
else if (!this.cache.hashCodeDefined && AopUtils.isHashCodeMethod(method)) {
// The target does not implement the hashCode() method itself.
return hashCode();
}
else if (method.getDeclaringClass() == DecoratingProxy.class) {
// There is only getDecoratedClass() declared -> dispatch to proxy config.
return AopProxyUtils.ultimateTargetClass(this.advised);
}
else if (!this.advised.opaque && method.getDeclaringClass().isInterface() &&
method.getDeclaringClass().isAssignableFrom(Advised.class)) {
// Service invocations on ProxyConfig with the proxy config...
return AopUtils.invokeJoinpointUsingReflection(this.advised, method, args);
}
// ...(略)exposeProxy、获取 target、组装拦截器链、proceed()
// (八)AOP 原理(下)从这里展开
}
finally {
// ...(略)
}
}
equals / hashCode 这两个从 Object 继承的方法没有接口签名 ,JDK 代理类无法把它们路由到目标对象(目标不在接口上),所以 Spring 在这里替它们定了契约:由代理自己基于"接口 + Advisor + TargetSource"实现等价语义,而不是转发给目标。ProxiedInterfacesCache 里那两个 equalsDefined / hashCodeDefined 标志就是优化点:如果用户接口里自己声明了 equals/hashCode,才按正常增强链走。Advised 分支则让代理暴露自己的配置(Advised 接口方法直接调度到 advised 配置对象),这是 AopUtils.isAopProxy() 能做运行期判断的基础。
CGLIB 路线 :入口在 CglibAopProxy#getProxy(),统一进 buildProxy():
java
private Object buildProxy(@Nullable ClassLoader classLoader, boolean classOnly) {
if (logger.isTraceEnabled()) {
logger.trace("Creating CGLIB proxy: " + this.advised.getTargetSource());
}
try {
Class<?> rootClass = this.advised.getTargetClass();
Assert.state(rootClass != null, "Target class must be available for creating a CGLIB proxy");
Class<?> proxySuperClass = rootClass;
// 目标本身已是 CGLIB 代理类时,上提一层作为父类,并把接口补进来
if (rootClass.getName().contains(ClassUtils.CGLIB_CLASS_SEPARATOR)) {
proxySuperClass = rootClass.getSuperclass();
Class<?>[] additionalInterfaces = rootClass.getInterfaces();
for (Class<?> additionalInterface : additionalInterfaces) {
this.advised.addInterface(additionalInterface);
}
}
// Validate the class, writing log messages as necessary.
// 校验 final 方法等无法代理的成员,输出告警日志
validateClassIfNecessary(proxySuperClass, classLoader);
// Configure CGLIB Enhancer...
Enhancer enhancer = createEnhancer();
if (classLoader != null) {
enhancer.setClassLoader(classLoader);
// ...(略)热重载 ClassLoader 的缓存开关
}
enhancer.setSuperclass(proxySuperClass);
enhancer.setInterfaces(AopProxyUtils.completeProxiedInterfaces(this.advised));
enhancer.setNamingPolicy(SpringNamingPolicy.INSTANCE);
// ...(略)strategy 与 AOT 相关设置
Callback[] callbacks = getCallbacks(rootClass);
Class<?>[] types = new Class<?>[callbacks.length];
for (int x = 0; x < types.length; x++) {
types[x] = callbacks[x].getClass();
}
// fixedInterceptorMap only populated at this point, after getCallbacks call above
ProxyCallbackFilter filter = new ProxyCallbackFilter(
this.advised.getConfigurationOnlyCopy(), this.fixedInterceptorMap, this.fixedInterceptorOffset);
enhancer.setCallbackFilter(filter);
enhancer.setCallbackTypes(types);
// Generate the proxy class and create a proxy instance.
// 生成代理类并创建代理实例
try {
return (classOnly ? createProxyClass(enhancer) : createProxyClassAndInstance(enhancer, callbacks));
}
finally {
// ...(略)filter 降为 key-only 状态用于类缓存
}
}
catch (CodeGenerationException | IllegalArgumentException ex) {
throw new AopConfigException("Could not generate CGLIB subclass of " + this.advised.getTargetClass() +
": Common causes of this problem include using a final class or a non-visible class", ex);
}
catch (Throwable ex) {
// TargetSource.getTarget() failed
throw new AopConfigException("Unexpected AOP exception", ex);
}
}
几处关键点:
SpringNamingPolicy:给生成的子类命名时追加$$SpringCGLIB$$分隔符------demo 里我们打印的类名就是这个策略的产物;validateClassIfNecessary():遍历方法检查final,final 方法无法被子类覆盖、也就无法被拦截,有告警日志。这就是"CGLIB 不能代理 final 类/final 方法"的出处,兜底异常信息里也写明了这个常见病因;getCallbacks(rootClass):构建回调链,主干是一个 7 元素的回调数组,ProxyCallbackFilter按方法逐个决定用哪个回调:
java
Callback[] mainCallbacks = new Callback[] {
aopInterceptor, // for normal advice
targetInterceptor, // invoke target without considering advice, if optimized
new SerializableNoOp(), // no override for methods mapped to this
targetDispatcher, this.advisedDispatcher,
new EqualsInterceptor(this.advised),
new HashCodeInterceptor(this.advised)
};
第一个 DynamicAdvisedInterceptor 是主力(普通带通知的方法调用全走它,内部同样组装拦截器链,链的逻辑留到(八));后面几个分别对应"无通知直达目标"、"方法原样放行"、" Advised 接口调度",以及和 JDK 路线对称的 equals/hashCode 契约。静态 Target + frozen 配置时还会追加固定链回调做性能优化(fixedCallbacks),这里不展开。
- 实例的创建 :CGLIB 生成的代理是目标类的子类 ,
enhancer.create()默认会调用目标类的构造器。真正干这活的是ObjenesisCglibAopProxy(3.3 节裁决出来的就是这个子类),它重写了createProxyClassAndInstance():
java
@Override
protected Object createProxyClassAndInstance(Enhancer enhancer, Callback[] callbacks) {
Class<?> proxyClass = enhancer.createClass();
Object proxyInstance = null;
if (objenesis.isWorthTrying()) {
try {
proxyInstance = objenesis.newInstance(proxyClass, enhancer.getUseCache());
}
catch (Throwable ex) {
logger.debug("Unable to instantiate proxy using Objenesis, " +
"falling back to regular proxy construction", ex);
}
}
if (proxyInstance == null) {
// ...(略)回退:走常规构造器创建
}
// ...(略)setCallbacks
}
用 Objenesis 不调用任何构造器 就实例化代理------为什么?如果走目标类构造器,构造器里的初始化逻辑(依赖注入前的字段赋值、构造器里的副作用)会在代理对象上执行两次且时机不对;Objenesis 绕开构造器创建"空白"实例,字段初始化只留在真正的目标对象上,代理只是壳。这就是 ObjenesisCglibAopProxy 类名里 Objenesis 的由来。
完整链路用时序图收拢一下(以默认配置、有接口的 Bean 为例):

四、Demo 实战验证
以上分析整理成一个可运行的纯 Java Maven 工程(文末有完整代码地址),依赖只有三样:spring-context、spring-aop、aspectjweaver,版本 6.2.5,JDK 17,不引入 Spring Boot------这样看到的 proxyTargetClass 默认行为才是 Spring Framework 裸配置的行为。
先看被代理的两个 Bean:一个有接口,一个没有。
java
public interface GreetingService {
String greet(String name);
}
public class GreetingServiceImpl implements GreetingService {
@Override
public String greet(String name) {
return "Hello, " + name + "!";
}
}
/** 无接口类:验证默认配置下必然走 CGLIB */
public class PlainService {
public String hello() {
return "plain hello";
}
}
再写一个最简单的切面,保证两个 Bean 都命中(service..* 匹配 service 包下任意类的任意方法):
java
@Aspect
public class LogAspect {
@Before("execution(* com.example.aop.service..*.*(..))")
public void before(JoinPoint jp) {
System.out.println("[LogAspect] before -> " + jp.getSignature().toShortString());
}
}
顺带提醒一个写切点时的真实陷阱:表达式不要宽到把 @Configuration 配置类也匹配进去 ------配置类一旦命中切点会被代理成 CGLIB 子类,@Bean 工厂方法的调用会穿透增强链、反过来触发切面 Bean 的自引用创建,启动直接抛 BeanCurrentlyInCreationException(demo 里我们刻意把切点收窄到 service 包避开这个坑)。
关键在两个配置类的差别------只有注解属性不同:
java
@Configuration
@EnableAspectJAutoProxy // proxyTargetClass 默认 false
public class JdkConfig {
@Bean public GreetingServiceImpl greetingService() { return new GreetingServiceImpl(); }
@Bean public PlainService plainService() { return new PlainService(); }
@Bean public LogAspect logAspect() { return new LogAspect(); }
}
@Configuration
@EnableAspectJAutoProxy(proxyTargetClass = true) // 强制 CGLIB
public class CglibConfig {
@Bean public GreetingServiceImpl greetingService() { return new GreetingServiceImpl(); }
@Bean public PlainService plainService() { return new PlainService(); }
@Bean public LogAspect logAspect() { return new LogAspect(); }
}
主类分别启动两个容器,打印两个 Bean 的实际类型,并调用方法确认增强生效:
java
public class AopProxyDemoMain {
public static void main(String[] args) {
run("proxyTargetClass = false(Spring Framework 默认)", new AnnotationConfigApplicationContext(JdkConfig.class));
run("proxyTargetClass = true(强制 CGLIB)", new AnnotationConfigApplicationContext(CglibConfig.class));
}
private static void run(String title, AnnotationConfigApplicationContext ctx) {
System.out.println("========== " + title + " ==========");
System.out.println("greetingService 类型: " + ctx.getBean("greetingService").getClass().getName());
System.out.println("plainService 类型: " + ctx.getBean("plainService").getClass().getName());
GreetingService service = ctx.getBean("greetingService", GreetingService.class);
System.out.println("调用结果: " + service.greet("Spring"));
ctx.close();
System.out.println();
}
}
运行输出(节选,$Proxy 前的动态模块编号和 $Proxy 后的数字每次运行可能不同;JDK 8 时代代理类名是 com.sun.proxy.$ProxyN,JDK 9+ 改为动态模块 jdk.proxyN.$ProxyN):
text
========== proxyTargetClass = false(Spring Framework 默认) ==========
greetingService 类型: jdk.proxy3.$Proxy40
plainService 类型: com.example.aop.service.PlainService$$SpringCGLIB$$0
[LogAspect] before -> GreetingService.greet(..)
调用结果: Hello, Spring!
========== proxyTargetClass = true(强制 CGLIB) ==========
greetingService 类型: com.example.aop.service.GreetingServiceImpl$$SpringCGLIB$$0
plainService 类型: com.example.aop.service.PlainService$$SpringCGLIB$$0
[LogAspect] before -> GreetingServiceImpl.greet(..)
调用结果: Hello, Spring!
与源码分析逐条对应:
| 验证点 | 3.3 节源码依据 | 实际输出 |
|---|---|---|
| 默认配置 + 有接口 → JDK 代理 | hasUserSuppliedInterfaces() 为 true,三条件全不满足 → else 分支 JdkDynamicAopProxy |
jdk.proxy3.$Proxy40 |
| 默认配置 + 无接口 → CGLIB | evaluateProxyInterfaces() 找不到合理接口,回退 setProxyTargetClass(true) → ObjenesisCglibAopProxy |
PlainService$$SpringCGLIB$$0 |
proxyTargetClass = true → 全 CGLIB |
三条件之二命中,且目标是普通类 → ObjenesisCglibAopProxy |
两个 Bean 都带 $$SpringCGLIB$$0 |
| 增强生效 | Advisor 在 findEligibleAdvisors 中匹配成功,代理回调链含 LogAspect 的前置通知 |
[LogAspect] before -> ... |
两个细节值得玩味:一是增强日志里的方法签名------JDK 模式下是接口方法 GreetingService.greet(..),CGLIB 模式下是实现类方法 GreetingServiceImpl.greet(..),再次印证"JDK 代理只实现接口、CGLIB 是子类覆盖";二是默认配置下同一个容器里两种代理并存 ------有接口的 Bean 走 JDK,无接口的 Bean 走 CGLIB,DefaultAopProxyFactory 是逐 Bean 裁决的,不是容器级一刀切。很多"为什么这个 Bean 是 $$SpringCGLIB$$ 那个是 $Proxy"的困惑,根源就在这。
最后用一张图把本文的知识点归纳一下:

五、总结
代理的创建由 AbstractAutoProxyCreator 这个 BPP 收口:注册链经 @EnableAspectJAutoProxy → AopConfigUtils 的升级机制落定为 AnnotationAwareAspectJAutoProxyCreator,在 postProcessAfterInitialization(循环依赖时提前到 getEarlyBeanReference)里经 wrapIfNecessary 判断------找候选、匹配切点、排序,命中则用 ProxyFactory 组装(TargetSource + Advisor + 接口评估),最终由 DefaultAopProxyFactory 裁决 JDK(有接口、未开类代理)还是 CGLIB(强制类代理或无接口),后者用 Objenesis 免构造器实例化子类代理。至于代理生成之后,调用是如何穿过 Advisor 链到达目标方法的,五种通知的执行顺序如何,下一篇见。
下一篇我们分析 AOP 原理(下):拦截器链与执行顺序------ReflectiveMethodInvocation#proceed() 如何驱动责任链,@Around、@Before、@After、@AfterReturning、@AfterThrowing 各自的进出时机与顺序规则。
Demo 完整代码 :Spring/S07-AOP上/aop-proxy-demo(Spring Framework 6.2.5 + JDK 17,mvn compile exec:java 运行,控制台输出两种配置下代理类型的对比)
专栏往期:
- SpringMVC 6+源码分析(一)初始化流程
- SpringMVC 6+源码分析(二)DispatcherServlet实例化流程 1
- SpringMVC 6+源码分析(三)DispatcherServlet实例化流程 2
- SpringMVC 6+源码分析(四)DispatcherServlet实例化流程 3------HandlerAdapter初始化
- SpringMVC 6+源码分析(五)执行流程
- SpringMVC 6+源码分析(六)参数处理
- SpringMVC 6+源码分析(七)返回值处理
- SpringMVC 6+源码分析(八)拦截器
- SpringMVC 6+源码分析(九)异常处理
- SpringMVC 6+源码分析(十)数据绑定
- SpringMVC 6+源码分析(十一)视图渲染与异步
- Spring 源码分析(一)IOC 容器总览与 refresh() 全景
- Spring 源码分析(二)配置类的解析与扫描
- Spring 源码分析(三)BeanFactoryPostProcessor 与占位符
- Spring 源码分析(四)Bean 生命周期(上):实例化与属性填充
- Spring 源码分析(五)Bean 生命周期(下)
- Spring 源码分析(六)循环依赖与三级缓存
本文为「源码学习」专栏系列文章,转载请注明出处。相互学习,共同进步!