Spring源码分析（四）

refresh方法分析上

prepareRefresh

	/**
	 * Prepare this context for refreshing, setting its startup date and
	 * active flag as well as performing any initialization of property sources.
	 */
	protected void prepareRefresh() {
		// 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.
		// 空方法，有同学可能会问，这为什么设计一个空方法呢？其实跳出整个方法，整体查看这个prepareRefresh方法，它其实是一种模板方法。
		// 如果我们需要拓展，可以重写
		initPropertySources();

		// Validate that all properties marked as required are resolvable:
		// see ConfigurablePropertyResolver#setRequiredProperties
		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...
		// 提前创建一个容器事件的队列
		this.earlyApplicationEvents = new LinkedHashSet<>();
	}
var foo = 'bar';

obtainFreshBeanFactory

ConfigurableListableBeanFactory beanFactory = obtainFreshBeanFactory();
		refreshBeanFactory();
		return getBeanFactory();

prepareBeanFactory

	/**
	 * Configure the factory's standard context characteristics,
	 * such as the context's ClassLoader and post-processors.
	 * @param beanFactory the BeanFactory to configure
	 */
	protected void prepareBeanFactory(ConfigurableListableBeanFactory beanFactory) {
		// Tell the internal bean factory to use the context's class loader etc.
		// 设置BeanFactory为context的classloader
		beanFactory.setBeanClassLoader(getClassLoader());
		if (!shouldIgnoreSpel) {
			//设置beanFactory的表达式语言处理器,spring3增加了表达式语言的支持
			beanFactory.setBeanExpressionResolver(new StandardBeanExpressionResolver(beanFactory.getBeanClassLoader()));
		}
		//为beanfactory增加了一个默认的propertyEditor,这个主要针对bean的属性等设置管理的一个工具
		beanFactory.addPropertyEditorRegistrar(new ResourceEditorRegistrar(this, getEnvironment()));

		// Configure the bean factory with context callbacks.
		// 配置BeanFactory Context的回调
		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.ignoreDependencyInterface(ApplicationStartup.class);

		// BeanFactory interface not registered as resolvable type in a plain factory.
		// MessageSource registered (and found for autowiring) as a bean.
		// 注入类型为BeanFactory时，注入beanFactory(DefaultListableBeanFactory)
		beanFactory.registerResolvableDependency(BeanFactory.class, beanFactory);
		beanFactory.registerResolvableDependency(ResourceLoader.class, this);
		//注入类型为ApplicationEventPublisher时，注入值为this(ApplicationContext)
		beanFactory.registerResolvableDependency(ApplicationEventPublisher.class, this);
		//注入类型为ApplicationContext时，注入值为this(ApplicationContext)
		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 (!IN_NATIVE_IMAGE && 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());
		}
		if (!beanFactory.containsLocalBean(APPLICATION_STARTUP_BEAN_NAME)) {
			beanFactory.registerSingleton(APPLICATION_STARTUP_BEAN_NAME, getApplicationStartup());
		}
	}

postProcessBeanFactory

空方法，留给我们自己去实现

invokeBeanFactoryPostProcessors

// An highlighted block
public static void invokeBeanFactoryPostProcessors(
        ConfigurableListableBeanFactory beanFactory, List<BeanFactoryPostProcessor> beanFactoryPostProcessors) {

    // Invoke BeanDefinitionRegistryPostProcessors first, if any.
    Set<String> processedBeans = new HashSet<>();

    //判断我们的beanFactory是否实现了BeanDefinitionRegistry
    if (beanFactory instanceof BeanDefinitionRegistry) {
        //强行把beanFactory转为BeanDefinitionRegistry
        BeanDefinitionRegistry registry = (BeanDefinitionRegistry) beanFactory;
        //保存BeanFactoryPostProcessor类型的后置处理器
        List<BeanFactoryPostProcessor> regularPostProcessors = new ArrayList<>();
        //保存BeanDefinitionRegistryPostProcessor类型的后置处理器
        List<BeanDefinitionRegistryPostProcessor> registryProcessors = new ArrayList<>();

        //循环我们传递进来的beanFactoryPostProcessors
        for (BeanFactoryPostProcessor postProcessor : beanFactoryPostProcessors) {
             //判断我们的后置处理器是不是BeanDefinitionRegistryPostProcessor
            if (postProcessor instanceof BeanDefinitionRegistryPostProcessor) {
                //进行强制转化
                BeanDefinitionRegistryPostProcessor registryProcessor =
                        (BeanDefinitionRegistryPostProcessor) postProcessor;
                //调用它的后置方法
                registryProcessor.postProcessBeanDefinitionRegistry(registry);
                //添加到我们用于保存的BeanDefinitionRegistryPostProcessor的集合中
                registryProcessors.add(registryProcessor);
            }
            else {
                //若没有实现BeanDefinitionRegistryPostProcessor接口，那么他就是BeanFactoryPostProcessor 把当前的后置处理器加入到regularPostProcessors中
                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<>();

        // First, invoke the BeanDefinitionRegistryPostProcessors that implement PriorityOrdered.
        //第一步:去容器中获取BeanDefinitionRegistryPostProcessor的bean的处理器名称
        String[] postProcessorNames =
                beanFactory.getBeanNamesForType(BeanDefinitionRegistryPostProcessor.class, true, false);
        //循环上一步获取的BeanDefinitionRegistryPostProcessor的类型名称
        for (String ppName : postProcessorNames) {
            //判断是否实现了PriorityOrdered接口的
            if (beanFactory.isTypeMatch(ppName, PriorityOrdered.class)) {
                //显示的调用getBean()的方式获取出该对象然后加入到currentRegistryProcessors集合中去
                currentRegistryProcessors.add(beanFactory.getBean(ppName, BeanDefinitionRegistryPostProcessor.class));
                //同时也加入到processedBeans集合中去
                processedBeans.add(ppName);
            }
        }
        //对currentRegistryProcessors集合中BeanDefinitionRegistryPostProcessor进行排序
        sortPostProcessors(currentRegistryProcessors, beanFactory);
        //把他加入到用于保存到registryProcessors中
        registryProcessors.addAll(currentRegistryProcessors);
        /**
         * 在这里典型的BeanDefinitionRegistryPostProcessor就是ConfigurationClassPostProcessor
         * 用于进行bean定义的加载 比如我们的包扫描，@import等
         */
        invokeBeanDefinitionRegistryPostProcessors(currentRegistryProcessors, registry);
        //调用完之后，马上clear
        currentRegistryProcessors.clear();

        // Next, invoke the BeanDefinitionRegistryPostProcessors that implement Ordered.
         //下一步 又去容器中获取BeanDefinitionRegistryPostProcessor的bean的处理器名称
        postProcessorNames = beanFactory.getBeanNamesForType(BeanDefinitionRegistryPostProcessor.class, true, false);
        //循环上一步获取的BeanDefinitionRegistryPostProcessor的类型名称
        for (String ppName : postProcessorNames) {
            //表示没有被处理过,且实现了Ordered接口的
            if (!processedBeans.contains(ppName) && beanFactory.isTypeMatch(ppName, Ordered.class)) {
                //显示的调用getBean()的方式获取出该对象然后加入到currentRegistryProcessors集合中去
                currentRegistryProcessors.add(beanFactory.getBean(ppName, BeanDefinitionRegistryPostProcessor.class));
                //同时也加入到processedBeans集合中去
                processedBeans.add(ppName);
            }
        }
        //对currentRegistryProcessors集合中BeanDefinitionRegistryPostProcessor进行排序
        sortPostProcessors(currentRegistryProcessors, beanFactory);
        //把他加入到用于保存到registryProcessors中
        registryProcessors.addAll(currentRegistryProcessors);
        //调用他的后置处理方法
        invokeBeanDefinitionRegistryPostProcessors(currentRegistryProcessors, registry);
        //调用完之后，马上clear
        currentRegistryProcessors.clear();


        //调用没有实现任何优先级接口的BeanDefinitionRegistryPostProcessor
        //定义一个重复处理的开关变量 默认值为true
        // Finally, invoke all other BeanDefinitionRegistryPostProcessors until no further ones appear.
        boolean reiterate = true;
        while (reiterate) {
            //进入循环马上把开关变量给改为false
            reiterate = false;
            //去容器中获取BeanDefinitionRegistryPostProcessor的bean的处理器名称
            postProcessorNames = beanFactory.getBeanNamesForType(BeanDefinitionRegistryPostProcessor.class, true, false);
            //循环上一步获取的BeanDefinitionRegistryPostProcessor的类型名称
            for (String ppName : postProcessorNames) {
                //没有被处理过的
                if (!processedBeans.contains(ppName)) {
                    //显示的调用getBean()的方式获取出该对象然后加入到currentRegistryProcessors集合中去
                    currentRegistryProcessors.add(beanFactory.getBean(ppName, BeanDefinitionRegistryPostProcessor.class));
                    //同时也加入到processedBeans集合中去
                    processedBeans.add(ppName);
                    //再次设置为true
                    reiterate = true;
                }
            }
            //对currentRegistryProcessors集合中BeanDefinitionRegistryPostProcessor进行排序
            sortPostProcessors(currentRegistryProcessors, beanFactory);
            //把他加入到用于保存到registryProcessors中
            registryProcessors.addAll(currentRegistryProcessors);
            //调用他的后置处理方法
            invokeBeanDefinitionRegistryPostProcessors(currentRegistryProcessors, registry);
            //进行clear
            currentRegistryProcessors.clear();
        }

        // Now, invoke the postProcessBeanFactory callback of all processors handled so far.
        //调用实现了BeanDefinitionRegistryPostProcessor的接口 他是他也同时实现了BeanFactoryPostProcessor的方法
        invokeBeanFactoryPostProcessors(registryProcessors, beanFactory);
        //调用BeanFactoryPostProcessor
        invokeBeanFactoryPostProcessors(regularPostProcessors, beanFactory);
    }

    else {
        //若当前的beanFactory没有实现了BeanDefinitionRegistry 直接调用beanFactoryPostProcessor接口的方法进行后置处理
        // 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!
    //最后一步 获取容器中所有的 BeanFactoryPostProcessor
    String[] postProcessorNames =
            beanFactory.getBeanNamesForType(BeanFactoryPostProcessor.class, true, false);

    // Separate between BeanFactoryPostProcessors that implement PriorityOrdered,
    // Ordered, and the rest.
    //保存BeanFactoryPostProcessor类型实现了priorityOrdered
    List<BeanFactoryPostProcessor> priorityOrderedPostProcessors = new ArrayList<>();
    //保存BeanFactoryPostProcessor类型实现了Ordered接口的
    List<String> orderedPostProcessorNames = new ArrayList<>();
    //保存BeanFactoryPostProcessor没有实现任何优先级接口的
    List<String> nonOrderedPostProcessorNames = new ArrayList<>();
    for (String ppName : postProcessorNames) {
        //processedBeans包含的话，表示在上面处理BeanDefinitionRegistryPostProcessor的时候处理过了
        if (processedBeans.contains(ppName)) {
            // skip - already processed in first phase above
        }
        //判断是否实现了PriorityOrdered
        else if (beanFactory.isTypeMatch(ppName, PriorityOrdered.class)) {
            priorityOrderedPostProcessors.add(beanFactory.getBean(ppName, BeanFactoryPostProcessor.class));
        }
        //判断是否实现了Ordered
        else if (beanFactory.isTypeMatch(ppName, Ordered.class)) {
            orderedPostProcessorNames.add(ppName);
        }
        //没有实现任何的优先级接口的
        else {
            nonOrderedPostProcessorNames.add(ppName);
        }
    }

    // First, invoke the BeanFactoryPostProcessors that implement PriorityOrdered.
    //先调用BeanFactoryPostProcessor实现了PriorityOrdered接口的
    sortPostProcessors(priorityOrderedPostProcessors, beanFactory);
    invokeBeanFactoryPostProcessors(priorityOrderedPostProcessors, beanFactory);

    // Next, invoke the BeanFactoryPostProcessors that implement Ordered.
    List<BeanFactoryPostProcessor> orderedPostProcessors = new ArrayList<>(orderedPostProcessorNames.size());
    for (String postProcessorName : orderedPostProcessorNames) {
        orderedPostProcessors.add(beanFactory.getBean(postProcessorName, BeanFactoryPostProcessor.class));
    }
    //再调用BeanFactoryPostProcessor实现了Ordered.
    sortPostProcessors(orderedPostProcessors, beanFactory);
    invokeBeanFactoryPostProcessors(orderedPostProcessors, beanFactory);

    // Finally, invoke all other BeanFactoryPostProcessors.
    //调用没有实现任何方法接口的
    List<BeanFactoryPostProcessor> nonOrderedPostProcessors = new ArrayList<>(nonOrderedPostProcessorNames.size());
    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();
}

其中invokeBeanDefinitionRegistryPostProcessors，这个方法也比较重要且代码量太大，我们放到单独一篇分析。