1、调用ClassPathXmlApplicationContext类中的构造方法：

	public ClassPathXmlApplicationContext(
			String[] configLocations, boolean refresh, @Nullable ApplicationContext parent)
			throws BeansException {

		super(parent);
		setConfigLocations(configLocations);
		if (refresh) {
			refresh();
		}
	}

2、调用ClassPathXmlApplicationContext类中的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();	//Spring解析xml配置文件将所有bean的信息保存起来
	
				// 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();	//SpringMVC中的国际化
	
					// 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);	//初始化所有单实例bean的地方
	
					// Last step: publish corresponding event.
					finishRefresh();
				}
	
				catch (BeansException ex) {
					if (logger.isWarnEnabled()) {
						logger.warn("Exception encountered during context initialization - " +
								"cancelling refresh attempt: " + ex);
					}
	
					// Destroy already created singletons to avoid dangling resources.
					destroyBeans();
	
					// Reset 'active' flag.
					cancelRefresh(ex);
	
					// Propagate exception to caller.
					throw ex;
				}
	
				finally {
					// Reset common introspection caches in Spring's core, since we
					// might not ever need metadata for singleton beans anymore...
					resetCommonCaches();
				}
			}
		}

3、调用AbstractApplicationContext类中的finishBeanFactoryInitialization(beanFactory)

	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));
			}
	
			// Register a default embedded value resolver if no bean post-processor
			// (such as a PropertyPlaceholderConfigurer bean) registered any before:
			// at this point, primarily for resolution in annotation attribute values.
			if (!beanFactory.hasEmbeddedValueResolver()) {
				beanFactory.addEmbeddedValueResolver(strVal -> getEnvironment().resolvePlaceholders(strVal));
			}
	
			// Initialize LoadTimeWeaverAware beans early to allow for registering their transformers early.
			String[] weaverAwareNames = beanFactory.getBeanNamesForType(LoadTimeWeaverAware.class, false, false);
			for (String weaverAwareName : weaverAwareNames) {
				getBean(weaverAwareName);
			}
	
			// Stop using the temporary ClassLoader for type matching.
			beanFactory.setTempClassLoader(null);
	
			// Allow for caching all bean definition metadata, not expecting further changes.
			beanFactory.freezeConfiguration();
	
			// Instantiate all remaining (non-lazy-init) singletons.
			beanFactory.preInstantiateSingletons();	//初始化所有非懒加载的单例bean
		}

4、执行preInstantiateSingletons()

	public void preInstantiateSingletons() throws BeansException {
			if (logger.isTraceEnabled()) {
				logger.trace("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<>(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)) {
						Object bean = getBean(FACTORY_BEAN_PREFIX + beanName);
						if (bean instanceof FactoryBean) {
							final FactoryBean<?> factory = (FactoryBean<?>) bean;
							boolean isEagerInit;
							if (System.getSecurityManager() != null && factory instanceof SmartFactoryBean) {
								isEagerInit = AccessController.doPrivileged((PrivilegedAction<Boolean>)
												((SmartFactoryBean<?>) factory)::isEagerInit,
										getAccessControlContext());
							}
							else {
								isEagerInit = (factory instanceof SmartFactoryBean &&
										((SmartFactoryBean<?>) factory).isEagerInit());
							}
							if (isEagerInit) {
								getBean(beanName);
							}
						}
					}
					else {
						getBean(beanName);	//非工厂bean且非懒加载的单例bean创建
					}
				}
			}
	
			// 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((PrivilegedAction<Object>) () -> {
							smartSingleton.afterSingletonsInstantiated();
							return null;
						}, getAccessControlContext());
					}
					else {
						smartSingleton.afterSingletonsInstantiated();
					}
				}
			}
		}

5、调用DefaultListableBeanFactory类中的getBean(beanName)

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

6、调用AbstractBeanFactory中的doGetBean(name, null, null, false)

	protected <T> T doGetBean(final String name, @Nullable final Class<T> requiredType,
				@Nullable 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);	//从已经注册的所有单实例bean中获得这个bean, 如果没创建过这个bean就返回null
			if (sharedInstance != null && args == null) {
				if (logger.isTraceEnabled()) {
					if (isSingletonCurrentlyInCreation(beanName)) {
						logger.trace("Returning eagerly cached instance of singleton bean '" + beanName +
								"' that is not fully initialized yet - a consequence of a circular reference");
					}
					else {
						logger.trace("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 (parentBeanFactory instanceof AbstractBeanFactory) {
						return ((AbstractBeanFactory) parentBeanFactory).doGetBean(
								nameToLookup, requiredType, args, typeCheckOnly);
					}
					else if (args != null) {
						// Delegation to parent with explicit args.
						return (T) parentBeanFactory.getBean(nameToLookup, args);
					}
					else if (requiredType != null) {
						// No args -> delegate to standard getBean method.
						return parentBeanFactory.getBean(nameToLookup, requiredType);
					}
					else {
						return (T) parentBeanFactory.getBean(nameToLookup);
					}
				}
	
				if (!typeCheckOnly) {
					markBeanAsCreated(beanName);
				}
	
				try {
					final RootBeanDefinition mbd = getMergedLocalBeanDefinition(beanName);
					checkMergedBeanDefinition(mbd, beanName, args);
	
					// Guarantee initialization of beans that the current bean depends on.
					String[] dependsOn = mbd.getDependsOn();	//缓存的map中不存在, 就先拿到依赖bean, 先创建
					if (dependsOn != null) {
						for (String dep : dependsOn) {
							if (isDependent(beanName, dep)) {
								throw new BeanCreationException(mbd.getResourceDescription(), beanName,
										"Circular depends-on relationship between '" + beanName + "' and '" + dep + "'");
							}
							registerDependentBean(dep, beanName);
							try {
								getBean(dep);	//缓存的map中不存在, 创建依赖bean
							}
							catch (NoSuchBeanDefinitionException ex) {
								throw new BeanCreationException(mbd.getResourceDescription(), beanName,
										"'" + beanName + "' depends on missing bean '" + dep + "'", ex);
							}
						}
					}
	
					// Create bean instance.
					if (mbd.isSingleton()) {
						sharedInstance = getSingleton(beanName, () -> {
							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);
					}
	
					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 name '" + scopeName + "'");
						}
						try {
							Object scopedInstance = scope.get(beanName, () -> {
								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 && !requiredType.isInstance(bean)) {
				try {
					T convertedBean = getTypeConverter().convertIfNecessary(bean, requiredType);
					if (convertedBean == null) {
						throw new BeanNotOfRequiredTypeException(name, requiredType, bean.getClass());
					}
					return convertedBean;
				}
				catch (TypeMismatchException ex) {
					if (logger.isTraceEnabled()) {
						logger.trace("Failed to convert bean '" + name + "' to required type '" +
								ClassUtils.getQualifiedName(requiredType) + "'", ex);
					}
					throw new BeanNotOfRequiredTypeException(name, requiredType, bean.getClass());
				}
			}
			return (T) bean;
		}

7、分析IOC容器中保存bean的数据结构，调用DefaultSingletonBeanRegistry中的getSingleton(beanName)

	public Object getSingleton(String beanName) {
			return getSingleton(beanName, true);
		}

8、调用同类中的getSingleton(beanName, true)

	protected Object getSingleton(String beanName, boolean allowEarlyReference) {
			Object singletonObject = this.singletonObjects.get(beanName);
			if (singletonObject == null && isSingletonCurrentlyInCreation(beanName)) {
				synchronized (this.singletonObjects) {
					singletonObject = this.earlySingletonObjects.get(beanName);
					if (singletonObject == null && allowEarlyReference) {
						ObjectFactory<?> singletonFactory = this.singletonFactories.get(beanName);
						if (singletonFactory != null) {
							singletonObject = singletonFactory.getObject();	//创建bean
							this.earlySingletonObjects.put(beanName, singletonObject);	//往缓存的map中添加创建的bean
							this.singletonFactories.remove(beanName);
						}
					}
				}
			}
			return singletonObject;
		}

创建好的bean对象最终会保存在singletonObjects中。

ioc容器的作用之一：保存单实例bean的地方。

/** Cache of singleton objects: bean name to bean instance. */
	private final Map<String, Object> singletonObjects = new ConcurrentHashMap<>(256);	//缓存bean实例的数据结构