Spring通过AbstractAutowireCapableBeanFactory#createBean创建Bean对象，方法大致如下
protected Object createBean(String beanName, RootBeanDefinition mbd, @Nullable Object[] args)
throws BeanCreationException {
// ...
try {
// Give BeanPostProcessors a chance to return a proxy
// instead of the target bean instance.
// 这是Spring创建Bean过程第一次调用Bean后置处理器的地方
// 从官方给的注释来看，是用来创建代理对象的
Object bean = resolveBeforeInstantiation(beanName, mbdToUse);
if (bean != null) {
return bean;
}
} catch (Throwable ex) { }
try {
// 如果上面没有返回一个代理对象，那么Spring由此开始创建一个Bean
Object beanInstance = doCreateBean(beanName, mbdToUse, args);
return beanInstance;
} catch (BeanCreationException | ImplicitlyAppearedSingletonException ex) { }
catch (Throwable ex) { }
}
createBean调用了resolveBeforeInstantiation(beanName, mbdToUse)尝试返回一个代理对象，若这个方法返回代理对象，那么Spring将直接返回该对象给外部使用，不再执行后续的所有操作，来看看这个方法都做了啥
protected Object resolveBeforeInstantiation(String beanName, RootBeanDefinition mbd) {
Object bean = null;
if (!Boolean.FALSE.equals(mbd.beforeInstantiationResolved)) {
// Make sure bean class is actually resolved at this point.
if (!mbd.isSynthetic() && hasInstantiationAwareBeanPostProcessors()) {
Class<?> targetType = determineTargetType(beanName, mbd);
if (targetType != null) {
// 循环执行所有InstantiationAwareBeanPostProcessor的
// postProcessBeforeInstantiation函数，这里可以顾名思义
// BeforeInstantiation，即对象实例化前执行，此处可以用来创建代理对象
bean = applyBeanPostProcessorsBeforeInstantiation(targetType, beanName);
if (bean != null) {
// 如果postProcessBeforeInstantiation返回了对象
// 则执行BeanPostProcessor#postProcessorsAfterInitialization
// 注意区分关键字Instantiation、Initialization，前者是实例化，后者是初始化
bean = applyBeanPostProcessorsAfterInitialization(bean, beanName);
}
}
}
mbd.beforeInstantiationResolved = (bean != null);
}
return bean;
}
/**
* 循环遍历Spring容器中所有的
* InstantiationAwareBeanPostProcessor#postProcessBeforeInstantiation
* 如果返回非null，则直接返回这个对象
*/
@Nullable
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;
}
/**
* 循环遍历Spring容器中所有的
* BeanPostProcessor#postProcessAfterInitialization
* 如果上面的方法返回了代理对象，给初始化后置处理方法一个机会对这个代理对象进行操作
*/
@Override
public Object applyBeanPostProcessorsAfterInitialization(Object existingBean, String beanName)
throws BeansException {
Object result = existingBean;
for (BeanPostProcessor beanProcessor : getBeanPostProcessors()) {
Object current = beanProcessor.postProcessAfterInitialization(result, beanName);
if (current == null) {
return result;
}
result = current;
}
return result;
}
扩展：以AspectJAwareAdvisorAutoProxyCreator为例，简述InstantiationAwareBeanPostProcessor应用
Spring提供了@EnableAspectJAutoProxy注解开启切面特性，该注解会通过@Import引入AspectJAutoProxyRegistrar，最终向Spring容器注册AnnotationAwareAspectJAutoProxyCreator
@Target(ElementType.TYPE)
@Retention(RetentionPolicy.RUNTIME)
@Documented
// 通过@Import引入AspectJAutoProxyRegistrar注册AnnotationAwareAspectJAutoProxyCreator
@Import(AspectJAutoProxyRegistrar.class)
public @interface EnableAspectJAutoProxy {
// ...
}
class AspectJAutoProxyRegistrar implements ImportBeanDefinitionRegistrar {
@Override
public void registerBeanDefinitions(AnnotationMetadata importingClassMetadata,
BeanDefinitionRegistry registry) {
// 这里最终注册了AnnotationAwareAspectJAutoProxyCreator
AopConfigUtils.registerAspectJAnnotationAutoProxyCreatorIfNecessary(registry);
// ...
}
}
AnnotationAwareAspectJAutoProxyCreator继承自AbstractAutoProxyCreator
public abstract class AbstractAutoProxyCreator extends ProxyProcessorSupport
implements SmartInstantiationAwareBeanPostProcessor, BeanFactoryAware {
// ...
// 使用一个全局的Map保存不需要生成代理的对象
private final Map<Object, Boolean> advisedBeans = new ConcurrentHashMap<>(256);
@Override
public Object postProcessBeforeInstantiation(Class<?> beanClass, String beanName)
throws BeansException {
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创建代理对象返回，否则当前类统一返回null
// 即AbstractAutoProxyCreator在没有自定义TargetSource的情况下，只有null返回值
// 仅仅通过advisedBeans全局Map记录哪些Bean不需要产生代理
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;
}
/**
* Bean初始化完毕之后，执行的后置处理器
* 通过wrapIfNecessary判断是否需要产生代理对象
*/
@Override
public Object postProcessAfterInitialization(@Nullable 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;
}
/**
* 在BeanPostProcessor初始化完毕之后，也会判断当前bean是否需要生成代理对象
* 不过这里执行的时机和resolveBeforeInstantiation生成代理对象之后直接执行初始化后置处理器不同
* 它通过了Spring创建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;
}
}
