创建spring 应用上下文
new AnnotationConfigApplicationContext(AsyncConfig.class);
使用AnnotationConfigApplicationContext创建bean
public AnnotationConfigApplicationContext(Class<?>... componentClasses) {
// 调用本类的构造函数，创建默认的Bean工厂DefaultListableBeanFactory
// 初始化内置的一些后置处理器【包括：用来解析常用注解@Resource，@Autowired，@Configuration等注解的后置处理器】
// 初始化Spring容器所需的环境信息对象Environment及资源加载器对象ResourceLoader，还会初始化配置文件解析器
this();
// 解析配置类并将配置类封装为一个bean定义注册到Bean定义注册中心
register(componentClasses);
// 执行刷新的容器操作
refresh();
}
public AnnotationConfigApplicationContext() {
/** 1.使用父类GenericApplicationContext创建默认的Bean工厂: DefaultListableBeanFactory */
/**
* 2.初始化默认的Bean定义读取器，该步骤也会给容器中注册用来处理Spring注解的后置处理器.
* 创建conditionEvaluator， 初始化用于处理条件注解的对象，
*
* 该步骤中会向容器中注入以下几个比较重要的后置处理器：
* (1) ConfigurationClassPostProcessor(本质是一个BeanFactoryPostProcessor): 用来处理JavaConfig配置类的后置处理器，包括JavaConfig配置类中注解的解析及处理操作
* (2) AutowiredAnnotationBeanPostProcessor: 用来处理@Autowired和@Value注解
* (3) CommonAnnotationBeanPostProcessor: 提供对JSR-250规范注解的支持@javax.annotation.Resource、
* @javax.annotation.PostConstruct 和 @javax.annotation.PreDestroy等的支持。
* (4) EventListenerMethodProcessor：提供对@PersistenceContext的支持
* (5) DefaultEventListenerFactory: 提供对@EventListener的支持
*/
this.reader = new AnnotatedBeanDefinitionReader(this);
/**
* 3.初始化默认的Bean定义扫描器，在ClassPathBeanDefinitionScanner的构造中，会初始化配置文件解析器
*
* 初始化CandidateComponentsIndexLoader对象，用来按照索引加载bean定义
*/
this.scanner = new ClassPathBeanDefinitionScanner(this);
}
<T> void doRegisterBean(Class<T> beanClass, @Nullable Supplier<T> instanceSupplier, @Nullable String name,
@Nullable Class<? extends Annotation>[] qualifiers, BeanDefinitionCustomizer... definitionCustomizers) {
// 实例化注解格式的Bean定义。其中包括设置bean的类型以及初始化用于获取类注解信息的元数据对象
AnnotatedGenericBeanDefinition abd = new AnnotatedGenericBeanDefinition(beanClass);
/**
* 根据类上面的注解元数据信息，判断注册过程是否需要跳过当前的bean，如果配置类上面未标注@Conditional注解，会返回false。不会跳过
*
* conditionEvaluator默认实现类为ConditionEvaluator
*
* abd.getMetadata获取到的MedataData类型为 StandardAnnotationMetaData
*/
// 如果当前配置类上没有标注@Conditional注解，返回false
if (this.conditionEvaluator.shouldSkip(abd.getMetadata())) {
return;
}
/***
// 1.supplier 使用:
Supplier<Integer> supplier = new Supplier<Integer>() {
@Override
public Integer get() {
return new Random().nextInt();
}
};
Integer result = supplier.get();
// 2. lambda表达式形式
supplier = () -> new Random().nextInt();
result = supplier.get();
*/
// 给Bean定义中注册回调supplier回调方法
abd.setInstanceSupplier(instanceSupplier);
// 默认实现类为：AnnotationScopeMetadataResolver，解析@Scope注解的元信息
ScopeMetadata scopeMetadata = this.scopeMetadataResolver.resolveScopeMetadata(abd);
// 设置bean的作用域，未设置默认为'singleton'
abd.setScope(scopeMetadata.getScopeName());
// 获取Bean的名称。如果传入的name为null。则使用默认的Bean Name生成器AnnotationBeanNameGenerator生成bean的名称.根据内省操作获取的bean名称.
String beanName = (name != null ? name : this.beanNameGenerator.generateBeanName(abd, this.registry));
// 解析公共注解上面的元数据信息 例如：@DependsOn， @Lazy，@Primary，@DependsOn，@Description
AnnotationConfigUtils.processCommonDefinitionAnnotations(abd);
// 如果使用new AnnotationConfigApplicationContext(Class<?> clazz)创建的bean容器，
// 则此处的qualifiers和下面的definitionCustomizers都默认为null
if (qualifiers != null) {
for (Class<? extends Annotation> qualifier : qualifiers) {
if (Primary.class == qualifier) {
abd.setPrimary(true);
}
else if (Lazy.class == qualifier) {
abd.setLazyInit(true);
}
else {
abd.addQualifier(new AutowireCandidateQualifier(qualifier));
}
}
}
for (BeanDefinitionCustomizer customizer : definitionCustomizers) {
customizer.customize(abd);
}
// 用来保存Bean的定义。包括bean的名称，定义及别名信息
BeanDefinitionHolder definitionHolder = new BeanDefinitionHolder(abd, beanName);
// 设置bean定义的作用域模式，如果为ScopedProxyMode.NO，直接返回.
definitionHolder = AnnotationConfigUtils.applyScopedProxyMode(scopeMetadata, definitionHolder, this.registry);
// 真正完成配置类bean定义的注册。将bean定义注册到bean定义注册中心，即：BeanDefinitionRegistry中
// this.registry即AnnotationConfigApplicationContext对象
BeanDefinitionReaderUtils.registerBeanDefinition(definitionHolder, this.registry);
}
refresh方法
执行刷新的容器操作 -核心代码
public void refresh() throws BeansException, IllegalStateException {
synchronized (this.startupShutdownMonitor) {
/**
* 1.准备上下文的刷新工作，记录bean容器的启动时间，容器活跃状态
* 验证系统中一些属性和属性值的设置等.
* 使用LinkedHashSet初始化earlyApplicationListeners和earlyApplicationEvents
*/
prepareRefresh();
/**
* 2.获取Bean工厂，期间会做解析和加载bean定义的一系列工作.生成BeanDefinition对象.
* 此处返回的beanFactory的真实类型为：DefaultListableBeanFactory
*
*/
ConfigurableListableBeanFactory beanFactory = obtainFreshBeanFactory();
/**
* 3.bean工厂的初始化准备工作，设置bean工厂的一些属性
* 比如：创建bean工厂时，需要忽略哪些接口，需要注册哪些bean，需要设置哪些Bean的后置处理器等.
*
* 例如常用的：ApplicationContextAwareBeanPostProcessor, ApplicationListenerDetector
*
* 此外，注册一些和环境相关的bean单实例bean.
*/
prepareBeanFactory(beanFactory);
try {
/**
* 4.Bean定义加载完毕之后实现，目前方法为空实现，留给开发人员进行自定义扩展。
*
* 该方法在Bean定义加载完毕之后，Bean实例化之前会执行
* 比如在BeanFactory加载完所有的Bean定义之后，想要修改某个bean的定义信息，可以通过重写这个方法实现.
*/
postProcessBeanFactory(beanFactory);
/**
* 5.执行beanFactory的后置处理器
*BeanFactoryPostProcessor:
* 功能: 允许我们在 Spring 容器实例化任何 bean 之前读取 bean 的定义 (BeanDefinition) 并进行修改。
* 作用时机: 在所有的 bean 定义都被加载、但 bean 实例还未创建的时候执行。
* 常见应用: 修改已加载到容器中的 bean 定义的属性，例如更改某个 bean 的作用域、属性值等。
* BeanDefinitionRegistryPostProcessor:
* 功能: 扩展了 BeanFactoryPostProcessor，提供了一个新的方法来修改应用程序的上下文的 bean 定义。此外，还可以动态注册新的 bean 定义。
* 作用时机: 它也是在所有 bean 定义被加载后执行，但在 BeanFactoryPostProcessor 之前。
* 常见应用: 动态注册新的 bean 定义、修改或移除已有的 bean 定义。
*
* 先执行BeanDefinitionRegistryPostProcessor接口的实现类的postProcessBeanDefinitionRegistry方法，
* 执行过程中，也是先执行实现了优先级接口PriorityOrdered的BeanDefinitionRegistryPostProcessor的postProcessBeanDefinitionRegistry方法
* 然后执行实现了Ordered接口的...
* 最后执行未实现PriorityOrdered接口和Ordered接口的...
*
* 然后执行BeanFactoryPostProcessor接口的实现类的postProcessBeanFactory方法
* 执行过程中，也是先执行实现了优先级接口PriorityOrdered的BeanFactoryPostProcessor的postProcessBeanFactory方法
* 然后执行实现了Ordered接口的...
* 最后执行未实现PriorityOrdered接口和Ordered接口的...
*
* 其中也涉及到了排序过程
*
*
* 配置类中的Selector类型的组件和@Component,@ComponentScan中的元数据信息也会在该步骤中进行解析
* 还包括执行条件注解@Condition的回调逻辑
*
*
* ImportBeanDefinitionRegistrar对应的registerBeanDefinitions方法也会在该步骤中调用，给容器中注册自定义的组件.
*/
invokeBeanFactoryPostProcessors(beanFactory);
/**
* 6.注册所有bean的后置处理器.用来拦截Bean的创建
*
* 注册所有实现了BeanPostProcessor接口的后置处理器
* 执行过程中，也是先执行实现了优先级接口PriorityOrdered接口的BeanPostProcessor的addBeanPostProcessor方法
* 然后执行实现了Ordered接口的...
* 最后执行未实现PriorityOrdered接口和Ordered接口的...
*
* 其中也涉及到了排序过程
*/
registerBeanPostProcessors(beanFactory);
/**
* 7.初始化消息源
* 用来做国际化，消息绑定，消息解析等功能
* 一般在SpringMVC中会使用到.
*/
initMessageSource();
/**
* 8.初始化事件派发器，用来发布事件
* 如果容器中有类型为ApplicationEventMulticaster的派发器组件，则直接获取使用
* 如果容器中没有，则默认创建一个类型为SimpleApplicationEventMulticaster的派发器，供容器派发事件使用
*/
initApplicationEventMulticaster();
/**
* 9.用来初始化一些特殊的Bean，目前默认是空方法，未实现，可以通过继承AbstractApplicationContext类，
* 然后覆写该方法进行自定义特殊bean的初始化.
*
* 比如：AbstractRefreshableWebApplicationContext中onRefresh方法用来初始化主题能力.
*
* SpringBoot在该步骤中启动内嵌Tomcat容器的
*
*/
onRefresh();
/**
* 10.注册监听器
* 将监听器绑定到广播器上，将监听器对应的beanName绑定到到第8步初始化的事件派发器中，
* 如果之前有发布的事件，则直接通过事件派发器将事件派发出去.
*/
registerListeners();
/**
* 11.初始化所有剩余的单实例Bean(没有使用懒加载的Bean).整个Spring IOC的核心.
*
* 包括执行@PostConstruct标注的方法.
*
* 注意：SpringMVC的父子容器创建Bean的过程：
* SpringMVC中，存在着父容器和子容器。当父容器启动之后，会通过该方法将所有的Dao和Service对应的Bean创建出来，保存到beanFactory的单例缓存容器中
* 当子容器启动之后，也会通过该方法将所有的Controller，viewResolver，HandlerMapping对应的Bean创建出来，然后放入到beanFactory的单例缓存容器中.
*/
finishBeanFactoryInitialization(beanFactory);
/** 12.发布事件。例如容器中的刷新事件:ContextRefreshedEvent就是在这一步中发布. SpringCloud在该步骤中会启动web服务 */
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.
// 清空单实例bean对应的map及缓存
destroyBeans();
// 设置容器的活跃状态为false
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();
}
}
}
prepareRefresh-准备上下文的刷新工作
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());
}
}
// Initialize any placeholder property sources in the context environment.
/**
* 如果需要在验证系统属性之前，给系统中设置一些默认值。可以通过继承AbstractApplicationContext类，并重写该方法实现。
* Spring留给开发人员的一个扩展点.
*
* 例如子类在方法中设置环境属性中必须需要的变量：getEnvironment().setRequiredProperties("myProp");
*/
initPropertySources();
// Validate that all properties marked as required are resolvable:
// see ConfigurablePropertyResolver#setRequiredProperties
/**
* 作用：校验设置的必须属性是否能够在系统环境中找到对应的值
*
* 如果在initPropertySources方法中使用getEnvironment().setRequiredProperties(String... keys)设置了必须的属性，而通过this.getProperty(key)
* 没有从系统环境中获取到属性的值，则会抛出MissingRequiredPropertiesException异常
*/
getEnvironment().validateRequiredProperties();
// Store pre-refresh ApplicationListeners...
if (this.earlyApplicationListeners == null) {
/** 在SpringBoot中会有大量的初始化监听器，用于初始化使用 */
this.earlyApplicationListeners = new LinkedHashSet<>(this.applicationListeners);
}
else {
// Reset local application listeners to pre-refresh state.
this.applicationListeners.clear();
this.applicationListeners.addAll(this.earlyApplicationListeners);
}
// Allow for the collection of early ApplicationEvents,
// to be published once the multicaster is available...
/** 定义早期的应用事件 */
this.earlyApplicationEvents = new LinkedHashSet<>();
}
obtainFreshBeanFactory-获取Bean工厂，期间会做解析和加载bean定义的一系列工作
protected ConfigurableListableBeanFactory obtainFreshBeanFactory() {
/**
* 刷新bean工厂，判断bean工厂是否已经存在，如果存在需要进行销毁和关闭
* 默认调用的是AbstractRefreshableApplicationContext的refreshBeanFactory方法.
* 刷新Bean工厂时会进行bean定义的加载操作。
*/
refreshBeanFactory();
// 这个方法是本类中定义的一个抽象方法，是一个模板方法，具体的实现在子类中
return getBeanFactory();
}
protected final void refreshBeanFactory() throws BeansException {
// 判断bean工厂是否存在，如果存在需要先销毁和关闭。否则会出现问题
if (hasBeanFactory()) {
// 销毁bean，根据bean的名称将bean工厂中的所有bean都从map中移除
destroyBeans();
// 关闭bean工厂，设置Bean工厂的序列化id为null，并将beanFactory的值赋值为null
closeBeanFactory();
}
try {
// 重新创建bean工厂，默认返回的是Bean工厂类型是：DefaultListableBeanFactory
DefaultListableBeanFactory beanFactory = createBeanFactory();
// 设置序列化ID，ID: class名称 + "@" + 对象的十六进制值
beanFactory.setSerializationId(getId());
// 定制bean工厂。作用：设置bean定义是否可以被覆盖以及设置bean在创建的时候是否允许循环引用.
customizeBeanFactory(beanFactory);
// 解析并加载bean的定义，默认是通过AbstractXmlApplicationContext类中的loadBeanDefinitions实现
loadBeanDefinitions(beanFactory);
synchronized (this.beanFactoryMonitor) {
this.beanFactory = beanFactory;
}
}
catch (IOException ex) {
throw new ApplicationContextException("I/O error parsing bean definition source for " + getDisplayName(), ex);
}
}
prepareBeanFactory--bean工厂的初始化准备工作，设置bean工厂的一些属性
protected void prepareBeanFactory(ConfigurableListableBeanFactory beanFactory) {
// Tell the internal bean factory to use the context's class loader etc.
beanFactory.setBeanClassLoader(getClassLoader());
// 设置SPEL表达式解析器，用来支持Spring的SPEL表达式
beanFactory.setBeanExpressionResolver(new StandardBeanExpressionResolver(beanFactory.getBeanClassLoader()));
// 添加属性编辑注册器。例如一个字符串类型的地址需要转换为一个Address对象，可以使用该功能.
// 可参考示例：spring-source-study模块下的com.wb.spring.propertyeditor包下的示例程序
beanFactory.addPropertyEditorRegistrar(new ResourceEditorRegistrar(this, getEnvironment()));
// 添加bean的后置处理器。此处添加的是Spring自己的后置处理器，用来回调bean所实现的aware接口中的方法.
beanFactory.addBeanPostProcessor(new ApplicationContextAwareProcessor(this));
// 下面的ignoreDependencyInterface是用来设置bean工厂中需要忽略的接口
// 可以通过实现EnvironmentAware接口来获取到当前的环境信息Environment。
/**
* 如果将EnvironmentAware接口添加到ignoreDependencyInterface中，则在使用的地方通过@Autowired将会无法正常注入
* 而是需要通过setEnvironment方法进行注入，下面的其他接口都类似.
*/
beanFactory.ignoreDependencyInterface(EnvironmentAware.class);
// 可以通过实现EmbeddedValueResolverAware接口来获取String类型值的解析器
beanFactory.ignoreDependencyInterface(EmbeddedValueResolverAware.class);
// 资源加载器，例如使用：@Autowired ResourceLoaderAware aware; 将不会被注入
beanFactory.ignoreDependencyInterface(ResourceLoaderAware.class);
// 事件发布器
beanFactory.ignoreDependencyInterface(ApplicationEventPublisherAware.class);
// 消息资源
beanFactory.ignoreDependencyInterface(MessageSourceAware.class);
// 应用的上下文信息
beanFactory.ignoreDependencyInterface(ApplicationContextAware.class);
// 注册一些可以自动装配的接口。 当类型为dependencyType时， 注入autowiredValue。为了解决一个类型有多个子类实现时，优先注入那个子类实现的问题。
// 例如下面第一个，当注入类型为BeanFactory时，注入的值为beanFactory，默认为DefaultListableBeanFactory
beanFactory.registerResolvableDependency(BeanFactory.class, beanFactory);
// 当注入类型为ResourceLoader时，注入的值为ApplicationContext
beanFactory.registerResolvableDependency(ResourceLoader.class, this);
// 当注入类型为ApplicationEventPublisher时，注入的值为ApplicationContext
beanFactory.registerResolvableDependency(ApplicationEventPublisher.class, this);
// 当注入的类型为ApplicationContext时，注入的值为ApplicationContext.
beanFactory.registerResolvableDependency(ApplicationContext.class, this);
// 增加一个bean的后置处理器，ApplicationListenerDetector
// Register early post-processor for detecting inner beans as ApplicationListeners.
beanFactory.addBeanPostProcessor(new ApplicationListenerDetector(this));
// Detect a LoadTimeWeaver and prepare for weaving, if found.
// 如果bean工厂中存在着名称为loadTimeWeaver的bean定义，则给bean工厂中加入LoaderTimeWeaverAwareProcessor后置处理器
// 补充：1、增加对AspectJ的支持，在Java中织入分为3种：(1) 编译期织入; (2) 类加载期织入; (3) 运行期织入。编译期织入指的是在java编译期，
// 采用特殊的编译器，将切面织入到java类中；类加载期织入则指的是通过特殊的类加载器，在字节码加载到JVM时，织入切面；运行期织入则是
// 通过采用cglib或者jdk进行切面的织入。
// 2、aspectJ中提供了两种方式：
// (1) 通过特殊编译器，在编译期，将aspectJ语言编写的切面类织入到java类中；
// (2) 类加载期织入，就是通过下面的LoadTimeWeaving
if (beanFactory.containsBean(LOAD_TIME_WEAVER_BEAN_NAME)) {
beanFactory.addBeanPostProcessor(new LoadTimeWeaverAwareProcessor(beanFactory));
// Set a temporary ClassLoader for type matching.
beanFactory.setTempClassLoader(new ContextTypeMatchClassLoader(beanFactory.getBeanClassLoader()));
}
// 给容器中注册一些与运行环境相关的单实例Bean
if (!beanFactory.containsLocalBean(ENVIRONMENT_BEAN_NAME)) {
// beanName: environment，直接将new出来的Spring内部对象放入到Spring的单实例缓存池中.
beanFactory.registerSingleton(ENVIRONMENT_BEAN_NAME, getEnvironment());
}
if (!beanFactory.containsLocalBean(SYSTEM_PROPERTIES_BEAN_NAME)) {
// beanName: systemProperties 方法：System.getProperties();
beanFactory.registerSingleton(SYSTEM_PROPERTIES_BEAN_NAME, getEnvironment().getSystemProperties());
}
if (!beanFactory.containsLocalBean(SYSTEM_ENVIRONMENT_BEAN_NAME)) {
// beanName: systemEnvironment, 方法：System.getEnv();
beanFactory.registerSingleton(SYSTEM_ENVIRONMENT_BEAN_NAME, getEnvironment().getSystemEnvironment());
}
}
postProcesssBeanFactory--Bean定义加载完毕之后实现，目前方法为空实现，可以自定义扩展。
invkeBeanFactoryPostProcessor--执行beanFactory的后置处理器 BeanFactoryPostProcessor BeanDefinitionRegistryPostProcessor
public static void invokeBeanFactoryPostProcessors(ConfigurableListableBeanFactory beanFactory,
List<BeanFactoryPostProcessor> beanFactoryPostProcessors) {
/** 用来记录已经执行过的后置处理器 */
Set<String> processedBeans = new HashSet<>();
/**
* 判断beanFactory的类型是否为BeanDefinitionRegistry
* 此处beanFactory的类型为：DefaultListableBeanFactory，而DefaultListableBeanFactory是实现了BeanDefinitionRegistry接口的，
* 所以此处判断里面的结果为true.
*
* BeanDefinitionRegistry接口中定义了操作bean定义的常用方法。如：注册bean定义，移除bean定义，获取bean定义的数量，判断是否包含指定的bean定义等...
*/
if (beanFactory instanceof BeanDefinitionRegistry) {
BeanDefinitionRegistry registry = (BeanDefinitionRegistry) beanFactory;
// 用于存放普通的bean工厂的后置处理器
List<BeanFactoryPostProcessor> regularPostProcessors = new ArrayList<>();
/**
* 用于存放类型为BeanDefinitionRegistryPostProcessor的bean工厂后置处理器。BeanDefinitionRegistry是bean定义的注册中心。用来存放所有的bean定义.
* BeanDefinitionRegistryPostProcessor继承自BeanFactoryPostProcessor
*/
List<BeanDefinitionRegistryPostProcessor> registryProcessors = new ArrayList<>();
/**
* 遍历所有的BeanFactoryPostProcessor，将普通的BeanFactoryPostProcessor和BeanDefinitionRegistryPostProcessor区分开.
*/
for (BeanFactoryPostProcessor postProcessor : beanFactoryPostProcessors) {
if (postProcessor instanceof BeanDefinitionRegistryPostProcessor) {
BeanDefinitionRegistryPostProcessor registryProcessor = (BeanDefinitionRegistryPostProcessor) postProcessor;
// 直接执行BeanDefinitionRegistryPostProcessor接口的postProcessBeanDefinitionRegistry方法.
registryProcessor.postProcessBeanDefinitionRegistry(registry);
// 添加到registryProcessors中，用于最后执行postProcessBeanFactory方法
registryProcessors.add(registryProcessor);
} else {
// 普通BeanFactoryPostProcessor，添加到regularPostProcessors中，用于最后执行postProcessBeanFactory方法.
regularPostProcessors.add(postProcessor);
}
}
// Do not initialize FactoryBeans here: We need to leave all regular beans
// uninitialized to let the bean factory post-processors apply to them!
// Separate between BeanDefinitionRegistryPostProcessors that implement
// PriorityOrdered, Ordered, and the rest.
// 保存本次将要执行的BeanDefinitionRegistryPostProcessor.
List<BeanDefinitionRegistryPostProcessor> currentRegistryProcessors = new ArrayList<>();
// 下面的for循环中是找出所有实现了PriorityOrdered接口的BeanDefinitionRegistryPostProcessor实现类
// 首先根据类型找出所有实现了BeanDefinitionRegistryPostProcessor接口的Bean的名称，然后依次循环遍历，判断是否实现了PriorityOrdered接口.
String[] postProcessorNames =
beanFactory.getBeanNamesForType(BeanDefinitionRegistryPostProcessor.class, true, false);
for (String ppName : postProcessorNames) {
if (beanFactory.isTypeMatch(ppName, PriorityOrdered.class)) {
// 获取ppName对应的Bean实例，并添加到当前要执行的currentRegistryProcessors中
// 此处会去创建容器中默认后置处理器对应的单实例bean
// 此处的beanFactory.getBean会根据Bean的类型去创建Bean工厂后置处理器对象，有Bean的创建过程。
currentRegistryProcessors.add(beanFactory.getBean(ppName, BeanDefinitionRegistryPostProcessor.class));
// 把将要执行的bean的名称加入到processedBeans中，后续后判断是否已经执行。避免重复执行.
processedBeans.add(ppName);
}
}
// 根据是否实现了PriorityOrder，Order接口以及具体的order数值来排序.
sortPostProcessors(currentRegistryProcessors, beanFactory);
// 添加到registryProcessors，最后用于执行postProcessBeanFactory方法
registryProcessors.addAll(currentRegistryProcessors);
// 遍历当前要执行的所有BeanDefinitionRegistryPostProcessor，执行其postProcessBeanDefinitionRegistry方法.
// 此处有一个重要的Bean定义注册中心的后置处理器：ConfigurationClassPostProcessor，配置类解析、条件注册的回调、方法及配置类的校验等操作
invokeBeanDefinitionRegistryPostProcessors(currentRegistryProcessors, registry);
// 执行完毕之后，清空currentRegistryProcessors
currentRegistryProcessors.clear();
// 查找所有实现了BeanDefinitionRegistryPostProcessor接口的实现类
// 重复查找是因为上面执行完了所有的BeanDefinitionRegistryPostProcessor类之后，可能又新增了其他的BeanDefinitionRegistryPostProcessor。
// 比如：有一个自定义的BeanDefinitionRegistryPostProcessor中实现了PriorityOrdered接口之后，同时实现了BeanDefinitionRegistryPostProcessor接口.
postProcessorNames = beanFactory.getBeanNamesForType(BeanDefinitionRegistryPostProcessor.class, true, false);
for (String ppName : postProcessorNames) {
// 校验是否实现了Ordered接口，并且之前未执行过
// 使用上述执行完毕之后记录的Set集合判断是否执行过.
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);
// 遍历所有的BeanDefinitionRegistryPostProcessor接口的实现类，
// 并执行BeanDefinitionRegistryPostProcessor的postProcessBeanDefinitionRegistry方法
invokeBeanDefinitionRegistryPostProcessors(currentRegistryProcessors, registry);
// 清空
currentRegistryProcessors.clear();
// Finally, invoke all other BeanDefinitionRegistryPostProcessors until no further ones appear.
// 最后，遍历其他除了实现Ordered接口和PriorityOrdered接口的BeanDefinitionRegistryPostProcessor实现类，
// 并执行其postProcessBeanDefinitionRegistry方法
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);
// 如果有BeanDefinitionRegistryPostProcessor被执行，则有可能产生新的BeanDefinitionRegistryPostProcessor
// 所以需要再次循环查找一次.
reiterate = true;
}
}
sortPostProcessors(currentRegistryProcessors, beanFactory);
registryProcessors.addAll(currentRegistryProcessors);
// 依次执行BeanDefinitionRegistryPostProcessor的postProcessBeanDefinitionRegistry()方法
// 执行时机是加载bean定义之前
invokeBeanDefinitionRegistryPostProcessors(currentRegistryProcessors, registry);
currentRegistryProcessors.clear();
}
// 执行所有BeanDefinitionRegistryPostProcessor接口的postProcessBeanFactory方法
// 加载bean定义之后.但是实例化bean实例之前
invokeBeanFactoryPostProcessors(registryProcessors, beanFactory);
// 执行所有普通的BeanFactoryPostProcessor的postProcessBeanFactory方法。这些BeanFactoryPostProcessor是从方法传进来的.
invokeBeanFactoryPostProcessors(regularPostProcessors, beanFactory);
}
else {
// Invoke factory processors registered with the context instance.
invokeBeanFactoryPostProcessors(beanFactoryPostProcessors, beanFactory);
}
// 至此，上面的过程已经处理完了入参beanFactoryPostProcessors和容器中所有的BeanDefinitionRegistryPostProcessor
///////////////////////////////////////////////////////////////////////////////////////////////////////
// 下面开始处理容器中的所有 BeanFactoryPostProcessor
// Do not initialize FactoryBeans here: We need to leave all regular beans
// uninitialized to let the bean factory post-processors apply to them!
// 查找容器中所有实现了BeanFactoryPostProcessor接口的实现类
String[] postProcessorNames =
beanFactory.getBeanNamesForType(BeanFactoryPostProcessor.class, true, false);
// Separate between BeanFactoryPostProcessors that implement PriorityOrdered,
// Ordered, and the rest.
// 用于存放所有实现了PriorityOrdered接口的BeanFactoryPostProcessor
List<BeanFactoryPostProcessor> priorityOrderedPostProcessors = new ArrayList<>();
// 用于存放实现了Ordered接口的BeanFactoryPostProcessor的beanName
List<String> orderedPostProcessorNames = new ArrayList<>();
// 用于实现了普通未实现Ordered接口的BeanFactoryPostProcessor的beanName
List<String> nonOrderedPostProcessorNames = new ArrayList<>();
// 循环所有的BeanFactoryPostProcessors
for (String ppName : postProcessorNames) {
// 如果前面已经执行过，直接跳过
if (processedBeans.contains(ppName)) {
// skip - already processed in first phase above
}
// 如果实现了PriorityOrdered接口，则获取bean并加入到priorityOrderedPostProcessors
else if (beanFactory.isTypeMatch(ppName, PriorityOrdered.class)) {
priorityOrderedPostProcessors.add(beanFactory.getBean(ppName, BeanFactoryPostProcessor.class));
}
// 如果是实现了Ordered接口的BeanFactoryPostProcessor，直接将其beanName放入到orderedPostProcessorNames
else if (beanFactory.isTypeMatch(ppName, Ordered.class)) {
orderedPostProcessorNames.add(ppName);
}
// 其他普通bean的名称放入到nonOrderedPostProcessorNames
else {
nonOrderedPostProcessorNames.add(ppName);
}
}
// 对实现了PriorityOrdered接口的BeanFactoryPostProcessor进行排序
sortPostProcessors(priorityOrderedPostProcessors, beanFactory);
// 调用所有实现了PriorityOrdered接口的BeanFactoryPostProcessor的postProcessBeanFactory方法
invokeBeanFactoryPostProcessors(priorityOrderedPostProcessors, beanFactory);
// 获取所有实现了Ordered接口的BeanFactoryPostProcessor，并获取Bean实例，添加到orderedPostProcessors中，准备执行
List<BeanFactoryPostProcessor> orderedPostProcessors = new ArrayList<>();
for (String postProcessorName : orderedPostProcessorNames) {
orderedPostProcessors.add(beanFactory.getBean(postProcessorName, BeanFactoryPostProcessor.class));
}
// 对orderedPostProcessors排序
sortPostProcessors(orderedPostProcessors, beanFactory);
// 调用实现了Ordered接口的BeanFactoryPostProcessor的postProcessBeanFactory方法
invokeBeanFactoryPostProcessors(orderedPostProcessors, beanFactory);
// 获取所有普通的未实现Ordered接口和PriorityOrdered接口的BeanFactoryPostProcessor对应的Bean实例，并添加到nonOrderedPostProcessors
List<BeanFactoryPostProcessor> nonOrderedPostProcessors = new ArrayList<>();
for (String postProcessorName : nonOrderedPostProcessorNames) {
nonOrderedPostProcessors.add(beanFactory.getBean(postProcessorName, BeanFactoryPostProcessor.class));
}
// 执行剩余未实现Ordered接口和PriorityOrdered接口的BeanFactoryPostProcessor的postProcessBeanFactory方法.
invokeBeanFactoryPostProcessors(nonOrderedPostProcessors, beanFactory);
// Clear cached merged bean definitions since the post-processors might have
// modified the original metadata, e.g. replacing placeholders in values...
// 删除元数据（bean名称，bean定义等?）缓存，因为在执行后置处理器的过程中，原始的元数据可能已经被修改，例如：属性值中的占位符信息
beanFactory.clearMetadataCache();
}
registerBeanPostProcessor--注册所有bean的后置处理器. 注册所有实现了BeanPostProcessor接口的后置处理器
public static void registerBeanPostProcessors(
ConfigurableListableBeanFactory beanFactory, AbstractApplicationContext applicationContext) {
// 根据类型获取所有BeanPostProcessor的BeanName
String[] postProcessorNames = beanFactory.getBeanNamesForType(BeanPostProcessor.class, true, false);
// Register BeanPostProcessorChecker that logs an info message
// a bean is created during BeanPostProcessor instantiation, i.e. when
// a bean is not eligible for getting processed by all BeanPostProcessors.
// 注册一个BeanPostProcessorChecker，用于记录Bean在BeanPostProcessor实例化时的信息
// 此处+1的操作是因为下面给beanFactory中加入了一个BeanPostProcessorChecker后置处理器.
int beanProcessorTargetCount = beanFactory.getBeanPostProcessorCount() + 1 + postProcessorNames.length;
beanFactory.addBeanPostProcessor(new BeanPostProcessorChecker(beanFactory, beanProcessorTargetCount));
// 存放实现了PriorityOrdered接口和未实现PriorityOrdered接口的BeanPostProcessor
List<BeanPostProcessor> priorityOrderedPostProcessors = new ArrayList<>();
// 用于存放Spring内部的BeanPostProcessor处理器
List<BeanPostProcessor> internalPostProcessors = new ArrayList<>();
// 存放实现了Ordered接口和未实现Ordered接口的BeanPostProcessor的beanName.
List<String> orderedPostProcessorNames = new ArrayList<>();
// 存放未实现任何排序接口的BeanPostProcessor的beanName
List<String> nonOrderedPostProcessorNames = new ArrayList<>();
// 对所有的BeanPostProcessor的beanName进行分类
for (String ppName : postProcessorNames) {
// 实现了PriorityOrdered接口的BeanPostProcessor的beanName
if (beanFactory.isTypeMatch(ppName, PriorityOrdered.class)) {
BeanPostProcessor pp = beanFactory.getBean(ppName, BeanPostProcessor.class);
priorityOrderedPostProcessors.add(pp);
if (pp instanceof MergedBeanDefinitionPostProcessor) {
// 实现了MergedBeanDefinitionPostProcessor的BeanPostProcessor
internalPostProcessors.add(pp);
}
}
// 实现了Ordered接口的BeanPostProcessor的beanName
else if (beanFactory.isTypeMatch(ppName, Ordered.class)) {
orderedPostProcessorNames.add(ppName);
}
// 未实现PriorityOrdered接口和Ordered接口的BeanPostProcessor的beanName.
else {
nonOrderedPostProcessorNames.add(ppName);
}
}
// First, register the BeanPostProcessors that implement PriorityOrdered.
// 优先注册实现了PriorityOrdered接口的BeanPostProcessor.
sortPostProcessors(priorityOrderedPostProcessors, beanFactory);
registerBeanPostProcessors(beanFactory, priorityOrderedPostProcessors);
// Next, register the BeanPostProcessors that implement Ordered.
// 保存实现了Ordered接口的BeanPostProcessor.
List<BeanPostProcessor> orderedPostProcessors = new ArrayList<>();
for (String ppName : orderedPostProcessorNames) {
BeanPostProcessor pp = beanFactory.getBean(ppName, BeanPostProcessor.class);
orderedPostProcessors.add(pp);
if (pp instanceof MergedBeanDefinitionPostProcessor) {
internalPostProcessors.add(pp);
}
}
// 注册实现了Ordered接口的BeanPostProcessor.
sortPostProcessors(orderedPostProcessors, beanFactory);
registerBeanPostProcessors(beanFactory, orderedPostProcessors);
// Now, register all regular BeanPostProcessors.
// 注册普通的BeanPostProcessor(既没有实现PriorityOrdered接口，也没有实现Ordered接口.)
List<BeanPostProcessor> nonOrderedPostProcessors = new ArrayList<>();
for (String ppName : nonOrderedPostProcessorNames) {
BeanPostProcessor pp = beanFactory.getBean(ppName, BeanPostProcessor.class);
nonOrderedPostProcessors.add(pp);
if (pp instanceof MergedBeanDefinitionPostProcessor) {
internalPostProcessors.add(pp);
}
}
registerBeanPostProcessors(beanFactory, nonOrderedPostProcessors);
// Finally, re-register all internal BeanPostProcessors.
// 最后注册所有实现了MergedBeanDefinitionPostProcessor接口的BeanPostProcessor
sortPostProcessors(internalPostProcessors, beanFactory);
registerBeanPostProcessors(beanFactory, internalPostProcessors);
// Re-register post-processor for detecting inner beans as ApplicationListeners,
// moving it to the end of the processor chain (for picking up proxies etc).
// 添加ApplicationListenerDetector的BeanPostProcessor。
// 重复添加一次该beanPostProcessor是为了将该beanPostProcessor移动到beanPostProcessor对应的list的最后
// 上述处理bean的过程中，可能存在一些内部bean也是ApplicationListenerDetector类型，所以需要在添加一次
beanFactory.addBeanPostProcessor(new ApplicationListenerDetector(applicationContext));
}
initMessageSource--初始化消息源
protected void initMessageSource() {
// 获取bean工厂
ConfigurableListableBeanFactory beanFactory = getBeanFactory();
// 判断是否在bean工厂中定义了id为messageSource的bean对象
if (beanFactory.containsLocalBean(MESSAGE_SOURCE_BEAN_NAME)) {
// 如果有id为messageSource，而且类型是MessageSource的组件，直接赋值给messageSource属性
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.isTraceEnabled()) {
logger.trace("Using MessageSource [" + this.messageSource + "]");
}
}
else {
// Use empty MessageSource to be able to accept getMessage calls.
// 如果没有，则创建一个DelegatingMessageSource类型的messageSource对象
DelegatingMessageSource dms = new DelegatingMessageSource();
dms.setParentMessageSource(getInternalParentMessageSource());
this.messageSource = dms;
// 将messageSource注册到容器中，在获取国际化配置文件中的某个值时，可以直接通过注入MessageSource，
// 调用其getMessage(String code, @Nullable Object[] args, @Nullable String defaultMessage, Locale locale)方法来获取.
beanFactory.registerSingleton(MESSAGE_SOURCE_BEAN_NAME, this.messageSource);
if (logger.isTraceEnabled()) {
logger.trace("No '" + MESSAGE_SOURCE_BEAN_NAME + "' bean, using [" + this.messageSource + "]");
}
}
}
initApplicationEventMulticaster--初始化事件派发器，用来发布事件
protected void initApplicationEventMulticaster() {
// 获取Bean工厂
ConfigurableListableBeanFactory beanFactory = getBeanFactory();
// 判断当前的bean工厂中有没有id为applicationEventMulticaster的事件派发器
if (beanFactory.containsLocalBean(APPLICATION_EVENT_MULTICASTER_BEAN_NAME)) {
// 如果有，则直接获取到ApplicationEventMulticaster类型的事件多播器，并赋值给applicationEventMulticaster.
this.applicationEventMulticaster =
beanFactory.getBean(APPLICATION_EVENT_MULTICASTER_BEAN_NAME, ApplicationEventMulticaster.class);
if (logger.isTraceEnabled()) {
logger.trace("Using ApplicationEventMulticaster [" + this.applicationEventMulticaster + "]");
}
}
else {
// 如果没有则创建一个类型为SimpleApplicationEventMulticaster事件监听器，
this.applicationEventMulticaster = new SimpleApplicationEventMulticaster(beanFactory);
// 将创建的事件多播器注册到容器中，在其他组件需要派发事件时，直接获取这个applicationEventMulticaster
beanFactory.registerSingleton(APPLICATION_EVENT_MULTICASTER_BEAN_NAME, this.applicationEventMulticaster);
if (logger.isTraceEnabled()) {
logger.trace("No '" + APPLICATION_EVENT_MULTICASTER_BEAN_NAME + "' bean, using " +
"[" + this.applicationEventMulticaster.getClass().getSimpleName() + "]");
}
}
}
onRefresh--用来初始化一些特殊的Bean 如Spring Boot tomcat
registerListeners--注册监听器
protected void registerListeners() {
// Register statically specified listeners first.
// 将注册的监听器绑定到广播器
for (ApplicationListener<?> listener : getApplicationListeners()) {
getApplicationEventMulticaster().addApplicationListener(listener);
}
// Do not initialize FactoryBeans here: We need to leave all regular beans
// uninitialized to let post-processors apply to them!
// 根据类型获取listener监听器的名称
String[] listenerBeanNames = getBeanNamesForType(ApplicationListener.class, true, false);
for (String listenerBeanName : listenerBeanNames) {
// 将事件监听器注册到派发器中，以后使用的时候，就可以直接通过事件派发器执行.
getApplicationEventMulticaster().addApplicationListenerBean(listenerBeanName);
}
// Publish early application events now that we finally have a multicaster...
// 如果之前存在着应用事件，则直接发布.比如如下自定义监听器的示例，会在此进行发布：
/**
* // 1.先自定义事件
public class TestEvent extends ApplicationEvent{
private User user;
public TestEvent(Object source,User user) {
this.user=user;
}
public User getUser() {
return user;
}
public void setUser(User user) {
this.user = user;
}
}
// 2.自定义监听器
public class TestListener implements ApplicationListener<TestEvent>{
public void onApplicationEvent(TestEvent event) {
User user = event.getUser();
System.out.println(user.getEmail());
}
}
// 3.配置监听器
<bean id="testListener" class="com.wb.listener.TestListener"></bean>
// 4.发布事件
MyApplicationContext context=new MyApplicationContext("classpath:applicationContext.xml");
User user=new User();
user.setEmail("1111");
context.publishEvent(new TestEvent("", user));
*/
/**
* 派发之前产生的事件。
* earlyApplicationEvent是在prepareRefresh中声明的.
*/
Set<ApplicationEvent> earlyEventsToProcess = this.earlyApplicationEvents;
this.earlyApplicationEvents = null;
if (earlyEventsToProcess != null) {
// earlyApplicationEvents如果不为空的话，则进行事件的派发
for (ApplicationEvent earlyEvent : earlyEventsToProcess) {
// 调用时间派发器进行事件的派发操作
getApplicationEventMulticaster().multicastEvent(earlyEvent);
}
}
}
finishBeanFactoryInitialization--初始化所有剩余的单实例Bean(没有使用懒加载的Bean)
protected void finishBeanFactoryInitialization(ConfigurableListableBeanFactory beanFactory) {
// 1. 初始化此上下文的转换服务，用来自定义将Spring中的某个Bean的属性从一个类型转换到另外一个类型.
// 判断Bean工厂中是否存在名称为conversionService的转换服务bean，如果存在而且类型为ConversionService，则获取该Bean实例，并将其设置到BeanFactory中
/**
* 例如：
* (1)有如下的javaBean:
* public class Person {
* public String name;
* public Date birthday;
* ...
* }
* (2)有如下的xml配置：
* <bean name="person" class="com.wb.test.Person">
* <property name="name" value="wangbing"/>
* <property name="birthday" value="1999-03-03"/>
* </bean>
* (3)有如下的测试类：
* ApplicationContext acx = new ClasspathXmlApplicationContext("test.xml");
* Person person = (Person) acx.getBean("person");
* System.out.println(person.name);
* System.out.println(person.birthday); // 改行会报错，提示字符串类型不能转换为日期类型
*
* (4)可以通过定义如下名称的bean，将某种类型的属性值转换为另外一种类型.
* <bean name="conversionService" class="com.wb.test.MyConversionService" />
* public class MyConversionService implements ConversionService {
* // 实现是否能转换以及具体转换的方法。
* public boolean canConvert(Class<?> sourceType, Class<?> targetType) {}
* public boolean canConvert(TypeDescriptor sourceType, TypeDescriptor targetType) {}
* public <T> T convert(Object source, Class<T> targetType) {}
* // 可以在该方法中实现转换逻辑。如果源类型sourceType是String类型的话，将其转换为Date类型返回。
* public Object convert(Object source, TypeDescriptor sourceType, TypeDescriptor targetType) {}
* }
*/
// 2.在Spring中，如果需要配置自定义的转换器，还可以直接利用Spring提供的ConversionServiceFactoryBean来完成。自己只需要实现具体的转换逻辑即可
/**
* (1)配置conversionService对应的工厂Bean：
* <bean id="conversionService" class="org.springframework.context.support.ConversionServiceFactoryBean">
* <property name="converters">
* <bean class="com.wb.test.MyConverter"/>
* </property>
* </bean>
* (2)然后自己去实现MyConverter即可：
* public class MyConverter implements Converter<String,Date> {
* @Override
* public Date convert(String source) {
* DateFormat format = new SimpleDateFormat("yyyy-MM-dd");
* try {
* return format.parse((String) source);
* } catch (ParseException e) {
* e.printStackTrace();
* }
* return null;
* }
* }
*/
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之前没有注册嵌入值解析器，则注册默认的嵌入值解析器，
* 主要用于注解属性值的解析例如：@Value("${app.name}")。
*/
// 值解析器设置的地方：在调用invokeBeanfactoryPostProcessor方法的时候，通过PropertySourcesPlaceholderConfigurer的后置处理方法设置进去的
if (!beanFactory.hasEmbeddedValueResolver()) {
// 调用resolvePlaceholders方法解析strVal对应的值
beanFactory.addEmbeddedValueResolver(strVal -> getEnvironment().resolvePlaceholders(strVal));
}
/**
* 初始化所有实现了LoadTimeWeaverAware接口的子类，用于类在加载进入jvm之前，动态增强类
* 这特别适用于Spring的JPA支持，其中load-time weaving加载织入对JPA类转换非常必要
*/
String[] weaverAwareNames = beanFactory.getBeanNamesForType(LoadTimeWeaverAware.class, false, false);
for (String weaverAwareName : weaverAwareNames) {
getBean(weaverAwareName);
}
// 停止使用临时的类加载器.
beanFactory.setTempClassLoader(null);
// 缓存(冻结)所有的BeanName（注册的bean定义不会被修改或进一步做处理了，因为下面马上要创建Bean的实例对象了）
beanFactory.freezeConfiguration();
// 初始化所有的单实例Bean，包括创建单实例bean的全部过程
beanFactory.preInstantiateSingletons();
}
preInstantiateSingletons-初始化所有的单实例Bean
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);
// 遍历所有的beanNames，触发所有非懒加载单例bean的初始化，即：创建所有的单实例Bean
for (String beanName : beanNames) {
// 获取beanName对应的MergedBeanDefinition.
RootBeanDefinition bd = getMergedLocalBeanDefinition(beanName);
// 如果bd对应的Bean实例满足：(不是抽象类 && 是单例 && 不是懒加载)
if (!bd.isAbstract() && bd.isSingleton() && !bd.isLazyInit()) {
// 判断BeanName对应的Bean实例是否是FactoryBean.
if (isFactoryBean(beanName)) {
// 通过beanName获取FactoryBean的实例，factoryBean的名称是："&" + beanName
Object bean = getBean(FACTORY_BEAN_PREFIX + beanName);
if (bean instanceof FactoryBean) {
final FactoryBean<?> factory = (FactoryBean<?>) bean;
boolean isEagerInit;
// 判断这个FactoryBean是否需要紧急初始化.
// System.getSecurityManager()方法是获取系统权限管理器，Java为了防止恶意代码执行(修改，删除操作系统文件)，做了权限管理，
// 默认的安全管理器配置文件是: $JAVA_HOME/jre/lib/security/java.policy
/**
* 在做访问控制决定时，如果遇到通过调用不带上下文参数（请参阅下文，以获取关于上下文参数的信息）的 doPrivileged 标记为“特权”的调用方，
* 则 checkPermission 方法将停止检查。如果该调用方的域具有指定的权限，则不进行进一步检查，并且 checkPermission 正常返回，
* 指示允许所请求的访问。如果该域不具有指定的权限，则通常抛出异常。
*
*
* AccessController.doPrivileged()方法的例子：
* 假设有这样一种情况：A程序想在 C:\Users\Jack\Desktop\test1 这个目录中新建一个文件，但是它没有相应的权限，
* 但是它引用了另外一个Jar包B，刚好B有权限在C:\Users\Jack\Desktop\test1目录中新建文件，
* 还有更巧的是B在新建文件的时候采用的是AccessController.doPrivileged方法进行的，这种情况下，A就可以调用B的创建文件的方法进行创建文件了。
*/
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，则通过BeanName去获取Bean实例.
getBean(beanName);
}
}
}
/**
* 上一步for循环中已经创建完了所有的单实例Bean，这个for循环中，会拿出所有的单实例Bean，
* 然后遍历，判断单实例bean是否实现了SmartInitializingSingleton接口，如果实现了该接口，
* 则调用单实例Bean的afterSingletonsInstantiated方法
*/
for (String beanName : beanNames) {
// 获取beanName对应的bean实例
Object singletonInstance = getSingleton(beanName);
// 判断当前的bean是否实现了SmartInitializingSingleton接口.
if (singletonInstance instanceof SmartInitializingSingleton) {
final SmartInitializingSingleton smartSingleton = (SmartInitializingSingleton) singletonInstance;
// 触发SmartInitializingSingleton实现类的afterSingletonInstantiated方法.
if (System.getSecurityManager() != null) {
AccessController.doPrivileged((PrivilegedAction<Object>) () -> {
smartSingleton.afterSingletonsInstantiated();
return null;
}, getAccessControlContext());
}
else {
/**
* 如果实现了SmartInitializingSingleton接口，则会调用afterSingletonInstantiated方法
* 例如@EventListener注解的实现原理，就是利用EventListenerMethodProcessor后置处理器完成的，
* 而在EventListenerMethodProcessor中就是实现了SmartInitializingSingleton接口
*/
smartSingleton.afterSingletonsInstantiated();
}
}
}
}
getBean doGetBean--获取单实例Bean
@Override
public Object getBean(String name) throws BeansException {
// 空方法
return 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 {
// 获取真正的BeanName。主要包括：(1) 去掉FactoryBean名称前面的&前缀；(2) bean别名解析；
final String beanName = transformedBeanName(name);
Object bean;
// 先尝试从缓存中获取单实例Bean，如果能获取到，说明已经被创建过
// 注意：如果是通过FactoryBean方式创建对象。在根据名称获取目标bean对象(非FactoryBean实例)时，此处返回的sharedInstance是FactoryBean对象
Object sharedInstance = getSingleton(beanName);
/**
* 当组件实现了FactoryBean接口，并重写了getObject方法时。在从容器中获取bean的时候，sharedInstance就是容器中返回的bean对象
* 此时sharedInstance不为空，就会调用getObjectForBeanInstance方法，这个方法内部会调用子类重写的getObject方法.
*/
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对象，包括使用FactoryBean来创建bean的逻辑.
bean = getObjectForBeanInstance(sharedInstance, name, beanName, null);
}
else {
// 如果当前创建的是单实例类型的bean，则尝试解决循环依赖，此处仅仅只是一个校验；如果当前的多实例bean正在创建中，而且存在循环依赖，直接抛出异常
if (isPrototypeCurrentlyInCreation(beanName)) {
throw new BeanCurrentlyInCreationException(beanName);
}
// 获取Bean的父工厂？ 在Spring和SpringMVC整合之后，会存在着父子容器问题
// TODO 父子容器处理
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);
}
}
// 标记Bean已经被创建，防止多线程时，Bean可能会被创建多个，就不是单实例了
if (!typeCheckOnly) {
// 将beanName对应的bean定义从mergedBeanDefinitions中移除，并将beanName添加到alreadyCreated集合中.
markBeanAsCreated(beanName);
}
try {
// 获取合并之后的Bean定义
final RootBeanDefinition mbd = getMergedLocalBeanDefinition(beanName);
// 校验bean对应的类是否为抽象的，如果bean对应的类标注了抽象，直接会抛出异常
checkMergedBeanDefinition(mbd, beanName, args);
/**
* 获取当前Bean所依赖的其他Bean
* 例如：<bean class="com.wb.beans.User" scope="prototype" depends-on="book,football" />，里面的depends-on就是依赖的bean
*/
String[] dependsOn = mbd.getDependsOn();
// 如果有依赖的Bean
if (dependsOn != null) {
for (String dep : dependsOn) {
// 判断是否存在着循环依赖. a->b b->c c->a这种情况
/**
* 该步骤里面会去解决bean之间的循环依赖，例如如下的bean依赖情况：
*
* <bean name="classA" class="com.wb.spring.finishBeanFactoryInitialization.domain.ClassA" depends-on="classB"></bean>
* <bean name="classB" class="com.wb.spring.finishBeanFactoryInitialization.domain.ClassB" depends-on="classA"></bean>
*
* 通过acx.getBean("classA");去获取classA对应的bean时，就会提示循环依赖异常。
*/
if (isDependent(beanName, dep)) {
throw new BeanCreationException(mbd.getResourceDescription(), beanName,
"Circular depends-on relationship between '" + beanName + "' and '" + dep + "'");
}
// 维护依赖和被依赖的bean之间的关联关系，Map<String,Set<String>> dependentMap
registerDependentBean(dep, beanName);
try {
// 先去创建当前bean所依赖的其他bean对象
getBean(dep);
}
catch (NoSuchBeanDefinitionException ex) {
throw new BeanCreationException(mbd.getResourceDescription(), beanName,
"'" + beanName + "' depends on missing bean '" + dep + "'", ex);
}
}
}
// bean定义如果是单例的，则调用createBean方法进行单实例bean的创建.
if (mbd.isSingleton()) {
// 此处的lambda表达式为：ObjectFactory的getObject方法
sharedInstance = getSingleton(beanName, () -> {
try {
/**
* 创建对象并初始化，Spring用来创建Bean实例的核心方法
* 此处调用的子类AbstractAutowireCapableBeanFactory的createBean方法.
*/
return createBean(beanName, mbd, args);
}
catch (BeansException ex) {
// 如果创建单实例bean失败，则会删除关于该bean的一切信息，包括三级缓存和已经注册的bean集合中有关该bean的信息
destroySingleton(beanName);
throw ex;
}
});
/**
* 从bean的实例中获取对象.上述创建出来的bean对象sharedInstance只代表了bean的初始状态，
* 并不一定是我们最终需要的bean。
*
* 举个例子，假如我们需要对工厂bean进行处理，那么这里得到的其实是工厂bean的初始状态，
* 但是我们真正需要的是工厂bean中定义的 factory-method方法中返回的bean，
* 而getObjectForBeanInstance方法就是完成这个工作的。
*
*
* 真实作用：如果一个类实现了FactoryBean接口，则上述bean创建完成之后，其实只是创建好了工厂bean，但是真实的应用
* bean还未创建，此处将会回调FactoryBean的getObject自定义方法进行应用bean的创建工作。
*/
bean = getObjectForBeanInstance(sharedInstance, name, beanName, mbd);
}
// 当前需要创建的bean如果是多例
else if (mbd.isPrototype()) {
// 创建多实例bean
Object prototypeInstance;
try {
// 进行多实例bean创建之前的准备工作，将当前正在创建的多实例bean的名称添加到prototypesCurrentlyInCreation中.
beforePrototypeCreation(beanName);
// 创建多实例对象，和创建单实例bean使用的是同一个方法
prototypeInstance = createBean(beanName, mbd, args);
}
finally {
// 从prototypesCurrentlyInCreation【ThreadLocal】中移除
afterPrototypeCreation(beanName);
}
bean = getObjectForBeanInstance(prototypeInstance, name, beanName, mbd);
}
// 未明确指定将要创建的bean是单例的还是多例的
else {
String scopeName = mbd.getScope();
// 从bean定义中获取bean的scope信息，如果bean的scope信息为null，也就是随意设置的scope，直接抛出异常
final Scope scope = this.scopes.get(scopeName);
if (scope == null) {
throw new IllegalStateException("No Scope registered for scope name '" + scopeName + "'");
}
try {
// 根据指定的scope获取bean实例
Object scopedInstance = scope.get(beanName, () -> {
// 初始化之前准备工作，将bean的名称添加到prototypesCurrentlyInCreation
beforePrototypeCreation(beanName);
try {
// 创建bean实例
return createBean(beanName, mbd, args);
}
finally {
// 从prototypesCurrentlyInCreation中移除
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转换为我们指定类型的Class，如果需要转换，则使用自定义的TypeConverter进行bean类型的转换
* 如果未指定TypeConverter，则默认使用SimpleTypeConverter，converter需要设置一个用来转化的Service实现类，即：ConversionService，
* ConversionService是在finishBeanFactoryInitialization方法的最前面进行注册的，可以在xml中配置对应的ConversionService实现类
*/
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;
}
getSingleton--尝试从缓存中获取单实例Bean过
protected Object getSingleton(String beanName, boolean allowEarlyReference) {
// 根据beanName从单实例对象缓存中获取单例对象(singletonObjects为一个ConcurrentHashMap，就是用来保存所有的单实例Bean的,
// key:beanName value:beanInstance) 相当于一级缓存
Object singletonObject = this.singletonObjects.get(beanName);
// 如果缓存中不存在，而且beanName对应的单实例Bean正在创建中.
if (singletonObject == null && isSingletonCurrentlyInCreation(beanName)) {
// 加锁操作.
synchronized (this.singletonObjects) {
// 从早期单实例对象缓存中获取单例对象（之所以称为单实例早期对象，
// 是因为earlySingletonObjects里面的对象都是通过提前曝光的ObjectFactory创建出来的，还未进行属性的填充）
singletonObject = this.earlySingletonObjects.get(beanName);
// 如果早期单实例对象缓存中没有，而且允许创建早期单实例对象引用
if (singletonObject == null && allowEarlyReference) {
// 则从单例工厂缓存中获取BeanName对应的单例工厂.
ObjectFactory<?> singletonFactory = this.singletonFactories.get(beanName);
if (singletonFactory != null) {
// 如果存在着单例对象工厂，则通过工厂创建一个单例对象，
// 调用的是：addSingletonFactory(beanName, () -> getEarlyBeanReference(beanName, mbd, bean))中的拉姆达表达式
singletonObject = singletonFactory.getObject();
// 将通过单例对象工厂创建的单例对象放入到早期单例对象缓存中，这个早期对象指的是一个空的未完成属性赋值和初始化的对象。
this.earlySingletonObjects.put(beanName, singletonObject);
// 移除该beanName对应的单例对象工厂，因为该单例工厂已经创建了一个实例对象，并且放入到earlySingletonObjects缓存中了，
// 所以，后续通过beanName获取单例对象，可以通过earlySingletonObjects缓存获取到，不需要再用到该单例工厂.
this.singletonFactories.remove(beanName);
}
}
}
}
return singletonObject;
}
createBean--创建对象并初始化
protected Object createBean(String beanName, RootBeanDefinition mbd, @Nullable Object[] args)
throws BeanCreationException {
if (logger.isTraceEnabled()) {
logger.trace("Creating instance of bean '" + beanName + "'");
}
// 获取bean的定义信息
RootBeanDefinition mbdToUse = mbd;
// 解析bean的类型，使用类加载器真实加载Bean的Class
Class<?> resolvedClass = resolveBeanClass(mbd, beanName);
if (resolvedClass != null && !mbd.hasBeanClass() && mbd.getBeanClassName() != null) {
mbdToUse = new RootBeanDefinition(mbd);
mbdToUse.setBeanClass(resolvedClass);
}
try {
// 对lookup-method和replaced-method指定的方法进行预处理.
// 主要是标记bean中是否有重载方法。如果一个类有多个重载方法，在后面真正调用或者增强的时候，还需要根据参数类型和参数个数判断调用的哪一个方法，
// 此处相当于是提前处理。对于只有一个方法的bean，直接标记为无重载方法.
// 使用的地方：该处设置完标志位之后，在后期的实例化过程中使用cglib实例化策略的时候会使用到。
mbdToUse.prepareMethodOverrides();
}
catch (BeanDefinitionValidationException ex) {
throw new BeanDefinitionStoreException(mbdToUse.getResourceDescription(),
beanName, "Validation of method overrides failed", ex);
}
try {
// 在真正创建Bean之前，执行bean实例化之前的一些工作，可以在此处生成自定义的代理对象.
// 通过实现InstantiationAwareBeanPostProcessor接口来进行自定义扩展，生成自定义的代理对象
// 可参考：【示例代码：com.wb.spring.instantiationaware.MyInstantiationAwareBeanPostProcessor】
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的操作
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);
}
}
doCreateBean--执行创建Bean的操作
protected Object doCreateBean(final String beanName, final RootBeanDefinition mbd, final @Nullable Object[] args)
throws BeanCreationException {
// Instantiate the bean.
BeanWrapper instanceWrapper = null;
if (mbd.isSingleton()) {
// 删除之前工厂bean缓存中的工厂bean对象，重新进行实例化.
instanceWrapper = this.factoryBeanInstanceCache.remove(beanName);
}
// 创建Bean的实例，并且包装为一个包装对象返回.
if (instanceWrapper == null) {
// 使用策略方法创建实例，包括：工厂方法，构造函数注入，简单初始化.
// TODO 里面调用的方法超级长
instanceWrapper = createBeanInstance(beanName, mbd, args);
}
// 获取新创建的bean对象和对应的class
final Object bean = instanceWrapper.getWrappedInstance();
Class<?> beanType = instanceWrapper.getWrappedClass();
if (beanType != NullBean.class) {
mbd.resolvedTargetType = beanType;
}
// Allow post-processors to modify the merged bean definition.
synchronized (mbd.postProcessingLock) {
// 如果还未执行MergedBeanDefinitionPostProcessor的postProcessMergedBeanDefinition方法
if (!mbd.postProcessed) {
try {
// 依次调用所有MergedBeanDefinitionPostProcessor的postProcessMergedBeanDefinition方法，用来处理类中使用注解标注的属性，并放入到缓存中.
/**
* 其中包括了
* 【AutowiredAnnotationBeanPostProcessor】， 用来处理@Autowired,@Value,@Inject注解
* 【CommonAnnotationBeanPostProcessor】， 用来处理@Resource注解
* 【RequiredAnnotationBeanPostProcessor】， 用来处理@Required注解
* 【InitDestroyAnnotationBeanPostProcessor】，用来处理@Predestroy和@PostConstruct注解
* 【ScheduledAnnotationBeanPostProcessor】，用来处理@Scheduled注解
* 等后置处理器
*/
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是单例的 && 允许bean之间的循环依赖 && bean正在创建中
*/
boolean earlySingletonExposure = (mbd.isSingleton()
&& this.allowCircularReferences
&& isSingletonCurrentlyInCreation(beanName));
// 判断是否需要提前暴露自己。如果需要提前暴露，会将创建完但未填充属性和初始化的bean放入到singletonFactories中，用来解决循环依赖.
// Spring中的单实例Bean，而且是使用属性注入的方式，默认支持循环依赖的；如果是prototype类型的，默认不支持循环依赖
// 如果是单例bean，而且使用构造器注入的方式，默认不支持循环依赖，可在构造器上添加@Lazy注解，让依赖的属性延迟初始化来解决
// 如果是单例bean和prototype类型的bean混用，则如果先创建单例，可以成功，如果先创建prototype类型的bean，则会失败
if (earlySingletonExposure) {
if (logger.isTraceEnabled()) {
logger.trace("Eagerly caching bean '" + beanName +
"' to allow for resolving potential circular references");
}
/**
* getEarlyBeanReference: 是用来获取到被SmartInstantiationAwareBeanPostProcessor后处理器处理过的刚刚实例化结束的bean对象
*
* addSingletonFactory: 是用来将刚刚初始化的bean对象放入到singletonFactories中，singletonFactories是个map集合，
* key: bean的名称，value: 是一个ObjectFactory，当存在着循环依赖时，可以通过ObjectFactory.getObject方法获取到刚刚实例化的bean对象
*/
addSingletonFactory(beanName, () -> getEarlyBeanReference(beanName, mbd, bean));
}
/** 初始化单实例bean。 包括：填充属性及执行初始化方法 */
Object exposedObject = bean;
try {
/**
* 【依赖注入】
* 填充的属性包括：普通属性和使用@Autowired和@Resource注解标注的引用类型属性的赋值。使用了反射操作set方法完成赋值.
*
* eg: 重点操作举例：
* 【创建完成Bean之后，填充Bean的属性，填充过程中会调用InstantiationAwareBeanPostProcessorAdaptor类的postProcessProperties方法】
*/
populateBean(beanName, mbd, instanceWrapper);
/**
* 完成Bean的初始化(执行afterPropertiesSet和init-method)
* 注意：会调用@PostConstruct标注的方法，这个方法是在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<>(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.");
}
}
}
}
try {
/**
* 注册bean的销毁方法，如果bean不是prototype类型，而且requiresDestruction方法返回true
* 则会将当前的bean放入到一个需要被销毁的map集合中.
*/
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, @Nullable BeanWrapper bw) {
if (bw == null) {
if (mbd.hasPropertyValues()) {
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;
/**
* 首先判断bean在初始化的时候是否需要进行属性值的注入.
*
* 可以通过扩展InstantiationAwareBeanPostProcessor接口来实现是否进行属性值注入的判断逻辑。
* 如下，直接返回false，则所有标注@Autowired注解的都不会进行依赖注入
*
* @Component
* class MyProcessor implements InstantiationAwareBeanPostProcessor {
* @Override
* public boolean postProcessAfterInstantiation(Object bean, String beanName) {
* return false;
* }
* }
*/
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;
}
/** 获取当前正在实例化的bean的所有属性及值，类型为map: key:属性名称，value:值或者引用 */
PropertyValues pvs = (mbd.hasPropertyValues() ? mbd.getPropertyValues() : null);
/** 如果bean定义中指定的注入类型为通过名称或者通过类型注入，则解析出依赖的属性值或引用。但是该步骤不会进行属性的赋值操作 */
if (mbd.getResolvedAutowireMode() == AUTOWIRE_BY_NAME || mbd.getResolvedAutowireMode() == AUTOWIRE_BY_TYPE) {
MutablePropertyValues newPvs = new MutablePropertyValues(pvs);
/** 如果是按照名称进行自动注入，通过属性名称获取依赖的属性值或者引用 */
if (mbd.getResolvedAutowireMode() == AUTOWIRE_BY_NAME) {
autowireByName(beanName, mbd, bw, newPvs);
}
/** 如果是按照类型进行自动注入，则通过属性的类型获取依赖的属性值或者引用 */
if (mbd.getResolvedAutowireMode() == AUTOWIRE_BY_TYPE) {
autowireByType(beanName, mbd, bw, newPvs);
}
pvs = newPvs;
}
// 当前bean是否有InstantiationAwareBeanPostProcessor类型的后置处理器
boolean hasInstAwareBpps = hasInstantiationAwareBeanPostProcessors();
// 自动装配时需要进行依赖的检查
boolean needsDepCheck = (mbd.getDependencyCheck() != AbstractBeanDefinition.DEPENDENCY_CHECK_NONE);
PropertyDescriptor[] filteredPds = null;
// 如果存在着InstantiationAwareBeanPostProcessor【继承自BeanPostProcessor】类型的后置处理器
if (hasInstAwareBpps) {
if (pvs == null) {
pvs = mbd.getPropertyValues();
}
for (BeanPostProcessor bp : getBeanPostProcessors()) {
// 如果是InstantiationAwareBeanPostProcessor的实例
if (bp instanceof InstantiationAwareBeanPostProcessor) {
InstantiationAwareBeanPostProcessor ibp = (InstantiationAwareBeanPostProcessor) bp;
// 则依次执行后置处理器的postProcessProperties，首先使用postProcessProperties，获取属性值
PropertyValues pvsToUse = ibp.postProcessProperties(pvs, bw.getWrappedInstance(), beanName);
if (pvsToUse == null) {
if (filteredPds == null) {
filteredPds = filterPropertyDescriptorsForDependencyCheck(bw, mbd.allowCaching);
}
// 如果通过postProcessProperties未获取到属性值，再通过postProcessPropertyValues获取属性值
pvsToUse = ibp.postProcessPropertyValues(pvs, filteredPds, bw.getWrappedInstance(), beanName);
if (pvsToUse == null) {
return;
}
}
pvs = pvsToUse;
}
}
}
// 如果需要进行依赖的检查【包括简单类型和对象类型】
if (needsDepCheck) {
if (filteredPds == null) {
/**
* 通过一些过滤条件过滤掉不需要自动注入属性值的属性
* 其中包括：refresh()方法的prepareBeanFactory步骤中所忽略的接口.
*/
filteredPds = filterPropertyDescriptorsForDependencyCheck(bw, mbd.allowCaching);
}
/**
* 检查属性值的依赖。如果bean中的属性有setter方法，但是属性名称没有包含在属性值列表中，将会抛出异常
*/
checkDependencies(beanName, mbd, filteredPds, pvs);
}
/** 如果解析出来的依赖属性值集合不为空，则通过applyPropertyValues进行属性值的填充 */
if (pvs != null) {
applyPropertyValues(beanName, mbd, bw, pvs);
}
}
initializeBean--完成Bean的初始化(执行afterPropertiesSet init-method和BeanPostProcessor的Before和After方法)
protected Object initializeBean(final String beanName, final Object bean, @Nullable RootBeanDefinition mbd) {
if (System.getSecurityManager() != null) {
AccessController.doPrivileged((PrivilegedAction<Object>) () -> {
invokeAwareMethods(beanName, bean);
return null;
}, getAccessControlContext());
}
else {
/**
* 调用Bean实现的Aware接口的方法，主要包括下面三个接口
* BeanNameAware ----> setBeanName()
* BeanClassLoaderAware ----> setBeanClassLoader()
* BeanFactoryAware ----> setBeanFactory()
*/
invokeAwareMethods(beanName, bean);
}
Object wrappedBean = bean;
if (mbd == null || !mbd.isSynthetic()) {
/** 调用Bean对象的postProcessBeforeInitialization方法，此处会执行标注@PostConstruct注解的方法 */
// 此处会调用ApplicationContextAwareProcessor执行其他的aware方法.
wrappedBean = applyBeanPostProcessorsBeforeInitialization(wrappedBean, beanName);
}
try {
/**
* 执行Bean的初始化方法:
*
* 1.先判断Bean是否实现了InitializingBean接口，如果实现了InitializingBean接口，则调用Bean对象的afterPropertiesSet方法；
* 2.然后判断Bean是否有指定init-method方法，如果指定了init-method方法，则调用bean对象的init-method指定的方法.
*/
invokeInitMethods(beanName, wrappedBean, mbd);
}
catch (Throwable ex) {
throw new BeanCreationException(
(mbd != null ? mbd.getResourceDescription() : null),
beanName, "Invocation of init method failed", ex);
}
if (mbd == null || !mbd.isSynthetic()) {
/**
* 调用Bean对象的postProcessAfterInitialization方法
*
* 如果需要创建代理，在该步骤中执行postProcessAfterInitialization方法的时候会去创建代理
* 调用AbstractAutoProxyCreator类的postProcessAfterInitialization方法，然后调用wrapIfNecessary方法去创建代理.
*
*
* 另外还有一些Aware接口，也会在该步骤中执行，例如：ApplicationContextAwareProcessor后置处理器，对应的setApplicationContext方法会被执行.
*/
wrappedBean = applyBeanPostProcessorsAfterInitialization(wrappedBean, beanName);
}
return wrappedBean;
}
finishRefresh --发布容器刷新完成事件
protected void finishRefresh() {
// Clear context-level resource caches (such as ASM metadata from scanning).
// 清空资源缓存.
clearResourceCaches();
// Initialize lifecycle processor for this context.
// 初始化声明周期处理器，用于处理Bean的生命周期.
initLifecycleProcessor();
// Propagate refresh to lifecycle processor first.
// 使用声明周期处理器传播刷新事件
getLifecycleProcessor().onRefresh();
// Publish the final event.
// 在Context中发布刷新事件
publishEvent(new ContextRefreshedEvent(this));
// Participate in LiveBeansView MBean, if active.
// 将本Context注册到ListBeansView中。包括注册Spring ApplicationContext对应的MBean
LiveBeansView.registerApplicationContext(this);
}
