SpringBoot中AbstractAutoProxyCreator类解析

已于 2024-05-17 14:36:17 修改
阅读量138 收藏
点赞数
文章标签： spring boot java 前端
于 2023-11-15 11:26:48 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_36851469/article/details/134414346
版权

 AbstractAutoProxyCreator如类名所示其核心功能是为代理。作为BeanPostProcessor接口的实现类实现了利用 AOP 代理包装每个符合条件的 bean，在调用 bean 本身之前委托给指定的拦截器。

此类区分“通用”拦截器：为其创建的所有代理共享，以及“特定”拦截器：每个 bean 实例唯一。

不需要有任何通用拦截器。如果有，则使用 InterceptorNames 属性来设置它们。

与ProxyFactoryBean一样，使用当前工厂中的拦截器名称而不是 bean 引用，来正确处理 prototype【原型】 advisors and interceptors：例如，支持有状态 mixin。 任何类型的通知advice都是支持{@link #setInterceptorNames "interceptorNames"} entries。

如果有大量的bean 需要用类似的代理包装，即委托给相同的拦截器，那么这种自动代理特别有用。 您可以向 bean 工厂注册 一个这样的后置理器来实现相同的效果，而不是为 x 个目标 bean 进行 x 个重复的代理定义。

子类可以应用任何策略来决定是否要代理 bean，例如按类型、按名称、按定义详细信息等。它们还可以返回额外的拦截器， 不过仅限应用于特定的 bean 实例。一个简单的具体实现是 BeanNameAutoProxyCreator，通过名称指定要代理的 bean。

Any number of TargetSourceCreator implementations can be used to create a custom target source: for example, to pool prototype objects。只要 TargetSourceCreator 指定一个自定义的TargetSource，即使没有advice，自动代理也会发生。如果没有设置 TargetSourceCreators，或者没有匹配，则默认情况下将使用SingletonTargetSource 来包装目标 bean 实例。

1.BeanPostProcessor

public interface BeanPostProcessor {

	default Object postProcessBeforeInitialization(Object bean, String beanName) {return bean;}

	default Object postProcessAfterInitialization(Object bean, String beanName) {return bean;}
}

2.InstantiationAwareBeanPostProcessor

public interface InstantiationAwareBeanPostProcessor extends BeanPostProcessor {
	default Object postProcessBeforeInstantiation(Class<?> beanClass, String beanName){return null;}
	default boolean postProcessAfterInstantiation(Object bean, String beanName) {return true;}
	//类之间通过注解@Autowired引入的依赖
	default PropertyValues postProcessProperties(PropertyValues pvs, Object bean, String beanName) {return null;}
}

3.SmartInstantiationAwareBeanPostProcessor

public interface SmartInstantiationAwareBeanPostProcessor extends InstantiationAwareBeanPostProcessor {
	default Class<?> predictBeanType(Class<?> beanClass, String beanName) {return null;}
	default Constructor<?>[] determineCandidateConstructors(Class<?> beanClass, String beanName) {return null;}
	// 类的过早暴露，此时类的终极形态为代理类
	default Object getEarlyBeanReference(Object bean, String beanName){return bean;}
}

4.接口方法执行时机

4.1.BeforeInstantiation & AfterInitialization

public abstract class AbstractAutowireCapableBeanFactory{

	protected Object createBean(String beanName, RootBeanDefinition mbd, @Nullable Object[] args){
		...
		// Give BeanPostProcessors a chance to return a proxy instead of the target bean instance.
		Object bean = resolveBeforeInstantiation(beanName, mbdToUse);
		return doCreateBean(beanName, mbdToUse, args);
	}

	protected Object resolveBeforeInstantiation(String beanName, RootBeanDefinition mbd) {
		Object bean = null;
		if (!Boolean.FALSE.equals(mbd.beforeInstantiationResolved)) {
			if (!mbd.isSynthetic() && hasInstantiationAwareBeanPostProcessors()) {
				Class<?> targetType = determineTargetType(beanName, mbd);
				if (targetType != null) {
					bean = applyBeanPostProcessorsBeforeInstantiation(targetType, beanName);
					if (bean != null) {
						bean = applyBeanPostProcessorsAfterInitialization(bean, beanName);
					}
				}
			}
			mbd.beforeInstantiationResolved = (bean != null);
		}
		return bean;
	}

}

4.2.determineCandidateConstructors

public abstract class AbstractAutowireCapableBeanFactory{

	protected BeanWrapper createBeanInstance(String beanName, RootBeanDefinition mbd, @Nullable Object[] args) {
		...	
		// Candidate constructors for autowiring?
		Constructor<?>[] ctors = determineConstructorsFromBeanPostProcessors(beanClass, beanName);
		...
		return instantiateBean(beanName, mbd);
	}

}

参考AutowiredAnnotationBeanPostProcessor解析@Autowired注解。当然在AOP代理或者事务方面无需该核心方法。

4.3.AfterInstantiation & postProcessProperties

public abstract class AbstractAutowireCapableBeanFactory{

	protected void populateBean(String beanName, RootBeanDefinition mbd, @Nullable BeanWrapper bw) {
		...
		if (!mbd.isSynthetic() && hasInstantiationAwareBeanPostProcessors()) {
			for (BeanPostProcessor bp : getBeanPostProcessors()) {
				if (bp instanceof InstantiationAwareBeanPostProcessor) {
					InstantiationAwareBeanPostProcessor ibp = (InstantiationAwareBeanPostProcessor) bp;
					if (!ibp.postProcessAfterInstantiation(bw.getWrappedInstance(), beanName)) {
						return;
					}
				}
			}
		}
		...
		for (BeanPostProcessor bp : getBeanPostProcessors()) {
			if (bp instanceof InstantiationAwareBeanPostProcessor) {
				InstantiationAwareBeanPostProcessor ibp = (InstantiationAwareBeanPostProcessor) bp;
				PropertyValues pvsToUse = ibp.postProcessProperties(pvs, bw.getWrappedInstance(), beanName);
				...
				pvs = pvsToUse;
			}
		}
		...
	}

}

4.4.BeforeInitialization & AfterInitialization

public abstract class AbstractAutowireCapableBeanFactory{

	protected Object initializeBean(String beanName, Object bean, @Nullable RootBeanDefinition mbd) {
		...
		invokeAwareMethods(beanName, bean);
		Object wrappedBean = bean;
		if (mbd == null || !mbd.isSynthetic()) {
			wrappedBean = applyBeanPostProcessorsBeforeInitialization(wrappedBean, beanName);
		}
		invokeInitMethods(beanName, wrappedBean, mbd);
		if (mbd == null || !mbd.isSynthetic()) {
			wrappedBean = applyBeanPostProcessorsAfterInitialization(wrappedBean, beanName);
		}
		return wrappedBean;
	}

}

5.AbstractAutoProxyCreator

判断一个类是否需要代理：

  1. 排除掉TargetSource类型的bean。
  2. 排除掉AOP相关的基础设施类：Advice、PointCut、Advisor、AopInfrastructureBean。
  3. 自定义是否需要跳过代理处理。
public abstract class AbstractAutoProxyCreator extends ProxyProcessorSupport
		implements SmartInstantiationAwareBeanPostProcessor, BeanFactoryAware {
    // 如果存在循环引用，则提前创建bean的代理类
	@Override
	public Object getEarlyBeanReference(Object bean, String beanName) {
		Object cacheKey = getCacheKey(bean.getClass(), beanName);
		this.earlyProxyReferences.put(cacheKey, bean);
		return wrapIfNecessary(bean, beanName, cacheKey);
	}

	@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);
				return null;
			}
		}

		// Create proxy here if we have a custom TargetSource.
		// Suppresses unnecessary default instantiation of the target bean:
		// The TargetSource will handle target instances in a custom fashion.
		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;
	}

	@Override
	public boolean postProcessAfterInstantiation(Object bean, String beanName) {
		return true;
	}

	@Override
	public PropertyValues postProcessProperties(PropertyValues pvs, Object bean, String beanName) {
		return pvs;
	}

	@Override
	public Object postProcessBeforeInitialization(Object bean, String beanName) {
		return bean;
	}

	// 通常情况触发bean的代理流程
	@Override
	public Object postProcessAfterInitialization(@Nullable Object bean, String beanName) {
		if (bean != null) {
			Object cacheKey = getCacheKey(bean.getClass(), beanName);
			if (this.earlyProxyReferences.remove(cacheKey) != bean) {
				return wrapIfNecessary(bean, beanName, cacheKey);
			}
		}
		return bean;
	}


	
	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;
	}

	
	protected Object createProxy(Class<?> beanClass, @Nullable String beanName,
			@Nullable Object[] specificInterceptors, TargetSource targetSource) {

		ProxyFactory proxyFactory = new ProxyFactory();
		proxyFactory.copyFrom(this);
		...
		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());
	}

	
	protected Advisor[] buildAdvisors(@Nullable String beanName, @Nullable Object[] specificInterceptors) {
		// Handle prototypes correctly...
		Advisor[] commonInterceptors = resolveInterceptorNames();

		List<Object> allInterceptors = new ArrayList<>();
		if (specificInterceptors != null) {
			allInterceptors.addAll(Arrays.asList(specificInterceptors));
			if (commonInterceptors.length > 0) {
				if (this.applyCommonInterceptorsFirst) {
					allInterceptors.addAll(0, Arrays.asList(commonInterceptors));
				}
				else {
					allInterceptors.addAll(Arrays.asList(commonInterceptors));
				}
			}
		}

		Advisor[] advisors = new Advisor[allInterceptors.size()];
		for (int i = 0; i < allInterceptors.size(); i++) {
			advisors[i] = this.advisorAdapterRegistry.wrap(allInterceptors.get(i));
		}
		return advisors;
	}

}

当然当前类为抽象类，必须由其子类触发抽象类的功能。例如如果存在aop相关的jar包就会引入类AnnotationAwareAspectJAutoProxyCreator，该类作为后置处理器判断ioc容器中每一个bean。

阿......嚏
关注
AbstractAutoProxyCreator
jianlee1991的博客
10-26 226
不同于ProxyFactory和ProxyFactoryBean 给单个bean增加代理。spring提供了基于一定规则自动发现和代理。 public abstract class AbstractAutoProxyCreator extends ProxyProcessorSupport implements SmartInstantiationAwareBeanPostProcessor, BeanFactoryAware { ProxyProcessorSupport 继承自Pro.
SpringBoot源码解析（十八）Spring事务tx源码分析(一)
lz710117239的博客
01-06 3266
在spring的tx源码中我们知道了，最后会通过AbstractAutoProxyCreator（其有一个父类是beanPostProcessor）的postProcessAfterInitialization(Object bean, String beanName)方法中的wrapIfNecessary方法去createProxy。其中生成jdk动态代理的类是JdkDynamicAopProx
AOP原理——2. AbstractAutoProxyCreator 创建动态代理对象
姜希成的博客
12-03 3650
SmartInstantiationAwareBeanPostProcessor接口继承自InstantiationAwareBeanPostProcessor接口，因此AbstractAutoProxyCreator是通过InstantiationAwareBeanPostProcessor接口的postProcessBeforeInstantiation方法来生成动态代理对象的。 public abstract class AbstractAutoProxyCreator extends ProxyPr
Spring-aop-AbstractAutoProxyCreator
文天大人
05-14 464
怀念二抱三抱
Spring AOP : APC 自动代理创建器 AbstractAutoProxyCreator
Details Inside Spring
07-17 1634
概述 AbstractAdvisorAutoProxyCreator是Spring AOP提供的一个SmartInstantiationAwareBeanPostProcessor,它的作用是将符合条件的bean包装成代理对象,包装成代理对象的过程会在bean实例外面包裹相应的AOP拦截器。调用者对该bean的方法调用，其实首先发生在相应的代理上，经过层层包裹的AOP拦截器之后，才真正执行目标be...
Spring AOP基础组件 AbstractAutoProxyCreator
我家有猫已长成的博客
02-16 1730
Spring AOP基础组件 AbstractAutoProxyCreator 简介。
Spring源码阅读-AOP实现核心类AbstractAutoProxyCreator
weixin_34151004的博客
08-29 205
2019独角兽企业重金招聘Python工程师标准>>> ...
Springboot源码 AbstractAdvisorAutoProxyCreator解析
08-25
Springboot源码 AbstractAdvisorAutoProxyCreator解析 AbstractAdvisorAutoProxyCreator是Springboot源码中一个重要的自动代理创建器，主要用于在Spring容器中自动创建代理实例。下面我们来详细了解...
SpringBoot---事务实现原理
qq_31331965的博客
11-07 1269
一、前言 利用SpringBoot实现事务非常简单，主要有以下两步骤： 1.在启动类上加注解@EnableTransactionManagement 2.在需要事务管理的方法上添加注解@Transactional 简单的代码后面却体现了SpringAOP的思想和精髓，接下来我们先思考一下可能的实现方式。 二、思考 要对一个方法进行事务管理，肯定要对该方法进行增强，那就有以下几个...
SpringBoot启动流程
wa_ka_ka的博客
08-19 452
0，启动@SpringBootApplication注解类的main方法 import org.springframework.boot.SpringApplication;//启动类 import org.springframework.boot.autoconfigure.SpringBootApplication; @SpringBootApplication//启动必要的注解 public class SpringBootDemoApplication { //运行main方法启动spri
细节知多少 - spring boot transaction解析之阶段一 带有@Transactional方法的service类生成代理类的阶段
没有伞的孩子只能快跑，如若不跑，只有一个结果：超过你的人回头鄙视你
06-13 2563
细节知多少 - spring boot transaction解析之阶段一 带有@Transactional方法的service类生成代理类的阶段 date: 2019-06-04 原文：spring boot transaction解析之阶段一 带有@Transactional方法的service类生成代理类的阶段 概述 spring boot transaction我们平时用着非常简单，只需要...
跟着小马哥学系列之 Spring AOP（AbstractAutoProxyCreator 详解）
qq_42419406的博客
05-14 3387
跟着小马哥学系列之 Spring AOP（ProxyProcessorSupport 详解）简介AbstractAutoProxyCreator 功能 学成路更宽，吊打面试官。 ——小马哥 简介 大家好，我是小马哥成千上万粉丝中的一员！2019年8月有幸在叩丁狼教育举办的猿圈活动中知道有这么一位大咖，从此结下了不解之缘！此系列在多次学习极客时间《小马哥讲Spring AOP 编程思想》基础上形成的个人一些总结。希望能帮助各位小伙伴， 祝小伙伴早日学有所成。 AbstractAutoProxyCreato
【Spring-AOP】底层类AbstractAutoProxyCreator分析
qq_34501351的博客
06-24 540
org.springframework.aop.framework.autoproxy.AbstractAutoProxyCreator 该类中做了对目标类的代理处理。 public abstract class AbstractAutoProxyCreator extends ProxyProcessorSupport implements SmartInstantiationAwareBeanPostProcessor, BeanFactoryAware 继承ProxyProcessorSuppo
spring源码解析-----AbstractAutoProxyCreator
公瑾的专栏
12-11 308
AbstractAutoProxyCreator.java部分代码如下 以下部分代码展示了动态代理的形成过程【部分】 /** * Create a proxy with the configured interceptors if the bean is * identified as one to proxy by the subclass. * @see #getAdvicesAndAdvisorsForBean */ @Override public Object p...
Spring AOP之基于AbstractAutoProxyCreator的自动代理
热门推荐
shuangyue的专栏
03-04 1万+
当系统比较复杂，或者中需要进行aop进行织入的bean较多时，简单采用ProxyFacotryBean无疑会增加很多工作量，同时由于要从ProxyFactoryBean获得代理对象，也会使应用和Spring之间的耦合度增加，并且很多时候可维护性不强，譬如，我们需要给bean名字满足“*service”的bean每个方法增加事务功能，如果采用ProxyFacotryBean必须为每个以service
一、spring aop 原理之 后置处理器 AnnotationAwareAspectJAutoProxyCreator 源码解析
sinat_17618381的博客
08-29 375
1.向容器中注册AnnotationAwareAspectJAutoProxyCreator 当开启基于注解的aop模式，要添加注解 @EnableAspectJAutoProxy，点进@EnableAspectJAutoProxy的源码 此注解帮助spring处理标记了 AspectJ注解的组件，有点类似原来的xml配置文件里面的 aop:aspectj-autoproxy /** * Enables support for handling components marked with Asp
Spring的BeanPostProcessor扩展点实现类AbstractAutoProxyCreator
ystyaoshengting的专栏
01-26 958
AbstractAutoProxyCreator SmartInstantiationAwareBeanPostProcessor接口继承自InstantiationAwareBeanPostProcessor接口。 因此AbstractAutoProxyCreator一般是通过InstantiationAwareBeanPostProcessor接口的postProcessBeforeInstantiation方法和postProcessAfterInitialization方法来返回代理对象； pos
spring基本使用(13)-springAOP的使用以及原理3 springAOP的自动代理创建器AbstractAutoProxyCreator
qq_34978129的博客
07-14 493
1、在前面一篇文章中我们讲了ProxyFactory、ProxyFacoryBean、AspectJProxyFactory三种用于创建代理类以及代理实例的非自动代理创建器，在Spring中其实也为我们提供了自动创建代理器。自动代理创建器的作用就是，自动解析到SpringIOC容器中的切面，根据切面的定义找到所有的Target目标类，在SpringIOC容器装载阶段为其织入切面定义中的增强。 2、非自动代理构建器 与 自动代理构建器的区别 非自动代理构建器使用繁琐，组要我们配置（目标类...
Spring源码解析（十三）——AOP原理——AnnotationAwareAspectJAutoProxyCreator注册
csdn_kenneth的博客
10-29 443
 * 2、 AnnotationAwareAspectJAutoProxyCreator：  *         AnnotationAwareAspectJAutoProxyCreator  *             -&gt;AspectJAwareAdvisorAutoProxyCreator  *                 -&gt;AbstractAdvisorAutoProxy...
SpringBoot启动Tomcat详细解析
如果用户没有自定义ApplicationContext类，SpringBoot会尝试从类路径中查找并实例化这些默认类。 接着，`BeanUtils.instantiateClass()`方法被用来创建ApplicationContext的实例。这个方法使用反射来创建指定类的...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值