Spring 5.x 源码之旅-43AOP之AnnotationAwareAspectJAutoProxyCreator

smart哥

于 2024-03-14 09:52:59 发布

阅读量669

点赞数 23

分类专栏： spring源码解析文章标签： spring spring源码

本文链接：https://blog.csdn.net/smart_an/article/details/136699420

版权

spring源码解析专栏收录该内容

94 篇文章 5 订阅

订阅专栏

作者简介：大家好，我是smart哥，前中兴通讯、美团架构师，现某互联网公司CTO

联系qq：184480602，加我进群，大家一起学习，一起进步，一起对抗互联网寒冬

学习必须往深处挖，挖的越深，基础越扎实！

阶段1、深入多线程

 阶段2、深入多线程设计模式

 阶段3、深入juc源码解析

阶段4、深入jdk其余源码解析

阶段5、深入jvm源码解析

码哥源码部分

码哥讲源码-原理源码篇【2024年最新大厂关于线程池使用的场景题】

码哥讲源码【炸雷啦！炸雷啦！黄光头他终于跑路啦！】

码哥讲源码-【jvm课程前置知识及c/c++调试环境搭建】

码哥讲源码-原理源码篇【揭秘join方法的唤醒本质上决定于jvm的底层析构函数】

码哥源码-原理源码篇【Doug Lea为什么要将成员变量赋值给局部变量后再操作？】

码哥讲源码【你水不是你的错,但是你胡说八道就是你不对了！】

码哥讲源码【谁再说Spring不支持多线程事务，你给我抽他！】

终结B站没人能讲清楚红黑树的历史，不服等你来踢馆！

打脸系列【020-3小时讲解MESI协议和volatile之间的关系，那些将x86下的验证结果当作最终结果的水货们请闭嘴】

AnnotationAwareAspectJAutoProxyCreator是什么

接着上一篇，好久没看这个图了，看上去很像很复杂，有些方法其实是子类实现了，他只是继承，你可以理解成一个可以在bean生命周期多次搞事的类。

AOP简单例子

今天我们来搞清楚AOP实现的原理，首先得有一个例子，弄个简单的。

MyLogAspects定义一个切面

里面定义了一个切点，某个包以及子包下的所有类的所有方法，添加一个Before注解方法，打个log而已。其实就是下面定义的MyService类的show方法做增强。

    @Aspect
    @Component
    public class MyLogAspects {
    
        /**
         * 修饰符 返回类型(一定要有) 包名.类名.方法名(一定要有) 参数
         */
        @Pointcut("execution(* com.ww.component.*.*(..))")
        public void pointCut() {
        }
    
        /**
         * 在目标方法执行后
         */
        @Before("pointCut()")
        public void logBefore() {
            System.out.println("logBefore");
        }

MyConfig配置类

加EnableAspectJAutoProxy注解，开启AOP，具体是怎么开启的，我上一篇文章讲了。

    @Configuration
    @EnableAspectJAutoProxy
    public class MyConfig {
    
        @Bean
        public IService getService() {
            return new MyService();
        }
    
        @Bean
        public MyLogAspects getMyLogAspects() {
            return new MyLogAspects();
        }
    }

MyService定义一个接口和实现类

我们要对show方法做增强。

    @Service
    public class MyService implements IService {
    
        @Override
        public void show() {
            System.out.println("MyService show");
        }
    }
    
    public interface IService {
        void show();
    }

测试代码

        @Test
        public void AopTest()  {
            AnnotationConfigApplicationContext applicationContext = new AnnotationConfigApplicationContext();
            applicationContext.register(MyConfig.class);
            applicationContext.refresh();
            IService bean = applicationContext.getBean(IService.class);
            bean.show();
        }

结果：

我们完成了最简单的AOP，接下来看看他是怎么做到的吧。

AOP是如何实现的

我们先不看源码，我们自己想象下，应该是先解析我们的MyLogAspects切面，然后知道哪些类的什么方法需要增强，然后在某个处理器处理的时候发现了那些类，然后进行代理，在方法的前面添加了一个方法可以打印信息，大致逻辑应该是这样，具体我们来看看吧。

MyLogAspects切面何时解析

前面我们有讲过有实例化之前的处理器处理，也就是applyBeanPostProcessorsBeforeInstantiation方法，因为我们的AnnotationAwareAspectJAutoProxyCreator也实现了这个方法，这个方法就可以把切面类给解析出来：

    @Override
    	public Object postProcessBeforeInstantiation(Class<?> beanClass, String beanName) {
    		Object cacheKey = getCacheKey(beanClass, beanName);
    
    		if (!StringUtils.hasLength(beanName) || !this.targetSourcedBeans.contains(beanName)) {
    			if (this.advisedBeans.containsKey(cacheKey)) {//查缓存，是否有处理过了，不管是不是需要通知增强的，只要处理过了就会放里面
    				return null;
    			}
    			if (isInfrastructureClass(beanClass) || shouldSkip(beanClass, beanName)) {
    				this.advisedBeans.put(cacheKey, Boolean.FALSE);//要跳过的直接设置FALSE
    				return null;
    			}
    		}
    
    		TargetSource targetSource = getCustomTargetSource(beanClass, beanName);
    		if (targetSource != null) {
    			if (StringUtils.hasLength(beanName)) {
    				this.targetSourcedBeans.add(beanName);
    			}
    			Object[] specificInterceptors = getAdvicesAndAdvisorsForBean(beanClass, beanName, targetSource);
    			Object proxy = createProxy(beanClass, beanName, specificInterceptors, targetSource);
    			this.proxyTypes.put(cacheKey, proxy.getClass());
    			return proxy;
    		}
    
    		return null;
    	}

isInfrastructureClass是否是内部基础类

    	@Override
    	protected boolean isInfrastructureClass(Class<?> beanClass) {
    		return (super.isInfrastructureClass(beanClass) ||
    				(this.aspectJAdvisorFactory != null && this.aspectJAdvisorFactory.isAspect(beanClass)));
    	}

AbstractAutoProxyCreator的isInfrastructureClass

主要看bean的类型是不是内部的类型，比如Advice，Pointcut，Advisor，AopInfrastructureBean这些是跟AOP相关的，所以不应该被处理。

    	protected boolean isInfrastructureClass(Class<?> beanClass) {
    		boolean retVal = Advice.class.isAssignableFrom(beanClass) ||
    				Pointcut.class.isAssignableFrom(beanClass) ||
    				Advisor.class.isAssignableFrom(beanClass) ||
    				AopInfrastructureBean.class.isAssignableFrom(beanClass);
    		if (retVal && logger.isTraceEnabled()) {
    			logger.trace("Did not attempt to auto-proxy infrastructure class [" + beanClass.getName() + "]");
    		}
    		return retVal;
    	}

AbstractAspectJAdvisorFactory的isAspect是否有Aspect注解

主要是看是否有Aspect注解，还有就是没有ajc$开头的属性名。

    	@Override
    	public boolean isAspect(Class<?> clazz) {
    		return (hasAspectAnnotation(clazz) && !compiledByAjc(clazz));
    	}

AspectJAwareAdvisorAutoProxyCreator的shouldSkip这个是关键

这个方法是找出Aspect切面和解析通知器的方法，通知器Advisor里面有通知Advice实例。

    	@Override
    	protected boolean shouldSkip(Class<?> beanClass, String beanName) {
    		// TODO: Consider optimization by caching the list of the aspect names
    		List<Advisor> candidateAdvisors = findCandidateAdvisors();
    		for (Advisor advisor : candidateAdvisors) {
    			if (advisor instanceof AspectJPointcutAdvisor &&
    					((AspectJPointcutAdvisor) advisor).getAspectName().equals(beanName)) {
    				return true;
    			}
    		}
    		return super.shouldSkip(beanClass, beanName);
    	}

这个里面很复杂，下一篇来详解吧。