Spring MVC初始化部分源码分析

首先定位到org.springframework.context.support.AbstractApplicationContext中的refresh()方法：

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) {                // Destroy already created singletons to avoid dangling resources.                destroyBeans();                // Reset 'active' flag.                cancelRefresh(ex);                // Propagate exception to caller.                throw ex;            }        }    }

从这个refresh()方法入手，我们先对Spring容器启动时的大致过程有个概念：

1. 首先，Spring容器启动时会做一些初始化工作（比如注册一些默认的环境bean，添加一些必要的bean等）
2. 读取配置文件，并将其中定义的Bean转换成BeanDefinition
3. postProcessBeanFactory()相当于为上下文子类提供了一个扩展点，用于对bean factory的拦截处理（比如在AbstractRefreshableWebApplicationContext中注册了web中特有的request/session scope等）
4. Spring容器会先实例化实现了BeanDefinitionRegistryPostProcessor接口的类，并按照一定的顺序依次调用它的回调方法postProcessBeanDefinitionRegistry(BeanDefinitionRegistry registry) 。之后是实例化BeanFactoryPostProcessor并调用它的回调方法postProcessBeanFactory(ConfigurableListableBeanFactory beanFactory)，由于BeanDefinitionRegistryPostProcessor是BeanFactoryPostProcessor的子接口，所以BeanDefinitionRegistryPostProcessor的postProcessBeanFactory(ConfigurableListableBeanFactory beanFactory)方法在这个阶段也会被调用，但是一般都留空。

5. Spring容器会按照一定的顺序实例化实现了BeanPostProcessor的类，并注册到容器中。第六步，注册messageSource。其余的后续步骤就不介绍了，这里再关注一下finishBeanFactoryInitialization(ConfigurableListableBeanFactory beanFactory)，这个方法用来实例化容器中定义的所有Singleton（不包括之前已经初始化了的）。

   下面挑一些重要的源码分析一下：

protected void invokeBeanFactoryPostProcessors(ConfigurableListableBeanFactory beanFactory) {        // Invoke BeanDefinitionRegistryPostProcessors first, if any.        Set<String> processedBeans = new HashSet<String>();        if (beanFactory instanceof BeanDefinitionRegistry) {            // 处理BeanFactoryPostProcessor的第一阶段            BeanDefinitionRegistry registry = (BeanDefinitionRegistry) beanFactory;            List<BeanFactoryPostProcessor> regularPostProcessors = new LinkedList<BeanFactoryPostProcessor>();            List<BeanDefinitionRegistryPostProcessor> registryPostProcessors =                    new LinkedList<BeanDefinitionRegistryPostProcessor>();            // 这里通过getBeanFactoryPostProcessors()得到的Processors是该类的成员变量值，那么应该可以注入。            // 不过下面会直接扫描容器中的所有实现了BeanFactoryPostProcessor的类，那么这步是不是显得有点多此一举？            for (BeanFactoryPostProcessor postProcessor : getBeanFactoryPostProcessors()) {                if (postProcessor instanceof BeanDefinitionRegistryPostProcessor) {                    BeanDefinitionRegistryPostProcessor registryPostProcessor =                            (BeanDefinitionRegistryPostProcessor) postProcessor;                    registryPostProcessor.postProcessBeanDefinitionRegistry(registry);                    registryPostProcessors.add(registryPostProcessor);                }                else {                    regularPostProcessors.add(postProcessor);                }            }            // 此处是获取注册了的所有实现了BeanDefinitionRegistryPostProcessor接口的类            Map<String, BeanDefinitionRegistryPostProcessor> beanMap =                    beanFactory.getBeansOfType(BeanDefinitionRegistryPostProcessor.class, true, false);            List<BeanDefinitionRegistryPostProcessor> registryPostProcessorBeans =                    new ArrayList<BeanDefinitionRegistryPostProcessor>(beanMap.values());            OrderComparator.sort(registryPostProcessorBeans);// 按照order排序之后依次调用            for (BeanDefinitionRegistryPostProcessor postProcessor : registryPostProcessorBeans) {                postProcessor.postProcessBeanDefinitionRegistry(registry);            }            // 这里再回调BeanFactoryPostProcessor的postProcessBeanFactory()方法            invokeBeanFactoryPostProcessors(registryPostProcessors, beanFactory);            invokeBeanFactoryPostProcessors(registryPostProcessorBeans, beanFactory);            invokeBeanFactoryPostProcessors(regularPostProcessors, beanFactory);            // 这里用processedBeans来记录处理过的Processors，以免后面再重复处理            processedBeans.addAll(beanMap.keySet());            // 到此，第一阶段结束        }        else {            // Invoke factory processors registered with the context instance.            invokeBeanFactoryPostProcessors(getBeanFactoryPostProcessors(), 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);        // 将BeanFactoryPostProcessors根据是否实现PriorityOrdered,Ordered,或都没实现区分成三类.        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 (isTypeMatch(ppName, PriorityOrdered.class)) {                priorityOrderedPostProcessors.add(beanFactory.getBean(ppName, BeanFactoryPostProcessor.class));            }            else if (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(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(getBean(postProcessorName, BeanFactoryPostProcessor.class));        }        invokeBeanFactoryPostProcessors(nonOrderedPostProcessors, beanFactory);    }

下面则开始处理BeanPostProcessor：

    protected void registerBeanPostProcessors(ConfigurableListableBeanFactory beanFactory) {        // 从容器中取得所有实现了BeanPostProcessor接口的类的名字        String[] postProcessorNames = beanFactory.getBeanNamesForType(BeanPostProcessor.class, true, false);        // Register BeanPostProcessorChecker that logs an info message when        // a bean is created during BeanPostProcessor instantiation, i.e. when        // a bean is not eligible for getting processed by all BeanPostProcessors.        // 注册BeanPostProcessorChecker用来记录当一个bean在BeanPostProcessor初始化过程中，比如，当一个bean不能被所有BeanPostProcessors处理时        int beanProcessorTargetCount = beanFactory.getBeanPostProcessorCount() + 1 + postProcessorNames.length;        beanFactory.addBeanPostProcessor(new BeanPostProcessorChecker(beanFactory, beanProcessorTargetCount));        // 和BeanFactoryPostProcessor一样，这里将BeanPostProcessors分为三种类别：实现了PriorityOrdered，实现了Ordered        // 和两者都没有实现的        List<BeanPostProcessor> priorityOrderedPostProcessors = new ArrayList<BeanPostProcessor>();        List<BeanPostProcessor> internalPostProcessors = new ArrayList<BeanPostProcessor>();        List<String> orderedPostProcessorNames = new ArrayList<String>();        List<String> nonOrderedPostProcessorNames = new ArrayList<String>();        for (String ppName : postProcessorNames) {            if (isTypeMatch(ppName, PriorityOrdered.class)) {                BeanPostProcessor pp = beanFactory.getBean(ppName, BeanPostProcessor.class);                priorityOrderedPostProcessors.add(pp);                if (pp instanceof MergedBeanDefinitionPostProcessor) {                    internalPostProcessors.add(pp);                }            }            else if (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);        // 最后需要重新注册所有的internal BeanPostProcessors        OrderComparator.sort(internalPostProcessors);        registerBeanPostProcessors(beanFactory, internalPostProcessors);        beanFactory.addBeanPostProcessor(new ApplicationListenerDetector());    }

看到上面最后重新注册所有internal那一步可能会不解，注册过了再注册一遍是什么意思呢？我们看看源码：

    public void addBeanPostProcessor(BeanPostProcessor beanPostProcessor) {        Assert.notNull(beanPostProcessor, "BeanPostProcessor must not be null");        this.beanPostProcessors.remove(beanPostProcessor);        this.beanPostProcessors.add(beanPostProcessor);        if (beanPostProcessor instanceof InstantiationAwareBeanPostProcessor) {            this.hasInstantiationAwareBeanPostProcessors = true;        }        if (beanPostProcessor instanceof DestructionAwareBeanPostProcessor) {            this.hasDestructionAwareBeanPostProcessors = true;        }    }

这里会先将原来注册的BeanPostProcessor移除掉，然后再添加，这样也就保证了internal BeanPostProcessor总是在List的最后，在对Bean进行Process时总能保证internal BeanPostProcessor最后执行。（虽然不知道目的是为何，但应该确实有必要）

下面一步是初始化MessageSource。首先会在容器中寻找是否存在名为messageSource的Bean，若存在则将其初始化并作为messageSource：

    protected void initMessageSource() {        ConfigurableListableBeanFactory beanFactory = getBeanFactory();        if (beanFactory.containsLocalBean(MESSAGE_SOURCE_BEAN_NAME)) {            this.messageSource = beanFactory.getBean(MESSAGE_SOURCE_BEAN_NAME, MessageSource.class);            // Make MessageSource aware of parent MessageSource.            if (this.parent != null && this.messageSource instanceof HierarchicalMessageSource) {                HierarchicalMessageSource hms = (HierarchicalMessageSource) this.messageSource;                if (hms.getParentMessageSource() == null) {                    // Only set parent context as parent MessageSource if no parent MessageSource                    // registered already.                    hms.setParentMessageSource(getInternalParentMessageSource());                }            }            if (logger.isDebugEnabled()) {                logger.debug("Using MessageSource [" + this.messageSource + "]");            }        }        else {            // 如果容器中不存在messageSource，那么只能用一个空实现DelegatingMessageSource            // 它会将所有的方法调用都委托给parentMessageSource，若parentMessageSource为null            // 那默认的渲染策略就是将message原样返回            DelegatingMessageSource dms = new DelegatingMessageSource();            dms.setParentMessageSource(getInternalParentMessageSource());            this.messageSource = dms;            beanFactory.registerSingleton(MESSAGE_SOURCE_BEAN_NAME, this.messageSource);            if (logger.isDebugEnabled()) {                logger.debug("Unable to locate MessageSource with name '" + MESSAGE_SOURCE_BEAN_NAME +                        "': using default [" + this.messageSource + "]");            }        }

中间省略一些略微次要的步骤，看下面这个方法：
这个方法是用来初始化容器中定义的所有Singleton（不包括之前已经初始化了的）

    protected void finishBeanFactoryInitialization(ConfigurableListableBeanFactory beanFactory) {        // 首先初始化conversion service        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();        // 实例化所有剩下的非懒加载的singletons        beanFactory.preInstantiateSingletons();    }

可以看到，这里的最后一步才是真正做初始化工作的，其余只是做一些辅助。再跟进去看看：

public void preInstantiateSingletons() throws BeansException {        if (this.logger.isInfoEnabled()) {            this.logger.info("Pre-instantiating singletons in " + this);        }        List<String> beanNames;        synchronized (this.beanDefinitionMap) {            // 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.            beanNames = new ArrayList<String>(this.beanDefinitionNames);        }        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>() {                            public Boolean run() {                                return ((SmartFactoryBean<?>) factory).isEagerInit();                            }                        }, getAccessControlContext());                    }                    else {                        isEagerInit = (factory instanceof SmartFactoryBean &&                                ((SmartFactoryBean<?>) factory).isEagerInit());                    }                    if (isEagerInit) {                        getBean(beanName);                    }                }                else {                    getBean(beanName);                }            }        }    }

可以看到，这里对加载进来的BeanDefinition进行了区分，判断其是否为FactoryBean。从上面的代码可以看出，若是非FactoryBean，那么直接就调用getBean(...)方法了：

    public Object getBean(String name) throws BeansException {        return doGetBean(name, null, null, false);    }

这里直接去调用doGetBean(...)方法：

    protected <T> T doGetBean(            final String name, final Class<T> requiredType, final Object[] args, boolean typeCheckOnly)            throws BeansException {        final String beanName = transformedBeanName(name);        Object bean;        // Eagerly check singleton cache for manually registered singletons.        Object sharedInstance = getSingleton(beanName);        if (sharedInstance != null && args == null) {            if (logger.isDebugEnabled()) {                if (isSingletonCurrentlyInCreation(beanName)) {                    logger.debug("Returning eagerly cached instance of singleton bean '" + beanName +                            "' that is not fully initialized yet - a consequence of a circular reference");                }                else {                    logger.debug("Returning cached instance of singleton bean '" + beanName + "'");                }            }            bean = getObjectForBeanInstance(sharedInstance, name, beanName, null);        }        else {            // Fail if we're already creating this bean instance:            // We're assumably within a circular reference.            if (isPrototypeCurrentlyInCreation(beanName)) {                throw new BeanCurrentlyInCreationException(beanName);            }            // Check if bean definition exists in this factory.            BeanFactory parentBeanFactory = getParentBeanFactory();            if (parentBeanFactory != null && !containsBeanDefinition(beanName)) {                // Not found -> check parent.                String nameToLookup = originalBeanName(name);                if (args != null) {                    // Delegation to parent with explicit args.                    return (T) parentBeanFactory.getBean(nameToLookup, args);                }                else {                    // No args -> delegate to standard getBean method.                    return parentBeanFactory.getBean(nameToLookup, requiredType);                }            }            if (!typeCheckOnly) {                markBeanAsCreated(beanName);            }            try {                final RootBeanDefinition mbd = getMergedLocalBeanDefinition(beanName);                checkMergedBeanDefinition(mbd, beanName, args);                // 保证依赖的bean在该bean之前实例化                String[] dependsOn = mbd.getDependsOn();                if (dependsOn != null) {                    for (String dependsOnBean : dependsOn) {                        getBean(dependsOnBean);                        registerDependentBean(dependsOnBean, beanName);                    }                }                // 到这里才是真正去创建单例Bean                if (mbd.isSingleton()) {                    sharedInstance = getSingleton(beanName, new ObjectFactory<Object>() {                        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;                            }                        }                    });                    // 若非FactoryBean的话，那么直接返回sharedInstance。若是FactoryBean且name不以&开头，那么则返回工厂生产的getObject()                    bean = getObjectForBeanInstance(sharedInstance, name, beanName, mbd);                }                else if (mbd.isPrototype()) {                    // It's a prototype -> create a new instance.                    Object prototypeInstance = null;                    try {                        beforePrototypeCreation(beanName);                        prototypeInstance = createBean(beanName, mbd, args);                    }                    finally {                        afterPrototypeCreation(beanName);                    }                    bean = getObjectForBeanInstance(prototypeInstance, name, beanName, mbd);                }                else {                    String scopeName = mbd.getScope();                    final Scope scope = this.scopes.get(scopeName);                    if (scope == null) {                        throw new IllegalStateException("No Scope registered for scope '" + scopeName + "'");                    }                    try {                        Object scopedInstance = scope.get(beanName, new ObjectFactory<Object>() {                            public Object getObject() throws BeansException {                                beforePrototypeCreation(beanName);                                try {                                    return createBean(beanName, mbd, args);                                }                                finally {                                    afterPrototypeCreation(beanName);                                }                            }                        });                        bean = getObjectForBeanInstance(scopedInstance, name, beanName, mbd);                    }                    catch (IllegalStateException ex) {                        throw new BeanCreationException(beanName,                                "Scope '" + scopeName + "' is not active for the current thread; " +                                "consider defining a scoped proxy for this bean if you intend to refer to it from a singleton",                                ex);                    }                }            }            catch (BeansException ex) {                cleanupAfterBeanCreationFailure(beanName);                throw ex;            }        }        // Check if required type matches the type of the actual bean instance.        if (requiredType != null && bean != null && !requiredType.isAssignableFrom(bean.getClass())) {            try {                return getTypeConverter().convertIfNecessary(bean, requiredType);            }            catch (TypeMismatchException ex) {                if (logger.isDebugEnabled()) {                    logger.debug("Failed to convert bean '" + name + "' to required type [" +                            ClassUtils.getQualifiedName(requiredType) + "]", ex);                }                throw new BeanNotOfRequiredTypeException(name, requiredType, bean.getClass());            }        }        return (T) bean;    }

可以看到doGetBean()中核心的方法就是createBean(...)：

    /**     * Central method of this class: creates a bean instance,     * populates the bean instance, applies post-processors, etc.     * @see #doCreateBean     */    @Override    protected Object createBean(final String beanName, final RootBeanDefinition mbd, final Object[] args)            throws BeanCreationException {        if (logger.isDebugEnabled()) {            logger.debug("Creating instance of bean '" + beanName + "'");        }        // Make sure bean class is actually resolved at this point.        resolveBeanClass(mbd, beanName);        // Prepare method overrides.        try {            mbd.prepareMethodOverrides();        }        catch (BeanDefinitionValidationException ex) {            throw new BeanDefinitionStoreException(mbd.getResourceDescription(),                    beanName, "Validation of method overrides failed", ex);        }        try {            // Give BeanPostProcessors a chance to return a proxy instead of the target bean instance.            Object bean = resolveBeforeInstantiation(beanName, mbd);            if (bean != null) {                return bean;            }        }        catch (Throwable ex) {            throw new BeanCreationException(mbd.getResourceDescription(), beanName,                    "BeanPostProcessor before instantiation of bean failed", ex);        }        Object beanInstance = doCreateBean(beanName, mbd, args);        if (logger.isDebugEnabled()) {            logger.debug("Finished creating instance of bean '" + beanName + "'");        }        return beanInstance;    }

可以看到，上面的方法返回的beanInstance是通过doCreateBean(...)方法得到的，跟踪进去：

protected Object doCreateBean(final String beanName, final RootBeanDefinition mbd, final Object[] args) {        // Instantiate the bean.        BeanWrapper instanceWrapper = null;        if (mbd.isSingleton()) {            instanceWrapper = this.factoryBeanInstanceCache.remove(beanName);        }        if (instanceWrapper == null) {            // 这里包含几个步骤：1、实例化bean 2、创建BeanWrapper来包装bean 3、并给BeanWrapper设置conversionService和propertyEditor            instanceWrapper = createBeanInstance(beanName, mbd, args);        }        final Object bean = (instanceWrapper != null ? instanceWrapper.getWrappedInstance() : null);        Class<?> beanType = (instanceWrapper != null ? instanceWrapper.getWrappedClass() : null);        synchronized (mbd.postProcessingLock) {            if (!mbd.postProcessed) {                // 调用BeanFactory上注册的MergedBeanDefinitionPostProcessor的回调方法，用来修改BeanDefinition                // 这里包括对一些注解的解析支持（比如@Resource，@PostConstruct——CommonAnnotationBeanPostProcessor                // @Value，@Autowired——AutowiredAnnotationBeanPostProcessor                // @Required——RequiredAnnotationBeanPostProcessor）                applyMergedBeanDefinitionPostProcessors(mbd, beanType, beanName);                mbd.postProcessed = true;            }        }        // Eagerly cache singletons to be able to resolve circular references        // even when triggered by lifecycle interfaces like BeanFactoryAware.        boolean earlySingletonExposure = (mbd.isSingleton() && this.allowCircularReferences &&                isSingletonCurrentlyInCreation(beanName));        if (earlySingletonExposure) {            if (logger.isDebugEnabled()) {                logger.debug("Eagerly caching bean '" + beanName +                        "' to allow for resolving potential circular references");            }            addSingletonFactory(beanName, new ObjectFactory<Object>() {                public Object getObject() throws BeansException {                    return getEarlyBeanReference(beanName, mbd, bean);                }            });        }        // Initialize the bean instance.        Object exposedObject = bean;        try {            // 给bean注入依赖 这个方法下面会分析一下            populateBean(beanName, mbd, instanceWrapper);            if (exposedObject != null) {                // 这里调用init方法，并用BeanPostProcessor来拦截Bean                exposedObject = initializeBean(beanName, exposedObject, mbd);            }        }        catch (Throwable ex) {            if (ex instanceof BeanCreationException && beanName.equals(((BeanCreationException) ex).getBeanName())) {                throw (BeanCreationException) ex;            }            else {                throw new BeanCreationException(mbd.getResourceDescription(), beanName, "Initialization of bean failed", ex);            }        }        if (earlySingletonExposure) {            Object earlySingletonReference = getSingleton(beanName, false);            if (earlySingletonReference != null) {                if (exposedObject == bean) {                    exposedObject = earlySingletonReference;                }                else if (!this.allowRawInjectionDespiteWrapping && hasDependentBean(beanName)) {                    String[] dependentBeans = getDependentBeans(beanName);                    Set<String> actualDependentBeans = new LinkedHashSet<String>(dependentBeans.length);                    for (String dependentBean : dependentBeans) {                        if (!removeSingletonIfCreatedForTypeCheckOnly(dependentBean)) {                            actualDependentBeans.add(dependentBean);                        }                    }                    if (!actualDependentBeans.isEmpty()) {                        throw new BeanCurrentlyInCreationException(beanName,                                "Bean with name '" + beanName + "' has been injected into other beans [" +                                StringUtils.collectionToCommaDelimitedString(actualDependentBeans) +                                "] in its raw version as part of a circular reference, but has eventually been " +                                "wrapped. This means that said other beans do not use the final version of the " +                                "bean. This is often the result of over-eager type matching - consider using " +                                "'getBeanNamesOfType' with the 'allowEagerInit' flag turned off, for example.");                    }                }            }        }        // Register bean as disposable.        try {            registerDisposableBeanIfNecessary(beanName, bean, mbd);        }        catch (BeanDefinitionValidationException ex) {            throw new BeanCreationException(mbd.getResourceDescription(), beanName, "Invalid destruction signature", ex);        }        return exposedObject;    }

最后再看下populateBean(...)这个注入依赖的方法：

    protected void populateBean(String beanName, RootBeanDefinition mbd, BeanWrapper bw) {        PropertyValues pvs = mbd.getPropertyValues();        if (bw == null) {            if (!pvs.isEmpty()) {                throw new BeanCreationException(                        mbd.getResourceDescription(), beanName, "Cannot apply property values to null instance");            }            else {                // Skip property population phase for null instance.                return;            }        }        // Give any InstantiationAwareBeanPostProcessors the opportunity to modify the        // state of the bean before properties are set. This can be used, for example,        // to support styles of field injection.        boolean continueWithPropertyPopulation = true;        if (!mbd.isSynthetic() && hasInstantiationAwareBeanPostProcessors()) {            for (BeanPostProcessor bp : getBeanPostProcessors()) {                if (bp instanceof InstantiationAwareBeanPostProcessor) {                    InstantiationAwareBeanPostProcessor ibp = (InstantiationAwareBeanPostProcessor) bp;                    if (!ibp.postProcessAfterInstantiation(bw.getWrappedInstance(), beanName)) {                        continueWithPropertyPopulation = false;                        break;                    }                }            }        }        if (!continueWithPropertyPopulation) {            return;        }        // 处理autowire byname和bytype的情况        if (mbd.getResolvedAutowireMode() == RootBeanDefinition.AUTOWIRE_BY_NAME ||                mbd.getResolvedAutowireMode() == RootBeanDefinition.AUTOWIRE_BY_TYPE) {            MutablePropertyValues newPvs = new MutablePropertyValues(pvs);            // Add property values based on autowire by name if applicable.            if (mbd.getResolvedAutowireMode() == RootBeanDefinition.AUTOWIRE_BY_NAME) {                autowireByName(beanName, mbd, bw, newPvs);            }            // Add property values based on autowire by type if applicable.            if (mbd.getResolvedAutowireMode() == RootBeanDefinition.AUTOWIRE_BY_TYPE) {                autowireByType(beanName, mbd, bw, newPvs);            }            pvs = newPvs;        }        boolean hasInstAwareBpps = hasInstantiationAwareBeanPostProcessors();        boolean needsDepCheck = (mbd.getDependencyCheck() != RootBeanDefinition.DEPENDENCY_CHECK_NONE);        if (hasInstAwareBpps || needsDepCheck) {            PropertyDescriptor[] filteredPds = filterPropertyDescriptorsForDependencyCheck(bw, mbd.allowCaching);            if (hasInstAwareBpps) {                // 而这里则是处理@Resource、@Autowire等自动装配的依赖                for (BeanPostProcessor bp : getBeanPostProcessors()) {                    if (bp instanceof InstantiationAwareBeanPostProcessor) {                        InstantiationAwareBeanPostProcessor ibp = (InstantiationAwareBeanPostProcessor) bp;                        pvs = ibp.postProcessPropertyValues(pvs, filteredPds, bw.getWrappedInstance(), beanName);                        if (pvs == null) {                            return;                        }                    }                }            }            if (needsDepCheck) {                checkDependencies(beanName, mbd, filteredPds, pvs);            }        }        // 将pvs转换成相应类型的属性值并设置到对应字段中去        applyPropertyValues(beanName, mbd, bw, pvs);    }

差不多分析完了，也就是自己对Spring源码的一个学习，希望对大家也可以有帮助。