（13）spring注解学习之AOP原理--AnnotationAwareAspectJAutoProxyCreator的拦截过程

最新推荐文章于 2022-01-21 17:42:37 发布
最新推荐文章于 2022-01-21 17:42:37 发布
阅读量267 收藏
点赞数
分类专栏： spring 文章标签： spring aop
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/u013019255/article/details/107516401
版权

AnnotationAwareAspectJAutoProxyCreator做了什么？

AnnotationAwareAspectJAutoProxyCreator => InstantiationAwareBeanPostProcessor
finishBeanFactoryInitialization操作之前AnnotationAwareAspectJAutoProxyCreator 把部分有beanDefinition的bean的实例 已经全部注册到容器中，现在初始化其他bean实例

refresh()

完成BeanFactory初始化工作；创建剩下的单实例bean
在这里插入图片描述

1.完成BeanFactory初始化工作finishBeanFactoryInitialization(beanFactory)

/**
 * Finish the initialization of this context's bean factory,
 * initializing all remaining singleton beans.
 */
protected void finishBeanFactoryInitialization(ConfigurableListableBeanFactory beanFactory) {

	// Instantiate all remaining (non-lazy-init) singletons.
	beanFactory.preInstantiateSingletons();
}
1.1 preInstantiateSingletons()
  • 遍历获取容器中所有的Bean，依次创建对象 =》getBean(beanName)
@Override
public void preInstantiateSingletons() throws BeansException {
	// Trigger initialization of all non-lazy singleton beans...
	
	//遍历获取容器中所有的Bean
	for (String beanName : beanNames) {
		RootBeanDefinition bd = getMergedLocalBeanDefinition(beanName);
		if (!bd.isAbstract() && bd.isSingleton() && !bd.isLazyInit()) {
			if (isFactoryBean(beanName)) {
				//xxxxxx省略
			}else {
				// 创建对象
				getBean(beanName);
			}
		}
	}
}
  • getBean->doGetBean()->getSingleton()-> singletonFactory.getObject()->createBean()
  1. doGetBean() 先从缓存中获取当前bean，如果能获取到，说明bean是之前被创建过的，直接使用，否则初次生成该bean，容器中之前无该bean，所以会新重建该bean
  • 只要创建好的Bean都会被缓存起来
    在这里插入图片描述
  • createBean()
    在这里插入图片描述

2. 创建bean

AnnotationAwareAspectJAutoProxyCreator 因为继承了InstantiationAwareBeanPostProcessor接口，所以会在所有bean创建之前会有一个拦截，先尝试返回bean的实例，调用postProcessBeforeInstantiation()

2.1 bean创建之前拦截
protected Object createBean()
{
    // 先尝试通过 后置处理器返回 代理对象
    Object bean = resolveBeforeInstantiation(beanName, mbdToUse);

    //不能返回 代理对象就创建 bean实例
    Object beanInstance = doCreateBean(beanName, mbdToUse, args);

}
2.1.1 resolveBeforeInstantiation ==》解析BeforeInstantiation
  • 希望后置处理器在此能返回一个代理对象；
  • 如果能返回代理对象就使用，如果不能就doCreateBean()
    在这里插入图片描述
2.1.2 resolveBeforeInstantiation里面的后置处理器先尝试返回对象

在这里插入图片描述

2.1.3 applyBeanPostProcessorsBeforeInstantiation
  • 拿到所有后置处理器，如果是InstantiationAwareBeanPostProcessor【相当于AnnotationAwareAspectJAutoProxyCreator 】
  • 就执行postProcessBeforeInstantiation
protected Object applyBeanPostProcessorsBeforeInstantiation(Class<?> beanClass, String beanName) {
	for (BeanPostProcessor bp : getBeanPostProcessors()) {
		if (bp instanceof InstantiationAwareBeanPostProcessor) {
			InstantiationAwareBeanPostProcessor ibp = (InstantiationAwareBeanPostProcessor) bp;
			Object result = ibp.postProcessBeforeInstantiation(beanClass, beanName);
			if (result != null) {
				return result;
			}
		}
	}
	return null;
}
2.1.4 postProcessBeforeInstantiation
  • 判断当前bean是否在advisedBeans中（保存了所有需要增强bean）
  • 判断当前bean是否是基础类型的，是否实现了Advice、Pointcut、Advisor、AopInfrastructureBean，或者是否是切面（@Aspect）
  • 是否需要跳过
public Object postProcessBeforeInstantiation(Class<?> beanClass, String beanName) throws BeansException {
	Object cacheKey = getCacheKey(beanClass, beanName);

	if (beanName == null || !this.targetSourcedBeans.contains(beanName)) 
	{
		// 先判断这个beanName 是否在advisedBeans增强器中
		if (this.advisedBeans.containsKey(cacheKey)) {
			return null;
		}
		//判断当前bean是否是基础类型的
		if (isInfrastructureClass(beanClass) || shouldSkip(beanClass, beanName)) {
			this.advisedBeans.put(cacheKey, Boolean.FALSE);
			return null;
		}
	}

		// Create proxy here if we have a custom TargetSource.
		if (beanName != null) {
			TargetSource targetSource = getCustomTargetSource(beanClass, beanName);
			if (targetSource != null) {
				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;
	}

@Override
protected boolean isInfrastructureClass(Class<?> beanClass) {

	return (super.isInfrastructureClass(beanClass) || this.aspectJAdvisorFactory.isAspect(beanClass));
}
  • 是否需要跳过
  • 1）、获取候选的增强器（切面里面的通知方法）【List candidateAdvisors】
  •  每一个封装的通知方法的增强器是 InstantiationModelAwarePointcutAdvisor；

  •  判断每一个增强器是否是 AspectJPointcutAdvisor 类型的；是就返回true
  • 2）、父类的super.shouldSkip(beanClass, beanName) 永远返回false–跳过
@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) {
			if (((AbstractAspectJAdvice) advisor.getAdvice()).getAspectName().equals(beanName)) {
				return true;
			}
		}
	}
	return super.shouldSkip(beanClass, beanName);
}

增强方法：
在这里插入图片描述

2.2 创建bean

doCreateBean(beanName, mbdToUse, args)

2.3 初始化bean

populateBean(beanName, mbd, instanceWrapper);

initializeBean()
{
  	applyBeanPostProcessorsBeforeInitialization(wrappedBean, beanName);
  	// 执行自定义初始化
  	invokeInitMethods(beanName, wrappedBean, mbd);
  	applyBeanPostProcessorsAfterInitialization(wrappedBean, beanName);
}

2.4 初始化bean之后的后置处理器执行

applyBeanPostProcessorsAfterInitialization
-----> postProcessAfterInitialization

2.4.1 postProcessAfterInitialization

//如果需要的情况下包装
return wrapIfNecessary(bean, beanName, cacheKey)

@Override
public Object postProcessAfterInitialization(Object bean, String beanName) throws BeansException {
	if (bean != null) {
		Object cacheKey = getCacheKey(bean.getClass(), beanName);
		if (!this.earlyProxyReferences.contains(cacheKey)) {
			return wrapIfNecessary(bean, beanName, cacheKey);
		}
	}
	return bean;
}
2.4.2 获取当前bean的所有增强器（通知方法） getAdvicesAndAdvisorsForBean
protected Object wrapIfNecessary(Object bean, String beanName, Object cacheKey) 
{
	// 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;
}
  • getAdvicesAndAdvisorsForBean —获取当前bean的所有增强器
@Override
	protected Object[] getAdvicesAndAdvisorsForBean(Class<?> beanClass, String beanName, TargetSource targetSource) {
		List<Advisor> advisors = findEligibleAdvisors(beanClass, beanName);
		if (advisors.isEmpty()) {
			return DO_NOT_PROXY;
		}
		return advisors.toArray();
	}
  • findEligibleAdvisors—获取到能在当前bean使用的增强器。
/*
* @see #findCandidateAdvisors
 * @see #sortAdvisors
 * @see #extendAdvisors
 */
protected List<Advisor> findEligibleAdvisors(Class<?> beanClass, String beanName) {
	List<Advisor> candidateAdvisors = findCandidateAdvisors();
	List<Advisor> eligibleAdvisors = findAdvisorsThatCanApply(candidateAdvisors, beanClass, beanName);
	extendAdvisors(eligibleAdvisors);
	if (!eligibleAdvisors.isEmpty()) {
		eligibleAdvisors = sortAdvisors(eligibleAdvisors);
	}
	return eligibleAdvisors;
}
  • 1）找到候选的所有的增强器（找哪些通知方法是需要切入当前bean方法的）
    比如说这个给 MathCalculator定义的四个增强方法（@Before/ @After / @AfterReturning/ @AfterThrowing）
List<Advisor> candidateAdvisors = findCandidateAdvisors();
  • 2）获取到能在当前bean使用的增强器
    四个增强方法（@Before/ @After / @AfterReturning/ @AfterThrowing）在当前bean的方法名字
List<Advisor> eligibleAdvisors = findAdvisorsThatCanApply(candidateAdvisors, beanClass, beanName);
  • 3）给增强器排序
eligibleAdvisors = sortAdvisors(eligibleAdvisors);
2.4.3 保存当前bean在advisedBeans中：表明当前bean是增强bean
this.advisedBeans.put(cacheKey, Boolean.TRUE);
2.4.4 如果当前bean需要增强，创建当前bean的代理对象createProxy（）方法
Object proxy = createProxy(
			bean.getClass(), beanName, specificInterceptors, new SingletonTargetSource(bean));

protected Object createProxy(
			Class<?> beanClass, String beanName, Object[] specificInterceptors, TargetSource targetSource) {
			
		ProxyFactory proxyFactory = new ProxyFactory();

		Advisor[] advisors = buildAdvisors(beanName, specificInterceptors);
		proxyFactory.addAdvisors(advisors);
		proxyFactory.setTargetSource(targetSource);
		customizeProxyFactory(proxyFactory);

		proxyFactory.setFrozen(this.freezeProxy);
		if (advisorsPreFiltered()) {
			proxyFactory.setPreFiltered(true);
		}

		return proxyFactory.getProxy(getProxyClassLoader());
}
  • 1）、获取所有增强器（通知方法）
Advisor[] advisors = buildAdvisors(beanName, specificInterceptors);
  • 2）、保存到代理工厂 proxyFactory
proxyFactory.addAdvisors(advisors);
  • 3）、创建代理对象 proxyFactory.getProxy(getProxyClassLoader())
public Object getProxy(ClassLoader classLoader) {
		return createAopProxy().getProxy(classLoader);
}
  • Spring自动决定创建那种代理对象
    <1>.JdkDynamicAopProxy(config);jdk动态代理； <2>.ObjenesisCglibAopProxy(config);cglib的动态代理；

新建一个AOP代理对象：getProxy()本质上就是创建AOP代理：createAopProxy

protected final synchronized AopProxy createAopProxy() {
		if (!this.active) {
			activate();
		}
		return getAopProxyFactory().createAopProxy(this);
}

targetClass 当前就是 MathCalculator类

如果 targetClass 是实现接口的，就用JdkDynamicAopProxy

@Override
public AopProxy createAopProxy(AdvisedSupport config) throws AopConfigException {
	if (config.isOptimize() || config.isProxyTargetClass() || hasNoUserSuppliedProxyInterfaces(config)) {
		Class<?> targetClass = config.getTargetClass();
		
		if (targetClass.isInterface() || Proxy.isProxyClass(targetClass)) {
			return new JdkDynamicAopProxy(config);
		}
		return new ObjenesisCglibAopProxy(config);
	}
	else {
		return new JdkDynamicAopProxy(config);
	}
}
2.4.5 给容器中返回当前组件使用cglib增强了的代理对象

createProxy () 方法返回的代理对象
在这里插入图片描述

2.4.6 以后容器中获取到的就是这个组件的代理对象，执行目标方法的时候，代理对象就会执行通知方法的流程
panda有个黑眼圈
关注
专栏目录
Spring-MVC-aop.zip
09-13
**注解方式的AOP拦截** 在Spring中，我们可以使用注解来定义切面和通知。例如，`@Aspect`注解用于声明一个类为切面，而`@Before`、`@After`、`@Around`、`@AfterReturning`和`@AfterThrowing`等注解则分别代表在...
Spring 事务第三篇-Spring 如何拦截事务方法并对其增强？
paralysed的博客
09-23 1042
目录 前言 不得不提的 @EnableTransactionManagement TransactionManagementConfigurationSelector AutoProxyRegistrar ProxyTransactionManagementConfiguration TransactionAttributeSource BeanFactoryTransactionAttributeSourceAdvisor TransactionInterc...
Spring AOP原理分析(四)--AnnotationAwareAspectJAutoProxyCreator#postProcessBeforeInstantiation源码解析
weixiaohuai的博客
01-21 1093
一、简介 AnnotationAwareAspectJAutoProxyCreator 实现了几个重要的扩展接口： 1）、实现了 BeanPostProcessor 接口：实现了 postProcessAfterInitialization()方法； 2）、实现了 InstantiationAwareBeanPostProcessor 接口：实现了 postProcessBeforeInstantiation()、postProcessAfterInstantiation()方法； 3）、实现了 S
Spring注解驱动开发第30讲——AnnotationAwareAspectJAutoProxyCreator作为后置处理器，你知道它都做了些什么吗？
李阿昀的博客
12-20 3175
写在前面 前一讲中，我们一步一步分析到了AbstractAutoProxyCreator抽象类的postProcessBeforeInstantiation()方法中，其实，我们也知道现在调用的其实是AnnotationAwareAspectJAutoProxyCreator类的postProcessBeforeInstantiation()方法。 那么，在这一讲中，我们就来看看AnnotationAwareAspectJAutoProxyCreator作为后置处理器，它的postProcessBefore
Spring AOP是如何工作的之AnnotationAwareAspectJAutoProxyCreator类源码解析
innerpeacez成长之路
03-12 2135
AnnotationAwareAspectJAutoProxyCreator类的层级结构图： 通过上图可以看到AnnotationAwareAspectJAutoProxyCreator实现了BeanPostProcessor接口，所以Spring 在加载AnnotationAwareAspectJAutoProxyCreator类的Bean对象的时候会在实例化之前调用postProcess...
Spring源码解析（十四）——AOP原理——AnnotationAwareAspectJAutoProxyCreator执行时机
csdn_kenneth的博客
10-29 634
     *             AnnotationAwareAspectJAutoProxyCreator =&gt; InstantiationAwareBeanPostProcessor  *         4）、finishBeanFactoryInitialization(beanFactory);完成BeanFactory初始化工作；创建剩下的单实例bean  *   ...
Spring Mvc AOP通过注解方式拦截controller等实现日志管理
08-18
本教程将详细介绍如何利用注解来配置和使用AOP来拦截Controller层的方法，以便记录执行过程中的相关信息，实现日志管理。 一、Spring AOP基础 AOP是Spring框架的核心组件之一，它允许程序员定义“切面”，这些切面...
浅尝Spring注解开发_AOP原理及完整过程分析（源码）.doc
07-08
《浅尝Spring注解开发_AOP原理及完整过程分析（源码）》 Spring框架的注解开发在现代Java应用中扮演着至关重要的角色，尤其是其面向切面编程（AOP）特性，使得代码更加模块化，提高了可维护性和可重用性。本文将...
使用Spring的注解方式实现AOP实例
08-30
使用Spring的注解方式实现AOP实例 使用Spring的注解方式实现AOP实例是指通过使用Spring框架提供的注解方式来实现Aspect-Oriented Programming（面向方面编程）的功能。AOP是面向对象编程的一种补充，能够将跨越多个...
Spring AOP注解案例及基本原理详解
08-19
Spring AOP注解案例及基本原理详解 Spring AOP是基于AspectJ实现的，提供了强大的面向切面编程功能。通过使用注解，可以将横切逻辑与业务逻辑分离，从而提高代码的可维护性和可读性。 Aspect: 切面是一个类，负责...
Spring AOP原理之AnnotationAwareAspectJAutoProxyCreator分析
luojinbai的专栏
01-28 4082
目录 1. 说明 2.AnnotationAwareAspectJAutoProxyCreator的继承关系 3. 关键类分析 1. 说明 @EnableAspectJAutoProxy通过@Import导入AspectJAutoProxyRegistrar.class,然后AspectJAutoProxyRegistrar是ImportBeanDefinitionRegistr...
spring aop源码解析2: AnnotationAwareAspectJAutoProxyCreator拦截切点bean（join point）创建过程并生成proxy（在切点织入切面）的过程
u013905744的专栏
06-13 690
接上一篇spring aop源码解析1: 创建、初始化并注册AnnotationAwareAspectJAutoProxyCreator继续 现在我们在容器中已经有了AnnotationAwareAspectJAutoProxyCreator这个BeanPostProcessor，那么之后我们再创建bean的时候，都会经过AnnotationAwareAspectJAutoProxyCreato...
spring aop 中的AnnotationAwareAspectJAutoProxyCreator 创建过程
yinbucheng的博客
07-24 948
spring aop 中的AnnotationAwareAspectJAutoProxyCreator 创建过程   我们在 EnableAspectJAutoProxy注解中看到如下语句 @Target(ElementType.TYPE) @Retention(RetentionPolicy.RUNTIME) @Documented @Import(AspectJAutoProxyReg...
spring aop源码解析1: 创建、初始化并注册AnnotationAwareAspectJAutoProxyCreator
u013905744的专栏
06-13 1678
spring aop的源码解析内容比较多，准备分为三个部分： 1. 创建、初始化并注册AnnotationAwareAspectJAutoProxyCreator 2. AnnotationAwareAspectJAutoProxyCreator拦截切点bean（join point）创建过程并生成proxy（在切点织入切面）的过程 3. 代理对象执行过程分析--构造拦截器链及触发拦截器链 ...
Spring注解驱动开发第29讲——注册完AnnotationAwareAspectJAutoProxyCreator后置处理器之后，就得完成BeanFactory的初始化工作了
李阿昀的博客
12-18 2740
写在前面 经过前面的研究，我们发现，IOC容器在创建对象的时候，会注册这一些后置处理器，而在上一讲中，就已经把AnnotationAwareAspectJAutoProxyCreator这个后置处理器创建出来了，它呢，就是@EnableAspectJAutoProxy注解利用AspectJAutoProxyRegistrar给容器中创建出的一个bean的配置信息。 当然了，在注册后置处理器的时候，这个bean肯定就已经提前创建出来了。而且，它呢，我们也都知道是一个后置处理器，只要这个后置处理器已经创建出来并
AOP原理——AnnotationAwareAspectJAutoProxyCreator分析
qq_39794062的博客
05-27 3088
一、AnnotationAwareAspectJAutoProxyCreator分析 @EnableAspectJAutoProxy注解会通过@Import注解快速导入AspectJAutoProxyRegistrar组件，这个组件会给容器中注册一个名为internalAutoProxyCreator的组件，internalAutoProxyCreator的组件的类型是AnnotationAwareAspectJAutoProxyCreator。 通过AnnotationAwareAspectJAutoPr
Spring-AOP 自动创建代理之AnnotationAwareAspectJAutoProxyCreator
热门推荐
小工匠
08-25 1万+
导读 实例导读Spring-AOP 自动创建代理Spring-AOP 自动创建代理之BeanNameAutoProxyCreatorSpring-AOP 自动创建代理之DefaultAdvisorAutoProxyCreatorSpring-AOP 自动创建代理之AnnotationAwareAspectJAutoProxyCreator实例代码已托管到Github—> https://github
spring中BeanNameAutoProxyCreator和AnnotationAwareAspectJAutoProxyCreator两种AOP代理方式使用总结
新栋BOOK
11-15 5850
昨天代码review的过程中，我们遇到了两种AOP代理的方式，一种是BeanNameAutoProxyCreator，另外一种是AnnotationAwareAspectJAutoProxyCreator。当时大家问这两种有和区别，十年的老司机 底气并不足的描述书写方式不一样。那么今天，我们就彻底剖析下两种代理。   其实，在spring内部，是通过BeanPostProcessor（《sp
Spring-Bean后置处理器之AnnotationAwareAspectJAutoProxyCreator
Silence的博客
11-07 573
本文能帮你解答的问题 AnnotationAwareAspectJAutoProxyCreator后置器的作用是什么? Spring AOP自动增强bean是如何实现的。 如何在spring上下文添加AnnotationAwareAspectJAutoProxyCreator？ 如何利用ProxyFactory硬编码实现一个bean的增强？ AnnotationAwareAspectJAutoProxyCreator是在bean的生命周期什么阶段完成bean的增强？
Spring注解配置与AOP实战：自动装配与使用解析
"本文主要探讨了Spring框架中的自动装配和AOP（面向切面编程）的使用，旨在帮助读者理解并应用这些核心功能。" 在Spring框架中，自动装配和AOP是两个非常重要的概念，它们极大地简化了开发工作，提高了代码的可维护...
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值