IOC容器加载-深度解析（全集）

@ComponentScan("com.xc.lifecycle.entity")
@Configuration
public class Config {
    @Bean()
    public Book book(){
        return new Book();
    }
}

public class Client {
    public static void main(String[] args) {
        //创建注解容器，入参为配置类
        AnnotationConfigApplicationContext context = new AnnotationConfigApplicationContext(Config.class);
        //获取某个bean
        Book book = context.getBean("book", Book.class);
        System.out.println(book);
        //关闭容器
        context.close();
    }
}

public static Set<BeanDefinitionHolder> registerAnnotationConfigProcessors(
		BeanDefinitionRegistry registry, @Nullable Object source) {
	//获取之前创建好的DefaultListableBeanFactory对象，beanFactory实例
	DefaultListableBeanFactory beanFactory = unwrapDefaultListableBeanFactory(registry);
	//为beanFactory添加两属性
	if (beanFactory != null) {
		if (!(beanFactory.getDependencyComparator() instanceof AnnotationAwareOrderComparator)) {
			beanFactory.setDependencyComparator(AnnotationAwareOrderComparator.INSTANCE);
		}
		if (!(beanFactory.getAutowireCandidateResolver() instanceof ContextAnnotationAutowireCandidateResolver)) {
			beanFactory.setAutowireCandidateResolver(new ContextAnnotationAutowireCandidateResolver());
		}
	}
	//创建8长度集合
	Set<BeanDefinitionHolder> beanDefs = new LinkedHashSet<>(8);
	//查询beanDefinitionMap是否有
	//internalConfigurationAnnotationProcessor =ConfigurationClassPostProcessor
	//（内部注解配置后置处理器）
	if (!registry.containsBeanDefinition(CONFIGURATION_ANNOTATION_PROCESSOR_BEAN_NAME)) {
		RootBeanDefinition def = new RootBeanDefinition(ConfigurationClassPostProcessor.class);
		def.setSource(source);
		//注册到beanDefinitionMap中，并添加到beanDefs集合中
		beanDefs.add(registerPostProcessor(registry, def, CONFIGURATION_ANNOTATION_PROCESSOR_BEAN_NAME));
	}
	//注册internalAutowiredAnnotationProcessor = AutowiredAnnotationBeanPostProcessor
	//与上面一样
	if (!registry.containsBeanDefinition(AUTOWIRED_ANNOTATION_PROCESSOR_BEAN_NAME)) {
		RootBeanDefinition def = new RootBeanDefinition(AutowiredAnnotationBeanPostProcessor.class);
		def.setSource(source);
		beanDefs.add(registerPostProcessor(registry, def, AUTOWIRED_ANNOTATION_PROCESSOR_BEAN_NAME));
	}

	// JSR-250，是java定义的一些注解，spring支持这注解。大致有：@PostConstruct@PreDestroy@Resource
	//注册internalCommonAnnotationProcessor = CommonAnnotationBeanPostProcessor
	if (jsr250Present && !registry.containsBeanDefinition(COMMON_ANNOTATION_PROCESSOR_BEAN_NAME)) {
		RootBeanDefinition def = new RootBeanDefinition(CommonAnnotationBeanPostProcessor.class);
		def.setSource(source);
		beanDefs.add(registerPostProcessor(registry, def, COMMON_ANNOTATION_PROCESSOR_BEAN_NAME));
	}

	// spring注册支持jpa注解的beanFactory后置处理器
	if (jpaPresent && !registry.containsBeanDefinition(PERSISTENCE_ANNOTATION_PROCESSOR_BEAN_NAME)) {
		RootBeanDefinition def = new RootBeanDefinition();
		try {
			def.setBeanClass(ClassUtils.forName(PERSISTENCE_ANNOTATION_PROCESSOR_CLASS_NAME,
					AnnotationConfigUtils.class.getClassLoader()));
		}
		catch (ClassNotFoundException ex) {
			throw new IllegalStateException(
					"Cannot load optional framework class: " + PERSISTENCE_ANNOTATION_PROCESSOR_CLASS_NAME, ex);
		}
		def.setSource(source);
		beanDefs.add(registerPostProcessor(registry, def, PERSISTENCE_ANNOTATION_PROCESSOR_BEAN_NAME));
	}
	//注册事件监听后置处理器
	//internalEventListenerProcessor = EventListenerMethodProcessor
	if (!registry.containsBeanDefinition(EVENT_LISTENER_PROCESSOR_BEAN_NAME)) {
		RootBeanDefinition def = new RootBeanDefinition(EventListenerMethodProcessor.class);
		def.setSource(source);
		beanDefs.add(registerPostProcessor(registry, def, EVENT_LISTENER_PROCESSOR_BEAN_NAME));
	}
	//注册事件监听工厂
	//internalEventListenerFactory = DefaultEventListenerFactory
	if (!registry.containsBeanDefinition(EVENT_LISTENER_FACTORY_BEAN_NAME)) {
		RootBeanDefinition def = new RootBeanDefinition(DefaultEventListenerFactory.class);
		def.setSource(source);
		beanDefs.add(registerPostProcessor(registry, def, EVENT_LISTENER_FACTORY_BEAN_NAME));
	}
	return beanDefs;
}

AnnotationConfigApplicationContext context = new AnnotationConfigApplicationContext(Config.class);
context.scan("com.xc.lifecycle.pojo");

@Override
public void refresh() throws BeansException, IllegalStateException {
	synchronized (this.startupShutdownMonitor) {
		// 1、刷新前预处理
		prepareRefresh();

		// 2、获取最新的bean工厂
		ConfigurableListableBeanFactory beanFactory = obtainFreshBeanFactory();

		// 3、注册bean工厂的类加载器和部分后置处理器
		prepareBeanFactory(beanFactory);

		try {
			// 4、bean工厂的后置处理器（子类实现）
			postProcessBeanFactory(beanFactory);

			// 5、执行bean工厂的后置处理器
			invokeBeanFactoryPostProcessors(beanFactory);

			// 6、实例化并注册所有的后置处理器
			registerBeanPostProcessors(beanFactory);

			// 7、初始化国际化组件
			initMessageSource();

			// 8、初始化事件多播器（用来广播事件）
			initApplicationEventMulticaster();

			// 9、子类实现，扩展其他bean
			onRefresh();

			// 10、注册监听器
			registerListeners();

			// 11、实例化，初始化所有的非懒加载的单例bean
			finishBeanFactoryInitialization(beanFactory);

			// 12、最后刷新，发布相应事件
			finishRefresh();
		}

		catch (BeansException ex) {
			if (logger.isWarnEnabled()) {
				logger.warn("Exception encountered during context initialization - " +
						"cancelling refresh attempt: " + ex);
			}

			// 销毁已创建的单例bean
			destroyBeans();

			// 重置容器激活标签
			cancelRefresh(ex);

			// 抛异常
			throw ex;
		}

		finally {
			// Reset common introspection caches in Spring's core, since we
			// might not ever need metadata for singleton beans anymore...
			resetCommonCaches();
		}
	}
}

protected void prepareRefresh() {
	//设置启动时间
	this.startupDate = System.currentTimeMillis();
	//容器是否关闭
	this.closed.set(false);
	//容器是否激活
	this.active.set(true);
	//根据日志开启级别打印日志
	if (logger.isDebugEnabled()) {
		if (logger.isTraceEnabled()) {
			logger.trace("Refreshing " + this);
		}
		else {
			logger.debug("Refreshing " + getDisplayName());
		}
	}

	// 空实现，子类实现。AnnotationConfigApplicationContext容器的子容器初始化工作。
	initPropertySources();

	//校验必须的一些属性
	getEnvironment().validateRequiredProperties();

	// 保存容器预处理的事件
	if (this.earlyApplicationListeners == null) {
		this.earlyApplicationListeners = new LinkedHashSet<>(this.applicationListeners);
	}
	else {
		// Reset local application listeners to pre-refresh state.
		this.applicationListeners.clear();
		this.applicationListeners.addAll(this.earlyApplicationListeners);
	}

	// 设置早期事件（以前的事件）
	// 将在Multicast可用后发布
	this.earlyApplicationEvents = new LinkedHashSet<>();
}

protected void prepareBeanFactory(ConfigurableListableBeanFactory beanFactory) {
	// 设置类加载器：存在则直接设置/不存在则新建一个默认类加载器
	beanFactory.setBeanClassLoader(getClassLoader());
	// 设置EL表达式解析器（Bean初始化完成后填充属性时会用到）
	beanFactory.setBeanExpressionResolver(new StandardBeanExpressionResolver(beanFactory.getBeanClassLoader()));
	// 设置属性注册解析器PropertyEditor
	beanFactory.addPropertyEditorRegistrar(new ResourceEditorRegistrar(this, getEnvironment()));

	// 将当前的ApplicationContext对象交给ApplicationContextAwareProcessor类来处理，
	// 从而在Aware接口实现类中的注入context
	beanFactory.addBeanPostProcessor(new ApplicationContextAwareProcessor(this));
	//设置忽略自动装配的接口
	//因为在ApplicationContextAwareProcessor中已经完成了手动注入
	beanFactory.ignoreDependencyInterface(EnvironmentAware.class);
	beanFactory.ignoreDependencyInterface(EmbeddedValueResolverAware.class);
	beanFactory.ignoreDependencyInterface(ResourceLoaderAware.class);
	beanFactory.ignoreDependencyInterface(ApplicationEventPublisherAware.class);
	beanFactory.ignoreDependencyInterface(MessageSourceAware.class);
	beanFactory.ignoreDependencyInterface(ApplicationContextAware.class);

	/**
	 * 注册几个自动装配相关的类和实例
	 * 在应用代码就可以通过类型自动装配把工厂实例和ApplicationContext实例设置到自定义bean的属性中
	 *
	 * 例如：这几个属性都会被自动设置，虽然没有在显示的在bean定义xml中注入它们
	 * @Autowired
	 * private BeanFactory beanFactory;
	 * @Autowired
	 * private ApplicationContext appContext;
	 */
	beanFactory.registerResolvableDependency(BeanFactory.class, beanFactory);
	beanFactory.registerResolvableDependency(ResourceLoader.class, this);
	beanFactory.registerResolvableDependency(ApplicationEventPublisher.class, this);
	beanFactory.registerResolvableDependency(ApplicationContext.class, this);

	// 注册监听后置处理器
	beanFactory.addBeanPostProcessor(new ApplicationListenerDetector(this));
	
	// 添加编译时AspectJ的支持
	// 当容器检查到定义了名称为loadTimeWeaver的bean时
	// 会注册一个LoadTimeWeaverAwareProcessor到容器中
	// 这个后置处理器用来处理LoadTimeWeaverAware接口的
	if (beanFactory.containsBean(LOAD_TIME_WEAVER_BEAN_NAME)) {
		beanFactory.addBeanPostProcessor(new LoadTimeWeaverAwareProcessor(beanFactory));
		beanFactory.setTempClassLoader(new ContextTypeMatchClassLoader(beanFactory.getBeanClassLoader()));
	}
	
	//将以下三个bean放入singletonObjects单例bean容器中
	// 注册当前容器环境environment组件Bean
	if (!beanFactory.containsLocalBean(ENVIRONMENT_BEAN_NAME)) {
		beanFactory.registerSingleton(ENVIRONMENT_BEAN_NAME, getEnvironment());
	}
	// 注册系统配置systemProperties组件Bean
	if (!beanFactory.containsLocalBean(SYSTEM_PROPERTIES_BEAN_NAME)) {
		beanFactory.registerSingleton(SYSTEM_PROPERTIES_BEAN_NAME, getEnvironment().getSystemProperties());
	}
	// 注册系统环境systemEnvironment组件Bean
	if (!beanFactory.containsLocalBean(SYSTEM_ENVIRONMENT_BEAN_NAME)) {
		beanFactory.registerSingleton(SYSTEM_ENVIRONMENT_BEAN_NAME, getEnvironment().getSystemEnvironment());
	}
}

public static void invokeBeanFactoryPostProcessors(
		ConfigurableListableBeanFactory beanFactory, List<BeanFactoryPostProcessor> beanFactoryPostProcessors) {

	// 执行beans集合
	Set<String> processedBeans = new HashSet<>();

	//如果有BeanDefinitionRegistryPostProcessors-bean定义后置处理器，先执行。
	//（后执行BeanFactoryPostProcessor-bean工厂后置处理器）
	if (beanFactory instanceof BeanDefinitionRegistry) {
		BeanDefinitionRegistry registry = (BeanDefinitionRegistry) beanFactory;
		// 用于存放入参bean定义后置处理器集合
		List<BeanFactoryPostProcessor> regularPostProcessors = new ArrayList<>();
		// 用于存放bean定义后置处理器集合
		List<BeanDefinitionRegistryPostProcessor> registryProcessors = new ArrayList<>();
		//这里处理入参的bean定义后置处理器，入参的数据是自定义传入的，不怎么用，这里不说了
		for (BeanFactoryPostProcessor postProcessor : beanFactoryPostProcessors) {
			if (postProcessor instanceof BeanDefinitionRegistryPostProcessor) {
				BeanDefinitionRegistryPostProcessor registryProcessor =
						(BeanDefinitionRegistryPostProcessor) postProcessor;
				registryProcessor.postProcessBeanDefinitionRegistry(registry);
				registryProcessors.add(registryProcessor);
			}
			else {
				regularPostProcessors.add(postProcessor);
			}
		}

		// 用于保存本次要执行的bean定义后置处理器（当前bean定义后置处理器）
		List<BeanDefinitionRegistryPostProcessor> currentRegistryProcessors = new ArrayList<>();

		// 首先，先执行实现了PriorityOrdered的bean定义后置处理器
		// 找出所有实现BeanDefinitionRegistryPostProcessor接口的Bean的beanName
		String[] postProcessorNames =
				beanFactory.getBeanNamesForType(BeanDefinitionRegistryPostProcessor.class, true, false);
		for (String ppName : postProcessorNames) {
			// 校验是否实现了PriorityOrdered接口
			if (beanFactory.isTypeMatch(ppName, PriorityOrdered.class)) {
				// 获取ppName对应的bean实例, 添加到currentRegistryProcessors中
				// beanFactory.getBean();获取bean，获取不到创建。后续单独将
				currentRegistryProcessors.add(beanFactory.getBean(ppName, BeanDefinitionRegistryPostProcessor.class));
				//将要被执行的加入processedBeans，避免后续重复执行
				processedBeans.add(ppName);
			}
		}
		//进行排序(之前注册默认处理器时候，添加过排序策略属性 )
		// beanFactory.setDependencyComparator(AnnotationAwareOrderComparator.INSTANCE);
		sortPostProcessors(currentRegistryProcessors, beanFactory);
		// 添加到bean定义后置处理器
		registryProcessors.addAll(currentRegistryProcessors);
		// 将所有bean定义后置处理器遍历执行它的方法 postProcessBeanDefinitionRegistry()
		// --对beanBefinition的增删改
		invokeBeanDefinitionRegistryPostProcessors(currentRegistryProcessors, registry);
		// 执行完毕后, 清空currentRegistryProcessors
		currentRegistryProcessors.clear();

		// 接下来，先执行实现了Ordered的bean定义后置处理器
		postProcessorNames = beanFactory.getBeanNamesForType(BeanDefinitionRegistryPostProcessor.class, true, false);
		for (String ppName : postProcessorNames) {
			// 校验是否实现了Ordered接口，并且还未执行过
			if (!processedBeans.contains(ppName) && beanFactory.isTypeMatch(ppName, Ordered.class)) {
				currentRegistryProcessors.add(beanFactory.getBean(ppName, BeanDefinitionRegistryPostProcessor.class));
				processedBeans.add(ppName);
			}
		}
		sortPostProcessors(currentRegistryProcessors, beanFactory);
		registryProcessors.addAll(currentRegistryProcessors);
		invokeBeanDefinitionRegistryPostProcessors(currentRegistryProcessors, registry);
		currentRegistryProcessors.clear();

		// 最后，执行剩下的bean定义后置处理器，什么排序接口都没有实现
		boolean reiterate = true;
		while (reiterate) {
			reiterate = false;
			postProcessorNames = beanFactory.getBeanNamesForType(BeanDefinitionRegistryPostProcessor.class, true, false);
			for (String ppName : postProcessorNames) {
				// 跳过已经执行过的
				if (!processedBeans.contains(ppName)) {
					currentRegistryProcessors.add(beanFactory.getBean(ppName, BeanDefinitionRegistryPostProcessor.class));
					processedBeans.add(ppName);
					 // 如果有bean定义后置处理器被执行, 则有可能会产生新的bean定义后置处理器
	                // 因此这边将reiterate赋值为true, 代表需要再循环查找一次
					reiterate = true;
				}
			}
			sortPostProcessors(currentRegistryProcessors, beanFactory);
			registryProcessors.addAll(currentRegistryProcessors);
			invokeBeanDefinitionRegistryPostProcessors(currentRegistryProcessors, registry);
			currentRegistryProcessors.clear();
		}

		// 现在统一执行bean定义后置处理器的postProcessBeanFactory方法
		//(BeanDefinitionRegistryPostProcessor继承自BeanFactoryPostProcessor)
		invokeBeanFactoryPostProcessors(registryProcessors, beanFactory);
		// 现在统一执行入参bean定义后置处理器的postProcessBeanFactory方法
		invokeBeanFactoryPostProcessors(regularPostProcessors, beanFactory);
	}

	else {
		// 如果没有bean定义后置处理器，直接执行参数传入的bean定义后置处理器
		invokeBeanFactoryPostProcessors(beanFactoryPostProcessors, beanFactory);
	}


	// 到这里 , 入参beanFactoryPostProcessors和容器中的所有BeanDefinitionRegistryPostProcessor已经全部处理完毕,
	// 下面开始处理容器中的所有BeanFactoryPostProcessor
	String[] postProcessorNames =
			beanFactory.getBeanNamesForType(BeanFactoryPostProcessor.class, true, false);

	...与上面代码一模一样，下面总集说
}

// 实例化所有的BeanPostProcessor并将其注册到BeanFactory中
public static void registerBeanPostProcessors(
      ConfigurableListableBeanFactory beanFactory, AbstractApplicationContext applicationContext) {
   // 获取beanFactory中所有的BeanPostProcessor类型的bean的名字
   String[] postProcessorNames = beanFactory.getBeanNamesForType(BeanPostProcessor.class, true, false);
   
   // 注册一个 BeanPostProcessorChecker，用来记录 bean 在 BeanPostProcessor 实例化时的信息。
   int beanProcessorTargetCount = beanFactory.getBeanPostProcessorCount() + 1 + postProcessorNames.length;
   beanFactory.addBeanPostProcessor(new BeanPostProcessorChecker(beanFactory, beanProcessorTargetCount));

   // 对所有的BeanPostProcessor根据实现不同的接口(PriorityOrdered,Ordered等)进行分离
   // 用于存放实现了PriorityOrdered.class的后处理器集合 
   List<BeanPostProcessor> priorityOrderedPostProcessors = new ArrayList<>();
   // 用于存放实现了PriorityOrdered.class并且是MergedBeanDefinitionPostProcessor类型的后处理器集合
   List<BeanPostProcessor> internalPostProcessors = new ArrayList<>();
   // 用于存放实现了Ordered.class的后处理器集合 
   List<String> orderedPostProcessorNames = new ArrayList<>();
   // 用于存放其它情况的后处理器集合 
   List<String> nonOrderedPostProcessorNames = new ArrayList<>();
   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);
      }
   }
   // 首先,注册实现了ProorityOrdered.class接口的BeanPostProcessor 
   // 排序
   sortPostProcessors(priorityOrderedPostProcessors, beanFactory);
   // 注册(将BeanPostProcessor加入到BeanFactory中beanFactory.addBeanPostProcessor(postProcessor)) 
   registerBeanPostProcessors(beanFactory, priorityOrderedPostProcessors);

   // 其次注册实现了Ordered.class接口的BeanPostProcessor 
   List<BeanPostProcessor> orderedPostProcessors = new ArrayList<>(orderedPostProcessorNames.size());
   for (String ppName : orderedPostProcessorNames) {
      BeanPostProcessor pp = beanFactory.getBean(ppName, BeanPostProcessor.class);
      orderedPostProcessors.add(pp);
      if (pp instanceof MergedBeanDefinitionPostProcessor) {
         internalPostProcessors.add(pp);
      }
   }
   sortPostProcessors(orderedPostProcessors, beanFactory);
   registerBeanPostProcessors(beanFactory, orderedPostProcessors);

   // 然后,注册剩余的所有普通的BeanPostProcessor
   List<BeanPostProcessor> nonOrderedPostProcessors = new ArrayList<>(nonOrderedPostProcessorNames.size());
   for (String ppName : nonOrderedPostProcessorNames) {
      BeanPostProcessor pp = beanFactory.getBean(ppName, BeanPostProcessor.class);
      nonOrderedPostProcessors.add(pp);
      if (pp instanceof MergedBeanDefinitionPostProcessor) {
         internalPostProcessors.add(pp);
      }
   }
   registerBeanPostProcessors(beanFactory, nonOrderedPostProcessors);

   // 最后,重新注册所有内部的BeanPostProcessor
   sortPostProcessors(internalPostProcessors, beanFactory);
   registerBeanPostProcessors(beanFactory, internalPostProcessors);

   //先删除再注册ApplicationListenerDetector（主要是为了移动到处理器链的末尾）
   beanFactory.addBeanPostProcessor(new ApplicationListenerDetector(applicationContext));
}

protected void registerListeners() {
    // 添加实现ApplicationListener作为侦听器的bean。
    // 不会影响其他侦听器，可以将它们添加为非bean。

    // 先注册静态指定的监听器
    for (ApplicationListener<?> listener : getApplicationListeners()) {
        getApplicationEventMulticaster().addApplicationListener(listener);
    }

    // 在事件多播器上添加监听 并没有执行
    String[] listenerBeanNames = getBeanNamesForType(ApplicationListener.class, true, false);
    for (String listenerBeanName : listenerBeanNames) {
        getApplicationEventMulticaster().addApplicationListenerBean(listenerBeanName);
    }

    // 发布早期的时间,并且将 earlyApplicationEvents 设置为空
    Set<ApplicationEvent> earlyEventsToProcess = this.earlyApplicationEvents;
    this.earlyApplicationEvents = null;
    if (!CollectionUtils.isEmpty(earlyEventsToProcess)) {
        for (ApplicationEvent earlyEvent : earlyEventsToProcess) {
            getApplicationEventMulticaster().multicastEvent(earlyEvent);
        }
    }
}

protected void finishRefresh() {
	// 清理缓存信息
	clearResourceCaches();

	// 初始化生命周期处理器
	initLifecycleProcessor();

	// 将刷新事件传播到生命周期处理器
	getLifecycleProcessor().onRefresh();

	// 发布容器刷新完毕事件到相应的监听器
	publishEvent(new ContextRefreshedEvent(this));

	// 略
	LiveBeansView.registerApplicationContext(this);
}

public class MyApplicationEvent extends ApplicationEvent {

	private static final long serialVersionUID = 5366526231219883438L;
	private String message;

	public MyApplicationEvent(Object source, String message) {
		super(source);
		this.message = message;
	}

	public String getMessage() {
		return message;
	}
}

@Component
public class MyApplicationListener implements ApplicationListener<MyApplicationEvent> {

	@Override
	public void onApplicationEvent(MyApplicationEvent event) {

		System.out.println("MyApplicationListener 收到消息: " + event.getMessage());

	}
}

@Component
public class MyAnnotationApplicationListener {

	@EventListener(classes = MyApplicationEvent.class)
	public void myApplicationEventListener(MyApplicationEvent event) {

		System.out.println("使用注解的方式, 收到事件: " + event.getMessage());
	}
}

public class Client {
    public static void main(String[] args) {
        //创建注解容器，入参为配置类
        AnnotationConfigApplicationContext context = new AnnotationConfigApplicationContext(Config.class);
        MyApplicationEvent event = new MyApplicationEvent(context,"呼叫。。。");
        context.publishEvent(event);
        //关闭容器
        context.close();
    }
}

protected void finishBeanFactoryInitialization(ConfigurableListableBeanFactory beanFactory) {
	// 初始化此上下文的转换服务
	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));
	}

	// 如果beanFactory之前没有注册嵌入值解析器，则注册默认的嵌入值解析器：主要用于注解属性值的解析。
	if (!beanFactory.hasEmbeddedValueResolver()) {
		beanFactory.addEmbeddedValueResolver(strVal -> getEnvironment().resolvePlaceholders(strVal));
	}

	// 初始化所有LoadTimeWeaverAware Bean实例对象
	String[] weaverAwareNames = beanFactory.getBeanNamesForType(LoadTimeWeaverAware.class, false, false);
	for (String weaverAwareName : weaverAwareNames) {
		getBean(weaverAwareName);
	}

	beanFactory.setTempClassLoader(null);

	// 冻结所有bean定义，注册的bean定义不会被修改或进一步后处理，因为马上要创建 Bean 实例对象了
	beanFactory.freezeConfiguration();

	// 实例化所有剩余（非懒加载）单例对象
	beanFactory.preInstantiateSingletons();
}

@Override
public void preInstantiateSingletons() throws BeansException {
	if (logger.isTraceEnabled()) {
		logger.trace("Pre-instantiating singletons in " + this);
	}

	// 创建beanDefinitionNames的副本beanNames用于后续的遍历，以允许init等方法注册新的bean定义
	List<String> beanNames = new ArrayList<>(this.beanDefinitionNames);

	// 所有非懒加载单例bean的初始化
	for (String beanName : beanNames) {
		// 获取合并后的bean定义信息
		RootBeanDefinition bd = getMergedLocalBeanDefinition(beanName);
		// bean定义对应的Bean实例：不是抽象类 && 是单例 && 不是懒加载
		if (!bd.isAbstract() && bd.isSingleton() && !bd.isLazyInit()) {
			// 判断beanName对应的bean是否为FactoryBean
			if (isFactoryBean(beanName)) {
				// 通过getBean(&beanName)拿到的是FactoryBean本身；
				// 通过getBean(beanName)拿到的是FactoryBean创建的Bean实例
				Object bean = getBean(FACTORY_BEAN_PREFIX + beanName);
				// 判断bean是否实现了FactoryBean
				if (bean instanceof FactoryBean) {
					final FactoryBean<?> factory = (FactoryBean<?>) bean;
					//判断是否需要立即创建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) {
						// 如果希望马上初始化，则通过beanName获取bean实例
						getBean(beanName);
					}
				}
			}
			else {
				// 如果beanName对应的bean不是FactoryBean，只是普通Bean，通过beanName获取bean实例
				getBean(beanName);
			}
		}
	}

	// 在所有bean实例化后，遍历所有beanName
	// 触发所有SmartInitializingSingleton实例化后后置处理器方法afterSingletonsInstantiated();
	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();
			}
		}
	}
}

protected RootBeanDefinition getMergedBeanDefinition(
		String beanName, BeanDefinition bd, @Nullable BeanDefinition containingBd)
		throws BeanDefinitionStoreException {

	synchronized (this.mergedBeanDefinitions) {
		RootBeanDefinition mbd = null;

		// 这里containingBd=null，所有，先从合并bean定义信息中获取
		if (containingBd == null) {
			mbd = this.mergedBeanDefinitions.get(beanName);
		}
		//获取不到
		if (mbd == null) {
			// 如果bd的parentName为空，代表bd没有父定义，无需与父定义进行合并操作，
			// 如果是RootBeanDefinition，则克隆一个；如果不是则new一个
			if (bd.getParentName() == null) {
				// Use copy of given root bean definition.
				if (bd instanceof RootBeanDefinition) {
					mbd = ((RootBeanDefinition) bd).cloneBeanDefinition();
				}
				else {
					mbd = new RootBeanDefinition(bd);
				}
			}
			else {
				// 存在父定义，需要与父定义合并
				BeanDefinition pbd;
				try {
					// 获取父定义的beanName,可能是别名
					String parentBeanName = transformedBeanName(bd.getParentName());
					// 如果父定义的beanName与该bean的beanName不同
					if (!beanName.equals(parentBeanName)) {
						// 获取父定义的MergedBeanDefinition（因为父定义也可能有父定义，也就是bd的爷爷定义...）
						// 递归调用获取合并bean定义信息
						pbd = getMergedBeanDefinition(parentBeanName);
					}
					else {
						// 如果父定义的beanName与bd的beanName相同
						// 只有在存在父BeanFactory的情况下，才允许父定义beanName与自己相同，否则就是将自己设置为父定义
						BeanFactory parent = getParentBeanFactory();
						if (parent instanceof ConfigurableBeanFactory) {
							// 如果父BeanFactory是ConfigurableBeanFactory，
							// 则通过父BeanFactory获取父定义的MergedBeanDefinition
							pbd = ((ConfigurableBeanFactory) parent).getMergedBeanDefinition(parentBeanName);
						}
						else {
							throw new NoSuchBeanDefinitionException(parentBeanName,
									"Parent name '" + parentBeanName + "' is equal to bean name '" + beanName +
									"': cannot be resolved without an AbstractBeanFactory parent");
						}
					}
				}
				catch (NoSuchBeanDefinitionException ex) {
					throw new BeanDefinitionStoreException(bd.getResourceDescription(), beanName,
							"Could not resolve parent bean definition '" + bd.getParentName() + "'", ex);
				}
				// 使用父定义pbd构建一个新的RootBeanDefinition对象
				mbd = new RootBeanDefinition(pbd);
				// 使用bd覆盖父定义
				mbd.overrideFrom(bd);
			}

			// 如果没有配置scope，则设置成默认的singleton
			if (!StringUtils.hasLength(mbd.getScope())) {
				mbd.setScope(RootBeanDefinition.SCOPE_SINGLETON);
			}

			// 这里 containingBd 为空
			if (containingBd != null && !containingBd.isSingleton() && mbd.isSingleton()) {
				mbd.setScope(containingBd.getScope());
			}

			// 将beanName与mbd放到mergedBeanDefinitions缓存，以便之后可以直接使用
			if (containingBd == null && isCacheBeanMetadata()) {
				this.mergedBeanDefinitions.put(beanName, mbd);
			}
		}

		return mbd;
	}
}

@Override
public boolean isFactoryBean(String name) throws NoSuchBeanDefinitionException {
	// 获取真正的beanName（去掉&前缀、解析别名）
	String beanName = transformedBeanName(name);
	// 尝试从缓存中获取bean
	Object beanInstance = getSingleton(beanName, false);
	if (beanInstance != null) {
		//存在，则判断类型是否为FactoryBean;
		return (beanInstance instanceof FactoryBean);
	}
	// No singleton instance found -> check bean definition.
	if (!containsBeanDefinition(beanName) && getParentBeanFactory() instanceof ConfigurableBeanFactory) {
		// 如果缓存中不存在此beanName && 父beanFactory是ConfigurableBeanFactory，则调用父BeanFactory判断是否为FactoryBean
		return ((ConfigurableBeanFactory) getParentBeanFactory()).isFactoryBean(name);
	}
	//通过MergedBeanDefinition来检查beanName对应的Bean是否为FactoryBean
	return isFactoryBean(beanName, getMergedLocalBeanDefinition(beanName));
}

protected <T> T doGetBean(final String name, @Nullable final Class<T> requiredType,
		@Nullable final Object[] args, boolean typeCheckOnly) throws BeansException {
	//解析beanName，主要是解析别名、去掉FactoryBean的前缀“&”
	final String beanName = transformedBeanName(name);
	Object bean;

	// 1、从缓存中获取beanName对应的实例
	Object sharedInstance = getSingleton(beanName);
	if (sharedInstance != null && args == null) {
		// 如果beanName的实例存在于缓存中
		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 + "'");
			}
		}
		// 2、返回beanName对应的实例对象（主要用于FactoryBean的特殊处理，普通Bean会直接返回sharedInstance本身）
		bean = getObjectForBeanInstance(sharedInstance, name, beanName, null);
	}

	else {
        // scope为prototype的循环依赖校验：如果beanName已经正在创建Bean实例中，
        // 而此时我们又要再一次创建beanName的实例，则代表出现了循环依赖，需要抛出异常。
        // 例子：如果存在A中有B的属性，B中有A的属性，那么当依赖注入的时候，
        // 就会产生当A还未创建完的时候因为对于B的创建再次返回创建A，造成循环依赖
		if (isPrototypeCurrentlyInCreation(beanName)) {
			throw new BeanCurrentlyInCreationException(beanName);
		}

		// 获取parentBeanFactory（父容器)
		BeanFactory parentBeanFactory = getParentBeanFactory();
		//如果parentBeanFactory存在，并且beanName在当前BeanFactory不存在Bean定义，
		//则尝试从parentBeanFactory中获取bean实例
		if (parentBeanFactory != null && !containsBeanDefinition(beanName)) {
			// 将别名解析成真正的beanName
			String nameToLookup = originalBeanName(name);
			if (parentBeanFactory instanceof AbstractBeanFactory) {
				return ((AbstractBeanFactory) parentBeanFactory).doGetBean(
						nameToLookup, requiredType, args, typeCheckOnly);
			}
			// 尝试在parentBeanFactory中获取bean对象实例
			else if (args != null) {
				return (T) parentBeanFactory.getBean(nameToLookup, args);
			}
			else if (requiredType != null) {
				return parentBeanFactory.getBean(nameToLookup, requiredType);
			}
			else {
				return (T) parentBeanFactory.getBean(nameToLookup);
			}
		}

		if (!typeCheckOnly) {
			// 如果不是仅仅做类型检测，而是创建bean实例，
			// 这里要将beanName放到alreadyCreated缓存,做记录
			markBeanAsCreated(beanName);
		}

		try {
			//将bean和父bean合并
			final RootBeanDefinition mbd = getMergedLocalBeanDefinition(beanName);
			//检查MergedBeanDefinition
			checkMergedBeanDefinition(mbd, beanName, args);

			// 拿到当前bean依赖的bean名称集合，在实例化自己之前，需要先实例化自己依赖的bean
			String[] dependsOn = mbd.getDependsOn();
			if (dependsOn != null) {
				//遍历当前bean依赖的bean名称集合
				for (String dep : dependsOn) {
					//3、检查dep是否依赖于beanName，即检查是否存在循环依赖
					if (isDependent(beanName, dep)) {
						//如果是循环依赖则抛异常
						throw new BeanCreationException(mbd.getResourceDescription(), beanName,
								"Circular depends-on relationship between '" + beanName + "' and '" + dep + "'");
					}
					//4、将dep和beanName的依赖关系注册到缓存中
					registerDependentBean(dep, beanName);
					try {
						//获取dep对应的bean实例，如果dep还没有创建bean实例，则创建dep的bean实例
						getBean(dep);
					}
					catch (NoSuchBeanDefinitionException ex) {
						throw new BeanCreationException(mbd.getResourceDescription(), beanName,
								"'" + beanName + "' depends on missing bean '" + dep + "'", ex);
					}
				}
			}

			// 针对不同的scope进行bean的创建
			if (mbd.isSingleton()) {
				//5、单例bean创建（新建了一个ObjectFactory，并且重写了getObject方法）
				sharedInstance = getSingleton(beanName, () -> {
					try {
						//3.5、创建Bean实例
						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;
					}
				});
				// 返回beanName对应的实例对象
				bean = getObjectForBeanInstance(sharedInstance, name, beanName, mbd);
			}

			else if (mbd.isPrototype()) {
				// 多例的bean创建
				Object prototypeInstance = null;
				try {
					// 6、创建实例前的操作（将beanName保存到prototypesCurrentlyInCreation缓存中）
					beforePrototypeCreation(beanName);
					// 创建Bean实例
					prototypeInstance = createBean(beanName, mbd, args);
				}
				finally {
					//创建实例后的操作（将创建完的beanName从prototypesCurrentlyInCreation缓存中移除）
					afterPrototypeCreation(beanName);
				}
				//beanName对应的实例对象
				bean = getObjectForBeanInstance(prototypeInstance, name, beanName, mbd);
			}

			else {
				// 其他scope的bean创建，可能是request之类的
                // 根据scopeName，从缓存拿到scope实例
				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 {
					//其他scope的bean创建（新建了一个ObjectFactory，并且重写了getObject方法）
					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;
		}
	}

	// 检查所需类型是否与实际的bean对象的类型匹配
	if (requiredType != null && !requiredType.isInstance(bean)) {
		try {
			// 类型不对，则尝试转换bean类型
			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;
}

//一级缓存（beanName->单例bean对象）单例对象的缓存
private final Map<String, Object> singletonObjects = new ConcurrentHashMap<>(256);
//二级缓存（beanName_>单例bean对象，对象还未进行属性填充、初始化）提前曝光的单例对象的缓存
//又称为早期单例对象，是因为earlySingletonObjects里的对象的都是通过提前曝光的ObjectFactory创建出来的，还未进行属性填充等操作
private final Map<String, Object> earlySingletonObjects = new HashMap<>(16);
//三级缓存（beanName->ObjectFactory 通过beanName获取单例bean工厂）单例对象工厂的缓存
private final Map<String, ObjectFactory<?>> singletonFactories = new HashMap<>(16);
//当前正在创建单例bean对象的beanName集合
private final Set<String> singletonsCurrentlyInCreation =
		Collections.newSetFromMap(new ConcurrentHashMap<>(16));

@Nullable
protected Object getSingleton(String beanName, boolean allowEarlyReference) {
	//从一级缓存获取单例对象
	Object singletonObject = this.singletonObjects.get(beanName);
    //如果一级缓存没有，并且该beanName对应的单例bean正在创建中
	if (singletonObject == null && isSingletonCurrentlyInCreation(beanName)) {
		synchronized (this.singletonObjects) {
			//尝试从二级缓存获取
			singletonObject = this.earlySingletonObjects.get(beanName);
            // 如果二级缓存也没有，并且允许bean对象提前曝光
			if (singletonObject == null && allowEarlyReference) {
                // 从三级缓存中获取beanName的单例工厂
				ObjectFactory<?> singletonFactory = this.singletonFactories.get(beanName);
				if (singletonFactory != null) {
                    // 如果存在单例对象工厂，则通过工厂创建一个单例对象
					singletonObject = singletonFactory.getObject();
                    // 将通过单例对象工厂创建的单例对象，放到二级缓存中
					this.earlySingletonObjects.put(beanName, singletonObject);
					// 移除该beanName对应的单例对象工厂
					// 因为该单例工厂已经创建了一个实例对象，并且放到二级缓存中
                    // 所以，后续获取beanName的单例对象，
                    // 可以通过二级缓存拿到，不需要在用到该单例工厂
					this.singletonFactories.remove(beanName);
				}
			}
		}
	}
	return singletonObject; //返回对象
}

protected Object getObjectForBeanInstance(
		Object beanInstance, String name, String beanName, @Nullable RootBeanDefinition mbd) {

	// 如果name以“&”为前缀，但是beanInstance不是FactoryBean，则抛异常
	if (BeanFactoryUtils.isFactoryDereference(name)) {
		if (beanInstance instanceof NullBean) {
			return beanInstance;
		}
		if (!(beanInstance instanceof FactoryBean)) {
			throw new BeanIsNotAFactoryException(beanName, beanInstance.getClass());
		}
	}

	// 如果beanInstance不是FactoryBean（也就是普通bean），则直接返回beanInstance
	// 或者
    // 如果beanInstance是FactoryBean，并且name以“&”为前缀，
    // 则直接返回beanInstance（以“&”为前缀代表想获取的是FactoryBean本身）
	if (!(beanInstance instanceof FactoryBean) || BeanFactoryUtils.isFactoryDereference(name)) {
		return beanInstance;
	}
	//走到这边，代表beanInstance是FactoryBean，但name不带有“&”前缀，
	//表示想要获取的是FactoryBean创建的对象实例
	Object object = null;
	if (mbd == null) {
		//这里mbd为空，则尝试从factoryBeanObjectCache缓存中获取该FactoryBean创建的对象实例
		object = getCachedObjectForFactoryBean(beanName);
	}
	if (object == null) {
		// 只有beanInstance是FactoryBean才能走到这边，因此直接强转
		FactoryBean<?> factory = (FactoryBean<?>) beanInstance;
		// mbd为空，但是该bean的BeanDefinition在缓存中存在，则获取该bean的MergedBeanDefinition
		if (mbd == null && containsBeanDefinition(beanName)) {
			mbd = getMergedLocalBeanDefinition(beanName);
		}
		//mbd是否是合成的（这个字段比较复杂，mbd正常情况都不是合成的，也就是false
		boolean synthetic = (mbd != null && mbd.isSynthetic());
		//2.1、从FactoryBean获取对象实例
		object = getObjectFromFactoryBean(factory, beanName, !synthetic);
	}
	return object;
}

private boolean isDependent(String beanName, String dependentBeanName, @Nullable Set<String> alreadySeen) {
	// alreadySeen这里是空，跳过
	if (alreadySeen != null && alreadySeen.contains(beanName)) {
		return false;
	}
	// 将别名解析为真正的名称
	String canonicalName = canonicalName(beanName);
	//获取依赖beanName的set集合
	Set<String> dependentBeans = this.dependentBeanMap.get(canonicalName);
	// 如果dependentBeans为空，则证明依赖beanName的为空，则dep不依赖bean，返回false
	if (dependentBeans == null) {
		return false;
	}
	// 如果依赖beanName的集合报告dep，则证明dep依赖beanName；则是循环依赖，返回true
	if (dependentBeans.contains(dependentBeanName)) {
		return true;
	}
	//循环检查，即检查依赖canonicalName的所有beanName是否存在被dependentBeanName依赖的（即隔层依赖）
	for (String transitiveDependency : dependentBeans) {
		if (alreadySeen == null) {
			alreadySeen = new HashSet<>();
		}
		//已经检查过的添加到alreadySeen，避免重复检查
		alreadySeen.add(beanName);
		if (isDependent(transitiveDependency, dependentBeanName, alreadySeen)) {
			return true;
		}
	}
	return false;
}

private final Map<String, Set<String>> dependentBeanMap = new ConcurrentHashMap<>(64);

/**
注意：beanName:依赖bean;dependentBeanName:注册bean
*/
public void registerDependentBean(String beanName, String dependentBeanName) {
	// 解析别名
	String canonicalName = canonicalName(beanName);

	synchronized (this.dependentBeanMap) {
		//创建一个dependentBeanMap缓存，key为这里的依赖bean：beanName
		Set<String> dependentBeans =
				this.dependentBeanMap.computeIfAbsent(canonicalName, k -> new LinkedHashSet<>(8));
		//set value如果失败，证明依赖关系已存在
		if (!dependentBeans.add(dependentBeanName)) {
			return;
		}
	}

	synchronized (this.dependenciesForBeanMap) {
		Set<String> dependenciesForBean =
				this.dependenciesForBeanMap.computeIfAbsent(dependentBeanName, k -> new LinkedHashSet<>(8));
		dependenciesForBean.add(canonicalName);
	}
}

public Object getSingleton(String beanName, ObjectFactory<?> singletonFactory) {
	Assert.notNull(beanName, "Bean name must not be null");
	// 加锁，避免重复创建单例对象
	synchronized (this.singletonObjects) {
		// 首先检查beanName对应的bean实例是否在缓存中存在，如果已经存在，则直接返回
		Object singletonObject = this.singletonObjects.get(beanName);
		if (singletonObject == null) {
			if (this.singletonsCurrentlyInDestruction) {
				// 缓存中不存在，且bean工厂的单例处于destruction状态时，不允许进行单例bean创建，报错
				throw new BeanCreationNotAllowedException(beanName,
						"Singleton bean creation not allowed while singletons of this factory are in destruction " +
						"(Do not request a bean from a BeanFactory in a destroy method implementation!)");
			}
			if (logger.isDebugEnabled()) {
				logger.debug("Creating shared instance of singleton bean '" + beanName + "'");
			}
			// 5.1 创建单例前的操作
			beforeSingletonCreation(beanName);
			boolean newSingleton = false;
			// 用于记录异常相关信息
			boolean recordSuppressedExceptions = (this.suppressedExceptions == null);
			if (recordSuppressedExceptions) {
				this.suppressedExceptions = new LinkedHashSet<>();
			}
			try {
				// 执行singletonFactory的getObject方法获取bean实例
				singletonObject = singletonFactory.getObject();
				// 标记为新的单例对象
				newSingleton = true;
			}
			catch (IllegalStateException ex) {
				//如果报错了，尝试从一级缓存中获取对象（已经不是新的单例对象了）
				singletonObject = this.singletonObjects.get(beanName);
				if (singletonObject == null) {
					throw ex;
				}
			}
			catch (BeanCreationException ex) {
				if (recordSuppressedExceptions) {
					for (Exception suppressedException : this.suppressedExceptions) {
						ex.addRelatedCause(suppressedException);
					}
				}
				throw ex;
			}
			finally {
				if (recordSuppressedExceptions) {
					this.suppressedExceptions = null;
				}
				// 5.2、创建单例后的操作
				afterSingletonCreation(beanName);
			}
			if (newSingleton) {
				// 5.3、如果是新的单例对象，将beanName和对应的bean实例添加到缓存中
				addSingleton(beanName, singletonObject);
			}
		}
		return singletonObject;
	}
}

protected void beforeSingletonCreation(String beanName) {
	// 先校验beanName是否为要在创建检查排除掉的（inCreationCheckExclusions缓存），如果不是，
	// 则将beanName加入到正在创建bean的缓存中（Set），如果beanName已经存在于该缓存，会返回false抛出异常（这种情况出现在构造器的循环依赖）
	if (!this.inCreationCheckExclusions.contains(beanName) && !this.singletonsCurrentlyInCreation.add(beanName)) {
		throw new BeanCurrentlyInCreationException(beanName);
	}
}

protected void afterSingletonCreation(String beanName) {
	// 先校验beanName是否为要在创建检查排除掉的（inCreationCheckExclusions缓存），如果不是，
	// 则将beanName从正在创建bean的缓存中（Set）移除，如果beanName不存在于该缓存，会返回false抛出异常
	if (!this.inCreationCheckExclusions.contains(beanName) && !this.singletonsCurrentlyInCreation.remove(beanName)) {
		throw new IllegalStateException("Singleton '" + beanName + "' isn't currently in creation");
	}
}

protected void addSingleton(String beanName, Object singletonObject) {
	synchronized (this.singletonObjects) {
		// 添加一级缓存（单例缓存对象）
		this.singletonObjects.put(beanName, singletonObject);
		// 删除三级缓存/单例工厂缓存（已经不需要）
		this.singletonFactories.remove(beanName);
		// 删除二级缓存/早期单例缓存，没有属性填充（已经不需要）
		this.earlySingletonObjects.remove(beanName);
		// 添加到已经注册的单例对象缓存
		this.registeredSingletons.add(beanName);
	}
}

protected void beforePrototypeCreation(String beanName) {
	// 获取当前线程中正在创建的prototype的bean的beanName集合
	Object curVal = this.prototypesCurrentlyInCreation.get();
	// 如果为空，则将ThreadLocal设置成当前的beanName
	if (curVal == null) {
		this.prototypesCurrentlyInCreation.set(beanName);
	}
	// 如果不为空，并且是String类型，则代表目前只有一个beanName，
	// 将之前和当前的一起封装成Set<String>，设置到ThreadLocal中
	else if (curVal instanceof String) {
		Set<String> beanNameSet = new HashSet<>(2);
		beanNameSet.add((String) curVal);
		beanNameSet.add(beanName);
		this.prototypesCurrentlyInCreation.set(beanNameSet);
	}
	else {
		// 如果不为空，并且不是String，则必然是Set<String>类型，将当前的beanName加到Set中去
		Set<String> beanNameSet = (Set<String>) curVal;
		beanNameSet.add(beanName);
	}
}

protected void afterPrototypeCreation(String beanName) {
	// 拿到当前线程中正在创建的prototype的bean的beanName集合
	Object curVal = this.prototypesCurrentlyInCreation.get();
	//如果是String类型，则代表目前只有一个beanName，则直接移除
	if (curVal instanceof String) {
		this.prototypesCurrentlyInCreation.remove();
	}
	else if (curVal instanceof Set) {
		// 如果是Set类型，则从Set从移除beanName
		Set<String> beanNameSet = (Set<String>) curVal;
		beanNameSet.remove(beanName);
		if (beanNameSet.isEmpty()) {
			this.prototypesCurrentlyInCreation.remove();
		}
	}
}

@Override
protected Object createBean(String beanName, RootBeanDefinition mbd, @Nullable Object[] args)
		throws BeanCreationException {

	if (logger.isTraceEnabled()) {
		logger.trace("Creating instance of bean '" + beanName + "'");
	}
	RootBeanDefinition mbdToUse = mbd;

	// 解析beanName对应的Bean的类型
	Class<?> resolvedClass = resolveBeanClass(mbd, beanName);
	if (resolvedClass != null && !mbd.hasBeanClass() && mbd.getBeanClassName() != null) {
        // 如果resolvedClass存在，并且mdb的beanClass类型不是Class，并且mdb的beanClass不为空（则代表beanClass存的是Class的name）,
        // 则使用mdb深拷贝一个新的RootBeanDefinition副本，并且将解析的Class赋值给拷贝的RootBeanDefinition副本的beanClass属性，
        // 该拷贝副本取代mdb用于后续的操作
		mbdToUse = new RootBeanDefinition(mbd);
		mbdToUse.setBeanClass(resolvedClass);
	}

	// 验证及准备覆盖的方法（对override属性进行标记及验证）
	try {
		mbdToUse.prepareMethodOverrides();
	}
	catch (BeanDefinitionValidationException ex) {
		throw new BeanDefinitionStoreException(mbdToUse.getResourceDescription(),
				beanName, "Validation of method overrides failed", ex);
	}

	try {
        // 1、实例化前的处理，给InstantiationAwareBeanPostProcessor一个机会返回代理对象来替代真正的bean实例，动态代理
		Object bean = resolveBeforeInstantiation(beanName, mbdToUse);
		if (bean != null) {
			return bean;
		}
	}
	catch (Throwable ex) {
		throw new BeanCreationException(mbdToUse.getResourceDescription(), beanName,
				"BeanPostProcessor before instantiation of bean failed", ex);
	}

	try {
		// 创建Bean实例（真正创建Bean的方法）
		Object beanInstance = doCreateBean(beanName, mbdToUse, args);
		if (logger.isTraceEnabled()) {
			logger.trace("Finished creating instance of bean '" + beanName + "'");
		}
		return beanInstance;
	}
	catch (BeanCreationException | ImplicitlyAppearedSingletonException ex) {
		// A previously detected exception with proper bean creation context already,
		// or illegal singleton state to be communicated up to DefaultSingletonBeanRegistry.
		throw ex;
	}
	catch (Throwable ex) {
		throw new BeanCreationException(
				mbdToUse.getResourceDescription(), beanName, "Unexpected exception during bean creation", ex);
	}
}

@Nullable
protected Object resolveBeforeInstantiation(String beanName, RootBeanDefinition mbd) {
	Object bean = null;
	if (!Boolean.FALSE.equals(mbd.beforeInstantiationResolved)) {
		// mbd不是合成的，并且BeanFactory中存在InstantiationAwareBeanPostProcessor（实例化前后后置处理器）
		if (!mbd.isSynthetic() && hasInstantiationAwareBeanPostProcessors()) {
			// 解析beanName对应的Bean实例的类型
			Class<?> targetType = determineTargetType(beanName, mbd);
			if (targetType != null) {
				// 1.1、实例化前的后置处理器应用（处理InstantiationAwareBeanPostProcessor）
				bean = applyBeanPostProcessorsBeforeInstantiation(targetType, beanName);
				if (bean != null) {
					// 如果返回的bean不为空，会跳过Spring默认的实例化过程，
					// 所以只能在这里调用BeanPostProcessor实现类的postProcessAfterInitialization方法
					bean = applyBeanPostProcessorsAfterInitialization(bean, beanName);
				}
			}
		}
		// 如果bean不为空，则将beforeInstantiationResolved赋值为true，代表在实例化之前已经解析
		mbd.beforeInstantiationResolved = (bean != null);
	}
	return bean;
}

@Nullable
protected Object applyBeanPostProcessorsBeforeInstantiation(Class<?> beanClass, String beanName) {
	// 遍历当前BeanFactory中所有的后置处理器
	for (BeanPostProcessor bp : getBeanPostProcessors()) {
		// 如果InstantiationAwareBeanPostProcessor或其子类
		if (bp instanceof InstantiationAwareBeanPostProcessor) {
			InstantiationAwareBeanPostProcessor ibp = (InstantiationAwareBeanPostProcessor) bp;
			// 执行postProcessBeforeInstantiation方法，在Bean实例化前操作，
			Object result = ibp.postProcessBeforeInstantiation(beanClass, beanName);
			if (result != null) {
				return result;
			}
		}
	}
	return null;
}

protected Object doCreateBean(final String beanName, final RootBeanDefinition mbd, final @Nullable Object[] args)
		throws BeanCreationException {

	// 新建Bean包装类
	BeanWrapper instanceWrapper = null;
	if (mbd.isSingleton()) {
		// 如果是FactoryBean，则需要先移除未完成的FactoryBean实例的缓存
		instanceWrapper = this.factoryBeanInstanceCache.remove(beanName);
	}
	if (instanceWrapper == null) {
		// 2.1、根据beanName、mbd、args，使用对应的策略创建Bean实例，并返回包装类BeanWrapper
		instanceWrapper = createBeanInstance(beanName, mbd, args);
	}
	// 拿到创建好的Bean实例
	final Object bean = instanceWrapper.getWrappedInstance();
	// 拿到Bean实例的类型
	Class<?> beanType = instanceWrapper.getWrappedClass();
	if (beanType != NullBean.class) {
		mbd.resolvedTargetType = beanType;
	}

	// 允许后置处理器修改合并bean的定义信息
	synchronized (mbd.postProcessingLock) {
		if (!mbd.postProcessed) {
			try {
				// 2.2、应用后置处理器MergedBeanDefinitionPostProcessor，允许修改MergedBeanDefinition，
				// Autowired注解正是通过此方法实现注入类型的预解析
				applyMergedBeanDefinitionPostProcessors(mbd, beanType, beanName);
			}
			catch (Throwable ex) {
				throw new BeanCreationException(mbd.getResourceDescription(), beanName,
						"Post-processing of merged bean definition failed", ex);
			}
			mbd.postProcessed = true;
		}
	}

	// 判断是否需要提早曝光实例：单例 && 允许循环依赖 && 当前bean正在创建中
	boolean earlySingletonExposure = (mbd.isSingleton() && this.allowCircularReferences &&
			isSingletonCurrentlyInCreation(beanName));
	if (earlySingletonExposure) {
		if (logger.isTraceEnabled()) {
			logger.trace("Eagerly caching bean '" + beanName +
					"' to allow for resolving potential circular references");
		}
		// 2.3、提前曝光beanName的ObjectFactory，用于解决循环引用
		// 应用后置处理器SmartInstantiationAwareBeanPostProcessor，
		// 允许返回指定bean的早期引用，若没有则直接返回bean
		// 2.4、getEarlyBeanReference();获取对指定bean的早期访问的引用
		addSingletonFactory(beanName, () -> getEarlyBeanReference(beanName, mbd, bean));
	}

	// 初始化bean实例
	Object exposedObject = bean;
	try {
		// 2.5、对bean进行属性填充；其中，可能存在依赖于其他bean的属性，则会递归初始化依赖的bean实例
		populateBean(beanName, mbd, instanceWrapper);
		// 2.6、初始化beanName
		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);
		// earlySingletonReference只有在当前解析的bean存在循环依赖的情况下才会不为空
		if (earlySingletonReference != null) {
			if (exposedObject == bean) {
				// 如果exposedObject没有在initializeBean方法中被增强，则不影响之前的循环引用
				exposedObject = earlySingletonReference;
			}
			else if (!this.allowRawInjectionDespiteWrapping && hasDependentBean(beanName)) {
                // 如果exposedObject在initializeBean方法中被增强 
                // && 不允许在循环引用的情况下使用注入原始bean实例
                // && 当前bean有被其他bean依赖

				// 拿到依赖当前bean的所有bean的beanName数组
				String[] dependentBeans = getDependentBeans(beanName);
				Set<String> actualDependentBeans = new LinkedHashSet<>(dependentBeans.length);
				for (String dependentBean : dependentBeans) {
					// 尝试移除这些bean的实例，因为这些bean依赖的bean已经被增强了，他们依赖的bean相当于脏数据
					if (!removeSingletonIfCreatedForTypeCheckOnly(dependentBean)) {
						//移除失败的添加到 actualDependentBeans
						actualDependentBeans.add(dependentBean);
					}
				}
				if (!actualDependentBeans.isEmpty()) {
					// 如果存在移除失败的，则抛出异常，因为存在bean依赖了“脏数据”
					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 {
	    //注册用于销毁的bean，执行销毁操作的有三种：
	    //自定义destroy方法、
	    //DisposableBean接口、
	    //DestructionAwareBeanPostProcessor
		registerDisposableBeanIfNecessary(beanName, bean, mbd);
	}
	catch (BeanDefinitionValidationException ex) {
		throw new BeanCreationException(
				mbd.getResourceDescription(), beanName, "Invalid destruction signature", ex);
	}
	// 完成创建并返回
	return exposedObject;
}

protected BeanWrapper createBeanInstance(String beanName, RootBeanDefinition mbd, @Nullable Object[] args) {
	// 解析bean的Class类型信息
	Class<?> beanClass = resolveBeanClass(mbd, beanName);
	// 确保class不为空，并且访问权限是public
	if (beanClass != null && !Modifier.isPublic(beanClass.getModifiers()) && !mbd.isNonPublicAccessAllowed()) {
		throw new BeanCreationException(mbd.getResourceDescription(), beanName,
				"Bean class isn't public, and non-public access not allowed: " + beanClass.getName());
	}
	// 2.1.1、通过Supplier实例化
	Supplier<?> instanceSupplier = mbd.getInstanceSupplier();
	if (instanceSupplier != null) {
		return obtainFromSupplier(instanceSupplier, beanName);
	}

	// 2.1.2、通过工厂方法实例化
	if (mbd.getFactoryMethodName() != null) {
		return instantiateUsingFactoryMethod(beanName, mbd, args);
	}

	// 构造函数或工厂方法是否已经解析过标记
	boolean resolved = false;
	// 是否需要自动注入（即是否需要解析构造函数参数）
	boolean autowireNecessary = false;
	if (args == null) {
		synchronized (mbd.constructorArgumentLock) {
			if (mbd.resolvedConstructorOrFactoryMethod != null) {
				// 如果resolvedConstructorOrFactoryMethod缓存不为空，则将resolved标记为已解析
				resolved = true;
				// 根据constructorArgumentsResolved判断是否需要自动注入
				autowireNecessary = mbd.constructorArgumentsResolved;
			}
		}
	}
	// 如果已经解析过，则使用resolvedConstructorOrFactoryMethod缓存里解析好的构造函数方法
	if (resolved) {
		if (autowireNecessary) {
			// 2.1.3、需要自动注入，则执行构造函数自动注入
			return autowireConstructor(beanName, mbd, null, null);
		}
		else {
			// 2.1.4、否则使用默认的构造函数进行bean的实例化
			return instantiateBean(beanName, mbd);
		}
	}

	// 2.1.5、应用后置处理器SmartInstantiationAwareBeanPostProcessor，拿到bean的候选构造函数
	Constructor<?>[] ctors = determineConstructorsFromBeanPostProcessors(beanClass, beanName);
	if (ctors != null || mbd.getResolvedAutowireMode() == AUTOWIRE_CONSTRUCTOR ||
			mbd.hasConstructorArgumentValues() || !ObjectUtils.isEmpty(args)) {
		 //如果ctors不为空 || mbd的注入方式为AUTOWIRE_CONSTRUCTOR 
		 // || mdb定义了构造函数的参数值 || args不为空，则执行构造函数自动注入
		return autowireConstructor(beanName, mbd, ctors, args);
	}

	// 找出最合适的默认构造方法
	ctors = mbd.getPreferredConstructors();
	if (ctors != null) {
		 构造函数自动注入
		return autowireConstructor(beanName, mbd, ctors, null);
	}

	// 没有特殊处理，则使用默认的构造函数进行bean的实例化
	return instantiateBean(beanName, mbd);
}