Spring 版本：version=5.1.0.BUILD-SNAPSHOT
前置知识
BeanPostProcessor简介
BeanPostProcessor接口，即bean后置处理器，作用是当Bean对象在实例化和依赖注入完毕后，显示调用初始化方法的前后，添加我们自己的逻辑。注意是Bean实例化完毕后及依赖注入完成后触发的。
简单的讲就是在Bean初始化的前后做一些事情，里面有两个方法，一个是postProcessBeforeInitialization，实例化、依赖注入完毕，在调用显示的初始化之前完成一些定制的初始化任务。另一个是postProcessAfterInitialization，实例化、依赖注入、初始化完毕时执行。
public interface BeanPostProcessor {
// bean的自定义初始化方法之前执行
@Nullable
default Object postProcessBeforeInitialization(Object bean, String beanName) throws BeansException {
return bean;
}
//bean的自定义初始化方法之后执行
@Nullable
default Object postProcessAfterInitialization(Object bean, String beanName) throws BeansException {
return bean;
}
}InstantiationAwareBeanPostProcessor简介
InstantiationAwareBeanPostProcessor接口是BeanPostProcessor接口的子接口，Instantiation翻译是实例化的意思，也就是说这个接口是在Bean实例化的前后做一些事情。主要作用：为特殊定制目标bean的实例化过程，如给目标对象创建代理对象。所以该接口的实现类需要实现5个方法。
public interface InstantiationAwareBeanPostProcessor extends BeanPostProcessor {
// 实例化前
@Nullable
default Object postProcessBeforeInstantiation(Class<?> beanClass, String beanName) throws BeansException {
return null;
}
// 实例化之后，属性填充之前执行
default boolean postProcessAfterInstantiation(Object bean, String beanName) throws BeansException {
return true;
}
// 属性填充之前，修改Bean中属性的内容
// 在这里可以修改即将要填充属性的值,自动注入是在这里进行的。
@Nullable
default PropertyValues postProcessProperties(PropertyValues pvs, Object bean, String beanName)
throws BeansException {
return null;
}
// spring5.1之后，该方法被抛弃，使用postProcessProperties代替
@Deprecated
@Nullable
default PropertyValues postProcessPropertyValues(
PropertyValues pvs, PropertyDescriptor[] pds, Object bean, String beanName) throws BeansException {
return pvs;
}
}AOP代理对象创建器：AspectJAwareAdvisorAutoProxyCreator
从上图的AspectJAwareAdvisorAutoProxyCreator的类继承体系结构图中，我们发现，它实现了InstantiationAwareBeanPostProcessor接口，具体为在抽象父类AbstractAutoProxyCreator：同时重写了postProcessBeforeInstantiation方法的实现（它实现了上面的5个方法）。
因此，AspectJAwareAdvisorAutoProxyCreator 也是一个bean后置处理器，它的作用是在bean对象实例化的前后可以进行一些操作。现在需要思考的是对于AspectJAwareAdvisorAutoProxyCreator这个对象是什么时候生成的呢？其实它在registerBeanPostProcessors注册bean后置处理器的时候实例化的。下面先进入refesh方法：
因此，我们先进入到AbstractApplicationContext#refresh方法
@Override
public void refresh() throws BeansException, IllegalStateException {
synchronized (this.startupShutdownMonitor) {
// Prepare this context for refreshing.
// 初始化属性配置文件、校验必要属性以及监听器
prepareRefresh();
// Tell the subclass to refresh the internal bean factory.
// 告诉子类刷新内部bean工厂，给beanFactory设置序列化id
ConfigurableListableBeanFactory beanFactory = obtainFreshBeanFactory();
// Prepare the bean factory for use in this context.
// 向beanFactory中注册了两个BeanPostProcessor,以及三个与环境相关的bean
// 这两个后置处理器为ApplicationContextAwareProcessor和ApplicationListenerDetector
// 前一个后置处理是为实现了ApplicationContextAware接口的类，回调setApplicationContext()方法，
// 后一个处理器时用来检测ApplicationListener类的，当某个Bean实现了ApplicationListener接口的bean被创建好后，会被加入到监听器列表中
prepareBeanFactory(beanFactory);
try {
// Allows post-processing of the bean factory in context subclasses.
// 空方法，由子类实现
postProcessBeanFactory(beanFactory);
// Invoke factory processors registered as beans in the context.
// 执行所有的BeanFactoryPostProcessor，包括自定义的，以及spring内置的。
// 默认情况下，容器中只有一个BeanFactoryPostProcessor,即：Spring内置的，ConfigurationClassPostProcessor(这个类很重要)
// 会先执行实现了BeanDefinitionRegistryPostProcessor接口的类，然后执行BeanFactoryPostProcessor的类
// ConfigurationClassPostProcessor类的postProcessorBeanFactory()方法进行了@Configuration类的解析，@ComponentScan的扫描，以及@Import注解的处理
// 经过这一步以后,会将所有交由spring管理的bean所对应的BeanDefinition放入到beanFactory的beanDefinitionMap中
// 同时ConfigurationClassPostProcessor类的postProcessorBeanFactory()方法执行完后，向容器中添加了一个后置处理器————ImportAwareBeanPostProcessor
invokeBeanFactoryPostProcessors(beanFactory);
// Register bean processors that intercept bean creation.
// 注册所有的BeanPostProcessor，因为在方法里面调用了getBean()方法，所以在这一步，实际上已经将所有的BeanPostProcessor实例化了
// 为什么要在这一步就将BeanPostProcessor实例化呢？因为后面要实例化bean，而BeanPostProcessor是用来干预bean的创建过程的，
// 所以必须在bean实例化之前就实例化所有的BeanPostProcessor(包括开发人员自己定义的)
// 最后再重新注册了ApplicationListenerDetector，这样做的目的是为了将ApplicationListenerDetector放入到后置处理器的最末端
registerBeanPostProcessors(beanFactory);
// Initialize message source for this context.
// 初始化MessageSource，用来做消息国际化。在一般项目中不会用到消息国际化
initMessageSource();
// Initialize event multicaster for this context.
// 初始化事件广播器，如果容器中存在了名字为applicationEventMulticaster的广播器，则使用该广播器
// 如果没有，则初始化一个SimpleApplicationEventMulticaster
// 事件广播器的用途是，发布事件，并且为所发布的时间找到对应的事件监听器。
initApplicationEventMulticaster();
// Initialize other special beans in specific context subclasses.
// 执行其他的初始化操作，例如和SpringMVC整合时，需要初始化一些其他的bean，但是对于纯spring工程来说，onFresh方法是一个空方法
onRefresh();
// Check for listener beans and register them.
// 这一步会将自定义的listener的bean名称放入到事件广播器中
// 同时还会将早期的ApplicationEvent发布(对于单独的spring工程来说，在此时不会有任何ApplicationEvent发布，
// 但是和springMVC整合时，springMVC会执行onRefresh()方法，在这里会发布事件)
registerListeners();
// Instantiate all remaining (non-lazy-init) singletons.
// 实例化剩余的非懒加载的单例bean(注意：剩余、非懒加载、单例)
// 为什么说是剩余呢？如果开发人员自定义了BeanPostProcessor，而BeanPostProcessor在前面已经实例化了，所以在这里不会再实例化，因此这里使用剩余一词
// 注：该方法十分重要，它完成了所有非懒加载的单例Bean的实例化和初始化，属性的填充以及解决了循环依赖等问题
finishBeanFactoryInitialization(beanFactory);
// Last step: publish corresponding event.
// 结束refresh，主要干了一件事，就是发布一个事件ContextRefreshEvent，通知大家spring容器refresh初始化结束了。
finishRefresh();
}
//...
}其中，registerBeanPostProcessors()就是进行所有的bean后置处理器的注册实例化
// 注册实例化所有的bean后置处理器，放入beanFactory属性中
public static void registerBeanPostProcessors(
ConfigurableListableBeanFactory beanFactory, AbstractApplicationContext applicationContext) {
//1、获取所有的bean后置处理器的name,再根据name去实例化对应的BeanPostProcessor
String[] postProcessorNames = beanFactory.getBeanNamesForType(BeanPostProcessor.class, true, false);
// Register BeanPostProcessorChecker that logs an info message when
// a bean is created during BeanPostProcessor instantiation, i.e. when
// a bean is not eligible for getting processed by all BeanPostProcessors.
int beanProcessorTargetCount = beanFactory.getBeanPostProcessorCount() + 1 + postProcessorNames.length;
beanFactory.addBeanPostProcessor(new BeanPostProcessorChecker(beanFactory, beanProcessorTargetCount));
//2、对这些后置处理器进行排序分类存储 list
// Separate between BeanPostProcessors that implement PriorityOrdered,
// Ordered, and the rest.
List<BeanPostProcessor> priorityOrderedPostProcessors = new ArrayList<>();
List<BeanPostProcessor> internalPostProcessors = new ArrayList<>();
List<String> orderedPostProcessorNames = new ArrayList<>();
List<String> nonOrderedPostProcessorNames = new ArrayList<>();
for (String ppName : postProcessorNames) {
if (beanFactory.isTypeMatch(ppName, PriorityOrdered.class)) {
BeanPostProcessor pp = beanFactory.getBean(ppName, BeanPostProcessor.class);
priorityOrderedPostProcessors.add(pp);
if (pp instanceof MergedBeanDefinitionPostProcessor) {
internalPostProcessors.add(pp);
}
} else if (beanFactory.isTypeMatch(ppName, Ordered.class)) {
orderedPostProcessorNames.add(ppName);
} else {
nonOrderedPostProcessorNames.add(ppName);
}
}
//3、以下是根据排序的优先级将所有的BeanPostProcessors后置处理器注册实例化，并放入AbstractBeanFactory的属性中
// -->即 List<BeanPostProcessor> beanPostProcessors
// （1）首先，注册实现了PriorityOrdered接口的BeanPostProcessors
// First, register the BeanPostProcessors that implement PriorityOrdered.
sortPostProcessors(priorityOrderedPostProcessors, beanFactory);//排序
registerBeanPostProcessors(beanFactory, priorityOrderedPostProcessors);
// （2）然后，注册实现了Ordered接口的BeanPostProcessors
// Next, register the BeanPostProcessors that implement Ordered.
List<BeanPostProcessor> orderedPostProcessors = new ArrayList<>();
for (String ppName : orderedPostProcessorNames) {
// AspectJAwareAdvisorAutoProxyCreator的实例化就是在这里进行的,因为它也属于BeanPostProcessor的子类
// 那么对于其它bean实例化的时候它就可以起到后置处理器的作用--> AOP生成代理对象
BeanPostProcessor pp = beanFactory.getBean(ppName, BeanPostProcessor.class);
orderedPostProcessors.add(pp);
if (pp instanceof MergedBeanDefinitionPostProcessor) {
internalPostProcessors.add(pp);
}
}
sortPostProcessors(orderedPostProcessors, beanFactory);//排序
registerBeanPostProcessors(beanFactory, orderedPostProcessors);
// （3）再注册所有普通的BeanPostProcessor（未实现PriorityOrdered/Ordered接口的bean后置处理器）
// Now, register all regular BeanPostProcessors.
List<BeanPostProcessor> nonOrderedPostProcessors = new ArrayList<>();
for (String ppName : nonOrderedPostProcessorNames) {
BeanPostProcessor pp = beanFactory.getBean(ppName, BeanPostProcessor.class);
nonOrderedPostProcessors.add(pp);
if (pp instanceof MergedBeanDefinitionPostProcessor) {
internalPostProcessors.add(pp);
}
}
registerBeanPostProcessors(beanFactory, nonOrderedPostProcessors);
// （4）最后，注册所有的 internalPostProcessors
// Finally, re-register all internal BeanPostProcessors.
sortPostProcessors(internalPostProcessors, beanFactory);
registerBeanPostProcessors(beanFactory, internalPostProcessors);
// Re-register post-processor for detecting inner beans as ApplicationListeners,
// moving it to the end of the processor chain (for picking up proxies etc).
beanFactory.addBeanPostProcessor(new ApplicationListenerDetector(applicationContext));
}其中，AspectJAwareAdvisorAutoProxyCreator实现了Ordered接口，所以它是在上面的第（2）步进行实例化的，那么对于其它bean实例化的时候它就可以起到后置处理器的作用了-->AOP，即给目标对象产生代理对象。
现在，我们已经知道AOP代理对象创建器（AspectJAwareAdvisorAutoProxyCreator）在哪里创建了，接下来就是寻找该bean后置处理器在什么时候给目标对象生成代理对象的。
进入AbstractApplicationContext#refresh方法中的 finishBeanFactoryInitialization(beanFactory)，看过Spring Bean生命周期源码的，应该都知道，该方法十分重要，它完成了所有剩余的、非懒加载的、单例的bean实例化和初始化过程。为什么说是剩余呢？如果开发人员自定义了BeanPostProcessor，而BeanPostProcessor在上面registerBeanPostProcessors()已经实例化了，所以在这里不会再实例化，因此这里使用剩余一词。
protected void finishBeanFactoryInitialization(ConfigurableListableBeanFactory beanFactory) {
// Initialize conversion service for this context.
if (beanFactory.containsBean(CONVERSION_SERVICE_BEAN_NAME) &&
beanFactory.isTypeMatch(CONVERSION_SERVICE_BEAN_NAME, ConversionService.class)) {
beanFactory.setConversionService(
beanFactory.getBean(CONVERSION_SERVICE_BEAN_NAME, ConversionService.class));
}
// Register a default embedded value resolver if no bean post-processor
// (such as a PropertyPlaceholderConfigurer bean) registered any before:
// at this point, primarily for resolution in annotation attribute values.
if (!beanFactory.hasEmbeddedValueResolver()) {
beanFactory.addEmbeddedValueResolver(strVal -> getEnvironment().resolvePlaceholders(strVal));
}
// Initialize LoadTimeWeaverAware beans early to allow for registering their transformers early.
String[] weaverAwareNames = beanFactory.getBeanNamesForType(LoadTimeWeaverAware.class, false, false);
for (String weaverAwareName : weaverAwareNames) {
getBean(weaverAwareName);
}
// Stop using the temporary ClassLoader for type matching.
beanFactory.setTempClassLoader(null);
// Allow for caching all bean definition metadata, not expecting further changes.
beanFactory.freezeConfiguration();
// Instantiate all remaining (non-lazy-init) singletons.
// 主要看这一个方法
beanFactory.preInstantiateSingletons();
}我们进入bean工厂AbstractBeanFactory的默认实现子类 DefaultListableBeanFactory#preInstantiateSingletons()方法，从原注释也可以知道，它才是实现所有剩余的单例bean实例化的方法：
@Override
public void preInstantiateSingletons() throws BeansException {
if (this.logger.isDebugEnabled()) {
this.logger.debug("Pre-instantiating singletons in " + this);
}
// Iterate over a copy to allow for init methods which in turn register new bean definitions.
// While this may not be part of the regular factory bootstrap, it does otherwise work fine.
//
List<String> beanNames = new ArrayList<>(this.beanDefinitionNames);
// Trigger initialization of all non-lazy singleton beans...
// 触发所有非懒加载的单例bean的初始化...
for (String beanName : beanNames) {
RootBeanDefinition bd = getMergedLocalBeanDefinition(beanName);
// 非抽象类、单例、非懒加载
if (!bd.isAbstract() && bd.isSingleton() && !bd.isLazyInit()) {
// 属于FactoryBean子类的bean
if (isFactoryBean(beanName)) {
Object bean = getBean(FACTORY_BEAN_PREFIX + beanName);
if (bean instanceof FactoryBean) {
final FactoryBean<?> factory = (FactoryBean<?>) bean;
boolean isEagerInit;
if (System.getSecurityManager() != null && factory instanceof SmartFactoryBean) {
isEagerInit = AccessController.doPrivileged((PrivilegedAction<Boolean>)
((SmartFactoryBean<?>) factory)::isEagerInit,
getAccessControlContext());
} else {
isEagerInit = (factory instanceof SmartFactoryBean &&
((SmartFactoryBean<?>) factory).isEagerInit());
}
if (isEagerInit) {
getBean(beanName);
}
}
} else {
// 普通bean(非FactoryBean子类)
getBean(beanName);
}
}
}
//...
}从上面源码，可以看到，这里bean的实例化，主要分为两种：
- FactoryBean子类的实例化
- 普通bean（非FactoryBean子类）的实例化
至于什么是FactoryBean？它可以让我们自定义Bean的创建过程，主要是通过实现FactoryBean接口的getObject()方法，具体可以看之前单独写的文章《【Spring源码：FactoryBean一】终于弄懂FactoryBean是如何自定义bean的创建过程了》。
最后，都会调用getBean(beanName)方法，我们可以继续追踪该方法源码，发现最终进入AbstractBeanFactory#doGetBean()方法：
protected <T> T doGetBean(final String name, @Nullable final Class<T> requiredType,
@Nullable final Object[] args, boolean typeCheckOnly) throws BeansException {
// beanName格式化转换，如别名、&factoryBean
final String beanName = transformedBeanName(name);
Object bean;
// Eagerly check singleton cache for manually registered singletons.
// 1、先从单例缓存池中获取
Object sharedInstance = getSingleton(beanName);
if (sharedInstance != null && args == null) {
//...
// 这里为啥不直接返回该sharedInstance？？ ---> FactoryBean作用：getObject()自定义bean的创建过程.
bean = getObjectForBeanInstance(sharedInstance, name, beanName, null);
} else {// 2、单例缓存池获取不到
//...
// Create bean instance.
// 根据bean的作用域范围scope，创建bean实例
if (mbd.isSingleton()) {// 单例
sharedInstance = getSingleton(beanName, () -> {
try {
// 重点
return createBean(beanName, mbd, args);
}
});
bean = getObjectForBeanInstance(sharedInstance, name, beanName, mbd);
}
// ...其中，该方法比较长，这里只截取部分核心代码，主要分两部分功能：
- 通过从单例缓存池中获取bean，能获取到（不为空），说明已创建过，则继续调用getObjectForBeanInstance()方法；
- 后半部分else是单例池获取不到时，说明是首次创建，需要调用createBean()方法，创建好之后，同样会调用到getObjectForBeanInstance()方法。
【注意】这里为啥获取到bean之后不直接返回，还要调用getObjectForBeanInstance()方法？
因为getObjectForBeanInstance()方法中还要进行判断该bean是FactoryBean子类，还是普通bean，如果是FactoryBean子类，并且name含有前缀&，则返回FactoryBean子类对象本身， 否则，返回FactoryBean子类的getObject()方法中自定义的对象，具体可看下面源码解释（这里也涉及到FactoryBean的知识）：
小插曲：AbstractBeanFactory#getObjectForBeanInstance()
protected Object getObjectForBeanInstance(
Object beanInstance, String name, String beanName, @Nullable RootBeanDefinition mbd) {
// Don't let calling code try to dereference the factory if the bean isn't a factory.
// 1、如果这是一个FactoryBean子类，并且name含有前缀&,说明需要获取的是FactoryBean子类本身，直接返回即可
if (BeanFactoryUtils.isFactoryDereference(name)) {
if (beanInstance instanceof NullBean) {
return beanInstance;
}
if (!(beanInstance instanceof FactoryBean)) {
throw new BeanIsNotAFactoryException(transformedBeanName(name), beanInstance.getClass());
}
}
// Now we have the bean instance, which may be a normal bean or a FactoryBean.
// If it's a FactoryBean, we use it to create a bean instance, unless the
// caller actually wants a reference to the factory.
// 2、如果这是一个普通bean,则直接返回该bean
if (!(beanInstance instanceof FactoryBean) || BeanFactoryUtils.isFactoryDereference(name)) {
return beanInstance;
}
// 3、能执行到这一步，说明它是一个FactoryBean子类，并且name不含&前缀
// 注意：如果是FactoryBean子类，name含有前缀&,则返回FactoryBean子类对象本身，
// 否则，返回FactoryBean子类的getObject()方法中自定义的对象
Object object = null;
if (mbd == null) {
object = getCachedObjectForFactoryBean(beanName);//先从缓存中获取
}
if (object == null) {
// Return bean instance from factory.
FactoryBean<?> factory = (FactoryBean<?>) beanInstance;
// Caches object obtained from FactoryBean if it is a singleton.
if (mbd == null && containsBeanDefinition(beanName)) {
mbd = getMergedLocalBeanDefinition(beanName);
}
boolean synthetic = (mbd != null && mbd.isSynthetic());
// 从FactoryBean中获取对象
object = getObjectFromFactoryBean(factory, beanName, !synthetic);
}
return object;
}其中，getObjectFromFactoryBean()方法，我们从名字就可以大概知道它是从FactoryBean中获取对象，由于篇幅原因，这里不详细分析，具体可看《【Spring源码：FactoryBean二】》。
【重点】
下面，我们继续回到主流程，createBean()方法，它属于AbstractBeanFactory中定义的方法，在AbstractAutowireCapableBeanFactory抽象子类中有默认实现，如下：
@Override
protected Object createBean(String beanName, RootBeanDefinition mbd, @Nullable Object[] args)
throws BeanCreationException {
RootBeanDefinition mbdToUse = mbd;
// 对给定的bean进行类加载
// Make sure bean class is actually resolved at this point, and
// clone the bean definition in case of a dynamically resolved Class
// which cannot be stored in the shared merged bean definition.
Class<?> resolvedClass = resolveBeanClass(mbd, beanName);
if (resolvedClass != null && !mbd.hasBeanClass() && mbd.getBeanClassName() != null) {
mbdToUse = new RootBeanDefinition(mbd);
mbdToUse.setBeanClass(resolvedClass);
}
// Prepare method overrides.
try {
mbdToUse.prepareMethodOverrides();
}
//1、代理对象的创建
// 一般是实现了InstantiationAwareBeanPostProcessor#postProcessBeforeInstantiation()
try {
// 调用 InstantiationAwareBeanPostProcessor 中的postProcessBeforeInstantiation。
// 这是在实例化bean之前执行的，可以直接在这里返回目标对象的的代理对象，这样就会跳过之后普通bean的doCreateBean创建过程，否则就继续执行正常的逻辑。
// 调用用于生成代理对象的BeanPostProcessor，如果bean不为null，则说明产生代理对象了，可以直接返回
// Give BeanPostProcessors a chance to return a proxy instead of the target bean instance.
// 让BeanPostProcessors有机会返回一个代理对象而不是目标bean实例
Object bean = resolveBeforeInstantiation(beanName, mbdToUse);
if (bean != null) {
// 如果bean不为null ,则直接返回，这种情况通常创建了代理对象。后面的doCreateBean不再执行
return bean;
}
}
//2、普通bean创建
try {
// 重点：创建bean
// 包括检查是否进行了类加载（没有则进行类加载），bean对象实例创建，bean对象实例的属性赋值，init-method的调用，BeanPostProcessor的调用
Object beanInstance = doCreateBean(beanName, mbdToUse, args);
if (logger.isDebugEnabled()) {
logger.debug("Finished creating instance of bean '" + beanName + "'");
}
return beanInstance;
}
}其中：
Object bean = resolveBeforeInstantiation(beanName, mbdToUse)
这句代码如果返回的bean不为空，则直接返回该bean，这种情况通常是创建了代理对象，后面的doCreateBean不再执行，下面具体分析：
AbstractAutowireCapableBeanFactory#resolveBeforeInstantiation()
@Nullable
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
// 如果返回不是null，则一般是代理对象
bean = applyBeanPostProcessorsBeforeInstantiation(targetType, beanName);
if (bean != null) {
// 如果使用postProcessBeforeInstantiation创建了bean对象，则是当前bean对象的代理对象了
// 这个方法执行完，退出则直接返回该代理bean对象了，
// 故在这里调用一下其他BeanPostProcessor的postProcessAfterInitialization
// 注意是initialization（初始化后），直接执行初始化之后的方法，中间的实例化之后 和 初始化之前都不执行
bean = applyBeanPostProcessorsAfterInitialization(bean, beanName);
}
}
}
mbd.beforeInstantiationResolved = (bean != null);
}
return bean;
}其中，执行applyBeanPostProcessorsBeforeInstantiation(targetType, beanName) 时，就会去遍历所有的BeanPostProcessor实例 ，判断是否是有属于InstantiationAwareBeanPostProcessor子类实例，有则去执行
InstantiationAwareBeanPostProcessor 的postProcessBeforeInstantiation方法，只要有一个result不为null，则后面的所有 后置处理器的方法就不执行了，直接返回(所以执行顺序很重要)，如下：
@Nullable
protected Object applyBeanPostProcessorsBeforeInstantiation(Class<?> beanClass, String beanName) {
// 获取所有的Bean后置处理器，然后遍历查看是否为子接口InstantiationAwareBeanPostProcessor，
// 如果是则调用其postProcessBeforeInstantiation方法
for (BeanPostProcessor bp : getBeanPostProcessors()) {
// 查找实现了InstantiationAwareBeanPostProcessor接口的BeanPostProcessor
// 其中在spring-aop模块定义的AspectJAwareAdvisorAutoProxyCreator就实现了InstantiationAwareBeanPostProcessor接口
if (bp instanceof InstantiationAwareBeanPostProcessor) {
InstantiationAwareBeanPostProcessor ibp = (InstantiationAwareBeanPostProcessor) bp;
// AbstractAutoProxyCreator 子类的 postProcessBeforeInstantiation()
Object result = ibp.postProcessBeforeInstantiation(beanClass, beanName);
// 如果创建成功则直接返回
if (result != null) {
//只要有一个result不为null；后面的所有 后置处理器的方法就不执行了，直接返回(所以执行顺序很重要)
return result;
}
}
}
return null;
}当applyBeanPostProcessorsBeforeInstantiation(）返回不为null时，则会接着执行applyBeanPostProcessorsAfterInitialization()，遍历所有的BeanPostProcessor实例，分别执行它们的postProcessAfterInitialization()方法，注意这里是xxxInitialization（初始化后），直接执行初始化之后的方法，中间的实例化之后 和 初始化之前都不执行。
@Override
public Object applyBeanPostProcessorsAfterInitialization(Object existingBean, String beanName)
throws BeansException {
Object result = existingBean;
// 遍历所有的bean后置处理器
for (BeanPostProcessor beanProcessor : getBeanPostProcessors()) {
// 其中有一个子类AbstractAutoProxyCreator,调用它的postProcessAfterInitialization就会产生aop代理对象
// 所以非提前生成的代理对象 是在属性填充populateBean完成之后，执行了initializeBean方法的时候进行的动态代理
Object current = beanProcessor.postProcessAfterInitialization(result, beanName);
if (current == null) {
return result;
}
result = current;
}
return result;
}上面3段代码详细说明：
- 如果postProcessBeforeInstantiation方法返回了Object是null，那么就直接返回，调用doCreateBean方法();
- 如果postProcessBeforeInstantiation返回不为null，说明修改了bean对象，然后这个时候就立马执行postProcessAfterInitialization方法(注意这个是初始化之后的方法，也就是通过这个方法实例化了之后，直接执行初始化之后的方法，中间的实例化之后 和 初始化之前都不执行);
- 在调用postProcessAfterInitialization方法时候如果返回null，那么就直接返回，调用doCreateBean方法()，(初始化之后的方法返回了null，那就需要调用doCreateBean生成对象了)
- 在调用postProcessAfterInitialization时返回不为null，那这个bean就直接返回给ioc容器了，初始化之后的操作是这里面最后一个方法了；
- 通过上面的描述，我们其实可以在这里生成一个代理类；
注：这小部分引用：https://blog.csdn.net/u010634066/article/details/80321854
下面，我们写一个例子让postProcessBeforeInstantiation返回一个代理类的情况
下面用cglib动态代理生成一个代理类:
public class TestFb {
public void dosomething() {
System.out.print("执行了dosomething.......\n");
}
}
public class MyMethodInterceptor implements MethodInterceptor {
@Override
public Object intercept(Object o, Method method, Object[] objects, MethodProxy methodProxy) throws Throwable {
System.out.println("目标方法前:" + method+"\n");
Object object = methodProxy.invokeSuper(o, objects);
System.out.println("目标方法后:" + method+"\n");
return object;
}
}
public class MyInstantiationAwareBeanPostProcessor implements InstantiationAwareBeanPostProcessor {
@Override
public Object postProcessBeforeInstantiation(Class<?> beanClass, String beanName) throws BeansException {
System.out.print("beanName:"+beanName+"执行..postProcessBeforeInstantiation\n");
//利用 其 生成动态代理
if(beanClass==TestFb.class){
Enhancer enhancer = new Enhancer();
enhancer.setSuperclass(beanClass);
enhancer.setCallback(new MyMethodInterceptor());
TestFb testFb = (TestFb)enhancer.create();
System.out.print("返回动态代理\n");
return testFb;
}
return null;
}
@Override
public boolean postProcessAfterInstantiation(Object bean, String beanName) throws BeansException {
System.out.print("beanName:"+beanName+"执行..postProcessAfterInstantiation\n");
return false;
}
@Override
public PropertyValues postProcessPropertyValues(PropertyValues pvs, PropertyDescriptor[] pds, Object bean, String beanName) throws BeansException {
System.out.print("beanName:"+beanName+"执行..postProcessPropertyValues\n");
return pvs;
}
@Override
public Object postProcessBeforeInitialization(Object bean, String beanName) throws BeansException {
System.out.print("beanName:"+beanName+"执行..postProcessBeforeInitialization\n");
return bean;
}
@Override
public Object postProcessAfterInitialization(Object bean, String beanName) throws BeansException {
System.out.print("beanName:"+beanName+"执行..postProcessAfterInitialization\n");
return bean;
}
}
然后启动
public static void main(String[] args) throws Exception {
ApplicationContext ac = new ClassPathXmlApplicationContext("SpringContextConfig.xml");
TestFb testFb = ac.getBean(TestFb.class);
testFb.dosomething();
}
输出结果:
beanName:tfb执行..postProcessBeforeInstantiation
返回动态代理
beanName:tfb执行..postProcessAfterInitialization
目标方法前:public void src.factorybean.TestFb.dosomething()
执行了dosomething.......
目标方法后:public void src.factorybean.TestFb.dosomething()
结果很明显了，postProcessBeforeInstantiation生成并返回了代理类，就直接执行 初始化之后的操作postProcessAfterInitialization；
没有执行 实例化之后postProcessAfterInstantiation，
也没执行 初始化之前postProcessBeforeInitialization。
小结：
InstantiationAwareBeanPostProcessor接口继承BeanPostProcessor接口，它内部提供了3个方法，再加上BeanPostProcessor接口内部的2个方法，所以实现这个接口需要实现5个方法。InstantiationAwareBeanPostProcessor接口的主要作用在于目标对象的实例化过程中需要处理的事情，包括实例化对象的前后过程以及实例的属性设置。
postProcessBeforeInstantiation方法是最先执行的方法，它在目标对象实例化之前调用，该方法的返回值类型是Object，我们可以返回任何类型的值。由于这个时候目标对象还未实例化，所以这个返回值可以用来代替原本该生成的目标对象的实例(比如代理对象)。如果该方法的返回值代替原本该生成的目标对象，后续只有postProcessAfterInitialization方法会调用，其它方法不再调用；否则按照正常的流程走。
注：由于篇幅原因，下一篇继续分析。
参考：
●阿里巴巴为什么能抗住90秒100亿？--服务端高并发分布式架构演进之路
●SpringCloud电商秒杀微服务-Redisson分布式锁方案
查看更多好文，进入公众号--撩我--往期精彩
一只 有深度 有灵魂 的公众号0.0
801
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
