@Override publicvoidrefresh()throws BeansException, IllegalStateException { synchronized (this.startupShutdownMonitor) { // Prepare this context for refreshing. /** * 刷新预处理,这里主要是保存了容器的启动时间、启动标志等信息;和主流程的关系不大 */ prepareRefresh(); // Tell the subclass to refresh the internal bean factory. /** * 这里最终获取了ConfigurableListableBeanFactory,和主流程的关系也不大 * DefaultListableBeanFactory实现了ConfigurableListableBeanFactory */ ConfigurableListableBeanFactory beanFactory = obtainFreshBeanFactory();
// Prepare the bean factory for use in this context. /** 准备这个上下文要数用的bean工厂 ,这里会设置beanFactory忽略的依赖接口(一些Aware接口),注册一些bean工厂依赖的bean(BeanFactory、ApplicationContext * ApplicationEventPublisher、ResourceLoader),以及一些默认的bean。 * 添加了两个后置处理器:ApplicationContextAwareProcessor、ApplicationListenerDetector * 设置了bean表达式解析器等 */ prepareBeanFactory(beanFactory); try { // Allows post-processing of the bean factory in context subclasses. /** 注册上下文子类的后置处理器 */ postProcessBeanFactory(beanFactory);
// Invoke factory processors registered as beans in the context. /** 实例化并调用所有已经注册的BeanFactoryPostProcessor,会解析@Import、@Component等注解 */ invokeBeanFactoryPostProcessors(beanFactory);
// Initialize message source for this context. // 初始化国际化资源处理器。不是主线程代码 initMessageSource();
// Initialize event multicaster for this context. /** 初始化事件多播器,容器是使用自定义的广播器还是默认的时间广播器都是在这个方法中进行处理的 */ initApplicationEventMulticaster();
// Initialize other special beans in specific context subclasses. /** 初始化特定容器中的指定bean,这个方法时空方法,用来扩展用。 * 该方法是模板方法,容器刷新的时候可以自定义逻辑,不同的spring容器有不同的实现 */ onRefresh();
// Check for listener beans and register them. /** 注册事件监听器 */ registerListeners();
// Destroy already created singletons to avoid dangling resources. destroyBeans();
// Reset 'active' flag. cancelRefresh(ex);
// Propagate exception to caller. throw ex; }
finally { // Reset common introspection caches in Spring's core, since we // might not ever need metadata for singleton beans anymore... resetCommonCaches(); } } }
protectedvoidprepareRefresh(){ // Switch to active. 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. /** 在上下文环境中初始化任何占位符属性源。 * 如果一个类重写了initPropertySources()方法,比如设置了一个环境变量testProperty, * 在容器启动的时候,会去环境变量中寻找testProperty,如果没有找到这个属性就会抛出异常 */ initPropertySources();
// Validate that all properties marked as required are resolvable: // see ConfigurablePropertyResolver#setRequiredProperties /** 校验环境依赖的所有环境变量或者属性是否存在,是否可以解析, * 这一步和上一步initPropertySources()相互配合使用,在initPropertySources()中设置了环境变量, * 在这一步检测环境变量在配置文件中是否已经配置了。 * 例如:在initPropertySources()中配置了testProperty属性,那么在validateRequiredProperties()中 * 会检测环境变量是否真正有这个testProperty属性,是否可以解析这个属性,如果不存在这个testProperty属性, * 那么会抛出MissingRequiredPropertiesException异常 */ getEnvironment().validateRequiredProperties();
// Store pre-refresh ApplicationListeners... 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); }
// Allow for the collection of early ApplicationEvents,to be published once the multicaster is available... // to be published once the multicaster is available... /** 创建早期多播器,一旦多播器可用就可以发送事件 * 所谓早期多播器就是:我们的事件监听器还没有注册到多播器上的时候,都是早期事件,早期事件不许要手动publishEvent发布,在 * RegisterListener中会自动发布 */ this.earlyApplicationEvents = new LinkedHashSet<>(); }
protectedvoidprepareBeanFactory(ConfigurableListableBeanFactory beanFactory){ // Tell the internal bean factory to use the context's class loader etc. /** 告诉内部bean工厂使用上下文的类加载器等 */ beanFactory.setBeanClassLoader(getClassLoader()); beanFactory.setBeanExpressionResolver(new StandardBeanExpressionResolver(beanFactory.getBeanClassLoader())); beanFactory.addPropertyEditorRegistrar(new ResourceEditorRegistrar(this, getEnvironment()));
// Configure the bean factory with context callbacks. /** 添加一个后置处理器:ApplicationContextAwareProcessor,这个后置处理器实现了BeanPostProcessor接口 */ beanFactory.addBeanPostProcessor(new ApplicationContextAwareProcessor(this));
// BeanFactory interface not registered as resolvable type in a plain factory. // MessageSource registered (and found for autowiring) as a bean. /** 为beanFactory注册解析依赖的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. /** 为bean工厂注册一个早期的后置处理器,这个后置处理器是一个监听器(ApplicationListenerDetector) */ beanFactory.addBeanPostProcessor(new ApplicationListenerDetector(this));
// Detect a LoadTimeWeaver and prepare for weaving, if found. /** 如果存在LoadTimeWeaver,就将其注册为LoadTimeWeaverAwareProcessor后置处理器 */ 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. /** 注册默认环境的bean */ 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()); } }
protectedvoidinvokeBeanFactoryPostProcessors(ConfigurableListableBeanFactory beanFactory){ /** * 1.getBeanFactoryPostProcessors(): 拿到当前应用上下文beanFactoryPostProcessors变量中的值 * 2.invokeBeanFactoryPostProcessors: 实例化并调用所有已注册的BeanFactoryPostProcessor */ 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())); } }
// Register BeanPostProcessorChecker that logs an info message when // a bean is created during BeanPostProcessor instantiation, i.e. when // a bean is not eligible for getting processed by all BeanPostProcessors. /** 注册一个BeanPostProcessorChecker 当bean在BeanPostProcessor被实例化创建时期间, * 即当有一个bean不符合所有BeanPostProcessors处理的条件时,会记录消息日志*/ int beanProcessorTargetCount = beanFactory.getBeanPostProcessorCount() + 1 + postProcessorNames.length; beanFactory.addBeanPostProcessor(new BeanPostProcessorChecker(beanFactory, beanProcessorTargetCount));
// Separate between BeanPostProcessors that implement PriorityOrdered, // Ordered, and the rest. /** 将实现PriorityOrdered接口,Ordered接口和其他接口的BeanPostProcessors分离开来 */ 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); } } elseif (beanFactory.isTypeMatch(ppName, Ordered.class)) { orderedPostProcessorNames.add(ppName); } else { nonOrderedPostProcessorNames.add(ppName); } }
// First, register the BeanPostProcessors that implement PriorityOrdered. /** 首先,注册实现了PriorityOrdered接口的BeanProcessors */ sortPostProcessors(priorityOrderedPostProcessors, beanFactory); registerBeanPostProcessors(beanFactory, priorityOrderedPostProcessors);
// Next, register the BeanPostProcessors that implement Ordered. /** 接下来,注册实现Ordered接口的BeanPostProcessors */ 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);
// Now, register all regular BeanPostProcessors. /** 注册剩余其他的BeanPostProcessors */ 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);
// Re-register post-processor for detecting inner beans as ApplicationListeners, // moving it to the end of the processor chain (for picking up proxies etc). /** 重新注册后处理器以将内部 bean 注册为 ApplicationListeners,将其移动到处理器链的末尾(用于获取代理等) */ beanFactory.addBeanPostProcessor(new ApplicationListenerDetector(applicationContext)); }
// Do not initialize FactoryBeans here: We need to leave all regular beans // uninitialized to let post-processors apply to them! /** 不在这里初始化FactoryBeans,需要让所有的常规bean处于未初始化的状态,让后置处理器去初始化他们 */ 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 (!CollectionUtils.isEmpty(earlyEventsToProcess)) { for (ApplicationEvent earlyEvent : earlyEventsToProcess) { /** 调用ApplicationEventMulticaster中的multicastEvent发布事件 */ getApplicationEventMulticaster().multicastEvent(earlyEvent); } } }
protectedvoidfinishBeanFactoryInitialization(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 BeanFactoryPostProcessor // (such as a PropertySourcesPlaceholderConfigurer bean) registered any before: // at this point, primarily for resolution in annotation attribute values. /** 如果在此之前没有注册过BeanFactoryPostProcessor后置处理器(像PropertySourcesPlaceholderConfigurer bean), * 则注册一个默认的嵌入值解析器,主要来解析注解属性值 */ if (!beanFactory.hasEmbeddedValueResolver()) { beanFactory.addEmbeddedValueResolver(strVal -> getEnvironment().resolvePlaceholders(strVal)); }
// Initialize LoadTimeWeaverAware beans early to allow for registering their transformers early. /** 初始化 LoadTimeWeaverAware bean,目的是为了后面注册他们的转换器 */ String[] weaverAwareNames = beanFactory.getBeanNamesForType(LoadTimeWeaverAware.class, false, false); for (String weaverAwareName : weaverAwareNames) { getBean(weaverAwareName); }
// Stop using the temporary ClassLoader for type matching. /** 停止使用临时的 ClassLoader来进行类型匹配 */ beanFactory.setTempClassLoader(null);
// Allow for caching all bean definition metadata, not expecting further changes. /** 冻结所有的bean定义, 说明注册的bean定义将不能被修改或任何进一步的处理 */ beanFactory.freezeConfiguration();