Spring框架探索二（BeanDefinition的扫描注册）

一、下图为简单的扫描注入过程时序图

二、扫描注入过程具体代码

​ spring的依赖注入是从SpringApplication的refreshContext(context)方法开始，具体流程如下;

@Override
public void refresh() throws BeansException, IllegalStateException {
   synchronized (this.startupShutdownMonitor) {
      // 刷新前准备，close和active标志的设置以及起始事件的获取,以及环境的准备
      prepareRefresh();
      // BeanFactory类的获取
      ConfigurableListableBeanFactory beanFactory = obtainFreshBeanFactory();
      // beanFactory的准备，涉及一些需要忽略的类和需要加的依赖
      prepareBeanFactory(beanFactory);
      try {
         // 忽略的类和需要加的依赖以及scope的设置
         postProcessBeanFactory(beanFactory);
         // 后置处理类的执行，扫描类的位置
         invokeBeanFactoryPostProcessors(beanFactory);
         // 后置处理类的注册实例化
         registerBeanPostProcessors(beanFactory);
         // 国际化处理,注册MessageSource类
         initMessageSource();
         // Initialize event multicaster for this context.
         initApplicationEventMulticaster();
         // Initialize other special beans in specific context subclasses.
         onRefresh();
         // 注册监听，会加入我们通过注解注入的类
         registerListeners();
         // beandefine的注入
         finishBeanFactoryInitialization(beanFactory);
         // Last step: publish corresponding event.
         finishRefresh();
      }

      catch (BeansException ex) {
         if (logger.isWarnEnabled()) {
            .... // 日志
         }
         // Bean的销毁
         destroyBeans();
         // 退出更新
         cancelRefresh(ex);
         // 抛出异常
         throw ex;
      }finally {
         // 重置缓存
         resetCommonCaches();
      }
   }
}

​ 更新前准备，是对更新标志、更新时间、属性设置、必要属性校验和监听等的处理。多是一些数据的初始化赋值。

protected void prepareRefresh() {
   // active、closed标志设置以及启动时间获取
   this.startupDate = System.currentTimeMillis();
   this.closed.set(false);
   this.active.set(true);

   if (logger.isDebugEnabled()) {
      if (logger.isTraceEnabled()) {
         .... // 日志
      }
      else {
         .... // 日志
      }
   }

   // propertySources的初始化servletContextInitParams与servletConfigInitParams
   initPropertySources();
   // 必填项检验
   getEnvironment().validateRequiredProperties();
   // 添加监听
   if (this.earlyApplicationListeners == null) {
      this.earlyApplicationListeners = new LinkedHashSet<>(this.applicationListeners);
   }
   else {
      // 存在的话重置
      this.applicationListeners.clear();
      this.applicationListeners.addAll(this.earlyApplicationListeners);
   }
   // 事件容器
   this.earlyApplicationEvents = new LinkedHashSet<>();
}

​ 初始化propertySources，对servletContextInitParams、servletConfigInitParams两个属性进行处理，这里以spring boot的方式启动，未设值。

protected void initPropertySources() {
   ConfigurableEnvironment env = getEnvironment();
   if (env instanceof ConfigurableWebEnvironment) {
      ((ConfigurableWebEnvironment) env).initPropertySources(this.servletContext, null);
   }
}

@Override
public void initPropertySources(@Nullable ServletContext servletContext, @Nullable 			ServletConfig servletConfig) {
	WebApplicationContextUtils.initServletPropertySources(getPropertySources(), 				servletContext, servletConfig);
}
//servletContextInitParams
public static final String SERVLET_CONTEXT_PROPERTY_SOURCE_NAME="servletContextInitParams";
//servletConfigInitParams
public static final String SERVLET_CONFIG_PROPERTY_SOURCE_NAME = "servletConfigInitParams";

//我们在springboot构建环境时属性集合中存在servletContextInitParams和servletConfigInitParams， //在这里我们进行初始化，都设置为空
public static void initServletPropertySources(MutablePropertySources sources,
	@Nullable ServletContext servletContext, @Nullable ServletConfig 						servletConfig) {

	Assert.notNull(sources, "'propertySources' must not be null");
	String name = StandardServletEnvironment.SERVLET_CONTEXT_PROPERTY_SOURCE_NAME;
	if (servletContext != null && sources.get(name) instanceof StubPropertySource) {
		sources.replace(name, new ServletContextPropertySource(name, servletContext));
	}
	name = StandardServletEnvironment.SERVLET_CONFIG_PROPERTY_SOURCE_NAME;
	if (servletConfig != null && sources.get(name) instanceof StubPropertySource) {
		sources.replace(name, new ServletConfigPropertySource(name, servletConfig));
	}
}

​ 查看是否有requiredProperties属性，但是配置没有（这里requiredProperties为空）。

@Override
public void validateRequiredProperties() {
   MissingRequiredPropertiesException ex = new MissingRequiredPropertiesException();
   for (String key : this.requiredProperties) {
      if (this.getProperty(key) == null) {
         ex.addMissingRequiredProperty(key);
      }
   }
   if (!ex.getMissingRequiredProperties().isEmpty()) {
      .... // 异常
   }
}

​ 对beanFactory的设置序列化值并返回给后面的方法使用，这里refreshed的采用CAS设置来保证同一时刻只能够有一个线程进行初始化。

protected ConfigurableListableBeanFactory obtainFreshBeanFactory() {
   refreshBeanFactory();
   return getBeanFactory();
}

//BeanFactory设置数列化ID
protected final void refreshBeanFactory() throws IllegalStateException {
	if (!this.refreshed.compareAndSet(false, true)) {
		.... // 异常
	}
	this.beanFactory.setSerializationId(getId());
}

​ 设置一些初始化需要的类加载器、忽略的Bean、必须的依赖等。

protected void prepareBeanFactory(ConfigurableListableBeanFactory beanFactory) {
   // 
   beanFactory.setBeanClassLoader(getClassLoader());
   beanFactory.setBeanExpressionResolver(new 										      StandardBeanExpressionResolver(beanFactory.getBeanClassLoader()));
   beanFactory.addPropertyEditorRegistrar(new ResourceEditorRegistrar(this, 				getEnvironment()));

   // 加入忽略的引用，Aware相关类
   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相关类
   beanFactory.registerResolvableDependency(BeanFactory.class, beanFactory);
   beanFactory.registerResolvableDependency(ResourceLoader.class, this);
   beanFactory.registerResolvableDependency(ApplicationEventPublisher.class, this);
   beanFactory.registerResolvableDependency(ApplicationContext.class, this);

   // 监听类
   beanFactory.addBeanPostProcessor(new ApplicationListenerDetector(this));

   // 加入AspectJ支持
   if (beanFactory.containsBean(LOAD_TIME_WEAVER_BEAN_NAME)) {
      beanFactory.addBeanPostProcessor(new LoadTimeWeaverAwareProcessor(beanFactory));
      // 匹配类设置类加载器
      beanFactory.setTempClassLoader(new 													ContextTypeMatchClassLoader(beanFactory.getBeanClassLoader()));
   }

   // 注册环境相关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());
   }
}

​ 工厂类的后置处理，实例化需要的类、设置忽略的类以及作用域的添加Request和Session。

//后置处理器的调用以及必要的包扫面和注册，AnnotationConfigServletWebServerApplicationContext
//初始化调用的是无参构造方法，不会给basePackages设置初始值。这里不会进行扫描
protected void postProcessBeanFactory(ConfigurableListableBeanFactory beanFactory) {
   super.postProcessBeanFactory(beanFactory);
   if (this.basePackages != null && this.basePackages.length > 0) {
      this.scanner.scan(this.basePackages);
   }
   if (!this.annotatedClasses.isEmpty()) {
      this.reader.register(ClassUtils.toClassArray(this.annotatedClasses));
   }
}

//实例化WebApplicationContextServletContextAwareProcessor、设置忽略的类ServletContextAware
//以及作用域处理
protected void postProcessBeanFactory(ConfigurableListableBeanFactory beanFactory) {
	beanFactory.addBeanPostProcessor(new 								
         WebApplicationContextServletContextAwareProcessor(this));
		beanFactory.ignoreDependencyInterface(ServletContextAware.class);
		registerWebApplicationScopes();
}

​ registerWebApplicationScopes注册作用域

private void registerWebApplicationScopes() {
  	//判断是否已经存在对应的作用域
  	ExistingWebApplicationScopes existingScopes = new 										ExistingWebApplicationScopes(getBeanFactory());
  		//注册作用域及相关的类
		WebApplicationContextUtils.registerWebApplicationScopes(getBeanFactory());
		existingScopes.restore();
}
	
public ExistingWebApplicationScopes(ConfigurableListableBeanFactory beanFactory) {
	this.beanFactory = beanFactory;
  	//判断作用域是否存在于bean工厂中
	for (String scopeName : SCOPES) {
		Scope scope = beanFactory.getRegisteredScope(scopeName);
		if (scope != null) {
			this.scopes.put(scopeName, scope);
		}
	}
}
//注册作用与相关类
public static void registerWebApplicationScopes(ConfigurableListableBeanFactory 			beanFactory) {
		registerWebApplicationScopes(beanFactory, null);
}

//添加request和session作用域，并添加相关的类
public static void registerWebApplicationScopes(ConfigurableListableBeanFactory 			beanFactory,@Nullable ServletContext sc) {
  	//添加request和session作用域
	beanFactory.registerScope(WebApplicationContext.SCOPE_REQUEST, new RequestScope());
	beanFactory.registerScope(WebApplicationContext.SCOPE_SESSION, new SessionScope());
	if (sc != null) {
		ServletContextScope appScope = new ServletContextScope(sc);
		beanFactory.registerScope(WebApplicationContext.SCOPE_APPLICATION, appScope);
		sc.setAttribute(ServletContextScope.class.getName(), appScope);
	}
	//添加web相关的类
	beanFactory.registerResolvableDependency(ServletRequest.class, new 							RequestObjectFactory());
	beanFactory.registerResolvableDependency(ServletResponse.class, new 						ResponseObjectFactory());
	beanFactory.registerResolvableDependency(HttpSession.class, new 							SessionObjectFactory());
	beanFactory.registerResolvableDependency(WebRequest.class, new 								WebRequestObjectFactory());
	if (jsfPresent) {
		FacesDependencyRegistrar.registerFacesDependencies(beanFactory);
	}
}

​ 扫描后置处理类的执行。

protected void invokeBeanFactoryPostProcessors(ConfigurableListableBeanFactory beanFactory) {
   PostProcessorRegistrationDelegate.invokeBeanFactoryPostProcessors(beanFactory, 			getBeanFactoryPostProcessors());

   // 引入AspectJ支持
   if (beanFactory.getTempClassLoader() == null && 										beanFactory.containsBean(LOAD_TIME_WEAVER_BEAN_NAME)) {
      beanFactory.addBeanPostProcessor(new LoadTimeWeaverAwareProcessor(beanFactory));
      beanFactory.setTempClassLoader(new 													ContextTypeMatchClassLoader(beanFactory.getBeanClassLoader()));
   }
}

​ BeanDefinetionRegistry后置处理器的扫描，Bean扫描入口在这里。

public static void invokeBeanFactoryPostProcessors(ConfigurableListableBeanFactory 			beanFactory, List<BeanFactoryPostProcessor> beanFactoryPostProcessors) {

   // Invoke BeanDefinitionRegistryPostProcessors first, if any.
   Set<String> processedBeans = new HashSet<>();
   //判断工厂类是否实现类BeanDefinitionRegistry接口
   if (beanFactory instanceof BeanDefinitionRegistry) {
      BeanDefinitionRegistry registry = (BeanDefinitionRegistry) beanFactory;
      List<BeanFactoryPostProcessor> regularPostProcessors = new ArrayList<>();
      List<BeanDefinitionRegistryPostProcessor> registryProcessors = new ArrayList<>();
	 // BeanDefinition注册类会首先进行处理,这里会有两个后置处理类，一个会注入内置的扫描后置处理类
     //另一个是检测扫面路径是否包含不应该存在的路径
      for (BeanFactoryPostProcessor postProcessor : beanFactoryPostProcessors) {
         if (postProcessor instanceof BeanDefinitionRegistryPostProcessor) {
            BeanDefinitionRegistryPostProcessor registryProcessor =
                  (BeanDefinitionRegistryPostProcessor) postProcessor;
            registryProcessor.postProcessBeanDefinitionRegistry(registry);
            registryProcessors.add(registryProcessor);
         }
         else {
            regularPostProcessors.add(postProcessor);
         }
      }

      List<BeanDefinitionRegistryPostProcessor> currentRegistryProcessors = 
        new ArrayList<>();

      // 获取容器中已经加入的后置处理器，并将加有PriorityOrdered注解的类实例化
      String[] postProcessorNames = beanFactory.getBeanNamesForType(
        BeanDefinitionRegistryPostProcessor.class, true, false);
      for (String ppName : postProcessorNames) {
         if (beanFactory.isTypeMatch(ppName, PriorityOrdered.class)) {
            currentRegistryProcessors.add(beanFactory.getBean(ppName, 								BeanDefinitionRegistryPostProcessor.class));
            processedBeans.add(ppName);
         }
      }
      //排序
      sortPostProcessors(currentRegistryProcessors, beanFactory);
      registryProcessors.addAll(currentRegistryProcessors);
      //执行后置处理器
      invokeBeanDefinitionRegistryPostProcessors(currentRegistryProcessors, registry);
      currentRegistryProcessors.clear();

      // 获取容器中已经加入的后置处理器，并将加有Ordered注解的类实例化
      postProcessorNames = 	beanFactory.getBeanNamesForType(
        BeanDefinitionRegistryPostProcessor.class, true, false);
      for (String ppName : postProcessorNames) {
         if (!processedBeans.contains(ppName) && beanFactory.isTypeMatch(ppName, 					Ordered.class)) {
            currentRegistryProcessors.add(beanFactory.getBean(ppName, 								BeanDefinitionRegistryPostProcessor.class));
            processedBeans.add(ppName);
         }
      }
      sortPostProcessors(currentRegistryProcessors, beanFactory);
      registryProcessors.addAll(currentRegistryProcessors);
      invokeBeanDefinitionRegistryPostProcessors(currentRegistryProcessors, registry);
      currentRegistryProcessors.clear();

      // 普通后置处理器的处理
      boolean reiterate = true;
      while (reiterate) {
         reiterate = false;
         postProcessorNames = beanFactory.getBeanNamesForType(
           BeanDefinitionRegistryPostProcessor.class, true, false);
         for (String ppName : postProcessorNames) {
            if (!processedBeans.contains(ppName)) {
               currentRegistryProcessors.add(
                 beanFactory.getBean(ppName, BeanDefinitionRegistryPostProcessor.class));
               processedBeans.add(ppName);
               reiterate = true;
            }
         }
         sortPostProcessors(currentRegistryProcessors, beanFactory);
         registryProcessors.addAll(currentRegistryProcessors);
         invokeBeanDefinitionRegistryPostProcessors(currentRegistryProcessors, registry);
         currentRegistryProcessors.clear();
      }

      // 反射执行后置处理器
      invokeBeanFactoryPostProcessors(registryProcessors, beanFactory);
      // 反射执行后置处理器 
     invokeBeanFactoryPostProcessors(regularPostProcessors, beanFactory);
   }

   else {
      // 反射执行后置处理器
      invokeBeanFactoryPostProcessors(beanFactoryPostProcessors, beanFactory);
   }

   // 根据类型获取BeanFactoryPostProcessor名称集合，扫描到的后置处理类进行插入
   String[] postProcessorNames =
         beanFactory.getBeanNamesForType(BeanFactoryPostProcessor.class, true, false);

   // priorityOrdered后置处理器集合
   List<BeanFactoryPostProcessor> priorityOrderedPostProcessors = new ArrayList<>();
   List<String> orderedPostProcessorNames = new ArrayList<>();
   List<String> nonOrderedPostProcessorNames = new ArrayList<>();
   for (String ppName : postProcessorNames) {
      if (processedBeans.contains(ppName)) {
         // skip - already processed in first phase above
      }
      else if (beanFactory.isTypeMatch(ppName, PriorityOrdered.class)) {
         priorityOrderedPostProcessors.add(
           beanFactory.getBean(ppName, BeanFactoryPostProcessor.class));
      }
      else if (beanFactory.isTypeMatch(ppName, Ordered.class)) {
         orderedPostProcessorNames.add(ppName);
      }
      else {
         nonOrderedPostProcessorNames.add(ppName);
      }
   }

   // 排序后反射执行后置处理器
   sortPostProcessors(priorityOrderedPostProcessors, beanFactory);
   invokeBeanFactoryPostProcessors(priorityOrderedPostProcessors, beanFactory);

   // 排序后执行后置处理器
   List<BeanFactoryPostProcessor> orderedPostProcessors = new ArrayList<>						(orderedPostProcessorNames.size());
   for (String postProcessorName : orderedPostProcessorNames) {
      orderedPostProcessors.add(beanFactory.getBean(postProcessorName, 						BeanFactoryPostProcessor.class));
   }
   sortPostProcessors(orderedPostProcessors, beanFactory);
   invokeBeanFactoryPostProcessors(orderedPostProcessors, beanFactory);

   // 排序后执行后置处理器
   List<BeanFactoryPostProcessor> nonOrderedPostProcessors = new ArrayList<>					(nonOrderedPostProcessorNames.size());
   for (String postProcessorName : nonOrderedPostProcessorNames) {
      nonOrderedPostProcessors.add(beanFactory.getBean(postProcessorName, 						BeanFactoryPostProcessor.class));
   }
   invokeBeanFactoryPostProcessors(nonOrderedPostProcessors, beanFactory);

   // 清除Metadata缓存
   beanFactory.clearMetadataCache();
}

​ invokeBeanDefinitionRegistryPostProcessors执行Bean定义的注册

private static void invokeBeanDefinitionRegistryPostProcessors(
      Collection<? extends BeanDefinitionRegistryPostProcessor> postProcessors, BeanDefinitionRegistry registry) {

   for (BeanDefinitionRegistryPostProcessor postProcessor : postProcessors) {
      // 扫描注册
      postProcessor.postProcessBeanDefinitionRegistry(registry);
   }
}

public void postProcessBeanDefinitionRegistry(BeanDefinitionRegistry registry) {
	int registryId = System.identityHashCode(registry);
	if (this.registriesPostProcessed.contains(registryId)) {
		.... // 异常
	}
	if (this.factoriesPostProcessed.contains(registryId)) {
		.... // 异常
	}
	this.registriesPostProcessed.add(registryId);
	//bean类的
	processConfigBeanDefinitions(registry);
}

​ processConfigBeanDefinitions处理配置类

public void processConfigBeanDefinitions(BeanDefinitionRegistry registry) {
   List<BeanDefinitionHolder> configCandidates = new ArrayList<>();
   // 将之前加入注册的Bean加入到数组中
   String[] candidateNames = registry.getBeanDefinitionNames();

   for (String beanName : candidateNames) {
      BeanDefinition beanDef = registry.getBeanDefinition(beanName);
      if (beanDef.getAttribute(ConfigurationClassUtils.CONFIGURATION_CLASS_ATTRIBUTE) != 		null) {
         if (logger.isDebugEnabled()) {
            .... // 日志
         }
      }
      // 判断是否时配置类
      else if (ConfigurationClassUtils.checkConfigurationClassCandidate(beanDef, 				this.metadataReaderFactory)) {
         // 如果是配置类加入到集合
         configCandidates.add(new BeanDefinitionHolder(beanDef, beanName));
      }
   }

   // 判断是否存在配置类Configuration,没有直接返回
   if (configCandidates.isEmpty()) {
      return;
   }

   // 根据order的值进行排序
   configCandidates.sort((bd1, bd2) -> {
      int i1 = ConfigurationClassUtils.getOrder(bd1.getBeanDefinition());
      int i2 = ConfigurationClassUtils.getOrder(bd2.getBeanDefinition());
      return Integer.compare(i1, i2);
   });
 
   SingletonBeanRegistry sbr = null;
   if (registry instanceof SingletonBeanRegistry) {
      sbr = (SingletonBeanRegistry) registry;
      if (!this.localBeanNameGeneratorSet) {
         // 获取beanNamede的生成类，没有直接使用默认的
         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();
   }

   // 定义解析类
   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());
   do {
      // 解析
      parser.parse(candidates);
      parser.validate();

      Set<ConfigurationClass> configClasses = new LinkedHashSet<>								(parser.getConfigurationClasses());
      configClasses.removeAll(alreadyParsed);

      // 定义解析类
      if (this.reader == null) {
         this.reader = new ConfigurationClassBeanDefinitionReader(
               registry, this.sourceExtractor, this.resourceLoader, this.environment,
               this.importBeanNameGenerator, parser.getImportRegistry());
      }
      // 配置类的解析
      this.reader.loadBeanDefinitions(configClasses);
      alreadyParsed.addAll(configClasses);

      candidates.clear();
      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());
   //  
   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();
   }
}

​ checkConfigurationClassCandidate判断是否是解析类

public static boolean checkConfigurationClassCandidate(
      BeanDefinition beanDef, MetadataReaderFactory metadataReaderFactory) {

   String className = beanDef.getBeanClassName();
   if (className == null || beanDef.getFactoryMethodName() != null) {
      return false;
   }

   AnnotationMetadata metadata;
   if (beanDef instanceof AnnotatedBeanDefinition &&  										className.equals(((AnnotatedBeanDefinition)beanDef).getMetadata()
         .getClassName())) {
      // Can reuse the pre-parsed metadata from the given BeanDefinition...
      metadata = ((AnnotatedBeanDefinition) beanDef).getMetadata();
   } else if (beanDef instanceof AbstractBeanDefinition && ((AbstractBeanDefinition) 			beanDef).hasBeanClass()) {
      // 判断是否是后置处理器类，或者监听工厂类或者代理类，直接忽略
      Class<?> beanClass = ((AbstractBeanDefinition) beanDef).getBeanClass();
      if (BeanFactoryPostProcessor.class.isAssignableFrom(beanClass) ||
            BeanPostProcessor.class.isAssignableFrom(beanClass) ||
            AopInfrastructureBean.class.isAssignableFrom(beanClass) ||
            EventListenerFactory.class.isAssignableFrom(beanClass)) {
         return false;
      }
      metadata = AnnotationMetadata.introspect(beanClass);
   }
   else {
      try {
         //这里是扫描的关键，是一个字节码解析器，--->字节码解析器
         MetadataReader metadataReader = 													metadataReaderFactory.getMetadataReader(className);
         metadata = metadataReader.getAnnotationMetadata();
      }
      catch (IOException ex) {
         if (logger.isDebugEnabled()) {
            .... // 日志
         }
         return false;
      }
   }

  	// 判断是否有Configuration注解
   Map<String, Object> config = 														metadata.getAnnotationAttributes(Configuration.class.getName());
  	// proxyBeanMethods属性判断
   if (config != null && !Boolean.FALSE.equals(config.get("proxyBeanMethods"))) {
      beanDef.setAttribute(CONFIGURATION_CLASS_ATTRIBUTE, CONFIGURATION_CLASS_FULL);
   }
   else if (config != null || isConfigurationCandidate(metadata)) {
      beanDef.setAttribute(CONFIGURATION_CLASS_ATTRIBUTE, CONFIGURATION_CLASS_LITE);
   }
   else {
      return false;
   }

   // 获取Order注解
   Integer order = getOrder(metadata);
   if (order != null) {
      beanDef.setAttribute(ORDER_ATTRIBUTE, order);
   }

   return true;
}

​ 字节码解析器getMetadataReader，通过初始化SimpleMetadataReader实例化ClassVisitor。进而根据ASM框架获取字节码信息，包含父类、注解信息、类的类型等信息，用于beanDefinition的获取。

public MetadataReader getMetadataReader(Resource resource) throws IOException {
   return new SimpleMetadataReader(resource, this.resourceLoader.getClassLoader());
}
//SimpleMetadataReader类的初始化
SimpleMetadataReader(Resource resource, @Nullable ClassLoader classLoader) throws 			IOException {
	SimpleAnnotationMetadataReadingVisitor visitor = new 								SimpleAnnotationMetadataReadingVisitor(classLoader);
	getClassReader(resource).accept(visitor, PARSING_OPTIONS);
	this.resource = resource;
	this.annotationMetadata = visitor.getMetadata();
}
// 	SimpleAnnotationMetadataReadingVisitor初始化时是通过ASM框架进行字节码扫描
SimpleAnnotationMetadataReadingVisitor(@Nullable ClassLoader classLoader) {
	super(SpringAsmInfo.ASM_VERSION);
	this.classLoader = classLoader;
}

​ 判断配置类类型进行解析

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) {
         .... // 异常
      }
      catch (Throwable ex) {
         .... // 异常
      }
   }

   this.deferredImportSelectorHandler.process();
}

​ 解析类开始进行解析

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);
			}
			// 
			return;
		}
		else {
			// 配置类存在时，先删除再插入
			this.configurationClasses.remove(configClass);
			this.knownSuperclasses.values().removeIf(configClass::equals);
		}
	}

	// 设置成资源类，供解析使用
	SourceClass 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())) {
      // 内部类处理逻辑
      processMemberClasses(configClass, sourceClass, filter);
   }

   // PropertySource处理逻辑
   for (AnnotationAttributes propertySource :  												AnnotationConfigUtils.attributesForRepeatable( sourceClass.getMetadata(), 				PropertySources.class, org.springframework.context.annotation
          .PropertySource.class)) {
      if (this.environment instanceof ConfigurableEnvironment) {
         // 解析propertySource属性的类
         processPropertySource(propertySource);
      }
      else {
         .... // 日志
      }
   }

   // ComponentScan注解处理逻辑
   Set<AnnotationAttributes> componentScans = 												AnnotationConfigUtils.attributesForRepeatable(
         sourceClass.getMetadata(), ComponentScans.class, ComponentScan.class);
   // 首先判断注解是否为空且chonditional条件要满足
   if (!componentScans.isEmpty() &&
         !this.conditionEvaluator.shouldSkip(sourceClass.getMetadata(), 						ConfigurationPhase.REGISTER_BEAN)) {
      for (AnnotationAttributes componentScan : componentScans) {
         // 对ComponentScan注解的类进行扫描
         Set<BeanDefinitionHolder> scannedBeanDefinitions =
               this.componentScanParser.parse(componentScan, 											sourceClass.getMetadata().getClassName());
         // 遍历扫描出来的scannedBeanDefinitions
         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), filter, true);

   // 解析ImportResource注解的类
   AnnotationAttributes 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);
         configClass.addImportedResource(resolvedResource, readerClass);
      }
   }

   // Bean注解的处理
   Set<MethodMetadata> beanMethods = retrieveBeanMethodMetadata(sourceClass);
   for (MethodMetadata methodMetadata : beanMethods) {
      configClass.addBeanMethod(new BeanMethod(methodMetadata, configClass));
   }

   // interfaces处理
   processInterfaces(configClass, sourceClass);

   // 判断父类是否是java或spring的内置类，不是继续进行解析
   if (sourceClass.getMetadata().hasSuperClass()) {
      String superclass = sourceClass.getMetadata().getSuperClassName();
      if (superclass != null && !superclass.startsWith("java") &&
            !this.knownSuperclasses.containsKey(superclass)) {
         this.knownSuperclasses.put(superclass, configClass);
         // 返回当前类的父类
         return sourceClass.getSuperClass();
      }
   }

   return null;
}

​ processMemberClasses内部成员类的处理

private void processMemberClasses(ConfigurationClass configClass, SourceClass sourceClass,
      Predicate<String> filter) throws IOException {

   // 成员类
   Collection<SourceClass> memberClasses = sourceClass.getMemberClasses();
   if (!memberClasses.isEmpty()) {
      List<SourceClass> candidates = new ArrayList<>(memberClasses.size());
      for (SourceClass memberClass : memberClasses) {
         if (ConfigurationClassUtils.isConfigurationCandidate(memberClass.getMetadata()) 			&& !memberClass.getMetadata().getClassName().equals(
            configClass.getMetadata().getClassName())) {
            candidates.add(memberClass);
         }
      }
     // 排序
      OrderComparator.sort(candidates);
      for (SourceClass candidate : candidates) {
         if (this.importStack.contains(configClass)) {
            this.problemReporter.error(new CircularImportProblem(configClass, 						this.importStack));
         }
         else {
            this.importStack.push(configClass);
            try {
               // 配置类循环解析
               processConfigurationClass(candidate.asConfigClass(configClass), filter);
            }
            finally {
               this.importStack.pop();
            }
         }
      }
   }
}

​ PropertySource注解的处理类

private void processPropertySource(AnnotationAttributes propertySource) throws IOException 
{
   // 获取扫描的属性名
   String name = propertySource.getString("name");
   if (!StringUtils.hasLength(name)) {
      name = null;
   }
   // 获取扫描的编码方式
   String encoding = propertySource.getString("encoding");
   if (!StringUtils.hasLength(encoding)) {
      encoding = null;
   }
   // 获取扫描的路径
   String[] locations = propertySource.getStringArray("value");
   Assert.isTrue(locations.length > 0, "At least one @PropertySource(value) location is 	required");
   // ignoreResourceNotFound属性
   boolean ignoreResourceNotFound = propertySource.getBoolean("ignoreResourceNotFound");
   Class<? extends PropertySourceFactory> factoryClass= propertySource.getClass("factory");
   PropertySourceFactory factory = (factoryClass == PropertySourceFactory.class ?
         DEFAULT_PROPERTY_SOURCE_FACTORY : BeanUtils.instantiateClass(factoryClass));

   for (String location : locations) {
      try {
         String resolvedLocation = this.environment.resolveRequiredPlaceholders(location);
         Resource resource = this.resourceLoader.getResource(resolvedLocation);
         // 将扫描出来的属性加入到environment中
         addPropertySource(factory.createPropertySource(name, new EncodedResource(resource, 			encoding)));
      }
      catch (IllegalArgumentException | FileNotFoundException | UnknownHostException | 				SocketException ex) {
         if (ignoreResourceNotFound) {
            if (logger.isInfoEnabled()) {
               .... // 日志
            }
         }
         else {
            .... // 异常
         }
      }
   }
}

​ 将属性加入到environment中

private void addPropertySource(PropertySource<?> propertySource) {
   String name = propertySource.getName();
   // 从environment中获取propertySources
   MutablePropertySources propertySources = ((ConfigurableEnvironment) 							this.environment).getPropertySources();
   // 原属性集合中是否包含该属性，根据情况将propertySource加入到环境类中
   if (this.propertySourceNames.contains(name)) {
      
      PropertySource<?> existing = propertySources.get(name);
      if (existing != null) {
         PropertySource<?> newSource = (propertySource instanceof ResourcePropertySource ?
               ((ResourcePropertySource) propertySource).withResourceName() : 						propertySource);
         if (existing instanceof CompositePropertySource) {
            ((CompositePropertySource) existing).addFirstPropertySource(newSource);
         }
         else {
            if (existing instanceof ResourcePropertySource) {
               existing = ((ResourcePropertySource) existing).withResourceName();
            }
            CompositePropertySource composite = new CompositePropertySource(name);
            composite.addPropertySource(newSource);
            composite.addPropertySource(existing);
            propertySources.replace(name, composite);
         }
         return;
      }
   }

   if (this.propertySourceNames.isEmpty()) {
      propertySources.addLast(propertySource);
   }
   else {
      String firstProcessed = this.propertySourceNames.get(this.propertySourceNames.size() 			- 1);
      propertySources.addBefore(firstProcessed, propertySource);
   }
   this.propertySourceNames.add(name);
}

​ 扫描类用于ComponentScans.class, ComponentScan.class注解的扫描，对该注解下配置的文件夹进行扫描，是spring扫描的核心类。

public Set<BeanDefinitionHolder> parse(AnnotationAttributes componentScan, final String declaringClass) {
   ClassPathBeanDefinitionScanner scanner = new 											ClassPathBeanDefinitionScanner(this.registry,
         componentScan.getBoolean("useDefaultFilters"), this.environment, 						this.resourceLoader);
   // 设置
   Class<? extends BeanNameGenerator> generatorClass = 											componentScan.getClass("nameGenerator");
   boolean useInheritedGenerator = (BeanNameGenerator.class == generatorClass);
   scanner.setBeanNameGenerator(useInheritedGenerator ? this.beanNameGenerator :
         BeanUtils.instantiateClass(generatorClass));
   // 设置作用域
   ScopedProxyMode scopedProxyMode = componentScan.getEnum("scopedProxy");
   if (scopedProxyMode != ScopedProxyMode.DEFAULT) {
      scanner.setScopedProxyMode(scopedProxyMode);
   }
   else {
      Class<? extends ScopeMetadataResolver> resolverClass = 									componentScan.getClass("scopeResolver");
      scanner.setScopeMetadataResolver(BeanUtils.instantiateClass(resolverClass));
   }
   // resourcePattern属性
   scanner.setResourcePattern(componentScan.getString("resourcePattern"));
   // includeFilters属性
   for (AnnotationAttributes filter : componentScan.getAnnotationArray("includeFilters")) {
      for (TypeFilter typeFilter : typeFiltersFor(filter)) {
         scanner.addIncludeFilter(typeFilter);
      }
   }
   // excludeFilters属性
   for (AnnotationAttributes filter : componentScan.getAnnotationArray("excludeFilters")) {
      for (TypeFilter typeFilter : typeFiltersFor(filter)) {
         scanner.addExcludeFilter(typeFilter);
      }
   }
   // lazyInit属性
   boolean lazyInit = componentScan.getBoolean("lazyInit");
   if (lazyInit) {
      scanner.getBeanDefinitionDefaults().setLazyInit(true);
   }
   // basePackages属性
   Set<String> basePackages = new LinkedHashSet<>();
   String[] basePackagesArray = componentScan.getStringArray("basePackages");
   for (String pkg : basePackagesArray) {
      String[] tokenized = 																	StringUtils.tokenizeToStringArray(this.environment.resolvePlaceholders(pkg),
            ConfigurableApplicationContext.CONFIG_LOCATION_DELIMITERS);
      Collections.addAll(basePackages, tokenized);
   }
   // basePackageClasses属性
   for (Class<?> clazz : componentScan.getClassArray("basePackageClasses")) {
      basePackages.add(ClassUtils.getPackageName(clazz));
   }
   if (basePackages.isEmpty()) {
      basePackages.add(ClassUtils.getPackageName(declaringClass));
   }
   // ExcludeFilter属性
   scanner.addExcludeFilter(new AbstractTypeHierarchyTraversingFilter(false, false) {
      @Override
      protected boolean matchClassName(String className) {
         return declaringClass.equals(className);
      }
   });
   return scanner.doScan(StringUtils.toStringArray(basePackages));
}

​ doScan根据路径进行类扫描

protected Set<BeanDefinitionHolder> doScan(String... basePackages) {
   Assert.notEmpty(basePackages, "At least one base package must be specified");
   Set<BeanDefinitionHolder> beanDefinitions = new LinkedHashSet<>();
   for (String basePackage : basePackages) {
      // 对需要扫描的路径进行扫描处理，生成BeanDefinition集合
      Set<BeanDefinition> candidates = findCandidateComponents(basePackage);
      for (BeanDefinition candidate : candidates) {
         // 获取作用域Metadata
         ScopeMetadata scopeMetadata = 															this.scopeMetadataResolver.resolveScopeMetadata(candidate);
         candidate.setScope(scopeMetadata.getScopeName());
         String beanName = this.beanNameGenerator.generateBeanName(candidate, 						this.registry);
         if (candidate instanceof AbstractBeanDefinition) {
            postProcessBeanDefinition((AbstractBeanDefinition) candidate, beanName);
         }
         if (candidate instanceof AnnotatedBeanDefinition) {
         // 共通处理
         	AnnotationConfigUtils.processCommonDefinitionAnnotations(
           		(AnnotatedBeanDefinition)candidate);
         }
         if (checkCandidate(beanName, candidate)) {
            BeanDefinitionHolder definitionHolder = new BeanDefinitionHolder(candidate, 			beanName);
           	// 作用域处理
            definitionHolder =
                  AnnotationConfigUtils.applyScopedProxyMode(scopeMetadata, 							definitionHolder, this.registry);
            beanDefinitions.add(definitionHolder);
            // 注册处理
            registerBeanDefinition(definitionHolder, this.registry);
         }
      }
   }
   return beanDefinitions;
}

​ Imports注解的处理类，Import注解导入的配置类存在三种情况，导入的是ImportSelector的实现类、ImportBeanDefinitionRegistrar的实现类和普通的类。

private void processImports(ConfigurationClass configClass, SourceClass currentSourceClass,
      Collection<SourceClass> importCandidates, Predicate<String> exclusionFilter,
      boolean checkForCircularImports) {

   if (importCandidates.isEmpty()) {
      return;
   }

   if (checkForCircularImports && isChainedImportOnStack(configClass)) {
      this.problemReporter.error(new CircularImportProblem(configClass, this.importStack));
   } else {
      this.importStack.push(configClass);
      try {
         for (SourceClass candidate : importCandidates) {
            // ImportSelector实现类的情况
            if (candidate.isAssignable(ImportSelector.class)) {
               Class<?> candidateClass = candidate.loadClass();
               // 初始化ImportSelector导入的类
               ImportSelector selector = 														  ParserStrategyUtils.instantiateClass(candidateClass, 									  ImportSelector.class,this.environment, this.resourceLoader, this.registry);
               Predicate<String> selectorFilter = selector.getExclusionFilter();
               if (selectorFilter != null) {
                  exclusionFilter = exclusionFilter.or(selectorFilter);
               }
               if (selector instanceof DeferredImportSelector) {
                  this.deferredImportSelectorHandler.handle(configClass, 								(DeferredImportSelector) selector);
               }
               else {
                  // 对EnableAutoConfiguration注解的处理，AutoConfigurationImportSelector通					 //	过SpringFactoriesLoader.loadFactoryNames来获取需要注入的类,这里是spring 					// boot自动配置类的注入
                  String[] importClassNames = 															selector.selectImports(currentSourceClass.getMetadata());
                  Collection<SourceClass> importSourceClasses = 											asSourceClasses(importClassNames, exclusionFilter);
                  // 这里存在一个排序，ConfigurationClassParer中grouping.getImports内部存在排				   // 序,AutoConfigurationSorter进行处理AutoConfigureBefore、								 // AutoConfigureAfter注解问题
                  processImports(configClass, currentSourceClass, importSourceClasses, 					exclusionFilter, false);
               }
            }
            // ImportBeanDefinitionRegistrar实现类的情况,主要针对mybatis的集成，通过				   // ImportBeanDefinitionRegistrar对mybatis的注解进行扫描
            else if (candidate.isAssignable(ImportBeanDefinitionRegistrar.class)) {
               Class<?> candidateClass = candidate.loadClass();
               ImportBeanDefinitionRegistrar registrar =
                     ParserStrategyUtils.instantiateClass(candidateClass, 									ImportBeanDefinitionRegistrar.class,
                           this.environment, this.resourceLoader, this.registry);
               configClass.addImportBeanDefinitionRegistrar(registrar, 									currentSourceClass.getMetadata());
            }
            else {
               // 普通配置类情况
               this.importStack.registerImport( currentSourceClass.getMetadata(),
               		candidate.getMetadata().getClassName());
         	  processConfigurationClass(candidate.asConfigClass(configClass), 						   	   exclusionFilter);
       	   }
     	}
 	 } catch (BeanDefinitionStoreException ex) {
       	.... // 异常
 	 } catch (Throwable ex) {
      	 .... // 异常
 	 } finally {
   	 	this.importStack.pop();
 	 }
   }
}

​ loadBeanDefinitions根据注解的不同对扫描器扫描的类进行处理，会对扫描出来的类进行注册。

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

private void loadBeanDefinitionsForConfigurationClass(
    ConfigurationClass configClass, TrackedConditionEvaluator trackedConditionEvaluator) {
   // Conditional注解的具体实现，包含ConditionalOnClass等注解
   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;
   }
   // 针对直接导入的类进行处理
   if (configClass.isImported()) {
      registerBeanDefinitionForImportedConfigurationClass(configClass);
   }
   // 对bean注解注入的beanDefine
   for (BeanMethod beanMethod : configClass.getBeanMethods()) {
      loadBeanDefinitionsForBeanMethod(beanMethod);
   }
   // 针对importResource注入的配置文件进行解析
   loadBeanDefinitionsFromImportedResources(configClass.getImportedResources());
   // 对ImportBeanDefinitionRegistrars注解方式进行处理
   loadBeanDefinitionsFromRegistrars(configClass.getImportBeanDefinitionRegistrars());
}

​ registerBeanDefinitionForImportedConfigurationClass注册导入的配置文件

private void registerBeanDefinitionForImportedConfigurationClass(ConfigurationClass configClass) {
   AnnotationMetadata metadata = configClass.getMetadata();
   AnnotatedGenericBeanDefinition configBeanDef = new 										AnnotatedGenericBeanDefinition(metadata);

   ScopeMetadata scopeMetadata = scopeMetadataResolver.resolveScopeMetadata(configBeanDef);
   configBeanDef.setScope(scopeMetadata.getScopeName());
   // 生成bean名称
   String configBeanName = this.importBeanNameGenerator.generateBeanName(configBeanDef, 		this.registry);
   // 解析共同类，针对通用注解进行解析，入Lazy、Primary、Role等
   AnnotationConfigUtils.processCommonDefinitionAnnotations(configBeanDef, metadata);

   BeanDefinitionHolder definitionHolder = new BeanDefinitionHolder(configBeanDef, 				configBeanName);
   definitionHolder = AnnotationConfigUtils.applyScopedProxyMode(scopeMetadata, 				definitionHolder, this.registry);
   // 注册beanDefinition
   this.registry.registerBeanDefinition(definitionHolder.getBeanName(), 						definitionHolder.getBeanDefinition());
   		configClass.setBeanName(configBeanName);

   if (logger.isTraceEnabled()) {
      .... // 日志
   }
}

​ loadBeanDefinitionsForBeanMethod以Bean注解形式注入的类的处理。

private void loadBeanDefinitionsForBeanMethod(BeanMethod beanMethod) {
   ConfigurationClass configClass = beanMethod.getConfigurationClass();
   MethodMetadata metadata = beanMethod.getMetadata();
   String methodName = metadata.getMethodName();

   // conditional判断是否注入
   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");

   // name属性
   List<String> names = new ArrayList<>(Arrays.asList(bean.getStringArray("name")));
   String beanName = (!names.isEmpty() ? names.remove(0) : methodName);

   // Alias别名
   for (String alias : names) {
      this.registry.registerAlias(beanName, alias);
   }

   // 是否进行方法覆盖，读取时会有具体的覆盖方法处理，主要是针对lookup-method和replaced-method
   if (isOverriddenByExistingDefinition(beanMethod, beanName)) {
      if (beanName.equals(beanMethod.getConfigurationClass().getBeanName())) {
         .... // 异常
      }
      return;
   }

   ConfigurationClassBeanDefinition beanDef = new 											ConfigurationClassBeanDefinition(configClass, metadata, beanName);
   beanDef.setSource(this.sourceExtractor.extractSource(metadata, 								configClass.getResource()));

   if (metadata.isStatic()) {
      // 设置Bean类
      if (configClass.getMetadata() instanceof StandardAnnotationMetadata) {
         beanDef.setBeanClass(((StandardAnnotationMetadata) 									configClass.getMetadata()).getIntrospectedClass());
      }
      else {
         beanDef.setBeanClassName(configClass.getMetadata().getClassName());
      }
      beanDef.setUniqueFactoryMethodName(methodName);
   } else {
      // 设置FactoryBean类
      beanDef.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);
   // 对bean注解的共通处理
   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);

   // 作用域的处理
   ScopedProxyMode 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;
      }
   }

   // 对代理作用域的处理
   BeanDefinition 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, 			  	beanName);
   }

   if (logger.isTraceEnabled()) {
      .... // 日志
   }
   // 注册beanDefinition
   this.registry.registerBeanDefinition(beanName, beanDefToRegister);
}

​ 对BeanDefinition的共同处理，将Lazy、value、Primary、DependsOn、Role和Description注解读取成具体的属性。

static void processCommonDefinitionAnnotations(AnnotatedBeanDefinition abd, AnnotatedTypeMetadata metadata) {
   // Lazy属性获取
   AnnotationAttributes lazy = attributesFor(metadata, Lazy.class);
   if (lazy != null) {
      abd.setLazyInit(lazy.getBoolean("value"));
   }
   else if (abd.getMetadata() != metadata) {
      // lazy属性处理，懒加载
      lazy = attributesFor(abd.getMetadata(), Lazy.class);
      if (lazy != null) {
         abd.setLazyInit(lazy.getBoolean("value"));
      }
   }

   if (metadata.isAnnotated(Primary.class.getName())) {
      // primary属性处理，优先加载项
      abd.setPrimary(true);
   }
   // dependsOn注解处理
   AnnotationAttributes dependsOn = attributesFor(metadata, DependsOn.class);
   if (dependsOn != null) {
      abd.setDependsOn(dependsOn.getStringArray("value"));
   }

   AnnotationAttributes role = attributesFor(metadata, Role.class);
   if (role != null) {
      // Role属性
      abd.setRole(role.getNumber("value").intValue());
   }
   // Desription属性
   AnnotationAttributes description = attributesFor(metadata, Description.class);
   if (description != null) {
      abd.setDescription(description.getString("value"));
   }
}

​ 对ImportResource导入的文件进行读取处理，使用BeanDefinitionReader类进行扫描。

private void loadBeanDefinitionsFromImportedResources(
      Map<String, Class<? extends BeanDefinitionReader>> importedResources) {

   Map<Class<?>, BeanDefinitionReader> readerInstanceCache = new HashMap<>();

   importedResources.forEach((resource, readerClass) -> {
      
      if (BeanDefinitionReader.class == readerClass) {
         if (StringUtils.endsWithIgnoreCase(resource, ".groovy")) {
            // .groovy文件处理
            readerClass = GroovyBeanDefinitionReader.class;
         }
         else {
            // xml后缀文件读取类
            readerClass = XmlBeanDefinitionReader.class;
         }
      }

      BeanDefinitionReader reader = readerInstanceCache.get(readerClass);
      if (reader == null) {
         try {
            // beanDefinition读取类的实例化
            reader = readerClass.getConstructor(BeanDefinitionRegistry.class)
              .newInstance(this.registry);
            // 设置类的属性
            if (reader instanceof AbstractBeanDefinitionReader) {
               AbstractBeanDefinitionReader abdr = ((AbstractBeanDefinitionReader) reader);
               abdr.setResourceLoader(this.resourceLoader);
               abdr.setEnvironment(this.environment);
            }
            readerInstanceCache.put(readerClass, reader);
         }
         catch (Throwable ex) {
            .... // 异常
         }
      }

      // 具体的资源文件读取过程，不进行详细介绍
      reader.loadBeanDefinitions(resource);
   });
}

​ 对ImportBeanDefinitionRegistrar的处理是通过自定义的类进行处理，通过实现registerBeanDefinitions方法来对具体的路径进行扫描。除了集成Mybatis外创建代理也是使用这种模式进行创建。

private void loadBeanDefinitionsFromRegistrars(Map<ImportBeanDefinitionRegistrar, 			AnnotationMetadata> registrars) {
   	registrars.forEach((registrar, metadata) ->registrar.registerBeanDefinitions(
      	metadata, this.registry,this.importBeanNameGenerator));
}

public void registerBeanDefinitions(AnnotationMetadata importingClassMetadata, 				BeanDefinitionRegistry registry) {
	// MapperScan注解的获取
    AnnotationAttributes annoAttrs = 														AnnotationAttributes.fromMap(importingClassMetadata.getAnnotationAttributes(
      	MapperScan.class.getName()));
    ClassPathMapperScanner scanner = new ClassPathMapperScanner(registry);

    // resourceLoader设置
    if (resourceLoader != null) {
      scanner.setResourceLoader(resourceLoader);
    }
	// 设置读取的注解类型
    Class<? extends Annotation> annotationClass = annoAttrs.getClass("annotationClass");
    if (!Annotation.class.equals(annotationClass)) {
      scanner.setAnnotationClass(annotationClass);
    }
	
    Class<?> markerInterface = annoAttrs.getClass("markerInterface");
    if (!Class.class.equals(markerInterface)) {
      scanner.setMarkerInterface(markerInterface);
    }
	// bean名称生成类
    Class<? extends BeanNameGenerator> generatorClass = 										annoAttrs.getClass("nameGenerator");
    if (!BeanNameGenerator.class.equals(generatorClass)) {
      scanner.setBeanNameGenerator(BeanUtils.instantiateClass(generatorClass));
    }
	// factoryBean
    Class<? extends MapperFactoryBean> mapperFactoryBeanClass = 								annoAttrs.getClass("factoryBean");
    if (!MapperFactoryBean.class.equals(mapperFactoryBeanClass)) {
      scanner.setMapperFactoryBean(BeanUtils.instantiateClass(mapperFactoryBeanClass));
    }
    // sqlSessionTemplateRef、sqlSessionFactoryRef
    scanner.setSqlSessionTemplateBeanName(annoAttrs.getString("sqlSessionTemplateRef"));
    scanner.setSqlSessionFactoryBeanName(annoAttrs.getString("sqlSessionFactoryRef"));
	// 扫描的包
    List<String> basePackages = new ArrayList<String>();
    for (String pkg : annoAttrs.getStringArray("value")) {
      if (StringUtils.hasText(pkg)) {
        basePackages.add(pkg);
      }
    }
    // 扫描的包
    for (String pkg : annoAttrs.getStringArray("basePackages")) {
      if (StringUtils.hasText(pkg)) {
        basePackages.add(pkg);
      }
    }
    // 扫描的包
    for (Class<?> clazz : annoAttrs.getClassArray("basePackageClasses")) {
      basePackages.add(ClassUtils.getPackageName(clazz));
    }
    scanner.registerFilters();
  	// mybatis的注解扫描
    scanner.doScan(StringUtils.toStringArray(basePackages));
  }

​ postProcessBeanFactory解析类，主要用于创建configuration的代理。

public void postProcessBeanFactory(ConfigurableListableBeanFactory beanFactory) {
   int factoryId = System.identityHashCode(beanFactory);
   if (this.factoriesPostProcessed.contains(factoryId)) {
       .... // 异常
   }
   this.factoriesPostProcessed.add(factoryId);
   if (!this.registriesPostProcessed.contains(factoryId)) {
      // 扫描解析类
      processConfigBeanDefinitions((BeanDefinitionRegistry) beanFactory);
   }
   // 对Configurtion进行代理
   enhanceConfigurationClasses(beanFactory);
   // 添加ImportAwareBeanPostProcessor
   beanFactory.addBeanPostProcessor(new ImportAwareBeanPostProcessor(beanFactory));
}
// 对Configurtion进行代理
public void enhanceConfigurationClasses(ConfigurableListableBeanFactory beanFactory) {
	Map<String, AbstractBeanDefinition> configBeanDefs = new LinkedHashMap<>();
	for (String beanName : beanFactory.getBeanDefinitionNames()) {
		BeanDefinition beanDef = beanFactory.getBeanDefinition(beanName);
		Object configClassAttr = beanDef.getAttribute(
          	ConfigurationClassUtils.CONFIGURATION_CLASS_ATTRIBUTE);
		MethodMetadata methodMetadata = null;
		if (beanDef instanceof AnnotatedBeanDefinition) {
			methodMetadata = ((AnnotatedBeanDefinition) 											beanDef).getFactoryMethodMetadata();
		}
		if ((configClassAttr != null || methodMetadata != null) && beanDef instanceof 				AbstractBeanDefinition) {
			//  
			AbstractBeanDefinition abd = (AbstractBeanDefinition) beanDef;
			if (!abd.hasBeanClass()) {
				try {
					abd.resolveBeanClass(this.beanClassLoader);
				} catch (Throwable ex) {
				    .... // 异常
					}
				}
			}
		if (ConfigurationClassUtils.CONFIGURATION_CLASS_FULL.equals(configClassAttr)) {
			if (!(beanDef instanceof AbstractBeanDefinition)) {
				.... // 异常
			}else if(logger.isInfoEnabled() && beanFactory.containsSingleton(beanName)) {
				.... // 异常
			}
				configBeanDefs.put(beanName, (AbstractBeanDefinition) beanDef);
			}
		}
		if (configBeanDefs.isEmpty()) {
			// nothing to enhance -> return immediately
			return;
		}

		ConfigurationClassEnhancer enhancer = new ConfigurationClassEnhancer();
		for(Map.Entry<String, AbstractBeanDefinition> entry : configBeanDefs.entrySet()){
			AbstractBeanDefinition beanDef = entry.getValue();
			// 添加target属性
			beanDef.setAttribute(AutoProxyUtils.PRESERVE_TARGET_CLASS_ATTRIBUTE, 						Boolean.TRUE);
			// BeanClass
			Class<?> configClass = beanDef.getBeanClass();
             // 获取类，代理或本类
			Class<?> enhancedClass = enhancer.enhance(configClass, this.beanClassLoader);
			if (configClass != enhancedClass) {
				if (logger.isTraceEnabled()) {
					.... // 日志
				}
				beanDef.setBeanClass(enhancedClass);
			}
		}
	}

​ 对configuretion注解的Bean定义添加代理处理

public void enhanceConfigurationClasses(ConfigurableListableBeanFactory beanFactory) {
	Map<String, AbstractBeanDefinition> configBeanDefs = new LinkedHashMap<>();
	for (String beanName : beanFactory.getBeanDefinitionNames()) {
		BeanDefinition beanDef = beanFactory.getBeanDefinition(beanName);
		Object configClassAttr = 																beanDef.getAttribute(ConfigurationClassUtils.CONFIGURATION_CLASS_ATTRIBUTE);
			MethodMetadata methodMetadata = null;
		if (beanDef instanceof AnnotatedBeanDefinition) {
			methodMetadata = 																		((AnnotatedBeanDefinition)beanDef).getFactoryMethodMetadata();
		}
		if ((configClassAttr != null || methodMetadata != null) && beanDef instanceof 				AbstractBeanDefinition) {
				// 
				AbstractBeanDefinition abd = (AbstractBeanDefinition) beanDef;
				if (!abd.hasBeanClass()) {
					try {
						abd.resolveBeanClass(this.beanClassLoader);
					}
					catch (Throwable ex) {
						.... // 异常
					}
				}
			}
		if (ConfigurationClassUtils.CONFIGURATION_CLASS_FULL.equals(configClassAttr)) {
			if (!(beanDef instanceof AbstractBeanDefinition)) {
				.... // 异常
			}else if(logger.isInfoEnabled() && beanFactory.containsSingleton(beanName)) {
				.... // 日志
			}
				configBeanDefs.put(beanName, (AbstractBeanDefinition) beanDef);
			}
		}
		if (configBeanDefs.isEmpty()) {
			//  
			return;
		}

    // 创建ConfigurationClassEnhancer对象
	ConfigurationClassEnhancer enhancer = new ConfigurationClassEnhancer();
	for (Map.Entry<String, AbstractBeanDefinition> entry : configBeanDefs.entrySet()) {
			AbstractBeanDefinition beanDef = entry.getValue();
			beanDef.setAttribute(AutoProxyUtils.PRESERVE_TARGET_CLASS_ATTRIBUTE, 							Boolean.TRUE);
			// 配置类
			Class<?> configClass = beanDef.getBeanClass();
			Class<?> enhancedClass = enhancer.enhance(configClass, this.beanClassLoader);
			if (configClass != enhancedClass) {
				if (logger.isTraceEnabled()) {
					.... // 日志
				}
				beanDef.setBeanClass(enhancedClass);
			}
		}
	}

// 判断是否需要创建代理类，根据情况返回
public Class<?> enhance(Class<?> configClass, @Nullable ClassLoader classLoader) {
		if (EnhancedConfiguration.class.isAssignableFrom(configClass)) {
			if (logger.isDebugEnabled()) {
				.... // 日志
			}
			return configClass;
		}
		Class<?> enhancedClass = createClass(newEnhancer(configClass, classLoader));
		if (logger.isTraceEnabled()) {
			.... // 日志
		}
		return enhancedClass;
	}

// 新建Enhancer对象
private Enhancer newEnhancer(Class<?> configSuperClass, @Nullable ClassLoader classLoader) {
		Enhancer enhancer = new Enhancer();
		enhancer.setSuperclass(configSuperClass);
		enhancer.setInterfaces(new Class<?>[] {EnhancedConfiguration.class});
		enhancer.setUseFactory(false);
		enhancer.setNamingPolicy(SpringNamingPolicy.INSTANCE);
		enhancer.setStrategy(new BeanFactoryAwareGeneratorStrategy(classLoader));
		enhancer.setCallbackFilter(CALLBACK_FILTER);
		enhancer.setCallbackTypes(CALLBACK_FILTER.getCallbackTypes());
		return enhancer;
}

​ registerBeanPostProcessors注册后置处理器

public static void registerBeanPostProcessors(ConfigurableListableBeanFactory beanFactory, 		AbstractApplicationContext applicationContext) {
	String[] postProcessorNames = beanFactory.getBeanNamesForType(BeanPostProcessor.class, 			true, false);

   // 计算后置处理器数量
   int beanProcessorTargetCount = beanFactory.getBeanPostProcessorCount() + 1 + 				postProcessorNames.length;
   // 添加后置处理器
   beanFactory.addBeanPostProcessor(new BeanPostProcessorChecker(beanFactory, 					beanProcessorTargetCount));

   
   List<BeanPostProcessor> priorityOrderedPostProcessors = new ArrayList<>();
   List<BeanPostProcessor> internalPostProcessors = new ArrayList<>();
   List<String> orderedPostProcessorNames = new ArrayList<>();
   List<String> nonOrderedPostProcessorNames = new ArrayList<>();
   // 获取含有PriorityOrdered注解的后置处理器
   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);
         }
      }
      else if (beanFactory.isTypeMatch(ppName, Ordered.class)) {
         // 加入后置处理器
         orderedPostProcessorNames.add(ppName);
      }
      else {
         nonOrderedPostProcessorNames.add(ppName);
      }
   }

   // 对实现PriorityOrdered接口的后置处理器排序然后注册
   sortPostProcessors(priorityOrderedPostProcessors, beanFactory);
   registerBeanPostProcessors(beanFactory, priorityOrderedPostProcessors);
   
   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);
      }
   }
   // 对实现Ordered注解的后置处理器排序后注册
   sortPostProcessors(orderedPostProcessors, beanFactory);
   registerBeanPostProcessors(beanFactory, orderedPostProcessors);

   // 无优先级后置处理器处理
   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);

   // 对无优先级后置处理器排序并注入
   sortPostProcessors(internalPostProcessors, beanFactory);
   registerBeanPostProcessors(beanFactory, internalPostProcessors);

   // 注册的ApplicationListenerDetector
   beanFactory.addBeanPostProcessor(new ApplicationListenerDetector(applicationContext));
}

​ addBeanPostProcessor添加后置处理器

public void addBeanPostProcessor(BeanPostProcessor beanPostProcessor) {
   Assert.notNull(beanPostProcessor, "BeanPostProcessor must not be null");
   // 移除要添加的类
   this.beanPostProcessors.remove(beanPostProcessor);
   // 将hasInstantiationAwareBeanPostProcessors置为true
   if (beanPostProcessor instanceof InstantiationAwareBeanPostProcessor) {
      this.hasInstantiationAwareBeanPostProcessors = true;
   }
  	// 将hasDestructionAwareBeanPostProcessors置为true
   if (beanPostProcessor instanceof DestructionAwareBeanPostProcessor) {
      this.hasDestructionAwareBeanPostProcessors = true;
   }
   // 加入后置处理器
   this.beanPostProcessors.add(beanPostProcessor);
}

​ initMessageSource初始化MessageSource类，MessageSource是处理国际化问题的类。仅仅是注入实体类并未进行处理，会在第一次使用时去对应的目录下找到配置文件，然后存入具体的类中，以后再获取直接根据key直接去找对应的值即可。

 protected void initMessageSource() {
   // 获取Bean工厂
   ConfigurableListableBeanFactory beanFactory = getBeanFactory();
   // 查看是否包含MessageSource类
   if (beanFactory.containsLocalBean(MESSAGE_SOURCE_BEAN_NAME)) {
 		// 将messageSource赋值
  		this.messageSource = beanFactory.getBean(MESSAGE_SOURCE_BEAN_NAME, 							MessageSource.class);
  		// 判断是否实现了HierarchicalMessageSource，且parent属性为空
  		if (this.parent != null && this.messageSource instanceof 									HierarchicalMessageSource) {
     		HierarchicalMessageSource hms = (HierarchicalMessageSource) 								this.messageSource;
     		if (hms.getParentMessageSource() == null) {
        		// 设置父MessageSource
        		hms.setParentMessageSource(getInternalParentMessageSource());
     		}
  		}
  		if (logger.isTraceEnabled()) {
     	.... // 日志
  		}
	}
   else {

  		// 生成MessageSource
  		DelegatingMessageSource dms = new DelegatingMessageSource();
  		dms.setParentMessageSource(getInternalParentMessageSource());
  		this.messageSource = dms;
  		// 注册messageSource
  		beanFactory.registerSingleton(MESSAGE_SOURCE_BEAN_NAME, this.messageSource);
  		if (logger.isTraceEnabled()) {
    		 .... // 日志
  		}
    }
}

initApplicationEventMulticaster初始化事件监听多路广播器。

protected void initApplicationEventMulticaster() {
	ConfigurableListableBeanFactory beanFactory = getBeanFactory();

   	// 判断是否存在事件监听多路广播器
	if (beanFactory.containsLocalBean(APPLICATION_EVENT_MULTICASTER_BEAN_NAME)) {
		// 直接初始化广播器
  		this.applicationEventMulticaster =
        	beanFactory.getBean(APPLICATION_EVENT_MULTICASTER_BEAN_NAME, 							ApplicationEventMulticaster.class);
 		 if (logger.isTraceEnabled()) {
     		.... // 日志
  		 }
   	}
	else {

  		// 新生成一个广播器
 		 this.applicationEventMulticaster = new 												SimpleApplicationEventMulticaster(beanFactory);
  		beanFactory.registerSingleton(APPLICATION_EVENT_MULTICASTER_BEAN_NAME, 				  		this.applicationEventMulticaster);
  		if (logger.isTraceEnabled()) {
     		.... // 日志
  		}
    }

}
        

​ registerListeners注册监听类。

protected void registerListeners() {
   // spring boot自动加载的监听
   for (ApplicationListener<?> listener : getApplicationListeners()) {
        getApplicationEventMulticaster().addApplicationListener(listener);
   }
   // 获取ApplicationListener实现类，自定义监听类的加入入口。实现ApplicationListener接口的类
   String[] listenerBeanNames = getBeanNamesForType(ApplicationListener.class, true,   								false);
   // 加入到广播器，spring boot环境初始化篇中有介绍
   for (String listenerBeanName : listenerBeanNames) {
        getApplicationEventMulticaster().addApplicationListenerBean(listenerBeanName);
   }

   // 早期监听事件加入广播器
   Set<ApplicationEvent> earlyEventsToProcess = this.earlyApplicationEvents;
   this.earlyApplicationEvents = null;
   if (!CollectionUtils.isEmpty(earlyEventsToProcess)) {
   		for (ApplicationEvent earlyEvent : earlyEventsToProcess) {
     		getApplicationEventMulticaster().multicastEvent(earlyEvent);
  		}
 	}
}

// 自定监听类加入入口
public void addApplicationListenerBean(String listenerBeanName) {
	synchronized (this.retrievalMutex) {
		this.defaultRetriever.applicationListenerBeans.add(listenerBeanName);
		this.retrieverCache.clear();
	}
}

三、总结

​ spring boot扫描注册Bean定义，是从AbstractApplicationContext的invokeBeanFactoryPostProcessors方法开始，通过ConfigurationClassPostProcessor的parse方法进行解析，解析注解分为Component、PropertySources、ComponentScans、ComponentScan、Import、ImportResource、Bean进行处理，第一次会是ComponentScans或ComponentScan标签分支，通过ConditionEvaluator的shouldSkip方法进行判断是否扫描这里是处理Conditional相关注解问题包含ConditionalOnClass等标签。然后通过ASM（字节码解析框架）对指定目录下字节码文件进行扫描，扫描出的注解再次进入ConfigurationClassPostProcessor的parse进行判断注解类型，然后进行不同的处理。Component注解会获取其内部类再次进行解析并且将其加入到配置类集合中、PropertySources注解会将扫描的结果加入到Environment类中、Import分为三种情况注解属性为DeferredImportSelector（自动配置类处理EnableAutoConfiguration注解，其中会有优先级排序，解决AutoConfigureAfter、AutoConfigureBefore等的优先级问题），ImportBeanDefinitionRegistrar（将该类作为变量加入配置类供注册时使用）和其他作为配置类再次扫描ImportResource会将其加入到importedResources属性供注册使用Bean直接加入到beanMethods，之后进行注册loadBeanDefinitions，其中importedResources通过ImportResource使用BeanDefinitionReader进行读取Bean定义，Bean注解直接根据属性获取Bean定义，ImportBeanDefinitionRegistrar通过具体实现获取Bean定义，Import直接导入的通过AnnotationConfigUtils调用工具类Bean定义，最终都通过DefaultListableBeanFactory注册到BeanDefinition集合中，如下为简单的时序图。