前言
本文主要研究启动Spring容器过程中出现的各种流程，以更好理解Spring的底层代码逻辑。由于现在Spring基于xml配置的方式已经有点过时，大都是用SpringBoot或SpringMVC基于注解的方法去定义创建bean，因此，本文主要以Spring注解配置启动类AnnotationConfigApplicationContext来研究Spring的底层源码。
启动流程
AnnotationConfigApplicationContext通过是以传入配置文件的方式来启动容器，基于注解的形式来管理bean之类的关系，下边是Spring常见的容器启动代码：
AnnotationConfigApplicationContext context = new AnnotationConfigApplicationContext(AppConfig.class);Spring的启动主要分为调用AnnotationConfigApplicationContext的构造方法、解析并注册配置类以及刷新容器的方法refresh，其中，最核心的就是refresh方法。
AnnotationConfigApplicationContext的构造方法
这里主要是基于父类GenericApplicationContext初始化默认bean工厂DefaultListableBeanFactory
并且初始化AnnotationConfigApplicationContext的两个重要的变量对象reader和scanner。
public GenericApplicationContext() {
this.beanFactory = new DefaultListableBeanFactory();
}通过各自的构建方法对这两个对象进行初始化，同时创建bean工厂、初始化内置的后置处理器以及容器的环境信息和资源加载器、文件解析器等等。
public AnnotationConfigApplicationContext() {
this.reader = new AnnotatedBeanDefinitionReader(this);
this.scanner = new ClassPathBeanDefinitionScanner(this);
}AnnotatedBeanDefinitionReader：注解形式的Bean定义扫描器，通过构造方法创建，构造方法中初始化Bean定义注册中心、用于处理条件注释的对象以及注解后置处理器。
registry传入AnnotationConfigApplicationContext自身，environment默认传入StandardEnvironment。
public AnnotatedBeanDefinitionReader(BeanDefinitionRegistry registry) {
this(registry, getOrCreateEnvironment(registry));
}public AnnotatedBeanDefinitionReader(BeanDefinitionRegistry registry, Environment environment) {
Assert.notNull(registry, "BeanDefinitionRegistry must not be null");
Assert.notNull(environment, "Environment must not be null");
this.registry = registry;
this.conditionEvaluator = new ConditionEvaluator(registry, environment, null);
AnnotationConfigUtils.registerAnnotationConfigProcessors(this.registry);
}1）初始化Bean定义注册中心为传入的registry参数；
2）根据传入的registry和environment创建条件注解处理器ConditionEvaluator，构造条件注解处理器期间也会初始化ConditionContextImpl上下文，ConditionContextImpl里边持有BeanDefinitionRegistry，ConfigurableListableBeanFactory，Environment，ResourceLoader，ClassLoader；
3）注册注解配置形式的后置处理器，主要是用于对bean中的注解进行相应的处理
主要包含以下几种后置处理器：
AnnotationAwareOrderComparator：排序比较器，用来支持Spring的Ordered类、@Order注解和@Priority注解。
ContextAnnotationAutowireCandidateResolver：bean自动注入时的候选解析器，主要用来处理@Lazy注解。
ConfigurationClassPostProcessor：处理@Configuration，@Import，@ImportResource和类内部的@Bean。
AutowiredAnnotationBeanPostProcessor：处理@Autowired注解和@Value注解的。
CommonAnnotationBeanPostProcessor：处理@javax.annotation.Resource、@javax.annotation.PostConstruct和@javax.annotation.PreDestroy等的注解。
PersistenceAnnotationBeanPostProcessor：处理@PersistenceContext注解的。
EventListenerMethodProcessor：处理@EventListener注解的支持。
DefaultEventListenerFactory：默认处理@EventListener注解的工厂。
ClassPathBeanDefinitionScanner：Classpath形式的Bean定义扫描器，通过构造方法创建，构造方法中初始化Bean定义注册中心、注册默认的filters、设置默认的环境信息以及资源读取器。
registry传入AnnotationConfigApplicationContext自身，useDefaultFilters默认传true，environment默认传入StandardEnvironment，resourceLoader传入AnnotationConfigApplicationContext自身。
public ClassPathBeanDefinitionScanner(BeanDefinitionRegistry registry) {
this(registry, true);
}public ClassPathBeanDefinitionScanner(BeanDefinitionRegistry registry, boolean useDefaultFilters) {
this(registry, useDefaultFilters, getOrCreateEnvironment(registry));
}public ClassPathBeanDefinitionScanner(BeanDefinitionRegistry registry, boolean useDefaultFilters,
Environment environment) {
this(registry, useDefaultFilters, environment,
(registry instanceof ResourceLoader ? (ResourceLoader) registry : null));
}public ClassPathBeanDefinitionScanner(BeanDefinitionRegistry registry, boolean useDefaultFilters,
Environment environment, @Nullable ResourceLoader resourceLoader) {
Assert.notNull(registry, "BeanDefinitionRegistry must not be null");
this.registry = registry;
if (useDefaultFilters) {
registerDefaultFilters();
}
setEnvironment(environment);
setResourceLoader(resourceLoader);
}1）初始化Bean定义注册中心为传入的registry参数；
2）注册默认的filters主要是初始化includeFilters，在里边加入Component、javax.annotation.ManagedBean和javax.inject.Named等几个注解；
3）设置环境为传入的environment参数；
4）设置资源读取器，传入resourceLoader，期间初始化资源解析器、元数据读取器工厂和Index解析器。
解析并注册配置类AppConfig
通过注解形式的Bean定义扫描器对配置类进行解析和注册。
public void register(Class<?>... annotatedClasses) {
Assert.notEmpty(annotatedClasses, "At least one annotated class must be specified");
this.reader.register(annotatedClasses);
}1）通过配置类的Class实例化注解格式的Bean定义AnnotatedGenericBeanDefinition 注解形式的bean定义，可以获取bean上的注解；
2）根据@Conditional条件注解判断当前bean是否需要跳过，配置类；
3）给bean定义注册supplier回调方法；
4）解析@Scope注解的元信息，给bean定义设置作用域；
5）获取bean名称，如未指定名称则默认的Bean Name生成器AnnotationBeanNameGenerator生成bean的名称，先尝试获取@Component/@Service/@Repository/@Controller上指定的beanName，如果没有获取到则生成默认的beanName，通常为类名首字母小写，如果类名前两个字母均为大写则不需要直接返回；
6）解析公共注解上面的元数据信息 例如：@DependsOn， @Lazy，@Primary，@DependsOn，@Description，如果bean上存在这些注解则给abd对应属性设置值；
7）将qualifiers和definitionCustomizers注册到bean定义；
8）bean定义的信息封装到BeanDefinitionHolder后注册到bean定义注册中心。
<T> void doRegisterBean(Class<T> annotatedClass, @Nullable Supplier<T> instanceSupplier, @Nullable String name,
@Nullable Class<? extends Annotation>[] qualifiers, BeanDefinitionCustomizer... definitionCustomizers) {
AnnotatedGenericBeanDefinition abd = new AnnotatedGenericBeanDefinition(annotatedClass);
if (this.conditionEvaluator.shouldSkip(abd.getMetadata())) {
return;
}
abd.setInstanceSupplier(instanceSupplier);
ScopeMetadata scopeMetadata = this.scopeMetadataResolver.resolveScopeMetadata(abd);
abd.setScope(scopeMetadata.getScopeName());
String beanName = (name != null ? name : this.beanNameGenerator.generateBeanName(abd, this.registry));
AnnotationConfigUtils.processCommonDefinitionAnnotations(abd);
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);
}
BeanDefinitionHolder definitionHolder = new BeanDefinitionHolder(abd, beanName);
definitionHolder = AnnotationConfigUtils.applyScopedProxyMode(scopeMetadata, definitionHolder, this.registry);
BeanDefinitionReaderUtils.registerBeanDefinition(definitionHolder, this.registry);
}刷新容器refresh
准备上下文的刷新工作
1）记录当前容器信息，如启动时间，关闭状态和激活状态；
2）可通过继承AbstractApplicationContext类，并重写initPropertySources，在方法中设置环境属性中必须需要的变量：getEnvironment().setRequiredProperties("requiredProp")；
3）检验设置的必要变量是否在当前环境变量中存在；
4）初始化earlyApplicationListeners和earlyApplicationEvents存放早期的监听器和应用事件。
protected void prepareRefresh() {
this.startupDate = System.currentTimeMillis();
this.closed.set(false);
this.active.set(true);
if (logger.isInfoEnabled()) {
logger.info("Refreshing " + this);
}
// Initialize any placeholder property sources in the context environment
initPropertySources();
// Validate that all properties marked as required are resolvable
// see ConfigurablePropertyResolver#setRequiredProperties
getEnvironment().validateRequiredProperties();
// Allow for the collection of early ApplicationEvents,
// to be published once the multicaster is available...
this.earlyApplicationEvents = new LinkedHashSet<>();
}获取bean工厂
1）刷新工厂，这里AnnotationConfigApplicationContext默认调用GenericApplicationContext，改变容器刷新标识。
2）调用子类的getBeanFactory()方法获取GenericApplicationContext中的默认bean工厂DefaultListableBeanFactory。
protected ConfigurableListableBeanFactory obtainFreshBeanFactory() {
refreshBeanFactory();
ConfigurableListableBeanFactory beanFactory = getBeanFactory();
if (logger.isDebugEnabled()) {
logger.debug("Bean factory for " + getDisplayName() + ": " + beanFactory);
}
return beanFactory;
}bean工厂的初始化准备工作
1）给bean工厂设置默认的类加载器、SPEL表达式解析器和类型转换器；
2）添加后置处理器ApplicationContextAwareProcessor处理回调接口；
3）bean工厂忽略回调接口的自动注入，即这些接口不能以@Autowire的方式自动注入，需要通过调用set方法去设置值；
4）为某些特定自动注入的实例，但注入的类型为这些类型时，会优先注入默认的实例；
5）添加ApplicationListenerDetector早期后置处理器以将实现ApplicationListener的bean添加到ApplicationContext的ApplicationListeners；
6）如果bean工厂中存在着名称为loadTimeWeaver的bean或bean定义，则给bean工厂中加入LoaderTimeWeaverAwareProcessor后置处理器；
7）给容器中注册一些与运行环境相关的单实例Bean。
protected void prepareBeanFactory(ConfigurableListableBeanFactory beanFactory) {
// Tell the internal bean factory to use the context's class loader etc.
beanFactory.setBeanClassLoader(getClassLoader());
beanFactory.setBeanExpressionResolver(new StandardBeanExpressionResolver(beanFactory.getBeanClassLoader()));
beanFactory.addPropertyEditorRegistrar(new ResourceEditorRegistrar(this, getEnvironment()));
// Configure the bean factory with context callbacks.
beanFactory.addBeanPostProcessor(new ApplicationContextAwareProcessor(this));
beanFactory.ignoreDependencyInterface(EnvironmentAware.class);
beanFactory.ignoreDependencyInterface(EmbeddedValueResolverAware.class);
beanFactory.ignoreDependencyInterface(ResourceLoaderAware.class);
beanFactory.ignoreDependencyInterface(ApplicationEventPublisherAware.class);
beanFactory.ignoreDependencyInterface(MessageSourceAware.class);
beanFactory.ignoreDependencyInterface(ApplicationContextAware.class);
// BeanFactory interface not registered as resolvable type in a plain factory.
// MessageSource registered (and found for autowiring) as a bean.
beanFactory.registerResolvableDependency(BeanFactory.class, beanFactory);
beanFactory.registerResolvableDependency(ResourceLoader.class, this);
beanFactory.registerResolvableDependency(ApplicationEventPublisher.class, this);
beanFactory.registerResolvableDependency(ApplicationContext.class, this);
// Register early post-processor for detecting inner beans as ApplicationListeners.
beanFactory.addBeanPostProcessor(new ApplicationListenerDetector(this));
// Detect a LoadTimeWeaver and prepare for weaving, if found.
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()));
}
// Register default environment beans.
if (!beanFactory.containsLocalBean(ENVIRONMENT_BEAN_NAME)) {
beanFactory.registerSingleton(ENVIRONMENT_BEAN_NAME, getEnvironment());
}
if (!beanFactory.containsLocalBean(SYSTEM_PROPERTIES_BEAN_NAME)) {
beanFactory.registerSingleton(SYSTEM_PROPERTIES_BEAN_NAME, getEnvironment().getSystemProperties());
}
if (!beanFactory.containsLocalBean(SYSTEM_ENVIRONMENT_BEAN_NAME)) {
beanFactory.registerSingleton(SYSTEM_ENVIRONMENT_BEAN_NAME, getEnvironment().getSystemEnvironment());
}
}添加Bean工厂扩展
自定义扩展点，可通过AbstractApplicationContext的子类实现该方法在Bean工厂初始化后进行扩展，示例如下：
public class MyApplicationContext extends AnnotationConfigApplicationContext {
@Override
protected void postProcessBeanFactory(ConfigurableListableBeanFactory beanFactory) {
BeanDefinition beanDefinition = beanFactory.getBeanDefinition("userService");
PropertyValue propertyValue = new PropertyValue("name", "小李");
beanDefinition.getPropertyValues().addPropertyValue(propertyValue);
System.out.println("definition: " + beanDefinition);
}
}执行bean工厂的后置处理器
传入参数为默认bean工厂和AnnotationConfigApplicationContext初始化设置的BeanFactoryPostProcessor集合beanFactoryPostProcessors
protected void invokeBeanFactoryPostProcessors(ConfigurableListableBeanFactory beanFactory) {
PostProcessorRegistrationDelegate.invokeBeanFactoryPostProcessors(beanFactory, getBeanFactoryPostProcessors());
// Detect a LoadTimeWeaver and prepare for weaving, if found in the meantime
// (e.g. through an @Bean method registered by ConfigurationClassPostProcessor)
if (beanFactory.getTempClassLoader() == null && beanFactory.containsBean(LOAD_TIME_WEAVER_BEAN_NAME)) {
beanFactory.addBeanPostProcessor(new LoadTimeWeaverAwareProcessor(beanFactory));
beanFactory.setTempClassLoader(new ContextTypeMatchClassLoader(beanFactory.getBeanClassLoader()));
}
}1）执行Bean工厂的所有后置处理器，详细流程如下：
① 遍历beanFactoryPostProcessors中区分BeanFactoryPostProcessor和BeanDefinitionRegistryPostProcessor，然后先执行其中BeanDefinitionRegistryPostProcessor的postProcessBeanDefinitionRegistry方法；
② 将Bean工厂的BeanDefinitionRegistryPostProcessor按实现PriorityOrdered接口、Ordered接口和未实现Ordered接口和PriorityOrdered接口的顺序，依次排序后执行其postProcessBeanDefinitionRegistry方法，其中最重要的是ConfigurationClassPostProcessor，该类会执行配置类解析、扫描包路径注册bean、条件注册的回调、方法及配置类的校验等操作；
③ 执行所有BeanDefinitionRegistryPostProcessor的postProcessBeanFactory方法；
④ 依次调用所有实现了PriorityOrdered接口、Ordered接口、普通未实现Ordered接口和PriorityOrdered接口的BeanFactoryPostProcessor的postProcessBeanFactory方法，其中同样涉及排序过程。
这里其实主要做的事情就是创建Bean定义并注册到Bean工厂中。
2）最后，会再次检测有没有注册bean名称为loadTimeWeaver的bean或bean定义，有的话则给bean工厂中加入LoaderTimeWeaverAwareProcessor后置处理器。
public static void invokeBeanFactoryPostProcessors(
ConfigurableListableBeanFactory beanFactory, List<BeanFactoryPostProcessor> beanFactoryPostProcessors) {
// Invoke BeanDefinitionRegistryPostProcessors first, if any.
Set<String> processedBeans = new HashSet<>();
if (beanFactory instanceof BeanDefinitionRegistry) {
BeanDefinitionRegistry registry = (BeanDefinitionRegistry) beanFactory;
List<BeanFactoryPostProcessor> regularPostProcessors = new LinkedList<>();
List<BeanDefinitionRegistryPostProcessor> registryProcessors = new LinkedList<>();
for (BeanFactoryPostProcessor postProcessor : beanFactoryPostProcessors) {
if (postProcessor instanceof BeanDefinitionRegistryPostProcessor) {
BeanDefinitionRegistryPostProcessor registryProcessor =
(BeanDefinitionRegistryPostProcessor) postProcessor;
registryProcessor.postProcessBeanDefinitionRegistry(registry);
registryProcessors.add(registryProcessor);
}
else {
regularPostProcessors.add(postProcessor);
}
}
// Do not initialize FactoryBeans here: We need to leave all regular beans
// uninitialized to let the bean factory post-processors apply to them!
// Separate between BeanDefinitionRegistryPostProcessors that implement
// PriorityOrdered, Ordered, and the rest.
List<BeanDefinitionRegistryPostProcessor> currentRegistryProcessors = new ArrayList<>();
// First, invoke the BeanDefinitionRegistryPostProcessors that implement PriorityOrdered.
String[] postProcessorNames =
beanFactory.getBeanNamesForType(BeanDefinitionRegistryPostProcessor.class, true, false);
for (String ppName : postProcessorNames) {
if (beanFactory.isTypeMatch(ppName, PriorityOrdered.class)) {
currentRegistryProcessors.add(beanFactory.getBean(ppName, BeanDefinitionRegistryPostProcessor.class));
processedBeans.add(ppName);
}
}
sortPostProcessors(currentRegistryProcessors, beanFactory);
registryProcessors.addAll(currentRegistryProcessors);
invokeBeanDefinitionRegistryPostProcessors(currentRegistryProcessors, registry);
currentRegistryProcessors.clear();
// Next, invoke the BeanDefinitionRegistryPostProcessors that implement Ordered.
postProcessorNames = beanFactory.getBeanNamesForType(BeanDefinitionRegistryPostProcessor.class, true, false);
for (String ppName : postProcessorNames) {
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();
// Finally, invoke all other BeanDefinitionRegistryPostProcessors until no further ones appear.
boolean reiterate = true;
while (reiterate) {
reiterate = false;
postProcessorNames = beanFactory.getBeanNamesForType(BeanDefinitionRegistryPostProcessor.class, true, false);
for (String ppName : postProcessorNames) {
if (!processedBeans.contains(ppName)) {
currentRegistryProcessors.add(beanFactory.getBean(ppName, BeanDefinitionRegistryPostProcessor.class));
processedBeans.add(ppName);
reiterate = true;
}
}
sortPostProcessors(currentRegistryProcessors, beanFactory);
registryProcessors.addAll(currentRegistryProcessors);
invokeBeanDefinitionRegistryPostProcessors(currentRegistryProcessors, registry);
currentRegistryProcessors.clear();
}
// Now, invoke the postProcessBeanFactory callback of all processors handled so far.
invokeBeanFactoryPostProcessors(registryProcessors, beanFactory);
invokeBeanFactoryPostProcessors(regularPostProcessors, beanFactory);
}
else {
// Invoke factory processors registered with the context instance.
invokeBeanFactoryPostProcessors(beanFactoryPostProcessors, beanFactory);
}
// Do not initialize FactoryBeans here: We need to leave all regular beans
// uninitialized to let the bean factory post-processors apply to them!
String[] postProcessorNames =
beanFactory.getBeanNamesForType(BeanFactoryPostProcessor.class, true, false);
// Separate between BeanFactoryPostProcessors that implement PriorityOrdered,
// Ordered, and the rest.
List<BeanFactoryPostProcessor> priorityOrderedPostProcessors = new ArrayList<>();
List<String> orderedPostProcessorNames = new ArrayList<>();
List<String> nonOrderedPostProcessorNames = new ArrayList<>();
for (String ppName : postProcessorNames) {
if (processedBeans.contains(ppName)) {
// skip - already processed in first phase above
}
else if (beanFactory.isTypeMatch(ppName, PriorityOrdered.class)) {
priorityOrderedPostProcessors.add(beanFactory.getBean(ppName, BeanFactoryPostProcessor.class));
}
else if (beanFactory.isTypeMatch(ppName, Ordered.class)) {
orderedPostProcessorNames.add(ppName);
}
else {
nonOrderedPostProcessorNames.add(ppName);
}
}
// First, invoke the BeanFactoryPostProcessors that implement PriorityOrdered.
sortPostProcessors(priorityOrderedPostProcessors, beanFactory);
invokeBeanFactoryPostProcessors(priorityOrderedPostProcessors, beanFactory);
// Next, invoke the BeanFactoryPostProcessors that implement Ordered.
List<BeanFactoryPostProcessor> orderedPostProcessors = new ArrayList<>();
for (String postProcessorName : orderedPostProcessorNames) {
orderedPostProcessors.add(beanFactory.getBean(postProcessorName, BeanFactoryPostProcessor.class));
}
sortPostProcessors(orderedPostProcessors, beanFactory);
invokeBeanFactoryPostProcessors(orderedPostProcessors, beanFactory);
// Finally, invoke all other BeanFactoryPostProcessors.
List<BeanFactoryPostProcessor> nonOrderedPostProcessors = new ArrayList<>();
for (String postProcessorName : nonOrderedPostProcessorNames) {
nonOrderedPostProcessors.add(beanFactory.getBean(postProcessorName, BeanFactoryPostProcessor.class));
}
invokeBeanFactoryPostProcessors(nonOrderedPostProcessors, beanFactory);
// Clear cached merged bean definitions since the post-processors might have
// modified the original metadata, e.g. replacing placeholders in values...
beanFactory.clearMetadataCache();
}注册所有bean的后置处理器
1）获取所有实现BeanPostProcessor的Bean；
2）给bean工厂添加BeanPostProcessorChecker后置处理器，用于记录Bean在BeanPostProcessor实例化时的信息，beanProcessorTargetCount里边+1是把BeanPostProcessorChecker提前算上；
3）依次将实现PriorityOrdered接口、Ordered接口和普通的Bean后置处理器排序后添加到bean工厂；
4）将上边bean后置处理器中实现了MergedBeanDefinitionPostProcessor接口的Bean后置处理器排序后再添加到bean工厂，将这些放到列表后边
5）重复添加ApplicationListenerDetector后置处理器，将该beanPostProcessor移动到beanPostProcessor对应的list的最后，因为上述后置处理可能会处理到类型为ApplicationListenerDetector的bean。
public static void registerBeanPostProcessors(
ConfigurableListableBeanFactory beanFactory, AbstractApplicationContext applicationContext) {
String[] postProcessorNames = beanFactory.getBeanNamesForType(BeanPostProcessor.class, true, false);
// Register BeanPostProcessorChecker that logs an info message when
// a bean is created during BeanPostProcessor instantiation, i.e. when
// a bean is not eligible for getting processed by all BeanPostProcessors.
int beanProcessorTargetCount = beanFactory.getBeanPostProcessorCount() + 1 + postProcessorNames.length;
beanFactory.addBeanPostProcessor(new BeanPostProcessorChecker(beanFactory, beanProcessorTargetCount));
// Separate between BeanPostProcessors that implement PriorityOrdered,
// Ordered, and the rest.
List<BeanPostProcessor> priorityOrderedPostProcessors = new ArrayList<>();
List<BeanPostProcessor> internalPostProcessors = new ArrayList<>();
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);
}
}
// First, register the BeanPostProcessors that implement PriorityOrdered.
sortPostProcessors(priorityOrderedPostProcessors, beanFactory);
registerBeanPostProcessors(beanFactory, priorityOrderedPostProcessors);
// Next, register the BeanPostProcessors that implement Ordered.
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);
}
}
sortPostProcessors(orderedPostProcessors, beanFactory);
registerBeanPostProcessors(beanFactory, orderedPostProcessors);
// Now, register all regular BeanPostProcessors.
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.
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).
beanFactory.addBeanPostProcessor(new ApplicationListenerDetector(applicationContext));
}初始化消息源
消息源用来做国际化，消息绑定，消息解析等功能，一般在SpringMVC中会使用到。
1）如果有id为messageSource，而且类型是MessageSource的bean或bean定义，则直接赋值给messageSource属性；
2）如果没有，则创建一个DelegatingMessageSource类型的messageSource对象，赋值给messageSource属性并将其注册到bean工厂中。
protected void initMessageSource() {
ConfigurableListableBeanFactory beanFactory = getBeanFactory();
if (beanFactory.containsLocalBean(MESSAGE_SOURCE_BEAN_NAME)) {
this.messageSource = beanFactory.getBean(MESSAGE_SOURCE_BEAN_NAME, MessageSource.class);
// Make MessageSource aware of parent MessageSource.
if (this.parent != null && this.messageSource instanceof HierarchicalMessageSource) {
HierarchicalMessageSource hms = (HierarchicalMessageSource) this.messageSource;
if (hms.getParentMessageSource() == null) {
// Only set parent context as parent MessageSource if no parent MessageSource
// registered already.
hms.setParentMessageSource(getInternalParentMessageSource());
}
}
if (logger.isDebugEnabled()) {
logger.debug("Using MessageSource [" + this.messageSource + "]");
}
}
else {
// Use empty MessageSource to be able to accept getMessage calls.
DelegatingMessageSource dms = new DelegatingMessageSource();
dms.setParentMessageSource(getInternalParentMessageSource());
this.messageSource = dms;
beanFactory.registerSingleton(MESSAGE_SOURCE_BEAN_NAME, this.messageSource);
if (logger.isDebugEnabled()) {
logger.debug("Unable to locate MessageSource with name '" + MESSAGE_SOURCE_BEAN_NAME +
"': using default [" + this.messageSource + "]");
}
}
}初始化事件派发器
1）如果有id为applicationEventMulticaster，而且类型是ApplicationEventMulticaster的bean或bean定义，直接赋值给applicationEventMulticaster属性；
2）如果没有，则创建一个SimpleApplicationEventMulticaster类型的ApplicationEventMulticaster对象，赋值给applicationEventMulticaster属性并将其注册到bean工厂中。
protected void initApplicationEventMulticaster() {
ConfigurableListableBeanFactory beanFactory = getBeanFactory();
if (beanFactory.containsLocalBean(APPLICATION_EVENT_MULTICASTER_BEAN_NAME)) {
this.applicationEventMulticaster =
beanFactory.getBean(APPLICATION_EVENT_MULTICASTER_BEAN_NAME, ApplicationEventMulticaster.class);
if (logger.isDebugEnabled()) {
logger.debug("Using ApplicationEventMulticaster [" + this.applicationEventMulticaster + "]");
}
}
else {
this.applicationEventMulticaster = new SimpleApplicationEventMulticaster(beanFactory);
beanFactory.registerSingleton(APPLICATION_EVENT_MULTICASTER_BEAN_NAME, this.applicationEventMulticaster);
if (logger.isDebugEnabled()) {
logger.debug("Unable to locate ApplicationEventMulticaster with name '" +
APPLICATION_EVENT_MULTICASTER_BEAN_NAME +
"': using default [" + this.applicationEventMulticaster + "]");
}
}
}onRefresh
默认为空，需通过继承AbstractApplicationContext覆写该方法。
注册监听器
1）将初始定义的监听器和根据类型获取到的监听器的名称绑定到事件派发器；
2）派发早期产生的事件。
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!
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...
Set<ApplicationEvent> earlyEventsToProcess = this.earlyApplicationEvents;
this.earlyApplicationEvents = null;
if (earlyEventsToProcess != null) {
for (ApplicationEvent earlyEvent : earlyEventsToProcess) {
getApplicationEventMulticaster().multicastEvent(earlyEvent);
}
}
}完成Bean工厂的初始化
1）初始化类型转换服务conversionService；
2）初始化嵌入值解析器embeddedValueResolvers；
3）初始化所有实现了LoadTimeWeaverAware接口的子类；
4）停止使用临时的类加载器并缓存(冻结)所有的BeanName；
5）提前初始化所有的单实例Bean。
protected void finishBeanFactoryInitialization(ConfigurableListableBeanFactory beanFactory) {
// Initialize conversion service for this context.
if (beanFactory.containsBean(CONVERSION_SERVICE_BEAN_NAME) &&
beanFactory.isTypeMatch(CONVERSION_SERVICE_BEAN_NAME, ConversionService.class)) {
beanFactory.setConversionService(
beanFactory.getBean(CONVERSION_SERVICE_BEAN_NAME, ConversionService.class));
}
// Register a default embedded value resolver if no bean post-processor
// (such as a PropertyPlaceholderConfigurer bean) registered any before:
// at this point, primarily for resolution in annotation attribute values.
if (!beanFactory.hasEmbeddedValueResolver()) {
beanFactory.addEmbeddedValueResolver(strVal -> getEnvironment().resolvePlaceholders(strVal));
}
// Initialize LoadTimeWeaverAware beans early to allow for registering their transformers early.
String[] weaverAwareNames = beanFactory.getBeanNamesForType(LoadTimeWeaverAware.class, false, false);
for (String weaverAwareName : weaverAwareNames) {
getBean(weaverAwareName);
}
// Stop using the temporary ClassLoader for type matching.
beanFactory.setTempClassLoader(null);
// Allow for caching all bean definition metadata, not expecting further changes.
beanFactory.freezeConfiguration();
// Instantiate all remaining (non-lazy-init) singletons.
beanFactory.preInstantiateSingletons();
}完成刷新容器
1）清空资源缓存；
2）初始化声明周期处理器；
3）使用声明周期处理器传播刷新事件；
4）在Context中发布刷新事件；
5）将本Context注册到ListBeansView中。
protected void finishRefresh() {
// Clear context-level resource caches (such as ASM metadata from scanning).
clearResourceCaches();
// Initialize lifecycle processor for this context.
initLifecycleProcessor();
// Propagate refresh to lifecycle processor first.
getLifecycleProcessor().onRefresh();
// Publish the final event.
publishEvent(new ContextRefreshedEvent(this));
// Participate in LiveBeansView MBean, if active.
LiveBeansView.registerApplicationContext(this);
}清除公共缓存
protected void resetCommonCaches() {
ReflectionUtils.clearCache();
ResolvableType.clearCache();
CachedIntrospectionResults.clearClassLoader(getClassLoader());
}总结
Spring的启动过程较为繁琐，整个容器启动的过程主要就是对bean的管理以及一些事件发布、国际化、类型转换，并且框架给每个类和接口都分配了对应职责，通过继承和实现将这些功能整合起来，比如启动类AnnotationConfigApplicationContext以及默认bean工厂DefaultListableBeanFactory，我觉得学习Spring框架更重要的还是学习它如何合理地去设计框架，后续我也准备更深入地分析探讨各个类和各个接口的作用和职责，也是想更好地去了解它使用它。
扫一扫
3597
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
