Spring 源码分析(七)AOP 原理(上):代理的创建

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 预选:

  1. isOptimize() :optimize 开关,主动要求激进优化。JDK 代理每次调用都走反射,CGLIB 生成的字节码可以直接调用,历史上这个开关是给性能敏感场景留的(现在 JVM 对反射的优化已经很好,很少用);
  2. isProxyTargetClass() :proxyTargetClass 开关,即 @EnableAspectJAutoProxy(proxyTargetClass = true) 或 XML 的 proxy-target-class="true"------显式要求按目标类代理;
  3. !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 运行,控制台输出两种配置下代理类型的对比)

专栏往期:

本文为「源码学习」专栏系列文章,转载请注明出处。相互学习,共同进步!

相关推荐
Tangq一定可以的19 分钟前
Spring AI Advisor 详解 - 给大模型调用加上“切面“,日志/过滤/记忆一键搞定
java·后端·spring
小巫编程室1 小时前
我造了一个 Java 能力包:让 AI 直接调用你的业务代码
java·前端·后端
十有八七1 小时前
手搓 Agent(五):学会翻书——RAG,先查资料再回答
前端·人工智能·后端
Swot1 小时前
产品 RAG 知识库与 AI 顾问 设计与实现
前端·后端
深入云栈1 小时前
Netty 4.2.x 源码深度解析 (二十四):池化内存分配 —— PoolArena、PoolChunk 与 PoolSubpage
java·后端·架构
ServBay2 小时前
PHP 8.6 最新发布:语法更新、实用函数与升级要点
后端·php
惜.己2 小时前
Java结合idea简单使用Playwright
java·开发语言·自动化
我不会起名字3223 小时前
Agent 总调错工具?MCP 接进 Go 后端的 4 个约束
后端·go·agent·mcp
考虑考虑3 小时前
git刷新远程分支列表
git·后端·gitlab