接着分析。
先贴出文末得总结：
总结：
- ApplicationContextAwareProcessor用来处理Aware等类，set传applicationContext参数进去，比如如果想获取ApplicationContext，则可以通过实现ApplicationContextAware接口。
- ApplicationListenerDetector，bean后置处理器，针对ApplicationListener，实例化的时候，放入beanFactory，
- BeanFactoryPostProcess，在实例化bean前，最先做的就是调用BeanFactoryPostProcess，所以如果BeanFactoryPostProcess里调用了getBean实例化了bean，之后再getBean的时候，不会触发BeanPostProcess的方法。
- 调用了BeanFactoryPostProcess之后，下一步就是，注册BeanPostProcess，会从所有bean中，找到BeanPostProcess，然后注册进beanFactory。
- 然后会创建事件广播器，然后把BeanPostProcess放入事件广播器。
- 然后就是注册ApplicationListener监听器，在所有的bean中找到application监听器，然后注册进事件广播器，之后发布application事件的时候，application监听器就会得到调用。
- 调用就是实例化bean，最先实例化的是类型转换器类，实例化其实是在getBean中完成了，实例化的bean都会保存在singleObject这个map中，所以每次getBean方法都是从这个map中取值，没有，则进行实例化，没有重写方法则使用反射实例化，否则使用cglib实例化，实例化之后会保存一份获取原始bean得bean工厂，用于解决循环依赖。
7、spring解决循环依赖使用了三个map，singletonObjects、earlySingletonObjects、singletonFactories。按正常思维想，其实只需要两个map就可以搞定循环依赖，一个singletonObjects保存真正的构造好的实例。一个earlySingletonObjects保存没有填充属性的实例。为什么是3个，原因是，当aop的时候singletonFactories map保存的factory调用getEarlyBeanReference方法获取的是代理类。没调一次获取一个代理类，所以这里需要使用earlySingletonObjects保存起来。
8.实例化了之后，注入依赖的属性。
9.然后回调方法，比如beanPostProcess和init初始化方法。
10.最后一步，发布初始化spring容器完成事件，通过事件发布器发布。
注意几个东西：beanFactoryPostProcess, beanPostProcess，事件监听器，ApplicationContextAware。以及他们的顺序。
注册调用beanFactoryPostProcess=》注册BeanPostProcess=》注册事件事件广播器=》注册事件监听器=》实例化bean=》回调beanPostProcess和init方法=》发布refresh完成事件。
beanFactoryPostProcess因为是最先调用得，所以，可以做很多事情，比如自己注入beanDefinition。
beanPostProcess：因为是在实例化bean之后调用，所以可以修改实例化得bean,比如Aop就是通过这个机制实现得，aop得DefaultAdvisorAutoProxyCreator就是一个BeanPostProcess，在bean初始化后，调用BeanPostProcess得方法返回一个代理类。
事件监听器：可以通过发布、监听事件，起到一个观察者模式。
比如，我曾经遇到过：beanPostProcess后置处理器，getBean得时候，怎么滴都得不到调用，后来发现是在BeanFactoryPostProcess中以及调用过getBean方法，而那时，并没有注册BeanPostProcess，所以得不到调用。
分析：
public void refresh() throws BeansException, IllegalStateException {
synchronized (this.startupShutdownMonitor) {
// 标记了激活、关闭状态，验证了下参数
prepareRefresh();
// 初始化了BeanFactory，分析并注册了BeanDefinition
ConfigurableListableBeanFactory beanFactory = obtainFreshBeanFactory();
// 添加了处理Aware类、监听ApplicationListenner的BeanPostProcess，注册了一些系统bean等。下文有解析
prepareBeanFactory(beanFactory);
try {
// 给子类实现的，空
postProcessBeanFactory(beanFactory);
// 注册和调用beanFactoryPostProcess，包括其子接口
// BeanDefinitionRegistryPostProcessor，后置处理器有优先级，会根据优先级顺
// 序调用。代码有点长，不贴了，逻辑比较简单
invokeBeanFactoryPostProcessors(beanFactory);
// 注册BeanPost处理器，和beanFactoryPostProcess一样，但是不会调用，调用时在其他bean初始化的时候，调用的
registerBeanPostProcessors(beanFactory);
// 初始化message，国际化的，忽略
initMessageSource();
// 初始化事件广播器，创建了SimpleApplicationEventMulticaster广播器，广播事件用的就是它
initApplicationEventMulticaster();
// 给子类实现的，空
onRefresh();
// 注册ApplicationListener,就是把监听器放入前面初始化的事件广播器
// 前面添加的事件后置处理器ApplicationListenerDetector，只是初始化bean的时
// 候，如果它实现了ApplicationListener接口，则放入BeanFactory，但是并没有
// 放入事件广播器，而这里会把beanFactory中的事件监听器，放入事件广播器
// 并且，我们自己定义的ApplicationListener，也会在这里获取，然后放入事件广播器
// 只有放入事件广播器的监听器，才会监听到事件
registerListeners();
// 实例化剩余没有实例的bean，前面可能已经实例化了一部分bean，比如
// beanFactory后置处理器中可能会调用getBean方法实例化bean，看下文解析
finishBeanFactoryInitialization(beanFactory);
// Last step: publish corresponding event.
finishRefresh();
}
catch (BeansException ex) {
if (logger.isWarnEnabled()) {
logger.warn("Exception encountered during context initialization - " +
"cancelling refresh attempt: " + ex);
}
// Destroy already created singletons to avoid dangling resources.
destroyBeans();
// Reset 'active' flag.
cancelRefresh(ex);
// Propagate exception to caller.
throw ex;
}
finally {
// Reset common introspection caches in Spring's core, since we
// might not ever need metadata for singleton beans anymore...
resetCommonCaches();
}
}
}
protected void prepareBeanFactory(ConfigurableListableBeanFactory beanFactory) {
// beanFactory设置类加载器
beanFactory.setBeanClassLoader(getClassLoader());
// 设置bean表达式分析器
beanFactory.setBeanExpressionResolver(new StandardBeanExpressionResolver(beanFactory.getBeanClassLoader()));
beanFactory.addPropertyEditorRegistrar(new ResourceEditorRegistrar(this, getEnvironment()));
// 添加一个BeanPostProcessor，ApplicationContextAwareProcessor这个后置bean处理器作用是：各种Aware类初始化的时候传递ApplicationContext对象，比如：
// ApplicationContextAware对象设置ApplicationContext对象
beanFactory.addBeanPostProcessor(new ApplicationContextAwareProcessor(this));
// 自动装配的时候忽略这些Aware类
beanFactory.ignoreDependencyInterface(EnvironmentAware.class);
beanFactory.ignoreDependencyInterface(EmbeddedValueResolverAware.class);
beanFactory.ignoreDependencyInterface(ResourceLoaderAware.class);
beanFactory.ignoreDependencyInterface(ApplicationEventPublisherAware.class);
beanFactory.ignoreDependencyInterface(MessageSourceAware.class);
beanFactory.ignoreDependencyInterface(ApplicationContextAware.class);
// BeanFactory interface not registered as resolvable type in a plain factory.
// 注册自动装配的bean：如果有bean指定自动装配这个类，则会set这个对象
beanFactory.registerResolvableDependency(BeanFactory.class, beanFactory);
beanFactory.registerResolvableDependency(ResourceLoader.class, this);
beanFactory.registerResolvableDependency(ApplicationEventPublisher.class, this);
beanFactory.registerResolvableDependency(ApplicationContext.class, this);
// Register early post-processor for detecting inner beans as ApplicationListeners.
// // 添加一个beanPost处理器：ApplicationListennerDetector。
// 顾名思义，这个beanPost处理器是，将实现了ApplicationListenner的接口的监听器，添加到Application中去
beanFactory.addBeanPostProcessor(new ApplicationListenerDetector(this));
// 是否有这个loadTimeWeaver，没有，忽略它
if (beanFactory.containsBean(LOAD_TIME_WEAVER_BEAN_NAME)) {
beanFactory.addBeanPostProcessor(new LoadTimeWeaverAwareProcessor(beanFactory));
// Set a temporary ClassLoader for type matching.
beanFactory.setTempClassLoader(new ContextTypeMatchClassLoader(beanFactory.getBeanClassLoader()));
}
// 把这些系统bean，注册进去
if (!beanFactory.containsLocalBean(ENVIRONMENT_BEAN_NAME)) {
// 因为这些系统bean，已经实例化了，所以注册极其简单，直接往
// DefaultSingletonBeanRegistry（DefaultListableBeanFactory实现了这个接口）
// 的singletonObjects这个map中放。所有的单例bean，最后都是放到这个对象中
beanFactory.registerSingleton(ENVIRONMENT_BEAN_NAME, getEnvironment());
}
if (!beanFactory.containsLocalBean(SYSTEM_PROPERTIES_BEAN_NAME)) {
beanFactory.registerSingleton(SYSTEM_PROPERTIES_BEAN_NAME, getEnvironment().getSystemProperties());
}
if (!beanFactory.containsLocalBean(SYSTEM_ENVIRONMENT_BEAN_NAME)) {
beanFactory.registerSingleton(SYSTEM_ENVIRONMENT_BEAN_NAME, getEnvironment().getSystemEnvironment());
}
}
注册bean后置处理器
public static void registerBeanPostProcessors(
ConfigurableListableBeanFactory beanFactory, AbstractApplicationContext applicationContext) {
// 获取BeanPostProcessor的实现类名
String[] postProcessorNames = beanFactory.getBeanNamesForType(BeanPostProcessor.class, true, false);
// beanProcess的总数量
int beanProcessorTargetCount = beanFactory.getBeanPostProcessorCount() + 1 + postProcessorNames.length;
beanFactory.addBeanPostProcessor(new BeanPostProcessorChecker(beanFactory, beanProcessorTargetCount));
// 实现了PriorityOrdered，实现了Ordered，没实现，三种后置处理器分别注册
List<BeanPostProcessor> priorityOrderedPostProcessors = new ArrayList<BeanPostProcessor>();
List<BeanPostProcessor> internalPostProcessors = new ArrayList<BeanPostProcessor>();
List<String> orderedPostProcessorNames = new ArrayList<String>();
List<String> nonOrderedPostProcessorNames = new ArrayList<String>();
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);
}
}
// First, register the BeanPostProcessors that implement PriorityOrdered.
sortPostProcessors(beanFactory, priorityOrderedPostProcessors);
registerBeanPostProcessors(beanFactory, priorityOrderedPostProcessors);
// Next, register the BeanPostProcessors that implement Ordered.
List<BeanPostProcessor> orderedPostProcessors = new ArrayList<BeanPostProcessor>();
for (String ppName : orderedPostProcessorNames) {
BeanPostProcessor pp = beanFactory.getBean(ppName, BeanPostProcessor.class);
orderedPostProcessors.add(pp);
if (pp instanceof MergedBeanDefinitionPostProcessor) {
internalPostProcessors.add(pp);
}
}
sortPostProcessors(beanFactory, orderedPostProcessors);
registerBeanPostProcessors(beanFactory, orderedPostProcessors);
// Now, register all regular BeanPostProcessors.
List<BeanPostProcessor> nonOrderedPostProcessors = new ArrayList<BeanPostProcessor>();
for (String ppName : nonOrderedPostProcessorNames) {
BeanPostProcessor pp = beanFactory.getBean(ppName, BeanPostProcessor.class);
nonOrderedPostProcessors.add(pp);
if (pp instanceof MergedBeanDefinitionPostProcessor) {
internalPostProcessors.add(pp);
}
}
registerBeanPostProcessors(beanFactory, nonOrderedPostProcessors);
// Finally, re-register all internal BeanPostProcessors.
sortPostProcessors(beanFactory, internalPostProcessors);
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));
}
实例化bean
// getBean就是真正的实例化对象
protected void finishBeanFactoryInitialization(ConfigurableListableBeanFactory beanFactory) {
// 先实例化类型转换器，并设置进beanFactory
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(new StringValueResolver() {
@Override
public String resolveStringValue(String strVal) {
return 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();
// 真正的实例化bean
beanFactory.preInstantiateSingletons();
}
@Override
public void preInstantiateSingletons() throws BeansException {
List<String> beanNames = new ArrayList<String>(this.beanDefinitionNames);
for (String beanName : beanNames) {
RootBeanDefinition bd = getMergedLocalBeanDefinition(beanName);
// 非抽象，非懒加载，单例
if (!bd.isAbstract() && bd.isSingleton() && !bd.isLazyInit()) {
// 是否是工厂bean，工厂bean，bean的名字前有&号
if (isFactoryBean(beanName)) {
final FactoryBean<?> factory = (FactoryBean<?>) getBean(FACTORY_BEAN_PREFIX + beanName);
boolean isEagerInit;
if (System.getSecurityManager() != null && factory instanceof SmartFactoryBean) {
isEagerInit = AccessController.doPrivileged(new PrivilegedAction<Boolean>() {
@Override
public Boolean run() {
return ((SmartFactoryBean<?>) factory).isEagerInit();
}
}, getAccessControlContext());
}
else {
isEagerInit = (factory instanceof SmartFactoryBean &&
((SmartFactoryBean<?>) factory).isEagerInit());
}
if (isEagerInit) {
getBean(beanName);
}
}
else {
// 非工厂bean进入这里，真正初始化
getBean(beanName);
}
}
}
// Trigger post-initialization callback for all applicable beans...
for (String beanName : beanNames) {
Object singletonInstance = getSingleton(beanName);
if (singletonInstance instanceof SmartInitializingSingleton) {
final SmartInitializingSingleton smartSingleton = (SmartInitializingSingleton) singletonInstance;
if (System.getSecurityManager() != null) {
AccessController.doPrivileged(new PrivilegedAction<Object>() {
@Override
public Object run() {
smartSingleton.afterSingletonsInstantiated();
return null;
}
}, getAccessControlContext());
}
else {
smartSingleton.afterSingletonsInstantiated();
}
}
}
}
分析getBean
@Override
public Object getBean(String name) throws BeansException {
return doGetBean(name, null, null, false);
}
protected <T> T doGetBean(
final String name, final Class<T> requiredType, final Object[] args, boolean typeCheckOnly){
final String beanName = transformedBeanName(name);
Object bean;
// 从前面说的singletonObjects对象中获取bean，没有则从singleFactory获取没有赋值属性的早期bean，解决循环依赖。
Object sharedInstance = getSingleton(beanName);
// bean如果已经初始化了，则返回
if (sharedInstance != null && args == null) {
.....
}
// 自己没有，就看看父beanFactory中有没有
BeanFactory parentBeanFactory = getParentBeanFactory();
if (parentBeanFactory != null && !containsBeanDefinition(beanName)) {
....
}
// 如果有depend-on属性，则先把依赖的bean，初始化
String[] dependsOn = mbd.getDependsOn();
if (dependsOn != null) {
for (String dep : dependsOn) {
if (isDependent(beanName, dep)) {
throw new BeanCreationException(mbd.getResourceDescription(), beanName,
"Circular depends-on relationship between '" + beanName + "' and '" + dep + "'");
}
registerDependentBean(dep, beanName);
getBean(dep);
}
}
}
// 如果是单例的，则调用createBean方法创建
if (mbd.isSingleton()) {
sharedInstance = getSingleton(beanName, new ObjectFactory<Object>() {
@Override
public Object getObject() throws BeansException {
try {
return createBean(beanName, mbd, args);
}
获取bean
protected Object getSingleton(String beanName, boolean allowEarlyReference) {
// singletonObjects有，则说明已经初始化了，直接返回
Object singletonObject = this.singletonObjects.get(beanName);
// 没有，则可能是循环依赖的，获取早期bean
if (singletonObject == null && isSingletonCurrentlyInCreation(beanName)) {
synchronized (this.singletonObjects) {
singletonObject = this.earlySingletonObjects.get(beanName);
if (singletonObject == null && allowEarlyReference) {
ObjectFactory<?> singletonFactory = this.singletonFactories.get(beanName);
if (singletonFactory != null) {
singletonObject = singletonFactory.getObject();
this.earlySingletonObjects.put(beanName, singletonObject);
this.singletonFactories.remove(beanName);
}
}
}
}
return (singletonObject != NULL_OBJECT ? singletonObject : null);
}
createBean方法创建
// 准备方法重载，方法重载
protected Object createBean(String beanName, RootBeanDefinition mbd, Object[] args) throws BeanCreationException {
// 调用InstantiationAwareBeanPostProcessor(BeanPostProcess的子类）的方法，实例化前，做一些操作
Object bean = resolveBeforeInstantiation(beanName, mbdToUse);
// 创建bean
Object beanInstance = doCreateBean(beanName, mbdToUse, args);
}
protected Object doCreateBean(final String beanName, final RootBeanDefinition mbd, final Object[] args)
throws BeanCreationException {、
// 真正实例化bean，有方法重写则通过cglib，没有则通过反射
instanceWrapper = createBeanInstance(beanName, mbd, args);
// 调用MergedBeanDefinitionPostProcessor（BeanPostProcessor子接口），忽视
applyMergedBeanDefinitionPostProcessors(mbd, beanType, beanName);
// 解决循环依赖，大概就是把获取原始bean（没有赋属性值的bean）得bean工厂，保存起来，保存在singletonFactories中，之后populateBean复制的时候，如果是循环依赖，则会从singletonFactories中取
/**
protected void addSingletonFactory(String beanName, ObjectFactory<?> singletonFactory) {
Assert.notNull(singletonFactory, "Singleton factory must not be null");
synchronized (this.singletonObjects) {
if (!this.singletonObjects.containsKey(beanName)) {
this.singletonFactories.put(beanName, singletonFactory);
this.earlySingletonObjects.remove(beanName);
this.registeredSingletons.add(beanName);
}
}
}
**/
boolean earlySingletonExposure = (mbd.isSingleton() && this.allowCircularReferences &&
isSingletonCurrentlyInCreation(beanName));
if (earlySingletonExposure) {
if (logger.isDebugEnabled()) {
logger.debug("Eagerly caching bean '" + beanName +
"' to allow for resolving potential circular references");
}
addSingletonFactory(beanName, new ObjectFactory<Object>() {
@Override
public Object getObject() throws BeansException {
return getEarlyBeanReference(beanName, mbd, bean);
}
});
}
// 赋值属性
populateBean(beanName, mbd, instanceWrapper);
// 回调，回调beanPostProcess，以及init-method或实现InitializingBean的初始化方法
exposedObject = initializeBean(beanName, exposedObject, mbd);
}
protected void applyPropertyValues(String beanName, BeanDefinition mbd, BeanWrapper bw, PropertyValues pvs) {
List<PropertyValue> original;
original = mpvs.getPropertyValueList();
}
// Create a deep copy, resolving any references for values.
List<PropertyValue> deepCopy = new ArrayList<PropertyValue>(original.size());
boolean resolveNecessary = false;
for (PropertyValue pv : original) {
if (pv.isConverted()) {
deepCopy.add(pv);
}
else {
String propertyName = pv.getName();
Object originalValue = pv.getValue();
// 在这里会去复属性值
Object resolvedValue = valueResolver.resolveValueIfNecessary(pv, originalValue);
....
}
private Object resolveReference(Object argName, RuntimeBeanReference ref) {
...
// 这里会去初始化属性对应的bean，如此循环，最后所有的bean都初始化了
Object bean = this.beanFactory.getBean(refName);
this.beanFactory.registerDependentBean(refName, this.beanName);
return bean;
}
}
总结：
- ApplicationContextAwareProcessor用来处理Aware等类，set传applicationContext参数进去，比如如果想获取ApplicationContext，则可以通过实现ApplicationContextAware接口。
- ApplicationListenerDetector，bean后置处理器，针对ApplicationListener，实例化的时候，放入beanFactory，
- BeanFactoryPostProcess，在实例化bean前，最先做的就是调用BeanFactoryPostProcess，所以如果BeanFactoryPostProcess里调用了getBean实例化了bean，之后再getBean的时候，不会触发BeanPostProcess的方法。
- 调用了BeanFactoryPostProcess之后，下一步就是，注册BeanPostProcess，会从所有bean中，找到BeanPostProcess，然后注册进beanFactory。
- 然后会创建事件广播器，然后把BeanPostProcess放入事件广播器。
- 然后就是注册ApplicationListener监听器，在所有的bean中找到application监听器，然后注册进事件广播器，之后发布application事件的时候，application监听器就会得到调用。
- 调用就是实例化bean，最先实例化的是类型转换器类，实例化其实是在getBean中完成了，实例化的bean都会保存在singleObject这个map中，所以每次getBean方法都是从这个map中取值，没有，则进行实例化，没有重写方法则使用反射实例化，否则使用cglib实例化，实例化之后会保存一份获取原始bean得bean工厂，用于解决循环依赖。
7、spring解决循环依赖使用了三个map，一级缓存singletonObjects、二级缓存earlySingletonObjects、三级缓存singletonFactories。第一次
Object sharedInstance = getSingleton(beanName)，从1级缓存取，如果对象正在创建，从二级缓存取，取不到从三级缓存区。都取不到，第二步：getSingleton(String beanName, ObjectFactory<?> singletonFactory)，创建bean，并放入三级缓存。
为什么要用factory，不直接放bean？
工厂会执行beanPostFactory,比如aop会生成代理类。
所以，如果没有三级缓存，每次获取，都会生成一个代理类
为什么不是二级缓存？
按正常思维想，其实只需要两个map就可以搞定循环依赖，一个singletonObjects保存真正的构造好的实例。一个earlySingletonObjects保存没有填充属性的实例。为什么是3个，原因是，当aop的时候singletonFactories map保存的factory调用getEarlyBeanReference方法获取的是代理类。没调一次获取一个代理类，所以这里需要使用earlySingletonObjects保存起来。比如A有两个B属性，那么注入B属性的时候，B属性factory在三级缓存里，没有二级缓存的话，从三级缓存里取，调用1次，生成一个代理类，那么就不是单例了。
8.实例化了之后，注入依赖的属性。
9.然后回调方法，比如beanPostProcess和init初始化方法。
10.最后一步，发布初始化spring容器完成事件，通过事件发布器发布。
注意几个东西：beanFactoryPostProcess, beanPostProcess，事件监听器，ApplicationContextAware。以及他们的顺序。
注册调用beanFactoryPostProcess=》注册BeanPostProcess=》注册事件事件广播器=》注册事件监听器=》实例化bean=》回调beanPostProcess和init方法=》发布refresh完成事件。
beanFactoryPostProcess因为是最先调用得，所以，可以做很多事情，比如自己注入beanDefinition。
beanPostProcess：因为是在实例化bean之后调用，所以可以修改实例化得bean,比如Aop就是通过这个机制实现得，aop得DefaultAdvisorAutoProxyCreator就是一个BeanPostProcess，在bean初始化后，调用BeanPostProcess得方法返回一个代理类。
事件监听器：可以通过发布、监听事件，起到一个观察者模式。
比如，我曾经遇到过：beanPostProcess后置处理器，getBean得时候，怎么滴都得不到调用，后来发现是在BeanFactoryPostProcess中以及调用过getBean方法，而那时，并没有注册BeanPostProcess，所以得不到调用。
网友评论