Spring分析-AOP
1.案例引入
在上一篇文章中，【Spring–IOC】【https://www.cnblogs.com/jackjavacpp/p/18829545】，我们了解到了IOC容器的创建过程，在文末也提到了AOP相关，但是没有作细致分析，这篇文章就结合示例，来详细分析一下Spring-AOP。
本文章示例代码见该仓库：【spring】中的“spring”模块。
仓库地址：https://gitee.com/quercus-sp204/sourcecode-and-demos
本节AOP示例代码如下：[ 在springaop 包下、然后测试类就是Main类里面的aop()方法 ]
@Component("dog")
public class Dog {
public Dog() { }
public void wangwang() {
System.out.println("wangwang --- 狗");
}
}
public interface Life {
void create();
void wangwang();
}
@Component(value = "lifeImpl")
public class LifeImpl implements Life {
@Override
public void create() {
System.out.println("[]--生命创建");
}
@Override
public void wangwang() {
System.out.println("[]--生命 汪汪汪");
}
public void wangwang( String msg ) {
System.out.println("=========== " + msg);
create(); wangwang();
System.out.println("===========");
}
}
// advice.java
@Component
@Aspect
public class MyAdvice {
private static final String dogExpression = "execution(* com.feng.springaop.*.wangwang*(..))";
@Around(dogExpression)
public Object aroundAdvice(ProceedingJoinPoint joinPoint) throws Throwable {
System.out.println("##########【DOG-环绕通知中的前置通知】##########");
Object returnVale = joinPoint.proceed();
System.out.println("##########【DOG-环绕通知中的后置通知】##########");
return returnVale;
}
}
// 一个普通的，没有配置任何通知
@Component
public class Cat {
public Cat() { }
public void miaomiao() {
System.out.println("猫 喵喵");
}
}
//Main.java
@Configuration
// @ComponentScan("com.feng.springioc") // 循环依赖分析 && IOC分析
@ComponentScan("com.feng.springaop") // spring-aop分析
@EnableAspectJAutoProxy
//@EnableAspectJAutoProxy(proxyTargetClass = true) // cglib
public class Main {
public static void main(String[] args) {
// xunhuan();
aop();
}
public static void aop() {
ApplicationContext context = new AnnotationConfigApplicationContext(Main.class);
Dog dog = context.getBean("dog", Dog.class);
dog.wangwang();
System.out.println(dog.getClass().getName());
Life impl = context.getBean("lifeImpl", Life.class);
impl.wangwang();
System.out.println(impl.getClass().getName());
Cat cat = context.getBean("cat", Cat.class);
cat.miaomiao();
System.out.println(cat.getClass().getName());
}
}
上面的示例代码挺简单的，运行上面的测试代码，我们可以得到如下输出：
##########【DOG-环绕通知中的前置通知】##########
wangwang --- 狗
##########【DOG-环绕通知中的后置通知】##########
com.feng.springaop.Dog$$EnhancerBySpringCGLIB$$563f1145
##########【DOG-环绕通知中的前置通知】##########
[]--生命 汪汪汪
##########【DOG-环绕通知中的后置通知】##########
com.sun.proxy.$Proxy17
猫 喵喵
com.feng.springaop.Cat
从输出内容可以看到，dog对象的bean是走的cglib的动态代理，由于lifeImpl实现了接口，故其采用的是jdk动态代理，但是猫猫确实是一个实打实的我们的对象。
动态代理不知道的可以看这篇文章：【动态代理】：https://blog.csdn.net/okok__TXF/article/details/144191784
可以得知是创建了代理对象，然后执行就是将“通知”和实际“执行的逻辑”组合在一起了，那么我们就从SpringAOP 是如何创建代理对象、执行过程是什么样子这两个方面来分析一下其AOP。
2.代理对象的创建
在前一篇文章中，我们得知，代理对象的创建是在initializeBean(xx)方法里面进行的，我们来验证一下：
首先debug到cat对象的初始化：如下图【在return的时候猫对象仍然是Cat类型的】
然后再看dog对象的初始化：如下图 【经过了图中绿色下划线之后，类型发生了变化CGLIB$$xxx的了】
在看一下lifeImpl的初始化：如下图 【经过了图中绿色下划线之后，类型发生了变化$Proxy的了】
经过上面的对比：我们可以得知，代理对象的生成是在wrappedBean = applyBeanPostProcessorsAfterInitialization(wrappedBean, beanName);里面的，此外如果实现了接口，那么就是jdk动态代理生成的代理对象、如果没有实现接口，那么就是走的CGLIB生成的代理对象。
目标很明确了，我们分析一下applyBeanPostProcessorsAfterInitialization方法就可以了。
进入到这个方法里面，debug调试过后
发现dog经过AnnotationAwareAspectJAutoProxyCreator.postProcessAfterInitialization(result, beanName) 方法之后，current就变成了 CGLIB的代理对象，说明这个方法大有奥秘！后面的lifeImpl对象亦是如此，就不给出图片阐述了。那为什么cat前后还是cat呢，并没有发生变化呢？
// 实际上是到了下面的类的postProcessAfterInitialization方法
// AbstractAutoProxyCreator.java 实现了BeanPostProcessor接口
public abstract class AbstractAutoProxyCreator extends ProxyProcessorSupport
implements SmartInstantiationAwareBeanPostProcessor, BeanFactoryAware {
@Override
public Object postProcessAfterInitialization(@Nullable Object bean, String beanName) {
if (bean != null) {
Object cacheKey = getCacheKey(bean.getClass(), beanName);
// 检查该 Bean 是否已被提前代理（如循环依赖中的早期引用）
if (this.earlyProxyReferences.remove(cacheKey) != bean) {
return wrapIfNecessary(bean, beanName, cacheKey);
}
}
return bean;
}
}
postProcessAfterInitialization()方法是 BeanPostProcessor 接口的实现，作用于 Bean 初始化之后（如 @PostConstruct 执行后），主要用于处理 Spring AOP 的代理逻辑。其核心目标是确保 Bean 在初始化完成后，根据需要生成代理对象，同时避免重复代理（尤其是在存在循环依赖时）。
此处的this.earlyProxyReferences.remove(cacheKey)就是从早期代理引用里面取出并移除该key的早期代理引用对象，来进行比对。这个earlyProxyReferences在哪里put呢？
在IOC那一章里面，在属性填充之前有这样一段代码，在三级缓存中添加了如下对象
// 缓存早期单例，以便能够解析循环引用
boolean earlySingletonExposure = (mbd.isSingleton() && this.allowCircularReferences &&
isSingletonCurrentlyInCreation(beanName));
if (earlySingletonExposure) {
....
addSingletonFactory(beanName, () -> getEarlyBeanReference(beanName, mbd, bean));
}
// 这个getEarlyBeanReference，最后是来到了
// AbstractAutoProxyCreator.java
@Override
public Object getEarlyBeanReference(Object bean, String beanName) {
Object cacheKey = getCacheKey(bean.getClass(), beanName);
this.earlyProxyReferences.put(cacheKey, bean); // 往早期代理引用放了一个对象--这里put的
return wrapIfNecessary(bean, beanName, cacheKey);
}
// return的是wrapIfNecessary(bean, beanName, cacheKey)
此章是没有循环引用的，只有循环依赖的时候才会用到三级缓存里面的东西，也就是循环依赖的时候才会往earlyProxyReferences中put东西。为什么？见后续文章**【spring循环依赖的解决】**。
那么这里的earlyProxyReferences就肯定一直都是空的，故在AbstractAutoProxyCreator :: postProcessAfterInitialization() 方法里面会走
if (this.earlyProxyReferences.remove(cacheKey) != bean) {
return wrapIfNecessary(bean, beanName, cacheKey); // 走这里
}
这个wrapIfNecessary是什么，下面来看看
protected Object wrapIfNecessary(Object bean, String beanName, Object cacheKey) {
//1. 如果该 Bean 已经被手动指定 TargetSource（如通过自定义 Scope），直接返回原始 Bean
if (StringUtils.hasLength(beanName) && this.targetSourcedBeans.contains(beanName))
return bean;
// 2. 如果缓存中标记该 Bean 不需要代理，直接返回
if (Boolean.FALSE.equals(this.advisedBeans.get(cacheKey)))
return bean;
// 3. 检查是否为基础设施类（如 Spring 内部类）或需要跳过代理的 Bean
if (isInfrastructureClass(bean.getClass()) || shouldSkip(bean.getClass(), beanName)) {
this.advisedBeans.put(cacheKey, Boolean.FALSE);
return bean;
}
// 4. 获取适用于该 Bean 的增强器（Advisors/Advices）**
Object[] specificInterceptors = getAdvicesAndAdvisorsForBean(bean.getClass(), beanName, null);
if (specificInterceptors != DO_NOT_PROXY) {
// 标记该 Bean 需要代理
this.advisedBeans.put(cacheKey, Boolean.TRUE);
// 5.创建代理对象 **
Object proxy = createProxy(
bean.getClass(), beanName, specificInterceptors, new SingletonTargetSource(bean));
this.proxyTypes.put(cacheKey, proxy.getClass());// 缓存代理类型，后续可通过 getBean 直接返回代理对象
return proxy;
}
// 6. 无增强器，标记该 Bean 不需要代理
this.advisedBeans.put(cacheKey, Boolean.FALSE);
return bean;
}
**一、获取适用于该 Bean 的增强器：**getAdvicesAndAdvisorsForBean(bean.getClass(), beanName, null);
// AbstractAdvisorAutoProxyCreator.java
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();
}
// 只看比较重要的1 2两点
protected List<Advisor> findEligibleAdvisors(Class<?> beanClass, String beanName) {
// 1.获取候选Advisor
List<Advisor> candidateAdvisors = findCandidateAdvisors();
// 2.获取适用于该bean的Advisor: 例如Pointcut匹配
List<Advisor> eligibleAdvisors = findAdvisorsThatCanApply(candidateAdvisors, beanClass, beanName);
extendAdvisors(eligibleAdvisors); // 扩展
if (!eligibleAdvisors.isEmpty()) {
eligibleAdvisors = sortAdvisors(eligibleAdvisors); // 排序
}
return eligibleAdvisors;
}
//第1点：候选Advisor AnnotationAwareAspectJAutoProxyCreator.java
@Override
protected List<Advisor> findCandidateAdvisors() {
// Add all the Spring advisors found according to superclass rules.
List<Advisor> advisors = super.findCandidateAdvisors();
// 为 Bean Factory 中的所有 AspectJ 方面构建 Advisor。
if (this.aspectJAdvisorsBuilder != null) {
advisors.addAll(this.aspectJAdvisorsBuilder.buildAspectJAdvisors()); // 进入
}
return advisors;
}
//BeanFactoryAspectJAdvisorsBuilder.java
public List<Advisor> buildAspectJAdvisors() {
...
if (this.advisorFactory.isAspect(beanType)) { // @Aspect
aspectNames.add(beanName);
AspectMetadata amd = new AspectMetadata(beanType, beanName);
if (amd.getAjType().getPerClause().getKind() == PerClauseKind.SINGLETON) {
MetadataAwareAspectInstanceFactory factory =
new BeanFactoryAspectInstanceFactory(this.beanFactory, beanName);
List<Advisor> classAdvisors = this.advisorFactory.getAdvisors(factory);
if (this.beanFactory.isSingleton(beanName)) {
this.advisorsCache.put(beanName, classAdvisors);
}
else {
this.aspectFactoryCache.put(beanName, factory);
}
advisors.addAll(classAdvisors);
}
else {
。。。
}
}
....
}
如图，找到了我们的MyAdvice.
// 第2点：获取适用于该bean的Advisor -- 自己debug吧。。。
// 我这就不给了,反正就是看candidateAdvisors匹不匹配嘛
protected List<Advisor> findAdvisorsThatCanApply(
List<Advisor> candidateAdvisors, Class<?> beanClass, String beanName) {
ProxyCreationContext.setCurrentProxiedBeanName(beanName);
try {
return AopUtils.findAdvisorsThatCanApply(candidateAdvisors, beanClass);
}
finally {
ProxyCreationContext.setCurrentProxiedBeanName(null);
}
}
在例子中，创建cat的时候，找不到合适的Advice，所以第二步就不会执行咯，故就不需要创建代理对象了
二、创建代理对象 : createProxy(xxx, xx, xxx, xxx) 【本文就以cglib创建代理对象为主，jdk动态代理创建就由读者自行调试分析了】
createProxy 是 Spring AOP 中 创建代理对象的核心方法，位于 AbstractAutoProxyCreator 类中。它负责根据 Bean 的配置和增强器（Advice/Advisors）生成 JDK 动态代理或 CGLIB 代理对象
// specificInterceptors就是第一步找到的advice中匹配该bean的东西，这里叫做拦截器
protected Object createProxy(Class<?> beanClass, @Nullable String beanName,
@Nullable Object[] specificInterceptors, TargetSource targetSource) {
...
if (proxyFactory.isProxyTargetClass()) {
// 强制使用 CGLIB 代理 --
if (Proxy.isProxyClass(beanClass) || ClassUtils.isLambdaClass(beanClass)) {
// 处理已被 JDK 代理的类或 Lambda 表达式
for (Class<?> ifc : beanClass.getInterfaces()) {
proxyFactory.addInterface(ifc); // 添加接口（确保引入增强器生效）
}
}
} else {
// 根据默认规则选择代理类型
if (shouldProxyTargetClass(beanClass, beanName)) {
// 如果是true-强制使用 CGLIB，即使目标类实现了接口
proxyFactory.setProxyTargetClass(true); // 强制 CGLIB
} else {
evaluateProxyInterfaces(beanClass, proxyFactory); // 检查接口决定代理类型
}
}
...
//构建并添加增强器（Advisors）
//将 specificInterceptors（如 MethodInterceptor）转换为 Spring 的 Advisor 对象。
Advisor[] advisors = buildAdvisors(beanName, specificInterceptors);
proxyFactory.addAdvisors(advisors);
...
//选择类加载器并生成代理
ClassLoader classLoader = getProxyClassLoader();
if (classLoader instanceof SmartClassLoader && classLoader != beanClass.getClassLoader()) {
classLoader = ((SmartClassLoader) classLoader).getOriginalClassLoader();
}
return proxyFactory.getProxy(classLoader);
}
上面最后是return proxyFactory.getProxy(classLoader); — 下面以dog对象为例子
// CglibAopProxy.java
@Override
public Object getProxy(@Nullable ClassLoader classLoader) {
try{
....
// 配置 CGLIB 的 Enhancer 对象
Enhancer enhancer = createEnhancer();
if (classLoader != null) {// 设置类加载器
enhancer.setClassLoader(classLoader);
if (classLoader instanceof SmartClassLoader &&
((SmartClassLoader) classLoader).isClassReloadable(proxySuperClass)) {
enhancer.setUseCache(false);
}
}
// 设置代理类的父类
enhancer.setSuperclass(proxySuperClass);
// 设置代理类要实现的接口
enhancer.setInterfaces(AopProxyUtils.completeProxiedInterfaces(this.advised));
enhancer.setNamingPolicy(SpringNamingPolicy.INSTANCE);
enhancer.setStrategy(new ClassLoaderAwareGeneratorStrategy(classLoader));
// 获取回调函数数组---------【重点1】
Callback[] callbacks = getCallbacks(rootClass);
Class<?>[] types = new Class<?>[callbacks.length];
for (int x = 0; x < types.length; x++) {
types[x] = callbacks[x].getClass();
}
// 设置回调过滤器--------【重点2】
enhancer.setCallbackFilter(new ProxyCallbackFilter(
this.advised.getConfigurationOnlyCopy(), this.fixedInterceptorMap, this.fixedInterceptorOffset));
enhancer.setCallbackTypes(types);
// 生成代理类并创建代理实例 --------- 【重点3】
return createProxyClassAndInstance(enhancer, callbacks);
} ...
}
创建代理对象【重点1】getCallbacks(rootClass); 这个里面是什么呢？
private Callback[] getCallbacks(Class<?> rootClass) throws Exception {
// Parameters used for optimization choices...
boolean isFrozen = this.advised.isFrozen();
boolean exposeProxy = this.advised.isExposeProxy();
// 是否静态类，这里的静态并非指静态类，而是每次调用返回的实例都是否是不可变的
// 如单例模式的bean就是静态，而多例模式下的bean就不是静态
boolean isStatic = this.advised.getTargetSource().isStatic();
// DynamicAdvisedInterceptor：用于处理包含 AOP 通知的方法调用，
//它会根据配置的切面和通知逻辑来执行相应的增强操作。
//内部通过 ReflectiveMethodInvocation 链式调用通知逻辑。
Callback aopInterceptor = new DynamicAdvisedInterceptor(this.advised);
....
Callback[] mainCallbacks = new Callback[] {
aopInterceptor, // for normal advice
targetInterceptor, // 目标方法直接调用拦截器
new SerializableNoOp(), // no override for methods mapped to this
targetDispatcher, this.advisedDispatcher,
new EqualsInterceptor(this.advised),// 处理代理对象的 equals 方法
new HashCodeInterceptor(this.advised)// 处理代理对象的 hashCode 方法
};
Callback[] callbacks;
// 如果类是静态 && 配置冻结。则准备做一些优化策略
if (isStatic && isFrozen) {
Method[] methods = rootClass.getMethods();
Callback[] fixedCallbacks = new Callback[methods.length];
this.fixedInterceptorMap = CollectionUtils.newHashMap(methods.length);
// TODO: small memory optimization here (can skip creation for methods with no advice)
for (int x = 0; x < methods.length; x++) {
Method method = methods[x];
List<Object> chain = this.advised.getInterceptorsAndDynamicInterceptionAdvice(method, rootClass);
fixedCallbacks[x] = new FixedChainStaticTargetInterceptor(
chain, this.advised.getTargetSource().getTarget(), this.advised.getTargetClass());
this.fixedInterceptorMap.put(method, x);
}
callbacks = new Callback[mainCallbacks.length + fixedCallbacks.length];
System.arraycopy(mainCallbacks, 0, callbacks, 0, mainCallbacks.length);
System.arraycopy(fixedCallbacks, 0, callbacks, mainCallbacks.length, fixedCallbacks.length);
this.fixedInterceptorOffset = mainCallbacks.length;
}
else {
callbacks = mainCallbacks; //
}
return callbacks;
}
创建代理对象【重点2】ProxyCallbackFilter 回调过滤器
// Constants for CGLIB callback array indices
private static final int AOP_PROXY = 0;
private static final int INVOKE_TARGET = 1;
private static final int NO_OVERRIDE = 2;
private static final int DISPATCH_TARGET = 3;
private static final int DISPATCH_ADVISED = 4;
private static final int INVOKE_EQUALS = 5;
private static final int INVOKE_HASHCODE = 6;
public ProxyCallbackFilter(
AdvisedSupport advised, Map<Method, Integer> fixedInterceptorMap, int fixedInterceptorOffset) {
this.advised = advised;
this.fixedInterceptorMap = fixedInterceptorMap;
this.fixedInterceptorOffset = fixedInterceptorOffset;
}
@Override
public int accept(Method method) {
// 1. 如果当前方法被 final 修饰，则不代理该方法
//如果method 被 final 修饰，则无法代理
if (AopUtils.isFinalizeMethod(method)) {
...
return NO_OVERRIDE;
}
if (!this.advised.isOpaque() && method.getDeclaringClass().isInterface() &&
method.getDeclaringClass().isAssignableFrom(Advised.class)) {
return DISPATCH_ADVISED;
}
// 3. equals 方法
if (AopUtils.isEqualsMethod(method))
...
// 4.hashCode
if (AopUtils.isHashCodeMethod(method))
...
Class<?> targetClass = this.advised.getTargetClass();
List<?> chain = this.advised.getInterceptorsAndDynamicInterceptionAdvice(method, targetClass);
boolean haveAdvice = !chain.isEmpty();
boolean isFrozen = this.advised.isFrozen();
boolean exposeProxy = this.advised.isExposeProxy();
boolean isStatic = this.advised.getTargetSource().isStatic();
if (haveAdvice || !isFrozen) {
if (exposeProxy) {
...
return AOP_PROXY;
}
// Check to see if we have fixed interceptor to serve this method.
// Else use the AOP_PROXY.
if (isStatic && isFrozen && this.fixedInterceptorMap.containsKey(method)) {
...
// We know that we are optimizing so we can use the FixedStaticChainInterceptors.
int index = this.fixedInterceptorMap.get(method);
return (index + this.fixedInterceptorOffset);
}
else {
return AOP_PROXY;
}
}
else {
if (exposeProxy || !isStatic)
return INVOKE_TARGET;
Class<?> returnType = method.getReturnType();
if (targetClass != null && returnType.isAssignableFrom(targetClass)) {
...
return INVOKE_TARGET;
}
else
..
return DISPATCH_TARGET;
}
}
创建代理对象【重点3】生成代理类并创建代理实例 createProxyClassAndInstance(enhancer, callbacks);
// ObjenesisCglibAopProxy.java
@Override
protected Object createProxyClassAndInstance(Enhancer enhancer, Callback[] callbacks) {
Class<?> proxyClass = enhancer.createClass();
Object proxyInstance = null;
if (objenesis.isWorthTrying()) {
try {
//Objenesis 是一个专门用于绕过对象构造函数直接实例化对象的库。
proxyInstance = objenesis.newInstance(proxyClass, enhancer.getUseCache());
}
.....
}
// 当 Objenesis 失败时，通过反射调用默认或指定参数的构造方法。
if (proxyInstance == null) {
// Regular instantiation via default constructor...
try {
Constructor<?> ctor = (this.constructorArgs != null ?
proxyClass.getDeclaredConstructor(this.constructorArgTypes) :
proxyClass.getDeclaredConstructor());
ReflectionUtils.makeAccessible(ctor);
proxyInstance = (this.constructorArgs != null ?
ctor.newInstance(this.constructorArgs) : ctor.newInstance());
}
....
}
// 回调链决定了代理对象的方法拦截行为（如切面增强、直接调用目标方法等）。
((Factory) proxyInstance).setCallbacks(callbacks);
return proxyInstance;
}
3.执行过程
执行是怎么样的呢？
照样从案例的执行开始看起
public static void aop() {
ApplicationContext context = new AnnotationConfigApplicationContext(Main.class);
Dog dog = context.getBean("dog", Dog.class);
dog.wangwang();
System.out.println(dog.getClass().getName());
Life impl = context.getBean("lifeImpl", Life.class);
impl.wangwang();
System.out.println(impl.getClass().getName());
Cat cat = context.getBean("cat", Cat.class);
cat.miaomiao();
System.out.println(cat.getClass().getName());
}
先执行的dog的方法【cglib】、再执行impl的方法【jdk】，因为第一个没有实现接口，第二个实现了接口。
上一节我们可以知道是proxyFactory.getProxy(classLoader);创建的代理对象，实际上getProxy是AopProxy接口的方法，那么在Spring中该接口的直接实现类只有两个：
以第一个例子开头，dog肯定是CglibAopProxy的代理对象。【代理不会的看这里】：https://www.cnblogs.com/jackjavacpp/p/18582124
熟悉cglib的都知道，通过cglib生成的代理对象，然后使用该对象执行目标方法，会走设置的方法拦截器，上一章最后创建代理对象那一节里面的getCallbacks方法，第一个就new了DynamicAdvisedInterceptor对象，它是用于处理包含 AOP 通知的方法调用。我们点开CglibAopProxy里面的DynamicAdvisedInterceptor静态内部类看一下，肯定重写了intercept方法，不用想啊，这就是会代理的好处啊。
//CglibAopProxy.java的静态内部类 DynamicAdvisedInterceptor
//proxy：CGLIB 生成的代理对象。
//method：被调用的方法（目标方法的反射对象）
//args: 方法参数。
//methodProxy：CGLIB 的 MethodProxy 对象，用于直接调用目标方法（比反射高效）
public Object intercept(Object proxy, Method method, Object[] args, MethodProxy methodProxy) throws Throwable {
Object oldProxy = null;
boolean setProxyContext = false;
Object target = null;
//targetSource：目标对象来源（如单例、原型或池化对象）
TargetSource targetSource = this.advised.getTargetSource();
try {
if (this.advised.exposeProxy) { //暴露代理到当前线程上下文
//允许目标对象内部方法通过 AopContext.currentProxy() 获取代理对象，
//解决自调用（如 this.method()）时 AOP 失效的问题。
oldProxy = AopContext.setCurrentProxy(proxy);
setProxyContext = true;
}
target = targetSource.getTarget(); //获取被代理的原始对象
Class<?> targetClass = (target != null ? target.getClass() : null);
List<Object> chain = this.advised.getInterceptorsAndDynamicInterceptionAdvice(method, targetClass);
Object retVal;
// 无拦截器，直接调用目标方法
if (chain.isEmpty() && CglibMethodInvocation.isMethodProxyCompatible(method)) {
Object[] argsToUse = AopProxyUtils.adaptArgumentsIfNecessary(method, args);
retVal = invokeMethod(target, method, argsToUse, methodProxy);
}
else {
// 有拦截器，创建方法调用链并执行
//调用其 proceed() 方法，按顺序执行拦截器链。
retVal = new CglibMethodInvocation(proxy, target, method, args, targetClass, chain, methodProxy)
.proceed();
}
retVal = processReturnType(proxy, target, method, retVal);
return retVal;
}
finally {
if (target != null && !targetSource.isStatic()) {
targetSource.releaseTarget(target);
}
if (setProxyContext) {
AopContext.setCurrentProxy(oldProxy); // 恢复原始代理上下文
}
}
}
public boolean equals()...
public int hashCode()....
}
CglibMethodInvocation.java
private static class CglibMethodInvocation extends ReflectiveMethodInvocation {
@Override
@Nullable
public Object proceed() throws Throwable {
try {
return super.proceed();
}
....
}
}
//ReflectiveMethodInvocation.java
@Override
@Nullable
public Object proceed() throws Throwable {
//从索引-1开始
if (this.currentInterceptorIndex == this.interceptorsAndDynamicMethodMatchers.size() - 1) {
return invokeJoinpoint(); // 所有拦截器执行完毕，调用目标方法
}
// 获取下一个拦截器
Object interceptorOrInterceptionAdvice =
this.interceptorsAndDynamicMethodMatchers.get(++this.currentInterceptorIndex);
//若获取的拦截器是 InterceptorAndDynamicMethodMatcher 类型，需进行动态方法匹配
if (interceptorOrInterceptionAdvice instanceof InterceptorAndDynamicMethodMatcher) {
// Evaluate dynamic method matcher here: static part will already have
// been evaluated and found to match.
InterceptorAndDynamicMethodMatcher dm =
(InterceptorAndDynamicMethodMatcher) interceptorOrInterceptionAdvice;
Class<?> targetClass = (this.targetClass != null ? this.targetClass : this.method.getDeclaringClass());
//若匹配成功，调用拦截器的 invoke 方法，传入当前 ReflectiveMethodInvocation 对象。
//匹配就是在拦截器链执行过程中动态判断当前拦截器是否需要应用于目标方法调用
if (dm.methodMatcher.matches(this.method, targetClass, this.arguments)) {
return dm.interceptor.invoke(this);
}
else {
// 动态匹配失败，跳过当前拦截器，递归调用 proceed 方法执行下一个拦截器
return proceed();
}
}
else {
// 不是动态方法匹配器，直接调用拦截器的 invoke 方法
return ((MethodInterceptor) interceptorOrInterceptionAdvice).invoke(this);
}
}
上面一个小小的方法就包含了
- 拦截器链模式：
通过责任链模式按顺序执行拦截器，支持灵活扩展（如事务、日志、安全等）。 - 性能优化：
- 无拦截器时直接调用目标方法。
- 使用
MethodProxy代替反射调用。
- 上下文管理：
AopContext解决自调用问题。TargetSource管理目标对象的生命周期。
4.案例分析
下面就以@Transacional注解、自定义Advice相结合为例子，分析一下代理创建及其运行过程。
首先搭建一个项目，如下：
// 1.实体类对象
@Data
@AllArgsConstructor
@NoArgsConstructor
@TableName("user_tab")
public class User {
@TableId(type = IdType.AUTO)
private Integer id;
private String name;
private BigDecimal account;
}
// 2.Mapper接口
@Mapper
public interface UserMapper extends BaseMapper<User> {
}
// 3.service
@Service
public class UserService {
@Resource
private UserMapper userMapper;
@Transactional
public void insertUser() {
userMapper.insert(new User(null, "张三", new BigDecimal(100)));
System.out.println("================业务操作--执行插入");
//throw new RuntimeException("插入用户失败");
}
}
//4.配置AOP 和 数据源 、事务管理器
@Aspect
@Component
public class MyAdvice {
private static final String userExpression = "execution(* com.feng.springCaseAnalysis.service.UserService.*(..))";
@Before(userExpression)
public void beforeAdvice() {
System.out.println("Before通知 -- UserService 之前");
}
@Around(userExpression)
public Object aroundAdvice(ProceedingJoinPoint joinPoint) throws Throwable {
System.out.println("环绕通知 -- UserService 之前");
Object result = joinPoint.proceed();
System.out.println("环绕通知 -- UserService 之后");
return result;
}
}
// 配置类
@Configuration
@MapperScan("com.feng.springCaseAnalysis.mapper")
@EnableTransactionManagement
public class DataProjectConfig {
@Bean
public DataSource dataSource() {
// 创建数据源
DruidDataSource dataSource = new DruidDataSource();
dataSource.setUsername("root");
dataSource.setPassword("123456");
dataSource.setUrl("jdbc:mysql://127.0.0.1:3306/spring_analysis?useUnicode=true&characterEncoding=utf-8&useSSL=false&serverTimezone=Asia/Shanghai");
dataSource.setDriverClassName("com.mysql.cj.jdbc.Driver");
dataSource.setInitialSize(5);
return dataSource;
}
@Bean
public MybatisSqlSessionFactoryBean sqlSessionFactory(DataSource dataSource) {
MybatisSqlSessionFactoryBean factoryBean = new MybatisSqlSessionFactoryBean();
factoryBean.setDataSource(dataSource);
return factoryBean;
}
// 事务管理器
@Bean
public DataSourceTransactionManager transactionManager(DataSource dataSource) {
DataSourceTransactionManager transactionManager = new DataSourceTransactionManager();
transactionManager.setDataSource(dataSource);
return transactionManager;
}
}
//5.Main测试
@Configuration
@ComponentScan("com.feng.springCaseAnalysis") // spring-- Transactional 结合 自定义 Advice 分析
@EnableAspectJAutoProxy
public class Main {
public static void main(String[] args) {
AnnotationConfigApplicationContext context = new AnnotationConfigApplicationContext(Main.class);
UserService userService = context.getBean("userService", UserService.class);
try {
userService.insertUser();
} catch ( Exception e ) {
System.out.println("【Exception！！！】" + e.getMessage());
}
}
}
在上面的案例搭建好之后，我们仔细分析一下UserService的代理创建过程：
来到为UserService寻找advisor的这里，读者们还记得这在哪个阶段吗？然后进入里面就是List<Advisor> advisors = findEligibleAdvisors(beanClass, beanName);。
如上图所示，在候选的Advisors中，除了我们自定义的两个Advisor，还找到了另外一个 BeanFactoryTransactionAttributeSourceAdvisor，它也是一个PointCutAdvisor。在调用canApply( )方法的时候，会解析UserService所有方法上面有没有@Transactional注解，并解析里面的属性，这里insertUser方法有@Transactional注解，故匹配上了。
@Override
public boolean matches(Method method, Class<?> targetClass) {
/*
method: com.feng.springCaseAnalysis.service.UserService.insertUser
targetClass: class com.feng.springCaseAnalysis.service.UserService
*/
// 这里的tas是AnnotationTransactionAttributeSource
TransactionAttributeSource tas = getTransactionAttributeSource();
return (tas == null || tas.getTransactionAttribute(method, targetClass) != null);
}
所以elibibAdvisors都匹配上了，此时的elibibAdvisors里面有三个Advisor。然后创建代理对象，设置CallBack那些就同理了，如下图所示。
然后就返回代理对象咯。
可以看到经过applyBeanPostProcessorsAfterInitialization(wrappedBean, beanName);之后，WrapperBean变成了UserService$$EnhancerBySpringCGLIB$$a768552c@4109代理对象了。
执行就很简单了：
递归调用嘛。
// TransactionInterceptor.java
@Override
@Nullable
public Object invoke(MethodInvocation invocation) throws Throwable {
// Work out the target class: may be {@code null}.
// The TransactionAttributeSource should be passed the target class
// as well as the method, which may be from an interface.
Class<?> targetClass = (invocation.getThis() != null ? AopUtils.getTargetClass(invocation.getThis()) : null);
// Adapt to TransactionAspectSupport's invokeWithinTransaction...
return invokeWithinTransaction(invocation.getMethod(), targetClass, new CoroutinesInvocationCallback() {
@Override
@Nullable
public Object proceedWithInvocation() throws Throwable {
return invocation.proceed();
}
@Override
public Object getTarget() {
return invocation.getThis();
}
@Override
public Object[] getArguments() {
return invocation.getArguments();
}
});
}
// invocation是一个函数式接口，proceedWithInvocation实际上就是上面的invocation.proceed(),这样就完成了递归调用了
protected Object invokeWithinTransaction(Method method, @Nullable Class<?> targetClass,
final InvocationCallback invocation) throws Throwable {
....
PlatformTransactionManager ptm = asPlatformTransactionManager(tm);
final String joinpointIdentification = methodIdentification(method, targetClass, txAttr);
if (txAttr == null || !(ptm instanceof CallbackPreferringPlatformTransactionManager)) {
TransactionInfo txInfo = createTransactionIfNecessary(ptm, txAttr, joinpointIdentification);
Object retVal;
try {
// 调用下一层
retVal = invocation.proceedWithInvocation();
}
catch (Throwable ex) { // 捕获到异常了
// 在里面判断一些条件，然后事务回滚
completeTransactionAfterThrowing(txInfo, ex);
throw ex;
}
finally {
cleanupTransactionInfo(txInfo);
}
if (retVal != null && vavrPresent && VavrDelegate.isVavrTry(retVal)) {
// Set rollback-only in case of Vavr failure matching our rollback rules...
TransactionStatus status = txInfo.getTransactionStatus();
if (status != null && txAttr != null) {
retVal = VavrDelegate.evaluateTryFailure(retVal, txAttr, status);
}
}
commitTransactionAfterReturning(txInfo); // 提交事务
return retVal;
}
5.思考题: @Import注解
本章案例见importCase包：
为什么在第四章案例中，多了那么多和Transactional的bean？在配置类@EnableTransactionManagement这个是干嘛的？
@Target(ElementType.TYPE)
@Retention(RetentionPolicy.RUNTIME)
@Documented
@Import(TransactionManagementConfigurationSelector.class) // 有这个注解
public @interface EnableTransactionManagement {
....
}
这个@Import注解的作用：@Import只能用在类上 ，@Import通过快速导入的方式实现把实例加入spring的IOC容器中。
①主要用法：
1.直接填class数组: bean名称是该类的全类名
// 主测试类
ApplicationContext context = new AnnotationConfigApplicationContext(Main.class);
Student bean = context.getBean(Student.class);
for (String name : context.getBeanDefinitionNames()) {
System.out.println(name);
}
System.out.println("========");
System.out.println(bean);
// 配置类
@Configuration
@Import({Student.class})
public class Config {
}
// Student并没有被Spring管理，
// 但是通过@Import导进去了
@Data
@AllArgsConstructor
@NoArgsConstructor
public class Student {
private String name = "asd";
private Integer age = 10;
}
运行结果如下：
org.springframework.context.annotation.internalConfigurationAnnotationProcessor
org.springframework.context.annotation.internalAutowiredAnnotationProcessor
org.springframework.context.annotation.internalCommonAnnotationProcessor
org.springframework.context.event.internalEventListenerProcessor
org.springframework.context.event.internalEventListenerFactory
main
config
com.feng.importCase.Student //看这里！！！！
org.springframework.aop.config.internalAutoProxyCreator
========
Student(name=asd, age=10)
2.ImportSelector方式【SpringBoot中用的很多】：
@Configuration
//@Import({Student.class})
@Import({MyStudentImportSelector.class})
public class Config {
}
//MyStudentImportSelector.java
public class MyStudentImportSelector implements ImportSelector {
//参数： AnnotationMetadata表示当前被@Import注解给标注的所有注解信息
@Override
public String[] selectImports(AnnotationMetadata importingClassMetadata) {
return new String[]{"com.feng.importCase.Student"};
}
}
配置类改成导入Selector，需要导入的类，在该Selector中给出来，这样就可以把我的Student类导进容器里面了。
3.ImportBeanDefinitionRegistrar方式
同样是一个接口，类似于第二种ImportSelector用法，只不过这种用法更加地自定义化注册
public class StudentImportRegistrar implements ImportBeanDefinitionRegistrar {
@Override
public void registerBeanDefinitions(AnnotationMetadata importingClassMetadata, BeanDefinitionRegistry registry) {
RootBeanDefinition beanDefinition = new RootBeanDefinition(Student.class);
registry.registerBeanDefinition("haha-student", beanDefinition);
}
}
@Configuration
//@Import({Student.class})
//@Import({MyStudentImportSelector.class})
@Import({StudentImportRegistrar.class})
public class Config {
}
②源码解析
@Import是在下面这一步起作用的。
refresh()里面往下 ---->
// Invoke factory processors registered as beans in the context.
invokeBeanFactoryPostProcessors(beanFactory); ---->
|
PostProcessorRegistrationDelegate.invokeBeanFactoryPostProcessors(beanFactory, getBeanFactoryPostProcessors());
|
invokeBeanDefinitionRegistryPostProcessors(currentRegistryProcessors, registry, beanFactory.getApplicationStartup());
待读者自行分析把。嘿嘿嘿
end.参考
- https://blog.csdn.net/qq_36882793/article/details/119823785 【cglib 的代理过程】
- https://www.cnblogs.com/yichunguo/p/12122598.html 【import】
