画布 1
bean的生命周期
  生成 bean
    平凡的 Bean 后处理器只关注 initialization 的前与后
    AbstractBeanFactory.getBean(String name, Class<T> requiredType)
但通常这个类的实现在现代 Spring 里是被 DefaultListableBeanFactory 的实例调用
      AbstractBeanFactory
        方法
          doGetBean
            使用 BeanFactoryUtils 把参数 name 转成 beanName
            Object sharedInstance = getSingleton(beanName)
              尝试从 singletonObjects 中取值
              取不到则校验 singletonsCurrentlyInCreation，然后从 earlySingletonObjects、加锁后：singletonObjects、earlySingletonObjects（注意，取了两次）、singletonFactories 尝试取对象
            如果 sharedInstance 有值，则从 getObjectForBeanInstance 取值，这里面有稍微复杂一点的 factoryBean的逻辑。
bean = getObjectForBeanInstance(prototypeInstance, name, beanName, mbd);
要么返回这个 bean 本身（要么这个 sharedInstance 是bean本身，要么是 factoryBean 的 dereference），要么这是一个 factoryBean，用它来生成对象。
实际上 MyBatis 是使用 FactoryBean 的方式，来让 Spring 来生成属于自己的 Bean 的。
            先假定我们在一个循环引用（circular reference）里，然后：
              isPrototypeCurrentlyInCreation，抛出 BeanCurrentlyInCreationException
              尝试在 parentBeanFactory 利用nameToLookup 机制来获取 bean
              确认是不是 typeCheckOnly，通常不是。直接先写入 alreadyCreated 这个缓存
              生成一个 applicationStartup
              getMergedLocalBeanDefinition(beanName)，然后 checkMergedBeanDefinition
              通过解读 mbd，得到所有 dependsOn，遍历 dependsOn，如果有依赖，则 throw new BeanCreationException，声明 Circular depends-on relationship
                否则，eager 地 getBean
              如果 mbd.isSingleton()
                sharedInstance = getSingleton(beanName, () -> {
try {
// 这是一个内嵌的结构，这个闭包是 getSingleton 许多步骤的中间一步
return createBean(beanName, mbd, args);
}
catch (BeansException ex) {
// Explicitly remove instance from singleton cache: It might have been put there
// eagerly by the creation process, to allow for circular reference resolution.
// Also remove any beans that received a temporary reference to the bean.
// 此处是比较高层的地方在生成 bean不行的地方，做bean的销毁
destroySingleton(beanName);
throw ex;
}
});
// 所有的 bean instance都要通过这个工厂过滤一次
beanInstance = getObjectForBeanInstance(sharedInstance, name, beanName, mbd);
                  getSingleton
                    这里可以体现出嵌套创建 bean 的时候会遇到的用集合去重的工序
                    加大锁 singletonObjects，这意味着 getSingleton 必须串行化
                    再从 singletonObjects 取值，取出来直接返回
                    如果这个 bean 正在被销毁，则抛出 BeanCreationNotAllowedException
                    beforeSingletonCreation(beanName)
!this.singletonsCurrentlyInCreation.add(beanName)
                    try {
// 这一步就是从闭包里取值
singletonObject = singletonFactory.getObject();
newSingleton = true;
}
                    如果成功，则去除 singletonsCurrentlyInCreation 里的配置
                    如果成功，则去除
if (newSingleton) {
addSingleton(beanName, singletonObject);
}
                      并且对一大堆集合进行操作：
synchronized (this.singletonObjects) {
this.singletonObjects.put(beanName, singletonObject);
this.singletonFactories.remove(beanName);
this.earlySingletonObjects.remove(beanName);
this.registeredSingletons.add(beanName);
}
                  getSingleton 这个方法来自于 DefaultSingletonBeanRegistry，而 AbstractBeanFactory 继承了 DefaultSingletonBeanRegistry
            这两步是第一次尝试使用 singleton 的缓存来获取 bean
          createBean
通常使用 AbstractAutowireCapableBeanFactory 的实现，this 仍然是 DefaultListableBeanFactory
            RootBeanDefinition mbdToUse = mbd;
mergedBeanDefinition
            Class<?> resolvedClass = resolveBeanClass(mbd, beanName);
if (resolvedClass != null && !mbd.hasBeanClass() && mbd.getBeanClassName() != null) {
// 做一个构造器拷贝
mbdToUse = new RootBeanDefinition(mbd);
mbdToUse.setBeanClass(resolvedClass);
}
              mbd.getBeanClass()
            try {
// Give BeanPostProcessors a chance to return a proxy instead of the target bean instance.
// 第0步：先试着获取一个proxy
Object bean = resolveBeforeInstantiation(beanName, mbdToUse);
if (bean != null) {
return bean;
}
}
              mbd.beforeInstantiationResolved 为 true 或者 null
before-instantiation post-processor 这个后处理器是特别拗口的。意味着是前实例化的后处理器。
              如果 bean 不是合成的（应用程序定义的 bean 都满足这个条件），且有 hasInstantiationAwareBeanPostProcessors（基础的框架内后处理器总有好几个）。 InstantiationAwareBeanPostProcessors 是 bean后处理器，是 AbstractBeanFactory 的一个成员列表。
这类 bean处理器有2个方法：
Object postProcessBeforeInstantiation 执行 InstantiationAwareBeanPostProcessors 的第一个方法
boolean postProcessAfterInstantiation 另有用处
              if (targetType != null) {
bean = applyBeanPostProcessorsBeforeInstantiation(targetType, beanName);
if (bean != null) {
// 如果前处理成功，后处理也会成功，注意，因为这里使用的是短路 bean，所以这里直接调用的是 AfterInitialization 的流程
bean = applyBeanPostProcessorsAfterInitialization(bean, beanName);
}
}
这里告诉我们，早期使用 beanProcessor 有两个必然不能略过的使用时机：before instantiation，和 after Initialization。即使是在短路逻辑里也是如此。
                applyBeanPostProcessorsBeforeInstantiation
                  先取 getBeanPostProcessorCache().instantiationAware 缓存的结果，然后 postProcessBeforeInstantiation
                    ConfigurationClassPostProcessor$ImportAwareBeanPostProcessor 的实例空实现
                    CommonAnnotationBeanPostProcessor 的实例空实现
                    AutowiredAnnotationBeanPostProcessor 的实例空实现
                    AnnotationAwareAspectJAutoProxyCreator 的实例
只有这个处理器热衷于用实现 postProcessBeforeInstantiation 作最早的初始化 proxy
                applyBeanPostProcessorsAfterInitialization
                  取出所有的 BeanPostProcessor，调用它的 postProcessAfterInitialization
              已经动过一次了，所以 beforeInstantiationResolved = (bean != null)
            Object beanInstance = doCreateBean(beanName, mbdToUse, args);
if (logger.isTraceEnabled()) {
logger.trace("Finished creating instance of bean '" + beanName + "'");
}
return beanInstance;
              这个方法告诉的意思是，“做一个bean”的流程，一部分是工厂组织方法调用完成的，另一部分是委托给各种各样的后处理器的接口方法完成的。
              doCreateBean
通常使用 AbstractAutowireCapableBeanFactory 的实现，this 仍然是 DefaultListableBeanFactory
                填充这个 bean
                声明一个为 null 的 instanceWrapper
                尝试用 remove 来获取缓存里的 bean：instanceWrapper = this.factoryBeanInstanceCache.remove(beanName)
                如果取不出来（第一次初始化的时候通常取不出来），则 instanceWrapper = createBeanInstance(beanName, mbd, args);
                instanceWrapper = createBeanInstance(beanName, mbd, args);
                  Class<?> beanClass = resolveBeanClass(mbd, beanName)，如果这个类不是 public 则抛出异常了
                  Supplier<?> instanceSupplier = mbd.getInstanceSupplier()
如果取得 instanceSupplier，则调用 obtainFromSupplier 来生成实例
                  if (mbd.getFactoryMethodName() != null) {
return instantiateUsingFactoryMethod(beanName, mbd, args);
}
                  Constructor<?>[] ctors = determineConstructorsFromBeanPostProcessors(beanClass, beanName);
实际上还是从4个 beanPostProcessor 里寻找合适的构造器
                  如果找得到构造器或者参数，走入 autowireConstructor
                  否则，走入 return instantiateBean(beanName, mbd)
                    if (System.getSecurityManager() != null)
                      beanInstance = AccessController.doPrivileged(
(PrivilegedAction<Object>) () -> getInstantiationStrategy().instantiate(mbd, beanName, this),
getAccessControlContext());
                    beanInstance = getInstantiationStrategy().instantiate(mbd, beanName, this);
                      使用 CglibSubclassingInstantiationStrategy 或者 SimpleInstantiationStrategy 来 instantiate，在 springConfiguration 里使用 SimpleInstantiationStrategy
                        锁定 bd.constructorArgumentLock
                        如果clazz 是接口，抛出异常
                        如果设置了 SecurityManager()，AccessController.doPrivileged 里 clazz::getDeclaredConstructor
                        否则，使用普通的 constructorToUse = clazz.getDeclaredConstructor();
                        return BeanUtils.instantiateClass(constructorToUse);
                          ReflectionUtils.makeAccessible(ctor);
                          return ctor.newInstance(argsWithDefaultValues);
                    用 beanInstance 装入 BeanWrapperImpl 得到 bw
                    initBeanWrapper(bw);
                      bw.setConversionService(getConversionService());
                      registerCustomEditors(bw);
                使用 instanceWrapper 的 beanType 来填充 mbd.resolvedTargetType
                在锁 postProcessingLock 里，使用 applyMergedBeanDefinitionPostProcessors 来修改 mbd
                  for (MergedBeanDefinitionPostProcessor processor : getBeanPostProcessorCache().mergedDefinition) {
// 这个 bean 后处理器的钩子方法是特殊的，专门为 mergedBeanDefinition 的 postProcess 设计的。这个位置晚于实例化，但又早于 populateBean
processor.postProcessMergedBeanDefinition(mbd, beanType, beanName);
}
                    ApplicationListenerDetector 的实例
                    CommonAnnotationBeanPostProcessor 的实例
                      // 调用父类 InitDestroyAnnotationBeanPostProcessor 中的回调方法处理 @PostConstruct 注解。这类方法通常会实现扫描@PostConstruct类，把所有的 bean 加入缓存里
super.postProcessMergedBeanDefinition(beanDefinition, beanType, beanName);
// 处理 @Resource 注解，
InjectionMetadata metadata = findResourceMetadata(beanName, beanType, null);
// 这有什么用呢？
metadata.checkConfigMembers(beanDefinition);
                      即 Spring 中注解的作用流程一般都是先要通过扫描，然后将对应的方法或者类进行缓存，最后在适时的时候进行调用）。
                    AutowiredAnnotationBeanPostProcessor 的实例
                确定 earlySingletonExposure，后面会用到
                populateBean(beanName, mbd, instanceWrapper);
                  如果 instanceWrapper 为空。 mbd.hasPropertyValues() 有值，则抛出异常；否则直接返回 null。
                  给 InstantiationAwareBeanPostProcessors() 一个机会，执行 postProcessAfterInstantiation。
只要有任意一个方法返回false，整个 populateBean 的流程都会停止！
                  PropertyValues pvs = (mbd.hasPropertyValues() ? mbd.getPropertyValues() : null);
                  获取 resolvedAutowireMode
@Resource 不等于name 和 type
                    resolvedAutowireMode == AUTOWIRE_BY_NAME
                      autowireByName(beanName, mbd, bw, newPvs);
                    resolvedAutowireMode == AUTOWIRE_BY_TYPE
                      autowireByType(beanName, mbd, bw, newPvs);
                  // 此处也在用 InstantiationAwareBeanPostProcessors，这是本方法内的第二次
boolean hasInstAwareBpps = hasInstantiationAwareBeanPostProcessors();
boolean needsDepCheck = (mbd.getDependencyCheck() != AbstractBeanDefinition.DEPENDENCY_CHECK_NONE);
                  // 把 pd 准备好
PropertyDescriptor[] filteredPds = null;
                  if (pvs == null) {
pvs = mbd.getPropertyValues();
}
                  for (InstantiationAwareBeanPostProcessor bp : getBeanPostProcessorCache().instantiationAware) {
// 先尝试处理 properties 得到一个 pvs。因为 postProcessPropertyValues 实际上已经废弃了，所以此刻返回非空 pvs 即意味着注入成功
PropertyValues pvsToUse = bp.postProcessProperties(pvs, bw.getWrappedInstance(), beanName);
if (pvsToUse == null) {
if (filteredPds == null) {
filteredPds = filterPropertyDescriptorsForDependencyCheck(bw, mbd.allowCaching);
}
pvsToUse = bp.postProcessPropertyValues(pvs, filteredPds, bw.getWrappedInstance(), beanName);
if (pvsToUse == null) {
return;
}
}
                // populate 和initialize以后，就得到了暴露对象
exposedObject = initializeBean(beanName, exposedObject, mbd);
                  调用这个bean可能存在的 aware 方法
                  这个地方是经典的后处理钩子，从顺序来讲，离构造器执行更远。也完全不需要 resolveDependencies
                  invokeAwareMethods(beanName, bean);
                    BeanNameAware
                    BeanClassLoaderAware
                    BeanFactoryAware
                      所以设置factory，就在 instantiate 和 populateBean之后，但在initialization 之前，这是一个夹缝时机
                  if (mbd == null || !mbd.isSynthetic()) {
wrappedBean = applyBeanPostProcessorsBeforeInitialization(wrappedBean, beanName);
}
                    // 这里是动态获取 PostProcessor 的，通常有10个 bean 后处理器
for (BeanPostProcessor processor : getBeanPostProcessors()) {
// 这里主要是调用某些非注入、非 init 方法的特殊方法，如初始化 @Postconstruct；或者把bean拿去绑定到某些别的地方
Object current = processor.postProcessBeforeInitialization(result, beanName);
if (current == null) {
// 只返回非空的处理后对象
return result;
}
// 否则，迭代后返回
result = current;
}
return result;
                      ConfigurationPropertiesBindingPostProcessor 的实例
                      InitDestroyAnnotationBeanPostProcessor 的实例
                      AnnotationAwareAspectJAutoProxyCreator 的实例
                  invokeInitMethods(beanName, wrappedBean, mbd);
                    查看能不能转成 InitializingBean，且不包含任何外部定义的 afterPropertiesSet 方法
                      可以转，安全管理者内或外执行 ((InitializingBean) bean).afterPropertiesSet();
                    获取 initMethodName
                      执行initMethod
                  if (mbd == null || !mbd.isSynthetic()) {
wrappedBean = applyBeanPostProcessorsAfterInitialization(wrappedBean, beanName);
}
                    Object result = existingBean;
for (BeanPostProcessor processor : getBeanPostProcessors()) {
Object current = processor.postProcessAfterInitialization(result, beanName);
if (current == null) {
return result;
}
result = current;
}
return result;
                  return wrappedBean;
                registerDisposableBeanIfNecessary(beanName, bean, mbd);
                  如果一个bean是 disposable 的，此时它应该被加入待处理列表。disposableBeans 是个 map。
        成员
    DefaultSingletonBeanRegistry
      这个注册表实际上是 bean 大缓存所在的地方
      关键方法
        public Object resolveDependency(DependencyDescriptor descriptor, @Nullable String requestingBeanName,
@Nullable Set<String> autowiredBeanNames, @Nullable TypeConverter typeConverter)
          ObjectProvider.class == descriptor.getDependencyType() 是通常的一般 field bean的注入点
          descriptor.initParameterNameDiscovery(getParameterNameDiscoverer());
          if (Optional.class == descriptor.getDependencyType()) {
// optional 走这里
return createOptionalDependency(descriptor, requestingBeanName);
}
          else if (ObjectFactory.class == descriptor.getDependencyType() || ObjectProvider.class == descriptor.getDependencyType()) {
return new DependencyObjectProvider(descriptor, requestingBeanName);
}
          else if (javaxInjectProviderClass == descriptor.getDependencyType()) {
return new Jsr330Factory().createDependencyProvider(descriptor, requestingBeanName);
}
          else {
Object result = getAutowireCandidateResolver().getLazyResolutionProxyIfNecessary(descriptor, requestingBeanName);
if (result == null) {
// 不 lazy 的 field 走到这里来
result = doResolveDependency(descriptor, requestingBeanName, autowiredBeanNames, typeConverter);
}
return result;
}
        Object doResolveDependency(DependencyDescriptor descriptor, @Nullable String beanName,
@Nullable Set<String> autowiredBeanNames, @Nullable TypeConverter typeConverter)
          InjectionPoint previousInjectionPoint = ConstructorResolver.setCurrentInjectionPoint(descriptor);
          Object shortcut = descriptor.resolveShortcut(this);
if (shortcut != null) {
return shortcut;
}
          // 一般的 getBean 走不到这里来
Object value = getAutowireCandidateResolver().getSuggestedValue(descriptor);
if (value != null) {
if (value instanceof String) {
String strVal = resolveEmbeddedValue((String) value);
BeanDefinition bd = (beanName != null && containsBean(beanName) ?getMergedBeanDefinition(beanName) : null);
value = evaluateBeanDefinitionString(strVal, bd);
}
TypeConverter converter = (typeConverter != null ? typeConverter : getTypeConverter());
try {
return converter.convertIfNecessary(value, type, descriptor.getTypeDescriptor());
} catch (UnsupportedOperationException ex) {
// A custom TypeConverter which does not support TypeDescriptor resolution...
return (descriptor.getField() != null ? converter.convertIfNecessary(value, type, descriptor.getField()) :
converter.convertIfNecessary(value, type, descriptor.getMethodParameter()));
}
}
          Object multipleBeans = resolveMultipleBeans(descriptor, beanName, autowiredBeanNames, typeConverter);
if (multipleBeans != null) {
return multipleBeans;
}
          Map<String, Object> matchingBeans = findAutowireCandidates(beanName, type, descriptor);
if (matchingBeans.isEmpty()) {
if (isRequired(descriptor)) {
raiseNoMatchingBeanFound(type, descriptor.getResolvableType(), descriptor);
}
return null;
}
          得到一大堆候选 beans ，然后大部分的平凡对象都会得到 instanceof Class
if (instanceCandidate instanceof Class) {
instanceCandidate = descriptor.resolveCandidate(autowiredBeanName, type, this);
}
Object result = instanceCandidate;
        Map<String, Object> findAutowireCandidates(
@Nullable String beanName, Class<?> requiredType, DependencyDescriptor descriptor)
          ---- 一大段代码
for (String candidate : candidateNames) {
if (!isSelfReference(beanName, candidate) && isAutowireCandidate(candidate, descriptor)) {
// 这里取 entry 的地方很关键
addCandidateEntry(result, candidate, descriptor, requiredType);
}
}
if (result.isEmpty()) {
boolean multiple = indicatesMultipleBeans(requiredType);
// Consider fallback matches if the first pass failed to find anything...
DependencyDescriptor fallbackDescriptor = descriptor.forFallbackMatch();
for (String candidate : candidateNames) {
if (!isSelfReference(beanName, candidate) && isAutowireCandidate(candidate, fallbackDescriptor) &&
(!multiple || getAutowireCandidateResolver().hasQualifier(descriptor))) {
addCandidateEntry(result, candidate, descriptor, requiredType);
}
}
if (result.isEmpty() && !multiple) {
// Consider self references as a final pass...
// but in the case of a dependency collection, not the very same bean itself.
for (String candidate : candidateNames) {
if (isSelfReference(beanName, candidate) &&
(!(descriptor instanceof MultiElementDescriptor) || !beanName.equals(candidate)) &&
isAutowireCandidate(candidate, fallbackDescriptor)) {
addCandidateEntry(result, candidate, descriptor, requiredType);
}
}
}
}
return result;
        void addCandidateEntry(Map<String, Object> candidates, String candidateName,
DependencyDescriptor descriptor, Class<?> requiredType)
          一大段代码
// 这个描述方法会自行解析 bean 实例，这是内部 descriptor 自解析的一个流程
Object beanInstance = descriptor.resolveCandidate(candidateName, requiredType, this);
candidates.put(candidateName, (beanInstance instanceof NullBean ? null : beanInstance));
一大段代码
      成员
        Cache of singleton objects: bean name to bean instance
实例化、注入、初始化完成的 bean 实例，getBean 是期待从这里取的
        Cache of singleton factories: bean name to ObjectFactory.
为实例创建代理的工厂
        Cache of early singleton objects: bean name to bean instance.
完成 instantiation 的实例存在这里
        private final Map<String, Object> singletonObjects
        Map<String, ObjectFactory<?>> singletonFactories
        earlySingletonObjects
    AbstractAutoProxyCreator
      常见方法
        postProcessBeforeInstantiation
          第一处调用 shouldSkip，引出后面的 findCandidateAdvisors
          获取 cacheKey
          扫描 advisedBeans，如果 cacheKey 能扫到这个 cacheKey，就返回 null，而不是返回扫出来的结果。这个缓存存放的是，是否要建议/通知这个 bean 的配置
          如果 bean 是一个 isInfrastructureClass ，则 advisedBeans 里把这个 bean 设置为 False，并返回 null
            Advice
            Pointcut
            Advisor
            AopInfrastructureBean
            this.aspectJAdvisorFactory.isAspect(beanClass)
          // 第一处决定是否要做 proxying
如果 shouldSkip(beanClass, beanName) 为真 ，则 advisedBeans 里把这个 bean 设置为 False，并返回 null
          如果 getCustomTargetSource 不为空，则尝试创建一个 proxy：
注意，此时得到的 TargetSource 是一个对象没错，但不是经过 createBean创造出来的！
            第四处调用引出后面的 findCandidateAdvisors
            把这种类型的bean 加入 targetSourcedBeans 集合
            getAdvicesAndAdvisorsForBean 获取增强的列表
            Object proxy = createProxy(beanClass, beanName, specificInterceptors, targetSource);
proxyFactory只要得到一个实例，就有办法创建一个符合某个接口的 proxy
            往 proxyTypes 放入这个生成的 proxy
            返回这个 proxy
          否则，返回 null
          平凡的 Configurtion 类在这些流程里一般都是 false，不产生任何的 proxy，只在最后返回 null
        postProcessAfterInitialization
          if (bean != null) {
Object cacheKey = getCacheKey(bean.getClass(), beanName);
if (this.earlyProxyReferences.remove(cacheKey) != bean) {
return wrapIfNecessary(bean, beanName, cacheKey);
}
}
return bean;
        wrapIfNecessary
          第二处调用 shouldSkip，引出后面的 findCandidateAdvisors。
这个方法实际上也是我们得到我们proxy bean 的地方
在进到这一步以前，我们得到的bean还是 target，而不是 proxied bean
          if (StringUtils.hasLength(beanName) && this.targetSourcedBeans.contains(beanName)) {
return bean;
}
if (Boolean.FALSE.equals(this.advisedBeans.get(cacheKey))) {
return bean;
}
// 第二处决定是否要 skip proxying
if (isInfrastructureClass(bean.getClass()) || shouldSkip(bean.getClass(), beanName)) {
this.advisedBeans.put(cacheKey, Boolean.FALSE);
return bean;
}
// Create proxy if we have advice.
// 第三处寻求 advisors
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;
        shouldSkip
          AutoProxyUtils.isOriginalInstance
      常见子类
        AbstractAdvisorAutoProxyCreator
          第三处调用引出后面的 findCandidateAdvisors
          getAdvicesAndAdvisorsForBean
            List<Advisor> advisors = findEligibleAdvisors(beanClass, beanName);
if (advisors.isEmpty()) {
return DO_NOT_PROXY;
}
return advisors.toArray();
          findCandidateAdvisors
            Assert.state(this.advisorRetrievalHelper != null, "No BeanFactoryAdvisorRetrievalHelper available");
return this.advisorRetrievalHelper.findAdvisorBeans();
          findEligibleAdvisors
            List<Advisor> candidateAdvisors = findCandidateAdvisors();
List<Advisor> eligibleAdvisors = findAdvisorsThatCanApply(candidateAdvisors, beanClass, beanName);
extendAdvisors(eligibleAdvisors);
if (!eligibleAdvisors.isEmpty()) {
eligibleAdvisors = sortAdvisors(eligibleAdvisors);
}
return eligibleAdvisors;
        AspectJAwareAdvisorAutoProxyCreator
          shouldSkip
            List<Advisor> candidateAdvisors = findCandidateAdvisors();
for (Advisor advisor : candidateAdvisors) {
if (advisor instanceof AspectJPointcutAdvisor &&
((AspectJPointcutAdvisor) advisor).getAspectName().equals(beanName)) {
// 如果发现本 bean 在全部的 advisor列表里，而且本bean 是 AspectJPointcutAdvisor
// 为了确定本 bean 是否一个advisor而要获取全部的 advisor，是这个设计最吊诡的地方
return true;
}
}
            // 在这里使用 AopUtils 来判定，很容易得到一个结论，这个 name 是否指向一个 original instance，如果是就会返回 true。但一般 springConfiguration在这里就会返回 false
return super.shouldSkip(beanClass, beanName);
        AnnotationAwareAspectJAutoProxyCreator
通常我们看到的 ProxyCreator的实例是这个类
          这是可能获取嵌套 advisor的地方
          findCandidateAdvisors
            // Add all the Spring advisors found according to superclass rules.
List<Advisor> advisors = super.findCandidateAdvisors();
// Build Advisors for all AspectJ aspects in the bean factory.
if (this.aspectJAdvisorsBuilder != null) {
// 生成全部的 aspect
advisors.addAll(this.aspectJAdvisorsBuilder.buildAspectJAdvisors());
}
return advisors;
              BeanFactoryAdvisorRetrievalHelper
                return this.advisorRetrievalHelper.findAdvisorBeans();
                  获取全部的 advisorNames
                  如果当前的 bean inSingletonCreation 或者 prototypeCreation
查看DefaultSingletonBeanRegistry 的 singletonsCurrentlyInCreation 和 AbstractBeanFactory 的 prototypesCurrentlyInCreation
就放弃这个 bean
                  否则：
advisors.add(this.beanFactory.getBean(name, Advisor.class));
创建不成也不要紧，吞掉这个异常再继续下一个 advisorName
    BeanPostProcessor
      方法
        postProcessBeforeInitialization
        postProcessAfterInitialization
      子类型
        @PostConstruct 和 @Predestroy 由这个后处理器处理
        InitDestroyAnnotationBeanPostProcessor
        InstantiationAwareBeanPostProcessor
          常见类型
            主要注册带有 @WebServiceRef， @Resource，@EJB 注解的属性
            在createBean 以前，尝试 resolveBeforeInstantiation，会用这个bean直接创建代理
            主要解决 带有 @Autowired，@Value，@Lookup，@Inject 注解的属性
            ConfigurationClassPostProcessor$ImportAwareBeanPostProcessor
            CommonAnnotationBeanPostProcessor
              field 注入就看这一个方法了
              postProcessProperties
                InjectionMetadata metadata = findResourceMetadata(beanName, bean.getClass(), pvs);
                metadata.inject(bean, beanName, pvs);
                return pvs;
              getResourceToInject
                // lazy的成员走第一分支，普通的成员走第二分支
return (this.lazyLookup ? buildLazyResourceProxy(this, requestingBeanName) :
getResource(this, requestingBeanName));
              buildLazyResourceProxy
              getResource(LookupElement element, @Nullable String requestingBeanName) // 第一个参数就是成员，如果成员变量叫env，element.mappedName 就是 env，而 requestingBeanName 则是外部 bean
                return autowireResource(this.resourceFactory, element, requestingBeanName);
              autowireResource
                先把工厂转成 AutowireCapableBeanFactory
                  DependencyDescriptor descriptor = element.getDependencyDescriptor();
// 表明了 lookupType/declaringClass/fieldName/eager/反射的 Field
                  if (this.fallbackToDefaultTypeMatch && element.isDefaultName && !factory.containsBean(name)
                    resource = beanFactory.resolveDependency(descriptor, requestingBeanName, autowiredBeanNames, null);
                再把工厂转成 ConfigurableBeanFactory
              产生的额外基类
                CustomExecutorServiceAnnotationBeanPostProcessor
                  方法
                    postProcessProperties
这个方法的扩展思路有两步：
1. 根据注解逐步构造 metadata
2. 调用metadata 的inject，当然metadata 为了inject 自己也实现了很多东西
                      // pvs 的用处在这里
InjectionMetadata metadata = findExecutorMetadata(beanName, bean.getClass(), pvs);
try {
// 这里的注入就是我们要做的事情
metadata.inject(bean, beanName, pvs);
} catch (Throwable ex) {
throw new BeanCreationException(beanName, "Injection of custom executor service dependencies failed", ex);
}
// 然后 as-is 地返回，就行了
return pvs;
                    findExecutorMetadata
重要：覆盖这一步，可以得到待注入的对象
                      private InjectionMetadata findExecutorMetadata(String beanName, final Class<?> clazz, @Nullable PropertyValues pvs) {
/*
* 生成 cache key，如果 beanName 不是空字符串，则使用 beanName作为 key，否则使用 clazz 的名称
*/
String cacheKey = (StringUtils.hasLength(beanName) ? beanName : clazz.getName());
// double-check 的变种，先用最小的锁快速校验 concurrent map。这是在本处理器内内置了一个 ConcurrentHashMap，然后每次查找前先搜索这个map
InjectionMetadata metadata = this.injectionMetadataCache.get(cacheKey);
// 如果找到了，先检查这个metaData是不是需要刷新（其实在 Spring里，初始化经常表达为刷新）
if (InjectionMetadata.needsRefresh(metadata, clazz)) {
synchronized (this.injectionMetadataCache) {
metadata = this.injectionMetadataCache.get(cacheKey);
// 校验要注入的 metadata 是否为空，且校验是不是已知的 metadata 的目标 class 不是 clazz
if (InjectionMetadata.needsRefresh(metadata, clazz)) {
if (metadata != null) {
// 如果需要刷新，先清空 pvs
metadata.clear(pvs);
}
// 一旦确认需要刷新待注入的元数据，就从 0 开始构建元数据
metadata = buildExecutorMetadata(clazz);
// 在锁里面再把这个元数据重新置回去，因为在锁里，所以不需要使用 putIfAbsent
this.injectionMetadataCache.put(cacheKey, metadata);
}
}
}
return metadata;
}
                    buildExecutorMetadata
                      // 首先扫描是否存在目标注解
if (!AnnotationUtils.isCandidateClass(clazz, Arrays.asList(CustomExecutorService.class))) {
return InjectionMetadata.EMPTY;
}
// 然后把所有反射成员都封装进一个元素里，把元素归一到链表上。这些 java 元素本身都是 Member 或者 AnnotatedMember
List<InjectionMetadata.InjectedElement> elements = new ArrayList<>();
Class<?> targetClass = clazz;
// 这就相当于实现了自定义的 @Autorwired 了
do {
final LinkedList<InjectionMetadata.InjectedElement> currElements = new LinkedList<>();
ReflectionUtils.doWithLocalFields(targetClass, field -> {
if (field.isAnnotationPresent(CustomExecutorService.class)) {
if (Modifier.isStatic(field.getModifiers())) {
throw new IllegalStateException("CustomExecutorService annotations are not supported on static fields");
}
currElements.add(new ExecutorElement(field, field, null));
}
});
ReflectionUtils.doWithLocalMethods(targetClass, method -> {
Method bridgedMethod = BridgeMethodResolver.findBridgedMethod(method);
if (!BridgeMethodResolver.isVisibilityBridgeMethodPair(method, bridgedMethod)) {
return;
}
if ((bridgedMethod.isAnnotationPresent(CustomExecutorService.class)) &&
method.equals(ClassUtils.getMostSpecificMethod(method, clazz))) {
if (Modifier.isStatic(method.getModifiers())) {
throw new IllegalStateException("CustomExecutorService annotations are not supported on static methods");
}
if (method.getParameterCount() != 1) {
throw new IllegalStateException("CustomExecutorService annotation requires a single-arg method: " + method);
}
PropertyDescriptor pd = BeanUtils.findPropertyForMethod(bridgedMethod, clazz);
currElements.add(new ExecutorElement(method, bridgedMethod, pd));
}
});
// 这里要注意了， 这里是 后面的插在前面，每次插入都是从 index =0 开始插入
elements.addAll(0, currElements);
targetClass = targetClass.getSuperclass();
} while (targetClass != null && targetClass != Object.class);
return InjectionMetadata.forElements(elements, clazz);
                  内部类
                    ExecutorElement
                      ExecutorElement(Member member, AnnotatedElement annotatedElement, @Nullable PropertyDescriptor propertyDescriptor) {
super(member, propertyDescriptor);
CustomExecutorService annotation = annotatedElement.getAnnotation(CustomExecutorService.class);
Class<?> resourceType = ExecutorService.class;
if (annotation != null) {
constructExecutorService(annotation, resourceType);
}
}
                      /**
* 获取要被注入的值
*
* @param target 目标 bean
* @param requestingBeanName 目标的 bean name，不是线程池的 id，而是目标的 bean name！
* @return 获取要被注入的值
*/
@Override
protected Object getResourceToInject(Object target, @Nullable String requestingBeanName) {
// 重要：实现注入的灵魂之一
return this.executorService;
}
            AutowiredAnnotationBeanPostProcessor
            AnnotationAwareAspectJAutoProxyCreator
          方法
            常见的 field 注入就看这个方法
            postProcessBeforeInstantiation
              执行完返回对象
            postProcessAfterInstantiation
              这个方法返回true 才执行真正 populate，所以这是一个完美的执行自定义注入，然后返回 false 的地方，让 Spring 不再执行注入的地方
            postProcessProperties
            postProcessPropertyValues
        SmartInstantiationAwareBeanPostProcessor
    InjectionMetadata
      inject
        Collection<InjectedElement> checkedElements = this.checkedElements;
Collection<InjectedElement> elementsToIterate = (checkedElements != null ? checkedElements : this.injectedElements);
if (!elementsToIterate.isEmpty()) {
for (InjectedElement element : elementsToIterate) {
element.inject(target, beanName, pvs);
}
}
    InjectedElement
      inject
        如果是 field
Field field = (Field) this.member;
ReflectionUtils.makeAccessible(field);
// 内部有个工厂逐级 resolveDependency，找到就返回，在这一步就直接反射 fieldSet就完了，不需要，也无法经过任何其他钩子了
field.set(target, getResourceToInject(target, requestingBeanName));
        否则假定是方法
if (checkPropertySkipping(pvs)) {
return;
}
try {
Method method = (Method) this.member;
ReflectionUtils.makeAccessible(method);
method.invoke(target, getResourceToInject(target, requestingBeanName));
} catch (InvocationTargetException ex) {
throw ex.getTargetException();
}
      getResourceToInject
    DependencyDescriptor
      Object resolveCandidate(String beanName, Class<?> requiredType, BeanFactory beanFactory)
        return beanFactory.getBean(beanName);
    通常 SecurityManager 是不设置的，设置了就会要求 doPrivileged
    这里我们可以看到，合成 bean 是不会被 BeanPostProcessor 的 before/after initialization 方法处理的
  销毁 bean
    实际上所有的 Disposable 类型不是裸类型呗调用的，而是被装进适配器里
    AbstractApplicationContext
      方法
        destroyBeans()
          getBeanFactory().destroySingletons()
      子类型
        AnnotationConfigServletWebApplicationContext
    DefaultListableBeanFactory
      destroySingletons()
        super.destroySingletons();
updateManualSingletonNames(Set::clear, set -> !set.isEmpty());
clearByTypeCache();
      destroySingleton
        super.destroySingleton(beanName);
removeManualSingletonName(beanName);
clearByTypeCache();
    DefaultSingletonBeanRegistry
      方法
        destroySingletons
          if (logger.isTraceEnabled()) {
logger.trace("Destroying singletons in " + this);
}
synchronized (this.singletonObjects) {
this.singletonsCurrentlyInDestruction = true;
}
String[] disposableBeanNames;
synchronized (this.disposableBeans) {
disposableBeanNames = StringUtils.toStringArray(this.disposableBeans.keySet());
}
for (int i = disposableBeanNames.length - 1; i >= 0; i--) {
destroySingleton(disposableBeanNames[i]);
}
this.containedBeanMap.clear();
this.dependentBeanMap.clear();
this.dependenciesForBeanMap.clear();
clearSingletonCache();
        destroySingleton
          // Remove a registered singleton of the given name, if any.
removeSingleton(beanName);
          // Destroy the corresponding DisposableBean instance.
DisposableBean disposableBean;
synchronized (this.disposableBeans) {
// 这里必定转化得成功，总是能用 remove 特定类型map的方法得到可转型的实例，因为remove的返回值是固定类型的
disposableBean = (DisposableBean) this.disposableBeans.remove(beanName);
}
          destroyBean(beanName, disposableBean);
        removeSingleton(beanName)
          synchronized (this.singletonObjects) {
this.singletonObjects.remove(beanName);
this.singletonFactories.remove(beanName);
this.earlySingletonObjects.remove(beanName);
this.registeredSingletons.remove(beanName);
}
        destroyBean(beanName, disposableBean);
          // Trigger destruction of dependent beans first...
Set<String> dependencies;
synchronized (this.dependentBeanMap) {
// Within full synchronization in order to guarantee a disconnected Set
// 这把锁和这个注释是很有用的设计模式，使用 sync 来断联列表可以防止部分发布？
dependencies = this.dependentBeanMap.remove(beanName);
}
用 remove 方法取出所有的依赖集 depSet
          if (dependencies != null) {
if (logger.isTraceEnabled()) {
logger.trace("Retrieved dependent beans for bean '" + beanName + "': " + dependencies);
}
for (String dependentBeanName : dependencies) {
destroySingleton(dependentBeanName);
}
}
逐一销毁依赖
          // Actually destroy the bean now...
if (bean != null) {
// 不一定能转成 disposal bean，但如果能转进来，则在这里调用 destroy 方法
bean.destroy();
}
          Set<String> containedBeans;
synchronized (this.containedBeanMap) {
// Within full synchronization in order to guarantee a disconnected Set
containedBeans = this.containedBeanMap.remove(beanName);
}
if (containedBeans != null) {
for (String containedBeanName : containedBeans) {
destroySingleton(containedBeanName);
}
}
递归地销毁上层依赖，如何解决重复销毁问题？
          // Remove destroyed bean from other beans' dependencies.
synchronized (this.dependentBeanMap) {
for (Iterator<Map.Entry<String, Set<String>>> it = this.dependentBeanMap.entrySet().iterator(); it.hasNext();) {
Map.Entry<String, Set<String>> entry = it.next();
Set<String> dependenciesToClean = entry.getValue();
dependenciesToClean.remove(beanName);
if (dependenciesToClean.isEmpty()) {
it.remove();
}
}
}
本 bean 可能会出现在其他bean的 dep map 的 set 里，所以要去掉 set 里的内容
          // Remove destroyed bean's prepared dependency information.
this.dependenciesForBeanMap.remove(beanName);
    DisposableBeanAdapter
      destroy()
        if (!CollectionUtils.isEmpty(this.beanPostProcessors)) {
// 这是 Disposable 类型的一种隐藏处置方法，至少隐藏了一个 InitDestroyAnnotationBeanPostProcessor 的子类实例，通常是 CommonAnnotationBeanPostProcessor 的后处理方法，来调用 @Predestroy 这个钩子
for (DestructionAwareBeanPostProcessor processor : this.beanPostProcessors) {
processor.postProcessBeforeDestruction(this.bean, this.beanName);
}
}
if (this.invokeDisposableBean) {
if (logger.isTraceEnabled()) {
logger.trace("Invoking destroy() on bean with name '" + this.beanName + "'");
}
try {
if (System.getSecurityManager() != null) {
AccessController.doPrivileged((PrivilegedExceptionAction<Object>) () -> {
((DisposableBean) this.bean).destroy();
return null;
}, this.acc);
}
else {
// 调用接口方法在这里
((DisposableBean) this.bean).destroy();
}
} catch (Throwable ex) {
String msg = "Invocation of destroy method failed on bean with name '" + this.beanName + "'";
if (logger.isDebugEnabled()) {
logger.warn(msg, ex);
}
else {
logger.warn(msg + ": " + ex);
}
}
}
if (this.invokeAutoCloseable) {
if (logger.isTraceEnabled()) {
logger.trace("Invoking close() on bean with name '" + this.beanName + "'");
}
try {
if (System.getSecurityManager() != null) {
AccessController.doPrivileged((PrivilegedExceptionAction<Object>) () -> {
((AutoCloseable) this.bean).close();
return null;
}, this.acc);
}
else {
// 一个容易被遗忘的关闭钩子
((AutoCloseable) this.bean).close();
}
}
catch (Throwable ex) {
String msg = "Invocation of close method failed on bean with name '" + this.beanName + "'";
if (logger.isDebugEnabled()) {
logger.warn(msg, ex);
} else {
logger.warn(msg + ": " + ex);
}
}
}
else if (this.destroyMethod != null) {
// 自定义方法在最外围
invokeCustomDestroyMethod(this.destroyMethod);
} else if (this.destroyMethodName != null) {
Method destroyMethod = determineDestroyMethod(this.destroyMethodName);
if (destroyMethod != null) {
invokeCustomDestroyMethod(ClassUtils.getInterfaceMethodIfPossible(destroyMethod, this.bean.getClass()));
}
}