Spring原理（二）IoC容器的初始化过程之ApplicationContext

妖狐艹你老母 2022-07-16 01:44 281阅读 0赞

上一篇已经介绍了BeanFactory的初始化过程，这一篇介绍一下ApplicationContext的初始化。ApplicationContext有很多实现，这里以常见的FileSystemXmlApplicationContext为例来说明一下ApplicationContext的初始化过程。

1.  启动ApplicationContext  
    以下代码就初始化了一个IoC容器，FileSystemXmlApplicationContext，可以通过getBean的方式得到配置好的bean对象。

FileSystemXmlApplicationContext ctx = new FileSystemXmlApplicationContext("D:/workspace/demo_spring/src/main/resources/applicationContext.xml");
         System.out.println(ctx.getBean("userService"));

下面继续看下构造方法FileSystemXmlApplicationContext 里面具体做了什么操作，方法refresh是整个初始化的关键入口。

public FileSystemXmlApplicationContext(String[] configLocations, boolean refresh, ApplicationContext parent)
                throws BeansException {
    
            super(parent);
            setConfigLocations(configLocations);
            if (refresh) {
                refresh();
            }
        }

可以看到refresh方法里做了很多操作，这里我们大概说明一下，本文侧重于说明初始化的过程，所以对其他的一些细节（比如xml文件的解析等）不做过多讨论。

public void refresh() throws BeansException, IllegalStateException {
            synchronized (this.startupShutdownMonitor) {
                // Prepare this context for refreshing.
                prepareRefresh();
    
                // Tell the subclass to refresh the internal bean factory.
                ConfigurableListableBeanFactory beanFactory = obtainFreshBeanFactory();
    
                // Prepare the bean factory for use in this context.
                prepareBeanFactory(beanFactory);
    
                try {
                    // Allows post-processing of the bean factory in context subclasses.
                    postProcessBeanFactory(beanFactory);
    
                    // Invoke factory processors registered as beans in the context.
                    invokeBeanFactoryPostProcessors(beanFactory);
    
                    // Register bean processors that intercept bean creation.
                    registerBeanPostProcessors(beanFactory);
    
                    // Initialize message source for this context.
                    initMessageSource();
    
                    // Initialize event multicaster for this context.
                    initApplicationEventMulticaster();
    
                    // Initialize other special beans in specific context subclasses.
                    onRefresh();
    
                    // Check for listener beans and register them.
                    registerListeners();
    
                    // Instantiate all remaining (non-lazy-init) singletons.
                    finishBeanFactoryInitialization(beanFactory);
    
                    // Last step: publish corresponding event.
                    finishRefresh();
                }
    
                catch (BeansException ex) {
                    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;
                }
            }
        }

obtainFreshBeanFactory方法的实现类是AbstractApplicationContext，这里使用了模板设计模式，方法refreshBeanFactory()定义在当前类里，作为基本方法，由AbstractApplicationContext的子类AbstractRefreshableApplicationContext实现（当在AbstractRefreshableApplicationContext中调用方法obtainFreshBeanFactory的时候，obtainFreshBeanFactory里的方法refreshBeanFactory实际是调用的实现类AbstractRefreshableApplicationContext的真正的方法。AbstractApplicationContext的实现类不止一个，至于为什么这里说是调用AbstractRefreshableApplicationContext的实现，请查看FileSystemXmlApplicationContext的继承结构）。

protected ConfigurableListableBeanFactory obtainFreshBeanFactory() {
            refreshBeanFactory();
            ConfigurableListableBeanFactory beanFactory = getBeanFactory();
    
            if (logger.isInfoEnabled()) {
                logger.info("Bean factory for application context [" + getId() + "]: " +
                        ObjectUtils.identityToString(beanFactory));
            }
            if (logger.isDebugEnabled()) {
                logger.debug(beanFactory.getBeanDefinitionCount() + " beans defined in " + this);
            }
    
            return beanFactory;
        }

AbstractRereshableApplicationContext类里的实现，这里方法refreshBeanFactory也使用了模板设计模式，基本方法是loadBeanDefinitions，在其子类AbstractXmlApplicationContext中实现。

protected final void refreshBeanFactory() throws BeansException {
            if (hasBeanFactory()) {
                destroyBeans();
                closeBeanFactory();
            }
            try {
                DefaultListableBeanFactory beanFactory = createBeanFactory();
                customizeBeanFactory(beanFactory);
                loadBeanDefinitions(beanFactory);
                synchronized (this.beanFactoryMonitor) {
                    this.beanFactory = beanFactory;
                }
            }
            catch (IOException ex) {
                throw new ApplicationContextException(
                        "I/O error parsing XML document for application context [" + getDisplayName() + "]", ex);
            }
        }

这里直接创建一个DefaultListableBeanFactory的对象并返回，由此可见applicationContext其实是建立在BeanFactory之上的，是对BeanFactory的封装而已，添加了一些特殊的功能。

protected DefaultListableBeanFactory createBeanFactory() {
            return new DefaultListableBeanFactory(getInternalParentBeanFactory());
        }

在方法customizeBeanFactory设置了两个属性，一个是是否允许bean定义的覆盖，一个是是否允许bean的循环引用。

protected void customizeBeanFactory(DefaultListableBeanFactory beanFactory) {
            if (this.allowBeanDefinitionOverriding != null) {
                beanFactory.setAllowBeanDefinitionOverriding(this.allowBeanDefinitionOverriding.booleanValue());
            }
            if (this.allowCircularReferences != null) {
                beanFactory.setAllowCircularReferences(this.allowCircularReferences.booleanValue());
            }
        }

下面是AbstractXmlApplicationContext的方法loadBeanDefinitions的实现。首先创建了一个XmlBeanDefinitionReader对象（有没有发现慢慢的回到的我们之前的BeanFactory的例子），initBeanDefinitionReader在当前类中是个空方法，

protected void loadBeanDefinitions(DefaultListableBeanFactory beanFactory) throws IOException {
            // Create a new XmlBeanDefinitionReader for the given BeanFactory.
            XmlBeanDefinitionReader beanDefinitionReader = new XmlBeanDefinitionReader(beanFactory);
    
            // Configure the bean definition reader with this context's
            // resource loading environment.
            beanDefinitionReader.setResourceLoader(this);
            beanDefinitionReader.setEntityResolver(new ResourceEntityResolver(this));
    
            // Allow a subclass to provide custom initialization of the reader,
            // then proceed with actually loading the bean definitions.
            initBeanDefinitionReader(beanDefinitionReader);
            loadBeanDefinitions(beanDefinitionReader);
        }

方法loadBeanDefinitions的实现如下，至于接下去的调用请参考（一）中的相关内容，不再赘述。

protected void loadBeanDefinitions(XmlBeanDefinitionReader reader) throws BeansException, IOException {
            Resource[] configResources = getConfigResources();
            if (configResources != null) {
                reader.loadBeanDefinitions(configResources);
            }
            String[] configLocations = getConfigLocations();
            if (configLocations != null) {
                reader.loadBeanDefinitions(configLocations);
            }
        }

BeanFactory初始化之后，接下来是方法invokeBeanFactoryPostProcessors，主要作用是执行BeanFactory的后置处理逻辑，beanFactoryPostProcessor的作用是在beanFactory初始化之后提供一个修改的机会。spring已经提供了不少实现，我们自己也可以写一些实现配置在xml中 或者手动调用。

比如我们自定义一个，配置如下：

定义如下：

public class MyBeanFactoryPostProcessor implements BeanFactoryPostProcessor { 
    
        @Override
        public void postProcessBeanFactory(ConfigurableListableBeanFactory beanFactory) throws BeansException {
            System.out.println("调用MyBeanFactoryPostProcessor的postProcessBeanFactory");
            BeanDefinition bd = beanFactory.getBeanDefinition("moneyService");
            MutablePropertyValues pv =  bd.getPropertyValues();  
            if (pv.contains("remark")) {  
                pv.addPropertyValue("remark", "在BeanFactoryPostProcessor中修改之后的备忘信息");  
            }  
        }
    
    }

不管是自定的BeanFactoryPostProcessor还是spring自带的，是怎么被执行的呢？我们继续分析，  
进入方法invokeBeanFactoryPostProcessors，其实现在AbstractApplicationContext中，代码如下：

protected void invokeBeanFactoryPostProcessors(ConfigurableListableBeanFactory beanFactory) {
            PostProcessorRegistrationDelegate.invokeBeanFactoryPostProcessors(beanFactory, getBeanFactoryPostProcessors());
        }

继续追踪到PostProcessorRegistrationDelegate的方法invokeBeanFactoryPostProcessors，  
主要功能是根据BeanFactoryPostProcessor实现的接口不同执行BeanFactoryPostProcessor，这里我们直接看最后一行代码 invokeBeanFactoryPostProcessors(nonOrderedPostProcessors, beanFactory);  
（至于为什么，是因为我跟踪代码时自己实现的一个最普通的BeanFactoryPostProcessor没有实现order之类的接口，所以走的正是这个最后一行的代码分支）。

public static void invokeBeanFactoryPostProcessors(
                ConfigurableListableBeanFactory beanFactory, List<BeanFactoryPostProcessor> beanFactoryPostProcessors) {
    
            // Invoke BeanDefinitionRegistryPostProcessors first, if any.
            Set<String> processedBeans = new HashSet<String>();
    
            if (beanFactory instanceof BeanDefinitionRegistry) {
                BeanDefinitionRegistry registry = (BeanDefinitionRegistry) beanFactory;
                List<BeanFactoryPostProcessor> regularPostProcessors = new LinkedList<BeanFactoryPostProcessor>();
                List<BeanDefinitionRegistryPostProcessor> registryPostProcessors =
                        new LinkedList<BeanDefinitionRegistryPostProcessor>();
    
                for (BeanFactoryPostProcessor postProcessor : beanFactoryPostProcessors) {
                    if (postProcessor instanceof BeanDefinitionRegistryPostProcessor) {
                        BeanDefinitionRegistryPostProcessor registryPostProcessor =
                                (BeanDefinitionRegistryPostProcessor) postProcessor;
                        registryPostProcessor.postProcessBeanDefinitionRegistry(registry);
                        registryPostProcessors.add(registryPostProcessor);
                    }
                    else {
                        regularPostProcessors.add(postProcessor);
                    }
                }
    
                // Do not initialize FactoryBeans here: We need to leave all regular beans
                // uninitialized to let the bean factory post-processors apply to them!
                // Separate between BeanDefinitionRegistryPostProcessors that implement
                // PriorityOrdered, Ordered, and the rest.
                String[] postProcessorNames =
                        beanFactory.getBeanNamesForType(BeanDefinitionRegistryPostProcessor.class, true, false);
    
                // First, invoke the BeanDefinitionRegistryPostProcessors that implement PriorityOrdered.
                List<BeanDefinitionRegistryPostProcessor> priorityOrderedPostProcessors = new ArrayList<BeanDefinitionRegistryPostProcessor>();
                for (String ppName : postProcessorNames) {
                    if (beanFactory.isTypeMatch(ppName, PriorityOrdered.class)) {
                        priorityOrderedPostProcessors.add(beanFactory.getBean(ppName, BeanDefinitionRegistryPostProcessor.class));
                        processedBeans.add(ppName);
                    }
                }
                OrderComparator.sort(priorityOrderedPostProcessors);
                registryPostProcessors.addAll(priorityOrderedPostProcessors);
                invokeBeanDefinitionRegistryPostProcessors(priorityOrderedPostProcessors, registry);
    
                // Next, invoke the BeanDefinitionRegistryPostProcessors that implement Ordered.
                postProcessorNames = beanFactory.getBeanNamesForType(BeanDefinitionRegistryPostProcessor.class, true, false);
                List<BeanDefinitionRegistryPostProcessor> orderedPostProcessors = new ArrayList<BeanDefinitionRegistryPostProcessor>();
                for (String ppName : postProcessorNames) {
                    if (!processedBeans.contains(ppName) && beanFactory.isTypeMatch(ppName, Ordered.class)) {
                        orderedPostProcessors.add(beanFactory.getBean(ppName, BeanDefinitionRegistryPostProcessor.class));
                        processedBeans.add(ppName);
                    }
                }
                OrderComparator.sort(orderedPostProcessors);
                registryPostProcessors.addAll(orderedPostProcessors);
                invokeBeanDefinitionRegistryPostProcessors(orderedPostProcessors, registry);
    
                // Finally, invoke all other BeanDefinitionRegistryPostProcessors until no further ones appear.
                boolean reiterate = true;
                while (reiterate) {
                    reiterate = false;
                    postProcessorNames = beanFactory.getBeanNamesForType(BeanDefinitionRegistryPostProcessor.class, true, false);
                    for (String ppName : postProcessorNames) {
                        if (!processedBeans.contains(ppName)) {
                            BeanDefinitionRegistryPostProcessor pp = beanFactory.getBean(ppName, BeanDefinitionRegistryPostProcessor.class);
                            registryPostProcessors.add(pp);
                            processedBeans.add(ppName);
                            pp.postProcessBeanDefinitionRegistry(registry);
                            reiterate = true;
                        }
                    }
                }
    
                // Now, invoke the postProcessBeanFactory callback of all processors handled so far.
                invokeBeanFactoryPostProcessors(registryPostProcessors, beanFactory);
                invokeBeanFactoryPostProcessors(regularPostProcessors, beanFactory);
            }
    
            else {
                // Invoke factory processors registered with the context instance.
                invokeBeanFactoryPostProcessors(beanFactoryPostProcessors, beanFactory);
            }
    
            // Do not initialize FactoryBeans here: We need to leave all regular beans
            // uninitialized to let the bean factory post-processors apply to them!
            String[] postProcessorNames =
                    beanFactory.getBeanNamesForType(BeanFactoryPostProcessor.class, true, false);
    
            // Separate between BeanFactoryPostProcessors that implement PriorityOrdered,
            // Ordered, and the rest.
            List<BeanFactoryPostProcessor> priorityOrderedPostProcessors = new ArrayList<BeanFactoryPostProcessor>();
            List<String> orderedPostProcessorNames = new ArrayList<String>();
            List<String> nonOrderedPostProcessorNames = new ArrayList<String>();
            for (String ppName : postProcessorNames) {
                if (processedBeans.contains(ppName)) {
                    // skip - already processed in first phase above
                }
                else if (beanFactory.isTypeMatch(ppName, PriorityOrdered.class)) {
                    priorityOrderedPostProcessors.add(beanFactory.getBean(ppName, BeanFactoryPostProcessor.class));
                }
                else if (beanFactory.isTypeMatch(ppName, Ordered.class)) {
                    orderedPostProcessorNames.add(ppName);
                }
                else {
                    nonOrderedPostProcessorNames.add(ppName);
                }
            }
    
            // First, invoke the BeanFactoryPostProcessors that implement PriorityOrdered.
            OrderComparator.sort(priorityOrderedPostProcessors);
            invokeBeanFactoryPostProcessors(priorityOrderedPostProcessors, beanFactory);
    
            // Next, invoke the BeanFactoryPostProcessors that implement Ordered.
            List<BeanFactoryPostProcessor> orderedPostProcessors = new ArrayList<BeanFactoryPostProcessor>();
            for (String postProcessorName : orderedPostProcessorNames) {
                orderedPostProcessors.add(beanFactory.getBean(postProcessorName, BeanFactoryPostProcessor.class));
            }
            OrderComparator.sort(orderedPostProcessors);
            invokeBeanFactoryPostProcessors(orderedPostProcessors, beanFactory);
    
            // Finally, invoke all other BeanFactoryPostProcessors.
            List<BeanFactoryPostProcessor> nonOrderedPostProcessors = new ArrayList<BeanFactoryPostProcessor>();
            for (String postProcessorName : nonOrderedPostProcessorNames) {
                nonOrderedPostProcessors.add(beanFactory.getBean(postProcessorName, BeanFactoryPostProcessor.class));
            }
            invokeBeanFactoryPostProcessors(nonOrderedPostProcessors, beanFactory);
        }

跟踪到方法invokeBeanFactoryPostProcessors，这里会依次执行BeanFactoryPostProcessor 的方法postProcessBeanFactory。方法postProcessBeanFactory正是我们自己实现的情况下继承BeanFactoryPostProcessor需要实现的（spring提供的BeanFactoryPostProcessor已经都实现好了不同的功能，我们直接配置好实用就可以了）。

/** * Invoke the given BeanFactoryPostProcessor beans. */
        private static void invokeBeanFactoryPostProcessors(
                Collection<? extends BeanFactoryPostProcessor> postProcessors, ConfigurableListableBeanFactory beanFactory) {
    
            for (BeanFactoryPostProcessor postProcessor : postProcessors) {
                postProcessor.postProcessBeanFactory(beanFactory);
            }
        }

回到refresh方法，继续往下分析，方法registerBeanPostProcessors作用是注册BeanPostProcessors到BeanFactory中，方法registerBeanPostProcessors的实现在父类AbstractApplicationContext中，  
// Register bean processors that intercept bean creation.  
registerBeanPostProcessors(beanFactory);

protected void registerBeanPostProcessors(ConfigurableListableBeanFactory beanFactory) {
            PostProcessorRegistrationDelegate.registerBeanPostProcessors(beanFactory, this);
        }

由以上代码可知，最终调用的是PostProcessorRegistrationDelegate的方法registerBeanPostProcessors，把BeanPostProcessors注册到BeanFactory中。

public static void registerBeanPostProcessors(
                ConfigurableListableBeanFactory beanFactory, AbstractApplicationContext applicationContext) {
    
            String[] postProcessorNames = beanFactory.getBeanNamesForType(BeanPostProcessor.class, true, false);
    
            // Register BeanPostProcessorChecker that logs an info message when
            // a bean is created during BeanPostProcessor instantiation, i.e. when
            // a bean is not eligible for getting processed by all BeanPostProcessors.
            int beanProcessorTargetCount = beanFactory.getBeanPostProcessorCount() + 1 + postProcessorNames.length;
            beanFactory.addBeanPostProcessor(new BeanPostProcessorChecker(beanFactory, beanProcessorTargetCount));
    
            // Separate between BeanPostProcessors that implement PriorityOrdered,
            // Ordered, and the rest.
            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.
            OrderComparator.sort(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);
                }
            }
            OrderComparator.sort(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.
            OrderComparator.sort(internalPostProcessors);
            registerBeanPostProcessors(beanFactory, internalPostProcessors);
    
            beanFactory.addBeanPostProcessor(new ApplicationListenerDetector(applicationContext));
        }

接下来refresh方法中还有几个方法，我们重点分析一下  
// Instantiate all remaining (non-lazy-init) singletons.  
finishBeanFactoryInitialization(beanFactory);  
其功能是完成余下（前面步骤已实例化的bean除外）所有非延迟初始化的单例bean的实例化

方法finishBeanFactoryInitialization前面一段是设置conversion service，至于conversion service相关的内容后面会专门分析。

protected void finishBeanFactoryInitialization(ConfigurableListableBeanFactory beanFactory) {
            // Initialize conversion service for this context.
            if (beanFactory.containsBean(CONVERSION_SERVICE_BEAN_NAME) &&
                    beanFactory.isTypeMatch(CONVERSION_SERVICE_BEAN_NAME, ConversionService.class)) {
                beanFactory.setConversionService(
                        beanFactory.getBean(CONVERSION_SERVICE_BEAN_NAME, ConversionService.class));
            }
    
            // Initialize LoadTimeWeaverAware beans early to allow for registering their transformers early.
            String[] weaverAwareNames = beanFactory.getBeanNamesForType(LoadTimeWeaverAware.class, false, false);
            for (String weaverAwareName : weaverAwareNames) {
                getBean(weaverAwareName);
            }
    
            // Stop using the temporary ClassLoader for type matching.
            beanFactory.setTempClassLoader(null);
    
            // Allow for caching all bean definition metadata, not expecting further changes.
            beanFactory.freezeConfiguration();
    
            // Instantiate all remaining (non-lazy-init) singletons.
            beanFactory.preInstantiateSingletons();
        }

可以看到方法preInstantiateSingletons中会调用实例化我们配置的所有单例非延迟实例化的bean，主要的功能调用了DefaultListableBeanFactory的父类AbstractBeanFactory的方法getBean，在调用getBean之前会先判断这个bean是不是FactoryBean, FactoryBean要做一些特别处理，后面在分析factoryBeanhe 普通bean的区别时会进一步分析，这里直接分析普通bean的实例化的逻辑。

public void preInstantiateSingletons() throws BeansException {
            if (this.logger.isDebugEnabled()) {
                this.logger.debug("Pre-instantiating singletons in " + this);
            }
    
            // Iterate over a copy to allow for init methods which in turn register new bean definitions.
            // While this may not be part of the regular factory bootstrap, it does otherwise work fine.
            List<String> beanNames = new ArrayList<String>(this.beanDefinitionNames);
    
            // Trigger initialization of all non-lazy singleton beans...
            for (String beanName : beanNames) {
                RootBeanDefinition bd = getMergedLocalBeanDefinition(beanName);
                if (!bd.isAbstract() && bd.isSingleton() && !bd.isLazyInit()) {
                    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 {
                        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->doGetBean, doGetBean方法实在太长就不在这里全部贴出来了，看一下关键代码  
如果是scope是单例的话会走下面的分支（spring默认的是单例的），这里有一个ObjectFactory的匿名类，重写了方法getObject，其中调用了方法createBean，实现在AbstractAutowireCapableBeanFactory里面

// Create bean instance.
                    if (mbd.isSingleton()) {
                        sharedInstance = getSingleton(beanName, new ObjectFactory<Object>() {
                            @Override
                            public Object getObject() throws BeansException {
                                try {
                                    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.
                                    destroySingleton(beanName);
                                    throw ex;
                                }
                            }
                        });
                        bean = getObjectForBeanInstance(sharedInstance, name, beanName, mbd);
                    }

方法getObjectForBeanInstance主要功能是判断是不是FactoryBean，如果是则执行实例化FactoryBean的逻辑，否则直接返回传入的bean实例对象。

protected Object getObjectFromFactoryBean(FactoryBean<?> factory, String beanName, boolean shouldPostProcess) {
            /* * 如果factory是单例模式且当前上下文的单例对象缓存中已经有此beanName代表的bean的实例，则直接尝试从缓存中取该实例， * 如果能够取出（不为空），则直接把对象返回，否则调用方法doGetObjectFromFactoryBean创建实例。 */
            if (factory.isSingleton() && containsSingleton(beanName)) {
                synchronized (getSingletonMutex()) {
                    Object object = this.factoryBeanObjectCache.get(beanName);
                    if (object == null) {
                        object = doGetObjectFromFactoryBean(factory, beanName);
                        // Only post-process and store if not put there already during getObject() call above
                        // (e.g. because of circular reference processing triggered by custom getBean calls)
                        Object alreadyThere = this.factoryBeanObjectCache.get(beanName);
                        if (alreadyThere != null) {
                            object = alreadyThere;
                        }
                        else {
                            if (object != null && shouldPostProcess) {
                                try {
                                    /* * 如果定义了BeanPostProcessor，则执行其postProcessAfterInitialization方法 */
                                    object = postProcessObjectFromFactoryBean(object, beanName);
                                }
                                catch (Throwable ex) {
                                    throw new BeanCreationException(beanName,
                                            "Post-processing of FactoryBean's singleton object failed", ex);
                                }
                            }
                            this.factoryBeanObjectCache.put(beanName, (object != null ? object : NULL_OBJECT));
                        }
                    }
                    return (object != NULL_OBJECT ? object : null);
                }
            }
            else {
                Object object = doGetObjectFromFactoryBean(factory, beanName);
                if (object != null && shouldPostProcess) {
                    try {
                        object = postProcessObjectFromFactoryBean(object, beanName);
                    }
                    catch (Throwable ex) {
                        throw new BeanCreationException(beanName, "Post-processing of FactoryBean's object failed", ex);
                    }
                }
                return object;
            }
        }

private Object doGetObjectFromFactoryBean(final FactoryBean<?> factory, final String beanName)
                throws BeanCreationException {
    
            Object object;
            try {
                if (System.getSecurityManager() != null) {
                    AccessControlContext acc = getAccessControlContext();
                    try {
                        /* *AccessController.doPrivileged是java安全框架里的内容，大概的意思就是在该方法内的代码能够访问 *需要访问的资源而不管改代码的调用者有没有访问资源的权限，相当于特权的意思。不过如果run方法调用了 *其他代码，只有这个其他代码具有访问资源的权限，整个run方法才能顺利访问资源，否则还是会报访问异常。 */
                        object = AccessController.doPrivileged(new PrivilegedExceptionAction<Object>() { 
                            @Override
                            public Object run() throws Exception {
                                    /* * 这里调用factoryBean的getObject方法得到factoryBean的实例对象，这里得到的是factoryBean * 作为工厂的产品，而不是factoryBean本身，方法getObject定义在factoryBean */
                                    return factory.getObject();
                                }
                            }, acc);
                    }
                    catch (PrivilegedActionException pae) {
                        throw pae.getException();
                    }
                }
                else {
                    object = factory.getObject();
                }
            }
            catch (FactoryBeanNotInitializedException ex) {
                throw new BeanCurrentlyInCreationException(beanName, ex.toString());
            }
            catch (Throwable ex) {
                throw new BeanCreationException(beanName, "FactoryBean threw exception on object creation", ex);
            }
    
            // Do not accept a null value for a FactoryBean that's not fully
            // initialized yet: Many FactoryBeans just return null then.
            if (object == null && isSingletonCurrentlyInCreation(beanName)) { 
                throw new BeanCurrentlyInCreationException(
                        beanName, "FactoryBean which is currently in creation returned null from getObject");
            }
            return object;
        }

继续看方法createBean里的关键代码

Object beanInstance = doCreateBean(beanName, mbd, args);

继续看方法doCreateBean里的关键代码，下面的代码是调用方法createBeanInstance实例化bean，  
如果要实例化的bean是singleton的则先从缓存中查找，缓存中有的话则直接返回，没有，则调用方法createBeanInstance创建。

if (mbd.isSingleton()) {
                instanceWrapper = this.factoryBeanInstanceCache.remove(beanName);
            }
            if (instanceWrapper == null) {
                instanceWrapper = createBeanInstance(beanName, mbd, args);
            }

看下方法createBeanInstance的关键代码，如果有配置工厂方法，则使用工厂方法实例化bean，至于工厂方法实例化的细节后面再分析。

if (mbd.getFactoryMethodName() != null)  {
                return instantiateUsingFactoryMethod(beanName, mbd, args);
            }

根据mbd.constructorArgumentsResolved的值分别走不同的分支，至于constructorArgumentsResolved怎么来的（前面没有注意，后面会再补上的），一般的bean走的是else分支

// Shortcut when re-creating the same bean...
            boolean resolved = false;
            boolean autowireNecessary = false;
            if (args == null) {
                synchronized (mbd.constructorArgumentLock) {
                    if (mbd.resolvedConstructorOrFactoryMethod != null) {
                        resolved = true;
                        autowireNecessary = mbd.constructorArgumentsResolved;
                    }
                }
            }
            if (resolved) {
                if (autowireNecessary) {
                    return autowireConstructor(beanName, mbd, null, null);
                }
                else {
                    return instantiateBean(beanName, mbd);
                }
            }

方法instantiateBean的代码可以看到，关键是这句代码：  
getInstantiationStrategy().instantiate(mbd, beanName, parent);  
会根据bean的定义确定一个实例化的策略 instantiationStrategy(这个值是怎么来的前面也没有注意，后面会补充的，暂且继续看下去)，通过追踪可以看到这里的策略是CglibSubclassingInstantiationStrategy继承了父类SimpleInstantiationStrategy，方法instantiate的实现在SimpleInstantiationStrategy里。

protected BeanWrapper instantiateBean(final String beanName, final RootBeanDefinition mbd) {
            try {
                Object beanInstance;
                final BeanFactory parent = this;
                if (System.getSecurityManager() != null) {
                    beanInstance = AccessController.doPrivileged(new PrivilegedAction<Object>() {
                        @Override
                        public Object run() {
                            return getInstantiationStrategy().instantiate(mbd, beanName, parent);
                        }
                    }, getAccessControlContext());
                }
                else {
                    beanInstance = getInstantiationStrategy().instantiate(mbd, beanName, parent);
                }
                BeanWrapper bw = new BeanWrapperImpl(beanInstance);
                initBeanWrapper(bw);
                return bw;
            }
            catch (Throwable ex) {
                throw new BeanCreationException(mbd.getResourceDescription(), beanName, "Instantiation of bean failed", ex);

在SimpleInstantiationStrategy的方法instantiate中有两个分支，  
一个分支走的是BeanUtils.instantiateClass(constructorToUse), 可以看到spring会去找bean的默认的无参构造函数，找不到（写了带参数的构造方法之后，jvm就不会创建默认的构造方法）的话就直接报No default constructor found异常，所以如果bean的class定义里定义了带参数的构造方法时，也要把无参的构造方法写出来（这也是spring推荐的的方式），代码如下：可以看到实例化使用的newInstance方法。

public Object instantiate(RootBeanDefinition bd, String beanName, BeanFactory owner) {
    // Don't override the class with CGLIB if no overrides.
    if (bd.getMethodOverrides().isEmpty()) {
    Constructor<?> constructorToUse;
    synchronized (bd.constructorArgumentLock) {
    constructorToUse = (Constructor<?>) bd.resolvedConstructorOrFactoryMethod;
    if (constructorToUse == null) {
    final Class<?> clazz = bd.getBeanClass();
    if (clazz.isInterface()) {
    throw new BeanInstantiationException(clazz, "Specified class is an interface");
    }
    try {
    if (System.getSecurityManager() != null) {
    constructorToUse = AccessController.doPrivileged(new PrivilegedExceptionAction<Constructor<?>>() {
    @Override
    public Constructor<?> run() throws Exception {
    return clazz.getDeclaredConstructor((Class[]) null);
    }
    });
    }
    else {
    constructorToUse =clazz.getDeclaredConstructor((Class[]) null);
    }
    bd.resolvedConstructorOrFactoryMethod = constructorToUse;
    }
    catch (Exception ex) {
    throw new BeanInstantiationException(clazz, "No default constructor found", ex);
    }
    }
    }
    return BeanUtils.instantiateClass(constructorToUse);
    }
    else {
    // Must generate CGLIB subclass.
    return instantiateWithMethodInjection(bd, beanName, owner);
    }
    }

instantiateWithMethodInjection(bd, beanName, owner)，该方法在CglibSubclassingInstantiationStrategy里，它会调用方法instantiateWithMethodInjection，方法又调用了CglibSubclassingInstantiationStrategy的内部类CglibSubclassCreator的方法instantiate。

protected Object instantiateWithMethodInjection(RootBeanDefinition bd, String beanName, BeanFactory owner,
                Constructor<?> ctor, Object... args) { // Must generate CGLIB subclass... return new CglibSubclassCreator(bd, owner).instantiate(ctor, args); }

可以看到方法instantiate里面有多个分支，但不管哪个分支最终都是通过newInstance方法实例化bean的。

public Object instantiate(Constructor<?> ctor, Object... args) {
                Class<?> subclass = createEnhancedSubclass(this.beanDefinition);
                Object instance;
                if (ctor == null) {
     instance = BeanUtils.instantiate(subclass); } else { try { Constructor<?> enhancedSubclassConstructor = subclass.getConstructor(ctor.getParameterTypes()); instance = enhancedSubclassConstructor.newInstance(args); } catch (Exception ex) { throw new BeanInstantiationException(this.beanDefinition.getBeanClass(), "Failed to invoke constructor for CGLIB enhanced subclass [" + subclass.getName() + "]", ex); } } // SPR-10785: set callbacks directly on the instance instead of in the // enhanced class (via the Enhancer) in order to avoid memory leaks. Factory factory = (Factory) instance; factory.setCallbacks(new Callback[] { NoOp.INSTANCE, new LookupOverrideMethodInterceptor(this.beanDefinition, this.owner), new ReplaceOverrideMethodInterceptor(this.beanDefinition, this.owner)}); return instance; }

回到AbstractAutowireCapableBeanFactory的方法doCreateBean，继续分析下面的代码：

// Initialize the bean instance.
            Object exposedObject = bean;
            try {
                populateBean(beanName, mbd, instanceWrapper);
                if (exposedObject != null) {
                    exposedObject = initializeBean(beanName, exposedObject, mbd);
                }
            }

下面是方法initializeBean的代码，可以看到这里先会去执行BeanPostProcessor，即执行BeanPostProcessor力的方法postProcessBeforeInitialization，然后执行这句代码  
invokeInitMethods(beanName, wrappedBean, mbd);也就是去调用bean定义的init-method,  
，最后执行postProcessAfterInitialization在实例化bean之后。完成整个bean的实例化。

protected Object initializeBean(final String beanName, final Object bean, RootBeanDefinition mbd) {
            if (System.getSecurityManager() != null) {
                AccessController.doPrivileged(new PrivilegedAction<Object>() {
                    @Override
                    public Object run() {
                        invokeAwareMethods(beanName, bean);
                        return null;
                    }
                }, getAccessControlContext());
            }
            else {
                invokeAwareMethods(beanName, bean);
            }
    
            Object wrappedBean = bean;
            if (mbd == null || !mbd.isSynthetic()) {
                wrappedBean = applyBeanPostProcessorsBeforeInitialization(wrappedBean, beanName);
            }
    
            try {
                invokeInitMethods(beanName, wrappedBean, mbd);
            }
            catch (Throwable ex) {
                throw new BeanCreationException(
                        (mbd != null ? mbd.getResourceDescription() : null),
                        beanName, "Invocation of init method failed", ex);
            }
    
            if (mbd == null || !mbd.isSynthetic()) {
                wrappedBean = applyBeanPostProcessorsAfterInitialization(wrappedBean, beanName);
            }
            return wrappedBean;
        }

未完待续。。。