Spring源码解析(六)-Bean的实例化流程(下)

接着上一小节的内容继续，从N313的this.populateBean(beanName, mbd, instanceWrapper)方法调用继续讲解。

AbstractAutowireCapableBeanFactory 863 N342
protected void populateBean(String beanName, RootBeanDefinition mbd, @Nullable BeanWrapper bw) {
        if (bw == null) {
            if (mbd.hasPropertyValues()) {
                throw new BeanCreationException(mbd.getResourceDescription(), beanName, "Cannot apply property values to null instance");
            }
        } else {
            boolean continueWithPropertyPopulation = true;
            if (!mbd.isSynthetic() && this.hasInstantiationAwareBeanPostProcessors()) {
                Iterator var5 = this.getBeanPostProcessors().iterator();

                while(var5.hasNext()) {
                    BeanPostProcessor bp = (BeanPostProcessor)var5.next();
                    if (bp instanceof InstantiationAwareBeanPostProcessor) {
                        InstantiationAwareBeanPostProcessor ibp = (InstantiationAwareBeanPostProcessor)bp;
                        if (!ibp.postProcessAfterInstantiation(bw.getWrappedInstance(), beanName)) {
                            continueWithPropertyPopulation = false;
                            break;
                        }
                    }
                }
            }

            if (continueWithPropertyPopulation) {
                PropertyValues pvs = mbd.hasPropertyValues() ? mbd.getPropertyValues() : null;
                if (mbd.getResolvedAutowireMode() == 1 || mbd.getResolvedAutowireMode() == 2) {
                    MutablePropertyValues newPvs = new MutablePropertyValues((PropertyValues)pvs);
                    if (mbd.getResolvedAutowireMode() == 1) {
                        this.autowireByName(beanName, mbd, bw, newPvs);
                    }

                    if (mbd.getResolvedAutowireMode() == 2) {
                        this.autowireByType(beanName, mbd, bw, newPvs);
                    }

                    pvs = newPvs;
                }

                boolean hasInstAwareBpps = this.hasInstantiationAwareBeanPostProcessors();
                boolean needsDepCheck = mbd.getDependencyCheck() != 0;
                PropertyDescriptor[] filteredPds = null;
                if (hasInstAwareBpps) {
                    if (pvs == null) {
                        pvs = mbd.getPropertyValues();
                    }

                    Iterator var9 = this.getBeanPostProcessors().iterator();

                    while(var9.hasNext()) {
                        BeanPostProcessor bp = (BeanPostProcessor)var9.next();
                        if (bp instanceof InstantiationAwareBeanPostProcessor) {
                            InstantiationAwareBeanPostProcessor ibp = (InstantiationAwareBeanPostProcessor)bp;
                            //N343   依赖注入过程，@Autowired的支持
                            PropertyValues pvsToUse = ibp.postProcessProperties((PropertyValues)pvs, bw.getWrappedInstance(), beanName);
                            if (pvsToUse == null) {
                                if (filteredPds == null) {
                                    filteredPds = this.filterPropertyDescriptorsForDependencyCheck(bw, mbd.allowCaching);
                                }
							
                                pvsToUse = ibp.postProcessPropertyValues((PropertyValues)pvs, filteredPds, bw.getWrappedInstance(), beanName);
                                if (pvsToUse == null) {
                                    return;
                                }
                            }

                            pvs = pvsToUse;
                        }
                    }
                }

                if (needsDepCheck) {
                    if (filteredPds == null) {
                        filteredPds = this.filterPropertyDescriptorsForDependencyCheck(bw, mbd.allowCaching);
                    }

                    this.checkDependencies(beanName, mbd, filteredPds, (PropertyValues)pvs);
                }

                if (pvs != null) {
                    //这个地方就是xml的<autowired>起作用的地方
                    this.applyPropertyValues(beanName, mbd, bw, (PropertyValues)pvs);
                }

            }
        }
    }

AutowiredAnnotationBeanPostProcessor 247 N343
public PropertyValues postProcessProperties(PropertyValues pvs, Object bean, String beanName) {
    	//N336  这里进入会从缓存中拿去之前已经收集好的InjectionMetadata
        InjectionMetadata metadata = this.findAutowiringMetadata(beanName, bean.getClass(), pvs);
		
        try {
            //344  拿到metadate后开始遍历并且执行相应逻辑
            metadata.inject(bean, beanName, pvs);
            return pvs;
        } catch (BeanCreationException var6) {
            throw var6;
        } catch (Throwable var7) {
            throw new BeanCreationException(beanName, "Injection of autowired dependencies failed", var7);
        }
    }

InjectionMetadata 56 N344
public void inject(Object target, @Nullable String beanName, @Nullable PropertyValues pvs) throws Throwable {
    	//在InjectionMetadata中已经存好了InjectedElement集合，这些集合存的带有@autowired的field或者method
        Collection<InjectionMetadata.InjectedElement> checkedElements = this.checkedElements;
        Collection<InjectionMetadata.InjectedElement> elementsToIterate = checkedElements != null ? checkedElements : this.injectedElements;
        InjectionMetadata.InjectedElement element;
        if (!((Collection)elementsToIterate).isEmpty()) {
            //遍历收集到的集合中的一个个InjectedElement
            //N345和N346  这里有两个实现类
            for(Iterator var6 = ((Collection)elementsToIterate).iterator(); var6.hasNext(); element.inject(target, beanName, pvs)) {
                element = (InjectionMetadata.InjectedElement)var6.next();
                if (logger.isTraceEnabled()) {
                    logger.trace("Processing injected element of bean '" + beanName + "': " + element);
                }
            }
        }

    }

AutowiredAnnotationBeanPostProcessor 536 N345
protected void inject(Object bean, @Nullable String beanName, @Nullable PropertyValues pvs) throws Throwable {
            Field field = (Field)this.member;
            Object value;
            if (this.cached) {
                value = AutowiredAnnotationBeanPostProcessor.this.resolvedCachedArgument(beanName, this.cachedFieldValue);
            } else {
                DependencyDescriptor desc = new DependencyDescriptor(field, this.required);
                desc.setContainingClass(bean.getClass());
                Set<String> autowiredBeanNames = new LinkedHashSet(1);
                Assert.state(AutowiredAnnotationBeanPostProcessor.this.beanFactory != null, "No BeanFactory available");
                TypeConverter typeConverter = AutowiredAnnotationBeanPostProcessor.this.beanFactory.getTypeConverter();

                try {
                    //N347   这里拿到需要注入的值，而spring获取引用类型的值只有一种方法，调用Factory.getBean()
                    value = AutowiredAnnotationBeanPostProcessor.this.beanFactory.resolveDependency(desc, beanName, autowiredBeanNames, typeConverter);
                } catch (BeansException var12) {
                    throw new UnsatisfiedDependencyException((String)null, beanName, new InjectionPoint(field), var12);
                }

                synchronized(this) {
                    if (!this.cached) {
                        if (value == null && !this.required) {
                            this.cachedFieldValue = null;
                        } else {
                            this.cachedFieldValue = desc;
                            AutowiredAnnotationBeanPostProcessor.this.registerDependentBeans(beanName, autowiredBeanNames);
                            if (autowiredBeanNames.size() == 1) {
                                String autowiredBeanName = (String)autowiredBeanNames.iterator().next();
                                if (AutowiredAnnotationBeanPostProcessor.this.beanFactory.containsBean(autowiredBeanName) && AutowiredAnnotationBeanPostProcessor.this.beanFactory.isTypeMatch(autowiredBeanName, field.getType())) {
                                    this.cachedFieldValue = new AutowiredAnnotationBeanPostProcessor.ShortcutDependencyDescriptor(desc, autowiredBeanName, field.getType());
                                }
                            }
                        }

                        this.cached = true;
                    }
                }
            }

            if (value != null) {
                //前面一大段获取到了需要注入的属性值，这里就反射注入值
                ReflectionUtils.makeAccessible(field);
                field.set(bean, value);
            }

        }

AutowiredAnnotationBeanPostProcessor 436 N346
protected void inject(Object bean, @Nullable String beanName, @Nullable PropertyValues pvs) throws Throwable {
            if (!this.checkPropertySkipping(pvs)) {
                Method method = (Method)this.member;
                Object[] arguments;
                if (this.cached) {
                    arguments = this.resolveCachedArguments(beanName);
                } else {
                    Class<?>[] paramTypes = method.getParameterTypes();
                    arguments = new Object[paramTypes.length];
                    DependencyDescriptor[] descriptors = new DependencyDescriptor[paramTypes.length];
                    Set<String> autowiredBeans = new LinkedHashSet(paramTypes.length);
                    Assert.state(AutowiredAnnotationBeanPostProcessor.this.beanFactory != null, "No BeanFactory available");
                    TypeConverter typeConverter = AutowiredAnnotationBeanPostProcessor.this.beanFactory.getTypeConverter();

                    for(int i = 0; i < arguments.length; ++i) {
                        MethodParameter methodParam = new MethodParameter(method, i);
                        DependencyDescriptor currDesc = new DependencyDescriptor(methodParam, this.required);
                        currDesc.setContainingClass(bean.getClass());
                        descriptors[i] = currDesc;

                        try {
                            //347  spring获取引用类型的值只有一种方法，调用Factory.getBean()。这个方法到最后会调用Factory.getBean()拿到实例 
                            Object arg = AutowiredAnnotationBeanPostProcessor.this.beanFactory.resolveDependency(currDesc, beanName, autowiredBeans, typeConverter);
                            if (arg == null && !this.required) {
                                arguments = null;
                                break;
                            }

                            arguments[i] = arg;
                        } catch (BeansException var18) {
                            throw new UnsatisfiedDependencyException((String)null, beanName, new InjectionPoint(methodParam), var18);
                        }
                    }

                    synchronized(this) {
                        if (!this.cached) {
                            if (arguments != null) {
                                Object[] cachedMethodArguments = new Object[paramTypes.length];
                                System.arraycopy(descriptors, 0, cachedMethodArguments, 0, arguments.length);
                                AutowiredAnnotationBeanPostProcessor.this.registerDependentBeans(beanName, autowiredBeans);
                                if (autowiredBeans.size() == paramTypes.length) {
                                    Iterator<String> it = autowiredBeans.iterator();

                                    for(int ix = 0; ix < paramTypes.length; ++ix) {
                                        String autowiredBeanName = (String)it.next();
                                        if (AutowiredAnnotationBeanPostProcessor.this.beanFactory.containsBean(autowiredBeanName) && AutowiredAnnotationBeanPostProcessor.this.beanFactory.isTypeMatch(autowiredBeanName, paramTypes[ix])) {
                                            cachedMethodArguments[ix] = new AutowiredAnnotationBeanPostProcessor.ShortcutDependencyDescriptor(descriptors[ix], autowiredBeanName, paramTypes[ix]);
                                        }
                                    }
                                }

                                this.cachedMethodArguments = cachedMethodArguments;
                            } else {
                                this.cachedMethodArguments = null;
                            }

                            this.cached = true;
                        }
                    }
                }

                if (arguments != null) {
                    try {
                        //通过上面一大堆代码拿到了方法的参数实例，通过反射调用执行此方法
                        ReflectionUtils.makeAccessible(method);
                        method.invoke(bean, arguments);
                    } catch (InvocationTargetException var16) {
                        throw var16.getTargetException();
                    }
                }

            }
        }

DefaultListableBeanFactory 907 N347
public Object resolveDependency(DependencyDescriptor descriptor, @Nullable String requestingBeanName, @Nullable Set<String> autowiredBeanNames, @Nullable TypeConverter typeConverter) throws BeansException {
        descriptor.initParameterNameDiscovery(this.getParameterNameDiscoverer());
        if (Optional.class == descriptor.getDependencyType()) {
            return this.createOptionalDependency(descriptor, requestingBeanName);
        } else if (ObjectFactory.class != descriptor.getDependencyType() && ObjectProvider.class != descriptor.getDependencyType()) {
            if (javaxInjectProviderClass == descriptor.getDependencyType()) {
                return (new DefaultListableBeanFactory.Jsr330Factory()).createDependencyProvider(descriptor, requestingBeanName);
            } else {
                Object result = this.getAutowireCandidateResolver().getLazyResolutionProxyIfNecessary(descriptor, requestingBeanName);
                if (result == null) {
                    //N348  继续往里找肯定有getBean方法
                    result = this.doResolveDependency(descriptor, requestingBeanName, autowiredBeanNames, typeConverter);
                }

                return result;
            }
        } else {
            return new DefaultListableBeanFactory.DependencyObjectProvider(descriptor, requestingBeanName);
        }
    }

DefaultListableBeanFactory 928 N348
public Object doResolveDependency(DependencyDescriptor descriptor, @Nullable String beanName, @Nullable Set<String> autowiredBeanNames, @Nullable TypeConverter typeConverter) throws BeansException {
        InjectionPoint previousInjectionPoint = ConstructorResolver.setCurrentInjectionPoint(descriptor);

        Object var14;
        try {
            Object shortcut = descriptor.resolveShortcut(this);
            if (shortcut != null) {
                Object var18 = shortcut;
                return var18;
            }

            Class<?> type = descriptor.getDependencyType();
            Object value = this.getAutowireCandidateResolver().getSuggestedValue(descriptor);
            Object var21;
            if (value != null) {
                if (value instanceof String) {
                    String strVal = this.resolveEmbeddedValue((String)value);
                    BeanDefinition bd = beanName != null && this.containsBean(beanName) ? this.getMergedBeanDefinition(beanName) : null;
                    value = this.evaluateBeanDefinitionString(strVal, bd);
                }

                TypeConverter converter = typeConverter != null ? typeConverter : this.getTypeConverter();
                var21 = descriptor.getField() != null ? converter.convertIfNecessary(value, type, descriptor.getField()) : converter.convertIfNecessary(value, type, descriptor.getMethodParameter());
                return var21;
            }

            Object multipleBeans = this.resolveMultipleBeans(descriptor, beanName, autowiredBeanNames, typeConverter);
            if (multipleBeans != null) {
                var21 = multipleBeans;
                return var21;
            }

            Map<String, Object> matchingBeans = this.findAutowireCandidates(beanName, type, descriptor);
            String autowiredBeanName;
            if (matchingBeans.isEmpty()) {
                if (this.isRequired(descriptor)) {
                    this.raiseNoMatchingBeanFound(type, descriptor.getResolvableType(), descriptor);
                }

                autowiredBeanName = null;
                return autowiredBeanName;
            }

            Object instanceCandidate;
            Object result;
            if (matchingBeans.size() > 1) {
                autowiredBeanName = this.determineAutowireCandidate(matchingBeans, descriptor);
                if (autowiredBeanName == null) {
                    if (this.isRequired(descriptor) || !this.indicatesMultipleBeans(type)) {
                        result = descriptor.resolveNotUnique(descriptor.getResolvableType(), matchingBeans);
                        return result;
                    }

                    result = null;
                    return result;
                }

                instanceCandidate = matchingBeans.get(autowiredBeanName);
            } else {
                Entry<String, Object> entry = (Entry)matchingBeans.entrySet().iterator().next();
                autowiredBeanName = (String)entry.getKey();
                instanceCandidate = entry.getValue();
            }

            if (autowiredBeanNames != null) {
                autowiredBeanNames.add(autowiredBeanName);
            }

            if (instanceCandidate instanceof Class) {
                //N349  在这里真正拿到了构造函数中依赖的实例
                instanceCandidate = descriptor.resolveCandidate(autowiredBeanName, type, this);
            }

            result = instanceCandidate;
            if (instanceCandidate instanceof NullBean) {
                if (this.isRequired(descriptor)) {
                    this.raiseNoMatchingBeanFound(type, descriptor.getResolvableType(), descriptor);
                }

                result = null;
            }

            if (!ClassUtils.isAssignableValue(type, result)) {
                throw new BeanNotOfRequiredTypeException(autowiredBeanName, type, instanceCandidate.getClass());
            }

            var14 = result;
        } finally {
            ConstructorResolver.setCurrentInjectionPoint(previousInjectionPoint);
        }

        return var14;
    }

DependencyDescriptor 139 N349
public Object resolveCandidate(String beanName, Class<?> requiredType, BeanFactory beanFactory) throws BeansException {
    	//终于找到了beanFactory.getBean(beanName)，就是这里拿到了需要注入的实例
        return beanFactory.getBean(beanName);
    }

AbstractAutowireCapableBeanFactory 1162 N350
protected Object initializeBean(String beanName, Object bean, @Nullable RootBeanDefinition mbd) {
        if (System.getSecurityManager() != null) {
            AccessController.doPrivileged(() -> {
                this.invokeAwareMethods(beanName, bean);
                return null;
            }, this.getAccessControlContext());
        } else {
            //N351   调用Aware方法
            this.invokeAwareMethods(beanName, bean);
        }

        Object wrappedBean = bean;
        if (mbd == null || !mbd.isSynthetic()) {
            //N352   @PostConstruct
            wrappedBean = this.applyBeanPostProcessorsBeforeInitialization(bean, beanName);
        }

        try {
            //N357    InitializingBean接口
            this.invokeInitMethods(beanName, wrappedBean, mbd);
        } catch (Throwable var6) {
            throw new BeanCreationException(mbd != null ? mbd.getResourceDescription() : null, beanName, "Invocation of init method failed", var6);
        }

        if (mbd == null || !mbd.isSynthetic()) {
            //这里请大家记住，因为这个方法调用beanPostProcess是AOP的入口，后面会从这里开始讲解AOP
            //还有另一个入口是在循环依赖的时候，也会专门讲到
            wrappedBean = this.applyBeanPostProcessorsAfterInitialization(wrappedBean, beanName);
        }

        return wrappedBean;
    }

AbstractAutowireCapableBeanFactory 1190 N351
private void invokeAwareMethods(String beanName, Object bean) {
    	//首先判断是不是Aware类型
        if (bean instanceof Aware) {
            //然后判断如果是调用BeanNameAware类型则调用这个接口的实现方法setBeanName
            if (bean instanceof BeanNameAware) {
                ((BeanNameAware)bean).setBeanName(beanName);
            }
			//然后判断如果是调用BeanClassLoaderAware类型则调用这个接口的实现方法setBeanClassLoader
            if (bean instanceof BeanClassLoaderAware) {
                ClassLoader bcl = this.getBeanClassLoader();
                if (bcl != null) {
                    ((BeanClassLoaderAware)bean).setBeanClassLoader(bcl);
                }
            }
			//然后判断如果是调用BeanFactoryAware类型则调用这个接口的实现方法setBeanFactory
            if (bean instanceof BeanFactoryAware) {
                ((BeanFactoryAware)bean).setBeanFactory(this);
            }
        }

    }

AbstractAutowireCapableBeanFactory 246 N352
public Object applyBeanPostProcessorsBeforeInitialization(Object existingBean, String beanName) throws BeansException {
        Object result = existingBean;

        Object current;
        for(Iterator var4 = this.getBeanPostProcessors().iterator(); var4.hasNext(); result = current) {
            BeanPostProcessor processor = (BeanPostProcessor)var4.next();
            //N353  ApplicationContextAwareProcessor
            //N355  InitDestroyAnnotationBeanPostProcessor
            current = processor.postProcessBeforeInitialization(result, beanName);
            if (current == null) {
                return result;
            }
        }

        return result;
    }

ApplicationContextAwareProcessor 34 N353
public Object postProcessBeforeInitialization(Object bean, String beanName) throws BeansException {
        AccessControlContext acc = null;
        if (System.getSecurityManager() != null && (bean instanceof EnvironmentAware || bean instanceof EmbeddedValueResolverAware || bean instanceof ResourceLoaderAware || bean instanceof ApplicationEventPublisherAware || bean instanceof MessageSourceAware || bean instanceof ApplicationContextAware)) {
            acc = this.applicationContext.getBeanFactory().getAccessControlContext();
        }

        if (acc != null) {
            AccessController.doPrivileged(() -> {
                this.invokeAwareInterfaces(bean);
                return null;
            }, acc);
        } else {
            //354   在这里执行主要的业务逻辑，也是对多种不同的Aware的调用
            this.invokeAwareInterfaces(bean);
        }

        return bean;
    }

ApplicationContextAwareProcessor 52 N354
private void invokeAwareInterfaces(Object bean) {
        if (bean instanceof Aware) {
            if (bean instanceof EnvironmentAware) {
                ((EnvironmentAware)bean).setEnvironment(this.applicationContext.getEnvironment());
            }

            if (bean instanceof EmbeddedValueResolverAware) {
                ((EmbeddedValueResolverAware)bean).setEmbeddedValueResolver(this.embeddedValueResolver);
            }

            if (bean instanceof ResourceLoaderAware) {
                ((ResourceLoaderAware)bean).setResourceLoader(this.applicationContext);
            }

            if (bean instanceof ApplicationEventPublisherAware) {
                ((ApplicationEventPublisherAware)bean).setApplicationEventPublisher(this.applicationContext);
            }

            if (bean instanceof MessageSourceAware) {
                ((MessageSourceAware)bean).setMessageSource(this.applicationContext);
            }

            if (bean instanceof ApplicationContextAware) {
                //这个类型是获取到ApplicationContext对象实例
                ((ApplicationContextAware)bean).setApplicationContext(this.applicationContext);
            }
        }

    }

InitDestroyAnnotationBeanPostProcessor 69 N355
public Object postProcessBeforeInitialization(Object bean, String beanName) throws BeansException {
    	//N332   之前运行过一遍是为了收集带有@postConstruct注解的方法，现在就可以直接获取到了
        InitDestroyAnnotationBeanPostProcessor.LifecycleMetadata metadata = this.findLifecycleMetadata(bean.getClass());

        try {
            //N356  调用@PostConstruct注解的方法
            metadata.invokeInitMethods(bean, beanName);
            return bean;
        } catch (InvocationTargetException var5) {
            throw new BeanCreationException(beanName, "Invocation of init method failed", var5.getTargetException());
        } catch (Throwable var6) {
            throw new BeanCreationException(beanName, "Failed to invoke init method", var6);
        }
    }

InitDestroyAnnotationBeanPostProcessor 259 N356   //类似N144接口，@autowired的属性或方法注入
public void invokeInitMethods(Object target, String beanName) throws Throwable {
            Collection<InitDestroyAnnotationBeanPostProcessor.LifecycleElement> checkedInitMethods = this.checkedInitMethods;
            Collection<InitDestroyAnnotationBeanPostProcessor.LifecycleElement> initMethodsToIterate = checkedInitMethods != null ? checkedInitMethods : this.initMethods;
            InitDestroyAnnotationBeanPostProcessor.LifecycleElement element;
            if (!((Collection)initMethodsToIterate).isEmpty()) {
                //遍历集合，反射调用。带@postConstruct注解的方法是没有参数的，所以下面是没有参数的方法反射
                for(Iterator var5 = ((Collection)initMethodsToIterate).iterator(); var5.hasNext(); element.invoke(target)) {
                    element = (InitDestroyAnnotationBeanPostProcessor.LifecycleElement)var5.next();
                    if (InitDestroyAnnotationBeanPostProcessor.this.logger.isTraceEnabled()) {
                        InitDestroyAnnotationBeanPostProcessor.this.logger.trace("Invoking init method on bean '" + beanName + "': " + element.getMethod());
                    }
                }
            }

        }

AbstractAutowireCapableBeanFactory 1210 N357
protected void invokeInitMethods(String beanName, Object bean, @Nullable RootBeanDefinition mbd) throws Throwable {
        boolean isInitializingBean = bean instanceof InitializingBean;
    	//这里是对InitializingBean接口的处理，如果bean继承了该接口，则进入if，调用afterPropertiesSet方法
        if (isInitializingBean && (mbd == null || !mbd.isExternallyManagedInitMethod("afterPropertiesSet"))) {
            if (this.logger.isTraceEnabled()) {
                this.logger.trace("Invoking afterPropertiesSet() on bean with name '" + beanName + "'");
            }

            if (System.getSecurityManager() != null) {
                try {
                    AccessController.doPrivileged(() -> {
                        ((InitializingBean)bean).afterPropertiesSet();
                        return null;
                    }, this.getAccessControlContext());
                } catch (PrivilegedActionException var6) {
                    throw var6.getException();
                }
            } else {
                //这里是对接口实现方法afterPropertiesSet()调用
                ((InitializingBean)bean).afterPropertiesSet();
            }
        }
		//这里是对init-method属性的调用(这个就是xml中的init-method属性)
        if (mbd != null && bean.getClass() != NullBean.class) {
            String initMethodName = mbd.getInitMethodName();
            if (StringUtils.hasLength(initMethodName) && (!isInitializingBean || !"afterPropertiesSet".equals(initMethodName)) && !mbd.isExternallyManagedInitMethod(initMethodName)) {
                this.invokeCustomInitMethod(beanName, bean, mbd);
            }
        }

    }

AbstractBeanFactory 1156 N358
protected void registerDisposableBeanIfNecessary(String beanName, Object bean, RootBeanDefinition mbd) {
        AccessControlContext acc = System.getSecurityManager() != null ? this.getAccessControlContext() : null;
    	//对于多例的实例是没有存入缓存的
        if (!mbd.isPrototype() && this.requiresDestruction(bean, mbd)) {
            //这里是处理单例的
            if (mbd.isSingleton()) {
                //N359  他会将beanName和DisposableBeanAdapter映射到disposableBeans这个LinkedHashMap
                this.registerDisposableBean(beanName, 
                    //N360   现在进入这个对象看看
                    new DisposableBeanAdapter(bean, beanName, mbd, this.getBeanPostProcessors(), acc));
            } else {
                //这里是处理非单例的（思路跟上面差不多的，可以自己探索试试）
                Scope scope = (Scope)this.scopes.get(mbd.getScope());
                if (scope == null) {
                    throw new IllegalStateException("No Scope registered for scope name '" + mbd.getScope() + "'");
                }
                scope.registerDestructionCallback(beanName,
                      new DisposableBeanAdapter(bean, beanName, mbd, this.getBeanPostProcessors(), acc));
            }
        }

    }

DefaultSingletonBeanRegistry 232 N359
public void registerDisposableBean(String beanName, DisposableBean bean) {
     //这个map就是专门存销毁对象的对象，容器销毁之前会循环遍历这个map并调用每个销毁对象的对象
        synchronized(this.disposableBeans) {
            this.disposableBeans.put(beanName, bean);
        }
    }

N360   //这个是DisposableBeanAdapter的构造函数
public DisposableBeanAdapter(Object bean, String beanName, RootBeanDefinition beanDefinition, List<BeanPostProcessor> postProcessors, @Nullable AccessControlContext acc) {
        Assert.notNull(bean, "Disposable bean must not be null");
        this.bean = bean;
        this.beanName = beanName;
    	//这里是判断当前bean是否为DisposableBean的实现类，如果是则设为true
        this.invokeDisposableBean = this.bean instanceof DisposableBean && !beanDefinition.isExternallyManagedDestroyMethod("destroy");
        this.nonPublicAccessAllowed = beanDefinition.isNonPublicAccessAllowed();
        this.acc = acc;
    //这里首先获取到DestroyMethod的方法名字（也就是在xml中的destroy-method属性的值，从beanDefinition中获取）
        String destroyMethodName = this.inferDestroyMethodIfNecessary(bean, beanDefinition);
        if (destroyMethodName != null && (!this.invokeDisposableBean || !"destroy".equals(destroyMethodName)) && !beanDefinition.isExternallyManagedDestroyMethod(destroyMethodName)) {
            //如果bd中有这个属性的值则会进入这里面，将上面局部变量值赋给Adapter的成员变量destroyMethodName
            this.destroyMethodName = destroyMethodName;
            //这里是获取到这个destroyMethodName的方法封装成Method类型的对象
            this.destroyMethod = this.determineDestroyMethod(destroyMethodName);
            if (this.destroyMethod == null) {
                if (beanDefinition.isEnforceDestroyMethod()) {
                    throw new BeanDefinitionValidationException("Could not find a destroy method named '" + destroyMethodName + "' on bean with name '" + beanName + "'");
                }
            } else {
                Class<?>[] paramTypes = this.destroyMethod.getParameterTypes();
                if (paramTypes.length > 1) {
                    throw new BeanDefinitionValidationException("Method '" + destroyMethodName + "' of bean '" + beanName + "' has more than one parameter - not supported as destroy method");
                }

                if (paramTypes.length == 1 && Boolean.TYPE != paramTypes[0]) {
                    throw new BeanDefinitionValidationException("Method '" + destroyMethodName + "' of bean '" + beanName + "' has a non-boolean parameter - not supported as destroy method");
                }
            }
        }
	//这里会循环所有bpp将收集了@PreDestroy的bpp放入到this.beanPostProcessors（应该是只有InitDestroyAnnotationBeanPostProcessor）
        this.beanPostProcessors = this.filterPostProcessors(postProcessors, bean);
    }

N161***
//上面N358-N360之间是对销毁操作的一个规范，而这些操作的规范总该有个地方去调用它，也就是在什么情况下由哪里调用这些操作呢？答案就是有tomcat根据servlet规范在容器销毁前会调用N362的方法
    
//N361--371    容器销毁前bean的销毁过程

N361
public void contextDestroyed(ServletContextEvent event) {
    	//N362
		closeWebApplicationContext(event.getServletContext());
		ContextCleanupListener.cleanupAttributes(event.getServletContext());
	}

ContextLoader 245 N362
public void closeWebApplicationContext(ServletContext servletContext) {
        servletContext.log("Closing Spring root WebApplicationContext");
        boolean var6 = false;

        try {
            var6 = true;
            if (this.context instanceof ConfigurableWebApplicationContext) {
                //363
                ((ConfigurableWebApplicationContext)this.context).close();
                var6 = false;
            } else {
                var6 = false;
            }
        } finally {
            if (var6) {
                ClassLoader ccl = Thread.currentThread().getContextClassLoader();
                if (ccl == ContextLoader.class.getClassLoader()) {
                    currentContext = null;
                } else if (ccl != null) {
                    currentContextPerThread.remove(ccl);
                }

                servletContext.removeAttribute(WebApplicationContext.ROOT_WEB_APPLICATION_CONTEXT_ATTRIBUTE);
            }
        }

        ClassLoader ccl = Thread.currentThread().getContextClassLoader();
        if (ccl == ContextLoader.class.getClassLoader()) {
            currentContext = null;
        } else if (ccl != null) {
            currentContextPerThread.remove(ccl);
        }

        servletContext.removeAttribute(WebApplicationContext.ROOT_WEB_APPLICATION_CONTEXT_ATTRIBUTE);
    }

AbstractApplicationContext 524 N363
public void close() {
        synchronized(this.startupShutdownMonitor) {
            //N364
            this.doClose();
            if (this.shutdownHook != null) {
                try {
                    Runtime.getRuntime().removeShutdownHook(this.shutdownHook);
                } catch (IllegalStateException var4) {
                }
            }

        }
    }

AbstractApplicationContext 537 N364
protected void doClose() {
        if (this.active.get() && this.closed.compareAndSet(false, true)) {
            if (this.logger.isDebugEnabled()) {
                this.logger.debug("Closing " + this);
            }

            LiveBeansView.unregisterApplicationContext(this);

            try {
                this.publishEvent((ApplicationEvent)(new ContextClosedEvent(this)));
            } catch (Throwable var3) {
                this.logger.warn("Exception thrown from ApplicationListener handling ContextClosedEvent", var3);
            }

            if (this.lifecycleProcessor != null) {
                try {
                    this.lifecycleProcessor.onClose();
                } catch (Throwable var2) {
                    this.logger.warn("Exception thrown from LifecycleProcessor on context close", var2);
                }
            }
			//365  这里是处理销毁的逻辑
            this.destroyBeans();
            this.closeBeanFactory();
            this.onClose();
            this.active.set(false);
        }

    }

AbstractApplicationContext 567 N365
protected void destroyBeans() {
    	//N366
        this.getBeanFactory().destroySingletons();
    }

DefaultSingletonBeanRegistry 335 N366
public void destroySingletons() {
        if (this.logger.isTraceEnabled()) {
            this.logger.trace("Destroying singletons in " + this);
        }

        synchronized(this.singletonObjects) {
            this.singletonsCurrentlyInDestruction = true;
        }

        String[] disposableBeanNames;
        synchronized(this.disposableBeans) {
            //这个this.disposableBeans应该很熟悉了，之前每个beanName都映射了一个Adapter到这个容器中。也就是存储了之前收集
            //到该bean销毁方法的adapter对象（N160).
            disposableBeanNames = StringUtils.toStringArray(this.disposableBeans.keySet());
        }
		//循环遍历上面生成的数组，数组元素是所有key
        for(int i = disposableBeanNames.length - 1; i >= 0; --i) {
            //N367  
            this.destroySingleton(disposableBeanNames[i]);
        }

        this.containedBeanMap.clear();
        this.dependentBeanMap.clear();
        this.dependenciesForBeanMap.clear();
        this.clearSingletonCache();
    }

DefaultSingletonBeanRegistry 369 N367
public void destroySingleton(String beanName) {
        this.removeSingleton(beanName);
        DisposableBean disposableBean;
        synchronized(this.disposableBeans) {
            //这里会删除这个bean的销毁adapter在disposableBeans这个容器中，删除的同时会获取到这个adapter
            disposableBean = (DisposableBean)this.disposableBeans.remove(beanName);
        }
		//N368  然后调用一次这个adapter的destroy方法
        this.destroyBean(beanName, disposableBean);
    }

DefaultSingletonBeanRegistry 379 N368
protected void destroyBean(String beanName, @Nullable DisposableBean bean) {
        Set dependencies;
        synchronized(this.dependentBeanMap) {
            dependencies = (Set)this.dependentBeanMap.remove(beanName);
        }

        if (dependencies != null) {
            if (this.logger.isTraceEnabled()) {
                this.logger.trace("Retrieved dependent beans for bean '" + beanName + "': " + dependencies);
            }

            Iterator var4 = dependencies.iterator();

            while(var4.hasNext()) {
                String dependentBeanName = (String)var4.next();
                this.destroySingleton(dependentBeanName);
            }
        }

        if (bean != null) {
            try {
                //N369   这里就调到了最重要的方法，adapter的对象的destroy方法，这个方法是调用之前构造函数收集到的方法来执行销毁操作
                bean.destroy();
            } catch (Throwable var13) {
                if (this.logger.isInfoEnabled()) {
                    this.logger.info("Destroy method on bean with name '" + beanName + "' threw an exception", var13);
                }
            }
        }

        Set containedBeans;
        synchronized(this.containedBeanMap) {
            containedBeans = (Set)this.containedBeanMap.remove(beanName);
        }

        if (containedBeans != null) {
            Iterator var15 = containedBeans.iterator();

            while(var15.hasNext()) {
                String containedBeanName = (String)var15.next();
                this.destroySingleton(containedBeanName);
            }
        }

        synchronized(this.dependentBeanMap) {
            Iterator it = this.dependentBeanMap.entrySet().iterator();

            while(it.hasNext()) {
                Entry<String, Set<String>> entry = (Entry)it.next();
                Set<String> dependenciesToClean = (Set)entry.getValue();
                dependenciesToClean.remove(beanName);
                if (dependenciesToClean.isEmpty()) {
                    it.remove();
                }
            }
        }

        this.dependenciesForBeanMap.remove(beanName);
    }

DisposableBeanAdapter 143 N369
public void destroy() {
    	//首先这里会拿到之前构造函数中处理好了并存到容器中的bp
    	//然后调用postProcessBeforeDestruction方法来调用带有@preDestroy
        if (!CollectionUtils.isEmpty(this.beanPostProcessors)) {
            Iterator var1 = this.beanPostProcessors.iterator();

            while(var1.hasNext()) {
                DestructionAwareBeanPostProcessor processor = (DestructionAwareBeanPostProcessor)var1.next();
                //N370  initDestroyAnnotationBeanPostProcessor这个方法会调用到之前收集好的带有@preDestroy的方法
                processor.postProcessBeforeDestruction(this.bean, this.beanName);
            }
        }
		//这里是判断当前销毁的bean是否实现DisposableBean的接口，在构造函数中已经判断好并用true或false来表示
        if (this.invokeDisposableBean) {
            if (logger.isTraceEnabled()) {
                logger.trace("Invoking destroy() on bean with name '" + this.beanName + "'");
            }

            try {
                if (System.getSecurityManager() != null) {
                    AccessController.doPrivileged(() -> {
                        //如果是实现DisposableBean的接口则会调用实现类中的destroy
                        ((DisposableBean)this.bean).destroy();
                        return null;
                    }, this.acc);
                } else {
                    ((DisposableBean)this.bean).destroy();
                }
            } catch (Throwable var3) {
                String msg = "Invocation of destroy method failed on bean with name '" + this.beanName + "'";
                if (logger.isDebugEnabled()) {
                    logger.info(msg, var3);
                } else {
                    logger.info(msg + ": " + var3);
                }
            }
        }

        if (this.destroyMethod != null) {
            //这里是判断是否存在destory-method属性（xml中），如果存在在构造函数中已经对这个属性收集好了并封装成Method对象
            //然后该方法会先获取参数在通过反射调用，就不细看了，应该都能想明白
            this.invokeCustomDestroyMethod(this.destroyMethod);
        } else if (this.destroyMethodName != null) {
            Method methodToCall = this.determineDestroyMethod(this.destroyMethodName);
            if (methodToCall != null) {
                this.invokeCustomDestroyMethod(methodToCall);
            }
        }

    }

InitDestroyAnnotationBeanPostProcessor 86 N370
public void postProcessBeforeDestruction(Object bean, String beanName) throws BeansException {
    	//N332  之前运行过一遍是为了收集带有@preDestroy注解的方法，现在就可以直接获取到了
        InitDestroyAnnotationBeanPostProcessor.LifecycleMetadata metadata = this.findLifecycleMetadata(bean.getClass());
        try {
            //N371  调用这些带有@preDestroy的方法
            metadata.invokeDestroyMethods(bean, beanName);
        } catch (InvocationTargetException var6) {
            String msg = "Destroy method on bean with name '" + beanName + "' threw an exception";
            if (this.logger.isDebugEnabled()) {
                this.logger.warn(msg, var6.getTargetException());
            } else {
                this.logger.warn(msg + ": " + var6.getTargetException());
            }
        } catch (Throwable var7) {
            this.logger.warn("Failed to invoke destroy method on bean with name '" + beanName + "'", var7);
        }

    }

InitDestroyAnnotationBeanPostProcessor 274 N371
public void invokeDestroyMethods(Object target, String beanName) throws Throwable {
            Collection<InitDestroyAnnotationBeanPostProcessor.LifecycleElement> checkedDestroyMethods = this.checkedDestroyMethods;
            Collection<InitDestroyAnnotationBeanPostProcessor.LifecycleElement> destroyMethodsToUse = checkedDestroyMethods != null ? checkedDestroyMethods : this.destroyMethods;
            InitDestroyAnnotationBeanPostProcessor.LifecycleElement element;
            if (!((Collection)destroyMethodsToUse).isEmpty()) {
                //如果集合不为空，也就是存在带有@preDestroy的方法，循环遍历通过反射调用这些方法
                for(Iterator var5 = ((Collection)destroyMethodsToUse).iterator(); var5.hasNext(); element.invoke(target)) {
                    element = (InitDestroyAnnotationBeanPostProcessor.LifecycleElement)var5.next();
                    if (InitDestroyAnnotationBeanPostProcessor.this.logger.isTraceEnabled()) {
                        InitDestroyAnnotationBeanPostProcessor.this.logger.trace("Invoking destroy method on bean '" + beanName + "': " + element.getMethod());
                    }
                }
            }

        }

至此，整个实例化的大体流程已经完全结束了，Spring专题接下来一小节会是讲解循环依赖的相关源码和场景分析。Spring已经讲了六小节了，有疑问的读者可以在评论区提出来大家讨论一下，笔者一定知无不言。