spring源码解析三

前面两讲讲到了应用上下文的初始化，比较重要的点就是在初始化Reader读取器时，会想spring的bean工厂添加6个beanDefinition对象。而register(componentClasses)也不过是将配置类转化为bd，交给spring的bean工厂。前面对于refresh()方法却讲解的比较少，今天我们就来详细讲解refresh()方法。

/**
	 * spring初始化spring环境
	 * @throws BeansException
	 * @throws IllegalStateException
	 */
	@Override
	public void refresh() throws BeansException, IllegalStateException {
		synchronized (this.startupShutdownMonitor) {
			// Prepare this context for refreshing.
			/**
			 * 准备工作包括设置启动时间，是否激活标识位，是否初始化属性源，不重要
			 */
			prepareRefresh();
			// Tell the subclass to refresh the internal bean factory.
			// 获取到spring的bean工厂，即DefaultListableBeanFactory对象
			ConfigurableListableBeanFactory beanFactory = obtainFreshBeanFactory();

			// Prepare the bean factory for use in this context.
			//配置其标准特征，比如bean工厂向上下文的加载器和BeanPostProcessor，设置一系列自动注入忽略的接口或是注解
			prepareBeanFactory(beanFactory);
			try {
				// Allows post-processing of the bean factory in context subclasses.
				// 将servletContext上下文进行设置到bean工厂，没什么实际内容
				postProcessBeanFactory(beanFactory);
				// Invoke factory processors registered as beans in the context.
				// 执行已经被注册到工厂中的beanFactory中的工厂后置处理器，其实只有ConfigurationClassPostProcessor
				invokeBeanFactoryPostProcessors(beanFactory);
				// Register bean processors that intercept bean creation.
				registerBeanPostProcessors(beanFactory);
				// Initialize message source for this context.
				initMessageSource();
				// Initialize event multicaster for this context.
				initApplicationEventMulticaster();
				// Initialize other special beans in specific context subclasses.
				onRefresh();
				// Check for listener beans and register them.
				registerListeners();

				// Instantiate all remaining (non-lazy-init) singletons.
				finishBeanFactoryInitialization(beanFactory);

				// Last step: publish corresponding event.
				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.
				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();
			}
		}
	}

由于方法众多，我就不一一介绍，下面仅仅按顺序介绍比较重要的方法。prepareBeanFactory(beanFactory);
invokeBeanFactoryPostProcessors(beanFactory);

下面先看看prepareBeanFactory(beanFactory);

/**
	 * 配置beanFactory标准特征，使其具备某些能力，比如上下文的加载器和post-processors的回调
	 * Configure the factory's standard context characteristics,
	 * such as the context's ClassLoader and post-processors.
	 * 此处的beanFactory几乎等同于DefaultListableBeanFactory
	 * @param beanFactory the BeanFactory to configure
	 *  此处的入参beanFactory就是spring的bean工厂，它用来产生对象
	 */
	protected void prepareBeanFactory(ConfigurableListableBeanFactory beanFactory) {
		// Tell the internal bean factory to use the context's class loader etc.
		// 告诉工厂需要使用的类加载器
		beanFactory.setBeanClassLoader(getClassLoader());
		// 表达式解析器，为了能让beanFactory解析bean的表达式，能够在前台页面获取bean当中的属性。一般没用了，现在一般都是用EL表达式了
		beanFactory.setBeanExpressionResolver(new StandardBeanExpressionResolver(beanFactory.getBeanClassLoader()));
		// 添加属性编辑器，如对象与String类型的转换,例如 <property name="newsDao" ref="newsDao" />
		beanFactory.addPropertyEditorRegistrar(new ResourceEditorRegistrar(this, getEnvironment()));

		// Configure the bean factory with context callbacks.
		// 添加一个后置处理器，内部维护的list，类型是BeanPostProcessor.
		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.
		/**
		 * 如果自定义的Bean中没有名为environment，systemProperties，systemEnvironment的Bean
		 * 则注册三个key为上面提到的三个到spring的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());
		}
	}

上面代码其实就是准备beanFactory，方法里主要给beanFactory设置类加载器，属性解析器，表达式解析器，以及向beanFactory添加了BeanPostProcessor后置处理器。

下面我们来看refresh（）中比较重要的第二段代码----invokeBeanFactoryPostProcessors(beanFactory)做了哪些工作

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) {
			BeanDefinitionRegistry registry = (BeanDefinitionRegistry) beanFactory;
			//BeanFactoryPostProcessor与BeanDefinitionRegistryPostProcessor是继承关系，后者是子类，有扩展
			List<BeanFactoryPostProcessor> regularPostProcessors = new ArrayList<>();
			List<BeanDefinitionRegistryPostProcessor> registryProcessors = new ArrayList<>();

			// 自定义的beanFactoryPostProcessors，自定义的可能实现BeanDefinitionRegistryPostProcessor，
			// 也可能实现BeanFactoryPostProcessor，没有手动添加就会不走下面的循环逻辑
			for (BeanFactoryPostProcessor postProcessor : beanFactoryPostProcessors) {
				if (postProcessor instanceof BeanDefinitionRegistryPostProcessor) {
					// 添加手动添加的实现了BeanDefinitionRegistryPostProcessor的工厂后置处理器
					BeanDefinitionRegistryPostProcessor registryProcessor =
							(BeanDefinitionRegistryPostProcessor) postProcessor;
					registryProcessor.postProcessBeanDefinitionRegistry(registry);
					registryProcessors.add(registryProcessor);
				} else {
					// 存放手动添加的实现了BeanFactoryPostProcessors
					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.
			// currentRegistryProcessors 存放spring内部自己实现了BeanDefinitionRegistryPostProcessor接口的bean工厂后置处理器
			List<BeanDefinitionRegistryPostProcessor> currentRegistryProcessors = new ArrayList<>();

			// First, invoke the BeanDefinitionRegistryPostProcessors that implement PriorityOrdered.
			/**
			 * getBeanNamesForType是spring工厂的一个方法，可以通过class类型获取到beanName，class类型是spring工厂维护的bd中的属性
			 * 为什么beanFactory中可以获取到BeanDefinitionRegistryPostProcessor.class的beanName呢？
			 * 那是因为在初始化reader的时候有新建，BeanFactoryPostProcessor对象，并将其放置入beanFactory
			 */
			String[] postProcessorNames =
					beanFactory.getBeanNamesForType(BeanDefinitionRegistryPostProcessor.class, true, false);
			// postProcessorNames中应该只有ConfigurationClassPostProcessor(BeanDefinitionRegistryPostProcessor的实现类)，
			for (String ppName : postProcessorNames) {
				if (beanFactory.isTypeMatch(ppName, PriorityOrdered.class)) {
					currentRegistryProcessors.add(beanFactory.getBean(ppName, BeanDefinitionRegistryPostProcessor.class));
					// 存放名字
					processedBeans.add(ppName);
				}
			}
			// 排序不重要，况且currentRegistryProcessors这里只有一个数据
			sortPostProcessors(currentRegistryProcessors, beanFactory);
			// 合并list，不重要（为什么要合并呢？）
			registryProcessors.addAll(currentRegistryProcessors);
			/**
			 * 在方法内部调用postProcessBeanDefinitionRegistry(registry)，
			 * 对postProcessBeanDefinitionRegistry是不是很熟悉？？他就是我们在自定义beanFactoryPostProcessor时重写的方法
			 * 可以这么说，这就是回调啊，它会循环所有的BeanFactoryPostProcessor.当然了，循环的都是实现了
			 * BeanDefinitionRegistryPostProcessor的后置处理器
			 * 惊不惊喜？意不意外
			 */
			invokeBeanDefinitionRegistryPostProcessors(currentRegistryProcessors, registry);
			currentRegistryProcessors.clear();
}

上面只是粘贴出了源码的一部分，虽然不完整，但是这段代码已经能充分表示核心功能。
上面主要是做将自定义或者spring自身的BeanDefinitionRegistryPostProcessor的后置处理器循环遍历，查看是否处理过，没有处理便放入一个list集合，然后对这个集合进行排序，去重，最终调用后置处理器的重写的方法。主要是org.springframework.context.annotation.ConfigurationClassPostProcessor后置处理器（在初始化Reader添加的一个bd就是它）的processConfigBeanDefinitions()方法在完成处理工作。
下面是解析器解析后置处理器的代码：

public void processConfigBeanDefinitions(BeanDefinitionRegistry registry) {
		List<BeanDefinitionHolder> configCandidates = new ArrayList<>();
		// 这里会有7个元素，前6个是在初始化reader是新建并交给spring容器管理的，最后一个是register程序的入口处添加的配置类类
		String[] candidateNames = registry.getBeanDefinitionNames();
		/**
		 * 由于spring容器中有了程序的入口处添加配置类，那么refresh中肯定要解析它呀，不然怎么扫描注解类。。。
		 * 下面是遍历7个对象，然而解析的只有程序入口主类
		 */
		for (String beanName : candidateNames) {
			BeanDefinition beanDef = registry.getBeanDefinition(beanName);
			// 如果BD中的configurationClass属性为full或者lite，则意味着处理过了，直接跳过
			if (ConfigurationClassUtils.isFullConfigurationClass(beanDef) ||
					ConfigurationClassUtils.isLiteConfigurationClass(beanDef)) {
				if (logger.isDebugEnabled()) {
					logger.debug("Bean definition has already been processed as a configuration class: " + beanDef);
				}
				/**
				 * 判断所有的bd类是否添加了@Controller，@Component，@Service等注解
				 * 只要程序入口主类上添加的配置有以上注解，都会被解析；这里不是解析业务的注解类哦
				 * 七个BD对象，只有我们自己的配置BD会被处理，其他6个都没有注解
				 * configCandidates中是添加了@Controller，@Component，@Service等注解的类的bd对象
 				 */
			} else if (ConfigurationClassUtils.checkConfigurationClassCandidate(beanDef, this.metadataReaderFactory)) {
				configCandidates.add(new BeanDefinitionHolder(beanDef, beanName));
			}
		}

		// Return immediately if no @Configuration classes were found
		if (configCandidates.isEmpty()) {
			return;
		}

		// Sort by previously determined @Order value, if applicable
		// 排序，根据顺序去解析
		configCandidates.sort((bd1, bd2) -> {
			int i1 = ConfigurationClassUtils.getOrder(bd1.getBeanDefinition());
			int i2 = ConfigurationClassUtils.getOrder(bd2.getBeanDefinition());
			return Integer.compare(i1, i2);
		});

		// Detect any custom bean name generation strategy supplied through the enclosing application context
		SingletonBeanRegistry sbr = null;
		if (registry instanceof SingletonBeanRegistry) {
			sbr = (SingletonBeanRegistry) registry;
			// 是否有重写beanName的生成器，没有则使用默认的
			if (!this.localBeanNameGeneratorSet) {
				BeanNameGenerator generator = (BeanNameGenerator) sbr.getSingleton(CONFIGURATION_BEAN_NAME_GENERATOR);
				if (generator != null) {
					this.componentScanBeanNameGenerator = generator;
					this.importBeanNameGenerator = generator;
				}
			}
		}

		if (this.environment == null) {
			this.environment = new StandardEnvironment();
		}

		// Parse each @Configuration class
		// 实例化ConfigurationClassParser，为了解析各个配置类
		ConfigurationClassParser parser = new ConfigurationClassParser(
				this.metadataReaderFactory, this.problemReporter, this.environment,
				this.resourceLoader, this.componentScanBeanNameGenerator, registry);

		// candidates和alreadyParsed中都只会有一个，那就是程序的配置类的BD，用于去重
		Set<BeanDefinitionHolder> candidates = new LinkedHashSet<>(configCandidates);
		Set<ConfigurationClass> alreadyParsed = new HashSet<>(configCandidates.size());
		do {
			// candidates都是加了注解@Configuration，@Component等
			// 符合条件的只有一个，这里的作用是扫描我们的配置类
			parser.parse(candidates);
			parser.validate();
			......
		}
	}

将spring的beanFactory中所有未处理过得BD而且有@Configuration， @Component，@ComponentScan，@Import，@ImportResource注解的拿出来，形成一个集合，然后排序，最后使用解析器去解析

protected void processConfigurationClass(ConfigurationClass configClass) throws IOException {
		// 肯定不会跳过
		if (this.conditionEvaluator.shouldSkip(configClass.getMetadata(), ConfigurationPhase.PARSE_CONFIGURATION)) {
			return;
		}
		// ConfigurationClass只是进行了封装，封装了元数据和beanName
		ConfigurationClass existingClass = this.configurationClasses.get(configClass);
		if (existingClass != null) {
			// 处理Import注解
			if (configClass.isImported()) {
				if (existingClass.isImported()) {
					existingClass.mergeImportedBy(configClass);
				}
				// Otherwise ignore new imported config class; existing non-imported class overrides it.
				return;
			} else {
				// Explicit bean definition found, probably replacing an import.
				// Let's remove the old one and go with the new one.
				this.configurationClasses.remove(configClass);
				this.knownSuperclasses.values().removeIf(configClass::equals);
			}
		}

		// Recursively process the configuration class and its superclass hierarchy.
		// 进行了封装或是转换了而已
		SourceClass sourceClass = asSourceClass(configClass);
		do {
			//
			sourceClass = doProcessConfigurationClass(configClass, sourceClass);
		}
		while (sourceClass != null);

		this.configurationClasses.put(configClass, configClass);
	}

最终调用链会走到下面这个方法：

protected final SourceClass doProcessConfigurationClass(ConfigurationClass configClass, SourceClass sourceClass)
			throws IOException {

		// Process any @ComponentScan annotations
		// 拿到componentScan的属性，如basePackage，value。。。
		Set<AnnotationAttributes> componentScans = AnnotationConfigUtils.attributesForRepeatable(
				sourceClass.getMetadata(), ComponentScans.class, ComponentScan.class);
		if (!componentScans.isEmpty() &&
				!this.conditionEvaluator.shouldSkip(sourceClass.getMetadata(), ConfigurationPhase.REGISTER_BEAN)) {
			for (AnnotationAttributes componentScan : componentScans) {
				// The config class is annotated with @ComponentScan -> perform the scan immediately
				Set<BeanDefinitionHolder> scannedBeanDefinitions =
						this.componentScanParser.parse(componentScan, sourceClass.getMetadata().getClassName());
				// 去解析扫描包，很重要，最终调用componentScanParser.parse
				// Check the set of scanned definitions for any further config classes and parse recursively if needed
				for (BeanDefinitionHolder holder : scannedBeanDefinitions) {
					BeanDefinition bdCand = holder.getBeanDefinition().getOriginatingBeanDefinition();
					if (bdCand == null) {
						bdCand = holder.getBeanDefinition();
					}
					if (ConfigurationClassUtils.checkConfigurationClassCandidate(bdCand, this.metadataReaderFactory)) {
						parse(bdCand.getBeanClassName(), holder.getBeanName());
					}
				}
			}
		}

		// No superclass -> processing is complete
		return null;
	}

这里会根据bd的ComponentScan去扫描指定的包下的类，并且声称bd对象，置入spring的beanFactory。这样Spring的bean工厂便可以根据这些bd对象去创建对象了。