到目前为止我们大概知道了Spring初始化过程，甚至知道了SpringMvc的影子。通过之前的分析我们大概还有两个问题，第一是注解解析和相关的扫描。第二是getBean方法，因为getBean就是从BeanDefineMap中实例化bean并注册到IOC中具体实现了，因此与之相关的处理会很多。其实仔细思考，注解解析的步骤获取不难。为什么这么说的原因是在解析的时候我们之前写过解析注解的实例。通过之前的例子我们自己好好扩展一下也可以实现注解的解析，然后按beanDefinition的规则逐个注册上去，这部分工作就算是做完了。因为这边只是解析，不需要考虑循环依赖的问题。为啥可以将所有的bean都可以扫描进去的原因在于代码在SpringApplication类的load()方法首先将启动类注册到beanDefinitionMap中了。而启动类上边的注解就是秘密的根源。怀着这样的猜测，让我们刨根溯源，发掘神秘背后的故事。

通过之前第四篇文章的描述，我们直接看ConfigurationClassPostProcessor类。

因为该类是一个后置处理器，那么必然会实现BeanDefinitionRegistryPostProcessors接口，这里考虑为何不用BeanFactoryPostProcessos接口？因为BeanDefinitionRegistryPostProcessors比BeanFactoryPostProcessors执行的早。除此之外还实现了PriorityOrdered, ResourceLoaderAware, BeanClassLoaderAware, EnvironmentAware 。通过之前对BeanPostProcessors接口的学习，我们大概知道bean在实例化的过程大概是先执行aware类型的接口、bean初始化的前置处理、initlized接口、bean初始化的后置处理。那么这里的priorityOrdered我们在解析后置处理器和beanPostProcessors的执行的见到了。该接口主要用来排序和优先级的。所以这些都不是问题的关键。这里需要研究的就是BeanDefinitionRegistryPostProcessors接口。

publicvoid 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);}

查看这块代码发现也是做一些判断处理，这里的registriesPostProcessed采用的是set数据类型，set我们都知道事去重的。其中hashSet的底层是HashMap，其key就是要存储的值，而value是一个定值。除此之外均和HashMap没有区别。ConcurentHashMap是HashMap的加锁变体，其中加锁的地方是链表的根或者红黑树的树根。其他均和HashMap一样。

这里我们详细看一下processConfigBeanDefinitions都做了哪些事情。

发现这块代码很多，基本就是我们要分析的核心了。

public void processConfigBeanDefinitions(BeanDefinitionRegistry registry) {   ListconfigCandidates =new ArrayList<>();//获取所有目前注册到beanDefinitionMap的类   String[] candidateNames = registry.getBeanDefinitionNames();   for (String beanName : candidateNames) {//拿到配置      BeanDefinition beanDef = registry.getBeanDefinition(beanName);      if (ConfigurationClassUtils.isFullConfigurationClass(beanDef) ||            ConfigurationClassUtils.isLiteConfigurationClass(beanDef)) {         if (logger.isDebugEnabled()) {            logger.debug("Bean definition has already been processed as a configuration class: " + beanDef);         }      }      else if (ConfigurationClassUtils.checkConfigurationClassCandidate(beanDef, this.metadataReaderFactory)) {//如果是configuration注解的类就添加到list队列中         configCandidates.add(new BeanDefinitionHolder(beanDef, beanName));      }   }   // 如果没有Configuration注解的类的时候，直接返回   if (configCandidates.isEmpty()) {      return;   }   // 对@Order注解的bean进行排序   configCandidates.sort((bd1, bd2) -> {      int i1 = ConfigurationClassUtils.getOrder(bd1.getBeanDefinition());      int i2 = ConfigurationClassUtils.getOrder(bd2.getBeanDefinition());      return Integer.compare(i1, i2);   });   //单例bean的注册类，转化为单例IOC容器的注册器   SingletonBeanRegistry sbr = null;   if (registry instanceof SingletonBeanRegistry) {      sbr = (SingletonBeanRegistry) registry;      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();   }   //实例化一个configuration注解解析器 ，这里注入了各种解析需要的工具，包括包扫描的。其中registry就是目标的容器   ConfigurationClassParser parser = new ConfigurationClassParser(         this.metadataReaderFactory, this.problemReporter, this.environment,         this.resourceLoader, this.componentScanBeanNameGenerator, registry);//使用set排一下重   Setcandidates =new LinkedHashSet<>(configCandidates);   SetalreadyParsed =new HashSet<>(configCandidates.size());   do {//使用configuration解析器解析所有已经加载到的被configuration修饰的bean      parser.parse(candidates);//解析完毕之后，我们需要的bean都被注册到beanDefinitionMap中，这里做一次校验      parser.validate();//将解析出来的具有Configuration相关的类放到configClasses中。      SetconfigClasses =new LinkedHashSet<>(parser.getConfigurationClasses());//这里先移除      configClasses.removeAll(alreadyParsed);      //创建一个配置阅读器，解析@Import注解的类，这里发现入参还是configClasses，说明了Import注解需要和Configuration注解配合使用。if (this.reader == null) {         this.reader = new ConfigurationClassBeanDefinitionReader(               registry, this.sourceExtractor, this.resourceLoader, this.environment,               this.importBeanNameGenerator, parser.getImportRegistry());      }//解析@Import注解      this.reader.loadBeanDefinitions(configClasses);//再添加回来      alreadyParsed.addAll(configClasses);//清除之前的配置list      candidates.clear();//到这里，注册的bean已经很多了，有可能已经大于之前的candidateNames的数量了      if (registry.getBeanDefinitionCount() > candidateNames.length) {//拿到类名字，这会应该包含了很多         String[] newCandidateNames = registry.getBeanDefinitionNames();//拿到之前解析的类名         SetoldCandidateNames =new HashSet<>(Arrays.asList(candidateNames));//已经存在的解析类         SetalreadyParsedClasses =new HashSet<>();         for (ConfigurationClass configurationClass : alreadyParsed) {            alreadyParsedClasses.add(configurationClass.getMetadata().getClassName());         }         for (String candidateName : newCandidateNames) {//如果老的没有包含，那么就获取并添加进去            if (!oldCandidateNames.contains(candidateName)) {               BeanDefinition bd = registry.getBeanDefinition(candidateName);//检验是否为configuration注解修饰的类并且不是解析类本身               if (ConfigurationClassUtils.checkConfigurationClassCandidate(bd, this.metadataReaderFactory) &&                     !alreadyParsedClasses.contains(bd.getBeanClassName())) {//添加进去                  candidates.add(new BeanDefinitionHolder(bd, candidateName));               }            }         }//相当于扩容了         candidateNames = newCandidateNames;      }   }   while (!candidates.isEmpty());   // 将ImportRegistry注册进去   if (sbr != null && !sbr.containsSingleton(IMPORT_REGISTRY_BEAN_NAME)) {      sbr.registerSingleton(IMPORT_REGISTRY_BEAN_NAME, parser.getImportRegistry());   }   if (this.metadataReaderFactory instanceof CachingMetadataReaderFactory) {//清空一下缓存      ((CachingMetadataReaderFactory) this.metadataReaderFactory).clearCache();   }}

判断是否为configuration注解

public static boolean isFullConfigurationCandidate(AnnotationMetadata metadata) {   return metadata.isAnnotated(Configuration.class.getName());}

解析Order注解

@Nullablepublic static Integer getOrder(AnnotationMetadata metadata) {   Map, Object> orderAttributes = metadata.getAnnotationAttributes(Order.class.getName());   return (orderAttributes != null ? ((Integer) orderAttributes.get(AnnotationUtils.VALUE)) : null);}

到这里我们基本了解了@Configuration和@Import的解析过程了。因为传入的类是启动类，而启动类必然会包含这个Configuration的注解因为@SpringBootApplication是个组合注解。解析到@Configuration注解的类之后就开始解析了。解析之后就包含了很多类了。然后再对@Import注解的解析。这是这块代码主要做的事情。那么这块我们看一下parse方法和import的解析过程吧。按理说这两个方法都不太难。

public void parse(SetconfigCandidates) {   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);      }   }   this.deferredImportSelectorHandler.process();}protected void processConfigurationClass(ConfigurationClass configClass) throws IOException {   if (this.conditionEvaluator.shouldSkip(configClass.getMetadata(), ConfigurationPhase.PARSE_CONFIGURATION)) {      return;   }//获取configuration修饰的类   ConfigurationClass existingClass = this.configurationClasses.get(configClass);   if (existingClass != null) {//看是否为是否已经被注入了      if (configClass.isImported()) {         if (existingClass.isImported()) {            existingClass.mergeImportedBy(configClass);         }         return;      }      else {         this.configurationClasses.remove(configClass);         this.knownSuperclasses.values().removeIf(configClass::equals);      }   }   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 {//判断是否为Compoent注解。   if (configClass.getMetadata().isAnnotated(Component.class.getName())) {//解析成员类。经过测试，可以在configuration注解修改时类的内部类定义被Compoent注解修饰的类，并成功注册到ioc      processMemberClasses(configClass, sourceClass);   }   // 解析@PropertySource，PropertiesCource的注解内容为数组，所以这里循环解析   for (AnnotationAttributes propertySource : AnnotationConfigUtils.attributesForRepeatable(         sourceClass.getMetadata(), PropertySources.class,         org.springframework.context.annotation.PropertySource.class)) {      if (this.environment instanceof ConfigurableEnvironment) {//这里的解析就是将配置文件读取，然后加入的到env中。         processPropertySource(propertySource);      }      else {         logger.info("Ignoring @PropertySource annotation on [" + sourceClass.getMetadata().getClassName() +               "]. Reason: Environment must implement ConfigurableEnvironment");      }   }   // 解析包扫描注解，同样的compoentScans注解是一个数组，所以循环遍历   SetcomponentScans = 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         SetscannedBeanDefinitions =               this.componentScanParser.parse(componentScan, sourceClass.getMetadata().getClassName());         // 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());            }         }      }   }   //解析@import注解   processImports(configClass, sourceClass, getImports(sourceClass), true);   // 解析@ImportResource注解   AnnotationAttributes importResource =         AnnotationConfigUtils.attributesFor(sourceClass.getMetadata(), ImportResource.class);   if (importResource != null) {      String[] resources = importResource.getStringArray("locations");      Class
     readerClass = importResource.getClass("reader");      for (String resource : resources) {         String resolvedResource = this.environment.resolveRequiredPlaceholders(resource);         configClass.addImportedResource(resolvedResource, readerClass);      }   }   // Process individual @Bean methods   SetbeanMethods = retrieveBeanMethodMetadata(sourceClass);   for (MethodMetadata methodMetadata : beanMethods) {      configClass.addBeanMethod(new BeanMethod(methodMetadata, configClass));   }   // 处理虚方法   processInterfaces(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 recurse         return sourceClass.getSuperClass();      }   return null;}

在ComponentScans解析的时候，最终调的scanner.doScan方法其中解析的时候，也是循环的调用之前的方法。

注解相关的验证

PropertiesSource和内部类component注解以及虚方法实例

总结：通过分析，我们看到这里大概将存在于类上的spring注解全部注册进去了。并通过扫描将项目体系中需要的类全部都注册了进去。但是到目前还有解析@Bean或者@Autowired等类内部的注解。除此之外我们需要注意的是今天学习的@Import、@ComponentScans、ImportRsource等注解需要结合@Configuration注解一起使用。