spring启动流程探索五、refresh()（4）invokeBeanDefinitionRegistryPostProcessors

invokeBeanDefinitionRegistryPostProcessors

这个方法里面做的工作是很多，他首先会去刷新beanDefinitionNames，而且有很多加载逻辑。
他在bean容器的生命周期有很重要的工作。我们先上代码把，看后代码再讲理解

private static void invokeBeanDefinitionRegistryPostProcessors(Collection<? extends BeanDefinitionRegistryPostProcessor> postProcessors, BeanDefinitionRegistry registry) {
    for (BeanDefinitionRegistryPostProcessor postProcessor : postProcessors) {
    postProcessor.postProcessBeanDefinitionRegistry(registry);}}

这里的作用只有一个，就是去循环调用postProcessor.postProcessBeanDefinitionRegistry，在
invokeBeanFactoryPostProcessors中调用了三次invokeBeanDefinitionRegistryPostProcessors，但是他第一次和其他两次调用时有很多不同的，大家可以跟着我继续去探讨。

第一次调用invokeBeanDefinitionRegistryPostProcessors

这时候进来的的beanName为internalConfigurationAnnotationProcessor，PostProcessors是
ConfigurationClassPostProcessor这个类，他在这个类里面才会开始去处理你注入的配置类的注解，他调用方法是这个

	@Overridepublic void postProcessBeanDefinitionRegistry(BeanDefinitionRegistry registry) {
    int registryId = System.identityHashCode(registry);if (this.registriesPostProcessed.contains(registryId)) {
    throw new IllegalStateException("postProcessBeanDefinitionRegistry already called on this post-processor against " + registry);}if (this.factoriesPostProcessed.contains(registryId)) {
    throw new IllegalStateException("postProcessBeanFactory already called on this post-processor against " + registry);}this.registriesPostProcessed.add(registryId);processConfigBeanDefinitions(registry);}

看下这个代码，其实工作就是赋值了一个hashcode，然后做了两次判断，后面的processConfigBeanDefinitions才是核心，继续往下

processConfigBeanDefinitions(registry)

	public void processConfigBeanDefinitions(BeanDefinitionRegistry registry) {
    List<BeanDefinitionHolder> configCandidates = new ArrayList<>();String[] candidateNames = registry.getBeanDefinitionNames();for (String beanName : candidateNames) {
    BeanDefinition beanDef = registry.getBeanDefinition(beanName);// 判断配置类是否已经执行了if (beanDef.getAttribute(ConfigurationClassUtils.CONFIGURATION_CLASS_ATTRIBUTE) != null) {
    if (logger.isDebugEnabled()) {
    logger.debug("Bean definition has already been processed as a configuration class: " + beanDef);}}// 检查是否为配置类，是的话就加入到configCandidateselse 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// 检测通过封闭的应用程序上下文提供的任何自定义Bean名称生成策略// 其实检测上下文内置的配置类internalConfigurationBeanNameGeneratorSingletonBeanRegistry sbr = null;if (registry instanceof SingletonBeanRegistry) {
    sbr = (SingletonBeanRegistry) registry;if (!this.localBeanNameGeneratorSet) {
    BeanNameGenerator generator = (BeanNameGenerator) sbr.getSingleton(AnnotationConfigUtils.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// 初始化Parse 开始读取@Configuration配置类ConfigurationClassParser parser = new ConfigurationClassParser(this.metadataReaderFactory, this.problemReporter, this.environment,this.resourceLoader, this.componentScanBeanNameGenerator, registry);Set<BeanDefinitionHolder> candidates = new LinkedHashSet<>(configCandidates);Set<ConfigurationClass> alreadyParsed = new HashSet<>(configCandidates.size());// 循环去创建candidates注入的bean 的定义信息do {
    // 核心方法一. 读取配置类的注解信息，后面详解parser.parse(candidates);parser.validate();Set<ConfigurationClass> configClasses = new LinkedHashSet<>(parser.getConfigurationClasses());configClasses.removeAll(alreadyParsed);// Read the model and create bean definitions based on its contentif (this.reader == null) {
    this.reader = new ConfigurationClassBeanDefinitionReader(registry, this.sourceExtractor, this.resourceLoader, this.environment,this.importBeanNameGenerator, parser.getImportRegistry());}// 核心方法二, 把configClasses里面的一些定义信息读取到registrythis.reader.loadBeanDefinitions(configClasses);// configClasses是已经读取过配置了alreadyParsed.addAll(configClasses);candidates.clear();// 如果registry的定义信息大于之前，说明loadBeanDefinitions和parse阶段新增了定义信息// 需要把新增的定义信息加入进去if (registry.getBeanDefinitionCount() > candidateNames.length) {
    String[] newCandidateNames = registry.getBeanDefinitionNames();Set<String> oldCandidateNames = new HashSet<>(Arrays.asList(candidateNames));Set<String> alreadyParsedClasses = new HashSet<>();for (ConfigurationClass configurationClass : alreadyParsed) {
    alreadyParsedClasses.add(configurationClass.getMetadata().getClassName());}for (String candidateName : newCandidateNames) {
    if (!oldCandidateNames.contains(candidateName)) {
    BeanDefinition bd = registry.getBeanDefinition(candidateName);if (ConfigurationClassUtils.checkConfigurationClassCandidate(bd, this.metadataReaderFactory) &&!alreadyParsedClasses.contains(bd.getBeanClassName())) {
    candidates.add(new BeanDefinitionHolder(bd, candidateName));}}}candidateNames = newCandidateNames;}}while (!candidates.isEmpty());// Register the ImportRegistry as a bean in order to support ImportAware @Configuration classes//将ImportRegistry注册为Bean，以支持ImportAware @Configuration类if (sbr != null && !sbr.containsSingleton(IMPORT_REGISTRY_BEAN_NAME)) {
    sbr.registerSingleton(IMPORT_REGISTRY_BEAN_NAME, parser.getImportRegistry());}if (this.metadataReaderFactory instanceof CachingMetadataReaderFactory) {
    // Clear cache in externally provided MetadataReaderFactory; this is a no-op// for a shared cache since it'll be cleared by the ApplicationContext.// 清除缓存((CachingMetadataReaderFactory) this.metadataReaderFactory).clearCache();}}

核心一、parser.parse(candidates)

public void parse(Set<BeanDefinitionHolder> configCandidates) {
    // 遍历for (BeanDefinitionHolder holder : configCandidates) {
    BeanDefinition bd = holder.getBeanDefinition();try {
    // 判断类型if (bd instanceof AnnotatedBeanDefinition) {
    parse(((AnnotatedBeanDefinition) bd).getMetadata(), holder.getBeanName());}else if (bd instanceof AbstractBeanDefinition && ((AbstractBeanDefinition) bd).hasBeanClass()) {
    parse(((AbstractBeanDefinition) bd).getBeanClass(), holder.getBeanName());}else {
    parse(bd.getBeanClassName(), holder.getBeanName());}}catch (BeanDefinitionStoreException ex) {
    throw ex;}catch (Throwable ex) {
    throw new BeanDefinitionStoreException("Failed to parse configuration class [" + bd.getBeanClassName() + "]", ex);}}// 把一些延时加载的引入放进configurationClasses中this.deferredImportSelectorHandler.process();}

这里他主要通过类型判断会走parse(((AnnotatedBeanDefinition) bd).getMetadata(), holder.getBeanName())这个方法

	protected final void parse(AnnotationMetadata metadata, String beanName) throws IOException {
    processConfigurationClass(new ConfigurationClass(metadata, beanName), DEFAULT_EXCLUSION_FILTER);}

继续往下

	protected void processConfigurationClass(ConfigurationClass configClass, Predicate<String> filter) throws IOException {
    // 是否需要跳过if (this.conditionEvaluator.shouldSkip(configClass.getMetadata(), ConfigurationPhase.PARSE_CONFIGURATION)) {
    return;}// 先去看看缓存中是否存在ConfigurationClass existingClass = this.configurationClasses.get(configClass);if (existingClass != null) {
    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.// 开始递归去处理configurationSourceClass sourceClass = asSourceClass(configClass, filter);do {
    sourceClass = doProcessConfigurationClass(configClass, sourceClass, filter);}while (sourceClass != null);this.configurationClasses.put(configClass, configClass);}

doProcessConfigurationClass

protected final SourceClass doProcessConfigurationClass(ConfigurationClass configClass, SourceClass sourceClass, Predicate<String> filter)throws IOException {
    // 先去递归处理配置类内部的Component注解if (configClass.getMetadata().isAnnotated(Component.class.getName())) {
    // Recursively process any member (nested) classes firstprocessMemberClasses(configClass, sourceClass, filter);}// 处理@PropertySource// Process any @PropertySource annotationsfor (AnnotationAttributes propertySource : AnnotationConfigUtils.attributesForRepeatable(sourceClass.getMetadata(), PropertySources.class,org.springframework.context.annotation.PropertySource.class)) {
    if (this.environment instanceof ConfigurableEnvironment) {
    processPropertySource(propertySource);}else {
    logger.info("Ignoring @PropertySource annotation on [" + sourceClass.getMetadata().getClassName() +"]. Reason: Environment must implement ConfigurableEnvironment");}}// 处理@ComponentScan和ComponentScans// Process any @ComponentScan annotationsSet<AnnotationAttributes> componentScans = AnnotationConfigUtils.attributesForRepeatable(sourceClass.getMetadata(), ComponentScans.class, ComponentScan.class);if (!componentScans.isEmpty() &&!this.conditionEvaluator.shouldSkip(sourceClass.getMetadata(), ConfigurationPhase.REGISTER_BEAN)) {
    // 循环拿到的componentScanfor (AnnotationAttributes componentScan : componentScans) {
    // The config class is annotated with @ComponentScan -> perform the scan immediatelySet<BeanDefinitionHolder> scannedBeanDefinitions =// 开始解析componentScan。// 核心方法 这里面详细讲解了spring怎么通过componentScan去读取bean信息this.componentScanParser.parse(componentScan, sourceClass.getMetadata().getClassName());// Check the set of scanned definitions for any further config classes and parse recursively if neededfor (BeanDefinitionHolder holder : scannedBeanDefinitions) {
    BeanDefinition bdCand = holder.getBeanDefinition().getOriginatingBeanDefinition();if (bdCand == null) {
    bdCand = holder.getBeanDefinition();}// 扫描componentScan地址下是否有其他的配置类信息，递归去接解析if (ConfigurationClassUtils.checkConfigurationClassCandidate(bdCand, this.metadataReaderFactory)) {
    parse(bdCand.getBeanClassName(), holder.getBeanName());}}}}// Process any @Import annotations// 处理@Import注解processImports(configClass, sourceClass, getImports(sourceClass), filter, true);// Process any @ImportResource annotations// 处理@ImportResourceAnnotationAttributes importResource =AnnotationConfigUtils.attributesFor(sourceClass.getMetadata(), ImportResource.class);if (importResource != null) {
    String[] resources = importResource.getStringArray("locations");Class<? extends BeanDefinitionReader> readerClass = importResource.getClass("reader");for (String resource : resources) {
    String resolvedResource = this.environment.resolveRequiredPlaceholders(resource);// 把引入的资源放到configClassconfigClass.addImportedResource(resolvedResource, readerClass);}}// Process individual @Bean methods// 处理@BeanSet<MethodMetadata> beanMethods = retrieveBeanMethodMetadata(sourceClass);for (MethodMetadata methodMetadata : beanMethods) {
    configClass.addBeanMethod(new BeanMethod(methodMetadata, configClass));}// Process default methods on interfacesprocessInterfaces(configClass, sourceClass);// 处理父类// Process superclass, if any// 处理父类if (sourceClass.getMetadata().hasSuperClass()) {
    String superclass = sourceClass.getMetadata().getSuperClassName();if (superclass != null && !superclass.startsWith("java") &&!this.knownSuperclasses.containsKey(superclass)) {
    this.knownSuperclasses.put(superclass, configClass);// Superclass found, return its annotation metadata and recursereturn sourceClass.getSuperClass();}}// No superclass -> processing is complete// 处理完成return null;}

大家看了下parse方法的整个流程，其实就是读取配置类上的注解，如果有个内部类的话，就递归去处理内部类注解。然后把处理好的信息放进configClass，以便后面使用。接下来看this.reader.loadBeanDefinitions(configClasses)这个方法

核心方法二、this.reader.loadBeanDefinitions(configClasses)

	public void loadBeanDefinitions(Set<ConfigurationClass> configurationModel) {
    TrackedConditionEvaluator trackedConditionEvaluator = new TrackedConditionEvaluator();for (ConfigurationClass configClass : configurationModel) {
    loadBeanDefinitionsForConfigurationClass(configClass, trackedConditionEvaluator);}}

继续往下

private void loadBeanDefinitionsForConfigurationClass(ConfigurationClass configClass, TrackedConditionEvaluator trackedConditionEvaluator) {
    // 判断是否需要跳过，需要跳过的话就移除定义信息if (trackedConditionEvaluator.shouldSkip(configClass)) {
    String beanName = configClass.getBeanName();if (StringUtils.hasLength(beanName) && this.registry.containsBeanDefinition(beanName)) {
    this.registry.removeBeanDefinition(beanName);}this.importRegistry.removeImportingClass(configClass.getMetadata().getClassName());return;}// 是否是Importedif (configClass.isImported()) {
    // 为Imported的配置注册定义信息registerBeanDefinitionForImportedConfigurationClass(configClass);}// 注册@Bean注解bean定义信息for (BeanMethod beanMethod : configClass.getBeanMethods()) {
    loadBeanDefinitionsForBeanMethod(beanMethod);}//注册@ImportedResources注解bean定义信息loadBeanDefinitionsFromImportedResources(configClass.getImportedResources());//处理BeanDefinitionRegistrarsloadBeanDefinitionsFromRegistrars(configClass.getImportBeanDefinitionRegistrars());}

这个方法其实就是处理上一步parse方法得到的信息，然后根据得到的信息一个个的去注册bean定义信息。因为作用查不到，我们就跳一个我们平时用的多@bean拿出来讲解，剩下的 如果大家有兴趣，大家可以自己去研究下。

loadBeanDefinitionsForBeanMethod

private void loadBeanDefinitionsForBeanMethod(BeanMethod beanMethod) {
    ConfigurationClass configClass = beanMethod.getConfigurationClass();MethodMetadata metadata = beanMethod.getMetadata();String methodName = metadata.getMethodName();// Do we need to mark the bean as skipped by its condition?// 判断是否需要跳过if (this.conditionEvaluator.shouldSkip(metadata, ConfigurationPhase.REGISTER_BEAN)) {
    configClass.skippedBeanMethods.add(methodName);return;}if (configClass.skippedBeanMethods.contains(methodName)) {
    return;}// 拿bean的参数值AnnotationAttributes bean = AnnotationConfigUtils.attributesFor(metadata, Bean.class);Assert.state(bean != null, "No @Bean annotation attributes");// Consider name and any aliases// 拿别名List<String> names = new ArrayList<>(Arrays.asList(bean.getStringArray("name")));// 别名存在的话就用别名，没有的话就用方法名String beanName = (!names.isEmpty() ? names.remove(0) : methodName);// Register aliases even when overridden// 把把方法名和别名记录for (String alias : names) {
    this.registry.registerAlias(beanName, alias);}// Has this effectively been overridden before (e.g. via XML)?// 是否通过别的途径覆盖了if (isOverriddenByExistingDefinition(beanMethod, beanName)) {
    if (beanName.equals(beanMethod.getConfigurationClass().getBeanName())) {
    throw new BeanDefinitionStoreException(beanMethod.getConfigurationClass().getResource().getDescription(),beanName, "Bean name derived from @Bean method '" + beanMethod.getMetadata().getMethodName() +"' clashes with bean name for containing configuration class; please make those names unique!");}return;}ConfigurationClassBeanDefinition beanDef = new ConfigurationClassBeanDefinition(configClass, metadata);// 设置源beanDef.setSource(this.sourceExtractor.extractSource(metadata, configClass.getResource()));// method 是否为isStaticif (metadata.isStatic()) {
    // static @Bean methodif (configClass.getMetadata() instanceof StandardAnnotationMetadata) {
    beanDef.setBeanClass(((StandardAnnotationMetadata) configClass.getMetadata()).getIntrospectedClass());}else {
    beanDef.setBeanClassName(configClass.getMetadata().getClassName());}beanDef.setUniqueFactoryMethodName(methodName);}else {
    // instance @Bean methodbeanDef.setFactoryBeanName(configClass.getBeanName());beanDef.setUniqueFactoryMethodName(methodName);}if (metadata instanceof StandardMethodMetadata) {
    beanDef.setResolvedFactoryMethod(((StandardMethodMetadata) metadata).getIntrospectedMethod());}beanDef.setAutowireMode(AbstractBeanDefinition.AUTOWIRE_CONSTRUCTOR);beanDef.setAttribute(org.springframework.beans.factory.annotation.RequiredAnnotationBeanPostProcessor.SKIP_REQUIRED_CHECK_ATTRIBUTE, Boolean.TRUE);AnnotationConfigUtils.processCommonDefinitionAnnotations(beanDef, metadata);Autowire autowire = bean.getEnum("autowire");if (autowire.isAutowire()) {
    beanDef.setAutowireMode(autowire.value());}boolean autowireCandidate = bean.getBoolean("autowireCandidate");if (!autowireCandidate) {
    beanDef.setAutowireCandidate(false);}String initMethodName = bean.getString("initMethod");if (StringUtils.hasText(initMethodName)) {
    beanDef.setInitMethodName(initMethodName);}String destroyMethodName = bean.getString("destroyMethod");beanDef.setDestroyMethodName(destroyMethodName);// Consider scopingScopedProxyMode proxyMode = ScopedProxyMode.NO;AnnotationAttributes attributes = AnnotationConfigUtils.attributesFor(metadata, Scope.class);if (attributes != null) {
    beanDef.setScope(attributes.getString("value"));proxyMode = attributes.getEnum("proxyMode");if (proxyMode == ScopedProxyMode.DEFAULT) {
    proxyMode = ScopedProxyMode.NO;}}// Replace the original bean definition with the target one, if necessaryBeanDefinition beanDefToRegister = beanDef;if (proxyMode != ScopedProxyMode.NO) {
    BeanDefinitionHolder proxyDef = ScopedProxyCreator.createScopedProxy(new BeanDefinitionHolder(beanDef, beanName), this.registry,proxyMode == ScopedProxyMode.TARGET_CLASS);beanDefToRegister = new ConfigurationClassBeanDefinition((RootBeanDefinition) proxyDef.getBeanDefinition(), configClass, metadata);}if (logger.isTraceEnabled()) {
    logger.trace(String.format("Registering bean definition for @Bean method %s.%s()",configClass.getMetadata().getClassName(), beanName));}this.registry.registerBeanDefinition(beanName, beanDefToRegister);}

这个方法我没写很多注释，其实看代码就很能看出来了，这个方法就是去拿你再写@Bean的里面一些参数的值，然后根据这些值，做一些操作，操作完成就直接注册。

现在看完invokeBeanDefinitionRegistryPostProcessors的这个调用链，大概就知道他的作用了，他第一次调用，因为容器中已经只有 org.springframework.context.annotation.internalConfigurationAnnotationProcessor （实际上是ConfigurationClassPostProcessor）这个BeanDefinitionRegistryPostProcessors的实现，所以他会先调用ConfigurationClassPostProcessor的postProcessBeanDefinitionRegistry方法去注册容器中的配置类，注册的时候会去调用parse方法是获取配置类的中注解信息，然后loadBeanDefinitions方法会把这些注解信息注册到容器。
然后第二和第三次就是来执行你自己注册的BeanDefinitionRegistryPostProcessors接口，只要你实现了，他就会去调用。这其实是为了让使用者去介入到spring容器生命周期的接口。
这个方法非常重要，要是完全看到他的所有代码，那基本上容器的生命周期过程你就了解了大半了。
还有一小半就是后面我们要讲的invokeBeanFactoryPostProcessors方法了，好的，我们接下来往下看